/////////////////////////////////////////////////////////////////////////////////
//
// FILE :    script.cpp
// PURPOSE : Scripting and stuff.
// AUTHOR :  Graeme & Obbe.
//			 anyway)
// CREATED : 12-11-99
//
/////////////////////////////////////////////////////////////////////////////////

#include "script/script.h"

// Rage headers
#include "audioengine/engine.h"
#include "system/param.h"
#include "vector/quaternion.h"

// Framework headers
#include "fwnet/nettypes.h"
#include "fwscene/stores/mapdatastore.h"
#include "fwscript/scriptInterface.h"

// Security headers
#include "security/ragesecwinapi.h"

// Game headers
#include "animation/AnimScene/AnimSceneManager.h"
#include "audio/scriptaudioentity.h"
#include "camera/CamInterface.h"
#include "control/replay/replay.h"
#include "cutscene/CutSceneManagerNew.h"
#include "debug/BugstarIntegration.h"
#include "event/EventErrors.h"
#include "event/EventGroup.h"
#include "event/EventNetwork.h"
#include "frontend/landing_page/LandingPageArbiter.h"
#include "frontend/landing_page/LandingPageConfig.h"
#include "Network/Events/NetworkEventTypes.h"
#include "Network/Network.h"
#include "Network/NetworkInterface.h"
#include "Network/Live/NetworkTelemetry.h"
#include "Objects/DummyObject.h"
#include "Objects/object.h"
#include "peds/ped.h"
#include "peds/Ped.h"
#include "scene/MapChange.h"
#include "scene/ExtraContentDefs.h"
#include "scene/worldpoints.h"
#include "scene/world/GameWorld.h"
#include "script/commands_apps.h"
#include "script/commands_audio.h"
#include "script/commands_brains.h"
#include "script/commands_camera.h"
#include "script/commands_cutscene.h"
#include "script/commands_datafile.h"
#include "script/commands_debug.h"
#include "script/commands_decorator.h"
#include "script/commands_extrametadata.h"
#include "script/commands_entity.h"
#include "script/commands_event.h"
#include "script/commands_gamestream.h"
#include "script/commands_gang.h"
#include "script/commands_hud.h"
#include "script/commands_interiors.h"
#include "script/commands_itemsets.h"
#include "script/commands_landingpage.h"
#include "script/commands_law.h"
#include "script/commands_localization.h"
#include "script/commands_misc.h"
#include "script/commands_money.h"
#include "script/commands_object.h"
#include "script/commands_pad.h"
#include "script/commands_path.h"
#include "script/commands_ped.h"
#include "script/commands_player.h"
#include "script/commands_physics.h"
#include "script/commands_script.h"
#include "script/commands_security.h"
#include "script/commands_shapetest.h"
#include "script/commands_socialclub.h"
#include "script/commands_stats.h"
#include "script/commands_streaming.h"
#include "script/commands_task.h"
#include "script/commands_vehicle.h"
#include "script/commands_volume.h"
#include "script/commands_weapon.h"
#include "script/commands_fire.h"
#include "script/commands_zone.h"
#include "script/commands_graphics.h"
#include "script/commands_clock.h"
#include "script/commands_network.h"
#include "script/commands_lobby.h"
#include "script/commands_inventory.h"
#include "script/commands_water.h"
#include "script/commands_xml.h"
#include "script/commands_ny.h"
#include "script/commands_dlc.h"
#include "script/commands_recording.h"
#include "script/commands_replay.h"
#include "script/commands_netshopping.h"
#include "script/commands_savemigration.h"
#include "script/script_areas.h"
#include "script/script_brains.h"
#include "script/script_cars_and_peds.h"
#include "script/script_debug.h"
#include "script/script_hud.h"
#include "script/handlers/GameScriptEntity.h"
#include "script/Handlers/GameScriptResources.h"
#include "script/script_helper.h"
#include "script/streamedscripts.h"
#include "script/script_channel.h"
#include "script/ScriptMetadataManager.h"
#include "security/plugins/apicheckplugin.h"
#include "streaming/streaming.h"
#include "system/controlMgr.h"
#include "system/exception.h"
#include "system/FileMgr.h"
#include "system/hangdetect.h"
#include "task/Scenario/info/ScenarioInfoManager.h"
#include "vfx/misc/MovieMeshManager.h"
#include "control/replay/replay.h"

SCRIPT_OPTIMISATIONS ()
NETWORK_OPTIMISATIONS ()

PARAM(startupscript, "[script] load and run this script in place of startup.sc");

PARAM(scriptInstructionLimit, "[script] set the maximum number of instructions per frame to something other than the default of 1,000,000");

PARAM(scriptProtectGlobals, "[script] protects scripts global memory outide of the script update process");

//Define a script assert channel
RAGE_DEFINE_CHANNEL(script)
RAGE_DEFINE_SUBCHANNEL(script,hud)
RAGE_DEFINE_SUBCHANNEL(script,camera)

CScriptsForBrains CTheScripts::ms_ScriptsForBrains;
CScriptBrainDispatcher CTheScripts::ms_ScriptBrainDispatcher;

bool CTheScripts::ms_bPlayerIsOnAMission = false;
bool CTheScripts::ms_bPlayerIsOnARandomEvent = false;
u32 CTheScripts::ms_Frack = 0xEBEFC45E;
parTree* CTheScripts::ms_pXmlTree = NULL;
parTreeNode* CTheScripts::ms_pCurrentXmlTreeNode = NULL;
bool CTheScripts::ms_bUpdatingScriptThreads = false;
bool CTheScripts::ms_bPlayerIsRepeatingAMission = false;
bool CTheScripts::ms_bPlayerIsInAnimalForm = false;
bool CTheScripts::ms_bIsInDirectorMode = false;
bool CTheScripts::ms_directorModeAvailable = true;
s32 CTheScripts::ms_customMPHudColor = HUD_COLOUR_INVALID;

CScriptPatrol CTheScripts::ms_ScriptPatrol;

CMissionReplayStats CTheScripts::ms_MissionReplayStats;

CHiddenObjects CTheScripts::ms_HiddenObjects;

atBinaryMap<CDLCScript*,u32> CDLCScript::ms_scripts;


#if __DEV
static bool bDisplayUsedScriptResources = false;
#endif

int CTheScripts::ms_NumberOfMiniGamesInProgress = 0;

#if !__PPU
bool CTheScripts::ms_bSinglePlayerRestoreHasJustOccurred = false;
#endif

#if __BANK
f32 CTheScripts::sm_fTimeFadedOut = 0.0f;
#endif	//	__BANK

#if !__FINAL
bool CTheScripts::ms_bScriptLaunched = false;
#endif //!__FINAL

sysTimer CTheScripts::sm_ScriptTimer;

char CTheScripts::ms_ContentIdOfCurrentUGCMission[RLUGC_MAX_CONTENTID_CHARS];

bool CTheScripts::ms_bAllowGameToPauseForStreaming = true;
bool CTheScripts::ms_bScenarioPedsCanBeGrabbedByScript = false;
bool CTheScripts::ms_bCodeRequestedAutosave = false;
bool CTheScripts::ms_bProcessingTheScriptsDuringGameInit = false;
CGameScriptHandlerMgr CTheScripts::ms_ScriptHandlerMgr(&CNetwork::GetBandwidthManager());
bool CTheScripts::ms_bKillingAllScriptThreads = false;
CScriptOpList CTheScripts::ms_scriptOpList;

static int s_InstructionLimit = 0;

GEN9_STANDALONE_ONLY(CTheScripts::InitState CTheScripts::ms_initState = CTheScripts::InitState::Uninitialized);

bool CTheScripts::GetClosestObjectCB(CEntity* pEntity, void* data)
{
	Assert(pEntity);
	ClosestObjectDataStruct* pClosestObjectData = reinterpret_cast<ClosestObjectDataStruct*>(data);

	if (pClosestObjectData->bCheckModelIndex && (pEntity->GetModelIndex() != pClosestObjectData->ModelIndexToCheck) )
	{
		return true;
	}

	if (pClosestObjectData->bCheckStealableFlag)
	{
		scriptAssertf(pEntity->GetIsTypeObject(), "%s:GetClosestObjectCB - Object should be a real object (not a dummy) if you're checking if it's stealable. This is a code problem (probably not a script problem)", CTheScripts::GetCurrentScriptNameAndProgramCounter());
		if (pEntity->GetIsTypeObject())
		{
			CObject *pObj = (CObject *) pEntity;
			if (pObj->m_nObjectFlags.bIsStealable == false)
			{
				return true;
			}
		}
	}

	if(!((1 << pEntity->GetOwnedBy()) & pClosestObjectData->nOwnedByMask))
	{
		return true;
	}

	Vector3 DiffVector = VEC3V_TO_VECTOR3(pEntity->GetTransform().GetPosition()) - pClosestObjectData->CoordToCalculateDistanceFrom;
	float ObjDistanceSquared = DiffVector.Mag2();
	if (ObjDistanceSquared < pClosestObjectData->fClosestDistanceSquared)
	{
		pClosestObjectData->pClosestObject = pEntity;
		pClosestObjectData->fClosestDistanceSquared = ObjDistanceSquared;
	}

	return true;
}


bool CTheScripts::CountMissionEntitiesInAreaCB(CEntity* pEntity, void* data)
{
	int* pNumberOfMissionEntities = reinterpret_cast<int*>(data);

	if (IsMissionEntity(pEntity))
		(*pNumberOfMissionEntities)++;

	return(true);
}

bool CTheScripts::IsMissionEntity(CEntity * pEntity)
{
	Assert(pEntity);
	switch (pEntity->GetType())
	{
	case ENTITY_TYPE_VEHICLE :
		if (((CVehicle *)pEntity)->PopTypeIsMission())
		{
			return true;
		}
		break;

	case ENTITY_TYPE_PED :
		if (((CPed *)pEntity)->PopTypeIsMission())
		{
			return true;
		}
		break;

	case ENTITY_TYPE_OBJECT :
		if (((CObject *)pEntity)->GetOwnedBy() == ENTITY_OWNEDBY_SCRIPT)	//	|| (((CObject *)pEntity)->GetOwnedBy() == MISSION_BRAIN_OBJECT) )
		{
			return true;
		}
		break;

	default :
		break;
	}
	return false;
}

extern scrCommandHash<scrCmd> s_CommandHash;
typedef void (*regFunction) ();

void CTheScripts::ScrambleAndRegister()
{
	atArray<regFunction> sourceArray;
	sourceArray.Reserve(100);

	sourceArray.Push(netshopping_commands::SetupScriptCommands);
	sourceArray.Push(script_commands::SetupScriptCommands);
	sourceArray.Push(object_commands::SetupScriptCommands);
	sourceArray.Push(xml_commands::SetupScriptCommands);
	sourceArray.Push(volume_commands::SetupScriptCommands);
	sourceArray.Push(brain_commands::SetupScriptCommands);
	sourceArray.Push(replay_commands::SetupScriptCommands);
	sourceArray.Push(weapon_commands::SetupScriptCommands);
	sourceArray.Push(apps_commands::SetupScriptCommands);
	sourceArray.Push(ped_commands::SetupScriptCommands);
	sourceArray.Push(fire_commands::SetupScriptCommands);
	sourceArray.Push(clock_commands::SetupScriptCommands);
	sourceArray.Push(interior_commands::SetupScriptCommands);
	sourceArray.Push(pad_commands::SetupScriptCommands);
	sourceArray.Push(graphics_commands::SetupScriptCommands);
	sourceArray.Push(inventory_commands::SetupScriptCommands);
	sourceArray.Push(localization_commands::SetupScriptCommands);
	sourceArray.Push(player_commands::SetupScriptCommands);
	sourceArray.Push(physics_commands::SetupScriptCommands);
	sourceArray.Push(entity_commands::SetupScriptCommands);
	sourceArray.Push(task_commands::SetupScriptCommands);
	sourceArray.Push(zone_commands::SetupScriptCommands);
	sourceArray.Push(misc_commands::SetupScriptCommands);
	sourceArray.Push(streaming_commands::SetupScriptCommands);
	sourceArray.Push(socialclub_commands::SetupScriptCommands);
	sourceArray.Push(law_commands::SetupScriptCommands);
	sourceArray.Push(audio_commands::SetupScriptCommands);
	sourceArray.Push(gta_commands::SetupScriptCommands);
	sourceArray.Push(path_commands::SetupScriptCommands);
	sourceArray.Push(itemsets_commands::SetupScriptCommands);
	sourceArray.Push(datafile_commands::SetupScriptCommands);
	sourceArray.Push(dlc_commands::SetupScriptCommands);
	sourceArray.Push(cutscene_commands::SetupScriptCommands);
	sourceArray.Push(stats_commands::SetupScriptCommands);
	sourceArray.Push(shapetest_commands::SetupScriptCommands);
	sourceArray.Push(recording_commands::SetupScriptCommands);
	sourceArray.Push(extrametadata_commands::SetupScriptCommands);
	sourceArray.Push(camera_commands::SetupScriptCommands);
	sourceArray.Push(vehicle_commands::SetupScriptCommands);
	sourceArray.Push(lobby_commands::SetupScriptCommands);
	sourceArray.Push(event_commands::SetupScriptCommands);
	sourceArray.Push(water_commands::SetupScriptCommands);
	sourceArray.Push(money_commands::SetupScriptCommands);
	sourceArray.Push(network_commands::SetupScriptCommands);
	sourceArray.Push(debug_commands::SetupScriptCommands);
	sourceArray.Push(gang_commands::SetupScriptCommands);
	sourceArray.Push(decorator_commands::SetupScriptCommands);
	sourceArray.Push(hud_commands::SetupScriptCommands);
	sourceArray.Push(savemigration_commands::SetupScriptCommands);
	sourceArray.Push(landingpage_commands::SetupScriptCommands);
	sourceArray.Push(security_commands::SetupScriptCommands);

	// scramble the function array
	u32 size = sourceArray.GetCount();
	for(u32 scrambleCount = 0; scrambleCount < 1000; scrambleCount++)
	{
		u32 randomIndex = fwRandom::GetRandomNumberInRange(0, size);

		regFunction temp = sourceArray[randomIndex];
		sourceArray.DeleteFast(randomIndex);
		sourceArray.Push(temp);
	}

	// execute all the functions in the scambled array
	for(u32 i = 0; i < sourceArray.GetCount(); i++)
	{
		sourceArray[i]();
	}
	ApiCheckPlugin_StopNativeHash();

	s_CommandHash.RegistrationComplete(true);
}

void CTheScripts::RegisterScriptCommands()
{
#if  1
	ScrambleAndRegister();
#else  //
	//@@: location CTHESCRIPTS_REGISTER_SCRIPTCOMMANDS
	netshopping_commands::SetupScriptCommands();
	script_commands::SetupScriptCommands();
	object_commands::SetupScriptCommands();
	xml_commands::SetupScriptCommands();
	volume_commands::SetupScriptCommands();
	brain_commands::SetupScriptCommands();
	replay_commands::SetupScriptCommands();
	weapon_commands::SetupScriptCommands();
	apps_commands::SetupScriptCommands();
	ped_commands::SetupScriptCommands();
	fire_commands::SetupScriptCommands();
	clock_commands::SetupScriptCommands();
	interior_commands::SetupScriptCommands();
	pad_commands::SetupScriptCommands();
	graphics_commands::SetupScriptCommands();
	inventory_commands::SetupScriptCommands();
	localization_commands::SetupScriptCommands();
	player_commands::SetupScriptCommands();
	physics_commands::SetupScriptCommands();
	entity_commands::SetupScriptCommands();
	task_commands::SetupScriptCommands();
	zone_commands::SetupScriptCommands();
	misc_commands::SetupScriptCommands();
	streaming_commands::SetupScriptCommands();
	socialclub_commands::SetupScriptCommands();
	law_commands::SetupScriptCommands();
	audio_commands::SetupScriptCommands();
	gta_commands::SetupScriptCommands();
	path_commands::SetupScriptCommands();
	itemsets_commands::SetupScriptCommands();
	datafile_commands::SetupScriptCommands();
	dlc_commands::SetupScriptCommands();
	cutscene_commands::SetupScriptCommands();
	stats_commands::SetupScriptCommands();
	shapetest_commands::SetupScriptCommands();
	recording_commands::SetupScriptCommands();
	extrametadata_commands::SetupScriptCommands();
	camera_commands::SetupScriptCommands();
	vehicle_commands::SetupScriptCommands();
	lobby_commands::SetupScriptCommands();
	event_commands::SetupScriptCommands();
	water_commands::SetupScriptCommands();
	money_commands::SetupScriptCommands();
	network_commands::SetupScriptCommands();
	debug_commands::SetupScriptCommands();
	gang_commands::SetupScriptCommands();
	decorator_commands::SetupScriptCommands();
	hud_commands::SetupScriptCommands();
	savemigration_commands::SetupScriptCommands();
	landingpage_commands::SetupScriptCommands();
	security_commands::SetupScriptCommands();
#endif // 1
}


void CTheScripts::GtaFaultHandler(const char *ASSERT_ONLY(CauseOfFault), scrThread*, scrThreadFaultID faultType)
{
	if (GetCurrentGtaScriptThread())
	{
		sErrorScriptID scriptID;
		scriptID.m_scriptNameHash =	GetCurrentGtaScriptThread()->m_HashOfScriptName;

		switch(faultType)
		{
		case THREAD_ARRAY_OVERFLOW:

			GetEventScriptErrorsGroup()->Add(CEventErrorArrayOverflow(scriptID));
			break;
		case THREAD_STACK_OVERFLOW:
			GetEventScriptErrorsGroup()->Add(CEventErrorStackOverflow(scriptID));
			break;
		case THREAD_INSTRUCTION_COUNT_OVERFLOW:
			GetEventScriptErrorsGroup()->Add(CEventErrorInstructionLimit(scriptID));
			break;
		case THREAD_UNKNOWN_ERROR_TYPE:
		default:
			GetEventScriptErrorsGroup()->Add(CEventErrorUnknownError(scriptID));
			break;
		}

#if __ASSERT
		//	display the program counter of the current script here
		char ErrorString[1024];
		sprintf(ErrorString, "%s : Program Counter = %d - Check the .scd file\n", GetCurrentScriptName(), GetCurrentGtaScriptThread()->GetThreadPC());
		scriptAssertf(0, "%s:%s", ErrorString, CauseOfFault);
#endif
	}
	else
	{
		scriptAssertf(0, "%s:%s", "Unknown script name", CauseOfFault);
	}
}


// KS - WR 156 - added stacksize argument
scrThreadId CTheScripts::GtaStartNewThreadOverride(const char *progname,const void *argStruct,int argStructSize, int stackSize)
{
	if (!progname || (strlen(progname) == 0) )
	{
		if (GetCurrentGtaScriptThread())
		{
			scriptAssertf(0, "%s:CTheScripts::GtaStartNewThreadOverride - trying to start a script without passing in a script name", GetCurrentScriptNameAndProgramCounter());
		}
		else
		{
			scriptAssertf(0, "CTheScripts::GtaStartNewThreadOverride - trying to start a script without passing in a script name");
		}
	}
	scrProgramId pid = scrProgram::IsCompiledAndResident(progname);
	if (!pid)
	{
		strLocalIndex id = g_StreamedScripts.FindSlot(progname);
		scriptAssertf(id != -1, "%s:Script doesn't exist", progname);
		if (id == -1)
			return THREAD_INVALID;

		scriptAssertf(g_StreamedScripts.Get(id), "%s:Script is not in memory", progname);

		scriptDisplayf("About to start script thread %s", progname);
		pid = g_StreamedScripts.GetProgramId(id.Get());
	}

	return GtaStartNewThreadWithProgramId(pid, argStruct,argStructSize, stackSize, progname);
}

scrThreadId CTheScripts::GtaStartNewThreadWithNameHashOverride(atHashValue hashOfProgName,const void *argStruct,int argStructSize, int stackSize)
{
	if (hashOfProgName.GetHash() == 0)
	{
		if (GetCurrentGtaScriptThread())
		{
			scriptAssertf(0, "%s:CTheScripts::GtaStartNewThreadWithNameHashOverride - the hash of the script to be started is 0", GetCurrentScriptNameAndProgramCounter());
		}
		else
		{
			scriptAssertf(0, "CTheScripts::GtaStartNewThreadWithNameHashOverride - the hash of the script to be started is 0");
		}
	}

//	I'm not sure what to do with IsCompiledAndResident. It seems to be using a different hash function - scrComputeHash
	scrProgramId pid = srcpidNONE;	//	 = scrProgram::IsCompiledAndResident(progname);
//	if (!pid)
	{
		strLocalIndex id = g_StreamedScripts.FindSlotFromHashKey(hashOfProgName.GetHash());
		scriptAssertf(id != -1, "Script with hash %u doesn't exist", hashOfProgName.GetHash());
		if (id == -1)
			return THREAD_INVALID;

		scriptAssertf(g_StreamedScripts.Get(id), "Script with hash %u is not in memory", hashOfProgName.GetHash());

		scriptDisplayf("About to start script thread with hash %u", hashOfProgName.GetHash());
		pid = g_StreamedScripts.GetProgramId(id.Get());
	}

	char debugStringContainingHash[32];
	formatf(debugStringContainingHash, "0x%x", hashOfProgName.GetHash());
	return GtaStartNewThreadWithProgramId(pid, argStruct,argStructSize, stackSize, debugStringContainingHash);
}

scrThreadId CTheScripts::GtaStartNewThreadWithProgramId(scrProgramId progId,const void *argStruct,int argStructSize,int stackSize, const char* OUTPUT_ONLY(progname) )
{
	scrThreadId threadId = scrThread::CreateThread(progId, argStruct, argStructSize, stackSize);

#if !__NO_OUTPUT
	if (threadId == THREAD_INVALID)
	{
#if __BANK
		GtaThread::DisplayAllRunningScripts(false);
#endif	//	__BANK

#if __ASSERT
		scriptAssertf(0, "%s:Failed to create a new thread (stack %d)", progname, stackSize);
#else
		scriptErrorf("%s:Failed to create a new thread (stack %d)", progname, stackSize);
#endif	//	__ASSERT
	}
#endif	//	!__NO_OUTPUT

	GtaThread *pNewOne = static_cast<GtaThread *> (scrThread::GetThread(threadId));
	if (pNewOne == NULL)
	{
#if __ASSERT
		scriptAssertf(0, "CTheScripts::GtaStartNewThreadWithProgramId - Could not get a pointer to the new thread %s", progname);
#else
		scriptErrorf("CTheScripts::GtaStartNewThreadWithProgramId - Could not get a pointer to the new thread %s", progname);
#endif	//	__ASSERT

		return THREAD_INVALID;
	}
	pNewOne->Initialise();

	ms_ScriptHandlerMgr.RegisterScript(*pNewOne);

#if __BANK
	if (CScriptDebug::ShouldThisScriptBeDebugged(progname))
	{
		GtaThread::AllocateDebuggerForThread(threadId);
	}

	CScriptDebug::SetComboBoxOfThreadNamesNeedsUpdated(true);
#endif

#if BACKTRACE_ENABLED
	sysException::BacktraceNotifyScriptLaunched((u32)progId, fwTimer::GetSystemTimeInMilliseconds());
#endif // BACKTRACE_ENABLED

    scriptDisplayf("Started new script thread %s(%d) with stack size %d", progname, threadId, stackSize);
	return threadId;
}

#if !__PPU
void CTheScripts::SetSinglePlayerRestoreHasJustOccurred(bool bRestoreJustOccurred)
{
	ms_bSinglePlayerRestoreHasJustOccurred = bRestoreJustOccurred;
}

bool CTheScripts::GetSinglePlayerRestoreHasJustOccurred()
{
	return ms_bSinglePlayerRestoreHasJustOccurred;
}
#endif	//	!__PPU


void CScriptPatrol::Init()
{
    bPatrolRouteOpen = false;
    ScriptPatrolNodeIndex = 0;
    ScriptPatrolLinkIndex = 0;
    ScriptPatrolRouteHash = 0;

//	fwIplPatrolNode ScriptPatrolNodes[MAX_NUMBER_OF_PATROL_NODES];
//	fwIplPatrolLink ScriptPatrolLinks[MAX_NUMBER_OF_PATROL_LINKS];
//	int ScriptPatrolNodeIDs[MAX_NUMBER_OF_PATROL_NODES];
}

void CScriptPatrol::OpenPatrolRoute(const char* RouteName)
{
	if (SCRIPT_VERIFY((strnicmp ("miss_", RouteName,5) == 0), "CScriptPatrol::OpenPatrolRoute - Script patrol routes name must start with miss_"))
	{
		if (SCRIPT_VERIFY(bPatrolRouteOpen == false, "CScriptPatrol::OpenPatrolRoute - Patrol route must be closed before being opened"))
		{
			ScriptPatrolRouteHash = atStringHash(RouteName);
			bPatrolRouteOpen  = true;
			ScriptPatrolNodeIndex = 0;
			ScriptPatrolLinkIndex = 0;
		}
	}
}

void CScriptPatrol::ClosePatrolRoute()
{
	bPatrolRouteOpen = false;
}

void CScriptPatrol::AddPatrolNode(int NodeId, const char* NodeType, Vector3 &vNodePos, Vector3 &vNodeHeading, int Duration)
{
	if (!vNodeHeading.IsZero())
	{
		vNodeHeading = vNodeHeading - vNodePos;
	}
	
	int iDuration = (int) Duration / 1000;

	// Check if the node type references a valid scenario right away, rather than waiting for
	// a more cryptic assert from the tasks.
	u32 nodeTypeHash = atStringHash(NodeType);
	scriptAssertf(!nodeTypeHash || SCENARIOINFOMGR.GetScenarioIndex(nodeTypeHash, false) >= 0,
			"%s:ADD_PATROL_NODE - failed for find scenario '%s'.",
			CTheScripts::GetCurrentScriptNameAndProgramCounter(), NodeType);

	if (SCRIPT_VERIFY(bPatrolRouteOpen == true, "CScriptPatrol::AddPatrolNode- Patrol route must be open before adding nodes"))
	{
		if (SCRIPT_VERIFY((ScriptPatrolNodeIndex <= MAX_NUMBER_OF_PATROL_NODES - 1) , "CScriptPatrol::AddPatrolNode - Patrol route can have no more than 16 nodes"))
		{
			ScriptPatrolNodes[ScriptPatrolNodeIndex].x = vNodePos.x;
			ScriptPatrolNodes[ScriptPatrolNodeIndex].y = vNodePos.y;
			ScriptPatrolNodes[ScriptPatrolNodeIndex].z = vNodePos.z;
			ScriptPatrolNodes[ScriptPatrolNodeIndex].headingX = vNodeHeading.x;
			ScriptPatrolNodes[ScriptPatrolNodeIndex].headingY = vNodeHeading.y;
			ScriptPatrolNodes[ScriptPatrolNodeIndex].headingZ = vNodeHeading.z;
			ScriptPatrolNodes[ScriptPatrolNodeIndex].nodeTypeHash = nodeTypeHash;
			ScriptPatrolNodes[ScriptPatrolNodeIndex].routeNameHash = ScriptPatrolRouteHash;
			ScriptPatrolNodes[ScriptPatrolNodeIndex].duration = iDuration;
			ScriptPatrolNodeIDs[ScriptPatrolNodeIndex] = NodeId;
			ScriptPatrolNodeIndex++;
		}
	}
}

void CScriptPatrol::AddPatrolLink(int NodeID1, int NodeID2)
{
	if (SCRIPT_VERIFY(bPatrolRouteOpen == true, "CScriptPatrol::AddPatrolLink - Patrol route must be open before adding nodes"))
	{
		if (SCRIPT_VERIFY(ScriptPatrolLinkIndex <= MAX_NUMBER_OF_PATROL_LINKS -1, "CScriptPatrol::AddPatrolLink - Patrol links must be less than 64"))
		{
			ScriptPatrolLinks[ScriptPatrolLinkIndex].node1 = NodeID1;
			ScriptPatrolLinks[ScriptPatrolLinkIndex].node2 = NodeID2;
			ScriptPatrolLinkIndex++;
		}
	}
}

void CScriptPatrol::CreatePatrolRoute()
{
	if (SCRIPT_VERIFY(bPatrolRouteOpen == false, "CScriptPatrol::CreatePatrolRoute - Must close the nodes before adding the route"))	
	{		
		CScriptResource_PatrolRoute patrolRoute(ScriptPatrolRouteHash, ScriptPatrolNodes, ScriptPatrolNodeIDs, ScriptPatrolNodeIndex, ScriptPatrolLinks, ScriptPatrolLinkIndex, 0);
		CTheScripts::GetCurrentGtaScriptHandler()->RegisterScriptResource(patrolRoute);
	}
}

void CTheScripts::Init(unsigned initMode)
{
	USE_MEMBUCKET(MEMBUCKET_SCRIPT);
    //@@: location CTHESCRIPTS_INIT_INIT_ENTRY_POINT

	GtaThread::StaticInit(initMode);

    if(initMode == INIT_CORE)
    {
		GEN9_STANDALONE_ONLY(Assertf(ms_initState == InitState::Uninitialized, "Unexpected state %d, should be %d", ms_initState, InitState::Uninitialized));
		GEN9_STANDALONE_ONLY(ms_initState = InitState::Initialized);

        RAGE_TRACK(CTheScripts);
		
#if ENABLE_SCRIPT_GLOBALS_HEAP
		const int globalsHeapSize = fwConfigManager::GetInstance().GetSizeOfPool(atHashString("scrGlobals", 0xC780FC5), CONFIGURED_FROM_FILE);
		sysMemStartPool();
		u8* heapMem = rage_new u8[globalsHeapSize];
		sysMemEndPool();
		scrProgram::InitGlobalsHeap(heapMem, globalsHeapSize);
#endif // ENABLE_SCRIPT_GLOBALS_HEAP

	    scrProgram::InitClass();
		scrThread::InitClass();
	    GtaThread::AllocateThreads();
		ms_ScriptHandlerMgr.Init();
		scriptInterface::Init(ms_ScriptHandlerMgr);

		CGameScriptResource::Init(initMode);
		//@@: location CTHESCRIPTS_INIT_INIT_SCRIPTSMETADATAMANAGER
		CScriptMetadataManager::Init();

	    scrThread::AppFaultHandler = GtaFaultHandler;
	    scrThread::StartNewThreadOverride = GtaStartNewThreadOverride;
		scrThread::StartNewThreadWithNameHashOverride = GtaStartNewThreadWithNameHashOverride;

#if !__PPU
	    ms_bSinglePlayerRestoreHasJustOccurred = false;
#endif

	    ms_bProcessingTheScriptsDuringGameInit = false;

	    // register commands

		//@@: location CTHESCRIPTS_INIT_REGISTER_BUILTIN_COMMANDS
	    scrThread::RegisterBuiltinCommands();

		RegisterScriptCommands();

#if SCRIPT_DEBUGGING
		// Process the -nativetrace command line argument to update actions for specified natives
	    scrThread::ParseNativeTraceCommandLine();
#endif

	    ms_pXmlTree = NULL;
	    ms_pCurrentXmlTreeNode = NULL;
	    ms_bUpdatingScriptThreads = false;

		s_InstructionLimit = 0;
#if !__FINAL
		if (PARAM_scriptInstructionLimit.Get())
		{
			PARAM_scriptInstructionLimit.Get(s_InstructionLimit);
		}
#endif	//	!__FINAL

#if RSG_PC && ENABLE_SCRIPT_TAMPER_CHECKER
		// Add the listener
		CScriptGlobalTamperChecker::Initialize();
#endif
    }

#if GEN9_STANDALONE_ENABLED
	// We want to run this exactly once during INIT_CORE for first launch. If the game session is
	//   subsequently shut down, we want to run this again when it is rebuilt during INIT_SESSION.
    if(ms_initState == InitState::Initialized)
#else
	if (initMode == INIT_SESSION)
#endif // GEN9_STANDALONE_ENABLED
    {
		GEN9_STANDALONE_ONLY(ms_initState = InitState::Running);

#if __DEV
	    g_StreamedScripts.ValidateAllScripts();
#endif

	    scriptAssertf (ms_pXmlTree== NULL, "CTheScripts::Init - XmlNodeTree is not Null");
	    ms_pXmlTree = NULL;
	    ms_pCurrentXmlTreeNode = NULL;
	    ms_bUpdatingScriptThreads = false;

	    //patrol routes
		ms_ScriptPatrol.Init();

	    ms_ScriptsForBrains.Init();
	    ms_ScriptBrainDispatcher.Init();

#if __DEV
	    bDisplayUsedScriptResources = false;
#endif

	    ms_bPlayerIsOnAMission = false;
		ms_bPlayerIsOnARandomEvent = false;
		ms_bPlayerIsRepeatingAMission = false;

	    ms_NumberOfMiniGamesInProgress = 0;

		ms_HiddenObjects.Init();

	    ms_bAllowGameToPauseForStreaming = true;

	    ms_bScenarioPedsCanBeGrabbedByScript = false;

			ms_bCodeRequestedAutosave = false;

		ms_bKillingAllScriptThreads = false;

	    ms_bProcessingTheScriptsDuringGameInit = false;

#if __BANK
		sm_fTimeFadedOut = 0.0f;
#endif	//	__BANK

#if !__FINAL
		ms_bScriptLaunched = false;
#endif //!__FINAL

		sm_ScriptTimer.Reset();

		SetContentIdOfCurrentUGCMission("");

		static const int kDefaultItemSetBufferSize = 128;		// May want to override this to be much larger through the configuration file, RDR2 needed 2048. Memory per unit should be 4 byets.
		const int itemSetBufferSize = fwConfigManager::GetInstance().GetSizeOfPool(ATSTRINGHASH("ItemSetBuffer", 0x04e2adf9b), kDefaultItemSetBufferSize);
		CItemSetManager::InitClass(itemSetBufferSize);
		
		LaunchStartupScript();
    }
	//@@: location CTHESCRIPTS_INIT_INITIALIZE_SCRIPT_SHAPE_TEST_MANAGER
	CScriptShapeTestManager::Init(initMode);
	//@@: location CTHESCRIPTS_INIT_INITIALIZE_MISSION_REPLAY_STATS_INIT
	ms_MissionReplayStats.Init(initMode);
}

void CTheScripts::LaunchStartupScript()
{
//	if (!bLoadingAPreviouslySavedGame)
    {
	    strLocalIndex mainScriptId = strLocalIndex(-1);

		// Gen9 Landing Page: There is now a pre-startup script that runs before the game session exists.
		//                    The -startupscript commandline param is delayed until the game session is created,
		//                    then it is loaded in script by landing_pre_startup.
#if GEN9_LANDING_PAGE_ENABLED
		const char *pScriptName = "landing_pre_startup";
#else // GEN9_LANDING_PAGE_ENABLED
		const char *pScriptName = CFileMgr::IsGameInstalled() ? "startup" : "startup_install";
		NOTFINAL_ONLY(PARAM_startupscript.Get(pScriptName));
#endif // GEN9_LANDING_PAGE_ENABLED

#if !__FINAL
		ms_bScriptLaunched = true;
#endif //!__FINAL

		mainScriptId = g_StreamedScripts.FindSlot(pScriptName);

        if(mainScriptId != -1)
		{
		    g_StreamedScripts.StreamingRequest(mainScriptId, STRFLAG_DONTDELETE);
		    CStreaming::LoadAllRequestedObjects();

			if (g_StreamedScripts.HasObjectLoaded(mainScriptId))
			{
#if EXECUTABLE_SCRIPTS
				// Load all of the precompiled controller scripts now.  (multiple scripts per PRX/DLL now)
				// We need to do this after we've registered all script commands, and also after all globals
				// have been registered as well.
				// See x:\gta5\script\dev\singleplayer\make_controllers.bat and build_controllers.bat.
				scrProgram::RegisterBinary("controllers");
#endif	// EXECUTABLE_SCRIPTS
				scrThreadId NewScrThreadId = scrThread::CreateThread(g_StreamedScripts.GetProgramId(mainScriptId.Get()), NULL, 0, GtaThread::GetDefaultStackSize());

				scrThread *pNewScriptThread = scrThread::GetThread(NewScrThreadId);
				if (pNewScriptThread)
				{
					GtaThread *pNewGtaThread = (GtaThread*) pNewScriptThread;

					pNewGtaThread->Initialise();

					ms_ScriptHandlerMgr.RegisterScript(*pNewScriptThread);

#if __BANK
					if (CScriptDebug::ShouldThisScriptBeDebugged(pNewScriptThread->GetScriptName()))
					{
						GtaThread::AllocateDebuggerForThread(NewScrThreadId);
					}
#endif
				}

				g_StreamedScripts.ClearRequiredFlag(mainScriptId.Get(), STRFLAG_DONTDELETE);
			}
			else
			{
				Quitf(ERR_SCR_LAUNCH_1,"CTheScripts::LaunchStartupScript - the %s script has not loaded despite LoadAllRequestedObjects() being called", pScriptName);
			}
	    }
		else
		{
			Quitf(ERR_SCR_LAUNCH_2,"CTheScripts::LaunchStartupScript - failed to find a script with the name %s in the script.rpf", pScriptName);
		}
    }
}

//
// name:		CTheScripts::Shutdown
// description:	
void CTheScripts::Shutdown(unsigned shutdownMode)
{
    if(shutdownMode == SHUTDOWN_CORE)
    {
		GEN9_STANDALONE_ONLY(ms_initState = InitState::Uninitialized);

		// shutdown script event queues
		GetEventScriptErrorsGroup()->Shutdown();
		GetEventScriptAIGroup()->Shutdown();
		GetEventScriptNetworkGroup()->Shutdown();

		g_ScriptAudioEntity.StopStream();
		ms_ScriptHandlerMgr.Shutdown();
        g_StreamedScripts.Shutdown();
		CScriptMetadataManager::Shutdown();
		GtaThread::DeallocateThreads();
	    scrProgram::ShutdownClass();
		scriptInterface::Shutdown();
	}
    else if(shutdownMode == SHUTDOWN_SESSION)
    {
		// Inform the script engine that it will need to relaunch scripts if the game session is initialised
		GEN9_STANDALONE_ONLY(ms_initState = InitState::Initialized);

		ms_bKillingAllScriptThreads = true;
		scrThread::KillAllThreads();
		ms_bKillingAllScriptThreads = false;

		CItemSetManager::ShutdownClass();
		g_ScriptAudioEntity.StopStream();
		g_StreamedScripts.ShutdownLevel();
		ms_HiddenObjects.UndoHiddenObjects();

		CScriptHud::Shutdown(shutdownMode);
		
		ms_scriptOpList.Flush();

		CGameScriptResource::Shutdown(shutdownMode);

#if ENABLE_SCRIPT_GLOBALS_HEAP
		ASSERT_ONLY(scrProgram::AssertGlobalsHeapEmpty();)
#endif // ENABLE_SCRIPT_GLOBALS_HEAP
    }

	CScriptShapeTestManager::Shutdown(shutdownMode);
}

/////////////////////////////////////////////////////////////////////////////////
// FUNCTION : Update
// PURPOSE :  Called by the main update loop.
/////////////////////////////////////////////////////////////////////////////////
void 
CTheScripts::Update()
{
}

bool CTheScripts::ShouldBeProcessed()
{
	if ( (fwTimer::IsGamePaused()) && (fwTimer::ShouldScriptsBePaused()) )
	{
		return false;
	}

//	Graeme - 14.06.10 - I had to comment this out to allow the scripts to run for one frame during initialisation
//	if(CGame::IsChangingSessionState())
//	{	// If the network connection is lost then a message is displayed telling the player this and waiting
//	for A to be pressed. It's probably a bad idea to continue processing the scripts while a session restart is pending.
//	This return will stop any scripts running until the session has ended and a new one has started.
//		return false;
//	}

	// scripts are only processed when the game is performing a full update/render or HTML is being displayed
	// or the player is on the player settings screen in a network game
	// or the scripts are processing for one frame during the initialisation phase
	// or the Gen9 landing page is displayed before the game session is initialized
	if(!CGame::ShouldDoFullUpdateRender() 
		&& !NetworkInterface::IsGameInProgress()
		&& !GetProcessingTheScriptsDuringGameInit()
		GEN9_LANDING_PAGE_ONLY(&& (!CLandingPageArbiter::IsLandingPageActive() || CGame::IsSessionInitialized()))
		)
	{
		return false;
	}

	ReFrack();

	// Don't process the scripts with a replay going on.
#if GTA_REPLAY
	if (CReplayMgr::IsEditModeActive() && !CReplayMgr::ShouldUpdateScripts())
	{
		return false;
	}
#endif

	return true;
}

/////////////////////////////////////////////////////////////////////////////////
// FUNCTION : Process
// PURPOSE :  Wrapper for InternalProcess so we can protect script globals from 
//			  Tampering on PC MP
/////////////////////////////////////////////////////////////////////////////////
void CTheScripts::Process(void)
{
#if RSG_PC && ENABLE_SCRIPT_TAMPER_CHECKER
	//////////////////////////////////////////////////////////////////////////
	// PC only - check for memory-tampering in script globals
	static bool s_bReportedPlayer = false;	
#if !__FINAL
	static bool s_bProtectMemory = true;
	if(PARAM_scriptProtectGlobals.Get())
	{
		s_bProtectMemory = true;
	}
#endif

	int page = -1;
	bool isMultiplayer = NetworkInterface::IsAnySessionActive() && NetworkInterface::IsGameInProgress();
	if (
#if !__FINAL
		s_bProtectMemory && 
#endif
		!CPauseMenu::IsActive() && CScriptGlobalTamperChecker::CurrentGlobalsDifferFromPreviousFrame(page))
	{
		if ( !s_bReportedPlayer && isMultiplayer )
		{
			s_bReportedPlayer = true;
			RageSecPluginGameReactionObject obj(REACT_GAMESERVER, GENERIC_GAME_ID, 0x20C8C138, 0x611E42B9, 0x23346609);
			rageSecGamePluginManager::GetRageSecGameReactionObjectQueue()->Push(obj);
		}
	}


	{   //unchecked scope on PC only
		CScriptGlobalTamperChecker::UncheckedScope uncheckedScope;	
#endif	//RSG_PC

		InternalProcess();

#if RSG_PC && ENABLE_SCRIPT_TAMPER_CHECKER		
	} // end unchecked scope on PC
	CScriptGlobalTamperChecker::Update();
#if !__FINAL
	if(s_bProtectMemory)
#endif
	{
#if		__BANK
		if(CScriptDebug::GetFakeTampering())
		{
			CScriptGlobalTamperChecker::FakeTamper(0);
		}
#endif //__BANK
	}
#endif

}

/////////////////////////////////////////////////////////////////////////////////
// FUNCTION : Process
// PURPOSE :  Processes the scripts.
/////////////////////////////////////////////////////////////////////////////////

void CTheScripts::InternalProcess(void)
{

	AUTO_HANG_DETECT_CRASH_ZONE;
	ms_ScriptHandlerMgr.Update();

#if __BANK
	if (camInterface::IsFadedOut())
	{
		sm_fTimeFadedOut += fwTimer::GetTimeStep();
	}
	else
	{
		sm_fTimeFadedOut = 0.0f;
	}

	if (DisplayScriptProcessMessagesWhileScreenIsFaded())
	{
		scriptDisplayf("CTheScripts::Process called while screen is faded");
	}
#endif	//	__BANK

	CControlMgr::UpdateVirtualKeyboard();

	if (!ShouldBeProcessed())
	{
		return;
	}

#if GTA_REPLAY
	if(!CReplayMgr::IsReplayDisabled() && !CReplayMgr::IsRecordingEnabled() && !CReplayMgr::ShouldUpdateScripts())
	{
		// update movie mesh manager
		g_movieMeshMgr.Update();
		return;
	}
#endif	//GTA_REPLAY

	PF_START_TIMEBAR_DETAIL("Script update");

	NetworkInterface::UpdateBeforeScripts();

#if RSG_PC
	NtDll::VerifyProtection();
	Kernel32::VerifyProtection();
#endif

	sm_ScriptTimer.Reset();

	CScriptAreas::Process();
	CScriptCars::Process();
	CScriptPeds::Process();
	CScriptDebug::Process();
	CScriptHud::Process();

#if __DEV
	if (bDisplayUsedScriptResources)
	{
		ms_ScriptHandlerMgr.DisplayObjectAndResourceInfo();
	}
#endif

#if __BANK
	ms_ScriptHandlerMgr.DisplayScriptHandlerInfo();
#endif

	if (CGameWorld::GetMainPlayerInfo() REPLAY_ONLY(&& CReplayMgr::IsReplayInControlOfWorld() == false))
	{
		CWorldPoints::ScanForScriptTriggerWorldPoints(CGameWorld::FindLocalPlayerCentreOfWorld());
	}

	ms_ScriptBrainDispatcher.Process();

#if __BANK
	if (CScriptDebug::GetOutputScriptDisplayTextCommands())
	{
		scripthudDisplayf("CTheScripts::Process - Start of processing script threads");
	}
#endif	//	__BANK

	scrThread::SetTimeStep(fwTimer::GetTimeStep());
	ms_bUpdatingScriptThreads = true;
	scrThread::UpdateAll(s_InstructionLimit);
	ms_bUpdatingScriptThreads = false;

#if __BANK
	if (CScriptDebug::GetOutputScriptDisplayTextCommands())
	{
		scripthudDisplayf("CTheScripts::Process - End of processing script threads");
	}
#endif	//	__BANK

	//Doing this immediately after threads update to minimise time spent with shapetest requests enqueued
	CScriptShapeTestManager::Update();

	//	To free .sco files faster so that they can be used within the Preview folder
	GtaThread::KillAllAbortedScriptThreads();

	// flush script event queues
	GetEventScriptErrorsGroup()->FlushAllAndMovePending();
	GetEventScriptAIGroup()->FlushAllAndMovePending();
	GetEventScriptNetworkGroup()->FlushAllAndMovePending();

	// update movie mesh manager
	g_movieMeshMgr.Update();

	CutSceneManager::GetInstance()->RenderBinkMovieAndUpdateRenderTargets();

#if __BANK
	if (DisplayScriptProcessMessagesWhileScreenIsFaded())
	{
		sm_fTimeFadedOut -= 4.0f;
	}
#endif	//	__BANK

	NetworkInterface::UpdateAfterScripts();

	CAnimSceneManager::Update(kAnimSceneUpdatePostScript);
}


void CTheScripts::RegisterEntity(CPhysical* pEntity, bool bScriptHostObject, bool bNetworked, bool bNewEntity)
{
	if (AssertVerify(pEntity) &&
		scriptVerifyf(!pEntity->GetExtension<CScriptEntityExtension>(), "CTheScripts::RegisterEntity - The entity with model %s and PopType %s is already registered as a mission entity", pEntity->GetModelName(), CTheScripts::GetPopTypeName(pEntity->PopTypeGet()) ))
	{
		CScriptEntityExtension* pNewExtension = rage_new CScriptEntityExtension(*pEntity);
		Assert(pEntity->GetExtension<CScriptEntityExtension>());

		scriptHandler* pScriptHandler = GetCurrentGtaScriptThread()->m_Handler;

		if (bScriptHostObject && NetworkInterface::IsGameInProgress())
		{
			if (!bNetworked)
			{
				sysStack::PrintStackTrace();
				Displayf("CTheScripts::RegisterEntity - trying to register a non-networked script host entity. Forcing networking.");
				Assertf(0, "CTheScripts::RegisterEntity - trying to register a non-networked script host entity. Forcing networking.");
				bNetworked = true;
			}

			if (bNetworked && !pEntity->GetNetworkObject())
			{
				sysStack::PrintStackTrace();
				Displayf("CTheScripts::RegisterEntity - trying to register a script host entity with no network object. Forcing client object.");
				Assertf(0, "CTheScripts::RegisterEntity - trying to register a script host entity with no network object. Forcing client object.");
				bScriptHostObject = false;
				bNetworked = false;
			}
		}

		// cache the networked state so that we know whether to register the object with the network code when a network game starts
		pNewExtension->SetIsNetworked(bNetworked);

		// all non-networked entities must be client ones as no other machine will know about them
		if (!bNetworked)
		{
			 bScriptHostObject = false;
		}

		if (AssertVerify(pScriptHandler))
		{
			pScriptHandler->RegisterNewScriptObject(static_cast<scriptHandlerObject&>(*pNewExtension), bScriptHostObject, bNetworked);

			if (pEntity->GetNetworkObject() && pScriptHandler->GetNetworkComponent())
			{
				if (bScriptHostObject)
				{
					static_cast<CGameScriptHandlerNetwork*>(pScriptHandler)->ValidateRegistrationRequest(pEntity, bNewEntity);

					// host objects should always be cloned on all machines running the script
					pEntity->GetNetworkObject()->SetGlobalFlag(CNetObjGame::GLOBALFLAG_CLONEALWAYS_SCRIPT, true);

					if (pEntity->GetNetworkObject())
					{
						// update the scope state immediately so that the clone creates will go out a.s.a.p
						NetworkInterface::GetObjectManager().UpdateAllInScopeStateImmediately(pEntity->GetNetworkObject());
					}
				}
			}
		}

		pEntity->ProtectStreamedArchetype();
	}
}

void CTheScripts::UnregisterEntity(CPhysical* pEntity, bool bCleanupScriptState)
{
	// unregister the ped from its associated script handler. 
	CScriptEntityExtension* pExtension = pEntity->GetExtension<CScriptEntityExtension>();
	scriptHandler* pScriptHandler = pExtension ? pExtension->GetScriptHandler() : NULL;

	if (pExtension && pScriptHandler)
	{
		// don't cleanup the script state of the target object if the object is about to be destroyed
		pExtension->SetCleanupTargetEntity(bCleanupScriptState);

		// set the no longer needed flag here so that the script handler knows that it needs to clean up the script info for the entity
		pExtension->SetNoLongerNeeded(true);

		pScriptHandler->UnregisterScriptObject(*pExtension);

		pEntity->UnprotectStreamedArchetype();
	}

// Graeme - the correct thing to do would be to delete the script guid for this entity here so that the entity can no longer be referenced by script
//	A few scripts are relying on being able to make a temp copy of an entityId, mark the entity as no longer needed and then call a few extra commands through the copied entityId
//	This wouldn't be possible if the line below was uncommented
//	fwScriptGuid::DeleteGuid(*pEntity);
}

CEntity** CTheScripts::GetAllScriptEntities(u32& numEntities)
{
	const u32 maxNumberOfScriptEntities = 700;
	static CEntity* entities[maxNumberOfScriptEntities];

	DEV_ONLY(memset(entities, 0, sizeof(entities)));

	scriptAssertf(maxNumberOfScriptEntities == (u32) CScriptEntityExtension::GetPool()->GetSize(), "CTheScripts::GetAllScriptEntities - maxNumberOfScriptEntities is %u. Change it to match the size of the CScriptEntityExtension pool which is defined in gameconfig.xml to be %d", 
		maxNumberOfScriptEntities, CScriptEntityExtension::GetPool()->GetSize());

	numEntities = ms_ScriptHandlerMgr.GetAllScriptHandlerEntities(entities, maxNumberOfScriptEntities);

	return entities;
}

bool CTheScripts::GetPlayerIsOnAMission(void)
{
	if (ms_bPlayerIsOnAMission)
	{
		return true;
	}

	return false;
}

bool CTheScripts::IsPlayerPlaying(CPed *pPlayerPed)
{
	if (scriptVerifyf(pPlayerPed, "CTheScripts::IsPlayerPlaying - ped pointer is NULL"))
	{
		CPlayerInfo *pPlayerInfo = pPlayerPed->GetPlayerInfo();
		if (scriptVerifyf(pPlayerInfo, "CTheScripts::IsPlayerPlaying - ped doesn't have PlayerInfo"))
		{
			if (pPlayerInfo->IsRestartingAfterDeath() || pPlayerPed->IsInjured()
				|| pPlayerInfo->IsRestartingAfterArrest())
			{
				return false;
			}
			else
			{
				return true;
			}
		}
	}

	return false;
}

#if __DEV
void CTheScripts::ClearAllEntityCheckedForDeadFlags(void)
{
	CPed::Pool *pedpool = CPed::GetPool();
	CPed *pPed;
	CVehicle::Pool *vehpool = CVehicle::GetPool();
	CVehicle *pVehicle;
	s32 i;

	i = (s32) pedpool->GetSize();

	while (i--)
	{
		pPed = pedpool->GetSlot(i);

		if (pPed)	//	 && !pPed->IsPlayer())
		{
			pPed->m_nDEflags.bCheckedForDead = FALSE;
		}
	}

	i = (s32) vehpool->GetSize();

	while (i--)
	{
		pVehicle = vehpool->GetSlot(i);

		if (pVehicle)
		{
			pVehicle->m_nDEflags.bCheckedForDead = FALSE;
		}
	}
}


#endif	//	__DEV


GtaThread *CTheScripts::GetCurrentGtaScriptThread(void)
{
	return static_cast<GtaThread *>(scrThread::GetActiveThread());
}

CGameScriptHandler *CTheScripts::GetCurrentGtaScriptHandler(void)
{
	return (scrThread::GetActiveThread() ? static_cast<GtaThread *>(scrThread::GetActiveThread())->m_Handler : NULL);
}

CGameScriptHandlerNetwork *CTheScripts::GetCurrentGtaScriptHandlerNetwork(void)
{
	CGameScriptHandler *pHandler = GetCurrentGtaScriptHandler();

	if (pHandler &&	pHandler->RequiresANetworkComponent())
	{
		return static_cast<CGameScriptHandlerNetwork *>(pHandler);
	}

	return NULL;
}

void CTheScripts::PrioritizeRequestsFromMissionScript(s32 &streamingFlags)
{
	if (!GetCurrentGtaScriptThread() || !GetCurrentGtaScriptThread()->m_bIsHighPrio)
		return;

	if (GetCurrentGtaScriptThread()->IsThisAMissionScript || GetCurrentGtaScriptThread()->GetIsARandomEventScript() || GetCurrentGtaScriptThread()->GetIsATriggerScript())
	{
		streamingFlags |= STRFLAG_PRIORITY_LOAD;
	}
}

u32 CTheScripts::GetCurrentScriptHash(void)
{
	const u32 noScript = 0;
	if (ms_bUpdatingScriptThreads)
	{
		return scrThread::GetActiveThread()->GetScriptNameHash();
	}
	else
	{
		return noScript;
	}
}

const char *CTheScripts::GetCurrentScriptName(void)
{
	const char* noScript = "";
	if (ms_bUpdatingScriptThreads)
	{
		return scrThread::GetActiveThread()->GetScriptName();
	}
	else
	{
		return noScript;
	}
}

#if !__NO_OUTPUT
const char *CTheScripts::GetCurrentScriptNameAndProgramCounter(void)
{
	static char text[256];

	if (ms_bUpdatingScriptThreads)
	{
		sprintf(text, "SCRIPT: Script Name = %s : Program Counter = %d", GetCurrentScriptName(), GetCurrentGtaScriptThread()->GetThreadPC() );
	}
	else
	{
		sprintf(text, " ");
	}

	return text;
}
#endif // !__NO_OUTPUT


void CTheScripts::SetContentIdOfCurrentUGCMission(const char *pContentIdString)
{
	if (pContentIdString == NULL)
	{
		scriptAssertf(0, "CTheScripts::SetContentIdOfCurrentUGCMission called with a NULL string so setting the string to empty");
		pContentIdString = "";
	}

	safecpy(ms_ContentIdOfCurrentUGCMission, pContentIdString, NELEM(ms_ContentIdOfCurrentUGCMission));
}

// ********************* CMissionReplayStats **************************
void CMissionReplayStats::Init(unsigned initMode)
{
	//	Don't clear the structure in INIT_SESSION
	if(initMode == INIT_CORE)
	{
		ClearReplayStatsStructure();
	}
}

//	When a Replay Mission is passed
void CMissionReplayStats::BeginReplayStatsStructure(s32 missionId, s32 missionType)
{
	if (scriptVerifyf(m_bStatsHaveBeenStored == false, "CMissionReplayStats::BeginReplayStatsStructure - stats have already been stored"))
	{
		if (scriptVerifyf(m_bConstructingStructureOfStats == false, "CMissionReplayStats::BeginReplayStatsStructure - structure of stats is already being constructed"))
		{
			m_bConstructingStructureOfStats = true;
			m_nMissionId = missionId;
			m_nMissionType = missionType;

			m_ArrayOfMissionStats.Reset();
		}
	}
}

void CMissionReplayStats::AddStatValueToReplayStatsStructure(s32 valueOfStat)
{
	if (scriptVerifyf(m_bConstructingStructureOfStats, "CMissionReplayStats::AddStatValueToReplayStatsStructure - structure of stats is not being constructed. Check that BEGIN_REPLAY_STATS has been called first"))
	{
		if (scriptVerifyf(m_bStatsHaveBeenStored == false, "CMissionReplayStats::AddStatValueToReplayStatsStructure - stats have already been stored"))
		{
			m_ArrayOfMissionStats.PushAndGrow(valueOfStat);
		}
	}	
}

void CMissionReplayStats::EndReplayStatsStructure()
{
	if (scriptVerifyf(m_bConstructingStructureOfStats, "CMissionReplayStats::EndReplayStatsStructure - structure of stats is not being constructed. Check that BEGIN_REPLAY_STATS has been called first"))
	{
		if (scriptVerifyf(m_bStatsHaveBeenStored == false, "CMissionReplayStats::EndReplayStatsStructure - stats have already been stored"))
		{
			m_bStatsHaveBeenStored = true;
			m_bConstructingStructureOfStats = false;
		}
	}
}
//	End of "When a Replay Mission is passed"

//	When a Load happens and the script detects that it’s a Replay save file
s32 CMissionReplayStats::GetNumberOfMissionStats()
{
	if (scriptVerifyf(m_bStatsHaveBeenStored, "CMissionReplayStats::GetNumberOfMissionStats - stats haven't been stored"))
	{
		return m_ArrayOfMissionStats.GetCount();
	}

	return 0;
}

s32 CMissionReplayStats::GetStatValueAtIndex(s32 arrayIndex)
{
	if (scriptVerifyf(m_bStatsHaveBeenStored, "CMissionReplayStats::GetStatValueAtIndex - stats haven't been stored"))
	{
		if (scriptVerifyf( (arrayIndex >= 0) && (arrayIndex < m_ArrayOfMissionStats.GetCount()), "CMissionReplayStats::GetStatValueAtIndex - arrayIndex %d is out of range 0 to %d", arrayIndex, m_ArrayOfMissionStats.GetCount()))
		{
			return m_ArrayOfMissionStats[arrayIndex];
		}
	}

	return 0;
}

void CMissionReplayStats::ClearReplayStatsStructure()
{

	m_bStatsHaveBeenStored = false;
	m_bConstructingStructureOfStats = false;
	m_nMissionId = 0;
	m_nMissionType = 0;

	m_ArrayOfMissionStats.Reset();
}
//	End of "When a Load happens and the script detects that it’s a Replay save file"



// ********************* CHiddenObjects **************************
void CHiddenObjects::Init()
{
	m_MapOfHiddenObjects.Reset();
}


#if !__NO_OUTPUT
void CHiddenObjects::DisplayInteriorDetails(fwInteriorLocation &interiorLoc)
{
	if (interiorLoc.IsValid())
	{
		scriptDisplayf("CHiddenObjects::DisplayInteriorDetails - interiorLoc is valid");

		scriptDisplayf("CHiddenObjects::DisplayInteriorDetails - interior proxy index is %d", interiorLoc.GetInteriorProxyIndex());

		if (interiorLoc.IsAttachedToRoom())
		{
			scriptDisplayf("CHiddenObjects::DisplayInteriorDetails - interiorLoc is attached to room. Room index is %d", interiorLoc.GetRoomIndex());
		}

		if (interiorLoc.IsAttachedToPortal())
		{
			scriptDisplayf("CHiddenObjects::DisplayInteriorDetails - interiorLoc is attached to portal. Portal index is %d. PortalToExterior=%s", interiorLoc.GetPortalIndex(), interiorLoc.IsPortalToExterior()?"true":"false");
		}
	}
	else
	{
		scriptDisplayf("CHiddenObjects::DisplayInteriorDetails - interiorLoc is not valid");
	}
}
#endif	//	!__NO_OUTPUT

void CHiddenObjects::AddToHiddenObjectMap(s32 ScriptGUIDOfEntity, spdSphere &SearchVolume, s32 ModelHash, 
										  CDummyObject *pDummyObj, fwInteriorLocation DummyInteriorLocation, s32 IplIndex)
{
	if (m_MapOfHiddenObjects.Access(ScriptGUIDOfEntity) == NULL)
	{
		hidden_object_struct HiddenObjStruct;
		HiddenObjStruct.m_SearchVolume = SearchVolume;
		HiddenObjStruct.m_ModelHash = ModelHash;

#if !__NO_OUTPUT
		fwModelId modelId;
		CBaseModelInfo* pModelInfo = CModelInfo::GetBaseModelInfoFromHashKey(static_cast< u32 >( ModelHash ), &modelId);

		if (scriptVerifyf(modelId.IsValid(), "CHiddenObjects::AddToHiddenObjectMap - %d (signed) %u (unsigned) is not a valid model hash", ModelHash, (u32) ModelHash))
		{
			Vec3V SearchPos = SearchVolume.GetCenter();
			scriptDisplayf("CHiddenObjects::AddToHiddenObjectMap - called for %s at %f %f %f", pModelInfo->GetModelName(), SearchPos.GetXf(), SearchPos.GetYf(), SearchPos.GetZf());
		}
#endif	//	!__NO_OUTPUT

		HiddenObjStruct.m_pRelatedDummyForObjectGrabbedFromTheWorld = pDummyObj;
		HiddenObjStruct.m_InteriorLocationOfRelatedDummyForObjectGrabbedFromTheWorld = DummyInteriorLocation;
		HiddenObjStruct.m_IplIndexOfObjectGrabbedFromTheWorld = IplIndex;

#if !__NO_OUTPUT
		scriptDisplayf("CHiddenObjects::AddToHiddenObjectMap - interior location details are");
		DisplayInteriorDetails(DummyInteriorLocation);
#endif	//	!__NO_OUTPUT

		m_MapOfHiddenObjects.Insert(ScriptGUIDOfEntity, HiddenObjStruct);
	}

	g_MapChangeMgr.Add((u32) ModelHash, (u32) ModelHash, SearchVolume, true, CMapChange::TYPE_HIDE, true, true);
}


void CHiddenObjects::ReregisterInHiddenObjectMap(s32 oldScriptGUIDOfEntity, s32 newScriptGUIDOfEntity)
{
	if (oldScriptGUIDOfEntity != newScriptGUIDOfEntity)
	{
//	Get entry for old GUID
		hidden_object_struct *pHideDataForThisEntity = m_MapOfHiddenObjects.Access(oldScriptGUIDOfEntity);
		if (pHideDataForThisEntity)
		{
			hidden_object_struct HiddenObjStruct = *pHideDataForThisEntity;

//	Remove entry for old GUID
			m_MapOfHiddenObjects.Delete(oldScriptGUIDOfEntity);

			if (scriptVerifyf(m_MapOfHiddenObjects.Access(newScriptGUIDOfEntity) == NULL, 
				"CHiddenObjects::ReregisterInHiddenObjectMap - MapOfHiddenObjects contains data for old GUID %d, but we didn't expect it to also contain data for the new GUID %d", oldScriptGUIDOfEntity, newScriptGUIDOfEntity))
			{
#if !__NO_OUTPUT
				fwModelId modelId;
				CBaseModelInfo* pModelInfo = CModelInfo::GetBaseModelInfoFromHashKey(static_cast< u32 >( HiddenObjStruct.m_ModelHash ), &modelId);

				if (scriptVerifyf(modelId.IsValid(), "CHiddenObjects::ReregisterInHiddenObjectMap - %d (signed) %u (unsigned) is not a valid model hash", HiddenObjStruct.m_ModelHash, (u32) HiddenObjStruct.m_ModelHash))
				{
					Vec3V SearchPos = HiddenObjStruct.m_SearchVolume.GetCenter();
					scriptDisplayf("CHiddenObjects::ReregisterInHiddenObjectMap - called for %s at %f %f %f (Old GUID=%d, New GUID=%d)", 
						pModelInfo->GetModelName(), SearchPos.GetXf(), SearchPos.GetYf(), SearchPos.GetZf(), 
						oldScriptGUIDOfEntity, newScriptGUIDOfEntity);
				}

				scriptDisplayf("CHiddenObjects::ReregisterInHiddenObjectMap - interior location details are");
				DisplayInteriorDetails(HiddenObjStruct.m_InteriorLocationOfRelatedDummyForObjectGrabbedFromTheWorld);
#endif	//	!__NO_OUTPUT

//	Add entry for new GUID
				m_MapOfHiddenObjects.Insert(newScriptGUIDOfEntity, HiddenObjStruct);
			}
		}
	}
}

bool CHiddenObjects::RemoveFromHiddenObjectMap(s32 ScriptGUIDOfEntity, bool bHandleRelatedDummy)
{
	bool bReturnValue = false;

	hidden_object_struct *pHideDataForThisEntity = m_MapOfHiddenObjects.Access(ScriptGUIDOfEntity);
	if (pHideDataForThisEntity)
	{
		g_MapChangeMgr.Remove(pHideDataForThisEntity->m_ModelHash, pHideDataForThisEntity->m_ModelHash, 
			pHideDataForThisEntity->m_SearchVolume, CMapChange::TYPE_HIDE, false);

		CObject *pObject = CTheScripts::GetEntityToModifyFromGUID<CObject>(ScriptGUIDOfEntity, 0);
		if (bHandleRelatedDummy && pObject)
		{
#if !__NO_OUTPUT
			Vec3V SearchPos = pHideDataForThisEntity->m_SearchVolume.GetCenter();
			scriptDisplayf("CHiddenObjects::RemoveFromHiddenObjectMap has been called for %s at %f %f %f", pObject->GetModelName(), SearchPos.GetXf(), SearchPos.GetYf(), SearchPos.GetZf());
#endif	//	!__NO_OUTPUT

			if (!pObject->GetIsRetainedByInteriorProxy())
			{	//	If the object is on a retained list then that means the interior is shut down so skip the following code
				//	and just make the object ENTITY_OWNEDBY_TEMP
				CDummyObject *pRelatedDummy = pHideDataForThisEntity->m_pRelatedDummyForObjectGrabbedFromTheWorld;
				fwInteriorLocation RelatedDummyLocation = pHideDataForThisEntity->m_InteriorLocationOfRelatedDummyForObjectGrabbedFromTheWorld;
				s32 IplIndex = pHideDataForThisEntity->m_IplIndexOfObjectGrabbedFromTheWorld;

				if (!pRelatedDummy)
				{
					scriptDisplayf("CHiddenObjects::RemoveFromHiddenObjectMap - pointer to related dummy for object %s has been lost so start a world search", pObject->GetModelName());
					pRelatedDummy = FindClosestMatchingDummy(pHideDataForThisEntity, pObject);
				}

				if (pRelatedDummy)
				{
					pObject->SetIplIndex(IplIndex);

					pObject->SetRelatedDummy(pRelatedDummy, RelatedDummyLocation);
					//	Can I just call CDummyObject::Disable() and let CObjectPopulation::ManageObject decide whether the object
					//	should be swapped to the dummy?
					pRelatedDummy->Disable();

					scriptDisplayf("CHiddenObjects::RemoveFromHiddenObjectMap - related dummy for object %s has been set up", pObject->GetModelName());

					bReturnValue = true;
				}
			}
			else
			{
				scriptDisplayf("CHiddenObjects::RemoveFromHiddenObjectMap - object %s is on a retained list so skipping the code to re-establish a connection with the related dummy", pObject->GetModelName());
			}
		}

		m_MapOfHiddenObjects.Delete(ScriptGUIDOfEntity);
	}

	return bReturnValue;
}

void CHiddenObjects::UndoHiddenObjects()
{
	scriptAssertf(m_MapOfHiddenObjects.GetNumUsed() == 0, "CHiddenObjects::UndoHiddenObjects - expected all hidden objects to have been dealt with already during Shutdown Session");

//	If any objects haven't already been unhidden then do that now
	atMap<s32, hidden_object_struct>::Iterator mapIterator = m_MapOfHiddenObjects.CreateIterator();
	while (!mapIterator.AtEnd())
	{
		s32 ScriptGUID = mapIterator.GetKey();
//	Can I assume that all CObjects will be deleted in Shutdown Session
//	and that UndoHiddenObjects() will only be called during Shutdown Session
		RemoveFromHiddenObjectMap(ScriptGUID, false);
		mapIterator.Start();
	}
}


struct ClosestDummyObjectStruct
{
	CEntity *m_pClosestDummyObject;

	u32 m_ModelHash;
	fwInteriorLocation m_InteriorLocation;
	s32 m_IplIndex;

	float m_fClosestDistanceSquared;
	Vec3V m_vCoordToCalculateDistanceFrom;
};


bool GetClosestDummyObjectCB(CEntity* pEntity, void* data)
{
	if (scriptVerifyf(pEntity, "GetClosestDummyObjectCB - entity pointer is NULL"))
	{
		if (scriptVerifyf(data, "GetClosestDummyObjectCB - data pointer is NULL"))
		{
			ClosestDummyObjectStruct* pClosestDummyObjectData = reinterpret_cast<ClosestDummyObjectStruct*>(data);

			if(pEntity->GetIsTypeDummyObject())
			{
				if (pEntity->GetBaseModelInfo()->GetModelNameHash() == pClosestDummyObjectData->m_ModelHash)
				{
					if (pEntity->GetIplIndex() == pClosestDummyObjectData->m_IplIndex)
					{
						if (pEntity->GetInteriorLocation().IsSameLocation(pClosestDummyObjectData->m_InteriorLocation))
						{
							//Get the distance between the centre of the locate and the entities position
							Vec3V DiffVector = pEntity->GetTransform().GetPosition() - pClosestDummyObjectData->m_vCoordToCalculateDistanceFrom;

							const float ObjDistanceSquared = MagSquared(DiffVector).Getf();

							if (ObjDistanceSquared < pClosestDummyObjectData->m_fClosestDistanceSquared)
							{
								pClosestDummyObjectData->m_pClosestDummyObject = pEntity;
								pClosestDummyObjectData->m_fClosestDistanceSquared = ObjDistanceSquared;
							}
						}
					}
				}
			}
		}
	}

	return true;
}


//	Debug function to print reason for failure of FindClosestMatchingDummy
void CHiddenObjects::DisplayFailReason(const char* ASSERT_ONLY(pFailReason), const hidden_object_struct* ASSERT_ONLY(pHideData), const CObject* ASSERT_ONLY(pObject))
{
#if __ASSERT
	Vector3 vObjectCoors(0.0f, 0.0f, 0.0f);
	const char *pObjectName = "Unknown Object";
	if (pObject)
	{
		vObjectCoors = VEC3V_TO_VECTOR3(pObject->GetTransform().GetPosition());
		pObjectName = pObject->GetModelName();
	}
	Vec3V SearchPos = pHideData->m_SearchVolume.GetCenter();

	scriptAssertf(0,
		"%s Object Name = %s, Object Pos = %f %f %f, Original Search Pos = %f %f %f",
		pFailReason, pObjectName, vObjectCoors.GetX(), vObjectCoors.GetY(), vObjectCoors.GetZ(), 
		SearchPos.GetXf(), SearchPos.GetYf(), SearchPos.GetZf());
#endif	//	__ASSERT
}

CDummyObject *CHiddenObjects::FindClosestMatchingDummy(hidden_object_struct *pHideData, const CObject* pObject)
{
	CDummyObject *pDummyObject = NULL;

	fwInteriorLocation InteriorLoc = pHideData->m_InteriorLocationOfRelatedDummyForObjectGrabbedFromTheWorld;

	bool bInteriorIsLoaded = false;
	bool bExteriorIsLoaded = false;
	if (InteriorLoc.IsValid())
	{
#if !__NO_OUTPUT
		scriptDisplayf("CHiddenObjects::FindClosestMatchingDummy - interior location details are");
		DisplayInteriorDetails(InteriorLoc);
#endif	//	!__NO_OUTPUT

		CInteriorProxy *pInteriorProxy = CInteriorProxy::GetFromLocation(InteriorLoc);
		if (pInteriorProxy)
		{
			if (pInteriorProxy->GetCurrentState() >= CInteriorProxy::PS_FULL)
			{
				bInteriorIsLoaded = true;
				scriptDisplayf("CHiddenObjects::FindClosestMatchingDummy - interior %d is instanced", InteriorLoc.GetInteriorProxyIndex());
			}
			else
			{
				scriptDisplayf("CHiddenObjects::FindClosestMatchingDummy - current state of interior proxy is %u", pInteriorProxy->GetCurrentState());

				scriptDisplayf("---");
				scriptDisplayf("interior & object dump...\n");
				scriptDisplayf("interior : %s, room : %d\n",pInteriorProxy->GetModelName(),InteriorLoc.GetRoomIndex());
				CDebug::DumpEntity(pObject);

				// this assert isn't a real problem - object may have been pushed into exterior
				//DisplayFailReason("CHiddenObjects::FindClosestMatchingDummy - expected interior to be instanced at this stage. If this was not the case, we should have earlied-out due to the CObject being retained.", pHideData, pObject);
			}
		}
		else
		{
			DisplayFailReason("CHiddenObjects::FindClosestMatchingDummy - pInteriorProxy is NULL.", pHideData, pObject);
		}
	}
	else
	{
// 		fwMapDataDef* pDef = fwMapDataStore::GetStore().GetSlot(pHideData->m_IplIndexOfObjectGrabbedFromTheWorld);
// 		if (pDef && pDef->IsLoaded())
		if ( fwMapDataStore::GetStore().HasObjectLoaded(strLocalIndex(pHideData->m_IplIndexOfObjectGrabbedFromTheWorld)) )
		{
			bExteriorIsLoaded = true;
			scriptDisplayf("CHiddenObjects::FindClosestMatchingDummy - ipl %d is loaded", pHideData->m_IplIndexOfObjectGrabbedFromTheWorld);
		}
	}

	if (bInteriorIsLoaded || bExteriorIsLoaded)
	{
		ClosestDummyObjectStruct searchData;
		searchData.m_pClosestDummyObject = NULL;

		searchData.m_ModelHash = (u32) pHideData->m_ModelHash;
		searchData.m_InteriorLocation = InteriorLoc;
		searchData.m_IplIndex = pHideData->m_IplIndexOfObjectGrabbedFromTheWorld;
		
		searchData.m_fClosestDistanceSquared = pHideData->m_SearchVolume.GetRadiusSquaredf() * 4.0f;	//	set this to larger than the scan range (remember it's squared distance)
		searchData.m_vCoordToCalculateDistanceFrom = pHideData->m_SearchVolume.GetCenter();

		SEARCH_LOCATION_FLAGS SearchFlags = SEARCH_LOCATION_EXTERIORS;	//	Search exteriors only
		if (bInteriorIsLoaded)
		{
			SearchFlags = SEARCH_LOCATION_INTERIORS;	//	Search interiors only
		}

		fwIsSphereIntersecting searchSphere(pHideData->m_SearchVolume);
		CGameWorld::ForAllEntitiesIntersecting(&searchSphere, GetClosestDummyObjectCB, (void*) &searchData, 
			ENTITY_TYPE_MASK_DUMMY_OBJECT, SearchFlags,
			SEARCH_LODTYPE_HIGHDETAIL, SEARCH_OPTION_NONE, WORLDREP_SEARCHMODULE_SCRIPT);

		if (searchData.m_pClosestDummyObject)
		{
			if (scriptVerifyf(searchData.m_pClosestDummyObject->GetIsTypeDummyObject(), "CHiddenObjects::FindClosestMatchingDummy - expected entity to be a dummy object"))
			{
				pDummyObject = static_cast<CDummyObject*>(searchData.m_pClosestDummyObject);
			}
		}
	}

	return pDummyObject;
}
// ********************* End of CHiddenObjects **************************

#if __ASSERT
bool CTheScripts::IsValidGlobalVariable(int *AddressToTest)
{
	for (int i=0; i<scrProgram::MAX_GLOBAL_BLOCKS; i++)
	{
		scrValue *pLow_addr = scrProgram::GetGlobals(i);
		scrValue *pHigh_addr = scrProgram::GetGlobals(i) + (scrProgram::GetGlobalSize(i));	//	4 *
		if ( (pLow_addr <= (scrValue *) AddressToTest) && ((scrValue *) AddressToTest < pHigh_addr) )
		{
			return true;
		}
	}

	return false;
}


void CTheScripts::DoEntityModifyChecks(const fwEntity* pEntity, unsigned assertFlags)
{
	if (scrThread::GetCurrentCmdName())
	{
		if (assertFlags & GUID_ASSERT_FLAG_ENTITY_EXISTS)
		{
			scriptAssertf(pEntity, "%s: %s - Entity doesn't exist", GetCurrentScriptNameAndProgramCounter(), scrThread::GetCurrentCmdName());
		}

		if (pEntity && (pEntity->GetType() == ENTITY_TYPE_VEHICLE || pEntity->GetType() == ENTITY_TYPE_PED || pEntity->GetType() == ENTITY_TYPE_OBJECT))
		{
			const CPhysical* pPhysical = static_cast<const CPhysical*>(pEntity);

			if (assertFlags & GUID_ASSERT_FLAG_DEAD_CHECK && pEntity->GetType() != ENTITY_TYPE_OBJECT)
			{
				scriptAssertf (pPhysical->m_nDEflags.bCheckedForDead == TRUE, "%s: %s - Check entity is alive this frame", GetCurrentScriptNameAndProgramCounter(), scrThread::GetCurrentCmdName());
			}

			if (assertFlags & GUID_ASSERT_FLAG_NOT_CLONE)
			{
				if (pPhysical->IsNetworkClone() || (pPhysical->GetNetworkObject() && pPhysical->GetNetworkObject()->IsPendingOwnerChange()))
				{
					scriptAssertf (0, "%s: %s - Cannot call this command on an entity (%s) owned by another machine! (Clone: %s, migrating: %s)", GetCurrentScriptNameAndProgramCounter(), scrThread::GetCurrentCmdName(), pPhysical->GetNetworkObject()->GetLogName(), pPhysical->IsNetworkClone() ? "true" : "false", pPhysical->GetNetworkObject()->IsPendingOwnerChange() ? "true" : "false");
				}
			}
		}
	}
}

#endif // __ASSERT


#if __BANK

const char *CTheScripts::GetPopTypeName(ePopType PopType)
{
	switch (PopType)
	{
		case POPTYPE_UNKNOWN :
			return "POPTYPE_UNKNOWN";
		case POPTYPE_RANDOM_PERMANENT :
			return "POPTYPE_RANDOM_PERMANENT";
		case POPTYPE_RANDOM_PARKED :
			return "POPTYPE_RANDOM_PARKED";
		case POPTYPE_RANDOM_PATROL :
			return "POPTYPE_RANDOM_PATROL";
		case POPTYPE_RANDOM_SCENARIO :
			return "POPTYPE_RANDOM_SCENARIO";
		case POPTYPE_RANDOM_AMBIENT :
			return "POPTYPE_RANDOM_AMBIENT";
		case POPTYPE_PERMANENT :
			return "POPTYPE_PERMANENT";
		case POPTYPE_MISSION :
			return "POPTYPE_MISSION";
		case POPTYPE_REPLAY :
			return "POPTYPE_REPLAY";
		case POPTYPE_TOOL :
			return "POPTYPE_TOOL";
		case POPTYPE_CACHE :
			return "POPTYPE_CACHE";
		case NUM_POPTYPES :
			return "NUM_POPTYPES";
	}

	return "Unknown PopType";
}

#endif // __BANK

fwExtensibleBase* CTheScripts::GetExtensibleBaseToModifyFromGUID(int guid, const char* ASSERT_ONLY(commandName), unsigned ASSERT_ONLY(assertFlags))
{
	fwExtensibleBase* pBase = fwScriptGuid::FromGuid<fwExtensibleBase>(guid);

#if __ASSERT
	if (commandName)
	{
		if (assertFlags & GUID_ASSERT_FLAG_ENTITY_EXISTS)
		{
			scriptAssertf(pBase, "%s: %s - Object doesn't exist", GetCurrentScriptNameAndProgramCounter(), commandName);
		}
	}
#endif // __ASSERT

	return pBase;
}

CItemSet* CTheScripts::GetItemSetToModifyFromGUID(int guid, const char* ASSERT_ONLY(commandName), unsigned ASSERT_ONLY(assertFlags))
{
	CItemSet* pItemSet = fwScriptGuid::FromGuid<CItemSet>(guid);

#if __ASSERT
	if (commandName)
	{
		if (assertFlags & GUID_ASSERT_FLAG_ENTITY_EXISTS)
		{
			scriptAssertf(pItemSet, "%s: %s - Item set doesn't exist", GetCurrentScriptNameAndProgramCounter(), commandName);
		}
	}
#endif // __ASSERT

	return pItemSet;
}

CScriptedCoverPoint* CTheScripts::GetScriptedCoverPointToModifyFromGUID(int guid, const char* ASSERT_ONLY(commandName), unsigned ASSERT_ONLY(assertFlags))
{
	CScriptedCoverPoint* pScriptedCoverPoint = fwScriptGuid::FromGuid<CScriptedCoverPoint>(guid);

#if __ASSERT
	if (commandName)
	{
		if (assertFlags & GUID_ASSERT_FLAG_ENTITY_EXISTS)
		{
			scriptAssertf(pScriptedCoverPoint, "%s: %s - Scripted coverpoint doesn't exist", GetCurrentScriptNameAndProgramCounter(), commandName);
		}
	}
#endif // __ASSERT

	return pScriptedCoverPoint;
}

const fwExtensibleBase* CTheScripts::GetExtensibleBaseToQueryFromGUID(int guid, const char* commandName, unsigned assertFlags)
{
	assertFlags &= (~GUID_ASSERT_FLAG_NOT_CLONE);
	return GetExtensibleBaseToModifyFromGUID(guid, commandName, assertFlags);
}

const CItemSet* CTheScripts::GetItemSetToQueryFromGUID(int guid, const char* commandName, unsigned assertFlags)
{
	assertFlags &= (~GUID_ASSERT_FLAG_NOT_CLONE);
	return GetItemSetToModifyFromGUID(guid, commandName, assertFlags);
}

const CScriptedCoverPoint* CTheScripts::GetScriptedCoverPointToQueryFromGUID(int guid, const char* commandName, unsigned assertFlags)
{
	return GetScriptedCoverPointToModifyFromGUID(guid, commandName, assertFlags);
}

int CTheScripts::GetGUIDFromEntity(fwEntity& entity)
{
	return fwScriptGuid::CreateGuid(entity);
}

int CTheScripts::GetGUIDFromExtensibleBase(fwExtensibleBase& base)
{
	return fwScriptGuid::GetGuidFromBase(base);
}

int	CTheScripts::GetGUIDFromPreferredCoverPoint(CScriptedCoverPoint& preferredCoverPoint)
{
	return fwScriptGuid::CreateGuid(preferredCoverPoint);
}

#if !__FINAL
EXTERN_PARSER_ENUM(ScriptTaskTypes);

const char* CTheScripts::GetScriptTaskName( s32 iCommandIndex )
{
	return PARSER_ENUM(ScriptTaskTypes).NameFromValue(iCommandIndex);
}


const char* CTheScripts::GetScriptStatusName( u8 iScriptStatus )
{
	switch( iScriptStatus )
	{
	case CPedScriptedTaskRecordData::EVENT_STAGE: return "WAITING_TO_START_TASK";
	case CPedScriptedTaskRecordData::ACTIVE_TASK_STAGE: return "PERFORMING_TASK";
	case CPedScriptedTaskRecordData::DORMANT_TASK_STAGE: return "DORMANT_TASK";
	case CPedScriptedTaskRecordData::VACANT_STAGE: return "VACANT_STAGE";
	case CPedScriptedTaskRecordData::GROUP_TASK_STAGE: return "GROUP_TASK_STAGE";
	case CPedScriptedTaskRecordData::UNUSED_ATTRACTOR_SCRIPT_TASK_STAGE: return "ATTRACTOR_SCRIPT_TASK_STAGE";
	case CPedScriptedTaskRecordData::SECONDARY_TASK_STAGE: return "SECONDARY_TASK_STAGE";
	default: return "FINISHED_TASK";
	}
}
#endif //!__FINAL

CPed* CTheScripts::FindLocalPlayerPed( int playerIndex, bool ASSERT_ONLY(bAssert) )
{
	CPed* pPlayerPed = NULL;

	if (NetworkInterface::IsGameInProgress())
	{
		CNetGamePlayer* pNetPlayer = NetworkInterface::GetPhysicalPlayerFromIndex(static_cast<PhysicalPlayerIndex>(playerIndex));

		if (scriptVerifyf(pNetPlayer && pNetPlayer->IsMyPlayer(), "%s : %s - Can only be called on the local player", CTheScripts::GetCurrentScriptNameAndProgramCounter(), scrThread::GetCurrentCmdName()))
		{
			pPlayerPed = pNetPlayer->GetPlayerPed();
		}
	}
	else if (scriptVerifyf(playerIndex==0, "%s : %s - Can only be called on the local player", CTheScripts::GetCurrentScriptNameAndProgramCounter(), scrThread::GetCurrentCmdName()))
	{	
		pPlayerPed = CGameWorld::FindLocalPlayer();
	}

#if __ASSERT
	if (bAssert)
	{
		scriptAssertf(pPlayerPed, "%s : %s - Player ped doesn't exist", CTheScripts::GetCurrentScriptNameAndProgramCounter(), scrThread::GetCurrentCmdName());
	}
#endif

	return pPlayerPed;
}

CPed* CTheScripts::FindNetworkPlayerPed( int playerIndex, bool ASSERT_ONLY(bAssert) )
{
	CPed* pPlayerPed = NULL;
	CNetGamePlayer* pNetPlayer = NULL;

	if (NetworkInterface::IsGameInProgress())
	{
		if (SCRIPT_VERIFY_PLAYER_INDEX(scrThread::GetCurrentCmdName(), playerIndex))
		{
			pNetPlayer = NetworkInterface::GetPhysicalPlayerFromIndex(static_cast<PhysicalPlayerIndex>(playerIndex));

			if (pNetPlayer)
			{
				pPlayerPed = pNetPlayer->GetPlayerPed();
			}
		}
	}
	else if (scriptVerifyf(playerIndex==0, "%s : %s - Can only be called on the local player", CTheScripts::GetCurrentScriptNameAndProgramCounter(), scrThread::GetCurrentCmdName()))
	{
		pPlayerPed = CGameWorld::FindLocalPlayer();
	}

#if __ASSERT
	if (bAssert)
	{
		scriptAssertf(!pPlayerPed || pPlayerPed->GetPlayerInfo(), "%s : %s - Player %d (%s) has no player info", CTheScripts::GetCurrentScriptNameAndProgramCounter(), scrThread::GetCurrentCmdName(), playerIndex, pNetPlayer ? pNetPlayer->GetLogName() : "-none-");
	}
#endif

	return pPlayerPed;
}

CNetGamePlayer *CTheScripts::FindNetworkPlayer( int playerIndex, bool ASSERT_ONLY(bAssert))
{
	CNetGamePlayer* pNetPlayer = NULL;

	if (scriptVerifyf(NetworkInterface::IsGameInProgress(), "%s : %s - A network game is not running", CTheScripts::GetCurrentScriptNameAndProgramCounter(), scrThread::GetCurrentCmdName()))
	{
		if (SCRIPT_VERIFY_PLAYER_INDEX(scrThread::GetCurrentCmdName(), playerIndex))
		{
			pNetPlayer = NetworkInterface::GetPhysicalPlayerFromIndex(static_cast<PhysicalPlayerIndex>(playerIndex));

#if __ASSERT
			if (bAssert)
			{
				scriptAssertf(pNetPlayer, "%s : %s - Network player doesn't exist", CTheScripts::GetCurrentScriptNameAndProgramCounter(), scrThread::GetCurrentCmdName());
			}
#endif
		}
	}

	return pNetPlayer;
}

bool CTheScripts::ExportGamerHandle(const rlGamerHandle* phGamer, int& handleData, int sizeOfData ASSERT_ONLY(, const char* szCommand))
{
#if __NO_OUTPUT
	if(!scriptVerifyf(phGamer->IsValid(), "%s : %s - Invalid handle!", CTheScripts::GetCurrentScriptNameAndProgramCounter(), szCommand))
#else
#if __ASSERT
	char szToString[RL_MAX_GAMER_HANDLE_CHARS];
#endif // __ASSERT
	if(!scriptVerifyf(phGamer->IsValid(), "%s : %s - Invalid handle! As String: %s", CTheScripts::GetCurrentScriptNameAndProgramCounter(), szCommand, phGamer->ToString(szToString)))
#endif
		return false;

	// script returns size in script words
	if(!scriptVerifyf(sizeOfData == SCRIPT_GAMER_HANDLE_SIZE, "%s : %s - Invalid data size!", CTheScripts::GetCurrentScriptNameAndProgramCounter(), szCommand))
		return false;

	sizeOfData *= sizeof(scrValue); 

	// buffer to write our handle into
	u8* pHandleBuffer = reinterpret_cast<u8*>(&handleData);

	// retrieve gamer handle
	unsigned nExported = 0;
#if __NO_OUTPUT
	if(!scriptVerifyf(phGamer->Export(pHandleBuffer, sizeOfData, &nExported), "%s : %s - Export failed!", CTheScripts::GetCurrentScriptNameAndProgramCounter(), szCommand))
#else
	if(!scriptVerifyf(phGamer->Export(pHandleBuffer, sizeOfData, &nExported), "%s : %s - Export failed! As String: %s", CTheScripts::GetCurrentScriptNameAndProgramCounter(), szCommand, phGamer->ToString(szToString)))
#endif
		return false;
	if(!scriptVerifyf(nExported < GAMER_HANDLE_SIZE, "%s : %s - Increase GAMER_HANDLE_SIZE!", CTheScripts::GetCurrentScriptNameAndProgramCounter(), szCommand))
		return false;

	return true;
}

bool CTheScripts::ImportGamerHandle(rlGamerHandle* phGamer, int& handleData, int sizeOfData ASSERT_ONLY(, const char* szCommand))
{
	// script returns size in script words
	if(!scriptVerifyf(sizeOfData == SCRIPT_GAMER_HANDLE_SIZE, "%s : %s - Invalid data size!", CTheScripts::GetCurrentScriptNameAndProgramCounter(), szCommand))
		return false;

	sizeOfData *= sizeof(scrValue); 

	// buffer to write our handle into
	u8* pHandleBuffer = reinterpret_cast<u8*>(&handleData);

	// retrieve gamer handle
	unsigned nImported = 0;
	if(!scriptVerifyf(phGamer->Import(pHandleBuffer, sizeOfData, &nImported), "%s : %s - Import failed!", CTheScripts::GetCurrentScriptNameAndProgramCounter(), szCommand))
	{
#if !__NO_OUTPUT
		if (sizeOfData == SCRIPT_GAMER_HANDLE_SIZE)
		{
			scriptErrorf("CTheScripts::ImportGamerHandle() - FAILED - left to right - Service 1st 8bits from left:");
			int* handleDataOut = &handleData;
			for (int i=0; i<SCRIPT_GAMER_HANDLE_SIZE; i++)
				scriptErrorf(".............. handleData[%d] = '%d'", i, handleDataOut[i]);
		}
#endif //!__NO_OUTPUT

		return false;
	}

	if(!scriptVerifyf(nImported < GAMER_HANDLE_SIZE, "%s : %s - Increase GAMER_HANDLE_SIZE!", CTheScripts::GetCurrentScriptNameAndProgramCounter(), szCommand))
		return false;

	return scriptVerifyf(phGamer->IsValid(), "%s : %s - Invalid handle!", CTheScripts::GetCurrentScriptNameAndProgramCounter(), szCommand);
}

bool CTheScripts::ImportGamerHandle(rlGamerHandle* phGamer, u8* pData ASSERT_ONLY(, const char* szCommand))
{
	// retrieve gamer handle
	unsigned nImported = 0;
	if(!scriptVerifyf(phGamer->Import(pData, GAMER_HANDLE_SIZE, &nImported), "%s : %s - Import failed! Invalid gamerhandle: %s", CTheScripts::GetCurrentScriptNameAndProgramCounter(), szCommand, pData))
		return false;
	if(!scriptVerifyf(nImported < GAMER_HANDLE_SIZE, "%s : %s - Increase GAMER_HANDLE_SIZE!", CTheScripts::GetCurrentScriptNameAndProgramCounter(), szCommand))
		return false;

	return scriptVerifyf(phGamer->IsValid(), "%s : %s - Invalid handle!", CTheScripts::GetCurrentScriptNameAndProgramCounter(), szCommand);
}

bool CTheScripts::HasEntityBeenRegisteredWithCurrentThread(const CPhysical* pPhysical)
{
	const CScriptEntityExtension* pExtension = pPhysical->GetExtension<CScriptEntityExtension>();

	return (pExtension && pExtension->GetScriptInfo() && pExtension->GetScriptInfo()->GetScriptId() == CGameScriptId(*GetCurrentGtaScriptThread()));
}

int CTheScripts::GetIdForEntityRegisteredWithCurrentThread(const CPhysical* pPhysical)
{
	if (AssertVerify(HasEntityBeenRegisteredWithCurrentThread(pPhysical)))
	{
		const CScriptEntityExtension* pExtension = pPhysical->GetExtension<CScriptEntityExtension>();

		return static_cast<int>(pExtension->GetScriptInfo()->GetObjectId());
	}

	return NULL_IN_SCRIPTING_LANGUAGE;
}

void CScriptEulers::MatrixFromEulers(Matrix34& matrix, const Vector3& eulers, EulerAngleOrder rotationOrder)
{
	switch(rotationOrder)
	{
	case EULER_XYZ:
		matrix.FromEulersXYZ(eulers);
		break;

	case EULER_XZY:
		matrix.FromEulersXZY(eulers);
		break;

	case EULER_YXZ:
		matrix.FromEulersYXZ(eulers);
		break;

	case EULER_YZX:
		matrix.FromEulersYZX(eulers);
		break;

	case EULER_ZXY:
		matrix.FromEulersZXY(eulers);
		break;

	case EULER_ZYX:
		matrix.FromEulersZYX(eulers);
		break;

	default:
		scriptAssertf(false, "Invalid Euler rotation order");
		matrix.Identity();
		break;
	}
}

Vector3 CScriptEulers::MatrixToEulers(const Matrix34& matrix, EulerAngleOrder rotationOrder)
{
	Vector3 eulers;

	switch(rotationOrder)
	{
	case EULER_XYZ:
		matrix.ToEulersXYZ(eulers);
		break;

	case EULER_XZY:
		matrix.ToEulersXZY(eulers);
		break;

	case EULER_YXZ:
		matrix.ToEulersYXZ(eulers);
		break;

	case EULER_YZX:
		matrix.ToEulersYZX(eulers);
		break;

	case EULER_ZXY:
		matrix.ToEulersZXY(eulers);
		break;

	case EULER_ZYX:
		matrix.ToEulersZYX(eulers);
		break;

	default:
		scriptAssertf(false, "Invalid Euler rotation order");
		eulers.Zero();
		break;
	}

	return eulers;
}

void CScriptEulers::QuaternionFromEulers(Quaternion& quat, const Vector3& eulers, EulerAngleOrder rotationOrder)
{
	switch(rotationOrder)
	{
	case EULER_XYZ:
		quat.FromEulers(eulers, eEulerOrderXYZ);
		break;

	case EULER_XZY:
		quat.FromEulers(eulers, eEulerOrderXZY);
		break;

	case EULER_YXZ:
		quat.FromEulers(eulers, eEulerOrderYXZ);
		break;

	case EULER_YZX:
		quat.FromEulers(eulers, eEulerOrderYZX);
		break;

	case EULER_ZXY:
		quat.FromEulers(eulers, eEulerOrderZXY);
		break;

	case EULER_ZYX:
		quat.FromEulers(eulers, eEulerOrderZYX);
		break;

	default:
		scriptAssertf(false, "CScriptEulers::QuaternionFromEulers - Invalid Euler rotation order");
		quat.Identity();
		break;
	}
}

Vector3	CScriptEulers::QuaternionToEulers(Quaternion& quat, EulerAngleOrder rotationOrder)
{
	Vector3 eulers;

	switch(rotationOrder)
	{
	case EULER_XYZ:
		quat.ToEulers(eulers, eEulerOrderXYZ);
		break;

	case EULER_XZY:
		quat.ToEulers(eulers, eEulerOrderXZY);
		break;

	case EULER_YXZ:
		quat.ToEulers(eulers, eEulerOrderYXZ);
		break;

	case EULER_YZX:
		quat.ToEulers(eulers, eEulerOrderYZX);
		break;

	case EULER_ZXY:
		quat.ToEulers(eulers, eEulerOrderZXY);
		break;

	case EULER_ZYX:
		quat.ToEulers(eulers, eEulerOrderZYX);
		break;

	default:
		scriptAssertf(false, "CScriptEulers::QuaternionToEulers - Invalid Euler rotation order");
		eulers.Zero();
		break;
	}

	return eulers;
}

// *************************************************************************************************

//	CPersistentScriptGlobals CTheScripts::PersistentScriptGlobals;

/*
void CPersistentScriptGlobals::Init()
{
	m_nSizeOfPersistentGlobalsBuffer = 0;
	m_pBackupOfPersistentGlobalsBuffer = NULL;
	m_nOffsetToStartOfPersistentGlobalsBuffer = -1;
}

void CPersistentScriptGlobals::Clear()
{
	m_nSizeOfPersistentGlobalsBuffer = 0;
	if (m_pBackupOfPersistentGlobalsBuffer)
	{
		delete[] m_pBackupOfPersistentGlobalsBuffer;
	}
	m_pBackupOfPersistentGlobalsBuffer = NULL;

	m_nOffsetToStartOfPersistentGlobalsBuffer = -1;
}

void CPersistentScriptGlobals::RegisterPersistentGlobalVariables(int *pStartOfPersistentGlobals, int nSizeOfBuffer)
{
	u8 *pStartOfGlobalsMemory = reinterpret_cast<u8*>(scrProgram::GetGlobals());
	u8 *pStartOfPersistents = reinterpret_cast<u8*>(pStartOfPersistentGlobals);
	int nOffsetToGlobalsInBytes = pStartOfPersistents - pStartOfGlobalsMemory;

	scriptAssertf( (nOffsetToGlobalsInBytes >= 0) && (nOffsetToGlobalsInBytes < static_cast<int>(sizeof(scrValue) * scrProgram::GetGlobalSize())), "CPersistentScriptGlobals::RegisterPersistentGlobalVariables - offset to persistent globals is out of range");
	scriptAssertf( (nOffsetToGlobalsInBytes + nSizeOfBuffer) <= static_cast<int>(sizeof(scrValue) * scrProgram::GetGlobalSize()), "CPersistentScriptGlobals::RegisterPersistentGlobalVariables - persistent globals structure extends past the end of the global script memory");

	scriptAssertf((scrProgram::GetGlobals() + (nOffsetToGlobalsInBytes/sizeof(scrValue)) ) == reinterpret_cast<scrValue*>(pStartOfPersistentGlobals), "CPersistentScriptGlobals::RegisterPersistentGlobalVariables - I've made a mistake in my calculations - Graeme");

	scriptAssertf( (m_nSizeOfPersistentGlobalsBuffer == 0) || (m_nSizeOfPersistentGlobalsBuffer == nSizeOfBuffer), "CPersistentScriptGlobals::RegisterPersistentGlobalVariables - attempting to change the size of the persistent globals structure");
	scriptAssertf( (m_nOffsetToStartOfPersistentGlobalsBuffer == -1) || (m_nOffsetToStartOfPersistentGlobalsBuffer == nOffsetToGlobalsInBytes), "CPersistentScriptGlobals::RegisterPersistentGlobalVariables - attempting to change the offset of the persistent globals structure");

	scriptAssertf(!m_pBackupOfPersistentGlobalsBuffer, "CPersistentScriptGlobals::RegisterPersistentGlobalVariables - didn't expect the backup buffer to be allocated at this point");

	Clear();

	m_nSizeOfPersistentGlobalsBuffer = nSizeOfBuffer;
	m_nOffsetToStartOfPersistentGlobalsBuffer = nOffsetToGlobalsInBytes;
}

bool CPersistentScriptGlobals::StorePersistentGlobalsInBackupBuffer()
{
	if (m_nSizeOfPersistentGlobalsBuffer == 0)
	{
		scriptAssertf(m_nOffsetToStartOfPersistentGlobalsBuffer == -1, "CPersistentScriptGlobals::StorePersistentGlobalsInBackupBuffer - size of buffer is 0 but offset is not -1");
		return true;	//	returning false would probably suggest that the function had failed rather than that the buffer didn't need to be allocated
	}

	if (m_pBackupOfPersistentGlobalsBuffer)
	{
		scriptAssertf(0, "CPersistentScriptGlobals::StorePersistentGlobalsInBackupBuffer - didn't expect backup buffer to already be allocated at this stage");
		delete[] m_pBackupOfPersistentGlobalsBuffer;
		m_pBackupOfPersistentGlobalsBuffer = NULL;
	}

	scriptAssertf( (m_nOffsetToStartOfPersistentGlobalsBuffer >= 0) && (m_nOffsetToStartOfPersistentGlobalsBuffer < static_cast<int>(sizeof(scrValue) * scrProgram::GetGlobalSize())), "CPersistentScriptGlobals::StorePersistentGlobalsInBackupBuffer - offset to persistent globals is out of range");
	scriptAssertf( (m_nOffsetToStartOfPersistentGlobalsBuffer + m_nSizeOfPersistentGlobalsBuffer) <= static_cast<int>(sizeof(scrValue) * scrProgram::GetGlobalSize()), "CPersistentScriptGlobals::StorePersistentGlobalsInBackupBuffer - persistent globals structure extends past the end of the global script memory");

//	Allocate buffer of the correct size
	m_pBackupOfPersistentGlobalsBuffer = rage_new u8[m_nSizeOfPersistentGlobalsBuffer];
	if (m_pBackupOfPersistentGlobalsBuffer)
	{	//	Copy the global data into this buffer
		const u8 *pStartOfPersistentStructureInGlobalsMemory = reinterpret_cast<const u8*>(scrProgram::GetGlobals()) + m_nOffsetToStartOfPersistentGlobalsBuffer;
		sysMemCpy(m_pBackupOfPersistentGlobalsBuffer, pStartOfPersistentStructureInGlobalsMemory, m_nSizeOfPersistentGlobalsBuffer);
	}
	else
	{
		scriptAssertf(0, "CPersistentScriptGlobals::StorePersistentGlobalsInBackupBuffer - failed to allocate memory for the backup buffer");
		return false;
	}

	return true;
}

bool CPersistentScriptGlobals::RestorePersistentGlobalsFromBackupBuffer()
{
	bool bSucceeded = true;

	if (scrProgram::GetGlobalSize() > 0)
	{
		if (m_pBackupOfPersistentGlobalsBuffer)
		{
			scriptAssertf(m_nSizeOfPersistentGlobalsBuffer > 0, "CPersistentScriptGlobals::RestorePersistentGlobalsFromBackupBuffer - size of buffer to restore must be greater than 0");

			scriptAssertf( (m_nOffsetToStartOfPersistentGlobalsBuffer >= 0) && (m_nOffsetToStartOfPersistentGlobalsBuffer < static_cast<int>(sizeof(scrValue) * scrProgram::GetGlobalSize())), "CPersistentScriptGlobals::RestorePersistentGlobalsFromBackupBuffer - offset to persistent globals is out of range");
			scriptAssertf( (m_nOffsetToStartOfPersistentGlobalsBuffer + m_nSizeOfPersistentGlobalsBuffer) <= static_cast<int>(sizeof(scrValue) * scrProgram::GetGlobalSize()), "CPersistentScriptGlobals::RestorePersistentGlobalsFromBackupBuffer - persistent globals structure extends past the end of the global script memory");

			//	Copy the contents of the backup buffer back into the global data
			u8 *pStartOfPersistentStructureInGlobalsMemory = reinterpret_cast<u8*>(scrProgram::GetGlobals()) + m_nOffsetToStartOfPersistentGlobalsBuffer;
			sysMemCpy(pStartOfPersistentStructureInGlobalsMemory, m_pBackupOfPersistentGlobalsBuffer, m_nSizeOfPersistentGlobalsBuffer);
		}
		else
		{
			if ( (m_nSizeOfPersistentGlobalsBuffer != 0) || (m_nOffsetToStartOfPersistentGlobalsBuffer != -1) )
			{
				scriptAssertf(0, "CPersistentScriptGlobals::RestorePersistentGlobalsFromBackupBuffer - no backup buffer to restore from");
				bSucceeded = false;
			}
		}
	}
	else
	{
		scriptAssertf(0, "CPersistentScriptGlobals::RestorePersistentGlobalsFromBackupBuffer - no global variables have been allocated at this stage");
		bSucceeded = false;
	}

//	free the backup buffer
	if (m_pBackupOfPersistentGlobalsBuffer)
	{
		delete[] m_pBackupOfPersistentGlobalsBuffer;
	}
	m_pBackupOfPersistentGlobalsBuffer = NULL;

	return bSucceeded;
}
*/

// *************************************************************************************************


class CDLCScriptDataMounter : public CDataFileMountInterface
{
	virtual bool LoadDataFile(const CDataFileMgr::DataFile& file)
	{
		switch(file.m_fileType)
		{
			case CDataFileMgr::DLC_SCRIPT_METAFILE:
			{
				CDLCScript::AddScriptData(file.m_filename);
				return true;
			}
			break;
			default:
				return false;
		}
	}
	virtual void UnloadDataFile(const CDataFileMgr::DataFile & file)
	{
		CDLCScript::RemoveScriptData(file.m_filename);
	}
}g_dlcScriptDataMounter;

void CDLCScript::AddScriptData(const char* fileName)
{
	CDLCScript* scriptData = rage_new CDLCScript;
	if(PARSER.LoadObject(fileName,NULL,*scriptData))
	{
		if(!CDLCScript::ms_scripts.Access(scriptData->GetScriptLiteralName().GetHash()))
		{
			scriptData->InitScript();
			CDLCScript::ms_scripts.SafeInsert(scriptData->GetScriptLiteralName().GetHash(),scriptData);
			CDLCScript::ms_scripts.FinishInsertion();
		}
		return;
	}
	delete scriptData;
}

void CDLCScript::RemoveScriptData(const char* fileName)
{
	CDLCScript* scriptData = rage_new CDLCScript;
	if(PARSER.LoadObject(fileName, NULL, *scriptData))
	{
		RemoveScript(scriptData);
	}
	delete scriptData;
}


void CDLCScript::Init(unsigned initMode)
{
	switch(initMode)
	{
		case INIT_CORE:
			CDataFileMount::RegisterMountInterface(CDataFileMgr::DLC_SCRIPT_METAFILE, &g_dlcScriptDataMounter);		
		break;
		case INIT_SESSION:
			for(dlcScriptIterator it=ms_scripts.Begin(); it!= ms_scripts.End();++it)
			{
				(*it)->InitScript();
			}
		break;
	}

}

void CDLCScript::Update()
{
	for(dlcScriptIterator it=ms_scripts.Begin(); it!= ms_scripts.End();++it)
	{
		(*it)->UpdateScript();
	}
}

void CDLCScript::Shutdown(unsigned shutdownMode)
{
	switch(shutdownMode)
	{
		case SHUTDOWN_SESSION:
		{
			for(dlcScriptIterator it=ms_scripts.Begin(); it!= ms_scripts.End();++it)
			{
				(*it)->ShutdownScript();
			}
		}
		break;
		case SHUTDOWN_WITH_MAP_LOADED:
		{
			for(dlcScriptIterator it=ms_scripts.Begin(); it!= ms_scripts.End();++it)
			{
				RemoveScript((*it));	
			}
			ms_scripts.Reset();		
		}
		break;
		//TODO map reset on tom's changes
	}
}

void CDLCScript::InitScript()
{
	const strLocalIndex scrIndex = g_StreamedScripts.FindSlotFromHashKey(m_startupScript.GetHash());
	if (Verifyf(scrIndex.IsValid(), "DLC Script %s can't be found", m_startupScript.GetCStr()))
	{
		m_request.Request(scrIndex, g_StreamedScripts.GetStreamingModuleId(), STRFLAG_PRIORITY_LOAD|STRFLAG_MISSION_REQUIRED);
		m_state = CDLCScript::DLC_SCR_REQUESTED;
	}
}

void CDLCScript::UpdateScript()
{
	switch (m_state)
	{
	case CDLCScript::DLC_SCR_REQUESTED:
		{
			if ( m_request.HasLoaded() )
			{
				const int objIdx = m_request.GetRequestId().Get();
				const char* progName = "";

				m_request.ClearRequiredFlags(STRFLAG_MISSION_REQUIRED);

#if !__NO_OUTPUT
				if( m_startupScript.GetCStr() != NULL ) 
					progName = m_startupScript.GetCStr();
#endif

				m_thread = CTheScripts::GtaStartNewThreadWithProgramId(g_StreamedScripts.GetProgramId(objIdx), NULL, 0, m_scriptCallstackSize, progName);
				m_request.Release();

				if (Verifyf(m_thread!= THREAD_INVALID,  "Error launching program %s", progName))
				{
					m_state = CDLCScript::DLC_SCR_LOADED;
				}
			}

		}
		break;
	default: 
		break;			
	}
}

void CDLCScript::ShutdownScript()
{
	m_request.Release();
	if (m_thread != THREAD_INVALID)
	{
		scrThread::KillThread(m_thread);
		m_thread = THREAD_INVALID;
		strLocalIndex slot = g_StreamedScripts.FindSlotFromHashKey(GetScriptLiteralName().GetHash());
		strIndex idx =g_StreamedScripts.GetStreamingIndex(slot);
		strStreamingEngine::GetInfo().RemoveObject(idx);
	}
	m_state = CDLCScript::DLC_SCR_NONE;
}

void CDLCScript::RemoveScript(CDLCScript* dlcScript)
{
	if(CDLCScript** curScriptPtr = CDLCScript::ms_scripts.SafeGet(dlcScript->GetScriptLiteralName().GetHash()))
	{
		CDLCScript* curScript = (*curScriptPtr);
		if(curScript)
		{		
			curScript->ShutdownScript();
			curScript->GetRequest().StreamingRemove();
			ms_scripts.Remove(ms_scripts.GetIndexFromDataPtr(curScriptPtr));
		}
	}
}

bool CDLCScript::ContainsScript(atLiteralHashValue nameHash)
{
	if(CDLCScript::ms_scripts.Access(nameHash.GetHash()))
		return true;
	return false;
}

#if RSG_PC && ENABLE_SCRIPT_TAMPER_CHECKER

atRangeArray<bool, scrProgram::MAX_GLOBAL_BLOCKS> CScriptGlobalTamperChecker::ms_abValidPage;
bool CScriptGlobalTamperChecker::ms_bTamperingDetected = false;
s32 CScriptGlobalTamperChecker::ms_cUncheckedSection = 0;
CScriptGlobalTamperCheckerTunablesListener CScriptGlobalTamperChecker::ms_pScriptGlobalTamperTunablesListener;

void CScriptGlobalTamperChecker::Initialize()
{
	// Add the listener
	Tunables::GetInstance().AddListener(&ms_pScriptGlobalTamperTunablesListener);
}
void CScriptGlobalTamperChecker::Reset()
{
	for (s32 i=0; i<scrProgram::MAX_GLOBAL_BLOCKS; i++)
	{
		ms_abValidPage[i] = false;
	}
	ms_bTamperingDetected = false;
}

bool CScriptGlobalTamperChecker::CurrentGlobalsDifferFromPreviousFrame(int &page)
{
	for (s32 i=0; i<scrProgram::MAX_GLOBAL_BLOCKS; i++)
	{
		if (ms_abValidPage[i] && (ms_cUncheckedSection == 0))
		{
			if (HaveGlobalsBeenWrittenToSinceReset(i))
			{
				page = i;
				return true;
			}
		}
	}
	return ms_bTamperingDetected;
}

void CScriptGlobalTamperChecker::Update()
{
	Assertf(ms_cUncheckedSection == 0, "Resetting Global Write Tracking in unchecked Section! Called Begin without End?"); 

	for (s32 i=0; i<scrProgram::MAX_GLOBAL_BLOCKS; i++)
	{
		if (scrProgram::GetGlobals(i) && ResetGlobalWriteTracking(i))
		{
			ms_abValidPage[i]= true;
		}
		else
		{
			ms_abValidPage[i] = false;
		}	
	}
}

//sets the memory for the globals as write only, letting us catch any
//exceptional cases left over in code
void CScriptGlobalTamperChecker::LockGlobalsMemory()
{
#if !RSG_FINAL
	for (s32 i=0; i<scrProgram::MAX_GLOBAL_BLOCKS; i++)
	{
		if (scrProgram::GetGlobals(i))
		{
			LockGlobalsMemory(i);
		}
	}
#endif
}

//unlock the globals memory for the script update
void CScriptGlobalTamperChecker::UnlockGlobalsMemory()
{
#if !RSG_FINAL
	for (s32 i=0; i<scrProgram::MAX_GLOBAL_BLOCKS; i++)
	{
		if (scrProgram::GetGlobals(i))
		{
			UnlockGlobalsMemory(i);
		}
	}
#endif
}

// Changes between a call to this and a call to EndUncheckedSection
// will not register as tampering
void CScriptGlobalTamperChecker::BeginUncheckedSection()
{
	// Do tamper check now as any results will be invalidated 
	// once we end the unchecked section
	int page = -1;
	ms_bTamperingDetected = NetworkInterface::IsGameInProgress() && (ms_cUncheckedSection == 0) && CurrentGlobalsDifferFromPreviousFrame(page);		
	if(ms_cUncheckedSection == 0 && PARAM_scriptProtectGlobals.Get())
	{
		CScriptGlobalTamperChecker::UnlockGlobalsMemory();
	}	
	ms_cUncheckedSection++;
}

void CScriptGlobalTamperChecker::EndUncheckedSection()
{
	ms_cUncheckedSection--;
	if(ms_cUncheckedSection == 0)
	{
		for (s32 i=0; i<scrProgram::MAX_GLOBAL_BLOCKS; i++)
		{
			if(ms_abValidPage[i])
			{
				ResetGlobalWriteTracking(i);
			}
		}

		if(PARAM_scriptProtectGlobals.Get())
		{
			CScriptGlobalTamperChecker::LockGlobalsMemory();
		}	
	}	
}

void CScriptGlobalTamperChecker::FakeTamper(const s32 offsetIndex)
{
#if !RSG_FINAL
	for (s32 i=0; i<scrProgram::MAX_GLOBAL_BLOCKS; i++)
	{
		if (scrProgram::GetGlobals(i) && ResetGlobalWriteTracking(i))
		{
			FakeTamper(i,offsetIndex);
		}
	}
#else
	(void)offsetIndex;
#endif
}

bool CScriptGlobalTamperChecker::ResetGlobalWriteTracking(s32 pageIndex)
{
	scrValue* globals = scrProgram::GetGlobals(pageIndex);
	if (globals)
	{
		const s32 globalSize = scrProgram::GetGlobalSize(pageIndex);
		return (ResetWriteWatch(globals, globalSize*sizeof(scrValue)) ==  0);
	}

	return false;
}

void CScriptGlobalTamperCheckerTunablesListener::OnTunablesRead()
{
	m_IsDisabled = Tunables::GetInstance().TryAccess(MP_GLOBAL_HASH, ATSTRINGHASH("DISABLE_SCRIPT_STATISTICS", 0xD4329E00), false);
}

bool CScriptGlobalTamperChecker::ShouldCheckGlobalBlock(s32 pageIndex)
{
	// Should we ignore everything because of tuneables?
	if(ms_pScriptGlobalTamperTunablesListener.IsDisabled())
		return false;

	//TODO: Extend to flexibly include other buckets via a tunable arrayn
	u32 blockNameHash = scrProgram::GetGlobalNameHash(pageIndex);

	const int numIgnorableGlobalBlocks = 3;
	const u32 ignoreableGlobalBlockNameHashes[numIgnorableGlobalBlocks] = {
		ATSTRINGHASH("startup", 0x41D6F794),
		ATSTRINGHASH("ugc_global_registration", 0x19F4EE3D),
		ATSTRINGHASH("global_fmmc_registration", 0x562E9707)};
	
	for(int i = 0; i < numIgnorableGlobalBlocks; i++)
	{
		if(blockNameHash == ignoreableGlobalBlockNameHashes[i])
			return false;
	}
	return true;
}

bool CScriptGlobalTamperChecker::HaveGlobalsBeenWrittenToSinceReset(s32 pageIndex)
{
	if(!ShouldCheckGlobalBlock(pageIndex))
		return false;

	scrValue* globals = scrProgram::GetGlobals(pageIndex);
	if (globals)
	{
		const s32 globalSize = scrProgram::GetGlobalSize(pageIndex);

		void* addressArray[128];
		ULONG_PTR count = 128;
		ULONG pageSize;

		if ( GetWriteWatch(0, globals, globalSize*sizeof(scrValue), addressArray, &count, &pageSize) == 0 )
		{
			if (count)
			{
#if !RSG_FINAL
				scriptWarningf("CScriptGlobalTamperChecker - Global %p / Page %d / Size %d / Valid Page? %x", globals, pageIndex, globalSize, ms_abValidPage[pageIndex]);
				for(int i = 0; i < count && i < 128; i++)
				{
					scriptWarningf("\tAddress %d/%d - %p", i , count-1, addressArray[i]);
				}

				if(PARAM_scriptProtectGlobals.Get())
				{
					__debugbreak();
				}
#endif
				return true;
			}
		}

	}
	return false;
}

void CScriptGlobalTamperChecker::LockGlobalsMemory(s32 pageIndex)
{
	scrValue* globals = scrProgram::GetGlobals(pageIndex);
	if (globals)
	{
		const s32 globalSize = scrProgram::GetGlobalSize(pageIndex);
		sysMemLockMemory(globals, globalSize*sizeof(scrValue));
	}
}

void CScriptGlobalTamperChecker::UnlockGlobalsMemory(s32 pageIndex)
{
	scrValue* globals = scrProgram::GetGlobals(pageIndex);
	if (globals)
	{
		const s32 globalSize = scrProgram::GetGlobalSize(pageIndex);
		sysMemUnlockMemory(globals, globalSize*sizeof(scrValue));
	}
}

void CScriptGlobalTamperChecker::FakeTamper(s32 pageIndex,const s32 offsetIndex)
{
	scrValue* globals = scrProgram::GetGlobals(pageIndex);
	if (globals)
	{
		const s32 globalSize = scrProgram::GetGlobalSize(pageIndex);
		if(offsetIndex < globalSize)
		{
			globals[offsetIndex].Int = 123;
		}
	}
}

CScriptGlobalTamperChecker::UncheckedScope::UncheckedScope()
{
	CScriptGlobalTamperChecker::BeginUncheckedSection();
}

CScriptGlobalTamperChecker::UncheckedScope::~UncheckedScope()
{
	CScriptGlobalTamperChecker::EndUncheckedSection();
}


#endif	//RSG_PC