Backups/GTASource
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
c971d568a112e5bec2e45ab389375b07c6914a6e
GTASource/game/audio/speechmanager.cpp
expvintl 419f2e4752 init
2025-02-23 17:40:52 +08:00

3920 lines
127 KiB
C++
Raw Blame History

//
// audio/speechmanager.cpp
//
// Copyright (C) 1999-2006 Rockstar Games. All Rights Reserved.
//
#include "northaudioengine.h"
#include "speechmanager.h"
#include "scriptaudioentity.h"
#include "control/replay/audio/SpeechAudioPacket.h"
#include "audiohardware/waveslot.h"
#include "audioengine/engine.h"
#include "audioengine/engineutil.h"
#include "speechaudioentity.h"
#include "virtcxtresolves.h"
#include "debug/debug.h"
#include "vehicles/vehicle.h"
#include "peds/ped.h"
#include "streaming/streamingengine.h"
#include "gameobjects.h"
#include "profile/profiler.h"
#include "debugaudio.h"
AUDIO_PEDS_OPTIMISATIONS()
audCurve g_VehicleOpennessToSpeechFilterCurve;
audCurve g_VehicleOpennessToSpeechVolumeCurve;
audCurve g_DistanceSqToPriorityScalarCurve;
#if __BANK
bool g_StressTestSpeech = false;
audSound *g_StressTestSpeechSound = NULL;
u32 g_StressTestSpeechVariation = 0;
char g_StressTestSpeechVoiceName[128] = {0};
char g_StressTestSpeechContext[128] = {0};
u32 g_StressTestMaxStartOffset = 0;
bool g_TestAnimalBankPriority = false;
bool g_DrawSpeechSlots = false;
bool g_DrawSpecificPainInfo = false;
bool g_DrawPainPlayedTotals = false;
bool g_DisplayAnimalBanks = false;
bool g_ForceAnimalBankUpdate = false;
bool g_OverrideSpecificPainLoaded = false;
u8 g_OverrideSpecificPainLevel = 0;
bool g_OverrideSpecificPainIsMale = false;
bool g_ForceSpecificPainBankSwap = false;
bool g_DebugTennisLoad = false;
bool g_DebugTennisUnload = false;
f32 g_LastRecordedPainValue;
atRangeArray<u32, AUD_PAIN_ID_NUM_TOTAL> g_DebugNumTimesPainTypePlayed;
extern bool g_UseTestPainBanks;
bool g_HavePreparedPainBanksForTesting = false;
bool g_PrintVoiceRefInfo = false;
#endif
u8 g_OverridePainVsAimScalar = 10;
audSpeechManager g_SpeechManager;
bool g_PrintUnknownContexts = false;
u32 g_NumPlayingAmbientSpeech = 0;
u32 g_StreamingIsBusy = 0;
u32 g_TimeBeforeWallaCanPlay = 1500;
u32 g_MaxWallaPlays = 15;
extern u32 g_WallaReuseTime;
//bool g_ChurnSpeech = true;
u32 g_LastTimeSpeechWasPlaying = 0;
u32 g_TimeBeforeChurningSpeech = 5000;
u32 g_LastTimeStreamingWasBusy = 0;
u32 g_StreamingBusyTime = 60;
u32 g_TimeBetweenSpecificPainBankSelection = 10000;
u32 g_TimeBetweenSpecificPainBankLoadAndSelection = 5000;
bool g_ActivatePainSpecificBankSwapping = true;
u32 g_MinTimeBetweenSameVariationOfPhoneCall = 180000;
extern bool g_StreamingSchmeaming;
extern audCategory *g_SpeechNormalCategory;
extern const u32 g_NoVoiceHash;
extern bool g_bSpeechAsserts;
extern const char* g_PainContexts[AUD_PAIN_ID_NUM_TOTAL];
extern const char* g_PlayerPainContexts[AUD_PAIN_ID_NUM_TOTAL];
extern u32 g_PainContextHashs[AUD_PAIN_ID_NUM_TOTAL];
extern u32 g_PainContextPHashs[AUD_PAIN_ID_NUM_TOTAL];
extern u32 g_PlayerPainContextHashs[AUD_PAIN_ID_NUM_TOTAL];
extern u32 g_PlayerPainContextPHashs[AUD_PAIN_ID_NUM_TOTAL];
f32 g_SpeechRolloffWhenInACar = 2.0f;
const u32 g_AnythingDullPHash = ATPARTIALSTRINGHASH("ANYTHING_DULL", 0x839929D9);
#define AUD_NUM_MICHAEL_PAIN_BANKS (4)
#define AUD_NUM_FRANKLIN_PAIN_BANKS (4)
#define AUD_NUM_TREVOR_PAIN_BANKS (4)
//#define AUD_NUM_MALE_PAIN_BANKS (3)
#define AUD_NUM_MALE_WEAK_PAIN_BANKS (4)
#define AUD_NUM_MALE_NORMAL_PAIN_BANKS (6)
#define AUD_NUM_MALE_TOUGH_PAIN_BANKS (5)
#define AUD_NUM_MALE_MIXED_PAIN_BANKS (9)
#define AUD_NUM_FEMALE_WEAK_PAIN_BANKS (0)
#define AUD_NUM_FEMALE_NORMAL_PAIN_BANKS (12)
#define AUD_NUM_FEMALE_MIXED_PAIN_BANKS (2)
const char* g_PainSlotType[4];
atRangeArray<const char*, AUD_PAIN_NUM_LEVELS> g_PainLevelString;
char g_PlayerPainRootBankName[32];
const char* g_BreathSlotType[AUD_BREATHING_TYPE_TOTAL];
u8 g_NumBreathingBanks[AUD_BREATHING_TYPE_TOTAL];
const char* g_BreathContexts[AUD_NUM_PLAYER_VFX_TYPES];
#define NUM_MINI_DRIVING_CONTEXTS 15
#define NUM_MINI_NON_DRIVING_CONTEXTS 9
#define NUM_GANG_CONTEXTS 52
#define NUM_LOUD_CONTEXTS 16 //25
#define NUM_TIME_LIMITED_ANIMAL_FAR_CONTEXTS 1
u32 g_MiniDrivingContextHashes[NUM_MINI_DRIVING_CONTEXTS];
u32 g_MiniNonDrivingContextHashes[NUM_MINI_NON_DRIVING_CONTEXTS];
u32 g_GangContextHashes[NUM_GANG_CONTEXTS];
u32 g_LoudContextHashes[NUM_LOUD_CONTEXTS];
const char* g_MiniDrivingContexts[NUM_MINI_DRIVING_CONTEXTS] = {
"RUN_FROM_FIGHT",
"FIGHT",
"DODGE",
"BUMP",
"GUN_RUN",
"GUN_COOL",
"TRAPPED",
"VEHICLE_ATTACKED",
"SURPRISED",
"CRASH_CAR",
"BLOCKED_VEHICLE",
"BLOCKED_PED",
"BLOCKED_GENERIC",
"JACKED_IN_CAR",
"JACK_CAR_BACK"
};
const char* g_MiniNonDrivingContexts[NUM_MINI_NON_DRIVING_CONTEXTS] = {
"RUN_FROM_FIGHT",
"FIGHT",
"DODGE",
"BUMP",
"GUN_RUN",
"GUN_COOL",
"TRAPPED",
"VEHICLE_ATTACKED",
"SURPRISED"
};
const char* g_GangContexts[NUM_GANG_CONTEXTS] = {
"ABUSE_DRIVER",
"BEEN_SHOT_SUBMIT",
"BLOCKED_PED",
"BLOCKED_VEHICLE",
"BUMP",
"CONV_GANG_RESP",
"CONV_GANG_STATE",
"CONV_SMOKE_RESP",
"CONV_SMOKE_STATE",
"COVER_ME",
"CRASH_BIKE",
"CRASH_CAR",
"CRASH_GENERIC",
"DODGE",
"DUCK",
"FIGHT",
"FOLLOWED_NO",
"GANG_ASK_PLAYER_LEAVE",
"GANG_ATTACK_WARNING",
"GANG_BUMP",
"GANG_CHASE",
"GANG_DODGE_WARNING",
"GANG_FIGHT_CHEER",
"GANG_INTERVENE",
"GANG_WATCH_THIS_GUY",
"GANG_WATCH_THIS_GUY_RESP",
"GANG_WATCH_THIS_GUY_SOLO",
"GANG_WEAPON_WARNING",
"GANG_YOU_DROP_WEAPON",
"GENERIC_BYE",
"GENERIC_FUCK_OFF",
"GENERIC_HI",
"GENERIC_NO",
"GENERIC_YES",
"INTIMIDATE_RESP",
"JACKED_IN_CAR",
"JACKED_ON_STREET",
"JACKING_CAR_BACK",
"JACKING_GENERIC_BACK",
"MOVE_IN",
"OVER_HANDLEBARS",
"PLAYER_OVER_THERE",
"PLAYER_UP_THERE",
"SHIT",
"SHOT_IN_LEG",
"SHUT_UP_HORN",
"SURROUNDED",
"TAKE_COVER",
"TARGET",
"THANKS",
"TRAPPED",
"VEHICLE_ATTACKED"
};
const char* g_LoudContexts[] = {
"GET_DOWN",
"SURROUNDED" ,
"MOVE_IN",
"COVER_ME",
"TARGET",
"DUCK",
"FALL_BACK",
"TAKE_COVER",
"ON_FIRE",
"PANIC",
"MEGAPHONE_FOOT_PURSUIT",
"MEGAPHONE_PED_CLEAR_STREET",
"PULL_OVER",
"PULL_OVER_WARNING",
"COP_HELI_MEGAPHONE",
"COP_HELI_MEGAPHONE_WARNING"
};
u32 g_TimeLimitedAnimalFarContextsPHashes[NUM_TIME_LIMITED_ANIMAL_FAR_CONTEXTS];
u32 g_TimeLimitedAnimalFarContextsLastPlayTime[NUM_TIME_LIMITED_ANIMAL_FAR_CONTEXTS];
u32 g_TimeLimitedAnimalFarContextsMinTimeBetween[NUM_TIME_LIMITED_ANIMAL_FAR_CONTEXTS] = {
0
};
const char* g_TimeLimitedAnimalFarContexts[NUM_TIME_LIMITED_ANIMAL_FAR_CONTEXTS] = {
""
};
enum
{
AUD_MINI_VOICE_TYPE_NORMAL,
AUD_MINI_VOICE_TYPE_DRIVING,
AUD_MINI_VOICE_TYPE_HOOKER,
AUD_MINI_VOICE_TYPE_GANG
};
struct tVoice
{
u32 VoiceName;
u32 ReferenceCount;
u32 RunningTab;
};
const char* g_AnimalBankNames[ANIMALTYPE_MAX] = {
"NONE",
"BOAR",
"CHICKEN",
"DOG",
"DOG_ROTTWEILER",
"HORSE",
"COW",
"COYOTE",
"DEER",
"EAGLE",
"FISH",
"HEN",
"MONKEY",
"MOUNTAIN_LION",
"PIGEON",
"RAT",
"SEAGULL",
"CROW",
"PIG",
"Chickenhawk",
"Cormorant",
"Rhesus",
"Retriever",
"Chimp",
"Husky",
"Shepherd",
"Cat",
"Whale",
"Dolphin",
"SmallDog",
"Hammerhead",
"Stingray",
"Rabbit",
"KillerWhale"
};
static SpeechContext* g_DefaultSpeechContext = NULL;
PF_PAGE(SpeechSoundsPage, "SpeechSounds");
PF_GROUP(SpeechSoundsGroup);
PF_LINK(SpeechSoundsPage, SpeechSoundsGroup);
PF_VALUE_INT(PlayingAmbientSpeech, SpeechSoundsGroup);
PF_VALUE_INT(StreamingIsBusy, SpeechSoundsGroup);
void audSpeechManager::Init()
{
audEntity::Init();
// Set up our slots
for (s32 i=0; i<g_MaxAmbientSpeechSlots; i++)
{
m_AmbientSpeechSlots[i].PlayState = AUD_SPEECH_SLOT_VACANT;
m_AmbientSpeechSlots[i].SpeechAudioEntity = NULL;
char slotName[32];
sprintf(slotName, "SPEECH_%d", i);
m_AmbientSpeechSlots[i].WaveSlot = audWaveSlot::FindWaveSlot(slotName);
if(!m_AmbientSpeechSlots[i].WaveSlot)
{
naWarningf("Failed to find ambient speech slot %s", slotName);
}
}
m_AmbientSpeechSlotToNextSearchFrom = 0;
for (s32 i=0; i<g_MaxScriptedSpeechSlots; i++)
{
m_ScriptedSpeechSlots[i].PlayState = AUD_SPEECH_SLOT_VACANT;
m_ScriptedSpeechSlots[i].SpeechAudioEntity = NULL;
char slotName[32];
sprintf(slotName, "SCRIPT_SPEECH_%d", i);
m_ScriptedSpeechSlots[i].WaveSlot = audWaveSlot::FindWaveSlot(slotName);
if(!m_ScriptedSpeechSlots[i].WaveSlot)
{
naWarningf("Failed to find script speech slot %s", slotName);
}
}
/*m_PlayerSpeechSlot.PlayState = AUD_SPEECH_SLOT_VACANT;
m_PlayerSpeechSlot.SpeechAudioEntity = NULL;
m_PlayerSpeechSlot.WaveSlot = audWaveSlot::FindWaveSlot("PLAYER_SPEECH");
if(!m_PlayerSpeechSlot.WaveSlot)
{
naWarningf("Failed to find player_speech slot");
}*/
SetPlayerPainRootBankName("PAIN_MICHAEL");
g_PainSlotType[0] = g_PlayerPainRootBankName;
g_PainSlotType[1] = "PAIN_MALE";
g_PainSlotType[2] = "PAIN_FEMALE";
g_PainSlotType[3] = "BREATHING_TEST";
g_PainLevelString[0] = "WEAK";
g_PainLevelString[1] = "NORMAL";
g_PainLevelString[2] = "TOUGH";
g_PainLevelString[3] = "MIXED";
for (u32 painType=0; painType<AUD_PAIN_VOICE_NUM_TYPES; painType++)
{
m_PainSlots[painType].BankId = 0;
m_PainSlots[painType].SlotState = AUD_PAIN_SLOT_USED_UP;
char slotName[32];
sprintf(slotName, "PAIN_%d", painType);
m_PainSlots[painType].WaveSlot = audWaveSlot::FindWaveSlot(slotName);
if(!m_PainSlots[painType].WaveSlot)
{
naWarningf("Failed to find pain slot %s", slotName);
}
m_CurrentPainBank[painType] = 1;
m_NextTimeToLoadPain[painType] = 0;
if(painType != AUD_PAIN_VOICE_TYPE_BREATHING)
{
for (u32 i=0; i<AUD_PAIN_ID_NUM_BANK_LOADED; i++)
{
m_NextVariationForPain[painType][i] = 1;
}
}
else
{
for (u32 i=0; i<AUD_NUM_PLAYER_VFX_TYPES; i++)
{
m_NextVariationForBreath[i] = 1;
}
}
m_TimeLastLoaded[painType] = 0;
}
m_BreathingTypeCurrentlyLoaded = AUD_BREATHING_TYPE_NONE;
m_PainSlots[AUD_PAIN_VOICE_NUM_TYPES].BankId = 0;
m_PainSlots[AUD_PAIN_VOICE_NUM_TYPES].SlotState = AUD_PAIN_SLOT_READY;
char slotName[32];
sprintf(slotName, "PAIN_%d", AUD_PAIN_VOICE_NUM_TYPES);
m_PainSlots[AUD_PAIN_VOICE_NUM_TYPES].WaveSlot = audWaveSlot::FindWaveSlot(slotName);
if(!m_PainSlots[AUD_PAIN_VOICE_NUM_TYPES].WaveSlot)
{
naWarningf("Failed to find pain slot %s", slotName);
}
m_PainTypeLoading = -1;
m_SpecificPainLevelToLoad = AUD_PAIN_LEVEL_NORMAL;
m_SpecificPainLevelLoaded = AUD_PAIN_LEVEL_NORMAL;
m_SpecificPainToLoadIsMale = true;
m_SpecificPainLoadedIsMale = false;
m_SpecificPainLoadingIsMale = false;
m_TimeSpecificBankLastLoaded = 0;
m_LastTimeSpecificPainBankSelected = 0;
ResetSpecificPainBankTrackingVars();
for(int i =0; i<AUD_PAIN_VOICE_NUM_TYPES; ++i)
{
for(int j=0; j<AUD_PAIN_ID_NUM_BANK_LOADED; ++j)
{
m_NumPainInCurrentBank[i][j] = 0;
}
}
for(int i=0; i<AUD_NUM_PLAYER_VFX_TYPES; i++)
{
m_BreathVariationsInCurrentBank[i] = 0;
}
g_BreathSlotType[AUD_BREATHING_TYPE_MICHAEL] = "BREATHING_MICHAEL";
g_BreathSlotType[AUD_BREATHING_TYPE_FRANKLIN] = "BREATHING_FRANKLIN";
g_BreathSlotType[AUD_BREATHING_TYPE_TREVOR] = "BREATHING_TREVOR";
g_BreathSlotType[AUD_BREATHING_TYPE_MP_MALE] = "";
g_BreathSlotType[AUD_BREATHING_TYPE_MP_FEMALE] = "";
g_NumBreathingBanks[AUD_BREATHING_TYPE_MICHAEL] = 1;
g_NumBreathingBanks[AUD_BREATHING_TYPE_FRANKLIN] = 1;
g_NumBreathingBanks[AUD_BREATHING_TYPE_TREVOR] = 1;
g_NumBreathingBanks[AUD_BREATHING_TYPE_MP_MALE] = 0;
g_NumBreathingBanks[AUD_BREATHING_TYPE_MP_FEMALE] = 0;
g_BreathContexts[BREATH_EXHALE] = "EXHALE";
g_BreathContexts[BREATH_EXHALE_CYCLING] = "EXHALE_CYCLING";
g_BreathContexts[BREATH_INHALE] = "INHALE";
g_BreathContexts[BREATH_SWIM_PRE_DIVE] = "SWIM_PRE_DIVE";
for (u32 i=0; i<g_PhraseMemorySize; i++)
{
m_PhraseMemory[i][0] = 0;
m_PhraseMemory[i][1] = 0;
m_PhraseMemory[i][2] = 0;
}
m_NextPhraseMemoryWriteIndex = 0;
for (u32 i=0; i<g_PhoneConvMemorySize; i++)
{
m_PhoneConversationMemory[i][0] = 0;
m_PhoneConversationMemory[i][1] = 0;
m_PhoneConversationMemory[i][2] = 0;
}
m_NextPhoneConvMemoryWriteIndex = 0;
g_VehicleOpennessToSpeechFilterCurve.Init("VEHICLE_INTERIOR_OPEN_TO_SPEECH_CUTOFF");
g_VehicleOpennessToSpeechVolumeCurve.Init("VEHICLE_INTERIOR_OPEN_TO_SPEECH_VOL");
g_DistanceSqToPriorityScalarCurve.Init("SPEECH_DISTANCE_SQ_PRIORITY_CURVE");
for (s32 i=0; i<NUM_MINI_DRIVING_CONTEXTS; i++)
{
g_MiniDrivingContextHashes[i] = atStringHash(g_MiniDrivingContexts[i]);
}
for (s32 i=0; i<NUM_MINI_NON_DRIVING_CONTEXTS; i++)
{
g_MiniNonDrivingContextHashes[i] = atStringHash(g_MiniNonDrivingContexts[i]);
}
for (s32 i=0; i<NUM_GANG_CONTEXTS; i++)
{
g_GangContextHashes[i] = atStringHash(g_GangContexts[i]);
}
for (s32 i=0; i<NUM_LOUD_CONTEXTS; i++)
{
g_LoudContextHashes[i] = atStringHash(g_LoudContexts[i]);
}
for (s32 i=0; i<NUM_TIME_LIMITED_ANIMAL_FAR_CONTEXTS; i++)
{
g_TimeLimitedAnimalFarContextsPHashes[i] = atPartialStringHash(g_TimeLimitedAnimalFarContexts[i]);
g_TimeLimitedAnimalFarContextsLastPlayTime[i] = 0;
}
m_ChurnSpeechSound = NULL;
m_ChurnSlot = -1;
m_ScriptOwningReservedSlot = THREAD_INVALID;
m_ScriptReservedSlotNum = 0;
g_DefaultSpeechContext = static_cast<SpeechContext*>(audNorthAudioEngine::GetMetadataManager().GetObjectMetadataPtr("DEFAULT_SPEECH_CONTEXT"));
naAssertf(g_DefaultSpeechContext, "Failed to find default speech context object. Any speech played through the ambient speech system without its own object will fail.");
for(int i=0; i<ANIMALTYPE_MAX; ++i)
{
m_AnimalInfoArray[i].AnimalType = (AnimalType)i;
char objName[64];
formatf(objName, "ANIMAL_PARAMS_%s", g_AnimalBankNames[i]);
m_AnimalInfoArray[i].Data = audNorthAudioEngine::GetObject<AnimalParams>(objName);
#if __BANK
if(!m_AnimalInfoArray[i].Data)
{
Warningf("Failed to find animal audio game object %s. Alert audio.", objName);
}
else
{
Warningf("Found animal audio game object %s.", objName);
}
#endif
m_NextAnimalBankNumToLoad[i] = 1;
m_NumAnimalAppearancesSinceLastUpdate[i] = 0;
m_NearestAnimalAppearancesSinceLastUpdate[i] = -1.0f;
m_NumAnimalBanks[i] = 0;
bool bankFound = true;
while(bankFound)
{
char bankName[64];
formatf(bankName, "ANIMALS_NEAR\\%s_NEAR_%.2i", g_AnimalBankNames[i], m_NumAnimalBanks[i]+1);
if(audWaveSlot::FindBankId(bankName) != ~0U)
{
Displayf("Found animal bank %s, index(%d)", bankName, i);
m_NumAnimalBanks[i]++;
}
else
bankFound = false;
}
m_NumAnimalsMakingSound[i] = 0;
}
m_MaxNumAnimalSlots = 3;
m_AnimalBankSlots.Reset();
m_AnimalBankSlots.Reserve(m_MaxNumAnimalSlots);
for(u32 i = 0; i < m_MaxNumAnimalSlots; i++)
{
if(!Verifyf(m_AnimalBankSlots.GetCount() < ANIMALTYPE_MAX, "Audio is set up to allow more animal bank slots than there are animals. This should be fixed."))
{
break;
}
formatf(slotName, sizeof(slotName), "ANIMAL_NEAR_%d", i);
audWaveSlot* waveSlot = audWaveSlot::FindWaveSlot(slotName);
if(waveSlot)
{
audAnimalBankSlot animalSlot;
animalSlot.WaveSlot = waveSlot;
m_AnimalBankSlots.PushAndGrow(animalSlot);
//LoadAnimalBank((AnimalType)(s8)m_AnimalBankSlots.GetCount(), (s8)m_AnimalBankSlots.GetCount()-1);
}
else
{
Assertf(0, "Failed to find animal bank slot %s", slotName);
}
}
m_TimeOfLastFullAnimalBankUpdate = 0;
m_ForceAnimalBankUpdate = false;
m_LoadingAfterAnimalUpdate = false;
for(int i=0; i<2; i++)
{
for(int j=0; j<AUD_NUM_PLAYER_VFX_TYPES; j++)
{
m_NumTennisVariations[i][j] = 0;
m_LastTennisVariations[i][j] = 0;
}
}
m_TennisOpponent = NULL;
m_TennisScriptIndex = -1;
m_CurrentTennisSlotLoading = -1;
m_TennisIsUsingAnimalBanks = false;
m_TennisOpponentIsMale = false;
m_TennisPlayerIsMichael = false;
m_TennisPlayerIsFranklin = false;
m_TennisPlayerIsTrevor = false;
#if GTA_REPLAY
m_ReplayNextPainBank = AUD_PAIN_VOICE_NUM_TYPES;
m_ReplayShouldSkipBankOnJump = false;
#endif // GTA_REPLAY
#if __BANK
ResetSpecificPainDrawStats();
#endif
}
void audSpeechManager::Shutdown()
{
audEntity::Shutdown();
for(int i =0; i<m_AnimalBankSlots.GetCount(); ++i)
{
m_AnimalBankSlots[i].ContextInfo.clear();
m_AnimalBankSlots[i].Owner = kAnimalNone;
}
for(int i=0; i<ANIMALTYPE_MAX; i++)
{
m_AnimalInfoArray[i].SlotNumber = -1;
}
}
void audSpeechManager::SetPlayerPainRootBankName(const CPed& newPlayer)
{
switch(newPlayer.GetPedType())
{
case PEDTYPE_PLAYER_0:
SetPlayerPainRootBankName("PAIN_MICHAEL");
break;
case PEDTYPE_PLAYER_1:
SetPlayerPainRootBankName("PAIN_FRANKLIN");
break;
case PEDTYPE_PLAYER_2:
SetPlayerPainRootBankName("PAIN_TREVOR");
break;
default:
SetPlayerPainRootBankName("PAIN_MICHAEL");
break;
}
}
void audSpeechManager::SetPlayerPainRootBankName(const char* bankName)
{
if (bankName)
{
#if GTA_REPLAY
if(CReplayMgr::ShouldRecord())
{ // If we could change this function to take in an ePedType instead of const char then
// the CPacketSetPlayerPainRoot packet can lose about 62 bytes..... (!)
CReplayMgr::RecordFx(CPacketSetPlayerPainRoot(g_PlayerPainRootBankName, bankName));
}
#endif // GTA_REPLAY
formatf(g_PlayerPainRootBankName, sizeof(g_PlayerPainRootBankName), bankName);
// we also need to clear out the old pain slots and load up the new ones - just mark them as used up and the update will deal with loading
m_PainSlots[AUD_PAIN_VOICE_TYPE_PLAYER].SlotState = AUD_PAIN_SLOT_USED_UP;
m_PainSlots[AUD_PAIN_VOICE_TYPE_BREATHING].SlotState = AUD_PAIN_SLOT_USED_UP;
}
}
void audSpeechManager::Update()
{
#if __DEV
// See how much ambient speech we're playing
g_NumPlayingAmbientSpeech = 0;
for (s32 i=0; i<g_MaxAmbientSpeechSlots; i++)
{
if (m_AmbientSpeechSlots[i].PlayState == AUD_SPEECH_SLOT_ALLOCATED)
{
g_NumPlayingAmbientSpeech++;
}
}
g_StreamingIsBusy = 0;
if (IsStreamingBusyForContext(g_AnythingDullPHash))
{
g_StreamingIsBusy = 1;
}
PF_SET(PlayingAmbientSpeech, g_NumPlayingAmbientSpeech);
PF_SET(StreamingIsBusy, g_StreamingIsBusy);
#endif
#if __BANK
audSpeechAudioEntity::UpdateVFXDebugDrawStructs();
audSpeechAudioEntity::UpdateAmbSpeechDebugDrawStructs();
if(g_StressTestSpeech)
{
if(!g_StressTestSpeechSound)
{
audSoundInitParams initParams;
initParams.Pan = 0;
initParams.StartOffset = audEngineUtil::GetRandomNumberInRange(0, (s32)g_StressTestMaxStartOffset);
CreateSound_PersistentReference("SPEECH_SCRIPTED_SPEECH", &g_StressTestSpeechSound, &initParams);
if(g_StressTestSpeechSound)
{
u32 numVariations = audSpeechSound::FindNumVariationsForVoiceAndContext(g_StressTestSpeechVoiceName,g_StressTestSpeechContext);
if(numVariations > 0)
{
audSpeechSound *speechSound = (audSpeechSound*)g_StressTestSpeechSound;
naAssertf(speechSound->GetSoundTypeID() == SpeechSound::TYPE_ID, "Speech sound was expected to have type %d but instead had type %d", SpeechSound::TYPE_ID, speechSound->GetSoundTypeID());
g_StressTestSpeechVariation = ((g_StressTestSpeechVariation + 1) % numVariations);
if(speechSound->InitSpeech(g_StressTestSpeechVoiceName, g_StressTestSpeechContext, g_StressTestSpeechVariation+1))
{
speechSound->PrepareAndPlay(audWaveSlot::FindWaveSlot("SCRIPT_SPEECH_0"), true, -1);
}
else
{
speechSound->StopAndForget();
}
}
}
}
}
if(g_DrawSpeechSlots)
DrawSpeechSlots();
if(g_DrawSpecificPainInfo)
DrawSpecificPainInfo();
if(g_DrawPainPlayedTotals)
DrawPainPlayedTotals();
if(g_DisplayAnimalBanks)
DrawAnimalBanks();
#endif
// Go through our slots, and if any are marked as STOPPING, see if they're done, and free them up.
for (s32 i=0; i<g_MaxAmbientSpeechSlots; i++)
{
if (m_AmbientSpeechSlots[i].PlayState == AUD_SPEECH_SLOT_STOPPING)
{
naAssertf(m_AmbientSpeechSlots[i].WaveSlot, "Next ambient speech slot has an invalid WaveSlot");
if (m_AmbientSpeechSlots[i].WaveSlot->GetReferenceCount() == 0)
{
// Slot's finished
m_AmbientSpeechSlots[i].PlayState = AUD_SPEECH_SLOT_VACANT;
}
}
if(m_AmbientSpeechSlots[i].PlayState == AUD_SPEECH_SLOT_ALLOCATED && m_AmbientSpeechSlots[i].SpeechAudioEntity &&
m_AmbientSpeechSlots[i].SpeechAudioEntity->GetParent() && m_AmbientSpeechSlots[i].SpeechAudioEntity->GetParent()->m_nDEflags.bFrozen)
{
m_AmbientSpeechSlots[i].SpeechAudioEntity->MarkToStopSpeech();
}
}
for (s32 i=0; i<g_MaxScriptedSpeechSlots; i++)
{
if (m_ScriptedSpeechSlots[i].PlayState == AUD_SPEECH_SLOT_STOPPING)
{
naAssertf(m_ScriptedSpeechSlots[i].WaveSlot, "Scripted speech slot has invalid WaveSlot");
if (m_ScriptedSpeechSlots[i].WaveSlot->GetReferenceCount() == 0)
{
// Slot's finished
m_ScriptedSpeechSlots[i].PlayState = AUD_SPEECH_SLOT_VACANT;
}
}
}
//if (m_PlayerSpeechSlot.PlayState == AUD_SPEECH_SLOT_STOPPING)
//{
// naAssertf(m_PlayerSpeechSlot.WaveSlot, "Player speech slot has invalid WaveSlot");
// if (m_PlayerSpeechSlot.WaveSlot->GetReferenceCount() == 0)
// {
// // Slot's finished
// m_PlayerSpeechSlot.PlayState = AUD_SPEECH_SLOT_VACANT;
// }
//}
u32 currentTime = g_AudioEngine.GetSoundManager().GetTimeInMilliseconds(0);
if(g_ActivatePainSpecificBankSwapping &&
currentTime - m_LastTimeSpecificPainBankSelected > g_TimeBetweenSpecificPainBankSelection &&
currentTime - m_TimeSpecificBankLastLoaded > g_TimeBetweenSpecificPainBankLoadAndSelection)
SelectSpecificPainBank(currentTime);
#if __BANK
else if(g_ForceSpecificPainBankSwap)
{
SelectSpecificPainBank(currentTime);
g_ForceSpecificPainBankSwap = false;
}
#endif
UpdatePainSlots();
UpdateBreathingBanks();
//UpdateGlobalSpeechMetrics();
#if __BANK
audSpeechAudioEntity::UpdateVFXDebugDrawStructs();
audSpeechAudioEntity::UpdateAmbSpeechDebugDrawStructs();
#endif
}
void audSpeechManager::UpdateGlobalSpeechMetrics()
{
// See how in a car we are, and scale up speech rolloffs accordingly
f32 inACarRatio = 0.0f;
bool isPlayerVehicleATrain = false;
audNorthAudioEngine::GetGtaEnvironment()->IsPlayerInVehicle(&inACarRatio, &isPlayerVehicleATrain);
f32 rolloff = (1.0f - inACarRatio) + (inACarRatio*g_SpeechRolloffWhenInACar);
if (isPlayerVehicleATrain)
{
rolloff = 1.0f;
}
// Get our relevant categories - don't scale up loud or high-rolloff, as these are already really big
if (g_SpeechNormalCategory)
{
g_SpeechNormalCategory->SetDistanceRollOffScale(rolloff);
}
}
const char* audSpeechManager::GetRandomContextForChurn()
{
return "BUMP";
}
void audSpeechManager::ResetSpecificPainBankTrackingVars()
{
for(u8 i=0; i<3; ++i)
{
for(u8 j=0; j<2; ++j)
m_PedsAimedAtOrHurtSinceLastSpecificPainBankSelected[i][j] = 0;
}
}
void audSpeechManager::RegisterPedAimedAtOrHurt(u8 toughness, bool shouldLowerToughness, bool hurt)
{
if(!g_ActivatePainSpecificBankSwapping)
return;
u32 amtToInc = hurt ? g_OverridePainVsAimScalar : 1;
if(shouldLowerToughness)
{
switch(toughness)
{
case AUD_TOUGHNESS_MALE_COWARDLY:
case AUD_TOUGHNESS_MALE_NORMAL:
case AUD_TOUGHNESS_MALE_BUM:
m_PedsAimedAtOrHurtSinceLastSpecificPainBankSelected[AUD_PAIN_LEVEL_WEAK][0] += amtToInc;
break;
case AUD_TOUGHNESS_MALE_BRAVE:
case AUD_TOUGHNESS_MALE_GANG:
case AUD_TOUGHNESS_COP:
m_PedsAimedAtOrHurtSinceLastSpecificPainBankSelected[AUD_PAIN_LEVEL_NORMAL][0] += amtToInc;
break;
case AUD_TOUGHNESS_FEMALE:
case AUD_TOUGHNESS_FEMALE_BUM:
m_PedsAimedAtOrHurtSinceLastSpecificPainBankSelected[AUD_PAIN_LEVEL_NORMAL][1] += amtToInc;
break;
default:
break;
}
}
else
{
switch(toughness)
{
case AUD_TOUGHNESS_MALE_COWARDLY:
case AUD_TOUGHNESS_MALE_BUM:
m_PedsAimedAtOrHurtSinceLastSpecificPainBankSelected[AUD_PAIN_LEVEL_WEAK][0] += amtToInc;
break;
case AUD_TOUGHNESS_MALE_NORMAL:
m_PedsAimedAtOrHurtSinceLastSpecificPainBankSelected[AUD_PAIN_LEVEL_NORMAL][0] += amtToInc;
break;
case AUD_TOUGHNESS_MALE_BRAVE:
case AUD_TOUGHNESS_MALE_GANG:
case AUD_TOUGHNESS_COP:
m_PedsAimedAtOrHurtSinceLastSpecificPainBankSelected[AUD_PAIN_LEVEL_TOUGH][0] += amtToInc;
break;
case AUD_TOUGHNESS_FEMALE:
case AUD_TOUGHNESS_FEMALE_BUM:
m_PedsAimedAtOrHurtSinceLastSpecificPainBankSelected[AUD_PAIN_LEVEL_NORMAL][1] += amtToInc;
break;
default:
break;
}
}
}
void audSpeechManager::SelectSpecificPainBank(u32 currentTime)
{
m_LastTimeSpecificPainBankSelected = currentTime;
#if __BANK
if(g_OverrideSpecificPainLoaded)
{
m_SpecificPainLevelToLoad = g_OverrideSpecificPainLevel;
m_SpecificPainToLoadIsMale = g_OverrideSpecificPainIsMale;
m_NeedToLoad[AUD_PAIN_VOICE_TYPE_SPECIFIC] = true;
ResetSpecificPainBankTrackingVars();
return;
}
#endif
u32 highestCount = 0;
u8 iForHighestCount = 0;
u8 jForHighestCount = 0;
for(u8 i=0; i<AUD_PAIN_LEVEL_MIXED; ++i)
{
for(u8 j=0; j<PAIN_DEBUG_NUM_GENDERS; ++j)
{
if(m_PedsAimedAtOrHurtSinceLastSpecificPainBankSelected[i][j] > highestCount)
{
highestCount = m_PedsAimedAtOrHurtSinceLastSpecificPainBankSelected[i][j];
iForHighestCount = i;
jForHighestCount = j;
}
}
}
bool shouldLoadMale = jForHighestCount==0;
if(highestCount != 0 && (m_SpecificPainLevelLoaded != iForHighestCount || m_SpecificPainLoadedIsMale != shouldLoadMale))
{
m_SpecificPainLevelToLoad = iForHighestCount;
m_SpecificPainToLoadIsMale = shouldLoadMale;
m_NeedToLoad[AUD_PAIN_VOICE_TYPE_SPECIFIC] = true;
}
//For now, we'll just keep whatever is loaded loaded. Perhaps we'll want to fall back to MALE_NORMAL
/*else
{
}*/
ResetSpecificPainBankTrackingVars();
}
void audSpeechManager::UpdatePainSlots()
{
#if GTA_REPLAY
if(CReplayMgr::IsEditModeActive() && (CReplayMgr::GetCurrentPlayBackState().IsSet(REPLAY_DIRECTION_BACK) || CReplayMgr::GetCurrentPlayBackState().IsSet(REPLAY_CURSOR_JUMP)))
return;
#endif // GTA_REPLAY
#if __BANK
if(g_UseTestPainBanks && !g_HavePreparedPainBanksForTesting)
{
m_PainSlots[AUD_PAIN_VOICE_TYPE_MALE].SlotState = AUD_PAIN_SLOT_USED_UP;
m_PainSlots[AUD_PAIN_VOICE_TYPE_FEMALE].SlotState = AUD_PAIN_SLOT_USED_UP;
g_HavePreparedPainBanksForTesting = true;
}
else if(!g_UseTestPainBanks && g_HavePreparedPainBanksForTesting)
{
g_HavePreparedPainBanksForTesting = false;
}
#endif
// Check current state of unused one, and kick off load if required, and we're free to.
for (u32 painVoiceType=0; painVoiceType<AUD_PAIN_VOICE_NUM_TYPES; painVoiceType++)
{
// If in-use one is done, move onto the other one if it's ready.
switch (m_PainSlots[painVoiceType].SlotState)
{
case AUD_PAIN_SLOT_USED_UP:
m_NeedToLoad[painVoiceType] = true;
//m_PainSlots[painVoiceType].SlotState = AUD_PAIN_SLOT_LOADING;
break;
case AUD_PAIN_SLOT_LOADING:
break;
case AUD_PAIN_SLOT_READY:
naErrorf("Audio: In-used pain slot claims to be ready. Type: %d", painVoiceType);
m_PainSlots[painVoiceType].SlotState = AUD_PAIN_SLOT_USED_UP;
break;
case AUD_PAIN_SLOT_IN_USE:
// See if we've played all of any of our lines, and if so, we're used up
// minus 1, as we deal with breathing elsewhere
for (u32 i=0; i<AUD_PAIN_ID_NUM_BANK_LOADED-1; i++)
{
if( m_NumPainInCurrentBank[painVoiceType][i] != 0 &&
m_NumTimesPainPlayed[painVoiceType][i] >= m_NumPainInCurrentBank[painVoiceType][i])
{
m_PainSlots[painVoiceType].SlotState = AUD_PAIN_SLOT_USED_UP;
break;
}
}
break;
}
}
s32 nextPainTypeToLoad = AUD_PAIN_VOICE_NUM_TYPES;
if(m_PainTypeLoading >= 0)
nextPainTypeToLoad = m_PainTypeLoading;
else
{
for(u32 painVoiceType=0; painVoiceType<AUD_PAIN_VOICE_NUM_TYPES; painVoiceType++)
{
if(m_NeedToLoad[painVoiceType])
{
if(m_NextTimeToLoadPain[painVoiceType]<audNorthAudioEngine::GetCurrentTimeInMs() &&
(nextPainTypeToLoad == AUD_PAIN_VOICE_NUM_TYPES || m_TimeLastLoaded[painVoiceType] < m_TimeLastLoaded[nextPainTypeToLoad]))
nextPainTypeToLoad = painVoiceType;
}
}
}
u8 numBanks = AUD_NUM_MICHAEL_PAIN_BANKS;
u8 painLevel = AUD_PAIN_LEVEL_MIXED;
if (nextPainTypeToLoad == AUD_PAIN_VOICE_TYPE_PLAYER)
{
switch(atStringHash(g_PlayerPainRootBankName))
{
case 0xAF868358: //PAIN_MICHAEL
numBanks = AUD_NUM_MICHAEL_PAIN_BANKS;
break;
case 0xEBDE18F: //PAIN_FRANKLIN
numBanks = AUD_NUM_FRANKLIN_PAIN_BANKS;
break;
case 0x983182FE: //PAIN_TREVOR
numBanks = AUD_NUM_TREVOR_PAIN_BANKS;
break;
}
}
else if (nextPainTypeToLoad == AUD_PAIN_VOICE_TYPE_MALE)
{
numBanks = AUD_NUM_MALE_MIXED_PAIN_BANKS;
}
else if(nextPainTypeToLoad == AUD_PAIN_VOICE_TYPE_FEMALE)
{
numBanks = AUD_NUM_FEMALE_NORMAL_PAIN_BANKS;
}
else if (nextPainTypeToLoad == AUD_PAIN_VOICE_TYPE_SPECIFIC)
{
switch(m_SpecificPainLevelToLoad)
{
case AUD_PAIN_LEVEL_WEAK:
numBanks = m_SpecificPainToLoadIsMale ? AUD_NUM_MALE_WEAK_PAIN_BANKS : AUD_NUM_FEMALE_WEAK_PAIN_BANKS;
painLevel = AUD_PAIN_LEVEL_WEAK;
break;
case AUD_PAIN_LEVEL_NORMAL:
numBanks = m_SpecificPainToLoadIsMale ? AUD_NUM_MALE_NORMAL_PAIN_BANKS : AUD_NUM_FEMALE_NORMAL_PAIN_BANKS;
painLevel = AUD_PAIN_LEVEL_NORMAL;
break;
case AUD_PAIN_LEVEL_TOUGH:
numBanks = m_SpecificPainToLoadIsMale ? AUD_NUM_MALE_TOUGH_PAIN_BANKS : AUD_NUM_FEMALE_NORMAL_PAIN_BANKS;
painLevel = (u8)(m_SpecificPainToLoadIsMale ? AUD_PAIN_LEVEL_TOUGH : AUD_PAIN_LEVEL_NORMAL);
break;
}
}
else if (nextPainTypeToLoad == AUD_PAIN_VOICE_TYPE_BREATHING)
{
numBanks = g_NumBreathingBanks[m_BreathingTypeToLoad];
}
//Initialize these here to avoid "transfer of control bypasses..." compile errors.
audWaveSlot::audWaveSlotLoadStatus loadStatus = audWaveSlot::NOT_REQUESTED;
audWaveSlot* temp = NULL;
audPainSlot& loadingSlot = m_PainSlots[AUD_PAIN_VOICE_NUM_TYPES];
switch (loadingSlot.SlotState)
{
case AUD_PAIN_SLOT_READY:
// See if it's ok to load the bank
Assertf(loadingSlot.WaveSlot, "Failed to find valid waveslot pointer in backup pain slot.");
naCErrorf(m_PainTypeLoading==-1, "Pain loading slot is set to READY but we have a valid PainTypeLoading set.");
if (loadingSlot.WaveSlot && nextPainTypeToLoad != AUD_PAIN_VOICE_NUM_TYPES)
{
Assign(m_PainTypeLoading, nextPainTypeToLoad);
if(loadingSlot.WaveSlot->GetReferenceCount() == 0)
{
//may as well cache this, in case we end up setting ToLoad from a different thread, though it will only be used
// if loading the specific bank
bool loadingSpecificMale = m_SpecificPainToLoadIsMale;
// Get the next bank name
u8 nextPainBank = (m_CurrentPainBank[nextPainTypeToLoad] % numBanks) + 1;
#if GTA_REPLAY
if(CReplayMgr::ShouldRecord())
{
CReplayMgr::RecordFx(CPacketPainWaveBankChange(m_CurrentPainBank[nextPainTypeToLoad], nextPainBank));
}
#endif // GTA_REPLAY
char voiceName[64] = "";
if (nextPainTypeToLoad==AUD_PAIN_VOICE_TYPE_PLAYER)
{
formatf(voiceName, 64, "%s_%02d", g_PlayerPainRootBankName, nextPainBank);
}
else if (nextPainTypeToLoad==AUD_PAIN_VOICE_TYPE_FEMALE)
{
formatf(voiceName, 64, "PAIN_FEMALE_NORMAL_%02d", nextPainBank);
}
else if(nextPainTypeToLoad==AUD_PAIN_VOICE_TYPE_SPECIFIC)
{
//there are no specific female banks
if(loadingSpecificMale)
{
formatf(voiceName, 64, "PAIN_%s_%s_%02d", "MALE", g_PainLevelString[painLevel], nextPainBank);
}
else
{
formatf(voiceName, 64, "PAIN_FEMALE_NORMAL_%02d", nextPainBank);
}
}
else if(nextPainTypeToLoad==AUD_PAIN_VOICE_TYPE_BREATHING)
{
formatf(voiceName, 64, "%s_%02d", g_BreathSlotType[m_BreathingTypeToLoad], nextPainBank);
}
else
{
#if __BANK
if(g_UseTestPainBanks)
nextPainBank = 1;
#endif
formatf(voiceName, 64, "%s_MIXED_%02d", g_PainSlotType[nextPainTypeToLoad], nextPainBank);
}
u32 bankId = audSpeechSound::FindBankIdForVoiceAndContext(voiceName, "PAIN_WHEEZE");
if(nextPainTypeToLoad==AUD_PAIN_VOICE_TYPE_BREATHING)
{
bankId = audSpeechSound::FindBankIdForVoiceAndContext(voiceName, "EXHALE");
}
else if(bankId == AUD_INVALID_BANK_ID)
{
bankId = audSpeechSound::FindBankIdForVoiceAndContext(voiceName, "PAIN_SHOVE");
if(bankId == AUD_INVALID_BANK_ID)
{
bankId = audSpeechSound::FindBankIdForVoiceAndContext(voiceName, "PAIN_LOW");
}
}
if (bankId < AUD_INVALID_BANK_ID)
{
Assign(loadingSlot.BankId, bankId);
loadingSlot.WaveSlot->LoadBank(bankId);
loadingSlot.SlotState = AUD_PAIN_SLOT_LOADING;
loadingSlot.VoiceNameHash = atStringHash(voiceName);
loadingSlot.PainLevel = painLevel;
#if __BANK
safecpy(loadingSlot.VoiceName, voiceName);
#endif
m_NextTimeToLoadPain[nextPainTypeToLoad] = audNorthAudioEngine::GetCurrentTimeInMs() + 1500;
m_TimeLastLoaded[nextPainTypeToLoad] = audNorthAudioEngine::GetCurrentTimeInMs();
if(nextPainTypeToLoad==AUD_PAIN_VOICE_TYPE_SPECIFIC)
m_SpecificPainLoadingIsMale = loadingSpecificMale;
}
else
{
m_NextTimeToLoadPain[nextPainTypeToLoad] = audNorthAudioEngine::GetCurrentTimeInMs() + 60000;
m_TimeLastLoaded[nextPainTypeToLoad] = audNorthAudioEngine::GetCurrentTimeInMs();
Assign(m_PainTypeLoading, -1);
}
}
else
{
Assign(m_PainTypeLoading, -1);
}
}
break;
case AUD_PAIN_SLOT_LOADING:
// See if it's done
loadStatus = loadingSlot.WaveSlot->GetBankLoadingStatus(loadingSlot.BankId);
switch (loadStatus)
{
case audWaveSlot::NOT_REQUESTED:
naErrorf("Pain bank not requested but thinks it has been");
loadingSlot.SlotState = AUD_PAIN_SLOT_READY;
break;
case audWaveSlot::FAILED:
// Assertf(0, "Audio: Pain bank load failed. Bank: %s, Slot: %d",
// audWaveSlot::GetBankName(m_PainSlots[painVoiceType][unusedSlot].BankId), unusedSlot);
naErrorf("Pain bank load load failed. Bank: %s", audWaveSlot::GetBankName(loadingSlot.BankId));
loadingSlot.SlotState = AUD_PAIN_SLOT_READY;
break;
case audWaveSlot::LOADED:
// change a few states, and point at that one
m_NeedToLoad[m_PainTypeLoading] = false;
m_CurrentPainBank[nextPainTypeToLoad] = (m_CurrentPainBank[nextPainTypeToLoad] % numBanks) + 1;
if(nextPainTypeToLoad!=AUD_PAIN_VOICE_TYPE_BREATHING)
{
for (u32 i=0; i<AUD_PAIN_ID_NUM_BANK_LOADED; i++)
{
m_NumTimesPainPlayed[nextPainTypeToLoad][i] = 0;
if(nextPainTypeToLoad == AUD_PAIN_VOICE_TYPE_PLAYER)
m_NumPainInCurrentBank[m_PainTypeLoading][i] = (u8)audSpeechSound::FindNumVariationsForVoiceAndContext(loadingSlot.VoiceNameHash, g_PlayerPainContexts[i]);
else
m_NumPainInCurrentBank[m_PainTypeLoading][i] = (u8)audSpeechSound::FindNumVariationsForVoiceAndContext(loadingSlot.VoiceNameHash, g_PainContexts[i]);
m_NextVariationForPain[m_PainTypeLoading][i] = 1;
}
}
else
{
for(int i=0; i<AUD_NUM_PLAYER_VFX_TYPES; i++)
{
m_NextVariationForBreath[i] = 1;
m_BreathVariationsInCurrentBank[i] = (u8)audSpeechSound::FindNumVariationsForVoiceAndContext(loadingSlot.VoiceNameHash, g_BreathContexts[i]);
}
m_BreathingTypeCurrentlyLoaded = m_BreathingTypeToLoad;
}
temp = m_PainSlots[m_PainTypeLoading].WaveSlot;
m_PainSlots[m_PainTypeLoading].WaveSlot = loadingSlot.WaveSlot;
loadingSlot.WaveSlot = temp;
m_PainSlots[m_PainTypeLoading].BankId = loadingSlot.BankId;
m_PainSlots[m_PainTypeLoading].SlotState = AUD_PAIN_SLOT_IN_USE;
m_PainSlots[m_PainTypeLoading].VoiceNameHash = loadingSlot.VoiceNameHash;
#if __BANK
safecpy(m_PainSlots[m_PainTypeLoading].VoiceName, loadingSlot.VoiceName);
#endif
if(m_PainTypeLoading == AUD_PAIN_VOICE_TYPE_SPECIFIC)
{
m_SpecificPainLevelLoaded = loadingSlot.PainLevel;
m_SpecificPainLoadedIsMale = m_SpecificPainLoadingIsMale;
m_TimeSpecificBankLastLoaded = g_AudioEngine.GetSoundManager().GetTimeInMilliseconds(0);
#if __BANK
//int genderIndex = m_SpecificPainLoadedIsMale ? 0 : 1;
int genderIndex = 0;
m_DebugSpecPainBankLoadCount[m_SpecificPainLevelLoaded][genderIndex]++;
m_DebugSpecPainTimeLastLoaded[m_SpecificPainLevelLoaded][genderIndex] = g_AudioEngine.GetSoundManager().GetTimeInMilliseconds(0);
m_DebugSpecPainBankLoadCountTotal++;
#endif
}
#if __BANK
else
m_DebugNonSpecPainBankLoadCountTotal++;
#endif
m_PainTypeLoading = -1;
loadingSlot.SlotState = AUD_PAIN_SLOT_READY;
break;
case audWaveSlot::LOADING:
default:
// All good, we'll wait for it
break;
}
break;
case AUD_PAIN_SLOT_IN_USE:
naErrorf("Audio: Unused pain slot claims to be in use. Type: %d", nextPainTypeToLoad);
loadingSlot.SlotState = AUD_PAIN_SLOT_READY;
break;
}
}
bool audSpeechManager::IsPainLoaded(u32 painVoiceType)
{
// Make sure this pain type has a bank loaded - this won't be true for the first few seconds of a game
if (painVoiceType<AUD_PAIN_VOICE_NUM_TYPES)
{
if (m_PainSlots[painVoiceType].SlotState == AUD_PAIN_SLOT_IN_USE)
{
return true;
}
}
return false;
}
void audSpeechManager::PlayedPain(u32 painVoiceType, u32 painType)
{
#if __BANK
if(painVoiceType == AUD_PAIN_VOICE_TYPE_SPECIFIC)
{
m_DebugSpecPainCountTotal++;
}
else if(painVoiceType == AUD_PAIN_VOICE_TYPE_FEMALE)
{
m_DebugNonSpecPainCountTotal++;
}
else if(painVoiceType == AUD_PAIN_VOICE_TYPE_MALE)
{
m_DebugNonSpecPainCountTotal++;
}
#endif
if(m_NumPainInCurrentBank[painVoiceType][painType] != 0)
{
m_NumTimesPainPlayed[painVoiceType][painType]++;
m_NextVariationForPain[painVoiceType][painType] =
(m_NextVariationForPain[painVoiceType][painType] % m_NumPainInCurrentBank[painVoiceType][painType]) + 1;
// also flag that we're not to swap this one out for a wee while - long enough that we'll defo have started playing any we're about to kick off
m_NextTimeToLoadPain[painVoiceType] = Max(m_NextTimeToLoadPain[painVoiceType], audNorthAudioEngine::GetCurrentTimeInMs() + 500);
}
}
#if GTA_REPLAY
void audSpeechManager::PlayedPainForReplay(u32 painVoiceType, u32 painType, u8 numTimes, u8 nextVariation, u32 nextTimeToLoad, bool isJumpingOrRwnd, bool isGoingForwards)
{
if(!isJumpingOrRwnd)
{ // We're just playing normally or fast forwarding so set the managers
// variables directly and let is manage things properly
m_NumTimesPainPlayed[painVoiceType][painType] = numTimes;
m_NextVariationForPain[painVoiceType][painType] = nextVariation;
m_NextTimeToLoadPain[painVoiceType] = nextTimeToLoad;
m_ReplayNeedToReconcile = false;
}
else
{
if(m_ReplayNeedToReconcile == false)
{ // Replay hasn't started modifying vars yet so copy across what
// they all should be
for(int pvt = 0; pvt < AUD_PAIN_VOICE_NUM_TYPES; ++pvt)
{
for(int pt = 0; pt < AUD_PAIN_ID_NUM_BANK_LOADED; ++pt)
{
m_ReplayNumTimesPainPlayed[pvt][pt] = m_NumTimesPainPlayed[pvt][pt];
m_ReplayNextVariationForPain[pvt][pt] = m_NextVariationForPain[pvt][pt];
}
m_ReplayNextTimeToLoadPain[pvt] = m_NextTimeToLoadPain[pvt];
}
}
// Set our modification from replay...
m_ReplayNumTimesPainPlayed[painVoiceType][painType] = numTimes;
m_ReplayNextVariationForPain[painVoiceType][painType] = nextVariation;
m_ReplayNextTimeToLoadPain[painVoiceType] = nextTimeToLoad;
m_ReplayNeedToReconcile = true; // These vars will need to be reconciled with the manager
}
m_ReplayWaveBankChangeWasLast = false; // Last action was to play a sound (not change bank)
m_ReplayWasGoingForwards = isGoingForwards;
}
void audSpeechManager::GetPlayedPainForReplayVars(u32 painVoiceType, u8* numTimes, u8* nextVariation, u32& nextTimeToLoad, u8& currentPainBank) const
{
for(int i = 0; i < AUD_PAIN_ID_NUM_BANK_LOADED; ++i)
{
numTimes[i] = m_NumTimesPainPlayed[painVoiceType][i];
nextVariation[i] = m_NextVariationForPain[painVoiceType][i];
}
nextTimeToLoad = m_NextTimeToLoadPain[painVoiceType];
currentPainBank = m_CurrentPainBank[painVoiceType];
}
void audSpeechManager::SetPlayedPainForReplayVars(u32 painVoiceType, const u8* numTimes, const u8* nextVariation, const u32& nextTimeToLoad, const u8& currentPainBank)
{
for(int i = 0; i < AUD_PAIN_ID_NUM_BANK_LOADED; ++i)
{
m_NumTimesPainPlayed[painVoiceType][i] = numTimes[i];
m_NextVariationForPain[painVoiceType][i] = nextVariation[i];
}
m_NextTimeToLoadPain[painVoiceType] = nextTimeToLoad;
m_CurrentPainBank[painVoiceType] = currentPainBank;
replayDebugf1("Current pain bank set to %u", currentPainBank);
m_CurrentPainBank[painVoiceType] = (m_CurrentPainBank[painVoiceType] % 2) + 1;
}
#endif // GTA_REPLAY
const char* audSpeechManager::GetPainLevelString(u8 toughness, bool shouldLowerToughness, bool& isSpecificPain) const
{
#if __BANK
if(g_UseTestPainBanks)
return g_PainLevelString[AUD_PAIN_LEVEL_MIXED];
#endif
if(shouldLowerToughness)
{
switch(toughness)
{
case AUD_TOUGHNESS_MALE_COWARDLY:
case AUD_TOUGHNESS_MALE_NORMAL:
case AUD_TOUGHNESS_MALE_BUM:
if(m_SpecificPainLoadedIsMale && m_SpecificPainLevelLoaded == AUD_PAIN_LEVEL_WEAK)
{
isSpecificPain = true;
return g_PainLevelString[AUD_PAIN_LEVEL_WEAK];
}
else
return g_PainLevelString[AUD_PAIN_LEVEL_MIXED];
case AUD_TOUGHNESS_MALE_BRAVE:
case AUD_TOUGHNESS_MALE_GANG:
case AUD_TOUGHNESS_COP:
if(m_SpecificPainLoadedIsMale && m_SpecificPainLevelLoaded == AUD_PAIN_LEVEL_NORMAL)
{
isSpecificPain = true;
return g_PainLevelString[AUD_PAIN_LEVEL_NORMAL];
}
else
return g_PainLevelString[AUD_PAIN_LEVEL_MIXED];
case AUD_TOUGHNESS_FEMALE:
case AUD_TOUGHNESS_FEMALE_BUM:
return g_PainLevelString[AUD_PAIN_LEVEL_NORMAL];
default:
Assertf(0, "Bad toughness value passed to GetPainLevelString()");
return g_PainLevelString[AUD_PAIN_LEVEL_MIXED];
}
}
else
{
switch(toughness)
{
case AUD_TOUGHNESS_MALE_COWARDLY:
case AUD_TOUGHNESS_MALE_BUM:
/*if(m_SpecificPainLoadedIsMale && m_SpecificPainLevelLoaded == AUD_PAIN_LEVEL_WEAK)
{
isSpecificPain = true;
return g_PainLevelString[AUD_PAIN_LEVEL_WEAK];
}
else*/
return g_PainLevelString[AUD_PAIN_LEVEL_MIXED];
case AUD_TOUGHNESS_MALE_NORMAL:
if(m_SpecificPainLoadedIsMale && m_SpecificPainLevelLoaded == AUD_PAIN_LEVEL_NORMAL)
{
isSpecificPain = true;
return g_PainLevelString[AUD_PAIN_LEVEL_NORMAL];
}
else
return g_PainLevelString[AUD_PAIN_LEVEL_MIXED];
case AUD_TOUGHNESS_MALE_BRAVE:
case AUD_TOUGHNESS_MALE_GANG:
case AUD_TOUGHNESS_COP:
if(m_SpecificPainLoadedIsMale && m_SpecificPainLevelLoaded == AUD_PAIN_LEVEL_TOUGH)
{
isSpecificPain = true;
return g_PainLevelString[AUD_PAIN_LEVEL_TOUGH];
}
else
return g_PainLevelString[AUD_PAIN_LEVEL_MIXED];
case AUD_TOUGHNESS_FEMALE:
case AUD_TOUGHNESS_FEMALE_BUM:
return g_PainLevelString[AUD_PAIN_LEVEL_NORMAL];
default:
Assertf(0, "Bad toughness value passed to GetPainLevelString()");
return g_PainLevelString[AUD_PAIN_LEVEL_MIXED];
}
}
}
audWaveSlot* audSpeechManager::GetWaveSlotForPain(u32 painVoiceType)
{
#if __DEV
naAssertf(painVoiceType<AUD_PAIN_VOICE_NUM_TYPES, "Pain voice type: %d", painVoiceType);
naAssertf(m_PainSlots[painVoiceType].WaveSlot, "Missing waveslot for paintype %u", painVoiceType);
#endif
return m_PainSlots[painVoiceType].WaveSlot;
}
u8 audSpeechManager::GetBankNumForPain(u32 painVoiceType)
{
#if __BANK
if(g_UseTestPainBanks)
return 1;
#endif
return m_CurrentPainBank[painVoiceType];
}
#if GTA_REPLAY
void audSpeechManager::SetBankNumForPain(u32 painVoiceType, u8 bank)
{
m_CurrentPainBank[painVoiceType] = bank;
}
#endif // GTA_REPLAY
u32 audSpeechManager::GetVariationForPain(u32 painVoiceType, u32 painType)
{
#if __BANK
if(g_UseTestPainBanks)
return 1;
#endif
Assert(painType < AUD_PAIN_ID_NUM_BANK_LOADED);
Assert(painVoiceType < AUD_PAIN_VOICE_NUM_TYPES);
return m_NextVariationForPain[painVoiceType][painType];
}
#if GTA_REPLAY
void audSpeechManager::SetVariationForPain(u32 painVoiceType, u32 painType, u8 variation)
{
if(Verifyf(painType < AUD_PAIN_ID_NUM_BANK_LOADED && painVoiceType < AUD_PAIN_VOICE_NUM_TYPES, "Invalid index into array"))
m_NextVariationForPain[painVoiceType][painType] = variation;
}
u8 audSpeechManager::GetNumTimesPlayed(u32 painVoiceType, u32 painType) const
{
if(Verifyf(painType < AUD_PAIN_ID_NUM_BANK_LOADED && painVoiceType < AUD_PAIN_VOICE_NUM_TYPES, "Invalid index into array"))
return m_NumTimesPainPlayed[painVoiceType][painType];
else
return m_NumTimesPainPlayed[0][0];
}
u32 audSpeechManager::GetNextTimeToLoad(u32 painVoiceType) const
{
if(Verifyf(painVoiceType < AUD_PAIN_VOICE_NUM_TYPES, "Invalid index into array"))
return m_NextTimeToLoadPain[painVoiceType];
else
return m_NextTimeToLoadPain[0];
}
#endif // GTA_REPLAY
u32 audSpeechManager::GetWaveLoadedPainVoiceFromVoiceType(u32 painVoiceType, const CPed* ped)
{
u32 voiceNameHash = 0;
if(painVoiceType == AUD_PAIN_VOICE_TYPE_PLAYER && ped)
{
if(ped->GetPedType() == PEDTYPE_PLAYER_0)
{
voiceNameHash = ATSTRINGHASH("WAVELOAD_PAIN_MICHAEL", 0x6531A692);
}
else if(ped->GetPedType() == PEDTYPE_PLAYER_1)
{
voiceNameHash = ATSTRINGHASH("WAVELOAD_PAIN_FRANKLIN", 0x33F65FC3);
}
else if(ped->GetPedType() == PEDTYPE_PLAYER_2)
{
voiceNameHash = ATSTRINGHASH("WAVELOAD_PAIN_TREVOR", 0xCF83E9F);
}
}
if(voiceNameHash == 0)
{
char voiceName[64];
formatf(voiceName, "WAVELOAD_%s", g_PainSlotType[painVoiceType]);
voiceNameHash = atStringHash(voiceName);
}
return voiceNameHash;
}
void audSpeechManager::UpdateBreathingBanks()
{
if(!FindPlayerPed() || !FindPlayerPed()->GetSpeechAudioEntity() || FindPlayerPed()->GetSpeechAudioEntity()->IsAnimal())
return;
switch(FindPlayerPed()->GetPedType())
{
case PEDTYPE_PLAYER_0:
m_BreathingTypeToLoad = AUD_BREATHING_TYPE_MICHAEL;
break;
case PEDTYPE_PLAYER_1:
m_BreathingTypeToLoad = AUD_BREATHING_TYPE_FRANKLIN;
break;
case PEDTYPE_PLAYER_2:
m_BreathingTypeToLoad = AUD_BREATHING_TYPE_TREVOR;
break;
default:
m_BreathingTypeToLoad = AUD_BREATHING_TYPE_MICHAEL;
}
if(m_BreathingTypeToLoad != m_BreathingTypeCurrentlyLoaded)
{
m_NeedToLoad[AUD_PAIN_VOICE_TYPE_BREATHING] = true;
}
}
const char* audSpeechManager::GetBreathingInfo(PlayerVocalEffectType eEffectType, u32& voiceNameHash, u8& variation)
{
if(naVerifyf(eEffectType < AUD_NUM_PLAYER_VFX_TYPES, "Invalid vfxType passed into PlayedBreath()"))
{
variation = m_NextVariationForBreath[eEffectType];
voiceNameHash = m_PainSlots[AUD_PAIN_VOICE_TYPE_BREATHING].VoiceNameHash;
return g_BreathContexts[eEffectType];
}
return "";
}
void audSpeechManager::PlayedBreath(PlayerVocalEffectType eEffectType)
{
if(naVerifyf(eEffectType < AUD_NUM_PLAYER_VFX_TYPES, "Invalid vfxType passed into PlayedBreath()"))
{
m_NextVariationForBreath[eEffectType]++;
if(m_NextVariationForBreath[eEffectType] > m_BreathVariationsInCurrentBank[eEffectType])
{
m_NeedToLoad[AUD_PAIN_VOICE_TYPE_BREATHING] = true;
m_NextVariationForBreath[eEffectType] = 1;
}
}
}
void audSpeechManager::UpdateAnimalBanks()
{
static u32 sMinTimeBetweenFullUpdates = 4000;
#if __BANK
if(g_DebugTennisLoad)
{
RequestTennisBanks(FindPlayerPed(), true);
g_DebugTennisLoad = false;
}
if(g_DebugTennisUnload)
{
UnrequestTennisBanks();
g_DebugTennisUnload = false;
}
#endif
if(m_TennisIsUsingAnimalBanks)
{
UpdateTennisBanks();
return;
}
for(int i=0; i<m_AnimalBankSlots.GetCount(); ++i)
{
Assertf(m_AnimalBankSlots[i].WaveSlot, "Animal bank slot has gone NULL. Please alert audio");
if(m_AnimalBankSlots[i].IsLoading)
{
switch(m_AnimalBankSlots[i].WaveSlot->GetBankLoadingStatus(m_AnimalBankSlots[i].BankdID))
{
case audWaveSlot::FAILED:
m_AnimalInfoArray[m_AnimalBankSlots[i].Owner].SlotNumber = -1;
m_AnimalBankSlots[i].BankdID = ~0U;
m_AnimalBankSlots[i].Owner = kAnimalNone;
m_AnimalBankSlots[i].IsLoading = false;
m_AnimalBankSlots[i].FailedLastTime = true;
break;
case audWaveSlot::LOADED:
m_AnimalInfoArray[m_AnimalBankSlots[i].Owner].SlotNumber = (s8)i;
m_AnimalBankSlots[i].IsLoading = false;
break;
default:
break;
}
}
}
if(GetIsCurrentlyLoadingAnimalBank())
return;
if(m_LoadingAfterAnimalUpdate)
{
for(int i=0; i<m_AnimalBankSlots.GetCount(); ++i)
{
AnimalType animalType = m_SortedAnimalList[i].AnimalType;
if(m_AnimalInfoArray[animalType].Priority <= 0.0f)
m_LoadingAfterAnimalUpdate = false;
else if(m_AnimalInfoArray[animalType].SlotNumber == -1)
{
LoadAnimalBank(animalType);
if(i == m_AnimalBankSlots.GetCount() - 1)
m_LoadingAfterAnimalUpdate = false;
return;
}
}
}
for(int i=0; i<m_AnimalBankSlots.GetCount(); ++i)
{
for(int j=0; j<m_AnimalBankSlots[i].ContextInfo.GetCount(); ++j)
{
if(m_AnimalBankSlots[i].ContextInfo[j].UsedUp >= 0)
{
if(m_AnimalBankSlots[i].ContextInfo[j].UsedUp > 0)
m_AnimalBankSlots[i].ContextInfo[j].UsedUp--;
if(m_AnimalBankSlots[i].ContextInfo[j].UsedUp==0 && m_AnimalBankSlots[i].ContextInfo[j].ForcesSwap)
{
LoadAnimalBank(m_AnimalBankSlots[i].Owner, (s8)i);
return;
}
}
}
}
u32 currentTime = g_AudioEngine.GetSoundManager().GetTimeInMilliseconds(0);
if(m_TimeOfLastFullAnimalBankUpdate + sMinTimeBetweenFullUpdates > currentTime && !m_ForceAnimalBankUpdate BANK_ONLY(&& !g_ForceAnimalBankUpdate))
return;
m_ForceAnimalBankUpdate = false;
BANK_ONLY(g_ForceAnimalBankUpdate = false;)
m_TimeOfLastFullAnimalBankUpdate = currentTime;
#if __BANK
if(g_TestAnimalBankPriority)
{
for(int i=0; i<ANIMALTYPE_MAX; ++i)
{
m_NumAnimalAppearancesSinceLastUpdate[i] = fwRandom::GetRandomNumberInRange(0,10);
m_NearestAnimalAppearancesSinceLastUpdate[i] = 1.0f;
}
}
#endif
//safety valve to clear this value in case something wierd happens. Set the number of each type of animal making a sound
// to 0, if none of those animal are present.
for(int i=0; i<ANIMALTYPE_MAX; ++i)
{
if(m_NumAnimalAppearancesSinceLastUpdate[i] == 0)
m_NumAnimalsMakingSound[i] = 0;
}
SortAnimalList(&m_SortedAnimalList[0]);
m_LoadingAfterAnimalUpdate = true;
}
void audSpeechManager::LoadAnimalBank(AnimalType animalId, s8 slotNum)
{
u8 lowestPrioritySlotNumber = 0;
for(int i=0; i<m_AnimalBankSlots.GetCount(); ++i)
{
if(m_AnimalBankSlots[i].Owner == animalId)
slotNum = (s8)i;
}
if(slotNum < 0)
{
f32 lowestPriority = FLT_MAX;
for(int i=0; i<m_AnimalBankSlots.GetCount(); ++i)
{
f32 priority = m_AnimalInfoArray[m_AnimalBankSlots[i].Owner].Priority;
if(priority < lowestPriority)
{
lowestPriority = priority;
lowestPrioritySlotNumber = (u8)i;
}
}
}
else
lowestPrioritySlotNumber = slotNum;
if(!Verifyf(animalId>kAnimalNone && animalId < ANIMALTYPE_MAX, "Invalid animal id %i passed to LoadAnimalBank", animalId))
return;
audAnimalBankSlot& animalSlot = m_AnimalBankSlots[lowestPrioritySlotNumber];
if(animalSlot.WaveSlot->GetReferenceCount() != 0)
return;
if(!Verifyf(!animalSlot.WaveSlot->GetIsLoading(), "Trying to load animal bank that is already currently loading."))
return;
//Set the animal info structs so that the animal getting kicked out takes a slot number of -1
if(m_AnimalBankSlots[lowestPrioritySlotNumber].Owner != kAnimalNone)
m_AnimalInfoArray[m_AnimalBankSlots[lowestPrioritySlotNumber].Owner].SlotNumber = -1;
char voiceName[64];
char bankName[64];
formatf(voiceName, "%s_NEAR_%.2d", g_AnimalBankNames[animalId], m_NextAnimalBankNumToLoad[animalId]);
formatf(bankName, "ANIMALS_NEAR\\%s", voiceName);
Displayf("Loading animal bank : %s", bankName);
animalSlot.BankdID = audWaveSlot::FindBankId(bankName);
if(!animalSlot.WaveSlot->LoadBank(animalSlot.BankdID))
return;
m_NextAnimalBankNumToLoad[animalId] = (m_NextAnimalBankNumToLoad[animalId] % m_NumAnimalBanks[animalId]) + 1;
const AnimalParams* params = m_AnimalInfoArray[animalId].Data;
if(!params)
return;
animalSlot.ContextInfo.Reset();
u32 voiceHash = atStringHash(voiceName);
for(int i=0; i<params->numContexts; i++)
{
audAnimalContextInfo contextInfo;
contextInfo.ContextPHash = atPartialStringHash(params->Context[i].ContextName);
contextInfo.NumVars = audSpeechSound::FindNumVariationsForVoiceAndContext(voiceHash, params->Context[i].ContextName);
if(contextInfo.NumVars != 0)
{
naAssertf(params->Context[i].MaxTimeBetween >= params->Context[i].MinTimeBetween, "Animal context has min time greater than its max time. Voicehash %u Context %s",
voiceHash, params->Context[i].ContextName);
contextInfo.NextTimeCanPlay = 0;
contextInfo.MinTimeBetween = params->Context[i].MinTimeBetween;
contextInfo.MaxTimeBetween = params->Context[i].MaxTimeBetween;
contextInfo.LastVarUsed = 0;
contextInfo.ForcesSwap = params->Context[i].ContextBits.BitFields.SwapWhenUsedUp;
contextInfo.UsedUp = -1;
animalSlot.ContextInfo.PushAndGrow(contextInfo);
}
}
//Fill in info for the audAnimalBankSlot
animalSlot.Owner = animalId;
animalSlot.IsLoading = true;
animalSlot.FailedLastTime = false;
animalSlot.VoiceName = voiceHash;
}
bool audSpeechManager::GetIsCurrentlyLoadingAnimalBank()
{
for(int i=0; i<m_AnimalBankSlots.GetCount(); ++i)
{
if(m_AnimalBankSlots[i].IsLoading)
return true;
}
return false;
}
void audSpeechManager::UpdateTennisBanks()
{
if(!m_TennisIsUsingAnimalBanks)
return;
if(m_CurrentTennisSlotLoading == -1)
{
m_CurrentTennisSlotLoading = 0;
LoadTennisBanks();
}
if(m_CurrentTennisSlotLoading < 2)
{
audAnimalBankSlot& tennisSlot = m_AnimalBankSlots[m_CurrentTennisSlotLoading];
audWaveSlot::audWaveSlotLoadStatus loadState = tennisSlot.WaveSlot->GetBankLoadingStatus(tennisSlot.BankdID);
if(loadState == audWaveSlot::LOADING)
{
return;
}
else
{
if(loadState == audWaveSlot::FAILED)
{
naWarningf("Tennis audio bank failed to load");
}
m_CurrentTennisSlotLoading++;
if(m_CurrentTennisSlotLoading >= 2)
{
return;
}
else
{
LoadTennisBanks();
}
}
}
}
void audSpeechManager::RequestTennisBanks(CPed* opponent BANK_ONLY(, bool debuggingTennis))
{
if(!opponent)
{
naWarningf("Not loading tennis audio bank. Invalid opponent ped.");
return;
}
#if __BANK
if(!debuggingTennis)
#endif
{
scrThreadId scriptThreadId = CTheScripts::GetCurrentGtaScriptThread()->GetThreadId();
naCErrorf(scriptThreadId, "Failed to get thread id");
m_TennisScriptIndex = g_ScriptAudioEntity.GetIndexFromScriptThreadId(scriptThreadId);
}
if (!naVerifyf(m_TennisScriptIndex>=0 BANK_ONLY(|| debuggingTennis), "No valid scriptIndex: %s; %d", CTheScripts::GetCurrentScriptName(), m_TennisScriptIndex))
{
return;
}
m_CurrentTennisSlotLoading = -1;
m_TennisIsUsingAnimalBanks = true;
for(int i =0; i<m_AnimalBankSlots.GetCount(); ++i)
{
m_AnimalBankSlots[i].ContextInfo.clear();
m_AnimalBankSlots[i].Owner = kAnimalNone;
}
for(int i=0; i<ANIMALTYPE_MAX; i++)
{
m_AnimalInfoArray[i].SlotNumber = -1;
}
m_TennisOpponent = opponent;
m_TennisOpponentIsMale = opponent->IsMale();
m_TennisPlayerIsMichael = false;
m_TennisPlayerIsFranklin = false;
m_TennisPlayerIsTrevor = false;
}
void audSpeechManager::UnrequestTennisBanks()
{
m_CurrentTennisSlotLoading = -1;
m_TennisIsUsingAnimalBanks = false;
m_ForceAnimalBankUpdate = true;
m_TennisOpponent = NULL;
}
void audSpeechManager::LoadTennisBanks()
{
if(naVerifyf(m_AnimalBankSlots.GetCount() >= 2, "Fewer than 2 animal slots. Not going to try and load tennis."))
{
if(m_CurrentTennisSlotLoading >= 2)
{
naWarningf("Trying to load tennis bank with invalid m_CurrentTennisSlotLoading.");
return;
}
audAnimalBankSlot& tennisSlot = m_AnimalBankSlots[m_CurrentTennisSlotLoading];
if(tennisSlot.WaveSlot->GetReferenceCount() != 0)
return;
if(!Verifyf(!tennisSlot.WaveSlot->GetIsLoading(), "Trying to load tennis bank that is already currently loading."))
return;
char voiceName[64];
char bankName[64];
//0th slot is for player
if(m_CurrentTennisSlotLoading == 0)
{
if(!FindPlayerPed())
{
m_CurrentTennisSlotLoading = 1;
naWarningf("Can't find player ped. Won't be loading their tennis bank.");
return;
}
switch(FindPlayerPed()->GetPedType())
{
case PEDTYPE_PLAYER_0: //MICHAEL
safecpy(voiceName, "TENNIS_VFX_MICHAEL");
safecpy(bankName, "ANIMALS_NEAR\\TENNIS_VFX_MICHAEL");
m_TennisPlayerIsMichael = true;
break;
case PEDTYPE_PLAYER_1: //FRANKLIN
safecpy(voiceName, "TENNIS_VFX_FRANKLIN");
safecpy(bankName, "ANIMALS_NEAR\\TENNIS_VFX_FRANKLIN");
m_TennisPlayerIsFranklin = true;
break;
case PEDTYPE_PLAYER_2: //TREVOR
safecpy(voiceName, "TENNIS_VFX_TREVOR");
safecpy(bankName, "ANIMALS_NEAR\\TENNIS_VFX_TREVOR");
m_TennisPlayerIsTrevor = true;
break;
default:
break;
}
}
else if(m_CurrentTennisSlotLoading == 1)
{
if(m_TennisOpponentIsMale)
{
safecpy(voiceName, "TENNIS_VFX_MALE1");
safecpy(bankName, "ANIMALS_NEAR\\TENNIS_VFX_MALE1");
}
else
{
safecpy(voiceName, "TENNIS_VFX_FEMALE1");
safecpy(bankName, "ANIMALS_NEAR\\TENNIS_VFX_FEMALE1");
}
}
else
{
return;
}
tennisSlot.BankdID = audWaveSlot::FindBankId(bankName);
if(!tennisSlot.WaveSlot->LoadBank(tennisSlot.BankdID))
return;
u32 voiceHash = atStringHash(voiceName);
//Fill in info for the audAnimalBankSlot
tennisSlot.IsLoading = true;
tennisSlot.FailedLastTime = false;
tennisSlot.VoiceName = voiceHash;
char context[64];
formatf(context, "%s_LITE", voiceName);
m_NumTennisContextPHashes[m_CurrentTennisSlotLoading][TENNIS_VFX_LITE] = atPartialStringHash(context);
m_NumTennisVariations[m_CurrentTennisSlotLoading][TENNIS_VFX_LITE] = audSpeechSound::FindNumVariationsForVoiceAndContext(voiceHash, atPartialStringHash(context));
m_LastTennisVariations[m_CurrentTennisSlotLoading][TENNIS_VFX_LITE] = 0;
formatf(context, "%s_MED", voiceName);
m_NumTennisContextPHashes[m_CurrentTennisSlotLoading][TENNIS_VFX_MED] = atPartialStringHash(context);
m_NumTennisVariations[m_CurrentTennisSlotLoading][TENNIS_VFX_MED] = audSpeechSound::FindNumVariationsForVoiceAndContext(voiceHash, atPartialStringHash(context));
m_LastTennisVariations[m_CurrentTennisSlotLoading][TENNIS_VFX_MED] = 0;
formatf(context, "%s_STRONG", voiceName);
m_NumTennisContextPHashes[m_CurrentTennisSlotLoading][TENNIS_VFX_STRONG] = atPartialStringHash(context);
m_NumTennisVariations[m_CurrentTennisSlotLoading][TENNIS_VFX_STRONG] = audSpeechSound::FindNumVariationsForVoiceAndContext(voiceHash, atPartialStringHash(context));
m_LastTennisVariations[m_CurrentTennisSlotLoading][TENNIS_VFX_STRONG] = 0;
}
}
audWaveSlot* audSpeechManager::GetTennisVocalizationInfo(CPed* m_Parent, const TennisVocalEffectType& tennisVFXType, u32& contextPhash, u32& voiceHash,
u32& variation)
{
if(!m_Parent || tennisVFXType >= AUD_NUM_TENNIS_VFX_TYPES || tennisVFXType < 0)
return NULL;
u8 speakerTypeIndex = 0; //0 for player
switch(m_Parent->GetPedType())
{
case PEDTYPE_PLAYER_0: //MICHAEL
if(!m_TennisPlayerIsMichael)
return NULL;
break;
case PEDTYPE_PLAYER_1: //FRANKLIN
if(!m_TennisPlayerIsFranklin)
return NULL;
break;
case PEDTYPE_PLAYER_2: //TREVOR
if(!m_TennisPlayerIsTrevor)
return NULL;
break;
default:
speakerTypeIndex = 1;
if(m_Parent != m_TennisOpponent)
return NULL;
if( (m_Parent->IsMale() && !m_TennisOpponentIsMale) || (!m_Parent->IsMale() && m_TennisOpponentIsMale) )
return NULL;
break;
}
contextPhash = m_NumTennisContextPHashes[speakerTypeIndex][tennisVFXType];
voiceHash = m_AnimalBankSlots[speakerTypeIndex].VoiceName;
if(m_NumTennisVariations[speakerTypeIndex][tennisVFXType] > 1)
{
variation = audEngineUtil::GetRandomNumberInRange(1, m_NumTennisVariations[speakerTypeIndex][tennisVFXType]);
if(variation == m_LastTennisVariations[speakerTypeIndex][tennisVFXType])
{
variation = (variation % m_NumTennisVariations[speakerTypeIndex][tennisVFXType]) + 1;
}
}
else
{
variation = m_NumTennisVariations[speakerTypeIndex][tennisVFXType];
}
m_LastTennisVariations[speakerTypeIndex][tennisVFXType] = variation;
return m_AnimalBankSlots[speakerTypeIndex].WaveSlot;
}
int CbCompareAnimalStructs(const void* pVoidA, const void* pVoidB)
{
const audAnimalQSortStruct* pA = (const audAnimalQSortStruct*)pVoidA;
const audAnimalQSortStruct* pB = (const audAnimalQSortStruct*)pVoidB;
return pA->Priority > pB->Priority ? -1 : (pA->Priority == pB->Priority ? 0 : 1);
}
void audSpeechManager::SortAnimalList(audAnimalQSortStruct* outList)
{
CPed* playerPed = FindPlayerPed();
s32 playerAnimalIndex = ANIMALTYPE_MAX;
if(playerPed && playerPed->GetSpeechAudioEntity() && playerPed->GetSpeechAudioEntity()->IsAnimal())
{
playerAnimalIndex = playerPed->GetSpeechAudioEntity()->GetAnimalType();
}
for(int i=0; i<ANIMALTYPE_MAX; ++i)
{
//Do whatever kind of priority calculations we want to here. For now, just take the number of times this kind of
// animal has been seen since the last frame and multiply by its base priority.
AnimalParams* params = m_AnimalInfoArray[i].Data;
m_AnimalInfoArray[i].Priority = 0.0f;
if(i == playerAnimalIndex)
{
m_AnimalInfoArray[i].Priority = 10000.0f; // boost the players animal bank to make sure their bank gets loaded
}
if(params)
{
f32 distanceScalar = m_NearestAnimalAppearancesSinceLastUpdate[i] < 0.0f ?
0.0f :
Clamp( 1.0f - (m_NearestAnimalAppearancesSinceLastUpdate[i]/ (params->MaxDistanceToBankLoad * params->MaxDistanceToBankLoad) ), 0.05f, 1.0f );
m_AnimalInfoArray[i].Priority = Max(4.0f, (f32)m_NumAnimalAppearancesSinceLastUpdate[i]) * distanceScalar * (f32)params->BasePriority;
}
outList[i].AnimalType = (AnimalType)i;
outList[i].Priority = m_AnimalInfoArray[i].Priority;
m_NumAnimalAppearancesSinceLastUpdate[i] = 0;
m_NearestAnimalAppearancesSinceLastUpdate[i] = -1.0f;
}
qsort(outList,ANIMALTYPE_MAX,sizeof(audAnimalQSortStruct),CbCompareAnimalStructs);
}
s32 audSpeechManager::GetVariationForNearAnimalContext(AnimalType animalType, const char* context)
{
return GetVariationForNearAnimalContext(animalType, atPartialStringHash(context));
}
s32 audSpeechManager::GetVariationForNearAnimalContext(AnimalType animalType, u32 contextPHash)
{
if(m_AnimalInfoArray[animalType].SlotNumber == -1)
return -1;
audAnimalBankSlot& bankSlot = m_AnimalBankSlots[m_AnimalInfoArray[animalType].SlotNumber];
for(int i=0; i<bankSlot.ContextInfo.GetCount(); ++i)
{
if(bankSlot.ContextInfo[i].ContextPHash == contextPHash)
{
if(bankSlot.ContextInfo[i].MinTimeBetween >= 0 &&
bankSlot.ContextInfo[i].NextTimeCanPlay > g_AudioEngine.GetSoundManager().GetTimeInMilliseconds(0))
return -1;
bankSlot.ContextInfo[i].LastVarUsed++;
if(bankSlot.ContextInfo[i].LastVarUsed > bankSlot.ContextInfo[i].NumVars)
{
bankSlot.ContextInfo[i].LastVarUsed = 1;
if(bankSlot.ContextInfo[i].UsedUp == -1)
bankSlot.ContextInfo[i].UsedUp = 3;
}
return bankSlot.ContextInfo[i].LastVarUsed;
}
}
return -1;
}
void audSpeechManager::NearAnimalContextPlayed(AnimalType animalType, u32 contextPHash)
{
if(m_AnimalInfoArray[animalType].SlotNumber == -1)
return;
audAnimalBankSlot& bankSlot = m_AnimalBankSlots[m_AnimalInfoArray[animalType].SlotNumber];
for(int i=0; i<bankSlot.ContextInfo.GetCount(); ++i)
{
if(bankSlot.ContextInfo[i].ContextPHash == contextPHash)
{
if(bankSlot.ContextInfo[i].MaxTimeBetween != -1)
{
s32 timeTilNext = audEngineUtil::GetRandomNumberInRange(bankSlot.ContextInfo[i].MinTimeBetween, bankSlot.ContextInfo[i].MaxTimeBetween);
bankSlot.ContextInfo[i].NextTimeCanPlay = g_AudioEngine.GetSoundManager().GetTimeInMilliseconds(0) + timeTilNext;
}
return;
}
}
}
void audSpeechManager::FarAnimalContextPlayed(u32 contextPHash, u32 timeInMs)
{
s32 contextIndex = -1;
for(int i=0; i<NUM_TIME_LIMITED_ANIMAL_FAR_CONTEXTS && contextIndex<0; i++)
{
if(g_TimeLimitedAnimalFarContextsPHashes[i] == contextPHash)
contextIndex = i;
}
if(contextIndex < 0)
return;
g_TimeLimitedAnimalFarContextsLastPlayTime[contextIndex] = timeInMs;
}
bool audSpeechManager::CanFarAnimalContextPlayed(u32 contextPHash, u32 timeInMs)
{
s32 contextIndex = -1;
for(int i=0; i<NUM_TIME_LIMITED_ANIMAL_FAR_CONTEXTS && contextIndex<0; i++)
{
if(g_TimeLimitedAnimalFarContextsPHashes[i] == contextPHash)
contextIndex = i;
}
if(contextIndex < 0)
return true;
return g_TimeLimitedAnimalFarContextsLastPlayTime[contextIndex] + g_TimeLimitedAnimalFarContextsMinTimeBetween[contextIndex] < timeInMs;
}
void audSpeechManager::GetWaveSlotAndVoiceNameForAnimal(AnimalType animalType, audWaveSlot*& waveSlot, u32& voiceName)
{
if(m_AnimalInfoArray[animalType].SlotNumber == -1 || m_AnimalBankSlots[m_AnimalInfoArray[animalType].SlotNumber].IsLoading ||
m_AnimalBankSlots[m_AnimalInfoArray[animalType].SlotNumber].Owner != animalType)
return;
waveSlot = m_AnimalBankSlots[m_AnimalInfoArray[animalType].SlotNumber].WaveSlot;
voiceName = m_AnimalBankSlots[m_AnimalInfoArray[animalType].SlotNumber].VoiceName;
}
void audSpeechManager::SetIfNearestAnimalInstance(AnimalType animalType, Vec3V_In pos)
{
float distSq = VEC3V_TO_VECTOR3((g_AudioEngine.GetEnvironment().GetVolumeListenerPosition() - pos)).Mag2();
if(m_NearestAnimalAppearancesSinceLastUpdate[animalType] < 0.0f ||
m_NearestAnimalAppearancesSinceLastUpdate[animalType] > distSq)
{
m_NearestAnimalAppearancesSinceLastUpdate[animalType] = distSq;
}
}
void audSpeechManager::IncrementAnimalsMakingSound(AnimalType animalType)
{
Assert(animalType < ANIMALTYPE_MAX);
m_NumAnimalsMakingSound[animalType]++;
}
void audSpeechManager::DecrementAnimalsMakingSound(AnimalType animalType)
{
if(m_NumAnimalsMakingSound[animalType] == 0)
{
Warningf("Attempting to decrement m_NumAnimalsMakingSound when it's already 0.");
return;
}
Assert(animalType < ANIMALTYPE_MAX);
m_NumAnimalsMakingSound[animalType]--;
}
u8 audSpeechManager::GetNumAnimalsMakingSound(AnimalType animalType)
{
Assert(animalType < ANIMALTYPE_MAX);
return m_NumAnimalsMakingSound[animalType];
}
bool audSpeechManager::IsStreamingBusyForContext(u32 UNUSED_PARAM(contextPHash))
{
if (g_StreamingSchmeaming)
{
return false;
}
// Don't play ambient speech if streaming stuff right in front of us.
if (strStreamingEngine::GetIsLoadingPriorityObjects())
{
return true;
}
// What the hell, let's just play everything if streaming's not busy - no reason not to
return false;
/*
// For now, just see how fast the player car's going, and don't allow anything other than DIVE or CRASH_CAR/etc if it's quick.
if (!strcmp(context, "DIVE") || !strcmp(context, "CRASH_CAR") || !strcmp(context, "CRASH_BIKE") || !strcmp(context, "CRASH_GENERIC") ||
!strcmp(context, "CRASH_CAR_DRIVEN"))
{
return false;
}
CVehicle* pVehicle = CGameWorld::FindLocalPlayerVehicle();
if (pVehicle && pVehicle->GetMoveSpeed().Mag2() > 40.0f)
{
return true;
}
return false;
*/
}
void audSpeechManager::ReserveAmbientSpeechSlotForScript()
{
if(m_ScriptOwningReservedSlot != 0)
return;
scrThreadId scriptID = CTheScripts::GetCurrentGtaScriptThread()->GetThreadId();
bool hadToStop;
s32 slot = GetAmbientSpeechSlot(NULL, &hadToStop, -1.0f);
if(!hadToStop)
{
Assign(m_ScriptReservedSlotNum, (u32)slot);
m_ScriptOwningReservedSlot = scriptID;
m_AmbientSpeechSlots[m_ScriptReservedSlotNum].PlayState = AUD_SPEECH_SLOT_VACANT;
g_SpeechManager.PopulateAmbientSpeechSlotWithPlayingSpeechInfo(slot, 0,
#if __BANK
"SCRIPT_RESERVED",
#endif
0);
}
else
{
FreeAmbientSpeechSlot(slot, true);
}
}
void audSpeechManager::ReleaseAmbientSpeechSlotForScript()
{
scrThreadId scriptID = CTheScripts::GetCurrentGtaScriptThread()->GetThreadId();
if(m_ScriptOwningReservedSlot == 0)
{
#if !__FINAL
GtaThread* pThread = static_cast<GtaThread*>(scrThread::GetThread(scriptID));
Warningf("Script with id %u and name %s attempting to release reserved speech slot when no speech slot has been reserved.",
scriptID, pThread ? pThread->GetScriptName(): "unknown");
#endif
return;
}
if(scriptID != m_ScriptOwningReservedSlot)
{
#if !__FINAL
GtaThread* pThread1 = static_cast<GtaThread*>(scrThread::GetThread(scriptID));
GtaThread* pThread2 = static_cast<GtaThread*>(scrThread::GetThread(m_ScriptOwningReservedSlot));
Warningf("Script with id %u and name %s attempting to release reserved speech slot when it is actually reserved by script with id %u and name %s.",
scriptID, pThread1 ? pThread1->GetScriptName(): "unknown", m_ScriptOwningReservedSlot, pThread2 ? pThread2->GetScriptName(): "unknown");
#endif
return;
}
FreeAmbientSpeechSlot(m_ScriptReservedSlotNum, true);
m_ScriptReservedSlotNum = 0;
m_ScriptOwningReservedSlot = THREAD_INVALID;
}
#if GTA_REPLAY
void audSpeechManager::FreeAllAmbientSpeechSlots()
{
if(m_ChurnSpeechSound)
{
m_ChurnSpeechSound->StopAndForget();
}
for (int i=0; i<g_MaxAmbientSpeechSlots; i++)
{
m_AmbientSpeechSlots[i].SpeechAudioEntity = NULL;
m_AmbientSpeechSlots[i].PlayState = AUD_SPEECH_SLOT_STOPPING;
Assert(m_AmbientSpeechSlots[i].WaveSlot);
if (m_AmbientSpeechSlots[i].WaveSlot->GetReferenceCount() == 0)
{
// Slot's finished
m_AmbientSpeechSlots[i].PlayState = AUD_SPEECH_SLOT_VACANT;
}
}
}
#endif
s32 audSpeechManager::GetAmbientSpeechSlot(audSpeechAudioEntity* requestingEntity, bool* hadToStopSpeech, f32 priority, scrThreadId scriptThreadId
#if AUD_DEFERRED_SPEECH_DEBUG_PRINT
, const char* context
#endif
, bool isHeli)
{
if(hadToStopSpeech)
*hadToStopSpeech = false;
if(m_ScriptOwningReservedSlot != 0 && scriptThreadId == m_ScriptOwningReservedSlot &&
m_AmbientSpeechSlots[m_ScriptReservedSlotNum].PlayState == AUD_SPEECH_SLOT_VACANT)
{
m_AmbientSpeechSlots[m_ScriptReservedSlotNum].PlayState = AUD_SPEECH_SLOT_ALLOCATED;
m_AmbientSpeechSlots[m_ScriptReservedSlotNum].SpeechAudioEntity = requestingEntity;
return m_ScriptReservedSlotNum;
}
f32 requestingPriority = GetRealAmbientSpeechPriority(requestingEntity, priority);
f32 lowestAllocatedPriority = -1.0f;
s32 lowestPrioritySlot = -1;
#if AUD_DEFERRED_SPEECH_DEBUG_PRINT
atRangeArray<f32, g_MaxAmbientSpeechSlots+1> debugPriority;
atRangeArray<f32, g_MaxAmbientSpeechSlots+1> debugRealPriority;
atRangeArray<f32, g_MaxAmbientSpeechSlots+1> debugDist2;
debugPriority[g_MaxAmbientSpeechSlots] = priority;
debugRealPriority[g_MaxAmbientSpeechSlots] = requestingPriority;
debugDist2[g_MaxAmbientSpeechSlots] = 0.0f;
if(requestingEntity)
{
CPed* parent = requestingEntity->GetParent();
if(parent)
debugDist2[g_MaxAmbientSpeechSlots] = (VEC3V_TO_VECTOR3(parent->GetMatrix().d()) - VEC3V_TO_VECTOR3(g_AudioEngine.GetEnvironment().GetVolumeListenerPosition())).Mag2();
}
#endif
// See if we've got a vacant slot. Don't allocate STOPPING ones for just now, for simplicity. And don't allow forcing out of less important ones.
for (s32 index=0; index<g_MaxAmbientSpeechSlots; index++)
{
int i = (m_AmbientSpeechSlotToNextSearchFrom + index) % g_MaxAmbientSpeechSlots;
if(m_AmbientSpeechSlots[i].PlayState == AUD_SPEECH_SLOT_VACANT)
{
//Allocate it, and return the slot number.
m_AmbientSpeechSlots[i].PlayState = AUD_SPEECH_SLOT_ALLOCATED;
m_AmbientSpeechSlots[i].SpeechAudioEntity = requestingEntity;
m_AmbientSpeechSlots[i].Priority = priority;
m_AmbientSpeechSlotToNextSearchFrom = (u8)((i+1)%g_MaxAmbientSpeechSlots);
return i;
}
f32 allocatedPriority = GetRealAmbientSpeechPriority(m_AmbientSpeechSlots[i].SpeechAudioEntity, m_AmbientSpeechSlots[i].Priority);
//For now, only kick speech off if it has a valid entity. Otherwise, we'll end up trying to call FreeSlot on the NULL entity and crashing.
//Even if we just free the slot through the speech manager, this really only marks it as stopping. We'll need a pointer to the sound
// or the ability to stop all sounds on a slot to really make it worth the effort of stealing slots with no entity.
if(m_AmbientSpeechSlots[i].SpeechAudioEntity && (lowestAllocatedPriority==-1 || allocatedPriority<lowestAllocatedPriority))
{
lowestPrioritySlot = i;
lowestAllocatedPriority = allocatedPriority;
}
#if AUD_DEFERRED_SPEECH_DEBUG_PRINT
debugPriority[i] = m_AmbientSpeechSlots[i].Priority;
debugRealPriority[i] = allocatedPriority;
debugDist2[i] = 0.0f;
if(m_AmbientSpeechSlots[i].SpeechAudioEntity)
{
CPed* parent = m_AmbientSpeechSlots[i].SpeechAudioEntity->GetParent();
if(parent)
debugDist2[i] = (VEC3V_TO_VECTOR3(parent->GetMatrix().d() - g_AudioEngine.GetEnvironment().GetVolumeListenerPosition())).Mag2();
}
#endif
}
//Some things, such as animal sounds or requests from script to reserve a slot, should never kick stuff out of slots.
if(priority < 0.0f)
return -1;
// We don't have any free. See if the lowest priority allocated slot is worth kicking out.
// For now, don't kick out already playing speech for something that doesn't have a valid requestingEntity
// Also, don't allow this to happen if we don't have a valid hadToStopSpeech pointer through which to notify our speechEntity that it
// should go into deferred speech mode.
// The check for a valid SpeechAudioEntity shouldn't be required, as this is checked before we mark the slot as lowest priority.
if(hadToStopSpeech && (requestingEntity || isHeli) && lowestPrioritySlot>-1 && requestingPriority > lowestAllocatedPriority
&& m_AmbientSpeechSlots[lowestPrioritySlot].SpeechAudioEntity)
{
m_AmbientSpeechSlots[lowestPrioritySlot].SpeechAudioEntity->FreeSlot();
*hadToStopSpeech = true;
#if AUD_DEFERRED_SPEECH_DEBUG_PRINT
audWarningf("[DEFERRED SPEECH] Incoming: Context: %s, Prio: %.02f, Real Prio: %.02f, Dist2: %.02f", context, debugPriority[g_MaxAmbientSpeechSlots], debugRealPriority[g_MaxAmbientSpeechSlots], debugDist2[g_MaxAmbientSpeechSlots]);
for (u32 i = 0; i < g_MaxAmbientSpeechSlots; i++)
{
char cxt[64];
cxt[0] = '\0';
if (m_AmbientSpeechSlots[i].SpeechAudioEntity)
{
m_AmbientSpeechSlots[i].SpeechAudioEntity->GetCurrentlyPlayingWaveName(cxt);
}
audWarningf("[DEFERRED SPEECH] Slot %d: Context: %s, Prio: %.02f, Real Prio: %.02f, Dist2: %.02f", i, cxt, debugPriority[i], debugRealPriority[i], debugDist2[i]);
}
audWarningf("[DEFERRED SPEECH] Slot Given: %i, from entity %p to entity %p", lowestPrioritySlot, m_AmbientSpeechSlots[lowestPrioritySlot].SpeechAudioEntity, requestingEntity);
#endif
return lowestPrioritySlot;
}
return -1;
}
f32 audSpeechManager::GetRealAmbientSpeechPriority(audSpeechAudioEntity* requestingEntity, f32 priority)
{
if(requestingEntity)
{
CPed* parent = requestingEntity->GetParent();
if(parent)
{
f32 dist2 = (VEC3V_TO_VECTOR3(parent->GetMatrix().d() - g_AudioEngine.GetEnvironment().GetVolumeListenerPosition())).Mag2();
priority = g_DistanceSqToPriorityScalarCurve.CalculateValue(dist2) * priority;
}
}
return priority;
}
void audSpeechManager::MarkSlotAsAllocated(int slotIndex, audSpeechAudioEntity* requestingEntity, f32 priority)
{
naAssertf(m_AmbientSpeechSlots[slotIndex].PlayState==AUD_SPEECH_SLOT_VACANT || (m_AmbientSpeechSlots[slotIndex].PlayState==AUD_SPEECH_SLOT_ALLOCATED && m_AmbientSpeechSlots[slotIndex].SpeechAudioEntity == requestingEntity), "Trying to mark speech slot as allocated when it isn't vacant yet. THIS IS VERY BAD!!!");
m_AmbientSpeechSlots[slotIndex].PlayState = AUD_SPEECH_SLOT_ALLOCATED;
m_AmbientSpeechSlots[slotIndex].SpeechAudioEntity = requestingEntity;
m_AmbientSpeechSlots[slotIndex].Priority = priority;
}
void audSpeechManager::FreeAmbientSpeechSlot(s32 slot, bool BANK_ONLY(okForEntityToBeNull))
{
// Remove the audio entity reference, and mark the slot as stopping or vacant, depending on the wave slot's state.
// (smoother to just let the Update() do the STOPPING->VACANT change, but it'd be good to synchronously free the slot - bound to need that at some point)
naAssertf(slot>=0 && slot<g_MaxAmbientSpeechSlots, "Slot index is out of bounds");
#if __BANK
if(m_AmbientSpeechSlots[slot].SpeechAudioEntity == NULL && !okForEntityToBeNull)
{
REPLAY_ONLY(if(!CReplayMgr::IsEditModeActive()))
{
Warningf("Ambient speech slot has no speech audio entity and it's not ok for it to be null when attempting to free ambient speech");
}
}
#endif
m_AmbientSpeechSlots[slot].SpeechAudioEntity = NULL;
m_AmbientSpeechSlots[slot].Priority = 0;
if (m_AmbientSpeechSlots[slot].WaveSlot->GetReferenceCount() == 0)
{
m_AmbientSpeechSlots[slot].PlayState = AUD_SPEECH_SLOT_VACANT;
}
else
{
m_AmbientSpeechSlots[slot].PlayState = AUD_SPEECH_SLOT_STOPPING;
//RK - TODO: Deal with Walla
}
}
void audSpeechManager::PopulateAmbientSpeechSlotWithPlayingSpeechInfo(s32 slot, u32 voiceName,
#if __BANK
const char* context,
#endif
s32 variation)
{
naAssertf(slot>=0 && slot<g_MaxAmbientSpeechSlots, "Slot index passed into PopulateAmbientSpeechSlotWithPlayingSpeechInfo is out of bounds");
m_AmbientSpeechSlots[slot].Voicename = voiceName;
#if __BANK
sprintf(m_AmbientSpeechSlots[slot].Context, "%s", context);
#endif
m_AmbientSpeechSlots[slot].VariationNumber = variation;
}
bool audSpeechManager::IsSlotVacant(s32 slotIndex)
{
naAssertf(slotIndex>=0 && slotIndex<g_MaxAmbientSpeechSlots, "Slot index passed into PopulateAmbientSpeechSlotWithPlayingSpeechInfo is out of bounds");
return m_AmbientSpeechSlots[slotIndex].PlayState == AUD_SPEECH_SLOT_VACANT;
}
bool audSpeechManager::IsSafeToReuseSlot(s32 slotIndex, const audSpeechAudioEntity* entity)
{
naAssertf(slotIndex >= 0 && slotIndex < g_MaxAmbientSpeechSlots, "Slot index passed into CanSlotBeReused is out of bounds");
return m_AmbientSpeechSlots[slotIndex].PlayState == AUD_SPEECH_SLOT_ALLOCATED && m_AmbientSpeechSlots[slotIndex].SpeechAudioEntity == entity && m_AmbientSpeechSlots[slotIndex].WaveSlot->GetReferenceCount() == 0;
}
bool audSpeechManager::IsScriptSpeechSlotVacant(s32 slotIndex)
{
naAssertf(slotIndex>=0 && slotIndex<g_MaxScriptedSpeechSlots, "Slot index passed into IsScriptSpeechSlotVacant is out of bounds");
return m_ScriptedSpeechSlots[slotIndex].PlayState == AUD_SPEECH_SLOT_VACANT;
}
s32 audSpeechManager::GetScriptSpeechSlotRefCount(s32 slotIndex)
{
if(m_ScriptedSpeechSlots[slotIndex].WaveSlot)
{
return m_ScriptedSpeechSlots[slotIndex].WaveSlot->GetReferenceCount();
}
return 0;
}
s32 audSpeechManager::GetScriptedSpeechSlot(audSpeechAudioEntity* requestingEntity)
{
// See if we've got a vacant slot. Don't allocate STOPPING ones for just now, for simplicity.
// We may do this differently - is it ever acceptable to not give a script a slot when it thinks it needs one?
for (s32 i=0; i<g_MaxScriptedSpeechSlots; i++)
{
if (m_ScriptedSpeechSlots[i].PlayState == AUD_SPEECH_SLOT_VACANT)
{
// Allocate it, and return the slot number.
m_ScriptedSpeechSlots[i].PlayState = AUD_SPEECH_SLOT_ALLOCATED;
m_ScriptedSpeechSlots[i].SpeechAudioEntity = requestingEntity;
return i;
}
}
// We don't have any free.
return -1;
}
u32 audSpeechManager::GetNumVacantAmbientSlots()
{
u32 numVacant = 0;
for(s32 loop = 0; loop < g_MaxAmbientSpeechSlots; loop++)
{
if(m_AmbientSpeechSlots[loop].PlayState == AUD_SPEECH_SLOT_VACANT)
{
numVacant++;
}
}
return numVacant;
}
void audSpeechManager::FreeAllScriptedSpeechSlots()
{
for(int i=0; i<g_MaxScriptedSpeechSlots; i++)
{
FreeScriptedSpeechSlot(i);
}
}
void audSpeechManager::FreeScriptedSpeechSlot(s32 slot)
{
// Remove the audio entity reference, and mark the slot as stopping or vacant, depending on the wave slot's state.
// (smoother to just let the Update() do the STOPPING->VACANT change, but it'd be good to synchronously free the slot - bound to need that at some point)
naAssertf(slot>=0 && slot<g_MaxScriptedSpeechSlots, "Slot index %d passed into FreeScriptedSpeechSlot is invalid", slot);
m_ScriptedSpeechSlots[slot].SpeechAudioEntity = NULL;
if (m_ScriptedSpeechSlots[slot].WaveSlot->GetReferenceCount() == 0)
{
m_ScriptedSpeechSlots[slot].PlayState = AUD_SPEECH_SLOT_VACANT;
}
else
{
m_ScriptedSpeechSlots[slot].PlayState = AUD_SPEECH_SLOT_STOPPING;
}
}
s32 audSpeechManager::WhenWasVariationLastPlayed(u32 voiceHash, u32 contextHash, u32 variationNum, u32& timeInMs)
{
// Search through the history, and see if the voice and variation combo are in it.
// We're currently pointing at the next slot to write into, m_NextPhraseMemoryWriteIndex
// Indices are correct but not obvious - we go from the previous index backwards (+g_PhraseMemorySize is there because I don't trust -ve modding)
for (u32 i=1; i<=g_PhraseMemorySize; i++)
{
u32 phraseMemoryIndex = (m_NextPhraseMemoryWriteIndex - i + g_PhraseMemorySize) % g_PhraseMemorySize;
if (m_PhraseMemory[phraseMemoryIndex][0] == voiceHash &&
m_PhraseMemory[phraseMemoryIndex][1] == contextHash &&
m_PhraseMemory[phraseMemoryIndex][2] == variationNum)
{
// This combo is in the history, return how long ago (in num phrases, not time) it was played.
timeInMs = m_PhraseMemory[phraseMemoryIndex][3];
return (i-1);
}
}
// We never found it, it's not in the history
timeInMs = 0;
return -1;
}
void audSpeechManager::BuildMemoryListForVoiceAndContext(u32 voiceHash, u32 contextHash, u32& memorySize, u32 aPhraseMemory[g_PhraseMemorySize][4])
{
// Search through the history, and see if the voice and variation combo are in it.
// We're currently pointing at the next slot to write into, m_NextPhraseMemoryWriteIndex
// Indices are correct but not obvious - we go from the previous index backwards (+g_PhraseMemorySize is there because I don't trust -ve modding)
for (u32 i=1; i<=g_PhraseMemorySize; i++)
{
u32 phraseMemoryIndex = (m_NextPhraseMemoryWriteIndex - i + g_PhraseMemorySize) % g_PhraseMemorySize;
if (m_PhraseMemory[phraseMemoryIndex][0] == voiceHash &&
m_PhraseMemory[phraseMemoryIndex][1] == contextHash )
{
aPhraseMemory[memorySize][0] = m_PhraseMemory[phraseMemoryIndex][0];
aPhraseMemory[memorySize][1] = m_PhraseMemory[phraseMemoryIndex][1];
aPhraseMemory[memorySize][2] = m_PhraseMemory[phraseMemoryIndex][2];
aPhraseMemory[memorySize][3] = m_PhraseMemory[phraseMemoryIndex][3];
++memorySize;
}
}
}
void audSpeechManager::AddVariationToHistory(u32 voiceHash, u32 contextHash, u32 variationNum, u32 timeInMs)
{
m_PhraseMemory[m_NextPhraseMemoryWriteIndex][0] = voiceHash;
m_PhraseMemory[m_NextPhraseMemoryWriteIndex][1] = contextHash;
m_PhraseMemory[m_NextPhraseMemoryWriteIndex][2] = variationNum;
m_PhraseMemory[m_NextPhraseMemoryWriteIndex][3] = timeInMs;
m_NextPhraseMemoryWriteIndex = (m_NextPhraseMemoryWriteIndex + 1) % g_PhraseMemorySize;
if (m_NextPhraseMemoryWriteIndex==0)
{
naWarningf("Burnt through all our speech memory. Time: %u", fwTimer::GetTimeInMilliseconds());
}
}
void audSpeechManager::GetTimeWhenContextCanNextPlay(SpeechContext *speechContext, u32* timeCanNextPlay, bool* isControlledByContext)
{
naAssertf(speechContext || !g_bSpeechAsserts, "Invalid SpeechContext passed into GetTimeWhenContextCanNextPlay");
naAssertf(timeCanNextPlay || !g_bSpeechAsserts, "Invalid u32* passed into GetTimeWhenContextCanNextPlay");
naAssertf(isControlledByContext || !g_bSpeechAsserts, "Invalid bool* parameter passed into GetTimeWhenContextCanNextPlay");
if (speechContext && speechContext->RepeatTime > -1)
{
*timeCanNextPlay = speechContext->TimeCanNextPlay;
*isControlledByContext = true;
}
else
{
*timeCanNextPlay = 0;
*isControlledByContext = false;
}
}
void audSpeechManager::GetTimeWhenTriggeredPrimaryContextCanNextPlay(TriggeredSpeechContext *speechContext, u32* timeCanNextPlay, bool* isControlledByContext)
{
naAssertf(speechContext || !g_bSpeechAsserts, "Invalid SpeechContext passed into GetTimeWhenContextCanNextPlay");
naAssertf(timeCanNextPlay || !g_bSpeechAsserts, "Invalid u32* passed into GetTimeWhenContextCanNextPlay");
naAssertf(isControlledByContext || !g_bSpeechAsserts, "Invalid bool* parameter passed into GetTimeWhenContextCanNextPlay");
if (speechContext && speechContext->PrimaryRepeatTime > -1)
{
*timeCanNextPlay = speechContext->TimeCanNextPlayPrimary;
*isControlledByContext = true;
}
else
{
*timeCanNextPlay = 0;
*isControlledByContext = false;
}
}
void audSpeechManager::GetTimeWhenTriggeredBackupContextCanNextPlay(TriggeredSpeechContext *speechContext, u32* timeCanNextPlay, bool* isControlledByContext)
{
naAssertf(speechContext || !g_bSpeechAsserts, "Invalid SpeechContext passed into GetTimeWhenContextCanNextPlay");
naAssertf(timeCanNextPlay || !g_bSpeechAsserts, "Invalid u32* passed into GetTimeWhenContextCanNextPlay");
naAssertf(isControlledByContext || !g_bSpeechAsserts, "Invalid bool* parameter passed into GetTimeWhenContextCanNextPlay");
if (speechContext && speechContext->BackupRepeatTime > -1)
{
*timeCanNextPlay = speechContext->TimeCanNextPlayBackup;
*isControlledByContext = true;
}
else
{
*timeCanNextPlay = 0;
*isControlledByContext = false;
}
}
u32 audSpeechManager::GetRepeatTimeContextCanPlayOnVoice(SpeechContext *speechContext)
{
naAssertf(speechContext || !g_bSpeechAsserts, "Invalid SpeechContext passed into GetRepeatTimeContextCanPlayOnVoice");
if (speechContext && speechContext->RepeatTimeOnSameVoice > -1)
{
f32 repeatTime = (f32)speechContext->RepeatTimeOnSameVoice;
u32 randomRepeatTime = (u32)(repeatTime * audEngineUtil::GetRandomNumberInRange(0.8f, 1.2f));
if (randomRepeatTime>50000)
{
randomRepeatTime = 50000;
}
return randomRepeatTime;
}
return audEngineUtil::GetRandomNumberInRange(6500, 10000);
}
u32 audSpeechManager::GetRepeatTimePrimaryTriggeredContextCanPlayOnVoice(TriggeredSpeechContext *speechContext)
{
naAssertf(speechContext || !g_bSpeechAsserts, "Invalid SpeechContext passed into GetRepeatTimeContextCanPlayOnVoice");
if (speechContext && speechContext->PrimaryRepeatTimeOnSameVoice > -1)
{
f32 repeatTime = (f32)speechContext->PrimaryRepeatTimeOnSameVoice;
u32 randomRepeatTime = (u32)(repeatTime * audEngineUtil::GetRandomNumberInRange(0.8f, 1.2f));
if (randomRepeatTime>50000)
{
randomRepeatTime = 50000;
}
return randomRepeatTime;
}
return audEngineUtil::GetRandomNumberInRange(6500, 10000);
}
u32 audSpeechManager::GetRepeatTimeBackupTriggeredContextCanPlayOnVoice(TriggeredSpeechContext *speechContext)
{
naAssertf(speechContext || !g_bSpeechAsserts, "Invalid SpeechContext passed into GetRepeatTimeContextCanPlayOnVoice");
if (speechContext && speechContext->BackupRepeatTimeOnSameVoice > -1)
{
f32 repeatTime = (f32)speechContext->BackupRepeatTimeOnSameVoice;
u32 randomRepeatTime = (u32)(repeatTime * audEngineUtil::GetRandomNumberInRange(0.8f, 1.2f));
if (randomRepeatTime>50000)
{
randomRepeatTime = 50000;
}
return randomRepeatTime;
}
return audEngineUtil::GetRandomNumberInRange(6500, 10000);
}
u32 audSpeechManager::GetTimeLastPlayedForContext(u32 contextPHash)
{
u32 ret = 0;
for (u32 i=0; i<g_PhraseMemorySize; i++)
{
if(m_PhraseMemory[i][1] == contextPHash && ret < m_PhraseMemory[i][3])
ret = m_PhraseMemory[i][3];
}
return ret;
}
void audSpeechManager::UpdateTimeContextWasLastUsed(const char *contextName, CPed* speaker, u32 timeInMs)
{
SpeechContext *speechContext = GetSpeechContext(contextName, speaker, NULL, NULL);
UpdateTimeContextWasLastUsed(speechContext, timeInMs);
}
void audSpeechManager::UpdateTimeContextWasLastUsed(SpeechContext *speechContext, u32 timeInMs)
{
naAssertf(speechContext || !g_bSpeechAsserts, "Invalid SpeechContext passed into UpdateTimeContextWasLastUsed");
if (speechContext && speechContext->RepeatTime > -1)
{
// To avoid things getting all in-sync with each other - our repeat time is randomised between 100% and 125%
s32 repeatTime = audEngineUtil::GetRandomNumberInRange(speechContext->RepeatTime, (s32)(((f32)speechContext->RepeatTime)*1.25f));
speechContext->TimeCanNextPlay = timeInMs + repeatTime;
}
}
void audSpeechManager::UpdateTimeTriggeredContextWasLastUsed(TriggeredSpeechContext* speechContext, u32 timeInMs)
{
naAssertf(speechContext || !g_bSpeechAsserts, "Invalid TriggeredSpeechContext passed into UpdateTimeTriggeredContextWasLastUsed");
if (speechContext && speechContext->TriggeredContextRepeatTime > -1)
{
// To avoid things getting all in-sync with each other - our repeat time is randomised between 100% and 125%
s32 repeatTime = audEngineUtil::GetRandomNumberInRange(speechContext->TriggeredContextRepeatTime, (s32)(((f32)speechContext->TriggeredContextRepeatTime)*1.25f));
speechContext->TimeCanNextUseTriggeredContext= timeInMs + repeatTime;
}
}
void audSpeechManager::UpdateTimePrimaryTriggeredContextWasLastUsed(TriggeredSpeechContext* speechContext, u32 timeInMs)
{
naAssertf(speechContext || !g_bSpeechAsserts, "Invalid TriggeredSpeechContext passed into UpdateTimePrimaryTriggeredContextWasLastUsed");
if (speechContext && speechContext->PrimaryRepeatTime > -1)
{
// To avoid things getting all in-sync with each other - our repeat time is randomised between 100% and 125%
s32 repeatTime = audEngineUtil::GetRandomNumberInRange(speechContext->PrimaryRepeatTime, (s32)(((f32)speechContext->PrimaryRepeatTime)*1.25f));
speechContext->TimeCanNextPlayPrimary = timeInMs + repeatTime;
}
}
void audSpeechManager::UpdateTimeBackupTriggeredContextWasLastUsed(TriggeredSpeechContext* speechContext, u32 timeInMs)
{
naAssertf(speechContext || !g_bSpeechAsserts, "Invalid TriggeredSpeechContext passed into UpdateTimeBackupTriggeredContextWasLastUsed");
if (speechContext && speechContext->BackupRepeatTime > -1)
{
// To avoid things getting all in-sync with each other - our repeat time is randomised between 100% and 125%
s32 repeatTime = audEngineUtil::GetRandomNumberInRange(speechContext->BackupRepeatTime, (s32)(((f32)speechContext->BackupRepeatTime)*1.25f));
speechContext->TimeCanNextPlayBackup = timeInMs + repeatTime;
}
}
u32 audSpeechManager::GetVoiceForPhoneConversation(u32 pedVoiceGroup)
{
PedVoiceGroups* pedVoiceGroupObject = audNorthAudioEngine::GetObject<PedVoiceGroups>(pedVoiceGroup);
if (pedVoiceGroupObject)
{
//0 is the voiceHash, 1 is the num of refs
atMultiRangeArray<u32, g_PhoneConvMemorySize, 2> NumRefsPerVoiceInPhoneHistory;
for(int i=0; i<g_PhoneConvMemorySize; i++)
NumRefsPerVoiceInPhoneHistory[i][0] = 0;
u32 numPedsFound = 0;
for(int i=0; i<pedVoiceGroupObject->numPrimaryVoices; ++i)
{
if(audSpeechSound::FindNumVariationsForVoiceAndContext(pedVoiceGroupObject->PrimaryVoice[i].VoiceName,ATPARTIALSTRINGHASH("PHONE_CONV1_INTRO", 0x8AADB637)) != 0)
{
u32 numRef = 0;
for(int j=0; j<g_PhoneConvMemorySize; ++j)
{
//exit early, as the rest of the history is blank
if(m_PhoneConversationMemory[j][0] == 0)
break;
if(pedVoiceGroupObject->PrimaryVoice[i].VoiceName == m_PhoneConversationMemory[j][0])
numRef++;
}
//if this voice doesn't appear, return it
if(numRef == 0)
{
return pedVoiceGroupObject->PrimaryVoice[i].VoiceName;
}
//otherwise, store it
NumRefsPerVoiceInPhoneHistory[numPedsFound][0] = pedVoiceGroupObject->PrimaryVoice[i].VoiceName;
NumRefsPerVoiceInPhoneHistory[numPedsFound++][1] = numRef;
}
}
u8* p = (u8*)&pedVoiceGroupObject->PrimaryVoice[pedVoiceGroupObject->numPrimaryVoices];
u8 numMiniVoices = *p;
p++;
tVoice* miniVoices = (tVoice*)p;
for(int i=0; i<numMiniVoices; ++i)
{
if(audSpeechSound::FindNumVariationsForVoiceAndContext(miniVoices[i].VoiceName,ATPARTIALSTRINGHASH("PHONE_CONV1_INTRO", 0x8AADB637)) != 0)
{
u32 numRef = 0;
for(int j=0; j<g_PhoneConvMemorySize; ++j)
{
//exit early, as the rest of the history is blank
if(m_PhoneConversationMemory[j][0] == 0)
break;
if(miniVoices[i].VoiceName == m_PhoneConversationMemory[j][0])
numRef++;
}
//if this voice doesn't appear, return it
if(numRef == 0)
{
return miniVoices[i].VoiceName;
}
//otherwise, store it
NumRefsPerVoiceInPhoneHistory[numPedsFound][0] = miniVoices[i].VoiceName;
NumRefsPerVoiceInPhoneHistory[numPedsFound++][1] = numRef;
}
}
p = (u8*)&miniVoices[numMiniVoices];
u8 numGangVoices = *p;
p++;
tVoice* gangVoices = (tVoice*)p;
for(int i=0; i<numGangVoices; ++i)
{
if(audSpeechSound::FindNumVariationsForVoiceAndContext(gangVoices[i].VoiceName,ATPARTIALSTRINGHASH("PHONE_CONV1_INTRO", 0x8AADB637)) != 0)
{
u32 numRef = 0;
for(int j=0; j<g_PhoneConvMemorySize; ++j)
{
//exit early, as the rest of the history is blank
if(m_PhoneConversationMemory[j][0] == 0)
break;
if(gangVoices[i].VoiceName == m_PhoneConversationMemory[j][0])
numRef++;
}
//if this voice doesn't appear, return it
if(numRef == 0)
{
return gangVoices[i].VoiceName;
}
//otherwise, store it
NumRefsPerVoiceInPhoneHistory[numPedsFound][0] = gangVoices[i].VoiceName;
NumRefsPerVoiceInPhoneHistory[numPedsFound++][1] = numRef;
}
}
//All these voices are present in the history, so lets find the one with the lowest ref count, giving priority to the
// earlier ones as they are full ped voices
u32 indexWithLowestRef = 0;
u32 lowestRef = NumRefsPerVoiceInPhoneHistory[0][1];
for(int i=1; i<numPedsFound; i++)
{
if(NumRefsPerVoiceInPhoneHistory[i][1] < lowestRef)
{
lowestRef = NumRefsPerVoiceInPhoneHistory[i][1];
indexWithLowestRef = i;
}
}
return NumRefsPerVoiceInPhoneHistory[indexWithLowestRef][0];
}
return 0;
}
u8 audSpeechManager::GetPhoneConversationVariationFromVoiceHash(u32 voiceHash)
{
if(!Verifyf(voiceHash != 0, "Trying to get a phone conv variation with voiceHash of 0."))
{
return 0;
}
char contextString[32];
safecpy(contextString, "PHONE_CONV1_INTRO");
if(audSpeechSound::FindNumVariationsForVoiceAndContext(voiceHash,atPartialStringHash(contextString)) == 0)
{
naAssertf(0, "voiceHash %i attempting to get phone conversation variation when it has none.", voiceHash);
return 0;
}
u32 numVariations=0;
while(numVariations<AUD_MAX_PHONE_CONVERSATIONS_PER_VOICE)
{
numVariations++;
formatf(contextString, "PHONE_CONV%i_INTRO", numVariations);
if(audSpeechSound::FindNumVariationsForVoiceAndContext(voiceHash,atPartialStringHash(contextString)) == 0)
break;
}
//numVariations is now one higher than the highest valid variation we have, so decrement
numVariations--;
atArray<bool> varFound;
varFound.Reset();
varFound.Resize(numVariations);
for(int i=0; i<numVariations; ++i)
varFound[i] = false;
u8 variationPlayedLongestAgo = 0;
u32 timeLongestVariationAgoPlayed = 0;
u8 numVariationsNotInHistory = static_cast<u8>(numVariations);
for(int i = 0; i< g_PhoneConvMemorySize; ++i)
{
if(m_PhoneConversationMemory[i][0] == 0)
{
//exit early...the rest of the history is blank
break;
}
if(voiceHash == m_PhoneConversationMemory[i][0])
{
numVariationsNotInHistory--;
varFound[m_PhoneConversationMemory[i][1]-1] = true; //minus 1, as conversation variations aren't 0 indexed
if(variationPlayedLongestAgo==0 || timeLongestVariationAgoPlayed > m_PhoneConversationMemory[i][2])
{
variationPlayedLongestAgo = static_cast<u8>(m_PhoneConversationMemory[i][1]);
timeLongestVariationAgoPlayed = m_PhoneConversationMemory[i][2];
}
}
}
//If the history holds no conversation for this voice, return a randome one
if(numVariationsNotInHistory == numVariations)
return static_cast<u8>((audEngineUtil::GetRandomInteger() % numVariations) + 1);
//If there are variations not in the history, pick a random one and return that
if(numVariationsNotInHistory != 0)
{
u8 startPos = static_cast<u8>(audEngineUtil::GetRandomInteger() % numVariations);
for(u8 i=0; i<numVariations; i++)
{
u8 index = (startPos + i) % numVariations;
if(!varFound[index])
return index+1; //plus 1, as conversation variations aren't 0 indexed
}
}
//otherwise, return the oldest variation we found if it's been long enough since it last played
if(fwTimer::GetTimeInMilliseconds() - timeLongestVariationAgoPlayed < g_MinTimeBetweenSameVariationOfPhoneCall)
return 0;
return variationPlayedLongestAgo;
}
void audSpeechManager::AddPhoneConversationVariationToHistory(u32 voiceHash, u32 variation, u32 timeInMs)
{
for(int i = 0; i< g_PhoneConvMemorySize; ++i)
{
if(m_PhoneConversationMemory[i][0] == voiceHash && m_PhoneConversationMemory[i][1] == variation)
{
m_PhoneConversationMemory[i][2] = timeInMs;
return;
}
}
m_PhoneConversationMemory[m_NextPhoneConvMemoryWriteIndex][0] = voiceHash;
m_PhoneConversationMemory[m_NextPhoneConvMemoryWriteIndex][1] = variation;
m_PhoneConversationMemory[m_NextPhoneConvMemoryWriteIndex][2] = timeInMs;
m_NextPhoneConvMemoryWriteIndex = (m_NextPhoneConvMemoryWriteIndex + 1) % g_PhoneConvMemorySize;
}
s32 audSpeechManager::WhenWasPhoneConversationLastPlayed(u32 voiceHash, u32 variation, u32& timeInMs)
{
for(int i = 0; i< g_PhoneConvMemorySize; ++i)
{
if(m_PhoneConversationMemory[i][0] == voiceHash && m_PhoneConversationMemory[i][1] == variation)
{
timeInMs = m_PhoneConversationMemory[i][2];
return i;
}
}
timeInMs = 0u;
return -1;
}
SpeechContext *audSpeechManager::GetSpeechContext(const char* contextName, CPed* speaker, bool* returningDefault)
{
u32 contextHash = atStringHash(contextName);
return GetSpeechContext(contextHash, speaker, NULL, returningDefault);
}
SpeechContext *audSpeechManager::GetSpeechContext(const char* contextName, CPed* speaker, CPed* replyingPed, bool* returningDefault)
{
u32 contextHash = atStringHash(contextName);
return GetSpeechContext(contextHash, speaker, replyingPed, returningDefault);
}
SpeechContext *audSpeechManager::GetSpeechContext(u32 contextHash, CPed* speaker, bool* returningDefault)
{
return GetSpeechContext(contextHash, speaker, NULL, returningDefault);
}
SpeechContext *audSpeechManager::GetSpeechContext(u32 contextHash, CPed* speaker, CPed* replyingPed, bool* returningDefault)
{
//Match the speech context with the ContextName field in the objects themselves, because the context object might have a different name
//if there was already a gameobject with the same hash, or the speechcontext may already be referenced by a bunch of other gameobjects.
//not useing GetObject because it checks against TYPE_ID, not BASE_TYPE_ID. Since I've added virtual context objects that inherit from
// regular speech context objects, this would end up throwing pointless asserts
AudBaseObject *obj = static_cast<AudBaseObject*>(audNorthAudioEngine::GetMetadataManager().GetObjectMetadataPtr(contextHash));
naAssertf(obj || !g_bSpeechAsserts, "No SpeechContext object for hash %u", contextHash);
if(obj && (obj->ClassId==SpeechContext::TYPE_ID || obj->ClassId==SpeechContextVirtual::TYPE_ID) )
{
SpeechContext* speechContext = static_cast<SpeechContext*>(obj);
if(returningDefault)
*returningDefault = false;
return ResolveVirtualSpeechContext(speechContext, speaker, replyingPed);
}
else if(obj && obj->ClassId==TriggeredSpeechContext::TYPE_ID)
{
return NULL;
}
else
{
if(returningDefault)
*returningDefault = true;
return g_DefaultSpeechContext;
}
}
SpeechContext* audSpeechManager::ResolveVirtualSpeechContext(const SpeechContext* speechContext, CPed* speaker, CPed* replyingPed)
{
if(!speechContext)
return NULL;
if(!Verifyf(speechContext->ClassId == SpeechContextVirtual::TYPE_ID || speechContext->ClassId == SpeechContext::TYPE_ID,
"Argument passed into ResolveVirtualSpeechContext isn't a speech context. TYPE_ID %u Name %s", speechContext->ClassId,
audNorthAudioEngine::GetMetadataManager().GetObjectName(speechContext->NameTableOffset, 0)))
return NULL;
if(speechContext->ClassId == SpeechContext::TYPE_ID)
return const_cast<SpeechContext*>(speechContext);
SpeechContextVirtual* speechContextVirt = audNorthAudioEngine::GetObject<SpeechContextVirtual>(atFinalizeHash(speechContext->ContextNamePHash));//reinterpret_cast<SpeechContextVirtual*>(speechContext);
if(!Verifyf(speechContextVirt, "Attempting to resolve a speech context with no context name partial hash."))
return NULL;
u8* resolvingFunction = (u8*)(&(speechContext->FakeGesture[speechContext->numFakeGestures]));
if(!resolvingFunction)
return NULL;
u8* numSpeechContexts = resolvingFunction;
numSpeechContexts++;
u8* justBeforeSpeechContexts = numSpeechContexts;
justBeforeSpeechContexts++;
u32* speechContexts = (u32*)justBeforeSpeechContexts;
switch(*resolvingFunction)
{
case SRF_TIME_OF_DAY:
return ResolveVirtualSpeechContext(audVirtCxtResolves::ResolveTimeOfDay(*numSpeechContexts, speechContexts), speaker);
case SRF_PED_TOUGHNESS:
return ResolveVirtualSpeechContext(audVirtCxtResolves::ResolveSpeakerToughness(*numSpeechContexts, speechContexts, speaker), speaker);
case SRF_TARGET_GENDER:
return ResolveVirtualSpeechContext(audVirtCxtResolves::ResolveTargetGender(*numSpeechContexts, speechContexts, speaker, replyingPed), speaker, replyingPed);
case SRF_DEFAULT:
default:
if(speechContextVirt->numSpeechContexts > 0)
return ResolveVirtualSpeechContext(static_cast<SpeechContext*>(audNorthAudioEngine::GetMetadataManager().GetObjectMetadataPtr(speechContextVirt->SpeechContexts[0].SpeechContext)), speaker);
return NULL;
}
}
bool audSpeechManager::DoesContextHaveANoGenderVersion(SpeechContext *speechContext)
{
naAssertf(speechContext || !g_bSpeechAsserts, "Invalid SpeechContext passed into DoesContextHaveADrunkVersion");
if (speechContext && speechContext->GenderNonSpecificVersion != 0)
{
return true;
}
return false;
}
audWaveSlot* audSpeechManager::GetAmbientWaveSlotFromId(s32 slotId)
{
naAssertf(slotId>=0 && slotId<g_MaxAmbientSpeechSlots, "Slot id passed into GetAmbientWaveSlotFromId is out of bounds");
return m_AmbientSpeechSlots[slotId].WaveSlot;
}
audWaveSlot* audSpeechManager::GetScriptedWaveSlotFromId(s32 slotId)
{
naAssertf(slotId>=0 && slotId<g_MaxScriptedSpeechSlots, "Slot id passed into GetScriptedWaveSlotFromid is out of bounds");
return m_ScriptedSpeechSlots[slotId].WaveSlot;
}
void audSpeechManager::SpeechAudioEntityBeingDeleted(audSpeechAudioEntity* audioEntity)
{
// Search through our slots, to check none of them are associated with our soon-to-be-deleted entity.
// For now, let's assert, as although it could be valid usage, it's more likely to be a bug.
for (s32 i=0; i<g_MaxAmbientSpeechSlots; i++)
{
if (m_AmbientSpeechSlots[i].SpeechAudioEntity == audioEntity)
{
naWarningf("Ambient speech slot is associated with speech audio entity that is being deleted");
m_AmbientSpeechSlots[i].SpeechAudioEntity = NULL;
m_AmbientSpeechSlots[i].PlayState = AUD_SPEECH_SLOT_STOPPING;
}
}
for (s32 i=0; i<g_MaxScriptedSpeechSlots; i++)
{
if (m_ScriptedSpeechSlots[i].SpeechAudioEntity == audioEntity)
{
naWarningf("Scripted speech slot is associated with speech audio entity that is being deleted");
m_ScriptedSpeechSlots[i].SpeechAudioEntity = NULL;
m_ScriptedSpeechSlots[i].PlayState = AUD_SPEECH_SLOT_STOPPING;
}
}
}
u32 audSpeechManager::GetPrimaryVoice(u32 pedVoiceGroup)
{
// rustle up that game object, and pull the first primary voice out of it
PedVoiceGroups* pedVoiceGroupObject = audNorthAudioEngine::GetObject<PedVoiceGroups>(pedVoiceGroup);
if (pedVoiceGroupObject && pedVoiceGroupObject->numPrimaryVoices>0)
{
return pedVoiceGroupObject->PrimaryVoice[0].VoiceName;
}
return 0;
}
u32 audSpeechManager::GetGangVoice(u32 pedVoiceGroup)
{
u8 numGangVoices = 0;
tVoice* gangVoices = GetGangVoices(pedVoiceGroup, numGangVoices);
if (numGangVoices>0)
{
return gangVoices[0].VoiceName;
}
return 0;
}
u32 audSpeechManager::GetBestPrimaryVoice(PedVoiceGroups* pedVoiceGroupObject, s32& minReferences, u32 contextPartialHash)
{
if (pedVoiceGroupObject && pedVoiceGroupObject->numPrimaryVoices>0)
{
// Go through all the primary voices and return the one with fewest references
// Don't start at the beginning - it meant when the game cleared everyone out, you'd always hear the same
// first voice immediately - specifically a problem with M_M_TAXIDRIVER, with 11 different voices.
s32 bestVoiceIndex = -1;
s32 fewestReferences = -1;
s32 lowestRunningTab = -1;
s32 startingIndex = audEngineUtil::GetRandomNumberInRange(0, pedVoiceGroupObject->numPrimaryVoices-1);
for (s32 i=0; i<pedVoiceGroupObject->numPrimaryVoices; i++)
{
s32 currentIndex = (startingIndex+i) % pedVoiceGroupObject->numPrimaryVoices;
if (fewestReferences==-1 || (s32)pedVoiceGroupObject->PrimaryVoice[currentIndex].ReferenceCount < fewestReferences ||
( (s32)pedVoiceGroupObject->PrimaryVoice[currentIndex].ReferenceCount == fewestReferences && pedVoiceGroupObject->PrimaryVoice[currentIndex].RunningTab < lowestRunningTab)
)
{
if (audSpeechSound::FindNumVariationsForVoiceAndContext(pedVoiceGroupObject->PrimaryVoice[currentIndex].VoiceName, contextPartialHash) != 0 ||
contextPartialHash == 0)
{
bestVoiceIndex = currentIndex;
fewestReferences = pedVoiceGroupObject->PrimaryVoice[currentIndex].ReferenceCount;
lowestRunningTab = pedVoiceGroupObject->PrimaryVoice[currentIndex].RunningTab;
if(fewestReferences == 0 && lowestRunningTab == 0 && pedVoiceGroupObject->PrimaryVoice[bestVoiceIndex].VoiceName != 0)
{
minReferences = fewestReferences;
return pedVoiceGroupObject->PrimaryVoice[bestVoiceIndex].VoiceName;
}
}
}
}
if (bestVoiceIndex>-1)
{
minReferences = (s32)pedVoiceGroupObject->PrimaryVoice[bestVoiceIndex].ReferenceCount;
return pedVoiceGroupObject->PrimaryVoice[bestVoiceIndex].VoiceName;
}
}
minReferences = -1;
return 0;
}
u32 audSpeechManager::GetBestMiniVoice(PedVoiceGroups* pedVoiceGroupObject, s32& minReferences, u32 contextPartialHash)
{
// Go through all the mini voices and return the one with fewest references - we allow driving ones to be returned, if fewer refs.
// We need to skip over the variable length primary voice array.
if (pedVoiceGroupObject)
{
u8* p = (u8*)&pedVoiceGroupObject->PrimaryVoice[pedVoiceGroupObject->numPrimaryVoices];
u8 numMiniVoices = *p;
p++;
tVoice* miniVoices = (tVoice*)p;
// Go through all the mini voices and return the one with fewest references - checking it's a non-driving voice
s32 bestVoiceIndex = -1;
s32 fewestReferences = -1;
s32 lowestRunningTab = -1;
if (numMiniVoices>0)
{
s32 startingIndex = audEngineUtil::GetRandomNumberInRange(0, numMiniVoices-1);
for (s32 i=0; i<numMiniVoices; i++)
{
s32 currentIndex = (startingIndex+i) % numMiniVoices;
if (fewestReferences==-1 || (s32)miniVoices[currentIndex].ReferenceCount < fewestReferences ||
( (s32)miniVoices[currentIndex].ReferenceCount == fewestReferences && miniVoices[currentIndex].RunningTab < lowestRunningTab)
)
{
if (contextPartialHash==0 || audSpeechSound::FindNumVariationsForVoiceAndContext(miniVoices[currentIndex].VoiceName, contextPartialHash) != 0)
{
bestVoiceIndex = currentIndex;
fewestReferences = miniVoices[currentIndex].ReferenceCount;
lowestRunningTab = miniVoices[currentIndex].RunningTab;
if(fewestReferences == 0 && lowestRunningTab == 0 && miniVoices[bestVoiceIndex].VoiceName != 0)
{
minReferences = fewestReferences;
return miniVoices[bestVoiceIndex].VoiceName;;
}
}
}
}
}
// see if we found a valid one
if (bestVoiceIndex>-1)
{
minReferences = (s32)miniVoices[bestVoiceIndex].ReferenceCount;
return miniVoices[bestVoiceIndex].VoiceName;
}
}
minReferences = -1;
return 0;
}
u32 audSpeechManager::GetBestGangVoice(PedVoiceGroups* pedVoiceGroupObject, s32& minReferences, u32 contextPartialHash)
{
// Go through all the gang voices and return the one with fewest references.
// We need to skip over the variable length primary voice array, and the variable length mini voice array.
u8 numGangVoices = 0;
tVoice* gangVoices = GetGangVoices(pedVoiceGroupObject, numGangVoices);
if (gangVoices && numGangVoices>0)
{
// Go through all the gang voices and return the one with fewest references
s32 bestVoiceIndex = -1;
s32 fewestReferences = -1;
s32 lowestRunningTab = -1;
s32 startingIndex = audEngineUtil::GetRandomNumberInRange(0, numGangVoices-1);
for (s32 i=0; i<numGangVoices; i++)
{
s32 currentIndex = (startingIndex+i) % numGangVoices;
if (fewestReferences==-1 || (s32)gangVoices[currentIndex].ReferenceCount < fewestReferences ||
( (s32)gangVoices[currentIndex].ReferenceCount == fewestReferences && gangVoices[currentIndex].RunningTab < lowestRunningTab)
)
{
if (contextPartialHash==0 || audSpeechSound::FindNumVariationsForVoiceAndContext(gangVoices[currentIndex].VoiceName, contextPartialHash) != 0)
{
bestVoiceIndex = currentIndex;
fewestReferences = gangVoices[currentIndex].ReferenceCount;
lowestRunningTab = gangVoices[currentIndex].RunningTab;
if(fewestReferences == 0 && lowestRunningTab == 0 && gangVoices[bestVoiceIndex].VoiceName != 0)
{
minReferences = fewestReferences;
return gangVoices[bestVoiceIndex].VoiceName;
}
}
}
}
if (bestVoiceIndex>-1)
{
minReferences = (s32)gangVoices[bestVoiceIndex].ReferenceCount;
return gangVoices[bestVoiceIndex].VoiceName;
}
}
minReferences = -1;
return 0;
}
u32 audSpeechManager::GetBestVoice(u32 pedVoiceGroup, u32 contextPHash, CPed* speaker, bool allowBackupPVG, s32* overallMinReferenceArg)
{
PedVoiceGroups* pedVoiceGroupObject = audNorthAudioEngine::GetObject<PedVoiceGroups>(pedVoiceGroup);
if(!pedVoiceGroupObject)
{
Warningf("Invalid PVG hash passed to GetBestVoice: %u. Setting to MALE_BRAVE", pedVoiceGroup);
if(speaker && speaker->GetSpeechAudioEntity())
{
switch(speaker->GetSpeechAudioEntity()->GetPedToughnessWithoutSetting())
{
case AUD_TOUGHNESS_MALE_NORMAL:
case AUD_TOUGHNESS_MALE_COWARDLY:
case AUD_TOUGHNESS_MALE_BUM:
pedVoiceGroupObject = audNorthAudioEngine::GetObject<PedVoiceGroups>(ATSTRINGHASH("MALE_COWARDLY_PVG", 0x1F6CDCC4));
break;
case AUD_TOUGHNESS_MALE_BRAVE:
case AUD_TOUGHNESS_MALE_GANG:
pedVoiceGroupObject = audNorthAudioEngine::GetObject<PedVoiceGroups>(ATSTRINGHASH("MALE_BRAVE_PVG", 0x0087d1fc0));
break;
case AUD_TOUGHNESS_COP:
pedVoiceGroupObject = audNorthAudioEngine::GetObject<PedVoiceGroups>(ATSTRINGHASH("COP_PVG", 0xA2468C11));
break;
case AUD_TOUGHNESS_FEMALE:
case AUD_TOUGHNESS_FEMALE_BUM:
pedVoiceGroupObject = audNorthAudioEngine::GetObject<PedVoiceGroups>(ATSTRINGHASH("FEMALE_PVG", 0x84FE566E));
break;
default:
if(speaker->IsMale())
pedVoiceGroupObject = audNorthAudioEngine::GetObject<PedVoiceGroups>(ATSTRINGHASH("MALE_BRAVE_PVG", 0x0087d1fc0));
else
pedVoiceGroupObject = audNorthAudioEngine::GetObject<PedVoiceGroups>(ATSTRINGHASH("FEMALE_PVG", 0x84FE566E));
break;
}
}
if(!pedVoiceGroupObject)
return 0;
}
//Displayf("%s", audNorthAudioEngine::GetMetadataManager().GetObjectNameFromNameTableOffset(pedVoiceGroupObject->NameTableOffset));
u32 bestVoice[3];
s32 minReferences[3];
for (s32 i=0; i<3; i++)
{
bestVoice[i] = 0;
minReferences[i] = -1;
}
if(audSpeechAudioEntity::IsMultipartContext(contextPHash))
{
contextPHash = atPartialStringHash("_01", contextPHash);
}
bestVoice[0] = GetBestMiniVoice(pedVoiceGroupObject, minReferences[0], contextPHash);
if(minReferences[0] == 0 && bestVoice[0] != 0)
return bestVoice[0];
bestVoice[1] = GetBestGangVoice(pedVoiceGroupObject, minReferences[1], contextPHash);
if(minReferences[1] == 0 && bestVoice[1] != 0)
return bestVoice[1];
bestVoice[2] = GetBestPrimaryVoice(pedVoiceGroupObject, minReferences[2], contextPHash);
if(minReferences[2] == 0 && bestVoice[2] != 0)
return bestVoice[2];
// Now see which has the least references, and go with that one
u32 overallBestVoice = 0;
s32 overallMinReference = -1;
for (s32 i=0; i<3; i++)
{
if (minReferences[i] > -1 && (minReferences[i] < overallMinReference || overallMinReference == -1))
{
overallBestVoice = bestVoice[i];
overallMinReference = minReferences[i];
}
}
AudBaseObject* obj =(rage::AudBaseObject*)audNorthAudioEngine::GetMetadataManager().GetObjectMetadataPtr(atFinalizeHash(contextPHash));
if(!obj)
{
//could be a situation where we've been handed a full hash instead of a partial, so let's look using a hash of 0
bestVoice[0] = GetBestMiniVoice(pedVoiceGroupObject, minReferences[0], 0);
if(minReferences[0] == 0 && bestVoice[0] != 0)
return bestVoice[0];
bestVoice[1] = GetBestGangVoice(pedVoiceGroupObject, minReferences[1], 0);
if(minReferences[1] == 0 && bestVoice[1] != 0)
return bestVoice[1];
bestVoice[2] = GetBestPrimaryVoice(pedVoiceGroupObject, minReferences[2], 0);
if(minReferences[2] == 0 && bestVoice[2] != 0)
return bestVoice[2];
// Now see which has the least references, and go with that one
overallBestVoice = 0;
overallMinReference = -1;
for (s32 i=0; i<3; i++)
{
if (minReferences[i] > -1 && (minReferences[i] < overallMinReference || overallMinReference == -1))
{
overallBestVoice = bestVoice[i];
overallMinReference = minReferences[i];
}
}
}
else if(overallBestVoice == 0 || overallMinReference>0)
{
TriggeredSpeechContext* triggeredSpeechContext = (obj && obj->ClassId == TriggeredSpeechContext::TYPE_ID) ? (TriggeredSpeechContext*)obj : NULL;
//see if the speech context has any backup contexts we can use
if(triggeredSpeechContext && triggeredSpeechContext->numBackupSpeechContexts > 0)
{
for(int i=0; i< triggeredSpeechContext->numBackupSpeechContexts; i++)
{
if(triggeredSpeechContext->BackupSpeechContext[i].SpeechContext == 0)
continue;
SpeechContext* backupObj =(rage::SpeechContext*)audNorthAudioEngine::GetMetadataManager().GetObjectMetadataPtr(triggeredSpeechContext->BackupSpeechContext[i].SpeechContext);
SpeechContext* backupContextObj = ResolveVirtualSpeechContext(backupObj, speaker);
if(backupContextObj)
{
contextPHash = backupContextObj->ContextNamePHash;
//Choose full voice before mini, if we're looking to backup context
bestVoice[0] = GetBestPrimaryVoice(pedVoiceGroupObject, minReferences[0], contextPHash);
if(minReferences[0] == 0 && bestVoice[0] != 0)
return bestVoice[0];
bestVoice[1] = GetBestMiniVoice(pedVoiceGroupObject, minReferences[1], contextPHash);
if(minReferences[1] == 0 && bestVoice[1] != 0)
return bestVoice[1];
bestVoice[2] = GetBestGangVoice(pedVoiceGroupObject, minReferences[2], contextPHash);
if(minReferences[2] == 0 && bestVoice[2] != 0)
return bestVoice[2];
for (s32 i=0; i<3; i++)
{
if (minReferences[i] > -1 && (minReferences[i] < overallMinReference || overallMinReference == -1))
{
overallBestVoice = bestVoice[i];
overallMinReference = minReferences[i];
}
}
}
if(!(overallBestVoice == 0 || overallMinReference>0))
break;
}
}
}
if(overallMinReferenceArg)
*overallMinReferenceArg = overallMinReference;
u32 overallBestBackupVoice = 0;
s32 overallMinBackupReference = -1;
if( (overallBestVoice == 0 || overallMinReference>0) && allowBackupPVG)
{
u8* p = (u8*)&pedVoiceGroupObject->PrimaryVoice[pedVoiceGroupObject->numPrimaryVoices];
u8 numMiniVoices = *p;
p++;
tVoice* miniVoices = (tVoice*)p;
p = (u8*)&miniVoices[numMiniVoices];
u8 numGangVoices = *p;
p++;
tVoice* gangVoices = (tVoice*)p;
p = (u8*)&gangVoices[numGangVoices];
u8 numBackupPVGs = *p;
p++;
u32* BackupPVGHashes = (u32*)p;
if(numBackupPVGs > 0)
{
u8 PVGStartIndex = audEngineUtil::GetRandomInteger() % numBackupPVGs;
for(int i=0; i<numBackupPVGs; i++)
{
s32 overallMinRefIn = -1;
u8 index = (PVGStartIndex + i) % numBackupPVGs;
//don't allow us to go any deeper...don't want to fall into some crazy infinite recursion or end up with a
// really inappropriate voice
bestVoice[0] = GetBestVoice(BackupPVGHashes[index], contextPHash, speaker, false, &overallMinRefIn);
//if we find an unreferenced voice, return it immediately
if(overallMinRefIn == 0 && overallBestBackupVoice != 0)
return overallBestBackupVoice;
if(overallMinBackupReference == -1 || overallMinBackupReference > overallMinRefIn)
{
overallMinBackupReference = overallMinRefIn;
overallBestBackupVoice = bestVoice[0];
}
}
}
}
if(overallBestBackupVoice == 0 || overallMinBackupReference >= overallMinReference)
return overallBestVoice;
return overallBestBackupVoice;
}
void audSpeechManager::AddReferenceToVoice(u32 pedVoiceGroup, u32 voiceNameHash BANK_ONLY(, audSpeechAudioEntity* speechEnt))
{
if (voiceNameHash==0)
{
return;
}
// go through our primary, mini and gang voices - return as soon as we find one
u8 numVoices = 0;
tVoice* voices = GetPrimaryVoices(pedVoiceGroup, numVoices);
for (u32 i=0; i<numVoices; i++)
{
if (voices[i].VoiceName == voiceNameHash)
{
voices[i].ReferenceCount++;
voices[i].RunningTab++;
#if __BANK
if(g_PrintVoiceRefInfo)
{
naDisplayf("[VoiceRef] Adding ref to primary voice %u. PVG: %s EntityPtr: %p Current: %u Total: %u", voiceNameHash,
audNorthAudioEngine::GetMetadataManager().GetObjectNameFromNameTableOffset(((PedVoiceGroups*)audNorthAudioEngine::GetObject<PedVoiceGroups>(pedVoiceGroup))->NameTableOffset),
speechEnt, voices[i].ReferenceCount, voices[i].RunningTab);
}
#endif
return;
}
}
numVoices = 0;
voices = GetMiniVoices(pedVoiceGroup, numVoices);
for (u32 i=0; i<numVoices; i++)
{
if (voices[i].VoiceName == voiceNameHash)
{
voices[i].ReferenceCount++;
voices[i].RunningTab++;
#if __BANK
if(g_PrintVoiceRefInfo)
{
naDisplayf("[VoiceRef] Adding ref to mini voice %u. PVG: %s EntityPtr: %p Current: %u Total: %u", voiceNameHash,
audNorthAudioEngine::GetMetadataManager().GetObjectNameFromNameTableOffset(((PedVoiceGroups*)audNorthAudioEngine::GetObject<PedVoiceGroups>(pedVoiceGroup))->NameTableOffset),
speechEnt, voices[i].ReferenceCount, voices[i].RunningTab);
}
#endif
return;
}
}
numVoices = 0;
voices = GetGangVoices(pedVoiceGroup, numVoices);
for (u32 i=0; i<numVoices; i++)
{
if (voices[i].VoiceName == voiceNameHash)
{
voices[i].ReferenceCount++;
voices[i].RunningTab++;
#if __BANK
if(g_PrintVoiceRefInfo)
{
naDisplayf("[VoiceRef] Adding ref to gang voice %u. PVG: %s EntityPtr: %p Current: %u Total: %u", voiceNameHash,
audNorthAudioEngine::GetMetadataManager().GetObjectNameFromNameTableOffset(((PedVoiceGroups*)audNorthAudioEngine::GetObject<PedVoiceGroups>(pedVoiceGroup))->NameTableOffset),
speechEnt, voices[i].ReferenceCount, voices[i].RunningTab);
}
#endif
return;
}
}
}
void audSpeechManager::RemoveReferenceToVoice(u32 pedVoiceGroup, u32 voiceNameHash)
{
if (voiceNameHash==0)
{
return;
}
// go through our primary, mini and gang voices - return as soon as we find one
u8 numVoices = 0;
tVoice* voices = GetPrimaryVoices(pedVoiceGroup, numVoices);
for (u32 i=0; i<numVoices; i++)
{
if (voices[i].VoiceName == voiceNameHash)
{
voices[i].ReferenceCount--;
return;
}
}
numVoices = 0;
voices = GetMiniVoices(pedVoiceGroup, numVoices);
for (u32 i=0; i<numVoices; i++)
{
if (voices[i].VoiceName == voiceNameHash)
{
voices[i].ReferenceCount--;
return;
}
}
numVoices = 0;
voices = GetGangVoices(pedVoiceGroup, numVoices);
for (u32 i=0; i<numVoices; i++)
{
if (voices[i].VoiceName == voiceNameHash)
{
voices[i].ReferenceCount--;
return;
}
}
}
u16 audSpeechManager::GetPossibleConversationTopicsForPvg(u32 pvg)
{
//we could be getting a voice name passed in, not a pvg, so check that first.
u32 voiceNameHash = pvg;
if(!audSpeechSound::DoesVoiceExist(voiceNameHash))
{
voiceNameHash = GetPrimaryVoice(pvg);
// if it doesn't exist yet, give a gang voice a whirl
if (!audSpeechSound::DoesVoiceExist(voiceNameHash))
{
voiceNameHash = g_SpeechManager.GetGangVoice(pvg);
}
if (voiceNameHash == 0 || voiceNameHash == g_NoVoiceHash)
{
return 0;
}
}
// Cycle through the various conversation types, and see if we have valid lines of dialogue for that topic.
const char* conversationLines[] =
{
"CONV_SMOKE_STATE",
"CONV_BIZ_STATE",
"CONV_BUM_STATE",
"CONV_CONSTRUCTION_STATE",
"CONV_PIMP_STATE_A",
"CONV_HOOKER_STATE_A",
"MOBILE_CHAT",
"TWO_WAY_PHONE_CHAT",
"CONV_GANG_STATE"
};
const u32 conversationTopics[] =
{
AUD_CONVERSATION_TOPIC_SMOKER,
AUD_CONVERSATION_TOPIC_BUSINESS,
AUD_CONVERSATION_TOPIC_BUM,
AUD_CONVERSATION_TOPIC_CONSTRUCTION,
AUD_CONVERSATION_TOPIC_PIMP,
AUD_CONVERSATION_TOPIC_HOOKER,
AUD_CONVERSATION_TOPIC_MOBILE,
AUD_CONVERSATION_TOPIC_TWO_WAY,
AUD_CONVERSATION_TOPIC_GANG
};
u16 validConversationTopics = 0;
for (u32 i=0; i<(sizeof(conversationTopics)/sizeof(u32)); i++)
{
if (audSpeechSound::FindNumVariationsForVoiceAndContext(voiceNameHash, const_cast<char*>(conversationLines[i])) > 0)
{
// It's valid for them to have this type of conversation
validConversationTopics = validConversationTopics | ((u16)conversationTopics[i]);
}
}
return validConversationTopics;
}
u8 audSpeechManager::GetMiniVoiceType(const u32 voiceNameHash)
{
// This is a bit shit - we shouldn't do FindVariationInfoForVoiceAndContext() every time - tag them at a higher level.
// First, see if it's a gang mini, then if it's a hooker, then if it's driving, then it must (check) be a non-driving.
u32 numVariations = 0;
const u32 CONV_GANG_STATE = ATPARTIALSTRINGHASH("CONV_GANG_STATE", 0x6E6D0E76);
const u32 HOOKER_SEX = ATPARTIALSTRINGHASH("HOOKER_SEX", 0x3D386278);
const u32 CRASH_CAR = ATPARTIALSTRINGHASH("CRASH_CAR", 0x251FCF02);
if (audSpeechSound::FindVariationInfoForVoiceAndContext(voiceNameHash, CONV_GANG_STATE, numVariations))
{
return AUD_MINI_VOICE_TYPE_GANG;
}
else if (audSpeechSound::FindVariationInfoForVoiceAndContext(voiceNameHash, HOOKER_SEX, numVariations))
{
return AUD_MINI_VOICE_TYPE_HOOKER;
}
else if (audSpeechSound::FindVariationInfoForVoiceAndContext(voiceNameHash, CRASH_CAR, numVariations))
{
return AUD_MINI_VOICE_TYPE_DRIVING;
}
else
{
// Once all voices are in-game, start doing this again
// Assert(audSpeechSound::FindVariationInfoForVoiceAndContext(voiceNameHash, "BUMP", numVariations));
return AUD_MINI_VOICE_TYPE_NORMAL;
}
}
bool audSpeechManager::IsAMiniNonDrivingContext(char* context)
{
u32 contextHash = atStringHash(context);
// See if it's in our list of mini non-driving contexts
for (s32 i=0; i<NUM_MINI_NON_DRIVING_CONTEXTS; i++)
{
if (g_MiniNonDrivingContextHashes[i] == contextHash)
{
return true;
}
}
return false;
}
bool audSpeechManager::IsAMiniDrivingContext(char* context)
{
u32 contextHash = atStringHash(context);
// See if it's in our list of mini non-driving contexts
for (s32 i=0; i<NUM_MINI_DRIVING_CONTEXTS; i++)
{
if (g_MiniDrivingContextHashes[i] == contextHash)
{
return true;
}
}
return false;
}
bool audSpeechManager::IsAGangContext(char* context)
{
u32 contextHash = atStringHash(context);
// See if it's in our list of mini non-driving contexts
for (s32 i=0; i<NUM_GANG_CONTEXTS; i++)
{
if (g_GangContextHashes[i] == contextHash)
{
return true;
}
}
return false;
}
tVoice* audSpeechManager::GetPrimaryVoices(u32 pedVoiceGroup, u8& numPrimaryVoices)
{
PedVoiceGroups* pedVoiceGroupObject = audNorthAudioEngine::GetObject<PedVoiceGroups>(pedVoiceGroup);
if (pedVoiceGroupObject)
{
numPrimaryVoices = pedVoiceGroupObject->numPrimaryVoices;
if (numPrimaryVoices>0)
{
return (tVoice*)&pedVoiceGroupObject->PrimaryVoice[0];
}
}
return NULL;
}
tVoice* audSpeechManager::GetMiniVoices(u32 pedVoiceGroup, u8& numMiniVoices)
{
PedVoiceGroups* pedVoiceGroupObject = audNorthAudioEngine::GetObject<PedVoiceGroups>(pedVoiceGroup);
if (pedVoiceGroupObject)
{
u8* p = (u8*)&pedVoiceGroupObject->PrimaryVoice[pedVoiceGroupObject->numPrimaryVoices];
numMiniVoices = *p;
if (numMiniVoices>0)
{
p++;
return (tVoice*)p;
}
}
return NULL;
}
tVoice* audSpeechManager::GetGangVoices(u32 pedVoiceGroup, u8& numGangVoices)
{
PedVoiceGroups* pedVoiceGroupObject = audNorthAudioEngine::GetObject<PedVoiceGroups>(pedVoiceGroup);
if (pedVoiceGroupObject)
{
u8* p = (u8*)&pedVoiceGroupObject->PrimaryVoice[pedVoiceGroupObject->numPrimaryVoices];
u8 numMiniVoices = *p;
p++;
tVoice* miniVoices = (tVoice*)p;
p = (u8*)&miniVoices[numMiniVoices];
numGangVoices = *p;
if (numGangVoices>0)
{
p++;
return (tVoice*)p;
}
}
return NULL;
}
tVoice* audSpeechManager::GetGangVoices(PedVoiceGroups* pedVoiceGroupObject, u8& numGangVoices)
{
if (pedVoiceGroupObject)
{
u8* p = (u8*)&pedVoiceGroupObject->PrimaryVoice[pedVoiceGroupObject->numPrimaryVoices];
u8 numMiniVoices = *p;
p++;
tVoice* miniVoices = (tVoice*)p;
p = (u8*)&miniVoices[numMiniVoices];
numGangVoices = *p;
if (numGangVoices>0)
{
p++;
return (tVoice*)p;
}
}
return NULL;
}
#if __BANK
void audSpeechManager::ResetSpecificPainDrawStats()
{
for(int i=0; i<AUD_PAIN_LEVEL_MIXED; i++)
{
for(int j=0; j<PAIN_DEBUG_NUM_GENDERS; j++)
{
m_DebugSpecPainTimeLastLoaded[i][j] = 0;
m_DebugNonSpecPainCount[i][j] = 0;
m_DebugSpecPainBankLoadCount[i][j] = 0;
}
}
m_DebugSpecPainCountTotal = 0;
m_DebugNonSpecPainCountTotal = 0;
m_DebugSpecPainBankLoadCountTotal = 0;
m_DebugNonSpecPainBankLoadCountTotal = 0;
for(int i=0; i<AUD_PAIN_ID_NUM_TOTAL; i++)
g_DebugNumTimesPainTypePlayed[i] = 0;
}
void audSpeechManager::DrawSpeechSlots()
{
char str[1024];
Color32 color;
f32 yPos = 0.5f;
f32 yInc = 0.025f;
formatf(str, sizeof(str), "AMBIENT SLOTS");
grcDebugDraw::Text(Vector2(0.05f, yPos), Color_purple, str);
yPos += yInc;
for (s32 i = 0; i < g_MaxAmbientSpeechSlots; i++)
{
formatf(str, sizeof(str), "Slot %d ", i);
switch(m_AmbientSpeechSlots[i].PlayState)
{
case AUD_SPEECH_SLOT_VACANT:
safecat(str, "VACANT", sizeof(str));
color = Color_white;
break;
case AUD_SPEECH_SLOT_ALLOCATED:
safecatf(str, sizeof(str), "ALLOCATED Voice: %u Sound: %s_%02d entity: %p", m_AmbientSpeechSlots[i].Voicename, m_AmbientSpeechSlots[i].Context, m_AmbientSpeechSlots[i].VariationNumber, m_AmbientSpeechSlots[i].SpeechAudioEntity);
color = Color_green;
break;
case AUD_SPEECH_SLOT_WALLA:
safecatf(str, sizeof(str), "WALLA Voice: %u Sound: %s_%02d entity: %p", m_AmbientSpeechSlots[i].Voicename, m_AmbientSpeechSlots[i].Context, m_AmbientSpeechSlots[i].VariationNumber, m_AmbientSpeechSlots[i].SpeechAudioEntity);
color = Color_green;
break;
case AUD_SPEECH_SLOT_STOPPING:
safecatf(str, sizeof(str), "STOPPING Voice: %u Sound: %s_%02d bank: %s", m_AmbientSpeechSlots[i].Voicename, m_AmbientSpeechSlots[i].Context, m_AmbientSpeechSlots[i].VariationNumber,
m_AmbientSpeechSlots[i].WaveSlot ? m_AmbientSpeechSlots[i].WaveSlot->GetLoadedBankName() : "NULL");
color = Color_yellow;
break;
default:
safecat(str, "UNKNOWN", sizeof(str));
color = Color_red;
break;
}
grcDebugDraw::Text(Vector2(0.05f, yPos), color, str);
yPos += yInc;
}
}
void audSpeechManager::DrawPainPlayedTotals()
{
char str[1024];
Color32 color;
f32 yPos = 0.05f;
f32 yInc = 0.025f;
f32 xPos = 0.05f;
formatf(str, "Pain Played Totals");
grcDebugDraw::Text(Vector2(xPos, yPos), Color_purple, str);
yPos += yInc;
for(int i=0; i<AUD_PAIN_ID_NUM_TOTAL; ++i)
{
if(i == AUD_PAIN_ID_NUM_BANK_LOADED)
{
yPos += yInc;
continue;
}
formatf(str, sizeof(str), "%s %u", g_PainContexts[i], g_DebugNumTimesPainTypePlayed[i]);
grcDebugDraw::Text(Vector2(xPos, yPos), color, str);
yPos += yInc;
}
formatf(str, sizeof(str), "Last Pain Value %f", g_LastRecordedPainValue);
grcDebugDraw::Text(Vector2(xPos, yPos), color, str);
yPos += yInc;
}
void audSpeechManager::DrawSpecificPainInfo()
{
char str[1024];
Color32 color;
f32 yPos = 0.05f;
f32 yInc = 0.025f;
f32 xPos = 0.05f;
formatf(str, "Specific Pain Info");
grcDebugDraw::Text(Vector2(xPos, yPos), Color_purple, str);
yPos += yInc;
formatf(str, sizeof(str), "Pct. of Pain That's Specific %f", m_DebugSpecPainCountTotal + m_DebugNonSpecPainCountTotal == 0 ? 0.0f : ((f32)m_DebugSpecPainCountTotal)/((f32)(m_DebugSpecPainCountTotal + m_DebugNonSpecPainCountTotal)));
color = Color_green;
grcDebugDraw::Text(Vector2(xPos, yPos), color, str);
yPos += yInc;
formatf(str, sizeof(str), "Specific Pain Instance Played Per Bank Swap %f", m_DebugSpecPainBankLoadCountTotal == 0 ? 0.0f : ((f32)m_DebugSpecPainCountTotal)/((f32) m_DebugSpecPainBankLoadCountTotal));
color = Color_green;
grcDebugDraw::Text(Vector2(xPos, yPos), color, str);
yPos += yInc;
formatf(str, sizeof(str), "Pct. of Pain Swaps That Are Specific Pain %f", m_DebugSpecPainBankLoadCountTotal + m_DebugNonSpecPainBankLoadCountTotal == 0 ? 0.0f : ((f32)m_DebugSpecPainBankLoadCountTotal)/((f32)(m_DebugSpecPainBankLoadCountTotal + m_DebugNonSpecPainBankLoadCountTotal)));
color = Color_green;
grcDebugDraw::Text(Vector2(xPos, yPos), color, str);
yPos += yInc;
yPos = 0.05f;
xPos = 0.6f;
formatf(str, sizeof(str), "Specific Bank Loaded %s_%s", m_SpecificPainLoadedIsMale ? "PAIN_MALE" : "PAIN_FEMALE", g_PainLevelString[m_SpecificPainLevelLoaded]);
color = Color_green;
grcDebugDraw::Text(Vector2(xPos, yPos), color, str);
yPos += yInc;
for(int i=0; i<3; i++)
{
for(int j=0; j<PAIN_DEBUG_NUM_GENDERS; j++)
{
formatf(str, sizeof(str), "PAIN_%s_%s %u %u", j==0 ? "MALE" : "FEMALE", g_PainLevelString[i],
m_DebugSpecPainBankLoadCount[i][j], m_DebugSpecPainTimeLastLoaded[i][j]);
color = Color_green;
grcDebugDraw::Text(Vector2(xPos, yPos), color, str);
yPos += yInc;
}
}
}
void audSpeechManager::DrawAnimalBanks()
{
char str[1024];
Color32 color;
f32 yPos = 0.05f;
f32 yInc = 0.025f;
f32 xPos = 0.05f;
formatf(str, "Animal Banks");
grcDebugDraw::Text(Vector2(xPos, yPos), Color_purple, str);
yPos += yInc;
for(int i=0; i<m_AnimalBankSlots.GetCount(); i++)
{
formatf(str, (m_AnimalBankSlots[i].WaveSlot ? m_AnimalBankSlots[i].WaveSlot->GetLoadedBankName() : "NULL"));
grcDebugDraw::Text(Vector2(xPos, yPos), Color_purple, str);
yPos += yInc;
}
}
#endif
Reference in New Issue View Git Blame Copy Permalink