// Ryzom - MMORPG Framework <http://dev.ryzom.com/projects/ryzom/>
// Copyright (C) 2010  Winch Gate Property Limited
//
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU Affero General Public License as
// published by the Free Software Foundation, either version 3 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 Affero General Public License for more details.
//
// You should have received a copy of the GNU Affero General Public License
// along with this program.  If not, see <http://www.gnu.org/licenses/>.



#include "stdpch.h"

#include "nel/misc/command.h"
#include "nel/misc/variable.h"
#include "nel/misc/config_file.h"
#include "nel/net/service.h"
#include "nel/ligo/primitive_utils.h"

#include "game_share/time_weather_season/time_and_season.h"

#include "zone_manager.h"
#include "mission_manager/mission_manager.h"
#include "primitives_parser.h"
#include "player_manager/player_manager.h"
#include "player_manager/player.h"
#include "player_manager/character.h"
#include "creature_manager/creature_manager.h"
#include "deposit.h"
#include "egs_globals.h"
#include "phrase_manager/phrase_utilities_functions.h"
#include "player_manager/character_respawn_points.h"
#include "stables/stable.h"
#include "chat_groups_ids.h"
#include "pvp_manager/pvp_manager.h"
#include "pvp_manager/pvp_manager_2.h"
#include "pvp_manager/pvp_safe_zone.h"

//#include "backward_compatibility/spawn_zones_back_compat.h"
#include "backward_compatibility/places_back_compat.h"

#include "pvp_manager/pvp.h"
#include "pvp_manager/pvp_faction_reward_manager/pvp_faction_reward_manager.h"

#include "outpost_manager/outpost_manager.h"
#include "modules/shard_unifier_client.h"

using namespace std;
using namespace NLMISC;
using namespace NLLIGO;
using namespace NLNET;

// The ecotype zones
CEcotypeZones CZoneManager::_EcotypeZones;
/*
const std::string CContinent::ContNames [] = 
{
	"fyros",
	"tryker"
	"zorai",
	"matis",
};
*/
/*
arg0: is the zone name id

arg1:
if zone is not pvp
	arg1 is interpreted as a boolean (0 - inactive, 1 - active)
if zone is a pvp zone
	arg1 is interpreted as 
		0 - inactive
		1 - active with faction point rewards
		2 - active without faction point rewards
*/
void cbSetZoneState( NLNET::CMessage& msgin, const std::string &serviceName, NLNET::TServiceId serviceId )
{
	string sZoneName;
	uint32 nState;
	
	msgin.serial(sZoneName);
	msgin.serial(nState);
	
	CZoneManager *pZM = &CZoneManager::getInstance();

	// get the places
	CPlace *place = pZM->getPlaceFromName(sZoneName);
	if (place != NULL)
		if (place->isGooPath())
			place->setGooActive(nState != 0);



	// get the deposit zone (linear search)
	const vector<CDeposit*> &rDeps = pZM->getDeposits();
	for (uint32 i = 0; i < rDeps.size(); ++i)
	{
		CDeposit *pd = rDeps[i];
		if (pd->getName() == sZoneName)
		{
			pd->enable(nState!=0);
			return;
		}
	}

	// get the pvp zone
	CPVPManager *pPVPM = CPVPManager::getInstance();
	IPVPZone *pPVPZ = pPVPM->getPVPZone(sZoneName);
	if (pPVPZ != NULL)
	{
		pPVPZ->setActive(nState!=0);
		
		CPVPVersusZone *pPVPVZ = dynamic_cast<CPVPVersusZone*>(pPVPZ);
		if (pPVPVZ != NULL)
			pPVPVZ->giveFactionPoints(nState == 1);

		return;
	}

	// TODO : treat other zones !
}


//-----------------------------------------------
// CGooPath build
//-----------------------------------------------
/*bool CGooPath::build(const NLLIGO::CPrimPath * path,uint16 id )
{
	_Id = id;
	*( (NLLIGO::CPrimPath*)this ) = *path;
	
	if ( !zone->getPropertyByName("name",_Name) )
	{
		nlwarning("<CGooPath build> : no name in goo place %u", id);
		return false;
	}
	
	if ( VPoints.empty() )
	{
		nlwarning("<CGooPath build> :no points in goo place %u/%s", id, _Name.c_str());
		return false;
	}
	// get the bounding box
	float minX = VPoints[0].x;
	float minY = VPoints[0].y;
	float maxX = VPoints[0].x;
	float maxY = VPoints[0].y;
	for ( uint i = 1; i < VPoints.size(); i++)
	{
		if ( VPoints[i].x < minX )minX = VPoints[i].x;
		if ( VPoints[i].y < minY )minY = VPoints[i].y;
		if ( VPoints[i].x > maxX )maxX = VPoints[i].x;
		if ( VPoints[i].y > maxY )maxY = VPoints[i].y;
	}
	// get the center of the Box
	_CenterX = sint32 ( ( minX + maxX ) *1000.0f / 2.0f );
	_CenterY = sint32 ( ( minY + maxY ) *1000.0f / 2.0f );
	return true;
}// CGooPath build
*/

//-----------------------------------------------
// Tp Dest zone build
//-----------------------------------------------
bool CTpSpawnZone::build(const NLLIGO::CPrimPoint * point)
{
	*( (NLLIGO::CPrimPoint*)this ) = *point;
	_Continent = CONTINENT::UNKNOWN;
	string value;
	if ( !point->getPropertyByName("name",_Name) )
	{
		nlwarning("<CTpSpawnZone build> : no name in CTpSpawnZone" );
		return false;
	}
	if ( !point->getPropertyByName("radius",value) )
	{
		nlwarning("<CTpSpawnZone build> : no radius in CTpSpawnZone '%s'",_Name.c_str() );
		return false;
	}

	// get radius in mm
	_Radius = uint16( atof( value.c_str() ) * 1000.0f );
	// get the z value if necessary
	if ( !point->getPropertyByName("use_z", value) )
	{
		nlwarning("<CTpSpawnZone build> : no use_z in CTpSpawnZone '%s'",_Name.c_str() );
		return false;
	}

	if ( value == "true" )
	{
		if ( !point->getPropertyByName("z", value) )
		{
			nlwarning("<CTpSpawnZone build> : no z in CTpSpawnZone '%s'",_Name.c_str() );
			return false;
		}
		NLMISC::fromString(value, Point.z);
		Point.z = float( sint32 (1000.0f* Point.z) );
	}
	else
		Point.z = 0.0f;
	


	// convert coords in mm
	Point.x = float( sint32 (1000.0f* Point.x) );
	Point.y = float( sint32 (1000.0f* Point.y) );


	if ( !point->getPropertyByName("type", value)  )
	{
		nlwarning("<CTpSpawnZone build> : no type in CTpSpawnZone '%s'",_Name.c_str() );
		return false;
	}
	_Type = RESPAWN_POINT::toRespawnPointType( value );
	if ( _Type == RESPAWN_POINT::UNKNOWN )
	{
		nlwarning("<CTpSpawnZone build> : invalid type '%s' in CTpSpawnZone '%s'",value.c_str(), _Name.c_str() );
		return false;
	}
	return true;
}

//-----------------------------------------------
// CPlace build
//-----------------------------------------------
bool CPlace::build(const NLLIGO::CPrimPath * path, uint16 id)
{
	_Id = id;
	if (!path->VPoints.empty())
		*( (NLLIGO::CPrimZone*)this ) = *(NLLIGO::CPrimZone*) path;
	
	if ( !path->getPropertyByName("name",_Name) )
	{
		nlwarning("<CPlace build> : no name for GooPath %u", id);
		return false;
	}

	if ( VPoints.empty() )
	{
		nlwarning("<CPlace build> :no points in GooPath %u/%s", id, _Name.c_str());
		return false;
	}

	string val;
	if (path->getPropertyByName("main place", val))
		_MainPlace = val == "true";
	else
		_MainPlace = false;

	nlverify (CPrimitivesParser::getAlias(path, _Alias));
//	_Alias = NLMISC::fromString( val.c_str() );
	nlassert( _Alias != CAIAliasTranslator::Invalid );

	// get the bounding box
	float minX = VPoints[0].x;
	float minY = VPoints[0].y;
	float maxX = VPoints[0].x;
	float maxY = VPoints[0].y;
	for ( uint i = 1; i < VPoints.size(); i++)
	{
		if ( VPoints[i].x < minX )minX = VPoints[i].x;
		if ( VPoints[i].y < minY )minY = VPoints[i].y;
		if ( VPoints[i].x > maxX )maxX = VPoints[i].x;
		if ( VPoints[i].y > maxY )maxY = VPoints[i].y;
	}
	// get the center of the Box
	_CenterX = sint32 ( ( minX + maxX ) *1000.0f / 2.0f );
	_CenterY = sint32 ( ( minY + maxY ) *1000.0f / 2.0f );
	_GooPath = true;
	_GooActive = true;
	_Reported = false;

	return true;
}


//-----------------------------------------------
// CPlace build
//-----------------------------------------------
bool CPlace::build(const NLLIGO::CPrimZone * zone,uint16 id, bool reportAutorised )
{
	_Id = id;
	if (!zone->VPoints.empty())
		*( (NLLIGO::CPrimZone*)this ) = *zone;

	if ( !zone->getPropertyByName("name",_Name) )
	{
		nlwarning("<CPlace build> : no name in place %u", id);
		return false;
	}

	string val;
	if (zone->getPropertyByName("reported", val))
		_Reported = val == "true";
	else
		_Reported = true & reportAutorised;

	if (zone->getPropertyByName("main place", val))
		_MainPlace = val == "true";
	else
		_MainPlace = true;

	if (!CPrimitivesParser::getAlias(zone, _Alias))
	{
		nlwarning("Fatal Error, no alias in primitive '%s'",
			buildPrimPath(zone).c_str());
		nlstop;
	}
//	_Alias = NLMISC::fromString( val.c_str() );
	nlassert( _Alias != CAIAliasTranslator::Invalid );

	 
	
	if ( VPoints.empty() )
	{
		nlwarning("<CPlace build> :no points in place %u/%s", id, _Name.c_str());
		return false;
	}
	// get the bounding box
	float minX = VPoints[0].x;
	float minY = VPoints[0].y;
	float maxX = VPoints[0].x;
	float maxY = VPoints[0].y;
	for ( uint i = 1; i < VPoints.size(); i++)
	{
		if ( VPoints[i].x < minX )minX = VPoints[i].x;
		if ( VPoints[i].y < minY )minY = VPoints[i].y;
		if ( VPoints[i].x > maxX )maxX = VPoints[i].x;
		if ( VPoints[i].y > maxY )maxY = VPoints[i].y;
	}
	// get the center of the Box
	_CenterX = sint32 ( ( minX + maxX ) *1000.0f / 2.0f );
	_CenterY = sint32 ( ( minY + maxY ) *1000.0f / 2.0f );
	_GooPath = false;
	_GooActive = false;

	// get place_type of re-spawn point
	PLACE_TYPE::TPlaceType placeType;
	if( zone->getPropertyByName("place_type", val) )
	{
		placeType = PLACE_TYPE::fromString(val);
		if( placeType == PLACE_TYPE::Undefined )
			placeType = PLACE_TYPE::Place;
	}
	else
		placeType = PLACE_TYPE::Place;

	// get children respawn points
	bool ret = true;
	for (uint i=0; i< getNumChildren();++i)	
	{
		const IPrimitive *child;
		if ( getChild(child,i) && child )
		{
			child->getPropertyByName("name",val);
			uint16 idx = CZoneManager::getInstance().getTpSpawnZoneIdByName(val);
			if ( idx != InvalidSpawnZoneId )
			{
				const CTpSpawnZone * spawn = CZoneManager::getInstance().getTpSpawnZone( idx );
				if ( spawn == NULL )
				{
					nlwarning( "Invalid spawn zone '%s' in place '%s' : bad index %u",val.c_str(), _Name.c_str(), idx );
					ret = false;
				}
				// if the respawn point is validated when user enters the place, add it to the place.
				// we dont add special respawn points ( outposts,... ) because they are validated separatly from the place where they are
				else if ( spawn->getType() == RESPAWN_POINT::KAMI ||
					spawn->getType() == RESPAWN_POINT::KARAVAN ||
					spawn->getType() == RESPAWN_POINT::NEWBIELAND ||
					spawn->getType() == RESPAWN_POINT::RESPAWNABLE )
				{
					(const_cast<CTpSpawnZone *>(spawn))->setPlaceType(placeType);
					_RespawnPoints.push_back( idx );
				}
			}
		}
	}
	return ret;
}// CPlace build

//-----------------------------------------------
// CRegion build
//-----------------------------------------------
bool CRegion::build(const NLLIGO::CPrimZone * zone,uint16 id)
{
	if ( CPlace::build(zone,id) )
	{
		string value;
		if ( !zone->getPropertyByName("newbie_region",value) )
		{
			nlwarning("<CRegion build> : failed : no newbie_region property in primitive");
			_NewbieRegion = false;
		}
		else
		{
			_NewbieRegion = (!nlstricmp( value,"true"))?true:false;
		}
		return true;
	}
	else
	{
		nlwarning("<CRegion build> : failed in place build");
		return false;
	}
}// CRegion build

//-----------------------------------------------
// CRegion dtor
//-----------------------------------------------
CRegion::~CRegion()
{
	
}// CRegion dtor

//-----------------------------------------------
// CRegion registerChatGroup
//-----------------------------------------------
void CRegion::registerChatGroup()
{
	TGroupId idGroup = CHAT_GROUPS_IDS::getRegionChatGroupId(_Id);
	CMessage msgout("ADD_GROUP");
	msgout.serial( idGroup );
	CChatGroup::TGroupType type = CChatGroup::region;
	msgout.serialEnum( type );
	sendMessageViaMirror( "IOS", msgout );
	
	// add online members ( if IOS crashed... )
	set< CEntityId >::iterator it = _Players.begin();
	for (; it != _Players.end(); ++it )
	{
		TDataSetRow row = TheDataset.getDataSetRow( (*it) );
		// if we can get the user from this row, the user is ingame
		CCharacter* user = PlayerManager.getChar( row );
		if ( user )
		{
			CMessage msgout("ADD_TO_GROUP");
			msgout.serial( idGroup );
			msgout.serial( const_cast<NLMISC::CEntityId &>(user->getId()) );
			sendMessageViaMirror( "IOS", msgout );
		}
	}
}

//-----------------------------------------------
// CRegion addPlayer
//-----------------------------------------------
void CRegion::addPlayer( const NLMISC::CEntityId & id )
{
	_Players.insert(id);
	TGroupId idGroup = CHAT_GROUPS_IDS::getRegionChatGroupId(_Id);
	CMessage msgout("ADD_TO_GROUP");
	msgout.serial( idGroup );
	msgout.serial( const_cast<NLMISC::CEntityId &>(id) );
	sendMessageViaMirror( "IOS", msgout );
}

//-----------------------------------------------
// CRegion removePlayer
//-----------------------------------------------
void CRegion::removePlayer( const NLMISC::CEntityId & id )
{
	_Players.erase(id);
	TGroupId idGroup = CHAT_GROUPS_IDS::getRegionChatGroupId(_Id);
	CMessage msgout("REMOVE_FROM_GROUP");
	msgout.serial( idGroup );
	msgout.serial( const_cast<NLMISC::CEntityId &>(id) );
	sendMessageViaMirror( "IOS", msgout );
}

//-----------------------------------------------
// CContinent build
//-----------------------------------------------
bool CContinent::build(const NLLIGO::CPrimZone * zone)
{
	string value;
	if ( zone->getPropertyByName("id",value) )
	{
		_Id = CONTINENT::toContinent( value );
		if ( _Id != CONTINENT::UNKNOWN )
		{
			return CPlace::build( zone,_Id );
		}
		else
			nlwarning("<CContinent build> : invalid continent id '%s'",value.c_str());
	}
	else
		nlwarning("<CContinent build> : no id in a continent");
	return false;
}// CContinent build

//-----------------------------------------------
// CContinent dtor
//-----------------------------------------------
CContinent::~CContinent()
{
	
}// CContinent dtor


//-----------------------------------------------
// CZoneManager init
//-----------------------------------------------
void CZoneManager::init()
{
	RandomGenerator.srand( CTickEventHandler::getGameCycle() );
	initInstance();
}// CZoneManager init

//-----------------------------------------------
// CZoneManager release
//-----------------------------------------------
void CZoneManager::release()
{
	for (uint i = 0; i < _Deposits.size(); i++ )
		delete _Deposits[i];
	for ( uint i = 0; i < _Places.size(); i++ )
		delete _Places[i];
	clearEcotypes();
}// CZoneManager release

//-----------------------------------------------
// CZoneManager initInstance
//-----------------------------------------------
void CZoneManager::initInstance()
{
	_NextDepositIndexUpdated = 0;
	_SpreadUpdateLoopBeginTick = CTickEventHandler::getGameCycle();
	
	// get the loaded primitives
	const CPrimitivesParser::TPrimitivesList & primsList = CPrimitivesParser::getInstance().getPrimitives();	

	_PlacesByAlias.clear();
	// parse the zones
	nlinfo("CZoneManager : parsing the zones");
	CPrimitivesParser::TPrimitivesList::const_iterator first, last;
	
	for (first = primsList.begin(), last = primsList.end(); first != last; ++first)
	{
		if (! parseContinents(first->Primitive.RootNode ) )
		{
			nlwarning("<CZoneManager constructor> Error while building the continents");
		}
	}

	for (first = primsList.begin(), last = primsList.end(); first != last; ++first)
	{
		if (! parseRegions(first->Primitive.RootNode ) )
		{
			nlwarning("<CZoneManager constructor> Error while building the regions");
		}
	}

	for (first = primsList.begin(), last = primsList.end(); first != last; ++first)
	{
		if (! parseTpSpawnZones(first->Primitive.RootNode ) )
		{
			nlwarning("<CZoneManager constructor> Error while building the tp spawn Zones");
		}
	}

	for (first = primsList.begin(), last = primsList.end(); first != last; ++first)
	{
		if (! parseZones(first->Primitive.RootNode ) )
		{
			nlwarning("<CZoneManager constructor> Error while building the zones");
		}
	}

	// Parse ecotypes, that will be used when building deposits
	for (first = primsList.begin(), last = primsList.end(); first != last; ++first)
	{
		if (! parseEcotypes( first->Primitive.RootNode ) )
		{
			nlwarning("<CZoneManager constructor> Error while building the ecotypes");
		}
	}

	// Parse (and build) deposits
	for (first = primsList.begin(), last = primsList.end(); first != last; ++first)
	{
		if (! parseDeposits(first->Primitive.RootNode ) )
		{
			nlwarning("<CZoneManager constructor> Error while building the zones");
		}
	}

	// Don't keep ecotypes in memory, the information is already in the deposits
	CDeposit::clearEcotypes();
 
	// Parse stables
	for (first = primsList.begin(), last = primsList.end(); first != last; ++first)
	{
		if (! parseStables(first->Primitive.RootNode ) )
		{
			nlwarning("<CZoneManager constructor> Error while building the stables");
		}
	}
	
	// Parse the goo border
	for (first = primsList.begin(), last = primsList.end(); first != last; ++first)
	{
		if (! parseGooBorder(first->Primitive.RootNode ) )
		{
			nlwarning("<CZoneManager constructor> Error while building the Goo Border");
		}
	}

	// preallocate 5 start points per newbieland
	_StartPoints.reserve( 20 );
	// Parse the start points
	for (first = primsList.begin(), last = primsList.end(); first != last; ++first)
	{
		if (! parseStartPoints(first->Primitive.RootNode ) )
		{
			nlwarning("<CZoneManager constructor> Error while building the start points");
		}
	}

	// parse the PVP zones, must be before parsing the PVP safe zones!
	for (first = primsList.begin(), last = primsList.end(); first != last; ++first)
	{
		if ( !parsePVPZones(first->Primitive.RootNode) )
		{
			nlwarning("<CZoneManager constructor> Error while building the PVP zones");
		}
	}

	// parse the PVP safe zones (except for outpost zones)
	for (first = primsList.begin(), last = primsList.end(); first != last; ++first)
	{
		if ( !parsePVPSafeZones(first->Primitive.RootNode) )
		{
			nlwarning("<CZoneManager constructor> Error while building the PVP safe zones");
		}
	}

	// apply config to PVP zones (must be done after loading primitives), except outpost ones
	CPVPManager::getInstance()->applyConfigToPVPZones();

	// for backward compatibility
	//BACK_COMPAT::initSpawnZonesCompat();
	BACK_COMPAT::initPlacesCompat();


	// Initialize messages from other services

	// array of callback items
	NLNET::TUnifiedCallbackItem _cbArray[] =
	{
		{ "SET_ZONE_STATE",		cbSetZoneState },
	};
	// register call back for zone manager
	CUnifiedNetwork::getInstance()->addCallbackArray( _cbArray, sizeof(_cbArray) / sizeof(_cbArray[0]) );
	
}// CZoneManager ctor

//-----------------------------------------------
// CZoneManager dtor
//-----------------------------------------------
CZoneManager::~CZoneManager()
{
	// remove deposits
	for (uint i = 0; i < _Deposits.size(); i++ )
		delete _Deposits[i];
	// all must have unregistered from the set of autospawn update
	nlassert(_DepositNeedingAutoSpawnUpdate.empty());

	// remove places
	for ( uint i = 0; i < _Places.size(); i++ )
		delete _Places[i];

	// clear ecotypes
	clearEcotypes();
}// CZoneManager dtor

//-----------------------------------------------
// CZoneManager iosConnection
//-----------------------------------------------
void CZoneManager::iosConnection()
{
	for ( uint i = 0; i < _Continents.size(); i++ )
	{
		for ( uint j = 0; j < _Continents[i].getRegions().size(); j++ )
		{
			_Continents[i].getRegions()[j]->registerChatGroup();
		}
	}
}// CZoneManager iosConnection

//-----------------------------------------------
// CZoneManager getTpSpawnZoneIdByName
//-----------------------------------------------
uint16 CZoneManager::getTpSpawnZoneIdByName( const std::string & name )
{
	map<string,uint16>::const_iterator it = _TpSpawnZoneIdByName.find( name );
	if ( it == _TpSpawnZoneIdByName.end() )
	{
		return InvalidSpawnZoneId;
	}

	const uint16 id = (*it).second;
	BOMB_IF( (id >= _TpSpawnZones.size()), "<SPAWN_ZONE> invalid spawn zone id", return InvalidSpawnZoneId );
	BOMB_IF( (name != _TpSpawnZones[id].getName()), "<SPAWN_ZONE> spawn zone name does not match", return InvalidSpawnZoneId );

	return id;
}// CZoneManager getTpSpawnZoneIdByName


//-----------------------------------------------
// CZoneManager parseContinents
//-----------------------------------------------
bool CZoneManager::parseContinents( const NLLIGO::IPrimitive* prim )
{
	std::string value;
	const CPrimZone* zone = dynamic_cast<const CPrimZone*>( prim);
	// if the primitive is a continent, parse it, build it and add it to this manager if it is correct
	if ( zone && zone->getPropertyByName("class",value) && value == "continent" )
	{
		CContinent continent;
		if ( continent.build( zone ) )
		{
			uint i = 0;
			for (; i < _Continents.size(); i++ )
			{
				if ( _Continents[i].getId() == continent.getId() )
					break;
			}
			if ( i == _Continents.size() )
			{
				_Continents.push_back( continent );
			}
		}
	}
		// Lookup recursively in the children
	bool ok = true;
	for (uint i=0;i<prim->getNumChildren();++i)	
	{
		const IPrimitive *child;
		if ( prim->getChild(child,i) )
			ok = parseContinents(child) && ok;
	}
	return ok;
}// CZoneManager parseContinents

//-----------------------------------------------
// CZoneManager parseRegions
//-----------------------------------------------
bool CZoneManager::parseRegions( const NLLIGO::IPrimitive* prim )
{
	std::string value;
	const CPrimZone* zone = dynamic_cast<const CPrimZone*>(prim);
	// if the primitive is a continent, parse it, build it and add it to this manager if it is correct
	if ( zone && prim->getPropertyByName("class",value) && value == "region" )
	{
		CRegion * region = new CRegion();
		if ( region->build( zone,(uint16)_Places.size() ) )
		{
			bool found = false;
			for (uint i = 0; i < _Continents.size(); i++ )
			{
				const std::vector<CPrimVector> & regionPoints = zone->VPoints;
				for (uint j = 0; j < regionPoints.size(); j++ )
				{
					if ( _Continents[i].contains( regionPoints[j] ) )
					{
						found = true;
						_Continents[i].addRegion( region );
						region->setContinent( (CONTINENT::TContinent) _Continents[i].getId() );
						break;
					}
				}
			}
			nlassertex(found, (toString("No continent found that includes the region %s", prim->getName().c_str()).c_str() ) );
			_Places.push_back( region );
			_PlacesByAlias.insert( make_pair(region->getAlias(), region) );
		}
		else
			delete region;
	}
	// Lookup recursively in the children
	bool ok = true;
	for (uint i=0;i<prim->getNumChildren();++i)	
	{
		const IPrimitive *child;
		if ( prim->getChild(child,i) )
			ok = parseRegions(child) && ok;
	}
	return ok;
}// CZoneManager parseRegions

//-----------------------------------------------
// CZoneManager parseZones
//-----------------------------------------------
bool CZoneManager::parseZones( const NLLIGO::IPrimitive* prim )
{
	std::string value;
	const CPrimZone* zone = dynamic_cast<const CPrimZone*>(prim);
	// if the primitive is a zone, parse it
	if ( zone )
	{
		// build the zone and add it to this manager if it is correct
		if (prim->getPropertyByName("class",value) )
		{
			if ( value == "place" )
			{
				CPlace* place = new CPlace();
				if ( place->build( zone,(uint16)_Places.size() ) )
				{
					for (uint i = 0; i < _Continents.size(); i++ )
					{
						for (uint j = 0; j < _Continents[i].getRegions().size(); j++ )
						{
							for ( uint k = 0; k < place->VPoints.size(); k++ )
							{
								if ( _Continents[i].getRegions()[j]->contains( place->VPoints[k] ) )
								{
									_Continents[i].getRegions()[j]->addPlace( place );
									break;
								}
							}
						}
					}
					_Places.push_back( place );
					_PlacesByAlias.insert( make_pair(place->getAlias(), place) );
				}
				else
					delete place;
			}
		}
	}
	// Lookup recursively in the children
	bool ok = true;
	for (uint i=0;i<prim->getNumChildren();++i)	
	{
		const IPrimitive *child;
		if ( prim->getChild(child,i) )
			ok = parseZones(child) && ok;
	}
	return ok;
} // CZoneManager parseZones

//-----------------------------------------------
// CZoneManager parseEcotypes
//-----------------------------------------------
bool CZoneManager::parseEcotypes( const NLLIGO::IPrimitive* prim )
{
	std::string value;
	if (prim->getPropertyByName("class",value) )
	{
		if ( value == "ecotypezone_list" )
		{
			std::string ecotypeZoneListName;
			prim->getPropertyByName( "name", ecotypeZoneListName );
			
			// Parse the children ecotypes
			for( uint i = 0; i < prim->getNumChildren(); ++i )
			{
				const IPrimitive * childPrim;
				if ( prim->getChild( childPrim, i ) )
				{
					// If the primitive is a zone, parse it
					const CPrimZone* zone = dynamic_cast<const CPrimZone*>(childPrim);		
					if ( zone )
					{	
						string primType;
						childPrim->getPropertyByName( "class", primType );
						if( primType == "ecotypezone" )
						{
							CEcotypeZone *ecotype = new CEcotypeZone();
							if ( ecotype->build( zone ) )
							{
								CDeposit::addEcotype( ecotype );
								CEcotypeZone *ecotype2 = new CEcotypeZone();
								if( ecotype2->build( zone ) )
									CZoneManager::addEcotype( ecotype2 );
								else
									delete ecotype2;
							}
							else
								delete ecotype;
						}
					}
				}
			}
		}
	}

	// Lookup recursively in the children
	bool ok = true;
	for (uint i=0;i<prim->getNumChildren();++i)	
	{
		const IPrimitive *child;
		if ( prim->getChild(child,i) )
			ok = parseEcotypes(child) && ok;
	}
	return ok;
}

//-----------------------------------------------
// CZoneManager parseDeposits
// Assumes the ecotypes have been parsed before
//-----------------------------------------------
bool CZoneManager::parseDeposits( const NLLIGO::IPrimitive* prim )
{
	std::string value;
	if (prim->getPropertyByName("class",value) )
	{
		if ( value == "depositzone_list" )
		{
			std::string depositZoneListName;
			prim->getPropertyByName( "name", depositZoneListName );
			
			// Parse the children deposits
			for( uint i = 0; i < prim->getNumChildren(); ++i )
			{
				const IPrimitive * childPrim;
				if ( prim->getChild( childPrim, i ) )
				{
					// If the primitive is a zone, parse it
					const CPrimZone* zone = dynamic_cast<const CPrimZone*>(childPrim);		
					if ( zone )
					{	
						string primType;
						childPrim->getPropertyByName( "class", primType );
						if( primType == "depositzone" )
						{
							bool found = false;
							CDeposit * deposit = new CDeposit;
							if ( deposit->build( zone ) )
							{
								for (uint j = 0; j < _Continents.size(); j++ )
								{
									for (uint k = 0; k < _Continents[j].getRegions().size(); k++ )
									{
										uint l = 0;
										for ( ; l < deposit->VPoints.size(); l++ )
										{
											if ( _Continents[j].getRegions()[k]->contains( deposit->VPoints[l] ) )
											{
												_Continents[j].getRegions()[k]->addDeposit( deposit );
												found = true;
												break;
											}
										}
									}
									if ( !found )
									{
										for ( uint k = 0; k < _Continents[j].getRegions().size(); k++ )
										{
											for ( uint l = 0 ; l < _Continents[j].getRegions()[k]->VPoints.size(); l++ )
											{
												if ( deposit->contains( _Continents[j].getRegions()[k]->VPoints[l] ) )
												{
													_Continents[j].getRegions()[k]->addDeposit( deposit );
													found = true;
													break;
												}
											}
										}
									}
								}
								if ( !found  )
									nlwarning("<CZoneManager parseDeposits> a deposit of %s is not in a region", depositZoneListName.c_str());
								_Deposits.push_back(deposit);
							}
							else
								delete deposit;
						}
					}
				}
			}
		}
	}
				
	// Lookup recursively in the children
	bool ok = true;
	for (uint i=0;i<prim->getNumChildren();++i)	
	{
		const IPrimitive *child;
		if ( prim->getChild(child,i) )
			ok = parseDeposits(child) && ok;
	}
	return ok;
} // CZoneManager parseDeposits

//-----------------------------------------------
// CZoneManager parseStables
//-----------------------------------------------
bool CZoneManager::parseStables( const NLLIGO::IPrimitive* prim )
{
// Primitives format:	
// <!-- stables -->
// <PRIMITIVE CLASS_NAME="stables" TYPE="node" AUTO_INIT="true" DELETABLE="true">
// <DYNAMIC_CHILD CLASS_NAME="stable"/>
// </PRIMITIVE>
//
// <!-- stable -->
// <PRIMITIVE CLASS_NAME="stable" TYPE="zone"  R="0" G="255" B="255" A="128" AUTO_INIT="false" DELETABLE="true">>
// <PARAMETER NAME="name" TYPE="string" VISIBLE="true"/>
//
// <STATIC_CHILD CLASS_NAME="stable_entry" NAME ="stable entry"/>
// </PRIMITIVE>
//
// <!-- stable entry point -->
// <PRIMITIVE CLASS_NAME="stable_entry" TYPE="point" R="128" G="50" B="200" A="128" AUTO_INIT="true" DELETABLE="false">
// </PRIMITIVE>

	std::string value;
	if (prim->getPropertyByName("class",value) )
	{
		if ( value == "stables" )
		{
			string stableName, continent;

			prim->getPropertyByName( "name", stableName );

			for( uint c = 0; c < prim->getNumChildren(); ++c )
			{
				const NLLIGO::IPrimitive* child;
				prim->getChild(child,c);
				if (child->getPropertyByName("class",value) )
				{
					if( value == "stable" )
					{
						//geometry of stable point (normally one dot with directional information)
						const NLLIGO::CPrimZone* primZone = dynamic_cast<const CPrimZone*>(child);
						if( primZone )
						{
							bool found = false;

							CPlace* place = new CPlace();
							if ( place->build( primZone,(uint16)_Places.size(), true ) )
							{
								for (uint i = 0; i < _Continents.size(); i++ )
								{
									continent = CONTINENT::toString( (CONTINENT::TContinent)_Continents[i].getId() );
									for (uint j = 0; j < _Continents[i].getRegions().size(); ++j )
									{
										for ( uint k = 0; k < place->VPoints.size(); ++k )
										{
											if ( _Continents[i].getRegions()[j]->contains( place->VPoints[k] ) )
											{
												_Continents[i].getRegions()[j]->addPlace( place );
												found = true;
												// Displaying the aliases of all the stables:
												//string branchPath = _Continents[i].getName() + "." + _Continents[i].getRegions()[j]->getName() + "." + place->getName();
												//InfoLog->displayRawNL( "STBL:%s: %u", branchPath.c_str(), place->getAlias() );
												break;
											}
										}
									}
								}
							}

							if( place->getId() == 0x35 )
							{
								nlinfo("catch it!");
							}

							if( found == false )
							{
								nlwarning("<CZoneManager::parseStables> Stable %s is not in a region", stableName.c_str());
								delete place;
							}
							else
							{
								_Places.push_back( place );
								_PlacesByAlias.insert( make_pair(place->getAlias(), place) );

								for( uint c2 = 0; c2 < child->getNumChildren(); ++c2 )
								{
									const NLLIGO::IPrimitive* child2;
									child->getChild(child2,c2);

									if (child2->getPropertyByName("class",value) )
									{
										if( value == "stable_entry" )
										{
											const NLLIGO::CPrimPoint *stableEntryPoint = dynamic_cast< const CPrimPoint * >(child2);
											if( stableEntryPoint == 0 )
											{
												nlwarning("<CZoneManager::parseStables> Stable %s not contained stable entry point", stableName.c_str());
												return false;
											}
											CStable::getInstance()->addStable( stableName, place->getId(), continent, stableEntryPoint->Point.x, stableEntryPoint->Point.y, stableEntryPoint->Point.z, stableEntryPoint->Angle );
										}
									}
								}
							}
						}
					}
				}
			}
		}
	}

	// Lookup recursively in the children
	bool ok = true;
	for (uint i=0;i<prim->getNumChildren();++i)	
	{
		const IPrimitive *child;
		if ( prim->getChild(child,i) )
			ok = parseStables(child) && ok;
	}
	return ok;
}

//-----------------------------------------------
// CZoneManager parseTpSpawnZones
//-----------------------------------------------
bool CZoneManager::parseTpSpawnZones( const NLLIGO::IPrimitive* prim )
{
	std::string value;
	if (prim->getPropertyByName("class",value) )
	{
		if ( value == "teleport_spawn_zone" )
		{
			const NLLIGO::CPrimPoint* point = dynamic_cast<const CPrimPoint*>(prim);
			if ( !point )
			{
				nlwarning("CZoneManager::parseTpSpawnZones -> teleport_trigger should be prim points");
				return false;
			}
			CTpSpawnZone zone;
			if( !zone.build( point ) )
				return false;

			// if it is a respawn point get the continent where the zone is
			if ( zone.getType() == RESPAWN_POINT::KAMI ||
				zone.getType() == RESPAWN_POINT::KARAVAN ||
				zone.getType() == RESPAWN_POINT::NEWBIELAND ||
				zone.getType() == RESPAWN_POINT::RESPAWNABLE )
			{
				bool found = false;
				uint j;
				for ( j = 0; j < _Continents.size() && !found; ++j )
				{
					if ( _Continents[j].contains( point->Point ) )
					{
						zone.setContinent((CONTINENT::TContinent) _Continents[j].getId());
						found = true;
						break;
					}
				}
				if( !found )	
				{
					nlwarning("<CZoneManager::parseTpSpawnZones> Re-spawn point '%s' is not in a continent", zone.getName().c_str());
					return false;
				}

				found = false;
				for ( uint k = 0; k < _Continents[j].getRegions().size(); k++ )
				{
					if( _Continents[j].getRegions()[k]->contains( point->Point ) )
					{
						zone.setRegion( _Continents[j].getRegions()[k]->getId() );
						found = true;
						break;
					}
				}
				if( ! found )
				{
					nlwarning("<CZoneManager::parseTpSpawnZones> Re-spawn point '%s' is not in a region", zone.getName().c_str());
					return false;
				}
			}

			nlassert( _TpSpawnZones.size() < 0xffff );

			map<string,uint16>::const_iterator it = _TpSpawnZoneIdByName.find( zone.getName() );
			BOMB_IF( (it != _TpSpawnZoneIdByName.end()),
				toString( "<SPAWN_ZONE> spawn zone name '%s' is already used!!!", zone.getName().c_str() ),
				return false
				);

			_TpSpawnZoneIdByName[zone.getName()] = (uint16)_TpSpawnZones.size();
			_TpSpawnZones.push_back( zone );
			return true;
		}
	}
	
	// Lookup recursively in the children
	bool ok = true;
	for (uint i=0;i<prim->getNumChildren();++i)	
	{
		const IPrimitive *child;
		if ( prim->getChild(child,i) )
			ok = parseTpSpawnZones(child) && ok;
	}
	return ok;
}

//-----------------------------------------------
// CZoneManager parseGooBorder
//-----------------------------------------------
bool CZoneManager::parseGooBorder( const NLLIGO::IPrimitive* prim )
{
	std::string value;
	if (prim->getPropertyByName("class",value) )
	{
		if ( value == "goo_border" )
		{
			string gooBorderName, continent;
			prim->getPropertyByName( "name", gooBorderName );

			const CPrimPath * path = dynamic_cast<const CPrimPath*>(prim);
			if( path )
			{
				CPlace* place = new CPlace();
				if ( place->build( path,(uint16)_Places.size() ) ) //assume CPrimPath and CPrimZone has the same members, method needed are only in CPrimZone
				{
					for (uint i = 0; i < _Continents.size(); i++ )
					{
						for (uint j = 0; j < _Continents[i].getRegions().size(); j++ )
						{
							for ( uint k = 0; k < place->VPoints.size(); k++ )
							{
								if ( _Continents[i].getRegions()[j]->contains( place->VPoints[k] ) )
								{
									_Continents[i].getRegions()[j]->addPlace( place );
									break;
								}
							}
						}
					}
					_Places.push_back( place );
					_PlacesByAlias.insert( make_pair(place->getAlias(), place) );
				}
				else
				{
					delete place;
				}
			}
		}
	}

	// Lookup recursively in the children
	bool ok = true;
	for (uint i=0;i<prim->getNumChildren();++i)	
	{
		const IPrimitive *child;
		if ( prim->getChild(child,i) )
			ok = parseGooBorder(child) && ok;
	}
	return ok;
}

//-----------------------------------------------
// CZoneManager parseStartPoints
//-----------------------------------------------
bool CZoneManager::parseStartPoints( const NLLIGO::IPrimitive* prim )
{
	std::string value;
	if (prim->getPropertyByName("class",value) )
	{
		if ( value == "start_village" )
		{
			string value;
			prim->getPropertyByName( "name", value );
			RYZOM_STARTING_POINT::TStartPoint start = RYZOM_STARTING_POINT::toStartPoint( value );
			if ( start == RYZOM_STARTING_POINT::NB_START_POINTS )
			{
				nlwarning("<parseStartPoints> invalid start point %s",value.c_str() );
				return false;
			}
			uint16 startIdx = (uint16) start;
			if ( startIdx >= _StartPoints.size() )
				_StartPoints.resize( startIdx + 1);

			bool ok = true;
			for (uint i=0;i<prim->getNumChildren();++i)	
			{
				const IPrimitive *child = NULL;
				if ( prim->getChild(child,i) && child && child->getPropertyByName("class",value) && value == "start_point")
				{
					CStartPoint point;
					child->getPropertyByName( "mission", value );
					point.Mission = CAIAliasTranslator::getInstance()->getMissionUniqueIdFromName( value );
					if ( point.Mission == CAIAliasTranslator::Invalid )
					{
						nlwarning("<parseStartPoints> invalid mission %s",value.c_str() );
					}
					child->getPropertyByName( "welcomer", value );
					point.Welcomer = CAIAliasTranslator::Invalid;
					vector<TAIAlias> aliases;
					CAIAliasTranslator::getInstance()->getNPCAliasesFromName( value, aliases );
					if ( aliases.empty() )
					{
						nlwarning("<parseStartPoints> invalid welcomer %s",value.c_str() );
					}
					else
						point.Welcomer = aliases[0];
					if ( point.Welcomer == CAIAliasTranslator::Invalid )
					{
						nlwarning("<parseStartPoints> invalid welcomer %s",value.c_str() );
					}
					child->getPropertyByName( "spawn_zone", value );
					point.SpawnZoneId = getTpSpawnZoneIdByName( value );
					if ( point.SpawnZoneId == InvalidSpawnZoneId )
					{
						nlwarning("<parseStartPoints> invalid spawn zone %s",value.c_str() );
						ok = false;
					}
					if ( ok )
					{
						_StartPoints[startIdx].push_back( point );
					}
				}
			}
			return ok;
		}
	}
	// Lookup recursively in the children
	bool ok = true;
	for (uint i=0;i<prim->getNumChildren();++i)	
	{
		const IPrimitive *child;
		if ( prim->getChild(child,i) )
			ok = parseStartPoints(child) && ok;
	}
	return ok;
}

CVariable<bool> LoadPVPFreeZones("egs", "LoadPVPFreeZones", "If true PVP free zones will be loaded", false, 0, true );
CVariable<bool> LoadPVPVersusZones("egs", "LoadPVPVersusZones", "If true PVP versus zones will be loaded", false, 0, true );
CVariable<bool> LoadPVPGuildZones("egs", "LoadPVPGuildZones", "If true PVP guild zones will be loaded", false, 0, true );

//-----------------------------------------------
// CZoneManager parsePVPZones
//-----------------------------------------------
bool CZoneManager::parsePVPZones( const NLLIGO::IPrimitive * prim )
{
	std::string value;
	prim->getPropertyByName("class",value);
	const CPrimZone * zone = dynamic_cast<const CPrimZone *>(prim);

	// if the primitive is a zone, parse it
	if ( zone && (value == "pvp_zone") )
	{
		CSmartPtr<IPVPZone> pvpZone = IPVPZone::build( zone );
		bool load = false;

		switch (pvpZone->getPVPZoneType())
		{
		case PVP_ZONE_TYPE::FreeZone:
			load = LoadPVPFreeZones;
			break;

		case PVP_ZONE_TYPE::VersusZone:
			load = LoadPVPVersusZones;
			break;

		case PVP_ZONE_TYPE::GuildZone:
			load = LoadPVPGuildZones;
			break;

		default:
			nlwarning( "Invalid %s zone in pvp_zone primitive %s", PVP_ZONE_TYPE::toString( pvpZone->getPVPZoneType() ).c_str(), prim->getName().c_str() );
			load = false;
		}
		if (load)
			CPVPManager::getInstance()->addPVPZone( pvpZone );
	}


	// lookup recursively in the children
	bool result = true;
	for (uint i = 0; i < prim->getNumChildren(); i++)
	{
		const IPrimitive * child;
		if ( prim->getChild(child, i) )
			result &= parsePVPZones(child);
	}

	return result;
} // CZoneManager parsePVPZones

//-----------------------------------------------
// CZoneManager parsePVPSafeZones
//-----------------------------------------------
bool CZoneManager::parsePVPSafeZones( const NLLIGO::IPrimitive * prim )
{
	std::string value;
	const CPrimPoint * point = dynamic_cast<const CPrimPoint *>(prim);

	// if the primitive is a point, parse it
	if ( point && prim->getPropertyByName("class",value) && value == "safe_zone" )
	{
		value = "true";
		prim->getPropertyByName("safe_from_pvp", value);
		if ( value == "true" )
		{
			CSmartPtr<CPVPSafeZone> safeZone = CPVPSafeZone::build( point );
			if ( !safeZone.isNull() )
			{
				CPVPManager::getInstance()->addPVPSafeZone( safeZone );
				CPVPManager2::getInstance()->addPVPSafeZone( safeZone );
			}
		}
	}

	// lookup recursively in the children
	bool result = true;
	for (uint i = 0; i < prim->getNumChildren(); i++)
	{
		const IPrimitive * child;
		if ( prim->getChild(child, i) )
			result &= parsePVPSafeZones(child);
	}

	return result;
} // CZoneManager parsePVPSafeZones

//-----------------------------------------------
// CZoneManager getContinent
//-----------------------------------------------
CContinent * CZoneManager::getContinent( sint32 x, sint32 y )
{
	CVector vect( x * 0.001f, y * 0.001f, 0.0f );
	for ( uint i = 0; i < _Continents.size(); i++ )
	{
		if ( _Continents[i].contains(vect) )
			return &_Continents[i];
	}
	return NULL;
	return getContinent(vect);
}// CZoneManager getContinent*


//-----------------------------------------------
// Same with vector
//-----------------------------------------------
CContinent * CZoneManager::getContinent( const NLMISC::CVector& pos )
{
	for ( uint i = 0; i < _Continents.size(); i++ )
	{
		if ( _Continents[i].contains(pos) )
			return &_Continents[i];
	}
	return NULL;
}// CZoneManager getContinent


//-----------------------------------------------
// CZoneManager getRegion
//-----------------------------------------------
bool CZoneManager::getRegion( sint32 x, sint32 y, const CRegion ** region, const CContinent ** continent)
{
	nlassert(region);
	CVector vect( x * 0.001f, y * 0.001f, 0.0f );
	for ( uint i = 0; i < _Continents.size(); i++ )
	{
		if ( _Continents[i].contains(vect) )
		{
			for (uint j = 0; j < _Continents[i].getRegions().size(); j++ )
			{
				if ( _Continents[i].getRegions()[j]->contains( vect ) )
				{
					if ( continent )
						*continent = &_Continents[i];

					*region =  _Continents[i].getRegions()[j];
					return true;
				}
			}
		}
	}
	return false;
}// CZoneManager getRegion

#include <limits>

//-----------------------------------------------
// CZoneManager getPlace
//-----------------------------------------------
bool CZoneManager::getPlace( sint32 x, sint32 y, float& gooDistance, const CPlace ** stable, std::vector<const CPlace *>& places, const CRegion ** region , const CContinent ** continent )
{
	nlassert(stable);

	if( continent ) *continent = NULL;
	if( region ) *region = NULL;
	*stable = NULL;

	float nearGooDistance = numeric_limits<float>::max();

	CVector vect( x * 0.001f, y * 0.001f, 0.0f );
	for ( uint i = 0; i < _Continents.size(); i++ )
	{
		if ( _Continents[i].contains(vect) )
		{
			if ( continent )
				*continent = &_Continents[i];
			for (uint j = 0; j < _Continents[i].getRegions().size(); j++ )
			{
				if ( _Continents[i].getRegions()[j]->contains( vect ) )
				{
					if ( region )
					{
						*region = _Continents[i].getRegions()[j];
					}
					for (uint k = 0; k < _Continents[i].getRegions()[j]->getPlaces().size(); k++ )
					{
						if(!_Continents[i].getRegions()[j]->getPlaces()[k]->isGooActive())
						{
							if ( _Continents[i].getRegions()[j]->getPlaces()[k]->contains( vect ) )
							{
								const CPlace * p;
								p = _Continents[i].getRegions()[j]->getPlaces()[k];

								CStable::TStableData stableData;
								if( CStable::getInstance()->getStableData( p->getId(), stableData ) )
								{
									*stable = p;
								}
								places.push_back( p );
							}
						}
						else
						{
							CVector p1, p2, nearPos;
							float distance;

							CPrimZone::contains (vect, _Continents[i].getRegions()[j]->getPlaces()[k]->VPoints, distance, nearPos, true);
							if( distance < nearGooDistance )
							{
								nearGooDistance = distance;
							}
						}
					}
					gooDistance = nearGooDistance;
					return true;
				}
			}
		}
	}
	gooDistance = nearGooDistance;
	return false;
}// CZoneManager getPlace


//-----------------------------------------------
// CZoneManager getRegion
//-----------------------------------------------
CRegion * CZoneManager::getRegion( const NLMISC::CVector& pos )
{
	const CRegion *cregion = 0;
	if ( (! getRegion( (sint32)(pos.x*1000.0f), (sint32)(pos.y*1000.0f), &cregion )) || (! cregion) )
	{
		nlwarning( "Invalid region for pos %s", pos.asString().c_str() );
		return NULL;
	}
	return (const_cast<CRegion*>(cregion));
}


//-----------------------------------------------
// CZoneManager getDepositsUnderUser
//-----------------------------------------------
void CZoneManager::getDepositsUnderPos( const CVector& pos, std::vector<CDeposit*>& deposits, bool warnIfOutsideOfRegion )
{
	const CRegion *cregion = 0;
	CRegion *region;
	if ( (! getRegion( (sint32)(pos.x*1000.0f), (sint32)(pos.y*1000.0f), &cregion )) || (! cregion) )
	{
		if ( warnIfOutsideOfRegion )
			nlwarning( "<CZoneManager getDepositsUnderPos> invalid region for pos %s", pos.asString().c_str() );
		return;
	}
	region = (const_cast<CRegion*>(cregion));
	deposits.clear();
	for (uint i=0; i!=region->getDeposits().size(); ++i )
	{
		if ( region->getDeposits()[i]->contains( pos ) )
			deposits.push_back( region->getDeposits()[i] );
	}
}// CZoneManager getDepositsUnderPos


//
// get the first deposit found under the position (faster than getDepositsUnderPos()), or NULL if not found
//
CDeposit* CZoneManager::getFirstFoundDepositUnderPos( const NLMISC::CVector& pos )
{
	const CRegion *cregion = 0;
	CRegion *region;
	if ( (! getRegion( (sint32)(pos.x*1000.0f), (sint32)(pos.y*1000.0f), &cregion )) || (! cregion) )
	{
		nlwarning( "<CZoneManager getFirstFoundDepositUnderPos> invalid region for pos %s", pos.asString().c_str() );
		return NULL;
	}
	region = (const_cast<CRegion*>(cregion));
	for (uint i=0; i!=region->getDeposits().size(); ++i )
	{
		if ( region->getDeposits()[i]->contains( pos ) )
			return region->getDeposits()[i];
	}
	return NULL;
}

//-----------------------------------------------
// CZoneManager getContinentFromId
//-----------------------------------------------
CPlace* CZoneManager::getPlaceFromAlias( TAIAlias alias )
{
	std::map< TAIAlias, CPlace* >::iterator it = _PlacesByAlias.find( alias );
	if ( it != _PlacesByAlias.end() )
	{
		return ( (*it).second );
	}
	return NULL;
}

//-----------------------------------------------
// CZoneManager getPlaceFromName
//-----------------------------------------------
CPlace* CZoneManager::getPlaceFromName( const std::string & name )
{
	for ( uint i = 0; i < _Places.size(); i++ )
	{
		if ( _Places[i] && _Places[i]->getName() == name )
		{
			return _Places[i];
		}
	}
	return NULL;
}// CZoneManager getPlaceFromName

//-----------------------------------------------
// CZoneManager getContinentFromId
//-----------------------------------------------
CContinent* CZoneManager::getContinentFromId( CONTINENT::TContinent id )
{
	if (id == CONTINENT::UNKNOWN )
		return NULL;
	for ( uint i = 0; i< _Continents.size(); i++ )
	{
		if ( _Continents[i].getId() == id )
			return &_Continents[i];
	}
	nlwarning("<CZoneManager getContinentFromId> continent id %u is out of bound",id);
	return NULL;
}// CZoneManager getContinentFromId

//-----------------------------------------------
// CZoneManager updateCharacterPosition
//-----------------------------------------------
void CZoneManager::updateCharacterPosition( CCharacter * user )
{
	nlassert(user);

	// if user is in an instance, do not update the places where he is
	CMirrorPropValueRO<TYPE_CELL> mirrorCell( TheDataset, user->getEntityRowId(), DSPropertyCELL );
	sint32 cell = mirrorCell;	
	if ( cell <= - 2 )
		return;
	if ( user->getState().X <= 0 || user->getState().Y >= 0 )
		return;

	SM_STATIC_PARAMS_1(params, STRING_MANAGER::place);
	SM_STATIC_PARAMS_2(params2, STRING_MANAGER::place, STRING_MANAGER::faction);

	// get the current location of the character
	const CPlace * stable;
	std::vector<const CPlace*> places;
	const CRegion * region ;
	const CContinent * continent;
	float gooDistance;
	getPlace( user, gooDistance, &stable, places, &region, &continent);

	// SOURCE: user->getCurrentContinent()
	// DESTINATION: continent->getId()
	//	{	
		// update the continent if necessary
		if ( continent == NULL )
		{
			CPlace * oldPlace = getContinentFromId( user->getCurrentContinent() ); // returns NULL for CONTINENT::UNKNOWN
			if (oldPlace)
			{
				params[0].Identifier = oldPlace->getName();
				PHRASE_UTILITIES::sendDynamicSystemMessage(user->getEntityRowId(),"EGS_LEAVE_CONTINENT",params);	
			}
			user->setCurrentContinent( CONTINENT::UNKNOWN );
		}
		else if ( (CONTINENT::TContinent)continent->getId() != user->getCurrentContinent() )
		{
			// if current continent is NEWBIELAND, send an 'newbie' update to the SU
			bool updateSU = false;
			if (user->getCurrentContinent() == CONTINENT::NEWBIELAND)
				updateSU = true;

			const CONTINENT::TContinent oldContinent = user->getCurrentContinent();
			CPlace * oldPlace = getContinentFromId( oldContinent ); // returns NULL for CONTINENT::UNKNOWN
			if (oldPlace)
			{
				params[0].Identifier = oldPlace->getName();
				PHRASE_UTILITIES::sendDynamicSystemMessage(user->getEntityRowId(),"EGS_LEAVE_CONTINENT",params);	
			}
			params[0].Identifier = continent->getName();
			PHRASE_UTILITIES::sendDynamicSystemMessage(user->getEntityRowId(),"EGS_ENTER_CONTINENT",params);	
			user->setCurrentContinent( (CONTINENT::TContinent)continent->getId() );
			// notify player respawn points system that continent changed
			user->getRespawnPoints().cbContinentChanged(oldContinent);
			// update newbieland flag (defailt to 1 if there's aproblem determining the true value)
			bool newbie = user->isNewbie();
//			user->_PropertyDatabase.setProp("USER:IS_NEWBIE", newbie);
			CBankAccessor_PLR::getUSER().setIS_NEWBIE(user->_PropertyDatabase, newbie);

			bool trialPlayer = false;
			CPlayer *player = PlayerManager.getPlayer( PlayerManager.getPlayerId(user->getId()));
			if (!player)
			{
				nlwarning("Error %s was not found in player manager.",user->getId().toString().c_str());
				trialPlayer = player->isTrialPlayer();
			}
//			user->_PropertyDatabase.setProp("USER:IS_TRIAL", trialPlayer);
			CBankAccessor_PLR::getUSER().setIS_TRIAL(user->_PropertyDatabase, trialPlayer);

			if (updateSU)
			{
				if (IShardUnifierEvent::getInstance() != NULL)
					IShardUnifierEvent::getInstance()->onUpdateCharNewbieFlag(user->getId(), newbie);
			}
		}
		
		// do the same for region
		// first send message for leaving previous region
		CRegion * oldRegion = dynamic_cast<CRegion *> ( getPlaceFromId( user->getCurrentRegion() ) );
		if( user->getCurrentRegion() != 0xFFFF )
		{
			// previously in region
			if( region == 0 || ( region->getId() != user->getCurrentRegion()) )
			{
				// and not the same than actual region
				if (oldRegion)
				{
					const CTotemBase* pTotem = CPVPFactionRewardManager::getInstance().getTotemBaseFromId( user->getCurrentRegion() );
					if( pTotem )
					{
						PVP_CLAN::TPVPClan regionFaction = pTotem->getOwnerFaction();
						if( regionFaction == PVP_CLAN::Neutral )
						{
							params[0].Identifier = oldRegion->getName();
							PHRASE_UTILITIES::sendDynamicSystemMessage(user->getEntityRowId(),"EGS_LEAVE_NEUTRAL_REGION",params);
						}
						else
						{
							params2[0].Identifier = oldRegion->getName();
							params2[1].Enum = PVP_CLAN::getFactionIndex(regionFaction);
							PHRASE_UTILITIES::sendDynamicSystemMessage(user->getEntityRowId(),"EGS_LEAVE_FACTION_REGION",params2);
						}
					}
					else
					{
						params[0].Identifier = oldRegion->getName();
						PHRASE_UTILITIES::sendDynamicSystemMessage(user->getEntityRowId(),"EGS_LEAVE_NEUTRAL_REGION",params);
					}

					oldRegion->removePlayer( user->getId() );

					// check if user leaves newbieland
					if ( region != 0 && oldRegion->isNewbieRegion() && !region->isNewbieRegion() )
					{
						user->getRespawnPoints().clearRespawnPoints();
					}
				}

				if( region == 0 )
				{
					user->setCurrentRegion( 0xFFFF );
					// remove spire effects for Pvp-flagged players
					if ( user->getPVPFlag() )
						CPVPFactionRewardManager::getInstance().removeTotemsEffects( user );
				}
			}
		}
		
		if ( region != 0 && (user->getCurrentRegion() != region->getId()) )
		{
			const CTotemBase* pTotem = CPVPFactionRewardManager::getInstance().getTotemBaseFromId( region->getId() );
			if( pTotem )
			{
				PVP_CLAN::TPVPClan regionFaction = pTotem->getOwnerFaction();
				if( regionFaction == PVP_CLAN::Neutral )
				{
					params[0].Identifier = region->getName();
					PHRASE_UTILITIES::sendDynamicSystemMessage(user->getEntityRowId(),"EGS_ENTER_NEUTRAL_REGION",params);
				}
				else
				{
					params2[0].Identifier = region->getName();
					params2[1].Enum = PVP_CLAN::getFactionIndex(regionFaction);
					PHRASE_UTILITIES::sendDynamicSystemMessage(user->getEntityRowId(),"EGS_ENTER_FACTION_REGION",params2);
				}
			}
			else
			{
				params[0].Identifier = region->getName();
				PHRASE_UTILITIES::sendDynamicSystemMessage(user->getEntityRowId(),"EGS_ENTER_NEUTRAL_REGION",params);
			}

			user->setCurrentRegion( region->getId() );
			((CRegion*)region)->addPlayer( user->getId() );
			
			// check if user leaves newbieland
			if ( oldRegion != 0 && oldRegion->isNewbieRegion() && !region->isNewbieRegion() )
			{
				user->getRespawnPoints().clearRespawnPoints();
			}

			// add new spire effects for Pvp-flagged players
			if ( user->getPVPFlag() )
				CPVPFactionRewardManager::getInstance().giveTotemsEffects( user );

			// Now the VisitPlace missions are checked in CMissionManager::checkVisitPlaceMissions()
			//CMissionEventVisitPlace event(region->getId() );
			//user->processMissionMultipleEvent(event);
		}
		
		// get new places
		const uint newPlacesSize = (uint)places.size();
		//bool sendWarning = false;
		bool changed = false;
		for ( uint i = 0; i < newPlacesSize; i++ )
		{
			if ( !user->isInPlace( places[i]->getId() ) )
			{
				if( places[i]->getReported() )
				{
					params[0].Identifier = places[i]->getName();
					PHRASE_UTILITIES::sendDynamicSystemMessage(user->getEntityRowId(),"EGS_ENTER_PLACE",params);
				}
				// Now the VisitPlace missions are checked in CMissionManager::checkVisitPlaceMissions()
				//CMissionEventVisitPlace event( places[i]->getId() );
				//user->processMissionMultipleEvent(event);
				
				// validate respawn points
				for ( uint j =  0; j< places[i]->getRespawnPoints().size(); j++ )
				{
					user->getRespawnPoints().addRespawnPoint( places[i]->getRespawnPoints()[j] );
				}

				changed = true;

				/// tells mission system that user enters a place
				for ( map<TAIAlias, CMission*>::iterator it = user->getMissionsBegin(); it != user->getMissionsEnd(); ++it )
				{
					CMissionManager::getInstance()->enterPlace( (*it).second,places[i]->getAlias(), places[i]->getId() );
				}
			}
		}

		// get left places
		const uint oldPlacesSize = (uint)user->getPlaces().size();
		for ( uint i = 0; i < oldPlacesSize; i++ )
		{
			uint j = 0;
			for (; j < newPlacesSize; j++ )
			{
				if ( places[j]->getId() == user->getPlaces()[i] )
					break;
			}
			if ( j == newPlacesSize )
			{
				CPlace * place = getPlaceFromId( user->getPlaces()[i] );
				if ( place )
				{
					if( place->getReported() )
					{
						params[0].Identifier = place->getName();
						PHRASE_UTILITIES::sendDynamicSystemMessage(user->getEntityRowId(),"EGS_LEAVE_PLACE",params);
					}

					/// tells mission system that user enters a place
					for ( map<TAIAlias, CMission*>::iterator it = user->getMissionsBegin(); it != user->getMissionsEnd(); ++it )
					{
						CMissionManager::getInstance()->leavePlace( (*it).second,place->getAlias(), place->getId() );
					}
				}
				changed = true;
			}
			
		}

		// enter/leave PVP zones
		TAIAlias pvpZoneAlias = CPVPManager::getInstance()->getPVPZoneFromUserPosition( user );
		if ( pvpZoneAlias != user->getCurrentPVPZone() && !user->isDead() )
		{
			if ( user->getCurrentPVPZone() != CAIAliasTranslator::Invalid )
			{
				CPVPManager::getInstance()->leavePVPZone( user );
			}

			if ( pvpZoneAlias != CAIAliasTranslator::Invalid )
			{
				CPVPManager::getInstance()->enterPVPZone( user, pvpZoneAlias );
			}

			user->setCurrentPVPZone( pvpZoneAlias );
		}

		// enter/leave outpost zones
		TAIAlias outpostAlias = COutpostManager::getInstance().getOutpostFromUserPosition( user );
		if ( outpostAlias != user->getCurrentOutpostZone() && !user->isDead() )
		{
			if ( user->getCurrentOutpostZone() != CAIAliasTranslator::Invalid )
			{
				COutpostManager::getInstance().leaveOutpostZone( user );
			}
			
			user->setCurrentOutpostZone( outpostAlias );
			
			if ( outpostAlias != CAIAliasTranslator::Invalid )
			{
				COutpostManager::getInstance().enterOutpostZone( user );
			}
		}
		
		if ( changed )
			user->setPlaces( places );

		// and stable
		// if the player is now in an unknown stable
		if( stable == NULL )
		{
			// disable this message because stables are already treated as places
			/*CPlace * oldStable = getPlaceFromId( user->getCurrentStable() );
			if (oldStable)
			{
				if( oldStable->getReported() )
				{
					params[0].Identifier = oldStable->getName();
					PHRASE_UTILITIES::sendDynamicSystemMessage(user->getEntityRowId(),"EGS_LEAVE_PLACE",params);
				}
			}*/

			user->setCurrentStable( 0xFFFF,0xFFFF);	
		}
		// check if player left old current stable for enter to another
		else if( user->getCurrentStable() != stable->getId() )
		{
			// disable this message because stables are already treated as places
			/*CPlace * oldStable = getPlaceFromId( user->getCurrentStable() );
			if (oldStable)
			{
				if( oldStable->getReported() )
				{
					params[0].Identifier = oldStable->getName();
					PHRASE_UTILITIES::sendDynamicSystemMessage(user->getEntityRowId(),"EGS_LEAVE_PLACE",params);
				}
			}
			if( stable->getReported() )
			{
				params[0].Identifier = stable->getName();
				PHRASE_UTILITIES::sendDynamicSystemMessage(user->getEntityRowId(),"EGS_ENTER_PLACE",params);
			}*/

			for ( uint i = 0; i < newPlacesSize; i++ )
			{
				if ( places[i]->isMainPlace() )
				{
					user->setCurrentStable( stable->getId(), places[i]->getId() );
					break;
				}
			}
			//  Now the VisitPlace missions are checked in CMissionManager::checkVisitPlaceMissions()
			//CMissionEventVisitPlace event(stable->getId() );
			//user->processMissionMultipleEvent(event);
		}

		// apply goo damage if needed
		user->applyGooDamage( gooDistance );
	//}
}// CZoneManager updateCharacterPosition

//-----------------------------------------------
// CZoneManager tickUpdate
//-----------------------------------------------
void CZoneManager::tickUpdate()
{
	// *** Update deposits at low frequency (each deposit is updated once per DepositUpdateFrequency (which is a period in game cycles, actually))
	// CPU is smoothed if there are more deposits than cycles in the period.
	uint32 nbDeposit = (uint32)_Deposits.size();
	if( ( (_NextDepositIndexUpdated != 0) || (CTickEventHandler::getGameCycle() - _SpreadUpdateLoopBeginTick ) >= DepositUpdateFrequency.get()) )
	{
		if ( _NextDepositIndexUpdated == 0 )
		{
			_SpreadUpdateLoopBeginTick = CTickEventHandler::getGameCycle();
		}
		uint32 i, nbDepositUpdatedByTick = (uint32 ) ( nbDeposit / DepositUpdateFrequency.get() ) + 1;
		for( i = _NextDepositIndexUpdated; i < _NextDepositIndexUpdated + nbDepositUpdatedByTick; ++i )
		{
			if( i < nbDeposit )
			{
				_Deposits[ i ]->lowFreqUpdate();
			}
		}
		
		if( i >= nbDeposit )
			_NextDepositIndexUpdated = 0;
		else
			_NextDepositIndexUpdated = i;
	}

	// *** Update the deposits that need an update for auto spawn
	std::set< CDeposit* >::iterator			itDeposit= _DepositNeedingAutoSpawnUpdate.begin();
	while(itDeposit!= _DepositNeedingAutoSpawnUpdate.end())
	{
		CDeposit	*deposit= *itDeposit;
		nlassert(deposit);
		deposit->autoSpawnUpdate();

		// remove the deposit from the set, and go next to update
		std::set< CDeposit* >::iterator		itNext= itDeposit;
		itNext++;
		_DepositNeedingAutoSpawnUpdate.erase(itDeposit);
		itDeposit= itNext;
	}

}// CZoneManager tickUpdate

//-----------------------------------------------
// CZoneManager dumpWorld
//-----------------------------------------------
void CZoneManager::dumpWorld(CLog & log)
{
	log.displayNL("%u continents", _Continents.size() );
	for (uint i = 0; i < _Continents.size(); i++ )
	{
		log.displayNL("CONTINENT %u : id=%u, name=%s", i, _Continents[i].getId(),_Continents[i].getName().c_str() );
		const std::vector< CRegion* > & regions =  _Continents[i].getRegions();
		for (uint j = 0; j < regions.size();j++ )
		{
			log.displayNL("      region %u : id=%u, name=%s",j, regions[j]->getId(),regions[j]->getName().c_str() );
			const std::vector< CPlace* > & places =  regions[j]->getPlaces();
			for (uint k = 0; k < places.size();k++ )
			{
				log.displayNL("            place %u : id=%u, name=%s", k, places[k]->getId(),places[k]->getName().c_str() );
			}
			log.displayNL("");          
			const std::vector< CDeposit* > & deposits =  regions[j]->getDeposits();
			log.displayNL("%u deposits", deposits.size() );
			//for (uint k = 0; k < deposits.size();k++ )
			//{
			//	log.displayNL("            deposits %u : id=%u", k, /*deposits[k]->getId()*/0, /*deposits[k]->getName().c_str()*/  );
			//}
		}

	}
}

//-----------------------------------------------
// CZoneManager dumpTpSpawnZones
//-----------------------------------------------
void CZoneManager::dumpTpSpawnZones(CLog & log)
{
	log.displayNL("%u tp spawn zones", _TpSpawnZones.size());
	for (uint i = 0; i < _TpSpawnZones.size(); i++)
	{
		log.displayNL("TP SPAWN ZONE %u : name=%s", i, _TpSpawnZones[i].getName().c_str());
	}
}

//-----------------------------------------------
// CZoneManager answerWhere
//-----------------------------------------------
void CZoneManager::answerWhere(const NLMISC::CEntityId & eId)
{
	///\todo nico manage building
	CCharacter * c = PlayerManager.getChar( eId );
	if (c )
	{
		c->setAfkState(false);
		CContinent * cont = getContinentFromId(c->getCurrentContinent());
		if ( !cont )
		{
			nlwarning("<CZoneManager answerWhere> invalid continent %u for entity %s",c->getCurrentContinent(),eId.toString().c_str());
			return;
		}
		CPlace * region = getPlaceFromId( c->getCurrentRegion() );
		if ( !region )
		{
			nlwarning("<CZoneManager answerWhere> invalid region %u for entity %s",c->getCurrentRegion(),eId.toString().c_str());
			return;
		}

		uint size = (uint)c->getPlaces().size();
		CPlace * place = NULL;
		for ( uint i = 0; i < size; i++ )
		{
			CPlace * placeTest = getPlaceFromId( c->getPlaces()[i] );
			nlassert( placeTest );
			if ( placeTest->isMainPlace() )
			{
				place = placeTest;
				break;
			}
		}
		
		STRING_MANAGER::TParam param;
		param.Type = STRING_MANAGER::place;
		if (place)
		{
			SM_STATIC_PARAMS_3(params, STRING_MANAGER::place, STRING_MANAGER::place, STRING_MANAGER::place);
			params[0].Identifier = cont->getName();
			params[1].Identifier = region->getName();
			params[2].Identifier = place->getName();
			PHRASE_UTILITIES::sendDynamicSystemMessage(TheDataset.getDataSetRow(eId),"EGS_ANSWER_WHERE",params);
		}
		else
		{
			SM_STATIC_PARAMS_2(params, STRING_MANAGER::place, STRING_MANAGER::place);
			params[0].Identifier = cont->getName();
			params[1].Identifier = region->getName();
			PHRASE_UTILITIES::sendDynamicSystemMessage(TheDataset.getDataSetRow(eId),"EGS_ANSWER_WHERE_NO_PLACE",params);
		}

		/*
		std::vector< NLMISC::CEntityId > bots;
		for ( uint i = 0; i < c->getPickedMissions().size(); i++ )
		{
			if ( c->getPickedMissions()[i] )
			{
				CStaticMission * mission = c->getPickedMissions()[i]->getTemplate();
				NLMISC::CEntityId bot;
				if ( CAIAliasTranslator::getInstance()->getEntityId(c->getPickedMissions()[i]->getRewardGiver(), bot ) )
				{
					uint  j = 0;
					for (; j < bots.size(); j++ )
					{
						if ( bots[j] == bot  )
							break;
					}
					if ( j == bots.size() )
						bots.push_back( bot );
				}
				for (uint j  = 0; j < mission->getSteps().size(); j++ )
				{
					mission->getSteps()[j]->addImpliedBots( bots );
				}
			}
		}
		if ( !bots.empty() )
		{
			CCharacter::sendMessageToClient( eId,"EGS_MISSION_DIR_INTRO" );
			double xUser = (double)c->getState().X;
			double yUser = (double)c->getState().Y;
			for ( uint i = 0; i < bots.size(); i++ )
			{
				CCreature * botPtr = CreatureManager.getCreature( bots[i] );
				if ( botPtr )
				{
					string botName;
					if ( CAIAliasTranslator::getInstance()->getNPCNameFromAlias( botPtr->getAlias(), botName ) )
					{	
						double dx = (double)botPtr->getState().X/1000.0-(double)xUser/1000.0;
						double dy = (double)botPtr->getState().Y/1000.0-(double)yUser/1000.0;
						double dist = sqrt(dx*dx+dy*dy);
						uint32 distshort = (uint16)dist;
						
						double angle = atan2 (dy, dx) + NLMISC::Pi;
						sint direction =(sint) floor( 0.5 + 8.0 * angle /(NLMISC::Pi) );
						direction = direction %16;
						
						static string txts[]=
						{
								"W",
								"WSW",
								"SW",
								"SSW",
								"S",
								"SSE",
								"SE",
								"ESE",
								"E",
								"ENE",
								"NE",
								"NNE",
								"N",
								"NNW",
								"NW",
								"WNW",
						};
						static string msgBot = ("EGS_MISSION_DIR_BOT");
						
						CMessage msgout("STATIC_STRING");
						msgout.serial( const_cast<CEntityId&>(eId) );
						std::set<CEntityId> empty;
						msgout.serialCont( empty );		
						msgout.serial( msgBot );
						msgout.serial( botName );
						msgout.serial( distshort );
						msgout.serial( txts[direction] );
						sendMessageViaMirror( "IOS", msgout );
					}
				}
			}
		}
		*/
	}
	else
	{
		nlwarning( "<CZoneManager answerWhere>Invalid char %s",eId.toString().c_str() );
	}
}


//-----------------------------------------------
// CZoneManager harvestDeposit
//-----------------------------------------------
/*void CZoneManager::harvestDeposit(CCharacter * user)
{
	nlassert(user);
	vector<CDeposit*> deposits;
	nlerror( "getDepositsUnderUser(user,deposits);" );
	if ( deposits.size() )
	{
		uint nbMps = 0;
		for (uint i = 0; i < deposits.size(); i++ )
			nbMps+= deposits[i]->getContentSize();
		uint result = RandomGenerator.rand( nbMps - 1 );
		nbMps = 0;
		for (uint i = 0; i < deposits.size(); i++ )
		{
			if ( result <  nbMps + deposits[i]->getContentSize() )
			{
				nlerror( "deposits[i]->harvestInfo(user->getId(),user->getHarvestInfos());" );
				break;
			}
			nbMps += deposits[i]->getContentSize();
		}
	}
	if (user->getHarvestInfos().Sheet == CSheetId::Unknown)
	{
		// no raw material found, return
		return;
	}

	user->getHarvestInfos().EndCherchingTime = CTickEventHandler::getGameCycle() + DepositSearchTime;
	user->setCurrentAction( CLIENT_ACTION_TYPE::Harvest, user->getHarvestInfos().EndCherchingTime );

}// CZoneManager harvestDeposit
*/


//-----------------------------------------------
// CZoneManager displayAllDeposit
//-----------------------------------------------
void CZoneManager::dumpDeposits( NLMISC::CLog & log, const std::string& depName, bool extendedInfo )
{
	bool displayAll = (depName == "ALL");
	for( uint i = 0; i < _Deposits.size(); i++ )
	{
		if ( _Deposits[i] )
		{
			if ( displayAll || (_Deposits[i]->name() == depName) )
				_Deposits[i]->displayContent( &log, extendedInfo );
		}
		else
			log.displayNL( "===== Deposit %d is NULL" );
	}
}// CZoneManager displayAllDeposit


//-----------------------------------------------
// CZoneManager getStartPointVector
//-----------------------------------------------
vector<CZoneManager::CStartPoint> CZoneManager::getStartPointVector( uint16 startPointIdx ) const
{
	if ( startPointIdx >= _StartPoints.size() )
	{
		nlwarning("bad start point index %u ( count %u )",startPointIdx , _StartPoints.size() );
		return vector<CStartPoint>();
	}

	return _StartPoints[startPointIdx];
}// CZoneManager getStartPointVector


//-----------------------------------------------
// Get the ecotype zone under the position.
// If not found, a NULL pointer is returned.
//-----------------------------------------------
ECOSYSTEM::EECosystem CZoneManager::getEcotype( const NLMISC::CVector& pos )
{
	// The ecotypes must not be overlapped: only the first one found is returned
	for ( CEcotypeZones::iterator it=_EcotypeZones.begin(); it!=_EcotypeZones.end(); ++it )
	{
		CEcotypeZone *ecotypeZone = (*it);
		if ( ecotypeZone->contains( pos ) )
		{
			return ecotypeZone->ecotype();
		}
	}
	return ECOSYSTEM::unknown;
}


//-----------------------------------------------
// Clear ecotype information
//-----------------------------------------------
void CZoneManager::clearEcotypes()
{
	for ( CEcotypeZones::iterator iez=_EcotypeZones.begin(); iez!=_EcotypeZones.end(); ++iez )
	{
		delete (*iez);
	}
	_EcotypeZones.clear();
}


//-----------------------------------------------
// deposit auto spawn
//-----------------------------------------------
void	CZoneManager::registerDepositToAutoSpawnUpdate(CDeposit *deposit)
{
	if(deposit)
		_DepositNeedingAutoSpawnUpdate.insert(deposit);
}
void	CZoneManager::unregisterDepositToAutoSpawnUpdate(CDeposit *deposit)
{
	if(deposit)
		_DepositNeedingAutoSpawnUpdate.erase(deposit);
}



// dump the world organisation
NLMISC_COMMAND(dumpWorld," dump the world organisation","")
{
	if (args.size() == 0)
	{
		CZoneManager::getInstance().dumpWorld(log);
		return true;
	}
	return false;
}

NLMISC_COMMAND(dumpTpSpawnZones, "dump the tp spawn zones", "")
{
	if (args.size() == 0)
	{
		CZoneManager::getInstance().dumpTpSpawnZones(log);
		return true;
	}
	return false;
}