#if __XENON
#include "system/xtl.h"
#endif

// Rage headers
#include "script/wrapper.h"
#include "fwmaths/angle.h"
#include "fwmaths/random.h"
#include "input/virtualkeyboard.h"
#include "spatialdata/aabb.h"
#include "spatialdata/sphere.h"
#include "string/unicode.h"
#include "vector/quaternion.h"
#include "diag/channel.h"
#include "physics/collisionoverlaptest.h"

// Game headers
#include "control/gamelogic.h"
#include "control/restart.h"
#include "control/stuntjump.h"
#include "core/game.h"
#include "frontend/Credits.h"
#include "frontend/FrontendStatsMgr.h"
#include "frontend/ProfileSettings.h"
#include "frontend/landing_page/LandingPageArbiter.h"
#if RSG_PC
#include "frontend/TextInputBox.h"
#endif // RSG_PC
#include "game/Clock.h"
#include "game/Dispatch/DispatchData.h"
#include "game/Dispatch/DispatchEnums.h"
#include "game/Dispatch/DispatchHelpers.h"
#include "game/Dispatch/DispatchManager.h"
#include "game/Dispatch/DispatchServices.h"
#include "game/Dispatch/IncidentManager.h"
#include "game/Dispatch/incidents.h"
#include "Game/localisation.h"
#include "game/ModelIndices.h"
#include "game/Performance.h"
#include "game/Riots.h"
#include "game/weather.h"
#include "game/cheat.h"
#include "game/zones.h"
#include "task/Movement/Climbing/ClimbDebug.h"
#include "ModelInfo/ModelInfo.h"
#include "ModelInfo/ModelInfo_Factories.h"
#include "Network/Objects/Entities/NetObjPlayer.h"
#include "Network/General/NetworkPendingProjectiles.h"
#include "objects/objectpopulation.h"
#include "Peds/CriminalCareer/CriminalCareerService.h"
#include "Peds/PedIntelligence/PedAILodManager.h"
#include "Peds/PedIntelligence.h"
#include "peds/peddebugvisualiser.h"
#include "peds/pedpopulation.h"
#include "peds/ped.h"
#include "peds/PlayerInfo.h"
#include "physics/physics.h"
#include "physics/WorldProbe/worldprobe.h"
#include "SaveLoad/SavegameScriptData/script_save_data.h"
#include "SaveLoad/GenericGameStorage.h"
#include "SaveLoad/savegame_messages.h"
#include "SaveLoad/savegame_queue.h"
#include "SaveLoad/savegame_save.h"
#include "SaveLoad/savegame_users_and_devices.h"
#include "scene/entity.h"
#include "scene/extracontent.h"
#include "scene/world/GameWorld.h"
#include "scene/InstancePriority.h"
#include "fwscene/search/SearchVolumes.h"
#include "script/handlers/GameScriptResources.h"
#include "script/script_brains.h"
#include "script/script.h"
#include "script/script_cars_and_peds.h"
#include "script/script_debug.h"
#include "script/script_helper.h"
#include "script/script_hud.h"
#include "script/ScriptMetadata.h"
#include "script/ScriptMetadataManager.h"
#include "streaming/streaming.h"
#include "system/FileMgr.h"
#include "system/appcontent.h"
#include "system/service.h"
#include "system/StreamingInstall.winrt.h"
#include "fwsys/timer.h"
#include "task/Combat/TacticalAnalysis.h"
#include "Task/Combat/TaskCombatMelee.h"
#include "Task/Crimes/RandomEventManager.h"
#include "Task/Default/TaskPlayer.h"
#include "Task/Default/Patrol/TaskPatrol.h"
#include "Task/Motion/Locomotion/TaskMotionPed.h"
#include "task/Motion/Locomotion/TaskMotionTennis.h"
#include "task/Scenario/ScenarioManager.h"
#include "text/TextConversion.h"
#include "text/messages.h"
#include "vehicles/vehiclepopulation.h"
#include "weapons/Bullet.h"
#include "weapons/projectiles/Projectile.h"
#include "weapons/Projectiles/ProjectileManager.h"
#include "streaming/populationstreaming.h"
#include "vehicles/VehicleFactory.h"
#include "vehicleAi/pathFind.h"
#include "Vfx/Misc/Scrollbars.h"
#include "Vfx/Clouds/Clouds.h"
#include "Vfx/Clouds/CloudHat.h"

#include "game/popmultiplierareas.h"

#include "network/NetworkInterface.h"
#include "network/events/NetworkEventTypes.h"
#include "system/EndUserBenchmark.h"
#include "diag/channel.h"
#include "SaveMigration/SaveMigration.h"
#if GEN9_STANDALONE_ENABLED
#include "control/ScriptRouterContext.h"
#include "control/ScriptRouterLink.h"

#endif

#if RSG_ORBIS
// used by activity feed scripts
#include "fwlocalisation/languagePack.h"
#include "fwnet/netplayer.h"
#endif

#if DR_ENABLED
#include "physics/debugPlayback.h"
#include "physics/debugevents.h"
#include "commands_misc.h"
#endif

SCRIPT_OPTIMISATIONS()
WEAPON_OPTIMISATIONS()

#if RSG_SCE
// For the PS, we need to be able to launch content when launched from the a LiveItem.
PARAM(LiveAreaLoadContent, "[LiveArea] The content id of the content to be loaded.");
#endif // RSG_SCE

#if !GEN9_STANDALONE_ENABLED
// I don't know if this is required.
// Maybe the two natives below that I've added this for could take any type of parameter since it doesn't get used.
struct DummyScriptRouterContextData {
	scrValue m_ScriptRouterSource;		// stored in .Int
	scrValue m_ScriptRouterMode;		// stored in .Int
	scrValue m_ScriptRouterArgType;		// stored in .Int
	scrTextLabel63 m_ScriptRouterArg;
};

SCR_DEFINE_NEW_POINTER_PARAM_AND_RET(DummyScriptRouterContextData);

#endif // !GEN9_STANDALONE_ENABLED

namespace misc_commands
{

int CommandAddHospitalRestart(const scrVector & scrVecCoors, float Heading, int WhenToUse)
{
	Vector3 VecPos = Vector3 (scrVecCoors);

	// We're quite forgiving on script passing in a number in a good range
	Assertf(Heading >= -360.0f && Heading <= 360.0f, "ADD_HOSPITAL_RESTART: Invalid desired heading: %f",Heading);
	float fHeadingRad = fwAngle::LimitRadianAngleSafe(Heading * DtoR);

	if(SCRIPT_VERIFY(((WhenToUse >=0) && (WhenToUse<=3)), "ADD_HOSPITAL_RESTART - Invalid Level"))
	{
		if (VecPos.z <= INVALID_MINIMUM_WORLD_Z)
		{
			VecPos.z = WorldProbe::FindGroundZForCoord(TOP_SURFACE, VecPos.x, VecPos.y);
		}
		
		return CRestart::AddHospitalRestartPoint(VecPos, fHeadingRad, WhenToUse);
	}

	return -1;
}

void CommandDisableHospitalRestart(int index, bool bDisable)
{
	CRestart::DisableHospitalRestartPoint(index, bDisable);
}


int CommandAddPoliceRestart(const scrVector & scrVecCoors, float Heading, int WhenToUse)
{
	Vector3 VecPos = Vector3 (scrVecCoors);

	// We're quite forgiving on script passing in a number in a good range
	Assertf(Heading >= -360.0f && Heading <= 360.0f, "ADD_POLICE_RESTART: Invalid desired heading: %f",Heading);
	float fHeadingRad = fwAngle::LimitRadianAngleSafe(Heading * DtoR);

	if(SCRIPT_VERIFY(((WhenToUse >=0) && (WhenToUse<=3)), "ADD_POLICE_RESTART - Invalid Level"))
	{	
		if (VecPos.z <= INVALID_MINIMUM_WORLD_Z)
		{
			VecPos.z = WorldProbe::FindGroundZForCoord(TOP_SURFACE, VecPos.x, VecPos.y);
		}

		return CRestart::AddPoliceRestartPoint(VecPos, fHeadingRad, WhenToUse);
	}

	return -1;
}

void CommandDisablePoliceRestart(int index, bool bDisable)
{
	CRestart::DisablePoliceRestartPoint(index, bDisable);
}


void CommandOverrideNextRestart(const scrVector & scrVecCoors, float Heading)
{
	Vector3 VecPos = Vector3 (scrVecCoors);

	if (VecPos.z <= INVALID_MINIMUM_WORLD_Z)
	{
		VecPos.z = WorldProbe::FindGroundZForCoord(TOP_SURFACE, VecPos.x, VecPos.y);
	}

	// We're quite forgiving on script passing in a number in a good range
	Assertf(Heading >= -360.0f && Heading <= 360.0f, "OVERRIDE_NEXT_RESTART: Invalid desired heading: %f",Heading);
	float fHeadingRad = fwAngle::LimitRadianAngleSafe(Heading * DtoR);

	CRestart::OverrideNextRestart(VecPos, fHeadingRad);
}

void CommandCancelOverrideRestart()
{
	CRestart::CancelOverrideRestart();
}

void CommandPauseDeathArrestRestart(bool bPaused)
{
	CRestart::bPausePlayerRespawnAfterDeathArrest = bPaused;
}

void CommandIgnoreNextRestart(bool bIgnore)
{
	CRestart::SetIgnoreNextRestart(bIgnore);
}

void CommandSetFadeOutAfterDeath(bool bSuppressFade)
{
	bSuppressFade = !bSuppressFade;
	CRestart::bSuppressFadeOutAfterDeath = bSuppressFade;
}

void CommandSetFadeOutAfterArrest(bool bSuppressFade)
{
	bSuppressFade = !bSuppressFade;
	CRestart::bSuppressFadeOutAfterArrest = bSuppressFade;
}

void CommandSetFadeInAfterDeathArrest(bool bSuppressFade)
{
	bSuppressFade = !bSuppressFade;

	CRestart::bSuppressFadeInAfterDeathArrest = bSuppressFade;
}

void CommandSetFadeInAfterLoad(bool bFadeIn)
{
	if (bFadeIn)
	{
		CGenericGameStorage::ms_bFadeInAfterSuccessfulLoad = true;
	}
	else
	{
		CGenericGameStorage::ms_bFadeInAfterSuccessfulLoad = false;
	}
}


int CommmandRegisterSaveHouse(const scrVector & scrVecCoors, float Heading, const char *pRoomName, int MapAreaName, s32 playerModelNameHash)	//	bronx, brooklyn, manhat, nj
{
	Vector3 VecPos = Vector3 (scrVecCoors);

	if(SCRIPT_VERIFY(((MapAreaName >=0) && (MapAreaName<=3)), "REGISTER_SAVE_HOUSE - Invalid Level"))
	{
		return CRestart::AddSaveHouse(VecPos, Heading, pRoomName, MapAreaName, (u32) playerModelNameHash);
	}
	return -1;
}

void CommandEnableSaveHouse(int SaveHouseIndex, bool bNewEnabledFlag, bool bAvailableForAutosaves)
{
	CRestart::SetSaveHouseEnabled(SaveHouseIndex, bNewEnabledFlag, bAvailableForAutosaves);
}

bool CommandOverrideSaveHouse(bool bOverride, const scrVector & scrVecCoors, float fHeading, bool bIsAnAutosave, Vector3 &vecReturnCoords, float &fReturnHeading)
{
	Vector3 VecPos = Vector3(scrVecCoors);
	CRestart::SetSavehouseOverride(bOverride, VecPos, fHeading);

	return CGenericGameStorage::FindClosestSaveHouse(bIsAnAutosave, vecReturnCoords, fReturnHeading);
}

//	Script BOOLs use 4 bytes so BOOL& on the script side becomes s32& on the code side
bool CommandGetSaveHouseDetailsAfterSuccessfulLoad(Vector3 &vecReturnCoords, float &fReturnHeading, s32 &bReturnFadeIn, s32 &bReturnSnapToGround)
{
	vecReturnCoords = CGenericGameStorage::ms_vCoordsOfClosestSaveHouse;
	fReturnHeading = CGenericGameStorage::ms_fHeadingOfClosestSaveHouse;
	
	if (CGenericGameStorage::ms_bFadeInAfterSuccessfulLoad)
	{
		bReturnFadeIn = 1;
	}
	else
	{
		bReturnFadeIn = 0;
	}

	if (CGenericGameStorage::ms_bPlayerShouldSnapToGroundOnSpawn)
	{
		bReturnSnapToGround = 1;
	}
	else
	{
		bReturnSnapToGround = 0;
	}

	return CGenericGameStorage::ms_bClosestSaveHouseDataIsValid;
}


bool IsCurrentPlayerModelValid()
{
	CPlayerInfo* pPlayerInfo = CGameWorld::GetMainPlayerInfo();
	CPed *pPlayerPed = pPlayerInfo ? pPlayerInfo->GetPlayerPed() : NULL;

	if (Verifyf(pPlayerPed, "IsCurrentPlayerModelValid - failed to find the player ped"))
	{
		CPedModelInfo* mi = pPlayerPed->GetPedModelInfo();
		if(Verifyf(mi, "IsCurrentPlayerModelValid - failed to find model info for player ped"))
		{
			u32 modelNameHash = mi->GetModelNameHash();
			if ( (modelNameHash == MI_PLAYERPED_PLAYER_ZERO.GetName())
					|| (modelNameHash == MI_PLAYERPED_PLAYER_ONE.GetName())
					|| (modelNameHash == MI_PLAYERPED_PLAYER_TWO.GetName()) )
			{
				return true;
			}

			Assertf(0, "IsCurrentPlayerModelValid - checking player model before autosaving but it's %s so the save won't be made", mi->GetModelName());
		}
	}

	return false;
}

void CommandDoAutoSave()
{
	//	check that the player is signed in
	//	check that the device is still available

	//	could ask Derek if there's a good place to call frontend type code that needs to display while the game is running
	//	will have to bring up a message saying don't remove your memory card, switch off etc.
#if __BANK
	if (CScriptDebug::GetAutoSaveEnabled() == false)
	{
		return;
	}
#endif

	if (CPauseMenu::GetMenuPreference(PREF_AUTOSAVE) == false)
	{	//	autosave has been disabled so return immediately without queueing an operation
		return;
	}

	if (CNetwork::IsNetworkOpen() || NetworkInterface::IsAnySessionActive())
	{
		scriptAssertf(0, "DO_AUTO_SAVE - can't queue a single player save while any network session is active");
		return;
	}

	if (!IsCurrentPlayerModelValid())
	{
		return;
	}
	
	CGenericGameStorage::QueueAutosave();
}

bool CommandGetIsAutoSaveOff()
{
	if (CPauseMenu::GetMenuPreference(PREF_AUTOSAVE) == false)
	{
		return true;
	}

	return false;
}

bool CommandGetIsDisplayingSaveMessage()
{
	return CSavingMessage::IsDisplayingSavingMessage();
}

bool CommandIsAutoSaveInProgress()
{
	if ( (CGenericGameStorage::GetSaveOperation() == OPERATION_AUTOSAVING)	//	Return true if autosave is at the head of the savegame queue
		|| CSavegameQueue::ContainsAnAutosave())		//	or is anywhere in the queue. Maybe I only really need to do this second check.
	{
		return true;
	}
	else
	{
		return false;
	}
}

bool CommandHasCodeRequestedAutosave()
{
	return CTheScripts::GetCodeRequestedAutoSave();
}

void CommandClearCodeRequestedAutosave()
{
	CTheScripts::SetCodeRequestedAutoSave(false);
}

//	When a Replay Mission is passed
void CommandBeginReplayStats(s32 missionId, s32 missionType)
{
	CTheScripts::GetMissionReplayStats().BeginReplayStatsStructure(missionId, missionType);
}

void CommandAddReplayStatValue(s32 valueOfStat)
{
	CTheScripts::GetMissionReplayStats().AddStatValueToReplayStatsStructure(valueOfStat);
}

void CommandEndReplayStats()
{
	CTheScripts::GetMissionReplayStats().EndReplayStatsStructure();
}
//	End of "When a Replay Mission is passed"


//	When a Load happens and the script detects that it’s a Replay save file
bool CommandHaveReplayStatsBeenStored()
{
	return CTheScripts::GetMissionReplayStats().HaveReplayStatsBeenStored();
}

s32 CommandGetReplayStatMissionId()
{
	return CTheScripts::GetMissionReplayStats().GetReplayStatMissionId();
}

s32 CommandGetReplayStatMissionType()
{
	return CTheScripts::GetMissionReplayStats().GetReplayStatMissionType();
}

s32 CommandGetReplayStatCount()
{
	return CTheScripts::GetMissionReplayStats().GetNumberOfMissionStats();
}

s32 CommandGetReplayStatAtIndex(s32 arrayIndex)
{
	return CTheScripts::GetMissionReplayStats().GetStatValueAtIndex(arrayIndex);
}

// So that HAVE_REPLAY_STATS_BEEN_STORED() doesn't return TRUE on the next normal load
void CommandClearReplayStats()
{
	CTheScripts::GetMissionReplayStats().ClearReplayStatsStructure();
}
//	End of "When a Load happens and the script detects that it's a Replay save file"



bool CommandQueueMissionRepeatLoad()
{
	return CGenericGameStorage::QueueMissionRepeatLoad();
}

s32 CommandGetStatusOfMissionRepeatLoad()
{
	return CGenericGameStorage::GetMissionRepeatLoadStatus();
}

void CommandClearStatusOfMissionRepeatLoad()
{
	CGenericGameStorage::ClearMissionRepeatLoadStatus();
}

bool CommandQueueMissionRepeatSave()
{
	return CGenericGameStorage::QueueMissionRepeatSave(false);
}

bool CommandQueueMissionRepeatSaveForBenchmarkTest()
{
	return CGenericGameStorage::QueueMissionRepeatSave(true);
}

s32 CommandGetStatusOfMissionRepeatSave()
{
	return CGenericGameStorage::GetMissionRepeatSaveStatus();
}

void CommandClearStatusOfMissionRepeatSave()
{
	CGenericGameStorage::ClearMissionRepeatSaveStatus();
}


bool CommandCanStartMissionPassedTune()
{
	//	Script can play tune if autosave is off
	//	Or the spinning disc message is displayed (which should mean that all warning screens have been done)
	//	The script will probably need to check Keith's flag about do autosave when possible
	//	If this flag is false then it's safe to play the tune
	//	If this flag is true then check CAN_START_MISSION_PASSED_TUNE to decide
	if (CPauseMenu::GetMenuPreference(PREF_AUTOSAVE) == false)
	{
		return true;
	}

	if (CSavingMessage::IsDisplayingSavingMessage())
	{
		return true;
	}

	return false;
}

bool CommandIsMemoryCardInUse()
{
	if (CGenericGameStorage::IsStorageDeviceBeingAccessed())
	{
		return true;
	}

	return false;
}

void CommandSetRandomSeed(int NewSeed)
{
	CRandomScripts::SetRandomSeed(NewSeed);
}

void CommandSetRandomMWCSeed(int /*NewSeed*/)
{
	//CRandomMWCScripts::SetRandomSeed(NewSeed);
}

void CommandSetTimeScale(float fNewTimeScale)
{
#if __BANK
	GtaThread* pThread = CTheScripts::GetCurrentGtaScriptThread();
	if(pThread)
	{
		scriptDisplayf("SET_TIME_SCALE(%f): Called from Script:- %s", fNewTimeScale, pThread->GetScriptName() );
	}
#endif	//__BANK

	// disable any active special abilities, someone them have timewarps of their own and this will mess with them
	//   CPed* pPlayer = CGameWorld::FindLocalPlayer();
	//   if (pPlayer && pPlayer->GetSpecialAbility())
	//{
	//       pPlayer->GetSpecialAbility()->Deactivate();
	//	
	//	//! Force special ability time scale to reset. This mimics the previous behaviour before we split
	//	//! into seperate timers.
	//	pPlayer->GetSpecialAbility()->SetTimeWarp(1.0f);
	//}

	fwTimer::SetTimeWarpScript(fNewTimeScale);
}

void CommandSetMissionFlag(bool MissionFlagValue)
{
	if (MissionFlagValue)
	{
		if(SCRIPT_VERIFY(CTheScripts::GetCurrentGtaScriptThread()->IsThisAMissionScript == false, "SET_MISSION_FLAG - Flag for this script is already TRUE"))
		{
			if(SCRIPT_VERIFY(CTheScripts::GetPlayerIsOnAMission() == false, "SET_MISSION_FLAG - Flag is already TRUE (probably set by another script)"))
			{
//				if(SCRIPT_VERIFY(CTheScripts::GetPlayerIsOnARandomEvent() == false, "SET_MISSION_FLAG - player is already on a random event so can't start a mission"))
				{
					CTheScripts::SetPlayerIsOnAMission(true);
					CTheScripts::GetCurrentGtaScriptThread()->IsThisAMissionScript = true;

					CDebug::SetCurrentMissionTag(CTheScripts::GetCurrentScriptName());

					Displayf("SET_MISSION_FLAG called by %s\n", CTheScripts::GetCurrentScriptName());

#if __BANK
					// Reset max ragdoll counters used for the level
					if (fragInstNMGta::ms_bLogUsedRagdolls)
					{
						fragInstNMGta::ms_MaxNMAgentsUsedCurrentLevel = 0;
						fragInstNMGta::ms_MaxRageRagdollsUsedCurrentLevel = 0;
						fragInstNMGta::ms_MaxNMAgentsUsedInComboCurrentLevel = 0;
						fragInstNMGta::ms_MaxRageRagdollsUsedInComboCurrentLevel = 0;
						fragInstNMGta::ms_MaxTotalRagdollsUsedCurrentLevel = 0;
						fragInstNMGta::ms_NumFallbackAnimsUsedCurrentLevel = 0;
					}
#endif
				}
			}
		}
	}
	else
	{
		scriptAssertf(0, "%s:SET_MISSION_FLAG - should never need to call this with FALSE", CTheScripts::GetCurrentScriptNameAndProgramCounter());
	}
}

void CommandSetMissionNameDisplay(const char * DEV_ONLY(pMissionName))
{
#if __DEV
	// tell the debug system what the current mission is - used for bugstar (if active) and for the release info bar
	CDebug::SetCurrentMissionName(pMissionName);
#endif
}

void CommandInformCodeOfContentIDOfCurrentUGCMission(const char *pContentIdString)
{
	CTheScripts::SetContentIdOfCurrentUGCMission(pContentIdString);
}

bool CommandGetMissionFlag()
{
	return (CTheScripts::GetPlayerIsOnAMission());
}

void CommandSetRandomEventFlag(bool bThisScriptIsARandomEvent)
{
	if (bThisScriptIsARandomEvent)
	{
		if(SCRIPT_VERIFY(CTheScripts::GetCurrentGtaScriptThread()->GetIsARandomEventScript() == false, "SET_RANDOM_EVENT_FLAG - Flag for this script is already TRUE"))
		{
			if(SCRIPT_VERIFY(CTheScripts::GetPlayerIsOnARandomEvent() == false, "SET_RANDOM_EVENT_FLAG - Flag is already TRUE (probably set by another script)"))
			{
				if(SCRIPT_VERIFY(CTheScripts::GetPlayerIsOnAMission() == false, "SET_RANDOM_EVENT_FLAG - player is already on a mission so can't start a random event"))
				{
					CTheScripts::SetPlayerIsOnARandomEvent(true);
					CTheScripts::GetCurrentGtaScriptThread()->SetIsARandomEventScript(true);

					CDebug::SetCurrentMissionTag(CTheScripts::GetCurrentScriptName());

					Displayf("SET_RANDOM_EVENT_FLAG called by %s\n", CTheScripts::GetCurrentScriptName());
				}
			}
		}
	}
	else
	{
		scriptAssertf(0, "%s:SET_RANDOM_EVENT_FLAG - should never need to call this with FALSE", CTheScripts::GetCurrentScriptNameAndProgramCounter());
	}
}

bool CommandGetRandomEventFlag()
{
	return (CTheScripts::GetPlayerIsOnARandomEvent());
}


bool CommandGetBaseElementLocationFromMetadata(int& outVLocation, int& outVRotation, int element, bool bHighEndApt)
{
	//request struct
	scriptDebugf3("GetBaseElementLocationFromMetadata %d %s", element, bHighEndApt? "high end apartment" : "");

	CBaseElementLocation* elementFound = NULL;
	if(!CScriptMetadataManager::GetBaseElementLocation(&elementFound, element, bHighEndApt))
	{
		Assertf(0, "Base Element Location for item %d %s cannot be found", element, bHighEndApt? "high end apartment" : "");
		return false;
	}

	//buffer to write back to
	u8* pOutLocationBuffer = reinterpret_cast<u8*>(&outVLocation);
	memcpy(pOutLocationBuffer, &elementFound->m_location.x, sizeof(float));
	pOutLocationBuffer += sizeof(scrValue);
	memcpy(pOutLocationBuffer, &elementFound->m_location.y, sizeof(float));
	pOutLocationBuffer += sizeof(scrValue);
	memcpy(pOutLocationBuffer, &elementFound->m_location.z, sizeof(float));

	u8* pOutRotationBuffer = reinterpret_cast<u8*>(&outVRotation);
	memcpy(pOutRotationBuffer, &elementFound->m_rotation.x, sizeof(float));
	pOutRotationBuffer += sizeof(scrValue);
	memcpy(pOutRotationBuffer, &elementFound->m_rotation.y, sizeof(float));
	pOutRotationBuffer += sizeof(scrValue);
	memcpy(pOutRotationBuffer, &elementFound->m_rotation.z, sizeof(float));

	return true;
}

bool CommandGetBaseElementLocationFromMetadataBlock(int& outVLocation, int& outVRotation, int element, int dataBlock)
{
	//request struct
	scriptDebugf3("GetBaseElementLocationFromMetadata %d data block %d", element, dataBlock);

	CBaseElementLocation* elementFound = NULL;
	if(!CScriptMetadataManager::GetBaseElementLocationFromBlock(&elementFound, element, dataBlock))
	{
		Assertf(0, "Base Element Location for item %d data block %d cannot be found", element, dataBlock);
		return false;
	}

	//buffer to write back to
	u8* pOutLocationBuffer = reinterpret_cast<u8*>(&outVLocation);
	memcpy(pOutLocationBuffer, &elementFound->m_location.x, sizeof(float));
	pOutLocationBuffer += sizeof(scrValue);
	memcpy(pOutLocationBuffer, &elementFound->m_location.y, sizeof(float));
	pOutLocationBuffer += sizeof(scrValue);
	memcpy(pOutLocationBuffer, &elementFound->m_location.z, sizeof(float));

	u8* pOutRotationBuffer = reinterpret_cast<u8*>(&outVRotation);
	memcpy(pOutRotationBuffer, &elementFound->m_rotation.x, sizeof(float));
	pOutRotationBuffer += sizeof(scrValue);
	memcpy(pOutRotationBuffer, &elementFound->m_rotation.y, sizeof(float));
	pOutRotationBuffer += sizeof(scrValue);
	memcpy(pOutRotationBuffer, &elementFound->m_rotation.z, sizeof(float));

	return true;
}

const char* CommandGetContentToLoad()
{
#if RSG_SCE
	static char sysServiceArg[255] = {0};

	const char* paramArg = NULL;
	if(PARAM_LiveAreaLoadContent.Get(paramArg))
	{
		return paramArg;
	}
	else if(g_SysService.Args().GetParamValue("-LiveAreaLoadContent", sysServiceArg))
	{
		return sysServiceArg;
	}
	else
#endif // RSG_ORBIS
	{
		return "";
	}
}

void CommandActivityFeedCreate(const char* captionString, const char* condensedCaptionString)
{
#if RSG_ORBIS
	int key = atStringHash(condensedCaptionString);
	g_rlNp.GetNpActivityFeed().Start(key);

	for (int language = LANGUAGE_ENGLISH ; language < MAX_LANGUAGES; ++language)
	{
		const char* iso = fwLanguagePack::GetIsoLanguageCode( (sysLanguage)language );

		char caption[64] = {0};
		formatf( caption, sizeof(caption),"%s_%c%c", captionString, std::toupper(iso[0]), std::toupper(iso[1]));

		char condensed[64] = {0};
		formatf( condensed, sizeof(condensed),"%s_%c%c", condensedCaptionString, std::toupper(iso[0]), std::toupper(iso[1]));

		g_rlNp.GetNpActivityFeed().PostCaptions((sysLanguage)language, TheText.Get(caption), TheText.Get(condensed));
	}

	//g_rlNp.GetNpActivityFeed().PostThumbnailImageURL("https://media.rockstargames.com/socialclub/activity/ps4/V/gtav_68x68.png"); // title image is the same for all posts
#else
	UNUSED_VAR(captionString);
	UNUSED_VAR(condensedCaptionString);
#endif
}

void CommandActivityFeedAddSubStringToCaption(const char* subString)
{
#if RSG_ORBIS
	for (int language = LANGUAGE_ENGLISH ; language < MAX_LANGUAGES; ++language)
	{
		const char* iso = fwLanguagePack::GetIsoLanguageCode( (sysLanguage)language );

		char subStringWithIso[64] = {0};
		formatf( subStringWithIso, sizeof(subStringWithIso),"%s_%c%c", subString, std::toupper(iso[0]), std::toupper(iso[1]));

		scriptAssertf(TheText.DoesTextLabelExist(subStringWithIso), "Activity Feed AddSubstring - String has not been translated. Probably not been added to activityfeed gametext - %s", subStringWithIso);

		const char* stringToPrint = TheText.Get(subStringWithIso);
		g_rlNp.GetNpActivityFeed().AddSubStringToCaption((sysLanguage)language, stringToPrint);
	}

	g_rlNp.GetNpActivityFeed().ConfirmCaptionSubStringComplete();
#else
	UNUSED_VAR(subString);
#endif
}

void CommandActivityFeedAddLiteralSubStringToCaption(const char* subString)
{
#if RSG_ORBIS
	for (int language = LANGUAGE_ENGLISH ; language < MAX_LANGUAGES; ++language)
	{
		g_rlNp.GetNpActivityFeed().AddSubStringToCaption((sysLanguage)language, subString);
	}

	g_rlNp.GetNpActivityFeed().ConfirmCaptionSubStringComplete();
#else
	UNUSED_VAR(subString);
#endif
}

void CommandActivityFeedAddFloatToCaption(float subValue, int decimalPoint)
{
#if RSG_ORBIS
	g_rlNp.GetNpActivityFeed().AddSubValueToCaptionFloat(subValue, decimalPoint);
#else
	UNUSED_VAR(subValue);
	UNUSED_VAR(decimalPoint);
#endif
}

void CommandActivityFeedAddIntToCaption(int subValue)
{
#if RSG_ORBIS
	g_rlNp.GetNpActivityFeed().AddSubValueToCaptionInt(subValue);
#else
	UNUSED_VAR(subValue);
#endif
}

void CommandActivityFeedSmallImageURL(const char* urlString, const char* aspectRatio)
{
#if RSG_ORBIS
	g_rlNp.GetNpActivityFeed().PostSmallImageURL(urlString, aspectRatio);
#else
UNUSED_VAR(urlString);
UNUSED_VAR(aspectRatio);
#endif
}

void CommandActivityFeedLargeImageURL(const char* urlString)
{
#if RSG_ORBIS
	g_rlNp.GetNpActivityFeed().PostLargeImageURL(urlString);
#else
UNUSED_VAR(urlString);
#endif
}

void CommandActivityFeedVideoURL(const char* urlString)
{
#if RSG_ORBIS
	g_rlNp.GetNpActivityFeed().PostVideoURL(urlString);
#else
UNUSED_VAR(urlString);
#endif
}

void CommandActivityFeedPostCustomStory(const char* caption)
{
#if RSG_ORBIS
	g_rlNp.GetNpActivityFeed().PostCustomCaption(caption);
#else
	UNUSED_VAR(caption);
#endif
}

void CommandActivityFeedActionURL(const char* urlString, const char* labelString)
{
#if RSG_ORBIS
	g_rlNp.GetNpActivityFeed().PostActionURL(urlString);

	for (int language = LANGUAGE_ENGLISH ; language < MAX_LANGUAGES; ++language)
	{
		const char* iso = fwLanguagePack::GetIsoLanguageCode( (sysLanguage)language );

		char label[64] = {0};
		formatf( label, sizeof(label),"%s_%c%c", labelString, std::toupper(iso[0]), std::toupper(iso[1]));
	
		g_rlNp.GetNpActivityFeed().PostTagForActionURL((sysLanguage)language, TheText.Get(label));
	}
#else
UNUSED_VAR(urlString);
UNUSED_VAR(labelString);
#endif
}

void CommandActivityFeedActionURLWithThumbnail(const char* urlString, const char* labelString, const char* thumbnail)
{
#if RSG_ORBIS
	g_rlNp.GetNpActivityFeed().PostActionURL(urlString);
	g_rlNp.GetNpActivityFeed().PostThumbnailForActionURL(thumbnail);

	for (int language = LANGUAGE_ENGLISH ; language < MAX_LANGUAGES; ++language)
	{
		const char* iso = fwLanguagePack::GetIsoLanguageCode( (sysLanguage)language );

		char label[64] = {0};
		formatf( label, sizeof(label),"%s_%c%c", labelString, std::toupper(iso[0]), std::toupper(iso[1]));

		g_rlNp.GetNpActivityFeed().PostTagForActionURL((sysLanguage)language, TheText.Get(label));
	}
#else
	UNUSED_VAR(urlString);
	UNUSED_VAR(labelString);
	UNUSED_VAR(thumbnail);
#endif
}

void CommandActivityFeedActionURLAdd(const char* urlString)
{
#if RSG_ORBIS
	g_rlNp.GetNpActivityFeed().AppendActionURL(urlString);
#else
	UNUSED_VAR(urlString);
#endif
}

void CommandActivityFeedActionStart(const char* commandLineString, const char* labelString)
{
#if RSG_ORBIS
	g_rlNp.GetNpActivityFeed().PostActionStart(commandLineString);

	for (int language = LANGUAGE_ENGLISH ; language < MAX_LANGUAGES; ++language)
	{
		const char* iso = fwLanguagePack::GetIsoLanguageCode( (sysLanguage)language );

		char label[64] = {0};
		formatf( label, sizeof(label),"%s_%c%c", labelString, std::toupper(iso[0]), std::toupper(iso[1]));

		g_rlNp.GetNpActivityFeed().PostTagForActionStart((sysLanguage)language, TheText.Get(label));
	}
#else
UNUSED_VAR(commandLineString);
UNUSED_VAR(labelString);
#endif
}

void CommandActivityFeedActionStartWithThumbnail(const char* commandLineString, const char* labelString, const char* thumbnail)
{
#if RSG_ORBIS
	g_rlNp.GetNpActivityFeed().PostActionStart(commandLineString);
	g_rlNp.GetNpActivityFeed().PostThumbnailForActionStart(thumbnail);

	for (int language = LANGUAGE_ENGLISH ; language < MAX_LANGUAGES; ++language)
	{
		const char* iso = fwLanguagePack::GetIsoLanguageCode( (sysLanguage)language );

		char label[64] = {0};
		formatf( label, sizeof(label),"%s_%c%c", labelString, std::toupper(iso[0]), std::toupper(iso[1]));

		g_rlNp.GetNpActivityFeed().PostTagForActionStart((sysLanguage)language, TheText.Get(label));
	}
#else
	UNUSED_VAR(commandLineString);
	UNUSED_VAR(labelString);
	UNUSED_VAR(thumbnail);
#endif
}

void CommandActivityFeedActionStartAdd(const char* commandLineString)
{
#if RSG_ORBIS
	g_rlNp.GetNpActivityFeed().AppendActionStart(commandLineString);
#else
	UNUSED_VAR(commandLineString);
#endif
}

void CommandActivityFeedActionStore(const char* productCodeString, const char* labelString)
{
#if RSG_ORBIS
	g_rlNp.GetNpActivityFeed().PostActionStore(productCodeString);

	for (int language = LANGUAGE_ENGLISH ; language < MAX_LANGUAGES; ++language)
	{
		const char* iso = fwLanguagePack::GetIsoLanguageCode( (sysLanguage)language );

		char label[64] = {0};
		formatf( label, sizeof(label),"%s_%c%c", labelString, std::toupper(iso[0]), std::toupper(iso[1]));

		g_rlNp.GetNpActivityFeed().PostTagForActionStore((sysLanguage)language, TheText.Get(label));
	}
#else
UNUSED_VAR(productCodeString);
UNUSED_VAR(labelString);
#endif
}

void CommandActivityFeedActionStoreWithThumbnail(const char* productCodeString, const char* labelString, const char* thumbnail)
{
#if RSG_ORBIS
	g_rlNp.GetNpActivityFeed().PostActionStore(productCodeString);
	g_rlNp.GetNpActivityFeed().PostThumbnailForActionStore(thumbnail);

	for (int language = LANGUAGE_ENGLISH ; language < MAX_LANGUAGES; ++language)
	{
		const char* iso = fwLanguagePack::GetIsoLanguageCode( (sysLanguage)language );

		char label[64] = {0};
		formatf( label, sizeof(label),"%s_%c%c", labelString, std::toupper(iso[0]), std::toupper(iso[1]));

		g_rlNp.GetNpActivityFeed().PostTagForActionStore((sysLanguage)language, TheText.Get(label));
	}
#else
	UNUSED_VAR(productCodeString);
	UNUSED_VAR(labelString);
	UNUSED_VAR(thumbnail);
#endif
}

void CommandActivityFeedPost()
{
#if RSG_ORBIS
	g_rlNp.GetNpActivityFeed().PostCurrentMessage();
#endif // RSG_ORBIS
}

void CommandActivityFeedOnlinePlayedWithPost(const char* gameMode)
{
#if RSG_ORBIS
	// weirdly, can only post in one language, unlike the other activity feed post
	g_rlNp.GetNpActivityFeed().StartOnlinePlayedWith(TheText.Get(gameMode));

	unsigned                 numRemotePhysicalPlayers = netInterface::GetNumRemotePhysicalPlayers();
	const netPlayer * const *remotePhysicalPlayers    = netInterface::GetRemotePhysicalPlayers();

	for(u8 index = 0; index < numRemotePhysicalPlayers; ++index)
	{
		const netPlayer *remotePlayer = remotePhysicalPlayers[index];
		if (remotePlayer)
		{
			PhysicalPlayerIndex playerIndex = remotePlayer->GetPhysicalPlayerIndex();

			if(playerIndex != INVALID_PLAYER_INDEX)
			{
				g_rlNp.GetNpActivityFeed().AddOnlinePlayedWith( remotePlayer->GetGamerInfo().GetGamerHandle() );
			}
		}
	}

 	g_rlNp.GetNpActivityFeed().PostOnlinePlayedWith();

#else
	UNUSED_VAR(gameMode);
#endif // RSG_ORBIS
}

bool CommandHasResumedFromSuspend()
{
	return g_SysService.HasResumedFromSuspend();
}

void CommandSetScriptHighPrio(bool highPrio)
{
	CTheScripts::GetCurrentGtaScriptThread()->m_bIsHighPrio = highPrio;
	Displayf("SET_SCRIPT_HIGH_PRIO (%s) called by %s\n", highPrio ? "true" : "false", CTheScripts::GetCurrentScriptName());
}

void CommandSetThisIsATriggerScript(bool bThisScriptIsATriggerScript)
{
	CTheScripts::GetCurrentGtaScriptThread()->SetIsATriggerScript(bThisScriptIsATriggerScript);

	scriptDisplayf("SET_THIS_IS_A_TRIGGER_SCRIPT(%s) called by %s", bThisScriptIsATriggerScript?"true":"false", CTheScripts::GetCurrentScriptName());
}

u32 CommandGetPrevWeatherTypeHashName()
{
	u32 prevTypeIndex = g_weather.GetPrevTypeIndex();
	u32 prevTypeHashName = g_weather.GetTypeHashName(prevTypeIndex);
	return (*(reinterpret_cast<s32*>(&prevTypeHashName)));
}

u32 CommandGetNextWeatherTypeHashName()
{
	u32 nextTypeIndex = g_weather.GetNextTypeIndex();
	u32 nextTypeHashName = g_weather.GetTypeHashName(nextTypeIndex);
	return (*(reinterpret_cast<s32*>(&nextTypeHashName)));
}

bool CommandIsPrevWeatherType(const char* typeName)
{
	s32 typeIndex = g_weather.GetTypeIndex(typeName);

	if (typeIndex>=0 && typeIndex<(s32)g_weather.GetNumTypes())
	{
		return typeIndex==(s32)g_weather.GetPrevTypeIndex();
	}
	else
	{
		scriptAssertf(0, "Invalid Weather Type (%s) found in IS_PREV_WEATHER_TYPE", typeName);
		return false;
	}
}

bool CommandIsNextWeatherType(const char* typeName)
{
	s32 typeIndex = g_weather.GetTypeIndex(typeName);

	if (typeIndex>=0 && typeIndex<(s32)g_weather.GetNumTypes())
	{
		return typeIndex==(s32)g_weather.GetNextTypeIndex();
	}
	else
	{
		scriptAssertf(0, "Invalid Weather Type (%s) found in IS_NEXT_WEATHER_TYPE", typeName);
		return false;
	}
}

void CommandSetWeatherTypePersist(const char* typeName)
{
	// multiplayer has a global time
	if(!scriptVerifyf(!NetworkInterface::IsApplyingMultiplayerGlobalClockAndWeather(), "SET_WEATHER_TYPE_PERSIST :: Not supported in network games! Use SET_OVERRIDE_WEATHER / SET_WEATHER_TYPE_NOW_PERSIST"))
		return; 

	s32 typeIndex = g_weather.GetTypeIndex(typeName);

	if (typeIndex>=0 && typeIndex<(s32)g_weather.GetNumTypes())
	{
		g_weather.ForceType(typeIndex);
	}
	else
	{
		scriptAssertf(0, "Invalid Weather Type (%s) found in SET_WEATHER_TYPE_PERSIST", typeName);
	}
}

void CommandSetWeatherTypeNowPersist(const char* typeName)
{
	s32 typeIndex = g_weather.GetTypeIndex(typeName);

	if (typeIndex>=0 && typeIndex<(s32)g_weather.GetNumTypes())
	{
		g_weather.ForceTypeNow(typeIndex, CWeather::FT_None);
	}
	else
	{
		scriptAssertf(0, "Invalid Weather Type (%s) found in SET_WEATHER_TYPE_NOW_PERSIST", typeName);
	}
}

void CommandSetWeatherTypeNow(const char* typeName)
{
	// multiplayer has a global time
	if(!scriptVerifyf(!NetworkInterface::IsApplyingMultiplayerGlobalClockAndWeather(), "SET_WEATHER_TYPE_NOW :: Not supported in network games! Use SET_OVERRIDE_WEATHER / SET_WEATHER_TYPE_NOW_PERSIST"))
		return; 

	s32 typeIndex = g_weather.GetTypeIndex(typeName);

	if (typeIndex>=0 && typeIndex<(s32)g_weather.GetNumTypes())
	{
		g_weather.SetTypeNow(typeIndex);
	}
	else
	{
		scriptAssertf(0, "Invalid Weather Type (%s) found in SET_WEATHER_TYPE_NOW", typeName);
	}
}

void CommandSetWeatherTypeOvertimePersist(const char* typeName, float time)
{
	scriptDebugf1("%s : SET_WEATHER_TYPE_OVERTIME_PERSIST called. Weather Type :\"%s\", Time: %f", CTheScripts::GetCurrentScriptNameAndProgramCounter(), typeName, time);

	s32 typeIndex = g_weather.GetTypeIndex(typeName);

	if (typeIndex>=0 && typeIndex<(s32)g_weather.GetNumTypes())
	{
		g_weather.ForceWeatherTypeOverTime(typeIndex,time);
	}
	else
	{
		scriptAssertf(0, "Invalid Weather Type (%s) found in SET_WEATHER_TYPE_OVERTIME_PERSIST", typeName);
	}
}

void CommandSetRandomWeatherType()
{
    // multiplayer has a global time 
    if(!scriptVerifyf(!NetworkInterface::IsApplyingMultiplayerGlobalClockAndWeather(), "SET_RANDOM_WEATHER_TYPE :: Not supported in network games! Use SET_OVERRIDE_WEATHER."))
        return; 

	g_weather.RandomiseType();
}

void CommandClearWeatherTypePersist()
{
	g_weather.ForceTypeClear();
}

void CommandGetWeatherState(s32& prevTypeHashName, s32& nextTypeHashName, float& interpVal)
{
	u32 prevTypeIndex = g_weather.GetPrevTypeIndex();
	u32 prevTypeHashNameTemp = g_weather.GetTypeHashName(prevTypeIndex);
	prevTypeHashName = (*(reinterpret_cast<s32*>(&prevTypeHashNameTemp)));

	u32 nextTypeIndex = g_weather.GetNextTypeIndex();
	u32 nextTypeHashNameTemp = g_weather.GetTypeHashName(nextTypeIndex);
	nextTypeHashName = (*(reinterpret_cast<s32*>(&nextTypeHashNameTemp)));
	
	interpVal = g_weather.GetInterp();
}

void CommandSetWeatherState(s32 prevTypeHashName, s32 nextTypeHashName, float interpVal)
{
    // multiplayer has a global time 
    if(!scriptVerifyf(!NetworkInterface::IsApplyingMultiplayerGlobalClockAndWeather(), "SET_CURR_WEATHER_STATE :: Not supported in network games! Use SET_OVERRIDE_WEATHER."))
        return; 

	const s32 prevTypeIndex = g_weather.GetTypeIndex((u32)prevTypeHashName);
	g_weather.SetPrevTypeIndex(prevTypeIndex);

	const s32 nextTypeIndex = g_weather.GetTypeIndex((u32)nextTypeHashName);
	g_weather.SetNextTypeIndex(nextTypeIndex);

	g_weather.SetInterp(interpVal);
}

void CommandSetOverrideWeatherEx(const char* typeName, bool resetWetness)
{
	const s32 typeIndex = g_weather.GetTypeIndex(typeName);

	if (0 <= typeIndex && typeIndex < g_weather.GetNumTypes())
	{
		scriptDebugf1("%s : SET_OVERRIDE_WEATHER called. Weather Type :\"%s\"", CTheScripts::GetCurrentScriptNameAndProgramCounter(), typeName);
		g_weather.OverrideType(typeIndex, resetWetness);
	}
	else
	{
		scriptAssertf(0, "%s : SET_OVERRIDE_WEATHER - Invalid Weather Type :\"%s\"", CTheScripts::GetCurrentScriptNameAndProgramCounter(), typeName);
	}
}

void CommandSetOverrideWeather(const char* typeName)
{
	CommandSetOverrideWeatherEx(typeName, false);
}

void CommandClearOverrideWeather()
{
	scriptDebugf1("%s : CLEAR_OVERRIDE_WEATHER called", CTheScripts::GetCurrentScriptNameAndProgramCounter());
	g_weather.StopOverriding();
}

void CommandSetOverrideShoreWaveAmplitude(float value)
{
	g_weather.SetOverrideShoreWaveAmplitude(value);
}

void CommandSetOverrideShoreWaveMinAmplitude(float value)
{
	g_weather.SetOverrideShoreWaveMinAmplitude(value);
}
	
void CommandSetOverrideShoreWaveMaxAmplitude(float value)
{
	g_weather.SetOverrideShoreWaveMaxAmplitude(value);
}

void CommandSetOverrideOceanNoiseMinAmplitude(float value)
{
	g_weather.SetOverrideOceanNoiseMinAmplitude(value);
}

void CommandSetOverrideOceanWaveAmplitude(float value)
{
	g_weather.SetOverrideOceanWaveAmplitude(value);
}

void CommandSetOverrideOceanWaveMinAmplitude(float value)
{
	g_weather.SetOverrideOceanWaveMinAmplitude(value);
}

void CommandSetOverrideOceanWaveMaxAmplitude(float value)
{
	g_weather.SetOverrideOceanWaveMaxAmplitude(value);
}
		
void CommandSetOverrideRippleBumpiness(float value)
{
	g_weather.SetOverrideRippleBumpiness(value);
}

void CommandSetOverrideRippleMinBumpiness(float value)
{
	g_weather.SetOverrideRippleMinBumpiness(value);
}
			
void CommandSetOverrideRippleMaxBumpiness(float value)
{
	g_weather.SetOverrideRippleMaxBumpiness(value);
}

void CommandSetOverrideRippleDisturb(float value)
{
	g_weather.SetOverrideRippleDisturb(value);
}

void CommandSetWaterOverrideStrength(float value)
{
	g_weather.SetWaterOverrideStrength(value);
}

void CommandFadeInWaterOverrideOverTime(float time)
{
	g_weather.FadeInWaterOverrideOverTime(time);
}

void CommandFadeOutWaterOverrideOverTime(float time)
{
	g_weather.FadeOutWaterOverrideOverTime(time);
}

void CommandClearWeatherTypeNowPersistNetwork(int transitionTime)
{
	if(CNetwork::IsApplyingMultiplayerGlobalClockAndWeather() && transitionTime > 0)
		CNetwork::StartWeatherTransitionToGlobal(transitionTime); 
	else
		g_weather.ForceTypeNow(-1, CWeather::FT_None);
}

void CommandSetWind(float wind)
{
	g_weather.SetWindOverride(wind);
}

void CommandSetWindSpeed(float windSpeed)
{
	float windSpeedMax = g_weather.GetWindSpeedMax();
	scriptAssertf(windSpeed<windSpeedMax, "trying to set a wind speed greater than the maximum allowed (%.2f) - clamping to max", windSpeedMax);
	g_weather.SetWindOverride(MIN(windSpeed/windSpeedMax, 1.0f));
}

float CommandGetWindSpeed()
{
	return g_weather.GetWindSpeed();
}

float CommandGetWindSpeedMax()
{
	return g_weather.GetWindSpeedMax();
}

void CommandSetWindDirection(float windDir)
{
	g_weather.SetWindDirectionOverride(windDir);
}

scrVector CommandGetWindDirection()
{
	return VEC3V_TO_VECTOR3(g_weather.GetWindDirection());
}

void CommandSetRain(float rain)
{
	g_weather.SetRainOverride(rain);
}

float CommandGetRainLevel()
{
	return g_weather.GetRain();
}

void CommandSetSnow(float snow)
{
	g_weather.SetSnowOverride(snow);
}

float CommandGetSnowLevel()
{
	return g_weather.GetSnow();
}

void CommandForceLightningFlash()
{
	g_weather.ForceLightningFlash();
}

int CommandAddWindThermal(const scrVector & scrVecCoors, float radius, float height, float maxStrength, float deltaStrength)
{
	return g_weather.AddWindThermal(VECTOR3_TO_VEC3V((Vector3)scrVecCoors), radius, height, maxStrength, deltaStrength);
}

void CommandRemoveWindThermal(int index)
{
	g_weather.RemoveWindThermal(index);
}

void CommandCloudSettingsOverride(const char *pSettingsName)
{
	if (pSettingsName && (!stricmp(pSettingsName,"NULL")||!stricmp(pSettingsName,"NONE")))
		CClouds::OverrideCloudSettingName(NULL);
	else
		CClouds::OverrideCloudSettingName(pSettingsName);
}

void CommandPreloadCloudHat(const char *pCloudHatName)
{
	CloudHatManager::GetInstance()->PreloadCloudHatByName(pCloudHatName);
}

void CommandReleasePreloadCloudHat(const char *pCloudHatName)
{
	CloudHatManager::GetInstance()->ReleasePreloadCloudHatByName(pCloudHatName);
}

void CommandLoadCloudHat(const char *pCloudHatName, float transitionTime=0.0f)
{
	CloudHatManager::GetInstance()->LoadCloudHatByName(pCloudHatName, transitionTime);
}

void CommandUnloadCloudHat(const char *pCloudHatName, float transitionTime=0.0f)
{
	CloudHatManager::GetInstance()->UnloadCloudHatByName(pCloudHatName, transitionTime);
}

void CommandUnloadAllCloudHats()
{
	CloudHatManager::GetInstance()->UnloadAllCloudHats();
}

void CommandSetCloudHatAlpha(float alpha)
{
	scriptAssertf(alpha >= 0.0f && alpha <= 1.0f, "%s:SET_CLOUDS_ALPHA - Alpha of %f is out of range", CTheScripts::GetCurrentScriptNameAndProgramCounter(), alpha);
	CClouds::SetCloudAlpha(alpha);
}

void CommandResetCloudHatAlpha()
{
	CClouds::SetCloudAlpha(1.0f);
}

float CommandGetCloudHatAlpha()
{
	return CClouds::GetCloudAlpha();
}

int CommandGetGameTimer()
{
	return ((int) fwTimer::GetTimeInMilliseconds());
}

int CommandGetNumberOfMicrosecondsSinceLastCall()
{
	static utimer_t lastTick = 0;

	utimer_t thisTick = sysTimer::GetTicks();
	utimer_t diffTick = thisTick - lastTick;
	float fDiffTick = static_cast<float>(diffTick);
	fDiffTick *= sysTimer::GetTicksToMicroseconds();
	s32 ReturnTick = static_cast<s32>(fDiffTick);

	lastTick = thisTick;

	return ReturnTick;
}

float CommandGetScriptTimeWithinFrameInMicroseconds()
{
	return CTheScripts::GetScriptTimer().GetUsTime();
}

void CommandResetScriptTimeWithinFrame()
{
	CTheScripts::GetScriptTimer().Reset();
}

float CommandGetFrameTime()
{
	return fwTimer::GetTimeStep();
}

float CommandGetSystemTimeStep()
{
	return fwTimer::GetSystemTimeStep();
}

int CommandGetFrameCount()
{
	return ((int) fwTimer::GetFrameCount());
}

#if GEN9_STANDALONE_ENABLED
bool CommandGetScriptRouterContextData(ScriptRouterContextData * contextData)
{
	if (SCRIPT_VERIFY(contextData, "GET_SCRIPT_ROUTER_CONTEXT_DATA: Failed. contextData is null"))
	{
		if (SCRIPT_VERIFY(ScriptRouterLink::HasPendingScriptRouterLink(), "GET_SCRIPT_ROUTER_CONTEXT_DATA: Attempting to get empty script router context"))
		{
			return ScriptRouterLink::ParseScriptRouterLink(*contextData);
		}
	}
	return false;
}
#else // GEN9_STANDALONE_ENABLED
bool CommandGetScriptRouterContextData(DummyScriptRouterContextData* UNUSED_PARAM(contextData))
{
	return false;
}
#endif // GEN9_STANDALONE_ENABLED

#if GEN9_STANDALONE_ENABLED
bool CommandSetScriptRouterLink(ScriptRouterContextData* contextData)
{
	if (SCRIPT_VERIFY(contextData, "CREATE_SCRIPT_ROUTER_LINK: Failed. contextData is null"))
	{
		return ScriptRouterLink::SetScriptRouterLink(*contextData);
	}
	return false;
}
#else // GEN9_STANDALONE_ENABLED
bool CommandSetScriptRouterLink(DummyScriptRouterContextData* UNUSED_PARAM(contextData))
{
	return false;
}
#endif // GEN9_STANDALONE_ENABLED

int CommandGetScriptRouterLinkHash()
{
#if GEN9_STANDALONE_ENABLED
	return ScriptRouterLink::GetScriptRouterLinkHash();
#else // GEN9_STANDALONE_ENABLED
	return 0;
#endif // GEN9_STANDALONE_ENABLED
}

bool CommandHasPendingScriptRouterLink()
{
#if GEN9_STANDALONE_ENABLED
	return ScriptRouterLink::HasPendingScriptRouterLink();
#else // GEN9_STANDALONE_ENABLED
	return false;
#endif // GEN9_STANDALONE_ENABLED
}

void CommandClearScriptRouterLink()
{
#if GEN9_STANDALONE_ENABLED
	Displayf("CLEAR_SCRIPT_ROUTER_LINK");
	ScriptRouterLink::ClearScriptRouterLink();
#endif // GEN9_STANDALONE_ENABLED
}

void CommandReportInvalidScriptRouterArgument(const char* argument)
{
#if GEN9_STANDALONE_ENABLED && RSG_OUTPUT
	Errorf("REPORT_INVALID_SCRIPT_ROUTER_ARGUMENT: %s", argument);
#else
	UNUSED_VAR(argument);
#endif // GEN9_STANDALONE_ENABLED
}

#if GEN9_STANDALONE_ENABLED && RSG_PROSPERO
void CommandSetActivityScriptRoutingEnabled(bool bEnabled)
{
	Displayf("SET_ACTIVITY_SCRIPT_ROUTING_ENABLED(%s)", bEnabled ? "TRUE" : "FALSE");
	ScriptRouterContext::SetActivityScriptRoutingEnabled(bEnabled);
}
#else // GEN9_STANDALONE_ENABLED && RSG_PROSPERO 
void CommandSetActivityScriptRoutingEnabled(bool UNUSED_PARAM(bEnabled))
{

}
#endif // GEN9_STANDALONE_ENABLED && RSG_PROSPERO 

void CommandSetFakeWantedLevel(int iWantedLevel)
{
	if(CScriptHud::iFakeWantedLevel != iWantedLevel)
	{
		Displayf("SET_FAKE_WANTED_LEVEL. :%d\n", iWantedLevel);
		CScriptHud::iFakeWantedLevel = iWantedLevel;
	}

	CScriptHud::vFakeWantedLevelPos = CGameWorld::FindLocalPlayerCentreOfWorld();  // store current player pos

	CGameWorld::FindLocalPlayerWanted()->m_LastTimeWantedLevelChanged = fwTimer::GetTimeInMilliseconds();
}


int CommandGetFakeWantedLevel()
{
	return CScriptHud::iFakeWantedLevel;
}


float CommandGenerateRandomFloatInRange(float MinFloat, float MaxFloat)
{
	return ( CRandomScripts::GetRandomNumberInRange( MinFloat, MaxFloat ) );
}

int CommandGenerateRandomIntInRange(int MinInt, int MaxInt)
{
	return ( CRandomScripts::GetRandomNumberInRange(MinInt, MaxInt) );
}

int CommandGenerateRandomMWCIntInRange(int MinInt, int MaxInt)
{
	bool revertBehaviour = false;
	revertBehaviour = Tunables::GetInstance().TryAccess(CD_GLOBAL_HASH, ATSTRINGHASH("REVERT_MWC_TO_OLD", 0xc5debb40), false);

	if (revertBehaviour)
	{
		return ( CRandomScripts::GetRandomNumberInRange(MinInt, MaxInt) );
	} else
	{
		return ( CRandomMWCScripts::GetRandomNumberInRange(MinInt, MaxInt) );
	}
}

bool CommandGetGroundZFor3dCoord(const scrVector & scrVecCoors, float& ReturnZ, bool waterAsGround = false, bool ignoreDistToWaterLevelCheck = false)
{
	Vector3 VecPos = Vector3 (scrVecCoors);

	bool FoundGround = false;

	if(SCRIPT_VERIFY(VecPos.FiniteElements(), "GET_GROUND_Z_FOR_3D_COORD - 3D coords were bad (not finite)."))
	{
		ReturnZ = WorldProbe::FindGroundZFor3DCoord(TOP_SURFACE, VecPos.x, VecPos.y, VecPos.z, &FoundGround);
	}

	scriptDebugf1("CommandGetGroundZFor3dCoord: %f %f %f   ReturnZ: %f  Found ground: %s ", VecPos.x, VecPos.y, VecPos.z, ReturnZ, FoundGround ? "TRUE": "FALSE");

	if(waterAsGround)
	{
		float waterZ = 0.0f;
		bool bFoundWater = false;

		if (ignoreDistToWaterLevelCheck)
		{
			bFoundWater = CWaterTestHelper::GetWaterHeightAtPositionIncludingRivers(VecPos, &waterZ, false, FLT_MAX);
		}
		else
		{
			bFoundWater = CVfxHelper::GetWaterZ(VECTOR3_TO_VEC3V(VecPos), waterZ)!=WATERTEST_TYPE_NONE;
		}

		if (bFoundWater)
		{
			// If no ground was found but there's water, we're too far off shore
			if(!FoundGround)
			{
				ReturnZ = waterZ;
				FoundGround = true;
			}
			// If the water level is above the ground
			if(FoundGround && waterZ>ReturnZ)
			{
				ReturnZ = waterZ;
			}
		}

		scriptDebugf1("CommandGetGroundZFor3dCoord: IncludeWater: TRUE  Found water: %s   Water Z: %f ", bFoundWater ? "TRUE" : "FALSE", waterZ);
	}

	return (FoundGround);
}

bool CommandGetGroundZAndNormalFor3dCoord(const scrVector & scrVecCoors, float& ReturnZ, Vector3& ReturnNormal)
{
	Vector3 VecPos = Vector3(scrVecCoors);
	Vector3 VecNormal;
	bool bFoundGround = false;

	if(SCRIPT_VERIFY(VecPos.FiniteElements(), "GET_GROUND_Z_AND_NORMAL_FOR_3D_COORD - 3D coords were bad (not finite)."))
	{
	ReturnZ = WorldProbe::FindGroundZFor3DCoord(TOP_SURFACE, VecPos.x, VecPos.y, VecPos.z, &bFoundGround, &VecNormal);

	ReturnNormal.x = VecNormal.x;
	ReturnNormal.y = VecNormal.y;
	ReturnNormal.z = VecNormal.z;
	}

	scriptDebugf1("CommandGetGroundZAndNormalFor3dCoord:  Pos: %f %f %f  Found ground: %s  VecNormal: %f %f %f  ReturnZ: %f ", VecPos.x, VecPos.y, VecPos.z, bFoundGround ? "TRUE" : "FALSE", VecNormal.x, VecNormal.y, VecNormal.z, ReturnZ);

	return bFoundGround;
}

bool CommandGetGroundZExcludeObjectsFor3dCoord(const scrVector & scrVecCoors, float& ReturnZ, bool includeWater = false, bool ignoreDistToWaterLevelCheck = false)
{
	Vector3 VecPos = Vector3 (scrVecCoors);

	bool FoundGround = false;

	if(SCRIPT_VERIFY(VecPos.FiniteElements(), "GET_GROUND_Z_EXCLUDING_OBJECTS_FOR_3D_COORD - 3D coords were bad (not finite)."))
	{
		WorldProbe::CShapeTestProbeDesc probeDesc;
		WorldProbe::CShapeTestHitPoint probeIsect;
		WorldProbe::CShapeTestResults probeResult(probeIsect);
		probeDesc.SetStartAndEnd(VecPos, Vector3(scrVecCoors.x, scrVecCoors.y, -1000.0f));
		probeDesc.SetResultsStructure(&probeResult);
		probeDesc.SetIncludeFlags(ArchetypeFlags::GTA_ALL_MAP_TYPES);
		probeDesc.SetExcludeTypeFlags( ArchetypeFlags::GTA_OBJECT_TYPE );
		probeDesc.SetContext(WorldProbe::LOS_Unspecified);

		FoundGround = WorldProbe::GetShapeTestManager()->SubmitTest( probeDesc );

		if( FoundGround )
		{
			ReturnZ = probeResult[0].GetHitPosition().z;
		}
	}

	scriptDebugf1("CommandGetGroundZExcludeObjectsFor3dCoord:  Pos: %f %f %f  Found ground: %s  ReturnZ: %f ", VecPos.x, VecPos.y, VecPos.z, FoundGround ? "TRUE" : "FALSE", ReturnZ);

	if(includeWater)
	{
		float waterZ = 0.0f;
		bool bFoundWater = false;

		if (ignoreDistToWaterLevelCheck)
		{
			bFoundWater = CWaterTestHelper::GetWaterHeightAtPositionIncludingRivers(VecPos, &waterZ, false, FLT_MAX);
		}
		else
		{
			bFoundWater = CVfxHelper::GetWaterZ(VECTOR3_TO_VEC3V(VecPos), waterZ)!=WATERTEST_TYPE_NONE;
		}

		if(bFoundWater)
		{
			// If no ground was found but there's water, we're too far off shore
			if(!FoundGround)
			{
				ReturnZ = waterZ;
				FoundGround = true;
			}
			// If the water level is above the ground
			if(FoundGround && waterZ>ReturnZ)
			{
				ReturnZ = waterZ;
			}
		}

		scriptDebugf1("CommandGetGroundZExcludeObjectsFor3dCoord:  IncludeWater: TRUE   Found water: %s   Water Z: %f", bFoundWater ? "TRUE" : "FALSE", waterZ );
	}

	return (FoundGround);
}

bool CommandIsBulletInAngledArea(const scrVector & scrVecCoors1, const scrVector & scrVecCoors2, float AreaWidth, bool bIsPlayer)
{
	Vector3 pos1 = Vector3(scrVecCoors1);
	Vector3 pos2 = Vector3(scrVecCoors2);
	
	CPed* pPlayer = NULL;
	if (bIsPlayer)
	{
		pPlayer = CGameWorld::FindLocalPlayer();
		if(!SCRIPT_VERIFY(pPlayer, "IS_BULLET_IN_AREA - Can't Find Player Ped"))
			return false;

		if(!SCRIPT_VERIFY(pPlayer->GetPlayerInfo(), "IS_BULLET_IN_AREA - Can't Get Player Info"))
			return false;
	}

	bool rv = CBulletManager::ComputeIsBulletInAngledArea(pos1, pos2, AreaWidth, pPlayer);
	return rv;
}

bool CommandIsBulletInArea(const scrVector & scrVecCoors, float Radius, bool bIsPlayer)
{
	Vector3 VecPos = Vector3 (scrVecCoors);
	
	CPed* pPlayer = NULL;
	if (bIsPlayer)
	{
		pPlayer = CGameWorld::FindLocalPlayer();
		if(!SCRIPT_VERIFY(pPlayer, "IS_BULLET_IN_AREA - Can't Find Player Ped"))
			return false;

		if(!SCRIPT_VERIFY(pPlayer->GetPlayerInfo(), "IS_BULLET_IN_AREA - Can't Get Player Info"))
			return false;
	}

	bool rv = CBulletManager::ComputeIsBulletInSphere(VecPos, Radius, pPlayer);
	return rv;
}

bool CommandHasBulletImpactedInArea(const scrVector & scrVecCoors, float Radius, bool bIsPlayer, bool bEntryOnly)
{
	Vector3 VecPos = Vector3 (scrVecCoors);

	CPed* pPlayer = NULL;
	if (bIsPlayer)
	{
		pPlayer = CGameWorld::FindLocalPlayer();
		if(!SCRIPT_VERIFY(pPlayer, "HAS_BULLET_IMPACTED_IN_AREA - Can't Find Player Ped"))
			return false;

		if(!SCRIPT_VERIFY(pPlayer->GetPlayerInfo(), "HAS_BULLET_IMPACTED_IN_AREA - Can't Get Player Info"))
			return false;
	}

	bool rv = CBulletManager::ComputeHasBulletImpactedInSphere(VecPos, Radius, pPlayer, bEntryOnly);
	return rv;
}

int CommandGetNumBulletsImpactedInArea(const scrVector & scrVecCoors, float Radius, bool bIsPlayer, bool bEntryOnly)
{
	Vector3 VecPos = Vector3 (scrVecCoors);

	CPed* pPlayer = NULL;
	if (bIsPlayer)
	{
		pPlayer = CGameWorld::FindLocalPlayer();
		if(!SCRIPT_VERIFY(pPlayer, "GET_NUM_BULLETS_IMPACTED_IN_AREA - Can't Find Player Ped"))
			return false;

		if(!SCRIPT_VERIFY(pPlayer->GetPlayerInfo(), "GET_NUM_BULLETS_IMPACTED_IN_AREA - Can't Get Player Info"))
			return false;
	}

	int rv = CBulletManager::ComputeNumBulletsImpactedInSphere(VecPos, Radius, pPlayer, bEntryOnly);
	return rv;
}

// Arranges the values of the two vectors so that the volume of the locate box is calculated correctly
void RefactorValuesForAreaCheck (Vector3 &VecMin, Vector3 &VecMax)
{
	float temp_float;

	if (VecMin.x > VecMax.x)
	{
		temp_float = VecMin.x;
		VecMin.x = VecMax.x;
		VecMax.x = temp_float;
	}

	if (VecMin.y > VecMax.y)
	{
		temp_float = VecMin.y;
		VecMin.y = VecMax.y;
		VecMax.y = temp_float;
	}

	if (VecMin.z > VecMax.z)
	{
		temp_float = VecMin.z;
		VecMin.z = VecMax.z;
		VecMax.z = temp_float;
	}
}

bool CommandIsBulletInBox(const scrVector & scrVecMinCoors, const scrVector & scrVecMaxCoors, bool bIsPlayer)
{
	Vector3 VecPosMin = Vector3(scrVecMinCoors);
	Vector3 VecPosMax = Vector3(scrVecMaxCoors);
	
	CPed* pPlayer = NULL;
	if (bIsPlayer)
	{
		pPlayer = CGameWorld::FindLocalPlayer();
		if(!SCRIPT_VERIFY(pPlayer, "IS_BULLET_IN_BOX - Can't Find Player Ped"))
			return false;

		if(!SCRIPT_VERIFY(pPlayer->GetPlayerInfo(), "IS_BULLET_IN_BOX - Can't Get Player Info"))
			return false;
	}

	RefactorValuesForAreaCheck (VecPosMin, VecPosMax);

	bool rv = CBulletManager::ComputeIsBulletInBox(VecPosMin, VecPosMax, pPlayer);
	return rv;
}

bool CommandHasBulletImpactedInBox(const scrVector & scrVecMinCoors, const scrVector & scrVecMaxCoors, bool bIsPlayer, bool bEntryOnly)
{
	Vector3 VecPosMin = Vector3(scrVecMinCoors);
	Vector3 VecPosMax = Vector3(scrVecMaxCoors);
	
	CPed* pPlayer = NULL;
	if (bIsPlayer)
	{
		pPlayer = CGameWorld::FindLocalPlayer();
		if(!SCRIPT_VERIFY(pPlayer, "HAS_BULLET_IMPACTED_IN_BOX - Can't Find Player Ped"))
			return false;

		if(!SCRIPT_VERIFY(pPlayer->GetPlayerInfo(), "HAS_BULLET_IMPACTED_IN_BOX - Can't Get Player Info"))
			return false;
	}

	RefactorValuesForAreaCheck (VecPosMin, VecPosMax);

	bool rv = CBulletManager::ComputeHasBulletImpactedInBox(VecPosMin, VecPosMax, pPlayer, bEntryOnly);
	return rv;
}

bool CommandHasBulletImpactedBehindPlane(const scrVector & scrVecPlanePoint, const scrVector & scrVecPlaneNormal, bool bEntryOnly )
{
	Vector3 vPlanePoint = Vector3(scrVecPlanePoint);
	Vector3 vPlaneNormal = Vector3(scrVecPlaneNormal);
	bool rv = CBulletManager::ComputeHasBulletImpactedBehindPlane( vPlanePoint, vPlaneNormal, bEntryOnly );
	return rv;
}

int CommandGetNumBulletsImpactedInBox(const scrVector & scrVecMinCoors, const scrVector & scrVecMaxCoors, bool bIsPlayer, bool bEntryOnly)
{
	Vector3 VecPosMin = Vector3(scrVecMinCoors);
	Vector3 VecPosMax = Vector3(scrVecMaxCoors);

	CPed* pPlayer = NULL;
	if (bIsPlayer)
	{
		pPlayer = CGameWorld::FindLocalPlayer();
		if(!SCRIPT_VERIFY(pPlayer, "GET_NUM_BULLETS_IMPACTED_IN_BOX - Can't Find Player Ped"))
			return false;

		if(!SCRIPT_VERIFY(pPlayer->GetPlayerInfo(), "GET_NUM_BULLETS_IMPACTED_IN_BOX - Can't Get Player Info"))
			return false;
	}

	RefactorValuesForAreaCheck (VecPosMin, VecPosMax);

	int rv = CBulletManager::ComputeNumBulletsImpactedInBox(VecPosMin, VecPosMax, pPlayer, bEntryOnly);
	return rv;
}

float CommandASin( float x )
{
	if(SCRIPT_VERIFY( x >= -1.0f && x <= 1.0f, "X for ASIN out of range!" ))
	{
		return rage::Asinf( x ) * RtoD;
	}
	return 0.0f;
}

float CommandACos( float x )
{
	if(SCRIPT_VERIFY( x >= -1.0f && x <= 1.0f, "X for ACOS out of range!" ))
	{
		return rage::Acosf( x ) * RtoD;
	}
	return 0.0f;
}

float CommandTan( float x )
{
	return rage::Tanf( x * DtoR );
}

float CommandATan( float x )
{
	return rage::Atan2f( x,1 ) * RtoD;
}

float CommandATan2( float y, float x )
{
	return rage::Atan2f( y, x ) * RtoD;
}

bool ComamndLineIntersectsPlane(const scrVector & vscrPntA, const scrVector & vscrPntB, const scrVector & vscrPntOnPlane, const scrVector & vscrNormal, float &fTValue)
{
	//Convert to friendlier vector form
	Vector3 origin(vscrPntA.x, vscrPntA.y, vscrPntA.z);
	Vector3 ray(vscrPntB.x-vscrPntA.x, vscrPntB.y-vscrPntA.y, vscrPntB.z-vscrPntA.z);
	Vector3 vNormal(vscrNormal.x, vscrNormal.y, vscrNormal.z);
	Vector3 vPntOnPlane(vscrPntOnPlane.x, vscrPntOnPlane.y, vscrPntOnPlane.z);

	//Create plane equation
	Vector4 plane(vscrNormal.x, vscrNormal.y, vscrNormal.z, vNormal.Dot(vPntOnPlane));
	bool bReturn = geomSegments::CollideRayPlane(origin, ray, plane, &fTValue);
	return bReturn;
}

bool CommandPointAreaOverlap(const scrVector & A1, const scrVector & A2, float AWidth, const scrVector & B1, const scrVector & B2, float BWidth)
{
	Vector3 vA1(A1.x, A1.y, A1.z);
	Vector3 vA2(A2.x, A2.y, A2.z);
	Vector3 vB1(B1.x, B1.y, B1.z);
	Vector3 vB2(B2.x, B2.y, B2.z);

	if (vA1.IsClose(vA2, SMALL_FLOAT))
	{
		scriptAssertf(0, "%s:GET_POINT_AREA_OVERLAP: Box A has no length A1(%.2f,%.2f,%.2f) A2(%.2f,%.2f,%.2f)", CTheScripts::GetCurrentScriptNameAndProgramCounter(), vA1.x, vA1.y, vA1.z, vA2.x, vA2.y, vA2.z);
		return false;
	}
	else if (vB1.IsClose(vB2, SMALL_FLOAT))
	{
		scriptAssertf(0, "%s:GET_POINT_AREA_OVERLAP: Box B has no length B1(%.2f,%.2f,%.2f) B2(%.2f,%.2f,%.2f)", CTheScripts::GetCurrentScriptNameAndProgramCounter(), vB1.x, vB1.y, vB1.z, vB2.x, vB2.y, vB2.z);
		return false;
	}

	Vector3 vAForward = vA1 - vA2;
	vAForward.z = 0.0f;
	vAForward.Normalize();

	Vector3 vBForward = vB1 - vB2;
	vBForward.z = 0.0f;
	vBForward.Normalize();

	float fAHeight = abs(vA1.z - vA2.z);
	float fBHeight = abs(vB1.z - vB2.z);

	Mat34V MatA;
	Mat34VFromAxisAngle(MatA, VECTOR3_TO_VEC3V(vAForward), ScalarVFromF32(0.0f), VECTOR3_TO_VEC3V((vA1 + vA2)*0.5f));
	Mat34V MatB;
	Mat34VFromAxisAngle(MatB, VECTOR3_TO_VEC3V(vBForward), ScalarVFromF32(0.0f), VECTOR3_TO_VEC3V((vB1 + vB2)*0.5f));

	Mat34V RelativeMatrix;
	UnTransformOrtho(RelativeMatrix, MatA, MatB);
	
	Vec3V BoxA_hw(0.5f * AWidth, 0.5f * (vA2 - vA1).Mag(), 0.5f * fAHeight);
	Vec3V BoxB_hw(0.5f * BWidth, 0.5f * (vB2 - vB1).Mag(), 0.5f * fBHeight);

	return COT_TestBoxToBoxOBB(BoxA_hw, BoxB_hw, RelativeMatrix);
}

float CommandClosestTValueOnLine(const scrVector & vPointToTest, const scrVector & vA, const scrVector & vB, bool bClampToLine)
{
	//Convert to friendlier vector form
	Vec3V vecA(vA.x, vA.y, vA.z);
	Vec3V vecAtoB(vB.x - vA.x, vB.y - vA.y, vB.z - vA.z);
	Vec3V vecPnt(vPointToTest.x, vPointToTest.y, vPointToTest.z);

	//Get closest point
	//Calculate a TValue
	ScalarV vTValue;
	if (bClampToLine)
	{
		vTValue = geomTValues::FindTValueSegToPoint(vecA, vecAtoB, vecPnt);
	}
	else
	{
		vTValue = geomTValues::FindTValueOpenSegToPointV(vecA, vecAtoB, vecPnt);
	}
	return vTValue.Getf();
}

scrVector CommandClosestPointOnLine(const scrVector & vPointToTest, const scrVector & vA, const scrVector & vB, bool bClampToLine)
{
	//Convert to friendlier vector form
	Vec3V vecA(vA.x, vA.y, vA.z);
	Vec3V vecAtoB(vB.x - vA.x, vB.y - vA.y, vB.z - vA.z);
	Vec3V vecPnt(vPointToTest.x, vPointToTest.y, vPointToTest.z);

	//Calculate a TValue
	ScalarV vTValue;
	if (bClampToLine)
	{
		vTValue = geomTValues::FindTValueSegToPoint(vecA, vecAtoB, vecPnt);
	}
	else
	{
		vTValue = geomTValues::FindTValueOpenSegToPointV(vecA, vecAtoB, vecPnt);
	}

	//Re-project along line
	vecPnt = vecA + (vecAtoB * vTValue);

	//Convert and return
	return scrVector(vecPnt.GetXf(), vecPnt.GetYf(), vecPnt.GetZf());
}


#if DR_ENABLED

void DebugRecordStart()
{
	if (Verifyf(debugPlayback::DebugRecorder::GetInstance(), "DR_ENABLED but no recorder instance"))
	{
		debugPlayback::DebugRecorder::GetInstance()->StartRecording();
	}
}

void DebugRecordEnd()
{
	if (Verifyf(debugPlayback::DebugRecorder::GetInstance(), "DR_ENABLED but no recorder instance"))
	{
		debugPlayback::DebugRecorder::GetInstance()->StopRecording();
	}
}

void DebugRecordSave(const char *pFileName)
{
	if (Verifyf(debugPlayback::DebugRecorder::GetInstance(), "DR_ENABLED but no recorder instance"))
	{
		debugPlayback::DebugRecorder::GetInstance()->Save(pFileName);
	}
}

void DebugRecordThisInst(int objectIndex)
{
	const CEntity *pEntity = CTheScripts::GetEntityToQueryFromGUID<CEntity>(objectIndex);
	debugPlayback::SetTrackAllEntities(false);
	if (pEntity)
	{
		debugPlayback::SetCurrentSelectedEntity(pEntity->GetCurrentPhysicsInst(), true);
		debugPlayback::SetTrackMode(debugPlayback::eTrackOne);
	}
}

void DebugRecordClearInsts()
{
	debugPlayback::ClearSelectedEntities();
}

void DebugRecordInst(int objectIndex)
{
	const CEntity *pEntity = CTheScripts::GetEntityToQueryFromGUID<CEntity>(objectIndex);
	if (Verifyf(pEntity && pEntity->GetCurrentPhysicsInst(), "Passed in invalid inst to add to list"))
	{
		debugPlayback::AddSelectedEntity(*pEntity->GetCurrentPhysicsInst());
	}
}

void DebugRecordAllInsts()
{
	debugPlayback::SetTrackAllEntities(true);
}

void DebugRecordRecordString(const char * pID, const char * pValue)	//VA_ARGS from script?
{
	debugPlayback::SetUseScriptCallstack(true);
	debugPlayback::AddSimpleLabel(pID, pValue);
	debugPlayback::SetUseScriptCallstack(false);
}


void DebugRecordSimpleLine(const char *pLabel, const scrVector & scrVecA, const scrVector & scrVecB, const scrVector & scrVecColorA, const scrVector & scrVecColorB)
{
	if (Verifyf(debugPlayback::DebugRecorder::GetInstance(), "DR_ENABLED but no recorder instance"))
	{
		Vec3V vA(scrVecA.x, scrVecA.y, scrVecA.z);
		Vec3V vB(scrVecB.x, scrVecB.y, scrVecB.z);
		Color32 colorA(scrVecColorA.x, scrVecColorA.y, scrVecColorA.z, 1.0f);
		Color32 colorB(scrVecColorB.x, scrVecColorB.y, scrVecColorB.z, 1.0f);
		debugPlayback::SetUseScriptCallstack(true);
		debugPlayback::AddSimpleLine(pLabel, vA, vB, colorA, colorB);
		debugPlayback::SetUseScriptCallstack(false);
	}
}

void DebugRecordInstLine(int entityIndex, const char *pLabel, const scrVector & scrVecA, const scrVector & scrVecB, const scrVector & scrVecColorA, const scrVector & scrVecColorB)
{
	if (Verifyf(debugPlayback::DebugRecorder::GetInstance(), "DR_ENABLED but no recorder instance"))
	{
		const CEntity *pEntity = CTheScripts::GetEntityToQueryFromGUID<CEntity>(entityIndex);
		if (pEntity && pEntity->GetCurrentPhysicsInst())
		{
			Vec3V vA(scrVecA.x, scrVecA.y, scrVecA.z);
			Vec3V vB(scrVecB.x, scrVecB.y, scrVecB.z);
			Color32 colorA(scrVecColorA.x, scrVecColorA.y, scrVecColorA.z, 1.0f);
			Color32 colorB(scrVecColorB.x, scrVecColorB.y, scrVecColorB.z, 1.0f);
			debugPlayback::SetUseScriptCallstack(true);
			debugPlayback::RecordInstLine(*pEntity->GetCurrentPhysicsInst(), pLabel, vA, vB, colorA, colorB);
			debugPlayback::SetUseScriptCallstack(false);
		}
	}
}

void DebugRecordSimpleSphere(const char *pLabel, const scrVector & scrVecA, float fRadius, const scrVector & scrVecColorA)
{
	if (Verifyf(debugPlayback::DebugRecorder::GetInstance(), "DR_ENABLED but no recorder instance"))
	{
		Vec3V vA(scrVecA.x, scrVecA.y, scrVecA.z);
		Color32 colorA(scrVecColorA.x, scrVecColorA.y, scrVecColorA.z, 1.0f);
		debugPlayback::SetUseScriptCallstack(true);
		debugPlayback::AddSimpleSphere(pLabel, vA, fRadius, colorA);
		debugPlayback::SetUseScriptCallstack(false);
	}
}

void DebugRecordInstSphere(int entityIndex, const char *pLabel, const scrVector & scrVecA, float fRadius, const scrVector & scrVecColorA)
{
	if (Verifyf(debugPlayback::DebugRecorder::GetInstance(), "DR_ENABLED but no recorder instance"))
	{
		const CEntity *pEntity = CTheScripts::GetEntityToQueryFromGUID<CEntity>(entityIndex);
		if (pEntity && pEntity->GetCurrentPhysicsInst())
		{
			Vec3V vA(scrVecA.x, scrVecA.y, scrVecA.z);
			Color32 colorA(scrVecColorA.x, scrVecColorA.y, scrVecColorA.z, 1.0f);
			debugPlayback::SetUseScriptCallstack(true);
			debugPlayback::RecordInstSphere(*pEntity->GetCurrentPhysicsInst(), pLabel, vA, fRadius, colorA);
			debugPlayback::SetUseScriptCallstack(false);
		}
	}
}

void DebugRecordRecordInstString(int objectIndex, const char *pID, const char * pValue)	//VA_ARGS from script?
{
	if (Verifyf(debugPlayback::DebugRecorder::GetInstance(), "DR_ENABLED but no recorder instance"))
	{
		const CEntity *pEntity = CTheScripts::GetEntityToQueryFromGUID<CEntity>(objectIndex);
		if (pEntity && pEntity->GetCurrentPhysicsInst())
		{
			debugPlayback::SetUseScriptCallstack(true);
			debugPlayback::RecordInstLabel(*pEntity->GetCurrentPhysicsInst(), pID, pValue);
			debugPlayback::SetUseScriptCallstack(false);
		}
	}
}

void DebugRecordRecordInstFloat(int objectIndex, const char * pID, float fValue)
{
	if (Verifyf(debugPlayback::DebugRecorder::GetInstance(), "DR_ENABLED but no recorder instance"))
	{
		const CEntity *pEntity = CTheScripts::GetEntityToQueryFromGUID<CEntity>(objectIndex);
		if (pEntity && pEntity->GetCurrentPhysicsInst())
		{
			debugPlayback::SetUseScriptCallstack(true);
			debugPlayback::RecordTaggedFloatValue(*pEntity->GetCurrentPhysicsInst(), fValue, pID);
			debugPlayback::SetUseScriptCallstack(false);
		}
	}
}

void DebugRecordRecordInstVector(int objectIndex, const char *pID, const scrVector & vValue, bool bIsPosition)
{
	if (Verifyf(debugPlayback::DebugRecorder::GetInstance(), "DR_ENABLED but no recorder instance"))
	{
		const CEntity *pEntity = CTheScripts::GetEntityToQueryFromGUID<CEntity>(objectIndex);
		if (pEntity && pEntity->GetCurrentPhysicsInst())
		{
			Vec3V vecValue(vValue.x, vValue.y, vValue.z);
			debugPlayback::SetUseScriptCallstack(true);
			debugPlayback::RecordTaggedVectorValue(*pEntity->GetCurrentPhysicsInst(), vecValue, pID, bIsPosition ? debugPlayback::eVectorTypePosition : debugPlayback::eVectorTypeVelocity);
			debugPlayback::SetUseScriptCallstack(false);
		}
	}
}
#else
void DebugRecordStart(){};
void DebugRecordEnd(){};
void DebugRecordSave(const char *){};
void DebugRecordThisInst(int /*objectIndex*/){};
void DebugRecordInst(int /*objectIndex*/){};
void DebugRecordAllInsts(){};
void DebugRecordClearInsts(){};
void DebugRecordSimpleLine(const char *, const scrVector &, const scrVector &, const scrVector &, const scrVector &){};
void DebugRecordInstLine(int , const char *, const scrVector &, const scrVector &, const scrVector & , const scrVector &){};
void DebugRecordSimpleSphere(const char *, const scrVector &, float, const scrVector &){};
void DebugRecordInstSphere(int , const char *, const scrVector &, float , const scrVector &){};
void DebugRecordRecordString(const char * /*pID*/, const char * /*pValue*/){}
void DebugRecordRecordInstString(int /*objectIndex*/, const char * /*pID*/, const char * /*pValue*/){};
void DebugRecordRecordInstFloat(int /*objectIndex*/, const char * /*pID*/, float /*fValue*/){};
void DebugRecordRecordInstVector(int /*objectIndex*/, const char * /*pID*/, const scrVector & /*vValue*/){};
#endif

struct AreaOccupiedDataStruct
{
	bool FoundEntity;
	bool bCheckIsAlive;
	const CEntity * pExcludeEntity;
};


bool AnyEntitiesInAreaCB(CEntity* pEntity, void* data)
{
	Assert(pEntity);
	AreaOccupiedDataStruct* pAreaOccupiedData = reinterpret_cast<AreaOccupiedDataStruct*>(data);

	if (pAreaOccupiedData->FoundEntity == false && pEntity != pAreaOccupiedData->pExcludeEntity)
	{
		if (pAreaOccupiedData->bCheckIsAlive && pEntity->GetIsTypePed() && static_cast<CPed*>(pEntity)->IsDead())
			return true;
		pAreaOccupiedData->FoundEntity = true;
		return false;	// done with the callbacks, no need to get any more results
	}

	return(true);
}


bool AnyMissionEntitiesInAreaCB(CEntity* pEntity, void* data)
{
	Assert(pEntity);
	AreaOccupiedDataStruct* pAreaOccupiedData = reinterpret_cast<AreaOccupiedDataStruct*>(data);

	if (pAreaOccupiedData->FoundEntity == false && pEntity != pAreaOccupiedData->pExcludeEntity)
	{
		if (CTheScripts::IsMissionEntity(pEntity))
		{
			pAreaOccupiedData->FoundEntity = true;
			return false;	// done with the callbacks, no need to get any more results
		}
	}

	return(true);
}


bool IsSearchVolumeOccupied(fwSearchVolume & searchVolume, bool bBuildingFlag, bool bVehicleFlag, bool bPedFlag, bool bObjectFlag, bool bDummyFlag, bool bCheckAlive, int excludeGuid)
{
	AreaOccupiedDataStruct AreaOccupiedData;
	AreaOccupiedData.FoundEntity = false;
	AreaOccupiedData.pExcludeEntity = NULL;
	AreaOccupiedData.bCheckIsAlive = bCheckAlive;

	if (NULL_IN_SCRIPTING_LANGUAGE != excludeGuid)
	{
		AreaOccupiedData.pExcludeEntity = CTheScripts::GetEntityToQueryFromGUID<CEntity>(excludeGuid);
	}

	s32 typeFlags = 0;
	if (bBuildingFlag)
	{
		typeFlags |= ENTITY_TYPE_MASK_BUILDING;
	}

	if (bVehicleFlag)
	{
		typeFlags |= ENTITY_TYPE_MASK_VEHICLE;
	}

	if (bPedFlag)
	{
		typeFlags |= ENTITY_TYPE_MASK_PED;
	}

	if (bObjectFlag)
	{
		typeFlags |= ENTITY_TYPE_MASK_OBJECT;
	}

	if (bDummyFlag)
	{
		typeFlags |= ENTITY_TYPE_MASK_DUMMY_OBJECT;
	}

	SEARCH_OPTION_FLAGS SearchFlags = SEARCH_OPTION_DYNAMICS_ONLY;
	if (bBuildingFlag || bDummyFlag)
	{
		SearchFlags = SEARCH_OPTION_NONE;
	}

	CGameWorld::ForAllEntitiesIntersecting(&searchVolume, AnyEntitiesInAreaCB, static_cast<void*>(&AreaOccupiedData),
		typeFlags, SEARCH_LOCATION_EXTERIORS|SEARCH_LOCATION_INTERIORS, SEARCH_LODTYPE_HIGHDETAIL, SearchFlags, WORLDREP_SEARCHMODULE_SCRIPT);

	if (AreaOccupiedData.FoundEntity)
	{
		return true;
	}

	return false;
}

bool CommandIsAreaOccupied(const scrVector & scrVecMinCoors, const scrVector & scrVecMaxCoors, bool bBuildingFlag, bool bVehicleFlag, bool bPedFlag, bool bObjectFlag, bool bDummyFlag, int excludeGuid, bool bCheckAlive)
{
	Vector3 VecPosMin = Vector3 (scrVecMinCoors);
	Vector3 VecPosMax = Vector3 (scrVecMaxCoors);

	RefactorValuesForAreaCheck(VecPosMin, VecPosMax);

	spdAABB testBox;
	testBox.Set(RCC_VEC3V(VecPosMin), RCC_VEC3V(VecPosMax));
	fwIsBoxIntersectingApprox searchBox(testBox);
	return IsSearchVolumeOccupied(searchBox, bBuildingFlag, bVehicleFlag, bPedFlag, bObjectFlag, bDummyFlag, bCheckAlive, excludeGuid);
}

bool CommandIsAreaOccupiedAccurate(const scrVector & scrVecMinCoors, const scrVector & scrVecMaxCoors, bool bBuildingFlag, bool bVehicleFlag, bool bPedFlag, bool bObjectFlag, bool bDummyFlag, int excludeGuid, bool bCheckAlive)
{
	Vector3 VecPosMin = Vector3(scrVecMinCoors);
	Vector3 VecPosMax = Vector3(scrVecMaxCoors);

	RefactorValuesForAreaCheck(VecPosMin, VecPosMax);

	spdAABB testBox;
	testBox.Set(RCC_VEC3V(VecPosMin), RCC_VEC3V(VecPosMax));
	fwIsBoxIntersectingBB searchBox(testBox);
	return IsSearchVolumeOccupied(searchBox, bBuildingFlag, bVehicleFlag, bPedFlag, bObjectFlag, bDummyFlag, bCheckAlive, excludeGuid);
}

bool CommandIsPositionOccupied(const scrVector & scrVecCenterCoords, float radius, bool bBuildingFlag, bool bVehicleFlag, bool bPedFlag, bool bObjectFlag, bool bDummyFlag, int excludeGuid,bool  bCheckAlive)
{
	const Vector3 centre = Vector3(scrVecCenterCoords);
	fwIsSphereIntersecting searchSphere(spdSphere(RCC_VEC3V(centre), ScalarV(radius)));

	return IsSearchVolumeOccupied(searchSphere, bBuildingFlag, bVehicleFlag, bPedFlag, bObjectFlag, bDummyFlag, bCheckAlive, excludeGuid);
}


bool CommandIsPointObscuredByAMissionEntity(const scrVector & scrVecCoors, const scrVector & scrVecDimension, int excludeGuid)
{
	AreaOccupiedDataStruct AreaOccupiedData;
	AreaOccupiedData.FoundEntity = false;
	AreaOccupiedData.pExcludeEntity = NULL;

	if (NULL_IN_SCRIPTING_LANGUAGE != excludeGuid)
	{
		AreaOccupiedData.pExcludeEntity = CTheScripts::GetEntityToQueryFromGUID<CEntity>(excludeGuid);
	}

	Vector3 VecPos = Vector3 (scrVecCoors);
	Vector3 VecDimension = Vector3 (scrVecDimension);

	Vector3 vBoxMin;
	Vector3 vBoxMax;

	vBoxMin.x = VecPos.x - VecDimension.x; 
	vBoxMax.x = VecPos.x + VecDimension.x;
	vBoxMin.y = VecPos.y - VecDimension.y; 
	vBoxMax.y = VecPos.y + VecDimension.y;
	vBoxMin.z = VecPos.z - VecDimension.z;
	vBoxMax.z = VecPos.z + VecDimension.z;

	RefactorValuesForAreaCheck(vBoxMin, vBoxMax);

	spdAABB testBox;
	testBox.Set(RCC_VEC3V(vBoxMin), RCC_VEC3V(vBoxMax));

	fwIsBoxIntersectingApprox searchBox(testBox);
	CGameWorld::ForAllEntitiesIntersecting(&searchBox, AnyMissionEntitiesInAreaCB, static_cast<void*>(&AreaOccupiedData),
		ENTITY_TYPE_MASK_VEHICLE|ENTITY_TYPE_MASK_PED|ENTITY_TYPE_MASK_OBJECT, SEARCH_LOCATION_EXTERIORS|SEARCH_LOCATION_INTERIORS, SEARCH_LODTYPE_HIGHDETAIL, SEARCH_OPTION_DYNAMICS_ONLY, WORLDREP_SEARCHMODULE_SCRIPT);

	if (AreaOccupiedData.FoundEntity)
	{
		return true;
	}

	return false;
}

void CommandClearAreaOfProjectiles(const scrVector & vPos, float fRadius, bool bBroadcast)
{
	spdAABB spdBounds = spdAABB( spdSphere((Vec3V)vPos, ScalarV(fRadius)) );
	CProjectileManager::RemoveAllProjectilesInBounds(spdBounds);
	if (bBroadcast && NetworkInterface::IsGameInProgress())
	{
		CClearAreaEvent::Trigger(CTheScripts::GetCurrentGtaScriptHandler()->GetScriptId(), vPos, fRadius, CClearAreaEvent::CLEAR_AREA_FLAG_PROJECTILES);
	}
}

void CommandClearArea(const scrVector & scrVecCoors, float Radius, bool DeleteProjectilesFlag, bool bLeaveCarGenCars, bool bClearLowPriorityPickupsOnly, bool bBroadcast)
{
	Vector3 VecCoors = Vector3 (scrVecCoors);

	if (VecCoors.z <= INVALID_MINIMUM_WORLD_Z)
	{
		VecCoors.z = WorldProbe::FindGroundZForCoord(TOP_SURFACE, VecCoors.x, VecCoors.y);
	}

#if !__NO_OUTPUT
	//if(CVehicleFactory::ms_bLogDestroyedVehicles)
	{
		Displayf("******************************************************************************************************************************");
		Displayf("COMMAND_CLEAR_AREA from \"%s\" Position (%.1f,%.1f,%.1f) Radius:%.1f",
			CTheScripts::GetCurrentGtaScriptHandler()->GetScriptName(),
			VecCoors.x, VecCoors.y, VecCoors.z, Radius);
		Displayf("    DeleteProjectilesFlag:%s, bLeaveCarGenCars:%s, bClearLowPriorityPickupsOnly:%s, bBroadcast:%s",
			DeleteProjectilesFlag ? "true":"false",
			bLeaveCarGenCars ? "true":"false",
			bClearLowPriorityPickupsOnly ? "true":"false",
			bBroadcast ? "true":"false");
		Displayf("******************************************************************************************************************************");
	}
#endif

	CGameWorld::ClearExcitingStuffFromArea(VecCoors, Radius, DeleteProjectilesFlag, false, false, bLeaveCarGenCars, NULL, bClearLowPriorityPickupsOnly, true);

	if (bBroadcast && NetworkInterface::IsGameInProgress())
	{
		// inform other machines that this area is being cleared
		u32 clearFlags = CClearAreaEvent::CLEAR_AREA_FLAG_ALL;

		if (DeleteProjectilesFlag)
			clearFlags |= CClearAreaEvent::CLEAR_AREA_FLAG_PROJECTILES;

		if (!bLeaveCarGenCars)
			clearFlags |= CClearAreaEvent::CLEAR_AREA_FLAG_CARGENS;

		CClearAreaEvent::Trigger(CTheScripts::GetCurrentGtaScriptHandler()->GetScriptId(), VecCoors, Radius, clearFlags);
	}
}


void CommandClearAreaLeaveVehicleHealth( const scrVector & scrVecCoors, float Radius, bool DeleteProjectilesFlag, bool bLeaveCarGenCars, bool bClearLowPriorityPickupsOnly, bool bBroadcast )
{
#if __BANK
	if(CVehicleFactory::ms_bLogDestroyedVehicles)
	{
		Displayf("******************************************************************************************************************************");
		Displayf("CLEAR_AREA_LEAVE_VEHICLE_HEALTH from \"%s\" Position (%.1f,%.1f,%.1f) Radius:%.1f",
			CTheScripts::GetCurrentGtaScriptHandler()->GetScriptName(),
			scrVecCoors.x, scrVecCoors.y, scrVecCoors.z, Radius);
		Displayf("    DeleteProjectilesFlag:%s, bLeaveCarGenCars:%s, bClearLowPriorityPickupsOnly:%s, bBroadcast:%s",
			DeleteProjectilesFlag ? "true":"false",
			bLeaveCarGenCars ? "true":"false",
			bClearLowPriorityPickupsOnly ? "true":"false",
			bBroadcast ? "true":"false");
		Displayf("******************************************************************************************************************************");
	}
#endif

	Vector3 VecCoors = Vector3 (scrVecCoors);

	if (VecCoors.z <= INVALID_MINIMUM_WORLD_Z)
	{
		VecCoors.z = WorldProbe::FindGroundZForCoord(TOP_SURFACE, VecCoors.x, VecCoors.y);
	}
	CGameWorld::ClearExcitingStuffFromArea(VecCoors, Radius, DeleteProjectilesFlag, false, false, bLeaveCarGenCars, NULL, bClearLowPriorityPickupsOnly, true, false );

	if (bBroadcast && NetworkInterface::IsGameInProgress())
	{
		// inform other machines that this area is being cleared
		u32 clearFlags = CClearAreaEvent::CLEAR_AREA_FLAG_ALL;

		if (DeleteProjectilesFlag)
			clearFlags |= CClearAreaEvent::CLEAR_AREA_FLAG_PROJECTILES;

		if (!bLeaveCarGenCars)
			clearFlags |= CClearAreaEvent::CLEAR_AREA_FLAG_CARGENS;

		CClearAreaEvent::Trigger(CTheScripts::GetCurrentGtaScriptHandler()->GetScriptId(), VecCoors, Radius, clearFlags);
	}
}


void CommandClearAreaOfVehicles(const scrVector & scrVecCoors, float Radius, bool bLeaveCarGenCars, bool bCheckViewFrustum, bool bIfWrecked, bool bIfAbandoned, bool bBroadcast, bool bIfEngineOnFire, bool bKeepScriptTrains)
{
#if __BANK
	Displayf("******************************************************************************************************************************");
	Displayf("CLEAR_AREA_OF_VEHICLES from \"%s\" Position (%.1f,%.1f,%.1f) Radius:%.1f",
		CTheScripts::GetCurrentGtaScriptHandler()->GetScriptName(),
		scrVecCoors.x, scrVecCoors.y, scrVecCoors.z, Radius);
	Displayf("    bLeaveCarGenCars:%s, bCheckViewFrustum:%s, bIfWrecked:%s, bIfAbandoned:%s, bBroadcast:%s, bIfEngineOnFire:%s, bKeepScriptTrains:%s",
		bLeaveCarGenCars ? "true":"false",
		bCheckViewFrustum ? "true":"false",
		bIfWrecked ? "true":"false",
		bIfAbandoned ? "true":"false",
		bBroadcast ? "true":"false",
		bIfEngineOnFire ? "true":"false",
		bKeepScriptTrains ? "true":"false");
	Displayf("******************************************************************************************************************************");
#endif

	Vector3 VecCoors = Vector3 (scrVecCoors);

	if (VecCoors.z <= INVALID_MINIMUM_WORLD_Z)
	{
		VecCoors.z = WorldProbe::FindGroundZForCoord(TOP_SURFACE, VecCoors.x, VecCoors.y);
	}

	CGameWorld::ClearCarsFromArea(VecCoors, Radius, false, bLeaveCarGenCars, bCheckViewFrustum, bIfWrecked, bIfAbandoned, true, bIfEngineOnFire, bKeepScriptTrains);

	if (bBroadcast && NetworkInterface::IsGameInProgress())
	{
		u32 clearFlags = CClearAreaEvent::CLEAR_AREA_FLAG_VEHICLES;

		if (!bLeaveCarGenCars)
			clearFlags |= CClearAreaEvent::CLEAR_AREA_FLAG_CARGENS;

		if(bCheckViewFrustum)
			clearFlags |= CClearAreaEvent::CLEAR_AREA_FLAG_CHECK_ALL_PLAYERS_FRUSTUMS;

		if(bIfWrecked)
			clearFlags |= CClearAreaEvent::CLEAR_AREA_FLAG_WRECKED_STATUS;

		if(bIfAbandoned)
			clearFlags |= CClearAreaEvent::CLEAR_AREA_FLAG_ABANDONED_STATUS;

		if (bIfEngineOnFire)
			clearFlags |= CClearAreaEvent::CLEAR_AREA_FLAG_ENGINE_ON_FIRE;

		// inform other machines that this area is being cleared
		CClearAreaEvent::Trigger(CTheScripts::GetCurrentGtaScriptHandler()->GetScriptId(), VecCoors, Radius, clearFlags);
	}
}

void CommandClearAngledAreaOfVehicles(const scrVector & scrVecAngledAreaPoint1, const scrVector & scrVecAngledAreaPoint2, float DistanceOfOppositeFace, bool bLeaveCarGenCars, bool bBroadcast, bool bCheckViewFrustum, bool bIfWrecked, bool bIfAbandoned, bool bIfEngineOnFire, bool bKeepScriptTrains)
{
#if __BANK
	if(CVehicleFactory::ms_bLogDestroyedVehicles)
	{
		Displayf("******************************************************************************************************************************");
		Displayf("CLEAR_ANGLED_AREA_OF_VEHICLES from \"%s\" Pt1 (%.1f,%.1f,%.1f) Pt2 (%.1f,%.1f,%.1f) Dist:%.1f",
			CTheScripts::GetCurrentGtaScriptHandler()->GetScriptName(),
			scrVecAngledAreaPoint1.x, scrVecAngledAreaPoint1.y, scrVecAngledAreaPoint1.z,
			scrVecAngledAreaPoint2.x, scrVecAngledAreaPoint2.y, scrVecAngledAreaPoint2.z,
			DistanceOfOppositeFace);
		Displayf("bLeaveCarGenCars:%s, bCheckViewFrustum:%s, bIfWrecked:%s, bIfAbandoned:%s, bBroadcast:%s, bIfEngineOnFire:%s, bKeepScriptTrains:%s",
			bLeaveCarGenCars ? "true":"false",
			bCheckViewFrustum ? "true":"false",
			bIfWrecked ? "true":"false",
			bIfAbandoned ? "true":"false",
			bBroadcast ? "true":"false",
			bIfEngineOnFire ? "true":"false",
			bKeepScriptTrains ? "true":"false");
		Displayf("******************************************************************************************************************************");
	}
#endif

	Vector3 vecAngledAreaPoint1 = Vector3(scrVecAngledAreaPoint1);
	Vector3 vecAngledAreaPoint2 = Vector3(scrVecAngledAreaPoint2);

	CGameWorld::ClearCarsFromAngledArea(vecAngledAreaPoint1, vecAngledAreaPoint2, DistanceOfOppositeFace, false, bLeaveCarGenCars, bCheckViewFrustum, bIfWrecked, bIfAbandoned, true, bIfEngineOnFire, bKeepScriptTrains);

	if (bBroadcast && NetworkInterface::IsGameInProgress())
	{
		scriptAssertf(0, "%s:CLEAR_ANGLED_AREA_OF_VEHICLES - this is not supported in multi-player. See JohnG", CTheScripts::GetCurrentScriptNameAndProgramCounter());
	}
}

void ClearAreaOfObjects(const scrVector & scrVecCoors, float Radius, s32 controlFlags=0)
{
	Vector3 VecCoors = Vector3 (scrVecCoors);

	if (VecCoors.z <= INVALID_MINIMUM_WORLD_Z)
	{
		VecCoors.z = WorldProbe::FindGroundZForCoord(TOP_SURFACE, VecCoors.x, VecCoors.y);
	}

#if !__NO_OUTPUT
	Displayf("******************************************************************************************************************************");
	Displayf("CLEAR_AREA_OF_OBJECTS from \"%s\" Position (%.1f,%.1f,%.1f) Radius:%.1f controlFlags:%d",
		CTheScripts::GetCurrentGtaScriptHandler()->GetScriptName(),
		VecCoors.x, VecCoors.y, VecCoors.z, Radius, controlFlags);
	Displayf("******************************************************************************************************************************");
#endif

	const bool bFlagForce			= (controlFlags & CLEAROBJ_FLAG_FORCE)!=0;
	const bool bFlagIncludeDoors	= (controlFlags & CLEAROBJ_FLAG_INCLUDE_DOORS)!=0;
	const bool bFlagObjsWithBrains	= (controlFlags & CLEAROBJ_FLAG_INCLUDE_OBJWITHBRAINS)!=0;
	const bool bFlagBroadcast		= (controlFlags & CLEAROBJ_FLAG_BROADCAST)!=0;
	const bool bFlagExcludeLadders	= (controlFlags & CLEAROBJ_FLAG_EXCLUDE_LADDERS)!=0;
	
	CGameWorld::ClearObjectsFromArea(VecCoors, Radius, bFlagObjsWithBrains, NULL, bFlagForce, bFlagIncludeDoors, bFlagExcludeLadders);

	if (bFlagBroadcast && NetworkInterface::IsGameInProgress())
	{
		// inform other machines that this area is being cleared
		CClearAreaEvent::Trigger(CTheScripts::GetCurrentGtaScriptHandler()->GetScriptId(), VecCoors, Radius, CClearAreaEvent::CLEAR_AREA_FLAG_OBJECTS);
	}
}

void CommandClearAreaOfObjects(const scrVector & scrVecCoors, float Radius, s32 controlFlags/*=0*/)
{
#if __BANK
	Displayf("******************************************************************************************************************************");
	Displayf("CLEAR_AREA_OF_OBJECTS from \"%s\" Position (%.1f,%.1f,%.1f) Radius:%.1f",
		CTheScripts::GetCurrentGtaScriptHandler()->GetScriptName(),
		scrVecCoors.x, scrVecCoors.y, scrVecCoors.z, Radius);
	Displayf("    controlFlags:%x, ",
		controlFlags);
	Displayf("******************************************************************************************************************************");
#endif
	ClearAreaOfObjects(scrVecCoors, Radius, controlFlags);
}

void CommandClearAreaOfPeds(const scrVector & scrVecCoors, float Radius, bool bBroadcast)
{
	Vector3 VecCoors = Vector3 (scrVecCoors);

	if (VecCoors.z <= INVALID_MINIMUM_WORLD_Z)
	{
		VecCoors.z = WorldProbe::FindGroundZForCoord(TOP_SURFACE, VecCoors.x, VecCoors.y);
	}
	CGameWorld::ClearPedsFromArea(VecCoors, Radius);

	if (bBroadcast && NetworkInterface::IsGameInProgress())
	{
		// inform other machines that this area is being cleared
		CClearAreaEvent::Trigger(CTheScripts::GetCurrentGtaScriptHandler()->GetScriptId(), VecCoors, Radius, CClearAreaEvent::CLEAR_AREA_FLAG_PEDS);
	}
}

void CommandClearAreaOfCops(const scrVector & scrVecCoors, float Radius, bool bBroadcast)
{
	Vector3 VecCoors = Vector3 (scrVecCoors);

	if (VecCoors.z <= INVALID_MINIMUM_WORLD_Z)
	{
		VecCoors.z = WorldProbe::FindGroundZForCoord(TOP_SURFACE, VecCoors.x, VecCoors.y);
	}
	CGameWorld::ClearCopsFromArea(VecCoors, Radius);

	if (bBroadcast && NetworkInterface::IsGameInProgress())
	{
		// inform other machines that this area is being cleared
		CClearAreaEvent::Trigger(CTheScripts::GetCurrentGtaScriptHandler()->GetScriptId(), VecCoors, Radius, CClearAreaEvent::CLEAR_AREA_FLAG_COPS);
	}
}

void CommandClearScenarioSpawnHistory()
{
	CScenarioManager::GetSpawnHistory().ClearHistory();
}

void CommandActivateSaveMenu(bool bAllowWhilePlayerIsInAVehicle)
{
	if (CGameWorld::FindLocalPlayer())
	{
		if (bAllowWhilePlayerIsInAVehicle || (CGameWorld::FindLocalPlayer()->GetPedConfigFlag( CPED_CONFIG_FLAG_InVehicle ) == false) )
		{	
			// stop the player and request the frontend opens up in savegame mode:
			CGameWorld::FindLocalPlayer()->SetVelocity(Vector3(0,0,0));
			CGameWorld::FindLocalPlayer()->SetAngVelocity(Vector3(0,0,0));
			CSavegameSave::SetSaveHasJustOccurred(false);

			CPauseMenu::QueueOpen(FE_MENU_VERSION_SAVEGAME);
		}
	}
}

int CommandGetStatusOfManualSave()
{
	return CPauseMenu::sm_ManualSaveStructure.GetStatus();
}

bool CommandDidSaveCompleteSuccessfully()
{
	if (CSavegameSave::GetSaveHasJustOccurred())
	{
		return true;
	}
	else
	{
		return false;
	}
}
/*
void CommandActivateNetworkSettingsMenu()
{
	if (CGameWorld::FindLocalPlayer())
	{
		//if (CGameWorld::FindLocalPlayer()->GetPedConfigFlag( CPED_CONFIG_FLAG_InVehicle ) == false) // Removed - See BUG 65128
		{	
			// stop the player and request the frontend opens up in savegame mode:
			CGameWorld::FindLocalPlayer()->SetVelocity(Vector3(0,0,0));
			CGameWorld::FindLocalPlayer()->SetAngVelocity(Vector3(0,0,0));
			CFrontEnd::RequestState(FRONTEND_STATE_OPEN_PLAYERSETTINGS);
		}
	}
}*/

void CommandSetNetworkMenu (bool UNUSED_PARAM(bActive))
{
	scriptAssertf(0, "SET_NETWORK_SETTINGS_MENU - depreciated command!  shouldnt be used!");

/*	if (bActive)
	{
		CommandActivateNetworkSettingsMenu();
	}
	else
	{
		if (CFrontEnd::IsInPlayerSettingsMenus())
		{	
			CFrontEnd::RequestState(FRONTEND_STATE_CLOSE);
		}
	}*/
}


bool CommandIsGermanVersion()
{
	return CLocalisation::GermanGame();
}

bool CommandIsAussieVersion()
{
	return CLocalisation::AussieGame();
}

bool CommandIsJapaneseVersion()
{
	return sysAppContent::IsJapaneseBuild();
}

void CommandSetCreditsActive (bool bActive )
{
	if (bActive)
	{
		CCredits::Init(INIT_AFTER_MAP_LOADED);
	}
	else
	{
		CCredits::Shutdown(SHUTDOWN_WITH_MAP_LOADED);
	}
}

void CommandSetCreditsFadeOutWithScreen(bool bFade)
{
	CCredits::SetToRenderBeforeFade(bFade);
}

bool CommandHaveCreditsReachedEnd()
{
	return (CCredits::HaveReachedEnd());
}

bool CommandAreCreditsRunning()
{
	return (CCredits::IsRunning());
}

void CommandTerminateAllScriptsWithThisName(const char *pName)
{
	if(SCRIPT_VERIFY((stricmp(CTheScripts::GetCurrentScriptName(), pName) != 0),"TERMINATE_ALL_SCRIPTS_WITH_THIS_NAME - Script can't terminate itself using this command"))
	{	
		GtaThread::KillAllThreadsWithThisName(pName);
	}
}

//	void CommandTerminateAllScriptsForNetworkGame()
//	{
//		GtaThread::KillAllThreadsForNetworkGame();
//		CTheScripts::GetScriptBrainDispatcher().PurgeWaitingItems();
//	}


// Check with Keith about removing this command and relying on the HAS_FORCE_CLEANUP_OCCURRED flags instead.
//	Any script that is currently calling NETWORK_SET_SCRIPT_IS_SAFE_FOR_NETWORK_GAME probably shouldn't be checking FORCE_CLEANUP_FLAG_SP_TO_MP.
void CommandThisScriptIsSafeForNetworkGame()
{
	CTheScripts::GetScriptHandlerMgr().SetScriptAsSafeToRunInMP(*CTheScripts::GetCurrentGtaScriptThread());
}

bool CommandGetIsScriptSafeForNetworkGame()
{
	return CTheScripts::GetCurrentGtaScriptThread()->bSafeForNetworkGame;
}

void CommandSetPlayerControlOnInMissionCleanup(bool bSetPlayerControlOnInCleanup)
{
	//	default setting is true
	if(SCRIPT_VERIFY(CTheScripts::GetCurrentGtaScriptThread()->IsThisAMissionScript, "SET_PLAYER_CONTROL_ON_IN_MISSION_CLEANUP - can only call this in a mission script"))
	{
		if (bSetPlayerControlOnInCleanup)
		{
			CTheScripts::GetCurrentGtaScriptThread()->bSetPlayerControlOnInMissionCleanup = true;
		}
		else
		{
			CTheScripts::GetCurrentGtaScriptThread()->bSetPlayerControlOnInMissionCleanup = false;
		}
	}
}


float CommandGetDistanceBetweenCoords(const scrVector & scrVecFirstCoors, const scrVector & scrVecSecondCoors, bool bCheck3d)
{
	Vector3 vecDiff;
	float ReturnDistance;
	
	Vector3 vecFirst = Vector3(scrVecFirstCoors);
	Vector3 vecSecond = Vector3(scrVecSecondCoors);

	if (!bCheck3d)
	{
		vecFirst.z = 0.0f;
		vecSecond.z = 0.0f;
	}
	
	vecDiff = vecFirst - vecSecond;
	ReturnDistance = vecDiff.Mag();

	return ReturnDistance;

}

float CommandGetAngleBetween2dVectors(float X1, float Y1, float X2, float Y2)
{
	float ResultAngle;
	ResultAngle = ((X1 * X2) + (Y1 * Y2));
	ResultAngle /= (   rage::SqrtfSafe((X1 * X1) + (Y1 * Y1))  *  rage::SqrtfSafe((X2 * X2) + (Y2 * Y2)) );
	ResultAngle = rage::Max(-1.0f, ResultAngle);		// Rounding errors can cause the value to be outside (-1.0 .. 1.0). This messes up the acos.
	ResultAngle = rage::Min(1.0f, ResultAngle);
	ResultAngle = rage::AcosfSafe(ResultAngle);
	ResultAngle = ( RtoD * ResultAngle);
	
	return ResultAngle;
}

float CommandGetHeadingFromVector2d(float VecX, float VecY)
{
	float temp_float;

	temp_float = fwAngle::GetATanOfXY( VecX, VecY );
	temp_float = ( RtoD * temp_float);
	temp_float -= 90.0f;
	while (temp_float < 0.0f)
	{
		temp_float += 360.0f;
	}

	return temp_float;
}

u8 m_fakeVehicleSequence = 0;
u8 AllocateVehicleFakeSequence()
{
	u8 result = m_fakeVehicleSequence;
	if((m_fakeVehicleSequence + 1) >= CNetworkPendingProjectiles::MAX_PENDING_PROJECTILES)
	{
		m_fakeVehicleSequence = CNetworkPendingProjectiles::MAX_PENDING_PROJECTILES_PER_TYPE;
	}
	else
	{
		m_fakeVehicleSequence++;
	}

	return result;
}

void CommandFireSingleBulletIgnoreEntityNew(const scrVector & scrVecStartCoors, const scrVector & scrVecEndCoors, int DamageCaused, bool bSetPerfectAccuracy, s32 WeaponType, s32 PedIndex, bool bCreateTraceVfx, bool bAllowRumble, float InitialVelocity, int IgnoreEntity, bool bForceCreateNewProjectileObject, bool bDisablePlayerCoverStartAdjustment, s32 TargetEntity, bool bDoDeadCheck, bool bFreezeProjectileWaitingOnCollision, bool bSetIgnoreCollisionEnitity, bool bIgnoreCollisionResetNoBB = false)
{
	const Vector3 vStartTemp = scrVecStartCoors;
	const Vector3 vEndTemp = scrVecEndCoors;

	Displayf("SHOOT_SINGLE_BULLET_BETWEEN_COORDS_IGNORE_ENTITY_NEW - Command Called");
#if __ASSERT
	
	scriptAssertf(!vStartTemp.IsClose(vEndTemp, SMALL_FLOAT), "Start and end coords are the same start : (%.2f,%.2f,%.2f), end : (%.2f,%.2f,%.2f)", scrVecStartCoors.x, scrVecStartCoors.y, scrVecStartCoors.z, scrVecEndCoors.x, scrVecEndCoors.y, scrVecEndCoors.z);
#endif // __ASSERT

	if(SCRIPT_VERIFY(DamageCaused >= 0, "SHOOT_SINGLE_BULLET_BETWEEN_COORDS_IGNORE_ENTITY_NEW - damage must have a positive value"))
	{
		CPed* pPed = NULL;

		if(PedIndex != NULL_IN_SCRIPTING_LANGUAGE)
		{
			unsigned assertFlags = CTheScripts::GUID_ASSERT_FLAGS_INCLUDE_CLONES;
			if(!bDoDeadCheck)
			{
				assertFlags = CTheScripts::GUID_ASSERT_FLAGS_INCLUDE_CLONES_NO_DEAD_CHECK;
			}

			pPed = CTheScripts::GetEntityToModifyFromGUID<CPed>(PedIndex, assertFlags);
		}

		CWeapon weapon(WeaponType, CWeapon::INFINITE_AMMO, NULL, true);

		Matrix34 weaponMatrix = weapon.BuildViewMatrix(vStartTemp, vEndTemp - vStartTemp);

		CEntity* pEntity = pPed;
		if(pPed && pPed->GetIsInVehicle() && weapon.GetWeaponInfo()->GetIsVehicleWeapon())
		{
			pEntity = pPed->GetMyVehicle();
		}

		CWeapon::sFireParams params(pEntity, weaponMatrix, &vStartTemp, &vEndTemp);
		params.iFireFlags = bSetPerfectAccuracy ? CWeapon::FF_SetPerfectAccuracy : 0;
		if (bCreateTraceVfx)
		{
			params.iFireFlags.SetFlag( CWeapon::FF_ForceBulletTrace );
		}
		else
		{
			params.iFireFlags.SetFlag( CWeapon::FF_ForceNoBulletTrace );
		}
		params.fApplyDamage = (float)DamageCaused;
		
		params.bCommandFireSingleBullet = true;
		params.fakeStickyBombSequenceId = AllocateVehicleFakeSequence();

		params.fInitialVelocity = InitialVelocity;
		params.bAllowRumble = bAllowRumble;
		params.bCreateNewProjectileObject = bForceCreateNewProjectileObject;	// Ensures we don't use the firing ped's projectile ordnance if one is equipped
		params.bDisablePlayerCoverStartAdjustment = bDisablePlayerCoverStartAdjustment;
		params.bProjectileCreatedByScriptWithNoOwner = !pEntity;
		params.bFreezeProjectileWaitingOnCollision = bFreezeProjectileWaitingOnCollision;

		if(IgnoreEntity != NULL_IN_SCRIPTING_LANGUAGE)
		{
			CEntity *pIgnoreEntity = CTheScripts::GetEntityToModifyFromGUID<CEntity>(IgnoreEntity, CTheScripts::GUID_ASSERT_FLAGS_INCLUDE_CLONES);
			params.pIgnoreDamageEntity = pIgnoreEntity;
			if (bSetIgnoreCollisionEnitity || bIgnoreCollisionResetNoBB)
			{
				params.pIgnoreCollisionEntity = pIgnoreEntity;
				params.bIgnoreCollisionResetNoBB = bIgnoreCollisionResetNoBB;
			}
		}

		if(TargetEntity != NULL_IN_SCRIPTING_LANGUAGE)
		{
			CEntity *pTargetEntity = CTheScripts::GetEntityToModifyFromGUID<CEntity>(TargetEntity, CTheScripts::GUID_ASSERT_FLAGS_INCLUDE_CLONES);
			params.pTargetEntity = pTargetEntity;
		}

#if __BANK
		Displayf("SHOOT_SINGLE_BULLET_BETWEEN_COORDS_IGNORE_ENTITY_NEW - Weapon Fired Between (%.2f,%.2f,%.2f) and (%.2f,%.2f,%.2f); damage - %i; weaponType - %i; firing entity - %s (%p), targetEntity - %s (%p), ignoreEntity - %s (%p), initialVelocity - %.2f, bSetPerfectAccuracy - %s, bCreateTraceVfx - %s, bAllowRumble - %s, bForceCreateNewProjectileObject - %s, bDisablePlayerCoverStartAdjustment - %s, bDoDeadCheck - %s, bFreezeProjectileWaitingOnCollision - %s, bSetIgnoreCollisionEnitity - %s",
			scrVecStartCoors.x, scrVecStartCoors.y, scrVecStartCoors.z, scrVecEndCoors.x, scrVecEndCoors.y, scrVecEndCoors.z,
			DamageCaused, WeaponType,
			pEntity && pEntity->GetIsDynamic() ? AILogging::GetDynamicEntityNameSafe(static_cast<const CDynamicEntity*>(pEntity)) : (pEntity ? pEntity->GetModelName() : "null"), pEntity,
			params.pTargetEntity && params.pTargetEntity->GetIsDynamic() ? AILogging::GetDynamicEntityNameSafe(static_cast<const CDynamicEntity*>(params.pTargetEntity.Get())) : (params.pTargetEntity ? params.pTargetEntity->GetModelName() : "null"), params.pTargetEntity.Get(),
			params.pIgnoreDamageEntity && params.pIgnoreDamageEntity->GetIsDynamic() ? AILogging::GetDynamicEntityNameSafe(static_cast<const CDynamicEntity*>(params.pIgnoreDamageEntity.Get())) : (params.pIgnoreDamageEntity ? params.pIgnoreDamageEntity->GetModelName() : "null"), params.pIgnoreDamageEntity.Get(),
			InitialVelocity, AILogging::GetBooleanAsString(bSetPerfectAccuracy), AILogging::GetBooleanAsString(bCreateTraceVfx), AILogging::GetBooleanAsString(bAllowRumble), AILogging::GetBooleanAsString(bForceCreateNewProjectileObject),
			AILogging::GetBooleanAsString(bDisablePlayerCoverStartAdjustment), AILogging::GetBooleanAsString(bDoDeadCheck), AILogging::GetBooleanAsString(bFreezeProjectileWaitingOnCollision), AILogging::GetBooleanAsString(bSetIgnoreCollisionEnitity));
#endif

		weapon.Fire(params);
	}
}

void CommandFireSingleBulletIgnoreEntity(const scrVector & scrVecStartCoors, const scrVector & scrVecEndCoors, int DamageCaused, bool bSetPerfectAccuracy, s32 WeaponType, s32 PedIndex, bool bCreateTraceVfx, bool bAllowRumble, float InitialVelocity, int IgnoreEntity, s32 TargetEntity)
{
	CommandFireSingleBulletIgnoreEntityNew(scrVecStartCoors, scrVecEndCoors, DamageCaused, bSetPerfectAccuracy, WeaponType, PedIndex, bCreateTraceVfx, bAllowRumble, InitialVelocity, IgnoreEntity, false, false, TargetEntity, true, false, false);
}

void CommandFireSingleBullet(const scrVector & scrVecStartCoors, const scrVector & scrVecEndCoors, int DamageCaused, bool bSetPerfectAccuracy, s32 WeaponType, s32 PedIndex, bool bCreateTraceVfx, bool bAllowRumble, float InitialVelocity)
{
	CommandFireSingleBulletIgnoreEntity(scrVecStartCoors, scrVecEndCoors, DamageCaused, bSetPerfectAccuracy, WeaponType, PedIndex, bCreateTraceVfx, bAllowRumble, InitialVelocity, 0, 0);
}

void CommandGetModelDimensions(int VehicleModelHashKey, Vector3& returnMin, Vector3& returnMax)
{
	CBaseModelInfo* pModelInfo = CModelInfo::GetBaseModelInfoFromHashKey((u32) VehicleModelHashKey, NULL);

	if(SCRIPT_VERIFY(pModelInfo, "GET_MODEL_DIMENSIONS - model doesn't exist"))
	{
		returnMin = pModelInfo->GetBoundingBoxMin();
		returnMax = pModelInfo->GetBoundingBoxMax();

		// GTAV - B*1755458 - The zentorno is deleted at the start of the mission because
		// it is too wide.
		// this is because the bounds for the doors have a rotation and stick out further than they should
		// it should really be fixed when the asset is created but that could break other things
		// this hack will just fix the bug and won't break anything else.
		if( pModelInfo->GetModelNameHash() == MI_CAR_ZENTORNO.GetName().GetHash() )
		{
			returnMin.x += 0.2f;
			returnMax.x -= 0.2f;
		}
#if RSG_GEN9
		if (pModelInfo->GetModelNameHash() == MI_CAR_CYCLONE2.GetName().GetHash())
		{
			static float shrinkX = 0.3f;
			returnMin.x += shrinkX;
			returnMax.x -= shrinkX;
		}
#endif // RSG_GEN9
	}
}

bool CommandIsBitSet(int Variable, int BitIndex)
{
	if(SCRIPT_VERIFY( ((BitIndex >=0) && (BitIndex <=31)), "IS_BIT_SET - bit must be between 0 to 31"))
	{
		return (Variable & (1 << BitIndex)) != 0;
	}
	return false;
}

void CommandSetBit(int &Variable, int BitIndex)
{
	if(SCRIPT_VERIFY( ((BitIndex >=0) && (BitIndex <=31)), "SET_BIT - bit must be between 0 to 31"))
	{
		Variable |= (1 << BitIndex);
	}
}


void CommandClearBit(int &Variable, int BitIndex)
{
	if(SCRIPT_VERIFY( ((BitIndex >=0) && (BitIndex <=31)), "CLEAR_BIT - bit must be between 0 to 31"))
	{
		Variable &= ~(1 << BitIndex);
	}
}


int CommandGetHashKey(const char *pString)
{
	u32 HashKey = 0;
	HashKey = atStringHash(pString);
	return ( *(reinterpret_cast<s32*>(&HashKey)) );
}

void CommandSlerpNearQuaternion(float Phase, float StartX, float StartY, float StartZ, float StartW, float TargetX, float TargetY, float TargetZ, float TargetW, float& ResultX, float& ResultY, float& ResultZ, float& ResultW )
{
	Quaternion Start(StartX,StartY, StartZ, StartW); 
	Quaternion Target(TargetX,TargetY, TargetZ, TargetW); 
	Quaternion Current; 

	Start.Normalize(); 
	Target.Normalize(); 

	Current.SlerpNear(Phase, Start, Target);

	ResultX = Current.x;
	ResultY = Current.y;
	ResultZ = Current.z;
	ResultW = Current.w;
}

void CommandUsingMissionCreator(bool bNewState)
{
	if(bNewState != CScriptHud::bUsingMissionCreator)
	{
#if GTA_REPLAY
		if(bNewState)
			CReplayMgr::OnWorldNotRecordable();
		else
			CReplayMgr::OnWorldBecomesRecordable();
#endif // GTA_REPLAY
		
		scriptDebugf1("CommandUsingMissionCreator :: %s -> %s", CScriptHud::bUsingMissionCreator ? "True" : "False", bNewState ? "True" : "False");
		CScriptHud::bUsingMissionCreator = bNewState;
	}
}

void CommandAllowMissionCreatorWarp(bool bAllow)
{
	if (CScriptHud::bAllowMissionCreatorWarp != bAllow)
	{
		CScriptHud::bAllowMissionCreatorWarp = bAllow;

		if (CPauseMenu::IsActive() && CPauseMenu::IsInMapScreen() && CPauseMenu::IsNavigatingContent())
		{
			CPauseMenu::RedrawInstructionalButtons(MENU_UNIQUE_ID_MAP);
		}
	}
}

void CommandSetMinigameInProgress(bool bNewState)
{
	if (bNewState)
	{
#if __DEV
		Displayf("SET_MINIGAME_IN_PROGRESS(TRUE) called by %s\n", CTheScripts::GetCurrentScriptNameAndProgramCounter());
#endif

		// Make sure to clear any old input data history.
		CControlMgr::GetMainPlayerControl().InitEmptyControls();

		if (CTheScripts::GetCurrentGtaScriptThread()->bIsThisAMiniGameScript == false)
		{
			CTheScripts::GetCurrentGtaScriptThread()->bIsThisAMiniGameScript = true;
			CTheScripts::GetCurrentGtaScriptThread()->bThisScriptAllowsNonMiniGameHelpMessages = false;

			CTheScripts::SetNumberOfMiniGamesInProgress(CTheScripts::GetNumberOfMiniGamesInProgress() + 1);
			scriptAssertf(CTheScripts::GetNumberOfMiniGamesInProgress() < 3, "%s:SET_MINIGAME_IN_PROGRESS - didn't expect to have more than 2 minigames running at the same time", CTheScripts::GetCurrentScriptNameAndProgramCounter());
		}
		else
		{
			scriptAssertf(0, "%s:SET_MINIGAME_IN_PROGRESS(TRUE) - this command is being called more than once for the same script", CTheScripts::GetCurrentScriptNameAndProgramCounter());
		}
	}
	else
	{
#if __DEV
		Displayf("SET_MINIGAME_IN_PROGRESS(FALSE) called by %s\n", CTheScripts::GetCurrentScriptNameAndProgramCounter());
#endif

		CTheScripts::GetCurrentGtaScriptThread()->TidyUpMiniGameFlag();

		// Make sure to clear any old input data history.
		CControlMgr::GetMainPlayerControl().InitEmptyControls();
	}
}

bool CommandIsMinigameInProgress()
{
	return (CTheScripts::GetNumberOfMiniGamesInProgress() > 0);
}

bool CommandIsThisAMinigameScript()
{
	if (CTheScripts::GetCurrentGtaScriptThread() && CTheScripts::GetCurrentGtaScriptThread()->bIsThisAMiniGameScript)
	{
		return true;
	}
	else
	{
		return false;
	}
}

bool CommandIsSniperInverted()
{
	//NOTE: This command is deprecated.
	return false;
}

bool CommandShouldUseMetricMeasurements()
{
	return CFrontendStatsMgr::ShouldUseMetric();
}

int CommandGetProfileSetting(s32 settingId)
{
	return CProfileSettings::GetInstance().GetInt( (CProfileSettings::ProfileSettingId) settingId);
}

float CommandGetCityDensity(void)
{
#if RSG_PC
	return CSettingsManager::GetInstance().GetSettings().m_graphics.m_CityDensity;
#else
	return 1.0f;
#endif 
}


bool CommandAreStringsEqual(const char *pStr1, const char *pStr2)
{
	if (!pStr1)
	{
		scriptAssertf(0, "%s:ARE_STRINGS_EQUAL - first string is NULL", CTheScripts::GetCurrentScriptNameAndProgramCounter());
		return false;
	}

	if (!pStr2)
	{
		scriptAssertf(0, "%s:ARE_STRINGS_EQUAL - second string is NULL", CTheScripts::GetCurrentScriptNameAndProgramCounter());
		return false;
	}

	if( !stricmp( pStr1, pStr2 ) )
	{
		return true;
	}
	return false;
}


int CommandCompareStrings(const char *pStr1, const char *pStr2, bool bCaseSensitive, int numberOfCharactersToCompare)
{
	if (numberOfCharactersToCompare <= 0)
	{
		if (bCaseSensitive)
		{
			return strcmp(pStr1, pStr2);
		}
	}
	else
	{
		if (bCaseSensitive)
		{
			return strncmp(pStr1, pStr2, numberOfCharactersToCompare);
		}
		else
		{
			return strnicmp(pStr1, pStr2, numberOfCharactersToCompare);
		}
	}

	return stricmp(pStr1, pStr2);
}


int AbsInt( int n )
{
	if( n < 0 ) { n = -n; }
	return n;
}

float AbsFloat( float fn )
{
	return rage::Abs( fn );
}

bool CommandIsSniperBulletInArea( const scrVector & scrVecMinCoors, const scrVector & scrVecMaxCoors )
{
	Vector3 VecPosMin = Vector3 (scrVecMinCoors);
	Vector3 VecPosMax = Vector3 (scrVecMaxCoors);

	RefactorValuesForAreaCheck (VecPosMin, VecPosMax);

	bool LatestCmpFlagResult = FALSE;

	if (CBulletManager::ComputeIsBulletInBox(VecPosMin, VecPosMax))
	{
		LatestCmpFlagResult = TRUE;
	}

	return LatestCmpFlagResult;
}

bool CommandIsProjectileInArea( const scrVector & scrVecMinCoors, const scrVector & scrVecMaxCoors, bool bIsPlayer )
{
	Vector3 VecPosMin = Vector3 (scrVecMinCoors);
	Vector3 VecPosMax = Vector3 (scrVecMaxCoors);

	RefactorValuesForAreaCheck (VecPosMin, VecPosMax);

	CPed* pPlayer = NULL;
	if (bIsPlayer)
	{
		pPlayer = CGameWorld::FindLocalPlayer();
		if(!SCRIPT_VERIFY(pPlayer, "IS_PROJECTILE_IN_AREA - Can't Find Player Ped"))
			return false;

		if(!SCRIPT_VERIFY(pPlayer->GetPlayerInfo(), "IS_PROJECTILE_IN_AREA - Can't Get Player Info"))
			return false;
	}

	bool LatestCmpFlagResult = FALSE;

	if (CProjectileManager::GetIsAnyProjectileInBounds(spdAABB(RCC_VEC3V(VecPosMin), RCC_VEC3V(VecPosMax)), 0, pPlayer))
	{
		LatestCmpFlagResult = TRUE;
	}

	return LatestCmpFlagResult;
}

bool CommandGetCoordsOfProjectileTypeInArea( const scrVector & scrVecMinCoors, const scrVector & scrVecMaxCoors, int WeaponType, Vector3 & returnPosition, bool bIsPlayer )
{
	Vector3 VecPosMin = Vector3 (scrVecMinCoors);
	Vector3 VecPosMax = Vector3 (scrVecMaxCoors);

	RefactorValuesForAreaCheck (VecPosMin, VecPosMax);

	bool LatestCmpFlagResult = FALSE;

	// Get the projectile type from the WeaponType
	const CWeaponInfo* pWeaponInfo = CWeaponInfoManager::GetInfo<CWeaponInfo>(WeaponType);
	if(scriptVerifyf(pWeaponInfo, "%s: WeaponType [%d] isn't valid", CTheScripts::GetCurrentScriptNameAndProgramCounter(), WeaponType))
	{
		if(scriptVerifyf(pWeaponInfo->GetFireType() == FIRE_TYPE_PROJECTILE, "%s: WeaponType [%s] isn't a projectile weapon", CTheScripts::GetCurrentScriptNameAndProgramCounter(), pWeaponInfo->GetName()))
		{
			const CAmmoInfo* pAmmoInfo = pWeaponInfo->GetAmmoInfo();
			if(scriptVerifyf(pAmmoInfo, "%s: WeaponType [%s] doesn't have ammo", CTheScripts::GetCurrentScriptNameAndProgramCounter(), pWeaponInfo->GetName()))
			{
				if(scriptVerifyf(pAmmoInfo->GetIsClassId(CAmmoProjectileInfo::GetStaticClassId()), "%s: WeaponType [%s] Ammo [%s] isn't a projectile type", CTheScripts::GetCurrentScriptNameAndProgramCounter(), pWeaponInfo->GetName(), pAmmoInfo->GetName()))
				{
					if(const CEntity * pProjectile = CProjectileManager::GetProjectileInBounds(spdAABB(RCC_VEC3V(VecPosMin), RCC_VEC3V(VecPosMax)), pAmmoInfo->GetHash()))
					{
						//by default, check this guy if we don't care about the owner
						bool bCheckThisProjectile = !bIsPlayer;

						if (bIsPlayer)
						{
							Assert(pProjectile->GetIsTypeObject());
							const CProjectile* pAsProjectile = (static_cast<const CObject*>(pProjectile))->GetAsProjectile();
							if (pAsProjectile && pAsProjectile->GetOwner() && pAsProjectile->GetOwner() == CGameWorld::FindLocalPlayer())
							{
								bCheckThisProjectile = true;
							}
						}

						if (bCheckThisProjectile)
						{
							returnPosition = VEC3V_TO_VECTOR3(pProjectile->GetTransform().GetPosition());
							LatestCmpFlagResult = TRUE;
						}
					}
				}
			}		
		}
	}

	return LatestCmpFlagResult;
}

bool CommandGetCoordsOfProjectileTypeInAngledArea( const scrVector & scrVecAngledAreaPoint1, const scrVector & scrVecAngledAreaPoint2, float DistanceOfOppositeFace, int WeaponType, Vector3 & returnPosition, bool bIsPlayer )
{
	bool LatestCmpFlagResult = FALSE;

	// Get the projectile type from the WeaponType
	const CWeaponInfo* pWeaponInfo = CWeaponInfoManager::GetInfo<CWeaponInfo>(WeaponType);
	if(scriptVerifyf(pWeaponInfo, "%s: WeaponType [%d] isn't valid", CTheScripts::GetCurrentScriptNameAndProgramCounter(), WeaponType))
	{
		if(scriptVerifyf(pWeaponInfo->GetFireType() == FIRE_TYPE_PROJECTILE, "%s: WeaponType [%s] isn't a projectile weapon", CTheScripts::GetCurrentScriptNameAndProgramCounter(), pWeaponInfo->GetName()))
		{
			const CAmmoInfo* pAmmoInfo = pWeaponInfo->GetAmmoInfo();
			if(scriptVerifyf(pAmmoInfo, "%s: WeaponType [%s] doesn't have ammo", CTheScripts::GetCurrentScriptNameAndProgramCounter(), pWeaponInfo->GetName()))
			{
				if(scriptVerifyf(pAmmoInfo->GetIsClassId(CAmmoProjectileInfo::GetStaticClassId()), "%s: WeaponType [%s] Ammo [%s] isn't a projectile type", CTheScripts::GetCurrentScriptNameAndProgramCounter(), pWeaponInfo->GetName(), pAmmoInfo->GetName()))
				{
					if(const CEntity * pProjectile = CProjectileManager::GetProjectileInAngledArea(Vector3(scrVecAngledAreaPoint1), Vector3(scrVecAngledAreaPoint2), DistanceOfOppositeFace, pAmmoInfo->GetHash()))
					{
						//by default, check this guy if we don't care about the owner
						bool bCheckThisProjectile = !bIsPlayer;

						if (bIsPlayer)
						{
							Assert(pProjectile->GetIsTypeObject());
							const CProjectile* pAsProjectile = (static_cast<const CObject*>(pProjectile))->GetAsProjectile();
							if (pAsProjectile && pAsProjectile->GetOwner() && pAsProjectile->GetOwner() == CGameWorld::FindLocalPlayer())
							{
								bCheckThisProjectile = true;
							}
						}

						if (bCheckThisProjectile)
						{
							returnPosition = VEC3V_TO_VECTOR3(pProjectile->GetTransform().GetPosition());
							LatestCmpFlagResult = TRUE;
						}
						
					}
				}
			}		
		}
	}

	return LatestCmpFlagResult;
}

bool CommandIsProjectileTypeInArea( const scrVector & scrVecMinCoors, const scrVector & scrVecMaxCoors, int WeaponType, bool bIsPlayer )
{
	Vector3 positionUnused;
	return CommandGetCoordsOfProjectileTypeInArea(scrVecMinCoors, scrVecMaxCoors, WeaponType, positionUnused, bIsPlayer);
}

bool CommandIsProjectileTypeInAngledArea( const scrVector & scrVecAngledAreaPoint1, const scrVector & scrVecAngledAreaPoint2, float DistanceOfOppositeFace, int WeaponType, bool bIsPlayer )
{
	Vector3 positionUnused;
	return CommandGetCoordsOfProjectileTypeInAngledArea( scrVecAngledAreaPoint1, scrVecAngledAreaPoint2, DistanceOfOppositeFace, WeaponType, positionUnused, bIsPlayer );
}

bool CommandIsProjectileTypeWithinDistance( const scrVector & scrVecCoors, int WeaponType, float distance, bool bIsPlayer)
{
	Vector3 VecPos = Vector3 (scrVecCoors);
	bool LatestCmpFlagResult = false;
	// Get the projectile type from the WeaponType
	const CWeaponInfo* pWeaponInfo = CWeaponInfoManager::GetInfo<CWeaponInfo>(WeaponType);
	if(scriptVerifyf(pWeaponInfo, "%s: WeaponType [%d] isn't valid", CTheScripts::GetCurrentScriptNameAndProgramCounter(), WeaponType))
	{
		if(scriptVerifyf(pWeaponInfo->GetFireType() == FIRE_TYPE_PROJECTILE, "%s: WeaponType [%s] isn't a projectile weapon", CTheScripts::GetCurrentScriptNameAndProgramCounter(), pWeaponInfo->GetName()))
		{
			const CAmmoInfo* pAmmoInfo = pWeaponInfo->GetAmmoInfo();
			if(scriptVerifyf(pAmmoInfo, "%s: WeaponType [%s] doesn't have ammo", CTheScripts::GetCurrentScriptNameAndProgramCounter(), pWeaponInfo->GetName()))
			{
				if(scriptVerifyf(pAmmoInfo->GetIsClassId(CAmmoProjectileInfo::GetStaticClassId()), "%s: WeaponType [%s] Ammo [%s] isn't a projectile type", CTheScripts::GetCurrentScriptNameAndProgramCounter(), pWeaponInfo->GetName(), pAmmoInfo->GetName()))
				{
					if(CEntity * pProjectile = CProjectileManager::GetProjectileWithinDistance( VecPos, pAmmoInfo->GetHash(), distance) )
					{
						//by default, check this guy if we don't care about the owner
						bool bCheckThisProjectile = !bIsPlayer;

						if (bIsPlayer)
						{
							Assert(pProjectile->GetIsTypeObject());
							const CProjectile* pAsProjectile = (static_cast<const CObject*>(pProjectile))->GetAsProjectile();
							if (pAsProjectile && pAsProjectile->GetOwner() && pAsProjectile->GetOwner() == CGameWorld::FindLocalPlayer())
							{
								bCheckThisProjectile = true;
							}
						}

						if (bCheckThisProjectile)
						{
							LatestCmpFlagResult = true;
						}
					}
				}
			}		
		}
	}
	return LatestCmpFlagResult;
}

bool CommandGetProjectileOfProjectileTypeWithinDistance( s32 pedIndex, int WeaponType, float distance, Vector3 & returnPosition, int& iProjectileEntity, bool needsToBeStationary )
{
	bool LatestCmpFlagResult = false;
	CPed* pPed = CTheScripts::GetEntityToModifyFromGUID<CPed>(pedIndex, CTheScripts::GUID_ASSERT_FLAGS_INCLUDE_CLONES);
	if(pPed)
	{
		// Get the projectile type from the WeaponType
		const CWeaponInfo* pWeaponInfo = CWeaponInfoManager::GetInfo<CWeaponInfo>(WeaponType);
		if(scriptVerifyf(pWeaponInfo, "%s: WeaponType [%d] isn't valid", CTheScripts::GetCurrentScriptNameAndProgramCounter(), WeaponType))
		{
			if(scriptVerifyf(pWeaponInfo->GetFireType() == FIRE_TYPE_PROJECTILE, "%s: WeaponType [%s] isn't a projectile weapon", CTheScripts::GetCurrentScriptNameAndProgramCounter(), pWeaponInfo->GetName()))
			{
				const CAmmoInfo* pAmmoInfo = pWeaponInfo->GetAmmoInfo();
				if(scriptVerifyf(pAmmoInfo, "%s: WeaponType [%s] doesn't have ammo", CTheScripts::GetCurrentScriptNameAndProgramCounter(), pWeaponInfo->GetName()))
				{
					if(scriptVerifyf(pAmmoInfo->GetIsClassId(CAmmoProjectileInfo::GetStaticClassId()), "%s: WeaponType [%s] Ammo [%s] isn't a projectile type", CTheScripts::GetCurrentScriptNameAndProgramCounter(), pWeaponInfo->GetName(), pAmmoInfo->GetName()))
					{
						if(CEntity * pProjectile = CProjectileManager::GetNewestProjectileWithinDistance( pPed, pAmmoInfo->GetHash(), distance, needsToBeStationary ))
						{
#if DEBUG_DRAW
							TUNE_GROUP_BOOL(COMMANDS_MISC, bRenderGetProjectileOfProjectileTypeWithinDistance, false);
							if(bRenderGetProjectileOfProjectileTypeWithinDistance)
							{
								grcDebugDraw::Sphere(pProjectile->GetTransform().GetPosition(), 0.25f, Color_blue, true, -1);
							}
#endif
							iProjectileEntity = CTheScripts::GetGUIDFromEntity(*pProjectile);
							returnPosition = VEC3V_TO_VECTOR3(pProjectile->GetTransform().GetPosition());
							LatestCmpFlagResult = true;
							scriptDisplayf("GET_PROJECTILE_OF_PROJECTILE_TYPE_WITHIN_DISTANCE: Found projectile of type %s at location <<%.2f, %.2f, %.2f>> owned by ped %s", pAmmoInfo->GetName(), returnPosition.x, returnPosition.y, returnPosition.z, pPed->GetDebugName());
						}
						else
						{
							scriptDisplayf("GET_PROJECTILE_OF_PROJECTILE_TYPE_WITHIN_DISTANCE: Could not find a projectile of type %s owned by ped %s within the given radius %.2f", pAmmoInfo->GetName(), pPed->GetDebugName(), distance);
						}
					}
				}		
			}
		}
	}
	return LatestCmpFlagResult;
}

bool CommandGetCoordsOfProjectileTypeWithinDistance( s32 pedIndex, int WeaponType, float distance, Vector3 & returnPosition, bool needsToBeStationary )
{
	int iProjectileEntity;
	return CommandGetProjectileOfProjectileTypeWithinDistance(pedIndex, WeaponType, distance, returnPosition, iProjectileEntity, needsToBeStationary);
}

void LimitAngle( float fAngleIn, float &fAngleOut )
{
	fAngleOut = fAngleIn;

	while( fAngleOut < 0.0f )
	{
		fAngleOut += 360.0f;
	}

	while( fAngleOut > 360.0f )
	{
		fAngleOut -= 360.0f;
	}
}


int CommandGetUniqueMapVersion()
{
	return EXTRACONTENT.GetMapChangesCRC();
}

bool CommandIsPCVersion()
{
#if RSG_PC
	return true;
#else
	return false;
#endif
}

bool CommandIsPS3Version()
{
#if RSG_PS3
	return true;
#else
	return false;
#endif
}

bool CommandIsOrbisVersion()
{
#if RSG_ORBIS
	return true;
#elif RSG_PROSPERO && GTA_SCRIPT_LEGACY_PLATFORM_VERSION
	return true;
#else
	return false;
#endif
}

bool CommandIsProsperoVersion()
{
#if RSG_PROSPERO
	return true;
#else
	return false;
#endif
}

bool CommandIsScePlatform()
{
#if RSG_ORBIS
	return true;
#elif RSG_PROSPERO
	return true;
#else
	return false;
#endif
}

bool CommandIsXbox360Version()
{
#if RSG_XENON
	return true;
#else
	return false;
#endif
}

bool CommandIsDurangoVersion()
{
#if RSG_DURANGO
	return true;
#elif RSG_SCARLETT && GTA_SCRIPT_LEGACY_PLATFORM_VERSION
	return true;
#else
	return false;
#endif
}

bool CommandIsScarlettVersion()
{
#if RSG_SCARLETT
	return true;
#else
	return false;
#endif
}

bool CommandIsXboxPlatform()
{
#if RSG_SCARLETT
	return true;
#elif RSG_DURANGO
	return true;
#else
	return false;
#endif
}

bool CommandIsSteamVersion()
{
#if RSG_PC && __STEAM_BUILD
	return true;
#else
	return false;
#endif
}

bool CommandHasStorageDeviceBeenSelected()
{
	if (CSavegameUsers::GetSignedInUser())
	{
		if (CSavegameDevices::IsDeviceValid())
		{
			return true;
		}
	}

	return false;
}

bool CommandIsStringNull(const char *pStringToTest)
{
	if (pStringToTest == NULL)
	{
		return true;
	}

	return false;
}

bool CommandIsStringNullOrEmpty(const char *pStringToTest)
{
	if (pStringToTest == NULL)
	{
		return true;
	}

	if (pStringToTest[0] == 0)
	{
		return true;
	}

	return false;	
}

bool CommandStringToInt(const char *pStringToConvert, int &ReturnInteger)
{
	int Index = 0;
	ReturnInteger = -999;

	if (!pStringToConvert)
	{
		scriptAssertf(0, "%s:STRING_TO_INT - this command is being called with a NULL pointer", CTheScripts::GetCurrentScriptNameAndProgramCounter());
		return false;
	}

	int string_length = istrlen(pStringToConvert);

	if (string_length == 0)
		return false;

	while (pStringToConvert[Index] != 0)
	{
		if ( (pStringToConvert[Index] < '0' || pStringToConvert[Index] > '9') )
		{
			if ( (pStringToConvert[Index] == '-') && (Index == 0) && (string_length > 1) )
			{

			}
			else
			{
				return false;
			}
		}

		Index++;
	}

	ReturnInteger = atoi(pStringToConvert);
	return true;
}


// DP - i may move this once i've re-written the Hud code
void CommandSetPhoneHudItem(int iType, const char *pTextLabel, int iNumber)
{
	CScriptHud::RadarMessage.bActivate = true;  // set item to activate

	CScriptHud::RadarMessage.iType = iType;

	if (iType == 0)
	{
		CScriptHud::RadarMessage.iNumber = 0;
		CScriptHud::RadarMessage.cMessage[0] = '\0';
	}
	else
	{
		CScriptHud::RadarMessage.iNumber = iNumber;
		safecpy(CScriptHud::RadarMessage.cMessage, pTextLabel, TEXT_KEY_SIZE);
	}
}

void CommandSetOverrideNoSprintingOnPhoneInMultiplayer(const bool b)
{
	CTaskMovePlayer::ms_bScriptOverrideNoRunningOnPhone = b;
}

void CommandSetMessagesWaiting(bool bWaiting)
{
	CScriptHud::RadarMessage.bMessagesWaiting = bWaiting;
}

void CommandSetSleepModeActive(bool bActive)
{
	CScriptHud::RadarMessage.bSleepModeActive = bActive;
}


void CommandSetBitsInRange(int &VariableToChange, int StartBit, int EndBit, int NewValue)
{
	if(SCRIPT_VERIFY( NewValue >= 0, "SET_BITS_IN_RANGE - NewValue must be >= 0"))
	{
		if(SCRIPT_VERIFY( (StartBit <= EndBit), "SET_BITS_IN_RANGE - StartBit should be less than or equal to EndBit"))
		{
			if(SCRIPT_VERIFY( (StartBit >=0) && (StartBit <= 31), "SET_BITS_IN_RANGE - Start Bit must be between 0 to 31"))
			{
				if(SCRIPT_VERIFY( (EndBit >=0) && (EndBit <= 31), "SET_BITS_IN_RANGE - End Bit must be between 0 to 31"))
				{
					int BitRange = (EndBit - StartBit) + 1;
					int MaxValueThatCanBeStored = (1 << BitRange);
					MaxValueThatCanBeStored -= 1;

				#if __ASSERT
					char ErrorString[256];

					if (NewValue > MaxValueThatCanBeStored)
					{
						sprintf(ErrorString, "SET_BITS_IN_RANGE - Number is too large to store in this number of bits - Start = %d, End = %d, Value = %d", StartBit, EndBit, NewValue);
						scriptAssertf(0, "%s:%s", CTheScripts::GetCurrentScriptNameAndProgramCounter(), ErrorString);
					}
				#endif

				//	int Mask = 0x0ffffffff;
					int Temp = (MaxValueThatCanBeStored << StartBit);

				//	clear bits between StartBit and EndBit
					VariableToChange &= ~Temp;
				//	Mask &= ~Temp;

				//	set bits 
					Temp = (NewValue << StartBit);
				//	Mask |= (NewValue << StartBit);
					VariableToChange |= Temp;
				}
			}
		}
	}
}

int CommandGetBitsInRange(int VariableToRead, int StartBit, int EndBit)
{
	if(SCRIPT_VERIFY((StartBit <= EndBit), "GET_BITS_IN_RANGE - StartBit should be less than or equal to EndBit"))
	{
		if(SCRIPT_VERIFY((StartBit >=0) && (StartBit <= 31), "GET_BITS_IN_RANGE - Start Bit must be between 0 to 31"))
		{
			if(SCRIPT_VERIFY((EndBit >=0) && (EndBit <= 31), "GET_BITS_IN_RANGE - End Bit must be between 0 to 31"))
			{
				int BitRange = (EndBit - StartBit) + 1;
				int MaxValueThatCanBeStored = (1 << BitRange);
				MaxValueThatCanBeStored -= 1;

				int Temp = (VariableToRead >> StartBit);
				Temp &= MaxValueThatCanBeStored;

				return Temp;
			}
		}
	}
	return 0;
}

int CommandAddStuntJump(const scrVector & startMin, const scrVector & startMax, const scrVector & endMin, const scrVector & endMax, const scrVector & cameraPoint, int reward, int level, bool camOptional)
{
	int retVal = 0;

	if(scriptVerifyf(SStuntJumpManager::IsInstantiated(), "ADD_STUNT_JUMP is called before the stunt jump manager is initialized."))
	{
		Vec3V vStartMin = Vec3V(startMin);
		Vec3V vStartMax = Vec3V(startMax);
		Vec3V vEndMin = Vec3V(endMin);
		Vec3V vEndMax = Vec3V(endMax);
		Vec3V vCameraPoint = Vec3V(cameraPoint);

		retVal = SStuntJumpManager::GetInstance().AddOne( vStartMin, vStartMax, vEndMin, vEndMax, vCameraPoint, reward, level, camOptional);
	}

	return retVal;
}

int CommandAddStuntJumpAngled(const scrVector & startMin, const scrVector & startMax, float startWidth, const scrVector & endMin, const scrVector & endMax, float endWidth, const scrVector & cameraPoint, int reward, int level, bool camOptional)
{
	int retVal = 0;

	if(scriptVerifyf(SStuntJumpManager::IsInstantiated(), "ADD_STUNT_JUMP_ANGLED is called before the stunt jump manager is initialized."))
	{
		Vec3V vStartMin = Vec3V(startMin);
		Vec3V vStartMax = Vec3V(startMax);
		Vec3V vEndMin = Vec3V(endMin);
		Vec3V vEndMax = Vec3V(endMax);
		Vec3V vCameraPoint = Vec3V(cameraPoint);

		retVal = SStuntJumpManager::GetInstance().AddOneAngled( vStartMin, vStartMax, startWidth, vEndMin, vEndMax, endWidth, vCameraPoint, reward, level, camOptional);
	}

	return retVal;
}

void CommandToggleShowOptionalStuntJumpCamera(bool bShow)
{
	SStuntJumpManager::GetInstance().ToggleShowOptionalStuntCameras(bShow);
}


void CommandDeleteStuntJump(int id)
{
	if(scriptVerifyf(SStuntJumpManager::IsInstantiated(), "DELETE_STUNT_JUMP is called before the stunt jump manager is initialized."))
	{
		SStuntJumpManager::GetInstance().DeleteOne(id);
	}
}

void CommandEnableStuntJumpSet(int id)
{
	if(scriptVerifyf(SStuntJumpManager::IsInstantiated(), "ENABLE_STUNT_JUMP_SET is called before the stunt jump manager is initialized."))
	{
		SStuntJumpManager::GetInstance().EnableSet(id);
	}
}

void CommandDisableStuntJumpSet(int id)
{
	if(scriptVerifyf(SStuntJumpManager::IsInstantiated(), "DISABLE_STUNT_JUMP_SET is called before the stunt jump manager is initialized."))
	{
		SStuntJumpManager::GetInstance().DisableSet(id);
	}
}

void CommandAllowStuntJumpsToTrigger(bool bAllow)
{
	if(scriptVerifyf(SStuntJumpManager::IsInstantiated(), "SET_STUNT_JUMPS_CAN_TRIGGER is called before the stunt jump manager is initialized."))
	{
		SStuntJumpManager::GetInstance().SetActive(bAllow);
	}
}

bool CommandIsStuntJumpInProgress()
{
	bool retVal = false;
	if(scriptVerifyf(SStuntJumpManager::IsInstantiated(), "IS_STUNT_JUMP_IN_PROGRESS is called before the stunt jump manager is initialized."))
	{
		retVal = SStuntJumpManager::GetInstance().IsAStuntjumpInProgress();
	}

	return retVal;
}


bool CommandIsStuntJumpMessageShowing()
{
	bool retVal = false;
	if(scriptVerifyf(SStuntJumpManager::IsInstantiated(), "IS_STUNT_JUMP_MESSAGE_SHOWING is called before the stunt jump manager is initialized."))
	{
		retVal = SStuntJumpManager::GetInstance().IsStuntjumpMessageShowing();
	}

	return retVal;
}


int CommandGetNumSuccessfulStuntJumps()
{
	int retVal = 0;
	if(scriptVerifyf(SStuntJumpManager::IsInstantiated(), "GET_NUM_SUCCESSFUL_STUNT_JUMPS is called before the stunt jump manager is initialized."))
	{
		retVal = SStuntJumpManager::GetInstance().GetStuntJumpCompletedStat();
	}

	return retVal;
}

int CommandGetTotalSuccessfulStuntJumps()
{
	int retVal = 0;
	if(scriptVerifyf(SStuntJumpManager::IsInstantiated(), "GET_TOTAL_SUCCESSFUL_STUNT_JUMPS is called before the stunt jump manager is initialized."))
	{
		retVal = SStuntJumpManager::GetInstance().GetTotalStuntJumpCompletedStat();
	}

	return retVal;
}

void CommandCancelStuntJump()
{
	if(scriptVerifyf(SStuntJumpManager::IsInstantiated(), "CANCLE_STUNT_JUMP is called before the stunt jump manager is initialized."))
	{
		SStuntJumpManager::GetInstance().AbortStuntJumpInProgress();
	}
}

void CommandSetGamePaused (bool bActive)
{
	if (bActive)
	{
		fwTimer::StartScriptPause();
		GtaThread::PauseAllThreadsBarThisOne(CTheScripts::GetCurrentGtaScriptThread());
	}
	else
	{
		fwTimer::EndScriptPause();
		GtaThread::UnpauseAllThreads();
	}

}


void CommandAllowThisScriptToBePaused(bool bScriptCanBePaused)
{
	CTheScripts::GetCurrentGtaScriptThread()->bThisScriptCanBePaused = bScriptCanBePaused;
}

void CommandSetThisScriptCanRemoveBlipsCreatedByAnyScript(bool bCanRemoveBlipsCreatedByOtherScripts)
{
	scriptDisplayf("%s:SET_THIS_SCRIPT_CAN_REMOVE_BLIPS_CREATED_BY_ANY_SCRIPT %s called", CTheScripts::GetCurrentScriptNameAndProgramCounter(), bCanRemoveBlipsCreatedByOtherScripts?"TRUE":"FALSE");
	CTheScripts::GetCurrentGtaScriptThread()->bThisScriptCanRemoveBlipsCreatedByAnyScript = bCanRemoveBlipsCreatedByOtherScripts;
}

void CommandClearNewsScrollbar()
{
	g_scrollbars.ClearNews();
}

void CommandAddStringToNewsScrollbar(const char *pName)
{
	g_scrollbars.AddNews(pName);
}

void CommandActivateCheat(int cheat)
{
	CCheat::ScriptActivatedCheat(cheat);
}

bool CommandHasCheatBeenActivated(const char* cheatCode)
{
	return CCheat::HasCheatActivated(cheatCode);
}

bool CommandHasCheatWithHashBeenActivated(s32 hashOfCheatString, s32 lengthOfCheatString)
{
	return CCheat::HasCheatActivated( (u32) hashOfCheatString, (u32) lengthOfCheatString);
}

bool CommandHasPcCheatWithHashBeeonActivated(s32 WIN32PC_ONLY(hashOfCheatString))
{
#if RSG_PC
	return CCheat::HasPcCheatActivated( (u32) hashOfCheatString );
#else
	return false;
#endif // RSG_PC
}

// Force freezing of all exterior physics
void CommandOverrideFreezeFlags(bool bOverride)
{
	CGameWorld::OverrideFreezeFlags(bOverride);
}

void CommandSetGlobalInstancePriority(int )
{
	//DEPRECATED
}

void CommandSetDefaultGlobalInstancePriority()
{
	//DEPRECATED
}

void CommandEnableXboxScreenSaver(bool XENON_ONLY(bEnable))
{
#if __XENON
	XEnableScreenSaver(bEnable);
#endif
}

bool CommandIsFrontendFading()
{
	return false;
}

void CommandPopulateNow()
{
 	CVehiclePopulation::ForcePopulationInit();
 	CPortalTracker::TriggerForceAllActiveInteriorCapture();
}

int CommandGetIndexOfCurrentLevel()
{
	if (CTheScripts::GetProcessingTheScriptsDuringGameInit())
	{
		return CGameLogic::GetRequestedLevelIndex();
	}
	else
	{
		return CGameLogic::GetCurrentLevelIndex();
	}
}

void CommandSwitchToLevel(int level)
{
	if (SCRIPT_VERIFY(level >= CGameLogic::DEFAULT_LEVEL_INDEX && level <= CGameLogic::MAX_LEVEL_INDEX, "SWITCH_TO_LEVEL - Level Index should be between 1 and 5 inclusive"))
	{
        CGame::ChangeLevel(level);
	}
}

//	REGISTER_PERSISTENT_GLOBAL_VARIABLES(Ss, SIZE_OF(Ss))
/*
void CommandRegisterPersistentGlobalVariables(int &AddressTemp, int Size)
{
	int *Address = &AddressTemp;

	if (SCRIPT_VERIFY(Size > 0, "REGISTER_PERSISTENT_GLOBAL_VARIABLES - Size of structure should be greater than 0"))
	{
		Size *= sizeof(scrValue);			// Script returns size in script words (4 bytes)
		CTheScripts::PersistentScriptGlobals.RegisterPersistentGlobalVariables(Address, Size);
	}
}
*/

void CommandSetGravityLevel(int iGravityLevel)
{
	if(SCRIPT_VERIFY(iGravityLevel >= 0 && iGravityLevel < CPhysics::NUM_GRAVITY_LEVELS, "Invalid gravity level"))
	{
		CPhysics::SetGravityLevel((CPhysics::eGravityLevel)iGravityLevel);
	}
}

int CommandGetCurrentStackSize()
{
	if (CTheScripts::GetCurrentGtaScriptThread())
	{
		return CTheScripts::GetCurrentGtaScriptThread()->GetThreadSP();
	}
	else
	{
		Assertf(0, "GET_CURRENT_STACK_SIZE - Failed to get a pointer to the current script thread");
		return 0;
	}
}

int GetAllocatedStackSize()
{
	if (CTheScripts::GetCurrentGtaScriptThread())
	{
		return CTheScripts::GetCurrentGtaScriptThread()->GetAllocatedStackSize();
	}
	else
	{
		Assertf(0, "GET_ALLOCATED_STACK_SIZE - Failed to get a pointer to the current script thread");
		return 0;
	}
}

int CommandGetNumberOfFreeStacksOfThisSize(int stackSize)
{
	return scrThread::CheckStackAvailability(stackSize);
}

// Script returns size in script words (4 bytes)
void CommandStartSaveData(s32 &StartOfStruct, s32 NumberOfScrValuesInStruct, bool bSinglePlayer)
{
	eTypeOfSavegame typeOfSavegame = SAVEGAME_MULTIPLAYER_SLOT_CONTAINING_MP_SCRIPT_DATA;
	if (bSinglePlayer)
	{
		typeOfSavegame = SAVEGAME_SINGLE_PLAYER;
	}

	CScriptSaveData::OpenScriptSaveData(typeOfSavegame, &StartOfStruct, NumberOfScrValuesInStruct, CTheScripts::GetCurrentGtaScriptThread());
}

void CommandStopSaveData()
{
//	search the array of parTrees for the name of this rtstruct and if the tree exists, load the data from it
	CScriptSaveData::CloseScriptStruct(CTheScripts::GetCurrentGtaScriptThread());
}

s32 CommandGetSizeOfSaveData(bool bSinglePlayer)
{
	eTypeOfSavegame typeOfSavegame = SAVEGAME_MULTIPLAYER_SLOT_CONTAINING_MP_SCRIPT_DATA;
	if (bSinglePlayer)
	{
		typeOfSavegame = SAVEGAME_SINGLE_PLAYER;
	}

	return CScriptSaveData::GetSizeOfSavedScriptData(typeOfSavegame, CTheScripts::GetCurrentGtaScriptThread());
}

void CommandRegisterIntToSave(int &IntToSave, const char *pLabel)
{
	CScriptSaveData::AddMemberToCurrentStruct(pLabel, Script_Save_Data_Type_Int, &IntToSave, CTheScripts::GetCurrentGtaScriptThread());
}

void CommandRegisterInt64ToSave(int &IntToSave, const char *pLabel)
{
	CScriptSaveData::AddMemberToCurrentStruct(pLabel, Script_Save_Data_Type_Int64, &IntToSave, CTheScripts::GetCurrentGtaScriptThread());
}

void CommandRegisterEnumToSave(int &EnumToSave, const char *pLabel)
{
	CScriptSaveData::AddMemberToCurrentStruct(pLabel, Script_Save_Data_Type_Int, &EnumToSave, CTheScripts::GetCurrentGtaScriptThread());
}


void CommandRegisterFloatToSave(float &FloatToSave, const char *pLabel)
{
	CScriptSaveData::AddMemberToCurrentStruct(pLabel, Script_Save_Data_Type_Float, &FloatToSave, CTheScripts::GetCurrentGtaScriptThread());
}

//	David Etherton in Rage Changelist 230215, wrote - 
//	"If you have a native function that accepts bool&, just change the C++ side to be int& and all will be well."
void CommandRegisterBoolToSave(int &BoolToSave, const char *pLabel)
{
	CScriptSaveData::AddMemberToCurrentStruct(pLabel, Script_Save_Data_Type_Int, &BoolToSave, CTheScripts::GetCurrentGtaScriptThread());
}

void CommandRegisterTextLabelToSave(const char *pTextLabelToSave, const char *pLabel)
{
	CScriptSaveData::AddMemberToCurrentStruct(pLabel, Script_Save_Data_Type_TextLabel15, pTextLabelToSave, CTheScripts::GetCurrentGtaScriptThread());
}

void CommandRegisterTextLabel3ToSave(const char *pTextLabelToSave, const char *pLabel)
{
	CScriptSaveData::AddMemberToCurrentStruct(pLabel, Script_Save_Data_Type_TextLabel3, pTextLabelToSave, CTheScripts::GetCurrentGtaScriptThread());
}

void CommandRegisterTextLabel7ToSave(const char *pTextLabelToSave, const char *pLabel)
{
	CScriptSaveData::AddMemberToCurrentStruct(pLabel, Script_Save_Data_Type_TextLabel7, pTextLabelToSave, CTheScripts::GetCurrentGtaScriptThread());
}

void CommandRegisterTextLabel15ToSave(const char *pTextLabelToSave, const char *pLabel)
{
	CScriptSaveData::AddMemberToCurrentStruct(pLabel, Script_Save_Data_Type_TextLabel15, pTextLabelToSave, CTheScripts::GetCurrentGtaScriptThread());
}

void CommandRegisterTextLabel23ToSave(const char *pTextLabelToSave, const char *pLabel)
{
	CScriptSaveData::AddMemberToCurrentStruct(pLabel, Script_Save_Data_Type_TextLabel23, pTextLabelToSave, CTheScripts::GetCurrentGtaScriptThread());
}

void CommandRegisterTextLabel31ToSave(const char *pTextLabelToSave, const char *pLabel)
{
	CScriptSaveData::AddMemberToCurrentStruct(pLabel, Script_Save_Data_Type_TextLabel31, pTextLabelToSave, CTheScripts::GetCurrentGtaScriptThread());
}

void CommandRegisterTextLabel63ToSave(const char *pTextLabelToSave, const char *pLabel)
{
	CScriptSaveData::AddMemberToCurrentStruct(pLabel, Script_Save_Data_Type_TextLabel63, pTextLabelToSave, CTheScripts::GetCurrentGtaScriptThread());
}


void CommandStartSaveStructWithSize(int &StartOfStruct, s32 NumberOfScrValuesInStruct, const char *pNameOfStructInstance)
{
	CScriptSaveData::OpenScriptStruct(pNameOfStructInstance, &StartOfStruct, NumberOfScrValuesInStruct, false, CTheScripts::GetCurrentGtaScriptThread());
}

void CommandStopSaveStruct()
{
	CScriptSaveData::CloseScriptStruct(CTheScripts::GetCurrentGtaScriptThread());
}

void CommandStartSaveArrayWithSize(int &StartOfArray, s32 NumberOfScrValuesInStruct, const char *pNameOfArrayInstance)
{
	CScriptSaveData::OpenScriptStruct(pNameOfArrayInstance, &StartOfArray, NumberOfScrValuesInStruct, true, CTheScripts::GetCurrentGtaScriptThread());
}

void CommandStopSaveArray()
{
	CScriptSaveData::CloseScriptStruct(CTheScripts::GetCurrentGtaScriptThread());
}

// bool CommandGetPedLastWeaponImpactCoord (int PedIndex), const scrVector & &ImpactCoord)
// {
// 	bool bValidImpact = false;
// 
// 
// 
// 	return bValidImpact;
// }


void CommandCopyScriptStruct(int &DestStruct, int &SourceStruct, int Size)
{
	void *scrDestStruct = reinterpret_cast<void *>(&DestStruct);
	const void *scrSourceStruct = reinterpret_cast<const void *>(&SourceStruct);

	// convert to bytes
	Size *= sizeof(scrValue);

	sysMemCpy(scrDestStruct, scrSourceStruct, Size);
}


void CommandEnableDispatchService(const int dispatchEnum, const bool bEnable)
{
	if( aiVerifyf(dispatchEnum >= 0 && dispatchEnum < DT_Max, "ENABLE_DISPATCH_SERVICE: dispatch enum out of range!") )
	{
		CDispatchManager::GetInstance().EnableDispatch(static_cast<DispatchType>(dispatchEnum), bEnable);
	}
}

void CommandBlockDispatchServiceResourceCreation(const int dispatchEnum, const bool bBlock)
{
	if( aiVerifyf(dispatchEnum >= 0 && dispatchEnum < DT_Max, "BLOCK_DISPATCH_SERVICE_RESOURCE_CREATION: dispatch enum out of range!") )
	{
		CDispatchManager::GetInstance().BlockDispatchResourceCreation(static_cast<DispatchType>(dispatchEnum), bBlock);
	}
}

int CommandGetNumberResourcesAllocatedToWantedLevel(const int dispatchEnum)
{
	if( aiVerifyf(dispatchEnum >= 0 && dispatchEnum < DT_Max, "GET_NUMBER_RESOURCES_ALLOCATED_TO_WANTED_LEVEL: dispatch enum out of range!") )
	{
		CPed* pPed = CGameWorld::FindLocalPlayer();
		if( pPed && pPed->GetPlayerWanted() )
		{
			CIncident* pWantedIncident = pPed->GetPlayerWanted()->m_wantedLevelIncident;
			if( pWantedIncident )
			{
				return pWantedIncident->GetAssignedResources(dispatchEnum);
			}
		}
	}
	return 0;
}

bool AddScriptIncident(CScriptIncident& incident, int& incidentIndex)
{
	int incidentSlot = -1;
	if (CIncidentManager::GetInstance().AddIncident(incident, true, &incidentSlot))
	{
		CIncident* pNewIncident = CIncidentManager::GetInstance().GetIncident(incidentSlot);

		if (aiVerify(pNewIncident))
		{
			incidentIndex = CIncident::GetPool()->GetIndex(pNewIncident);
			return true;
		}
	}

	incidentIndex = NULL_IN_SCRIPTING_LANGUAGE;
	return false;
}

bool CommandCreateIncident(const int dispatchEnum, const scrVector & svLocation, const s32 iNumUnits, float fTime, int& incidentIndex, s32 iOverrideRelGroupHash, const int assassinsLevel)
{
	incidentIndex = NULL_IN_SCRIPTING_LANGUAGE;

	Vector3 vLocation(svLocation);
	bool bAddIncident = true;

	// Don't add incidents if the firetruck or ambulance won't be able to reach it
	if(dispatchEnum == DT_FireDepartment || dispatchEnum == DT_AmbulanceDepartment)
	{
		float fDistanceToOnNode = (CMapAreas::GetAreaIndexFromPosition(vLocation) == 0 ) ? 90.0f : 40.0f;

		// don't add incidents if the firetruck/ambulance won't be able to reach it
		CNodeAddress CurrentNode;
		CurrentNode = ThePaths.FindNodeClosestToCoors(vLocation, fDistanceToOnNode,  CPathFind::IgnoreSwitchedOffNodes);

		if (CurrentNode.IsEmpty())
		{
			bAddIncident = false;
		}
	}

	// Update the spawn timers for fire and ambulance
	if(bAddIncident)
	{
		if(dispatchEnum == DT_FireDepartment)
		{
			CDispatchService* pFireDispatchService = CDispatchManager::GetInstance().GetDispatch(DT_FireDepartment);
			if(pFireDispatchService)
			{
				if(!pFireDispatchService->GetTimerTicking())
				{
					pFireDispatchService->ResetSpawnTimer();
				}
			}
		}

		if(dispatchEnum == DT_AmbulanceDepartment)
		{
			CDispatchService* pAmbulanceDispatchService = CDispatchManager::GetInstance().GetDispatch(DT_AmbulanceDepartment);
			if(pAmbulanceDispatchService)
			{
				if(!pAmbulanceDispatchService->GetTimerTicking())
				{
					pAmbulanceDispatchService->ResetSpawnTimer();
				}
			}
		}
	}
		

	if( bAddIncident && aiVerifyf(iNumUnits > 0, "CREATE_INCIDENT: Must request at least 1 unit.") &&
		aiVerifyf(dispatchEnum >= 0 && dispatchEnum < DT_Max, "CREATE_INCIDENT: dispatch enum out of range!") )
	{
		CScriptIncident scriptIncident(NULL, vLocation, fTime);
		if(dispatchEnum == DT_AmbulanceDepartment || dispatchEnum == DT_FireDepartment)
		{
			scriptIncident.SetUseExistingPedsOnFoot(false);
		}

		scriptIncident.SetOverrideRelationshipGroupHash((u32)iOverrideRelGroupHash);

		if (assassinsLevel != AL_Invalid && scriptVerifyf(assassinsLevel > AL_Invalid && assassinsLevel < AL_Max, "CREATE_INCIDENT: Passed in assassinsLevel (%i) is not supported! Max allowed is %i", assassinsLevel, AL_Max))
		{
			if (scriptVerifyf(dispatchEnum == DT_Assassins,"CREATE_INCIDENT: assassin level can't be used with %i dispatch type (it should only be used with DT_ASSASSINS)",dispatchEnum))
			{
				scriptIncident.SetAssassinDispatchLevel(assassinsLevel);
			}
		}

		scriptIncident.SetRequestedResources(dispatchEnum, iNumUnits);
		return AddScriptIncident(scriptIncident, incidentIndex);

	}
	return false;
}

bool CommandCreateIncidentWithEntity(const int dispatchEnum, int EntityIndex, const s32 iNumUnits, float fTime, int& incidentIndex, s32 iOverrideRelGroupHash, const int assassinsLevel)
{
	incidentIndex = NULL_IN_SCRIPTING_LANGUAGE;

	if( aiVerifyf(iNumUnits > 0, "CREATE_INCIDENT_WITH_ENTITY: Must request at least 1 unit.") &&
		aiVerifyf(dispatchEnum >= 0 && dispatchEnum < DT_Max, "CREATE_INCIDENT_WITH_ENTITY: dispatch enum out of range!") )
	{
		CPhysical *pEntity = CTheScripts::GetEntityToModifyFromGUID<CPhysical>(EntityIndex);

		if(pEntity)
		{
			Vector3 vLocation(VEC3V_TO_VECTOR3(pEntity->GetTransform().GetPosition()));
			CScriptIncident scriptIncident(pEntity, vLocation, fTime);
			if(dispatchEnum == DT_AmbulanceDepartment || dispatchEnum == DT_FireDepartment)
			{
				scriptIncident.SetUseExistingPedsOnFoot(false);
			}

			scriptIncident.SetOverrideRelationshipGroupHash((u32)iOverrideRelGroupHash);

			if (assassinsLevel != AL_Invalid && scriptVerifyf(assassinsLevel > AL_Invalid && assassinsLevel < AL_Max, "CREATE_INCIDENT_WITH_ENTITY: Passed in assassinsLevel (%i) is not supported! Max allowed is %i", assassinsLevel, AL_Max))
			{
				if (scriptVerifyf(dispatchEnum == DT_Assassins,"CREATE_INCIDENT_WITH_ENTITY: assassin level can't be used with %i dispatch type (it should only be used with DT_ASSASSINS)",dispatchEnum))
				{
					scriptIncident.SetAssassinDispatchLevel(assassinsLevel);
				}
			}

			scriptIncident.SetRequestedResources(dispatchEnum, iNumUnits);
			return AddScriptIncident(scriptIncident, incidentIndex);
		}
	}
	return false;
}

void CommandSetIncidentRequestedUnits(int incidentIndex, const int dispatchEnum, const s32 iNumUnits)
{
	CIncident* pIncident = CIncident::GetPool()->GetAt(incidentIndex);
	if( aiVerifyf(pIncident, "SET_INCIDENT_REQUESTED_UNITS: Incident doesn't exist!") && 
		aiVerifyf(pIncident->GetType() == CIncident::IT_Scripted, "Incident of incorrect type!") )
	{
		CScriptIncident* pScriptedIncident = static_cast<CScriptIncident*>(pIncident);
		pScriptedIncident->SetRequestedResources(dispatchEnum, iNumUnits);
	}
}

void CommandSetIdealSpawnDistanceForIncident(int incidentIndex, float distance)
{
	CIncident* pIncident = CIncident::GetPool()->GetAt(incidentIndex);
	if( aiVerifyf(pIncident, "SET_IDEAL_SPAWN_DISTANCE_FOR_INCIDENT: Incident doesn't exist!") && 
		aiVerifyf(pIncident->GetType() == CIncident::IT_Scripted, "Incident of incorrect type!") )
	{
		CScriptIncident* pScriptedIncident = static_cast<CScriptIncident*>(pIncident);
		pScriptedIncident->SetIdealSpawnDistance(distance);
	}
}

void CommandDeleteIncident(int incidentIndex)
{
	CIncident* pIncident = CIncident::GetPool()->GetAt(incidentIndex);
	if( pIncident )
	{
		CIncidentManager::GetInstance().ClearIncident(pIncident);
	}
}

bool CommandIsIncidentValid(int incidentIndex)
{
	CIncident* pIncident = CIncident::GetPool()->GetAt(incidentIndex);
	if( pIncident )
	{
		return true;
	}
	return false;
}

bool CommandFindSpawnPointInDirection(const scrVector & vPosition, const scrVector &vDirection, float fIdealSpawnDistance, Vector3& vSpawnPoint)
{
	return (CDispatchSpawnHelper::FindSpawnPointInDirection((Vec3V)vPosition, (Vec3V)vDirection, fIdealSpawnDistance,
		CDispatchSpawnHelper::FSPIDF_CanFollowOutgoingLinks, RC_VEC3V(vSpawnPoint)));
}

void AddPopMultiplierAreaOverNetwork(u32 index)
{
	// Add over network....is a network game in progress and are we the script host?
	if(NetworkInterface::IsGameInProgress() && CTheScripts::GetCurrentGtaScriptHandlerNetwork())
	{
		PopMultiplierArea const*const area = CThePopMultiplierAreas::GetActiveArea(index);
		if (!area)
			return;

#if !__FINAL
        if(area->m_isSphere)
        {
            scriptDebugf1("%s: Adding population multiplier area sphere over network: Centre: (%.2f, %.2f, %.2f) Radius:%.2f, PD:%.2f, VD:%.2f, CAM:%s",
                CTheScripts::GetCurrentScriptNameAndProgramCounter(), 
                area->m_minWS.x, area->m_minWS.y, area->m_minWS.z,
                area->m_maxWS.x,
                area->m_pedDensityMultiplier,
                area->m_trafficDensityMultiplier,
			    area->m_bCameraGlobalMultiplier ? "(cam-global mult)" : "(zone-local mult)");
        }
        else
        {
            scriptDebugf1("%s: Adding population multiplier area box over network: Box Min (%.2f, %.2f, %.2f)-> Box Max (%.2f, %.2f, %.2f), PD:%.2f, VD:%.2f, CAM:%s",
                CTheScripts::GetCurrentScriptNameAndProgramCounter(), 
                area->m_minWS.x, area->m_minWS.y, area->m_minWS.z,
                area->m_maxWS.x, area->m_maxWS.y, area->m_maxWS.z,
                area->m_pedDensityMultiplier,
                area->m_trafficDensityMultiplier,
			    area->m_bCameraGlobalMultiplier ? "(cam-global mult)" : "(zone-local mult)");
        }
        scrThread::PrePrintStackTrace();
#endif // !__FINAL

		NetworkInterface::AddPopMultiplierAreaOverNetwork
		(
			CTheScripts::GetCurrentGtaScriptHandler()->GetScriptId(),
			area->m_minWS,
			area->m_maxWS,
			area->m_pedDensityMultiplier,
			area->m_trafficDensityMultiplier,
			area->m_isSphere,
			area->m_bCameraGlobalMultiplier
		);
	}
}

u32 CommandAddPopMultiplierArea(const scrVector & _minWS, const scrVector & _maxWS, float _pedDensityMultiplier, float _trafficDensityMultiplier, bool localOnly, bool bCameraGlobalMultiplier)
{
	u32 index = CThePopMultiplierAreas::CreatePopMultiplierArea(_minWS, _maxWS, _pedDensityMultiplier, _trafficDensityMultiplier, bCameraGlobalMultiplier);

	if(!localOnly)
	{
		scriptDebugf1("ADD_POP_MULTIPLIER_AREA (CommandAddPopMultiplierArea) was called with localOnly set to false. Forwarding to AddPopMultiplierAreaOverNetwork");
		AddPopMultiplierAreaOverNetwork(index);
	}
	else
	{
		scriptDebugf1("%s: Adding population multiplier area: (%.2f, %.2f, %.2f)->(%.2f, %.2f, %.2f), PD:%.2f, VD:%.2f, Local Only: %s, CAM: %s",
			CTheScripts::GetCurrentScriptNameAndProgramCounter(), 
			_minWS.x, _minWS.y, _minWS.z,
			_maxWS.x, _maxWS.y, _maxWS.z,
			_pedDensityMultiplier,
			_trafficDensityMultiplier,
			localOnly ? "True" : "False",
			bCameraGlobalMultiplier ? "(cam-global mult)" : "(zone-local mult)");
	}

	return index;
}

u32 CommandAddPopMultiplierSphere(const scrVector & _center, float _radius, float _pedDensityMultiplier, float _trafficDensityMultiplier, bool localOnly, bool bCameraGlobalMultiplier)
{
	u32 index = CThePopMultiplierAreas::CreatePopMultiplierArea(_center, _radius, _pedDensityMultiplier, _trafficDensityMultiplier, bCameraGlobalMultiplier);

	if(!localOnly)
	{
		scriptDebugf1("ADD_POP_MULTIPLIER_SPHERE (CommandAddPopMultiplierArea) was called with localOnly set to false. Forwarding to AddPopMultiplierAreaOverNetwork");
		AddPopMultiplierAreaOverNetwork(index);
	}
	else
	{
		scriptDebugf1("%s: Adding sphere population multiplier area: Center: (%.2f, %.2f, %.2f) with radius of %.2f, PD:%.2f, VD:%.2f, Local Only: %s, CAM: %s",
			CTheScripts::GetCurrentScriptNameAndProgramCounter(), 
			_center.x, _center.y, _center.z,
			_radius,
			_pedDensityMultiplier,
			_trafficDensityMultiplier,
			localOnly ? "True" : "False",
			bCameraGlobalMultiplier ? "(cam-global mult)" : "(zone-local mult)");
	}

	return index;
}

bool CommandDoesPopMultiplierAreaExist(int index)
{
	if (scriptVerifyf( (index >= 0) && (index < MAX_POP_MULTIPLIER_AREAS), "%s : invalid index %d - must be >= 0 and less than MAX_POP_MULTIPLIER_AREAS (%d)", __FUNCTION__, index, MAX_POP_MULTIPLIER_AREAS))
	{
		PopMultiplierArea const * const area = CThePopMultiplierAreas::GetActiveArea(index);

		if(area && area->m_init)
		{
			return true;
		}
	}

	return false;
}

bool CommandDoesPopMultiplierSphereExist(int sphereIndex)
{
	return CommandDoesPopMultiplierAreaExist(sphereIndex);
}

void RemovePopMultiplierAreaOverNetwork(u32 index)
{
	if(NetworkInterface::IsGameInProgress() && CTheScripts::GetCurrentGtaScriptHandlerNetwork())
	{
		PopMultiplierArea const*const area = CThePopMultiplierAreas::GetActiveArea(index);
		if (!area)
			return;

#if !__FINAL
        scriptDebugf1("%s: Removing population multiplier area over network: (%.2f, %.2f, %.2f)->(%.2f, %.2f, %.2f), PD:%.2f, VD:%.2f%s",
            CTheScripts::GetCurrentScriptNameAndProgramCounter(), 
            area->m_minWS.x, area->m_minWS.y, area->m_minWS.z,
            area->m_maxWS.x, area->m_maxWS.y, area->m_maxWS.z,
            area->m_pedDensityMultiplier,
            area->m_trafficDensityMultiplier,
            area->m_isSphere ? " (Sphere)" : "");
        scrThread::PrePrintStackTrace();
#endif // !__FINAL

		NetworkInterface::RemovePopMultiplierAreaOverNetwork
        (
            CTheScripts::GetCurrentGtaScriptHandler()->GetScriptId(),
            area->m_minWS,
            area->m_maxWS,
			area->m_pedDensityMultiplier,
			area->m_trafficDensityMultiplier,
            area->m_isSphere,
			area->m_bCameraGlobalMultiplier
        );
	}
}

void CommandRemovePopDensityMultiplierArea(int _areaIndex, bool localOnly)
{
	Assertf(_areaIndex < MAX_POP_MULTIPLIER_AREAS, "%s : invalid index %d - must be less than MAX_POP_MULTIPLIER_AREAS (%d) : areaIndex = %d : localOnly = %d", __FUNCTION__, _areaIndex, MAX_POP_MULTIPLIER_AREAS, _areaIndex, localOnly);	

	PopMultiplierArea const * const area = CThePopMultiplierAreas::GetActiveArea(_areaIndex);

	if(!area || !area->m_init)
	{
		Assertf(false, "%s : No area registered for index %d - either not registered or already freed up? areaIndex = %d : localOnly = %d", __FUNCTION__, _areaIndex, _areaIndex, localOnly);	

		return;
	}

	if(CTheScripts::GetCurrentGtaScriptHandler())
	{
		if(!localOnly)
		{
			if(NetworkInterface::FindPopMultiplierAreaOverNetwork(CTheScripts::GetCurrentGtaScriptHandler()->GetScriptId(), area->m_minWS, area->m_maxWS, area->m_pedDensityMultiplier, area->m_trafficDensityMultiplier, area->IsSphere(), area->m_bCameraGlobalMultiplier))
			{
				RemovePopMultiplierAreaOverNetwork(_areaIndex);

				CThePopMultiplierAreas::RemovePopMultiplierArea(area->m_minWS, area->m_maxWS, area->m_isSphere, area->m_pedDensityMultiplier, area->m_trafficDensityMultiplier, area->m_bCameraGlobalMultiplier);

				return;
			}
			else
			{
				scriptDebugf1("CommandRemovePopDensityMultiplierArea Failed to FindPopMultiplierAreaOverNetwork! (%.2f, %.2f, %.2f)->(%.2f, %.2f, %.2f), PD:%.2f, VD:%.2f, CGM:%s",
                    area->m_minWS.x, area->m_minWS.y, area->m_minWS.z,
                    area->m_maxWS.x, area->m_maxWS.y, area->m_maxWS.z,
                    area->m_pedDensityMultiplier,
                    area->m_trafficDensityMultiplier,
                    area->m_bCameraGlobalMultiplier ? "TRUE" : "FALSE");
			}
		}
		else
		{
			if(!NetworkInterface::FindPopMultiplierAreaOverNetwork(CTheScripts::GetCurrentGtaScriptHandler()->GetScriptId(), area->m_minWS, area->m_maxWS, area->m_pedDensityMultiplier, area->m_trafficDensityMultiplier, area->IsSphere(), area->m_bCameraGlobalMultiplier))
			{
				scriptDebugf1("%s: Removing population multiplier area locally: (%.2f, %.2f, %.2f)->(%.2f, %.2f, %.2f), PD:%.2f, VD:%.2f, CGM:%s",
					CTheScripts::GetCurrentScriptNameAndProgramCounter(), 
					area->m_minWS.x, area->m_minWS.y, area->m_minWS.z,
					area->m_maxWS.x, area->m_maxWS.y, area->m_maxWS.z,
					area->m_pedDensityMultiplier,
					area->m_trafficDensityMultiplier,
                    area->m_bCameraGlobalMultiplier ? "TRUE" : "FALSE");

				CThePopMultiplierAreas::RemovePopMultiplierArea(area->m_minWS, area->m_maxWS, area->m_isSphere, area->m_pedDensityMultiplier, area->m_trafficDensityMultiplier, area->m_bCameraGlobalMultiplier);

				return;
			}
			else
			{
				scriptDebugf1("CommandRemovePopDensityMultiplierArea Attempting to locally delete a multiplayer pop area! (%.2f, %.2f, %.2f)->(%.2f, %.2f, %.2f), PD:%.2f, VD:%.2f, CGM:%s",
                    area->m_minWS.x, area->m_minWS.y, area->m_minWS.z,
                    area->m_maxWS.x, area->m_maxWS.y, area->m_maxWS.z,
                    area->m_pedDensityMultiplier,
                    area->m_trafficDensityMultiplier,
                    area->m_bCameraGlobalMultiplier ? "TRUE" : "FALSE");
			}
		}
	}

	Assertf(false, "ERROR : CommandRemovePopDensityMultiplierArea : Script handler == %p _areaIndex %d: (%.2f, %.2f, %.2f)->(%.2f, %.2f, %.2f), PD:%.2f, VD:%.2f, CGM:%s",
        CTheScripts::GetCurrentGtaScriptHandler(),
        _areaIndex,
        area->m_minWS.x, area->m_minWS.y, area->m_minWS.z,
        area->m_maxWS.x, area->m_maxWS.y, area->m_maxWS.z,
        area->m_pedDensityMultiplier,
        area->m_trafficDensityMultiplier,
        area->m_bCameraGlobalMultiplier ? "TRUE" : "FALSE");
}

bool CommandIsPopDensityMultiplierAreaNetworked(int _areaIndex)
{
	PopMultiplierArea const * const area = CThePopMultiplierAreas::GetActiveArea(_areaIndex);

	if(!area || !area->m_init)
	{
		scriptDebugf1("%s : No area registered for index %d - either not registered or already freed up? areaIndex = %d", __FUNCTION__, _areaIndex, _areaIndex);	
		return false;
	}

	if(CTheScripts::GetCurrentGtaScriptHandler())
	{
		return NetworkInterface::FindPopMultiplierAreaOverNetwork(CTheScripts::GetCurrentGtaScriptHandler()->GetScriptId(), area->m_minWS, area->m_maxWS, area->m_pedDensityMultiplier, area->m_trafficDensityMultiplier, area->IsSphere(), area->m_bCameraGlobalMultiplier);
	}	
	return false;
}

void CommandRemovePopDensityMultiplierSphere(int sphereIndex, bool localOnly)
{
	CommandRemovePopDensityMultiplierArea(sphereIndex, localOnly);
}

void CommandEnableTennisMode(s32 pedIndex, bool enable, bool bUseFemaleClipSet) 
{
	CPed* pPed = CTheScripts::GetEntityToModifyFromGUID<CPed>(pedIndex, CTheScripts::GUID_ASSERT_FLAGS_INCLUDE_CLONES);
	if(pPed)
	{
		SCRIPT_ASSERT(pPed->m_nDEflags.bCheckedForDead == TRUE, "ENABLE_TENNIS_MODE - Check ped is alive this frame");
		if (enable)
		{
			CTaskMotionPed* pCurrentMotionTask = static_cast<CTaskMotionPed*>(pPed->GetPedIntelligence()->GetTaskManager()->FindTaskByTypeActive(PED_TASK_TREE_MOTION, CTaskTypes::TASK_MOTION_PED));
			if(pCurrentMotionTask)
			{
				pCurrentMotionTask->SetCleanupMotionTaskNetworkOnQuit(false);
			}

			CTaskMotionTennis* pTask = rage_new CTaskMotionTennis(bUseFemaleClipSet); 
			pPed->GetPedIntelligence()->GetTaskManager()->SetTask(PED_TASK_TREE_MOTION, pTask, PED_TASK_MOTION_DEFAULT, true);
		} 
		else 
		{
			pPed->StartPrimaryMotionTask();
		}
	}
}


void CommandCloneOverrideTennisMode(s32 pedIndex, bool bAllowOverrideCloneUpdate)
{
	const CPed* pPed = CTheScripts::GetEntityToQueryFromGUID<CPed>(pedIndex);
	if(pPed)
	{
		SCRIPT_ASSERT(pPed->m_nDEflags.bCheckedForDead == TRUE, "ENABLE_CLONE_OVERRIDE_TENNIS_MODE - Check ped is alive this frame");
		CTaskMotionTennis* pTask = (CTaskMotionTennis*)(pPed->GetPedIntelligence()->FindTaskActiveMotionByType(CTaskTypes::TASK_MOTION_TENNIS));
		if(pTask)
		{
			pTask->SetAllowOverrideCloneUpdate(bAllowOverrideCloneUpdate);
		}
	}
}

bool CommandIsInTennisMode(s32 pedIndex) 
{
	const CPed* pPed = CTheScripts::GetEntityToQueryFromGUID<CPed>(pedIndex);
	if(pPed)
	{
		SCRIPT_ASSERT(pPed->m_nDEflags.bCheckedForDead == TRUE, "IS_TENNIS_MODE - Check ped is alive this frame");
		CTaskMotionTennis* pTaskMoVE = (CTaskMotionTennis*)pPed->GetPedIntelligence()->FindTaskActiveMotionByType(CTaskTypes::TASK_MOTION_TENNIS);
		if(pTaskMoVE && pTaskMoVE->GetMoveNetworkHelper()->IsNetworkActive())
		{
			return true;
		}
	}
	return false;
}

void CommandPlayTennisSwingAnim(s32 pedIndex, const char *pAnimDictName, const char *pAnimName, float startPhase, float playRate, bool bSlowBlend)
{
	const CPed* pPed = CTheScripts::GetEntityToQueryFromGUID<CPed>(pedIndex);
	if(pPed)
	{
		SCRIPT_ASSERT(pPed->m_nDEflags.bCheckedForDead == TRUE, "PLAY_TENNIS_SWING_ANIM - Check ped is alive this frame");
		CTaskMotionTennis* pTask = (CTaskMotionTennis*)(pPed->GetPedIntelligence()->FindTaskActiveMotionByType(CTaskTypes::TASK_MOTION_TENNIS));
		if(pTask)
		{
			pTask->PlayTennisSwingAnim(pAnimDictName, pAnimName, startPhase, playRate, bSlowBlend);
		}
	}
}

void CommandPlayTennisDiveAnim(s32 pedIndex, int iDirection, float fDiveHorizontal, float fDiveVertical, float fPlayRate, bool bSlowBlend)
{
	const CPed* pPed = CTheScripts::GetEntityToQueryFromGUID<CPed>(pedIndex);
	if(pPed)
	{
		SCRIPT_ASSERT(pPed->m_nDEflags.bCheckedForDead == TRUE, "PLAY_TENNIS_DIVE_ANIM - Check ped is alive this frame");
		CTaskMotionTennis* pTask = (CTaskMotionTennis*)(pPed->GetPedIntelligence()->FindTaskActiveMotionByType(CTaskTypes::TASK_MOTION_TENNIS));
		if(pTask)
		{
			pTask->PlayDiveAnim((CTaskMotionTennis::eDiveDirection)iDirection, fDiveHorizontal, fDiveVertical, fPlayRate, bSlowBlend);
		}
	}
}

void CommandSetTennisSwingAnimPlayRate(s32 pedIndex, float playRate)
{
	const CPed* pPed = CTheScripts::GetEntityToQueryFromGUID<CPed>(pedIndex);
	if(pPed)
	{
		SCRIPT_ASSERT(pPed->m_nDEflags.bCheckedForDead == TRUE, "SET_TENNIS_SWING_ANIM_PLAY_RATE - Check ped is alive this frame");
		CTaskMotionTennis* pTask = (CTaskMotionTennis*)(pPed->GetPedIntelligence()->FindTaskActiveMotionByType(CTaskTypes::TASK_MOTION_TENNIS));
		if(pTask)
		{
			pTask->SetSwingAnimPlayRate(playRate);
		}
	}
}

bool CommandGetTennisSwingAnimComplete(s32 pedIndex)
{
	const CPed* pPed = CTheScripts::GetEntityToQueryFromGUID<CPed>(pedIndex);
	if(pPed)
	{
		SCRIPT_ASSERT(pPed->m_nDEflags.bCheckedForDead == TRUE, "GET_TENNIS_SWING_ANIM_COMPLETE - Check ped is alive this frame");
		CTaskMotionTennis* pTask = (CTaskMotionTennis*)(pPed->GetPedIntelligence()->FindTaskActiveMotionByType(CTaskTypes::TASK_MOTION_TENNIS));
		if(pTask)
		{
			return pTask->GetTennisSwingAnimComplete();
		}
	}

	return false;
}

bool CommandTennisSwingAnimCanBeInterrupted(s32 pedIndex)
{
	const CPed* pPed = CTheScripts::GetEntityToQueryFromGUID<CPed>(pedIndex);
	if(pPed)
	{
		SCRIPT_ASSERT(pPed->m_nDEflags.bCheckedForDead == TRUE, "GET_TENNIS_SWING_ANIM_CAN_BE_INTERRUPTED - Check ped is alive this frame");
		CTaskMotionTennis* pTask = (CTaskMotionTennis*)(pPed->GetPedIntelligence()->FindTaskActiveMotionByType(CTaskTypes::TASK_MOTION_TENNIS));
		if(pTask)
		{
			return pTask->GetTennisSwingAnimCanBeInterrupted();
		}
	}

	return false;
}

bool CommandTennisSwingAnimSwung(s32 pedIndex)
{
	const CPed* pPed = CTheScripts::GetEntityToQueryFromGUID<CPed>(pedIndex);
	if(pPed)
	{
		SCRIPT_ASSERT(pPed->m_nDEflags.bCheckedForDead == TRUE, "GET_TENNIS_SWING_ANIM_SWUNG - Check ped is alive this frame");
		CTaskMotionTennis* pTask = (CTaskMotionTennis*)(pPed->GetPedIntelligence()->FindTaskActiveMotionByType(CTaskTypes::TASK_MOTION_TENNIS));
		if(pTask)
		{
			return pTask->GetTennisSwingAnimSwung();
		}
	}

	return false;
}

void CommandSetTennisAllowDampenStrafeDirection(s32 pedIndex, bool bAllow)
{
	const CPed* pPed = CTheScripts::GetEntityToQueryFromGUID<CPed>(pedIndex);
	if(pPed)
	{
		SCRIPT_ASSERT(pPed->m_nDEflags.bCheckedForDead == TRUE, "SET_TENNIS_ALLOW_DAMPEN_STRAFE_DIRECTION - Check ped is alive this frame");
		CTaskMotionTennis* pTask = (CTaskMotionTennis*)(pPed->GetPedIntelligence()->FindTaskActiveMotionByType(CTaskTypes::TASK_MOTION_TENNIS));
		if(pTask)
		{
			pTask->SetAllowDampenStrafeDirection(bAllow);
		}
	}
}

void CommandSetTennisMoveNetworkSignalFloat(int PedIndex, const char* szSignal, float fSignal)
{
	CPed* pPed = CTheScripts::GetEntityToModifyFromGUID<CPed>(PedIndex, CTheScripts::GUID_ASSERT_FLAGS_INCLUDE_CLONES);
	if (pPed && pPed->GetPedIntelligence())
	{
		CTaskMotionTennis* pTaskMoVE = (CTaskMotionTennis*)(pPed->GetPedIntelligence()->FindTaskActiveMotionByType(CTaskTypes::TASK_MOTION_TENNIS));
		if (SCRIPT_VERIFY (pTaskMoVE, "SET_TENNIS_MOVE_NETWORK_SIGNAL_FLOAT - task CTaskMotionTennis is not running!"))
		{
			if( SCRIPT_VERIFY (pTaskMoVE->GetMoveNetworkHelper()->IsNetworkActive(), "SET_TENNIS_MOVE_NETWORK_SIGNAL_FLOAT - Move network not active!") )
			{
				if( SCRIPT_VERIFY ((!pPed->IsNetworkClone() || pTaskMoVE->GetAllowOverrideCloneUpdate()),
					"SET_TENNIS_MOVE_NETWORK_SIGNAL_FLOAT - Can't set float on cloned ped if its task is not being overridden!" ) )
				{
					pTaskMoVE->SetSignalFloat(szSignal, fSignal);
				}
			}
		}
	}
}

void CommandResetDispatchSpawnLocation()
{
	//Reset the spawn location.
	CDispatchSpawnProperties::GetInstance().ResetLocation();
}

void CommandSetDispatchSpawnLocation(const scrVector & vLocation)
{
	//Set the spawn location.
	CDispatchSpawnProperties::GetInstance().SetLocation((Vec3V)vLocation);
}

void CommandResetDispatchIdealSpawnDistance()
{
	//Reset the ideal spawn distance.
	CDispatchSpawnProperties::GetInstance().ResetIdealSpawnDistance();
}

void CommandSetDispatchIdealSpawnDistance(const float fIdealSpawnDistance)
{
	//Set the ideal spawn distance.
	CDispatchSpawnProperties::GetInstance().SetIdealSpawnDistance(fIdealSpawnDistance);
}

void CommandResetDispatchTimeBetweenSpawnAttempts(const int dispatchEnum)
{
	//Check if the resource is active.
	scriptResource* pResource = CTheScripts::GetCurrentGtaScriptHandler()->GetScriptResource(CGameScriptResource::SCRIPT_RESOURCE_DISPATCH_TIME_BETWEEN_SPAWN_ATTEMPTS, dispatchEnum);
	if(pResource)
	{
		//Remove the resource.
		CTheScripts::GetCurrentGtaScriptHandler()->RemoveScriptResource(pResource->GetId(), false, true, CGameScriptResource::SCRIPT_RESOURCE_DISPATCH_TIME_BETWEEN_SPAWN_ATTEMPTS);
	}
}

void CommandSetDispatchTimeBetweenSpawnAttempts(const int dispatchEnum, const float fTimeBetweenSpawnAttempts)
{
	//Remove the resource.
	CommandResetDispatchTimeBetweenSpawnAttempts(dispatchEnum);
	
	//Register the resource.
	CScriptResource_DispatchTimeBetweenSpawnAttempts timeBetweenSpawnAttempts(dispatchEnum, fTimeBetweenSpawnAttempts);
	CTheScripts::GetCurrentGtaScriptHandler()->RegisterScriptResource(timeBetweenSpawnAttempts);
}

void CommandResetDispatchTimeBetweenSpawnAttemptsMultiplier(const int dispatchEnum)
{
	//Check if the resource is active.
	scriptResource* pResource = CTheScripts::GetCurrentGtaScriptHandler()->GetScriptResource(CGameScriptResource::SCRIPT_RESOURCE_DISPATCH_TIME_BETWEEN_SPAWN_ATTEMPTS_MULTIPLIER, dispatchEnum);
	if(pResource)
	{
		//Remove the resource.
		CTheScripts::GetCurrentGtaScriptHandler()->RemoveScriptResource(pResource->GetId(), false, true, CGameScriptResource::SCRIPT_RESOURCE_DISPATCH_TIME_BETWEEN_SPAWN_ATTEMPTS_MULTIPLIER);
	}
}

void CommandSetDispatchTimeBetweenSpawnAttemptsMultiplier(const int dispatchEnum, const float fTimeBetweenSpawnAttemptsMultiplier)
{
	//Remove the resource.
	CommandResetDispatchTimeBetweenSpawnAttemptsMultiplier(dispatchEnum);
	
	//Register the resource.
	CScriptResource_DispatchTimeBetweenSpawnAttemptsMultiplier timeBetweenSpawnAttemptsMultiplier(dispatchEnum, fTimeBetweenSpawnAttemptsMultiplier);
	CTheScripts::GetCurrentGtaScriptHandler()->RegisterScriptResource(timeBetweenSpawnAttemptsMultiplier);
}

int CommandAddDispatchSpawnAngledBlockingArea(const scrVector & vStart, const scrVector & vEnd, float fWidth)
{
	//Add the blocking area.
	int iIndex = CDispatchSpawnProperties::GetInstance().AddAngledBlockingArea((Vec3V)vStart, (Vec3V)vEnd, fWidth);
	if(SCRIPT_VERIFY(iIndex >= 0, "ADD_DISPATCH_SPAWN_ANGLED_BLOCKING_AREA -- Failed to add blocking area."))
	{
		return iIndex;
	}
	else
	{
		return -1;
	}
}

int CommandAddDispatchSpawnSphereBlockingArea(const scrVector & vCenter, float fRadius)
{
	//Add the blocking area.
	int iIndex = CDispatchSpawnProperties::GetInstance().AddSphereBlockingArea((Vec3V)vCenter, fRadius);
	if(SCRIPT_VERIFY(iIndex >= 0, "ADD_DISPATCH_SPAWN_SPHERE_BLOCKING_AREA -- Failed to add blocking area."))
	{
		return iIndex;
	}
	else
	{
		return -1;
	}
}

void CommandRemoveDispatchSpawnBlockingArea(int iIndex)
{
	//Remove the blocking area.
	CDispatchSpawnProperties::GetInstance().RemoveBlockingArea(iIndex);
}

void CommandResetDispatchSpawnBlockingAreas()
{
	//Reset the blocking areas.
	CDispatchSpawnProperties::GetInstance().ResetBlockingAreas();
}

void CommandResetWantedResponseNumPedsToSpawn()
{
	//Reset the number of peds to spawn.
	CWantedResponseOverrides::GetInstance().ResetNumPedsToSpawn();
}

void CommandSetWantedResponseNumPedsToSpawn(int iDispatchType, int iNumPedsToSpawn)
{
	//Set the number of peds to spawn.
	CWantedResponseOverrides::GetInstance().SetNumPedsToSpawn((DispatchType)iDispatchType, (s8)iNumPedsToSpawn);
}

void CommandAddTacticalNavMeshPoint(const scrVector & vPosition)
{
	CTacticalAnalysisNavMeshPoints::AddPointFromScript((Vec3V)vPosition);
}

void CommandClearTacticalNavMeshPoints()
{
	CTacticalAnalysisNavMeshPoints::ClearPointsFromScript();
}

void CommandSetRiotModeEnabled(bool bEnabled)
{
	CRiots::GetInstance().SetEnabled(bEnabled);
}

/* Virtual Keyboard usage:

DISPLAY_ONSCREEN_KEYBOARD("Enter Some Text", "initial value")

INT oskStatus = OSK_PENDING
WHILE (oskStatus == OSK_PENDING) DO
	oskStatus = UPDATE_ONSCREEN_KEYBOARD()
	WAIT(0)
END

IF oskStatus == OSK_SUCCESS THEN
    STRING result = GET_ONSCREEN_KEYBOARD_RESULT()
END

*/


enum eKeyboardType
{
	ONSCREEN_KEYBOARD_ENGLISH,
	ONSCREEN_KEYBOARD_LOCALISED,
	ONSCREEN_KEYBOARD_PASSWORD,
	ONSCREEN_KEYBOARD_GAMERTAG,
	ONSCREEN_KEYBOARD_EMAIL,
	ONSCREEN_KEYBOARD_BASIC_ENGLISH,
	ONSCREEN_KEYBOARD_FILENAME,
};


void CommandDisplayOnScreenKeyboardWithLongerInitialString(s32 keyboardTypeFlag, const char* title, const char* XENON_ONLY(pDescription) DURANGO_ONLY(pDescription), const char* pInitialValue1, const char* pInitialValue2, const char* pInitialValue3, const char* pInitialValue4, const char* pInitialValue5, const char* pInitialValue6, const char* pInitialValue7, const char* pInitialValue8, s32 maxLength)
{
	static char16 g_VirtualKeyboardTitle[64];
#if __XENON || RSG_DURANGO
	static char16 g_VirtualKeyboardDescription[256];
#endif	//	__XENON || RSG_DURANGO

	if (maxLength < 2)
	{
		scriptAssertf(0, "%s : DISPLAY_ONSCREEN_KEYBOARD - MaxLength (%d) is less than 2 so setting it to 2", CTheScripts::GetCurrentScriptNameAndProgramCounter(), maxLength);
		maxLength = 2;
	}

	if (maxLength > ioVirtualKeyboard::MAX_STRING_LENGTH_FOR_VIRTUAL_KEYBOARD)
	{
		scriptAssertf(0, "%s : DISPLAY_ONSCREEN_KEYBOARD - MaxLength (%d) is greater than %d so setting it to %d", CTheScripts::GetCurrentScriptNameAndProgramCounter(), maxLength, ioVirtualKeyboard::MAX_STRING_LENGTH_FOR_VIRTUAL_KEYBOARD, ioVirtualKeyboard::MAX_STRING_LENGTH_FOR_VIRTUAL_KEYBOARD);
		maxLength = ioVirtualKeyboard::MAX_STRING_LENGTH_FOR_VIRTUAL_KEYBOARD;
	}

	if (title == NULL)
	{
		scriptAssertf(0, "DISPLAY_ONSCREEN_KEYBOARD - prompt string is NULL so setting it to an empty string");
		title = "";
	}

	char longInitialString[ioVirtualKeyboard::MAX_STRING_LENGTH_FOR_VIRTUAL_KEYBOARD];

	safecpy(longInitialString, "", ioVirtualKeyboard::MAX_STRING_LENGTH_FOR_VIRTUAL_KEYBOARD);
	if (scriptVerifyf(pInitialValue1, "DISPLAY_ONSCREEN_KEYBOARD - initialValue string is NULL so setting it to an empty string"))
	{
		safecat(longInitialString, pInitialValue1, ioVirtualKeyboard::MAX_STRING_LENGTH_FOR_VIRTUAL_KEYBOARD);
	}

	if (pInitialValue2)
	{
		safecat(longInitialString, pInitialValue2, ioVirtualKeyboard::MAX_STRING_LENGTH_FOR_VIRTUAL_KEYBOARD);
	}

	if (pInitialValue3)
	{
		safecat(longInitialString, pInitialValue3, ioVirtualKeyboard::MAX_STRING_LENGTH_FOR_VIRTUAL_KEYBOARD);
	}

	if (pInitialValue4)
	{
		safecat(longInitialString, pInitialValue4, ioVirtualKeyboard::MAX_STRING_LENGTH_FOR_VIRTUAL_KEYBOARD);
	}

	if (pInitialValue5)
	{
		safecat(longInitialString, pInitialValue5, ioVirtualKeyboard::MAX_STRING_LENGTH_FOR_VIRTUAL_KEYBOARD);
	}

	if (pInitialValue6)
	{
		safecat(longInitialString, pInitialValue6, ioVirtualKeyboard::MAX_STRING_LENGTH_FOR_VIRTUAL_KEYBOARD);
	}
	if (pInitialValue7)
	{
		safecat(longInitialString, pInitialValue7, ioVirtualKeyboard::MAX_STRING_LENGTH_FOR_VIRTUAL_KEYBOARD);
	}
	if (pInitialValue8)
	{
		safecat(longInitialString, pInitialValue8, ioVirtualKeyboard::MAX_STRING_LENGTH_FOR_VIRTUAL_KEYBOARD);
	}

	USES_CONVERSION;
	ioVirtualKeyboard::Params params;

	params.m_KeyboardType = ioVirtualKeyboard::kTextType_ALPHABET;
	params.m_AlphabetType = ioVirtualKeyboard::kAlphabetType_ENGLISH;

	switch (keyboardTypeFlag)
	{
	case ONSCREEN_KEYBOARD_ENGLISH :
		break;

	case ONSCREEN_KEYBOARD_LOCALISED :
		switch (CPauseMenu::GetMenuPreference(PREF_CURRENT_LANGUAGE))
		{
		case LANGUAGE_RUSSIAN :
			params.m_AlphabetType = ioVirtualKeyboard::kAlphabetType_CYRILLIC;
			break;

		case LANGUAGE_KOREAN :
			params.m_AlphabetType = ioVirtualKeyboard::kAlphabetType_KOREAN;
			break;

		case LANGUAGE_CHINESE_TRADITIONAL :
			params.m_AlphabetType = ioVirtualKeyboard::kAlphabetType_CHINESE;
			break;

		case LANGUAGE_CHINESE_SIMPLIFIED:
			params.m_AlphabetType = ioVirtualKeyboard::kAlphabetType_CHINESE_SIMPLIFIED;
			break;

		case LANGUAGE_JAPANESE :
			params.m_AlphabetType = ioVirtualKeyboard::kAlphabetType_JAPANESE;
			break;

		case LANGUAGE_POLISH :
			params.m_AlphabetType = ioVirtualKeyboard::kAlphabetType_POLISH;
			break;
		}
		break;

	case ONSCREEN_KEYBOARD_PASSWORD :
		params.m_KeyboardType = ioVirtualKeyboard::kTextType_PASSWORD;
		break;

	case ONSCREEN_KEYBOARD_GAMERTAG :
		params.m_KeyboardType = ioVirtualKeyboard::kTextType_GAMERTAG;
		break;

	case ONSCREEN_KEYBOARD_EMAIL :
		params.m_KeyboardType = ioVirtualKeyboard::kTextType_EMAIL;
		break;

	case ONSCREEN_KEYBOARD_BASIC_ENGLISH :
		params.m_AlphabetType = ioVirtualKeyboard::kAlphabetType_BASIC_ENGLISH;
		break;

	case ONSCREEN_KEYBOARD_FILENAME :
		params.m_KeyboardType = ioVirtualKeyboard::kTextType_FILENAME;
		break;

	default :
		scriptAssertf(0, "%s : DISPLAY_ONSCREEN_KEYBOARD - Unrecognized keyboardTypeFlag %d so defaulting to English kTextType_ALPHABET", CTheScripts::GetCurrentScriptNameAndProgramCounter(), keyboardTypeFlag);
		break;
	}

	Utf8ToWide(g_VirtualKeyboardTitle, TheText.Get(title), NELEM(g_VirtualKeyboardTitle));
	params.m_Title = g_VirtualKeyboardTitle;

#if __XENON || RSG_DURANGO
	if (pDescription)
	{
		Utf8ToWide(g_VirtualKeyboardDescription, TheText.Get(pDescription), NELEM(g_VirtualKeyboardDescription));
		params.m_Description = g_VirtualKeyboardDescription;
	}
#endif	//	__XENON || RSG_DURANGO

	params.m_InitialValue = UTF8_TO_WIDE(longInitialString);
	//params.m_InitialValue = A2W(initialValue);
	params.m_PlayerIndex = CControlMgr::GetMainPlayerIndex();
	params.m_MaxLength = maxLength;

	CControlMgr::ShowVirtualKeyboard(params);
}

void CommandDisplayOnScreenKeyboard(s32 keyboardTypeFlag, const char* title, const char* pDescription, const char* pInitialValue1, const char* pInitialValue2, const char* pInitialValue3, const char* pInitialValue4, s32 maxLength)
{
	CommandDisplayOnScreenKeyboardWithLongerInitialString(keyboardTypeFlag, title, pDescription, pInitialValue1, pInitialValue2, pInitialValue3, pInitialValue4, "", "", "", "", maxLength);
}


int CommandUpdateOnScreenKeyboard()
{
	return (int)CControlMgr::UpdateVirtualKeyboard();
}

const char* CommandGetOnScreenKeyboardResult()
{
	if (CControlMgr::GetVirtualKeyboardState() == ioVirtualKeyboard::kKBState_SUCCESS)
	{
		return CControlMgr::GetVirtualKeyboardResult();
	}
	return NULL;
}

void CommandCancelOnScreenKeyboard()
{
	CControlMgr::CancelVirtualKeyboard();
}


void CommandSetAllowTildeCharacterFromOnScreenKeyboard(bool NOTFINAL_ONLY(bAllowTilde))
{
#if !__FINAL
	CControlMgr::SetAllowTildeCharacterFromVirtualKeyboard(bAllowTilde);
#endif	//	!__FINAL
}

void CommandNextOnScreenKeyboardResultWillDisplayUsingTheseFonts(int fontBitField)
{
	CControlMgr::SetFontBitFieldForDisplayingOnscreenKeyboardResult(fontBitField);
}

void CommandEnableAction(int iActionToEnable, bool bEnable)
{
	ACTIONMGR.EnableAction( (u32)iActionToEnable, bEnable );
}

bool CommandIsActionEnabled( int iActionHash )
{
	return ACTIONMGR.IsActionEnabled( (u32)iActionHash );
}


int CommandGetRealWorldTime()
{
	return fwTimer::GetTimeInMilliseconds() / 1000;
}

void CommandSetRandomEventEnabled(s32 eventType, bool bEnable)
{
	CRandomEventManager::GetInstance().SetEventTypeEnabled(eventType, bEnable);
}

void CommandSetExplosiveAmmoThisFrame(int PlayerIndex)
{
	if (NetworkInterface::IsGameInProgress())
	{
		scriptAssertf(0, "SET_EXPLOSIVE_AMMO_THIS_FRAME call detected in MP, blocked!");
#if USE_RAGESEC
		RageSecPluginGameReactionObject t(REACT_TELEMETRY, GENERIC_GAME_ID, fwRandom::GetRandomNumber(), fwRandom::GetRandomNumber(), 0xD1D3C375);
		rageSecGamePluginManager::GetRageSecGameReactionObjectQueue()->Push(t);
		t.type = REACT_KICK_RANDOMLY;
		rageSecGamePluginManager::GetRageSecGameReactionObjectQueue()->Push(t);
		t.type = REACT_DESTROY_MATCHMAKING;
		rageSecGamePluginManager::GetRageSecGameReactionObjectQueue()->Push(t);
#endif // USE_RAGESEC
	}
	else
	{
		CPed* pPlayer = CTheScripts::FindLocalPlayerPed(PlayerIndex);
		if (pPlayer)
		{
			pPlayer->GetPlayerInfo()->GetPlayerResetFlags().SetFlag(CPlayerResetFlags::PRF_EXPLOSIVE_AMMO_ON);
		}
	}
}

void CommandSetFireAmmoThisFrame(int PlayerIndex)
{
	if(NetworkInterface::IsGameInProgress())
	{
		CPed* pPlayer = CTheScripts::FindNetworkPlayerPed(PlayerIndex);
		if (pPlayer)
		{
			pPlayer->GetPlayerInfo()->GetPlayerResetFlags().SetFlag(CPlayerResetFlags::PRF_FIRE_AMMO_ON);
		}
	}
	else
	{
		CPed* pPlayer = CTheScripts::FindLocalPlayerPed(PlayerIndex);
		if (pPlayer)
		{
			pPlayer->GetPlayerInfo()->GetPlayerResetFlags().SetFlag(CPlayerResetFlags::PRF_FIRE_AMMO_ON);
		}
	}
}

void CommandSetExplosiveMeleeThisFrame(int PlayerIndex)
{
	if (NetworkInterface::IsGameInProgress())
	{
		scriptAssertf(0, "SET_EXPLOSIVE_MELEE_THIS_FRAME call detected in MP, blocked!");
#if USE_RAGESEC
		RageSecPluginGameReactionObject t(REACT_TELEMETRY, GENERIC_GAME_ID, fwRandom::GetRandomNumber(), fwRandom::GetRandomNumber(), 0xC9BA5BEB);
		rageSecGamePluginManager::GetRageSecGameReactionObjectQueue()->Push(t);
		t.type = REACT_KICK_RANDOMLY;
		rageSecGamePluginManager::GetRageSecGameReactionObjectQueue()->Push(t);
		t.type = REACT_DESTROY_MATCHMAKING;
		rageSecGamePluginManager::GetRageSecGameReactionObjectQueue()->Push(t);
#endif // USE_RAGESEC
	}
	else
	{
		CPed* pPlayer = CTheScripts::FindLocalPlayerPed(PlayerIndex);
		if (pPlayer)
		{
			pPlayer->GetPlayerInfo()->GetPlayerResetFlags().SetFlag(CPlayerResetFlags::PRF_EXPLOSIVE_MELEE_ON);
		}
	}
}

void CommandSetSuperJumpThisFrame(int PlayerIndex)
{
	CPed* pPlayer = CTheScripts::FindLocalPlayerPed(PlayerIndex);
	if (pPlayer)
	{
		pPlayer->GetPlayerInfo()->GetPlayerResetFlags().SetFlag(CPlayerResetFlags::PRF_SUPER_JUMP_ON);
	}
}

bool CommandGetIsSuperJumpActive(int PlayerIndex)
{
	CPed* pPlayer = CTheScripts::FindLocalPlayerPed(PlayerIndex);
	if (pPlayer)
	{
		return pPlayer->GetPlayerInfo()->GetPlayerResetFlags().IsFlagSet(CPlayerResetFlags::PRF_SUPER_JUMP_ON);
	}
	return false;
}

void CommandSetBeastJumpThisFrame(int PlayerIndex)
{
	CPed* pPlayer = CTheScripts::FindLocalPlayerPed(PlayerIndex);
	if (pPlayer)
	{
		pPlayer->GetPlayerInfo()->GetPlayerResetFlags().SetFlag(CPlayerResetFlags::PRF_BEAST_JUMP_ON);
	}
}

bool CommandGetIsBeastJumpActive(int PlayerIndex)
{
	CPed* pPlayer = CTheScripts::FindLocalPlayerPed(PlayerIndex);
	if (pPlayer)
	{
		return pPlayer->GetPlayerInfo()->GetPlayerResetFlags().IsFlagSet(CPlayerResetFlags::PRF_BEAST_JUMP_ON);
	}
	return false;
}

void CommandSetForcedJumpThisFrame(int PlayerIndex)
{
	CPed* pPlayer = CTheScripts::FindLocalPlayerPed(PlayerIndex);
	if (pPlayer)
	{
		pPlayer->GetPlayerInfo()->GetPlayerResetFlags().SetFlag(CPlayerResetFlags::PRF_FORCED_JUMP);
	}
}

void CommandWaitUntilGameInstalled()
{
	SCRIPT_ASSERT(false, "WAIT_UNTIL_GAME_INSTALLED - This command isn't used anymore!");
}

bool CommandHasGameInstalledThisSession()
{
	return StreamingInstall::HasInstalledThisSession();
}


void CommandSetInstancePriorityMode(int playMode)
{
	CInstancePriority::SetMode(playMode);
}

void CommandSetInstancePriorityHint(int hint)
{
	CInstancePriority::SetScriptHint(hint);
}

void CommandSetTickerJohnMarstonIsDone()
{
	CProfileSettings& settings = CProfileSettings::GetInstance();
	scriptAssertf(settings.AreSettingsValid(), "%s:SET_TICKER_JOHNMARSTON_IS_DONE - Profile Settings are not available.", CTheScripts::GetCurrentScriptNameAndProgramCounter());

	if(settings.AreSettingsValid() && !settings.Exists(CProfileSettings::TICKER_JOHN_MARSTON_IS_AVAILABLE))
	{
		settings.Set(CProfileSettings::TICKER_JOHN_MARSTON_IS_AVAILABLE, 1);
		settings.Write();
	}
}

void CommandPreventArrestStateThisFrame()
{
	CGameLogic::SuppressArrestState();
}

bool CommandAreProfileSettingsValid()
{
	CProfileSettings& settings = CProfileSettings::GetInstance();
	return settings.AreSettingsValid();
}

void CommandForceStatePlaying()
{
	CGameLogic::ForceStatePlaying();

	CPlayerInfo	*pPlayerInfo = CGameWorld::GetMainPlayerInfo();
	if( pPlayerInfo && pPlayerInfo->GetPlayerPed() )
	{
		pPlayerInfo->SetPlayerState(CPlayerInfo::PLAYERSTATE_PLAYING);
	}
}

void CommandScriptRaceInit(s32 numCheckpoints, s32 numLaps, s32 numPlayers, s32 localPlayerIndex)
{
    CRaceTimes::Init(numCheckpoints, numLaps, numPlayers, localPlayerIndex);
}

void CommandScriptRaceShutdown()
{
    CRaceTimes::Shutdown();
}

void CommandScriptRacePlayerHitCheckpoint(s32 pedIndex, s32 checkpoint, s32 lap, s32 time)
{
    CRaceTimes::CheckpointHit(pedIndex, checkpoint, lap, time);
}

bool CommandScriptRaceGetPlayerSplitTime(s32 pedIndex, s32& time, s32& position)
{
    return CRaceTimes::GetPlayerTime(pedIndex, time, position);
}


void CommandStartEndUserBenchmark()
{
#if COLLECT_END_USER_BENCHMARKS
	EndUserBenchmarks::StartBenchmark();
#endif
}

void CommandStopEndUserBenchmark()
{
#if COLLECT_END_USER_BENCHMARKS
	EndUserBenchmarks::StopBenchmark();
#endif
}

void CommandResetEndUserBenchmarks()
{
#if COLLECT_END_USER_BENCHMARKS
	scriptDebugf1("%s : RESET_END_USER_BENCHMARK", CTheScripts::GetCurrentScriptNameAndProgramCounter());
	EndUserBenchmarks::ResetBenchmarks();
#endif
}

void CommandSaveEndUserBenchmarks()
{
#if COLLECT_END_USER_BENCHMARKS
	EndUserBenchmarks::OutputBenchmarkResults();
#endif
}

bool CommandDidUIStartEndUserBenchmarks()
{
#if COLLECT_END_USER_BENCHMARKS
	return EndUserBenchmarks::GetWasStartedFromPauseMenu(FE_MENU_VERSION_SP_PAUSE);
#else
	return false;
#endif
}

bool CommandDidLandingScreenStartEndUserBenchmarks()
{
#if COLLECT_END_USER_BENCHMARKS
	return EndUserBenchmarks::GetWasStartedFromPauseMenu(FE_MENU_VERSION_LANDING_MENU);
#else
	return false;
#endif
}

bool CommandEndUserBenchmarkCommandline()
{
#if COLLECT_END_USER_BENCHMARKS
	return EndUserBenchmarks::GetWasBenchmarkOnCommandline();
#else
	return false;
#endif
}



s32 CommandGetBenchmarkIterationCount()
{
#if COLLECT_END_USER_BENCHMARKS
	return EndUserBenchmarks::GetIterationCount();
#else
	return -1;
#endif
}

s32 CommandGetBenchmarkPassCount()
{
#if COLLECT_END_USER_BENCHMARKS
	return EndUserBenchmarks::GetSinglePassInfo();
#else
	return -1;
#endif
}



void CommandQuitGame()
{
#if RSG_PC
	CPauseMenu::SetGameWantsToExitToWindows(true);
	NetworkInterface::GetNetworkExitFlow().StartShutdownTasks();
#endif
}

void CommandRestartGame()
{
#if RSG_PC
	CPauseMenu::SetGameWantsToRestart(true); 
	NetworkInterface::GetNetworkExitFlow().StartShutdownTasks(); 
#endif
}

bool CommandHasAsyncInstallFinished()
{
    return CFileMgr::HasAsyncInstallFinished();
}

void CommandCleanupAsyncInstall()
{
    CFileMgr::CleanupAsyncInstall();
}

bool CommandPlmIsInConstrainedMode()
{
	return g_SysService.IsConstrained();
}

u32 CommandPlmGetConstrainedDurationMs()
{
	return g_SysService.GetConstrainedDurationMs();
}

void CommandSetPlayerIsInAnimalForm(bool bInAnimalForm)
{
	scriptDisplayf("SET_PLAYER_IS_IN_ANIMAL_FORM(%s) called by %s", bInAnimalForm?"true":"false", CTheScripts::GetCurrentScriptNameAndProgramCounter());
	CTheScripts::SetPlayerIsInAnimalForm(bInAnimalForm);
}

bool CommandGetPlayerIsInAnimalForm()
{
	return CTheScripts::GetPlayerIsInAnimalForm();
}

void CommandSetPlayerIsRepeatingAMission(bool bIsRepeatingAMission)
{
	CTheScripts::SetPlayerIsRepeatingAMission(bIsRepeatingAMission);
}

void CommandDisableScreenDimmingThisFrame()
{
	g_SysService.DisableScreenDimmingThisFrame();
}

int CommandGetLogFileNumber()
{
#if !__NO_OUTPUT
	return diagChannel::GetLogFileNumber();
#else
	return -1;
#endif
}

void CommandUseActiveCameraForTimeslicingCentre()
{
	CPedAILodManager::SetUseActiveCameraForTimeslicingCentre();
}

bool CommandIsSessionInitialized()
{
	return CGame::IsSessionInitialized();
}

#if GEN9_STANDALONE_ENABLED
int CommandGetChosenCriminalCareer()
{
	if (!uiVerifyf(SCriminalCareerService::IsInstantiated(), "Criminal Career has not been instantiated, returning default value"))
	{
		return CriminalCareerDefs::CareerIdentifier_None;
	}
	else
	{
		const CriminalCareerDefs::CareerIdentifier c_careerIdentifier = SCriminalCareerService::GetInstance().GetChosenCareerIdentifier();
		return c_careerIdentifier;
	}	
}

bool CommandHasFinalizedChosenCriminalCareer()
{
	if (!uiVerifyf(SCriminalCareerService::IsInstantiated(), "Criminal Career has not been instantiated"))
	{
		return false;
	}
	else
	{
		const bool c_isFinalized = SCriminalCareerService::GetInstance().IsShoppingCartFinalized();
		return c_isFinalized;
	}
}

int CommandGetChosenMpCharacterSlot()
{
	if (uiVerifyf(SCriminalCareerService::IsInstantiated(), "Criminal Career has not been instantiated, returning default value"))
	{
		const int c_chosenMpCharacterSlot = SCriminalCareerService::GetInstance().GetChosenMpCharacterSlot();
		return c_chosenMpCharacterSlot;	
	}
	else
	{
		return -1;
	}
}

void CommandResetChosenMpCharacterSlot()
{	
	if (uiVerifyf(SCriminalCareerService::IsInstantiated(), "Criminal Career has not been instantiated, cannot reset"))
	{
#if !__FINAL
		scrThread::PrePrintStackTrace();
#endif
		SCriminalCareerService::GetInstance().ResetChosenMpCharacterSlot();
	}
}

#endif // GEN9_STANDALONE_ENABLED

#if RSG_GEN9
static atHashMap<int, int> s_ContentIdIndices;

void CommandSetContentIdIndex(int hash, int index)
{
	s_ContentIdIndices.Insert(hash, index);
}

int CommandGetContentIdIndex(int hash)
{
	if (atHashMap<int, int>::Pair* found = s_ContentIdIndices.FindPair(hash))
	{
		return found->second;
	}

	return -1;
}
#else
static atMap<int, int> s_ContentIdIndices;

void CommandSetContentIdIndex(int hash, int index)
{
	s_ContentIdIndices.Insert(hash, index);
}

int CommandGetContentIdIndex(int hash)
{
	const int* contentIdIndex = s_ContentIdIndices.Access(hash);
	if (contentIdIndex)
	{
		return *contentIdIndex;
	}

	return -1;
}
#endif // RSG_GEN9

void SetupScriptCommands()
{
	SCR_REGISTER_UNUSED(GET_CURRENT_STACK_SIZE,0x9d05ca7eb03931e4, CommandGetCurrentStackSize );
	SCR_REGISTER_SECURE(GET_ALLOCATED_STACK_SIZE,0x02bff29a859c559b, GetAllocatedStackSize);
	SCR_REGISTER_SECURE(GET_NUMBER_OF_FREE_STACKS_OF_THIS_SIZE,0x1bb8523a8f665d3c, CommandGetNumberOfFreeStacksOfThisSize);

	SCR_REGISTER_SECURE(SET_RANDOM_SEED,0xab6792da769477ef, CommandSetRandomSeed);
	SCR_REGISTER_UNUSED(SET_RANDOM_MWC_SEED,0xb3ba759687828e96, CommandSetRandomMWCSeed);

	SCR_REGISTER_SECURE(SET_TIME_SCALE,0x434e3ae126ddc5b5, CommandSetTimeScale);
	SCR_REGISTER_SECURE(SET_MISSION_FLAG,0xbd1f51fb3fa2c6e4, CommandSetMissionFlag);
	SCR_REGISTER_SECURE(GET_MISSION_FLAG,0x969475fa6ab2673a, CommandGetMissionFlag);
	SCR_REGISTER_SECURE(SET_RANDOM_EVENT_FLAG,0xa560174a439e78f1, CommandSetRandomEventFlag);
	SCR_REGISTER_SECURE(GET_RANDOM_EVENT_FLAG,0xe3bbdb1c36703410, CommandGetRandomEventFlag);

	SCR_REGISTER_SECURE(GET_CONTENT_TO_LOAD,0x64ae4acd8b8abba0, CommandGetContentToLoad);

	SCR_REGISTER_SECURE(ACTIVITY_FEED_CREATE,0xf3f7ab8cb18f8672, CommandActivityFeedCreate);
	SCR_REGISTER_SECURE(ACTIVITY_FEED_ADD_SUBSTRING_TO_CAPTION,0x23790f9720c61a64, CommandActivityFeedAddSubStringToCaption);
	SCR_REGISTER_SECURE(ACTIVITY_FEED_ADD_LITERAL_SUBSTRING_TO_CAPTION,0x83016c761162c9b3, CommandActivityFeedAddLiteralSubStringToCaption);
	SCR_REGISTER_UNUSED(ACTIVITY_FEED_ADD_FLOAT_TO_CAPTION,0xcfb26410637d79ca, CommandActivityFeedAddFloatToCaption);
	SCR_REGISTER_SECURE(ACTIVITY_FEED_ADD_INT_TO_CAPTION,0x382b4843eeac4bee, CommandActivityFeedAddIntToCaption);
	SCR_REGISTER_UNUSED(ACTIVITY_FEED_SMALL_IMAGE_URL,0x4c2138ed18b7ddaa, CommandActivityFeedSmallImageURL);
	SCR_REGISTER_SECURE(ACTIVITY_FEED_LARGE_IMAGE_URL,0x2cab098edb97dc42, CommandActivityFeedLargeImageURL);
	SCR_REGISTER_UNUSED(ACTIVITY_FEED_VIDEO_URL,0xa4bfbde5d14a04b5, CommandActivityFeedVideoURL);
	SCR_REGISTER_UNUSED(ACTIVITY_FEED_POST_CUSTOM_STORY,0xc4d9429bf312e605, CommandActivityFeedPostCustomStory);
	SCR_REGISTER_UNUSED(ACTIVITY_FEED_ACTION_URL,0x033f22cad386d2d9, CommandActivityFeedActionURL);
	SCR_REGISTER_UNUSED(ACTIVITY_FEED_ACTION_URL_WITH_THUMBNAIL,0xae452dbe980adcfb, CommandActivityFeedActionURLWithThumbnail);
	SCR_REGISTER_UNUSED(ACTIVITY_FEED_ACTION_URL_ADD,0x4a8874357028cab0, CommandActivityFeedActionURLAdd);
	SCR_REGISTER_SECURE(ACTIVITY_FEED_ACTION_START_WITH_COMMAND_LINE,0x56740f9b3cf5c107, CommandActivityFeedActionStart);
	SCR_REGISTER_UNUSED(ACTIVITY_FEED_ACTION_START_WITH_COMMAND_LINE_WITH_THUMBNAIL,0xe15061aad60143bc, CommandActivityFeedActionStartWithThumbnail);
	SCR_REGISTER_SECURE(ACTIVITY_FEED_ACTION_START_WITH_COMMAND_LINE_ADD,0x66a8a07bdb4374ec, CommandActivityFeedActionStartAdd);
	SCR_REGISTER_UNUSED(ACTIVITY_FEED_ACTION_STORE,0xde7297e83b3c3198, CommandActivityFeedActionStore);
	SCR_REGISTER_UNUSED(ACTIVITY_FEED_ACTION_STORE_WITH_THUMBNAIL,0xebc2e94e7854050e, CommandActivityFeedActionStoreWithThumbnail);
	SCR_REGISTER_SECURE(ACTIVITY_FEED_POST,0xdc9fc08ce33c7a1c, CommandActivityFeedPost);
	SCR_REGISTER_SECURE(ACTIVITY_FEED_ONLINE_PLAYED_WITH_POST,0x8ae5e7c487444291, CommandActivityFeedOnlinePlayedWithPost);

	SCR_REGISTER_SECURE(HAS_RESUMED_FROM_SUSPEND,0xf4c7da2b4577a1a8, CommandHasResumedFromSuspend);

	SCR_REGISTER_SECURE(SET_SCRIPT_HIGH_PRIO,0xeeefcc23227a8148, CommandSetScriptHighPrio);

	SCR_REGISTER_SECURE(SET_THIS_IS_A_TRIGGER_SCRIPT,0x3e397aa8c35a7536, CommandSetThisIsATriggerScript);

	SCR_REGISTER_UNUSED(SET_MISSION_NAME_DISPLAY,0x75712baa1c868552, CommandSetMissionNameDisplay		);

	SCR_REGISTER_SECURE(INFORM_CODE_OF_CONTENT_ID_OF_CURRENT_UGC_MISSION,0x5878944a227f31f3, CommandInformCodeOfContentIDOfCurrentUGCMission);

	SCR_REGISTER_UNUSED(GET_BASE_ELEMENT_LOCATION_FROM_METADATA,0xa435716d942bc584, CommandGetBaseElementLocationFromMetadata);
	SCR_REGISTER_SECURE(GET_BASE_ELEMENT_LOCATION_FROM_METADATA_BLOCK,0x8fbc59b07727a89e, CommandGetBaseElementLocationFromMetadataBlock);

	// new weather commands
	SCR_REGISTER_SECURE(GET_PREV_WEATHER_TYPE_HASH_NAME,0x0831c76f5bf9595e, CommandGetPrevWeatherTypeHashName);
	SCR_REGISTER_SECURE(GET_NEXT_WEATHER_TYPE_HASH_NAME,0xb1d36fa656f76888, CommandGetNextWeatherTypeHashName);
	SCR_REGISTER_SECURE(IS_PREV_WEATHER_TYPE,0x410dfb50be272f58, CommandIsPrevWeatherType);
	SCR_REGISTER_SECURE(IS_NEXT_WEATHER_TYPE,0x6dcfe88f29c7556e, CommandIsNextWeatherType);
	SCR_REGISTER_SECURE(SET_WEATHER_TYPE_PERSIST,0xa32f818f9701571c, CommandSetWeatherTypePersist);
	SCR_REGISTER_SECURE(SET_WEATHER_TYPE_NOW_PERSIST,0x9cd86fac92dbe038, CommandSetWeatherTypeNowPersist);
	SCR_REGISTER_SECURE(SET_WEATHER_TYPE_NOW,0xfd366591424e7542, CommandSetWeatherTypeNow);
	SCR_REGISTER_SECURE(SET_WEATHER_TYPE_OVERTIME_PERSIST,0x95fc0d9ffa87229e, CommandSetWeatherTypeOvertimePersist);
	SCR_REGISTER_SECURE(SET_RANDOM_WEATHER_TYPE,0xe715ced9607d2ece, CommandSetRandomWeatherType);
	SCR_REGISTER_SECURE(CLEAR_WEATHER_TYPE_PERSIST,0xc4075f869bc19306, CommandClearWeatherTypePersist);
	SCR_REGISTER_SECURE(CLEAR_WEATHER_TYPE_NOW_PERSIST_NETWORK,0x18b8b239b6c992fe, CommandClearWeatherTypeNowPersistNetwork);
	SCR_REGISTER_SECURE(GET_CURR_WEATHER_STATE,0x234904ad6416665b, CommandGetWeatherState);
	SCR_REGISTER_SECURE(SET_CURR_WEATHER_STATE,0x325fe91915483aae, CommandSetWeatherState);


	// used to override the global weather setting for network games
	SCR_REGISTER_SECURE(SET_OVERRIDE_WEATHER,0x6964c8d9877ab910, CommandSetOverrideWeather);
	SCR_REGISTER_SECURE(SET_OVERRIDE_WEATHEREX,0xdb125694c9cda16b, CommandSetOverrideWeatherEx);
	SCR_REGISTER_SECURE(CLEAR_OVERRIDE_WEATHER,0x92af77f76753447a, CommandClearOverrideWeather);

	SCR_REGISTER_SECURE(WATER_OVERRIDE_SET_SHOREWAVEAMPLITUDE,0xb252b5efbe5eac46,		CommandSetOverrideShoreWaveAmplitude);
	SCR_REGISTER_SECURE(WATER_OVERRIDE_SET_SHOREWAVEMINAMPLITUDE,0x72fcb447b822ff47,	CommandSetOverrideShoreWaveMinAmplitude);
	SCR_REGISTER_SECURE(WATER_OVERRIDE_SET_SHOREWAVEMAXAMPLITUDE,0x86ede07c99406ba7,	CommandSetOverrideShoreWaveMaxAmplitude);
	SCR_REGISTER_SECURE(WATER_OVERRIDE_SET_OCEANNOISEMINAMPLITUDE,0xfea2c505215523d7,	CommandSetOverrideOceanNoiseMinAmplitude);
	SCR_REGISTER_SECURE(WATER_OVERRIDE_SET_OCEANWAVEAMPLITUDE,0x77048cb9a5fb0916,		CommandSetOverrideOceanWaveAmplitude);
	SCR_REGISTER_SECURE(WATER_OVERRIDE_SET_OCEANWAVEMINAMPLITUDE,0x09282630f7e20396,	CommandSetOverrideOceanWaveMinAmplitude);
	SCR_REGISTER_SECURE(WATER_OVERRIDE_SET_OCEANWAVEMAXAMPLITUDE,0x84cafc0a42fd76a0,	CommandSetOverrideOceanWaveMaxAmplitude);
	SCR_REGISTER_SECURE(WATER_OVERRIDE_SET_RIPPLEBUMPINESS,0x5aa6d432576df799,			CommandSetOverrideRippleBumpiness);
	SCR_REGISTER_SECURE(WATER_OVERRIDE_SET_RIPPLEMINBUMPINESS,0x1a821c0c65ec99af,		CommandSetOverrideRippleMinBumpiness);
	SCR_REGISTER_SECURE(WATER_OVERRIDE_SET_RIPPLEMAXBUMPINESS,0x8786d241002bc8d3,		CommandSetOverrideRippleMaxBumpiness);
	SCR_REGISTER_SECURE(WATER_OVERRIDE_SET_RIPPLEDISTURB,0x81a6481340f8990d,			CommandSetOverrideRippleDisturb);
	SCR_REGISTER_SECURE(WATER_OVERRIDE_SET_STRENGTH,0xd25cad13a0bd46c9,				CommandSetWaterOverrideStrength);
	SCR_REGISTER_SECURE(WATER_OVERRIDE_FADE_IN,0x5d5d57e564e3d07b,						CommandFadeInWaterOverrideOverTime);
	SCR_REGISTER_SECURE(WATER_OVERRIDE_FADE_OUT,0x871782f14f0d7b2d,					CommandFadeOutWaterOverrideOverTime);

	SCR_REGISTER_SECURE(SET_WIND,0xab0c65a9ad2e3cff, CommandSetWind);
	SCR_REGISTER_SECURE(SET_WIND_SPEED,0xc66ad89039f856e2, CommandSetWindSpeed);
	SCR_REGISTER_SECURE(GET_WIND_SPEED,0xeb79f8939f3e6872, CommandGetWindSpeed);
	SCR_REGISTER_UNUSED(GET_WIND_SPEED_MAX,0xe161612575d0216d, CommandGetWindSpeedMax);
	SCR_REGISTER_SECURE(SET_WIND_DIRECTION,0xfa33a321c7b93ced, CommandSetWindDirection);
	SCR_REGISTER_SECURE(GET_WIND_DIRECTION,0x140a8934a5733d96, CommandGetWindDirection);
	SCR_REGISTER_SECURE(SET_RAIN,0xbf9611f192a7c3eb, CommandSetRain);
	SCR_REGISTER_SECURE(GET_RAIN_LEVEL,0x63b191e910106864, CommandGetRainLevel);
	SCR_REGISTER_SECURE(SET_SNOW,0xe22e7b8fa0c9916a, CommandSetSnow);
	SCR_REGISTER_SECURE(GET_SNOW_LEVEL,0xb5e8a19e38498780, CommandGetSnowLevel);
	SCR_REGISTER_SECURE(FORCE_LIGHTNING_FLASH,0xd7c2019ec11e9a90, CommandForceLightningFlash);

	SCR_REGISTER_UNUSED(ADD_WIND_THERMAL,0x37201cd57a9b677f, CommandAddWindThermal);
	SCR_REGISTER_UNUSED(REMOVE_WIND_THERMAL,0x480dc99192605686, CommandRemoveWindThermal);

	SCR_REGISTER_SECURE(SET_CLOUD_SETTINGS_OVERRIDE,0xd6013c019f519e30,CommandCloudSettingsOverride);
	SCR_REGISTER_SECURE(PRELOAD_CLOUD_HAT,0x13f742409efb338e, CommandPreloadCloudHat);
	SCR_REGISTER_UNUSED(RELEASE_PRELOAD_CLOUD_HAT,0x30008e3f5eef01cf, CommandReleasePreloadCloudHat);
	SCR_REGISTER_SECURE(LOAD_CLOUD_HAT,0x52e423fd38f601b9, CommandLoadCloudHat);
	SCR_REGISTER_SECURE(UNLOAD_CLOUD_HAT,0xc6d4125eb3ef156d, CommandUnloadCloudHat);
	SCR_REGISTER_SECURE(UNLOAD_ALL_CLOUD_HATS,0x967d9549339d0a5b, CommandUnloadAllCloudHats);
	
	SCR_REGISTER_SECURE(SET_CLOUDS_ALPHA,0xee1c00f3473ac995, CommandSetCloudHatAlpha);
	SCR_REGISTER_UNUSED(RESET_CLOUDS_ALPHA,0x8aec426542aa2bd9, CommandResetCloudHatAlpha);
	SCR_REGISTER_SECURE(GET_CLOUDS_ALPHA,0xd69743921ab3f0f1, CommandGetCloudHatAlpha);

	SCR_REGISTER_SECURE(GET_GAME_TIMER,0x320d1840b6daa1cc, CommandGetGameTimer);
	SCR_REGISTER_UNUSED(GET_NUMBER_OF_MICROSECONDS_SINCE_LAST_CALL,0x2250f0db2ed78dee, CommandGetNumberOfMicrosecondsSinceLastCall);
	SCR_REGISTER_UNUSED(GET_SCRIPT_TIME_WITHIN_FRAME_IN_MICROSECONDS,0x165e83a234816d0b, CommandGetScriptTimeWithinFrameInMicroseconds);
	SCR_REGISTER_UNUSED(RESET_SCRIPT_TIME_WITHIN_FRAME,0x47649a42d455d975, CommandResetScriptTimeWithinFrame);
	SCR_REGISTER_SECURE(GET_FRAME_TIME,0x51109c28352ec9a3, CommandGetFrameTime);
	SCR_REGISTER_SECURE(GET_SYSTEM_TIME_STEP,0x74aa3c129f86fc2d, CommandGetSystemTimeStep);

	SCR_REGISTER_SECURE(GET_FRAME_COUNT,0x8142a6539ddc180f, CommandGetFrameCount);
	
	//Maths
	SCR_REGISTER_SECURE(GET_RANDOM_FLOAT_IN_RANGE,0xc4eab25a108c2429, CommandGenerateRandomFloatInRange);
	SCR_REGISTER_SECURE(GET_RANDOM_INT_IN_RANGE,0x5853b15f78e1a265, CommandGenerateRandomIntInRange);
	SCR_REGISTER_SECURE(GET_RANDOM_MWC_INT_IN_RANGE,0x95f3c8dae5a0339c, CommandGenerateRandomMWCIntInRange);

	SCR_REGISTER_SECURE(GET_GROUND_Z_FOR_3D_COORD,0x9cd4cbf2bbe10f00, CommandGetGroundZFor3dCoord);
	SCR_REGISTER_SECURE(GET_GROUND_Z_AND_NORMAL_FOR_3D_COORD,0x45d982dae0be3255, CommandGetGroundZAndNormalFor3dCoord);
	SCR_REGISTER_SECURE(GET_GROUND_Z_EXCLUDING_OBJECTS_FOR_3D_COORD,0x6d2d1393fa9794d3, CommandGetGroundZExcludeObjectsFor3dCoord);
	SCR_REGISTER_SECURE(ASIN,0xcd3c356ca8d8298c, CommandASin);
	SCR_REGISTER_SECURE(ACOS,0x12528dc2778cb217, CommandACos);
	SCR_REGISTER_SECURE(TAN,0x06a2016215b8e171, CommandTan);
	SCR_REGISTER_SECURE(ATAN,0xe391a81befb0f974, CommandATan);
	SCR_REGISTER_SECURE(ATAN2,0xc529d13129c03cf4, CommandATan2);
	SCR_REGISTER_SECURE(GET_DISTANCE_BETWEEN_COORDS,0x987a5f1e1a67e3c0, CommandGetDistanceBetweenCoords);
	SCR_REGISTER_SECURE(GET_ANGLE_BETWEEN_2D_VECTORS,0x952f3fa2e7880565, CommandGetAngleBetween2dVectors);
	SCR_REGISTER_SECURE(GET_HEADING_FROM_VECTOR_2D,0xd12efcab87804bed, CommandGetHeadingFromVector2d);
	SCR_REGISTER_SECURE(GET_RATIO_OF_CLOSEST_POINT_ON_LINE,0xd7500bc8646dab0d, CommandClosestTValueOnLine);
	SCR_REGISTER_SECURE(GET_CLOSEST_POINT_ON_LINE,0x291018e753a9a0ad, CommandClosestPointOnLine);
	SCR_REGISTER_SECURE(GET_LINE_PLANE_INTERSECTION,0xdfaf13813077792a, ComamndLineIntersectsPlane);
	SCR_REGISTER_SECURE(GET_POINT_AREA_OVERLAP,0xc25227ffc64097ff, CommandPointAreaOverlap);
	SCR_REGISTER_SECURE(SET_BIT,0xced9e32812d6c7c7, CommandSetBit);
	SCR_REGISTER_SECURE(CLEAR_BIT,0xb0550bc91b0159d6, CommandClearBit);
	SCR_REGISTER_SECURE(GET_HASH_KEY,0x2e87280918b16506, CommandGetHashKey);
	SCR_REGISTER_SECURE(SLERP_NEAR_QUATERNION,0x6d60832059befca5, CommandSlerpNearQuaternion); 

	//DEBUG event recording
	SCR_REGISTER_UNUSED(DEBUG_RECORD_START,0xa90d7a9390bd8f3d, DebugRecordStart);
	SCR_REGISTER_UNUSED(DEBUG_RECORD_END,0xabfed591ce971f84, DebugRecordEnd);
	SCR_REGISTER_UNUSED(DEBUG_RECORD_SAVE,0x8ff49609d8384b9b, DebugRecordSave);
	SCR_REGISTER_UNUSED(DEBUG_RECORD_THIS_ENTITY,0x391c5280f4245775, DebugRecordThisInst);
	SCR_REGISTER_UNUSED(DEBUG_RECORD_ENTITY,0x9a4ce63767c521ff, DebugRecordInst);
	SCR_REGISTER_UNUSED(DEBUG_RECORD_CLEAR_ENTITIES,0x23535bc7b0368aa6, DebugRecordClearInsts);
	SCR_REGISTER_UNUSED(DEBUG_RECORD_ALL_ENTITIES,0x897fa206c9849bbe, DebugRecordAllInsts);
	SCR_REGISTER_UNUSED(DEBUG_RECORD_STRING,0x541bf377d861ed23, DebugRecordRecordString);
	SCR_REGISTER_UNUSED(DEBUG_RECORD_ENTITY_STRING,0x26ec0a96a7d7fe0e, DebugRecordRecordInstString);
	SCR_REGISTER_UNUSED(DEBUG_RECORD_ENTITY_FLOAT,0x1060750a8d39db07, DebugRecordRecordInstFloat);
	SCR_REGISTER_UNUSED(DEBUG_RECORD_ENTITY_VECTOR,0x64fb1a2f3ad76350, DebugRecordRecordInstVector);
	SCR_REGISTER_UNUSED(DEBUG_RECORD_LINE,0x1a100e58fe8dabe2, DebugRecordSimpleLine);
	SCR_REGISTER_UNUSED(DEBUG_RECORD_SPHERE,0x1f41e39434616104, DebugRecordSimpleSphere);
	SCR_REGISTER_UNUSED(DEBUG_RECORD_ENTITY_LINE,0xccc1adde87802277, DebugRecordInstLine);
	SCR_REGISTER_UNUSED(DEBUG_RECORD_ENTITY_SPHERE,0x1f47c1a96eae8796, DebugRecordInstSphere);

	//Area
	SCR_REGISTER_SECURE(IS_AREA_OCCUPIED,0x15c2370f75b1b388, CommandIsAreaOccupied);
	SCR_REGISTER_SECURE(IS_AREA_OCCUPIED_SLOW,0x6ea66e1eac07ca8c, CommandIsAreaOccupiedAccurate);
	SCR_REGISTER_SECURE(IS_POSITION_OCCUPIED,0x90bd7eb173e1cfd6, CommandIsPositionOccupied);
	SCR_REGISTER_SECURE(IS_POINT_OBSCURED_BY_A_MISSION_ENTITY,0x488e34a772939b4c, CommandIsPointObscuredByAMissionEntity);
	SCR_REGISTER_SECURE(CLEAR_AREA,0x7a997a0a971d305f, CommandClearArea);
	SCR_REGISTER_SECURE(CLEAR_AREA_LEAVE_VEHICLE_HEALTH,0xd414399d29212438, CommandClearAreaLeaveVehicleHealth );
	SCR_REGISTER_SECURE(CLEAR_AREA_OF_VEHICLES,0x02b222eadc9dc566, CommandClearAreaOfVehicles);
	SCR_REGISTER_SECURE(CLEAR_ANGLED_AREA_OF_VEHICLES,0x17b104183e0f2c46, CommandClearAngledAreaOfVehicles);
	SCR_REGISTER_SECURE(CLEAR_AREA_OF_OBJECTS,0xdc226c748c3c868d, CommandClearAreaOfObjects);
	SCR_REGISTER_SECURE(CLEAR_AREA_OF_PEDS,0xf96094a43d443c41, CommandClearAreaOfPeds);
	SCR_REGISTER_SECURE(CLEAR_AREA_OF_COPS,0xcb583354ea6e5e4a, CommandClearAreaOfCops);
	SCR_REGISTER_SECURE(CLEAR_AREA_OF_PROJECTILES,0x917f631782a9cb32, CommandClearAreaOfProjectiles);
	SCR_REGISTER_SECURE(CLEAR_SCENARIO_SPAWN_HISTORY,0x49bd8a3aec4c4cf4, CommandClearScenarioSpawnHistory);
	SCR_REGISTER_SECURE(SET_SAVE_MENU_ACTIVE,0xe708f785c0b6cb98, CommandActivateSaveMenu);
	SCR_REGISTER_SECURE(GET_STATUS_OF_MANUAL_SAVE,0x889492759cde5b07, CommandGetStatusOfManualSave);
	SCR_REGISTER_UNUSED(DID_SAVE_COMPLETE_SUCCESSFULLY,0x05706e34f1c87047, CommandDidSaveCompleteSuccessfully);
	SCR_REGISTER_UNUSED(SET_NETWORK_SETTINGS_MENU,0x257b7aefb66d58d2, CommandSetNetworkMenu);
	SCR_REGISTER_SECURE(SET_CREDITS_ACTIVE,0x291b578efc5bc622, CommandSetCreditsActive);
	SCR_REGISTER_SECURE(SET_CREDITS_FADE_OUT_WITH_SCREEN,0x4b980fe990fd29a0, CommandSetCreditsFadeOutWithScreen);
	SCR_REGISTER_SECURE(HAVE_CREDITS_REACHED_END,0xca215a1d7ffd35cc, CommandHaveCreditsReachedEnd);
	SCR_REGISTER_SECURE(ARE_CREDITS_RUNNING,0xa1cec49d70a8bf2c,CommandAreCreditsRunning);
	
	SCR_REGISTER_SECURE(TERMINATE_ALL_SCRIPTS_WITH_THIS_NAME,0xcb67cdee283e73dc, CommandTerminateAllScriptsWithThisName);
//	SCR_REGISTER_UNUSED(TERMINATE_ALL_SCRIPTS_FOR_NETWORK_GAME, 0x51c902bd, CommandTerminateAllScriptsForNetworkGame);
	SCR_REGISTER_SECURE(NETWORK_SET_SCRIPT_IS_SAFE_FOR_NETWORK_GAME,0x3f57bedbc381cbc7, CommandThisScriptIsSafeForNetworkGame);
	SCR_REGISTER_UNUSED(NETWORK_GET_IS_SCRIPT_SAFE_FOR_NETWORK_GAME,0xfadba653c265e78a, CommandGetIsScriptSafeForNetworkGame);
	SCR_REGISTER_UNUSED(SET_PLAYER_CONTROL_ON_IN_MISSION_CLEANUP,0x451a0065621843ce, CommandSetPlayerControlOnInMissionCleanup);

	SCR_REGISTER_SECURE(ADD_HOSPITAL_RESTART,0x6104d87e51533cf0, CommandAddHospitalRestart);
	SCR_REGISTER_SECURE(DISABLE_HOSPITAL_RESTART,0x582d074c5cdb512a, CommandDisableHospitalRestart);

	SCR_REGISTER_SECURE(ADD_POLICE_RESTART,0xd5c8a1f537cc13cd, CommandAddPoliceRestart);
	SCR_REGISTER_SECURE(DISABLE_POLICE_RESTART,0xcb7dbda526904496, CommandDisablePoliceRestart);

	SCR_REGISTER_SECURE(SET_RESTART_COORD_OVERRIDE,0x275e58a39347a249, CommandOverrideNextRestart);
	SCR_REGISTER_SECURE(CLEAR_RESTART_COORD_OVERRIDE,0x1b9c2beba596b762, CommandCancelOverrideRestart);
	SCR_REGISTER_SECURE(PAUSE_DEATH_ARREST_RESTART,0x3780e26e475691ed, CommandPauseDeathArrestRestart);
	SCR_REGISTER_SECURE(IGNORE_NEXT_RESTART,0x631794154765bf95, CommandIgnoreNextRestart);

	SCR_REGISTER_SECURE(SET_FADE_OUT_AFTER_DEATH,0xb607c92d60b318dd, CommandSetFadeOutAfterDeath);
	SCR_REGISTER_SECURE(SET_FADE_OUT_AFTER_ARREST,0x07fd15da380c8512, CommandSetFadeOutAfterArrest);
	SCR_REGISTER_SECURE(SET_FADE_IN_AFTER_DEATH_ARREST,0x3e49ef84c421e367, CommandSetFadeInAfterDeathArrest);
	SCR_REGISTER_SECURE(SET_FADE_IN_AFTER_LOAD,0x8eaab4c63946014a, CommandSetFadeInAfterLoad);
	SCR_REGISTER_SECURE(REGISTER_SAVE_HOUSE,0x1409c3f0480b1ae1, CommmandRegisterSaveHouse);
	SCR_REGISTER_SECURE(SET_SAVE_HOUSE,0x71c0ad6b706b0460, CommandEnableSaveHouse);
	SCR_REGISTER_SECURE(OVERRIDE_SAVE_HOUSE,0x6c3901dad6a66e9b, CommandOverrideSaveHouse);
	SCR_REGISTER_SECURE(GET_SAVE_HOUSE_DETAILS_AFTER_SUCCESSFUL_LOAD,0xbb3adc7c09e1a3fe, CommandGetSaveHouseDetailsAfterSuccessfulLoad);
	SCR_REGISTER_SECURE(DO_AUTO_SAVE,0x090f3b7471315852, CommandDoAutoSave);
	SCR_REGISTER_SECURE(GET_IS_AUTO_SAVE_OFF,0x1a02fc35b2cea0b1, CommandGetIsAutoSaveOff);
	SCR_REGISTER_UNUSED(GET_IS_DISPLAYING_SAVE_MESSAGE,0xb4b43085c1b27f3f, CommandGetIsDisplayingSaveMessage);
	SCR_REGISTER_SECURE(IS_AUTO_SAVE_IN_PROGRESS,0x07ad9e67f357c655, CommandIsAutoSaveInProgress);
	SCR_REGISTER_SECURE(HAS_CODE_REQUESTED_AUTOSAVE,0x07e4b614127ef0b9, CommandHasCodeRequestedAutosave);
	SCR_REGISTER_SECURE(CLEAR_CODE_REQUESTED_AUTOSAVE,0xc2d330547506b393, CommandClearCodeRequestedAutosave);

	SCR_REGISTER_SECURE(BEGIN_REPLAY_STATS,0x3e9c72be85529fca, CommandBeginReplayStats);
	SCR_REGISTER_SECURE(ADD_REPLAY_STAT_VALUE,0x0bc5939c2b796f37, CommandAddReplayStatValue);
	SCR_REGISTER_SECURE(END_REPLAY_STATS,0x7c6521e71e7516ff, CommandEndReplayStats);

	SCR_REGISTER_SECURE(HAVE_REPLAY_STATS_BEEN_STORED,0x816bb3ea7eff7ae0, CommandHaveReplayStatsBeenStored);
	SCR_REGISTER_SECURE(GET_REPLAY_STAT_MISSION_ID,0x9452928d5e202744, CommandGetReplayStatMissionId);
	SCR_REGISTER_SECURE(GET_REPLAY_STAT_MISSION_TYPE,0x239a5a4365d45418, CommandGetReplayStatMissionType);
	SCR_REGISTER_SECURE(GET_REPLAY_STAT_COUNT,0x40b3ae143c0ad363, CommandGetReplayStatCount);
	SCR_REGISTER_SECURE(GET_REPLAY_STAT_AT_INDEX,0x8ee1969ab2d0232f, CommandGetReplayStatAtIndex);
	SCR_REGISTER_SECURE(CLEAR_REPLAY_STATS,0x4a38a0835fed135b, CommandClearReplayStats);



	SCR_REGISTER_SECURE(QUEUE_MISSION_REPEAT_LOAD,0x70a108100ab45cd7, CommandQueueMissionRepeatLoad);
	SCR_REGISTER_UNUSED(GET_STATUS_OF_MISSION_REPEAT_LOAD,0xab63a5455a68d6c1, CommandGetStatusOfMissionRepeatLoad);
	SCR_REGISTER_UNUSED(CLEAR_STATUS_OF_MISSION_REPEAT_LOAD,0x0756649919c96d14, CommandClearStatusOfMissionRepeatLoad);

	SCR_REGISTER_SECURE(QUEUE_MISSION_REPEAT_SAVE,0x18e2479a36402e8d, CommandQueueMissionRepeatSave);
	SCR_REGISTER_SECURE(QUEUE_MISSION_REPEAT_SAVE_FOR_BENCHMARK_TEST,0xe799476ecf831fe3, CommandQueueMissionRepeatSaveForBenchmarkTest);
	SCR_REGISTER_SECURE(GET_STATUS_OF_MISSION_REPEAT_SAVE,0x0c76dfddcbb67a06, CommandGetStatusOfMissionRepeatSave);
	SCR_REGISTER_UNUSED(CLEAR_STATUS_OF_MISSION_REPEAT_SAVE,0xeb0b7f57c096cfde, CommandClearStatusOfMissionRepeatSave);
	
	SCR_REGISTER_UNUSED(CAN_START_MISSION_PASSED_TUNE,0xd4ca97b2ea1d6e7b, CommandCanStartMissionPassedTune);
	SCR_REGISTER_SECURE(IS_MEMORY_CARD_IN_USE,0x92b900558e4a1e49, CommandIsMemoryCardInUse);
	SCR_REGISTER_SECURE(SHOOT_SINGLE_BULLET_BETWEEN_COORDS,0xdb6ad61ce00e8a46, CommandFireSingleBullet);
	SCR_REGISTER_SECURE(SHOOT_SINGLE_BULLET_BETWEEN_COORDS_IGNORE_ENTITY,0x251885feebe139f2, CommandFireSingleBulletIgnoreEntity);
	SCR_REGISTER_SECURE(SHOOT_SINGLE_BULLET_BETWEEN_COORDS_IGNORE_ENTITY_NEW,0x633f41b5cea31cc2, CommandFireSingleBulletIgnoreEntityNew);
	SCR_REGISTER_SECURE(GET_MODEL_DIMENSIONS,0xb38ef75835faf667, CommandGetModelDimensions);
	SCR_REGISTER_SECURE(SET_FAKE_WANTED_LEVEL,0x30266329281c3a4f, CommandSetFakeWantedLevel);
	SCR_REGISTER_SECURE(GET_FAKE_WANTED_LEVEL,0xc1267d7e16e74496, CommandGetFakeWantedLevel);
	SCR_REGISTER_UNUSED(IS_BIT_SET,0xe2d0c323a1ae5d85, CommandIsBitSet);

	SCR_REGISTER_SECURE(USING_MISSION_CREATOR,0xed32721223814a05, CommandUsingMissionCreator);
	SCR_REGISTER_SECURE(ALLOW_MISSION_CREATOR_WARP,0x49e24542c726ebac, CommandAllowMissionCreatorWarp);
	SCR_REGISTER_SECURE(SET_MINIGAME_IN_PROGRESS,0x0d0b74b18bf93317, CommandSetMinigameInProgress);
	SCR_REGISTER_SECURE(IS_MINIGAME_IN_PROGRESS,0x410d46b709324b0f, CommandIsMinigameInProgress);
	SCR_REGISTER_SECURE(IS_THIS_A_MINIGAME_SCRIPT,0x4308664be93cb669, CommandIsThisAMinigameScript);
	SCR_REGISTER_SECURE(IS_SNIPER_INVERTED,0x8a6d972d3a2e44d7, CommandIsSniperInverted);
	SCR_REGISTER_SECURE(SHOULD_USE_METRIC_MEASUREMENTS,0x70350e94345b6f7b, CommandShouldUseMetricMeasurements);
	SCR_REGISTER_SECURE(GET_PROFILE_SETTING,0x5d851a9195129ce9, CommandGetProfileSetting);
	SCR_REGISTER_SECURE(ARE_STRINGS_EQUAL,0x3c57c2f07fee34d2, CommandAreStringsEqual);
	SCR_REGISTER_SECURE(COMPARE_STRINGS,0x1c1342f0adfea3b3, CommandCompareStrings);
	SCR_REGISTER_SECURE(ABSI,0x07141611fd632b59, AbsInt);
	SCR_REGISTER_SECURE(ABSF,0x48053974ed6f63ce, AbsFloat);
	SCR_REGISTER_SECURE(IS_SNIPER_BULLET_IN_AREA,0x42b9e261d7c3ebbf, CommandIsSniperBulletInArea);
	SCR_REGISTER_SECURE(IS_PROJECTILE_IN_AREA,0x863026e0c5c2e52b, CommandIsProjectileInArea);
	SCR_REGISTER_SECURE(IS_PROJECTILE_TYPE_IN_AREA,0xa1c6623fc1047dad, CommandIsProjectileTypeInArea);
	SCR_REGISTER_SECURE(IS_PROJECTILE_TYPE_IN_ANGLED_AREA,0x2767353d989432a3, CommandIsProjectileTypeInAngledArea);
	SCR_REGISTER_SECURE(IS_PROJECTILE_TYPE_WITHIN_DISTANCE,0xedf30c9168b336d8, CommandIsProjectileTypeWithinDistance);
	SCR_REGISTER_SECURE(GET_COORDS_OF_PROJECTILE_TYPE_IN_AREA,0x42b0867e406ec2ae, CommandGetCoordsOfProjectileTypeInArea);
	SCR_REGISTER_UNUSED(GET_COORDS_OF_PROJECTILE_TYPE_IN_ANGLED_AREA,0x0338ae308befb34d, CommandGetCoordsOfProjectileTypeInAngledArea);
	SCR_REGISTER_SECURE(GET_COORDS_OF_PROJECTILE_TYPE_WITHIN_DISTANCE,0xe3d651a33d0fad23, CommandGetCoordsOfProjectileTypeWithinDistance);
	SCR_REGISTER_SECURE(GET_PROJECTILE_OF_PROJECTILE_TYPE_WITHIN_DISTANCE,0x367885498c2037bd, CommandGetProjectileOfProjectileTypeWithinDistance);
	SCR_REGISTER_SECURE(IS_BULLET_IN_ANGLED_AREA,0x42d790a6634dc8dc, CommandIsBulletInAngledArea);
	SCR_REGISTER_SECURE(IS_BULLET_IN_AREA,0x9ac74c7ef847a074, CommandIsBulletInArea);
	SCR_REGISTER_SECURE(IS_BULLET_IN_BOX,0x4cb6acee3ea17cc9, CommandIsBulletInBox);
	SCR_REGISTER_SECURE(HAS_BULLET_IMPACTED_IN_AREA,0x81c70e8a536aac9e, CommandHasBulletImpactedInArea);
	SCR_REGISTER_SECURE(HAS_BULLET_IMPACTED_IN_BOX,0xc73d3966feed8c9c, CommandHasBulletImpactedInBox);
	SCR_REGISTER_UNUSED(HAS_BULLET_IMPACTED_BEHIND_PLANE,0xed02ab40f9b6feb6, CommandHasBulletImpactedBehindPlane);
	SCR_REGISTER_UNUSED(GET_NUM_BULLETS_IMPACTED_IN_BOX,0x2c800874540f4f3b, CommandGetNumBulletsImpactedInBox);
	SCR_REGISTER_UNUSED(GET_NUM_BULLETS_IMPACTED_IN_AREA,0x91d2f1868e0793c4, CommandGetNumBulletsImpactedInArea);

	SCR_REGISTER_UNUSED(GET_UNIQUE_MAP_VERSION,0x87c65863a6cb6f41, CommandGetUniqueMapVersion);
	SCR_REGISTER_SECURE(IS_ORBIS_VERSION,0xa7384dad7cf469da, CommandIsOrbisVersion);
	SCR_REGISTER_SECURE(IS_DURANGO_VERSION,0x3ebd3af4e5d7a08c, CommandIsDurangoVersion);
	SCR_REGISTER_SECURE(IS_XBOX360_VERSION,0xdfc67688f9088b45, CommandIsXbox360Version);
	SCR_REGISTER_SECURE(IS_PS3_VERSION,0x527312c0df85960a, CommandIsPS3Version);
	SCR_REGISTER_SECURE(IS_PC_VERSION,0x8fe9914d4872d601, CommandIsPCVersion);
	SCR_REGISTER_SECURE(IS_STEAM_VERSION,0x0a27b2b6282f7169, CommandIsSteamVersion);
	SCR_REGISTER_UNUSED(IS_GERMAN_VERSION,0x687c805ba078733c, CommandIsGermanVersion);
	SCR_REGISTER_SECURE(IS_AUSSIE_VERSION,0x86790e25cce58a5b, CommandIsAussieVersion);
	SCR_REGISTER_SECURE(IS_JAPANESE_VERSION,0xb8c0bb75d8a77db3, CommandIsJapaneseVersion);
	SCR_REGISTER_SECURE(IS_XBOX_PLATFORM, 0x138679ca01e21f53, CommandIsXboxPlatform);
	SCR_REGISTER_SECURE(IS_SCARLETT_VERSION, 0xc545ab1cf97abb34, CommandIsScarlettVersion);
	SCR_REGISTER_SECURE(IS_SCE_PLATFORM, 0xf911e695c1eb8518, CommandIsScePlatform);
	SCR_REGISTER_SECURE(IS_PROSPERO_VERSION, 0x807abe1ab65c24d2, CommandIsProsperoVersion);

	SCR_REGISTER_UNUSED(HAS_STORAGE_DEVICE_BEEN_SELECTED,0x26e19cb0038ed95f, CommandHasStorageDeviceBeenSelected);

	SCR_REGISTER_SECURE(IS_STRING_NULL,0xe8f6c1f695b25b91,	CommandIsStringNull);
	SCR_REGISTER_SECURE(IS_STRING_NULL_OR_EMPTY,0xacc32b78196fbc2a, CommandIsStringNullOrEmpty);
	SCR_REGISTER_SECURE(STRING_TO_INT,0xa8581fb9086c10c4,		CommandStringToInt);
	SCR_REGISTER_UNUSED(SET_PHONE_HUD_ITEM,0xcfcd18ca8fff8d7c, CommandSetPhoneHudItem);
	SCR_REGISTER_UNUSED(SET_OVERRIDE_NO_SPRINTING_ON_PHONE_IN_MULTIPLAYER,0xb6fab419baa3b5fa, CommandSetOverrideNoSprintingOnPhoneInMultiplayer);
	SCR_REGISTER_UNUSED(SET_MESSAGES_WAITING,0xe5b2167603650634, CommandSetMessagesWaiting);
	SCR_REGISTER_UNUSED(SET_SLEEP_MODE_ACTIVE,0x236d7f6c1691ef9b, CommandSetSleepModeActive);
	SCR_REGISTER_SECURE(SET_BITS_IN_RANGE,0x66daaa2eabb846b9, CommandSetBitsInRange);
	SCR_REGISTER_SECURE(GET_BITS_IN_RANGE,0xf6cf013e72c680b4, CommandGetBitsInRange);
	SCR_REGISTER_SECURE(ADD_STUNT_JUMP,0xe3e21255829bfa40, CommandAddStuntJump);
	SCR_REGISTER_SECURE(ADD_STUNT_JUMP_ANGLED,0x55b30d3eba45a1fa, CommandAddStuntJumpAngled);
	SCR_REGISTER_SECURE(TOGGLE_SHOW_OPTIONAL_STUNT_JUMP_CAMERA,0xc14f6902ae1a5e2a, CommandToggleShowOptionalStuntJumpCamera);
	SCR_REGISTER_SECURE(DELETE_STUNT_JUMP,0x2e1fd4291978441d, CommandDeleteStuntJump);
	SCR_REGISTER_SECURE(ENABLE_STUNT_JUMP_SET,0xe26992076b0111b4, CommandEnableStuntJumpSet);
	SCR_REGISTER_SECURE(DISABLE_STUNT_JUMP_SET,0x3a19907cc9850026, CommandDisableStuntJumpSet);
	SCR_REGISTER_SECURE(SET_STUNT_JUMPS_CAN_TRIGGER,0x97df6de511b1cc98, CommandAllowStuntJumpsToTrigger);
	SCR_REGISTER_SECURE(IS_STUNT_JUMP_IN_PROGRESS,0xbf6119a4ad89ef09, CommandIsStuntJumpInProgress);
	SCR_REGISTER_SECURE(IS_STUNT_JUMP_MESSAGE_SHOWING,0x70843a833fda0155, CommandIsStuntJumpMessageShowing);
	SCR_REGISTER_SECURE(GET_NUM_SUCCESSFUL_STUNT_JUMPS,0xc543ff0fe8bf24ac, CommandGetNumSuccessfulStuntJumps);
	SCR_REGISTER_SECURE(GET_TOTAL_SUCCESSFUL_STUNT_JUMPS,0x59de6e7fa1beff04, CommandGetTotalSuccessfulStuntJumps);
	SCR_REGISTER_SECURE(CANCEL_STUNT_JUMP,0x8a5171986f5357d4, CommandCancelStuntJump);
	SCR_REGISTER_SECURE(SET_GAME_PAUSED,0x27f66b7fe7db7c3a, CommandSetGamePaused);
	SCR_REGISTER_SECURE(SET_THIS_SCRIPT_CAN_BE_PAUSED,0x2c07cbafac54a645, CommandAllowThisScriptToBePaused);
	SCR_REGISTER_SECURE(SET_THIS_SCRIPT_CAN_REMOVE_BLIPS_CREATED_BY_ANY_SCRIPT,0xe2b3315f89fb203d, CommandSetThisScriptCanRemoveBlipsCreatedByAnyScript);
	SCR_REGISTER_UNUSED(CLEAR_NEWS_SCROLLBAR,0xf7af2da93489cc3e, CommandClearNewsScrollbar);
	SCR_REGISTER_UNUSED(ADD_STRING_TO_NEWS_SCROLLBAR,0x83982aa807758dad, CommandAddStringToNewsScrollbar);
	SCR_REGISTER_UNUSED(SET_CHEAT_ACTIVE,0xd41dbda3fabb3c5f, CommandActivateCheat);
	SCR_REGISTER_UNUSED(HAS_CHEAT_BEEN_ACTIVATED,0x5b4dd99aedcb74c9, CommandHasCheatBeenActivated);
	SCR_REGISTER_SECURE(HAS_CHEAT_WITH_HASH_BEEN_ACTIVATED,0x549ecfc9f246e127, CommandHasCheatWithHashBeenActivated);
	SCR_REGISTER_SECURE(HAS_PC_CHEAT_WITH_HASH_BEEN_ACTIVATED,0x21d2b24a19ad8996, CommandHasPcCheatWithHashBeeonActivated);
	SCR_REGISTER_SECURE(OVERRIDE_FREEZE_FLAGS,0xa404d3b3cbec1144, CommandOverrideFreezeFlags);

	SCR_REGISTER_UNUSED(SET_GLOBAL_INSTANCE_PRIORITY,0xfde10efcb8697073, CommandSetGlobalInstancePriority);
	SCR_REGISTER_UNUSED(SET_DEFAULT_GLOBAL_INSTANCE_PRIORITY,0xa2466e3a9ed547b7, CommandSetDefaultGlobalInstancePriority);
	SCR_REGISTER_SECURE(SET_INSTANCE_PRIORITY_MODE,0x0da2849a157f1c01, CommandSetInstancePriorityMode);
	SCR_REGISTER_SECURE(SET_INSTANCE_PRIORITY_HINT,0x9b8a09aad1cfefb3, CommandSetInstancePriorityHint);

	SCR_REGISTER_UNUSED(SET_XBOX_SCREEN_SAVER,0x34a435880aac72ce, CommandEnableXboxScreenSaver);
	SCR_REGISTER_SECURE(IS_FRONTEND_FADING,0x6304243969f5a11a, CommandIsFrontendFading);
	SCR_REGISTER_SECURE(POPULATE_NOW,0x466bf1f57ab05359, CommandPopulateNow);
	SCR_REGISTER_SECURE(GET_INDEX_OF_CURRENT_LEVEL,0x33d66016fe7b1f4c, CommandGetIndexOfCurrentLevel);
	SCR_REGISTER_UNUSED(SWITCH_TO_LEVEL,0x0d736c2a8021511c, CommandSwitchToLevel);
//	SCR_REGISTER_UNUSED(REGISTER_PERSISTENT_GLOBAL_VARIABLES, 0x42830d95, CommandRegisterPersistentGlobalVariables);
	SCR_REGISTER_SECURE(SET_GRAVITY_LEVEL,0x29f437c0738a11d6, CommandSetGravityLevel);

	SCR_REGISTER_SECURE(START_SAVE_DATA,0x6a3cf241a8e6bb10, CommandStartSaveData);
	SCR_REGISTER_SECURE(STOP_SAVE_DATA,0x6be88f905e2d4a46, CommandStopSaveData);
	SCR_REGISTER_SECURE(GET_SIZE_OF_SAVE_DATA,0xc42fc514879fbd37, CommandGetSizeOfSaveData);
	SCR_REGISTER_SECURE(REGISTER_INT_TO_SAVE,0x761051927661f94b, CommandRegisterIntToSave);
	SCR_REGISTER_SECURE(REGISTER_INT64_TO_SAVE,0x8ee599308657b2a9, CommandRegisterInt64ToSave);
	SCR_REGISTER_SECURE(REGISTER_ENUM_TO_SAVE,0x9702f50cca480d02, CommandRegisterEnumToSave);
	SCR_REGISTER_SECURE(REGISTER_FLOAT_TO_SAVE,0xd9ec39a4185f1a0f, CommandRegisterFloatToSave);
	SCR_REGISTER_SECURE(REGISTER_BOOL_TO_SAVE,0xf0d5ec209bfbceb4, CommandRegisterBoolToSave);
	SCR_REGISTER_SECURE(REGISTER_TEXT_LABEL_TO_SAVE,0x3f5eb2069155d1b2, CommandRegisterTextLabelToSave);
	SCR_REGISTER_UNUSED(REGISTER_TEXT_LABEL_3_TO_SAVE,0x3f0600d8ea048c7e, CommandRegisterTextLabel3ToSave);
	SCR_REGISTER_UNUSED(REGISTER_TEXT_LABEL_7_TO_SAVE,0x425c2a67015424cd, CommandRegisterTextLabel7ToSave);
	SCR_REGISTER_SECURE(REGISTER_TEXT_LABEL_15_TO_SAVE,0x4cf17ce9e4568a82, CommandRegisterTextLabel15ToSave);
	SCR_REGISTER_SECURE(REGISTER_TEXT_LABEL_23_TO_SAVE,0xd8129bfbc7574726, CommandRegisterTextLabel23ToSave);
	SCR_REGISTER_SECURE(REGISTER_TEXT_LABEL_31_TO_SAVE,0xb55ff6a2f8dcf841, CommandRegisterTextLabel31ToSave);
	SCR_REGISTER_SECURE(REGISTER_TEXT_LABEL_63_TO_SAVE,0x76c51166efaffcf8, CommandRegisterTextLabel63ToSave);
	SCR_REGISTER_SECURE(START_SAVE_STRUCT_WITH_SIZE,0x35ef5a3254a1ae34, CommandStartSaveStructWithSize);
	SCR_REGISTER_SECURE(STOP_SAVE_STRUCT,0xa78477896ddce3c5, CommandStopSaveStruct);
	SCR_REGISTER_SECURE(START_SAVE_ARRAY_WITH_SIZE,0xc6882a6353b4adb3, CommandStartSaveArrayWithSize);
	SCR_REGISTER_SECURE(STOP_SAVE_ARRAY,0xbda66a8b530a60ab, CommandStopSaveArray);
	
	SCR_REGISTER_SECURE(COPY_SCRIPT_STRUCT,0x049557638ade4df8, CommandCopyScriptStruct);

	SCR_REGISTER_SECURE(ENABLE_DISPATCH_SERVICE,0x07cecf421d895f3d, CommandEnableDispatchService);
	SCR_REGISTER_SECURE(BLOCK_DISPATCH_SERVICE_RESOURCE_CREATION,0x5258fce0ec176e04, CommandBlockDispatchServiceResourceCreation);
	SCR_REGISTER_SECURE(GET_NUMBER_RESOURCES_ALLOCATED_TO_WANTED_LEVEL,0x75eff7187a7d4dc4, CommandGetNumberResourcesAllocatedToWantedLevel);
	
	
	SCR_REGISTER_SECURE(CREATE_INCIDENT,0x302d843e3c8f40e2, CommandCreateIncident);
	SCR_REGISTER_SECURE(CREATE_INCIDENT_WITH_ENTITY,0x5d5732191056751c, CommandCreateIncidentWithEntity);
	SCR_REGISTER_SECURE(DELETE_INCIDENT,0xa4d968c5e2a5d0a0, CommandDeleteIncident);
	SCR_REGISTER_SECURE(IS_INCIDENT_VALID,0x99b99da99fb0d4ec, CommandIsIncidentValid);
	SCR_REGISTER_SECURE(SET_INCIDENT_REQUESTED_UNITS,0x337e4f61a2792efe, CommandSetIncidentRequestedUnits);
	SCR_REGISTER_SECURE(SET_IDEAL_SPAWN_DISTANCE_FOR_INCIDENT,0xb4ee171ee2b772bf, CommandSetIdealSpawnDistanceForIncident);

	SCR_REGISTER_SECURE(FIND_SPAWN_POINT_IN_DIRECTION,0xed142878c9f94e2f, CommandFindSpawnPointInDirection);

	SCR_REGISTER_SECURE(ADD_POP_MULTIPLIER_AREA,0x7cc9abaffea56277, CommandAddPopMultiplierArea);
	SCR_REGISTER_SECURE(DOES_POP_MULTIPLIER_AREA_EXIST,0x4b4bc360c6d8d2a4, CommandDoesPopMultiplierAreaExist);
	SCR_REGISTER_SECURE(REMOVE_POP_MULTIPLIER_AREA,0x79d94867e24afb8a, CommandRemovePopDensityMultiplierArea);
	SCR_REGISTER_SECURE(IS_POP_MULTIPLIER_AREA_NETWORKED,0x2ccebb043649a456, CommandIsPopDensityMultiplierAreaNetworked);
	

	SCR_REGISTER_SECURE(ADD_POP_MULTIPLIER_SPHERE,0x9c5e0d0887ecd76d, CommandAddPopMultiplierSphere);
	SCR_REGISTER_SECURE(DOES_POP_MULTIPLIER_SPHERE_EXIST,0x9638d57f9a8decf9, CommandDoesPopMultiplierSphereExist);
	SCR_REGISTER_SECURE(REMOVE_POP_MULTIPLIER_SPHERE,0xf63317d708095ce2, CommandRemovePopDensityMultiplierSphere);


	//Mini game support
	SCR_REGISTER_SECURE(ENABLE_TENNIS_MODE,0x6535edbe6f8dbb11, CommandEnableTennisMode);
	SCR_REGISTER_UNUSED(ENABLE_CLONE_OVERRIDE_TENNIS_MODE,0x88c77cbe7aeff1c0, CommandCloneOverrideTennisMode);
	SCR_REGISTER_SECURE(IS_TENNIS_MODE,0x4b383368dc8ccf38, CommandIsInTennisMode);	
	SCR_REGISTER_SECURE(PLAY_TENNIS_SWING_ANIM,0xa427179dc0581389, CommandPlayTennisSwingAnim);	
	SCR_REGISTER_UNUSED(SET_TENNIS_SWING_ANIM_PLAY_RATE,0xf654a9796bd73ae2, CommandSetTennisSwingAnimPlayRate);	
	SCR_REGISTER_SECURE(GET_TENNIS_SWING_ANIM_COMPLETE,0x75c0723cf45e484f, CommandGetTennisSwingAnimComplete);	
	SCR_REGISTER_SECURE(GET_TENNIS_SWING_ANIM_CAN_BE_INTERRUPTED,0x6460d686d9ea3ea9, CommandTennisSwingAnimCanBeInterrupted);	
	SCR_REGISTER_SECURE(GET_TENNIS_SWING_ANIM_SWUNG,0x061730bd8d533982, CommandTennisSwingAnimSwung);	
	SCR_REGISTER_UNUSED(SET_TENNIS_ALLOW_DAMPEN_STRAFE_DIRECTION,0x6903eb81d900e828, CommandSetTennisAllowDampenStrafeDirection);	
	SCR_REGISTER_SECURE(PLAY_TENNIS_DIVE_ANIM,0x08c0f779422456f1, CommandPlayTennisDiveAnim);	
	SCR_REGISTER_SECURE(SET_TENNIS_MOVE_NETWORK_SIGNAL_FLOAT,0x5f64484476f8387b, CommandSetTennisMoveNetworkSignalFloat);	
	
	//Dispatch
	SCR_REGISTER_SECURE(RESET_DISPATCH_SPAWN_LOCATION,0x9979f63cd1e2927a, CommandResetDispatchSpawnLocation);
	SCR_REGISTER_SECURE(SET_DISPATCH_SPAWN_LOCATION,0x1eea2d366d6c2406, CommandSetDispatchSpawnLocation);
	SCR_REGISTER_SECURE(RESET_DISPATCH_IDEAL_SPAWN_DISTANCE,0x34a2da203a9abc58, CommandResetDispatchIdealSpawnDistance);
	SCR_REGISTER_SECURE(SET_DISPATCH_IDEAL_SPAWN_DISTANCE,0xb0520b53aa49f54f, CommandSetDispatchIdealSpawnDistance);
	SCR_REGISTER_SECURE(RESET_DISPATCH_TIME_BETWEEN_SPAWN_ATTEMPTS,0x82ec6fa179cc6599, CommandResetDispatchTimeBetweenSpawnAttempts);
	SCR_REGISTER_SECURE(SET_DISPATCH_TIME_BETWEEN_SPAWN_ATTEMPTS,0xd1f5efbaf2ec7b47, CommandSetDispatchTimeBetweenSpawnAttempts);
	SCR_REGISTER_UNUSED(RESET_DISPATCH_TIME_BETWEEN_SPAWN_ATTEMPTS_MULTIPLIER,0xe6ab6f0e5e7e8f3d, CommandResetDispatchTimeBetweenSpawnAttemptsMultiplier);
	SCR_REGISTER_SECURE(SET_DISPATCH_TIME_BETWEEN_SPAWN_ATTEMPTS_MULTIPLIER,0x8df9d06d24867ef7, CommandSetDispatchTimeBetweenSpawnAttemptsMultiplier);
	SCR_REGISTER_SECURE(ADD_DISPATCH_SPAWN_ANGLED_BLOCKING_AREA,0x40b95e12f9a36a28, CommandAddDispatchSpawnAngledBlockingArea);
	SCR_REGISTER_SECURE(ADD_DISPATCH_SPAWN_SPHERE_BLOCKING_AREA,0x903a26ef102dab53, CommandAddDispatchSpawnSphereBlockingArea);
	SCR_REGISTER_SECURE(REMOVE_DISPATCH_SPAWN_BLOCKING_AREA,0xd41a5dca42ba8bdd, CommandRemoveDispatchSpawnBlockingArea);
	SCR_REGISTER_SECURE(RESET_DISPATCH_SPAWN_BLOCKING_AREAS,0x77be4f11ef7fc8c7, CommandResetDispatchSpawnBlockingAreas);

	//Wanted Response
	SCR_REGISTER_SECURE(RESET_WANTED_RESPONSE_NUM_PEDS_TO_SPAWN,0x777e9192665d1ca2, CommandResetWantedResponseNumPedsToSpawn);
	SCR_REGISTER_SECURE(SET_WANTED_RESPONSE_NUM_PEDS_TO_SPAWN,0x4f0c3dda5af5a24f, CommandSetWantedResponseNumPedsToSpawn);

	//Tactical Analysis
	SCR_REGISTER_SECURE(ADD_TACTICAL_NAV_MESH_POINT,0xac5d4c07ad99da31, CommandAddTacticalNavMeshPoint);
	SCR_REGISTER_SECURE(CLEAR_TACTICAL_NAV_MESH_POINTS,0x3cde5c5113b2a756, CommandClearTacticalNavMeshPoints);

	//Riot Mode
	SCR_REGISTER_SECURE(SET_RIOT_MODE_ENABLED,0xf542970145bc96b5, CommandSetRiotModeEnabled);

	//On-screen Keyboard Support
	SCR_REGISTER_SECURE(DISPLAY_ONSCREEN_KEYBOARD_WITH_LONGER_INITIAL_STRING,0x9f75296be5b9e406, CommandDisplayOnScreenKeyboardWithLongerInitialString);
	SCR_REGISTER_SECURE(DISPLAY_ONSCREEN_KEYBOARD,0xd36afc4a86165b46, CommandDisplayOnScreenKeyboard);
	SCR_REGISTER_SECURE(UPDATE_ONSCREEN_KEYBOARD,0x9417f1137725b4b3, CommandUpdateOnScreenKeyboard);
	SCR_REGISTER_SECURE(GET_ONSCREEN_KEYBOARD_RESULT,0xd0cd6f19a5cd39ec, CommandGetOnScreenKeyboardResult);
	SCR_REGISTER_SECURE(CANCEL_ONSCREEN_KEYBOARD,0xa4d40100016b1da1, CommandCancelOnScreenKeyboard);
	SCR_REGISTER_UNUSED(SET_ALLOW_TILDE_CHARACTER_FROM_ONSCREEN_KEYBOARD,0x27a5cdc282d09650, CommandSetAllowTildeCharacterFromOnScreenKeyboard);

	SCR_REGISTER_SECURE(NEXT_ONSCREEN_KEYBOARD_RESULT_WILL_DISPLAY_USING_THESE_FONTS,0xaebb4e3408e9c382, CommandNextOnScreenKeyboardResultWillDisplayUsingTheseFonts);

	// Action Manager
	SCR_REGISTER_SECURE(ACTION_MANAGER_ENABLE_ACTION,0x43efe7c11330165e, CommandEnableAction);
	SCR_REGISTER_UNUSED(ACTION_MANAGER_IS_ACTION_ENABLED,0xd12fee6181945623, CommandIsActionEnabled);


	SCR_REGISTER_SECURE(GET_REAL_WORLD_TIME,0x3f60413f5df65748, CommandGetRealWorldTime );

	//Random event
	SCR_REGISTER_SECURE(SUPRESS_RANDOM_EVENT_THIS_FRAME,0xbd9c95510c697303, CommandSetRandomEventEnabled );

	//Cheats
	SCR_REGISTER_SECURE(SET_EXPLOSIVE_AMMO_THIS_FRAME,0x582ef587cc7597ae, CommandSetExplosiveAmmoThisFrame );
	SCR_REGISTER_SECURE(SET_FIRE_AMMO_THIS_FRAME,0x7fe655ce221e741b, CommandSetFireAmmoThisFrame );
	SCR_REGISTER_SECURE(SET_EXPLOSIVE_MELEE_THIS_FRAME,0xc3562ba50c82388b, CommandSetExplosiveMeleeThisFrame );
	SCR_REGISTER_SECURE(SET_SUPER_JUMP_THIS_FRAME,0xa39a115964cb8d41, CommandSetSuperJumpThisFrame );
	SCR_REGISTER_UNUSED(GET_IS_SUPER_JUMP_ACTIVE,0x4859abb912d14d99, CommandGetIsSuperJumpActive );
	SCR_REGISTER_SECURE(SET_BEAST_JUMP_THIS_FRAME,0xf85eb82eef0fad32, CommandSetBeastJumpThisFrame );
	SCR_REGISTER_UNUSED(GET_IS_BEAST_JUMP_ACTIVE,0x172607fb83e84f65, CommandGetIsBeastJumpActive );

	SCR_REGISTER_SECURE(SET_FORCED_JUMP_THIS_FRAME,0xd097da9bfe7a2016, CommandSetForcedJumpThisFrame );

	SCR_REGISTER_UNUSED(WAIT_UNTIL_GAME_INSTALLED,0x7f60cd94039a85ea, CommandWaitUntilGameInstalled);
	SCR_REGISTER_SECURE(HAS_GAME_INSTALLED_THIS_SESSION,0x05c8821cd3e101ba, CommandHasGameInstalledThisSession);


	SCR_REGISTER_SECURE(SET_TICKER_JOHNMARSTON_IS_DONE,0x48d794795c819e09, CommandSetTickerJohnMarstonIsDone);
	SCR_REGISTER_SECURE(ARE_PROFILE_SETTINGS_VALID,0xb8f4926b803bfd19, CommandAreProfileSettingsValid);

	SCR_REGISTER_SECURE(PREVENT_ARREST_STATE_THIS_FRAME,0x1a4209996802ef21, CommandPreventArrestStateThisFrame);
	SCR_REGISTER_SECURE(FORCE_GAME_STATE_PLAYING,0x956030e0596c0f3e, CommandForceStatePlaying);

	SCR_REGISTER_SECURE(SCRIPT_RACE_INIT,0xb209dde44ec31285, CommandScriptRaceInit);
	SCR_REGISTER_SECURE(SCRIPT_RACE_SHUTDOWN,0x21177c558350f942, CommandScriptRaceShutdown);
	SCR_REGISTER_SECURE(SCRIPT_RACE_PLAYER_HIT_CHECKPOINT,0x8b131ad9ca84bce8, CommandScriptRacePlayerHitCheckpoint);
	SCR_REGISTER_SECURE(SCRIPT_RACE_GET_PLAYER_SPLIT_TIME,0xeb390afeb597210e, CommandScriptRaceGetPlayerSplitTime);

	// End User Benchmarks
	SCR_REGISTER_SECURE(START_END_USER_BENCHMARK,0xfdb4b0657fc92719, CommandStartEndUserBenchmark);
	SCR_REGISTER_SECURE(STOP_END_USER_BENCHMARK,0x125d159abd01a279, CommandStopEndUserBenchmark);
	SCR_REGISTER_SECURE(RESET_END_USER_BENCHMARK,0x16c1baaa79abea83, CommandResetEndUserBenchmarks);
	SCR_REGISTER_SECURE(SAVE_END_USER_BENCHMARK,0xd6cf1348fbd2f71a, CommandSaveEndUserBenchmarks);
	SCR_REGISTER_SECURE(UI_STARTED_END_USER_BENCHMARK,0xe76e60fda68de799, CommandDidUIStartEndUserBenchmarks);
	SCR_REGISTER_SECURE(LANDING_SCREEN_STARTED_END_USER_BENCHMARK,0xed419b5d18c4aa5a, CommandDidLandingScreenStartEndUserBenchmarks);
	SCR_REGISTER_SECURE(IS_COMMANDLINE_END_USER_BENCHMARK,0x22f20e950399daed, CommandEndUserBenchmarkCommandline);
	SCR_REGISTER_SECURE(GET_BENCHMARK_ITERATIONS,0xbeae7b00e881ae3e, CommandGetBenchmarkIterationCount);
	SCR_REGISTER_SECURE(GET_BENCHMARK_PASS,0xf6d0f47e80cff135, CommandGetBenchmarkPassCount);

	SCR_REGISTER_SECURE(RESTART_GAME,0xeba933b1a2380569, CommandRestartGame);
	SCR_REGISTER_SECURE(QUIT_GAME,0x315551089dac8c73, CommandQuitGame);

    SCR_REGISTER_SECURE(HAS_ASYNC_INSTALL_FINISHED,0xda2d2333ed6bb2c1, CommandHasAsyncInstallFinished);
    SCR_REGISTER_SECURE(CLEANUP_ASYNC_INSTALL,0xeac0d007daaa67a6, CommandCleanupAsyncInstall);

	// PLM (Process Lifetime Management)
	SCR_REGISTER_SECURE(PLM_IS_IN_CONSTRAINED_MODE,0xaf62a965ebf9946a, CommandPlmIsInConstrainedMode);
	SCR_REGISTER_SECURE(PLM_GET_CONSTRAINED_DURATION_MS,0xfe3098cc7933c733, CommandPlmGetConstrainedDurationMs);

	SCR_REGISTER_SECURE(SET_PLAYER_IS_IN_ANIMAL_FORM,0x608a0ddf19c87adf, CommandSetPlayerIsInAnimalForm);
	SCR_REGISTER_SECURE(GET_IS_PLAYER_IN_ANIMAL_FORM,0x80f6e0a3b422f9fd, CommandGetPlayerIsInAnimalForm);

	SCR_REGISTER_SECURE(SET_PLAYER_IS_REPEATING_A_MISSION,0x004d0da56b6ff87a, CommandSetPlayerIsRepeatingAMission);

	// Stop screen dimming.
	SCR_REGISTER_SECURE(DISABLE_SCREEN_DIMMING_THIS_FRAME,0x21c4591c6022e9f3, CommandDisableScreenDimmingThisFrame);

	// Log file
	SCR_REGISTER_UNUSED(GET_LOG_FILE_NUMBER,0x64eb00f8e968882d, CommandGetLogFileNumber);

	//Get The Density of the city
	SCR_REGISTER_SECURE(GET_CITY_DENSITY,0x5cc952a51a751c4c, CommandGetCityDensity);

	//Set anim timeslicing score centre to use the camera, rather than population centre
	SCR_REGISTER_SECURE(USE_ACTIVE_CAMERA_FOR_TIMESLICING_CENTRE,0x6a9ec5834979e98a, CommandUseActiveCameraForTimeslicingCentre);

	// script router navigation
#if GEN9_STANDALONE_ENABLED
	SCR_REGISTER_UNUSED(GET_SCRIPT_ROUTER_CONTEXT,0xd3b3a6d194fb6d3b, CommandGetScriptRouterContextData);
	SCR_REGISTER_UNUSED(SET_SCRIPT_ROUTER_LINK,0x5d22dae27ef205b3, CommandSetScriptRouterLink);
	SCR_REGISTER_UNUSED(GET_SCRIPT_ROUTER_LINK_HASH,0x8267ec27aa1bb696, CommandGetScriptRouterLinkHash);
	SCR_REGISTER_UNUSED(HAS_PENDING_SCRIPT_ROUTER_LINK,0x15aad97a998e81ba, CommandHasPendingScriptRouterLink);
	SCR_REGISTER_UNUSED(CLEAR_SCRIPT_ROUTER_LINK,0x63d53e11c1c1cce3, CommandClearScriptRouterLink);
	SCR_REGISTER_UNUSED(REPORT_INVALID_SCRIPT_ROUTER_ARGUMENT, 0x87acffe5c7610714, CommandReportInvalidScriptRouterArgument);

	SCR_REGISTER_UNUSED(SET_ACTIVITY_SCRIPT_ROUTING_ENABLED, 0xa4523cd8e76ff12d, CommandSetActivityScriptRoutingEnabled);
	SCR_REGISTER_UNUSED(IS_SESSION_INITIALIZED,0xd4073af8bf125a14, CommandIsSessionInitialized);
#endif

#if GEN9_STANDALONE_ENABLED
	SCR_REGISTER_UNUSED(GET_CHOSEN_CRIMINAL_CAREER,0x088de8e8e8f522dd, CommandGetChosenCriminalCareer);
	SCR_REGISTER_UNUSED(HAS_FINALIZED_CHOSEN_CRIMINAL_CAREER, 0x543cb61641ac456e, CommandHasFinalizedChosenCriminalCareer);
	SCR_REGISTER_UNUSED(GET_CHOSEN_MP_CHARACTER_SLOT,0xf7d89f7e3ff81e21, CommandGetChosenMpCharacterSlot);
	SCR_REGISTER_UNUSED(RESET_CHOSEN_MP_CHARACTER_SLOT, 0xff018aa297325503, CommandResetChosenMpCharacterSlot);
#endif // GEN9_STANDALONE_ENABLED

	SCR_REGISTER_SECURE(SET_CONTENT_ID_INDEX, 0x4b82fa6f2d624634, CommandSetContentIdIndex);
	SCR_REGISTER_SECURE(GET_CONTENT_ID_INDEX, 0xecf041186c5a94dc, CommandGetContentIdIndex);
}

}	//	end of namespace misc_commands