1419 lines
54 KiB
C++
1419 lines
54 KiB
C++
#include "script/script_brains.h"
|
|
|
|
// Rage headers
|
|
|
|
// Game headers
|
|
#include "control/gamelogic.h"
|
|
#include "ModelInfo/ModelInfo.h"
|
|
#include "ModelInfo/ModelInfo_Factories.h"
|
|
#include "network/NetworkInterface.h"
|
|
#include "peds/ped.h"
|
|
#include "scene/world/GameWorld.h"
|
|
#include "scene/worldpoints.h"
|
|
#include "script/script.h"
|
|
#include "script/script_helper.h"
|
|
#include "script/streamedscripts.h"
|
|
#include "streaming/streamingvisualize.h"
|
|
#include "debug/debugglobals.h"
|
|
#include "scene/DataFileMgr.h"
|
|
#include "control/replay/ReplaySettings.h"
|
|
|
|
#define DEFAULT_OBJECT_ACTIVATION_RANGE (5.0f)
|
|
|
|
class CScriptBrainFileMounter : public CDataFileMountInterface
|
|
{
|
|
virtual bool LoadDataFile(const CDataFileMgr::DataFile & file)
|
|
{
|
|
switch(file.m_fileType)
|
|
{
|
|
case CDataFileMgr::SCRIPT_BRAIN_FILE: CTheScripts::GetScriptsForBrains().AddScriptBrainsFromFile(file.m_filename); break;
|
|
default: return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
virtual void UnloadDataFile(const CDataFileMgr::DataFile & file)
|
|
{
|
|
switch(file.m_fileType)
|
|
{
|
|
case CDataFileMgr::SCRIPT_BRAIN_FILE: CTheScripts::GetScriptsForBrains().RemoveScriptBrainsFromFile(file.m_filename); break;
|
|
default: break;
|
|
}
|
|
}
|
|
} g_ScriptBrainFileMounter;
|
|
|
|
// start of script brain functions
|
|
|
|
void CScriptsForBrains::script_brain_struct::Initialise()
|
|
{
|
|
m_ScriptFileName.Clear();
|
|
m_fBrainActivationRange = DEFAULT_OBJECT_ACTIVATION_RANGE;
|
|
m_ScenarioName.Clear(); // Used by Scenario Ped brains
|
|
m_ModelHashkey = 0;
|
|
m_TypeOfBrain = -1;
|
|
m_ObjectGroupingID = -1;
|
|
m_PercentageChance = 0;
|
|
m_bBrainActive = true;
|
|
m_SetToWhichThisBrainBelongs = 0;
|
|
// bOnlyGiveBrainToScenarioPeds = false;
|
|
}
|
|
|
|
void CScriptsForBrains::AddScriptBrainsFromFile(const char* filePath)
|
|
{
|
|
sScriptBrainLists brainsToLoad;
|
|
|
|
if (PARSER.LoadObject(filePath, NULL, brainsToLoad))
|
|
{
|
|
for (u32 i = 0; i < brainsToLoad.m_worldPointBrains.GetCount(); i++)
|
|
{
|
|
sWorldPointScriptBrains& currBrain = brainsToLoad.m_worldPointBrains[i];
|
|
|
|
AddScriptBrainForWorldPoint(strStreamingObjectNameString(currBrain.m_ScriptName),
|
|
CScriptsForBrains::WORLD_POINT, currBrain.m_ActivationRange, static_cast<u32>(currBrain.m_setToWhichThisBrainBelongs));
|
|
}
|
|
}
|
|
}
|
|
|
|
void CScriptsForBrains::RemoveScriptBrainsFromFile(const char* filePath)
|
|
{
|
|
sScriptBrainLists brainsToLoad;
|
|
|
|
if (PARSER.LoadObject(filePath, NULL, brainsToLoad))
|
|
{
|
|
for (u32 i = 0; i < brainsToLoad.m_worldPointBrains.GetCount(); i++)
|
|
{
|
|
sWorldPointScriptBrains& currBrain = brainsToLoad.m_worldPointBrains[i];
|
|
s16 brainIndex = (s16)GetIndexOfScriptBrainWithThisName(strStreamingObjectName(currBrain.m_ScriptName.GetHash()),
|
|
CScriptsForBrains::WORLD_POINT);
|
|
|
|
CWorldPoints::RemoveScriptBrain(brainIndex);
|
|
ResetSlot(brainIndex);
|
|
}
|
|
}
|
|
}
|
|
|
|
void CScriptsForBrains::Init(void)
|
|
{
|
|
CDataFileMount::RegisterMountInterface(CDataFileMgr::SCRIPT_BRAIN_FILE, &g_ScriptBrainFileMounter, eDFMI_UnloadFirst);
|
|
|
|
for (u32 loop = 0; loop < MAX_DIFFERENT_SCRIPT_BRAINS; loop++)
|
|
{
|
|
m_ScriptBrainArray[loop].Initialise();
|
|
}
|
|
|
|
m_SetsEnabled = 0;
|
|
|
|
// bEnableBrainAllocation = true; // needed when getclosestped style commands convert a dummy ped to a real ped
|
|
}
|
|
|
|
// void CScriptsForBrains::SetEnableBrainAllocationFlag(bool bEnableAllocation)
|
|
// {
|
|
// bEnableBrainAllocation = bEnableAllocation;
|
|
// }
|
|
|
|
// This is used to turn off all the casino object brains in Paul's Heist9 mission
|
|
/*
|
|
void CScriptsForBrains::SwitchAllObjectBrainsWithThisID(int object_grouping_id, bool bBrainOn)
|
|
{
|
|
if (object_grouping_id < 0)
|
|
return;
|
|
|
|
for (u32 loop = 0; loop < MAX_DIFFERENT_SCRIPT_BRAINS; loop++)
|
|
{
|
|
if (m_ScriptBrainArray[loop].m_ObjectGroupingID == object_grouping_id)
|
|
{
|
|
m_ScriptBrainArray[loop].m_bBrainActive = bBrainOn;
|
|
}
|
|
}
|
|
}
|
|
*/
|
|
|
|
|
|
void CScriptsForBrains::EnableBrainSet(u32 setToEnable)
|
|
{
|
|
Assertf(setToEnable > 0 && setToEnable <= (1 << 31), "CScriptsForBrains::EnableBrainSet - brain set can only be 1, 2, 4, 8, ... 2147483648");
|
|
m_SetsEnabled |= setToEnable;
|
|
scriptDebugf2("CScriptsForBrains::EnableBrainSet - called for %u. m_SetsEnabled is now %u", setToEnable, m_SetsEnabled);
|
|
}
|
|
|
|
void CScriptsForBrains::DisableBrainSet(u32 setToDisable)
|
|
{
|
|
Assertf(setToDisable > 0 && setToDisable <= (1 << 31), "CScriptsForBrains::DisableBrainSet - brain set can only be 1, 2, 4, 8, ... 2147483648");
|
|
m_SetsEnabled &= ~setToDisable;
|
|
scriptDebugf2("CScriptsForBrains::DisableBrainSet - called for %u. m_SetsEnabled is now %u", setToDisable, m_SetsEnabled);
|
|
}
|
|
|
|
void CScriptsForBrains::ResetSlot(s32 index)
|
|
{
|
|
if (index >= 0 && index < MAX_DIFFERENT_SCRIPT_BRAINS)
|
|
{
|
|
m_ScriptBrainArray[index].Initialise();
|
|
}
|
|
}
|
|
|
|
s32 CScriptsForBrains::FindFreeSlot()
|
|
{
|
|
s32 loop = 0;
|
|
while (loop < MAX_DIFFERENT_SCRIPT_BRAINS)
|
|
{
|
|
if (m_ScriptBrainArray[loop].m_ScriptFileName.GetLength() == 0)
|
|
{
|
|
return loop;
|
|
}
|
|
loop++;
|
|
}
|
|
return -1;
|
|
}
|
|
|
|
void CScriptsForBrains::AddScriptBrainForEntity(const strStreamingObjectNameString pScriptName, u32 EntityModelHashkey, u8 Percentage, s8 BrainType, s8 object_grouping_id, float ObjectActivationRange, u32 SetToWhichThisBrainBelongs)
|
|
{
|
|
scriptAssertf( (Percentage > 0) && (Percentage <= 100), "CScriptsForBrains::AddScriptBrainForEntity - Percentage must be greater than 0 and less than 101");
|
|
|
|
s32 free_slot = FindFreeSlot();
|
|
|
|
if (scriptVerifyf(free_slot >= 0, "CScriptsForBrains::AddScriptBrainForEntity - No more space for script brains"))
|
|
{
|
|
m_ScriptBrainArray[free_slot].m_ScriptFileName = pScriptName;
|
|
|
|
if (ObjectActivationRange <= 0.0f)
|
|
{
|
|
m_ScriptBrainArray[free_slot].m_fBrainActivationRange = DEFAULT_OBJECT_ACTIVATION_RANGE;
|
|
}
|
|
else
|
|
{
|
|
m_ScriptBrainArray[free_slot].m_fBrainActivationRange = ObjectActivationRange;
|
|
}
|
|
m_ScriptBrainArray[free_slot].m_ScenarioName.Clear(); // Only used by Scenario Ped brains
|
|
|
|
m_ScriptBrainArray[free_slot].m_ModelHashkey= EntityModelHashkey;
|
|
m_ScriptBrainArray[free_slot].m_TypeOfBrain = BrainType;
|
|
m_ScriptBrainArray[free_slot].m_ObjectGroupingID = object_grouping_id;
|
|
m_ScriptBrainArray[free_slot].m_PercentageChance = Percentage;
|
|
m_ScriptBrainArray[free_slot].m_bBrainActive = true;
|
|
m_ScriptBrainArray[free_slot].m_SetToWhichThisBrainBelongs = SetToWhichThisBrainBelongs;
|
|
// m_ScriptBrainArray[free_slot].bOnlyGiveBrainToScenarioPeds = bScenarioPedsOnly;
|
|
|
|
#if __ASSERT
|
|
u32 TotalPercentage = 0;
|
|
for (u32 loop = 0; loop < MAX_DIFFERENT_SCRIPT_BRAINS; loop++)
|
|
{
|
|
if ( (m_ScriptBrainArray[loop].m_ModelHashkey == EntityModelHashkey) && (m_ScriptBrainArray[loop].m_TypeOfBrain == BrainType) )
|
|
{
|
|
TotalPercentage += m_ScriptBrainArray[loop].m_PercentageChance;
|
|
}
|
|
}
|
|
scriptAssertf( (TotalPercentage > 0) && (TotalPercentage < 101), "CScriptsForBrains::AddScriptBrainForEntity - Total percentage for this ped is out of range");
|
|
#endif // __ASSERT
|
|
|
|
#if __DEV
|
|
u32 totalNumberOfUsedBrains = 0;
|
|
for (u32 loop = 0; loop < MAX_DIFFERENT_SCRIPT_BRAINS; loop++)
|
|
{
|
|
if (m_ScriptBrainArray[loop].m_ScriptFileName.GetLength() > 0)
|
|
{
|
|
totalNumberOfUsedBrains++;
|
|
}
|
|
}
|
|
scriptDisplayf("CScriptsForBrains::AddScriptBrainForEntity - Added %s Total number of used brains = %u", pScriptName.GetCStr(), totalNumberOfUsedBrains);
|
|
#endif // __DEV
|
|
}
|
|
}
|
|
|
|
|
|
void CScriptsForBrains::AddScriptBrainForWorldPoint(const strStreamingObjectNameString pScriptName, s8 BrainType, float ActivationRange, u32 SetToWhichThisBrainBelongs)
|
|
{
|
|
s32 free_slot = FindFreeSlot();
|
|
|
|
if(scriptVerifyf(free_slot >= 0, "CScriptsForBrains::AddScriptBrainForWorldPoint - No more space for script brains"))
|
|
{
|
|
m_ScriptBrainArray[free_slot].m_ScriptFileName = pScriptName;
|
|
m_ScriptBrainArray[free_slot].m_fBrainActivationRange = ActivationRange;
|
|
m_ScriptBrainArray[free_slot].m_ScenarioName.Clear(); // Only used by Scenario Ped brains
|
|
m_ScriptBrainArray[free_slot].m_ModelHashkey = 0;
|
|
m_ScriptBrainArray[free_slot].m_TypeOfBrain = BrainType;
|
|
m_ScriptBrainArray[free_slot].m_ObjectGroupingID = -1;
|
|
m_ScriptBrainArray[free_slot].m_PercentageChance = 0;
|
|
m_ScriptBrainArray[free_slot].m_bBrainActive = true;
|
|
m_ScriptBrainArray[free_slot].m_SetToWhichThisBrainBelongs = SetToWhichThisBrainBelongs;
|
|
// m_ScriptBrainArray[free_slot].bOnlyGiveBrainToScenarioPeds = false;
|
|
|
|
#if __DEV
|
|
u32 totalNumberOfUsedBrains = 0;
|
|
for (u32 loop = 0; loop < MAX_DIFFERENT_SCRIPT_BRAINS; loop++)
|
|
{
|
|
if (m_ScriptBrainArray[loop].m_ScriptFileName.GetLength() > 0)
|
|
{
|
|
totalNumberOfUsedBrains++;
|
|
}
|
|
}
|
|
scriptDisplayf("CScriptsForBrains::AddScriptBrainForWorldPoint - Added %s Total number of used brains = %u", pScriptName.GetCStr(), totalNumberOfUsedBrains);
|
|
#endif // __DEV
|
|
}
|
|
}
|
|
|
|
void CScriptsForBrains::AddScriptBrainForScenarioPed(const strStreamingObjectNameString pScriptName, const atHashWithStringNotFinal ScenarioName, u8 Percentage, float fActivationRange, u32 SetToWhichThisBrainBelongs)
|
|
{
|
|
scriptAssertf( (Percentage > 0) && (Percentage <= 100), "CScriptsForBrains::AddScriptBrainForScenarioPed - Percentage must be greater than 0 and less than 101");
|
|
|
|
s32 free_slot = FindFreeSlot();
|
|
|
|
if(scriptVerifyf(free_slot >= 0, "CScriptsForBrains::AddScriptBrainForScenarioPed - No more space for script brains"))
|
|
{
|
|
m_ScriptBrainArray[free_slot].m_ScriptFileName = pScriptName;
|
|
if (fActivationRange <= 0.0f)
|
|
{
|
|
m_ScriptBrainArray[free_slot].m_fBrainActivationRange = DEFAULT_OBJECT_ACTIVATION_RANGE;
|
|
}
|
|
else
|
|
{
|
|
m_ScriptBrainArray[free_slot].m_fBrainActivationRange = fActivationRange;
|
|
}
|
|
|
|
m_ScriptBrainArray[free_slot].m_ScenarioName = ScenarioName;
|
|
m_ScriptBrainArray[free_slot].m_ModelHashkey = 0;
|
|
m_ScriptBrainArray[free_slot].m_TypeOfBrain = SCENARIO_PED;
|
|
m_ScriptBrainArray[free_slot].m_ObjectGroupingID = -1;
|
|
m_ScriptBrainArray[free_slot].m_PercentageChance = Percentage;
|
|
m_ScriptBrainArray[free_slot].m_bBrainActive = true;
|
|
m_ScriptBrainArray[free_slot].m_SetToWhichThisBrainBelongs = SetToWhichThisBrainBelongs;
|
|
// m_ScriptBrainArray[free_slot].bOnlyGiveBrainToScenarioPeds = false;
|
|
|
|
#if __DEV
|
|
u32 totalNumberOfUsedBrains = 0;
|
|
for (u32 loop = 0; loop < MAX_DIFFERENT_SCRIPT_BRAINS; loop++)
|
|
{
|
|
if (m_ScriptBrainArray[loop].m_ScriptFileName.GetLength() > 0)
|
|
{
|
|
totalNumberOfUsedBrains++;
|
|
}
|
|
}
|
|
scriptDisplayf("CScriptsForBrains::AddScriptBrainForScenarioPed - Added %s Total number of used brains = %u", pScriptName.GetCStr(), totalNumberOfUsedBrains);
|
|
#endif // __DEV
|
|
}
|
|
}
|
|
|
|
|
|
void CScriptsForBrains::CheckAndApplyIfNewEntityNeedsScript(CEntity *pNewEntity, s8 BrainType)
|
|
{
|
|
scriptAssertf( (BrainType == PED_STREAMED) || (BrainType == OBJECT_STREAMED), "CScriptsForBrains::CheckAndApplyIfNewEntityNeedsScript - can only call for PED_STREAMED, OBJECT_STREAMED");
|
|
|
|
if ( BrainType == PED_STREAMED )
|
|
{
|
|
scriptAssertf( ((CPed *)pNewEntity)->GetPedConfigFlag( CPED_CONFIG_FLAG_HasAScriptBrain ) == false, "CScriptsForBrains::CheckAndApplyIfNewEntityNeedsScript - can't start a second script brain for ped");
|
|
scriptAssertf( ((CPed *)pNewEntity)->GetPedConfigFlag( CPED_CONFIG_FLAG_WaitingForScriptBrainToLoad ) == false, "CScriptsForBrains::CheckAndApplyIfNewEntityNeedsScript - already waiting for a streamed script brain to load for this ped");
|
|
if ( (((CPed *)pNewEntity)->GetPedConfigFlag( CPED_CONFIG_FLAG_HasAScriptBrain )) || (((CPed *)pNewEntity)->GetPedConfigFlag( CPED_CONFIG_FLAG_WaitingForScriptBrainToLoad )) )
|
|
{
|
|
return;
|
|
}
|
|
|
|
// bPedCreatedForScenario = ((CPed *)pNewEntity)->PopTypeGet() == POPTYPE_RANDOM_SCENARIO;
|
|
}
|
|
else
|
|
{
|
|
scriptAssertf( ((CObject *)pNewEntity)->m_nObjectFlags.ScriptBrainStatus == CObject::OBJECT_DOESNT_USE_SCRIPT_BRAIN, "CScriptsForBrains::CheckAndApplyIfNewEntityNeedsScript - this object has already been set up with a script brain");
|
|
if (((CObject *)pNewEntity)->m_nObjectFlags.ScriptBrainStatus != CObject::OBJECT_DOESNT_USE_SCRIPT_BRAIN)
|
|
{
|
|
return;
|
|
}
|
|
}
|
|
|
|
s32 scriptBrainIndexFound = -1;
|
|
u32 loop = 0;
|
|
while(loop < MAX_DIFFERENT_SCRIPT_BRAINS)
|
|
{
|
|
bool bMatch = false;
|
|
if( (m_ScriptBrainArray[loop].m_TypeOfBrain == BrainType) &&
|
|
(pNewEntity->GetBaseModelInfo() != NULL) &&
|
|
(m_ScriptBrainArray[loop].m_ModelHashkey == pNewEntity->GetBaseModelInfo()->GetModelNameHash()) )
|
|
{
|
|
bMatch = true;
|
|
}
|
|
|
|
if (bMatch)
|
|
{
|
|
s32 RandomInt = fwRandom::GetRandomNumberInRange(0, 100);
|
|
if (RandomInt < m_ScriptBrainArray[loop].m_PercentageChance)
|
|
{
|
|
scriptBrainIndexFound = loop;
|
|
}
|
|
}
|
|
loop++;
|
|
}
|
|
|
|
if(scriptBrainIndexFound >= 0)
|
|
{
|
|
StartOrRequestNewStreamedScriptBrain(scriptBrainIndexFound, pNewEntity, BrainType, true);
|
|
}
|
|
}
|
|
|
|
s32 CScriptsForBrains::GetBrainIndexForNewScenarioPed(u32 HashOfScenarioName)
|
|
{
|
|
u32 loop = 0;
|
|
while(loop < MAX_DIFFERENT_SCRIPT_BRAINS)
|
|
{
|
|
if ( (m_ScriptBrainArray[loop].m_TypeOfBrain == SCENARIO_PED)
|
|
&& (m_ScriptBrainArray[loop].m_ScenarioName.GetHash() == HashOfScenarioName) )
|
|
{
|
|
s32 RandomInt = fwRandom::GetRandomNumberInRange(0, 100);
|
|
if (RandomInt < m_ScriptBrainArray[loop].m_PercentageChance)
|
|
{
|
|
return loop;
|
|
}
|
|
}
|
|
|
|
loop++;
|
|
}
|
|
|
|
return -1;
|
|
}
|
|
|
|
void CScriptsForBrains::GiveScenarioBrainToPed(CPed *pPed, s32 ScenarioBrainIndex)
|
|
{
|
|
if (scriptVerifyf(ScenarioBrainIndex >= 0, "CScriptsForBrains::GiveScenarioBrainToPed - brain index should be >= 0"))
|
|
{
|
|
if (scriptVerifyf(m_ScriptBrainArray[ScenarioBrainIndex].m_TypeOfBrain == SCENARIO_PED, "CScriptsForBrains::GiveScenarioBrainToPed - brain with index %d is not a SCENARIO_PED brain", ScenarioBrainIndex))
|
|
{
|
|
if (scriptVerifyf(pPed->GetPedConfigFlag( CPED_CONFIG_FLAG_HasAScriptBrain ) == false, "CScriptsForBrains::GiveScenarioBrainToPed - can't start a second script brain for ped"))
|
|
{
|
|
if (scriptVerifyf(pPed->GetPedConfigFlag( CPED_CONFIG_FLAG_WaitingForScriptBrainToLoad ) == false, "CScriptsForBrains::GiveScenarioBrainToPed - already waiting for a streamed script brain to load for this ped"))
|
|
{
|
|
StartOrRequestNewStreamedScriptBrain(ScenarioBrainIndex, pPed, SCENARIO_PED, true);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
bool CScriptsForBrains::CanBrainSafelyRun(s32 ScriptBrainIndex)
|
|
{
|
|
if (scriptVerifyf( (ScriptBrainIndex >= 0) && (ScriptBrainIndex < MAX_DIFFERENT_SCRIPT_BRAINS), "CScriptsForBrains::CanBrainSafelyRun - script brain index %d is out of range 0 to %d", ScriptBrainIndex, MAX_DIFFERENT_SCRIPT_BRAINS))
|
|
{
|
|
if ( (OBJECT_STREAMED == m_ScriptBrainArray[ScriptBrainIndex].m_TypeOfBrain) || (WORLD_POINT == m_ScriptBrainArray[ScriptBrainIndex].m_TypeOfBrain) )
|
|
{
|
|
if ( (m_ScriptBrainArray[ScriptBrainIndex].m_SetToWhichThisBrainBelongs & m_SetsEnabled) == 0)
|
|
{
|
|
return false;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (NetworkInterface::IsGameInProgress())
|
|
{
|
|
return false;
|
|
}
|
|
}
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
void CScriptsForBrains::ClearMissionRequiredFlagOnTheStreamedScript(s32 ScriptBrainIndex)
|
|
{
|
|
if ( scriptVerifyf((ScriptBrainIndex >= 0) && (ScriptBrainIndex < MAX_DIFFERENT_SCRIPT_BRAINS), "CScriptsForBrains::ClearMissionRequiredFlagOnTheStreamedScript - ScriptBrainIndex %d is out of range. Should be >= 0 and < %d", ScriptBrainIndex, MAX_DIFFERENT_SCRIPT_BRAINS) )
|
|
{
|
|
s32 ScriptId = g_StreamedScripts.FindSlot(m_ScriptBrainArray[ScriptBrainIndex].m_ScriptFileName).Get();
|
|
if (scriptVerifyf(ScriptId != -1, "CScriptsForBrains::ClearMissionRequiredFlagOnTheStreamedScript - couldn't find a script called %s", m_ScriptBrainArray[ScriptBrainIndex].m_ScriptFileName.GetCStr()))
|
|
{
|
|
scriptDisplayf("CScriptsForBrains::ClearMissionRequiredFlagOnTheStreamedScript - clearing STRFLAG_MISSION_REQUIRED for %s", m_ScriptBrainArray[ScriptBrainIndex].m_ScriptFileName.GetCStr());
|
|
g_StreamedScripts.ClearRequiredFlag(ScriptId, STRFLAG_MISSION_REQUIRED);
|
|
}
|
|
}
|
|
}
|
|
|
|
void CScriptsForBrains::StartOrRequestNewStreamedScriptBrain(s32 ScriptBrainIndex, void *pEntityOrWorldPoint, s32 BrainType, bool bFirstTime)
|
|
{
|
|
CPed *pPed = NULL;
|
|
CObject *pObject = NULL;
|
|
C2dEffect *pEff = NULL;
|
|
|
|
#if !__FINAL
|
|
if (!gbAllowScriptBrains)
|
|
{
|
|
return;
|
|
}
|
|
#endif
|
|
|
|
if ( (OBJECT_STREAMED == BrainType) || (WORLD_POINT == BrainType) )
|
|
{
|
|
if ( (m_ScriptBrainArray[ScriptBrainIndex].m_SetToWhichThisBrainBelongs & m_SetsEnabled) == 0)
|
|
{
|
|
return;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (NetworkInterface::IsNetworkOpen())
|
|
{
|
|
return;
|
|
}
|
|
}
|
|
|
|
STRVIS_AUTO_CONTEXT(strStreamingVisualize::SCRIPTBRAIN);
|
|
Vector3 brainPosition = VEC3_ZERO;
|
|
|
|
switch (BrainType)
|
|
{
|
|
case PED_STREAMED :
|
|
case SCENARIO_PED :
|
|
pPed = static_cast<CPed*>(pEntityOrWorldPoint);
|
|
brainPosition = VEC3V_TO_VECTOR3(pPed->GetTransform().GetPosition());
|
|
break;
|
|
|
|
case OBJECT_STREAMED :
|
|
pObject = static_cast<CObject*>(pEntityOrWorldPoint);
|
|
brainPosition = VEC3V_TO_VECTOR3(pObject->GetTransform().GetPosition());
|
|
break;
|
|
|
|
case WORLD_POINT :
|
|
pEff = static_cast<C2dEffect*>(pEntityOrWorldPoint);
|
|
pEff->GetPos(brainPosition);
|
|
break;
|
|
|
|
default :
|
|
scriptAssertf(0, "CScriptsForBrains::StartOrRequestNewStreamedScriptBrain - unknown brain type");
|
|
break;
|
|
}
|
|
|
|
if (bFirstTime)
|
|
{
|
|
if (m_ScriptBrainArray[ScriptBrainIndex].m_bBrainActive == false)
|
|
{
|
|
return;
|
|
}
|
|
|
|
switch (BrainType)
|
|
{
|
|
case PED_STREAMED :
|
|
case SCENARIO_PED :
|
|
scriptAssertf( pPed->GetPedConfigFlag( CPED_CONFIG_FLAG_HasAScriptBrain ) == false, "CScriptsForBrains::StartOrRequestNewStreamedScriptBrain - can't start a second script brain for ped");
|
|
scriptAssertf( pPed->GetPedConfigFlag( CPED_CONFIG_FLAG_WaitingForScriptBrainToLoad ) == false, "CScriptsForBrains::StartOrRequestNewStreamedScriptBrain - already waiting for a streamed script brain to load for this ped");
|
|
|
|
if ( (pPed->GetPedConfigFlag( CPED_CONFIG_FLAG_HasAScriptBrain )) || (pPed->GetPedConfigFlag( CPED_CONFIG_FLAG_WaitingForScriptBrainToLoad )) )
|
|
{
|
|
return;
|
|
}
|
|
|
|
// scriptAssertf( pPed->PopTypeGet() == POPTYPE_RANDOM_SCENARIO || !m_ScriptBrainArray[ScriptBrainIndex].bOnlyGiveBrainToScenarioPeds, "CScriptsForBrains::StartOrRequestNewStreamedScriptBrain - trying to give a scenario-only brain to a non-scenario ped");
|
|
// if (pPed->PopTypeGet() != POPTYPE_RANDOM_SCENARIO && m_ScriptBrainArray[ScriptBrainIndex].bOnlyGiveBrainToScenarioPeds)
|
|
// {
|
|
// return;
|
|
// }
|
|
break;
|
|
|
|
case OBJECT_STREAMED :
|
|
scriptAssertf( pObject->m_nObjectFlags.ScriptBrainStatus == CObject::OBJECT_DOESNT_USE_SCRIPT_BRAIN, "CScriptsForBrains::StartOrRequestNewStreamedScriptBrain - this object has already been set up with a script brain");
|
|
|
|
if (pObject->m_nObjectFlags.ScriptBrainStatus != CObject::OBJECT_DOESNT_USE_SCRIPT_BRAIN)
|
|
{
|
|
return;
|
|
}
|
|
break;
|
|
|
|
case WORLD_POINT :
|
|
{
|
|
CWorldPointAttr* wp = pEff->GetWorldPoint();
|
|
|
|
scriptAssertf( wp->BrainStatus == CWorldPoints::OUT_OF_BRAIN_RANGE, "CScriptsForBrains::StartOrRequestNewStreamedScriptBrain - this world point has already been set up with a script brain");
|
|
|
|
if (wp->BrainStatus != CWorldPoints::OUT_OF_BRAIN_RANGE)
|
|
{
|
|
return;
|
|
}
|
|
}
|
|
break;
|
|
|
|
default :
|
|
scriptAssertf(0, "CScriptsForBrains::StartOrRequestNewStreamedScriptBrain - unknown brain type");
|
|
break;
|
|
}
|
|
}
|
|
|
|
strLocalIndex ScriptId = g_StreamedScripts.FindSlot(m_ScriptBrainArray[ScriptBrainIndex].m_ScriptFileName);
|
|
if (ScriptId == -1)
|
|
{
|
|
scriptAssertf(0, "%s: CScriptsForBrains::StartOrRequestNewStreamedScriptBrain - Script doesn't exist", m_ScriptBrainArray[ScriptBrainIndex].m_ScriptFileName.GetCStr());
|
|
return;
|
|
}
|
|
|
|
if (BrainType == OBJECT_STREAMED)
|
|
{
|
|
// always add objects to the array even if the script has already streamed
|
|
// I think this is because the level designer can terminate the object brain script
|
|
// if the object is outside its defined activation range.
|
|
// Since the object remains in the array until the object is deleted, the script will
|
|
// be re-triggered if the player re-enters the activation range.
|
|
|
|
// I think this comment must have been added before !bFirstTime was added to
|
|
// g_StreamedScripts.HasObjectLoaded(ScriptId) below
|
|
|
|
if (bFirstTime)
|
|
{
|
|
pObject->StreamedScriptBrainToLoad = (s16)ScriptBrainIndex;
|
|
pObject->m_nObjectFlags.ScriptBrainStatus = CObject::OBJECT_WAITING_TILL_IN_BRAIN_RANGE;
|
|
CTheScripts::GetScriptBrainDispatcher().AddWaitingObject(pObject, ScriptBrainIndex);
|
|
}
|
|
else
|
|
{
|
|
pObject->m_nObjectFlags.ScriptBrainStatus = CObject::OBJECT_WAITING_FOR_SCRIPT_BRAIN_TO_LOAD;
|
|
}
|
|
}
|
|
|
|
if (!bFirstTime && (g_StreamedScripts.HasObjectLoaded(ScriptId)) )
|
|
{
|
|
CGameScriptId scriptId(m_ScriptBrainArray[ScriptBrainIndex].m_ScriptFileName.GetCStr(), brainPosition);
|
|
|
|
if (!CTheScripts::GetScriptHandlerMgr().GetScriptHandler(scriptId))
|
|
{
|
|
// Never start a script the first time - to solve problem with over 50 Empire State telescopes
|
|
// being converted from dummy to real objects in one frame and starting a script each despite not being in activation range
|
|
StartNewStreamedScriptBrain(ScriptBrainIndex, pEntityOrWorldPoint);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
const s32 streamingFlags = STRFLAG_MISSION_REQUIRED|STRFLAG_PRIORITY_LOAD;
|
|
switch (BrainType)
|
|
{
|
|
case PED_STREAMED :
|
|
g_StreamedScripts.StreamingRequest(ScriptId, streamingFlags);
|
|
if (bFirstTime)
|
|
{
|
|
pPed->SetStreamedScriptBrainToLoad( (s16)ScriptBrainIndex );
|
|
pPed->SetPedConfigFlag( CPED_CONFIG_FLAG_WaitingForScriptBrainToLoad, true );
|
|
CTheScripts::GetScriptBrainDispatcher().AddWaitingPed(static_cast<CPed*>(pEntityOrWorldPoint), ScriptBrainIndex);
|
|
}
|
|
break;
|
|
|
|
case OBJECT_STREAMED :
|
|
g_StreamedScripts.StreamingRequest(ScriptId, streamingFlags);
|
|
// most of this was already handled at the start of the function
|
|
break;
|
|
|
|
case WORLD_POINT :
|
|
g_StreamedScripts.StreamingRequest(ScriptId, streamingFlags);
|
|
if (bFirstTime)
|
|
{
|
|
pEff->GetWorldPoint()->BrainStatus = CWorldPoints::WAITING_FOR_BRAIN_TO_LOAD;
|
|
CTheScripts::GetScriptBrainDispatcher().AddWaitingWorldPoint(static_cast<C2dEffect*>(pEntityOrWorldPoint), ScriptBrainIndex);
|
|
}
|
|
break;
|
|
|
|
case SCENARIO_PED :
|
|
if (bFirstTime)
|
|
{
|
|
pPed->SetStreamedScriptBrainToLoad( (s16)ScriptBrainIndex );
|
|
pPed->SetPedConfigFlag( CPED_CONFIG_FLAG_WaitingForScriptBrainToLoad, true );
|
|
CTheScripts::GetScriptBrainDispatcher().AddWaitingPed(static_cast<CPed*>(pEntityOrWorldPoint), ScriptBrainIndex);
|
|
}
|
|
else
|
|
{ // Only request the scenario ped script once the player is within the activation range
|
|
// The range check is done within CScriptBrainDispatcher::Process()
|
|
g_StreamedScripts.StreamingRequest(ScriptId, streamingFlags);
|
|
}
|
|
break;
|
|
default :
|
|
scriptAssertf(0, "CScriptsForBrains::StartOrRequestNewStreamedScriptBrain - unknown brain type");
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
void CScriptsForBrains::StartNewStreamedScriptBrain(u32 ScriptBrainIndex, void *pEntityOrWorldPoint)
|
|
{
|
|
int EntityOrWorldPointIndex = -1;
|
|
|
|
strLocalIndex id = g_StreamedScripts.FindSlot(m_ScriptBrainArray[ScriptBrainIndex].m_ScriptFileName);
|
|
scriptAssertf(id != -1, "%s:CScriptsForBrains::StartNewStreamedScriptBrain - Script doesn't exist", m_ScriptBrainArray[ScriptBrainIndex].m_ScriptFileName.GetCStr());
|
|
scriptAssertf(g_StreamedScripts.Get(id), "%s:CScriptsForBrains::StartNewStreamedScriptBrain - script brain has not loaded yet", m_ScriptBrainArray[ScriptBrainIndex].m_ScriptFileName.GetCStr());
|
|
|
|
GtaThread *pNewOne = NULL;
|
|
|
|
scrValue NewThreadID;
|
|
// Maximum size needed for LocalVariablesForNewScript is for WORLD_POINTs
|
|
// Array of MAX_NUM_COORDS_FOR_WORLD_POINT Vectors
|
|
// plus 1 for the size of array (created by the script compiler)
|
|
// Array of MAX_NUM_COORDS_FOR_WORLD_POINT Headings
|
|
// plus 1 for the size of array (created by the script compiler)
|
|
// plus 1 for the script's number_of_coords variable
|
|
scrValue *LocalVariablesForNewScript = rage_new scrValue[(4 * (MAX_NUMBER_OF_EXTRA_WORLD_POINT_COORDS+1)) + 3];
|
|
|
|
scrValue InputParams[4];
|
|
|
|
InputParams[0].String = scrEncodeString(m_ScriptBrainArray[ScriptBrainIndex].m_ScriptFileName.GetCStr());
|
|
InputParams[1].Reference = scrEncodeReference(&LocalVariablesForNewScript[0]); // static_cast<scrPointer<scrValue>>
|
|
InputParams[2].Int = 1;
|
|
InputParams[3].Int = GtaThread::GetDefaultStackSize();
|
|
|
|
scrThread::Info InfoForNewScript(&NewThreadID, 4, &InputParams[0]);
|
|
|
|
switch (m_ScriptBrainArray[ScriptBrainIndex].m_TypeOfBrain)
|
|
{
|
|
case PED_STREAMED :
|
|
case SCENARIO_PED :
|
|
{ // The first local variable of the rage_new script will contain a pointer to this ped
|
|
CPed *pPed = static_cast<CPed*>(pEntityOrWorldPoint);
|
|
|
|
EntityOrWorldPointIndex = CTheScripts::GetGUIDFromEntity(*pPed);
|
|
LocalVariablesForNewScript[0].Int = EntityOrWorldPointIndex;
|
|
scrThread::StartNewScriptWithArgs(InfoForNewScript);
|
|
|
|
// GW 14/09/06 - The brain scripts were adding two refs for each thread started. I've tried to remove one of those refs.
|
|
// g_StreamedScripts.AddRef(id);
|
|
// Now that the script has at least one ref it can't be streamed out so it is safe to clear STRFLAG_MISSION_REQUIRED
|
|
g_StreamedScripts.ClearRequiredFlag(id.Get(), STRFLAG_MISSION_REQUIRED);
|
|
|
|
pPed->SetPedConfigFlag( CPED_CONFIG_FLAG_HasAScriptBrain, true );
|
|
|
|
if (m_ScriptBrainArray[ScriptBrainIndex].m_TypeOfBrain != SCENARIO_PED)
|
|
{ // Don't remove scenario peds from the brain dispatcher array here.
|
|
// This will allow the brain to be retriggered if the player moves away and back again.
|
|
// The brain script can call DONT_RETRIGGER_BRAIN_FOR_THIS_SCENARIO_PED to remove
|
|
// the entry from the brain dispatcher array so that the brain won't retrigger.
|
|
pPed->SetPedConfigFlag( CPED_CONFIG_FLAG_WaitingForScriptBrainToLoad, false );
|
|
CTheScripts::GetScriptBrainDispatcher().RemoveWaitingPed(pPed, pPed->GetStreamedScriptBrainToLoad());
|
|
pPed->SetStreamedScriptBrainToLoad(-1);
|
|
}
|
|
}
|
|
break;
|
|
|
|
case OBJECT_STREAMED :
|
|
{ // The first local variable of the rage_new script will contain a pointer to this object
|
|
CObject *pObject = static_cast<CObject*>(pEntityOrWorldPoint);
|
|
|
|
#if !__NO_OUTPUT
|
|
Vec3V vecObjCoords = pObject->GetTransform().GetPosition();
|
|
scriptDisplayf("CScriptsForBrains::StartNewStreamedScriptBrain - Starting script brain for object %s at %f, %f, %f", pObject->GetModelName(), vecObjCoords.GetXf(), vecObjCoords.GetYf(), vecObjCoords.GetZf());
|
|
|
|
CInteriorProxy *pInteriorProxy = NULL;
|
|
if (pObject->GetIsRetainedByInteriorProxy())
|
|
{
|
|
pInteriorProxy = CInteriorProxy::GetPool()->GetSlot(pObject->GetRetainingInteriorProxy());
|
|
if (pInteriorProxy)
|
|
{
|
|
scriptDisplayf("CScriptsForBrains::StartNewStreamedScriptBrain - Object retained by interior %s", pInteriorProxy->GetName().GetCStr());
|
|
}
|
|
}
|
|
else
|
|
{
|
|
fwInteriorLocation interiorLoc = pObject->GetInteriorLocation();
|
|
if (interiorLoc.IsValid())
|
|
{
|
|
pInteriorProxy = CInteriorProxy::GetFromLocation(interiorLoc);
|
|
|
|
if (pInteriorProxy)
|
|
{
|
|
scriptDisplayf("CScriptsForBrains::StartNewStreamedScriptBrain - Object in interior %s:%d", pInteriorProxy->GetName().GetCStr(), interiorLoc.GetInteriorProxyIndex());
|
|
|
|
if (interiorLoc.IsAttachedToRoom())
|
|
{
|
|
scriptDisplayf("CScriptsForBrains::StartNewStreamedScriptBrain - Object in room %d", interiorLoc.GetRoomIndex());
|
|
}
|
|
else if (interiorLoc.IsAttachedToPortal())
|
|
{
|
|
scriptDisplayf("CScriptsForBrains::StartNewStreamedScriptBrain - Object attached to portal %d", interiorLoc.GetPortalIndex());
|
|
}
|
|
}
|
|
}
|
|
}
|
|
#endif // !__NO_OUTPUT
|
|
|
|
EntityOrWorldPointIndex = CTheScripts::GetGUIDFromEntity(*pObject);
|
|
LocalVariablesForNewScript[0].Int = EntityOrWorldPointIndex;
|
|
|
|
scrThread::StartNewScriptWithArgs(InfoForNewScript);
|
|
|
|
// GW 14/09/06 - The brain scripts were adding two refs for each thread started. I've tried to remove one of those refs.
|
|
// g_StreamedScripts.AddRef(id);
|
|
// Now that the script has one ref it can't be streamed out so it is safe to clear STRFLAG_MISSION_REQUIRED
|
|
g_StreamedScripts.ClearRequiredFlag(id.Get(), STRFLAG_MISSION_REQUIRED);
|
|
pObject->m_nObjectFlags.ScriptBrainStatus = CObject::OBJECT_RUNNING_SCRIPT_BRAIN;
|
|
|
|
}
|
|
break;
|
|
|
|
case WORLD_POINT :
|
|
{ // The first local variable of the rage_new script will contain the number of points
|
|
// The second local variable will be the number of elements in the array (all arrays have this before the first element)
|
|
// This will be followed by three floats for the x,y,z of each point
|
|
// There must be at least one point
|
|
|
|
int loop = 0;
|
|
C2dEffect *pEffect = static_cast<C2dEffect*>(pEntityOrWorldPoint);
|
|
CWorldPointAttr* wp = pEffect->GetWorldPoint();
|
|
Vector3 Pos;
|
|
pEffect->GetPos(Pos);
|
|
|
|
LocalVariablesForNewScript[0].Int = wp->num_of_extra_coords+1;
|
|
LocalVariablesForNewScript[1].Int = MAX_NUMBER_OF_EXTRA_WORLD_POINT_COORDS+1;
|
|
|
|
for (loop = 0; loop < MAX_NUMBER_OF_EXTRA_WORLD_POINT_COORDS+1; loop++)
|
|
{
|
|
LocalVariablesForNewScript[(3 * loop) + 2].Float = 0.0f;
|
|
LocalVariablesForNewScript[(3 * loop) + 3].Float = 0.0f;
|
|
LocalVariablesForNewScript[(3 * loop) + 4].Float = 0.0f;
|
|
|
|
LocalVariablesForNewScript[loop + (3 * (MAX_NUMBER_OF_EXTRA_WORLD_POINT_COORDS)) + 6].Float = 0.0f;
|
|
|
|
}
|
|
|
|
LocalVariablesForNewScript[(3 * 0) + 2].Float = Pos.x; // Coordinates of main point of 2d effect
|
|
LocalVariablesForNewScript[(3 * 0) + 3].Float = Pos.y;
|
|
LocalVariablesForNewScript[(3 * 0) + 4].Float = Pos.z;
|
|
LocalVariablesForNewScript[ (3 * MAX_NUMBER_OF_EXTRA_WORLD_POINT_COORDS) + 6].Float = wp->extraCoordOrientations[0];
|
|
|
|
for (loop = 0; loop < wp->num_of_extra_coords; loop++)
|
|
{
|
|
LocalVariablesForNewScript[(3 * (loop+1)) + 2].Float = wp->extraCoords[loop].x;
|
|
LocalVariablesForNewScript[(3 * (loop+1)) + 3].Float = wp->extraCoords[loop].y;
|
|
LocalVariablesForNewScript[(3 * (loop+1)) + 4].Float = wp->extraCoords[loop].z;
|
|
|
|
LocalVariablesForNewScript[ (loop+1) + (3 * MAX_NUMBER_OF_EXTRA_WORLD_POINT_COORDS) + 6].Float = wp->extraCoordOrientations[loop+1];
|
|
}
|
|
|
|
LocalVariablesForNewScript[(3 * MAX_NUMBER_OF_EXTRA_WORLD_POINT_COORDS) + 5].Int = MAX_NUMBER_OF_EXTRA_WORLD_POINT_COORDS+1;
|
|
|
|
|
|
|
|
// Array of MAX_NUM_COORDS_FOR_WORLD_POINT Vectors
|
|
// plus 1 for the size of array (created by the script compiler)
|
|
// Array of MAX_NUM_COORDS_FOR_WORLD_POINT Headings
|
|
// plus 1 for the size of array (created by the script compiler)
|
|
// plus 1 for the script's number_of_coords variable
|
|
InputParams[2].Int = (4 * (MAX_NUMBER_OF_EXTRA_WORLD_POINT_COORDS+1)) + 3; // override the default value of 1
|
|
|
|
|
|
|
|
scrThread::StartNewScriptWithArgs(InfoForNewScript);
|
|
|
|
// GW 14/09/06 - The brain scripts were adding two refs for each thread started. I've tried to remove one of those refs.
|
|
// g_StreamedScripts.AddRef(id);
|
|
// Now that the script has at least one ref it can't be streamed out so it is safe to clear STRFLAG_MISSION_REQUIRED
|
|
g_StreamedScripts.ClearRequiredFlag(id.Get(), STRFLAG_MISSION_REQUIRED);
|
|
|
|
if(pEffect->GetWorldPoint()){
|
|
EntityOrWorldPointIndex = CModelInfo::GetWorldPointStore().GetElementIndex(fwFactory::GLOBAL, pEffect->GetWorldPoint());
|
|
}
|
|
|
|
wp->BrainStatus = CWorldPoints::RUNNING_BRAIN;
|
|
CTheScripts::GetScriptBrainDispatcher().RemoveWaitingWorldPoint(pEffect, wp->ScriptBrainToLoad);
|
|
// Don't reset scriptBrainIndexToLoad here as IsWorldPointWithinActivationRange needs the link from WorldPoint to m_ScriptBrainArray
|
|
// pWorldPoint->scriptBrainIndexToLoad = -1;
|
|
}
|
|
break;
|
|
|
|
default :
|
|
scriptAssertf(0, "CScriptsForBrains::StartNewStreamedScriptBrain - unknown brain type");
|
|
break;
|
|
}
|
|
|
|
pNewOne = static_cast<GtaThread *> (scrThread::GetThread(static_cast<scrThreadId>(NewThreadID.Int)));
|
|
if (scriptVerifyf(pNewOne, "CScriptsForBrains::StartNewStreamedScriptBrain - Could not get a thread %s", m_ScriptBrainArray[ScriptBrainIndex].m_ScriptFileName.GetCStr()))
|
|
{
|
|
pNewOne->ScriptBrainType = m_ScriptBrainArray[ScriptBrainIndex].m_TypeOfBrain;
|
|
scriptAssertf(EntityOrWorldPointIndex >= 0, "CScriptsForBrains::StartNewStreamedScriptBrain - EntityOrWorldPointIndex should have been assigned by now");
|
|
pNewOne->EntityIndexForScriptBrain = EntityOrWorldPointIndex;
|
|
|
|
if (pNewOne->m_Handler)
|
|
{
|
|
CTheScripts::GetScriptHandlerMgr().RecalculateScriptId(*pNewOne->m_Handler);
|
|
}
|
|
}
|
|
delete[] LocalVariablesForNewScript;
|
|
}
|
|
|
|
s32 CScriptsForBrains::GetIndexOfScriptBrainWithThisName(const strStreamingObjectName pScriptName, s8 BrainType)
|
|
{
|
|
u32 loop = 0;
|
|
while (loop < MAX_DIFFERENT_SCRIPT_BRAINS)
|
|
{
|
|
if ((m_ScriptBrainArray[loop].m_TypeOfBrain == BrainType) && (m_ScriptBrainArray[loop].m_ScriptFileName.GetHash() == pScriptName.GetHash()))
|
|
{
|
|
return loop;
|
|
}
|
|
else
|
|
{
|
|
loop++;
|
|
}
|
|
}
|
|
|
|
return -1;
|
|
}
|
|
|
|
bool CScriptsForBrains::IsObjectWithinActivationRange(const CObject *pObject, const Vector3 &vecCentrePoint)
|
|
{
|
|
#if GTA_REPLAY
|
|
// Always out of range for replay
|
|
if( CReplayMgr::IsReplayInControlOfWorld() == false )
|
|
#endif //GTA_REPLAY
|
|
{
|
|
s32 ScriptBrainIndex = pObject->StreamedScriptBrainToLoad;
|
|
if (scriptVerifyf( (ScriptBrainIndex >= 0) && (ScriptBrainIndex < MAX_DIFFERENT_SCRIPT_BRAINS), "CScriptsForBrains::IsObjectWithinActivationRange - Script brain index is out of range"))
|
|
{
|
|
if (scriptVerifyf(m_ScriptBrainArray[ScriptBrainIndex].m_TypeOfBrain == OBJECT_STREAMED, "CScriptsForBrains::IsObjectWithinActivationRange - Expected brain type to be Object"))
|
|
{
|
|
const Vector3 ObjectPos = VEC3V_TO_VECTOR3(pObject->GetTransform().GetPosition());
|
|
if (ArePointsWithinActivationRange(vecCentrePoint, ObjectPos, ScriptBrainIndex, 0.0f, false))
|
|
{
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
bool CScriptsForBrains::IsScenarioPedWithinActivationRange(const CPed *pPed, const Vector3 &vecCentrePoint, float fRangeExtension)
|
|
{
|
|
#if GTA_REPLAY
|
|
// Always out of range for replay
|
|
if( CReplayMgr::IsReplayInControlOfWorld() == false )
|
|
#endif //GTA_REPLAY
|
|
{
|
|
s32 ScriptBrainIndex = pPed->GetStreamedScriptBrainToLoad();
|
|
if (scriptVerifyf( (ScriptBrainIndex >= 0) && (ScriptBrainIndex < MAX_DIFFERENT_SCRIPT_BRAINS), "CScriptsForBrains::IsScenarioPedWithinActivationRange - Script brain index is out of range"))
|
|
{
|
|
if (scriptVerifyf(m_ScriptBrainArray[ScriptBrainIndex].m_TypeOfBrain == SCENARIO_PED, "CScriptsForBrains::IsScenarioPedWithinActivationRange - Expected brain type to be SCENARIO_PED"))
|
|
{
|
|
const Vector3 PedPos = VEC3V_TO_VECTOR3(pPed->GetTransform().GetPosition());
|
|
if (ArePointsWithinActivationRange(vecCentrePoint, PedPos, ScriptBrainIndex, fRangeExtension, false))
|
|
{
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
bool CScriptsForBrains::IsWorldPointWithinActivationRange(C2dEffect *pEff, const Vector3 &vecCentrePoint)
|
|
{
|
|
#if GTA_REPLAY
|
|
// Always out of range for replay
|
|
if( CReplayMgr::IsReplayInControlOfWorld() == false )
|
|
#endif //GTA_REPLAY
|
|
{
|
|
CWorldPointAttr* wp = pEff->GetWorldPoint();
|
|
if (!wp)
|
|
{
|
|
scriptAssertf(0, "CScriptsForBrains::IsWorldPointWithinActivationRange - Type = %d, Pos = %f %f %f", pEff->GetType(), pEff->GetPosDirect().x, pEff->GetPosDirect().y, pEff->GetPosDirect().z);
|
|
return false;
|
|
}
|
|
|
|
int ScriptBrainIndex = wp->ScriptBrainToLoad;
|
|
Vector3 vecWorldPointPos;
|
|
pEff->GetPos(vecWorldPointPos);
|
|
|
|
if (ScriptBrainIndex < 0) return false; // This will happen frequently if a worldpoint has been set up in max but the corresponding brain hasn't been registered by the script.
|
|
|
|
if (scriptVerifyf(ScriptBrainIndex < MAX_DIFFERENT_SCRIPT_BRAINS, "CScriptsForBrains::IsWorldPointWithinActivationRange - Script brain index is out of range"))
|
|
{
|
|
if (scriptVerifyf(m_ScriptBrainArray[ScriptBrainIndex].m_TypeOfBrain == WORLD_POINT, "CScriptsForBrains::IsWorldPointWithinActivationRange - Expected brain type to be World Point"))
|
|
{
|
|
// Tom's window cleaner lift needs to work for tall buildings so ignore z for all world points
|
|
// so that the script doesn't terminate if the player is 200 metres above the ground
|
|
if (ArePointsWithinActivationRange(vecWorldPointPos, vecCentrePoint, ScriptBrainIndex, 0.0f, true))
|
|
{
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
const char *CScriptsForBrains::GetScriptFileName(s32 BrainIndex)
|
|
{
|
|
if (scriptVerifyf((BrainIndex >= 0) && (BrainIndex < MAX_DIFFERENT_SCRIPT_BRAINS), "CScriptsForBrains::GetScriptFileName - brain index is out of range"))
|
|
{
|
|
return m_ScriptBrainArray[BrainIndex].m_ScriptFileName.GetCStr();
|
|
}
|
|
|
|
return NULL;
|
|
}
|
|
|
|
s8 CScriptsForBrains::GetBrainType(s32 BrainIndex)
|
|
{
|
|
if (scriptVerifyf((BrainIndex >= 0) && (BrainIndex < MAX_DIFFERENT_SCRIPT_BRAINS), "CScriptsForBrains::GetBrainType - brain index is out of range"))
|
|
{
|
|
return m_ScriptBrainArray[BrainIndex].m_TypeOfBrain;
|
|
}
|
|
|
|
return -1;
|
|
}
|
|
|
|
bool CScriptsForBrains::ArePointsWithinActivationRange(const Vector3 &vecCoord1, const Vector3 &vecCoord2, s32 ScriptBrainIndex, float fRangeExtension, bool bIgnoreZ)
|
|
{
|
|
Vector3 vecDiff = (vecCoord1 - vecCoord2);
|
|
if (bIgnoreZ)
|
|
{
|
|
vecDiff.z = 0.0f;
|
|
}
|
|
|
|
float distance_to_player_squared = vecDiff.Mag2();
|
|
|
|
float fActivationRange = m_ScriptBrainArray[ScriptBrainIndex].m_fBrainActivationRange + fRangeExtension;
|
|
|
|
if (distance_to_player_squared < (fActivationRange * fActivationRange) )
|
|
{
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
|
|
void CScriptsForBrains::RemoveScenarioPedFromBrainDispatcherArray(CPed *pPed)
|
|
{
|
|
if (scriptVerifyf(pPed, "CScriptsForBrains::RemoveScenarioPedFromBrainDispatcherArray - ped doesn't exist"))
|
|
{
|
|
s16 ScriptBrainIndex = pPed->GetStreamedScriptBrainToLoad();
|
|
if (scriptVerifyf(ScriptBrainIndex >= 0, "CScriptsForBrains::RemoveScenarioPedFromBrainDispatcherArray - ped doesn't have an associated script brain"))
|
|
{
|
|
if (scriptVerifyf(ScriptBrainIndex < MAX_DIFFERENT_SCRIPT_BRAINS, "CScriptsForBrains::RemoveScenarioPedFromBrainDispatcherArray - Script brain index is out of range"))
|
|
{
|
|
if (scriptVerifyf(m_ScriptBrainArray[ScriptBrainIndex].m_TypeOfBrain == SCENARIO_PED, "CScriptsForBrains::RemoveScenarioPedFromBrainDispatcherArray - Expected brain type to be SCENARIO_PED"))
|
|
{
|
|
CTheScripts::GetScriptBrainDispatcher().RemoveWaitingPed(pPed, ScriptBrainIndex);
|
|
|
|
// I can't reset the following two variables here because the script brain might still call GetBrainActivationRangeSquaredOfScenarioPed
|
|
// which relies on GetStreamedScriptBrainToLoad() so I'll leave it for the Ped destructor to reset them
|
|
// pPed->SetPedConfigFlag( CPED_CONFIG_FLAG_WaitingForScriptBrainToLoad, false );
|
|
// pPed->SetStreamedScriptBrainToLoad(-1);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// end of script brain functions
|
|
|
|
|
|
void CScriptBrainDispatcher::ItemWaitingForBrain::Clear()
|
|
{
|
|
m_pWaitingObject = NULL;
|
|
m_pWaitingPed = NULL;
|
|
m_pWaitingWorldPoint = NULL;
|
|
|
|
m_scriptBrainIndex = -1;
|
|
m_waitingItemsType = INVALID_WAITING;
|
|
}
|
|
|
|
void CScriptBrainDispatcher::Init(void)
|
|
{
|
|
for (u32 loop = 0; loop < MAX_ENTITIES_WAITING_FOR_SCRIPT_BRAIN; loop++)
|
|
{
|
|
ItemsWaitingForBrains[loop].Clear();
|
|
}
|
|
}
|
|
void CScriptBrainDispatcher::AddWaitingObject(CObject* pItem, s32 scriptBrainIndexToLoad)
|
|
{
|
|
const WaitingItemType itemType = OBJECT_WAITING;
|
|
AddWaitingItem(static_cast<void*>(pItem), scriptBrainIndexToLoad, itemType);
|
|
}
|
|
void CScriptBrainDispatcher::AddWaitingPed(CPed* pItem, s32 scriptBrainIndexToLoad)
|
|
{
|
|
const WaitingItemType itemType = PED_WAITING;
|
|
AddWaitingItem(static_cast<void*>(pItem), scriptBrainIndexToLoad, itemType);
|
|
}
|
|
void CScriptBrainDispatcher::AddWaitingWorldPoint(C2dEffect* pItem, s32 scriptBrainIndexToLoad)
|
|
{
|
|
const WaitingItemType itemType = WORLD_POINT_WAITING;
|
|
AddWaitingItem(static_cast<void*>(pItem), scriptBrainIndexToLoad, itemType);
|
|
}
|
|
void CScriptBrainDispatcher::AddWaitingItem(void *pEntityOrPoint, s32 scriptBrainIndexToLoad, WaitingItemType itemType)
|
|
{
|
|
scriptAssertf(itemType != INVALID_WAITING, "CScriptBrainDispatcher::AddWaitingItem -Adding a waiting item with invalid type is not allowed.");
|
|
|
|
s32 free_index = -1;
|
|
u32 loop = 0;
|
|
while (loop < MAX_ENTITIES_WAITING_FOR_SCRIPT_BRAIN)
|
|
{
|
|
if (ItemsWaitingForBrains[loop].m_waitingItemsType == INVALID_WAITING)
|
|
{
|
|
free_index = loop;
|
|
}
|
|
else
|
|
{
|
|
if (ItemsWaitingForBrains[loop].m_scriptBrainIndex != scriptBrainIndexToLoad)
|
|
{
|
|
bool itemsAreSame = false;
|
|
switch (itemType)
|
|
{
|
|
case PED_WAITING :
|
|
itemsAreSame = (ItemsWaitingForBrains[loop].m_pWaitingPed == pEntityOrPoint);
|
|
break;
|
|
case OBJECT_WAITING :
|
|
itemsAreSame = (ItemsWaitingForBrains[loop].m_pWaitingObject == pEntityOrPoint);
|
|
break;
|
|
case WORLD_POINT_WAITING :
|
|
itemsAreSame = (ItemsWaitingForBrains[loop].m_pWaitingWorldPoint == pEntityOrPoint);
|
|
break;
|
|
default :
|
|
scriptAssertf(0, "CScriptBrainDispatcher::AddWaitingItem - Item is not a ped, object or world point");
|
|
break;
|
|
}
|
|
|
|
if (itemsAreSame)
|
|
{ // this entity is already in the list so just return
|
|
scriptAssertf(0, "CScriptBrainDispatcher::AddWaitingItem - item is already in the list for a different brain");
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
|
|
loop++;
|
|
}
|
|
|
|
scriptAssertf(free_index >= 0, "CScriptBrainDispatcher::AddWaitingItem - no space left in list");
|
|
|
|
if (free_index >= 0)
|
|
{
|
|
switch (itemType)
|
|
{
|
|
case PED_WAITING :
|
|
ItemsWaitingForBrains[free_index].m_pWaitingPed = static_cast<CPed*>(pEntityOrPoint);
|
|
break;
|
|
case OBJECT_WAITING :
|
|
ItemsWaitingForBrains[free_index].m_pWaitingObject = static_cast<CObject*>(pEntityOrPoint);
|
|
break;
|
|
case WORLD_POINT_WAITING :
|
|
ItemsWaitingForBrains[free_index].m_pWaitingWorldPoint = static_cast<C2dEffect*>(pEntityOrPoint);
|
|
break;
|
|
default :
|
|
scriptAssertf(0, "CScriptBrainDispatcher::AddWaitingItem - New item is not a ped, object or world point");
|
|
break;
|
|
}
|
|
ItemsWaitingForBrains[free_index].m_scriptBrainIndex = scriptBrainIndexToLoad;
|
|
ItemsWaitingForBrains[free_index].m_waitingItemsType = itemType;
|
|
}
|
|
}
|
|
void CScriptBrainDispatcher::RemoveWaitingObject(CObject* pItem, s32 scriptBrainIndexToLoad)
|
|
{
|
|
const WaitingItemType itemType = OBJECT_WAITING;
|
|
RemoveWaitingItem(static_cast<void*>(pItem), scriptBrainIndexToLoad, itemType);
|
|
}
|
|
void CScriptBrainDispatcher::RemoveWaitingPed(CPed* pItem, s32 scriptBrainIndexToLoad)
|
|
{
|
|
const WaitingItemType itemType = PED_WAITING;
|
|
RemoveWaitingItem(static_cast<void*>(pItem), scriptBrainIndexToLoad, itemType);
|
|
}
|
|
void CScriptBrainDispatcher::RemoveWaitingWorldPoint(C2dEffect* pItem, s32 scriptBrainIndexToLoad)
|
|
{
|
|
const WaitingItemType itemType = WORLD_POINT_WAITING;
|
|
RemoveWaitingItem(static_cast<void*>(pItem), scriptBrainIndexToLoad, itemType);
|
|
}
|
|
void CScriptBrainDispatcher::RemoveWaitingItem(void *pEntityOrPoint, s32 scriptBrainIndexToLoad, WaitingItemType itemType)
|
|
{
|
|
u32 loop = 0;
|
|
while (loop < MAX_ENTITIES_WAITING_FOR_SCRIPT_BRAIN)
|
|
{
|
|
bool itemsAreSame = false;
|
|
switch (itemType)
|
|
{
|
|
case PED_WAITING :
|
|
itemsAreSame = (ItemsWaitingForBrains[loop].m_pWaitingPed == pEntityOrPoint);
|
|
break;
|
|
case OBJECT_WAITING :
|
|
itemsAreSame = (ItemsWaitingForBrains[loop].m_pWaitingObject == pEntityOrPoint);
|
|
break;
|
|
case WORLD_POINT_WAITING :
|
|
itemsAreSame = (ItemsWaitingForBrains[loop].m_pWaitingWorldPoint == pEntityOrPoint);
|
|
break;
|
|
default :
|
|
scriptAssertf(0, "CScriptBrainDispatcher::RemoveWaitingItem - Item is not a ped, object or world point");
|
|
break;
|
|
}
|
|
|
|
if (itemsAreSame)
|
|
{
|
|
if (ItemsWaitingForBrains[loop].m_scriptBrainIndex != scriptBrainIndexToLoad)
|
|
{
|
|
scriptAssertf(0, "CScriptBrainDispatcher::RemoveWaitingItem - Entity is in the list for a different brain");
|
|
}
|
|
else if (ItemsWaitingForBrains[loop].m_waitingItemsType != itemType)
|
|
{
|
|
scriptAssertf(0, "CScriptBrainDispatcher::RemoveWaitingItem - m_waitingItemsType doesn't match");
|
|
}
|
|
else
|
|
{
|
|
ItemsWaitingForBrains[loop].Clear();
|
|
}
|
|
}
|
|
|
|
loop++;
|
|
}
|
|
}
|
|
// Object remains in array for as long as it exists
|
|
//
|
|
// Script is marked as no longer needed when the object is deleted and in StartNewStreamedScriptBrain()
|
|
|
|
// For scenario peds, they'll remain in the array until the ped is deleted or the script brain itself says to remove the array entry.
|
|
// This should allow the brain to be retriggered if the player moves away and back again.
|
|
|
|
void CScriptBrainDispatcher::Process(void)
|
|
{
|
|
CEntity *pEntity = NULL;
|
|
C2dEffect *pEffect = NULL;
|
|
CPed *pPed = NULL;
|
|
CObject *pObject = NULL;
|
|
|
|
if (!CGameWorld::FindLocalPlayer())
|
|
{ // can't get the player's position until he has been created
|
|
return;
|
|
}
|
|
|
|
const Vector3 PlayerPos = CGameWorld::FindLocalPlayerCentreOfWorld();
|
|
|
|
u32 loop = 0;
|
|
while (loop < MAX_ENTITIES_WAITING_FOR_SCRIPT_BRAIN)
|
|
{
|
|
if (ItemsWaitingForBrains[loop].m_waitingItemsType != INVALID_WAITING)
|
|
{
|
|
pEntity = NULL;
|
|
pEffect = NULL;
|
|
switch (ItemsWaitingForBrains[loop].m_waitingItemsType)
|
|
{
|
|
case PED_WAITING :
|
|
pEntity = static_cast<CEntity*>(ItemsWaitingForBrains[loop].m_pWaitingPed);
|
|
break;
|
|
case OBJECT_WAITING :
|
|
pEntity = static_cast<CEntity*>(ItemsWaitingForBrains[loop].m_pWaitingObject);
|
|
break;
|
|
case WORLD_POINT_WAITING :
|
|
pEffect = ItemsWaitingForBrains[loop].m_pWaitingWorldPoint;
|
|
break;
|
|
default :
|
|
scriptAssertf(0, "CScriptBrainDispatcher::Process - Item is not a ped, object or world point");
|
|
break;
|
|
}
|
|
|
|
s8 BrainType = CTheScripts::GetScriptsForBrains().GetBrainType(ItemsWaitingForBrains[loop].m_scriptBrainIndex);
|
|
switch (BrainType)
|
|
{
|
|
case CScriptsForBrains::PED_STREAMED :
|
|
scriptAssertf(pEntity->GetType() == ENTITY_TYPE_PED, "CScriptBrainDispatcher::Process - Ped script brain expects ped entity");
|
|
pPed = (CPed *) pEntity;
|
|
scriptAssertf(pPed->GetPedConfigFlag( CPED_CONFIG_FLAG_WaitingForScriptBrainToLoad ), "CScriptBrainDispatcher::Process - Ped's waiting for script brain flag should be set");
|
|
CTheScripts::GetScriptsForBrains().StartOrRequestNewStreamedScriptBrain(pPed->GetStreamedScriptBrainToLoad(), pPed, BrainType, false); // , pPed->ScriptTriggerMethod); // CScriptsForBrains::PED_STREAMED);
|
|
break;
|
|
|
|
case CScriptsForBrains::OBJECT_STREAMED :
|
|
scriptAssertf(pEntity->GetType() == ENTITY_TYPE_OBJECT, "CScriptBrainDispatcher::Process - Object script brain expects object entity");
|
|
pObject = (CObject *) pEntity;
|
|
|
|
switch (pObject->m_nObjectFlags.ScriptBrainStatus)
|
|
{
|
|
case CObject::OBJECT_WAITING_TILL_IN_BRAIN_RANGE :
|
|
if (CTheScripts::GetScriptsForBrains().IsObjectWithinActivationRange(pObject, PlayerPos))
|
|
{
|
|
CTheScripts::GetScriptsForBrains().StartOrRequestNewStreamedScriptBrain(pObject->StreamedScriptBrainToLoad, pObject, BrainType, false); // , TRIGGER_METHOD_NA); // CScriptsForBrains::OBJECT_STREAMED);
|
|
}
|
|
break;
|
|
|
|
case CObject::OBJECT_WAITING_FOR_SCRIPT_BRAIN_TO_LOAD :
|
|
CTheScripts::GetScriptsForBrains().StartOrRequestNewStreamedScriptBrain(pObject->StreamedScriptBrainToLoad, pObject, BrainType, false); // , TRIGGER_METHOD_NA); // CScriptsForBrains::OBJECT_STREAMED);
|
|
break;
|
|
|
|
case CObject::OBJECT_WAITING_TILL_OUT_OF_BRAIN_RANGE :
|
|
if (CTheScripts::GetScriptsForBrains().IsObjectWithinActivationRange(pObject, PlayerPos) == false)
|
|
{
|
|
pObject->m_nObjectFlags.ScriptBrainStatus = CObject::OBJECT_WAITING_TILL_IN_BRAIN_RANGE;
|
|
}
|
|
break;
|
|
|
|
case CObject::OBJECT_RUNNING_SCRIPT_BRAIN :
|
|
// do nothing - already running the script - it is up to the script to check if the object is within range of the player
|
|
break;
|
|
|
|
default :
|
|
scriptAssertf(0, "CScriptBrainDispatcher::Process - unexpected script brain status for object");
|
|
break;
|
|
}
|
|
|
|
break;
|
|
case CScriptsForBrains::WORLD_POINT :
|
|
{
|
|
if (!CTheScripts::GetScriptsForBrains().CanBrainSafelyRun(pEffect->GetWorldPoint()->ScriptBrainToLoad))
|
|
{
|
|
CTheScripts::GetScriptsForBrains().ClearMissionRequiredFlagOnTheStreamedScript(pEffect->GetWorldPoint()->ScriptBrainToLoad);
|
|
|
|
pEffect->GetWorldPoint()->Reset(false);
|
|
|
|
ItemsWaitingForBrains[loop].Clear();
|
|
}
|
|
else
|
|
{
|
|
CTheScripts::GetScriptsForBrains().StartOrRequestNewStreamedScriptBrain(pEffect->GetWorldPoint()->ScriptBrainToLoad, pEffect, BrainType, false); // , TRIGGER_METHOD_NA);
|
|
}
|
|
}
|
|
break;
|
|
|
|
case CScriptsForBrains::SCENARIO_PED :
|
|
{
|
|
scriptAssertf(pEntity->GetType() == ENTITY_TYPE_PED, "CScriptBrainDispatcher::Process - Scenario ped script brain expects ped entity");
|
|
pPed = (CPed *) pEntity;
|
|
|
|
if (!pPed->GetPedConfigFlag( CPED_CONFIG_FLAG_HasAScriptBrain ))
|
|
{
|
|
scriptAssertf(pPed->GetPedConfigFlag( CPED_CONFIG_FLAG_WaitingForScriptBrainToLoad ), "CScriptBrainDispatcher::Process - Scenario ped's waiting for script brain flag should be set");
|
|
if (CTheScripts::GetScriptsForBrains().IsScenarioPedWithinActivationRange(pPed, PlayerPos, 0.0f))
|
|
{
|
|
CTheScripts::GetScriptsForBrains().StartOrRequestNewStreamedScriptBrain(pPed->GetStreamedScriptBrainToLoad(), pPed, BrainType, false);
|
|
}
|
|
}
|
|
}
|
|
break;
|
|
|
|
default :
|
|
scriptAssertf(0, "CScriptBrainDispatcher::Process - unknown brain type");
|
|
break;
|
|
}
|
|
}
|
|
|
|
loop++;
|
|
}
|
|
}
|
|
|
|
void CScriptBrainDispatcher::ReactivateAllObjectBrainsThatAreWaitingTillOutOfRange()
|
|
{
|
|
int loop = 0;
|
|
while (loop < MAX_ENTITIES_WAITING_FOR_SCRIPT_BRAIN)
|
|
{
|
|
if (ItemsWaitingForBrains[loop].m_waitingItemsType == OBJECT_WAITING)
|
|
{
|
|
if (ItemsWaitingForBrains[loop].m_pWaitingObject)
|
|
{
|
|
if (ItemsWaitingForBrains[loop].m_pWaitingObject->m_nObjectFlags.ScriptBrainStatus == CObject::OBJECT_WAITING_TILL_OUT_OF_BRAIN_RANGE)
|
|
{
|
|
ItemsWaitingForBrains[loop].m_pWaitingObject->m_nObjectFlags.ScriptBrainStatus = CObject::OBJECT_WAITING_TILL_IN_BRAIN_RANGE;
|
|
}
|
|
}
|
|
}
|
|
loop++;
|
|
}
|
|
}
|
|
|
|
|
|
void CScriptBrainDispatcher::ReactivateNamedObjectBrainsWaitingTillOutOfRange(const char *pNameToSearchFor)
|
|
{
|
|
int loop = 0;
|
|
while (loop < MAX_ENTITIES_WAITING_FOR_SCRIPT_BRAIN)
|
|
{
|
|
if (ItemsWaitingForBrains[loop].m_waitingItemsType == OBJECT_WAITING)
|
|
{
|
|
if (ItemsWaitingForBrains[loop].m_pWaitingObject)
|
|
{
|
|
if (ItemsWaitingForBrains[loop].m_pWaitingObject->m_nObjectFlags.ScriptBrainStatus == CObject::OBJECT_WAITING_TILL_OUT_OF_BRAIN_RANGE)
|
|
{
|
|
if (scriptVerifyf(ItemsWaitingForBrains[loop].m_scriptBrainIndex != -1, "CScriptBrainDispatcher::ReactivateNamedObjectBrainsWaitingTillOutOfRange - didn't expect m_scriptBrainIndex to be -1 here"))
|
|
{
|
|
const char *pNameOfThisScript = CTheScripts::GetScriptsForBrains().GetScriptFileName(ItemsWaitingForBrains[loop].m_scriptBrainIndex);
|
|
if (scriptVerifyf(pNameOfThisScript, "CScriptBrainDispatcher::ReactivateNamedObjectBrainsWaitingTillOutOfRange - failed to find the name of script in ItemsWaitingForBrains array"))
|
|
{
|
|
if (stricmp(pNameToSearchFor, pNameOfThisScript) == 0)
|
|
{
|
|
ItemsWaitingForBrains[loop].m_pWaitingObject->m_nObjectFlags.ScriptBrainStatus = CObject::OBJECT_WAITING_TILL_IN_BRAIN_RANGE;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
loop++;
|
|
}
|
|
}
|
|
|
|
|
|
/*
|
|
void CScriptBrainDispatcher::PurgeWaitingItems(void)
|
|
{
|
|
int loop = 0;
|
|
while (loop < MAX_ENTITIES_WAITING_FOR_SCRIPT_BRAIN)
|
|
{
|
|
if (ItemsWaitingForBrains[loop].m_waitingItemsType != INVALID_WAITING)
|
|
{
|
|
switch (ItemsWaitingForBrains[loop].m_waitingItemsType)
|
|
{
|
|
case PED_WAITING :
|
|
{
|
|
CPed *pPed = ItemsWaitingForBrains[loop].m_pWaitingPed;
|
|
scriptAssertf(pPed->GetStreamedScriptBrainToLoad() == ItemsWaitingForBrains[loop].m_scriptBrainIndex, "CScriptBrainDispatcher::PurgeWaitingItems - Brain Index should be the same within ped and within waiting array");
|
|
scriptAssertf(pPed->GetPedConfigFlag( CPED_CONFIG_FLAG_HasAScriptBrain ) == false, "CScriptBrainDispatcher::PurgeWaitingItems - ped shouldn't be in the waiting array if it already has a brain");
|
|
scriptAssertf(pPed->GetPedConfigFlag( CPED_CONFIG_FLAG_WaitingForScriptBrainToLoad ), "CScriptBrainDispatcher::PurgeWaitingItems - ped in the waiting array should have its waiting flag set");
|
|
|
|
pPed->SetPedConfigFlag( CPED_CONFIG_FLAG_WaitingForScriptBrainToLoad, false );
|
|
pPed->SetStreamedScriptBrainToLoad(-1);
|
|
}
|
|
break;
|
|
case OBJECT_WAITING :
|
|
{
|
|
#if __ASSERT
|
|
CObject *pObject = ItemsWaitingForBrains[loop].m_pWaitingObject;
|
|
scriptAssertf(pObject->StreamedScriptBrainToLoad == ItemsWaitingForBrains[loop].m_scriptBrainIndex, "CScriptBrainDispatcher::PurgeWaitingItems - Brain Index should be the same within object and within waiting array");
|
|
scriptAssertf(pObject->m_nObjectFlags.ScriptBrainStatus != CObject::OBJECT_DOESNT_USE_SCRIPT_BRAIN, "CScriptBrainDispatcher::PurgeWaitingItems - object brain status shouldn't be OBJECT_DOESNT_USE_SCRIPT_BRAIN");
|
|
#endif
|
|
// Any script that is already running should be left to terminate itself
|
|
|
|
// Leave it up to the object destructor to reset these
|
|
// m_nObjectFlags.ScriptBrainStatus
|
|
// StreamedScriptBrainToLoad
|
|
}
|
|
break;
|
|
case WORLD_POINT_WAITING :
|
|
{
|
|
C2dEffect *pEffect = ItemsWaitingForBrains[loop].m_pWaitingWorldPoint;
|
|
CWorldPointAttr* wp = pEffect->GetWorldPoint();
|
|
|
|
scriptAssertf(wp->BrainStatus == CWorldPoints::WAITING_FOR_BRAIN_TO_LOAD, "CScriptBrainDispatcher::PurgeWaitingItems - World point in waiting array doesn't have WAITING status");
|
|
scriptAssertf(wp->ScriptBrainToLoad == ItemsWaitingForBrains[loop].m_scriptBrainIndex, "CScriptBrainDispatcher::PurgeWaitingItems - Brain Index should be the same within world point and within waiting array");
|
|
|
|
// Setting this to WAITING_TILL_OUT_OF_BRAIN_RANGE instead of OUT_OF_BRAIN_RANGE should prevent the brain triggering
|
|
// as soon as the player leaves the network game if he is standing within the activation range
|
|
wp->BrainStatus = CWorldPoints::WAITING_TILL_OUT_OF_BRAIN_RANGE;
|
|
// Don't reset scriptBrainIndexToLoad here as IsWorldPointWithinActivationRange needs the link from WorldPoint to ScriptBrainArray
|
|
// pWorldPoint->scriptBrainIndexToLoad = -1;
|
|
}
|
|
break;
|
|
default :
|
|
scriptAssertf(0, "CScriptBrainDispatcher::PurgeWaitingItems - Item is not a ped, object or world point");
|
|
break;
|
|
}
|
|
|
|
s32 nBrainIndex = ItemsWaitingForBrains[loop].m_scriptBrainIndex;
|
|
scriptAssertf( (nBrainIndex >= 0) && (nBrainIndex < MAX_DIFFERENT_SCRIPT_BRAINS), "CScriptBrainDispatcher::PurgeWaitingItems - script brain index is out of range");
|
|
s32 StreamedScriptId = g_StreamedScripts.FindSlot(CTheScripts::GetScriptsForBrains().ScriptBrainArray[nBrainIndex].m_ScriptFileName);
|
|
scriptAssertf(StreamedScriptId != -1, "%s:CScriptBrainDispatcher::PurgeWaitingItems - Script doesn't exist", CTheScripts::GetScriptsForBrains().ScriptBrainArray[nBrainIndex].m_ScriptFileName.GetCStr());
|
|
g_StreamedScripts.ClearRequiredFlag(StreamedScriptId, STRFLAG_MISSION_REQUIRED);
|
|
|
|
ItemsWaitingForBrains[loop].m_pWaitingObject = NULL;
|
|
ItemsWaitingForBrains[loop].m_pWaitingPed = NULL;
|
|
ItemsWaitingForBrains[loop].m_pWaitingWorldPoint = NULL;
|
|
|
|
ItemsWaitingForBrains[loop].m_scriptBrainIndex = -1;
|
|
ItemsWaitingForBrains[loop].m_waitingItemsType = INVALID_WAITING;
|
|
}
|
|
loop++;
|
|
}
|
|
}
|
|
bool CScriptBrainDispatcher::AreAnyItemsWaiting(void)
|
|
{
|
|
int loop = (MAX_ENTITIES_WAITING_FOR_SCRIPT_BRAIN - 1);
|
|
while (loop >= 0)
|
|
{
|
|
if (ItemsWaitingForBrains[loop].m_waitingItemsType != INVALID_WAITING)
|
|
{
|
|
return true;
|
|
}
|
|
loop--;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
*/
|
|
|
|
|