956 lines
32 KiB
Scheme
Executable File
956 lines
32 KiB
Scheme
Executable File
//- commands headers -//
|
|
USING "commands_replay.sch"
|
|
|
|
//- script headers -//
|
|
|
|
//- public headers -//
|
|
|
|
//- private headers -//
|
|
USING "friendActivity_dialogue_private.sch"
|
|
|
|
#IF IS_DEBUG_BUILD
|
|
//- debug headers -//
|
|
#ENDIF
|
|
|
|
|
|
//---------------------------------------------------------------------------------------------------
|
|
//-- Sort friends
|
|
//---------------------------------------------------------------------------------------------------
|
|
|
|
FUNC BOOL Private_SortMembers(BOOL bSortFriendMembers)
|
|
|
|
enumCharacterList currentPlayerChar = GET_CURRENT_PLAYER_PED_ENUM()
|
|
BOOL bResortedMembers = FALSE
|
|
|
|
// If player has swapped with friend A
|
|
IF gActivity.mFriendA.eState <> FRIEND_NULL AND gActivity.mFriendA.eChar = currentPlayerChar
|
|
|
|
structFriend tempMember = gActivity.mPlayer
|
|
|
|
// Swap player and friend members
|
|
gActivity.mPlayer = gActivity.mFriendA
|
|
gActivity.mFriendA = tempMember
|
|
bResortedMembers = TRUE
|
|
ENDIF
|
|
|
|
// If player has swapped with friend B
|
|
IF gActivity.mFriendB.eState <> FRIEND_NULL AND gActivity.mFriendB.eChar = currentPlayerChar
|
|
|
|
structFriend tempMember = gActivity.mPlayer
|
|
|
|
// Swap player and friend members
|
|
gActivity.mPlayer = gActivity.mFriendB
|
|
gActivity.mFriendB = tempMember
|
|
bResortedMembers = TRUE
|
|
ENDIF
|
|
|
|
// If friend A has cancelled, but friend B still exists
|
|
IF bSortFriendMembers
|
|
IF gActivity.mFriendA.eState = FRIEND_NULL AND gActivity.mFriendB.eState <> FRIEND_NULL
|
|
|
|
structFriend tempMember = gActivity.mFriendA
|
|
|
|
// Swap player and friend members
|
|
gActivity.mFriendA = gActivity.mFriendB
|
|
gActivity.mFriendB = tempMember
|
|
bResortedMembers = TRUE
|
|
ENDIF
|
|
ENDIF
|
|
|
|
// PRIVATE_SET_FRIEND_A_PED_ID(gActivity.mFriendA.hPed)
|
|
// PRIVATE_SET_FRIEND_B_PED_ID(gActivity.mFriendB.hPed)
|
|
|
|
Private_SetFriendsForcedSeats()
|
|
|
|
IF bResortedMembers
|
|
#IF IS_DEBUG_BUILD
|
|
TEXT_LABEL tPlayer = GetLabel_enumCharacterList(gActivity.mPlayer.eChar)
|
|
TEXT_LABEL tFriendA = GetLabel_enumCharacterList(gActivity.mFriendA.eChar)
|
|
TEXT_LABEL tFriendB = GetLabel_enumCharacterList(gActivity.mFriendB.eChar)
|
|
CPRINTLN(DEBUG_FRIENDS, "Pickup_SortFriends():- ", tPlayer, " / ", tFriendA, " / ", tFriendB)
|
|
#ENDIF
|
|
|
|
RETURN TRUE
|
|
ENDIF
|
|
|
|
RETURN FALSE
|
|
ENDFUNC
|
|
|
|
|
|
//---------------------------------------------------------------------------------------------------
|
|
//-- Rejection
|
|
//---------------------------------------------------------------------------------------------------
|
|
|
|
PROC Private_DeleteMembersForGriefing()
|
|
Private_CleanupFriend(gActivity.mPlayer, MC_Delete)
|
|
Private_CleanupFriend(gActivity.mFriendA, MC_Delete)
|
|
Private_CleanupFriend(gActivity.mFriendB, MC_Delete)
|
|
ENDPROC
|
|
|
|
FUNC BOOL Private_CanRejectCharForMission(enumCharacterList eChar, INT iAllowedChars)
|
|
RETURN NOT IS_BIT_SET(iAllowedChars, ENUM_TO_INT(GET_FRIEND_FROM_CHAR(eChar)))
|
|
ENDFUNC
|
|
|
|
FUNC BOOL Private_CanZoneRejectAnyConversableMembers()
|
|
|
|
// Is player in a rejection zone for a mission he can trigger?
|
|
IF (g_eFriendMissionZoneState = FRIEND_MISSION_ZONE_REJECT AND IS_BITMASK_SET(g_sMissionStaticData[g_eFriendMissionZoneID].triggerCharBitset, GET_PLAYER_PED_BIT(GET_CURRENT_PLAYER_PED_ENUM())))
|
|
|
|
// Can any friends in group be rejected for this mission?
|
|
IF (Private_CanFriendConverse(gActivity.mFriendA) AND Private_CanRejectCharForMission(gActivity.mFriendA.eChar, g_iFriendMissionZoneAcceptBitset))
|
|
OR (Private_CanFriendConverse(gActivity.mFriendB) AND Private_CanRejectCharForMission(gActivity.mFriendB.eChar, g_iFriendMissionZoneAcceptBitset))
|
|
RETURN TRUE
|
|
ENDIF
|
|
|
|
// Can any soldiers in group be rejected for this mission?
|
|
enumCharacterList ePlayerChar = GET_CURRENT_PLAYER_PED_ENUM()
|
|
enumCharacterList eChar
|
|
REPEAT MAX_BATTLE_BUDDIES eChar
|
|
IF eChar <> ePlayerChar
|
|
IF (Private_CanSoldierConverse(gActivity.mSoldiers[eChar]) AND Private_CanRejectCharForMission(eChar, g_iFriendMissionZoneAcceptBitset))
|
|
RETURN TRUE
|
|
ENDIF
|
|
ENDIF
|
|
ENDREPEAT
|
|
|
|
ENDIF
|
|
|
|
RETURN FALSE
|
|
|
|
ENDFUNC
|
|
|
|
FUNC BOOL Private_CanTimeRejectAnyConversableMembers()
|
|
|
|
IF g_eFriendMissionZoneState = FRIEND_MISSION_ZONE_OFF
|
|
|
|
IF GET_PLAYER_WANTED_LEVEL(PLAYER_ID()) = 0
|
|
|
|
enumCharacterList ePlayerChar = GET_CURRENT_PLAYER_PED_ENUM()
|
|
enumCharacterList eChar
|
|
REPEAT MAX_BATTLE_BUDDIES eChar
|
|
IF eChar <> ePlayerChar
|
|
IF Private_CanSoldierConverse(gActivity.mSoldiers[eChar]) AND Private_CanRejectSoldierForTime(gActivity.mSoldiers[eChar])
|
|
RETURN TRUE
|
|
ENDIF
|
|
ENDIF
|
|
ENDREPEAT
|
|
|
|
ENDIF
|
|
|
|
ENDIF
|
|
|
|
RETURN FALSE
|
|
|
|
ENDFUNC
|
|
|
|
|
|
|
|
PROC Private_RejectMembersForMission(BOOL bAllowSubtitles, enumFriendActivityPhrase ePhrase = FAP_REJECTION_OK, BOOL bIsPrep = FALSE)
|
|
|
|
IF bAllowSubtitles
|
|
CPRINTLN(DEBUG_FRIENDS, "Private_RejectMembersForMission(bAllowSubtitles = TRUE)")
|
|
ELSE
|
|
CPRINTLN(DEBUG_FRIENDS, "Private_RejectMembersForMission(bAllowSubtitles = FALSE)")
|
|
ENDIF
|
|
CPRINTLN(DEBUG_FRIENDS, "Current mission = ", GetLabel_SP_MISSIONS(g_eFriendMissionZoneID))
|
|
|
|
// Reject friends if they cannot join current mission, or if they are not in group
|
|
|
|
IF bIsPrep
|
|
|
|
IF Private_IsFriendValid(gActivity.mFriendA) AND NOT Private_CanFriendLeave(gActivity.mFriendA)
|
|
Private_SetFriendTrapped(gActivity.mFriendA)
|
|
ELSE
|
|
Private_SetFriendRejected(gActivity.mFriendA, bAllowSubtitles, ePhrase)
|
|
ENDIF
|
|
|
|
ELSE
|
|
IF Private_CanRejectCharForMission(gActivity.mFriendA.eChar, g_iFriendMissionZoneAcceptBitset)
|
|
OR NOT Private_CanFriendConverse(gActivity.mFriendA)
|
|
Private_SetFriendRejected(gActivity.mFriendA, bAllowSubtitles, ePhrase)
|
|
ENDIF
|
|
ENDIF
|
|
|
|
|
|
IF bIsPrep
|
|
|
|
IF Private_IsFriendValid(gActivity.mFriendB) AND NOT Private_CanFriendLeave(gActivity.mFriendB)
|
|
Private_SetFriendTrapped(gActivity.mFriendB)
|
|
ELSE
|
|
Private_SetFriendRejected(gActivity.mFriendB, bAllowSubtitles, ePhrase)
|
|
ENDIF
|
|
|
|
ELSE
|
|
IF Private_CanRejectCharForMission(gActivity.mFriendB.eChar, g_iFriendMissionZoneAcceptBitset)
|
|
OR NOT Private_CanFriendConverse(gActivity.mFriendB)
|
|
Private_SetFriendRejected(gActivity.mFriendB, bAllowSubtitles, ePhrase)
|
|
ENDIF
|
|
ENDIF
|
|
|
|
// Same for soldiers, except if they are on the way to a prep mission, don't reject them for not being in the group yet
|
|
|
|
// enumCharacterList ePlayerChar = GET_CURRENT_PLAYER_PED_ENUM() // BBUDDIES REMOVED
|
|
// enumCharacterList eChar
|
|
// REPEAT MAX_BATTLE_BUDDIES eChar
|
|
// IF eChar <> ePlayerChar
|
|
// IF Private_CanRejectCharForMission(eChar, g_iFriendMissionZoneAcceptBitset)
|
|
// Private_SetSoldierRejected(gActivity.mSoldiers[eChar], g_eFriendMissionZoneID, bAllowSubtitles, ePhrase)
|
|
//
|
|
// ELIF NOT Private_CanSoldierConverse(gActivity.mSoldiers[eChar]) AND NOT IS_BIT_SET(g_sMissionStaticData[g_eFriendMissionZoneID].settingsBitset, MF_INDEX_IS_PREP)
|
|
// Private_SetSoldierRejected(gActivity.mSoldiers[eChar], g_eFriendMissionZoneID, bAllowSubtitles, ePhrase)
|
|
// ENDIF
|
|
// ENDIF
|
|
// ENDREPEAT
|
|
|
|
ENDPROC
|
|
|
|
PROC Private_RejectAllSoldiers(BOOL bAllowSubtitles, enumFriendActivityPhrase ePhrase)
|
|
|
|
#IF IS_DEBUG_BUILD
|
|
TEXT_LABEL_63 tPhrase = GetLabel_enumFriendActivityPhrase(ePhrase)
|
|
CPRINTLN(DEBUG_FRIENDS, "Private_RejectAllSoldiers(", tPhrase, ")")
|
|
#ENDIF
|
|
|
|
enumCharacterList ePlayerChar = GET_CURRENT_PLAYER_PED_ENUM()
|
|
enumCharacterList eChar
|
|
REPEAT MAX_BATTLE_BUDDIES eChar
|
|
IF eChar <> ePlayerChar
|
|
Private_SetSoldierRejected(gActivity.mSoldiers[eChar], g_BattleBuddyMission, bAllowSubtitles, ePhrase)
|
|
ENDIF
|
|
ENDREPEAT
|
|
ENDPROC
|
|
|
|
|
|
|
|
PROC Private_SetZoneRejection(BOOL bEnable)
|
|
IF gActivity.bIsZoneRejectionEnabled <> bEnable
|
|
|
|
// Enable/disable zone rejection
|
|
gActivity.bIsZoneRejectionEnabled = bEnable
|
|
|
|
// If disabling, stop current dialogue if running
|
|
IF bEnable = TRUE
|
|
CPRINTLN(DEBUG_FRIENDS, "Private_EnableZoneRejection(TRUE)")
|
|
ELSE
|
|
CPRINTLN(DEBUG_FRIENDS, "Private_EnableZoneRejection(FALSE)")
|
|
|
|
IF gActivity.mDialogue.eState = FDIALOGUE_REJECTZONE
|
|
OR gActivity.mDialogue.eState = FDIALOGUE_REJECTWAIT
|
|
CPRINTLN(DEBUG_FRIENDS, "Private_EnableZoneRejection(FALSE) - Ending rejection zone dialogue")
|
|
Private_EndDialogueState(gActivity.mDialogue)
|
|
ELSE
|
|
CPRINTLN(DEBUG_FRIENDS, "Private_EnableZoneRejection(FALSE) - No rejection zone dialogue playing")
|
|
ENDIF
|
|
|
|
gActivity.eRecentRejectionZone = SP_MISSION_NONE
|
|
ENDIF
|
|
|
|
ENDIF
|
|
ENDPROC
|
|
|
|
PROC Private_UpdateRejection()
|
|
|
|
// Reject for zone
|
|
IF gActivity.bIsZoneRejectionEnabled
|
|
AND g_eFriendMissionZoneState <> FRIEND_MISSION_ZONE_LAUNCHING
|
|
AND g_eFriendMissionZoneState <> FRIEND_MISSION_ZONE_LAUNCHED
|
|
|
|
IF Private_CanZoneRejectAnyConversableMembers()
|
|
|
|
// Start dialogue
|
|
IF gActivity.mDialogue.eState <> FDIALOGUE_REJECTZONE
|
|
AND gActivity.mDialogue.eState <> FDIALOGUE_REJECTWAIT
|
|
AND gActivity.eRecentRejectionZone <> g_eFriendMissionZoneID
|
|
|
|
Private_SetDialogueState(gActivity.mDialogue, FDIALOGUE_REJECTZONE)
|
|
gActivity.eRecentRejectionZone = g_eFriendMissionZoneID
|
|
|
|
ENDIF
|
|
|
|
// Reject members if possible
|
|
IF NOT IS_PED_IN_ANY_VEHICLE(PLAYER_PED_ID())
|
|
IF NOT IS_MESSAGE_BEING_DISPLAYED()
|
|
IF gActivity.mDialogue.eState <> FDIALOGUE_REJECTZONE
|
|
Private_RejectMembersForMission(TRUE)
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
|
|
ELSE
|
|
|
|
// Abort dialogue
|
|
IF gActivity.mDialogue.eState = FDIALOGUE_REJECTWAIT
|
|
IF g_eFriendMissionZoneState <> FRIEND_MISSION_ZONE_REJECT
|
|
Private_SetDialogueState(gActivity.mDialogue, FDIALOGUE_REJECTCANCEL)
|
|
ENDIF
|
|
ENDIF
|
|
|
|
ENDIF
|
|
ENDIF
|
|
|
|
// Reject trapped friends
|
|
IF gActivity.mFriendA.eState = FRIEND_TRAPPED
|
|
IF Private_CanFriendLeave(gActivity.mFriendA) AND NOT IS_MESSAGE_BEING_DISPLAYED()
|
|
IF IS_PLAYER_PED_PLAYABLE(gActivity.mFriendA.eChar)
|
|
Private_SetFriendRejected(gActivity.mFriendA, /*g_BattleBuddyMission*/ TRUE, FAP_REJECTION_OK)
|
|
ELSE
|
|
Private_SetFriendRejected(gActivity.mFriendA, /*g_BattleBuddyMission*/ TRUE, FAP_REJECTION_CRAZY)
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF gActivity.mFriendB.eState = FRIEND_TRAPPED
|
|
IF Private_CanFriendLeave(gActivity.mFriendB) AND NOT IS_MESSAGE_BEING_DISPLAYED()
|
|
IF IS_PLAYER_PED_PLAYABLE(gActivity.mFriendB.eChar)
|
|
Private_SetFriendRejected(gActivity.mFriendB, /*g_BattleBuddyMission*/ TRUE, FAP_REJECTION_OK)
|
|
ELSE
|
|
Private_SetFriendRejected(gActivity.mFriendB, /*g_BattleBuddyMission*/ TRUE, FAP_REJECTION_CRAZY)
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
|
|
// Reject for squad timeout
|
|
IF Private_CanTimeRejectAnyConversableMembers()
|
|
IF Private_CanPlayAudio(gActivity.mAudio) AND (NOT IS_PED_IN_ANY_VEHICLE(PLAYER_PED_ID()) OR ABSF(GET_ENTITY_SPEED(PLAYER_PED_ID())) < 0.5)
|
|
Private_RejectAllSoldiers(TRUE, FAP_REJECTION_TIMEOUT)
|
|
ENDIF
|
|
ENDIF
|
|
|
|
// Reject for BB flag
|
|
IF Private_CheckBehaviourFlag(BBF_RejectAllBattleBuddies)
|
|
Private_RejectAllSoldiers(TRUE, NO_FRIEND_ACTIVITY_PHRASE)
|
|
ENDIF
|
|
|
|
ENDPROC
|
|
|
|
|
|
//---------------------------------------------------------------------------------------------------
|
|
//-- Add requests
|
|
//---------------------------------------------------------------------------------------------------
|
|
|
|
FUNC BOOL Private_ProcessAddFriends(BOOL bOnlyAllowIfMetAmbiently = FALSE)
|
|
|
|
IF NOT Private_IsPlayerSwitching()
|
|
|
|
// Get pending connection
|
|
enumFriendConnection ePendingConnection
|
|
IF GET_PENDING_CONNECTIONS(ePendingConnection) > 0
|
|
|
|
// Get friend char from pending connection
|
|
enumCharacterList eFriendChar
|
|
IF GET_PENDING_CONNECTION_CHAR(ePendingConnection, eFriendChar)
|
|
|
|
//-- If met friend ambiently, remove any friends waiting to be picked up --
|
|
BOOL bMetAmbiently = FALSE
|
|
IF GET_CONNECTION_MODE(ePendingConnection) = FC_MODE_Ambient
|
|
bMetAmbiently = TRUE
|
|
ENDIF
|
|
|
|
IF bMetAmbiently
|
|
BOOL bWereMembersRemoved = FALSE
|
|
|
|
IF gActivity.mFriendA.eState = FRIEND_PICKUP
|
|
CPRINTLN(DEBUG_FRIENDS, "Private_HandleAddFriendRequests() - Met friend - Removing pickup ", GetLabel_enumCharacterList(gActivity.mFriendA.eChar))
|
|
Private_CleanupFriend(gActivity.mFriendA, MC_Release)
|
|
bWereMembersRemoved = TRUE
|
|
ENDIF
|
|
|
|
IF gActivity.mFriendB.eState = FRIEND_PICKUP
|
|
CPRINTLN(DEBUG_FRIENDS, "Private_HandleAddFriendRequests() - Met friend - Removing pickup ", GetLabel_enumCharacterList(gActivity.mFriendB.eChar))
|
|
Private_CleanupFriend(gActivity.mFriendB, MC_Release)
|
|
bWereMembersRemoved = TRUE
|
|
ENDIF
|
|
|
|
IF bWereMembersRemoved
|
|
Private_SortMembers(TRUE)
|
|
// TODO: Help message
|
|
ENDIF
|
|
|
|
ELIF bOnlyAllowIfMetAmbiently
|
|
// Can only meet ambiently at this stage -> so abort and reset connection
|
|
SET_CONNECTION_STATE(ePendingConnection, FC_STATE_ContactWait)
|
|
RETURN FALSE
|
|
ENDIF
|
|
|
|
//-- Add friend --
|
|
IF gActivity.mFriendA.eState = FRIEND_NULL
|
|
|
|
enumFriendLocation ePickupLocation = FriendLoc_GetBestPickupLoc(gActivity.mPlayer.eChar, eFriendChar, TRUE, gActivity.mFriendB.ePickup)
|
|
|
|
IF ACTIVATE_CONNECTION(ePendingConnection, FC_MODE_Friend)
|
|
IF Private_AddFriend(gActivity.mFriendA, eFriendChar, ePickupLocation, 0, bMetAmbiently)
|
|
|
|
// Cancel old queued text messages
|
|
Private_CancelCommsBetweenFriends(gActivity.mFriendA.eChar, gActivity.mPlayer.eChar)
|
|
Private_CancelCommsBetweenFriends(gActivity.mFriendA.eChar, gActivity.mFriendB.eChar)
|
|
|
|
RETURN TRUE
|
|
ENDIF
|
|
ENDIF
|
|
|
|
ELIF gActivity.mFriendB.eState = FRIEND_NULL
|
|
|
|
enumFriendLocation ePickupLocation = FriendLoc_GetBestPickupLoc(gActivity.mPlayer.eChar, eFriendChar, TRUE, gActivity.mFriendA.ePickup)
|
|
|
|
IF ACTIVATE_CONNECTION(ePendingConnection, FC_MODE_Friend)
|
|
IF Private_AddFriend(gActivity.mFriendB, eFriendChar, ePickupLocation, 1, bMetAmbiently)
|
|
|
|
// Cancel old queued text messages
|
|
Private_CancelCommsBetweenFriends(gActivity.mFriendB.eChar, gActivity.mPlayer.eChar)
|
|
Private_CancelCommsBetweenFriends(gActivity.mFriendB.eChar, gActivity.mFriendA.eChar)
|
|
|
|
RETURN TRUE
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
|
|
ELSE
|
|
SCRIPT_ASSERT("Private_HandleAddFriendRequests() - Cannot get valid character for friend to be added - perhaps current player is not properly involved in the pending connection")
|
|
ENDIF
|
|
|
|
// Failed to create pending connection, reset it
|
|
SET_CONNECTION_STATE(ePendingConnection, FC_STATE_ContactWait)
|
|
RETURN FALSE
|
|
ENDIF
|
|
|
|
ENDIF
|
|
|
|
RETURN FALSE
|
|
|
|
ENDFUNC
|
|
|
|
FUNC BOOL Private_ProcessAddSoldiers()
|
|
|
|
IF NOT Private_IsPlayerSwitching()
|
|
|
|
// Get pending connection
|
|
enumFriendConnection ePendingConnection
|
|
IF GET_PENDING_CONNECTIONS(ePendingConnection) > 0
|
|
|
|
// Get friend char from pending connection
|
|
enumCharacterList eFriendChar = NO_CHARACTER
|
|
IF GET_PENDING_CONNECTION_CHAR(ePendingConnection, eFriendChar)
|
|
AND IS_PLAYER_PED_PLAYABLE(eFriendChar)
|
|
|
|
//-- Add squad member --
|
|
IF gActivity.mSoldiers[eFriendChar].eState = SOLDIER_NULL
|
|
|
|
enumFriendConnectionMode eInitMode = GET_CONNECTION_MODE(ePendingConnection)
|
|
|
|
IF ACTIVATE_CONNECTION(ePendingConnection, FC_MODE_Squad)
|
|
IF Private_AddSoldier(gActivity.mSoldiers[eFriendChar], eInitMode)
|
|
RETURN TRUE
|
|
ENDIF
|
|
ENDIF
|
|
|
|
ENDIF
|
|
|
|
ELSE
|
|
SCRIPT_ASSERT("Private_HandleSquadAddRequests() - Cannot get valid character for squad member to be added - perhaps current player is not properly involved in the pending connection")
|
|
ENDIF
|
|
|
|
// Failed to create pending connection, reset it
|
|
SET_CONNECTION_STATE(ePendingConnection, FC_STATE_ContactWait)
|
|
RETURN FALSE
|
|
ENDIF
|
|
|
|
ENDIF
|
|
|
|
RETURN FALSE
|
|
|
|
ENDFUNC
|
|
|
|
|
|
//---------------------------------------------------------------------------------------------------
|
|
//-- Process members
|
|
//---------------------------------------------------------------------------------------------------
|
|
|
|
PROC Private_ProcessMembers()
|
|
|
|
// Process soldiers
|
|
INT iSlot
|
|
REPEAT MAX_BATTLE_BUDDIES iSlot
|
|
Private_UpdateSoldier(gActivity.mSoldiers[iSlot])
|
|
ENDREPEAT
|
|
|
|
// Process friends
|
|
Private_UpdateFriend(gActivity.mPlayer)
|
|
Private_UpdateFriend(gActivity.mFriendA)
|
|
Private_UpdateFriend(gActivity.mFriendB)
|
|
|
|
HANDLE_BUDDY_HEAD_TRACK_WHILE_ENTERING_VEHICLE()
|
|
|
|
// Clear damage
|
|
IF NOT IS_PED_INJURED(PLAYER_PED_ID())
|
|
CLEAR_ENTITY_LAST_DAMAGE_ENTITY(PLAYER_PED_ID())
|
|
CLEAR_ENTITY_LAST_WEAPON_DAMAGE(PLAYER_PED_ID())
|
|
ENDIF
|
|
IF NOT IS_PED_INJURED(gActivity.mFriendA.hPed)
|
|
CLEAR_ENTITY_LAST_DAMAGE_ENTITY(gActivity.mFriendA.hPed)
|
|
CLEAR_ENTITY_LAST_WEAPON_DAMAGE(gActivity.mFriendA.hPed)
|
|
ENDIF
|
|
IF NOT IS_PED_INJURED(gActivity.mFriendB.hPed)
|
|
CLEAR_ENTITY_LAST_DAMAGE_ENTITY(gActivity.mFriendB.hPed)
|
|
CLEAR_ENTITY_LAST_WEAPON_DAMAGE(gActivity.mFriendB.hPed)
|
|
ENDIF
|
|
|
|
ENDPROC
|
|
|
|
|
|
//---------------------------------------------------------------------------------------------------
|
|
//-- Remove requests
|
|
//---------------------------------------------------------------------------------------------------
|
|
|
|
PROC Private_LogFriendFail(structFriend& friend, enumCharacterList& eFailChar)
|
|
IF friend.eState <> FRIEND_CANCEL
|
|
eFailChar = friend.eChar
|
|
ENDIF
|
|
ENDPROC
|
|
|
|
PROC Private_ProcessRemoveMembers()
|
|
|
|
// Process rejection for zones and time
|
|
Private_UpdateRejection()
|
|
|
|
|
|
BOOL bWereMembersRemoved = FALSE
|
|
|
|
// Remove friends
|
|
IF NOT Private_IsPlayerSwitching()
|
|
|
|
// Remove friend A if requested
|
|
IF gActivity.mFriendA.eState >= FRIEND_CANCEL
|
|
CPRINTLN(DEBUG_FRIENDS, "Private_ProcessRemoveMembers() - Removing friend A: ", GetLabel_enumCharacterList(gActivity.mFriendA.eChar))
|
|
|
|
Private_LogFriendFail(gActivity.mFriendA, gActivity.eLogFailCharA)
|
|
Private_RemoveFailedFriend(gActivity.mFriendA)
|
|
bWereMembersRemoved = TRUE
|
|
ENDIF
|
|
|
|
// Remove friend B if requested
|
|
IF gActivity.mFriendB.eState >= FRIEND_CANCEL
|
|
CPRINTLN(DEBUG_FRIENDS, "Private_ProcessRemoveMembers() - Removing friend B: ", GetLabel_enumCharacterList(gActivity.mFriendB.eChar))
|
|
|
|
Private_LogFriendFail(gActivity.mFriendB, gActivity.eLogFailCharB)
|
|
Private_RemoveFailedFriend(gActivity.mFriendB)
|
|
bWereMembersRemoved = TRUE
|
|
ENDIF
|
|
|
|
// Ensure friend A is never blank
|
|
IF bWereMembersRemoved
|
|
Private_SortMembers(TRUE)
|
|
ENDIF
|
|
|
|
ENDIF
|
|
|
|
// Remove soldiers
|
|
// enumCharacterList eChar
|
|
// REPEAT MAX_BATTLE_BUDDIES eChar
|
|
//
|
|
// IF gActivity.mSoldiers[eChar].eState >= SOLDIER_FAIL_INJURED
|
|
// CPRINTLN(DEBUG_FRIENDS, "Private_ProcessRemoveMembers() - Removing soldier: ", GetLabel_enumCharacterList(eChar))
|
|
//
|
|
// Private_HandleSoldierFail(gActivity.mSoldiers[eChar], eCleanupStyle)
|
|
// Private_CleanupSoldier(gActivity.mSoldiers[eChar], eCleanupStyle)
|
|
// ENDIF
|
|
//
|
|
// ENDREPEAT
|
|
|
|
ENDPROC
|
|
|
|
|
|
//---------------------------------------------------------------------------------------------------
|
|
//-- Help
|
|
//---------------------------------------------------------------------------------------------------
|
|
|
|
FUNC BOOL Private_DisplayQueuedHelp(STRING sLabel)
|
|
|
|
// IF NOT IS_CURRENTLY_ON_MISSION_OF_TYPE(MISSION_TYPE_STORY_PREP)
|
|
// AND NOT IS_CURRENTLY_ON_MISSION_OF_TYPE(MISSION_TYPE_FRIEND_SQUAD)
|
|
//
|
|
// SWITCH GET_FLOW_HELP_MESSAGE_STATUS(sLabel)
|
|
// CASE FHS_EXPIRED
|
|
// CPRINTLN(DEBUG_FRIENDS, "Private_DisplayQueuedHelp() - \"", sLabel, "\" trying to queue")
|
|
// ADD_HELP_TO_FLOW_QUEUE(sLabel, FHP_HIGH, 0, DEFAULT_HELP_TEXT_TIME)
|
|
// BREAK
|
|
//
|
|
//// CASE FHS_QUEUED
|
|
//// CPRINTLN(DEBUG_FRIENDS, "Private_DisplayQueuedHelp() - \"", sLabel, "\" is queued")
|
|
//// BREAK
|
|
//
|
|
// CASE FHS_DISPLAYED
|
|
// CPRINTLN(DEBUG_FRIENDS, "Private_DisplayQueuedHelp() - \"", sLabel, "\" was displayed by queue")
|
|
// RETURN TRUE
|
|
// BREAK
|
|
// ENDSWITCH
|
|
//
|
|
// ELSE
|
|
|
|
IF NOT IS_HELP_MESSAGE_ON_SCREEN()
|
|
CPRINTLN(DEBUG_FRIENDS, "Private_DisplayQueuedHelp() - \"", sLabel, "\" was displayed without queueing (as on mission)")
|
|
PRINT_HELP(sLabel)
|
|
RETURN TRUE
|
|
ENDIF
|
|
|
|
// ENDIF
|
|
|
|
RETURN FALSE
|
|
|
|
ENDFUNC
|
|
|
|
PROC Private_ProcessHelp()
|
|
|
|
// Help text: battle buddy arriving
|
|
IF g_savedGlobals.sFriendsData.g_bHelpDoneBBuddyArrival = FALSE
|
|
IF gActivity.mSoldiers[CHAR_MICHAEL].eState = SOLDIER_ARRIVE_IN_CAR
|
|
OR gActivity.mSoldiers[CHAR_MICHAEL].eState = SOLDIER_FOLLOW
|
|
IF Private_DisplayQueuedHelp("FR_H_BUDM_A")
|
|
g_savedGlobals.sFriendsData.g_bHelpDoneBBuddyArrival = TRUE
|
|
EXIT
|
|
ENDIF
|
|
|
|
ELIF gActivity.mSoldiers[CHAR_FRANKLIN].eState = SOLDIER_ARRIVE_IN_CAR
|
|
OR gActivity.mSoldiers[CHAR_FRANKLIN].eState = SOLDIER_FOLLOW
|
|
IF Private_DisplayQueuedHelp("FR_H_BUDF_A")
|
|
g_savedGlobals.sFriendsData.g_bHelpDoneBBuddyArrival = TRUE
|
|
EXIT
|
|
ENDIF
|
|
|
|
ELIF gActivity.mSoldiers[CHAR_TREVOR].eState = SOLDIER_ARRIVE_IN_CAR
|
|
OR gActivity.mSoldiers[CHAR_TREVOR].eState = SOLDIER_FOLLOW
|
|
IF Private_DisplayQueuedHelp("FR_H_BUDT_A")
|
|
g_savedGlobals.sFriendsData.g_bHelpDoneBBuddyArrival = TRUE
|
|
EXIT
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
|
|
// Help text: player can switch to battle buddy
|
|
IF g_savedGlobals.sFriendsData.g_bHelpDoneBBuddySwitch = FALSE
|
|
IF gActivity.bIsAnySwitchAvailable
|
|
IF Private_DisplayQueuedHelp("FR_H_BUD_SW")
|
|
g_savedGlobals.sFriendsData.g_bHelpDoneBBuddySwitch = TRUE
|
|
EXIT
|
|
ENDIF
|
|
ENDIF
|
|
|
|
ELIF IS_HELP_MESSAGE_BEING_DISPLAYED()
|
|
IF IS_PLAYER_SWITCH_IN_PROGRESS()
|
|
IF IS_THIS_HELP_MESSAGE_BEING_DISPLAYED("FR_H_BUD_SW")
|
|
CLEAR_HELP()
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
|
|
ENDPROC
|
|
|
|
//---------------------------------------------------------------------------------------------------
|
|
//-- Global handles
|
|
//---------------------------------------------------------------------------------------------------
|
|
|
|
PROC Private_UpdateGlobalFriendHandles()
|
|
|
|
// Keep global ped IDs in sync
|
|
IF FRIEND_A_PED_ID() <> gActivity.mFriendA.hPed
|
|
CPRINTLN(DEBUG_FRIENDS, "Update FRIEND_A_PED_ID to ", GetLabel_enumCharacterList(gActivity.mFriendA.eChar), ", hPed = ", NATIVE_TO_INT(gActivity.mFriendA.hPed))
|
|
PRIVATE_SET_FRIEND_A_PED_ID(gActivity.mFriendA.hPed)
|
|
ENDIF
|
|
|
|
IF FRIEND_B_PED_ID() <> gActivity.mFriendB.hPed
|
|
CPRINTLN(DEBUG_FRIENDS, "Update FRIEND_B_PED_ID to ", GetLabel_enumCharacterList(gActivity.mFriendB.eChar), ", hPed = ", NATIVE_TO_INT(gActivity.mFriendB.hPed))
|
|
PRIVATE_SET_FRIEND_B_PED_ID(gActivity.mFriendB.hPed)
|
|
ENDIF
|
|
|
|
ENDPROC
|
|
|
|
|
|
|
|
|
|
|
|
//---------------------------------------------------------------------------------------------------
|
|
//-- Transfer
|
|
//---------------------------------------------------------------------------------------------------
|
|
|
|
/// This is called when player has friends and either (a) squad mission starts, or (b) player calls squad buddy
|
|
PROC Private_TransferMembersToSquad()
|
|
|
|
// CPRINTLN(DEBUG_FRIENDS, "\n")
|
|
// CPRINTLN(DEBUG_FRIENDS, "Private_TransferMembersToSquad() - ** TRANSFER STARTED **")
|
|
//
|
|
// enumFriendConnection eConnection
|
|
// enumCharacterList ePlayerChar = gActivity.mPlayer.eChar
|
|
// enumCharacterList eFriendAChar = gActivity.mFriendA.eChar
|
|
// enumCharacterList eFriendBChar = gActivity.mFriendB.eChar
|
|
//
|
|
// gActivity.eLogFailCharA = NO_CHARACTER
|
|
// gActivity.eLogFailCharB = NO_CHARACTER
|
|
//
|
|
//
|
|
// //-- Squad mission must be set to transfer members
|
|
// IF g_BattleBuddyMission = SP_MISSION_NONE
|
|
// SCRIPT_ASSERT("Private_TransferMembersToSquad() - Squad mission is not set")
|
|
// ENDIF
|
|
//
|
|
//
|
|
// //-- Setup dialogue states for squad mode
|
|
// Private_SetDialogueState(gActivity.mDialogue, FDIALOGUE_SQUAD)
|
|
// Private_SetDialogueIdleState(gActivity.mDialogue, FDIALOGUE_SQUAD_IDLE)
|
|
//
|
|
//
|
|
// //-- Transfer connections
|
|
//
|
|
// // Backup connections, as Init ones will get cleared by cleanups
|
|
// enumFriendConnectionState backupStates[MAX_FRIEND_CONNECTIONS]
|
|
// enumFriendConnectionMode backupModes[MAX_FRIEND_CONNECTIONS]
|
|
// REPEAT MAX_FRIEND_CONNECTIONS eConnection
|
|
// backupStates[eConnection] = GET_CONNECTION_STATE(eConnection)
|
|
// backupModes[eConnection] = GET_CONNECTION_MODE(eConnection)
|
|
// ENDREPEAT
|
|
//
|
|
// // Transfer player
|
|
// Private_CleanupFriend(gActivity.mPlayer, MC_LeavePedIntact)
|
|
// Private_AddSoldier(gActivity.mSoldiers[ePlayerChar])
|
|
// Private_SetSoldierGlobalFlag(gActivity.mSoldiers[ePlayerChar], g_bitfieldBattleBuddyAvailable)
|
|
//
|
|
// // Transfer friend A
|
|
// IF NOT Private_IsFriendValid(gActivity.mFriendA)
|
|
// OR NOT Private_CanFriendConverse(gActivity.mFriendA)
|
|
//
|
|
// Private_SetFriendRejected(gActivity.mFriendA, g_BattleBuddyMission, FALSE, NO_FRIEND_ACTIVITY_PHRASE)
|
|
// Private_CleanupFriend(gActivity.mFriendA, MC_Release)
|
|
//
|
|
// ELIF NOT IS_BIT_SET(g_BattleBuddyAllowedChars, ENUM_TO_INT(GET_FRIEND_FROM_CHAR(gActivity.mFriendA.eChar)))
|
|
//
|
|
// IF NOT Private_CanFriendLeave(gActivity.mFriendA)
|
|
// Private_SetFriendTrapped(gActivity.mFriendA)
|
|
// ELSE
|
|
// Private_SetFriendRejected(gActivity.mFriendA, g_BattleBuddyMission, FALSE, FAP_REJECTION_OK)
|
|
// Private_CleanupFriend(gActivity.mFriendA, MC_Release)
|
|
// ENDIF
|
|
//
|
|
// ELSE
|
|
// // Convert to soldier
|
|
// Private_CleanupFriend(gActivity.mFriendA, MC_LeavePedIntact)
|
|
//
|
|
// IF GET_CONNECTION(ePlayerChar, eFriendAChar, eConnection)
|
|
// IF ACTIVATE_CONNECTION(eConnection, FC_MODE_Squad)
|
|
// Private_AddSoldier(gActivity.mSoldiers[eFriendAChar])
|
|
// Private_SetSoldierGlobalFlag(gActivity.mSoldiers[eFriendAChar], g_bitfieldBattleBuddyAvailable)
|
|
// ENDIF
|
|
// ENDIF
|
|
// ENDIF
|
|
//
|
|
// // Transfer friend B
|
|
// IF NOT Private_IsFriendValid(gActivity.mFriendB)
|
|
// OR NOT Private_CanFriendConverse(gActivity.mFriendB)
|
|
//
|
|
// Private_SetFriendRejected(gActivity.mFriendB, g_BattleBuddyMission, FALSE, NO_FRIEND_ACTIVITY_PHRASE)
|
|
// Private_CleanupFriend(gActivity.mFriendB, MC_Release)
|
|
//
|
|
// ELIF NOT IS_BIT_SET(g_BattleBuddyAllowedChars, ENUM_TO_INT(GET_FRIEND_FROM_CHAR(gActivity.mFriendB.eChar)))
|
|
//
|
|
// IF NOT Private_CanFriendLeave(gActivity.mFriendB)
|
|
// Private_SetFriendTrapped(gActivity.mFriendB)
|
|
// ELSE
|
|
// Private_SetFriendRejected(gActivity.mFriendB, g_BattleBuddyMission, FALSE, FAP_REJECTION_OK)
|
|
// Private_CleanupFriend(gActivity.mFriendB, MC_Release)
|
|
// ENDIF
|
|
//
|
|
// ELSE
|
|
// // Convert to soldier
|
|
// Private_CleanupFriend(gActivity.mFriendB, MC_LeavePedIntact)
|
|
//
|
|
// IF GET_CONNECTION(ePlayerChar, eFriendBChar, eConnection)
|
|
// IF ACTIVATE_CONNECTION(eConnection, FC_MODE_Squad)
|
|
// Private_AddSoldier(gActivity.mSoldiers[eFriendBChar])
|
|
// Private_SetSoldierGlobalFlag(gActivity.mSoldiers[eFriendBChar], g_bitfieldBattleBuddyAvailable)
|
|
// ENDIF
|
|
// ENDIF
|
|
// ENDIF
|
|
//
|
|
// // Restore any init connections
|
|
// REPEAT MAX_FRIEND_CONNECTIONS eConnection
|
|
// IF backupStates[eConnection] = FC_STATE_Init
|
|
// SET_CONNECTION_STATE(eConnection, backupStates[eConnection])
|
|
// SET_CONNECTION_MODE(eConnection, backupModes[eConnection])
|
|
// ENDIF
|
|
// ENDREPEAT
|
|
//
|
|
// OVERWRITE_BATTLEBUDDY_SNAPSHOT()
|
|
// CPRINTLN(DEBUG_FRIENDS, "Snapshot: g_bitfieldBattleBuddyAvailable = ", g_bitfieldBattleBuddyAvailable)
|
|
//
|
|
// IF g_eFriendMissionZoneState <> FRIEND_MISSION_ZONE_OFF
|
|
// IF g_eFriendMissionZoneID = SP_MISSION_FBI_4_PREP_4
|
|
// OR g_eFriendMissionZoneID = SP_MISSION_FBI_4_PREP_5
|
|
// CPRINTLN(DEBUG_FRIENDS, "Friend activity will resume when player passes squad mission...")
|
|
// gActivity.bResumeFriendsAfterSquad = TRUE
|
|
// ENDIF
|
|
// ENDIF
|
|
//
|
|
// CPRINTLN(DEBUG_FRIENDS, "Private_TransferMembersToSquad() - ** TRANSFER DONE **\n")
|
|
|
|
ENDPROC
|
|
|
|
|
|
FUNC BOOL Private_TransferMembersToFriends()
|
|
|
|
// CPRINTLN(DEBUG_FRIENDS, "\n")
|
|
// CPRINTLN(DEBUG_FRIENDS, "Private_TransferMembersToFriends() - ** TRANSFER STARTED **")
|
|
//
|
|
// // Clear any friends that are remaining from before the squad mode
|
|
// IF Private_IsFriendValid(gActivity.mFriendA)
|
|
// Private_SetFriendRejected(gActivity.mFriendA, g_BattleBuddyMission, FALSE, NO_FRIEND_ACTIVITY_PHRASE)
|
|
// ENDIF
|
|
// IF Private_IsFriendValid(gActivity.mFriendB)
|
|
// Private_SetFriendRejected(gActivity.mFriendB, g_BattleBuddyMission, FALSE, NO_FRIEND_ACTIVITY_PHRASE)
|
|
// ENDIF
|
|
//
|
|
// Private_CleanupFriend(gActivity.mPlayer)
|
|
// Private_CleanupFriend(gActivity.mFriendA)
|
|
// Private_CleanupFriend(gActivity.mFriendB)
|
|
//
|
|
// //g_bitfieldBattleBuddyAvailable = 0 // Does this need doing?
|
|
//
|
|
// DEACTIVATE_ALL_CONNECTIONS()
|
|
//
|
|
// enumFriendConnection eConnection
|
|
// enumCharacterList ePlayerChar = GET_CURRENT_PLAYER_PED_ENUM()
|
|
//
|
|
// // Transfer soldiers to friends
|
|
// BOOL bAddedFriendA = FALSE
|
|
//
|
|
// IF NOT IS_PED_INJURED(gActivity.mSoldiers[ePlayerChar].hPed)
|
|
//
|
|
// // Transfer player
|
|
// Private_CleanupSoldier(gActivity.mSoldiers[ePlayerChar], MC_LeavePedIntact)
|
|
// Private_AddFriend(gActivity.mPlayer, ePlayerChar, NO_FRIEND_LOCATION, 0, FALSE)
|
|
//
|
|
// // Transfer other buddies
|
|
// enumCharacterList eChar
|
|
// REPEAT MAX_BATTLE_BUDDIES eChar
|
|
// IF eChar <> ePlayerChar
|
|
// IF NOT IS_PED_INJURED(gActivity.mSoldiers[eChar].hPed)
|
|
// IF (gActivity.mSoldiers[eChar].eState = SOLDIER_GROUP
|
|
// OR gActivity.mSoldiers[eChar].eState = SOLDIER_APPROACH
|
|
// OR gActivity.mSoldiers[eChar].eState = SOLDIER_OVERRIDDEN)
|
|
// AND Private_IsSoldierGlobalFlagSet(gActivity.mSoldiers[eChar], g_bitfieldBattleBuddyAvailable)
|
|
//
|
|
// Private_CleanupSoldier(gActivity.mSoldiers[eChar], MC_LeavePedIntact)
|
|
//
|
|
// IF GET_CONNECTION(ePlayerChar, eChar, eConnection)
|
|
// IF ACTIVATE_CONNECTION(eConnection, FC_MODE_Friend)
|
|
// IF bAddedFriendA = FALSE
|
|
// Private_AddFriend(gActivity.mFriendA, eChar, NO_FRIEND_LOCATION, 0, TRUE)
|
|
// bAddedFriendA = TRUE
|
|
// ELSE
|
|
// Private_AddFriend(gActivity.mFriendB, eChar, NO_FRIEND_LOCATION, 0, TRUE)
|
|
// ENDIF
|
|
// ENDIF
|
|
// ENDIF
|
|
//
|
|
// ELSE
|
|
// Private_CleanupSoldier(gActivity.mSoldiers[eChar], MC_Release)
|
|
// ENDIF
|
|
// ENDIF
|
|
// ENDIF
|
|
// ENDREPEAT
|
|
//
|
|
// ENDIF
|
|
//
|
|
// CPRINTLN(DEBUG_FRIENDS, "Private_TransferMembersToFriends() - ** TRANSFER DONE **\n")
|
|
//
|
|
RETURN ARE_ANY_FRIEND_CONNECTIONS_PENDING_OR_ACTIVE()
|
|
|
|
ENDFUNC
|
|
|
|
|
|
//---------------------------------------------------------------------------------------------------
|
|
//-- Friend fails
|
|
//---------------------------------------------------------------------------------------------------
|
|
|
|
FUNC BOOL Private_AreFriendsFailed()
|
|
|
|
// If all members have failed, fail mission
|
|
IF gActivity.mFriendA.eState = FRIEND_NULL AND gActivity.mFriendB.eState = FRIEND_NULL
|
|
|
|
IF Private_GetDialogueState(gActivity.mDialogue) <> FDIALOGUE_REJECTED
|
|
|
|
IF gActivity.iFailQueueCount = 0
|
|
|
|
RETURN TRUE
|
|
|
|
ENDIF
|
|
|
|
ENDIF
|
|
|
|
ENDIF
|
|
|
|
RETURN FALSE
|
|
|
|
ENDFUNC
|
|
|
|
|
|
FUNC BOOL Private_AreAnyMembersValid()
|
|
|
|
// Are any friends are valid...
|
|
IF (gActivity.mFriendA.eState <> FRIEND_NULL AND gActivity.mFriendA.eState < FRIEND_CANCEL)
|
|
OR (gActivity.mFriendB.eState <> FRIEND_NULL AND gActivity.mFriendB.eState < FRIEND_CANCEL)
|
|
RETURN TRUE
|
|
ENDIF
|
|
|
|
// Are any soldiers valid...
|
|
enumCharacterList eLoopChar
|
|
REPEAT MAX_BATTLE_BUDDIES eLoopChar
|
|
IF gActivity.mSoldiers[eLoopChar].eState <> SOLDIER_NULL
|
|
AND gActivity.mSoldiers[eLoopChar].eState <> SOLDIER_PLAYER
|
|
AND gActivity.mSoldiers[eLoopChar].eState < SOLDIER_FAIL_INJURED
|
|
RETURN TRUE
|
|
ENDIF
|
|
ENDREPEAT
|
|
|
|
RETURN FALSE
|
|
|
|
ENDFUNC
|
|
|
|
FUNC BOOL Private_AreAllMembersRemoved()
|
|
|
|
// If any friends are valid, don't fail
|
|
IF gActivity.mFriendA.eState <> FRIEND_NULL
|
|
OR gActivity.mFriendB.eState <> FRIEND_NULL
|
|
RETURN FALSE
|
|
ENDIF
|
|
|
|
// If any soldiers are valid don't fail
|
|
enumCharacterList eLoopChar
|
|
REPEAT MAX_BATTLE_BUDDIES eLoopChar
|
|
IF gActivity.mSoldiers[eLoopChar].eState <> SOLDIER_NULL
|
|
AND gActivity.mSoldiers[eLoopChar].eState <> SOLDIER_PLAYER
|
|
RETURN FALSE
|
|
ENDIF
|
|
ENDREPEAT
|
|
|
|
// If doing rejection dialogue, or need to print fail reason don't fail
|
|
IF Private_GetDialogueState(gActivity.mDialogue) = FDIALOGUE_REJECTED
|
|
OR gActivity.iFailQueueCount > 0
|
|
RETURN FALSE
|
|
ENDIF
|
|
|
|
RETURN TRUE
|
|
|
|
ENDFUNC
|
|
|
|
|
|
PROC Private_ProcessSystem(BOOL bProcessHelp = FALSE)
|
|
|
|
Private_ProcessDialogue(gActivity.mDialogue, gActivity.mAudio)
|
|
Private_UpdateGlobalFriendHandles()
|
|
|
|
Private_ProcessFailReasonQueue()
|
|
Private_ProcessTextMessageQueue()
|
|
|
|
IF bProcessHelp
|
|
Private_ProcessHelp()
|
|
ENDIF
|
|
|
|
ENDPROC
|