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

//-------------------------------------------------
// File: ggsm_arcade_main.sch
// Purpose: the game itself
//-------------------------------------------------

//-------------------------------------------------
// INCLUDES
//-------------------------------------------------
USING "ggsm_structs.sch"
USING "ggsm_maths.sch"
USING "ggsm_helpers.sch"
USING "ggsm_drawing.sch"
USING "ggsm_entity.sch"

//-------------------------------------------------
// SPECIAL WEAPON FUNCTIONS
//-------------------------------------------------

PROC GGSM_UPDATE_SPECIAL_WEAPON_DECOY(GGSM_SPWEAPON_DATA &data)	
	INT a
	VECTOR_2D vPos 
	
	SWITCH (data.eState)
		CASE GGSM_SPWEAPON_LAUNCH
			vPos = sGGSMData.sEntities[sGGSMData.iPlayerShipIndex].sWorld.vPosition
			GGSM_PLAYER_DECOY_INIT(sGGSMData.sEntities[sGGSMData.iPlayerShipIndex].sWorld.vPosition)
			data.fTimer = GGSM_DECOY_ACTIVE_TIME
			data.eState = GGSM_SPWEAPON_ACTIVE
			GGSM_PLAY_SOUND_FROM_POSITION(ARCADE_GAMES_SOUND_GGSM_ABIL_PLAYER_ACTIVATE_DECOY, vPos)
		BREAK 
		CASE GGSM_SPWEAPON_ACTIVE
			a = FLOOR((data.fTimer / GGSM_DECOY_ACTIVE_TIME) * 128.0)
			ARCADE_GAMES_SOUND_PLAY_LOOP(ARCADE_GAMES_SOUND_GGSM_ABIL_PLAYER_DECOY_LOOP)
			IF GGSM_DOES_PLAYER_DECOY_EXIST()
				GGSM_SET_PACKED_A_COLOR(sGGSMData.sEntities[sGGSMData.iPlayerDecoyIndex].iPackedColor, a)
			ELSE 
				data.eState = GGSM_SPWEAPON_COOLDOWN
				EXIT 
			ENDIF 
			
			IF (data.fTimer < 0)
				vPos = sGGSMData.sEntities[sGGSMData.iPlayerDecoyIndex].sWorld.vPosition
				ARCADE_GAMES_SOUND_STOP(ARCADE_GAMES_SOUND_GGSM_ABIL_PLAYER_DECOY_LOOP)
				GGSM_ENTITY_DESTROY(sGGSMData.sEntities[sGGSMData.iPlayerDecoyIndex])
				GGSM_PLAY_SOUND_FROM_POSITION(ARCADE_GAMES_SOUND_GGSM_ABIL_PLAYER_DEACTIVATE_DECOY, vPos)
				data.eState = GGSM_SPWEAPON_COOLDOWN
			ENDIF 
		BREAK 
		
		CASE GGSM_SPWEAPON_COOLDOWN
			IF GGSM_DOES_PLAYER_DECOY_EXIST()
				GGSM_ENTITY_DESTROY(sGGSMData.sEntities[sGGSMData.iPlayerDecoyIndex])
			ENDIF
			ARCADE_GAMES_SOUND_STOP(ARCADE_GAMES_SOUND_GGSM_ABIL_PLAYER_DECOY_LOOP)
			data.eState = GGSM_SPWEAPON_INACTIVE
		BREAK
	ENDSWITCH 
ENDPROC 

PROC GGSM_UPDATE_SPECIAL_WEAPON_NUKE(GGSM_SPWEAPON_DATA &data)	
	INT iDead 
	
	SWITCH (data.eState)
		CASE GGSM_SPWEAPON_LAUNCH
			GGSM_SET_PLAYER_INVUNERABLE()			
			GGSM_PLAY_SOUND(ARCADE_GAMES_SOUND_GGSM_ABIL_PLAYER_ACTIVATE_NUKE)
			data.eState = GGSM_SPWEAPON_DETONATE
		BREAK 
		CASE GGSM_SPWEAPON_DETONATE		
			GGSM_FADE_TO_WHITE(0.125)
			data.eState = GGSM_SPWEAPON_ACTIVE 
		BREAK 
		CASE GGSM_SPWEAPON_ACTIVE
			IF GGSM_IS_SCREEN_WHITED_OUT()
				iDead = GGSM_ENTITY_NUKE_ARRAY(sGGSMData.sEntities, FALSE)
				IF (iDead >= GGSM_KILLS_NEEDED_FOR_NUKE_TSHIRT)
					//GGSM_UNLOCK_PRIZE(GGSM_UNLOCK_TSHIRTS_GGSM_NUKE)
				ENDIF
				
				GGSM_RESET_PROJECTILE_ARRAY(sGGSMData.sProjectiles)
				data.eState = GGSM_SPWEAPON_COOLDOWN
				GGSM_FADE_FROM_WHITE()
			ENDIF 
		BREAK 
		CASE GGSM_SPWEAPON_COOLDOWN
			GGSM_FADE_FROM_WHITE()
			data.eState = GGSM_SPWEAPON_INACTIVE
		BREAK
	ENDSWITCH 
ENDPROC 

PROC GGSM_UPDATE_SPECIAL_WEAPON_REFLECT(GGSM_SPWEAPON_DATA &data)	
	INT a 
	 
	SWITCH (data.eState)
		CASE GGSM_SPWEAPON_LAUNCH
			GGSM_PLAYER_SHIELD_INIT(TRUE)
			SET_BITMASK_ENUM_AS_ENUM(sGGSMData.sEntities[sGGSMData.iPlayerShipIndex].eFlags, GGSM_ENTITY_BIT_REFLECT_BULLETS)
			data.fTimer = GGSM_REPLUSE_ACTIVE_TIME
			data.eState = GGSM_SPWEAPON_ACTIVE
			GGSM_PLAY_SOUND_FROM_POSITION(ARCADE_GAMES_SOUND_GGSM_ABIL_PLAYER_ACTIVATE_REPUSLE, sGGSMData.sEntities[sGGSMData.iPlayerShipIndex].sWorld.vPosition)
		BREAK 
		CASE GGSM_SPWEAPON_ACTIVE		
			a = FLOOR((data.fTimer / GGSM_REPLUSE_ACTIVE_TIME) * 255.0)
			
			IF GGSM_DOES_PLAYER_SHIELD_EXIST()
				GGSM_SET_PACKED_A_COLOR(sGGSMData.sEntities[sGGSMData.iPlayerShieldIndex].iPackedColor, a)
			ELSE 
				CLEAR_BITMASK_ENUM_AS_ENUM(sGGSMData.sEntities[sGGSMData.iPlayerShipIndex].eFlags, GGSM_ENTITY_BIT_REFLECT_BULLETS)
				data.eState = GGSM_SPWEAPON_COOLDOWN
				EXIT 
			ENDIF 
			
			IF (data.fTimer < 0) OR NOT GGSM_IS_PLAYER_SHIP_ALIVE()
				CLEAR_BITMASK_ENUM_AS_ENUM(sGGSMData.sEntities[sGGSMData.iPlayerShipIndex].eFlags, GGSM_ENTITY_BIT_REFLECT_BULLETS)
				GGSM_ENTITY_DESTROY(sGGSMData.sEntities[sGGSMData.iPlayerShieldIndex])
				data.eState = GGSM_SPWEAPON_COOLDOWN
			ENDIF 
		BREAK 
		
		CASE GGSM_SPWEAPON_COOLDOWN
			CLEAR_BITMASK_ENUM_AS_ENUM(sGGSMData.sEntities[sGGSMData.iPlayerShipIndex].eFlags, GGSM_ENTITY_BIT_REFLECT_BULLETS)
			GGSM_PLAY_SOUND_FROM_POSITION(ARCADE_GAMES_SOUND_GGSM_ABIL_PLAYER_DEACTIVATE_REPULSE, sGGSMData.sEntities[sGGSMData.iPlayerShipIndex].sWorld.vPosition)
			IF GGSM_DOES_PLAYER_SHIELD_EXIST()
				GGSM_ENTITY_DESTROY(sGGSMData.sEntities[sGGSMData.iPlayerShieldIndex])
			ENDIF 
			
			data.eState = GGSM_SPWEAPON_INACTIVE
		BREAK
	ENDSWITCH 
ENDPROC 

PROC GGSM_UPDATE_SPECIAL_WEAPON_SHIELD(GGSM_SPWEAPON_DATA &data)
	INT a 
	
	SWITCH (data.eState)
		CASE GGSM_SPWEAPON_LAUNCH
			GGSM_PLAYER_SHIELD_INIT(FALSE)
			CLEAR_BITMASK_ENUM_AS_ENUM(sGGSMData.sEntities[sGGSMData.iPlayerShipIndex].eFlags, GGSM_ENTITY_BIT_REFLECT_BULLETS)
			GGSM_PLAY_SOUND_FROM_POSITION(ARCADE_GAMES_SOUND_GGSM_ABIL_PLAYER_ACTIVATE_SHIELD, sGGSMData.sEntities[sGGSMData.iPlayerShipIndex].sWorld.vPosition)
			data.eState = GGSM_SPWEAPON_ACTIVE
		BREAK 
		CASE GGSM_SPWEAPON_ACTIVE
			IF GGSM_DOES_PLAYER_SHIELD_EXIST()
				a = FLOOR(GGSM_ENTITY_GET_HP_PERCENTAGE(sGGSMData.sEntities[sGGSMData.iPlayerShieldIndex]) * 255.0)
				GGSM_SET_PACKED_A_COLOR(sGGSMData.sEntities[sGGSMData.iPlayerShieldIndex].iPackedColor, a)
			ELSE  
				data.eState = GGSM_SPWEAPON_COOLDOWN
			ENDIF 
		BREAK 
		CASE GGSM_SPWEAPON_COOLDOWN
			IF GGSM_DOES_PLAYER_SHIELD_EXIST()
				GGSM_PLAY_SOUND_FROM_POSITION(ARCADE_GAMES_SOUND_GGSM_ABIL_PLAYER_DEACTIVATE_SHIELD, sGGSMData.sEntities[sGGSMData.iPlayerShipIndex].sWorld.vPosition)
				GGSM_ENTITY_DESTROY(sGGSMData.sEntities[sGGSMData.iPlayerShieldIndex])
			ENDIF 
			
			data.eState = GGSM_SPWEAPON_INACTIVE
		BREAK
	ENDSWITCH 
ENDPROC 

PROC GGSM_UPDATE_SPECIAL_WEAPON_TEMPORAL(GGSM_SPWEAPON_DATA &data)
	SWITCH (data.eState)
		CASE GGSM_SPWEAPON_LAUNCH
			data.fTimer = GGSM_TEMPORAL_ACTIVE_TIME
			data.eState = GGSM_SPWEAPON_ACTIVE
			GGSM_PLAY_SOUND(ARCADE_GAMES_SOUND_GGSM_ABIL_PLAYER_ACTIVATE_STUN)
		BREAK 
		CASE GGSM_SPWEAPON_ACTIVE
			sGGSMData.fTimeScale -= (GET_FRAME_TIME() / 2.0)
			IF (sGGSMData.fTimeScale < GGSM_TEMPORAL_TIME_SCALE)
				sGGSMData.fTimeScale = GGSM_TEMPORAL_TIME_SCALE
			ENDIF 
			
			IF (data.fTimer < 0.0) OR NOT GGSM_IS_PLAYER_SHIP_ALIVE()
				GGSM_PLAY_SOUND(ARCADE_GAMES_SOUND_GGSM_ABIL_PLAYER_DEACTIVATE_STUN)
				data.eState = GGSM_SPWEAPON_COOLDOWN
			ENDIF 
		BREAK 
		CASE GGSM_SPWEAPON_COOLDOWN
			sGGSMData.fTimeScale += (GET_FRAME_TIME() / 2.0)
			IF (sGGSMData.fTimeScale >= 1.0)
				sGGSMData.fTimeScale = 1.0			
				data.eState = GGSM_SPWEAPON_INACTIVE
			ENDIF 
		BREAK 
	ENDSWITCH 
ENDPROC

FUNC BOOL GGSM_GET_FREE_SPECIAL_WEAPON_SLOT(GGSM_SPWEAPON_DATA &array[], INT &ind)
	INT i
	
	REPEAT COUNT_OF(array) i
		IF (array[i].eState = GGSM_SPWEAPON_INACTIVE)
			ind = i
			RETURN TRUE 
		ENDIF 
	ENDREPEAT
	
	RETURN FALSE 
ENDFUNC 

FUNC BOOL GGSM_DEPLOY_SPECIAL_WEAPON(GGSM_SPECIAL_WEAPON_TYPE eType)
	INT ind 
	
	IF NOT GGSM_GET_FREE_SPECIAL_WEAPON_SLOT(sGGSMData.sSpWeaponData, ind)
		RETURN FALSE 
	ENDIF 
	
	sGGSMData.sSpWeaponData[ind].eType = eType
	sGGSMData.sSpWeaponData[ind].eState = GGSM_SPWEAPON_LAUNCH
	RETURN TRUE 
ENDFUNC 

PROC GGSM_UPDATE_SPECIAL_WEAPON(GGSM_SPWEAPON_DATA &spr)
	IF (spr.eType = GGSM_SPECIAL_WEAPON_NONE)
		EXIT 
	ENDIF 
	
	IF (spr.fTimer > 0.0)
		spr.fTimer -= GET_FRAME_TIME()
	ENDIF 
	
	SWITCH (spr.eType)
		CASE GGSM_SPECIAL_WEAPON_DECOY
			GGSM_UPDATE_SPECIAL_WEAPON_DECOY(spr)
		BREAK 		
		CASE GGSM_SPECIAL_WEAPON_NUKE
			GGSM_UPDATE_SPECIAL_WEAPON_NUKE(spr)
		BREAK 
		CASE GGSM_SPECIAL_WEAPON_REFLECT
			GGSM_UPDATE_SPECIAL_WEAPON_REFLECT(spr)
		BREAK
		CASE GGSM_SPECIAL_WEAPON_SHIELD
			GGSM_UPDATE_SPECIAL_WEAPON_SHIELD(spr)
		BREAK 	
		CASE GGSM_SPECIAL_WEAPON_TEMPORAL
			GGSM_UPDATE_SPECIAL_WEAPON_TEMPORAL(spr)
		BREAK 	
	ENDSWITCH 
ENDPROC 

PROC GGSM_UPDATE_SPECIAL_WEAPON_ARRAY(GGSM_SPWEAPON_DATA &array[])
	INT i
	
	REPEAT COUNT_OF(array) i
		GGSM_UPDATE_SPECIAL_WEAPON(array[i]) 
	ENDREPEAT
ENDPROC 

//-------------------------------------------------
// POWER UP FUNCTIONS
//-------------------------------------------------
PROC GGSM_SET_WEAPON_IN_SLOT(GGSM_SPRITE_TYPE eType, INT iSlot)

	// handle help
	IF (iSlot = GGSM_WEAPON_SLOT_SPECIAL) AND NOT IS_BITMASK_ENUM_AS_ENUM_SET(sGGSMData.eHelpFlags, GGSM_HELP_BIT_SPECIAL)
		IF GGSM_SHOULD_SHOW_TUTORIAL(GGSM_HELP_BIT_SPECIAL)
			ARCADE_GAMES_HELP_TEXT_PRINT(ARCADE_GAMES_HELP_TEXT_ENUM_GGSM_SPECIALWPN)
		ENDIF 
		SET_BITMASK_ENUM_AS_ENUM(sGGSMData.eHelpFlags, GGSM_HELP_BIT_SPECIAL)
	ENDIF 
	
	IF (iSlot = GGSM_WEAPON_SLOT_DEFENSE) AND NOT IS_BITMASK_ENUM_AS_ENUM_SET(sGGSMData.eHelpFlags, GGSM_HELP_BIT_DEFENSE)
		IF GGSM_SHOULD_SHOW_TUTORIAL(GGSM_HELP_BIT_DEFENSE)
			ARCADE_GAMES_HELP_TEXT_PRINT(ARCADE_GAMES_HELP_TEXT_ENUM_GGSM_DEFENSEWPN)
		ENDIF
		
		SET_BITMASK_ENUM_AS_ENUM(sGGSMData.eHelpFlags, GGSM_HELP_BIT_DEFENSE)
	ENDIF 
	
	sGGSMData.eWeaponSlot[iSlot] = eType
ENDPROC 

PROC GGSM_USE_WEAPON_IN_SLOT(INT iSlot)
	INT iSlotCheck 
	
	IF NOT GGSM_GET_FREE_SPECIAL_WEAPON_SLOT(sGGSMData.sSpWeaponData, iSlotCheck)
		EXIT 
	ENDIF 
		
	SWITCH (sGGSMData.eWeaponSlot[iSlot])
		CASE GGSM_SPRITE_POWER_UP_STUN
			GGSM_DEPLOY_SPECIAL_WEAPON(GGSM_SPECIAL_WEAPON_TEMPORAL)
		BREAK 
		
		CASE GGSM_SPRITE_POWER_UP_NUKE
			GGSM_DEPLOY_SPECIAL_WEAPON(GGSM_SPECIAL_WEAPON_NUKE)
		BREAK 
		
		CASE GGSM_SPRITE_POWER_UP_DECOY
			GGSM_DEPLOY_SPECIAL_WEAPON(GGSM_SPECIAL_WEAPON_DECOY)
		BREAK
		
		CASE GGSM_SPRITE_POWER_UP_SHIELD
			GGSM_DEPLOY_SPECIAL_WEAPON(GGSM_SPECIAL_WEAPON_SHIELD)
		BREAK
	
		CASE GGSM_SPRITE_POWER_UP_REPULSE
			GGSM_DEPLOY_SPECIAL_WEAPON(GGSM_SPECIAL_WEAPON_REFLECT)
		BREAK
	ENDSWITCH 
	
	sGGSMData.eWeaponSlot[iSlot] = GGSM_SPRITE_NONE
ENDPROC 

PROC GGSM_APPLY_POWER_UP(GGSM_POWER_UP &pType)
	IF NOT GGSM_DOES_PLAYER_SHIP_EXIST()
		EXIT 
	ENDIF 
	
	VECTOR_2D vShipPos = sGGSMData.sEntities[sGGSMData.iPlayerShipIndex].sWorld.vPosition
	
	SWITCH (pType.eType)
		CASE GGSM_SPRITE_POWER_UP_DUALARCH
			GGSM_ENTITY_SET_WEAPON(sGGSMData.sEntities[sGGSMData.iPlayerShipIndex], GGSM_WEAPON_PLYRDUALARCH)
			GGSM_PLAY_SOUND_FROM_POSITION(ARCADE_GAMES_SOUND_GGSM_PICKUP_DOUBLE, vShipPos)
			GGSM_PLAY_SOUND_FROM_POSITION(ARCADE_GAMES_SOUND_GGSM_MONKEY_VOICE_COLLECT_POWERUP, vShipPos)
		BREAK 	 
		
		CASE GGSM_SPRITE_POWER_UP_FORWARD_BACK
			GGSM_ENTITY_SET_WEAPON(sGGSMData.sEntities[sGGSMData.iPlayerShipIndex], GGSM_WEAPON_PLYRBACKVULCAN)
			GGSM_PLAY_SOUND_FROM_POSITION(ARCADE_GAMES_SOUND_GGSM_PICKUP_BOLT, vShipPos)
			GGSM_PLAY_SOUND_FROM_POSITION(ARCADE_GAMES_SOUND_GGSM_MONKEY_VOICE_COLLECT_POWERUP, vShipPos)
		BREAK 	 
		
		CASE GGSM_SPRITE_POWER_UP_DECOY
			GGSM_SET_WEAPON_IN_SLOT(GGSM_SPRITE_POWER_UP_DECOY, GGSM_WEAPON_SLOT_DEFENSE)
			GGSM_PLAY_SOUND_FROM_POSITION(ARCADE_GAMES_SOUND_GGSM_PICKUP_DECOY, vShipPos)
			GGSM_PLAY_SOUND_FROM_POSITION(ARCADE_GAMES_SOUND_GGSM_MONKEY_VOICE_COLLECT_POWERUP, vShipPos)
		BREAK 	
		
		CASE GGSM_SPRITE_POWER_UP_EXPLOSION
			GGSM_ENTITY_SET_WEAPON(sGGSMData.sEntities[sGGSMData.iPlayerShipIndex], GGSM_WEAPON_PLYREXPSHELL)
			GGSM_PLAY_SOUND_FROM_POSITION(ARCADE_GAMES_SOUND_GGSM_PICKUP_EXPLOSION, vShipPos)
			GGSM_PLAY_SOUND_FROM_POSITION(ARCADE_GAMES_SOUND_GGSM_MONKEY_VOICE_COLLECT_POWERUP, vShipPos)
		BREAK 	 
		
		CASE GGSM_SPRITE_POWER_UP_EXTRALIFE
			GGSM_GIVE_EXTRA_LIFE()
		BREAK 
		
		CASE GGSM_SPRITE_POWER_UP_HEALTH
			GGSM_PLAY_SOUND_FROM_POSITION(ARCADE_GAMES_SOUND_GGSM_MONKEY_VOICE_COLLECT_POWERUP, vShipPos)
			GGSM_PLAY_SOUND_FROM_POSITION(ARCADE_GAMES_SOUND_GGSM_PICKUP_HEALTH, vShipPos)
				
			IF GGSM_ENTITY_IS_AT_FULL_HEALTH(sGGSMData.sEntities[sGGSMData.iPlayerShipIndex])
				GGSM_INCREASE_PLAYER_SCORE(GGSM_POINTS_FOR_FULL_HEALTH)
			ELSE 
				GGSM_ENTITY_RESET_HEALTH(sGGSMData.sEntities[sGGSMData.iPlayerShipIndex])
			ENDIF 
		BREAK 
		
		CASE GGSM_SPRITE_POWER_UP_NUKE	
			GGSM_SET_WEAPON_IN_SLOT(GGSM_SPRITE_POWER_UP_NUKE, GGSM_WEAPON_SLOT_SPECIAL)
			GGSM_PLAY_SOUND_FROM_POSITION(ARCADE_GAMES_SOUND_GGSM_PICKUP_NUKE, vShipPos)
			GGSM_PLAY_SOUND_FROM_POSITION(ARCADE_GAMES_SOUND_GGSM_MONKEY_VOICE_COLLECT_POWERUP, vShipPos)
		BREAK 	
		
		CASE GGSM_SPRITE_POWER_UP_REPULSE
			GGSM_SET_WEAPON_IN_SLOT(GGSM_SPRITE_POWER_UP_REPULSE, GGSM_WEAPON_SLOT_DEFENSE)
			GGSM_PLAY_SOUND_FROM_POSITION(ARCADE_GAMES_SOUND_GGSM_PICKUP_REPULSE, vShipPos)
			GGSM_PLAY_SOUND_FROM_POSITION(ARCADE_GAMES_SOUND_GGSM_MONKEY_VOICE_COLLECT_POWERUP, vShipPos)
		BREAK 	
		
		CASE GGSM_SPRITE_POWER_UP_ROCKET
			GGSM_ENTITY_SET_WEAPON(sGGSMData.sEntities[sGGSMData.iPlayerShipIndex], GGSM_WEAPON_PLYRHOMINGROCKET)
			GGSM_PLAY_SOUND_FROM_POSITION(ARCADE_GAMES_SOUND_GGSM_PICKUP_ROCKET, vShipPos)
			GGSM_PLAY_SOUND_FROM_POSITION(ARCADE_GAMES_SOUND_GGSM_MONKEY_VOICE_COLLECT_POWERUP, vShipPos)
		BREAK 		
		
		CASE GGSM_SPRITE_POWER_UP_SCATTER
			GGSM_ENTITY_SET_WEAPON(sGGSMData.sEntities[sGGSMData.iPlayerShipIndex], GGSM_WEAPON_PLYRSCATTER)
			GGSM_PLAY_SOUND_FROM_POSITION(ARCADE_GAMES_SOUND_GGSM_PICKUP_SCATTER, vShipPos)
			GGSM_PLAY_SOUND_FROM_POSITION(ARCADE_GAMES_SOUND_GGSM_MONKEY_VOICE_COLLECT_POWERUP, vShipPos)
		BREAK 	
		
		CASE GGSM_SPRITE_POWER_UP_SHIELD
			GGSM_SET_WEAPON_IN_SLOT(GGSM_SPRITE_POWER_UP_SHIELD, GGSM_WEAPON_SLOT_DEFENSE)
			GGSM_PLAY_SOUND_FROM_POSITION(ARCADE_GAMES_SOUND_GGSM_PICKUP_SHIELD, vShipPos)
			GGSM_PLAY_SOUND_FROM_POSITION(ARCADE_GAMES_SOUND_GGSM_MONKEY_VOICE_COLLECT_POWERUP, vShipPos)
		BREAK 	
		
		CASE GGSM_SPRITE_POWER_UP_STUN
			GGSM_SET_WEAPON_IN_SLOT(GGSM_SPRITE_POWER_UP_STUN, GGSM_WEAPON_SLOT_SPECIAL)
			GGSM_PLAY_SOUND_FROM_POSITION(ARCADE_GAMES_SOUND_GGSM_PICKUP_STUN, vShipPos)
			GGSM_PLAY_SOUND_FROM_POSITION(ARCADE_GAMES_SOUND_GGSM_MONKEY_VOICE_COLLECT_POWERUP, vShipPos)
		BREAK 	
		
		CASE GGSM_SPRITE_POWER_UP_WAVE
			GGSM_ENTITY_SET_WEAPON(sGGSMData.sEntities[sGGSMData.iPlayerShipIndex], GGSM_WEAPON_PLYRWAVEBLASTER)
			GGSM_PLAY_SOUND_FROM_POSITION(ARCADE_GAMES_SOUND_GGSM_PICKUP_WAVE, vShipPos)
			GGSM_PLAY_SOUND_FROM_POSITION(ARCADE_GAMES_SOUND_GGSM_MONKEY_VOICE_COLLECT_POWERUP, vShipPos)
		BREAK 	
	ENDSWITCH 
	
	GGSM_INCREASE_PLAYER_SCORE(100)
	sGGSMData.sGameStats.powerUps ++
	
	CDEBUG1LN(DEBUG_MINIGAME, "GGSM_APPLY_POWER_UP - TYPE:", GGSM_GET_SPRITE_NAME(pType.eType))
	pType.eType = GGSM_SPRITE_NONE
ENDPROC 

PROC GGSM_UPDATE_POWER_UP(GGSM_POWER_UP &pType)
	VECTOR_2D vPos
	VECTOR_2D vSize 
	FLOAT fDistSq
	
	IF (pType.eType = GGSM_SPRITE_NONE)
		EXIT 
	ENDIF 
	
	#IF IS_DEBUG_BUILD
		IF (sGGSMData.bDebugNoPowerUps)
			pType.eType = GGSM_SPRITE_NONE
			EXIT 
		ENDIF 
	#ENDIF
	
	// move power up
	vPos = GGSM_UNPACK_VECTOR_2D(pType.iPackedPosition)
	
	vSize = GGSM_GET_SPRITE_SIZE(GGSM_SPRITE_POWER_UP_BEAM)
	vPos.x -= GGSM_POWER_UP_SPEED * sGGSMData.fTimeScale * sGGSMData.fDeltaTime
	IF (vPos.x < 1500.0)
		IF NOT GGSM_IS_POINT_ON_SCREEN(vPos, vSize)
			CDEBUG1LN(DEBUG_MINIGAME, "GGSM_UPDATE_POWER_UP - TYPE:", GGSM_GET_SPRITE_NAME(pType.eType), " OFF SCREEN")
			pType.eType = GGSM_SPRITE_NONE
			EXIT 
		ENDIF 
	ENDIF 
	
	IF NOT GGSM_IS_PLAYER_SHIP_ALIVE()
		EXIT 
	ENDIF 
	
	// handle power up collision
	pType.iPackedPosition = GGSM_PACK_VECTOR_2D_TO_INT(vPos)
	fDistSq = VECTOR_2D_DIST2(sGGSMData.sEntities[sGGSMData.iPlayerShipIndex].sCollider.sAABB.vCenter, vPos)
	
	IF (fDistSq <= (500.0 * 500.0))
		IF GGSM_SHOULD_SHOW_TUTORIAL(GGSM_HELP_BIT_POWERUP)
			ARCADE_GAMES_HELP_TEXT_CLEAR()
			ARCADE_GAMES_HELP_TEXT_PRINT(ARCADE_GAMES_HELP_TEXT_ENUM_GGSM_COLLECTPOWERUP)
		ENDIF 
		SET_BITMASK_ENUM_AS_ENUM(sGGSMData.eHelpFlags, GGSM_HELP_BIT_POWERUP)
	ENDIF 
	
	IF (fDistSq <= (vSize.x * vSize.x))
		SET_BITMASK_ENUM_AS_ENUM(sGGSMData.eHelpFlags, GGSM_HELP_BIT_POWERUP)
		GGSM_APPLY_POWER_UP(pType)
		sGGSMData.bPowerUpCollected = TRUE
	ENDIF 
ENDPROC

PROC GGSM_UPDATE_POWER_UP_ARRAY(GGSM_POWER_UP &pArray[])
	INT i
	
	REPEAT COUNT_OF(pArray) i
		GGSM_UPDATE_POWER_UP(pArray[i])
	ENDREPEAT 
ENDPROC 

//-------------------------------------------------
// ENEMY SPAWNER
//-------------------------------------------------	

PROC GGSM_RESET_ENEMY_SPAWNER()
	sGGSMData.iSpawnIndexCounter = 0
	sGGSMData.iEnemiesCreated = 0
	sGGSMData.iEnemiesDestroyed = 0
	sGGSMData.fChainMultiplier = 0.0
ENDPROC 

PROC GGSM_UPDATE_ENEMY_SPAWNER()
	INT iGroupID = -1
	 
	#IF IS_DEBUG_BUILD
		IF (sGGSMData.bDebugDisableEnemySpawn)
			EXIT 
		ENDIF
	#ENDIF
	
	// update spawner
	IF (sGGSMData.iSpawnIndexCounter >= GGSM_MAX_SPAWN_DATA)
		EXIT 
	ENDIF 
	
	GGSM_FORMATION_DATA data = sGGSMData.sSpawnData[sGGSMData.iSpawnIndexCounter]
	
	IF (sGGSMData.sCamera.fDistTravelled < data.fScrollDistance) OR (data.fScrollDistance <= 0.0)
		EXIT 
	ENDIF 
	
	iGroupID = GGSM_GET_FREE_ENTITY_GROUP(sGGSMData.sEntityGroup)
	IF (iGroupID = -1)
		CPRINTLN(DEBUG_MINIGAME, "GGSM_UPDATE_ENEMY_SPAWNER - CAN'T GET FREE GROUP")
		EXIT 
	ENDIF 
	
	GGSM_ACTIVATE_ENTITY_GROUP_AS_FORMATION(sGGSMData.sEntityGroup[iGroupID], data)
	sGGSMData.iSpawnIndexCounter ++
ENDPROC 

PROC GGSM_RESET_FOR_STAGE_START(BOOL bResetStageData = TRUE, FLOAT fSkipDist = 0.0) 
	CPRINTLN(DEBUG_MINIGAME, "GGSM_RESET_FOR_STAGE_START - Reset Stage Data:", GET_STRING_FROM_BOOL(bResetStageData))
	GGSM_RESET_ENTITY_ARRAY(sGGSMData.sEntities)
	GGSM_RESET_PROJECTILE_ARRAY(sGGSMData.sProjectiles)
	GGSM_RESET_ENTITY_DEPTHSORT_ARRAY()
	GGSM_DIALOG_CONTROLLER_SET_STATE(sGGSMData.sDialogController, GGSM_DIALOG_STATE_NONE)
	GGSM_RESET_ENTITY_GROUP_ARRAY(sGGSMData.sEntityGroup)
	GGSM_RESET_FXSPRITE_ARRAY(sGGSMData.sFXSprite)
	GGSM_RESET_POWER_UP_ARRAY(sGGSMData.sPowerUp)
	GGSM_RESET_SPECIAL_WEAPONS_ARRAY(sGGSMData.sSpWeaponData)
	GGSM_RESET_BOSS_CONTROLLER_ARRAY(sGGSMData.sBossController)
	
	GGSM_RESET_ENEMY_SPAWNER()
	GGSM_CAMERA_RESET(sGGSMData.sCamera)
	GGSM_BGSCROLLER_RESET(sGGSMData.sBGScroller, sGGSMData.sGameStats.level)
	
	sGGSMData.iSpawnIndexCounter = 0
	IF (bResetStageData)
		GGSM_GET_STAGE_FORMATION_DATA_ARRAY(sGGSMData.sSpawnData, sGGSMData.sGameStats.level)
		GGSM_GET_STAGE_TILE_MAP(sGGSMData.sTileMap, sGGSMData.sGameStats.level)
	ENDIF 
	
	sGGSMData.iPlayerDecoyIndex = GGSM_INVALID_ENTITY
	sGGSMData.iPlayerShieldIndex = GGSM_INVALID_ENTITY
	sGGSMData.iPlayerShipIndex = GGSM_INVALID_ENTITY
	
	sGGSMData.eStageFlags = GGSM_STAGE_BIT_NONE
	sGGSMData.iEntitiesActive = 0
	sGGSMData.iProjectilesActive = 0
	sGGSMData.iSectorBonus = 0
	sGGSMData.iTakedownBonus = 0
	sGGSMData.iNoMissBonus = GGSM_NO_MISS_CLEAR_BONUS
	sGGSMData.iNoDamageBonus = GGSM_NO_DAMAGE_CLEAR_BONUS
	sGGSMData.fChainMultiplier = 0.0
	
	sGGSMData.iGraze = 0
	sGGSMData.fGrazeTimer = 0.0
	
	GGSM_CAMERA_JUMP_TO_DISTANCE(sGGSMData.sCamera, fSkipDist)
	sGGSMData.iSpawnIndexCounter = 0
	CPRINTLN(DEBUG_MINIGAME, "GGSM_RESET_FOR_STAGE_START - Spawn Used:", sGGSMData.iSpawnsUsed)
ENDPROC 

PROC GGSM_RESET_FOR_GAME_START()
	INT i
	
	GGSM_RESET_GAME_STATS()
	sGGSMData.iPlayerLives = 3
	sGGSMData.iExtendPtsCounter = 0
	sGGSMData.iMaxEntitiesActive = 0
	sGGSMData.iMaxGroupsActive = 0
	sGGSMData.iMaxProjectilesActive = 0
	sGGSMData.bPowerUpCollected = FALSE
	
	REPEAT COUNT_OF(sGGSMData.eWeaponSlot) i
		sGGSMData.eWeaponSlot[i] = GGSM_SPRITE_NONE
	ENDREPEAT		
ENDPROC 

PROC GGSM_PROCESS_PLAYER_VS_ENEMY_COLLISIONS()
	INT cnt 
	
	IF (sGGSMData.iPlayerShipIndex = GGSM_INVALID_ENTITY)
		EXIT 
	ENDIF 
	
	IF NOT GGSM_ENTITY_HAS_COLLISION(sGGSMData.sEntities[sGGSMData.iPlayerShipIndex])
		EXIT 
	ENDIF 
			
	REPEAT COUNT_OF(sGGSMData.sEntities) cnt
		IF NOT GGSM_ENTITY_CAN_COLLIDE_WITH(sGGSMData.sEntities[sGGSMData.iPlayerShipIndex], sGGSMData.sEntities[cnt])
			RELOOP
		ENDIF 
		
		IF GGSM_DOES_PLAYER_SHIELD_EXIST()
			IF GGSM_COLLIDER_INTERSECT(sGGSMData.sEntities[cnt].sCollider, sGGSMData.sEntities[sGGSMData.iPlayerShieldIndex].sCollider)
				GGSM_ENTITY_DAMAGE(sGGSMData.sEntities[sGGSMData.iPlayerShieldIndex], 9999)
				sGGSMData.sEntities[sGGSMData.iPlayerShipIndex].iInvTimeMS = GET_GAME_TIMER() + 1000
				
				EXIT
			ENDIF
		ENDIF 
		
		IF GGSM_COLLIDER_INTERSECT(sGGSMData.sEntities[cnt].sCollider, sGGSMData.sEntities[sGGSMData.iPlayerShipIndex].sCollider)
			IF GGSM_ENTITY_DAMAGE(sGGSMData.sEntities[sGGSMData.iPlayerShipIndex], GGSM_PLAYER_DAMAGE_PER_ENEMY_COLLISION)
				cnt = COUNT_OF(sGGSMData.sEntities) + 1
			ELSE
				RELOOP
			ENDIF
		ENDIF
	ENDREPEAT
ENDPROC 

PROC GGSM_PROCESS_ENTITY_VS_PROJECTILE_COLLISIONS(GGSM_ENTITY &entArray[], GGSM_PROJECTILE &projArray[])
	INT ind, cnt  
	BOOL bHasReflectCapability 
	
	// player bullets vs enemies
	REPEAT COUNT_OF(entArray) cnt
		IF NOT GGSM_ENTITY_HAS_COLLISION(entArray[cnt])
			RELOOP 
		ENDIF 
		
		bHasReflectCapability = IS_BITMASK_ENUM_AS_ENUM_SET(entArray[cnt].eFlags, GGSM_ENTITY_BIT_REFLECT_BULLETS)
		
		REPEAT COUNT_OF(projArray) ind 
			IF NOT GGSM_ENTITY_CAN_COLLIDE_WITH_PROJECTILE(entArray[cnt], projArray[ind])
				RELOOP
			ENDIF			

			IF GGSM_COLLIDER_INTERSECT(projArray[ind].sCollider, entArray[cnt].sCollider)
				IF (bHasReflectCapability)
					GGSM_REFLECT_PROJECTILE(projArray[ind])
					RELOOP 
				ENDIF 
				
				GGSM_PROJECTILE_TAKE_DAMAGE(projArray[ind])
				
				IF GGSM_ENTITY_DAMAGE(entArray[cnt])
					ind = COUNT_OF(projArray) + 1
				ELSE
					RELOOP
				ENDIF
			ENDIF
		ENDREPEAT 		
	ENDREPEAT
ENDPROC

PROC GGSM_PROCESS_PROJECTILE_VS_BACKGROUND_COLLISIONS(GGSM_PROJECTILE &projArray[])
	INT ind

	IF (sGGSMData.sTileMap.iMapWidth = 0) OR (sGGSMData.sTileMap.iMapHeight = 0)
		EXIT 
	ENDIF 
	
	REPEAT COUNT_OF(projArray) ind 
		IF NOT GGSM_PROJECTILE_HAS_COLLISION(projArray[ind])
			RELOOP 
		ENDIF			
		
		IF GGSM_IS_SCREEN_POSITION_COLLIDED_WITH_TILE_MAP(projArray[ind].sCollider.sData.vCollisionVectors[0])
			GGSM_PROJECTILE_TAKE_DAMAGE(projArray[ind])
			RELOOP	
		ENDIF 
		
		IF (projArray[ind].sCollider.sData.eType = GGSM_COLLISION_CAPSULE)
			IF GGSM_IS_SCREEN_POSITION_COLLIDED_WITH_TILE_MAP(projArray[ind].sCollider.sData.vCollisionVectors[1])
				GGSM_PROJECTILE_TAKE_DAMAGE(projArray[ind])
				RELOOP	
			ENDIF 
		ENDIF
	ENDREPEAT 		
ENDPROC

PROC GGSM_PROCESS_PLAYER_VS_BACKGROUND_COLLISIONS()

	IF (sGGSMData.sTileMap.iMapWidth = 0) OR (sGGSMData.sTileMap.iMapHeight = 0)
		EXIT 
	ENDIF 
	
	IF (sGGSMData.iPlayerShipIndex = GGSM_INVALID_ENTITY)
		EXIT 
	ENDIF 
	
	IF NOT GGSM_ENTITY_HAS_COLLISION(sGGSMData.sEntities[sGGSMData.iPlayerShipIndex])
		EXIT 
	ENDIF 
	
	INT i
	VECTOR_2D vPos 
	VECTOR_2D vCollidePoints[GGSM_MAX_ENTITY_BG_COLLISIONPOINTS]
	
	vCollidePoints[0] = INIT_VECTOR_2D(0.0, -30.0)
	vCollidePoints[1] = INIT_VECTOR_2D(35.0, 0.0)
	vCollidePoints[2] = INIT_VECTOR_2D(0.0, 35.0)
	vCollidePoints[3] = INIT_VECTOR_2D(-31.0, 0.0)
	
	REPEAT GGSM_MAX_ENTITY_BG_COLLISIONPOINTS i
		vPos = ADD_VECTOR_2D(sGGSMData.sEntities[sGGSMData.iPlayerShipIndex].sCollider.sAABB.vCenter, vCollidePoints[i])
		IF GGSM_IS_SCREEN_POSITION_COLLIDED_WITH_TILE_MAP(vPos)
			
			IF GGSM_DOES_PLAYER_SHIELD_EXIST()
				GGSM_ENTITY_DAMAGE(sGGSMData.sEntities[sGGSMData.iPlayerShieldIndex], 9999)
				sGGSMData.sEntities[sGGSMData.iPlayerShipIndex].iInvTimeMS = GET_GAME_TIMER() + 1000
				EXIT
			ENDIF
			
			GGSM_ENTITY_DAMAGE(sGGSMData.sEntities[sGGSMData.iPlayerShipIndex], 9999)
			EXIT 	
		ENDIF
	ENDREPEAT 
ENDPROC

PROC GGSM_UPDATE_MAIN_GAME()
	INT i
	
	IF (sGGSMData.bGamePaused)
		EXIT 
	ENDIF 
	
	IF GGSM_IS_DIALOG_ACTIVE()
		GGSM_SET_PLAYER_INVUNERABLE()
		EXIT 
	ENDIF 
	
	CLEAR_BITMASK_ENUM_AS_ENUM(sGGSMData.eStageFlags, GGSM_STAGE_BIT_ENEMIES_ACTIVE | GGSM_STAGE_BIT_PLAYER_PROJECTILES_ACTIVE | GGSM_STAGE_BIT_BOSSES_ACTIVE | GGSM_STAGE_BIT_ENEMY_PROJECTILES_ACTIVE | GGSM_STAGE_BIT_GROUPS_ACTIVE)
	
	IF IS_BITMASK_ENUM_AS_ENUM_SET(sGGSMData.eStageFlags, GGSM_STAGE_BIT_PLAYER_BOSS_INVUNERABLE)
		GGSM_SET_PLAYER_INVUNERABLE()
	ENDIF 
		
	IF (sGGSMData.fKillStreakTimer > 0.0)
		sGGSMData.fKillStreakTimer -= GET_FRAME_TIME()
		IF (sGGSMData.fKillStreakTimer <= 0.0)
			sGGSMData.fKillStreakTimer = 0.0
			sGGSMData.iKillStreak = 0
		ENDIF 
	ENDIF 
	
	IF (sGGSMData.iPlayerLives > 0) AND NOT GGSM_DOES_PLAYER_SHIP_EXIST()
		GGSM_PLAYER_SHIP_INIT(INIT_VECTOR_2D(600.0, 540.0))
	ENDIF 
	
	GGSM_UPDATE_ENEMY_SPAWNER()
	
	sGGSMData.iGroupsActive = 0
	REPEAT COUNT_OF(sGGSMData.sEntityGroup) i
		GGSM_ENTITY_GROUP_UPDATE(sGGSMData.sEntityGroup[i])
	ENDREPEAT
	IF (sGGSMData.iGroupsActive > sGGSMData.iMaxGroupsActive)
		sGGSMData.iMaxGroupsActive = sGGSMData.iGroupsActive
	ENDIF
	
	sGGSMData.iEntitiesActive = 0
	REPEAT GGSM_MAX_ENTITIES i
		IF (sGGSMData.sEntities[i].eState != GGSM_ENTITY_STATE_NONE)
			GGSM_ENTITY_UPDATE(sGGSMData.sEntities[i])
		ENDIF 
	ENDREPEAT 
	IF (sGGSMData.iEntitiesActive > sGGSMData.iMaxEntitiesActive)
		sGGSMData.iMaxEntitiesActive = sGGSMData.iEntitiesActive
	ENDIF
	
	GGSM_BOSS_CONTROLLER_UPDATE_ARRAY(sGGSMData.sBossController)
	GGSM_UPDATE_PROJECTILE_ARRAY(sGGSMData.sProjectiles)
	
	GGSM_PROCESS_PLAYER_VS_ENEMY_COLLISIONS()
	GGSM_PROCESS_ENTITY_VS_PROJECTILE_COLLISIONS(sGGSMData.sEntities, sGGSMData.sProjectiles)
	GGSM_PROCESS_PROJECTILE_VS_BACKGROUND_COLLISIONS(sGGSMData.sProjectiles)
	GGSM_PROCESS_PLAYER_VS_BACKGROUND_COLLISIONS()

	IF IS_BITMASK_ENUM_AS_ENUM_SET(sGGSMData.eStageFlags, GGSM_STAGE_BIT_PLAYER_SPECIAL_WPN_USED)
		GGSM_USE_WEAPON_IN_SLOT(GGSM_WEAPON_SLOT_SPECIAL)
		CLEAR_BITMASK_ENUM_AS_ENUM(sGGSMData.eStageFlags, GGSM_STAGE_BIT_PLAYER_SPECIAL_WPN_USED)
	ENDIF 
		
	IF IS_BITMASK_ENUM_AS_ENUM_SET(sGGSMData.eStageFlags, GGSM_STAGE_BIT_PLAYER_DEFENSE_WPN_USED)
		GGSM_USE_WEAPON_IN_SLOT(GGSM_WEAPON_SLOT_DEFENSE)
		CLEAR_BITMASK_ENUM_AS_ENUM(sGGSMData.eStageFlags, GGSM_STAGE_BIT_PLAYER_DEFENSE_WPN_USED)
	ENDIF 
	
	GGSM_UPDATE_FXSPRITE_ARRAY(sGGSMData.sFXSprite)
	GGSM_UPDATE_SPECIAL_WEAPON_ARRAY(sGGSMData.sSpWeaponData)
	GGSM_UPDATE_POWER_UP_ARRAY(sGGSMData.sPowerUp)
	
	IF (GET_GAME_TIMER() > sGGSMData.iLastEnemyDeathTimeMS + GGSM_CHAIN_GRACE_TIME_MS)
		sGGSMData.fChainMultiplier -= (GET_FRAME_TIME() * GGSM_CHAIN_REDUCE_RATE_PER_SECOND)
		IF (sGGSMData.fChainMultiplier < 0)
			sGGSMData.fChainMultiplier = 0
		ENDIF 
	ENDIF 
	
	sGGSMData.fGrazeTimer += GET_FRAME_TIME()
	IF (sGGSMData.fGrazeTimer > sGGSMData.fGrazeTime) AND (sGGSMData.bGrazed)
		sGGSMData.bGrazed = FALSE
		GGSM_INCREASE_PLAYER_SCORE(10)
		sGGSMData.iGraze ++
		sGGSMData.fGrazeTimer = sGGSMData.fGrazeTime
	ENDIF 
ENDPROC 

//-------------------------------------------------
// CLIENT STATE
//-------------------------------------------------	

/// PURPOSE:
///    Set Client State
/// PARAMS:
///    eNewState - New State
PROC GGSM_SET_CLIENT_SUBSTATE(GGSM_SUBSTATE eNewState)	
	ARCADE_GAMES_HELP_TEXT_CLEAR()
	CDEBUG1LN(DEBUG_MINIGAME, "[GGSM] GGSM_SET_CLIENT_SUBSTATE - State changed from ", 
		GGSM_SUBSTATE_TO_STRING(sGGSMData.eSubState), " to ", GGSM_SUBSTATE_TO_STRING(eNewState))
	sGGSMData.eSubState = eNewState
	sGGSMData.fStateTimer = 0
	sGGSMData.fStateInterpolateValue = 0.0
	sGGSMData.fTimeScale = 1.0
ENDPROC

/// PURPOSE:
///    Set Client State
/// PARAMS:
///    eNewState - New State
PROC GGSM_SET_CLIENT_STATE(GGSM_STATE eNewState)	
	CDEBUG1LN(DEBUG_MINIGAME, "[GGSM] GGSM_SET_CLIENT_STATE - State changed from ", 
		GGSM_STATE_TO_STRING(sGGSMData.eState), " to ", GGSM_STATE_TO_STRING(eNewState))
	
	sGGSMData.bGamePaused = FALSE
	sGGSMData.eState = eNewState
	GGSM_SET_CLIENT_SUBSTATE(GGSM_SUBSTATE_INIT)
ENDPROC

/// PURPOSE:
///    Cleanup and Exit Client
PROC GGSM_CLEANUP_AND_EXIT_CLIENT()
	IF GGSM_IS_GAME_ACTIVELY_PLAYING()
		GGSM_SEND_PLAYSTATS()
	ENDIF 
	
	GGSM_TRIGGER_MUSIC_EVENT("ARCADE_SM_STOP")
	CDEBUG1LN(DEBUG_MINIGAME, "[GGSM] [JS] - GGSM_CLEANUP_AND_EXIT_CLIENT - Cleaning up and terminating the script")
	GGSM_PLAY_AVATAR_LEAVE_MACHINE_ANIM()
	ARCADE_CABINET_COMMON_CLEANUP()
	
	GGSM_RELEASE_BINK_MOVIE(sGGSMData.sBinkMovie)
	GGSM_RELEASE_ALL_TEXTURE_DICTS()
	GGSM_STOP_AUDIO_SCENE("DLC_CH_AM_SM_IN_MENUS_SCENE")
	GGSM_STOP_AUDIO_SCENE("DLC_CH_AM_SM_IN_GAMEPLAY_SCENE")
	GGSM_STOP_AUDIO_SCENE("DLC_CH_ARCADE_MACHINE_IN_USE_SCENE")
	GGSM_PC_CONTROLS_CLEANUP()
	ARCADE_GAMES_HELP_TEXT_CLEAR()
	ARCADE_GAMES_AUDIO_CLEAN_UP()
	
	ARCADE_GAMES_SOUND_RELEASE_AUDIO_BANK("DLC_HEIST3\\H3_SpaceMonkey3")
	CLEAR_ADDITIONAL_TEXT(MINIGAME_TEXT_SLOT, FALSE)
	TERMINATE_THIS_MULTIPLAYER_THREAD_NO_ARGS()	
ENDPROC

/// PURPOSE:
///    Initializes the Client
PROC GGSM_PROCESS_CLIENT_STATE_INIT()	
	GGSM_INIT_GLOBALS()
	
	ARCADE_CABINET_COMMON_INITIALIZATION()	
	ARCADE_GAMES_POSTFX_INIT(CASINO_ARCADE_GAME_GO_GO_SPACE_MONKEY_3)
	ARCADE_GAMES_SOUND_INIT(CASINO_ARCADE_GAME_GO_GO_SPACE_MONKEY_3)
	
	GGSM_PC_CONTROLS_INIT()
	GGSM_SET_CHALLENGE_BITS_FROM_AWARDS()
	GGSM_CAMERA_INIT(sGGSMData.sCamera)
	GGSM_TILEMAP_INIT(sGGSMData.sTileMap)
	GGSM_SET_CLIENT_STATE(GGSM_STATE_REQUESTING_ASSETS)	
ENDPROC

/// PURPOSE:
///    Processes Requesting of Assets
PROC GGSM_PROCESS_CLIENT_STATE_REQUESTING_ASSETS()
	IF NOT GGSM_LOAD_TEXTURE_DICT(GGSM_TEXDICT_RESIDENT)
		EXIT
	ENDIF 
	
	IF GGSM_IS_ANY_EDITOR_INCLUDED()
		IF NOT GGSM_LOAD_ALL_TEXTURE_DICTS()
			EXIT 
		ENDIF 
	ENDIF 
	
	//Additional Text
	REQUEST_ADDITIONAL_TEXT("GGSM", MINIGAME_TEXT_SLOT)
	IF NOT HAS_THIS_ADDITIONAL_TEXT_LOADED("GGSM", MINIGAME_TEXT_SLOT)
		CDEBUG1LN(DEBUG_MINIGAME, "[GGSM] GGSM_PROCESS_CLIENT_STATE_REQUESTING_ASSETS - Loading Additional Text: GGSM")
		EXIT
	ENDIF
	
	IF NOT ARCADE_GAMES_POSTFX_REQUESTING_ASSETS()
		CDEBUG1LN(DEBUG_MINIGAME, "[GGSM] GGSM_PROCESS_CLIENT_STATE_REQUESTING_ASSETS - Post FX")
		EXIT 
	ENDIF 
	
	//Audio
	IF NOT ARCADE_GAMES_SOUND_REQUESTING_AUDIO_BANK("DLC_HEIST3\\H3_SpaceMonkey3")
		CDEBUG1LN(DEBUG_MINIGAME, "[GGSM] GGSM_PROCESS_CLIENT_STATE_REQUESTING_ASSETS - Loading Audio Bank DLC_HEIST3/H3_SpaceMonkey3")
		EXIT
	ENDIF
	
	GGSM_START_AUDIO_SCENE("DLC_CH_ARCADE_MACHINE_IN_USE_SCENE")
	GGSM_SET_CLIENT_STATE(GGSM_STATE_PSA_SCREEN)
	
	#IF GGSM_NO_INTRO
		GGSM_SET_CLIENT_STATE(GGSM_STATE_STAGE_SELECT)
	#ENDIF 
	
	GGSM_FADE_SCREEN_OUT(0.01)
ENDPROC

PROC GGSM_PROCESS_CLIENT_STATE_FIB_WARNING()
	SWITCH (sGGSMData.eSubState)
		CASE GGSM_SUBSTATE_INIT
			IF NOT GGSM_LOAD_TEXTURE_DICT_FOR_SPRITE(GGSM_SPRITE_FBI_WARN)
				EXIT 
			ENDIF 
			
			GGSM_FADE_SCREEN_IN()
			GGSM_SET_CLIENT_SUBSTATE(GGSM_SUBSTATE_ACTIVE)
		BREAK 
		
		CASE GGSM_SUBSTATE_ACTIVE			
			GGSM_DRAW_CLIENT_STATE_FIB_WARNING()
			IF (sGGSMData.fStateTimer > 5.0)
				GGSM_FADE_SCREEN_OUT()
				GGSM_SET_CLIENT_SUBSTATE(GGSM_SUBSTATE_CLEANUP)
			ENDIF
		BREAK 
		
		CASE GGSM_SUBSTATE_CLEANUP
			GGSM_DRAW_CLIENT_STATE_FIB_WARNING()
			IF GGSM_IS_SCREEN_FADED_OUT()
				GGSM_SET_CLIENT_STATE(GGSM_STATE_PSA_SCREEN)
			ENDIF 
		BREAK 
	ENDSWITCH
ENDPROC

PROC GGSM_PROCESS_CLIENT_STATE_PSA_SCREEN()
	SWITCH (sGGSMData.eSubState)
		CASE GGSM_SUBSTATE_INIT
			IF NOT GGSM_LOAD_TEXTURE_DICT_FOR_SPRITE(GGSM_SPRITE_PSA)
				EXIT 
			ENDIF 
			
			GGSM_FADE_SCREEN_IN()
			GGSM_SET_CLIENT_SUBSTATE(GGSM_SUBSTATE_ACTIVE)
		BREAK 
		
		CASE GGSM_SUBSTATE_ACTIVE			
			GGSM_DRAW_CLIENT_STATE_PSA_SCREEN()
			IF (sGGSMData.fStateTimer > 4.0)
				GGSM_FADE_SCREEN_OUT()
				GGSM_SET_CLIENT_SUBSTATE(GGSM_SUBSTATE_CLEANUP)
			ENDIF
		BREAK 
		
		CASE GGSM_SUBSTATE_CLEANUP
			GGSM_DRAW_CLIENT_STATE_PSA_SCREEN()
			IF GGSM_IS_SCREEN_FADED_OUT()
				GGSM_SET_CLIENT_STATE(GGSM_STATE_DEVELOPER_LOGO)
			ENDIF 
		BREAK 
	ENDSWITCH
ENDPROC

PROC GGSM_PROCESS_CLIENT_STATE_DEVELOPER_LOGO()
	GGSM_DRAW_BLACK_BG()
	
	SWITCH (sGGSMData.eSubState)
		CASE GGSM_SUBSTATE_INIT
			GGSM_FADE_SCREEN_IN()
			IF NOT GGSM_START_BINK_MOVIE(sGGSMData.sBinkMovie, "_Pixtro_Intro_80s_2")
				GGSM_SET_CLIENT_STATE(GGSM_STATE_FIB_WARNING)
				EXIT 
			ENDIF
			
			GGSM_SET_CLIENT_SUBSTATE(GGSM_SUBSTATE_ACTIVE)
		BREAK 
		
		CASE GGSM_SUBSTATE_ACTIVE		
			IF GGSM_DRAW_BINK_MOVIE(sGGSMData.sBinkMovie)
				GGSM_FADE_SCREEN_OUT_INSTANT()
				GGSM_SET_CLIENT_SUBSTATE(GGSM_SUBSTATE_CLEANUP)
			ENDIF
		BREAK 
		
		CASE GGSM_SUBSTATE_CLEANUP
			IF GGSM_IS_SCREEN_FADED_OUT()
				GGSM_RELEASE_BINK_MOVIE(sGGSMData.sBinkMovie)
				GGSM_SET_CLIENT_STATE(GGSM_STATE_TITLE_SCREEN)
			ENDIF 
		BREAK 		
	ENDSWITCH
ENDPROC

PROC GGSM_PROCESS_CLIENT_STATE_TITLE_SCREEN()
	SWITCH (sGGSMData.eSubState)
		CASE GGSM_SUBSTATE_INIT
			IF NOT GGSM_LOAD_TEXTURE_DICT(GGSM_TEXDICT_FRONTEND)
				EXIT 
			ENDIF 

			IF NOT GGSM_LOAD_TEXTURE_DICT(GGSM_TEXDICT_BG)
				EXIT 
			ENDIF 
			
			GGSM_FADE_SCREEN_IN()
			GGSM_CAMERA_RESET(sGGSMData.sCamera)
			GGSM_BGSCROLLER_RESET(sGGSMData.sBGScroller, 0)
			GGSM_START_AUDIO_SCENE("DLC_CH_AM_SM_IN_MENUS_SCENE")
			GGSM_SET_CLIENT_SUBSTATE(GGSM_SUBSTATE_ACTIVE)
			
			GGSM_TRIGGER_MUSIC_EVENT("ARCADE_SM_THEME_START")
		BREAK 
		
		CASE GGSM_SUBSTATE_ACTIVE
			GGSM_DRAW_CLIENT_STATE_TITLE_SCREEN()
			
			sGGSMData.bHardMode = IS_DISABLED_CONTROL_PRESSED(FRONTEND_CONTROL, INPUT_SCRIPT_LT) AND IS_DISABLED_CONTROL_PRESSED(FRONTEND_CONTROL, INPUT_SCRIPT_RT) AND IS_DISABLED_CONTROL_PRESSED(FRONTEND_CONTROL, INPUT_SCRIPT_LB) AND IS_DISABLED_CONTROL_PRESSED(FRONTEND_CONTROL, INPUT_SCRIPT_RB) AND IS_DISABLED_CONTROL_PRESSED(FRONTEND_CONTROL, INPUT_SCRIPT_RLEFT)
			sGGSMData.fScrollTimePerFrame = GGSM_SCROLL_TIME_PER_FRAME
			
			IF (sGGSMData.bHardMode)
				sGGSMData.fScrollTimePerFrame = GGSM_SCROLL_TIME_PER_FRAME / 2.0
			ENDIF
			
			IF GGSM_IS_SCREEN_FADED_IN()
				IF NOT ARCADE_GAMES_HELP_TEXT_IS_THIS_BEING_DISPLAYED(ARCADE_GAMES_HELP_TEXT_ENUM_GGSM_TITLE)
					ARCADE_GAMES_HELP_TEXT_PRINT(ARCADE_GAMES_HELP_TEXT_ENUM_GGSM_TITLE, 15000)
				ENDIF
			ENDIF 
			
			IF GGSM_HAS_PLAYER_PRESSED_START() OR GGSM_HAS_PLAYER_PRESSED_FIRE()
				GGSM_FADE_SCREEN_OUT()
				GGSM_PLAY_SOUND(ARCADE_GAMES_SOUND_GGSM_PRESSED_START)
				GGSM_SET_CLIENT_SUBSTATE(GGSM_SUBSTATE_CLEANUP)
			ELIF (sGGSMData.fStateTimer > 15.0)
				GGSM_FADE_SCREEN_OUT()
				GGSM_SET_CLIENT_SUBSTATE(GGSM_SUBSTATE_CLEANUP_TO_LDB)
			ENDIF
		BREAK 
		
		CASE GGSM_SUBSTATE_CLEANUP
			GGSM_DRAW_CLIENT_STATE_TITLE_SCREEN()
			IF GGSM_IS_SCREEN_FADED_OUT()
				GGSM_SET_CLIENT_STATE(GGSM_STATE_STORY)
			ENDIF 
		BREAK 
		
		CASE GGSM_SUBSTATE_CLEANUP_TO_LDB
			GGSM_DRAW_CLIENT_STATE_TITLE_SCREEN()
			IF GGSM_IS_SCREEN_FADED_OUT()
				GGSM_SET_CLIENT_STATE(GGSM_STATE_LEADERBOARD)
			ENDIF 		
		BREAK
	ENDSWITCH 
ENDPROC

/// PURPOSE:
///    Handles the main game state
PROC GGSM_PROCESS_CLIENT_STATE_PLAYING()	
	SWITCH (sGGSMData.eSubState)
		CASE GGSM_SUBSTATE_INIT
			IF NOT GGSM_LOAD_TEXTURE_DICT(GGSM_TEXDICT_BG)
				EXIT 
			ENDIF 
			
			GGSM_FADE_SCREEN_IN()
			ARCADE_GAMES_HELP_TEXT_CLEAR()
			GGSM_STOP_AUDIO_SCENE("DLC_CH_AM_SM_IN_MENUS_SCENE")
			GGSM_SET_CLIENT_SUBSTATE(GGSM_SUBSTATE_ACTIVE)
		BREAK 
		
		CASE GGSM_SUBSTATE_ACTIVE
			GGSM_DRAW_BG()
		BREAK 
	ENDSWITCH
ENDPROC

///    Handles the main game state
PROC GGSM_PROCESS_CLIENT_STATE_STORY()		
	SWITCH (sGGSMData.eSubState)
		CASE GGSM_SUBSTATE_INIT
			IF NOT GGSM_LOAD_TEXTURE_DICT(GGSM_TEXDICT_FRONTEND)
				EXIT 
			ENDIF 
			
			GGSM_CAMERA_RESET(sGGSMData.sCamera)
			GGSM_RESET_FOR_GAME_START()
			GGSM_RESET_FOR_STAGE_START(TRUE)
			GGSM_SET_CLIENT_SUBSTATE(GGSM_SUBSTATE_ACTIVE)
			sGGSMData.vStoryBasePos = INIT_VECTOR_2D(cfBASE_SCREEN_HALF_WIDTH, GGSM_STORY_MAX_Y_POS)
			sGGSMData.fStoryScrollRate = 40.0
			GGSM_FADE_SCREEN_IN()
		BREAK 
	
		CASE GGSM_SUBSTATE_ACTIVE	
			sGGSMData.vStoryBasePos.y -= (sGGSMData.fStoryScrollRate * GET_FRAME_TIME())
			GGSM_DRAW_CLIENT_STATE_STORY()
			
			IF GGSM_HAS_PLAYER_PRESSED_START() OR GGSM_HAS_PLAYER_PRESSED_FIRE() OR (sGGSMData.vStoryBasePos.y < GGSM_STORY_MIN_Y_POS)
				GGSM_FADE_SCREEN_OUT()
				GGSM_PLAY_SOUND(ARCADE_GAMES_SOUND_GGSM_PRESSED_START)
				GGSM_SET_CLIENT_SUBSTATE(GGSM_SUBSTATE_CLEANUP)
			ENDIF
		BREAK 
		
		CASE GGSM_SUBSTATE_CLEANUP
			GGSM_DRAW_CLIENT_STATE_STORY()
			IF GGSM_IS_SCREEN_FADED_OUT()
				GGSM_SET_CLIENT_STATE(GGSM_STATE_STAGE_SELECT)
			ENDIF 
		BREAK 
	ENDSWITCH 
ENDPROC 

/// PURPOSE:
///    Handles the main game state
PROC GGSM_PROCESS_CLIENT_STATE_STAGE_MISSION_SELECT()	
	SWITCH (sGGSMData.eSubState)
		CASE GGSM_SUBSTATE_INIT
			IF NOT GGSM_LOAD_TEXTURE_DICT(GGSM_TEXDICT_BG)
				EXIT 
			ENDIF
			
			IF NOT GGSM_LOAD_TEXTURE_DICT(GGSM_TEXDICT_FRONTEND)
				EXIT 
			ENDIF
	
			IF NOT GGSM_LOAD_TEXTURE_DICT(GGSM_TEXDICT_GAME)
				EXIT 
			ENDIF
			
			GGSM_FADE_SCREEN_IN()
			GGSM_CAMERA_RESET(sGGSMData.sCamera)
			GGSM_RESET_FOR_STAGE_START(TRUE)
			GGSM_SET_CLIENT_SUBSTATE(GGSM_SUBSTATE_MAP_FLY_START)
		BREAK 
	
		CASE GGSM_SUBSTATE_MAP_FLY_START		
			IF (sGGSMData.fStateTimer > 0.5)
				GGSM_SET_CLIENT_SUBSTATE(GGSM_SUBSTATE_MAP_FLY)
			ELIF GGSM_HAS_PLAYER_PRESSED_FIRE()
				GGSM_SET_CLIENT_SUBSTATE(GGSM_SUBSTATE_ACTIVE)
				sGGSMData.fStateInterpolateValue = 1.0
			ELIF GGSM_HAS_PLAYER_PRESSED_START()
				GGSM_SET_CLIENT_SUBSTATE(GGSM_SUBSTATE_MAP_DONE)		
				sGGSMData.fStateInterpolateValue = 1.0
			ENDIF
			
			GGSM_DRAW_CLIENT_STATE_STAGE_MISSION_SELECT()
		BREAK
		
		CASE GGSM_SUBSTATE_MAP_FLY
			sGGSMData.fStateInterpolateValue += GET_FRAME_TIME()
			IF (sGGSMData.fStateInterpolateValue >= 1.0) OR GGSM_HAS_PLAYER_PRESSED_FIRE()
				GGSM_SET_CLIENT_SUBSTATE(GGSM_SUBSTATE_ACTIVE)
				sGGSMData.fStateInterpolateValue = 1.0
			ELIF GGSM_HAS_PLAYER_PRESSED_START()
				GGSM_SET_CLIENT_SUBSTATE(GGSM_SUBSTATE_MAP_DONE)		
				sGGSMData.fStateInterpolateValue = 1.0
			ENDIF
			
			GGSM_DRAW_CLIENT_STATE_STAGE_MISSION_SELECT()
		BREAK 
		
		CASE GGSM_SUBSTATE_ACTIVE	
			GGSM_DRAW_CLIENT_STATE_STAGE_MISSION_SELECT()
			
			IF GGSM_HAS_PLAYER_PRESSED_START() OR GGSM_HAS_PLAYER_PRESSED_FIRE()
				GGSM_SET_CLIENT_SUBSTATE(GGSM_SUBSTATE_MAP_DONE)
				sGGSMData.fStateInterpolateValue = 1.0
			ENDIF 
		BREAK 
		
		CASE GGSM_SUBSTATE_MAP_DONE
			GGSM_DRAW_CLIENT_STATE_STAGE_MISSION_SELECT()
			GGSM_FADE_SCREEN_OUT()
			GGSM_PLAY_SOUND(ARCADE_GAMES_SOUND_GGSM_MONKEY_VOICE_STAGE_SELECT)
			GGSM_SET_CLIENT_SUBSTATE(GGSM_SUBSTATE_CLEANUP)
			sGGSMData.fStateInterpolateValue = 1.0		
		BREAK 
		
		CASE GGSM_SUBSTATE_CLEANUP
			GGSM_DRAW_CLIENT_STATE_STAGE_MISSION_SELECT()
			
			IF GGSM_IS_SCREEN_FADED_OUT()
				GGSM_SET_CLIENT_STATE(GGSM_STATE_STAGE_ACTIVE)
			ENDIF 
		BREAK 
	ENDSWITCH 
ENDPROC 
	
/// PURPOSE:
///    Handles the main game state
PROC GGSM_PROCESS_CLIENT_STATE_STAGE_ACTIVE()	
	GGSM_TEXDICT stageBG 
	
	SWITCH (sGGSMData.eSubState)
		CASE GGSM_SUBSTATE_INIT
			GGSM_RELEASE_TEXTURE_DICT(GGSM_TEXDICT_FRONTEND)
			
			IF NOT GGSM_LOAD_TEXTURE_DICT(GGSM_TEXDICT_GAME)
				EXIT 
			ENDIF 
			
			IF NOT GGSM_LOAD_TEXTURE_DICT(GGSM_TEXDICT_BG)
				EXIT 
			ENDIF 
			
			stageBG = GGSM_GET_TEXDICT_FOR_STAGE_TILES(sGGSMData.sGameStats.level)
			IF (stageBG != GGSM_TEXDICT_NONE) AND NOT GGSM_LOAD_TEXTURE_DICT(stageBG)
				EXIT 
			ENDIF 
			
			GGSM_FADE_SCREEN_IN()
			ARCADE_GAMES_HELP_TEXT_CLEAR()
			GGSM_PLAY_AVATAR_PLAY_RANDOM_IDLE_ANIM()
			GGSM_START_AUDIO_SCENE("DLC_CH_AM_SM_IN_GAMEPLAY_SCENE")
			GGSM_STOP_AUDIO_SCENE("DLC_CH_AM_SM_IN_MENUS_SCENE")
			GGSM_RESET_FOR_STAGE_START(FALSE)		
			GGSM_SET_CLIENT_SUBSTATE(GGSM_SUBSTATE_ACTIVE)
			GGSM_TRIGGER_MUSIC_EVENT_FOR_STAGE(sGGSMData.sGameStats.level)
		BREAK 
		
		CASE GGSM_SUBSTATE_ACTIVE
			GGSM_UPDATE_MAIN_GAME()
			GGSM_DRAW_MAIN_GAME()
			
			IF NOT IS_BITMASK_ENUM_AS_ENUM_SET(sGGSMData.eStageFlags, GGSM_STAGE_BIT_EXPLOSIONS_ACTIVE)
				IF (sGGSMData.iPlayerLives = 0) AND NOT GGSM_DOES_PLAYER_SHIP_EXIST()
					sGGSMData.fPlayerDeadTimer += GET_FRAME_TIME()
					IF (sGGSMData.fPlayerDeadTimer >= 1.5)
						GGSM_FADE_SCREEN_OUT()
						GGSM_SET_CLIENT_SUBSTATE(GGSM_SUBSTATE_CLEANUP)
					ENDIF 
				ELSE 
					sGGSMData.fPlayerDeadTimer = 0.0
				ENDIF 
			ENDIF
			
			IF GGSM_IS_STAGE_READY_TO_END()		
				GGSM_SET_CLIENT_STATE(GGSM_STATE_STAGE_CLEAR)
			ENDIF
		BREAK 
		
		CASE GGSM_SUBSTATE_CLEANUP
			GGSM_DRAW_MAIN_GAME()
			
			IF GGSM_IS_SCREEN_FADED_OUT()
				GGSM_SET_CLIENT_STATE(GGSM_STATE_GAME_OVER)
			ENDIF 
		BREAK 
	ENDSWITCH 
ENDPROC

PROC GGSM_PROCESS_CLIENT_STATE_STAGE_CLEAR()
	FLOAT pc 
	FLOAT fShipY = 690.0
	
	GGSM_SET_PLAYER_INVUNERABLE()
	GGSM_UPDATE_MAIN_GAME()
	GGSM_DRAW_GAME_STATE_STAGE_CLEAR()
	
	SWITCH (sGGSMData.eSubState)
		CASE GGSM_SUBSTATE_INIT
			IF NOT IS_BITMASK_ENUM_AS_ENUM_SET(sGGSMData.eStageFlags, GGSM_STAGE_BIT_EXPLOSIONS_ACTIVE)
				GGSM_RESET_PROJECTILE_ARRAY(sGGSMData.sProjectiles)
				CLEAR_BITMASK_ENUM_AS_ENUM(sGGSMData.sEntities[sGGSMData.iPlayerShipIndex].eFlags, GGSM_ENTITY_BIT_WPN_ACTIVE)	
				SET_BITMASK_ENUM_AS_ENUM(sGGSMData.eStageFlags, GGSM_STAGE_BIT_DISABLE_WEAPONS)
				SET_BITMASK_ENUM_AS_ENUM(sGGSMData.eStageFlags, GGSM_STAGE_BIT_BRING_CAMERA_TO_STOP)
				
				IF (sGGSMData.sGameStats.level = 1)
					//GGSM_DIALOG_CONTROLLER_START_DIALOG(sGGSMData.sDialogController, GGSM_DIALOG_ASTEROID_LEAVE)
				ENDIF 
				
				GGSM_SET_CLIENT_SUBSTATE(GGSM_SUBSTATE_CLR_DIALOG)
			ENDIF
		BREAK 
		
		CASE GGSM_SUBSTATE_CLR_DIALOG 
			IF NOT GGSM_IS_DIALOG_ACTIVE()
				GGSM_ENTITY_SET_MOVEMENT_TO_VECTOR(sGGSMData.sEntities[sGGSMData.iPlayerShipIndex], INIT_VECTOR_2D(cfBASE_SCREEN_HALF_WIDTH, fShipY))
				CLEAR_BITMASK_ENUM_AS_ENUM(sGGSMData.sEntities[sGGSMData.iPlayerShipIndex].eFlags, GGSM_ENTITY_BIT_WPN_ACTIVE)	
				SET_BITMASK_ENUM_AS_ENUM(sGGSMData.eStageFlags, GGSM_STAGE_BIT_DISABLE_WEAPONS)
				SET_BITMASK_ENUM_AS_ENUM(sGGSMData.eStageFlags, GGSM_STAGE_BIT_BRING_CAMERA_TO_STOP)
				
				sGGSMData.sEntities[sGGSMData.iPlayerShipIndex].fSpeed /= 2.0
				
				sGGSMData.iSectorBonus = (sGGSMData.sGameStats.level) * GGSM_SECTOR_CLEAR_BONUS
				pc = (TO_FLOAT(sGGSMData.iEnemiesDestroyed) / TO_FLOAT(sGGSMData.iEnemiesCreated)) * 100.0
				IF (pc >= 100.0)
					pc = 100.0
				ENDIF 
			
				sGGSMData.iTakedownBonus = CEIL(pc) * (GGSM_TAKEDOWN_BONUS / 100)
				sGGSMData.iTakedownBonus -= (sGGSMData.iTakedownBonus % 100)
				
				IF GGSM_IS_LAST_STAGE()
					sGGSMData.iAllClearBonus = (GGSM_POINTS_PER_LIFE_ALL_CLEAR * sGGSMData.iPlayerLives)
					IF (sGGSMData.bHardMode) 
						sGGSMData.iAllClearBonus += sGGSMData.sGameStats.score
					ENDIF
				ELSE 
					sGGSMData.iAllClearBonus = 0
				ENDIF 
				
				GGSM_SET_CLIENT_SUBSTATE(GGSM_SUBSTATE_CLR_STAGE_CLEAR)
			ENDIF 
		BREAK

		CASE GGSM_SUBSTATE_CLR_STAGE_CLEAR
			// handle movement anim
			IF (sGGSMData.sEntities[sGGSMData.iPlayerShipIndex].sWorld.vPosition.y > fShipY)
				GGSM_ENTITY_SET_ANIM_FRAME(sGGSMData.sEntities[sGGSMData.iPlayerShipIndex], 1)
			ELIF (sGGSMData.sEntities[sGGSMData.iPlayerShipIndex].sWorld.vPosition.y < fShipY)
				GGSM_ENTITY_SET_ANIM_FRAME(sGGSMData.sEntities[sGGSMData.iPlayerShipIndex], 2)
			ELSE 
				GGSM_ENTITY_SET_ANIM_FRAME(sGGSMData.sEntities[sGGSMData.iPlayerShipIndex], 0)
			ENDIF 
			
			IF IS_BITMASK_ENUM_AS_ENUM_SET(sGGSMData.sEntities[sGGSMData.iPlayerShipIndex].eMoveFlags, GGSM_MOVE_BIT_COMPLETE)
				GGSM_FAKE_FADE_SCREEN_OUT(1.0)
				GGSM_TRIGGER_MUSIC_EVENT("ARCADE_SM_THEME_START")
				GGSM_ENTITY_SET_MOVEMENT_TYPE(sGGSMData.sEntities[sGGSMData.iPlayerShipIndex], GGSM_MOVEMENT_NONE)
				GGSM_SET_CLIENT_SUBSTATE(GGSM_SUBSTATE_CLR_STAGE_BONUS)
			ENDIF 
		BREAK 
		
		CASE GGSM_SUBSTATE_CLR_STAGE_BONUS
			IF GGSM_IS_SCREEN_FAKE_FADED_OUT()
				GGSM_SET_CLIENT_SUBSTATE(GGSM_SUBSTATE_CLR_SECTOR_BONUS)
			ENDIF 
		BREAK 
		
		CASE GGSM_SUBSTATE_CLR_SECTOR_BONUS
			IF (sGGSMData.iSectorBonus <= 0)
				sGGSMData.iSectorBonus = 0
				GGSM_SET_CLIENT_SUBSTATE(GGSM_SUBSTATE_CLR_TAKEDOWN_BONUS)
			ELSE 
				ARCADE_GAMES_SOUND_PLAY_LOOP(ARCADE_GAMES_SOUND_GGSM_SCORE_COUNT_LOOP)
				sGGSMData.iSectorBonus -= GGSM_BONUS_COUNT_RATE
				GGSM_INCREASE_PLAYER_SCORE(GGSM_BONUS_COUNT_RATE, GGSM_IS_LAST_STAGE())	
			ENDIF 		
		BREAK 
		
		CASE GGSM_SUBSTATE_CLR_TAKEDOWN_BONUS
			IF (sGGSMData.iTakedownBonus <= 0)
				sGGSMData.iTakedownBonus = 0
				GGSM_SET_CLIENT_SUBSTATE(GGSM_SUBSTATE_CLR_NO_DMG_BONUS)
			ELSE 	
				ARCADE_GAMES_SOUND_PLAY_LOOP(ARCADE_GAMES_SOUND_GGSM_SCORE_COUNT_LOOP)
				sGGSMData.iTakedownBonus -= GGSM_BONUS_COUNT_RATE
				GGSM_INCREASE_PLAYER_SCORE(GGSM_BONUS_COUNT_RATE, GGSM_IS_LAST_STAGE())				
			ENDIF 
		BREAK 
		
		CASE GGSM_SUBSTATE_CLR_NO_DMG_BONUS
			IF (sGGSMData.iNoDamageBonus <= 0)
				sGGSMData.iNoDamageBonus = 0
				GGSM_SET_CLIENT_SUBSTATE(GGSM_SUBSTATE_CLR_NO_MISS_BONUS)
			ELSE 	
				ARCADE_GAMES_SOUND_PLAY_LOOP(ARCADE_GAMES_SOUND_GGSM_SCORE_COUNT_LOOP)
				sGGSMData.iNoDamageBonus -= GGSM_BONUS_COUNT_RATE
				GGSM_INCREASE_PLAYER_SCORE(GGSM_BONUS_COUNT_RATE, GGSM_IS_LAST_STAGE())				
			ENDIF 
		BREAK 
		
		CASE GGSM_SUBSTATE_CLR_NO_MISS_BONUS
			IF (sGGSMData.iNoMissBonus <= 0)
				sGGSMData.iNoMissBonus = 0
				GGSM_SET_CLIENT_SUBSTATE(GGSM_SUBSTATE_CLR_ALL_CLEAR_BONUS)
			ELSE 
				ARCADE_GAMES_SOUND_PLAY_LOOP(ARCADE_GAMES_SOUND_GGSM_SCORE_COUNT_LOOP)
				sGGSMData.iNoMissBonus -= GGSM_BONUS_COUNT_RATE
				GGSM_INCREASE_PLAYER_SCORE(GGSM_BONUS_COUNT_RATE, GGSM_IS_LAST_STAGE())			
			ENDIF 
		BREAK 
		
		CASE GGSM_SUBSTATE_CLR_ALL_CLEAR_BONUS
			IF (sGGSMData.iAllClearBonus <= 0)
				sGGSMData.iAllClearBonus = 0
				GGSM_SET_CLIENT_SUBSTATE(GGSM_SUBSTATE_CLR_FLY_OFF)
			ELSE 
				ARCADE_GAMES_SOUND_PLAY_LOOP(ARCADE_GAMES_SOUND_GGSM_SCORE_COUNT_LOOP)
				sGGSMData.iAllClearBonus -= GGSM_BONUS_COUNT_RATE
				GGSM_INCREASE_PLAYER_SCORE(GGSM_BONUS_COUNT_RATE, GGSM_IS_LAST_STAGE())			
			ENDIF 
		BREAK 
		
		CASE GGSM_SUBSTATE_CLR_FLY_OFF
			ARCADE_GAMES_SOUND_STOP(ARCADE_GAMES_SOUND_GGSM_SCORE_COUNT_LOOP)
			ARCADE_GAMES_SOUND_PLAY(ARCADE_GAMES_SOUND_GGSM_SCORE_COUNT_FINAL)
			sGGSMData.sEntities[sGGSMData.iPlayerShipIndex].fSpeed *= 2.0
			GGSM_ENTITY_SET_MOVEMENT_TO_VECTOR(sGGSMData.sEntities[sGGSMData.iPlayerShipIndex], INIT_VECTOR_2D(1800.0, fShipY))
			GGSM_SET_CLIENT_SUBSTATE(GGSM_SUBSTATE_CLR_FLY_OFF_DONE)
		BREAK 
		
		CASE GGSM_SUBSTATE_CLR_FLY_OFF_DONE
			IF IS_BITMASK_ENUM_AS_ENUM_SET(sGGSMData.sEntities[sGGSMData.iPlayerShipIndex].eMoveFlags, GGSM_MOVE_BIT_COMPLETE)
				GGSM_FADE_SCREEN_OUT()
				GGSM_SET_CLIENT_SUBSTATE(GGSM_SUBSTATE_CLEANUP)
			ENDIF 
		BREAK	
		
		CASE GGSM_SUBSTATE_CLEANUP
			IF GGSM_IS_SCREEN_FADED_OUT()
				IF NOT IS_BITMASK_ENUM_AS_ENUM_SET(sGGSMData.eStageFlags, GGSM_STAGE_BIT_PLAYER_DAMAGED) AND NOT IS_BITMASK_ENUM_AS_ENUM_SET(sGGSMData.eStageFlags, GGSM_STAGE_BIT_PLAYER_DIED)
					GGSM_SET_CHALLENGE_COMPLETED(GGSM_CHALLENGE_BIT_APE_ESCAPE)
				ENDIF
				
				GGSM_CLEAR_FAKE_FADE()
				sGGSMData.sGameStats.level ++
				IF (sGGSMData.sGameStats.level > GGSM_SECTOR_MAX)
					GGSM_SET_CLIENT_STATE(GGSM_STATE_STAGE_CONGRATS)
				ELSE 
					GGSM_SET_CLIENT_STATE(GGSM_STATE_STAGE_SELECT)
				ENDIF			
			ENDIF 
		BREAK 
	ENDSWITCH 
ENDPROC 

PROC GGSM_PROCESS_CLIENT_STATE_STAGE_CONGRATS()	
	SWITCH (sGGSMData.eSubState)
		CASE GGSM_SUBSTATE_INIT
			IF NOT GGSM_LOAD_TEXTURE_DICT(GGSM_TEXDICT_BG)
				EXIT 
			ENDIF
			
			IF NOT GGSM_LOAD_TEXTURE_DICT(GGSM_TEXDICT_FRONTEND)
				EXIT 
			ENDIF
			
			IF (sGGSMData.bPowerUpCollected = FALSE )
				GGSM_SET_CHALLENGE_COMPLETED(GGSM_CHALLENGE_BIT_MONKEY_MIND)
			ENDIF
				
			sGGSMData.sGameStats.level = 0
			GGSM_SEND_PLAYSTATS()
			GGSM_RESET_FOR_STAGE_START(FALSE)	
			GGSM_FADE_SCREEN_IN()
			GGSM_SET_CLIENT_SUBSTATE(GGSM_SUBSTATE_ACTIVE)
			//GGSM_UNLOCK_PRIZE(GGSM_UNLOCK_TSHIRTS_GGSM_CLOCKEDIT)
		BREAK 
		
		CASE GGSM_SUBSTATE_ACTIVE
			GGSM_DRAW_CLIENT_STATE_STAGE_CONGRATS()
			IF GGSM_HAS_PLAYER_PRESSED_START() OR GGSM_HAS_PLAYER_PRESSED_FIRE() OR (sGGSMData.fStateTimer > 15.0)
				GGSM_FADE_SCREEN_OUT()
				GGSM_SET_CLIENT_SUBSTATE(GGSM_SUBSTATE_CLEANUP)
			ENDIF
		BREAK		
		
		CASE GGSM_SUBSTATE_CLEANUP
			GGSM_DRAW_CLIENT_STATE_STAGE_CONGRATS()
			IF GGSM_IS_SCREEN_FADED_OUT()		
				GGSM_SET_CLIENT_STATE(GGSM_STATE_LEADERBOARD_ENTRY)
			ENDIF 
		BREAK 
	ENDSWITCH 
ENDPROC 

/// PURPOSE:
///    Handles the main game state
PROC GGSM_PROCESS_CLIENT_STATE_GAME_OVER()	
	SWITCH (sGGSMData.eSubState)
		CASE GGSM_SUBSTATE_INIT
			IF NOT GGSM_LOAD_TEXTURE_DICT(GGSM_TEXDICT_PORTRAITS)
				EXIT 
			ENDIF 
			
			IF NOT GGSM_LOAD_TEXTURE_DICT(GGSM_TEXDICT_DIALOG)
				EXIT 
			ENDIF 
			
			IF NOT GGSM_LOAD_TEXTURE_DICT(GGSM_TEXDICT_FRONTEND)
				EXIT 
			ENDIF 
			
			GGSM_SEND_PLAYSTATS()
			GGSM_FADE_SCREEN_IN()
			ARCADE_GAMES_HELP_TEXT_CLEAR()
			GGSM_RESET_FOR_STAGE_START()
			GGSM_START_AUDIO_SCENE("DLC_CH_AM_SM_IN_MENUS_SCENE")
			GGSM_STOP_AUDIO_SCENE("DLC_CH_AM_SM_IN_GAMEPLAY_SCENE")
			GGSM_DIALOG_CONTROLLER_START_DIALOG(sGGSMData.sDialogController, GGSM_DIALOG_GAME_OVER)
			GGSM_TRIGGER_MUSIC_EVENT("ARCADE_SM_STOP")
			GGSM_PLAY_SOUND(ARCADE_GAMES_SOUND_GGSM_GAME_OVER)
			GGSM_SET_CLIENT_SUBSTATE(GGSM_SUBSTATE_ACTIVE)
		BREAK 
		
		CASE GGSM_SUBSTATE_ACTIVE
			ARCADE_DRAW_PIXELSPACE_SPRITE(GGSM_GET_TEXTURE_DICT(GGSM_TEXDICT_FRONTEND), "GAME_OVER_SCREEN", INIT_VECTOR_2D(cfBASE_SCREEN_HALF_WIDTH, cfBASE_SCREEN_HALF_HEIGHT), INIT_VECTOR_2D(1364.0, 972.0), 0, sGGSMData.rgbaWhite)
			GGSM_DRAW_GAME_OVER_TEXT()
	
			IF NOT GGSM_IS_DIALOG_ACTIVE()
				GGSM_FADE_SCREEN_OUT()
				GGSM_SET_CLIENT_SUBSTATE(GGSM_SUBSTATE_CLEANUP)
			ENDIF 
		BREAK 
		
		CASE GGSM_SUBSTATE_CLEANUP
			ARCADE_DRAW_PIXELSPACE_SPRITE(GGSM_GET_TEXTURE_DICT(GGSM_TEXDICT_FRONTEND), "GAME_OVER_SCREEN", INIT_VECTOR_2D(cfBASE_SCREEN_HALF_WIDTH, cfBASE_SCREEN_HALF_HEIGHT), INIT_VECTOR_2D(1364.0, 972.0), 0, sGGSMData.rgbaWhite)
			GGSM_DRAW_GAME_OVER_TEXT()
	
			IF GGSM_IS_SCREEN_FADED_OUT()
				GGSM_SET_CLIENT_STATE(GGSM_STATE_LEADERBOARD_ENTRY)
			ENDIF
		BREAK 
	ENDSWITCH
ENDPROC

/// PURPOSE:
///  Handles the leaderboard
PROC GGSM_PROCESS_CLIENT_STATE_LEADERBOARD()
	SWITCH (sGGSMData.eSubState)
		CASE GGSM_SUBSTATE_INIT
			IF NOT GGSM_LOAD_TEXTURE_DICT(GGSM_TEXDICT_FRONTEND)
				EXIT 
			ENDIF 
		
			IF NOT GGSM_LOAD_TEXTURE_DICT(GGSM_TEXDICT_BG)
				EXIT 
			ENDIF 
			
			GGSM_FADE_SCREEN_IN()
			ARCADE_GAMES_HELP_TEXT_CLEAR()
			GGSM_STOP_AUDIO_SCENE("DLC_CH_AM_SM_IN_GAMEPLAY_SCENE")
			GGSM_START_AUDIO_SCENE("DLC_CH_AM_SM_IN_MENUS_SCENE")
			GGSM_CAMERA_RESET(sGGSMData.sCamera)
			GGSM_SET_CLIENT_SUBSTATE(GGSM_SUBSTATE_ACTIVE)
		BREAK 
		
		CASE GGSM_SUBSTATE_ACTIVE	
			GGSM_DRAW_BG()
			ARCADE_GAMES_LEADERBOARD_DRAW()
		
			IF (sGGSMData.fStateTimer > 10.0) OR GGSM_HAS_PLAYER_PRESSED_START() OR GGSM_HAS_PLAYER_PRESSED_CANCEL()
				GGSM_FADE_SCREEN_OUT()
				GGSM_SET_CLIENT_SUBSTATE(GGSM_SUBSTATE_CLEANUP)
			ENDIF 
		BREAK 
		
		CASE GGSM_SUBSTATE_CLEANUP
			IF GGSM_IS_SCREEN_FADED_OUT()
				GGSM_SET_CLIENT_STATE(GGSM_STATE_TITLE_SCREEN)
			ELSE 
				GGSM_DRAW_BG()
				ARCADE_GAMES_LEADERBOARD_DRAW()			
			ENDIF 
		BREAK
	ENDSWITCH 
ENDPROC


/// PURPOSE:
///  Handles the leaderboard
PROC GGSM_PROCESS_CLIENT_STATE_LEADERBOARD_ENTRY()
	SWITCH (sGGSMData.eSubState)
		CASE GGSM_SUBSTATE_INIT
			IF NOT GGSM_LOAD_TEXTURE_DICT(GGSM_TEXDICT_FRONTEND)
				EXIT 
			ENDIF 
	
			IF NOT GGSM_LOAD_TEXTURE_DICT(GGSM_TEXDICT_BG)
				EXIT 
			ENDIF 
			
			GGSM_FADE_FROM_WHITE()
			GGSM_FADE_SCREEN_IN()
			ARCADE_GAMES_HELP_TEXT_CLEAR()
			GGSM_STOP_AUDIO_SCENE("DLC_CH_AM_SM_IN_GAMEPLAY_SCENE")
			GGSM_START_AUDIO_SCENE("DLC_CH_AM_SM_IN_MENUS_SCENE")
			GGSM_CAMERA_RESET(sGGSMData.sCamera)
			GGSM_SET_CLIENT_SUBSTATE(GGSM_SUBSTATE_ACTIVE)
			GGSM_TRIGGER_MUSIC_EVENT("ARCADE_SM_THEME_START")
		BREAK 
		
		CASE GGSM_SUBSTATE_ACTIVE
			GGSM_DRAW_BG()
			ARCADE_GAMES_LEADERBOARD_PROCESS_ENTRY(sGGSMData.sGameStats.score)
			ARCADE_GAMES_LEADERBOARD_DRAW()
			
			IF (sAGLeaderboardData.bEditing = FALSE) AND (GGSM_HAS_PLAYER_PRESSED_START() OR GGSM_HAS_PLAYER_PRESSED_CANCEL())
				GGSM_FADE_SCREEN_OUT()
				GGSM_SET_CLIENT_SUBSTATE(GGSM_SUBSTATE_CLEANUP)
			ENDIF 
		BREAK 
		
		CASE GGSM_SUBSTATE_CLEANUP
			IF GGSM_IS_SCREEN_FADED_OUT()
				GGSM_SET_CLIENT_STATE(GGSM_STATE_TITLE_SCREEN)
			ELSE 
				GGSM_DRAW_BG()
				ARCADE_GAMES_LEADERBOARD_DRAW()
			ENDIF
		BREAK
	ENDSWITCH 
ENDPROC

/// PURPOSE:
///    The actual state machine
PROC GGSM_PROCESS_CLIENT_STATE_MACHINE()
	IF (sGGSMData.eState > GGSM_STATE_REQUESTING_ASSETS)
		GGSM_DRAW_BLACK_BG()
		GGSM_CAMERA_UPDATE(sGGSMData.sCamera)
		GGSM_BGSCROLLER_UPDATE(sGGSMData.sBGScroller)
	ENDIF 
	
	SWITCH sGGSMData.eState	
		CASE GGSM_STATE_INIT		
			GGSM_PROCESS_CLIENT_STATE_INIT()		
		BREAK
		
		CASE GGSM_STATE_REQUESTING_ASSETS		
			GGSM_PROCESS_CLIENT_STATE_REQUESTING_ASSETS()	
		BREAK
		
		CASE GGSM_STATE_FIB_WARNING
			GGSM_PROCESS_CLIENT_STATE_FIB_WARNING()
		BREAK 
		
		CASE GGSM_STATE_PSA_SCREEN
			GGSM_PROCESS_CLIENT_STATE_PSA_SCREEN()
		BREAK 
	
		CASE GGSM_STATE_DEVELOPER_LOGO
			GGSM_PROCESS_CLIENT_STATE_DEVELOPER_LOGO()
		BREAK
		
		CASE GGSM_STATE_TITLE_SCREEN
			GGSM_PROCESS_CLIENT_STATE_TITLE_SCREEN()
		BREAK 
		
		CASE GGSM_STATE_PLAYING	
			GGSM_PROCESS_CLIENT_STATE_PLAYING()	
		BREAK
		
		CASE GGSM_STATE_STORY
			GGSM_PROCESS_CLIENT_STATE_STORY()
		BREAK 
		
		CASE GGSM_STATE_STAGE_SELECT
			GGSM_PROCESS_CLIENT_STATE_STAGE_MISSION_SELECT()
		BREAK 
		
		CASE GGSM_STATE_STAGE_ACTIVE
			GGSM_PROCESS_CLIENT_STATE_STAGE_ACTIVE()
		BREAK 
		
		CASE GGSM_STATE_STAGE_CLEAR
			GGSM_PROCESS_CLIENT_STATE_STAGE_CLEAR()
		BREAK 
		
		CASE GGSM_STATE_STAGE_CONGRATS
			GGSM_PROCESS_CLIENT_STATE_STAGE_CONGRATS()
		BREAK 
		
		CASE GGSM_STATE_GAME_OVER
			GGSM_PROCESS_CLIENT_STATE_GAME_OVER()
		BREAK 
		
		CASE GGSM_STATE_LEADERBOARD
			GGSM_PROCESS_CLIENT_STATE_LEADERBOARD()
		BREAK
		
		CASE GGSM_STATE_LEADERBOARD_ENTRY
			GGSM_PROCESS_CLIENT_STATE_LEADERBOARD_ENTRY()
		BREAK
		
		CASE GGSM_STATE_CLEANUP		
			GGSM_CLEANUP_AND_EXIT_CLIENT()		
		BREAK		
	ENDSWITCH	
	
	IF GGSM_IS_GAME_PLAYING()
		GGSM_TILEMAP_SET_RENDERABLE_TILE_BOUNDS(sGGSMData.sTileMap, sGGSMData.sCamera)
		GGSM_DIALOG_CONTROLLER_UPDATE(sGGSMData.sDialogController)
		IF IS_BITMASK_ENUM_AS_ENUM_SET(sGGSMData.eStageFlags, GGSM_STAGE_BIT_FORCE_Z_SORT)
			GGSM_QUICK_SORT_ZDEPTH_ARRAY(sGGSMData.sZSortData, 0, GGSM_MAX_ENTITIES - 1)
			CLEAR_BITMASK_ENUM_AS_ENUM(sGGSMData.eStageFlags, GGSM_STAGE_BIT_FORCE_Z_SORT)
		ENDIF 
	ENDIF
	
	IF (sGGSMData.fFadeTime != 0.0)
		sGGSMData.fFadeAlpha = CLAMP(sGGSMData.fFadeAlpha + (GET_FRAME_TIME() / sGGSMData.fFadeTime), 0.0, 1.0)
	ENDIF 
	
	IF (sGGSMData.fFakeFadeTime != 0.0)
		sGGSMData.fFakeFadeAlpha = CLAMP(sGGSMData.fFakeFadeAlpha + (GET_FRAME_TIME() / sGGSMData.fFakeFadeTime), 0.0, 1.0)
	ENDIF 
	
	IF (sGGSMData.fWhiteOutFadeTime != 0.0)
		sGGSMData.fWhiteOutAlpha = CLAMP(sGGSMData.fWhiteOutAlpha + (GET_FRAME_TIME() / sGGSMData.fWhiteOutFadeTime), 0.0, 1.0)
	ENDIF 
	
	IF (sGGSMData.eState > GGSM_STATE_REQUESTING_ASSETS)
		GGSM_DRAW_FACADE()
	ENDIF 
	
	IF IS_PC_VERSION() AND IS_USING_KEYBOARD_AND_MOUSE(FRONTEND_CONTROL)
		sGGSMData.sQuitTimer.action = INPUT_FRONTEND_DELETE
	ELSE 
		sGGSMData.sQuitTimer.action = INPUT_FRONTEND_CANCEL
	ENDIF 
	
	INT iQuitTime = 1000

	IF IS_CONTROL_PRESSED(sGGSMData.sQuitTimer.control, sGGSMData.sQuitTimer.action)
	OR (IS_DISABLED_CONTROL_PRESSED(sGGSMData.sQuitTimer.control, sGGSMData.sQuitTimer.action))
		IF IS_PC_VERSION() AND IS_USING_KEYBOARD_AND_MOUSE(FRONTEND_CONTROL)
			DRAW_GENERIC_METER(ABSI(GET_TIME_DIFFERENCE(GET_NETWORK_TIME(), sGGSMData.sQuitTimer.sTimer.Timer)), iQuitTime, "DEG_GAME_QUIT")
		ELSE
			DRAW_GENERIC_METER(ABSI(GET_TIME_DIFFERENCE(GET_NETWORK_TIME(), sGGSMData.sQuitTimer.sTimer.Timer)), iQuitTime, "DEG_GAME_QUIT")
		ENDIF
	ELSE
		IF IS_PC_VERSION() AND IS_USING_KEYBOARD_AND_MOUSE(FRONTEND_CONTROL)
			DRAW_GENERIC_METER(0, iQuitTime, "DEG_GAME_QUIT")
		ELSE
			DRAW_GENERIC_METER(0, iQuitTime, "DEG_GAME_QUIT")
		ENDIF
	ENDIF
	
	IF IS_CONTROL_HELD(sGGSMData.sQuitTimer, DEFAULT, iQuitTime)
	OR SHOULD_KICK_PLAYER_FROM_ANY_ARCADE_GAME()
		IF GGSM_IS_GAME_ACTIVELY_PLAYING()
			GGSM_SEND_PLAYSTATS()
		ENDIF 
		GGSM_SET_CLIENT_STATE(GGSM_STATE_CLEANUP)
	ENDIF 
ENDPROC

//-------------------------------------------------
// DEBUG FUNCTIONS
//-------------------------------------------------

#IF IS_DEBUG_BUILD

/// PURPOSE:
///    Sets up the parent widget group
/// PARAMS:
///    parentWidgetGroup - group
PROC GGSM_DEBUG_SET_PARENT_WIDGET_GROUP(WIDGET_GROUP_ID parentWidgetGroup)
	sGGSMData.widgetGroupExample = parentWidgetGroup	
ENDPROC

/// PURPOSE:
///    Entity Type Selector
/// PARAMS:
///    index - index for editing the type
PROC GGSM_BOSS_STATE_SELECTOR(INT &index, STRING str = NULL)		
	GGSM_BOSS_STATE eBet
	
	START_NEW_WIDGET_COMBO()
	REPEAT NUM_GGSM_BOSS_STATE eBet
		ADD_TO_WIDGET_COMBO(GGSM_BOSS_STATE_TO_STRING(eBet))
	ENDREPEAT
	
	IF (NOT IS_STRING_NULL_OR_EMPTY(str))
		STOP_WIDGET_COMBO(str, index)
	ELSE 
		STOP_WIDGET_COMBO("Boss State", index)
	ENDIF 
ENDPROC

/// PURPOSE:
///    Client Type Selector
/// PARAMS:
///    index - index for editing the type
PROC GGSM_STATE_SELECTOR(INT &index, STRING str = NULL)	
	GGSM_STATE eBet
	
	START_NEW_WIDGET_COMBO()
	REPEAT NUM_GGSM_STATE eBet
		ADD_TO_WIDGET_COMBO(GGSM_STATE_TO_STRING(eBet))
	ENDREPEAT
	
	IF (NOT IS_STRING_NULL_OR_EMPTY(str))
		STOP_WIDGET_COMBO(str, index)
	ELSE 
		STOP_WIDGET_COMBO("Client State", index)
	ENDIF 
ENDPROC

/// PURPOSE:
///    Client Type Selector
/// PARAMS:
///    index - index for editing the type
PROC GGSM_SUBSTATE_SELECTOR(INT &index, STRING str = NULL)	
	GGSM_SUBSTATE eBet
	
	START_NEW_WIDGET_COMBO()
	REPEAT NUM_GGSM_SUBSTATE eBet
		ADD_TO_WIDGET_COMBO(GGSM_SUBSTATE_TO_STRING(eBet))
	ENDREPEAT
	
	IF (NOT IS_STRING_NULL_OR_EMPTY(str))
		STOP_WIDGET_COMBO(str, index)
	ELSE 
		STOP_WIDGET_COMBO("Client Substate", index)
	ENDIF 
ENDPROC

/// PURPOSE:
///    Entity Type Selector
/// PARAMS:
///    index - index for editing the type
PROC GGSM_ENTITY_TYPE_SELECTOR(INT &index)	
	GGSM_ENTITY_TYPE eBet
	
	START_NEW_WIDGET_COMBO()
	REPEAT NUM_GGSM_ENTITY_TYPE eBet
		ADD_TO_WIDGET_COMBO(GGSM_ENTITY_TYPE_TO_STRING(eBet))
	ENDREPEAT
	STOP_WIDGET_COMBO("Entity Type", index)
ENDPROC

/// PURPOSE:
///    Tile collision Type Widget
/// PARAMS:
///    data - data to effect
PROC GGSM_TILE_COLLISION_TYPE_SELECTOR(INT &index)	
	GGSM_TILE_COLLISION_TYPE eBet
	
	START_NEW_WIDGET_COMBO()
	REPEAT NUM_GGSM_TILE_COLLISION_TYPE eBet
		ADD_TO_WIDGET_COMBO(GGSM_TILE_COLLISION_TYPE_TO_STRING(eBet))
	ENDREPEAT
	STOP_WIDGET_COMBO("Tile Collision Type", index)
ENDPROC

/// PURPOSE:
///    Entity Type Selector
/// PARAMS:
///    index - index for editing the type
PROC GGSM_UNLOCK_SELECTOR(INT &index)	
	GGSM_UNLOCK_TYPE eBet
	
	START_NEW_WIDGET_COMBO()
	REPEAT NUM_GGSM_UNLOCK_TYPE eBet
		ADD_TO_WIDGET_COMBO(GGSM_UNLOCK_TYPE_TO_STRING(eBet))
	ENDREPEAT
	STOP_WIDGET_COMBO("Unlock Type", index)
ENDPROC

/// PURPOSE:
///    Creates a read only 2D vector widget
/// PARAMS:
///    str - widget name
///    vec - vector
PROC GGSM_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 GGSM_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 GGSM_ADD_WIDGET_TRANSFORM_SLIDER(STRING str, GGSM_TRANSFORM &t)
	START_WIDGET_GROUP(str) 
		GGSM_ADD_WIDGET_VECTOR_2D_SLIDER("Position", t.vPosition, -cfBASE_SCREEN_WIDTH, cfBASE_SCREEN_WIDTH, 10)
		ADD_WIDGET_FLOAT_SLIDER("Rotation", t.fRotation, -720.0, 720.0, 1)
		GGSM_ADD_WIDGET_VECTOR_2D_SLIDER("Scale", t.vScale, -10.0, 10.0, 0.25)
	STOP_WIDGET_GROUP()
ENDPROC 

PROC GGSM_ADD_WIDGET_TRANSFORM_READ_ONLY(STRING str, GGSM_TRANSFORM &t)
	START_WIDGET_GROUP(str) 
		GGSM_ADD_WIDGET_VECTOR_2D_READONLY("Position", t.vPosition)
		ADD_WIDGET_FLOAT_READ_ONLY("Rotation", t.fRotation)
		GGSM_ADD_WIDGET_VECTOR_2D_READONLY("Scale", t.vScale)
	STOP_WIDGET_GROUP()
ENDPROC 

PROC GGSM_RGBA_COLOUR_STRUCT_WIDGET(RGBA_COLOUR_STRUCT &col, STRING str)
	START_WIDGET_GROUP(str)
		ADD_WIDGET_INT_SLIDER("Red", col.iR, 0, 255, 1)
		ADD_WIDGET_INT_SLIDER("Green", col.iG, 0, 255, 1)
		ADD_WIDGET_INT_SLIDER("Blue", col.iB, 0, 255, 1)
		ADD_WIDGET_INT_SLIDER("Alpha", col.iA, 0, 255, 1)
	STOP_WIDGET_GROUP()	
ENDPROC

PROC GGSM_BOSS_CONTROLLER_CREATE_WIDGET(GGSM_BOSS_CONTROLLER &boss, STRING str)
	INT i
	TEXT_LABEL_23 txt 
	
	START_WIDGET_GROUP(str)			
		ADD_WIDGET_BOOL("Change State", boss.bDebugSetState)
		GGSM_BOSS_STATE_SELECTOR(boss.iDebugSetState, "Change State")
		GGSM_BOSS_STATE_SELECTOR(boss.iCurrentState)
		ADD_WIDGET_FLOAT_READ_ONLY("State Timer", boss.fStateTimer)
		ADD_WIDGET_INT_READ_ONLY("HP", boss.iTotalHP)
		ADD_WIDGET_INT_READ_ONLY("Max HP", boss.iMaxTotalHP)
		ADD_WIDGET_INT_READ_ONLY("Group", boss.iGroupID)
		ADD_WIDGET_INT_READ_ONLY("Sub Group", boss.iSubGroupID)
		ADD_WIDGET_INT_READ_ONLY("Boss Pattern State", boss.iBossPatternState)
		ADD_BIT_FIELD_WIDGET("Summed HP Contributors", boss.iSummedMaxHPBitSet)
		ADD_BIT_FIELD_WIDGET("Used Pattern Bit Set", boss.iPatternUsedBitSet)
		ADD_WIDGET_INT_READ_ONLY("Boss Max Patterns", boss.iMaxPatterns)
		ADD_WIDGET_INT_READ_ONLY("Internal Counter", boss.iInternalCounter)
	
		START_WIDGET_GROUP("Entities")
			REPEAT GGSM_MAX_BOSS_PARTS i
				txt = "Entity "
				txt += i
				ADD_WIDGET_INT_READ_ONLY(txt, boss.iEntityIndex[i])
			ENDREPEAT
		STOP_WIDGET_GROUP()
	STOP_WIDGET_GROUP()
ENDPROC

PROC GGSM_CAMERA_CREATE_DEBUG_WIDGET(GGSM_CAMERA &sCamera)
	START_WIDGET_GROUP("Viewport Camera")
		GGSM_ADD_WIDGET_VECTOR_2D_READONLY("Viewport Offset", sCamera.vWorldViewportOffset)
		GGSM_ADD_WIDGET_VECTOR_2D_SLIDER("World Pos", sCamera.vWorldPosition, -10000000.0, 10000000.0, 4)	
		GGSM_ADD_WIDGET_VECTOR_2D_READONLY("Last World Pos", sCamera.vLastWorldPosition)
		GGSM_ADD_WIDGET_VECTOR_2D_SLIDER("Scroll Direction", sCamera.vScrollDirection, -1.0, 1.0, 0.001)
		ADD_WIDGET_FLOAT_SLIDER("Tile Scroll Speed", sCamera.fTileScrollSpeed, 0, 1000000, 1)
		ADD_WIDGET_FLOAT_READ_ONLY("Dist Travelled", sCamera.fDistTravelled)
		ADD_WIDGET_BOOL("Debug Move Camera", sCamera.bDebugMoveCamera)
		ADD_WIDGET_FLOAT_SLIDER("Move Camera Dist", sCamera.fDebugMoveCameraDist, 0, 1000000, 1)
		ADD_WIDGET_FLOAT_READ_ONLY("Spd", sCamera.fSpd)
	STOP_WIDGET_GROUP()
ENDPROC

/// PURPOSE:
///    Collsion Data Widget
/// PARAMS:
///    data - data to effect
PROC GGSM_COLLISION_DATA_WIDGET(GGSM_COLLISION_DATA &data)
	START_WIDGET_GROUP(GGSM_COLLISION_SHAPE_TO_STRING(data.eType))
		GGSM_ADD_WIDGET_VECTOR_2D_SLIDER("Vector 0", data.vCollisionVectors[0], -cfBASE_SCREEN_WIDTH, cfBASE_SCREEN_WIDTH, 1)
		GGSM_ADD_WIDGET_VECTOR_2D_SLIDER("Vector 1", data.vCollisionVectors[1], -cfBASE_SCREEN_WIDTH, cfBASE_SCREEN_WIDTH, 1)
		ADD_WIDGET_FLOAT_SLIDER("Col Radius", data.fColRadius, -cfBASE_SCREEN_WIDTH, cfBASE_SCREEN_WIDTH, 1)
	STOP_WIDGET_GROUP()
ENDPROC

PROC GGSM_ENTITY_WIDGET(GGSM_ENTITY &data, STRING str)
	INT i
	TEXT_LABEL_15 txt 
	
	START_WIDGET_GROUP(str)
		ADD_WIDGET_INT_READ_ONLY("Parent Index", data.iEntityParentIndex)
		ADD_WIDGET_INT_READ_ONLY("Group ID", data.iGroupID)
				
		ADD_WIDGET_INT_READ_ONLY("HP", data.iHP)
		ADD_WIDGET_INT_READ_ONLY("Inv Frame Time", data.iInvTimeMS)
		ADD_WIDGET_FLOAT_READ_ONLY("Anim Frame", data.fAnimFrame)
		ADD_WIDGET_FLOAT_READ_ONLY("Timer", data.fTimer)
		ADD_WIDGET_FLOAT_READ_ONLY("Explode Timer", data.fExplodeTimer)
		
		GGSM_ADD_WIDGET_TRANSFORM_SLIDER("Local", data.sLocal)
		GGSM_ADD_WIDGET_TRANSFORM_READ_ONLY("World", data.sWorld)

		START_WIDGET_GROUP("Movement")
			GGSM_ADD_WIDGET_VECTOR_2D_READONLY("Local Direction", data.vLocalDirection)
			ADD_WIDGET_FLOAT_SLIDER("Speed", data.fSpeed, 0, 20000, 1)
			
			START_WIDGET_GROUP("Move Params")
				REPEAT COUNT_OF(data.fMoveParam) i
					txt = "Param "
					txt += i
					ADD_WIDGET_FLOAT_READ_ONLY(txt, data.fMoveParam[i])
				ENDREPEAT 
			STOP_WIDGET_GROUP()	
		STOP_WIDGET_GROUP()
	
		START_WIDGET_GROUP("Weapon")
			ADD_WIDGET_INT_READ_ONLY("iWeaponBurstCounter", data.iWeaponBurstCounter)
			ADD_WIDGET_INT_READ_ONLY("iWeaponShotCounter", data.iWeaponShotCounter)
			ADD_WIDGET_FLOAT_READ_ONLY("Timer", data.fWeaponTimer)
		STOP_WIDGET_GROUP()	
	STOP_WIDGET_GROUP()	
ENDPROC

PROC GGSM_ENTITY_DATA_WIDGET(GGSM_ENTITY_DATA &data, GGSM_ENTITY_TYPE eType)
	START_WIDGET_GROUP(GGSM_ENTITY_TYPE_TO_STRING(eType))
		ADD_WIDGET_INT_SLIDER("HP", data.iMaxHP, 0, 1000, 1)	
		ADD_WIDGET_FLOAT_SLIDER("Base Speed", data.fBaseSpeed, 0, 8000, 1)
		GGSM_ADD_WIDGET_TRANSFORM_SLIDER("Gun Transform", data.sGunPos)
		GGSM_COLLISION_DATA_WIDGET(data.sCollisionData)
	STOP_WIDGET_GROUP()	
ENDPROC

PROC GGSM_PROJECTILE_WIDGET(GGSM_PROJECTILE &data, STRING str)
	START_WIDGET_GROUP(str)
		ADD_WIDGET_FLOAT_READ_ONLY("Timer", data.fTimer)
		ADD_WIDGET_INT_READ_ONLY("Target Index", data.iTargetIndex)
		GGSM_ADD_WIDGET_VECTOR_2D_READONLY("Point 0", data.sCollider.sData.vCollisionVectors[0])
		GGSM_ADD_WIDGET_VECTOR_2D_READONLY("Point 1", data.sCollider.sData.vCollisionVectors[1])
		ADD_WIDGET_FLOAT_SLIDER("Radius", data.sCollider.sData.fColRadius, -cfBASE_SCREEN_WIDTH, cfBASE_SCREEN_WIDTH, 1)
		ADD_WIDGET_FLOAT_SLIDER("Length", data.fLength, -cfBASE_SCREEN_WIDTH, cfBASE_SCREEN_WIDTH, 1)
	STOP_WIDGET_GROUP()	
ENDPROC

#IF GGSM_DEBUG_TSHIRT_HELP
PROC GGSM_CREATE_TSHIRT_DEBUG_WIDGET()
	START_WIDGET_GROUP("T-Shirt Debug")
		ADD_WIDGET_BOOL("bDebugResetUnlocks", sGGSMData.bDebugResetUnlocks)
		ADD_WIDGET_BOOL("bDebugShowUnlock", sGGSMData.bDebugShowUnlock)
		GGSM_UNLOCK_SELECTOR(sGGSMData.iDebugUnlockSelector)
	STOP_WIDGET_GROUP()
ENDPROC 

PROC GGSM_UPDATE_TSHIRT_DEBUG_WIDGET()
	GGSM_UNLOCK_TYPE eType 
	
	IF (sGGSMData.bDebugResetUnlocks)
		SET_MP_INT_CHARACTER_STAT(MP_STAT_ARCADE_HELP_BITSET, 0)
		sGGSMData.bDebugResetUnlocks = FALSE 
	ENDIF 
	
	IF (sGGSMData.bDebugShowUnlock)
		eType = INT_TO_ENUM(GGSM_UNLOCK_TYPE, sGGSMData.iDebugUnlockSelector)
		GGSM_UNLOCK_PRIZE(eType)
		sGGSMData.bDebugShowUnlock = FALSE 
	ENDIF 
ENDPROC
#ENDIF 

#IF GGSM_CHALLENGE_DEBUG
PROC GGSM_CREATE_CHALLENGE_DEBUG_WIDGET()
	START_WIDGET_GROUP("Challenge Debug")
		ADD_WIDGET_BOOL("Reset", sGGSMData.bDebugResetChallenge)
		ADD_WIDGET_BOOL("Show Awards", sGGSMData.bDebugShowAwardsOnScreen)
		ADD_WIDGET_BOOL("ApeEscape", sGGSMData.bDebugChallengeApeEscape)
		ADD_WIDGET_BOOL("MonkeyMind", sGGSMData.bDebugChallengeMonkeyMind)
		ADD_WIDGET_BOOL("AstroChimp B", sGGSMData.bDebugChallengeAstroChimpB)
		ADD_WIDGET_BOOL("AstroChimp S", sGGSMData.bDebugChallengeAstroChimpS)
		ADD_WIDGET_BOOL("AstroChimp G", sGGSMData.bDebugChallengeAstroChimpG)
		ADD_WIDGET_BOOL("AstroChimp P", sGGSMData.bDebugChallengeAstroChimpP)
		ADD_WIDGET_BOOL("AquaApe", sGGSMData.bDebugChallengeAquaApe)
		ADD_WIDGET_BOOL("Award All", sGGSMData.bDebugAwardAllChallenges)
	STOP_WIDGET_GROUP()
ENDPROC 

PROC GGSM_UPDATE_CHALLENGE_DEBUG_WIDGET()	
	IF (sGGSMData.bDebugResetChallenge)
		GGSM_RESET_CHALLENGES()
		sGGSMData.bDebugResetChallenge = FALSE 
	ENDIF 
	
	IF (sGGSMData.bDebugChallengeApeEscape)
		GGSM_SET_CHALLENGE_COMPLETED(GGSM_CHALLENGE_BIT_APE_ESCAPE)
		sGGSMData.bDebugChallengeApeEscape = FALSE 
	ENDIF 
	
	IF (sGGSMData.bDebugChallengeMonkeyMind)
		GGSM_SET_CHALLENGE_COMPLETED(GGSM_CHALLENGE_BIT_MONKEY_MIND)
		sGGSMData.bDebugChallengeMonkeyMind = FALSE 
	ENDIF 
	
	IF (sGGSMData.bDebugChallengeAstroChimpB)
		GGSM_SET_CHALLENGE_COMPLETED(GGSM_CHALLENGE_BIT_ASTROCHIMP_B)
		sGGSMData.bDebugChallengeAstroChimpB = FALSE 
	ENDIF 
	
	IF (sGGSMData.bDebugChallengeAstroChimpS)
		GGSM_SET_CHALLENGE_COMPLETED(GGSM_CHALLENGE_BIT_ASTROCHIMP_S)
		sGGSMData.bDebugChallengeAstroChimpS = FALSE 
	ENDIF 
	
	IF (sGGSMData.bDebugChallengeAstroChimpG)
		GGSM_SET_CHALLENGE_COMPLETED(GGSM_CHALLENGE_BIT_ASTROCHIMP_G)
		sGGSMData.bDebugChallengeAstroChimpG = FALSE 
	ENDIF 
	
	IF (sGGSMData.bDebugChallengeAstroChimpP)
		GGSM_SET_CHALLENGE_COMPLETED(GGSM_CHALLENGE_BIT_ASTROCHIMP_P)
		sGGSMData.bDebugChallengeAstroChimpP = FALSE 
	ENDIF 
	
	IF (sGGSMData.bDebugAwardAllChallenges)
		GGSM_RESET_CHALLENGES()
		GGSM_SET_CHALLENGE_COMPLETED(GGSM_CHALLENGE_BIT_APE_ESCAPE)
		GGSM_SET_CHALLENGE_COMPLETED(GGSM_CHALLENGE_BIT_ASTROCHIMP_B)
		GGSM_SET_CHALLENGE_COMPLETED(GGSM_CHALLENGE_BIT_ASTROCHIMP_S)
		GGSM_SET_CHALLENGE_COMPLETED(GGSM_CHALLENGE_BIT_ASTROCHIMP_G)
		GGSM_SET_CHALLENGE_COMPLETED(GGSM_CHALLENGE_BIT_ASTROCHIMP_P)
		GGSM_SET_CHALLENGE_COMPLETED(GGSM_CHALLENGE_BIT_MONKEY_MIND)
		sGGSMData.bDebugAwardAllChallenges = FALSE 
	ENDIF 
	
	IF (sGGSMData.bDebugShowAwardsOnScreen)
		GGSM_DRAW_AWARD_DEBUG()
	ENDIF 
ENDPROC
#ENDIF 

//-------------------------------------------------
// EDITOR CORE DEBUG FUNCTIONS
//-------------------------------------------------

FUNC BOOL GGSM_EDITOR_CORE_IS_EDITOR_ACTIVE(GGSM_EDITOR_CORE &editor)
	RETURN editor.bEditorActive
ENDFUNC 

FUNC BOOL GGSM_EDITOR_CORE_IS_EDITOR_LAST_ACTIVE(GGSM_EDITOR_CORE &editor)
	RETURN editor.bLastEditorActive
ENDFUNC 

PROC GGSM_EDITOR_CORE_FINALISE_FOR_FRAME_END(GGSM_EDITOR_CORE &editor)
	editor.iLastEditDatam = editor.iCurrentEditDatam
	editor.iLastEditIndex = editor.iCurrentEditIndex
	editor.bLastEditorActive = editor.bEditorActive
	editor.bLastPauseState = sGGSMData.bGamePaused
ENDPROC 

PROC GGSM_EDITOR_CORE_SET_EDITOR_BIT(GGSM_EDITOR_CORE &editor, GGSM_EDITOR_BIT eBit)
	SET_BITMASK_ENUM_AS_ENUM(editor.eFlags, eBit)
	CPRINTLN(DEBUG_MINIGAME, "GGSM_EDITOR_CORE_SET_EDITOR_BIT - ", GGSM_EDITOR_BIT_TO_STRING(eBit))
ENDPROC

PROC GGSM_EDITOR_CORE_CLEAR_EDITOR_BIT(GGSM_EDITOR_CORE &editor, GGSM_EDITOR_BIT eBit)
	CLEAR_BITMASK_ENUM_AS_ENUM(editor.eFlags, eBit)
	CPRINTLN(DEBUG_MINIGAME, "GGSM_EDITOR_CORE_CLEAR_EDITOR_BIT - ", GGSM_EDITOR_BIT_TO_STRING(eBit))
ENDPROC

FUNC BOOL GGSM_EDITOR_CORE_EDIT_INT_PARAM(GGSM_EDITOR_CORE &editor, INT &iValue, INT max, INT iIgnoreValue = -1)
	IF IS_DISABLED_CONTROL_JUST_PRESSED(FRONTEND_CONTROL, INPUT_SCRIPT_PAD_LEFT)
		iValue --
		IF (iValue < 0)
			iValue = max - 1
		ENDIF 
		
		IF (editor.iOption != iIgnoreValue)
			CLEAR_BITMASK_ENUM_AS_ENUM(editor.eFlags, GGSM_EDITOR_BIT_SAVED)
		ENDIF 
		
		RETURN TRUE 
	ENDIF 
	
	IF IS_DISABLED_CONTROL_JUST_PRESSED(FRONTEND_CONTROL, INPUT_SCRIPT_PAD_RIGHT)
		iValue ++
		IF (iValue >= max)
			iValue = 0
		ENDIF
		
		IF (editor.iOption != iIgnoreValue)
			CLEAR_BITMASK_ENUM_AS_ENUM(editor.eFlags, GGSM_EDITOR_BIT_SAVED)
		ENDIF 
		
		RETURN TRUE
	ENDIF 
	
	RETURN FALSE
ENDFUNC  

FUNC BOOL GGSM_EDITOR_CORE_EDIT_INT_MIN_MAX(GGSM_EDITOR_CORE &editor, INT &iValue, INT min, INT max, INT iIgnoreValue = -1)
	IF IS_DISABLED_CONTROL_JUST_PRESSED(FRONTEND_CONTROL, INPUT_SCRIPT_PAD_LEFT)
		iValue --
		IF (iValue < min)
			iValue = max - 1
		ENDIF 
		
		IF (editor.iOption != iIgnoreValue)
			CLEAR_BITMASK_ENUM_AS_ENUM(editor.eFlags, GGSM_EDITOR_BIT_SAVED)
		ENDIF 
		
		RETURN TRUE 
	ENDIF 
	
	IF IS_DISABLED_CONTROL_JUST_PRESSED(FRONTEND_CONTROL, INPUT_SCRIPT_PAD_RIGHT)
		iValue ++
		IF (iValue >= max)
			iValue = min
		ENDIF
		
		IF (editor.iOption != iIgnoreValue)
			CLEAR_BITMASK_ENUM_AS_ENUM(editor.eFlags, GGSM_EDITOR_BIT_SAVED)
		ENDIF 
		
		RETURN TRUE
	ENDIF 
	
	RETURN FALSE
ENDFUNC  

PROC GGSM_EDITOR_CORE_EDIT_FLOAT_MIN_MAX(GGSM_EDITOR_CORE &editor, FLOAT &iValue, FLOAT inc, FLOAT min, FLOAT max, INT iIgnoreValue = -1)
	IF IS_DISABLED_CONTROL_JUST_PRESSED(FRONTEND_CONTROL, INPUT_SCRIPT_PAD_LEFT)
		iValue -= inc
		IF (iValue < min)
			iValue = max
		ENDIF 
		
		IF (editor.iOption != iIgnoreValue)
			CLEAR_BITMASK_ENUM_AS_ENUM(editor.eFlags, GGSM_EDITOR_BIT_SAVED)
		ENDIF 
	ENDIF 
	
	IF IS_DISABLED_CONTROL_JUST_PRESSED(FRONTEND_CONTROL, INPUT_SCRIPT_PAD_RIGHT)
		iValue += inc
		IF (iValue > max)
			iValue = min
		ENDIF
		
		IF (editor.iOption != iIgnoreValue)
			CLEAR_BITMASK_ENUM_AS_ENUM(editor.eFlags, GGSM_EDITOR_BIT_SAVED)
		ENDIF 
	ENDIF 
ENDPROC 

PROC GGSM_EDITOR_CORE_PICK_OPTION(GGSM_EDITOR_CORE &editor, INT iMaxOption)
	// options
	IF IS_DISABLED_CONTROL_JUST_PRESSED(FRONTEND_CONTROL, INPUT_SCRIPT_PAD_UP)
		editor.iOption --
		IF (editor.iOption < 0)
			editor.iOption = iMaxOption - 1
		ENDIF 
	ENDIF 
	
	IF IS_DISABLED_CONTROL_JUST_PRESSED(FRONTEND_CONTROL, INPUT_SCRIPT_PAD_DOWN)
		editor.iOption ++
		IF (editor.iOption >= iMaxOption)
			editor.iOption = 0
		ENDIF 
	ENDIF 
ENDPROC 

PROC GGSM_EDITOR_CORE_SHARED_UPDATE(GGSM_EDITOR_CORE &editor)

	IF (editor.iLastEditIndex != editor.iCurrentEditIndex)
		GGSM_EDITOR_CORE_SET_EDITOR_BIT(editor, GGSM_EDITOR_BIT_COPY_FROM_DATA)
	ENDIF 
		
	IF IS_DISABLED_CONTROL_JUST_PRESSED(FRONTEND_CONTROL, INPUT_SCRIPT_RLEFT)
		GGSM_EDITOR_CORE_SET_EDITOR_BIT(editor, GGSM_EDITOR_BIT_COPY_TO_DATA)
	ENDIF 

	IF IS_DISABLED_CONTROL_JUST_PRESSED(FRONTEND_CONTROL, INPUT_SCRIPT_RRIGHT)
		GGSM_EDITOR_CORE_SET_EDITOR_BIT(editor, GGSM_EDITOR_BIT_COPY_FROM_DATA)
	ENDIF 
	
	IF IS_DISABLED_CONTROL_JUST_PRESSED(FRONTEND_CONTROL, INPUT_SCRIPT_RDOWN)
		GGSM_EDITOR_CORE_SET_EDITOR_BIT(editor, GGSM_EDITOR_BIT_TEST_SYSTEM)
	ENDIF 
	
	IF IS_DISABLED_CONTROL_JUST_PRESSED(FRONTEND_CONTROL, INPUT_SCRIPT_RUP)
		GGSM_EDITOR_CORE_SET_EDITOR_BIT(editor, GGSM_EDITOR_BIT_EXPORT)
	ENDIF 
	
	IF IS_DISABLED_CONTROL_JUST_PRESSED(FRONTEND_CONTROL, INPUT_SCRIPT_SELECT)
		sGGSMData.bGamePaused = !sGGSMData.bGamePaused
	ENDIF 
ENDPROC

//-------------------------------------------------
// EDITOR TEST DEBUG FUNCTIONS
//-------------------------------------------------
#IF GGSM_ENTITY_EDITOR_ACTIVE
PROC GGSM_ENTITY_EDITOR_WIDGET_UPDATE(GGSM_ENTITY_EDITOR &editor)
	
	IF (editor.sEditCore.bEditorActive = TRUE)
		IF (editor.sEditCore.bLastEditorActive = FALSE)
			GGSM_EDITOR_CORE_SET_EDITOR_BIT(editor.sEditCore, GGSM_EDITOR_BIT_COPY_FROM_DATA)
			sGGSMData.bGamePaused = TRUE		
		ENDIF
		
		DISABLE_PLAYER_CONTROLS_THIS_FRAME()
		GGSM_SET_PLAYER_INVUNERABLE()	
		
		GGSM_EDITOR_CORE_SHARED_UPDATE(editor.sEditCore)
		GGSM_EDITOR_CORE_PICK_OPTION(editor.sEditCore, GGSM_ENTITY_EDITOR_OPTION_MAX)
		
		// handle options
		SWITCH (editor.sEditCore.iOption)
			CASE GGSM_ENTITY_EDITOR_OPTION_DATA_SELECT
				IF GGSM_EDITOR_CORE_EDIT_INT_PARAM(editor.sEditCore, editor.sEditCore.iCurrentEditIndex, ENUM_TO_INT(NUM_GGSM_ENTITY_TYPE))
					GGSM_EDITOR_CORE_SET_EDITOR_BIT(editor.sEditCore, GGSM_EDITOR_BIT_COPY_FROM_DATA)
				ENDIF
			BREAK
		ENDSWITCH	
		
		IF IS_BITMASK_ENUM_AS_ENUM_SET(editor.sEditCore.eFlags, GGSM_EDITOR_BIT_COPY_FROM_DATA)
			editor.eEditType = INT_TO_ENUM(GGSM_ENTITY_TYPE, editor.sEditCore.iCurrentEditIndex)
			editor.sEditData = GGSM_ENTITY_DATA_GET(editor.eEditType)
			GGSM_EDITOR_CORE_CLEAR_EDITOR_BIT(editor.sEditCore, GGSM_EDITOR_BIT_COPY_FROM_DATA)
			GGSM_ENTITY_RESET(editor.sTestEntity)
			GGSM_ENTITY_INIT(editor.sTestEntity, editor.eEditType, INIT_VECTOR_2D(cfBASE_SCREEN_HALF_WIDTH, cfBASE_SCREEN_HALF_HEIGHT), 0, TRUE)
		ENDIF 
		
		// handle point movement
		SWITCH (editor.sEditCore.iOption)
			CASE GGSM_ENTITY_EDITOR_OPTION_POINT_EDIT
				GGSM_ALTER_POINT_WITH_INPUT(editor.sEditData.sCollisionData.vCollisionVectors[0], 128.0, GGSM_INPUT_LSTICK)
				GGSM_ALTER_POINT_WITH_INPUT(editor.sEditData.sCollisionData.vCollisionVectors[1], 128.0, GGSM_INPUT_RSTICK)
			BREAK 
			CASE GGSM_ENTITY_EDITOR_OPTION_RADIUS_SELECT
				GGSM_ALTER_FLOAT_WITH_INPUT(editor.sEditData.sCollisionData.fColRadius, 128.0, GGSM_INPUT_LSTICK)
			BREAK 
			CASE GGSM_ENTITY_EDITOR_OPTION_GUNPOS_SELECT
				GGSM_ALTER_POINT_WITH_INPUT(editor.sEditData.sGunPos.vPosition, 128.0, GGSM_INPUT_LSTICK)
				GGSM_ALTER_FLOAT_WITH_INPUT(editor.sEditData.sGunPos.fRotation, 360.0, GGSM_INPUT_RSTICK)
			BREAK 
		ENDSWITCH 
		
		IF IS_DISABLED_CONTROL_JUST_PRESSED(FRONTEND_CONTROL, INPUT_SCRIPT_RDOWN)
			GGSM_EDITOR_CORE_SET_EDITOR_BIT(editor.sEditCore, GGSM_EDITOR_BIT_COPY_TO_DATA)
		ENDIF 		
		
		IF IS_BITMASK_ENUM_AS_ENUM_SET(editor.sEditCore.eFlags, GGSM_EDITOR_BIT_COPY_TO_DATA)
			editor.eEditType = INT_TO_ENUM(GGSM_ENTITY_TYPE, editor.sEditCore.iCurrentEditIndex)
			
			GGSM_EDITOR_CORE_CLEAR_EDITOR_BIT(editor.sEditCore, GGSM_EDITOR_BIT_COPY_TO_DATA)
			GGSM_EDITOR_CORE_SET_EDITOR_BIT(editor.sEditCore, GGSM_EDITOR_BIT_SAVED)
			GGSM_ENTITY_RESET(editor.sTestEntity)
			GGSM_ENTITY_INIT(editor.sTestEntity, editor.eEditType, INIT_VECTOR_2D(cfBASE_SCREEN_HALF_WIDTH, cfBASE_SCREEN_HALF_HEIGHT), 0, TRUE)
		ENDIF 
		
		IF IS_BITMASK_ENUM_AS_ENUM_SET(editor.sEditCore.eFlags, GGSM_EDITOR_BIT_EXPORT)
			GGSM_EDITOR_CORE_CLEAR_EDITOR_BIT(editor.sEditCore, GGSM_EDITOR_BIT_EXPORT)
			GGSM_EDITOR_CORE_SET_EDITOR_BIT(editor.sEditCore, GGSM_EDITOR_BIT_SAVED)
		ENDIF 
		
		editor.sDebugEntData[editor.eEditType] = editor.sEditData
		GGSM_ENTITY_UPDATE(editor.sTestEntity)
		GGSM_DRAW_ENTITY_EDITOR(editor) 
	ELSE 
		IF (editor.sEditCore.bLastEditorActive != editor.sEditCore.bEditorActive)
			sGGSMData.bGamePaused = FALSE 
		ENDIF 	
	ENDIF 
	
	GGSM_EDITOR_CORE_FINALISE_FOR_FRAME_END(editor.sEditCore) 
ENDPROC
#ENDIF 

#IF GGSM_SPAWN_EDITOR_ACTIVE
PROC GGSM_SPAWN_EDITOR_WIDGET_UPDATE(GGSM_SPAWN_EDITOR &editor)

	// check right stick
	VECTOR_2D vec = INIT_VECTOR_2D(GET_DISABLED_CONTROL_NORMAL(FRONTEND_CONTROL, INPUT_SCRIPT_RIGHT_AXIS_X), GET_DISABLED_CONTROL_NORMAL(FRONTEND_CONTROL, INPUT_SCRIPT_RIGHT_AXIS_Y))
	FLOAT len = VECTOR_2D_MAG(vec)
	INT iGroupID = -1
	INT ind 
		
	IF (editor.sEditCore.bEditorActive = TRUE)
		IF (editor.sEditCore.bLastEditorActive = FALSE)
			GGSM_EDITOR_CORE_SET_EDITOR_BIT(editor.sEditCore, GGSM_EDITOR_BIT_COPY_FROM_DATA)
			GGSM_RESET_FOR_STAGE_START(FALSE)
			sGGSMData.bGamePaused = TRUE		
		ENDIF
		
		IF IS_CONTROL_HELD(sGGSMData.sStartBtnTimer)
			sGGSMData.bGamePaused = FALSE 
			editor.sEditCore.bEditorActive = FALSE 
			GGSM_SET_CLIENT_STATE(GGSM_STATE_STAGE_ACTIVE)
			EXIT 
		ENDIF 
		
		DISABLE_PLAYER_CONTROLS_THIS_FRAME()
		GGSM_SET_PLAYER_INVUNERABLE()			
		GGSM_EDITOR_CORE_SHARED_UPDATE(editor.sEditCore)
		GGSM_EDITOR_CORE_PICK_OPTION(editor.sEditCore, GGSM_SPAWN_EDITOR_OPTION_MAX)
		
		IF (len >= 0.9)
			editor.fFormAngle = GET_HEADING_FROM_VECTOR_2D(vec.x, vec.y)
		ENDIF 
		
		// options
		SWITCH (editor.sEditCore.iOption)
			CASE GGSM_SPAWN_EDITOR_OPTION_DATA_SELECT
				IF GGSM_EDITOR_CORE_EDIT_INT_PARAM(editor.sEditCore, editor.sEditCore.iCurrentEditIndex, GGSM_MAX_SPAWN_DATA)
					GGSM_EDITOR_CORE_SET_EDITOR_BIT(editor.sEditCore, GGSM_EDITOR_BIT_COPY_FROM_DATA)
				ENDIF			
			BREAK		
			CASE GGSM_SPAWN_EDITOR_OPTION_FORMATION_SELECT
				GGSM_EDITOR_CORE_EDIT_INT_PARAM(editor.sEditCore, editor.iFormationType, ENUM_TO_INT(NUM_GGSM_FORMATION_TYPE), GGSM_SPAWN_EDITOR_OPTION_FORMATION_SELECT)
			BREAK
			
			CASE GGSM_SPAWN_EDITOR_OPTION_ENTITY_SELECT
				GGSM_EDITOR_CORE_EDIT_INT_PARAM(editor.sEditCore, editor.iEntityType, ENUM_TO_INT(NUM_GGSM_ENTITY_TYPE))
			BREAK 
			
			CASE GGSM_SPAWN_EDITOR_OPTION_MOVEMENT_SELECT
				GGSM_EDITOR_CORE_EDIT_INT_PARAM(editor.sEditCore, editor.iMoveType, ENUM_TO_INT(NUM_GGSM_MOVEMENT_TYPE))
			BREAK 
			
			CASE GGSM_SPAWN_EDITOR_OPTION_WEAPON_SELECT
				GGSM_EDITOR_CORE_EDIT_INT_PARAM(editor.sEditCore, editor.iWeaponType, ENUM_TO_INT(NUM_GGSM_WEAPON_TYPE))
			BREAK
			
			CASE GGSM_SPAWN_EDITOR_OPTION_UNITCOUNT_SELECT
				GGSM_EDITOR_CORE_EDIT_INT_PARAM(editor.sEditCore, editor.sEditData.iFormationMembers, GGSM_MAX_ENEMIES)
			BREAK 
			
			CASE GGSM_SPAWN_EDITOR_OPTION_XSPACE_SELECT
				GGSM_EDITOR_CORE_EDIT_FLOAT_MIN_MAX(editor.sEditCore, editor.sEditData.vSpacing.x, 0.125, 0.125, 4.0, GGSM_SPAWN_EDITOR_OPTION_FORMATION_SELECT)
			BREAK 

			CASE GGSM_SPAWN_EDITOR_OPTION_YSPACE_SELECT
				GGSM_EDITOR_CORE_EDIT_FLOAT_MIN_MAX(editor.sEditCore, editor.sEditData.vSpacing.y, 0.125, 0.125, 4.0, GGSM_SPAWN_EDITOR_OPTION_FORMATION_SELECT)
			BREAK 
			
			CASE GGSM_SPAWN_EDITOR_OPTION_PATH_SELECT
				IF (editor.iFormationType != ENUM_TO_INT(GGSM_FORMATION_POWER_UP))
					GGSM_EDITOR_CORE_EDIT_INT_MIN_MAX(editor.sEditCore, editor.sEditData.iPathNumber, -1, GGSM_MAX_PATH_LIBRARY)
				ELSE 
					GGSM_EDITOR_CORE_EDIT_INT_PARAM(editor.sEditCore, editor.sEditData.iPathNumber, GGSM_NUM_POWER_UPS)
				ENDIF
			BREAK 
			
			CASE GGSM_SPAWN_EDITOR_OPTION_FORMATION_SHIFT
				GGSM_EDITOR_CORE_EDIT_FLOAT_MIN_MAX(editor.sEditCore, editor.fFormShift, 50.0, -10000.0, 10000.0, GGSM_SPAWN_EDITOR_OPTION_FORMATION_SELECT)
			BREAK 
		ENDSWITCH
		
		// shift the camera forward and backward
		IF IS_DISABLED_CONTROL_JUST_PRESSED(FRONTEND_CONTROL, INPUT_SCRIPT_LB)
			GGSM_RESET_FOR_STAGE_START(FALSE)
			editor.sEditCore.iActiveTestGroup = -1
		ENDIF 
		
		IF IS_DISABLED_CONTROL_PRESSED(FRONTEND_CONTROL, INPUT_SCRIPT_RT)
			sGGSMData.sCamera.vWorldPosition.x += (700.0 * GET_FRAME_TIME())
			sGGSMData.sCamera.fDistTravelled += (700.0 * GET_FRAME_TIME())
			sGGSMData.sCamera.vLastWorldPosition = sGGSMData.sCamera.vWorldPosition
		ENDIF 
		
		IF IS_DISABLED_CONTROL_PRESSED(FRONTEND_CONTROL, INPUT_SCRIPT_RB)
			sGGSMData.sCamera.vWorldPosition.x -= (700.0 * GET_FRAME_TIME())
			sGGSMData.sCamera.fDistTravelled -= (700.0 * GET_FRAME_TIME())
			sGGSMData.sCamera.vLastWorldPosition = sGGSMData.sCamera.vWorldPosition
		ENDIF 
		
		IF IS_DISABLED_CONTROL_JUST_PRESSED(FRONTEND_CONTROL, INPUT_SCRIPT_LT) 
			IF (editor.sEditCore.iOption != GGSM_SPAWN_EDITOR_OPTION_FORMATION_SHIFT)
				ind = GGSM_GET_FREE_FORMATION_SLOT(sGGSMData.sSpawnData)
				IF (ind != -1)
					editor.sEditCore.iCurrentEditIndex = ind
					editor.sEditCore.iLastEditIndex = ind 
				ENDIF 
			ELSE 
				GGSM_SHIFT_FORMATION_DATA_ARRAY(sGGSMData.sSpawnData, editor.fFormShift, editor.sEditCore.iCurrentEditIndex)
			ENDIF
		ENDIF 
		
		// handle point movement
		GGSM_ALTER_POINT_WITH_INPUT(editor.vFormPosition, 700.0)
		editor.vFormPosition.x = CLAMP(editor.vFormPosition.x, -cfBASE_SCREEN_WIDTH, cfBASE_SCREEN_WIDTH)
		editor.vFormPosition.y = CLAMP(editor.vFormPosition.y, -cfBASE_SCREEN_WIDTH, cfBASE_SCREEN_WIDTH)
		
		// copy data from array
		IF IS_BITMASK_ENUM_AS_ENUM_SET(editor.sEditCore.eFlags, GGSM_EDITOR_BIT_COPY_FROM_DATA)
			editor.sEditData = sGGSMData.sSpawnData[editor.sEditCore.iCurrentEditIndex]
			editor.iEntityType = ENUM_TO_INT(GGSM_FORMATION_GET_ENTITY_TYPE(editor.sEditData))
			editor.iFormationType = ENUM_TO_INT(GGSM_FORMATION_GET_TYPE(editor.sEditData))
			editor.iMoveType = ENUM_TO_INT(GGSM_FORMATION_GET_MOVEMENT_TYPE(editor.sEditData))
			editor.iWeaponType = ENUM_TO_INT(GGSM_FORMATION_GET_WEAPON_TYPE(editor.sEditData))
			
			vec = GGSM_FORMATION_GET_START_DIRECTION(editor.sEditData)
			editor.fFormAngle = GET_HEADING_FROM_VECTOR_2D(vec.x, vec.y)
			editor.vFormPosition = GGSM_FORMATION_GET_START_POSITION(editor.sEditData)
			GGSM_RESET_FOR_STAGE_START(FALSE, editor.sEditData.fScrollDistance)
			sGGSMData.iSpawnIndexCounter = editor.sEditCore.iCurrentEditIndex
			GGSM_EDITOR_CORE_CLEAR_EDITOR_BIT(editor.sEditCore, GGSM_EDITOR_BIT_COPY_FROM_DATA)
		ENDIF 
	
		// copy data to array 
		IF IS_BITMASK_ENUM_AS_ENUM_SET(editor.sEditCore.eFlags, GGSM_EDITOR_BIT_COPY_TO_DATA)	
			vec = GGSM_ROTATE_VECTOR_2D_ABOUT_Z(INIT_VECTOR_2D(0, 1), editor.fFormAngle)			
			GGSM_FORMATION_SET_SCROLL_DISTANCE(editor.sEditData, sGGSMData.sCamera.fDistTravelled)
			GGSM_FORMATION_SET_START_POSITION(editor.sEditData, editor.vFormPosition.x, editor.vFormPosition.y)
			GGSM_FORMATION_SET_START_DIRECTION(editor.sEditData, vec.x, vec.y)
			sGGSMData.sSpawnData[editor.sEditCore.iCurrentEditIndex] = editor.sEditData
			
			GGSM_QUICK_SORT_FORMATION_DATA_ARRAY(sGGSMData.sSpawnData)
			editor.sEditCore.iCurrentEditIndex = GGSM_FIND_FORMATION_SLOT_AT_DISTANCE(sGGSMData.sSpawnData, editor.sEditData.fScrollDistance)
			GGSM_EDITOR_CORE_CLEAR_EDITOR_BIT(editor.sEditCore, GGSM_EDITOR_BIT_COPY_TO_DATA)
			GGSM_EDITOR_CORE_SET_EDITOR_BIT(editor.sEditCore, GGSM_EDITOR_BIT_SAVED)
		ENDIF
		
		// update dropdowns
		GGSM_FORMATION_SET_TYPE(editor.sEditData, INT_TO_ENUM(GGSM_FORMATION_TYPE, editor.iFormationType))
		GGSM_FORMATION_SET_ENTITY_TYPE(editor.sEditData, INT_TO_ENUM(GGSM_ENTITY_TYPE, editor.iEntityType))
		GGSM_FORMATION_SET_MOVEMENT_TYPE(editor.sEditData, INT_TO_ENUM(GGSM_MOVEMENT_TYPE, editor.iMoveType))
		GGSM_FORMATION_SET_WEAPON_TYPE(editor.sEditData, INT_TO_ENUM(GGSM_WEAPON_TYPE, editor.iWeaponType))

		// test formation
		IF IS_BITMASK_ENUM_AS_ENUM_SET(editor.sEditCore.eFlags, GGSM_EDITOR_BIT_TEST_SYSTEM)	
			vec = GGSM_ROTATE_VECTOR_2D_ABOUT_Z(INIT_VECTOR_2D(0, 1), editor.fFormAngle)			
			GGSM_FORMATION_SET_START_DIRECTION(editor.sEditData, vec.x, vec.y)
			GGSM_FORMATION_SET_START_POSITION(editor.sEditData, editor.vFormPosition.x, editor.vFormPosition.y)
			
			iGroupID = GGSM_GET_FREE_ENTITY_GROUP(sGGSMData.sEntityGroup)
			IF (iGroupID != GGSM_INVALID_GROUP_ID)
				editor.sEditCore.iActiveTestGroup = iGroupID
				GGSM_FORMATION_SET_SCROLL_DISTANCE(editor.sEditData, sGGSMData.sCamera.fDistTravelled)
				GGSM_ACTIVATE_ENTITY_GROUP_AS_FORMATION(sGGSMData.sEntityGroup[iGroupID], editor.sEditData)
			ENDIF 
			
			GGSM_EDITOR_CORE_SET_EDITOR_BIT(editor.sEditCore, GGSM_EDITOR_BIT_COPY_TO_DATA)
			GGSM_EDITOR_CORE_CLEAR_EDITOR_BIT(editor.sEditCore, GGSM_EDITOR_BIT_TEST_SYSTEM)
		ENDIF 

		// update scroll while test is active
		IF (editor.sEditCore.iActiveTestGroup != GGSM_INVALID_GROUP_ID)
			IF GGSM_ENTITY_GROUP_IS_RUNNING(sGGSMData.sEntityGroup[editor.sEditCore.iActiveTestGroup])
				sGGSMData.bGamePaused = FALSE 
			ENDIF
			
			IF GGSM_ENTITY_GROUP_HAS_GROUP_FINISHED(sGGSMData.sEntityGroup[editor.sEditCore.iActiveTestGroup])
				GGSM_RESET_FOR_STAGE_START(FALSE, editor.sEditData.fScrollDistance)
				editor.sEditCore.iActiveTestGroup = GGSM_INVALID_GROUP_ID
				sGGSMData.bGamePaused = TRUE
			ENDIF		
		ENDIF 
		
		// export
		IF IS_BITMASK_ENUM_AS_ENUM_SET(editor.sEditCore.eFlags, GGSM_EDITOR_BIT_EXPORT)	
			GGSM_QUICK_SORT_FORMATION_DATA_ARRAY(sGGSMData.sSpawnData)
			GGSM_DEBUG_EXPORT_FORMATION_ARRAY_TO_SCRIPT(sGGSMData.sSpawnData, DEFAULT, TRUE)
			GGSM_EDITOR_CORE_CLEAR_EDITOR_BIT(editor.sEditCore, GGSM_EDITOR_BIT_EXPORT)
			GGSM_EDITOR_CORE_SET_EDITOR_BIT(editor.sEditCore, GGSM_EDITOR_BIT_SAVED)
		ENDIF
		
		GGSM_DRAW_SPAWN_EDITOR(editor)
	ELSE 
		IF (editor.sEditCore.bLastEditorActive != editor.sEditCore.bEditorActive)
			sGGSMData.bGamePaused = FALSE 
		ENDIF 	
	ENDIF 
	
	GGSM_EDITOR_CORE_FINALISE_FOR_FRAME_END(editor.sEditCore) 
ENDPROC
#ENDIF 

#IF GGSM_TILEMAP_EDITOR_ACTIVE
PROC GGSM_TILEMAP_EDITOR_WIDGET_UPDATE(GGSM_TILEMAP_EDITOR &editor, GGSM_TILEMAP &tm)
	IF (editor.sEditCore.bEditorActive = TRUE)
		IF (editor.sEditCore.bLastEditorActive = FALSE)
			GGSM_RESET_FOR_STAGE_START(FALSE)
			sGGSMData.bGamePaused = TRUE
		ENDIF
		
		sGGSMData.bDrawCollisionDebug = TRUE
		DISABLE_PLAYER_CONTROLS_THIS_FRAME()
		GGSM_SET_PLAYER_INVUNERABLE()			
		GGSM_EDITOR_CORE_SHARED_UPDATE(editor.sEditCore)
		
		IF IS_DISABLED_CONTROL_PRESSED(FRONTEND_CONTROL, INPUT_SCRIPT_RT)
			GGSM_EDITOR_CORE_CLEAR_EDITOR_BIT(editor.sEditCore, GGSM_EDITOR_BIT_EDIT_MODE)
		ELSE 
			GGSM_EDITOR_CORE_SET_EDITOR_BIT(editor.sEditCore, GGSM_EDITOR_BIT_EDIT_MODE)		
		ENDIF 
	
		IF NOT IS_BITMASK_ENUM_AS_ENUM_SET(editor.sEditCore.eFlags, GGSM_EDITOR_BIT_EDIT_MODE)
			GGSM_EDITOR_CORE_PICK_OPTION(editor.sEditCore, GGSM_TILEMAP_EDITOR_OPTION_MAX)
			
			// options
			SWITCH (editor.sEditCore.iOption)
				CASE GGSM_TILEMAP_EDITOR_OPTION_TILE_SELECT
					GGSM_EDITOR_CORE_EDIT_INT_PARAM(editor.sEditCore, editor.sEditCore.iCurrentEditIndex, tm.iMaxTiles)
				BREAK			
				
				CASE GGSM_TILEMAP_EDITOR_OPTION_FLIP_SELECT
					GGSM_EDITOR_CORE_EDIT_INT_PARAM(editor.sEditCore, editor.iFlipBits, 4)
				BREAK		
				
				CASE GGSM_TILEMAP_EDITOR_OPTION_MAX_X_SELECT
					GGSM_EDITOR_CORE_EDIT_INT_PARAM(editor.sEditCore, tm.iMapWidth, GGSM_MAX_TILEMAP_SIZE_X + 1)
				BREAK				
						
				CASE GGSM_TILEMAP_EDITOR_OPTION_MAX_Y_SELECT
					GGSM_EDITOR_CORE_EDIT_INT_PARAM(editor.sEditCore, tm.iMapHeight, GGSM_MAX_TILEMAP_SIZE_Y + 1)
				BREAK
			ENDSWITCH
		
		ELSE 
			IF IS_DISABLED_CONTROL_JUST_PRESSED(FRONTEND_CONTROL, INPUT_SCRIPT_PAD_LEFT)
				editor.iEditMapX --
			ENDIF 

			IF IS_DISABLED_CONTROL_JUST_PRESSED(FRONTEND_CONTROL, INPUT_SCRIPT_PAD_RIGHT)
				editor.iEditMapX ++
			ENDIF 

			IF IS_DISABLED_CONTROL_JUST_PRESSED(FRONTEND_CONTROL, INPUT_SCRIPT_PAD_UP)
				editor.iEditMapY --
			ENDIF 

			IF IS_DISABLED_CONTROL_JUST_PRESSED(FRONTEND_CONTROL, INPUT_SCRIPT_PAD_DOWN)
				editor.iEditMapY ++
			ENDIF
		ENDIF
		
		IF GGSM_ALTER_POINT_WITH_INPUT(sGGSMData.sCamera.vWorldPosition, 700.0, GGSM_INPUT_RSTICK)
			GGSM_WORLD_POSITION_IN_TILE_MAP(tm, ADD_VECTOR_2D(sGGSMData.sCamera.vWorldPosition, sGGSMData.sCamera.vWorldViewportOffset), editor.iEditMapX, editor.iEditMapY)
		ENDIF	
		
		// clamp values
		editor.iEditMapX = CLAMP_INT(editor.iEditMapX, 0, tm.iMapWidth - 1)
		editor.iEditMapY = CLAMP_INT(editor.iEditMapY, 0, tm.iMapHeight - 1)
		editor.sEditCore.iCurrentEditIndex = CLAMP_INT(editor.sEditCore.iCurrentEditIndex, 0, tm.iMaxTiles - 1)
		
		// copy data to array 
		IF IS_BITMASK_ENUM_AS_ENUM_SET(editor.sEditCore.eFlags, GGSM_EDITOR_BIT_COPY_TO_DATA)	
			GGSM_TILEMAP_SET_INDEX(tm, editor.iEditMapX, editor.iEditMapY, editor.sEditCore.iCurrentEditIndex)
			GGSM_TILE_SET_FLIP(tm, editor.iEditMapX, editor.iEditMapY, editor.iFlipBits)
			CLEAR_BITMASK_ENUM_AS_ENUM(editor.sEditCore.eFlags, GGSM_EDITOR_BIT_COPY_TO_DATA)	
		ENDIF 	
		
		IF IS_BITMASK_ENUM_AS_ENUM_SET(editor.sEditCore.eFlags, GGSM_EDITOR_BIT_EXPORT)	
			CLEAR_BITMASK_ENUM_AS_ENUM(editor.sEditCore.eFlags, GGSM_EDITOR_BIT_EXPORT)
			GGSM_DEBUG_EXPORT_TILE_MAP_DATA_TO_SCRIPT(tm)
			SET_BITMASK_ENUM_AS_ENUM(editor.sEditCore.eFlags, GGSM_EDITOR_BIT_SAVED)
		ENDIF
		
		GGSM_DRAW_TILE_MAP_EDITOR(editor, tm)
	ELSE 
		IF (editor.sEditCore.bLastEditorActive != editor.sEditCore.bEditorActive)
			sGGSMData.bGamePaused = FALSE 
		ENDIF 	
	ENDIF 
	
	editor.iLastEditMapX = editor.iEditMapX
	editor.iLastEditMapY = editor.iEditMapY
	GGSM_EDITOR_CORE_FINALISE_FOR_FRAME_END(editor.sEditCore) 
ENDPROC
#ENDIF 

//-------------------------------------------------
// LOG FUNCTIONS
//-------------------------------------------------

PROC GGSM_AABB_TO_LOG(GGSM_AABB &ent)
	CPRINTLN(DEBUG_MINIGAME, "  --- GGSM_AABB ---")	
	CPRINTLN(DEBUG_MINIGAME, "  vCenter:[", ent.vCenter.x, ",", ent.vCenter.y,"]")
	CPRINTLN(DEBUG_MINIGAME, "  vHalfSize:[", ent.vHalfSize.x, ",", ent.vHalfSize.y,"]")
	CPRINTLN(DEBUG_MINIGAME, "  --- END GGSM_AABB ---")	
	CPRINTLN(DEBUG_MINIGAME, " ")
ENDPROC 

PROC GGSM_BOSS_CONTROLLER_TO_LOG(GGSM_BOSS_CONTROLLER &ent, INT i)
	INT entIndex
	
	CPRINTLN(DEBUG_MINIGAME, "  --- GGSM_BOSS_CONTROLLER [", i ,"]---")
	CPRINTLN(DEBUG_MINIGAME, "  	eType:", GGSM_BOSS_TYPE_TO_STRING(ent.eType))
	CPRINTLN(DEBUG_MINIGAME, "  	eState:", GGSM_BOSS_STATE_TO_STRING(ent.eState))
	CPRINTLN(DEBUG_MINIGAME, "  	HP:", ent.iTotalHP, "/", ent.iMaxTotalHP)
	CPRINTLN(DEBUG_MINIGAME, "  	fStateTimer:", ent.fStateTimer)
	CPRINTLN(DEBUG_MINIGAME, "  	iGroupID:", ent.iGroupID)
	CPRINTLN(DEBUG_MINIGAME, "  	iSummedMaxHPBitSet:", ent.iSummedMaxHPBitSet)
	CPRINTLN(DEBUG_MINIGAME, "  	iBossPatternState:", ent.iBossPatternState)
	
	CPRINTLN(DEBUG_MINIGAME, "  ")
	CPRINTLN(DEBUG_MINIGAME, "  	--- BOSS SECTIONS ---")
	
	REPEAT GGSM_MAX_BOSS_PARTS i
		entIndex = GGSM_BOSS_CONTROLLER_GET_ENTITY_INDEX(ent, i)
		IF (entIndex != GGSM_INVALID_ENTITY) 
			CPRINTLN(DEBUG_MINIGAME, "	   ", i, ") ", GGSM_ENTITY_TYPE_TO_STRING(sGGSMData.sEntities[entIndex].eType), " HP:", sGGSMData.sEntities[entIndex].iHP)
		ENDIF 
	ENDREPEAT

	CPRINTLN(DEBUG_MINIGAME, "  ")
	CPRINTLN(DEBUG_MINIGAME, "  --- END GGSM_BOSS_CONTROLLER ---")
	CPRINTLN(DEBUG_MINIGAME, " ")
ENDPROC 

PROC GGSM_COLLISION_DATA_STATE_TO_LOG(GGSM_COLLISION_DATA &ent)
	INT i
	CPRINTLN(DEBUG_MINIGAME, "  --- GGSM_COLLISION_DATA ---")
	CPRINTLN(DEBUG_MINIGAME, "  eType:", GGSM_COLLISION_SHAPE_TO_STRING(ent.eType))
	CPRINTLN(DEBUG_MINIGAME, "  fColRadius:", ent.fColRadius)
	REPEAT COUNT_OF(ent.vCollisionVectors) i
		CPRINTLN(DEBUG_MINIGAME, "  vCollisionVectors:")
		CPRINTLN(DEBUG_MINIGAME, "     vCollisionVectors[", i, "] = [", ent.vCollisionVectors[i].x, ",", ent.vCollisionVectors[i].y,"]")
	ENDREPEAT 
	CPRINTLN(DEBUG_MINIGAME, "  ")
	CPRINTLN(DEBUG_MINIGAME, "  --- END GGSM_COLLISION_DATA ---")
	CPRINTLN(DEBUG_MINIGAME, " ")
ENDPROC 

PROC GGSM_COLLIDER_TO_LOG(GGSM_COLLIDER &ent)
	CPRINTLN(DEBUG_MINIGAME, "  --- GGSM_COLLIDER ---")
	GGSM_COLLISION_DATA_STATE_TO_LOG(ent.sData)
	GGSM_AABB_TO_LOG(ent.sAABB)
	CPRINTLN(DEBUG_MINIGAME, "  --- END GGSM_COLLIDER ---")
	CPRINTLN(DEBUG_MINIGAME, " ")
ENDPROC

PROC GGSM_DIALOG_CONTROLLER_TO_LOG(GGSM_DIALOG_CONTROLLER &ent)
	CPRINTLN(DEBUG_MINIGAME, "  --- GGSM_DIALOG_CONTROLLER ---")
	CPRINTLN(DEBUG_MINIGAME, "  eType:", GGSM_DIALOG_TYPE_TO_STRING(ent.eType))
	CPRINTLN(DEBUG_MINIGAME, "  eState:", GGSM_DIALOG_STATE_TO_STRING(ent.eState))
	CPRINTLN(DEBUG_MINIGAME, "  eLeftPicture:", GGSM_SPRITE_TYPE_TO_STRING(ent.eLeftPicture))	
	CPRINTLN(DEBUG_MINIGAME, "  eRightPicture:", GGSM_SPRITE_TYPE_TO_STRING(ent.eRightPicture))	
	CPRINTLN(DEBUG_MINIGAME, "  eLeftDialog:", GGSM_SPRITE_TYPE_TO_STRING(ent.eLeftDialog))	
	CPRINTLN(DEBUG_MINIGAME, "  eRightDialog:", GGSM_SPRITE_TYPE_TO_STRING(ent.eRightDialog))	
	CPRINTLN(DEBUG_MINIGAME, "  iSlideInOffset:", ent.iSlideInOffset)
	CPRINTLN(DEBUG_MINIGAME, "  iVariation:", ent.iVariation)
	CPRINTLN(DEBUG_MINIGAME, "  iMsgNumber:", ent.iMsgNumber)
	CPRINTLN(DEBUG_MINIGAME, "  iMsgTimerMS:", ent.iMsgTimerMS)
	CPRINTLN(DEBUG_MINIGAME, "  --- END GGSM_DIALOG_CONTROLLER ---")
	CPRINTLN(DEBUG_MINIGAME, " ")
ENDPROC

PROC GGSM_ENTITY_TO_LOG(GGSM_ENTITY &ent)
	INT i
	VECTOR_2D v
	GGSM_ENTITY_BIT bit 
	
	CPRINTLN(DEBUG_MINIGAME, "  --- GGSM_ENTITY [", GGSM_ENTITY_GET_ARRAY_INDEX(ent),"]---")
	CPRINTLN(DEBUG_MINIGAME, "  	eState:", GGSM_ENTITY_STATE_TO_STRING(ent.eState))
	CPRINTLN(DEBUG_MINIGAME, "  	eType:", GGSM_ENTITY_TYPE_TO_STRING(ent.eType))
	CPRINTLN(DEBUG_MINIGAME, "  	iArrayIndex:", GGSM_ENTITY_GET_ARRAY_INDEX(ent))
	CPRINTLN(DEBUG_MINIGAME, "      iFlags:", ENUM_TO_INT(ent.eFlags))
	CPRINTLN(DEBUG_MINIGAME, "  	iGroupID:", ent.iGroupID)
	CPRINTLN(DEBUG_MINIGAME, "  	iEntityParentIndex:", GGSM_ENTITY_GET_PARENT_INDEX(ent))
	CPRINTLN(DEBUG_MINIGAME, "  	iHP:", ent.iHP)
	CPRINTLN(DEBUG_MINIGAME, "  	iInvTimeMS:", ent.iInvTimeMS)
	CPRINTLN(DEBUG_MINIGAME, "  	fAnimFrame:", ent.fAnimFrame)
	CPRINTLN(DEBUG_MINIGAME, "  	fExplodeTimer:", ent.fExplodeTimer)
	CPRINTLN(DEBUG_MINIGAME, "  	fTimer:", ent.fTimer)
	CPRINTLN(DEBUG_MINIGAME, " ")
	
	CPRINTLN(DEBUG_MINIGAME, "  	--- ACTIVE FLAGS ---")
	REPEAT 32 i
		bit = INT_TO_ENUM(GGSM_ENTITY_BIT, SHIFT_LEFT(1, i))
		IF IS_BITMASK_ENUM_AS_ENUM_SET(ent.eFlags, bit)
			CPRINTLN(DEBUG_MINIGAME,"  	", GGSM_ENTITY_BIT_TO_STRING(bit))
		ENDIF 
	ENDREPEAT 
	CPRINTLN(DEBUG_MINIGAME, " ")
	
	CPRINTLN(DEBUG_MINIGAME, "  	--- TRANSFORM ---")
	CPRINTLN(DEBUG_MINIGAME, "  	vLocalPosition:[", ent.sLocal.vPosition.x, ",", ent.sLocal.vPosition.y, "]")
	CPRINTLN(DEBUG_MINIGAME, "  	fLocalRotation:", ent.sLocal.fRotation)
	CPRINTLN(DEBUG_MINIGAME, "  	vLocalScale:[", ent.sLocal.vScale.x, ",", ent.sLocal.vScale.y, "]")
	CPRINTLN(DEBUG_MINIGAME, "  	vPosition:[", ent.sWorld.vPosition.x, ",", ent.sWorld.vPosition.y, "]")
	CPRINTLN(DEBUG_MINIGAME, "  	fRotation:", ent.sWorld.fRotation)
	CPRINTLN(DEBUG_MINIGAME, "  	vScale:[", ent.sWorld.vScale.x, ",", ent.sWorld.vScale.y, "]")
	v = GGSM_UNPACK_VECTOR_2D(ent.iPackedLocalOrigin)
	CPRINTLN(DEBUG_MINIGAME, "  	iPackedLocalOrigin:[", v.x, ",", v.y, "]")
	CPRINTLN(DEBUG_MINIGAME, " ")
	
	CPRINTLN(DEBUG_MINIGAME, "  	--- MOVEMENT ---")
	CPRINTLN(DEBUG_MINIGAME, "  	eMoveType:", GGSM_MOVEMENT_TYPE_TO_STRING(ent.eMoveType))
	CPRINTLN(DEBUG_MINIGAME, "  	eMoveState:", GGSM_MOVESTATE_TYPE_TO_STRING(ent.eMoveState))
	CPRINTLN(DEBUG_MINIGAME, "  	vLocalDirection:[", ent.vLocalDirection.x, ",", ent.vLocalDirection.y, "]")
	v = GGSM_UNPACK_VECTOR_2D(ent.iPackedLocalTargetPosition)
	CPRINTLN(DEBUG_MINIGAME, "  	iPackedTargetLocalPosition:[", v.x, ",", v.y, "]")
	CPRINTLN(DEBUG_MINIGAME, "  	fSpeed:", ent.fSpeed)
	REPEAT COUNT_OF(ent.fMoveParam) i
		CPRINTLN(DEBUG_MINIGAME, "  	fMoveParam[", i, "]:", ent.fMoveParam[i])
	ENDREPEAT
	CPRINTLN(DEBUG_MINIGAME, " ")
	
	CPRINTLN(DEBUG_MINIGAME, "  	--- COLLISION ---")
	CPRINTLN(DEBUG_MINIGAME, "  	eType:", GGSM_COLLISION_SHAPE_TO_STRING(ent.sCollider.sData.eType))
	CPRINTLN(DEBUG_MINIGAME, "  	fColRadius:", ent.sCollider.sData.fColRadius)
	CPRINTLN(DEBUG_MINIGAME, "  	AABB vCenter:[", ent.sCollider.sAABB.vCenter.x, ",", ent.sCollider.sAABB.vCenter.y,"]")
	CPRINTLN(DEBUG_MINIGAME, "  	AABB vHalfSize:[", ent.sCollider.sAABB.vHalfSize.x, ",", ent.sCollider.sAABB.vHalfSize.y,"]")
	CPRINTLN(DEBUG_MINIGAME, "  	vCollisionVectors:")
	REPEAT COUNT_OF(ent.sCollider.sData.vCollisionVectors) i
		CPRINTLN(DEBUG_MINIGAME, "     	vCollisionVectors[", i, "] = [", ent.sCollider.sData.vCollisionVectors[i].x, ",", ent.sCollider.sData.vCollisionVectors[i].y,"]")
	ENDREPEAT 
	CPRINTLN(DEBUG_MINIGAME, " ")

	/*
	CPRINTLN(DEBUG_MINIGAME, "  	--- FX ---")	
	CPRINTLN(DEBUG_MINIGAME, "  	eSpriteAnim:", GGSM_SPRITE_ANIM_TO_STRING(ent.eSpriteAnim))
	IF (ent.iPackedColor != 0)
		GGSM_UNPACK_RGBA_COLOUR(ent.iPackedColor, col)
		CPRINTLN(DEBUG_MINIGAME, "  	iPackedColor:", col.iR, " ", col.iG, " ", col.iB, " ", col.iA)
	ENDIF
	*/
	
	CPRINTLN(DEBUG_MINIGAME, "  ")
	CPRINTLN(DEBUG_MINIGAME, "  	--- WEAPONS ---")		
	CPRINTLN(DEBUG_MINIGAME, "  	eWeaponState:", GGSM_WEAPON_STATE_TO_STRING(ent.eWeaponState))
	CPRINTLN(DEBUG_MINIGAME, "  	eWeaponType:", GGSM_WEAPON_TYPE_TO_STRING(ent.eWeaponType))
	CPRINTLN(DEBUG_MINIGAME, "  	fWeaponTimer:", ent.fWeaponTimer)	
	CPRINTLN(DEBUG_MINIGAME, "  	iWeaponShotCounter:", ent.iWeaponShotCounter)	
	CPRINTLN(DEBUG_MINIGAME, "  	iWeaponBurstCounter:", ent.iWeaponBurstCounter)	
	CPRINTLN(DEBUG_MINIGAME, "  	iNumShotsOverride:", ent.iNumShotsOverride)	
	CPRINTLN(DEBUG_MINIGAME, "  ")
	
	CPRINTLN(DEBUG_MINIGAME, "  --- END_GGSM_ENTITY ---")
	CPRINTLN(DEBUG_MINIGAME, " ")
ENDPROC 

PROC GGSM_ENTITY_GROUP_TO_LOG(GGSM_ENTITY_GROUP &ent)
	INT i
	VECTOR_2D v 
	GGSM_GROUP_BIT bit 
	
	CPRINTLN(DEBUG_MINIGAME, "  --- GGSM_ENTITY_GROUP [",ent.iGroupID ,"]---")
	CPRINTLN(DEBUG_MINIGAME, "  	eFlags:", ENUM_TO_INT(ent.eFlags))
	CPRINTLN(DEBUG_MINIGAME, "  	iLeader:", ent.iLeader)
	CPRINTLN(DEBUG_MINIGAME, "  	iMembersBitSet:", ent.iMemberBitSet)
	CPRINTLN(DEBUG_MINIGAME, "  	iMembersOnStageBitSet:", ent.iMembersOnStageBitSet)
	CPRINTLN(DEBUG_MINIGAME, "  	iActiveCount:", ent.iActiveCount)
	CPRINTLN(DEBUG_MINIGAME, "  	iMembersToCreate:", ent.iMembersToCreate)
	CPRINTLN(DEBUG_MINIGAME, "  	fDistCounter:", ent.fDistCounter)	
	CPRINTLN(DEBUG_MINIGAME, "  ")
	//GGSM_FORMATION_DATA_TO_LOG(ent.sFormSettings)
	CPRINTLN(DEBUG_MINIGAME, "  ")
	
	CPRINTLN(DEBUG_MINIGAME, "  	--- ACTIVE FLAGS ---")
	REPEAT 32 i
		bit = INT_TO_ENUM(GGSM_GROUP_BIT, SHIFT_LEFT(1, i))
		IF IS_BITMASK_ENUM_AS_ENUM_SET(ent.eFlags, bit)
			CPRINTLN(DEBUG_MINIGAME,"  	", GGSM_GROUP_BIT_TO_STRING(bit))
		ENDIF 
	ENDREPEAT 
	CPRINTLN(DEBUG_MINIGAME, " ")
	
	IF (ent.iActiveCount > 0)
		CPRINTLN(DEBUG_MINIGAME, "  ")
		CPRINTLN(DEBUG_MINIGAME, "  	--- MEMBERS ---")		
		REPEAT GGSM_MAX_ENTITIES i
			IF (sGGSMData.sEntities[i].eState != GGSM_ENTITY_STATE_NONE) AND (GGSM_ENTITY_GET_GROUP_ID(sGGSMData.sEntities[i]) = ent.iGroupID)
				v = sGGSMData.sEntities[i].sWorld.vPosition
				CPRINTLN(DEBUG_MINIGAME, "  	ENTITY:", i, " ", GGSM_ENTITY_TYPE_TO_STRING(sGGSMData.sEntities[i].eType), " POS:[", v.x, ", ", v.y, "]")
			ENDIF 
		ENDREPEAT 
		CPRINTLN(DEBUG_MINIGAME, "  ")
	ENDIF
	
	CPRINTLN(DEBUG_MINIGAME, "  	--- FORMATION PARAMS ---")
	CPRINTLN(DEBUG_MINIGAME, "  	eFormType:", GGSM_FORMATION_TYPE_TO_STRING(GGSM_FORMATION_GET_TYPE(ent.sFormSettings)))
	CPRINTLN(DEBUG_MINIGAME, "  	eEntityType:", GGSM_ENTITY_TYPE_TO_STRING(GGSM_FORMATION_GET_ENTITY_TYPE(ent.sFormSettings)))
	CPRINTLN(DEBUG_MINIGAME, "  	eWeaponType:", GGSM_WEAPON_TYPE_TO_STRING(GGSM_FORMATION_GET_WEAPON_TYPE(ent.sFormSettings)))
	CPRINTLN(DEBUG_MINIGAME, "  	eMovementType:", GGSM_MOVEMENT_TYPE_TO_STRING(GGSM_FORMATION_GET_MOVEMENT_TYPE(ent.sFormSettings)))
	v = GGSM_FORMATION_GET_START_POSITION(ent.sFormSettings)
	CPRINTLN(DEBUG_MINIGAME, "  	vBasePos:[", v.x, ",", v.y,"]")
	v = GGSM_FORMATION_GET_START_DIRECTION(ent.sFormSettings)
	CPRINTLN(DEBUG_MINIGAME, "  	vBaseDir:[", v.x, ",", v.y,"]")	
	v = GGSM_FORMATION_GET_SPACING(ent.sFormSettings)
	CPRINTLN(DEBUG_MINIGAME, "  	vSpacing:[", v.x, ",", v.y,"]")	
	CPRINTLN(DEBUG_MINIGAME, "  	fScrollDistance:", GGSM_FORMATION_GET_SCROLL_DISTANCE(ent.sFormSettings))	
	
	CPRINTLN(DEBUG_MINIGAME, "  ")
	CPRINTLN(DEBUG_MINIGAME, "  --- END_GGSM_ENTITY_GROUP ---")
	CPRINTLN(DEBUG_MINIGAME, " ")
ENDPROC 

PROC GGSM_FX_SPRITE_TO_LOG(GGSM_FX_SPRITE &ent, INT n)
	GGSM_FX_SPRITE_BIT bit
	VECTOR_2D v
	INT i 
	
	CPRINTLN(DEBUG_MINIGAME, "  --- GGSM_SPRITE [", n ,"]---")

	CPRINTLN(DEBUG_MINIGAME, "  	--- ACTIVE FLAGS ---")
	REPEAT 32 i
		bit = INT_TO_ENUM(GGSM_FX_SPRITE_BIT, SHIFT_LEFT(1, i))
		IF IS_BITMASK_ENUM_AS_ENUM_SET(ent.eFlags, bit)
			CPRINTLN(DEBUG_MINIGAME,"  	", GGSM_FX_SPRITE_BIT_TO_STRING(bit))
		ENDIF 
	ENDREPEAT 
	CPRINTLN(DEBUG_MINIGAME, " ")

	CPRINTLN(DEBUG_MINIGAME, "  	--- INFO ---")
	CPRINTLN(DEBUG_MINIGAME, "  	eSpriteAnim:", GGSM_SPRITE_ANIM_TO_STRING(ent.eSpriteAnim))
	CPRINTLN(DEBUG_MINIGAME, "  	eSpriteType:", GGSM_SPRITE_TYPE_TO_STRING(ent.eSpriteType))
	v = GGSM_UNPACK_VECTOR_2D(ent.iPackedPosition)
	CPRINTLN(DEBUG_MINIGAME, "  	iPackedPosition:[", v.x, ",", v.y, "]")
	CPRINTLN(DEBUG_MINIGAME, "  	fAnimFrame:", ent.fAnimFrame)
	CPRINTLN(DEBUG_MINIGAME, "  	fScale:", ent.fScale)
	CPRINTLN(DEBUG_MINIGAME, "  ")
	CPRINTLN(DEBUG_MINIGAME, "  --- END_GGSM_SPRITE ---")
	CPRINTLN(DEBUG_MINIGAME, " ")
ENDPROC 

PROC GGSM_PROJECTILE_TO_LOG(GGSM_PROJECTILE &ent, INT n)
	GGSM_PROJECTILE_BIT bit
	INT i
	
	CPRINTLN(DEBUG_MINIGAME, "  --- GGSM_PROJECTILE [", n ,"]---")
	CPRINTLN(DEBUG_MINIGAME, "  	eType:", GGSM_PROJECTILE_TYPE_TO_STRING(ent.eType))
	CPRINTLN(DEBUG_MINIGAME, "  	eFlags:", ENUM_TO_INT(ent.eFlags))
	CPRINTLN(DEBUG_MINIGAME, "  	iTargetIndex:", ent.iTargetIndex)
	CPRINTLN(DEBUG_MINIGAME, "  	fTimer:", ent.fTimer)
	CPRINTLN(DEBUG_MINIGAME, "  ")
	
	CPRINTLN(DEBUG_MINIGAME, "  	--- ACTIVE FLAGS ---")
	REPEAT 32 i
		bit = INT_TO_ENUM(GGSM_PROJECTILE_BIT, SHIFT_LEFT(1, i))
		IF IS_BITMASK_ENUM_AS_ENUM_SET(ent.eFlags, bit)
			CPRINTLN(DEBUG_MINIGAME,"  	", GGSM_PROJECTILE_BIT_TO_STRING(bit))
		ENDIF 
	ENDREPEAT 
	CPRINTLN(DEBUG_MINIGAME, " ")
	
	CPRINTLN(DEBUG_MINIGAME, "  	--- MOVEMENT ---")
	CPRINTLN(DEBUG_MINIGAME, "  	vDirection:[", ent.vDirection.x, ",", ent.vDirection.y, "]")
	CPRINTLN(DEBUG_MINIGAME, "  	fSpeed:", ent.fSpeed)
	CPRINTLN(DEBUG_MINIGAME, "  	fRotation:", GET_HEADING_FROM_VECTOR_2D(ent.vDirection.x, ent.vDirection.y))
	CPRINTLN(DEBUG_MINIGAME, "  ")
	
	CPRINTLN(DEBUG_MINIGAME, "  	--- COLLISION ---")
	CPRINTLN(DEBUG_MINIGAME, "  	eType:", GGSM_COLLISION_SHAPE_TO_STRING(ent.sCollider.sData.eType))
	CPRINTLN(DEBUG_MINIGAME, "  	fLength:", ent.fLength)
	CPRINTLN(DEBUG_MINIGAME, "  	fColRadius:", ent.sCollider.sData.fColRadius)
	CPRINTLN(DEBUG_MINIGAME, "  	AABB vCenter:[", ent.sCollider.sAABB.vCenter.x, ",", ent.sCollider.sAABB.vCenter.y,"]")
	CPRINTLN(DEBUG_MINIGAME, "  	AABB vHalfSize:[", ent.sCollider.sAABB.vHalfSize.x, ",", ent.sCollider.sAABB.vHalfSize.y,"]")
	CPRINTLN(DEBUG_MINIGAME, "  	vCollisionVectors:")
	REPEAT COUNT_OF(ent.sCollider.sData.vCollisionVectors) i
		CPRINTLN(DEBUG_MINIGAME, "     	vCollisionVectors[", i, "] = [", ent.sCollider.sData.vCollisionVectors[i].x, ",", ent.sCollider.sData.vCollisionVectors[i].y,"]")
	ENDREPEAT 

	CPRINTLN(DEBUG_MINIGAME, " ")
	CPRINTLN(DEBUG_MINIGAME, "  --- END_GGSM_PROJECTILE ---")
	CPRINTLN(DEBUG_MINIGAME, " ")
ENDPROC 

PROC GGSM_TO_LOG()
	INT i, n
	GGSM_STAGE_BIT stageBit 
	GGSM_CHALLENGE_BIT challengeBit 
	GGSM_TEXDICT textureBit
	GGSM_UNLOCK_TYPE unlockType
	
	CPRINTLN(DEBUG_MINIGAME, "  --- STATE ---")
	CPRINTLN(DEBUG_MINIGAME, "  eClientState:", GGSM_STATE_TO_STRING(sGGSMData.eState))
	CPRINTLN(DEBUG_MINIGAME, "  fTimeScale:", sGGSMData.fTimeScale)
	CPRINTLN(DEBUG_MINIGAME, "  gameTimer:", GET_GAME_TIMER())
	CPRINTLN(DEBUG_MINIGAME, "  bPowerUpCollected:", GET_STRING_FROM_BOOL(sGGSMData.bPowerUpCollected))
	CPRINTLN(DEBUG_MINIGAME, "  ")
	
	CPRINTLN(DEBUG_MINIGAME, "  --- STATS ---")
	CPRINTLN(DEBUG_MINIGAME, "  gameType:", sGGSMData.sGameStats.gameType)
	CPRINTLN(DEBUG_MINIGAME, "  matchId:", sGGSMData.sGameStats.matchId)
	CPRINTLN(DEBUG_MINIGAME, "  numPlayers:", sGGSMData.sGameStats.numPlayers)
	CPRINTLN(DEBUG_MINIGAME, "  level:", sGGSMData.sGameStats.level)
	CPRINTLN(DEBUG_MINIGAME, "  powerUps:", sGGSMData.sGameStats.powerUps)
	CPRINTLN(DEBUG_MINIGAME, "  kills:", sGGSMData.sGameStats.kills)
	CPRINTLN(DEBUG_MINIGAME, "  timePlayed:", sGGSMData.sGameStats.timePlayed)
	CPRINTLN(DEBUG_MINIGAME, "  score:", sGGSMData.sGameStats.score)
	CPRINTLN(DEBUG_MINIGAME, "  reward:", sGGSMData.sGameStats.reward)
	CPRINTLN(DEBUG_MINIGAME, "  challenges:", sGGSMData.sGameStats.challenges)
	CPRINTLN(DEBUG_MINIGAME, "  iPlayerLives:", sGGSMData.iPlayerLives)
	CPRINTLN(DEBUG_MINIGAME, "  ")	
	
	CPRINTLN(DEBUG_MINIGAME, "  --- ENTITIES ---")
	n = 0
	REPEAT COUNT_OF(sGGSMData.sEntities) i
		IF (sGGSMData.sEntities[i].eState != GGSM_ENTITY_STATE_NONE)
			GGSM_ENTITY_TO_LOG(sGGSMData.sEntities[i])
			n ++
		ENDIF 
	ENDREPEAT 
	CPRINTLN(DEBUG_MINIGAME," # ACTIVE ENTITIES:", n)
	CPRINTLN(DEBUG_MINIGAME, "  ")
	
	CPRINTLN(DEBUG_MINIGAME, "  --- PLAYER PROJECTILES ---")
	n = 0
	REPEAT COUNT_OF(sGGSMData.sProjectiles) i
		IF IS_BITMASK_ENUM_AS_ENUM_SET(sGGSMData.sProjectiles[i].eFlags, GGSM_PROJECTILE_BIT_ACTIVE) 
			IF IS_BITMASK_ENUM_AS_ENUM_SET(sGGSMData.sProjectiles[i].eFlags, GGSM_PROJECTILE_BIT_IS_PLAYER_ALLIED)		
				GGSM_PROJECTILE_TO_LOG(sGGSMData.sProjectiles[i], i)
				n ++
			ENDIF
		ENDIF 
	ENDREPEAT 
	CPRINTLN(DEBUG_MINIGAME," # ACTIVE PROJECTILES:", n)
	CPRINTLN(DEBUG_MINIGAME, "  ")
	
	CPRINTLN(DEBUG_MINIGAME, "  --- ENEMY PROJECTILES ---")
	n = 0
	REPEAT COUNT_OF(sGGSMData.sProjectiles) i
		IF IS_BITMASK_ENUM_AS_ENUM_SET(sGGSMData.sProjectiles[i].eFlags, GGSM_PROJECTILE_BIT_ACTIVE)
			IF NOT IS_BITMASK_ENUM_AS_ENUM_SET(sGGSMData.sProjectiles[i].eFlags, GGSM_PROJECTILE_BIT_IS_PLAYER_ALLIED)	
				GGSM_PROJECTILE_TO_LOG(sGGSMData.sProjectiles[i], i)
			ENDIF
			n ++
		ENDIF 
	ENDREPEAT  
	CPRINTLN(DEBUG_MINIGAME," # ACTIVE PROJECTILES:", n)
	CPRINTLN(DEBUG_MINIGAME, "  ")
	
	CPRINTLN(DEBUG_MINIGAME, "  --- ENTITY GROUPS ---")
	REPEAT COUNT_OF(sGGSMData.sEntityGroup) i
		IF IS_BITMASK_ENUM_AS_ENUM_SET(sGGSMData.sEntityGroup[i].eFlags, GGSM_GROUP_BIT_ACTIVE)
			GGSM_ENTITY_GROUP_TO_LOG(sGGSMData.sEntityGroup[i])
		ENDIF 
	ENDREPEAT
	CPRINTLN(DEBUG_MINIGAME, "  ")
	
	CPRINTLN(DEBUG_MINIGAME, "  --- BOSS CONTROLLERS ---")
	REPEAT COUNT_OF(sGGSMData.sBossController) i
		GGSM_BOSS_CONTROLLER_TO_LOG(sGGSMData.sBossController[i], i)
	ENDREPEAT
	CPRINTLN(DEBUG_MINIGAME, "  ")
	
	CPRINTLN(DEBUG_MINIGAME, "  --- FX SPRITES ---")
	REPEAT COUNT_OF(sGGSMData.sFXSprite) i
		IF IS_BITMASK_ENUM_AS_ENUM_SET(sGGSMData.sFXSprite[i].eFlags, GGSM_FX_SPRITE_BIT_ACTIVE)
			GGSM_FX_SPRITE_TO_LOG(sGGSMData.sFXSprite[i], i)
		ENDIF 
	ENDREPEAT
	CPRINTLN(DEBUG_MINIGAME, "  ")
	
	CPRINTLN(DEBUG_MINIGAME, " 	--- STAGE FLAGS ---")
	REPEAT 32 i
		stageBit = INT_TO_ENUM(GGSM_STAGE_BIT, SHIFT_LEFT(1, i))
		IF IS_BITMASK_ENUM_AS_ENUM_SET(sGGSMData.eStageFlags, stageBit)
			CPRINTLN(DEBUG_MINIGAME,"  	", GGSM_STAGE_BIT_TO_STRING(stageBit))
		ENDIF 
	ENDREPEAT 
	CPRINTLN(DEBUG_MINIGAME, " ")
	
	CPRINTLN(DEBUG_MINIGAME, " 	--- CHALLENGE FLAGS ---")
	REPEAT 32 i
		challengeBit = INT_TO_ENUM(GGSM_CHALLENGE_BIT, SHIFT_LEFT(1, i))
		IF IS_BITMASK_ENUM_AS_ENUM_SET(sGGSMData.eChallengeFlags, challengeBit)
			CPRINTLN(DEBUG_MINIGAME,"  	", GGSM_CHALLENGE_BIT_TO_STRING(challengeBit))
		ENDIF 
	ENDREPEAT 
	CPRINTLN(DEBUG_MINIGAME, " ")
	
	CPRINTLN(DEBUG_MINIGAME, " 	--- UNLOCKS FLAGS ---")
	REPEAT NUM_GGSM_UNLOCK_TYPE unlockType
		IF (unlockType != GGSM_UNLOCK_NONE)
			CPRINTLN(DEBUG_MINIGAME,"  	", GGSM_UNLOCK_TYPE_TO_STRING(unlockType), ":", GET_STRING_FROM_BOOL(IS_BIT_SET(sGGSMData.iUnlockedBitField, ENUM_TO_INT(unlockType))))
		ENDIF 
	ENDREPEAT 
	CPRINTLN(DEBUG_MINIGAME, " ")
	
	CPRINTLN(DEBUG_MINIGAME, " 	--- TEXTURE DICTS ---")
	REPEAT GGSM_MAX_TEXDICT i
		textureBit = INT_TO_ENUM(GGSM_TEXDICT, SHIFT_LEFT(1, i))
		IF IS_BITMASK_ENUM_AS_ENUM_SET(sGGSMData.eLoadedTextureFlags, textureBit)
			CPRINTLN(DEBUG_MINIGAME,"  	", GGSM_TEXDICT_TO_STRING(textureBit))
		ENDIF 
	ENDREPEAT 
	CPRINTLN(DEBUG_MINIGAME, " ")
	
	CPRINTLN(DEBUG_MINIGAME, "  --- Z SORT DATA ---")
	REPEAT COUNT_OF(sGGSMData.sZSortData) i
		CPRINTLN(DEBUG_MINIGAME, "  Slot:", i, " Entity Index:", sGGSMData.sZSortData[i].iEntityIndex, " Z-Depth:", sGGSMData.sZSortData[i].iZDepth)
	ENDREPEAT
	

	GGSM_DIALOG_CONTROLLER_TO_LOG(sGGSMData.sDialogController)	
	CPRINTLN(DEBUG_MINIGAME, "  ")
ENDPROC

//-------------------------------------------------
// MAIN DEBUG FUNCTIONS
//-------------------------------------------------

/// PURPOSE:
///    Creates Debug Widgets
PROC GGSM_DEBUG_CREATE_WIDGETS()	
	IF sGGSMData.bDebugCreatedWidgets
		EXIT
	ENDIF
	
	IF sGGSMData.widgetGroupExample = NULL
		EXIT
	ENDIF
	
	INT i
	TEXT_LABEL_31 txt 
	
	SET_CURRENT_WIDGET_GROUP(sGGSMData.widgetGroupExample)
	START_WIDGET_GROUP("Game Widgets")

		ADD_WIDGET_BOOL("Dump To TTY", sGGSMData.bDebugDumpToLogs)
		ADD_WIDGET_BOOL("Draw Collision", sGGSMData.bDrawCollisionDebug)
		ADD_WIDGET_BOOL("Disable SFX", sGGSMData.bDebugDisableSFX)
				
		ADD_WIDGET_BOOL("g_bBlockArcadeCabinetDrawing", g_bBlockArcadeCabinetDrawing)
		ADD_WIDGET_BOOL("g_bMinimizeArcadeCabinetDrawing", g_bMinimizeArcadeCabinetDrawing)	
		ADD_WIDGET_BOOL("Game Paused", sGGSMData.bGamePaused)
		ADD_WIDGET_BOOL("Game Force Quit", sGGSMData.bGameForceQuit)
		
		ADD_WIDGET_FLOAT_SLIDER("Analog Dead Zone", sGGSMData.fAnalogDeadZone, 0.1, 1.0, 0.1)	
		ADD_WIDGET_FLOAT_SLIDER("D-Pad Scalar", sGGSMData.fDPadScalar, 0.1, 1.0, 0.1)	
		ADD_WIDGET_INT_READ_ONLY("Stack Size", sGGSMData.iDebugCurrentStackSize)
		ADD_WIDGET_FLOAT_READ_ONLY("Frame Time", sGGSMData.fDebugFrameTime)
		ADD_WIDGET_FLOAT_SLIDER("Time Scale", sGGSMData.fTimeScale, 0.1, 1.0, 0.1)	
		
		START_WIDGET_GROUP("Client State")	
			ADD_WIDGET_BOOL("Change State", sGGSMData.bDebugChangeState)
			
			GGSM_STATE_SELECTOR(sGGSMData.iDebugStateSelector)
			GGSM_STATE_SELECTOR(sGGSMData.iDebugCurrentState, "Current State")
			GGSM_SUBSTATE_SELECTOR(sGGSMData.iDebugCurrentSubstate, "Current SubState")
			ADD_WIDGET_FLOAT_READ_ONLY("Timer", sGGSMData.fStateTimer)
			ADD_WIDGET_FLOAT_SLIDER("Interpolator", sGGSMData.fStateInterpolateValue, 0.0, 1.0, 0.1)
		STOP_WIDGET_GROUP()
		
		#IF GGSM_DEBUG_TSHIRT_HELP
			GGSM_CREATE_TSHIRT_DEBUG_WIDGET()
		#ENDIF

		GGSM_CAMERA_CREATE_DEBUG_WIDGET(sGGSMData.sCamera)
		
		START_WIDGET_GROUP("Instances")
			ADD_WIDGET_BOOL("Skip To Boss", sGGSMData.bDebugJumpToBoss)
			ADD_WIDGET_BOOL("Kill All Enemies", sGGSMData.bDebugKillAllEnemies)
			ADD_WIDGET_BOOL("Player Invunerable", sGGSMData.bDebugPlayerInvunerable)
			ADD_WIDGET_INT_SLIDER("Spawn Index Counter", sGGSMData.iSpawnIndexCounter, 0, GGSM_MAX_SPAWN_DATA - 1, 1)
			ADD_WIDGET_INT_SLIDER("Spawns Used", sGGSMData.iSpawnsUsed, 0, GGSM_MAX_SPAWN_DATA, 1)
			ADD_WIDGET_INT_READ_ONLY("Player Ship Index", sGGSMData.iPlayerShipIndex)
			
			START_WIDGET_GROUP("Entities")
				REPEAT GGSM_MAX_ENTITIES i
					txt = "Entity "
					txt += i
					GGSM_ENTITY_WIDGET(sGGSMData.sEntities[i], txt)
				ENDREPEAT
			STOP_WIDGET_GROUP()	
			
			START_WIDGET_GROUP("Projectiles")
				REPEAT GGSM_MAX_PROJECTILES i
					txt = "Projectile "
					txt += i
					GGSM_PROJECTILE_WIDGET(sGGSMData.sProjectiles[i], txt)
				ENDREPEAT
			STOP_WIDGET_GROUP()
			
			START_WIDGET_GROUP("Entity Groups")
				REPEAT GGSM_MAX_ENTITY_GROUPS i
				 	txt = "Group "
					txt += i
					START_WIDGET_GROUP(txt)
						ADD_WIDGET_INT_READ_ONLY("Leader", sGGSMData.sEntityGroup[i].iLeader)
						ADD_WIDGET_INT_READ_ONLY("Active Count", sGGSMData.sEntityGroup[i].iActiveCount)
						ADD_WIDGET_INT_READ_ONLY("Members Left To Create", sGGSMData.sEntityGroup[i].iMembersToCreate)
						ADD_BIT_FIELD_WIDGET("Group Members", sGGSMData.sEntityGroup[i].iMemberBitSet)
						ADD_BIT_FIELD_WIDGET("Group Members On Stage", sGGSMData.sEntityGroup[i].iMembersOnStageBitSet)
					STOP_WIDGET_GROUP()
				ENDREPEAT
			STOP_WIDGET_GROUP()
			
			START_WIDGET_GROUP("Boss Controllers")
				REPEAT COUNT_OF(sGGSMData.sBossController) i
				 	txt = "Boss Controller "
					txt += i
					GGSM_BOSS_CONTROLLER_CREATE_WIDGET(sGGSMData.sBossController[i], txt)
				ENDREPEAT 
			STOP_WIDGET_GROUP()
		STOP_WIDGET_GROUP()
		
		START_WIDGET_GROUP("Rendering Counters")
			ADD_WIDGET_INT_READ_ONLY("iRectsDrawnThisFrame", iRectsDrawnThisFrame)
			ADD_WIDGET_INT_READ_ONLY("iSpritesDrawnThisFrame", iSpritesDrawnThisFrame)
			ADD_WIDGET_INT_READ_ONLY("iDebugLinesDrawnThisFrame", iDebugLinesDrawnThisFrame)
			ADD_WIDGET_FLOAT_READ_ONLY("Fade Alpha", sGGSMData.fFadeAlpha)
			ADD_WIDGET_FLOAT_SLIDER("Fade Time", sGGSMData.fFadeTime, -5.0, 5.0, 0.125)
	
			START_WIDGET_GROUP("Story")
				GGSM_ADD_WIDGET_VECTOR_2D_SLIDER("Story Base Pos", sGGSMData.vStoryBasePos, -cfBASE_SCREEN_WIDTH, cfBASE_SCREEN_WIDTH, 1)
				ADD_WIDGET_FLOAT_SLIDER("Story Scroll Rate", sGGSMData.fStoryScrollRate, 0.0, 1600.0, 1.0)	
				ADD_WIDGET_FLOAT_SLIDER("Min Width", sGGSMData.fStoryMinWidth, 0.0, 2048.0, 1.0)
				ADD_WIDGET_FLOAT_SLIDER("Max Width", sGGSMData.fStoryMaxWidth, 0.0, 2048.0, 1.0)
				ADD_WIDGET_FLOAT_SLIDER("Fadeout Y-Pos", sGGSMData.fStoryFadeOutYPos, -cfBASE_SCREEN_WIDTH, cfBASE_SCREEN_WIDTH, 1)
				ADD_WIDGET_FLOAT_READ_ONLY("Story T", sGGSMData.fDebugStoryT)
			STOP_WIDGET_GROUP()	
			
			START_WIDGET_GROUP("Z Sort List")
				REPEAT COUNT_OF(sGGSMData.sZSortData) i
				 	txt = "Entry "
					txt += i
					START_WIDGET_GROUP(txt)		
						ADD_WIDGET_INT_READ_ONLY("Entity", sGGSMData.sZSortData[i].iEntityIndex)
						ADD_WIDGET_INT_READ_ONLY("Depth", sGGSMData.sZSortData[i].iZDepth)
					STOP_WIDGET_GROUP()
				ENDREPEAT 
			STOP_WIDGET_GROUP()	
			
		STOP_WIDGET_GROUP()
		
		START_WIDGET_GROUP("Stats")
			ADD_WIDGET_BOOL("Set Stage", sGGSMData.bDebugSetStage)
			ADD_WIDGET_BOOL("Force Default Leaderboard", sAGLeaderboardData.bForceDefaultLeaderboard)
			ADD_WIDGET_INT_SLIDER("Stage", sGGSMData.sGameStats.level, 0, 10, 1)
			ADD_WIDGET_INT_SLIDER("Lives", sGGSMData.iPlayerLives, 0, 99, 1)
			ADD_WIDGET_INT_READ_ONLY("Score", sGGSMData.sGameStats.score)
			ADD_WIDGET_INT_READ_ONLY("Kill Streak", sGGSMData.iKillStreak)
			ADD_WIDGET_FLOAT_READ_ONLY("Kill Streak Timer", sGGSMData.fKillStreakTimer)
			ADD_WIDGET_FLOAT_READ_ONLY("Chain Multiplier", sGGSMData.fChainMultiplier)
			ADD_WIDGET_FLOAT_SLIDER("Time Per Frame", sGGSMData.fScrollTimePerFrame, 0.010, 0.050, 0.001)
			
			ADD_WIDGET_INT_READ_ONLY("Extend Point Counter", sGGSMData.iExtendPtsCounter)
			ADD_WIDGET_INT_READ_ONLY("Enemies Created", sGGSMData.iEnemiesCreated)
			ADD_WIDGET_INT_READ_ONLY("Enemies Destroyed", sGGSMData.iEnemiesDestroyed)
			ADD_WIDGET_INT_READ_ONLY("Entities Active", sGGSMData.iEntitiesActive)
			ADD_WIDGET_INT_READ_ONLY("Groups Active", sGGSMData.iGroupsActive)
			ADD_WIDGET_INT_READ_ONLY("Enemy Projectiles Active", sGGSMData.iEnemyProjectilesActive)
			ADD_WIDGET_INT_READ_ONLY("Total Projectiles Active", sGGSMData.iProjectilesActive)
			ADD_WIDGET_INT_READ_ONLY("Max Entities Active", sGGSMData.iMaxEntitiesActive)
			ADD_WIDGET_INT_READ_ONLY("Max Groups Active", sGGSMData.iMaxGroupsActive)
			ADD_WIDGET_INT_READ_ONLY("Max Projectiles Active", sGGSMData.iMaxProjectilesActive)			
			
			START_WIDGET_GROUP("Graze")
				ADD_WIDGET_INT_READ_ONLY("Graze", sGGSMData.iGraze)
				ADD_WIDGET_FLOAT_READ_ONLY("Graze Timer", sGGSMData.fGrazeTimer)
				ADD_WIDGET_FLOAT_SLIDER("Graze Timer", sGGSMData.fGrazeTime, 0.0, 1.0, 0.001)
				ADD_WIDGET_FLOAT_SLIDER("Graze Radius", sGGSMData.fGrazeRadius, 0.0, 128.0, 1.0)
			STOP_WIDGET_GROUP()
			
			START_WIDGET_GROUP("Game Stats")
				ADD_WIDGET_INT_READ_ONLY("Game Type", sGGSMData.sGameStats.gameType)
				ADD_WIDGET_INT_READ_ONLY("Match ID", sGGSMData.sGameStats.matchId)
				ADD_WIDGET_INT_READ_ONLY("# Players", sGGSMData.sGameStats.numPlayers)
				ADD_WIDGET_INT_READ_ONLY("Level", sGGSMData.sGameStats.level)
				ADD_WIDGET_INT_READ_ONLY("Power Ups", sGGSMData.sGameStats.powerUps)
				ADD_WIDGET_INT_READ_ONLY("Kills", sGGSMData.sGameStats.kills)
				ADD_WIDGET_INT_READ_ONLY("Time Played", sGGSMData.sGameStats.timePlayed)
				ADD_WIDGET_INT_READ_ONLY("Score", sGGSMData.sGameStats.score)
				ADD_WIDGET_INT_READ_ONLY("Reward", sGGSMData.sGameStats.reward)
				ADD_WIDGET_INT_READ_ONLY("Challenges", sGGSMData.sGameStats.challenges)				
			STOP_WIDGET_GROUP()	
		STOP_WIDGET_GROUP()

		ARCADE_GAMES_POSTFX_WIDGET_CREATE()
		
		START_WIDGET_GROUP("Debug Stuff")
			ADD_WIDGET_BOOL("Show Spawn Debug", sGGSMData.bShowSpawnDebug)
			ADD_WIDGET_BOOL("Disable Post FX", sGGSMData.bDebugDisablePostFX)
			
			#IF GGSM_ENTITY_EDITOR_ACTIVE
				ADD_WIDGET_BOOL("Entity Editor Active", sGGSMData.sDebugEntityEditor.sEditCore.bEditorActive)
			#ENDIF
			
			#IF GGSM_SPAWN_EDITOR_ACTIVE
				ADD_WIDGET_BOOL("Spawn Editor Active", sGGSMData.sDebugSpawnEditor.sEditCore.bEditorActive)
			#ENDIF
		
			#IF GGSM_TILEMAP_EDITOR_ACTIVE
				ADD_WIDGET_BOOL("Tilemap Editor Active", sGGSMData.sDebugMapEditor.sEditCore.bEditorActive)
			#ENDIF
			
			#IF GGSM_SOUND_TEST
				ARCADE_GAMES_SOUND_WIDGET_CREATE()
			#ENDIF
			
			#IF GGSM_CHALLENGE_DEBUG
				GGSM_CREATE_CHALLENGE_DEBUG_WIDGET()
			#ENDIF
			
			ADD_WIDGET_BOOL("bDebugCreatePowerUp", sGGSMData.bDebugCreatePowerUp)

			START_WIDGET_GROUP("Debug Rect")
				ADD_WIDGET_BOOL("Show Rect", sGGSMData.bDrawDebugRect)
				ADD_WIDGET_BOOL("Center Mode", sGGSMData.bDebugRectCenterMode)
				GGSM_ADD_WIDGET_VECTOR_2D_SLIDER("Top Left (Center)", sGGSMData.vDebugRect[0], -cfBASE_SCREEN_WIDTH, cfBASE_SCREEN_WIDTH, 10)
				GGSM_ADD_WIDGET_VECTOR_2D_SLIDER("Base Right (HalfSize)", sGGSMData.vDebugRect[1], -cfBASE_SCREEN_WIDTH, cfBASE_SCREEN_WIDTH, 10)			
			STOP_WIDGET_GROUP()	
			
		STOP_WIDGET_GROUP()
	STOP_WIDGET_GROUP()
	CLEAR_CURRENT_WIDGET_GROUP(sGGSMData.widgetGroupExample)
	
	sGGSMData.bDebugCreatedWidgets = TRUE
ENDPROC		

/// PURPOSE:
///    Dumps the current state of the game to the logs
///    Automatically called when a bug is entered
PROC GGSM_DEBUG_DUMP_DATA_TO_LOGS()
	ARCADE_CABINET_DUMP_DATA_TO_CONSOLE()
	GGSM_TO_LOG()
	sGGSMData.bDebugDumpToLogs = FALSE
ENDPROC

/// PURPOSE:
///    Update Debug Processing
PROC GGSM_DEBUG_PROCESSING()	
	INT i 
	VECTOR_2D rc, rs
	RGBA_COLOUR_STRUCT rcol
	
	GGSM_DEBUG_CREATE_WIDGETS()
	sGGSMData.fDebugFrameTime = GET_FRAME_TIME()
	sGGSMData.iDebugCurrentStackSize = GET_CURRENT_STACK_SIZE()
	SET_DEBUG_LINES_AND_SPHERES_DRAWING_ACTIVE(TRUE)
	
	//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)
	OR sGGSMData.bDebugDumpToLogs
		GGSM_DEBUG_DUMP_DATA_TO_LOGS()
	ENDIF
	
	IF (sGGSMData.bDebugChangeState)
		GGSM_SET_CLIENT_STATE(INT_TO_ENUM(GGSM_STATE, sGGSMData.iDebugStateSelector))
		sGGSMData.bDebugChangeState = FALSE
	ENDIF
	
	sGGSMData.fDebugStoryT = GGSM_CALCULATE_T_FOR_STORY_POS(sGGSMData.vStoryBasePos.y)
	sGGSMData.iDebugCurrentState = ENUM_TO_INT(sGGSMData.eState)
	sGGSMData.iDebugCurrentSubstate = ENUM_TO_INT(sGGSMData.eSubState)
	
	IF (sGGSMData.bDebugCreatePowerUp)
		GGSM_CREATE_POWER_UP(INT_TO_ENUM(GGSM_SPRITE_TYPE, GET_RANDOM_INT_IN_RANGE(ENUM_TO_INT(GGSM_SPRITE_POWER_UP_BEAM), ENUM_TO_INT(GGSM_SPRITE_POWER_UP_WAVE) + 1)), sGGSMData.sPowerUp)
		sGGSMData.bDebugCreatePowerUp = FALSE
	ENDIF 
	
	IF (sGGSMData.bDebugSetStage)
		GGSM_SET_CLIENT_STATE(GGSM_STATE_STAGE_SELECT)
		sGGSMData.bDebugSetStage = FALSE 
	ENDIF 
	
	REPEAT COUNT_OF(sGGSMData.sBossController) i
		IF (sGGSMData.sBossController[i].bDebugSetState)
			GGSM_BOSS_CONTROLLER_SET_STATE(sGGSMData.sBossController[i], INT_TO_ENUM(GGSM_BOSS_STATE, sGGSMData.sBossController[i].iDebugSetState))
			sGGSMData.sBossController[i].bDebugSetState = FALSE 
		ENDIF 
		sGGSMData.sBossController[i].iCurrentState = ENUM_TO_INT(sGGSMData.sBossController[i].eState)
	ENDREPEAT
	
	#IF GGSM_CHALLENGE_DEBUG
		GGSM_UPDATE_CHALLENGE_DEBUG_WIDGET()
	#ENDIF
	
	#IF GGSM_DEBUG_TSHIRT_HELP
		GGSM_UPDATE_TSHIRT_DEBUG_WIDGET()
	#ENDIF
			
	#IF GGSM_ENTITY_EDITOR_ACTIVE
		GGSM_ENTITY_EDITOR_WIDGET_UPDATE(sGGSMData.sDebugEntityEditor)
	#ENDIF 
			
	#IF GGSM_SPAWN_EDITOR_ACTIVE
		GGSM_SPAWN_EDITOR_WIDGET_UPDATE(sGGSMData.sDebugSpawnEditor)
	#ENDIF
			
	#IF GGSM_TILEMAP_EDITOR_ACTIVE
		GGSM_TILEMAP_EDITOR_WIDGET_UPDATE(sGGSMData.sDebugMapEditor, sGGSMData.sTileMap)
	#ENDIF
	
	#IF GGSM_SOUND_TEST
		ARCADE_GAMES_SOUND_WIDGET_CREATE()
	#ENDIF 
	
	IF (sGGSMData.bDrawDebugRect)
		INIT_RGBA_STRUCT(rcol, 255, 255, 255, 64)
		
		IF (sGGSMData.bDebugRectCenterMode = FALSE) 
			rs.x = sGGSMData.vDebugRect[1].x - sGGSMData.vDebugRect[0].x
			rs.y = sGGSMData.vDebugRect[1].y - sGGSMData.vDebugRect[0].y
			rc.x = sGGSMData.vDebugRect[0].x + (rs.x / 2.0)
			rc.y = sGGSMData.vDebugRect[0].y + (rs.y / 2.0)
			ARCADE_DRAW_PIXELSPACE_RECT(rc, rs, rcol)
		ELSE 
			ARCADE_DRAW_PIXELSPACE_RECT(sGGSMData.vDebugRect[0], sGGSMData.vDebugRect[1], rcol)
		ENDIF 
	ENDIF 
	
	IF (sGGSMData.bDebugJumpToBoss)
		i = sGGSMData.iSpawnsUsed - 1
		sGGSMData.iSpawnIndexCounter = i
		sGGSMData.bDebugKillAllEnemies = TRUE 
		GGSM_CAMERA_JUMP_TO_DISTANCE(sGGSMData.sCamera, sGGSMData.sSpawnData[i].fScrollDistance)
		sGGSMData.bDebugJumpToBoss = FALSE
	ENDIF 
	
	IF (sGGSMData.bDebugKillAllEnemies)
		GGSM_ENTITY_EXPLODE_ARRAY(sGGSMData.sEntities, FALSE)
		sGGSMData.bDebugKillAllEnemies = FALSE
	ENDIF
	
	IF (sGGSMData.bDebugPlayerInvunerable)
		GGSM_SET_PLAYER_INVUNERABLE()
	ENDIF
	
	IF (sGGSMData.bShowSpawnDebug)
		GGSM_DRAW_SPAWN_DEBUG()
	ENDIF
ENDPROC

#ENDIF

//-------------------------------------------------
// PER FRAME UPDATES
//-------------------------------------------------

/// PURPOSE:
///    Handles Script Events
PROC GGSM_PROCESS_SCRIPT_EVENTS()
ENDPROC

/// PURPOSE:
///    Run every frame before the client state machine is processed
PROC GGSM_PRE_UPDATE()	
	IF sGGSMData.eState >= GGSM_STATE_CLEANUP
		// Cleaning up, don't do anything
		EXIT
	ENDIF
	
	IF NOT IS_SKYSWOOP_AT_GROUND() 
		GGSM_SET_CLIENT_STATE(GGSM_STATE_CLEANUP)
		EXIT
	ENDIF
	
	GGSM_UPDATE_MAIN_TIMERS()
	GGSM_PROCESS_SCRIPT_EVENTS()
	GGSM_UPDATE_AVATAR()
	ARCADE_GAMES_LEADERBOARD_PROCESS_EVENTS()
	ARCADE_GAMES_LEADERBOARD_LOAD(CASINO_ARCADE_GAME_GO_GO_SPACE_MONKEY_3)
	ARCADE_GAMES_HELP_TEXT_PRE_UPDATE()
	
	BOOL bIsPlaying = (sGGSMData.eState >= GGSM_STATE_PLAYING)
	ARCADE_CABINET_COMMON_EVERY_FRAME_PROCESSING(bIsPlaying)
ENDPROC
	
/// PURPOSE:
///    Run every frame after the client state machine is processed
PROC GGSM_POST_UPDATE()	
    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_GGSM()
	GGSM_PRE_UPDATE()
	GGSM_PROCESS_CLIENT_STATE_MACHINE()
	GGSM_POST_UPDATE()	
	
	#IF IS_DEBUG_BUILD
		GGSM_DEBUG_PROCESSING()	
	#ENDIF
ENDPROC