857 lines
35 KiB
Scheme
Executable File
857 lines
35 KiB
Scheme
Executable File
//╒═════════════════════════════════════════════════════════════════════════════╕
|
|
//│ Author: Adam Westwood Date: 12/07/14 │
|
|
//╞═════════════════════════════════════════════════════════════════════════════╡
|
|
//│ │
|
|
//│ Drill Minigame │
|
|
//│ │
|
|
//│ Controls the drill minigame │
|
|
//| │
|
|
//│ │
|
|
//╘═════════════════════════════════════════════════════════════════════════════╛
|
|
|
|
USING "timer_public.sch"
|
|
|
|
USING "rage_builtins.sch"
|
|
USING "globals.sch"
|
|
|
|
USING "commands_audio.sch"
|
|
USING "commands_camera.sch"
|
|
USING "commands_clock.sch"
|
|
USING "commands_debug.sch"
|
|
USING "commands_fire.sch"
|
|
USING "commands_graphics.sch"
|
|
USING "commands_hud.sch"
|
|
USING "commands_misc.sch"
|
|
USING "commands_object.sch"
|
|
USING "commands_pad.sch"
|
|
USING "commands_ped.sch"
|
|
USING "commands_player.sch"
|
|
USING "commands_script.sch"
|
|
USING "commands_streaming.sch"
|
|
USING "commands_task.sch"
|
|
USING "commands_vehicle.sch"
|
|
USING "commands_interiors.sch"
|
|
USING "net_include.sch"
|
|
|
|
USING "model_enums.sch"
|
|
USING "script_player.sch"
|
|
USING "script_misc.sch"
|
|
USING "selector_public.sch"
|
|
USING "timer_public.sch"
|
|
|
|
USING "LineActivation.sch"
|
|
|
|
#IF IS_DEBUG_BUILD
|
|
USING "shared_debug.sch"
|
|
USING "script_debug.sch"
|
|
#ENDIF
|
|
|
|
CONST_INT DRILL_MINIGAME_STATE_INITIALISE 0
|
|
CONST_INT DRILL_MINIGAME_STATE_DRILLING 1
|
|
CONST_INT DRILL_MINIGAME_STATE_CLEANUP 2
|
|
|
|
CONST_INT DRILL_BITSET_IS_IN_SWEET_SPOT 0
|
|
CONST_INT DRILL_BITSET_IS_MINIGAME_COMPLETE 1
|
|
CONST_INT DRILL_BITSET_DID_PLAYER_MESS_UP 2
|
|
CONST_INT DRILL_BITSET_DID_PLAYER_MESS_UP_ON_LEFT_SIDE 4
|
|
CONST_INT DRILL_BITSET_DID_PLAYER_BACK_OUT 5
|
|
CONST_INT DRILL_BITSET_SKIP_WALK_TO_POSITION 6
|
|
CONST_INT DRILL_BITSET_HAS_BROADCAST_ASSET_REQUEST 7
|
|
|
|
CONST_FLOAT DRILL_MAX_SWEET_SPOT_SIZE 0.25 //0.2 - Rob - 2167673 - make drilling game twice as long (compensate a little for decreased speed)
|
|
CONST_FLOAT DRILL_MIN_SWEET_SPOT_SIZE 0.15
|
|
CONST_FLOAT DRILL_MAX_PROGRESS_SPEED 0.025 //0.07 - Rob - 2167673 - make drilling game twice as long
|
|
CONST_FLOAT DRILL_MIN_PROGRESS_SPEED 0.0
|
|
CONST_FLOAT DRILL_COOLDOWN_SPEED 0.08
|
|
CONST_FLOAT DRILL_OVERHEAT_SPEED 0.35 //0.4 - Rob - 2167673 - make drilling game twice as long (compensate a little for decreased speed)
|
|
CONST_FLOAT DRILL_LEAN_INTERP_SPEED 0.2
|
|
CONST_FLOAT DRILL_POS_SCALE_MODIFIER 0.82
|
|
CONST_FLOAT DRILL_PASS_POINT 0.775
|
|
CONST_FLOAT DRILL_START_POINT 0.08
|
|
CONST_FLOAT DRILL_PIN_BREAK_POWER_MODIFER_MAX 0.5
|
|
CONST_FLOAT DRILL_PIN_BREAK_POWER_MODIFIER_DECEL 0.4
|
|
|
|
STRUCT S_DRILL_DATA
|
|
INT iBitset
|
|
INT iHUDFlashTimer
|
|
INT iCurrentState
|
|
INT iDrillSoundID = -1
|
|
INT iSyncScene
|
|
INT iPassTimer
|
|
INT iAudioEvent
|
|
//INT iMoveNetworkSignalState
|
|
FLOAT fCurrentDrillPosY
|
|
FLOAT fCurrentDrillBasePosX
|
|
FLOAT fCurrentDrillPower
|
|
FLOAT fPinBreakPowerModifier
|
|
FLOAT fCurrentProgress
|
|
FLOAT fCurrentSweetSpotHeight
|
|
FLOAT fCurrentSweetSpotMin
|
|
FLOAT fCurrentSweetSpotMax
|
|
FLOAT fCurrentHeatLevel
|
|
FLOAT fCurrentProgressIncreaseSpeed
|
|
FLOAT fCurrentLeanPos
|
|
FLOAT fCurrentForwardLeanPos
|
|
FLOAT fForwardLeanExtraAmountForPins
|
|
FLOAT fCurrentDrillAnimPower
|
|
FLOAT fCurrentDrillBitPos
|
|
FLOAT fDrillBitShakeOffset
|
|
FLOAT fDesiredDrillBitShakeOffset
|
|
FLOAT fCurrentCamShake
|
|
FLOAT fCamRotOffset
|
|
FLOAT fDesiredCamRotOffset
|
|
FLOAT fCamHeightOffset
|
|
FLOAT fDesiredCamHeightOffset
|
|
FLOAT fDrillBitAnimSpeed
|
|
FLOAT fHudPosX = 0.82
|
|
FLOAT fHudPosY = 0.83
|
|
|
|
CAMERA_INDEX cam
|
|
SCALEFORM_INDEX sfDrillHud
|
|
|
|
VECTOR vCamPointPos
|
|
VECTOR vCamStartPos
|
|
|
|
#IF IS_DEBUG_BUILD
|
|
BOOL bDisplayDebug
|
|
INT iDebugNumPrintsThisFrame
|
|
#ENDIF
|
|
ENDSTRUCT
|
|
|
|
// PC CONTROL FOR DRILLING MINIGAME
|
|
BOOL bPCCOntrolsSetup = FALSE
|
|
|
|
PROC SETUP_PC_DRILLING_CONTROLS()
|
|
|
|
IF IS_PC_VERSION()
|
|
IF bPCCOntrolsSetup = FALSE
|
|
CDEBUG1LN(DEBUG_MISSION, "[RUN_DRILL_MINIGAME]- Setup PC controls" )
|
|
INIT_PC_SCRIPTED_CONTROLS("MP DRILL MINIGAME")
|
|
bPCCOntrolsSetup = TRUE
|
|
ENDIF
|
|
ENDIF
|
|
ENDPROC
|
|
|
|
PROC CLEANUP_PC_DRILLING_CONTROLS()
|
|
|
|
IF IS_PC_VERSION()
|
|
IF bPCCOntrolsSetup = TRUE
|
|
CDEBUG1LN(DEBUG_MISSION, "[RUN_DRILL_MINIGAME]- Cleanup PC controls" )
|
|
SHUTDOWN_PC_SCRIPTED_CONTROLS()
|
|
bPCCOntrolsSetup = FALSE
|
|
ENDIF
|
|
ENDIF
|
|
ENDPROC
|
|
|
|
/// REQUEST_DRILL_MINIGAME_ASSETS()
|
|
/// NOTES:
|
|
/// PURPOSE:
|
|
/// checking assets are loaded
|
|
/// PARAMS:
|
|
/// RETURNS:
|
|
PROC REQUEST_DRILL_MINIGAME_ASSETS(S_DRILL_DATA &sDrillData)
|
|
REQUEST_ANIM_DICT("anim@heists@fleeca_bank@drilling")
|
|
REQUEST_MODEL(HEI_PROP_HEIST_DEPOSIT_BOX)
|
|
REQUEST_MODEL(hei_prop_heist_drill)
|
|
REQUEST_MODEL(HEI_P_M_BAG_VAR22_ARM_S)
|
|
REQUEST_MODEL(HEI_PROP_HEI_DRILL_HOLE)
|
|
REQUEST_SCRIPT_AUDIO_BANK("DLC_MPHEIST\\HEIST_FLEECA_DRILL")
|
|
REQUEST_SCRIPT_AUDIO_BANK("DLC_MPHEIST\\HEIST_FLEECA_DRILL_2")
|
|
REQUEST_NAMED_PTFX_ASSET("fm_mission_controler")
|
|
|
|
IF sDrillData.sfDrillHud = NULL
|
|
sDrillData.sfDrillHud = REQUEST_SCALEFORM_MOVIE("DRILLING")
|
|
ENDIF
|
|
ENDPROC
|
|
|
|
/// HAVE_DRILL_ASSETS_LOADED()
|
|
/// NOTES:
|
|
/// PURPOSE:
|
|
/// checking assets are loaded
|
|
/// PARAMS:
|
|
/// RETURNS:
|
|
FUNC BOOL HAVE_DRILL_ASSETS_LOADED(S_DRILL_DATA &sDrillData)
|
|
REQUEST_ANIM_DICT("anim@heists@fleeca_bank@drilling")
|
|
REQUEST_MODEL(HEI_PROP_HEIST_DEPOSIT_BOX)
|
|
REQUEST_MODEL(hei_prop_heist_drill)
|
|
REQUEST_MODEL(HEI_P_M_BAG_VAR22_ARM_S)
|
|
IF HAS_ANIM_DICT_LOADED("anim@heists@fleeca_bank@drilling")
|
|
AND HAS_MODEL_LOADED(HEI_PROP_HEIST_DEPOSIT_BOX)
|
|
AND HAS_MODEL_LOADED(hei_prop_heist_drill)
|
|
AND HAS_MODEL_LOADED(HEI_P_M_BAG_VAR22_ARM_S)
|
|
AND HAS_MODEL_LOADED(HEI_PROP_HEI_DRILL_HOLE)
|
|
AND HAS_NAMED_PTFX_ASSET_LOADED("fm_mission_controler")
|
|
AND HAS_SCALEFORM_MOVIE_LOADED(sDrillData.sfDrillHud)
|
|
AND REQUEST_SCRIPT_AUDIO_BANK("DLC_MPHEIST\\HEIST_FLEECA_DRILL")
|
|
AND REQUEST_SCRIPT_AUDIO_BANK("DLC_MPHEIST\\HEIST_FLEECA_DRILL_2")
|
|
RETURN TRUE
|
|
ENDIF
|
|
|
|
RETURN FALSE
|
|
ENDFUNC
|
|
|
|
PROC RESET_DRILL_MINIGAME_DATA(S_DRILL_DATA &sDrillData)
|
|
sDrillData.iBitset = 0
|
|
sDrillData.iHUDFlashTimer = 0
|
|
sDrillData.iCurrentState = 0
|
|
sDrillData.iAudioEvent = 0
|
|
sDrillData.fCurrentDrillPosY = 0.0
|
|
sDrillData.fCurrentDrillBitPos = 0.0
|
|
sDrillData.fDrillBitShakeOffset = 0.0
|
|
sDrillData.fCurrentDrillBasePosX = 0.0
|
|
sDrillData.fCurrentDrillPower = 0.0
|
|
sDrillData.fCurrentProgress = 0.0
|
|
sDrillData.fCurrentSweetSpotHeight = DRILL_MAX_SWEET_SPOT_SIZE
|
|
sDrillData.fCurrentSweetSpotMin = 0.0
|
|
sDrillData.fCurrentSweetSpotMax = 0.0
|
|
sDrillData.fCurrentHeatLevel = 0.0
|
|
sDrillData.fCurrentProgressIncreaseSpeed = 0.0
|
|
sDrillData.fForwardLeanExtraAmountForPins = 0.0
|
|
sDrillData.fPinBreakPowerModifier = 0.0
|
|
ENDPROC
|
|
|
|
/// PURPOSE:
|
|
/// Checks if it's okay to run the drilling minigame.
|
|
FUNC BOOL IS_SAFE_TO_PLAY_DRILL_MINIGAME()
|
|
//Currently just one check: may be expanded in the future.
|
|
IF NOT IS_CUTSCENE_PLAYING()
|
|
RETURN TRUE
|
|
ENDIF
|
|
|
|
RETURN FALSE
|
|
ENDFUNC
|
|
|
|
FUNC BOOL MANAGE_DRILL_TIMER(INT &iStartTime, INT iTimeToWait)
|
|
RETURN (GET_GAME_TIMER() - iStartTime > iTimeToWait)
|
|
ENDFUNC
|
|
|
|
PROC FORCE_QUIT_FAIL_DRILL_MINIGAME_KEEP_DATA(S_DRILL_DATA &drill_data, BOOL bResetData = TRUE)
|
|
IF IS_MINIGAME_IN_PROGRESS()
|
|
SET_MINIGAME_IN_PROGRESS(FALSE)
|
|
ENDIF
|
|
CLEAR_HELP()
|
|
NET_SET_PLAYER_CONTROL(PLAYER_ID(), TRUE)
|
|
DISABLE_CELLPHONE(FALSE)
|
|
DISABLE_SCRIPT_HUD_THIS_FRAME_RESET()
|
|
|
|
IF bResetData
|
|
RESET_DRILL_MINIGAME_DATA(drill_data)
|
|
ENDIF
|
|
ENDPROC
|
|
|
|
PROC FORCE_QUIT_PASS_DRILL_MINIGAME_KEEP_DATA(S_DRILL_DATA &drill_data, BOOL bResetData = TRUE, BOOL bClearTasks = TRUE, BOOL bRestoreControl = TRUE)
|
|
IF IS_MINIGAME_IN_PROGRESS()
|
|
SET_MINIGAME_IN_PROGRESS(FALSE)
|
|
ENDIF
|
|
|
|
IF bClearTasks
|
|
CLEAR_PED_TASKS(PLAYER_PED_ID())
|
|
ENDIF
|
|
|
|
CLEAR_HELP()
|
|
IF bRestoreControl
|
|
NET_SET_PLAYER_CONTROL(PLAYER_ID(), TRUE)
|
|
ENDIF
|
|
DISABLE_CELLPHONE(FALSE)
|
|
DISABLE_SCRIPT_HUD_THIS_FRAME_RESET()
|
|
|
|
CLEANUP_PC_DRILLING_CONTROLS()
|
|
|
|
IF bResetData
|
|
RESET_DRILL_MINIGAME_DATA(drill_data)
|
|
ENDIF
|
|
ENDPROC
|
|
|
|
FUNC BOOL HAS_PLAYER_BEAT_DRILL_MINIGAME(S_DRILL_DATA &sDrillData, BOOL bForceQuit = FALSE)
|
|
IF IS_BIT_SET(sDrillData.iBitset, DRILL_BITSET_IS_MINIGAME_COMPLETE)
|
|
IF bForceQuit
|
|
FORCE_QUIT_PASS_DRILL_MINIGAME_KEEP_DATA(sDrillData)
|
|
ENDIF
|
|
|
|
RETURN TRUE
|
|
ENDIF
|
|
|
|
RETURN FALSE
|
|
ENDFUNC
|
|
|
|
PROC INITIALISE_MINIGAME_VALUES(S_DRILL_DATA &sDrillData)
|
|
IF NOT IS_BIT_SET(sDrillData.iBitset, DRILL_BITSET_DID_PLAYER_MESS_UP)
|
|
IF NOT IS_BIT_SET(sDrillData.iBitset, DRILL_BITSET_DID_PLAYER_BACK_OUT)
|
|
sDrillData.fCurrentProgress = DRILL_START_POINT
|
|
sDrillData.iAudioEvent = 0
|
|
ENDIF
|
|
|
|
sDrillData.fCurrentHeatLevel = 0.0
|
|
ENDIF
|
|
|
|
sDrillData.iHUDFlashTimer = 0
|
|
sDrillData.iCurrentState = 0
|
|
sDrillData.fCurrentDrillPosY = 0.0
|
|
sDrillData.fCurrentDrillBitPos = 0.0
|
|
sDrillData.fDrillBitShakeOffset = 0.0
|
|
sDrillData.fCurrentDrillBasePosX = 0.0
|
|
sDrillData.fCurrentDrillPower = 0.0
|
|
sDrillData.fCurrentProgressIncreaseSpeed = 0.0
|
|
sDrillData.fCurrentForwardLeanPos = 0.0
|
|
sDrillData.fForwardLeanExtraAmountForPins = 0.0
|
|
sDrillData.fPinBreakPowerModifier = 0.0
|
|
|
|
sDrillData.fCurrentSweetSpotHeight = DRILL_MAX_SWEET_SPOT_SIZE
|
|
sDrillData.fCurrentSweetSpotMax = sDrillData.fCurrentProgress
|
|
sDrillData.fCurrentSweetSpotMin = sDrillData.fCurrentSweetSpotMax - DRILL_MAX_SWEET_SPOT_SIZE
|
|
|
|
IF sDrillData.fCurrentSweetSpotMin < 0.0
|
|
sDrillData.fCurrentSweetSpotMin = 0.0
|
|
ENDIF
|
|
|
|
CLEAR_BIT(sDrillData.iBitset, DRILL_BITSET_IS_MINIGAME_COMPLETE)
|
|
CLEAR_BIT(sDrillData.iBitset, DRILL_BITSET_DID_PLAYER_MESS_UP)
|
|
ENDPROC
|
|
|
|
/*FUNC BOOL IS_DRILL_IN_SWEET_SPOT(S_DRILL_DATA &sDrillData)
|
|
IF sDrillData.fCurrentDrillPosY >= sDrillData.fCurrentSweetSpotMin
|
|
AND sDrillData.fCurrentDrillPosY <= sDrillData.fCurrentSweetSpotMax
|
|
RETURN TRUE
|
|
ENDIF
|
|
|
|
RETURN FALSE
|
|
ENDFUNC*/
|
|
|
|
PROC SET_PLAYER_BACKED_OUT_OF_DRILLING(S_DRILL_DATA &sDrillData)
|
|
SET_BIT(sDrillData.iBitset, DRILL_BITSET_DID_PLAYER_BACK_OUT)
|
|
ENDPROC
|
|
|
|
FUNC BOOL HAS_PLAYER_BACKED_OUT_OF_DRILLING(S_DRILL_DATA &sDrillData)
|
|
RETURN IS_BIT_SET(sDrillData.iBitset, DRILL_BITSET_DID_PLAYER_BACK_OUT)
|
|
ENDFUNC
|
|
|
|
PROC PLAYER_MESSED_UP_DRILLING(S_DRILL_DATA &sDrillData)
|
|
SET_CONTROL_SHAKE(PLAYER_CONTROL, 2000, 220)
|
|
|
|
SET_BIT(sDrillData.iBitset, DRILL_BITSET_DID_PLAYER_MESS_UP)
|
|
|
|
IF sDrillData.fCurrentDrillBasePosX <= 0.0
|
|
SET_BIT(sDrillData.iBitset, DRILL_BITSET_DID_PLAYER_MESS_UP_ON_LEFT_SIDE)
|
|
ELSE
|
|
CLEAR_BIT(sDrillData.iBitset, DRILL_BITSET_DID_PLAYER_MESS_UP_ON_LEFT_SIDE)
|
|
ENDIF
|
|
ENDPROC
|
|
|
|
FUNC BOOL HAS_PLAYER_MESSED_UP_DRILLING(S_DRILL_DATA &sDrillData)
|
|
RETURN IS_BIT_SET(sDrillData.iBitset, DRILL_BITSET_DID_PLAYER_MESS_UP)
|
|
ENDFUNC
|
|
|
|
/// PURPOSE:
|
|
/// Returns whether the player was leaning on the left side when they messed up the drilling minigame. Useful for
|
|
/// working out which transition anim to play.
|
|
FUNC BOOL DID_PLAYER_MESS_UP_DRILLING_ON_LEFT_SIDE(S_DRILL_DATA &sDrillData)
|
|
RETURN IS_BIT_SET(sDrillData.iBitset, DRILL_BITSET_DID_PLAYER_MESS_UP_ON_LEFT_SIDE)
|
|
ENDFUNC
|
|
|
|
/// PURPOSE:
|
|
/// Calculates a skew value for the drill's sideways movement: the skew forces the player to compensate their own movement to avoid hitting the edges.
|
|
/// The skew changes with the current progress of the drill.
|
|
/*FUNC FLOAT GET_CURRENT_DRILL_POSITION_SKEW(S_DRILL_DATA &sDrillData)
|
|
FLOAT fSkew = 0.0
|
|
|
|
IF sDrillData.fCurrentProgress > 0.3
|
|
fSkew = 1.15 * SIN(600.0 * (sDrillData.fCurrentProgress - 0.3))
|
|
ENDIF
|
|
|
|
RETURN fSkew
|
|
ENDFUNC*/
|
|
|
|
PROC SHAKE_DRILL_BIT(S_DRILL_DATA &sDrillData)
|
|
IF sDrillData.fCurrentDrillPosY > sDrillData.fCurrentSweetSpotMax
|
|
IF ABSF(sDrillData.fDesiredDrillBitShakeOffset - sDrillData.fDrillBitShakeOffset) < 0.002
|
|
sDrillData.fDesiredDrillBitShakeOffset = GET_RANDOM_FLOAT_IN_RANGE(-0.04, 0.0)
|
|
ENDIF
|
|
ELSE
|
|
sDrillData.fDesiredDrillBitShakeOffset = 0.0
|
|
ENDIF
|
|
|
|
sDrillData.fDrillBitShakeOffset = LERP_FLOAT(sDrillData.fDrillBitShakeOffset, sDrillData.fDesiredDrillBitShakeOffset, 1.0)
|
|
ENDPROC
|
|
|
|
//Old HUD, due to be replaced by Scaleform.
|
|
/*PROC DRAW_DRILL_MINIGAME_HUD(S_DRILL_DATA &sDrillData)
|
|
IF CAN_INGAME_HUD_ELEMENTS_DISPLAY()
|
|
CONST_FLOAT DRILL_HUD_CENTRE_X 0.85
|
|
CONST_FLOAT DRILL_HUD_CENTRE_Y 0.8
|
|
CONST_FLOAT DRILL_HUD_HEIGHT 0.2
|
|
CONST_FLOAT DRILL_HUD_WIDTH 0.03
|
|
CONST_FLOAT DRILL_HUD_PROGRESS_HEIGHT 0.18
|
|
CONST_FLOAT DRILL_HUD_PROGRESS_WIDTH 0.025
|
|
CONST_FLOAT DRILL_HUD_INDICATOR_SIZE 0.003
|
|
|
|
BOOL bFlashHUD = FALSE
|
|
INT iR, iG, iB
|
|
INT iScreenSizeX
|
|
INT iScreenSizeY
|
|
GET_SCREEN_RESOLUTION(iScreenSizeX, iScreenSizeY)
|
|
|
|
FLOAT fAspectRatio = TO_FLOAT(iScreenSizeX) / TO_FLOAT(iScreenSizeY)
|
|
|
|
//Work out the colour for the progress bar: colour is based on heat level. Try to get the colour to gradually turn from green to red.
|
|
//Roughly the colours should be:
|
|
// heat = 0.0 colour = green
|
|
// heat - 0.25 colour = yellow
|
|
// heat = 0.5 colour = orange
|
|
// heat = 0.75 colour = red
|
|
// heat = 1.0 colour = dark red
|
|
IF sDrillData.fCurrentHeatLevel >= 0.75
|
|
//Increase red value where heat 1.0 = 128 and heat 0.75 = 255
|
|
iR = 128 + ROUND(((0.25 - (sDrillData.fCurrentHeatLevel - 0.75)) / 0.25) * 127.0)
|
|
ELIF sDrillData.fCurrentHeatLevel < 0.25
|
|
iR = ROUND((sDrillData.fCurrentHeatLevel / 0.25) * 255.0)
|
|
ELSE
|
|
iR = 255
|
|
ENDIF
|
|
|
|
IF sDrillData.fCurrentHeatLevel >= 0.75
|
|
iG = 0
|
|
ELIF sDrillData.fCurrentHeatLevel >= 0.25
|
|
//Increase green value where heat 0.75 = 0 and heat 0.25 = 255
|
|
iG = ROUND(((0.5 - (sDrillData.fCurrentHeatLevel - 0.25)) / 0.5) * 255.0)
|
|
ELSE
|
|
iG = 255
|
|
ENDIF
|
|
|
|
iB = 0
|
|
|
|
//If the player is outside the sweet spot then flash the whole bar.
|
|
IF NOT IS_BIT_SET(sDrillData.iBitset, DRILL_BITSET_IS_IN_SWEET_SPOT)
|
|
AND sDrillData.fCurrentDrillPower > 0.0
|
|
IF sDrillData.iHUDFlashTimer = 0
|
|
OR GET_GAME_TIMER() - sDrillData.iHUDFlashTimer > 300
|
|
sDrillData.iHUDFlashTimer = GET_GAME_TIMER()
|
|
ELSE
|
|
IF GET_GAME_TIMER() - sDrillData.iHUDFlashTimer < 100
|
|
bFlashHUD = TRUE
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
|
|
//Draw the background (black background plus a progress background).
|
|
DRAW_RECT(DRILL_HUD_CENTRE_X, DRILL_HUD_CENTRE_Y, DRILL_HUD_WIDTH, DRILL_HUD_HEIGHT, 0, 0, 0, 128)
|
|
|
|
IF bFlashHUD
|
|
DRAW_RECT(DRILL_HUD_CENTRE_X, DRILL_HUD_CENTRE_Y, DRILL_HUD_PROGRESS_WIDTH, DRILL_HUD_PROGRESS_HEIGHT, 255, 255, 255, 255)
|
|
ELSE
|
|
DRAW_RECT(DRILL_HUD_CENTRE_X, DRILL_HUD_CENTRE_Y, DRILL_HUD_PROGRESS_WIDTH, DRILL_HUD_PROGRESS_HEIGHT, ROUND(TO_FLOAT(iR) * 0.25), ROUND(TO_FLOAT(iG) * 0.25), ROUND(TO_FLOAT(iB) * 0.25), 255)
|
|
ENDIF
|
|
|
|
//Draw the progress bar.
|
|
FLOAT fProgressBarHeight = sDrillData.fCurrentProgress * DRILL_HUD_PROGRESS_HEIGHT
|
|
FLOAT fProgressBarCentreY = DRILL_HUD_CENTRE_Y + (DRILL_HUD_PROGRESS_HEIGHT * 0.5) - (fProgressBarHeight * 0.5)
|
|
|
|
IF bFlashHUD
|
|
DRAW_RECT(DRILL_HUD_CENTRE_X, fProgressBarCentreY, DRILL_HUD_PROGRESS_WIDTH, fProgressBarHeight, 255, 255, 255, 255)
|
|
ELSE
|
|
DRAW_RECT(DRILL_HUD_CENTRE_X, fProgressBarCentreY, DRILL_HUD_PROGRESS_WIDTH, fProgressBarHeight, iR, iG, iB, 255)
|
|
ENDIF
|
|
|
|
//Draw the sweet spot.
|
|
FLOAT fSweetSpotHeight = (sDrillData.fCurrentSweetSpotMax - sDrillData.fCurrentSweetSpotMin) * DRILL_HUD_PROGRESS_HEIGHT
|
|
FLOAT fSweetSpotCentreY = DRILL_HUD_CENTRE_Y + (DRILL_HUD_PROGRESS_HEIGHT * 0.5) - fProgressBarHeight + (fSweetSpotHeight * 0.5)
|
|
|
|
IF bFlashHUD
|
|
DRAW_RECT(DRILL_HUD_CENTRE_X, fSweetSpotCentreY, DRILL_HUD_PROGRESS_WIDTH, fSweetSpotHeight, 255, 255, 255, 255)
|
|
ELSE
|
|
DRAW_RECT(DRILL_HUD_CENTRE_X, fSweetSpotCentreY, DRILL_HUD_PROGRESS_WIDTH, fSweetSpotHeight, 0, 96, 255, 255)
|
|
ENDIF
|
|
|
|
//Draw the drill indicator.
|
|
FLOAT fIndicatorPosX = DRILL_HUD_CENTRE_X + (sDrillData.fCurrentDrillSkewedPosX * DRILL_HUD_PROGRESS_WIDTH * 0.5)
|
|
FLOAT fIndicatorPosY = DRILL_HUD_CENTRE_Y + (DRILL_HUD_PROGRESS_HEIGHT * 0.5) - (sDrillData.fCurrentDrillPosY * DRILL_HUD_PROGRESS_HEIGHT)
|
|
DRAW_RECT(fIndicatorPosX, fIndicatorPosY, DRILL_HUD_INDICATOR_SIZE, DRILL_HUD_INDICATOR_SIZE * fAspectRatio, 255, 255, 255, 255)
|
|
ENDIF
|
|
ENDPROC*/
|
|
|
|
//New version of HUD using scaleform movie.
|
|
PROC DRAW_DRILL_MINIGAME_SCALEFORM_HUD(S_DRILL_DATA &sDrillData)
|
|
IF CAN_INGAME_HUD_ELEMENTS_DISPLAY()
|
|
AND IS_SAFE_TO_PLAY_DRILL_MINIGAME()
|
|
HIDE_HUD_AND_RADAR_THIS_FRAME()
|
|
THEFEED_HIDE_THIS_FRAME()
|
|
|
|
//NOTE: with the current UI the drill starts to strobe at max power, so adjust the input value slightly. This also lets us boost the speed when we hit a pin (2207563)
|
|
CALL_SCALEFORM_MOVIE_METHOD_WITH_NUMBER(sDrillData.sfDrillHud, "SET_SPEED", (sDrillData.fCurrentDrillPower * 0.79) + (sDrillData.fPinBreakPowerModifier * 0.08))
|
|
CALL_SCALEFORM_MOVIE_METHOD_WITH_NUMBER(sDrillData.sfDrillHud, "SET_HOLE_DEPTH", sDrillData.fCurrentProgress)
|
|
CALL_SCALEFORM_MOVIE_METHOD_WITH_NUMBER(sDrillData.sfDrillHud, "SET_DRILL_POSITION", sDrillData.fCurrentDrillBitPos + sDrillData.fDrillBitShakeOffset)
|
|
CALL_SCALEFORM_MOVIE_METHOD_WITH_NUMBER(sDrillData.sfDrillHud, "SET_TEMPERATURE", sDrillData.fCurrentHeatLevel)
|
|
|
|
DRAW_SCALEFORM_MOVIE_FULLSCREEN(sDrillData.sfDrillHUD, 255, 255, 255, 255)
|
|
//DRAW_SCALEFORM_MOVIE(sDrillData.sfDrillHUD, sDrillData.fHudPosX, sDrillData.fHudPosY, 0.6, 0.8, 255, 255, 255, 255)
|
|
ENDIF
|
|
ENDPROC
|
|
|
|
#IF IS_DEBUG_BUILD
|
|
PROC DRAW_STRING_TO_DRILL_DEBUG(S_DRILL_DATA &sDrillData, STRING strDebug)
|
|
SET_DEBUG_LINES_AND_SPHERES_DRAWING_ACTIVE(TRUE)
|
|
DRAW_DEBUG_TEXT_2D(strDebug, <<0.05, 0.04 + (0.04 * sDrillData.iDebugNumPrintsThisFrame), 0.0>>, 0, 0, 255, 255)
|
|
sDrillData.iDebugNumPrintsThisFrame++
|
|
ENDPROC
|
|
|
|
PROC DRAW_INT_TO_DRILL_DEBUG(S_DRILL_DATA &sDrillData, INT iDebug, STRING strLabel)
|
|
TEXT_LABEL_63 strConcat = strLabel
|
|
strConcat += iDebug
|
|
|
|
DRAW_STRING_TO_DRILL_DEBUG(sDrillData, strConcat)
|
|
ENDPROC
|
|
|
|
PROC DRAW_FLOAT_TO_DRILL_DEBUG(S_DRILL_DATA &sDrillData, FLOAT fDebug, STRING strLabel)
|
|
TEXT_LABEL_63 strConcat = strLabel
|
|
strConcat += " "
|
|
strConcat += GET_STRING_FROM_FLOAT(fDebug)
|
|
|
|
DRAW_STRING_TO_DRILL_DEBUG(sDrillData, strConcat)
|
|
ENDPROC
|
|
|
|
PROC DUMP_DRILL_MINIGAME_STATE_TO_CONSOLE(S_DRILL_DATA &sDrillData)
|
|
INT iCurrentTime = GET_GAME_TIMER()
|
|
|
|
CDEBUG1LN(DEBUG_MISSION, "[RUN_DRILL_MINIGAME] Dumping script state, current game time = ", iCurrentTime)
|
|
CDEBUG1LN(DEBUG_MISSION, "[RUN_DRILL_MINIGAME] iCurrentState = ", sDrillData.iCurrentState)
|
|
CDEBUG1LN(DEBUG_MISSION, "[RUN_DRILL_MINIGAME] iBitset = ", sDrillData.iBitSet)
|
|
CDEBUG1LN(DEBUG_MISSION, "[RUN_DRILL_MINIGAME] iHUDFlashTimer = ", sDrillData.iHUDFlashTimer)
|
|
CDEBUG1LN(DEBUG_MISSION, "[RUN_DRILL_MINIGAME] fCurrentDrillPosY = ", sDrillData.fCurrentDrillPosY)
|
|
CDEBUG1LN(DEBUG_MISSION, "[RUN_DRILL_MINIGAME] fCurrentDrillBasePosX = ", sDrillData.fCurrentDrillBasePosX)
|
|
CDEBUG1LN(DEBUG_MISSION, "[RUN_DRILL_MINIGAME] fCurrentDrillBitPos = ", sDrillData.fCurrentDrillBitPos)
|
|
CDEBUG1LN(DEBUG_MISSION, "[RUN_DRILL_MINIGAME] fDrillBitShakeOffset = ", sDrillData.fDrillBitShakeOffset)
|
|
CDEBUG1LN(DEBUG_MISSION, "[RUN_DRILL_MINIGAME] fCurrentLeanPos = ", sDrillData.fCurrentLeanPos)
|
|
CDEBUG1LN(DEBUG_MISSION, "[RUN_DRILL_MINIGAME] fCurrentForwardLeanPos = ", sDrillData.fCurrentForwardLeanPos)
|
|
CDEBUG1LN(DEBUG_MISSION, "[RUN_DRILL_MINIGAME] fCurrentDrillPower = ", sDrillData.fCurrentDrillPower)
|
|
CDEBUG1LN(DEBUG_MISSION, "[RUN_DRILL_MINIGAME] fCurrentProgress = ", sDrillData.fCurrentProgress)
|
|
CDEBUG1LN(DEBUG_MISSION, "[RUN_DRILL_MINIGAME] fCurrentSweetSpotHeight = ", sDrillData.fCurrentSweetSpotHeight)
|
|
CDEBUG1LN(DEBUG_MISSION, "[RUN_DRILL_MINIGAME] fCurrentSweetSpotMin = ", sDrillData.fCurrentSweetSpotMin)
|
|
CDEBUG1LN(DEBUG_MISSION, "[RUN_DRILL_MINIGAME] fCurrentSweetSpotMax = ", sDrillData.fCurrentSweetSpotMax)
|
|
CDEBUG1LN(DEBUG_MISSION, "[RUN_DRILL_MINIGAME] fCurrentHeatLevel = ", sDrillData.fCurrentHeatLevel)
|
|
CDEBUG1LN(DEBUG_MISSION, "[RUN_DRILL_MINIGAME] fCurrentProgressIncreaseSpeed = ", sDrillData.fCurrentProgressIncreaseSpeed)
|
|
CDEBUG1LN(DEBUG_MISSION, "[RUN_DRILL_MINIGAME] fHudPosX = ", sDrillData.fHudPosX)
|
|
CDEBUG1LN(DEBUG_MISSION, "[RUN_DRILL_MINIGAME] fHudPosY = ", sDrillData.fHudPosY)
|
|
ENDPROC
|
|
|
|
PROC UPDATE_DRILL_MINIGAME_DEBUG(S_DRILL_DATA &sDrillData)
|
|
//Dump the state of all variables if someone enters a bug.
|
|
IF IS_KEYBOARD_KEY_PRESSED(KEY_SPACE)
|
|
OR IS_KEYBOARD_KEY_PRESSED(KEY_RBRACKET)
|
|
DUMP_DRILL_MINIGAME_STATE_TO_CONSOLE(sDrillData)
|
|
ENDIF
|
|
|
|
//Instant pass.
|
|
IF IS_KEYBOARD_KEY_JUST_PRESSED(KEY_NUMPAD1)
|
|
sDrillData.fCurrentProgress = 1.0
|
|
ENDIF
|
|
|
|
//Incremental increase
|
|
IF IS_KEYBOARD_KEY_JUST_PRESSED(KEY_NUMPAD9)
|
|
sDrillData.fCurrentProgress += 0.005
|
|
ENDIF
|
|
|
|
//Incremental decrease
|
|
IF IS_KEYBOARD_KEY_JUST_PRESSED(KEY_NUMPAD3)
|
|
sDrillData.fCurrentProgress -= 0.005
|
|
ENDIF
|
|
|
|
//Display some debug
|
|
IF IS_KEYBOARD_KEY_JUST_PRESSED(KEY_NUMPAD5)
|
|
sDrillData.bDisplayDebug = NOT sDrillData.bDisplayDebug
|
|
ENDIF
|
|
|
|
//Move the HUD around
|
|
IF IS_KEYBOARD_KEY_JUST_PRESSED(KEY_NUMPAD4)
|
|
sDrillData.fHudPosX -= 0.01
|
|
ENDIF
|
|
|
|
IF IS_KEYBOARD_KEY_JUST_PRESSED(KEY_NUMPAD6)
|
|
sDrillData.fHudPosX += 0.01
|
|
ENDIF
|
|
|
|
IF IS_KEYBOARD_KEY_JUST_PRESSED(KEY_NUMPAD8)
|
|
sDrillData.fHudPosY -= 0.01
|
|
ENDIF
|
|
|
|
IF IS_KEYBOARD_KEY_JUST_PRESSED(KEY_NUMPAD2)
|
|
sDrillData.fHudPosY += 0.01
|
|
ENDIF
|
|
|
|
IF sDrillData.bDisplayDebug
|
|
sDrillData.iDebugNumPrintsThisFrame = 0
|
|
|
|
DRAW_INT_TO_DRILL_DEBUG(sDrillData, sDrillData.iCurrentState, "iCurrentState")
|
|
DRAW_FLOAT_TO_DRILL_DEBUG(sDrillData, sDrillData.fCurrentDrillBasePosX, "fCurrentDrillBasePosX")
|
|
DRAW_FLOAT_TO_DRILL_DEBUG(sDrillData, sDrillData.fCurrentLeanPos, "fCurrentLeanPos")
|
|
DRAW_FLOAT_TO_DRILL_DEBUG(sDrillData, sDrillData.fCurrentForwardLeanPos, "fCurrentForwardLeanPos")
|
|
DRAW_FLOAT_TO_DRILL_DEBUG(sDrillData, sDrillData.fCurrentDrillPosY, "fCurrentDrillPosY")
|
|
DRAW_FLOAT_TO_DRILL_DEBUG(sDrillData, sDrillData.fCurrentDrillBitPos, "fCurrentDrillBitPos")
|
|
DRAW_FLOAT_TO_DRILL_DEBUG(sDrillData, sDrillData.fDrillBitShakeOffset, "fDrillBitShakeOffset")
|
|
DRAW_FLOAT_TO_DRILL_DEBUG(sDrillData, sDrillData.fCurrentDrillPower, "fCurrentDrillPower")
|
|
DRAW_FLOAT_TO_DRILL_DEBUG(sDrillData, sDrillData.fPinBreakPowerModifier, "fPinBreakPowerModifier")
|
|
DRAW_FLOAT_TO_DRILL_DEBUG(sDrillData, sDrillData.fCurrentDrillAnimPower, "fCurrentDrillAnimPower")
|
|
DRAW_FLOAT_TO_DRILL_DEBUG(sDrillData, sDrillData.fCurrentProgress, "fCurrentProgress")
|
|
DRAW_FLOAT_TO_DRILL_DEBUG(sDrillData, sDrillData.fCurrentSweetSpotHeight, "fCurrentSweetSpotHeight")
|
|
DRAW_FLOAT_TO_DRILL_DEBUG(sDrillData, sDrillData.fCurrentSweetSpotMin, "fCurrentSweetSpotMin")
|
|
DRAW_FLOAT_TO_DRILL_DEBUG(sDrillData, sDrillData.fCurrentSweetSpotMax, "fCurrentSweetSpotMax")
|
|
DRAW_FLOAT_TO_DRILL_DEBUG(sDrillData, sDrillData.fCurrentHeatLevel, "fCurrentHeatLevel")
|
|
DRAW_FLOAT_TO_DRILL_DEBUG(sDrillData, sDrillData.fCurrentProgressIncreaseSpeed, "fCurrentProgressIncreaseSpeed")
|
|
|
|
DRAW_RECT(0.8, 0.5, 0.05, sDrillData.fCurrentSweetSpotHeight * 0.5, 255, 0, 0, 255)
|
|
ENDIF
|
|
ENDPROC
|
|
#ENDIF
|
|
|
|
PROC RUN_DRILL_MINIGAME(S_DRILL_DATA &sDrillData)
|
|
#IF IS_DEBUG_BUILD
|
|
UPDATE_DRILL_MINIGAME_DEBUG(sDrillData)
|
|
#ENDIF
|
|
|
|
SWITCH sDrillData.iCurrentState
|
|
CASE DRILL_MINIGAME_STATE_INITIALISE
|
|
INITIALISE_MINIGAME_VALUES(sDrillData)
|
|
|
|
//If this is a second attempt at the game then reset the backing out flag.
|
|
CLEAR_BIT(sDrillData.iBitset, DRILL_BITSET_DID_PLAYER_BACK_OUT)
|
|
sDrillData.iCurrentState = DRILL_MINIGAME_STATE_DRILLING
|
|
|
|
SETUP_PC_DRILLING_CONTROLS()
|
|
|
|
BREAK
|
|
|
|
CASE DRILL_MINIGAME_STATE_DRILLING
|
|
CLEAR_BIT(sDrillData.iBitset, DRILL_BITSET_IS_IN_SWEET_SPOT)
|
|
|
|
//Grab the inputs
|
|
IF HAS_PLAYER_MESSED_UP_DRILLING(sDrillData)
|
|
OR NOT IS_SAFE_TO_PLAY_DRILL_MINIGAME()
|
|
sDrillData.fCurrentDrillBasePosX = 0.0
|
|
sDrillData.fCurrentDrillPosY = 0.0
|
|
sDrillData.fCurrentDrillPower = 0.0
|
|
ELSE
|
|
sDrillData.fCurrentDrillBasePosX = GET_CONTROL_NORMAL(FRONTEND_CONTROL, INPUT_SCRIPT_LEFT_AXIS_X)
|
|
|
|
IF IS_USING_KEYBOARD_AND_MOUSE(FRONTEND_CONTROL)
|
|
|
|
IF IS_MOUSE_LOOK_INVERTED()
|
|
sDrillData.fCurrentDrillPosY += ( GET_CONTROL_NORMAL(FRONTEND_CONTROL, INPUT_SCRIPT_LEFT_AXIS_Y) * 0.25 )
|
|
ELSE
|
|
sDrillData.fCurrentDrillPosY -= ( GET_CONTROL_NORMAL(FRONTEND_CONTROL, INPUT_SCRIPT_LEFT_AXIS_Y) * 0.25 )
|
|
ENDIF
|
|
ELSE
|
|
sDrillData.fCurrentDrillPosY = -GET_CONTROL_NORMAL(FRONTEND_CONTROL, INPUT_FRONTEND_AXIS_Y)
|
|
ENDIF
|
|
sDrillData.fCurrentDrillPower = GET_CONTROL_NORMAL(FRONTEND_CONTROL, INPUT_SCRIPT_RT)
|
|
ENDIF
|
|
|
|
//Floor negative values of the Y position as they're not relevant.
|
|
IF sDrillData.fCurrentDrillPosY < 0.0
|
|
sDrillData.fCurrentDrillPosY = 0.0
|
|
ENDIF
|
|
|
|
//2081557 - Allow some room in the Y-position so the game doesn't get stuck due to a dodgy analog stick.
|
|
IF NOT IS_USING_KEYBOARD_AND_MOUSE(FRONTEND_CONTROL)
|
|
sDrillData.fCurrentDrillPosY = sDrillData.fCurrentDrillPosY / DRILL_POS_SCALE_MODIFIER
|
|
ENDIF
|
|
|
|
IF sDrillData.fCurrentDrillPosY > 1.0
|
|
sDrillData.fCurrentDrillPosY = 1.0
|
|
ENDIF
|
|
|
|
// No need to dead-zone on mouse
|
|
IF NOT IS_USING_KEYBOARD_AND_MOUSE(FRONTEND_CONTROL)
|
|
//If the power is a really small value then floor it (to protect against dodgy pad triggers).
|
|
IF sDrillData.fCurrentDrillPower < 0.03
|
|
sDrillData.fCurrentDrillPower = 0.0
|
|
ENDIF
|
|
ENDIF
|
|
|
|
//2207563 - Have a power modifier value that kicks in when a pin breaks and gradually dies down. If the player stops drilling it dies down more quickly.
|
|
sDrillData.fPinBreakPowerModifier = sDrillData.fPinBreakPowerModifier -@ (DRILL_PIN_BREAK_POWER_MODIFIER_DECEL + (0.2 * (1.0 - sDrillData.fCurrentDrillPower)))
|
|
|
|
IF sDrillData.fPinBreakPowerModifier < 0.0
|
|
sDrillData.fPinBreakPowerModifier = 0.0
|
|
ENDIF
|
|
|
|
sDrillData.fCurrentDrillPower *= (1.0 + (sDrillData.fPinBreakPowerModifier * DRILL_PIN_BREAK_POWER_MODIFER_MAX))
|
|
|
|
IF sDrillData.fCurrentDrillPower > 1.0
|
|
sDrillData.fCurrentDrillPower = 1.0
|
|
ENDIF
|
|
|
|
//Determine the current sweet spot height and progress speed we should progress (both are based on drill power).
|
|
//Extra request: Make the sweet spot bigger at the start to make it easier.
|
|
FLOAT fSweetSpotExtraHeight
|
|
sDrillData.fCurrentSweetSpotHeight = DRILL_MAX_SWEET_SPOT_SIZE - ((DRILL_MAX_SWEET_SPOT_SIZE - DRILL_MIN_SWEET_SPOT_SIZE) * sDrillData.fCurrentDrillPower)
|
|
fSweetSpotExtraHeight = (1.0 - sDrillData.fCurrentProgress) * DRILL_MAX_SWEET_SPOT_SIZE
|
|
sDrillData.fCurrentSweetSpotHeight += fSweetSpotExtraHeight
|
|
sDrillData.fCurrentProgressIncreaseSpeed = DRILL_MIN_PROGRESS_SPEED + ((DRILL_MAX_PROGRESS_SPEED - DRILL_MIN_PROGRESS_SPEED) * sDrillData.fCurrentDrillPower)
|
|
|
|
//2207563 - Make the sweet spot smaller if we just broke a pin.
|
|
sDrillData.fCurrentSweetSpotHeight /= (1.0 + (sDrillData.fPinBreakPowerModifier * 6.0))
|
|
|
|
//Determine the current sweet spot: the sweet spot goes from the top of the progress bar down to a position depending on the current height.
|
|
sDrillData.fCurrentSweetSpotMin = sDrillData.fCurrentProgress
|
|
sDrillData.fCurrentSweetSpotMax = sDrillData.fCurrentSweetSpotMin + sDrillData.fCurrentSweetSpotHeight
|
|
|
|
IF sDrillData.fCurrentSweetSpotMin < 0.0
|
|
sDrillData.fCurrentSweetSpotMin = 0.0
|
|
ENDIF
|
|
|
|
IF sDrillData.fCurrentSweetSpotMax > 1.0
|
|
sDrillData.fCurrentSweetSpotMax = 1.0
|
|
ENDIF
|
|
|
|
//Handle progress and overheat updates (don't update if the player currently messed up and is still recovering).
|
|
IF NOT HAS_PLAYER_MESSED_UP_DRILLING(sDrillData)
|
|
IF sDrillData.fCurrentDrillPower > 0.0
|
|
IF sDrillData.fCurrentDrillPosY < sDrillData.fCurrentSweetSpotMin
|
|
//Drill is too far back: nothing happens.
|
|
SET_CONTROL_SHAKE(FRONTEND_CONTROL, 200, 15 + ROUND(sDrillData.fCurrentDrillPower * 45.0) + ROUND(sDrillData.fPinBreakPowerModifier * 45.0))
|
|
ELIF sDrillData.fCurrentDrillPosY > sDrillData.fCurrentSweetSpotMax
|
|
//Drill is too far forward: overheat it. Increase the rate of overheating based on drill power.
|
|
sDrillData.fCurrentHeatLevel = sDrillData.fCurrentHeatLevel +@ (DRILL_OVERHEAT_SPEED + (sDrillData.fCurrentDrillPower * 0.2))
|
|
SET_CONTROL_SHAKE(FRONTEND_CONTROL, 200, 200)
|
|
ELSE
|
|
//Drill is in the sweet spot.
|
|
sDrillData.fCurrentProgress = sDrillData.fCurrentProgress +@ sDrillData.fCurrentProgressIncreaseSpeed
|
|
|
|
IF sDrillData.fCurrentProgress >= 1.0
|
|
sDrillData.fCurrentProgress = 1.0
|
|
ENDIF
|
|
|
|
SET_BIT(sDrillData.iBitset, DRILL_BITSET_IS_IN_SWEET_SPOT)
|
|
SET_CONTROL_SHAKE(FRONTEND_CONTROL, 200, 30 + ROUND(sDrillData.fCurrentDrillPower * 60.0) + ROUND(sDrillData.fPinBreakPowerModifier * 60.0))
|
|
ENDIF
|
|
ELSE
|
|
//Shake slightly if the player is pushing the drill too hard.
|
|
IF sDrillData.fCurrentDrillPosY > sDrillData.fCurrentSweetSpotMax
|
|
SET_CONTROL_SHAKE(FRONTEND_CONTROL, 200, 30)
|
|
ENDIF
|
|
ENDIF
|
|
ELSE
|
|
sDrillData.fCurrentForwardLeanPos = 0.0
|
|
ENDIF
|
|
|
|
//Decrease the overheat meter over time, if the player has let go of the power then cool down quicker (or if they overheated completely).
|
|
IF HAS_PLAYER_MESSED_UP_DRILLING(sDrillData)
|
|
sDrillData.fCurrentHeatLevel = sDrillData.fCurrentHeatLevel -@ (DRILL_COOLDOWN_SPEED * 2.0)
|
|
ELIF sDrillData.fCurrentDrillPower > 0.0
|
|
sDrillData.fCurrentHeatLevel = sDrillData.fCurrentHeatLevel -@ DRILL_COOLDOWN_SPEED
|
|
ELSE
|
|
sDrillData.fCurrentHeatLevel = sDrillData.fCurrentHeatLevel -@ (DRILL_COOLDOWN_SPEED * 1.25)
|
|
ENDIF
|
|
|
|
//Cap the heat value.
|
|
IF sDrillData.fCurrentHeatLevel > 1.0
|
|
sDrillData.fCurrentHeatLevel = 1.0
|
|
ELIF sDrillData.fCurrentHeatLevel < 0.0
|
|
sDrillData.fCurrentHeatLevel = 0.0
|
|
ENDIF
|
|
|
|
//Set the visible drill bit position: the drill can't go further than the current progress. If the player is trying to do this then shake the drill bit.
|
|
sDrillData.fCurrentDrillBitPos = sDrillData.fCurrentDrillBitPos + ((sDrillData.fCurrentDrillPosY - sDrillData.fCurrentDrillBitPos) * 0.5)
|
|
|
|
IF sDrillData.fCurrentDrillBitPos > sDrillData.fCurrentProgress
|
|
sDrillData.fCurrentDrillBitPos = sDrillData.fCurrentProgress
|
|
ENDIF
|
|
|
|
SHAKE_DRILL_BIT(sDrillData)
|
|
|
|
//Work out the anim values: these are just interpolations of the progress and sideways movement values, and are used for smoothing out the anims.
|
|
sDrillData.fCurrentLeanPos = COSINE_INTERP_FLOAT(sDrillData.fCurrentLeanPos, sDrillData.fCurrentDrillBasePosX, DRILL_LEAN_INTERP_SPEED)
|
|
sDrillData.fCurrentForwardLeanPos = COSINE_INTERP_FLOAT(sDrillData.fCurrentForwardLeanPos, sDrillData.fCurrentDrillBitPos, DRILL_LEAN_INTERP_SPEED * 0.5)
|
|
sDrillData.fCurrentDrillAnimPower = COSINE_INTERP_FLOAT(sDrillData.fCurrentDrillAnimPower, sDrillData.fCurrentDrillPower, 0.4)
|
|
|
|
//If the progress reaches max then go to the next stage.
|
|
//NOTE: the new drill scaleform cracks before progress reaches 1.0.
|
|
//2136848 - Have some delay so it doesn't cut to the cutscene too quickly after passing.
|
|
IF sDrillData.fCurrentProgress >= DRILL_PASS_POINT
|
|
AND IS_SAFE_TO_PLAY_DRILL_MINIGAME()
|
|
//Guarantee that we;ve gone past the point where the drill HUD cracks.
|
|
IF DRILL_PASS_POINT < 0.99
|
|
AND sDrillData.fCurrentProgress - DRILL_PASS_POINT < 0.01
|
|
sDrillData.fCurrentProgress = DRILL_PASS_POINT + 0.01
|
|
ENDIF
|
|
|
|
IF GET_GAME_TIMER() - sDrillData.iPassTimer > 500
|
|
CDEBUG1LN(DEBUG_MISSION, "[RUN_DRILL_MINIGAME] Progress complete, passing minigame.")
|
|
|
|
sDrillData.iCurrentState = DRILL_MINIGAME_STATE_CLEANUP
|
|
ENDIF
|
|
ELSE
|
|
sDrillData.iPassTimer = GET_GAME_TIMER()
|
|
ENDIF
|
|
|
|
//If the heat level reaches max then put us in the overheat state.
|
|
IF sDrillData.fCurrentHeatLevel >= 1.0
|
|
AND sDrillData.iCurrentState != DRILL_MINIGAME_STATE_CLEANUP
|
|
CDEBUG1LN(DEBUG_MISSION, "[RUN_DRILL_MINIGAME] Player messed up.")
|
|
|
|
PLAYER_MESSED_UP_DRILLING(sDrillData)
|
|
ENDIF
|
|
|
|
//Handle audio for pins breaking, also make sure the progress is forced to a value that guarantees the sound and UI sync up.
|
|
IF sDrillData.iAudioEvent = 0
|
|
IF sDrillData.fCurrentProgress > 0.325
|
|
CDEBUG1LN(DEBUG_MISSION, "[RUN_DRILL_MINIGAME] Playing drill pin break sound ", sDrillData.iAudioEvent)
|
|
PLAY_SOUND_FRONTEND( -1, "Drill_Pin_Break", "DLC_HEIST_FLEECA_SOUNDSET")
|
|
IF sDrillData.fCurrentProgress < 0.33
|
|
sDrillData.fCurrentProgress = 0.33
|
|
ENDIF
|
|
sDrillData.fCurrentProgress += 0.01 //2207563 - This gives the effect of the drill lurching forward after breaking a pin.
|
|
sDrillData.fPinBreakPowerModifier = 1.0
|
|
|
|
sDrillData.iAudioEvent++
|
|
ENDIF
|
|
ELIF sDrillData.iAudioEvent = 1
|
|
//2207563 - This will be added to the lean animation phase, giving the effect of the player lurching forward after each pin breaking.
|
|
sDrillData.fForwardLeanExtraAmountForPins += (0.06 - sDrillData.fForwardLeanExtraAmountForPins) * 0.5
|
|
|
|
IF sDrillData.fCurrentProgress > 0.475
|
|
CDEBUG1LN(DEBUG_MISSION, "[RUN_DRILL_MINIGAME] Playing drill pin break sound ", sDrillData.iAudioEvent)
|
|
PLAY_SOUND_FRONTEND( -1, "Drill_Pin_Break", "DLC_HEIST_FLEECA_SOUNDSET")
|
|
IF sDrillData.fCurrentProgress < 0.48
|
|
sDrillData.fCurrentProgress = 0.48
|
|
ENDIF
|
|
sDrillData.fCurrentProgress += 0.01
|
|
sDrillData.fPinBreakPowerModifier = 1.0
|
|
sDrillData.iAudioEvent++
|
|
ENDIF
|
|
ELIF sDrillData.iAudioEvent = 2
|
|
sDrillData.fForwardLeanExtraAmountForPins += (0.12 - sDrillData.fForwardLeanExtraAmountForPins) * 0.5
|
|
|
|
IF sDrillData.fCurrentProgress > 0.625
|
|
CDEBUG1LN(DEBUG_MISSION, "[RUN_DRILL_MINIGAME] Playing drill pin break sound ", sDrillData.iAudioEvent)
|
|
PLAY_SOUND_FRONTEND( -1, "Drill_Pin_Break", "DLC_HEIST_FLEECA_SOUNDSET")
|
|
IF sDrillData.fCurrentProgress < 0.63
|
|
sDrillData.fCurrentProgress = 0.63
|
|
ENDIF
|
|
sDrillData.fCurrentProgress += 0.01
|
|
sDrillData.fPinBreakPowerModifier = 1.0
|
|
sDrillData.iAudioEvent++
|
|
ENDIF
|
|
ELIF sDrillData.iAudioEvent = 3
|
|
sDrillData.fForwardLeanExtraAmountForPins += (0.18 - sDrillData.fForwardLeanExtraAmountForPins) * 0.5
|
|
|
|
IF sDrillData.fCurrentProgress >= DRILL_PASS_POINT
|
|
CDEBUG1LN(DEBUG_MISSION, "[RUN_DRILL_MINIGAME] Playing drill pin break sound ", sDrillData.iAudioEvent)
|
|
PLAY_SOUND_FRONTEND( -1, "Drill_Pin_Break", "DLC_HEIST_FLEECA_SOUNDSET")
|
|
sDrillData.fCurrentProgress += 0.01
|
|
sDrillData.fPinBreakPowerModifier = 1.0
|
|
sDrillData.iAudioEvent++
|
|
ENDIF
|
|
ENDIF
|
|
BREAK
|
|
|
|
CASE DRILL_MINIGAME_STATE_CLEANUP
|
|
SET_BIT(sDrillData.iBitset, DRILL_BITSET_IS_MINIGAME_COMPLETE)
|
|
sDrillData.iCurrentState++
|
|
CLEANUP_PC_DRILLING_CONTROLS()
|
|
BREAK
|
|
ENDSWITCH
|
|
|
|
//Update HUD
|
|
//DRAW_DRILL_MINIGAME_HUD(sDrillData)
|
|
DRAW_DRILL_MINIGAME_SCALEFORM_HUD(sDrillData)
|
|
ENDPROC
|