USING "cutscene_public.sch"
USING "replay_private.sch"
USING "vehicle_gen_public.sch"
USING "respawn_location_private.sch"

#IF IS_DEBUG_BUILD
	USING "debug_channels_structs.sch"
#ENDIF


// *****************************************************************************************
//
//		MISSION NAME	:	replay_public.sch
//		AUTHOR			:	Keith McLeman
//		MAINTAINED		:	Ben Rollinson
//						:	Andy Minghella
//		DESCRIPTION		:	Public Access to Replay functionality.
//
// *****************************************************************************************

/// PURPOSE:
///    Returns whether the player accepted the replay.
///    Should only be called after GET_MISSION_FLOW_SAFE_TO_CLEANUP has returned true.
/// RETURNS:
///    TRUE if the player accepted replay. FALSE otherwise.
FUNC BOOL HAS_PLAYER_ACCEPTED_REPLAY()
	IF g_replay.replayStageID = RS_ACCEPTING	
		RETURN TRUE
	ENDIF
	
	RETURN FALSE
ENDFUNC

/// PURPOSE:
///    Allows replay controller to tell mission scripts when it is safe to cleanup
/// RETURNS:
///    TRUE when it is safe to do the full cleanup. FALSE otherwise
FUNC BOOL GET_MISSION_FLOW_SAFE_TO_CLEANUP()
	IF g_bMagDemoActive
		RETURN TRUE // safe to do the full cleanup
	ENDIF

	IF g_replay.replayStageID = RS_ACCEPTING					 
	OR g_replay.replayStageID = RS_REJECTING
		RETURN TRUE // safe to do the full cleanup
	ENDIF

	// otherwise it is not safe to do the full cleanup
	RETURN FALSE
ENDFUNC

/// PURPOSE:
///    Checks if a replay is in progress
/// RETURNS:
///    BOOL		TRUE if a replay is in progress, otherwise FALSE
FUNC BOOL IS_REPLAY_IN_PROGRESS()
	IF g_replay.replayStageID = RS_ACTIVE
	OR g_replay.replayStageID = RS_ACTIVATE
		RETURN TRUE
	ENDIF
	
	RETURN FALSE
ENDFUNC

/// PURPOSE:
///    Checks if a replay is being processed.
///    Anywhere between mission failed and the replay starting / being declined.
///    NOTE: if this function is edited you will need to update PRIVATE_Is_Safe_To_Start_Communication()
/// RETURNS:
///    True if replay is being processed. False otherwise.
FUNC BOOL IS_REPLAY_BEING_PROCESSED()
	IF g_replay.replayStageID = RS_NOT_REQUIRED
	OR g_replay.replayStageID = RS_ACTIVE
	OR g_replay.replayStageID = RS_REJECTED
	OR g_replay.replayStageID = RS_NOT_RUNNING
		// either not processing replay screen, or we're currently on a replay
		RETURN FALSE 
	ENDIF
	#IF IS_DEBUG_BUILD
		IF g_replay.replayStageID =RS_WAITING_FOR_FLOW
			// or we're waiting for gameflow to setup (after a debug menu force cleanup)
			RETURN FALSE
		ENDIF
	#ENDIF
	
	RETURN TRUE // we are currently processing a replay
ENDFUNC	

// ===========================================================================================================
//		Replay Mid-Mission Stage Public Access Functions
// ===========================================================================================================

/// PURPOSE: Sets the mid-mission stage for the current mission and sets a debug name for stat tracking.
/// NOTES:	Only the current mission needs to know what this INT represents for that mission.
///    
/// PARAMS:
///    paramMidMissionStage - An INT (represents a mission-specific stage of a mission)
///    paramDebugName - A debug string that will be written into Metrics Zone and Smoketest results.
///    bFinalCheckpoint - Would skipping from this checkpoint end the mission? (used in shitskips)
///    bCanLowerCheckpoint - Is this checkpoint allowed to be lower then the previous checkpoint?
///    (This is only used if multiple checkpoints can be completed out of order)
///    (If you need to use this speak to Andy Minghella otherwise the game will assert)
///    mPedForVehicleSnapshot - use this if you need to store the vehicle info for any ped other than the current player ped (defaults to null, to use the current player ped)
PROC SET_REPLAY_MID_MISSION_STAGE_WITH_NAME(INT paramMidMissionStage, STRING paramDebugName, BOOL bFinalCheckpoint = FALSE, BOOL bCanLowerCheckpoint = FALSE, PED_INDEX mPedForVehicleSnapshot=NULL, BOOL bStoreCheckpointVehicle = TRUE)
	
	IF bCanLowerCheckpoint = TRUE
		#if not IS_DEBUG_BUILD
			IF NOT ARE_STRINGS_EQUAL("FinaleC2", GET_THIS_SCRIPT_NAME())
				CPRINTLN(DEBUG_REPLAY,"Script is force lowering replay checkpoint, bug for Andy Minghella. script= ", GET_THIS_SCRIPT_NAME())
				SCRIPT_ASSERT("Script is force lowering replay checkpoint, bug for Andy Minghella.")
			ENDIF
		#endif
	ENDIF
	
	BOOL bNewCheckpoint = FALSE
	
	IF bCanLowerCheckpoint = TRUE
		//special case mission that can lower checkpoint
		// store new checkpoint if the checkpoint number is different to stored
		IF paramMidMissionStage <> g_replayMissionStage
			bNewCheckpoint = TRUE
		ENDIF
	ELSE
	 	// normal mission, only store checkpoint if new checkpoint number is higher than stored one
		IF paramMidMissionStage > g_replayMissionStage
			bNewCheckpoint = TRUE
		ENDIF
	ENDIF
	
	// only update snapshot etc if this is a new mission stage
	IF bNewCheckpoint = TRUE
		CPRINTLN(DEBUG_REPLAY, GET_THIS_SCRIPT_NAME(), " has set Mid-Mission replay stage to: ", paramMidMissionStage)
		CPRINTLN(DEBUG_REPLAY,"replayStageReadOnly was previously ", g_replay.replayStageReadOnly)
		CPRINTLN(DEBUG_REPLAY,"g_replayMissionStage was previously ", g_replayMissionStage)

		COPY_BANK_TRANSLOGS() 

		IF paramMidMissionStage <= g_replayMissionStage
			CPRINTLN(DEBUG_REPLAY,"bCanLowerCheckpoint being used ")
		ENDIF
	
		// --------shitskip---------------------------
		//Update mission fails without progress if this is a story mission.
		SP_MISSIONS eMissionID = GET_SP_MISSION_ID_FOR_SCRIPT_NAME(GET_THIS_SCRIPT_NAME(), TRUE)
		
		#if USE_CLF_DLC
			IF eMissionID != SP_MISSION_NONE AND eMissionID != SP_MISSION_MAX_CLF
				g_savedGlobalsClifford.sFlow.missionSavedData[eMissionID].missionFailsNoProgress = 0
				
				// Tell the playstats system this story mission has hit a checkpoint.
				INT iVariation = GET_MISSION_VARIATION(eMissionID)
				TEXT_LABEL_7 txtStatID = g_sMissionStaticData[eMissionID].statID
				
				PLAYSTATS_MISSION_CHECKPOINT(txtStatID, iVariation, g_replayMissionStage, paramMidMissionStage)
				CDEBUG1LN(DEBUG_FLOW, "Flagging playstat MISSION CHECKPOINT for story mission. MissionID:", txtStatID, " Variation:", iVariation, " Checkpoint:", paramMidMissionStage)
			endif
		#endif
		#if USE_NRM_DLC
			IF eMissionID != SP_MISSION_NONE AND eMissionID != SP_MISSION_MAX_NRM
				g_savedGlobalsnorman.sFlow.missionSavedData[eMissionID].missionFailsNoProgress = 0
				
				// Tell the playstats system this story mission has hit a checkpoint.
				INT iVariation = GET_MISSION_VARIATION(eMissionID)
				TEXT_LABEL_7 txtStatID = g_sMissionStaticData[eMissionID].statID
				
				PLAYSTATS_MISSION_CHECKPOINT(txtStatID, iVariation, g_replayMissionStage, paramMidMissionStage)
				CDEBUG1LN(DEBUG_FLOW, "Flagging playstat MISSION CHECKPOINT for story mission. MissionID:", txtStatID, " Variation:", iVariation, " Checkpoint:", paramMidMissionStage)
			endif
		#endif
		
		#if not USE_CLF_DLC
		#if not USE_NRM_DLC
			IF eMissionID != SP_MISSION_NONE AND eMissionID != SP_MISSION_MAX
				g_savedGlobals.sFlow.missionSavedData[eMissionID].missionFailsNoProgress = 0
				
				// Tell the playstats system this story mission has hit a checkpoint.
				INT iVariation = GET_MISSION_VARIATION(eMissionID)
				TEXT_LABEL_7 txtStatID = g_sMissionStaticData[eMissionID].statID
				IF eMissionID = SP_HEIST_JEWELRY_2
					SWITCH g_savedGlobals.sFlow.controls.intIDs[FLOWINT_HEIST_CHOICE_JEWEL]
						CASE HEIST_CHOICE_JEWEL_STEALTH			txtStatID += "A"	BREAK
						CASE HEIST_CHOICE_JEWEL_HIGH_IMPACT		txtStatID += "B"	BREAK
					ENDSWITCH
				ENDIF
				PLAYSTATS_MISSION_CHECKPOINT(txtStatID, iVariation, g_replayMissionStage, paramMidMissionStage)
				CDEBUG1LN(DEBUG_FLOW, "Flagging playstat MISSION CHECKPOINT for story mission. MissionID:", txtStatID, " Variation:", iVariation, " Checkpoint:", paramMidMissionStage)
			ELSE
				// not a story mission, see if its an RC that uses shitskips
				g_eRC_MissionIDs eRCMissionID = Get_RC_MissionID_For_Script(GET_THIS_SCRIPT_NAME(), TRUE)
				IF eRCMissionID <> NO_RC_MISSION
			 		g_savedGlobals.sRandomChars.savedRC[eRCMissionID].iFailsNoProgress = 0
					
					// Tell the playstats system this story mission has hit a checkpoint.
					TEXT_LABEL tStatLabel = GET_RC_STAT_ID(eRCMissionID)
					PLAYSTATS_MISSION_CHECKPOINT(tStatLabel, 0, g_replayMissionStage, paramMidMissionStage)
					CDEBUG1LN(DEBUG_FLOW, "Flagging playstat MISSION CHECKPOINT for RC mission. Script:", GET_THIS_SCRIPT_NAME(), " Variation:", 0, " Checkpoint:", paramMidMissionStage, " RC  statID = ", tStatLabel)
				ELSE
					// check if this is a bailbond mission
					INT iBailBond
					iBailBond = GET_BAIL_BOND_MISSION_FROM_SCRIPT(g_replay.replayScriptName) 
					IF iBailBond >-1
						g_savedGlobals.sBailBondData.iFailsNoProgress[iBailBond] = 0
					ENDIF
				ENDIF
			ENDIF
		#endif
		#endif
		g_bShitskipToEnd = bFinalCheckpoint // if this is the final checkpoint, shitskipping from here would end the mission
		
		// --------------replay variables ------------------------------
		g_replayMissionStage = paramMidMissionStage
		Store_Game_State_Snapshot_For_Stage(paramMidMissionStage, paramDebugName, mPedForVehicleSnapshot, bStoreCheckpointVehicle)
		
		#IF IS_FINAL_BUILD
			//Keeps final build compiling.
			IF ARE_STRINGS_EQUAL(paramDebugName, "")
			ENDIF
		#ENDIF
	ELSE
		IF paramMidMissionStage < g_replayMissionStage
			CPRINTLN(DEBUG_REPLAY, GET_THIS_SCRIPT_NAME(), " tried to set Mid-Mission replay stage to a lower value: ", paramMidMissionStage)
			CPRINTLN(DEBUG_REPLAY,"g_replayMissionStage is currently ", g_replayMissionStage)
		ELSE
			CPRINTLN(DEBUG_REPLAY, GET_THIS_SCRIPT_NAME(), " tried to set Mid-Mission replay stage to its current value: ", paramMidMissionStage)
		ENDIF
	ENDIF
ENDPROC

/// PURPOSE:
///    Sets the mid-mission stage for the current mission.
///    NOTES:	Only the current mission needs to know what this INT represents for that mission.
///			It is the original version of this variable that gets written to by the mission. A copy of
///			this variable is read by the mission - this ensures that a mission being replayed has
///			access to a mid-mission stage value from the previous play of the mission that is in
///			no danger of being overwritten by the current replay of the mission.
/// PARAMS:
///    paramMidMissionStage - An INT (represents a mission-specific stage of a mission)
///    bFinalCheckpoint - Would skipping from this checkpoint end the mission? (used in shitskips)
PROC SET_REPLAY_MID_MISSION_STAGE(INT paramMidMissionStage, BOOL bFinalCheckpoint = FALSE)
	SET_REPLAY_MID_MISSION_STAGE_WITH_NAME(paramMidMissionStage, "NOT SET", bFinalCheckpoint)
ENDPROC

// PURPOSE:	Returns the mid-mission stage to the current mission.
// NOTES:	The meaning of this INT is known only to the mission being replayed.
//			It is a copy of the variable that gets returned to the mission. The original
//			can get written to while the mission is in progress so we use a read-only
//			copy to ensure the data doesn't get corrupted during a replay.
//
// RETURN VALUE:	INT		Replay Mid-Mission Stage
FUNC INT GET_REPLAY_MID_MISSION_STAGE()
	// Only a mission being replayed needs access to this variable - it means nothing to every other mission
	IF NOT (g_replay.replayStageID = RS_ACTIVE)
	AND NOT (g_replay.replayStageID = RS_ACTIVATE)
		CERRORLN(DEBUG_REPLAY, GET_THIS_SCRIPT_NAME(), " has requested access to the Mid-Mission Stage variable when not on a replay.")
		SCRIPT_ASSERT("Mid-Mission Replay Stage variable being requested when a replay is not active - Tell Andrew Minghella")
		RETURN 0
	ENDIF
	
	RETURN g_replay.replayStageReadOnly
ENDFUNC

/// PURPOSE:
///    Returns the vehicle index that was stored when the mission launched
///    (the index is the player's last vehicle if close enough to be stored)
/// RETURNS:
///    VEHICLE_INDEX of the vehicle the player triggered mission with
FUNC VEHICLE_INDEX GET_MISSION_START_VEHICLE_INDEX()
	RETURN g_startSnapshot.mVehicleIndex
ENDFUNC

/// PURPOSE:
///    Moves the mission start vehicle to position specified
/// PARAMS:
///    vPos - position to move it o
///    fHeading - new heading to use
PROC SET_POSITION_OF_MISSION_START_VEHICLE(VECTOR vPos, FLOAT fHeading)
	IF DOES_ENTITY_EXIST(g_startSnapshot.mVehicleIndex)
		IF IS_VEHICLE_DRIVEABLE(g_startSnapshot.mVehicleIndex)
			SET_ENTITY_COORDS(g_startSnapshot.mVehicleIndex, vPos)
			SET_ENTITY_HEADING(g_startSnapshot.mVehicleIndex, fHeading)
			SET_VEHICLE_ON_GROUND_PROPERLY(g_startSnapshot.mVehicleIndex)
		ENDIF
	ENDIF
ENDPROC

/// PURPOSE:
///    Sets the mission start vehicle as a car gen
/// PARAMS:
///    vPos = where to set the vehicle as a vehicle gen (if set to <<0.0,0.0,0.0>> it will use the vehicle's current pos and heading
///    fHeading: the heading to use when setting vehicle as a vehicle gen
///    bUseClosestSafehouse = would you like to set this vehicle as a vehicle gen at the nearest savehouse?
///    eCharacter = which character's savehouse would you like to use?
PROC SET_MISSION_START_VEHICLE_AS_VEHICLE_GEN(VECTOR vPos, FLOAT fHeading, BOOL bUseClosestSafehouse = FALSE, enumCharacterList eCharacter = NO_CHARACTER)
	
	//CPRINTLN(DEBUG_REPLAY, "SET_MISSION_START_VEHICLE_AS_VEHICLE_GEN called")
					
	IF DOES_ENTITY_EXIST(g_startSnapshot.mVehicleIndex)
		IF IS_VEHICLE_DRIVEABLE(g_startSnapshot.mVehicleIndex)
			IF GET_VEHICLE_GEN_VEHICLE_INDEX(VEHGEN_MISSION_VEH) != g_startSnapshot.mVehicleIndex
			
				// nearest savehouse?
				IF bUseClosestSafehouse = TRUE
					VECTOR vSafehousePos
					FLOAT fSavehouseHeading
					IF GET_CAR_RESPOT_POS_FOR_NEAREST_SAVEHOUSE(GET_ENTITY_COORDS(g_startSnapshot.mVehicleIndex), eCharacter, vSafehousePos, fSaveHouseHeading)
						// we found a safehouse, update pos and heading used
						vPos = vSafehousePos
						fHeading = fSavehouseHeading
						CPRINTLN(DEBUG_REPLAY, "SET_MISSION_START_VEHICLE_AS_VEHICLE_GEN got savehouse pos ", vPos, "  heading", fHeading)
					ELSE
						CPRINTLN(DEBUG_REPLAY, "SET_MISSION_START_VEHICLE_AS_VEHICLE_GEN failed to find nearest savehouse")
					ENDIF
				ENDIF
			
				SET_MISSION_VEHICLE_GEN_VEHICLE(g_startSnapshot.mVehicleIndex, vPos, fHeading)
				CPRINTLN(DEBUG_REPLAY, "SET_MISSION_START_VEHICLE_AS_VEHICLE_GEN using custom pos ", vPos, "  heading", fHeading)
			ELSE
				CPRINTLN(DEBUG_REPLAY, "SET_MISSION_START_VEHICLE_AS_VEHICLE_GEN vehicle is already vehicle gen")
			ENDIF
		ELSE
			CPRINTLN(DEBUG_REPLAY, "SET_MISSION_START_VEHICLE_AS_VEHICLE_GEN not driveable")
		ENDIF
	ELSE
		CPRINTLN(DEBUG_REPLAY, "SET_MISSION_START_VEHICLE_AS_VEHICLE_GEN doesn't exist")
	ENDIF
ENDPROC

/// PURPOSE:
///    Sets the current/last vehicle of the players as a car gen
/// PARAMS:
///    vPos = where to set the vehicle as a vehicle gen (if set to <<0.0,0.0,0.0>> it will use the vehicle's current pos and heading
///    fHeading: the heading to use when setting vehicle as a vehicle gen
///    bUseClosestSafehouse = would you like to set this vehicle as a vehicle gen at the nearest savehouse?
///    eCharacter = which character's savehouse would you like to use?
PROC SET_MISSION_LAST_VEHICLE_AS_VEHICLE_GEN(VECTOR vPos, FLOAT fHeading, BOOL bUseClosestSafehouse = FALSE, enumCharacterList eCharacter = NO_CHARACTER)
	
	//CPRINTLN(DEBUG_REPLAY, "SET_MISSION_LAST_VEHICLE_AS_VEHICLE_GEN called")
					
	IF DOES_ENTITY_EXIST(GET_PLAYERS_LAST_VEHICLE())
		IF IS_VEHICLE_DRIVEABLE(GET_PLAYERS_LAST_VEHICLE())
			IF GET_VEHICLE_GEN_VEHICLE_INDEX(VEHGEN_MISSION_VEH) != GET_PLAYERS_LAST_VEHICLE()
			
				// nearest savehouse?
				IF bUseClosestSafehouse = TRUE
					VECTOR vSafehousePos
					FLOAT fSavehouseHeading
					IF GET_CAR_RESPOT_POS_FOR_NEAREST_SAVEHOUSE(GET_ENTITY_COORDS(GET_PLAYERS_LAST_VEHICLE()), eCharacter, vSafehousePos, fSaveHouseHeading)
						// we found a safehouse, update pos and heading used
						vPos = vSafehousePos
						fHeading = fSavehouseHeading
						CPRINTLN(DEBUG_REPLAY, "SET_MISSION_LAST_VEHICLE_AS_VEHICLE_GEN got savehouse pos ", vPos, "  heading", fHeading)
					ELSE
						CPRINTLN(DEBUG_REPLAY, "SET_MISSION_LAST_VEHICLE_AS_VEHICLE_GEN failed to find nearest savehouse")
					ENDIF
				ENDIF
			
				SET_MISSION_VEHICLE_GEN_VEHICLE(GET_PLAYERS_LAST_VEHICLE(), vPos, fHeading)
				CPRINTLN(DEBUG_REPLAY, "SET_MISSION_LAST_VEHICLE_AS_VEHICLE_GEN using custom pos ", vPos, "  heading", fHeading)
			ELSE
				CPRINTLN(DEBUG_REPLAY, "SET_MISSION_LAST_VEHICLE_AS_VEHICLE_GEN vehicle is already vehicle gen")
			ENDIF
		ELSE
			CPRINTLN(DEBUG_REPLAY, "SET_MISSION_LAST_VEHICLE_AS_VEHICLE_GEN not driveable")
		ENDIF
	ELSE
		CPRINTLN(DEBUG_REPLAY, "SET_MISSION_LAST_VEHICLE_AS_VEHICLE_GEN doesn't exist")
	ENDIF
ENDPROC

/// PURPOSE:
///    Returns whether the start snapshot has a vehicle saved in it.
/// RETURNS:
///    True if the start snapshot has a vehicle saved in it
FUNC BOOL IS_REPLAY_START_VEHICLE_AVAILABLE()
	RETURN IsSnapshotVehicleAvailable(g_startSnapshot.mVehicleStruct)
ENDFUNC

/// PURPOSE:
///    Start loading the model for a replay start vehicle.
PROC REQUEST_REPLAY_START_VEHICLE_MODEL()
	RequestSnapshotVehicleModel(g_startSnapshot.mVehicleStruct)
ENDPROC

/// PURPOSE:
///    Check if a the model for a replay start vehicle is loaded.
/// RETURNS:
///    True if the model has loaded
FUNC BOOL HAS_REPLAY_START_VEHICLE_LOADED()
	RETURN HasSnapshotVehicleLoaded(g_startSnapshot.mVehicleStruct)
ENDFUNC

/// PURPOSE:
///    Returns the model of the replay start vehicle (stored in the mission start snapshot)
/// RETURNS:
///    MODEL_NAMES vehicle model stored in start snapshot or DUMMY_MODEL if there isn't one
FUNC MODEL_NAMES GET_REPLAY_START_VEHICLE_MODEL()
	RETURN g_startSnapshot.mVehicleStruct.mVehicle.eModel
ENDFUNC

/// PURPOSE:
///    Returns the model of the replay vehicle (stored in the mission stage snapshot)
/// RETURNS:
///     MODEL_NAMES vehicle model stored in stage snapshot or DUMMY_MODEL if there isn't one
FUNC MODEL_NAMES GET_REPLAY_CHECKPOINT_VEHICLE_MODEL()
	RETURN g_stageSnapshot.mVehicleStruct.mVehicle.eModel
ENDFUNC

/// PURPOSE:
///    Checks whether the model is under an allowed size
/// PARAMS:
///    vAllowableSize - how large the vehicle is allowed to be
///    bUseDefaultSize - just use the default size check? (ok for most average vehicles)
/// RETURNS:
///    TRUE if the vehicle is of allowable size. FALSE otherwise
FUNC BOOL IS_REPLAY_VEHICLE_MODEL_UNDER_SIZE_LIMIT(MODEL_NAMES eModel, VECTOR vAllowableSize, BOOL bUseDefaultSize = TRUE)
	VECTOR vVehicleSizeMin
	VECTOR vVehicleSizeMax	
	
	IF eModel = DUMMY_MODEL_FOR_SCRIPT
		RETURN FALSE // no vehicle available
	ENDIF
	
	// default allowable size
	IF bUseDefaultSize = TRUE
		vAllowableSize = GET_DEFAULT_ALLOWABLE_VEHICLE_SIZE_VECTOR()
	ENDIF	
	
	GET_MODEL_DIMENSIONS(eModel, vVehicleSizeMin, vVehicleSizeMax)
			
	IF vVehicleSizeMax.x - vVehicleSizeMin.x > vAllowableSize.x
		RETURN FALSE // vehicle too large
	ELIF vVehicleSizeMax.y - vVehicleSizeMin.y > vAllowableSize.y
		RETURN FALSE // vehicle too large
	ELIF vVehicleSizeMax.z - vVehicleSizeMin.z > vAllowableSize.z
		RETURN FALSE // vehicle too large
	ENDIF
	RETURN TRUE //  vehicle is under the size limit	
ENDFUNC

/// PURPOSE:
///    Checks whether the checkpoint vehicle is under an allowed size
/// PARAMS:
///    vAllowableSize - how large the vehicle is allowed to be
///    bUseDefaultSize - just use the default size check? (ok for most average vehicles)
/// RETURNS:
///    TRUE if the vehicle is of allowable size. FALSE otherwise
FUNC BOOL IS_REPLAY_CHECKPOINT_VEHICLE_UNDER_SIZE_LIMIT(VECTOR vAllowableSize, BOOL bUseDefaultSize = TRUE)
	RETURN IS_REPLAY_VEHICLE_MODEL_UNDER_SIZE_LIMIT(g_stageSnapshot.mVehicleStruct.mVehicle.eModel, vAllowableSize, bUseDefaultSize)
ENDFUNC

/// PURPOSE:
///    Checks whether the stored replay start vehicle is under an allowed size
/// PARAMS:
///    vAllowableSize - how large the vehicle is allowed to be
///    bUseDefaultSize - just use the default size check? (ok for most average vehicles)
/// RETURNS:
///    TRUE if the vehicle is of allowable size. FALSE otherwise
FUNC BOOL IS_REPLAY_START_VEHICLE_UNDER_SIZE_LIMIT(VECTOR vAllowableSize, BOOL bUseDefaultSize = TRUE)
	RETURN IS_REPLAY_VEHICLE_MODEL_UNDER_SIZE_LIMIT(g_startSnapshot.mVehicleStruct.mVehicle.eModel, vAllowableSize, bUseDefaultSize)
ENDFUNC

/// PURPOSE:
/// 	Checks if the stored replay start vehicle is a specific model. 
//		IS_REPLAY_START_VEHICLE_AVAILABLE() should be checked before attempting 
//		this query.
/// PARAMS:
///    paramVehicleModel - the model type we are checking against
/// RETURNS:
///    TRUE if the start replay vehicle is the model specified.
FUNC BOOL IS_REPLAY_START_VEHICLE_THIS_MODEL(MODEL_NAMES paramVehicleModel)
	RETURN IsSnapshotVehicleThisModel(g_startSnapshot, paramVehicleModel)
ENDFUNC

/// PURPOSE:
///   	Creates the replay vehicle saved for the start of the mission. 
//		IS_REPLAY_START_VEHICLE_AVAILABLE() should be checked before attempting to create 
//		a replay checkpoint vehicle. 
/// PARAMS:
///    paramCoords - where to create the replay vehicle (if <<0.0,0.0,0.0>> it is created at the co-ords from the snapshot)
///    paramHeading - the replay vehicle's heading
/// RETURNS:
///    The vehicle index of the replay vehicle
FUNC VEHICLE_INDEX CREATE_REPLAY_START_VEHICLE(VECTOR paramCoords, FLOAT paramHeading = 0.0)
	RETURN CreateSnapshotVehicle(g_startSnapshot.mVehicleStruct, paramCoords, paramHeading)
ENDFUNC

/// PURPOSE:
///    Returns whether the checkpoint snapshot has a vehicle saved in it.
/// RETURNS:
///    True if the checkpoint snapshot has a vehicle saved in it
FUNC BOOL IS_REPLAY_CHECKPOINT_VEHICLE_AVAILABLE()
	RETURN IsSnapshotVehicleAvailable(g_stageSnapshot.mVehicleStruct)
ENDFUNC

/// PURPOSE:
///    Allows the automatically stored replay checkpoint vehicle to be overriden by the mission
///    scripter.
PROC OVERRIDE_REPLAY_CHECKPOINT_VEHICLE(VEHICLE_INDEX paramVehicle)
	Store_Vehicle_Snapshot_For_Vehicle(g_stageSnapshot.mVehicleStruct, g_stageSnapshot, paramVehicle, TRUE)
ENDPROC

/// PURPOSE:
///    Returns which player character the vehicle snapshot was stored for
/// PARAMS:
///    bStartSnapshot - are we checking the start snapshot (if false it checks the stage snapshot)
/// RETURNS:
///    enumCharacterList the player character that the vehicle snapshot was stored for (or NO_CHARACTER)
FUNC enumCharacterList GET_REPLAY_VEHICLE_OWNER(BOOL bStartSnapshot)
	IF bStartSnapshot = TRUE
		RETURN g_startSnapshot.eVehicleOwner
	ELSE
		RETURN g_stageSnapshot.eVehicleOwner
	ENDIF
ENDFUNC

/// PURPOSE:
///    Start loading the model for a replay checkpoint vehicle.
PROC REQUEST_REPLAY_CHECKPOINT_VEHICLE_MODEL()
	RequestSnapshotVehicleModel(g_stageSnapshot.mVehicleStruct)
ENDPROC

/// PURPOSE:
///    Checks the model of the checkpoint vehicle and returns whether its suitable for a car chase
/// PARAMS:
///    bAllowHelis - Are helicopters allowed for this car chase?
///    bAllowCopCars - Are cop cars allowed for this car chase?
/// RETURNS:
///    TRUE if the vehicle is suitable for use in a car chase
FUNC BOOL IS_REPLAY_CHECKPOINT_VEHICLE_OK_FOR_CHASE()
	
	// no vehicle available
	IF NOT IS_REPLAY_CHECKPOINT_VEHICLE_AVAILABLE()
		RETURN FALSE 
	ENDIF
	
	// don't use boats, planes or trains
	IF IS_THIS_MODEL_A_BOAT(g_stageSnapshot.mVehicleStruct.mVehicle.eModel)
	OR IS_THIS_MODEL_A_PLANE(g_stageSnapshot.mVehicleStruct.mVehicle.eModel)
	OR IS_THIS_MODEL_A_TRAIN(g_stageSnapshot.mVehicleStruct.mVehicle.eModel)
		RETURN FALSE
	ENDIF
	
	// check that the vehicle is fast enough for use in car chase
	FLOAT fSpeed = GET_VEHICLE_MODEL_ESTIMATED_MAX_SPEED(g_stageSnapshot.mVehicleStruct.mVehicle.eModel)
	CPRINTLN(DEBUG_REPLAY, "Vehicle speed is: ", fSpeed, "Min for car chase is 37")
	IF fSpeed < 37.0
		RETURN FALSE
	ENDIF
	
	RETURN TRUE
ENDFUNC
/// PURPOSE:
///    Check if a the model for a replay checkpoint vehicle is loaded.
/// RETURNS:
///    True if the model has loaded
FUNC BOOL HAS_REPLAY_CHECKPOINT_VEHICLE_LOADED()
	RETURN HasSnapshotVehicleLoaded(g_stageSnapshot.mVehicleStruct)
ENDFUNC

/// PURPOSE:
/// 	Checks if the stored replay checkpoint vehicle is a specific model. 
//		IS_REPLAY_CHECKPOINT_VEHICLE_AVAILABLE() should be checked before attempting 
//		this query.
/// PARAMS:
///    paramVehicleModel - the model type we are checking against
/// RETURNS:
///    TRUE if the start replay vehicle is the model specified.
FUNC BOOL IS_REPLAY_CHECKPOINT_VEHICLE_THIS_MODEL(MODEL_NAMES paramVehicleModel)
	RETURN IsSnapshotVehicleThisModel(g_stageSnapshot, paramVehicleModel)
ENDFUNC

/// PURPOSE:
///   	Creates the replay vehicle saved for the checkpoint of the mission. 
//		IS_REPLAY_CHECKPOINT_VEHICLE_AVAILABLE() should be checked before attempting to create 
//		a replay checkpoint vehicle. 
/// PARAMS:
///    paramCoords - where to create the replay vehicle (if <<0.0,0.0,0.0>> it is created at the co-ords from the snapshot)
///    paramHeading - the replay vehicle's heading
/// RETURNS:
///    The vehicle index of the replay vehicle
FUNC VEHICLE_INDEX CREATE_REPLAY_CHECKPOINT_VEHICLE(VECTOR paramCoords, FLOAT paramHeading = 0.0)
	RETURN CreateSnapshotVehicle(g_stageSnapshot.mVehicleStruct, paramCoords, paramHeading)
ENDFUNC

/// PURPOSE: 
///    Returns the coords the player was standing at when they hit the last replay checkpoint.
/// RETURNS:
///    Vector: player co-ords at the last replay checkpoint
FUNC VECTOR GET_REPLAY_CHECKPOINT_PLAYER_POSITION()
	RETURN g_stageSnapshot.mPlayerStruct.vPos
ENDFUNC

/// PURPOSE: 
///    Returns the heading the player was facing when they hit the last replay checkpoint.
/// RETURNS:
///    Float: player heading at the last replay checkpoint
FUNC FLOAT GET_REPLAY_CHECKPOINT_PLAYER_HEADING()
	RETURN g_stageSnapshot.mPlayerStruct.fHeading
ENDFUNC

/// PURPOSE:
///    Called by launchers for missions that trigger by the player entering a vehicle
///    This stores the player's last vehicle instead of the mission trigger vehicle   
PROC STORE_START_PLAYER_VEHICLE_SNAPSHOT()
	Store_Vehicle_Snapshot_For_Last_Player_Vehicle(g_startSnapshot.mVehicleStruct, g_startSnapshot)
ENDPROC

/// PURPOSE:
///    Used to set where the player's vehicle will be recreated if he rejects a replay for this mission.
///    (This is only used if the player fails without being killed / arrested)
/// PARAMS:
///    vVehiclePos - where the respawn the player's vehicle
///    fVehicleHeading - the heading to use for the player's vehicle
PROC SET_REPLAY_DECLINED_VEHICLE_WARP_LOCATION(VECTOR vVehiclePos, FLOAT fVehicleHeading)
	Set_Vehicle_Snapshot_Pos(g_stageSnapshot.mVehicleStruct, vVehiclePos, fVehicleHeading)
ENDPROC

/// PURPOSE:
///    Checks if a replay is being processed for the RC mission specified
/// PARAMS:
///    eRCMissionID - the RC mission we are checking for
/// RETURNS:
///    TRUE if this RC mission is being processed for a replay.
#if not USE_CLF_DLC
#if not USE_NRM_DLC
FUNC BOOL IS_THIS_RC_MISSION_BEING_PROCESSED_FOR_REPLAY(g_eRC_MissionIDs eRCMissionID)
	IF IS_REPLAY_BEING_PROCESSED()
	AND g_replay.replayType = REPLAY_TYPE_RANDOM_CHARACTER
	AND eRCMissionID = Get_RC_MissionID_For_Script(g_replay.replayScriptName)
		RETURN TRUE
	ENDIF
	RETURN FALSE
ENDFUNC
#endif
#endif
/// PURPOSE:
///    Puts the player back in the clothes he started the mission in
PROC RESTORE_MISSION_START_OUTFIT()
	CPRINTLN(DEBUG_REPLAY, "Restoring start outfit for", GET_THIS_SCRIPT_NAME())
	Restore_Game_State_Snapshot_Clothes(g_startSnapshot)
	IF NOT IS_PED_INJURED(PLAYER_PED_ID())
		SET_PED_VARIATIONS(PLAYER_PED_ID(), g_sLastStoredPlayerPedClothes[GET_PLAYER_PED_ENUM(PLAYER_PED_ID())])
	ENDIF
ENDPROC

/// PURPOSE:
///    Returns which character the player was controlling when they launched this mission
///    This is the character they were when the mission start snapshot was taken 
FUNC enumCharacterList GET_PLAYER_CHARACTER_AT_MISSION_START() 
	RETURN g_startSnapshot.eCharacter
ENDFUNC

/// PURPOSE:
///    Returns whether the player was in a vehicle at his last checkpoint
/// RETURNS:
///    TRUE if he was in a vehicle at last checkpoint, otherwise returns FALSE
FUNC BOOL WAS_PLAYER_IN_VEHICLE_AT_CHECKPOINT()
	RETURN g_stageSnapshot.mVehicleStruct.bInVehicle
ENDFUNC

/// PURPOSE:
///    Returns whether the player was in a vehicle when he triggered the mission
/// RETURNS:
///    TRUE if he was in a vehicle when he triggered the mission, otherwise returns FALSE
FUNC BOOL WAS_PLAYER_IN_VEHICLE_AT_MISSION_START()
	RETURN g_startSnapshot.mVehicleStruct.bInVehicle
ENDFUNC


/// PURPOSE:
///    Checks if the vehicle is suitable for creation for a replay
/// PARAMS:
///    bCarChase - does this vehicle need to be suitable for a car chase?
///    bAllowHelis - is a helicopter a suitable vehicle?
///    bAllowCopCars - are cop vehicles suitable?
/// RETURNS:
///    TRUE if all checks are passed, FALSE otherwise
FUNC BOOL IS_CHECKPOINT_VEHICLE_SUITABLE(BOOL bCarChase = FALSE, BOOL bAllowHelis= FALSE, BOOL bAllowCopCars = FALSE, BOOL bAllowPlanes = TRUE)
	// don't allow boats (if a mission needs this, will set up on a bool param)
	IF IS_THIS_MODEL_A_BOAT(g_stageSnapshot.mVehicleStruct.mVehicle.eModel)
		CPRINTLN(DEBUG_REPLAY, "Boats not allowed for this replay.")
		RETURN FALSE
	ENDIF

	IF bAllowHelis= FALSE 
	AND IS_THIS_MODEL_A_HELI(g_stageSnapshot.mVehicleStruct.mVehicle.eModel)
		CPRINTLN(DEBUG_REPLAY, "Helicopters not allowed for this replay.")
		RETURN FALSE
	ENDIF

	IF bAllowCopCars= FALSE 
	AND IS_MODEL_POLICE_VEHICLE(g_stageSnapshot.mVehicleStruct.mVehicle.eModel)
		CPRINTLN(DEBUG_REPLAY, "Cop vehicles not allowed for this replay.")
		RETURN FALSE
	ENDIF
	
	IF bAllowPlanes = FALSE
	AND IS_THIS_MODEL_A_PLANE(g_stageSnapshot.mVehicleStruct.mVehicle.eModel)
		CPRINTLN(DEBUG_REPLAY, "Planes not allowed for this replay.")
		RETURN FALSE
	ENDIF
	
	// check car chase suitability
	IF bCarChase = TRUE
		IF NOT IS_REPLAY_CHECKPOINT_VEHICLE_OK_FOR_CHASE() 
			CPRINTLN(DEBUG_REPLAY, "Vehicle needed for car chase and is not suitable")
			RETURN FALSE
		ENDIF
	ENDIF
	RETURN TRUE // checkpoint vehicle is suitable
ENDFUNC

/// PURPOSE:
///     Checks if this replay has a vehicle associated with it.  
///    	If so, it recreates the vehicle at the co-ords specified. (if the vehicle is suitable)
///    	If not, it creates a new vehicle at the co-ords specified (bool available to turn this off)  
/// PARAMS:
///    mVehicle - vehicle index of the new vehicle.
///    vVehiclePos - where to create the vehicle.
///    fVehicleHeading -  heading of the vehicle.
///    bWarpPlayerIn - If true we warp the player into the car. If false we leave him where he is.
///    bCarChase - does this vehicle need to be suitable for a car chase?
///    bAllowHelis - is a helicopter a suitable vehicle?
///    bAllowCopCars - are cop vehicles suitable?
///    bCreateNewVehicle - if there is no replay vehicle (or it isn't suitable), should we create a new one?
///    mVehicleModel - the model for the new vehicle (only used if no replay vehicle available or it is unsuitable)
///    iColour - the colour of the new vehicle (only used if no replay vehicle available or it is unsuitable)
///    ePlayerPed- if this set to one of the 3 player characters we create that player character's default vehicle (if a replay vehicle isn't available)
PROC CREATE_VEHICLE_FOR_REPLAY(VEHICLE_INDEX &mVehicle, VECTOR vVehiclePos, FLOAT fVehicleHeading, BOOL bWarpPlayerIn = TRUE, BOOL bCarChase = FALSE, BOOL bAllowHelis= FALSE, BOOL bAllowCopCars = FALSE, BOOL bCreateNewVehicle = TRUE, MODEL_NAMES mVehicleModel = ASTEROPE,  INT iColour = 0, enumCharacterList ePlayerPed = NO_CHARACTER, BOOL bAllowPlanes = TRUE)

	BOOL bUseReplayVehicle = TRUE
	
	IF NOT IS_REPLAY_IN_PROGRESS()
    OR NOT IS_REPLAY_CHECKPOINT_VEHICLE_AVAILABLE()
		bUseReplayVehicle = FALSE
		CPRINTLN(DEBUG_REPLAY, "Not on a replay, or no replay vehicle available")
	ENDIF
	
	// check the optional vehicle types
	IF bUseReplayVehicle = TRUE
		IF NOT IS_CHECKPOINT_VEHICLE_SUITABLE(bCarChase, bAllowHelis, bAllowCopCars, bAllowPlanes)
			bUseReplayVehicle = FALSE
		ENDIF
	ENDIF
	
	IF bUseReplayVehicle = TRUE
		CPRINTLN(DEBUG_REPLAY, "Creating replay checkpoint vehicle")
		REQUEST_REPLAY_CHECKPOINT_VEHICLE_MODEL()
		WHILE NOT HAS_REPLAY_CHECKPOINT_VEHICLE_LOADED()
			WAIT(0)
		ENDWHILE
		
        // This replay has a vehicle available, create it
        mVehicle = CREATE_REPLAY_CHECKPOINT_VEHICLE(vVehiclePos, fVehicleHeading) 
	ELSE
    	// No vehicle available for replay. Create a new one?
		IF bCreateNewVehicle = TRUE
			CPRINTLN(DEBUG_REPLAY, "No replay checkpoint vehicle available- creating a new one")
		
			// If no vector specified, use the vector in the snapshot
			IF ARE_VECTORS_EQUAL(vVehiclePos, <<0.0,0.0,0.0>>) 
				vVehiclePos = g_stageSnapshot.mVehicleStruct.vVehiclePos
				fVehicleHeading = g_stageSnapshot.mVehicleStruct.fVehicleHeading
			ENDIF
			
			// clear space for the vehicle
			CLEAR_AREA(vVehiclePos, 5.0, TRUE) // clear area so we can create the car
			DELETE_VEHICLE_GEN_VEHICLES_IN_AREA(vVehiclePos, 5.0)
		
			// create default player vehicle or use model specified?
			IF IS_PLAYER_PED_PLAYABLE(ePlayerPed)
				CPRINTLN(DEBUG_REPLAY, "Create player's default vehicle: ePlayerPed= ", ePlayerPed)
				DELETE_ALL_SCRIPT_CREATED_PLAYER_VEHICLES(ePlayerPed)
				WHILE NOT CREATE_PLAYER_VEHICLE(mVehicle, ePlayerPed, vVehiclePos, fVehicleHeading)
					WAIT(0)
				ENDWHILE
				CPRINTLN(DEBUG_REPLAY, "Created player's default vehicle: ePlayerPed= ", ePlayerPed)
				
			ELSE
				CPRINTLN(DEBUG_REPLAY, "Create new vehicle")
				REQUEST_MODEL(mVehicleModel)
				WHILE NOT HAS_MODEL_LOADED(mVehicleModel)
					WAIT(0)
				ENDWHILE
				mVehicle = CREATE_VEHICLE(mVehicleModel, vVehiclePos, fVehicleHeading)
				IF DOES_ENTITY_EXIST(mVehicle)
				AND NOT IS_ENTITY_DEAD(mVehicle)
					IF iColour = 0
						SET_VEHICLE_COLOUR_COMBINATION(mVehicle,0)
					ELIF iColour > 0
						SET_VEHICLE_COLOURS(mVehicle, iColour, iColour)
					ENDIF
				ENDIF
				SET_MODEL_AS_NO_LONGER_NEEDED(mVehicleModel)
			ENDIF
		ENDIF
    ENDIF
	
	IF bWarpPlayerIn = TRUE
		IF DOES_ENTITY_EXIST(mVehicle)
		AND NOT IS_ENTITY_DEAD(mVehicle)
		AND DOES_ENTITY_EXIST(PLAYER_PED_ID())
		AND NOT IS_ENTITY_DEAD(PLAYER_PED_ID())
			SET_PED_INTO_VEHICLE(PLAYER_PED_ID(), mVehicle)
			SET_VEHICLE_ON_GROUND_PROPERLY(mVehicle)
		ENDIF
	ENDIF
ENDPROC

/// PURPOSE:
///     Checks if this replay has a vehicle associated with it.  
///    	If so it recreates the vehicle:
///    	If the player triggered mission in a car it recreates the car where it was (if suitable)
///    	Otherwise it puts the player in his snapshot car at nearest road node
///    
///    	If a snapshot vehicle isnt available it puts him in a new car at nearest road node (can be toggled) 
/// PARAMS:
///    mVehicle - vehicle index of the new vehicle.
///    bCarChase - does this vehicle need to be suitable for a car chase?
///    bAllowHelis - is a helicopter a suitable vehicle?
///    bAllowCopCars - are cop vehicles suitable?
///    bCreateNewVehicle - if there is no replay vehicle (or it isn't suitable), should we create a new one?
///    mVehicleModel - the model for the new vehicle (only used if no replay vehicle available or it is unsuitable)
///    iColour - the colour of the new vehicle (only used if no replay vehicle available or it is unsuitable)
///    ePlayerPed- if this set to one of the 3 player characters we create that player character's default vehicle (if a replay vehicle isn't available)
PROC CREATE_VEHICLE_FOR_PHONECALL_TRIGGER_REPLAY(VEHICLE_INDEX &mVehicle, BOOL bCarChase = FALSE, BOOL bAllowHelis= FALSE, BOOL bAllowCopCars = FALSE, BOOL bCreateNewVehicle = TRUE, MODEL_NAMES mVehicleModel = ASTEROPE,  INT iColour = 0, enumCharacterList ePlayerPed = NO_CHARACTER)
	VECTOR vPos = GET_ENTITY_COORDS(PLAYER_PED_ID())
	FLOAt fHeading = GET_ENTITY_HEADING(PLAYER_PED_ID())
	
	IF WAS_PLAYER_IN_VEHICLE_AT_MISSION_START()
	AND IS_CHECKPOINT_VEHICLE_SUITABLE(bCarChase, bAllowHelis, bAllowCopCars)
		CPRINTLN(DEBUG_REPLAY, "player was in vehicle when mission triggerd, use the snapshot pos and heading")
		// setting these to 0 causes CreateSnapshotVehicle to use the snapshot values
		vPos = <<0.0,0.0,0.0>>
		fHeading = 0.0
		CREATE_VEHICLE_FOR_REPLAY(mVehicle, vPos, fHeading, TRUE, bCarChase, bAllowHelis, bAllowCopCars, bCreateNewVehicle, mVehicleModel, iColour, ePlayerPed)
	ELSE
		// player wasn't in a vehicle
		// OR checkpoint vehicle isn't suitable (may be a heli in the air etc)
		// put him in his snapshot vehicle (or a new one) at nearest road node
		IF GET_CLOSEST_VEHICLE_NODE_WITH_HEADING(vPos, vPos, fHeading)
			CREATE_VEHICLE_FOR_REPLAY(mVehicle, vPos, fHeading, TRUE, bCarChase, bAllowHelis, bAllowCopCars, bCreateNewVehicle, mVehicleModel, iColour, ePlayerPed)
		ELSE
			// couldn't get a nearby road node, leave player where he is
		ENDIF
	ENDIF
ENDPROC

#IF IS_DEBUG_BUILD
	/// PURPOSE:
	///    Starts a new metrics tracking stage.  Used for metrics and smoketest.
	///    This is to be used for missions that don't have many replay checkpoints.
	/// PARAMS:
	///    sStageName - the debug name for this metrics stage
	PROC Start_New_Metrics_Stage(STRING sStageName)
		StartNewMetricsStage(1, GET_THIS_SCRIPT_NAME(), sStageName)
	ENDPROC
#ENDIF

/// PURPOSE:
///    Attempts to store the weapon the player character was using when he failed a mission.
///    If he had this weapon at his last checkpoint, it is stored.
///    If he didn't have it at his last checkpoint, WEAPONTYPE_INVALID is stored.
/// PARAMS:
///    mPed - the ped index of the player character we want to store the fail weapon of
///    iCharIndex - the index of the player character (CHAR_MICHAEL = 0, CHAR_FRANKLIN = 1 or CHAR_TREVOR = 2)
PROC Store_Fail_Weapon(PED_INDEX mPed, INt iCharIndex)

	WEAPON_TYPE mWeapon = WEAPONTYPE_INVALID

	IF DOES_ENTITY_EXIST(mPed)
		IF GET_CURRENT_PED_WEAPON(mPed, mWeapon, FALSE)
			// found usable weapon
			IF mWeapon <> WEAPONTYPE_INVALID
			AND mWeapon <> WEAPONTYPE_UNARMED 
				// weapon isn't invalid or unarmed
				IF NOT Had_Weapon_At_Last_Checkpoint(iCharIndex, mWeapon)
					// player didn't have this weapon at last checkpoint
					mWeapon = WEAPONTYPE_INVALID
				ENDIF
			ENDIF
		ENDIF
	ENDIF

	CPRINTLN(DEBUG_REPLAY, "Storing Fail weapon for Char: ", iCharIndex, " weapon: ", ENUM_TO_INT(mWeapon))
	
	// store fail weapon. Will be WEAPONTYPE_INVALID if player didn't have this weapon at last checkpoint
	IF g_replayMissionStage > 0
		g_stageSnapshot.mFailWeapon[iCharIndex] = mWeapon
	ELSE
		g_startSnapshot.mFailWeapon[iCharIndex] = mWeapon
	ENDIF
ENDPROC

/// PURPOSE:
///    Returns the weapontype the player character specified was using when he failed this mission
///    (Will be invalid if he didn't have that weapon at his last checkpoint)
/// PARAMS:
///    iCharIndex - the index of the player character (CHAR_MICHAEL = 0, CHAR_FRANKLIN = 1 or CHAR_TREVOR = 2)
/// RETURNS:
///    WEAPON_TYPE the weapon the player had equipped when he failed this misison
FUNC WEAPON_TYPE Get_Fail_Weapon(INT iCharIndex)

	IF g_replayMissionStage > 0
		RETURN g_stageSnapshot.mFailWeapon[iCharIndex]
	ELSE
		RETURN g_startSnapshot.mFailWeapon[iCharIndex]
	ENDIF
ENDFUNC

/// PURPOSE:
///    Sets a vehicle as restricted. (This should be called when the vehicle is created)
///    The player will be removed from restricted vehicles when they reject a replay, and the vehicle will be deleted.
///    They will also not be recreated when the replay controller creates a snapshot car for the player after rejecting a replay
/// PARAMS:
///    mVehicle - the vehicle index of the vehicle you want to restrict
///    iVehicleNumber - where in the restricted vehicles array you want to put this car
///    (this should be the same each time you create this particular car)
PROC SET_VEHICLE_AS_RESTRICTED(VEHICLE_INDEX mVehicle, INT iVehicleNumber)
	g_replay.mRestrictedVehicles[iVehicleNumber] = mVehicle
	CPRINTLN(DEBUG_REPLAY, "Restricted vehicle added: ",  iVehicleNumber)
ENDPROC

/// PURPOSE:
///    Sets what character the player will be if he rejects the mission replay
///    This should only be used in special cases (e.g. Exile 2 where we can't have the player return to game as Franklin)
///    This does not need to be called to avoid the player returning to gameplay as a locked character (That is already handled by the replay controller)
///    If you want to use this function- check with Andy Minghella or Ben Rollinson
PROC SET_REPLAY_REJECTED_CHARACTER(enumCharacterList eReplayRejectCharacter) 
	g_replay.eReplayRejectCharacter = eReplayRejectCharacter
	CPRINTLN(DEBUG_REPLAY, "SET_REPLAY_REJECTED_CHARACTER: to ", ENUM_TO_INT(eReplayRejectCharacter))
ENDPROC

/// PURPOSE:
///    Allows missions that only have the "mission start" checkpoint to have shitskips display "skip mission"
PROC SET_START_CHECKPOINT_AS_FINAL()
	g_bShitskipToEnd = TRUE
ENDPROC

/// PURPOSE:
///   Returns the position and heading of the player, from when he triggered this mission 
/// PARAMS:
///    vPos - the pos he was in.
///    fHeading - his heading.
PROC GET_MISSION_START_POS_AND_HEADING(VECTOR &vPos, FLOAT &fHeading)
	vPos = g_startSnapshot.mPlayerStruct.vPos
	fHeading = g_startSnapshot.mPlayerStruct.fHeading
ENDPROC

/// PURPOSE:
///    Checks if a replay is currently being set up.
///    This is only used by the new replay warp system.
/// RETURNS:
///   This will return TRUE after START_REPLAY_SETUP has been called, until END_REPLAY_SETUP is called. 
FUNC BOOL IS_REPLAY_BEING_SET_UP()
	RETURN IS_BIT_SET(g_replay.iReplayBits, ENUM_TO_INT(RB_REPLAY_SETUP_STARTED))
ENDFUNC

/// PURPOSE:
///    Returns the size of the load scene the replay controller will use to set up the replay
/// RETURNS:
///    INT size to use
FUNC FLOAT GET_REPLAY_LOAD_SCENE_SIZE()
	IF IS_BIT_SET(g_replay.iReplayBits, ENUM_TO_INT(RB_FULLY_INTERIOR))
		CPRINTLN(DEBUG_REPLAY, "GET_REPLAY_LOAD_SCENE_SIZE: Interior.")
		RETURN REPLAY_LOAD_SCENE_SIZE_INTERIOR // smaller stream size for interior
	ENDIF
	CPRINTLN(DEBUG_REPLAY, "GET_REPLAY_LOAD_SCENE_SIZE: Normal.")
	RETURN  REPLAY_LOAD_SCENE_SIZE
ENDFUNC

/// PURPOSE:
///    Handles warping the player for a replay setup.
///    THIS SHOULD ONLY BE CALLED BY THE REPLAY CONTROLLER
/// PARAMS:
///    iEarlyOutTime - timer used for early out of vehicle repopulation
///    streamVolID - handle to the volumne we are streaming
/// RETURNS:
///    TRUE when warp is complete.
FUNC BOOL REPLAY_WARP_PLAYER(INT &iEarlyOutTime)

	IF NOT IS_REPLAY_IN_PROGRESS()
		RETURN TRUE
	ENDIF
	
	IF IS_PLAYER_PLAYING(PLAYER_ID())
		SWITCH g_eReplayWarpStage
		
			CASE RWS_WAIT
				// waiting for mission to setup warp pos
			BREAK
		
			// start the teleport
			CASE RWS_START
				CPRINTLN(DEBUG_REPLAY, "REPLAY_WARP_PLAYER started")
				SET_GAME_PAUSED(FALSE)
				
				// turn off emergency streaming (pausing game will ensure player doesnt fall through floor)
				//SET_GAME_PAUSES_FOR_STREAMING(FALSE) 
				
				// move player now
				CLEAR_AREA(g_eReplayWarpPos, 5.0, TRUE)
				IF DOES_ENTITY_EXIST(PLAYER_PED_ID())
					IF NOT IS_PED_INJURED(PLAYER_PED_ID())
						SET_ENTITY_COORDS(PLAYER_PED_ID(), g_eReplayWarpPos)
						SET_ENTITY_HEADING(PLAYER_PED_ID(), g_eReplayWarpHeading)
						SET_GAMEPLAY_CAM_RELATIVE_PITCH(0.0) 
						SET_GAMEPLAY_CAM_RELATIVE_HEADING(0.0)
					ENDIF
				ENDIF
				
				NEW_LOAD_SCENE_START_SPHERE(g_eReplayWarpPos, GET_REPLAY_LOAD_SCENE_SIZE()) // start the load scene in same frame (1481684- requested by Ian)
				
				WAIT(0) // wait a frame for the camera to catch up before pausing
				
				// clear the area
				CLEAR_AREA(g_eReplayWarpPos, 5000, TRUE, FALSE)
				CLEAR_AREA_OF_OBJECTS(g_eReplayWarpPos, 5000)
				ReplayClearParticles(5000)
				CLEAR_ALL_MUST_LEAVE_AREA_VEHICLE_GEN_FLAGS()
				RESET_VEHICLE_GEN_LOADED_CHECKS()
				
				SETTIMERA(0)
				SET_GAME_PAUSED(TRUE)
				g_eReplayWarpStage = RWS_START_LOAD
			BREAK
			
			// try to create the new load scene
			CASE RWS_START_LOAD
				IF IS_NEW_LOAD_SCENE_ACTIVE()
					CPRINTLN(DEBUG_REPLAY, "REPLAY_WARP_PLAYER new load scene succesfully started.")
					SETTIMERA(0)
					g_eReplayWarpStage = RWS_DO_WARP
				ELSE
					IF NEW_LOAD_SCENE_START_SPHERE(g_eReplayWarpPos, GET_REPLAY_LOAD_SCENE_SIZE())
						CPRINTLN(DEBUG_REPLAY, "REPLAY_WARP_PLAYER new load scene succesfully started.")
						SETTIMERA(0)
						g_eReplayWarpStage = RWS_DO_WARP
					ELSE
						CPRINTLN(DEBUG_REPLAY, "REPLAY_WARP_PLAYER trying to start new load scene. ", TIMERA())
						// early out check
						IF TIMERA() > 5000
							CPRINTLN(DEBUG_REPLAY, "REPLAY_WARP_PLAYER took too long to create new load scene. Go to RWS_POST_WARP.")
							g_eReplayWarpStage =RWS_POST_WARP
						ENDIF
					ENDIF
				ENDIF
			BREAK
		
			// wait for the new load scene to finish
			CASE RWS_DO_WARP
				// wait for warp to finish 
				IF IS_NEW_LOAD_SCENE_ACTIVE()
					IF IS_NEW_LOAD_SCENE_LOADED()
						CPRINTLN(DEBUG_REPLAY, "REPLAY_WARP_PLAYER warp finished")
						g_eReplayWarpStage = RWS_POST_WARP
					ELSE
						CPRINTLN(DEBUG_REPLAY, "REPLAY_WARP_PLAYER new load scene still loading: ", TIMERA())
					ENDIF
				ELSE
					CPRINTLN(DEBUG_REPLAY, "REPLAY_WARP_PLAYER new load scene not active")
				ENDIF
				
				// check for early out
				IF TIMERA() > REPLAY_LOAD_SCENE_TIMEOUT
					CPRINTLN(DEBUG_REPLAY, "REPLAY_WARP_PLAYER took too long: early out")
					g_eReplayWarpStage = RWS_POST_WARP
				ENDIF

				// check for debug skip
				#IF IS_DEBUG_BUILD
					IF (IS_KEYBOARD_KEY_JUST_PRESSED(KEY_V))
						CPRINTLN(DEBUG_REPLAY, "REPLAY_WARP_PLAYER debug skipping streaming.")
						g_eReplayWarpStage = RWS_POST_WARP
					ENDIF
				#ENDIF
			BREAK
			
			// post warp cleanup- then start repopulation
			CASE RWS_POST_WARP
				// debug only breaks for checking missions aren't clearing the area we've just repopulated
				//BREAK_ON_NATIVE_COMMAND("CLEAR_AREA", FALSE)
				//BREAK_ON_NATIVE_COMMAND("CLEAR_AREA_OF_PEDS", FALSE)
				
				// clear and repopulate the area
				IF DOES_ENTITY_EXIST(PLAYER_PED_ID())
					IF NOT IS_PED_INJURED(PLAYER_PED_ID())
					
						// get rid of the stream vol
						IF IS_NEW_LOAD_SCENE_ACTIVE()
							NEW_LOAD_SCENE_STOP()
						ENDIF
						
						// need to unpause for repopulate stuff to work
						SET_GAME_PAUSED(FALSE)
						
						// allow emergency streaming again
						//SET_GAME_PAUSES_FOR_STREAMING(TRUE)
						
						// refill population
						INSTANTLY_FILL_PED_POPULATION()
						IF IS_BIT_SET(g_replay.iReplayBits, ENUM_TO_INT(RB_DO_VEHICLE_REPOP))
							INSTANTLY_FILL_VEHICLE_POPULATION()
							iEarlyOutTime = GET_GAME_TIMER() + REPOP_EARLY_OUT
						ELSE
							// if not doing vehicle repop, set the early out
							iEarlyOutTime = GET_GAME_TIMER() + REPOP_MIN_WAIT
						ENDIF
						POPULATE_NOW()
					ENDIF
				ENDIF
				g_eReplayWarpStage = RWS_REPOPULATE
			BREAK
			
			// wait for repopulation to finish
			CASE RWS_REPOPULATE
				IF (HAS_INSTANT_FILL_VEHICLE_POPULATION_FINISHED()
				AND HAVE_ALL_VEHICLE_GENS_LOADED_NEAR_PLAYER()
				AND GET_GAME_TIMER() > iEarlyOutTime - (REPOP_EARLY_OUT-REPOP_MIN_WAIT))
				OR GET_GAME_TIMER() > iEarlyOutTime
					IF GET_GAME_TIMER() > iEarlyOutTime
						IF IS_BIT_SET(g_replay.iReplayBits, ENUM_TO_INT(RB_DO_VEHICLE_REPOP))
							CPRINTLN(DEBUG_REPLAY, "REPLAY_WARP_PLAYER repopulation took too long, early out.")
						ELSE
							CPRINTLN(DEBUG_REPLAY, "REPLAY_WARP_PLAYER skipping vehicle repopulation.")
						ENDIF
					ENDIF

					// reset camera behind player
					SET_GAMEPLAY_CAM_RELATIVE_PITCH(0.0) 
					SET_GAMEPLAY_CAM_RELATIVE_HEADING(0.0)
					
					// repause the game
					SET_GAME_PAUSED(TRUE)
					
					// finished
					CPRINTLN(DEBUG_REPLAY, "REPLAY_WARP_PLAYER: repopulation finished")
					g_eReplayWarpStage = RWS_DONE
					RETURN TRUE
				ELSE
					CPRINTLN(DEBUG_REPLAY, "REPLAY_WARP_PLAYER waiting for vehicle repopulation.")
				ENDIF
			BREAK
			
			// replay warp finished
			CASE RWS_DONE
				RETURN TRUE
			BREAK
		ENDSWITCH
	ENDIF
	
	RETURN FALSE // not finished warp / repopulate	
ENDFUNC

/// PURPOSE:
///    Call this when your mission starts setting up for a replay.
///    Disables audio, pauses the game and disables player control etc.  
/// PARAMS:
///    vPos - where you want to put the player
///    fHeading - the heading you want the player to have
///    bRefillVehiclePop - do you want to refill the vehicle population?
///    bFullyInterior - if this area is fully interior with no view of outside we can use a smaller stream area
PROC START_REPLAY_SETUP(VECTOR vPos, FLOAT fHeading, BOOL bRefillVehiclePop = TRUE, BOOL bFullyInterior = FALSE)
	CPRINTLN(DEBUG_REPLAY, "START_REPLAY_SETUP called. vPos= ", vPos, " fHeading= ", fHeading)
	
	IF IS_REPLAY_IN_PROGRESS()

		// ensure the mission script can't be paused
		SET_THIS_SCRIPT_CAN_BE_PAUSED(FALSE)

		// pause the game
		CLEAR_BIT(g_replay.iReplayBits, ENUM_TO_INT(RB_PAUSED_GAME)) //stops replay controller unpausing
		SET_GAME_PAUSED(TRUE)
		
		// disable player control
		IF IS_PLAYER_PLAYING(PLAYER_ID())
			SET_PLAYER_CONTROL(PLAYER_ID(), FALSE)
		ENDIF
		
		// reset any replay setup variables here:
		g_eReplayWarpPos = vPos
		g_eReplayWarpHeading = fHeading
		g_eReplayWarpStage = RWS_START
		
		IF bRefillVehiclePop = TRUE
			SET_BIT(g_replay.iReplayBits, ENUM_TO_INT(RB_DO_VEHICLE_REPOP))
		ELSE
			CLEAR_BIT(g_replay.iReplayBits, ENUM_TO_INT(RB_DO_VEHICLE_REPOP))
		ENDIF
		
		IF bFullyInterior = TRUE
			CPRINTLN(DEBUG_REPLAY, "Doing set up for interior checkpoint.")
			SET_BIT(g_replay.iReplayBits, ENUM_TO_INT(RB_FULLY_INTERIOR))
		ELSE
			CPRINTLN(DEBUG_REPLAY, "Doing set up for normal checkpoint.")
			CLEAR_BIT(g_replay.iReplayBits, ENUM_TO_INT(RB_FULLY_INTERIOR))
		ENDIF
		
		// replay set up has started
		Replay_Toggle_Setup(TRUE)
	ENDIF
ENDPROC

/// PURPOSE:
///    Call this when your mission has finished setting up for a replay.
///    REPLAY_WARP_PLAYER() should already have returned true.
///    Enables audio, unpauses the game, enables player control etc.   
/// PARAMS:
///    mVehicle - the vehicle to put the player in. If left as null is left on foot.
///    mSeat - the seat of the vehicle that you want to put the player in.
///    bReturnPlayerControl- do we want to turn player control back on now?
PROC END_REPLAY_SETUP(VEHICLE_INDEX mVehicle = NULL, VEHICLE_SEAT mSeat= VS_DRIVER, BOOL bReturnPlayerControl = TRUE)
	CPRINTLN(DEBUG_REPLAY, "END_REPLAY_SETUP called.")
	
	IF IS_REPLAY_IN_PROGRESS()
	AND IS_REPLAY_BEING_SET_UP()
	
		WHILE g_eReplayWarpStage <> RWS_DONE
			WAIT(0)
			//CPRINTLN(DEBUG_REPLAY, "END_REPLAY_SETUP: Waiting for warp to finish")
		ENDWHILE
		
		// unpause the game
		SET_GAME_PAUSED(FALSE)
		
		// clear wetness here as it no longer seems to work while paused
		IF DOES_ENTITY_EXIST(PLAYER_PED_ID())
			IF NOT IS_PED_INJURED(PLAYER_PED_ID())
				CLEAR_PED_WETNESS(PLAYER_PED_ID())
			ENDIF
		ENDIF
		
		// put the player in the vehicle specified
		IF mVehicle <> NULL
			IF NOT IS_PED_INJURED(PLAYER_PED_ID())
				IF DOES_ENTITY_EXIST(mVehicle)
					IF IS_VEHICLE_DRIVEABLE(mVehicle)
						IF NOT IS_PED_IN_VEHICLE(PLAYER_PED_ID(), mVehicle)
							SET_PED_INTO_VEHICLE(PLAYER_PED_ID(), mVehicle, mSeat)
							// reset camera behind player
							SET_GAMEPLAY_CAM_RELATIVE_PITCH(0.0) 
							SET_GAMEPLAY_CAM_RELATIVE_HEADING(0.0)
							WAIT(0) // wait a frame for camera to catch up
							CPRINTLN(DEBUG_REPLAY, "END_REPLAY_SETUP: Put player in vehicle")
						ENDIF	
					ENDIF
				ENDIF
			ENDIF
		ENDIF
			
		// return player control
		IF bReturnPlayerControl = TRUE
			IF IS_PLAYER_PLAYING(PLAYER_ID())
				SET_PLAYER_CONTROL(PLAYER_ID(), TRUE)
			ENDIF
		ENDIF
		
		//Make sure all PostFX are cleared at this point.
		ANIMPOSTFX_STOP_ALL()
		
		// replay set up is complete
		Replay_Toggle_Setup(FALSE)
		
		// allow mission script to be paused as normal from now on
		//SET_THIS_SCRIPT_CAN_BE_PAUSED(TRUE)
	ENDIF
ENDPROC