gtav-src/script/dev_ng/shared/include/public/camhedz_arcade_main.sch

USING "camhedz_arcade_drawing.sch"
USING "net_arcade_cabinet.sch"


/// PURPOSE:
///    Updates the values used for animating sprite sequences
PROC CMHDZ_UPDATE_ANIM_FRAMES()
	
	INT p, i
	FOR p = 0 TO ciCMHDZ_MAX_PLAYERS - 1
	
		//Blast Slow anim update
		FOR i = 0  TO ciCMHDZ_MAX_PROJECTILES - 1
			sCMHDZData.sPlayerData[p].sBulletData[i].iSlowFrameTimeCounter += ROUND(GET_FRAME_TIME() * 1000)
			sCMHDZData.sPlayerData[p].sBulletData[i].iSlowUpdateFrames = FLOOR(sCMHDZData.sPlayerData[p].sBulletData[i].iSlowFrameTimeCounter / cfCMHDZ_SLOW_ANIM_FRAME_TIME)
			sCMHDZData.sPlayerData[p].sBulletData[i].iSlowFrameTimeCounter -= ROUND(cfCMHDZ_SLOW_ANIM_FRAME_TIME * sCMHDZData.sPlayerData[p].sBulletData[i].iSlowUpdateFrames)
		ENDFOR
		
		FOR i = 0 TO ciCMHDZ_MAX_PLAYER_THROWN_PROJECTILES - 1
			sCMHDZData.sPlayerData[p].sThrownProjectile[i].iSlowFrameTimeCounter +=  ROUND(GET_FRAME_TIME() * 1000)
			sCMHDZData.sPlayerData[p].sThrownProjectile[i].iSlowUpdateFrames = FLOOR(sCMHDZData.sPlayerData[p].sThrownProjectile[i].iSlowFrameTimeCounter / cfCMHDZ_DEFAULT_ANIM_FRAME_TIME)
			sCMHDZData.sPlayerData[p].sThrownProjectile[i].iSlowFrameTimeCounter -= ROUND(cfCMHDZ_DEFAULT_ANIM_FRAME_TIME * sCMHDZData.sPlayerData[p].sThrownProjectile[i].iSlowUpdateFrames)
		ENDFOR
	ENDFOR
	
	// Enemies
	FOR i = 0 TO ciCMHDZ_MAX_ENEMIES  -1

		//Slow anim update
		sCMHDZData.sEnemyData[i].iSlowFrameTimeCounter += ROUND(GET_FRAME_TIME() * 1000)
		sCMHDZData.sEnemyData[i].iSlowUpdateFrames = FLOOR(sCMHDZData.sEnemyData[i].iSlowFrameTimeCounter / cfCMHDZ_SLOW_ANIM_FRAME_TIME)
		sCMHDZData.sEnemyData[i].iSlowFrameTimeCounter -= ROUND(cfCMHDZ_SLOW_ANIM_FRAME_TIME * sCMHDZData.sEnemyData[i].iSlowUpdateFrames)
		
		//Default anim update
		sCMHDZData.sEnemyData[i].iDefaultFrameTimeCounter += ROUND(GET_FRAME_TIME() * 1000)
		sCMHDZData.sEnemyData[i].iDefaultUpdateFrames = FLOOR(sCMHDZData.sEnemyData[i].iDefaultFrameTimeCounter / cfCMHDZ_DEFAULT_ANIM_FRAME_TIME)
		sCMHDZData.sEnemyData[i].iDefaultFrameTimeCounter -= ROUND(cfCMHDZ_DEFAULT_ANIM_FRAME_TIME * sCMHDZData.sEnemyData[i].iDefaultUpdateFrames)
		
	ENDFOR
	
//	FOR i = 0 TO ciCMHDZ_MAX_HOSTAGES  -1
//
//		//Slow anim update
//		sCMHDZData.sHostageData[i].iSlowFrameTimeCounter += ROUND(GET_FRAME_TIME() * 1000)
//		sCMHDZData.sHostageData[i].iSlowUpdateFrames = FLOOR(sCMHDZData.sHostageData[i].iSlowFrameTimeCounter / cfCMHDZ_SLOW_ANIM_FRAME_TIME)
//		sCMHDZData.sHostageData[i].iSlowFrameTimeCounter -= ROUND(cfCMHDZ_SLOW_ANIM_FRAME_TIME * sCMHDZData.sHostageData[i].iSlowUpdateFrames)
//		
//		//Default anim update
//		sCMHDZData.sHostageData[i].iDefaultFrameTimeCounter += ROUND(GET_FRAME_TIME() * 1000)
//		sCMHDZData.sHostageData[i].iDefaultUpdateFrames = FLOOR(sCMHDZData.sHostageData[i].iDefaultFrameTimeCounter / cfCMHDZ_DEFAULT_ANIM_FRAME_TIME)
//		sCMHDZData.sHostageData[i].iDefaultFrameTimeCounter -= ROUND(cfCMHDZ_DEFAULT_ANIM_FRAME_TIME * sCMHDZData.sHostageData[i].iDefaultUpdateFrames)
//		
//	ENDFOR
	
	FOR i = 0 TO ciCMHDZ_MAX_FX  -1

		//Slow anim update
		sCMHDZData.sFXData[i].iSlowFrameTimeCounter += ROUND(GET_FRAME_TIME() * 1000)
		sCMHDZData.sFXData[i].iSlowUpdateFrames = FLOOR(sCMHDZData.sFXData[i].iSlowFrameTimeCounter / cfCMHDZ_SLOW_ANIM_FRAME_TIME)
		sCMHDZData.sFXData[i].iSlowFrameTimeCounter -= ROUND(cfCMHDZ_SLOW_ANIM_FRAME_TIME * sCMHDZData.sFXData[i].iSlowUpdateFrames)

		// Medium
		sCMHDZData.sFXData[i].iMedFrameTimeCounter += ROUND(GET_FRAME_TIME() * 1000)
		sCMHDZData.sFXData[i].iMedUpdateFrames = FLOOR(sCMHDZData.sFXData[i].iMedFrameTimeCounter / cfCMHDZ_DEFAULT_ANIM_FRAME_TIME)
		sCMHDZData.sFXData[i].iMedFrameTimeCounter -= ROUND(cfCMHDZ_DEFAULT_ANIM_FRAME_TIME * sCMHDZData.sFXData[i].iMedUpdateFrames)

	ENDFOR
	
	FOR i = 0 TO ciCMHDZ_MAX_COVER - 1
		IF CMHDZ_COVER_DATA_IS_BITMASK_SET(i, CMHDZ_COVER_DATA_BITS_IS_ANIMATED)
		AND sCMHDZData.sCoverData[i].iHitCount > 0
			//Slow anim update
			sCMHDZData.sCoverData[i].iSlowFrameTimeCounter += ROUND(GET_FRAME_TIME() * 1000)
			sCMHDZData.sCoverData[i].iSlowUpdateFrames = FLOOR(sCMHDZData.sCoverData[i].iSlowFrameTimeCounter / cfCMHDZ_SLOW_ANIM_FRAME_TIME)
			sCMHDZData.sCoverData[i].iSlowFrameTimeCounter -= ROUND(cfCMHDZ_SLOW_ANIM_FRAME_TIME * sCMHDZData.sCoverData[i].iSlowUpdateFrames)
			
			//Default anim update
			sCMHDZData.sCoverData[i].iDefaultFrameTimeCounter += ROUND(GET_FRAME_TIME() * 1000)
			sCMHDZData.sCoverData[i].iDefaultUpdateFrames = FLOOR(sCMHDZData.sCoverData[i].iDefaultFrameTimeCounter / cfCMHDZ_DEFAULT_ANIM_FRAME_TIME)
			sCMHDZData.sCoverData[i].iDefaultFrameTimeCounter -= ROUND(cfCMHDZ_DEFAULT_ANIM_FRAME_TIME * sCMHDZData.sCoverData[i].iDefaultUpdateFrames)

		ENDIF
	ENDFOR
	
	FOR i = 0 TO ciCMHDZ_MAX_ENEMY_PROJECTILES - 1
		sCMHDZData.sEnemyProjectiles[i].iSlowFrameTimeCounter +=  ROUND(GET_FRAME_TIME() * 1000)
		sCMHDZData.sEnemyProjectiles[i].iSlowUpdateFrames = FLOOR(sCMHDZData.sEnemyProjectiles[i].iSlowFrameTimeCounter / cfCMHDZ_SLOW_ANIM_FRAME_TIME)
		sCMHDZData.sEnemyProjectiles[i].iSlowFrameTimeCounter -= ROUND(cfCMHDZ_SLOW_ANIM_FRAME_TIME * sCMHDZData.sEnemyProjectiles[i].iSlowUpdateFrames)
	ENDFOR
	
ENDPROC

PROC CMHDZ_TRIGGER_TITLE_MUSIC()
	IF NOT IS_BIT_SET(sCMHDZData.iMusicBitset,  ENUM_TO_INT(CMHDZ_MUSIC_BIT_STARTED_TITLE))
		CDEBUG2LN(DEBUG_MINIGAME, "[CMHDZ_TRIGGER_TITLE_MUSIC] Called.")
		//DEBUG_PRINTCALLSTACK()
		CMHDZ_TRIGGER_MUSIC_EVENT(CMHDZ_MUSIC_EVENT_TITLE)
		SET_BIT(sCMHDZData.iMusicBitset,  ENUM_TO_INT(CMHDZ_MUSIC_BIT_STARTED_TITLE))
	ENDIF
ENDPROC

PROC CMHDZ_SET_LOCAL_STATE(CMHDZ_ARCADE_CLIENT_STATE eNewState)
	//CDEBUG2LN(DEBUG_MINIGAME, " ")
	//CDEBUG2LN(DEBUG_MINIGAME, "[CMHDZ_ARCADE] [BAZ] {DSW} CMHDZ_SET_LOCAL_STATE - State changed from ", 
	//CMHDZ_ARCADE_CLIENT_STATE_TO_STRING(sCMHDZData.eClientState), " to ", CMHDZ_ARCADE_CLIENT_STATE_TO_STRING(eNewState))
	//DEBUG_PRINTCALLSTACK()
	sCMHDZData.eClientState = eNewState
	
//	IF eNewState = CMHDZ_ARCADE_CLIENT_STATE_LEVEL_SELECTION_MENU	// relaced by CMHDZ_AUDIO_EFFECT_PLAYER_START
//		CMHDZ_PLAY_SOUND_AND_RELEASE_NO_POSITION(CMHDZ_AUDIO_EFFECT_SELECT_STAGE)
//	ENDIF
ENDPROC


PROC CMHDZ_RESET_ALL_ENEMY_THROWN_PROJECTLES()
	INT i
	REPEAT ciCMHDZ_MAX_ENEMY_PROJECTILES i
		CMHDZ_RESET_ENEMY_THROWN_PROJECTILE(i)
	ENDREPEAT
	
	sCMHDZData.iNumberOfThrownEnemyProjectiles = 0
ENDPROC

PROC RESET_ENEMIES()
	INT i = 0
	FOR i = 0 TO ciCMHDZ_MAX_ENEMIES  -1
		CMHDZ_RESET_ENEMY(i)
		sCMHDZData.sEnemyData[i].iEnemyType = CMHDZ_ENEMY_INVALID
	ENDFOR
ENDPROC


PROC CMHDZ_RESET_ALL_COVER()
	INT i
	FOR i = 0 TO ciCMHDZ_MAX_COVER -1
		CMHDZ_RESET_COVER(i)
		sCMHDZData.sCoverData[i].eType = CMHDZ_ASSET_INVALID
	ENDFOR
	sCMHDZData.iNumberOfProps = 0
ENDPROC




PROC CMHDZ_CLEANUP_VARIABLES()
	
	sCMHDZData.sPlayerData[0].fHealth = 1.0
//	sCMHDZData.sPlayerData[0].iWeapon = 0
//	sCMHDZData.sPlayerData[0].iAmmo = ciCMHDZ_PLAYER_START_AMMO
	CMHDZ_RESET_ALL_PLAYER_THROWN_PROJECTILES(0)
	CMHDZ_INIT_PLAYER_WEAPON()
	
	sCMHDZData.sPlayerData[0].fHitCountdown = 0.0
	
	//sCMHDZData.iCurrentScreen = 1
	////sCMHDZData.fOverallLevelProgression = 0.0 // Trialing keeping this the same.
	
	sCMHDZData.iCurrentActiveEnemies[0] = 0
	sCMHDZData.iCurrentActiveEnemies[1] = 0
	sCMHDZData.iCurrentActiveEnemies[2] = 0
		
	sCMHDZData.bFadingOut = FALSE
	
	sCMHDZData.eLevelState = CMHDZ_FADING_IN
	
	CMHDZ_RESET_ALL_COVER()
	
	RESET_ENEMIES()
	CMHDZ_RESET_ITEMS()
	
	CMHDZ_RESET_ALL_ENEMY_THROWN_PROJECTLES()
	
	
	sCMHDZData.iNumberOfEnemies = 0
	sCMHDZData.iTotalNumberOfEnemies = 0
	sCMHDZData.iTotalNumberOfEnemiesSpawned = 0
	
	//CMHDZ_RESET_HOSTAGES()
	
	INT i
	FOR i = 0 TO ciCMHDZ_MAX_BACKGROUND_ELEMS - 1
		CMHDZ_BACKGROUND_DATA_SET_RENDERING(i, FALSE)
	ENDFOR
	sCMHDZData.iNumberOfBackgroundElements = 0
	
	CMHDZ_RESET_ITEMS()

	FOR i = 0 TO ciCMHDZ_MAX_FX - 1
		sCMHDZData.sFXData[i].bActive = FALSE
	ENDFOR
	
	// Reinit boss structure
	sCMHDZData.sBossData.rgbaColor = sCMHDZData.rgbaWhite
	CMHDZ_CHANGE_BOSS_STATE(CMHDZ_BOSS_STATE_INACTIVE)
	sCMHDZData.sBossData.iActiveLane = ciCMHDZ_LANE_FOREGROUND
	sCMHDZData.sBossData.bShotThisFrame = FALSE
	
	CLEAR_BITMASK_ENUM_AS_ENUM(sCMHDZData.sBossData.eDataBits, CMHDZ_BOSS_DATA_BITS_SPAWNED_ENEMIES_1)
	CLEAR_BITMASK_ENUM_AS_ENUM(sCMHDZData.sBossData.eDataBits, CMHDZ_BOSS_DATA_BITS_SPAWNED_ENEMIES_2)
	CLEAR_BITMASK_ENUM_AS_ENUM(sCMHDZData.sBossData.eDataBits, CMHDZ_BOSS_DATA_BITS_ANIM_FINISHED_ONCE)
	CLEAR_BITMASK_ENUM_AS_ENUM(sCMHDZData.sBossData.eDataBits, CMHDZ_BOSS_DATA_BITS_REVERSE)
	CLEAR_BITMASK_ENUM_AS_ENUM(sCMHDZData.sBossData.eDataBits, CMHDZ_BOSS_DATA_BITS_TAKING_DAMAGE)
	CLEAR_BITMASK_ENUM_AS_ENUM(sCMHDZData.sBossData.eDataBits, CMHDZ_BOSS_DATA_BITS_NONE)
	
	sCMHDZData.sBossData.fAnimTimer = 0.0
	sCMHDZData.sBossData.fHealth = cfBOSS_MaxHealth
			
	//sCMHDZData.vV_ScanMod = INIT_VECTOR_2D(1.0,1.0)
	
	CMHDZ_RESET_LOCAL_PLAYER_SCORE_FOR_CURRENT_LEVEL()
ENDPROC

FUNC BOOL CMHDZ_CHECK_FOR_MENU_PROGRESS_BUTTON(BOOL bAllowAccept = TRUE)
	BOOL bShouldReturn = FALSE
	
	//		bShouldReturn = IS_DISABLED_CONTROL_JUST_PRESSED(FRONTEND_CONTROL, INPUT_FRONTEND_CANCEL) 
//		
//		IF bAllowAccept 
//			bShouldReturn = (IS_DISABLED_CONTROL_JUST_PRESSED(FRONTEND_CONTROL, INPUT_FRONTEND_ACCEPT)
//			OR IS_DISABLED_CONTROL_JUST_PRESSED(FRONTEND_CONTROL, INPUT_ATTACK)
//			OR IS_DISABLED_CONTROL_JUST_PRESSED(FRONTEND_CONTROL, INPUT_SCRIPT_RT))
//		ENDIF	

		IF IS_USING_KEYBOARD_AND_MOUSE(PLAYER_CONTROL)
			bShouldReturn = IS_DISABLED_CONTROL_JUST_PRESSED(PLAYER_CONTROL, INPUT_FRONTEND_CANCEL)
#IF IS_DEBUG_BUILD
							OR IS_KEYBOARD_KEY_JUST_PRESSED(KEY_BACK) 
							OR IS_KEYBOARD_KEY_JUST_PRESSED(KEY_ESCAPE)
							OR IS_KEYBOARD_KEY_JUST_PRESSED(KEY_DELETE)
#ENDIF
							
			IF (bAllowAccept
			AND !bShouldReturn)
				bShouldReturn = (IS_DISABLED_CONTROL_JUST_PRESSED(PLAYER_CONTROL, INPUT_FRONTEND_ACCEPT)
							OR IS_DISABLED_CONTROL_JUST_PRESSED(PLAYER_CONTROL, INPUT_ATTACK)
							OR IS_DISABLED_CONTROL_JUST_PRESSED(FRONTEND_CONTROL, INPUT_SCRIPT_RT))
							
				CDEBUG2LN(DEBUG_MINIGAME, "[CMHDZ][BAZ] CMHDZ_CHECK_PLAYER_RETURNING_TO_MENU - bAllowAccept")
			ENDIF
							
		ELSE
			bShouldReturn = IS_DISABLED_CONTROL_JUST_PRESSED(FRONTEND_CONTROL, INPUT_FRONTEND_CANCEL)
				
			IF (bAllowAccept
			AND !bShouldReturn)
				bShouldReturn = (IS_DISABLED_CONTROL_JUST_PRESSED(PLAYER_CONTROL, INPUT_FRONTEND_ACCEPT)
							OR IS_DISABLED_CONTROL_JUST_PRESSED(PLAYER_CONTROL, INPUT_ATTACK)
							OR IS_DISABLED_CONTROL_JUST_PRESSED(FRONTEND_CONTROL, INPUT_SCRIPT_RT))
			ENDIF
		ENDIF
	
	
	RETURN bShouldReturn
ENDFUNC

PROC CMHDZ_CHECK_PLAYER_RETURNING_TO_MENU(BOOL bReturnToTitle = TRUE, BOOL bAllowAccept = FALSE, BOOL bIsLeaderboard = FALSE, BOOL bUseTimeOut = FALSE)
	BOOL bShouldReturn
	BOOL bTimeExpired
	IF bUseTimeOut
		IF sCMHDZData.iReturnToMenuTimeout = 0
			 sCMHDZData.iReturnToMenuTimeout = GET_GAME_TIMER()
		ENDIF
	ENDIF
	
	bTimeExpired = (bUseTimeOut AND (GET_GAME_TIMER() - sCMHDZData.iReturnToMenuTimeout > 10000))
	IF NOT bIsLeaderboard
//		bShouldReturn = IS_DISABLED_CONTROL_JUST_PRESSED(FRONTEND_CONTROL, INPUT_FRONTEND_CANCEL) 
//		
//		IF bAllowAccept 
//			bShouldReturn = (IS_DISABLED_CONTROL_JUST_PRESSED(FRONTEND_CONTROL, INPUT_FRONTEND_ACCEPT)
//			OR IS_DISABLED_CONTROL_JUST_PRESSED(FRONTEND_CONTROL, INPUT_ATTACK)
//			OR IS_DISABLED_CONTROL_JUST_PRESSED(FRONTEND_CONTROL, INPUT_SCRIPT_RT))
//		ENDIF	

		IF IS_USING_KEYBOARD_AND_MOUSE(PLAYER_CONTROL)
			bShouldReturn = IS_DISABLED_CONTROL_JUST_PRESSED(PLAYER_CONTROL, INPUT_FRONTEND_CANCEL)
#IF IS_DEBUG_BUILD
							OR IS_KEYBOARD_KEY_JUST_PRESSED(KEY_BACK) 
							OR IS_KEYBOARD_KEY_JUST_PRESSED(KEY_ESCAPE)
							OR IS_KEYBOARD_KEY_JUST_PRESSED(KEY_DELETE)
#ENDIF
							
			IF (bAllowAccept
			AND !bShouldReturn)
				bShouldReturn = (IS_DISABLED_CONTROL_JUST_PRESSED(PLAYER_CONTROL, INPUT_FRONTEND_ACCEPT)
							OR IS_DISABLED_CONTROL_JUST_PRESSED(PLAYER_CONTROL, INPUT_ATTACK)
							OR IS_DISABLED_CONTROL_JUST_PRESSED(FRONTEND_CONTROL, INPUT_SCRIPT_RT))
							
				CDEBUG2LN(DEBUG_MINIGAME, "[CMHDZ][BAZ] CMHDZ_CHECK_PLAYER_RETURNING_TO_MENU - bAllowAccept")
			ENDIF
							
		ELSE
			bShouldReturn = IS_DISABLED_CONTROL_JUST_PRESSED(FRONTEND_CONTROL, INPUT_FRONTEND_CANCEL)
				
			IF (bAllowAccept
			AND !bShouldReturn)
				bShouldReturn = (IS_DISABLED_CONTROL_JUST_PRESSED(PLAYER_CONTROL, INPUT_FRONTEND_ACCEPT)
							OR IS_DISABLED_CONTROL_JUST_PRESSED(PLAYER_CONTROL, INPUT_ATTACK)
							OR IS_DISABLED_CONTROL_JUST_PRESSED(FRONTEND_CONTROL, INPUT_SCRIPT_RT))
			ENDIF
		ENDIF
			
//#IF IS_DEBUG_BUILD
	ELSE
		IF IS_USING_KEYBOARD_AND_MOUSE(PLAYER_CONTROL)
			bShouldReturn = IS_DISABLED_CONTROL_JUST_PRESSED(PLAYER_CONTROL, INPUT_FRONTEND_CANCEL)
#IF IS_DEBUG_BUILD
							OR IS_KEYBOARD_KEY_JUST_PRESSED(KEY_BACK) 
							OR IS_KEYBOARD_KEY_JUST_PRESSED(KEY_ESCAPE)
							OR IS_KEYBOARD_KEY_JUST_PRESSED(KEY_DELETE)
#ENDIF
			IF (bAllowAccept
			AND !bShouldReturn)
				bShouldReturn = (IS_DISABLED_CONTROL_JUST_PRESSED(PLAYER_CONTROL, INPUT_FRONTEND_ACCEPT)
							OR IS_DISABLED_CONTROL_JUST_PRESSED(PLAYER_CONTROL, INPUT_ATTACK)
							OR IS_DISABLED_CONTROL_JUST_PRESSED(FRONTEND_CONTROL, INPUT_SCRIPT_RT))
			ENDIF
							
		ELSE
			
			bShouldReturn = IS_DISABLED_CONTROL_JUST_PRESSED(FRONTEND_CONTROL, INPUT_FRONTEND_CANCEL)
			
			IF (bAllowAccept
			AND !bShouldReturn)
				bShouldReturn = (IS_DISABLED_CONTROL_JUST_PRESSED(PLAYER_CONTROL, INPUT_FRONTEND_ACCEPT)
							OR IS_DISABLED_CONTROL_JUST_PRESSED(PLAYER_CONTROL, INPUT_ATTACK)
							OR IS_DISABLED_CONTROL_JUST_PRESSED(FRONTEND_CONTROL, INPUT_SCRIPT_RT))
			
			ENDIF

		ENDIF
//#ENDIF
	ENDIF
	
	IF bShouldReturn
	OR bTimeExpired
		#IF IS_DEBUG_BUILD
			IF bTimeExpired
				//CDEBUG2LN(DEBUG_MINIGAME, "[CMHDZ_CHECK_PLAYER_RETURNING_TO_MENU] {dsw} Time expired - bReturnToTitle: ", bReturnToTitle, " bAllowAccept: ", bAllowAccept, " bIsLeaderboard: ",bIsLeaderboard, " bUseTimeOut: ",bUseTimeOut)
				DEBUG_PRINTCALLSTACK()
			ENDIF
		#ENDIF
		

		CMHDZ_PLAY_SOUND_AND_RELEASE_NO_POSITION(CMHDZ_AUDIO_EFFECT_MENU_BACK)
		
		
		CMHDZ_CLEANUP_VARIABLES()
		
		// No penalty for chekcing each stage at this point.
		INT i
		REPEAT ENUM_TO_INT(CMHDZ_MAX_LEVELS) i
			CMHDZ_CANCEL_MUSIC_EVENT(CMHDZ_GET_MUSIC_EVENT_FOR_LEVEL(INT_TO_ENUM(CMHDZ_LEVELS, i)))
		ENDREPEAT
		
		CMHDZ_TRIGGER_TITLE_MUSIC()
		
		IF bReturnToTitle
			CMHDZ_SET_LOCAL_STATE(CMHDZ_ARCADE_CLIENT_STATE_TITLE_SCREEN)
			//CMHDZ_START_MOVIE_FORCE(sCMHDZData.bmIdCmhdzIntro, "CMHDZ_Intro_Static")
//			SET_BINK_MOVIE_TIME(sCMHDZData.bmIdCmhdzIntro, 99.0)
//			DRAW_BINK_MOVIE(sCMHDZData.bmIdCmhdzIntro, cfSCREEN_CENTER, cfSCREEN_CENTER, fRatioWidth, fRatioHeight, 0.0, 255,255,255,255)
			sCMHDZData.iReturnToMenuTimeout = 0
		ELSE
			CMHDZ_SET_LOCAL_STATE(CMHDZ_ARCADE_CLIENT_STATE_LEVEL_SELECTION_MENU)
			//sCMHDZData.fSyncOffsetY = 600 // Offset to correct
			sCMHDZData.iReturnToMenuTimeout = 0
		ENDIF
		
		
	ENDIF
	
ENDPROC



PROC CMHDZ_INIT_GOTO_LEADERBOARD()
	INT i
	FOR i = 0 TO ciCMHDZ_MAX_BACKGROUND_ELEMS - 1
		CMHDZ_BACKGROUND_DATA_SET_RENDERING(i, FALSE)
	ENDFOR
	
	// Grab a random frame.
	sCMHDZData.eCurrentLevel = INT_TO_ENUM(CMHDZ_LEVELS, GET_RANDOM_INT_IN_RANGE(0, 5))
	
	CMHDZ_RESET_ALL_COVER()
	
	sCMHDZData.iNumberOfBackgroundElements = 0
	
	#IF IS_DEBUG_BUILD
	//CDEBUG2LN(DEBUG_MINIGAME, "[CMHDZ_PROCESS_CLIENT_STATE_INIT_LEVEL] {DSW} Called. Level: ", CMHDZ_LEVELS_TO_STRING(CMHDZ_GET_CURRENT_LEVEL()))
	#ENDIF
	
	//-- Need to still draw the menu during this frame
	CMHDZ_DRAW_MENU_BACKGROUND()
	TWS_DRAW_FRONT_FX()
	//CMHDZ_DRAW_CLIENT_STATE_MENU()
		
	sCMHDZData.iCurrentScreen = FLOOR(sCMHDZData.fOverallLevelProgression/cfCMHDZ_SCREEN_LENGTH)
	TEXT_LABEL_31 tl31TextDict = CMHDZ_GET_TEXTURE_DICTIONARY_FOR_LEVEL(sCMHDZData.eCurrentLevel)
	REQUEST_STREAMED_TEXTURE_DICT(tl31TextDict)
	IF NOT HAS_STREAMED_TEXTURE_DICT_LOADED(tl31TextDict)
		//CDEBUG2LN(DEBUG_MINIGAME, "[CMHDZ_ARCADE] {dsw} CMHDZ_PROCESS_CLIENT_STATE_INIT_LEVEL - Loading ", tl31TextDict)
		EXIT
	ENDIF
		
	// Reset Counter Variables
	CMHDZ_CLEANUP_VARIABLES()
	CMHDZ_INIT_COVER_POINTS(sCMHDZData.eCurrentLevel)
	CMHDZ_INIT_PLAYERS()
	CMHDZ_INIT_BACKGROUND(sCMHDZData.eCurrentLevel)
	CMHDZ_INIT_ITEMS()
	CMHDZ_INIT_PLAY_VARIABLES()
	CMHDZ_INIT_BOSS_STRUCT()
	CMHDZ_INIT_SOUND()
	
	sCMHDZData.iLocalLevelRunningTime = GET_GAME_TIMER()
	sCMHDZData.iLevelBitset[ENUM_TO_INT(sCMHDZData.eCurrentLevel)] = 0
	i = 0 // reset
	REPEAT ciCMHDZ_MAX_LANES i
		sCMHDZData.iCurrentActiveEnemies[i] = 0
		sCMHDZData.iTimeSinceEnemyActive[i] = 0
	ENDREPEAT
	
	sCMHDZData.iResultsScreenTimer = 0
	sCMHDZData.iResultsScreenTimeout = 0
	sCMHDZData.iReturnToMenuTimeout = 0
	
	sCMHDZData.iTotalNumberOfEnemiesKilledForScreen = 0
	
	// New progression trackers#
	sCMHDZData.fOverallLevelProgression = 0.0
	sCMHDZData.iStaticScreenPhase = 0
	
	ARCADE_GAMES_HELP_TEXT_CLEAR()

	CMHDZ_INIT_BACKGROUND(CMHDZ_LEVEL_SCRAPYARD)
	CMHDZ_INIT_COVER_POINTS(CMHDZ_LEVEL_SCRAPYARD)
		
ENDPROC

PROC CMHDZ_ACTIVATE_ITEM(INT iIndex)
	#IF IS_DEBUG_BUILD
		//CDEBUG2LN(DEBUG_MINIGAME, "[CMHDZ_ACTIVATE_ITEM] {DSW} Called. Item: ", iIndex, " Type: ", CMHDZ_ITEM_TYPES_TO_STRING(sCMHDZData.sItemData[iIndex].eItemType), " Pos: ", sCMHDZData.sItemData[iIndex].vSpritePos.x, ", ", sCMHDZData.sItemData[iIndex].vSpritePos.y)
	#ENDIF
//	INT iInClip
//	INT iTotal
//	INT iRand
//	CMHDZ_PLAYER_WEAPON_DATA weaponData
	SWITCH sCMHDZData.sItemData[iIndex].eItemType
	
		CASE CMHDZ_ITEM_NAIL_GUN_AMMO
	//		sCMHDZData.sPlayerData[0].iWeapon = 1
		//	sCMHDZData.sPlayerData[0].iAmmo = 1000
			CMHDZ_SET_PLAYER_SPECIAL_WEAPON(CMHDZ_PLAYER_WEAPON_NAILGUN)
			CMHDZ_PLAY_SOUND_AND_RELEASE_NO_POSITION(CMHDZ_AUDIO_EFFECT_NAILGUN_RELOAD_SINGLE)
			CMHDZ_PLAY_SOUND_AND_RELEASE_NO_POSITION(CMHDZ_AUDIO_EFFECT_DIRECTOR_Weapon_Rnd)
			sCMHDZData.sItemData[iIndex].bRendering = FALSE
			sCMHDZData.sItemData[iIndex].iRenderAfterWarpCount = 0
		BREAK
		
		CASE CMHDZ_ITEM_RIFLE_AMMO
			CMHDZ_PLAY_SOUND_AND_RELEASE_NO_POSITION(CMHDZ_AUDIO_EFFECT_RIFLE_RELOAD_SINGLE)
			CMHDZ_SET_PLAYER_SPECIAL_WEAPON(CMHDZ_PLAYER_WEAPON_RIFLE)
			CMHDZ_PLAY_SOUND_AND_RELEASE_NO_POSITION(CMHDZ_AUDIO_EFFECT_DIRECTOR_Weapon_AR)
			sCMHDZData.sItemData[iIndex].bRendering = FALSE
			sCMHDZData.sItemData[iIndex].iRenderAfterWarpCount = 0
		BREAK
		
		CASE CMHDZ_ITEM_SHOTGUN_AMMO
			CMHDZ_PLAY_SOUND_AND_RELEASE_NO_POSITION(CMHDZ_AUDIO_EFFECT_SHOTGUN_RELOAD_SINGLE)
			CMHDZ_SET_PLAYER_SPECIAL_WEAPON(CMHDZ_PLAYER_WEAPON_SHOTGUN)
			CMHDZ_PLAY_SOUND_AND_RELEASE_NO_POSITION(CMHDZ_AUDIO_EFFECT_DIRECTOR_Weapon_SG)
			sCMHDZData.sItemData[iIndex].bRendering = FALSE
			sCMHDZData.sItemData[iIndex].iRenderAfterWarpCount = 0
		BREAK
				
		CASE CMHDZ_ITEM_HEALTH
			CMHDZ_PLAY_SOUND_AND_RELEASE_NO_POSITION(CMHDZ_AUDIO_EFFECT_PICKUP_HEALTH)
			CMHDZ_PLAY_DIRECTOR_DIALOGUE(CMHDZ_AUDIO_EFFECT_DIRECTOR_Collectable_Health)
			sCMHDZData.sPlayerData[0].fHealth = CLAMP(sCMHDZData.sPlayerData[0].fHealth + 0.5, 0.0, 1.0)
			sCMHDZData.sItemData[iIndex].bRendering = FALSE
			sCMHDZData.sItemData[iIndex].iRenderAfterWarpCount = 0
		BREAK
			
		CASE CMHDZ_ITEM_SHIELD
			//CMHDZ_PLAY_SOUND_NO_POSITION(CMHDZ_AUDIO_EFFECT_PICKUP_SHIELD)
			CMHDZ_PLAY_DIRECTOR_DIALOGUE(CMHDZ_AUDIO_EFFECT_DIRECTOR_Collectable_Invulnerable)
			CMHDZ_SET_PLAYER_BIT(CMHDZ_PLAYER_BIT_INVULNERABILE)

			sCMHDZData.sPlayerData[0].iInvulnerableTimer = GET_GAME_TIMER()
			sCMHDZData.sItemData[iIndex].bRendering = FALSE
			sCMHDZData.sItemData[iIndex].iRenderAfterWarpCount = 0
			
			sCMHDZData.fPowerRunTimer = 0.0
			
			//CMHDZ_START_AUDIO_SCENE(CMHDZ_AUDIO_SCENE_POWERUP_ACTIVE)
		BREAK
		
		CASE CMHDZ_ITEM_BUFF
			//CMHDZ_PLAY_SOUND_NO_POSITION(CMHDZ_AUDIO_EFFECT_PICKUP_BUFF)
			CMHDZ_SET_PLAYER_BIT(CMHDZ_PLAYER_BIT_QUAD_DAMAGE)
			//CMHDZ_START_AUDIO_SCENE(CMHDZ_AUDIO_SCENE_POWERUP_ACTIVE)
			CMHDZ_PLAY_DIRECTOR_DIALOGUE(CMHDZ_AUDIO_EFFECT_DIRECTOR_Collectable_Damage)
			sCMHDZData.fPowerRunTimer = 0.0
			sCMHDZData.sPlayerData[0].iQuadDamageTimer = GET_GAME_TIMER()		
			sCMHDZData.sItemData[iIndex].bRendering = FALSE
			sCMHDZData.sItemData[iIndex].iRenderAfterWarpCount = 0
		BREAK
			
		CASE CMHDZ_ITEM_CASH
			CMHDZ_PLAY_SOUND_AND_RELEASE_NO_POSITION(CMHDZ_AUDIO_EFFECT_PICKUP_CASH)
			CMHDZ_PLAY_DIRECTOR_DIALOGUE(CMHDZ_AUDIO_EFFECT_DIRECTOR_Collectable_Cash)
			CMHDZ_ADD_TO_LOCAL_PLAYER_SCORE(CMHDZ_SCORE_TYPE_CASH)
			sCMHDZData.sItemData[iIndex].bRendering = FALSE
			sCMHDZData.sItemData[iIndex].iRenderAfterWarpCount = 0
		BREAK		
		
		CASE CMHDZ_ITEM_MOLOTOV
			sCMHDZData.sPlayerData[0].projectileType = CMHDZ_PROJECTILE_MOLOTOV
			sCMHDZData.sPlayerData[0].iThrownProjectilesAmmo = ciCMHDZ_ITEM_MOLOTOV_AMMO_COUNT
			CMHDZ_PLAY_SOUND_AND_RELEASE_NO_POSITION(CMHDZ_AUDIO_EFFECT_DIRECTOR_Weapon_MV)
			sCMHDZData.sItemData[iIndex].bRendering = FALSE
			sCMHDZData.sItemData[iIndex].iRenderAfterWarpCount = 0
		BREAK 
		
		CASE CMHDZ_ITEM_BRICK
			sCMHDZData.sPlayerData[0].projectileType = CMHDZ_PROJECTILE_BRICK
			sCMHDZData.sPlayerData[0].iThrownProjectilesAmmo = ciCMHDZ_ITEM_BRICK_AMMO_COUNT
			sCMHDZData.sItemData[iIndex].bRendering = FALSE
			sCMHDZData.sItemData[iIndex].iRenderAfterWarpCount = 0
		BREAK 
		
		CASE CMHDZ_ITEM_NAILBOMB
			sCMHDZData.sPlayerData[0].projectileType = CMHDZ_PROJECTILE_NAILBOMB
			sCMHDZData.sPlayerData[0].iThrownProjectilesAmmo = ciCMHDZ_ITEM_NAILBOMB_AMMO_COUNT
			CMHDZ_PLAY_SOUND_AND_RELEASE_NO_POSITION(CMHDZ_AUDIO_EFFECT_DIRECTOR_Weapon_NB)
			sCMHDZData.sItemData[iIndex].bRendering = FALSE
			sCMHDZData.sItemData[iIndex].iRenderAfterWarpCount = 0
		BREAK 

		CASE CMHDZ_ITEM_DYNAMITE
			sCMHDZData.sPlayerData[0].projectileType = CMHDZ_PROJECTILE_DYNAMITE
			sCMHDZData.sPlayerData[0].iThrownProjectilesAmmo = ciCMHDZ_ITEM_DYNAMITE_AMMO_COUNT
			sCMHDZData.sItemData[iIndex].bRendering = FALSE
			sCMHDZData.sItemData[iIndex].iRenderAfterWarpCount = 0
		BREAK 
		
		CASE CMHDZ_ITEM_VIDEOTAPE
			CMHDZ_PLAY_SOUND_AND_RELEASE_NO_POSITION(CMHDZ_AUDIO_EFFECT_PICKUP_TAPE)
			CMHDZ_PLAY_DIRECTOR_DIALOGUE(CMHDZ_AUDIO_EFFECT_DIRECTOR_Collectable_Tape)
			CMHDZ_ADD_TO_LOCAL_PLAYER_SCORE(CMHDZ_SCORE_TYPE_TAPE)
			sCMHDZData.sItemData[iIndex].bRendering = FALSE
			sCMHDZData.sItemData[iIndex].iRenderAfterWarpCount = 0
		BREAK
	ENDSWITCH
	
	// Activate item
	SWITCH sCMHDZData.sItemData[iIndex].eItemType
		CASE CMHDZ_ITEM_BUFF
		CASE CMHDZ_ITEM_SHIELD
			sAGPostFXData.sFXLayers[ARCADE_GAMES_POSTFX_LAYER_SCAN_LINE].bShow = TRUE
			sAGPostFXData.sFXLayers[ARCADE_GAMES_POSTFX_LAYER_FLICKERING].bShow = TRUE
			INIT_RGBA_STRUCT(sAGPostFXData.sFXLayers[ARCADE_GAMES_POSTFX_LAYER_SCAN_LINE].rgbaColor,255,255,255,20)
		BREAK
	ENDSWITCH
	
	//CMHDZ_PLAY_SOUND_AND_RELEASE_NO_POSITION(CMHDZ_AUDIO_EFFECT_MUSIC_TRANSITION)
	CMHDZ_INCREASE_POWERUPS_COLLECTED_FOR_CURRENT_LEVEL()
ENDPROC

FUNC BOOL CMHDZ_CHECK_FOR_HEADSHOT(VECTOR_2D vSpriteTL, VECTOR_2D vBullet, INT iLane)
	//CDEBUG2LN(DEBUG_MINIGAME, "[CMHDZ_ARCADE] {DSW} [CMHDZ_CHECK_FOR_HEADSHOT] ")
	//CDEBUG2LN(DEBUG_MINIGAME, "[CMHDZ_ARCADE] {DSW} [CMHDZ_CHECK_FOR_HEADSHOT] Lane: ", iLane)
//	IF sCMHDZData.sPlayerData[0].weaponType != CMHDZ_PLAYER_WEAPON_TYPE_SPECIAL
//		RETURN FALSE
//	ENDIF
//		
//	IF CMHDZ_GET_PLAYER_CURRENT_WEAPON() = CMHDZ_PLAYER_WEAPON_NAILGUN
//		RETURN FALSE
//	ENDIF
		
	FLOAT fAbsfDist = ABSF(vBullet.Y - vSpriteTL.y)
	FLOAT fYMin, fYMax
	
	SWITCH iLane
		CASE ciCMHDZ_LANE_BACKGROUND // Back of screen
			fYMin = cfCMHDZ_HEADSHOT_BACKGROUND_MIN_Y
			fYMax = cfCMHDZ_HEADSHOT_BACKGROUND_MAX_Y
		BREAK
		
		CASE ciCMHDZ_LANE_MIDDLE // Middle of screen
			fYMin = cfCMHDZ_HEADSHOT_MIDGROUND_MIN_Y
			fYMax = cfCMHDZ_HEADSHOT_MIDGROUND_MAX_Y
		BREAK
		
		CASE ciCMHDZ_LANE_FOREGROUND // Front of screen
			fYMin = cfCMHDZ_HEADSHOT_FOREGROUND_MIN_Y
			fYMax = cfCMHDZ_HEADSHOT_FOREGROUND_MAX_Y
		BREAK
	ENDSWITCH
	
	
	fAbsfDist = ABSF(vBullet.Y - vSpriteTL.y)
	IF fAbsfDist >= fYMin 
	AND fAbsfDist <= fYMax
		//CDEBUG2LN(DEBUG_MINIGAME, "[CMHDZ_ARCADE] {DSW} [CMHDZ_CHECK_FOR_HEADSHOT] HEADSHOT!")
		RETURN TRUE
	ENDIF
	
	//CDEBUG2LN(DEBUG_MINIGAME, "[CMHDZ_ARCADE] {DSW} [CMHDZ_CHECK_FOR_HEADSHOT] No Headshot - Diff: ", fAbsfDist, " Min: ", fYMin, " Max : ", fYMax)
	
	
	RETURN FALSE
ENDFUNC

PROC CMHDZ_PLAY_AUDIO_FOR_SHOT_COVER(INT iCover)
	CMHDZ_ASSET_TYPES eType = sCMHDZData.sCoverData[iCover].eType
	VECTOR_2D vPos = sCMHDZData.sCoverData[iCover].vSpritePos
	
	
	#IF IS_DEBUG_BUILD
		//CPRINTLN(DEBUG_MINIGAME, "[CMHDZ_PLAY_AUDIO_FOR_SHOT_COVER] [CMHDZ_HANDLE_PLAYER_BULLET_COLLISION_WITH_COVER] {dsw} Cover ", iCover, " Type: ", CMHDZ_ASSET_TYPES_TO_STRING(sCMHDZData.sCoverData[iCover].eType))
	#ENDIF
	
	SWITCH eType
		
		CASE CMHDZ_ASSET_GRASS
		CASE CMHDZ_ASSET_BUSH_1
		CASE CMHDZ_ASSET_BUSH_2
			CMHDZ_PLAY_SOUND_AND_RELEASE(CMHDZ_AUDIO_EFFECT_BULLET_HIT_BUSHES, vPos)
		BREAK
		
		CASE CMHDZ_ASSET_MEATGRINDER_1
		CASE CMHDZ_ASSET_SCRAPYARD_MD_VAN_1
		CASE CMHDZ_ASSET_SCRAPYARD_MD_VAN_2
		CASE CMHDZ_ASSET_SCRAPYARD_MD_VAN_3
		CASE CMHDZ_ASSET_SCRAPYARD_MD_VAN_4
		CASE CMHDZ_ASSET_SCRAPYARD_MD_CAR_1
		CASE CMHDZ_ASSET_SCRAPYARD_MD_CAR_2
		CASE CMHDZ_ASSET_SCRAPYARD_MD_CAR_3
		CASE CMHDZ_ASSET_SCRAPYARD_MD_CAR_4
			CMHDZ_PLAY_SOUND_AND_RELEASE(CMHDZ_AUDIO_EFFECT_BULLET_HIT_METAL, vPos)
		BREAK
		
		CASE CMHDZ_ASSET_ROCK_SMALL
		CASE CMHDZ_ASSET_ROCK_LARGE
			CMHDZ_PLAY_SOUND_AND_RELEASE(CMHDZ_AUDIO_EFFECT_BULLET_HIT_ROCK, vPos)
		BREAK
		
		CASE CMHDZ_ASSET_BODYBAG_1
		CASE CMHDZ_ASSET_BODYBAG_2
		CASE CMHDZ_ASSET_BODYBAG_3
		CASE CMHDZ_ASSET_BODYBAG_FLOOR_1
		CASE CMHDZ_ASSET_BODYBAG_FLOOR_2
		CASE CMHDZ_ASSET_BODYBAG_FLOOR_3
		CASE CMHDZ_ASSET_BODYBAG_FLOOR_4		
		CASE CMHDZ_ASSET_PIG
			CMHDZ_PLAY_SOUND_AND_RELEASE(CMHDZ_AUDIO_EFFECT_BULLET_HIT_BODY, vPos)
		BREAK
		
		DEFAULT
			CMHDZ_PLAY_SOUND_AND_RELEASE(CMHDZ_AUDIO_EFFECT_BULLET_HIT_GENERIC, vPos)
		BREAK
	ENDSWITCH
ENDPROC

FUNC INT CMHDZ_GET_NUMBER_OF_PICKUPS_PLACED_INSIDE_PIGS_FOR_CURRENT_SCREEN()
	INT i
	INT iCount
	FOR i = 0 TO ciCMHDZ_MAX_COVER - 1
		IF sCMHDZData.sCoverData[i].eType = CMHDZ_ASSET_PIG
			IF CMHDZ_IS_POSITION_ON_SCREEN(sCMHDZData.sCoverData[i].vSpritePos)
				IF CMHDZ_COVER_DATA_IS_BITMASK_SET(i, CMHDZ_COVER_DATA_BITS_SPAWNED_PICKUP)
					iCount++
				ENDIF
			ENDIF
		ENDIF
	ENDFOR
	
	RETURN iCount
ENDFUNC
PROC CMHDZ_HANDLE_PLAYER_BULLET_COLLISION_WITH_COVER(	INT iCover, INT iPlayer, INT iProjectile, BOOL &bProcessedThisFrame  )
	IF bProcessedThisFrame 
		EXIT
	ENDIF
	
	IF sCMHDZData.sCoverData[iCover].iCoverLane = ciCMHDZ_LANE_FOREGROUND
		EXIT
	ENDIF
	
	INT iRandom
	INT iPlaced
	VECTOR_2D vPickupLoc
	sCMHDZData.sPlayerData[iPlayer].sBulletData[iProjectile].bHitObject = TRUE
	sCMHDZData.sPlayerData[iPlayer].sBulletData[iProjectile].iTimeOfHit = GET_GAME_TIMER()
	sCMHDZData.sCoverData[iCover].iHitCount++

	#IF IS_DEBUG_BUILD
		//CDEBUG2LN(DEBUG_MINIGAME, "[HANDLE_PLAYER_BULLET_COLLISION] [CMHDZ_HANDLE_PLAYER_BULLET_COLLISION_WITH_COVER] {dsw} Cover ", iCover, " Shot. Hit count: ", sCMHDZData.sCoverData[iCover].iHitCount, " Lane: ", sCMHDZData.sCoverData[iCover].iCoverLane, " Type: ", CMHDZ_ASSET_TYPES_TO_STRING(sCMHDZData.sCoverData[iCover].eType), " Special? ", CMHDZ_COVER_DATA_IS_BITMASK_SET(iCover, CMHDZ_COVER_DATA_BITS_IS_SPECIAL_COVER))
	#ENDIF
	
	IF CMHDZ_COVER_DATA_IS_BITMASK_SET(iCover, CMHDZ_COVER_DATA_BITS_IS_SPECIAL_COVER)
		CMHDZ_PLAY_SOUND_AND_RELEASE(CMHDZ_AUDIO_EFFECT_EXP_GENERIC, sCMHDZData.sCoverData[iCover].vSpritePos)
		
		TWS_CREATE_FX(sCMHDZData.sCoverData[iCover].vSpritePos, CMHDZ_FX_EXPLOSION, sCMHDZData.sCoverData[iCover].iCoverLane)
		
		//-- When we explode a TNT barrel, replace it with another at same spot, but don't render until after it's warped around again
		IF sCMHDZData.sCoverData[iCover].eType = CMHDZ_ASSET_SPECIAL_TNT_BARREL_1
//		OR sCMHDZData.sCoverData[iCover].eType = CMHDZ_ASSET_SPECIAL_TNT_CRATE
			CMHDZ_ADD_COVER_TO_LIST(sCMHDZData.sCoverData[iCover].vSpritePos, CMHDZ_ASSET_SPECIAL_TNT_BARREL_1, sCMHDZData.sCoverData[iCover].iCoverLane, DEFAULT)
		ENDIF
		
		CMHDZ_KILL_ALL_ENEMIES_IN_RANGE(sCMHDZData.sCoverData[iCover].vSpritePos, 400)
		CMHDZ_ADD_TO_LOCAL_PLAYER_SCORE(CMHDZ_SCORE_TYPE_SCENERY)
		
	ELIF CMHDZ_COVER_DATA_IS_BITMASK_SET(iCover, CMHDZ_COVER_DATA_BITS_IS_ANIMATED)
		

		IF sCMHDZData.sCoverData[iCover].eType = CMHDZ_ASSET_PIG
			IF NOT CMHDZ_COVER_DATA_IS_BITMASK_SET(iCover, CMHDZ_COVER_DATA_BITS_SPAWNED_PICKUP)
				IF sCMHDZData.sCoverData[iCover].iHitCount > 0
				//	sCMHDZData.sCoverData[iCover].bSpawnedPickup = TRUE
					vPickupLoc = sCMHDZData.sCoverData[iCover].vSpritePos
//					vPickupLoc.x += cfCMHDZ_PICKUP_COFFIN_OFFSET_X
//					vPickupLoc.y += cfCMHDZ_PICKUP_COFFIN_OFFSET_Y
					vPickupLoc.x -= 12.0
					vPickupLoc.y += 36.0

					
					// N.B Pickups in foreground lane (i.e. those in coffins / outhouses) wil not warp, and will vanish when off screne
					
					iRandom = GET_RANDOM_INT_IN_RANGE(0, 6)
					
					//-- If we're stopping on screen 8 in the Slaughterhouse level, want to force either a NAILGUN gun pickup or a health
					//-- pickup
					IF CMHDZ_GET_CURRENT_LEVEL() = CMHDZ_LEVEL_SLAUGHTERHOUSE
						IF CMHDZ_IS_LEVEL_STOPPED()
						OR CMHDZ_IS_MOVING_LEVEL_ABOUT_TO_STOP()
							iPlaced = CMHDZ_GET_NUMBER_OF_PICKUPS_PLACED_INSIDE_PIGS_FOR_CURRENT_SCREEN()
							IF iPlaced = 0
								//CDEBUG2LN(DEBUG_MINIGAME, "[HANDLE_PLAYER_BULLET_COLLISION] [CMHDZ_HANDLE_PLAYER_BULLET_COLLISION_WITH_COVER] Graveyard level - stopped - haven't placed any pickups inside coffin forcing NAILGUN gun")
								iRandom = 8
							ELIF iPlaced = 1
								//CDEBUG2LN(DEBUG_MINIGAME, "[HANDLE_PLAYER_BULLET_COLLISION] [CMHDZ_HANDLE_PLAYER_BULLET_COLLISION_WITH_COVER] Graveyard level - stopped - placed 1 pickupinside coffin forcing health")
								iRandom = 5
							ELSE
								//CDEBUG2LN(DEBUG_MINIGAME, "[HANDLE_PLAYER_BULLET_COLLISION] [CMHDZ_HANDLE_PLAYER_BULLET_COLLISION_WITH_COVER]  Placed too many inside coffin - iPlaced: ", iPlaced) 
							ENDIF
						ENDIF
					ENDIF
					
					SWITCH iRandom
						CASE 0		CMHDZ_ADD_ITEM_TO_LIST(vPickupLoc, CMHDZ_ITEM_RIFLE_AMMO, 	ciCMHDZ_LANE_FOREGROUND, DEFAULT, 0.75)	BREAK
						CASE 1		CMHDZ_ADD_ITEM_TO_LIST(vPickupLoc, CMHDZ_ITEM_SHOTGUN_AMMO, 	ciCMHDZ_LANE_FOREGROUND, DEFAULT, 0.75)	BREAK
						CASE 2		CMHDZ_ADD_ITEM_TO_LIST(vPickupLoc, CMHDZ_ITEM_HEALTH, 		ciCMHDZ_LANE_FOREGROUND, DEFAULT, 0.75)	BREAK
						CASE 3		CMHDZ_ADD_ITEM_TO_LIST(vPickupLoc, CMHDZ_ITEM_BUFF, 		ciCMHDZ_LANE_FOREGROUND, DEFAULT, 0.75)	BREAK
						CASE 4		CMHDZ_ADD_ITEM_TO_LIST(vPickupLoc, CMHDZ_ITEM_SHIELD, 	ciCMHDZ_LANE_FOREGROUND, DEFAULT, 0.75)	BREAK
						CASE 5		CMHDZ_ADD_ITEM_TO_LIST(vPickupLoc, CMHDZ_ITEM_NAIL_GUN_AMMO, 	ciCMHDZ_LANE_FOREGROUND, DEFAULT, 0.75)	BREAK
						//CASE 2		CMHDZ_ADD_ITEM_TO_LIST(vPickupLoc, CMHDZ_ITEM_REVOLVER_AMMO, ciCMHDZ_LANE_FOREGROUND, DEFAULT, 0.75)	BREAK
						//CASE 6		CMHDZ_ADD_ITEM_TO_LIST(vPickupLoc, CMHDZ_ITEM_CASH, 	ciCMHDZ_LANE_FOREGROUND, DEFAULT, 0.75)	BREAK
						//CASE 6		CMHDZ_ADD_ITEM_TO_LIST(vPickupLoc, CMHDZ_ITEM_MOLOTOV, 	ciCMHDZ_LANE_FOREGROUND, DEFAULT, 0.75)	BREAK
						//CASE 7		CMHDZ_ADD_ITEM_TO_LIST(vPickupLoc, CMHDZ_ITEM_NAILBOMB, 	ciCMHDZ_LANE_FOREGROUND, DEFAULT, 0.75)	BREAK
					ENDSWITCH
					
					// Director dialogue
					CMHDZ_HANDLE_DIRECTOR_ONE_OFF_DIALOGUE(CMHDZ_AUDIO_EFFECT_DIRECTOR_Props_Destroyed)
					//CDEBUG2LN(DEBUG_MINIGAME, "[HANDLE_PLAYER_BULLET_COLLISION] [CMHDZ_HANDLE_PLAYER_BULLET_COLLISION_WITH_COVER] Spawned ammo inside outhouse ", iCover)
					CMHDZ_COVER_DATA_SET_BIT_BY_BOOL(iCover, CMHDZ_COVER_DATA_BITS_SPAWNED_PICKUP)
				ENDIF
			ENDIF
		ENDIF
	
	ENDIF
	
	CMHDZ_PLAY_AUDIO_FOR_SHOT_COVER(iCover)
	
	bProcessedThisFrame = TRUE
ENDPROC

FUNC INT CMHDZ_GET_AMOUNT_ENEMY_HAS_BEEN_DAMAGED(INT iEnemy, BOOL bHeadshot)
	#IF IS_DEBUG_BUILD
		//CPRINTLN(DEBUG_MINIGAME, "[HANDLE_PLAYER_BULLET_COLLISION] [CMHDZ_GET_AMOUNT_ENEMY_HAS_BEEN_DAMAGED] {dsw} ")
		//CPRINTLN(DEBUG_MINIGAME, "[HANDLE_PLAYER_BULLET_COLLISION] [CMHDZ_GET_AMOUNT_ENEMY_HAS_BEEN_DAMAGED] {dsw} Enemy ", iEnemy, " Shot at least once. Lane: ", sCMHDZData.sEnemyData[iEnemy].iEnemyLane, " Type: ", CMHDZ_ENEMY_TYPES_TO_STRING(sCMHDZData.sEnemyData[iEnemy].iEnemyType), " Headshot? ", bHeadshot)
	#ENDIF
		
	INT iBaseDamage
	INT iRand
	IF bHeadshot
		//CPRINTLN(DEBUG_MINIGAME, "[HANDLE_PLAYER_BULLET_COLLISION] [CMHDZ_GET_AMOUNT_ENEMY_HAS_BEEN_DAMAGED] {dsw} was headshot. Damage: ", CMHDZ_GET_ENEMY_START_HEALTH_FOR_TYPE())
		RETURN CMHDZ_GET_ENEMY_START_HEALTH_FOR_TYPE()
	ENDIF
	
	IF sCMHDZData.sEnemyData[iEnemy].iEnemyLane = ciCMHDZ_LANE_FOREGROUND
		//CPRINTLN(DEBUG_MINIGAME, "[HANDLE_PLAYER_BULLET_COLLISION] [CMHDZ_GET_AMOUNT_ENEMY_HAS_BEEN_DAMAGED] {dsw} Foreground enemy. Damage: ", CMHDZ_GET_ENEMY_START_HEALTH_FOR_TYPE())
		RETURN CMHDZ_GET_ENEMY_START_HEALTH_FOR_TYPE()
	ENDIF
	
	CMHDZ_PLAYER_WEAPON weapon = CMHDZ_GET_PLAYER_CURRENT_WEAPON()
	CMHDZ_PLAYER_WEAPON_DATA data = CMHDZ_GET_PLAYER_WEAPON_DATA(weapon)
	iBaseDamage = data.iMinDamagePerShot
	
	IF CMHDZ_IS_PLAYER_BIT_SET(CMHDZ_PLAYER_BIT_QUAD_DAMAGE)
		iBaseDamage *= 4
	ENDIF
	
	IF sCMHDZData.sPlayerData[0].weaponType = CMHDZ_PLAYER_WEAPON_TYPE_DEFAULT
		iRand = GET_RANDOM_INT_IN_RANGE(0, 4)
		iBaseDamage += iRand
		//CPRINTLN(DEBUG_MINIGAME, "[HANDLE_PLAYER_BULLET_COLLISION] [CMHDZ_GET_AMOUNT_ENEMY_HAS_BEEN_DAMAGED] {dsw} Player has pistol. Damage: ", iBaseDamage)
		RETURN iBaseDamage
	ENDIF
	
	#IF IS_DEBUG_BUILD
		//CPRINTLN(DEBUG_MINIGAME, "[HANDLE_PLAYER_BULLET_COLLISION] [CMHDZ_GET_AMOUNT_ENEMY_HAS_BEEN_DAMAGED] {dsw} Player has weapon: ", CMHDZ_PLAYER_WEAPON_TO_STRING(weapon), " Returning: ", data.iMinDamagePerShot)
	#ENDIF
	
	RETURN data.iMinDamagePerShot
ENDFUNC

PROC CMHDZ_HANDLE_PLAYER_BULLET_COLLISION_WITH_ENEMY(INT iEnemy, INT iPlayer, INT iProjectile, VECTOR_2D vSpriteTopLeft, VECTOR_2D vBulletPos )

	// Don't count it if they're already dying.
	IF sCMHDZData.sEnemyData[iEnemy].eState = CMHDZ_ENEMY_STATE_DYING
	OR sCMHDZData.sEnemyData[iEnemy].eState = CMHDZ_ENEMY_STATE_DYING_HEADSHOT
	OR sCMHDZData.sEnemyData[iEnemy].eState = CMHDZ_ENEMY_STATE_DYING_BURNING
		EXIT
	ENDIF

	// Don't process if it's the RAT.
	IF sCMHDZData.sEnemyData[iEnemy].iEnemyType = CMHDZ_RARE_ENEMY_RAT
		EXIT
	ENDIF

	BOOL bHeadshot
	
	IF NOT CMHDZ_ENEMY_DATA_IS_BITMASK_SET(iEnemy, CMHDZ_ENEMY_DATA_BITS_SHOT_AT_LEAST_ONCE)
		CMHDZ_ENEMY_DATA_SET_BIT_BY_BOOL(iEnemy, CMHDZ_ENEMY_DATA_BITS_SHOT_AT_LEAST_ONCE, TRUE)
		#IF IS_DEBUG_BUILD
			//CDEBUG2LN(DEBUG_MINIGAME, "[HANDLE_PLAYER_BULLET_COLLISION] [CMHDZ_HANDLE_PLAYER_BULLET_COLLISION_WITH_ENEMY] {dsw} Enemy ", iEnemy, " Shot at least once. Lane: ", sCMHDZData.sEnemyData[iEnemy].iEnemyLane, " Type: ", CMHDZ_ENEMY_TYPES_TO_STRING(sCMHDZData.sEnemyData[iEnemy].iEnemyType))
		#ENDIF
	ENDIF
		

	bHeadshot = CMHDZ_CHECK_FOR_HEADSHOT( vSpriteTopLeft, vBulletPos, sCMHDZData.sEnemyData[iEnemy].iEnemyLane )
	sCMHDZData.sEnemyData[iEnemy].iHealth -= CMHDZ_GET_AMOUNT_ENEMY_HAS_BEEN_DAMAGED(iEnemy, bHeadshot)
	IF sCMHDZData.sEnemyData[iEnemy].iHealth > 0
		IF !bHeadshot
			CMHDZ_PLAY_SOUND_AND_RELEASE(CMHDZ_AUDIO_EFFECT_BULLET_HIT_BODY, sCMHDZData.sEnemyData[iEnemy].vSpritePos)
		ELSE
			CMHDZ_PLAY_SOUND_AND_RELEASE(CMHDZ_AUDIO_EFFECT_BULLET_HIT_HEADSHOT, sCMHDZData.sEnemyData[iEnemy].vSpritePos)
		ENDIF
		
		IF NOT CMHDZ_ENEMY_DATA_IS_BITMASK_SET(iEnemy, CMHDZ_ENEMY_DATA_BITS_IS_BONUS)
			CMHDZ_PLAY_ENEMY_TYPE_SOUND_AND_RELEASE(sCMHDZData.sEnemyData[iEnemy].iEnemyType, CMHDZ_AUDIO_EFFECT_ENEMY_INJURED, sCMHDZData.sEnemyData[iEnemy].vSpritePos, sCMHDZData.sEnemyData[iEnemy].iEnemyVoiceID)
		ELSE
			CMHDZ_PLAY_BONUS_PAIN_AUDIO(iEnemy)
		ENDIF
		
		SET_BITMASK_ENUM_AS_ENUM(sCMHDZData.sPlayerData[iPlayer].eReticuleBits, CMHDZ_RETICLE_BITS_HIT_TARGET)
		CMHDZ_INCREASE_ENEMY_HIT_COUNT_FOR_CURRENT_LEVEL(sCMHDZData.sPlayerData[iPlayer].sBulletData[iProjectile].bHit)
		#IF IS_DEBUG_BUILD
			//CDEBUG2LN(DEBUG_MINIGAME, "[HANDLE_PLAYER_BULLET_COLLISION] {dsw} Enemy ", iEnemy, "  Has been injured. New Health: ", sCMHDZData.sEnemyData[iEnemy].iHealth, " Type: ", CMHDZ_ENEMY_TYPES_TO_STRING(sCMHDZData.sEnemyData[iEnemy].iEnemyType))
		#ENDIF
	ELSE
		
		IF bHeadshot
//			AND NOT CMHDZ_IS_BEAR(iEnemy)
			CMHDZ_SET_HELP_TEXT_BIT(CMHDZ_HELP_TEXT_BIT_AT_LEAST_ONE_HEADSHOT)
			CMHDZ_ADD_TO_LOCAL_PLAYER_SCORE( CMHDZ_SCORE_TYPE_ENEMY_HEADSHOT )
			CMHDZ_INCREASE_ENEMY_HEADSHOT_COUNT_FOR_CURRENT_LEVEL()
			CMHDZ_SET_HELP_TEXT_BIT(CMHDZ_HELP_TEXT_BIT_AT_LEAST_ONE_HEADSHOT)
			CMHDZ_INCREASE_ENEMY_HIT_COUNT_FOR_CURRENT_LEVEL(sCMHDZData.sPlayerData[iPlayer].sBulletData[iProjectile].bHit)
			CMHDZ_PLAY_SOUND_AND_RELEASE_NO_POSITION(CMHDZ_AUDIO_EFFECT_PLAYER_SHOOT_HEADSHOT)
		ELSE
			CMHDZ_ADD_TO_LOCAL_PLAYER_SCORE( CMHDZ_SCORE_TYPE_ENEMY )
			CMHDZ_INCREASE_ENEMY_HIT_COUNT_FOR_CURRENT_LEVEL(sCMHDZData.sPlayerData[iPlayer].sBulletData[iProjectile].bHit)
		ENDIF

		CMHDZ_PLAY_SOUND_AND_RELEASE(CMHDZ_AUDIO_EFFECT_BULLET_HIT_BODY, sCMHDZData.sEnemyData[iEnemy].vSpritePos)
		//CMHDZ_PLAY_SOUND_AND_RELEASE(CMHDZ_AUDIO_EFFECT_ENEMY_A_DEAD, sCMHDZData.sEnemyData[iEnemy].vSpritePos)

		// Bonus enemies run a different logic
		IF NOT CMHDZ_ENEMY_DATA_IS_BITMASK_SET(iEnemy, CMHDZ_ENEMY_DATA_BITS_IS_BONUS)
			IF sCMHDZData.sEnemyData[iEnemy].eState != CMHDZ_ENEMY_STATE_DYING_BURNING
				//CMHDZ_PLAY_ENEMY_TYPE_SOUND_AND_RELEASE(sCMHDZData.sEnemyData[iEnemy].iEnemyType, CMHDZ_AUDIO_EFFECT_ENEMY_DEAD, sCMHDZData.sEnemyData[iEnemy].vSpritePos, sCMHDZData.sEnemyData[iEnemy].iEnemyVoiceID)
				CMHDZ_PLAY_SOUND_AND_RELEASE(CMHDZ_AUDIO_EFFECT_ENEMY_DEAD, sCMHDZData.sEnemyData[iEnemy].vSpritePos)
//			ELSE // Is on fire
//				CMHDZ_PLAY_SOUND_AND_RELEASE(CMHDZ_AUDIO_EFFECT_ENEMY_ON_FIRE, sCMHDZData.sEnemyData[iEnemy].vSpritePos)
			ENDIF
		ELSE
			CMHDZ_PLAY_BONUS_DEATH_AUDIO(iEnemy)
		ENDIF

		sCMHDZData.sEnemyData[iEnemy].eState = CMHDZ_ENEMY_STATE_DYING
		
		IF bHeadshot
			// High velocity weapons only cause the head explosions.
//			IF sCMHDZData.sPlayerData[0].activeWeapon =  CMHDZ_PLAYER_WEAPON_RIFLE
//			OR sCMHDZData.sPlayerData[0].activeWeapon =  CMHDZ_PLAYER_WEAPON_SHOTGUN
			sCMHDZData.sEnemyData[iEnemy].eState = CMHDZ_ENEMY_STATE_DYING_HEADSHOT
			CMHDZ_PLAY_DIRECTOR_DIALOGUE(CMHDZ_AUDIO_EFFECT_DIRECTOR_Enemy_Kill_Headshot)
//			ENDIF
		ENDIF
		
		sCMHDZData.sEnemyData[iEnemy].fAnimTimer = 0.0
		SET_BITMASK_ENUM_AS_ENUM(sCMHDZData.sPlayerData[iPlayer].eReticuleBits, CMHDZ_RETICLE_BITS_DESTROYED_TARGET)
	ENDIF
	
	// Moving call to consider Hit count.
	sCMHDZData.sPlayerData[iPlayer].sBulletData[iProjectile].bHit = TRUE
	sCMHDZData.sPlayerData[iPlayer].sBulletData[iProjectile].iTimeOfHit = GET_GAME_TIMER()
	
ENDPROC

PROC CMHDZ_HANDLE_PLAYER_BULLET_COLLISION_WITH_BOSS(CMHDZ_BOSS_DATA &sBossData, INT iPlayer, INT iProjectile, VECTOR_2D vSpriteTopLeft, VECTOR_2D vBulletPos )

	BOOL bHeadshot
	UNUSED_PARAMETER(bHeadshot)
	sCMHDZData.sPlayerData[iPlayer].sBulletData[iProjectile].bHit = TRUE
	sCMHDZData.sPlayerData[iPlayer].sBulletData[iProjectile].iTimeOfHit = GET_GAME_TIMER()

	bHeadshot = CMHDZ_CHECK_FOR_HEADSHOT( vSpriteTopLeft, vBulletPos, sBossData.iActiveLane )
	//sBossData.fHealth -= CMHDZ_GET_AMOUNT_BOSS_HAS_BEEN_DAMAGED(sBossData, bHeadshot)
	
	IF sCMHDZData.sBossData.fHealth > 0		
		SET_BITMASK_ENUM_AS_ENUM(sCMHDZData.sPlayerData[iPlayer].eReticuleBits, CMHDZ_RETICLE_BITS_HIT_TARGET)
		
		#IF IS_DEBUG_BUILD
			//CDEBUG2LN(DEBUG_MINIGAME, "[HANDLE_PLAYER_BULLET_COLLISION] {dsw} Enemy ", iEnemy, "  Has been injured. New Health: ", sCMHDZData.sEnemyData[iEnemy].iHealth, " Type: ", CMHDZ_ENEMY_TYPES_TO_STRING(sCMHDZData.sEnemyData[iEnemy].iEnemyType))
		#ENDIF
	ELSE
		SET_BITMASK_ENUM_AS_ENUM(sCMHDZData.sPlayerData[iPlayer].eReticuleBits, CMHDZ_RETICLE_BITS_DESTROYED_TARGET)
	ENDIF
			
	CMHDZ_INCREASE_ENEMY_HIT_COUNT_FOR_CURRENT_LEVEL((sCMHDZData.sPlayerData[iPlayer].sBulletData[iProjectile].bHit 
		OR sCMHDZData.sPlayerData[iPlayer].sBulletData[iProjectile].bHitObject)) // Unfir to penalise enemy accuracy on this one.
			
	CMHDZ_HANDLE_BEARSY_DAMAGE(sBossData, bHeadshot)
	
ENDPROC

PROC CMHDZ_HANDLE_PLAYER_BULLET_COLLISION_WITH_ITEM( INT iItem, INT iPlayer, INT iProjectile,BOOL &bProcessedThisFrame )
	IF bProcessedThisFrame
		EXIT
	ENDIF
	#IF IS_DEBUG_BUILD
		//CPRINTLN(DEBUG_MINIGAME, "[HANDLE_PLAYER_BULLET_COLLISION] [CMHDZ_HANDLE_PLAYER_BULLET_COLLISION_WITH_ITEM] {dsw}  Hit item", iItem, " Type: ", CMHDZ_ITEM_TYPES_TO_STRING(sCMHDZData.sItemData[iItem].eItemType))
	#ENDIF
	
	sCMHDZData.sPlayerData[iPlayer].sBulletData[iProjectile].bHitObject = TRUE
	sCMHDZData.sPlayerData[iPlayer].sBulletData[iProjectile].iTimeOfHit = GET_GAME_TIMER()
	CMHDZ_INCREASE_ENEMY_HIT_COUNT_FOR_CURRENT_LEVEL((sCMHDZData.sPlayerData[iPlayer].sBulletData[iProjectile].bHit 
						OR sCMHDZData.sPlayerData[iPlayer].sBulletData[iProjectile].bHitObject)) // Unfir to penalise enemy accuracy on this one.
						
	sCMHDZData.sItemData[iItem].bShot = TRUE
	
	CMHDZ_ACTIVATE_ITEM(iItem)
	
	bProcessedThisFrame = TRUE
ENDPROC

PROC CMHDZ_HANDLE_PLAYER_BULLET_COLLISION_WITH_THROWN_WEAPON( INT iWeapon, INT iPlayer, INT iProjectile , BOOL &bProcessedThisFrame)
	
	IF bProcessedThisFrame
		EXIT
	ENDIF
	#IF IS_DEBUG_BUILD
		//CDEBUG2LN(DEBUG_MINIGAME, "[HANDLE_PLAYER_BULLET_COLLISION] [CMHDZ_HANDLE_PLAYER_BULLET_COLLISION_WITH_THROWN_WEAPON] {dsw}  Hit thrown weapon ", iWeapon, " Type: ", CMHDZ_PROJECTILE_TYPES_TO_STRING(sCMHDZData.sEnemyProjectiles[iWeapon].eType))
	#ENDIF
	
	// Unfir to penalise enemy accuracy on this one.
	CMHDZ_INCREASE_ENEMY_HIT_COUNT_FOR_CURRENT_LEVEL((sCMHDZData.sPlayerData[iPlayer].sBulletData[iProjectile].bHit 
		OR sCMHDZData.sPlayerData[iPlayer].sBulletData[iProjectile].bHitObject)) // Unfir to penalise enemy accuracy on this one.
				
	sCMHDZData.sPlayerData[iPlayer].sBulletData[iProjectile].bHit = TRUE
	sCMHDZData.sPlayerData[iPlayer].sBulletData[iProjectile].iTimeOfHit = GET_GAME_TIMER()
	sCMHDZData.sEnemyProjectiles[iWeapon].eState = CMHDZ_PROJECTILE_STATE_IMPACT
	SET_CONTROL_SHAKE(FRONTEND_CONTROL, 100, 20)
	CMHDZ_PLAY_SOUND_AND_RELEASE(CMHDZ_AUDIO_EFFECT_EXP_DYNAMITE, sCMHDZData.sEnemyProjectiles[iWeapon].vSpritePos)
	
	//CMHDZ_KILL_ALL_ENEMIES_IN_AREA(sCMHDZData.sEnemyProjectiles[iWeapon].vSpritePos, INIT_VECTOR_2D(cfCMHDZ_SPRITE_GANG_THROWN_EXPLOSION_LARGE_WIDTH, cfCMHDZ_SPRITE_GANG_THROWN_EXPLOSION_LARGE_HEIGHT), 2.0)
	SWITCH sCMHDZData.sEnemyProjectiles[iWeapon].eType 
		CASE CMHDZ_PROJECTILE_DYNAMITE
			TWS_CREATE_FX(sCMHDZData.sEnemyProjectiles[iWeapon].vSpritePos, CMHDZ_FX_ENEMY_TNT_EXP, 1)
			CMHDZ_KILL_ALL_ENEMIES_IN_RANGE(sCMHDZData.sEnemyProjectiles[iWeapon].vSpritePos, 1500)
		BREAK
		
		// Stopped bearsy projectile midair.
		CASE CMHDZ_PROJECTILE_JOWL
		CASE CMHDZ_PROJECTILE_LEG
		CASE CMHDZ_PROJECTILE_TROTTER
		CASE CMHDZ_PROJECTILE_BONE
			TWS_CREATE_FX(sCMHDZData.sEnemyProjectiles[iWeapon].vSpritePos, CMHDZ_FX_BLOOD_SPLAT, ciCMHDZ_LANE_FOREGROUND)
			TWS_CREATE_FX(sCMHDZData.sEnemyProjectiles[iWeapon].vSpritePos, CMHDZ_FX_BEARSY_FOREGROUND_PAIN_BLOOD, ciCMHDZ_LANE_FOREGROUND)
		BREAK
	ENDSWITCH
	
	bProcessedThisFrame = TRUE		
ENDPROC


PROC HANDLE_PLAYER_BULLET_COLLISION(INT iPlayer, INT iProjectile)
	
	IF NOT sCMHDZData.sPlayerData[iPlayer].bHasJustShot
		EXIT
	ENDIF
	
	INT i
	CMHDZ_PLAYER_WEAPON_DATA weaponData
	weaponData = CMHDZ_GET_PLAYER_WEAPON_DATA(CMHDZ_GET_PLAYER_CURRENT_WEAPON())
	
	FLOAT fSpreadModifier = weaponData.fSpreadModifier
	
	INT iMaxEnemyImpacts = weaponData.iMaxEnemyImpacts
	
	FLOAT fDistance, fDistanceX, fDistanceY, x1, x2, y1, y2 // Top-left & Bottom-right corners of collision
	VECTOR_2D vBulletPos = INIT_VECTOR_2D(sCMHDZData.sPlayerData[iPlayer].sBulletData[iProjectile].vSpritePos.X, sCMHDZData.sPlayerData[iPlayer].sBulletData[iProjectile].vSpritePos.Y)
	
	INT iEnemyHit[ciCMHDZ_MAX_ENEMY_SHOT_AT_ONCE]
	INT iCurrentNumberOfEnemyHit = 0
	
	FOR i = 0 TO ciCMHDZ_MAX_ENEMY_SHOT_AT_ONCE -1
		iEnemyHit[i] = -1
	ENDFOR
	
	INT iCoverHit = -1
	INT iItemHit = -1
	INT iThrownHit = -1
	BOOL bBossHit
	
	FLOAT fModifier
	FLOAT fWidth
	FLOAT fHeight
	FOR i = 0 TO ciCMHDZ_MAX_COVER -1
		IF CMHDZ_DRAW_COVER_PROCESS_CHECK(i, sCMHDZData.sCoverData[i].iCoverLane, CMHDZ_COVER_DATA_IS_BITMASK_SET(i, CMHDZ_COVER_DATA_BITS_IS_FAR_BG))
			fModifier = CMHDZ_COVER_UTIL_GET_SIZE_MODIFIER_FOR_COLLISION_CHECK(sCMHDZData.sCoverData[i].eType)
			fWidth = sCMHDZData.sCoverData[i].fCoverWidth * fModifier
			fHeight = sCMHDZData.sCoverData[i].fCoverHeight * fModifier
			
			IF fWidth <= 0.0
				SCRIPT_ASSERT("[BAZ][HANDLE_PLAYER_BULLET_COLLISION] Width is returning 0.0 for cover so will never get hit. Check object initialisation.")
			ENDIF
			
			x1 = sCMHDZData.sCoverData[i].vSpritePos.x - (fWidth/2)
			y1 = sCMHDZData.sCoverData[i].vSpritePos.y - (fHeight/2)
			
			x2 = sCMHDZData.sCoverData[i].vSpritePos.x + (fWidth/2)
			y2 = sCMHDZData.sCoverData[i].vSpritePos.y + (fHeight/2)
			
			IF (sCMHDZData.sPlayerData[iPlayer].sBulletData[iProjectile].vSpritePos.X > x1 AND sCMHDZData.sPlayerData[iPlayer].sBulletData[iProjectile].vSpritePos.X < x2
			AND sCMHDZData.sPlayerData[iPlayer].sBulletData[iProjectile].vSpritePos.Y > y1 AND sCMHDZData.sPlayerData[iPlayer].sBulletData[iProjectile].vSpritePos.Y < y2)
				IF iCoverHit = -1
				OR sCMHDZData.sCoverData[i].iCoverLane >  sCMHDZData.sCoverData[iCoverHit].iCoverLane
				OR (CMHDZ_COVER_DATA_IS_BITMASK_SET(i, CMHDZ_COVER_DATA_BITS_IS_SPECIAL_COVER) AND NOT CMHDZ_COVER_DATA_IS_BITMASK_SET(iCoverHit, CMHDZ_COVER_DATA_BITS_IS_SPECIAL_COVER))
				OR (CMHDZ_COVER_DATA_IS_BITMASK_SET(i, CMHDZ_COVER_DATA_BITS_IS_ANIMATED) AND NOT CMHDZ_COVER_DATA_IS_BITMASK_SET(iCoverHit, CMHDZ_COVER_DATA_BITS_IS_ANIMATED))
					iCoverHit = i
				ENDIF				
			ENDIF
		ENDIF
	ENDFOR
		
	BOOL bBulletHitEnemyCoordCheck
	FLOAT fSpreadDistanceX
	FLOAT fSpreadDistanceY
		
	FOR i = 0 TO ciCMHDZ_MAX_ENEMIES  -1
	
		bBulletHitEnemyCoordCheck = FALSE
		IF sCMHDZData.sEnemyData[i].eState = CMHDZ_ENEMY_STATE_ATTACKING
		OR sCMHDZData.sEnemyData[i].eState = CMHDZ_ENEMY_STATE_ACTIVE
		OR sCMHDZData.sEnemyData[i].eState = CMHDZ_ENEMY_STATE_STUNNED
			IF sCMHDZData.sEnemyData[i].iHealth > 0

				x1 = sCMHDZData.sEnemyData[i].vSpritePos.x - (sCMHDZData.sEnemyData[i].vSize.x/2)
				y1 = sCMHDZData.sEnemyData[i].vSpritePos.y - (sCMHDZData.sEnemyData[i].vSize.y/2)
				
				x2 = sCMHDZData.sEnemyData[i].vSpritePos.x + (sCMHDZData.sEnemyData[i].vSize.x/2)
				y2 = sCMHDZData.sEnemyData[i].vSpritePos.y + (sCMHDZData.sEnemyData[i].vSize.y/2)
				
				IF sCMHDZData.sEnemyData[i].iEnemyType = CMHDZ_FOREGROUND_ENEMY_T5_2
					x1 -= (160.0)
					y1 -= (100.0)
					x2 += (160.0)
					y2 += (100.0)
				ENDIF
												
				IF fSpreadModifier = 1.0
				OR sCMHDZData.sEnemyData[i].iEnemyLane = ciCMHDZ_LANE_FOREGROUND
					IF sCMHDZData.sEnemyData[i].iEnemyLane = ciCMHDZ_LANE_FOREGROUND
						x1 -= (fSpreadModifier/2.0)
						x2 += (fSpreadModifier/2.0)
					ENDIF
					
					IF (vBulletPos.X > x1 AND vBulletPos.X < x2
					AND vBulletPos.Y > y1 AND vBulletPos.Y < y2)
						bBulletHitEnemyCoordCheck = TRUE
					ENDIF
				ELSE
					// Size up if enemy is in the foreground.
//					IF sCMHDZData.sEnemyData[i].iEnemyLane = ciCMHDZ_LANE_FOREGROUND
//						fSpreadModifier *= 1.5
//					ENDIF
					
					fSpreadDistanceX = sCMHDZData.sEnemyData[i].vSpritePos.x - vBulletPos.X	
					fSpreadDistanceY = sCMHDZData.sEnemyData[i].vSpritePos.Y - vBulletPos.Y	
					IF ((fSpreadDistanceX * fSpreadDistanceX) + (fSpreadDistanceY * fSpreadDistanceY ) < (fSpreadModifier * fSpreadModifier))
						bBulletHitEnemyCoordCheck = TRUE
						//CDEBUG2LN(DEBUG_MINIGAME, "[HANDLE_PLAYER_BULLET_COLLISION] {dsw} Potential Enemy SPREAD hit: ",i, " fSpreadModifier: ", fSpreadModifier, " Current weapon: ", CMHDZ_PLAYER_WEAPON_TO_STRING(CMHDZ_GET_PLAYER_CURRENT_WEAPON()))
					ENDIF
					// Rest modifier
					fSpreadModifier = weaponData.fSpreadModifier
				ENDIF
				
				IF bBulletHitEnemyCoordCheck
					IF iMaxEnemyImpacts = 1
					AND iCurrentNumberOfEnemyHit < ciCMHDZ_MAX_ENEMY_SHOT_AT_ONCE
						IF iEnemyHit[iCurrentNumberOfEnemyHit] = -1 
						OR sCMHDZData.sEnemyData[i].iEnemyLane >  sCMHDZData.sEnemyData[iEnemyHit[iCurrentNumberOfEnemyHit]].iEnemyLane
							iEnemyHit[iCurrentNumberOfEnemyHit] = i
							iCurrentNumberOfEnemyHit++
						ENDIF
					ELSE
						IF iCurrentNumberOfEnemyHit < iMaxEnemyImpacts
							IF iEnemyHit[iCurrentNumberOfEnemyHit] = -1
								iEnemyHit[iCurrentNumberOfEnemyHit] = i
								iCurrentNumberOfEnemyHit++
															
								#IF IS_DEBUG_BUILD
									//CPRINTLN(DEBUG_MINIGAME, "[HANDLE_PLAYER_BULLET_COLLISION] {dsw} Potential Enemy hit: ",i, " Lane: ", sCMHDZData.sEnemyData[i].iEnemyLane, "  Type: ", CMHDZ_ENEMY_TYPES_TO_STRING(sCMHDZData.sEnemyData[i].iEnemyType))
									//CPRINTLN(DEBUG_MINIGAME, "[HANDLE_PLAYER_BULLET_COLLISION] {dsw} Potential Enemy hit: ",i, " Bullet: ",vBulletPos.x, ", ", vBulletPos.y, " Point1: ", x1, ", ", y1, " Point2: ",x2, ", ", y2) 
									//CPRINTLN(DEBUG_MINIGAME, "[HANDLE_PLAYER_BULLET_COLLISION] {dsw} Number of Potential Enemy hits: ", iCurrentNumberOfEnemyHit, " Max with weapon: ", iMaxEnemyImpacts, " Weapon: ", CMHDZ_PLAYER_WEAPON_TO_STRING(CMHDZ_GET_PLAYER_CURRENT_WEAPON()))
								#ENDIF
							ENDIF
						ENDIF
					ENDIF
				ENDIF
			ENDIF
		ENDIF
	ENDFOR
	
	FOR i = 0 TO ciCMHDZ_MAX_ITEMS  -1
		
		IF NOT sCMHDZData.sItemData[i].bShot
			IF sCMHDZData.sItemData[i].bRendering
				fDistanceX = sCMHDZData.sPlayerData[iPlayer].vSpriteFinalReticlePos.x - sCMHDZData.sItemData[i].vSpritePos.x
				fDistanceY = sCMHDZData.sPlayerData[iPlayer].vSpriteFinalReticlePos.y - sCMHDZData.sItemData[i].vSpritePos.y
				fDistance = SQRT(fDistanceX * fDistanceX + fDistanceY * fDistanceY)
				
				#IF IS_DEBUG_BUILD
					//CPRINTLN(DEBUG_MINIGAME, "[HANDLE_PLAYER_BULLET_COLLISION] {dsw} Checking item: ", i, " Type: ", CMHDZ_ITEM_TYPES_TO_STRING(sCMHDZData.sItemData[i].eItemType), " Pos: ", sCMHDZData.sItemData[i].vSpritePos.x, ", ", sCMHDZData.sItemData[i].vSpritePos.y, " Rendering: ", sCMHDZData.sItemData[i].bRendering, " Dist from bullet : ", fDistance)
				#ENDIF
				
				IF fDistance < 60
					IF iItemHit = -1
					OR sCMHDZData.sItemData[i].iLane > sCMHDZData.sItemData[iItemHit].iLane
				//		CMHDZ_HANDLE_PLAYER_BULLET_COLLISION_WITH_ITEM(i,iPlayer, iProjectile )
						iItemHit = i
						#IF IS_DEBUG_BUILD
							//CPRINTLN(DEBUG_MINIGAME, "[HANDLE_PLAYER_BULLET_COLLISION] {dsw} Potential Item hit: ",i, " Lane: ", sCMHDZData.sItemData[i].iLane, "  Type: ", CMHDZ_ITEM_TYPES_TO_STRING(sCMHDZData.sItemData[i].eItemType))
						#ENDIF
					ENDIF
				ENDIF
			ENDIF
		ELSE
			#IF IS_DEBUG_BUILD
//				//CPRINTLN(DEBUG_MINIGAME, "[HANDLE_PLAYER_BULLET_COLLISION] {dsw} Not checking item as bShot Item: ",i, " Lane: ", sCMHDZData.sItemData[i].iLane, "  Type: ", CMHDZ_ITEM_TYPES_TO_STRING(sCMHDZData.sItemData[i].eItemType),  " Pos: ", sCMHDZData.sItemData[i].vSpritePos.x, ", ", sCMHDZData.sItemData[i].vSpritePos.y)
			#ENDIF
		ENDIF
	ENDFOR
	
	VECTOR_2D v2ProjSize
	FOR i = 0 TO ciCMHDZ_MAX_ENEMY_PROJECTILES  -1
		IF sCMHDZData.sEnemyProjectiles[i].eType = CMHDZ_PROJECTILE_DYNAMITE
		OR sCMHDZData.sEnemyProjectiles[i].eType = CMHDZ_PROJECTILE_JOWL
		OR sCMHDZData.sEnemyProjectiles[i].eType = CMHDZ_PROJECTILE_LEG
		OR sCMHDZData.sEnemyProjectiles[i].eType = CMHDZ_PROJECTILE_TROTTER
		OR sCMHDZData.sEnemyProjectiles[i].eType = CMHDZ_PROJECTILE_BONE
			IF sCMHDZData.sEnemyProjectiles[i].eState = CMHDZ_PROJECTILE_STATE_AIRBORNE
				SWITCH sCMHDZData.sEnemyProjectiles[i].iSpriteAnimFrame
					CASE 0			v2ProjSize = INIT_VECTOR_2D(ciCMHDZ_DYNAMITE_SMALL_WIDTH, ciCMHDZ_DYNAMITE_SMALL_HEIGHT)		BREAK
					CASE 1			v2ProjSize = INIT_VECTOR_2D(ciCMHDZ_DYNAMITE_SMALL_WIDTH, ciCMHDZ_DYNAMITE_SMALL_HEIGHT)		BREAK
					CASE 2			v2ProjSize = INIT_VECTOR_2D(ciCMHDZ_DYNAMITE_MEDIUM_WIDTH, ciCMHDZ_DYNAMITE_MEDIUM_HEIGHT)		BREAK
					CASE 3			v2ProjSize = INIT_VECTOR_2D(ciCMHDZ_DYNAMITE_MEDIUM_WIDTH, ciCMHDZ_DYNAMITE_MEDIUM_HEIGHT)		BREAK
					CASE 4			v2ProjSize = INIT_VECTOR_2D(ciCMHDZ_DYNAMITE_LARGE_WIDTH, ciCMHDZ_DYNAMITE_LARGE_HEIGHT)		BREAK
					CASE 5			v2ProjSize = INIT_VECTOR_2D(ciCMHDZ_DYNAMITE_LARGE_WIDTH, ciCMHDZ_DYNAMITE_LARGE_HEIGHT)		BREAK
				ENDSWITCH
				
				x1 = sCMHDZData.sEnemyProjectiles[i].vSpritePos.x - (v2ProjSize.x/2)
				y1 = sCMHDZData.sEnemyProjectiles[i].vSpritePos.y - (v2ProjSize.y/2)
				
				x2 = sCMHDZData.sEnemyProjectiles[i].vSpritePos.x + (v2ProjSize.x/2)
				y2 = sCMHDZData.sEnemyProjectiles[i].vSpritePos.y + (v2ProjSize.y/2)
				
				// Increase size can be a bit too hard to hit
				IF sCMHDZData.sEnemyProjectiles[i].eType = CMHDZ_PROJECTILE_DYNAMITE
					x1 -= (120.0 + fSpreadModifier)
					y1 -= (120.0 + fSpreadModifier)
					x2 += (120.0 + fSpreadModifier)
					y2 += (120.0 + fSpreadModifier)
				ENDIF
				
				IF sCMHDZData.sEnemyProjectiles[i].eType = CMHDZ_PROJECTILE_JOWL
				OR sCMHDZData.sEnemyProjectiles[i].eType = CMHDZ_PROJECTILE_LEG
				OR sCMHDZData.sEnemyProjectiles[i].eType = CMHDZ_PROJECTILE_TROTTER
				OR sCMHDZData.sEnemyProjectiles[i].eType = CMHDZ_PROJECTILE_BONE
					x1 -= (180.0 + fSpreadModifier)
					y1 -= (180.0 + fSpreadModifier)
					x2 += (180.0 + fSpreadModifier)
					y2 += (180.0 + fSpreadModifier)
				ENDIF
				
				IF (vBulletPos.X > x1 AND sCMHDZData.sPlayerData[iPlayer].sBulletData[iProjectile].vSpritePos.X < x2
				AND vBulletPos.Y > y1 AND sCMHDZData.sPlayerData[iPlayer].sBulletData[iProjectile].vSpritePos.Y < y2)
					IF iThrownHit = -1
					//	CMHDZ_HANDLE_PLAYER_BULLET_COLLISION_WITH_THROWN_WEAPON(i, iPlayer, iProjectile)
						iThrownHit = i
						#IF IS_DEBUG_BUILD
							CDEBUG2LN(DEBUG_MINIGAME, "[HANDLE_PLAYER_BULLET_COLLISION] {dsw} Potential thrown weapon hit: ",i, " Lane: ", sCMHDZData.sEnemyProjectiles[i].iLane, "  Type: ", CMHDZ_PROJECTILE_TYPES_TO_STRING(sCMHDZData.sEnemyProjectiles[i].eType))
						#ENDIF
					ENDIF
				ENDIF
			ENDIF
		ENDIF
	ENDFOR

	// Hit bearsy
	VECTOR_2D v2BearsySize
	v2BearsySize = sCMHDZData.sBossData.vScale
	x1 = sCMHDZData.sBossData.vSpritePos.x - (v2BearsySize.x/1.5)
	y1 = sCMHDZData.sBossData.vSpritePos.y - (v2BearsySize.y/1.5)
	
	x2 = sCMHDZData.sBossData.vSpritePos.x + (v2BearsySize.x/1.5)
	y2 = sCMHDZData.sBossData.vSpritePos.y + (v2BearsySize.y/1.5)
	
	IF fSpreadModifier = 1.0
	OR sCMHDZData.sBossData.iActiveLane = ciCMHDZ_LANE_FOREGROUND

		IF sCMHDZData.sEnemyData[i].iEnemyLane = ciCMHDZ_LANE_FOREGROUND
			x1 -= (fSpreadModifier/2.0)
			x2 += (fSpreadModifier/2.0)
			y1 -= (fSpreadModifier/2.0)
			y2 += (fSpreadModifier/2.0)
		ENDIF

		IF (vBulletPos.X > x1 AND vBulletPos.X < x2
		AND vBulletPos.Y > y1 AND vBulletPos.Y < y2)
			bBulletHitEnemyCoordCheck = TRUE
		ENDIF
	ELSE
		// Size up if enemy is in the foreground.
//		IF sCMHDZData.sBossData.iActiveLane = ciCMHDZ_LANE_FOREGROUND
//			fSpreadModifier *= 2.0
//		ENDIF
	
		fSpreadDistanceX = sCMHDZData.sBossData.vSpritePos.x - vBulletPos.X	
		fSpreadDistanceY = sCMHDZData.sBossData.vSpritePos.Y - vBulletPos.Y	
		IF ((fSpreadDistanceX * fSpreadDistanceX) + (fSpreadDistanceY * fSpreadDistanceY ) < (fSpreadModifier * fSpreadModifier))
			bBulletHitEnemyCoordCheck = TRUE
			//CDEBUG2LN(DEBUG_MINIGAME, "[HANDLE_PLAYER_BULLET_COLLISION] {dsw} Potential Enemy SPREAD hit: ",i, " fSpreadModifier: ", fSpreadModifier, " Current weapon: ", CMHDZ_PLAYER_WEAPON_TO_STRING(CMHDZ_GET_PLAYER_CURRENT_WEAPON()))
		ENDIF
		
		fSpreadModifier = weaponData.fSpreadModifier
	ENDIF

	IF (bBulletHitEnemyCoordCheck)
		IF !bBossHit
			bBossHit = TRUE
		ENDIF
	ENDIF
	
	//-- Figure out what we actually hit.
	IF iThrownHit = -1 AND iCoverHit = -1 AND iItemHit = -1 AND iEnemyHit[0] = -1 AND !bBossHit
		//-- Didn't hit anything
		CMHDZ_PLAY_SOUND_AND_RELEASE(CMHDZ_AUDIO_EFFECT_BULLET_HIT_GENERIC, vBulletPos)
	ENDIF
	
	
	BOOL bProcessedHitCoverThisFrame = FALSE
	BOOL bProcessedHitItemsThisFrame = FALSE
//	BOOL bProcessedHitHostagesThisFrame = FALSE
	BOOL bProcessedHitThrownObjectsThisFrame = FALSE
	i = 0
	
	// For any given lane, Cover > Items > Enemy > Hostages
	
	IF iThrownHit >= 0
		//-- Hit thrown explosive
		CMHDZ_HANDLE_PLAYER_BULLET_COLLISION_WITH_THROWN_WEAPON(iThrownHit, iPlayer, iProjectile, bProcessedHitThrownObjectsThisFrame)
	ENDIF
	
	IF iCurrentNumberOfEnemyHit = 0
		iCurrentNumberOfEnemyHit = 1
	ENDIF
	
	
	FOR i = 0 TO iCurrentNumberOfEnemyHit - 1
		
		
		//-- If we've hit a foreground enemy, go with that
		IF iEnemyHit[i] > -1 AND sCMHDZData.sEnemyData[iEnemyHit[i]].iEnemyLane = ciCMHDZ_LANE_FOREGROUND
			CMHDZ_HANDLE_PLAYER_BULLET_COLLISION_WITH_ENEMY(iEnemyHit[i], iPlayer, iProjectile, INIT_VECTOR_2D(sCMHDZData.sEnemyData[iEnemyHit[i]].vSpritePos.x - (sCMHDZData.sEnemyData[iEnemyHit[i]].vSize.x/2), sCMHDZData.sEnemyData[iEnemyHit[i]].vSpritePos.y - (sCMHDZData.sEnemyData[iEnemyHit[i]].vSize.y/2)), vBulletPos)
		ELIF iItemHit > -1 AND sCMHDZData.sItemData[iItemHit].iLane = ciCMHDZ_LANE_FOREGROUND
			//-- Hit a foreground item - generally a pickup hidden in an out house
			CMHDZ_HANDLE_PLAYER_BULLET_COLLISION_WITH_ITEM(iItemHit,iPlayer, iProjectile, bProcessedHitItemsThisFrame )
		ELIF iEnemyHit[i] > -1 AND CMHDZ_ENEMY_DATA_IS_BITMASK_SET(iEnemyHit[i], CMHDZ_ENEMY_DATA_BITS_IS_POPUP)
			//-- Enemy peds that 'pop up' behind buildings can always be hit
			CMHDZ_HANDLE_PLAYER_BULLET_COLLISION_WITH_ENEMY(iEnemyHit[i], iPlayer, iProjectile, INIT_VECTOR_2D(sCMHDZData.sEnemyData[iEnemyHit[i]].vSpritePos.x - (sCMHDZData.sEnemyData[iEnemyHit[i]].vSize.x/2), sCMHDZData.sEnemyData[iEnemyHit[i]].vSpritePos.y - (sCMHDZData.sEnemyData[iEnemyHit[i]].vSize.y/2)), vBulletPos)
		ELSE
			IF iItemHit > -1
				IF sCMHDZData.sItemData[iItemHit].iLane = ciCMHDZ_LANE_MIDDLE 
					CMHDZ_HANDLE_PLAYER_BULLET_COLLISION_WITH_ITEM(iItemHit,iPlayer, iProjectile, bProcessedHitItemsThisFrame )
				ELIF sCMHDZData.sItemData[iItemHit].iLane = ciCMHDZ_LANE_BACKGROUND
					IF iEnemyHit[i] > -1 AND sCMHDZData.sEnemyData[iEnemyHit[i]].iEnemyLane = ciCMHDZ_LANE_MIDDLE
						CMHDZ_HANDLE_PLAYER_BULLET_COLLISION_WITH_ENEMY(iEnemyHit[i], iPlayer, iProjectile, INIT_VECTOR_2D(sCMHDZData.sEnemyData[iEnemyHit[i]].vSpritePos.x - (sCMHDZData.sEnemyData[iEnemyHit[i]].vSize.x/2), sCMHDZData.sEnemyData[iEnemyHit[i]].vSpritePos.y - (sCMHDZData.sEnemyData[iEnemyHit[i]].vSize.y/2)), vBulletPos)
					ELSE
						CMHDZ_HANDLE_PLAYER_BULLET_COLLISION_WITH_ITEM(iItemHit,iPlayer, iProjectile, bProcessedHitItemsThisFrame )
					ENDIF
				ENDIF
			ELSE
				IF iCoverHit > -1
					IF sCMHDZData.sCoverData[iCoverHit].iCoverLane = ciCMHDZ_LANE_MIDDLE
					AND NOT CMHDZ_CAN_SHOOT_THROUGH_COVER(iCoverHit)
						//-- Hit cover in middle lane
						CMHDZ_HANDLE_PLAYER_BULLET_COLLISION_WITH_COVER(iCoverHit, iPlayer, iProjectile, bProcessedHitCoverThisFrame)
					ELIF sCMHDZData.sCoverData[iCoverHit].iCoverLane = ciCMHDZ_LANE_BACKGROUND
					OR CMHDZ_CAN_SHOOT_THROUGH_COVER(iCoverHit)
						//-- Background cover hit, check if anything in front of it
						IF iItemHit > -1 AND sCMHDZData.sItemData[iItemHit].iLane = ciCMHDZ_LANE_MIDDLE 
							CMHDZ_HANDLE_PLAYER_BULLET_COLLISION_WITH_ITEM(iItemHit,iPlayer, iProjectile, bProcessedHitItemsThisFrame )
						ELIF iEnemyHit[i] > -1 AND ( sCMHDZData.sEnemyData[iEnemyHit[i]].iEnemyLane = ciCMHDZ_LANE_MIDDLE OR CMHDZ_CAN_SHOOT_THROUGH_COVER(iCoverHit))
							CMHDZ_HANDLE_PLAYER_BULLET_COLLISION_WITH_ENEMY(iEnemyHit[i], iPlayer, iProjectile, INIT_VECTOR_2D(sCMHDZData.sEnemyData[iEnemyHit[i]].vSpritePos.x - (sCMHDZData.sEnemyData[iEnemyHit[i]].vSize.x/2), sCMHDZData.sEnemyData[iEnemyHit[i]].vSpritePos.y - (sCMHDZData.sEnemyData[iEnemyHit[i]].vSize.y/2)), vBulletPos)
						ELIF iEnemyHit[i] > -1 AND ( sCMHDZData.sEnemyData[iEnemyHit[i]].iEnemyLane = ciCMHDZ_LANE_BACKGROUND)
							//-- Be generous with peds sticking their heads above cover
							fModifier = CMHDZ_COVER_UTIL_GET_SIZE_MODIFIER_FOR_COLLISION_CHECK(sCMHDZData.sCoverData[iCoverHit].eType)
							fHeight = sCMHDZData.sCoverData[iCoverHit].fCoverHeight * fModifier
													
							IF sCMHDZData.sCoverData[iCoverHit].vSpritePos.y - (fHeight /2.0) < (sCMHDZData.sEnemyData[iEnemyHit[i]].vSpritePos.y + (sCMHDZData.sEnemyData[iEnemyHit[i]].vSize.y / 2.0))
								CMHDZ_HANDLE_PLAYER_BULLET_COLLISION_WITH_ENEMY(iEnemyHit[i], iPlayer, iProjectile, INIT_VECTOR_2D(sCMHDZData.sEnemyData[iEnemyHit[i]].vSpritePos.x - (sCMHDZData.sEnemyData[iEnemyHit[i]].vSize.x/2), sCMHDZData.sEnemyData[iEnemyHit[i]].vSpritePos.y - (sCMHDZData.sEnemyData[iEnemyHit[i]].vSize.y/2)), vBulletPos)
							ENDIF
							
						ELSE
							CMHDZ_HANDLE_PLAYER_BULLET_COLLISION_WITH_COVER(iCoverHit, iPlayer, iProjectile, bProcessedHitCoverThisFrame)
						ENDIF
					ENDIF	
				ELIF iEnemyHit[i] > -1
					IF sCMHDZData.sEnemyData[iEnemyHit[i]].iEnemyLane = ciCMHDZ_LANE_MIDDLE
						CMHDZ_HANDLE_PLAYER_BULLET_COLLISION_WITH_ENEMY(iEnemyHit[i], iPlayer, iProjectile, INIT_VECTOR_2D(sCMHDZData.sEnemyData[iEnemyHit[i]].vSpritePos.x - (sCMHDZData.sEnemyData[iEnemyHit[i]].vSize.x/2), sCMHDZData.sEnemyData[iEnemyHit[i]].vSpritePos.y - (sCMHDZData.sEnemyData[iEnemyHit[i]].vSize.y/2)), vBulletPos)
					ELIF sCMHDZData.sEnemyData[iEnemyHit[i]].iEnemyLane = ciCMHDZ_LANE_BACKGROUND
						CMHDZ_HANDLE_PLAYER_BULLET_COLLISION_WITH_ENEMY(iEnemyHit[i], iPlayer, iProjectile, INIT_VECTOR_2D(sCMHDZData.sEnemyData[iEnemyHit[i]].vSpritePos.x - (sCMHDZData.sEnemyData[iEnemyHit[i]].vSize.x/2), sCMHDZData.sEnemyData[iEnemyHit[i]].vSpritePos.y - (sCMHDZData.sEnemyData[iEnemyHit[i]].vSize.y/2)), vBulletPos)
					ENDIF
				ENDIF
						
			ENDIF
		ENDIF
		
	ENDFOR
	
	IF bBossHit
		CMHDZ_HANDLE_PLAYER_BULLET_COLLISION_WITH_BOSS(sCMHDZData.sBossData, iPlayer, iProjectile, INIT_VECTOR_2D(sCMHDZData.sBossData.vSpritePos.x - (sCMHDZData.sBossData.vScale.x/2), sCMHDZData.sBossData.vSpritePos.y - (sCMHDZData.sBossData.vSpritePos.y/2)), vBulletPos)
	ENDIF
	
	// Harsh to punish accuracy like this. Hits reset if you take damage.
//	IF NOT bHitSomething
//		IF CMHDZ_GET_PLAYER_SUCESSIVE_HITS() != 1
//			CMHDZ_RESET_PLAYER_SUCCESSIVE_HITS()
//		ENDIF
//	ENDIF

ENDPROC

PROC CMHDZ_ACTIVATE_MENU_OPTION(CMHDZ_MENU_OPTIONS eOption)
	/*
	CMHDZ_LEVEL_CITY
	CMHDZ_LEVEL_SCRAPYARD,
	CMHDZ_LEVEL_ASYLUM,
	CMHDZ_LEVEL_PARK,
	CMHDZ_LEVEL_SLAUGHTERHOUSE,
	*/
	//CDEBUG2LN(DEBUG_MINIGAME, "[CMHDZ_ARCADE] CMHDZ_ACTIVATE_MENU_OPTION ")
	
	SWITCH eOption
	CASE CMHDZ_START
		CMHDZ_PLAY_SOUND_AND_RELEASE_NO_POSITION(CMHDZ_AUDIO_EFFECT_BULLET_HIT_START)
		//DG_START_MOVIE(sCMHDZData.bmIdCmhdzIntro, "CMHDZ_Intro_FadeOut")
		CMHDZ_START_MOVIE_FORCE(sCMHDZData.bmIdCmhdzIntro, "CMHDZ_Intro_FadeOut")
		CMHDZ_SET_LOCAL_STATE(CMHDZ_ARCADE_CLIENT_STATE_TITLE_FADEOUT)
	BREAK
	
	CASE CMHDZ_SCORES
		IF NOT sCMHDZData.bSkipLeaderboard
			
			CMHDZ_PLAY_SOUND_AND_RELEASE_NO_POSITION(CMHDZ_AUDIO_EFFECT_BULLET_HIT_OPTION)
			
			CMHDZ_INIT_GOTO_LEADERBOARD()
			CMHDZ_SET_LOCAL_STATE(CMHDZ_ARCADE_CLIENT_STATE_VIEW_LEADERBOARD)
		//	CMHDZ_SET_LOCAL_STATE(CMHDZ_ARCADE_CLIENT_STATE_EDIT_LEADERBOARD)
		ENDIF
	BREAK
	
	CASE CMHDZ_WANTED_1
	
		sCMHDZData.eCurrentLevel = CMHDZ_LEVEL_CITY
		//CMHDZ_PLAY_SOUND_AND_RELEASE_NO_POSITION(CMHDZ_AUDIO_EFFECT_SELECT_STAGE)
		CMHDZ_TRIGGER_MUSIC_EVENT(CMHDZ_MUSIC_EVENT_STOP)
		CMHDZ_PLAY_DIRECTOR_DIALOGUE(CMHDZ_AUDIO_EFFECT_DIRECTOR_Level_Select_Slums)
		CMHDZ_SET_LOCAL_STATE(CMHDZ_ARCADE_CLIENT_STATE_INIT_LEVEL)
	
	BREAK
	CASE CMHDZ_WANTED_2
	
		sCMHDZData.eCurrentLevel = CMHDZ_LEVEL_SCRAPYARD	
		//CMHDZ_PLAY_SOUND_AND_RELEASE_NO_POSITION(CMHDZ_AUDIO_EFFECT_SELECT_STAGE)
		CMHDZ_TRIGGER_MUSIC_EVENT(CMHDZ_MUSIC_EVENT_STOP)
		CMHDZ_PLAY_DIRECTOR_DIALOGUE(CMHDZ_AUDIO_EFFECT_DIRECTOR_Level_Select_Junkyard)
		CMHDZ_SET_LOCAL_STATE(CMHDZ_ARCADE_CLIENT_STATE_INIT_LEVEL)
	
	
	BREAK
	CASE CMHDZ_WANTED_3

		sCMHDZData.eCurrentLevel = CMHDZ_LEVEL_ASYLUM
		//CMHDZ_PLAY_SOUND_AND_RELEASE_NO_POSITION(CMHDZ_AUDIO_EFFECT_SELECT_STAGE)
		CMHDZ_TRIGGER_MUSIC_EVENT(CMHDZ_MUSIC_EVENT_STOP)
		CMHDZ_PLAY_DIRECTOR_DIALOGUE(CMHDZ_AUDIO_EFFECT_DIRECTOR_Level_Select_Asylum)
		CMHDZ_SET_LOCAL_STATE(CMHDZ_ARCADE_CLIENT_STATE_INIT_LEVEL)

	
	BREAK
	CASE CMHDZ_WANTED_4
	
		sCMHDZData.eCurrentLevel = CMHDZ_LEVEL_PARK
		//CMHDZ_PLAY_SOUND_AND_RELEASE_NO_POSITION(CMHDZ_AUDIO_EFFECT_SELECT_STAGE)
		CMHDZ_TRIGGER_MUSIC_EVENT(CMHDZ_MUSIC_EVENT_STOP)
		CMHDZ_PLAY_DIRECTOR_DIALOGUE(CMHDZ_AUDIO_EFFECT_DIRECTOR_Level_Select_Theme_Park)
		CMHDZ_SET_LOCAL_STATE(CMHDZ_ARCADE_CLIENT_STATE_INIT_LEVEL)
	
	
	BREAK
	CASE CMHDZ_WANTED_5
	
		sCMHDZData.eCurrentLevel = CMHDZ_LEVEL_SLAUGHTERHOUSE
		//CMHDZ_PLAY_SOUND_AND_RELEASE_NO_POSITION(CMHDZ_AUDIO_EFFECT_SELECT_STAGE)
		CMHDZ_TRIGGER_MUSIC_EVENT(CMHDZ_MUSIC_EVENT_STOP)
		CMHDZ_PLAY_DIRECTOR_DIALOGUE(CMHDZ_AUDIO_EFFECT_DIRECTOR_Level_Select_Slaughterhouse)
		CMHDZ_SET_LOCAL_STATE(CMHDZ_ARCADE_CLIENT_STATE_INIT_LEVEL)
	
	BREAK
	
	CASE CMHDZ_REWIND
		CMHDZ_PLAY_SOUND_AND_RELEASE_NO_POSITION(CMHDZ_AUDIO_EFFECT_BULLET_HIT_OPTION)
		CMHDZ_SET_RESULT_SCREEN_STATE(CMHDZ_RESULT_SCREEN_STATE_START_REWIND)
	BREAK 
	
	CASE CMHDZ_EJECT
		CMHDZ_PLAY_SOUND_AND_RELEASE_NO_POSITION(CMHDZ_AUDIO_EFFECT_BULLET_HIT_OPTION)
		CMHDZ_PLAY_DIRECTOR_DIALOGUE(CMHDZ_AUDIO_EFFECT_DIRECTOR_Quit)
		CMHDZ_SET_RESULT_SCREEN_STATE(CMHDZ_RESULT_SCREEN_STATE_GOTO_LEADERBOARD)
	BREAK 
	
  	ENDSWITCH
ENDPROC

PROC HANDLE_PLAYER_BULLET_IN_MENU(INT iPlayer, INT iProjectile)
	
	IF NOT sCMHDZData.sPlayerData[iPlayer].bHasJustShot
		EXIT
	ENDIF
	
	INT i
//	FLOAT x1, x2, y1, y2 // Top-left & Bottom-right corners of collision
	

	BOOL bHitSomething
	FOR i = 0 TO ciCMHDZ_MAX_MENU_OPTIONS-1

		IF sCMHDZData.sMenuOptionsData[i].eClientState = sCMHDZData.eClientState
	
			sCMHDZData.sPlayerData[iPlayer].sBulletData[iProjectile].bHit = TRUE
			
//			x1 = sCMHDZData.sMenuOptionsData[i].vSpritePos.x - (sCMHDZData.sMenuOptionsData[i].vSize.x/2)
//			y1 = sCMHDZData.sMenuOptionsData[i].vSpritePos.y - (sCMHDZData.sMenuOptionsData[i].vSize.y/2)
//			
//			x2 = sCMHDZData.sMenuOptionsData[i].vSpritePos.x + (sCMHDZData.sMenuOptionsData[i].vSize.x/2)
//			y2 = sCMHDZData.sMenuOptionsData[i].vSpritePos.y + (sCMHDZData.sMenuOptionsData[i].vSize.y/2)
//			
			
			
//			IF sCMHDZData.sMenuOptionsData[i].eMenuOption = CMHDZ_START
//				//CDEBUG2LN(DEBUG_MINIGAME, "[CMHDZ_ARCADE] {DSW} [HANDLE_PLAYER_BULLET_IN_MENU] ")
//				//CDEBUG2LN(DEBUG_MINIGAME, "[CMHDZ_ARCADE] {DSW} [HANDLE_PLAYER_BULLET_IN_MENU] Sprite Pos X: ", sCMHDZData.sMenuOptionsData[i].vSpritePos.x, " Pos Y: ",sCMHDZData.sMenuOptionsData[i].vSpritePos.y)
//				//CDEBUG2LN(DEBUG_MINIGAME, "[CMHDZ_ARCADE] {DSW} [HANDLE_PLAYER_BULLET_IN_MENU] Sprite Size X:  ", sCMHDZData.sMenuOptionsData[i].vSize.x, " Size Y: ", sCMHDZData.sMenuOptionsData[i].vSize.y)
//				//CDEBUG2LN(DEBUG_MINIGAME, "[CMHDZ_ARCADE] {DSW} [HANDLE_PLAYER_BULLET_IN_MENU] Sprite (x1, y1) : ", x1, " , ", y1, " (x2, y2): ", x2, ", ", y2)
//				//CDEBUG2LN(DEBUG_MINIGAME, "[CMHDZ_ARCADE] {DSW} [HANDLE_PLAYER_BULLET_IN_MENU] Bullet x: ", sCMHDZData.sPlayerData[iPlayer].sBulletData[iProjectile].vSpritePos.X, " y: ", sCMHDZData.sPlayerData[iPlayer].sBulletData[iProjectile].vSpritePos.y)
//				
//				
//				//CDEBUG2LN(DEBUG_MINIGAME, "[CMHDZ_ARCADE] {DSW} [HANDLE_PLAYER_BULLET_IN_MENU] ")
//			ENDIF
			
//			IF (sCMHDZData.sPlayerData[iPlayer].sBulletData[iProjectile].vSpritePos.X > x1 AND sCMHDZData.sPlayerData[iPlayer].sBulletData[iProjectile].vSpritePos.X < x2
//			AND sCMHDZData.sPlayerData[iPlayer].sBulletData[iProjectile].vSpritePos.Y > y1 AND sCMHDZData.sPlayerData[iPlayer].sBulletData[iProjectile].vSpritePos.Y < y2)
			
			IF CMHDZ_IS_POSITION_OVER_MENU_OPTION(sCMHDZData.sPlayerData[iPlayer].sBulletData[iProjectile].vSpritePos, INT_TO_ENUM(CMHDZ_MENU_OPTIONS, i))
				bHitSomething = TRUE
				sCMHDZData.sPlayerData[iPlayer].sBulletData[iProjectile].iTimeOfHit = GET_GAME_TIMER()
				IF CMHDZ_IS_MENU_OPTION_UNLOCKED(sCMHDZData.sMenuOptionsData[i].eMenuOption)
					CMHDZ_ACTIVATE_MENU_OPTION(sCMHDZData.sMenuOptionsData[i].eMenuOption)
				ELSE
					CMHDZ_PLAY_SOUND_AND_RELEASE_NO_POSITION(CMHDZ_AUDIO_EFFECT_SCREEN_LOCKED)
				ENDIF
			ENDIF
		ENDIF
		
	ENDFOR
	
	IF NOT bHitSomething
		CMHDZ_PLAY_SOUND_AND_RELEASE_NO_POSITION(CMHDZ_AUDIO_EFFECT_BULLET_HIT_MISS)
	ENDIF
ENDPROC

PROC CMHDZ_CHECK_PLAYER_HOVERING_ENEMY()
	
	FLOAT distanceX, distanceY, fDistance
	INT iPlayer, i
	
	FOR iPlayer = 0 TO ciCMHDZ_MAX_PLAYERS - 1
	
		sCMHDZData.sPlayerData[iPlayer].bHoveringEnemy = FALSE
		
		FOR i = 0 TO ciCMHDZ_MAX_ENEMIES  -1

			IF (sCMHDZData.sEnemyData[i].eState = CMHDZ_ENEMY_STATE_ACTIVE OR sCMHDZData.sEnemyData[i].eState = CMHDZ_ENEMY_STATE_ATTACKING) 
			AND sCMHDZData.sEnemyData[i].iHealth > 0
				distanceX = sCMHDZData.sPlayerData[iPlayer].vSpriteInitReticlePos.x - sCMHDZData.sEnemyData[i].vSpritePos.x
				distanceY = sCMHDZData.sPlayerData[iPlayer].vSpriteInitReticlePos.y - sCMHDZData.sEnemyData[i].vSpritePos.y
				fDistance = SQRT(distanceX * distanceX + distanceY * distanceY)
			
				IF fDistance <= 112 * CMHDZ_GET_ENEMY_TYPE_SCALE_FOR_LANE(sCMHDZData.sEnemyData[i].iEnemyLane)
					sCMHDZData.sPlayerData[iPlayer].bHoveringEnemy = TRUE
					EXIT
				ENDIF
			ENDIF
		ENDFOR
		
		FOR i = 0 TO ciCMHDZ_MAX_ITEMS  -1
	
		IF NOT sCMHDZData.sItemData[i].bShot
			IF sCMHDZData.sItemData[i].bRendering
				distanceX = sCMHDZData.sPlayerData[iPlayer].vSpriteInitReticlePos.x - sCMHDZData.sItemData[i].vSpritePos.x
				distanceY = sCMHDZData.sPlayerData[iPlayer].vSpriteInitReticlePos.y - sCMHDZData.sItemData[i].vSpritePos.y
				fDistance = SQRT(distanceX * distanceX + distanceY * distanceY)
			
				IF fDistance <= 76
					sCMHDZData.sPlayerData[iPlayer].bHoveringEnemy = TRUE
				ENDIF
			ENDIF
		ENDIF
	ENDFOR
	ENDFOR
ENDPROC

PROC CMHDZ_CHECK_PLAYER_HOVERING_MENU_OPTION()
	
//	FLOAT x1, x2, y1, y2 // Top-left & Bottom-right corners of collision

	INT iPlayer, i
	FOR iPlayer = 0 TO ciCMHDZ_MAX_PLAYERS - 1
		
		sCMHDZData.sPlayerData[iPlayer].bHoveringEnemy = FALSE

		FOR i = 0 TO ciCMHDZ_MAX_MENU_OPTIONS-1

			IF sCMHDZData.sMenuOptionsData[i].eClientState = sCMHDZData.eClientState
				
//				x1 = sCMHDZData.sMenuOptionsData[i].vSpritePos.x - (sCMHDZData.sMenuOptionsData[i].vSize.x/2)
//				y1 = sCMHDZData.sMenuOptionsData[i].vSpritePos.y - (sCMHDZData.sMenuOptionsData[i].vSize.y/2)
//				
//				x2 = sCMHDZData.sMenuOptionsData[i].vSpritePos.x + (sCMHDZData.sMenuOptionsData[i].vSize.x/2)
//				y2 = sCMHDZData.sMenuOptionsData[i].vSpritePos.y + (sCMHDZData.sMenuOptionsData[i].vSize.y/2)
//				
//				IF (sCMHDZData.sPlayerData[iPlayer].vSpriteInitReticlePos.x > x1 
//				AND sCMHDZData.sPlayerData[iPlayer].vSpriteInitReticlePos.x < x2
//				AND sCMHDZData.sPlayerData[iPlayer].vSpriteInitReticlePos.y > y1 
//				AND sCMHDZData.sPlayerData[iPlayer].vSpriteInitReticlePos.Y < y2)
				
				IF CMHDZ_IS_POSITION_OVER_MENU_OPTION(sCMHDZData.sPlayerData[iPlayer].vSpriteInitReticlePos, INT_TO_ENUM(CMHDZ_MENU_OPTIONS, i))
					sCMHDZData.sPlayerData[iPlayer].bHoveringEnemy = TRUE
				ENDIF
			ENDIF
			
		ENDFOR
	ENDFOR
	
ENDPROC

PROC CMHDZ_HANDLE_RETICULE_MOVEMENT(BOOL bAllowRightStick = TRUE, BOOL bInMenu = FALSE)

	IF CMHDZ_IS_PLAYER_PLAYING()
		IF CMHDZ_GET_LOCAL_PLAYER_HEALTH() <= 0.0
			EXIT
		ENDIF
	ENDIF
	FLOAT fAxisThresholdMod = cfIAP_CONTROLLER_AXIS_THRESHOLD_MOD
	 
	FLOAT fLeftLimit = 305.0
	FLOAT fRightLimit = cfRIGHT_SCREEN_LIMIT
	FLOAT fDownLimit = 80.0
	FLOAT fUpLimit = 995.0
	
	IF NOT IS_USING_KEYBOARD_AND_MOUSE(PLAYER_CONTROL)
		// Controller
		FLOAT fRightStickX = GET_DISABLED_CONTROL_NORMAL(FRONTEND_CONTROL, INPUT_SCRIPT_RIGHT_AXIS_X)
		FLOAT fRightStickY = GET_DISABLED_CONTROL_NORMAL(FRONTEND_CONTROL, INPUT_SCRIPT_RIGHT_AXIS_Y)
		FLOAT fLeftStickX  = GET_DISABLED_CONTROL_NORMAL(FRONTEND_CONTROL, INPUT_SCRIPT_LEFT_AXIS_X)
		FLOAT fLeftStickY  = GET_DISABLED_CONTROL_NORMAL(FRONTEND_CONTROL, INPUT_SCRIPT_LEFT_AXIS_Y)
		
		IF (bAllowRightStick = FALSE)
			fRightStickX = 0
			fRightStickY = 0
		ENDIF
		
		fAxisThresholdMod = 0.10
		
		BOOL bMovingLeft 	= (fLeftStickX < -cfSTICK_THRESHOLD * fAxisThresholdMod)
		BOOL bMovingRight 	= (fLeftStickX > cfSTICK_THRESHOLD * fAxisThresholdMod)
		BOOL bMovingDown	= (fLeftStickY < -cfSTICK_THRESHOLD * fAxisThresholdMod)
		BOOL bMovingUp 		= (fLeftStickY > cfSTICK_THRESHOLD * fAxisThresholdMod)
	
		FLOAT fMoveSpeedX = ABSF(fLeftStickX * 55)
		FLOAT fMoveSpeedY = ABSF(fLeftStickY * 45)
		FLOAT fAutoAimTension = 0.35 // Set Between 0.0 - 1.0
		
		IF bInMenu
			CMHDZ_CHECK_PLAYER_HOVERING_MENU_OPTION()
		ELSE // In game
			IF (fMoveSpeedX >= 5)
			OR (fMoveSpeedY >= 5)
				CMHDZ_CHECK_PLAYER_HOVERING_ENEMY()
			ENDIF
		ENDIF
		
		//Reticule 1
		IF bMovingLeft AND sCMHDZData.sPlayerData[0].vSpriteInitReticlePos.x >= fLeftLimit // 0.0
			sCMHDZData.sPlayerData[0].vSpriteInitReticlePos.x -= (fMoveSpeedX - (BOOL_TO_INT(sCMHDZData.sPlayerData[0].bHoveringEnemy) * (fMoveSpeedX*fAutoAimTension))) * CMHDZ_GET_RETICULE_UPDATE()
			IF sCMHDZData.sPlayerData[0].vSpriteInitReticlePos.x < fLeftLimit
				sCMHDZData.sPlayerData[0].vSpriteInitReticlePos.x = fLeftLimit
			ENDIF
		ELIF bMovingRight AND sCMHDZData.sPlayerData[0].vSpriteInitReticlePos.x <= fRightLimit
			sCMHDZData.sPlayerData[0].vSpriteInitReticlePos.x += (fMoveSpeedX - (BOOL_TO_INT(sCMHDZData.sPlayerData[0].bHoveringEnemy) * (fMoveSpeedX*fAutoAimTension))) * CMHDZ_GET_RETICULE_UPDATE()
			IF sCMHDZData.sPlayerData[0].vSpriteInitReticlePos.x > fRightLimit
				sCMHDZData.sPlayerData[0].vSpriteInitReticlePos.x = fRightLimit
			ENDIF
		ENDIF
		
		IF bMovingDown AND sCMHDZData.sPlayerData[0].vSpriteInitReticlePos.y >= fDownLimit //20.0
			sCMHDZData.sPlayerData[0].vSpriteInitReticlePos.y -= (fMoveSpeedY - (BOOL_TO_INT(sCMHDZData.sPlayerData[0].bHoveringEnemy) * (fMoveSpeedY*fAutoAimTension)))  * CMHDZ_GET_RETICULE_UPDATE()
			IF sCMHDZData.sPlayerData[0].vSpriteInitReticlePos.y < fDownLimit
				sCMHDZData.sPlayerData[0].vSpriteInitReticlePos.y = fDownLimit
			ENDIF
		ELIF bMovingUp AND sCMHDZData.sPlayerData[0].vSpriteInitReticlePos.y <= fUpLimit
			sCMHDZData.sPlayerData[0].vSpriteInitReticlePos.y += (fMoveSpeedY - (BOOL_TO_INT(sCMHDZData.sPlayerData[0].bHoveringEnemy) * (fMoveSpeedY*fAutoAimTension)))  * CMHDZ_GET_RETICULE_UPDATE()
			IF sCMHDZData.sPlayerData[0].vSpriteInitReticlePos.y > fUpLimit
				sCMHDZData.sPlayerData[0].vSpriteInitReticlePos.y = fUpLimit
			ENDIF
		ENDIF
		
		// Get the right stick micro mod
		VECTOR_2D vRightStickMod
//		vRightStickMod.x = (cfBASE_SCREEN_WIDTH/2.0) + ((fRightLimit - (cfBASE_SCREEN_WIDTH/2.0))*fRightStickX)
//		vRightStickMod.y = (cfBASE_SCREEN_HEIGHT/2.0) + ((fUpLimit - (cfBASE_SCREEN_HEIGHT/2.0))*fRightStickY)
		vRightStickMod.x = ((fRightLimit - (cfBASE_SCREEN_WIDTH/2.0))*fRightStickX)
		vRightStickMod.y = ((fUpLimit - (cfBASE_SCREEN_HEIGHT/2.0))*fRightStickY)
		
		vRightStickMod = MULTIPLY_VECTOR_2D(vRightStickMod, 1.1)
		
		// Add the relative results together.
		sCMHDZData.sPlayerData[0].vSpriteFinalReticlePos = sCMHDZData.sPlayerData[0].vSpriteInitReticlePos
		sCMHDZData.sPlayerData[0].vSpriteFinalReticlePos.x += vRightStickMod.x
		sCMHDZData.sPlayerData[0].vSpriteFinalReticlePos.y += vRightStickMod.y
		
		IF sCMHDZData.sPlayerData[0].vSpriteFinalReticlePos.x < fLeftLimit
			sCMHDZData.sPlayerData[0].vSpriteFinalReticlePos.x = fLeftLimit
		ENDIF
		
		IF sCMHDZData.sPlayerData[0].vSpriteFinalReticlePos.x > fRightLimit
			sCMHDZData.sPlayerData[0].vSpriteFinalReticlePos.x = fRightLimit
		ENDIF
		
		IF sCMHDZData.sPlayerData[0].vSpriteFinalReticlePos.y < fDownLimit
			sCMHDZData.sPlayerData[0].vSpriteFinalReticlePos.y = fDownLimit
		ENDIF
		
		IF sCMHDZData.sPlayerData[0].vSpriteFinalReticlePos.y > fUpLimit
			sCMHDZData.sPlayerData[0].vSpriteFinalReticlePos.y = fUpLimit
		ENDIF
	ELSE
		
		//-- Mouse
		FLOAT fMouseX= GET_DISABLED_CONTROL_NORMAL(FRONTEND_CONTROL, INPUT_CURSOR_X)
		FLOAT fMouseY= GET_DISABLED_CONTROL_NORMAL(FRONTEND_CONTROL, INPUT_CURSOR_Y)

		fMouseX= GET_DISABLED_CONTROL_NORMAL(PLAYER_CONTROL, INPUT_CURSOR_X)
		fMouseY= GET_DISABLED_CONTROL_NORMAL(PLAYER_CONTROL, INPUT_CURSOR_Y)
		
		VECTOR_2D vTopLeft = INIT_VECTOR_2D(fLeftLimit, fUpLimit)
		VECTOR_2D vBottomRight = INIT_VECTOR_2D(fRightLimit, fDownLimit)
		
		FLOAT fXAxisPlay = vBottomRight.x - vTopLeft.x
		FLOAT fYAxisPlay = vTopLeft.Y - vBottomRight.y
		
		sCMHDZData.sPlayerData[0].vSpriteFinalReticlePos = INIT_VECTOR_2D(vTopLeft.x + (fMouseX * fXAxisPlay), vBottomRight.y + (fMouseY * fYAxisPlay))
	ENDIF

ENDPROC

PROC CMHDZ_HANDLE_PLAYER_MOVEMENT()
	
	CMHDZ_HANDLE_RETICULE_MOVEMENT()
	
ENDPROC

PROC CMHDZ_HANDLE_PLAYER_ABILITIES()
	IF CMHDZ_IS_PLAYER_BIT_SET(CMHDZ_PLAYER_BIT_INVULNERABILE)
		IF GET_GAME_TIMER() - sCMHDZData.sPlayerData[0].iInvulnerableTimer > ciCMHDZ_ITEM_SHIELD_TIME
			CMHDZ_CLEAR_PLAYER_BIT(CMHDZ_PLAYER_BIT_INVULNERABILE)
			//CMHDZ_STOP_SOUND(CMHDZ_AUDIO_EFFECT_PICKUP_SHIELD)
			//CMHDZ_PLAY_SOUND_AND_RELEASE_NO_POSITION(CMHDZ_AUDIO_EFFECT_MUSIC_TRANSITION)
			CMHDZ_STOP_AUDIO_SCENE(CMHDZ_AUDIO_SCENE_POWERUP_ACTIVE)
			CMHDZ_PLAY_DIRECTOR_DIALOGUE(CMHDZ_AUDIO_EFFECT_DIRECTOR_Collectable_Run_Out)
			//sAGPostFXData.sFXLayers[ARCADE_GAMES_POSTFX_LAYER_SCAN_LINE].bShow = FALSE
			sAGPostFXData.sFXLayers[ARCADE_GAMES_POSTFX_LAYER_FLICKERING].bShow = FALSE
			sCMHDZData.fPowerRunTimer = 0.0
			INIT_RGBA_STRUCT(sAGPostFXData.sFXLayers[ARCADE_GAMES_POSTFX_LAYER_SCAN_LINE].rgbaColor,255,255,255,3)
		ENDIF
	ENDIF
	
	IF CMHDZ_IS_PLAYER_BIT_SET(CMHDZ_PLAYER_BIT_HIDE_RETICULE)
		IF GET_GAME_TIMER() - sCMHDZData.sPlayerData[0].iHideReticuleTimer > ciCMHDZ_HIDE_RETICULE_TIME
			CMHDZ_CLEAR_PLAYER_BIT(CMHDZ_PLAYER_BIT_HIDE_RETICULE)
			//CMHDZ_PLAY_SOUND_AND_RELEASE_NO_POSITION(CMHDZ_AUDIO_EFFECT_MUSIC_TRANSITION)
			CMHDZ_STOP_AUDIO_SCENE(CMHDZ_AUDIO_SCENE_POWERUP_ACTIVE)
			CMHDZ_PLAY_DIRECTOR_DIALOGUE(CMHDZ_AUDIO_EFFECT_DIRECTOR_Collectable_Run_Out)
			//sAGPostFXData.sFXLayers[ARCADE_GAMES_POSTFX_LAYER_SCAN_LINE].bShow = FALSE
			sAGPostFXData.sFXLayers[ARCADE_GAMES_POSTFX_LAYER_FLICKERING].bShow = FALSE
			INIT_RGBA_STRUCT(sAGPostFXData.sFXLayers[ARCADE_GAMES_POSTFX_LAYER_SCAN_LINE].rgbaColor,255,255,255,3)
		ENDIF
	ENDIF
	
	IF CMHDZ_IS_PLAYER_BIT_SET(CMHDZ_PLAYER_BIT_QUAD_DAMAGE)
		IF GET_GAME_TIMER() - sCMHDZData.sPlayerData[0].iQuadDamageTimer > ciCMHDZ_ITEM_BUFF_TIME
			CMHDZ_CLEAR_PLAYER_BIT(CMHDZ_PLAYER_BIT_QUAD_DAMAGE)
			//CMHDZ_STOP_SOUND(CMHDZ_AUDIO_EFFECT_PICKUP_BUFF)
			//CMHDZ_PLAY_SOUND_AND_RELEASE_NO_POSITION(CMHDZ_AUDIO_EFFECT_MUSIC_TRANSITION)
			CMHDZ_STOP_AUDIO_SCENE(CMHDZ_AUDIO_SCENE_POWERUP_ACTIVE)
			CMHDZ_PLAY_DIRECTOR_DIALOGUE(CMHDZ_AUDIO_EFFECT_DIRECTOR_Collectable_Run_Out)
			//sAGPostFXData.sFXLayers[ARCADE_GAMES_POSTFX_LAYER_SCAN_LINE].bShow = FALSE
			sAGPostFXData.sFXLayers[ARCADE_GAMES_POSTFX_LAYER_FLICKERING].bShow = FALSE
			sCMHDZData.fPowerRunTimer = 0.0
			INIT_RGBA_STRUCT(sAGPostFXData.sFXLayers[ARCADE_GAMES_POSTFX_LAYER_SCAN_LINE].rgbaColor,255,255,255,3)
		ENDIF
	ENDIF	
	
	IF CMHDZ_IS_PLAYER_BIT_SET(CMHDZ_PLAYER_BIT_INVULNERABILE)
	OR CMHDZ_IS_PLAYER_BIT_SET(CMHDZ_PLAYER_BIT_HIDE_RETICULE)
	OR CMHDZ_IS_PLAYER_BIT_SET(CMHDZ_PLAYER_BIT_QUAD_DAMAGE)
		sCMHDZData.fSoundGlitchAdditional += 0.25
		sCMHDZData.fPowerRunTimer += (0.0+@1000)
	ENDIF
		
ENDPROC

FUNC BOOL CMHDZ_CAN_ENEMY_SHOOT_GUN(INT iEnemy)
	IF sCMHDZData.sEnemyData[iEnemy].vSpritePos.x >= cfRIGHT_SCREEN_LIMIT
		RETURN FALSE
	ENDIF
	
	IF sCMHDZData.sEnemyData[iEnemy].vSpritePos.x <= 300.0
		RETURN FALSE
	ENDIF
	
	IF CMHDZ_IS_ENEMY_TYPE_THROWING_ENEMY(sCMHDZData.sEnemyData[iEnemy].iEnemyType)
		RETURN FALSE
	ENDIF
	
//	IF sCMHDZData.sEnemyData[iEnemy].iEnemyType = CMHDZ_FOREGROUND_ENEMY_BEAR
//		RETURN FALSE
//	ENDIF
	// CMHDZ_ADD_ENEMY_TO_LIST(1398.0, 446.875, 357.875,
	
	FLOAT fPosY
	FLOAT fLocToCheck
	IF CMHDZ_ENEMY_DATA_IS_BITMASK_SET(iEnemy, CMHDZ_ENEMY_DATA_BITS_IS_POPUP)
		fPosY 		= sCMHDZData.sEnemyData[iEnemy].vSpritePos.y
		fLocToCheck	= sCMHDZData.sEnemyData[iEnemy].fStoppingX + 10.0
		
		//CDEBUG2LN(DEBUG_MINIGAME, "[CMHDZ_CAN_ENEMY_SHOOT_GUN] [CMHDZ_ENEMY_STATE_ACTIVE] [dsw] Enemy ", iEnemy, " Is popup Y Pos: ",fPosY, "> ? ", fLocToCheck)
		IF fPosY > fLocToCheck
			//CDEBUG2LN(DEBUG_MINIGAME, "[CMHDZ_CAN_ENEMY_SHOOT_GUN] [CMHDZ_ENEMY_STATE_ACTIVE] [dsw] Enemy ", iEnemy, " FALSE")
			RETURN FALSE
		ENDIF
		
		// Wait till full out before shooting
		IF sCMHDZData.sEnemyData[iEnemy].iPopUpTime < 1500
			RETURN FALSE
		ENDIF
		
		//CDEBUG2LN(DEBUG_MINIGAME, "[CMHDZ_CAN_ENEMY_SHOOT_GUN] [CMHDZ_ENEMY_STATE_ACTIVE] [dsw] Enemy ", iEnemy, " TRUE")
	ENDIF
	
	
	RETURN TRUE
ENDFUNC

PROC CMHDZ_HANDLE_POPUP_ENEMY(INT iEnemy)
	IF NOT CMHDZ_ENEMY_DATA_IS_BITMASK_SET(iEnemy, CMHDZ_ENEMY_DATA_BITS_IS_POPUP)
		EXIT
	ENDIF

	IF sCMHDZData.sEnemyData[iEnemy].vSpritePos.y > sCMHDZData.sEnemyData[iEnemy].fStoppingX
	AND sCMHDZData.sEnemyData[iEnemy].iPopUpTime = 0 // Needs additional condition to stop it freezing in place.
		sCMHDZData.sEnemyData[iEnemy].vSpritePos.y -= (0.45*(0.0+@1000))
		CDEBUG2LN(DEBUG_MINIGAME, "[CMHDZ_HANDLE_ENEMIES] [CMHDZ_ENEMY_STATE_ACTIVE] [CMHDZ_HANDLE_POPUP_ENEMY] Enemy ", iEnemy, " Going up Y pos ", sCMHDZData.sEnemyData[iEnemy].vSpritePos.y, " Stop ", sCMHDZData.sEnemyData[iEnemy].fStoppingX)
	ELSE
		CDEBUG2LN(DEBUG_MINIGAME, "[CMHDZ_HANDLE_ENEMIES] [CMHDZ_ENEMY_STATE_ACTIVE] [CMHDZ_HANDLE_POPUP_ENEMY] Enemy ", iEnemy, " Finished up, grabbing time")
		sCMHDZData.sEnemyData[iEnemy].iPopUpTime += ROUND(0.0+@1000) // Better timer
	ENDIF

	// Don't pop down after popup.
	IF sCMHDZData.eCurrentLevel = CMHDZ_LEVEL_ASYLUM
		EXIT
	ENDIF

	IF sCMHDZData.sEnemyData[iEnemy].iPopUpTime > 3000	
//	OR CMHDZ_ENEMY_DATA_IS_BITMASK_SET(iEnemy, CMHDZ_ENEMY_DATA_BITS_THROWN_PROJECTILE)
		IF sCMHDZData.sEnemyData[iEnemy].vSpritePos.y < sCMHDZData.sEnemyData[iEnemy].vStartPos.y
			CDEBUG2LN(DEBUG_MINIGAME, "[CMHDZ_HANDLE_ENEMIES] [CMHDZ_ENEMY_STATE_ACTIVE] [CMHDZ_HANDLE_POPUP_ENEMY] Enemy ", iEnemy, " Going dowm Y pos ", sCMHDZData.sEnemyData[iEnemy].vSpritePos.y, " Stop ",  sCMHDZData.sEnemyData[iEnemy].vStartPos.y)
			sCMHDZData.sEnemyData[iEnemy].vSpritePos.y += (0.45*(0.0+@1000))
		ELSE
			CDEBUG2LN(DEBUG_MINIGAME, "[CMHDZ_HANDLE_ENEMIES] [CMHDZ_ENEMY_STATE_ACTIVE] [CMHDZ_HANDLE_POPUP_ENEMY] Enemy ", iEnemy, " FINISHED Going dowm Y pos ", sCMHDZData.sEnemyData[iEnemy].vSpritePos.y, " Stop ",  sCMHDZData.sEnemyData[iEnemy].vStartPos.y)
			IF sCMHDZData.sEnemyData[iEnemy].iPopUpTime > 6000
				sCMHDZData.sEnemyData[iEnemy].iPopUpTime = 0
			ENDIF
		ENDIF
	ENDIF

ENDPROC


FUNC BOOL CMHDZ_INIT_THROWN_PLAYER_PROJECTILE(INT iPlayer, CMHDZ_PROJECTILE_TYPES eType, VECTOR_2D vInitialPos)
	#IF IS_DEBUG_BUILD
		//CDEBUG2LN(DEBUG_MINIGAME, "[CMHDZ_INIT_THROWN_PLAYER_PROJECTILE] Called, PLAYER:", iPlayer, " Type: ", CMHDZ_PROJECTILE_TYPES_TO_STRING(eType), " Initial pos: ",vInitialPos.x, ", ", vInitialPos.y)
	#ENDIF
	
	IF sCMHDZData.sPlayerData[iPlayer].iNumberOfThrownProjectiles >= ciCMHDZ_MAX_PLAYER_THROWN_PROJECTILES
		//CDEBUG2LN(DEBUG_MINIGAME, "[CMHDZ_INIT_THROWN_PLAYER_PROJECTILE] PLAYER:", iPlayer, " Too many projectiles - exiting ")
		RETURN FALSE 
	ENDIF
	
	IF (eType = CMHDZ_PROJECTILE_BRICK)
		// Zone in on the nearest enemy coord
		FLOAT fSmallestDistance = -1.0 // Invalid distance
		FLOAT distanceX
		FLOAT distanceY
		FLOAT fDistance
		INT iEnemyToHit = -1
		
		INT i
		REPEAT ciCMHDZ_MAX_ENEMIES i
			IF CMHDZ_SHOULD_COUNT_ENEMY_AS_ALIVE(i)
			AND CMHDZ_IS_ENEMY_ON_SCREEN(i)
			AND sCMHDZData.sEnemyData[i].eState != CMHDZ_ENEMY_STATE_WAITING
				distanceX = vInitialPos.x - sCMHDZData.sEnemyData[i].vSpritePos.x
				distanceY = vInitialPos.y - sCMHDZData.sEnemyData[i].vSpritePos.y
				fDistance = SQRT(distanceX * distanceX + distanceY * distanceY)
				
				// Initialise the value if -1
				IF fSmallestDistance = -1.0
					fSmallestDistance = fDistance
				ENDIF
			
				IF fDistance <= 300
				AND fDistance <= fSmallestDistance
					
					fSmallestDistance = fDistance
	//				IF (sCMHDZData.sEnemyData[i].eState = CMHDZ_ENEMY_STATE_ACTIVE
	//				OR sCMHDZData.sEnemyData[i].eState = CMHDZ_ENEMY_STATE_ATTACKING)
					iEnemyToHit = i
					CDEBUG2LN(DEBUG_MINIGAME, "[BAZ] CMHDZ_INIT_THROWN_PLAYER_PROJECTILE - fDistance = ", fSmallestDistance, " iEnemyToHit = ", iEnemyToHit)
					
				ENDIF
			
			ENDIF
		ENDREPEAT
		
		// Asign the position of the nearest enemy to the projectile.
		IF  fSmallestDistance > -1.0
		AND fSmallestDistance <= 300 // Is in a valid range
		AND iEnemyToHit != -1
			vInitialPos = sCMHDZData.sEnemyData[iEnemyToHit].vSpritePos
			sCMHDZData.sPlayerData[iPlayer].sThrownProjectile[sCMHDZData.sPlayerData[iPlayer].iNumberOfThrownProjectiles].iEnemyInstToHit = iEnemyToHit
			CDEBUG2LN(DEBUG_MINIGAME, "[BAZ] CMHDZ_INIT_THROWN_PLAYER_PROJECTILE - Enemy to be hit: ", sCMHDZData.sPlayerData[iPlayer].sThrownProjectile[sCMHDZData.sPlayerData[iPlayer].iNumberOfThrownProjectiles].iEnemyInstToHit)
		ELSE
			RETURN FALSE
		ENDIF
		
		IF (GET_GAME_TIMER() <= (sCMHDZData.sPlayerData[iPlayer].iLastThrownProjectileTime + sCMHDZData.sPlayerData[iPlayer].iThrownProjectileReloadDelay))
			//CDEBUG2LN(DEBUG_MINIGAME, "[CMHDZ_INIT_THROWN_PLAYER_PROJECTILE] PLAYER:", iPlayer, " Projectile Thrown Too Recently ")
			RETURN FALSE 
		ENDIF	
	ELIF (eType = CMHDZ_PROJECTILE_MOLOTOV)
		vInitialPos.x = (cfBASE_SCREEN_WIDTH/2.0)
		vInitialPos.y = (cfBASE_SCREEN_HEIGHT/2.0)
	ENDIF

	sCMHDZData.sPlayerData[iPlayer].sThrownProjectile[sCMHDZData.sPlayerData[iPlayer].iNumberOfThrownProjectiles].eState = CMHDZ_PROJECTILE_STATE_AIRBORNE
	sCMHDZData.sPlayerData[iPlayer].sThrownProjectile[sCMHDZData.sPlayerData[iPlayer].iNumberOfThrownProjectiles].eType = eType
	sCMHDZData.sPlayerData[iPlayer].sThrownProjectile[sCMHDZData.sPlayerData[iPlayer].iNumberOfThrownProjectiles].vSpritePos = vInitialPos
	
	sCMHDZData.sPlayerData[iPlayer].iLastThrownProjectileTime = GET_GAME_TIMER()
	
	IF (eType != CMHDZ_PROJECTILE_BRICK)
		sCMHDZData.sPlayerData[iPlayer].iThrownProjectilesAmmo --
		
		// turn projectile back into brick when ran out
		IF (sCMHDZData.sPlayerData[iPlayer].iThrownProjectilesAmmo = 0)
			sCMHDZData.sPlayerData[iPlayer].projectileType = CMHDZ_PROJECTILE_BRICK
		ENDIF
	ENDIF 
	
	//Sound effects
	
	CMHDZ_AUDIO_EFFECT eAudioEffect
	
	SWITCH sCMHDZData.sPlayerData[iPlayer].projectileType
	
		CASE CMHDZ_PROJECTILE_BRICK
			eAudioEffect = CMHDZ_AUDIO_EFFECT_PLAYER_BRICK_THROW
		BREAK
	
		CASE CMHDZ_PROJECTILE_MOLOTOV
			eAudioEffect = CMHDZ_AUDIO_EFFECT_PLAYER_MOLOTOV_THROW
		BREAK
	
		CASE CMHDZ_PROJECTILE_NAILBOMB
			eAudioEffect = CMHDZ_AUDIO_EFFECT_PLAYER_NAILBOMB_THROW
		BREAK
		
	ENDSWITCH
	
	CMHDZ_PLAY_SOUND_AND_RELEASE(eAudioEffect, vInitialPos)
	
	RETURN TRUE 
ENDFUNC

PROC CMHDZ_HANDLE_THROWN_PLAYER_PROJECTILES(INT iPlayer)
	INT i
	INT iEnemyID = -1
	REPEAT ciCMHDZ_MAX_PLAYER_THROWN_PROJECTILES i
		SWITCH sCMHDZData.sPlayerData[iPlayer].sThrownProjectile[i].eState
			CASE CMHDZ_PROJECTILE_STATE_AIRBORNE
				sCMHDZData.sPlayerData[iPlayer].sThrownProjectile[i].iSpriteAnimFrame += sCMHDZData.sPlayerData[iPlayer].sThrownProjectile[i].iSlowUpdateFrames
				IF sCMHDZData.sPlayerData[iPlayer].sThrownProjectile[i].iSpriteAnimFrame >= ciCMHDZ_MAX_ENEMY_THROWN_DYNAMITE_ANIM_FRAMES 
					sCMHDZData.sPlayerData[iPlayer].sThrownProjectile[i].eState = 	CMHDZ_PROJECTILE_STATE_IMPACT
					// Add additional enemy states when we implement differences between the projectile weapons
					SWITCH (sCMHDZData.sPlayerData[iPlayer].sThrownProjectile[i].eType)
						CASE CMHDZ_PROJECTILE_MOLOTOV
							CMHDZ_KILL_ALL_ENEMIES_IN_RANGE(sCMHDZData.sPlayerData[iPlayer].sThrownProjectile[i].vSpritePos, 1500)
							TWS_CREATE_FX(sCMHDZData.sPlayerData[iPlayer].sThrownProjectile[i].vSpritePos, CMHDZ_FX_ENEMY_TNT_EXP, 1)
							
							// Damage Bearsy
							IF CMHDZ_IS_BEARSY_ON_SCREEN()
								IF sCMHDZData.sBossData.eCurrentBossState != CMHDZ_BOSS_STATE_INACTIVE
								AND sCMHDZData.sBossData.iActiveLane != ciCMHDZ_LANE_FOREGROUND
									IF sCMHDZData.sBossData.eCurrentBossState != CMHDZ_BOSS_STATE_STUNNED_BACKGROUND
									AND sCMHDZData.sBossData.eCurrentBossState != CMHDZ_BOSS_STATE_WALKING_INV
										sCMHDZData.sBossData.fHealth -= 40
										sCMHDZData.sBossData.bShotThisFrame = TRUE
									ENDIF
								ENDIF
							ENDIF
							
						BREAK
						
						CASE CMHDZ_PROJECTILE_BRICK // If it's the brick stun the enemy it impacts with.
							
								// Make a direct reference from 
							IF sCMHDZData.sPlayerData[iPlayer].sThrownProjectile[i].iEnemyInstToHit != -1
								iEnemyID = sCMHDZData.sPlayerData[iPlayer].sThrownProjectile[i].iEnemyInstToHit
							ENDIF
							
							IF iEnemyID != -1
							AND sCMHDZData.sEnemyData[iEnemyID].iHealth > 0
								IF sCMHDZData.sEnemyData[iEnemyID].iEnemyLane != ciCMHDZ_LANE_POPUP_LHS
								AND sCMHDZData.sEnemyData[iEnemyID].iEnemyLane != ciCMHDZ_LANE_POPUP_RHS
									sCMHDZData.sEnemyData[iEnemyID].fAnimTimer = 2000.0 // 2 second stun time.
									sCMHDZData.sEnemyData[iEnemyID].eState = CMHDZ_ENEMY_STATE_STUNNED 
									
									CMHDZ_PLAY_ENEMY_TYPE_SOUND_AND_RELEASE(sCMHDZData.sEnemyData[iEnemyID].iEnemyType, CMHDZ_AUDIO_EFFECT_ENEMY_INJURED, 
											sCMHDZData.sEnemyData[iEnemyID].vSpritePos, sCMHDZData.sEnemyData[iEnemyID].iEnemyVoiceID)
								ELSE // Just kill popup enemies
									sCMHDZData.sEnemyData[iEnemyID].iHealth = 0
									sCMHDZData.sEnemyData[iEnemyID].fAnimTimer = 0.0
									sCMHDZData.sEnemyData[iEnemyID].eState = CMHDZ_ENEMY_STATE_DYING // If the projectile type is a Molotov
									CMHDZ_ADD_TO_LOCAL_PLAYER_SCORE(CMHDZ_SCORE_TYPE_ENEMY)
								ENDIF
							ENDIF
							
							TWS_CREATE_FX(sCMHDZData.sEnemyData[iEnemyID].vSpritePos, CMHDZ_FX_OUCH, sCMHDZData.sEnemyData[iEnemyID].iEnemyLane)
						BREAK
						
						CASE CMHDZ_PROJECTILE_NAILBOMB
							CMHDZ_STUN_ENEMIES_IN_RANGE(sCMHDZData.sPlayerData[iPlayer].sThrownProjectile[i].vSpritePos, 500)
							TWS_CREATE_FX(sCMHDZData.sPlayerData[iPlayer].sThrownProjectile[i].vSpritePos, CMHDZ_FX_ENEMY_TNT_EXP, 1)
							
							// Damage Bearsy
							IF sCMHDZData.sBossData.eCurrentBossState != CMHDZ_BOSS_STATE_INACTIVE
							AND sCMHDZData.sBossData.iActiveLane = ciCMHDZ_LANE_BACKGROUND
								IF sCMHDZData.sBossData.eCurrentBossState != CMHDZ_BOSS_STATE_STUNNED_BACKGROUND
								AND sCMHDZData.sBossData.eCurrentBossState != CMHDZ_BOSS_STATE_WALKING_INV
									sCMHDZData.sBossData.fHealth -= 20
									sCMHDZData.sBossData.bShotThisFrame = TRUE
								ENDIF
							ENDIF
						BREAK
					ENDSWITCH

					
					//Sound effects

					CMHDZ_AUDIO_EFFECT eAudioEffect

					SWITCH sCMHDZData.sPlayerData[iPlayer].projectileType

						CASE CMHDZ_PROJECTILE_BRICK
							eAudioEffect = CMHDZ_AUDIO_EFFECT_PLAYER_BRICK_HIT
						BREAK

						CASE CMHDZ_PROJECTILE_MOLOTOV
							eAudioEffect = CMHDZ_AUDIO_EFFECT_PLAYER_MOLOTOV_HIT
						BREAK

						CASE CMHDZ_PROJECTILE_NAILBOMB
							eAudioEffect = CMHDZ_AUDIO_EFFECT_PLAYER_NAILBOMB_HIT
						BREAK
						
					ENDSWITCH

					
					CMHDZ_PLAY_SOUND_AND_RELEASE(eAudioEffect, sCMHDZData.sPlayerData[iPlayer].sThrownProjectile[i].vSpritePos)
					
					//
					
					SET_CONTROL_SHAKE(FRONTEND_CONTROL, 100, 20)
				ENDIF
				
			BREAK
			
			CASE CMHDZ_PROJECTILE_STATE_IMPACT
				CMHDZ_RESET_PLAYER_THROWN_PROJECTILE(iPlayer, i)
			BREAK
		ENDSWITCH
	ENDREPEAT
ENDPROC

PROC CMHDZ_INIT_THROWN_ENEMY_PROJECTILE(CMHDZ_PROJECTILE_TYPES eType, VECTOR_2D vInitialPos)
	#IF IS_DEBUG_BUILD
		//CDEBUG2LN(DEBUG_MINIGAME, "[CMHDZ_INIT_THROWN_ENEMY_PROJECTILE] Called, type: ", CMHDZ_PROJECTILE_TYPES_TO_STRING(eType), " Initial pos: ",vInitialPos.x, ", ", vInitialPos.y)
	#ENDIF
	
	IF sCMHDZData.iNumberOfThrownEnemyProjectiles > ciCMHDZ_MAX_ENEMY_PROJECTILES - 1
		//CDEBUG2LN(DEBUG_MINIGAME, "[CMHDZ_INIT_THROWN_ENEMY_PROJECTILE] Too many projectiles - exiting ")
		EXIT
	ENDIF
	
	sCMHDZData.sEnemyProjectiles[sCMHDZData.iNumberOfThrownEnemyProjectiles].eState = CMHDZ_PROJECTILE_STATE_AIRBORNE
	sCMHDZData.sEnemyProjectiles[sCMHDZData.iNumberOfThrownEnemyProjectiles].eType = eType
	sCMHDZData.sEnemyProjectiles[sCMHDZData.iNumberOfThrownEnemyProjectiles].vSpritePos = vInitialPos
ENDPROC

PROC CMHDZ_HANDLE_THROWN_ENEMY_PROJECTILES()
	INT i
	
	
	REPEAT ciCMHDZ_MAX_ENEMY_PROJECTILES i
		SWITCH sCMHDZData.sEnemyProjectiles[i].eState
			CASE CMHDZ_PROJECTILE_STATE_AIRBORNE
				sCMHDZData.sEnemyProjectiles[i].iSpriteAnimFrame += sCMHDZData.sEnemyProjectiles[i].iSlowUpdateFrames
				IF sCMHDZData.sEnemyProjectiles[i].iSpriteAnimFrame >= ciCMHDZ_MAX_ENEMY_THROWN_DYNAMITE_ANIM_FRAMES 
					sCMHDZData.sEnemyProjectiles[i].eState = 	CMHDZ_PROJECTILE_STATE_IMPACT
					SET_CONTROL_SHAKE(FRONTEND_CONTROL, 100, 20)
					
					SWITCH(sCMHDZData.sEnemyProjectiles[i].eType)
						CASE CMHDZ_PROJECTILE_DYNAMITE
							CMHDZ_DAMAGE_PLAYER(CMHDZ_DAMAGE_PLAYER_TYPE_DYNAMITE)
							TWS_CREATE_FX(sCMHDZData.sEnemyProjectiles[i].vSpritePos, CMHDZ_FX_ENEMY_TNT_EXP, 1)
							CMHDZ_PLAY_SOUND_AND_RELEASE(CMHDZ_AUDIO_EFFECT_EXP_DYNAMITE, sCMHDZData.sEnemyProjectiles[i].vSpritePos)
						BREAK
						
						CASE CMHDZ_PROJECTILE_BONE
						CASE CMHDZ_PROJECTILE_JOWL
						CASE CMHDZ_PROJECTILE_LEG
						CASE CMHDZ_PROJECTILE_TROTTER
							CMHDZ_DAMAGE_PLAYER(CMHDZ_DAMAGE_PLAYER_TYPE_SLASH)
							TWS_CREATE_FX(sCMHDZData.sEnemyProjectiles[i].vSpritePos, CMHDZ_FX_BLOOD_SPLAT, 1)
							CMHDZ_PLAY_SOUND_AND_RELEASE(CMHDZ_AUDIO_EFFECT_BEARSY_MEAT_IMPACT, sCMHDZData.sEnemyProjectiles[i].vSpritePos)
						BREAK
						
					ENDSWITCH
				ENDIF				
			BREAK
			
			CASE CMHDZ_PROJECTILE_STATE_IMPACT
				CMHDZ_RESET_ENEMY_THROWN_PROJECTILE(i)
			BREAK
		ENDSWITCH
	ENDREPEAT
ENDPROC

FUNC BOOL CMHDZ_CAN_ENEMY_STOP_TO_CHECK_FOR_COVER(INT iEnemy)
	IF CMHDZ_ENEMY_DATA_IS_BITMASK_SET(iEnemy, CMHDZ_ENEMY_DATA_BITS_IS_POPUP)
		RETURN FALSE
	ENDIF
	
	IF CMHDZ_ENEMY_DATA_IS_BITMASK_SET(iEnemy, CMHDZ_ENEMY_DATA_BITS_THROWN_PROJECTILE)
		RETURN FALSE
	ENDIF
	
	RETURN TRUE
ENDFUNC

FUNC BOOL CMHDZ_SHOULD_CLEANUP_ENEMY_FOR_BEING_OFF_SCREEN(INT iEnemy)
	VECTOR_2D vPos = sCMHDZData.sEnemyData[iEnemy].vSpritePos
	VECTOR_2D vSize = sCMHDZData.sEnemyData[iEnemy].vSize
	vSize.x = ABSF(vSize.x) // Fix the value if the scale is reversed for animation.
	FLOAT fScale = CMHDZ_GET_ENEMY_TYPE_SCALE_FOR_LANE(sCMHDZData.sEnemyData[iEnemy].iEnemyLane)
	BOOL bFromLeft = CMHDZ_ENEMY_DATA_IS_BITMASK_SET(iEnemy, CMHDZ_ENEMY_DATA_BITS_REVERSE)
	BOOL bThrownProjectile = CMHDZ_ENEMY_DATA_IS_BITMASK_SET(iEnemy, CMHDZ_ENEMY_DATA_BITS_THROWN_PROJECTILE)
	
	IF sCMHDZData.sEnemyData[iEnemy].eState = CMHDZ_ENEMY_STATE_ACTIVE
		IF NOT CMHDZ_ENEMY_DATA_IS_BITMASK_SET(iEnemy, CMHDZ_ENEMY_DATA_BITS_APPEARED_ON_SCREEN)
			RETURN FALSE
		ENDIF
	ENDIF
	
	IF vPos.x <( cfLEFT_SCREEN_LIMIT - ( vSize.x * fScale) )
		//-- Enemy is off the left hand side of the screen
		#IF IS_DEBUG_BUILD
		//CPRINTLN(DEBUG_MINIGAME, "[CMHDZ_HANDLE_ENEMIES] [CMHDZ_SHOULD_CLEANUP_ENEMY_FOR_BEING_OFF_SCREEN] {dsw} True Enemy ", iEnemy, " Off LHS Type: ", CMHDZ_ENEMY_TYPES_TO_STRING(sCMHDZData.sEnemyData[iEnemy].iEnemyType), " Pos x ", vPos.x)
		#ENDIF
		RETURN TRUE
	ENDIF
	
	
	IF bFromLeft AND bThrownProjectile AND vPos.x > ( cfRIGHT_SCREEN_LIMIT +  ( vSize.x * fScale) )
		#IF IS_DEBUG_BUILD
		//CPRINTLN(DEBUG_MINIGAME, "[CMHDZ_HANDLE_ENEMIES] [CMHDZ_SHOULD_CLEANUP_ENEMY_FOR_BEING_OFF_SCREEN] {dsw} True Enemy ", iEnemy, " Thrown projectile, off rhs Type: ", CMHDZ_ENEMY_TYPES_TO_STRING(sCMHDZData.sEnemyData[iEnemy].iEnemyType), " Pos x ", vPos.x)
		#ENDIF
		RETURN TRUE
	ENDIF
	
	IF bFromLeft AND CMHDZ_ENEMY_DATA_IS_BITMASK_SET(iEnemy, CMHDZ_ENEMY_DATA_BITS_APPEARED_ON_SCREEN) AND vPos.x > cfBASE_SCREEN_WIDTH * 2.0
		#IF IS_DEBUG_BUILD
		//CPRINTLN(DEBUG_MINIGAME, "[CMHDZ_HANDLE_ENEMIES] [CMHDZ_SHOULD_CLEANUP_ENEMY_FOR_BEING_OFF_SCREEN] {dsw} True Enemy ", iEnemy, " From lhs, far off rhs Type: ", CMHDZ_ENEMY_TYPES_TO_STRING(sCMHDZData.sEnemyData[iEnemy].iEnemyType), " Pos x ", vPos.x)
		#ENDIF
		RETURN TRUE
	ENDIF
//	#IF IS_DEBUG_BUILD
//		IF eType = CMHDZ_COFFIN_ENEMY OR eType = CMHDZ_OUTHOUSE_ENEMY
//			//CPRINTLN(DEBUG_MINIGAME, "[CMHDZ_HANDLE_ENEMIES] [CMHDZ_SHOULD_CLEANUP_ENEMY_FOR_BEING_OFF_SCREEN]")
//			//CPRINTLN(DEBUG_MINIGAME, "[CMHDZ_HANDLE_ENEMIES] [CMHDZ_SHOULD_CLEANUP_ENEMY_FOR_BEING_OFF_SCREEN] Enemy ", iEnemy, " Type: ", CMHDZ_ENEMY_TYPES_TO_STRING(eType), " State: ", CMHDZ_ENEMY_STATE_TO_STRING(sCMHDZData.sEnemyData[iEnemy].eState) )
//			//CPRINTLN(DEBUG_MINIGAME, "[CMHDZ_HANDLE_ENEMIES] [CMHDZ_SHOULD_CLEANUP_ENEMY_FOR_BEING_OFF_SCREEN] Pos: ", vPos.x, ", ", vPos.y, " Ever on screen? ", CMHDZ_ENEMY_DATA_IS_BITMASK_SET(iEnemy, CMHDZ_ENEMY_DATA_BITS_APPEARED_ON_SCREEN), " Shot? ", CMHDZ_ENEMY_DATA_IS_BITMASK_SET(iEnemy, CMHDZ_ENEMY_DATA_BITS_SHOT_AT_LEAST_ONCE))
//			//CPRINTLN(DEBUG_MINIGAME, "[CMHDZ_HANDLE_ENEMIES] [CMHDZ_SHOULD_CLEANUP_ENEMY_FOR_BEING_OFF_SCREEN] Level stopped? ", CMHDZ_IS_LEVEL_STOPPED())
//			//CPRINTLN(DEBUG_MINIGAME, "[CMHDZ_HANDLE_ENEMIES] [CMHDZ_SHOULD_CLEANUP_ENEMY_FOR_BEING_OFF_SCREEN]")
//			
//		ENDIF
//	#ENDIF
	
	IF CMHDZ_IS_LEVEL_STOPPED()
		IF sCMHDZData.sEnemyData[iEnemy].eState = CMHDZ_ENEMY_STATE_ATTACKING
			IF sCMHDZData.sEnemyData[iEnemy].eState = CMHDZ_ENEMY_STATE_ACTIVE
		
				IF vPos.x > ( cfRIGHT_SCREEN_LIMIT )
					#IF IS_DEBUG_BUILD
					//CPRINTLN(DEBUG_MINIGAME, "[CMHDZ_HANDLE_ENEMIES] [CMHDZ_SHOULD_CLEANUP_ENEMY_FOR_BEING_OFF_SCREEN] {dsw} True Enemy ", iEnemy, " Level stopped, off rhs Type: ", CMHDZ_ENEMY_TYPES_TO_STRING(sCMHDZData.sEnemyData[iEnemy].iEnemyType), " Pos x ", vPos.x)
					#ENDIF
					RETURN TRUE
				ELIF vPos.x <= ( 300.0 )
					#IF IS_DEBUG_BUILD
					//CPRINTLN(DEBUG_MINIGAME, "[CMHDZ_HANDLE_ENEMIES] [CMHDZ_SHOULD_CLEANUP_ENEMY_FOR_BEING_OFF_SCREEN] {dsw} True Enemy ", iEnemy, " Level stopped, off lhs Type: ", CMHDZ_ENEMY_TYPES_TO_STRING(sCMHDZData.sEnemyData[iEnemy].iEnemyType), " Pos x ", vPos.x)
					#ENDIF
					RETURN TRUE
				
				ENDIF
			ENDIF
		ENDIF
	ENDIF
	
	IF CMHDZ_ENEMY_DATA_IS_BITMASK_SET(iEnemy, CMHDZ_ENEMY_DATA_BITS_IS_BONUS)

		IF CMHDZ_ENEMY_DATA_IS_BITMASK_SET(iEnemy, CMHDZ_ENEMY_DATA_BITS_APPEARED_ON_SCREEN) 
			IF bFromLeft 
			AND vPos.x >= cfBASE_SCREEN_WIDTH
				RETURN TRUE
			ENDIF
		
			IF !bFromLeft 
			AND vPos.x <= 0.0
				RETURN TRUE
			ENDIF
		ENDIF
	
	ENDIF
	
	RETURN FALSE
ENDFUNC

FUNC BOOL CMHDZ_SHOULD_FORCE_DOORS_OPEN(INT iEnemyCover)
	IF sCMHDZData.sEnemyData[iEnemyCover].iRenderAfterWarpedCount = 0
		IF sCMHDZData.sEnemyData[iEnemyCover].iWarpedForMovingLevelCount > 0
			RETURN TRUE
		ENDIF
	ELSE
		IF sCMHDZData.sEnemyData[iEnemyCover].iWarpedForMovingLevelCount > sCMHDZData.sEnemyData[iEnemyCover].iRenderAfterWarpedCount
			RETURN TRUE
		ENDIF
	ENDIF
	
	RETURN FALSE
ENDFUNC




PROC CMHDZ_HANDLE_ENEMIES()
	
	INT iCurrentGameTime = GET_GAME_TIMER()
//	INT iBlockingCover
	INT i//, j
	VECTOR_2D vThrow
	FLOAT fXpos
	BOOL bCanEnemyEnter
	
//	FLOAT fCoverWidth
//	FLOAT fScale
	FOR i = 0 TO ciCMHDZ_MAX_ENEMIES - 1
//		iBlockingCover = -1
		
		#IF IS_DEBUG_BUILD
//		//CDEBUG2LN(DEBUG_MINIGAME, "[CMHDZ_HANDLE_ENEMIES] [CMHDZ_ENEMY_STATE_ACTIVE] [dsw]")
//		//CDEBUG2LN(DEBUG_MINIGAME, "[CMHDZ_HANDLE_ENEMIES] [CMHDZ_ENEMY_STATE_ACTIVE] [dsw] Processing Enemy: ",i)
//		//CDEBUG2LN(DEBUG_MINIGAME, "[CMHDZ_HANDLE_ENEMIES] [CMHDZ_ENEMY_STATE_ACTIVE] [dsw] 				State: ", CMHDZ_ENEMY_STATE_TO_STRING(sCMHDZData.sEnemyData[i].eState), " Lane: ",sCMHDZData.sEnemyData[i].iEnemyLane, " Type:", CMHDZ_ENEMY_TYPES_TO_STRING(sCMHDZData.sEnemyData[i].iEnemyType))
//		//CDEBUG2LN(DEBUG_MINIGAME, "[CMHDZ_HANDLE_ENEMIES] [CMHDZ_ENEMY_STATE_ACTIVE] [dsw]				Active in stage: ", sCMHDZData.sEnemyData[i].iLevelStage, " Current stage:", CMHDZ_GET_CURRENT_LEVEL_SCREEN())
		#ENDIF
		
		IF NOT CMHDZ_ENEMY_DATA_IS_BITMASK_SET(i, CMHDZ_ENEMY_DATA_BITS_APPEARED_ON_SCREEN)
			IF sCMHDZData.sEnemyData[i].eState = CMHDZ_ENEMY_STATE_ACTIVE
			OR sCMHDZData.sEnemyData[i].eState = CMHDZ_ENEMY_STATE_ATTACKING
			OR sCMHDZData.sEnemyData[i].eState = CMHDZ_ENEMY_STATE_DYING
			OR sCMHDZData.sEnemyData[i].eState = CMHDZ_ENEMY_STATE_DYING_HEADSHOT
				fXpos = sCMHDZData.sEnemyData[i].vSpritePos.x
				IF fXPos > cfLEFT_SCREEN_LIMIT AND fXPos < cfRIGHT_SCREEN_LIMIT	
					#IF IS_DEBUG_BUILD
					//CDEBUG2LN(DEBUG_MINIGAME, "[CMHDZ_HANDLE_ENEMIES] [CMHDZ_ENEMY_STATE_ACTIVE] [dsw] Enemy: ",i, " Appeared on screen. Type: ", CMHDZ_ENEMY_TYPES_TO_STRING(sCMHDZData.sEnemyData[i].iEnemyType), " State: ", CMHDZ_ENEMY_STATE_TO_STRING(sCMHDZData.sEnemyData[i].eState), " Lane: ", sCMHDZData.sEnemyData[i].iEnemyLane)
					#ENDIF
					
					CMHDZ_ENEMY_DATA_SET_BIT_BY_BOOL(i, CMHDZ_ENEMY_DATA_BITS_APPEARED_ON_SCREEN, TRUE)
					sCMHDZData.iTotalNumberOfEnemiesSpawned ++
				ENDIF
			ENDIF
		ENDIF
		
		// Update enemy stopping position to match the screen scrolling.
		IF sCMHDZData.sEnemyData[i].fPointToAppear <= sCMHDZData.fOverallLevelProgression
			IF IS_MOVING_LEVEL()
			AND sCMHDZData.sEnemyData[i].iEnemyLane != ciCMHDZ_LANE_FOREGROUND
			AND sCMHDZData.sEnemyData[i].iEnemyLane != ciCMHDZ_LANE_POPUP_LHS
			AND sCMHDZData.sEnemyData[i].iEnemyLane != ciCMHDZ_LANE_POPUP_RHS
			AND sCMHDZData.sEnemyData[i].fStoppingX > -200
			AND sCMHDZData.sEnemyData[i].fStoppingX < 2000
				sCMHDZData.sEnemyData[i].fStoppingX -= CMHDZ_GET_GENERAL_UPDATE()
			ENDIF
		ENDIF
				
		SWITCH sCMHDZData.sEnemyData[i].eState
		
		CASE CMHDZ_ENEMY_STATE_ACTIVE
		
			#IF IS_DEBUG_BUILD
		//		//CPRINTLN(DEBUG_MINIGAME, "[CMHDZ_HANDLE_ENEMIES] [CMHDZ_IS_COVER_SUITABLE_FOR_ENEMY_TO_USE] {dsw} Start of Active Enemy ", i, " Staggered count: ", sCMHDZData.iStaggeredOnScreenViableCoverCount)
			#ENDIF

			sCMHDZData.sEnemyData[i].iSpriteAnimFrame += sCMHDZData.sEnemyData[i].iSlowUpdateFrames
			IF sCMHDZData.sEnemyData[i].iSpriteAnimFrame >= ciCMHDZ_MAX_ANIM_FRAMES
				sCMHDZData.sEnemyData[i].iSpriteAnimFrame = 0
			ENDIF
			
			
//			IF sCMHDZData.sEnemyData[i].iEnemyType != CMHDZ_CART_1 AND sCMHDZData.sEnemyData[i].iSpriteAnimFrame >= ciCMHDZ_MAX_ANIM_FRAMES
//				sCMHDZData.sEnemyData[i].iSpriteAnimFrame = 0
//			ELIF sCMHDZData.sEnemyData[i].iEnemyType = CMHDZ_CART_1
//				sCMHDZData.sEnemyData[i].iSpriteAnimFrame = 0
//			ENDIF

//			IF sCMHDZData.sEnemyData[i].iHealth <= 0
//				sCMHDZData.sEnemyData[i].eState = CMHDZ_ENEMY_STATE_DYING
//				#IF IS_DEBUG_BUILD
//					//CPRINTLN(DEBUG_MINIGAME, "[CMHDZ_HANDLE_ENEMIES] {dsw} Enemy ", i, "  set as Dying as iHealth <= 0. Type: ", CMHDZ_ENEMY_TYPES_TO_STRING(sCMHDZData.sEnemyData[i].iEnemyType))
//				#ENDIF
//			ENDIF
			
			IF NOT CMHDZ_ENEMY_DATA_IS_BITMASK_SET(i, CMHDZ_ENEMY_DATA_BITS_IS_POPUP)
			AND NOT CMHDZ_ENEMY_DATA_IS_BITMASK_SET(i, CMHDZ_ENEMY_DATA_BITS_IS_BONUS)
			//	//CDEBUG2LN(DEBUG_MINIGAME, "[CMHDZ_HANDLE_ENEMIES] [dsw] [CMHDZ_IS_COVER_SUITABLE_FOR_ENEMY_TO_USE] Enemy ",i , " Comparing sprite x ", sCMHDZData.sEnemyData[i].vSpritePos.x, " wih stopping x ", sCMHDZData.sEnemyData[i].fStoppingX) 
				IF (sCMHDZData.sEnemyData[i].vSpritePos.x >= sCMHDZData.sEnemyData[i].fStoppingX
				AND CMHDZ_ENEMY_DATA_IS_BITMASK_SET(i, CMHDZ_ENEMY_DATA_BITS_REVERSE))
				OR (sCMHDZData.sEnemyData[i].vSpritePos.x <= sCMHDZData.sEnemyData[i].fStoppingX
				AND !CMHDZ_ENEMY_DATA_IS_BITMASK_SET(i, CMHDZ_ENEMY_DATA_BITS_REVERSE))
					//-- If the enemy is about to stop and shoot then check the stop location isn't behind a big bit of cover
					sCMHDZData.sEnemyData[i].eState = CMHDZ_ENEMY_STATE_ATTACKING
											
					//CDEBUG2LN(DEBUG_MINIGAME, "[BAZ] CMHDZ_ENEMY_STATE_ACTIVE - CMHDZ_ENEMY_DATA_BITS_THROWN_PROJECTILE - eState = CMHDZ_ENEMY_STATE_ATTACKING - IS at stoppping position")
					sCMHDZData.sEnemyData[i].iTimeOfLastShot = GET_GAME_TIMER()
				ELSE
					//-- If the ped is stiil on their way to their stopping loc, stop if they happen to pass some suitable cover
					IF sCMHDZData.sEnemyData[i].eState = CMHDZ_ENEMY_STATE_ACTIVE
					AND NOT CMHDZ_ENEMY_DATA_IS_BITMASK_SET(i, CMHDZ_ENEMY_DATA_BITS_THROWN_PROJECTILE)
						IF CMHDZ_IS_COVER_SUITABLE_FOR_ENEMY_TO_USE(sCMHDZData.iViableOnScreenEnemyCoverPoints[sCMHDZData.iStaggeredOnScreenViableCoverCount], i)
							sCMHDZData.sEnemyData[i].eState = CMHDZ_ENEMY_STATE_ATTACKING
							CDEBUG2LN(DEBUG_MINIGAME, "[BAZ] CMHDZ_ENEMY_STATE_ACTIVE - CMHDZ_ENEMY_DATA_BITS_THROWN_PROJECTILE - eState = CMHDZ_ENEMY_STATE_ATTACKING")
							sCMHDZData.sEnemyData[i].iTimeOfLastShot = GET_GAME_TIMER()
						ENDIF
					ENDIF

				ENDIF

			ENDIF
					
			SWITCH sCMHDZData.sEnemyData[i].iEnemyLane
				CASE 2
					IF CMHDZ_ENEMY_DATA_IS_BITMASK_SET(i, CMHDZ_ENEMY_DATA_BITS_REVERSE)
						sCMHDZData.sEnemyData[i].vSpritePos.x += CMHDZ_GET_ENEMY_FOREGROUND_UPDATE(TRUE)
					ELSE
						sCMHDZData.sEnemyData[i].vSpritePos.x -= CMHDZ_GET_ENEMY_FOREGROUND_UPDATE(FALSE)
					ENDIF
				BREAK
				CASE 1
					IF CMHDZ_ENEMY_DATA_IS_BITMASK_SET(i, CMHDZ_ENEMY_DATA_BITS_REVERSE)
						sCMHDZData.sEnemyData[i].vSpritePos.x += CMHDZ_GET_ENEMY_MIDDLE_UPDATE(TRUE)
					ELSE
						sCMHDZData.sEnemyData[i].vSpritePos.x -= CMHDZ_GET_ENEMY_MIDDLE_UPDATE(FALSE)
					ENDIF
				BREAK
				CASE 0
					IF CMHDZ_ENEMY_DATA_IS_BITMASK_SET(i, CMHDZ_ENEMY_DATA_BITS_REVERSE)
						sCMHDZData.sEnemyData[i].vSpritePos.x += CMHDZ_GET_ENEMY_BACKGROUND_UPDATE(TRUE)
					ELSE
						sCMHDZData.sEnemyData[i].vSpritePos.x -= CMHDZ_GET_ENEMY_BACKGROUND_UPDATE(FALSE)
					ENDIF
				BREAK
				
			ENDSWITCH
		
			IF sCMHDZData.sEnemyData[i].eState = CMHDZ_ENEMY_STATE_ACTIVE
				IF CMHDZ_SHOULD_CLEANUP_ENEMY_FOR_BEING_OFF_SCREEN(i)
					#IF IS_DEBUG_BUILD
					//CPRINTLN(DEBUG_MINIGAME, "[CMHDZ_HANDLE_ENEMIES] {dsw} Enemy ", i, " Active but went outside the limits and is being set as inactive. Type: ", CMHDZ_ENEMY_TYPES_TO_STRING(sCMHDZData.sEnemyData[i].iEnemyType))
					#ENDIF
					
					IF CMHDZ_ENEMY_DATA_IS_BITMASK_SET(i, CMHDZ_ENEMY_DATA_BITS_IS_BONUS)
						CMHDZ_PLAY_BONUS_MISSED_AUDIO(i)
					ENDIF
					
					sCMHDZData.sEnemyData[i].eState = CMHDZ_ENEMY_STATE_INACTIVE
					sCMHDZData.iCurrentActiveEnemies[sCMHDZData.sEnemyData[i].iEnemyLane]--
					
//					IF sCMHDZData.iCurrentActiveEnemies[sCMHDZData.sEnemyData[i].iEnemyLane] = ciCMHDZ_LANE_BACKGROUND
//						sCMHDZData.iCurrentActiveEnemies[sCMHDZData.sEnemyData[i].iEnemyLane] = ciCMHDZ_LANE_BACKGROUND
//						//CPRINTLN(DEBUG_MINIGAME, "[CMHDZ_HANDLE_ENEMIES] {dsw} iCurrentActiveEnemies in lane ", sCMHDZData.sEnemyData[i].iEnemyLane, " < 0 (1)")
//					ENDIF
					
					IF sCMHDZData.iCurrentActiveEnemies[sCMHDZData.sEnemyData[i].iEnemyLane] = ciCMHDZ_LANE_FOREGROUND
						CDEBUG2LN(DEBUG_MINIGAME, "[CMHDZ_HANDLE_ENEMIES] {baz} Cleanup foreground enemy off screen")
					ENDIF
				ENDIF
			ENDIF
		BREAK
		
		CASE CMHDZ_ENEMY_STATE_ATTACKING
				
			IF IS_MOVING_LEVEL() AND sCMHDZData.sEnemyData[i].iEnemyLane != ciCMHDZ_LANE_FOREGROUND
				sCMHDZData.sEnemyData[i].vSpritePos.x -= CMHDZ_GET_ENEMY_SHOOTING_UPDATE()
			ENDIF
			
			IF CMHDZ_CAN_ENEMY_SHOOT_GUN(i)
				IF iCurrentGameTime - sCMHDZData.sEnemyData[i].iTimeOfLastShot > ciCMHDZ_ENEMY_TIME_TO_SHOOT - (ENUM_TO_INT(sCMHDZData.eCurrentLevel) * 200)
					sCMHDZData.sEnemyData[i].iTimeOfLastShot = GET_GAME_TIMER()
					
					IF sCMHDZData.sEnemyData[i].iEnemyLane = ciCMHDZ_LANE_FOREGROUND
						TWS_CREATE_FX(INIT_VECTOR_2D(sCMHDZData.sEnemyData[i].vSpritePos.x + cfCMHDZ_FG_ENEMY_1_X_OFFSET, sCMHDZData.sEnemyData[i].vSpritePos.Y - cfCMHDZ_FG_ENEMY_1_Y_OFFSET), CMHDZ_FX_ENEMY_SHOT, sCMHDZData.sEnemyData[i].iEnemyLane)
					ELSE
						IF NOT CMHDZ_IS_ENEMY_TYPE_THROWING_ENEMY(sCMHDZData.sEnemyData[i].iEnemyType)
							TWS_CREATE_FX(INIT_VECTOR_2D(sCMHDZData.sEnemyData[i].vSpritePos.x + cfCMHDZ_BG_ENEMY_1_X_OFFSET, sCMHDZData.sEnemyData[i].vSpritePos.Y + cfCMHDZ_BG_ENEMY_1_Y_OFFSET), CMHDZ_FX_ENEMY_SHOT, sCMHDZData.sEnemyData[i].iEnemyLane)
						ENDIF
					ENDIF
					
					IF GET_PLAYER_TOTAL_AMMO_FOR_ALL_WEAPON_TYPES() <= 0
						IF sCMHDZData.sPlayerData[0].iNoAmmoTimer = 0
							sCMHDZData.sPlayerData[0].iNoAmmoTimer = GET_GAME_TIMER()
							//CPRINTLN(DEBUG_MINIGAME, "[CMHDZ_ARCADE] {DSW} Start iNoAmmoTimer")
						ELSE
							IF GET_GAME_TIMER() - sCMHDZData.sPlayerData[0].iNoAmmoTimer >= ciCMHDZ_PLAYER_CRITICAL_DAMAGE_NO_AMMO_TIME 
								IF sCMHDZData.sPlayerData[0].fHealth > 0.05
									//CPRINTLN(DEBUG_MINIGAME, "[CMHDZ_ARCADE] {DSW} Forcing hit critical as ammo <=0")
									sCMHDZData.sPlayerData[0].fHealth = 0.05
								ENDIF
							ENDIF
						ENDIF
					ELSE
						IF sCMHDZData.sPlayerData[0].iNoAmmoTimer != 0
							sCMHDZData.sPlayerData[0].iNoAmmoTimer = 0
						ENDIF
					ENDIF
					
					IF CMHDZ_ENEMY_DATA_IS_BITMASK_SET(i, CMHDZ_ENEMY_DATA_BITS_WILL_INFLICT_MELEE_DAMAGE)
						CMHDZ_DAMAGE_PLAYER(CMHDZ_DAMAGE_PLAYER_TYPE_SLASH)
						TWS_CREATE_FX(sCMHDZData.sEnemyData[i].vSpritePos, CMHDZ_FX_SLASH_EFFECT, ciCMHDZ_LANE_FOREGROUND)
						CMHDZ_PLAY_ENEMY_TYPE_SOUND_AND_RELEASE(sCMHDZData.sEnemyData[i].iEnemyType, CMHDZ_AUDIO_EFFECT_ENEMY_ATTACK, sCMHDZData.sEnemyData[i].vSpritePos, sCMHDZData.sEnemyData[i].iEnemyVoiceID)
						sCMHDZData.sEnemyData[i].fAnimTimer = 900 // Hold the slash animation for 0.9 secs

						CMHDZ_PLAY_ENEMY_WEAPON_MELEE_SWING_SOUND_AND_RELEASE(sCMHDZData.sEnemyData[i].iEnemyType, sCMHDZData.sEnemyData[i].vSpritePos)
						CMHDZ_PLAY_ENEMY_WEAPON_ATTACK_SOUND_AND_RELEASE(sCMHDZData.sEnemyData[i].iEnemyType, sCMHDZData.sEnemyData[i].vSpritePos)

						IF NOT CMHDZ_ENEMY_DATA_IS_BITMASK_SET(i, CMHDZ_ENEMY_DATA_BITS_PLAYED_WARN_AUDIO)
							CMHDZ_ENEMY_DATA_SET_BIT_BY_BOOL(i, CMHDZ_ENEMY_DATA_BITS_PLAYED_WARN_AUDIO, FALSE)
						ENDIF
					ELSE
						CMHDZ_DAMAGE_PLAYER(CMHDZ_DAMAGE_PLAYER_TYPE_BULLET)
						CMHDZ_PLAY_SOUND_AND_RELEASE(CMHDZ_AUDIO_EFFECT_ENEMY_RIFLE_FIRE, sCMHDZData.sEnemyData[i].vSpritePos)
						CMHDZ_PLAY_ENEMY_WEAPON_ATTACK_SOUND_AND_RELEASE(sCMHDZData.sEnemyData[i].iEnemyType, sCMHDZData.sEnemyData[i].vSpritePos)
					ENDIF
										
					#IF IS_DEBUG_BUILD
					//CPRINTLN(DEBUG_MINIGAME, "[CMHDZ_ARCADE] Player has been hit by enemy ", i, " Ped Pos: ", sCMHDZData.sEnemyData[i].vSpritePos.x, ", ", sCMHDZData.sEnemyData[i].vSpritePos.y, " lane: ", sCMHDZData.sEnemyData[i].iEnemyLane, " Type: ", CMHDZ_ENEMY_TYPES_TO_STRING(sCMHDZData.sEnemyData[i].iEnemyType), " Popup? ",  CMHDZ_ENEMY_DATA_IS_BITMASK_SET(i, CMHDZ_ENEMY_DATA_BITS_IS_POPUP))
					#ENDIF
				ELSE
					//-- Audio for enemy cocking weapon
					IF NOT CMHDZ_ENEMY_DATA_IS_BITMASK_SET(i, CMHDZ_ENEMY_DATA_BITS_PLAYED_AIM_AUDIO)
						//CMHDZ_PLAY_SOUND_AND_RELEASE(CMHDZ_AUDIO_EFFECT_ENEMY_RIFLE_AIM,sCMHDZData.sEnemyData[i].vSpritePos)
						CMHDZ_PLAY_ENEMY_WEAPON_READY_SOUND_AND_RELEASE(sCMHDZData.sEnemyData[i].iEnemyType, sCMHDZData.sEnemyData[i].vSpritePos)
						CMHDZ_ENEMY_DATA_SET_BIT_BY_BOOL(i, CMHDZ_ENEMY_DATA_BITS_PLAYED_AIM_AUDIO)
					ENDIF
				
					//-- Enemies 'laugh' just before they fire a critical shot
					IF NOT CMHDZ_ENEMY_DATA_IS_BITMASK_SET(i, CMHDZ_ENEMY_DATA_BITS_PLAYED_WARN_AUDIO)
						IF iCurrentGameTime - sCMHDZData.sEnemyData[i].iTimeOfLastShot > (ciCMHDZ_ENEMY_TIME_TO_SHOOT - (200)) - 1000
							//IF CMHDZ_GET_LOCAL_PLAYER_HEALTH() <= 0.1 AND CMHDZ_GET_LOCAL_PLAYER_HEALTH() > 0.0
							CMHDZ_ENEMY_DATA_SET_BIT_BY_BOOL(i, CMHDZ_ENEMY_DATA_BITS_PLAYED_WARN_AUDIO, TRUE)
								//CMHDZ_PLAY_SOUND_AND_RELEASE(CMHDZ_AUDIO_EFFECT_ENEMY_CRIT_WARNING, sCMHDZData.sEnemyData[i].vSpritePos)
							CMHDZ_PLAY_ENEMY_TYPE_SOUND_AND_RELEASE(sCMHDZData.sEnemyData[i].iEnemyType, CMHDZ_AUDIO_EFFECT_ENEMY_GLOAT, sCMHDZData.sEnemyData[i].vSpritePos, sCMHDZData.sEnemyData[i].iEnemyVoiceID)
							//ENDIF
						ENDIF
					ENDIF
					
				ENDIF
//			ELIF CMHDZ_IS_BEAR(i)
//				IF iCurrentGameTime - sCMHDZData.sEnemyData[i].iTimeOfLastShot > ciCMHDZ_ENEMY_TIME_TO_SHOOT - (ENUM_TO_INT(sCMHDZData.eCurrentLevel) * 200)
//					sCMHDZData.sEnemyData[i].iTimeOfLastShot = GET_GAME_TIMER()
//					//CPRINTLN(DEBUG_MINIGAME, "[CMHDZ_HANDLE_ENEMIES] {DSW} Bear ", i, " attacking ")
//				ENDIF
			ENDIF
			
	//		IF sCMHDZData.sEnemyData[i].vSpritePos.x < cfLEFT_SCREEN_LIMIT - ( sCMHDZData.sEnemyData[i].vSize.x * CMHDZ_GET_ENEMY_TYPE_SCALE_FOR_LANE(sCMHDZData.sEnemyData[i].iEnemyType, sCMHDZData.sEnemyData[i].iEnemyLane))
	//		OR (sCMHDZData.sEnemyData[i].bReverse AND sCMHDZData.sEnemyData[i].bThrownProjectile AND sCMHDZData.sEnemyData[i].vSpritePos.x > cfRIGHT_SCREEN_LIMIT -  ( sCMHDZData.sEnemyData[i].vSize.x * CMHDZ_GET_ENEMY_TYPE_SCALE_FOR_LANE(sCMHDZData.sEnemyData[i].iEnemyType, sCMHDZData.sEnemyData[i].iEnemyLane)))
			IF CMHDZ_SHOULD_CLEANUP_ENEMY_FOR_BEING_OFF_SCREEN(i)
				#IF IS_DEBUG_BUILD
				//CPRINTLN(DEBUG_MINIGAME, "[CMHDZ_HANDLE_ENEMIES] {dsw} Enemy ", i, " went outside the limits and is being set as inactive. Type: ", CMHDZ_ENEMY_TYPES_TO_STRING(sCMHDZData.sEnemyData[i].iEnemyType))
				#ENDIF
				
				sCMHDZData.sEnemyData[i].eState = CMHDZ_ENEMY_STATE_INACTIVE
				sCMHDZData.iCurrentActiveEnemies[sCMHDZData.sEnemyData[i].iEnemyLane]--
				
				IF sCMHDZData.iCurrentActiveEnemies[sCMHDZData.sEnemyData[i].iEnemyLane] < ciCMHDZ_LANE_BACKGROUND
					sCMHDZData.iCurrentActiveEnemies[sCMHDZData.sEnemyData[i].iEnemyLane] = ciCMHDZ_LANE_BACKGROUND
					//CPRINTLN(DEBUG_MINIGAME, "[CMHDZ_HANDLE_ENEMIES] {dsw} iCurrentActiveEnemies in lane ", sCMHDZData.sEnemyData[i].iEnemyLane, " < 0 (2)")
				ENDIF
			ENDIF
			
			IF CMHDZ_IS_ENEMY_TYPE_THROWING_ENEMY(sCMHDZData.sEnemyData[i].iEnemyType)
				IF NOT CMHDZ_ENEMY_DATA_IS_BITMASK_SET(i, CMHDZ_ENEMY_DATA_BITS_THROWN_PROJECTILE)
					sCMHDZData.sEnemyData[i].iSpriteAnimFrame += sCMHDZData.sEnemyData[i].iSlowUpdateFrames
					IF sCMHDZData.sEnemyData[i].iSpriteAnimFrame > ciCMHDZ_MAX_THROWING_FRAMES -2
						sCMHDZData.sEnemyData[i].iSpriteAnimFrame = ciCMHDZ_MAX_THROWING_FRAMES -2
						CMHDZ_ENEMY_DATA_SET_BIT_BY_BOOL(i, CMHDZ_ENEMY_DATA_BITS_THROWN_PROJECTILE)
						sCMHDZData.sEnemyData[i].iTimeOfLastShot = GET_GAME_TIMER()
						vThrow = sCMHDZData.sEnemyData[i].vSpritePos
						vThrow.x -= 23.75
						vThrow.y -= 95.125
						CMHDZ_INIT_THROWN_ENEMY_PROJECTILE(CMHDZ_PROJECTILE_DYNAMITE, vThrow)
						CMHDZ_PLAY_SOUND_AND_RELEASE(CMHDZ_AUDIO_EFFECT_ENEMY_THROW_DYNAMITE, sCMHDZData.sEnemyData[i].vSpritePos)
						//CPRINTLN(DEBUG_MINIGAME, "[CMHDZ_HANDLE_ENEMIES] {dsw} Enemy ", i, " Throwing projectile")
					ENDIF
				ELIF NOT CMHDZ_ENEMY_DATA_IS_BITMASK_SET(i, CMHDZ_ENEMY_DATA_BITS_IS_POPUP)
					IF GET_GAME_TIMER() - sCMHDZData.sEnemyData[i].iTimeOfLastShot > 1000
						IF CMHDZ_ENEMY_DATA_IS_BITMASK_SET(i, CMHDZ_ENEMY_DATA_BITS_REVERSE)
							sCMHDZData.sEnemyData[i].fStoppingX = 2000.0
						ELSE
							sCMHDZData.sEnemyData[i].fStoppingX = -200.0
						ENDIF
						
						CDEBUG2LN(DEBUG_MINIGAME, "[CMHDZ_HANDLE_ENEMIES] {dsw} Enemy ", i, " has thrown projectile and time expired. Running off screen")
						sCMHDZData.sEnemyData[i].eState = CMHDZ_ENEMY_STATE_ACTIVE
					ENDIF
				ENDIF
			ENDIF
				
			CMHDZ_HANDLE_POPUP_ENEMY(i)
		BREAK
		
		CASE CMHDZ_ENEMY_STATE_STUNNED
		
			IF IS_MOVING_LEVEL()
				sCMHDZData.sEnemyData[i].vSpritePos.x -= CMHDZ_GET_ENEMY_DYING_UPDATE()
			ENDIF
			
			IF sCMHDZData.sEnemyData[i].fAnimTimer > 0
				sCMHDZData.sEnemyData[i].fAnimTimer -= (0.0+@1000)
			ELSE // Stun time over
				// Testing: May have state conflict
				sCMHDZData.sEnemyData[i].eState = CMHDZ_ENEMY_STATE_ACTIVE // Return to active.
			ENDIF
	
		BREAK
		
		CASE CMHDZ_ENEMY_STATE_DYING
		CASE CMHDZ_ENEMY_STATE_DYING_HEADSHOT
		CASE CMHDZ_ENEMY_STATE_DYING_BURNING
			sCMHDZData.sEnemyData[i].fAnimTimer += (0.0+@1000)
			
			IF IS_MOVING_LEVEL()
				sCMHDZData.sEnemyData[i].vSpritePos.x -= CMHDZ_GET_ENEMY_DYING_UPDATE()
			ENDIF
			
			SWITCH sCMHDZData.sEnemyData[i].iEnemyLane
				CASE ciCMHDZ_LANE_FOREGROUND
					sCMHDZData.sEnemyData[i].vSpritePos.y -= (0.5*(0.0+@1000))
				BREAK
				CASE ciCMHDZ_LANE_MIDDLE
					sCMHDZData.sEnemyData[i].vSpritePos.y -= (0.4*(0.0+@1000))
				BREAK
				CASE ciCMHDZ_LANE_BACKGROUND
				CASE ciCMHDZ_LANE_POPUP_LHS
				CASE ciCMHDZ_LANE_POPUP_RHS
					sCMHDZData.sEnemyData[i].vSpritePos.y -= (0.3*(0.0+@1000))
				BREAK
			ENDSWITCH
			
			IF sCMHDZData.sEnemyData[i].fAnimTimer >= 200.0 // Disappear after 0.4 seconds
				
				IF sCMHDZData.sEnemyData[i].eState = CMHDZ_ENEMY_STATE_DYING_BURNING
				//AND sCMHDZData.sEnemyData[i].iEnemyLane = ciCMHDZ_LANE_FOREGROUND
					CDEBUG2LN(DEBUG_MINIGAME, "[BAZ] CMHDZ_HANDLE_ENEMIES - Timing out burning enemy in Foreground")
					//ASSERTLN("[BAZ] CMHDZ_HANDLE_ENEMIES - Timing out burning enemy in Foreground")
				ENDIF
				
				IF sCMHDZData.iCurrentActiveEnemies[sCMHDZData.sEnemyData[i].iEnemyLane] > 0
					sCMHDZData.iCurrentActiveEnemies[sCMHDZData.sEnemyData[i].iEnemyLane]--
				ENDIF
								
				sCMHDZData.sEnemyData[i].fAnimTimer = 0.0			
				sCMHDZData.sEnemyData[i].eState = CMHDZ_ENEMY_STATE_INACTIVE
			ENDIF
			
			// Trigger director commentary
			CMHDZ_HANDLE_DIRECTOR_ONE_OFF_DIALOGUE(CMHDZ_AUDIO_EFFECT_DIRECTOR_Enemy_Kill)
			
		BREAK
		
		CASE CMHDZ_ENEMY_STATE_WAITING
//			IF sCMHDZData.iCurrentActiveEnemies[sCMHDZData.sEnemyData[i].iEnemyLane] != ciCMHDZ_LANE_MIDDLE
//				//CPRINTLN(DEBUG_MINIGAME, "[CMHDZ_ARCADE] {DSW} [CMHDZ_HANDLE_ENEMIES] Active in lane ", sCMHDZData.sEnemyData[i].iEnemyLane, ": ", sCMHDZData.iCurrentActiveEnemies[sCMHDZData.sEnemyData[i].iEnemyLane])
//			ENDIF
			
			//-- Set enemy peds as active, depending on their parameters
			//IF sCMHDZData.iCurrentActiveEnemies[sCMHDZData.sEnemyData[i].iEnemyLane] < ciCMHDZ_LANE_MIDDLE
			bCanEnemyEnter = (sCMHDZData.sEnemyData[i].fPointToAppear <= sCMHDZData.fOverallLevelProgression)
				AND (!CMHDZ_IS_LEVEL_BIT_SET_FOR_CURRENT_LEVEL(CMHDZ_LEVELS_BIT_STOPPED))
			
			// Only bring in the enemy if the static screen phase is valid
			IF CMHDZ_IS_LEVEL_BIT_SET_FOR_CURRENT_LEVEL(CMHDZ_LEVELS_BIT_STOPPED)
			AND IS_BITMASK_ENUM_AS_ENUM_SET(sCMHDZData.sEnemyData[i].eDataBits, CMHDZ_ENEMY_DATA_BITS_WAIT_UNTIL_LEVEL_STATIONARY)
			AND sCMHDZData.sEnemyData[i].iStaticScreenPhase > 0
			AND sCMHDZData.sEnemyData[i].fPointToAppear <= sCMHDZData.fOverallLevelProgression + cfCMHDZ_SCREEN_LENGTH
				bCanEnemyEnter = (sCMHDZData.sEnemyData[i].iStaticScreenPhase = sCMHDZData.iStaticScreenPhase)
			ENDIF
			
			IF bCanEnemyEnter
				IF CMHDZ_ENEMY_DATA_IS_BITMASK_SET(i, CMHDZ_ENEMY_DATA_BITS_WAIT_UNTIL_LEVEL_STATIONARY)
					IF NOT CMHDZ_IS_LEVEL_BIT_SET_FOR_CURRENT_LEVEL(CMHDZ_LEVELS_BIT_STOPPED)
						//-- The ped only appears when the level is stationary, but it is still moving
						RELOOP
					ENDIF
				ENDIF
				
				IF CMHDZ_ENEMY_DATA_IS_BITMASK_SET(i, CMHDZ_ENEMY_DATA_BITS_IS_POPUP)
					IF CMHDZ_ENEMY_DATA_IS_BITMASK_SET(i, CMHDZ_ENEMY_DATA_BITS_WAIT_UNTIL_LEVEL_STATIONARY)

						IF sCMHDZData.iTimeSinceEnemyActive[sCMHDZData.sEnemyData[i].iEnemyLane] = ciCMHDZ_LANE_BACKGROUND
						OR GET_GAME_TIMER() - sCMHDZData.iTimeSinceEnemyActive[sCMHDZData.sEnemyData[i].iEnemyLane] > 1500
							//-- This ped 'pops-up' from behind scenery, but only when the level has stopped scrolling
								
							#IF IS_DEBUG_BUILD
							//CPRINTLN(DEBUG_MINIGAME, "[CMHDZ_ARCADE] {DSW} [CMHDZ_HANDLE_ENEMIES] Setting as SHOOTING stationary pop up enemy ", i, " Lane: ", sCMHDZData.sEnemyData[i].iEnemyLane, " Is popup? ", CMHDZ_ENEMY_DATA_IS_BITMASK_SET(i, CMHDZ_ENEMY_DATA_BITS_IS_POPUP) ," Type: ", CMHDZ_ENEMY_TYPES_TO_STRING(sCMHDZData.sEnemyData[i].iEnemyType))
							#ENDIF
							
							sCMHDZData.iCurrentActiveEnemies[sCMHDZData.sEnemyData[i].iEnemyLane]++
							sCMHDZData.sEnemyData[i].eState = CMHDZ_ENEMY_STATE_ATTACKING

						ENDIF
					ELSE

						//-- This ped pops up behind scenery while the level is moving
						IF CMHDZ_IS_ENEMY_ON_SCREEN(i, cfLEFT_SCREEN_LIMIT)
							#IF IS_DEBUG_BUILD
							//CPRINTLN(DEBUG_MINIGAME, "[CMHDZ_ARCADE] {DSW} [CMHDZ_HANDLE_ENEMIES] Setting as SHOOTING moving pop up enemy ", i, " Lane: ", sCMHDZData.sEnemyData[i].iEnemyLane, " Is popup? ", CMHDZ_ENEMY_DATA_IS_BITMASK_SET(i, CMHDZ_ENEMY_DATA_BITS_IS_POPUP)," Type: ", CMHDZ_ENEMY_TYPES_TO_STRING(sCMHDZData.sEnemyData[i].iEnemyType))
							#ENDIF
							sCMHDZData.iCurrentActiveEnemies[sCMHDZData.sEnemyData[i].iEnemyLane]++
							sCMHDZData.sEnemyData[i].eState = CMHDZ_ENEMY_STATE_ATTACKING
						ENDIF
						
						
					ENDIF
				ELSE // Set the PED active on screen here
					IF sCMHDZData.sEnemyData[i].iRenderAfterWarpedCount = 0
					OR sCMHDZData.sEnemyData[i].iRenderAfterWarpedCount = sCMHDZData.sEnemyData[i].iWarpedForMovingLevelCount
						//-- This is a normal ped who runs into position from either the left or the right of the screev

						sCMHDZData.iCurrentActiveEnemies[sCMHDZData.sEnemyData[i].iEnemyLane]++
						
						#IF IS_DEBUG_BUILD
						//CPRINTLN(DEBUG_MINIGAME, "[CMHDZ_ARCADE] {DSW} [CMHDZ_HANDLE_ENEMIES] Setting as CMHDZ_ENEMY_STATE_ACTIVE enemy ", i, " Lane: ", sCMHDZData.sEnemyData[i].iEnemyLane, " Is popup? ", CMHDZ_ENEMY_DATA_IS_BITMASK_SET(i, CMHDZ_ENEMY_DATA_BITS_IS_POPUP)," Type: ", CMHDZ_ENEMY_TYPES_TO_STRING(sCMHDZData.sEnemyData[i].iEnemyType), " Active in lane: ", sCMHDZData.iCurrentActiveEnemies[sCMHDZData.sEnemyData[i].iEnemyLane])
						#ENDIF
						
						IF CMHDZ_ENEMY_DATA_IS_BITMASK_SET(i, CMHDZ_ENEMY_DATA_BITS_IS_BONUS)
							CMHDZ_PLAY_BONUS_APPEAR_AUDIO(i)
						ENDIF
						
						IF NOT CMHDZ_ENEMY_DATA_IS_BITMASK_SET(i, CMHDZ_ENEMY_DATA_BITS_IS_BONUS)
							CMHDZ_HANDLE_DIRECTOR_ONE_OFF_DIALOGUE(CMHDZ_AUDIO_EFFECT_DIRECTOR_First_Enemy_Appear)
						ENDIF
						
						IF CMHDZ_IS_ENEMY_TYPE_THROWING_ENEMY(sCMHDZData.sEnemyData[i].iEnemyType)
							CMHDZ_SET_HELP_TEXT_BIT(CMHDZ_HELP_TEXT_BIT_DYNAMITE)
						ENDIF

						sCMHDZData.sEnemyData[i].eState = CMHDZ_ENEMY_STATE_ACTIVE
					ENDIF
				ENDIF
				
				
				//ENDIF
			ENDIF
			
			//-- Still want to update the positions of some 'inactive' enemies. generally for when we don't want them to appear from the start
			IF IS_MOVING_LEVEL()
				IF CMHDZ_ENEMY_DATA_IS_BITMASK_SET(i, CMHDZ_ENEMY_DATA_BITS_IS_POPUP)
				//OR (CMHDZ_GET_CURRENT_LEVEL() = CMHDZ_LEVEL_PARK)
				OR sCMHDZData.sEnemyData[i].iRenderAfterWarpedCount > 0
					//IF NOT CMHDZ_ENEMY_DATA_IS_BITMASK_SET(i, CMHDZ_ENEMY_DATA_BITS_WAIT_UNTIL_LEVEL_STATIONARY)
					IF sCMHDZData.fOverallLevelProgression >= sCMHDZData.sEnemyData[i].fPointToAppear
						sCMHDZData.sEnemyData[i].vSpritePos.x -= CMHDZ_GET_ENEMY_WAITING_UPDATE()
					ENDIF
					
					IF sCMHDZData.sEnemyData[i].iRenderAfterWarpedCount > 0
						IF sCMHDZData.sEnemyData[i].vSpritePos.x <= 0
							sCMHDZData.sEnemyData[i].vSpritePos.x = CMHDZ_GET_OFFSET_FOR_ELEMENT_WARP_FOR_CURRENT_LEVEL()
							//CDEBUG2LN(DEBUG_MINIGAME, "[CMHDZ_HANDLE_ENEMIES] [CMHDZ_ENEMY_STATE_WAITING] [OUTHOUSE_WARP] [dsw] Enemy: ",i, " Warped")
							sCMHDZData.sEnemyData[i].iWarpedForMovingLevelCount++
						ENDIF
					ENDIF
				ENDIF
			ENDIF
		BREAK
		ENDSWITCH

	ENDFOR

ENDPROC

////-- Handle NAILGUN gun overheating
//PROC CMHDZ_PROCESS_NAILGUN_GUN_TEMP()
//	FLOAT fTimeOverHeat = cfCMHDZ_NAILGUN_OVERHEAT_TIME_SECONDS
//	FLOAT fTimeCooldown = cfCMHDZ_NAILGUN_COOLDOWN_TIME_SECONDS
//	
//	BOOL bShooting
//	FLOAT fFrameTime = GET_FRAME_TIME()
//	
//	IF CMHDZ_GET_PLAYER_CURRENT_WEAPON() = CMHDZ_PLAYER_WEAPON_NAILGUN
//	
//		bSHooting = (IS_DISABLED_CONTROL_PRESSED(FRONTEND_CONTROL, INPUT_SCRIPT_RT) OR IS_DISABLED_CONTROL_PRESSED(FRONTEND_CONTROL, INPUT_SCRIPT_RDOWN)
//						AND  CMHDZ_GET_LOCAL_PLAYER_HEALTH() > 0.0)
//						
//		IF CMHDZ_IS_PLAYER_BIT_SET(CMHDZ_PLAYER_BIT_NAILGUN_OVERHEAT)
//			IF NOT CMHDZ_IS_PLAYER_BIT_SET(CMHDZ_PLAYER_BIT_NAILGUN_STOPPED_SHOOTING)
//				IF NOT bSHooting
//					CMHDZ_SET_PLAYER_BIT(CMHDZ_PLAYER_BIT_NAILGUN_STOPPED_SHOOTING)
//				ENDIF
//			ENDIF
//			
//			IF bSHooting
//				IF sCMHDZData.sPlayerData[0].iNAILGUNOverheatTime = 0
//				OR (GET_GAME_TIMER() - sCMHDZData.sPlayerData[0].iNAILGUNOverheatTime) > 100
//					sCMHDZData.sPlayerData[0].iNAILGUNOverheatTime = GET_GAME_TIMER()
//					CMHDZ_PLAY_SOUND_AND_RELEASE_NO_POSITION(CMHDZ_AUDIO_EFFECT_SHOOT_NAILGUN_OVERHEAT)
//				ENDIF
//				
//				IF NOT CMHDZ_IS_PLAYER_BIT_SET(CMHDZ_PLAYER_BIT_NAILGUN_STOPPED_SHOOTING)
//					sCMHDZData.sPlayerData[0].fNAILGUNGunTemp = 1.0
//					EXIT
//				ENDIF
//			ENDIF
//			
//			
//			
//			IF sCMHDZData.sPlayerData[0].fNAILGUNGunTemp > 0.0
//				sCMHDZData.sPlayerData[0].fNAILGUNGunTemp -=  (1.0 / (fTimeCooldown/fFrameTime))
//			//	//CDEBUG2LN(DEBUG_MINIGAME, "[CMHDZ_PROCESS_NAILGUN_GUN_TEMP] DECREASE sCMHDZData.sPlayerData[0].fNAILGUNGunTemp = ", sCMHDZData.sPlayerData[0].fNAILGUNGunTemp)
//			ELSE
//				sCMHDZData.sPlayerData[0].fNAILGUNGunTemp = 0.0
//				CMHDZ_CLEAR_PLAYER_BIT(CMHDZ_PLAYER_BIT_NAILGUN_OVERHEAT)
//				CMHDZ_CLEAR_PLAYER_BIT(CMHDZ_PLAYER_BIT_NAILGUN_STOPPED_SHOOTING)
//			ENDIF
//			
//			EXIT
//		ENDIF
//		
//		
//						
//		IF bSHooting
//			IF sCMHDZData.sPlayerData[0].fNAILGUNGunTemp < 1.0
//								
//				IF NOT CMHDZ_IS_PLAYER_BIT_SET(CMHDZ_PLAYER_BIT_NAILGUN_OVERHEAT)
//					sCMHDZData.sPlayerData[0].fNAILGUNGunTemp +=  (1.0 / (fTimeOverHeat/fFrameTime))
//					
//					IF sCMHDZData.sPlayerData[0].fNAILGUNGunTemp >= 1.0
//						CMHDZ_PLAY_SOUND_AND_RELEASE_NO_POSITION(CMHDZ_AUDIO_EFFECT_NAILGUN_OVERHEAT)
//						CMHDZ_SET_PLAYER_BIT(CMHDZ_PLAYER_BIT_NAILGUN_OVERHEAT)
//					ENDIF
////				ELSE
////					IF sCMHDZData.sPlayerData[0].iNAILGUNOverheatTime = 0
////					OR (GET_GAME_TIMER() - sCMHDZData.sPlayerData[0].iNAILGUNOverheatTime) > 100
////						sCMHDZData.sPlayerData[0].iNAILGUNOverheatTime = GET_GAME_TIMER()
////						CMHDZ_PLAY_SOUND_AND_RELEASE_NO_POSITION(CMHDZ_AUDIO_EFFECT_SHOOT_NAILGUN_OVERHEAT)
////					ENDIF
//				ENDIF
//			ELSE
//				sCMHDZData.sPlayerData[0].fNAILGUNGunTemp = 1.0
//			ENDIF
//		ELSE
//			IF sCMHDZData.sPlayerData[0].fNAILGUNGunTemp > 0.0
//				sCMHDZData.sPlayerData[0].fNAILGUNGunTemp -=  (1.0 / (fTimeCooldown/fFrameTime))
//			//	//CDEBUG2LN(DEBUG_MINIGAME, "[CMHDZ_PROCESS_NAILGUN_GUN_TEMP] DECREASE sCMHDZData.sPlayerData[0].fNAILGUNGunTemp = ", sCMHDZData.sPlayerData[0].fNAILGUNGunTemp)
//			ELSE
//				sCMHDZData.sPlayerData[0].fNAILGUNGunTemp = 0.0
//				CMHDZ_CLEAR_PLAYER_BIT(CMHDZ_PLAYER_BIT_NAILGUN_OVERHEAT)
//				CMHDZ_CLEAR_PLAYER_BIT(CMHDZ_PLAYER_BIT_NAILGUN_STOPPED_SHOOTING)
//			ENDIF
//		ENDIF
//	ELSE
//		IF sCMHDZData.sPlayerData[0].fNAILGUNGunTemp != 0.0
//			sCMHDZData.sPlayerData[0].fNAILGUNGunTemp = 0.0
//		ENDIF
//	ENDIF
//ENDPROC

FUNC BOOL CMHDZ_PLAYER_SHOT(INT iPlayer, BOOL bIsMenu)
	
	BOOL bReturn = FALSE
	CMHDZ_PLAYER_WEAPON_DATA weaponData
	
	IF CMHDZ_GET_PLAYER_AMMO_IN_CLIP_FOR_CURRENT_WEAPON() > 0
	OR bIsMenu
		IF  CMHDZ_IS_PLAYER_SHOOTING()
			//-- Shoot pistol
			IF CMHDZ_GET_PLAYER_CURRENT_WEAPON() = GET_PLAYER_DEFAULT_WEAPON()
				IF NOT bIsMenu
					sCMHDZData.sPlayerData[0].weaponData[CMHDZ_PLAYER_WEAPON_TYPE_DEFAULT].iLastShotTime = GET_GAME_TIMER()
				ENDIF
				bReturn = TRUE
			ELSE
				
				IF CMHDZ_GET_PLAYER_CURRENT_WEAPON() = CMHDZ_PLAYER_WEAPON_SHOTGUN
				OR CMHDZ_GET_PLAYER_CURRENT_WEAPON() = CMHDZ_PLAYER_WEAPON_RIFLE
					weaponData = CMHDZ_GET_PLAYER_WEAPON_DATA(CMHDZ_GET_PLAYER_CURRENT_WEAPON())
					IF sCMHDZData.sPlayerData[0].weaponData[CMHDZ_PLAYER_WEAPON_TYPE_SPECIAL].iLastShotTime = 0
					OR GET_GAME_TIMER() - sCMHDZData.sPlayerData[0].weaponData[CMHDZ_PLAYER_WEAPON_TYPE_SPECIAL].iLastShotTime >= weaponData.iMinTimeBetweenShots
						sCMHDZData.sPlayerData[0].weaponData[CMHDZ_PLAYER_WEAPON_TYPE_SPECIAL].iLastShotTime = GET_GAME_TIMER()
						bReturn = TRUE
					ENDIF
				ENDIF
			ENDIF
		ENDIF
		
		//--SHoot NAILGUN gun
		IF (CMHDZ_GET_PLAYER_CURRENT_WEAPON() = CMHDZ_PLAYER_WEAPON_NAILGUN 
		AND (CMHDZ_IS_PLAYER_HOLDING_SHOOT())
		AND GET_GAME_TIMER() - sCMHDZData.sPlayerData[iPlayer].iLastProjectileTime > 100)
//			IF NOT CMHDZ_IS_PLAYER_BIT_SET(CMHDZ_PLAYER_BIT_NAILGUN_OVERHEAT)
				bReturn = TRUE
//			ENDIF
		ENDIF
	ENDIF
	
	IF (bReturn 
	OR (CMHDZ_IS_PLAYER_SHOOTING()
	AND CMHDZ_GET_PLAYER_AMMO_IN_CLIP_FOR_CURRENT_WEAPON() = 0))
		CMHDZ_HANDLE_PLAYER_SHOOTING_AUDIO(bIsMenu)
	ENDIF
	
	RETURN bReturn
ENDFUNC

PROC CMHDZ_HANDLE_PLAYER_RELOADING()
	CMHDZ_PLAYER_WEAPON_TYPE weaponType = sCMHDZData.sPlayerData[0].weaponType
	
	//-- Exit if the gun clip is full
	IF NOT CMHDZ_CAN_PLAYER_CURRNT_WEAPON_BE_RELOADED()
		IF sCMHDZData.sPlayerData[0].bIsReloading[weaponType]
			sCMHDZData.sPlayerData[0].bIsReloading[weaponType] = FALSE
		ENDIF
		
		IF sCMHDZData.sPlayerData[0].weaponData[weaponType].iReloadSingleBulletTime != 0
			sCMHDZData.sPlayerData[0].weaponData[weaponType].iReloadSingleBulletTime = 0
		ENDIF
		
		IF CMHDZ_IS_PLAYER_BIT_SET(CMHDZ_PLAYER_BIT_RELOADED_FIRST_BULLET)
			CMHDZ_CLEAR_PLAYER_BIT(CMHDZ_PLAYER_BIT_RELOADED_FIRST_BULLET)
		ENDIF
		
		EXIT
	ENDIF
	
	//-- Stop reloading if the player shoots after starting to reload.
	IF CMHDZ_GET_PLAYER_AMMO_IN_CLIP_FOR_CURRENT_WEAPON() > 0
		IF CMHDZ_PLAYER_SHOT(0, FALSE)
			IF sCMHDZData.sPlayerData[0].bIsReloading[weaponType]
				sCMHDZData.sPlayerData[0].bIsReloading[weaponType] = FALSE
			ENDIF
			
			IF sCMHDZData.sPlayerData[0].weaponData[weaponType].iReloadSingleBulletTime != 0
				sCMHDZData.sPlayerData[0].weaponData[weaponType].iReloadSingleBulletTime = 0
			ENDIF
			
			IF CMHDZ_IS_PLAYER_BIT_SET(CMHDZ_PLAYER_BIT_RELOADED_FIRST_BULLET)
				CMHDZ_CLEAR_PLAYER_BIT(CMHDZ_PLAYER_BIT_RELOADED_FIRST_BULLET)
			ENDIF
			EXIT
		ENDIF
	ENDIF
	
	IF sCMHDZData.sPlayerData[0].bIsReloading[weaponType]
		CMHDZ_RELOAD_PLAYER_WEAPON()
	ENDIF
	
ENDPROC


PROC CMHDZ_HANDLE_PLAYER_SHOOTING(INT iPlayer, BOOL bIsMenu = FALSE)
	CMHDZ_STOP_LOOPING_WEAPON_AUDIO()
	
	sCMHDZData.sPlayerData[iPlayer].bHasJustShot = FALSE
	sCMHDZData.sPlayerData[iPlayer].eReticuleBits = CMHDZ_RETICLE_BITS_NONE 
	
	// PROCESS BULLETS
//	IF ((CMHDZ_GET_PLAYER_CURRENT_WEAPON() = GET_PLAYER_DEFAULT_WEAPON() AND CMHDZ_IS_PLAYER_SHOOTING())
//		OR (CMHDZ_GET_PLAYER_CURRENT_WEAPON() = CMHDZ_PLAYER_WEAPON_NAILGUN AND IS_DISABLED_CONTROL_PRESSED(FRONTEND_CONTROL, INPUT_SCRIPT_RT) AND GET_GAME_TIMER() - sCMHDZData.sPlayerData[iPlayer].iLastProjectileTime > 100))
//	AND (CMHDZ_GET_PLAYER_AMMO_IN_CLIP_FOR_CURRENT_WEAPON() > 0 AND iPlayer = 0 OR bIsMenu)
	IF CMHDZ_PLAYER_SHOT(iPlayer, bIsMenu)
		IF bIsMenu
		OR CMHDZ_GET_LOCAL_PLAYER_HEALTH() > 0.0
		 
			sCMHDZData.sPlayerData[iPlayer].iLastProjectileTime = GET_GAME_TIMER()
				
			//CPRINTLN(DEBUG_MINIGAME, "TLG - Player shot.")
			SET_BITMASK_ENUM_AS_ENUM(sCMHDZData.sPlayerData[iPlayer].eReticuleBits, CMHDZ_RETICLE_BITS_IS_SHOOTING)
			
			SET_CONTROL_SHAKE(FRONTEND_CONTROL, 100, 20)
			sCMHDZData.sPlayerData[iPlayer].bHasJustShot = TRUE
			
			sCMHDZData.sPlayerData[iPlayer].sBulletData[sCMHDZData.sPlayerData[iPlayer].iProjectileIndex].vSpritePos = sCMHDZData.sPlayerData[iPlayer].vSpriteFinalReticlePos
			
			sCMHDZData.sPlayerData[iPlayer].sBulletData[sCMHDZData.sPlayerData[iPlayer].iProjectileIndex].iSpriteBlastAnimFrame = 0
			sCMHDZData.sPlayerData[iPlayer].sBulletData[sCMHDZData.sPlayerData[iPlayer].iProjectileIndex].bShot = TRUE

			sCMHDZData.sPlayerData[iPlayer].iProjectileIndex = (sCMHDZData.sPlayerData[iPlayer].iProjectileIndex + 1) % ciCMHDZ_MAX_PROJECTILES
		ENDIF
		
		IF NOT bIsMenu
			IF CMHDZ_GET_LOCAL_PLAYER_HEALTH() > 0.0
			AND (sCMHDZData.iFade = 0.0) // bugstar://7148845

				// Do not apply ammo deductions for the editor mode.
				IF sCMHDZData.eClientState != CMHDZ_ARCADE_CLIENT_STATE_EDITOR_ACTIVE
					CMHDZ_INCREASE_SHOT_FIRED_FOR_CURRENT_LEVEL()
					CMHDZ_REDUCE_PLAYER_AMMO_IN_CLIP()
				ENDIF
			ENDIF
		ELSE
//			CMHDZ_HANDLE_PLAYER_SHOOTING_AUDIO(TRUE)
		ENDIF
	ENDIF
	
//	IF sCMHDZData.eClientState = CMHDZ_ARCADE_CLIENT_STATE_PLAYING
//	OR sCMHDZData.eClientState = CMHDZ_ARCADE_CLIENT_STATE_VIEW_LEADERBOARD
//	OR sCMHDZData.eClientState = CMHDZ_ARCADE_CLIENT_STATE_EDIT_LEADERBOARD
	IF !bIsMenu
		IF CMHDZ_GET_LOCAL_PLAYER_HEALTH() > 0.0
			// Reloading.
			IF IS_DISABLED_CONTROL_JUST_PRESSED(FRONTEND_CONTROL, INPUT_SCRIPT_RB)
			OR IS_DISABLED_CONTROL_JUST_PRESSED(FRONTEND_CONTROL, INPUT_FRONTEND_CANCEL)
			OR (IS_USING_KEYBOARD_AND_MOUSE(PLAYER_CONTROL)
			AND IS_DISABLED_CONTROL_JUST_PRESSED(PLAYER_CONTROL, INPUT_AIM))

		
				//-- Check for player reloading
				IF NOT sCMHDZData.sPlayerData[0].bIsReloading[sCMHDZData.sPlayerData[0].weaponType]
					sCMHDZData.sPlayerData[0].bIsReloading[sCMHDZData.sPlayerData[0].weaponType] = TRUE
				ENDIF
			ELIF CMHDZ_IS_PLAYER_THROWING()
			
				IF (sCMHDZData.sPlayerData[0].projectileType != CMHDZ_PROJECTILE_NONE)
					CMHDZ_INIT_THROWN_PLAYER_PROJECTILE(0, sCMHDZData.sPlayerData[0].projectileType, sCMHDZData.sPlayerData[0].vSpriteFinalReticlePos)
				ENDIF
			ELSE
				IF CMHDZ_GET_PLAYER_AMMO_IN_CLIP_FOR_CURRENT_WEAPON() = 0 
				AND NOT CMHDZ_DOES_PLAYER_CURRENT_WEAPON_HAVE_INFINITE_AMMO()
					IF CMHDZ_GET_PLAYER_TOTAL_AMMO_IN_CURRENT_WEAPON(FALSE) > 0
						//-- Check for player shootig empty weapon
//						IF CMHDZ_IS_PLAYER_SHOOTING()
//							CMHDZ_HANDLE_PLAYER_FIRING_EMPTY_WEAPON_AUDIO()
//						ENDIF
					ELSE
						IF sCMHDZData.sPlayerData[0].weaponType = CMHDZ_PLAYER_WEAPON_TYPE_SPECIAL
							CMHDZ_SET_PLAYER_WEAPON_TYPE(CMHDZ_PLAYER_WEAPON_TYPE_DEFAULT)
							CMHDZ_SET_PLAYER_SPECIAL_WEAPON(CMHDZ_PLAYER_WEAPON_NONE, FALSE)
							CMHDZ_INIT_PLAYER_SPECIAL_WEAPON()
						ENDIF
					ENDIF
				ENDIF
			ENDIF 
			
		ENDIF
	ENDIF
		
	INT i
	FOR i = 0  TO ciCMHDZ_MAX_PROJECTILES - 1
	
		IF sCMHDZData.sPlayerData[iPlayer].sBulletData[i].bShot

			sCMHDZData.sPlayerData[iPlayer].sBulletData[i].iSpriteBlastAnimFrame += sCMHDZData.sPlayerData[iPlayer].sBulletData[i].iSlowUpdateFrames
			
			IF bIsMenu
				HANDLE_PLAYER_BULLET_IN_MENU(iPlayer, i)
			ELSE
				HANDLE_PLAYER_BULLET_COLLISION(iPlayer, i)
				
				IF IS_MOVING_LEVEL()
					sCMHDZData.sPlayerData[iPlayer].sBulletData[i].vSpritePos.X -= CMHDZ_GET_PROJECTILE_UPDATE()
				ENDIF
			ENDIF
			
			IF sCMHDZData.sPlayerData[iPlayer].sBulletData[i].iSpriteBlastAnimFrame >= ciCMHDZ_PLAYER_SHOT_MAX_ANIM_FRAMES
				
				sCMHDZData.sPlayerData[iPlayer].sBulletData[i].bShot = FALSE
				sCMHDZData.sPlayerData[iPlayer].sBulletData[i].bHit = FALSE
				sCMHDZData.sPlayerData[iPlayer].sBulletData[i].bHitObject = FALSE 
				sCMHDZData.sPlayerData[iPlayer].sBulletData[i].bPlayedAudio = FALSE
				sCMHDZData.sPlayerData[iPlayer].sBulletData[i].iSpriteBlastAnimFrame = 0
				
			ENDIF
			
		ENDIF
	ENDFOR
	
	//CMHDZ_PROCESS_NAILGUN_GUN_TEMP()
ENDPROC

PROC CMHDZ_PROCESS_MENU_CONTROLS()

//	FLOAT fAxisThresholdMod = cfIAP_CONTROLLER_AXIS_THRESHOLD_MOD
//	
//	FLOAT fRightStickX = GET_DISABLED_CONTROL_NORMAL(FRONTEND_CONTROL, INPUT_SCRIPT_RIGHT_AXIS_X)
//	FLOAT fRightStickY = GET_DISABLED_CONTROL_NORMAL(FRONTEND_CONTROL, INPUT_SCRIPT_RIGHT_AXIS_Y)
	

	
//	fAxisThresholdMod = 0.5
//	
//	//Reticule 1
//	IF fRightStickX < -cfSTICK_THRESHOLD * fAxisThresholdMod AND sCMHDZData.sPlayerData[0].vSpriteFinalReticlePos.x > 0.0
//		sCMHDZData.sPlayerData[0].vSpriteFinalReticlePos.x -= 30 - (BOOL_TO_INT(sCMHDZData.sPlayerData[0].bHoveringEnemy) * 15)
//	ELIF fRightStickX > cfSTICK_THRESHOLD * fAxisThresholdMod AND sCMHDZData.sPlayerData[0].vSpriteFinalReticlePos.x < (cfBASE_SCREEN_WIDTH - 40)
//		sCMHDZData.sPlayerData[0].vSpriteFinalReticlePos.x += 30 - (BOOL_TO_INT(sCMHDZData.sPlayerData[0].bHoveringEnemy) * 15)
//	ENDIF
//	
//	IF fRightStickY < -cfSTICK_THRESHOLD * fAxisThresholdMod AND sCMHDZData.sPlayerData[0].vSpriteFinalReticlePos.y > 20.0
//		sCMHDZData.sPlayerData[0].vSpriteFinalReticlePos.y -= 30 - (BOOL_TO_INT(sCMHDZData.sPlayerData[0].bHoveringEnemy) * 15)
//	ELIF fRightStickY > cfSTICK_THRESHOLD * fAxisThresholdMod AND sCMHDZData.sPlayerData[0].vSpriteFinalReticlePos.y < (cfBASE_SCREEN_HEIGHT - 40)
//		sCMHDZData.sPlayerData[0].vSpriteFinalReticlePos.y += 30 - (BOOL_TO_INT(sCMHDZData.sPlayerData[0].bHoveringEnemy) * 15)
//	ENDIF
	
	CMHDZ_HANDLE_RETICULE_MOVEMENT(FALSE, TRUE)
	
	////CPRINTLN(DEBUG_MINIGAME, "[CMHDZ_ARCADE] RETICULE ", sCMHDZData.sPlayerData[0].vSpriteFinalReticlePos.x, ",", sCMHDZData.sPlayerData[0].vSpriteFinalReticlePos.y)
ENDPROC

/// PURPOSE:
///    Levels are split up into screens. Generally each full span is a single screen.
/// RETURNS: True when all stages complete    
//FUNC INT CMHDZ_GET_SCREEN_PROGRESSION_VALUES()
//	
//	RETURN ROUND(((1920.0) * sCMHDZData.iCurrentScreen)*2.2)
//	
//ENDFUNC

FUNC BOOL CMHDZ_MAINTAIN_PLAYER_CURRENT_LEVEL_PROGRESSION()
	
	// Testing moved check
	IF IS_MOVING_LEVEL() 
		IF CMHDZ_SHOULD_MOVING_LEVEL_STOP()
		AND CMHDZ_GET_TOTAL_NUMBER_OF_ENEMIES_LEFT_ALIVE_FOR_SCREEN() > 0
		AND NOT CMHDZ_IS_LEVEL_STOPPED()
			IF sCMHDZData.iStaticScreenPhase <= 0
				sCMHDZData.iStaticScreenPhase++
			ENDIF
			
			//IF CMHDZ_GET_TOTAL_NUMBER_OF_ENEMIES_LEFT_ALIVE_FOR_CURRENT_PHASE() > 0
			IF sCMHDZData.eCurrentLevel != CMHDZ_LEVEL_SLAUGHTERHOUSE 
				CMHDZ_PLAY_DIRECTOR_DIALOGUE(CMHDZ_AUDIO_EFFECT_DIRECTOR_Get_Ready)
			ENDIF
				
			CMHDZ_SET_HELP_TEXT_BIT(CMHDZ_HELP_TEXT_BIT_MICROAIM)
			CMHDZ_SET_LEVEL_BIT_FOR_CURRENT_LEVEL(CMHDZ_LEVELS_BIT_STOPPED)
			CDEBUG2LN(DEBUG_MINIGAME, "[BAZ] CMHDZ_MAINTAIN_PLAYER_CURRENT_LEVEL_PROGRESSION - CMHDZ_SET_LEVEL_BIT_FOR_CURRENT_LEVEL(CMHDZ_LEVELS_BIT_STOPPED) - sCMHDZData.iStaticScreenPhase: ", sCMHDZData.iStaticScreenPhase)
			//ENDIF
		ENDIF
	ENDIF
	
	// By default we increase the screen count every Set number of pixels
	IF NOT CMHDZ_IS_LEVEL_STOPPED()
	
		
		sCMHDZData.fOverallLevelProgression += (CMHDZ_GET_GENERAL_UPDATE())
					
		// 1 is the minimum screen value so we count from there.
		sCMHDZData.iCurrentScreen = FLOOR(sCMHDZData.fOverallLevelProgression/(cfCMHDZ_SCREEN_LENGTH))
		
	ELSE //CMHDZ_IS_LEVEL_STOPPED()
	
		IF CMHDZ_GET_TOTAL_NUMBER_OF_ENEMIES_LEFT_ALIVE_FOR_CURRENT_PHASE() <= 0
			sCMHDZData.iStaticScreenPhase++
			CDEBUG2LN(DEBUG_MINIGAME,"[BAZ] CMHDZ_MAINTAIN_PLAYER_CURRENT_LEVEL_PROGRESSION - sCMHDZData.iStaticScreenPhase = ", sCMHDZData.iStaticScreenPhase, " CMHDZ_GET_TOTAL_NUMBER_OF_ENEMIES_LEFT_ALIVE_FOR_CURRENT_PHASE =  ", CMHDZ_GET_TOTAL_NUMBER_OF_ENEMIES_LEFT_ALIVE_FOR_CURRENT_PHASE())
		ENDIF
		
		IF CMHDZ_GET_CURRENT_LEVEL_SCREEN() >= CMHDZ_GET_FINAL_SCREEN_IN_CURRENT_LEVEL()
			
			// Update the boss fight if we're in teh final level.
			IF sCMHDZData.eCurrentLevel = CMHDZ_LEVEL_SLAUGHTERHOUSE
				IF CMHDZ_BEARSY_UPDATE()
					//CMHDZ_RESET_SCREEN_TO_STOP_ON()			
					// check for round clear
					CMHDZ_PLAY_SOUND_AND_RELEASE_NO_POSITION(CMHDZ_AUDIO_EFFECT_PLAYER_COMPLETE_LEVEL)
					RETURN TRUE
				ELSE
					RETURN FALSE
				ENDIF
			ENDIF

			IF sCMHDZData.iStaticScreenPhase > CMHDZ_GET_STATIC_SCREEN_PHASE_COUNT()
			//IF CMHDZ_GET_TOTAL_NUMBER_OF_ENEMIES_LEFT_ALIVE_FOR_CURRENT_SCREEN() = 0
				//CDEBUG2LN(DEBUG_MINIGAME, "CMHDZ_MAINTAIN_PLAYER_CURRENT_LEVEL_PROGRESSION - update stage iEnemyLeftInStage = 0")
				CMHDZ_RESET_SCREEN_TO_STOP_ON()
							
				// check for round clear
				CMHDZ_PLAY_SOUND_AND_RELEASE_NO_POSITION(CMHDZ_AUDIO_EFFECT_PLAYER_COMPLETE_LEVEL)
				RETURN TRUE
			ENDIF
			
			RETURN FALSE
		ENDIF
		
		IF sCMHDZData.iStaticScreenPhase > CMHDZ_GET_STATIC_SCREEN_PHASE_COUNT()
			CMHDZ_CLEAR_LEVEL_BIT_FOR_LEVEL(sCMHDZData.eCurrentLevel, CMHDZ_LEVELS_BIT_STOPPED)
			CDEBUG2LN(DEBUG_MINIGAME,"[BAZ] CMHDZ_MAINTAIN_PLAYER_CURRENT_LEVEL_PROGRESSION - Clearing flag - CMHDZ_GET_STATIC_SCREEN_PHASE_COUNT() = ", CMHDZ_GET_STATIC_SCREEN_PHASE_COUNT())
			sCMHDZData.iTotalNumberOfEnemiesKilledForScreen = 0
			sCMHDZData.iStaticScreenPhase = 0
		ENDIF
	
	ENDIF
		
	RETURN FALSE
ENDFUNC

PROC CMHDZ_CHECK_PLAYER_PROGRESS()
	
	IF sCMHDZData.eLevelState = CMHDZ_PLAY
		
		IF CMHDZ_GET_LOCAL_PLAYER_HEALTH() <= 0.0 // OR sCMHDZData.sPlayerData[0].iAmmo <= 0
			CMHDZ_PLAY_SOUND_AND_RELEASE_NO_POSITION(CMHDZ_AUDIO_EFFECT_PLAYER_HEALTH_DEAD)
			//CMHDZ_PLAY_SOUND_AND_RELEASE_NO_POSITION(CMHDZ_AUDIO_EFFECT_PLAYER_DEATH)
		//	sCMHDZData.bFadingOut = TRUE
			sCMHDZData.eLevelState = CMHDZ_WAIT_FOR_DEAD
						
			CDEBUG2LN(DEBUG_MINIGAME, "[CMHDZ_ARCADE] [BAZ] sCMHDZData.eLevelState = WAIT_FOR_DEAD")
			IF NOT IS_BIT_SET(sCMHDZData.iMusicBitset, ENUM_TO_INT(CMHDZ_MUSIC_BIT_STOPPED))
				CMHDZ_TRIGGER_MUSIC_EVENT(CMHDZ_MUSIC_EVENT_STOP)
				SET_BIT(sCMHDZData.iMusicBitset, ENUM_TO_INT(CMHDZ_MUSIC_BIT_STOPPED))
			ENDIF
			
		ELSE 
			
			IF CMHDZ_MAINTAIN_PLAYER_CURRENT_LEVEL_PROGRESSION()
				CDEBUG2LN(DEBUG_MINIGAME, "[CMHDZ_ARCADE] [GD] Level completed")

				sCMHDZData.bLevelsCompleted[ENUM_TO_INT(sCMHDZData.eCurrentLevel)] = TRUE
				sCMHDZData.bFadingOut = TRUE
				sCMHDZData.eLevelState = CMHDZ_FADING_OUT
				CMHDZ_ASIGN_STAR_RATING(sCMHDZData.eCurrentLevel)
				

				IF CMHDZ_ARE_ALL_LEVELS_COMPLETE()
					CMHDZ_MAINTAIN_PLAYER_AWARDS()
					CMHDZ_SEND_TELEMETRY()
				ELSE
					CMHDZ_PLAY_DIRECTOR_DIALOGUE(CMHDZ_AUDIO_EFFECT_DIRECTOR_Complete_Level)
				ENDIF

			ENDIF
		ENDIF
	ELIF sCMHDZData.eLevelState = CMHDZ_WAIT_FOR_DEAD
		IF sCMHDZData.sPlayerData[0].iDeadTime = 0
			sCMHDZData.sPlayerData[0].iDeadTime = GET_GAME_TIMER()
		ELSE
			IF GET_GAME_TIMER() - sCMHDZData.sPlayerData[0].iDeadTime >= ciCMHDZ_WAIT_FOR_DEAD_TIME
				CMHDZ_STOP_AUDIO_SCENE(CMHDZ_AUDIO_SCENE_GAMEPLAY)
				CMHDZ_STOP_SOUND(CMHDZ_AUDIO_EFFECT_LEVEL_BACKGROUND_LOOP)
				CMHDZ_PLAY_DIRECTOR_DIALOGUE(CMHDZ_AUDIO_EFFECT_DIRECTOR_Player_Death)
				CMHDZ_START_AUDIO_SCENE(CMHDZ_AUDIO_SCENE_MENUS)
				
				CDEBUG2LN(DEBUG_MINIGAME, "[CMHDZ_ARCADE] [BAZ] CMHDZ_SET_LOCAL_STATE(CMHDZ_ARCADE_CLIENT_STATE_GAME_OVER)")
				CMHDZ_SET_RESULT_SCREEN_STATE(CMHDZ_RESULT_SCREEN_STATE_INIT)
									
				CMHDZ_ASIGN_STAR_RATING(sCMHDZData.eCurrentLevel)
					
				CMHDZ_SET_LOCAL_STATE(CMHDZ_ARCADE_CLIENT_STATE_GAME_OVER)
			ENDIF
		ENDIF
	ELIF sCMHDZData.eLevelState = CMHDZ_FADING_OUT
		
		IF sCMHDZData.iFade >= 255
			CMHDZ_STOP_SOUND(CMHDZ_AUDIO_EFFECT_LEVEL_BACKGROUND_LOOP)
			CMHDZ_STOP_AUDIO_SCENE(CMHDZ_AUDIO_SCENE_GAMEPLAY)
			CMHDZ_STOP_AUDIO_SCENE(CMHDZ_AUDIO_SCENE_POWERUP_ACTIVE)
						
			CMHDZ_CLEAR_PLAYER_BIT(CMHDZ_PLAYER_BIT_QUAD_DAMAGE)
			CMHDZ_STOP_SOUND(CMHDZ_AUDIO_EFFECT_PICKUP_BUFF)
			
			CMHDZ_CLEAR_PLAYER_BIT(CMHDZ_PLAYER_BIT_INVULNERABILE)
			CMHDZ_STOP_SOUND(CMHDZ_AUDIO_EFFECT_PICKUP_SHIELD)

			// Go to the result screen
			CMHDZ_SET_RESULT_SCREEN_STATE(CMHDZ_RESULT_SCREEN_STATE_INIT)
			CMHDZ_SET_LOCAL_STATE(CMHDZ_ARCADE_CLIENT_STATE_RESULT_SCREEN)
		ENDIF
		
	ENDIF
	
ENDPROC

PROC CMHDZ_PROCESS_CLIENT_STATE_INIT()

	ARCADE_CABINET_COMMON_INITIALIZATION()
	
	CMHDZ_INIT_COLOUR_STRUCTS()
	CMHDZ_INIT_MENU()
	
	CMHDZ_INIT_PLAYER_WEAPON()
	
	CMHDZ_INIT_BOSS_STRUCT()

	CMHDZ_SET_LOCAL_STATE(CMHDZ_ARCADE_CLIENT_STATE_FIB)
	
ENDPROC

// Process REQUESTING ASSETS
//PROC CMHDZ_PROCESS_CLIENT_STATE_REQUESTING_ASSETS()
//
//	IF NOT CMHDZ_LOAD_ALL_TEXTURE_DICTS()
//		CDEBUG2LN(DEBUG_MINIGAME, "CMHDZ_LOAD_ALL_TEXTURE_DICTS - Returning false")
//		EXIT 
//	ENDIF
//	
//	IF NOT ARCADE_GAMES_POSTFX_REQUESTING_ASSETS()
//		CDEBUG2LN(DEBUG_MINIGAME, "[CMHDZ_ARCADE] [BAZ] CMHDZ_PROCESS_CLIENT_STATE_REQUESTING_ASSETS Loading POSTFX assets")
//		EXIT
//	ENDIF
//	
//	IF NOT REQUEST_SCRIPT_AUDIO_BANK("DLC_TUNER/DLC_Tuner_AM_CH")
//		CDEBUG2LN(DEBUG_MINIGAME, "[CMHDZ_ARCADE] [BAZ] CMHDZ_PROCESS_CLIENT_STATE_REQUESTING_ASSETS - Waiting for main audio")
//		EXIT
//	ENDIF
//
////	IF NOT REQUEST_SCRIPT_AUDIO_BANK("DLC_TUNER/DLC_Tuner_AM_CH_Enemy_Vocal")
////		CDEBUG2LN(DEBUG_MINIGAME, "[CMHDZ_ARCADE] [BAZ] CMHDZ_PROCESS_CLIENT_STATE_REQUESTING_ASSETS - Waiting for enemy vocal audio")
////		EXIT
////	ENDIF
//
//	IF NOT REQUEST_SCRIPT_AUDIO_BANK("DLC_TUNER/DLC_Tuner_AM_CH_Dir_Vocal")
//		CDEBUG2LN(DEBUG_MINIGAME, "[CMHDZ_ARCADE] [BAZ] CMHDZ_PROCESS_CLIENT_STATE_REQUESTING_ASSETS - Waiting for Director vocal audio")
//		EXIT
//	ENDIF
//		
//	#IF IS_DEBUG_BUILD
//		#IF CMHDZ_CMDLINE_BOOT_INTO_EDITOR
//			#IF CMHDZ_CMDLINE_EDITOR_NEW		
//				sCMHDZData.sEditor.bEditorActive = TRUE 
//			#ENDIF
//		#ENDIF
//		
//		IF GET_COMMANDLINE_PARAM_EXISTS("sc_BadlandsSkipIntro") OR (CMHDZ_CMDLINE_NO_INTRO = 1)
//			CMHDZ_START_AUDIO_SCENE(CMHDZ_AUDIO_SCENE_MENUS)
//			CMHDZ_SET_LOCAL_STATE(CMHDZ_ARCADE_CLIENT_STATE_TITLE_SCREEN)
//			EXIT
//		ENDIF
//	#ENDIF
//
//	//CMHDZ_SET_LOCAL_STATE(CMHDZ_ARCADE_CLIENT_STATE_FIB)
//
//ENDPROC

FUNC BOOL CMHDZ_PROCESS_CLIENT_STATE_REQUESTING_ASSETS()

	IF NOT CMHDZ_LOAD_ALL_TEXTURE_DICTS()
		CDEBUG2LN(DEBUG_MINIGAME, "CMHDZ_LOAD_ALL_TEXTURE_DICTS - Returning false")
		RETURN FALSE
	ENDIF
	
//	IF NOT ARCADE_GAMES_POSTFX_REQUESTING_ASSETS()
//		CDEBUG2LN(DEBUG_MINIGAME, "[CMHDZ_ARCADE] [BAZ] CMHDZ_PROCESS_CLIENT_STATE_REQUESTING_ASSETS Loading POSTFX assets")
//		RETURN FALSE
//	ENDIF
	
	IF NOT REQUEST_SCRIPT_AUDIO_BANK("DLC_TUNER/DLC_Tuner_AM_CH")
		CDEBUG2LN(DEBUG_MINIGAME, "[CMHDZ_ARCADE] [BAZ] CMHDZ_PROCESS_CLIENT_STATE_REQUESTING_ASSETS - Waiting for main audio")
		RETURN FALSE
	ENDIF

//	IF NOT REQUEST_SCRIPT_AUDIO_BANK("DLC_TUNER/DLC_Tuner_AM_CH_Enemy_Vocal")
//		CDEBUG2LN(DEBUG_MINIGAME, "[CMHDZ_ARCADE] [BAZ] CMHDZ_PROCESS_CLIENT_STATE_REQUESTING_ASSETS - Waiting for enemy vocal audio")
//		EXIT
//	ENDIF

	IF NOT REQUEST_SCRIPT_AUDIO_BANK("DLC_TUNER/DLC_Tuner_AM_CH_Dir_Vocal")
		CDEBUG2LN(DEBUG_MINIGAME, "[CMHDZ_ARCADE] [BAZ] CMHDZ_PROCESS_CLIENT_STATE_REQUESTING_ASSETS - Waiting for Director vocal audio")
		RETURN FALSE
	ENDIF
		
	#IF IS_DEBUG_BUILD
		#IF CMHDZ_CMDLINE_BOOT_INTO_EDITOR
			#IF CMHDZ_CMDLINE_EDITOR_NEW		
				sCMHDZData.sEditor.bEditorActive = TRUE 
			#ENDIF
		#ENDIF
		
		IF GET_COMMANDLINE_PARAM_EXISTS("sc_BadlandsSkipIntro") OR (CMHDZ_CMDLINE_NO_INTRO = 1)
			CMHDZ_START_AUDIO_SCENE(CMHDZ_AUDIO_SCENE_MENUS)
			CMHDZ_SET_LOCAL_STATE(CMHDZ_ARCADE_CLIENT_STATE_TITLE_SCREEN)
			RETURN FALSE
		ENDIF
	#ENDIF

	//CMHDZ_SET_LOCAL_STATE(CMHDZ_ARCADE_CLIENT_STATE_FIB)
	RETURN TRUE
ENDFUNC

//-- Process intro Bink movie
PROC CMHDZ_PROCESS_CLIENT_INTRO()

	//Wait for the intro movie to finish
	CMHDZ_DRAW_MENU_BACKGROUND()
	
	FLOAT fRatioWidth = 1.0 * GET_ASPECT_RATIO_MODIFIER_FROM_ASPECT_RATIO()
	FLOAT fRatioHeight = 1.0
	BOOL bMovieFinished = CMHDZ_DRAW_MOVIE_SEQUENCE(sCMHDZData.bmIdCmhdzIntro, fRatioWidth, fRatioHeight)
//	ARCADE_GAMES_POSTFX_DRAW()
		
	CDEBUG2LN(DEBUG_MINIGAME, "[BAZ] CMHDZ_PROCESS_CLIENT_INTRO - Movie time: ", GET_BINK_MOVIE_TIME(sCMHDZData.bmIdCmhdzIntro))
	
	IF ARE_ANY_CONTROLS_BEING_PRESSED()
		CMHDZ_START_AUDIO_SCENE(CMHDZ_AUDIO_SCENE_MENUS)
		CMHDZ_SET_LOCAL_STATE(CMHDZ_ARCADE_CLIENT_STATE_TITLE_SCREEN)
		//SET_BINK_MOVIE_TIME(sCMHDZData.bmIdCmhdzIntro, 99.0)		
		//CMHDZ_START_MOVIE_FORCE(sCMHDZData.bmIdCmhdzIntro, "CMHDZ_Intro_Static")
		CMHDZ_STOP_TITLE_INTRO_MOVIE(sCMHDZData.bmIdCmhdzIntro)
		CMHDZ_PLAY_SOUND_AND_RELEASE_NO_POSITION(CMHDZ_AUDIO_EFFECT_Logo_Appear)
		TWS_DRAW_FRONT_FX()
		EXIT
	ENDIF
	
	IF NOT bMovieFinished
//		//CDEBUG2LN(DEBUG_MINIGAME, "{DSW} [CMHDZ_PROCESS_CLIENT_INTRO] Movie Time: ", GET_BINK_MOVIE_TIME(sCMHDZData.bmIdCmhdzIntro))
		IF NOT IS_BIT_SET(sCMHDZData.iMusicBitset, ENUM_TO_INT(CMHDZ_MUSIC_BIT_STARTED_INTRO))
			//IF GET_BINK_MOVIE_TIME(sCMHDZData.bmIdCmhdzIntro) >= 0.0
			CMHDZ_TRIGGER_MUSIC_EVENT(CMHDZ_MUSIC_EVENT_INTRO)
			
			//DG_START_MOVIE()
			SET_BIT(sCMHDZData.iMusicBitset, ENUM_TO_INT(CMHDZ_MUSIC_BIT_STARTED_INTRO))
			//ENDIF
		ENDIF
		
		TWS_DRAW_FRONT_FX()
		EXIT // Stop further progress.
	ENDIF
	
	//SCRIPT_ASSERT("[CMHDZ][BAZ] CMHDZ_PROCESS_CLIENT_INTRO")
	CMHDZ_DRAW_MENU_BACKGROUND()
	CMHDZ_DRAW_GAME_SPRITE_DETAILS(CMHDZ_GET_TEXTURE_DICT_NAME(CMHDZ_TEXDICT_CH_TITLES), "CAMHEDZ_TITLE_SCREEN_CHARACTER", 
		INIT_VECTOR_2D(cfBASE_SCREEN_WIDTH/2, (cfBASE_SCREEN_HEIGHT/2)), INIT_VECTOR_2D(782, 1080), 0, sCMHDZData.rgbaSprite)
			
	//CMHDZ_START_MOVIE_FORCE(sCMHDZData.bmIdCmhdzIntro, "CMHDZ_Intro_Static")	
	CMHDZ_STOP_TITLE_INTRO_MOVIE(sCMHDZData.bmIdCmhdzIntro)
	CMHDZ_START_AUDIO_SCENE(CMHDZ_AUDIO_SCENE_MENUS)

	CMHDZ_PLAY_SOUND_AND_RELEASE_NO_POSITION(CMHDZ_AUDIO_EFFECT_Logo_Appear)

	CMHDZ_SET_LOCAL_STATE(CMHDZ_ARCADE_CLIENT_STATE_TITLE_SCREEN)
	
	TWS_DRAW_FRONT_FX()
ENDPROC


PROC CMHDZ_PROCESS_CLIENT_STATE_FIB
	CMHDZ_DRAW_MENU_BACKGROUND()
	CDEBUG2LN(DEBUG_MINIGAME, "[CMHDZ][BAZ] CMHDZ_PROCESS_CLIENT_STATE_FIB")
	
//	CMHDZ_DRAW_GAME_SPRITE(sCMHDZData.tl31BaseTextDict, "ARCADE_FIB", INIT_VECTOR_2D(cfBASE_SCREEN_WIDTH/2, cfBASE_SCREEN_HEIGHT/2), INIT_VECTOR_2D(cfCMHDZ_FIB_SCREEN_WIDTH, cfCMHDZ_FIB_SCREEN_HEIGHT), 0, sCMHDZData.rgbaSprite)
	CMHDZ_DRAW_GAME_SPRITE_DETAILS(CMHDZ_GET_TEXTURE_DICT_NAME(CMHDZ_TEXDICT_FACADE), "BADLANDS_PSA_SCREEN", INIT_VECTOR_2D(cfBASE_SCREEN_WIDTH/2, cfBASE_SCREEN_HEIGHT/2), INIT_VECTOR_2D(cfCMHDZ_PSA_SCREEN_WIDTH, cfCMHDZ_PSA_SCREEN_HEIGHT), 0, sCMHDZData.rgbaSprite)
	
	TWS_DRAW_FRONT_FX()
	
	IF NOT CMHDZ_PROCESS_CLIENT_STATE_REQUESTING_ASSETS()
		EXIT
	ENDIF

	
	IF sCMHDZData.iTimer = 0
		sCMHDZData.iTimer = GET_GAME_TIMER()
	ELSE
		IF GET_GAME_TIMER() - sCMHDZData.iTimer > 5000
		OR CMHDZ_IS_PLAYER_SHOOTING()
			DG_START_MOVIE(sCMHDZData.bmIdCmhdzIntro, "CMHDZ_Intro")  // _1992_DegenatronLogo_720_auto
			sCMHDZData.iTimer = 0
			ARCADE_GAMES_HELP_TEXT_CLEAR()
			CMHDZ_SET_LOCAL_STATE(CMHDZ_ARCADE_CLIENT_STATE_INTRO)
			
		ENDIF
	ENDIF
	
ENDPROC

// Process TITLE SCREEN
PROC CMHDZ_PROCESS_CLIENT_STATE_TITLE_SCREEN()
	
	ARCADE_GAMES_HELP_TEXT_PRINT_FOREVER(ARCADE_GAMES_HELP_TEXT_ENUM_CMHDZ_HELP_MENU)
	
	CMHDZ_TRIGGER_TITLE_MUSIC()
	
	CMHDZ_HANDLE_PLAYER_SHOOTING(0, TRUE)
	CMHDZ_PROCESS_MENU_CONTROLS()
	
	CMHDZ_DRAW_CLIENT_STATE_TITLE_SCREEN()


ENDPROC

PROC CMHDZ_PROCESS_CLIENT_STATE_TITLE_SCREEN_FADE_OUT()
	
	ARCADE_GAMES_HELP_TEXT_PRINT_FOREVER(ARCADE_GAMES_HELP_TEXT_ENUM_CMHDZ_HELP_MENU)

	FLOAT fRatioWidth = 1.0 * GET_ASPECT_RATIO_MODIFIER_FROM_ASPECT_RATIO()
	FLOAT fRatioHeight = 1.0
			
	IF DG_DRAW_MOVIE(sCMHDZData.bmIdCmhdzIntro, fRatioWidth, fRatioHeight)
//#IF IS_DEBUG_BUILD
	OR IS_DISABLED_CONTROL_JUST_PRESSED(FRONTEND_CONTROL, INPUT_FRONTEND_ACCEPT)
	OR IS_DISABLED_CONTROL_JUST_PRESSED(PLAYER_CONTROL, INPUT_ATTACK)
//#ENDIF
		//sCMHDZData.fSyncOffsetY = 700
		CMHDZ_STOP_TITLE_INTRO_MOVIE(sCMHDZData.bmIdCmhdzIntro)
		CMHDZ_SET_LOCAL_STATE(CMHDZ_ARCADE_CLIENT_STATE_LEVEL_SELECTION_MENU)
	ENDIF
	
	IF GET_BINK_MOVIE_TIME(sCMHDZData.bmIdCmhdzIntro) <= 5.0
	
		ARCADE_DRAW_PIXELSPACE_RECT(INIT_VECTOR_2D(cfBASE_SCREEN_WIDTH/2, cfBASE_SCREEN_HEIGHT/2), INIT_VECTOR_2D(cfBASE_SCREEN_WIDTH, cfBASE_SCREEN_HEIGHT), sCMHDZData.rgbaBlack)
	
		CMHDZ_DRAW_GAME_SPRITE_DETAILS(CMHDZ_GET_TEXTURE_DICT_NAME(CMHDZ_TEXDICT_CH_TITLES), "CAMHEDZ_TITLE_SCREEN_CHARACTER", 
			INIT_VECTOR_2D(cfBASE_SCREEN_WIDTH/2, (cfBASE_SCREEN_HEIGHT/2)), INIT_VECTOR_2D(782, 1080), 0, sCMHDZData.rgbaSprite)
	ENDIF
	
	TWS_DRAW_FRONT_FX()
ENDPROC

// Process STATE MENU
PROC CMHDZ_PROCESS_CLIENT_STATE_LEVEL_SELECT_MENU()
	ARCADE_GAMES_HELP_TEXT_PRINT_FOREVER(ARCADE_GAMES_HELP_TEXT_ENUM_CMHDZ_HELP_MENU)
	CMHDZ_TRIGGER_TITLE_MUSIC()
	
	CMHDZ_PROCESS_MENU_CONTROLS()
	CMHDZ_HANDLE_PLAYER_SHOOTING(0, TRUE)
	CMHDZ_DRAW_CLIENT_STATE_MENU()
	CMHDZ_CHECK_PLAYER_RETURNING_TO_MENU(TRUE)
ENDPROC

// Process INIT LEVEL
PROC CMHDZ_PROCESS_CLIENT_STATE_INIT_LEVEL()
	#IF IS_DEBUG_BUILD
	//CDEBUG2LN(DEBUG_MINIGAME, "[CMHDZ_PROCESS_CLIENT_STATE_INIT_LEVEL] {DSW} Called. Level: ", CMHDZ_LEVELS_TO_STRING(CMHDZ_GET_CURRENT_LEVEL()))
	#ENDIF

	ARCADE_GAMES_HELP_TEXT_CLEAR()

	//-- Need to still draw the menu during this frame
	CMHDZ_DRAW_MENU_BACKGROUND()
	TWS_DRAW_FRONT_FX()
	//CMHDZ_DRAW_CLIENT_STATE_MENU()
	
	TEXT_LABEL_31 tl31TextDict = CMHDZ_GET_TEXTURE_DICTIONARY_FOR_LEVEL(sCMHDZData.eCurrentLevel)
	REQUEST_STREAMED_TEXTURE_DICT(tl31TextDict)
	IF NOT HAS_STREAMED_TEXTURE_DICT_LOADED(tl31TextDict)
		//CDEBUG2LN(DEBUG_MINIGAME, "[CMHDZ_ARCADE] {dsw} CMHDZ_PROCESS_CLIENT_STATE_INIT_LEVEL - Loading ", tl31TextDict)
		EXIT
	ENDIF
	
	INT i
	
	// Reset Counter Variables
	CMHDZ_CLEANUP_VARIABLES()
	CMHDZ_INIT_COVER_POINTS(sCMHDZData.eCurrentLevel)
	CMHDZ_INIT_ENEMIES()
	CMHDZ_INIT_PLAYERS()
	CMHDZ_INIT_BACKGROUND(sCMHDZData.eCurrentLevel)
	CMHDZ_INIT_ITEMS()
	CMHDZ_INIT_PLAY_VARIABLES()
	CMHDZ_INIT_SOUND()
	CMHDZ_INIT_BOSS_STRUCT()
	
	CMHDZ_RESET_LOCAL_PLAYER_SCORE_FOR_CURRENT_LEVEL()
	
	CMHDZ_STOP_AUDIO_SCENE(CMHDZ_AUDIO_SCENE_MENUS)
	CMHDZ_START_AUDIO_SCENE(CMHDZ_AUDIO_SCENE_GAMEPLAY)
	
	sCMHDZData.iLocalLevelRunningTime = GET_GAME_TIMER()
	sCMHDZData.iLevelBitset[ENUM_TO_INT(sCMHDZData.eCurrentLevel)] = 0

	sCMHDZData.iTotalLevelShots[sCMHDZData.eCurrentLevel] = 0
	sCMHDZData.iTotalLevelEnemyHits[sCMHDZData.eCurrentLevel] = 0
	sCMHDZData.iTotalLevelEnemyHeadShots[sCMHDZData.eCurrentLevel] = 0
	sCMHDZData.iTotalPowerupsCollected[sCMHDZData.eCurrentLevel] = 0
	sCMHDZData.iStaggeredOnScreenViableCoverCount = 0
	CMHDZ_RESET_SCREEN_TO_STOP_ON()

	REPEAT ciCMHDZ_MAX_LANES i
		sCMHDZData.iCurrentActiveEnemies[i] = 0
		sCMHDZData.iTimeSinceEnemyActive[i] = 0
	ENDREPEAT
	
	sCMHDZData.iResultsScreenTimer = 0
	sCMHDZData.iResultsScreenTimeout = 0
	sCMHDZData.iReturnToMenuTimeout = 0
	
	sCMHDZData.iTotalNumberOfEnemiesKilledForScreen = 0
	
	// New progression trackers
	sCMHDZData.fOverallLevelProgression = 0.0
	sCMHDZData.iStaticScreenPhase = 0
	sCMHDZData.iCurrentScreen = FLOOR(sCMHDZData.fOverallLevelProgression/cfCMHDZ_SCREEN_LENGTH)

	CMHDZ_CLEAR_LEVEL_BIT_FOR_LEVEL(sCMHDZData.eCurrentLevel, CMHDZ_LEVELS_BIT_STOPPED)
	CMHDZ_CLEAR_LEVEL_BIT_FOR_LEVEL(sCMHDZData.eCurrentLevel, CMHDZ_LEVELS_BIT_DONE_RESULTS_SCREEN_AUDIO)
	CMHDZ_CLEAR_LEVEL_BIT_FOR_LEVEL(sCMHDZData.eCurrentLevel, CMHDZ_LEVELS_BIT_ADDED_ON_ACCURACY_BONUS)
	CMHDZ_CLEAR_LEVEL_BIT_FOR_LEVEL(sCMHDZData.eCurrentLevel, CMHDZ_LEVELS_BIT_PLAYED_DEATH_SCREEN_AUDIO)
	CMHDZ_CLEAR_LEVEL_BIT_FOR_LEVEL(sCMHDZData.eCurrentLevel, CMHDZ_LEVELS_BIT_PLAYED_ACCURACY_SCORE_AUDIO)
	CMHDZ_CLEAR_LEVEL_BIT_FOR_LEVEL(sCMHDZData.eCurrentLevel, CMHDZ_LEVELS_BIT_PLAYED_RESULTS_SCORE_AUDIO)
	CMHDZ_CLEAR_LEVEL_BIT_FOR_LEVEL(sCMHDZData.eCurrentLevel, CMHDZ_LEVELS_BIT_PLAYED_DEATH_SCREEN_AUDIO)
	
	IF sCMHDZData.eCurrentLevel = CMHDZ_LEVEL_SCRAPYARD
	OR sCMHDZData.eCurrentLevel = CMHDZ_LEVEL_ASYLUM
		CMHDZ_CLEAR_LEVEL_BIT_FOR_LEVEL(sCMHDZData.eCurrentLevel, CMHDZ_LEVELS_BIT_CHALLENGE_MONKEY_C_MONKEY_DIE_BUNNY_KILL)
	ENDIF
	
	IF sCMHDZData.eCurrentLevel = CMHDZ_LEVEL_PARK
	OR sCMHDZData.eCurrentLevel = CMHDZ_LEVEL_CITY
		CMHDZ_CLEAR_LEVEL_BIT_FOR_LEVEL(sCMHDZData.eCurrentLevel, CMHDZ_LEVELS_BIT_CHALLENGE_MONKEY_C_MONKEY_DIE_MONKEY_KILL)
	ENDIF
		
	IF CMHDZ_GET_LOCAL_PLAYER_HI_SCORE_FOR_LEVEL(CMHDZ_GET_CURRENT_LEVEL_AS_INT()) > 0
		CMHDZ_SET_LEVEL_BIT_FOR_CURRENT_LEVEL(CMHDZ_LEVELS_BIT_REPLAYING_LEVEL)
	ENDIF
	
	CLEAR_BIT(sCMHDZData.iMusicBitset,  ENUM_TO_INT(CMHDZ_MUSIC_BIT_STARTED_TITLE))
	CLEAR_BIT(sCMHDZData.iMusicBitset, ENUM_TO_INT(CMHDZ_MUSIC_BIT_STOPPED))
	CLEAR_BIT(sCMHDZData.iMusicBitset, ENUM_TO_INT(CMHDZ_MUSIC_BIT_DEATH))
	ARCADE_GAMES_HELP_TEXT_CLEAR()
	sAGHelpText.iCurrentHelpTextExpiry = NATIVE_TO_INT(GET_NETWORK_TIME()) + 4000
	
	CMHDZ_SET_LOCAL_STATE(CMHDZ_ARCADE_CLIENT_STATE_PLAYING)
		
	CMHDZ_PREPARE_MUSIC_EVENT(CMHDZ_MUSIC_EVENT_DEATH)
	CMHDZ_PREPARE_MUSIC_EVENT(CMHDZ_MUSIC_EVENT_HIT)
	CMHDZ_PREPARE_MUSIC_EVENT(CMHDZ_MUSIC_EVENT_HIT_ALT)
	
	// Set up help text string
	CMHDZ_SET_HELP_TEXT_BIT(CMHDZ_HELP_TEXT_BIT_SHOOT_AIM)	
	CMHDZ_SET_HELP_TEXT_BIT(CMHDZ_HELP_TEXT_BIT_THROW)

ENDPROC

// Process PLAYING
PROC CMHDZ_PROCESS_CLIENT_STATE_PLAYING()
	#IF IS_DEBUG_BUILD
		IF (sCMHDZData.bDebugPause)
			CMHDZ_DRAW_CLIENT_STATE_PLAYING()
			EXIT 
		ENDIF
	#ENDIF
	
//	//CMHDZ_REPLAY_SYSTEM_UPDATE()
//	IF CMHDZ_IS_REPLAY_SYSTEM_PLAYING_BACK()
//		CMHDZ_DRAW_CLIENT_STATE_PLAYING()
//		EXIT 
//	ENDIF 
	
	CMHDZ_HANDLE_ENEMIES()
	
	CMHDZ_HANDLE_THROWN_ENEMY_PROJECTILES()
	
	CMHDZ_HANDLE_PLAYER_SHOOTING(0)
	CMHDZ_HANDLE_THROWN_PLAYER_PROJECTILES(0)
	CMHDZ_HANDLE_PLAYER_RELOADING()
	
	CMHDZ_HANDLE_PLAYER_MOVEMENT()
	
	CMHDZ_HANDLE_PLAYER_ABILITIES()
	
	CMHDZ_HANDLE_FX()
	
	CMHDZ_CHECK_PLAYER_PROGRESS()
	
	CMHDZ_DRAW_CLIENT_STATE_PLAYING()
	
	CMHDZ_HANDLE_LOOPING_AUDIO()
	
	CMHDZ_MAINTAIN_HELP_TEXT()
	
#IF IS_DEBUG_BUILD
	IF GET_COMMANDLINE_PARAM_EXISTS("sc_BadlandsReturnToMenuInGame") OR (CMHDZ_CMDLINE_RTN_TO_MENU_IN_GAME = 1)
		CMHDZ_CHECK_PLAYER_RETURNING_TO_MENU(TRUE)
	ENDIF
#ENDIF

ENDPROC

// Process PLAYING
PROC CMHDZ_PROCESS_CLIENT_STATE_EDITOR_ACTIVE()
	#IF IS_DEBUG_BUILD
		#IF CMHDZ_CMDLINE_EDITOR_NEW 
	
			IF (sCMHDZData.sEditor.bPlayStage)

				CMHDZ_PROCESS_CLIENT_STATE_PLAYING()
			ELSE
				CMHDZ_HANDLE_RETICULE_MOVEMENT(FALSE)
				//CDEBUG2LN(DEBUG_MINIGAME, "[BAZ]CMHDZ_PROCESS_CLIENT_STATE_EDITOR_ACTIVE - CMHDZ_HANDLE_RETICULE_MOVEMENT")
				CMHDZ_DRAW_CLIENT_STATE_EDITOR_ACTIVE()
			ENDIF

			EXIT 
		#ENDIF 
	#ENDIF
	
	// if the editor isn't defined and somehow we end up here - reset the stage
	CMHDZ_PROCESS_CLIENT_STATE_INIT_LEVEL()
ENDPROC

FUNC BOOL CMHDZ_IS_SCORE_POOR_FOR_CURRENT_LEVEL()
	INT iScore = CMHDZ_GET_LOCAL_PLAYER_SCORE_FOR_LEVEL(CMHDZ_GET_CURRENT_LEVEL_AS_INT())
	
	SWITCH CMHDZ_GET_CURRENT_LEVEL()
		CASE CMHDZ_LEVEL_CITY
			RETURN iScore < 1000
		BREAK
		
		CASE CMHDZ_LEVEL_SCRAPYARD
			RETURN iScore < 1000
		BREAK
		
		CASE CMHDZ_LEVEL_ASYLUM
			RETURN iScore < 1000
		BREAK
		
		CASE CMHDZ_LEVEL_PARK
			RETURN iScore < 1000
		BREAK
		
		CASE CMHDZ_LEVEL_SLAUGHTERHOUSE
			RETURN iScore < 1000
		BREAK
	ENDSWITCH
	RETURN FALSE
ENDFUNC

FUNC BOOL CMHDZ_IS_SCORE_AVERAGE_FOR_CURRENT_LEVEL()
	INT iScore = CMHDZ_GET_LOCAL_PLAYER_SCORE_FOR_LEVEL(CMHDZ_GET_CURRENT_LEVEL_AS_INT())
	
	SWITCH CMHDZ_GET_CURRENT_LEVEL()
		CASE CMHDZ_LEVEL_CITY
			RETURN iScore < 1500
		BREAK
		
		CASE CMHDZ_LEVEL_SCRAPYARD
			RETURN iScore < 1500
		BREAK
		
		CASE CMHDZ_LEVEL_ASYLUM
			RETURN iScore < 1500
		BREAK
		
		CASE CMHDZ_LEVEL_PARK
			RETURN iScore < 1500
		BREAK
		
		CASE CMHDZ_LEVEL_SLAUGHTERHOUSE
			RETURN iScore < 1500
		BREAK
	ENDSWITCH
	
	RETURN FALSE
ENDFUNC

FUNC BOOL CMHDZ_IS_SCORE_BELOW_MAX_FOR_CURRENT_LEVEL()
	INT iScore = CMHDZ_GET_LOCAL_PLAYER_SCORE_FOR_LEVEL(CMHDZ_GET_CURRENT_LEVEL_AS_INT())

	SWITCH CMHDZ_GET_CURRENT_LEVEL()
		CASE CMHDZ_LEVEL_CITY
			RETURN iScore < 10000
		BREAK
		
		CASE CMHDZ_LEVEL_SCRAPYARD
			RETURN iScore < 10000
		BREAK
		
		CASE CMHDZ_LEVEL_ASYLUM
			RETURN iScore < 10000
		BREAK
		
		CASE CMHDZ_LEVEL_PARK
			RETURN iScore < 20000
		BREAK
		
		CASE CMHDZ_LEVEL_SLAUGHTERHOUSE
			RETURN iScore < 100000
		BREAK
	ENDSWITCH
	
	RETURN FALSE
ENDFUNC

FUNC BOOL CMHDZ_IS_SCORE_ABOVE_MAX_FOR_CURRENT_LEVEL()
	INT iScore = CMHDZ_GET_LOCAL_PLAYER_SCORE_FOR_LEVEL(CMHDZ_GET_CURRENT_LEVEL_AS_INT())
	
	SWITCH CMHDZ_GET_CURRENT_LEVEL()
		CASE CMHDZ_LEVEL_CITY
			RETURN iScore >= 10000
		BREAK
		
		CASE CMHDZ_LEVEL_SCRAPYARD
			RETURN iScore >= 10000
		BREAK
		
		CASE CMHDZ_LEVEL_ASYLUM
			RETURN iScore >= 10000
		BREAK
		
		CASE CMHDZ_LEVEL_PARK
			RETURN iScore >= 20000
		BREAK
		
		CASE CMHDZ_LEVEL_SLAUGHTERHOUSE
			RETURN iScore >= 100000
		BREAK
	ENDSWITCH
	
	RETURN FALSE
ENDFUNC

PROC CMHDZ_PROCESS_CLIENT_STATE_GAME_OVER()

	// Reset screen effects
	IF sCMHDZData.fSyncOffsetY != 0.0 
	AND (sCMHDZData.eResultState != CMHDZ_RESULT_SCREEN_STATE_REWIND)
		INIT_RGBA_STRUCT(sCMHDZData.rgbaSprite, 255, 255, 255, 255)
		sCMHDZData.fSyncOffsetY = 0.0
	ENDIF

	CMHDZ_PROCESS_MENU_CONTROLS()
	CMHDZ_HANDLE_PLAYER_SHOOTING(0, TRUE)
	//CMHDZ_REPLAY_SYSTEM_UPDATE()
	CMHDZ_DRAW_CLIENT_STATE_GAME_OVER()
	IF (sCMHDZData.eResultState = CMHDZ_RESULT_SCREEN_STATE_COMPLETE)
		CMHDZ_PLAY_SOUND_AND_RELEASE_NO_POSITION(CMHDZ_AUDIO_EFFECT_MENU_CONTINUE)
		CMHDZ_SET_LOCAL_STATE(CMHDZ_ARCADE_CLIENT_STATE_INIT_LEVEL)
	ENDIF
	
	IF (sCMHDZData.eResultState = CMHDZ_RESULT_SCREEN_STATE_GOTO_LEADERBOARD)
		IF sCMHDZData.bSkipLeaderboard
			CMHDZ_CHECK_PLAYER_RETURNING_TO_MENU(FALSE, TRUE, DEFAULT, TRUE)
		ELSE
			CMHDZ_INIT_GOTO_LEADERBOARD()
			CMHDZ_SET_LOCAL_STATE(CMHDZ_ARCADE_CLIENT_STATE_EDIT_LEADERBOARD)
		ENDIF
	ENDIF
ENDPROC

// Process RESULT SCREEN
PROC CMHDZ_PROCESS_CLIENT_STATE_RESULT_SCREEN()
	BOOL bDoFinalScene
	BOOL bShouldGoToLeaderboard
	STRING sSubtitles
	
	IF sCMHDZData.iResultsScreenTimer = 0
		sCMHDZData.iResultsScreenTimer = GET_GAME_TIMER()
	ENDIF
	IF CMHDZ_ARE_ALL_LEVELS_COMPLETE() AND NOT sCMHDZData.bPlayedOutro
		bDoFinalScene = TRUE
	ENDIF
	
	#IF IS_DEBUG_BUILD
		IF GET_COMMANDLINE_PARAM_EXISTS("sc_badlandsForceOutro") OR (CMHDZ_CMDLINE_FORCE_OUTRO = 1)
			bDoFinalScene = TRUE
		ENDIF
	#ENDIF
	
	// Fix the screen jump
//	IF sCMHDZData.fSyncOffsetY > 0
//		sCMHDZData.fSyncOffsetY -= (0.0+@GET_RANDOM_FLOAT_IN_RANGE(2500.0,4000.0))
//	ELSE
//		sCMHDZData.fSyncOffsetY = 0.0
//	ENDIF
	
	SWITCH (sCMHDZData.eResultState)
		CASE CMHDZ_RESULT_SCREEN_STATE_INIT
			//sCMHDZData.sPlayerData[0].vSpriteFinalReticlePos = INIT_VECTOR_2D(cfBASE_SCREEN_WIDTH/3, cfBASE_SCREEN_HEIGHT/3)
			//CMHDZ_REPLAY_SYSTEM_STOP_RECORDING()
						
			// Display the subtitle if language isn't English				
			IF GET_CURRENT_LANGUAGE() != LANGUAGE_ENGLISH
				sSubtitles = "CMHDZ_LVW1"
				
				SWITCH sCMHDZData.eCurrentLevel
					
					CASE CMHDZ_LEVEL_CITY
						sSubtitles = "CMHDZ_LVW1"
					BREAK 
					
					CASE CMHDZ_LEVEL_SCRAPYARD
						sSubtitles = "CMHDZ_LVW2"
					BREAK 

					CASE CMHDZ_LEVEL_ASYLUM
						sSubtitles = "CMHDZ_LVW3"
					BREAK 
					
					CASE CMHDZ_LEVEL_PARK
						sSubtitles = "CMHDZ_LVW4"
					BREAK 
					
					CASE CMHDZ_LEVEL_SLAUGHTERHOUSE
						sSubtitles = "CMHDZ_LVW5"
					BREAK 
					
				ENDSWITCH
				
				PRINT_NOW(sSubtitles, 8000, 1)
			ENDIF

			CMHDZ_SET_RESULT_SCREEN_STATE(CMHDZ_RESULT_SCREEN_STATE_COMPLETE)
		BREAK
		
		CASE CMHDZ_RESULT_SCREEN_STATE_COMPLETE
			
		//	INT i
			
			IF sCMHDZData.sPlayerData[0].fHealth <= 0.0
				bShouldGoToLeaderboard = TRUE
				IF NOT IS_BIT_SET(sCMHDZData.iMusicBitset, ENUM_TO_INT(CMHDZ_MUSIC_BIT_DEATH))
					CMHDZ_TRIGGER_MUSIC_EVENT(CMHDZ_MUSIC_EVENT_DEATH)
					SET_BIT(sCMHDZData.iMusicBitset, ENUM_TO_INT(CMHDZ_MUSIC_BIT_DEATH))
				ENDIF
				
			//	//CDEBUG2LN(DEBUG_MINIGAME, "[CMHDZ_PROCESS_CLIENT_STATE_RESULT_SCREEN] {DSW} bShouldGoToLeaderboard = TRUE Player health: ", sCMHDZData.sPlayerData[0].fHealth)
			ELSE
				//IF CMHDZ_ARE_ALL_LEVELS_COMPLETE() AND NOT sCMHDZData.bPlayedOutro
				IF bDoFinalScene
					IF (GET_GAME_TIMER() - sCMHDZData.iResultsScreenTimer ) > 14000
					OR (GET_GAME_TIMER() - sCMHDZData.iResultsScreenTimer ) > 2000
					AND CMHDZ_CHECK_FOR_MENU_PROGRESS_BUTTON()
						DG_START_MOVIE(sCMHDZData.bmIdCmhdzOutro, "CMHDZ_Outro")
						CMHDZ_SET_LOCAL_STATE(CMHDZ_ARCADE_CLIENT_STATE_OUTRO_MOVIE)
					ENDIF
				ELSE
					IF (GET_GAME_TIMER() - sCMHDZData.iResultsScreenTimer) > 2000
						CMHDZ_CHECK_PLAYER_RETURNING_TO_MENU(FALSE, TRUE, DEFAULT, TRUE)
					ENDIF
				ENDIF
				
				//-- Audio for results screen
				IF NOT CMHDZ_IS_LEVEL_BIT_SET_FOR_CURRENT_LEVEL(CMHDZ_LEVELS_BIT_DONE_RESULTS_SCREEN_AUDIO)
		//			IF CMHDZ_IS_SCORE_POOR_FOR_CURRENT_LEVEL()
		//				CMHDZ_PLAY_SOUND_AND_RELEASE_NO_POSITION(CMHDZ_AUDIO_EFFECT_PLAYER_SCORE_BAD)
		//			ELIF CMHDZ_IS_SCORE_AVERAGE_FOR_CURRENT_LEVEL()
		//				CMHDZ_PLAY_SOUND_AND_RELEASE_NO_POSITION(CMHDZ_AUDIO_EFFECT_PLAYER_SCORE_AVERAGE)
					//EL
					IF CMHDZ_IS_SCORE_BELOW_MAX_FOR_CURRENT_LEVEL()
						//CMHDZ_PLAY_SOUND_AND_RELEASE_NO_POSITION(CMHDZ_AUDIO_EFFECT_PLAYER_SCORE_GOOD)
						CMHDZ_PLAY_DIRECTOR_DIALOGUE(CMHDZ_AUDIO_EFFECT_DIRECTOR_Score_Ok)
					ELIF CMHDZ_IS_SCORE_ABOVE_MAX_FOR_CURRENT_LEVEL()
						CMHDZ_PLAY_DIRECTOR_DIALOGUE(CMHDZ_AUDIO_EFFECT_DIRECTOR_Score_Good)
					ENDIF
					
					CMHDZ_SET_LEVEL_BIT_FOR_CURRENT_LEVEL(CMHDZ_LEVELS_BIT_DONE_RESULTS_SCREEN_AUDIO)
				ENDIF
			ENDIF
			

			
			IF bShouldGoToLeaderboard
				IF sCMHDZData.bSkipLeaderboard
					CMHDZ_CHECK_PLAYER_RETURNING_TO_MENU(FALSE, TRUE, DEFAULT, TRUE)
				ELSE
					IF IS_DISABLED_CONTROL_JUST_PRESSED(FRONTEND_CONTROL, INPUT_FRONTEND_CANCEL) 
					OR IS_DISABLED_CONTROL_JUST_PRESSED(FRONTEND_CONTROL, INPUT_FRONTEND_ACCEPT)
					OR (GET_GAME_TIMER() - sCMHDZData.iResultsScreenTimer ) > 14000
						CMHDZ_INIT_GOTO_LEADERBOARD()
						CMHDZ_SET_LOCAL_STATE(CMHDZ_ARCADE_CLIENT_STATE_EDIT_LEADERBOARD)
					ENDIF
				ENDIF
			ENDIF
					
		BREAK
		
	ENDSWITCH

	
	CMHDZ_DRAW_CLIENT_STATE_RESULT_SCREEN(bDoFinalScene)

ENDPROC

PROC CMHDZ_PROCESS_CLIENT_STATE_OUTRO_MOVIE()
	CMHDZ_DRAW_MENU_BACKGROUND()
	
	FLOAT fRatioWidth = 1.0 * GET_ASPECT_RATIO_MODIFIER_FROM_ASPECT_RATIO()
	FLOAT fRatioHeight = 1.0
	BOOL bMovieFinished = DG_DRAW_MOVIE(sCMHDZData.bmIdCmhdzOutro, fRatioWidth, fRatioHeight)
	
	
	IF NOT bMovieFinished
		////CDEBUG2LN(DEBUG_MINIGAME, "{DSW} [CMHDZ_PROCESS_CLIENT_STATE_OUTRO_MOVIE] Movie Time: ", GET_BINK_MOVIE_TIME(sCMHDZData.bmIdCmhdzOutro))
		IF NOT sCMHDZData.bPlayedOutroAudio
			IF GET_BINK_MOVIE_TIME(sCMHDZData.bmIdCmhdzOutro) >= 78.0
				CMHDZ_PLAY_SOUND_AND_RELEASE_NO_POSITION(CMHDZ_AUDIO_EFFECT_PLAYER_FINISH_GAME)
				sCMHDZData.bPlayedOutroAudio = TRUE
			ENDIF
		ENDIF
		CDEBUG2LN(DEBUG_MINIGAME, "[BAZ] CMHDZ_PROCESS_CLIENT_STATE_OUTRO_MOVIE - Outro movie is running.")
		TWS_DRAW_FRONT_FX()
		EXIT
	ENDIF
	
	sCMHDZData.bPlayedOutro = TRUE
	
	IF NOT sCMHDZData.bSkipLeaderboard
		CMHDZ_INIT_GOTO_LEADERBOARD()
		CMHDZ_SET_LOCAL_STATE(CMHDZ_ARCADE_CLIENT_STATE_EDIT_LEADERBOARD)
		//CMHDZ_SET_LOCAL_STATE(CMHDZ_ARCADE_CLIENT_STATE_VIEW_LEADERBOARD)
	ELSE
		CMHDZ_START_MOVIE_FORCE(sCMHDZData.bmIdCmhdzIntro, "CMHDZ_Intro")
		CMHDZ_SET_LOCAL_STATE(CMHDZ_ARCADE_CLIENT_STATE_TITLE_SCREEN)
	ENDIF
	
	TWS_DRAW_FRONT_FX()
ENDPROC

PROC CMHDZ_PROCESS_CLIENT_STATE_VIEW_LEADERBOARD()
	CMHDZ_DRAW_CLIENT_STATE_LEADERBOARD()
	
	CMHDZ_CHECK_PLAYER_RETURNING_TO_MENU(TRUE, TRUE, TRUE)
ENDPROC

PROC CMHDZ_PROCESS_CLIENT_STATE_EDIT_LEADERBOARD()
	CDEBUG2LN(DEBUG_MINIGAME, "[CMHDZ][BAZ] CMHDZ_PROCESS_CLIENT_STATE_EDIT_LEADERBOARD - Processing leaderboard entry")
	CMHDZ_TRIGGER_TITLE_MUSIC()
	INT iPlayerScore
//	INT iPlayerScore = 50000//CMHDZ_GET_LOCAL_PLAYER_TOTAL_SCORE()
//	playerBd[PARTICIPANT_ID_TO_INT()].iLeaderboardScore = iPlayerScore

	IF playerBd[PARTICIPANT_ID_TO_INT()].iLeaderboardScore != CMHDZ_GET_LOCAL_PLAYER_TOTAL_SCORE()
		playerBd[PARTICIPANT_ID_TO_INT()].iLeaderboardScore = CMHDZ_GET_LOCAL_PLAYER_TOTAL_SCORE()
	ENDIF
	
	iPlayerScore = playerBd[PARTICIPANT_ID_TO_INT()].iLeaderboardScore
	BOOL bServerReady = IS_BIT_SET(cmhdzServerBd.iSortLbForPart, PARTICIPANT_ID_TO_INT())
	
	//ARCADE_GAMES_LEADERBOARD_PROCESS_ENTRY(sCMHDZData.sLbData, cmhdzServerBd.sLeaderboard, playerBd, playerBd[PARTICIPANT_ID_TO_INT()].iLeaderboardInitials, iPlayerScore, bServerReady)
	ARCADE_GAMES_LEADERBOARD_PROCESS_ENTRY(sCMHDZData.sLbData, cmhdzServerBd.sLeaderboard, playerBd[PARTICIPANT_ID_TO_INT()].iLeaderboardInitials, iPlayerScore, bServerReady)
	
	CMHDZ_DRAW_CLIENT_STATE_LEADERBOARD()
	
	IF NOT sCMHDZData.sLbData.bEditing	
		CMHDZ_RESET_LOCAL_PLAYER_SCORE_FOR_CURRENT_LEVEL()
		CMHDZ_SET_LOCAL_STATE(CMHDZ_ARCADE_CLIENT_STATE_VIEW_LEADERBOARD)
	ENDIF
ENDPROC

// Process CLEANUP
PROC CMHDZ_CLEANUP_AND_EXIT_CLIENT()
	
	//CDEBUG2LN(DEBUG_MINIGAME, "{dsw} [CMHDZ_CLEANUP_AND_EXIT_CLIENT] - Cleaning up and terminating the script")
	
	CMHDZ_CANCEL_MUSIC_EVENT(CMHDZ_MUSIC_EVENT_DEATH)
	CMHDZ_CANCEL_MUSIC_EVENT(CMHDZ_MUSIC_EVENT_HIT)
	CMHDZ_CANCEL_MUSIC_EVENT(CMHDZ_MUSIC_EVENT_HIT_ALT)
	CMHDZ_CANCEL_MUSIC_EVENT(CMHDZ_GET_MUSIC_EVENT_FOR_LEVEL(sCMHDZData.eCurrentLevel))
	
	CMHDZ_TRIGGER_MUSIC_EVENT(CMHDZ_MUSIC_EVENT_STOP)
	
	#IF IS_DEBUG_BUILD
	#IF CMHDZ_CMDLINE_EDITOR_NEW
	CLEANUP_MENU_ASSETS()
	#ENDIF
	#ENDIF
	
	IF NETWORK_IS_HOST_OF_THIS_SCRIPT()
		CMHDZ_SEND_TELEMETRY()
	ENDIF
	
	sCMHDZData.sArcadeAnimData.bHoldLastFrame = FALSE
	sCMHDZData.sArcadeAnimData.bLoopAnim = FALSE 
	IF sCMHDZData.ePlayerPedAnimState = CMHDZ_PLAYER_PED_ANIM_IDLE
		//CDEBUG2LN(DEBUG_MINIGAME, "{dsw} [CMHDZ_CLEANUP_AND_EXIT_CLIENT] - ARCADE_CABINET_ANIM_CLIP_EXIT")
		PLAY_ARCADE_CABINET_ANIMATION(sCMHDZData.sArcadeAnimData, ARCADE_CABINET_ANIM_CLIP_EXIT) 
	ELSE
		//CDEBUG2LN(DEBUG_MINIGAME, "{dsw} [CMHDZ_CLEANUP_AND_EXIT_CLIENT] - ARCADE_CABINET_ANIM_CLIP_LAST_GUNSLINGERS_EXIT_FROM_AIM")
		PLAY_ARCADE_CABINET_ANIMATION(sCMHDZData.sArcadeAnimData, ARCADE_CABINET_ANIM_CLIP_LAST_GUNSLINGERS_EXIT_FROM_AIM)
	ENDIF
	ARCADE_CABINET_COMMON_CLEANUP()
	
	ARCADE_GAMES_HELP_TEXT_CLEAR()
	
	CMHDZ_STOP_AUDIO_SCENE(CMHDZ_AUDIO_SCENE_MENUS)
	CMHDZ_STOP_SOUND(CMHDZ_AUDIO_EFFECT_LEVEL_BACKGROUND_LOOP)
	CMHDZ_STOP_AUDIO_SCENE(CMHDZ_AUDIO_SCENE_GAMEPLAY)
	DG_CLEAN_UP_MOVIE(sCMHDZData.bmIdCmhdzIntro) 
	DG_CLEAN_UP_MOVIE(sCMHDZData.bmIdCmhdzOutro) 
//	DG_CLEAN_UP_MOVIE(sCMHDZData.bmIdCmhdzIntro) 
//	DG_CLEAN_UP_MOVIE(sCMHDZData.bmIdCmhdzIntro_LoopStatic) 
	//SET_STREAMED_TEXTURE_DICT_AS_NO_LONGER_NEEDED(sCMHDZData.tl31BaseTextDict)

	ARCADE_GAMES_SOUND_RELEASE_AUDIO_BANK("DLC_TUNER/DLC_Tuner_AM_CH")
	ARCADE_GAMES_SOUND_RELEASE_AUDIO_BANK("DLC_TUNER/DLC_Tuner_AM_CH_Enemy_Vocal")
	ARCADE_GAMES_SOUND_RELEASE_AUDIO_BANK("DLC_TUNER/DLC_Tuner_AM_CH_Dir_Vocal")

	CMHDZ_RELEASE_ALL_TEXTURE_DICTS()

	TERMINATE_THIS_MULTIPLAYER_THREAD_NO_ARGS()
	//CDEBUG2LN(DEBUG_MINIGAME, "{baz} [CMHDZ_CLEANUP_AND_EXIT_CLIENT] - ARCADE_CABINET_ANIM_CLIP_LAST_GUNSLINGERS_EXIT_FROM_AIM")

ENDPROC

FUNC ARCADE_CABINET_ANIM_CLIPS CMHDZ_GET_PLAY_IDLE_CLIP_FROM_COUNT(INT iCount)
	ARCADE_CABINET_ANIM_CLIPS ePlayIdle
	SWITCH iCount
		CASE 0		ePlayIdle = ARCADE_CABINET_ANIM_CLIP_PLAY_IDLE			BREAK
		CASE 1		ePlayIdle = ARCADE_CABINET_ANIM_CLIP_PLAY_IDLE_V2		BREAK
		CASE 2		ePlayIdle = ARCADE_CABINET_ANIM_CLIP_PLAY_IDLE_V3		BREAK
		CASE 3		ePlayIdle = ARCADE_CABINET_ANIM_CLIP_PLAY_IDLE_V4		BREAK
	ENDSWITCH
	
	RETURN ePlayIdle
ENDFUNC

FUNC BOOL CMHDZ_SHOULD_PLAY_NEXT_PLAY_IDLE_ANIM()
	IF sCMHDZData.iIdleAnimCount = -1
		//CDEBUG2LN(DEBUG_MINIGAME, "{dsw} [CMHDZ_SHOULD_PLAY_NEXT_PLAY_IDLE_ANIM]  True - iIdleAnimCount: ", sCMHDZData.iIdleAnimCount)
		RETURN TRUE
	ENDIF
	
	INT iCurrent = sCMHDZData.iIdleAnimCount - 1
	IF iCurrent < 0
		iCurrent = 0
	ENDIF
	ARCADE_CABINET_ANIM_CLIPS ePlayIdle = CMHDZ_GET_PLAY_IDLE_CLIP_FROM_COUNT(sCMHDZData.iIdleAnimCount)
	
	IF IS_PLAYER_PLAYING_THIS_ARCADE_CABINET_ANIMATION_CLIP(ePlayIdle)
		IF HAS_ARCADE_CABINET_ANIMATION_CLIP_FINISHED(ePlayIdle)
			//CDEBUG2LN(DEBUG_MINIGAME, "{dsw} [CMHDZ_SHOULD_PLAY_NEXT_PLAY_IDLE_ANIM]  True - Previous idle finished COunt:: ", iCurrent)
			RETURN TRUE
		ENDIF
	ENDIF
	
	RETURN FALSE
ENDFUNC
PROC CMHDZ_PROCESS_PLAYER_PED_ANIMS()
	/*
	url:bugstar:6022461
	PLAY_ARCADE_CABINET_ANIMATION(eAnimEvent, ARCADE_CABINET_ANIM_CLIP_LAST_GUNSLINGERS_LEVEL_COMPLETE) 
PLAY_ARCADE_CABINET_ANIMATION(eAnimEvent, ARCADE_CABINET_ANIM_CLIP_LAST_GUNSLINGERS_LOSE_LIFE) 
	PLAY_ARCADE_CABINET_ANIMATION(eAnimEvent, ARCADE_CABINET_ANIM_CLIP_WIN) 
	PLAY_ARCADE_CABINET_ANIMATION(eAnimEvent, ARCADE_CABINET_ANIM_CLIP_LOSE)
	*/ 
	ARCADE_CABINET_ANIM_CLIPS ePlayIdle
	SWITCH sCMHDZData.ePlayerPedAnimState
		//-- Idle (stand)
		CASE CMHDZ_PLAYER_PED_ANIM_IDLE
			IF sCMHDZData.eClientState = CMHDZ_ARCADE_CLIENT_STATE_LEVEL_SELECTION_MENU
				sCMHDZData.sArcadeAnimData.bHoldLastFrame = TRUE
				sCMHDZData.sArcadeAnimData.bLoopAnim = FALSE
				sCMHDZData.sArcadeAnimData.fBlendInDelta = SLOW_BLEND_IN
				sCMHDZData.sArcadeAnimData.fBlendOutDelta = SLOW_BLEND_OUT
				PLAY_ARCADE_CABINET_ANIMATION(sCMHDZData.sArcadeAnimData, ARCADE_CABINET_ANIM_CLIP_LAST_GUNSLINGERS_IDLE_TO_AIM) 
				
				CMHDZ_SET_PLAYER_PED_ANIM_STATE(CMHDZ_PLAYER_PED_ANIM_IDLE_TO_AIM)
			ENDIF
		BREAK
		
		//-- Idle (stand) -> Aiming
		CASE CMHDZ_PLAYER_PED_ANIM_IDLE_TO_AIM
			IF IS_PLAYER_PLAYING_THIS_ARCADE_CABINET_ANIMATION_CLIP(ARCADE_CABINET_ANIM_CLIP_LAST_GUNSLINGERS_IDLE_TO_AIM)
				IF HAS_ARCADE_CABINET_ANIMATION_CLIP_FINISHED(ARCADE_CABINET_ANIM_CLIP_LAST_GUNSLINGERS_IDLE_TO_AIM)
					sCMHDZData.sArcadeAnimData.bHoldLastFrame = FALSE
					sCMHDZData.sArcadeAnimData.bLoopAnim = TRUE
					sCMHDZData.sArcadeAnimData.fBlendInDelta = SLOW_BLEND_IN
					sCMHDZData.sArcadeAnimData.fBlendOutDelta = SLOW_BLEND_OUT
					PLAY_ARCADE_CABINET_ANIMATION(sCMHDZData.sArcadeAnimData, ARCADE_CABINET_ANIM_CLIP_LAST_GUNSLINGERS_AIM_IDLE) 
					
					sCMHDZData.iIdleAnimCount = -1
					CMHDZ_SET_PLAYER_PED_ANIM_STATE(CMHDZ_PLAYER_PED_ANIM_AIM_IDLE)
				ELSE
					//CDEBUG2LN(DEBUG_MINIGAME, "[CMHDZ_PROCESS_PLAYER_PED_ANIMS] {DSW} Waiting for HAS_ARCADE_CABINET_ANIMATION_CLIP_FINISHED - ARCADE_CABINET_ANIM_CLIP_LAST_GUNSLINGERS_IDLE_TO_AIM")
				ENDIF
			ENDIF
		BREAK
		
		//-- Idle (Aiming) -> Idle (playing)
		CASE CMHDZ_PLAYER_PED_ANIM_AIM_IDLE
			IF sCMHDZData.eClientState = CMHDZ_ARCADE_CLIENT_STATE_PLAYING
				IF CMHDZ_GET_LOCAL_PLAYER_HEALTH() > 0.0 
				AND CMHDZ_GET_TOTAL_NUMBER_OF_ENEMIES_LEFT_ALIVE_FOR_CURRENT_SCREEN() > 0
					IF CMHDZ_SHOULD_PLAY_NEXT_PLAY_IDLE_ANIM()
						sCMHDZData.iIdleAnimCount++
						
						IF sCMHDZData.iIdleAnimCount > 3
							sCMHDZData.iIdleAnimCount = 0
						ENDIF
						
												
						ePlayIdle = CMHDZ_GET_PLAY_IDLE_CLIP_FROM_COUNT(sCMHDZData.iIdleAnimCount)
						SWITCH sCMHDZData.iIdleAnimCount
							CASE 0		ePlayIdle = ARCADE_CABINET_ANIM_CLIP_PLAY_IDLE			BREAK
							CASE 1		ePlayIdle = ARCADE_CABINET_ANIM_CLIP_PLAY_IDLE_V2		BREAK
							CASE 2		ePlayIdle = ARCADE_CABINET_ANIM_CLIP_PLAY_IDLE_V3		BREAK
							CASE 3		ePlayIdle = ARCADE_CABINET_ANIM_CLIP_PLAY_IDLE_V4		BREAK
						ENDSWITCH
					
					
						//CDEBUG2LN(DEBUG_MINIGAME, "[CMHDZ_PROCESS_PLAYER_PED_ANIMS] {DSW} Starting play_idle, var: ",  sCMHDZData.iIdleAnimCount)
						
						
						sCMHDZData.sArcadeAnimData.fBlendInDelta = REALLY_SLOW_BLEND_IN
						sCMHDZData.sArcadeAnimData.fBlendOutDelta = REALLY_SLOW_BLEND_OUT
						PLAY_ARCADE_CABINET_ANIMATION(sCMHDZData.sArcadeAnimData, ePlayIdle) 
						sCMHDZData.bDoneReactionAnim = FALSE	
				//		CMHDZ_SET_PLAYER_PED_ANIM_STATE(CMHDZ_PLAYER_PED_ANIM_PLAY_IDLE)
					ENDIF
				ENDIF

			ENDIF
			
			IF NOT sCMHDZData.bDoneReactionAnim
				IF CMHDZ_GET_LOCAL_PLAYER_HEALTH() <= 0.0
					sCMHDZData.sArcadeAnimData.fBlendInDelta = SLOW_BLEND_IN
					sCMHDZData.sArcadeAnimData.fBlendOutDelta = SLOW_BLEND_OUT
					sCMHDZData.sArcadeAnimData.bLoopAnim = FALSE
					sCMHDZData.sArcadeAnimData.bHoldLastFrame = TRUE
					PLAY_ARCADE_CABINET_ANIMATION(sCMHDZData.sArcadeAnimData, ARCADE_CABINET_ANIM_CLIP_LAST_GUNSLINGERS_LOSE_LIFE)
					
					CMHDZ_SET_PLAYER_PED_ANIM_STATE(CMHDZ_PLAYER_PED_ANIM_AIM_IDLE_TO_LOSE_LIFE)
					sCMHDZData.bDoneReactionAnim = TRUE
				ELSE 
					IF sCMHDZData.eClientState = CMHDZ_ARCADE_CLIENT_STATE_PLAYING
					OR sCMHDZData.eClientState = CMHDZ_ARCADE_CLIENT_STATE_RESULT_SCREEN
						IF (CMHDZ_GET_LOCAL_PLAYER_HEALTH() > 0.0 AND CMHDZ_GET_TOTAL_NUMBER_OF_ENEMIES_LEFT_ALIVE_FOR_CURRENT_SCREEN() = 0)

							sCMHDZData.sArcadeAnimData.fBlendInDelta = SLOW_BLEND_IN
							sCMHDZData.sArcadeAnimData.fBlendOutDelta = SLOW_BLEND_OUT
							sCMHDZData.sArcadeAnimData.bLoopAnim = FALSE
							sCMHDZData.sArcadeAnimData.bHoldLastFrame = TRUE
							
							IF CMHDZ_ARE_ALL_LEVELS_COMPLETE()
							AND NOT sCMHDZData.bPlayedWinningAnim
								sCMHDZData.bPlayedWinningAnim = TRUE
								PLAY_ARCADE_CABINET_ANIMATION(sCMHDZData.sArcadeAnimData, ARCADE_CABINET_ANIM_CLIP_WIN)
								
								CMHDZ_SET_PLAYER_PED_ANIM_STATE(CMHDZ_PLAYER_PED_ANIM_AIM_IDLE_TO_COMPLETE_GAME)
							ELSE
								PLAY_ARCADE_CABINET_ANIMATION(sCMHDZData.sArcadeAnimData, ARCADE_CABINET_ANIM_CLIP_LAST_GUNSLINGERS_LEVEL_COMPLETE)
								
								CMHDZ_SET_PLAYER_PED_ANIM_STATE(CMHDZ_PLAYER_PED_ANIM_AIM_IDLE_TO_COMPLETE_SCREEN)

							ENDIF
							
							sCMHDZData.bDoneReactionAnim = TRUE 
						ENDIF
					ENDIF
				ENDIF
			ENDIF
		BREAK
		
//		CASE CMHDZ_PLAYER_PED_ANIM_PLAY_IDLE
//			IF CMHDZ_GET_LOCAL_PLAYER_HEALTH() <= 0.0
//				sCMHDZData.sArcadeAnimData.fBlendInDelta = SLOW_BLEND_IN
//				sCMHDZData.sArcadeAnimData.fBlendOutDelta = SLOW_BLEND_OUT
//				sCMHDZData.sArcadeAnimData.bLoopAnim = FALSE
//				sCMHDZData.sArcadeAnimData.bHoldLastFrame = TRUE
//				PLAY_ARCADE_CABINET_ANIMATION(sCMHDZData.sArcadeAnimData, ARCADE_CABINET_ANIM_CLIP_LAST_GUNSLINGERS_LOSE_LIFE)
//				
//				CMHDZ_SET_PLAYER_PED_ANIM_STATE(CMHDZ_PLAYER_PED_ANIM_AIM_IDLE_TO_LOSE_LIFE)
//			ELSE 
//				IF sCMHDZData.eClientState = CMHDZ_ARCADE_CLIENT_STATE_PLAYING
//				OR sCMHDZData.eClientState = CMHDZ_ARCADE_CLIENT_STATE_RESULT_SCREEN
//					IF (CMHDZ_GET_LOCAL_PLAYER_HEALTH() > 0.0 AND CMHDZ_GET_TOTAL_NUMBER_OF_ENEMIES_LEFT_ALIVE_FOR_CURRENT_SCREEN() = 0)
//
//						sCMHDZData.sArcadeAnimData.fBlendInDelta = SLOW_BLEND_IN
//						sCMHDZData.sArcadeAnimData.fBlendOutDelta = SLOW_BLEND_OUT
//						sCMHDZData.sArcadeAnimData.bLoopAnim = FALSE
//						sCMHDZData.sArcadeAnimData.bHoldLastFrame = TRUE
//						
//						IF CMHDZ_ARE_ALL_LEVELS_COMPLETE()
//						AND NOT sCMHDZData.bPlayedWinningAnim
//							sCMHDZData.bPlayedWinningAnim = TRUE
//							PLAY_ARCADE_CABINET_ANIMATION(sCMHDZData.sArcadeAnimData, ARCADE_CABINET_ANIM_CLIP_WIN)
//							
//							CMHDZ_SET_PLAYER_PED_ANIM_STATE(CMHDZ_PLAYER_PED_ANIM_AIM_IDLE_TO_COMPLETE_GAME)
//						ELSE
//							PLAY_ARCADE_CABINET_ANIMATION(sCMHDZData.sArcadeAnimData, ARCADE_CABINET_ANIM_CLIP_LAST_GUNSLINGERS_LEVEL_COMPLETE)
//							
//							CMHDZ_SET_PLAYER_PED_ANIM_STATE(CMHDZ_PLAYER_PED_ANIM_AIM_IDLE_TO_COMPLETE_SCREEN)
//
//						ENDIF
//					ENDIF
//				ENDIF
//			ENDIF
//			
//		BREAK
		
		//-- Idle (Playing) -> Lose life
		CASE CMHDZ_PLAYER_PED_ANIM_AIM_IDLE_TO_LOSE_LIFE
			IF IS_PLAYER_PLAYING_THIS_ARCADE_CABINET_ANIMATION_CLIP(ARCADE_CABINET_ANIM_CLIP_LAST_GUNSLINGERS_LOSE_LIFE)
				IF HAS_ARCADE_CABINET_ANIMATION_CLIP_FINISHED(ARCADE_CABINET_ANIM_CLIP_LAST_GUNSLINGERS_LOSE_LIFE)
					sCMHDZData.sArcadeAnimData.bHoldLastFrame = FALSE
					sCMHDZData.sArcadeAnimData.bLoopAnim = TRUE
					sCMHDZData.sArcadeAnimData.fBlendInDelta = SLOW_BLEND_IN
					sCMHDZData.sArcadeAnimData.fBlendOutDelta = SLOW_BLEND_OUT
					PLAY_ARCADE_CABINET_ANIMATION(sCMHDZData.sArcadeAnimData, ARCADE_CABINET_ANIM_CLIP_LAST_GUNSLINGERS_AIM_IDLE) 
					sCMHDZData.iIdleAnimCount = -1
					CMHDZ_SET_PLAYER_PED_ANIM_STATE(CMHDZ_PLAYER_PED_ANIM_AIM_IDLE)
				ENDIF
			ENDIF
		BREAK
		
		//-- Idle (Aiming) -> Complete stage
		CASE CMHDZ_PLAYER_PED_ANIM_AIM_IDLE_TO_COMPLETE_SCREEN
			IF IS_PLAYER_PLAYING_THIS_ARCADE_CABINET_ANIMATION_CLIP(ARCADE_CABINET_ANIM_CLIP_LAST_GUNSLINGERS_LEVEL_COMPLETE)
				IF HAS_ARCADE_CABINET_ANIMATION_CLIP_FINISHED(ARCADE_CABINET_ANIM_CLIP_LAST_GUNSLINGERS_LEVEL_COMPLETE)
						sCMHDZData.sArcadeAnimData.fBlendInDelta = SLOW_BLEND_IN
						sCMHDZData.sArcadeAnimData.fBlendOutDelta = SLOW_BLEND_OUT
						sCMHDZData.sArcadeAnimData.bHoldLastFrame = FALSE
						sCMHDZData.sArcadeAnimData.bLoopAnim = TRUE
						
						PLAY_ARCADE_CABINET_ANIMATION(sCMHDZData.sArcadeAnimData, ARCADE_CABINET_ANIM_CLIP_LAST_GUNSLINGERS_AIM_IDLE) 
						sCMHDZData.iIdleAnimCount = -1
						CMHDZ_SET_PLAYER_PED_ANIM_STATE(CMHDZ_PLAYER_PED_ANIM_AIM_IDLE)
					
				ENDIF
			ENDIF
		BREAK
		
		//-- Idle (Playing) -> Complete game
		CASE CMHDZ_PLAYER_PED_ANIM_AIM_IDLE_TO_COMPLETE_GAME
			IF IS_PLAYER_PLAYING_THIS_ARCADE_CABINET_ANIMATION_CLIP(ARCADE_CABINET_ANIM_CLIP_WIN)
				IF HAS_ARCADE_CABINET_ANIMATION_CLIP_FINISHED(ARCADE_CABINET_ANIM_CLIP_WIN)
					IF sCMHDZData.eClientState != CMHDZ_ARCADE_CLIENT_STATE_PLAYING
						sCMHDZData.sArcadeAnimData.bHoldLastFrame = FALSE
						sCMHDZData.sArcadeAnimData.bLoopAnim = TRUE
						sCMHDZData.sArcadeAnimData.fBlendInDelta = REALLY_SLOW_BLEND_IN
						sCMHDZData.sArcadeAnimData.fBlendOutDelta = REALLY_SLOW_BLEND_OUT
						PLAY_ARCADE_CABINET_ANIMATION(sCMHDZData.sArcadeAnimData, ARCADE_CABINET_ANIM_CLIP_IDLE) 
						
						CMHDZ_SET_PLAYER_PED_ANIM_STATE(CMHDZ_PLAYER_PED_ANIM_IDLE)
					ENDIF
				ENDIF
			ENDIF
		BREAK
	ENDSWITCH
ENDPROC

PROC CMHDZ_PROCESS_CLIENT_STATE_MACHINE()
#IF IS_DEBUG_BUILD
	sCMHDZData.iAssertCounter = 0
#ENDIF

	IF sCMHDZData.eClientState != CMHDZ_ARCADE_CLIENT_STATE_INIT
	
		// Black backdrop
		ARCADE_DRAW_PIXELSPACE_RECT(INIT_VECTOR_2D(cfBASE_SCREEN_WIDTH/2,cfBASE_SCREEN_HEIGHT/2),
								INIT_VECTOR_2D(cfBASE_SCREEN_WIDTH,cfBASE_SCREEN_HEIGHT),
								sCMHDZData.rgbaBlack)
	
	ENDIF

	SWITCH sCMHDZData.eClientState
		
		CASE CMHDZ_ARCADE_CLIENT_STATE_INIT
		
			IF NOT CMHDZ_LOAD_TEXDICT(CMHDZ_TEXDICT_FACADE)
				BREAK
			ENDIF
			
			IF NOT ARCADE_GAMES_POSTFX_REQUESTING_ASSETS()
				CDEBUG2LN(DEBUG_MINIGAME, "[CMHDZ_ARCADE] [BAZ] CMHDZ_PROCESS_CLIENT_STATE_REQUESTING_ASSETS Loading POSTFX assets")
				BREAK
			ENDIF
		
			CMHDZ_PROCESS_CLIENT_STATE_INIT()
		
		BREAK
		
//		CASE CMHDZ_ARCADE_CLIENT_STATE_REQUESTING_ASSETS
//		
//			CMHDZ_PROCESS_CLIENT_STATE_REQUESTING_ASSETS()
//		
//		BREAK
		
		// Remove if not needed.
		CASE CMHDZ_ARCADE_CLIENT_STATE_FIB
			CMHDZ_PROCESS_CLIENT_STATE_FIB()
		BREAK
		
		CASE CMHDZ_ARCADE_CLIENT_STATE_INTRO
			
			CMHDZ_PROCESS_CLIENT_INTRO()
			
		BREAK
		
		CASE CMHDZ_ARCADE_CLIENT_STATE_TITLE_SCREEN
			
			CMHDZ_PROCESS_CLIENT_STATE_TITLE_SCREEN()
		
		BREAK
		
		CASE CMHDZ_ARCADE_CLIENT_STATE_TITLE_FADEOUT
		
			CMHDZ_PROCESS_CLIENT_STATE_TITLE_SCREEN_FADE_OUT()
			
		BREAK

		CASE CMHDZ_ARCADE_CLIENT_STATE_LEVEL_SELECTION_MENU
		
			CMHDZ_PROCESS_CLIENT_STATE_LEVEL_SELECT_MENU()
		
		BREAK
		
		CASE CMHDZ_ARCADE_CLIENT_STATE_INIT_LEVEL
		
			CMHDZ_PROCESS_CLIENT_STATE_INIT_LEVEL()
				
		BREAK
		
		CASE CMHDZ_ARCADE_CLIENT_STATE_PLAYING

			CMHDZ_PROCESS_CLIENT_STATE_PLAYING()
			
			#IF IS_DEBUG_BUILD
//				IF IS_KEYBOARD_KEY_JUST_PRESSED(KEY_DOWN)
//					//CMHDZ_SET_LEVEL_BIT_FOR_CURRENT_LEVEL(CMHDZ_LEVELS_BIT_STOPPED)
//					CMHDZ_INCREASE_CURRENT_LEVEL_SCREEN()
//				ENDIF
				IF IS_DEBUG_KEY_JUST_PRESSED(KEY_DOWN, KEYBOARD_MODIFIER_NONE, "Debug complete")
					sCMHDZData.bLevelsCompleted[ENUM_TO_INT(sCMHDZData.eCurrentLevel)] = TRUE
					sCMHDZData.bFadingOut = TRUE
					
					CMHDZ_CLEAR_LEVEL_BIT_FOR_LEVEL(sCMHDZData.eCurrentLevel, CMHDZ_LEVELS_BIT_REPLAYING_LEVEL)
					
					// Debugging worst possible score
					playerBd[PARTICIPANT_ID_TO_INT()].iPlayerScore[CMHDZ_GET_CURRENT_LEVEL()] = 9999
					playerBd[PARTICIPANT_ID_TO_INT()].iPlayerHiScore[CMHDZ_GET_CURRENT_LEVEL()] = 9999
					sCMHDZData.iTotalLevelShots[CMHDZ_GET_CURRENT_LEVEL()] = 100
					sCMHDZData.iTotalLevelEnemyHits[CMHDZ_GET_CURRENT_LEVEL()] = 0
					
					CMHDZ_ASIGN_STAR_RATING(sCMHDZData.eCurrentLevel)
					
					IF CMHDZ_ARE_ALL_LEVELS_COMPLETE()
						CMHDZ_MAINTAIN_PLAYER_AWARDS()
						CMHDZ_SEND_TELEMETRY()
					ENDIF
					
					sCMHDZData.eLevelState = CMHDZ_FADING_OUT
				ENDIF

				IF GET_COMMANDLINE_PARAM_EXISTS("sc_BadlandsOnScreen") OR (CMHDZ_CMDLINE_ON_SCREEN_DEBUG = 1)
					CMHDZ_DO_ON_SCREEN_DEBUG()
				ENDIF
			#ENDIF

		BREAK
		
		CASE CMHDZ_ARCADE_CLIENT_STATE_EDITOR_ACTIVE
			CMHDZ_PROCESS_CLIENT_STATE_EDITOR_ACTIVE()
		BREAK
		
		CASE CMHDZ_ARCADE_CLIENT_STATE_GAME_OVER
			CMHDZ_PROCESS_CLIENT_STATE_GAME_OVER()
		BREAK
		
		CASE CMHDZ_ARCADE_CLIENT_STATE_RESULT_SCREEN
		
			CMHDZ_PROCESS_CLIENT_STATE_RESULT_SCREEN()
		
		BREAK
		
		CASE CMHDZ_ARCADE_CLIENT_STATE_OUTRO_MOVIE
			CMHDZ_PROCESS_CLIENT_STATE_OUTRO_MOVIE()
		BREAK
		
		CASE CMHDZ_ARCADE_CLIENT_STATE_EDIT_LEADERBOARD
		
			CMHDZ_PROCESS_CLIENT_STATE_EDIT_LEADERBOARD()
		
		BREAK
		
		CASE CMHDZ_ARCADE_CLIENT_STATE_VIEW_LEADERBOARD
		
			CMHDZ_PROCESS_CLIENT_STATE_VIEW_LEADERBOARD()
		
		BREAK
		
		CASE CMHDZ_ARCADE_CLIENT_STATE_CLEANUP
		
			CMHDZ_CLEANUP_AND_EXIT_CLIENT()
			TERMINATE_THIS_MULTIPLAYER_THREAD_NO_ARGS()
		
		BREAK
		
	ENDSWITCH

	//-- Handle player ped anims while playing
	CMHDZ_PROCESS_PLAYER_PED_ANIMS()
ENDPROC

#IF IS_DEBUG_BUILD
PROC CMHDZ_DEBUG_OUTPUT_ALL_ENEMY_POSITIONS()
	INT i
	//CDEBUG2LN(DEBUG_MINIGAME, "{dsw} [OUTPUT_ENEMY_POSITIONS] ")
	FOR i = 0 TO ciCMHDZ_MAX_ENEMIES  -1
		IF sCMHDZData.sEnemyData[i].eState != CMHDZ_ENEMY_STATE_INACTIVE
			//CDEBUG2LN(DEBUG_MINIGAME, "{dsw} [OUTPUT_ENEMY_POSITIONS] Enemy ", i, " lane:", sCMHDZData.sEnemyData[i].iEnemyLane, " Type: ", CMHDZ_ENEMY_TYPES_TO_STRING(sCMHDZData.sEnemyData[i].iEnemyType), " State: ", CMHDZ_ENEMY_STATE_TO_STRING(sCMHDZData.sEnemyData[i].eState) , " Active in screen: ", sCMHDZData.sEnemyData[i].fPointToAppear)
			//CDEBUG2LN(DEBUG_MINIGAME, "{dsw} [OUTPUT_ENEMY_POSITIONS] Reverse? ", CMHDZ_ENEMY_DATA_IS_BITMASK_SET(i, CMHDZ_ENEMY_DATA_BITS_REVERSE), " Pos: ", sCMHDZData.sEnemyData[i].vSpritePos.x, ", ", sCMHDZData.sEnemyData[i].vSpritePos.y, " Stopping: ", sCMHDZData.sEnemyData[i].fStoppingX, " Start: ", sCMHDZData.sEnemyData[i].vStartPos.x, ", ", sCMHDZData.sEnemyData[i].vStartPos.y)
			//CDEBUG2LN(DEBUG_MINIGAME, "{dsw} [OUTPUT_ENEMY_POSITIONS] Ever on screen? ", CMHDZ_ENEMY_DATA_IS_BITMASK_SET(i, CMHDZ_ENEMY_DATA_BITS_APPEARED_ON_SCREEN))
			//CDEBUG2LN(DEBUG_MINIGAME, "{dsw} [OUTPUT_ENEMY_POSITIONS]")
		ENDIF
	ENDFOR
ENDPROC

PROC CMHDZ_DEBUG_OUTPUT_ALL_PICKUP_POSITIONS()
	INT i
	//CDEBUG2LN(DEBUG_MINIGAME, "{dsw} [CMHDZ_DEBUG_OUTPUT_ALL_PICKUP_POSITIONS] ")
	
	/*
	sCMHDZData.sItemData[iItem].bRendering = FALSE
	sCMHDZData.sItemData[iItem].iMinScreen = 0
	sCMHDZData.sItemData[iItem].iRenderAfterWarpCount = 0
	sCMHDZData.sItemData[iItem].iWarpCount = 0
	sCMHDZData.sItemData[iItem].bShot = FALSE
	*/
	FOR i = 0 TO ciCMHDZ_MAX_ITEMS  -1
		//CDEBUG2LN(DEBUG_MINIGAME, "{dsw} [CMHDZ_DEBUG_OUTPUT_ALL_PICKUP_POSITIONS] sCMHDZData.sItemData[", i, "]..eItemType = ", CMHDZ_ITEM_TYPES_TO_STRING(sCMHDZData.sItemData[i].eItemType))
		//CDEBUG2LN(DEBUG_MINIGAME, "{dsw} [CMHDZ_DEBUG_OUTPUT_ALL_PICKUP_POSITIONS] sCMHDZData.sItemData[", i, "].bRendering = ", sCMHDZData.sItemData[i].bRendering) 
		//CDEBUG2LN(DEBUG_MINIGAME, "{dsw} [CMHDZ_DEBUG_OUTPUT_ALL_PICKUP_POSITIONS] sCMHDZData.sItemData[", i, "].vSpritePos = ", sCMHDZData.sItemData[i].vSpritePos.x, ", ", sCMHDZData.sItemData[i].vSpritePos.y)
		//CDEBUG2LN(DEBUG_MINIGAME, "{dsw} [CMHDZ_DEBUG_OUTPUT_ALL_PICKUP_POSITIONS] sCMHDZData.sItemData[", i, "].iMinScreen = ", sCMHDZData.sItemData[i].iMinScreen)
		//CDEBUG2LN(DEBUG_MINIGAME, "{dsw} [CMHDZ_DEBUG_OUTPUT_ALL_PICKUP_POSITIONS] sCMHDZData.sItemData[", i, "].iRenderAfterWarpCount = ", sCMHDZData.sItemData[i].iRenderAfterWarpCount)
		//CDEBUG2LN(DEBUG_MINIGAME, "{dsw} [CMHDZ_DEBUG_OUTPUT_ALL_PICKUP_POSITIONS] sCMHDZData.sItemData[", i, "].iMinScreen = ", sCMHDZData.sItemData[i].iMinScreen)
		//CDEBUG2LN(DEBUG_MINIGAME, "{dsw} [CMHDZ_DEBUG_OUTPUT_ALL_PICKUP_POSITIONS] sCMHDZData.sItemData[", i, "].iWarpCount = ", sCMHDZData.sItemData[i].iWarpCount)
		//CDEBUG2LN(DEBUG_MINIGAME, "{dsw} [CMHDZ_DEBUG_OUTPUT_ALL_PICKUP_POSITIONS] sCMHDZData.sItemData[", i, "].bShot = ", sCMHDZData.sItemData[i].bShot)
		//CDEBUG2LN(DEBUG_MINIGAME, "{dsw} [CMHDZ_DEBUG_OUTPUT_ALL_PICKUP_POSITIONS] ")
		
	ENDFOR
ENDPROC
PROC CMHDZ_DEBUG_SET_PARENT_WIDGET_GROUP(WIDGET_GROUP_ID parentWidgetGroup)

	sCMHDZData.widgetGroupExample = parentWidgetGroup
	
ENDPROC
	
/// PURPOSE:
///    Creates a read only 2D vector widget
/// PARAMS:
///    str - widget name
///    vec - vector
PROC CMHDZ_ADD_WIDGET_VECTOR_2D_READONLY(STRING str, VECTOR_2D &vec)
	TEXT_LABEL_23 txt 
	
	txt = str
	txt += " X"
	ADD_WIDGET_FLOAT_READ_ONLY(txt, vec.x) 

	txt = str
	txt += " Y"
	ADD_WIDGET_FLOAT_READ_ONLY(txt, vec.y) 
ENDPROC

/// PURPOSE:
///    Creates an editable 2D Vector widget
/// PARAMS:
///    str - widget name 
///    vec - vector
///    vMin - min value (note this effects both x and y)
///    vMax - max value (note this effects both x and y)
///    vStep - value increase rate
PROC CMHDZ_ADD_WIDGET_VECTOR_2D_SLIDER(STRING str, VECTOR_2D &vec, FLOAT vMin, FLOAT vMax, FLOAT vStep)
	TEXT_LABEL_23 txt 
	
	txt = str
	txt += " X"
	ADD_WIDGET_FLOAT_SLIDER(txt, vec.x, vMin, vMax, vStep)

	txt = str
	txt += " Y"
	ADD_WIDGET_FLOAT_SLIDER(txt, vec.y, vMin, vMax, vStep)
ENDPROC

PROC CMHDZ_DEBUG_CREATE_PLAYER_DATA_WIDGET(CMHDZ_PLAYER_DATA &dat)
	START_WIDGET_GROUP("Player Data")
		ADD_WIDGET_BOOL("bHasJustShot", dat.bHasJustShot)
		ADD_WIDGET_BOOL("bCovering", dat.bCovering)
		ADD_WIDGET_BOOL("bHoveringEnemy", dat.bHoveringEnemy)
		ADD_WIDGET_BOOL("bShouldShowReloadPrompt", dat.bShouldShowReloadPrompt)
		ADD_WIDGET_BOOL("bDoneReloadEffect", dat.bDoneReloadEffect)
		ADD_WIDGET_FLOAT_SLIDER("Health", dat.fHealth, 0.0, 1.0, 0.01)
		
		ADD_BIT_FIELD_WIDGET("Player Bitset", dat.iPlayerBitset)
		
		START_WIDGET_GROUP("Timing")
			ADD_WIDGET_INT_READ_ONLY("iLastShotTime", dat.iLastShotTime)
			ADD_WIDGET_INT_READ_ONLY("iLastProjectileTime", dat.iLastProjectileTime)
			ADD_WIDGET_INT_READ_ONLY("iDeadTime", dat.iDeadTime)
			ADD_WIDGET_INT_READ_ONLY("iReloadPromptShowTime", dat.iReloadPromptShowTime)
			ADD_WIDGET_INT_READ_ONLY("iInvulnerableTimer", dat.iInvulnerableTimer)
			ADD_WIDGET_INT_READ_ONLY("iHideReticuleTimer", dat.iHideReticuleTimer)
			ADD_WIDGET_INT_READ_ONLY("iQuadDamageTimer", dat.iQuadDamageTimer)
			ADD_WIDGET_INT_READ_ONLY("iNoAmmoTimer", dat.iNoAmmoTimer)
		STOP_WIDGET_GROUP()
		
		START_WIDGET_GROUP("Weapon Stuff")
			ADD_WIDGET_INT_READ_ONLY("iProjectileIndex", dat.iProjectileIndex)
			ADD_WIDGET_FLOAT_READ_ONLY("fHitCountdown", dat.fHitCountdown)
			ADD_WIDGET_INT_READ_ONLY("iNumberOfThrownProjectiles", dat.iNumberOfThrownProjectiles)
			ADD_WIDGET_INT_SLIDER("iThrownProjectilesAmmo", dat.iThrownProjectilesAmmo, 0, 100, 1)
			ADD_WIDGET_INT_SLIDER("iThrownProjectileReloadDelay", dat.iThrownProjectileReloadDelay, 0, 5000, 250)
			
			ADD_WIDGET_INT_READ_ONLY("iLastThrownProjectileTime", dat.iLastThrownProjectileTime)
		STOP_WIDGET_GROUP()
	
		START_WIDGET_GROUP("Scoring")
			ADD_WIDGET_INT_READ_ONLY("iSuccessiveHits", dat.iSuccessiveHits)
			ADD_WIDGET_INT_READ_ONLY("iChainedScore", dat.iChainedScore)
			ADD_WIDGET_INT_READ_ONLY("iScoreNoChain", dat.iScoreNoChain)
			ADD_WIDGET_INT_READ_ONLY("iPreviousTargetScore", dat.iPreviousTargetScore)
		STOP_WIDGET_GROUP()
	STOP_WIDGET_GROUP()
ENDPROC 

PROC CMHDZ_DEBUG_CREATE_DEBUG_STATE_WIDGET(CMHDZ_DEBUG_STATE_WIDGET &widget, INT iMaxStates = 99, STRING str = null)
	IF IS_STRING_NULL_OR_EMPTY(str)
		str = "Debug State"
	ENDIF 
	
	START_WIDGET_GROUP(str)
		widget.twCurrentState = ADD_TEXT_WIDGET("Current State")
		ADD_WIDGET_BOOL("Change State", widget.bDebugChangeState)
		ADD_WIDGET_INT_SLIDER("New State Selector", widget.iDesiredStateSelector, 0, iMaxStates - 1, 1)
		widget.twDesiredState = ADD_TEXT_WIDGET("New State")
	STOP_WIDGET_GROUP()
ENDPROC

PROC CMHDZ_DEBUG_UPDATE_CLIENT_STATE_WIDGET(CMHDZ_DEBUG_STATE_WIDGET &widget)
	CMHDZ_ARCADE_CLIENT_STATE st = INT_TO_ENUM(CMHDZ_ARCADE_CLIENT_STATE, widget.iDesiredStateSelector)
	IF (widget.bDebugChangeState)
		CMHDZ_SET_LOCAL_STATE(st)
		widget.bDebugChangeState = FALSE 
	ENDIF 

	SET_CONTENTS_OF_TEXT_WIDGET(widget.twCurrentState, CMHDZ_ARCADE_CLIENT_STATE_TO_STRING(sCMHDZData.eClientState))
	SET_CONTENTS_OF_TEXT_WIDGET(widget.twDesiredState, CMHDZ_ARCADE_CLIENT_STATE_TO_STRING(st))
ENDPROC 
#ENDIF


#IF IS_DEBUG_BUILD
#IF CMHDZ_CMDLINE_EDITOR_NEW
FUNC BOOL CMHDZ_EDITOR_IS_CONTROL_PRESSED_FOR_OPTION(CMHDZ_EDITOR &widget, CONTROL_ACTION ctrl, INT iTimeBetweenPresses = 200)
	IF IS_USING_KEYBOARD_AND_MOUSE(PLAYER_CONTROL)
		RETURN FALSE
	ENDIF

	IF IS_CONTROL_JUST_PRESSED(FRONTEND_CONTROL, ctrl) 
		widget.iDirectionDebounceTime = GET_GAME_TIMER() + iTimeBetweenPresses
		RETURN TRUE 
	ENDIF 
	
	IF IS_CONTROL_PRESSED(FRONTEND_CONTROL, ctrl) AND (GET_GAME_TIMER() > widget.iDirectionDebounceTime)
		widget.iDirectionDebounceTime = GET_GAME_TIMER() + iTimeBetweenPresses
		RETURN TRUE 
	ENDIF 
	
	RETURN FALSE 
ENDFUNC 

FUNC BOOL CMHDZ_EDITOR_IS_KEY_PRESSED_FOR_OPTION(CMHDZ_EDITOR &widget, KEY_NUMBER ctrl, INT iTimeBetweenPresses = 200)
	IF IS_KEYBOARD_KEY_JUST_PRESSED(ctrl) 
		widget.iDirectionDebounceTime = GET_GAME_TIMER() + iTimeBetweenPresses
		//CPRINTLN(DEBUG_MINIGAME, "CMHDZ_EDITOR_IS_KEY_PRESSED_FOR_OPTION - ctrl key just pressed")
		RETURN TRUE 
	ENDIF 
	
	IF IS_KEYBOARD_KEY_JUST_PRESSED(ctrl) AND (GET_GAME_TIMER() > widget.iDirectionDebounceTime)
		widget.iDirectionDebounceTime = GET_GAME_TIMER() + iTimeBetweenPresses
		//CPRINTLN(DEBUG_MINIGAME, "CMHDZ_EDITOR_IS_KEY_PRESSED_FOR_OPTION - ctrl key just pressed. timer debounced")
		RETURN TRUE 
	ENDIF
	
	RETURN FALSE 
ENDFUNC 
	
FUNC BOOL CMHDZ_EDITOR_CONTROLLER_ADJUST_BOOL(CMHDZ_EDITOR &w, BOOL &value)
	IF CMHDZ_EDITOR_IS_CONTROL_PRESSED_FOR_OPTION(w, INPUT_SCRIPT_PAD_LEFT)
	OR CMHDZ_EDITOR_IS_CONTROL_PRESSED_FOR_OPTION(w, INPUT_CELLPHONE_LEFT)
		value = !value
		RETURN TRUE
	ENDIF
	
	IF CMHDZ_EDITOR_IS_CONTROL_PRESSED_FOR_OPTION(w, INPUT_SCRIPT_PAD_RIGHT)
	OR CMHDZ_EDITOR_IS_CONTROL_PRESSED_FOR_OPTION(w, INPUT_CELLPHONE_RIGHT)
		value = !value
		RETURN TRUE
	ENDIF

	IF IS_USING_KEYBOARD_AND_MOUSE(PLAYER_CONTROL)
		IF CMHDZ_EDITOR_IS_KEY_PRESSED_FOR_OPTION(w, KEY_LEFT)
		OR CMHDZ_EDITOR_IS_KEY_PRESSED_FOR_OPTION(w, KEY_A)
			value = !value
			RETURN TRUE
		ENDIF
		
		IF CMHDZ_EDITOR_IS_KEY_PRESSED_FOR_OPTION(w, KEY_RIGHT)
		OR CMHDZ_EDITOR_IS_KEY_PRESSED_FOR_OPTION(w, KEY_D)
			value = !value
			RETURN TRUE
		ENDIF
	ENDIF
	
	RETURN FALSE 
ENDFUNC
	
FUNC BOOL CMHDZ_EDITOR_CONTROLLER_ADJUST_BITMASK_ENUM_BOOL(CMHDZ_EDITOR &w, ENUM_TO_INT &eBitField, ENUM_TO_INT eBitMask)
	BOOL value
	IF CMHDZ_EDITOR_IS_CONTROL_PRESSED_FOR_OPTION(w, INPUT_SCRIPT_PAD_LEFT)
		value = IS_BITMASK_ENUM_AS_ENUM_SET(eBitField, eBitMask)
		SET_BITMASK_ENUM_AS_ENUM_BY_BOOL(eBitField, eBitMask, !value)
		RETURN TRUE
	ENDIF
	
	IF CMHDZ_EDITOR_IS_CONTROL_PRESSED_FOR_OPTION(w, INPUT_SCRIPT_PAD_RIGHT)
		value = IS_BITMASK_ENUM_AS_ENUM_SET(eBitField, eBitMask)
		SET_BITMASK_ENUM_AS_ENUM_BY_BOOL(eBitField, eBitMask, !value)
		RETURN TRUE
	ENDIF
	
	
	IF IS_USING_KEYBOARD_AND_MOUSE(PLAYER_CONTROL)
		IF CMHDZ_EDITOR_IS_KEY_PRESSED_FOR_OPTION(w, KEY_LEFT)
		OR CMHDZ_EDITOR_IS_KEY_PRESSED_FOR_OPTION(w, KEY_A)
			value = IS_BITMASK_ENUM_AS_ENUM_SET(eBitField, eBitMask)
			SET_BITMASK_ENUM_AS_ENUM_BY_BOOL(eBitField, eBitMask, !value)
			RETURN TRUE
		ENDIF
		
		IF CMHDZ_EDITOR_IS_KEY_PRESSED_FOR_OPTION(w, KEY_RIGHT)
		OR CMHDZ_EDITOR_IS_KEY_PRESSED_FOR_OPTION(w, KEY_D)
			value = IS_BITMASK_ENUM_AS_ENUM_SET(eBitField, eBitMask)
			SET_BITMASK_ENUM_AS_ENUM_BY_BOOL(eBitField, eBitMask, !value)
			RETURN TRUE
		ENDIF
	ENDIF
	
	RETURN FALSE 
ENDFUNC

FUNC BOOL CMHDZ_EDITOR_CONTROLLER_ADJUST_BITSET_BOOL(CMHDZ_EDITOR &w, INT &iBitSet, INT iBit)
	BOOL value
	IF CMHDZ_EDITOR_IS_CONTROL_PRESSED_FOR_OPTION(w, INPUT_SCRIPT_PAD_LEFT) OR CMHDZ_EDITOR_IS_CONTROL_PRESSED_FOR_OPTION(w, INPUT_SCRIPT_PAD_RIGHT)
		value = !IS_BIT_SET(iBitSet, iBit)
		IF (value)
			SET_BIT(iBitSet, iBit)
		ELSE 
			CLEAR_BIT(iBitSet, iBit)
		ENDIF
		RETURN TRUE
	ENDIF
	
	RETURN FALSE 
ENDFUNC

FUNC BOOL CMHDZ_EDITOR_CONTROLLER_ADJUST_INT(CMHDZ_EDITOR &w, INT &value, INT iVMin, INT iVMax, INT iInc = 1, BOOL bMaxInclusive = TRUE)
	BOOL bChange 
	
	
	IF CMHDZ_EDITOR_IS_CONTROL_PRESSED_FOR_OPTION(w, INPUT_SCRIPT_PAD_LEFT)
		value -= iInc
		bChange = TRUE
	ENDIF
	
	IF CMHDZ_EDITOR_IS_CONTROL_PRESSED_FOR_OPTION(w, INPUT_SCRIPT_PAD_RIGHT)
		value += iInc
		bChange = TRUE
	ENDIF

	
	IF IS_USING_KEYBOARD_AND_MOUSE(PLAYER_CONTROL)
		IF CMHDZ_EDITOR_IS_KEY_PRESSED_FOR_OPTION(w, KEY_LEFT)
		OR CMHDZ_EDITOR_IS_KEY_PRESSED_FOR_OPTION(w, KEY_A)
			value -= iInc
			bChange = TRUE
		ENDIF
		
		IF CMHDZ_EDITOR_IS_KEY_PRESSED_FOR_OPTION(w, KEY_RIGHT)
		OR CMHDZ_EDITOR_IS_KEY_PRESSED_FOR_OPTION(w, KEY_D)
			value += iInc
			bChange = TRUE
		ENDIF
	ENDIF
	
	IF (bMaxInclusive = FALSE)
		iVMax --
	ENDIF
	
	IF (value < iVMin)
		value = iVMax
	ENDIF 
	
	IF (value > iVMax)
		value = iVMin
	ENDIF 
	
	RETURN bChange
ENDFUNC

FUNC BOOL CMHDZ_EDITOR_CONTROLLER_ADJUST_FLOAT(CMHDZ_EDITOR &w, FLOAT &value, FLOAT iVMin, FLOAT iVMax, FLOAT iInc = 1.0, BOOL bMaxInclusive = TRUE)
	BOOL bChange 
	
	IF CMHDZ_EDITOR_IS_CONTROL_PRESSED_FOR_OPTION(w, INPUT_SCRIPT_PAD_LEFT)
		value -= iInc
		bChange = TRUE
	ENDIF
	
	IF CMHDZ_EDITOR_IS_CONTROL_PRESSED_FOR_OPTION(w, INPUT_SCRIPT_PAD_RIGHT)
		value += iInc
		bChange = TRUE
	ENDIF	
	
	IF IS_USING_KEYBOARD_AND_MOUSE(PLAYER_CONTROL)
		IF CMHDZ_EDITOR_IS_KEY_PRESSED_FOR_OPTION(w, KEY_LEFT)
		OR CMHDZ_EDITOR_IS_KEY_PRESSED_FOR_OPTION(w, KEY_A)
			value -= iInc
			bChange = TRUE
		ENDIF
		
		IF CMHDZ_EDITOR_IS_KEY_PRESSED_FOR_OPTION(w, KEY_RIGHT)
		OR CMHDZ_EDITOR_IS_KEY_PRESSED_FOR_OPTION(w, KEY_D)
			value += iInc
			bChange = TRUE
		ENDIF
	ENDIF
	
	IF (bMaxInclusive = FALSE)
		iVMax -= 1.0
	ENDIF
	
	IF (value < iVMin)
		value = iVMax
	ENDIF 
	
	IF (value > iVMax)
		value = iVMin
	ENDIF 
	
	RETURN bChange
ENDFUNC

PROC CMHDZ_EDITOR_COPY_DATA_TO_GAME(CMHDZ_EDITOR &widget)
	CMHDZ_COPY_ENEMY_MAP_DATA_TO_GAME(widget.sEnemyMapData)
	CMHDZ_COPY_COVER_MAP_DATA_TO_GAME(widget.sCoverMapData)
	CMHDZ_COPY_ITEM_MAP_DATA_TO_GAME(widget.sItemMapData)
ENDPROC 

PROC CMHDZ_EDITOR_RESET_MAP_DATA(CMHDZ_EDITOR &widget)
	CMHDZ_RESET_ALL_ENEMY_MAP_DATA(widget.sEnemyMapData)
	CMHDZ_RESET_ALL_COVER_MAP_DATA(widget.sCoverMapData)
	CMHDZ_RESET_ALL_ITEM_MAP_DATA(widget.sItemMapData)
ENDPROC 

PROC CMHDZ_EDITOR_LOAD_OR_RESTART_LEVEL(CMHDZ_EDITOR &widget, BOOL bLoad = TRUE)	
	sCMHDZData.eCurrentLevel = INT_TO_ENUM(CMHDZ_LEVELS, widget.iActiveLevel)
	CMHDZ_CLEANUP_VARIABLES()
	
	CMHDZ_PROCESS_CLIENT_STATE_INIT_LEVEL()
	
	IF (bLoad)
		CMHDZ_EDITOR_RESET_MAP_DATA(widget)
	ELSE 
		CMHDZ_EDITOR_COPY_DATA_TO_GAME(widget)	
	ENDIF
		
//	INT i
//	REPEAT COUNT_OF(sCMHDZData.iPropToStopOn) i
//		sCMHDZData.iPropToStopOn[i] = -1
//	ENDREPEAT
	
//	CMHDZ_INIT_COVER_POINTS(sCMHDZData.eCurrentLevel)
//	CMHDZ_INIT_ENEMIES()
//	sCMHDZData.iTotalNumberOfEnemies = sCMHDZData.iNumberOfEnemies
//	//CMHDZ_INIT_HOSTAGES()
//	CMHDZ_INIT_BACKGROUND(sCMHDZData.eCurrentLevel)
//	CMHDZ_INIT_ITEMS()
	
	widget.bShowMiniMap = TRUE
	widget.bRebuildMenu = TRUE 
	widget.iSelectedData = -1
	widget.iNewUnitData = 0
	
	sCMHDZData.iCurrentScreen = FLOOR(sCMHDZData.fOverallLevelProgression/cfCMHDZ_SCREEN_LENGTH)
	sCMHDZData.bDebugPause = TRUE
	CDEBUG2LN(DEBUG_MINIGAME, "[BAZ] CMHDZ_EDITOR_LOAD_OR_RESTART_LEVEL - Returning to Editor state.")
	CMHDZ_SET_LOCAL_STATE(CMHDZ_ARCADE_CLIENT_STATE_EDITOR_ACTIVE)
ENDPROC

PROC CMHDZ_EDITOR_PLAY_LEVEL(CMHDZ_EDITOR &widget)
	CMHDZ_EDITOR_LOAD_OR_RESTART_LEVEL(widget, FALSE)	
	sCMHDZData.bDebugPause = FALSE 
	widget.bShowMiniMap = FALSE 
	widget.bPlayStage = TRUE
ENDPROC 

PROC CMHDZ_EDITOR_GET_ACTIVE_SCREEN_DATA(CMHDZ_EDITOR &widget)

	CMHDZ_COPY_COVER_MAP_DATA_TO_GAME(widget.sCoverMapData)
	CMHDZ_COPY_ITEM_MAP_DATA_TO_GAME(widget.sItemMapData)

ENDPROC 

FUNC INT CMHDZ_EDITOR_PLACE_NEW_UNIT(CMHDZ_EDITOR &widget, INT iEntityType = -1)
	INT iSlot 
	VECTOR_2D vPos
	//VECTOR_2D vScnOrigin = CMHDZ_GET_ORIGIN_FOR_SCREEN((CEIL(sCMHDZData.fOverallLevelProgression/((cfRIGHT_SCREEN_LIMIT + cfLEFT_SCREEN_LIMIT)/2))))
	CMHDZ_ASSET_TYPES eAssetType = CMHDZ_ASSET_TRASHBAG_BIG
	CMHDZ_ITEM_TYPES eItemType = CMHDZ_ITEM_HEALTH
	CMHDZ_ENEMY_TYPES eEnemyType = CMHDZ_ENEMY_1
//	CMHDZ_HOSTAGE_TYPES eHostageType = CMHDZ_HOSTAGE_GIRL
	
	vPos.x = cfBASE_SCREEN_WIDTH / 2.0
	vPos.y = cfBASE_SCREEN_HEIGHT / 2.0

	SWITCH (widget.iEditMode)
		CASE CMHDZ_EDITOR_MODE_COVER
			iSlot = CMHDZ_GET_COVER_MAP_DATA_SLOT(widget.sCoverMapData)
			IF (iSlot = -1)
				RETURN -1
			ENDIF 
			
			IF (iEntityType != -1)
				eAssetType = INT_TO_ENUM(CMHDZ_ASSET_TYPES, iEntityType)
			ENDIF
			
			CMHDZ_RESET_COVER_MAP_DATA(widget.sCoverMapData[iSlot])			
			CMHDZ_SET_DEFAULT_COVER_MAP_DATA(widget.sCoverMapData[iSlot], vPos, eAssetType, ciCMHDZ_LANE_MIDDLE)
			CMHDZ_EDITOR_GET_ACTIVE_SCREEN_DATA(widget)
			widget.iSelectedData = iSlot
			widget.bRebuildMenu = TRUE
			RETURN iSlot
		BREAK
		CASE CMHDZ_EDITOR_MODE_ITEM
			iSlot = CMHDZ_GET_ITEM_MAP_DATA_SLOT(widget.sItemMapData)
			IF (iSlot = -1)
				RETURN -1
			ENDIF 
			
			IF (iEntityType != -1)
				eItemType = INT_TO_ENUM(CMHDZ_ITEM_TYPES, iEntityType)
			ENDIF
			
			CMHDZ_RESET_ITEM_MAP_DATA(widget.sItemMapData[iSlot])			
			CMHDZ_SET_ITEM_MAP_DATA(widget.sItemMapData[iSlot], vPos, eItemType, ciCMHDZ_LANE_MIDDLE, DEFAULT, DEFAULT, (ROUND(sCMHDZData.fOverallLevelProgression/cfCMHDZ_SCREEN_LENGTH)))
			CMHDZ_COPY_ITEM_MAP_DATA_TO_GAME(widget.sItemMapData)
			sCMHDZData.sItemData[iSlot].bRendering = TRUE
			widget.iSelectedData = iSlot
			widget.bRebuildMenu = TRUE
			RETURN iSlot
		BREAK
		CASE CMHDZ_EDITOR_MODE_ENEMY
			iSlot = CMHDZ_GET_ENEMY_MAP_DATA_SLOT(widget.sEnemyMapData)
			IF (iSlot = -1)
				RETURN -1
			ENDIF 
			
			IF (iEntityType != -1)
				eEnemyType = INT_TO_ENUM(CMHDZ_ENEMY_TYPES, iEntityType)
			ENDIF
			
			CMHDZ_RESET_ENEMY_MAP_DATA(widget.sEnemyMapData[iSlot])			
			CMHDZ_SET_ENEMY_MAP_DATA(widget.sEnemyMapData[iSlot], vPos, 940.0, ciCMHDZ_LANE_MIDDLE, FALSE, eEnemyType, sCMHDZData.fOverallLevelProgression, FALSE, FALSE, 0)
			CMHDZ_COPY_ENEMY_MAP_DATA_TO_GAME(widget.sEnemyMapData)
			widget.iSelectedData = iSlot
			widget.bRebuildMenu = TRUE
			RETURN iSlot
		BREAK	
//		CASE CMHDZ_EDITOR_MODE_HOSTAGE
//			iSlot = CMHDZ_GET_HOSTAGE_MAP_DATA_SLOT(widget.sHostageMapData)
//			IF (iSlot = -1)
//				RETURN -1
//			ENDIF 
//			
//			IF (iEntityType != -1)
//				eHostageType = INT_TO_ENUM(CMHDZ_HOSTAGE_TYPES, iEntityType)
//			ENDIF
//			
//			CMHDZ_RESET_HOSTAGE_MAP_DATA(widget.sHostageMapData[iSlot])			
//			CMHDZ_SET_HOSTAGE_MAP_DATA(widget.sHostageMapData[iSlot], vPos, 940, ciCMHDZ_LANE_MIDDLE, FALSE, eHostageType)
//			CMHDZ_COPY_HOSTAGE_MAP_DATA_TO_GAME(widget.sHostageMapData)
//			widget.iSelectedData = iSlot
//			widget.bRebuildMenu = TRUE
//			RETURN iSlot
//		BREAK	
	ENDSWITCH
	
	RETURN -1
ENDFUNC

PROC CMHDZ_EDITOR_ADD_MENU_ITEM_BOOL(CMHDZ_EDITOR &w, INT iRow, STRING opt, BOOL bValue, BOOL bArrows = TRUE)
	ADD_MENU_ITEM_TEXT(iRow, "STRING", 1, TRUE)
	ADD_MENU_ITEM_TEXT_COMPONENT_LITERAL(opt)
	ADD_MENU_ITEM_TEXT(iRow, "STRING", 1, TRUE)
	IF (bValue)
		ADD_MENU_ITEM_TEXT_COMPONENT_LITERAL("ON")
	ELSE 
		ADD_MENU_ITEM_TEXT_COMPONENT_LITERAL("OFF")
	ENDIF 
	SET_MENU_ITEM_TOGGLEABLE(FALSE, bArrows)
	
	w.iMenuMaxSelection ++
ENDPROC 

PROC CMHDZ_EDITOR_ADD_MENU_ITEM_INT(CMHDZ_EDITOR &w, INT iRow, STRING opt, INT iValue, BOOL bArrows = TRUE)
	ADD_MENU_ITEM_TEXT(iRow, "STRING", 1, TRUE)
	ADD_MENU_ITEM_TEXT_COMPONENT_LITERAL(opt)
	ADD_MENU_ITEM_TEXT(iRow, "STRING", 1, TRUE)
	ADD_MENU_ITEM_TEXT_COMPONENT_LITERAL(GET_STRING_FROM_INT(iValue))
	SET_MENU_ITEM_TOGGLEABLE(FALSE, bArrows)
	w.iMenuMaxSelection ++
ENDPROC 

PROC CMHDZ_EDITOR_ADD_MENU_ITEM_FLOAT(CMHDZ_EDITOR &w, INT iRow, STRING opt, FLOAT fValue, INT dp = 2, BOOL bArrows = TRUE)
	ADD_MENU_ITEM_TEXT(iRow, "STRING", 1, TRUE)
	ADD_MENU_ITEM_TEXT_COMPONENT_LITERAL(opt)
	ADD_MENU_ITEM_TEXT(iRow, "STRING", 1, TRUE)
	ADD_MENU_ITEM_TEXT_COMPONENT_LITERAL(GET_STRING_FROM_FLOAT(fValue, dp))
	SET_MENU_ITEM_TOGGLEABLE(FALSE, bArrows)
	w.iMenuMaxSelection ++
ENDPROC 
	
PROC CMHDZ_EDITOR_ADD_MENU_ITEM_STRING(CMHDZ_EDITOR &w, INT iRow, STRING opt, STRING sValue, BOOL bArrows = TRUE)
	ADD_MENU_ITEM_TEXT(iRow, "STRING", 1, TRUE)
	ADD_MENU_ITEM_TEXT_COMPONENT_LITERAL(opt)
	ADD_MENU_ITEM_TEXT(iRow, "STRING", 1, TRUE)
	ADD_MENU_ITEM_TEXT_COMPONENT_LITERAL(sValue)
	SET_MENU_ITEM_TOGGLEABLE(FALSE, bArrows)
	w.iMenuMaxSelection ++
ENDPROC 

PROC CMHDZ_EDITOR_BUILD_COVER_MENU(CMHDZ_EDITOR &w)
	INT iStrLen 
	STRING str 
	
	// add asset type
	ADD_MENU_ITEM_TEXT(CMHDZ_EDITOR_MODE_COVER_NEW_UNIT, "STRING", 1, TRUE)
	ADD_MENU_ITEM_TEXT_COMPONENT_LITERAL("Place New")
	ADD_MENU_ITEM_TEXT(CMHDZ_EDITOR_MODE_COVER_NEW_UNIT, "STRING", 1, TRUE)
	
	str = CMHDZ_ASSET_TYPES_TO_STRING(INT_TO_ENUM(CMHDZ_ASSET_TYPES, w.iNewUnitData))
	iStrlen = GET_LENGTH_OF_LITERAL_STRING(str)
	
	ADD_MENU_ITEM_TEXT_COMPONENT_LITERAL(GET_STRING_FROM_STRING(str, 6, iStrLen))
	SET_MENU_ITEM_TOGGLEABLE(FALSE, TRUE)
	w.iMenuMaxSelection ++
	
	// selected index 
	ADD_MENU_ITEM_TEXT(CMHDZ_EDITOR_MODE_COVER_INDEX, "STRING", 1, TRUE)
	ADD_MENU_ITEM_TEXT_COMPONENT_LITERAL("Selected Item")
	ADD_MENU_ITEM_TEXT(CMHDZ_EDITOR_MODE_COVER_INDEX, "STRING", 1, TRUE)
	ADD_MENU_ITEM_TEXT_COMPONENT_LITERAL(GET_STRING_FROM_INT(w.iSelectedData))
	SET_MENU_ITEM_TOGGLEABLE(FALSE, TRUE)
	w.iMenuMaxSelection ++
	
	// level to edit
	ADD_MENU_ITEM_TEXT(CMHDZ_EDITOR_MODE_COVER_LEVEL, "STRING", 1, TRUE)
	ADD_MENU_ITEM_TEXT_COMPONENT_LITERAL("Level")
	ADD_MENU_ITEM_TEXT(CMHDZ_EDITOR_MODE_COVER_LEVEL, "STRING", 1, TRUE)
	ADD_MENU_ITEM_TEXT_COMPONENT_LITERAL(CMHDZ_LEVELS_TO_STRING(INT_TO_ENUM(CMHDZ_LEVELS, w.iActiveLevel)))
	SET_MENU_ITEM_TOGGLEABLE(FALSE, TRUE)
	w.iMenuMaxSelection ++	

	IF (w.iSelectedData = -1)
		EXIT 
	ENDIF
	
	// add asset type
	ADD_MENU_ITEM_TEXT(CMHDZ_EDITOR_MODE_COVER_TYPE, "STRING", 1, TRUE)
	ADD_MENU_ITEM_TEXT_COMPONENT_LITERAL("Type")
	ADD_MENU_ITEM_TEXT(CMHDZ_EDITOR_MODE_COVER_TYPE, "STRING", 1, TRUE)
	
	str = CMHDZ_ASSET_TYPES_TO_STRING(w.sCoverMapData[w.iSelectedData].eType)
	iStrlen = GET_LENGTH_OF_LITERAL_STRING(str)
	
	ADD_MENU_ITEM_TEXT_COMPONENT_LITERAL(GET_STRING_FROM_STRING(str, 6, iStrLen))
	SET_MENU_ITEM_TOGGLEABLE(FALSE, TRUE)
	w.iMenuMaxSelection ++
	
	// add lane type
	ADD_MENU_ITEM_TEXT(CMHDZ_EDITOR_MODE_COVER_LANE, "STRING", 1, TRUE)
	ADD_MENU_ITEM_TEXT_COMPONENT_LITERAL("Lane")
	ADD_MENU_ITEM_TEXT(CMHDZ_EDITOR_MODE_COVER_LANE, "STRING", 1, TRUE)
	ADD_MENU_ITEM_TEXT_COMPONENT_LITERAL(CMHDZ_LANE_TO_STRING(w.sCoverMapData[w.iSelectedData].iCoverLane))
	SET_MENU_ITEM_TOGGLEABLE(FALSE, TRUE)
	w.iMenuMaxSelection ++		
	
	// add screen type
	ADD_MENU_ITEM_TEXT(CMHDZ_EDITOR_MODE_COVER_SCREEN, "STRING", 1, TRUE)
	ADD_MENU_ITEM_TEXT_COMPONENT_LITERAL("Screen")
	ADD_MENU_ITEM_TEXT(CMHDZ_EDITOR_MODE_COVER_SCREEN, "STRING", 1, TRUE)
			
	INT iActiveScreen = ROUND(sCMHDZData.fOverallLevelProgression/cfCMHDZ_SCREEN_LENGTH)
		
	IF iActiveScreen <= 0
		iActiveScreen = 1
	ENDIF
	
	ADD_MENU_ITEM_TEXT_COMPONENT_LITERAL(CMHDZ_SCREEN_TO_STRING(iActiveScreen))
	w.iMenuMaxSelection ++	
	
	// add pos x
	ADD_MENU_ITEM_TEXT(CMHDZ_EDITOR_MODE_COVER_INITIAL_X, "STRING", 1, TRUE)
	ADD_MENU_ITEM_TEXT_COMPONENT_LITERAL("Initial X Pos / Point to appear")
	ADD_MENU_ITEM_TEXT(CMHDZ_EDITOR_MODE_COVER_INITIAL_X, "STRING", 1, TRUE)
	ADD_MENU_ITEM_TEXT_COMPONENT_LITERAL(GET_STRING_FROM_FLOAT(w.sCoverMapData[w.iSelectedData].vSpriteInitialPos.x, 2))
	w.iMenuMaxSelection ++	
	
	// add pos y
	ADD_MENU_ITEM_TEXT(CMHDZ_EDITOR_MODE_COVER_INITIAL_Y, "STRING", 1, TRUE)
	ADD_MENU_ITEM_TEXT_COMPONENT_LITERAL("Initial Y Pos")
	ADD_MENU_ITEM_TEXT(CMHDZ_EDITOR_MODE_COVER_INITIAL_Y, "STRING", 1, TRUE)
	ADD_MENU_ITEM_TEXT_COMPONENT_LITERAL(GET_STRING_FROM_FLOAT(w.sCoverMapData[w.iSelectedData].vSpriteInitialPos.y, 2))
	w.iMenuMaxSelection ++	
	
	// add never render
	ADD_MENU_ITEM_TEXT(CMHDZ_EDITOR_MODE_COVER_IS_FAR_BG, "STRING", 1, TRUE)
	ADD_MENU_ITEM_TEXT_COMPONENT_LITERAL("Is Far BG")
	ADD_MENU_ITEM_TEXT(CMHDZ_EDITOR_MODE_COVER_IS_FAR_BG, "STRING", 1, TRUE)
	IF IS_BITMASK_ENUM_AS_ENUM_SET(w.sCoverMapData[w.iSelectedData].eDataBits, CMHDZ_COVER_DATA_BITS_IS_FAR_BG)
		ADD_MENU_ITEM_TEXT_COMPONENT_LITERAL("ON")
	ELSE 
		ADD_MENU_ITEM_TEXT_COMPONENT_LITERAL("OFF")
	ENDIF 
	w.iMenuMaxSelection ++
	
	ADD_MENU_ITEM_TEXT(CMHDZ_EDITOR_MODE_COVER_REMOVE_OFF_SCREEN, "STRING", 1, TRUE)
	ADD_MENU_ITEM_TEXT_COMPONENT_LITERAL("Remove when off screen")
	ADD_MENU_ITEM_TEXT(CMHDZ_EDITOR_MODE_COVER_REMOVE_OFF_SCREEN, "STRING", 1, TRUE)
	IF IS_BITMASK_ENUM_AS_ENUM_SET(w.sCoverMapData[w.iSelectedData].eDataBits, CMHDZ_COVER_DATA_BITS_REMOVE_OFF_SCREEN)
		ADD_MENU_ITEM_TEXT_COMPONENT_LITERAL("ON")
	ELSE 
		ADD_MENU_ITEM_TEXT_COMPONENT_LITERAL("OFF")
	ENDIF 
	w.iMenuMaxSelection ++
	
	// add never render
	ADD_MENU_ITEM_TEXT(CMHDZ_EDITOR_MODE_COVER_EXPORT, "STRING", 1, TRUE)
	ADD_MENU_ITEM_TEXT_COMPONENT_LITERAL("Export Cover Info")
	w.iMenuMaxSelection ++
	
	ADD_MENU_ITEM_TEXT(CMHDZ_EDITOR_MODE_COVER_EXPORT_ALL, "STRING", 1, TRUE)
	ADD_MENU_ITEM_TEXT_COMPONENT_LITERAL("Export All Cover Info")
	w.iMenuMaxSelection ++
	
ENDPROC 

PROC CMHDZ_EDITOR_BUILD_ENEMY_MENU(CMHDZ_EDITOR &w)
	INT iStrLen 
	STRING str 
	
	// add asset type
	ADD_MENU_ITEM_TEXT(CMHDZ_EDITOR_MODE_ENEMY_NEW_UNIT, "STRING", 1, TRUE)
	ADD_MENU_ITEM_TEXT_COMPONENT_LITERAL("Place New")
	ADD_MENU_ITEM_TEXT(CMHDZ_EDITOR_MODE_ENEMY_NEW_UNIT, "STRING", 1, TRUE)
	
	str = CMHDZ_ENEMY_TYPES_TO_STRING(INT_TO_ENUM(CMHDZ_ENEMY_TYPES, w.iNewUnitData))
	iStrlen = GET_LENGTH_OF_LITERAL_STRING(str)
	
	ADD_MENU_ITEM_TEXT_COMPONENT_LITERAL(GET_STRING_FROM_STRING(str, 4, iStrLen))
	SET_MENU_ITEM_TOGGLEABLE(FALSE, TRUE)
	w.iMenuMaxSelection ++
		
	// selected index 
	ADD_MENU_ITEM_TEXT(CMHDZ_EDITOR_MODE_ENEMY_INDEX, "STRING", 1, TRUE)
	ADD_MENU_ITEM_TEXT_COMPONENT_LITERAL("Selected Item")
	ADD_MENU_ITEM_TEXT(CMHDZ_EDITOR_MODE_ENEMY_INDEX, "STRING", 1, TRUE)
	ADD_MENU_ITEM_TEXT_COMPONENT_LITERAL(GET_STRING_FROM_INT(w.iSelectedData))
	SET_MENU_ITEM_TOGGLEABLE(FALSE, TRUE)
	w.iMenuMaxSelection ++

	// level to edit
	ADD_MENU_ITEM_TEXT(CMHDZ_EDITOR_MODE_ENEMY_LEVEL, "STRING", 1, TRUE)
	ADD_MENU_ITEM_TEXT_COMPONENT_LITERAL("Level")
	ADD_MENU_ITEM_TEXT(CMHDZ_EDITOR_MODE_ENEMY_LEVEL, "STRING", 1, TRUE)
	ADD_MENU_ITEM_TEXT_COMPONENT_LITERAL(CMHDZ_LEVELS_TO_STRING(INT_TO_ENUM(CMHDZ_LEVELS, w.iActiveLevel)))
	SET_MENU_ITEM_TOGGLEABLE(FALSE, TRUE)
	w.iMenuMaxSelection ++	

	IF (w.iSelectedData = -1)
		EXIT 
	ENDIF
	
	// add asset type
	ADD_MENU_ITEM_TEXT(CMHDZ_EDITOR_MODE_ENEMY_TYPE, "STRING", 1, TRUE)
	ADD_MENU_ITEM_TEXT_COMPONENT_LITERAL("Type")
	ADD_MENU_ITEM_TEXT(CMHDZ_EDITOR_MODE_ENEMY_TYPE, "STRING", 1, TRUE)
	
	str = CMHDZ_ENEMY_TYPES_TO_STRING(w.sEnemyMapData[w.iSelectedData].eEnemyType)
	iStrlen = GET_LENGTH_OF_LITERAL_STRING(str)
	
	ADD_MENU_ITEM_TEXT_COMPONENT_LITERAL(GET_STRING_FROM_STRING(str, 4, iStrLen))
	SET_MENU_ITEM_TOGGLEABLE(FALSE, TRUE)
	w.iMenuMaxSelection ++
	
	// add lane type
	ADD_MENU_ITEM_TEXT(CMHDZ_EDITOR_MODE_ENEMY_LANE, "STRING", 1, TRUE)
	ADD_MENU_ITEM_TEXT_COMPONENT_LITERAL("Lane")
	ADD_MENU_ITEM_TEXT(CMHDZ_EDITOR_MODE_ENEMY_LANE, "STRING", 1, TRUE)
	ADD_MENU_ITEM_TEXT_COMPONENT_LITERAL(CMHDZ_LANE_TO_STRING(w.sEnemyMapData[w.iSelectedData].iLane))
	SET_MENU_ITEM_TOGGLEABLE(FALSE, TRUE)
	w.iMenuMaxSelection ++		

	// add point to appear
	ADD_MENU_ITEM_TEXT(CMHDZ_EDITOR_MODE_ENEMY_POSITION, "STRING", 1, TRUE)
	ADD_MENU_ITEM_TEXT_COMPONENT_LITERAL("Point to Appear")
	ADD_MENU_ITEM_TEXT(CMHDZ_EDITOR_MODE_ENEMY_POSITION, "STRING", 1, TRUE)
	ADD_MENU_ITEM_TEXT_COMPONENT_LITERAL(GET_STRING_FROM_FLOAT(w.sEnemyMapData[w.iSelectedData].fPointToAppear, 2))
	w.iMenuMaxSelection ++	
	
	// add stage type
//	ADD_MENU_ITEM_TEXT(CMHDZ_EDITOR_MODE_ENEMY_SCREEN, "STRING", 1, TRUE)
//	ADD_MENU_ITEM_TEXT_COMPONENT_LITERAL("Screen")
//	ADD_MENU_ITEM_TEXT(CMHDZ_EDITOR_MODE_ENEMY_POSITION, "STRING", 1, TRUE)
//		
//	INT iActiveScreen = CEIL(sCMHDZData.fOverallLevelProgression/((cfRIGHT_SCREEN_LIMIT + cfLEFT_SCREEN_LIMIT)/2))
//		
//	IF iActiveScreen <= 0
//		iActiveScreen = 1
//	ENDIF
//	
//	ADD_MENU_ITEM_TEXT_COMPONENT_LITERAL(CMHDZ_SCREEN_TO_STRING(iActiveScreen))
//	w.iMenuMaxSelection ++				
	
	// add pos x
	ADD_MENU_ITEM_TEXT(CMHDZ_EDITOR_MODE_ENEMY_INITIAL_X, "STRING", 1, TRUE)
	ADD_MENU_ITEM_TEXT_COMPONENT_LITERAL("Initial X Pos")
	ADD_MENU_ITEM_TEXT(CMHDZ_EDITOR_MODE_ENEMY_INITIAL_X, "STRING", 1, TRUE)
	ADD_MENU_ITEM_TEXT_COMPONENT_LITERAL(GET_STRING_FROM_FLOAT(w.sEnemyMapData[w.iSelectedData].vSpritePos.x, 2))
	w.iMenuMaxSelection ++	
	
	// add pos y
	ADD_MENU_ITEM_TEXT(CMHDZ_EDITOR_MODE_ENEMY_INITIAL_Y, "STRING", 1, TRUE)
	ADD_MENU_ITEM_TEXT_COMPONENT_LITERAL("Initial Y Pos")
	ADD_MENU_ITEM_TEXT(CMHDZ_EDITOR_MODE_ENEMY_INITIAL_Y, "STRING", 1, TRUE)
	ADD_MENU_ITEM_TEXT_COMPONENT_LITERAL(GET_STRING_FROM_FLOAT(w.sEnemyMapData[w.iSelectedData].vSpritePos.y, 2))
	w.iMenuMaxSelection ++	
	
	// add stop scrolling pos
	ADD_MENU_ITEM_TEXT(CMHDZ_EDITOR_MODE_ENEMY_STOP_POS, "STRING", 1, TRUE)
	ADD_MENU_ITEM_TEXT_COMPONENT_LITERAL("Stop Pos X")
	ADD_MENU_ITEM_TEXT(CMHDZ_EDITOR_MODE_ENEMY_STOP_POS, "STRING", 1, TRUE)
	ADD_MENU_ITEM_TEXT_COMPONENT_LITERAL(GET_STRING_FROM_FLOAT(w.sEnemyMapData[w.iSelectedData].fStoppingPos, 2))
	w.iMenuMaxSelection ++	
	
	// add never render
	ADD_MENU_ITEM_TEXT(CMHDZ_EDITOR_MODE_ENEMY_WAITSCROLL, "STRING", 1, TRUE)
	ADD_MENU_ITEM_TEXT_COMPONENT_LITERAL("Wait Stationary")
	ADD_MENU_ITEM_TEXT(CMHDZ_EDITOR_MODE_ENEMY_WAITSCROLL, "STRING", 1, TRUE)
	IF IS_BITMASK_ENUM_AS_ENUM_SET(w.sEnemyMapData[w.iSelectedData].eDataBits, CMHDZ_ENEMY_DATA_BITS_WAIT_UNTIL_LEVEL_STATIONARY)
		ADD_MENU_ITEM_TEXT_COMPONENT_LITERAL("ON")
	ELSE 
		ADD_MENU_ITEM_TEXT_COMPONENT_LITERAL("OFF")
	ENDIF 
	w.iMenuMaxSelection ++
	
	// add stop scrolling
	ADD_MENU_ITEM_TEXT(CMHDZ_EDITOR_MODE_ENEMY_REVERSE, "STRING", 1, TRUE)
	ADD_MENU_ITEM_TEXT_COMPONENT_LITERAL("From Left")
	ADD_MENU_ITEM_TEXT(CMHDZ_EDITOR_MODE_ENEMY_REVERSE, "STRING", 1, TRUE)
	IF IS_BITMASK_ENUM_AS_ENUM_SET(w.sEnemyMapData[w.iSelectedData].eDataBits, CMHDZ_ENEMY_DATA_BITS_REVERSE)
		ADD_MENU_ITEM_TEXT_COMPONENT_LITERAL("ON")
	ELSE 
		ADD_MENU_ITEM_TEXT_COMPONENT_LITERAL("OFF")
	ENDIF 
	w.iMenuMaxSelection ++	
	
	// add never render
	ADD_MENU_ITEM_TEXT(CMHDZ_EDITOR_MODE_ENEMY_IS_POP_UP, "STRING", 1, TRUE)
	ADD_MENU_ITEM_TEXT_COMPONENT_LITERAL("Pop Up")
	ADD_MENU_ITEM_TEXT(CMHDZ_EDITOR_MODE_ENEMY_IS_POP_UP, "STRING", 1, TRUE)
	IF IS_BITMASK_ENUM_AS_ENUM_SET(w.sEnemyMapData[w.iSelectedData].eDataBits, CMHDZ_ENEMY_DATA_BITS_IS_POPUP)
		ADD_MENU_ITEM_TEXT_COMPONENT_LITERAL("ON")
	ELSE 
		ADD_MENU_ITEM_TEXT_COMPONENT_LITERAL("OFF")
	ENDIF 
	w.iMenuMaxSelection ++
	
	// add render warp count
//	ADD_MENU_ITEM_TEXT(CMHDZ_EDITOR_MODE_ENEMY_RENDERWARP, "STRING", 1, TRUE)
//	ADD_MENU_ITEM_TEXT_COMPONENT_LITERAL("Warp Count")
//	ADD_MENU_ITEM_TEXT(w.iMenuMaxSelection, "STRING", 1, TRUE)
//	ADD_MENU_ITEM_TEXT_COMPONENT_LITERAL(GET_STRING_FROM_INT(w.sEnemyMapData[w.iSelectedData].iRenderAfterWarpCount))
//	SET_MENU_ITEM_TOGGLEABLE(FALSE, TRUE)
//	w.iMenuMaxSelection ++	
	
	ADD_MENU_ITEM_TEXT(CMHDZ_EDITOR_MODE_ENEMY_EXPORT, "STRING", 1, TRUE)
	ADD_MENU_ITEM_TEXT_COMPONENT_LITERAL("Export Enemy Info")
	//ADD_MENU_ITEM_TEXT(CMHDZ_EDITOR_MODE_ENEMY_EXPORT, "STRING", 1, TRUE)
	w.iMenuMaxSelection ++
	
	ADD_MENU_ITEM_TEXT(CMHDZ_EDITOR_MODE_ENEMY_EXPORT_ALL, "STRING", 1, TRUE)
	ADD_MENU_ITEM_TEXT_COMPONENT_LITERAL("Export All Enemy Info")
	//ADD_MENU_ITEM_TEXT(CMHDZ_EDITOR_MODE_ENEMY_EXPORT_ALL, "STRING", 1, TRUE)
	w.iMenuMaxSelection ++

ENDPROC 

PROC CMHDZ_EDITOR_BUILD_ITEM_MENU(CMHDZ_EDITOR &w)
	INT iStrLen 
	STRING str 
	
	// add asset type
	ADD_MENU_ITEM_TEXT(CMHDZ_EDITOR_MODE_ITEM_NEW_UNIT, "STRING", 1, TRUE)
	ADD_MENU_ITEM_TEXT_COMPONENT_LITERAL("Place New")
	ADD_MENU_ITEM_TEXT(CMHDZ_EDITOR_MODE_ITEM_NEW_UNIT, "STRING", 1, TRUE)
	
	str = CMHDZ_ITEM_TYPES_TO_STRING(INT_TO_ENUM(CMHDZ_ITEM_TYPES, w.iNewUnitData))
	iStrlen = GET_LENGTH_OF_LITERAL_STRING(str)
	
	ADD_MENU_ITEM_TEXT_COMPONENT_LITERAL(GET_STRING_FROM_STRING(str, 5, iStrLen))
	SET_MENU_ITEM_TOGGLEABLE(FALSE, TRUE)
	w.iMenuMaxSelection ++
	
	// selected index 
	ADD_MENU_ITEM_TEXT(CMHDZ_EDITOR_MODE_ITEM_INDEX, "STRING", 1, TRUE)
	ADD_MENU_ITEM_TEXT_COMPONENT_LITERAL("Selected Item")
	ADD_MENU_ITEM_TEXT(CMHDZ_EDITOR_MODE_ITEM_INDEX, "STRING", 1, TRUE)
	ADD_MENU_ITEM_TEXT_COMPONENT_LITERAL(GET_STRING_FROM_INT(w.iSelectedData))
	SET_MENU_ITEM_TOGGLEABLE(FALSE, TRUE)
	w.iMenuMaxSelection ++

	// level to edit
	ADD_MENU_ITEM_TEXT(CMHDZ_EDITOR_MODE_ITEM_LEVEL, "STRING", 1, TRUE)
	ADD_MENU_ITEM_TEXT_COMPONENT_LITERAL("Level")
	ADD_MENU_ITEM_TEXT(CMHDZ_EDITOR_MODE_ITEM_LEVEL, "STRING", 1, TRUE)
	ADD_MENU_ITEM_TEXT_COMPONENT_LITERAL(CMHDZ_LEVELS_TO_STRING(INT_TO_ENUM(CMHDZ_LEVELS, w.iActiveLevel)))
	SET_MENU_ITEM_TOGGLEABLE(FALSE, TRUE)
	w.iMenuMaxSelection ++	

	IF (w.iSelectedData = -1)
		EXIT 
	ENDIF
	
	// add asset type
	ADD_MENU_ITEM_TEXT(CMHDZ_EDITOR_MODE_ITEM_TYPE, "STRING", 1, TRUE)
	ADD_MENU_ITEM_TEXT_COMPONENT_LITERAL("Type")
	ADD_MENU_ITEM_TEXT(CMHDZ_EDITOR_MODE_ITEM_TYPE, "STRING", 1, TRUE)
	
	str = CMHDZ_ITEM_TYPES_TO_STRING(w.sItemMapData[w.iSelectedData].eItemType)
	iStrlen = GET_LENGTH_OF_LITERAL_STRING(str)
	
	ADD_MENU_ITEM_TEXT_COMPONENT_LITERAL(GET_STRING_FROM_STRING(str, 6, iStrLen))
	SET_MENU_ITEM_TOGGLEABLE(FALSE, TRUE)
	w.iMenuMaxSelection ++
	
	// add lane type
	ADD_MENU_ITEM_TEXT(CMHDZ_EDITOR_MODE_ITEM_LANE, "STRING", 1, TRUE)
	ADD_MENU_ITEM_TEXT_COMPONENT_LITERAL("Lane")
	ADD_MENU_ITEM_TEXT(CMHDZ_EDITOR_MODE_ITEM_LANE, "STRING", 1, TRUE)
	ADD_MENU_ITEM_TEXT_COMPONENT_LITERAL(CMHDZ_LANE_TO_STRING(w.sItemMapData[w.iSelectedData].iLane))
	SET_MENU_ITEM_TOGGLEABLE(FALSE, TRUE)
	w.iMenuMaxSelection ++		
	
	// add stage type
	ADD_MENU_ITEM_TEXT(CMHDZ_EDITOR_MODE_ITEM_SCREEN, "STRING", 1, TRUE)
	ADD_MENU_ITEM_TEXT_COMPONENT_LITERAL("Screen")
	ADD_MENU_ITEM_TEXT(CMHDZ_EDITOR_MODE_ITEM_SCREEN, "STRING", 1, TRUE)
	
	INT iActiveScreen = ROUND(sCMHDZData.fOverallLevelProgression/cfCMHDZ_SCREEN_LENGTH)
		
	IF iActiveScreen <= 0
		iActiveScreen = 1
	ENDIF
	
	ADD_MENU_ITEM_TEXT_COMPONENT_LITERAL(CMHDZ_SCREEN_TO_STRING(iActiveScreen))
	SET_MENU_ITEM_TOGGLEABLE(FALSE, TRUE)
	w.iMenuMaxSelection ++	
	
	// add pos x
	ADD_MENU_ITEM_TEXT(CMHDZ_EDITOR_MODE_ITEM_INITIAL_X, "STRING", 1, TRUE)
	ADD_MENU_ITEM_TEXT_COMPONENT_LITERAL("Initial X Pos")
	ADD_MENU_ITEM_TEXT(CMHDZ_EDITOR_MODE_ITEM_INITIAL_X, "STRING", 1, TRUE)
	ADD_MENU_ITEM_TEXT_COMPONENT_LITERAL(GET_STRING_FROM_FLOAT(w.sItemMapData[w.iSelectedData].vSpritePos.x, 2))
	w.iMenuMaxSelection ++	
	
	// add pos y
	ADD_MENU_ITEM_TEXT(CMHDZ_EDITOR_MODE_ITEM_INITIAL_Y, "STRING", 1, TRUE)
	ADD_MENU_ITEM_TEXT_COMPONENT_LITERAL("Initial Y Pos")
	ADD_MENU_ITEM_TEXT(CMHDZ_EDITOR_MODE_ITEM_INITIAL_Y, "STRING", 1, TRUE)
	ADD_MENU_ITEM_TEXT_COMPONENT_LITERAL(GET_STRING_FROM_FLOAT(w.sItemMapData[w.iSelectedData].vSpritePos.y, 2))
	w.iMenuMaxSelection ++	
	
	// add render warp count
	ADD_MENU_ITEM_TEXT(CMHDZ_EDITOR_MODE_ITEM_RENDERWARP, "STRING", 1, TRUE)
	ADD_MENU_ITEM_TEXT_COMPONENT_LITERAL("Warp Count")
	ADD_MENU_ITEM_TEXT(CMHDZ_EDITOR_MODE_ITEM_RENDERWARP, "STRING", 1, TRUE)
	ADD_MENU_ITEM_TEXT_COMPONENT_LITERAL(GET_STRING_FROM_INT(w.sItemMapData[w.iSelectedData].iRenderAfterWarpCount))
	SET_MENU_ITEM_TOGGLEABLE(FALSE, TRUE)
	w.iMenuMaxSelection ++				
	
	// add stop scrolling pos
	ADD_MENU_ITEM_TEXT(CMHDZ_EDITOR_MODE_ITEM_FORCESCALE, "STRING", 1, TRUE)
	ADD_MENU_ITEM_TEXT_COMPONENT_LITERAL("Force Scale")
	ADD_MENU_ITEM_TEXT(CMHDZ_EDITOR_MODE_ITEM_FORCESCALE, "STRING", 1, TRUE)
	ADD_MENU_ITEM_TEXT_COMPONENT_LITERAL(GET_STRING_FROM_FLOAT(w.sItemMapData[w.iSelectedData].fForceScale, 4))
	w.iMenuMaxSelection ++	
	
	ADD_MENU_ITEM_TEXT(CMHDZ_EDITOR_MODE_ITEM_EXPORT, "STRING", 1, TRUE)
	ADD_MENU_ITEM_TEXT_COMPONENT_LITERAL("Export Item Info")
	w.iMenuMaxSelection ++
	
	ADD_MENU_ITEM_TEXT(CMHDZ_EDITOR_MODE_ITEM_EXPORT_ALL, "STRING", 1, TRUE)
	ADD_MENU_ITEM_TEXT_COMPONENT_LITERAL("Export All Item Info")
	//ADD_MENU_ITEM_TEXT(CMHDZ_EDITOR_MODE_ITEM_EXPORT_ALL, "STRING", 1, TRUE)
	w.iMenuMaxSelection ++
ENDPROC 

PROC CMHDZ_EDITOR_BUILD_LEVEL_MENU(CMHDZ_EDITOR &w)
	// level to edit
	ADD_MENU_ITEM_TEXT(CMHDZ_EDITOR_MODE_LEVEL_INDEX, "STRING", 1, TRUE)
	ADD_MENU_ITEM_TEXT_COMPONENT_LITERAL("Level")
	ADD_MENU_ITEM_TEXT(CMHDZ_EDITOR_MODE_LEVEL_INDEX, "STRING", 1, TRUE)
	ADD_MENU_ITEM_TEXT_COMPONENT_LITERAL(CMHDZ_LEVELS_TO_STRING(INT_TO_ENUM(CMHDZ_LEVELS, w.iActiveLevel)))
	SET_MENU_ITEM_TOGGLEABLE(FALSE, TRUE)
	w.iMenuMaxSelection ++	
	
	// stage to edit
	ADD_MENU_ITEM_TEXT(CMHDZ_EDITOR_MODE_LEVEL_PROGRESS_SET, "STRING", 1, TRUE)
	ADD_MENU_ITEM_TEXT_COMPONENT_LITERAL("Level Progression")
	ADD_MENU_ITEM_TEXT(CMHDZ_EDITOR_MODE_LEVEL_PROGRESS_SET, "STRING", 1, TRUE)
	ADD_MENU_ITEM_TEXT_COMPONENT_LITERAL(GET_STRING_FROM_INT(ROUND(sCMHDZData.fOverallLevelProgression)))
	w.iMenuMaxSelection ++
	
	// add screen type
	ADD_MENU_ITEM_TEXT(CMHDZ_EDITOR_MODE_LEVEL_SCREEN, "STRING", 1, TRUE)
	ADD_MENU_ITEM_TEXT_COMPONENT_LITERAL("Screen")
	ADD_MENU_ITEM_TEXT(CMHDZ_EDITOR_MODE_LEVEL_SCREEN, "STRING", 1, TRUE)
	
	INT iActiveScreen = ROUND(sCMHDZData.fOverallLevelProgression/cfCMHDZ_SCREEN_LENGTH)
		
	IF iActiveScreen <= 0
		iActiveScreen = 1
	ENDIF
	
	ADD_MENU_ITEM_TEXT_COMPONENT_LITERAL(CMHDZ_SCREEN_TO_STRING(iActiveScreen))
	w.iMenuMaxSelection ++	
	
	// add screen type
	//ADD_MENU_ITEM_TEXT(CMHDZ_EDITOR_MODE_LEVEL_STOP_PROP, "STRING", 1, TRUE)
	ADD_MENU_ITEM_TEXT_COMPONENT_LITERAL("View Stop Prop")
	//ADD_MENU_ITEM_TEXT(CMHDZ_EDITOR_MODE_LEVEL_STOP_PROP, "STRING", 1, TRUE)
	//ADD_MENU_ITEM_TEXT_COMPONENT_LITERAL(GET_STRING_FROM_INT(sCMHDZData.iPropToStopOn[(CEIL(sCMHDZData.fOverallLevelProgression/((cfRIGHT_SCREEN_LIMIT + cfLEFT_SCREEN_LIMIT)/2)))]))
	SET_MENU_ITEM_TOGGLEABLE(FALSE, TRUE)
	w.iMenuMaxSelection ++	
	
	// add export level
	ADD_MENU_ITEM_TEXT(CMHDZ_EDITOR_MODE_LEVEL_PLAY, "STRING", 1, TRUE)
	ADD_MENU_ITEM_TEXT_COMPONENT_LITERAL("Play Active Stage")
	w.iMenuMaxSelection ++	
	
	// add reset level
	ADD_MENU_ITEM_TEXT(CMHDZ_EDITOR_MODE_LEVEL_RESET, "STRING", 1, (ENUM_TO_INT(sCMHDZData.eCurrentLevel) = w.iActiveLevel))
	ADD_MENU_ITEM_TEXT_COMPONENT_LITERAL("Reset Editor Level")
	w.iMenuMaxSelection ++	
	
	// add load level
	ADD_MENU_ITEM_TEXT(CMHDZ_EDITOR_MODE_EXPORT_LEVEL, "STRING", 1, TRUE)
	ADD_MENU_ITEM_TEXT_COMPONENT_LITERAL("Export Level Map to Game")
	w.iMenuMaxSelection ++	
ENDPROC

//PROC CMHDZ_EDITOR_BUILD_HOSTAGE_MENU(CMHDZ_EDITOR &w)
//	INT iStrLen 
//	STRING str 
//	
//	// add asset type
//	ADD_MENU_ITEM_TEXT(CMHDZ_EDITOR_MODE_HOSTAGE_NEW_UNIT, "STRING", 1, TRUE)
//	ADD_MENU_ITEM_TEXT_COMPONENT_LITERAL("Place New")
//	ADD_MENU_ITEM_TEXT(CMHDZ_EDITOR_MODE_HOSTAGE_NEW_UNIT, "STRING", 1, TRUE)
//	
//	str = CMHDZ_HOSTAGE_TYPES_TO_STRING(INT_TO_ENUM(CMHDZ_HOSTAGE_TYPES, w.iNewUnitData))
//	iStrlen = GET_LENGTH_OF_LITERAL_STRING(str)
//	
//	ADD_MENU_ITEM_TEXT_COMPONENT_LITERAL(GET_STRING_FROM_STRING(str, 4, iStrLen))
//	SET_MENU_ITEM_TOGGLEABLE(FALSE, TRUE)
//	w.iMenuMaxSelection ++
//	
//	// selected index 
//	ADD_MENU_ITEM_TEXT(CMHDZ_EDITOR_MODE_HOSTAGE_INDEX, "STRING", 1, TRUE)
//	ADD_MENU_ITEM_TEXT_COMPONENT_LITERAL("Selected Item")
//	ADD_MENU_ITEM_TEXT(CMHDZ_EDITOR_MODE_HOSTAGE_INDEX, "STRING", 1, TRUE)
//	ADD_MENU_ITEM_TEXT_COMPONENT_LITERAL(GET_STRING_FROM_INT(w.iSelectedData))
//	SET_MENU_ITEM_TOGGLEABLE(FALSE, TRUE)
//	w.iMenuMaxSelection ++
//
//	IF (w.iSelectedData = -1)
//		EXIT 
//	ENDIF
//	
//	// add asset type
//	ADD_MENU_ITEM_TEXT(CMHDZ_EDITOR_MODE_HOSTAGE_TYPE, "STRING", 1, TRUE)
//	ADD_MENU_ITEM_TEXT_COMPONENT_LITERAL("Type")
//	ADD_MENU_ITEM_TEXT(CMHDZ_EDITOR_MODE_HOSTAGE_TYPE, "STRING", 1, TRUE)
//	
//	str = CMHDZ_HOSTAGE_TYPES_TO_STRING(w.sHostageMapData[w.iSelectedData].eHostageType)
//	iStrlen = GET_LENGTH_OF_LITERAL_STRING(str)
//	
//	ADD_MENU_ITEM_TEXT_COMPONENT_LITERAL(GET_STRING_FROM_STRING(str, 4, iStrLen))
//	SET_MENU_ITEM_TOGGLEABLE(FALSE, TRUE)
//	w.iMenuMaxSelection ++
//	
//	// add lane type
//	ADD_MENU_ITEM_TEXT(CMHDZ_EDITOR_MODE_HOSTAGE_LANE, "STRING", 1, TRUE)
//	ADD_MENU_ITEM_TEXT_COMPONENT_LITERAL("Lane")
//	ADD_MENU_ITEM_TEXT(CMHDZ_EDITOR_MODE_HOSTAGE_LANE, "STRING", 1, TRUE)
//	ADD_MENU_ITEM_TEXT_COMPONENT_LITERAL(CMHDZ_LANE_TO_STRING(w.sHostageMapData[w.iSelectedData].iHostageLane))
//	SET_MENU_ITEM_TOGGLEABLE(FALSE, TRUE)
//	w.iMenuMaxSelection ++					
//	
//	// add pos x
//	ADD_MENU_ITEM_TEXT(CMHDZ_EDITOR_MODE_HOSTAGE_INITIAL_X, "STRING", 1, TRUE)
//	ADD_MENU_ITEM_TEXT_COMPONENT_LITERAL("Initial X Pos")
//	ADD_MENU_ITEM_TEXT(w.iMenuMaxSelection, "STRING", 1, TRUE)
//	ADD_MENU_ITEM_TEXT_COMPONENT_LITERAL(GET_STRING_FROM_FLOAT(w.sHostageMapData[w.iSelectedData].vSpritePos.x, 2))
//	w.iMenuMaxSelection ++	
//	
//	// add pos y
//	ADD_MENU_ITEM_TEXT(CMHDZ_EDITOR_MODE_HOSTAGE_INITIAL_Y, "STRING", 1, TRUE)
//	ADD_MENU_ITEM_TEXT_COMPONENT_LITERAL("Initial Y Pos")
//	ADD_MENU_ITEM_TEXT(w.iMenuMaxSelection, "STRING", 1, TRUE)
//	ADD_MENU_ITEM_TEXT_COMPONENT_LITERAL(GET_STRING_FROM_FLOAT(w.sHostageMapData[w.iSelectedData].vSpritePos.y, 2))
//	w.iMenuMaxSelection ++	
//	
//	// add stop scrolling
//	ADD_MENU_ITEM_TEXT(CMHDZ_EDITOR_MODE_HOSTAGE_REVERSE, "STRING", 1, TRUE)
//	ADD_MENU_ITEM_TEXT_COMPONENT_LITERAL("From Left")
//	ADD_MENU_ITEM_TEXT(w.iMenuMaxSelection, "STRING", 1, TRUE)
//	IF IS_BIT_SET(w.sHostageMapData[w.iSelectedData].iBitset, ENUM_TO_INT(CMHDZ_HOSTAGE_BIT_GOING_BACK))
//		ADD_MENU_ITEM_TEXT_COMPONENT_LITERAL("ON")
//	ELSE 
//		ADD_MENU_ITEM_TEXT_COMPONENT_LITERAL("OFF")
//	ENDIF 
//	w.iMenuMaxSelection ++	
//	
//	// add stop scrolling pos
//	ADD_MENU_ITEM_TEXT(CMHDZ_EDITOR_MODE_HOSTAGE_STOP_POS, "STRING", 1, TRUE)
//	ADD_MENU_ITEM_TEXT_COMPONENT_LITERAL("Stop Pos X")
//	ADD_MENU_ITEM_TEXT(w.iMenuMaxSelection, "STRING", 1, TRUE)
//	ADD_MENU_ITEM_TEXT_COMPONENT_LITERAL(GET_STRING_FROM_FLOAT(w.sHostageMapData[w.iSelectedData].fStoppingX, 2))
//	w.iMenuMaxSelection ++	
//ENDPROC 

PROC CMHDZ_EDITOR_BUILD_PLAY_MENU(CMHDZ_EDITOR &w, BOOL bPlayMode = TRUE)
	TEXT_LABEL_63 str 
	//INT iCurrentStage = CMHDZ_GET_CURRENT_LEVEL_SCREEN()
	w.iMenuCurrentSelection = 0
	
	IF (bPlayMode = TRUE)
		CLEAR_MENU_DATA()
		SET_MENU_TITLE("STRING")
		str = "ACTIVE LEVEL: "
		str += CMHDZ_LEVELS_TO_STRING(sCMHDZData.eCurrentLevel)
		ADD_LITERAL_TO_MENU_TITLE(str)
		SET_MENU_HEADER_COLOUR(0, 128, 0, 255, TRUE)

		SET_MENU_ITEM_JUSTIFICATION(FONT_LEFT, FONT_RIGHT)
		SET_MENU_ITEM_LAYOUT(MENU_ITEM_TEXT, MENU_ITEM_TEXT)
		SET_CURRENT_MENU_ITEM(w.iMenuCurrentSelection)
	ENDIF
	
	w.iMenuMaxSelection = 0
	
	// add asset type
	ADD_MENU_ITEM_TEXT(w.iMenuMaxSelection, "STRING", 1, TRUE)
	ADD_MENU_ITEM_TEXT_COMPONENT_LITERAL("Current Screen")
	ADD_MENU_ITEM_TEXT(w.iMenuMaxSelection, "STRING", 1, TRUE)
	ADD_MENU_ITEM_TEXT_COMPONENT_LITERAL(GET_STRING_FROM_INT(sCMHDZData.iCurrentScreen))
	w.iMenuMaxSelection ++
	
	ADD_MENU_ITEM_TEXT(w.iMenuMaxSelection, "STRING", 1, TRUE)
	ADD_MENU_ITEM_TEXT_COMPONENT_LITERAL("Overall Progression")
	ADD_MENU_ITEM_TEXT(w.iMenuMaxSelection, "STRING", 1, TRUE)
	ADD_MENU_ITEM_TEXT_COMPONENT_LITERAL(GET_STRING_FROM_INT(ROUND(sCMHDZData.fOverallLevelProgression)))
	w.iMenuMaxSelection ++
	
	// add asset type
//	ADD_MENU_ITEM_TEXT(w.iMenuMaxSelection, "STRING", 1, TRUE)
//	ADD_MENU_ITEM_TEXT_COMPONENT_LITERAL("Stop Prop For Screen")
//	ADD_MENU_ITEM_TEXT(w.iMenuMaxSelection, "STRING", 1, TRUE)
//	IF (sCMHDZData.iCurrentScreen != -1)
//		//ADD_MENU_ITEM_TEXT_COMPONENT_LITERAL(GET_STRING_FROM_INT(sCMHDZData.iPropToStopOn[sCMHDZData.iCurrentScreen]))
//	ELSE 
//		ADD_MENU_ITEM_TEXT_COMPONENT_LITERAL("INVALID")
//	ENDIF
//	w.iMenuMaxSelection ++
	
//	// add asset type
//	ADD_MENU_ITEM_TEXT(w.iMenuMaxSelection, "STRING", 1, TRUE)
//	ADD_MENU_ITEM_TEXT_COMPONENT_LITERAL("Screen To Stop On")
//	ADD_MENU_ITEM_TEXT(w.iMenuMaxSelection, "STRING", 1, TRUE)
//	w.iMenuMaxSelection ++	
	
	// selected index 	
	ADD_MENU_ITEM_TEXT(w.iMenuMaxSelection, "STRING", 1, TRUE)
	ADD_MENU_ITEM_TEXT_COMPONENT_LITERAL("Enemies Left For Stage")
	ADD_MENU_ITEM_TEXT(w.iMenuMaxSelection, "STRING", 1, TRUE)
	ADD_MENU_ITEM_TEXT_COMPONENT_LITERAL(GET_STRING_FROM_INT(CMHDZ_GET_TOTAL_NUMBER_OF_ENEMIES_LEFT_ALIVE_FOR_LEVEL()))
	SET_MENU_ITEM_TOGGLEABLE(FALSE, FALSE)
	w.iMenuMaxSelection ++	
	
	// selected index 	
	ADD_MENU_ITEM_TEXT(w.iMenuMaxSelection, "STRING", 1, TRUE)
	ADD_MENU_ITEM_TEXT_COMPONENT_LITERAL("Enemies Alive for Phase")
	ADD_MENU_ITEM_TEXT(w.iMenuMaxSelection, "STRING", 1, TRUE)
	ADD_MENU_ITEM_TEXT_COMPONENT_LITERAL(GET_STRING_FROM_INT(CMHDZ_GET_TOTAL_NUMBER_OF_ENEMIES_LEFT_ALIVE_FOR_CURRENT_PHASE()))
	SET_MENU_ITEM_TOGGLEABLE(FALSE, FALSE)
	w.iMenuMaxSelection ++	
	
	// add asset type
	ADD_MENU_ITEM_TEXT(w.iMenuMaxSelection, "STRING", 1, TRUE)
	ADD_MENU_ITEM_TEXT_COMPONENT_LITERAL("Ready To Stop")
	ADD_MENU_ITEM_TEXT(w.iMenuMaxSelection, "STRING", 1, TRUE)
	IF (CMHDZ_IS_MOVING_LEVEL_ABOUT_TO_STOP())
		ADD_MENU_ITEM_TEXT_COMPONENT_LITERAL("ON")
	ELSE 
		ADD_MENU_ITEM_TEXT_COMPONENT_LITERAL("OFF")
	ENDIF 
	w.iMenuMaxSelection ++
	
	// add asset type
	ADD_MENU_ITEM_TEXT(w.iMenuMaxSelection, "STRING", 1, TRUE)
	ADD_MENU_ITEM_TEXT_COMPONENT_LITERAL("Has Stopped")
	ADD_MENU_ITEM_TEXT(w.iMenuMaxSelection, "STRING", 1, TRUE)
	IF CMHDZ_IS_LEVEL_STOPPED()
		ADD_MENU_ITEM_TEXT_COMPONENT_LITERAL("ON")
	ELSE 
		ADD_MENU_ITEM_TEXT_COMPONENT_LITERAL("OFF")
	ENDIF 
	w.iMenuMaxSelection ++
	
	ADD_MENU_ITEM_TEXT(w.iMenuMaxSelection, "STRING", 1, TRUE)
	ADD_MENU_ITEM_TEXT_COMPONENT_LITERAL("Shots Fired")
	ADD_MENU_ITEM_TEXT(w.iMenuMaxSelection, "STRING", 1, TRUE)
	ADD_MENU_ITEM_TEXT_COMPONENT_LITERAL(GET_STRING_FROM_INT(CMHDZ_GET_TOTAL_SHOTS_FIRED_IN_CURRENT_LEVEL()))
	SET_MENU_ITEM_TOGGLEABLE(FALSE, FALSE)
	w.iMenuMaxSelection ++	
	
	ADD_MENU_ITEM_TEXT(w.iMenuMaxSelection, "STRING", 1, TRUE)
	ADD_MENU_ITEM_TEXT_COMPONENT_LITERAL("Enemies Hit")
	ADD_MENU_ITEM_TEXT(w.iMenuMaxSelection, "STRING", 1, TRUE)
	ADD_MENU_ITEM_TEXT_COMPONENT_LITERAL(GET_STRING_FROM_INT(CMHDZ_GET_TOTAL_ENEMY_HITS_FOR_CURRENT_LEVEL()))
	SET_MENU_ITEM_TOGGLEABLE(FALSE, FALSE)
	w.iMenuMaxSelection ++	
	
//	IF (iCurrentStage < ciCMHDZ_MAX_SCREENS)
//		//INT iStrLen
//		
//		ADD_MENU_ITEM_TEXT(w.iMenuMaxSelection, "STRING", 1, TRUE)
//		ADD_MENU_ITEM_TEXT_COMPONENT_LITERAL(" ")
//		w.iMenuMaxSelection ++
//		
//		ADD_MENU_ITEM_TEXT(w.iMenuMaxSelection, "STRING", 1, TRUE)
//		ADD_MENU_ITEM_TEXT_COMPONENT_LITERAL("Stage Settings")	
//		w.iMenuMaxSelection ++
//		// add stop scrong
//		ADD_MENU_ITEM_TEXT(w.iMenuMaxSelection, "STRING", 1, TRUE)
//		ADD_MENU_ITEM_TEXT_COMPONENT_LITERAL("Stop Scroll On Stage End")
//		ADD_MENU_ITEM_TEXT(w.iMenuMaxSelection, "STRING", 1, TRUE)
////		IF (sCMHDZData.sStageEndData[iCurrentStage].bStopScrollingOnStageEnd)
////			ADD_MENU_ITEM_TEXT_COMPONENT_LITERAL("ON")
////		ELSE 
////			ADD_MENU_ITEM_TEXT_COMPONENT_LITERAL("OFF")
////		ENDIF 
//		w.iMenuMaxSelection ++	
//		
//		// add stop scrolling
////		ADD_MENU_ITEM_TEXT(w.iMenuMaxSelection, "STRING", 1, TRUE)
////		ADD_MENU_ITEM_TEXT_COMPONENT_LITERAL("Stationary Stage")
////		ADD_MENU_ITEM_TEXT(w.iMenuMaxSelection, "STRING", 1, TRUE)
////		IF (sCMHDZData.sStageEndData[iCurrentStage].bStationary)
////			ADD_MENU_ITEM_TEXT_COMPONENT_LITERAL("ON")
////		ELSE 
////			ADD_MENU_ITEM_TEXT_COMPONENT_LITERAL("OFF")
////		ENDIF 
////		w.iMenuMaxSelection ++	
//		
//		// add asset type
//		ADD_MENU_ITEM_TEXT(w.iMenuMaxSelection, "STRING", 1, TRUE)
//		ADD_MENU_ITEM_TEXT_COMPONENT_LITERAL("End Condition")
//		ADD_MENU_ITEM_TEXT(w.iMenuMaxSelection, "STRING", 1, TRUE)
//		w.iMenuMaxSelection ++
//		
//		// selected index 
//		ADD_MENU_ITEM_TEXT(w.iMenuMaxSelection, "STRING", 1, TRUE)
//		ADD_MENU_ITEM_TEXT_COMPONENT_LITERAL("Condition Value")
//		ADD_MENU_ITEM_TEXT(w.iMenuMaxSelection, "STRING", 1, TRUE)
////		ADD_MENU_ITEM_TEXT_COMPONENT_LITERAL(GET_STRING_FROM_INT(sCMHDZData.sStageEndData[iCurrentStage].iValue))
//		w.iMenuMaxSelection ++			
//		
//		// selected index 
//		ADD_MENU_ITEM_TEXT(w.iMenuMaxSelection, "STRING", 1, TRUE)
//		ADD_MENU_ITEM_TEXT_COMPONENT_LITERAL("Enemy Less Than Stop")
//		ADD_MENU_ITEM_TEXT(w.iMenuMaxSelection, "STRING", 1, TRUE)
////		ADD_MENU_ITEM_TEXT_COMPONENT_LITERAL(GET_STRING_FROM_INT(sCMHDZData.sStageEndData[iCurrentStage].iScrollStopEnemyCount))
//		SET_MENU_ITEM_TOGGLEABLE(FALSE, TRUE)
//		w.iMenuMaxSelection ++
//	ENDIF
	
	IF (bPlayMode = TRUE)
		SET_MAX_MENU_ROWS_TO_DISPLAY(w.iMenuMaxSelection)
		w.bRebuildMenu = FALSE
	ENDIF
ENDPROC

PROC CMHDZ_EDITOR_BUILD_BOSS_MENU(CMHDZ_EDITOR &w)//, BOOL bPlayMode = TRUE)

	TEXT_LABEL_63 strToDisplay
	
//	ADD_MENU_ITEM_TEXT(w.iMenuMaxSelection, "STRING", 1, TRUE)
//	ADD_MENU_ITEM_TEXT_COMPONENT_LITERAL("Phase Index")
//	ADD_MENU_ITEM_TEXT(w.iMenuMaxSelection, "STRING", 1, TRUE)
//	ADD_MENU_ITEM_TEXT_COMPONENT_LITERAL(GET_STRING_FROM_INT(sCMHDZData.sBossData.iPhaseIndex))
//	w.iMenuMaxSelection ++

	ADD_MENU_ITEM_TEXT(w.iMenuMaxSelection, "STRING", 1, TRUE)
	ADD_MENU_ITEM_TEXT_COMPONENT_LITERAL("Start Health")
	ADD_MENU_ITEM_TEXT(w.iMenuMaxSelection, "STRING", 1, TRUE)
	ADD_MENU_ITEM_TEXT_COMPONENT_LITERAL(GET_STRING_FROM_FLOAT(cfBOSS_MaxHealth, 2))
	w.iMenuMaxSelection ++

	ADD_MENU_ITEM_TEXT(w.iMenuMaxSelection, "STRING", 1, TRUE)
	ADD_MENU_ITEM_TEXT_COMPONENT_LITERAL("Current Health")
	ADD_MENU_ITEM_TEXT(w.iMenuMaxSelection, "STRING", 1, TRUE)
	ADD_MENU_ITEM_TEXT_COMPONENT_LITERAL(GET_STRING_FROM_FLOAT(sCMHDZData.sBossData.fHealth, 2))
	w.iMenuMaxSelection ++

//	ADD_MENU_ITEM_TEXT(w.iMenuMaxSelection, "STRING", 1, TRUE)
//	ADD_MENU_ITEM_TEXT_COMPONENT_LITERAL("Boss starting state")
//	ADD_MENU_ITEM_TEXT(w.iMenuMaxSelection, "STRING", 1, TRUE)
//	strToDisplay = CMHDZ_BOSS_STATE_TO_STRING(sCMHDZData.sBossData.eStartingState)
//	ADD_MENU_ITEM_TEXT_COMPONENT_LITERAL(GET_STRING_FROM_STRING(strToDisplay, 17, GET_LENGTH_OF_LITERAL_STRING(strToDisplay)))
//	w.iMenuMaxSelection ++
	
//	ADD_MENU_ITEM_TEXT(w.iMenuMaxSelection, "STRING", 1, TRUE)
//	ADD_MENU_ITEM_TEXT_COMPONENT_LITERAL("Pop Up X Coord")
//	ADD_MENU_ITEM_TEXT(w.iMenuMaxSelection, "STRING", 1, TRUE)
//	ADD_MENU_ITEM_TEXT_COMPONENT_LITERAL(GET_STRING_FROM_FLOAT(sCMHDZData.sBossData.fForegroundXAppear, 2))
//	w.iMenuMaxSelection ++
	
//	ADD_MENU_ITEM_TEXT(w.iMenuMaxSelection, "STRING", 1, TRUE)
//	ADD_MENU_ITEM_TEXT_COMPONENT_LITERAL("Block time")
//	ADD_MENU_ITEM_TEXT(w.iMenuMaxSelection, "STRING", 1, TRUE)
//	ADD_MENU_ITEM_TEXT_COMPONENT_LITERAL(GET_STRING_FROM_FLOAT(sCMHDZData.sBossData.fIdleAttackTime, 2))
//	w.iMenuMaxSelection ++

	ADD_MENU_ITEM_TEXT(w.iMenuMaxSelection, "STRING", 1, TRUE)
	ADD_MENU_ITEM_TEXT_COMPONENT_LITERAL("Background lane")
	ADD_MENU_ITEM_TEXT(w.iMenuMaxSelection, "STRING", 1, TRUE)
	strToDisplay = CMHDZ_LANE_TO_STRING(sCMHDZData.sBossData.iActiveLane)
	ADD_MENU_ITEM_TEXT_COMPONENT_LITERAL(GET_STRING_FROM_STRING(strToDisplay, 13, GET_LENGTH_OF_LITERAL_STRING(strToDisplay)))
	w.iMenuMaxSelection ++

	ADD_MENU_ITEM_TEXT(w.iMenuMaxSelection, "STRING", 1, TRUE)
	ADD_MENU_ITEM_TEXT_COMPONENT_LITERAL("Spawn Helpers")
	ADD_MENU_ITEM_TEXT(w.iMenuMaxSelection, "STRING", 1, TRUE)
	ADD_MENU_ITEM_TEXT_COMPONENT_LITERAL(GET_STRING_FROM_BOOL(IS_BITMASK_ENUM_AS_ENUM_SET(sCMHDZData.sBossData.eDataBits, CMHDZ_BOSS_DATA_BITS_SPAWNED_ENEMIES_1)))
	w.iMenuMaxSelection ++

//	ADD_MENU_ITEM_TEXT(w.iMenuMaxSelection, "STRING", 1, TRUE)
//	ADD_MENU_ITEM_TEXT_COMPONENT_LITERAL("Midground Popup")
//	ADD_MENU_ITEM_TEXT(w.iMenuMaxSelection, "STRING", 1, TRUE)
//	ADD_MENU_ITEM_TEXT_COMPONENT_LITERAL(GET_STRING_FROM_BOOL(IS_BITMASK_ENUM_AS_ENUM_SET(sCMHDZData.sBossData.eDataBits, CMHDZ_BOSS_DATA_BITS_POPUP)))
//	w.iMenuMaxSelection ++
	
ENDPROC

PROC CMHDZ_EDITOR_BUILD_MENU(CMHDZ_EDITOR &w)//, BOOL bPlayMode = TRUE)
	TEXT_LABEL_63 str
	// title bar 
	CLEAR_MENU_DATA()
	SET_MENU_TITLE("STRING")
	SET_MENU_HEADER_COLOUR(0, 0, 128, 255, TRUE)
	
	SWITCH (w.iEditMode)
		CASE CMHDZ_EDITOR_MODE_ITEM
			str = "ITEM EDITOR   USED:"
			str += sCMHDZData.iNumberOfItems
			str += "/"
			str += ciCMHDZ_MAX_ITEMS 
				
			// Prevent overflow
			IF w.iSelectedData >= ciCMHDZ_MAX_ITEMS
				w.iSelectedData = 0
			ENDIF
			
		BREAK
//		CASE CMHDZ_EDITOR_MODE_HOSTAGE
//			str = "HOSTAGE EDITOR   USED:"
//			str += sCMHDZData.iNumberOfHostages
//			str += "/"
//			str += ciCMHDZ_MAX_HOSTAGES
//		BREAK
		CASE CMHDZ_EDITOR_MODE_ENEMY
			str = "ENEMY EDITOR   USED:"
			str += sCMHDZData.iNumberOfEnemies
			str += "/"
			str += ciCMHDZ_MAX_ENEMIES
			
			// Prevent overflow
			IF w.iSelectedData >= ciCMHDZ_MAX_ENEMIES
				w.iSelectedData = 0
			ENDIF
			
		BREAK
		CASE CMHDZ_EDITOR_MODE_COVER
			str = "COVER EDITOR   USED:"
			str += sCMHDZData.iNumberOfProps
			str += "/"
			str += ciCMHDZ_MAX_COVER 
			
			// Prevent overflow
			IF w.iSelectedData >= ciCMHDZ_MAX_COVER
				w.iSelectedData = 0
			ENDIF
			
		BREAK
		CASE CMHDZ_EDITOR_MODE_BOSS
			str = "BOSS EDITOR:"
		BREAK
		DEFAULT
			str = "Camhedz EDITOR"
		BREAK 
	ENDSWITCH 
	
	//IF (w.iEditMode < 4)
		//str += " SCN:"
		//str += (CEIL(sCMHDZData.fOverallLevelProgression/((cfRIGHT_SCREEN_LIMIT + cfLEFT_SCREEN_LIMIT)/2)))
	//ENDIF
	
	w.iMenuMaxSelection = 0
	ADD_LITERAL_TO_MENU_TITLE(str)
	SET_MENU_ITEM_JUSTIFICATION(FONT_LEFT, FONT_RIGHT)
	SET_MENU_ITEM_LAYOUT(MENU_ITEM_TEXT, MENU_ITEM_TEXT)
	SET_CURRENT_MENU_ITEM(w.iMenuCurrentSelection)
	
	// main option
	ADD_MENU_ITEM_TEXT(0, "STRING", 1, TRUE)
	ADD_MENU_ITEM_TEXT_COMPONENT_LITERAL("Mode")
	ADD_MENU_ITEM_TEXT(0, "STRING", 1, TRUE)
	ADD_MENU_ITEM_TEXT_COMPONENT_LITERAL(CMHDZ_EDITOR_MODE_TO_STRING(w.iEditMode))
	SET_MENU_ITEM_TOGGLEABLE(FALSE, TRUE)
	w.iMenuMaxSelection ++
	
	// add asset menu
	SWITCH (w.iEditMode)
		CASE CMHDZ_EDITOR_MODE_ITEM
			CMHDZ_EDITOR_BUILD_ITEM_MENU(w)
		BREAK 
		CASE CMHDZ_EDITOR_MODE_ENEMY
			CMHDZ_EDITOR_BUILD_ENEMY_MENU(w)
		BREAK
		CASE CMHDZ_EDITOR_MODE_COVER
			CMHDZ_EDITOR_BUILD_COVER_MENU(w)
		BREAK 
		CASE CMHDZ_EDITOR_MODE_LEVEL
			CMHDZ_EDITOR_BUILD_LEVEL_MENU(w)
		BREAK
		CASE CMHDZ_EDITOR_MODE_BOSS
			CMHDZ_EDITOR_BUILD_BOSS_MENU(w)//, bPlayMode)
		BREAK
	ENDSWITCH
	SET_MAX_MENU_ROWS_TO_DISPLAY(w.iMenuMaxSelection)
	w.bRebuildMenu = FALSE 
ENDPROC 

PROC CMHDZ_EDITOR_SELECT_RETICULE_OVER_OBJECT_FOR_EDIT(CMHDZ_EDITOR &w)
	INT i
	
	// priorities current mode
	IF (w.iEditMode < 5)
		IF (w.iReticuleOverIndex[w.iEditMode] != -1)
			IF (w.iSelectedData != w.iReticuleOverIndex[w.iEditMode])
				w.iSelectedData = w.iReticuleOverIndex[w.iEditMode]
				w.bRebuildMenu = TRUE
			ENDIF
			EXIT 
		ENDIF 
	ENDIF
	
	// then check item
	REPEAT 5 i
		IF (w.iReticuleOverIndex[i] != -1) AND (w.iEditMode != i)
			w.iEditMode = i
			w.iSelectedData = w.iReticuleOverIndex[i]
			w.bRebuildMenu = TRUE
			EXIT 
		ENDIF
	ENDREPEAT
		
ENDPROC

PROC CMHDZ_EDITOR_UPDATE_GENERAL_OPTIONS(CMHDZ_EDITOR &w)

	// handle up and down and quit
	IF CMHDZ_EDITOR_IS_CONTROL_PRESSED_FOR_OPTION(w, INPUT_SCRIPT_PAD_UP)
	OR CMHDZ_EDITOR_IS_KEY_PRESSED_FOR_OPTION(w, KEY_W)
	OR CMHDZ_EDITOR_IS_KEY_PRESSED_FOR_OPTION(w, KEY_UP)
	OR CMHDZ_EDITOR_IS_CONTROL_PRESSED_FOR_OPTION(w, INPUT_CELLPHONE_UP)
		w.iMenuCurrentSelection --
		IF (w.iMenuCurrentSelection < 0)
			w.iMenuCurrentSelection = w.iMenuMaxSelection - 1
		ENDIF 
		
		w.bRebuildMenu = TRUE
	ENDIF
	
	IF CMHDZ_EDITOR_IS_CONTROL_PRESSED_FOR_OPTION(w, INPUT_SCRIPT_PAD_DOWN)
	OR CMHDZ_EDITOR_IS_KEY_PRESSED_FOR_OPTION(w, KEY_S)
	OR CMHDZ_EDITOR_IS_KEY_PRESSED_FOR_OPTION(w, KEY_DOWN)
	OR CMHDZ_EDITOR_IS_CONTROL_PRESSED_FOR_OPTION(w, INPUT_CELLPHONE_DOWN)
		w.iMenuCurrentSelection ++
		IF (w.iMenuCurrentSelection >= w.iMenuMaxSelection)
			w.iMenuCurrentSelection = 0
		ENDIF 
		
		w.bRebuildMenu = TRUE
	ENDIF
	
//	IF CMHDZ_EDITOR_IS_CONTROL_PRESSED_FOR_OPTION(w, INPUT_FRONTEND_CANCEL)
//	OR CMHDZ_EDITOR_IS_KEY_PRESSED_FOR_OPTION(w, KEY_RSHIFT)
//		IF (w.iEditMode != CMHDZ_EDITOR_MODE_LEVEL)
//			w.iEditMode = CMHDZ_EDITOR_MODE_LEVEL
//			w.bRebuildMenu = TRUE
//		ENDIF 
//	ENDIF 
	
	// handle main option change
	IF (w.iMenuCurrentSelection = 0)
	AND (IS_CONTROL_PRESSED(FRONTEND_CONTROL, INPUT_SCRIPT_RLEFT)
	OR (IS_USING_KEYBOARD_AND_MOUSE(FRONTEND_CONTROL) AND IS_KEYBOARD_KEY_PRESSED(KEY_LCONTROL)))
		IF CMHDZ_EDITOR_CONTROLLER_ADJUST_INT(w, w.iEditMode, 0, CMHDZ_EDITOR_MODE_MAX_TYPES, 1, FALSE)
			CMHDZ_EDITOR_LOAD_OR_RESTART_LEVEL(w, TRUE) // Restart the level when we switch Editor modes.
			
			// Change the stage and progress for the Boss menu.
			IF w.iEditMode = CMHDZ_EDITOR_MODE_BOSS
				w.iActiveLevel = ENUM_TO_INT(CMHDZ_LEVEL_SLAUGHTERHOUSE)
								
				CMHDZ_EDITOR_LOAD_OR_RESTART_LEVEL(w, TRUE)
				sCMHDZData.fOverallLevelProgression = 25306
				
			ENDIF
			sCMHDZData.bDebugInvunerablePlayer = TRUE
			w.bRebuildMenu = TRUE
			w.iSelectedData = -1
		ENDIF 
	ENDIF
	
	// pick based on mode type
	IF CMHDZ_EDITOR_IS_CONTROL_PRESSED_FOR_OPTION(w, w.ctrlPick)
	OR CMHDZ_EDITOR_IS_KEY_PRESSED_FOR_OPTION(w, w.ctrlPick_PC)
		CMHDZ_EDITOR_SELECT_RETICULE_OVER_OBJECT_FOR_EDIT(w)
	ENDIF
ENDPROC 

FUNC BOOL CMHDZ_EDITOR_UPDATE_COVER_OPTIONS(CMHDZ_EDITOR &w)
	INT iType 
	FLOAT fAdjust
	
	SWITCH (w.iMenuCurrentSelection)
		CASE CMHDZ_EDITOR_MODE_COVER_NEW_UNIT			
			IF CMHDZ_EDITOR_CONTROLLER_ADJUST_INT(w, w.iNewUnitData, 0, ENUM_TO_INT(NUM_CMHDZ_ASSET_TYPES), 1, FALSE)
				RETURN TRUE 
			ENDIF 
			
			IF CMHDZ_EDITOR_IS_CONTROL_PRESSED_FOR_OPTION(w, w.ctrlPlace)
			OR CMHDZ_EDITOR_IS_KEY_PRESSED_FOR_OPTION(w, w.ctrlPlace_PC)
				iType = CMHDZ_EDITOR_PLACE_NEW_UNIT(w, w.iNewUnitData)
				RETURN (iType != -1)
			ENDIF 
		BREAK 
		
		CASE CMHDZ_EDITOR_MODE_COVER_INDEX			
			IF CMHDZ_EDITOR_CONTROLLER_ADJUST_INT(w, w.iSelectedData, 0, sCMHDZData.iNumberOfProps, 1, FALSE)
				IF (w.iSelectedData <= -1)
				OR w.iSelectedData > sCMHDZData.iNumberOfProps
					w.iSelectedData = 0
				ENDIF
				
				// Set camera to the point the cover appears
				sCMHDZData.fOverallLevelProgression = w.sCoverMapData[w.iSelectedData].vSpriteInitialPos.x - (cfBASE_SCREEN_WIDTH/2.0)
				sCMHDZData.iCurrentScreen = FLOOR(sCMHDZData.fOverallLevelProgression/cfCMHDZ_SCREEN_LENGTH)
				RETURN TRUE
			ENDIF
		BREAK 
		
		CASE CMHDZ_EDITOR_MODE_COVER_LEVEL
			IF CMHDZ_EDITOR_CONTROLLER_ADJUST_INT(w, w.iActiveLevel, 0, ENUM_TO_INT(CMHDZ_MAX_LEVELS), 1, FALSE)
				CMHDZ_EDITOR_LOAD_OR_RESTART_LEVEL(w, TRUE)
				RETURN TRUE
			ENDIF
		BREAK 
		
		CASE CMHDZ_EDITOR_MODE_COVER_TYPE
			iType = ENUM_TO_INT(w.sCoverMapData[w.iSelectedData].eType)
			IF CMHDZ_EDITOR_CONTROLLER_ADJUST_INT(w, iType, -1, ENUM_TO_INT(NUM_CMHDZ_ASSET_TYPES), 1, FALSE)
				w.sCoverMapData[w.iSelectedData].eType = INT_TO_ENUM(CMHDZ_ASSET_TYPES, iType)	
				RETURN TRUE
			ENDIF
		BREAK
		
		CASE CMHDZ_EDITOR_MODE_COVER_LANE
			IF CMHDZ_EDITOR_CONTROLLER_ADJUST_INT(w, w.sCoverMapData[w.iSelectedData].iCoverLane, 0, ciCMHDZ_MAX_LANES, 1, FALSE)
			//CMHDZ_COPY_COVER_MAP_TO_COVER(sCMHDZData.sCoverMapData[w.iSelectedData], w.iSelectedData)
				RETURN TRUE
			ENDIF	
			
		BREAK
				
		CASE CMHDZ_EDITOR_MODE_COVER_IS_FAR_BG
			IF CMHDZ_EDITOR_CONTROLLER_ADJUST_BITMASK_ENUM_BOOL(w, w.sCoverMapData[w.iSelectedData].eDataBits, CMHDZ_COVER_DATA_BITS_IS_FAR_BG)
				RETURN TRUE
			ENDIF	
		BREAK
		
		CASE CMHDZ_EDITOR_MODE_COVER_REMOVE_OFF_SCREEN
			IF CMHDZ_EDITOR_CONTROLLER_ADJUST_BITMASK_ENUM_BOOL(w, w.sCoverMapData[w.iSelectedData].eDataBits, CMHDZ_COVER_DATA_BITS_REMOVE_OFF_SCREEN)
				RETURN TRUE
			ENDIF	
		BREAK
		
		CASE CMHDZ_EDITOR_MODE_COVER_EXPORT		
			IF CMHDZ_EDITOR_IS_CONTROL_PRESSED_FOR_OPTION(w, w.ctrlPlace)
			OR CMHDZ_EDITOR_IS_KEY_PRESSED_FOR_OPTION(w, w.ctrlPlace_PC)
				CMHDZ_DEBUG_EXPORT_COVER_MAP_DATA_TO_SCRIPT(w.sCoverMapData[w.iSelectedData], w.iSelectedData)
				RETURN TRUE
			ENDIF
		BREAK
		
		CASE CMHDZ_EDITOR_MODE_COVER_EXPORT_ALL		
			IF CMHDZ_EDITOR_IS_CONTROL_PRESSED_FOR_OPTION(w, w.ctrlPlace)
			OR CMHDZ_EDITOR_IS_KEY_PRESSED_FOR_OPTION(w, w.ctrlPlace_PC)
				CMHDZ_DEBUG_EXPORT_COVER_MAP_DATA_ARRAY_TO_SCRIPT(w.sCoverMapData)
				RETURN TRUE
			ENDIF
		BREAK
		
//		CASE CMHDZ_EDITOR_MODE_COVER_SCROLLING
//			IF CMHDZ_EDITOR_CONTROLLER_ADJUST_BITMASK_ENUM_BOOL(w, w.sCoverMapData[w.iSelectedData].eDataBits, CMHDZ_COVER_DATA_BITS_STOP_SCROLLING)
//				IF IS_BITMASK_ENUM_AS_ENUM_SET(w.sCoverMapData[w.iSelectedData].eDataBits, CMHDZ_COVER_DATA_BITS_STOP_SCROLLING) 
//					IF (w.sCoverMapData[w.iSelectedData].fXScreenCoordForStop = 0.0)					
//						w.sCoverMapData[w.iSelectedData].fXScreenCoordForStop = sCMHDZData.sCoverData[w.iSelectedData].vSpritePos.x
//					ENDIF
//					
//					IF (w.sCoverMapData[w.iSelectedData].fXScreenCoordForStop < 700)
//						w.sCoverMapData[w.iSelectedData].fXScreenCoordForStop = 700
//					ENDIF
//					
//				ENDIF 
//				
//				RETURN TRUE
//			ENDIF	
//		BREAK
		
//		CASE CMHDZ_EDITOR_MODE_COVER_STOP_POS
//			IF CMHDZ_EDITOR_CONTROLLER_ADJUST_FLOAT(w, w.sCoverMapData[w.iSelectedData].fXScreenCoordForStop, 0, 2500, 24)
////				IF IS_BITMASK_ENUM_AS_ENUM_SET(w.sCoverMapData[w.iSelectedData].eDataBits, CMHDZ_COVER_DATA_BITS_STOP_SCROLLING)
////					IF (w.sCoverMapData[w.iSelectedData].fXScreenCoordForStop < 700)
////						w.sCoverMapData[w.iSelectedData].fXScreenCoordForStop = 700
////					ENDIF				
////				ENDIF
//				RETURN TRUE
//			ENDIF	
//		BREAK
//		
		CASE CMHDZ_EDITOR_MODE_COVER_INITIAL_X
		
			fAdjust = 240.0

			IF IS_DISABLED_CONTROL_PRESSED(FRONTEND_CONTROL, INPUT_SCRIPT_RLEFT)
#IF IS_DEBUG_BUILD				
			OR IS_KEYBOARD_KEY_PRESSED(KEY_LSHIFT)
#ENDIF
				fAdjust = 24.00
			ENDIF
		
			IF CMHDZ_EDITOR_CONTROLLER_ADJUST_FLOAT(w, w.sCoverMapData[w.iSelectedData].vSpriteInitialPos.x, cfCMHDZ_MIN_EDITOR_X_COORD, cfCMHDZ_MAX_EDITOR_X_COORD, fAdjust)
				sCMHDZData.fOverallLevelProgression = w.sCoverMapData[w.iSelectedData].vSpriteInitialPos.x - (cfBASE_SCREEN_WIDTH/2.0)
				sCMHDZData.iCurrentScreen = FLOOR(sCMHDZData.fOverallLevelProgression/cfCMHDZ_SCREEN_LENGTH)
				RETURN TRUE
			ENDIF	
		BREAK
		
		CASE CMHDZ_EDITOR_MODE_COVER_INITIAL_Y
			IF CMHDZ_EDITOR_CONTROLLER_ADJUST_FLOAT(w, w.sCoverMapData[w.iSelectedData].vSpriteInitialPos.y, cfCMHDZ_MIN_EDITOR_Y_COORD, cfCMHDZ_MAX_EDITOR_Y_COORD, 24)
				w.sCoverMapData[w.iSelectedData].vSpritePos.y = w.sCoverMapData[w.iSelectedData].vSpriteInitialPos.y
				RETURN TRUE
			ENDIF	
		BREAK
	ENDSWITCH 
	
	CMHDZ_COPY_COVER_MAP_DATA_TO_GAME(w.sCoverMapData)
	
	RETURN FALSE 
ENDFUNC

FUNC BOOL CMHDZ_EDITOR_UPDATE_ENEMY_OPTIONS(CMHDZ_EDITOR &w)
	INT iType 	
	FLOAT fAdjust // Can change some interation values with modifiers.
	
	SWITCH (w.iMenuCurrentSelection)
		CASE CMHDZ_EDITOR_MODE_ENEMY_NEW_UNIT			
			IF CMHDZ_EDITOR_CONTROLLER_ADJUST_INT(w, w.iNewUnitData, 0, ENUM_TO_INT(NUM_CMHDZ_ENEMY_TYPES), 1, FALSE)
				RETURN TRUE 
			ENDIF 
			
			IF CMHDZ_EDITOR_IS_CONTROL_PRESSED_FOR_OPTION(w, w.ctrlPlace)
			OR CMHDZ_EDITOR_IS_KEY_PRESSED_FOR_OPTION(w, w.ctrlPlace_PC)
				iType = CMHDZ_EDITOR_PLACE_NEW_UNIT(w, w.iNewUnitData)
				RETURN (iType != -1)
			ENDIF 
		BREAK 
		
		CASE CMHDZ_EDITOR_MODE_ENEMY_INDEX			
			IF CMHDZ_EDITOR_CONTROLLER_ADJUST_INT(w, w.iSelectedData, 0, ciCMHDZ_MAX_ENEMIES, 1, FALSE)
				IF (w.iSelectedData != -1)
					IF (w.sEnemyMapData[w.iSelectedData].eEnemyType = CMHDZ_ENEMY_INVALID)
						w.iSelectedData = 0
					ENDIF 
										
					// Set the screen view to the enemy you are looking at.
					IF w.sEnemyMapData[w.iSelectedData].fPointToAppear > 0.0
						sCMHDZData.fOverallLevelProgression = w.sEnemyMapData[w.iSelectedData].fPointToAppear
						sCMHDZData.iCurrentScreen = FLOOR(sCMHDZData.fOverallLevelProgression/cfCMHDZ_SCREEN_LENGTH)
					ENDIF
					
				ENDIF
								
				RETURN TRUE
			ENDIF
		BREAK 
		
		CASE CMHDZ_EDITOR_MODE_ENEMY_LEVEL
			// Safety precaution
			IF (IS_CONTROL_PRESSED(FRONTEND_CONTROL, INPUT_SCRIPT_RLEFT)
			OR (IS_USING_KEYBOARD_AND_MOUSE(FRONTEND_CONTROL) AND IS_KEYBOARD_KEY_PRESSED(KEY_LCONTROL)))
				IF CMHDZ_EDITOR_CONTROLLER_ADJUST_INT(w, w.iActiveLevel, 0, ENUM_TO_INT(CMHDZ_MAX_LEVELS), 1, FALSE)
					CMHDZ_COPY_ENEMY_MAP_DATA_TO_GAME(w.sEnemyMapData)
					CMHDZ_EDITOR_LOAD_OR_RESTART_LEVEL(w, TRUE)
					RETURN TRUE
				ENDIF
			ENDIF
		BREAK 
		
		CASE CMHDZ_EDITOR_MODE_ENEMY_TYPE
			iType = ENUM_TO_INT(w.sEnemyMapData[w.iSelectedData].eEnemyType)
			IF CMHDZ_EDITOR_CONTROLLER_ADJUST_INT(w, iType, 0, ENUM_TO_INT(NUM_CMHDZ_ENEMY_TYPES), 1, FALSE)
				w.sEnemyMapData[w.iSelectedData].eEnemyType = INT_TO_ENUM(CMHDZ_ENEMY_TYPES, iType)
				CMHDZ_COPY_ENEMY_MAP_TO_ENEMY(w.sEnemyMapData[w.iSelectedData], w.iSelectedData)
				RETURN TRUE
			ENDIF	
		BREAK
		
		CASE CMHDZ_EDITOR_MODE_ENEMY_LANE
			IF CMHDZ_EDITOR_CONTROLLER_ADJUST_INT(w, w.sEnemyMapData[w.iSelectedData].iLane, 0, ciCMHDZ_MAX_LANES, 1, FALSE)
				CMHDZ_COPY_ENEMY_MAP_TO_ENEMY(w.sEnemyMapData[w.iSelectedData], w.iSelectedData)
				RETURN TRUE
			ENDIF	
		BREAK
		
		CASE CMHDZ_EDITOR_MODE_ENEMY_POSITION
				
			fAdjust = 240.0

			IF IS_DISABLED_CONTROL_PRESSED(FRONTEND_CONTROL, INPUT_SCRIPT_RLEFT)
#IF IS_DEBUG_BUILD				
			OR IS_KEYBOARD_KEY_PRESSED(KEY_LSHIFT)
#ENDIF
				fAdjust = 24.00
			ENDIF
			
			IF CMHDZ_EDITOR_CONTROLLER_ADJUST_FLOAT(w, w.sEnemyMapData[w.iSelectedData].fPointToAppear,  0.0, CMHDZ_GET_FINAL_SCREEN_IN_CURRENT_LEVEL() * cfCMHDZ_SCREEN_LENGTH, fAdjust)
				//CMHDZ_COPY_ENEMY_MAP_TO_ENEMY(w.sEnemyMapData[w.iSelectedData], w.iSelectedData)
				
				// Update the camera position
				sCMHDZData.fOverallLevelProgression = w.sEnemyMapData[w.iSelectedData].fPointToAppear
				sCMHDZData.iCurrentScreen = FLOOR(sCMHDZData.fOverallLevelProgression/cfCMHDZ_SCREEN_LENGTH)
				
				RETURN TRUE
			ENDIF	
		BREAK
		
//		CASE CMHDZ_EDITOR_MODE_ENEMY_RENDERWARP
//			IF CMHDZ_EDITOR_CONTROLLER_ADJUST_INT(w, w.sEnemyMapData[w.iSelectedData].iRenderAfterWarpCount, 0, 10)
//				CMHDZ_COPY_ENEMY_MAP_TO_ENEMY(w.sEnemyMapData[w.iSelectedData], w.iSelectedData)
//				RETURN TRUE
//			ENDIF	
//		BREAK		

		CASE CMHDZ_EDITOR_MODE_ENEMY_REVERSE
			IF CMHDZ_EDITOR_CONTROLLER_ADJUST_BITMASK_ENUM_BOOL(w, w.sEnemyMapData[w.iSelectedData].eDataBits, CMHDZ_ENEMY_DATA_BITS_REVERSE)
				CMHDZ_COPY_ENEMY_MAP_TO_ENEMY(w.sEnemyMapData[w.iSelectedData], w.iSelectedData)
				RETURN TRUE
			ENDIF	
		BREAK
		
		CASE CMHDZ_EDITOR_MODE_ENEMY_WAITSCROLL
			IF CMHDZ_EDITOR_CONTROLLER_ADJUST_BITMASK_ENUM_BOOL(w, w.sEnemyMapData[w.iSelectedData].eDataBits, CMHDZ_ENEMY_DATA_BITS_WAIT_UNTIL_LEVEL_STATIONARY)
				CMHDZ_COPY_ENEMY_MAP_TO_ENEMY(w.sEnemyMapData[w.iSelectedData], w.iSelectedData)
				RETURN TRUE
			ENDIF	
		BREAK
		
		CASE CMHDZ_EDITOR_MODE_ENEMY_IS_POP_UP
			IF CMHDZ_EDITOR_CONTROLLER_ADJUST_BITMASK_ENUM_BOOL(w, w.sEnemyMapData[w.iSelectedData].eDataBits, CMHDZ_ENEMY_DATA_BITS_IS_POPUP)
				CMHDZ_COPY_ENEMY_MAP_TO_ENEMY(w.sEnemyMapData[w.iSelectedData], w.iSelectedData)
				RETURN TRUE
			ENDIF	
		BREAK
		
		CASE CMHDZ_EDITOR_MODE_ENEMY_STOP_POS
			IF CMHDZ_EDITOR_CONTROLLER_ADJUST_FLOAT(w, w.sEnemyMapData[w.iSelectedData].fStoppingPos, cfCMHDZ_MIN_EDITOR_X_COORD, cfCMHDZ_MAX_EDITOR_X_COORD, 24)
				CMHDZ_COPY_ENEMY_MAP_TO_ENEMY(w.sEnemyMapData[w.iSelectedData], w.iSelectedData)
				RETURN TRUE
			ENDIF	
		BREAK
			
		CASE CMHDZ_EDITOR_MODE_ENEMY_INITIAL_X
			IF CMHDZ_EDITOR_CONTROLLER_ADJUST_FLOAT(w, w.sEnemyMapData[w.iSelectedData].vSpritePos.x, cfCMHDZ_MIN_EDITOR_X_COORD, cfCMHDZ_MAX_EDITOR_X_COORD, 24)
				////sCMHDZData.fOverallLevelProgression = w.sEnemyMapData[w.iSelectedData].vSpritePos.x
				RETURN TRUE
			ENDIF	
		BREAK
		
		CASE CMHDZ_EDITOR_MODE_ENEMY_INITIAL_Y
			IF CMHDZ_EDITOR_CONTROLLER_ADJUST_FLOAT(w, w.sEnemyMapData[w.iSelectedData].vSpritePos.y, cfCMHDZ_MIN_EDITOR_Y_COORD, cfCMHDZ_MAX_EDITOR_Y_COORD, 24)
				RETURN TRUE
			ENDIF	
		BREAK
		
		CASE CMHDZ_EDITOR_MODE_ENEMY_EXPORT
			IF CMHDZ_EDITOR_IS_CONTROL_PRESSED_FOR_OPTION(w, w.ctrlPlace)
			OR CMHDZ_EDITOR_IS_KEY_PRESSED_FOR_OPTION(w, w.ctrlPlace_PC)
				CMHDZ_DEBUG_EXPORT_ENEMY_MAP_DATA_TO_SCRIPT(w.sEnemyMapData[w.iSelectedData], w.iSelectedData)
				RETURN TRUE
			ENDIF
		BREAK
		
		CASE CMHDZ_EDITOR_MODE_ENEMY_EXPORT_ALL
			IF CMHDZ_EDITOR_IS_CONTROL_PRESSED_FOR_OPTION(w, w.ctrlPlace)
			OR CMHDZ_EDITOR_IS_KEY_PRESSED_FOR_OPTION(w, w.ctrlPlace_PC)
				CMHDZ_DEBUG_EXPORT_ENEMY_MAP_DATA_ARRAY_TO_SCRIPT(w.sEnemyMapData)
				CMHDZ_COPY_ENEMY_MAP_DATA_TO_GAME(w.sEnemyMapData)
				RETURN TRUE
			ENDIF
		BREAK
	ENDSWITCH 
	
	//CMHDZ_COPY_ENEMY_MAP_DATA_TO_GAME(w.sEnemyMapData)
		
	RETURN FALSE 
ENDFUNC

FUNC BOOL CMHDZ_EDITOR_UPDATE_ITEM_OPTIONS(CMHDZ_EDITOR &w)
	INT iType 
	FLOAT fAdjust
	
	SWITCH (w.iMenuCurrentSelection)
		CASE CMHDZ_EDITOR_MODE_ITEM_NEW_UNIT			
			IF CMHDZ_EDITOR_CONTROLLER_ADJUST_INT(w, w.iNewUnitData, 0, ENUM_TO_INT(NUM_CMHDZ_ITEM_TYPES), 1, FALSE)
				RETURN TRUE 
			ENDIF 
			
			IF CMHDZ_EDITOR_IS_CONTROL_PRESSED_FOR_OPTION(w, w.ctrlPlace)
			OR CMHDZ_EDITOR_IS_KEY_PRESSED_FOR_OPTION(w, w.ctrlPlace_PC)
				iType = CMHDZ_EDITOR_PLACE_NEW_UNIT(w, w.iNewUnitData)
				RETURN (iType != -1)
			ENDIF 
		BREAK 
		
		CASE CMHDZ_EDITOR_MODE_ITEM_INDEX			
			IF CMHDZ_EDITOR_CONTROLLER_ADJUST_INT(w, w.iSelectedData, 0, ciCMHDZ_MAX_ITEMS, 1, FALSE)
				IF (w.iSelectedData != -1)
				OR w.iSelectedData >= sCMHDZData.iNumberOfItems
					IF (w.sItemMapData[w.iSelectedData].eItemType = CMHDZ_ITEM_NONE)
						w.iSelectedData = 0
					ENDIF 					
					
					sCMHDZData.fOverallLevelProgression = w.sItemMapData[w.iSelectedData].vSpritePos.x - (cfBASE_SCREEN_WIDTH/2.0)
					//sCMHDZData.fOverallLevelProgression = (w.sItemMapData[w.iSelectedData].vSpritePos.x - (w.sItemMapData[w.iSelectedData].vSpritePos.x%1920))
					sCMHDZData.iCurrentScreen = FLOOR(sCMHDZData.fOverallLevelProgression/cfCMHDZ_SCREEN_LENGTH)
				ENDIF
				
				RETURN TRUE
			ENDIF
		BREAK 
		
		CASE CMHDZ_EDITOR_MODE_ITEM_LEVEL
			IF CMHDZ_EDITOR_CONTROLLER_ADJUST_INT(w, w.iActiveLevel, 0, ENUM_TO_INT(CMHDZ_MAX_LEVELS), 1, FALSE)
				CMHDZ_EDITOR_LOAD_OR_RESTART_LEVEL(w, TRUE)
				RETURN TRUE
			ENDIF
		BREAK 
	
		CASE CMHDZ_EDITOR_MODE_ITEM_TYPE
			iType = ENUM_TO_INT(w.sItemMapData[w.iSelectedData].eItemType)
			IF CMHDZ_EDITOR_CONTROLLER_ADJUST_INT(w, iType, 0, ENUM_TO_INT(NUM_CMHDZ_ITEM_TYPES), 1, FALSE)
				w.sItemMapData[w.iSelectedData].eItemType = INT_TO_ENUM(CMHDZ_ITEM_TYPES, iType)
				CMHDZ_COPY_ITEM_MAP_TO_ITEM(w.sItemMapData[w.iSelectedData], w.iSelectedData)
				RETURN TRUE
			ENDIF	
		BREAK
		
		CASE CMHDZ_EDITOR_MODE_ITEM_LANE
			IF CMHDZ_EDITOR_CONTROLLER_ADJUST_INT(w, w.sItemMapData[w.iSelectedData].iLane, 0, ciCMHDZ_MAX_LANES, 1, FALSE)
				CMHDZ_COPY_ITEM_MAP_TO_ITEM(w.sItemMapData[w.iSelectedData], w.iSelectedData)
				RETURN TRUE
			ENDIF	
		BREAK
		
		CASE CMHDZ_EDITOR_MODE_ITEM_SCREEN
			IF CMHDZ_EDITOR_CONTROLLER_ADJUST_INT(w, w.sItemMapData[w.iSelectedData].iMinScreen,  1, ciCMHDZ_MAX_SCREENS)
				RETURN TRUE
			ENDIF	
		BREAK
		
		CASE CMHDZ_EDITOR_MODE_ITEM_RENDERWARP
			IF CMHDZ_EDITOR_CONTROLLER_ADJUST_INT(w, w.sItemMapData[w.iSelectedData].iRenderAfterWarpCount, 0, 10)
				CMHDZ_COPY_ITEM_MAP_TO_ITEM(w.sItemMapData[w.iSelectedData], w.iSelectedData)
				RETURN TRUE
			ENDIF	
		BREAK		
		
		CASE CMHDZ_EDITOR_MODE_ITEM_FORCESCALE
			IF CMHDZ_EDITOR_CONTROLLER_ADJUST_FLOAT(w, w.sItemMapData[w.iSelectedData].fForceScale, 0, 2.0, 0.25)
				RETURN TRUE
			ENDIF	
		BREAK
		
		CASE CMHDZ_EDITOR_MODE_ITEM_INITIAL_X
		
			fAdjust = 240.0

			IF IS_DISABLED_CONTROL_PRESSED(FRONTEND_CONTROL, INPUT_SCRIPT_RLEFT)
#IF IS_DEBUG_BUILD				
			OR IS_KEYBOARD_KEY_PRESSED(KEY_LSHIFT)
#ENDIF
				fAdjust = 24.00
			ENDIF
		
			IF CMHDZ_EDITOR_CONTROLLER_ADJUST_FLOAT(w, w.sItemMapData[w.iSelectedData].vSpritePos.x, 0, CMHDZ_GET_FINAL_SCREEN_IN_CURRENT_LEVEL() * 1920.0, fAdjust)
				// Adjust again if we're manipulating X position.
				sCMHDZData.fOverallLevelProgression = w.sItemMapData[w.iSelectedData].vSpritePos.x - (cfBASE_SCREEN_WIDTH/2.0)
				sCMHDZData.iCurrentScreen = FLOOR(sCMHDZData.fOverallLevelProgression/cfCMHDZ_SCREEN_LENGTH)
				RETURN TRUE
			ENDIF	
		BREAK
		
		CASE CMHDZ_EDITOR_MODE_ITEM_INITIAL_Y
			IF CMHDZ_EDITOR_CONTROLLER_ADJUST_FLOAT(w, w.sItemMapData[w.iSelectedData].vSpritePos.y, 0, cfBASE_SCREEN_HEIGHT, 24)
				RETURN TRUE
			ENDIF	
		BREAK
		
		CASE CMHDZ_EDITOR_MODE_ITEM_EXPORT
			IF CMHDZ_EDITOR_IS_CONTROL_PRESSED_FOR_OPTION(w, w.ctrlPlace)
			OR CMHDZ_EDITOR_IS_KEY_PRESSED_FOR_OPTION(w, w.ctrlPlace_PC)
				CMHDZ_DEBUG_EXPORT_ITEM_MAP_DATA_TO_SCRIPT(w.sItemMapData[w.iSelectedData], w.iSelectedData)
				RETURN TRUE
			ENDIF
		BREAK

		CASE CMHDZ_EDITOR_MODE_ITEM_EXPORT_ALL
			IF CMHDZ_EDITOR_IS_CONTROL_PRESSED_FOR_OPTION(w, w.ctrlPlace)
			OR CMHDZ_EDITOR_IS_KEY_PRESSED_FOR_OPTION(w, w.ctrlPlace_PC)
				CMHDZ_DEBUG_EXPORT_ITEM_MAP_DATA_ARRAY_TO_SCRIPT(w.sItemMapData)
				RETURN TRUE
			ENDIF
		BREAK
		
	ENDSWITCH 
	
	//CMHDZ_COPY_ITEM_MAP_DATA_TO_GAME(w.sItemMapData)
	
	RETURN FALSE 
ENDFUNC

//FUNC BOOL CMHDZ_EDITOR_UPDATE_HOSTAGE_OPTIONS(CMHDZ_EDITOR &w)
//	INT iType 
//	
//	SWITCH (w.iMenuCurrentSelection)
//		CASE CMHDZ_EDITOR_MODE_HOSTAGE_NEW_UNIT			
//			IF CMHDZ_EDITOR_CONTROLLER_ADJUST_INT(w, w.iNewUnitData, 0, ENUM_TO_INT(NUM_CMHDZ_HOSTAGE_TYPES), 1, FALSE)
//				RETURN TRUE 
//			ENDIF 
//			
//			IF CMHDZ_EDITOR_IS_CONTROL_PRESSED_FOR_OPTION(w, w.ctrlPlace)
//			OR CMHDZ_EDITOR_IS_KEY_PRESSED_FOR_OPTION(w, w.ctrlPlace_PC)
//				iType = CMHDZ_EDITOR_PLACE_NEW_UNIT(w, w.iNewUnitData)
//				RETURN (iType != -1)
//			ENDIF 
//		BREAK 
//		
//		CASE CMHDZ_EDITOR_MODE_HOSTAGE_INDEX			
//			IF CMHDZ_EDITOR_CONTROLLER_ADJUST_INT(w, w.iSelectedData, 0, ciCMHDZ_MAX_HOSTAGES, 1, FALSE)
//				IF (w.iSelectedData != -1)
//					IF (w.sHostageMapData[w.iSelectedData].eHostageType = CMHDZ_HOSTAGE_INVALID)
//						w.iSelectedData = 0
//					ENDIF 
//				ENDIF
//				
//				RETURN TRUE
//			ENDIF
//		BREAK 
//		
//		CASE CMHDZ_EDITOR_MODE_HOSTAGE_TYPE
//			iType = ENUM_TO_INT(w.sHostageMapData[w.iSelectedData].eHostageType)
//			IF CMHDZ_EDITOR_CONTROLLER_ADJUST_INT(w, iType, -1, ENUM_TO_INT(NUM_CMHDZ_HOSTAGE_TYPES), 1, FALSE)
//				w.sHostageMapData[w.iSelectedData].eHostageType = INT_TO_ENUM(CMHDZ_HOSTAGE_TYPES, iType)
//				CMHDZ_COPY_HOSTAGE_MAP_TO_HOSTAGE(w.sHostageMapData[w.iSelectedData], w.iSelectedData)
//				RETURN TRUE
//			ENDIF	
//		BREAK
//		
//		CASE CMHDZ_EDITOR_MODE_HOSTAGE_LANE
//			IF CMHDZ_EDITOR_CONTROLLER_ADJUST_INT(w, w.sHostageMapData[w.iSelectedData].iHostageLane, 0, ciCMHDZ_MAX_LANES, 1, FALSE)
//				CMHDZ_COPY_HOSTAGE_MAP_TO_HOSTAGE(w.sHostageMapData[w.iSelectedData], w.iSelectedData)
//				RETURN TRUE
//			ENDIF	
//		BREAK	
//
//		CASE CMHDZ_EDITOR_MODE_HOSTAGE_REVERSE
//			IF CMHDZ_EDITOR_CONTROLLER_ADJUST_BITSET_BOOL(w, w.sHostageMapData[w.iSelectedData].iBitset, ENUM_TO_INT(CMHDZ_HOSTAGE_BIT_GOING_BACK))
//				CMHDZ_COPY_HOSTAGE_MAP_TO_HOSTAGE(w.sHostageMapData[w.iSelectedData], w.iSelectedData)
//				RETURN TRUE
//			ENDIF	
//		BREAK
//		
//		CASE CMHDZ_EDITOR_MODE_HOSTAGE_STOP_POS
//			IF CMHDZ_EDITOR_CONTROLLER_ADJUST_FLOAT(w, w.sHostageMapData[w.iSelectedData].fStoppingX, 0, 2500, 50)
//				CMHDZ_COPY_HOSTAGE_MAP_TO_HOSTAGE(w.sHostageMapData[w.iSelectedData], w.iSelectedData)
//				RETURN TRUE
//			ENDIF	
//		BREAK
//		
//		CASE CMHDZ_EDITOR_MODE_HOSTAGE_INITIAL_X
//			IF CMHDZ_EDITOR_CONTROLLER_ADJUST_FLOAT(w, w.sHostageMapData[w.iSelectedData].vSpritePos.x, -4000, 4000, 50)
//				RETURN TRUE
//			ENDIF	
//		BREAK
//		
//		CASE CMHDZ_EDITOR_MODE_HOSTAGE_INITIAL_Y
//			IF CMHDZ_EDITOR_CONTROLLER_ADJUST_FLOAT(w, w.sHostageMapData[w.iSelectedData].vSpritePos.y, 0, cfBASE_SCREEN_HEIGHT, 50)
//				RETURN TRUE
//			ENDIF	
//		BREAK
//	ENDSWITCH 
//	
//	RETURN FALSE 
//ENDFUNC


FUNC BOOL CMHDZ_EDITOR_UPDATE_LEVEL_OPTIONS(CMHDZ_EDITOR &w)
	FLOAT fAdjust // Can change some interation values with modifiers.
	
	SWITCH (w.iMenuCurrentSelection)
		CASE CMHDZ_EDITOR_MODE_LEVEL_INDEX			
			IF CMHDZ_EDITOR_CONTROLLER_ADJUST_INT(w, w.iActiveLevel, 0, ENUM_TO_INT(CMHDZ_MAX_LEVELS), 1, FALSE)
				CMHDZ_EDITOR_LOAD_OR_RESTART_LEVEL(w, TRUE)
				RETURN TRUE
			ENDIF
		BREAK 
		
		CASE CMHDZ_EDITOR_MODE_LEVEL_PROGRESS_SET
			fAdjust = 240.0

			IF (IS_DISABLED_CONTROL_PRESSED(FRONTEND_CONTROL, INPUT_SCRIPT_RLEFT))
				fAdjust = 24.00
			ENDIF

			IF CMHDZ_EDITOR_CONTROLLER_ADJUST_FLOAT(w, sCMHDZData.fOverallLevelProgression,  0.0, CMHDZ_GET_FINAL_SCREEN_IN_CURRENT_LEVEL()*cfRIGHT_SCREEN_LIMIT, fAdjust)
				sCMHDZData.iCurrentScreen = FLOOR(sCMHDZData.fOverallLevelProgression/cfCMHDZ_SCREEN_LENGTH)
				RETURN TRUE
			ENDIF	
		BREAK
		
		CASE CMHDZ_EDITOR_MODE_LEVEL_SCREEN
//			IF CMHDZ_EDITOR_CONTROLLER_ADJUST_INT(w, (CEIL(sCMHDZData.fOverallLevelProgression/((cfRIGHT_SCREEN_LIMIT + cfLEFT_SCREEN_LIMIT)/2))), 1, CMHDZ_GET_FINAL_SCREEN_IN_CURRENT_LEVEL())
//				CMHDZ_EDITOR_GET_ACTIVE_SCREEN_DATA(w, (CEIL(sCMHDZData.fOverallLevelProgression/((cfRIGHT_SCREEN_LIMIT + cfLEFT_SCREEN_LIMIT)/2))))
//				RETURN TRUE
//			ENDIF	
		BREAK
		
//		CASE CMHDZ_EDITOR_MODE_LEVEL_STOP_PROP
//			IF (ENUM_TO_INT(sCMHDZData.eCurrentLevel) = w.iActiveLevel)	
//				IF CMHDZ_EDITOR_IS_CONTROL_PRESSED_FOR_OPTION(w, w.ctrlPick)
//				OR CMHDZ_EDITOR_IS_KEY_PRESSED_FOR_OPTION(w, w.ctrlPick_PC)
//					IF (sCMHDZData.iPropToStopOn[(CEIL(sCMHDZData.fOverallLevelProgression/((cfRIGHT_SCREEN_LIMIT + cfLEFT_SCREEN_LIMIT)/2)))] != -1)
//						//CMHDZ_EDITOR_GET_ACTIVE_SCREEN_DATA(w, w.sCoverMapData[sCMHDZData.iPropToStopOn[(CEIL(sCMHDZData.fOverallLevelProgression/((cfRIGHT_SCREEN_LIMIT + cfLEFT_SCREEN_LIMIT)/2)))]].iScreen)	
//						RETURN TRUE
//					ENDIF
//				ENDIF	
//			ENDIF
//		BREAK
		
		CASE CMHDZ_EDITOR_MODE_LEVEL_PLAY 
			IF CMHDZ_EDITOR_IS_CONTROL_PRESSED_FOR_OPTION(w, w.ctrlPick)
			OR CMHDZ_EDITOR_IS_KEY_PRESSED_FOR_OPTION(w, w.ctrlPick_PC)				
				CMHDZ_EDITOR_PLAY_LEVEL(w)
				RETURN TRUE
			ENDIF	
		BREAK		

		CASE CMHDZ_EDITOR_MODE_LEVEL_RESET
			IF (ENUM_TO_INT(sCMHDZData.eCurrentLevel) = w.iActiveLevel)
				IF CMHDZ_EDITOR_IS_CONTROL_PRESSED_FOR_OPTION(w, w.ctrlPick)
				OR CMHDZ_EDITOR_IS_KEY_PRESSED_FOR_OPTION(w, w.ctrlPick_PC)	
					CMHDZ_EDITOR_LOAD_OR_RESTART_LEVEL(w, FALSE)
					RETURN TRUE
				ENDIF
			ENDIF	
		BREAK
		
		CASE CMHDZ_EDITOR_MODE_EXPORT_LEVEL
			IF CMHDZ_EDITOR_IS_CONTROL_PRESSED_FOR_OPTION(w, w.ctrlPick)
			OR CMHDZ_EDITOR_IS_KEY_PRESSED_FOR_OPTION(w, w.ctrlPick_PC)	
				CMHDZ_EDITOR_LOAD_OR_RESTART_LEVEL(w, TRUE)
				RETURN TRUE
			ENDIF	
		BREAK
		
	ENDSWITCH 
	
	RETURN FALSE 
ENDFUNC

PROC CMHDZ_EDITOR_RUN_MENU(CMHDZ_EDITOR &w)
	IF (w.bPlayStage)
		EXIT 
	ENDIF 
	
	IF CMHDZ_EDITOR_IS_CONTROL_PRESSED_FOR_OPTION(w, w.ctrlToggleMap)
	OR CMHDZ_EDITOR_IS_KEY_PRESSED_FOR_OPTION(w, w.ctrlToggleMap_PC)
		w.bShowMiniMap = !w.bShowMiniMap
	ENDIF
	
	IF CMHDZ_EDITOR_IS_CONTROL_PRESSED_FOR_OPTION(w, w.ctrlToggleMap)
	OR CMHDZ_EDITOR_IS_KEY_PRESSED_FOR_OPTION(w, w.ctrlToggleMap_PC)
		IF (!w.bMenuActive)
			w.bRebuildMenu = TRUE
		ENDIF
		w.bMenuActive = !w.bMenuActive
	ENDIF
	
	IF (!w.bMenuActive) OR IS_PAUSE_MENU_ACTIVE_EX()
		EXIT
	ENDIF 
	
	IF NOT LOAD_MENU_ASSETS()
		EXIT 
	ENDIF 
	
	IF (w.bRebuildMenu)
		CMHDZ_EDITOR_BUILD_MENU(w)
	ELSE 
		SET_CURRENT_MENU_ITEM(w.iMenuCurrentSelection)
	ENDIF
	
	CMHDZ_EDITOR_UPDATE_GENERAL_OPTIONS(w)
	
	SWITCH (w.iEditMode)
		
		CASE CMHDZ_EDITOR_MODE_ITEM
			IF CMHDZ_EDITOR_UPDATE_ITEM_OPTIONS(w)
				IF (w.iSelectedData != -1)
					CMHDZ_COPY_ITEM_MAP_TO_ITEM(w.sItemMapData[w.iSelectedData], w.iSelectedData)
				ENDIF
				w.bRebuildMenu = TRUE
			ENDIF 
		BREAK 
			
		CASE CMHDZ_EDITOR_MODE_ENEMY
			IF CMHDZ_EDITOR_UPDATE_ENEMY_OPTIONS(w)
				IF (w.iSelectedData != -1)
					CMHDZ_COPY_ENEMY_MAP_TO_ENEMY(w.sEnemyMapData[w.iSelectedData], w.iSelectedData)
				ENDIF
				w.bRebuildMenu = TRUE
			ENDIF 
		BREAK 
		
		CASE CMHDZ_EDITOR_MODE_COVER
			IF CMHDZ_EDITOR_UPDATE_COVER_OPTIONS(w)
				IF (w.iSelectedData != -1)
					//CMHDZ_COPY_COVER_MAP_TO_COVER(w.sCoverMapData[w.iSelectedData], w.iSelectedData)
				ENDIF
				w.bRebuildMenu = TRUE
			ENDIF 
		BREAK 
		
		CASE CMHDZ_EDITOR_MODE_LEVEL
			IF CMHDZ_EDITOR_UPDATE_LEVEL_OPTIONS(w)
				w.bRebuildMenu = TRUE
			ENDIF 
		BREAK 
		
	ENDSWITCH
	
	DRAW_MENU()
ENDPROC 

PROC CMHDZ_EDITOR_RUN_PLAY_MENU(CMHDZ_EDITOR &w)
	IF ((!w.bPlayStage) AND (sCMHDZData.eClientState != CMHDZ_ARCADE_CLIENT_STATE_PLAYING))
		EXIT 
	ENDIF 
	
	IF CMHDZ_EDITOR_IS_CONTROL_PRESSED_FOR_OPTION(w, w.ctrlToggleMenu)
		IF (!w.bMenuActive)
			w.bRebuildMenu = TRUE
		ENDIF
		w.bMenuActive = !w.bMenuActive
	ENDIF
	
	IF CMHDZ_EDITOR_IS_KEY_PRESSED_FOR_OPTION(w, w.ctrlToggleMenu_PC)
		IF (!w.bMenuActive)
			w.bRebuildMenu = TRUE
		ENDIF
		w.bMenuActive = !w.bMenuActive
	ENDIF
	
	IF (!w.bMenuActive) OR IS_PAUSE_MENU_ACTIVE_EX()
		EXIT
	ENDIF 
	
	IF NOT LOAD_MENU_ASSETS()
		EXIT 
	ENDIF 
	
	IF (GET_GAME_TIMER() > w.iPlayMenuUpdateClock)
		w.bRebuildMenu = TRUE 
		w.iPlayMenuUpdateClock = (GET_GAME_TIMER() + 500)
	ENDIF
	
	IF (w.bRebuildMenu)
		CMHDZ_EDITOR_BUILD_PLAY_MENU(w)
	ELSE 
		SET_CURRENT_MENU_ITEM(w.iMenuCurrentSelection)
	ENDIF
	
	DRAW_MENU()
ENDPROC 

FUNC INT CMHDZ_EDITOR_CHECK_RETICULE_OVER_INDEX(INT iMode)
	SWITCH (iMode)
		CASE CMHDZ_EDITOR_MODE_ENEMY
			RETURN CMHDZ_GET_ENEMY_OVER_RETICULE()
		BREAK 
		CASE CMHDZ_EDITOR_MODE_COVER
			RETURN CMHDZ_GET_COVER_OVER_RETICULE()
		BREAK 		
//		CASE CMHDZ_EDITOR_MODE_HOSTAGE
//			RETURN CMHDZ_GET_HOSTAGE_OVER_RETICULE()
//		BREAK 	
		CASE CMHDZ_EDITOR_MODE_ITEM
			RETURN CMHDZ_GET_ITEM_OVER_RETICULE()
		BREAK 	 
	ENDSWITCH	

	RETURN -1
ENDFUNC 

PROC CMHDZ_EDITOR_UPDATE_RETICULE_DRAG(CMHDZ_EDITOR &w)
	IF (w.bPlayStage)
		EXIT 
	ENDIF 
	
	IF (w.iSelectedData = -1)
		EXIT 
	ENDIF
	
	IF NOT CMHDZ_EDITOR_IS_CONTROL_PRESSED_FOR_OPTION(w, w.ctrlPick)
	AND NOT CMHDZ_EDITOR_IS_KEY_PRESSED_FOR_OPTION(w, w.ctrlPick_PC)
		EXIT
	ENDIF


	IF IS_VECTOR_2D_ZERO(w.vReticuleDelta)
	 	EXIT 
	ENDIF
	
	SWITCH (w.iEditMode)
		CASE CMHDZ_EDITOR_MODE_COVER
			w.sCoverMapData[w.iSelectedData].vSpriteInitialPos.x += w.vReticuleDelta.x
			w.sCoverMapData[w.iSelectedData].vSpriteInitialPos.y += w.vReticuleDelta.y
			
			//w.sCoverMapData[w.iSelectedData].iScreen = CMHDZ_GET_SCREEN_FOR_X_POSITION(w.sCoverMapData[w.iSelectedData].vSpriteInitialPos.x)
			CMHDZ_COPY_COVER_MAP_TO_COVER(w.sCoverMapData[w.iSelectedData], w.iSelectedData)

//			sCMHDZData.sCoverData[w.iSelectedData].vSpritePos.x += w.vReticuleDelta.x
//			sCMHDZData.sCoverData[w.iSelectedData].vSpritePos.y += w.vReticuleDelta.y
			w.bRebuildMenu = TRUE
		BREAK 
		
		CASE CMHDZ_EDITOR_MODE_ITEM
			w.sItemMapData[w.iSelectedData].vSpritePos.x += w.vReticuleDelta.x
			w.sItemMapData[w.iSelectedData].vSpritePos.y += w.vReticuleDelta.y
			CMHDZ_COPY_ITEM_MAP_TO_ITEM(w.sItemMapData[w.iSelectedData], w.iSelectedData)
			
//			sCMHDZData.sItemData[w.iSelectedData].vSpritePos.x += w.vReticuleDelta.x
//			sCMHDZData.sItemData[w.iSelectedData].vSpritePos.y += w.vReticuleDelta.y
			w.bRebuildMenu = TRUE
		BREAK 
	ENDSWITCH
ENDPROC

PROC CMHDZ_EDITOR_UPDATE_RETICULE(CMHDZ_EDITOR &w)
	INT i
	BOOL bTypeLocked
	
	// reticule
	w.vReticulePos = CMHDZ_GET_PLAYER_RETICULE_POSITON()
	w.vReticuleDelta = SUBTRACT_VECTOR_2D(w.vReticulePos, w.vReticuleOldPos)
	w.vReticuleOldPos = w.vReticulePos	
	
	IF (w.bPlayStage)
		EXIT 
	ENDIF 
	
	REPEAT 4 i
		w.iReticuleOverIndex[i] = CMHDZ_EDITOR_CHECK_RETICULE_OVER_INDEX(i)
		IF (w.iReticuleOverIndex[i] != -1)
			IF (w.iEditMode = i) OR (bTypeLocked = FALSE)
				w.iReticuleOverType = i
				bTypeLocked = TRUE 
			ENDIF 
		ENDIF
	ENDREPEAT
	
	CMHDZ_EDITOR_UPDATE_RETICULE_DRAG(w)
ENDPROC

PROC CMHDZ_EDITOR_REBOOT(CMHDZ_EDITOR &w, BOOL bLoad = FALSE)
	w.bPlayStage = FALSE 
	sCMHDZData.bDebugPause = TRUE 
	CMHDZ_EDITOR_LOAD_OR_RESTART_LEVEL(w, bLoad)
	w.iEditMode = CMHDZ_EDITOR_MODE_LEVEL 
	w.iSelectedData = -1
	w.bMenuActive = TRUE 
	w.bRebuildMenu = TRUE
	
	sCMHDZData.bDebugInvunerablePlayer = TRUE
	CDEBUG2LN(DEBUG_MINIGAME, "[BAZ] CMHDZ_EDITOR_REBOOT - w.bPlayStage = FALSE")	
ENDPROC 

PROC CMHDZ_UPDATE_EDITOR_WIDGET(CMHDZ_EDITOR &w)
	IF (!w.bEditorActive)
		EXIT
	ENDIF 

	IF (sCMHDZData.eClientState = CMHDZ_ARCADE_CLIENT_STATE_PLAYING)
		CMHDZ_EDITOR_DRAW_ENTITY_INDICES(w)
		//CMHDZ_EDITOR_DRAW_PROP_STOP_PROP(sCMHDZData.iCurrentScreen)
		CMHDZ_EDITOR_RUN_PLAY_MENU(w)
		EXIT
	ENDIF
	
	IF (w.bPlayStage) 
		sCMHDZData.bDebugInvunerablePlayer = TRUE
		//IF CMHDZ_EDITOR_UPDATE_PLAYER_PROGRESSION(w)
		//IF CMHDZ_MAINTAIN_PLAYER_CURRENT_LEVEL_PROGRESSION()
		IF sCMHDZData.bLevelsCompleted[ENUM_TO_INT(sCMHDZData.eCurrentLevel)]
			w.bPlayStage = FALSE 
			CDEBUG2LN(DEBUG_MINIGAME, "[BAZ] CMHDZ_UPDATE_EDITOR_WIDGET - w.bPlayStage = FALSE")
			sCMHDZData.bDebugPause = TRUE
		ENDIF
		
		IF IS_CONTROL_JUST_PRESSED(FRONTEND_CONTROL, INPUT_CELLPHONE_DOWN) // Originall clashed with reloading. No good
			CMHDZ_EDITOR_REBOOT(w)
			sCMHDZData.bDebugPause = TRUE 
		ENDIF 
	ENDIF 
	

	//CMHDZ_EDITOR_UPDATE_RETICULE(w)
	//CMHDZ_EDITOR_DRAW_SELECTION_OVERLAYS(w)
	CMHDZ_EDITOR_DRAW_ENTITY_INDICES(w)
	//CMHDZ_EDITOR_DRAW_PROP_STOP_PROP((CEIL(sCMHDZData.fOverallLevelProgression/((cfRIGHT_SCREEN_LIMIT + cfLEFT_SCREEN_LIMIT)/2))))
	CMHDZ_EDITOR_DRAW_MINIMAP(w)
	//CMHDZ_DRAW_RETICLES()
	CMHDZ_EDITOR_RUN_MENU(w)
	CMHDZ_EDITOR_RUN_PLAY_MENU(w)
ENDPROC 

PROC CMHDZ_CREATE_EDITOR_WIDGET(CMHDZ_EDITOR &w)
	INT i
	TEXT_LABEL_63 txt 
	
	w.vMiniMapPos = INIT_VECTOR_2D(cfGAME_HUD_MINIMAP_X, cfGAME_HUD_MINIMAP_Y)
	w.vMiniMapSize = INIT_VECTOR_2D(cfGAME_HUD_MINIMAP_WIDTH, cfGAME_HUD_MINIMAP_HEIGHT)
	
	INT iActiveScreen = FLOOR(sCMHDZData.fOverallLevelProgression/cfCMHDZ_SCREEN_LENGTH)
	
	START_WIDGET_GROUP("CMHDZ Editor")
		ADD_WIDGET_BOOL("Editor Active", w.bEditorActive)
		ADD_WIDGET_BOOL("Play Stage", w.bPlayStage)
		
		START_WIDGET_GROUP("Menu")
			ADD_WIDGET_BOOL("Menu Active", w.bMenuActive)
			ADD_WIDGET_BOOL("Rebuild Menu", w.bRebuildMenu)
			ADD_WIDGET_INT_READ_ONLY("Current Selection", w.iMenuCurrentSelection)
		STOP_WIDGET_GROUP()
		
		START_WIDGET_GROUP("Map")
			ADD_WIDGET_BOOL("Show Map", w.bShowMiniMap)
			ADD_WIDGET_VECTOR_2D_SLIDER("Map Display Pos", w.vMiniMapPos, -2000.0, 2000.0, 10.0)
			ADD_WIDGET_VECTOR_2D_SLIDER("Map Display Size", w.vMiniMapSize, -2000.0, 2000.0, 10.0)		
		STOP_WIDGET_GROUP()
		
		START_WIDGET_GROUP("Indexes")
			ADD_WIDGET_BOOL("Show Enemy", w.bShowEntityIndicies[CMHDZ_EDITOR_MODE_ENEMY])
			ADD_WIDGET_BOOL("Show Cover", w.bShowEntityIndicies[CMHDZ_EDITOR_MODE_COVER])
//			ADD_WIDGET_BOOL("Show Hostage", w.bShowEntityIndicies[CMHDZ_EDITOR_MODE_HOSTAGE])
			ADD_WIDGET_BOOL("Show Item", w.bShowEntityIndicies[CMHDZ_EDITOR_MODE_ITEM])
		STOP_WIDGET_GROUP()
			
		START_WIDGET_GROUP("Edit")
			ADD_WIDGET_INT_READ_ONLY("Edit Mode", w.iEditMode)
			ADD_WIDGET_INT_READ_ONLY("New Unit Type", w.iNewUnitData)
			ADD_WIDGET_INT_READ_ONLY("Selected Data", w.iSelectedData)
		STOP_WIDGET_GROUP()
		
		START_WIDGET_GROUP("Level")
			ADD_WIDGET_INT_READ_ONLY("Active Level", w.iActiveLevel)					
			ADD_WIDGET_INT_READ_ONLY("Active Screen", iActiveScreen)
		STOP_WIDGET_GROUP()
		
		START_WIDGET_GROUP("Reticule")
			ADD_WIDGET_INT_READ_ONLY("Reticule Over Type", w.iReticuleOverType)
			ADD_WIDGET_VECTOR_2D_READ_ONLY("Position", w.vReticulePos)
			ADD_WIDGET_VECTOR_2D_READ_ONLY("Delta", w.vReticuleDelta)
			REPEAT 4 i
				txt = "Over "
				txt += CMHDZ_EDITOR_MODE_TO_STRING(i)
				ADD_WIDGET_INT_READ_ONLY(txt, w.iReticuleOverIndex[i])
			ENDREPEAT
		STOP_WIDGET_GROUP()
		
//		START_WIDGET_GROUP("Prop To Stop Screen On")
//			REPEAT ciCMHDZ_MAX_SCREENS i
//				txt = "Scn "
//				txt += i
//				ADD_WIDGET_INT_READ_ONLY(txt, sCMHDZData.iPropToStopOn[i])
//			ENDREPEAT
//		STOP_WIDGET_GROUP()
	STOP_WIDGET_GROUP()
	
	SET_DEBUG_LINES_AND_SPHERES_DRAWING_ACTIVE(TRUE)
ENDPROC 
#ENDIF
#ENDIF

#IF IS_DEBUG_BUILD
PROC CMHDZ_DEBUG_CREATE_WIDGETS()
	
	IF sCMHDZData.bDebugCreatedWidgets
		EXIT
	ENDIF
	
	IF sCMHDZData.widgetGroupExample = NULL
		EXIT
	ENDIF
	
	
	//CDEBUG2LN(DEBUG_MINIGAME, "[CMHDZ_ARCADE] [BAZ] [DSW] Creating widgets...")
	SET_CURRENT_WIDGET_GROUP(sCMHDZData.widgetGroupExample)
	START_WIDGET_GROUP("CMHDZ Arcade Widgets")
		ADD_WIDGET_BOOL("Invunerable Player", sCMHDZData.bDebugInvunerablePlayer)
		ADD_WIDGET_BOOL("Debug Pause", sCMHDZData.bDebugPause)
		ADD_WIDGET_INT_READ_ONLY("Stack Size", sCMHDZData.iDebugStackSize)
		ADD_WIDGET_INT_READ_ONLY("iRectsDrawnThisFrame", iRectsDrawnThisFrame)
		ADD_WIDGET_INT_READ_ONLY("iSpritesDrawnThisFrame", iSpritesDrawnThisFrame)
		ADD_WIDGET_INT_READ_ONLY("iDebugLinesDrawnThisFrame", iDebugLinesDrawnThisFrame)
		ADD_WIDGET_FLOAT_SLIDER("Debug Float", sCMHDZData.fDebugFloat, 0, 5, 0.01)
		
		CMHDZ_DEBUG_CREATE_DEBUG_STATE_WIDGET(sCMHDZData.sClientStateWidget, ENUM_TO_INT(NUM_CMHDZ_ARCADE_CLIENT_STATE), "Client State")		
		
		#IF CMHDZ_CMDLINE_EDITOR_NEW
			CMHDZ_CREATE_EDITOR_WIDGET(sCMHDZData.sEditor)
		#ENDIF

		
//		IF (CMHDZ_MAX_REPLAY_ENTRIES != 1)
//			CMHDZ_DEBUG_CREATE_REPLAY_SYSTEM_WIDGET(sCMHDZData.sReplaySystem)
//		ENDIF
		
		START_WIDGET_GROUP("Game")  
			CMHDZ_DEBUG_CREATE_PLAYER_DATA_WIDGET(sCMHDZData.sPlayerData[0])
			START_WIDGET_GROUP("My Scores")
				ADD_WIDGET_INT_READ_ONLY("Desert ", sCMHDZData.iMyScores[0])
				ADD_WIDGET_INT_READ_ONLY("Town ", sCMHDZData.iMyScores[1])
				ADD_WIDGET_INT_READ_ONLY("Forest ", sCMHDZData.iMyScores[2])
				ADD_WIDGET_INT_READ_ONLY("Mine ", sCMHDZData.iMyScores[3])
				ADD_WIDGET_INT_READ_ONLY("Graveyard ", sCMHDZData.iMyScores[4])
				ADD_WIDGET_INT_READ_ONLY("Successive Hits", sCMHDZData.sPlayerData[0].iSuccessiveHits)
				ADD_WIDGET_INT_READ_ONLY("Chain", sCMHDZData.sPlayerData[0].iChainedScore)
			STOP_WIDGET_GROUP()
			START_WIDGET_GROUP("Level") 
				//ADD_WIDGET_INT_READ_ONLY("# of Stages", sCMHDZData.iDebugTotalStages)
				ADD_WIDGET_INT_READ_ONLY("Shots", sCMHDZData.iTotalLevelShots[CMHDZ_GET_CURRENT_LEVEL()])
				ADD_WIDGET_INT_READ_ONLY("Enemy Kills", sCMHDZData.iTotalLevelEnemyHits[CMHDZ_GET_CURRENT_LEVEL()])
				ADD_WIDGET_INT_READ_ONLY("HeadShots", sCMHDZData.iTotalLevelEnemyHeadShots[CMHDZ_GET_CURRENT_LEVEL()])
				//ADD_WIDGET_INT_READ_ONLY("Birds", sCMHDZData.iTotalLevelBirdsShot[CMHDZ_GET_CURRENT_LEVEL()])
			STOP_WIDGET_GROUP()
			START_WIDGET_GROUP("Enemies Count")
				ADD_WIDGET_INT_READ_ONLY("Lane 0 Active ", sCMHDZData.iCurrentActiveEnemies[0])
				ADD_WIDGET_INT_READ_ONLY("Lane 1 Active ", sCMHDZData.iCurrentActiveEnemies[1])
				ADD_WIDGET_INT_READ_ONLY("Lane 2 Active ", sCMHDZData.iCurrentActiveEnemies[2])
				ADD_WIDGET_INT_READ_ONLY("Total rem ", sCMHDZData.iDebugEnemiesRemaining)				
				ADD_WIDGET_INT_READ_ONLY("Total Spawned", sCMHDZData.iTotalNumberOfEnemiesSpawned)
				ADD_WIDGET_INT_READ_ONLY("Total Count", sCMHDZData.iTotalNumberOfEnemies)
				ADD_WIDGET_BOOL("Output all pos", sCMHDZData.bDebugOutputAliveEnemies)
			STOP_WIDGET_GROUP()
			START_WIDGET_GROUP("Background") 
				ADD_WIDGET_BOOL("Stop moving", sCMHDZData.bStopMovingLevel)
				ADD_WIDGET_BOOL("Hide Facade", sCMHDZData.bDisableFacade)
				ADD_WIDGET_BOOL("Shift props left", sCMHDZData.bDebugShiftPropsLeft)
				ADD_WIDGET_BOOL("Shift props right", sCMHDZData.bDebugShiftPropsRight)
				ADD_WIDGET_BOOL("Flip Background", sCMHDZData.bFlipBackground)
				ADD_WIDGET_INT_READ_ONLY("# of BG Elements Drawn", sCMHDZData.iNumberOfBackgroundElementsDrawn)
				ADD_WIDGET_FLOAT_SLIDER("Background Speed Mult", sCMHDZData.fBackgroundSpeedMult, 1, 20.0, 1)
				
				ADD_WIDGET_FLOAT_READ_ONLY("Tile 0 X", sCMHDZData.sBackgroundTilesData[0].vSpritePos.x)
				ADD_WIDGET_FLOAT_READ_ONLY("Tile 1 X", sCMHDZData.sBackgroundTilesData[1].vSpritePos.x)
	//			ADD_WIDGET_FLOAT_READ_ONLY("Tile 2 X", sCMHDZData.sBackgroundTilesData[2].vSpritePos.x)
	//			ADD_WIDGET_FLOAT_READ_ONLY("Tile 3 X", sCMHDZData.sBackgroundTilesData[3].vSpritePos.x)
	//			ADD_WIDGET_FLOAT_READ_ONLY("Tile 4 X", sCMHDZData.sBackgroundTilesData[4].vSpritePos.x)
	//			ADD_WIDGET_FLOAT_READ_ONLY("Tile 5 X", sCMHDZData.sBackgroundTilesData[5].vSpritePos.x)
	//			ADD_WIDGET_FLOAT_READ_ONLY("Tile 6 X", sCMHDZData.sBackgroundTilesData[6].vSpritePos.x)
			STOP_WIDGET_GROUP()
			START_WIDGET_GROUP("Player Thrown Projectiles")
				ADD_WIDGET_BOOL("Set Projectile", sCMHDZData.bDebugSetPlayerProjectile)
				sCMHDZData.twDebugPlayerProjectileType = ADD_TEXT_WIDGET("Projectile")
				ADD_WIDGET_INT_SLIDER("Projectile Type", sCMHDZData.iDebugPlayerProjectileType, 0, ENUM_TO_INT(NUM_CMHDZ_PROJECTILE_TYPES) - 1, 1)
				ADD_WIDGET_INT_SLIDER("Ammo Count", sCMHDZData.sPlayerData[0].iThrownProjectilesAmmo, 0, 99, 1)
				ADD_WIDGET_INT_SLIDER("Reload Time", sCMHDZData.sPlayerData[0].iThrownProjectileReloadDelay, 0, 5000, 250)
				ADD_WIDGET_BOOL("Launch Projectile", sCMHDZData.bDebugLaunchPlayerProjectile)
				ADD_WIDGET_BOOL("Clear Projectile", sCMHDZData.bDebugClearPlayerProjectile)
			STOP_WIDGET_GROUP()
			START_WIDGET_GROUP("Enemy Projectiles")
				ADD_WIDGET_BOOL("Launch Projectile", sCMHDZData.bDebugLaunchDynamite)
				ADD_WIDGET_BOOL("Clear Projectile", sCMHDZData.bDebugClearDynamite)
			STOP_WIDGET_GROUP()
			START_WIDGET_GROUP("Awards")
				ADD_WIDGET_BOOL("Award Deadeye T-Shirt", sCMHDZData.bDebugAwardDeadeye)
				ADD_WIDGET_INT_SLIDER("Sharshooter award", sCMHDZData.iDebugFACES_OF_DEATH, 0, 50, 1)
				ADD_WIDGET_BOOL("Set birds shot", sCMHDZData.bDebugAwardSetFACES_OF_DEATH)
				ADD_WIDGET_BOOL("Award FACES_OF_DEATH T-Shirt", sCMHDZData.bDebugAwardFACES_OF_DEATH)
				ADD_WIDGET_BOOL("Award Pistols at dawn T-Shirt", sCMHDZData.bDebugAwardSTV)
				ADD_WIDGET_BOOL("Award Complete T-Shirt", sCMHDZData.bDebugAwardComplete)
				ADD_WIDGET_BOOL("Award Complete Trophy", sCMHDZData.bDebugAwardTrophy)
				ADD_WIDGET_BOOL("Clear stats", sCMHDZData.bClearAwardStats)			
			STOP_WIDGET_GROUP()
			
			START_WIDGET_GROUP("Pickups")
				ADD_WIDGET_BOOL("Enable", sCMHDZData.bDebugEnablePickup)
				ADD_WIDGET_INT_SLIDER("Show Screen Pickups", sCMHDZData.iDebugPickupScreen, -1, ciCMHDZ_MAX_SCREENS, 1)
				ADD_WIDGET_BOOL("Quad Damage", sCMHDZData.bDebugEnableQuadDamage)
			STOP_WIDGET_GROUP()
		STOP_WIDGET_GROUP()
		
		START_WIDGET_GROUP("Level Select Screen Debug")

			
			ADD_WIDGET_FLOAT_SLIDER("Level 1 score X", cfCMHDZ_SOLO_LEVEL1_SCORE_X_POS, -100, 2000, 4)
			ADD_WIDGET_FLOAT_SLIDER("Level 2 score X", cfCMHDZ_SOLO_LEVEL2_SCORE_X_POS, -100, 2000, 4)
			ADD_WIDGET_FLOAT_SLIDER("Level 3 score X", cfCMHDZ_SOLO_LEVEL3_SCORE_X_POS, -100, 2000, 4)
			ADD_WIDGET_FLOAT_SLIDER("Level 4 score X", cfCMHDZ_SOLO_LEVEL4_SCORE_X_POS, -100, 2000, 4)
			ADD_WIDGET_FLOAT_SLIDER("Level 5 score X", cfCMHDZ_SOLO_LEVEL5_SCORE_X_POS, -100, 2000, 4)
			
			ADD_WIDGET_FLOAT_SLIDER("Level 1 Star X", cfCMHDZ_SOLO_LEVEL1_STAR_X_POS, -100, 2000, 4)
			ADD_WIDGET_FLOAT_SLIDER("Level 1 Star Y", cfCMHDZ_SOLO_LEVEL1_STAR_Y_POS, -100, 2000, 4)
			ADD_WIDGET_FLOAT_SLIDER("Level 2 Star X", cfCMHDZ_SOLO_LEVEL2_STAR_X_POS, -100, 2000, 4)
			ADD_WIDGET_FLOAT_SLIDER("Level 3 Star X", cfCMHDZ_SOLO_LEVEL3_STAR_X_POS, -100, 2000, 4)
			ADD_WIDGET_FLOAT_SLIDER("Level 4 Star X", cfCMHDZ_SOLO_LEVEL4_STAR_X_POS, -100, 2000, 4)
			ADD_WIDGET_FLOAT_SLIDER("Level 4 Star Y", cfCMHDZ_SOLO_LEVEL4_STAR_Y_POS, -100, 2000, 4)
			ADD_WIDGET_FLOAT_SLIDER("Level 5 Star X", cfCMHDZ_SOLO_LEVEL5_STAR_X_POS, -100, 2000, 4)

//			ADD_WIDGET_FLOAT_SLIDER("Level Accuracy Results Pos X", cfCMHDZ_RESULTS_SCREEN_COMPLETE_ACCURACY_POS_X, -100, 2000, 4)
//			ADD_WIDGET_FLOAT_SLIDER("Level Accuracy VAL Results Pos X", cfCMHDZ_RESULTS_SCREEN_COMPLETE_ACCURACY_VAL_POS_X, -100, 2000, 4)
//			
//			ADD_WIDGET_FLOAT_SLIDER("GAME Score Results Pos X", cfCMHDZ_RESULTS_SCREEN_GAME_COMPLETE_SCORE_POS_X, -100, 2000, 4)
//			ADD_WIDGET_FLOAT_SLIDER("GAME Accuracy Results Pos X", cfCMHDZ_RESULTS_SCREEN_COMPLETE_ACCURACY_POS_X, -100, 2000, 4)
		
		STOP_WIDGET_GROUP()
		
		START_WIDGET_GROUP("Result Screen Debug")
		
			ADD_WIDGET_FLOAT_SLIDER("Level Score Results Pos X", cfCMHDZ_RESULTS_SCREEN_COMPLETE_SCORE_POS_X, -100, 2000, 4)
			ADD_WIDGET_FLOAT_SLIDER("Level Score Results VAL Pos X", cfCMHDZ_RESULTS_SCREEN_COMPLETE_SCORE_VAL_POS_X, -100, 2000, 4)
			
//			ADD_WIDGET_FLOAT_SLIDER("Level Score Results Pos X", cfCMHDZ_RESULTS_SCREEN_COMPLETE_SCORE_VAL_POS_X, -100, 2000, 4)
//			ADD_WIDGET_FLOAT_SLIDER("Level Score Results VAL Pos X", cfCMHDZ_RESULTS_SCREEN_COMPLETE_SCORE_VAL_POS_X, -100, 2000, 4)
			
			ADD_WIDGET_FLOAT_SLIDER("Level Accuracy Results Pos X", cfCMHDZ_RESULTS_SCREEN_COMPLETE_ACCURACY_POS_X, -100, 2000, 4)
			ADD_WIDGET_FLOAT_SLIDER("Level Accuracy VAL Results Pos X", cfCMHDZ_RESULTS_SCREEN_COMPLETE_ACCURACY_VAL_POS_X, -100, 2000, 4)
			
			ADD_WIDGET_FLOAT_SLIDER("GAME Score Results Pos X", cfCMHDZ_RESULTS_SCREEN_GAME_COMPLETE_SCORE_VAL_POS_X, -100, 2000, 4)
			ADD_WIDGET_FLOAT_SLIDER("GAME Accuracy Results Pos X", cfCMHDZ_RESULTS_SCREEN_COMPLETE_ACCURACY_VAL_POS_X, -100, 2000, 4)
			
			ADD_WIDGET_FLOAT_SLIDER("GAME Star Results Pos X", cfCMHDZ_SOLO_RESULTS_STAR_X_POS, -100, 2000, 2)
			ADD_WIDGET_FLOAT_SLIDER("GAME Star Results Pos Y", cfCMHDZ_SOLO_RESULTS_STAR_Y_POS, -100, 2000, 2)
		
			ADD_WIDGET_FLOAT_SLIDER("FINAL Star Results Pos X", cfCMHDZ_SOLO_GAME_RESULTS_STAR_X_POS, -100, 2000, 2)
			ADD_WIDGET_FLOAT_SLIDER("FINAL Star Results Pos Y", cfCMHDZ_SOLO_GAME_RESULTS_STAR_Y_POS, -100, 2000, 2)
						
			ADD_WIDGET_FLOAT_SLIDER("cfCMHDZ_SPRITE_HUD_TIME_TEXT_X", cfCMHDZ_SPRITE_HUD_TIME_TEXT_X, -100, 2000, 2)
			ADD_WIDGET_FLOAT_SLIDER("cfCMHDZ_SPRITE_HUD_TIME_TEXT_Y", cfCMHDZ_SPRITE_HUD_TIME_TEXT_Y, -100, 2000, 2)
			
		STOP_WIDGET_GROUP()
		
		START_WIDGET_GROUP("Bazal's Debug")
			START_WIDGET_GROUP("Stuff")
				ADD_WIDGET_FLOAT_READ_ONLY("vSpriteMarkerPos X", sCMHDZData.sPlayerData[0].vSpriteFinalReticlePos.x)
				ADD_WIDGET_FLOAT_READ_ONLY("vSpriteMarkerPos Y", sCMHDZData.sPlayerData[0].vSpriteFinalReticlePos.y)
				ADD_WIDGET_FLOAT_READ_ONLY("Prop X", sCMHDZData.sCoverData[8].vSpritePos.x)
				ADD_WIDGET_FLOAT_READ_ONLY("Prop X", sCMHDZData.sCoverData[9].vSpritePos.x)
				ADD_WIDGET_FLOAT_READ_ONLY("Prop X", sCMHDZData.sCoverData[10].vSpritePos.x)
				ADD_WIDGET_FLOAT_READ_ONLY("Enemy X", sCMHDZData.sEnemyData[0].vSpritePos.x)
		//		ADD_WIDGET_FLOAT_SLIDER("Reticule Screen Sp X", sCMHDZData.fDebugEntityWorldSpaceX, -cfGAME_SCREEN_WIDTH, cfGAME_SCREEN_WIDTH, 0.5)
		//		ADD_WIDGET_FLOAT_SLIDER("Reticule Screen Sp Y", sCMHDZData.fDebugEntityWorldSpaceY, -cfGAME_SCREEN_HEIGHT, cfGAME_SCREEN_HEIGHT, 0.5)
			STOP_WIDGET_GROUP()
			
			START_WIDGET_GROUP("Enemy Hover")
				ADD_WIDGET_BOOL("Enable Enemy Hover", sCMHDZData.bEnableEnemyHover)
				ADD_WIDGET_FLOAT_READ_ONLY("Marker World Px Pos X", sCMHDZData.sPlayerData[0].vSpriteFinalReticlePos.x)
				ADD_WIDGET_FLOAT_READ_ONLY("Marker World Px Pos Y", sCMHDZData.sPlayerData[0].vSpriteFinalReticlePos.y)
				ADD_WIDGET_FLOAT_READ_ONLY("Reticule-Entity Dist", sCMHDZData.fReticuleSpriteDist)
				ADD_WIDGET_INT_READ_ONLY("Entity ID", sCMHDZData.iDebugEntityId )
				ADD_WIDGET_INT_READ_ONLY("Entity Type", sCMHDZData.iDebugType )
				ADD_WIDGET_INT_READ_ONLY("Entity State", sCMHDZData.iDebugEntityState )
				ADD_WIDGET_FLOAT_READ_ONLY("Entity stopping X", sCMHDZData.fEntityStoppingX)
				ADD_WIDGET_INT_READ_ONLY("Lane", sCMHDZData.iDebugLane) 
				ADD_WIDGET_INT_READ_ONLY("Anim frame", sCMHDZData.iDebugAnimFrame)
				ADD_WIDGET_FLOAT_READ_ONLY("Entity World X", sCMHDZData.fDebugEntityWorldX)
				ADD_WIDGET_FLOAT_READ_ONLY("Entity World Y", sCMHDZData.fDebugEntityWorldY)
	//			ADD_WIDGET_FLOAT_READ_ONLY("Entity TL X", sCMHDZData.fDebugEntityCornerX[0])
	//			ADD_WIDGET_FLOAT_READ_ONLY("Entity TL Y", sCMHDZData.fDebugEntityCornerY[0])
	//			ADD_WIDGET_FLOAT_READ_ONLY("Entity BR X", sCMHDZData.fDebugEntityCornerX[1])
	//			ADD_WIDGET_FLOAT_READ_ONLY("Entity BR Y", sCMHDZData.fDebugEntityCornerY[1])
	//			ADD_WIDGET_FLOAT_READ_ONLY("Ent-Ret TL X Diff", sCMHDZData.fDebugReticuleEntityTLDiffX)
	//			ADD_WIDGET_FLOAT_READ_ONLY("Ent-Ret TL Y Diff", sCMHDZData.fDebugReticuleEntityTLDiffY)
			STOP_WIDGET_GROUP()
		
			START_WIDGET_GROUP("Texture Pos")
				ADD_WIDGET_FLOAT_SLIDER("Texture 1 X", sCMHDZData.fTexturePosX[0], -10000.0, 10000.0, 0.5)
				ADD_WIDGET_FLOAT_SLIDER("Texture 1 Y", sCMHDZData.fTexturePosY[0], -10000.0, 10000.0, 0.5)
				ADD_WIDGET_FLOAT_SLIDER("Texture 1 Scale", sCMHDZData.fTextureScale[0], 0.0, 1.0, 0.05)
				ADD_WIDGET_FLOAT_SLIDER("Texture 2 X", sCMHDZData.fTexturePosX[1], -10000.0, 10000.0, 0.5)
				ADD_WIDGET_FLOAT_SLIDER("Texture 2 Y", sCMHDZData.fTexturePosY[1], -10000.0, 10000.0, 0.5)
				ADD_WIDGET_FLOAT_SLIDER("Texture 3 X", sCMHDZData.fTexturePosX[2], -10000.0, 10000.0, 0.5)
				ADD_WIDGET_FLOAT_SLIDER("Texture 3 Y", sCMHDZData.fTexturePosY[2], -10000.0, 10000.0, 0.5)
				ADD_WIDGET_INT_SLIDER("Value", sCMHDZData.iDebugIntegerValue,0, 100000, 1)
				ADD_WIDGET_FLOAT_SLIDER("Scale",sCMHDZData.fDebugFloatValue, -10.0, 10.0, 0.1)
			STOP_WIDGET_GROUP()
			
			START_WIDGET_GROUP("Props / Cover")  
				ADD_WIDGET_BOOL("Enable Hover", sCMHDZData.bEnableCoverHover)
				ADD_WIDGET_BOOL("Stop moving", sCMHDZData.bStopMovingLevel)
				ADD_WIDGET_INT_READ_ONLY("Index", sCMHDZData.iDebugIntegerValue)
				sCMHDZData.twDebugId = ADD_TEXT_WIDGET("Prop Type") 
				ADD_WIDGET_FLOAT_READ_ONLY("Prop X", sCMHDZData.fDebugEntityWorldX)
				ADD_WIDGET_FLOAT_READ_ONLY("Prop Y", sCMHDZData.fDebugEntityWorldY)
				ADD_WIDGET_INT_READ_ONLY("Prop Lane", sCMHDZData.iDebugLane)
//				ADD_WIDGET_INT_READ_ONLY("Prop Screen", sCMHDZData.iDebugCoverScreen)
				ADD_WIDGET_FLOAT_READ_ONLY("Prop Scale", sCMHDZData.fDebugEntityScale)
				ADD_WIDGET_BOOL("Edit", sCMHDZData.bDebugEnableEdit)
				ADD_WIDGET_BOOL("Finalise Edit", sCMHDZData.bDebugFinaliseEdit)
				ADD_WIDGET_BOOL("Hide Foreground", sCMHDZData.bDebugHideForegroundProps)
				ADD_WIDGET_INT_READ_ONLY("Editing ID", sCMHDZData.iEntityEdit)
				sCMHDZData.twDebugId = ADD_TEXT_WIDGET("Editing Type") 
				ADD_WIDGET_FLOAT_SLIDER("Pos X", sCMHDZData.fTexturePosX[0], -10000.0, 10000.0, 0.5)
				ADD_WIDGET_FLOAT_SLIDER("Pos Y", sCMHDZData.fTexturePosY[0], -10000.0, 10000.0, 0.5)
				ADD_WIDGET_FLOAT_READ_ONLY("Initial Pos X", sCMHDZData.fTexturePosX[1])
				ADD_WIDGET_FLOAT_READ_ONLY("Initial Pos Y", sCMHDZData.fTexturePosY[1])
			STOP_WIDGET_GROUP()
	/*
			START_WIDGET_GROUP("Controls")
	//			ADD_WIDGET_FLOAT_READ_ONLY("Stick X", sCMHDZData.fDebugStickX)
	//			ADD_WIDGET_FLOAT_READ_ONLY("Stick Y", sCMHDZData.fDebugStickX)
	//			ADD_WIDGET_FLOAT_READ_ONLY("Mouse X", sCMHDZData.fDebugMouseX)
	//			ADD_WIDGET_FLOAT_READ_ONLY("Mouse Y", sCMHDZData.fDebugMouseY)
			STOP_WIDGET_GROUP()
	*/
		STOP_WIDGET_GROUP()

	STOP_WIDGET_GROUP()
	
	ARCADE_GAMES_LEADERBOARD_WIDGET_CREATE(sCMHDZData.sLbData)	
	ARCADE_GAMES_POSTFX_WIDGET_CREATE()
	
	START_WIDGET_GROUP("Debug Rect")
		ADD_WIDGET_BOOL("Show Rect", sCMHDZData.bDrawDebugRect)
		ADD_WIDGET_BOOL("Center Mode", sCMHDZData.bDebugRectCenterMode)
		CMHDZ_ADD_WIDGET_VECTOR_2D_SLIDER("Top Left (Center)", sCMHDZData.vDebugRect[0], -cfBASE_SCREEN_WIDTH, cfBASE_SCREEN_WIDTH, 10)
		CMHDZ_ADD_WIDGET_VECTOR_2D_SLIDER("Base Right (HalfSize)", sCMHDZData.vDebugRect[1], -cfBASE_SCREEN_WIDTH, cfBASE_SCREEN_WIDTH, 10)			
	STOP_WIDGET_GROUP()	
			
	START_WIDGET_GROUP("Update")
		ADD_WIDGET_INT_SLIDER("Base FPS", ciBASE_FPS, 0, 1000, 1)
	STOP_WIDGET_GROUP()
	START_WIDGET_GROUP("Server BD")
		ADD_WIDGET_INT_READ_ONLY("Number of players ", cmhdzServerBd.iNumPlayers)
	STOP_WIDGET_GROUP()
		
	CLEAR_CURRENT_WIDGET_GROUP(sCMHDZData.widgetGroupExample)
	
	sCMHDZData.fTexturePosX[0] = 1000.0 //cfBASE_SCREEN_WIDTH/6*2
	sCMHDZData.fTexturePosY[0] =  315.0 //152.500
	sCMHDZData.fTextureScale[0] = 1.0 
	sCMHDZData.fTexturePosX[1] = cfCMHDZ_RESULTS_SCREEN_COMPLETE_ACCURACY_POS_X 
	sCMHDZData.fTexturePosY[1] = cfCMHDZ_RESULTS_SCREEN_COMPLETE_ACCURACY_POS_Y
	sCMHDZData.fTexturePosX[2] = 500.0
	sCMHDZData.fTexturePosY[2] = 500.0
	
	sCMHDZData.iDebugIntegerValue = 7250
	sCMHDZData.fDebugFloatValue = 1.0
	
	sCMHDZData.iDebugCover = -1
	sCMHDZData.iDebugForegroundEnemy = -1
	sCMHDZData.iDebugMiddleEnemy = -1
	sCMHDZData.iDebugBackgroundEnemy = -1
	
	sCMHDZData.bDebugCreatedWidgets = TRUE

ENDPROC

PROC CMHDZ_UPDATE_WIDGETS()
	INT i
	
	sCMHDZData.iDebugStackSize = GET_CURRENT_STACK_SIZE()
	
	#IF CMHDZ_CMDLINE_EDITOR_NEW
		CMHDZ_DEBUG_UPDATE_CLIENT_STATE_WIDGET(sCMHDZData.sClientStateWidget)
		CMHDZ_UPDATE_EDITOR_WIDGET(sCMHDZData.sEditor)
	#ENDIF
	
	IF PARTICIPANT_ID_TO_INT() >= 0
		
		IF sCMHDZData.iMyScores[sCMHDZData.iStaggeredDebugCount] != playerBd[PARTICIPANT_ID_TO_INT()].iPlayerScore[sCMHDZData.iStaggeredDebugCount]
			sCMHDZData.iMyScores[sCMHDZData.iStaggeredDebugCount] = playerBd[PARTICIPANT_ID_TO_INT()].iPlayerScore[sCMHDZData.iStaggeredDebugCount]
		ENDIF
		
	ENDIF
	
	sCMHDZData.iDebugEnemiesRemaining = CMHDZ_GET_TOTAL_NUMBER_OF_ENEMIES_LEFT_ALIVE_FOR_CURRENT_SCREEN()
	
	VECTOR_2D vReticule = CMHDZ_GET_PLAYER_RETICULE_POSITON()
	FLOAT distanceX, distanceY, fDistance, fDistanceToCheck
	BOOL bIsHovering
	IF sCMHDZData.bEnableEnemyHover
		FOR i = 0 TO ciCMHDZ_MAX_ENEMIES  -1

			IF (sCMHDZData.sEnemyData[i].eState = CMHDZ_ENEMY_STATE_ACTIVE OR sCMHDZData.sEnemyData[i].eState = CMHDZ_ENEMY_STATE_ATTACKING) AND sCMHDZData.sEnemyData[i].iHealth > 0
				distanceX = vReticule.x - sCMHDZData.sEnemyData[i].vSpritePos.x
				distanceY = vReticule.y - sCMHDZData.sEnemyData[i].vSpritePos.y
				fDistance = SQRT(distanceX * distanceX + distanceY * distanceY)
				
				IF (sCMHDZData.sEnemyData[i].iEnemyLane = ciCMHDZ_LANE_BACKGROUND OR sCMHDZData.sEnemyData[i].iEnemyLane = ciCMHDZ_LANE_MIDDLE)
					fDistanceToCheck = 120.0
				ELSE
					fDistanceToCheck = 320.0 // 280.0
				ENDIF
				
				IF fDistance < fDistanceToCheck
					sCMHDZData.fReticuleSpriteDist = fDistance
					sCMHDZData.iDebugEntityId = i
					sCMHDZData.iDebugType = ENUM_TO_INT(sCMHDZData.sEnemyData[i].iEnemyType)
					sCMHDZData.iDebugLane = sCMHDZData.sEnemyData[i].iEnemyLane
					sCMHDZData.iDebugEntityState  = ENUM_TO_INT(sCMHDZData.sEnemyData[i].eState)
					sCMHDZData.fEntityStoppingX = sCMHDZData.sEnemyData[i].fStoppingX
					sCMHDZData.fDebugEntityWorldX = sCMHDZData.sEnemyData[i].vSpritePos.x
					sCMHDZData.fDebugEntityWorldY = sCMHDZData.sEnemyData[i].vSpritePos.Y
					
					sCMHDZData.iDebugAnimFrame = sCMHDZData.sEnemyData[i].iSpriteAnimFrame
					
					VECTOR_2D vCorner0 = INIT_VECTOR_2D(sCMHDZData.sEnemyData[i].vSpritePos.x - (sCMHDZData.sEnemyData[i].vSize.x/2), sCMHDZData.sEnemyData[i].vSpritePos.y - (sCMHDZData.sEnemyData[i].vSize.y/2))
					VECTOR_2D vCorner1 = INIT_VECTOR_2D(sCMHDZData.sEnemyData[i].vSpritePos.x + (sCMHDZData.sEnemyData[i].vSize.x/2), sCMHDZData.sEnemyData[i].vSpritePos.y + (sCMHDZData.sEnemyData[i].vSize.y/2)) 
					
					sCMHDZData.fDebugEntityCornerX[0] = vCorner0.x
					sCMHDZData.fDebugEntityCornerY[0] = vCorner0.y
					sCMHDZData.fDebugEntityCornerX[1] = vCorner1.x
					sCMHDZData.fDebugEntityCornerY[1] = vCorner1.y
					
					sCMHDZData.fDebugReticuleEntityTLDiffX = vReticule.x - vCorner0.x
					sCMHDZData.fDebugReticuleEntityTLDiffY = vReticule.y - vCorner0.y
					bIsHovering = TRUE
				ENDIF
			ENDIF
		ENDFOR
		
		IF NOT bIsHovering
			sCMHDZData.iDebugEntityId = -1
			sCMHDZData.fDebugEntityWorldX = -1.0
			sCMHDZData.fDebugEntityWorldY = -1.0
			sCMHDZData.fDebugEntityCornerX[0] = -1.0
			sCMHDZData.fDebugEntityCornerY[0] = -1.0
			sCMHDZData.fDebugEntityCornerX[1] = -1.0
			sCMHDZData.fDebugEntityCornerY[1] = -1.0
			sCMHDZData.iDebugLane = -1
			sCMHDZData.fReticuleSpriteDist = -1.0
			sCMHDZData.fDebugReticuleEntityTLDiffX = -1.0
			sCMHDZData.fDebugReticuleEntityTLDiffY = -1.0
		ENDIF
	ENDIF
	STRING sCover
	IF sCMHDZData.bEnableCoverHover
		INT iClosest = CMHDZ_GET_CLOSEST_PROP_TO_COORD(vReticule)
		IF iClosest > -1
			sCover = CMHDZ_ASSET_TYPES_TO_STRING(sCMHDZData.sCoverData[iClosest].eType)
			sCMHDZData.fDebugEntityWorldX = sCMHDZData.sCoverData[iClosest].vSpritePos.x
			sCMHDZData.fDebugEntityWorldY = sCMHDZData.sCoverData[iClosest].vSpritePos.Y
			sCMHDZData.iDebugLane = sCMHDZData.sCoverData[iClosest].iCoverLane
			sCMHDZData.iDebugIntegerValue = iClosest
//			sCMHDZData.iDebugCoverScreen = sCMHDZData.sCoverData[iClosest].iScreen
			sCMHDZData.fDebugEntityScale = CMHDZ_COVER_UTIL_GET_TYPE_SCALE_FOR_LANE(sCMHDZData.sCoverData[iClosest].eType, sCMHDZData.sCoverData[iClosest].iCoverLane)
		ELSE
			sCover = CMHDZ_ASSET_TYPES_TO_STRING(CMHDZ_ASSET_INVALID)
			sCMHDZData.fDebugEntityWorldX = -9999999.0
			sCMHDZData.fDebugEntityWorldY = -9999999.0
			sCMHDZData.iDebugIntegerValue = -1
		ENDIF
		SET_CONTENTS_OF_TEXT_WIDGET(sCMHDZData.twDebugId, sCover)
	ENDIF
	
	IF sCMHDZData.bDebugEnableEdit
	AND sCMHDZData.bEnableCoverHover
		IF NOT sCMHDZData.bDebugInitEdit
		AND sCMHDZData.iDebugIntegerValue > -1
			sCMHDZData.iEntityEdit = sCMHDZData.iDebugIntegerValue
			sCMHDZData.bDebugInitEdit = TRUE
			sCMHDZData.fTexturePosX[0] = sCMHDZData.sCoverData[sCMHDZData.iEntityEdit].vSpritePos.x
			sCMHDZData.fTexturePosY[0] = sCMHDZData.sCoverData[sCMHDZData.iEntityEdit].vSpritePos.y
			sCMHDZData.fTexturePosX[1] = sCMHDZData.sCoverData[sCMHDZData.iEntityEdit].vSpriteInitialPos.x
			sCMHDZData.fTexturePosY[1] = sCMHDZData.sCoverData[sCMHDZData.iEntityEdit].vSpriteInitialPos.y
			sCMHDZData.fTexturePosX[2] = sCMHDZData.sCoverData[sCMHDZData.iEntityEdit].vSpritePos.x
			sCMHDZData.fTexturePosY[2] = sCMHDZData.sCoverData[sCMHDZData.iEntityEdit].vSpritePos.y
			sCMHDZData.bDebugHideForegroundProps = TRUE
		ELIF sCMHDZData.bDebugInitEdit
			sCover = CMHDZ_ASSET_TYPES_TO_STRING(sCMHDZData.sCoverData[sCMHDZData.iEntityEdit].eType)
			SET_CONTENTS_OF_TEXT_WIDGET(sCMHDZData.twDebugId, sCover)
			sCMHDZData.sCoverData[sCMHDZData.iEntityEdit].vSpritePos = GET_DEBUG_TEXTURE_POS(0)
			IF (sCMHDZData.fTexturePosY[2] != sCMHDZData.fTexturePosY[0])
				sCMHDZData.fTexturePosY[1] -= (sCMHDZData.fTexturePosY[2] - sCMHDZData.fTexturePosY[0])
				sCMHDZData.fTexturePosY[2] = sCMHDZData.fTexturePosY[0]
			ENDIF
			
			IF (sCMHDZData.fTexturePosX[2] != sCMHDZData.fTexturePosX[0])
				sCMHDZData.fTexturePosX[1] -= (sCMHDZData.fTexturePosX[2] - sCMHDZData.fTexturePosX[0])
				sCMHDZData.fTexturePosX[2] = sCMHDZData.fTexturePosX[0]
			ENDIF			
			
			IF (sCMHDZData.bDebugFinaliseEdit) OR (sCMHDZData.bStopMovingLevel)
				sCMHDZData.sCoverData[sCMHDZData.iEntityEdit].vSpriteInitialPos.x = sCMHDZData.fTexturePosX[1]
				sCMHDZData.sCoverData[sCMHDZData.iEntityEdit].vSpriteInitialPos.y = sCMHDZData.fTexturePosY[1]
				sCMHDZData.bDebugFinaliseEdit = FALSE 
			ENDIF
		ENDIF
	ELSE
		IF sCMHDZData.bDebugInitEdit
			sCMHDZData.bDebugInitEdit = FALSE
			sCMHDZData.iEntityEdit = -1
		ENDIF
	ENDIF
		
	IF sCMHDZData.bDebugShiftPropsLeft
		sCMHDZData.bDebugShiftPropsLeft = FALSE
		i = 0
		REPEAT ciCMHDZ_MAX_COVER i

			sCMHDZData.sCoverData[i].vSpritePos.x -= (cfBASE_SCREEN_WIDTH / 2.0)

		ENDREPEAT
	ENDIF
	
	IF sCMHDZData.bDebugShiftPropsRight
		sCMHDZData.bDebugShiftPropsRight = FALSE
		i = 0
		REPEAT ciCMHDZ_MAX_COVER i
			sCMHDZData.sCoverData[i].vSpritePos.x += (cfBASE_SCREEN_WIDTH / 2.0)
		ENDREPEAT
	ENDIF
	
	IF sCMHDZData.bDebugOutputAliveEnemies
		sCMHDZData.bDebugOutputAliveEnemies = FALSE
		
		CMHDZ_DEBUG_OUTPUT_ALL_ENEMY_POSITIONS()
	ENDIF
	
	IF sCMHDZData.bDebugAwardDeadeye
		sCMHDZData.bDebugAwardDeadeye = FALSE
		CMHDZ_AWARD_TRAINED_TO_KILL()
	ENDIF
	
	IF sCMHDZData.bDebugAwardSTV
		sCMHDZData.bDebugAwardSTV = FALSE
		CMHDZ_AWARD_STRAIGHT_TO_VIDEO()
	ENDIF
	
//	IF sCMHDZData.bDebugAwardFACES_OF_DEATH
//		sCMHDZData.bDebugAwardFACES_OF_DEATH = FALSE
//		ARCADE_CABINET_FLOW_NOTIFICATIONS_SET_SHOW_TSHIRT_HELP(ARCADE_GAME_TSHIRTS_)
//	ENDIF
//	
//	IF sCMHDZData.bDebugAwardSetFACES_OF_DEATH
//		sCMHDZData.bDebugAwardSetFACES_OF_DEATH = FALSE
//		//sCMHDZData.iTotalLevelBirdsShot[1] = sCMHDZData.iDebugFACES_OF_DEATH
//		IF sCMHDZData.iDebugFACES_OF_DEATH >= CMHDZ_GET_FACES_OF_DEATH_AWARD_PLATINUM_TARGET_SCORE()
//			CMHDZ_AWARD_FACES_OF_DEATH(sCMHDZData.iDebugFACES_OF_DEATH, TRUE)
//		ELSE
//			CMHDZ_AWARD_FACES_OF_DEATH(sCMHDZData.iDebugFACES_OF_DEATH, FALSE)
//		ENDIF
//	ENDIF


//	IF sCMHDZData.bDebugAwardComplete
//		sCMHDZData.bDebugAwardComplete = FALSE
//		ARCADE_CABINET_FLOW_NOTIFICATIONS_SET_SHOW_TSHIRT_HELP(ARCADE_GAME_TSHIRTS_CAMHEDZ_FOD)
//	ENDIF
	
	IF sCMHDZData.bDebugAwardTrophy
		sCMHDZData.bDebugAwardTrophy = FALSE
		ARCADE_CABINET_FLOW_NOTIFICATIONS_SET_SHOW_TROPHY_HELP(ARCADE_GAME_TROPHY_CAMHEDZ, TRUE)
		SET_PACKED_STAT_BOOL(PACKED_MP_AWARD_BEARSY_MASK, TRUE)
	ENDIF
	
	IF sCMHDZData.bClearAwardStats 
		SET_MP_INT_CHARACTER_STAT(MP_STAT_ARCADE_HELP_BITSET, 0)
		SET_MP_INT_CHARACTER_STAT(MP_STAT_ARCADE_HELP_BITSETTWO, 0)
		SET_MP_INT_CHARACTER_AWARD(MP_AWARD_FACES_OF_DEATH,0)
		SET_MP_BOOL_CHARACTER_AWARD(MP_AWARD_TRAINED_TO_KILL, FALSE)
		SET_MP_BOOL_CHARACTER_AWARD(MP_AWARD_STRAIGHT_TO_VIDEO, FALSE)
		SET_MP_BOOL_CHARACTER_AWARD(MP_AWARD_MONKEY_C_MONKEY_DO, FALSE)
		SET_MP_BOOL_CHARACTER_AWARD(MP_AWARD_DIRECTOR, FALSE)
		SCRIPT_ASSERT("sCMHDZData.bClearAwardStats - Cleared all Awards")
		sCMHDZData.bClearAwardStats = FALSE
	ENDIF
	IF sCMHDZData.bDebugLaunchDynamite
		sCMHDZData.bDebugLaunchDynamite = FALSE
		CMHDZ_INIT_THROWN_ENEMY_PROJECTILE(CMHDZ_PROJECTILE_DYNAMITE, INIT_VECTOR_2D(cfBASE_SCREEN_WIDTH / 2.0, cfBASE_SCREEN_HEIGHT / 2.0))
	ENDIF
	
	IF sCMHDZData.bDebugClearDynamite
		sCMHDZData.bDebugClearDynamite = FALSE
		CMHDZ_RESET_ALL_ENEMY_THROWN_PROJECTLES()
	ENDIF
	
	IF sCMHDZData.bDebugSetPlayerProjectile
		sCMHDZData.sPlayerData[0].projectileType = INT_TO_ENUM(CMHDZ_PROJECTILE_TYPES, sCMHDZData.iDebugPlayerProjectileType)
		sCMHDZData.bDebugSetPlayerProjectile = FALSE
	ENDIF 
	
	IF sCMHDZData.bDebugLaunchPlayerProjectile
		sCMHDZData.bDebugLaunchPlayerProjectile = FALSE
		CMHDZ_INIT_THROWN_PLAYER_PROJECTILE(0, sCMHDZData.sPlayerData[0].projectileType, sCMHDZData.sPlayerData[0].vSpriteFinalReticlePos)
	ENDIF
	
	IF sCMHDZData.bDebugClearPlayerProjectile
		sCMHDZData.bDebugClearPlayerProjectile = FALSE
		CMHDZ_RESET_ALL_PLAYER_THROWN_PROJECTILES(0)
	ENDIF
	
	IF sCMHDZData.bDebugEnableQuadDamage
		CMHDZ_SET_PLAYER_BIT(CMHDZ_PLAYER_BIT_QUAD_DAMAGE)
		CMHDZ_START_AUDIO_SCENE(CMHDZ_AUDIO_SCENE_POWERUP_ACTIVE)
		sCMHDZData.sPlayerData[0].iQuadDamageTimer = GET_GAME_TIMER()
		sCMHDZData.bDebugEnableQuadDamage = FALSE
	ENDIF 
	
	VECTOR_2D vInitialPos
	VECTOR_2D vOffset
	IF sCMHDZData.bDebugEnablePickup
		IF sCMHDZData.iDebugPickupScreen != -1
			CMHDZ_GET_ITEM_INITIAL_POS_AND_OFFSET_FOR_SCREEN(CMHDZ_ITEM_HEALTH, sCMHDZData.iDebugPickupScreen, vInitialPos, vOffset)
			CMHDZ_DRAW_GAME_SPRITE(CMHDZ_SPRITE_ITEM_HEALTH,  vInitialPos, INIT_VECTOR_2D(cfCMHDZ_ITEM_HEALTH_WIDTH, cfCMHDZ_ITEM_HEALTH_HEIGHT), 0, sCMHDZData.rgbaSprite)
			
			CMHDZ_GET_ITEM_INITIAL_POS_AND_OFFSET_FOR_SCREEN(CMHDZ_ITEM_RIFLE_AMMO, sCMHDZData.iDebugPickupScreen, vInitialPos, vOffset)
			CMHDZ_DRAW_GAME_SPRITE(CMHDZ_SPRITE_ITEM_RIFLE_AMMO,  vInitialPos, INIT_VECTOR_2D(cfCMHDZ_SPRITE_HUD_PISTOL_AMMO_CLIP_WIDTH, cfCMHDZ_SPRITE_HUD_PISTOL_AMMO_CLIP_HEIGHT), 0, sCMHDZData.rgbaSprite)
			
			CMHDZ_GET_ITEM_INITIAL_POS_AND_OFFSET_FOR_SCREEN(CMHDZ_ITEM_SHOTGUN_AMMO, sCMHDZData.iDebugPickupScreen, vInitialPos, vOffset)
			CMHDZ_DRAW_GAME_SPRITE(CMHDZ_SPRITE_ITEM_SHOTGUN_AMMO,  vInitialPos, INIT_VECTOR_2D(cfCMHDZ_SPRITE_HUD_SHOTGUN_AMMO_CLIP_WIDTH, cfCMHDZ_SPRITE_HUD_SHOTGUN_AMMO_CLIP_HEIGHT), 0, sCMHDZData.rgbaSprite)
			
			CMHDZ_GET_ITEM_INITIAL_POS_AND_OFFSET_FOR_SCREEN(CMHDZ_ITEM_NAIL_GUN_AMMO, sCMHDZData.iDebugPickupScreen, vInitialPos, vOffset)
			CMHDZ_DRAW_GAME_SPRITE(CMHDZ_SPRITE_ITEM_MACHINE_GUN_AMMO,  vInitialPos, INIT_VECTOR_2D(cfCMHDZ_SPRITE_HUD_AMMO_WIDTH, cfCMHDZ_SPRITE_HUD_AMMO_HEIGHT), 0, sCMHDZData.rgbaSprite)
		ENDIF
	ELSE
		IF sCMHDZData.iDebugPickupScreen != -1
			sCMHDZData.iDebugPickupScreen = -1
		ENDIF
	ENDIF
//	sCMHDZData.fDebugStickX = GET_DISABLED_CONTROL_NORMAL(FRONTEND_CONTROL, INPUT_SCRIPT_RIGHT_AXIS_X)
//	sCMHDZData.fDebugStickY = GET_DISABLED_CONTROL_NORMAL(FRONTEND_CONTROL, INPUT_SCRIPT_RIGHT_AXIS_Y)
//	sCMHDZData.fDebugMouseX = GET_DISABLED_CONTROL_NORMAL(FRONTEND_CONTROL, INPUT_CURSOR_X)
//	sCMHDZData.fDebugMouseY = GET_DISABLED_CONTROL_NORMAL(FRONTEND_CONTROL, INPUT_CURSOR_Y)
	sCMHDZData.iStaggeredDebugCount++
	IF sCMHDZData.iStaggeredDebugCount >= ENUM_TO_INT(CMHDZ_MAX_LEVELS)
		sCMHDZData.iStaggeredDebugCount = 0
	ENDIF
	
	ARCADE_GAMES_POSTFX_WIDGET_UPDATE()
	
	VECTOR_2D rs, rc 
	RGBA_COLOUR_STRUCT rcol 
	
	IF (sCMHDZData.bDrawDebugRect)
		INIT_RGBA_STRUCT(rcol, 255, 255, 255, 64)
		
		IF (sCMHDZData.bDebugRectCenterMode = FALSE) 
			rs.x = sCMHDZData.vDebugRect[1].x - sCMHDZData.vDebugRect[0].x
			rs.y = sCMHDZData.vDebugRect[1].y - sCMHDZData.vDebugRect[0].y
			rc.x = sCMHDZData.vDebugRect[0].x + (rs.x / 2.0)
			rc.y = sCMHDZData.vDebugRect[0].y + (rs.y / 2.0)
			ARCADE_DRAW_PIXELSPACE_RECT(rc, rs, rcol)
		ELSE 
			ARCADE_DRAW_PIXELSPACE_RECT(sCMHDZData.vDebugRect[0], sCMHDZData.vDebugRect[1], rcol)
		ENDIF 
	ENDIF 
	
//	IF (CMHDZ_MAX_REPLAY_ENTRIES != 1)
//		CMHDZ_DEBUG_UPDATE_REPLAY_SYSTEM_WIDGET(sCMHDZData.sReplaySystem)
//	ENDIF
	
	ARCADE_GAMES_LEADERBOARD_WIDGET_UPDATE(sCMHDZData.sLbData, playerBd, cmhdzServerBd.sLeaderboard)
ENDPROC

/// PURPOSE:
///    Dumps the current state of the game to the logs
///    Automatically called when a bug is entered
PROC CMHDZ_DEBUG_DUMP_DATA_TO_LOGS()

	ARCADE_CABINET_DUMP_DATA_TO_CONSOLE()

	//CDEBUG2LN(DEBUG_MINIGAME, "[CMHDZ_ARCADE] [BAZ] {dsw} CMHDZ_DEBUG_DUMP_DATA_TO_LOGS - Dumping data...")
	
	//General
	//CDEBUG2LN(DEBUG_MINIGAME, "[CMHDZ_ARCADE] [BAZ] ----- GENERAL -----")
	//CDEBUG2LN(DEBUG_MINIGAME, "[CMHDZ_ARCADE] [BAZ] eClientState = ", CMHDZ_ARCADE_CLIENT_STATE_TO_STRING(sCMHDZData.eClientState))
	
	CMHDZ_DEBUG_OUTPUT_ALL_ENEMY_POSITIONS()
	
	CMHDZ_DEBUG_OUTPUT_ALL_PICKUP_POSITIONS()
	
ENDPROC

PROC CMHDZ_DEBUG_PROCESSING()

	CMHDZ_DEBUG_CREATE_WIDGETS()
	
	//If a bug is entered dump all data to the console.
	IF IS_KEYBOARD_KEY_PRESSED(KEY_SPACE)
	OR IS_KEYBOARD_KEY_PRESSED(KEY_RBRACKET)
		CMHDZ_DEBUG_DUMP_DATA_TO_LOGS()
	ENDIF
	
ENDPROC

#ENDIF

/// PURPOSE:
///    Run every frame before the client state machine is processed
PROC CMHDZ_PRE_UPDATE()
	
	IF sCMHDZData.eClientState >= CMHDZ_ARCADE_CLIENT_STATE_CLEANUP
		// Cleaning up, don't do anything
		EXIT
	ENDIF
	
	IF NOT IS_SKYSWOOP_AT_GROUND() 
	OR SHOULD_KICK_PLAYER_FROM_ANY_ARCADE_GAME()
		CMHDZ_SET_LOCAL_STATE(CMHDZ_ARCADE_CLIENT_STATE_CLEANUP)
		EXIT
	ENDIF
	
	ARCADE_GAMES_HELP_TEXT_PRE_UPDATE()
	
	ARCADE_GAMES_LEADERBOARD_PROCESS_EVENTS(sCMHDZData.sLbData, cmhdzServerBd.sLeaderboard, playerBd, cmhdzServerBd.bLeaderboardRecieved)
	
	ARCADE_GAMES_LEADERBOARD_LOAD(sCMHDZData.sLbData, CASINO_ARCADE_GAME_Camhedz, cmhdzServerBd.bLeaderboardRecieved)
	
	CMHDZ_UPDATE_ANIM_FRAMES()
	
	CMHDZ_UPDATE_SOUND_GLITCH_LEVEL()
	
	BOOL bIsPlaying = sCMHDZData.eClientState >= CMHDZ_ARCADE_CLIENT_STATE_INTRO
	
	INT i
	IF bIsPlaying
	
		//-- Construct an array of all the onscreen cover locations which enemy peds can use to hide behind
		//-- Peds can loop through this to see if there's any nearby cover.
		//-- Avoids having every enemy loop through every cover location, every frame.
		IF sCMHDZData.iStaggeredOnScreenViableCoverCount = 0
			sCMHDZData.iNumberOfViableOnScreenCoverPoints = 0
			
			REPEAT ciCMHDZ_MAX_COVER i
				IF sCMHDZData.iNumberOfViableOnScreenCoverPoints < ciCMHDZ_MAX_SUITABLE_HIDE_BEHIND_COVER
					IF CMHDZ_COVER_UTIL_IS_TYPE_SUITABLE_FOR_COVER(sCMHDZData.sCoverData[i].eType)
						IF CMHDZ_IS_COVER_ON_SCREEN(i, cfLEFT_SCREEN_LIMIT)
//							#IF IS_DEBUG_BUILD
//							//CDEBUG2LN(DEBUG_MINIGAME, "[CMHDZ_PRE_UPDATE] [CMHDZ_IS_COVER_SUITABLE_FOR_ENEMY_TO_USE] [dsw] ")
//							//CDEBUG2LN(DEBUG_MINIGAME, "[CMHDZ_PRE_UPDATE] [CMHDZ_IS_COVER_SUITABLE_FOR_ENEMY_TO_USE] [dsw] Adding cover ", i, " To viable cover locations. Type: ", CMHDZ_ASSET_TYPES_TO_STRING(sCMHDZData.sCoverData[i].eType), " Tot Viable: ", sCMHDZData.iNumberOfViableOnScreenCoverPoints + 1  )
//							#ENDIF
							sCMHDZData.iViableOnScreenEnemyCoverPoints[sCMHDZData.iNumberOfViableOnScreenCoverPoints] = i
							sCMHDZData.iNumberOfViableOnScreenCoverPoints++
							
						ENDIF
					ENDIF
				ENDIF
			ENDREPEAT
		ENDIF
	ENDIF
	ARCADE_CABINET_COMMON_EVERY_FRAME_PROCESSING(bIsPlaying)
	
	CMHDZ_SET_CURRENT_TIMESTEP()
	
ENDPROC
	
/// PURPOSE:
///    Run every frame after the client state machine is processed
PROC CMHDZ_POST_UPDATE()
	
	//Hide help text every frame unless this minigame wants to show some
	//See x:\gta5\script\dev_ng\shared\include\public\invade_persuade_main.sch IAP_SHOULD_ALLOW_HELP_TEXT_THIS_FRAME()
	
	IF NOT ARCADE_GAMES_HELP_TEXT_SHOULD_ALLOW_THIS_FRAME()
		HIDE_HELP_TEXT_THIS_FRAME()
	ENDIF
	
ENDPROC

/// PURPOSE:
///    Call every frame to run the minigame
PROC PROCESS_CMHDZ_ARCADE()
	
	CMHDZ_PRE_UPDATE()
	
	CMHDZ_PROCESS_CLIENT_STATE_MACHINE()
	
	CMHDZ_POST_UPDATE()
	
	#IF IS_DEBUG_BUILD
		CMHDZ_DEBUG_PROCESSING()
	#ENDIF	
ENDPROC