////////////////////////////////////////////////////////////////////
//                                                               //
// SCRIPT NAME     :    MP_Darts.sc                             //
// AUTHOR          :    Lino Manansala                         //
// DESCRIPTION     :    Multiplayer Darts      			      //
//                                                           //
//////////////////////////////////////////////////////////////

// GUIDE
// search for these and add bookmarks to make your life easier
// 
// #SPECTATE
// #NORMAL
// #THROWOFF
// #REALGAME
//

USING "net_mission.sch"
USING "net_hud_activating.sch"
USING "fmmc_restart_header.sch"
USING "net_celebration_screen.sch"

USING "Darts.sch"
USING "Darts_Core.sch"
USING "Darts_UI_lib.sch"

USING "MP_Darts.sch"
USING "MP_Darts_Client_lib.sch"
USING "MP_Darts_Server_lib.sch"
USING "MP_Darts_Broadcast_lib.sch"
USING "Darts_Leaderboard_lib.sch"
USING "fmmc_mp_setup_mission.sch"
USING "achievement_public.sch"

CONST_INT BASE_BULLSEYE_XP 	10 		// award for succesful bullseyes
CONST_INT BASE_LEG_WIN_XP 	50		// award for each leg win
CONST_INT BASE_MATCH_WIN_XP 250		// award for a total match win
CONST_INT BASE_DART_PLAY_XP 100		// award for participating

INT iSelfID, iOtherID
//INT iAllowSkipCutsceneTime
BOOL bSoloMP
BOOL bPlayerQuit

STRING sFacialDictPed
STRING sFacialClip[3]
STRING sFacialDictPed2
STRING sFacialClip2[3]

INT iNumberOfPlayers

CELEBRATION_SCREEN_DATA sCelebrationData
CAMERA_INDEX camEndScreen
CAMERA_INDEX renderingCam
CAMERA_INDEX ciDartsQuit
CAMERA_INDEX camDartsSync

SCRIPT_SHARD_BIG_MESSAGE shardBigMessage
SCRIPT_SHARD_BIG_MESSAGE shardMidSizeMessage



ENUM DART_PLAYER_POSITION
	DART_PLAYER_IN_POSITION,
	DART_PLAYER_OUT_POSITION
ENDENUM

#IF IS_DEBUG_BUILD
BOOL bDartsNoSocialClub
#ENDIF

PROC PRINT_WITH_NAME_AND_TWO_NUMBERS(STRING pTextLabel, STRING PlayerName, INT FirstNumberToInsert, INT SecondNumberToInsert, INT Duration, INT Colour)
	Colour = Colour
	BEGIN_TEXT_COMMAND_PRINT(pTextLabel)
//		IF NOT (Colour = HUD_COLOUR_PURE_WHITE)
//			SET_COLOUR_OF_NEXT_TEXT_COMPONENT(Colour)
//		ENDIF	
		ADD_TEXT_COMPONENT_SUBSTRING_PLAYER_NAME(PlayerName)
		ADD_TEXT_COMPONENT_INTEGER(FirstNumberToInsert)
		ADD_TEXT_COMPONENT_INTEGER(SecondNumberToInsert)
	END_TEXT_COMMAND_PRINT(Duration, TRUE)
ENDPROC

PROC PRINT_WITH_NAME(STRING pTextLabel, STRING PlayerName, INT Duration, INT Colour)
	Colour = Colour
	BEGIN_TEXT_COMMAND_PRINT(pTextLabel)
//		IF NOT (Colour = HUD_COLOUR_PURE_WHITE)
//			SET_COLOUR_OF_NEXT_TEXT_COMPONENT(Colour)
//		ENDIF	
		ADD_TEXT_COMPONENT_SUBSTRING_PLAYER_NAME(PlayerName)
	END_TEXT_COMMAND_PRINT(Duration, TRUE)
ENDPROC

PROC PRINT_WITH_NAME_AND_NUMBER(STRING pTextLabel, STRING PlayerName, INT NumberToInsert, INT Duration, INT Colour)
	Colour = Colour
	BEGIN_TEXT_COMMAND_PRINT(pTextLabel)
//		IF NOT (Colour = HUD_COLOUR_PURE_WHITE)
//			SET_COLOUR_OF_NEXT_TEXT_COMPONENT(Colour)
//		ENDIF	
		ADD_TEXT_COMPONENT_SUBSTRING_PLAYER_NAME(PlayerName)
		ADD_TEXT_COMPONENT_INTEGER(NumberToInsert)
	END_TEXT_COMMAND_PRINT(Duration, TRUE)
ENDPROC

PROC PRINT_WITH_TWO_NAMES_AND_NUMBER(STRING pTextLabel, STRING FirstPlayerName, STRING SecondPlayerName, INT NumberToInsert, INT Duration, INT Colour)
	Colour = Colour
	BEGIN_TEXT_COMMAND_PRINT(pTextLabel)
//		IF NOT (Colour = HUD_COLOUR_PURE_WHITE)
//			SET_COLOUR_OF_NEXT_TEXT_COMPONENT(Colour)
//		ENDIF	
		ADD_TEXT_COMPONENT_SUBSTRING_PLAYER_NAME(FirstPlayerName)
		ADD_TEXT_COMPONENT_INTEGER(NumberToInsert)
		ADD_TEXT_COMPONENT_SUBSTRING_PLAYER_NAME(SecondPlayerName)
	END_TEXT_COMMAND_PRINT(Duration, TRUE)
ENDPROC

PROC PRINT_WITH_TWO_NAMES_AND_TWO_NUMBERS(STRING pTextLabel, STRING FirstPlayerName, STRING SecondPlayerName, INT FirstNumberToInsert, INT SecondNumberToInsert, INT Duration, INT Colour)
	Colour = Colour
	BEGIN_TEXT_COMMAND_PRINT(pTextLabel)
//		IF NOT (Colour = HUD_COLOUR_PURE_WHITE)
//			SET_COLOUR_OF_NEXT_TEXT_COMPONENT(Colour)
//		ENDIF	
		ADD_TEXT_COMPONENT_SUBSTRING_PLAYER_NAME(FirstPlayerName)
		ADD_TEXT_COMPONENT_INTEGER(FirstNumberToInsert)
		ADD_TEXT_COMPONENT_INTEGER(SecondNumberToInsert)
		ADD_TEXT_COMPONENT_SUBSTRING_PLAYER_NAME(SecondPlayerName)
	END_TEXT_COMMAND_PRINT(Duration, TRUE)
ENDPROC

/// PURPOSE:
///    how many participants are actually players?  rather then spectators or sctv
/// PARAMS:
///    bPrintDebugInfo - TRUE to show info about who's who, should not be set if this is getting called every frame
/// RETURNS:
///    
FUNC INT NETWORK_GET_NUM_PLAYERS(DARTS_PLAYER_BROADCAST_DATA & DartsPlayerData[DARTSMP_IDS], BOOL bPrintDebugInfo = FALSE) 
	INT iNumPlayers
	INT idx, iNumParticipants
	INT partID
	
	PARTICIPANT_INDEX participantID
	
	iNumParticipants = ENUM_TO_INT(DARTSMP_IDS)
	
	IF bPrintDebugInfo
	CDEBUG1LN(DEBUG_DARTS, "checking players, current participants = ", iNumParticipants)
	ENDIF
	
	// can't run a repeat method if there's only one participant, because the first participant gets id 1
	// this would work if it started at 0
	
	REPEAT iNumParticipants idx
		participantID = INT_TO_PARTICIPANTINDEX( idx )
		IF NETWORK_IS_PARTICIPANT_ACTIVE( participantID )
			IF IS_PLAYER_SCTV(NETWORK_GET_PLAYER_INDEX(participantID))
			OR DID_PLAYER_JOIN_MISSION_AS_SPECTATOR(NETWORK_GET_PLAYER_INDEX(participantID))
				IF IS_PLAYER_SCTV(NETWORK_GET_PLAYER_INDEX(participantID))
					IF bPrintDebugInfo
						partID = DartsPlayerData[idx].iParticipantID
						CDEBUG1LN(DEBUG_DARTS, "this participant is sctv: ", DartsPlayerData[idx].iParticipantID)
						IF partID = idx
							CDEBUG1LN(DEBUG_DARTS, "partID = idx")
						ENDIF
					ENDIF
				ENDIF
				IF DID_PLAYER_JOIN_MISSION_AS_SPECTATOR(NETWORK_GET_PLAYER_INDEX(participantID))
					IF bPrintDebugInfo
						CDEBUG1LN(DEBUG_DARTS, "this participant is spectator: ", DartsPlayerData[idx].iParticipantID)
					ENDIF
				ENDIF
			ELSE
				iNumPlayers++
				IF bPrintDebugInfo
					CDEBUG1LN(DEBUG_DARTS, "this participant is a player: ", DartsPlayerData[idx].iParticipantID)
					CDEBUG1LN(DEBUG_DARTS, "number of players: ", iNumPlayers)
				ENDIF
			ENDIF
		ENDIF
	ENDREPEAT
	
	RETURN iNumPlayers
ENDFUNC

/// PURPOSE:
///    how many participants are spectators?
/// PARAMS:
///    bPrintDebugInfo - TRUE to show info about who's who, should not be set if this is getting called every frame
/// RETURNS:
///    
FUNC INT NETWORK_GET_NUM_SPECTATORS(DARTS_PLAYER_BROADCAST_DATA & DartsPlayerData[DARTSMP_IDS], BOOL bPrintDebugInfo = FALSE) 
	INT iNumPlayers
	INT idx, iNumParticipants
	
	iNumParticipants = ENUM_TO_INT(DARTSMP_IDS)
	
	IF bPrintDebugInfo
		CDEBUG1LN(DEBUG_DARTS, "checking spectators, current participants = ", iNumParticipants)
	ENDIF
	
	REPEAT iNumParticipants idx
		IF DARTS_CHECK_CLIENT_FLAG(DartsPlayerData[idx], DARTS_CLIENTFLAG_PARTICIPANT_SET)
			IF IS_PLAYER_SCTV(NETWORK_GET_PLAYER_INDEX(INT_TO_PARTICIPANTINDEX(DartsPlayerData[idx].iParticipantID)))
			OR DID_PLAYER_JOIN_MISSION_AS_SPECTATOR(NETWORK_GET_PLAYER_INDEX(INT_TO_PARTICIPANTINDEX(DartsPlayerData[idx].iParticipantID)))
				IF DID_PLAYER_JOIN_MISSION_AS_SPECTATOR(NETWORK_GET_PLAYER_INDEX(INT_TO_PARTICIPANTINDEX(DartsPlayerData[idx].iParticipantID)))
					IF bPrintDebugInfo
						CDEBUG1LN(DEBUG_DARTS, "this participant is spectator: ", DartsPlayerData[idx].iParticipantID)
					ENDIF
					iNumPlayers++
				ENDIF
				IF IS_PLAYER_SCTV(NETWORK_GET_PLAYER_INDEX(INT_TO_PARTICIPANTINDEX(DartsPlayerData[idx].iParticipantID)))
					IF bPrintDebugInfo
						CDEBUG1LN(DEBUG_DARTS, "this participant is sctv: ", DartsPlayerData[idx].iParticipantID)
					ENDIF
					iNumPlayers--
				ENDIF
			ENDIF
		ENDIF
	ENDREPEAT
	
	RETURN iNumPlayers
ENDFUNC

/// PURPOSE:
///    how many participants are SCTV? not as important as players or spectators, but putting in place anyway
/// PARAMS:
///    bPrintDebugInfo - TRUE to show info about who's who, should not be set if this is getting called every frame
/// RETURNS:
///    
FUNC INT NETWORK_GET_NUM_SCTV(DARTS_PLAYER_BROADCAST_DATA & DartsPlayerData[DARTSMP_IDS], BOOL bPrintDebugInfo = FALSE) 
	INT iNumPlayers
	INT idx, iNumParticipants
	
	iNumParticipants = ENUM_TO_INT(DARTSMP_IDS)
	
	IF bPrintDebugInfo
		CDEBUG1LN(DEBUG_DARTS, "checking SCTV, current participants = ", iNumParticipants)
	ENDIF
	
	REPEAT iNumParticipants idx
		IF DARTS_CHECK_CLIENT_FLAG(DartsPlayerData[idx], DARTS_CLIENTFLAG_PARTICIPANT_SET)
			IF IS_PLAYER_SCTV(NETWORK_GET_PLAYER_INDEX(INT_TO_PARTICIPANTINDEX(idx)))
				IF bPrintDebugInfo
					CDEBUG1LN(DEBUG_DARTS, "this participant is sctv: ", idx)
				ENDIF
				iNumPlayers++
			ENDIF
		ENDIF
	ENDREPEAT
	
	RETURN iNumPlayers
ENDFUNC


FUNC INT DART_GET_OTHER_PLAYERS_ID(DARTS_PLAYER_BROADCAST_DATA & DartsPlayerData[DARTSMP_IDS], INT & returnID)
	INT myPartID
	INT idx, iNumParticipants, iMaxParticipants
	
	PARTICIPANT_INDEX participantID
	
	myPartID = PARTICIPANT_ID_TO_INT()
	
	iMaxParticipants = ENUM_TO_INT(DARTSMP_IDS)
	
	REPEAT iMaxParticipants idx
		participantID = INT_TO_PARTICIPANTINDEX( idx )
		IF NETWORK_IS_PARTICIPANT_ACTIVE( participantID )
		AND DARTS_CHECK_CLIENT_FLAG(DartsPlayerData[idx], DARTS_CLIENTFLAG_PARTICIPANT_SET)
			IF NOT IS_PLAYER_SCTV(NETWORK_GET_PLAYER_INDEX(participantID))
			AND NOT DID_PLAYER_JOIN_MISSION_AS_SPECTATOR(NETWORK_GET_PLAYER_INDEX(participantID))
				IF myPartID <> DartsPlayerData[idx].iParticipantID
				
					returnID = DartsPlayerData[idx].iParticipantID
					CDEBUG1LN(DEBUG_DARTS, "the other participant is: ", returnID)
				ENDIF
				
				iNumParticipants++
			ENDIF
		ENDIF
	ENDREPEAT
	
	CDEBUG1LN(DEBUG_DARTS, "num players seen: ", iNumParticipants)
	RETURN iNumParticipants
ENDFUNC

/// PURPOSE:
///    
/// PARAMS:
///    DartsPlayerData - 
///    iReturnPlayers - 
/// RETURNS:
///    
FUNC BOOL GET_BOTH_PLAYERS_ID(DARTS_PLAYER_BROADCAST_DATA & DartsPlayerData[DARTSMP_IDS], INT & iReturnPlayers[DART_PLAYER_IDS])
	
	INT idx, iMaxParticipants, iNumParticipants
	
	PARTICIPANT_INDEX participantID
	
	iMaxParticipants = ENUM_TO_INT(DARTSMP_IDS)
	
	REPEAT iMaxParticipants idx
		participantID = INT_TO_PARTICIPANTINDEX( idx )
		IF NETWORK_IS_PARTICIPANT_ACTIVE( participantID )
		AND DARTS_CHECK_CLIENT_FLAG(DartsPlayerData[idx], DARTS_CLIENTFLAG_PARTICIPANT_SET)
			IF NOT IS_PLAYER_SCTV(NETWORK_GET_PLAYER_INDEX(participantID))
			AND NOT DID_PLAYER_JOIN_MISSION_AS_SPECTATOR(NETWORK_GET_PLAYER_INDEX(participantID))
				
				iReturnPlayers[DartsPlayerData[idx].iOffsetPlayerID] = DartsPlayerData[idx].iParticipantID
				iNumParticipants++
				
				CDEBUG1LN(DEBUG_DARTS, "found a participant")
				CDEBUG1LN(DEBUG_DARTS, "which one : ", DartsPlayerData[idx].iOffsetPlayerID)
				CDEBUG1LN(DEBUG_DARTS, "what ID: ", DartsPlayerData[idx].iParticipantID)
				CDEBUG1LN(DEBUG_DARTS, "num participants: ", iNumParticipants)
				
			ENDIF
		ENDIF
	ENDREPEAT
	
	IF iNumParticipants = 2
		RETURN TRUE
	ELSE
		RETURN FALSE
	ENDIF
ENDFUNC

PROC CLEANUP_MP_DARTS_GAME(MP_DARTS_GAME & MPDartGame, DARTS_UI & DartsUI, BOOL bRestoreUI = TRUE, BOOL bLeaveArea = FALSE, BOOL bQuitter = FALSE)
	
	CDEBUG1LN(DEBUG_DARTS, "Starting Darts cleanup procedure")
	
	IF NOT bPlayerQuit
		SET_ENDED_MISSION_AT_LEADERBOARD_VOTE_OR_TIME_OUT()
		CDEBUG1LN(DEBUG_DARTS, "dart mission ended at leaderboard or timed out ")
	ENDIF
	
	IF NOT IS_PED_INJURED(PLAYER_PED_ID())
		CLEAR_PED_SECONDARY_TASK(PLAYER_PED_ID())
		//FREEZE_ENTITY_POSITION(PLAYER_PED_ID(), FALSE)
		TASK_SWAP_WEAPON(PLAYER_PED_ID(), TRUE)
		IF NOT IS_ENTITY_VISIBLE(PLAYER_PED_ID())
		AND NOT IS_PLAYER_SCTV(PLAYER_ID()) // B*2339942
			SET_ENTITY_VISIBLE(PLAYER_PED_ID(), TRUE)
		ENDIF
	ENDIF
	
	DISPLAY_AREA_NAME(TRUE)
	
	IF bRestoreUI
	AND NETWORK_IS_SIGNED_ONLINE()
		CDEBUG1LN(DEBUG_DARTS, "Restoring UI in Darts cleanup")
		
		DISABLE_CELLPHONE(FALSE)
//		SET_MP_OVERHEAD_STATS_ACTIVE(TRUE)
//		DISABLE_SCRIPT_HUD(HUDPART_ALL_OVERHEADS, FALSE)
//		ENABLE_RANK_AND_XP_BAR()
//		DISABLE_SCRIPT_HUD(HUDPART_RANKBAR, FALSE)
		ENABLE_ALL_MP_HUD()
		
		DISPLAY_RADAR(TRUE)
		
		PLAYER_INDEX broadcastIndex
		broadcastIndex = NETWORK_GET_PLAYER_INDEX(INT_TO_PARTICIPANTINDEX(PARTICIPANT_ID_TO_INT()))
		CDEBUG1LN(DEBUG_DARTS, "Broadcasting darts clear to all players on team ", GET_PLAYER_TEAM(broadcastIndex))
		BROADCAST_DARTS_CLEAR(broadcastIndex, GET_PLAYER_TEAM(broadcastIndex))
	ENDIF
	
	IF bQuitter
		CLEAR_PRINTS()
	ENDIF
	
	// cleanup big splash text
	//CLEANUP_BIG_MESSAGE()
	CLEAR_ALL_BIG_MESSAGES()
	
	SET_BIT_FOR_FRANKIE_SAYS_ACHIEVEMENT(ACH45_DARTS)
						
	// cleanup dem darts here
	INT iTemp1
	REPEAT NUM_DART_TURNS iTemp1
		CLEANUP_DART(MPDartGame.Darts[iTemp1])
	ENDREPEAT
	
	CLEANUP_BOARD(MPDartGame.dBoard)
	CLEANUP_RETICLE()
	
	CLEANUP_SOCIAL_CLUB_LEADERBOARD(DartsUI.dartsLB_control)
	
	IF NOT bLeaveArea
		CLEANUP_HUD()
	ENDIF
	
	SET_MODEL_AS_NO_LONGER_NEEDED(modelDart1)
//	SET_MODEL_AS_NO_LONGER_NEEDED(modelDart2)
	SET_MODEL_AS_NO_LONGER_NEEDED(modelReticleRegular)
	
	IF (MPDartGame.iGamesWon = MPDartGame.iGamesLost)
	AND NOT bQuitter
		iTemp1 = ciFMMC_END_OF_MISSION_STATUS_CANCELLED
	ELIF (MPDartGame.iGamesWon > MPDartGame.iGamesLost)
		iTemp1 = ciFMMC_END_OF_MISSION_STATUS_PASSED
	ELSE
		iTemp1 = ciFMMC_END_OF_MISSION_STATUS_FAILED
	ENDIF
	
	//Clean up freemode variables
	IF GET_CURRENT_GAMEMODE() = GAMEMODE_FM
		RESET_FMMC_MISSION_VARIABLES(TRUE, FALSE, iTemp1)
	ENDIF
	
	IF NETWORK_IS_SIGNED_ONLINE()
	AND NOT bSoloMP
		#IF IS_DEBUG_BUILD
		IF NOT bDartsNoSocialClub
		#ENDIF
		WRITE_DARTS_SCLB_DATA(LEADERBOARD_MINI_GAMES_DARTS,TRUE)
		#IF IS_DEBUG_BUILD
		ELSE
		CDEBUG1LN(DEBUG_DARTS, "Debug used, not uploading stats to social club")
		ENDIF
		#ENDIF
	ELIF bSoloMP
		CDEBUG1LN(DEBUG_DARTS, "soloMP, no leaderboard write")
	ENDIF
	
	IF MPGlobals.DartsData.bResultsDisplayed
		MPGlobals.DartsData.bResultsDisplayed = FALSE
	ENDIF
	
	SET_PLAYER_CONTROL(PLAYER_ID(), TRUE)
	
	RESET_HUD_COMPONENT_VALUES(NEW_HUD_SUBTITLE_TEXT)
	
	SET_RESULT_SCREEN_DISPLAYING_STATE(FALSE)
	
	RELEASE_SCRIPT_AUDIO_BANK()
	
	SET_CELEBRATION_SCREEN_AS_ACTIVE(FALSE)
	CLEANUP_CELEBRATION_SCREEN(sCelebrationData)
	
	CDEBUG1LN(DEBUG_DARTS, "All Cleaned Up")
	
//	IF IS_SCREEN_FADED_OUT()
//		DO_SCREEN_FADE_IN(2000)
//	ENDIF

	CLEANUP_DARTS_PC_CONTROLS()
	
	//gdisablerankupmessage = FALSE
	SET_DISABLE_RANK_UP_MESSAGE(FALSE)
	
	SET_ON_JOB_INTRO(FALSE)
	
	IF DOES_CAM_EXIST(renderingCam)
		IF IS_CAM_ACTIVE(renderingCam)
			SET_CAM_ACTIVE(renderingCam, FALSE)
		ENDIF
		DESTROY_CAM(renderingCam)
	ENDIF
	
	IF DOES_CAM_EXIST(ciDartsQuit)
		IF IS_CAM_ACTIVE(ciDartsQuit)
			SET_CAM_ACTIVE(ciDartsQuit, FALSE)
		ENDIF
		DESTROY_CAM(ciDartsQuit)
	ENDIF
	
	IF DOES_CAM_EXIST(camDartsSync)
		IF IS_CAM_ACTIVE(camDartsSync)
			SET_CAM_ACTIVE(camDartsSync, FALSE)
		ENDIF
		DESTROY_CAM(camDartsSync)
	ENDIF
	
	IF DOES_CAM_EXIST(camEndScreen)
		IF IS_CAM_ACTIVE(camEndScreen)
			SET_CAM_ACTIVE(camEndScreen, FALSE)
		ENDIF
		DESTROY_CAM(camEndScreen)
	ENDIF
	
	TERMINATE_THIS_MULTIPLAYER_THREAD_NO_ARGS()	
ENDPROC

/// PURPOSE:
///    Grab the necessary assets for Darts
PROC REQUEST_STREAMS(DARTS_SCOREBOARD & DartsSB)
	REQUEST_MODEL(modelDart1)
//	REQUEST_MODEL(modelDart2)
	REQUEST_MODEL(modelReticleRegular)	
		
	REQUEST_STREAMED_TEXTURE_DICT("Darts")
	
	REQUEST_ANIM_DICT("mini@darts")
	REQUEST_ANIM_DICT(sFacialDictPed)
	REQUEST_ANIM_DICT(sFacialDictPed2)
	REQUEST_ANIM_DICT("mini@dartsintro_alt1")
	REQUEST_ANIM_DICT("mini@dartsoutro")
	
	DartsSB.siScoreBoard			= REQUEST_SCALEFORM_MOVIE("darts_scoreboard")
	shardBigMessage.siMovie			= REQUEST_MG_BIG_MESSAGE()
	shardMidSizeMessage.siMovie		= REQUEST_MG_MIDSIZED_MESSAGE()
	
	
//	REQUEST_CELEBRATION_SCREEN(sCelebrationData)
	
	REQUEST_ADDITIONAL_TEXT("DARTS", MINIGAME_TEXT_SLOT)
ENDPROC

/// PURPOSE:
///    Asset loading checker
/// RETURNS:
///    TRUE if all the needed assets have loaded
FUNC BOOL HAVE_STREAMS_LOADED(DARTS_SCOREBOARD & DartsSB)
//	IF NOT LOAD_MENU_ASSETS()
//		CDEBUG1LN(DEBUG_DARTS, "Menu assets loading")
//		RETURN FALSE
//	ENDIF
	IF NOT REQUEST_SCRIPT_AUDIO_BANK("SCRIPT\\DARTS")	
		CDEBUG1LN(DEBUG_DARTS, "Darts Audio loading")
		RETURN FALSE
	ENDIF
	
	IF NOT REQUEST_SCRIPT_AUDIO_BANK("SCRIPT\\FAMILY1_2")	
		CDEBUG1LN(DEBUG_DARTS, "Family Audio loading")
		RETURN FALSE
	ENDIF
	
	IF NOT REQUEST_SCRIPT_AUDIO_BANK("HUD_AWARDS")	
		CDEBUG1LN(DEBUG_DARTS, "HUD_AWARDS Audio loading")
		RETURN FALSE
	ENDIF
	
	IF NOT HAS_MODEL_LOADED(modelDart1)
		CDEBUG1LN(DEBUG_DARTS, "modelDart1 loading")
		RETURN FALSE
	ENDIF
	IF NOT HAS_MODEL_LOADED(modelReticleRegular)
		CDEBUG1LN(DEBUG_DARTS, "modelReticleRegular loading")
		RETURN FALSE
	ENDIF
	IF NOT HAS_SCALEFORM_MOVIE_LOADED(DartsSB.siScoreBoard)
		CDEBUG1LN(DEBUG_DARTS, "DartsSB.siScoreBoard loading")
		RETURN FALSE
	ENDIF
	IF NOT HAS_ADDITIONAL_TEXT_LOADED(MINIGAME_TEXT_SLOT)
		CDEBUG1LN(DEBUG_DARTS, "MINIGAME_TEXT_SLOT loading")
		RETURN FALSE
	ENDIF
	IF NOT HAS_ANIM_DICT_LOADED("mini@darts")
		CDEBUG1LN(DEBUG_DARTS, "mini@darts loading")
		RETURN FALSE
	ENDIF
	IF NOT HAS_ANIM_DICT_LOADED(sFacialDictPed)
		CDEBUG1LN(DEBUG_DARTS, "sFacialDictPed loading")
		RETURN FALSE
	ENDIF
	IF NOT HAS_ANIM_DICT_LOADED(sFacialDictPed2)
		CDEBUG1LN(DEBUG_DARTS, "sFacialDictPed2 loading")
		RETURN FALSE
	ENDIF
	
	IF NOT HAS_ANIM_DICT_LOADED("mini@dartsintro_alt1")
		CDEBUG1LN(DEBUG_DARTS, "mini@dartsintro_alt1 loading")
		RETURN FALSE
	ENDIF
	
	IF NOT HAS_ANIM_DICT_LOADED("mini@dartsoutro")
		CDEBUG1LN(DEBUG_DARTS, "mini@dartsoutro loading")
		RETURN FALSE
	ENDIF
	
	IF NOT HAS_STREAMED_TEXTURE_DICT_LOADED("Darts")
		CDEBUG1LN(DEBUG_DARTS, "Darts streamed texture dict loading")
		RETURN FALSE
	ENDIF
	
//	IF NOT HAS_CELEBRATION_SCREEN_LOADED(sCelebrationData)
//		CDEBUG1LN(DEBUG_DARTS, "Celebration data loading")
//		RETURN FALSE
//	ENDIF
	
	RETURN TRUE
ENDFUNC


/// PURPOSE:
///    Do necessary pre game start ini.
/// RETURNS:
///    FALSE if the script fails to receive an initial network broadcast.
FUNC BOOL DARTS_NETWORK_INIT(MP_MISSION_DATA & missionScriptArgs, DARTS_SERVER_BROADCAST_DATA & DartsServerData, DARTS_PLAYER_BROADCAST_DATA & DartsPlayerData[DARTSMP_IDS])
	
	CLEAR_HELP()
	
	// This marks the script as a net script, and handles any instancing setup. 
	IF missionScriptArgs.mdID.idMission <> eAM_DARTS
		CDEBUG1LN(DEBUG_DARTS, "Changing missionScriptArgs.mdID.idMission to eAM_DARTS...")
		missionScriptArgs.mdID.idMission = eAM_DARTS
	ENDIF
	
	//If we are in freemode launch diffrently
	IF GET_CURRENT_GAMEMODE() = GAMEMODE_FM
		
		CDEBUG1LN(DEBUG_DARTS, "Set this script as a network script with 2 players.  FM VERSION")
		
		//Freemode mission start details
		INT iPlayerMissionToLoad = FMMC_MINI_GAME_CREATOR_ID
		INT iMissionVariation 	 = 0
		INT iNumberPlayers 	 = ENUM_TO_INT(DARTSMP_IDS)//2
		//Call the function that controls the setting up of this script
		FMMC_PROCESS_PRE_GAME_COMMON(missionScriptArgs, iPlayerMissionToLoad, iMissionVariation, iNumberPlayers)
		
		GlobalplayerBD_FM[NATIVE_TO_INT(PLAYER_ID())].iCurrentMissionType = FMMC_TYPE_MG_DARTS
		
		//Script has started set the global broadcast data up so every body knows
		SET_FM_MISSION_LAUNCHED_SUCESS(missionScriptArgs.mdID.idCreator, missionScriptArgs.mdID.idVariation, missionScriptArgs.iInstanceId)
	
	//If we are not in freemode deal with it normally
	ELSE
	
		CDEBUG1LN(DEBUG_DARTS, "Set this script as a network script with 2 players.  CNC VERSION")
		SETUP_MP_MISSION_FOR_NETWORK(GET_MAX_NUM_PARTICIPANTS_FOR_MP_MISSION(missionScriptArgs.mdID.idMission), missionScriptArgs)
	
		//NETWORK_SET_THIS_SCRIPT_IS_NETWORK_SCRIPT(2, FALSE)
		
		// This makes sure the net script is active, waits untull it is.
		HANDLE_NET_SCRIPT_INITIALISATION()
		RESERVE_NETWORK_MISSION_OBJECTS(5)//8) // TODO: just the dart board?
		
		// This script will not be paused if another script calls PAUSE_GAME
		SET_THIS_SCRIPT_CAN_BE_PAUSED(FALSE)
		
	ENDIF
	
	//These are common to all modes
	NETWORK_REGISTER_HOST_BROADCAST_VARIABLES(DartsServerData, SIZE_OF(DartsServerData))
	NETWORK_REGISTER_PLAYER_BROADCAST_VARIABLES(DartsPlayerData, SIZE_OF(DartsPlayerData))

	iSelfID = PARTICIPANT_ID_TO_INT()
	
	CDEBUG1LN(DEBUG_DARTS, "*********ID Check********************")
	CDEBUG1LN(DEBUG_DARTS, "* iSelfID  = ", iSelfID)
	CDEBUG1LN(DEBUG_DARTS, "*************************************")
	
	IF DID_I_JOIN_MISSION_AS_SPECTATOR()
	OR IS_PLAYER_SCTV(PLAYER_ID())
		
		iSelfID = PARTICIPANT_ID_TO_INT()
		CDEBUG1LN(DEBUG_DARTS, "*********ID Check********************")
		CDEBUG1LN(DEBUG_DARTS, "* iSelfID  = ", iSelfID)
		CDEBUG1LN(DEBUG_DARTS, "*************************************")
		
		
		IF DID_I_JOIN_MISSION_AS_SPECTATOR()
			CDEBUG1LN(DEBUG_DARTS, "FTR THIS IS STARTING AS SPECTATOR")
			DARTS_SET_CLIENT_FLAG(DartsPlayerData[iSelfID], DARTS_CLIENTFLAG_I_AM_SPECTATOR)
		ENDIF
		
		IF IS_PLAYER_SCTV(PLAYER_ID())
			CDEBUG1LN(DEBUG_DARTS, "FTR THIS IS STARTING AS SCTV")
			DARTS_SET_CLIENT_FLAG(DartsPlayerData[iSelfID], DARTS_CLIENTFLAG_I_AM_SCTV)
			DARTS_CLEAR_CLIENT_FLAG(DartsPlayerData[iSelfID], DARTS_CLIENTFLAG_I_AM_SPECTATOR)
		ENDIF
		
	ELSE
		CDEBUG1LN(DEBUG_DARTS, "FTR THIS IS NOT SPECTATING")
	ENDIF
	
	DARTS_SET_PLAYER_MP_STATE(DartsPlayerData[iSelfID], DARTS_MPSTATE_WAIT_PRE_INIT)
	
	IF NETWORK_IS_HOST_OF_THIS_SCRIPT()
		DARTS_SET_SERVER_MP_STATE(DartsServerData, DARTS_MPSTATE_INIT)
		//DartsServerData.iMatchHistoryID = PLAYSTATS_CREATE_MATCH_HISTORY_ID()
		PLAYSTATS_CREATE_MATCH_HISTORY_ID_2(DartsServerData.iMatchType, DartsServerData.iMatchHistoryID)
	ENDIF
	
	// KGM: Wait for the first network broadcast before moving on - call this as the last instruction in pre-game
	// (after Initialisation and Broadcast Variable Registration - Hosts can do this too)
	IF NOT Wait_For_First_Network_Broadcast()
		RETURN FALSE
	ENDIF
	
	RETURN TRUE
ENDFUNC

FUNC BOOL SHOULD_DARTS_LEVEL_HELP_SHOW(INT iNumGames, INT & iBitToSet)
	IF iNumGames >= 10
		IF NOT IS_BIT_SET(g_savedGlobals.sDartsData.iDartTimePlayed, gDARTS_MP_LVL_UP_SHWN)
			iBitToSet = gDARTS_MP_LVL_UP_SHWN
			RETURN TRUE
		ENDIF
	ENDIF
	
	RETURN FALSE
ENDFUNC

//  take in a vector from the other player, and your own darts
// Draw the sprite reticle at that point
// Sprite reticle has to be different color, so make sure a function is ready for that
PROC DARTS_DRAW_PLAYERS_RETICLE(VECTOR vReticlePos, INT iDartPlayerID, BOOL bWatching = FALSE)
	spriteReticle.x = vReticlePos.x
	spriteReticle.y = vReticlePos.y
	IF iDartPlayerID = 0
		// color - blue
		spriteReticle.r = 255
		spriteReticle.g = 255
		spriteReticle.b = 255
	ELIF iDartPlayerID = 1
		// color - red
		spriteReticle.r = 255
		spriteReticle.g = 255
		spriteReticle.b = 255
	ELSE
		// color - white
		spriteReticle.r = 255
		spriteReticle.g = 250
		spriteReticle.b = 255
	ENDIF
	
	IF bWatching
		//DRAW_2D_SPRITE("MPCharCard", "MP_CharCard_Stats_Icons5", spriteReticle)
	ENDIF
ENDPROC

PROC COPY_DART_TO_LOCAL(DART & localDart, DARTS_PLAYER_BROADCAST_DATA & thatPlayerData, INT iOtherPlayerID = 0)
	localDart.vPosition 	= thatPlayerData.ClientDart.vPosition
	localDart.vThrow 		= thatPlayerData.ClientDart.vThrow
	localDart.vTarget 		= thatPlayerData.ClientDart.vTarget	
	localDart.vRotation 	= thatPlayerData.ClientDart.vRotation
	localDart.vOffsetTarget = thatPlayerData.ClientDart.vOffsetTarget
	localDart.bStuck 		= thatPlayerData.ClientDart.bStuck
	localDart.bTravelling 	= thatPlayerData.ClientDart.bTravelling
	
	MODEL_NAMES otherDart
	
	otherDart = modelDart1
	
	iOtherPlayerID = iOtherPlayerID
//	
//	IF iOtherPlayerID = 0
//		otherDart = modelDart1
//		CDEBUG1LN(DEBUG_DARTS, "**********PROP_DART_1 registered**********")
//	ELSE
//		otherDart = modelDart2
//		CDEBUG1LN(DEBUG_DARTS, "**********PROP_DART_2 registered**********")
//	ENDIF
	
	CDEBUG1LN(DEBUG_DARTS, "**********localDart.vTarget = ", localDart.vTarget)
	CDEBUG1LN(DEBUG_DARTS, "**********localDart.vOffsetTarget = ", localDart.vOffsetTarget)
	CDEBUG1LN(DEBUG_DARTS, "**********localDart.vThrow = ", localDart.vThrow)
	
	localDart.object = CREATE_OBJECT(otherDart, vInitDartPos, FALSE, FALSE)
ENDPROC

FUNC BOOL DARTS_PLAYER_QUIT_CONTROL(DARTS_PLAYER_BROADCAST_DATA & playerData, DARTS_UI & DartsUI, INT & iDebugThrottle)
	
	IF IS_CONTROL_JUST_RELEASED(FRONTEND_CONTROL, INPUT_SCRIPT_PAD_RIGHT)
	AND NOT IS_PAUSE_MENU_ACTIVE()
		IF NOT DARTS_CHECK_CLIENT_FLAG(playerData, DARTS_CLIENTFLAG_QUIT_ATTEMPTED)
			DARTS_SET_CLIENT_FLAG(playerData, DARTS_CLIENTFLAG_QUIT_ATTEMPTED)
			CLEAR_HELP()
		ENDIF
	ENDIF
	
	IF DARTS_CHECK_CLIENT_FLAG(playerData, DARTS_CLIENTFLAG_QUIT_ATTEMPTED)
		DEBUG_MESSAGE_PERIODIC("CLIENT DARTS_MPSTATE_LEAVE", iDebugThrottle)
		DARTS_QUIT_UI(DartsUI)
		
		IF NOT IS_PAUSE_MENU_ACTIVE()
			IF IS_CONTROL_JUST_RELEASED(FRONTEND_CONTROL, INPUT_FRONTEND_ACCEPT)
				CLEAR_PRINTS()
				DARTS_SET_CLIENT_FLAG(playerData, DARTS_CLIENTFLAG_QUIT_CONFIRMED)
				bPlayerQuit = TRUE
				RETURN TRUE
			ENDIF
			
			IF IS_CONTROL_JUST_RELEASED(FRONTEND_CONTROL, INPUT_FRONTEND_CANCEL)
				DARTS_SET_UI_FLAG(DartsUI.iFlags, DARTS_UIFLAGS_SETUP_QUITUI, FALSE)
				DARTS_CLEAR_CLIENT_FLAG(playerData, DARTS_CLIENTFLAG_QUIT_ATTEMPTED)
			ENDIF
		ENDIF
	ENDIF
	
	RETURN FALSE
ENDFUNC

FUNC BOOL DARTS_PLAYER_QUIT_CONTROL_SPECTATOR(DARTS_PLAYER_BROADCAST_DATA & playerData, DARTS_UI & DartsUI, INT & iDebugThrottle)
	
	IF DARTS_CHECK_CLIENT_FLAG(playerData, DARTS_CLIENTFLAG_QUIT_ATTEMPTED)
		DEBUG_MESSAGE_PERIODIC("CLIENT DARTS_MPSTATE_LEAVE", iDebugThrottle)
		DARTS_QUIT_UI(DartsUI)
		
		IF NOT IS_PAUSE_MENU_ACTIVE()
			IF IS_CONTROL_JUST_RELEASED(FRONTEND_CONTROL, INPUT_FRONTEND_ACCEPT)
				CLEAR_PRINTS()
				bPlayerQuit = TRUE
				RETURN TRUE
			ENDIF
			
			IF IS_CONTROL_JUST_RELEASED(FRONTEND_CONTROL, INPUT_FRONTEND_CANCEL)
				DARTS_SET_UI_FLAG(DartsUI.iFlags, DARTS_UIFLAGS_SETUP_QUITUI, FALSE)
				DARTS_CLEAR_CLIENT_FLAG(playerData, DARTS_CLIENTFLAG_QUIT_ATTEMPTED)
			ENDIF
		ENDIF
	ELSE
		IF IS_CONTROL_JUST_RELEASED(FRONTEND_CONTROL, INPUT_FRONTEND_CANCEL)
		AND NOT IS_PAUSE_MENU_ACTIVE()
			IF NOT DARTS_CHECK_CLIENT_FLAG(playerData, DARTS_CLIENTFLAG_QUIT_ATTEMPTED)
				DARTS_SET_CLIENT_FLAG(playerData, DARTS_CLIENTFLAG_QUIT_ATTEMPTED)
				CLEAR_HELP()
			ENDIF
		ENDIF
	ENDIF
	
	RETURN FALSE
ENDFUNC

CONST_FLOAT fBoard_offsetZ -0.7744

#IF IS_DEBUG_BUILD
	USING "shared_debug.sch"

	BOOL bDangerZoneOccupied
	BOOL bWinDartsGame
	BOOL bTurnOffShakes

	PROC ADD_AM_DART_WIDGETS()
		START_WIDGET_GROUP("AM_DARTS")
			ADD_WIDGET_BOOL("Occupy Danger Zone", bDangerZoneOccupied)
			ADD_WIDGET_BOOL("Win Game", bWinDartsGame)
			ADD_WIDGET_BOOL("Turn off shake", bTurnOffShakes)
		STOP_WIDGET_GROUP()
	ENDPROC
	
	PROC PROCESS_WIDGETS(DARTS_SERVER_BROADCAST_DATA & ServerData)
	
		IF NETWORK_IS_HOST_OF_THIS_SCRIPT()
			IF bDangerZoneOccupied
			
				ServerData.bDangerZoneOccupied = TRUE
			ELSE
				ServerData.bDangerZoneOccupied = FALSE
			ENDIF
			
			IF bWinDartsGame
				ServerData.bDoWinning = TRUE
				bWinDartsGame = FALSE
			ENDIF
		ENDIF
		
		IF bTurnOffShakes
			fWobbleFactor = 0.0
			fRealWobFactor = 0.0
		ENDIF
		
	ENDPROC
	
#ENDIF

FUNC BOOL DARTS_TUTORIAL(DARTS_TUTORIAL_STAGE & DartsTutorialStage, DARTS_BOARD & DartsBoard, DARTS_AI_BRAIN & AIBrain, 
						DARTS_PLAYER_STATE & TurnStage, DART & TutorialDarts[], structTimer & TutorialTimer, DARTS_PLAYER_BROADCAST_DATA & playerData[])
	
//	IF HANDLE_SKIP_CUTSCENE(iAllowSkipCutsceneTime)
//		DartsTutorialStage = TS_SKIP
//	ENDIF
	
//	IF IS_CUTSCENE_SKIP_BUTTON_JUST_PRESSED()
//		IF NOT DARTS_CHECK_CLIENT_FLAG(playerData[iSelfID], DARTS_CLIENTFLAG_TUTORIAL_SKIP)
//			DARTS_SET_CLIENT_FLAG(playerData[iSelfID], DARTS_CLIENTFLAG_TUTORIAL_SKIP)
//		ELSE
//			DARTS_CLEAR_CLIENT_FLAG(playerData[iSelfID], DARTS_CLIENTFLAG_TUTORIAL_SKIP)
//		ENDIF
//	ENDIF
	
	IF DARTS_CHECK_CLIENT_FLAG(playerData[iSelfID], DARTS_CLIENTFLAG_TUTORIAL_SKIP)
	AND DARTS_CHECK_CLIENT_FLAG(playerData[iOtherID], DARTS_CLIENTFLAG_TUTORIAL_SKIP)
		DO_SCREEN_FADE_OUT(500)
		WHILE NOT IS_SCREEN_FADED_OUT()
			WAIT(0)
		ENDWHILE
		
		DartsTutorialStage = TS_SKIP
	ENDIF
	
	SWITCH DartsTutorialStage
		CASE TS_THROWING
			//iAllowSkipCutsceneTime = GET_GAME_TIMER()
			
			RESTART_TIMER_NOW(TutorialTimer)
			
			DISPLAY_RADAR(FALSE)	
			
			DARTS_TUTORIAL_CAM(DartsBoard.vDartBoard, DartsBoard.fBoardHeading,
								GET_TUTORIAL_CAM_COORD_OFFSET(TS_THROWING), GET_TUTORIAL_CAM_ROT_OFFSET(), 0, TRUE)
			
			RENDER_SCRIPT_CAMS(TRUE, FALSE)
			
			IF IS_SCREEN_FADED_OUT() OR IS_SCREEN_FADING_OUT()
				CDEBUG1LN(DEBUG_DARTS, "[DARTS_MPSTATE_TUTORIAL] fade in called for")
				DO_SCREEN_FADE_IN(500)
			ENDIF
			
			CDEBUG1LN(DEBUG_DARTS, "Finished TS_THROWING")
			DartsTutorialStage = TS_DART_LANDING
		BREAK
		
		CASE TS_DART_LANDING			
			
			SWITCH iTurn
				CASE 0
					IF GET_TIMER_IN_SECONDS_SAFE(TutorialTimer) > 1.0
						
						PRINT_HELP("DARTS_HOW_TO_2")
						RESTART_TIMER_NOW(TutorialTimer)
						iTurn++
						
					ENDIF
				BREAK
				
				CASE 1
					IF GET_TIMER_IN_SECONDS_SAFE(TutorialTimer) > 2.0
						IF TurnStage = DPS_AIM 
							AIBrain.iThrowValue = 20
							AIBrain.iThrowMultiplier = 3
							GET_AI_THROW_VECTOR(TutorialDarts[0], DartsBoard, TurnStage, AIBrain, TRUE)
						ENDIF
			
						IF TurnStage = DPS_THROW
							IF THROW_DART(TutorialDarts[0], DartsBoard)
								PLAY_SOUND_FROM_COORD(-1, "DARTS_HIT_BOARD_MASTER", DartsBoard.vDartBoard)
								iTurn++
								RESTART_TIMER_NOW(TutorialTimer)
								TurnStage = DPS_AIM
							ENDIF
						ENDIF
					ENDIF
				BREAK
				
				CASE 2
					IF GET_TIMER_IN_SECONDS_SAFE(TutorialTimer) > 5.0
						
						PRINT_HELP("DARTS_HOW_TO_3")
						RESTART_TIMER_NOW(TutorialTimer)
						iTurn++
						
					ENDIF
				BREAK
				
				CASE 3
					IF GET_TIMER_IN_SECONDS_SAFE(TutorialTimer) > 2.0
						IF TurnStage = DPS_AIM 
							AIBrain.iThrowValue = 50
							AIBrain.iThrowMultiplier = 1
							GET_AI_THROW_VECTOR(TutorialDarts[1], DartsBoard, TurnStage, AIBrain, TRUE)
						ENDIF
			
						IF TurnStage = DPS_THROW
							IF THROW_DART(TutorialDarts[1], DartsBoard)
								PLAY_SOUND_FROM_COORD(-1, "DARTS_HIT_BOARD_MASTER", DartsBoard.vDartBoard)
								RESTART_TIMER_NOW(TutorialTimer)
								TurnStage = DPS_AIM
								iTurn++
							ENDIF
						ENDIF
					ENDIF
				BREAK
				
				CASE 4
					IF GET_TIMER_IN_SECONDS_SAFE(TutorialTimer) > 5.0
						
						PRINT_HELP("DARTS_HOW_3A")
						RESTART_TIMER_NOW(TutorialTimer)
						iTurn++
						
					ENDIF
				BREAK
				
				CASE 5
					IF GET_TIMER_IN_SECONDS_SAFE(TutorialTimer) > 2.0
						
						IF TurnStage = DPS_AIM
							AIBrain.iThrowValue = 20
							AIBrain.iThrowMultiplier = 2
							GET_AI_THROW_VECTOR(TutorialDarts[2], DartsBoard, 
												TurnStage, AIBrain, TRUE)
							CDEBUG1LN(DEBUG_DARTS, "*****************Got the last Throw Vector")
						ENDIF
			
						IF TurnStage = DPS_THROW
							IF THROW_DART(TutorialDarts[2], DartsBoard)
								RESTART_TIMER_NOW(TutorialTimer)
								PLAY_SOUND_FROM_COORD(-1, "DARTS_HIT_BOARD_MASTER", DartsBoard.vDartBoard)
								CDEBUG1LN(DEBUG_DARTS, "*****************Threw the last Dart")
								TurnStage = DPS_AIM					
								DartsTutorialStage = TS_DOUBLE
								
							ENDIF
						ENDIF
					ENDIF
				BREAK
			ENDSWITCH
		BREAK
		
		CASE TS_DOUBLE
			IF GET_TIMER_IN_SECONDS_SAFE(TutorialTimer) > 5.0
				RESTART_TIMER_NOW(TutorialTimer)
				CLEAR_HELP()
				DARTS_TUTORIAL_CAM_INTERP(DartsBoard.vDartBoard, DartsBoard.fBoardHeading,
											GET_TUTORIAL_CAM_COORD_OFFSET(TS_DOUBLE), GET_TUTORIAL_CAM_ROT_OFFSET(), 1500)
				//HELP_AT_ENTITY_OFFSET("DARTS_DOUBLE_T", DartGame.TutorialDarts[0].object, << 0, 0, -0.85 >>)
				DartsTutorialStage = TS_TRIPLE
				CDEBUG1LN(DEBUG_DARTS, "Leaving TS_DOUBLE")
			ENDIF
		BREAK
		
		CASE TS_TRIPLE
			IF NOT IS_CAM_INTERPOLATING(camTutInterp)
			AND NOT IS_THIS_HELP_MESSAGE_BEING_DISPLAYED("DARTS_DOUBLE_T")
				PRINT_HELP("DARTS_DOUBLE_T")
				
			//AND NOT IS_THIS_FLOATING_HELP_BEING_DISPLAYED("DARTS_DOUBLE_T")
			//	HELP_AT_ENTITY_OFFSET("DARTS_DOUBLE_T", DartGame.TutorialDarts[0].object, << 0, 0, -0.85 >>)
			ENDIF
			
			IF GET_TIMER_IN_SECONDS_SAFE(TutorialTimer) > 6.0
				RESTART_TIMER_NOW(TutorialTimer)
				DARTS_TUTORIAL_CAM(DartsBoard.vDartBoard, DartsBoard.fBoardHeading,
									GET_TUTORIAL_CAM_COORD_OFFSET(TS_TRIPLE), GET_TUTORIAL_CAM_ROT_OFFSET(), 1000)
				//HELP_AT_ENTITY("DARTS_TRIPLE_T", DartGame.TutorialDarts[0].object)
				//CLEAR_THIS_FLOATING_HELP("DARTS_DOUBLE_T")
				DartsTutorialStage = TS_BULLSEYE
				CDEBUG1LN(DEBUG_DARTS, "Leaving TS_TRIPLE")
			ENDIF
		BREAK
		
		CASE TS_BULLSEYE
			IF NOT IS_CAM_INTERPOLATING(camTutorial)
			AND NOT IS_THIS_HELP_MESSAGE_BEING_DISPLAYED("DARTS_TRIPLE_T")
				PRINT_HELP("DARTS_TRIPLE_T")
				
			//AND NOT IS_THIS_FLOATING_HELP_BEING_DISPLAYED("DARTS_TRIPLE_T")
			//	HELP_AT_ENTITY("DARTS_TRIPLE_T", DartGame.TutorialDarts[0].object)
			ENDIF
			
			IF GET_TIMER_IN_SECONDS_SAFE(TutorialTimer) > 6.0
				RESTART_TIMER_NOW(TutorialTimer)
				DARTS_TUTORIAL_CAM_INTERP(DartsBoard.vDartBoard, DartsBoard.fBoardHeading,
											GET_TUTORIAL_CAM_COORD_OFFSET(TS_BULLSEYE), GET_TUTORIAL_CAM_ROT_OFFSET(), 1000)
				//HELP_AT_ENTITY("DARTS_BULL_T", DartGame.TutorialDarts[1].object)
				//CLEAR_THIS_FLOATING_HELP("DARTS_TRIPLE_T")
				DartsTutorialStage = TS_DBL_TO_WIN
				CDEBUG1LN(DEBUG_DARTS, "Leaving TS_BULLSEYE")
			ENDIF
		BREAK
		
		CASE TS_DBL_TO_WIN
			IF NOT IS_CAM_INTERPOLATING(camTutInterp)
			AND NOT IS_THIS_HELP_MESSAGE_BEING_DISPLAYED("DARTS_BULL_T")
				PRINT_HELP("DARTS_BULL_T")
				
			//AND NOT IS_THIS_FLOATING_HELP_BEING_DISPLAYED("DARTS_BULL_T")
			//	HELP_AT_ENTITY("DARTS_BULL_T", DartGame.TutorialDarts[1].object)
			ENDIF
			
			IF GET_TIMER_IN_SECONDS_SAFE(TutorialTimer) > 6.0
				RESTART_TIMER_NOW(TutorialTimer)
				DARTS_TUTORIAL_CAM(DartsBoard.vDartBoard, DartsBoard.fBoardHeading,
									GET_TUTORIAL_CAM_COORD_OFFSET(TS_DBL_TO_WIN), GET_TUTORIAL_CAM_ROT_OFFSET(), 1500)
				//HELP_AT_ENTITY("DARTS_DBL_WIN", DartGame.TutorialDarts[2].object)
				//CLEAR_THIS_FLOATING_HELP("DARTS_BULL_T")
				DartsTutorialStage = TS_ENDING
				CDEBUG1LN(DEBUG_DARTS, "Leaving TS_DBL_TO_WIN")
			ENDIF
		BREAK
		
		CASE TS_ENDING
			IF NOT IS_CAM_INTERPOLATING(camTutorial)
			AND NOT IS_THIS_HELP_MESSAGE_BEING_DISPLAYED("DARTS_DBL_WIN")
				PRINT_HELP("DARTS_DBL_WIN")
				
			//AND NOT IS_THIS_FLOATING_HELP_BEING_DISPLAYED("DARTS_DBL_WIN")
			//	HELP_AT_ENTITY("DARTS_DBL_WIN", DartGame.TutorialDarts[2].object)
			ENDIF
			
			IF GET_TIMER_IN_SECONDS_SAFE(TutorialTimer) > 6.0 //TIMERA() > 6000
				
				SET_CAM_ACTIVE_WITH_INTERP(camDartGame, camTutorial, 1500)
				//CLEAR_THIS_FLOATING_HELP("DARTS_DBL_WIN")
				DartsTutorialStage = TS_ENDING2
				CDEBUG1LN(DEBUG_DARTS, "Leaving TS_ENDING")
			ENDIF
		BREAK
		
		CASE TS_ENDING2
			IF NOT IS_CAM_INTERPOLATING(camDartGame)
				iTurn = 0
				CLEAR_HELP()
				CLEAR_PRINTS()
				CLEAR_ALL_FLOATING_HELP()
				INT i
				REPEAT NUM_DART_TURNS i
					CLEANUP_DART(TutorialDarts[i])
				ENDREPEAT
				
				RETURN TRUE
			ENDIF
		BREAK
		
		CASE TS_SKIP
			IF IS_SCREEN_FADED_OUT()
				iTurn = 0
				CLEAR_HELP()
				CLEAR_PRINTS()
				CLEAR_ALL_FLOATING_HELP()
				INT i
				REPEAT NUM_DART_TURNS i
					CLEANUP_DART(TutorialDarts[i])
				ENDREPEAT
				
				SET_CAM_ACTIVE(camDartGame, TRUE)
				
				//DO_SCREEN_FADE_IN(500)
				
				RETURN TRUE
			ENDIF
		BREAK
	ENDSWITCH
	
	RETURN FALSE
ENDFUNC

PROC DARTS_SETUP_MP_QUIT_CAM()
	
	IF NOT DOES_CAM_EXIST(ciDartsQuit)
		ciDartsQuit = CREATE_CAMERA_WITH_PARAMS(CAMTYPE_SCRIPTED, <<0,0,0>>, <<0,0,0>>)
	ENDIF
	
	SET_CAM_COORD(ciDartsQuit, <<1993.8000, 3049.7000, 47.8000>>)
	SET_CAM_ROT(ciDartsQuit, <<5.8000, -0.0000, 55.6000>>)
	SET_CAM_FOV(ciDartsQuit, 50.0)
	SET_CAM_ACTIVE(ciDartsQuit, TRUE)
	
ENDPROC

/// PURPOSE:
///    takes off high heels, ONLY USE FOR CLONED PEDS
/// PARAMS:
///    dartPed - one of the players
PROC DARTS_TAKE_OFF_HIGH_HEELS(PED_INDEX & dartPed)
	SET_PED_COMPONENT_VARIATION(dartPed, PED_COMP_FEET, 1, 0)
ENDPROC


FUNC BOOL IS_DARTS_GAME_ALMOST_DONE(DARTS_SERVER_BROADCAST_DATA & ServerData, DARTS_PLAYER_BROADCAST_DATA & PlayerData[])
	
	BOOL bGameAlmostDone
	
	// sets and legs are both 1, score is at least < 100
	// sets > 1, set amount is greater then set max * 66%
	// sets = 1, leg amount is greater then leg max * 66%
	
	IF NOT DARTS_CHECK_CLIENT_FLAG(PlayerData[iSelfID], DARTS_CLIENTFLAG_SINGLE_PLAYER)
		IF ((serverData.iNumLegs = 1 AND serverData.iNumSets = 1) AND (ServerData.iScores[iSelfID] < 101 OR ServerData.iScores[iOtherID] < 101))
		OR ( serverData.iNumSets > 1 AND (serverData.iSets[iSelfID] >= FLOOR(serverData.iNumSets * 0.66) OR serverData.iSets[iOtherID] >= FLOOR(serverData.iNumSets * 0.66)) )
		OR ( serverData.iNumLegs > 1 AND (serverData.iLegs[iSelfID] >= FLOOR(serverData.iNumLegs * 0.33) OR serverData.iLegs[iOtherID] >= FLOOR(serverData.iNumLegs * 0.33)) )
			CDEBUG1LN(DEBUG_DARTS, "dart game is almost done")
			bGameAlmostDone = TRUE
		ELSE
			CDEBUG1LN(DEBUG_DARTS, "dart game is NOT almost done")
		ENDIF
		
		CDEBUG1LN(DEBUG_DARTS, "serverData.iNumLegs = ", serverData.iNumLegs)
		CDEBUG1LN(DEBUG_DARTS, "serverData.iNumSets = ", serverData.iNumSets)
		CDEBUG1LN(DEBUG_DARTS, "serverData.iSets[iSelfID] = ", serverData.iSets[iSelfID])
		CDEBUG1LN(DEBUG_DARTS, "serverData.iSets[iOtherID] = ", serverData.iSets[iOtherID])
		CDEBUG1LN(DEBUG_DARTS, "serverData.iLegs[iSelfID] = ", serverData.iLegs[iSelfID])
		CDEBUG1LN(DEBUG_DARTS, "serverData.iLegs[iOtherID] = ", serverData.iLegs[iOtherID])
		CDEBUG1LN(DEBUG_DARTS, "serverData.iScores[iSelfID] = ", serverData.iScores[iSelfID])
		CDEBUG1LN(DEBUG_DARTS, "serverData.iScores[iOtherID] = ", serverData.iScores[iOtherID])
		
	ENDIF
	
	RETURN bGameAlmostDone
	
ENDFUNC

PROC DARTS_DISPLAY_SPECIAL_SPLASH_MP_SHARD(DARTS_UI & DartsUI)
	IF DartsUI.bTriggerSplash
		IF DartsUI.eSplashStage = DARTSSPLASHSTAGE_DONE
			DartsUI.eSplashStage = DARTSSPLASHSTAGE_INIT
		ENDIF
		DartsUI.bTriggerSplash = FALSE
	ENDIF
	
	SWITCH DartsUI.eSplashStage
		CASE DARTSSPLASHSTAGE_INIT
			SET_SHARD_BIG_MESSAGE(shardMidSizeMessage, DARTS_GET_SPLASH_STRING(DartsUI.eWhichSplash), "", 2000, SHARD_MESSAGE_MIDSIZED, HUD_COLOUR_WHITE)
			DartsUI.eSplashStage = DARTSSPLASHSTAGE_DISPLAY
		BREAK
		CASE DARTSSPLASHSTAGE_DISPLAY
			IF NOT UPDATE_SHARD_BIG_MESSAGE(shardMidSizeMessage, FALSE)
				RESET_SHARD_BIG_MESSAGE(shardMidSizeMessage)
				DartsUI.eSplashStage = DARTSSPLASHSTAGE_DONE
			ENDIF
		BREAK
		CASE DARTSSPLASHSTAGE_DONE
			// nada
		BREAK
	ENDSWITCH
ENDPROC

PROC DARTS_MAINTAIN_REALTIME_MP(DARTS_MP_STATE eMPState)
	IF eMPState < DARTS_MPSTATE_IN_PROGRESS
		NETWORK_DISABLE_REALTIME_MULTIPLAYER()
	ENDIF
ENDPROC

SCRIPT (MP_MISSION_DATA missionScriptArgs)
	
	MP_DARTS_GAME MPDartGame 
	DARTS_ARGS Args
	DARTS_STARTING_RETICLE_POS DartsInitReticlePos
	DARTS_PLAYER_POS DartsPlayerPos
	DARTS_MP_TERMINATE_REASON terminateReason
	DARTS_MP_LEAVE_STATE leaveState
	DARTS_SCOREBOARD DartsSB
	DARTS_UI DartsUI
	DARTS_TIMER localDartsTimer //for use with the rematch/quit clock
	DART_PLAYER_POSITION DartPlayerPosition
	DARTS_LOCATION DartsLocation
	
	DARTS_TUTORIAL_STAGE DartsTutorialStage
	DARTS_AI_BRAIN AIBrain
	DARTS_PLAYER_STATE TurnStage = DPS_AIM
	//DART TutorialDarts[3]
	
	DARTS_MP_STATE eSpecState = DARTS_MPSTATE_INIT
	DARTS_MP_WAIT_STAGE eSpecWaitStage
	DARTS_MP_TURN_STATUS eSpecTurnStatus
	
	//END_SCREEN_DATASET_TITLE_UPDATE DartsEndScreen
	
	GAMER_HANDLE DartsGamerHandle[NUM_DART_PLAYERS]
	
	SCRIPT_TIMER timeDartsAwardFailSafe
	
	structTimer controlTimer
	structTimer ReThrowTimer
	structTimer TutorialTimer
	structTimer SpectateGateTimer
	structTimer endDelay
	
//	FMMC_EOM_DETAILS sEndOfMission
//	PLAYER_CURRENT_STATUS_COUNTS sPlayerCounts
	
	GENERIC_MINIGAME_STAGE eGenericMGStage = GENERIC_CELEBRATION_WINNER
	PLAYER_INDEX winningPlayer
	
	PLAYER_INDEX broadcastIndex

	SEQUENCE_INDEX siTemp
	
	PED_INDEX piOtherPlayer
	//PED_INDEX piOpponentClone
	PED_INDEX piPlayerClones[2]
	
	OBJECT_INDEX oiDartChallenge
	
	VECTOR vPlayerCoord
	VECTOR vCamCoord
	VECTOR vPlayerCurrentPos
	VECTOR vHickBar //, vRockClub //, vLostHideout
	//VECTOR vTemp
	VECTOR vSpectatePos = <<1993.2574, 3044.2151, 46.2151>>//<<1995.5557, 3047.5154, 46.2153>>
	
	VECTOR scenePosition
	VECTOR sceneRotation
	
	INT i, j
	INT iSplashStage
	INT iDebugThrottle
	INT iStaminaXP
	INT iLevelBit
	
	INT iBullseyeXP
	INT iXPGained
	INT iXPToGive
	
	INT iBetWinnings
	
	INT iNumParticipants
	INT iLastNumParticipants
	INT iNumPlayers
	INT iLastNumPlayers
	
	//for use by spectators / sctv
	INT iSpectatePlayerID[DART_PLAYER_IDS]
	INT iSpecTurn
	INT iSpecThower
	INT iSpecLastScore[DART_PLAYER_IDS]
	
	INT iSceneId
	
	FLOAT fStaminaPercentage
	FLOAT fSteadyShotLength
	FLOAT fSpectateHeading = 42.3856
	
	BOOL bFoundPlayer
	BOOL bAlreadyInGangHouse
	BOOL bWaitUIShown // TODO:  CONVERT TO FLAG SYSTEM
	BOOL bBoardTakenUIShown // TODO:  CONVERT TO FLAG SYSTEM
	BOOL bInWinRange
	BOOL bWaitUIShow
	BOOL bShowSplash
	BOOL bShowShotClockThrowHelp
	BOOL bSpecResetDone
	BOOL bCheckPlayers
	BOOL bPlaySplashFX
	BOOL bPhaseGrabbed
	
	TEXT_LABEL_7 sCrewTags[NUM_DART_PLAYERS]
	
	TEXT_LABEL_63 sShardPlayerName
	TEXT_LABEL_23 contentID	
	
	STRING sDartsPlayerNames[NUM_DART_PLAYERS]
	
	STRING sOutroWin[3]
	STRING sOutroLoss[3]
	STRING sOutroCam[3]
	
	sOutroWin[0] = "darts_outro_01_guy1"
	sOutroWin[1] = "darts_outro_02_guy2"
	sOutroWin[2] = "darts_outro_03_guy2"
	
	sOutroLoss[0] = "darts_outro_01_guy2"
	sOutroLoss[1] = "darts_outro_02_guy1"
	sOutroLoss[2] = "darts_outro_03_guy1"
	
	sOutroCam[0] = "darts_outro_01_cam"
	sOutroCam[1] = "darts_outro_02_cam"
	sOutroCam[2] = "darts_outro_03_cam"
	
	sFacialDictPed 	= "facials@gen_male@variations@happy"
	sFacialDictPed2 = "facials@gen_male@variations@angry"
	
	sFacialClip[0] = "mood_happy_1"
	sFacialClip[1] = "mood_happy_2"
	sFacialClip[2] = "mood_happy_3"
	
	sFacialClip2[0] = "mood_angry_1"
	sFacialClip2[1] = "mood_angry_2"
	sFacialClip2[2] = "mood_angry_3"
	
	vHickBar = <<1992.293213,3050.582764,47.989731>>
	//vRockClub = <<-572.040649,294.195770,79.937401>>
	
	// uncomment this to reset flags
	//g_iDartsTutorialFlags = 0
	
	IF NOT IS_PED_INJURED(PLAYER_PED_ID())
//		IF GET_PLAYER_DISTANCE_FROM_LOCATION(vRockClub) < GET_PLAYER_DISTANCE_FROM_LOCATION(vHickBar)
//			DartsLocation = DARTSLOCATION_ROCK_CLUB
//			Args.vDartBoard = vRockClub
//			Args.fBoardHeading = -4.999956
//			CDEBUG1LN(DEBUG_DARTS, "Darts game started at Rock Club")
//		ELSE
			DartsLocation = DARTSLOCATION_HICK_BAR
			Args.vDartBoard = vHickBar
			Args.fBoardHeading = 57.783146
			CDEBUG1LN(DEBUG_DARTS, "Darts game started at Hick Bar")
//		ENDIF
	ENDIF
	
//	IF DOES_OBJECT_OF_TYPE_EXIST_AT_COORDS(Args.vDartBoard, 5.0, PROP_DART_BD_CAB_01)
//		Args.oiDartBoard = GET_CLOSEST_OBJECT_OF_TYPE(Args.vDartBoard, 5.0, PROP_DART_BD_CAB_01)
//		GET_COORDS_AND_ROTATION_OF_CLOSEST_OBJECT_OF_TYPE(Args.vDartBoard, 5.0, PROP_DART_BD_CAB_01, Args.vDartBoard, vTemp, EULER_XYZ)
//		Args.fBoardHeading = vTemp.z
//		CDEBUG1LN(DEBUG_DARTS, "PROP_DART_BD_CAB_01 found in area.")
//		CDEBUG1LN(DEBUG_DARTS, "Args.vDartBoard is now ", Args.vDartBoard)
//		CDEBUG1LN(DEBUG_DARTS, "Args.fBoardHeading is now ", Args.fBoardHeading)
//	ELSE
//		CDEBUG1LN(DEBUG_DARTS, "PROP_DART_BD_CAB_01 not found in area of Darts Args.")
//	ENDIF

	SETUP_DARTS_PC_CONTROLS()
	
	MPGlobals.DartsData.bDartsPlayBusy = FALSE
	
	bShowSplash = FALSE
	
	DARTS_SERVER_BROADCAST_DATA ServerData
	DARTS_PLAYER_BROADCAST_DATA PlayerData[DARTSMP_IDS]//[DART_PLAYER_IDS]
	
	IF NOT DARTS_NETWORK_INIT(missionScriptArgs, ServerData, PlayerData)
		CDEBUG1LN(DEBUG_DARTS, "Failed to receive an initial network broadcast. Cleaning up.")
		CLEANUP_MP_DARTS_GAME(MPDartGame, DartsUI, FALSE)
	ENDIF
	
	IF NOT IS_PLAYER_SCTV(PLAYER_ID())
		NET_SET_PLAYER_CONTROL(PLAYER_ID(), FALSE, NSPC_CLEAR_TASKS | NSPC_NO_COLLISION | NSPC_FREEZE_POSITION)
	ENDIF
	
	//DARTS_SET_PLAYER_NAME(PlayerData[iSelfID], GET_PLAYER_NAME(PLAYER_ID()))
	
	fScaledWobble = 0.06
	fScaledRealWobble = 0.08
	fWobbleFactor = fScaledWobble
	fRealWobFactor = fScaledRealWobble
	
	PlayerData[iSelfID].iParticipantID = iSelfID
	DARTS_SET_CLIENT_FLAG(PlayerData[iSelfID], DARTS_CLIENTFLAG_PARTICIPANT_SET)
	
	IF NETWORK_IS_HOST_OF_THIS_SCRIPT()
		PlayerData[iSelfID].iOffsetPlayerID = ENUM_TO_INT(DART_PLAYER_HOME)
	ELSE
		PlayerData[iSelfID].iOffsetPlayerID = ENUM_TO_INT(DART_PLAYER_AWAY)
	ENDIF
	
	CLIENT_SET_UP_PROXIMITY_CHAT(CHAT_PROXIMITY_MAX)
	
	REQUEST_SYSTEM_ACTIVITY_TYPE_PLAY_DARTS()
	
	WHILE NOT bFoundPlayer
		WAIT(0)
		
		MAINTAIN_CELEBRATION_PRE_LOAD(sCelebrationData)
		
		iNumberOfPlayers = NETWORK_GET_NUM_PLAYERS(PlayerData)
		
		IF NOT NETWORK_IS_IN_SESSION()
			CDEBUG1LN(DEBUG_DARTS, "NETWORK_IS_IN_SESSION() is FALSE, cleaning up")
			CLEANUP_MP_DARTS_GAME(MPDartGame, DartsUI, FALSE)
		
		ELIF DID_I_JOIN_MISSION_AS_SPECTATOR()
		OR IS_PLAYER_SCTV(PLAYER_ID())
			
			IF iNumberOfPlayers >= 2
				
				IF GET_BOTH_PLAYERS_ID(PlayerData, iSpectatePlayerID)
					bFoundPlayer = TRUE
					CDEBUG1LN(DEBUG_DARTS, "am_darts: joining as spectator for 2 player game")
				ENDIF
				
			ELIF iNumberOfPlayers >= 1
			
				IF NOT IS_TIMER_STARTED(controlTimer)
					CDEBUG1LN(DEBUG_DARTS, "looking for more players ")
					START_TIMER_NOW(controlTimer)
				ELIF GET_TIMER_IN_SECONDS(controlTimer) > 4.0
					GET_BOTH_PLAYERS_ID(PlayerData, iSpectatePlayerID)
					
					bFoundPlayer = TRUE
					CDEBUG1LN(DEBUG_DARTS, "am_darts: joining as spectator for one player game")
				ENDIF
			
			ELSE
			
				IF NOT IS_TIMER_STARTED(controlTimer)
					CDEBUG1LN(DEBUG_DARTS, "no players, wait 10 seconds for one to appear ")
					START_TIMER_NOW(controlTimer)
				ELIF GET_TIMER_IN_SECONDS(controlTimer) > 10.0
					
					CDEBUG1LN(DEBUG_DARTS, "no players, clean up")
					CLEANUP_MP_DARTS_GAME(MPDartGame, DartsUI, FALSE)
					
				ENDIF
			
			ENDIF
		
		ELIF iNumberOfPlayers >= NUM_DART_PLAYERS
			IF DART_GET_OTHER_PLAYERS_ID(PlayerData, iOtherID) = NUM_DART_PLAYERS
				bFoundPlayer = TRUE
				IF IS_TIMER_STARTED(controlTimer)
					CANCEL_TIMER(controlTimer)
				ENDIF
				
				CDEBUG1LN(DEBUG_DARTS, "2 player game started")
				
				//Stop people joining my mission // this will be changed for SCTV
				SET_FM_MISSION_AS_NOT_JOINABLE()
			ENDIF
			
		ELIF (MPGlobals.DartsData.bDartsPlayBusy = TRUE)
			CLEAR_HELP()
			
			BROADCAST_DARTS_BOARD_ACTIVATE(PLAYER_ID(), FALSE)
			CDEBUG1LN(DEBUG_DARTS, "am_darts: player started sitting, cleaning up")
			CLEANUP_MP_DARTS_GAME(MPDartGame, DartsUI, FALSE)
		
		ELIF IS_BIT_SET(MPGlobals.DartsData.iDisplayState, 5)
			PRINT_NOW("DARTS_ENEMIES", DEFAULT_GOD_TEXT_TIME, 0)
			BROADCAST_DARTS_BOARD_ACTIVATE(PLAYER_ID(), FALSE)
			CDEBUG1LN(DEBUG_DARTS, "ENEMIES IN THE HOUSE, CLEANING UP")
			CLEANUP_MP_DARTS_GAME(MPDartGame, DartsUI)
		
		ELSE
			
			IF (GET_CURRENT_GAMEMODE() = GAMEMODE_FM)
				IF NOT IS_TIMER_STARTED(controlTimer)
					CDEBUG1LN(DEBUG_DARTS, "bFoundPlayer = False, setting controlTimer ")
					START_TIMER_NOW(controlTimer)
				ELIF GET_TIMER_IN_SECONDS(controlTimer) > 4.0
					CDEBUG1LN(DEBUG_DARTS, "controlTimer > 4.0, must be a single player darts game")
					bFoundPlayer = TRUE
					
					DARTS_SET_CLIENT_FLAG(PlayerData[iSelfID], DARTS_CLIENTFLAG_SINGLE_PLAYER)
					bSoloMP = TRUE
					
					PlayerData[iSelfID].iOffsetPlayerID = ENUM_TO_INT(DART_PLAYER_HOME)
					
					IF IS_TIMER_STARTED(controlTimer)
						CANCEL_TIMER(controlTimer)
					ENDIF
					
					//Stop people joining my mission // this will be changed for SCTV
					SET_FM_MISSION_AS_NOT_JOINABLE()
				ENDIF
			ENDIF
			
			renderingCam = GET_RENDERING_CAM()
			IF DOES_CAM_EXIST(renderingCam)
				vCamCoord = GET_CAM_COORD(GET_RENDERING_CAM())
				IF NOT IS_ENTITY_DEAD(PLAYER_PED_ID())
					vPlayerCoord = GET_ENTITY_COORDS(PLAYER_PED_ID())
				ENDIF
			ELSE
				vCamCoord = vPlayerCoord
			ENDIF
			
			// See if we are changing players.
			IF vCamCoord.z > vPlayerCoord.z + 50.0
				BROADCAST_DARTS_BOARD_ACTIVATE(PLAYER_ID(), FALSE)
				CDEBUG1LN(DEBUG_DARTS, "Player initiated MP menu.  Cleaning up AM_DARTS")
				CLEANUP_MP_DARTS_GAME(MPDartGame, DartsUI, FALSE)
			
				
			// Show help text.
			ELIF NOT bWaitUIShown
				
				bWaitUIShown = TRUE
			ENDIF
		ENDIF
	ENDWHILE
	
	CDEBUG1LN(DEBUG_DARTS, "*********ID Check********************")
	CDEBUG1LN(DEBUG_DARTS, "* iOtherID  = ", iOtherID)
	CDEBUG1LN(DEBUG_DARTS, "*************************************")
	
	// Wait for server and client broadcast data to sync up.
	IF GET_CURRENT_GAMEMODE() != GAMEMODE_FM
		WAIT(500)
	ENDIF
	
	// Make sure we aren't trying to join a game in progress.
	// this check was mainly for CnC
	IF (DARTS_CHECK_CLIENT_FLAG(PlayerData[iOtherID], DARTS_CLIENTFLAG_MATCH_MADE) AND GET_CURRENT_GAMEMODE() != GAMEMODE_FM)
	AND NOT DID_I_JOIN_MISSION_AS_SPECTATOR()
	AND NOT IS_PLAYER_SCTV(PLAYER_ID())
		WHILE TRUE
			// Print a message saying we can't join this game.
			IF NOT bBoardTakenUIShown
				START_TIMER_NOW(controlTimer)
				
				bBoardTakenUIShown = TRUE
				
			// Wait for confirmation from player or timeout.
			ELIF IS_CONTROL_JUST_PRESSED(FRONTEND_CONTROL, INPUT_FRONTEND_ACCEPT) OR GET_TIMER_IN_SECONDS(controlTimer) >= 8.0
				CLEAR_HELP()
				CDEBUG1LN(DEBUG_DARTS, "Darts game was already in progress, cleaning up AM_DARTS")
				CLEANUP_MP_DARTS_GAME(MPDartGame, DartsUI, FALSE)
			ENDIF
			WAIT(0)
		ENDWHILE
	ENDIF
	
	#IF IS_DEBUG_BUILD
		ADD_AM_DART_WIDGETS()
	#ENDIF
	
	DISPLAY_AREA_NAME(FALSE)
	
	IF NOT DARTS_CHECK_CLIENT_FLAG(PlayerData[iSelfID], DARTS_CLIENTFLAG_SINGLE_PLAYER)
	AND NOT DID_I_JOIN_MISSION_AS_SPECTATOR()
	AND NOT IS_PLAYER_SCTV(PLAYER_ID())
		PlayerData[iSelfID].piOther = GET_PLAYER_PED(NETWORK_GET_PLAYER_INDEX(INT_TO_PARTICIPANTINDEX(iOtherID)))  
		CDEBUG1LN(DEBUG_DARTS, "piOther is set")
	ELSE
		CDEBUG1LN(DEBUG_DARTS, "piOther is not set, must be a single player game, or spectator")
	ENDIF
	
	iStaminaXP = GET_MP_INT_CHARACTER_STAT(MP_STAT_STAMINA) //GET_SP_PLAYER_PED_STAT_VALUE(CHAR_MULTIPLAYER, PS_STAMINA)
	CDEBUG1LN(DEBUG_DARTS, "stamina stat = ", iStaminaXP)
	
	fStaminaPercentage = TO_FLOAT(iStaminaXP)/100
	fSteadyShotLength = fStaminaPercentage * 540
	iSteadyShotLength = ROUND(fSteadyShotLength) + 660
	
	CDEBUG1LN(DEBUG_DARTS, "steady shot = ", iSteadyShotLength)
	IF iSteadyShotLength < 660
		iSteadyShotLength = 660
		CDEBUG1LN(DEBUG_DARTS, "steady shot readjusted to 660")
	ENDIF
	
	CDEBUG1LN(DEBUG_DARTS, "[AM_DARTS] has reached the while loop")
	CPRINTLN(DEBUG_DARTS, "TYPING CHANGES ARE IN")
	
	IF bMinigamePlayerQuitFlag
		bMinigamePlayerQuitFlag = FALSE
	ENDIF
	
	STORE_PLAYER_INTERACTION_ANIM_VALUES_FOR_CELEBRATION_SCREEN()
	
	IF NOT DID_I_JOIN_MISSION_AS_SPECTATOR()
		ANIMPOSTFX_STOP_ALL()
	ENDIF
	
	//gdisablerankupmessage = TRUE
	SET_DISABLE_RANK_UP_MESSAGE(TRUE)
	
	WHILE TRUE
		WAIT(0)
		
		iNumberOfPlayers = NETWORK_GET_NUM_PLAYERS(PlayerData)
		
		//Check at the start of the frame if the script should die. 		
		IF SHOULD_THIS_MULTIPLAYER_THREAD_TERMINATE()
			CLEANUP_MP_DARTS_GAME(MPDartGame, DartsUI)
		ENDIF
		
		SET_HUD_COMPONENT_POSITION(NEW_HUD_SUBTITLE_TEXT, 0.0, -0.0375)
		
		NETWORK_PREVENT_SCRIPT_HOST_MIGRATION()
		
		// _______________________________DEBUG START______________________________________________
		#IF IS_DEBUG_BUILD
		
		// Debug Key: win game
		IF (IS_KEYBOARD_KEY_JUST_PRESSED(KEY_S))
			CDEBUG1LN(DEBUG_DARTS, "Darts debug succeed!  setting win flag")
			bDartsNoSocialClub = TRUE
			RESTART_TIMER_NOW(controlTimer)
			PlayerData[iSelfID].eMPState = DARTS_MPSTATE_GAME_END
			DARTS_SET_CLIENT_FLAG(PlayerData[iSelfID], DARTS_CLIENTFLAG_WINNERD)
		ENDIF
		
		// Debug Key: lose game
		IF (IS_KEYBOARD_KEY_JUST_PRESSED(KEY_F))
			CDEBUG1LN(DEBUG_DARTS, "Darts debug failed!  setting lose flag")
			bDartsNoSocialClub = TRUE
			RESTART_TIMER_NOW(controlTimer)
			PlayerData[iSelfID].eMPState = DARTS_MPSTATE_GAME_END
			DARTS_SET_CLIENT_FLAG(PlayerData[iSelfID], DARTS_CLIENTFLAG_LOSERD)
		ENDIF
		
		IF (PlayerData[iOtherID].eMPState = DARTS_MPSTATE_GAME_END)
		AND NOT (PlayerData[iSelfID].eMPState = DARTS_MPSTATE_GAME_END)
		AND ( DARTS_CHECK_CLIENT_FLAG(PlayerData[iOtherID], DARTS_CLIENTFLAG_WINNERD)
			OR DARTS_CHECK_CLIENT_FLAG(PlayerData[iOtherID], DARTS_CLIENTFLAG_LOSERD) )
			CDEBUG1LN(DEBUG_DARTS, "DARTS_MPSTATE_GAME_END getting set because opponent debugged")
			bDartsNoSocialClub = TRUE
			RESTART_TIMER_NOW(controlTimer)
			PlayerData[iSelfID].eMPState = DARTS_MPSTATE_GAME_END
		ENDIF
		
		PROCESS_WIDGETS(ServerData)
		
		#ENDIF
		// _______________________________DEBUG END________________________________________________
		
		//TODO: add an every frame check here to see who are players and who are sctv's
		INT idx
		INT IDcheck
		PARTICIPANT_INDEX participantID
		
		iNumPlayers = 0
		iNumParticipants = NETWORK_GET_NUM_PARTICIPANTS()
		
		IDcheck = PARTICIPANT_ID_TO_INT()
		
		IF IDcheck <> iSelfID
			CDEBUG1LN(DEBUG_DARTS, "ID has changed! WHAT?!!")
			iSelfID = IDcheck
		ENDIF
		
		IF iLastNumParticipants <> iNumParticipants
			CDEBUG1LN(DEBUG_DARTS, "last num participants has changed!")
			CDEBUG1LN(DEBUG_DARTS, "last num participants = ", iLastNumParticipants)
			CDEBUG1LN(DEBUG_DARTS, "current participants = ", iNumParticipants)
			bCheckPlayers = TRUE
			
			iLastNumParticipants = iNumParticipants
		ENDIF
		
		
		REPEAT iNumParticipants idx
			participantID = INT_TO_PARTICIPANTINDEX( idx )
			IF NETWORK_IS_PARTICIPANT_ACTIVE( participantID )
				IF IS_PLAYER_SCTV(NETWORK_GET_PLAYER_INDEX(participantID))
				OR DID_PLAYER_JOIN_MISSION_AS_SPECTATOR(NETWORK_GET_PLAYER_INDEX(participantID))
					IF IS_PLAYER_SCTV(NETWORK_GET_PLAYER_INDEX(participantID))
						IF bCheckPlayers
							CDEBUG1LN(DEBUG_DARTS, "this participant is sctv: ", idx)
						ENDIF
					ENDIF
					IF DID_PLAYER_JOIN_MISSION_AS_SPECTATOR(NETWORK_GET_PLAYER_INDEX(participantID))
						IF bCheckPlayers
							CDEBUG1LN(DEBUG_DARTS, "this participant is spectator: ", idx)
						ENDIF
					ENDIF
				ELSE
					IF bCheckPlayers
						CDEBUG1LN(DEBUG_DARTS, "this participant is a player: ", idx)
						iNumPlayers++
						CDEBUG1LN(DEBUG_DARTS, "number of players: ", iNumPlayers)
						IF iNumPlayers <> iLastNumPlayers
							CDEBUG1LN(DEBUG_DARTS, "number of players: ", iNumPlayers)
							CDEBUG1LN(DEBUG_DARTS, "number of last players: ", iLastNumPlayers)
						ENDIF
					ENDIF
				ENDIF
			ELSE
				IF bCheckPlayers
					CDEBUG1LN(DEBUG_DARTS, "this participant is NOT active! : ", idx)
				ENDIF
			ENDIF
		ENDREPEAT
		
		iLastNumPlayers = iNumPlayers
		
		bCheckPlayers = FALSE
		
		// doing this to hide location text
		HIDE_HUD_AND_RADAR_THIS_FRAME()
		DISABLE_SELECTOR_THIS_FRAME()
		SET_LOADING_ICON_SUBTITLES_OFFSET_SHIFT_THIS_FRAME()
		
		ALLOW_ALTERNATIVE_SCRIPT_CONTROLS_LAYOUT(PLAYER_CONTROL)
		ALLOW_ALTERNATIVE_SCRIPT_CONTROLS_LAYOUT(FRONTEND_CONTROL)
		
		DARTS_MAINTAIN_REALTIME_MP(PlayerData[iSelfID].eMPState)
		
		// #SPECTATE GAMEPLAY HERE VVVVV
		
		//IF IS_PLAYER_SCTV(PLAYER_ID())
		IF DID_I_JOIN_MISSION_AS_SPECTATOR()
		OR IS_PLAYER_SCTV(PLAYER_ID())
			IF SHOULD_THIS_MULTIPLAYER_THREAD_TERMINATE()
			OR PlayerData[iSpectatePlayerID[DART_PLAYER_HOME]].eMPState > DARTS_MPSTATE_WAIT_POST_GAME
			OR PlayerData[iSpectatePlayerID[DART_PLAYER_AWAY]].eMPState > DARTS_MPSTATE_TERMINATE_SPLASH
			OR iNumberOfPlayers < 1
				CDEBUG1LN(DEBUG_DARTS, "looks like game players are quitting, CLEANING UP DARTS")
				CLEANUP_MP_DARTS_GAME(MPDartGame, DartsUI)
			ENDIF
			
			IF PlayerData[iSpectatePlayerID[DART_PLAYER_HOME]].eMPState > DARTS_MPSTATE_SETUP
			AND eSpecState > DARTS_MPSTATE_SETUP
				DRAW_SCALEFORM_MOVIE_3D(DartsSB.siScoreBoard, DartsSB.vScoreBoardPos, DartsSB.vScoreBoardRot, DartsSB.vScoreBoardScale, DartsSB.vScoreBoardScale)
			ENDIF
			
			// checking the current sync'd data from the spectators view point
//			
//			IF (GET_GAME_TIMER() % 1500) < 50
//				CDEBUG1LN(DEBUG_DARTS, "********** ************ ***********")
//				CDEBUG1LN(DEBUG_DARTS, "PlayerData[DART_PLAYER_HOME_SERVER].eMPState = ", PlayerData[DART_PLAYER_HOME_SERVER].eMPState)
//				CDEBUG1LN(DEBUG_DARTS, "PlayerData[DART_PLAYER_HOME_SERVER].eMPThrowStage = ", PlayerData[DART_PLAYER_HOME_SERVER].eMPThrowStage)
//				CDEBUG1LN(DEBUG_DARTS, "PlayerData[DART_PLAYER_HOME_SERVER].eMPWaitStage = ", PlayerData[DART_PLAYER_HOME_SERVER].eMPWaitStage)
//				CDEBUG1LN(DEBUG_DARTS, "PlayerData[DART_PLAYER_HOME_SERVER].sName = ", PlayerData[DART_PLAYER_HOME_SERVER].sName)
//				CDEBUG1LN(DEBUG_DARTS, "********** ************ ***********")
//				CDEBUG1LN(DEBUG_DARTS, "PlayerData[DART_PLAYER_AWAY_SERVER].eMPState = ", PlayerData[DART_PLAYER_AWAY_SERVER].eMPState)
//				CDEBUG1LN(DEBUG_DARTS, "PlayerData[DART_PLAYER_AWAY_SERVER].eMPThrowStage = ", PlayerData[DART_PLAYER_AWAY_SERVER].eMPThrowStage)
//				CDEBUG1LN(DEBUG_DARTS, "PlayerData[DART_PLAYER_AWAY_SERVER].eMPWaitStage = ", PlayerData[DART_PLAYER_AWAY_SERVER].eMPWaitStage)
//				CDEBUG1LN(DEBUG_DARTS, "PlayerData[DART_PLAYER_AWAY_SERVER].sName = ", PlayerData[DART_PLAYER_AWAY_SERVER].sName)
//				CDEBUG1LN(DEBUG_DARTS, "********** ************ ***********")
//				CDEBUG1LN(DEBUG_DARTS, "serverData.mpState = ", serverData.mpState)
//				CDEBUG1LN(DEBUG_DARTS, "serverData.mpTurnStatus[DART_PLAYER_HOME_SERVER] = ", serverData.mpTurnStatus[DART_PLAYER_HOME_SERVER])
//				CDEBUG1LN(DEBUG_DARTS, "serverData.mpTurnStatus[DART_PLAYER_AWAY_SERVER] = ", serverData.mpTurnStatus[DART_PLAYER_AWAY_SERVER])
//				CDEBUG1LN(DEBUG_DARTS, "serverData.iScores[DART_PLAYER_HOME_SERVER] = ", serverData.iScores[DART_PLAYER_HOME_SERVER])
//				CDEBUG1LN(DEBUG_DARTS, "serverData.iScores[DART_PLAYER_AWAY_SERVER] = ", serverData.iScores[DART_PLAYER_AWAY_SERVER])
//				CDEBUG1LN(DEBUG_DARTS, "serverData.iLastScore[DART_PLAYER_HOME_SERVER].iLastScore = ", serverData.iLastScore[DART_PLAYER_HOME_SERVER])
//				CDEBUG1LN(DEBUG_DARTS, "serverData.iLastScore[DART_PLAYER_AWAY_SERVER].iLastScore = ", serverData.iLastScore[DART_PLAYER_AWAY_SERVER])
//				CDEBUG1LN(DEBUG_DARTS, "serverData.iLegs[DART_PLAYER_HOME_SERVER] = ", serverData.iLegs[DART_PLAYER_HOME_SERVER])
//				CDEBUG1LN(DEBUG_DARTS, "serverData.iLegs[DART_PLAYER_AWAY_SERVER] = ", serverData.iLegs[DART_PLAYER_AWAY_SERVER])
//				CDEBUG1LN(DEBUG_DARTS, "serverData.iSets[DART_PLAYER_HOME_SERVER] = ", serverData.iSets[DART_PLAYER_HOME_SERVER])
//				CDEBUG1LN(DEBUG_DARTS, "serverData.iSets[DART_PLAYER_AWAY_SERVER] = ", serverData.iSets[DART_PLAYER_AWAY_SERVER])
//				CDEBUG1LN(DEBUG_DARTS, "serverData.iNumLegs = ", serverData.iNumLegs)
//				CDEBUG1LN(DEBUG_DARTS, "serverData.iNumSets = ", serverData.iNumSets)
//				CDEBUG1LN(DEBUG_DARTS, "serverData.iServerTurn = ", serverData.iServerTurn)
//				CDEBUG1LN(DEBUG_DARTS, "serverData.iTurnscore = ", serverData.iTurnscore)
//				CDEBUG1LN(DEBUG_DARTS, "serverData.iWinner = ", serverData.iWinner)
//				CDEBUG1LN(DEBUG_DARTS, "serverData.iThrower = ", serverData.iThrower)
//				CDEBUG1LN(DEBUG_DARTS, "********** ************ ***********")
//			ENDIF
			
			IF eSpecState >= DARTS_MPSTATE_THROW_OFF
			AND eSpecState < DARTS_MPSTATE_GAME_END
				
				IF NOT IS_PLAYER_SCTV(PLAYER_ID())
					
					IF NOT IS_PLAYER_SWITCH_IN_PROGRESS()
						
						IF NOT DARTS_GET_UI_FLAG(DartsUI.iFlags, DARTS_UIFLAGS_SETUP_INGAME)
							INIT_SIMPLE_USE_CONTEXT(DartsUI.inGameControlContext, FALSE, FALSE, FALSE, TRUE)
							ADD_SIMPLE_USE_CONTEXT_INPUT(DartsUI.inGameControlContext, "DARTS_END_QT", FRONTEND_CONTROL, INPUT_SCRIPT_PAD_RIGHT)
							DARTS_SET_UI_FLAG(DartsUI.iFlags, DARTS_UIFLAGS_SETUP_INGAME, TRUE)
						ENDIF
						
						IF NOT NETWORK_TEXT_CHAT_IS_TYPING()
							UPDATE_SIMPLE_USE_CONTEXT(DartsUI.inGameControlContext, 200, default, default, FALSE)
						ENDIF
						
						IF DARTS_PLAYER_QUIT_CONTROL(PlayerData[iSelfID], DartsUI, iDebugThrottle)
							eSpecState = DARTS_MPSTATE_END
						ENDIF
					ENDIF
				ELSE
					IF NOT IS_PLAYER_SWITCH_IN_PROGRESS()
						IF DARTS_PLAYER_QUIT_CONTROL_SPECTATOR(PlayerData[iSelfID], DartsUI, iDebugThrottle)
							eSpecState = DARTS_MPSTATE_END
						ENDIF
					ENDIF
				ENDIF
				
			ENDIF
			
			SWITCH eSpecState
				
				CASE DARTS_MPSTATE_INIT	
					
					CDEBUG1LN(DEBUG_DARTS, "Spectator has reached Client side INIT")
					INIT_BOARD(MPDartGame.dBoard, Args)
					
					INIT_CAM(MPDartGame.dBoard.vDartBoard, MPDartGame.dBoard.fBoardHeading)
					
					INT k
					REPEAT NUM_DART_TURNS k
						INIT_DARTS(MPDartGame.Darts[k], 0)//iSelfID)
					ENDREPEAT
					
					DARTS_INIT_SCOREBOARD(DartsSB, ENUM_TO_INT(DartsLocation), MPDartGame.dBoard.vDartBoard, MPDartGame.dBoard.fBoardHeading)
					REQUEST_STREAMS(DartsSB)
					REGISTER_SCRIPT_WITH_AUDIO()
					
					//Disabling UI
					DISABLE_ALL_MP_HUD()
					
					DISPLAY_RADAR(FALSE)
					DISABLE_CELLPHONE(TRUE)
					
					GET_WORLD_OFFSETS(MPDartGame.dBoard, DartsPlayerPos, DartsInitReticlePos, TRUE)
					CDEBUG1LN(DEBUG_DARTS, "GET_WORLD_OFFSETS obtained in DARTS_MPSTATE_SETUP")
					
					CDEBUG1LN(DEBUG_DARTS, "GET_WORLD_OFFSETS obtained in DARTS_MPSTATE_SETUP")
					
					DartsPlayerPos.vDartPlayrPos = GET_OFFSET_FROM_COORD_AND_HEADING_IN_WORLD_COORDS( MPDartGame.dBoard.vDartBoard, 
																									MPDartGame.dBoard.fBoardHeading,  
																									<< -0.4, -2.4 + fDartBoardOriginOffset, fBoard_offsetZ-1 >>)	
					DartsPlayerPos.vOpponentPos = GET_OFFSET_FROM_COORD_AND_HEADING_IN_WORLD_COORDS( MPDartGame.dBoard.vDartBoard, 
																									MPDartGame.dBoard.fBoardHeading, 
																									<< 0.5, -2.4 + fDartBoardOriginOffset, fBoard_offsetZ >>)
					IF NOT IS_PED_INJURED(PLAYER_PED_ID())
						SET_ENTITY_COORDS(PLAYER_PED_ID(), vSpectatePos)
						SET_ENTITY_HEADING(PLAYER_PED_ID(), fSpectateHeading)
						IF IS_ENTITY_VISIBLE(PLAYER_PED_ID())
							SET_ENTITY_VISIBLE(PLAYER_PED_ID(), FALSE)
						ENDIF
						
						IF GET_PLAYER_CURRENT_HELD_WEAPON() <> WEAPONTYPE_UNARMED
							//TASK_SWAP_WEAPON(PLAYER_PED_ID(), FALSE)
							SET_CURRENT_PED_WEAPON(PLAYER_PED_ID(), WEAPONTYPE_UNARMED, TRUE)
							CDEBUG1LN(DEBUG_DARTS, "Had to holster weapon again in spectate")
						ENDIF
						
						IF IS_PLAYER_CONTROL_ON(PLAYER_ID())
							IF NOT IS_PLAYER_SCTV(PLAYER_ID())
								SET_PLAYER_CONTROL(PLAYER_ID(), FALSE)
								CDEBUG1LN(DEBUG_DARTS, "Had to turn player control off again in spectate")
							ENDIF
						ENDIF
					ENDIF
					
					//NEW_LOAD_SCENE_START(vHickBar, <<-3.4831, 0.0223, 60.6925>>, 20)
					
					CDEBUG1LN(DEBUG_DARTS, "Spectator Finished Stage_init")
					eSpecState = DARTS_MPSTATE_STREAMING
				BREAK
				
				CASE DARTS_MPSTATE_STREAMING
					IF HAVE_STREAMS_LOADED(DartsSB)
					//AND ( IS_NEW_LOAD_SCENE_LOADED() )
						CDEBUG1LN(DEBUG_DARTS, "Spectator Finished DARTS_MPSTATE_STREAMING")
						eSpecState = DARTS_MPSTATE_SETUP
					ELSE
						CDEBUG1LN(DEBUG_DARTS, "Spectator Loading scene")
					ENDIF
				BREAK
				
				CASE DARTS_MPSTATE_SETUP
					CDEBUG1LN(DEBUG_DARTS, "Reached Spectator side SETUP")
					
					DARTS_ACTIVATE_QUIT_UI(DartsUI.uiQuitControls)
					DARTS_ACTIVATE_ENDGAME_UI(DartsUI.uiEndGameControls)
						
					
					IF NOT DARTS_CHECK_CLIENT_FLAG(PlayerData[iSpectatePlayerID[DART_PLAYER_HOME]], DARTS_CLIENTFLAG_SINGLE_PLAYER)
						sDartsPlayerNames[DART_PLAYER_AWAY] = GET_PLAYER_NAME(NETWORK_GET_PLAYER_INDEX(INT_TO_PARTICIPANTINDEX(iSpectatePlayerID[DART_PLAYER_AWAY])))
						DartsGamerHandle[DART_PLAYER_AWAY] = GET_GAMER_HANDLE_PLAYER(NETWORK_GET_PLAYER_INDEX(INT_TO_PARTICIPANTINDEX(iSpectatePlayerID[DART_PLAYER_AWAY])))
						sCrewTags[DART_PLAYER_AWAY] = GET_PLAYER_CLAN_TAG(DartsGamerHandle[DART_PLAYER_AWAY])
						
						IF NOT IS_PED_INJURED(GET_PLAYER_PED(NETWORK_GET_PLAYER_INDEX(INT_TO_PARTICIPANTINDEX(iSpectatePlayerID[DART_PLAYER_AWAY]))))
							piPlayerClones[DART_PLAYER_AWAY] = CLONE_PED(GET_PLAYER_PED(NETWORK_GET_PLAYER_INDEX(INT_TO_PARTICIPANTINDEX(iSpectatePlayerID[DART_PLAYER_AWAY]))), FALSE, FALSE)
						ENDIF
						
						CDEBUG1LN(DEBUG_DARTS, "sCrewTags ", iSpectatePlayerID[DART_PLAYER_AWAY], " = ", sCrewTags[DART_PLAYER_AWAY])
						IF NOT IS_STRING_EMPTY(sCrewTags[DART_PLAYER_AWAY])
							DARTS_ADD_SB_CREW_TAG(DartsSB, ENUM_TO_INT(DART_PLAYER_AWAY), sCrewTags[DART_PLAYER_AWAY])
						ENDIF
						DARTS_CLEAR_SCORES(DartsSB, ENUM_TO_INT(DART_PLAYER_AWAY))
						
						IF IS_PED_WEARING_HIGH_HEELS(piPlayerClones[DART_PLAYER_AWAY])
							CDEBUG1LN(DEBUG_DARTS, "clone away ped is wearing high heels, taking them off")
							DARTS_TAKE_OFF_HIGH_HEELS(piPlayerClones[DART_PLAYER_AWAY])
						ELSE
							CDEBUG1LN(DEBUG_DARTS, "clone away ped is not wearing high heels")
						ENDIF
					ENDIF
					
					sDartsPlayerNames[DART_PLAYER_HOME] = GET_PLAYER_NAME(NETWORK_GET_PLAYER_INDEX(INT_TO_PARTICIPANTINDEX(iSpectatePlayerID[DART_PLAYER_HOME])))
					DartsGamerHandle[DART_PLAYER_HOME] = GET_GAMER_HANDLE_PLAYER(NETWORK_GET_PLAYER_INDEX(INT_TO_PARTICIPANTINDEX(iSpectatePlayerID[DART_PLAYER_HOME])))
					sCrewTags[DART_PLAYER_HOME] = GET_PLAYER_CLAN_TAG(DartsGamerHandle[DART_PLAYER_HOME])
					
					piOtherPlayer = GET_PLAYER_PED(NETWORK_GET_PLAYER_INDEX(INT_TO_PARTICIPANTINDEX(iSpectatePlayerID[DART_PLAYER_HOME])))
					
					IF NOT IS_PED_INJURED(piOtherPlayer)
						piPlayerClones[DART_PLAYER_HOME] = CLONE_PED(piOtherPlayer, FALSE, FALSE)
					ENDIF
					
					IF IS_PED_WEARING_HIGH_HEELS(piPlayerClones[DART_PLAYER_HOME])
						CDEBUG1LN(DEBUG_DARTS, "clone home ped is wearing high heels, taking them off")
						DARTS_TAKE_OFF_HIGH_HEELS(piPlayerClones[DART_PLAYER_HOME])
					ELSE
						CDEBUG1LN(DEBUG_DARTS, "clone home ped is not wearing high heels")
					ENDIF
					
					CDEBUG1LN(DEBUG_DARTS, "sCrewTags ", iSpectatePlayerID[DART_PLAYER_HOME], " = ", sCrewTags[DART_PLAYER_HOME])
					IF NOT IS_STRING_EMPTY(sCrewTags[DART_PLAYER_HOME])
						DARTS_ADD_SB_CREW_TAG(DartsSB, ENUM_TO_INT(DART_PLAYER_HOME), sCrewTags[DART_PLAYER_HOME])
					ENDIF
					DARTS_CLEAR_SCORES(DartsSB, ENUM_TO_INT(DART_PLAYER_HOME))
					
					IF NOT DARTS_CHECK_CLIENT_FLAG(PlayerData[iSpectatePlayerID[DART_PLAYER_HOME]], DARTS_CLIENTFLAG_SINGLE_PLAYER)
						DARTS_ADD_NAMES(DartsSB, sDartsPlayerNames[DART_PLAYER_AWAY], sDartsPlayerNames[DART_PLAYER_HOME])
					ELSE
						DARTS_ADD_NAMES(DartsSB, "", sDartsPlayerNames[DART_PLAYER_HOME])
					ENDIF
					
					// maybe add already listed scores here
					
					CDEBUG1LN(DEBUG_DARTS, "AM_Darts.sc: g_FMMC_STRUCT.iNumberOfLegs = ", g_FMMC_STRUCT.iNumberOfLegs)
					CDEBUG1LN(DEBUG_DARTS, "AM_Darts.sc: g_FMMC_STRUCT.iNumberOfSets = ", g_FMMC_STRUCT.iNumberOfSets)
					
					IF g_FMMC_STRUCT.iNumberOfLegs > 0
					OR g_FMMC_STRUCT.iNumberOfSets > 0
						UPDATE_SB_SETS_LEGS(DartsSB, 0, 0, 0, 0)
					ENDIF
					
					CLEAR_AREA(Args.vDartBoard, 0.5, TRUE)
					
					DARTS_GAME_CAM()
					
					CDEBUG1LN(DEBUG_DARTS, "spectator Going from DARTS_MPSTATE_SETUP to DARTS_MPSTATE_TUTORIAL")
					eSpecState = DARTS_MPSTATE_TUTORIAL
				BREAK
				
				CASE DARTS_MPSTATE_TUTORIAL
					IF NOT DARTS_CHECK_CLIENT_FLAG(PlayerData[iSpectatePlayerID[DART_PLAYER_HOME]], DARTS_CLIENTFLAG_SINGLE_PLAYER)
					AND ServerData.mpState < DARTS_MPSTATE_SETUP
						CDEBUG1LN(DEBUG_DARTS, "spectator Going to DARTS_MPSTATE_THROW_OFF_SETUP")
						eSpecState = DARTS_MPSTATE_THROW_OFF_SETUP
					ELSE
						DEAL_WITH_FM_MATCH_START(FMMC_TYPE_MG_DARTS, ServerData.iMatchHistoryID, ServerData.iMatchType)
						CDEBUG1LN(DEBUG_DARTS, "spectator Going to DARTS_MPSTATE_SYNC_OBJECTS")
						CDEBUG1LN(DEBUG_DARTS, "ServerData.mpState = ", ServerData.mpState)
						CDEBUG1LN(DEBUG_DARTS, "single player flag = ", DARTS_CHECK_CLIENT_FLAG(PlayerData[iSpectatePlayerID[DART_PLAYER_HOME]], DARTS_CLIENTFLAG_SINGLE_PLAYER))
						eSpecState = DARTS_MPSTATE_SYNC_OBJECTS
					ENDIF
				BREAK
				
				CASE DARTS_MPSTATE_THROW_OFF_SETUP
					IF NOT IS_TIMER_STARTED(controlTimer)
						//SETUP_NEW_BIG_MESSAGE(BIG_MESSAGE_CUSTOM, "DARTS_THRW_OFF", "DARTS_THRW_STR")
						//SET_SCALEFORM_BIG_MESSAGE(DartsUI.siBigMessage, "DARTS_THRW_OFF", "DARTS_THRW_STR", default, default, default, TRUE, MG_BIG_MESSAGE_ANIM_TIME)
						
						START_TIMER_NOW(controlTimer)
						
						IF IS_SCREEN_FADED_OUT()
							DO_SCREEN_FADE_IN(500)
						ENDIF
					ELIF GET_TIMER_IN_SECONDS_SAFE(controlTimer) >= 5.0
					//OR NOT UPDATE_SCALEFORM_BIG_MESSAGE(DartsUI.siBigMessage)
					OR PlayerData[iSpectatePlayerID[DART_PLAYER_HOME]].eMPState = DARTS_MPSTATE_THROW_OFF
					OR PlayerData[iSpectatePlayerID[DART_PLAYER_AWAY]].eMPState = DARTS_MPSTATE_THROW_OFF
						CLEANUP_BIG_MESSAGE()
						CANCEL_TIMER(controlTimer)
						
						UPDATE_HIGHLIGHT(DartsSB, ENUM_TO_INT(DART_PLAYER_HOME))
						
						DARTS_INIT_TIMERS(localDartsTimer)
						
						DEAL_WITH_FM_MATCH_START(FMMC_TYPE_MG_DARTS, ServerData.iMatchHistoryID, ServerData.iMatchType)
						
						eSpecState = DARTS_MPSTATE_THROW_OFF
						
						eSpecTurnStatus = DARTS_MPTURN_WAITING
						eSpecWaitStage = DARTS_MPWAIT_AIM
						iSpecThower = ENUM_TO_INT(DART_PLAYER_HOME)
					ENDIF
				BREAK
				
				CASE DARTS_MPSTATE_THROW_OFF
					IF DARTS_SERVER_CHECK_FLAG(ServerData, DARTSERVERFLAG_DO_THROWOFF)
						IF serverData.mpTurnStatus[iSpectatePlayerID[DART_PLAYER_HOME]] = DARTS_MPTURN_WINNING
						OR serverData.mpTurnStatus[iSpectatePlayerID[DART_PLAYER_AWAY]] = DARTS_MPTURN_WINNING
							eSpecTurnStatus = DARTS_MPTURN_WINNING
						ENDIF
						
						// Do everyting playing related right chea
						SWITCH eSpecTurnStatus 
							CASE DARTS_MPTURN_WAITING
								SWITCH eSpecWaitStage
									CASE DARTS_MPWAIT_AIM
										
										
										
										IF playerData[iSpectatePlayerID[iSpecThower]].bDartThrown
											CDEBUG1LN(DEBUG_DARTS, "Current client finished WAIT - AIMING")
											
											DARTS_SET_UI_FLAG(DartsUI.iFlags, DARTS_UIFLAGS_UPDATE_PRINTED, FALSE)
											
											// grab other players dart throw info so we can throw that thang
											iSpecTurn = ServerData.iServerTurn
											COPY_DART_TO_LOCAL(MPDartGame.Darts[iSpecTurn], playerData[iSpectatePlayerID[iSpecThower]])
											
											eSpecWaitStage = DARTS_MPWAIT_THROW
										ELSE
											IF (GET_GAME_TIMER() % 1500) < 50
												CDEBUG1LN(DEBUG_DARTS, "spectator is waiting for other client to throw")
												CDEBUG1LN(DEBUG_DARTS, "iSpecThower = ", iSpecThower)
												CDEBUG1LN(DEBUG_DARTS, "iSpectatePlayerID[iSpecThower] = ", iSpectatePlayerID[iSpecThower])
												CDEBUG1LN(DEBUG_DARTS, "serverdata.iThrower = ", serverdata.iThrower)
											ENDIF
										ENDIF
									BREAK
									
									CASE DARTS_MPWAIT_THROW		
										CDEBUG1LN(DEBUG_DARTS, "[spec] current client is WAITING - Throwing")
										IF THROW_DART(MPDartGame.Darts[iSpecTurn], MPDartGame.dBoard)
											CDEBUG1LN(DEBUG_DARTS, "Regular Throw Completed - spec side")
											
											bSpecResetDone = FALSE
											
											eSpecWaitStage = DARTS_MPWAIT_SCORE
											CDEBUG1LN(DEBUG_DARTS, "[spec] going to spec side score check")
											eSpecTurnStatus = DARTS_MPTURN_SCORE_CHECK
										ENDIF
									BREAK
									
									CASE DARTS_MPWAIT_SCORE
										IF (GET_GAME_TIMER() % 2000) < 50
											CDEBUG1LN(DEBUG_DARTS, "[spec] going to spec side score check")
										ENDIF
									BREAK
								ENDSWITCH
							BREAK
							
							CASE DARTS_MPTURN_SCORE_CHECK
								
								// spectate is only for sp darts, so tuning this just for that
								IF NOT DARTS_GET_UI_FLAG(DartsUI.iFlags, DARTS_UIFLAGS_UPDATE_PRINTED)
									// if prints are needed 
									DARTS_SET_UI_FLAG(DartsUI.iFlags, DARTS_UIFLAGS_UPDATE_PRINTED, TRUE)
								ENDIF
								
								IF NOT bSpecResetDone
								//AND DARTS_GET_UI_FLAG(serverData.iUIFlags, DARTS_UIFLAGS_TURN_CONTINUE)
									IF (playerData[iSpectatePlayerID[DART_PLAYER_HOME]].bResetDone OR playerData[iSpectatePlayerID[DART_PLAYER_AWAY]].bResetDone)
										CDEBUG1LN(DEBUG_DARTS, "[AM_DARTS] spec is in SCORE CHECK")
										
										eSpecWaitStage = DARTS_MPWAIT_AIM
										
										RESTART_TIMER_NOW(SpectateGateTimer)
										
										CDEBUG1LN(DEBUG_DARTS, "[AM_DARTS] spec finished reset in SCORE CHECK")
										bSpecResetDone = TRUE
									ENDIF
								ELSE
									IF (GET_GAME_TIMER() % 2000) < 50
										CDEBUG1LN(DEBUG_DARTS, "[AM_DARTS] spec waiting for client flag bResetDone")
									ENDIF
								ENDIF
								
								IF bSpecResetDone
								AND ( ServerData.mpTurnStatus[iSpectatePlayerID[DART_PLAYER_HOME]] = DARTS_MPTURN_THROWING
									OR ServerData.mpTurnStatus[iSpectatePlayerID[DART_PLAYER_AWAY]] = DARTS_MPTURN_THROWING )
								AND ( playerData[iSpectatePlayerID[DART_PLAYER_HOME]].eMPThrowStage = DARTS_MPTHROW_AIM
									OR playerData[iSpectatePlayerID[DART_PLAYER_AWAY]].eMPThrowStage = DARTS_MPTHROW_AIM )
								AND GET_TIMER_IN_SECONDS_SAFE(SpectateGateTimer) > 1.0
//									IF DARTS_GET_UI_FLAG(serverData.iUIFlags, DARTS_UIFLAGS_SWITCH_PLAYER) //serverData.bDoSwitchPlayer
										CDEBUG1LN(DEBUG_DARTS, "[AM_DARTS] spec did see server flag for switch_player")
										
										iSpecThower = playerData[iSpectatePlayerID[DART_PLAYER_AWAY]].iOffsetPlayerID
										
										IF NOT DARTS_CHECK_CLIENT_FLAG(PlayerData[iSpectatePlayerID[DART_PLAYER_HOME]], DARTS_CLIENTFLAG_SINGLE_PLAYER)
											UPDATE_HIGHLIGHT(DartsSB, playerData[serverData.iWaiter].iOffsetPlayerID)
										ENDIF
//									ELSE
//										CDEBUG1LN(DEBUG_DARTS, "[AM_DARTS] spec did not see server flag for switch_player")
//									ENDIF
									
									CANCEL_TIMER(SpectateGateTimer)
									
									CDEBUG1LN(DEBUG_DARTS, "[AM_DARTS] spec going back to waiting")
									eSpecTurnStatus = DARTS_MPTURN_WAITING
								ENDIF
							BREAK
							
							CASE DARTS_MPTURN_WINNING
								INT y
								REPEAT NUM_MP_DART_TURNS y
									RESET_DART(MPDartGame.Darts[y])
									MPDartGame.Darts[y].bDoneScoring = FALSE
									CDEBUG1LN(DEBUG_DARTS, "[AM_DARTS]MPDartGame.Darts ", y, " was reset")
								ENDREPEAT
								
								CANCEL_TIMER(controlTimer)
								
								eSpecState = DARTS_MPSTATE_SYNC_OBJECTS
							BREAK
						ENDSWITCH
					ENDIF
				BREAK
				
				CASE DARTS_MPSTATE_SYNC_OBJECTS
					CDEBUG1LN(DEBUG_DARTS, "spectator DARTS_MPSTATE_SYNC_OBJECTS")
					i = 0
					j = 0
					
					// TODO this will have to be adjusted to account for mid game joins
					// looks like other player will have to place this info in the broadcast data
					REPEAT NUM_MP_DART_PLAYERS i
						MPDartGame.iThrowsTaken[i] 	= 0
						MPDartGame.iBullsEyesHit[i]	= 0
						DARTS_CLEAR_SCORES(DartsSB, i)
						iSpecLastScore[i] = 301
					ENDREPEAT
					
					DARTS_ADD_SCORE(DartsSB, ENUM_TO_INT(DART_PLAYER_HOME), 301)
					IF NOT DARTS_CHECK_CLIENT_FLAG(PlayerData[iSpectatePlayerID[DART_PLAYER_HOME]], DARTS_CLIENTFLAG_SINGLE_PLAYER)
						DARTS_ADD_SCORE(DartsSB, ENUM_TO_INT(DART_PLAYER_AWAY), 301)
					ENDIF
					
					REPEAT  NUM_MP_DART_TURNS j
						RESET_DART(MPDartGame.Darts[j])
						MPDartGame.Darts[j].bDoneScoring = FALSE
						CDEBUG1LN(DEBUG_DARTS, "[AM_DARTS]MPDartGame.Darts ", j, " was reset")
					ENDREPEAT
					
					//RESET_CLIENT_DART(PlayerData[DART_PLAYER_HOME_SERVER])
					
					DARTS_INIT_TIMERS(localDartsTimer)
					
					eSpecWaitStage = DARTS_MPWAIT_AIM
					
					MPDartGame.bEndGameMessageDisplayed = FALSE
					MPDartGame.bWinNoise = FALSE
					
					bInWinRange = FALSE
					
					CLEAR_AREA(Args.vDartBoard, 0.5, TRUE)
					REMOVE_DECALS_IN_RANGE(Args.vDartBoard, 0.5)
					
					eSpecState = DARTS_MPSTATE_SETUP_POST
				BREAK
				
				CASE DARTS_MPSTATE_SETUP_POST
					IF ServerData.mpState = DARTS_MPSTATE_IN_PROGRESS
						
						DARTS_GAME_CAM()
						SET_GAMEPLAY_CAM_RELATIVE_HEADING(0.0)
						SET_GAMEPLAY_CAM_RELATIVE_PITCH(0.0)
						
						eSpecState = DARTS_MPSTATE_IN_PROGRESS
						eSpecTurnStatus = DARTS_MPTURN_WAITING
						eSpecWaitStage = DARTS_MPWAIT_AIM
						CDEBUG1LN(DEBUG_DARTS, "spectator is proceeding to IN PROGRESS")
						
						IF NOT DARTS_CHECK_CLIENT_FLAG(PlayerData[iSpectatePlayerID[DART_PLAYER_HOME]], DARTS_CLIENTFLAG_SINGLE_PLAYER)
							iSpecThower = PICK_INT((serverData.iCoinFlip = 0), ENUM_TO_INT(DART_PLAYER_AWAY), ENUM_TO_INT(DART_PLAYER_HOME))
						ELSE
							iSpecThower = ENUM_TO_INT(DART_PLAYER_HOME)
						ENDIF
						
						IF NOT DARTS_CHECK_CLIENT_FLAG(PlayerData[iSpectatePlayerID[DART_PLAYER_HOME]], DARTS_CLIENTFLAG_SINGLE_PLAYER)
							UPDATE_HIGHLIGHT(DartsSB, PICK_INT((serverData.iCoinFlip = 0), ENUM_TO_INT(DART_PLAYER_AWAY), ENUM_TO_INT(DART_PLAYER_HOME)))
						ELSE
							UPDATE_HIGHLIGHT(DartsSB, ENUM_TO_INT(DART_PLAYER_HOME))
						ENDIF
						bWaitUIShow = FALSE
					ENDIF
				BREAK
				
				CASE DARTS_MPSTATE_WAIT_POST_MENU
					CDEBUG1LN(DEBUG_DARTS, "[AM_DARTS] has reached Client side WAIT POST MENU")
					// Sitting in a waiting state
					
					IF DARTS_SERVER_CHECK_FLAG(serverData, DARTSERVERFLAG_MOVETOGAME)
						PlayerData[iSpectatePlayerID[DART_PLAYER_HOME]].eMPState = DARTS_MPSTATE_IN_PROGRESS
					ENDIF
				BREAK
				
				CASE DARTS_MPSTATE_IN_PROGRESS
					
					// failsafe for player not being there
					IF NOT IS_PLAYER_SCTV(PLAYER_ID())	//Not needed as the Target is the Focus - Bug 1673437
					AND GET_PLAYER_DISTANCE_FROM_LOCATION(vSpectatePos) > 2.0
						SET_ENTITY_COORDS(PLAYER_PED_ID(), vSpectatePos)
						SET_ENTITY_HEADING(PLAYER_PED_ID(), fSpectateHeading)
						IF IS_ENTITY_VISIBLE(PLAYER_PED_ID())
							SET_ENTITY_VISIBLE(PLAYER_PED_ID(), FALSE)
						ENDIF
						CDEBUG1LN(DEBUG_DARTS, " DARTS - SET PLAYER COORDS (2) ", vSpectatePos)
					ELSE
						// failsafe for screen not fading back in
						IF NOT IS_PLAYER_SCTV(PLAYER_ID())
							IF IS_SCREEN_FADED_OUT()
								DO_SCREEN_FADE_IN(500)
							ENDIF
							
							IF IS_PLAYER_CONTROL_ON(PLAYER_ID())
								SET_PLAYER_CONTROL(PLAYER_ID(), FALSE)
								CDEBUG1LN(DEBUG_DARTS, "Had to turn player control off again in in progress")
							ENDIF
						ENDIF
						
					ENDIF
					
					IF serverData.mpTurnStatus[iSpectatePlayerID[DART_PLAYER_HOME]] = DARTS_MPTURN_WINNING
					OR serverData.mpTurnStatus[iSpectatePlayerID[DART_PLAYER_AWAY]] = DARTS_MPTURN_WINNING
						eSpecTurnStatus = DARTS_MPTURN_WINNING
					ENDIF
					
//					IF (GET_GAME_TIMER() % 1000) < 50
//						CDEBUG1LN(DEBUG_DARTS, "serverData.mpTurnStatus[DART_PLAYER_HOME_SERVER] = ", serverData.mpTurnStatus[DART_PLAYER_HOME_SERVER])
//					ENDIF
					
						// Do everyting playing related right chea
					SWITCH eSpecTurnStatus 
						CASE DARTS_MPTURN_WAITING
							SWITCH eSpecWaitStage
								CASE DARTS_MPWAIT_AIM
									
									IF playerData[iSpectatePlayerID[iSpecThower]].bDartThrown
										CDEBUG1LN(DEBUG_DARTS, "Current client finished WAIT - AIMING")
										
										DARTS_SET_UI_FLAG(DartsUI.iFlags, DARTS_UIFLAGS_UPDATE_PRINTED, FALSE)
										
										// grab other players dart throw info so we can throw that thang
										iSpecTurn = ServerData.iServerTurn
										COPY_DART_TO_LOCAL(MPDartGame.Darts[iSpecTurn], playerData[iSpectatePlayerID[iSpecThower]])
										
										eSpecWaitStage = DARTS_MPWAIT_THROW
									ELSE
										IF (GET_GAME_TIMER() % 2000) < 50
											CDEBUG1LN(DEBUG_DARTS, "Spectator is waiting for client to throw")
											CDEBUG1LN(DEBUG_DARTS, "iSpecThower = ", iSpecThower)
											CDEBUG1LN(DEBUG_DARTS, "iSpectatePlayerID[iSpecThower] = ", iSpectatePlayerID[iSpecThower])
											CDEBUG1LN(DEBUG_DARTS, "playerData[iSpectatePlayerID[iSpecThower]].bDartThrown = ", playerData[iSpectatePlayerID[iSpecThower]].bDartThrown)
										ENDIF
									ENDIF
								BREAK
								
								CASE DARTS_MPWAIT_THROW		
									CDEBUG1LN(DEBUG_DARTS, "[spec] current client is WAITING - Throwing")
									IF THROW_DART(MPDartGame.Darts[iSpecTurn], MPDartGame.dBoard)
										CDEBUG1LN(DEBUG_DARTS, "Regular Throw Completed - spec side")
										
										bSpecResetDone = FALSE
										
										eSpecWaitStage = DARTS_MPWAIT_SCORE
										CDEBUG1LN(DEBUG_DARTS, "[spec] going to spec side score check")
										eSpecTurnStatus = DARTS_MPTURN_SCORE_CHECK
									ENDIF
								BREAK
								
								CASE DARTS_MPWAIT_SCORE
									IF (GET_GAME_TIMER() % 2000) < 50
										CDEBUG1LN(DEBUG_DARTS, "[spec] going to spec side score check")
									ENDIF
								BREAK
							ENDSWITCH
						BREAK
						
						CASE DARTS_MPTURN_SCORE_CHECK
							
							// spectate is only for sp darts, so tuning this just for that
							IF NOT DARTS_GET_UI_FLAG(DartsUI.iFlags, DARTS_UIFLAGS_UPDATE_PRINTED)
								// if prints are needed 
								DARTS_SET_UI_FLAG(DartsUI.iFlags, DARTS_UIFLAGS_UPDATE_PRINTED, TRUE)
							ENDIF
							
							IF NOT bSpecResetDone
							//AND DARTS_GET_UI_FLAG(serverData.iUIFlags, DARTS_UIFLAGS_TURN_CONTINUE)
								IF (playerData[iSpectatePlayerID[DART_PLAYER_HOME]].bResetDone OR playerData[iSpectatePlayerID[DART_PLAYER_AWAY]].bResetDone)
									CDEBUG1LN(DEBUG_DARTS, "[AM_DARTS] spec is in SCORE CHECK")
									
									eSpecWaitStage = DARTS_MPWAIT_AIM
									
									RESTART_TIMER_NOW(SpectateGateTimer)
									
									CDEBUG1LN(DEBUG_DARTS, "[AM_DARTS] spec finished reset in SCORE CHECK")
									bSpecResetDone = TRUE
								ENDIF
							ELSE
								IF (GET_GAME_TIMER() % 2000) < 50
									CDEBUG1LN(DEBUG_DARTS, "[AM_DARTS] spec waiting for client flag bResetDone")
								ENDIF
							ENDIF
							
							IF bSpecResetDone
							AND ( ServerData.mpTurnStatus[iSpectatePlayerID[DART_PLAYER_HOME]] = DARTS_MPTURN_THROWING
								OR (ServerData.mpTurnStatus[iSpectatePlayerID[DART_PLAYER_AWAY]] = DARTS_MPTURN_THROWING 
									AND NOT DARTS_CHECK_CLIENT_FLAG(PlayerData[iSpectatePlayerID[DART_PLAYER_HOME]], DARTS_CLIENTFLAG_SINGLE_PLAYER)) )
							AND ( playerData[iSpectatePlayerID[DART_PLAYER_HOME]].eMPThrowStage = DARTS_MPTHROW_AIM
								OR (playerData[iSpectatePlayerID[DART_PLAYER_AWAY]].eMPThrowStage = DARTS_MPTHROW_AIM 
									AND NOT DARTS_CHECK_CLIENT_FLAG(PlayerData[iSpectatePlayerID[DART_PLAYER_HOME]], DARTS_CLIENTFLAG_SINGLE_PLAYER)))
							AND GET_TIMER_IN_SECONDS_SAFE(SpectateGateTimer) > 1.0
								IF DARTS_GET_UI_FLAG(serverData.iUIFlags, DARTS_UIFLAGS_SWITCH_PLAYER) //serverData.bDoSwitchPlayer
									CDEBUG1LN(DEBUG_DARTS, "[AM_DARTS] spec did see server flag for switch_player")
									// sending the darts back to the player, resetting them
									// serves the same functioon as RESET_DART without deleting the object
									INT y
									REPEAT NUM_MP_DART_TURNS y
										RESET_DART(MPDartGame.Darts[y])
										MPDartGame.Darts[y].bDoneScoring = FALSE
										CDEBUG1LN(DEBUG_DARTS, "[spec] MPDartGame.Darts ", y, " was reset")
									ENDREPEAT
									
									IF iSpecLastScore[playerData[ServerData.iThrower].iOffsetPlayerID] <> ServerData.iScores[ServerData.iThrower]
										DARTS_ADD_SCORE(DartsSB, playerData[ServerData.iThrower].iOffsetPlayerID, ServerData.iScores[ServerData.iThrower])
									ENDIF
									
									CDEBUG2LN(DEBUG_DARTS, "[AM_DARTS] ServerData.iThrower = ", ServerData.iThrower)
									CDEBUG2LN(DEBUG_DARTS, "[AM_DARTS] ServerData.iLastScore = ", ServerData.iLastScore[ServerData.iThrower])
									CDEBUG2LN(DEBUG_DARTS, "[AM_DARTS] ServerData.iScores = ", ServerData.iScores[ServerData.iThrower])
									CDEBUG2LN(DEBUG_DARTS, "[AM_DARTS] iSpecLastScore = ", iSpecLastScore[playerData[ServerData.iThrower].iOffsetPlayerID])
									
									CDEBUG2LN(DEBUG_DARTS, "[AM_DARTS] ServerData.mpTurnStatus[iSpectatePlayerID[DART_PLAYER_HOME]] = ", ServerData.mpTurnStatus[iSpectatePlayerID[DART_PLAYER_HOME]])
									CDEBUG2LN(DEBUG_DARTS, "[AM_DARTS] ServerData.mpTurnStatus[iSpectatePlayerID[DART_PLAYER_AWAY]] = ", ServerData.mpTurnStatus[iSpectatePlayerID[DART_PLAYER_AWAY]])
									CDEBUG2LN(DEBUG_DARTS, "[AM_DARTS] playerData[iSpectatePlayerID[DART_PLAYER_HOME]].eMPThrowStage = ", playerData[iSpectatePlayerID[DART_PLAYER_HOME]].eMPThrowStage)
									CDEBUG2LN(DEBUG_DARTS, "[AM_DARTS] playerData[iSpectatePlayerID[DART_PLAYER_AWAY]].eMPThrowStage = ", playerData[iSpectatePlayerID[DART_PLAYER_AWAY]].eMPThrowStage)
									
									IF ServerData.mpTurnStatus[iSpectatePlayerID[DART_PLAYER_HOME]] = DARTS_MPTURN_THROWING
										iSpecThower = playerData[iSpectatePlayerID[DART_PLAYER_HOME]].iOffsetPlayerID
										CDEBUG1LN(DEBUG_DARTS, "[AM_DARTS] iSpecThower is going home")
									ELSE
										iSpecThower = playerData[iSpectatePlayerID[DART_PLAYER_AWAY]].iOffsetPlayerID
										CDEBUG1LN(DEBUG_DARTS, "[AM_DARTS] iSpecThower is going away")
									ENDIF
									
									CDEBUG1LN(DEBUG_DARTS, "[AM_DARTS] iSpecThower = ", iSpecThower)
									
									IF NOT DARTS_CHECK_CLIENT_FLAG(PlayerData[iSpectatePlayerID[DART_PLAYER_HOME]], DARTS_CLIENTFLAG_SINGLE_PLAYER)
										UPDATE_HIGHLIGHT(DartsSB, playerData[serverData.iWaiter].iOffsetPlayerID)
										CDEBUG1LN(DEBUG_DARTS, "[AM_DARTS] changed highlight to player ", playerData[serverData.iWaiter].iOffsetPlayerID)
									ENDIF
								ELSE
									CDEBUG1LN(DEBUG_DARTS, "[AM_DARTS] spec did not see server flag for switch_player")
								ENDIF
								
								CANCEL_TIMER(SpectateGateTimer)
								
								
								
								
								
								CDEBUG1LN(DEBUG_DARTS, "[AM_DARTS] spec going back to waiting")
								eSpecTurnStatus = DARTS_MPTURN_WAITING
							ENDIF
						BREAK
						
						CASE DARTS_MPTURN_WINNING
							CDEBUG1LN(DEBUG_DARTS, "********** serverData.iWinner = ", serverData.iWinner)
							
							CLEAR_PRINTS()
							
							IF DARTS_SERVER_CHECK_FLAG(serverData, DARTSERVERFLAG_DO_TRANSITION)
								CDEBUG1LN(DEBUG_DARTS, "[spec] server said to go to transition")
								iSplashStage = 0
								RESTART_TIMER_NOW(controlTimer)
								eSpecState = DARTS_MPSTATE_GAME_TRANSITION
							ELSE
								RESTART_TIMER_NOW(controlTimer)
								CDEBUG1LN(DEBUG_DARTS, "[spec] server said to go to game end")
								eSpecState = DARTS_MPSTATE_GAME_END
							ENDIF
						BREAK
					ENDSWITCH
				BREAK
				
				CASE DARTS_MPSTATE_GAME_TRANSITION
					
					SET_PLAYER_INVISIBLE_LOCALLY(NETWORK_GET_PLAYER_INDEX(INT_TO_PARTICIPANTINDEX(iSpectatePlayerID[DART_PLAYER_HOME])))
					
					IF NOT DARTS_CHECK_CLIENT_FLAG(PlayerData[iSpectatePlayerID[DART_PLAYER_HOME]], DARTS_CLIENTFLAG_SINGLE_PLAYER)
						SET_PLAYER_INVISIBLE_LOCALLY(NETWORK_GET_PLAYER_INDEX(INT_TO_PARTICIPANTINDEX(iSpectatePlayerID[DART_PLAYER_AWAY])))
					ENDIF
					
					SWITCH iSplashStage
						CASE 0
							IF GET_TIMER_IN_SECONDS_SAFE(controlTimer) > 1.5
								CLEAR_HELP()
								
								//ANOTHER_GAME_CAM_MP(PLAYER_PED_ID())
								ANOTHER_GAME_CAM()
								
								SET_SHARD_BIG_MESSAGE(shardMidSizeMessage, "DARTS_WINP", "", 2500, SHARD_MESSAGE_MIDSIZED, HUD_COLOUR_WHITE)
								
								IF DARTS_CHECK_CLIENT_FLAG(PlayerData[iSpectatePlayerID[DART_PLAYER_HOME]], DARTS_CLIENTFLAG_SINGLE_PLAYER)
									UPDATE_SB_SETS_LEGS(DartsSB, 0, serverData.iSets[iSpectatePlayerID[DART_PLAYER_HOME]], 0, serverData.iLegs[iSpectatePlayerID[DART_PLAYER_HOME]])
								ELSE
									UPDATE_SB_SETS_LEGS(DartsSB, serverData.iSets[iSpectatePlayerID[DART_PLAYER_AWAY]], serverData.iSets[iSpectatePlayerID[DART_PLAYER_HOME]], 
														serverData.iLegs[iSpectatePlayerID[DART_PLAYER_AWAY]], serverData.iLegs[iSpectatePlayerID[DART_PLAYER_HOME]])
								ENDIF
								
								INT iWhichOutro
									
								FLOAT fResolution
								fResolution = GET_ASPECT_RATIO(TRUE)
								CDEBUG1LN(DEBUG_DARTS, " fResolution = ", fResolution)
								
								IF fResolution > 2.0
									CDEBUG1LN(DEBUG_DARTS, " resolution is eyefinity")
									scenePosition = << 1992.29407, 3047.57690, 46.21517 >>
									sceneRotation = << 0.000, 0.000, 138.740 >>
								ELSE
									CDEBUG1LN(DEBUG_DARTS, "resolution is not eyefinity")
									scenePosition = << 1992.33569, 3047.92432, 46.21517 >>
									sceneRotation = << 0.000, 0.000, 136.740 >>
								ENDIF
								
								iWhichOutro = (GET_RANDOM_INT_IN_RANGE() % 3)
								
								CDEBUG1LN(DEBUG_DARTS, "iWhichOutro = ", iWhichOutro)
								
								iSceneID = CREATE_SYNCHRONIZED_SCENE(scenePosition, sceneRotation)
								camDartsSync = CREATE_CAM("DEFAULT_ANIMATED_CAMERA", FALSE)
								PLAY_SYNCHRONIZED_CAM_ANIM(camDartsSync, iSceneID, sOutroCam[iWhichOutro], "mini@dartsoutro")
								SET_CAM_ACTIVE(camDartsSync, TRUE)
								RENDER_SCRIPT_CAMS(TRUE, FALSE)
								
								IF NOT DARTS_CHECK_CLIENT_FLAG(PlayerData[iSpectatePlayerID[DART_PLAYER_HOME]], DARTS_CLIENTFLAG_SINGLE_PLAYER)
									IF NOT IS_PED_INJURED(piPlayerClones[0])
									AND NOT IS_PED_INJURED(piPlayerClones[1])
										
										IF serverData.iWinner = iSpectatePlayerID[DART_PLAYER_HOME]
											TASK_SYNCHRONIZED_SCENE (piPlayerClones[DART_PLAYER_HOME], iSceneID, "mini@dartsoutro", sOutroWin[iWhichOutro], INSTANT_BLEND_IN, WALK_BLEND_OUT )
											TASK_SYNCHRONIZED_SCENE (piPlayerClones[DART_PLAYER_AWAY], iSceneID, "mini@dartsoutro", sOutroLoss[iWhichOutro], INSTANT_BLEND_IN, WALK_BLEND_OUT )
											TASK_PLAY_ANIM(piPlayerClones[DART_PLAYER_HOME], sFacialDictPed, sFacialClip[GET_RANDOM_INT_IN_RANGE(0, 3)], WALK_BLEND_IN, WALK_BLEND_OUT, -1, AF_SECONDARY | AF_LOOPING)
										ELSE
											TASK_SYNCHRONIZED_SCENE (piPlayerClones[DART_PLAYER_AWAY], iSceneID, "mini@dartsoutro", sOutroWin[iWhichOutro], INSTANT_BLEND_IN, WALK_BLEND_OUT )
											TASK_SYNCHRONIZED_SCENE (piPlayerClones[DART_PLAYER_HOME], iSceneID, "mini@dartsoutro", sOutroLoss[iWhichOutro], INSTANT_BLEND_IN, WALK_BLEND_OUT )
											TASK_PLAY_ANIM(piPlayerClones[DART_PLAYER_AWAY], sFacialDictPed2, sFacialClip2[GET_RANDOM_INT_IN_RANGE(0, 3)], WALK_BLEND_IN, WALK_BLEND_OUT, -1, AF_SECONDARY | AF_LOOPING)
										ENDIF
									ENDIF
								ELSE
									IF NOT IS_PED_INJURED(piPlayerClones[DART_PLAYER_HOME])
										TASK_SYNCHRONIZED_SCENE (piPlayerClones[DART_PLAYER_HOME], iSceneID, "mini@dartsoutro", sOutroWin[iWhichOutro], INSTANT_BLEND_IN, WALK_BLEND_OUT )
										TASK_PLAY_ANIM(piPlayerClones[DART_PLAYER_HOME], sFacialDictPed, sFacialClip[GET_RANDOM_INT_IN_RANGE(0, 3)], WALK_BLEND_IN, WALK_BLEND_OUT, -1, AF_SECONDARY | AF_LOOPING)
									ENDIF
								ENDIF
								
								iSplashStage++
							ENDIF
						BREAK
						
						CASE 1
							IF NOT UPDATE_SHARD_BIG_MESSAGE(shardMidSizeMessage, TRUE)
								
								RESET_SHARD_BIG_MESSAGE(shardMidSizeMessage)
								
								REPEAT NUM_MP_DART_PLAYERS i
									DARTS_CLEAR_SCORES(DartsSB, i)
								ENDREPEAT
								
								REPEAT NUM_MP_DART_TURNS j
									RESET_DART(MPDartGame.Darts[j])
								ENDREPEAT
								
								iSplashStage++
							ENDIF
						BREAK
						
						CASE 2
							CDEBUG1LN(DEBUG_DARTS, "spec going to wait post game Starting another set/leg")
							
							DARTS_GAME_CAM()
							
							IF NOT DARTS_CHECK_CLIENT_FLAG(PlayerData[iSpectatePlayerID[DART_PLAYER_HOME]], DARTS_CLIENTFLAG_SINGLE_PLAYER)
								IF NOT IS_PED_INJURED(piPlayerClones[DART_PLAYER_AWAY])
								AND NOT IS_PED_INJURED(piPlayerClones[DART_PLAYER_HOME])
									DESTROY_CAM(camDartsSync)
									CLEAR_PED_TASKS (piPlayerClones[DART_PLAYER_AWAY])
									CLEAR_PED_TASKS (piPlayerClones[DART_PLAYER_HOME])
								ENDIF
							ELSE
								IF NOT IS_PED_INJURED(piPlayerClones[DART_PLAYER_HOME])
									DESTROY_CAM(camDartsSync)
									CLEAR_PED_TASKS (piPlayerClones[DART_PLAYER_HOME])
								ENDIF
							ENDIF
							
							
							
							iSplashStage = 0
							eSpecState = DARTS_MPSTATE_WAIT_POST_GAME
						BREAK
						
					ENDSWITCH
				BREAK
				
				CASE DARTS_MPSTATE_GAME_END
					
					IF (GET_GAME_TIMER() % 2500) < 50
						CDEBUG1LN(DEBUG_DARTS, "Reached spec side GAME END")
					ENDIF
					
					IF NETWORK_IS_PARTICIPANT_ACTIVE(INT_TO_PARTICIPANTINDEX(iSpectatePlayerID[DART_PLAYER_HOME]))
						SET_PLAYER_INVISIBLE_LOCALLY(NETWORK_GET_PLAYER_INDEX(INT_TO_PARTICIPANTINDEX(iSpectatePlayerID[DART_PLAYER_HOME])))
						IF (GET_GAME_TIMER() % 2500) < 50
							CDEBUG1LN(DEBUG_DARTS, "home player succesfully set invisible")
						ENDIF
					ELSE
						CDEBUG1LN(DEBUG_DARTS, "home player not set invisible, participant is not active")
					ENDIF
					
					IF NOT DARTS_CHECK_CLIENT_FLAG(PlayerData[iSpectatePlayerID[DART_PLAYER_HOME]], DARTS_CLIENTFLAG_SINGLE_PLAYER)
						IF NETWORK_IS_PARTICIPANT_ACTIVE(INT_TO_PARTICIPANTINDEX(iSpectatePlayerID[DART_PLAYER_AWAY]))
							SET_PLAYER_INVISIBLE_LOCALLY(NETWORK_GET_PLAYER_INDEX(INT_TO_PARTICIPANTINDEX(iSpectatePlayerID[DART_PLAYER_AWAY])))
							CDEBUG1LN(DEBUG_DARTS, "away player succesfully set invisible")
						ELSE
							CDEBUG1LN(DEBUG_DARTS, "away player not set invisible, participant is not active")
						ENDIF
					ENDIF
					
					IF GET_TIMER_IN_SECONDS_SAFE(controlTimer) > 0.75
						// wait for the player to pick an option
						IF MPDartGame.bEndGameMessageDisplayed 
							
							UPDATE_SHARD_BIG_MESSAGE(shardBigMessage)
							
							IF DID_I_JOIN_MISSION_AS_SPECTATOR()
							AND NOT IS_PLAYER_SCTV(PLAYER_ID())
								IF HAS_NET_TIMER_STARTED(serverData.timeLeaderboardTimeOut)
								OR (IS_SYNCHRONIZED_SCENE_RUNNING(iSceneID) AND GET_SYNCHRONIZED_SCENE_PHASE(iSceneID) >= 0.995)
								OR NOT IS_SYNCHRONIZED_SCENE_RUNNING(iSceneID)
									
//									IF MAINTAIN_END_OF_MISSION_SCREEN(sEndOfMission, serverData.sServerFMMC_EOM,
//																GET_TIME_DIFFERENCE(GET_NETWORK_TIME(),serverData.timeLeaderboardTimeOut.timer) >= VIEW_LEADERBOARD_TIME,
//																FALSE, FALSE, FALSE, FALSE, FALSE, serverData.timeLeaderboardTimeOut.timer, VIEW_LEADERBOARD_TIME, "LBD_TIMEOUT", TRUE)
										//Go to cleanup state
										CDEBUG1LN(DEBUG_DARTS, "spectate voted")
										eSpecState = DARTS_MPSTATE_END
//									ELSE
//										//DISPLAY_DARTS_LEADERBOARD(DartsUI, DartsEndScreen, iXPGained, DartsUI.iOurScore, DartsUI.iTheirScore, iBetWinnings)
//									ENDIF
								ENDIF
							ENDIF
							
							// player wants another game
							IF PlayerData[iSpectatePlayerID[DART_PLAYER_HOME]].bDoRematch 
							OR PlayerData[iSpectatePlayerID[DART_PLAYER_AWAY]].bDoRematch
								IF serverData.mpState >= DARTS_MPSTATE_SETUP
									
									INT iTemp1, iTemp2
									iTemp1 = ENUM_TO_INT(DART_PLAYER_AWAY)
									iTemp2 = ENUM_TO_INT(DART_PLAYER_HOME)
									
									CDEBUG1LN(DEBUG_DARTS, "iTemp1 = ", iTemp1, " iTemp2 = ", iTemp2)
									DARTS_CLEAR_SCORES(DartsSB, iTemp1)
									DARTS_CLEAR_SCORES(DartsSB, iTemp2)
									
									IF DID_I_JOIN_MISSION_AS_SPECTATOR()
									AND NOT IS_PLAYER_SCTV(PLAYER_ID())
										CDEBUG1LN(DEBUG_DARTS, "transitioning into actual game")
										
									ELSE
										CDEBUG1LN(DEBUG_DARTS, "spec state going to wait post game")
										eSpecState = DARTS_MPSTATE_WAIT_POST_GAME
									ENDIF
									
								ENDIF
							ENDIF
							
						ELSE
							
							// wait 'til we've finished rendering the player win/lost text
							IF NOT MPDartGame.bAnotherCamActive
								
								CLEAR_HELP()
								CLEAR_PRINTS()
								
								DartsUI.iOurScore += serverData.iSets[iSelfID]
								DartsUI.iTheirScore += serverData.iSets[iOtherID]
								DartsUI.sMyName = sDartsPlayerNames[PlayerData[iSelfID].iOffsetPlayerID]
								DartsUI.sTheirName = sDartsPlayerNames[PlayerData[iOtherID].iOffsetPlayerID]
								
								SET_SHARD_BIG_MESSAGE(shardBigMessage, "DARTS_WINP", "DARTS_WINSP")
								
								INT iWhichOutro
									
								FLOAT fResolution
								fResolution = GET_ASPECT_RATIO(TRUE)
								CDEBUG1LN(DEBUG_DARTS, " fResolution = ", fResolution)
								
								IF fResolution > 2.0
									CDEBUG1LN(DEBUG_DARTS, " resolution is eyefinity")
									scenePosition = << 1992.29407, 3047.57690, 46.21517 >>
									sceneRotation = << 0.000, 0.000, 138.740 >>
								ELSE
									CDEBUG1LN(DEBUG_DARTS, "resolution is not eyefinity")
									scenePosition = << 1992.33569, 3047.92432, 46.21517 >>
									sceneRotation = << 0.000, 0.000, 136.740 >>
								ENDIF
								
								iWhichOutro = (GET_RANDOM_INT_IN_RANGE() % 3)
								
								CDEBUG1LN(DEBUG_DARTS, "iWhichOutro = ", iWhichOutro)
								
								iSceneID = CREATE_SYNCHRONIZED_SCENE(scenePosition, sceneRotation)
								camDartsSync = CREATE_CAM("DEFAULT_ANIMATED_CAMERA", FALSE)
								PLAY_SYNCHRONIZED_CAM_ANIM(camDartsSync, iSceneID, sOutroCam[iWhichOutro], "mini@dartsoutro")
								SET_CAM_ACTIVE(camDartsSync, TRUE)
								RENDER_SCRIPT_CAMS(TRUE, FALSE)
								
								IF NOT DARTS_CHECK_CLIENT_FLAG(PlayerData[iSpectatePlayerID[DART_PLAYER_HOME]], DARTS_CLIENTFLAG_SINGLE_PLAYER)
									IF NOT IS_PED_INJURED(piPlayerClones[0])
									AND NOT IS_PED_INJURED(piPlayerClones[1])
										
										IF serverData.iWinner = iSpectatePlayerID[DART_PLAYER_HOME]
											TASK_SYNCHRONIZED_SCENE (piPlayerClones[DART_PLAYER_HOME], iSceneID, "mini@dartsoutro", sOutroWin[iWhichOutro], INSTANT_BLEND_IN, WALK_BLEND_OUT )
											TASK_SYNCHRONIZED_SCENE (piPlayerClones[DART_PLAYER_AWAY], iSceneID, "mini@dartsoutro", sOutroLoss[iWhichOutro], INSTANT_BLEND_IN, WALK_BLEND_OUT )
											TASK_PLAY_ANIM(piPlayerClones[DART_PLAYER_HOME], sFacialDictPed, sFacialClip[GET_RANDOM_INT_IN_RANGE(0, 3)], WALK_BLEND_IN, WALK_BLEND_OUT, -1, AF_SECONDARY | AF_LOOPING)
										ELSE
											TASK_SYNCHRONIZED_SCENE (piPlayerClones[DART_PLAYER_AWAY], iSceneID, "mini@dartsoutro", sOutroWin[iWhichOutro], INSTANT_BLEND_IN, WALK_BLEND_OUT )
											TASK_SYNCHRONIZED_SCENE (piPlayerClones[DART_PLAYER_HOME], iSceneID, "mini@dartsoutro", sOutroLoss[iWhichOutro], INSTANT_BLEND_IN, WALK_BLEND_OUT )
											TASK_PLAY_ANIM(piPlayerClones[DART_PLAYER_AWAY], sFacialDictPed2, sFacialClip2[GET_RANDOM_INT_IN_RANGE(0, 3)], WALK_BLEND_IN, WALK_BLEND_OUT, -1, AF_SECONDARY | AF_LOOPING)
										ENDIF
									ENDIF
								ELSE
									IF NOT IS_PED_INJURED(piPlayerClones[DART_PLAYER_HOME])
										TASK_SYNCHRONIZED_SCENE (piPlayerClones[DART_PLAYER_HOME], iSceneID, "mini@dartsoutro", sOutroWin[iWhichOutro], INSTANT_BLEND_IN, WALK_BLEND_OUT )
										TASK_PLAY_ANIM(piPlayerClones[DART_PLAYER_HOME], sFacialDictPed, sFacialClip[GET_RANDOM_INT_IN_RANGE(0, 3)], WALK_BLEND_IN, WALK_BLEND_OUT, -1, AF_SECONDARY | AF_LOOPING)
									ENDIF
								ENDIF
								
								//ANOTHER_GAME_CAM()
								DartsUI.iEndDelay = GET_GAME_TIMER()
								
								PRINT_HELP("DARTS_SPECAD")
								
								MPDartGame.bAnotherCamActive = TRUE
							
							//ELIF NOT IS_CAM_INTERPOLATING(camAnotherGameMP)
							ELIF GET_GAME_TIMER() - DartsUI.iEndDelay > 400
								
								MPDartGame.bEndGameMessageDisplayed = TRUE
								
							ENDIF
						ENDIF
					ENDIF
					
				BREAK
				
				CASE DARTS_MPSTATE_WAIT_POST_GAME
					DEBUG_MESSAGE_PERIODIC("spectate DARTS_MPSTATE_WAIT_POST_GAME", iDebugThrottle)
					
					IF (PlayerData[iSpectatePlayerID[DART_PLAYER_HOME]].bDoRematch AND PlayerData[iSpectatePlayerID[DART_PLAYER_AWAY]].bDoRematch)
					OR (PlayerData[iSpectatePlayerID[DART_PLAYER_HOME]].bDoRematch AND DARTS_CHECK_CLIENT_FLAG(PlayerData[iSpectatePlayerID[DART_PLAYER_HOME]], DARTS_CLIENTFLAG_SINGLE_PLAYER))
					OR PlayerData[iSpectatePlayerID[DART_PLAYER_HOME]].eMPState = DARTS_MPSTATE_IN_PROGRESS
						//IF serverData.mpState = DARTS_MPSTATE_SETUP
							CDEBUG1LN(DEBUG_DARTS, "spectate going to sync objects")
							eSpecState = DARTS_MPSTATE_SYNC_OBJECTS
						//ENDIF
					ENDIF
					
				BREAK
				
				CASE DARTS_MPSTATE_TERMINATE_SPLASH
					IF (GET_GAME_TIMER() % 1000) < 50
						CDEBUG1LN(DEBUG_DARTS, "spec is chilling in DARTS_MPSTATE_TERMINATE_SPLASH")
						IF DID_I_JOIN_MISSION_AS_SPECTATOR()
							CDEBUG1LN(DEBUG_DARTS, "still being seen as a spectator")
						ELSE
							CDEBUG1LN(DEBUG_DARTS, "no longer a spectator - this is physically impossible")
						ENDIF
					ENDIF
				BREAK
				
				CASE DARTS_MPSTATE_END
					IF HAS_NET_TIMER_STARTED(timeDartsAwardFailSafe)
					
						//RENDER_SCRIPT_CAMS(FALSE, FALSE)
						DARTS_SETUP_MP_QUIT_CAM()
						
						CLEANUP_BIG_MESSAGE()
						
						IF IS_SCREEN_FADED_OUT()
						OR IS_SCREEN_FADING_OUT()
							DO_SCREEN_FADE_IN(500)
						ENDIF
						
						CLEANUP_MP_DARTS_GAME(MPDartGame, DartsUI)
						CDEBUG1LN(DEBUG_DARTS, "spec cleanup called in DARTS_MPSTATE_END")
						
						IF NOT g_TransitionSessionNonResetVars.sPostMissionCleanupData.bRequestLeaderBoardCam
							REQUEST_LEADERBOARD_CAM()
						ELIF IS_LEADERBOARD_CAM_READY(TRUE)
							REINIT_NET_TIMER(timeDartsAwardFailSafe)
							SET_RESULT_SCREEN_DISPLAYING_STATE(FALSE)
							
							CDEBUG1LN(DEBUG_DARTS, "spec going to DARTS_MPSTATE_LEAVE")
							PlayerData[iSelfID].eMPState = DARTS_MPSTATE_LEAVE
						ENDIF
					ELSE
						START_NET_TIMER(timeDartsAwardFailSafe)
						CDEBUG1LN(DEBUG_DARTS, "started failsafe net timer")
					ENDIF
				BREAK
				
				CASE DARTS_MPSTATE_LEAVE
					
					DEAL_WITH_FM_MATCH_END(FMMC_TYPE_MG_DARTS, ServerData.iMatchHistoryID, missionScriptArgs.mdID.idVariation, 
											PICK_INT(MPDartGame.bDartWinner, 1, 0), PICK_INT(MPDartGame.bDartWinner, 1, 2))
					SET_RESULT_SCREEN_DISPLAYING_STATE(FALSE)
					CLEANUP_MP_DARTS_GAME(MPDartGame, DartsUI)
					CDEBUG1LN(DEBUG_DARTS, "spec cleanup called in DARTS_MPSTATE_LEAVE")
				BREAK
				
			ENDSWITCH
		
//  ---------------------------------------------------------------------------------------------------------------------------------			

		ELSE
			// #NORMAL GAMEPLAY HERE VVVVVVV
			
			// If we have a match end event, bail
			IF SHOULD_THIS_MULTIPLAYER_THREAD_TERMINATE()
			OR SHOULD_PLAYER_LEAVE_MP_MISSION(TRUE)
				
				IF PlayerData[iSelfID].eMPState < DARTS_MPSTATE_GAME_END
				AND serverData.mpTurnStatus[iSelfID]  < DARTS_MPTURN_WINNING
				AND (MPDartGame.iGamesWon = 0)
				AND (MPDartGame.iGamesLost = 0)
					CDEBUG1LN(DEBUG_DARTS, "Also giving money back to the player in line 970")
					IF IS_DARTS_GAME_ALMOST_DONE(ServerData, PlayerData)
						INCREMENT_BY_MP_INT_CHARACTER_AWARD(MP_AWARD_WIN_AT_DARTS , 1)
						iBetWinnings = BROADCAST_BETTING_MISSION_FINISHED(PLAYER_ID())
					ELSE
						iBetWinnings = BROADCAST_BETTING_MISSION_FINISHED_TIED()
					ENDIF
					CDEBUG1LN(DEBUG_DARTS, "iBetWinnings = ", iBetWinnings)
				
					IF RECEIVED_EVENT(EVENT_NETWORK_END_MATCH)
						bMinigamePlayerQuitFlag = TRUE
					ENDIF
				
				ENDIF
				
				CDEBUG1LN(DEBUG_DARTS, "SHOULD_THIS_MULTIPLAYER_THREAD_TERMINATE returned true, CLEANING UP DARTS")
				CLEANUP_MP_DARTS_GAME(MPDartGame, DartsUI)
			ENDIF
			
			//If the mission is being told to die
			IF SHOULD_PLAYER_LEAVE_MP_MISSION(TRUE)
				IF PlayerData[iSelfID].eMPState < DARTS_MPSTATE_GAME_END
				AND serverData.mpTurnStatus[iSelfID]  < DARTS_MPTURN_WINNING
				AND (MPDartGame.iGamesWon = 0)
				AND (MPDartGame.iGamesLost = 0)
					CDEBUG1LN(DEBUG_DARTS, "Also giving money back to the player in line 970")
					
					IF IS_DARTS_GAME_ALMOST_DONE(ServerData, PlayerData)
						INCREMENT_BY_MP_INT_CHARACTER_AWARD(MP_AWARD_WIN_AT_DARTS , 1)
						iBetWinnings = BROADCAST_BETTING_MISSION_FINISHED(PLAYER_ID())
					ELSE
						iBetWinnings = BROADCAST_BETTING_MISSION_FINISHED_TIED()
					ENDIF
					CDEBUG1LN(DEBUG_DARTS, "iBetWinnings = ", iBetWinnings)
				ENDIF
				
				CDEBUG1LN(DEBUG_DARTS, "SHOULD_PLAYER_LEAVE_MP_MISSION returned true, CLEANING UP DARTS")
				CLEANUP_MP_DARTS_GAME(MPDartGame, DartsUI)
			ENDIF
			
			
			IF IS_PED_INJURED(PLAYER_PED_ID())
				CDEBUG1LN(DEBUG_DARTS, "IS_PED_INJURED(PLAYER_PED_ID()) returned true, CLEANING UP DARTS")
				CLEANUP_MP_DARTS_GAME(MPDartGame, DartsUI)
			ENDIF
			
			IF (	(iNumberOfPlayers < 2
					AND PlayerData[iSelfID].eMPState < DARTS_MPSTATE_GAME_END)
				OR (PlayerData[iOtherID].eMPState > DARTS_MPSTATE_WAIT_POST_GAME
					AND PlayerData[iSelfID].eMPState < DARTS_MPSTATE_GAME_END)	)
			AND NOT DARTS_CHECK_CLIENT_FLAG(PlayerData[iSelfID], DARTS_CLIENTFLAG_SINGLE_PLAYER)
				
				IF NOT IS_PED_INJURED(PLAYER_PED_ID())
					CLEAR_PED_TASKS_IMMEDIATELY(PLAYER_PED_ID())
				ENDIF
				
				IF PlayerData[iSelfID].eMPState = DARTS_MPSTATE_GAME_END
				OR PlayerData[iSelfID].eMPState = DARTS_MPSTATE_WAIT_POST_GAME
					CDEBUG1LN(DEBUG_DARTS, "game had already ended, setting terminate reason to ENDGAME")
					terminateReason = DARTS_MPTERMINATEREASON_ENDGAME
				ELSE
					CDEBUG1LN(DEBUG_DARTS, "game was still in play, setting terminate reason to PLAYERLEFT")
					terminateReason = DARTS_MPTERMINATEREASON_PLAYERLEFT
				
					IF IS_DARTS_GAME_ALMOST_DONE(ServerData, PlayerData)
						INCREMENT_BY_MP_INT_CHARACTER_AWARD(MP_AWARD_WIN_AT_DARTS , 1)
						iBetWinnings = BROADCAST_BETTING_MISSION_FINISHED(PLAYER_ID())
					ELSE
						iBetWinnings = BROADCAST_BETTING_MISSION_FINISHED_TIED()
					ENDIF
					CDEBUG1LN(DEBUG_DARTS, "iBetWinnings in 1812 is ", iBetWinnings)
				ENDIF
				
				BROADCAST_DARTS_BOARD_ACTIVATE(PLAYER_ID(), FALSE)
				CDEBUG1LN(DEBUG_DARTS, "NETWORK_GET_NUM_PLAYERS() < 2 returned true, CLEANING UP DARTS")
				CDEBUG1LN(DEBUG_DARTS, "NETWORK_GET_NUM_PLAYERS() has returned: ", iNumberOfPlayers)
				CDEBUG1LN(DEBUG_DARTS, "AM_Darts: PlayerData[iOtherID].eMPState at this moment = ", PlayerData[iOtherID].eMPState)
				CDEBUG1LN(DEBUG_DARTS, "AM_Darts: PlayerData[iSelfID].eMPState at this moment = ", PlayerData[iSelfID].eMPState)
				PlayerData[iSelfID].eMPState = DARTS_MPSTATE_TERMINATE_SPLASH
			ELSE
				IF (GET_GAME_TIMER() % 10000) < 50
					CDEBUG1LN(DEBUG_DARTS, "AM_Darts: NETWORK_GET_NUM_PLAYERS() = ", NETWORK_GET_NUM_PLAYERS(PlayerData, TRUE))
					CDEBUG1LN(DEBUG_DARTS, "AM_Darts: PlayerData[iOtherID].eMPState  = ", PlayerData[iOtherID].eMPState)
					CDEBUG1LN(DEBUG_DARTS, "AM_Darts: PlayerData[iSelfID].eMPState   = ", PlayerData[iSelfID].eMPState)
					CDEBUG1LN(DEBUG_DARTS, "AM_Darts: host status   = ", NETWORK_IS_HOST_OF_THIS_SCRIPT())
				ENDIF
			ENDIF
			
			// checking for new spectators
			IF DARTS_CHECK_CLIENT_FLAG(PlayerData[iSelfID], DARTS_CLIENTFLAG_SINGLE_PLAYER)
			AND NETWORK_GET_NUM_PARTICIPANTS() = 2
				// listen for spectator flag
				IF DARTS_CHECK_CLIENT_FLAG(PlayerData[iOtherID], DARTS_CLIENTFLAG_I_AM_SPECTATOR)
					IF NOT DARTS_CHECK_CLIENT_FLAG(PlayerData[iSelfID], DARTS_CLIENTFLAG_NEW_CHALLENGER)
						CDEBUG1LN(DEBUG_DARTS, "A new challenger has been sensed")
						DARTS_SET_CLIENT_FLAG(PlayerData[iSelfID], DARTS_CLIENTFLAG_NEW_CHALLENGER)
					ENDIF
				ENDIF
			ELIF DARTS_CHECK_CLIENT_FLAG(PlayerData[iSelfID], DARTS_CLIENTFLAG_NEW_CHALLENGER)
			AND NETWORK_GET_NUM_PARTICIPANTS() < 2
				CDEBUG1LN(DEBUG_DARTS, "New challenger left")
				DARTS_CLEAR_CLIENT_FLAG(PlayerData[iSelfID], DARTS_CLIENTFLAG_NEW_CHALLENGER)
			ENDIF
			
			#IF IS_DEBUG_BUILD
			TEXT_LABEL_63 sTest = "NETWORK_GET_NUM_PARTICIPANTS Num Players "
			sTest += CONVERT_INT_TO_STRING(NETWORK_GET_NUM_PARTICIPANTS())
			
			TEXT_LABEL_63 sTest2 = "NETWORK_GET_NUM_SCRIPT_PARTICIPANTS Num Players "
			sTest2 += CONVERT_INT_TO_STRING(NETWORK_GET_NUM_SCRIPT_PARTICIPANTS("AM_Darts", NETWORK_GET_INSTANCE_ID_OF_THIS_SCRIPT()))
			
			DRAW_DEBUG_TEXT_2D(sTest, <<0.6, 0.25, 0>>)
			DRAW_DEBUG_TEXT_2D(sTest2, <<0.6, 0.28, 0>>)
			
			#ENDIF
			
	//		IF GET_CURRENT_GAMEMODE() != GAMEMODE_FM
	//			IF DOES_ENTITY_EXIST(PLAYER_PED_ID())
	//				IF IS_PED_RAGDOLL(PLAYER_PED_ID())
	//					IF NOT IS_PED_INJURED(PLAYER_PED_ID())
	//						CLEAR_PED_TASKS_IMMEDIATELY(PLAYER_PED_ID())
	//					ENDIF
	//					BROADCAST_DARTS_BOARD_ACTIVATE(PLAYER_ID(), FALSE)
	//					CDEBUG1LN(DEBUG_DARTS, "ONE OF THE PEDS IS RAGDOLLING")
	//					CLEANUP_MP_DARTS_GAME(MPDartGame, DartsUI)
	//				ENDIF
	//			ENDIF
	//			
	//			IF DOES_ENTITY_EXIST(PlayerData[iSelfID].piOther)
	//				IF IS_PED_RAGDOLL(PlayerData[iSelfID].piOther)
	//					IF NOT IS_PED_INJURED(PLAYER_PED_ID())
	//						CLEAR_PED_TASKS_IMMEDIATELY(PLAYER_PED_ID())
	//					ENDIF
	//					
	//					BROADCAST_DARTS_BOARD_ACTIVATE(PLAYER_ID(), FALSE)
	//					CDEBUG1LN(DEBUG_DARTS, "OTHER PLAYER IS RAGDOLLING")
	//					CLEANUP_MP_DARTS_GAME(MPDartGame, DartsUI)
	//				ENDIF
	//			ELSE
	//				DEBUG_MESSAGE_PERIODIC("PlayerData[iSelfID].piOther does NOT exist.  what up with that?", iDebugThrottle)
	//			ENDIF
	//				
	//		ENDIF
			
			IF IS_BIT_SET(MPGlobals.DartsData.iDisplayState, 5)
				IF NOT IS_PED_INJURED(PLAYER_PED_ID())
					CLEAR_PED_TASKS_IMMEDIATELY(PLAYER_PED_ID())
				ENDIF
				PRINT_NOW("DARTS_ENEMIES", DEFAULT_GOD_TEXT_TIME, 0)
				BROADCAST_DARTS_BOARD_ACTIVATE(PLAYER_ID(), FALSE)
				CDEBUG1LN(DEBUG_DARTS, "ENEMIES IN THE HOUSE, CLEANING UP")
				CLEANUP_MP_DARTS_GAME(MPDartGame, DartsUI)
			ENDIF
			
			// Detecting quit flags thrown by server
			IF DARTS_PLAYER_PROCESS_SERVER_FLAGS(ServerData, PlayerData[iSelfID], localDartsTimer)
				
				IF IS_DARTS_GAME_ALMOST_DONE(ServerData, PlayerData)
					INCREMENT_BY_MP_INT_CHARACTER_AWARD(MP_AWARD_WIN_AT_DARTS , 1)
					iBetWinnings = BROADCAST_BETTING_MISSION_FINISHED(PLAYER_ID())
				ELSE
					iBetWinnings = BROADCAST_BETTING_MISSION_FINISHED_TIED()
				ENDIF
				CDEBUG1LN(DEBUG_DARTS, "iBetWinnings = ", iBetWinnings)
			ENDIF
			
			// Process Events thrown from other clients
			//DARTS_BROADCAST_PROCESS_EVENTS(Player[iSelfID])  // TODO: this isn't currently being used all that much... not much at all.  take out?
			
			// chalk scoreboard
			IF PlayerData[iSelfID].eMPState > DARTS_MPSTATE_SETUP
				DRAW_SCALEFORM_MOVIE_3D(DartsSB.siScoreBoard, DartsSB.vScoreBoardPos, DartsSB.vScoreBoardRot, DartsSB.vScoreBoardScale, DartsSB.vScoreBoardScale)
			ENDIF
			
			
			IF PlayerData[iSelfID].eMPState = DARTS_MPSTATE_READY_UP
				IF NOT IS_PED_INJURED(piOtherPlayer)
//					NETWORK_OVERRIDE_COORDS_AND_HEADING(piOtherPlayer, DartsPlayerPos.vOpponentPos, MPDartGame.dBoard.fBoardHeading)
				ENDIF
			ENDIF
			
			IF PlayerData[iSelfID].eMPState >= DARTS_MPSTATE_THROW_OFF
			AND PlayerData[iSelfID].eMPState < DARTS_MPSTATE_GAME_END //DARTS_MPSTATE_TERMINATE_SPLASH
				IF DARTS_PLAYER_QUIT_CONTROL(PlayerData[iSelfID], DartsUI, iDebugThrottle)
					bMinigamePlayerQuitFlag = TRUE
					
					IF IS_DARTS_GAME_ALMOST_DONE(ServerData, PlayerData)
						INCREMENT_BY_MP_INT_CHARACTER_AWARD(MP_AWARD_WIN_AT_DARTS , 1)
						iBetWinnings = BROADCAST_BETTING_MISSION_FINISHED(NETWORK_GET_PLAYER_INDEX(INT_TO_PARTICIPANTINDEX(iOtherID)))
					ELSE
						iBetWinnings = BROADCAST_BETTING_MISSION_FINISHED_TIED()
					ENDIF
					
					SET_VARS_ON_FMMC_EOM_VOTE_PASSING(ciFMMC_EOM_VOTE_STATUS_QUIT, <<0.0, 0.0, 0.0>>, contentID)
					
					DartsUI.iTheirScore++
					PlayerData[iSelfID].eMPState = DARTS_MPSTATE_END
				ENDIF
			ENDIF
			
			SWITCH PlayerData[iSelfID].eMPState
				CASE DARTS_MPSTATE_WAIT_PRE_INIT
					IF ServerData.mpState > DARTS_MPSTATE_INIT
						IF NOT IS_PED_INJURED(PLAYER_PED_ID())
							//TASK_SWAP_WEAPON(PLAYER_PED_ID(), FALSE)
							SET_CURRENT_PED_WEAPON(PLAYER_PED_ID(), WEAPONTYPE_UNARMED, TRUE)
							IF GET_CURRENT_GAMEMODE() = GAMEMODE_FM 
								CDEBUG1LN(DEBUG_DARTS, "Darts Faded out at DARTS_MPSTATE_WAIT_PRE_INIT")
								SET_PLAYER_CONTROL(PLAYER_ID(), FALSE)
								START_DARTS_GAME_FADE_OUT()
							ELSE
								CDEBUG1LN(DEBUG_DARTS, "Darts DID NOT Fade out at DARTS_MPSTATE_WAIT_PRE_INIT")
								SET_PLAYER_CONTROL(PLAYER_ID(), FALSE, SPC_LEAVE_CAMERA_CONTROL_ON)
								bAlreadyInGangHouse = TRUE
							ENDIF
							
							CDEBUG1LN(DEBUG_DARTS, "Weapon should be holstered and control should be off")
							
							IF NOT IS_PLAYER_SCTV(PLAYER_ID())
								NET_SET_PLAYER_CONTROL(PLAYER_ID(), FALSE, NSPC_CLEAR_TASKS  | NSPC_CAN_BE_TARGETTED | NSPC_ALLOW_PLAYER_DAMAGE)
							ENDIF
							
							PlayerData[iSelfID].eMPState = DARTS_MPSTATE_PRE_INIT
						ENDIF
					ENDIF
				BREAK
				
				CASE DARTS_MPSTATE_PRE_INIT
					CDEBUG1LN(DEBUG_DARTS, "[AM_DARTS] has reached Client side PRE INIT")
					IF IS_SCREEN_FADED_OUT()
						
						IF GET_CURRENT_GAMEMODE() != GAMEMODE_FM 
							IF NOT IS_PED_INJURED(PLAYER_PED_ID())
								SET_ENTITY_COORDS(PLAYER_PED_ID(), vInitLostHideoutPos)
								NEW_LOAD_SCENE_START(vInitLostHideoutPos, <<-3.4831, 0.0223, 60.6925>>, 20)
							ENDIF
							
							CDEBUG1LN(DEBUG_DARTS, "SET_ENTITY_COORDS and NETWORK_START_LOAD_SCENE done")
						ENDIF
						
						CDEBUG1LN(DEBUG_DARTS, "going to _pre_init_wait")
						PlayerData[iSelfID].eMPState = DARTS_MPSTATE_PRE_INIT_WAIT
					
					ELSE
						
						INIT_BOARD(MPDartGame.dBoard, Args)
						GET_WORLD_OFFSETS(MPDartGame.dBoard, DartsPlayerPos, DartsInitReticlePos, TRUE)
						
						IF iSelfID = DART_PLAYER_AWAY_SERVER
							DartsPlayerPos.vDartPlayrPos = GET_OFFSET_FROM_COORD_AND_HEADING_IN_WORLD_COORDS(MPDartGame.dBoard.vDartBoard, 
																											MPDartGame.dBoard.fBoardHeading, 
																											<< -0.3, -2.6 + fDartBoardOriginOffset, -1.7272 >>)	
						ELSE
							DartsPlayerPos.vDartPlayrPos = GET_OFFSET_FROM_COORD_AND_HEADING_IN_WORLD_COORDS(MPDartGame.dBoard.vDartBoard, 
																											MPDartGame.dBoard.fBoardHeading, 
																											<< 0.3, -2.6 + fDartBoardOriginOffset, -1.7272 >>)
						ENDIF
						
						IF NOT IS_PED_INJURED(PLAYER_PED_ID())
							vPlayerCurrentPos = GET_ENTITY_COORDS(PLAYER_PED_ID())
							
							CLEAR_SEQUENCE_TASK(siTemp)
							OPEN_SEQUENCE_TASK(siTemp)
								
								IF iSelfID = DART_PLAYER_AWAY_SERVER
									TASK_STAND_STILL(NULL, 500)
								ENDIF
								IF vPlayerCurrentPos.z > 75.2
									TASK_JUMP(NULL, FALSE)
								ENDIF
								TASK_FOLLOW_NAV_MESH_TO_COORD(NULL, DartsPlayerPos.vDartPlayrPos, PEDMOVEBLENDRATIO_WALK, 5000, 0.3)
							//	TASK_GO_STRAIGHT_TO_COORD(NULL, DartsPlayerPos.vDartPlayrPos, PEDMOVEBLENDRATIO_WALK)
								TASK_ACHIEVE_HEADING(NULL, MPDartGame.dBoard.fBoardHeading)
								
							CLOSE_SEQUENCE_TASK(siTemp)
							TASK_PERFORM_SEQUENCE(PLAYER_PED_ID(), siTemp)
						ENDIF
						
						CDEBUG1LN(DEBUG_DARTS, "Players tasked to get into position")
						PlayerData[iSelfID].eMPState = DARTS_MPSTATE_PRE_INIT_WAIT
					ENDIF
				BREAK
				
				CASE DARTS_MPSTATE_PRE_INIT_WAIT
					IF NOT bAlreadyInGangHouse
						IF GET_CURRENT_GAMEMODE() != GAMEMODE_FM 
						AND NETWORK_UPDATE_LOAD_SCENE()
							CDEBUG1LN(DEBUG_DARTS, "NETWORK_UPDATE_LOAD_SCENE finished")
							SET_GAMEPLAY_CAM_RELATIVE_HEADING(0.0)
							SET_GAMEPLAY_CAM_RELATIVE_PITCH(0.0)
							PlayerData[iSelfID].eMPState = DARTS_MPSTATE_INIT
							CDEBUG1LN(DEBUG_DARTS, "[AM_DARTS] has reached Client side PRE INIT WAIT")
						ELSE
							SET_GAMEPLAY_CAM_RELATIVE_HEADING(0.0)
							SET_GAMEPLAY_CAM_RELATIVE_PITCH(0.0)
							PlayerData[iSelfID].eMPState = DARTS_MPSTATE_INIT
							CDEBUG1LN(DEBUG_DARTS, "[AM_DARTS] has reached Client side INIT")
						ENDIF
					
					ELIF GET_SCRIPT_TASK_STATUS(PLAYER_PED_ID(), SCRIPT_TASK_PERFORM_SEQUENCE) = FINISHED_TASK //GET_PLAYER_DISTANCE_FROM_LOCATION(DartsPlayerPos.vDartPlayrPos) < 1.5
					AND NOT DARTS_CHECK_CLIENT_FLAG(PlayerData[iSelfID], DARTS_CLIENTFLAG_IN_POSITION)
						CDEBUG1LN(DEBUG_DARTS, "Darts player in place")
						DartPlayerPosition = DART_PLAYER_IN_POSITION
						DARTS_SET_CLIENT_FLAG(PlayerData[iSelfID], DARTS_CLIENTFLAG_IN_POSITION)
					
					ELIF DARTS_CHECK_CLIENT_FLAG(PlayerData[iSelfID], DARTS_CLIENTFLAG_IN_POSITION)
					AND DARTS_CHECK_CLIENT_FLAG(PlayerData[iOtherID], DARTS_CLIENTFLAG_IN_POSITION)
						CDEBUG1LN(DEBUG_DARTS, "Both Darts players in place, fading out")
					//	DO_SCREEN_FADE_OUT(500)
						
						PlayerData[iSelfID].eMPState = DARTS_MPSTATE_INIT
					ENDIF
				BREAK
				
				CASE DARTS_MPSTATE_INIT	
				//	IF (bAlreadyInGangHouse AND IS_SCREEN_FADED_OUT())
				//	OR NOT bAlreadyInGangHouse
						CDEBUG1LN(DEBUG_DARTS, "[AM_DARTS] has reached Client side INIT")
						INIT_BOARD(MPDartGame.dBoard, Args)
						
						INIT_CAM(MPDartGame.dBoard.vDartBoard, MPDartGame.dBoard.fBoardHeading)
						
						INT k
						REPEAT NUM_DART_TURNS k
							INIT_DARTS(MPDartGame.Darts[k], 0)//iSelfID)
							IF GET_CURRENT_GAMEMODE() = GAMEMODE_FM
								//INIT_DARTS(TutorialDarts[k], 0)
							ENDIF
						ENDREPEAT
						
						INIT_SPRITE_RETICLE()
						DARTS_INIT_SCOREBOARD(DartsSB, ENUM_TO_INT(DartsLocation), MPDartGame.dBoard.vDartBoard, MPDartGame.dBoard.fBoardHeading)
						REQUEST_STREAMS(DartsSB)
						REGISTER_SCRIPT_WITH_AUDIO()
						
						//Disabling UI
					//	SET_MP_OVERHEAD_STATS_ACTIVE(FALSE)
					//	DISABLE_SCRIPT_HUD(HUDPART_ALL_OVERHEADS, TRUE)
					//	DISABLE_RANK_AND_XP_BAR()
					//	DISABLE_SCRIPT_HUD(HUDPART_RANKBAR, TRUE)
						DISABLE_ALL_MP_HUD()
						
						DISPLAY_RADAR(FALSE)
						DISABLE_CELLPHONE(TRUE)
						
						FREEZE_ENTITY_POSITION(PLAYER_PED_ID(), TRUE)
						
						iSteadyShotLength = 770 
						
						IF NOT IS_PED_INJURED(PLAYER_PED_ID())
							IF IS_PLAYER_CONTROL_ON(PLAYER_ID())
								IF NOT IS_PLAYER_SCTV(PLAYER_ID())
									SET_PLAYER_CONTROL(PLAYER_ID(), FALSE)
									CDEBUG1LN(DEBUG_DARTS, "Had to turn player control off again in  DARTS_MPSTATE_INIT")
								ENDIF
							ENDIF
						ENDIF
						
						CDEBUG1LN(DEBUG_DARTS, "Finished Stage_init")
						PlayerData[iSelfID].eMPState = DARTS_MPSTATE_STREAMING
				//	ENDIF
				BREAK
				
				CASE DARTS_MPSTATE_STREAMING
					IF HAVE_STREAMS_LOADED(DartsSB)
						PlayerData[iSelfID].eMPState = DARTS_MPSTATE_SETUP
						CDEBUG1LN(DEBUG_DARTS, "[AM_DARTS] Finished STREAMING")
					ENDIF
				BREAK
				
				CASE DARTS_MPSTATE_SETUP
					CDEBUG1LN(DEBUG_DARTS, "Reached Client side SETUP")
					
					DARTS_SET_CLIENT_FLAG(playerData[iSelfID], DARTS_CLIENTFLAG_MATCH_MADE)
					
					// placing the players in their prospective positions
					IF GET_CURRENT_GAMEMODE() = GAMEMODE_FM 
					OR NOT bAlreadyInGangHouse
						
						GET_WORLD_OFFSETS(MPDartGame.dBoard, DartsPlayerPos, DartsInitReticlePos, TRUE)
						CDEBUG1LN(DEBUG_DARTS, "GET_WORLD_OFFSETS obtained in DARTS_MPSTATE_SETUP")
						
						IF NETWORK_IS_HOST_OF_THIS_SCRIPT()
							DartsPlayerPos.vDartPlayrPos = GET_OFFSET_FROM_COORD_AND_HEADING_IN_WORLD_COORDS( MPDartGame.dBoard.vDartBoard, 
																											MPDartGame.dBoard.fBoardHeading, 
																											<< 0.5, -2.4 + fDartBoardOriginOffset, fBoard_offsetZ-1 >>)
							DartsPlayerPos.vOpponentPos = GET_OFFSET_FROM_COORD_AND_HEADING_IN_WORLD_COORDS( MPDartGame.dBoard.vDartBoard, 
																											MPDartGame.dBoard.fBoardHeading, 
																											<< -0.4, -2.4 + fDartBoardOriginOffset, fBoard_offsetZ >>)
						ELSE
							DartsPlayerPos.vDartPlayrPos = GET_OFFSET_FROM_COORD_AND_HEADING_IN_WORLD_COORDS( MPDartGame.dBoard.vDartBoard, 
																											MPDartGame.dBoard.fBoardHeading,
																											<< -0.4, -2.4 + fDartBoardOriginOffset, fBoard_offsetZ-1 >>)	
							DartsPlayerPos.vOpponentPos = GET_OFFSET_FROM_COORD_AND_HEADING_IN_WORLD_COORDS( MPDartGame.dBoard.vDartBoard, 
																											MPDartGame.dBoard.fBoardHeading,
																											<< 0.5, -2.4 + fDartBoardOriginOffset, fBoard_offsetZ >>)
						ENDIF
						
						IF NOT IS_PED_INJURED(PLAYER_PED_ID())
							
							CDEBUG1LN(DEBUG_DARTS, "my player pos = ", DartsPlayerPos.vDartPlayrPos)
							CDEBUG1LN(DEBUG_DARTS, "oponent   pos = ", DartsPlayerPos.vOpponentPos)
							
							SET_ENTITY_COORDS(PLAYER_PED_ID(), DartsPlayerPos.vDartPlayrPos)
							SET_ENTITY_HEADING(PLAYER_PED_ID(), MPDartGame.dBoard.fBoardHeading)
							IF IS_ENTITY_VISIBLE(PLAYER_PED_ID())
								IF NOT DARTS_CHECK_CLIENT_FLAG(PlayerData[iSelfID], DARTS_CLIENTFLAG_SINGLE_PLAYER)
									SET_ENTITY_VISIBLE(PLAYER_PED_ID(), FALSE)
								ENDIF
							ENDIF
							
							IF GET_PLAYER_CURRENT_HELD_WEAPON() <> WEAPONTYPE_UNARMED
								//TASK_SWAP_WEAPON(PLAYER_PED_ID(), FALSE)
								SET_CURRENT_PED_WEAPON(PLAYER_PED_ID(), WEAPONTYPE_UNARMED, TRUE)
								CDEBUG1LN(DEBUG_DARTS, "Had to holster weapon again in  DARTS_MPSTATE_SETUP")
							ENDIF
							
							IF IS_PLAYER_CONTROL_ON(PLAYER_ID())
								IF NOT IS_PLAYER_SCTV(PLAYER_ID())
									SET_PLAYER_CONTROL(PLAYER_ID(), FALSE)
									CDEBUG1LN(DEBUG_DARTS, "Had to turn player control off again in  DARTS_MPSTATE_SETUP")
								ENDIF
							ENDIF
						ENDIF
					ENDIF
					
					oiReticle = CREATE_OBJECT(modelReticleRegular, DartsInitReticlePos.vInitReticlePos, FALSE, FALSE)
					
					oiDartChallenge = CREATE_OBJECT(PROP_DART_1, DartsInitReticlePos.vInitReticlePos, FALSE, FALSE)
					
					// set minigame control scaleforms
					DARTS_ACTIVATE_QUIT_UI(DartsUI.uiQuitControls)
					DARTS_ACTIVATE_ENDGAME_UI(DartsUI.uiEndGameControls)
					
					sDartsPlayerNames[PlayerData[iSelfID].iOffsetPlayerID] = GET_PLAYER_NAME(NETWORK_GET_PLAYER_INDEX(INT_TO_PARTICIPANTINDEX(iSelfID)))
					DartsGamerHandle[PlayerData[iSelfID].iOffsetPlayerID] = GET_GAMER_HANDLE_PLAYER(NETWORK_GET_PLAYER_INDEX(INT_TO_PARTICIPANTINDEX(iSelfID)))
					sCrewTags[PlayerData[iSelfID].iOffsetPlayerID] = GET_PLAYER_CLAN_TAG(DartsGamerHandle[PlayerData[iSelfID].iOffsetPlayerID])
					
					IF NOT DARTS_CHECK_CLIENT_FLAG(PlayerData[iSelfID], DARTS_CLIENTFLAG_SINGLE_PLAYER)
						
						sDartsPlayerNames[PlayerData[iOtherID].iOffsetPlayerID] = GET_PLAYER_NAME(NETWORK_GET_PLAYER_INDEX(INT_TO_PARTICIPANTINDEX(iOtherID)))
						DartsGamerHandle[PlayerData[iOtherID].iOffsetPlayerID] = GET_GAMER_HANDLE_PLAYER(NETWORK_GET_PLAYER_INDEX(INT_TO_PARTICIPANTINDEX(iOtherID)))
						sCrewTags[PlayerData[iOtherID].iOffsetPlayerID] = GET_PLAYER_CLAN_TAG(DartsGamerHandle[PlayerData[iOtherID].iOffsetPlayerID])
						
						piOtherPlayer = GET_PLAYER_PED(NETWORK_GET_PLAYER_INDEX(INT_TO_PARTICIPANTINDEX(iOtherID)))
						
						IF NOT IS_PED_INJURED(GET_PLAYER_PED(NETWORK_GET_PLAYER_INDEX(INT_TO_PARTICIPANTINDEX(iOtherID))))
							piPlayerClones[PlayerData[iOtherID].iOffsetPlayerID] = CLONE_PED(GET_PLAYER_PED(NETWORK_GET_PLAYER_INDEX(INT_TO_PARTICIPANTINDEX(iOtherID))), FALSE, FALSE)
						ENDIF
						
						IF NOT IS_PED_INJURED(GET_PLAYER_PED(NETWORK_GET_PLAYER_INDEX(INT_TO_PARTICIPANTINDEX(iSelfID))))
							piPlayerClones[PlayerData[iSelfID].iOffsetPlayerID] = CLONE_PED(GET_PLAYER_PED(NETWORK_GET_PLAYER_INDEX(INT_TO_PARTICIPANTINDEX(iSelfID))), FALSE, FALSE)
						ENDIF
						
						IF IS_PED_WEARING_HIGH_HEELS(piPlayerClones[PlayerData[iSelfID].iOffsetPlayerID])
							CDEBUG1LN(DEBUG_DARTS, "clone self ped is wearing high heels, taking them off")
							DARTS_TAKE_OFF_HIGH_HEELS(piPlayerClones[PlayerData[iSelfID].iOffsetPlayerID])
						ELSE
							CDEBUG1LN(DEBUG_DARTS, "clone self ped is not wearing high heels")
						ENDIF
						
						IF IS_PED_WEARING_HIGH_HEELS(piPlayerClones[PlayerData[iOtherID].iOffsetPlayerID])
							CDEBUG1LN(DEBUG_DARTS, "clone other ped is wearing high heels, taking them off")
							DARTS_TAKE_OFF_HIGH_HEELS(piPlayerClones[PlayerData[iOtherID].iOffsetPlayerID])
						ELSE
							CDEBUG1LN(DEBUG_DARTS, "clone other ped is not wearing high heels")
						ENDIF
						
						IF NOT IS_PED_INJURED(PLAYER_PED_ID())
							SET_ENTITY_COORDS(PLAYER_PED_ID(), <<1991.1589, 3045.9758, 46.2151>>) // coord out of camera view, since clones are now being used
							IF IS_ENTITY_VISIBLE(PLAYER_PED_ID())
								SET_ENTITY_VISIBLE(PLAYER_PED_ID(), FALSE)
							ENDIF
						ENDIF
						
						INT iTemp1, iTemp2
						iTemp1 = ENUM_TO_INT(DART_PLAYER_AWAY)
						iTemp2 = ENUM_TO_INT(DART_PLAYER_HOME)
						
						CDEBUG1LN(DEBUG_DARTS, "iTemp1 = ", iTemp1, " iTemp2 = ", iTemp2)
						CDEBUG1LN(DEBUG_DARTS, "sCrewTags ", iTemp1, " = ", sCrewTags[iTemp1])
						CDEBUG1LN(DEBUG_DARTS, "sCrewTags ", iTemp2, " = ", sCrewTags[iTemp2])
						
						DARTS_ADD_NAMES(DartsSB, sDartsPlayerNames[iTemp1], sDartsPlayerNames[iTemp2])
						IF NOT IS_STRING_EMPTY(sCrewTags[iTemp1])
							DARTS_ADD_SB_CREW_TAG(DartsSB, iTemp1, sCrewTags[iTemp1])
						ENDIF
						IF NOT IS_STRING_EMPTY(sCrewTags[iTemp2])
							DARTS_ADD_SB_CREW_TAG(DartsSB, iTemp2, sCrewTags[iTemp2])
						ENDIF
						DARTS_CLEAR_SCORES(DartsSB, iTemp1)
						DARTS_CLEAR_SCORES(DartsSB, iTemp2)
						
					ELSE
						CDEBUG1LN(DEBUG_DARTS, "sCrewTags ", PlayerData[iSelfID].iOffsetPlayerID, " = ", sCrewTags[PlayerData[iSelfID].iOffsetPlayerID])
						DARTS_ADD_NAMES(DartsSB, "", sDartsPlayerNames[PlayerData[iSelfID].iOffsetPlayerID])
						IF NOT IS_STRING_EMPTY(sCrewTags[PlayerData[iSelfID].iOffsetPlayerID])
							DARTS_ADD_SB_CREW_TAG(DartsSB, ENUM_TO_INT(DART_PLAYER_HOME), sCrewTags[PlayerData[iSelfID].iOffsetPlayerID])
						ENDIF
						DARTS_CLEAR_SCORES(DartsSB, ENUM_TO_INT(DART_PLAYER_HOME))
					ENDIF
					
					CDEBUG1LN(DEBUG_DARTS, "AM_Darts.sc: g_FMMC_STRUCT.iNumberOfLegs = ", g_FMMC_STRUCT.iNumberOfLegs)
					CDEBUG1LN(DEBUG_DARTS, "AM_Darts.sc: g_FMMC_STRUCT.iNumberOfSets = ", g_FMMC_STRUCT.iNumberOfSets)
					
					IF g_FMMC_STRUCT.iNumberOfLegs > 0
					OR g_FMMC_STRUCT.iNumberOfSets > 0
						UPDATE_SB_SETS_LEGS(DartsSB, 0, 0, 0, 0)
					ENDIF
					
					IF bShowSplash
						SETUP_NEW_BIG_MESSAGE(BIG_MESSAGE_CUSTOM, "MN_DART")
						CDEBUG1LN(DEBUG_DARTS, "AM_Darts.sc: Big 'Darts' Message displayed")
						
						START_TIMER_NOW(controlTimer)
						
						ANOTHER_GAME_CAM_MP(PLAYER_PED_ID())
						RENDER_SCRIPT_CAMS(TRUE, FALSE)
					ENDIF
					
					CLEAR_AREA(Args.vDartBoard, 0.5, TRUE)
					REMOVE_DECALS_IN_RANGE(Args.vDartBoard, 0.5)
					
					SET_ON_JOB_INTRO(TRUE)
					
					CDEBUG1LN(DEBUG_DARTS, "Going from DARTS_MPSTATE_SETUP to DARTS_MPSTATE_READY_UP")
					PlayerData[iSelfID].eMPState = DARTS_MPSTATE_READY_UP
				BREAK
				
				CASE DARTS_MPSTATE_READY_UP
					IF (IS_SCREEN_FADED_OUT() OR IS_SCREEN_FADING_OUT())
					AND GET_TIMER_IN_SECONDS_SAFE(controlTimer) > 1.0
					AND bShowSplash
						CDEBUG1LN(DEBUG_DARTS, "[DARTS_MPSTATE_READY_UP] fade in called for")
						DO_SCREEN_FADE_IN(500)
					ENDIF
					
					IF ( NOT DARTS_CHECK_CLIENT_FLAG(PlayerData[iSelfID], DARTS_CLIENTFLAG_AT_TUTORIAL)
						AND ((IS_CONTROL_JUST_PRESSED(FRONTEND_CONTROL, INPUT_FRONTEND_ACCEPT) AND GET_TIMER_IN_SECONDS_SAFE(controlTimer) > 1.6)
							OR GET_TIMER_IN_SECONDS_SAFE(controlTimer) > 20.0) )
					OR NOT bShowSplash
						
						IF bShowSplash
							CLEANUP_BIG_MESSAGE()
							CANCEL_TIMER(controlTimer)
						ENDIF
						
						//IF IS_BIT_SET(g_iDartsTutorialFlags, gDARTS_MPTUTORIAL_SHOWN)
						//IF GET_MP_BOOL_CHARACTER_STAT(MP_STAT_DARTS_SEEN_TUTORIAL)
							DARTS_SET_CLIENT_FLAG(PlayerData[iSelfID], DARTS_CLIENTFLAG_TUTORIAL_DONE)
							CDEBUG1LN(DEBUG_DARTS, "Tutorial has been seen, skipping it")
							CDEBUG1LN(DEBUG_DARTS, "tbh the tutorial will always get skipped")
						//ELSE
						//	CDEBUG1LN(DEBUG_DARTS, "Tutorial has not been seen yet")
						//ENDIF
						
						PlayerData[iSelfID].eMPState = DARTS_MPSTATE_TUTORIAL
						DARTS_SET_CLIENT_FLAG(PlayerData[iSelfID], DARTS_CLIENTFLAG_AT_TUTORIAL)
					ELSE
						IF NOT DARTS_CHECK_CLIENT_FLAG(PlayerData[iSelfID], DARTS_CLIENTFLAG_AT_TUTORIAL)
						AND bShowSplash
							UPDATE_CUSTOM_BIG_MESSAGE("MN_DART")
						ENDIF
					ENDIF
				BREAK
				
				CASE DARTS_MPSTATE_TUTORIAL
					IF (DARTS_CHECK_CLIENT_FLAG(PlayerData[iSelfID], DARTS_CLIENTFLAG_AT_TUTORIAL) AND DARTS_CHECK_CLIENT_FLAG(PlayerData[iOtherID], DARTS_CLIENTFLAG_AT_TUTORIAL))
					OR (DARTS_CHECK_CLIENT_FLAG(PlayerData[iSelfID], DARTS_CLIENTFLAG_AT_TUTORIAL) AND DARTS_CHECK_CLIENT_FLAG(PlayerData[iSelfID], DARTS_CLIENTFLAG_SINGLE_PLAYER))
						IF GET_CURRENT_GAMEMODE() = GAMEMODE_FM
						AND (NOT (DARTS_CHECK_CLIENT_FLAG(PlayerData[iSelfID], DARTS_CLIENTFLAG_TUTORIAL_DONE) AND DARTS_CHECK_CLIENT_FLAG(PlayerData[iOtherID], DARTS_CLIENTFLAG_TUTORIAL_DONE))
							AND NOT (DARTS_CHECK_CLIENT_FLAG(PlayerData[iSelfID], DARTS_CLIENTFLAG_TUTORIAL_DONE) AND DARTS_CHECK_CLIENT_FLAG(PlayerData[iSelfID], DARTS_CLIENTFLAG_SINGLE_PLAYER)))
							IF DARTS_TUTORIAL(DartsTutorialStage, MPDartGame.dBoard, AIBrain, 
											TurnStage, MPDartGame.Darts, TutorialTimer, PlayerData)
											//TurnStage, TutorialDarts, TutorialTimer, PlayerData)
							
								CDEBUG1LN(DEBUG_DARTS, "FINISHED TUTORIAL")
								//SET_BIT(g_iDartsTutorialFlags, gDARTS_MPTUTORIAL_SHOWN)
								SET_MP_BOOL_CHARACTER_STAT(MP_STAT_DARTS_SEEN_TUTORIAL, TRUE)
								CDEBUG1LN(DEBUG_DARTS, "Setting MP_STAT_DARTS_SEEN_TUTORIAL to true")
								
								IF NOT DARTS_CHECK_CLIENT_FLAG(PlayerData[iSelfID], DARTS_CLIENTFLAG_SINGLE_PLAYER)
									//PlayerData[iSelfID].eMPState = DARTS_MPSTATE_THROW_OFF_SETUP
									PlayerData[iSelfID].eMPState = DARTS_MPSTATE_INTRO_SYNC_SETUP
								ELSE
									CDEBUG1LN(DEBUG_DARTS, "[AM_DARTS]  setting FM Match Start just before the game starts")
									DEAL_WITH_FM_MATCH_START(FMMC_TYPE_MG_DARTS, ServerData.iMatchHistoryID, ServerData.iMatchType)
									
									PlayerData[iSelfID].eMPState = DARTS_MPSTATE_SYNC_OBJECTS
								ENDIF
							ENDIF
							
						ELSE
							CDEBUG1LN(DEBUG_DARTS, "TUTORIAL ALREADY SHOWN, SKIPPING")
							CLEAR_HELP()
							DARTS_GAME_CAM()
							IF NOT DARTS_CHECK_CLIENT_FLAG(PlayerData[iSelfID], DARTS_CLIENTFLAG_SINGLE_PLAYER)
								//PlayerData[iSelfID].eMPState = DARTS_MPSTATE_THROW_OFF_SETUP
								PlayerData[iSelfID].eMPState = DARTS_MPSTATE_INTRO_SYNC_SETUP
							ELSE
								CDEBUG1LN(DEBUG_DARTS, "[AM_DARTS]  setting FM Match Start just before the game starts")
								DEAL_WITH_FM_MATCH_START(FMMC_TYPE_MG_DARTS, ServerData.iMatchHistoryID, ServerData.iMatchType)
								
								PlayerData[iSelfID].eMPState = DARTS_MPSTATE_SYNC_OBJECTS
							ENDIF
						ENDIF
					ENDIF
				BREAK
				
				CASE DARTS_MPSTATE_INTRO_SYNC_SETUP
					
					IF IS_SCREEN_FADED_OUT()
						DO_SCREEN_FADE_IN(500)
						CDEBUG1LN(DEBUG_DARTS, "doing fade in in intro sync setup")
					ELSE
						
						//piOpponentClone = CLONE_PED(piOtherPlayer, FALSE, FALSE)
						SET_PLAYER_INVISIBLE_LOCALLY(NETWORK_GET_PLAYER_INDEX(INT_TO_PARTICIPANTINDEX(iOtherID)))
						SET_PLAYER_INVISIBLE_LOCALLY(PLAYER_ID())
						CDEBUG1LN(DEBUG_DARTS, "created clone")
						
						IF NOT IS_PED_INJURED(piPlayerClones[DART_PLAYER_AWAY])
						AND NOT IS_PED_INJURED(piPlayerClones[DART_PLAYER_HOME])
	//						iSceneId = CREATE_SYNCHRONIZED_SCENE(GET_OFFSET_FROM_ENTITY_IN_WORLD_COORDS(DartsArgs.oiDartBoard, << 0.337842, -0.243051, -0.329731 >>), 
	//																		<< 0, 0, GET_ENTITY_HEADING(DartsArgs.oiDartBoard) - 3.783146>>)
							CDEBUG1LN(DEBUG_DARTS, "tasking sync scene")
							
							iSceneId = CREATE_SYNCHRONIZED_SCENE(<<1992.679, 3050.739, 47.660>>, << 0, 0, 54.000>>)
							camDartsSync = CREATE_CAM("DEFAULT_ANIMATED_CAMERA", FALSE)
							PLAY_SYNCHRONIZED_CAM_ANIM(camDartsSync, iSceneId, "darts_ig_intro_alt1_cam", "mini@dartsintro_alt1")
							SET_CAM_ACTIVE(camDartsSync, TRUE)
							RENDER_SCRIPT_CAMS(TRUE, FALSE)
							TASK_SYNCHRONIZED_SCENE (piPlayerClones[DART_PLAYER_AWAY], iSceneId, "mini@dartsintro_alt1", "darts_ig_intro_alt1_guy1", INSTANT_BLEND_IN, INSTANT_BLEND_OUT )
							TASK_SYNCHRONIZED_SCENE (piPlayerClones[DART_PLAYER_HOME], iSceneId, "mini@dartsintro_alt1", "darts_ig_intro_alt1_guy2", INSTANT_BLEND_IN, INSTANT_BLEND_OUT )
							TASK_PLAY_ANIM(piPlayerClones[DART_PLAYER_AWAY], "mini@dartsintro_alt1", "darts_ig_intro_alt1_guy1_face", NORMAL_BLEND_IN, NORMAL_BLEND_OUT, -1, AF_SECONDARY)
							TASK_PLAY_ANIM(piPlayerClones[DART_PLAYER_HOME], "mini@dartsintro_alt1", "darts_ig_intro_alt1_guy2_face", NORMAL_BLEND_IN, NORMAL_BLEND_OUT, -1, AF_SECONDARY)
							PLAY_SYNCHRONIZED_ENTITY_ANIM( oiDartChallenge, iSceneId, "darts_ig_intro_alt1_dart","mini@dartsintro_alt1" , INSTANT_BLEND_IN )
							
							CDEBUG1LN(DEBUG_DARTS, "going to intro sync play")
							PlayerData[iSelfID].eMPState = DARTS_MPSTATE_INTRO_SYNC_PLAY
						ENDIF
					ENDIF
					
				BREAK
				
				CASE DARTS_MPSTATE_INTRO_SYNC_PLAY
					
					SET_PLAYER_INVISIBLE_LOCALLY(NETWORK_GET_PLAYER_INDEX(INT_TO_PARTICIPANTINDEX(iOtherID)))
					SET_PLAYER_INVISIBLE_LOCALLY(PLAYER_ID())
					
					IF GET_SYNCHRONIZED_SCENE_PHASE(iSceneId) = 1.0
						
						CDEBUG1LN(DEBUG_DARTS, "sync scene is done")
						
						IF NOT IS_PED_INJURED(piPlayerClones[DART_PLAYER_AWAY])
						AND NOT IS_PED_INJURED(piPlayerClones[DART_PLAYER_HOME])
						
							DARTS_GAME_CAM()
							
							DESTROY_CAM(camDartsSync)
							CLEAR_PED_TASKS (piPlayerClones[DART_PLAYER_AWAY])
							CLEAR_PED_TASKS (piPlayerClones[DART_PLAYER_HOME])
							
							DELETE_OBJECT(oiDartChallenge)
							
							PlayerData[iSelfID].eMPState = DARTS_MPSTATE_THROW_OFF_SETUP
							iSplashStage = 0
						ENDIF
					ELSE
						CDEBUG1LN(DEBUG_DARTS, "sync scene is still running")
					ENDIF
					
				BREAK
				
				CASE DARTS_MPSTATE_THROW_OFF_SETUP
					IF NOT IS_TIMER_STARTED(controlTimer)
						
						SET_SHARD_BIG_MESSAGE(shardBigMessage, "DARTS_THRW_OFF", "DARTS_THRW_STR", 3000)
						
						START_TIMER_NOW(controlTimer)
						
						IF IS_SCREEN_FADED_OUT()
							DO_SCREEN_FADE_IN(500)
						ENDIF
					ELIF GET_TIMER_IN_SECONDS_SAFE(controlTimer) >= 3.5
					//OR (IS_CONTROL_JUST_PRESSED(FRONTEND_CONTROL, INPUT_FRONTEND_ACCEPT) 
					//	AND GET_TIMER_IN_SECONDS_SAFE(controlTimer) > 1.6)
					//OR NOT UPDATE_SCALEFORM_BIG_MESSAGE(DartsUI.siBigMessage, TRUE)
					OR NOT UPDATE_SHARD_BIG_MESSAGE(shardBigMessage)
						
						CLEANUP_BIG_MESSAGE()
						CANCEL_TIMER(controlTimer)
						
						CDEBUG1LN(DEBUG_DARTS, "[AM_DARTS]  setting FM Match Start just before the game starts")
						DEAL_WITH_FM_MATCH_START(FMMC_TYPE_MG_DARTS, ServerData.iMatchHistoryID, ServerData.iMatchType)
						
						UPDATE_HIGHLIGHT(DartsSB, ENUM_TO_INT(DART_PLAYER_HOME))
						
						DARTS_INIT_TIMERS(localDartsTimer)
						
						RESET_SHARD_BIG_MESSAGE(shardBigMessage)
						
						DARTS_SET_CLIENT_FLAG(PlayerData[iSelfID], DARTS_CLIENTFLAG_AT_THROWOFF)
						PlayerData[iSelfID].eMPState = DARTS_MPSTATE_THROW_OFF
					ENDIF
				BREAK
				
				// #THROWOFF GAMEPLAY HERE VVVVVVV
				
				CASE DARTS_MPSTATE_THROW_OFF
					
					IF DARTS_SERVER_CHECK_FLAG(ServerData, DARTSERVERFLAG_DO_THROWOFF)
						
						IF IS_SCREEN_FADED_OUT()
							DO_SCREEN_FADE_IN(500)
						ENDIF
						
	//					IF DARTS_PLAYER_QUIT_CONTROL(PlayerData[iSelfID], DartsUI, iDebugThrottle)
	//						PlayerData[iSelfID].eMPState = DARTS_MPSTATE_END
	//					ENDIF
						
						IF NOT DARTS_CHECK_CLIENT_FLAG(playerData[iSelfID], DARTS_CLIENTFLAG_QUIT_ATTEMPTED)
							IF NOT (serverData.mpTurnStatus[iSelfID] = DARTS_MPTURN_WINNING)
							AND ( NOT playerData[iSelfID].bDartThrown = TRUE
								OR NOT playerData[iOtherID].bDartThrown = TRUE )
							AND NOT DARTS_GET_UI_FLAG(serverData.iUIFlags, DARTS_UIFLAGS_SWITCH_PLAYER)
								IF NOT bUITextDisplayed
									IF NOT (serverData.mpTurnStatus[iSelfID] = DARTS_MPTURN_SCORE_CHECK)
										IF bShowShotClockThrowHelp
										AND NOT DARTS_GET_UI_FLAG(DartsUI.iFlags, DARTS_UIFLAGS_SHOT_CLOCK_HELP)
											IF NOT IS_BIT_SET(g_iDartsTutorialFlags, gSHOT_CLOCK_HELP_SHOWN)
												PRINT_HELP("DARTS_TIOT")
												SET_BIT(g_iDartsTutorialFlags, gSHOT_CLOCK_HELP_SHOWN)
											ENDIF
											DARTS_SET_UI_FLAG(DartsUI.iFlags, DARTS_UIFLAGS_SHOT_CLOCK_HELP, TRUE)
										ENDIF
									ENDIF
									DartsUI.bInstructTextTransIn = TRUE
								ELSE
									IF DartsUI.bInstructTextTransIn
										CLEAR_HELP()
										DartsUI.bInstructTextTransIn = FALSE
									ENDIF
								ENDIF
							ENDIF
							
							// Drawing the instuctional button UI
							IF ((playerData[iSelfID].eMPThrowStage = DARTS_MPTHROW_AIM) 
									AND (serverData.mpTurnStatus[iSelfID] = DARTS_MPTURN_THROWING))
							OR bWaitUIShow
								DARTS_MP_THROWOFF_CONTROLS_UI(DartsUI, (serverData.mpTurnStatus[iSelfID] = DARTS_MPTURN_THROWING))
							ENDIF
						ENDIF
						
						// Do everyting playing related right chea
						SWITCH serverData.mpTurnStatus[iSelfID] 
							CASE DARTS_MPTURN_THROWING
								SWITCH playerData[iSelfID].eMPThrowStage
									CASE DARTS_MPTHROW_AIM
										
										//DARTS_GAME_HELP(ServerData.iServerTurn, TRUE)
										
	//									IF NOT DARTS_GET_UI_FLAG(DartsUI.iFlags, DARTS_UIFLAGS_SHOT_CLECK_HELP)
	//										IF NOT IS_BIT_SET(g_iDartsTutorialFlags, gDARTS_CLOCK_HELP_SHOWN)
	//											PRINT_HELP("DARTS_CLOCK")
	//											SET_BIT(g_iDartsTutorialFlags, gDARTS_CLOCK_HELP_SHOWN)
	//										ENDIF
	//										DARTS_SET_UI_FLAG(DartsUI.iFlags, DARTS_UIFLAGS_SHOT_CLECK_HELP, TRUE)
	//									ENDIF
										
										IF NOT IS_BIT_SET(g_iDartsTutorialFlags, gDARTS_AIM_TUT_SHOWN)
											PRINT_HELP("DARTS_AIM_HLP")
											SET_BIT(g_iDartsTutorialFlags, gDARTS_AIM_TUT_SHOWN)
										ELIF NOT IS_THIS_HELP_MESSAGE_BEING_DISPLAYED("DARTS_AIM_HLP")
										AND NOT IS_BIT_SET(g_iDartsTutorialFlags, gDARTS_CLOCK_HELP_SHOWN)
											PRINT_HELP("DARTS_CLOCK")
											SET_BIT(g_iDartsTutorialFlags, gDARTS_CLOCK_HELP_SHOWN)
										ENDIF
										
										IF NOT DARTS_CHECK_CLIENT_FLAG(playerData[iSelfID], DARTS_CLIENTFLAG_QUIT_ATTEMPTED)
											DARTS_DRAW_THROW_OFF_CLOCK(ServerData.DartsTimer, TRUE)
										ENDIF
										
										IF ServerData.DartsTimer.bNewShot
											CDEBUG1LN(DEBUG_DARTS, "Server timer has sensed a new shot!")
										ENDIF
										
										IF ServerData.DartsTimer.bTimeRunOut
											CDEBUG1LN(DEBUG_DARTS, "Server timer has sensed that it has run out!")
										ENDIF
										
										IF (NOT DARTS_CHECK_CLIENT_FLAG(playerData[iSelfID], DARTS_CLIENTFLAG_QUIT_ATTEMPTED)
											AND NOT IS_PAUSE_MENU_ACTIVE())
										OR ServerData.DartsTimer.bTimeRunOut
											IF DO_AIMING(MPDartGame.Darts[serverData.iServerTurn], MPDartGame.dBoard,
														DartsInitReticlePos, FALSE, ServerData.DartsTimer.bTimeRunOut, TRUE)
												CDEBUG1LN(DEBUG_DARTS, "[AM_DARTS->DARTS_MPTHROW_AIM] current client finished AIMING")
												
												IF ServerData.DartsTimer.bTimeRunOut
												AND NOT bShowShotClockThrowHelp
													bShowShotClockThrowHelp = TRUE
												ENDIF
												
												DARTS_SET_UI_FLAG(DartsUI.iFlags, DARTS_UIFLAGS_UPDATE_PRINTED, FALSE)
												
												// copy dart's throw info to the client so that other player can grab it
												CDEBUG1LN(DEBUG_DARTS, "[AM_DARTS->DARTS_MPTHROW_AIM] Copy the throwers data for dart ", 0)
												COPY_DART_TO_CLIENT(playerData[iSelfID], MPDartGame.Darts[serverData.iServerTurn])
												
												IF DARTS_CHECK_CLIENT_FLAG(PlayerData[iSelfID], DARTS_CLIENTFLAG_RETHROW_NEEDED)
													DARTS_CLEAR_CLIENT_FLAG(PlayerData[iSelfID], DARTS_CLIENTFLAG_RETHROW_NEEDED)
												ENDIF
												
												IF MPGlobals.DartsData.iDangerPedCount <= 0
												OR NOT IS_BIT_SET(MPGlobals.DartsData.iDisplayState, 2)
													DARTS_CLEAR_CLIENT_FLAG(PlayerData[iSelfID], DARTS_CLIENTFLAG_DANGER_DART)
													CDEBUG1LN(DEBUG_DARTS, "[AM_DARTS->DARTS_MPTHROW_AIM] no peds in danger zone, clearing danger flag")
												ELSE
													DARTS_SET_CLIENT_FLAG(PlayerData[iSelfID], DARTS_CLIENTFLAG_DANGER_DART)
													CDEBUG1LN(DEBUG_DARTS, "[AM_DARTS->DARTS_MPTHROW_AIM] setting danger flag, peds in danger zone: ", MPGlobals.DartsData.iDangerPedCount)
												ENDIF
												
												playerData[iSelfID].bDartThrown = TRUE
												playerData[iSelfID].eMPThrowStage = DARTS_MPTHROW_THROW
											ENDIF
										ENDIF
									BREAK
									
									CASE DARTS_MPTHROW_THROW
										DEBUG_MESSAGE_PERIODIC("[AM_DARTS] current client is THROWING", iDebugThrottle)
										IF NOT DARTS_CHECK_CLIENT_FLAG(PlayerData[iSelfID], DARTS_CLIENTFLAG_DANGER_DART)
											IF THROW_DART(MPDartGame.Darts[serverData.iServerTurn], MPDartGame.dBoard)
												CDEBUG1LN(DEBUG_DARTS, "Regular Throw completed")
												playerData[iSelfID].bResetDone = FALSE
												playerData[iSelfID].eMPThrowStage = DARTS_MPTHROW_SCORE
											ENDIF
										ELSE
											IF NOT IS_TIMER_STARTED(ReThrowTimer)
												IF THROW_DART_AT_ENTITY(MPDartGame.Darts[ServerData.iServerTurn], MPDartGame.dBoard, << 988.1219, -99.3023, 73.8456 >>)
													BROADCAST_DANGER_ZONE_UPDATE(PLAYER_ID(), DARTS_DANGERZONE_DART_THROW)
													CDEBUG1LN(DEBUG_DARTS, "Danger dart throw completed")
													
													playerData[iSelfID].bDartThrown = FALSE
													playerData[iSelfID].bResetDone = FALSE
													
													RESTART_TIMER_NOW(ReThrowTimer)
												ENDIF
											
											ELIF GET_TIMER_IN_SECONDS(ReThrowTimer) > 1.0
											OR DARTS_CHECK_CLIENT_FLAG(PlayerData[iOtherID], DARTS_CLIENTFLAG_RETHROW_NEEDED)
												
												IF NOT DARTS_CHECK_CLIENT_FLAG(PlayerData[iSelfID], DARTS_CLIENTFLAG_RETHROW_NEEDED)
													DARTS_SET_CLIENT_FLAG(PlayerData[iSelfID], DARTS_CLIENTFLAG_RETHROW_NEEDED)
												ENDIF
												
												CDEBUG1LN(DEBUG_DARTS, "Danger dart throw completed, going back to DARTS_MPTHROW_AIM - THROW SIDE")
												CANCEL_TIMER(ReThrowTimer)
												playerData[iSelfID].eMPThrowStage = DARTS_MPTHROW_AIM
											ENDIF
										ENDIF
									BREAK
									
									CASE DARTS_MPTHROW_SCORE
										//IF PlayerData[iOtherID].eMPWaitStage >= DARTS_MPWAIT_SCORE
											CDEBUG1LN(DEBUG_DARTS, "[AM_DARTS] current client is SCORING")
											
											SCORE_DART(MPDartGame.Darts[serverData.iServerTurn], MPDartGame.dBoard)
											playerData[iSelfID].ClientDart.fLength = MPDartGame.Darts[serverData.iServerTurn].fLength
											
											CDEBUG1LN(DEBUG_DARTS, "[AM_DARTS] THROW - Client Dart ", ServerData.iServerTurn, " fLength = ", playerData[iSelfID].ClientDart.fLength)
											CDEBUG1LN(DEBUG_DARTS, "[AM_DARTS] THROW - Local Dart ", ServerData.iServerTurn, " fLength = ", MPDartGame.Darts[ServerData.iServerTurn].fLength)
											playerData[iSelfID].eMPThrowStage = DARTS_MPTHROW_TURN_CHANGE
										//ENDIF
										DEBUG_MESSAGE_PERIODIC("Current client is waiting for other client to finish throwing", iDebugThrottle)
									BREAK
									
									CASE DARTS_MPTHROW_TURN_CHANGE	
										IF PlayerData[iOtherID].eMPWaitStage >= DARTS_MPWAIT_TURN_CHANGE
											CDEBUG1LN(DEBUG_DARTS, "[AM_DARTS] current client is THROWING - TURN CHANGE")
											
											playerData[iSelfID].bDartThrown = FALSE
											
											DARTS_SET_CLIENT_FLAG(PlayerData[iSelfID], DARTS_CLIENTFLAG_SCORING_DONE)
											
											IF NOT MPDartGame.Darts[serverData.iServerTurn].bDoneScoring
												MPDartGame.Darts[serverData.iServerTurn].bDoneScoring = TRUE
											ENDIF
											SETTIMERA(0)
										ENDIF
										DEBUG_MESSAGE_PERIODIC("Waiting for other client to get to DARTS_MPWAIT_TURN_CHANGE", iDebugThrottle)
									BREAK
								ENDSWITCH
							BREAK
							
							CASE DARTS_MPTURN_WAITING
								SWITCH playerData[iSelfID].eMPWaitStage
									CASE DARTS_MPWAIT_AIM
										
										IF NOT DARTS_CHECK_CLIENT_FLAG(playerData[iSelfID], DARTS_CLIENTFLAG_QUIT_ATTEMPTED)
											DARTS_DRAW_THROW_OFF_CLOCK(ServerData.DartsTimer, FALSE)
										ENDIF
										
										IF NOT bWaitUIShow
											bWaitUIShow = TRUE
										ENDIF
										
										IF playerData[iOtherID].bDartThrown
											CDEBUG1LN(DEBUG_DARTS, "Current client finished WAIT - AIMING")
											
											DARTS_SET_UI_FLAG(DartsUI.iFlags, DARTS_UIFLAGS_UPDATE_PRINTED, FALSE)
											
											// grab other players dart throw info so we can throw that thang
											COPY_DART_TO_LOCAL(MPDartGame.Darts[serverData.iServerTurn], playerData[iOtherID], iOtherID)
											
											IF DARTS_CHECK_CLIENT_FLAG(PlayerData[iSelfID], DARTS_CLIENTFLAG_RETHROW_NEEDED)
												DARTS_CLEAR_CLIENT_FLAG(PlayerData[iSelfID], DARTS_CLIENTFLAG_RETHROW_NEEDED)
											ENDIF
											
											playerData[iSelfID].eMPWaitStage = DARTS_MPWAIT_THROW
										ELSE
											DEBUG_MESSAGE_PERIODIC("Current client is waiting for other client to throw", iDebugThrottle)
										ENDIF
									BREAK
									
									CASE DARTS_MPWAIT_THROW		
										CDEBUG1LN(DEBUG_DARTS, "[AM_DARTS] current client is WAITING - Throwing")
										IF NOT DARTS_CHECK_CLIENT_FLAG(PlayerData[iOtherID], DARTS_CLIENTFLAG_DANGER_DART)
											IF THROW_DART(MPDartGame.Darts[serverData.iServerTurn], MPDartGame.dBoard)
												CDEBUG1LN(DEBUG_DARTS, "Regular Throw Completed - Wait side")
												playerData[iSelfID].bResetDone = FALSE
												playerData[iSelfID].eMPWaitStage = DARTS_MPWAIT_SCORE
											ENDIF
										ELSE
											IF NOT IS_TIMER_STARTED(ReThrowTimer)
												IF THROW_DART_AT_ENTITY(MPDartGame.Darts[ServerData.iServerTurn], MPDartGame.dBoard, << 988.1219, -99.3023, 73.8456 >>)
													CDEBUG1LN(DEBUG_DARTS, "Danger Dart Completed - WAIT SIDE")
													RESTART_TIMER_NOW(ReThrowTimer)
												ENDIF
											
											ELIF GET_TIMER_IN_SECONDS(ReThrowTimer) > 1.0
											OR DARTS_CHECK_CLIENT_FLAG(PlayerData[iOtherID], DARTS_CLIENTFLAG_RETHROW_NEEDED)
												
												IF NOT DARTS_CHECK_CLIENT_FLAG(PlayerData[iSelfID], DARTS_CLIENTFLAG_RETHROW_NEEDED)
													DARTS_SET_CLIENT_FLAG(PlayerData[iSelfID], DARTS_CLIENTFLAG_RETHROW_NEEDED)
												ENDIF
												
												CDEBUG1LN(DEBUG_DARTS, "Danger dart throw completed, going back to DARTS_MPTHROW_AIM - WAIT SIDE")
												CANCEL_TIMER(RethrowTimer)
												playerData[iSelfID].eMPWaitStage = DARTS_MPWAIT_AIM
											ENDIF
										ENDIF
									BREAK
									
									CASE DARTS_MPWAIT_SCORE
										IF PlayerData[iOtherID].eMPThrowStage >= DARTS_MPTHROW_SCORE
											CDEBUG1LN(DEBUG_DARTS, "[AM_DARTS] current client is WAITING - SCORING")
											SCORE_DART(MPDartGame.Darts[serverData.iServerTurn], MPDartGame.dBoard)
											playerData[iSelfID].ClientDart.fLength = MPDartGame.Darts[serverData.iServerTurn].fLength
											
											CDEBUG1LN(DEBUG_DARTS, "[AM_DARTS] WAIT - Client Dart ", ServerData.iServerTurn, " fLength = ", playerData[iSelfID].ClientDart.fLength)
											CDEBUG1LN(DEBUG_DARTS, "[AM_DARTS] WAIT - Local Dart ", ServerData.iServerTurn, " fLength = ", MPDartGame.Darts[serverData.iServerTurn].fLength)
											playerData[iSelfID].eMPWaitStage = DARTS_MPWAIT_TURN_CHANGE
										ENDIF
										DEBUG_MESSAGE_PERIODIC("Current client is waiting for other client to finish throwing", iDebugThrottle)
									BREAK
									
									CASE DARTS_MPWAIT_TURN_CHANGE
										IF PlayerData[iOtherID].eMPThrowStage >= DARTS_MPTHROW_TURN_CHANGE
											CDEBUG1LN(DEBUG_DARTS, "[AM_DARTS] current client is WAITING - TURN CHANGE")
											
											DARTS_SET_CLIENT_FLAG(PlayerData[iSelfID], DARTS_CLIENTFLAG_SCORING_DONE)
											
											IF NOT MPDartGame.Darts[serverData.iServerTurn].bDoneScoring
												MPDartGame.Darts[serverData.iServerTurn].bDoneScoring = TRUE
											ENDIF
											SETTIMERA(0)
										ENDIF
										DEBUG_MESSAGE_PERIODIC("Waiting for other client to get to DARTS_MPTHROW_TURN_CHANGE", iDebugThrottle)
									BREAK
								ENDSWITCH
							BREAK
							
							CASE DARTS_MPTURN_SCORE_CHECK
								
								IF NOT DARTS_GET_UI_FLAG(DartsUI.iFlags, DARTS_UIFLAGS_UPDATE_PRINTED)
									IF iSelfID = serverData.iThrower
										// print something?
									ELSE
										// print something else?
									ENDIF
									DARTS_SET_UI_FLAG(DartsUI.iFlags, DARTS_UIFLAGS_UPDATE_PRINTED, TRUE)
								ENDIF
								
								IF NOT playerData[iSelfID].bResetDone 
								AND ( TIMERA() > 1000 )
									CDEBUG1LN(DEBUG_DARTS, "[AM_DARTS] current client is in SCORE CHECK")
									playerData[iSelfID].eMPWaitStage = DARTS_MPWAIT_AIM
									playerData[iSelfID].eMPThrowStage = DARTS_MPTHROW_AIM
									MPDartGame.Darts[ServerData.iServerTurn].bDoneScoring = FALSE
									DARTS_CLEAR_CLIENT_FLAG(PlayerData[iSelfID], DARTS_CLIENTFLAG_SCORING_DONE)
									
									CLEAR_HELP()
									
									IF DARTS_GET_UI_FLAG(serverData.iUIFlags, DARTS_UIFLAGS_SWITCH_PLAYER)
										
										// sending the darts back to the player, resetting them
										// serves the same functioon as RESET_DART without deleting the object
										INT y
										REPEAT NUM_MP_DART_TURNS y
											//RESET_DART(MPDartGame.Darts[y])
											MPDartGame.Darts[y].bDoneScoring = FALSE
											CDEBUG1LN(DEBUG_DARTS, "[AM_DARTS]MPDartGame.Darts ", y, " was reset")
										ENDREPEAT
										
										IF iSelfID != serverData.iThrower
											bWaitUIShow = FALSE
										ENDIF
										
										UPDATE_HIGHLIGHT(DartsSB, playerData[serverData.iWaiter].iOffsetPlayerID)
										
										iSteadyShotsUsed = 0
									ENDIF
									
									playerData[iSelfID].bResetDone = TRUE
								ENDIF
							BREAK
							
							CASE DARTS_MPTURN_WINNING
								
								IF NOT IS_TIMER_STARTED(controlTimer)
									
									CDEBUG1LN(DEBUG_DARTS, "********** serverData.iWinner = ", serverData.iWinner)
									CLEAR_PRINTS()
									CLEAR_HELP()
									
									IF (serverData.iWinner = PlayerData[iSelfID].iOffsetPlayerID)
										
										sShardPlayerName = "<C>"
										sShardPlayerName += "~HUD_COLOUR_BLUE~"
										sShardPlayerName += sDartsPlayerNames[PlayerData[iSelfID].iOffsetPlayerID]
										sShardPlayerName += "</C>"
										sShardPlayerName += "~s~"
										
										SET_SHARD_BIG_MESSAGE_WITH_PLAYER_NAME_IN_STRAPLINE(shardBigMessage, "DARTS_THRW_WIN", "DARTS_FIRST", sShardPlayerName, 3000, SHARD_MESSAGE_CENTERED, HUD_COLOUR_WHITE)
										
										//SET_SCALEFORM_BIG_MESSAGE_WITH_PLAYER_NAME_IN_STRAPLINE(DartsUI.siBigMessage, "DARTS_THRW_WIN", "DARTS_FIRST", sDartsPlayerNames[PlayerData[iSelfID].iOffsetPlayerID], 5000, 
										//														default, default, TRUE, MG_BIG_MESSAGE_ANIM_TIME_SLOW)
										PLAY_SOUND_FRONTEND(-1, "WIN", "HUD_AWARDS")
									ELSE
										
										sShardPlayerName = "<C>"
										sShardPlayerName += "~HUD_COLOUR_RED~"
										sShardPlayerName += sDartsPlayerNames[PlayerData[iOtherID].iOffsetPlayerID]
										sShardPlayerName += "</C>"
										sShardPlayerName += "~s~"
										
										SET_SHARD_BIG_MESSAGE_WITH_PLAYER_NAME_IN_STRAPLINE(shardBigMessage, "DARTS_THRW_LOS", "DARTS_FIRST", sShardPlayerName, 3000, SHARD_MESSAGE_CENTERED, HUD_COLOUR_RED)
										
										//SET_SCALEFORM_BIG_MESSAGE_WITH_PLAYER_NAME_IN_STRAPLINE(DartsUI.siBigMessage, "DARTS_THRW_LOS", "DARTS_FIRST", sDartsPlayerNames[PlayerData[iOtherID].iOffsetPlayerID], 5000, 
										//														HUD_COLOUR_RED, default, TRUE, MG_BIG_MESSAGE_ANIM_TIME_SLOW)
										PLAY_SOUND_FRONTEND(-1, "LOSER", "HUD_AWARDS")
									ENDIF
									//SETUP_NEW_BIG_MESSAGE(BIG_MESSAGE_CUSTOM, "DARTS_THRW_OFF", "DARTS_THRW_STR")
									SET_CAM_ACTIVE(camDartGame, TRUE)
									START_TIMER_NOW(controlTimer)
									
								ELIF GET_TIMER_IN_SECONDS_SAFE(controlTimer) >= 5.0
								//OR NOT UPDATE_SCALEFORM_BIG_MESSAGE(DartsUI.siBigMessage, TRUE)
								OR NOT UPDATE_SHARD_BIG_MESSAGE(shardBigMessage, TRUE)
									
									INT y
									REPEAT NUM_MP_DART_TURNS y
										RESET_DART(MPDartGame.Darts[y])
										MPDartGame.Darts[y].bDoneScoring = FALSE
										CDEBUG1LN(DEBUG_DARTS, "[AM_DARTS]MPDartGame.Darts ", y, " was reset")
									ENDREPEAT
									
									CANCEL_TIMER(controlTimer)
									
									RESET_SHARD_BIG_MESSAGE(shardBigMessage)
									
									DARTS_SET_CLIENT_FLAG(PlayerData[iSelfID], DARTS_CLIENTFLAG_AT_THROWOFF)
									PlayerData[iSelfID].eMPState = DARTS_MPSTATE_SYNC_OBJECTS
								ENDIF
								
	//							IF NOT MPGlobals.DartsData.bResultsDisplayed
	//								MPGlobals.DartsData.bResultsDisplayed = TRUE
	//							ENDIF
	//							
	//							MPDartGame.bDartWinner = (serverData.iWinner = iSelfID)
								
							BREAK
						ENDSWITCH
					ENDIF
				BREAK
				
				CASE DARTS_MPSTATE_SYNC_OBJECTS
					CDEBUG1LN(DEBUG_DARTS, "Client DARTS_MPSTATE_SYNC_OBJECTS")
					i = 0
					j = 0
					REPEAT NUM_MP_DART_PLAYERS i
						MPDartGame.iThrowsTaken[i] 	= 0
						MPDartGame.iBullsEyesHit[i]	= 0
						DARTS_CLEAR_SCORES(DartsSB, i)
					ENDREPEAT
					
					DARTS_ADD_SCORE(DartsSB, ENUM_TO_INT(DART_PLAYER_HOME), 301)
					IF NOT DARTS_CHECK_CLIENT_FLAG(PlayerData[iSelfID], DARTS_CLIENTFLAG_SINGLE_PLAYER)
						DARTS_ADD_SCORE(DartsSB, ENUM_TO_INT(DART_PLAYER_AWAY), 301)
					ENDIF
					
					REPEAT  NUM_MP_DART_TURNS j
						RESET_DART(MPDartGame.Darts[j])
						MPDartGame.Darts[j].bDoneScoring = FALSE
						CDEBUG1LN(DEBUG_DARTS, "[AM_DARTS]MPDartGame.Darts ", j, " was reset")
					ENDREPEAT
					
					RESET_CLIENT_DART(PlayerData[iSelfID])
					
					DARTS_INIT_TIMERS(localDartsTimer)
					
					playerData[iSelfID].eMPThrowStage = DARTS_MPTHROW_AIM
					playerData[iSelfID].eMPWaitStage = DARTS_MPWAIT_AIM
					playerData[iSelfID].bDartThrown = FALSE
					
					MPDartGame.bEndGameMessageDisplayed = FALSE
					MPDartGame.bWinNoise = FALSE
					
					bInWinRange = FALSE
					
//					CLEAR_AREA(Args.vDartBoard, 0.5, TRUE)
//					REMOVE_DECALS_IN_RANGE(Args.vDartBoard, 0.5)
					
					iSteadyShotsUsed = 0
					
					bSteadyShotHelp = FALSE
					
					DARTS_SET_UI_FLAG(DartsUI.iFlags, DARTS_UIFLAGS_FIRST_THROW, FALSE)
					
					SET_ON_JOB_INTRO(FALSE)
					
					DARTS_SET_CLIENT_FLAG(PlayerData[iSelfID], DARTS_CLIENTFLAG_SYNC_COMPLETE)
					PlayerData[iSelfID].eMPState = DARTS_MPSTATE_SETUP_POST
				BREAK
				
				CASE DARTS_MPSTATE_SETUP_POST
					DEBUG_MESSAGE_PERIODIC("Client DARTS_MPSTATE_SETUP_POST", iDebugThrottle)
					IF ServerData.mpState = DARTS_MPSTATE_IN_PROGRESS
						PlayerData[iSelfID].bDoRematch = FALSE
						
						// TODO: implement the cam interpolation
	//					IF IS_SCREEN_FADED_OUT() OR IS_SCREEN_FADING_OUT()
	//						DO_SCREEN_FADE_IN(500)
	//					ENDIF
						
						DARTS_GAME_CAM()
						FREEZE_ENTITY_POSITION(PLAYER_PED_ID(), TRUE)
						
						SET_GAMEPLAY_CAM_RELATIVE_HEADING(0.0)
						SET_GAMEPLAY_CAM_RELATIVE_PITCH(0.0)
						
						IF SHOULD_DARTS_LEVEL_HELP_SHOW(GET_MP_INT_CHARACTER_STAT(MP_STAT_CRDARTS), iLevelBit)
							CDEBUG1LN(DEBUG_DARTS, "show the level up prompt")
							DARTS_SET_UI_FLAG(DartsUI.iFlags, DARTS_UIFLAGS_SHOW_LEVEL_UP, TRUE)
						ELSE
							CDEBUG1LN(DEBUG_DARTS, "no level up prompt to show")
						ENDIF
						
						fScaledWobble = GET_MP_WOBBLE_LEVEL(GET_MP_INT_CHARACTER_STAT(MP_STAT_CRDARTS)) //0.076
						fScaledRealWobble = GET_MP_REAL_WOBBLE_LEVEL(GET_MP_INT_CHARACTER_STAT(MP_STAT_CRDARTS)) //0.1015
						
						CDEBUG1LN(DEBUG_DARTS, "total darts games  = ", GET_MP_INT_CHARACTER_STAT(MP_STAT_CRDARTS))
						CDEBUG1LN(DEBUG_DARTS, "scaled wobble      = ", fScaledWobble)
						CDEBUG1LN(DEBUG_DARTS, "scaled real wobble = ", fScaledRealWobble)
						
						fWobbleFactor = fScaledWobble
						fRealWobFactor = fScaledRealWobble
						
						DARTS_CLEAR_CLIENT_FLAG(PlayerData[iSelfID], DARTS_CLIENTFLAG_SYNC_COMPLETE)
						PlayerData[iSelfID].eMPState = DARTS_MPSTATE_IN_PROGRESS
						CDEBUG1LN(DEBUG_DARTS, "[AM_DARTS] Client is proceeding to IN PROGRESS")
						
						IF NOT DARTS_CHECK_CLIENT_FLAG(PlayerData[iSelfID], DARTS_CLIENTFLAG_SINGLE_PLAYER)
							DartsStats[DARTS_SCLB_STAT_NUM_MATCHES]++
						ENDIF
						
						DARTS_INIT_UI(DartsUI)
						
						IF NOT DARTS_CHECK_CLIENT_FLAG(PlayerData[iSelfID], DARTS_CLIENTFLAG_SINGLE_PLAYER)
							UPDATE_HIGHLIGHT(DartsSB, PICK_INT((serverData.iCoinFlip = 0), ENUM_TO_INT(DART_PLAYER_AWAY), ENUM_TO_INT(DART_PLAYER_HOME)))
						ELSE
							UPDATE_HIGHLIGHT(DartsSB, ENUM_TO_INT(DART_PLAYER_HOME))
						ENDIF
						bWaitUIShow = FALSE
					ENDIF
				BREAK
				
				CASE DARTS_MPSTATE_WAIT_POST_MENU
					CDEBUG1LN(DEBUG_DARTS, "[AM_DARTS] has reached Client side WAIT POST MENU")
					// Sitting in a waiting state
					
					IF DARTS_SERVER_CHECK_FLAG(serverData, DARTSERVERFLAG_MOVETOGAME)
						PlayerData[iSelfID].eMPState = DARTS_MPSTATE_IN_PROGRESS
					ENDIF
				BREAK
				
				// #REALGAME HERE VVVVVVV				
				
				CASE DARTS_MPSTATE_IN_PROGRESS
					
					// failsafe for screen not fading back in
					IF IS_SCREEN_FADED_OUT()
						DO_SCREEN_FADE_IN(500)
					ENDIF
					
	//				IF NOT DARTS_GET_UI_FLAG(DartsUI.iFlags, DARTS_UIFLAGS_FIRST_THROW)
	//					PRINT_WITH_NAME("DARTS_FIRST", sDartsPlayerNames[PICK_INT((serverData.mpTurnStatus[iSelfID]=DARTS_MPTURN_THROWING), iSelfID, iOtherID)], DEFAULT_GOD_TEXT_TIME, 0)
	//					DARTS_SET_UI_FLAG(DartsUI.iFlags, DARTS_UIFLAGS_FIRST_THROW, TRUE)
	//				ENDIF
					
	//				HANDLE_SWITCH_CAM()
					
					// making sure the dart players stay in position
					SWITCH DartPlayerPosition
						CASE DART_PLAYER_IN_POSITION
							IF NOT IS_PED_INJURED(PLAYER_PED_ID())
							AND GET_PLAYER_DISTANCE_FROM_LOCATION(DartsPlayerPos.vDartPlayrPos) > 1.5
								
//							#IF IS_DEBUG_BUILD
//								CDEBUG1LN(DEBUG_DARTS, "GET_PLAYER_DISTANCE_FROM_LOCATION(DartsPlayerPos.vDartPlayrPos) = ", GET_PLAYER_DISTANCE_FROM_LOCATION(DartsPlayerPos.vDartPlayrPos))
//							#ENDIF
//								
//								CLEAR_SEQUENCE_TASK(siTemp)
//								OPEN_SEQUENCE_TASK(siTemp)
//									TASK_FOLLOW_NAV_MESH_TO_COORD(NULL, DartsPlayerPos.vDartPlayrPos, PEDMOVEBLENDRATIO_WALK, 5000, 0.3)
//									TASK_ACHIEVE_HEADING(NULL, MPDartGame.dBoard.fBoardHeading)
//								CLOSE_SEQUENCE_TASK(siTemp)
//								TASK_PERFORM_SEQUENCE(PLAYER_PED_ID(), siTemp)
//								
//								CDEBUG1LN(DEBUG_DARTS, "Dart player out of position, tasked to move back")
//								
//								DartPlayerPosition = DART_PLAYER_OUT_POSITION
							ENDIF
						BREAK
						
						CASE DART_PLAYER_OUT_POSITION
							IF NOT IS_PED_INJURED(PLAYER_PED_ID())
							AND GET_SCRIPT_TASK_STATUS(PLAYER_PED_ID(), SCRIPT_TASK_PERFORM_SEQUENCE) = FINISHED_TASK
								
//								CDEBUG1LN(DEBUG_DARTS, "Dart player is now back in position")
								
								DartPlayerPosition = DART_PLAYER_IN_POSITION
							ENDIF
						BREAK
					ENDSWITCH
					
	//				IF DARTS_PLAYER_QUIT_CONTROL(PlayerData[iSelfID], DartsUI, iDebugThrottle)
	//					PlayerData[iSelfID].eMPState = DARTS_MPSTATE_END
	//				ENDIF
					
					// Drawing the hud and the control scheme
					IF NOT DARTS_CHECK_CLIENT_FLAG(playerData[iSelfID], DARTS_CLIENTFLAG_QUIT_ATTEMPTED)
						
						// help text drawing
						IF NOT (serverData.mpTurnStatus[iSelfID] = DARTS_MPTURN_WINNING)
						AND ( NOT playerData[iSelfID].bDartThrown = TRUE
							OR NOT playerData[iOtherID].bDartThrown = TRUE )
						AND NOT DARTS_GET_UI_FLAG(serverData.iUIFlags, DARTS_UIFLAGS_SWITCH_PLAYER)
									
							IF NOT bUITextDisplayed
								
								IF DARTS_GET_UI_FLAG(DartsUI.iFlags, DARTS_UIFLAGS_END_HELP_READY)
								AND serverData.mpTurnStatus[iSelfID] = DARTS_MPTURN_THROWING
									IF NOT DARTS_GET_UI_FLAG(DartsUI.iFlags, DARTS_UIFLAGS_WIN_HELP)
										IF NOT IS_BIT_SET(g_iDartsTutorialFlags, gWIN_HELP_SHOWN)
											PRINT_HELP("DARTS_INSTR_W")
											SET_BIT(g_iDartsTutorialFlags, gWIN_HELP_SHOWN)
										ENDIF
										DARTS_SET_UI_FLAG(DartsUI.iFlags, DARTS_UIFLAGS_WIN_HELP, TRUE)
									ELIF NOT DARTS_GET_UI_FLAG(DartsUI.iFlags, DARTS_UIFLAGS_BUST_HELP)
									AND DARTS_GET_UI_FLAG(DartsUI.iFlags, DARTS_UIFLAGS_BUST_HELP_READY)
										IF NOT IS_BIT_SET(g_iDartsTutorialFlags, gBUST_HELP_SHOWN)
											PRINT_HELP("DARTS_INSTR_B")
											SET_BIT(g_iDartsTutorialFlags, gBUST_HELP_SHOWN)
										ENDIF
										DARTS_SET_UI_FLAG(DartsUI.iFlags, DARTS_UIFLAGS_BUST_HELP, TRUE)
									ENDIF
								ENDIF
								
								IF bInWinRange
								AND NOT IS_THIS_HELP_MESSAGE_BEING_DISPLAYED("DARTS_SHT_USE")
								AND NOT IS_THIS_HELP_MESSAGE_BEING_DISPLAYED("DARTS_FST_HLP")
								AND serverData.mpTurnStatus[iSelfID] = DARTS_MPTURN_THROWING
									
	//								IF (serverData.iScores[iSelfID] % 2) = 0
	//								AND (serverData.iScores[iSelfID] = 50 OR serverData.iScores[iSelfID] < 41)
	//								
	//									IF serverData.iScores[iSelfID] = 50
	//									ELSE
	//										CLEAR_HELP()
	//									ENDIF
	//								ENDIF
								
								ELIF NOT (serverData.mpTurnStatus[iSelfID] = DARTS_MPTURN_SCORE_CHECK)
									//DEBUG_MESSAGE_PERIODIC("DARTS UI IS SHOWING REGULAR HELP", iDebugThrottle)
									IF bShowShotClockThrowHelp //ServerData.DartsTimer.bTimeRunOut
									AND NOT DARTS_GET_UI_FLAG(DartsUI.iFlags, DARTS_UIFLAGS_SHOT_CLOCK_HELP)
									AND NOT IS_THIS_HELP_MESSAGE_BEING_DISPLAYED("DARTS_INSTR_W")
									AND NOT IS_THIS_HELP_MESSAGE_BEING_DISPLAYED("DARTS_INSTR_B")
									AND (IS_TIMER_STARTED(ServerData.DartsTimer.stShotClock) AND GET_TIMER_IN_SECONDS_SAFE(ServerData.DartsTimer.stShotClock) < 5)
										IF NOT IS_BIT_SET(g_iDartsTutorialFlags, gSHOT_CLOCK_HELP_SHOWN)
											PRINT_HELP("DARTS_TIOT")
											SET_BIT(g_iDartsTutorialFlags, gSHOT_CLOCK_HELP_SHOWN)
											CDEBUG1LN(DEBUG_DARTS, "shot clock help bit set here")
										ELSE
											CDEBUG1LN(DEBUG_DARTS, "shot clock help bit already set")
										ENDIF
										CDEBUG1LN(DEBUG_DARTS, "shot clock ui flag set")
										DARTS_SET_UI_FLAG(DartsUI.iFlags, DARTS_UIFLAGS_SHOT_CLOCK_HELP, TRUE)
									ENDIF
								ENDIF
								DartsUI.bInstructTextTransIn = TRUE
							ELSE
								IF DartsUI.bInstructTextTransIn
									CLEAR_HELP()
									DartsUI.bInstructTextTransIn = FALSE
								ENDIF
							ENDIF
						ENDIF
						
						// Drawing the Darts Left UI element and the instructional buttons
						IF ((playerData[iSelfID].eMPThrowStage = DARTS_MPTHROW_AIM) 
							AND (serverData.mpTurnStatus[iSelfID] = DARTS_MPTURN_THROWING))
						OR bWaitUIShow
							IF NOT IS_PLAYER_SWITCH_IN_PROGRESS()
							AND NOT IS_TRANSITION_ACTIVE()
								DARTS_MP_CONTROLS_UI(DartsUI, (serverData.mpTurnStatus[iSelfID] = DARTS_MPTURN_THROWING))
							ENDIF
						ENDIF
						
						IF NOT IS_PAUSE_MENU_ACTIVE()
							DARTS_DISPLAY_SPECIAL_SPLASH_MP_SHARD(DartsUI)
							IF bPlaySplashFX
								PLAY_SOUND_FRONTEND ( -1, "GOLF_NEW_RECORD", "HUD_AWARDS")
								bPlaySplashFX = FALSE
							ENDIF
						ENDIF
					ENDIF
					
					// Do everyting playing related right chea
					SWITCH serverData.mpTurnStatus[iSelfID] 
						CASE DARTS_MPTURN_THROWING
							SWITCH playerData[iSelfID].eMPThrowStage
								CASE DARTS_MPTHROW_AIM
									playerData[iSelfID].bDartAim = TRUE
	//								playerData[iSelfID].vReticlePos.x = spriteReticle.x
	//								playerData[iSelfID].vReticlePos.y = spriteReticle.y
									
									IF NOT DARTS_CHECK_CLIENT_FLAG(playerData[iSelfID], DARTS_CLIENTFLAG_QUIT_ATTEMPTED)
										//DARTS_DRAW_PLAYERS_RETICLE(playerData[iSelfID].vReticlePos, iSelfID)
										DARTS_DRAW_SHOT_CLOCK(ServerData.DartsTimer, TRUE)
										//DRAW_DARTS_RETICLE_GUIDE(iSelfID, iSelfID)
									ENDIF
									
									DARTS_GAME_HELP(ServerData.iServerTurn, TRUE)
									
									IF DARTS_GET_UI_FLAG(DartsUI.iFlags, DARTS_UIFLAGS_SHOW_LEVEL_UP)
										IF NOT IS_THIS_HELP_MESSAGE_BEING_DISPLAYED("DARTS_SHT_USE")
										AND NOT IS_THIS_HELP_MESSAGE_BEING_DISPLAYED("DARTS_CLOCK")
										AND NOT IS_THIS_HELP_MESSAGE_BEING_DISPLAYED("DARTS_INSTR_W")
										AND NOT IS_THIS_HELP_MESSAGE_BEING_DISPLAYED("DARTS_INSTR_B")
										AND NOT IS_THIS_HELP_MESSAGE_BEING_DISPLAYED("DARTS_AIM_HLP")
										AND NOT IS_THIS_HELP_MESSAGE_BEING_DISPLAYED("DARTS_STD_HLP")
										AND NOT IS_THIS_HELP_MESSAGE_BEING_DISPLAYED("DARTS_FST_HLP")
											PRINT_HELP("DARTS_LEVEL")
											SET_BIT(g_savedGlobals.sDartsData.iDartTimePlayed, iLevelBit)
											DARTS_SET_UI_FLAG(DartsUI.iFlags, DARTS_UIFLAGS_SHOW_LEVEL_UP, FALSE)
										ENDIF
									ENDIF
									
									IF ServerData.DartsTimer.bNewShot
										CDEBUG1LN(DEBUG_DARTS, "Server timer has sensed a new shot!")
									ENDIF
									
									IF ServerData.DartsTimer.bTimeRunOut
										CDEBUG1LN(DEBUG_DARTS, "Server timer has sensed that it has run out!")
									ENDIF
									
									IF (NOT DARTS_CHECK_CLIENT_FLAG(playerData[iSelfID], DARTS_CLIENTFLAG_QUIT_ATTEMPTED)
										AND NOT IS_PAUSE_MENU_ACTIVE()
										AND NOT IS_PLAYER_SWITCH_IN_PROGRESS()
										AND NOT IS_TRANSITION_ACTIVE())
									OR ServerData.DartsTimer.bTimeRunOut
										IF DO_AIMING(MPDartGame.Darts[ServerData.iServerTurn], MPDartGame.dBoard,
													DartsInitReticlePos, FALSE, ServerData.DartsTimer.bTimeRunOut)
											CDEBUG1LN(DEBUG_DARTS, "[AM_DARTS->DARTS_MPTHROW_AIM] current client finished AIMING")
											
											IF ServerData.DartsTimer.bTimeRunOut
											AND NOT bShowShotClockThrowHelp
												bShowShotClockThrowHelp = TRUE
											ENDIF
											
											DartsUI.iDartsLeft--
											
											DARTS_SET_UI_FLAG(DartsUI.iFlags, DARTS_UIFLAGS_UPDATE_PRINTED, FALSE)
											
											// copy dart's throw info to the client so that other player can grab it
											CDEBUG1LN(DEBUG_DARTS, "[AM_DARTS->DARTS_MPTHROW_AIM] Copy the throwers data for dart ", ServerData.iServerTurn)
											COPY_DART_TO_CLIENT(playerData[iSelfID], MPDartGame.Darts[ServerData.iServerTurn])
											
											IF DARTS_CHECK_CLIENT_FLAG(PlayerData[iSelfID], DARTS_CLIENTFLAG_RETHROW_NEEDED)
												DARTS_CLEAR_CLIENT_FLAG(PlayerData[iSelfID], DARTS_CLIENTFLAG_RETHROW_NEEDED)
											ENDIF
											
											IF MPGlobals.DartsData.iDangerPedCount <= 0
											OR NOT IS_BIT_SET(MPGlobals.DartsData.iDisplayState, 2)
												DARTS_CLEAR_CLIENT_FLAG(PlayerData[iSelfID], DARTS_CLIENTFLAG_DANGER_DART)
												CDEBUG1LN(DEBUG_DARTS, "[AM_DARTS->DARTS_MPTHROW_AIM] no peds in danger zone, clearing danger flag")
											ELSE
												DARTS_SET_CLIENT_FLAG(PlayerData[iSelfID], DARTS_CLIENTFLAG_DANGER_DART)
												CDEBUG1LN(DEBUG_DARTS, "[AM_DARTS->DARTS_MPTHROW_AIM] setting danger flag, peds in danger zone: ", MPGlobals.DartsData.iDangerPedCount)
											ENDIF
											
											IF NOT DARTS_CHECK_CLIENT_FLAG(PlayerData[iSelfID], DARTS_CLIENTFLAG_SINGLE_PLAYER)
												DartsStats[DARTS_SCLB_STAT_DARTS_THROWN]++
											ENDIF
											
											playerData[iSelfID].bDartThrown = TRUE
											playerData[iSelfID].bDartAim = FALSE
											playerData[iSelfID].eMPThrowStage = DARTS_MPTHROW_THROW
										ENDIF
									ENDIF
								BREAK
								
								CASE DARTS_MPTHROW_THROW
									DEBUG_MESSAGE_PERIODIC("[AM_DARTS] current client is THROWING", iDebugThrottle)
									IF NOT DARTS_CHECK_CLIENT_FLAG(PlayerData[iSelfID], DARTS_CLIENTFLAG_DANGER_DART)
										IF THROW_DART(MPDartGame.Darts[ServerData.iServerTurn], MPDartGame.dBoard)
											CDEBUG1LN(DEBUG_DARTS, "Regular Throw completed")
											MPDartGame.iThrowsTaken[PlayerData[iSelfID].iOffsetPlayerID]++
											playerData[iSelfID].bResetDone = FALSE
											playerData[iSelfID].eMPThrowStage = DARTS_MPTHROW_SCORE
										ENDIF
									ELSE
										IF NOT IS_TIMER_STARTED(ReThrowTimer)
											IF THROW_DART_AT_ENTITY(MPDartGame.Darts[ServerData.iServerTurn], MPDartGame.dBoard, << 988.1219, -99.3023, 73.8456 >>)
												BROADCAST_DANGER_ZONE_UPDATE(PLAYER_ID(), DARTS_DANGERZONE_DART_THROW)
												CDEBUG1LN(DEBUG_DARTS, "Danger dart throw completed")
												
												playerData[iSelfID].bDartThrown = FALSE
												playerData[iSelfID].bDartAim = TRUE
												playerData[iSelfID].bResetDone = FALSE
												
												RESTART_TIMER_NOW(ReThrowTimer)
											ENDIF
										
										ELIF GET_TIMER_IN_SECONDS(ReThrowTimer) > 1.0
										OR DARTS_CHECK_CLIENT_FLAG(PlayerData[iOtherID], DARTS_CLIENTFLAG_RETHROW_NEEDED)
											
											IF NOT DARTS_CHECK_CLIENT_FLAG(PlayerData[iSelfID], DARTS_CLIENTFLAG_RETHROW_NEEDED)
												DARTS_SET_CLIENT_FLAG(PlayerData[iSelfID], DARTS_CLIENTFLAG_RETHROW_NEEDED)
											ENDIF
											
											CDEBUG1LN(DEBUG_DARTS, "Danger dart throw completed, going back to DARTS_MPTHROW_AIM - THROW SIDE")
											CANCEL_TIMER(ReThrowTimer)
											playerData[iSelfID].eMPThrowStage = DARTS_MPTHROW_AIM
										ENDIF
									ENDIF
								BREAK
								
								CASE DARTS_MPTHROW_SCORE
//									IF PlayerData[iOtherID].eMPWaitStage >= DARTS_MPWAIT_SCORE
//									OR DARTS_CHECK_CLIENT_FLAG(PlayerData[iSelfID], DARTS_CLIENTFLAG_SINGLE_PLAYER)
										CDEBUG1LN(DEBUG_DARTS, "[AM_DARTS] current client is SCORING")
										
										//playerData[iSelfID].bDartThrown = FALSE
										
										SCORE_DART(MPDartGame.Darts[ServerData.iServerTurn], MPDartGame.dBoard)
										playerData[iSelfID].ClientDart.iHitValue = MPDartGame.Darts[ServerData.iServerTurn].iHitValue
										
										IF playerData[iSelfID].ClientDart.iHitValue = 50
											MPDartGame.iBullsEyesHit[PlayerData[iSelfID].iOffsetPlayerID]++
										ENDIF
										
										IF playerData[iSelfID].ClientDart.iHitMultiplier = 2 OR playerData[iSelfID].ClientDart.iHitValue = 50
											playerData[iSelfID].bDoubleThrow = TRUE
										ELSE
											playerData[iSelfID].bDoubleThrow = FALSE
										ENDIF
										
										CDEBUG1LN(DEBUG_DARTS, "[AM_DARTS] THROW - Client Dart ", ServerData.iServerTurn, " hit value = ", playerData[iSelfID].ClientDart.iHitValue)
										CDEBUG1LN(DEBUG_DARTS, "[AM_DARTS] THROW - Local Dart ", ServerData.iServerTurn, " hit value = ", MPDartGame.Darts[ServerData.iServerTurn].iHitValue)
										playerData[iSelfID].eMPThrowStage = DARTS_MPTHROW_TURN_CHANGE
//									ENDIF
									DEBUG_MESSAGE_PERIODIC("Current client is waiting for other client to finish throwing", iDebugThrottle)
								BREAK
								
								CASE DARTS_MPTHROW_TURN_CHANGE	
									IF PlayerData[iOtherID].eMPWaitStage >= DARTS_MPWAIT_TURN_CHANGE
									OR DARTS_CHECK_CLIENT_FLAG(PlayerData[iSelfID], DARTS_CLIENTFLAG_SINGLE_PLAYER)
										
										playerData[iSelfID].bDartThrown = FALSE
										
										DARTS_SET_CLIENT_FLAG(PlayerData[iSelfID], DARTS_CLIENTFLAG_SCORING_DONE)
										
										CDEBUG1LN(DEBUG_DARTS, "[AM_DARTS] current client is THROWING - TURN CHANGE")
										CDEBUG1LN(DEBUG_DARTS, "[AM_DARTS] ServerData.iServerTurn = ", ServerData.iServerTurn)
										CDEBUG1LN(DEBUG_DARTS, "[AM_DARTS] iServerTurn].bDoneScoring = ", MPDartGame.Darts[ServerData.iServerTurn].bDoneScoring)
										
										
										IF NOT MPDartGame.Darts[ServerData.iServerTurn].bDoneScoring
											MPDartGame.Darts[ServerData.iServerTurn].bDoneScoring = TRUE
										ENDIF
										SETTIMERA(0)
									ENDIF
									DEBUG_MESSAGE_PERIODIC("Waiting for other client to get to DARTS_MPWAIT_TURN_CHANGE", iDebugThrottle)
								BREAK
							ENDSWITCH
						BREAK
						
						CASE DARTS_MPTURN_WAITING
							SWITCH playerData[iSelfID].eMPWaitStage
								CASE DARTS_MPWAIT_AIM
									
									// uncomment if you want to draw the reticle on both machines 
									/*
									IF playerData[iOtherID].bDartAim
										DARTS_DRAW_PLAYERS_RETICLE(playerData[iOtherID].vReticlePos, iOtherID, TRUE)
										DRAW_DARTS_RETICLE_GUIDE(iSelfID, iOtherID)
									ENDIF
									*/
									
									IF NOT bWaitUIShow
										bWaitUIShow = TRUE
									ENDIF
									
									IF NOT DARTS_CHECK_CLIENT_FLAG(playerData[iSelfID], DARTS_CLIENTFLAG_QUIT_ATTEMPTED)
										DARTS_DRAW_SHOT_CLOCK(ServerData.DartsTimer, FALSE)
									ENDIF
									
									IF playerData[iOtherID].bDartThrown
										CDEBUG1LN(DEBUG_DARTS, "Current client finished WAIT - AIMING")
										
										DartsUI.iDartsLeft--
										
										DARTS_SET_UI_FLAG(DartsUI.iFlags, DARTS_UIFLAGS_UPDATE_PRINTED, FALSE)
										
										// grab other players dart throw info so we can throw that thang
										COPY_DART_TO_LOCAL(MPDartGame.Darts[ServerData.iServerTurn], playerData[iOtherID], iOtherID)
										
										IF DARTS_CHECK_CLIENT_FLAG(PlayerData[iSelfID], DARTS_CLIENTFLAG_RETHROW_NEEDED)
											DARTS_CLEAR_CLIENT_FLAG(PlayerData[iSelfID], DARTS_CLIENTFLAG_RETHROW_NEEDED)
										ENDIF
										
										playerData[iSelfID].eMPWaitStage = DARTS_MPWAIT_THROW
									ELSE
										DEBUG_MESSAGE_PERIODIC("Current client is waiting for other client to throw", iDebugThrottle)
									ENDIF
								BREAK
								
								CASE DARTS_MPWAIT_THROW		
									CDEBUG1LN(DEBUG_DARTS, "[AM_DARTS] current client is WAITING - Throwing")
									IF NOT DARTS_CHECK_CLIENT_FLAG(PlayerData[iOtherID], DARTS_CLIENTFLAG_DANGER_DART)
										IF THROW_DART(MPDartGame.Darts[ServerData.iServerTurn], MPDartGame.dBoard)
											CDEBUG1LN(DEBUG_DARTS, "Regular Throw Completed - Wait side")
											MPDartGame.iThrowsTaken[PlayerData[iOtherID].iOffsetPlayerID]++
											playerData[iSelfID].bResetDone = FALSE
											playerData[iSelfID].eMPWaitStage = DARTS_MPWAIT_SCORE
										ENDIF
									ELSE
										IF NOT IS_TIMER_STARTED(ReThrowTimer)
											IF THROW_DART_AT_ENTITY(MPDartGame.Darts[ServerData.iServerTurn], MPDartGame.dBoard, << 988.1219, -99.3023, 73.8456 >>)
												CDEBUG1LN(DEBUG_DARTS, "Danger Dart Completed - WAIT SIDE")
												RESTART_TIMER_NOW(ReThrowTimer)
											ENDIF
										
										ELIF GET_TIMER_IN_SECONDS(ReThrowTimer) > 1.0
										OR DARTS_CHECK_CLIENT_FLAG(PlayerData[iOtherID], DARTS_CLIENTFLAG_RETHROW_NEEDED)
											
											IF NOT DARTS_CHECK_CLIENT_FLAG(PlayerData[iSelfID], DARTS_CLIENTFLAG_RETHROW_NEEDED)
												DARTS_SET_CLIENT_FLAG(PlayerData[iSelfID], DARTS_CLIENTFLAG_RETHROW_NEEDED)
											ENDIF
											
											CDEBUG1LN(DEBUG_DARTS, "Danger dart throw completed, going back to DARTS_MPTHROW_AIM - WAIT SIDE")
											CANCEL_TIMER(RethrowTimer)
											playerData[iSelfID].eMPWaitStage = DARTS_MPWAIT_AIM
										ENDIF
									ENDIF
								BREAK
								
								CASE DARTS_MPWAIT_SCORE
									IF PlayerData[iOtherID].eMPThrowStage >= DARTS_MPTHROW_SCORE
										CDEBUG1LN(DEBUG_DARTS, "[AM_DARTS] current client is WAITING - SCORING")
										SCORE_DART(MPDartGame.Darts[ServerData.iServerTurn], MPDartGame.dBoard)
										playerData[iSelfID].ClientDart.iHitValue = MPDartGame.Darts[ServerData.iServerTurn].iHitValue
										
										IF playerData[iSelfID].ClientDart.iHitValue = 50
											MPDartGame.iBullsEyesHit[PlayerData[iOtherID].iOffsetPlayerID]++
										ENDIF
										
										IF playerData[iSelfID].ClientDart.iHitMultiplier = 2 OR playerData[iSelfID].ClientDart.iHitValue = 50
											playerData[iSelfID].bDoubleThrow = TRUE
										ELSE
											playerData[iSelfID].bDoubleThrow = FALSE
										ENDIF
										
										CDEBUG1LN(DEBUG_DARTS, "[AM_DARTS] WAIT - Client Dart ", ServerData.iServerTurn, " hit value = ", playerData[iSelfID].ClientDart.iHitValue)
										CDEBUG1LN(DEBUG_DARTS, "[AM_DARTS] WAIT - Local Dart ", ServerData.iServerTurn, " hit value = ", MPDartGame.Darts[ServerData.iServerTurn].iHitValue)
										playerData[iSelfID].eMPWaitStage = DARTS_MPWAIT_TURN_CHANGE
									ENDIF
									DEBUG_MESSAGE_PERIODIC("Current client is waiting for other client to finish throwing", iDebugThrottle)
								BREAK
								
								CASE DARTS_MPWAIT_TURN_CHANGE
									IF PlayerData[iOtherID].eMPThrowStage >= DARTS_MPTHROW_TURN_CHANGE
										CDEBUG1LN(DEBUG_DARTS, "[AM_DARTS] current client is WAITING - TURN CHANGE")
										CDEBUG1LN(DEBUG_DARTS, "[AM_DARTS] ServerData.iServerTurn = ", ServerData.iServerTurn)
										CDEBUG1LN(DEBUG_DARTS, "[AM_DARTS] iServerTurn].bDoneScoring = ", MPDartGame.Darts[ServerData.iServerTurn].bDoneScoring)
										
										DARTS_SET_CLIENT_FLAG(PlayerData[iSelfID], DARTS_CLIENTFLAG_SCORING_DONE)
										
										IF NOT MPDartGame.Darts[ServerData.iServerTurn].bDoneScoring
											MPDartGame.Darts[ServerData.iServerTurn].bDoneScoring = TRUE
										ENDIF
										SETTIMERA(0)
									ENDIF
									DEBUG_MESSAGE_PERIODIC("Waiting for other client to get to DARTS_MPTHROW_TURN_CHANGE", iDebugThrottle)
								BREAK
							ENDSWITCH
						BREAK
						
						CASE DARTS_MPTURN_SCORE_CHECK
							IF ((serverData.iScores[iSelfID] < 41 AND serverData.iScores[iSelfID] > 0) AND (serverData.iScores[iSelfID] % 2 = 0)) 
							OR serverData.iScores[iSelfID] = 50
								IF NOT bInWinRange //DARTS_GET_UI_FLAG(serverData.iUIFlags, DARTS_UIFLAGS_IN_WIN_RANGE)
									CDEBUG1LN(DEBUG_DARTS, "DARTS UIFLAG IS SETTING DARTS_UIFLAGS_IN_WIN_RANGE")
									//DARTS_SET_UI_FLAG(serverData.iUIFlags, DARTS_UIFLAGS_IN_WIN_RANGE, TRUE)
									bInWinRange = TRUE
								ELSE
									DEBUG_MESSAGE_PERIODIC("DARTS UIFLAG IS DARTS_UIFLAGS_IN_WIN_RANGE IS ALREADY SET", iDebugThrottle)
								ENDIF
							ENDIF
							
							IF serverData.iScores[iSelfID] <= 170
							AND NOT DARTS_GET_UI_FLAG(DartsUI.iFlags, DARTS_UIFLAGS_END_HELP_READY)
								DARTS_SET_UI_FLAG(DartsUI.iFlags, DARTS_UIFLAGS_END_HELP_READY, TRUE)
							ENDIF
							
							IF NOT DARTS_GET_UI_FLAG(DartsUI.iFlags, DARTS_UIFLAGS_BUST_HELP_READY)
							AND DARTS_GET_UI_FLAG(DartsUI.iFlags, DARTS_UIFLAGS_WIN_HELP)
								DARTS_SET_UI_FLAG(DartsUI.iFlags, DARTS_UIFLAGS_BUST_HELP_READY, TRUE)
							ENDIF
							
							IF NOT DARTS_GET_UI_FLAG(DartsUI.iFlags, DARTS_UIFLAGS_UPDATE_PRINTED)
								CLEAR_PRINTS()
								CLEAR_HELP()
								IF iSelfID = serverData.iThrower
									IF DARTS_GET_UI_FLAG(serverData.iUIFlags, DARTS_UIFLAGS_TURN_CONTINUE)
										CDEBUG1LN(DEBUG_DARTS, "My server score is ", ServerData.iScores[iSelfID])
										CDEBUG1LN(DEBUG_DARTS, "Other server score is ", ServerData.iScores[iOtherID])
										PRINT_WITH_2_NUMBERS_NOW("DARTS_REMAIN", ServerData.iLastScore[iSelfID] - ServerData.iScores[iSelfID], ServerData.iScores[iSelfID], 20000, 0)
										//PRINT_WITH_NUMBER("DARTS_REMAINL", ServerData.iScores[iSelfID], 20000, 0)
										
										IF playerData[iSelfID].ClientDart.iHitValue = 50
											DARTS_TRIGGER_SPLASH(DartsUI, DARTSSPLASH_BULLSEYE)
											bPlaySplashFX = TRUE
										ENDIF
										
									ELIF DARTS_GET_UI_FLAG(serverData.iUIFlags, DARTS_UIFLAGS_BUST_UNDER_ZERO)
										PRINT_WITH_NUMBER("DARTS_BUST_L", ServerData.iTurnscore, 5000, 0)
									ELIF DARTS_GET_UI_FLAG(serverData.iUIFlags, DARTS_UIFLAGS_BUST_NOT_DOUBLE)
										PRINT_WITH_NUMBER("DARTS_DOUBLE_L", playerData[iSelfID].ClientDart.iHitValue, 5000, 0)
									ELIF DARTS_GET_UI_FLAG(serverData.iUIFlags, DARTS_UIFLAGS_BUST_ONE_POINT_LEFT)
										PRINT_NOW("DARTS_ONE_PT", 5000, 0)
									ELIF DARTS_GET_UI_FLAG(serverData.iUIFlags, DARTS_UIFLAGS_SWITCH_PLAYER)
										IF playerData[iSelfID].ClientDart.iHitValue = 50
											DARTS_TRIGGER_SPLASH(DartsUI, DARTSSPLASH_BULLSEYE)
											bPlaySplashFX = TRUE
										ELIF ServerData.iTurnscore = 180
											DARTS_TRIGGER_SPLASH(DartsUI, DARTSSPLASH_180)
											bPlaySplashFX = TRUE
										ENDIF
										
										IF NOT DARTS_CHECK_CLIENT_FLAG(PlayerData[iSelfID], DARTS_CLIENTFLAG_SINGLE_PLAYER)
											PRINT_WITH_NAME_AND_NUMBER("DARTS_SWITCH_L", sDartsPlayerNames[playerData[iOtherID].iOffsetPlayerID], ServerData.iScores[iSelfID], 5000, 0)
										ELSE
											PRINT_WITH_2_NUMBERS_NOW("DARTS_REMAIN", ServerData.iLastScore[iSelfID] - ServerData.iScores[iSelfID], ServerData.iScores[iSelfID], 5000, 0)
											//PRINT_WITH_NUMBER("DARTS_REMAINL", ServerData.iScores[iSelfID], 5000, 0)
										ENDIF
										
									ENDIF
								ELSE
									IF DARTS_GET_UI_FLAG(serverData.iUIFlags, DARTS_UIFLAGS_TURN_CONTINUE)
										CDEBUG1LN(DEBUG_DARTS, "My server score is ", ServerData.iScores[iSelfID])
										CDEBUG1LN(DEBUG_DARTS, "Other server score is ", ServerData.iScores[iOtherID])
										PRINT_WITH_2_NUMBERS_NOW("DARTS_REMAIN", ServerData.iLastScore[iOtherID] - ServerData.iScores[iOtherID], ServerData.iScores[iOtherID], 20000, 0)
										//PRINT_WITH_NUMBER("DARTS_REMAINL", ServerData.iScores[iOtherID], 20000, 0)
									
									ELIF DARTS_GET_UI_FLAG(serverData.iUIFlags, DARTS_UIFLAGS_BUST_UNDER_ZERO)
										PRINT_WITH_NUMBER("DARTS_BUST_L", ServerData.iTurnscore, 5000, 0)
									ELIF DARTS_GET_UI_FLAG(serverData.iUIFlags, DARTS_UIFLAGS_BUST_NOT_DOUBLE)
										PRINT_WITH_NUMBER("DARTS_DOUBLE_L", playerData[iSelfID].ClientDart.iHitValue, 5000, 0)
									ELIF DARTS_GET_UI_FLAG(serverData.iUIFlags, DARTS_UIFLAGS_BUST_ONE_POINT_LEFT)
										PRINT_NOW("DARTS_ONE_PT", 5000, 0)
									ELIF DARTS_GET_UI_FLAG(serverData.iUIFlags, DARTS_UIFLAGS_SWITCH_PLAYER)
										PRINT_WITH_NAME_AND_NUMBER("DARTS_SWITCH_L", GET_PLAYER_NAME(PLAYER_ID()), ServerData.iScores[iOtherID], 5000, 0)
										
									ENDIF
								ENDIF
								DARTS_SET_UI_FLAG(DartsUI.iFlags, DARTS_UIFLAGS_UPDATE_PRINTED, TRUE)
							ENDIF
							
							IF NOT playerData[iSelfID].bResetDone 
							AND ( (DARTS_GET_UI_FLAG(serverData.iUIFlags, DARTS_UIFLAGS_TURN_CONTINUE) AND TIMERA() > 1000)
								OR TIMERA() > 2000 )
								CDEBUG1LN(DEBUG_DARTS, "[AM_DARTS] current client is in SCORE CHECK")
								playerData[iSelfID].eMPWaitStage = DARTS_MPWAIT_AIM
								playerData[iSelfID].eMPThrowStage = DARTS_MPTHROW_AIM
								MPDartGame.Darts[ServerData.iServerTurn].bDoneScoring = FALSE
								DARTS_CLEAR_CLIENT_FLAG(PlayerData[iSelfID], DARTS_CLIENTFLAG_SCORING_DONE)
								
								IF iSelfID = serverData.iThrower
									IF playerData[iSelfID].ClientDart.iHitValue = 50
										DartsStats[DARTS_SCLB_STAT_BULLS_EYES]++
										CDEBUG1LN(DEBUG_DARTS, "[DARTSXP] xp given for bullseye")
										iXPToGive = ROUND(BASE_BULLSEYE_XP * g_sMPTunables.fxp_tunable_darts_bullseye)
										CDEBUG1LN(DEBUG_DARTS, "[DARTSXP] after tuning, xp given = ", iXPToGive)
										iBullseyeXP += GIVE_LOCAL_PLAYER_XP(eXPTYPE_CO_OP_JOBFM, "XPT_DARTS", XPTYPE_SKILL, XPCATEGORY_SKILL_DARTS_BULLSEYE, iXPToGive)
										CDEBUG1LN(DEBUG_DARTS, "[DARTSXP] iBullseyeXP is now ", iBullseyeXP)
									ENDIF
								ENDIF
								
								IF DARTS_GET_UI_FLAG(serverData.iUIFlags, DARTS_UIFLAGS_SWITCH_PLAYER) //serverData.bDoSwitchPlayer
									
									DartsUI.iDartsLeft = 3
									
									// sending the darts back to the player, resetting them
									// serves the same functioon as RESET_DART without deleting the object
									INT y
									REPEAT NUM_MP_DART_TURNS y
										RESET_DART(MPDartGame.Darts[y])
										MPDartGame.Darts[y].bDoneScoring = FALSE
										CDEBUG1LN(DEBUG_DARTS, "[AM_DARTS]MPDartGame.Darts ", y, " was reset")
									ENDREPEAT
									
									IF ServerData.iLastScore[ServerData.iThrower] <> ServerData.iScores[ServerData.iThrower]
										DARTS_ADD_SCORE(DartsSB, playerData[ServerData.iThrower].iOffsetPlayerID, ServerData.iScores[ServerData.iThrower])
									ENDIF
									
									CDEBUG1LN(DEBUG_DARTS, "[AM_DARTS]iSelfID = ", iSelfID)
									CDEBUG1LN(DEBUG_DARTS, "[AM_DARTS]serverData.iThrower = ", serverData.iThrower)
									CDEBUG1LN(DEBUG_DARTS, "[AM_DARTS]ServerData.iTurnscore = ", ServerData.iTurnscore)
									
									IF iSelfID = serverData.iThrower
										IF ServerData.iTurnscore = 180
										AND NOT DARTS_CHECK_CLIENT_FLAG(PlayerData[iSelfID], DARTS_CLIENTFLAG_SINGLE_PLAYER)
											DartsStats[DARTS_SCLB_STAT_NUM_180S]++
											CDEBUG1LN(DEBUG_DARTS, "[AM_DARTS]Added 180 stat")
										ENDIF
									ELSE
										bWaitUIShow = FALSE
									ENDIF
									
									IF NOT DARTS_CHECK_CLIENT_FLAG(PlayerData[iSelfID], DARTS_CLIENTFLAG_SINGLE_PLAYER)
										UPDATE_HIGHLIGHT(DartsSB, playerData[serverData.iWaiter].iOffsetPlayerID)
									ENDIF
									
									iSteadyShotsUsed = 0
								ENDIF
								CDEBUG1LN(DEBUG_DARTS, "[AM_DARTS] current client finished reset in SCORE CHECK")
								playerData[iSelfID].bResetDone = TRUE
							ENDIF
						BREAK
						
						CASE DARTS_MPTURN_WINNING
							CDEBUG1LN(DEBUG_DARTS, "********** serverData.iWinner = ", serverData.iWinner)
							
							CLEAR_PRINTS()
							
							IF NOT MPGlobals.DartsData.bResultsDisplayed
								MPGlobals.DartsData.bResultsDisplayed = TRUE
							ENDIF
							
							// if you done won
							IF serverData.iWinner = iSelfID
								//PRINT_WITH_NUMBER_NOW("DARTS_REMAINL", 0, 5000, 1)
								MPDartGame.bDartWinner = TRUE
								
								MPDartGame.iGamesWon++
								
								IF iSelfID = serverData.iThrower
									IF playerData[iSelfID].ClientDart.iHitValue = 50
										CDEBUG1LN(DEBUG_DARTS, "[DARTSXP] experience given for bullseye after a win")
										DartsStats[DARTS_SCLB_STAT_BULLS_EYES]++
										iXPToGive = ROUND(BASE_BULLSEYE_XP * g_sMPTunables.fxp_tunable_darts_bullseye)
										CDEBUG1LN(DEBUG_DARTS, "[DARTSXP] after tuning, xp given = ", iXPToGive)
										iBullseyeXP += GIVE_LOCAL_PLAYER_XP(eXPTYPE_CO_OP_JOBFM, "XPT_DARTS", XPTYPE_SKILL, XPCATEGORY_SKILL_DARTS_BULLSEYE, iXPToGive)
										CDEBUG1LN(DEBUG_DARTS, "[DARTSXP] iBullseyeXP is now ", iBullseyeXP)
									ENDIF
								ENDIF
								
								IF NOT DARTS_CHECK_CLIENT_FLAG(PlayerData[iSelfID], DARTS_CLIENTFLAG_SINGLE_PLAYER)
									CDEBUG1LN(DEBUG_DARTS, "[DARTSXP] experience given for leg win")
									DartsStats[DARTS_SCLB_STAT_NUM_LEGS_WON]++
									iXPGained += ROUND(BASE_LEG_WIN_XP * g_sMPTunables.fxp_tunable_darts_legwon)
									CDEBUG1LN(DEBUG_DARTS, "[DARTSXP] g_sMPTunables.fxp_tunable_darts_legwon = ", g_sMPTunables.fxp_tunable_darts_legwon)
									//GIVE_LOCAL_PLAYER_XP(eXPTYPE_CO_OP_JOBFM, "XPT_DARTS", XPTYPE_COMPLETE, XPCATEGORY_COMPLETE_DARTS_WIN, 50)
									CDEBUG1LN(DEBUG_DARTS, "[DARTSXP] iXPGained is now ", iXPGained)
								ENDIF
								
								IF MPDartGame.iThrowsTaken[PlayerData[iSelfID].iOffsetPlayerID] <= 6
									SET_MP_BOOL_CHARACTER_AWARD(MP_AWARD_FM6DARTCHKOUT, TRUE)
								ENDIF
								
							// if you lost... loser
							ELSE
								//PRINT_WITH_NUMBER_NOW("DARTS_REMAINL", 0, 5000, 1)
								MPDartGame.bDartWinner = FALSE
								
								MPDartGame.iGamesLost++
								
								IF NOT DARTS_CHECK_CLIENT_FLAG(PlayerData[iSelfID], DARTS_CLIENTFLAG_SINGLE_PLAYER)
									DartsStats[DARTS_SCLB_STAT_NUM_LEGS_LOST]++
								ENDIF
								
							ENDIF
							
							RESTART_TIMER_NOW(controlTimer) 
							
							IF DARTS_SERVER_CHECK_FLAG(serverData, DARTSERVERFLAG_DO_TRANSITION)
								PlayerData[iSelfID].eMPState = DARTS_MPSTATE_GAME_TRANSITION
							ELSE
								
								CDEBUG1LN(DEBUG_DARTS, "calling trigger pre load for DARTS")
								TRIGGER_CELEBRATION_PRE_LOAD(sCelebrationData, TRUE)
								
								IF NOT DARTS_CHECK_CLIENT_FLAG(PlayerData[iSelfID], DARTS_CLIENTFLAG_SINGLE_PLAYER)
									IF MPDartGame.bDartWinner
										
										IF serverData.iNumLegs < 5
											INCREMENT_PLAYER_PED_STAT(CHAR_MULTIPLAYER, PS_STRENGTH, 1)
											CPRINTLN(DEBUG_DARTS, "STRENGTH STAT INCREASED by 1 FROM DARTS")
										ELSE
											INCREMENT_PLAYER_PED_STAT(CHAR_MULTIPLAYER, PS_STRENGTH, 2)
											CPRINTLN(DEBUG_DARTS, "STRENGTH STAT INCREASED by 2 FROM DARTS")
										ENDIF
										
										INCREMENT_BY_MP_INT_CHARACTER_AWARD(MP_AWARD_WIN_AT_DARTS , 1)
										INCREMENT_BY_MP_INT_PLAYER_STAT(MPPLY_DARTS_TOTAL_WINS, 1)
										DartsStats[DARTS_SCLB_STAT_NUM_WINS]++
										DartsStats[DARTS_SCLB_STAT_NUM_SETS_WON]++
									ELSE
										DartsStats[DARTS_SCLB_STAT_NUM_LOSSES]++
										DartsStats[DARTS_SCLB_STAT_NUM_SETS_LOST]++
									ENDIF
									
									INCREMENT_BY_MP_INT_PLAYER_STAT(MPPLY_DARTS_TOTAL_MATCHES, 1)
								ENDIF
								
								DartsUI.iOurScore += serverData.iSets[iSelfID]
								DartsUI.iTheirScore += serverData.iSets[iOtherID]
								DartsUI.sMyName = sDartsPlayerNames[playerData[iSelfID].iOffsetPlayerID]
								DartsUI.sTheirName = sDartsPlayerNames[playerData[iOtherID].iOffsetPlayerID]
								
								IF NOT DARTS_CHECK_CLIENT_FLAG(PlayerData[iSelfID], DARTS_CLIENTFLAG_SINGLE_PLAYER)
									IF MPDartGame.bDartWinner
										CDEBUG1LN(DEBUG_DARTS, "[DARTSXP] giving darts won XP")
										iXPGained += ROUND(BASE_MATCH_WIN_XP * g_sMPTunables.fxp_tunable_darts_match_win)
										CDEBUG1LN(DEBUG_DARTS, "[DARTSXP] g_sMPTunables.fxp_tunable_darts_match_win is  ", g_sMPTunables.fxp_tunable_darts_match_win)
										//GIVE_LOCAL_PLAYER_XP(eXPTYPE_CO_OP_JOBFM, "XPT_DARTS", XPTYPE_COMPLETE, XPCATEGORY_COMPLETE_DARTS_WIN, 250)
										CDEBUG1LN(DEBUG_DARTS, "[DARTSXP] iXPGained is now ", iXPGained)
										iBetWinnings = BROADCAST_BETTING_MISSION_FINISHED(PLAYER_ID())
										CDEBUG1LN(DEBUG_DARTS, "money given to me the winner")
									ELSE
										iBetWinnings = BROADCAST_BETTING_MISSION_FINISHED(NETWORK_GET_PLAYER_INDEX(INT_TO_PARTICIPANTINDEX(iOtherID)))
										CDEBUG1LN(DEBUG_DARTS, "money given to the other guy, cuz i lost")
									ENDIF
								ENDIF
								
								IF MPDartGame.bDartWinner
									
								ENDIF
								
								IF iBetWinnings > 0
									CDEBUG1LN(DEBUG_DARTS, "iBetWinnings = ", iBetWinnings)
								ELSE
									CDEBUG1LN(DEBUG_DARTS, "no bets were won")
								ENDIF
								
								CDEBUG1LN(DEBUG_DARTS, "g_iMyBetWinnings = ", g_iMyBetWinnings)
								
								CDEBUG1LN(DEBUG_DARTS, "[DARTSXP] giving darts match finish bonus")
								iXPGained += ROUND(BASE_DART_PLAY_XP * g_sMPTunables.fxp_tunable_darts_taking_part)
								CDEBUG1LN(DEBUG_DARTS, "[DARTSXP] g_sMPTunables.fxp_tunable_darts_taking_part = ", g_sMPTunables.fxp_tunable_darts_taking_part)
								//GIVE_LOCAL_PLAYER_XP(eXPTYPE_CO_OP_JOBFM, "XPT_DARTS", XPTYPE_COMPLETE, XPCATEGORY_COMPLETE_DARTS_WIN, 100)
								CDEBUG1LN(DEBUG_DARTS, "[DARTSXP] iXPGained is now ", iXPGained)
								
								SET_MP_DAILY_OBJECTIVE_COMPLETE(MP_DAILY_JOB_PLAY_DARTS)
								CPRINTLN(DEBUG_DARTS, "DAILY OBJECTIVE COMPLETE FOR DARTS")
								
								PlayerData[iSelfID].eMPState = DARTS_MPSTATE_GAME_END
							ENDIF
						BREAK
					ENDSWITCH			
				BREAK
				
				CASE DARTS_MPSTATE_GAME_TRANSITION
					IF NOT DARTS_CHECK_CLIENT_FLAG(PlayerData[iSelfID], DARTS_CLIENTFLAG_SINGLE_PLAYER)
						SET_PLAYER_INVISIBLE_LOCALLY(NETWORK_GET_PLAYER_INDEX(INT_TO_PARTICIPANTINDEX(iOtherID)))
						SET_PLAYER_INVISIBLE_LOCALLY(PLAYER_ID())
					ENDIF
					
					SWITCH iSplashStage
						CASE 0
							IF GET_TIMER_IN_SECONDS_SAFE(controlTimer) > 0.75
								CLEAR_HELP()
								CLEAR_PRINTS()
								
								
								
								IF DARTS_CHECK_CLIENT_FLAG(PlayerData[iSelfID], DARTS_CLIENTFLAG_SINGLE_PLAYER)
									UPDATE_SB_SETS_LEGS(DartsSB, 0, serverData.iSets[iSelfID], 0, serverData.iLegs[iSelfID])
								ELSE
									IF NETWORK_IS_HOST_OF_THIS_SCRIPT()
										UPDATE_SB_SETS_LEGS(DartsSB, serverData.iSets[iOtherID], serverData.iSets[iSelfID], serverData.iLegs[iOtherID], serverData.iLegs[iSelfID])
									ELSE
										UPDATE_SB_SETS_LEGS(DartsSB, serverData.iSets[iSelfID], serverData.iSets[iOtherID], serverData.iLegs[iSelfID], serverData.iLegs[iOtherID])
									ENDIF
								ENDIF
								
								//big message here
								IF DARTS_SERVER_CHECK_FLAG(serverData, DARTSERVERFLAG_SET_JUST_WON)
									IF NOT DARTS_CHECK_CLIENT_FLAG(PlayerData[iSelfID], DARTS_CLIENTFLAG_SINGLE_PLAYER)
										IF MPDartGame.bDartWinner
											DartsStats[DARTS_SCLB_STAT_NUM_SETS_WON]++
										ELSE
											DartsStats[DARTS_SCLB_STAT_NUM_SETS_LOST]++
										ENDIF
									ENDIF
									
									IF MPDartGame.bDartWinner
										IF NOT DARTS_CHECK_CLIENT_FLAG(PlayerData[iSelfID], DARTS_CLIENTFLAG_SINGLE_PLAYER)
											SET_SHARD_BIG_MESSAGE(shardMidSizeMessage, "DARTS_WINNER", "DARTS_SETW", 4000, SHARD_MESSAGE_MIDSIZED, HUD_COLOUR_WHITE)
											//SET_SCALEFORM_MIDSIZED_MESSAGE(DartsUI.siMidMessage, "DARTS_WINNER", "DARTS_SETW")
										ELSE
											SET_SHARD_BIG_MESSAGE(shardMidSizeMessage, "DARTS_WINP", "DARTS_SETW", 4000, SHARD_MESSAGE_MIDSIZED, HUD_COLOUR_WHITE)
											//SET_SCALEFORM_MIDSIZED_MESSAGE(DartsUI.siMidMessage, "DARTS_WINP", "DARTS_SETW")
										ENDIF
									ELSE
										SET_SHARD_BIG_MESSAGE(shardMidSizeMessage, "BM_R2P_LOSS", "DARTS_SETL", 4000, SHARD_MESSAGE_MIDSIZED, HUD_COLOUR_RED)
										//SET_SCALEFORM_MIDSIZED_MESSAGE(DartsUI.siMidMessage, "DARTS_LOSER", "DARTS_SETL",4000, HUD_COLOUR_RED)
									ENDIF
								ELSE
									IF MPDartGame.bDartWinner
										IF NOT DARTS_CHECK_CLIENT_FLAG(PlayerData[iSelfID], DARTS_CLIENTFLAG_SINGLE_PLAYER)
											SET_SHARD_BIG_MESSAGE(shardMidSizeMessage, "DARTS_WINNER", "DARTS_LEGW", 4000, SHARD_MESSAGE_MIDSIZED, HUD_COLOUR_WHITE)
											//SET_SCALEFORM_MIDSIZED_MESSAGE(DartsUI.siMidMessage, "DARTS_WINNER", "DARTS_LEGW")
										ELSE
											SET_SHARD_BIG_MESSAGE(shardMidSizeMessage, "DARTS_WINP", "DARTS_LEGW", 4000, SHARD_MESSAGE_MIDSIZED, HUD_COLOUR_WHITE)
											//SET_SCALEFORM_MIDSIZED_MESSAGE(DartsUI.siMidMessage, "DARTS_WINP", "DARTS_LEGW")
										ENDIF
									ELSE
										SET_SHARD_BIG_MESSAGE(shardMidSizeMessage, "BM_R2P_LOSS", "DARTS_LEGL", 4000, SHARD_MESSAGE_MIDSIZED, HUD_COLOUR_RED)
										//SET_SCALEFORM_MIDSIZED_MESSAGE(DartsUI.siMidMessage, "DARTS_LOSER", "DARTS_LEGL", 4000, HUD_COLOUR_RED)
									ENDIF
								ENDIF
								
								IF MPDartGame.bDartWinner
									PLAY_SOUND_FRONTEND ( -1, "WIN", "HUD_AWARDS")
								ELSE
									PLAY_SOUND_FRONTEND ( -1, "LOSER", "HUD_AWARDS")
								ENDIF
								
								INT iWhichOutro
									
								FLOAT fResolution
								fResolution = GET_ASPECT_RATIO(TRUE)
								CDEBUG1LN(DEBUG_DARTS, " fResolution = ", fResolution)
								
								IF fResolution > 2.0
									CDEBUG1LN(DEBUG_DARTS, " resolution is eyefinity")
									scenePosition = << 1992.29407, 3047.57690, 46.21517 >>
									sceneRotation = << 0.000, 0.000, 138.740 >>
								ELSE
									CDEBUG1LN(DEBUG_DARTS, "resolution is not eyefinity")
									scenePosition = << 1992.33569, 3047.92432, 46.21517 >>
									sceneRotation = << 0.000, 0.000, 136.740 >>
								ENDIF
								
								iWhichOutro = (GET_RANDOM_INT_IN_RANGE() % 3)
								
								CDEBUG1LN(DEBUG_DARTS, "iWhichOutro = ", iWhichOutro)
								
								iSceneID = CREATE_SYNCHRONIZED_SCENE(scenePosition, sceneRotation)
								camDartsSync = CREATE_CAM("DEFAULT_ANIMATED_CAMERA", FALSE)
								PLAY_SYNCHRONIZED_CAM_ANIM(camDartsSync, iSceneID, sOutroCam[iWhichOutro], "mini@dartsoutro")
								SET_CAM_ACTIVE(camDartsSync, TRUE)
								RENDER_SCRIPT_CAMS(TRUE, FALSE)
								
								IF NOT DARTS_CHECK_CLIENT_FLAG(PlayerData[iSelfID], DARTS_CLIENTFLAG_SINGLE_PLAYER)
									IF NOT IS_PED_INJURED(piPlayerClones[0])
									AND NOT IS_PED_INJURED(piPlayerClones[1])
										IF MPDartGame.bDartWinner
											TASK_SYNCHRONIZED_SCENE (piPlayerClones[playerData[iSelfID].iOffsetPlayerID], iSceneID, "mini@dartsoutro", sOutroWin[iWhichOutro], INSTANT_BLEND_IN, WALK_BLEND_OUT )
											TASK_SYNCHRONIZED_SCENE (piPlayerClones[playerData[iOtherID].iOffsetPlayerID], iSceneID, "mini@dartsoutro", sOutroLoss[iWhichOutro], INSTANT_BLEND_IN, WALK_BLEND_OUT )
											TASK_PLAY_ANIM(piPlayerClones[playerData[iSelfID].iOffsetPlayerID], sFacialDictPed, sFacialClip[GET_RANDOM_INT_IN_RANGE(0, 3)], WALK_BLEND_IN, WALK_BLEND_OUT, -1, AF_SECONDARY | AF_LOOPING)
										ELSE
											TASK_SYNCHRONIZED_SCENE (piPlayerClones[playerData[iOtherID].iOffsetPlayerID], iSceneID, "mini@dartsoutro", sOutroWin[iWhichOutro], INSTANT_BLEND_IN, WALK_BLEND_OUT )
											TASK_SYNCHRONIZED_SCENE (piPlayerClones[playerData[iSelfID].iOffsetPlayerID], iSceneID, "mini@dartsoutro", sOutroLoss[iWhichOutro], INSTANT_BLEND_IN, WALK_BLEND_OUT )
											TASK_PLAY_ANIM(piPlayerClones[playerData[iSelfID].iOffsetPlayerID], sFacialDictPed2, sFacialClip2[GET_RANDOM_INT_IN_RANGE(0, 3)], WALK_BLEND_IN, WALK_BLEND_OUT, -1, AF_SECONDARY | AF_LOOPING)
										ENDIF
									ENDIF
								ELSE
									IF NOT IS_PED_INJURED(PLAYER_PED_ID())
										TASK_SYNCHRONIZED_SCENE (PLAYER_PED_ID(), iSceneID, "mini@dartsoutro", sOutroWin[iWhichOutro], INSTANT_BLEND_IN, WALK_BLEND_OUT )
										TASK_PLAY_ANIM(PLAYER_PED_ID(), sFacialDictPed, sFacialClip[GET_RANDOM_INT_IN_RANGE(0, 3)], WALK_BLEND_IN, WALK_BLEND_OUT, -1, AF_SECONDARY | AF_LOOPING)
									ENDIF
								ENDIF
								
								iSplashStage++
							ENDIF
						BREAK
						
						CASE 1
							//IF NOT UPDATE_SCALEFORM_MIDSIZED_MESSAGE(DartsUI.siMidMessage, TRUE)
							IF NOT UPDATE_SHARD_BIG_MESSAGE(shardMidSizeMessage, TRUE)
								
								RESET_SHARD_BIG_MESSAGE(shardMidSizeMessage)
								
								REPEAT NUM_MP_DART_PLAYERS i
									DARTS_CLEAR_SCORES(DartsSB, i)
								ENDREPEAT
								
								REPEAT NUM_MP_DART_TURNS j
									RESET_DART(MPDartGame.Darts[j])
								ENDREPEAT
								
								iSplashStage++
							ENDIF
						BREAK
						
						CASE 2
							IF NOT DARTS_CHECK_CLIENT_FLAG(PlayerData[iSelfID], DARTS_CLIENTFLAG_SINGLE_PLAYER)
								IF NOT IS_PED_INJURED(piPlayerClones[DART_PLAYER_AWAY])
								AND NOT IS_PED_INJURED(piPlayerClones[DART_PLAYER_HOME])
									DARTS_GAME_CAM()
									DESTROY_CAM(camDartsSync)
									CLEAR_PED_TASKS (piPlayerClones[DART_PLAYER_AWAY])
									CLEAR_PED_TASKS (piPlayerClones[DART_PLAYER_HOME])
								ENDIF
							ELSE
								IF NOT IS_PED_INJURED(PLAYER_PED_ID())
									DARTS_GAME_CAM()
									DESTROY_CAM(camDartsSync)
									CLEAR_PED_TASKS (PLAYER_PED_ID())
								ENDIF
							ENDIF
							
							CDEBUG1LN(DEBUG_DARTS, "Starting another set/leg")
							PlayerData[iSelfID].bDoRematch = TRUE
							KILL_MINIGAME_MISSION_TRACKER()
							iSplashStage = 0
							PlayerData[iSelfID].eMPState = DARTS_MPSTATE_WAIT_POST_GAME
						BREAK
						
					ENDSWITCH
				BREAK
				
				CASE DARTS_MPSTATE_GAME_END
					//DARTS_UI_RETVAL DartsUIRetVal
					JOB_WIN_STATUS eJobWinStatus
					
					DEBUG_MESSAGE_PERIODIC("Reached Client side GAME END", iDebugThrottle)
					
					IF NOT DARTS_CHECK_CLIENT_FLAG(PlayerData[iSelfID], DARTS_CLIENTFLAG_SINGLE_PLAYER)
						IF NETWORK_IS_PARTICIPANT_ACTIVE( INT_TO_PARTICIPANTINDEX(iOtherID) )
							SET_PLAYER_INVISIBLE_LOCALLY(NETWORK_GET_PLAYER_INDEX(INT_TO_PARTICIPANTINDEX(iOtherID)))
						ENDIF
						SET_PLAYER_INVISIBLE_LOCALLY(PLAYER_ID())
					ENDIF
					
					IF GET_TIMER_IN_SECONDS_SAFE(controlTimer) > 0.75
						// wait for the player to pick an option
						
						IF (PlayerData[iOtherID].eMPState >= DARTS_MPSTATE_GAME_END)
						OR DARTS_CHECK_CLIENT_FLAG(PlayerData[iSelfID], DARTS_CLIENTFLAG_SINGLE_PLAYER)
							
							// wait 'til we've finished rendering the player win/lost text
							IF NOT MPDartGame.bAnotherCamActive
								
								CLEAR_HELP()
								CLEAR_PRINTS()
								
								#IF IS_DEBUG_BUILD
									IF DARTS_CHECK_CLIENT_FLAG(PlayerData[iSelfID], DARTS_CLIENTFLAG_WINNERD)
									OR DARTS_CHECK_CLIENT_FLAG(PlayerData[iOtherID], DARTS_CLIENTFLAG_LOSERD)
										MPDartGame.bDartWinner = TRUE
									ELIF DARTS_CHECK_CLIENT_FLAG(PlayerData[iOtherID], DARTS_CLIENTFLAG_WINNERD)
									OR DARTS_CHECK_CLIENT_FLAG(PlayerData[iSelfID], DARTS_CLIENTFLAG_LOSERD)
										MPDartGame.bDartWinner = FALSE
									ENDIF
								#ENDIF
								
								INT iWhichOutro
								
								FLOAT fResolution
								fResolution = GET_ASPECT_RATIO(TRUE)
								CDEBUG1LN(DEBUG_DARTS, " fResolution = ", fResolution)
								
								IF fResolution > 2.0
									CDEBUG1LN(DEBUG_DARTS, " resolution is eyefinity")
									scenePosition = << 1992.29407, 3047.57690, 46.21517 >>
									sceneRotation = << 0.000, 0.000, 138.740 >>
								ELSE
									CDEBUG1LN(DEBUG_DARTS, "resolution is not eyefinity")
									scenePosition = << 1992.33569, 3047.92432, 46.21517 >>
									sceneRotation = << 0.000, 0.000, 136.740 >>
								ENDIF
								
								iWhichOutro = 2 //(GET_RANDOM_INT_IN_RANGE() % 3) DO NOT CHECK THIS IN
								
								CDEBUG1LN(DEBUG_DARTS, "iWhichOutro = ", iWhichOutro)
								
								iSceneID = CREATE_SYNCHRONIZED_SCENE(scenePosition, sceneRotation)
								camDartsSync = CREATE_CAM("DEFAULT_ANIMATED_CAMERA", FALSE)
								PLAY_SYNCHRONIZED_CAM_ANIM(camDartsSync, iSceneID, sOutroCam[iWhichOutro], "mini@dartsoutro")
								SET_CAM_ACTIVE(camDartsSync, TRUE)
								RENDER_SCRIPT_CAMS(TRUE, FALSE)
								
								IF NOT DARTS_CHECK_CLIENT_FLAG(PlayerData[iSelfID], DARTS_CLIENTFLAG_SINGLE_PLAYER)
									IF NOT IS_PED_INJURED(piPlayerClones[0])
									AND NOT IS_PED_INJURED(piPlayerClones[1])
										IF MPDartGame.bDartWinner
											PLAY_CELEB_WIN_POST_FX()
										
											TASK_SYNCHRONIZED_SCENE (piPlayerClones[playerData[iSelfID].iOffsetPlayerID], iSceneID, "mini@dartsoutro", sOutroWin[iWhichOutro], INSTANT_BLEND_IN, WALK_BLEND_OUT )
											TASK_SYNCHRONIZED_SCENE (piPlayerClones[playerData[iOtherID].iOffsetPlayerID], iSceneID, "mini@dartsoutro", sOutroLoss[iWhichOutro], INSTANT_BLEND_IN, WALK_BLEND_OUT )
											TASK_PLAY_ANIM(piPlayerClones[playerData[iSelfID].iOffsetPlayerID], sFacialDictPed, sFacialClip[GET_RANDOM_INT_IN_RANGE(0, 3)], WALK_BLEND_IN, WALK_BLEND_OUT, -1, AF_SECONDARY | AF_LOOPING)
										ELSE
											PLAY_CELEB_LOSE_POST_FX()
											
											TASK_SYNCHRONIZED_SCENE (piPlayerClones[playerData[iOtherID].iOffsetPlayerID], iSceneID, "mini@dartsoutro", sOutroWin[iWhichOutro], INSTANT_BLEND_IN, WALK_BLEND_OUT )
											TASK_SYNCHRONIZED_SCENE (piPlayerClones[playerData[iSelfID].iOffsetPlayerID], iSceneID, "mini@dartsoutro", sOutroLoss[iWhichOutro], INSTANT_BLEND_IN, WALK_BLEND_OUT )
											TASK_PLAY_ANIM(piPlayerClones[playerData[iSelfID].iOffsetPlayerID], sFacialDictPed2, sFacialClip2[GET_RANDOM_INT_IN_RANGE(0, 3)], WALK_BLEND_IN, WALK_BLEND_OUT, -1, AF_SECONDARY | AF_LOOPING)
										ENDIF
									ENDIF
								ELSE
									IF NOT IS_PED_INJURED(PLAYER_PED_ID())
										PLAY_CELEB_WIN_POST_FX()
										
										TASK_SYNCHRONIZED_SCENE (PLAYER_PED_ID(), iSceneID, "mini@dartsoutro", sOutroWin[iWhichOutro], INSTANT_BLEND_IN, WALK_BLEND_OUT )
										TASK_PLAY_ANIM(PLAYER_PED_ID(), sFacialDictPed, sFacialClip[GET_RANDOM_INT_IN_RANGE(0, 3)], WALK_BLEND_IN, WALK_BLEND_OUT, -1, AF_SECONDARY | AF_LOOPING)
									ENDIF
								ENDIF
								
								MPDartGame.bAnotherCamActive = TRUE
							ELSE
								IF (IS_SYNCHRONIZED_SCENE_RUNNING(iSceneID) AND GET_SYNCHRONIZED_SCENE_PHASE(iSceneID) >= 0.995)
								OR NOT IS_SYNCHRONIZED_SCENE_RUNNING(iSceneID)
									
//									IF DOES_CAM_EXIST(camDartsSync)
//										DESTROY_CAM(camDartsSync)
//										
//										IF NOT DARTS_CHECK_CLIENT_FLAG(PlayerData[iSelfID], DARTS_CLIENTFLAG_SINGLE_PLAYER)
//											IF NOT IS_PED_INJURED(piPlayerClones[0])
//											AND NOT IS_PED_INJURED(piPlayerClones[1])
//												CLEAR_PED_TASKS_IMMEDIATELY(piPlayerClones[0])
//												CLEAR_PED_TASKS_IMMEDIATELY(piPlayerClones[1])
//												FORCE_PED_AI_AND_ANIMATION_UPDATE(piPlayerClones[0])
//												FORCE_PED_AI_AND_ANIMATION_UPDATE(piPlayerClones[1])
//											ENDIF
//										ELSE
//											IF NOT IS_PED_INJURED(PLAYER_PED_ID())
//												CLEAR_PED_TASKS_IMMEDIATELY(PLAYER_PED_ID())
//												FORCE_PED_AI_AND_ANIMATION_UPDATE(PLAYER_PED_ID())
//											ENDIF
//										ENDIF
//									ENDIF
//									
//									DARTS_SETUP_MP_QUIT_CAM()
//									//ANOTHER_GAME_BACKSIDE()
								ENDIF
							ENDIF
						ENDIF
						
						IF iBullseyeXP > 0
							CDEBUG1LN(DEBUG_DARTS, "iBullseyeXP = ", iBullseyeXP)
						ENDIF
						
						IF MPDartGame.bDartWinner
							eJobWinStatus = JOB_STATUS_WIN
							winningPlayer = PLAYER_ID()
						ELSE
							eJobWinStatus = JOB_STATUS_LOSE
							winningPlayer = NETWORK_GET_PLAYER_INDEX(INT_TO_PARTICIPANTINDEX(iOtherID))
						ENDIF
						
						IF GET_TIMER_IN_SECONDS_SAFE(controlTimer) > 2.15
							IF HAS_GENERIC_CELEBRATION_FINISHED(sCelebrationData, camEndScreen, 
																"XPT_DARTS", XPTYPE_COMPLETE, XPCATEGORY_COMPLETE_DARTS_WIN, iXPGained, 
																eJobWinStatus, g_iMyBetWinnings, eGenericMGStage, winningPlayer, TRUE, 
																0, 0, TRUE, FALSE)
																//DartsStats[DARTS_SCLB_STAT_NUM_LEGS_WON], DartsStats[DARTS_SCLB_STAT_NUM_LEGS_WON] + DartsStats[DARTS_SCLB_STAT_NUM_LEGS_LOST], TRUE)
							
	//							IF NOT g_TransitionSessionNonResetVars.sPostMissionCleanupData.bRequestLeaderBoardCam
	//								REQUEST_LEADERBOARD_CAM()
	//								//RENDER_SCRIPT_CAMS(FALSE, FALSE)
	//								
	//							ELIF IS_LEADERBOARD_CAM_READY(TRUE)
									
								IF NOT IS_TIMER_STARTED(endDelay)
									RESTART_TIMER_NOW(endDelay)
//									IF DOES_CAM_EXIST(camDartsSync)
//										DESTROY_CAM(camDartsSync)
//										
//										IF NOT DARTS_CHECK_CLIENT_FLAG(PlayerData[iSelfID], DARTS_CLIENTFLAG_SINGLE_PLAYER)
//											IF NOT IS_PED_INJURED(piPlayerClones[0])
//											AND NOT IS_PED_INJURED(piPlayerClones[1])
//												CLEAR_PED_TASKS_IMMEDIATELY(piPlayerClones[0])
//												CLEAR_PED_TASKS_IMMEDIATELY(piPlayerClones[1])
//												FORCE_PED_AI_AND_ANIMATION_UPDATE(piPlayerClones[0])
//												FORCE_PED_AI_AND_ANIMATION_UPDATE(piPlayerClones[1])
//											ENDIF
//										ELSE
//											IF NOT IS_PED_INJURED(PLAYER_PED_ID())
//												CLEAR_PED_TASKS_IMMEDIATELY(PLAYER_PED_ID())
//												FORCE_PED_AI_AND_ANIMATION_UPDATE(PLAYER_PED_ID())
//											ENDIF
//										ENDIF
//									ENDIF
//									
//									DARTS_SETUP_MP_QUIT_CAM()
									IF MPDartGame.bDartWinner
										ANIMPOSTFX_STOP("MP_Celeb_Win")
										//ANIMPOSTFX_PLAY("MP_Celeb_Win_Out", 0, TRUE)
									ELSE
										ANIMPOSTFX_STOP("MP_Celeb_Lose")
										//ANIMPOSTFX_PLAY("MP_Celeb_Lose_Out", 0, TRUE)
									ENDIF
									
								ELIF GET_TIMER_IN_SECONDS(endDelay) > 0.1
								
								ENDIF
								
								IF SET_SKYSWOOP_UP(TRUE, TRUE, FALSE)
								
									IF MPDartGame.bEndGameMessageDisplayed 
										
										#IF IS_DEBUG_BUILD
										IF DARTS_CHECK_CLIENT_FLAG(PlayerData[iSelfID], DARTS_CLIENTFLAG_WINNERD)
										OR DARTS_CHECK_CLIENT_FLAG(PlayerData[iSelfID], DARTS_CLIENTFLAG_LOSERD)
											CDEBUG1LN(DEBUG_DARTS, "Win / Lose debug flags cleared up")
											DARTS_CLEAR_CLIENT_FLAG(PlayerData[iSelfID], DARTS_CLIENTFLAG_WINNERD)
											DARTS_CLEAR_CLIENT_FLAG(PlayerData[iSelfID], DARTS_CLIENTFLAG_LOSERD)
										ENDIF
										#ENDIF
										
//										IF NETWORK_IS_HOST_OF_THIS_SCRIPT()
//											IF NOT HAS_NET_TIMER_STARTED(serverData.timeLeaderboardTimeOut)
//												START_NET_TIMER(serverData.timeLeaderboardTimeOut)
//											ENDIF
//										
//											FMMC_EOM_SERVER_RESET_PLAYER_COUNTS(sPlayerCounts)
//											INT iRematchLoop
//											REPEAT NETWORK_GET_MAX_NUM_PARTICIPANTS() iRematchLoop
//												IF NETWORK_IS_PARTICIPANT_ACTIVE(INT_TO_PARTICIPANTINDEX(iRematchLoop))
//													FMMC_EOM_SERVER_PLAYER_PROCESSING(sPlayerCounts, iRematchLoop)
//												ENDIF
//											ENDREPEAT
//											
//											FMMC_EOM_SERVER_END_OF_FRAME_PROCESSING(sPlayerCounts, serverData.sServerFMMC_EOM, FMMC_TYPE_MG_DARTS, 0)
//										ENDIF
										
										
//										IF HAS_NET_TIMER_STARTED(serverData.timeLeaderboardTimeOut)
//											IF MAINTAIN_END_OF_MISSION_SCREEN(sEndOfMission, serverData.sServerFMMC_EOM,
//																		GET_TIME_DIFFERENCE(GET_NETWORK_TIME(),serverData.timeLeaderboardTimeOut.timer) >= VIEW_LEADERBOARD_TIME,
//																		FALSE, FALSE, FALSE, FALSE, FALSE, serverData.timeLeaderboardTimeOut.timer, VIEW_LEADERBOARD_TIME, "LBD_TIMEOUT", TRUE)
												//Go to cleanup state
												CDEBUG1LN(DEBUG_DARTS, "Client chose to quit")
												CDEBUG1LN(DEBUG_DARTS, "my betting Wins = ", iBetWinnings)
												
												SET_VARS_ON_FMMC_EOM_VOTE_PASSING(ciFMMC_EOM_VOTE_STATUS_CONTINUE, <<0.0, 0.0, 0.0>>, contentID)
												
												CLEAR_PRINTS()
												PlayerData[iSelfID].bDoQuit = TRUE
												PlayerData[iSelfID].eMPState = DARTS_MPSTATE_END
//											ELSE
//												CDEBUG1LN(DEBUG_DARTS, "still voting")
//												//DISPLAY_DARTS_LEADERBOARD(DartsUI, DartsEndScreen, iXPGained, DartsUI.iOurScore, DartsUI.iTheirScore, iBetWinnings)
//											ENDIF
//										ENDIF
										
									ELSE
										IF (PlayerData[iOtherID].eMPState >= DARTS_MPSTATE_GAME_END)
										OR DARTS_CHECK_CLIENT_FLAG(PlayerData[iSelfID], DARTS_CLIENTFLAG_SINGLE_PLAYER)
											
											#IF IS_DEBUG_BUILD
												IF DARTS_CHECK_CLIENT_FLAG(PlayerData[iSelfID], DARTS_CLIENTFLAG_WINNERD)
												OR DARTS_CHECK_CLIENT_FLAG(PlayerData[iOtherID], DARTS_CLIENTFLAG_LOSERD)
													MPDartGame.bDartWinner = TRUE
												ELIF DARTS_CHECK_CLIENT_FLAG(PlayerData[iOtherID], DARTS_CLIENTFLAG_WINNERD)
												OR DARTS_CHECK_CLIENT_FLAG(PlayerData[iSelfID], DARTS_CLIENTFLAG_LOSERD)
													MPDartGame.bDartWinner = FALSE
												ENDIF
											#ENDIF
											
											MPDartGame.bEndGameMessageDisplayed = TRUE
											
										ENDIF
									ENDIF
								ENDIF
								
							ENDIF
							
							IF sCelebrationData.eCurrentStage = CELEBRATION_STAGE_PLAYING 
							AND HAS_NET_TIMER_EXPIRED(sCelebrationData.sCelebrationTimer, (CELEBRATION_SCREEN_STAT_DISPLAY_TIME/2) - 750)
								IF NOT bPhaseGrabbed
									
									//SET_SKYFREEZE_FROZEN()
									
									CDEBUG1LN(DEBUG_DARTS, "g_sMPTunables.xpMultiplier = ", g_sMPTunables.xpMultiplier)
									CDEBUG1LN(DEBUG_DARTS, "LOBBY_AUTO_MULTIPLAYER_FREEMODE() = ", LOBBY_AUTO_MULTIPLAYER_FREEMODE())
									CDEBUG1LN(DEBUG_DARTS, "GET_SKYFREEZE_STAGE() = ", GET_SKYFREEZE_STAGE())
									CDEBUG1LN(DEBUG_DARTS, "IS_PAUSE_MENU_ACTIVE() = ", IS_PAUSE_MENU_ACTIVE())
									
									IF GET_SKYFREEZE_STAGE() = SKYFREEZE_NONE
										SET_SKYFREEZE_STAGE(SKYFREEZE_FROZEN)
									ENDIF
									
									TOGGLE_RENDERPHASES(FALSE)
									
									CDEBUG1LN(DEBUG_DARTS, "rendering toggled")
									bPhaseGrabbed = TRUE
								ENDIF
							ENDIF
						ENDIF
					ENDIF
				BREAK
				
				CASE DARTS_MPSTATE_WAIT_POST_GAME
					DEBUG_MESSAGE_PERIODIC("CLIENT DARTS_MPSTATE_WAIT_POST_GAME", iDebugThrottle)
					
					IF (PlayerData[iSelfID].bDoRematch AND PlayerData[iOtherID].bDoRematch)
					OR (PlayerData[iSelfID].bDoRematch AND DARTS_CHECK_CLIENT_FLAG(PlayerData[iSelfID], DARTS_CLIENTFLAG_SINGLE_PLAYER))
										
						IF NOT IS_PED_INJURED(PLAYER_PED_ID()) AND NOT IS_PED_INJURED(PlayerData[iSelfID].piOther)
							TASK_CLEAR_LOOK_AT(PLAYER_PED_ID())							
						ENDIF
						// TODO:  add audio for playing again
						
						IF DARTS_CHECK_CLIENT_FLAG(PlayerData[iSelfID], DARTS_CLIENTFLAG_NEW_CHALLENGER)
							sDartsPlayerNames[PlayerData[iSelfID].iOffsetPlayerID] = GET_PLAYER_NAME(NETWORK_GET_PLAYER_INDEX(INT_TO_PARTICIPANTINDEX(iSelfID)))
							DartsGamerHandle[PlayerData[iSelfID].iOffsetPlayerID] = GET_GAMER_HANDLE_PLAYER(NETWORK_GET_PLAYER_INDEX(INT_TO_PARTICIPANTINDEX(iSelfID)))
							sCrewTags[PlayerData[iSelfID].iOffsetPlayerID] = GET_PLAYER_CLAN_TAG(DartsGamerHandle[PlayerData[iSelfID].iOffsetPlayerID])
								
							sDartsPlayerNames[PlayerData[iOtherID].iOffsetPlayerID] = GET_PLAYER_NAME(NETWORK_GET_PLAYER_INDEX(INT_TO_PARTICIPANTINDEX(iOtherID)))
							DartsGamerHandle[PlayerData[iOtherID].iOffsetPlayerID] = GET_GAMER_HANDLE_PLAYER(NETWORK_GET_PLAYER_INDEX(INT_TO_PARTICIPANTINDEX(iOtherID)))
							sCrewTags[PlayerData[iOtherID].iOffsetPlayerID] = GET_PLAYER_CLAN_TAG(DartsGamerHandle[PlayerData[iOtherID].iOffsetPlayerID])
							
							piOtherPlayer = GET_PLAYER_PED(NETWORK_GET_PLAYER_INDEX(INT_TO_PARTICIPANTINDEX(iOtherID)))
							
							INT iTemp1, iTemp2
							iTemp1 = ENUM_TO_INT(DART_PLAYER_AWAY)
							iTemp2 = ENUM_TO_INT(DART_PLAYER_HOME)
							
							CDEBUG1LN(DEBUG_DARTS, "iTemp1 = ", iTemp1, " iTemp2 = ", iTemp2)
							CDEBUG1LN(DEBUG_DARTS, "sCrewTags ", iTemp1, " = ", sCrewTags[iTemp1])
							CDEBUG1LN(DEBUG_DARTS, "sCrewTags ", iTemp2, " = ", sCrewTags[iTemp2])
							
							DARTS_ADD_NAMES(DartsSB, sDartsPlayerNames[iTemp1], sDartsPlayerNames[iTemp2])
							IF NOT IS_STRING_EMPTY(sCrewTags[iTemp1])
								DARTS_ADD_SB_CREW_TAG(DartsSB, iTemp1, sCrewTags[iTemp1])
							ENDIF
							IF NOT IS_STRING_EMPTY(sCrewTags[iTemp2])
								DARTS_ADD_SB_CREW_TAG(DartsSB, iTemp2, sCrewTags[iTemp2])
							ENDIF
							DARTS_CLEAR_SCORES(DartsSB, iTemp1)
							DARTS_CLEAR_SCORES(DartsSB, iTemp2)
							
							DARTS_CLEAR_CLIENT_FLAG(PlayerData[iSelfID], DARTS_CLIENTFLAG_SINGLE_PLAYER)
							DARTS_CLEAR_CLIENT_FLAG(PlayerData[iSelfID], DARTS_CLIENTFLAG_NEW_CHALLENGER)
						ENDIF
						
						CLEAR_HELP()
						CLEANUP_BIG_MESSAGE()
						
						IF (serverData.mpState = DARTS_MPSTATE_SETUP)
							PlayerData[iSelfID].eMPState = DARTS_MPSTATE_SYNC_OBJECTS
						ENDIF
					ENDIF
					
					// other player wants to quit 
					IF PlayerData[iOtherID].bDoQuit
						KILL_MINIGAME_MISSION_TRACKER()
						CLEAR_PRINTS()
						CLEANUP_BIG_MESSAGE()
						
						PlayerData[iSelfID].eMPState = DARTS_MPSTATE_TERMINATE_SPLASH
					ENDIF
				BREAK
				
				CASE DARTS_MPSTATE_TERMINATE_SPLASH
					DEBUG_MESSAGE_PERIODIC("Reached Client side TERMINATE SPLASH", iDebugThrottle)
					
					IF GET_CURRENT_GAMEMODE() = GAMEMODE_FM
						IF HAS_NET_TIMER_STARTED(timeDartsAwardFailSafe)
							//RENDER_SCRIPT_CAMS(FALSE, FALSE)
							DARTS_SETUP_MP_QUIT_CAM()
							
							
							IF IS_SCREEN_FADED_OUT()
							OR IS_SCREEN_FADING_OUT()
								DO_SCREEN_FADE_IN(500)
							ENDIF
							
							IF NOT g_TransitionSessionNonResetVars.sPostMissionCleanupData.bRequestLeaderBoardCam
								REQUEST_LEADERBOARD_CAM()
							ELIF IS_LEADERBOARD_CAM_READY(TRUE)
								REINIT_NET_TIMER(timeDartsAwardFailSafe)
								CLEAR_PRINTS()
								CLEAR_HELP()
								SET_RESULT_SCREEN_DISPLAYING_STATE(FALSE)
								
								IF MPGlobals.DartsData.bResultsDisplayed
									MPGlobals.DartsData.bResultsDisplayed = FALSE
								ENDIF
								
								PlayerData[iSelfID].eMPState = DARTS_MPSTATE_LEAVE
								
								IF (terminateReason = DARTS_MPTERMINATEREASON_PLAYERLEFT)
									SET_SHARD_BIG_MESSAGE(shardBigMessage, "DARTS_WINNER", "DARTS_OPP_LFT", (AWARD_FAILSAFE/2), SHARD_MESSAGE_CENTERED, HUD_COLOUR_WHITE)
									INIT_SIMPLE_USE_CONTEXT(DartsUI.inGameControlContext, FALSE, FALSE, FALSE, TRUE)
									ADD_SIMPLE_USE_CONTEXT_INPUT(DartsUI.inGameControlContext, "CMRC_CONT", FRONTEND_CONTROL, INPUT_FRONTEND_ACCEPT)
									leaveState = DARTS_MPLEAVESTATE_BIG_MESSAGE
									
									SET_VARS_ON_FMMC_EOM_VOTE_PASSING(ciFMMC_EOM_VOTE_STATUS_CONTINUE, <<0.0, 0.0, 0.0>>, contentID)
								ELSE
									IF NOT DARTS_CHECK_CLIENT_FLAG(PlayerData[DART_PLAYER_HOME_SERVER], DARTS_CLIENTFLAG_SINGLE_PLAYER)
										IF IS_STRING_NULL(sDartsPlayerNames[playerData[iOtherID].iOffsetPlayerID])
											PRINT_NOW("DARTS_OPP_LFT", DEFAULT_GOD_TEXT_TIME, 0)
										ELSE
											CDEBUG1LN(DEBUG_DARTS, "Other player name (ln 2950) = ", sDartsPlayerNames[playerData[iOtherID].iOffsetPlayerID])
											PRINT_WITH_NAME("DARTS_PLYR_LFT", sDartsPlayerNames[playerData[iOtherID].iOffsetPlayerID], DEFAULT_GOD_TEXT_TIME, 0)
										ENDIF
									ENDIF
									leaveState = DARTS_MPLEAVESTATE_LEADERBOARD
								ENDIF
							
							ENDIF
						ELSE
							START_NET_TIMER(timeDartsAwardFailSafe)
						ENDIF
					ELSE
						CDEBUG1LN(DEBUG_DARTS, "Other player name (ln 2962) = ", sDartsPlayerNames[playerData[iOtherID].iOffsetPlayerID])
						PRINT_WITH_NAME("DARTS_PLYR_LFT", sDartsPlayerNames[playerData[iOtherID].iOffsetPlayerID], DEFAULT_GOD_TEXT_TIME, 0)
						CLEANUP_MP_DARTS_GAME(MPDartGame, DartsUI)
					ENDIF
				BREAK
				
				CASE DARTS_MPSTATE_END
					IF GET_CURRENT_GAMEMODE() = GAMEMODE_FM
						
						IF HAS_NET_TIMER_STARTED(timeDartsAwardFailSafe)
						
							//RENDER_SCRIPT_CAMS(FALSE, FALSE)
							DARTS_SETUP_MP_QUIT_CAM()
							
							CLEANUP_BIG_MESSAGE()
							
							IF IS_SCREEN_FADED_OUT()
							OR IS_SCREEN_FADING_OUT()
								DO_SCREEN_FADE_IN(500)
							ENDIF
							
//							IF NOT g_TransitionSessionNonResetVars.sPostMissionCleanupData.bRequestLeaderBoardCam
//								REQUEST_LEADERBOARD_CAM()
//							ELIF IS_LEADERBOARD_CAM_READY(TRUE)
							IF SET_SKYSWOOP_UP(TRUE)
								REINIT_NET_TIMER(timeDartsAwardFailSafe)
								SET_RESULT_SCREEN_DISPLAYING_STATE(FALSE)
								
								IF MPGlobals.DartsData.bResultsDisplayed
									MPGlobals.DartsData.bResultsDisplayed = FALSE
								ENDIF
								PlayerData[iSelfID].eMPState = DARTS_MPSTATE_LEAVE
//							ENDIF
							
								leaveState = DARTS_MPLEAVESTATE_LEADERBOARD
							ENDIF
						ELSE
							START_NET_TIMER(timeDartsAwardFailSafe)
						ENDIF
					ELSE
						CDEBUG1LN(DEBUG_DARTS, "CLIENT STATE: DARTS_MPSTATE_END")
						CLEANUP_MP_DARTS_GAME(MPDartGame, DartsUI, TRUE, FALSE, TRUE)
					ENDIF
				BREAK
				
				CASE DARTS_MPSTATE_LEAVE
					SWITCH leaveState
						CASE DARTS_MPLEAVESTATE_BIG_MESSAGE
							IF NOT UPDATE_SHARD_BIG_MESSAGE(shardBigMessage, TRUE)
							OR HAS_NET_TIMER_EXPIRED(timeDartsAwardFailSafe, AWARD_FAILSAFE/2)
								CLEANUP_BIG_MESSAGE()
								
								CDEBUG1LN(DEBUG_DARTS, "[DARTSXP] timeDartsAwardFailSafe = ", GET_NET_TIMER_DIFFERENCE_WITH_CURRENT_TIME(timeDartsAwardFailSafe))
								
								CDEBUG1LN(DEBUG_DARTS, "[DARTSXP] giving participation XP after an early quit")
								iXPToGive = ROUND(BASE_DART_PLAY_XP * g_sMPTunables.fxp_tunable_darts_taking_part)
								CDEBUG1LN(DEBUG_DARTS, "[DARTSXP] g_sMPTunables.fxp_tunable_darts_bullseye = ", g_sMPTunables.fxp_tunable_darts_bullseye)
								CDEBUG1LN(DEBUG_DARTS, "[DARTSXP] g_sMPTunables.fxp_tunable_darts_legwon = ", g_sMPTunables.fxp_tunable_darts_legwon)
								CDEBUG1LN(DEBUG_DARTS, "[DARTSXP] g_sMPTunables.fxp_tunable_darts_match_win = ", g_sMPTunables.fxp_tunable_darts_match_win)
								CDEBUG1LN(DEBUG_DARTS, "[DARTSXP] g_sMPTunables.fxp_tunable_darts_taking_part = ", g_sMPTunables.fxp_tunable_darts_taking_part)
								CDEBUG1LN(DEBUG_DARTS, "[DARTSXP] iXPToGive = ", iXPToGive)
								iXPGained += GIVE_LOCAL_PLAYER_XP(eXPTYPE_CO_OP_JOBFM, "XPT_DARTS", XPTYPE_COMPLETE, XPCATEGORY_COMPLETE_DARTS_WIN, iXPToGive)
								CDEBUG1LN(DEBUG_DARTS, "[DARTSXP] iXPGained is now ", iXPGained)
								DartsUI.iOurScore++
								leaveState = DARTS_MPLEAVESTATE_SWOOP_UP
							ELSE
								IF NOT NETWORK_TEXT_CHAT_IS_TYPING()
									UPDATE_SIMPLE_USE_CONTEXT(DartsUI.inGameControlContext)
								ENDIF
							ENDIF
						BREAK
						
						CASE DARTS_MPLEAVESTATE_SWOOP_UP
							IF SET_SKYSWOOP_UP(TRUE)
								leaveState = DARTS_MPLEAVESTATE_LEADERBOARD
							ENDIF
						BREAK
						
						CASE DARTS_MPLEAVESTATE_LEADERBOARD
//							IF DISPLAY_DARTS_LEADERBOARD(DartsUI, DartsEndScreen, iXPGained, DartsUI.iOurScore, DartsUI.iTheirScore, iBetWinnings)
//							OR HAS_NET_TIMER_EXPIRED(timeDartsAwardFailSafe, AWARD_FAILSAFE)
								DEAL_WITH_FM_MATCH_END(FMMC_TYPE_MG_DARTS, ServerData.iMatchHistoryID, missionScriptArgs.mdID.idVariation, 
														PICK_INT(MPDartGame.bDartWinner, 1, 0), PICK_INT(MPDartGame.bDartWinner, 1, 2))
								
								SET_RESULT_SCREEN_DISPLAYING_STATE(FALSE)
								
								CLEANUP_MP_DARTS_GAME(MPDartGame, DartsUI)
//							ENDIF
						BREAK
					ENDSWITCH
				BREAK
				
			ENDSWITCH
		ENDIF
		
		// Server state machine
		IF NETWORK_IS_HOST_OF_THIS_SCRIPT()
			// General Update
			SWITCH ServerData.mpState
				CASE DARTS_MPSTATE_INIT
					CDEBUG1LN(DEBUG_DARTS, "[AM_DARTS] has reached Server side INIT")
					// wait for another participant
					IF iNumberOfPlayers >= 2
						// server side init stuff HERE
						
						IF DART_GET_OTHER_PLAYERS_ID(PlayerData, DART_PLAYER_AWAY_SERVER) = 2
						
							DART_PLAYER_HOME_SERVER = PARTICIPANT_ID_TO_INT()
							
							CDEBUG1LN(DEBUG_DARTS, "[AM_DARTS] Server says:")
							CDEBUG1LN(DEBUG_DARTS, "[AM_DARTS] DART_PLAYER_HOME_SERVER = ", DART_PLAYER_HOME_SERVER)
							CDEBUG1LN(DEBUG_DARTS, "[AM_DARTS] DART_PLAYER_AWAY_SERVER = ", DART_PLAYER_AWAY_SERVER)
							
							ServerData.mpState = DARTS_MPSTATE_THROW_OFF_SETUP
						ENDIF
						
					ELIF DARTS_CHECK_CLIENT_FLAG(PlayerData[iSelfID], DARTS_CLIENTFLAG_SINGLE_PLAYER)
						
						DART_PLAYER_HOME_SERVER = PARTICIPANT_ID_TO_INT()
						
						ServerData.mpState = DARTS_MPSTATE_SETUP
					ENDIF
				BREAK
				
				CASE DARTS_MPSTATE_THROW_OFF_SETUP
					DEBUG_MESSAGE_PERIODIC("Reached Server side THROW_OFF_SETUP", iDebugThrottle)
					IF IS_BIT_SET(PlayerData[iOtherID].iClientFlags, ENUM_TO_INT(DARTS_CLIENTFLAG_AT_THROWOFF))
					AND IS_BIT_SET(PlayerData[iSelfID].iClientFlags, ENUM_TO_INT(DARTS_CLIENTFLAG_AT_THROWOFF))
						DARTS_SERVER_THROW_OFF_SETUP(ServerData)
						ServerData.mpState = DARTS_MPSTATE_THROW_OFF
					ENDIF
				BREAK
				
				CASE DARTS_MPSTATE_THROW_OFF
					//DARTS_SERVER_UPDATE_RUN_CONDITIONS(ServerData, terminateReason, PlayerData)
					DARTS_SERVER_THROW_OFF_UPDATE(ServerData, PlayerData, MPDartGame.Darts[ServerData.iServerTurn])
				BREAK
				
				CASE DARTS_MPSTATE_SETUP
					DEBUG_MESSAGE_PERIODIC("Reached Server side SETUP", iDebugThrottle)
					IF (IS_BIT_SET(PlayerData[iOtherID].iClientFlags, ENUM_TO_INT(DARTS_CLIENTFLAG_SYNC_COMPLETE))
						AND IS_BIT_SET(PlayerData[iSelfID].iClientFlags, ENUM_TO_INT(DARTS_CLIENTFLAG_SYNC_COMPLETE)))
					OR (IS_BIT_SET(PlayerData[iSelfID].iClientFlags, ENUM_TO_INT(DARTS_CLIENTFLAG_SYNC_COMPLETE))
						AND IS_BIT_SET(PlayerData[iSelfID].iClientFlags, ENUM_TO_INT(DARTS_CLIENTFLAG_SINGLE_PLAYER)))
						
						DARTS_SERVER_GAME_SETUP(ServerData, DARTS_CHECK_CLIENT_FLAG(PlayerData[iSelfID], DARTS_CLIENTFLAG_SINGLE_PLAYER), iSelfID)
						
						// deactivate floating board help
						BROADCAST_DARTS_BOARD_ACTIVATE(PLAYER_ID(), FALSE)
						
						IF NOT DARTS_CHECK_CLIENT_FLAG(PlayerData[iSelfID], DARTS_CLIENTFLAG_SINGLE_PLAYER)
							// broadcast match info to all players
							broadcastIndex = NETWORK_GET_PLAYER_INDEX(INT_TO_PARTICIPANTINDEX(iSelfID))
							BROADCAST_DARTS_UPDATE(broadcastIndex, NETWORK_GET_PLAYER_INDEX(INT_TO_PARTICIPANTINDEX(iOtherID)), 
													ServerData.iScores[DART_PLAYER_AWAY_SERVER], ServerData.iScores[DART_PLAYER_HOME_SERVER], 
													GET_PLAYER_TEAM(broadcastIndex), TRUE)
						ENDIF
						
						ServerData.mpState = DARTS_MPSTATE_IN_PROGRESS
						CDEBUG1LN(DEBUG_DARTS, "[AM_DARTS]Server is proceeding to IN PROGRESS")
					ENDIF
				BREAK
				
				CASE DARTS_MPSTATE_IN_PROGRESS
					//DARTS_SERVER_UPDATE_RUN_CONDITIONS(ServerData, terminateReason, PlayerData)
					IF NOT DARTS_CHECK_CLIENT_FLAG(PlayerData[iSelfID], DARTS_CLIENTFLAG_SINGLE_PLAYER)
						IF (GET_GAME_TIMER() % 5000) < 50
							CDEBUG1LN(DEBUG_DARTS, "[AM_DARTS] ServerData.iServerTurn = ", ServerData.iServerTurn)
							CDEBUG1LN(DEBUG_DARTS, "[AM_DARTS] iServerTurn.bDoneScoring = ", MPDartGame.Darts[ServerData.iServerTurn].bDoneScoring)
						ENDIF
						
						DARTS_SERVER_UPDATE_GAME(ServerData, PlayerData, MPDartGame.Darts[ServerData.iServerTurn])
					ELSE
						DARTS_SERVER_UPDATE_SINGLE_PLAYER_GAME(ServerData, PlayerData, MPDartGame.Darts[ServerData.iServerTurn])
					ENDIF
				BREAK				
			ENDSWITCH		
		ENDIF		
	ENDWHILE
ENDSCRIPT