x/gtav-src
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
a6770644bb24d2fc66a35fb9db6d70df5d108b1c
gtav-src/script/dev_ng/singleplayer/scripts/Ambient/Object/ob_jukebox.sc
T
x a6770644bb init gta
2025-09-29 00:52:08 +02:00

1736 lines
57 KiB
Python
Executable File
Raw Blame History

///// ob_jukebox.sc
///// Mark Richardson - 13/07/16
///// Network Jukebox functionailty
USING "rage_builtins.sch"
USING "globals.sch"
USING "cellphone_public.sch"
USING "commands_zone.sch"
USING "menu_public.sch"
USING "net_clubhouse.sch"
//***********Script CONSTS***********
CONST_INT ciJukeboxUseCharge 1
//Broadcast data BS consts (Player)
CONST_INT ciRequestingUseOfJukebox 0
CONST_INT ciUsingJukebox 1
CONST_INT ciRequestedPlaylistChange 2
CONST_INT ciRequestedVolumeChange 3
//Local BS consts
CONST_INT ciDelayTimerActive 0
CONST_INT ciRebuildMenu 1
CONST_INT cinetworkInitDone 2
CONST_INT ciMenuActive 3
CONST_INT ciPlaySelectTrackAnim 4
CONST_INT ciPlayInsertCoinAnim 5
CONST_INT ciJukeboxEnabled 6
ENUM JUKEBOX_MENU_STAGE
eSelectPlaylist,
eTurnJBOffNoMoney, //Seperate stage for when the player has no cash
eConfirm
ENDENUM
ENUM JUKEBOX_ACTIVITY_STAGE
eJAInactive,
eJAPlayingEntryAnim,
eJAAwaitingAproval,
eJAMenuActive,
eJAExit
ENDENUM
ENUM JUKEBOX_SERVER_STAGE
JBServerStageOff,
JBServerStageOn
ENDENUM
//***********Script variables***********
OBJECT_INDEX obJukebox
PLAYER_INDEX pPropertyOwnerID
INT iLocalActivePlaylistID = 0
INT iSelectedPlaylist = -1
INT iCurrentSelection = 0
INT iCurrentProperty = -1
INT iStaggeredPlayerLoop = 0
INT iJukeboxContextIntention = NEW_CONTEXT_INTENTION
INT iJukeBoxSyncSceneStage = 0
INT iJukeBoxSyncSceneID = 0
INT iJukeBoxBS = 0
INT iJBSelectedPlistPlayTime = 0
INT iMostPlayedPlayistTime = 0
INT iTelemSelectedPlaylist = 0
INT iMenuOnOffOption
STRING sJukeboxAnimDict = "anim@amb@clubhouse@jukebox@"
JUKEBOX_MENU_STAGE eMenuStage = eSelectPlaylist
JUKEBOX_ACTIVITY_STAGE eActivityStage = eJAInactive
SCRIPT_TIMER stAnalogueMenuDelay
SCRIPT_TIMER stJBWalkToTimer
SCRIPT_TIMER stStatAutosaveTimer
VECTOR vJukeboxCoords
VECTOR vtrigger
VECTOR vSynchSceneOrigin
//***********Script Structs***********
// The server broadcast data.
STRUCT ServerBroadcastData
// Game State
JUKEBOX_SERVER_STAGE iJukeboxServerState = JBServerStageOn
FLOAT fVolume = 0.5
INT iJukeboxUserID = -1
INT iActivePlaylistID = -1
BOOL bNewPlaylistSelectedByOwner
ENDSTRUCT
ServerBroadcastData serverBD
// The client broadcast data.
STRUCT PlayerBroadcastData
INT iBitSet
INT iNewPlaylistRequestID
FLOAT fVolume
ENDSTRUCT
PlayerBroadcastData playerBD[NUM_NETWORK_PLAYERS]
//***********Script functions***********
PROC CLEANUP_ANY_PLAYING_ANIMATIONS()
IF DOES_ENTITY_EXIST(PLAYER_PED_ID())
AND NOT IS_ENTITY_DEAD(PLAYER_PED_ID())
IF IS_ENTITY_PLAYING_ANIM(PLAYER_PED_ID(), sJukeboxAnimDict, "IDLE")
OR IS_ENTITY_PLAYING_ANIM(PLAYER_PED_ID(), sJukeboxAnimDict, "EXIT")
OR IS_ENTITY_PLAYING_ANIM(PLAYER_PED_ID(), sJukeboxAnimDict, "INSERT_COINS")
OR IS_ENTITY_PLAYING_ANIM(PLAYER_PED_ID(), sJukeboxAnimDict, "SELECT_TRACK")
CLEAR_PED_TASKS_IMMEDIATELY(PLAYER_PED_ID())
ENDIF
ENDIF
ENDPROC
PROC INIT_TIME_STAMP_FOR_CURRENT_PLAYLIST()
#IF FEATURE_CASINO_HEIST
IF iCurrentProperty = PROPERTY_ARCADE_GARAGE
INT iFavouritePList = GET_LOCAL_PLAYERS_FAVOURITE_ARCADE_JUKEBOX_PLAYLIST_ID()
iJBSelectedPlistPlayTime = GET_CLOUD_TIME_AS_INT()
iMostPlayedPlayistTime = GET_MP_INT_CHARACTER_STAT(GET_FAV_ARCADE_PLAYLIST_STAT_FROM_ID(iFavouritePList))
ELSE
#ENDIF
INT iFavouritePList = GET_LOCAL_PLAYERS_FAVOURITE_JUKEBOX_PLAYLIST_ID()
iJBSelectedPlistPlayTime = GET_CLOUD_TIME_AS_INT()
iMostPlayedPlayistTime = GET_MP_INT_CHARACTER_STAT(GET_FAV_PLAYLIST_STAT_FROM_ID(iFavouritePList))
#IF FEATURE_CASINO_HEIST
ENDIF
#ENDIF
ENDPROC
/// PURPOSE:
/// Adds the total time the given playlist has been played to the relevant stat
PROC SAVE_JB_PLAYLIST_PLAY_TIME(INT iOldPlaylist)
IF iOldPlaylist = iMenuOnOffOption
CDEBUG1LN(DEBUG_SAFEHOUSE, "<JUKEBOX> SAVE_JB_PLAYLIST_PLAY_TIME not setting stat as the JB has been turned off")
EXIT
ENDIF
#IF FEATURE_CASINO_HEIST
IF iCurrentProperty = PROPERTY_ARCADE_GARAGE
INT iCurrentSavedTime = GET_MP_INT_CHARACTER_STAT(GET_FAV_ARCADE_PLAYLIST_STAT_FROM_ID(iOldPlaylist))
INT iTimeToAdd = (GET_CLOUD_TIME_AS_INT() - iJBSelectedPlistPlayTime)
CDEBUG1LN(DEBUG_SAFEHOUSE, "<JUKEBOX> SAVE_JB_PLAYLIST_PLAY_TIME saving time for playlist: ", iOldPlaylist, " Previous total time: ", iCurrentSavedTime, " seconds. Time to add: ", iTimeToAdd, " seconds.")
//Set the stat
SET_MP_INT_CHARACTER_STAT(GET_FAV_ARCADE_PLAYLIST_STAT_FROM_ID(iOldPlaylist), (iCurrentSavedTime + iTimeToAdd))
//Set the BD
IF iMostPlayedPlayistTime < (iCurrentSavedTime + iTimeToAdd)
SET_PLAYERS_FAVOURITE_PLAYLIST(GET_LOCAL_PLAYERS_FAVOURITE_ARCADE_JUKEBOX_PLAYLIST_ID())
ENDIF
ELSE
#ENDIF
INT iCurrentSavedTime = GET_MP_INT_CHARACTER_STAT(GET_FAV_PLAYLIST_STAT_FROM_ID(iOldPlaylist))
INT iTimeToAdd = (GET_CLOUD_TIME_AS_INT() - iJBSelectedPlistPlayTime)
CDEBUG1LN(DEBUG_SAFEHOUSE, "<JUKEBOX> SAVE_JB_PLAYLIST_PLAY_TIME saving time for playlist: ", iOldPlaylist, " Previous total time: ", iCurrentSavedTime, " seconds. Time to add: ", iTimeToAdd, " seconds.")
//Set the stat
SET_MP_INT_CHARACTER_STAT(GET_FAV_PLAYLIST_STAT_FROM_ID(iOldPlaylist), (iCurrentSavedTime + iTimeToAdd))
//Set the BD
IF iMostPlayedPlayistTime < (iCurrentSavedTime + iTimeToAdd)
SET_PLAYERS_FAVOURITE_PLAYLIST(GET_LOCAL_PLAYERS_FAVOURITE_JUKEBOX_PLAYLIST_ID())
ENDIF
#IF FEATURE_CASINO_HEIST
ENDIF
#ENDIF
iJBSelectedPlistPlayTime = GET_CLOUD_TIME_AS_INT()
ENDPROC
PROC CLEANUP_JUKEBOX(BOOL bCleanupPlayerControl = FALSE)
CDEBUG1LN(DEBUG_SAFEHOUSE, "<JUKEBOX> CLEANUP_JUKEBOX")
DISABLE_CELLPHONE(FALSE)
IF IS_BIT_SET(iJukeBoxBS, ciMenuActive)
CLEANUP_MENU_ASSETS()
ENDIF
SET_BIT(g_JukeboxData.iBitSet, ciJBJustRunCleanup)
IF iJukeboxContextIntention != NEW_CONTEXT_INTENTION
RELEASE_CONTEXT_INTENTION(iJukeboxContextIntention)
ENDIF
IF pPropertyOwnerID = PLAYER_ID()
SAVE_JB_PLAYLIST_PLAY_TIME(iLocalActivePlaylistID)
ENDIF
IF IS_HELP_MESSAGE_BEING_DISPLAYED()
AND IS_THIS_HELP_MESSAGE_BEING_DISPLAYED("JBOX_NO_MONEY")
CLEAR_HELP(TRUE)
ENDIF
THEFEED_RESUME()
CLEANUP_ANY_PLAYING_ANIMATIONS()
IF bCleanupPlayerControl
NET_SET_PLAYER_CONTROL(PLAYER_ID(), TRUE)
ENDIF
#IF FEATURE_CASINO_HEIST
IF iCurrentProperty = PROPERTY_ARCADE_GARAGE
STOP_AUDIO_SCENE("dlc_ch_arcade_music_volume")
ENDIF
#ENDIF
TERMINATE_THIS_THREAD()
ENDPROC
FUNC BOOL IS_JUKEBOX_ON()
RETURN serverBD.iJukeboxServerState = JBServerStageOn
ENDFUNC
FUNC BOOL IS_JUKEBOX_IN_USE()
IF serverBD.iJukeboxUserID != -1
RETURN TRUE
ENDIF
RETURN FALSE
ENDFUNC
PROC CHARGE_PLAYER_FOR_JB(INT iPlaylist)
INT iPlaylistHash
IF IS_PROPERTY_CLUBHOUSE(iCurrentProperty)
iPlaylistHash = GET_HASH_KEY(GET_CLUBHOUSE_PLAYLIST_NAME_FROM_ID(iPlaylist))
#IF FEATURE_CASINO_HEIST
ELIF iCurrentProperty = PROPERTY_ARCADE_GARAGE
iPlaylistHash = GET_HASH_KEY(GET_ARCADE_PLAYLIST_NAME_FROM_ID(iPlaylist))
#ENDIF
ENDIF
IF NETWORK_CAN_SPEND_MONEY(ciJukeboxUseCharge, FALSE, FALSE, TRUE)
IF USE_SERVER_TRANSACTIONS()
INT iTransactionID
CDEBUG1LN(DEBUG_SHOPS, "<JUKEBOX> [$$$] Charging MP player for jukebox - PC: $", ciJukeboxUseCharge)
TRIGGER_FIRE_AND_FORGET_SERVICE_TRANSACTION(SERVICE_SPEND_JUKEBOX, ciJukeboxUseCharge, iTransactionID, FALSE, FALSE, TRUE)
g_cashTransactionData[iTransactionID].cashInfo.iItemHash = iPlaylistHash
ELSE
CDEBUG1LN(DEBUG_SHOPS, "<JUKEBOX> [$$$] Charging MP player for jukebox - CONSOLE: $", ciJukeboxUseCharge)
NETWORK_SPENT_JUKEBOX(ciJukeboxUseCharge, iPlaylistHash, FALSE, FALSE)
ENDIF
ENDIF
ENDPROC
#IF IS_DEBUG_BUILD
FUNC STRING GET_JUKEBOX_ACTIVITY_STAGE_AS_STRING(JUKEBOX_ACTIVITY_STAGE eStage)
SWITCH eStage
CASE eJAInactive RETURN "eJAInactive"
CASE eJAPlayingEntryAnim RETURN "eJAPlayingEntryAnim"
CASE eJAAwaitingAproval RETURN "eJAAwaitingAproval"
CASE eJAMenuActive RETURN "eJAMenuActive"
CASE eJAExit RETURN "eJAExit"
ENDSWITCH
RETURN "Jukebox stage unknown"
ENDFUNC
#ENDIF
PROC SET_JUKEBOX_ACTIVITY_STAGE(JUKEBOX_ACTIVITY_STAGE eNewStage)
#IF IS_DEBUG_BUILD
CDEBUG1LN(DEBUG_SAFEHOUSE, "<JUKEBOX> SET_JUKEBOX_ACTIVITY_STAGE old stage: ", GET_JUKEBOX_ACTIVITY_STAGE_AS_STRING(eActivityStage), " New stage: ", GET_JUKEBOX_ACTIVITY_STAGE_AS_STRING(eNewStage))
DEBUG_PRINTCALLSTACK()
#ENDIF
eActivityStage = eNewStage
ENDPROC
PROC REQUEST_VOLUME_CHANGE(FLOAT fNewVolume)
playerBD[NATIVE_TO_INT(PLAYER_ID())].fVolume = fNewVolume
SET_BIT(playerBD[NATIVE_TO_INT(PLAYER_ID())].iBitSet, ciRequestedVolumeChange)
CDEBUG1LN(DEBUG_SAFEHOUSE, "<JUKEBOX> RUN_JUKEBOX_ACTIVITY - Requested volume change to ", fNewVolume)
ENDPROC
/// PURPOSE:
/// Disable all controls necessary whilst the menu is active
PROC JUKEBOX_MENU_CONTROL_DISABLE()
SET_CLEAR_ON_CALL_HUD_THIS_FRAME()
HANG_UP_AND_PUT_AWAY_PHONE(TRUE)
IF (NOT IS_SYSTEM_UI_BEING_DISPLAYED())
AND (NOT IS_PAUSE_MENU_ACTIVE())
DISABLE_ALL_CONTROL_ACTIONS(PLAYER_CONTROL)
ENABLE_ALL_CONTROL_ACTIONS(CAMERA_CONTROL)
DISABLE_CONTROL_ACTION(FRONTEND_CONTROL, INPUT_FRONTEND_PAUSE_ALTERNATE)
ENDIF
ENDPROC
FUNC INT GET_MAX_AVAILABLE_PLAYLISTS()
IF iCurrentProperty = PROPERTY_ARCADE_GARAGE
#IF FEATURE_TUNER
IF pPropertyOwnerID = PLAYER_ID()
AND HAS_LOCAL_PLAYER_COLLECTED_ANY_USB_MIXES()
RETURN 10 // url:bugstar:6593351
ENDIF
#ENDIF
RETURN 9
ENDIF
#IF FEATURE_TUNER
IF pPropertyOwnerID = PLAYER_ID()
AND HAS_LOCAL_PLAYER_COLLECTED_ANY_USB_MIXES()
RETURN 5 // url:bugstar:6593351
ENDIF
#ENDIF
RETURN 4
ENDFUNC
FUNC INT GET_MENU_OFF_OPTION()
RETURN GET_MAX_AVAILABLE_PLAYLISTS()
ENDFUNC
FUNC INT GET_JUKEBOX_MENU_LIMIT()
INT iNumberOfPlaylists = GET_MAX_AVAILABLE_PLAYLISTS()
SWITCH eMenuStage
CASE eConfirm RETURN 1
CASE eSelectPlaylist
IF IS_JUKEBOX_ON()
RETURN iNumberOfPlaylists //Not (ciMaxAvailablePlaylists -1) to allow for the on/off option
ELSE
RETURN (iNumberOfPlaylists -1)
ENDIF
BREAK
CASE eTurnJBOffNoMoney RETURN 0
ENDSWITCH
SCRIPT_ASSERT("<JUKEBOX> GET_JUKEBOX_MENU_LIMIT: Invalid stage!")
RETURN 0
ENDFUNC
PROC HANDLE_PC_CONTROL(BOOL &bPrevious, BOOL &bNext, BOOL &bAccept, BOOL &bBack, BOOL &bLeft, BOOL &bRight)
// Mouse control support
IF IS_PC_VERSION()
AND NOT NETWORK_TEXT_CHAT_IS_TYPING()
IF IS_USING_CURSOR(FRONTEND_CONTROL)
DISABLE_CONTROL_ACTION(PLAYER_CONTROL, INPUT_LOOK_LR)
DISABLE_CONTROL_ACTION(PLAYER_CONTROL, INPUT_LOOK_UD)
DISABLE_CONTROL_ACTION(FRONTEND_CONTROL, INPUT_FRONTEND_PAUSE_ALTERNATE)
ENABLE_CONTROL_ACTION(PLAYER_CONTROL, INPUT_CURSOR_ACCEPT)
ENABLE_CONTROL_ACTION(PLAYER_CONTROL, INPUT_CURSOR_CANCEL)
ENABLE_CONTROL_ACTION(PLAYER_CONTROL, INPUT_CURSOR_SCROLL_UP)
ENABLE_CONTROL_ACTION(PLAYER_CONTROL, INPUT_CURSOR_SCROLL_DOWN)
IF ((g_iMenuCursorItem = MENU_CURSOR_NO_ITEM) OR (g_iMenuCursorItem = MENU_CURSOR_NO_CAMERA_MOVE) OR (g_iMenuCursorItem = MENU_CURSOR_DRAG_CAM))
ENABLE_CONTROL_ACTION(CAMERA_CONTROL, INPUT_LOOK_LR)
ENABLE_CONTROL_ACTION(CAMERA_CONTROL, INPUT_LOOK_UD)
ELSE
DISABLE_CONTROL_ACTION(CAMERA_CONTROL, INPUT_LOOK_LR)
DISABLE_CONTROL_ACTION(CAMERA_CONTROL, INPUT_LOOK_UD)
ENDIF
HANDLE_CURSOR_HIGHLIGHTED_MENU_ITEMS()
HANDLE_MENU_CURSOR(FALSE)
ENDIF
// Mouse select
IF IS_MENU_CURSOR_ACCEPT_PRESSED()
IF g_iMenuCursorItem = iCurrentSelection
bAccept = TRUE
ELSE
iCurrentSelection = g_iMenuCursorItem
SET_CURRENT_MENU_ITEM(iCurrentSelection)
ENDIF
ENDIF
// Menu cursor back
IF IS_MENU_CURSOR_CANCEL_PRESSED()
bBack = TRUE
ENDIF
// Mouse scroll up
IF IS_MENU_CURSOR_SCROLL_UP_PRESSED()
OR IS_CONTROL_PRESSED(FRONTEND_CONTROL, INPUT_FRONTEND_UP)
bPrevious = TRUE
ENDIF
// Mouse scroll down
IF IS_MENU_CURSOR_SCROLL_DOWN_PRESSED()
OR IS_CONTROL_PRESSED(FRONTEND_CONTROL, INPUT_FRONTEND_DOWN)
bNext = TRUE
ENDIF
IF IS_CONTROL_PRESSED(FRONTEND_CONTROL, INPUT_FRONTEND_LEFT)
bLeft = TRUE
ENDIF
IF IS_CONTROL_PRESSED(FRONTEND_CONTROL, INPUT_FRONTEND_RIGHT)
bRight = TRUE
ENDIF
ENDIF
ENDPROC
/// PURPOSE:
/// Control the response to any input whilst the menu is active
PROC HANDLE_JUKEBOX_MENU_INPUT()
INT iLeftY
INT iMenuInputDelay = 150
BOOL bPrevious, bNext, bLeft, bRight
IF IS_USING_CURSOR(FRONTEND_CONTROL)
iMenuInputDelay = 110
ENDIF
JUKEBOX_MENU_CONTROL_DISABLE()
// Set the input flag states
ENABLE_CONTROL_ACTION(FRONTEND_CONTROL, INPUT_FRONTEND_AXIS_X)
ENABLE_CONTROL_ACTION(FRONTEND_CONTROL, INPUT_FRONTEND_AXIS_Y)
ENABLE_CONTROL_ACTION(FRONTEND_CONTROL, INPUT_FRONTEND_ACCEPT)
ENABLE_CONTROL_ACTION(FRONTEND_CONTROL, INPUT_FRONTEND_UP)
ENABLE_CONTROL_ACTION(FRONTEND_CONTROL, INPUT_FRONTEND_DOWN)
BOOL bAccept = (IS_CONTROL_JUST_PRESSED(FRONTEND_CONTROL, INPUT_FRONTEND_ACCEPT))
BOOL bBack = (IS_CONTROL_JUST_PRESSED(FRONTEND_CONTROL, INPUT_FRONTEND_CANCEL) OR IS_DISABLED_CONTROL_JUST_PRESSED(FRONTEND_CONTROL, INPUT_FRONTEND_CANCEL))
iLeftY = GET_CONTROL_VALUE(FRONTEND_CONTROL, INPUT_FRONTEND_AXIS_Y)
IF NOT IS_BIT_SET(iJukeBoxBS, cidelayTimerActive)
IF IS_USING_CURSOR(FRONTEND_CONTROL)
HANDLE_PC_CONTROL(bPrevious, bNext, bAccept, bBack, bLeft, bRight)
ELSE
bPrevious = ((iLeftY < 100) OR IS_CONTROL_PRESSED(FRONTEND_CONTROL, INPUT_FRONTEND_UP))
bNext = ((iLeftY > 150) OR IS_CONTROL_PRESSED(FRONTEND_CONTROL, INPUT_FRONTEND_DOWN))
bLeft = IS_CONTROL_PRESSED(FRONTEND_CONTROL, INPUT_CONTEXT_SECONDARY)
bRight = IS_CONTROL_PRESSED(FRONTEND_CONTROL, INPUT_CONTEXT)
ENDIF
IF bPrevious OR bNext OR bLeft OR bRight
START_NET_TIMER(stAnalogueMenuDelay)
SET_BIT(iJukeBoxBS, ciDelayTimerActive)
ENDIF
ELIF HAS_NET_TIMER_EXPIRED(stAnalogueMenuDelay, iMenuInputDelay)
RESET_NET_TIMER(stAnalogueMenuDelay)
CLEAR_BIT(iJukeBoxBS, ciDelayTimerActive)
ENDIF
//Menu navigation
IF bNext
iCurrentSelection ++
IF iCurrentSelection > GET_JUKEBOX_MENU_LIMIT()
iCurrentSelection = 0
ENDIF
PLAY_SOUND_FRONTEND(-1, "NAV_UP_DOWN", "HUD_FRONTEND_DEFAULT_SOUNDSET")
ENDIF
IF bPrevious
iCurrentSelection --
IF iCurrentSelection < 0
iCurrentSelection = GET_JUKEBOX_MENU_LIMIT()
ENDIF
PLAY_SOUND_FRONTEND(-1, "NAV_UP_DOWN", "HUD_FRONTEND_DEFAULT_SOUNDSET")
ENDIF
#IF FEATURE_CASINO_HEIST
IF iCurrentProperty = PROPERTY_ARCADE_GARAGE
IF bLeft
IF serverBD.fVolume < 1
REQUEST_VOLUME_CHANGE(serverBD.fVolume + 0.5)
ENDIF
ENDIF
IF bRight
IF serverBD.fVolume > 0
REQUEST_VOLUME_CHANGE(serverBD.fVolume - 0.5)
ENDIF
ENDIF
ENDIF
#ENDIF
//Menu - Select an option
IF bAccept
BOOL bPlayErrorSound = FALSE
SWITCH eMenuStage
CASE eTurnJBOffNoMoney
eMenuStage = eSelectPlaylist
iCurrentSelection = 0
//Set the selection to off and exit the activity
iSelectedPlaylist = iMenuOnOffOption
SET_JUKEBOX_ACTIVITY_STAGE(eJAExit)
CLEAR_BIT(iJukeBoxBS ,ciPlayInsertCoinAnim)
BREAK
CASE eSelectPlaylist
IF iCurrentSelection != ServerBD.iActivePlaylistID
OR NOT IS_JUKEBOX_ON()
//Move to the next stage if we've selected a valid playlist
iSelectedPlaylist = iCurrentSelection
eMenuStage = eConfirm
iCurrentSelection = 0
SET_BIT(iJukeBoxBS, ciRebuildMenu)
SET_BIT(iJukeBoxBS ,ciPlaySelectTrackAnim)
ELSE
bPlayErrorSound = TRUE
ENDIF
BREAK
CASE eConfirm
IF iCurrentSelection = 0
//This will allow us to interupt the select playlist anim to exit
iJukeBoxSyncSceneStage = 0
SET_JUKEBOX_ACTIVITY_STAGE(eJAExit)
//If we have not selected the 'Turn off' option charge the player and switch the playlist
IF iSelectedPlaylist != iMenuOnOffOption
SET_BIT(iJukeBoxBS ,ciPlayInsertCoinAnim)
CHARGE_PLAYER_FOR_JB(iSelectedPlaylist)
ENDIF
ELSE
//Go back to the select playlist stage as we selected the 'No' option
eMenuStage = eSelectPlaylist
iCurrentSelection = 0
SET_BIT(iJukeBoxBS, ciRebuildMenu)
ENDIF
BREAK
ENDSWITCH
//Play the relevant sound effect
IF bPlayErrorSound
PLAY_SOUND_FRONTEND(-1, "ERROR", "HUD_FRONTEND_DEFAULT_SOUNDSET")
ELSE
PLAY_SOUND_FRONTEND(-1, "SELECT", "HUD_FRONTEND_DEFAULT_SOUNDSET")
ENDIF
ENDIF
//Menu - Back button pressed
IF bBack
PLAY_SOUND_FRONTEND(-1, "BACK", "HUD_FRONTEND_DEFAULT_SOUNDSET")
SWITCH eMenuStage
CASE eSelectPlaylist
eMenuStage = eSelectPlaylist
iSelectedPlaylist = -1
SET_JUKEBOX_ACTIVITY_STAGE(eJAExit)
CLEAR_BIT(iJukeBoxBS ,ciPlayInsertCoinAnim)
BREAK
CASE eTurnJBOffNoMoney
iCurrentSelection = 0
iSelectedPlaylist = -1
SET_JUKEBOX_ACTIVITY_STAGE(eJAExit)
CLEAR_BIT(iJukeBoxBS ,ciPlayInsertCoinAnim)
BREAK
CASE eConfirm
eMenuStage = eSelectPlaylist
iCurrentSelection = 0
iSelectedPlaylist = -1
SET_BIT(iJukeBoxBS, ciRebuildMenu)
BREAK
ENDSWITCH
ENDIF
ENDPROC
PROC BUILD_JUKEBOX_OFF_MENU()
SETUP_MENU_WITH_TITLE("JBOX_MENU_T")
ADD_MENU_ITEM_TEXT(0, "JBOX_M_OFF", 0, TRUE)
SET_CURRENT_MENU_ITEM(iCurrentSelection)
ADD_MENU_HELP_KEY_CLICKABLE(INPUT_FRONTEND_ACCEPT, "ITEM_SELECT")
ADD_MENU_HELP_KEY_CLICKABLE(INPUT_FRONTEND_CANCEL, "ITEM_BACK")
ENDPROC
PROC BUILD_JUKEBOX_MAIN_MENU()
SETUP_MENU_WITH_TITLE("JBOX_MENU_T")
INT iNumberOfPlaylists = GET_MAX_AVAILABLE_PLAYLISTS()
INT iIter
//Build a list of available playlists
REPEAT iNumberOfPlaylists iIter
TEXT_LABEL_15 tlPlaylistName = "JBOX_PLIST_"
//if we're playing this playlist now mark it as unavailable
BOOL bItemAvailable = iIter != serverBD.iActivePlaylistID
IF NOT IS_JUKEBOX_ON()
bItemAvailable = TRUE
ENDIF
tlPlaylistName += iIter
// Custom mix
#IF FEATURE_TUNER
IF iCurrentProperty != PROPERTY_ARCADE_GARAGE
AND pPropertyOwnerID = PLAYER_ID()
AND HAS_LOCAL_PLAYER_COLLECTED_ANY_USB_MIXES()
AND (iIter = (GET_MAX_AVAILABLE_PLAYLISTS() - 1))
tlPlaylistName += "a"
ENDIF
#ENDIF
ADD_MENU_ITEM_TEXT(iIter, tlPlaylistName, 0, bItemAvailable)
IF bItemAvailable
ADD_MENU_ITEM_TEXT(iIter, "JBOX_CHARGE", 0, bItemAvailable)
ENDIF
ENDREPEAT
IF IS_JUKEBOX_ON()
//Add an option to switch off the JB
ADD_MENU_ITEM_TEXT(iIter, "JBOX_M_OFF", 0, TRUE)
ENDIF
SET_CURRENT_MENU_ITEM(iCurrentSelection)
ADD_MENU_HELP_KEY_CLICKABLE(INPUT_FRONTEND_ACCEPT, "ITEM_SELECT")
ADD_MENU_HELP_KEY_CLICKABLE(INPUT_FRONTEND_CANCEL, "ITEM_BACK")
IF iCurrentProperty = PROPERTY_ARCADE_GARAGE
AND IS_JUKEBOX_ON()
ADD_MENU_HELP_KEY_GROUP(INPUTGROUP_FRONTEND_DPAD_LR, "HUD_INPUT77")
ENDIF
ENDPROC
PROC BUILD_FINAL_MENU()
SETUP_MENU_WITH_TITLE("JBOX_CONF_T")
ADD_MENU_ITEM_TEXT(0, "JBOX_MENU_0",0, TRUE)
ADD_MENU_ITEM_TEXT(1, "JBOX_MENU_1",0, TRUE)
SET_CURRENT_MENU_ITEM(iCurrentSelection)
ADD_MENU_HELP_KEY_CLICKABLE(INPUT_FRONTEND_ACCEPT, "ITEM_SELECT")
ADD_MENU_HELP_KEY_CLICKABLE(INPUT_FRONTEND_CANCEL, "ITEM_BACK")
ENDPROC
PROC BUILD_JUKEBOX_MENU()
SWITCH eMenuStage
CASE eTurnJBOffNoMoney
BUILD_JUKEBOX_OFF_MENU()
BREAK
CASE eSelectPlaylist
BUILD_JUKEBOX_MAIN_MENU()
BREAK
CASE eConfirm
BUILD_FINAL_MENU()
BREAK
ENDSWITCH
ENDPROC
PROC SETUP_JUKEBOX_OFF_DESCRIPTION()
SET_CURRENT_MENU_ITEM_DESCRIPTION("JBOX_TOFF_NM")
ENDPROC
PROC SETUP_JUKEBOX_MAIN_MENU_DESCRIPTION()
IF iCurrentSelection = ServerBD.iActivePlaylistID
AND IS_JUKEBOX_ON()
SET_CURRENT_MENU_ITEM_DESCRIPTION("JBOX_PLIST_PLY")
ELIF iCurrentSelection = iMenuOnOffOption
SET_CURRENT_MENU_ITEM_DESCRIPTION("JBOX_TOFF")
ELSE
TEXT_LABEL_15 tlPlaylistDesc = "JBOX_PLIST_D_"
tlPlaylistDesc += iCurrentSelection
// Custom mix
#IF FEATURE_TUNER
IF iCurrentProperty != PROPERTY_ARCADE_GARAGE
AND pPropertyOwnerID = PLAYER_ID()
AND HAS_LOCAL_PLAYER_COLLECTED_ANY_USB_MIXES()
AND (iCurrentSelection = (GET_MAX_AVAILABLE_PLAYLISTS() - 1))
tlPlaylistDesc += "a"
ENDIF
#ENDIF
SET_CURRENT_MENU_ITEM_DESCRIPTION(tlPlaylistDesc)
ENDIF
ENDPROC
PROC SETUP_FINAL_MENU_DESCRIPTION()
IF NOT IS_JUKEBOX_ON()
IF iCurrentSelection = 0
SET_CURRENT_MENU_ITEM_DESCRIPTION("JBOX_CONF_ON")
ELSE
SET_CURRENT_MENU_ITEM_DESCRIPTION("JBOX_CANC_PUR")
ENDIF
ELIF iSelectedPlaylist = iMenuOnOffOption
IF iCurrentSelection = 0
SET_CURRENT_MENU_ITEM_DESCRIPTION("JBOX_CONF_OFF")
ELSE
SET_CURRENT_MENU_ITEM_DESCRIPTION("JBOX_CANC_PUR")
ENDIF
ELIF iCurrentSelection = 0
SET_CURRENT_MENU_ITEM_DESCRIPTION("JBOX_CONF_PUR")
ELSE
SET_CURRENT_MENU_ITEM_DESCRIPTION("JBOX_CANC_PUR")
ENDIF
ENDPROC
PROC RUN_MENU_DESCRIPTION()
SWITCH eMenuStage
CASE eTurnJBOffNoMoney
SETUP_JUKEBOX_OFF_DESCRIPTION()
BREAK
CASE eSelectPlaylist
SETUP_JUKEBOX_MAIN_MENU_DESCRIPTION()
BREAK
CASE eConfirm
SETUP_FINAL_MENU_DESCRIPTION()
BREAK
ENDSWITCH
ENDPROC
PROC DEAL_WITH_HUD_ELEMENTS()
HIDE_HUD_AND_RADAR_THIS_FRAME()
HIDE_SCRIPTED_HUD_COMPONENT_THIS_FRAME(HUD_MP_RANK_BAR)
ENDPROC
/// PURPOSE:
/// Loads them menu assets and builds the current menu
PROC RUN_JUKEBOX_MENU()
IF NOT IS_PAUSE_MENU_ACTIVE_EX()
HANDLE_JUKEBOX_MENU_INPUT()
IF LOAD_MENU_ASSETS("SNK_MNU", DEFAULT, TRUE)
IF IS_BIT_SET(iJukeBoxBS, ciRebuildMenu)
BUILD_JUKEBOX_MENU()
CLEAR_BIT(iJukeBoxBS, ciRebuildMenu)
ELSE
SET_CURRENT_MENU_ITEM(iCurrentSelection)
ENDIF
RUN_MENU_DESCRIPTION()
DRAW_MENU()
DEAL_WITH_HUD_ELEMENTS()
SET_BIT(iJukeBoxBS, ciMenuActive)
ENDIF
ENDIF
ENDPROC
/// PURPOSE:
/// Plays a sync scene on the local player
/// PARAMS:
/// sAnimation - The anim to play
/// bInterupt - Interupt the currently playing animation
/// bLooped - Determines if the anim should play on a loop
/// RETURNS:
/// True when the animation has been started
FUNC BOOL PLAY_INDIVIDUAL_JUKEBOX_ANIMATION(STRING sAnimation, BOOl bInterupt = FALSE, BOOL bLooped = FALSE)
INT iLocaJukeboxSynchSceneID = NETWORK_GET_LOCAL_SCENE_FROM_NETWORK_ID(iJukeBoxSyncSceneID)
REQUEST_ANIM_DICT(sJukeboxAnimDict)
IF HAS_ANIM_DICT_LOADED(sJukeboxAnimDict)
IF (NOT IS_SYNCHRONIZED_SCENE_RUNNING(iLocaJukeboxSynchSceneID)
OR GET_SYNCHRONIZED_SCENE_PHASE(iLocaJukeboxSynchSceneID) >= 0.96)
OR bInterupt
IF IS_SYNCHRONIZED_SCENE_RUNNING(iJukeBoxSyncSceneID)
DETACH_SYNCHRONIZED_SCENE(iJukeBoxSyncSceneID)
iJukeBoxSyncSceneID = -1
ENDIF
iJukeBoxSyncSceneID = NETWORK_CREATE_SYNCHRONISED_SCENE(vSynchSceneOrigin,
GET_ENTITY_ROTATION(obJukebox),DEFAULT,FALSE, bLooped)
NETWORK_ADD_PED_TO_SYNCHRONISED_SCENE(PLAYER_PED_ID(), iJukeBoxSyncSceneID,
sJukeboxAnimDict, sAnimation,
SLOW_BLEND_IN, REALLY_SLOW_BLEND_OUT, SYNCED_SCENE_USE_PHYSICS|SYNCED_SCENE_DONT_INTERRUPT, DEFAULT, REALLY_SLOW_BLEND_IN)
NETWORK_START_SYNCHRONISED_SCENE(iJukeBoxSyncSceneID)
CDEBUG1LN(DEBUG_SAFEHOUSE, "<JUKEBOX> PLAY_INDIVIDUAL_JUKEBOX_ANIMATION started anim: ", sAnimation)
RETURN TRUE
ENDIF
ENDIF
RETURN FALSE
ENDFUNC
//// PURPOSE:
/// Runs the enter to idle sync scene animations on the player using the jukebox
/// RETURNS:
/// True wehn the idle sync scene has started
FUNC BOOL RUN_ENTER_TO_IDLE_SYNC_SCENE()
JUKEBOX_MENU_CONTROL_DISABLE()
CONST_INT ciWalkToPosition 0
CONST_INT ciBeginEnterAnim 1
CONST_INT ciBeginIdleAnim 2
SWITCH iJukeBoxSyncSceneStage
CASE ciWalkToPosition
DISABLE_CELLPHONE_THIS_FRAME_ONLY()
VECTOR vTaregtPos
vTaregtPos = GET_OFFSET_FROM_ENTITY_IN_WORLD_COORDS(obJukebox, <<0.06, -0.8958, 0.2>>)
IF NOT HAS_NET_TIMER_STARTED(stJBWalkToTimer)
START_NET_TIMER(stJBWalkToTimer)
ELIF HAS_NET_TIMER_EXPIRED(stJBWalkToTimer, 2000)
iJukeBoxSyncSceneStage = ciBeginEnterAnim
CDEBUG1LN(DEBUG_SAFEHOUSE, "<JUKEBOX> JB in position timer expierd! Moving on")
ENDIF
IF NOT ARE_VECTORS_ALMOST_EQUAL(GET_ENTITY_COORDS(PLAYER_PED_ID()), vTaregtPos, 0.8)
IF NOT IsPedPerformingTask(PLAYER_PED_ID(), SCRIPT_TASK_GO_STRAIGHT_TO_COORD)
CDEBUG1LN(DEBUG_SAFEHOUSE, "<JUKEBOX> Tasking player to go to:", vTaregtPos)
TASK_GO_STRAIGHT_TO_COORD(PLAYER_PED_ID(), vTaregtPos, PEDMOVEBLENDRATIO_WALK, 4000, GET_ENTITY_HEADING(obJukebox), 0.125)
ENDIF
ELSE
CDEBUG1LN(DEBUG_SAFEHOUSE, "<JUKEBOX> JB in position! Moving on")
#IF IS_DEBUG_BUILD
VECTOR vPlayerPos
vPlayerPos = GET_ENTITY_COORDS(PLAYER_PED_ID())
CDEBUG1LN(DEBUG_SAFEHOUSE, "<JUKEBOX>[ENTER] player pos: ", vPlayerPos, " Target pos: ", vTaregtPos)
#ENDIF
iJukeBoxSyncSceneStage = ciBeginEnterAnim
ENDIF
BREAK
CASE ciBeginEnterAnim
IF PLAY_INDIVIDUAL_JUKEBOX_ANIMATION("ENTER", TRUE)
RESET_NET_TIMER(stJBWalkToTimer)
iJukeBoxSyncSceneStage = ciBeginIdleAnim
CDEBUG1LN(DEBUG_SAFEHOUSE, "<JUKEBOX> ciBeginEnterAnim starting enter anim. Walk to timer reset")
ENDIF
BREAK
CASE ciBeginIdleAnim
IF PLAY_INDIVIDUAL_JUKEBOX_ANIMATION("IDLE", DEFAULT, TRUE)
CDEBUG1LN(DEBUG_SAFEHOUSE, "<JUKEBOX>: RUN_ENTER_TO_IDLE_SYNC_SCENE complete. Start menu")
//Reset the sync scene stage and return true
iJukeBoxSyncSceneStage = 0
RETURN TRUE
ENDIF
BREAK
ENDSWITCH
RETURN FALSE
ENDFUNC
/// PURPOSE:
/// Starts the eixt anim on the player currently using the jukebox
/// Pass true for bPlayInsertCoins to play the insert coin anim first, folowed by the exit
/// RETURNS:
/// True when the sync scene has begun
FUNC BOOL RUN_EXIT_SYNC_SCENE(BOOL bPlayInsertCoins)
CONST_INT ciPlayInsertCoins 0
CONST_INT ciPlayExit 1
IF NOT bPlayInsertCoins
iJukeBoxSyncSceneStage = ciPlayExit
ENDIF
IF NOT IS_ENTITY_DEAD(PLAYER_PED_ID())
SWITCH iJukeBoxSyncSceneStage
CASE ciPlayInsertCoins
IF PLAY_INDIVIDUAL_JUKEBOX_ANIMATION("INSERT_COINS", TRUE)
CDEBUG1LN(DEBUG_SAFEHOUSE, "<JUKEBOX>: <RUN_EXIT_SYNC_SCENE> Coins inserted. moving onto exit anim")
iJukeBoxSyncSceneStage = ciPlayExit
ENDIF
BREAK
CASE ciPlayExit
IF PLAY_INDIVIDUAL_JUKEBOX_ANIMATION("EXIT", NOT bPlayInsertCoins)
REMOVE_ANIM_DICT(sJukeboxAnimDict)
CDEBUG1LN(DEBUG_SAFEHOUSE, "<JUKEBOX>: <RUN_EXIT_SYNC_SCENE> Started exit sync scene")
//Reset the sync scene stage and return true
iJukeBoxSyncSceneStage = 0
RETURN TRUE
ENDIF
BREAK
ENDSWITCH
ELSE
CDEBUG1LN(DEBUG_SAFEHOUSE, "<JUKEBOX>: <RUN_EXIT_SYNC_SCENE> player is dead")
ENDIF
DISABLE_CELLPHONE_THIS_FRAME_ONLY()
RETURN FALSE
ENDFUNC
/// PURPOSE:
/// Runs the slect track animation as a sync scene, then returns back to the idle animation
/// RETURNS:
/// True once the idle animation has started
FUNC BOOL PLAY_SELECT_TRACK_SYNC_SCENE()
CONST_INT ciPlaySelectTrack 0
CONST_INT ciPlayIdle 1
IF NOT IS_ENTITY_DEAD(PLAYER_PED_ID())
SWITCH iJukeBoxSyncSceneStage
CASE ciPlaySelectTrack
IF PLAY_INDIVIDUAL_JUKEBOX_ANIMATION("SELECT_TRACK", TRUE)
CDEBUG1LN(DEBUG_SAFEHOUSE, "<JUKEBOX>: <PLAY_SELECT_TRACK_SYNC_SCENE> Track selected. moving back to idle")
iJukeBoxSyncSceneStage = ciPlayIdle
ENDIF
BREAK
CASE ciPlayIdle
IF PLAY_INDIVIDUAL_JUKEBOX_ANIMATION("IDLE", DEFAULT, TRUE)
CDEBUG1LN(DEBUG_SAFEHOUSE, "<JUKEBOX>: <PLAY_SELECT_TRACK_SYNC_SCENE> Started idle scene")
//Reset the sync scene stage and return true
iJukeBoxSyncSceneStage = 0
RETURN TRUE
ENDIF
BREAK
ENDSWITCH
ELSE
CDEBUG1LN(DEBUG_SAFEHOUSE, "<JUKEBOX>: <RUN_EXIT_SYNC_SCENE> player is dead")
ENDIF
DISABLE_CELLPHONE_THIS_FRAME_ONLY()
RETURN FALSE
ENDFUNC
/// PURPOSE:
/// Checks if the local player is alone in the locate
/// RETURNS:
/// True if alone in the locate
FUNC BOOL IS_PLAYER_ALONE_IN_AREA()
PED_INDEX mPed[2]
INT iPeds = GET_PED_NEARBY_PEDS(PLAYER_PED_ID(), mPed)
IF iPeds > 0
INT i
FOR i = 0 TO 1
IF NOT IS_ENTITY_DEAD(mPed[i])
IF IS_ENTITY_AT_COORD(mPed[i], vtrigger, <<0.8, 0.8, 1.5>>, FALSE, TRUE, TM_ON_FOOT)
RETURN FALSE
ENDIF
ENDIF
ENDFOR
ENDIF
RETURN TRUE
ENDFUNC
/// PURPOSE:
/// Checks if the player can use the jukebox
/// RETURNS:
/// True if the player is able to use the jukebox
FUNC BOOL IS_PLAYER_IN_POSITION_AND_ABLE_TO_USE_JB()
BOOL bPropertyAllowsJukebox = TRUE
IF IS_PLAYER_IN_ARCADE_PROPERTY(PLAYER_ID())
AND NOT HAS_PLAYER_COMPLETED_FULL_ARCADE_SETUP(pPropertyOwnerID)
bPropertyAllowsJukebox = FALSE
ENDIF
IF NOT IS_BIT_SET(g_JukeboxData.iBitSet, ciJBBlockPlayerUsingJB)
AND NOT IS_PLAYER_USING_OFFICE_SEATID_VALID()
AND NOT IS_PHONE_ONSCREEN()
AND NOT IS_BROWSER_OPEN()
AND NOT IS_PED_IN_COVER(PLAYER_PED_ID())
AND (GET_ROOM_KEY_FROM_ENTITY(PLAYER_PED_ID()) = GET_ROOM_KEY_FROM_ENTITY(obJukebox))
AND IS_ENTITY_AT_COORD(PLAYER_PED_ID(), vtrigger, <<0.55, 0.8, 1.5>>, FALSE, TRUE, TM_ON_FOOT)
//AND IS_PLAYER_ALONE_IN_AREA()
AND NOT IS_ENTITY_PLAYING_ANIM(PLAYER_PED_ID(), sJukeboxAnimDict, "EXIT")
AND NOT IS_PLAYER_ENTERING_OR_EXITING_PROPERTY(PLAYER_ID())
AND NOT IS_JUKEBOX_IN_USE()
AND bPropertyAllowsJukebox
AND NOT IS_BIT_SET(g_simpleInteriorData.iFifthBS, BS5_SIMPLE_INTERIOR_INSTANT_PASS_OUT)
AND Get_Peds_Drunk_Alcohol_Hit_Count(PLAYER_PED_ID()) <= 9
AND NOT g_SpawnData.bPassedOutDrunk
AND NOT IS_PED_RAGDOLL(PLAYER_PED_ID())
RETURN TRUE
ENDIF
RETURN FALSE
ENDFUNC
/// PURPOSE:
/// Runs a check to see if the player can afford to use the JB
/// If the JB is on we should still be able to turn it off
FUNC BOOL CAN_PLAYER_USE_JB_WITH_NO_MONEY()
IF IS_JUKEBOX_ON()
OR NETWORK_CAN_SPEND_MONEY(1, FALSE, FALSE, FALSE)
RETURN TRUE
ENDIF
RETURN FALSE
ENDFUNC
PROC REQUEST_PLAYLIST_CHANGE(INT iNewPlaylistID)
playerBD[NATIVE_TO_INT(PLAYER_ID())].iNewPlaylistRequestID = iNewPlaylistID
SET_BIT(playerBD[NATIVE_TO_INT(PLAYER_ID())].iBitSet, ciRequestedPlaylistChange)
CDEBUG1LN(DEBUG_SAFEHOUSE, "<JUKEBOX> RUN_JUKEBOX_ACTIVITY stage exit. Requested playlist change to ", iNewPlaylistID)
ENDPROC
PROC CLEAR_NO_MONEY_HELP()
IF IS_HELP_MESSAGE_BEING_DISPLAYED()
AND IS_THIS_HELP_MESSAGE_BEING_DISPLAYED("JBOX_NO_MONEY")
CLEAR_HELP(TRUE)
ENDIF
ENDPROC
/// PURPOSE:
/// Runs the jukebox activity stages for the local player
/// This will request to use the jukebox when the player triggers the context intention
PROC RUN_JUKEBOX_ACTIVITY()
SWITCH eActivityStage
CASE eJAInactive
IF IS_PLAYER_IN_POSITION_AND_ABLE_TO_USE_JB()
AND CAN_PLAYER_USE_JB_WITH_NO_MONEY()
CLEAR_NO_MONEY_HELP()
IF iJukeboxContextIntention = NEW_CONTEXT_INTENTION
REGISTER_CONTEXT_INTENTION(iJukeboxContextIntention, CP_HIGH_PRIORITY, "JBOX_INTERACT")
ELIF (iJukeboxContextIntention != NEW_CONTEXT_INTENTION AND HAS_CONTEXT_BUTTON_TRIGGERED(iJukeboxContextIntention))
AND NOT IS_PED_RUNNING(PLAYER_PED_ID())
SET_JUKEBOX_ACTIVITY_STAGE(eJAAwaitingAproval)
RELEASE_CONTEXT_INTENTION(iJukeboxContextIntention)
//Disable player controls
NET_SET_PLAYER_CONTROL(PLAYER_ID(), FALSE, NSPC_LEAVE_CAMERA_CONTROL_ON)
CDEBUG1LN(DEBUG_SAFEHOUSE, "<JUKEBOX>: RUN_JB_ACTIVITY player is requesting use of JB. Player ID: ", NATIVE_TO_INT(PLAYER_ID()))
SET_BIT(playerBD[NATIVE_TO_INT(PLAYER_ID())].iBitSet, ciRequestingUseOfJukebox)
SET_BIT(g_JukeboxData.iBitSet, ciJBTriggeredContextInt)
ENDIF
SET_BIT(g_JukeboxData.iBitSet, ciJBInLocate)
ELIF iJukeboxContextIntention != NEW_CONTEXT_INTENTION
RELEASE_CONTEXT_INTENTION(iJukeboxContextIntention)
CLEAR_BIT(g_JukeboxData.iBitSet, ciJBInLocate)
ELIF NOT CAN_PLAYER_USE_JB_WITH_NO_MONEY()
AND IS_PLAYER_IN_POSITION_AND_ABLE_TO_USE_JB()
PRINT_HELP_FOREVER("JBOX_NO_MONEY")
CLEAR_BIT(g_JukeboxData.iBitSet, ciJBInLocate)
ELSE
CLEAR_NO_MONEY_HELP()
CLEAR_BIT(g_JukeboxData.iBitSet, ciJBInLocate)
ENDIF
BREAK
CASE eJAAwaitingAproval
IF serverBD.iJukeboxUserID = NATIVE_TO_INT(PLAYER_ID())
AND IS_SKYSWOOP_AT_GROUND()
//Start the entry sync scene from the begining
iJukeBoxSyncSceneStage = 0
//Move onto the next main stage
SET_JUKEBOX_ACTIVITY_STAGE(eJAPlayingEntryAnim)
//Clear our request
CLEAR_BIT(playerBD[NATIVE_TO_INT(PLAYER_ID())].iBitSet, ciRequestingUseOfJukebox)
//Inform the server we're using the Jukebox
SET_BIT(playerBD[NATIVE_TO_INT(PLAYER_ID())].iBitSet, ciUsingJukebox)
//Clear the walk to timer
RESET_NET_TIMER(stJBWalkToTimer)
CDEBUG1LN(DEBUG_SAFEHOUSE, "<JUKEBOX>: RUN_JB_ACTIVITY JB request approved. Player ID: ", NATIVE_TO_INT(PLAYER_ID()), " Calling NET_SET_PLAYER_CONTROL with FALSE & NSPC_LEAVE_CAMERA_CONTROL_ON")
ELIF serverBD.iJukeboxUserID != -1
OR NOT IS_SKYSWOOP_AT_GROUND()
SET_JUKEBOX_ACTIVITY_STAGE(eJAInactive)
CLEAR_BIT(playerBD[NATIVE_TO_INT(PLAYER_ID())].iBitSet, ciRequestingUseOfJukebox)
CLEAR_BIT(g_JukeboxData.iBitSet, ciJBTriggeredContextInt)
NET_SET_PLAYER_CONTROL(PLAYER_ID(), TRUE)
CDEBUG1LN(DEBUG_SAFEHOUSE, "<JUKEBOX>: RUN_JB_ACTIVITY JB request denied. Player ID: ", NATIVE_TO_INT(PLAYER_ID()), " Player already using is: ", serverBD.iJukeboxUserID)
ENDIF
BREAK
CASE eJAPlayingEntryAnim
IF RUN_ENTER_TO_IDLE_SYNC_SCENE()
iCurrentSelection = 0
SET_BIT(iJukeBoxBS, ciRebuildMenu)
SET_JUKEBOX_ACTIVITY_STAGE(eJAMenuActive)
IF NOT NETWORK_CAN_SPEND_MONEY(1, FALSE, FALSE, FALSE)
eMenuStage = eTurnJBOffNoMoney
ENDIF
ENDIF
BREAK
CASE eJAMenuActive
IF IS_BIT_SET(iJukeBoxBS ,ciPlaySelectTrackAnim)
IF PLAY_SELECT_TRACK_SYNC_SCENE()
CLEAR_BIT(iJukeBoxBS, ciPlaySelectTrackAnim)
ENDIF
ENDIF
RUN_JUKEBOX_MENU()
BREAK
CASE eJAExit
IF IS_BIT_SET(iJukeBoxBS, ciMenuActive)
CLEAR_BIT(iJukeBoxBS, ciMenuActive)
CLEANUP_MENU_ASSETS()
ENDIF
INT iLocaJukeboxSynchSceneID
iLocaJukeboxSynchSceneID = NETWORK_GET_LOCAL_SCENE_FROM_NETWORK_ID(iJukeBoxSyncSceneID)
IF NOT IS_ENTITY_PLAYING_ANIM(PLAYER_PED_ID(), sJukeboxAnimDict, "EXIT")
RUN_EXIT_SYNC_SCENE(IS_BIT_SET(iJukeBoxBS ,ciPlayInsertCoinAnim))
//Select then new playlist whilst the insert coins anim is playing
//Or when the exit anim has begun (For turning the JB off)
IF iSelectedPlaylist != -1
IF IS_ENTITY_PLAYING_ANIM(PLAYER_PED_ID(), sJukeboxAnimDict, "INSERT_COINS")
AND GET_SYNCHRONIZED_SCENE_PHASE(iLocaJukeboxSynchSceneID) >= 0.82
OR NOT IS_BIT_SET(iJukeBoxBS ,ciPlayInsertCoinAnim)
REQUEST_PLAYLIST_CHANGE(iSelectedPlaylist)
ENDIF
ENDIF
ELSE
IF GET_SYNCHRONIZED_SCENE_PHASE(iLocaJukeboxSynchSceneID) >= 0.96
CLEAR_BIT(iJukeBoxBS ,ciPlayInsertCoinAnim)
CLEAR_BIT(iJukeBoxBS, ciPlaySelectTrackAnim)
CLEAR_BIT(playerBD[NATIVE_TO_INT(PLAYER_ID())].iBitSet, ciUsingJukebox)
CLEAR_BIT(playerBD[NATIVE_TO_INT(PLAYER_ID())].iBitSet, ciRequestedPlaylistChange)
CLEAR_BIT(playerBD[NATIVE_TO_INT(PLAYER_ID())].iBitSet, ciRequestedVolumeChange)
CDEBUG1LN(DEBUG_SAFEHOUSE, "<JUKEBOX> RUN_JUKEBOX_ACTIVITY calling NET_SET_PLAYER_CONTROL with TRUE")
NET_SET_PLAYER_CONTROL(PLAYER_ID(), TRUE)
CLEAR_BIT(g_JukeboxData.iBitSet, ciJBTriggeredContextInt)
eMenuStage = eSelectPlaylist
#IF FEATURE_CASINO_HEIST
IF iCurrentProperty = PROPERTY_ARCADE_GARAGE
iTelemSelectedPlaylist = GlobalplayerBD_FM[NATIVE_TO_INT(pPropertyOwnerID)].propertyDetails.iClubhouseJBPlaylistID
ELSE
#ENDIF
iTelemSelectedPlaylist = GlobalplayerBD_FM[NATIVE_TO_INT(pPropertyOwnerID)].propertyDetails.iArcadeJBPlaylistID
#IF FEATURE_CASINO_HEIST
ENDIF
#ENDIF
// Send telemetry data on this activity.
PLAYSTATS_MC_CLUBHOUSE_ACTIVITY(
GB_GET_GANG_BOSS_UUID_INT_A(GB_GET_LOCAL_PLAYER_GANG_BOSS()),
GB_GET_GANG_BOSS_UUID_INT_B(GB_GET_LOCAL_PLAYER_GANG_BOSS()),
GB_GET_MATCH_ID_1_FOR_TELEMETRY(),
GB_GET_MATCH_ID_2_FOR_TELEMETRY(),
4,
iTelemSelectedPlaylist,
0)
CDEBUG1LN(DEBUG_SAFEHOUSE, "<JUKEBOX> PLAYSTATS_MC_CLUBHOUSE_ACTIVITY: Setting Jukebox station to ", iTelemSelectedPlaylist)
SET_JUKEBOX_ACTIVITY_STAGE(eJAInactive)
ENDIF
ENDIF
BREAK
ENDSWITCH
ENDPROC
PROC RUN_NETWORK_SCRIPT_INIT()
IF NETWORK_IS_GAME_IN_PROGRESS()
AND NOT IS_BIT_SET(iJukeBoxBS, cinetworkInitDone)
//Get the interior instance we are in
INT iInteriorInstance = mpPropMaintain.iMostRecentPropertyID
#IF FEATURE_CASINO_HEIST
IF IS_PLAYER_IN_ANY_SIMPLE_INTERIOR(PLAYER_ID())
iInteriorInstance = GET_SIMPLE_INTERIOR_INT_SCRIPT_INSTANCE() + 32
ENDIF
#ENDIF
CDEBUG1LN(DEBUG_SAFEHOUSE, "<JUKEBOX> RUN_NETWORK_SCRIPT_INIT atempting to create a network script with an instance ID of: ", iInteriorInstance)
NETWORK_SET_SCRIPT_IS_SAFE_FOR_NETWORK_GAME()
NETWORK_SET_THIS_SCRIPT_IS_NETWORK_SCRIPT(NUM_NETWORK_PLAYERS, FALSE, iInteriorInstance)
// This makes sure the net script is active, waits until it is.
HANDLE_NET_SCRIPT_INITIALISATION()
SET_THIS_SCRIPT_CAN_BE_PAUSED(FALSE)
NETWORK_REGISTER_HOST_BROADCAST_VARIABLES(serverBD, SIZE_OF(serverBD))
NETWORK_REGISTER_PLAYER_BROADCAST_VARIABLES(playerBD, SIZE_OF(playerBD))
// KGM: Wait for the first network broadcast before moving on
// (after Initialisation and Broadcast Variable Registration - Hosts can do this too)
IF NOT Wait_For_First_Network_Broadcast()
PRINTLN("[MP safehouse]<JUKEBOX> - MISSION END - FAILED TO RECEIVE INITIAL NETWORK BROADCAST - SCRIPT CLEANUP")
CLEANUP_JUKEBOX()
ENDIF
SET_BIT(iJukeBoxBS, cinetworkInitDone)
CDEBUG1LN(DEBUG_SAFEHOUSE, "[MP safehouse]<JUKEBOX> JUKEBOX script: Ready for network launch...")
ENDIF
ENDPROC
/// PURPOSE:
/// Check for any flags that mean this script should terminate
PROC RUN_CLEANUP_CHECKS()
#IF FEATURE_CASINO_HEIST
IF iCurrentProperty = PROPERTY_ARCADE_GARAGE
IF IS_PLAYER_WALKING_OUT_OF_SIMPLE_INTERIOR(PLAYER_ID())
CDEBUG1LN(DEBUG_SAFEHOUSE, "<JUKEBOX> Shutting down! IS_PLAYER_WALKING_OUT_OF_SIMPLE_INTERIOR")
CLEANUP_JUKEBOX()
ELIF NOT NETWORK_IS_GAME_IN_PROGRESS()
CDEBUG1LN(DEBUG_SAFEHOUSE, "<JUKEBOX> Shutting down! No network game is currently active")
CLEANUP_JUKEBOX()
ELIF IS_ENTITY_DEAD(PLAYER_PED_ID())
CDEBUG1LN(DEBUG_SAFEHOUSE, "<JUKEBOX> Shutting down! Player is injured or dead")
CLEANUP_JUKEBOX()
ELIF IS_BIT_SET(g_JukeboxData.iBitSet, ciJBInteriorGeneralCleanup)
CDEBUG1LN(DEBUG_SAFEHOUSE, "<JUKEBOX> Shutting down! ciJBInteriorGeneralCleanup is set")
CLEAR_BIT(g_JukeboxData.iBitSet, ciJBInteriorGeneralCleanup)
CLEANUP_JUKEBOX()
ELIF IS_BIT_SET(g_SimpleInteriorData.iSeventhBS, BS7_SIMPLE_INTERIOR_RENOVATION_TRIGGERED)
IF eActivityStage != eJAInactive
IF IS_BIT_SET(iJukeBoxBS, ciMenuActive)
CLEAR_BIT(iJukeBoxBS, ciMenuActive)
CLEANUP_MENU_ASSETS()
ENDIF
CLEAR_BIT(iJukeBoxBS ,ciPlayInsertCoinAnim)
CLEAR_BIT(iJukeBoxBS, ciPlaySelectTrackAnim)
CLEAR_BIT(playerBD[NATIVE_TO_INT(PLAYER_ID())].iBitSet, ciUsingJukebox)
CLEAR_BIT(playerBD[NATIVE_TO_INT(PLAYER_ID())].iBitSet, ciRequestedPlaylistChange)
CLEAR_BIT(playerBD[NATIVE_TO_INT(PLAYER_ID())].iBitSet, ciRequestedVolumeChange)
CLEAR_BIT(playerBD[NATIVE_TO_INT(PLAYER_ID())].iBitSet, ciRequestingUseOfJukebox)
CLEAR_BIT(g_JukeboxData.iBitSet, ciJBTriggeredContextInt)
eMenuStage = eSelectPlaylist
SET_JUKEBOX_ACTIVITY_STAGE(eJAInactive)
CDEBUG1LN(DEBUG_SAFEHOUSE, "<JUKEBOX> Cleaning up JB! Player is renovating the arcade whilst using the JB")
ENDIF
ELIF NOT IS_PLAYER_IN_ARCADE_PROPERTY(PLAYER_ID())
CDEBUG1LN(DEBUG_SAFEHOUSE, "<JUKEBOX> Shutting down! Player has left the building")
CLEANUP_JUKEBOX()
ENDIF
ELSE
#ENDIF
IF IS_BIT_SET(GlobalplayerBD_FM[NATIVE_TO_INT(PLAYER_ID())].propertyDetails.iBS,PROPERTY_BROADCAST_BS_PLAYER_EXITING_PROPERTY)
CDEBUG1LN(DEBUG_SAFEHOUSE, "<JUKEBOX> Shutting down! PROPERTY_BROADCAST_BS_PLAYER_EXITING_PROPERTY is set")
CLEANUP_JUKEBOX()
ELIF NOT NETWORK_IS_GAME_IN_PROGRESS()
CDEBUG1LN(DEBUG_SAFEHOUSE, "<JUKEBOX> Shutting down! No network game is currently active")
CLEANUP_JUKEBOX()
ELIF IS_ENTITY_DEAD(PLAYER_PED_ID())
CDEBUG1LN(DEBUG_SAFEHOUSE, "<JUKEBOX> Shutting down! Player is injured or dead")
CLEANUP_JUKEBOX()
ELIF IS_BIT_SET(g_JukeboxData.iBitSet, ciJBInteriorGeneralCleanup)
CDEBUG1LN(DEBUG_SAFEHOUSE, "<JUKEBOX> Shutting down! ciJBInteriorGeneralCleanup is set")
CLEAR_BIT(g_JukeboxData.iBitSet, ciJBInteriorGeneralCleanup)
CLEANUP_JUKEBOX()
ELIF GET_UPDATE_CUSTOM_APT()
IF eActivityStage != eJAInactive
IF IS_BIT_SET(iJukeBoxBS, ciMenuActive)
CLEAR_BIT(iJukeBoxBS, ciMenuActive)
CLEANUP_MENU_ASSETS()
ENDIF
CLEAR_BIT(iJukeBoxBS ,ciPlayInsertCoinAnim)
CLEAR_BIT(iJukeBoxBS, ciPlaySelectTrackAnim)
CLEAR_BIT(playerBD[NATIVE_TO_INT(PLAYER_ID())].iBitSet, ciUsingJukebox)
CLEAR_BIT(playerBD[NATIVE_TO_INT(PLAYER_ID())].iBitSet, ciRequestedPlaylistChange)
CLEAR_BIT(playerBD[NATIVE_TO_INT(PLAYER_ID())].iBitSet, ciRequestedVolumeChange)
CLEAR_BIT(playerBD[NATIVE_TO_INT(PLAYER_ID())].iBitSet, ciRequestingUseOfJukebox)
CLEAR_BIT(g_JukeboxData.iBitSet, ciJBTriggeredContextInt)
eMenuStage = eSelectPlaylist
SET_JUKEBOX_ACTIVITY_STAGE(eJAInactive)
CDEBUG1LN(DEBUG_SAFEHOUSE, "<JUKEBOX> Cleaning up JB! Player is renovating the clubhouse whilst using the JB")
ENDIF
ELIF iCurrentProperty != GlobalplayerBD_FM[NATIVE_TO_INT(PLAYER_ID())].propertyDetails.iCurrentlyInsideProperty
CDEBUG1LN(DEBUG_SAFEHOUSE, "<JUKEBOX> Shutting down! Player has left the building")
CLEANUP_JUKEBOX()
ENDIF
#IF FEATURE_CASINO_HEIST
ENDIF
#ENDIF
ENDPROC
/// PURPOSE:
/// Returns the location of the jukebox interior. Used to grab a handle to the object
FUNC VECTOR GET_JUKEBOX_COORDS
IF IS_PROPERTY_CLUBHOUSE(iCurrentProperty)
RETURN GET_CLUBHOUSE_JUKEBOX_COORDS(iCurrentProperty)
#IF FEATURE_CASINO_HEIST
ELIF iCurrentProperty = PROPERTY_ARCADE_GARAGE
RETURN GET_ARCADE_JUKEBOX_COORDS()
#ENDIF
ENDIF
RETURN <<0.0, 0.0, 0.0>>
ENDFUNC
/// PURPOSE:
/// Sets the station for all emitters in the current interior
PROC CHANGE_PLAYLIST(INT iPlaylistID)
IF IS_PROPERTY_CLUBHOUSE(iCurrentProperty)
//We want to save the current playlist but not try to set the static emiters to an invalid playlist
IF iPlaylistID != iMenuOnOffOption
AND iPlaylistID != -1
IF pPropertyOwnerID = PLAYER_ID()
AND iJBSelectedPlistPlayTime != 0
SAVE_JB_PLAYLIST_PLAY_TIME(iLocalActivePlaylistID)
ENDIF
CHANGE_CLUBHOUSE_JUKEBOX_PLAYLIST(iCurrentProperty, iPlaylistID)
ENDIF
IF iPlaylistID != -1
iLocalActivePlaylistID = iPlaylistID
ENDIF
CDEBUG1LN(DEBUG_SAFEHOUSE, "<JUKEBOX> CHANGE_PLAYLIST Server says Playlist changed to ", iPlaylistID)
#IF FEATURE_CASINO_HEIST
ELIF iCurrentProperty = PROPERTY_ARCADE_GARAGE
//We want to save the current playlist but not try to set the static emiters to an invalid playlist
IF iPlaylistID != iMenuOnOffOption
AND iPlaylistID != -1
IF pPropertyOwnerID = PLAYER_ID()
AND iJBSelectedPlistPlayTime != 0
SAVE_JB_PLAYLIST_PLAY_TIME(iLocalActivePlaylistID)
ENDIF
CHANGE_ARCADE_JUKEBOX_PLAYLIST(iPlaylistID)
ENDIF
IF iPlaylistID != -1
iLocalActivePlaylistID = iPlaylistID
ENDIF
CDEBUG1LN(DEBUG_SAFEHOUSE, "<JUKEBOX> CHANGE_PLAYLIST Server says Playlist changed to ", iPlaylistID)
#ENDIF
ELSE
CASSERTLN(DEBUG_SAFEHOUSE, "<JUKEBOX> CHANGE_PLAYLIST invalid property ID: ", iCurrentProperty)
ENDIF
ENDPROC
/// PURPOSE:
/// Turn on or off the static emitters
PROC SET_ALL_JUKEBOX_STATIC_EMITTERS_ON_OFF_STATE(BOOL bEnabled)
IF bEnabled
SET_BIT(iJukeBoxBS, ciJukeboxEnabled)
ELSE
CLEAR_BIT(iJukeBoxBS, ciJukeboxEnabled)
ENDIF
IF IS_PROPERTY_CLUBHOUSE(iCurrentProperty)
SET_CLUBHOUSE_JUKEBOX_STATIC_EMITTERS_ON_OFF_STATE(iCurrentProperty, bEnabled)
#IF FEATURE_CASINO_HEIST
ELIF iCurrentProperty = PROPERTY_ARCADE_GARAGE
SET_ARCADE_JUKEBOX_STATIC_EMITTERS_ON_OFF_STATE(bEnabled)
#ENDIF
ELSE
CASSERTLN(DEBUG_SAFEHOUSE, "<JUKEBOX> SET_ALL_JUKEBOX_STATIC_EMITTERS_ON_OFF_STATE invalid property ID: ", iCurrentProperty)
ENDIF
ENDPROC
/// PURPOSE:
/// Run checks for any requests to use the jukebox or change the current playlist
PROC RUN_SERVER_CHECKS()
IF IS_JUKEBOX_IN_USE()
//Check for any new playlist requests
IF IS_BIT_SET(playerBD[serverBD.iJukeboxUserID].iBitSet, ciRequestedPlaylistChange)
IF playerBD[serverBD.iJukeboxUserID].iNewPlaylistRequestID = iMenuOnOffOption
IF IS_JUKEBOX_ON()
CDEBUG1LN(DEBUG_SAFEHOUSE, "<JUKEBOX> RUN_SERVER_CHECKS jukebox no longer in use. Requesting Jukebox turn OFF by player: ", serverBD.iJukeboxUserID)
serverBD.iJukeboxServerState = JBServerStageOff
serverBD.iActivePlaylistID = iMenuOnOffOption
IF NATIVE_TO_INT(pPropertyOwnerID) = serverBD.iJukeboxUserID
CDEBUG1LN(DEBUG_SAFEHOUSE, "<JUKEBOX> RUN_SERVER_CHECKS jukebox no longer in use. Property Owner requested turn off")
serverBD.bNewPlaylistSelectedByOwner = TRUE
ENDIF
ENDIF
ELIF serverBD.iActivePlaylistID != playerBD[serverBD.iJukeboxUserID].iNewPlaylistRequestID
serverBD.iActivePlaylistID = playerBD[serverBD.iJukeboxUserID].iNewPlaylistRequestID
CDEBUG1LN(DEBUG_SAFEHOUSE, "<JUKEBOX> RUN_SERVER_CHECKS jukebox no longer in use. Requesting PList change to ", serverBD.iActivePlaylistID, " by player: ", serverBD.iJukeboxUserID)
IF NATIVE_TO_INT(pPropertyOwnerID) = serverBD.iJukeboxUserID
CDEBUG1LN(DEBUG_SAFEHOUSE, "<JUKEBOX> RUN_SERVER_CHECKS jukebox no longer in use. Property Owner requested state change")
serverBD.bNewPlaylistSelectedByOwner = TRUE
ENDIF
serverBD.iJukeboxServerState = JBServerStageOn
ENDIF
ENDIF
//Check for any new playlist requests
IF IS_BIT_SET(playerBD[serverBD.iJukeboxUserID].iBitSet, ciRequestedVolumeChange)
IF serverBD.fVolume != playerBD[serverBD.iJukeboxUserID].fVolume
serverBD.fVolume = playerBD[serverBD.iJukeboxUserID].fVolume
CDEBUG1LN(DEBUG_SAFEHOUSE, "<JUKEBOX> RUN_SERVER_CHECKS - Requesting volume change to ", serverBD.fVolume, " by player: ", serverBD.iJukeboxUserID)
ENDIF
ENDIF
//Monitor the player using the jukebox
IF NOT IS_BIT_SET(playerBD[serverBD.iJukeboxUserID].iBitSet, ciUsingJukebox)
AND NOT IS_BIT_SET(playerBD[serverBD.iJukeboxUserID].iBitSet, ciRequestingUseOfJukebox)
serverBD.iJukeboxUserID = -1
ENDIF
//Look for any new requests to use the JB
ELIF IS_BIT_SET(playerBD[iStaggeredPlayerLoop].iBitSet, ciRequestingUseOfJukebox)
IF NOT IS_JUKEBOX_IN_USE()
serverBD.iJukeboxUserID = iStaggeredPlayerLoop
CDEBUG1LN(DEBUG_SAFEHOUSE, "<JUKEBOX> RUN_SERVER_CHECKS jukebox now in use by player ", iStaggeredPlayerLoop)
ENDIF
ENDIF
//Make sure we reset this flag once the oner has saved the new playlist
//We do this because the owner of the clubhouse may not be the script host
IF NOT IS_JUKEBOX_IN_USE()
#IF FEATURE_CASINO_HEIST
IF iCurrentProperty = PROPERTY_ARCADE_GARAGE
IF GlobalplayerBD_FM[NATIVE_TO_INT(pPropertyOwnerID)].propertyDetails.iArcadeJBPlaylistID = serverBD.iActivePlaylistID
AND (NOT IS_JUKEBOX_ON() AND GlobalplayerBD_FM[NATIVE_TO_INT(pPropertyOwnerID)].propertyDetails.iArcadeJBPlaylistID = iMenuOnOffOption)
serverBD.bNewPlaylistSelectedByOwner = FALSE
ENDIF
ELSE
#ENDIF
IF GlobalplayerBD_FM[NATIVE_TO_INT(pPropertyOwnerID)].propertyDetails.iClubhouseJBPlaylistID = serverBD.iActivePlaylistID
AND (NOT IS_JUKEBOX_ON() AND GlobalplayerBD_FM[NATIVE_TO_INT(pPropertyOwnerID)].propertyDetails.iClubhouseJBPlaylistID = iMenuOnOffOption)
serverBD.bNewPlaylistSelectedByOwner = FALSE
ENDIF
#IF FEATURE_CASINO_HEIST
ENDIF
#ENDIF
ENDIF
//Move to the next player in the loop
iStaggeredPlayerLoop ++
IF iStaggeredPlayerLoop = NUM_NETWORK_PLAYERS
iStaggeredPlayerLoop = 0
ENDIF
ENDPROC
/// PURPOSE:
/// Run client side checks. Currently only checks for playlist changes
PROC RUN_CLIENT_CHECKS()
BOOL bServerJBEnabled = IS_JUKEBOX_ON()
IF serverBD.iActivePlaylistID != iLocalActivePlaylistID
CHANGE_PLAYLIST(serverBD.iActivePlaylistID)
//Set our stat and BD if we're the owner
//We do this because the owner of the clubhouse may not be the script host
IF pPropertyOwnerID = PLAYER_ID()
AND serverBD.bNewPlaylistSelectedByOwner
#IF FEATURE_CASINO_HEIST
IF iCurrentProperty = PROPERTY_ARCADE_GARAGE
SET_PACKED_STAT_INT(PACKED_MP_INT_ARCADE_JB_SAVED_PLAYLIST, iLocalActivePlaylistID)
GlobalplayerBD_FM[NATIVE_TO_INT(pPropertyOwnerID)].propertyDetails.iArcadeJBPlaylistID = iLocalActivePlaylistID
ELSE
#ENDIF
SET_PACKED_STAT_INT(PACKED_MP_INT_CLUBHOUSE_JB_SAVED_PLAYLIST, iLocalActivePlaylistID)
GlobalplayerBD_FM[NATIVE_TO_INT(pPropertyOwnerID)].propertyDetails.iClubhouseJBPlaylistID = iLocalActivePlaylistID
#IF FEATURE_CASINO_HEIST
ENDIF
#ENDIF
CDEBUG1LN(DEBUG_SAFEHOUSE, "<JUKEBOX> RUN_CLIENT_CHECKS property owner setting PL stats")
ENDIF
ENDIF
IF (IS_BIT_SET(iJukeBoxBS, ciJukeboxEnabled) != bServerJBEnabled)
SET_ALL_JUKEBOX_STATIC_EMITTERS_ON_OFF_STATE(bServerJBEnabled)
//Set our stat and BD if we're the owner
//We do this because the owner of the clubhouse may not be the script host
IF pPropertyOwnerID = PLAYER_ID()
AND serverBD.bNewPlaylistSelectedByOwner
AND NOT bServerJBEnabled
#IF FEATURE_CASINO_HEIST
IF iCurrentProperty = PROPERTY_ARCADE_GARAGE
SET_PACKED_STAT_INT(PACKED_MP_INT_ARCADE_JB_SAVED_PLAYLIST, iMenuOnOffOption)
GlobalplayerBD_FM[NATIVE_TO_INT(pPropertyOwnerID)].propertyDetails.iArcadeJBPlaylistID = iMenuOnOffOption
ELSE
#ENDIF
SET_PACKED_STAT_INT(PACKED_MP_INT_CLUBHOUSE_JB_SAVED_PLAYLIST, iMenuOnOffOption)
GlobalplayerBD_FM[NATIVE_TO_INT(pPropertyOwnerID)].propertyDetails.iClubhouseJBPlaylistID = iMenuOnOffOption
#IF FEATURE_CASINO_HEIST
ENDIF
#ENDIF
CDEBUG1LN(DEBUG_SAFEHOUSE, "<JUKEBOX> RUN_CLIENT_CHECKS property owner setting PL stat to OFF")
ENDIF
ENDIF
ENDPROC
PROC RUN_AUTOSAVE_STAT_TIMER()
IF pPropertyOwnerID = PLAYER_ID()
AND IS_JUKEBOX_ON()
IF NOT HAS_NET_TIMER_STARTED(stStatAutosaveTimer)
START_NET_TIMER(stStatAutosaveTimer)
ELIF HAS_NET_TIMER_EXPIRED(stStatAutosaveTimer, 180000)
SAVE_JB_PLAYLIST_PLAY_TIME(iLocalActivePlaylistID)
REINIT_NET_TIMER(stStatAutosaveTimer)
ENDIF
ENDIF
ENDPROC
//FEATURE_BIKER
//***********SCRIPT functions***********
SCRIPT
CDEBUG1LN(DEBUG_SAFEHOUSE, "<JUKEBOX> started \"", GET_THIS_SCRIPT_NAME(), "\"")
IF GET_NUMBER_OF_THREADS_RUNNING_THE_SCRIPT_WITH_THIS_HASH(GET_HASH_KEY("ob_jukebox")) > 1
CDEBUG1LN(DEBUG_SAFEHOUSE, "<JUKEBOX> JUKEBOX script already running! cleaning up.")
CLEANUP_JUKEBOX()
ENDIF
iCurrentProperty = GlobalplayerBD_FM[NATIVE_TO_INT(PLAYER_ID())].propertyDetails.iCurrentlyInsideProperty
#IF FEATURE_CASINO_HEIST
IF IS_PLAYER_IN_ARCADE_PROPERTY(PLAYER_ID())
iCurrentProperty = PROPERTY_ARCADE_GARAGE
ENDIF
#ENDIF
iMenuOnOffOption = GET_MENU_OFF_OPTION()
RUN_CLEANUP_CHECKS()
RUN_NETWORK_SCRIPT_INIT()
// Default cleanup
IF HAS_FORCE_CLEANUP_OCCURRED()
OR MPGlobalsAmbience.bRunningFmIntroCut
IF MPGlobalsAmbience.bRunningFmIntroCut
CDEBUG1LN(DEBUG_SAFEHOUSE, "<JUKEBOX> bRunningFmIntroCut is true so cleaning up!")
ENDIF
CDEBUG1LN(DEBUG_SAFEHOUSE, "<JUKEBOX> DEFAULT CLEANUP")
CLEANUP_JUKEBOX()
ENDIF
//Get the ID of the owner so we can check their BD
GAMER_HANDLE sPropertyOwnerGH
GET_GAMER_HANDLE_OF_PROPERTY_OWNER(PLAYER_ID(), sPropertyOwnerGH)
IF IS_GAMER_HANDLE_VALID(sPropertyOwnerGH)
IF NETWORK_IS_GAMER_IN_MY_SESSION(sPropertyOwnerGH)
pPropertyOwnerID = NETWORK_GET_PLAYER_FROM_GAMER_HANDLE(sPropertyOwnerGH)
ENDIF
ENDIF
#IF FEATURE_CASINO_HEIST
IF iCurrentProperty = PROPERTY_ARCADE_GARAGE
pPropertyOwnerID = GET_OWNER_OF_SIMPLE_INTERIOR_PLAYER_IS_IN(PLAYER_ID())
START_AUDIO_SCENE("dlc_ch_arcade_music_volume")
SET_AUDIO_SCENE_VARIABLE("dlc_ch_arcade_music_volume", "ArcadeRadioVolumeDucking", serverBD.fVolume)
ENDIF
#ENDIF
IF pPropertyOwnerID = INVALID_PLAYER_INDEX()
CDEBUG1LN(DEBUG_SAFEHOUSE, "<JUKEBOX> CLEANUP pPropertyOwnerID = INVALID_PLAYER_INDEX")
CLEANUP_JUKEBOX()
ENDIF
IF NETWORK_IS_HOST_OF_THIS_SCRIPT()
//Select the saved playlist or turn off the jukebox
#IF FEATURE_CASINO_HEIST
IF iCurrentProperty = PROPERTY_ARCADE_GARAGE
IF GlobalplayerBD_FM[NATIVE_TO_INT(pPropertyOwnerID)].propertyDetails.iArcadeJBPlaylistID != iMenuOnOffOption
AND HAS_PLAYER_COMPLETED_FULL_ARCADE_SETUP(pPropertyOwnerID)
CHANGE_PLAYLIST(GlobalplayerBD_FM[NATIVE_TO_INT(pPropertyOwnerID)].propertyDetails.iArcadeJBPlaylistID)
SET_ALL_JUKEBOX_STATIC_EMITTERS_ON_OFF_STATE(TRUE)
serverBD.fVolume = 0.5
serverBD.iJukeboxServerState = JBServerStageOn
serverBD.iActivePlaylistID = iLocalActivePlaylistID
INIT_TIME_STAMP_FOR_CURRENT_PLAYLIST()
ELSE
SET_ALL_JUKEBOX_STATIC_EMITTERS_ON_OFF_STATE(FALSE)
serverBD.fVolume = 0.5
serverBD.iJukeboxServerState = JBServerStageOff
ENDIF
ELSE
#ENDIF
IF GlobalplayerBD_FM[NATIVE_TO_INT(pPropertyOwnerID)].propertyDetails.iClubhouseJBPlaylistID != iMenuOnOffOption
CHANGE_PLAYLIST(GlobalplayerBD_FM[NATIVE_TO_INT(pPropertyOwnerID)].propertyDetails.iClubhouseJBPlaylistID)
SET_ALL_JUKEBOX_STATIC_EMITTERS_ON_OFF_STATE(TRUE)
serverBD.iJukeboxServerState = JBServerStageOn
serverBD.iActivePlaylistID = iLocalActivePlaylistID
INIT_TIME_STAMP_FOR_CURRENT_PLAYLIST()
ELSE
SET_ALL_JUKEBOX_STATIC_EMITTERS_ON_OFF_STATE(FALSE)
serverBD.iJukeboxServerState = JBServerStageOff
ENDIF
#IF FEATURE_CASINO_HEIST
ENDIF
#ENDIF
ELSE
//Get the current playlist and activate the static emitters
CHANGE_PLAYLIST(serverBD.iActivePlaylistID)
SET_ALL_JUKEBOX_STATIC_EMITTERS_ON_OFF_STATE(IS_JUKEBOX_ON())
ENDIF
/// main update loop
WHILE TRUE
RUN_CLEANUP_CHECKS()
iMenuOnOffOption = GET_MENU_OFF_OPTION()
#IF FEATURE_CASINO_HEIST
IF iCurrentProperty = PROPERTY_ARCADE_GARAGE
SET_AUDIO_SCENE_VARIABLE("dlc_ch_arcade_music_volume", "ArcadeRadioVolumeDucking", serverBD.fVolume)
ENDIF
#ENDIF
IF obJukebox != NULL
AND NOT ARE_VECTORS_EQUAL(vSynchSceneOrigin, <<0.0, 0.0, 0.0>>)
IF NETWORK_IS_HOST_OF_THIS_SCRIPT()
RUN_SERVER_CHECKS()
ENDIF
//Runs the sync scene and controls moving through local jukebox stages
RUN_JUKEBOX_ACTIVITY()
//Responds to changes from the server
RUN_CLIENT_CHECKS()
//Run auto save timer
RUN_AUTOSAVE_STAT_TIMER()
ELSE
//Find the object for the property we are inside
//We don't do this to start with as we need to setup the static emitters before the jukebox model is ready
IF iCurrentProperty != -1
AND iCurrentProperty <= MAX_MP_PROPERTIES
vJukeboxCoords = GET_JUKEBOX_COORDS()
IF GET_FRAME_COUNT() % 4 = 0
CDEBUG1LN(DEBUG_SAFEHOUSE, "<JUKEBOX> Looking for Jukebox at coords: ", vJukeboxCoords, " In property: ", iCurrentProperty)
ENDIF
#IF FEATURE_CASINO_HEIST
IF iCurrentProperty = PROPERTY_ARCADE_GARAGE
obJukebox = GET_CLOSEST_OBJECT_OF_TYPE(vJukeboxCoords, 2.0, INT_TO_ENUM(MODEL_NAMES, HASH("ch_prop_arcade_jukebox_01a")), TRUE, FALSE, FALSE)
ELSE
#ENDIF
obJukebox = GET_CLOSEST_OBJECT_OF_TYPE(vJukeboxCoords, 2.0, INT_TO_ENUM(MODEL_NAMES, HASH("bkr_prop_clubhouse_jukebox_01a")), TRUE, FALSE, FALSE)
#IF FEATURE_CASINO_HEIST
ENDIF
#ENDIF
//Calculate the trigger vector
IF DOES_ENTITY_EXIST(obJukebox)
vtrigger = GET_ENTITY_COORDS(obJukebox,TRUE) - (GET_ENTITY_FORWARD_VECTOR(obJukebox)* 0.6)
vtrigger.z += 0.5
vSynchSceneOrigin = GET_OFFSET_FROM_ENTITY_IN_WORLD_COORDS(obJukebox, <<0.0, -0.12, -0.0315>>)
CDEBUG1LN(DEBUG_SAFEHOUSE, "<JUKEBOX>: Found Jukebox! vSyncSceneOrigin: ", vSynchSceneOrigin)
ENDIF
ELSE
CDEBUG1LN(DEBUG_SAFEHOUSE, "<JUKEBOX> JUKEBOX script not in a property so cleaning up!")
CLEANUP_JUKEBOX()
ENDIF
ENDIF
#IF IS_DEBUG_BUILD
IF IS_DEBUG_KEY_JUST_PRESSED(KEY_Q, KEYBOARD_MODIFIER_CTRL_SHIFT, "Kill Jukebox Script")
CLEANUP_JUKEBOX(TRUE)
ENDIF
#ENDIF
WAIT(0)
ENDWHILE
// Script should never reach here. Always terminate with cleanup function.
CASSERTLN(DEBUG_SAFEHOUSE, "<JUKEBOX> \"", GET_THIS_SCRIPT_NAME(), "\" should never reach here. Always terminate with cleanup function.")
ENDSCRIPT
Reference in New Issue View Git Blame Copy Permalink