// 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/>.



// misc
#include "nel/misc/command.h"
#include "nel/misc/vector_2d.h"
#include "nel/misc/vectord.h"
#include "nel/misc/hierarchical_timer.h"
#include "nel/misc/path.h"
#include "nel/misc/sheet_id.h"
//
#include "nel/ligo/primitive.h"
#include "nel/ligo/ligo_config.h"
//
// game share
#include "game_share/tick_event_handler.h"
#include "game_share/ryzom_version.h"
#include "game_share/mirrored_data_set.h"
#include "game_share/ryzom_mirror_properties.h"
#include "game_share/mode_and_behaviour.h"
#include "game_share/synchronised_message.h"
#include "server_share/used_continent.h"
#include "server_share/pet_interface_msg.h"
#include "game_share/utils.h"
//
// r2 share
#include "server_share/r2_variables.h"
//
// local
#include "gpm_service.h"
#include "world_position_manager.h"
#include "vision_delta_manager.h"
#include "client_messages.h"
#include "sheets.h"

#ifdef NL_OS_WINDOWS
#	define NOMINMAX
#	include <windows.h>
#endif // NL_OS_WINDOWS

// force admin module to link in
extern void admin_modules_forceLink();
void foo()
{
	admin_modules_forceLink();
}


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

CGlobalPositionManagerService *pCGPMS= NULL;

NLLIGO::CLigoConfig LigoConfig;


/*
 * Get var from config file
 */
// Sint version
bool	getVarFromConfigFile(CConfigFile &cf, const string &name, sint32 &variable, sint32 defaultValue = 0)
{
	CConfigFile::CVar	*ptr = cf.getVarPtr(name);
	bool	success;
	variable = ((success = (ptr != NULL)) ? ptr->asInt() : defaultValue);
	return success;
}
// Uint version
bool	getVarFromConfigFile(CConfigFile &cf, const string &name, uint32 &variable, uint32 defaultValue = 0)
{
	CConfigFile::CVar	*ptr = cf.getVarPtr(name);
	bool	success;
	variable = ((success = (ptr != NULL)) ? ptr->asInt() : defaultValue);
	return success;
}
// Bool version
bool	getVarFromConfigFile(CConfigFile &cf, const string &name, bool &variable, bool defaultValue = false)
{
	CConfigFile::CVar	*ptr = cf.getVarPtr(name);
	bool	success;
	variable = ((success = (ptr != NULL)) ? (ptr->asInt() != 0) : defaultValue);
	return success;
}
// Float version
bool	getVarFromConfigFile(CConfigFile &cf, const string &name, float &variable, float defaultValue = 0.0f)
{
	CConfigFile::CVar	*ptr = cf.getVarPtr(name);
	bool	success;
	variable = ((success = (ptr != NULL)) ? ptr->asFloat() : defaultValue);
	return success;
}
// Double version
bool	getVarFromConfigFile(CConfigFile &cf, const string &name, double &variable, double defaultValue = 0)
{
	CConfigFile::CVar	*ptr = cf.getVarPtr(name);
	bool	success;
	variable = ((success = (ptr != NULL)) ? ptr->asDouble() : defaultValue);
	return success;
}
// String version
bool	getVarFromConfigFile(CConfigFile &cf, const string &name, string &variable, const string &defaultValue = string(""))
{
	CConfigFile::CVar	*ptr = cf.getVarPtr(name);
	bool	success;
	variable = ((success = (ptr != NULL)) ? ptr->asString() : defaultValue);
	return success;
}

#define GET_VAR_FROM_CF(var, def) getVarFromConfigFile(ConfigFile, #var, var, def);

/*-----------------------------------------------------------------*\
						cbConnection
\*-----------------------------------------------------------------*/
void cbConnection( const std::string &serviceName, NLNET::TServiceId serviceId, void *arg )
{
} // cbConnection //


TGameCycle TickStopGameCycle = 0;

/*-----------------------------------------------------------------*\
						cbDisconnection
\*-----------------------------------------------------------------*/
void cbDisconnection( const std::string &serviceName, NLNET::TServiceId serviceId, void *arg )
{
	if( serviceName == string("TICKS") )
	{
		TickStopGameCycle = CTickEventHandler::getGameCycle();
		nlinfo( "tick stop -> %u", TickStopGameCycle );
	}

	// remove all entities created by this service
	//CWorldPositionManager::removeAiVisionEntitiesForService( serviceId );
	if (!IsRingShard)
	{
		CWorldPositionManager::triggerUnsubscribe(serviceId);
	}

} // cbDisconnection //


void cbEGSConnection( const std::string &serviceName, NLNET::TServiceId serviceId, void *arg )
{
// The follwoing code commented out by Sadge because no refference could be found to reception of this message
//	// transmit the names of the used continents to the EGS
//	try
//	{
//		CUsedContinent::TUsedContinentCont continents = CUsedContinent::instance().getContinents();
//
//		vector< string > continentsNames;
//		for (uint i=0; i<continents.size(); ++i)
//		{
//			continentsNames.push_back(continents[i].ContinentName);
//		}
///*		CConfigFile::CVar& cvUsedContinents = pCGPMS->ConfigFile.getVar("UsedContinents");
//		for ( uint i = 0; (sint)i<cvUsedContinents.size(); ++i)
//		{
//			if (cvUsedContinents.asString(i) != "")
//			{
//				continentsNames.push_back(cvUsedContinents.asString(i));
//			}
//		}
//*/
//		CMessage msgout("USED_CONTINENTS");
//		msgout.serialCont( continentsNames ),
//		CUnifiedNetwork::getInstance()->send( "EGS", msgout );
//	}
//	catch(EUnknownVar &)
//	{
//		nlwarning("<cbEGSConnection> UsedContinents not found, no continent used");
//	}

	// send ESG all IA creatures
	//CWorldPositionManager::sendAgentsToEGS();

} // cbEGSConnection //

/*-----------------------------------------------------------------*\
						EVSConnection
\*-----------------------------------------------------------------*/
void cbEVSConnection( const std::string &serviceName, NLNET::TServiceId serviceId, void *arg )
{
	EVSUp = true;
}

/*-----------------------------------------------------------------*\
						EVSDisconnection
\*-----------------------------------------------------------------*/
void cbEVSDisconnection( const std::string &serviceName, NLNET::TServiceId serviceId, void *arg )
{
	EVSUp = false;
}


/*--------------------------------------------------------------*\
						cbSync()
\*--------------------------------------------------------------*/
void cbSync()
{
	// update World Position Manager time
	if( !TickStopGameCycle )
	{
		if (!IsRingShard) { CWorldPositionManager::setCurrentTick( CTickEventHandler::getGameCycle() ); }
	}
	nlinfo( "Sync -> %u", CTickEventHandler::getGameCycle() );
} // cbSync //



/*
 * Crash Callback
 */
string	crashCallback()
{
	return CWorldPositionManager::getPlayersPosHistory();
}



/****************************************************************\
 ************** callback table for input message ****************
\****************************************************************/
TUnifiedCallbackItem CbArray[] =
{
	{ "CB_UNUSED",					NULL }
};


/*
 * Initialisation 2
 */
void	cbMirrorIsReady( CMirror *mirror )
{
	pCGPMS->initMirror();
}


/****************************************************************\
							init()
\****************************************************************/
// init the service
void CGlobalPositionManagerService::init()
{
	setVersion (RYZOM_VERSION);

	// keep pointer on class
	pCGPMS = this;

	// set update time out
	setUpdateTimeout(100);

	CUnifiedNetwork::getInstance()->setServiceUpCallback( string("*"), cbConnection, 0);
	CUnifiedNetwork::getInstance()->setServiceUpCallback( "EGS", cbEGSConnection, 0);
	CUnifiedNetwork::getInstance()->setServiceUpCallback( "EVS", cbEVSConnection, 0);

	CUnifiedNetwork::getInstance()->setServiceDownCallback( string("*"), cbDisconnection, 0);
	CUnifiedNetwork::getInstance()->setServiceDownCallback( "EVS", cbEVSDisconnection, 0);


	uint32		WorldMapSizeX;
	uint32		WorldMapSizeY;
	uint32		VisionDistance;
	uint32		PrimitiveMaxSize;
	uint32		NbWorldImages;
	bool		LoadPacsPrims;
	bool		LoadPacsCol;

	// init the class transport system
	TRANSPORT_CLASS_REGISTER (CGPMPlayerPrivilegeInst);

	GET_VAR_FROM_CF(CheckPlayerSpeed, true);
	GET_VAR_FROM_CF(Verbose, false);

	GET_VAR_FROM_CF(WorldMapSizeX, 2100);
	GET_VAR_FROM_CF(WorldMapSizeY, 2970);
	GET_VAR_FROM_CF(VisionDistance, 250000);
	GET_VAR_FROM_CF(PrimitiveMaxSize, 8);
	GET_VAR_FROM_CF(NbWorldImages, 31);

	GET_VAR_FROM_CF(LoadPacsCol, false);
	GET_VAR_FROM_CF(LoadPacsPrims, true);


	CSheets::init();

	// World Position Manager init
	if (!IsRingShard)
	{
		CWorldPositionManager::init(WorldMapSizeX, WorldMapSizeY, VisionDistance, PrimitiveMaxSize, (uint8)NbWorldImages, LoadPacsPrims, LoadPacsCol);
	}

	// Init ligo
	if (!LigoConfig.readPrimitiveClass ("world_editor_classes.xml", false))
	{
		// Should be in l:\leveldesign\world_editor_files
		nlerror ("Can't load ligo primitive config file world_editor_classes.xml");
	}
/*	// read the continent name translator
	map<string, string>	translator;
	{
		CConfigFile::CVar *v = IService::getInstance()->ConfigFile.getVarPtr("ContinentNameTranslator");
		if (v)
		{
			for (sint i=0; i<v->size()/2; ++i)
			{
				string s1, s2;
				s1 = v->asString(i*2);
				s2 = v->asString(i*2+1);
				translator[s1] = s2;
			}
		}
	}
*/

	// todo: r2 GPMS doesn't read pacs for now - this will have to be fixed later
	if (!IsRingShard)
	{
		// init continents
		try
		{
			CUsedContinent::TUsedContinentCont continents = CUsedContinent::instance().getContinents();
	//		CConfigFile::CVar& cvUsedContinents = ConfigFile.getVar("UsedContinents");
	//		uint	i;
	//		for (i=0; (sint)i<cvUsedContinents.size(); ++i)
	//			if (cvUsedContinents.asString(i) != "")
			for (uint i=0; i<continents.size(); ++i)
			{
				string name = continents[i].ContinentName;
				name = CUsedContinent::instance().getPhysicalContinentName(name);
	//			if (translator.find(name) != translator.end())
	//				name = translator[name];
	//			CWorldPositionManager::loadContinent(cvUsedContinents.asString(i), cvUsedContinents.asString(i), i);
				CWorldPositionManager::loadContinent(name, continents[i].ContinentName, continents[i].ContinentInstance);
			}
		}
		catch(EUnknownVar &)
		{
			nlwarning("<CGlobalPositionManagerService::init> UsedContinents not found, no continent used");
		}
	}

	NLLIGO::Register();

	CMessages::init();
	CClientMessages::init();

	//
	if (!IsRingShard) { CWorldPositionManager::initPatatManager(); }

	// Init the mirror system
	vector<string> datasetNames;
	datasetNames.push_back( "fe_temp" );
	Mirror.init( datasetNames, cbMirrorIsReady, gpmsUpdate, cbSync );
	Mirror.setServiceMirrorUpCallback( "EGS", cbEGSConnection, 0);

	setCrashCallback(crashCallback);

	if (IsRingShard)
	{
		// setup the R2 Vision object and move checker object
		pCGPMS->RingVisionDeltaManager=new CVisionDeltaManager;
		pCGPMS->RingVisionUniverse= new R2_VISION::CUniverse;
		pCGPMS->RingVisionUniverse->registerVisionDeltaManager(RingVisionDeltaManager);
		pCGPMS->MoveChecker= new CMoveChecker;
	}

} // init //


/*
 * Init after the mirror init
 */
void CGlobalPositionManagerService::initMirror()
{
/*
	// Allow to add a few entities manually (using the command addEntity)
	Mirror.declareEntityTypeOwner( RYZOMID::player, 10 );
	Mirror.declareEntityTypeOwner( RYZOMID::npc, 500 );
*/

	DataSet = &(Mirror.getDataSet("fe_temp"));
	DataSet->declareProperty( "X", PSOReadWrite | PSONotifyChanges, "X" );		// group notification on X
	DataSet->declareProperty( "Y", PSOReadWrite | PSONotifyChanges, "X" );		// group notification on X
	DataSet->declareProperty( "Z", PSOReadWrite | PSONotifyChanges, "X" );		// group notification on X
	DataSet->declareProperty( "Theta", PSOReadWrite | PSONotifyChanges, "X" );	// group notification on X
	DataSet->declareProperty( "AIInstance", PSOReadOnly | PSONotifyChanges );
	DataSet->declareProperty( "WhoSeesMe", PSOReadOnly | PSONotifyChanges );
	DataSet->declareProperty( "LocalX", PSOReadWrite );
	DataSet->declareProperty( "LocalY", PSOReadWrite );
	DataSet->declareProperty( "LocalZ", PSOReadWrite );
	DataSet->declareProperty( "TickPos", PSOReadWrite );
	DataSet->declareProperty( "Sheet", PSOReadWrite );
	DataSet->declareProperty( "Mode", PSOReadOnly /*| PSONotifyChanges*/ );
	DataSet->declareProperty( "Behaviour", PSOReadOnly );
	DataSet->declareProperty( "Cell", PSOReadWrite );
	DataSet->declareProperty( "VisionCounter", PSOReadWrite );
	DataSet->declareProperty( "CurrentRunSpeed", PSOReadOnly );
	DataSet->declareProperty( "CurrentWalkSpeed", PSOReadOnly );
	DataSet->declareProperty( "RiderEntity", PSOReadOnly );
	DataSet->declareProperty( "Fuel", PSOReadOnly );
	initRyzomVisualPropertyIndices( *DataSet );

	Mirror.setNotificationCallback( IsRingShard? CGlobalPositionManagerService::ringShardProcessMirrorUpdates: CGlobalPositionManagerService::processMirrorUpdates );
}


/****************************************************************\
							update()
\****************************************************************/
// main loop
bool CGlobalPositionManagerService::update()
{
	return true;
} // update //


void CGlobalPositionManagerService::_checkAddCharacterToRingAIInstance(sint32 aiInstance)
{
	TCharactersPerAIInstance::iterator it= _CharactersPerAIInstance.find(aiInstance);
	if (it==_CharactersPerAIInstance.end())
	{
		// this is the first character to be added to this instance so initialise it
		_CharactersPerAIInstance[aiInstance]=1;
		nlinfo("Creating new AIInstance in ring vision universe: %d",aiInstance);
		pCGPMS->RingVisionUniverse->createInstance(aiInstance,0);
	}
	else
	{
		++it->second;
		nldebug("Increasing number of entities in aiInstance %d to %d",aiInstance,it->second);
	}
}

void CGlobalPositionManagerService::_checkRemoveCharacterFromRingAIInstance(sint32 aiInstance)
{
	TCharactersPerAIInstance::iterator it= _CharactersPerAIInstance.find(aiInstance);
	BOMB_IF(it==_CharactersPerAIInstance.end(),NLMISC::toString("BUG: Can't find ai instance %d to remove character from",aiInstance),return);

	// decrement count of characters in ai instance and remove the instance if its empty
	--it->second;
	if (it->second<1)
	{
		// this was the last character in the instance so delete it
		nlinfo("removing AIInstance because last character has just left: %d",aiInstance);
		_CharactersPerAIInstance.erase(it);
		pCGPMS->RingVisionUniverse->removeInstance(aiInstance);
	}
	else
	{
		nldebug("Decreasing number of entities in aiInstance %d to %d",aiInstance,it->second);
	}
}

void CGlobalPositionManagerService::ringShardProcessMirrorUpdates()
{
	// Process entities added to mirror
	TheDataset.beginAddedEntities();
	TDataSetRow entityIndex = TheDataset.getNextAddedEntity();
	while ( entityIndex != LAST_CHANGED )
	{
		// lookup stats for the entity in the mirror
		const NLMISC::CEntityId &eid= TheDataset.getEntityId( entityIndex );
		CMirrorPropValueRO<sint32> aiInstance	( TheDataset, entityIndex, DSPropertyAI_INSTANCE );
		CMirrorPropValueRO<sint32> x			( TheDataset, entityIndex, DSPropertyPOSX );
		CMirrorPropValueRO<sint32> y			( TheDataset, entityIndex, DSPropertyPOSY );
		CMirrorPropValueRO<TYPE_WHO_SEES_ME> whoSeesMe	( TheDataset, entityIndex, DSPropertyWHO_SEES_ME );
		R2_VISION::TInvisibilityLevel invisibility= (R2_VISION::TInvisibilityLevel)(whoSeesMe&((1<<R2_VISION::NUM_WHOSEESME_BITS)-1));

		// increment count of number of characters in AIInstance, instanciating new instance if required
		pCGPMS->_checkAddCharacterToRingAIInstance(aiInstance);

		// if we have a player then set them up in the move checker
		if (eid.getType()==RYZOMID::player)
		{
			pCGPMS->MoveChecker->teleport(entityIndex, x, y, CTickEventHandler::getGameCycle());
		}

		// add entity to the ring vision universe object
		pCGPMS->RingVisionUniverse->addEntity(entityIndex,aiInstance,x,y,invisibility,eid.getType()==RYZOMID::player);
		entityIndex = TheDataset.getNextAddedEntity();
	}
	TheDataset.endAddedEntities();

	// Process entities removed from mirror
	TheDataset.beginRemovedEntities();
	CEntityId *id;
	entityIndex = TheDataset.getNextRemovedEntity( &id );
	while ( entityIndex != LAST_CHANGED )
	{
		// check that the character being removed exists in the r2VisionUniverse and get hold of their AIInstance
		const R2_VISION::SUniverseEntity* theEntity= pCGPMS->RingVisionUniverse->getEntity(entityIndex);
		BOMB_IF(theEntity==NULL,"Failed to identify the character that the mirror tells us is being removed",continue);
		uint32 aiInstance= theEntity->AIInstance;

		// remove entity from the ring vision universe object
		pCGPMS->RingVisionUniverse->removeEntity(entityIndex);

		// decrement the count of characters in the given instance and remove it if need be
		pCGPMS->_checkRemoveCharacterFromRingAIInstance(aiInstance);

		// prepare to iterate...
		entityIndex = TheDataset.getNextRemovedEntity( &id );
	}
	TheDataset.endRemovedEntities();

	// Process properties changed and notified in the mirror
	TPropertyIndex propIndex;
	TheDataset.beginChangedValues();
	TheDataset.getNextChangedValue( entityIndex, propIndex );
	while ( entityIndex != LAST_CHANGED )
	{
		if (propIndex == DSPropertyAI_INSTANCE)
		{
			// lookup stats for the entity in the mirror
			sint32 aiInstance=	CMirrorPropValueRO<sint32>( TheDataset, entityIndex, DSPropertyAI_INSTANCE );
			sint32 x= CMirrorPropValueRO<sint32>( TheDataset, entityIndex, DSPropertyPOSX );
			sint32 y= CMirrorPropValueRO<sint32>( TheDataset, entityIndex, DSPropertyPOSY );
			CMirrorPropValueRO<TYPE_WHO_SEES_ME> whoSeesMe ( TheDataset, entityIndex, DSPropertyWHO_SEES_ME );
			R2_VISION::TInvisibilityLevel invisibility= (R2_VISION::TInvisibilityLevel)(whoSeesMe&((1<<R2_VISION::NUM_WHOSEESME_BITS)-1));

			// if we have a player then remove them from the move checker
			if (TheDataset.getEntityId(entityIndex).getType()==RYZOMID::player)
			{
				pCGPMS->MoveChecker->teleport(entityIndex, x, y, CTickEventHandler::getGameCycle());
			}

			// check that the character being teleported exists in the r2VisionUniverse and get hold of their old AIInstance
			const R2_VISION::SUniverseEntity* theEntity= pCGPMS->RingVisionUniverse->getEntity(entityIndex);
			BOMB_IF(theEntity==NULL, "Failed to identify the character that the mirror tells us is being removed",
				TheDataset.getNextChangedValue( entityIndex, propIndex ); continue);
			sint32 oldAiInstance= theEntity->AIInstance;

			// check whether this is a real teleportation or just a move
			if (oldAiInstance==aiInstance)
			{
				// the aiInstance hasn't changed so just perform a move
				// note: this happens systematicaly on appearance of a new entity - the ai instance is
				// setup once via code that manages appearance of new entities in mirror and it's setup
				// again here... the coordinates are probably the same too but since I can't guarantee
				// it I prefer to let the code do its stuff
				pCGPMS->RingVisionUniverse->setEntityPosition(entityIndex,x,y);
			}
			else
			{
				// make sure the instance we're teleporting to exists
				pCGPMS->_checkAddCharacterToRingAIInstance(aiInstance);

				// teleport entity within the ring vision universe
				pCGPMS->RingVisionUniverse->teleportEntity(entityIndex,aiInstance,x,y,invisibility);

				// if this was the last entity in their old instance then get rid of the instance
				pCGPMS->_checkRemoveCharacterFromRingAIInstance(oldAiInstance);
			}
		}
		else if (propIndex == DSPropertyPOSX)
		{
			// lookup stats for the entity in the mirror
			CMirrorPropValueRO<sint32> x ( TheDataset, entityIndex, DSPropertyPOSX );
			CMirrorPropValueRO<sint32> y ( TheDataset, entityIndex, DSPropertyPOSY );

			// update the cell
			CMirrorPropValue1DS<TYPE_CELL> cell ( TheDataset, entityIndex, DSPropertyCELL );
			uint32	cx = (uint16) ( + x()/CWorldPositionManager::getCellSize() );
			uint32	cy = (uint16) ( - y()/CWorldPositionManager::getCellSize() );

			cell = (cx<<16) + cy;

			// move entity within the ring vision universe
			pCGPMS->RingVisionUniverse->setEntityPosition(entityIndex,x,y);
		}
		else if (propIndex == DSPropertyWHO_SEES_ME)
		{
			// lookup stats for the entity in the mirror
			CMirrorPropValueRO<TYPE_WHO_SEES_ME> whoSeesMe ( TheDataset, entityIndex, DSPropertyWHO_SEES_ME );

			uint32 visibilityValue= ((uint32)whoSeesMe==0)? R2_VISION::WHOSEESME_INVISIBLE_DM: ((uint32)(whoSeesMe+1)==0)? R2_VISION::WHOSEESME_VISIBLE_MOB: (uint32)whoSeesMe;

			// apply the change to the entity
			pCGPMS->RingVisionUniverse->setEntityInvisibilityInfo(entityIndex, visibilityValue);
		}
		TheDataset.getNextChangedValue( entityIndex, propIndex );
	}
	TheDataset.endChangedValues();
}

void CGlobalPositionManagerService::processMirrorUpdates()
{
	// Process entities added to mirror
	TheDataset.beginAddedEntities();
	TDataSetRow entityIndex = TheDataset.getNextAddedEntity();
	while ( entityIndex != LAST_CHANGED )
	{
		//nldebug( "%u: OnAddEntity %d", CTickEventHandler::getGameCycle(), entityIndex );
		CWorldPositionManager::onAddEntity( entityIndex );
		entityIndex = TheDataset.getNextAddedEntity();
	}
	TheDataset.endAddedEntities();

	// Process entities removed from mirror
	TheDataset.beginRemovedEntities();
	CEntityId *id;
	entityIndex = TheDataset.getNextRemovedEntity( &id );
	while ( entityIndex != LAST_CHANGED )
	{
		//nldebug( "%u: OnRemoveEntity %d", CTickEventHandler::getGameCycle(), entityIndex );
		CWorldPositionManager::onRemoveEntity(entityIndex);
		entityIndex = TheDataset.getNextRemovedEntity( &id );
	}
	TheDataset.endRemovedEntities();

	// Process properties changed and notified in the mirror
	TPropertyIndex propIndex;
	TheDataset.beginChangedValues();
	TheDataset.getNextChangedValue( entityIndex, propIndex );
	while ( entityIndex != LAST_CHANGED )
	{
		//nldebug( "%u: OnPosChange %d", CTickEventHandler::getGameCycle(), entityIndex );
		//nlassert( propIndex == DSPropertyPOSX ); // (X, Y, Z, Theta) use "group notification" with prop X (and are the only ones with notification)

		if (propIndex == DSPropertyPOSX)
		{
			// TEMP: while we don't handle all by entity indices, we need to test if the entityId has been notified (added)
			CWorldEntity	*entity = CWorldPositionManager::getEntityPtr(entityIndex);
			if (entity)
			{
				if (entity->getType() == CWorldEntity::Player && entity->CheckMotion)
				{
					// this is a player and has to check motion
					// then reset the player position according to the mirror pos
					H_AUTO(gpmsUpdateResetServerPosition);
					CWorldPositionManager::resetPrimitive(entity);
					entity->PosInitialised = true;
				}
				else
				{
					H_AUTO(gpmsUpdateServerPosition);
					//nlinfo("Update %s pos: %d,%d,%d - %d", entity->Id.toString().c_str(), entity->X(), entity->Y(), entity->Z(), entity->X.getWriterServiceId());
					CWorldPositionManager::updateEntityPosition(entity);
				}
			}
		}
		//nldebug( "Pos changed from mirror E%d", entityIndex  );
		TheDataset.getNextChangedValue( entityIndex, propIndex );
	}
	TheDataset.endChangedValues();
}


/****************************************************************\
						gpmsUpdate()
\****************************************************************/
void CGlobalPositionManagerService::gpmsUpdate()
{
	if ( ! pCGPMS->Mirror.mirrorIsReady() )
		return;

	H_AUTO(gpmsUpdate);

	// process vision update for non-ring shards
	if (!IsRingShard)
	{
		// also update internal clock (increase tick counter by one)
		H_TIME(PositionManagerUpdate, CWorldPositionManager::update(););

		uint	i;
		for (i=0; i<pCGPMS->Tracked.size(); ++i)
			CWorldPositionManager::displayEntity(CWorldPositionManager::getEntityIndex(pCGPMS->Tracked[i]));
	}

	// process vision update for ring shards
	if (IsRingShard)
	{
		H_AUTO(ringVisionUpdate);
		pCGPMS->RingVisionUniverse->update();
		pCGPMS->RingVisionDeltaManager->update();
	}

} // gpmsUpdate //


/****************************************************************\
							release()
\****************************************************************/
void CGlobalPositionManagerService::release()
{
	CMessages::release();

	if (!IsRingShard)
	{
		CWorldPositionManager::release();
	}

	CSheets::release();

}// release //




NLNET_SERVICE_MAIN( CGlobalPositionManagerService, "GPMS", "gpm_service", 0, CbArray, "", "" );