//////////////////////////////////////////////////////////////////////////////////////////
//																						//
//		SCRIPT NAME		:	epsCars.sc													//
//		AUTHOR			:																//
//		DESCRIPTION		:	Manages the progress of the Epsilon 3 car pickup request 	//
//							emails and objectives.										//
//																						//
//////////////////////////////////////////////////////////////////////////////////////////

//----------------------
//	INCLUDES
//----------------------
USING "email_public.sch"
USING "rgeneral_include.sch"
USING "RC_Helper_Functions.sch"

//----------------------
//	ENUMS
//----------------------
ENUM STAGE_ENUM
	SE_GET_VEHICLE = 0,
	SE_APPROACH_GARAGE,
	SE_DELIVER_VEHICLE,
	SE_VEHICLE_OCCUPIED,
	SE_PLAYER_WANTED,
	SE_LEAVE_VEHICLE,
	SE_MISSION_CLEAR
ENDENUM

ENUM GARAGE_DOOR_STATE
	GDS_NULL,
	GDS_OPEN,
	GDS_CLOSED,
	GDS_CLOSING,
	GDS_OPENING
ENDENUM

//----------------------
//	CONSTS
//----------------------
CONST_INT XVERSION_NUMBER	216

CONST_FLOAT GARAGE_DOOR_SPEED			0.05
CONST_FLOAT GARAGE_DOOR_OPEN_RATIO		1.0
CONST_FLOAT GARAGE_DOOR_CLOSED_RATIO	0.0

CONST_INT DAMAGE_THRESHOLD				750		// if the vehicles hp is less than this help text comes up and the offer to grab a car will be rejected
CONST_INT QUALITY_THRESHOLD				875		// if the vehicles hp is less this a bad e-mail gets sent

CONST_INT MAX_CARS						5
CONST_INT NO_MIDSIZED_MESSAGE			99

CONST_FLOAT DOOR_DIST_THRESHOLD			15.0

//---------------------
//	STRUCTS
//----------------------
STRUCT EMAIL_HELPER
	EMAIL_MESSAGE_ENUMS eMailID
	STRING sEmailBody
	STRING sEmailBadBody
ENDSTRUCT

STRUCT GARAGE_DOOR_HELPER
	GARAGE_DOOR_STATE doorState
	GARAGE_DOOR_STATE doorDesiredState
	MODEL_NAMES doorModel
	VECTOR vDoorPosition
	VECTOR vCenterPosition
	FLOAT fDoorRatio = 0.0
	FLOAT fDoorSpeed = 0.015
	FLOAT fGarageRadius = 7.25
ENDSTRUCT

STRUCT GARAGE_HELPER
	VECTOR vDoorPosition
	MODEL_NAMES doorModel
	GARAGE_DOOR_STATE doorState
	GARAGE_DOOR_STATE doorDesiredState
	ANGLED_AREA garageArea				// make sure the width goes along the door axis
	
	VECTOR vCenterPosition
	FLOAT fDoorRatio = 0.0
	FLOAT fDoorSpeed = 0.015
	
	VECTOR vDoorEdge[2]
	BOOL bIsBlocked = FALSE
ENDSTRUCT

//---------------------
//	VARIABLES
//----------------------
VECTOR vDropOffPoint = <<-690.938049,512.270325,109.363853>> // 3meter radius

GARAGE_HELPER dropOffGarage
EMAIL_HELPER eMailHelper[MAX_CARS]

MODEL_NAMES carModels[MAX_CARS]
BLIP_INDEX vLocationBlip

STAGE_PROGRESS stageProgress
STAGE_ENUM stageEnum

INT SoundID
BOOL bPlayingLoopedSound = FALSE

INT iNextDay
INT iSubState = 0
INT iCarsDelivered = 0
INT iLastIndexDelivered = -1
BOOL bHelpDisplayed = FALSE
BOOL bDmgHelpDisplayed = FALSE
BOOL bMessHelpDisplayed = FALSE
BOOL bExitCarHelpDisplayed = FALSE
BOOL bBeenWanted = FALSE

INT iBlockedTimer

INT iEmailTimer = 0
INT EMAIL_DELAY	= 60000	// ONE_MINUTE

ANGLED_AREA noGarageRoadArea
VEHICLE_INDEX currentEpsilonVehicle
SCENARIO_BLOCKING_INDEX sScenarioBlockIndex
structPedsForConversation convoMichael

SCALEFORM_INDEX sFormMidSized
INT iMidSizedMessageStage = NO_MIDSIZED_MESSAGE
INT iMidSizedMessageTimer

#IF IS_DEBUG_BUILD
	WIDGET_GROUP_ID mWidgetGroup
	BLIP_INDEX vVehicleGenBlip[7]
	BLIP_INDEX blipDropOff
	
	INT iCurrentDay = GET_CLOCK_DAY_OF_MONTH()
	BOOL bAdvanceTime = FALSE
	BOOL bForceQuitWin = FALSE
	BOOL bForceQuitFail = FALSE
	
	INT iShowState = 0
	BOOL bTestOpenDoor = FALSE
	BOOL bTestCloseDoor = FALSE
	BOOL bIsInStopArea = FALSE
	BOOL bIsGarageOccupied = FALSE
	BOOL bIsDoorBlocked = FALSE
	BOOL bTempCarDelivered[MAX_CARS]
	BOOL bTempCarBadCondition[MAX_CARS]
	
	BOOL bBlipDropOffPoint = FALSE
	BOOL bShowVehicleGens = FALSE
	BOOL bHideVehicleGens = FALSE
	BOOL bHideVehicleGenCarbon = FALSE
	BOOL bHideVehicleGenVacca = FALSE
	BOOL bHideVehicleGenSurano = FALSE
	BOOL bHideVehicleGenSuperD = FALSE
	BOOL bHideVehicleGenTornado = FALSE
	
	BOOL bShowDebugStuff = FALSE
	BOOL bWarpToGarage = FALSE
	BOOL bSendTestEmail 
	INT iFakeCarsLeftCount = 0
	
	BOOL bCreatePedInCar = FALSE
	FLOAT fDistDoor
	FLOAT fDistCenter
	INT iCarHP = 0
	INT iCarBrokeParts = 0
	INT iCarLooseParts = 0
	VECTOR vGarageSafePoint = <<-690.156982,511.264130,109.363853>> // 7.25 radius
#ENDIF

FUNC BOOL IS_DYNAMIC_EMAIL_ARRIVED_YET(DYNAMIC_EMAIL_THREAD_NAMES thread)
	INT index = GET_DYNAMIC_EMAIL_THREAD_BUFFER_INDEX(thread)
	IF index = -1
		CPRINTLN(DEBUG_AMBIENT, "EPSCARS.SC: Buffer no longer exists")
		RETURN TRUE
	ENDIF
	
	CPRINTLN(DEBUG_AMBIENT, "EPSCARS.SC: iProgress on this buffer is = ", g_DynamicEmailThreadBuffers[index].iProgress)
	
	RETURN FALSE
ENDFUNC

//----------------------
//	GARAGE FUNCTIONS
//----------------------

/// PURPOSE:
///    Setups a garage
/// PARAMS:
///    gdh - 
///    mdl - 
///    doorPos - 
///    p1 - 
///    p2 - 
///    width - 
PROC SETUP_GARAGE_HELPER(GARAGE_HELPER &gdh, MODEL_NAMES mdl, VECTOR doorPos, VECTOR cpos, VECTOR p1, VECTOR p2, FLOAT width, VECTOR d1, VECTOR d2)
	gdh.doorModel = mdl
	gdh.vDoorPosition = doorPos
	gdh.doorDesiredState = GDS_CLOSED
	gdh.doorState = GDS_NULL
	
	gdh.vDoorEdge[0] = d1
	gdh.vDoorEdge[1] = d2
	gdh.vCenterPosition = cpos
	SET_ANGLED_AREA(gdh.garageArea, p1, p2, width)
	
ENDPROC

/// PURPOSE:
///    Checks if garage has finished closing
/// PARAMS:
///    gdh - reference
FUNC BOOL HAS_GARAGE_HELPER_FINISHED_CLOSING(GARAGE_HELPER &gdh)
	RETURN (gdh.doorDesiredState = GDS_CLOSED) AND (gdh.doorState = GDS_CLOSED)
ENDFUNC

/// PURPOSE:
///    Checks if garage has finished moving
/// PARAMS:
///    gdh - reference
FUNC BOOL HAS_GARAGE_HELPER_FINISHED_MOVING(GARAGE_HELPER &gdh)
	RETURN gdh.doorDesiredState = gdh.doorState
ENDFUNC

/// PURPOSE:
///    Checks if garage has finished opening
/// PARAMS:
///    gdh - reference
FUNC BOOL HAS_GARAGE_HELPER_FINISHED_OPENING(GARAGE_HELPER &gdh)
	RETURN (gdh.doorDesiredState = GDS_OPEN) AND (gdh.doorState = GDS_OPEN)
ENDFUNC

FUNC BOOL IS_PLAYER_CLEAR_OF_GARAGE(GARAGE_HELPER &gdh)
	RETURN NOT (gdh.bIsBlocked) AND NOT IS_POSITION_OCCUPIED(gdh.vCenterPosition, 6.2, FALSE, FALSE, TRUE, FALSE, FALSE)
ENDFUNC

/// PURPOSE:
///    Sets the Garage State
/// PARAMS:
///    gdh - reference
///    state - new state
PROC SET_DESIRED_GARAGE_HELPER_STATE(GARAGE_HELPER &gdh, GARAGE_DOOR_STATE state)
	gdh.doorDesiredState = state
ENDPROC

/// PURPOSE:
///    Locks the garage
/// PARAMS:
///    gdh - reference
PROC FORCE_LOCK_GARAGE_HELPER(GARAGE_HELPER &gdh)
	IF DOES_OBJECT_OF_TYPE_EXIST_AT_COORDS(gdh.vDoorPosition, 20.0, gdh.doorModel)
		SET_STATE_OF_CLOSEST_DOOR_OF_TYPE(gdh.doorModel, gdh.vDoorPosition, TRUE, GARAGE_DOOR_CLOSED_RATIO)
	ENDIF
ENDPROC

/// PURPOSE:
///    Unlocks the garage
/// PARAMS:
///    gdh - reference
PROC FORCE_UNLOCK_GARAGE_HELPER(GARAGE_HELPER &gdh)
	IF DOES_OBJECT_OF_TYPE_EXIST_AT_COORDS(gdh.vDoorPosition, 20.0, gdh.doorModel)
		SET_STATE_OF_CLOSEST_DOOR_OF_TYPE(gdh.doorModel, gdh.vDoorPosition, FALSE, -1.0)
	ENDIF
ENDPROC


/// PURPOSE:
///    Update Garage
/// PARAMS:
///    gdh - reference
PROC UPDATE_GARAGE_HELPER(GARAGE_HELPER &gdh)
	VECTOR v
	
	// do blocked check - should do these on odd and even frames
	gdh.bIsBlocked = FALSE
	
	IF IS_POSITION_OCCUPIED(gdh.vDoorEdge[0], 1.2, FALSE, TRUE, TRUE, FALSE, FALSE, PLAYER_PED_ID())
		gdh.bIsBlocked = TRUE
		CPRINTLN(DEBUG_AMBIENT, "Eps Cars: Garage is blocked (gdh.vDoorEdge[0] occupied)")
	ELIF IS_POSITION_OCCUPIED(gdh.vDoorEdge[1], 1.2, FALSE, TRUE, TRUE, FALSE, FALSE, PLAYER_PED_ID())
		gdh.bIsBlocked = TRUE
		CPRINTLN(DEBUG_AMBIENT, "Eps Cars: Garage is blocked (gdh.vDoorEdge[1] occupied)")
	ELSE
		v = INTERPOLATE_VECTOR(gdh.vDoorEdge[0], gdh.vDoorEdge[1], 0.5)
		gdh.bIsBlocked = IS_POSITION_OCCUPIED(v, 1.2, FALSE, TRUE, TRUE, FALSE, FALSE, PLAYER_PED_ID())
		IF gdh.bIsBlocked
			CPRINTLN(DEBUG_AMBIENT, "Eps Cars: Garage is blocked (INTERPOLATE_VECTOR occupied)")
		ENDIF
	ENDIF	
	
	// update closing off door
	IF (gdh.doorDesiredState = GDS_CLOSED) AND ((gdh.doorState <> GDS_CLOSED) OR (gdh.doorState = GDS_CLOSING))
		gdh.fDoorRatio -= gdh.fDoorSpeed
		IF (gdh.fDoorRatio <= GARAGE_DOOR_CLOSED_RATIO)
			gdh.fDoorRatio = GARAGE_DOOR_CLOSED_RATIO
			gdh.doorState = GDS_CLOSED
			STOP_SOUND(SoundID)
			CPRINTLN(DEBUG_AMBIENT, "Stopping Closing sound ID")
			bPlayingLoopedSound = FALSE
			PLAY_SOUND_FROM_COORD(-1, "CLOSED", gdh.vDoorPosition, "DOOR_GARAGE", DEFAULT, DEFAULT, TRUE)
		ELSE
			IF NOT bPlayingLoopedSound
				PLAY_SOUND_FROM_COORD(SoundID, "CLOSING", gdh.vDoorPosition, "DOOR_GARAGE", DEFAULT, DEFAULT, TRUE)
				CPRINTLN(DEBUG_AMBIENT, "Playing Closing audio loop")
				bPlayingLoopedSound = TRUE
			ENDIF
		ENDIF
	ENDIF
	
	IF (gdh.doorDesiredState = GDS_OPEN) AND ((gdh.doorState <> GDS_OPEN) OR (gdh.doorState = GDS_OPENING))
		gdh.fDoorRatio += gdh.fDoorSpeed
		IF (gdh.fDoorRatio >= GARAGE_DOOR_OPEN_RATIO)
			gdh.fDoorRatio = GARAGE_DOOR_OPEN_RATIO
			gdh.doorState = GDS_OPEN
			STOP_SOUND(SoundID)
			CPRINTLN(DEBUG_AMBIENT, "Stopping Opening sound ID")
			bPlayingLoopedSound = FALSE
			PLAY_SOUND_FROM_COORD(-1, "OPENED", gdh.vDoorPosition, "DOOR_GARAGE", DEFAULT, DEFAULT, TRUE)
		ELSE
			IF NOT bPlayingLoopedSound
				PLAY_SOUND_FROM_COORD(SoundID, "OPENING", gdh.vDoorPosition, "DOOR_GARAGE", DEFAULT, DEFAULT, TRUE)
				CPRINTLN(DEBUG_AMBIENT, "Playing Opening audio loop")
				bPlayingLoopedSound = TRUE
			ENDIF
		ENDIF
	ENDIF
	
	IF DOES_OBJECT_OF_TYPE_EXIST_AT_COORDS(gdh.vDoorPosition, 20.0, gdh.doorModel)
		SET_STATE_OF_CLOSEST_DOOR_OF_TYPE(gdh.doorModel, gdh.vDoorPosition, TRUE, gdh.fDoorRatio)
	ENDIF
ENDPROC


//----------------------
//	CARCHECK FUNCTIONS
//----------------------

//------------------------------------------------------------------------------
//	FUNCTION: GET_CARS_DELIVERED_COUNT()
//  PURPOSE: TELLS US HOW MANY CARS ARE DELIVERED
//------------------------------------------------------------------------------
FUNC INT GET_CARS_DELIVERED_COUNT()
	INT i = 0
	INT cnt = 0
	
	REPEAT MAX_CARS i
		IF IS_BIT_SET(iCarsDelivered, i)
			cnt ++
		ENDIF
	ENDREPEAT
	
	RETURN cnt
ENDFUNC

PROC FORCE_ALL_CARS_DELIVERED()
	INT i
	iCarsDelivered = 0
	REPEAT MAX_CARS i
		SET_BIT(iCarsDelivered, i)
	ENDREPEAT	
ENDPROC

FUNC INT GET_CARS_LEFT_COUNT()
	RETURN MAX_CARS - GET_CARS_DELIVERED_COUNT()
ENDFUNC

//------------------------------------------------------------------------------
//	FUNCTION: ARE_ALL_CARS_DELIVERED()
//  PURPOSE: RETURNS TRUE IF ALL CARS ARE DELIVERED
//------------------------------------------------------------------------------
FUNC BOOL ARE_ALL_CARS_DELIVERED()
	RETURN (GET_CARS_DELIVERED_COUNT() = MAX_CARS)
ENDFUNC

//------------------------------------------------------------------------------
//	FUNCTION: IS_CAR_INDEX_DELIVERED()
//  PURPOSE: RETURNS CAR INDEX IS DELIVERED
//------------------------------------------------------------------------------
FUNC BOOL IS_CAR_INDEX_DELIVERED(INT i)
	RETURN IS_BIT_SET(iCarsDelivered, i)
ENDFUNC

//------------------------------------------------------------------------------
//	FUNCTION: IS_CAR_INDEX_DELIVERED()
//  PURPOSE: RETURNS CAR INDEX IS DELIVERED
//------------------------------------------------------------------------------
FUNC BOOL IS_CAR_INDEX_CONDITION_BAD(INT i)
	IF (i < 0)
		RETURN TRUE 
	ENDIF
	
	RETURN IS_BIT_SET(iCarsDelivered, i + MAX_CARS)
ENDFUNC

/// PURPOSE:
///    Checks if player is any car which hasn't been delivered and is good enough for Epsilon
/// RETURNS:
///    
FUNC BOOL IS_CAR_ON_REQUIRED_LIST(VEHICLE_INDEX v)
	INT i 
	
	REPEAT MAX_CARS i
		IF GET_ENTITY_MODEL(v) = carModels[i]
			IF NOT IS_CAR_INDEX_DELIVERED(i)
				RETURN TRUE
			ENDIF
		ENDIF
	ENDREPEAT
	
	RETURN FALSE
ENDFUNC

//------------------------------------------------------------------------------
//	FUNCTION: IS_CAR_TOO_BUST_FOR_EPSILON(()
//  PURPOSE: RETURNS TRUE IF A CAR IS NO GOOD
//------------------------------------------------------------------------------
FUNC BOOL IS_CAR_TOO_BUST_FOR_EPSILON(VEHICLE_INDEX v)

	IF NOT IS_ENTITY_OK(v)
		RETURN TRUE
	ENDIF
	
	IF (GET_ENTITY_HEALTH(v) < DAMAGE_THRESHOLD) 
		RETURN TRUE
	ENDIF
	
	IF IS_VEHICLE_BUMPER_BROKEN_OFF(v, TRUE) OR IS_VEHICLE_BUMPER_BROKEN_OFF(v, FALSE)
		RETURN TRUE
	ENDIF
	
	RETURN GET_VEHICLE_NUM_OF_BROKEN_OFF_PARTS(v) > 0
ENDFUNC

//------------------------------------------------------------------------------
//	FUNCTION: IS_CAR_INDEX_DELIVERED()
//  PURPOSE: RETURNS CAR INDEX IS DELIVERED
//------------------------------------------------------------------------------
PROC SET_CAR_INDEX_DELIVERED(INT i, BOOL del)
	IF (del)
		SET_BIT(iCarsDelivered, i)
		iLastIndexDelivered = i
	ELSE
		CLEAR_BIT(iCarsDelivered, i)
	ENDIF
ENDPROC

//------------------------------------------------------------------------------
//	FUNCTION: IS_CAR_INDEX_DELIVERED()
//  PURPOSE: RETURNS CAR INDEX IS DELIVERED
//------------------------------------------------------------------------------
PROC SET_CAR_INDEX_CONDITION_BAD(INT i, BOOL con)
	IF (con)
		SET_BIT(iCarsDelivered, i + MAX_CARS)
	ELSE
		CLEAR_BIT(iCarsDelivered, i + MAX_CARS)
	ENDIF
ENDPROC

//------------------------------------------------------------------------------
//	FUNCTION: FORCE_SET_ALL_CARS_DELIVERED()
//  PURPOSE: SETS ALL CARS TO BE DELIVERED - FOR 'S' SKIP
//------------------------------------------------------------------------------
PROC FORCE_SET_ALL_CARS_DELIVERED()
	INT i
	
	REPEAT MAX_CARS i 
		SET_CAR_INDEX_DELIVERED(i, TRUE)
	ENDREPEAT
	
	g_savedGlobals.sAmbient.iEpsilonCarStage = iCarsDelivered
ENDPROC

FUNC BOOL CHECK_CARMODEL(MODEL_NAMES carModel, INT ind)

	IF (carModel = carModels[ind])
		RETURN TRUE
	ENDIF
	
	IF (carModels[ind] <> TORNADO2)
		RETURN FALSE 
	ENDIF
	
	IF (carModel = TORNADO)
		RETURN TRUE
	ENDIF
	
	IF (carModel = TORNADO2)
		RETURN TRUE
	ENDIF

	IF (carModel = TORNADO3)
		RETURN TRUE
	ENDIF
		
	IF (carModel = TORNADO4)
		RETURN TRUE
	ENDIF
	
	RETURN FALSE
ENDFUNC

/// PURPOSE:
///    Marks off Delivered Car
/// PARAMS:
///    v - Car index
/// RETURNS:
///    Returns true if it has been delivered
FUNC BOOL MARK_OFF_DELIVERED_CAR(VEHICLE_INDEX v)
	INT i 
	MODEL_NAMES carModel = GET_ENTITY_MODEL(v)
	
	IF IS_CAR_TOO_BUST_FOR_EPSILON(v)
		RETURN FALSE
	ENDIF
	
	REPEAT MAX_CARS i
		IF CHECK_CARMODEL(carModel, i)
			IF NOT IS_CAR_INDEX_DELIVERED(i)
				SET_CAR_INDEX_CONDITION_BAD(i, (GET_ENTITY_HEALTH(v) < QUALITY_THRESHOLD))
				SET_CAR_INDEX_DELIVERED(i, TRUE)
				RETURN TRUE
			ENDIF
		ENDIF
	ENDREPEAT

	RETURN FALSE
ENDFUNC

/// PURPOSE:
///    Checks if player is any car which hasn't been delivered and is good enough for Epsilon
/// RETURNS:
///    
FUNC BOOL IS_PLAYER_IN_ANY_UNDELIVERED_CAR()
	INT i = 0
	VEHICLE_INDEX v 
	
	IF NOT IS_ENTITY_OK(PLAYER_PED_ID())
		RETURN FALSE
	ENDIF
	
	IF NOT IS_PED_IN_ANY_VEHICLE(PLAYER_PED_ID())
		bDmgHelpDisplayed = FALSE 
		RETURN FALSE
	ENDIF
	
	v = GET_VEHICLE_PED_IS_USING(PLAYER_PED_ID())
	IF NOT IS_ENTITY_OK(v)
		RETURN FALSE
	ENDIF
	
	REPEAT MAX_CARS i 
		IF NOT IS_CAR_INDEX_DELIVERED(i)
			IF CHECK_CARMODEL(GET_ENTITY_MODEL(v), i)
				IF IS_CAR_TOO_BUST_FOR_EPSILON(v)
					IF NOT (bDmgHelpDisplayed)
						PRINT_HELP("EPS_DROP_FAIL")
						bDmgHelpDisplayed = TRUE
					ENDIF
					
					RETURN FALSE
				ENDIF

				RETURN TRUE
			ENDIF
		ENDIF
	ENDREPEAT
	
	RETURN FALSE
ENDFUNC

//------------------------------------------------------------------------------
//	FUNCTION: IS_PLAYER_IN_ANY_UNDELIVERED_CAR()
//  PURPOSE: RETURNS IF PLAYER IS NOT IN A DELIVERED CAR
//------------------------------------------------------------------------------
FUNC BOOL MARK_OFF_ANY_UNDELIVERED_CARS_IN_GARAGE(GARAGE_HELPER &gdh)
	INT i
	INT iCnt
	BOOL ok = FALSE
	VEHICLE_INDEX carArray[20]
	
	iCnt = GET_PED_NEARBY_VEHICLES(PLAYER_PED_ID(), carArray)
	IF (iCnt = 0)
		RETURN FALSE 
	ENDIF
	
	REPEAT iCnt i
		IF IS_ENTITY_OK(carArray[i])
			IF IS_ENTITY_IN_ANGLED_AREA(carArray[i], gdh.garageArea.vPosition[0], gdh.garageArea.vPosition[1], gdh.garageArea.fWidth)
			AND NOT gdh.bIsBlocked
				IF MARK_OFF_DELIVERED_CAR(carArray[i])
					ok = TRUE 
				ENDIF
			ENDIF
		ENDIF
	ENDREPEAT
	
	IF (ok = TRUE)
		g_savedGlobals.sAmbient.iEpsilonLastEmailSentDay = GET_CLOCK_DAY_OF_MONTH()
		CPRINTLN(DEBUG_AMBIENT, "NEXT E-MAIL WILL BE SEND OUT ON THE ", (g_savedGlobals.sAmbient.iEpsilonLastEmailSentDay + 14) % GET_NUMBER_OF_DAYS_IN_MONTH(INT_TO_ENUM(MONTH_OF_YEAR, GET_CLOCK_MONTH()), GET_CLOCK_YEAR()))
		iEmailTimer = GET_GAME_TIMER() + EMAIL_DELAY
	ENDIF
	
	RETURN ok
ENDFUNC

//----------------------
//	FUNCTIONS
//----------------------

PROC START_VEHICLE_DELIVERED_MESSAGE()
	iMidSizedMessageStage = 0
	
	//Set epsilon step stat
	INT iCurrent
	STAT_GET_INT(NUM_EPSILON_STEP,iCurrent)
	IF iCurrent < 6+GET_CARS_DELIVERED_COUNT()
		STAT_SET_INT(NUM_EPSILON_STEP,6+GET_CARS_DELIVERED_COUNT())
		SET_ACHIEVEMENT_PROGRESS_SAFE(ENUM_TO_INT(ACH20),6+GET_CARS_DELIVERED_COUNT())
	ENDIF
ENDPROC

/// PURPOSE:
// 		Print a message stating how many signs have been destroyed if this is needed...
// 		Now using the Midsized message UI as per Les request
/// PARAMS:
//		data 				- contains needed data
//		iMessageStage		- the stage of the message displaying (for the case statement)
//		siMessage			- scaleform index
//		sTitle				- the message string to display (e.g so many scraps collected/ destroyed)
PROC UPDATE_VEHICLE_DELIVERED_MESSAGE(SCALEFORM_INDEX &siMessage,  INT &iMessageTimer, INT &iMessageStage)
	INT iSplashSoundID

	SWITCH iMessageStage
		CASE 0
			siMessage = REQUEST_SCALEFORM_MOVIE("MIDSIZED_MESSAGE")
			IF HAS_SCALEFORM_MOVIE_LOADED(siMessage)
				iSplashSoundID = GET_SOUND_ID()
				PLAY_SOUND_FRONTEND(iSplashSoundID, "CHECKPOINT_UNDER_THE_BRIDGE", "HUD_MINI_GAME_SOUNDSET")
				iMessageStage++
			ENDIF
		BREAK
		CASE 1
			BEGIN_SCALEFORM_MOVIE_METHOD(siMessage, "SHOW_SHARD_MIDSIZED_MESSAGE")
				BEGIN_TEXT_COMMAND_SCALEFORM_STRING("EPS_CAR_TITLE")
				END_TEXT_COMMAND_SCALEFORM_STRING()
				BEGIN_TEXT_COMMAND_SCALEFORM_STRING("EPS_CAR_NOTE")
					ADD_TEXT_COMPONENT_INTEGER(GET_CARS_DELIVERED_COUNT())
				END_TEXT_COMMAND_SCALEFORM_STRING()
			END_SCALEFORM_MOVIE_METHOD()
			iMessageTimer = GET_GAME_TIMER()
			iMessageStage++
		BREAK
		CASE 2
			IF (GET_GAME_TIMER() - iMessageTimer) > DEFAULT_GOD_TEXT_TIME - 500
				BEGIN_SCALEFORM_MOVIE_METHOD(siMessage, "SHARD_ANIM_OUT")
					SCALEFORM_MOVIE_METHOD_ADD_PARAM_INT(ENUM_TO_INT(HUD_COLOUR_WHITE))
					SCALEFORM_MOVIE_METHOD_ADD_PARAM_FLOAT(0.33)
				END_SCALEFORM_MOVIE_METHOD()
				iMessageStage++
			ELSE
				IF NOT IS_RESULT_SCREEN_DISPLAYING()
					IF HAS_SCALEFORM_MOVIE_LOADED(siMessage)
						DRAW_SCALEFORM_MOVIE_FULLSCREEN(siMessage, 100, 100, 100, 255)
					ENDIF
				ENDIF
			ENDIF
		BREAK
		CASE 3
			IF (GET_GAME_TIMER() - iMessageTimer) > DEFAULT_GOD_TEXT_TIME
				iMessageStage++
			ELSE
				IF NOT IS_RESULT_SCREEN_DISPLAYING()
					IF HAS_SCALEFORM_MOVIE_LOADED(siMessage)
						DRAW_SCALEFORM_MOVIE_FULLSCREEN(siMessage, 100, 100, 100, 255)
					ENDIF
				ENDIF
			ENDIF
		BREAK
		CASE 4
			IF HAS_SCALEFORM_MOVIE_LOADED(siMessage)
				SET_SCALEFORM_MOVIE_AS_NO_LONGER_NEEDED(siMessage)
			ENDIF
			iMessageStage = NO_MIDSIZED_MESSAGE
		BREAK
		CASE NO_MIDSIZED_MESSAGE
		BREAK
	ENDSWITCH
ENDPROC



//----------------------
//	EMAIL FUNCTIONS
//----------------------
FUNC STRING GET_VEHICLE_TEXT_KEY_FROM_INDEX(MODEL_NAMES mdl)
	IF (mdl = carModels[0])
		RETURN "EPS_CARNME_0"
	ENDIF

	IF (mdl = carModels[1])
		RETURN "EPS_CARNME_1"
	ENDIF

	IF (mdl = carModels[2])
		RETURN "EPS_CARNME_2"
	ENDIF

	IF (mdl = carModels[3])
		RETURN "EPS_CARNME_3"
	ENDIF

	IF (mdl = carModels[4])
		RETURN "EPS_CARNME_4"
	ENDIF
	
	SCRIPT_ASSERT("THE LIST OF VEHICLES HAS CHANGED")
	RETURN "EPS_CARNME_N"
ENDFUNC


PROC SEND_INITIAL_EMAIL()
	// setup first e-mail detialing cars
	INT i

	CPRINTLN(DEBUG_AMBIENT, "SENDING INITIAL E-MAIL")
	FIRE_EMAIL_INTO_DYNAMIC_THREAD(DYNAMIC_THREAD_EPSILON3, CULTINITIAL, TRUE)//bool added to denote that you're about to override the content
	OVERRIDE_CONTENT_FOR_DYNAMIC_THREAD(DYNAMIC_THREAD_EPSILON3, "EPS_GMAIL_G5", FALSE)

	REPEAT COUNT_OF (carModels) i
		ADD_CONTENT_FOR_DYNAMIC_THREAD_SUBSTRING(DYNAMIC_THREAD_EPSILON3, GET_VEHICLE_TEXT_KEY_FROM_INDEX(carModels[i]))
		#IF IS_DEBUG_BUILD
			CPRINTLN(DEBUG_AMBIENT, "ADDING STRING:", GET_MODEL_NAME_FOR_DEBUG(carModels[i]))
		#ENDIF
	ENDREPEAT
	
	PUSH_FEEDIFICATION_OF_DYNAMIC_THREAD(DYNAMIC_THREAD_EPSILON3)
	g_savedGlobals.sAmbient.iEpsilonLastEmailSentDay = GET_CLOCK_DAY_OF_MONTH()
ENDPROC

PROC SEND_EMAIL_FOR_CARS_LEFT(INT i)
	// setup first e-mail detialing cars
	INT iCarsLeft
	IF (i <= 0)
		EXIT
	ENDIF

	CPRINTLN(DEBUG_AMBIENT, "CARS LEFT:", i)
	CPRINTLN(DEBUG_AMBIENT, "EMAIL INDEX:", MAX_CARS - i)
	FIRE_EMAIL_INTO_DYNAMIC_THREAD(DYNAMIC_THREAD_EPSILON3, eMailHelper[MAX_CARS - i].eMailID,TRUE)//bool added to denote that you're about to override the content
	
	IF (IS_CAR_INDEX_CONDITION_BAD(iLastIndexDelivered)) 
		OVERRIDE_CONTENT_FOR_DYNAMIC_THREAD(DYNAMIC_THREAD_EPSILON3, eMailHelper[MAX_CARS - i].sEmailBadBody,FALSE)
	ELSE
		OVERRIDE_CONTENT_FOR_DYNAMIC_THREAD(DYNAMIC_THREAD_EPSILON3, eMailHelper[MAX_CARS - i].sEmailBody,FALSE)
	ENDIF	
	
	i = 0
	iCarsLeft = 0
	REPEAT COUNT_OF (carModels) i
		IF NOT IS_CAR_INDEX_DELIVERED(i)
			ADD_CONTENT_FOR_DYNAMIC_THREAD_SUBSTRING(DYNAMIC_THREAD_EPSILON3, GET_VEHICLE_TEXT_KEY_FROM_INDEX(carModels[i]))
			
			#IF IS_DEBUG_BUILD
				CPRINTLN(DEBUG_AMBIENT, "ADDING STRING:", GET_MODEL_NAME_FOR_DEBUG(carModels[i]))
			#ENDIF
			
			iCarsLeft ++
		ENDIF
	ENDREPEAT
	
	PUSH_FEEDIFICATION_OF_DYNAMIC_THREAD(DYNAMIC_THREAD_EPSILON3)
	g_savedGlobals.sAmbient.iEpsilonLastEmailSentDay = GET_CLOCK_DAY_OF_MONTH()
	
	// just to stop the release build from crting
	IF (iCarsLeft = 0)
	ENDIF
	
	#IF IS_DEBUG_BUILD
		i = 0
		REPEAT (MAX_CARS - iCarsLeft) i
			CPRINTLN(DEBUG_AMBIENT, "SANITY CHECK")
		ENDREPEAT	
	#ENDIF
ENDPROC

//----------------------
//	STATE FUNCTIONS
//----------------------
PROC SET_MISSION_STATE(STAGE_ENUM in)
	// Setup new mission state
	stageEnum = in
	stageProgress = SP_SETUP
ENDPROC

/// PURPOSE: Triggers the mocap cutscene and completes mission once finished
PROC UPDATE_STATE_GET_VEHICLE(STAGE_PROGRESS &prog)
	SWITCH (prog)
		CASE SP_SETUP
			CPRINTLN(DEBUG_AMBIENT, "Eps Cars: In GET_VEHICLE")
			prog = SP_RUNNING
			bHelpDisplayed = FALSE
			
			bMessHelpDisplayed = FALSE
			SAFE_REMOVE_BLIP(vLocationBlip)
		BREAK
		CASE SP_RUNNING
			
			// Fix for B*2202890 - quicksave saved player's position inside the garage while no car was around to keep the garage door open
			// You shouldn't be able to get in here without a vehicle anyway so if you're in this area and still "looking for a car", something's gone wrong
			IF IS_ENTITY_ALIVE(PLAYER_PED_ID())
				IF IS_ENTITY_IN_ANGLED_AREA(PLAYER_PED_ID(), dropOffGarage.garageArea.vPosition[0], dropOffGarage.garageArea.vPosition[1], dropOffGarage.garageArea.fWidth)
				AND HAS_GARAGE_HELPER_FINISHED_CLOSING(dropOffGarage)
					CPRINTLN(DEBUG_AMBIENT, "EPSCARS.SC - Player was inside garage when door was closed and trying to get a vehicle... teleporting player!")
					SET_ENTITY_COORDS(PLAYER_PED_ID(), <<-687.6668, 500.5980, 109.0364>>)
					SET_ENTITY_HEADING(PLAYER_PED_ID(), 200.7367)
				ENDIF
			ENDIF
			
			IF (GET_DISTANCE_BETWEEN_ENTITY_AND_COORD(PLAYER_PED_ID(), dropOffGarage.vDoorPosition, FALSE) > (DOOR_DIST_THRESHOLD + 5.0))
				SET_DESIRED_GARAGE_HELPER_STATE(dropOffGarage, GDS_CLOSED)
				IF dropOffGarage.doorState != GDS_CLOSED // Prevents the garage door update from constantly trying to close the door when you're close to it
					dropOffGarage.doorState = GDS_CLOSING
				ENDIF
			ENDIF
					
			IF IS_PLAYER_IN_ANY_UNDELIVERED_CAR()
				IF (GET_PLAYER_WANTED_LEVEL(PLAYER_ID()) > 0)
					SET_MISSION_STATE(SE_PLAYER_WANTED)
					EXIT
				ENDIF
				
				prog = SP_CLEANUP
				EXIT
			ENDIF
		BREAK
		CASE SP_CLEANUP
			IF (bHelpDisplayed = FALSE)
			AND IS_ENTITY_ALIVE(PLAYER_PED_ID())
				IF (currentEpsilonVehicle <> GET_VEHICLE_PED_IS_IN(PLAYER_PED_ID(), TRUE))				
					currentEpsilonVehicle = GET_VEHICLE_PED_IS_IN(PLAYER_PED_ID(), TRUE)
					PRINT_HELP("EPS_DROP_HELP")
					bHelpDisplayed = TRUE
					
				ENDIF
				
			ENDIF

			bDmgHelpDisplayed = FALSE
			SET_MISSION_STATE(SE_APPROACH_GARAGE)
		BREAK
	ENDSWITCH
ENDPROC

/// PURPOSE:
///    Update Delivery
/// PARAMS:
///    prog - stage 
PROC UPDATE_STATE_PLAYER_WANTED(STAGE_PROGRESS &prog)
	SWITCH (prog)
		CASE SP_SETUP
			CPRINTLN(DEBUG_AMBIENT, "Eps Cars: In PLAYER_WANTED")
			SAFE_REMOVE_BLIP(vLocationBlip)
			IF bBeenWanted = FALSE
				PRINT_HELP("EPS_DROP_WANTED")
			ENDIF
			prog = SP_RUNNING
		BREAK
		CASE SP_RUNNING
			IF GET_PLAYER_WANTED_LEVEL(PLAYER_ID()) = 0
				prog = SP_CLEANUP
			ENDIF
		BREAK
		CASE SP_CLEANUP
			IF NOT IS_PLAYER_IN_ANY_UNDELIVERED_CAR()
				SET_MISSION_STATE(SE_GET_VEHICLE)
			ELSE
				IF bBeenWanted = FALSE
					PRINT_HELP("EPS_DROP_ESCAPE")
				ENDIF
				
				SET_MISSION_STATE(SE_DELIVER_VEHICLE)
			ENDIF
			
			bBeenWanted = TRUE
		BREAK
	ENDSWITCH
ENDPROC

/// PURPOSE:
///    Update Delivery
/// PARAMS:
///    prog - stage 
PROC UPDATE_STATE_VEHICLE_OCCUPIED(STAGE_PROGRESS &prog)
	VEHICLE_INDEX veh
	
	SWITCH (prog)
		CASE SP_SETUP
			CPRINTLN(DEBUG_AMBIENT, "Eps Cars: In VEHICLE_OCCUPIED")
			SAFE_REMOVE_BLIP(vLocationBlip)
			PRINT_HELP("EPS_DROP_PERSON")
			prog = SP_RUNNING
		BREAK
		CASE SP_RUNNING
			IF NOT IS_PLAYER_IN_ANY_UNDELIVERED_CAR()
				prog = SP_CLEANUP
				EXIT
			ENDIF
			
			IF IS_PED_IN_ANY_VEHICLE(PLAYER_PED_ID(), TRUE)
				veh = GET_VEHICLE_PED_IS_IN(PLAYER_PED_ID(), TRUE)
				IF IS_ENTITY_OK(veh) 
					IF (GET_VEHICLE_NUMBER_OF_PASSENGERS(veh) = 0)
						prog = SP_CLEANUP
					ENDIF
				ENDIF
			ENDIF
		BREAK
		CASE SP_CLEANUP
			IF NOT IS_PLAYER_IN_ANY_UNDELIVERED_CAR()
				SET_MISSION_STATE(SE_GET_VEHICLE)
			ELSE
				PRINT_HELP("EPS_DROP_ESCAPE")
				SET_MISSION_STATE(SE_DELIVER_VEHICLE)
			ENDIF
		BREAK
	ENDSWITCH
ENDPROC

/// PURPOSE:
///    Update Delivery
/// PARAMS:
///    prog - stage 
PROC UPDATE_STATE_APPROACH_GARAGE(STAGE_PROGRESS &prog)
	VEHICLE_INDEX veh
	
	SWITCH (prog)
		CASE SP_SETUP
			CPRINTLN(DEBUG_AMBIENT, "Eps Cars: In APPROACH_GARAGE")
			IF NOT DOES_BLIP_EXIST(vLocationBlip)
				vLocationBlip = ADD_BLIP_FOR_COORD(vDropOffPoint)
				IF DOES_BLIP_EXIST(vLocationBlip)
					SET_BLIP_SPRITE(vLocationBlip, RADAR_TRACE_EPSILON)
					SET_BLIP_COLOUR(vLocationBlip, BLIP_COLOUR_MICHAEL)					
				ENDIF
			ENDIF
			prog = SP_RUNNING
			iSubState = 0
		BREAK
		CASE SP_RUNNING		
			IF NOT IS_PLAYER_IN_ANY_UNDELIVERED_CAR()
				SET_MISSION_STATE(SE_GET_VEHICLE)
				EXIT 
			ENDIF

			IF (GET_PLAYER_WANTED_LEVEL(PLAYER_ID()) > 0)
				SET_MISSION_STATE(SE_PLAYER_WANTED)
				EXIT
			ENDIF
			
			IF IS_ENTITY_ALIVE(PLAYER_PED_ID())
			AND IS_PED_IN_ANY_VEHICLE(PLAYER_PED_ID(), TRUE)
				veh = GET_VEHICLE_PED_IS_IN(PLAYER_PED_ID(), TRUE)
			ENDIF
			
			IF IS_ENTITY_OK(veh) AND (GET_VEHICLE_NUMBER_OF_PASSENGERS(veh) > 0)
				IF GET_PED_IN_VEHICLE_SEAT(veh, VS_FRONT_RIGHT) <> PLAYER_PED_ID()
					SET_MISSION_STATE(SE_VEHICLE_OCCUPIED)
					EXIT
				ENDIF
			ENDIF
			
			IF (GET_DISTANCE_BETWEEN_ENTITY_AND_COORD(PLAYER_PED_ID(), dropOffGarage.vDoorPosition, FALSE) < DOOR_DIST_THRESHOLD)
				prog = SP_CLEANUP
				EXIT 
			ENDIF
		BREAK
		CASE SP_CLEANUP
			SET_MISSION_STATE(SE_DELIVER_VEHICLE)
		BREAK
	ENDSWITCH
ENDPROC

/// PURPOSE:
///    Update Delivery
/// PARAMS:
///    prog - stage 
PROC UPDATE_STATE_DELIVER_VEHICLE(STAGE_PROGRESS &prog)
	VEHICLE_INDEX veh
	
	SWITCH (prog)
		CASE SP_SETUP
			CPRINTLN(DEBUG_AMBIENT, "Eps Cars: In DELIVER_VEHICLE")
			SET_DESIRED_GARAGE_HELPER_STATE(dropOffGarage, GDS_OPEN)
			dropOffGarage.doorState = GDS_OPENING
			
			IF IS_PED_IN_ANY_VEHICLE(PLAYER_PED_ID()) 
				STOP_FIRE_IN_RANGE(GET_ENTITY_COORDS(PLAYER_PED_ID()), 1.5) 
			ENDIF
			
			prog = SP_RUNNING
			iSubState = 0
			iBlockedTimer = 0
		BREAK
		CASE SP_RUNNING	
			SWITCH (iSubState)
				CASE 0 // wait for player to get in range
					IF (bMessHelpDisplayed = TRUE) AND NOT (dropOffGarage.bIsBlocked)
						IF IS_THIS_HELP_MESSAGE_BEING_DISPLAYED("EPS_DROP_MESS")
							CLEAR_HELP()
						ENDIF
					ENDIF
					
					IF (GET_PLAYER_WANTED_LEVEL(PLAYER_ID()) > 0)
						SET_MISSION_STATE(SE_PLAYER_WANTED)
						EXIT
					ENDIF
					
					IF IS_ENTITY_ALIVE(PLAYER_PED_ID())
					AND IS_PED_IN_ANY_VEHICLE(PLAYER_PED_ID())
						veh = GET_VEHICLE_PED_IS_IN(PLAYER_PED_ID(), TRUE)
					ENDIF
					IF IS_ENTITY_OK(veh) AND (GET_VEHICLE_NUMBER_OF_PASSENGERS(veh) > 0)
						IF GET_PED_IN_VEHICLE_SEAT(veh, VS_FRONT_RIGHT) <> PLAYER_PED_ID()
							SET_MISSION_STATE(SE_VEHICLE_OCCUPIED)
							EXIT
						ENDIF
					ENDIF
			
					IF NOT (dropOffGarage.bIsBlocked)
						IF bExitCarHelpDisplayed = FALSE
							IF IS_VEHICLE_OK(veh)
								IF IS_ENTITY_IN_ANGLED_AREA(veh, dropOffGarage.garageArea.vPosition[0], dropOffGarage.garageArea.vPosition[1], dropOffGarage.garageArea.fWidth)
									PRINT_NOW("EPS_DROP_EXIT", DEFAULT_GOD_TEXT_TIME, 1)
									iBlockedTimer = 0
									bExitCarHelpDisplayed = TRUE
									bMessHelpDisplayed = FALSE
								ENDIF
							ENDIF
						ENDIF
						
						IF (GET_DISTANCE_BETWEEN_ENTITY_AND_COORD(PLAYER_PED_ID(), dropOffGarage.vCenterPosition, FALSE) < 3.0)
							SAFE_REMOVE_BLIP(vLocationBlip)
						ENDIF
						
						IF (GET_DISTANCE_BETWEEN_ENTITY_AND_COORD(PLAYER_PED_ID(), dropOffGarage.vDoorPosition, FALSE) > (DOOR_DIST_THRESHOLD + 5.0))
							SET_DESIRED_GARAGE_HELPER_STATE(dropOffGarage, GDS_CLOSED)
							dropOffGarage.doorState = GDS_CLOSING
							bExitCarHelpDisplayed = FALSE
							bMessHelpDisplayed = FALSE
							iBlockedTimer = 0
							SET_MISSION_STATE(SE_APPROACH_GARAGE)
							EXIT
						ENDIF
		
						IF IS_PLAYER_CLEAR_OF_GARAGE(dropOffGarage) AND NOT IS_PED_IN_ANY_VEHICLE(PLAYER_PED_ID())
							SET_DESIRED_GARAGE_HELPER_STATE(dropOffGarage, GDS_CLOSED)
							dropOffGarage.doorState = GDS_CLOSING
							iBlockedTimer = 0
							SET_MISSION_STATE(SE_GET_VEHICLE)

							EXIT 
						ENDIF
					ENDIF
					
					IF (dropOffGarage.bIsBlocked)
					AND NOT IS_PED_IN_ANY_VEHICLE(PLAYER_PED_ID())
					AND IS_PED_ON_FOOT(PLAYER_PED_ID())
						IF iBlockedTimer = 0
							iBlockedTimer = GET_GAME_TIMER()
						ELIF (GET_GAME_TIMER() - iBlockedTimer) > 500
							IF (bMessHelpDisplayed = FALSE)
								CLEAR_PRINTS()
								PRINT_HELP("EPS_DROP_MESS")
								CPRINTLN(DEBUG_AMBIENT, "CLEAR STUFF AWAY FROM THE GARAGE")
								bMessHelpDisplayed = TRUE
								bExitCarHelpDisplayed = FALSE
							ENDIF
						ENDIF
					ENDIF
				BREAK
			ENDSWITCH
		BREAK
	ENDSWITCH			
ENDPROC

//----------------------
//	DEBUG FUNCTIONS
//----------------------
#IF IS_DEBUG_BUILD

/// PURPOSE:
///    Setups Debug Widgets
PROC SETUP_DEBUG_WIDGETS()
	INT i 
	
	mWidgetGroup = START_WIDGET_GROUP("Epsilon Cargrab Controller")	
		ADD_WIDGET_BOOL("Quit Win Script", bForceQuitWin)
		ADD_WIDGET_BOOL("Quit Fail Script", bForceQuitWin)
		ADD_WIDGET_BOOL("Warp To Garage", bWarpToGarage)
		ADD_WIDGET_BOOL("Show Debug Stuff", bShowDebugStuff)
		ADD_WIDGET_BOOL("Create Dude", bCreatePedInCar)
		
		START_WIDGET_GROUP("Door Stuff")
			ADD_WIDGET_BOOL("Open Door", bTestOpenDoor)
			ADD_WIDGET_BOOL("Close Door", bTestCloseDoor)
			ADD_WIDGET_BOOL("Is In Stop Area", bIsInStopArea)
			ADD_WIDGET_BOOL("Garage Occupied", bIsGarageOccupied)
			ADD_WIDGET_BOOL("Door Blocked", bIsDoorBlocked)
			ADD_WIDGET_BOOL("Help Displayed", bHelpDisplayed)
			ADD_WIDGET_BOOL("Damage Help Displayed", bDmgHelpDisplayed)
		STOP_WIDGET_GROUP()
		
		START_WIDGET_GROUP("Blip Display")
			ADD_WIDGET_BOOL("Blip Route", bBlipDropOffPoint)
			ADD_WIDGET_BOOL("Show Vehicle Gens", bShowVehicleGens)
			ADD_WIDGET_BOOL("Hide Vehicle Gens", bHideVehicleGens)
			ADD_WIDGET_BOOL("Hide Vehicle Gen Surano", bHideVehicleGenSurano)
			ADD_WIDGET_BOOL("Hide Vehicle Gen SuperD", bHideVehicleGenSuperD)
			ADD_WIDGET_BOOL("Hide Vehicle Gen Carbon", bHideVehicleGenCarbon)
			ADD_WIDGET_BOOL("Hide Vehicle Gen Vacca", bHideVehicleGenVacca)
			ADD_WIDGET_BOOL("Hide Vehicle Gen Tornado", bHideVehicleGenTornado)
		STOP_WIDGET_GROUP()

		START_WIDGET_GROUP("E-Mail")
			ADD_WIDGET_BOOL("Advance Time", bAdvanceTime)
			ADD_WIDGET_BOOL("Send Test E-Mail", bSendTestEmail)
			ADD_WIDGET_INT_SLIDER("E-Mail Delay Timer", EMAIL_DELAY, 0, 60000, 1000 )
			ADD_WIDGET_INT_SLIDER("Fake Cars Left Count", iFakeCarsLeftCount, 0, MAX_CARS, 1 )
			
			ADD_WIDGET_INT_READ_ONLY("Day E-Mail Sent", g_savedGlobals.sAmbient.iEpsilonLastEmailSentDay)
			ADD_WIDGET_INT_READ_ONLY("Current Day", iCurrentDay)
			ADD_WIDGET_INT_READ_ONLY("Next E-Mail Day", iNextDay)
		STOP_WIDGET_GROUP()
		
		START_WIDGET_GROUP("Stats")
			ADD_WIDGET_INT_READ_ONLY("Vehicle HP", iCarHP)
			ADD_WIDGET_INT_READ_ONLY("Vehicle Broke Parts", iCarBrokeParts)
			ADD_WIDGET_INT_READ_ONLY("Vehicle Loose Parts", iCarLooseParts)
			ADD_WIDGET_FLOAT_READ_ONLY("Door Ratio", dropOffGarage.fDoorRatio)
			ADD_WIDGET_INT_READ_ONLY("Last Index Delivered", iLastIndexDelivered)
			ADD_WIDGET_FLOAT_READ_ONLY("Player to Door", fDistDoor)
			ADD_WIDGET_FLOAT_READ_ONLY("Player to Center", fDistCenter)
			ADD_WIDGET_INT_READ_ONLY("Last Index Delivered", iLastIndexDelivered)
			ADD_WIDGET_FLOAT_READ_ONLY("Player to Door", fDistDoor)
			ADD_WIDGET_FLOAT_READ_ONLY("Player to Center", fDistCenter)
			ADD_WIDGET_INT_READ_ONLY("Mission State", iShowState)
			ADD_WIDGET_INT_READ_ONLY("Mission Sub State", iSubState)
		STOP_WIDGET_GROUP()
		
		START_WIDGET_GROUP("Collected Car List")
			REPEAT (COUNT_OF(carModels)) i
				ADD_WIDGET_BOOL(GET_MODEL_NAME_FOR_DEBUG(carModels[i]), bTempCarDelivered[i])
			ENDREPEAT
		STOP_WIDGET_GROUP()
		
		START_WIDGET_GROUP("Bad Car Condition List")
			REPEAT (COUNT_OF(carModels)) i
				ADD_WIDGET_BOOL(GET_MODEL_NAME_FOR_DEBUG(carModels[i]), bTempCarBadCondition[i])
			ENDREPEAT
		STOP_WIDGET_GROUP()
		
	STOP_WIDGET_GROUP()
ENDPROC

/// PURPOSE:
///    Updates all The Widgets
PROC UPDATE_DEBUG_WIDGETS()
	INT i
	VEHICLE_INDEX v 
	
	IF (bAdvanceTime)
		ADD_TO_CLOCK_TIME(4, 0, 0)
	ENDIF
	
	IF (bShowDebugStuff)
		DRAW_DEBUG_AREA(dropOffGarage.garageArea.vPosition[0], dropOffGarage.garageArea.vPosition[1], dropOffGarage.garageArea.fWidth)
		DRAW_DEBUG_CIRCLE(dropOffGarage.vCenterPosition, 3.0)
		DRAW_DEBUG_CIRCLE(dropOffGarage.vDoorEdge[0], 2.0)
		DRAW_DEBUG_CIRCLE(dropOffGarage.vDoorEdge[1], 2.0)
	ENDIF
	
	iShowState = ENUM_TO_INT(stageEnum)
	
	REPEAT MAX_CARS i
		bTempCarDelivered[i] = IS_CAR_INDEX_DELIVERED(i)
		bTempCarBadCondition[i] = IS_CAR_INDEX_CONDITION_BAD(i)
	ENDREPEAT
	
	IF (bCreatePedInCar)
	AND DOES_ENTITY_EXIST(PLAYER_PED_ID())
		IF IS_PED_IN_ANY_VEHICLE(PLAYER_PED_ID())
			IF IS_ENTITY_OK(GET_VEHICLE_PED_IS_IN(PLAYER_PED_ID(), TRUE))
				CREATE_PED_INSIDE_VEHICLE_AUTO_SEAT(GET_ENTITY_MODEL(PLAYER_PED_ID()), GET_VEHICLE_PED_IS_IN(PLAYER_PED_ID(), TRUE))
				bCreatePedInCar = FALSE
			ENDIF
		ENDIF
	ENDIF
	
	IF (bSendTestEmail)
		SEND_EMAIL_FOR_CARS_LEFT(iFakeCarsLeftCount)
		bSendTestEmail = FALSE
	ENDIF
	
	IF (bWarpToGarage)
		SAFE_TELEPORT_ENTITY(PLAYER_PED_ID(), <<-686.3673, 499.3271, 109.0014>>, 16.6346)
		bWarpToGarage = FALSE 
	ENDIF
	
	bIsDoorBlocked = dropOffGarage.bIsBlocked
	
	IF (bShowVehicleGens) OR (bHideVehicleGens)
	 	i = 0
		REPEAT COUNT_OF(vVehicleGenBlip) i 
			SAFE_REMOVE_BLIP(vVehicleGenBlip[i])
		ENDREPEAT
		
		bHideVehicleGens = FALSE
	ENDIF
	
	IF (bBlipDropOffPoint)
		SAFE_REMOVE_BLIP(blipDropOff)
		blipDropOff = CREATE_COORD_BLIP(dropOffGarage.vCenterPosition, BLIPPRIORITY_MED, TRUE)
		bBlipDropOffPoint = FALSE
	ENDIF
	
	IF (bShowVehicleGens)
		IF (NOT bHideVehicleGenVacca)
			vVehicleGenBlip[0] = CREATE_COORD_BLIP(GET_VEHICLE_GEN_COORDS(VEHGEN_EPS3_VACCA), BLIPPRIORITY_MED, FALSE)
		ENDIF
		
		IF (NOT bHideVehicleGenVacca)
			vVehicleGenBlip[1] = CREATE_COORD_BLIP(GET_VEHICLE_GEN_COORDS(VEHGEN_EPS3_SURANO), BLIPPRIORITY_MED, FALSE)
		ENDIF
		
		IF (NOT bHideVehicleGenTornado)		
			vVehicleGenBlip[2] = CREATE_COORD_BLIP(GET_VEHICLE_GEN_COORDS(VEHGEN_EPS3_TORNADO2), BLIPPRIORITY_MED, FALSE)
		ENDIF
		
		IF (NOT bHideVehicleGenSuperD)	
			vVehicleGenBlip[3] = CREATE_COORD_BLIP(GET_VEHICLE_GEN_COORDS(VEHGEN_EPS3_SUPERD), BLIPPRIORITY_MED, FALSE)
		ENDIF
		
		IF (NOT bHideVehicleGenCarbon)
			vVehicleGenBlip[4] = CREATE_COORD_BLIP(GET_VEHICLE_GEN_COORDS(VEHGEN_EPS3_DOUBLE), BLIPPRIORITY_MED, FALSE)
			vVehicleGenBlip[5] = CREATE_COORD_BLIP(GET_VEHICLE_GEN_COORDS(VEHGEN_EPS3_DOUBLE_2), BLIPPRIORITY_MED, FALSE)
			vVehicleGenBlip[6] = CREATE_COORD_BLIP(GET_VEHICLE_GEN_COORDS(VEHGEN_EPS3_DOUBLE_3), BLIPPRIORITY_MED, FALSE)
		ENDIF
		
		bShowVehicleGens = FALSE
	ENDIF
	
	IF (bTestOpenDoor)
		SET_DESIRED_GARAGE_HELPER_STATE(dropOffGarage, GDS_OPEN)
		dropOffGarage.doorState = GDS_OPENING
		bTestOpenDoor = FALSE
	ENDIF
	
	IF (bTestCloseDoor)
		SET_DESIRED_GARAGE_HELPER_STATE(dropOffGarage, GDS_CLOSED)
		dropOffGarage.doorState = GDS_OPENING
		bTestCloseDoor = FALSE
	ENDIF
	
	IF NOT IS_ENTITY_OK(PLAYER_PED_ID())
		EXIT
	ENDIF
	
	bIsInStopArea = FALSE
	IF IS_PED_IN_ANY_VEHICLE(PLAYER_PED_ID(), TRUE) 
		v = GET_VEHICLE_PED_IS_IN(PLAYER_PED_ID(), TRUE) 
		IF IS_ENTITY_OK(v) 
			bIsInStopArea = IS_ENTITY_IN_RANGE_COORDS(v, vDropOffPoint, 3.0)
		ENDIF
	ENDIF
	
	fDistDoor = GET_DISTANCE_BETWEEN_ENTITY_AND_COORD(PLAYER_PED_ID(), dropOffGarage.vDoorPosition, FALSE)
	fDistCenter = GET_DISTANCE_BETWEEN_ENTITY_AND_COORD(PLAYER_PED_ID(), dropOffGarage.vCenterPosition, FALSE)
	
	bIsGarageOccupied = IS_POSITION_OCCUPIED(vGarageSafePoint, 7.25, FALSE, FALSE, TRUE, FALSE, FALSE)

	iCarHP = 0
	IF IS_ENTITY_OK(PLAYER_PED_ID())
		IF IS_PED_IN_ANY_VEHICLE(PLAYER_PED_ID(), TRUE)
			VEHICLE_INDEX ind = GET_VEHICLE_PED_IS_IN(PLAYER_PED_ID(), TRUE)
			IF IS_ENTITY_OK(ind)
				iCarHP = GET_ENTITY_HEALTH(ind)
				iCarBrokeParts = GET_VEHICLE_NUM_OF_BROKEN_OFF_PARTS(ind)
				iCarLooseParts = GET_VEHICLE_NUM_OF_BROKEN_LOOSEN_PARTS(ind)
			ENDIF
		ENDIF
	ENDIF
ENDPROC

/// PURPOSE:
///    Cleans up All The Widgets
PROC CLEANUP_DEBUG_WIDGETS()
	INT i
	
 	i = 0
	REPEAT COUNT_OF(vVehicleGenBlip) i 
		SAFE_REMOVE_BLIP(vVehicleGenBlip[i])
	ENDREPEAT
		
	IF DOES_WIDGET_GROUP_EXIST(mWidgetGroup)
		DELETE_WIDGET_GROUP(mWidgetGroup)
	ENDIF
ENDPROC 
#ENDIF

//----------------------
//	SCRIPT FUNCTIONS
//----------------------

/// PURPOSE:
///    Loads Car Models
PROC REQUEST_CAR_MODELS()
	//INT i = 0
	
	carModels[0] = VACCA
	carModels[1] = SURANO
	carModels[2] = TORNADO2
	carModels[3] = SUPERD
	carModels[4] = DOUBLE
	
	eMailHelper[0].eMailID = CULT1
	eMailHelper[0].sEmailBody = "EPS_GMAIL_G5"
	eMailHelper[0].sEmailBadBody = "EPS_BMAIL_G5"
	
	eMailHelper[1].eMailID = CULT2
	eMailHelper[1].sEmailBody = "EPS_GMAIL_G4"
	eMailHelper[1].sEmailBadBody = "EPS_BMAIL_G4"
	
	eMailHelper[2].eMailID = CULT3
	eMailHelper[2].sEmailBody = "EPS_GMAIL_G3"
	eMailHelper[2].sEmailBadBody = "EPS_BMAIL_G3"
	
	eMailHelper[3].eMailID = CULT4
	eMailHelper[3].sEmailBody = "EPS_GMAIL_G2"
	eMailHelper[3].sEmailBadBody = "EPS_BMAIL_G2"
	
	eMailHelper[4].eMailID = CULT5
	eMailHelper[4].sEmailBody = "EPS_GMAIL_G1"
	eMailHelper[4].sEmailBadBody = "EPS_BMAIL_G1"
	
	/* DON'T REQUEST THE MODELS ANYMORE - B*1072740
	REPEAT MAX_CARS i
		IF NOT IS_BIT_SET(iCarsDelivered, i)
			SECURE_REQUEST_AND_LOAD_MODEL(carModels[i], FALSE)
		ENDIF
	ENDREPEAT
	 */
	 
	//SECURE_REQUEST_AND_LOAD_TEXTURE_DICT("Epsilon_Cars", TRUE)
ENDPROC

/// PURPOSE:
///    Turn on or off mission vehicle gens
/// PARAMS:
///    ok - 
PROC SET_MISSION_VEHICLE_GENS_AVAILABLE(BOOL ok)
	CPRINTLN(DEBUG_AMBIENT, "EPSCARS.SC - MISSION VEHICLE GENS ARE:", ok) 
	
	SET_VEHICLE_GEN_AVAILABLE(VEHGEN_EPS3_VACCA, ok)
	SET_VEHICLE_GEN_AVAILABLE(VEHGEN_EPS3_SURANO, ok)
	SET_VEHICLE_GEN_AVAILABLE(VEHGEN_EPS3_TORNADO2, ok)
	SET_VEHICLE_GEN_AVAILABLE(VEHGEN_EPS3_SUPERD, ok)
	SET_VEHICLE_GEN_AVAILABLE(VEHGEN_EPS3_DOUBLE, ok)
	SET_VEHICLE_GEN_AVAILABLE(VEHGEN_EPS3_DOUBLE_2, ok)
	SET_VEHICLE_GEN_AVAILABLE(VEHGEN_EPS3_DOUBLE_3, ok)
ENDPROC

/// PURPOSE:
///    Releases Car Models
PROC RELEASE_CAR_MODELS()
	INT i = 0
	REPEAT MAX_CARS i
		SET_MODEL_AS_NO_LONGER_NEEDED(carModels[i])
	ENDREPEAT

	//SECURE_UNLOAD_TEXTURE_DICT("Epsilon_Cars")
ENDPROC

/// PURPOSE:
///    Script Cleanup
PROC SCRIPT_CLEANUP()
	#IF IS_DEBUG_BUILD
		CLEANUP_DEBUG_WIDGETS()
	#ENDIF
	
	SAFE_REMOVE_BLIP(vLocationBlip)
	SET_MISSION_VEHICLE_GENS_AVAILABLE(FALSE)
	RELEASE_CAR_MODELS()
	FORCE_LOCK_GARAGE_HELPER(dropOffGarage)
	
	CPRINTLN(DEBUG_AMBIENT, "EPSCARS.SC - SCRIPT CLEANUP") 
	//RELEASE_DYNAMIC_THREAD_HOLD_ON_BUFFER(DYNAMIC_THREAD_EPSILON3)
	g_savedGlobals.sAmbient.iEpsilonCarStage = iCarsDelivered
	
	// Register completion stats when completing normally or via debug
	IF ARE_ALL_CARS_DELIVERED()
	OR GET_MISSION_FLOW_FLAG_STATE(FLOWFLAG_EPSILON_CARS_DONE) = TRUE
	
		CPRINTLN(DEBUG_AMBIENT, "EPSCARS.SC - ALL CARS DELIVERED - SET THE FLOW FLAG")
		
		// Set the flow flag so the Epsilon 4 mission can be started.
		Set_Mission_Flow_Flag_State(FLOWFLAG_EPSILON_CARS_DONE, TRUE)
	
		// No longer require the script to be relaunched when loading from a savegame.
		Remove_Script_From_Relaunch_List(LAUNCH_BIT_RC_AMB_EPSILON_CARS)
	ENDIF
	
	SET_ROADS_BACK_TO_ORIGINAL_IN_ANGLED_AREA(<<-683.450317,492.992249,108.873665>>, <<-688.835693,506.999664,112.192780>>, 11.250000)
	SET_ROADS_BACK_TO_ORIGINAL_IN_ANGLED_AREA(noGarageRoadArea.vPosition[0], noGarageRoadArea.vPosition[1], 8.250000)
	REMOVE_SCENARIO_BLOCKING_AREA(sScenarioBlockIndex)
	
	IF (sFormMidSized <> NULL)
		SET_SCALEFORM_MOVIE_AS_NO_LONGER_NEEDED(sFormMidSized)
		sFormMidSized = NULL
	ENDIF
	
	//Set epsilon step stat
	INT iCurrent
	STAT_GET_INT(NUM_EPSILON_STEP,iCurrent)
	IF iCurrent < 6+GET_CARS_DELIVERED_COUNT()
		STAT_SET_INT(NUM_EPSILON_STEP,6+GET_CARS_DELIVERED_COUNT())
		SET_ACHIEVEMENT_PROGRESS_SAFE(ENUM_TO_INT(ACH20),6+GET_CARS_DELIVERED_COUNT())
	ENDIF
	
	CPRINTLN(DEBUG_AMBIENT, "EPSCARS.SC - CARS DELIVERED:", GET_CARS_DELIVERED_COUNT())
	CPRINTLN(DEBUG_AMBIENT, "EPSCARS.SC - TERMINATING EPSCARS.SC AMBIENT SCRIPT") 
	TERMINATE_THIS_THREAD()
ENDPROC

PROC SCRIPT_RESUME()
	VECTOR vmin, vmax
	IF NOT IS_ENTITY_OK(PLAYER_PED_ID())
	ENDIF
				
	CPRINTLN(DEBUG_AMBIENT, "EPSCARS.SC - RESUMING EPSCARS.SC AMBIENT SCRIPT") 
	SET_ROADS_IN_ANGLED_AREA(<<-683.450317,492.992249,108.873665>>, <<-688.835693,506.999664,112.192780>>, 11.250000, FALSE, FALSE)
	CALCULATE_MIN_MAX_FROM_POSITION_AND_RADIUS(<<-688.5, 503.7, 110.2>>, 30.0, vmin, vmax)
	sScenarioBlockIndex = ADD_SCENARIO_BLOCKING_AREA(vmin, vmax)
	
	iCarsDelivered = g_savedGlobals.sAmbient.iEpsilonCarStage
	REQUEST_CAR_MODELS()
	
	IF ARE_ALL_CARS_DELIVERED()
		CPRINTLN(DEBUG_AMBIENT, "EPSCARS.SC - NUM OF DELIVERED CARS >= 5, CLEANUP SCRIPT SO FLOW FLAG IS SET")
		SCRIPT_CLEANUP()
	ENDIF
	
	SET_MISSION_VEHICLE_GENS_AVAILABLE(TRUE)
	
	// check to see if the thread already exists - if not send the email out
	IF (GET_DYNAMIC_EMAIL_THREAD_BUFFER_INDEX(DYNAMIC_THREAD_EPSILON3) = -1)
		SEND_EMAIL_FOR_CARS_LEFT(GET_CARS_LEFT_COUNT())
	ELSE
		CPRINTLN(DEBUG_AMBIENT, "EPSCARS.SC - E-MAIL ALREADY EXISTS IN THREAD") 
	ENDIF
	
	CPRINTLN(DEBUG_AMBIENT, "EPSCARS.SC - CARS DELIVERED:", GET_CARS_DELIVERED_COUNT())
	SET_MISSION_STATE(SE_GET_VEHICLE)
		
	#IF IS_DEBUG_BUILD
		UPDATE_DEBUG_WIDGETS()
		SETUP_DEBUG_WIDGETS()
	#ENDIF
ENDPROC

PROC SCRIPT_TIDY()
	CPRINTLN(DEBUG_AMBIENT, "EPSCARS.SC - TIDYING UP EPSCARS.SC AMBIENT SCRIPT FOR SUSPEND") 
	IF DOES_BLIP_EXIST(vLocationBlip)
		SAFE_REMOVE_BLIP(vLocationBlip)
		vLocationBlip = NULL
	ENDIF
			
	#IF IS_DEBUG_BUILD
		CLEANUP_DEBUG_WIDGETS()
	#ENDIF
	
	g_savedGlobals.sAmbient.iEpsilonCarStage = iCarsDelivered
	SAFE_REMOVE_BLIP(vLocationBlip)
	SET_MISSION_VEHICLE_GENS_AVAILABLE(FALSE)
	RELEASE_CAR_MODELS()
	FORCE_LOCK_GARAGE_HELPER(dropOffGarage)
	
	
	// turn road nodes in garage back on
	REMOVE_SCENARIO_BLOCKING_AREA(sScenarioBlockIndex)
	SET_ROADS_BACK_TO_ORIGINAL_IN_ANGLED_AREA(<<-683.450317,492.992249,108.873665>>, <<-688.835693,506.999664,112.192780>>, 11.250000)
	SET_ROADS_BACK_TO_ORIGINAL_IN_ANGLED_AREA(noGarageRoadArea.vPosition[0], noGarageRoadArea.vPosition[1], 8.250000)
ENDPROC

PROC SCRIPT_SUSPEND()
	CPRINTLN(DEBUG_AMBIENT, "EPSCARS.SC - SUSPENDING AMBIENT SCRIPT") 
	SCRIPT_TIDY()
	
	CPRINTLN(DEBUG_AMBIENT, "EPSCARS.SC - CARS DELIVERED:", GET_CARS_DELIVERED_COUNT())
	
	WHILE GET_MISSION_FLAG() OR (GET_CURRENT_PLAYER_PED_ENUM() <> CHAR_MICHAEL)
		WAIT(0)
	ENDWHILE
	SCRIPT_RESUME()
ENDPROC


SCRIPT 
	VECTOR vmin, vmax 
	
	CPRINTLN(DEBUG_AMBIENT, "EPSCARS.SC - INIT EPSCARS.SC AMBIENT SCRIPT")
	IF HAS_FORCE_CLEANUP_OCCURRED(FORCE_CLEANUP_FLAG_DEBUG_MENU|FORCE_CLEANUP_FLAG_SP_TO_MP|FORCE_CLEANUP_FLAG_DIRECTOR)
		SCRIPT_CLEANUP()
	ENDIF
	
	IF (GET_MISSION_FLOW_FLAG_STATE(FLOWFLAG_EPSILON_CARS_DONE) = TRUE)
		FORCE_ALL_CARS_DELIVERED()
		CPRINTLN(DEBUG_AMBIENT, "EPSCARS.SC - ALL CARS HAVE BEEN GOT BEFORE EXECUTING SCRIPT - TERMINATE")
		TERMINATE_THIS_THREAD()
	ENDIF
	
	// get the save number from save game
	iCarsDelivered = g_savedGlobals.sAmbient.iEpsilonCarStage
	
	// load cars and setup the mission
	REQUEST_CAR_MODELS()
	
	IF ARE_ALL_CARS_DELIVERED()
		CPRINTLN(DEBUG_AMBIENT, "EPSCARS.SC - NUM OF DELIVERED CARS >= 5, CLEANUP SCRIPT SO FLOW FLAG IS SET")
		SCRIPT_CLEANUP()
	ENDIF
	
	// Register the script so that it can be relaunched when loading from a savegame.
	Register_Script_To_Relaunch_List(LAUNCH_BIT_RC_AMB_EPSILON_CARS)
	
	CPRINTLN(DEBUG_AMBIENT, "EPSCARS.SC - STARTING EPSCARS.SC AMBIENT SCRIPT #:", XVERSION_NUMBER)

	SETUP_GARAGE_HELPER(dropOffGarage, PROP_CH2_09C_GARAGE_DOOR, <<-689.81, 510.34, 109.98>>, vDropOffPoint,
			 			<<-688.491882,507.254944,108.918564>>, <<-691.883484,516.268860,113.431572>>, 9.250000,
						//<<-689.047424,507.330627,109.364105>>, <<-691.816345,516.054688,112.113853>>, 8.000000,
						<<-687.455261,507.517944,109.363510>>, <<-690.948364,506.278290,109.363121>>)
						
	SET_DESIRED_GARAGE_HELPER_STATE(dropOffGarage, GDS_CLOSED)
	dropOffGarage.doorState = GDS_CLOSING
	CLEAR_AREA_OF_VEHICLES(vDropOffPoint, 5.0)
	
	// turn off road nodes around garage B*760390
	SET_ANGLED_AREA(noGarageRoadArea, <<-691.905884,515.824890,108.613853>>, <<-684.060547,493.017120,110.850395>>, 8.250000)
	SET_ROADS_IN_ANGLED_AREA(noGarageRoadArea.vPosition[0], noGarageRoadArea.vPosition[1], 8.250000, FALSE, FALSE)
	SET_ROADS_IN_ANGLED_AREA(<<-683.450317,492.992249,108.873665>>, <<-688.835693,506.999664,112.192780>>, 11.250000, FALSE, FALSE)
	
	CALCULATE_MIN_MAX_FROM_POSITION_AND_RADIUS(<<-688.5, 503.7, 110.2>>, 30.0, vmin, vmax)
	sScenarioBlockIndex = ADD_SCENARIO_BLOCKING_AREA(vmin, vmax)
	 
	/* waiting until auto save is done with
	CPRINTLN(DEBUG_AMBIENT, "EPSCARS.SC - INIT - WAITING TILL AUTO SAVE IS DONE") 
	WHILE IS_AUTOSAVE_REQUEST_IN_PROGRESS() OR IS_AUTO_SAVE_IN_PROGRESS()
		WAIT(0)
	ENDWHILE
	CPRINTLN(DEBUG_AMBIENT, "EPSCARS.SC - INIT - AUTO SAVE COMPLETE") 
	*/
	
	IF (GET_MISSION_FLOW_FLAG_STATE(FLOWFLAG_EPSILON_CARS_DONE) = TRUE)
		FORCE_ALL_CARS_DELIVERED()
		CPRINTLN(DEBUG_AMBIENT, "EPSCARS.SC - ALL CARS HAVE BEEN GOT BEFORE EXECUTING SCRIPT - TERMINATE")
		SCRIPT_CLEANUP()
	ENDIF
	
	#IF IS_DEBUG_BUILD
		SETUP_DEBUG_WIDGETS()
	#ENDIF
	
	IF (g_savedGlobals.sAmbient.iEpsilonLastEmailSentDay = 0)
		g_savedGlobals.sAmbient.iEpsilonLastEmailSentDay = GET_CLOCK_DAY_OF_MONTH()
	ENDIF
	
	 

	
	// also don't send out the e-mail if we are debug skipping
	// check to see if the thread already exists - if not send the email out
//	IF (GET_MISSION_FLOW_FLAG_STATE(FLOWFLAG_EPSILON_CARS_DONE) = FALSE)
//		IF (GET_DYNAMIC_EMAIL_THREAD_BUFFER_INDEX(DYNAMIC_THREAD_EPSILON3) = -1)
//			
//			primeEmail = TRUE
//			
//			#IF IS_DEBUG_BUILD
//				primeEmail = (g_flowUnsaved.bUpdatingGameflow = FALSE)
//			#ENDIF
//	
//			IF (primeEmail)
//				CPRINTLN(DEBUG_AMBIENT, "EPSCARS.SC - PRIMING E-MAIL")
//				ASSIGN_BUFFER_TO_DYNAMIC_EMAIL_THREAD(DYNAMIC_THREAD_EPSILON3)
//				
//				//FIRE_EMAIL_INTO_DYNAMIC_THREAD(DYNAMIC_THREAD_EPSILON3, CULTINITIAL)
//				//OVERRIDE_CONTENT_FOR_DYNAMIC_THREAD(DYNAMIC_THREAD_EPSILON3, "EPS_1STEMAIL")
//				
//				CPRINTLN(DEBUG_AMBIENT, "EPSCARS.SC - WAITING TO SEND")
//				
//				FIRE_EMAIL_INTO_DYNAMIC_THREAD(DYNAMIC_THREAD_EPSILON3, CULTINITIAL)
//				OVERRIDE_CONTENT_FOR_DYNAMIC_THREAD(DYNAMIC_THREAD_EPSILON3, "EPS_1STEMAIL")
//			ELSE
//				
//			ENDIF
//			bInitialEmailBuffer = TRUE
//			CPRINTLN(DEBUG_AMBIENT, "EPSCARS.SC - INITIAL E-MAIL SENT")
//		ELSE
//			CPRINTLN(DEBUG_AMBIENT, "EPSCARS.SC - EPSILON E-MAIL THREAD ALL READY EXISTS")
//		ENDIF
//	ENDIF
	
	SET_MISSION_VEHICLE_GENS_AVAILABLE(TRUE)
	SET_MISSION_STATE(SE_GET_VEHICLE)
	
	WHILE (TRUE)
		
		// Immediately cleanup if this script has been completed via debug
		IF GET_MISSION_FLOW_FLAG_STATE(FLOWFLAG_EPSILON_CARS_DONE) = TRUE
			FORCE_ALL_CARS_DELIVERED()
			SCRIPT_CLEANUP()
		ENDIF
		
		IS_ENTITY_OK(PLAYER_PED_ID())
		IF GET_MISSION_FLAG() OR (GET_CURRENT_PLAYER_PED_ENUM() <> CHAR_MICHAEL)
			SCRIPT_SUSPEND()
		ENDIF
	
		SWITCH (stageEnum)

			CASE SE_GET_VEHICLE
				UPDATE_STATE_GET_VEHICLE(stageProgress)
			BREAK
			CASE SE_PLAYER_WANTED
				UPDATE_STATE_PLAYER_WANTED(stageProgress)
			BREAK
			CASE SE_APPROACH_GARAGE
				UPDATE_STATE_APPROACH_GARAGE(stageProgress)
			BREAK
			CASE SE_DELIVER_VEHICLE
				UPDATE_STATE_DELIVER_VEHICLE(stageProgress)
			BREAK
			CASE SE_VEHICLE_OCCUPIED
				UPDATE_STATE_VEHICLE_OCCUPIED(stageProgress)
			BREAK
			CASE SE_MISSION_CLEAR
				FIRE_EMAIL_INTO_DYNAMIC_THREAD(DYNAMIC_THREAD_EPSILON3, CULTFINALE)
				OVERRIDE_CONTENT_FOR_DYNAMIC_THREAD(DYNAMIC_THREAD_EPSILON3, "EPS_LSTEMAIL")
				RELEASE_DYNAMIC_THREAD_HOLD_ON_BUFFER(DYNAMIC_THREAD_EPSILON3)
				//MISSION_FLOW_PLAY_END_OF_MISSION_MUSIC(TRUE)
				SCRIPT_CLEANUP()
			BREAK
		ENDSWITCH

		UPDATE_GARAGE_HELPER(dropOffGarage)

		IF HAS_GARAGE_HELPER_FINISHED_CLOSING(dropOffGarage)
			IF MARK_OFF_ANY_UNDELIVERED_CARS_IN_GARAGE(dropOffGarage)
				IF GET_LAST_DRIVEN_VEHICLE() = g_vCarToTrackForImpound
					CPRINTLN(DEBUG_AMBIENT, "Delivered car was being tracked for impound: cleared it")
					g_vCarToTrackForImpound = NULL
					g_savedGlobals.sVehicleGenData.bTrackingImpoundVehicle = FALSE
				ENDIF
				CLEAR_AREA_OF_VEHICLES(dropOffGarage.vCenterPosition, 8.5)
				g_savedGlobals.sAmbient.iEpsilonCarStage = iCarsDelivered
				MAKE_AUTOSAVE_REQUEST()
				
				ADD_PED_FOR_DIALOGUE(convoMichael, ENUM_TO_INT(CHAR_MICHAEL), PLAYER_PED_ID(), "MICHAEL")
				CREATE_CONVERSATION(convoMichael, "EPS3AUD", "EP3_MCS1", CONV_PRIORITY_LOW)
				
				/*
				BEGIN_TEXT_COMMAND_THEFEED_POST("EPS_CAR_NOTE")
				ADD_TEXT_COMPONENT_INTEGER(GET_CARS_DELIVERED_COUNT())
				END_TEXT_COMMAND_THEFEED_POST_TICKER(FALSE)
				*/
				IF IS_THIS_HELP_MESSAGE_BEING_DISPLAYED("EPS_DROP_HELP")
					CLEAR_HELP()
				ENDIF
				
				START_VEHICLE_DELIVERED_MESSAGE()
			ENDIF
		ENDIF
		
		IF (g_savedGlobals.sAmbient.iEpsilonLastEmailSentDay <> 0)
			iNextDay = (g_savedGlobals.sAmbient.iEpsilonLastEmailSentDay + 14) % GET_NUMBER_OF_DAYS_IN_MONTH(INT_TO_ENUM(MONTH_OF_YEAR, GET_CLOCK_MONTH()), GET_CLOCK_YEAR())
			IF (GET_CLOCK_DAY_OF_MONTH() = iNextDay)
			AND NOT IS_PHONE_ONSCREEN()
			AND NOT IS_PLAYER_DEAD(PLAYER_ID())
			AND IS_PLAYER_PLAYING(PLAYER_ID())
				CPRINTLN(DEBUG_AMBIENT, "TIME TO SEND OUT EMAIL")
				SEND_EMAIL_FOR_CARS_LEFT(GET_CARS_LEFT_COUNT())
			ENDIF
		ENDIF

		UPDATE_VEHICLE_DELIVERED_MESSAGE(sFormMidSized, iMidSizedMessageTimer, iMidSizedMessageStage)
		
		IF (iEmailTimer > 0) AND (GET_GAME_TIMER() > iEmailTimer) AND (iMidSizedMessageStage = NO_MIDSIZED_MESSAGE)
			iEmailTimer = 0
			
			IF ARE_ALL_CARS_DELIVERED()
				SET_MISSION_STATE(SE_MISSION_CLEAR)
			ENDIF
		ENDIF

		#IF IS_DEBUG_BUILD
			UPDATE_DEBUG_WIDGETS()
			
			// 'S' skip will pass the mission with all cars delivered
			#IF IS_DEBUG_BUILD
				IF (bForceQuitWin)
					FORCE_SET_ALL_CARS_DELIVERED()
					RELEASE_DYNAMIC_THREAD_HOLD_ON_BUFFER(DYNAMIC_THREAD_EPSILON3)
					SCRIPT_CLEANUP()
				ENDIF
				
				// fail the scripts and reset the save game value
				IF (bForceQuitFail)
					RELEASE_DYNAMIC_THREAD_HOLD_ON_BUFFER(DYNAMIC_THREAD_EPSILON3)
					iCarsDelivered = 0
					g_savedGlobals.sAmbient.iEpsilonCarStage = iCarsDelivered
					SCRIPT_CLEANUP()
				ENDIF
			#ENDIF
		#ENDIF
		WAIT(0)
	ENDWHILE
ENDSCRIPT