From 12ee71e4f732c883b33b9165c448302ea726186b Mon Sep 17 00:00:00 2001 From: Filip Gawin Date: Fri, 30 Aug 2019 00:44:57 +0200 Subject: [PATCH] audio7 --- src/audio/AudioManager.cpp | 921 +++++++++++++++++++++++++++++++++---- src/audio/AudioManager.h | 116 +++-- src/audio/DMAudio.cpp | 2 +- src/audio/DMAudio.h | 3 +- src/audio/MusicManager.cpp | 10 +- src/audio/MusicManager.h | 4 +- src/control/PathFind.cpp | 53 ++- src/core/common.h | 8 +- 8 files changed, 956 insertions(+), 161 deletions(-) diff --git a/src/audio/AudioManager.cpp b/src/audio/AudioManager.cpp index b82c650c..ae520684 100644 --- a/src/audio/AudioManager.cpp +++ b/src/audio/AudioManager.cpp @@ -39,9 +39,12 @@ int32 *BankStartOffset = (int32 *)0x6FAB70; //[2] int32 &g_nMissionAudioSfx = *(int32 *)0x60ED84; bool &bPlayerJustEnteredCar = *(bool *)0x6508C4; bool &g_bMissionAudioLoadFailed = *(bool *)0x95CD8E; +uint32 *gMinTimeToNextReport = (uint32 *)0x8E2828; +uint8 &gSpecialSuspectLastSeenReport = *(uint8 *)0x95CD4D; constexpr int totalAudioEntitiesSlots = 200; constexpr int maxVolume = 127; +constexpr int policeChannel = 28; // TODO: where is this used? Is this the right file? enum eVehicleModel { @@ -236,6 +239,43 @@ cPedComments::Process() } } +void +cAudioCollisionManager::AddCollisionToRequestedQueue() +{ + int32 collisionsIndex; + int32 i; + + if(m_bCollisionsInQueue >= 10u) { + collisionsIndex = m_bIndicesTable[9]; + if(m_sQueue.m_fDistance >= m_asCollisions1[collisionsIndex].m_fDistance) return; + } else { + collisionsIndex = m_bCollisionsInQueue++; + } + + m_asCollisions1[collisionsIndex] = m_sQueue; + + i = 0; + if(collisionsIndex) { + while(m_asCollisions1[m_bIndicesTable[i]].m_fDistance <= + m_asCollisions1[collisionsIndex].m_fDistance) { + if(++i >= collisionsIndex) { + m_bIndicesTable[i] = collisionsIndex; + return; + } + } + memmove(&m_bIndicesTable[i + 1], &m_bIndicesTable[i], 9 - i); + } + m_bIndicesTable[i] = collisionsIndex; +} + +void +cAudioScriptObject::Reset() +{ + AudioId = 125; + Posn = {0.0f, 0.0f, 0.0f}; + AudioEntity = -5; +} + void * cAudioScriptObject::operator new(size_t sz) { @@ -347,15 +387,63 @@ cAudioManager::AddReflectionsToRequestedQueue() } } -#if 1 -WRAPPER void +void cAudioManager::AddReleasingSounds() { - EAXJMP(0x57B8D0); -} -#else + bool toProcess[44]; -#endif + for(int32 i = 0; i < m_bSampleRequestQueuesStatus[m_bActiveSampleQueue]; i++) { + tActiveSample &sample = + m_asSamples[!m_bActiveSampleQueue] + [m_abSampleQueueIndexTable[!m_bActiveSampleQueue][i]]; + if(!m_asSamples[!m_bActiveSampleQueue] + [m_abSampleQueueIndexTable[!m_bActiveSampleQueue][i]] + .m_bLoopEnded) { + toProcess[i] = 0; + for(int32 j = 0; j < m_bSampleRequestQueuesStatus[m_bActiveSampleQueue]; + j++) { + if(sample.m_nEntityIndex == + m_asSamples[m_bActiveSampleQueue] + [m_abSampleQueueIndexTable[m_bActiveSampleQueue] + [j]] + .m_nEntityIndex && + sample.m_counter == + m_asSamples[m_bActiveSampleQueue] + [m_abSampleQueueIndexTable[m_bActiveSampleQueue] + [j]] + .m_counter) { + toProcess[i] = 1; + break; + } + } + if(!toProcess[i]) { + if(sample.m_counter <= 255u || !sample.m_bLoopsRemaining) { + if(!sample.field_76) continue; + if(!sample.m_nLoopCount) { + if(sample.field_88 == -1) { + sample.field_88 = + sample.m_bVolume / sample.field_76; + if(sample.field_88 <= 0) + sample.field_88 = 1; + } + if(sample.m_bVolume <= sample.field_88) { + sample.field_76 = 0; + continue; + } + sample.m_bVolume -= sample.field_88; + } + --sample.field_76; + if(field_2) { + if(sample.field_16 < 20u) ++sample.field_16; + } + sample.field_56 = 0; + } + memcpy(&m_sQueueSample, &sample, 92); + AddSampleToRequestedQueue(); + } + } + } +} void cAudioManager::AddSampleToRequestedQueue() @@ -399,18 +487,21 @@ cAudioManager::AddSampleToRequestedQueue() } } -WRAPPER void cAudioManager::AgeCrimes() { - EAXJMP(0x580AF0); + for(uint8 i = 0; i < 10; i++) { + if(crimes[i].type) { + if(++crimes[i].timer > 1500u) crimes[i].type = 0; + } + } } void cAudioManager::CalculateDistance(bool *ptr, float dist) { if(*ptr == false) { - m_sQueueSample.m_fDistance = sqrt(dist); + m_sQueueSample.m_fDistance = Sqrt(dist); *ptr = true; } } @@ -421,6 +512,39 @@ cAudioManager::CheckForAnAudioFileOnCD() const return SampleManager.CheckForAnAudioFileOnCD(); } +void +cAudioManager::ClearActiveSamples() +{ + for(int32 i = 0; i < m_bActiveSamples; i++) { + m_asActiveSamples[i].m_nEntityIndex = -5; + m_asActiveSamples[i].m_counter = 0; + m_asActiveSamples[i].m_nSampleIndex = NO_SAMPLE; + m_asActiveSamples[i].m_bBankIndex = 3; + m_asActiveSamples[i].m_bIsDistant = 0; + m_asActiveSamples[i].field_16 = 5; + m_asActiveSamples[i].m_nFrequency = 0; + m_asActiveSamples[i].m_bVolume = 0; + m_asActiveSamples[i].m_bEmittingVolume = 0; + m_asActiveSamples[i].m_fDistance = 0.0f; + m_asActiveSamples[i].m_bIsProcessed = 0; + m_asActiveSamples[i].m_bLoopEnded = 0; + m_asActiveSamples[i].m_nLoopCount = 1; + m_asActiveSamples[i].m_nLoopStart = 0; + m_asActiveSamples[i].m_nLoopEnd = -1; + m_asActiveSamples[i].field_48 = 0.0f; + m_asActiveSamples[i].m_fSoundIntensity = 200.0f; + m_asActiveSamples[i].m_bOffset = 63; + m_asActiveSamples[i].field_56 = 0; + m_asActiveSamples[i].calculatedVolume = 0; + m_asActiveSamples[i].field_76 = 0; + m_asActiveSamples[i].field_88 = -1; + m_asActiveSamples[i].m_vecPos = {0.0f, 0.0f, 0.0f}; + m_asActiveSamples[i].m_bReverbFlag = 0; + m_asActiveSamples[i].m_bLoopsRemaining = 0; + m_asActiveSamples[i].m_bRequireReflection = 0; + } +} + void cAudioManager::ClearMissionAudio() { @@ -563,7 +687,7 @@ cAudioManager::DestroyEntity(int32 id) void cAudioManager::DoJumboVolOffset() const { - if(!(m_FrameCounter % (m_anRandomTable[0] % 6u + 3))) + if(!(m_nTimeOfRecentCrime % (m_anRandomTable[0] % 6u + 3))) jumboVolOffset = m_anRandomTable[1] % 60u; } @@ -2736,46 +2860,47 @@ cAudioManager::GetCollisionLoopingRatio(uint32 a, uint32 b, float c) const } float -cAudioManager::GetCollisionOneShotRatio(uint32 a, float b) const +cAudioManager::GetCollisionOneShotRatio(int32 a, float b) const { float result; switch(a) { - case 0u: - case 1u: - case 5u: - case 26u: - case 31u: result = GetCollisionRatio(b, 10.0, 60.0, 50.0); break; - case 2u: - case 3u: - case 4u: - case 30u: result = GetCollisionRatio(b, 0.0, 2.0, 2.0); break; - case 6u: result = GetCollisionRatio(b, 6.0, 50.0, 44.0); break; - case 7u: - case 16u: result = GetCollisionRatio(b, 0.1, 10.0, 9.9); break; - case 8u: - case 11u: result = GetCollisionRatio(b, 30.0, 130.0, 100.0); break; - case 9u: result = GetCollisionRatio(b, 20.0, 100.0, 80.0); break; - case 10u: result = GetCollisionRatio(b, 0.0, 4.0, 4.0); break; - case 12u: - case 13u: - case 32u: result = GetCollisionRatio(b, 1.0, 10.0, 9.0); break; - case 14u: result = GetCollisionRatio(b, 1.0, 15.0, 14.0); break; - case 15u: result = GetCollisionRatio(b, 8.0, 50.0, 42.0); break; - case 17u: result = GetCollisionRatio(b, 0.0, 20.0, 20.0); break; - case 18u: - case 19u: - case 23u: - case 29u: result = GetCollisionRatio(b, 0.0, 10.0, 10.0); break; - case 20u: result = GetCollisionRatio(b, 1.0, 4.0, 3.0); break; - case 21u: result = GetCollisionRatio(b, 0.1, 5.0, 4.9); break; - case 22u: result = GetCollisionRatio(b, 0.1, 40.0, 39.9); break; - case 24u: result = GetCollisionRatio(b, 0.1, 4.0, 3.9); break; - case 25u: result = GetCollisionRatio(b, 0.0, 0.5, 0.5); break; - case 27u: result = GetCollisionRatio(b, 4.0, 40.0, 36.0); break; - case 28u: result = GetCollisionRatio(b, 0.0, 5.0, 5.0); break; - default: result = 0.0; break; + case SURFACE_DEFAULT: + case SURFACE_TARMAC: + case SURFACE_PAVEMENT: + case SURFACE_STONE: + case SURFACE_BOLLARD: result = GetCollisionRatio(b, 10.f, 60.f, 50.f); break; + case SURFACE_GRASS: + case SURFACE_LOOSE30: result = GetCollisionRatio(b, 0.f, 2.f, 2.f); break; + case SURFACE_DIRT: result = GetCollisionRatio(b, 0.f, 2.f, 2.f); break; + case SURFACE_DIRTTRACK: result = GetCollisionRatio(b, 0.f, 2.f, 2.f); break; + case SURFACE_METAL6: result = GetCollisionRatio(b, 6.f, 50.f, 44.f); break; + case SURFACE_GLASS: result = GetCollisionRatio(b, 0.1f, 10.f, 9.9f); break; + case SURFACE_SCAFFOLD: + case SURFACE_STEEL: result = GetCollisionRatio(b, 30.f, 130.f, 100.f); break; + case SURFACE_METAL_DOOR: result = GetCollisionRatio(b, 20.f, 100.f, 80.f); break; + case SURFACE_BILLBOARD: result = GetCollisionRatio(b, 0.f, 4.f, 4.f); break; + case SURFACE_METAL_POLE: + case SURFACE_GATE: result = GetCollisionRatio(b, 1.f, 10.f, 9.f); break; + case SURFACE_STREET_LIGHT: result = GetCollisionRatio(b, 1.f, 10.f, 9.f); break; + case SURFACE_METAL14: result = GetCollisionRatio(b, 1.f, 15.f, 14.f); break; + case SURFACE_METAL15: result = GetCollisionRatio(b, 8.f, 50.f, 42.f); break; + case SURFACE_METAL_FENCE: result = GetCollisionRatio(b, 0.1f, 10.f, 9.9f); break; + case SURFACE_FLESH: result = GetCollisionRatio(b, 0.f, 20.f, 20.f); break; + case SURFACE_SAND: result = GetCollisionRatio(b, 0.f, 10.f, 10.f); break; + case SURFACE_PUDDLE: result = GetCollisionRatio(b, 0.f, 10.f, 10.f); break; + case SURFACE_WOOD: result = GetCollisionRatio(b, 1.f, 4.f, 3.f); break; + case SURFACE_WOOD_BOX: result = GetCollisionRatio(b, 0.1f, 5.f, 4.9f); break; + case SURFACE_WOOD_PLANK: result = GetCollisionRatio(b, 0.1f, 40.f, 39.9f); break; + case SURFACE_TIRE: + case SURFACE_RUBBER29: result = GetCollisionRatio(b, 0.f, 10.f, 10.f); break; + case SURFACE_HARD24: result = GetCollisionRatio(b, 0.1f, 4.f, 3.9f); break; + case SURFACE_HEDGE: result = GetCollisionRatio(b, 0.f, 0.5f, 0.5f); break; + case SURFACE_METAL27: result = GetCollisionRatio(b, 4.f, 40.f, 36.f); break; + case SURFACE_METAL28: result = GetCollisionRatio(b, 0.f, 5.f, 5.f); break; + default: result = 0.f; break; } + return result; } @@ -2926,6 +3051,60 @@ cAudioManager::GetPhrase(uint32 *phrase, uint32 *prevPhrase, uint32 sample, uint *prevPhrase = *phrase; } +float +cAudioManager::GetVehicleDriveWheelSkidValue(uint8 wheel, CAutomobile *automobile, + cTransmission *transmission, float velocityChange) +{ + int wheelState; + float relativeVelChange; + float gasPedalAudio = automobile->m_fGasPedalAudio; + float modificator; + float velChange; + float relativeVel; + + wheelState = automobile->m_aWheelState[wheel]; + if(wheelState == 1 && gasPedalAudio > 0.4f) { + relativeVelChange = (gasPedalAudio + -0.4f) * 1.25f; + + } else if(wheelState == 2) { + relativeVelChange = min(1.0f, Abs(velocityChange) / transmission->fMaxVelocity); + } else if(wheelState == 3) { + modificator = 0.4f; + relativeVelChange = gasPedalAudio; + if(relativeVelChange > 0.4f) { + relativeVelChange = relativeVelChange - 0.4f; + modificator = 1.6667f; + } + velChange = Abs(velocityChange); + if(relativeVelChange > 0.4f) relativeVelChange = relativeVelChange * modificator; + if(velChange > 0.04f) { + relativeVel = min(1.0f, velChange / transmission->fMaxVelocity); + } else { + relativeVel = 0.0f; + } + if(relativeVel >= relativeVelChange) relativeVelChange = relativeVel; + } else { + relativeVelChange = 0.0f; + } + + return max(relativeVelChange, min(1.0f, Abs(automobile->m_vecTurnSpeed.z) * 20.0f)); +} + +float +cAudioManager::GetVehicleNonDriveWheelSkidValue(uint8 wheel, CAutomobile *automobile, + cTransmission *transmission, float velocityChange) +{ + float relativeVelChange; + + if(automobile->m_aWheelState[wheel] == 2) { + relativeVelChange = min(1.0f, Abs(velocityChange) / transmission->fMaxVelocity); + } else { + relativeVelChange = 0.0; + } + + return max(relativeVelChange, min(1.0f, Abs(automobile->m_vecTurnSpeed.z) * 20.0f)); +} + bool cAudioManager::HasAirBrakes(int32 model) const { @@ -2954,11 +3133,17 @@ cAudioManager::Initialise() } } -WRAPPER void cAudioManager::InitialisePoliceRadio() { - EAXJMP(0x57EEC0); + unk2 = 0; + unk3 = 0; + unk4 = 0; + for(int32 i = 0; i < 10; i++) { crimes[i].type = 0; } + + SampleManager.SetChannelReverbFlag(28, 0); + gSpecialSuspectLastSeenReport = 0; + for(int32 i = 0; i < 18; i++) { gMinTimeToNextReport[i] = m_nTimeOfRecentCrime; } } WRAPPER @@ -3427,7 +3612,7 @@ cAudioManager::ProcessBoatMovingOverWater(cVehicleParams *params) if(velocityChange <= 0.0005f && params->m_pVehicle->GetPosition().y) return 1; velocityChange = min(0.75f, velocityChange); - multiplier = (velocityChange - 0.0005f) * 1.3342f; + multiplier = (velocityChange - 0.0005f) * 4 / 3; CalculateDistance((bool *)params, params->m_fDistance); vol = (30.f * multiplier); m_sQueueSample.m_bVolume = ComputeVolume(vol, 50.f, m_sQueueSample.m_fDistance); @@ -3671,7 +3856,7 @@ cAudioManager::ProcessCinemaScriptObject(uint8 sound) m_sQueueSample.m_nFrequency = SampleManager.GetSampleBaseFrequency( m_sQueueSample.m_nSampleIndex); m_sQueueSample.m_nFrequency += - RandomDisplacement(m_sQueueSample.m_nFrequency >> 2); + RandomDisplacement(m_sQueueSample.m_nFrequency / 4); m_sQueueSample.m_counter = counter++; m_sQueueSample.m_bIsDistant = 0; m_sQueueSample.m_nLoopCount = 1; @@ -4266,7 +4451,7 @@ cAudioManager::ProcessHomeScriptObject(uint8 sound) m_sQueueSample.m_nFrequency = SampleManager.GetSampleBaseFrequency( m_sQueueSample.m_nSampleIndex); m_sQueueSample.m_nFrequency += - RandomDisplacement(m_sQueueSample.m_nFrequency >> 4); + RandomDisplacement(m_sQueueSample.m_nFrequency / 16); m_sQueueSample.m_counter = counter++; m_sQueueSample.m_bIsDistant = 0; m_sQueueSample.m_nLoopCount = 1; @@ -4371,7 +4556,7 @@ cAudioManager::ProcessJumboFlying() void cAudioManager::ProcessJumboLanding(CPlane *plane) { - float modificator = (LandingPoint - PlanePathPosition[plane->m_nPlaneId]) * 0.0028571f; + float modificator = (LandingPoint - PlanePathPosition[plane->m_nPlaneId]) / 350.f; if(SetupJumboFlySound(107.f * modificator + 20)) { if(SetupJumboTaxiSound(75.f * (1.f - modificator))) { SetupJumboEngineSound(maxVolume, 22050); @@ -4384,7 +4569,7 @@ cAudioManager::ProcessJumboLanding(CPlane *plane) void cAudioManager::ProcessJumboTakeOff(CPlane *plane) { - float modificator = (PlanePathPosition[plane->m_nPlaneId] - TakeOffPoint) * 0.0033333f; + float modificator = (PlanePathPosition[plane->m_nPlaneId] - TakeOffPoint) / 300.f; if(SetupJumboFlySound((107.f * modificator) + 20) && SetupJumboRumbleSound(maxVolume * (1.f - modificator))) { @@ -6671,15 +6856,6 @@ struct tVehicleSampleData { int32 *CSWTCH_554 = (int32 *)0x606A50; tVehicleSampleData *vehicleSampleData = (tVehicleSampleData *)0x606204; -#if 0 -WRAPPER -void -cAudioManager::ProcessPlayersVehicleEngine(cVehicleParams *params, CAutomobile *automobile) -{ - EAXJMP(0x56B0D0); -} -#else - void cAudioManager::ProcessPlayersVehicleEngine(cVehicleParams *params, CAutomobile *automobile) { @@ -6963,13 +7139,70 @@ cAudioManager::ProcessPlayersVehicleEngine(cVehicleParams *params, CAutomobile * bHandbrakeOnLastFrame = automobile->bIsHandbrakeOn; bLostTractionLastFrame = lostTraction; } -#endif -WRAPPER void cAudioManager::ProcessPoliceCellBeatingScriptObject(uint8 sound) { - EAXJMP(0x578190); + uint32 time = CTimer::GetTimeInMilliseconds(); + int32 sampleIndex; + uint8 emittingVol; + float distSquared; + float maxDist; + cPedParams params; + + static uint8 counter = 0; + + if(time > audioLogicTimers[7]) { + switch(sound) { + case SCRIPT_SOUND_POLICE_CELL_BEATING_LOOP_S: + maxDist = 900.f; + m_sQueueSample.m_fSoundIntensity = 30.0f; + break; + case SCRIPT_SOUND_POLICE_CELL_BEATING_LOOP_L: + maxDist = 6400.f; + m_sQueueSample.m_fSoundIntensity = 80.0f; + break; + default: break; + } + distSquared = GetDistanceSquared(&m_sQueueSample.m_vecPos); + if(distSquared < maxDist) { + m_sQueueSample.m_fDistance = sqrt(distSquared); + if(m_nTimeOfRecentCrime & 1) + sampleIndex = (m_anRandomTable[1] & 3) + AUDIO_SAMPLE_PED_HIT_1; + else + sampleIndex = + (m_anRandomTable[3] & 1) + AUDIO_SAMPLE_PED_HIT_BY_BAT; + m_sQueueSample.m_nSampleIndex = sampleIndex; + emittingVol = m_anRandomTable[0] % 50u + 55; + m_sQueueSample.m_bVolume = + ComputeVolume(emittingVol, m_sQueueSample.m_fSoundIntensity, + m_sQueueSample.m_fDistance); + if(m_sQueueSample.m_bVolume) { + m_sQueueSample.m_bBankIndex = 0; + m_sQueueSample.m_nFrequency = SampleManager.GetSampleBaseFrequency( + m_sQueueSample.m_nSampleIndex); + m_sQueueSample.m_nFrequency += + RandomDisplacement(m_sQueueSample.m_nFrequency / 16); + m_sQueueSample.m_counter = counter++; + m_sQueueSample.m_bIsDistant = 0; + m_sQueueSample.m_nLoopCount = 1; + m_sQueueSample.field_56 = 1; + m_sQueueSample.field_16 = 3; + m_sQueueSample.field_48 = 0.0f; + m_sQueueSample.m_bEmittingVolume = emittingVol; + m_sQueueSample.m_nLoopStart = 0; + m_sQueueSample.m_nLoopEnd = -1; + m_sQueueSample.m_bReverbFlag = 1; + m_sQueueSample.m_bRequireReflection = 0; + AddSampleToRequestedQueue(); + params.m_bDistanceCalculated = 1; + params.m_fDistance = distSquared; + params.m_pPed = 0; + SetupPedComments(¶ms, SOUND_8A); + } + audioLogicTimers[7] = time + 500 + m_anRandomTable[3] % 1500u; + } + } } void @@ -7611,6 +7844,107 @@ cAudioManager::ProcessVehicleRoadNoise(cVehicleParams *params) return 1; } +void +cAudioManager::ProcessVehicleSkidding(cVehicleParams *params) +{ + + CAutomobile *automobile; + cTransmission *transmission; + signed int emittingVol; + float newSkidVal = 0.f; + float skidVal = 0.f; + + if(params->m_fDistance >= 1600.f) return; + automobile = (CAutomobile *)params->m_pVehicle; + if(!automobile->m_nWheelsOnGround) return; + CalculateDistance((bool *)params, params->m_fDistance); + for(int32 i = 0; i < 4; i++) { + if(!automobile->m_aWheelState[i] || automobile->Damage.GetWheelStatus(i) == 2) + continue; + transmission = params->m_pTransmission; + if(transmission->nDriveType == '4') { + newSkidVal = GetVehicleDriveWheelSkidValue(i, automobile, transmission, + params->m_fVelocityChange); + if(newSkidVal > skidVal) skidVal = newSkidVal; + continue; + } + if(transmission->nDriveType != 'F') { + if(transmission->nDriveType != 'R') { + if(newSkidVal > skidVal) skidVal = newSkidVal; + continue; + } + if(i != 1 && i != 3) { + newSkidVal = GetVehicleNonDriveWheelSkidValue( + i, automobile, transmission, params->m_fVelocityChange); + if(newSkidVal > skidVal) skidVal = newSkidVal; + continue; + } + newSkidVal = GetVehicleDriveWheelSkidValue(i, automobile, transmission, + params->m_fVelocityChange); + if(newSkidVal > skidVal) skidVal = newSkidVal; + continue; + } + if(!i || i == 2) { + newSkidVal = GetVehicleDriveWheelSkidValue(i, automobile, transmission, + params->m_fVelocityChange); + if(newSkidVal > skidVal) skidVal = newSkidVal; + continue; + } + newSkidVal = GetVehicleNonDriveWheelSkidValue(i, automobile, transmission, + params->m_fVelocityChange); + if(newSkidVal > skidVal) skidVal = newSkidVal; + } + + if(skidVal > 0.0f) { + emittingVol = 50.f * skidVal; + m_sQueueSample.m_bVolume = + ComputeVolume(emittingVol, 40.f, m_sQueueSample.m_fDistance); + if(m_sQueueSample.m_bVolume) { + m_sQueueSample.m_counter = 3; + switch(params->m_pVehicle->m_nSurfaceTouched) { + case SURFACE_GRASS: + case SURFACE_HEDGE: + m_sQueueSample.m_nSampleIndex = + AUDIO_SAMPLE_COLLISION_LOOPING_GRASS; + emittingVol /= 4; + m_sQueueSample.m_nFrequency = + (signed __int64)(13000.f * skidVal + 35000.f); + m_sQueueSample.m_bVolume /= 4; + break; + case SURFACE_DIRT: + case SURFACE_DIRTTRACK: + case SURFACE_SAND: + case SURFACE_PUDDLE: + m_sQueueSample.m_nSampleIndex = AUDIO_SAMPLE_COLLISION_LOOPING_SOFT; + m_sQueueSample.m_nFrequency = 6000.f * skidVal + 10000.f; + break; + + default: + m_sQueueSample.m_nSampleIndex = AUDIO_SAMPLE_VEHICLE_SKIDDING; + m_sQueueSample.m_nFrequency = 5000.f * skidVal + 11000.f; + break; + } + + m_sQueueSample.m_bBankIndex = 0; + m_sQueueSample.m_bIsDistant = 0; + m_sQueueSample.field_16 = 8; + m_sQueueSample.m_nLoopCount = 0; + m_sQueueSample.m_bEmittingVolume = emittingVol; + m_sQueueSample.m_nLoopStart = + SampleManager.GetSampleLoopStartOffset(m_sQueueSample.m_nSampleIndex); + m_sQueueSample.m_nLoopEnd = + SampleManager.GetSampleLoopEndOffset(m_sQueueSample.m_nSampleIndex); + m_sQueueSample.field_48 = 3.0; + m_sQueueSample.m_fSoundIntensity = 40.0; + m_sQueueSample.field_56 = 0; + m_sQueueSample.field_76 = 3; + m_sQueueSample.m_bReverbFlag = 1; + m_sQueueSample.m_bRequireReflection = 0; + AddSampleToRequestedQueue(); + } + } +} + WRAPPER void cAudioManager::ProcessWaterCannon(int32) { EAXJMP(0x575F30); } @@ -7647,7 +7981,7 @@ cAudioManager::ProcessWeather(int32 id) m_sQueueSample.m_nLoopEnd = -1; m_sQueueSample.m_bReverbFlag = 0; m_sQueueSample.m_bRequireReflection = 0; - cAudioManager::AddSampleToRequestedQueue(); + AddSampleToRequestedQueue(); } if(CWeather::Rain > 0.0f && (!CCullZones::CamNoRain() || !CCullZones::PlayerNoRain())) { m_sQueueSample.m_nSampleIndex = AUDIO_SAMPLE_COLLISION_LOOPING_GRASS; @@ -7669,7 +8003,7 @@ cAudioManager::ProcessWeather(int32 id) m_sQueueSample.m_nLoopEnd = SampleManager.GetSampleLoopEndOffset(m_sQueueSample.m_nSampleIndex); m_sQueueSample.m_bRequireReflection = 0; - cAudioManager::AddSampleToRequestedQueue(); + AddSampleToRequestedQueue(); } } @@ -7799,18 +8133,68 @@ cAudioManager::ReleaseDigitalHandle() const if(m_bIsInitialised) { SampleManager.ReleaseDigitalHandle(); } } -WRAPPER -int32 -cAudioManager::ReportCollision(CEntity *a2, CEntity *a3, uint8 a4, uint8 a5, float a6, float a7) +void +cAudioManager::ReportCollision(CEntity *entity1, CEntity *entity2, uint8 surface1, uint8 surface2, + float collisionPower, float velocity) { - EAXJMP(0x568410); + float dist; + CVector v1; + CVector v2; + + if(m_bIsInitialised && m_nCollisionEntity >= 0 && !m_bUserPause && + (velocity >= 0.0016f || collisionPower >= 0.01f)) { + if((entity1->m_status & 7) == ENTITY_TYPE_BUILDING) { + v1 = v2 = entity2->GetPosition(); + } else if((entity2->m_status & 7) == ENTITY_TYPE_BUILDING) { + v1 = v2 = entity1->GetPosition(); + } else { + v1 = entity1->GetPosition(); + v2 = entity2->GetPosition(); + } + CVector pos = (v1 + v2) * 0.5f; + dist = GetDistanceSquared(&pos); + if(dist < 3600.f) { + m_sCollisionManager.m_sQueue.m_pEntity1 = entity1; + m_sCollisionManager.m_sQueue.m_pEntity2 = entity2; + m_sCollisionManager.m_sQueue.m_bSurface1 = surface1; + m_sCollisionManager.m_sQueue.m_bSurface2 = surface2; + m_sCollisionManager.m_sQueue.m_fIntensity1 = collisionPower; + m_sCollisionManager.m_sQueue.m_fIntensity2 = velocity; + m_sCollisionManager.m_sQueue.m_vecPosition = pos; + m_sCollisionManager.m_sQueue.m_fDistance = dist; + m_sCollisionManager.AddCollisionToRequestedQueue(); + } + } } -WRAPPER -int32 -cAudioManager::ReportCrime(eCrimeType crime, const CVector *pos) +void +cAudioManager::ReportCrime(int32 type, const CVector *pos) { - EAXJMP(0x5803D0); + int32 lastCrime; + + lastCrime = 10; + if(m_bIsInitialised && MusicManager.m_nMusicMode != 2 && + FindPlayerPed()->m_pWanted->m_nWantedLevel > 0 && (type > 0 || type < 17) && + m_nTimeOfRecentCrime >= gMinTimeToNextReport[type]) { + for(int32 i = 0; i < 10; i++) { + if(crimes[i].type) { + if(crimes[i].type == type) { + crimes[i].position = *pos; + crimes[i].timer = 0; + return; + } + } else { + lastCrime = i; + } + } + + if(lastCrime < 10) { + crimes[lastCrime].type = type; + crimes[lastCrime].position = *pos; + crimes[lastCrime].timer = 0; + gMinTimeToNextReport[type] = m_nTimeOfRecentCrime + 500; + } + } } void @@ -7835,23 +8219,42 @@ cAudioManager::ResetAudioLogicTimers(int32 timer) } } ClearMissionAudio(); - SampleManager.StopChannel(28); + SampleManager.StopChannel(policeChannel); } void cAudioManager::ResetPoliceRadio() { if(m_bIsInitialised) { - if(SampleManager.GetChannelUsedFlag(28)) SampleManager.StopChannel(28); + if(SampleManager.GetChannelUsedFlag(policeChannel)) + SampleManager.StopChannel(policeChannel); InitialisePoliceRadio(); } } -WRAPPER void -cAudioManager::ResetTimers(uint32 a2) +cAudioManager::ResetTimers(uint32 time) { - EAXJMP(0x57A7B0); + if(m_bIsInitialised) { + m_bTimerJustReset = 1; + m_nTimer = time; + ClearRequestedQueue(); + if(m_bActiveSampleQueue) { + m_bActiveSampleQueue = 0; + ClearRequestedQueue(); + m_bActiveSampleQueue = 1; + } else { + m_bActiveSampleQueue = 1; + ClearRequestedQueue(); + m_bActiveSampleQueue = 0; + } + ClearActiveSamples(); + ClearMissionAudio(); + SampleManager.StopChannel(policeChannel); + SampleManager.SetEffectsFadeVolume(0); + SampleManager.SetMusicFadeVolume(0); + MusicManager.ResetMusicAfterReload(); + } } WRAPPER void @@ -7861,7 +8264,222 @@ cAudioManager::Service() } WRAPPER -int8 cAudioManager::SetCurrent3DProvider(uint8) { EAXJMP(0x57A910); } +void +cAudioManager::ServiceCollisions() +{ + EAXJMP(0x5686D0); +} + +void +cAudioManager::ServicePoliceRadio() +{ + int wantedLevel = 0; // bug?; + static uint32 nLastSeen = 300; + + if(m_bIsInitialised) { + if(!m_bUserPause) { + bool crimeReport = SetupCrimeReport(); + wantedLevel = FindPlayerPed()->m_pWanted->m_nWantedLevel; + if(!crimeReport) { + if(wantedLevel) { + if(nLastSeen) { + --nLastSeen; + } else { + nLastSeen = m_anRandomTable[1] % 1000u + 2000; + SetupSuspectLastSeenReport(); + } + } + } + } + ServicePoliceRadioChannel(wantedLevel); + } +} + +void +cAudioManager::ServicePoliceRadioChannel(int32 wantedLevel) +{ + + bool processed = false; + uint32 sample; + int32 freq; + + static int cWait = 0; + static bool bChannelOpen = 0; + static uint8 bMissionAudioPhysicalPlayingStatus = 0; + static int32 PoliceChannelFreq = 5500; + + if(m_bIsInitialised) { + if(m_bUserPause) { + if(SampleManager.GetChannelUsedFlag(policeChannel)) + SampleManager.StopChannel(policeChannel); + if(g_nMissionAudioSfx != TOTAL_AUDIO_SAMPLES && + bMissionAudioPhysicalPlayingStatus == 1 && + SampleManager.IsStreamPlaying(1u)) { + SampleManager.PauseStream(1, 1u); + } + } else { + if(m_bPreviousUserPause && g_nMissionAudioSfx != TOTAL_AUDIO_SAMPLES && + bMissionAudioPhysicalPlayingStatus == 1) { + SampleManager.PauseStream(0, 1u); + } + if(!unk2) bChannelOpen = 0; + if(cWait) { + --cWait; + return; + } + if(g_nMissionAudioSfx != 3032 && !bChannelOpen) { + if(g_nMissionAudioPlayingStatus) { + if(g_nMissionAudioPlayingStatus == 1 && + !bMissionAudioPhysicalPlayingStatus && + SampleManager.IsStreamPlaying(1u)) { + bMissionAudioPhysicalPlayingStatus = 1; + } + if(bMissionAudioPhysicalPlayingStatus == 1) { + if(SampleManager.IsStreamPlaying(1u)) { + DoPoliceRadioCrackle(); + } else { + bMissionAudioPhysicalPlayingStatus = 2; + g_nMissionAudioPlayingStatus = 2; + g_nMissionAudioSfx = TOTAL_AUDIO_SAMPLES; + cWait = 30; + } + return; + } + } else if(!SampleManager.GetChannelUsedFlag(policeChannel)) { + SampleManager.PreloadStreamedFile(g_nMissionAudioSfx, 1u); + SampleManager.SetStreamedVolumeAndPan(maxVolume, 63u, 1, + 1u); + SampleManager.StartPreloadedStreamedFile(1u); + g_nMissionAudioPlayingStatus = 1; + bMissionAudioPhysicalPlayingStatus = 0; + return; + } + } + if(bChannelOpen) DoPoliceRadioCrackle(); + if((g_nMissionAudioSfx == TOTAL_AUDIO_SAMPLES || + g_nMissionAudioPlayingStatus != 1) && + !SampleManager.GetChannelUsedFlag(policeChannel) && unk2) { + if(unk2) { + sample = *(uint32 *)&stuff[4 * unk4]; + --unk2; + unk4 = (unk4 + 1) % 60; + } else { + sample = TOTAL_AUDIO_SAMPLES; + } + if(!wantedLevel) { + if(gSpecialSuspectLastSeenReport) { + gSpecialSuspectLastSeenReport = 0; + } else if((unsigned int)(sample - 212) <= 2 || + sample == TOTAL_AUDIO_SAMPLES) { + bChannelOpen = 0; + processed = 1; + } + } + if(sample == TOTAL_AUDIO_SAMPLES) { + if(!processed) cWait = 30; + } else { + SampleManager.InitialiseChannel(policeChannel, sample, 0); + switch(sample) { + case AUDIO_SAMPLE_POLICE_SCANNER_SMALL_CRACKLE_1: + case AUDIO_SAMPLE_POLICE_SCANNER_SMALL_CRACKLE_2: + case AUDIO_SAMPLE_POLICE_SCANNER_SMALL_CRACKLE_3: + freq = m_anRandomTable[4] % 2000u + 10025; + bChannelOpen = bChannelOpen == 0; + break; + default: + freq = SampleManager.GetSampleBaseFrequency(sample); + break; + } + PoliceChannelFreq = freq; + SampleManager.SetChannelFrequency(policeChannel, freq); + SampleManager.SetChannelVolume(policeChannel, 100u); + SampleManager.SetChannelPan(policeChannel, 63); + SampleManager.SetChannelLoopCount(policeChannel, 1); + SampleManager.SetChannelLoopPoints(policeChannel, 0, -1); + SampleManager.StartChannel(policeChannel); + } + if(processed) ResetPoliceRadio(); + } + } + } +} +#if 1 +WRAPPER +void +cAudioManager::ServiceSoundEffects() +{ + +} + +#else + +void +cAudioManager::ServiceSoundEffects() +{ + uint32 timeOfRecentCrime; + cAudioScriptObject *object; + + timeOfRecentCrime = m_nTimeOfRecentCrime; + ++m_nTimeOfRecentCrime; + if(timeOfRecentCrime % 5) + field_2 = 0; + else + field_2 = 1; + if(m_bUserPause && !m_bPreviousUserPause) { + for(int32 i = 0; i < 29; i++) SampleManager.StopChannel(i); + + ClearRequestedQueue(); + if(m_bActiveSampleQueue) { + m_bActiveSampleQueue = 0; + ClearRequestedQueue(); + m_bActiveSampleQueue = 1; + } else { + m_bActiveSampleQueue = 1; + ClearRequestedQueue(); + m_bActiveSampleQueue = 0; + } + ClearActiveSamples(); + } + m_bActiveSampleQueue = m_bActiveSampleQueue != 1; + ProcessReverb(); + ProcessSpecial(); + ClearRequestedQueue(); + InterrogateAudioEntities(); + m_sPedComments.Process(); + ServicePoliceRadio(); + ServiceCollisions(); + AddReleasingSounds(); + ProcessMissionAudio(); + sub_57C2B0(); + ProcessActiveQueues(); + for(int32 i = 0; i < m_nScriptObjectEntityTotal; ++i) { + object = (cAudioScriptObject *)m_asAudioEntities[m_anScriptObjectEntityIndices[i]] + .m_pEntity; + if(object) { delete object; } + DestroyEntity(m_anScriptObjectEntityIndices[i]); + } + m_nScriptObjectEntityTotal = 0; +} +#endif +int8 +cAudioManager::SetCurrent3DProvider(uint8 which) +{ + if(!m_bIsInitialised) return -1; + for(uint8 i = 0; i < m_bActiveSamples + 1; ++i) SampleManager.StopChannel(i); + ClearRequestedQueue(); + if(m_bActiveSampleQueue) + m_bActiveSampleQueue = 0; + else + m_bActiveSampleQueue = 1; + ClearRequestedQueue(); + ClearActiveSamples(); + int8 current = SampleManager.SetCurrent3DProvider(which); + if(current > 0) { + m_bActiveSamples = SampleManager.GetMaximumSupportedChannels(); + if(m_bActiveSamples > 1u) --m_bActiveSamples; + } + return current; +} void cAudioManager::SetDynamicAcousticModelingStatus(bool status) @@ -7886,7 +8504,54 @@ cAudioManager::SetEntityStatus(int32 id, bool status) { if(m_bIsInitialised && id >= 0 && id < totalAudioEntitiesSlots) { if(m_asAudioEntities[id].m_bIsUsed) { m_asAudioEntities[id].m_bStatus = status; } + } +} + +uint32 +cAudioManager::SetLoopingCollisionRequestedSfxFreqAndGetVol(cAudioCollision *audioCollision) +{ + uint8 surface1 = audioCollision->m_bSurface1; + uint8 surface2 = audioCollision->m_bSurface2; + int32 vol; + float ratio; + + if(surface1 != SURFACE_GRASS && surface2 != SURFACE_GRASS && surface1 != SURFACE_HEDGE && + surface2 != SURFACE_HEDGE) { + if(surface1 != SURFACE_PUDDLE && surface2 != SURFACE_PUDDLE) { + if(surface1 != SURFACE_DIRT && surface2 != SURFACE_DIRT && + surface1 != SURFACE_DIRTTRACK && surface2 != SURFACE_DIRTTRACK && + surface1 != SURFACE_SAND && surface2 != SURFACE_SAND) { + if(surface1 == SURFACE_FLESH || surface2 == SURFACE_FLESH) { + return 0; + } + ratio = GetCollisionRatio(audioCollision->m_fIntensity2, 0.0001f, + 0.09f, 0.0899f); + m_sQueueSample.m_nSampleIndex = + AUDIO_SAMPLE_COLLISION_LOOPING_GENERIC; + m_sQueueSample.m_nFrequency = 10000.f * ratio + 10000; + vol = 40.f * ratio; + } else { + ratio = GetCollisionRatio(audioCollision->m_fIntensity2, 0.0001f, + 0.09f, 0.0899f); + m_sQueueSample.m_nSampleIndex = AUDIO_SAMPLE_COLLISION_LOOPING_SOFT; + m_sQueueSample.m_nFrequency = 6000.f * ratio + 10000; + vol = 50.f * ratio; + } + } else { + ratio = GetCollisionRatio(audioCollision->m_fIntensity2, 0.0001f, 0.09f, + 0.0899f); + m_sQueueSample.m_nSampleIndex = AUDIO_SAMPLE_LOOPING_WATER; + m_sQueueSample.m_nFrequency = 6050.f * ratio + 16000; + vol = 30.f * ratio; + } + } else { + ratio = GetCollisionRatio(audioCollision->m_fIntensity2, 0.0001f, 0.09f, 0.0899f); + m_sQueueSample.m_nSampleIndex = AUDIO_SAMPLE_COLLISION_LOOPING_GRASS; + m_sQueueSample.m_nFrequency = 13000.f * ratio + 35000; + vol = 50.f * ratio; } + if(audioCollision->m_nBaseVolume < 2) vol = audioCollision->m_nBaseVolume * vol / 2; + return vol; } void @@ -7926,7 +8591,48 @@ cAudioManager::SetMusicMasterVolume(uint8 volume) const void cAudioManager::SetSpeakerConfig(int32 conf) const { - SampleManager.SetSpeakerConfig(conf); + SampleManager.SetSpeakerConfig(conf); +} + +void +cAudioManager::SetUpLoopingCollisionSound(cAudioCollision *col, uint8 counter) +{ + if(col->m_fIntensity2 > 0.0016f) { + uint8 emittingVol = SetLoopingCollisionRequestedSfxFreqAndGetVol(col); + if(emittingVol) { + m_sQueueSample.m_fDistance = Sqrt(col->m_fDistance); + m_sQueueSample.m_bVolume = + ComputeVolume(emittingVol, 60.f, m_sQueueSample.m_fDistance); + if(m_sQueueSample.m_bVolume) { + m_sQueueSample.m_counter = counter; + m_sQueueSample.m_vecPos = col->m_vecPosition; + m_sQueueSample.m_bBankIndex = 0; + m_sQueueSample.m_bIsDistant = 0; + m_sQueueSample.field_16 = 7; + m_sQueueSample.m_nLoopCount = 0; + m_sQueueSample.m_bEmittingVolume = emittingVol; + m_sQueueSample.m_nLoopStart = + SampleManager.GetSampleLoopStartOffset( + m_sQueueSample.m_nSampleIndex); + m_sQueueSample.m_nLoopEnd = SampleManager.GetSampleLoopEndOffset( + m_sQueueSample.m_nSampleIndex); + m_sQueueSample.field_48 = 4.0f; + m_sQueueSample.m_fSoundIntensity = 60.0f; + m_sQueueSample.field_56 = 0; + m_sQueueSample.field_76 = 5; + m_sQueueSample.m_bReverbFlag = 1; + m_sQueueSample.m_bRequireReflection = 0; + AddSampleToRequestedQueue(); + } + } + } +} + +WRAPPER +bool +cAudioManager::SetupCrimeReport() +{ + EAXJMP(0x57F5B0); } WRAPPER @@ -8010,9 +8716,9 @@ cAudioManager::SetupJumboTaxiSound(uint8 vol) if(m_sQueueSample.m_fDistance >= 180.f) return 0; - emittingVol = (vol >> 1) + ((vol >> 1) * m_sQueueSample.m_fDistance * 0.0055556f); + emittingVol = (vol + (vol * m_sQueueSample.m_fDistance / 180)) / 2; - if(m_sQueueSample.m_fDistance * 0.0055556f < 0.7f) + if(m_sQueueSample.m_fDistance / 180 < 0.7f) emittingVol -= emittingVol * gJumboVolOffsetPercentage / 100; m_sQueueSample.m_bVolume = ComputeVolume(emittingVol, 180.f, m_sQueueSample.m_fDistance); @@ -8197,6 +8903,13 @@ cAudioManager::SetupPedComments(cPedParams *params, uint32 sound) } } +WRAPPER +void +cAudioManager::SetupSuspectLastSeenReport() +{ + EAXJMP(0x57FCC0); +} + void cAudioManager::Terminate() { @@ -8289,15 +9002,39 @@ cAudioManager::UsesSirenSwitching(int32 model) const } } +WRAPPER +void +cAudioManager::sub_57C2B0() +{ + EAXJMP(0x57C2B0); +} + +int32 +cAudioManager::sub_57C320(uint8 a1, float a2, float a3) +{ + float v4; + float v5; + int32 v6; + + v4 = 0.25f * a2; + v5 = a2 - v4; + if(a3 <= v5) + v6 = a1; + else + v6 = ((v4 - (a3 - v5)) * (float)a1 / v4); + return v6; +} + STARTPATCHES InjectHook(0x57B210, &cAudioManager::AddDetailsToRequestedOrderList, PATCH_JUMP); InjectHook(0x56AD30, &cAudioManager::AddPlayerCarSample, PATCH_JUMP); InjectHook(0x57B300, &cAudioManager::AddReflectionsToRequestedQueue, PATCH_JUMP); -// InjectHook(0x57B8D0, &cAudioManager::AddReleasingSounds, PATCH_JUMP); +InjectHook(0x57B8D0, &cAudioManager::AddReleasingSounds, PATCH_JUMP); InjectHook(0x57B070, &cAudioManager::AddSampleToRequestedQueue, PATCH_JUMP); -// InjectHook(0x580AF0, &cAudioManager::AgeCrimes, PATCH_JUMP); +InjectHook(0x580AF0, &cAudioManager::AgeCrimes, PATCH_JUMP); InjectHook(0x5697A0, &cAudioManager::CalculateDistance, PATCH_JUMP); InjectHook(0x57AA10, &cAudioManager::CheckForAnAudioFileOnCD, PATCH_JUMP); +InjectHook(0x57C160, &cAudioManager::ClearActiveSamples, PATCH_JUMP); InjectHook(0x5796A0, &cAudioManager::ClearMissionAudio, PATCH_JUMP); InjectHook(0x57C120, &cAudioManager::ClearRequestedQueue, PATCH_JUMP); InjectHook(0x57AE00, &cAudioManager::ComputeDopplerEffectedFrequency, PATCH_JUMP); @@ -8366,6 +9103,8 @@ InjectHook(0x57A8A0, &cAudioManager::GetNum3DProvidersAvailable, PATCH_JUMP); InjectHook(0x574FD0, &cAudioManager::GetOJGTalkSfx, PATCH_JUMP); InjectHook(0x570960, &cAudioManager::GetPedCommentSfx, PATCH_JUMP); InjectHook(0x570DB0, &cAudioManager::GetPhrase, PATCH_JUMP); +InjectHook(0x56BF80, &cAudioManager::GetVehicleDriveWheelSkidValue, PATCH_JUMP); +InjectHook(0x56C120, &cAudioManager::GetVehicleNonDriveWheelSkidValue, PATCH_JUMP); InjectHook(0x575240, &cAudioManager::GetPimpTalkSfx, PATCH_JUMP); InjectHook(0x570E00, &cAudioManager::GetPlayerTalkSfx, PATCH_JUMP); InjectHook(0x5737E0, &cAudioManager::GetScumFemaleTalkSfx, PATCH_JUMP); @@ -8395,6 +9134,7 @@ InjectHook(0x5718D0, &cAudioManager::GetYakuzaTalkSfx, PATCH_JUMP); InjectHook(0x5719E0, &cAudioManager::GetYardieTalkSfx, PATCH_JUMP); InjectHook(0x56CAB0, &cAudioManager::HasAirBrakes, PATCH_JUMP); InjectHook(0x57A0E0, &cAudioManager::Initialise, PATCH_JUMP); +InjectHook(0x57EEC0, &cAudioManager::InitialisePoliceRadio, PATCH_JUMP); // InjectHook(0x57EAC0, &cAudioManager::InitialisePoliceRadioZones, PATCH_JUMP); InjectHook(0x57B030, &cAudioManager::InterrogateAudioEntities, PATCH_JUMP); InjectHook(0x57AA50, &cAudioManager::IsAudioInitialised, PATCH_JUMP); @@ -8445,6 +9185,7 @@ InjectHook(0x56F4D0, &cAudioManager::ProcessPedHeadphones, PATCH_JUMP); InjectHook(0x5699C0, &cAudioManager::ProcessPhysical, PATCH_JUMP); InjectHook(0x56E860, &cAudioManager::ProcessPlane, PATCH_JUMP); InjectHook(0x56B0D0, &cAudioManager::ProcessPlayersVehicleEngine, PATCH_JUMP); +InjectHook(0x578190, &cAudioManager::ProcessPoliceCellBeatingScriptObject, PATCH_JUMP); InjectHook(0x577280, &cAudioManager::ProcessPornCinema, PATCH_JUMP); InjectHook(0x569CC0, &cAudioManager::ProcessRainOnVehicle, PATCH_JUMP); InjectHook(0x569700, &cAudioManager::ProcessReverb, PATCH_JUMP); @@ -8457,14 +9198,22 @@ InjectHook(0x56DBF0, &cAudioManager::ProcessTrainNoise, PATCH_JUMP); InjectHook(0x56C770, &cAudioManager::ProcessVehicleDoors, PATCH_JUMP); InjectHook(0x56C640, &cAudioManager::ProcessVehicleReverseWarning, PATCH_JUMP); InjectHook(0x56A230, &cAudioManager::ProcessVehicleRoadNoise, PATCH_JUMP); +InjectHook(0x56BCB0, &cAudioManager::ProcessVehicleSkidding, PATCH_JUMP); InjectHook(0x578370, &cAudioManager::ProcessWeather, PATCH_JUMP); InjectHook(0x56A440, &cAudioManager::ProcessWetRoadNoise, PATCH_JUMP); InjectHook(0x577530, &cAudioManager::ProcessWorkShopScriptObject, PATCH_JUMP); InjectHook(0x57AF90, &cAudioManager::RandomDisplacement, PATCH_JUMP); InjectHook(0x57A9F0, &cAudioManager::ReacquireDigitalHandle, PATCH_JUMP); InjectHook(0x57A9E0, &cAudioManager::ReleaseDigitalHandle, PATCH_JUMP); +InjectHook(0x568410, &cAudioManager::ReportCollision, PATCH_JUMP); +InjectHook(0x5803D0, &cAudioManager::ReportCrime, PATCH_JUMP); InjectHook(0x569650, &cAudioManager::ResetAudioLogicTimers, PATCH_JUMP); InjectHook(0x57EFF0, &cAudioManager::ResetPoliceRadio, PATCH_JUMP); +InjectHook(0x57A7B0, &cAudioManager::ResetTimers, PATCH_JUMP); +InjectHook(0x57F110, &cAudioManager::ServicePoliceRadio, PATCH_JUMP); +InjectHook(0x57F1B0, &cAudioManager::ServicePoliceRadioChannel, PATCH_JUMP); +//InjectHook(0x57AA60, &cAudioManager::ServiceSoundEffects, PATCH_JUMP); +InjectHook(0x57A910, &cAudioManager::SetCurrent3DProvider, PATCH_JUMP); InjectHook(0x57AA00, &cAudioManager::SetDynamicAcousticModelingStatus, PATCH_JUMP); InjectHook(0x57A770, &cAudioManager::SetEffectsFadeVolume, PATCH_JUMP); InjectHook(0x57A730, &cAudioManager::SetEffectsMasterVolume, PATCH_JUMP); @@ -8485,6 +9234,8 @@ InjectHook(0x56AC80, &cAudioManager::UpdateGasPedalAudio, PATCH_JUMP); InjectHook(0x56C600, &cAudioManager::UsesReverseWarning, PATCH_JUMP); InjectHook(0x56C3C0, &cAudioManager::UsesSiren, PATCH_JUMP); InjectHook(0x56C3F0, &cAudioManager::UsesSirenSwitching, PATCH_JUMP); +InjectHook(0x57C320, &cAudioManager::sub_57C320, PATCH_JUMP); InjectHook(0x5755C0, &cPedComments::Add, PATCH_JUMP); InjectHook(0x575730, &cPedComments::Process, PATCH_JUMP); +InjectHook(0x5685E0, &cAudioCollisionManager::AddCollisionToRequestedQueue, PATCH_JUMP); ENDPATCHES diff --git a/src/audio/AudioManager.h b/src/audio/AudioManager.h index fb462e94..59a92a48 100644 --- a/src/audio/AudioManager.h +++ b/src/audio/AudioManager.h @@ -45,7 +45,7 @@ public: uint8 field_82; uint8 field_83; int32 calculatedVolume; - uint8 field_88; + int8 field_88; uint8 field_89; uint8 field_90; uint8 field_91; @@ -158,7 +158,8 @@ public: uint8 gap_811; cAudioCollision m_sQueue; - void AddCollisionToRequestedQueue(); // todo + // reversed all methods + void AddCollisionToRequestedQueue(); /// ok }; static_assert(sizeof(cAudioCollisionManager) == 852, "cAudioCollisionManager: error"); @@ -199,6 +200,8 @@ public: CVector Posn; int32 AudioEntity; + void Reset(); // todo hook + static void *operator new(size_t); static void *operator new(size_t, int); static void operator delete(void *, size_t); @@ -232,6 +235,15 @@ enum AudioEntityHandle { AEHANDLE_ERROR_BADAUDIOTYPE = -1, }; +struct Crime { + int32 type; + CVector position; + uint16 timer; + uint16 b; +}; + +static_assert(sizeof(Crime) == 20, "Crime: error "); + class cAudioManager { public: @@ -248,10 +260,13 @@ public: uint8 field_13; uint8 field_14; uint8 field_15; + // 100 int32 m_nTimer; tActiveSample m_sQueueSample; - uint8 m_bActiveSampleQueue; + // 224 + bool m_bActiveSampleQueue; uint8 gap_109[3]; + // 264 tActiveSample m_asSamples[2][27]; uint8 m_abSampleQueueIndexTable[2][27]; uint8 m_bSampleRequestQueuesStatus[2]; @@ -267,7 +282,13 @@ public: int32 m_nFireAudioEntity; int32 m_nWaterCannonEntity; int32 m_nPoliceChannelEntity; - uint8 gap45B8[444]; + uint8 stuff[239]; + uint8 unk1; + uint8 unk2; + uint8 unk3; + uint8 unk4; + uint8 unk5; + Crime crimes[10]; int32 m_nFrontEndEntity; int32 m_nCollisionEntity; cAudioCollisionManager m_sCollisionManager; @@ -279,24 +300,25 @@ public: uint8 m_bUserPause; uint8 m_bPreviousUserPause; uint8 field_19195; // time? - uint32 m_FrameCounter; + uint32 m_nTimeOfRecentCrime; // getters - uint32 GetFrameCounter() const { return m_FrameCounter; } + uint32 GetFrameCounter() const { return m_nTimeOfRecentCrime; } float GetReflectionsDistance(int32 idx) const { return m_afReflectionsDistances[idx]; } int32 GetRandomNumber(int32 idx) const { return m_anRandomTable[idx]; } // "Should" be in alphabetic order, except "getXTalkSfx" - void AddDetailsToRequestedOrderList(uint8 sample); /// ok + void AddDetailsToRequestedOrderList(uint8 sample); /// ok (check once more) void AddPlayerCarSample(uint8 emittingVolume, int32 freq, uint32 sample, uint8 unk1, uint8 counter, bool notLooping); /// ok void AddReflectionsToRequestedQueue(); /// ok (check value) - void AddReleasingSounds(); // todo (difficult) + void AddReleasingSounds(); /// ok (check) void AddSampleToRequestedQueue(); /// ok - void AgeCrimes(); // todo + void AgeCrimes(); /// ok void CalculateDistance(bool *ptr, float dist); /// ok bool CheckForAnAudioFileOnCD() const; /// ok + void ClearActiveSamples(); /// ok void ClearMissionAudio(); /// ok void ClearRequestedQueue(); /// ok int32 ComputeDopplerEffectedFrequency(uint32 oldFreq, float position1, float position2, @@ -395,7 +417,7 @@ public: uint8 GetCDAudioDriveLetter() const; int8 GetCurrent3DProviderIndex() const; /// ok float GetCollisionLoopingRatio(uint32 a, uint32 b, float c) const; // not used - float GetCollisionOneShotRatio(uint32 a, float b) const; /// ok + float GetCollisionOneShotRatio(int32 a, float b) const; /// ok float GetCollisionRatio(float a, float b, float c, float d) const; /// ok float GetDistanceSquared(CVector *v) const; /// ok int32 GetJumboTaxiFreq() const; /// ok @@ -404,14 +426,17 @@ public: uint8 GetNum3DProvidersAvailable() const; int32 GetPedCommentSfx(CPed *ped, int32 sound); void GetPhrase(uint32 *phrase, uint32 *prevPhrase, uint32 sample, uint32 maxOffset) const; - float GetVehicleDriveWheelSkidValue(uint8 a1, CAutomobile *a2, cTransmission *a3, - float a4); // todo - int32 GetVehicleNonDriveWheelSkidValue(float a1, int a2, int a3, int a4, float a5); // todo + float GetVehicleDriveWheelSkidValue(uint8 wheel, CAutomobile *automobile, + cTransmission *transmission, + float velocityChange); /// ok + float GetVehicleNonDriveWheelSkidValue(uint8 wheel, CAutomobile *automobile, + cTransmission *transmission, + float velocityChange); /// ok bool HasAirBrakes(int32 model) const; /// ok void Initialise(); /// ok - void InitialisePoliceRadio(); // todo + void InitialisePoliceRadio(); /// ok void InitialisePoliceRadioZones(); // todo void InterrogateAudioEntities(); /// ok bool IsAudioInitialised() const; /// ok @@ -464,7 +489,7 @@ public: void ProcessLaunderetteScriptObject(uint8 sound); /// ok void ProcessLoopingScriptObject(uint8 sound); /// ok void ProcessMissionAudio(); /// ok - void ProcessModelCarEngine(cVehicleParams *params); /// ok (check float comparisons) + void ProcessModelCarEngine(cVehicleParams *params); /// ok void ProcessOneShotScriptObject(uint8 sound); /// ok void ProcessPed(CPhysical *ped); /// ok void ProcessPedHeadphones(cPedParams *params); /// ok @@ -473,7 +498,7 @@ public: void ProcessPlane(cVehicleParams *params); /// ok void ProcessPlayersVehicleEngine(cVehicleParams *params, CAutomobile *automobile); /// ok (check float comparisons) - void ProcessPoliceCellBeatingScriptObject(uint8 sound); // todo + void ProcessPoliceCellBeatingScriptObject(uint8 sound); /// ok void ProcessPornCinema(uint8 sound); /// ok void ProcessProjectiles(); // todo requires CProjectileInfo void ProcessRainOnVehicle(cVehicleParams *params); /// ok @@ -486,49 +511,49 @@ public: bool ProcessTrainNoise(cVehicleParams *params); /// ok void ProcessVehicle(CVehicle *); // todo bool ProcessVehicleDoors(cVehicleParams *params); /// ok - // bool ProcessVehicleEngine(void *); - // void ProcessVehicleHorn(cVehicleParams *params); - // void ProcessVehicleOneShots(void *); + bool ProcessVehicleEngine(void *); // todo + void ProcessVehicleHorn(cVehicleParams *params); // todo + void ProcessVehicleOneShots(void *); // todo bool ProcessVehicleReverseWarning(cVehicleParams *params); /// ok bool ProcessVehicleRoadNoise(cVehicleParams *params); /// ok - // void ProcessVehicleSirenOrAlarm(void *); - // void ProcessVehicleSkidding(void *); - void ProcessWaterCannon(int32); // todo - void ProcessWeather(int32 id); /// ok - bool ProcessWetRoadNoise(cVehicleParams *params); /// ok - void ProcessWorkShopScriptObject(uint8 sound); /// ok + void ProcessVehicleSirenOrAlarm(void *); // todo + void ProcessVehicleSkidding(cVehicleParams *params); /// ok + void ProcessWaterCannon(int32); // todo + void ProcessWeather(int32 id); /// ok + bool ProcessWetRoadNoise(cVehicleParams *params); /// ok + void ProcessWorkShopScriptObject(uint8 sound); /// ok int32 RandomDisplacement(uint32 seed) const; void ReacquireDigitalHandle() const; void ReleaseDigitalHandle() const; - int32 ReportCollision(CEntity *a2, CEntity *a3, uint8 a4, uint8 a5, float a6, - float a7); // todo - int32 ReportCrime(eCrimeType crime, const CVector *pos); // todo - void ResetAudioLogicTimers(int32 timer); /// ok - void ResetPoliceRadio(); /// ok - void ResetTimers(uint32 a2); // todo + void ReportCollision(CEntity *entity1, CEntity *entity2, uint8 surface1, uint8 surface2, + float collisionPower, float intensity2); /// ok + void ReportCrime(int32 crime, const CVector *pos); /// ok + void ResetAudioLogicTimers(int32 timer); /// ok + void ResetPoliceRadio(); /// ok + void ResetTimers(uint32 time); /// ok - void Service(); // todo - void ServiceCollisions(); // todo - void ServicePoliceRadio(); // todo - void ServicePoliceRadioChannel(int a2); // todo - void ServiceSoundEffects(); // todo - int8 SetCurrent3DProvider(uint8); // todo + void Service(); // todo + void ServiceCollisions(); // todo + void ServicePoliceRadio(); /// ok + void ServicePoliceRadioChannel(int32 wantedLevel); /// ok + void ServiceSoundEffects(); /// ok + int8 SetCurrent3DProvider(uint8 which); /// ok void SetDynamicAcousticModelingStatus(bool status); void SetEffectsFadeVolume(uint8 volume) const; void SetEffectsMasterVolume(uint8 volume) const; void SetEntityStatus(int32 id, bool status); - uint32 SetLoopingCollisionRequestedSfxFreqAndGetVol(int32); // todo + uint32 SetLoopingCollisionRequestedSfxFreqAndGetVol(cAudioCollision *audioCollision); // todo hook void SetMissionAudioLocation(float x, float y, float z); void SetMissionScriptPoliceAudio(int32 sfx) const; - void SetMonoMode(uint8); // todo + void SetMonoMode(uint8); // todo (mobile) void SetMusicFadeVolume(uint8 volume) const; void SetMusicMasterVolume(uint8 volume) const; void SetSpeakerConfig(int32 conf) const; - void SetUpLoopingCollisionSound(int a2, int a3); // todo + void SetUpLoopingCollisionSound(cAudioCollision *col, uint8 counter); // todo hook void SetUpOneShotCollisionSound(int a2); // todo - void SetupCrimeReport(); // todo - bool SetupJumboEngineSound(uint8, int32); // todo + bool SetupCrimeReport(); // todo + bool SetupJumboEngineSound(uint8 a2, int32 a3); // todo bool SetupJumboFlySound(uint8 emittingVol); /// ok bool SetupJumboRumbleSound(uint8 emittingVol); /// ok bool SetupJumboTaxiSound(uint8 vol); /// ok @@ -537,12 +562,15 @@ public: void SetupSuspectLastSeenReport(); // todo void Terminate(); - void TranslateEntity(CVector *v1, CVector *v2) const; /// ok + void TranslateEntity(CVector *v1, CVector *v2) const; - void UpdateGasPedalAudio(CAutomobile *automobile); // todo hook + void UpdateGasPedalAudio(CAutomobile *automobile); bool UsesReverseWarning(int32 model) const; bool UsesSiren(int32 model) const; bool UsesSirenSwitching(int32 model) const; + + void sub_57C2B0(); // todo (weird) and obtain name + int32 sub_57C320(uint8 a1, float a2, float a3); /// ok (get name) }; static_assert(sizeof(cAudioManager) == 19220, "cAudioManager: error"); diff --git a/src/audio/DMAudio.cpp b/src/audio/DMAudio.cpp index 82267858..8b4de961 100644 --- a/src/audio/DMAudio.cpp +++ b/src/audio/DMAudio.cpp @@ -26,7 +26,7 @@ cDMAudio::Service(void) } int32 -cDMAudio::CreateEntity(eAudioType type, void *UID) +cDMAudio::CreateEntity(int32 type, void *UID) { return AudioManager.CreateEntity(type, (CPhysical *)UID); } diff --git a/src/audio/DMAudio.h b/src/audio/DMAudio.h index fe120576..9c551733 100644 --- a/src/audio/DMAudio.h +++ b/src/audio/DMAudio.h @@ -180,7 +180,6 @@ enum eSound : int16 class cAudioScriptObject; class CEntity; enum eCrimeType; -enum eAudioType; class cDMAudio { @@ -192,7 +191,7 @@ public: void Terminate(void); void Service(void); - int32 CreateEntity(eAudioType type, void *UID); + int32 CreateEntity(int32 type, void *UID); void DestroyEntity(int32 audioEntity); void SetEntityStatus(int32 audioEntity, uint8 status); void PlayOneShot(int32 audioEntity, uint16 oneShot, float volume); diff --git a/src/audio/MusicManager.cpp b/src/audio/MusicManager.cpp index 01a21d5d..a14994cd 100644 --- a/src/audio/MusicManager.cpp +++ b/src/audio/MusicManager.cpp @@ -239,7 +239,15 @@ WRAPPER void cMusicManager::SetRadioInCar(unsigned int) EAXJMP(0x57D2C0); } -WRAPPER void cMusicManager::SetRadioChannelByScript(unsigned char, int) +WRAPPER void +cMusicManager::SetRadioChannelByScript(unsigned char, int) { EAXJMP(0x57D180); +} + +WRAPPER +void +cMusicManager::ResetMusicAfterReload() +{ + EAXJMP(0x57CF30); } \ No newline at end of file diff --git a/src/audio/MusicManager.h b/src/audio/MusicManager.h index f20424a8..6ced08f7 100644 --- a/src/audio/MusicManager.h +++ b/src/audio/MusicManager.h @@ -286,7 +286,7 @@ public: char *Get3DProviderName(char); bool PlayerInCar(); void DisplayRadioStationName(); - + void PlayAnnouncement(unsigned char); void PlayFrontEndTrack(unsigned char, unsigned char); void PreloadCutSceneMusic(unsigned char); @@ -295,6 +295,8 @@ public: int32 GetRadioInCar(void); void SetRadioInCar(unsigned int); void SetRadioChannelByScript(unsigned char, int); + + void ResetMusicAfterReload(); }; static_assert(sizeof(cMusicManager) == 0x95C, "cMusicManager: error"); diff --git a/src/control/PathFind.cpp b/src/control/PathFind.cpp index 3c16202b..700a89f1 100644 --- a/src/control/PathFind.cpp +++ b/src/control/PathFind.cpp @@ -1278,38 +1278,50 @@ CPathFind::DoPathSearch(uint8 type, CVector start, int32 startNodeId, CVector ta targetNode = FindNodeClosestToCoors(target, type, distLimit); else targetNode = forcedTargetNode; - if(targetNode < 0) - goto fail; + if(targetNode < 0) { + *pNumNodes = 0; + if(pDist) *pDist = 100000.0f; + return; + } // Find start int numPathsToTry; CTreadable *startObj; - if(startNodeId < 0){ + if(startNodeId < 0) { if(vehicle == nil || (startObj = vehicle->m_treadable[type]) == nil) startObj = FindRoadObjectClosestToCoors(start, type); numPathsToTry = 0; - for(i = 0; i < 12; i++){ - if(startObj->m_nodeIndices[type][i] < 0) - break; - if(m_pathNodes[startObj->m_nodeIndices[type][i]].group == m_pathNodes[targetNode].group) + for(i = 0; i < 12; i++) { + if(startObj->m_nodeIndices[type][i] < 0) break; + if(m_pathNodes[startObj->m_nodeIndices[type][i]].group == + m_pathNodes[targetNode].group) numPathsToTry++; } - }else{ + } else { numPathsToTry = 1; startObj = m_mapObjects[m_pathNodes[startNodeId].objectIndex]; } - if(numPathsToTry == 0) - goto fail; - - if(startNodeId < 0){ - // why only check node 0? - if(m_pathNodes[startObj->m_nodeIndices[type][0]].group != m_pathNodes[targetNode].group) - goto fail; - }else{ - if(m_pathNodes[startNodeId].group != m_pathNodes[targetNode].group) - goto fail; + if(numPathsToTry == 0) { + *pNumNodes = 0; + if(pDist) *pDist = 100000.0f; + return; } + if(startNodeId < 0) { + // why only check node 0? + if(m_pathNodes[startObj->m_nodeIndices[type][0]].group != + m_pathNodes[targetNode].group) { + *pNumNodes = 0; + if(pDist) *pDist = 100000.0f; + return; + } + } else { + if(m_pathNodes[startNodeId].group != m_pathNodes[targetNode].group) { + *pNumNodes = 0; + if(pDist) *pDist = 100000.0f; + return; + } + } for(i = 0; i < 512; i++) m_searchNodes[i].next = nil; @@ -1388,11 +1400,6 @@ CPathFind::DoPathSearch(uint8 type, CVector start, int32 startNodeId, CVector ta for(i = 0; i < numNodesToBeCleared; i++) apNodesToBeCleared[i]->distance = MAX_DIST; return; - -fail: - *pNumNodes = 0; - if(pDist) - *pDist = 100000.0f; } static CPathNode *pNodeList[32]; diff --git a/src/core/common.h b/src/core/common.h index 920b7108..0a2e6768 100644 --- a/src/core/common.h +++ b/src/core/common.h @@ -121,7 +121,7 @@ public: CRGBA(void) { } CRGBA(uint8 r, uint8 g, uint8 b, uint8 a) : r(r), g(g), b(b), a(a) { } - CRGBA &CRGBA::operator =(const CRGBA &right) + CRGBA &operator =(const CRGBA &right) { this->r = right.r; this->g = right.g; @@ -142,7 +142,7 @@ public: return rwRGBA; } - CRGBA &CRGBA::operator =(const RwRGBA &right) + CRGBA &operator =(const RwRGBA &right) { this->r = right.red; this->g = right.green; @@ -197,8 +197,8 @@ void re3_assert(const char *expr, const char *filename, unsigned int lineno, con #define ARRAY_SIZE(array) (sizeof(array) / sizeof(array[0])) #define BIT(num) (1<<(num)) -#define max(a, b) (((a) > (b)) ? (a) : (b)) -#define min(a, b) (((a) < (b)) ? (a) : (b)) +auto max = [](auto a, auto b) { return ((a) > (b)) ? (a) : (b); }; +auto min = [](auto a, auto b) { return ((a) < (b)) ? (a) : (b); }; #define ABS(a) (((a) < 0) ? (-(a)) : (a)) #define norm(value, min, max) (((value) < (min)) ? 0 : (((value) > (max)) ? 1 : (((value) - (min)) / ((max) - (min)))))