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

1884 lines
58 KiB
C++
Raw Permalink Blame History

#include "script/script_cars_and_peds.h"
// Framework headers
#include "fwsys/metadatastore.h"
#include "fwvehicleai/pathfindtypes.h"
// Game headers
#include "animation/MovePed.h"
#include "camera/CamInterface.h"
#include "event/Events.h"
#include "event/ShockingEvents.h"
#include "MissionCreatorData_parser.h"
#include "Peds/ped.h"
#include "Peds/PedCapsule.h"
#include "Peds/PedFactory.h"
#include "Peds/PedIntelligence.h"
#include "Peds/pedpopulation.h"
#include "Peds/PedTaskRecord.h"
#include "Peds/WildlifeManager.h"
#include "physics/physics.h"
#include "scene/world/GameWorld.h"
#include "scene/LoadScene.h"
#include "scene/playerswitch/PlayerSwitchInterface.h"
#include "script/script.h"
#include "script/script_brains.h"
#include "script/script_channel.h"
#include "streaming/populationstreaming.h"
#include "streaming/streaming.h"
#include "task/General/TaskBasic.h"
#include "task/Response/Info/AgitatedManager.h"
#include "task/Scenario/ScenarioManager.h"
#include "Vehicles/vehicle.h"
#include "Vehicles/VehicleFactory.h"
#include "vehicles/VehiclePopulation.h"
#include "vehicleAi/VehicleIntelligence.h"
#include "vfx/particles/PtFxManager.h"
#define AS_GOOD_AS_STOPPED_SPEED (0.02f)
AI_OPTIMISATIONS()
NETWORK_OPTIMISATIONS()
#define UPSIDEDOWN_CAR_TIMER_THRESHOLD (7000)
CUpsideDownCarCheck CScriptCars::UpsideDownCars;
CStuckCarCheck CScriptCars::StuckCars;
CSuppressedModels CScriptPeds::SuppressedPedModels;
CRestrictedModels CScriptPeds::RestrictedPedModels;
CSuppressedModels CScriptCars::SuppressedCarModels;
PARAM(missioncreatordebug, "prints debug related to the missionc reator asset budget");
// Class to handle checking for mission cars being stuck on their roofs
/////////////////////////////////////////////////////////////////////////////////
// FUNCTION : CUpsideDownCarCheck::Init
// PURPOSE : Clears the array used to check for upside-down cars
/////////////////////////////////////////////////////////////////////////////////
void CUpsideDownCarCheck::Init(void)
{
for (u32 loop = 0; loop < MAX_UPSIDEDOWN_CAR_CHECKS; loop++)
{
Cars[loop].CarID = NULL_IN_SCRIPTING_LANGUAGE;
Cars[loop].UpsideDownTimer = 0;
}
}
/////////////////////////////////////////////////////////////////////////////////
// FUNCTION : CUpsideDownCarCheck::IsCarUpsideDown
// PURPOSE : Returns TRUE if the specified car is upside-down and moving slowly
// INPUTS : ID of car to check
// RETURNS : TRUE if the car is stuck on its roof, FALSE if the car is not on its
// roof or is moving at a reasonable speed
/////////////////////////////////////////////////////////////////////////////////
bool CUpsideDownCarCheck::IsCarUpsideDown(s32 CarToCheckID)
{
const CVehicle *pVehicleToCheck = CTheScripts::GetEntityToQueryFromGUID<CVehicle>(CarToCheckID);
if(scriptVerifyf(pVehicleToCheck, "CUpsideDownCarCheck::IsCarUpsideDown - Car doesn't exist"))
{
return IsCarUpsideDown(pVehicleToCheck);
}
return false;
}
/////////////////////////////////////////////////////////////////////////////////
// FUNCTION : As above, but takes pointer to vehicle
/////////////////////////////////////////////////////////////////////////////////
bool CUpsideDownCarCheck::IsCarUpsideDown(const CVehicle* pVehicleToCheck)
{
if(scriptVerifyf(pVehicleToCheck, "CUpsideDownCarCheck::IsCarUpsideDown - car doesn't exist"))
{
const float fCz = pVehicleToCheck->GetTransform().GetC().GetZf();
int iNumberOfWheels = pVehicleToCheck->GetNumWheels();
if(iNumberOfWheels <= 0)
{
iNumberOfWheels = 1;//pretend we have at least one wheel, so this will vaguely work for boats
}
static dev_float sfMaxVelMagSq = 4.0f;
if(pVehicleToCheck->GetVelocity().Mag2() < sfMaxVelMagSq && ((fCz < UPSIDEDOWN_CAR_UPZ_THRESHOLD && pVehicleToCheck->GetNumContactWheels() < iNumberOfWheels) || fCz < 0.0f))
{
if(pVehicleToCheck->CanPedStepOutCar(NULL, false))
return true;
}
}
return false;
}
/////////////////////////////////////////////////////////////////////////////////
// FUNCTION : CUpsideDownCarCheck::IsCarInUpsideDownCarArray
// PURPOSE : Checks whether the provided car ID is contained in the CUpsideDownCarCheck array
/////////////////////////////////////////////////////////////////////////////////
bool CUpsideDownCarCheck::IsCarInUpsideDownCarArray(s32 CarToCheckID)
{
for (u32 loop = 0; loop < MAX_UPSIDEDOWN_CAR_CHECKS; loop++)
{
if (Cars[loop].CarID == CarToCheckID)
{
return true;
}
}
return false;
}
/////////////////////////////////////////////////////////////////////////////////
// FUNCTION : CUpsideDownCarCheck::UpdateTimers
// PURPOSE : Increases the timer of all cars in the array which are currently upside down
/////////////////////////////////////////////////////////////////////////////////
void CUpsideDownCarCheck::UpdateTimers(void)
{
u32 TimeStep = fwTimer::GetTimeStepInMilliseconds();
for (u32 loop = 0; loop < MAX_UPSIDEDOWN_CAR_CHECKS; loop++)
{
if (Cars[loop].CarID != NULL_IN_SCRIPTING_LANGUAGE)
{
const CVehicle *pVehicle = CTheScripts::GetEntityToQueryFromGUID<CVehicle>(Cars[loop].CarID, 0);
if (pVehicle)
{
if (IsCarUpsideDown(pVehicle))
{
Cars[loop].UpsideDownTimer += TimeStep;
}
else
{
Cars[loop].UpsideDownTimer = 0;
}
}
else
{ // Car is no longer on the map - remove it from the array of cars to check
Cars[loop].CarID = NULL_IN_SCRIPTING_LANGUAGE;
Cars[loop].UpsideDownTimer = 0;
}
}
}
}
/////////////////////////////////////////////////////////////////////////////////
// FUNCTION : CUpsideDownCarCheck::AddCarToCheck
// PURPOSE : Adds a car to the array of cars to be checked for being upside-down
// INPUTS : ID of car to add
/////////////////////////////////////////////////////////////////////////////////
void CUpsideDownCarCheck::AddCarToCheck(s32 NewCarID)
{
u32 loop = 0;
// Check car is not already in the array
while (loop < MAX_UPSIDEDOWN_CAR_CHECKS)
{
scriptAssertf((Cars[loop].CarID != NewCarID), "CUpsideDownCarCheck::AddCarToCheck - Trying to add car to upsidedown check again");
loop++;
}
loop = 0;
// Find a space in the array for the car
while ((loop < MAX_UPSIDEDOWN_CAR_CHECKS) && (Cars[loop].CarID != NULL_IN_SCRIPTING_LANGUAGE))
{
loop++;
}
scriptAssertf((loop < MAX_UPSIDEDOWN_CAR_CHECKS), "CUpsideDownCarCheck::AddCarToCheck - Too many upsidedown car checks");
// Add the car to the array
if (loop < MAX_UPSIDEDOWN_CAR_CHECKS)
{
Cars[loop].CarID = NewCarID;
Cars[loop].UpsideDownTimer = 0;
}
}
/////////////////////////////////////////////////////////////////////////////////
// FUNCTION : CUpsideDownCarCheck::RemoveCarFromCheck
// PURPOSE : Removes a car from the array of cars to be checked (if it is there)
// INPUTS : ID of car to remove
/////////////////////////////////////////////////////////////////////////////////
void CUpsideDownCarCheck::RemoveCarFromCheck(s32 RemoveCarID)
{
for (u32 loop = 0; loop < MAX_UPSIDEDOWN_CAR_CHECKS; loop++)
{
if (Cars[loop].CarID == RemoveCarID)
{
Cars[loop].CarID = NULL_IN_SCRIPTING_LANGUAGE;
Cars[loop].UpsideDownTimer = 0;
}
}
}
/////////////////////////////////////////////////////////////////////////////////
// FUNCTION : CUpsideDownCarCheck::HasCarBeenUpsideDownForAWhile
// PURPOSE : Returns TRUE if the specified car (which must be in the array)
// has been upside-down for the required length of time
// INPUTS : ID of car to check (must have already been added to the array)
// RETURNS : TRUE if the car has been upside-down for a reasonable time
/////////////////////////////////////////////////////////////////////////////////
bool CUpsideDownCarCheck::HasCarBeenUpsideDownForAWhile(s32 CheckCarID)
{
for (u32 loop = 0; loop < MAX_UPSIDEDOWN_CAR_CHECKS; loop++)
{
if (Cars[loop].CarID == CheckCarID)
{
if (Cars[loop].UpsideDownTimer > UPSIDEDOWN_CAR_TIMER_THRESHOLD)
{
return TRUE;
}
else
{
return FALSE;
}
}
}
scriptAssertf(0, "CUpsideDownCarCheck::HasCarBeenUpsideDownForAWhile - Vehicle not in upsidedown check array");
return FALSE;
}
// End of code for checking for upsidedown cars
// Class to handle checking for mission cars being stuck
void CStuckCarCheck::ResetArrayElement(u32 Index)
{
Cars[Index].m_CarID = NULL_IN_SCRIPTING_LANGUAGE;
Cars[Index].LastPos = Vector3(-5000.0f, -5000.0f, -5000.0f);
Cars[Index].LastChecked = -1;
Cars[Index].StuckRadius = 0.0f;
Cars[Index].CheckTime = 0;
Cars[Index].bStuck = FALSE;
Cars[Index].bWarpCar = false;
Cars[Index].bWarpIfStuckFlag = false;
Cars[Index].bWarpIfUpsideDownFlag = false;
Cars[Index].bWarpIfInWaterFlag = false;
Cars[Index].NumberOfNodesToCheck = 0;
}
void CStuckCarCheck::Init(void)
{
for (u32 loop = 0; loop < MAX_STUCK_CAR_CHECKS; loop++)
{
ResetArrayElement(loop);
}
}
bool CStuckCarCheck::AttemptToWarpVehicle(CVehicle *pVehicle, Vector3 &NewCoords, float NewHeading)
{
float fRadiusForOffScreenChecks = 4.0f; // should this be available to the level designers too?
if (camInterface::IsSphereVisibleInGameViewport(NewCoords, fRadiusForOffScreenChecks) == false)
{
// NewCoords.z += 1.0f;
float MinX = NewCoords.x - fRadiusForOffScreenChecks;
float MaxX = NewCoords.x + fRadiusForOffScreenChecks;
float MinY = NewCoords.y - fRadiusForOffScreenChecks;
float MaxY = NewCoords.y + fRadiusForOffScreenChecks;
float MinZ = NewCoords.z - fRadiusForOffScreenChecks;
float MaxZ = NewCoords.z + fRadiusForOffScreenChecks;
Vec3V vBoxMin(MinX, MinY, MinZ);
Vec3V vBoxMax(MaxX, MaxY, MaxZ);
spdAABB testBox;
testBox.Set(vBoxMin, vBoxMax);
int NumberOfMissionEntitiesInArea = 0;
fwIsBoxIntersectingApprox searchBox(testBox);
CGameWorld::ForAllEntitiesIntersecting(&searchBox,
CTheScripts::CountMissionEntitiesInAreaCB, static_cast<void*>(&NumberOfMissionEntitiesInArea),
ENTITY_TYPE_MASK_VEHICLE|ENTITY_TYPE_MASK_PED|ENTITY_TYPE_MASK_OBJECT, SEARCH_LOCATION_EXTERIORS|SEARCH_LOCATION_INTERIORS,
SEARCH_LODTYPE_HIGHDETAIL, SEARCH_OPTION_NONE, WORLDREP_SEARCHMODULE_SCRIPT);
if (NumberOfMissionEntitiesInArea == 0)
{
CVehiclePopulation::SetCoordsOfScriptCar(pVehicle, NewCoords.x, NewCoords.y, NewCoords.z, true, true); // clear orientation to ensure the vehicle isn't upside-down
pVehicle->SetHeading(( DtoR * NewHeading));
return true;
}
}
return false;
}
void CStuckCarCheck::Process(void)
{
Vector3 DiffVec;
Vector3 NewCoords;
float NewHeading;
CNodeAddress ResultNode;
u32 TimeStep = fwTimer::GetTimeInMilliseconds();
for (u32 loop = 0; loop < MAX_STUCK_CAR_CHECKS; loop++)
{
if (Cars[loop].m_CarID != NULL_IN_SCRIPTING_LANGUAGE)
{
CVehicle *pVehicle = CTheScripts::GetEntityToModifyFromGUID<CVehicle>(Cars[loop].m_CarID, 0);
if (pVehicle)
{
if (pVehicle->GetDriver())
{
if (TimeStep > u32(Cars[loop].LastChecked + Cars[loop].CheckTime))
{
const Vector3 NewPos = VEC3V_TO_VECTOR3(pVehicle->GetTransform().GetPosition());
DiffVec = NewPos - Cars[loop].LastPos;
float DistanceMoved = DiffVec.Mag();
if (DistanceMoved < Cars[loop].StuckRadius)
{
Cars[loop].bStuck = TRUE;
}
else
{
Cars[loop].bStuck = FALSE;
}
Cars[loop].LastPos = NewPos;
Cars[loop].LastChecked = TimeStep;
}
if (Cars[loop].bWarpCar)
{
bool bAttemptToWarpThisCarNow = false;
if (Cars[loop].bWarpIfStuckFlag)
{
if (Cars[loop].bStuck)
{
bAttemptToWarpThisCarNow = true;
}
}
if (Cars[loop].bWarpIfUpsideDownFlag)
{
if(CScriptCars::GetUpsideDownCars().IsCarUpsideDown(pVehicle))
bAttemptToWarpThisCarNow = true;
}
if (Cars[loop].bWarpIfInWaterFlag)
{
if (pVehicle->GetIsInWater())
{
bAttemptToWarpThisCarNow = true;
}
}
if (bAttemptToWarpThisCarNow)
{
if (camInterface::IsSphereVisibleInGameViewport(pVehicle->GetBoundCentre(), pVehicle->GetBoundRadius()) == false)
{ // car is offscreen
if (Cars[loop].NumberOfNodesToCheck < 0)
{
CVehicleNodeList * pNodeList = pVehicle->GetIntelligence()->GetNodeList();
Assertf(pNodeList, "CStuckCarCheck::Process - vehicle has no node list");
if(pNodeList)
{
// find the vehicle's last route coords
CNodeAddress OldNode, NewNode;
s32 iTargetNode = pNodeList->GetTargetNodeIndex();
s32 iOldNode = pNodeList->GetTargetNodeIndex() - 1;
OldNode = pNodeList->GetPathNodeAddr(iOldNode);
NewNode = pNodeList->GetPathNodeAddr(iTargetNode);
bool bSuccess;
NewCoords = ThePaths.FindNodeCoorsForScript(OldNode, NewNode, &NewHeading, &bSuccess);
// Assert(bSuccess);
if (bSuccess)
{
AttemptToWarpVehicle(pVehicle, NewCoords, NewHeading);
}
}
}
else
{ // closest car nodes - check up to NumberOfNodesToCheck closest car nodes from its current position
u8 ClosestNodeIndex = 0;
bool bFound = false;
const Vector3 vVehiclePosition = VEC3V_TO_VECTOR3(pVehicle->GetTransform().GetPosition());
while ( (ClosestNodeIndex < Cars[loop].NumberOfNodesToCheck) && !bFound)
{
ResultNode = ThePaths.FindNthNodeClosestToCoors(vVehiclePosition, 999999.9f, false, ClosestNodeIndex);
bool bSuccess;
NewCoords = ThePaths.FindNodeCoorsForScript(ResultNode, &bSuccess);
// Assert(bSuccess); // Code needed to deal with this.
if (bSuccess)
{
NewHeading = ThePaths.FindNodeOrientationForCarPlacement(ResultNode); // in degrees
if (AttemptToWarpVehicle(pVehicle, NewCoords, NewHeading))
{
bFound = true;
}
else
{
ClosestNodeIndex++;
}
}
else
{
ClosestNodeIndex++;
}
}
}
}
}
} // end of if (Cars[loop].bWarpCar)
} // end of if (pVehicle->pDriver)
else
{ // vehicle doesn't have a driver
Cars[loop].LastPos = VEC3V_TO_VECTOR3(pVehicle->GetTransform().GetPosition());
Cars[loop].LastChecked = TimeStep;
}
}
else
{ // Car is no longer on the map - remove it from the array of cars to check
ResetArrayElement(loop);
}
} // end of if (Cars[loop].m_CarID != NULL_IN_SCRIPTING_LANGUAGE)
} // end of for
}
void CStuckCarCheck::AddCarToCheck(s32 NewCarID, float StuckRad, u32 CheckEvery, bool bWarpCar, bool bStuckFlag, bool bUpsideDownFlag, bool bInWaterFlag, s8 NumberOfNodesToCheck)
{
const CVehicle *pVehicle = CTheScripts::GetEntityToQueryFromGUID<CVehicle>(NewCarID);
if (pVehicle)
{ // Only add the car if it is valid
u32 loop = 0;
// Check car is not already in the array
while (loop < MAX_STUCK_CAR_CHECKS)
{
scriptAssertf( (Cars[loop].m_CarID != NewCarID), "CStuckCarCheck::AddCarToCheck - Trying to add car to stuck car check again");
loop++;
}
loop = 0;
// Find a space in the array for the car
while ((loop < MAX_STUCK_CAR_CHECKS) && (Cars[loop].m_CarID != NULL_IN_SCRIPTING_LANGUAGE))
{
loop++;
}
scriptAssertf( (loop < MAX_STUCK_CAR_CHECKS), "CStuckCarCheck::AddCarToCheck - Too many stuck car checks");
// Add the car to the array
if (loop < MAX_STUCK_CAR_CHECKS)
{
Cars[loop].m_CarID = NewCarID;
Cars[loop].LastPos = VEC3V_TO_VECTOR3(pVehicle->GetTransform().GetPosition());
Cars[loop].LastChecked = fwTimer::GetTimeInMilliseconds();
Cars[loop].StuckRadius = StuckRad;
Cars[loop].CheckTime = CheckEvery;
Cars[loop].bStuck = FALSE;
Cars[loop].bWarpCar = bWarpCar;
Cars[loop].bWarpIfStuckFlag = bStuckFlag;
Cars[loop].bWarpIfUpsideDownFlag = bUpsideDownFlag;
Cars[loop].bWarpIfInWaterFlag = bInWaterFlag;
Cars[loop].NumberOfNodesToCheck = NumberOfNodesToCheck;
}
}
}
void CStuckCarCheck::RemoveCarFromCheck(s32 RemoveCarID)
{
for (u32 loop = 0; loop < MAX_STUCK_CAR_CHECKS; loop++)
{
if (Cars[loop].m_CarID == RemoveCarID)
{
ResetArrayElement(loop);
}
}
}
// Clears the stuck flag if the car is present in the stuck car check array
void CStuckCarCheck::ClearStuckFlagForCar(s32 CheckCarID)
{
for (u32 loop = 0; loop < MAX_STUCK_CAR_CHECKS; loop++)
{
if (Cars[loop].m_CarID == CheckCarID)
{
Cars[loop].bStuck = false;
}
}
}
bool CStuckCarCheck::IsCarInStuckCarArray(s32 CheckCarID)
{
for (u32 loop = 0; loop < MAX_STUCK_CAR_CHECKS; loop++)
{
if (Cars[loop].m_CarID == CheckCarID)
{
return true;
}
}
return false;
}
// End of code for checking for mission cars being stuck
bool CBoatIsBeachedCheck::IsBoatBeached(const CVehicle& in_VehicleToCheck)
{
if ( in_VehicleToCheck.InheritsFromBoat() )
{
if ( in_VehicleToCheck.GetIntelligence() )
{
if ( in_VehicleToCheck.GetIntelligence()->GetBoatAvoidanceHelper() )
{
if ( in_VehicleToCheck.GetIntelligence()->GetBoatAvoidanceHelper()->IsBeached() )
{
return true;
}
}
}
}
return false;
}
// end of code for checking boats beached
void CScriptCars::Init(unsigned initMode)
{
if(initMode == INIT_SESSION)
{
UpsideDownCars.Init();
StuckCars.Init();
SuppressedCarModels.ClearAllSuppressedModels();
}
}
void CScriptPeds::Init(unsigned initMode)
{
if(initMode == INIT_SESSION)
{
SuppressedPedModels.ClearAllSuppressedModels();
CTaskSequences::Init();
CPedGroups::Init();
CInformFriendsEventQueue::Init();
CInformGroupEventQueue::Init();
}
}
void CScriptEntities::Init(unsigned initMode)
{
if(initMode == INIT_SESSION)
{
}
}
void CScriptCars::Process(void)
{
UpsideDownCars.UpdateTimers();
StuckCars.Process();
}
void CScriptPeds::Process(void)
{
// Certain events can be suppressed per frame through script.
// To support this, reset the suppression at the last possible moment (i.e., now).
// That way we are certain that all events had a chance to be blocked as they can be
// created at various times in the update cycle.
CShockingEventsManager::ProcessPreScripts();
// Likewise, certain aspects of scenario usage can be suppressed per frame through script.
CScenarioManager::ProcessPreScripts();
// Clear the suppression of shocking events this frame before scripts get a chance to run.
CAgitatedManager::GetInstance().SetSuppressAgitationEvents(false);
// Clear reset variables in the wildlife manager.
CWildlifeManager::GetInstance().ProcessPreScripts();
// Clear ped reset variables.
CPed::SetRandomPedsBlockingNonTempEventsThisFrame(false);
// Reset cop perception override parameters if set by script using SET_COP_PERCEPTION_OVERRIDES (get set in CPed::ProcessPreRender).
bool bResetCopPerceptionOverrides = CPedPerception::ms_bCopOverridesSet;
if (bResetCopPerceptionOverrides)
{
CPedPerception::ResetCopOverrideParameters();
}
CPedAccuracy::fMPAmbientLawPedAccuracyModifier = 1.0f;
CPed::Pool* pPedPool = CPed::GetPool();
s32 i=pPedPool->GetSize();
while(i--)
{
CPed *pPed = pPedPool->GetSlot(i);
if(pPed)
{
//Clear all the recorded events for every mission ped.
if(pPed->PopTypeIsMission())
{
pPed->GetPedIntelligence()->RecordEventForScript(EVENT_NONE,0);
}
// Reset anything on players that needs to be reset pre-script
if(pPed->IsPlayer() && pPed->GetPlayerInfo())
{
pPed->GetPlayerInfo()->ResetPreScript();
}
// Reset the perception data on cops if overrides were previously set.
if (bResetCopPerceptionOverrides && pPed->IsCopPed())
{
pPed->GetPedIntelligence()->SetPedPerception(pPed);
}
}
}
}
void CSuppressedModels::ClearAllSuppressedModels(void)
{
u32 loop = 0;
while (loop < SuppressedModels.GetCount())
{
gPopStreaming.RequestVehicleDriver(SuppressedModels[loop].SuppressedModel);
loop++;
}
SuppressedModels.Reset();
}
bool CSuppressedModels::AddToSuppressedModelArray(u32 NewModel, const strStreamingObjectName pScriptName)
{
if (HasModelBeenSuppressed(NewModel))
{ // This model is already in the array so just return
return false;
}
if (!scriptVerifyf(!SuppressedModels.IsFull(), "AddToSuppressedModelArray - no space left to add another model, max is %i", SuppressedModels.GetMaxCount()))
{
return false;
}
suppressed_model_struct st;
st.SuppressedModel = NewModel;
st.NameOfScriptThatHasSuppressedModel = pScriptName;
SuppressedModels.Push(st);
gPopStreaming.UnrequestVehicleDriver(NewModel);
return true;
}
bool CSuppressedModels::RemoveFromSuppressedModelArray(u32 ModelToRemove)
{
u32 loop = 0;
while (loop < SuppressedModels.GetCount())
{
if (SuppressedModels[loop].SuppressedModel == ModelToRemove)
{
SuppressedModels.DeleteFast(loop);
gPopStreaming.RequestVehicleDriver(ModelToRemove);
return true; // we're already testing to make sure we don't have duplicates in AddToSuppressedModelArray()
}
loop++;
}
return false;
}
bool CSuppressedModels::HasModelBeenSuppressed(u32 Model)
{
u32 loop = 0;
while (loop < SuppressedModels.GetCount())
{
if (SuppressedModels[loop].SuppressedModel == Model)
{
return true;
}
loop++;
}
return false;
}
#if __BANK
void CSuppressedModels::PrintSuppressedModels()
{
for (int loop = 0; loop < SuppressedModels.GetCount(); loop++)
{
if (SuppressedModels[loop].SuppressedModel != fwModelId::MI_INVALID)
{
scriptDisplayf("%s suppressed by %s",
CModelInfo::GetBaseModelInfoName(fwModelId(strLocalIndex(SuppressedModels[loop].SuppressedModel))),
SuppressedModels[loop].NameOfScriptThatHasSuppressedModel.GetCStr());
}
}
}
#endif // __BANK
#if DEBUG_DRAW
void CSuppressedModels::DisplaySuppressedModels()
{
char debugText[255];
bool bAnySuppressedModels = false;
formatf(debugText, "Suppressed models:");
char* debugTextPtr = debugText;
debugTextPtr += strlen(debugTextPtr);
for (s32 i = 0; i < SuppressedModels.GetCount(); i++)
{
if (SuppressedModels[i].SuppressedModel != fwModelId::MI_INVALID)
{
#if !__FINAL
formatf(debugTextPtr, debugText + sizeof(debugText) - debugTextPtr, " %s", CModelInfo::GetBaseModelInfoName(fwModelId(strLocalIndex(SuppressedModels[i].SuppressedModel))));
#else
formatf(debugTextPtr, debugText + sizeof(debugText) - debugTextPtr, " %d", SuppressedModels[i].SuppressedModel);
#endif
debugTextPtr += strlen(debugTextPtr);
bAnySuppressedModels = true;
}
}
if (bAnySuppressedModels)
{
grcDebugDraw::AddDebugOutput(debugText);
}
}
#else // DEBUG_DRAW
void CSuppressedModels::DisplaySuppressedModels()
{
}
#endif // DEBUG_DRAW
CRestrictedModels::CRestrictedModels()
{
ClearAllRestrictedModels();
}
void CRestrictedModels::ClearAllRestrictedModels()
{
RestrictedModels.Reset();
}
void CRestrictedModels::AddToRestrictedModelArray(u32 model, const strStreamingObjectName scriptName)
{
if (HasModelBeenRestricted(model))
{ // This model is already in the array so just return
return;
}
scriptAssertf(!RestrictedModels.IsFull(), "AddToRestrictedModelArray - no space left to add another model");
RestrictedModelStruct st;
st.m_model = model;
st.m_scriptName = scriptName;
RestrictedModels.Push(st);
}
void CRestrictedModels::RemoveFromRestrictedModelArray(u32 model)
{
u32 loop = 0;
while (loop < RestrictedModels.GetCount())
{
if (RestrictedModels[loop].m_model == model)
{
RestrictedModels.DeleteFast(loop);
break; // we're already testing to make sure we don't have duplicates in AddToSuppressedModelArray()
}
loop++;
}
}
bool CRestrictedModels::HasModelBeenRestricted(u32 model) const
{
u32 loop = 0;
while (loop < RestrictedModels.GetCount())
{
if (RestrictedModels[loop].m_model == model)
{
return true;
}
loop++;
}
return false;
}
void CRestrictedModels::DisplayRestrictedModels()
{
#if DEBUG_DRAW
char debugText[255];
bool bAnyRestrictedModels = false;
formatf(debugText, "Restricted Models:");
char* debugTextPtr = debugText;
debugTextPtr += strlen(debugTextPtr);
for (s32 i = 0; i < RestrictedModels.GetCount(); i++)
{
if (RestrictedModels[i].m_model != fwModelId::MI_INVALID)
{
#if !__FINAL
formatf(debugTextPtr, debugText + sizeof(debugText) - debugTextPtr, " %s", CModelInfo::GetBaseModelInfoName(fwModelId(strLocalIndex(RestrictedModels[i].m_model))));
#else
formatf(debugTextPtr, debugText + sizeof(debugText) - debugTextPtr, " %d", RestrictedModels[i].m_model);
#endif
debugTextPtr += strlen(debugTextPtr);
bAnyRestrictedModels = true;
}
}
if (bAnyRestrictedModels)
{
grcDebugDraw::AddDebugOutput(debugText);
}
#endif // DEBUG_DRAW
}
#if __BANK
void CRestrictedModels::PrintRestrictedModels()
{
for (int loop = 0; loop < RestrictedModels.GetCount(); loop++)
{
if (RestrictedModels[loop].m_model != fwModelId::MI_INVALID)
{
scriptDisplayf("%s restricted by %s",
CModelInfo::GetBaseModelInfoName(fwModelId(strLocalIndex(RestrictedModels[loop].m_model))),
RestrictedModels[loop].m_scriptName.GetCStr());
}
}
}
#endif // __BANK
bool CScriptPeds::IsPedStopped(const CPed *pPedToCheck)
{
if (scriptVerifyf(pPedToCheck, "CScriptPeds::IsPedStopped - Ped doesn't exist"))
{
if (pPedToCheck->GetPedConfigFlag( CPED_CONFIG_FLAG_InVehicle ) && pPedToCheck->GetMyVehicle())
{
scriptAssertf(pPedToCheck->GetMyVehicle(), "CScriptPeds::IsPedStopped - Ped is not in a vehicle");
if (pPedToCheck->GetMyVehicle()->GetDistanceTravelled() <= (AS_GOOD_AS_STOPPED_SPEED * 50.0f*fwTimer::GetTimeStep()))
{
return TRUE;
}
}
else
{
if (pPedToCheck->IsPlayer())
{
if (pPedToCheck->GetPedIntelligence()->FindTaskByType(CTaskTypes::TASK_JUMPVAULT))
return FALSE;
}
if (pPedToCheck->GetMotionData()->GetIsStill())
{
if ( (pPedToCheck->GetPedConfigFlag( CPED_CONFIG_FLAG_IsInTheAir ) == false) && (pPedToCheck->GetPedResetFlag( CPED_RESET_FLAG_IsLanding ) == false) && pPedToCheck->GetIsStanding() )
{
fwDynamicEntityComponent *pedDynComp = pPedToCheck->GetDynamicComponent();
if (!pedDynComp || pedDynComp->GetAnimatedVelocity().XYMag2() == 0.0f)
{
return TRUE;
}
}
}
}
}
return FALSE;
}
bool CScriptPeds::HasPedModelBeenRestrictedOrSuppressed(u32 modelIndex)
{
CPedModelInfo *pPedModelInfo = static_cast<CPedModelInfo *>(CModelInfo::GetBaseModelInfo(fwModelId(strLocalIndex(modelIndex))));
return HasPedModelBeenRestrictedOrSuppressed(modelIndex, pPedModelInfo);
}
bool CScriptPeds::HasPedModelBeenRestrictedOrSuppressed(u32 modelIndex, const CPedModelInfo *pPedModelInfo)
{
return (pPedModelInfo && (GetSuppressedPedModels().HasModelBeenSuppressed(modelIndex) || (pPedModelInfo->GetNumTimesOnFootAndInCar() > 0 && GetRestrictedPedModels().HasModelBeenRestricted(modelIndex))));
}
bool CScriptCars::IsVehicleStopped(const CVehicle *pVehicleToCheck)
{
if (scriptVerifyf(pVehicleToCheck, "CScriptCars::IsVehicleStopped - Vehicle doesn't exist"))
{
//When a ped exits a vehicle it moves, so this tries to compensate for this amount of movement.
if (pVehicleToCheck->GetHandBrake())
{
if (pVehicleToCheck->GetVelocity().Mag2() <= 0.05*0.05 )//, fwTimer::GetOldTimeStep()))) GetOldTimeStep doesn't exist anymore (Obbe)
{
return TRUE;
}
}
else
{
if (pVehicleToCheck->GetVelocity().Mag2() <= AS_GOOD_AS_STOPPED_SPEED*AS_GOOD_AS_STOPPED_SPEED )//, fwTimer::GetOldTimeStep()))) GetOldTimeStep doesn't exist anymore (Obbe)
{
return TRUE;
}
}
}
return FALSE;
}
void CScriptPeds::SetPedCoordinates(CPed* pPed, float NewX,float NewY, float NewZ, int Flags, bool bWarp, bool bResetPlants)
{
#if !__FINAL && !__NO_OUTPUT && __BANK
if (pPed && pPed->IsPlayer() && g_PlayerSwitch.IsActive())
{
Displayf("[Playerswitch] Script %s is moving player ped %s to (%4.2f, %4.2f, %4.2f) during switch. Call stack follows", CTheScripts::GetCurrentScriptNameAndProgramCounter(), pPed->GetModelName(), NewX, NewY, NewZ);
scrThread::PrePrintStackTrace();
}
if (pPed && pPed->IsPlayer() && g_LoadScene.IsActive())
{
Displayf("[Playerswitch] Script %s is moving player ped %s to (%4.2f, %4.2f, %4.2f) during load scene. Call stack follows", CTheScripts::GetCurrentScriptNameAndProgramCounter(), pPed->GetModelName(), NewX, NewY, NewZ);
scrThread::PrePrintStackTrace();
}
#endif
bool bWarpGang = false;
if (Flags & SetPedCoordFlag_WarpGang)
{
bWarpGang = true;
}
bool bOffset = false;
if (Flags & SetPedCoordFlag_OffsetZ)
{
bOffset = true;
}
bool bWarpCar = false;
if (Flags & SetPedCoordFlag_WarpCar)
{
bWarpCar = true;
}
CVehicle* pVehicle = NULL;
if (pPed->GetPedConfigFlag( CPED_CONFIG_FLAG_InVehicle ))
{
pVehicle = pPed->GetMyVehicle();
}
bool bOnGround = false;
if (NewZ <= INVALID_MINIMUM_WORLD_Z)
{
NewZ = WorldProbe::FindGroundZForCoord(BOTTOM_SURFACE, NewX, NewY);
bOnGround = true;
}
// Don't clear tasks if the ped is injured, and deactivate the ragdoll in a safe way.
bool bKeepTasks = pPed->IsInjured() || (Flags & SetPedCoordFlag_KeepTasks);
if( bKeepTasks ||
( pPed->GetUsingRagdoll() && bWarp ) )
{
pPed->DeactivatePhysicsAndDealWithRagdoll();
// We have seen a number of crashes when going into spectator mode.
// These seem to be caused by the ragdoll inst still having active contacts but they are now a long way from where the ped is
// to try and fix that we will just make sure we clear all the ragdoll inst contacts
if( pPed->GetRagdollInst() )
{
CPhysics::ClearManifoldsForInst( pPed->GetRagdollInst() );
}
}
if(pVehicle && pVehicle->GetVehicleType()==VEHICLE_TYPE_TRAIN)
{
pPed->SetPedOutOfVehicle(CPed::PVF_Warp|CPed::PVF_IgnoreSafetyPositionCheck);
pVehicle = NULL;
}
if (pVehicle && !bWarpCar)
{
CNetObjPed *pNetObjPed = (CNetObjPed *)pPed->GetNetworkObject();
if(pNetObjPed)
{
pNetObjPed->SetPedOutOfVehicle(CPed::PVF_IgnoreSafetyPositionCheck);
}
else
{
// pPed->GetPedIntelligence()->FlushImmediately(true);
pPed->SetPedOutOfVehicle(CPed::PVF_Warp|CPed::PVF_IgnoreSafetyPositionCheck);
}
pVehicle = NULL;
}
if (pVehicle && bWarpCar)
{
scriptAssertf(!pVehicle->IsNetworkClone(), "%s:Attempting to set the coordinates of a ped in a vehicle controlled on another machine", CTheScripts::GetCurrentScriptNameAndProgramCounter());
CVehiclePopulation::SetCoordsOfScriptCar(pVehicle, NewX, NewY, NewZ, false, true);
}
else
{
#if __ASSERT
if ((Flags & SetPedCoordFlag_AllowClones)==0)
{
scriptAssertf(!pPed->IsNetworkClone(), "%s:Attempting to set the coordinates of a ped controlled on another machine", CTheScripts::GetCurrentScriptNameAndProgramCounter());
}
#endif
if(bOffset)
{
NewZ += pPed->GetCapsuleInfo()->GetGroundToRootOffset(); // pPed->GetDistanceFromCentreOfMassToBaseOfModel();
}
if(NetworkInterface::IsGameInProgress())
{
// we can't warp the entire group in the network game as the different group members
// may be owned by other machines - this isn't the nicest way to fix this, but it's
// what the scripters want!
bWarpGang = false;
}
bool bKeepIK = (Flags & SetPedCoordFlag_KeepIK) != 0;
CPedGroup* pPedGroup=pPed->GetPedsGroup();
if(pPedGroup && pPedGroup->GetGroupMembership()->IsLeader(pPed) && bWarpGang)
{
//Ped is leader of the group so teleport the whole group.
pPedGroup->Teleport(Vector3(NewX, NewY, NewZ), bKeepTasks, bKeepIK, bResetPlants);
}
else
{
//Ped isn't leader of any group so just teleport the ped.
pPed->Teleport(Vector3(NewX, NewY, NewZ), pPed->GetCurrentHeading(), bKeepTasks, true, bKeepIK, bWarp, bResetPlants);
}
if(bOnGround)
{
pPed->SetIsStanding(true);
pPed->SetWasStanding(true);
pPed->SetGroundOffsetForPhysics(-pPed->GetCapsuleInfo()->GetGroundToRootOffset());
}
//Clear some space for pPed.
if(bWarp)
{
CScriptEntities::ClearSpaceForMissionEntity(pPed);
}
}
CStreaming::SetIsPlayerPositioned(true);
}
// Name : CScriptEntities::ClearSpaceForMissionEntity
// Purpose : Removes any unimportant peds and vehicles from the space
// which is occupied by a newly-created mission entity
// Parameters : pointer to the entity
// Returns : nothing
void CScriptEntities::ClearSpaceForMissionEntity(CEntity *pEnt)
{
CEntity *pCurrentEnt;
CPed *pPed;
CVehicle *pVehicle;
u16 loop;
float Range = pEnt->GetBoundRadius();
s32 NumberOfCollisions = 0;
// Check for collisions with vehicles, peds, objects and dummies
CEntity *pCollidingEnts[16];
CGameWorld::FindObjectsKindaColliding(VEC3V_TO_VECTOR3(pEnt->GetTransform().GetPosition()), Range, FALSE, FALSE, &NumberOfCollisions, 16, pCollidingEnts,
FALSE, TRUE, TRUE, FALSE, FALSE); // TRUE, TRUE);
// FALSE, TRUE, TRUE, TRUE, TRUE);
Matrix34 m = MAT34V_TO_MATRIX34(pEnt->GetMatrix());
if (NumberOfCollisions > 0)
{
for (loop = 0; loop < NumberOfCollisions; loop++)
{
pCurrentEnt = pCollidingEnts[loop];
if (pCurrentEnt != pEnt)
{
switch (pCurrentEnt->GetType())
{
case ENTITY_TYPE_PED :
{
// Peds in vehicles will be deleted when the vehicle is deleted
// so don't delete them seperately
pPed = (CPed *) pCurrentEnt;
if(pPed->GetPedConfigFlag( CPED_CONFIG_FLAG_InVehicle ))
{
pCollidingEnts[loop] = NULL;
}
if(pPed->IsPlayer() || !pPed->CanBeDeleted())
{
pCollidingEnts[loop] = NULL;
}
}
break;
case ENTITY_TYPE_VEHICLE :
{
pVehicle = (CVehicle *)pCurrentEnt;
// The false here (at the end of CanBeDeleted) means that being the player's last car is not enough to stop it being removed
if(pVehicle->m_nVehicleFlags.bCannotRemoveFromWorld || !pVehicle->CanBeDeletedSpecial(true, true, true, true, false))
{
pCollidingEnts[loop] = NULL;
}
}
break;
}
}
}
for(loop = 0; loop < NumberOfCollisions; loop++)
{
pCurrentEnt = pCollidingEnts[loop];
if( (pCurrentEnt != pEnt) && (pCurrentEnt != NULL))
{
if(pEnt->GetCurrentPhysicsInst() && pCurrentEnt->GetCurrentPhysicsInst() &&
Verifyf(pCurrentEnt->GetCurrentPhysicsInst() != reinterpret_cast<phInst*>(0xDDDDDDDD) && pCurrentEnt->GetCurrentPhysicsInst() != reinterpret_cast<phInst*>(0xCDCDCDCD), "Entity with no valid physics instance caught!"))
{
WorldProbe::CShapeTestBoundDesc boundTestDesc;
boundTestDesc.SetDomainForTest(WorldProbe::TEST_AGAINST_INDIVIDUAL_OBJECTS);
boundTestDesc.SetBoundFromEntity(pEnt);
boundTestDesc.SetIncludeEntity(pCurrentEnt);
boundTestDesc.SetTransform(&m);
if(WorldProbe::GetShapeTestManager()->SubmitTest(boundTestDesc))
{
switch (pCurrentEnt->GetType())
{
case ENTITY_TYPE_VEHICLE :
Displayf("Will try to delete a vehicle where a mission entity should be\n");
pVehicle = (CVehicle *)pCurrentEnt;
// this test is now done at an earlier stage to avoid wasted work in TestEntityAgainstEntity
// just assert to check that change worked ok
Assert(!pVehicle->m_nVehicleFlags.bCannotRemoveFromWorld && pVehicle->CanBeDeletedSpecial(true, true, true, true, false));
{
//skip any cargo cars, their parents will clean them up
if (CVehicle::IsEntityAttachedToTrailer(pVehicle))
{
continue;
}
pVehicle->RemoveDeleteWithParentProgenyFromList(&pCollidingEnts[loop+1],NumberOfCollisions-loop-1);
if (pVehicle->HasDummyAttachmentChildren())
{
for (int i = 0; i < pVehicle->GetMaxNumDummyAttachmentChildren(); i++)
{
if (pVehicle->GetDummyAttachmentChild(i))
{
std::replace( &pCollidingEnts[loop+1], pCollidingEnts + NumberOfCollisions, (CEntity*) pVehicle->GetDummyAttachmentChild(i), (CEntity*) NULL );
pVehicle->GetDummyAttachmentChild(i)->RemoveDeleteWithParentProgenyFromList(&pCollidingEnts[loop+1],NumberOfCollisions-loop-1);
}
}
}
CVehicleFactory::GetFactory()->Destroy(pVehicle);
}
// Is it safe to just assume that the vehicle has been deleted?
break;
case ENTITY_TYPE_PED :
pPed = (CPed *) pCurrentEnt;
// this test is now done at an earlier stage to avoid wasted work in TestEntityAgainstEntity
Assert(!pPed->IsPlayer() && pPed->CanBeDeleted());
{
// Is it safe to just delete any ped (including cops/emergency)?
pPed->RemoveDeleteWithParentProgenyFromList(&pCollidingEnts[loop+1],NumberOfCollisions-loop-1);
CPedFactory::GetFactory()->DestroyPed(pPed);
Displayf("Deleted a ped where a mission entity should be\n");
}
break;
default :
scriptAssertf(0, "ClearSpaceForMissionEntity - Colliding Entity Type not handled");
break;
}
}
}
}
}
}
}
//
// name: GivePedScriptedTask
// description: Give ped a new task. Instead of just giving a task the ped gets given
// a scripted task event. This ensures the ped will get the task and that
// it doesn't break the current task
void CScriptPeds::GivePedScriptedTask(s32 pedId, CTaskSequenceList* pTaskList, s32 CurrCommand,const char* commandName)
{
CTask* pTask = rage_new CTaskUseSequence(*pTaskList);
GivePedScriptedTask(pedId, pTask, CurrCommand, commandName);
}
void CScriptPeds::GivePedScriptedTask(s32 iPedID, aiTask* pTask, s32 CurrCommand, const char* commandName)
{
#if __DEV
char tmp[512];
sprintf(tmp, "%s, %s", CTheScripts::GetCurrentScriptNameAndProgramCounter(), commandName);
#endif
if (NetworkInterface::IsGameInProgress() && !CQueriableInterface::IsTaskHandledByNetwork(pTask->GetTaskType()) && !CQueriableInterface::CanTaskBeGivenToNonLocalPeds(pTask->GetTaskType()))
{
scriptAssertf(0, "%s : %s (%s) - This script command is not supported in network game scripts", CTheScripts::GetCurrentScriptNameAndProgramCounter(), commandName, pTask->GetName().c_str());
}
if (NULL_IN_SCRIPTING_LANGUAGE != iPedID) // New Rage script compiler uses NULL instead of -1 for sequence tasks
{
// Give task to ped
CPed* pPed = CTheScripts::GetEntityToModifyFromGUID<CPed>(iPedID, CTheScripts::GUID_ASSERT_FLAGS_INCLUDE_CLONES);
if (!pPed)
{
delete pTask;
return;
}
// if we are giving a task to a ped we are not currently in control of we need the network code to handle it
if(pPed->IsNetworkClone() || (pPed->GetNetworkObject() && pPed->GetNetworkObject()->IsPendingOwnerChange()))
{
gnetDebug2("%s : Calling %s on remotely owned %s", CTheScripts::GetCurrentScriptNameAndProgramCounter(), commandName, pPed->GetNetworkObject()->GetLogName());
NetworkInterface::GivePedScriptedTask(pPed, pTask, commandName);
return;
}
scriptAssertf(-1==CTaskSequences::ms_iActiveSequence, "%s:Sequence opened unexpectedly", tmp);
// A ped with a brain can only be given a task by its own ped brain script
CPed* pPedForBrain=0;
s8 ScriptBrainType = CTheScripts::GetCurrentGtaScriptThread()->ScriptBrainType;
if ( (CScriptsForBrains::PED_STREAMED==ScriptBrainType) || (CScriptsForBrains::SCENARIO_PED==ScriptBrainType) )
{
pPedForBrain = CTheScripts::GetEntityToModifyFromGUID<CPed>(CTheScripts::GetCurrentGtaScriptThread()->EntityIndexForScriptBrain);
}
if(pPed->GetPedConfigFlag( CPED_CONFIG_FLAG_HasAScriptBrain ) && pPedForBrain!=pPed)
{
delete pTask;
return;
}
// check that a sequence being used by this ped is not too large
if (pPed->GetNetworkObject() && !pPed->IsPlayer() && pTask->GetTaskType() == CTaskTypes::TASK_USE_SEQUENCE)
{
const CTaskSequenceList* pSeqList = static_cast<CTaskUseSequence*>(pTask)->GetTaskSequenceList();
if (pSeqList)
{
u32 numTasks = pSeqList->GetTaskList().GetNumTasks();
if (numTasks > IPedNodeDataAccessor::MAX_SYNCED_SEQUENCE_TASKS)
{
scriptAssertf(0, "%s : %s - The sequence used for this task is too big (%d), the max size currently supported is %d. Speak to a network coder", CTheScripts::GetCurrentScriptNameAndProgramCounter(), commandName, numTasks, IPedNodeDataAccessor::MAX_SYNCED_SEQUENCE_TASKS);
}
}
}
// create event and give to ped
CEventScriptCommand event(PED_TASK_PRIORITY_PRIMARY,pTask);
#if __DEV
event.SetScriptNameAndCounter(CTheScripts::GetCurrentScriptName(), CTheScripts::GetCurrentGtaScriptThread()->GetThreadPC());
#endif
pPed->GetPedIntelligence()->RemoveEventsOfType( EVENT_SCRIPT_COMMAND );
pPed->GetPedAiLod().SetForceNoTimesliceIntelligenceUpdate(true);// ensure event is processed next frame
CEvent* pEvent=pPed->GetPedIntelligence()->AddEvent(event,true);
if(pEvent)
{
const int iVacantSlot=CPedScriptedTaskRecord::GetVacantSlot();
Assert(iVacantSlot>=0);
if( iVacantSlot >= 0 )
{
#if __DEV
CPedScriptedTaskRecord::ms_scriptedTasks[iVacantSlot].Set(pPed,CurrCommand,(const CEventScriptCommand*)pEvent,tmp);
#else
CPedScriptedTaskRecord::ms_scriptedTasks[iVacantSlot].Set(pPed,CurrCommand,(const CEventScriptCommand*)pEvent);
#endif
}
}
}
else
{
// Add task to sequence
scriptAssertf(CTaskSequences::ms_bIsOpened[CTaskSequences::ms_iActiveSequence], "%s:Sequence task closed", tmp);
if (scriptVerifyf(CTaskSequences::ms_iActiveSequence >=0 && CTaskSequences::ms_iActiveSequence<CTaskSequences::MAX_NUM_SEQUENCE_TASKS, "%s:Sequence task closed", tmp))
{
#if __ASSERT
if (NetworkInterface::IsGameInProgress() && !CTaskSequences::ms_TaskSequenceLists[CTaskSequences::ms_iActiveSequence].IsMigrationPrevented())
{
aiTask* pTaskToCheck = pTask;
// the subtask of a control movement task is what is synced and recreated when the ped migrates
if (pTask && pTask->GetTaskType() == CTaskTypes::TASK_COMPLEX_CONTROL_MOVEMENT)
{
CTaskComplexControlMovement *pMoveTask = SafeCast(CTaskComplexControlMovement, pTask);
pTaskToCheck = pMoveTask->GetBackupCopyOfMovementSubtask();
// sub task not currently synced
scriptAssertf(pMoveTask->GetMainSubTaskType() == CTaskTypes::TASK_NONE, "%s : %s (%s) - CTaskComplexControlMovement - sub task not currently supported in MP", CTheScripts::GetCurrentScriptNameAndProgramCounter(), commandName, pTaskToCheck->GetName().c_str());
}
if (pTaskToCheck && !CQueriableInterface::CanTaskBeGivenToNonLocalPeds(pTaskToCheck->GetTaskType()))
{
scriptAssertf(0, "%s : %s (%s) - Adding this task to a sequence is not currently supported in MP (it may not run when the ped migrates)", CTheScripts::GetCurrentScriptNameAndProgramCounter(), commandName, pTaskToCheck->GetName().c_str());
return;
}
}
#endif // __ASSERT
CTaskSequences::ms_TaskSequenceLists[CTaskSequences::ms_iActiveSequence].AddTask(pTask);
}
else
{
delete pTask;
return;
}
}
}
/*
CRaceTimes is a helper class for script to use to quickly get split times in races.
It's based around three arrays:
* ms_players stores all participating players where the index into the array is the player index used in the other arrays too.
* ms_splitTimes is used to cache the calculated split times and each player's position in the race. this will only need updating once any player crosses a new checkpoint.
* ms_records stores the absolute race time for each player, for each checkpoint, for each lap
ms_records is a flat array but it really stores a 3d array like this:
| | c0
| lap0 | c1
player0 | | c2
| | c0
| lap1 | c1
| | c2
| | c0
| lap0 | c1
player1 | | c2
| | c0
| lap1 | c1
| | c2
...
It only stores the race time at each checkpoint as an s32 (c0 - cn).
*/
atArray<s32> CRaceTimes::ms_records;
atArray<CRaceTimes::sSplitTime> CRaceTimes::ms_splitTimes;
atArray<CRaceTimes::sPlayer> CRaceTimes::ms_players;
s32 CRaceTimes::ms_numCheckPoints = 0;
s32 CRaceTimes::ms_numLaps = 0;
s32 CRaceTimes::ms_numPlayers = 0;
s32 CRaceTimes::ms_lastLocalCheckpoint = -1;
s32 CRaceTimes::ms_localPlayerIndex = -1;
bool CRaceTimes::ms_modified = true;
#define MAX_PLAYERS_ALLOWED (32)
void CRaceTimes::Init(s32 numCheckpoints, s32 numLaps, s32 numPlayers, s32 localPlayerIndex)
{
if (!Verifyf(numCheckpoints > 0, "CRaceTimes::Init: Invalid checkpoint count!"))
return;
if (!Verifyf(numPlayers > 0, "CRaceTimes::Init: Invalid player count!"))
return;
ms_records.Reset();
ms_records.Resize(numCheckpoints * numLaps * numPlayers);
ms_splitTimes.Reset();
ms_splitTimes.Resize(numPlayers);
for (s32 i = 0; i < numPlayers; ++i)
{
ms_splitTimes[i].time = 0;
ms_splitTimes[i].position = i;
}
ms_players.Reset();
ms_players.Resize(numPlayers);
ms_localPlayerIndex = localPlayerIndex;
ms_numCheckPoints = numCheckpoints;
ms_numLaps = numLaps;
ms_numPlayers = numPlayers;
ms_lastLocalCheckpoint = -1;
Displayf("[RACETIMES]: RaceTimes Init checkpoints: %d laps: %d players: %d", numCheckpoints, numLaps, numPlayers);
if (!Verifyf(ms_numPlayers <= MAX_PLAYERS_ALLOWED, "Too many players (%d) passed to CRaceTime::Init! Max allowed is %d", numPlayers, MAX_PLAYERS_ALLOWED))
ms_numPlayers = MAX_PLAYERS_ALLOWED;
}
void CRaceTimes::Shutdown()
{
Displayf("[RACETIMES]: RaceTimes shutdown!");
ms_records.Reset();
ms_splitTimes.Reset();
ms_players.Reset();
ms_numPlayers = 0;
ms_numCheckPoints = 0;
ms_numLaps = 0;
ms_lastLocalCheckpoint = -1;
ms_localPlayerIndex = -1;
}
void CRaceTimes::CheckpointHit(s32 pedIndex, s32 checkpoint, s32 lap, s32 time)
{
if (pedIndex < 0)
return;
if (!Verifyf(checkpoint >= 0 && checkpoint < ms_numCheckPoints, "Checkpoint %d out of %d passed in to CRaceTimes::CheckpointHit!", checkpoint, ms_numCheckPoints))
return;
if (!Verifyf(lap >= 0 && lap < ms_numLaps, "Lap %d out of %d passed in to CRaceTimes::CheckpointHit!", lap, ms_numLaps))
return;
s32 firstEmpty = ms_numPlayers;
s32 playerIndex = ms_numPlayers;
for (s32 i = 0; i < ms_numPlayers; ++i)
{
// store first empty index in case this ped isn't yet registered
if (firstEmpty == ms_numPlayers && ms_players[i].pedIndex == -1)
firstEmpty = i;
if (ms_players[i].pedIndex == pedIndex)
{
playerIndex = i;
break;
}
}
if (playerIndex == ms_numPlayers && firstEmpty != ms_numPlayers)
{
playerIndex = firstEmpty;
ms_players[playerIndex].pedIndex = pedIndex;
}
if (!Verifyf(playerIndex >= 0 && playerIndex < ms_numPlayers, "CRaceTimes::CheckpointHit: No empty slot found for player %d! index: %d", pedIndex, playerIndex))
return;
s32 arrayIndex = playerIndex * (ms_numCheckPoints * ms_numLaps) + lap * ms_numCheckPoints + checkpoint;
Assert(arrayIndex >= 0 && arrayIndex < ms_numCheckPoints * ms_numLaps * ms_numPlayers);
ms_players[playerIndex].lastCheckpoint = lap * ms_numCheckPoints + checkpoint;
// store local player last checkpoint in static
if (pedIndex == ms_localPlayerIndex)
ms_lastLocalCheckpoint = ms_players[playerIndex].lastCheckpoint;
Displayf("[RACETIMES]: Checkpoint Hit: player index: %d (%d)(local player: %p) checkpoint: %d lap: %d time: %d lastCheckPoint: %d", playerIndex, pedIndex, CPedFactory::GetFactory()->GetLocalPlayer(), checkpoint, lap, time, ms_players[playerIndex].lastCheckpoint);
ms_records[arrayIndex] = time;
ms_modified = true;
}
int SplitTimeCompare(const CRaceTimes::sSplitTime* a, const CRaceTimes::sSplitTime* b)
{
return a->time - b->time;
}
bool CRaceTimes::UpdateTimes()
{
// find local player's index into the record array
s32 localPlayerIndex = ms_numPlayers;
for (s32 i = 0; i < ms_numPlayers; ++i)
{
if (ms_players[i].pedIndex == ms_localPlayerIndex)
{
localPlayerIndex = i;
break;
}
}
if (!Verifyf(localPlayerIndex >= 0 && localPlayerIndex < ms_numPlayers, "CRaceTimes::GetPlayerTime: Local player %d not found in list!", ms_localPlayerIndex))
return false;
#if 1 // position isn't currently used by script so skip sorting
Assert(ms_lastLocalCheckpoint >= 0 && ms_lastLocalCheckpoint < ms_numCheckPoints * ms_numLaps);
s32 arrayStep = ms_numCheckPoints * ms_numLaps;
for (s32 i = 0; i < ms_numPlayers; ++i)
{
ms_splitTimes[i].position = i;
s32 playerCheckpoint = ms_players[i].lastCheckpoint;
// if this player is ahead of the local player, calculate the split time for the local player's last checkpoint
if (playerCheckpoint > ms_lastLocalCheckpoint)
playerCheckpoint = ms_lastLocalCheckpoint;
// if no checkpoint has been passed set the time to 0, script deals with this
if (playerCheckpoint < 0)
continue;
s32 localPlayerArrayIndex = playerCheckpoint + arrayStep * localPlayerIndex;
Assertf(playerCheckpoint < ms_numCheckPoints * ms_numLaps, "Invalid checkpoint %d for player %d (%d)", playerCheckpoint, i, ms_players[i].pedIndex);
ms_splitTimes[i].time = ms_records[playerCheckpoint + arrayStep * i] - ms_records[localPlayerArrayIndex];
}
#else
// calculate split times relative to the local player
sSplitTime backingStore[MAX_PLAYERS_ALLOWED];
atUserArray<sSplitTime> splitTimes(backingStore, MAX_PLAYERS_ALLOWED);
Assert(ms_lastLocalCheckpoint >= 0 && ms_lastLocalCheckpoint < ms_numCheckPoints * ms_numLaps);
s32 arrayStep = ms_numCheckPoints * ms_numLaps;
s32 localPlayerArrayIndex = ms_lastLocalCheckpoint + arrayStep * localPlayerIndex;
for (s32 i = 0; i < ms_numPlayers; ++i)
{
sSplitTime& newSplit = splitTimes.Append();
newSplit.time = ms_records[ms_lastLocalCheckpoint + arrayStep * i] - ms_records[localPlayerArrayIndex];
newSplit.position = i;
}
splitTimes.QSort(0, -1, SplitTimeCompare);
// store the sorted times for later use
for (s32 i = 0; i < ms_numPlayers; ++i)
{
s32 index = splitTimes[i].position;
ms_splitTimes[index].time = splitTimes[i].time;
ms_splitTimes[index].position = i;
}
#endif
ms_modified = false;
return true;
}
bool CRaceTimes::GetPlayerTime(s32 pedIndex, s32& time, s32& position)
{
time = 0;
if (pedIndex < 0)
return false;
// local player hasn't crossed the first checkpoint yet
if (ms_lastLocalCheckpoint < 0)
return true;
// find the given player's index into the record array
s32 playerIndex = ms_numPlayers;
for (s32 i = 0; i < ms_numPlayers; ++i)
{
if (ms_players[i].pedIndex == pedIndex)
{
playerIndex = i;
break;
}
}
// GetPlayerTime might be called before all players have hit the first checkpoint and we won't find them in the array
if (playerIndex < 0 || playerIndex >= ms_numPlayers)
return false;
#if 0 // we don't care about this now, we just calculate the last valid split time instead
// current player hasn't crossed the same checkpoint as the player's last one, report no time
if (ms_players[playerIndex].lastCheckpoint < ms_lastLocalCheckpoint)
return false;
#endif
// update times if needed
if (ms_modified)
if (!UpdateTimes())
return false;
time = ms_splitTimes[playerIndex].time;
position = ms_splitTimes[playerIndex].position;
Displayf("[RACETIMES]: Get Player Time: player index %d (%d) time: %d position: %d", playerIndex, pedIndex, time, position);
return true;
}
const char* MISSION_CREATOR_DATA_FILE = "common:/data/missioncreatordata";
MissionCreatorAssetData* MissionCreatorAssets::ms_data = NULL;
atArray<MissionCreatorAssets::sAssetEntry> MissionCreatorAssets::ms_assets;
s32 MissionCreatorAssets::ms_freeMemory = 0;
void MissionCreatorAssets::Init()
{
Shutdown();
PARSER.LoadObjectPtr(MISSION_CREATOR_DATA_FILE, "meta", ms_data);
Assertf(ms_data, "MissionCreatorAssets::Init: Failed to load %s", MISSION_CREATOR_DATA_FILE);
if (ms_data)
{
ms_data->memory <<= 20;
ms_freeMemory = ms_data->memory;
}
#if !__FINAL
if (PARAM_missioncreatordebug.Get())
Displayf("[MISSION_CREATOR_ASSETS]: Init %d memory available", ms_freeMemory);
#endif
}
void MissionCreatorAssets::Shutdown()
{
ms_assets.Reset();
delete ms_data;
ms_data = NULL;
ms_freeMemory = 0;
#if !__FINAL
if (PARAM_missioncreatordebug.Get())
Displayf("[MISSION_CREATOR_ASSETS]: Shutdown");
#endif
}
bool MissionCreatorAssets::HasRoomForModel(fwModelId modelId)
{
if (!ms_data)
return false;
if (modelId.IsValid())
{
// get all dependencies for this asset
strIndex backingStore[STREAMING_MAX_DEPENDENCIES];
atUserArray<strIndex> deps(backingStore, STREAMING_MAX_DEPENDENCIES);
CModelInfo::GetObjectAndDependencies(modelId, deps, gPopStreaming.GetResidentObjectList().GetElements(), gPopStreaming.GetResidentObjectList().GetCount());
// sum up the additional memory cost this new model would incur
u32 main = 0;
u32 vram = 0;
GetAdditionalModelCost(deps, main, vram);
#if !__FINAL
if (PARAM_missioncreatordebug.Get())
{
CBaseModelInfo* pModelInfo = CModelInfo::GetBaseModelInfo(modelId);
if (pModelInfo)
{
Displayf("[MISSION_CREATOR_ASSETS]: RequestingHasRoomForModel %s (cost %d) with free memory %d", pModelInfo->GetModelName(), main + vram, ms_freeMemory);
}
}
#endif
// not enough space in the budget
if ((s32)(main + vram) <= ms_freeMemory)
return true;
}
return false;
}
bool MissionCreatorAssets::AddModel(fwModelId modelId)
{
if (!ms_data)
return false;
if (modelId.IsValid())
{
// get all dependencies for this asset
strIndex backingStore[STREAMING_MAX_DEPENDENCIES];
atUserArray<strIndex> deps(backingStore, STREAMING_MAX_DEPENDENCIES);
CModelInfo::GetObjectAndDependencies(modelId, deps, gPopStreaming.GetResidentObjectList().GetElements(), gPopStreaming.GetResidentObjectList().GetCount());
// sum up the additional memory cost this new model would incur
u32 main = 0;
u32 vram = 0;
GetAdditionalModelCost(deps, main, vram);
#if !__FINAL
if (PARAM_missioncreatordebug.Get())
{
CBaseModelInfo* pModelInfo = CModelInfo::GetBaseModelInfo(modelId);
if (pModelInfo)
{
Displayf("[MISSION_CREATOR_ASSETS]: Adding %s (cost %d) with free memory %d", pModelInfo->GetModelName(), main + vram, ms_freeMemory);
}
}
#endif
#if 0 // allow script to over-allocate
// not enough space in the budget
if ((s32)(main + vram) > ms_freeMemory)
return false;
#endif
// add cost to our tracking
AddAdditionalModelCost(deps);
return true;
}
return false;
}
void MissionCreatorAssets::RemoveModel(fwModelId modelId)
{
if (!ms_data)
return;
if (modelId.IsValid())
{
// get all dependencies for this asset
strIndex backingStore[STREAMING_MAX_DEPENDENCIES];
atUserArray<strIndex> deps(backingStore, STREAMING_MAX_DEPENDENCIES);
CModelInfo::GetObjectAndDependencies(modelId, deps, gPopStreaming.GetResidentObjectList().GetElements(), gPopStreaming.GetResidentObjectList().GetCount());
// remove cost from our tracking
RemoveAdditionalModelCost(deps);
#if !__FINAL
if (PARAM_missioncreatordebug.Get())
{
CBaseModelInfo* pModelInfo = CModelInfo::GetBaseModelInfo(modelId);
if (pModelInfo)
{
Displayf("[MISSION_CREATOR_ASSETS]: Removing %s", pModelInfo->GetModelName());
}
}
#endif
}
}
float MissionCreatorAssets::GetUsedBudget()
{
if (!ms_data)
return 0.f;
float budget = (ms_data->memory > 0) ? (1.0f - ((float)ms_freeMemory / ms_data->memory)) : 0.0f;
#if !__FINAL
if (PARAM_missioncreatordebug.Get())
Displayf("[MISSION_CREATOR_ASSETS]: Budget requested %f", budget);
#endif
return budget;
}
void MissionCreatorAssets::GetAdditionalModelCost(const atUserArray<strIndex>& deps, u32& main, u32& vram)
{
for (s32 i = 0; i < deps.GetCount(); ++i)
{
bool found = false;
for (s32 f = 0; f < ms_assets.GetCount(); ++f)
{
if (ms_assets[f].refCount > 0 && ms_assets[f].streamIdx == deps[i])
{
found = true;
break;
}
}
// if asset is already in our tracking list, skip it
if (found)
continue;
main += (s32)strStreamingEngine::GetInfo().GetObjectVirtualSize(deps[i]);
vram += (s32)strStreamingEngine::GetInfo().GetObjectPhysicalSize(deps[i]);
}
}
void MissionCreatorAssets::AddAdditionalModelCost(const atUserArray<strIndex>& deps)
{
for (s32 i = 0; i < deps.GetCount(); ++i)
{
bool found = false;
s32 firstEmpty = -1;
for (s32 f = 0; f < ms_assets.GetCount(); ++f)
{
if (firstEmpty == -1 && ms_assets[f].refCount == 0)
firstEmpty = f;
if (ms_assets[f].refCount > 0 && ms_assets[f].streamIdx == deps[i])
{
ms_assets[f].refCount++;
found = true;
break;
}
}
// if asset is already in our tracking list, skip it
if (found)
continue;
if (firstEmpty != -1)
{
ms_assets[firstEmpty].refCount = 1;
ms_assets[firstEmpty].streamIdx = deps[i];
}
else
{
sAssetEntry newEntry;
newEntry.refCount = 1;
newEntry.streamIdx = deps[i];
ms_assets.PushAndGrow(newEntry);
}
s32 virtSize = (s32)strStreamingEngine::GetInfo().GetObjectVirtualSize(deps[i]);
s32 physSize = (s32)strStreamingEngine::GetInfo().GetObjectPhysicalSize(deps[i]);
#if __ASSERT
bool bIsMetaData = (strStreamingEngine::GetInfo().GetModuleId(deps[i]) == g_fwMetaDataStore.GetStreamingModuleId());
bool bIsDummy = strStreamingEngine::GetInfo().GetStreamingInfoRef(deps[i]).IsFlagSet(STRFLAG_INTERNAL_DUMMY);
scriptAssertf(bIsDummy || bIsMetaData || ( (virtSize + physSize) > 0), "%s, requested resource size is 0, are we getting resource size from unloaded rpf? Please load the model '%s' first.",
CTheScripts::GetCurrentScriptNameAndProgramCounter(),
strStreamingEngine::GetInfo().GetObjectName(deps[i]));
#endif // __ASSERT
ms_freeMemory -= virtSize;
ms_freeMemory -= physSize;
#if 0 // allow script to over-allocate
Assertf(ms_freeMemory >= 0, "MissionCreatorAssets::AddAdditionalModelCost: Memory tracking went wrong! memory %d - %d", ms_freeMemory, strStreamingEngine::GetInfo().GetObjectVirtualSize(deps[i]));
#endif
}
}
void MissionCreatorAssets::RemoveAdditionalModelCost(const atUserArray<strIndex>& deps)
{
for (s32 i = 0; i < deps.GetCount(); ++i)
{
for (s32 f = 0; f < ms_assets.GetCount(); ++f)
{
if (ms_assets[f].streamIdx == deps[i])
{
if (ms_assets[f].refCount > 0)
{
ms_assets[f].refCount--;
if (ms_assets[f].refCount == 0)
{
ms_freeMemory += (s32)strStreamingEngine::GetInfo().GetObjectVirtualSize(deps[i]);
ms_freeMemory += (s32)strStreamingEngine::GetInfo().GetObjectPhysicalSize(deps[i]);
}
}
}
}
}
Assert(ms_data);
Assertf(ms_freeMemory <= (s32)ms_data->memory, "MissionCreatorAssets::RemoveAdditionalModelCost: Memory tracking went wrong! memory %d", ms_freeMemory);
}
Reference in New Issue View Git Blame Copy Permalink