MY PRIVATE LEAKS OF GTA V AND GTA VI
Discord : https://discord.gg/2hkHuNQvhH
Telegram : https://t.me/gtaleakoff
BTC : bc1qg4xts26esh7uqyrkz3jtmpy447l6tn24f4j37c
ETH : 0x6a7A4a14A8681B59C677c95226685E9654afBAb8
#include "fwanimation/animmanager.h" #include "fwanimation/directorcomponentsyncedscene.h" #include "fwscene/stores/networkdefstore.h" #include "fwscene/stores/framefilterdictionarystore.h" #include "script/commands_task.h" #include "script/wrapper.h" #include "script/thread.h" //Game headers #include "ai/debug/system/AIDebugLogManager.h" #include "animation/AnimDefines.h" #include "animation/Move.h" #include "control/WaypointRecording.h" #include "control/replay/replay.h" #include "event/EventShocking.h" #include "event/EventWeapon.h" #include "event/ShockingEvents.h" #include "game/ModelIndices.h" #include "math/angmath.h" #include "network/NetworkInterface.h" #include "network/Events/NetworkEventTypes.h" #include "peds/PedFactory.h" #include "peds/PedHelmetComponent.h" #include "peds/PedIntelligence.h" #include "peds/Pedpopulation.h" #include "peds/PedTaskRecord.h" #include "peds/Ped.h" #include "peds/WildlifeManager.h" #include "physics/WorldProbe/worldprobe.h" #include "physics/RagdollConstraints.h" #include "pickups/Pickup.h" #include "pickups/PickupPlacement.h" #include "scene/world/GameWorld.h" #include "fwpheffects/ropemanager.h" #include "fwscene/search/SearchVolumes.h" #include "script/Handlers/GameScriptEntity.h" #include "script/Handlers/GameScriptResources.h" #include "script/Handlers/GameScriptMgr.h" #include "script/scrchannel.h" #include "script/script.h" #include "script/script_cars_and_peds.h" #include "script/script_helper.h" #include "script/ScriptTaskTypes.h" #include "script/commands_waypoint.h" #include "script/commands_entity.h" #include "streaming/streaming.h" #include "Task/Animation/TaskMoveScripted.h" #include "Task/Combat/Cover/Cover.h" #include "Task/Combat/TaskNewCombat.h" #include "Task/Combat/Cover/TaskCover.h" #include "Task/Combat/Cover/TaskSeekCover.h" #include "Task/Combat/Cover/TaskStayInCover.h" #include "Task/Combat/Subtasks/TaskDraggingToSafety.h" #include "Task/Combat/Subtasks/TaskHeliChase.h" #include "Task/Combat/Subtasks/TaskPlaneChase.h" #include "Task/Combat/Subtasks/TaskStealth.h" #include "Task/Combat/Subtasks/TaskVehicleChase.h" #include "Task/Combat/Subtasks/TaskVehicleCombat.h" #include "task/Combat/TaskCombat.h" #include "task/Combat/TaskCombatMelee.h" #include "Task/Combat/TaskDamageDeath.h" #include "Task/Combat/TaskInvestigate.h" #include "Task/Combat/TaskReact.h" #include "Task/Combat/TaskSearch.h" #include "Task/Combat/TaskSharkAttack.h" #include "Task/Combat/TaskThreatResponse.h" #include "Task/Combat/TaskWrithe.h" #include "Task/Default/AmbientAnimationManager.h" #include "Task/Default/Patrol/PatrolRoutes.h" #include "Task/Default/Patrol/TaskPatrol.h" #include "Task/Default/TaskArrest.h" #include "Task/Default/ArrestHelpers.h" #include "Task/Default/TaskChat.h" #include "Task/Default/TaskCuffed.h" #include "Task/Default/TaskPlayer.h" #include "Task/Default/TaskWander.h" #include "Task/General/TaskBasic.h" #include "Task/General/TaskGeneralSweep.h" #include "Task/General/Phone/TaskMobilePhone.h" #include "Task/Scenario/info/ScenarioInfoManager.h" #include "Task/General/TaskSecondary.h" #include "Task/Motion/Locomotion/TaskMotionPed.h" #include "Task/Movement/Climbing/TaskGoToAndClimbLadder.h" #include "Task/Movement/Climbing/TaskRappel.h" #include "Task/Movement/Jumping/TaskJump.h" #include "Task/Movement/TaskFall.h" #include "Task/Movement/TaskSlideToCoord.h" #include "Task/Movement/TaskCollisionResponse.h" #include "Task/Movement/TaskFollowWaypointRecording.h" #include "Task/Movement/TaskGoto.h" #include "Task/Movement/TaskGoToPointAiming.h" #include "Task/Movement/TaskMoveFollowEntityOffset.h" #include "Task/Movement/TaskParachute.h" #include "Task/Movement/TaskJetpack.h" #include "Task/Movement/TaskSeekEntity.h" #include "Task/Physics/TaskAnimatedAttach.h" #include "Task/Physics/TaskNM.h" #include "Task/Physics/TaskNMBindPose.h" #include "Task/Physics/TaskNMElectrocute.h" #include "Task/Physics/TaskNMDangle.h" #include "Task/Physics/TaskNMHighFall.h" #include "Task/Physics/TaskNMSlungOverShoulder.h" //#include "Task/Physics/TaskNMStumble.h" #include "Task/Response/TaskAgitated.h" #include "Task/Response/TaskConfront.h" #include "Task/Response/TaskFlee.h" #include "Task/Response/TaskGangs.h" #include "task/Response/TaskReactAndFlee.h" #include "Task/Response/TaskShockingEvents.h" #include "Task/Scenario/Info/ScenarioInfo.h" #include "Task/Scenario/ScenarioManager.h" #include "Task/Scenario/ScenarioPointManager.h" #include "Task/Scenario/Types/TaskParkedVehicleScenario.h" #include "Task/Scenario/Types/TaskUseScenario.h" #include "Task/Service/Police/TaskPolicePatrol.h" #include "Task/Service/Swat/TaskSwat.h" #include "Task/System/Task.h" #include "Task/Animation/TaskAnims.h" #include "Task/Animation/TaskScriptedAnimation.h" #include "Task/System/TaskManager.h" #include "Task/Vehicle/TaskCar.h" #include "Task/Vehicle/TaskCarAccessories.h" #include "Task/Vehicle/TaskCarUtils.h" #include "Task/Vehicle/TaskEnterVehicle.h" #include "Task/Vehicle/TaskExitVehicle.h" #include "Task/Vehicle/TaskMountAnimal.h" #include "Task/Vehicle/TaskRideTrain.h" #include "Task/Vehicle/TaskVehicleWeapon.h" #include "Task/Weapons/Gun/TaskGun.h" #include "Task/Weapons/Gun/TaskAimGunScripted.h" #include "Task/Weapons/Gun/TaskReloadGun.h" #include "Task/Weapons/Gun/Metadata/ScriptedGunTaskInfo.h" #include "Task/Weapons/Gun/Metadata/ScriptedGunTaskInfoMetadataMgr.h" #include "Task/Weapons/Gun/TaskVehicleDriveBy.h" #include "Task/Weapons/TaskBomb.h" #include "Task/Weapons/TaskProjectile.h" #include "Task/Weapons/TaskSwapWeapon.h" #include "Task/Weapons/WeaponController.h" #include "debug/DebugScene.h" #include "vehicleAi/vehicleintelligence.h" #include "vehicleAi/Task/TaskVehicleGoTo.h" #include "vehicleAi/Task/TaskVehicleGotoAutomobile.h" #include "vehicleAi/Task/TaskVehicleGoToHelicopter.h" #include "vehicleAi/Task/TaskVehicleGoToPlane.h" #include "vehicleAi/Task/TaskVehicleGoToSubmarine.h" #include "vehicleAi/Task/TaskVehicleAttack.h" #include "vehicleAi/Task/TaskVehicleBlock.h" #include "vehicleAi/Task/TaskVehicleCircle.h" #include "vehicleAi/Task/TaskVehicleCruise.h" #include "vehicleAi/Task/TaskVehicleDeadDriver.h" #include "vehicleAi/Task/TaskVehicleEscort.h" #include "vehicleAi/Task/TaskVehicleFlying.h" #include "vehicleAi/Task/TaskVehicleFollowRecording.h" #include "vehicleAi/Task/TaskVehicleGoToLongRange.h" #include "vehicleAi/Task/TaskVehicleHeliProtect.h" #include "vehicleAi/Task/TaskVehiclePark.h" #include "vehicleAi/Task/TaskVehiclePoliceBehaviour.h" #include "vehicleAi/Task/TaskVehicleTempAction.h" #include "vehicleAi/Task/TaskVehicleThreePointTurn.h" #include "vehicleAi/task/TaskVehicleAnimation.h" #include "vehicleAi/task/TaskVehiclePursue.h" #include "vehicleAi/task/TaskVehicleLandPlane.h" #include "vehicles/Metadata/VehicleEntryPointInfo.h" #include "vehicles/Planes.h" #include "Weapons/Info/WeaponInfoManager.h"
//Rage headers #include "script/wrapper.h"
SCRIPT_OPTIMISATIONS () AI_OPTIMISATIONS() AI_VEHICLE_OPTIMISATIONS()
namespace task_commands { void UpdatePedRagdollBoundsForScriptActivation(CPed* pPed) { // only need to do this if we're in the viewport, not in ragdoll already and our capsule physics isn't active if (pPed && pPed->GetIsVisibleInSomeViewportThisFrame() && !pPed->GetUsingRagdoll()) { pPed->UpdateRagdollRootTransformFromAnimatedSkel(); pPed->UpdateRagdollBoundsFromAnimatedSkel(); } }
void CommandTaskToggleDuck( int PedIndex, s32 iToggleType )
{
if (SCRIPT_VERIFY(CGameConfig::Get().AllowCrouchedMovement(), "TASK_TOGGLE_DUCK - Crouch is disabled" ))
{
CTask* pTask = rage_new CTaskCrouchToggle(iToggleType);
CScriptPeds::GivePedScriptedTask(PedIndex, pTask, SCRIPT_TASK_TOGGLE_DUCK, "TASK_TOGGLE_DUCK");
}
}
void CommandTaskPause(int PedIndex, int Time)
{
CTask* pTask=rage_new CTaskPause(Time);
CScriptPeds::GivePedScriptedTask(PedIndex, pTask, SCRIPT_TASK_PAUSE, "TASK_PAUSE");
}
void CommandTaskStandStill(int PedIndex, int StandStillTime)
{
if (SCRIPT_VERIFY((StandStillTime == -1) || (StandStillTime > 0) ,"TASK_STAND_STILL - Time must be -1 for infinite, otherwise > 0" ))
{
const int numFramesToRun = 0; // no frame limit
const bool bMakeMountStandStill = true;
const bool bEnableTimeslicing = (StandStillTime == -1);
CTask* pTask = rage_new CTaskDoNothing(StandStillTime, numFramesToRun, bMakeMountStandStill, bEnableTimeslicing);
CScriptPeds::GivePedScriptedTask(PedIndex, pTask, SCRIPT_TASK_STAND_STILL, "TASK_STAND_STILL");
}
}
void CommandTaskJump(int PedIndex, bool UNUSED_PARAM(UsePlayerLaunchForce), bool DoSuperJump, bool UseFullSuperJumpForce)
{
s32 nFlags = JF_DisableVault;
if (DoSuperJump)
nFlags |= JF_SuperJump | JF_BeastJump;
if (UseFullSuperJumpForce)
nFlags |= JF_AIUseFullForceBeastJump;
CTask* pTask=rage_new CTaskJumpVault(nFlags);
CScriptPeds::GivePedScriptedTask(PedIndex, pTask, SCRIPT_TASK_JUMP, "TASK_JUMP");
}
void CommandTaskCower(int PedIndex, int Time)
{
if (SCRIPT_VERIFY((Time == -1) || (Time > 0) ,"TASK_COWER - Time must be -1 for infinite and > 0" ))
{
CTask* pTask=rage_new CTaskCower(Time);
CScriptPeds::GivePedScriptedTask(PedIndex, pTask, SCRIPT_TASK_COWER, "TASK_COWER");
}
}
void CommandTaskHandsUp(int PedIndex, int Time, int PedToFaceIndex, int TimeToFacePed, int Flags)
{
if (SCRIPT_VERIFY((Time == -1) || (Time > 0) ,"TASK_HANDS_UP - Time must be -1 for infinite and > 0" ))
{
CPed* pPed = CTheScripts::GetEntityToModifyFromGUID<CPed>(PedToFaceIndex, CTheScripts::GUID_ASSERT_FLAGS_INCLUDE_CLONES_NO_DEAD_CHECK ^ CTheScripts::GUID_ASSERT_FLAG_ENTITY_EXISTS);
CTask* pTask=rage_new CTaskHandsUp(Time, pPed, TimeToFacePed, Flags);
CScriptPeds::GivePedScriptedTask(PedIndex, pTask, SCRIPT_TASK_HANDS_UP, "TASK_HANDS_UP");
}
}
void CommandUpdateTaskHandsUpDuration(int PedIndex, int Time)
{
CPed* pPed = CTheScripts::GetEntityToModifyFromGUID<CPed>(PedIndex);
if (pPed && pPed->GetPedIntelligence())
{
CTaskHandsUp* pTaskHandsUp = static_cast<CTaskHandsUp*>(pPed->GetPedIntelligence()->FindTaskByType(CTaskTypes::TASK_HANDS_UP));
if (SCRIPT_VERIFY (pTaskHandsUp, "UPDATE_TASK_HANDS_UP_DURATION - task is not running!"))
{
pTaskHandsUp->SetDuration(Time);
}
}
}
void CommandTaskDuck(int PedIndex, int Time)
{
if (SCRIPT_VERIFY(CGameConfig::Get().AllowCrouchedMovement(), "TASK_DUCK - Crouch is disabled" ))
{
if (SCRIPT_VERIFY((Time == -1) || (Time > 0) ,"TASK_DUCK - Time must be -1 for infinite and > 0" ))
{
CTask* pTask;
if(-1==Time)
{
pTask=rage_new CTaskCrouch(0);
}
else
{
pTask=rage_new CTaskCrouch(Time);
}
CScriptPeds::GivePedScriptedTask(PedIndex, pTask, SCRIPT_TASK_DUCK, "TASK_DUCK");
}
}
}
void ScriptPassengerTask( int iPedID, CVehicle *pVehicle, int iTime, SeatRequestType requestType, int iSeat, int UNUSED_PARAM(EnterStatus), float fMoveBlendRatio, VehicleEnterExitFlags iScriptFlags, fwMvClipSetId overrideClipsetId, const char* commandName)
{
float fTime = (float)iTime;
fTime/=1000.0f;
if( -1==iTime )
{
fTime = 0.0f;
}
else if( iTime > 0 )
{
iScriptFlags.BitSet().Set(CVehicleEnterExitFlags::WarpAfterTime);
}
// Convert the time into seconds
CTask* pTask = rage_new CTaskEnterVehicle(pVehicle, requestType, iSeat, iScriptFlags, fTime, fMoveBlendRatio, NULL, overrideClipsetId);
CScriptPeds::GivePedScriptedTask( iPedID, pTask, SCRIPT_TASK_ENTER_VEHICLE, commandName);
}
void ScriptDriverTask( int iPedID, CVehicle *pVehicle, int iTime, int UNUSED_PARAM(EnterStatus), VehicleEnterExitFlags iScriptFlags, float fMoveBlendRatio, fwMvClipSetId overrideClipsetId, const char* commandName)
{
s32 seat = pVehicle->GetDriverSeat();
float fTime = (float)iTime;
if( -1==iTime )
{
fTime = 0.0f;
}
else if( iTime >= 0 )
{
iScriptFlags.BitSet().Set(CVehicleEnterExitFlags::WarpAfterTime);
}
// Convert the time into seconds
fTime/=1000.0f;
CScriptPeds::GivePedScriptedTask( iPedID, rage_new CTaskEnterVehicle(pVehicle, SR_Specific, seat, iScriptFlags, fTime, fMoveBlendRatio, NULL, overrideClipsetId), SCRIPT_TASK_ENTER_VEHICLE, commandName);
}
void CommandTaskOpenVehicleDoor( int iPedID, int iVehicleID, int iTime, int iSeat, float fMoveBlendRatio)
{
SeatRequestType seatRequestType = SR_Specific;
s32 iSeatRequest = iSeat+1;
if( iSeat == -2 )
{
seatRequestType = SR_Any;
}
if (SCRIPT_VERIFY((iTime == -1) || (iTime > 0) ,"TASK_OPEN_VEHICLE_DOOR - Time must be -1 for infinite and > 0" ))
{
CVehicle *pVehicle = CTheScripts::GetEntityToModifyFromGUID<CVehicle>(iVehicleID, CTheScripts::GUID_ASSERT_FLAGS_INCLUDE_CLONES);
if (pVehicle)
{
VehicleEnterExitFlags vehicleFlags;
vehicleFlags.BitSet().Set(CVehicleEnterExitFlags::JustOpenDoor);
if (iSeatRequest != 0)
{
if (SCRIPT_VERIFY(iSeatRequest < pVehicle->GetSeatManager()->GetMaxSeats(), "TASK_OPEN_VEHICLE_DOOR - seat doesn't exist"))
{
ScriptPassengerTask(iPedID, pVehicle, iTime, seatRequestType, iSeatRequest, 0, fMoveBlendRatio, vehicleFlags, CLIP_SET_ID_INVALID, "TASK_OPEN_VEHICLE_DOOR");
}
}
else
{
if (SCRIPT_VERIFY (!pVehicle->GetDriver(), "TASK_OPEN_VEHICLE_DOOR - Vehicle already has a driver"))
{
ScriptDriverTask(iPedID, pVehicle, iTime, 0, vehicleFlags, fMoveBlendRatio, CLIP_SET_ID_INVALID, "TASK_OPEN_VEHICLE_DOOR");
}
}
}
}
}
void CommandTaskEnterVehicle( int iPedID, int iVehicleID, int iTime, int iSeat, float fMoveBlendRatio, const int iScriptFlags, const char* szOverrideEntryClipsetName )
{
VehicleEnterExitFlags iFlags;
CTaskVehicleFSM::SetScriptedVehicleEntryExitFlags(iFlags, iScriptFlags);
SeatRequestType seatRequestType = SR_Specific;
s32 iSeatRequest = iSeat+1;
if( iSeat == -2 )
{
seatRequestType = SR_Any;
}
if (SCRIPT_VERIFY((iTime == -1) || (iTime > 0) ,"TASK_ENTER_VEHICLE - Time must be -1 for infinite and > 0" ))
{
CVehicle *pVehicle = CTheScripts::GetEntityToModifyFromGUID<CVehicle>(iVehicleID, CTheScripts::GUID_ASSERT_FLAGS_INCLUDE_CLONES);
if (pVehicle)
{
#if __ASSERT const bool bIsTrailerLarge = MI_TRAILER_TRAILERLARGE.IsValid() && pVehicle->GetModelIndex() == MI_TRAILER_TRAILERLARGE; if (bIsTrailerLarge) { AI_LOG_WITH_ARGS("Ped with index %i is being placed into the trailerlarge from %s", iPedID, CTheScripts::GetCurrentScriptNameAndProgramCounter()); AI_LOG_STACK_TRACE(8); } #endif // __ASSERT fwMvClipSetId overrideClipsetId = CLIP_SET_ID_INVALID;
//look for an clip set with this name
if (szOverrideEntryClipsetName)
{
if (fwClipSetManager::GetClipSet(fwMvClipSetId(szOverrideEntryClipsetName)))
{
overrideClipsetId.SetFromString(szOverrideEntryClipsetName);
#if __ASSERT scriptAssertf(fwClipSetManager::IsStreamedIn_DEPRECATED(overrideClipsetId), "TASK_ENTER_VEHICLE - Clip set %s is not loaded yet:", szOverrideEntryClipsetName); #endif // __ASSERT } #if __ASSERT else { scriptAssertf(0, "Couldn't find clipset with name %s", szOverrideEntryClipsetName); } #endif // __ASSERT }
if (iSeatRequest != 0)
{
if (SCRIPT_VERIFY(iSeatRequest < pVehicle->GetSeatManager()->GetMaxSeats(), "TASK_ENTER_VEHICLE - seat doesn't exist"))
{
ScriptPassengerTask(iPedID, pVehicle, iTime, seatRequestType, iSeatRequest, 0, fMoveBlendRatio, iFlags, overrideClipsetId, "TASK_ENTER_VEHICLE");
}
}
else
{
// See if the vehicle has a driver already, if they are still running the enter vehicle task then they must be shuffling
// so discount them
CPed* pDriver = pVehicle->GetDriver();
if (pDriver && pDriver->GetPedIntelligence()->FindTaskActiveByType(CTaskTypes::TASK_ENTER_VEHICLE))
{
pDriver = NULL;
}
//driver seat
if (SCRIPT_VERIFY(!pDriver || (iFlags.BitSet().IsSet(CVehicleEnterExitFlags::JackIfOccupied)), "TASK_ENTER_VEHICLE - Vehicle already has a driver"))
{
ScriptDriverTask(iPedID, pVehicle, iTime, 0, iFlags, fMoveBlendRatio, overrideClipsetId, "TASK_ENTER_VEHICLE");
}
}
}
}
}
void CommandTaskLeaveVehicle( int iPedID, int iVehicleID, s32 iScriptFlags )
{
CVehicle *pVehicle = CTheScripts::GetEntityToModifyFromGUID<CVehicle>(iVehicleID, CTheScripts::GUID_ASSERT_FLAGS_INCLUDE_CLONES);
if (pVehicle)
{
VehicleEnterExitFlags vehicleFlags;
CTaskVehicleFSM::SetScriptedVehicleEntryExitFlags(vehicleFlags, iScriptFlags);
vehicleFlags.BitSet().Set(CVehicleEnterExitFlags::DontJackAnyone);
CTask* pTask=rage_new CTaskExitVehicle(pVehicle,vehicleFlags);
CScriptPeds::GivePedScriptedTask( iPedID, pTask, SCRIPT_TASK_LEAVE_VEHICLE, "TASK_LEAVE_VEHICLE");
}
}
void CommandTaskVehicleDriveToCoord_Intern( int iPedID, int iVehicleID, const Vector3 &VecCoors_, float CruiseSpeed, int iMode, int UNUSED_PARAM(VehicleModelHashKey), int iDrivingFlags, float TargetRadius, float StraightLineDist)
{
Vector3 VecCoors = VecCoors_;
TUNE_GROUP_BOOL(RACING_AI, RACING_actuallyGoFast, false);
TUNE_GROUP_FLOAT(RACING_AI, RACING_actuallyGoFastSpeed, 50.0f, 0.0, 100.0f, 0.1f);
if(RACING_actuallyGoFast)
{
CruiseSpeed = RACING_actuallyGoFastSpeed;
}
CTask* pTask = NULL;
CVehicle *pVehicle = NULL;
pVehicle = CTheScripts::GetEntityToModifyFromGUID<CVehicle>(iVehicleID, CTheScripts::GUID_ASSERT_FLAGS_INCLUDE_CLONES);
if (!pVehicle)
{
return;
}
if (VecCoors.z <= INVALID_MINIMUM_WORLD_Z)
{
VecCoors.z = WorldProbe::FindGroundZForCoord(TOP_SURFACE, VecCoors.x, VecCoors.y);
}
if (StraightLineDist < 0.0f)
{
StraightLineDist = sVehicleMissionParams::DEFAULT_SWITCH_TO_STRAIGHT_LINE_DIST;
}
// The old driving styles are still present in the script headers, until we remove them this will
// At least make drivingstyle reversing work.
if( iMode == 2 )
{
iDrivingFlags |= DF_DriveInReverse;
}
aiTask *pVehicleTask = CVehicleIntelligence::GetGotoTaskForVehicle(pVehicle, NULL, &VecCoors, iDrivingFlags, TargetRadius, StraightLineDist, CruiseSpeed);
pTask = rage_new CTaskControlVehicle(pVehicle, pVehicleTask );
CScriptPeds::GivePedScriptedTask( iPedID, pTask, SCRIPT_TASK_VEHICLE_DRIVE_TO_COORD, "TASK_VEHICLE_DRIVE_TO_COORD");
}
void CommandTaskVehicleDriveToCoord( int iPedID, int iVehicleID, const scrVector & scrVecCoors, float CruiseSpeed, int iMode, int VehicleModelHashKey, int iDrivingFlags, float TargetRadius, float StraightLineDist )
{
Vector3 VecCoors = Vector3 (scrVecCoors);
CommandTaskVehicleDriveToCoord_Intern( iPedID, iVehicleID, VecCoors, CruiseSpeed, iMode, VehicleModelHashKey, iDrivingFlags, TargetRadius, StraightLineDist );
}
void CommandTaskVehicleDriveToCoordLongRange(int iPedID, int iVehicleID, const scrVector & scrVecCoors, float CruiseSpeed, int iDrivingFlags, float TargetRadius)
{
Vector3 VecCoors = Vector3(scrVecCoors);
CTask* pTask = NULL;
CVehicle *pVehicle = NULL;
pVehicle = CTheScripts::GetEntityToModifyFromGUID<CVehicle>(iVehicleID, CTheScripts::GUID_ASSERT_FLAGS_INCLUDE_CLONES);
if (!pVehicle)
{
return;
}
if (VecCoors.z <= INVALID_MINIMUM_WORLD_Z)
{
VecCoors.z = WorldProbe::FindGroundZForCoord(TOP_SURFACE, VecCoors.x, VecCoors.y);
}
//aiTask *pVehicleTask = CVehicleIntelligence::GetGotoTaskForVehicle(pVehicle, NULL, &VecCoors, iDrivingFlags, TargetRadius, StraightLineDist, CruiseSpeed);
sVehicleMissionParams params;
params.SetTargetPosition(VecCoors);
params.m_iDrivingFlags = iDrivingFlags;
params.m_fTargetArriveDist = TargetRadius;
params.m_fCruiseSpeed = CruiseSpeed;
CTask* pVehicleTask = rage_new CTaskVehicleGotoLongRange(params);
pTask = rage_new CTaskControlVehicle(pVehicle, pVehicleTask );
CScriptPeds::GivePedScriptedTask( iPedID, pTask, SCRIPT_TASK_VEHICLE_DRIVE_TO_COORD_LONGRANGE, "TASK_VEHICLE_DRIVE_TO_COORD_LONGRANGE");
}
#if ENABLE_HORSE
void CommandTaskMountAnimal( int iPedID, int iMountID, int iTime, int iSeat, float fMoveBlendRatio, const int iFlags )
{
s32 iSeatRequest = iSeat+1;
if (SCRIPT_VERIFY((iTime == -1) || (iTime > 0) ,"TASK_MOUNT_ANIMAL - Time must be -1 for infinite and > 0" ))
{
// if this task is being added to a sequence, don't do a clone check on the mount
unsigned assertFlags = (iPedID == NULL_IN_SCRIPTING_LANGUAGE) ? CTheScripts::GUID_ASSERT_FLAGS_INCLUDE_CLONES : CTheScripts::GUID_ASSERT_FLAGS_ALL;
CPed *pMount = CTheScripts::GetEntityToModifyFromGUID<CPed>(iMountID, assertFlags);
if (pMount)
{
if (iSeatRequest != 0)
{
scriptAssertf(false, "Non-driver's on mounts not yet supported by TASK_MOUNT_ANIMAL");
}
else
{
VehicleEnterExitFlags vehicleFlags;
CTaskVehicleFSM::SetScriptedVehicleEntryExitFlags(vehicleFlags, iFlags);
//driver seat
if (SCRIPT_VERIFY(!pMount->GetSeatManager()->GetDriver() || vehicleFlags.BitSet().IsSet(CVehicleEnterExitFlags::JackIfOccupied), "TASK_MOUNT_ANIMAL - Mount already has a driver"))
{
s32 seat = pMount->GetPedModelInfo()->GetModelSeatInfo()->GetDriverSeat();
float fTime = (float)iTime;
if( -1==iTime )
{
fTime = 0.0f;
}
else if( iTime >= 0 )
{
vehicleFlags.BitSet().Set(CVehicleEnterExitFlags::WarpAfterTime);
}
// Convert the time into seconds
fTime/=1000.0f;
CScriptPeds::GivePedScriptedTask( iPedID, rage_new CTaskMountAnimal(pMount, SR_Specific, seat, vehicleFlags, fTime, fMoveBlendRatio), SCRIPT_TASK_MOUNT_ANIMAL, "TASK_MOUNT_ANIMAL");
}
}
}
}
}
void CommandTaskDismountAnimal( int iPedID, s32 iScriptFlags )
{
CPed *pMount = NULL;
if(iPedID != NULL_IN_SCRIPTING_LANGUAGE) {
CPed *pPed = CTheScripts::GetEntityToModifyFromGUID<CPed>(iPedID);
if (pPed)
{
pMount = pPed->GetMyMount();
if (!pMount)
{
return;
}
}
}
VehicleEnterExitFlags vehicleFlags;
CTaskVehicleFSM::SetScriptedVehicleEntryExitFlags(vehicleFlags, iScriptFlags);
vehicleFlags.BitSet().Set(CVehicleEnterExitFlags::DontJackAnyone);
CTask* pTask=rage_new CTaskDismountAnimal(vehicleFlags);
CScriptPeds::GivePedScriptedTask( iPedID, pTask, SCRIPT_TASK_DISMOUNT_ANIMAL, "TASK_DISMOUNT_ANIMAL");
}
#else
void CommandTaskMountAnimal( int UNUSED_PARAM(iPedID), int UNUSED_PARAM(iMountID), int UNUSED_PARAM(iTime), int UNUSED_PARAM(iSeat), float UNUSED_PARAM(fMoveBlendRatio), const int UNUSED_PARAM(iFlags) )
{
}
void CommandTaskDismountAnimal( int UNUSED_PARAM(iPedID), s32 UNUSED_PARAM(iScriptFlags) )
{
}
#endif
void CommandTaskVehicleDriveWander( int iPedID, int iVehicleID, float fSpeed, int iDrivingFlags )
{
CVehicle *pVehicle = NULL;
if(iVehicleID != NULL_IN_SCRIPTING_LANGUAGE)
{
pVehicle = CTheScripts::GetEntityToModifyFromGUID<CVehicle>(iVehicleID, CTheScripts::GUID_ASSERT_FLAGS_INCLUDE_CLONES);
}
if (!SCRIPT_VERIFY(pVehicle, "TASK_VEHICLE_DRIVE_WANDER needs a valid vehicle"))
{
return;
}
// cap cruise speed to the maximum
float fCruiseSpeed = rage::Min(fSpeed, CTaskVehicleMissionBase::MAX_CRUISE_SPEED);
CTask* pTask=rage_new CTaskCarDriveWander(pVehicle, iDrivingFlags, fCruiseSpeed);
CScriptPeds::GivePedScriptedTask( iPedID, pTask, SCRIPT_TASK_VEHICLE_DRIVE_WANDER, "TASK_VEHICLE_DRIVE_WANDER");
}
void CommandTaskGoStraightToCoord(int PedIndex, const scrVector &scrVecCoors, float MoveBlendRatio, int Time, const float fTargetHeading, const float fInTargetRadius)
{
if (SCRIPT_VERIFY((Time == -1) || (Time > 0) ,"TASK_GO_STRAIGHT_TO_COORD - Time must be -1 for infinite and > 0" ))
{
CTask* pTask;
Vector3 vTarget(scrVecCoors);
const float fTargetRadius = fInTargetRadius;//CTaskMoveGoToPointAndStandStill::ms_fTargetRadius;
const float fSlowDownDistance = CTaskMoveGoToPointAndStandStill::ms_fSlowDownDistance;
float fMainTaskTimer = 0.0f;
if(-1==Time)
{
pTask=rage_new CTaskMoveGoToPointAndStandStill(MoveBlendRatio,vTarget,fTargetRadius,fSlowDownDistance,false,true, fTargetHeading<DEFAULT_NAVMESH_FINAL_HEADING ? DtoR * fTargetHeading : fTargetHeading);
}
else
{
fMainTaskTimer = (float)Time/1000.0f;
if( fMainTaskTimer > 0.0f )
fMainTaskTimer += 2.0f;
int iTime = Max(CTaskComplexGoToPointAndStandStillTimed::ms_iTime, Time);
pTask=rage_new CTaskComplexGoToPointAndStandStillTimed(MoveBlendRatio,vTarget,fTargetRadius,fSlowDownDistance, iTime, true, fTargetHeading<DEFAULT_NAVMESH_FINAL_HEADING ? DtoR * fTargetHeading : fTargetHeading);
}
pTask = rage_new CTaskComplexControlMovement( pTask, NULL, CTaskComplexControlMovement::TerminateOnMovementTask, fMainTaskTimer );
CScriptPeds::GivePedScriptedTask(PedIndex, pTask, SCRIPT_TASK_GO_STRAIGHT_TO_COORD, "TASK_GO_STRAIGHT_TO_COORD");
}
}
void CommandTaskGoStraightToCoordRelativeToEntity(int PedIndex, int EntityIndex, const scrVector & scrVecCoors, float MoveBlendRatio, int Time)
{
Vector3 vLocalTarget(scrVecCoors);
const float fTargetRadius = CTaskMoveGoToPointAndStandStill::ms_fTargetRadius;
if (SCRIPT_VERIFY((Time == -1) || (Time > 0) ,"TASK_GO_STRAIGHT_TO_COORD_RELATIVE_TO_ENTITY - Time must be -1 for infinite and > 0" ))
{
const CEntity *pEntity = CTheScripts::GetEntityToQueryFromGUID<CEntity>(EntityIndex);
if (pEntity)
{
CTaskMoveGoToPointRelativeToEntityAndStandStill * pMoveTask = rage_new CTaskMoveGoToPointRelativeToEntityAndStandStill(
pEntity,
MoveBlendRatio,
vLocalTarget,
fTargetRadius,
Time
);
CTask * pTask = rage_new CTaskComplexControlMovement( pMoveTask );
CScriptPeds::GivePedScriptedTask(PedIndex, pTask, SCRIPT_TASK_GO_STRAIGHT_TO_COORD_RELATIVE_TO_ENTITY, "TASK_GO_STRAIGHT_TO_COORD_RELATIVE_TO_ENTITY");
}
}
}
void CommandTaskAchieveHeading(int PedIndex, float fHeadingDegrees, int iTime)
{
float fTime;
if(iTime < 0)
{
fTime = -1.0f;
}
else if(iTime == 0)
{
fTime = 0.0f;
}
else
{
fTime = ((float)iTime)/1000.0f;
}
const float fHeadingRadians=( DtoR * fHeadingDegrees);
CTask* pTask=rage_new CTaskMoveAchieveHeading(fHeadingRadians, CTaskMoveAchieveHeading::ms_fHeadingChangeRateFrac, CTaskMoveAchieveHeading::ms_fHeadingTolerance, fTime);
pTask = rage_new CTaskComplexControlMovement( pTask );
CScriptPeds::GivePedScriptedTask(PedIndex, pTask, SCRIPT_TASK_ACHIEVE_HEADING, "TASK_ACHIEVE_HEADING");
}
void CommandFlushRoute()
{
CTaskMoveFollowPointRoute::ms_pointRoute.Clear();
}
void CommandExtendRoute(const scrVector & scrVecCoors)
{
Vector3 vTarget(scrVecCoors);
if (CTaskMoveFollowPointRoute::ms_pointRoute.Add(vTarget) == false)
{
scriptAssertf(0, "%s:EXTEND_ROUTE - too many points in this route ", CTheScripts::GetCurrentScriptNameAndProgramCounter());
}
}
void CommandTaskFollowToOffsetOfEntity(int PedIndex, int EntityIndex, const scrVector & scrVecOffset, float MoveBlendRatio, int Time, float Radius, bool RelativeOffset)
{
Vector3 Offset(scrVecOffset);
const CPhysical* pEntity = CTheScripts::GetEntityToQueryFromGUID<CPhysical>(EntityIndex);
if (pEntity)
{
if (SCRIPT_VERIFY((Time == -1) || (Time > 0) ,"TASK_FOLLOW_TO_OFFSET_OF_PED - Time must be -1 for infinite and > 0" ))
{
CTask* pTask= rage_new CTaskComplexControlMovement(rage_new CTaskMoveFollowEntityOffset(pEntity, MoveBlendRatio, Radius, Offset, Time, RelativeOffset));
CScriptPeds::GivePedScriptedTask(PedIndex, pTask, SCRIPT_TASK_FOLLOW_TO_OFFSET_OF_ENTITY, "TASK_FOLLOW_TO_OFFSET_OF_ENTITY");
}
}
}
void CommandTaskFollowToOffsetOfPickup(int PedIndex, int PickupID, const scrVector & scrVecOffset, float MoveBlendRatio, int Time, float Radius, bool RelativeOffset)
{
if (SCRIPT_VERIFY((Time == -1) || (Time > 0) ,"TASK_FOLLOW_TO_OFFSET_OF_PICKUP - Time must be -1 for infinite and > 0" ))
{
if (scriptVerify(CTheScripts::GetCurrentGtaScriptHandler()))
{
scriptHandlerObject* pScriptHandlerObject = CTheScripts::GetCurrentGtaScriptHandler()->GetScriptObject(PickupID);
if (scriptVerifyf(pScriptHandlerObject, "%s: TASK_FOLLOW_TO_OFFSET_OF_PICKUP - failed to find script handler object for pickup ID", CTheScripts::GetCurrentScriptNameAndProgramCounter()))
{
if (scriptVerifyf(static_cast<CGameScriptHandlerObject*>(pScriptHandlerObject)->GetType() == SCRIPT_HANDLER_OBJECT_TYPE_PICKUP, "%s: TASK_FOLLOW_TO_OFFSET_OF_PICKUP - This is not a pickup id", CTheScripts::GetCurrentScriptNameAndProgramCounter()))
{
CPickupPlacement* pPlacement = static_cast<CPickupPlacement*>(pScriptHandlerObject);
if (SCRIPT_VERIFY(pPlacement,"TASK_FOLLOW_TO_OFFSET_OF_PICKUP - Pickup does not exist"))
{
if (SCRIPT_VERIFY(!pPlacement->GetIsCollected(), "TASK_FOLLOW_TO_OFFSET_OF_PICKUP - pickup has already been collected"))
{
if (SCRIPT_VERIFY(!pPlacement->GetHasPickupBeenDestroyed(), "TASK_FOLLOW_TO_OFFSET_OF_PICKUP - pickup has been destroyed"))
{
const CPickup *pPickup = pPlacement->GetPickup();
if (SCRIPT_VERIFY(pPickup, "TASK_FOLLOW_TO_OFFSET_OF_PICKUP - pickup object for this pickup placement is NULL"))
{
Vector3 Offset(scrVecOffset);
CTask* pTask= rage_new CTaskComplexControlMovement(rage_new CTaskMoveFollowEntityOffset(pPickup, MoveBlendRatio, Radius, Offset, Time, RelativeOffset));
CScriptPeds::GivePedScriptedTask(PedIndex, pTask, SCRIPT_TASK_FOLLOW_TO_OFFSET_OF_PICKUP, "TASK_FOLLOW_TO_OFFSET_OF_PICKUP");
}
}
}
}
}
}
}
}
}
void CommandTaskFollowPointRoute(int PedIndex, float MoveBlendRatio, int Mode)
{
if (SCRIPT_VERIFY (((CTaskMoveFollowPointRoute::TICKET_SINGLE==Mode) ||
(CTaskMoveFollowPointRoute::TICKET_RETURN==Mode) ||
(CTaskMoveFollowPointRoute::TICKET_SEASON==Mode) ||
(CTaskMoveFollowPointRoute::TICKET_LOOP==Mode)),
"TASK_FOLLOW_POINT_ROUTE - invalid mode"))
{
CTask* pTask=rage_new CTaskMoveFollowPointRoute(MoveBlendRatio,CTaskMoveFollowPointRoute::ms_pointRoute,Mode);
pTask = rage_new CTaskComplexControlMovement( pTask );
CScriptPeds::GivePedScriptedTask(PedIndex, pTask, SCRIPT_TASK_FOLLOW_POINT_ROUTE, "TASK_FOLLOW_POINT_ROUTE");
}
}
// Please keep this in sync with the enumeration in "commands_task.sch"
enum EGOTO_ENTITY_SCRIPT_FLAGS
{
EGOTO_ENTITY_NEVER_SLOW_FOR_PATH_LENGTH = 0x01,
};
void CommandTaskGoToEntity(int PedIndex, int EntityIndex, int Time, float SeekRadius, float MoveBlendRatio, float fSlowDownDistance, int iFlags)
{
const CEntity* pEntity = CTheScripts::GetEntityToQueryFromGUID<CEntity>(EntityIndex);
if (pEntity)
{
if (SCRIPT_VERIFY((Time == -1) || (Time > 0) ,"TASK_GOTO_ENTITY - Time must be -1 for infinite and > 0" ))
{
if (NetworkInterface::IsGameInProgress() && (!pEntity->GetIsDynamic() || !((CDynamicEntity*)pEntity)->GetNetworkObject()))
{
scriptAssertf(0, "%s:TASK_GOTO_ENTITY; the entity must be networked or this ped will not be able to migrate properly", CTheScripts::GetCurrentScriptNameAndProgramCounter());
}
CTask* pMoveTask=rage_new TTaskMoveSeekEntityStandard(pEntity, Time, TTaskMoveSeekEntityStandard::ms_iPeriod, SeekRadius);
((TTaskMoveSeekEntityStandard*)pMoveTask)->SetMoveBlendRatio(MoveBlendRatio);
// scripted seek entity, so we use larger search extents
((TTaskMoveSeekEntityStandard*)pMoveTask)->SetUseLargerSearchExtents(true);
((TTaskMoveSeekEntityStandard*)pMoveTask)->SetUseAdaptiveUpdateFreq(true);
((TTaskMoveSeekEntityStandard*)pMoveTask)->SetSlowDownDistance(fSlowDownDistance);
if((iFlags & EGOTO_ENTITY_NEVER_SLOW_FOR_PATH_LENGTH)!=0)
{
((TTaskMoveSeekEntityStandard*)pMoveTask)->SetNeverSlowDownForPathLength(true);
}
CTask* pTask = rage_new CTaskComplexControlMovement( pMoveTask );
CScriptPeds::GivePedScriptedTask(PedIndex, pTask, SCRIPT_TASK_GO_TO_ENTITY, "TASK_GOTO_ENTITY");
}
}
}
void CommandTaskSmartFleeCoord(int PedIndex, const scrVector & scrVecCoors, float SafeDistance, int Time, bool UNUSED_PARAM(bPreferPavements), bool bQuitIfOutOfRange)
{
if (SCRIPT_VERIFY((Time == -1) || (Time > 0) ,"TASK_SMART_FLEE_POINT - Time must be -1 for infinite and > 0" ))
{
if (SCRIPT_VERIFY(SafeDistance >= 0.0f ,"TASK_SMART_FLEE_POINT - SafeDistance must be >= 0.0" ))
{
Vector3 vTarget(scrVecCoors);
CTaskSmartFlee* pTask = rage_new CTaskSmartFlee(CAITarget(vTarget),SafeDistance,Time);
// scripted flee task, so we use larger search extents
pTask->SetUseLargerSearchExtents(true);
pTask->SetQuitIfOutOfRange(bQuitIfOutOfRange);
CScriptPeds::GivePedScriptedTask(PedIndex, pTask, SCRIPT_TASK_SMART_FLEE_POINT, "TASK_SMART_FLEE_POINT");
}
}
}
void CommandTaskSmartFleePed(int PedIndex, int OtherPedIndex, float SafeDistance, int Time, bool UNUSED_PARAM(bPreferPavements), bool UNUSED_PARAM(bUpdateToNearestHatedPed))
{
if (SCRIPT_VERIFY((Time == -1) || (Time > 0) ,"TASK_SMART_FLEE_PED - Time must be -1 for infinite and > 0" ))
{
if (SCRIPT_VERIFY(SafeDistance >= 0.0f ,"TASK_SMART_FLEE_PED - SafeDistance must be >= 0.0" ))
{
const CPed* pOtherPed = CTheScripts::GetEntityToQueryFromGUID<CPed>(OtherPedIndex);
if (pOtherPed)
{
CTaskSmartFlee* pTask = rage_new CTaskSmartFlee(CAITarget(pOtherPed), // Target to flee from
SafeDistance, // Distance to stop at
Time, // Time to flee for
CTaskSmartFlee::ms_uiEntityPosCheckPeriod,
0.0f, /*CTaskSmartFlee::ms_fEntityPosChangeThreshold*/
false);
// scripted flee task, so we use larger search extents
pTask->SetUseLargerSearchExtents(true);
pTask->SetConsiderRunStartForPathLookAhead(true);
CScriptPeds::GivePedScriptedTask(PedIndex, pTask, SCRIPT_TASK_SMART_FLEE_PED, "TASK_SMART_FLEE_PED");
}
}
}
}
void CommandTaskReactAndFleeCoord(int PedIndex, const scrVector & scrVecCoors)
{
Vector3 vTarget(scrVecCoors);
CTaskReactAndFlee* pTask = rage_new CTaskReactAndFlee(CAITarget(vTarget), CTaskReactAndFlee::BA_Gunfire);
CScriptPeds::GivePedScriptedTask(PedIndex, pTask, SCRIPT_TASK_REACT_AND_FLEE_COORD, "TASK_REACT_AND_FLEE_COORD");
}
void CommandTaskReactAndFleePed(int PedIndex, int OtherPedIndex)
{
const CPed* pOtherPed = CTheScripts::GetEntityToQueryFromGUID<CPed>(OtherPedIndex);
if(pOtherPed)
{
CTaskReactAndFlee* pTask = rage_new CTaskReactAndFlee(CAITarget(pOtherPed), CTaskReactAndFlee::BA_Gunfire);
CScriptPeds::GivePedScriptedTask(PedIndex, pTask, SCRIPT_TASK_REACT_AND_FLEE_PED, "TASK_REACT_AND_FLEE_PED");
}
}
CEventShocking* GetShockingEventFromIDInternal(int EventIndex)
{
CEventGroupGlobal& global = *GetEventGlobalGroup();
int num = global.GetNumEvents();
for(int j = 0; j < num; j++)
{
fwEvent* ev = global.GetEventByIndex(j);
if(!ev || !static_cast<CEvent*>(ev)->IsShockingEvent())
{
continue;
}
CEventShocking* pShocking = static_cast<CEventShocking*>(ev);
// Check if we've found the event we're looking for.
// Note: GetCreatedByScript() is here in case a script-created event timed out by itself,
// and then a code-created one reused the same ID (which would require a wraparound, so it's
// unlikely anyway). Since there are currently no commands to give scripts the ID numbers
// of code-created shocking events, the only valid use of this command is for script-created
// events.
if(EventIndex == (int)pShocking->GetId() && pShocking->GetCreatedByScript())
{
return pShocking;
}
}
return NULL;
}
void CommandTaskShockingEventBackAway(int PedIndex, int EventIndex)
{
CEventShocking* pEvent = GetShockingEventFromIDInternal(EventIndex);
if (SCRIPT_VERIFY(pEvent, "Invalid event specified to react to!"))
{
const CPed* pPed = CTheScripts::GetEntityToQueryFromGUID<CPed>(PedIndex);
if (SCRIPT_VERIFY(pPed, "Invalid PedIndex!"))
{
CTask* pTask = rage_new CTaskShockingEventBackAway(pEvent, CTaskShockingEventBackAway::GetDefaultBackAwayPositionForPed(*pPed));
CScriptPeds::GivePedScriptedTask(PedIndex, pTask, SCRIPT_TASK_SHOCKING_EVENT_BACK_AWAY, "TASK_SHOCKING_EVENT_BACK_AWAY");
}
}
}
void CommandTaskShockingEventHurryAway(int PedIndex, int EventIndex)
{
CEventShocking* pEvent = GetShockingEventFromIDInternal(EventIndex);
if (SCRIPT_VERIFY(pEvent, "Invalid event specified to react to!"))
{
CTask* pTask = rage_new CTaskShockingEventHurryAway(pEvent);
CScriptPeds::GivePedScriptedTask(PedIndex, pTask, SCRIPT_TASK_SHOCKING_EVENT_HURRY_AWAY, "TASK_SHOCKING_EVENT_HURRY_AWAY");
}
}
void CommandTaskShockingEventReact(int PedIndex, int EventIndex)
{
CEventShocking* pEvent = GetShockingEventFromIDInternal(EventIndex);
if (SCRIPT_VERIFY(pEvent, "Invalid event specified to react to!"))
{
CTask* pTask = rage_new CTaskShockingEventReact(pEvent);
CScriptPeds::GivePedScriptedTask(PedIndex, pTask, SCRIPT_TASK_SHOCKING_EVENT_REACT, "TASK_SHOCKING_EVENT_REACT");
}
}
void CommandTaskWanderInArea(int PedIndex, const scrVector & scvCenter, float fRadius, float fMinWaitTime, float fMaxWaitTime)
{
if (SCRIPT_VERIFY(fMinWaitTime <= fMaxWaitTime, "MinWaitTime was greater than MaxWaitTime"))
{
Vec3V vCenter(scvCenter);
CTask* pTask = rage_new CTaskWanderInArea(MOVEBLENDRATIO_WALK, fRadius, VEC3V_TO_VECTOR3(vCenter), fMinWaitTime, fMaxWaitTime);
CScriptPeds::GivePedScriptedTask(PedIndex, pTask, SCRIPT_TASK_WANDER_IN_AREA, "TASK_WANDER_IN_AREA");
}
}
void CommandTaskWanderStandard(int PedIndex, float fHeading, int iFlags)
{
float fWanderHeading = (IsClose(fHeading, DEFAULT_NAVMESH_FINAL_HEADING, 0.1f) ? fwRandom::GetRandomNumberInRange(0.0f, TWO_PI) : fHeading* DtoR);
CTaskWander * pTask = rage_new CTaskWander(MOVEBLENDRATIO_WALK, fWanderHeading);
if((iFlags & EWDR_KEEP_MOVING_WHILST_WAITING_FOR_PATH)!=0)
{
pTask->KeepMovingWhilstWaitingForFirstPath(NULL);
}
CScriptPeds::GivePedScriptedTask(PedIndex, pTask, SCRIPT_TASK_WANDER_STANDARD, "TASK_WANDER_STANDARD");
}
void CommandTaskWanderSpecific(int PedIndex, const char* CondtionalAnimGroupStr, const char* ConditonalAnimStr, float fHeading)
{
// Find the conditionalAnimsGroup
const CConditionalAnimsGroup* pConditionalAnimGroup = CONDITIONALANIMSMGR.GetConditionalAnimsGroup(atHashString(CondtionalAnimGroupStr));
if (scriptVerifyf(pConditionalAnimGroup, "TASK_WANDER_SPECIFIC called with invalid ConditionalAnimGroup name, (%s)", CondtionalAnimGroupStr))
{
// Search for the specified conditionalAnim
atHashString conditionalAnimHash(ConditonalAnimStr);
for (int scan = 0; scan < pConditionalAnimGroup->GetNumAnims(); ++scan)
{
const CConditionalAnims* pAnims = pConditionalAnimGroup->GetAnims(scan);
if (pAnims && pAnims->GetNameHash() == conditionalAnimHash)
{
float fWanderHeading = (IsClose(fHeading, DEFAULT_NAVMESH_FINAL_HEADING, 0.1f) ? fwRandom::GetRandomNumberInRange(0.0f, TWO_PI) : fHeading* DtoR);
CTask* pTask = rage_new CTaskWander(MOVEBLENDRATIO_WALK, fWanderHeading, pConditionalAnimGroup, scan);
CScriptPeds::GivePedScriptedTask(PedIndex, pTask, SCRIPT_TASK_WANDER_SPECIFIC, "TASK_WANDER_SPECIFIC");
return;
}
}
// If you get here, we failed to find the specified conditional anim.
scriptAssertf(0, "TASK_WANDER_SPECIFIC could not find ConditionalAnim name (%s) in ConditionalAnimGroup (%s)", ConditonalAnimStr, CondtionalAnimGroupStr);
}
}
void CommandTaskCombat( int iPedID, int iOtherPedID, const int iCombatFlags, const int iThreatResponseFlags )
{
// NULL peds are valid since this task can run in a sequence
const CPed *pPed = NULL;
if(iPedID != NULL_IN_SCRIPTING_LANGUAGE)
pPed = CTheScripts::GetEntityToModifyFromGUID<CPed>(iPedID);
const CPed *pSecondPed = CTheScripts::GetEntityToQueryFromGUID<CPed>(iOtherPedID);
if (pSecondPed)
{
SCRIPT_ASSERT((!pPed || !pPed->GetPedIntelligence()->IsFriendlyWith(*pSecondPed)), "TASK_COMBAT_PED - Ped told to attack friendly ped!");
SCRIPT_ASSERT(!pSecondPed->GetPedResetFlag(CPED_RESET_FLAG_CannotBeTargeted), "TASK_COMBAT_PED - Ped told to attack ped with flag PRF_CannotBeTargetedByAI!");
CTaskThreatResponse* pTask= rage_new CTaskThreatResponse(pSecondPed);
pTask->GetConfigFlags().SetAllFlags((u8)iThreatResponseFlags);
pTask->GetConfigFlagsForCombat().SetAllFlags(iCombatFlags);
CScriptPeds::GivePedScriptedTask(iPedID, pTask, SCRIPT_TASK_COMBAT, "TASK_COMBAT_PED");
}
}
void CommandTaskCombatHatedTargetsInArea( int PedIndex, const scrVector & scvCentre, float Radius, const int iCombatFlags )
{
if(NetworkInterface::IsGameInProgress())
{
SCRIPT_ASSERT(Radius < CClonedCombatClosestTargetInAreaInfo::MAX_AREA, "Radius is greater than max allowed (300.0m)");
Radius = rage::Clamp( Radius, 0.0f, CClonedCombatClosestTargetInAreaInfo::MAX_AREA );
}
Vector3 vCentre = scvCentre;
CTask* pTask=rage_new CTaskCombatClosestTargetInArea(vCentre,Radius, false, CTaskCombatClosestTargetInArea::INVALID_OVERALL_TIME, iCombatFlags);
CScriptPeds::GivePedScriptedTask( PedIndex, pTask, SCRIPT_TASK_COMBAT_HATED_TARGETS_IN_AREA, "TASK_COMBAT_HATED_PED_IN_AREA" );
}
void CommandTaskCombatHatedTargetsAroundPed( int PedIndex, float Radius, const int iCombatFlags )
{
if(NetworkInterface::IsGameInProgress())
{
SCRIPT_ASSERT(Radius < CClonedCombatClosestTargetInAreaInfo::MAX_AREA, "Radius is greater than max allowed (300.0m)");
Radius = rage::Clamp( Radius, 0.0f, CClonedCombatClosestTargetInAreaInfo::MAX_AREA );
}
CTask* pTask=rage_new CTaskCombatClosestTargetInArea(Vector3(0.0f, 0.0f, 0.0f),Radius, true, CTaskCombatClosestTargetInArea::INVALID_OVERALL_TIME, iCombatFlags);
CScriptPeds::GivePedScriptedTask( PedIndex, pTask, SCRIPT_TASK_COMBAT_HATED_TARGETS_AROUND_PED, "TASK_COMBAT_HATED_TARGETS_AROUND_PED" );
}
void CommandTaskCombatHatedTargetsAroundPedTimed( int PedIndex, float Radius, int iTime, const int iCombatFlags )
{
if(NetworkInterface::IsGameInProgress())
{
SCRIPT_ASSERT(Radius < CClonedCombatClosestTargetInAreaInfo::MAX_AREA, "Radius is greater than max allowed (300.0m)");
Radius = rage::Clamp( Radius, 0.0f, CClonedCombatClosestTargetInAreaInfo::MAX_AREA );
}
float fTime = ((float) iTime) / 1000.0f ;
CTask* pTask=rage_new CTaskCombatClosestTargetInArea(Vector3(0.0f, 0.0f, 0.0f),Radius, true, fTime, iCombatFlags );
CScriptPeds::GivePedScriptedTask( PedIndex, pTask, SCRIPT_TASK_COMBAT_HATED_TARGETS_AROUND_PED_TIMED, "TASK_COMBAT_HATED_TARGETS_AROUND_PED_TIMED" );
}
void CommandTaskCombatTimed( int PedIndex, int iOtherPedID, s32 iTime, const int iFlags )
{
CPed *pSecondPed = CTheScripts::GetEntityToModifyFromGUID<CPed>(iOtherPedID);
if (pSecondPed)
{
if(NULL_IN_SCRIPTING_LANGUAGE!=PedIndex)
{
const CPed *pPed = CTheScripts::GetEntityToQueryFromGUID<CPed>(PedIndex);
if( pPed )
{
if(!SCRIPT_VERIFY(!pPed->GetPedIntelligence()->IsFriendlyWith(*pSecondPed), "TASK_COMBAT_TIMED - Ped told to attack friendly ped!"))
return;
}
}
float fTime = ((float) iTime) / 1000.0f ;
CTaskThreatResponse* pTask=rage_new CTaskThreatResponse(pSecondPed, fTime);
pTask->GetConfigFlags().SetFlag(CTaskThreatResponse::CF_CanFightArmedPedsWhenNotArmed);
pTask->GetConfigFlagsForCombat().SetAllFlags(iFlags);
CScriptPeds::GivePedScriptedTask( PedIndex, pTask, SCRIPT_TASK_COMBAT_TIMED, "TASK_COMBAT_TIMED" );
}
}
void CommandTaskThrowProjectile( int PedIndex, const scrVector & scrVecTarget, int IgnoreCollisionEntityIndex, bool CreateInvincibleProjectile)
{
CEntity* pIgnoreCollisionEntity = NULL;
if (IgnoreCollisionEntityIndex != NULL_IN_SCRIPTING_LANGUAGE)
{
pIgnoreCollisionEntity = CTheScripts::GetEntityToModifyFromGUID<CEntity>(IgnoreCollisionEntityIndex, CTheScripts::GUID_ASSERT_FLAGS_INCLUDE_CLONES_NO_DEAD_CHECK);
#if __BANK if (!pIgnoreCollisionEntity) { scriptAssertf(0,"TASK_THROW_PROJECTILE - IgnoreCollisionEntityIndex is not null (%i), but could not find the entity in the world!", IgnoreCollisionEntityIndex); } #endif }
// Create vectors needed for getting the start position, trajectory, velocity.
CTaskAimAndThrowProjectile* pTask = rage_new CTaskAimAndThrowProjectile( CWeaponTarget( scrVecTarget ), pIgnoreCollisionEntity, CreateInvincibleProjectile );
CScriptPeds::GivePedScriptedTask(PedIndex, pTask, SCRIPT_TASK_THROW_PROJECTILE, "TASK_THROW_PROJECTILE");
}
//*************************************************************************************************************************
CTaskMoveFollowNavMesh * CreateNavigateTask(const int iPedIndex, const Vector3 &vTarget, const float fMoveBlendRatio, int iTime, const float fTargetRadius, const float fTargetHeading = DEFAULT_NAVMESH_FINAL_HEADING)
{
//*************************************************************
// Assert that scripters aren't trying to do "crazy shit"(tm)
if(iPedIndex != NULL_IN_SCRIPTING_LANGUAGE)
{
CPed * pPed = CTheScripts::GetEntityToModifyFromGUID<CPed>(iPedIndex, CTheScripts::GUID_ASSERT_FLAGS_INCLUDE_CLONES);
if (!pPed)
return NULL;
}
//********************************
// Sanity-check for comedy values
ASSERT_ONLY(static const float fStupidlyLargeValue = 10000.0f);
scriptAssertf(rage::FPIsFinite(vTarget.x) && rage::FPIsFinite(vTarget.y) && rage::FPIsFinite(vTarget.z), "script \'%s\'\nNAVIGATE_TO_COORD - Ped %i's target (%.2f, %.2f, %.2f) is duff.", CTheScripts::GetCurrentScriptNameAndProgramCounter(), iPedIndex, vTarget.x, vTarget.y, vTarget.z);
scriptAssertf((vTarget.x > -fStupidlyLargeValue && vTarget.y > -fStupidlyLargeValue && vTarget.z > -fStupidlyLargeValue && vTarget.x < fStupidlyLargeValue && vTarget.y < fStupidlyLargeValue && vTarget.z < fStupidlyLargeValue), "script \'%s\'\nNAVIGATE_TO_COORD - Ped %i's target (%.2f, %.2f, %.2f) is outside of the world.", CTheScripts::GetCurrentScriptNameAndProgramCounter(), iPedIndex, vTarget.x, vTarget.y, vTarget.z);
//***************************************************************
// Translate iTime into a value meaningful to the navmesh task
//-1 is assumed as to be infinite -2, will assert legacy used to be infinite
//*********************************************************
// Create the CTaskMoveFollowNavMesh task
// Set up the task according to the passed-in parameters
CTaskMoveFollowNavMesh* pTaskFollowNavMesh = rage_new CTaskMoveFollowNavMesh(
fMoveBlendRatio,
vTarget,
fTargetRadius,
CTaskMoveFollowNavMesh::ms_fSlowDownDistance,
iTime,
true,
false,
NULL,
fTargetRadius);
//***********************************************
// This is always set for scripted navmesh tasks
pTaskFollowNavMesh->SetIsScriptedRoute(true);
pTaskFollowNavMesh->SetTargetStopHeading(fTargetHeading);
return pTaskFollowNavMesh;
}
void CommandTaskFollowNavMeshToCoord(const int iPedIndex, const scrVector & vScrTarget, const float fMoveBlendRatio, const int iTime, const float fTargetRadius, const int iFlags, const float fTargetHeading)
{
Assertf(fMoveBlendRatio >= MOVEBLENDRATIO_STILL && fMoveBlendRatio <= MOVEBLENDRATIO_SPRINT, "Invalid 'fMoveBlendRatio' specified in TASK_FOLLOW_NAVMESH_TO_COORD. Must be in range (%.1f to %.1f) inclusive. You've passed in %.1f", MOVEBLENDRATIO_STILL, MOVEBLENDRATIO_SPRINT, fMoveBlendRatio);
CTaskMoveFollowNavMesh * pTaskFollowNavMesh = CreateNavigateTask(iPedIndex, vScrTarget, fMoveBlendRatio, iTime, fTargetRadius, fTargetHeading<DEFAULT_NAVMESH_FINAL_HEADING ? DtoR * fTargetHeading : fTargetHeading);
if (iTime < -1)
{
scriptAssertf(0, "%s:TASK_FOLLOW_NAVMESH_TO_COORD - Time must be -1 for infinite ", CTheScripts::GetCurrentScriptNameAndProgramCounter());
return;
}
else if (iTime == 0)
{
scriptAssertf(0, "%s:TASK_FOLLOW_NAVMESH_TO_COORD - You cannot give a task 0 time", CTheScripts::GetCurrentScriptNameAndProgramCounter());
return;
}
if(!pTaskFollowNavMesh)
return;
#if __ASSERT if (fTargetHeading<DEFAULT_NAVMESH_FINAL_HEADING && ((iFlags & ENAV_SUPPRESS_EXACT_STOP)!=0)) { Assertf(false, "You cannot specify 'ENAV_SUPPRESS_EXACT_STOP' and have a target-heading"); } #endif
pTaskFollowNavMesh->SetScriptBehaviourFlags(iFlags, NULL);
//*****************************************************************************************************
// The 'fMainTaskTimer' value is used to warp the ped via the parent CTaskComplexControlMovement task
float fMainTaskTimer = ((float)iTime)/1000.0f;
if(fMainTaskTimer > 0.0f)
fMainTaskTimer += 2.0f;
//**********************************************************************************
// Now wrap the task in the CTaskComplexControlMovement parent, and give to the ped
CTask * pTask = rage_new CTaskComplexControlMovement( pTaskFollowNavMesh, NULL, CTaskComplexControlMovement::TerminateOnMovementTask, fMainTaskTimer );
CScriptPeds::GivePedScriptedTask(iPedIndex, pTask, SCRIPT_TASK_FOLLOW_NAV_MESH_TO_COORD, "TASK_FOLLOW_NAVMESH_TO_COORD");
}
void CommandTaskFollowNavMeshToCoordAdvanced(const int iPedIndex, const Vector3 &vTarget, const float fMoveBlendRatio, const int iTime, const float fTargetRadius, const int iFlags, TNavMeshScriptStruct * pNavData, const float fTargetHeading )
{
Assertf(fMoveBlendRatio >= MOVEBLENDRATIO_STILL && fMoveBlendRatio <= MOVEBLENDRATIO_SPRINT, "Invalid 'fMoveBlendRatio' specified in TASK_FOLLOW_NAVMESH_TO_COORD_ADVANCED. Must be in range (%.1f to %.1f) inclusive. You've passed in %.1f", MOVEBLENDRATIO_STILL, MOVEBLENDRATIO_SPRINT, fMoveBlendRatio);
//********************
// Create the task
if (iTime < -1)
{
scriptAssertf(0, "%s:TASK_FOLLOW_NAVMESH_TO_COORD_ADVANCED - Time must be -1 for infinite ", CTheScripts::GetCurrentScriptNameAndProgramCounter());
return;
}
else if (iTime == 0)
{
scriptAssertf(0, "%s:TASK_FOLLOW_NAVMESH_TO_COORD_ADVANCED - You cannot give a task 0 time", CTheScripts::GetCurrentScriptNameAndProgramCounter());
return;
}
CTaskMoveFollowNavMesh * pTaskFollowNavMesh = CreateNavigateTask(iPedIndex, vTarget, fMoveBlendRatio, iTime, fTargetRadius, fTargetHeading<DEFAULT_NAVMESH_FINAL_HEADING ? DtoR * fTargetHeading: fTargetHeading);
if(!pTaskFollowNavMesh)
return;
pTaskFollowNavMesh->SetScriptBehaviourFlags(iFlags, pNavData);
//*****************************************************************************************************
// The 'fMainTaskTimer' value is used to warp the ped via the parent CTaskComplexControlMovement task
float fMainTaskTimer = ((float)iTime)/1000.0f;
if(fMainTaskTimer > 0.0f)
fMainTaskTimer += 2.0f;
//**********************************************************************************
// Now wrap the task in the CTaskComplexControlMovement parent, and give to the ped
CTask * pTask = rage_new CTaskComplexControlMovement( pTaskFollowNavMesh, NULL, CTaskComplexControlMovement::TerminateOnMovementTask, fMainTaskTimer);
CScriptPeds::GivePedScriptedTask(iPedIndex, pTask, SCRIPT_TASK_FOLLOW_NAVMESH_TO_COORD_ADVANCED, "TASK_FOLLOW_NAVMESH_TO_COORD_ADVANCED");
}
//***********************************************************
// CommandTaskNavigateToCoordAdvanced - parameter list:
//
// int iPedIndex
// const scrVector & vScrTarget
// float fMoveBlendRatio
// int iTime
// float fTargetRadius
// int iFlags
// TNavMeshScriptStruct navStruct
//
void CommandTaskFollowNavMeshToCoordAdvanced_ScrStruct(scrThread::Info & info)
{
//**********************************************************************
// Extract the parameters from the scrThread::Info structure. This
// is necessary as the way of passing structures into script functions
ASSERT_ONLY(static const int iNumParams = 12);
scriptAssertf(info.ParamCount == iNumParams, "script \'%s\'\nTASK_FOLLOW_NAV_MESH_TO_COORD_ADVANCED - You have passed in the wrong num arguments (%i instead of %i)", CTheScripts::GetCurrentScriptNameAndProgramCounter(), info.ParamCount, iNumParams);
// Get the ped index
const int iPedIndex = info.Params[0].Int;
// Get the target position
//const float * pFloat = &info.Params[1].Reference->Float;
const Vector3 vTarget(info.Params[1].Float, info.Params[2].Float, info.Params[3].Float);
// Get the move blend ratio
const float fMoveBlendRatio = info.Params[4].Float;
// Get the time
int iTime = info.Params[5].Int;
// Get the target radius
const float fTargetRadius = info.Params[6].Float;
// Get the bit-flags
const int iFlags = info.Params[7].Int;
// Get the nav data structure
//void * pStructData = info.Params[6].Reference;
//TNavMeshScriptStruct * pNavStruct = (TNavMeshScriptStruct*)pStructData;
TNavMeshScriptStruct NavStruct;
NavStruct.m_fSlideToCoordHeading = info.Params[8].Float;
NavStruct.m_fMaxSlopeNavigable = info.Params[9].Float;
NavStruct.m_fClampMaxSearchDistance = info.Params[10].Float;
// Final heading
const float fTargetHeading = info.Params[11].Float;
CommandTaskFollowNavMeshToCoordAdvanced(iPedIndex, vTarget, fMoveBlendRatio, iTime, fTargetRadius, iFlags, &NavStruct, fTargetHeading);
}
// Sets the path-style for this ped, so that they will use climb-overs or not during pathfinding
void CommandSetPedPathCanUseClimbOvers(int PedIndex, bool Flag)
{
CPed * pPed = CTheScripts::GetEntityToModifyFromGUID<CPed>(PedIndex);
if (pPed)
{
CPedIntelligence * pPedAI = pPed->GetPedIntelligence();
pPedAI->GetNavCapabilities().SetFlag(CPedNavCapabilityInfo::FLAG_MAY_CLIMB, Flag);
}
}
// Sets the path-style for this ped, so that they will use ladders or not during pathfinding
void CommandSetPedPathCanUseLadders(int PedIndex, bool Flag)
{
CPed * pPed = CTheScripts::GetEntityToModifyFromGUID<CPed>(PedIndex);
if (pPed)
{
CPedIntelligence * pPedAI = pPed->GetPedIntelligence();
pPedAI->GetNavCapabilities().SetFlag(CPedNavCapabilityInfo::FLAG_MAY_USE_LADDERS, Flag);
}
}
// Sets the path-style for this ped, so that they will use high drop-downs or not during pathfinding
void CommandSetPedPathCanDropFromHeight(int PedIndex, bool Flag)
{
CPed * pPed = CTheScripts::GetEntityToModifyFromGUID<CPed>(PedIndex);
if (pPed)
{
CPedIntelligence * pPedAI = pPed->GetPedIntelligence();
pPedAI->GetNavCapabilities().SetFlag(CPedNavCapabilityInfo::FLAG_MAY_DROP, Flag);
}
}
// Sets the path-style for this ped, so designers can modify how likely it is for a ped to use a climb during navigation
void CommandSetPedPathClimbCostModifier(int PedIndex, float fModifier)
{
fModifier = Clamp(fModifier, 0.0f, 10.0f);
CPed * pPed = CTheScripts::GetEntityToModifyFromGUID<CPed>(PedIndex);
if (pPed)
{
CPedIntelligence * pPedAI = pPed->GetPedIntelligence();
pPedAI->GetNavCapabilities().SetClimbCostModifier(fModifier);
}
}
//
void CommandSetPedToMayEnterWater(int PedIndex, bool Flag)
{
CPed * pPed = CTheScripts::GetEntityToModifyFromGUID<CPed>(PedIndex);
if (pPed)
{
CPedIntelligence * pPedAI = pPed->GetPedIntelligence();
pPedAI->GetNavCapabilities().SetFlag(CPedNavCapabilityInfo::FLAG_MAY_ENTER_WATER, Flag);
}
}
// Sets the path-style for this ped, so that they will use prefer to avoid water or not during pathfinding
void CommandSetPedPreferToAvoidWater(int PedIndex, bool Flag)
{
CPed * pPed = CTheScripts::GetEntityToModifyFromGUID<CPed>(PedIndex);
if (pPed)
{
CPedIntelligence * pPedAI = pPed->GetPedIntelligence();
pPedAI->GetNavCapabilities().SetFlag(CPedNavCapabilityInfo::FLAG_PREFER_TO_AVOID_WATER, Flag);
}
}
// Sets the path-style for this ped, so that they will use prefer to avoid fire during pathfinding
void CommandSetPedPathAvoidFire(int PedIndex, bool Flag)
{
CPed * pPed = CTheScripts::GetEntityToModifyFromGUID<CPed>(PedIndex);
if (pPed)
{
CPedIntelligence * pPedAI = pPed->GetPedIntelligence();
pPedAI->GetNavCapabilities().SetFlag(CPedNavCapabilityInfo::FLAG_AVOID_FIRE, Flag);
}
}
// Needs to be called each frame or it will reset.
void CommandSetGlobalMinBirdFlightHeight(float fHeight)
{
CWildlifeManager::GetInstance().SetScriptMinBirdHeight(fHeight);
}
//****************************************************************************
// Retrieves the remaining distance to the target, if a ped is following
// a navmesh route in their primary slot. Returns enumeration value to
// indicate whether the navmesh task was found.
int CommandGetNavMeshRouteDistanceRemaining(int PedIndex, float & fOutDistanceRemaining, int & bThisIsLastRouteSection)
{
fOutDistanceRemaining = 0.0f;
bThisIsLastRouteSection = false;
const CPed * pPed = CTheScripts::GetEntityToQueryFromGUID<CPed>(PedIndex);
if(pPed)
{
CPedIntelligence * pPedAI = pPed->GetPedIntelligence();
aiTask * pTask = pPedAI->FindTaskActiveMovementByType(CTaskTypes::TASK_MOVE_FOLLOW_NAVMESH);
if(pTask)
{
CTaskMoveFollowNavMesh * pNavTask = (CTaskMoveFollowNavMesh*)pTask;
bThisIsLastRouteSection = pNavTask->GetLastRoutePointIsTarget();
if(pNavTask->IsFollowingNavMeshRoute() && !pNavTask->GetIsFleeing())
{
fOutDistanceRemaining = pNavTask->GetDistanceLeftOnCurrentRouteSection(pPed);
return NAVMESHROUTE_ROUTE_FOUND;
}
else
{
return NAVMESHROUTE_ROUTE_NOT_FOUND;
}
}
}
return NAVMESHROUTE_TASK_NOT_FOUND;
}
int CommandGetNavMeshRouteResult(int PedIndex)
{
const CPed * pPed = CTheScripts::GetEntityToQueryFromGUID<CPed>(PedIndex);
if(pPed)
{
CPedIntelligence * pPedAI = pPed->GetPedIntelligence();
// Script task priority must be active
if(pPedAI->GetTaskManager()->GetTree(PED_TASK_TREE_PRIMARY)->GetActiveTaskPriority()==PED_TASK_PRIORITY_PRIMARY)
{
// The movement task tree must be running its general movement task
if(pPedAI->GetTaskManager()->GetTree(PED_TASK_TREE_MOVEMENT)->GetActiveTaskPriority()==PED_TASK_MOVEMENT_GENERAL)
{
// A control movement task must be found
CTaskComplexControlMovement * pControlMovementTask = (CTaskComplexControlMovement*) pPedAI->FindTaskPrimaryByType(CTaskTypes::TASK_COMPLEX_CONTROL_MOVEMENT);
// The control movement must have a running movement task
if(pControlMovementTask && pControlMovementTask->GetRunningMovementTask(pPed))
{
CTaskMoveFollowNavMesh * pNavTask = (CTaskMoveFollowNavMesh*)pPedAI->GetTaskManager()->GetTree(PED_TASK_TREE_MOVEMENT)->FindTaskByTypeActive(CTaskTypes::TASK_MOVE_FOLLOW_NAVMESH);
if(pNavTask)
{
if(pNavTask->GetState()==CTaskNavBase::NavBaseState_FollowingPath)
{
return NAVMESHROUTE_ROUTE_FOUND;
}
else if(pNavTask->IsUnableToFindRoute())
{
return NAVMESHROUTE_ROUTE_NOT_FOUND;
}
else
{
return NAVMESHROUTE_ROUTE_NOT_YET_TRIED;
}
}
}
}
}
}
return NAVMESHROUTE_TASK_NOT_FOUND;
}
bool CommandIsControlledVehicleUnableToGetToRoad(int PedIndex)
{
const CPed * pPed = CTheScripts::GetEntityToQueryFromGUID<CPed>(PedIndex);
if(pPed)
{
CPedIntelligence * pPedAI = pPed->GetPedIntelligence();
// Script task priority must be active
if(pPedAI->GetTaskManager()->GetTree(PED_TASK_TREE_PRIMARY)->GetActiveTaskPriority()==PED_TASK_PRIORITY_PRIMARY)
{
// A control vehicle task must be found
CTaskControlVehicle* pControlVehicleTask = (CTaskControlVehicle*) pPedAI->FindTaskPrimaryByType(CTaskTypes::TASK_CONTROL_VEHICLE);
if(pControlVehicleTask)
{
return pControlVehicleTask->IsVehicleTaskUnableToGetToRoad();
}
}
}
return false;
}
void CommandTaskGoToCoordAnyMeans( int PedIndex, const scrVector & scrVecCoors, float fMoveBlendRatio, int iVehicleID, bool bUseLongRangeVehiclePathing, s32 iDrivingFlags, float fMaxRangeToShootTargets)
{
Vector3 vTarget(scrVecCoors);
CVehicle *pVehicle=NULL;
if(iVehicleID != NULL_IN_SCRIPTING_LANGUAGE)
{
pVehicle = CTheScripts::GetEntityToModifyFromGUID<CVehicle>(iVehicleID, CTheScripts::GUID_ASSERT_FLAGS_INCLUDE_CLONES);
if(!pVehicle)
return;
}
CTask* pTask=rage_new CTaskGoToPointAnyMeans(fMoveBlendRatio,vTarget,pVehicle, CTaskGoToPointAnyMeans::ms_fTargetRadius, -1, bUseLongRangeVehiclePathing, iDrivingFlags, fMaxRangeToShootTargets);
CScriptPeds::GivePedScriptedTask( PedIndex, pTask, SCRIPT_TASK_GO_TO_COORD_ANY_MEANS, "TASK_GO_TO_COORD_ANY_MEANS");
}
void CommandTaskGoToCoordAnyMeansExtraParams( int PedIndex, const scrVector & scrVecCoors, float fMoveBlendRatio, int iVehicleID, bool bUseLongRangeVehiclePathing, s32 iDrivingFlags, float fMaxRangeToShootTargets, float fExtraVehToTargetDistToPreferVe, float fDriveStraightLineDistance, s32 iExtraFlags, float fWarpTimerMS)
{
Vector3 vTarget(scrVecCoors);
CVehicle *pVehicle=NULL;
if(iVehicleID != NULL_IN_SCRIPTING_LANGUAGE)
{
pVehicle = CTheScripts::GetEntityToModifyFromGUID<CVehicle>(iVehicleID, CTheScripts::GUID_ASSERT_FLAGS_INCLUDE_CLONES);
if(!pVehicle)
return;
}
CTask* pTask=rage_new CTaskGoToPointAnyMeans(fMoveBlendRatio,vTarget,pVehicle, CTaskGoToPointAnyMeans::ms_fTargetRadius, -1, bUseLongRangeVehiclePathing, iDrivingFlags, fMaxRangeToShootTargets, fExtraVehToTargetDistToPreferVe, fDriveStraightLineDistance, static_cast<u16>(iExtraFlags), -1.0f, fWarpTimerMS);
CScriptPeds::GivePedScriptedTask( PedIndex, pTask, SCRIPT_TASK_GO_TO_COORD_ANY_MEANS_EXTRA_PARAMS, "SCRIPT_TASK_GO_TO_COORD_ANY_MEANS_EXTRA_PARAMS");
}
void CommandTaskGoToCoordAnyMeansExtraParamsWithCruiseSpeed( int PedIndex, const scrVector & scrVecCoors, float fMoveBlendRatio, int iVehicleID, bool bUseLongRangeVehiclePathing, s32 iDrivingFlags, float fMaxRangeToShootTargets, float fExtraVehToTargetDistToPreferVe, float fDriveStraightLineDistance, s32 iExtraFlags, float fCruiseSpeed, float fTargetArriveDist)
{
Vector3 vTarget(scrVecCoors);
CVehicle *pVehicle=NULL;
if(iVehicleID != NULL_IN_SCRIPTING_LANGUAGE)
{
pVehicle = CTheScripts::GetEntityToModifyFromGUID<CVehicle>(iVehicleID, CTheScripts::GUID_ASSERT_FLAGS_INCLUDE_CLONES);
if(!pVehicle)
return;
}
CTask* pTask=rage_new CTaskGoToPointAnyMeans(fMoveBlendRatio,vTarget,pVehicle, CTaskGoToPointAnyMeans::ms_fTargetRadius, -1, bUseLongRangeVehiclePathing, iDrivingFlags, fMaxRangeToShootTargets, fExtraVehToTargetDistToPreferVe, fDriveStraightLineDistance, static_cast<u16>(iExtraFlags), fCruiseSpeed, -1.0f, fTargetArriveDist);
CScriptPeds::GivePedScriptedTask( PedIndex, pTask, SCRIPT_TASK_GO_TO_COORD_ANY_MEANS_EXTRA_PARAMS_WITH_CRUISE_SPEED, "TASK_GO_TO_COORD_ANY_MEANS_EXTRA_PARAMS_WITH_CRUISE_SPEED");
}
#if __BANK bool VerifyDictAndAnim(atHashString dictionaryHash, atHashString animHash, const char * ASSERT_ONLY(scriptName)) { strLocalIndex dictIndex = fwAnimManager::FindSlotFromHashKey(dictionaryHash.GetHash());
if (scriptVerifyf(dictIndex.Get()>-1, "%s - The dictionary name '%s' is not recognised.", scriptName, dictionaryHash.TryGetCStr()))
{
strIndex index = strStreamingEngine::GetInfo().GetModuleMgr().GetModule(fwAnimManager::GetStreamingModuleId())->GetStreamingIndex(dictIndex);
if (scriptVerifyf(strStreamingEngine::GetInfo().GetStreamingInfo(index)->GetStatus() == STRINFO_LOADED, "%s - The dictionary '%s' is not streamed in.", scriptName, dictionaryHash.TryGetCStr()))
{
const crClip* pClip = fwAnimManager::GetClipIfExistsByDictIndex(dictIndex.Get(), animHash.GetHash());
if (scriptVerifyf(pClip, "%s - The clip '%s' does not exist in dictionary '%s'", scriptName, animHash.TryGetCStr(), dictionaryHash.TryGetCStr()))
{
return true;
}
}
}
return false;
}
#endif //__BANK
CTaskScriptedAnimation::ePlaybackPriority GetPriorityFromControlFlags(s32 nControlFlags)
{
// TODO - convert to support the new anim priority flags
CTaskScriptedAnimation::ePlaybackPriority priority = CTaskScriptedAnimation::kPriorityLow;
if (nControlFlags == AF_PRIORITY_MEDIUM)
{
priority = CTaskScriptedAnimation::kPriorityMid;
}
else if (nControlFlags == AF_PRIORITY_HIGH)
{
priority = CTaskScriptedAnimation::kPriorityHigh;
}
return priority;
}
void PlayAnimScriptCommand(int CurrCommand, int PedIndex, const char *pAnimName, const char *pAnimDictNameStr, float fBlendInDelta, float fBlendOutDelta, int nTimeToPlay, int nControlFlags, int nIkFlags, bool bAdvanced, const Vector3 &initialPosition, const Vector3 &initialOrientation, float fStartPhase, EulerAngleOrder RotationOrder, bool phaseControlled, bool bAllowOverrideCloneUpdate)
{
eScriptedAnimFlagsBitSet flags;
flags.BitSet().SetBits(nControlFlags);
if(!SCRIPT_VERIFY(pAnimName, "TASK_PLAY_ANIM - Animation name is null"))
{
return;
}
if(!SCRIPT_VERIFY(pAnimDictNameStr, "TASK_PLAY_ANIM - Animation dictionary name is null"))
{
return;
}
if (bAllowOverrideCloneUpdate && !NetworkInterface::IsGameInProgress())
{
bAllowOverrideCloneUpdate = false;
SCRIPT_ASSERT(0, "Don't expect bAllowOverrideCloneUpdate to be set true in SP. Clearing this bool.");
}
const strStreamingObjectName pAnimDictName( pAnimDictNameStr );
CPed *pPed = NULL;
if(NULL_IN_SCRIPTING_LANGUAGE!=PedIndex)
{
pPed = CTheScripts::GetEntityToModifyFromGUID<CPed>(PedIndex, CTheScripts::GUID_ASSERT_FLAGS_INCLUDE_CLONES);
if(!pPed)
{
return;
}
if(pPed->GetIsAttached())
{
SCRIPT_ASSERT(!flags.BitSet().IsSet(AF_OVERRIDE_PHYSICS), "TASK_PLAY_ANIM - Cannot use AF_OVERRIDE_PHYSICS when ped is attached!");
SCRIPT_ASSERT(!flags.BitSet().IsSet(AF_TURN_OFF_COLLISION), "TASK_PLAY_ANIM - Cannot set CTaskScriptedAnimation::AF_TURN_OFF_COLLISION when ped is attached!");
SCRIPT_ASSERT(!flags.BitSet().IsSet(AF_IGNORE_GRAVITY), "TASK_PLAY_ANIM - Cannot set CTaskScriptedAnimation::AF_IGNORE_GRAVITY when ped is attached!");
}
}
else if(bAllowOverrideCloneUpdate)
{
SCRIPT_ASSERT(0, "In MP don't expect bAllowOverrideCloneUpdate to be set true with null PedIndex!");
return;
}
bool bPartOfASequence = (PedIndex == NULL_IN_SCRIPTING_LANGUAGE);
//scriptAssertf(strlen(pAnimName)<ANIM_NAMELEN, "%s:TASK_PLAY_ANIM - Animation name is null : %s", CTheScripts::GetCurrentScriptNameAndProgramCounter(), pAnimName);
if(!bPartOfASequence)
{
BANK_ONLY(VerifyDictAndAnim(pAnimDictName, pAnimName, "TASK_PLAY_ANIM");)
}
u32 iBoneMask = BONEMASK_ALL;
eIkControlFlagsBitSet& ikFlags = reinterpret_cast<eIkControlFlagsBitSet&>(nIkFlags);
if (flags.BitSet().IsSet(AF_UPPERBODY))
{
iBoneMask = BONEMASK_UPPERONLY;
}
// Currently, always extract the mover and the initial offset when using override physics mode
if (flags.BitSet().IsSet(AF_OVERRIDE_PHYSICS) )
{
flags.BitSet().Set(AF_USE_MOVER_EXTRACTION, true);
flags.BitSet().Set(AF_EXTRACT_INITIAL_OFFSET, true);
}
CTask* pTask;
if (nTimeToPlay<0)
nTimeToPlay = -1;
if (bAdvanced)
{
Quaternion rotationQuaternion;
CScriptEulers::QuaternionFromEulers(rotationQuaternion, initialOrientation, RotationOrder);
pTask = rage_new CTaskScriptedAnimation(pAnimDictName, pAnimName, CTaskScriptedAnimation::kPriorityLow, iBoneMask, fwAnimHelpers::CalcBlendDuration(fBlendInDelta), fwAnimHelpers::CalcBlendDuration(fBlendOutDelta), nTimeToPlay, flags, fStartPhase, initialPosition, rotationQuaternion, false, phaseControlled, ikFlags, bAllowOverrideCloneUpdate, bPartOfASequence);
}
else
{
pTask = rage_new CTaskScriptedAnimation(pAnimDictName, pAnimName, CTaskScriptedAnimation::kPriorityLow, iBoneMask, fwAnimHelpers::CalcBlendDuration(fBlendInDelta), fwAnimHelpers::CalcBlendDuration(fBlendOutDelta), nTimeToPlay, flags, fStartPhase, false, phaseControlled, ikFlags, bAllowOverrideCloneUpdate, bPartOfASequence);
}
#if !__FINAL if(NetworkInterface::IsGameInProgress()) { scriptDebugf1("PlayAnimScriptCommand PedIndex %d, pPed %s, pAnimName %s, pAnimDictNameStr %s nControlFlags 0x%x, pTask [ %p ]", PedIndex, pPed?(pPed->GetNetworkObject()?pPed->GetNetworkObject()->GetLogName():pPed->GetModelName() ):"Null pPed", pAnimName, pAnimDictNameStr, nControlFlags, pTask); } #endif
if (flags.BitSet().IsSet(AF_USE_ALTERNATIVE_FP_ANIM))
{
static const char * s_fpsClipSuffixHash = "_FP";
u32 fpsClipHash = atPartialStringHash(s_fpsClipSuffixHash, atPartialStringHash(pAnimName));
atHashString finalFpsHash(atFinalizeHash(fpsClipHash));
static_cast<CTaskScriptedAnimation*>(pTask)->SetFPSClipHash(finalFpsHash);
if(!bPartOfASequence)
{
BANK_ONLY(VerifyDictAndAnim(pAnimDictName, finalFpsHash, "TASK_PLAY_ANIM");)
}
}
if(bAllowOverrideCloneUpdate)
{
scriptAssertf( !flags.BitSet().IsSet(AF_LOOPING) && !flags.BitSet().IsSet(AF_HOLD_LAST_FRAME), "Don't support AF_LOOPING or AF_HOLD_LAST_FRAME with bAllowOverrideCloneUpdate %d",nControlFlags);
CTaskScriptedAnimation* pTaskScriptedAnimation = static_cast<CTaskScriptedAnimation*>(pTask);
if(pPed->IsNetworkClone())
{
pPed->GetPedIntelligence()->AddLocalCloneTask(pTaskScriptedAnimation, PED_TASK_PRIORITY_PRIMARY);
}
else
{
int iEventPriority = E_PRIORITY_GIVE_PED_TASK;
CEventGivePedTask event(PED_TASK_PRIORITY_PRIMARY,pTaskScriptedAnimation,false,iEventPriority);
pPed->GetPedIntelligence()->AddEvent(event);
}
return;
}
// Nb/ PedIndex == NULL_IN_SCRIPTING_LANGUAGE if the task is part of a sequence
bool bSecondary = flags.BitSet().IsSet(AF_SECONDARY);
if ( bPartOfASequence && bSecondary )
{
CTask* pTaskSecond=pTask;
pTask=rage_new CTaskAffectSecondaryBehaviour(true,PED_TASK_SECONDARY_PARTIAL_ANIM,pTaskSecond);
}
else if (bSecondary)
{
if(SCRIPT_VERIFY( !bPartOfASequence, "TASK_PLAY_ANIM_SECONDARY* Cant be used in a sequence!" ))
{
CPed * pPed = CTheScripts::GetEntityToModifyFromGUID<CPed>(PedIndex);
if(pPed)
{
pPed->GetPedIntelligence()->AddTaskSecondary( pTask, PED_TASK_SECONDARY_PARTIAL_ANIM );
}
}
return;
}
if (!bPartOfASequence && flags.BitSet().IsSet(AF_OVERRIDE_PHYSICS))
{
//force an ai update post camera so that the anim will be visible next frame (rather than waiting for the next task update)
CPed * pPed = CTheScripts::GetEntityToModifyFromGUID<CPed>(PedIndex);
if(pPed)
{
pPed->SetPedResetFlag( CPED_RESET_FLAG_ForcePostCameraAIUpdate, true );
}
}
CScriptPeds::GivePedScriptedTask(PedIndex, pTask, CurrCommand, "TASK_PLAY_ANIM");
}
CTaskScriptedAnimation* FindPrimaryScriptedAnimTask(const CPed* pPed)
{
CTaskScriptedAnimation* pTask = static_cast<CTaskScriptedAnimation*>(pPed->GetPedIntelligence()->FindTaskPrimaryByType(CTaskTypes::TASK_SCRIPTED_ANIMATION));
return pTask;
}
CTaskScriptedAnimation* FindSecondaryScriptedAnimTask(const CPed* pPed)
{
CTask* pTask = pPed->GetPedIntelligence()->GetTaskSecondaryPartialAnim();
if (pTask && pTask->GetTaskType()==CTaskTypes::TASK_SCRIPTED_ANIMATION)
{
return static_cast<CTaskScriptedAnimation*>(pTask);
}
return NULL;
}
const crClip* FindClipForScriptCommand(const char * pDictName, const char * pClipName, const char * ASSERT_ONLY(pScriptName))
{
const crClip* pClip = fwAnimManager::GetClipIfExistsByName(pDictName, pClipName);
#if __ASSERT if (!pClip) { const char * pFailReason; strLocalIndex dictIndex = strLocalIndex(fwAnimManager::FindSlot(pDictName)); if (dictIndex.Get()<0) { pFailReason = " The dictionary does not exist."; } else { fwClipDictionaryDef* pDictDef = fwAnimManager::GetSlot(dictIndex); if ( !pDictDef) { pFailReason = " The dictionary is not in the image!"; } else if (!GET_OBJECT(pDictDef)) { pFailReason = " The dictionary is not streamed in."; } else { pFailReason = " The clip is not in the dictionary"; } } animAssertf (pClip, "(%s) Unable to retrieve clip '%s' from dictionary '%s'.%s", pScriptName, pClipName, pDictName, pFailReason); } #endif // __ASSERT return pClip; }
void CommandTaskPlayAnim(int PedIndex, const char *pAnimDictName, const char *pAnimName, float fBlendInDelta, float fBlendOutDelta, int nTimeToPlay, int nFlags, float startPhase, bool phaseControlled, int ikFlags, bool bAllowOverrideCloneUpdate)
{
if (SCRIPT_VERIFY((nTimeToPlay == -1) || (nTimeToPlay > 0) ,"TASK_PLAY_ANIM - Time must be -1 for infinite or > 0" ))
{
PlayAnimScriptCommand(SCRIPT_TASK_PLAY_ANIM, PedIndex, pAnimName, pAnimDictName, fBlendInDelta, fBlendOutDelta, nTimeToPlay, nFlags, ikFlags, false, VEC3_ZERO, VEC3_ZERO, startPhase, EULER_YXZ, phaseControlled, bAllowOverrideCloneUpdate);
}
}
#if __BANK void VerifySlotData(CTaskScriptedAnimation::ScriptInitSlotData* pData) { if (pData) { switch(pData->state.Int) { case CTaskScriptedAnimation::kStateSingleClip: { VerifyDictAndAnim(scrDecodeString(pData->dict0.String), scrDecodeString(pData->clip0.String), "TASK_SCRIPTED_ANIMATION"); } break; case CTaskScriptedAnimation::kStateBlend: { VerifyDictAndAnim(scrDecodeString(pData->dict0.String), scrDecodeString(pData->clip0.String), "TASK_SCRIPTED_ANIMATION"); VerifyDictAndAnim(scrDecodeString(pData->dict1.String), scrDecodeString(pData->clip1.String), "TASK_SCRIPTED_ANIMATION"); VerifyDictAndAnim(scrDecodeString(pData->dict2.String), scrDecodeString(pData->clip2.String), "TASK_SCRIPTED_ANIMATION"); } break; default: {
}
break;
}
}
}
#endif //__BANK
void CommandTaskScriptedAnimation(int pedIndex, int& priorityLowData, int& priorityMidData, int& priorityHighData, float blendInDelta, float BlendOutDelta)
{
CTaskScriptedAnimation::ScriptInitSlotData* priorityLow = reinterpret_cast<CTaskScriptedAnimation::ScriptInitSlotData*>(&priorityLowData);
CTaskScriptedAnimation::ScriptInitSlotData* priorityMid = reinterpret_cast<CTaskScriptedAnimation::ScriptInitSlotData*>(&priorityMidData);
CTaskScriptedAnimation::ScriptInitSlotData* priorityHigh = reinterpret_cast<CTaskScriptedAnimation::ScriptInitSlotData*>(&priorityHighData);
#if __BANK // verify the clips exist, etc VerifySlotData(priorityLow); VerifySlotData(priorityMid); VerifySlotData(priorityHigh); #endif //__BANK
bool bSecondaryTask = false;
u32 combinedBits = priorityLow->flags.Int | priorityMid->flags.Int | priorityHigh->flags.Int;
eScriptedAnimFlagsBitSet& combinedFlags = reinterpret_cast<eScriptedAnimFlagsBitSet&>(combinedBits);
if ( combinedFlags.BitSet().IsSet(AF_SECONDARY) )
{
bSecondaryTask = true;
}
#if __ASSERT if (NetworkInterface::IsGameInProgress() ) { if( (priorityMid->state.Int!=CTaskScriptedAnimation::kStateEmpty) || (priorityHigh->state.Int!=CTaskScriptedAnimation::kStateEmpty) ) { scriptAssertf(false,"TASK_SCRIPTED_ANIMATION:: Network implementation only handles one slot data in ANIM_DATA& priorityLow. priorityMid %s, priorityHigh %s", (priorityMid->state.Int!=CTaskScriptedAnimation::kStateEmpty)?"Valid":"Empty", (priorityHigh->state.Int!=CTaskScriptedAnimation::kStateEmpty)?"Valid":"Empty"); } scriptAssertf( (priorityLow->clip2.String==NULL || priorityLow->weight2.Float==0.0f),"TASK_SCRIPTED_ANIMATION:: Network blended anim implementation only handles first 2 weighted anims. weight2 = %.5f, clip =%s", priorityLow->weight2.Float, priorityLow->clip2.String?priorityLow->clip2.String:"Null clip string"); } #endif // Start the new task CTask* pTask = rage_new CTaskScriptedAnimation(*priorityLow, *priorityMid, *priorityHigh, blendInDelta, BlendOutDelta);
// handle the automated FPS alternative clip
if (combinedFlags.BitSet().IsSet(AF_USE_ALTERNATIVE_FP_ANIM))
{
if (pTask && priorityLow->state.Int==CTaskScriptedAnimation::kStateSingleClip)
{
static const char * s_fpsClipSuffixHash = "_FP";
u32 fpsClipHash = atPartialStringHash(s_fpsClipSuffixHash, atPartialStringHash(priorityLow->clip0.String));
atHashString finalFpsHash(atFinalizeHash(fpsClipHash));
static_cast<CTaskScriptedAnimation*>(pTask)->SetFPSClipHash(finalFpsHash);
BANK_ONLY(VerifyDictAndAnim(scrDecodeString(priorityLow->dict0.String), finalFpsHash, "TASK_SCRIPTED_ANIMATION");)
}
}
bool bPartOfASequence = (pedIndex == NULL_IN_SCRIPTING_LANGUAGE);
if ( bPartOfASequence && bSecondaryTask )
{
CTask* pTaskSecond=pTask;
pTask=rage_new CTaskAffectSecondaryBehaviour(true,PED_TASK_SECONDARY_PARTIAL_ANIM,pTaskSecond);
}
else if (bSecondaryTask)
{
CPed * pPed = CTheScripts::GetEntityToModifyFromGUID<CPed>(pedIndex, bSecondaryTask ? CTheScripts::GUID_ASSERT_FLAGS_INCLUDE_CLONES : CTheScripts::GUID_ASSERT_FLAGS_ALL);
if(pPed)
{
pPed->GetPedIntelligence()->AddTaskSecondary( pTask, PED_TASK_SECONDARY_PARTIAL_ANIM );
}
return;
}
if (!bPartOfASequence && combinedFlags.BitSet().IsSet(AF_OVERRIDE_PHYSICS))
{
//force an ai update post camera so that the anim will be visible next frame (rather than waiting for the next task update)
CPed * pPed = CTheScripts::GetEntityToModifyFromGUID<CPed>(pedIndex, bSecondaryTask ? CTheScripts::GUID_ASSERT_FLAGS_INCLUDE_CLONES : CTheScripts::GUID_ASSERT_FLAGS_ALL);
if(pPed)
{
pPed->SetPedResetFlag( CPED_RESET_FLAG_ForcePostCameraAIUpdate, true );
}
}
CScriptPeds::GivePedScriptedTask(pedIndex, pTask, SCRIPT_TASK_PLAY_ANIM, "TASK_SCRIPTED_ANIMATION");
}
void CommandPlayEntityScriptedAnimation(int EntityIndex, int& priorityLowData, int& priorityMidData, int& priorityHighData, float blendInDelta, float BlendOutDelta)
{
CTaskScriptedAnimation::ScriptInitSlotData* priorityLow = reinterpret_cast<CTaskScriptedAnimation::ScriptInitSlotData*>(&priorityLowData);
CTaskScriptedAnimation::ScriptInitSlotData* priorityMid = reinterpret_cast<CTaskScriptedAnimation::ScriptInitSlotData*>(&priorityMidData);
CTaskScriptedAnimation::ScriptInitSlotData* priorityHigh = reinterpret_cast<CTaskScriptedAnimation::ScriptInitSlotData*>(&priorityHighData);
#if __BANK // verify the clips exist, etc VerifySlotData(priorityLow); VerifySlotData(priorityMid); VerifySlotData(priorityHigh); #endif //__BANK
// Start the new task
CPhysical *pEntity = CTheScripts::GetEntityToModifyFromGUID< CPhysical >(EntityIndex);
if(pEntity)
{
CTask* pTask = rage_new CTaskScriptedAnimation(*priorityLow, *priorityMid, *priorityHigh, blendInDelta, BlendOutDelta);
if (pEntity->GetIsTypeObject())
{
CObject *pObject = static_cast<CObject*>(pEntity);
pObject->SetTask(pTask, CObjectIntelligence::OBJECT_TASK_TREE_SECONDARY, CObjectIntelligence::OBJECT_TASK_SECONDARY_ANIM);
}
else if(pEntity->GetIsTypeVehicle())
{
CVehicle *pVehicle = static_cast<CVehicle*>(pEntity);
pVehicle->GetIntelligence()->AddTask(VEHICLE_TASK_TREE_SECONDARY, pTask, VEHICLE_TASK_SECONDARY_ANIM, true);
}
else
{
delete pTask;
}
}
}
void CommandTaskPlayPhoneGestureAnimation(int PedIndex, const char* pAnimDictHash, const char* pAnimName, const char *pFilterName, float fBlendInDuration, float fBlendOutDuration, bool bIsLooping, bool bHoldLastFrame)
{
const CPed * pPed = CTheScripts::GetEntityToModifyFromGUID<CPed>(PedIndex, CTheScripts::GUID_ASSERT_FLAGS_INCLUDE_CLONES);
if (SCRIPT_VERIFY(pPed && pPed->GetAnimDirector(), "TASK_PLAY_PHONE_GESTURE_ANIMATION - Invalid ped or ped has no anim director."))
{
// Look to see if secondary/phone task is running
CTaskMobilePhone *pTaskMobilePhone = static_cast<CTaskMobilePhone*>(pPed->GetPedIntelligence()->FindTaskSecondaryByType(CTaskTypes::TASK_MOBILE_PHONE));
if (SCRIPT_VERIFY(pTaskMobilePhone, "TASK_PLAY_PHONE_GESTURE_ANIMATION - Ped is not running mobile phone task."))
{
// Check if clip actually exists
u32 uDictHashkey = atHashString(pAnimDictHash);
s32 sAnimDictIndex = fwAnimManager::FindSlotFromHashKey(uDictHashkey).Get();
u32 uAnimHashKey = atHashString(pAnimName);
const crClip* pClip = fwAnimManager::GetClipIfExistsByDictIndex(sAnimDictIndex, uAnimHashKey);
scriptAssertf(pClip, "TASK_PLAY_PHONE_GESTURE_ANIMATION - Animation does not exist. Please ensure dictionary is streamed in! sAnimDictIndex: %d, uAnimHashKey: %d", sAnimDictIndex, uAnimHashKey);
if (pClip)
{
pTaskMobilePhone->RequestAdditionalSecondaryAnims(pAnimDictHash, pAnimName, pFilterName, fBlendInDuration, fBlendOutDuration, bIsLooping, bHoldLastFrame);
}
}
}
}
void CommandTaskStopPhoneGestureAnimation(int PedIndex, float fBlendOutOverride)
{
const CPed * pPed = CTheScripts::GetEntityToModifyFromGUID<CPed>(PedIndex, CTheScripts::GUID_ASSERT_FLAGS_INCLUDE_CLONES);
if (SCRIPT_VERIFY(pPed && pPed->GetAnimDirector(), "TASK_STOP_PHONE_GESTURE_ANIMATION - Invalid ped or ped has no anim director."))
{
CTaskMobilePhone *pTaskMobilePhone = static_cast<CTaskMobilePhone*>(pPed->GetPedIntelligence()->FindTaskSecondaryByType(CTaskTypes::TASK_MOBILE_PHONE));
if (SCRIPT_VERIFY(pTaskMobilePhone, "TASK_STOP_PHONE_GESTURE_ANIMATION - Ped is not running mobile phone task."))
{
pTaskMobilePhone->ClearAdditionalSecondaryAnimation(fBlendOutOverride);
}
}
}
bool CommandIsPlayingPhoneGestureAnim(int PedIndex)
{
const CPed * pPed = CTheScripts::GetEntityToModifyFromGUID<CPed>(PedIndex, CTheScripts::GUID_ASSERT_FLAGS_INCLUDE_CLONES);
if (SCRIPT_VERIFY(pPed && pPed->GetAnimDirector(), "(IS_PLAYING_PHONE_GESTURE_ANIM - Invalid ped or ped has no anim director."))
{
CTaskMobilePhone *pTaskMobilePhone = static_cast<CTaskMobilePhone*>(pPed->GetPedIntelligence()->FindTaskSecondaryByType(CTaskTypes::TASK_MOBILE_PHONE));
if (SCRIPT_VERIFY(pTaskMobilePhone, "(IS_PLAYING_PHONE_GESTURE_ANIM - Ped is not running mobile phone task."))
{
return pTaskMobilePhone->GetIsPlayingAdditionalSecondaryAnim();
}
}
return false;
}
float CommandGetPhoneGestureAnimCurrentTime(int PedIndex)
{
const CPed * pPed = CTheScripts::GetEntityToModifyFromGUID<CPed>(PedIndex, CTheScripts::GUID_ASSERT_FLAGS_INCLUDE_CLONES);
if (SCRIPT_VERIFY(pPed && pPed->GetAnimDirector(), "GET_PHONE_GESTURE_ANIM_CURRENT_TIME - Invalid ped or ped has no anim director."))
{
CTaskMobilePhone *pTaskMobilePhone = static_cast<CTaskMobilePhone*>(pPed->GetPedIntelligence()->FindTaskSecondaryByType(CTaskTypes::TASK_MOBILE_PHONE));
if (SCRIPT_VERIFY(pTaskMobilePhone, "GET_PHONE_GESTURE_ANIM_CURRENT_TIME - Ped is not running mobile phone task."))
{
return pTaskMobilePhone->GetAdditionalSecondaryAnimPhase();
}
}
return -1.0f;
}
float CommandGetPhoneGestureAnimTotalTime(int PedIndex)
{
const CPed * pPed = CTheScripts::GetEntityToModifyFromGUID<CPed>(PedIndex, CTheScripts::GUID_ASSERT_FLAGS_INCLUDE_CLONES);
if (SCRIPT_VERIFY(pPed && pPed->GetAnimDirector(), "GET_PHONE_GESTURE_ANIM_TOTAL_TIME - Invalid ped or ped has no anim director."))
{
CTaskMobilePhone *pTaskMobilePhone = static_cast<CTaskMobilePhone*>(pPed->GetPedIntelligence()->FindTaskSecondaryByType(CTaskTypes::TASK_MOBILE_PHONE));
if (SCRIPT_VERIFY(pTaskMobilePhone, "GET_PHONE_GESTURE_ANIM_TOTAL_TIME - Ped is not running mobile phone task."))
{
return pTaskMobilePhone->GetAdditionalSecondaryAnimDuration();
}
}
return -1.0f;
}
void CommandStartAnimPlayback(int EntityIndex, int& data, s32 priority)
{
CTaskScriptedAnimation::ScriptInitSlotData* slotData = reinterpret_cast<CTaskScriptedAnimation::ScriptInitSlotData*>(&data);
CPhysical *pPhysical = CTheScripts::GetEntityToModifyFromGUID<CPhysical>(EntityIndex);
if(pPhysical)
{
// look for an existing scripted animation task running on the ped
CTaskScriptedAnimation* pTask = NULL;
if (slotData->flags.Int & BIT(AF_SECONDARY))
{
pTask = entity_commands::FindScriptedAnimTask(EntityIndex, true, false);
}
else
{
pTask = entity_commands::FindScriptedAnimTask(EntityIndex, true);
}
if (SCRIPT_VERIFY(pTask, "START_ANIM_PLAYBACK: Anim task is not playing. Use TASK_SCRIPTED_ANIMATION to begin the task."))
{
CTaskScriptedAnimation::InitSlotData data(*slotData);
pTask->StartPlayback(data, GetPriorityFromControlFlags(priority));
}
}
}
void CommandStopAnimPlayback(int EntityIndex, s32 priority, bool secondary = false)
{
CPhysical *pPhysical = CTheScripts::GetEntityToModifyFromGUID<CPhysical>(EntityIndex);
if(pPhysical)
{
// look for an existing scripted animation task running on the ped
CTaskScriptedAnimation* pTask = NULL;
if (secondary)
{
pTask = entity_commands::FindScriptedAnimTask(EntityIndex, true, false);
}
else
{
pTask = entity_commands::FindScriptedAnimTask(EntityIndex, true);
}
if (SCRIPT_VERIFY(pTask, "STOP_ANIM_PLAYBACK: Anim task is not playing."))
{
pTask->StopPlayback(GetPriorityFromControlFlags(priority));
}
}
}
void CommandTaskClipSetClip(int EntityIndex, const char * pAnimDictName, const char * pAnimName, s32 priority, s32 index, bool secondary = false)
{
CPhysical *pPhysical = CTheScripts::GetEntityToModifyFromGUID<CPhysical>(EntityIndex);
if(pPhysical)
{
// look for an existing scripted animation task running on the ped
CTaskScriptedAnimation* pTask = NULL;
if (secondary)
{
pTask = entity_commands::FindScriptedAnimTask(EntityIndex, true, false);
}
else
{
pTask = entity_commands::FindScriptedAnimTask(EntityIndex, true);
}
if (SCRIPT_VERIFY(pTask, "TASK_CLIP_SET_CLIP: Anim task is not playing. Use TASK_ANIM_START_CLIP or TASK_ANIM_START_BLEND to begin the task."))
{
const crClip* pClip = FindClipForScriptCommand(pAnimDictName, pAnimName, "TASK_CLIP_SET_CLIP");
if (pClip)
{
pTask->SetClip(pClip, GetPriorityFromControlFlags(priority), (u8)index);
}
}
}
}
void CommandTaskClipSetBlendWeight(int EntityIndex, float weight, s32 priority, s32 index, bool secondary = false)
{
CPhysical *pPhysical = CTheScripts::GetEntityToModifyFromGUID<CPhysical>(EntityIndex);
if(pPhysical)
{
// look for an existing scripted animation task running on the ped
CTaskScriptedAnimation* pTask = NULL;
if (secondary)
{
pTask = pTask = entity_commands::FindScriptedAnimTask(EntityIndex, true, false);
}
else
{
pTask = pTask = entity_commands::FindScriptedAnimTask(EntityIndex, true);
}
if (SCRIPT_VERIFY(pTask, "TASK_CLIP_SET_BLEND_WEIGHT: Anim task is not playing. Use TASK_ANIM_START_BLEND to begin the task."))
{
pTask->SetBlend(weight, GetPriorityFromControlFlags(priority) , (u8)index);
}
}
}
void CommandTaskClipSetFilter(int EntityIndex, const char * pFilterName, s32 priority, bool secondary = false)
{
CPhysical *pPhysical = CTheScripts::GetEntityToModifyFromGUID<CPhysical>(EntityIndex);
if(pPhysical)
{
// look for an existing scripted animation task running on the ped
CTaskScriptedAnimation* pTask = NULL;
if (secondary)
{
pTask = entity_commands::FindScriptedAnimTask(EntityIndex, true, false);
}
else
{
pTask = entity_commands::FindScriptedAnimTask(EntityIndex, true);
}
if (SCRIPT_VERIFY(pTask, "TASK_CLIP_SET_FILTER: Anim task is not playing. Use TASK_ANIM_START_CLIP or TASK_ANIM_START_BLEND to begin the task."))
{
pTask->SetFilter(pFilterName, GetPriorityFromControlFlags(priority));
}
}
}
void CommandTaskClipSetPhase(int EntityIndex, float phase, s32 priority, bool secondary = false)
{
CPhysical *pPhysical = CTheScripts::GetEntityToModifyFromGUID<CPhysical>(EntityIndex);
if(pPhysical)
{
// look for an existing scripted animation task running on the ped
CTaskScriptedAnimation* pTask = NULL;
if (secondary)
{
pTask = entity_commands::FindScriptedAnimTask(EntityIndex, true, false);
}
else
{
pTask = entity_commands::FindScriptedAnimTask(EntityIndex, true);
}
if (SCRIPT_VERIFY(pTask, "TASK_CLIP_SET_PHASE: Anim task is not playing. Use TASK_ANIM_START_CLIP or TASK_ANIM_START_BLEND to begin the task."))
{
pTask->SetPhase(phase, GetPriorityFromControlFlags(priority));
}
}
}
void CommandTaskClipSetRate(int EntityIndex, float rate, s32 priority, bool secondary = false)
{
CPhysical *pPhysical = CTheScripts::GetEntityToModifyFromGUID<CPhysical>(EntityIndex);
if(pPhysical)
{
// look for an existing scripted animation task running on the ped
CTaskScriptedAnimation* pTask = NULL;
if (secondary)
{
pTask = entity_commands::FindScriptedAnimTask(EntityIndex, true, false);
}
else
{
pTask = entity_commands::FindScriptedAnimTask(EntityIndex, true);
}
if (SCRIPT_VERIFY(pTask, "TASK_CLIP_SET_RATE: Anim task is not playing. Use TASK_ANIM_START_CLIP or TASK_ANIM_START_BLEND to begin the task."))
{
pTask->SetRate(rate, GetPriorityFromControlFlags(priority));
}
}
}
void CommandTaskClipSetLooped(int EntityIndex, bool looped, s32 priority, bool secondary = false)
{
CPhysical *pPhysical = CTheScripts::GetEntityToModifyFromGUID<CPhysical>(EntityIndex);
if(pPhysical)
{
// look for an existing scripted animation task running on the ped
CTaskScriptedAnimation* pTask = NULL;
if (secondary)
{
pTask = entity_commands::FindScriptedAnimTask(EntityIndex, true, false);
}
else
{
pTask = entity_commands::FindScriptedAnimTask(EntityIndex, true);
}
if (SCRIPT_VERIFY(pTask, "TASK_CLIP_SET_LOOPED: Anim task is not playing. Use TASK_ANIM_START_CLIP or TASK_ANIM_START_BLEND to begin the task."))
{
pTask->SetLooped(looped, GetPriorityFromControlFlags(priority));
}
}
}
void CommandTaskPlayAnimAdvanced(int PedIndex, const char *pAnimDictName, const char *pAnimName, const scrVector & pos, const scrVector & rot, float fBlendInDelta, float fBlendOutDelta, int nTimeToPlay, int nFlags, float startPhase, int RotOrder, int ikFlags)
{
if (SCRIPT_VERIFY((nTimeToPlay == -1) || (nTimeToPlay > 0) ,"TASK_PLAY_ANIM - Time must be -1 for infinite or > 0" ))
{
// Transform the rotation into x = yaw, y = pitch, z = roll
// Convert from degrees to radians
Vector3 axisRot(DtoR*rot.x, DtoR*rot.y, DtoR*rot.z);
#if GTA_REPLAY CPed *pPed = NULL; if(NULL_IN_SCRIPTING_LANGUAGE!=PedIndex) { pPed = CTheScripts::GetEntityToModifyFromGUID(PedIndex, CTheScripts::GUID_ASSERT_FLAGS_INCLUDE_CLONES); if(pPed) { CReplayMgr::RecordWarpedEntity(pPed); } } #endif
PlayAnimScriptCommand(SCRIPT_TASK_PLAY_ANIM, PedIndex, pAnimName, pAnimDictName, fBlendInDelta, fBlendOutDelta, nTimeToPlay, nFlags, ikFlags, true, Vector3(pos), axisRot, startPhase, static_cast<EulerAngleOrder>(RotOrder), false, false);
}
}
void CommandStopAnimTask(int EntityIndex, const char *pAnimDictName, const char *pAnimName, float fBlendDelta)
{
// Check the object
CPhysical *pPhysical = CTheScripts::GetEntityToModifyFromGUID<CPhysical>(EntityIndex);
if(pPhysical)
{
// look for an existing scripted animation task running on the ped
CTaskScriptedAnimation* pTask = NULL;
pTask = entity_commands::FindScriptedAnimTask(EntityIndex, true);
if (pTask && pTask->IsPlayingClip(pAnimDictName, pAnimName))
{
// nothing to see here
}
else
{
//check the secondary task tree
pTask = entity_commands::FindScriptedAnimTask(EntityIndex, true, false);
if (pTask && !pTask->IsPlayingClip(pAnimDictName,pAnimName))
{
pTask = NULL;
}
}
const CTaskSynchronizedScene* pTaskSynchronizedScene = NULL;
if (!pTask)
{
pTaskSynchronizedScene = entity_commands::FindSynchronizedSceneTask(EntityIndex, pAnimDictName, pAnimName);
if (!SCRIPT_VERIFY(pTaskSynchronizedScene == NULL, "STOP_ANIM_TASK - Entity is playing the anim through a synced scene, use STOP_SYNCHRONIZED_ENTITY_ANIM instead!"))
{
pTaskSynchronizedScene = NULL;
}
}
if(!pTaskSynchronizedScene)
{
if (SCRIPT_VERIFY(pTask, "STOP_ANIM_TASK - Entity isn't running the anim"))
{
scriptAssertf(fBlendDelta<0.0f, "Blend out delta must be less than 0.0");
pTask->BlendOut(fwAnimHelpers::CalcBlendDuration(fBlendDelta));
}
}
}
}
void CommandTaskSynchronizedScene(int PedIndex, int sceneId, const char *pAnimDictName, const char *pAnimName, float blendIn, float blendOut, int flags, int ragdollBlockingFlags, float moverBlendDelta, int ikFlags)
{
if (SCRIPT_VERIFY(PedIndex!=NULL_IN_SCRIPTING_LANGUAGE, "TASK_SYNCHRONIZED_SCENE cannot be used in a sequence!"))
{
if (SCRIPT_VERIFY(fwAnimDirectorComponentSyncedScene::IsValidSceneId((fwSyncedSceneId)sceneId), "TASK_SYNCHRONIZED_SCENE: Invalid scene id!"))
{
// Get the ped
CPed* pPed = CTheScripts::GetEntityToModifyFromGUID<CPed>(PedIndex);
if(pPed)
{
scriptAssertf(blendIn>0.0f ,"TASK_SYNCHRONIZED_SCENE: blend in delta is (%f) should be > 0.0f. Changing to INSTANT_BLEND_IN_DELTA.", blendIn);
if (blendIn<=0.0f)
blendIn = INSTANT_BLEND_IN_DELTA;
scriptAssertf(blendOut<0.0f ,"TASK_SYNCHRONIZED_SCENE: blend out delta (%f) should be < 0.0. Changing to INSTANT_BLEND_OUT_DELTA.", blendOut);
if (blendOut>=0.0f)
blendOut = INSTANT_BLEND_OUT_DELTA;
scriptAssertf(moverBlendDelta>0.0f ,"TASK_SYNCHRONIZED_SCENE: mover blend delta (%f) should be > 0.0f. Changing to INSTANT_BLEND_IN_DELTA!", moverBlendDelta);
if (moverBlendDelta<=0.0f)
moverBlendDelta = INSTANT_BLEND_IN_DELTA;
if(pPed->GetIsAttached())
{
// If we are using CTaskUseScenario, it's probably not a problem if we are attached, because it's likely
// the task itself that has attached the ped.
CTaskUseScenario* pScenarioTask = static_cast<CTaskUseScenario*>(pPed->GetPedIntelligence()->FindTaskActiveByType(CTaskTypes::TASK_USE_SCENARIO));
if(pScenarioTask)
{
// It would have been expected to me that the running CTaskUseScenario would be aborted and
// clean up the detachment before CTaskSynchronizedScene starts, so that we would just need
// to find a way to bypass the attachment check below. For some reason, that doesn't seem to happen,
// but by calling MakeAbortable(), the task seems to clean up the attachment (and we can still
// check GetIsAttached() below), in case the abort failed or if there was some other reason the
// ped was attached. /FF
pScenarioTask->MakeAbortable(CTask::ABORT_PRIORITY_IMMEDIATE, NULL);
}
}
if (pPed->GetPedConfigFlag( CPED_CONFIG_FLAG_InVehicle ))
{
// Added by sorr in CL 6438528
if(pPed->IsLocalPlayer() && pPed->GetPedAudioEntity())
{
u32 animDictNameHash = atStringHash(pAnimDictName);
if(animDictNameHash == ATSTRINGHASH("mini@prostitutes@sexlow_veh_first_person", 0x3A68E23A) ||
animDictNameHash == ATSTRINGHASH("mini@prostitutes@sexnorm_veh_first_person", 0xF72790A8))
{
pPed->GetPedAudioEntity()->SetCachedBJVehicle(pPed->GetMyVehicle());
}
}
// Added by sorr in CL 6438528
Warningf("TASK_SYNCHRONIZED_SCENE: Ped was in vehicle, setting them out of it.");
pPed->SetPedOutOfVehicle(CPed::PVF_IgnoreSafetyPositionCheck|CPed::PVF_Warp);
}
const fwAttachmentEntityExtension *pExtension = pPed->GetAttachmentExtension();
if (pExtension)
{
fwEntity *entity = pExtension->GetAttachParent();
if (entity)
{
Warningf("TASK_SYNCHRONIZED_SCENE: Ped was attached. Detaching them.");
pPed->DetachFromParent(DETACH_FLAG_IGNORE_SAFE_POSITION_CHECK|DETACH_FLAG_SKIP_CURRENT_POSITION_CHECK);
}
}
scriptAssertf(!pPed->GetIsAttached(), "TASK_SYNCHRONIZED_SCENE: Ped is attached.");
const crClip* pClip = FindClipForScriptCommand(pAnimDictName, pAnimName, "TASK_SYNCHRONIZED_SCENE");
if (pClip)
{
eSyncedSceneFlagsBitSet& sceneFlags = reinterpret_cast<eSyncedSceneFlagsBitSet&>(flags);
eRagdollBlockingFlagsBitSet& ragdollFlags = reinterpret_cast<eRagdollBlockingFlagsBitSet&>(ragdollBlockingFlags);
eIkControlFlagsBitSet& ikControlFlags = reinterpret_cast<eIkControlFlagsBitSet&>(ikFlags);
CTaskSynchronizedScene* pTask = rage_new CTaskSynchronizedScene(static_cast<fwSyncedSceneId>(sceneId), atPartialStringHash(pAnimName), pAnimDictName, blendIn, blendOut, sceneFlags, ragdollFlags, moverBlendDelta, -1, ikControlFlags);
#if __DEV fwAnimDirectorComponentSyncedScene::RegisterWithSyncedScene(static_cast(sceneId), pPed); #endif //__DEV
CScriptPeds::GivePedScriptedTask(PedIndex, pTask, SCRIPT_TASK_SYNCHRONIZED_SCENE, "TASK_SYNCHRONIZED_SCENE");
animEntityDebugf(pPed, "TASK_SYNCHRONIZED_SCENE - %s starting synced scene task", CTheScripts::GetCurrentScriptNameAndProgramCounter());
// make sure we do an ai update now to sync up next frame
pPed->SetPedResetFlag( CPED_RESET_FLAG_ForcePostCameraAIUpdate, true );
pPed->SetPedResetFlag( CPED_RESET_FLAG_AllowUpdateIfNoCollisionLoaded, true);
if (blendIn==INSTANT_BLEND_IN_DELTA)
{
animDebugf3("[%u:%u] TASK_SYNCHRONIZED_SCENE: forcing a post camera anim update ped %s(%p) for instant blend in of synced scene", fwTimer::GetTimeInMilliseconds(), fwTimer::GetFrameCount(), pPed->GetModelName(), pPed);
pPed->SetPedResetFlag( CPED_RESET_FLAG_ForcePostCameraAnimUpdate, true );
}
}
}
}
}
}
int GetActualSequenceId(int Sequence)
{
return CTheScripts::GetCurrentGtaScriptHandler()->GetResourceReferenceFromId(Sequence);
}
void CommandOpenSequenceTask(int &Sequence)
{
CScriptResource_SequenceTask sequenceResource;
Sequence = CTheScripts::GetCurrentGtaScriptHandler()->RegisterScriptResourceAndGetId(sequenceResource);
}
void CommandCloseSequenceTask(int Sequence)
{
const int iTaskID = GetActualSequenceId(Sequence);
if(SCRIPT_VERIFY(iTaskID>=0, "CLOSE_SEQUENCE_TASK - No free sequences left."))
{
if(SCRIPT_VERIFY(iTaskID<CTaskSequences::MAX_NUM_SEQUENCE_TASKS, "CLOSE_SEQUENCE_TASK - Sequence task ID too big"))
{
if(SCRIPT_VERIFY(CTaskSequences::ms_bIsOpened[iTaskID], "CLOSE_SEQUENCE_TASK - Sequence task is already closed"))
{
SCRIPT_ASSERT(!CTaskSequences::ms_TaskSequenceLists[iTaskID].IsEmpty(), "CLOSE_SEQUENCE_TASK - sequence is empty");
CTaskSequences::ms_bIsOpened[iTaskID]=false;
CTaskSequences::ms_iActiveSequence=-1;
}
}
}
}
void CommandTaskPerformSequence(int PedIndex, int Sequence)
{
const int iTaskID = GetActualSequenceId(Sequence);
if(SCRIPT_VERIFY(iTaskID >= 0 && iTaskID<CTaskSequences::MAX_NUM_SEQUENCE_TASKS, "TASK_PERFORM_SEQUENCE - not a valid Sequence task ID"))
{
if (SCRIPT_VERIFY(!CTaskSequences::ms_bIsOpened[iTaskID], "TASK_PERFORM_SEQUENCE - Sequence task is still open"))
{
if (SCRIPT_VERIFY(!CTaskSequences::ms_TaskSequenceLists[iTaskID].IsEmpty(), "TASK_PERFORM_SEQUENCE - sequence task empty"))
{
CTaskUseSequence* pSequenceTask=rage_new CTaskUseSequence(iTaskID, Sequence);
#if __ASSERT //If assigning a sequence with a prop task in it, make sure the ped has an inventory.
CPed* pPed = CTheScripts::GetEntityToModifyFromGUID<CPed>(PedIndex, CTheScripts::GUID_ASSERT_FLAGS_INCLUDE_CLONES);
const CTaskList& taskList = pSequenceTask->GetTaskSequenceList()->GetTaskList();
for (int seqIndex = 0; seqIndex < taskList.GetNumTasks(); ++seqIndex)
{
const CTask* pTask = static_cast<const CTask*>(taskList.GetTask(seqIndex));
if (pTask && pTask->GetTaskType() == CTaskTypes::TASK_USE_SCENARIO)
{
const CTaskUseScenario* pScenarioTask = static_cast<const CTaskUseScenario*>(pTask);
scriptAssertf(!pScenarioTask->GetScenarioInfo().HasProp() || pPed->GetInventory(), "%s: Attempting to assign a ped a task sequence that includes a prop scenario (%s), but the ped(%s) has no inventory", CTheScripts::GetCurrentScriptNameAndProgramCounter(), pScenarioTask->GetScenarioInfo().GetName(), pPed->GetModelName());
}
}
#endif CScriptPeds::GivePedScriptedTask(PedIndex, pSequenceTask, SCRIPT_TASK_PERFORM_SEQUENCE, "TASK_PERFORM_SEQUENCE"); } } } }
void CommandTaskPerformSequenceLocally(int PedIndex, int Sequence)
{
const int iTaskID = GetActualSequenceId(Sequence);
if(SCRIPT_VERIFY(iTaskID >= 0 && iTaskID<CTaskSequences::MAX_NUM_SEQUENCE_TASKS, "TASK_PERFORM_SEQUENCE_LOCALLY - not a valid Sequence task ID"))
{
if(SCRIPT_VERIFY(!CTaskSequences::ms_bIsOpened[iTaskID], "TASK_PERFORM_SEQUENCE_LOCALLY - Sequence task is still open"))
{
if(SCRIPT_VERIFY(!CTaskSequences::ms_TaskSequenceLists[iTaskID].IsEmpty(), "TASK_PERFORM_SEQUENCE_LOCALLY - sequence task empty"))
{
CTaskUseSequence* pTask=rage_new CTaskUseSequence(iTaskID);
CScriptPeds::GivePedScriptedTask(PedIndex,pTask, SCRIPT_TASK_PERFORM_SEQUENCE_LOCALLY, "TASK_PERFORM_SEQUENCE_LOCALLY");
}
}
}
}
void CommandClearSequenceTask(int &Sequence)
{
CTheScripts::GetCurrentGtaScriptHandler()->RemoveScriptResource(Sequence, false, true, CGameScriptResource::SCRIPT_RESOURCE_SEQUENCE_TASK);
Sequence = 0;
}
void CommandSetSequenceToRepeat(int Sequence, int repeat)
{
const int iSequenceTaskID = GetActualSequenceId(Sequence);
const int iRepeatMode=repeat;
if(SCRIPT_VERIFY(iSequenceTaskID==CTaskSequences::ms_iActiveSequence, "SET_SEQUENCE_TO_REPEAT - Using wrong sequence ID"))
{
if(SCRIPT_VERIFY (iSequenceTaskID>=0 && iSequenceTaskID<CTaskSequences::MAX_NUM_SEQUENCE_TASKS, "SET_SEQUENCE_TO_REPEAT - Sequence task ID out of range"))
{
if(SCRIPT_VERIFY (CTaskSequences::ms_bIsOpened[iSequenceTaskID], "SET_SEQUENCE_TO_REPEAT - Sequence task needs to be open"))
{
CTaskSequences::ms_TaskSequenceLists[CTaskSequences::ms_iActiveSequence].SetRepeatMode(iRepeatMode);
}
}
}
}
void CommandSetSequencePreventMigration(int Sequence)
{
const int iSequenceTaskID = GetActualSequenceId(Sequence);
if(SCRIPT_VERIFY(iSequenceTaskID==CTaskSequences::ms_iActiveSequence, "SET_SEQUENCE_PREVENT_MIGRATION - Using wrong sequence ID"))
{
if(SCRIPT_VERIFY (iSequenceTaskID>=0 && iSequenceTaskID<CTaskSequences::MAX_NUM_SEQUENCE_TASKS, "SET_SEQUENCE_TO_REPEAT - Sequence task ID out of range"))
{
if(SCRIPT_VERIFY (CTaskSequences::ms_bIsOpened[iSequenceTaskID], "SET_SEQUENCE_PREVENT_MIGRATION - Sequence task needs to be open"))
{
CTaskSequences::ms_TaskSequenceLists[CTaskSequences::ms_iActiveSequence].PreventMigration();
}
}
}
}
int CommandGetSequenceProgress(int PedIndex)
{
int iProgress=-1;
const CPed* pPed = CTheScripts::GetEntityToQueryFromGUID<CPed>(PedIndex);
if (pPed)
{
if (SCRIPT_VERIFY(CPedScriptedTaskRecord::GetStatus(pPed, SCRIPT_TASK_PERFORM_SEQUENCE)>=0 ||
CPedScriptedTaskRecord::GetStatus(pPed, SCRIPT_TASK_PERFORM_SEQUENCE_FROM_PROGRESS)>=0,
"GET_SEQUENCE_PROGRESS - Ped isn't performing sequence"))
{
bool b=false;
const int iStage1=CPedScriptedTaskRecord::GetStatus(pPed, SCRIPT_TASK_PERFORM_SEQUENCE);
if(CPedScriptedTaskRecordData::EVENT_STAGE==iStage1)
{
b=true;
iProgress=-1;
}
const int iStage2=CPedScriptedTaskRecord::GetStatus(pPed, SCRIPT_TASK_PERFORM_SEQUENCE_FROM_PROGRESS);
if(CPedScriptedTaskRecordData::EVENT_STAGE==iStage2)
{
b=true;
iProgress=-1;
}
if(!b)
{
if( pPed->GetPedIntelligence()->GetQueriableInterface()->IsTaskPresentAtPriority( CTaskTypes::TASK_USE_SEQUENCE, PED_TASK_PRIORITY_PRIMARY ) )
{
iProgress = pPed->GetPedIntelligence()->GetQueriableInterface()->GetSequenceProgressForTaskType( 0, CTaskTypes::TASK_USE_SEQUENCE, PED_TASK_PRIORITY_PRIMARY );
}
else
{
scriptAssertf(false, "GET_SEQUENCE_PROGRESS- Ped doesn't have a the correct primary task");
}
}
}
}
return iProgress;
}
void CommandTaskGetOffBoat( int iPedID, int iTime )
{
if (SCRIPT_VERIFY((iTime == -1) || (iTime > 0) ,"TASK_GET_OFF_BOAT - Time must be -1 for infinite and > 0" ))
{
CTaskComplexGetOffBoat * pTaskGetOffBoat = rage_new CTaskComplexGetOffBoat(iTime);
CScriptPeds::GivePedScriptedTask( iPedID, pTaskGetOffBoat, SCRIPT_TASK_GET_OFF_BOAT, "TASK_GET_OFF_BOAT");
}
}
bool CommandGetIsTaskActive( int iPedID, int iCommandType )
{
const CPed *pPed = CTheScripts::GetEntityToQueryFromGUID<CPed>(iPedID);
if (pPed)
{
if(pPed->GetPedIntelligence()->GetQueriableInterface()->IsTaskCurrentlyRunning(iCommandType, true))
{
return true;
}
}
return false;
}
int CommandGetActiveVehicleMissionType(int iVehID)
{
const CVehicle *pVehicle = CTheScripts::GetEntityToQueryFromGUID<CVehicle>(iVehID);
if (pVehicle)
{
sVehicleMissionParams params;
s32 iTaskType = CTaskTypes::TASK_INVALID_ID;
pVehicle->GetIntelligence()->GetActiveTaskInfo(iTaskType, params);
return CVehicleIntelligence::GetMissionIdentifierFromTaskType(iTaskType, params);
}
return MISSION_NONE;
}
int CommandGetScriptTaskStatus( int iPedID, int iCommandType)
{
#if __ASSERT scriptAssertf(CTheScripts::GetScriptTaskName(iCommandType), "%s GET_SCRIPT_TASK_STATUS: Unknown command type (%d)", CTheScripts::GetCurrentScriptNameAndProgramCounter(), iCommandType); #endif // __ASSERT const CPed *pPed = CTheScripts::GetEntityToQueryFromGUID(iPedID); if (pPed) { int iTaskStatus=CPedScriptedTaskRecord::GetStatus(pPed,iCommandType); if (iTaskStatus == -1) { iTaskStatus = CPedScriptedTaskRecordData::MAX_NUM_STAGES; } return iTaskStatus; } return (CPedScriptedTaskRecordData::MAX_NUM_STAGES); }
void CommandTaskLeaveAnyVehicle( int iPedID, int iDelayTime, int iFlags)
{
VehicleEnterExitFlags vehicleFlags;
CTaskVehicleFSM::SetScriptedVehicleEntryExitFlags(vehicleFlags, iFlags);
if (!vehicleFlags.BitSet().IsSet(CVehicleEnterExitFlags::DontDefaultWarpIfDoorBlocked))
{
vehicleFlags.BitSet().Set(CVehicleEnterExitFlags::WarpIfDoorBlocked);
}
CTask* pTask=rage_new CTaskLeaveAnyCar(iDelayTime, vehicleFlags);
AI_LOG_WITH_ARGS("[Script] - Script %s has created CTaskLeaveAnyCar from SCRIPT_TASK_LEAVE_ANY_VEHICLE at 0x%p for ped with id %i\n", CTheScripts::GetCurrentScriptName(), pTask, iPedID);
CScriptPeds::GivePedScriptedTask( iPedID, pTask, SCRIPT_TASK_LEAVE_ANY_VEHICLE, "TASK_LEAVE_ANY_VEHICLE");
}
void CommandTaskAimGunScripted(int iPedID, int iGunTaskType, bool bDisableBlockingClip, bool bInstantBlendToAim)
{
const CScriptedGunTaskInfo* pScriptedGunTaskInfo = CScriptedGunTaskMetadataMgr::GetScriptedGunTaskInfoByHash((u32)iGunTaskType);
if (scriptVerifyf(pScriptedGunTaskInfo, "TASK_AIM_GUN_SCRIPTED - scripted gun task info (%u) didn't exist, check metadata", iGunTaskType))
{
CPed* pPed = CTheScripts::GetEntityToModifyFromGUID<CPed>(iPedID);
if (pPed)
{
SCRIPT_ASSERT(pPed->IsLocalPlayer(), "TASK_AIM_GUN_SCRIPTED - Only supported on the player ped");
//Position the default target position ahead of the player
Vector3 targetPos = VEC3V_TO_VECTOR3(pPed->GetTransform().GetPosition()) + (VEC3V_TO_VECTOR3(pPed->GetTransform().GetForward()) * 3.0f);
CTaskGun* pGunTask = rage_new CTaskGun(CWeaponController::WCT_Player, CTaskTypes::TASK_AIM_GUN_SCRIPTED, CWeaponTarget(targetPos));
if( bDisableBlockingClip )
pGunTask->GetGunFlags().SetFlag(GF_DisableBlockingClip);
if( bInstantBlendToAim )
pGunTask->GetGunFlags().SetFlag(GF_InstantBlendToAim);
pGunTask->GetGunFlags().SetFlag(GF_ForceAimState);
pGunTask->GetGunFlags().SetFlag(GF_DisableTorsoIk);
pGunTask->SetScriptedGunTaskInfoHash(pScriptedGunTaskInfo->GetName().GetHash());
CScriptPeds::GivePedScriptedTask( iPedID, pGunTask, SCRIPT_TASK_AIM_GUN_SCRIPTED, "TASK_AIM_GUN_SCRIPTED");
}
}
}
void CommandTaskAimGunScriptedWithTarget(int iPedID, int iTargetPedID, const scrVector & scrVecTargetOrOffset, int iGunTaskType, bool bDisableBlockingClip, bool bForceAim)
{
const CScriptedGunTaskInfo* pScriptedGunTaskInfo = CScriptedGunTaskMetadataMgr::GetScriptedGunTaskInfoByHash((u32)iGunTaskType);
if (scriptVerifyf(pScriptedGunTaskInfo, "TASK_AIM_GUN_SCRIPTED_WITH_TARGET - scripted gun task info (%u) didn't exist, check metadata", iGunTaskType))
{
CPed* pPed = CTheScripts::GetEntityToModifyFromGUID<CPed>(iPedID);
if (pPed)
{
CTaskGun* pGunTask;
Vec3V vTargetOrOffset(scrVecTargetOrOffset);
const CPed* pTargetPed = CTheScripts::GetEntityToQueryFromGUID<CPed>(iTargetPedID, CTheScripts::GUID_ASSERT_FLAG_DEAD_CHECK);
CWeaponController::WeaponControllerType controllerType = CWeaponController::WCT_Fire;
if(bForceAim)
{
controllerType = CWeaponController::WCT_Aim;
}
if(pTargetPed)
{
pGunTask = rage_new CTaskGun(controllerType, CTaskTypes::TASK_AIM_GUN_SCRIPTED, CWeaponTarget(pTargetPed, VEC3V_TO_VECTOR3(vTargetOrOffset)));
}
else
{
pGunTask = rage_new CTaskGun(controllerType, CTaskTypes::TASK_AIM_GUN_SCRIPTED, CWeaponTarget(VEC3V_TO_VECTOR3(vTargetOrOffset)));
}
if(pPed->IsLocalPlayer())
{
pGunTask->SetFiringPatternHash(FIRING_PATTERN_FULL_AUTO);
}
if( bDisableBlockingClip )
pGunTask->GetGunFlags().SetFlag(GF_DisableBlockingClip);
pGunTask->GetGunFlags().SetFlag(GF_ForceAimState);
pGunTask->SetScriptedGunTaskInfoHash(pScriptedGunTaskInfo->GetName().GetHash());
CScriptPeds::GivePedScriptedTask( iPedID, pGunTask, SCRIPT_TASK_AIM_GUN_SCRIPTED, "TASK_AIM_GUN_SCRIPTED_WITH_TARGET");
}
}
}
void CommmandUpdateTaskAimGunScriptedTarget(int iPedID, int iTargetPedID, const scrVector & scrVecTargetOrOffset, bool bDisableBlockingClip)
{
CPed* pPed = CTheScripts::GetEntityToModifyFromGUID<CPed>(iPedID);
if (pPed)
{
CTaskAimGunScripted* pAimGunTask = static_cast<CTaskAimGunScripted*>(pPed->GetPedIntelligence()->FindTaskActiveByType(CTaskTypes::TASK_AIM_GUN_SCRIPTED));
if(SCRIPT_VERIFY(pAimGunTask, "UPDATE_TASK_AIM_GUN_SCRIPTED_TARGET - Ped must be running TASK_AIM_GUN_SCRIPTED"))
{
if( bDisableBlockingClip )
{
pAimGunTask->GetGunFlags().SetFlag(GF_DisableBlockingClip);
}
pAimGunTask->GetGunFlags().SetFlag(GF_ForceAimState);
//Update the target on the gun task
CTaskGun* pGunTask = static_cast<CTaskGun*>(pPed->GetPedIntelligence()->FindTaskActiveByType(CTaskTypes::TASK_GUN));
if(SCRIPT_VERIFY(pGunTask, "UPDATE_TASK_AIM_GUN_SCRIPTED_TARGET - Ped must be running CTaskGun"))
{
Vec3V vTargetOrOffset(scrVecTargetOrOffset);
const CPed* pTargetPed = CTheScripts::GetEntityToQueryFromGUID<CPed>(iTargetPedID, CTheScripts::GUID_ASSERT_FLAG_DEAD_CHECK);
if(pTargetPed)
{
pGunTask->SetTarget( CWeaponTarget(pTargetPed, VEC3V_TO_VECTOR3(vTargetOrOffset)));
}
else
{
pGunTask->SetTarget( CWeaponTarget(VEC3V_TO_VECTOR3(vTargetOrOffset)));
}
}
}
}
}
const char * CommandGetClipSetForScriptedGunTask(s32 iGunTaskType)
{
const CScriptedGunTaskInfo* pScriptedGunTaskInfo = CScriptedGunTaskMetadataMgr::GetScriptedGunTaskInfoByHash((u32)iGunTaskType);
if (scriptVerifyf(pScriptedGunTaskInfo, "GET_CLIP_SET_FOR_SCRIPTED_GUN_TASK - Scripted gun task info %u didn't exist, check metadata", (u32)iGunTaskType))
{
return pScriptedGunTaskInfo->GetClipSetName().GetCStr();
}
return NULL;
}
void CommandSetRopeTrackEntityForGunTask(int iPedID, int iEntityID)
{
const CPed* pPed = CTheScripts::GetEntityToQueryFromGUID<CPed>(iPedID);
if(SCRIPT_VERIFY(pPed, "SET_ROPE_TRACK_ENTITY_FOR_SCRIPTED_GUN_TASK - Invalid ped"))
{
CEntity* pEntity = const_cast<CEntity*>(CTheScripts::GetEntityToQueryFromGUID<CEntity>(iEntityID));
if(SCRIPT_VERIFY(pEntity, "SET_ROPE_TRACK_ENTITY_FOR_SCRIPTED_GUN_TASK - Invalid entity"))
{
CTaskAimGunScripted* pAimTask = static_cast<CTaskAimGunScripted*>(pPed->GetPedIntelligence()->FindTaskActiveByType(CTaskTypes::TASK_AIM_GUN_SCRIPTED));
if(SCRIPT_VERIFY(pAimTask, "SET_ROPE_TRACK_ENTITY_FOR_SCRIPTED_GUN_TASK - Ped must be running TASK_AIM_GUN_SCRIPTED"))
{
pAimTask->SetRopeOrientationEntity(pEntity);
}
}
}
}
void CommandTaskAimGunAtEntity(int iPedID, int iEntityID, int iTime, bool bInstantBlendToAim )
{
if (SCRIPT_VERIFY((iTime == -1) || (iTime >= 0) ,"TASK_AIM_GUN_AT_ENTITY - Time must be -1 for infinite" ))
{
const CEntity *pEntity = CTheScripts::GetEntityToQueryFromGUID<CEntity>(iEntityID);
if (pEntity)
{
CTaskGun* pTaskGun = rage_new CTaskGun(CWeaponController::WCT_Aim, CTaskTypes::TASK_AIM_GUN_ON_FOOT, CWeaponTarget(pEntity), ((float) iTime) / 1000.0f);
if(iTime == -1)
{
pTaskGun->GetGunFlags().SetFlag(GF_InfiniteDuration);
}
else if (iTime == 0)
{
pTaskGun->GetGunFlags().SetFlag(GF_DisableAiming);
}
if(bInstantBlendToAim)
{
pTaskGun->GetGunFlags().SetFlag(GF_InstantBlendToAim);
}
CScriptPeds::GivePedScriptedTask( iPedID, pTaskGun, SCRIPT_TASK_AIM_GUN_AT_ENTITY, "TASK_AIM_GUN_AT_ENTITY");
}
}
}
void CommandTaskTurnPedToFaceEntity( int iPedID, int iEntityID, int iTime )
{
const CEntity* pEntity = CTheScripts::GetEntityToQueryFromGUID<CEntity>(iEntityID, CTheScripts::GUID_ASSERT_FLAGS_NO_DEAD_CHECK);
if (pEntity)
{
float fTime;
if(iTime < 0)
{
fTime = -1.0f;
}
else if(iTime == 0)
{
fTime = 0.0f;
}
else
{
fTime = ((float)iTime)/1000.0f;
}
CTask* pTask=rage_new CTaskTurnToFaceEntityOrCoord(pEntity, CTaskMoveAchieveHeading::ms_fHeadingChangeRateFrac, CTaskMoveAchieveHeading::ms_fHeadingTolerance, fTime);
CScriptPeds::GivePedScriptedTask( iPedID, pTask, SCRIPT_TASK_TURN_PED_TO_FACE_ENTITY, "TASK_TURN_PED_TO_FACE_ENTITY");
}
}
void CommandTaskAimGunAtCoord( int iPedID, const scrVector & scrVecCoors, int iTime, bool bInstantBlendToAim, bool bPlayAimIntro )
{
if (SCRIPT_VERIFY((iTime == -1) || (iTime >= 0) ,"TASK_AIM_GUN_AT_COORD - Time must be -1 for infinite and >= 0" ))
{
Vector3 vecAimTarget(scrVecCoors);
CTaskGun* pTaskGun = rage_new CTaskGun(CWeaponController::WCT_Aim, CTaskTypes::TASK_AIM_GUN_ON_FOOT, CWeaponTarget(vecAimTarget), ((float) iTime) / 1000.0f);
if(iTime == -1)
{
pTaskGun->GetGunFlags().SetFlag(GF_InfiniteDuration);
}
else if(iTime == 0)
{
pTaskGun->GetGunFlags().SetFlag(GF_DisableAiming);
}
if(bInstantBlendToAim)
{
pTaskGun->GetGunFlags().SetFlag(GF_InstantBlendToAim);
}
if(bPlayAimIntro)
{
pTaskGun->SetPlayAimIntro(true);
}
CScriptPeds::GivePedScriptedTask(iPedID, pTaskGun, SCRIPT_TASK_AIM_GUN_AT_COORD, "TASK_AIM_GUN_AT_COORD");
}
}
void CommandTaskShootAtCoord( int iPedID, const scrVector & scrVecCoors, int iTime, int iFiringPatternHash )
{
if (SCRIPT_VERIFY((iTime == -1) || (iTime > 0) ,"TASK_SHOOT_GUN_AT_COORD - Time must be -1 for infinite and > 0" ))
{
Vector3 TempCoors( scrVecCoors);
CTask* pTask = NULL;
if(iPedID != NULL_IN_SCRIPTING_LANGUAGE)
{
CPed *pPed = CTheScripts::GetEntityToModifyFromGUID<CPed>(iPedID);
if (pPed)
{
if(scriptVerifyf(pPed->GetWeaponManager(), "%s:TASK_SHOOT_GUN_AT_COORD - ped requires a weapon manager", CTheScripts::GetCurrentScriptNameAndProgramCounter()))
{
const CWeaponInfo* pWeaponInfo = CWeaponInfoManager::GetInfo<CWeaponInfo>(pPed->GetWeaponManager()->GetEquippedWeaponHash());
if(scriptVerifyf(pWeaponInfo, "%s:TASK_SHOOT_GUN_AT_COORD - pWeaponInfo NULL - ped has no equiped weapon info", CTheScripts::GetCurrentScriptNameAndProgramCounter())
&& pWeaponInfo->GetIsThrownWeapon())
{
pTask = rage_new CTaskAimAndThrowProjectile( CWeaponTarget( TempCoors ) );
}
}
}
else
{
return;
}
}
if(pTask==NULL)
{
pTask = rage_new CTaskGun(CWeaponController::WCT_Fire, CTaskTypes::TASK_AIM_GUN_ON_FOOT, CWeaponTarget(TempCoors), ((float) iTime) / 1000.0f);
if(iFiringPatternHash)
{
static_cast<CTaskGun*>(pTask)->SetFiringPatternHash(iFiringPatternHash);
}
if(iTime == -1)
{
static_cast<CTaskGun*>(pTask)->GetGunFlags().SetFlag(GF_InfiniteDuration);
}
}
CScriptPeds::GivePedScriptedTask( iPedID, pTask, SCRIPT_TASK_SHOOT_AT_COORD, "TASK_SHOOT_GUN_AT_COORD");
}
}
void CommandTaskShuffleToNextVehicleSeat( int iPedID, int iVehicleID, bool bUseAlternateShuffle)
{
CVehicle *pVehicle = CTheScripts::GetEntityToModifyFromGUID<CVehicle>(iVehicleID, CTheScripts::GUID_ASSERT_FLAGS_INCLUDE_CLONES);
CPed* pPed = NULL;
if(iPedID != NULL_IN_SCRIPTING_LANGUAGE)
{
pPed = CTheScripts::GetEntityToModifyFromGUID<CPed>(iPedID);
if (pPed)
{
if (!SCRIPT_VERIFY(pPed->GetPedConfigFlag( CPED_CONFIG_FLAG_InVehicle ) && pPed->GetMyVehicle(), "Ped isn't in a vehicle, need to call IS_PED_IN_ANY_VEHICLE to verify ped is in one") ||
!SCRIPT_VERIFY(pPed->GetMyVehicle() == pVehicle, "Ped is not in the given vehicle - TASK_SHUFFLE_TO_NEXT_VEHICLE_SEAT"))
{
return;
}
}
}
if (pVehicle)
{
s32 iTargetSeatIndex = -1;
if (pPed && bUseAlternateShuffle && pVehicle->GetSeatManager() && pVehicle->GetVehicleModelInfo() && pVehicle->GetVehicleModelInfo()->GetModelSeatInfo())
{
const s32 iCurrentSeatIndex = pVehicle->GetSeatManager()->GetPedsSeatIndex(pPed);
const s32 iCurrentEntryPointIndex = pVehicle->GetVehicleModelInfo()->GetModelSeatInfo()->GetEntryPointIndexForSeat(iCurrentSeatIndex, pVehicle);
iTargetSeatIndex = pVehicle->GetVehicleModelInfo()->GetModelSeatInfo()->GetShuffleSeatForSeat(iCurrentEntryPointIndex, iCurrentSeatIndex, true);
}
CTask* pTask = rage_new CTaskInVehicleSeatShuffle(pVehicle,NULL, true, iTargetSeatIndex);
CScriptPeds::GivePedScriptedTask(iPedID, pTask, SCRIPT_TASK_SHUFFLE_TO_NEXT_VEHICLE_SEAT, "TASK_SHUFFLE_TO_NEXT_VEHICLE_SEAT");
}
}
void CommandClearPedTasks(int iPedID)
{
CPed *pPed = CTheScripts::GetEntityToModifyFromGUID<CPed>(iPedID, CTheScripts::GUID_ASSERT_FLAGS_INCLUDE_CLONES);
if (pPed)
{
if (SCRIPT_VERIFY(!pPed->IsInjured(), "Ped is injured, cannot clear all tasks!"))
{
if(pPed->IsNetworkClone())
{
bool bClearTasksImmediately = false;
CClearPedTasksEvent::Trigger(pPed, bClearTasksImmediately);
}
else
{
AI_LOG_WITH_ARGS_IF_SCRIPT_OR_PLAYER_PED(pPed, "[Script] - Ped %s has had tasks cleared by script %s\n", AILogging::GetDynamicEntityNameSafe(pPed), CTheScripts::GetCurrentScriptName());
pPed->GetPedIntelligence()->ClearTasks();
pPed->SetIsCrouching(false);
}
#if __DEV // Record the task in the debug list static char stringName[] = "CLEAR_PED_TASKS"; pPed->GetPedIntelligence()->AddScriptHistoryString(stringName, stringName, CTheScripts::GetCurrentScriptName(), CTheScripts::GetCurrentGtaScriptThread()->GetThreadPC()); #endif } } }
void CommandClearPedScriptTaskIfRunningThreatResponseNonTempTask(int iPedID)
{
CPed *pPed = CTheScripts::GetEntityToModifyFromGUID<CPed>(iPedID, CTheScripts::GUID_ASSERT_FLAGS_INCLUDE_CLONES);
if (pPed)
{
// If this ped is running a non temporary threat response task, clear their primary (script) task which is dormant
// [GTAV] B*1605087
CTask* pNonTempTask = pPed->GetPedIntelligence()->GetTaskAtPriority(PED_TASK_PRIORITY_EVENT_RESPONSE_NONTEMP);
if (pNonTempTask && pNonTempTask->GetTaskType() == CTaskTypes::TASK_THREAT_RESPONSE)
{
pPed->GetPedIntelligence()->ClearPrimaryTaskAtPriority(PED_TASK_PRIORITY_PRIMARY);
}
}
}
void CommandClearPedSecondaryTask(int iPedID)
{
CPed *pPed = CTheScripts::GetEntityToModifyFromGUID<CPed>(iPedID);
if (pPed)
{
pPed->GetPedIntelligence()->ClearTasks( false, true );
}
}
void CommandTaskEveryoneLeaveVehicle(int iVehicleID)
{
// this script command is not approved for use in network scripts
if (SCRIPT_VERIFY(!NetworkInterface::IsGameInProgress(), "%TASK_EVERYONE_LEAVE_VEHICLE - This script command is not allowed in network game scripts!"))
{
CVehicle *pVehicle = CTheScripts::GetEntityToModifyFromGUID<CVehicle>(iVehicleID);
if (SCRIPT_VERIFY(pVehicle, "TASK_EVERYONE_LEAVE_VEHICLE - Vehicle doesn't exist"))
{
for(int loop = 0;loop < pVehicle->GetSeatManager()->GetMaxSeats(); loop++)
{
CPed* pPedInSeat = pVehicle->GetSeatManager()->GetPedInSeat(loop);
if(pPedInSeat && !pPedInSeat->IsInjured() )
{
const int iDelay=(loop+1)*500+fwRandom::GetRandomNumberInRange(-100,100);
CTask* pTask=rage_new CTaskLeaveAnyCar(iDelay);
AI_LOG_WITH_ARGS("[Script] - Script %s has created CTaskLeaveAnyCar from SCRIPT_TASK_EVERYONE_LEAVE_VEHICLE at 0x%p for ped %s\n", CTheScripts::GetCurrentScriptName(), pTask, AILogging::GetDynamicEntityNameSafe(pPedInSeat));
const int iPedID=CTheScripts::GetGUIDFromEntity(*pPedInSeat);
CScriptPeds::GivePedScriptedTask( iPedID,pTask, SCRIPT_TASK_EVERYONE_LEAVE_VEHICLE, "TASK_EVERYONE_LEAVE_VEHICLE");
}
}
}
}
}
// Please keep this in sync with the enumeration in "commands_task.sch"
enum ESEEK_ENTITY_OFFSET_FLAGS
{
ESEEK_OFFSET_ORIENTATES_WITH_ENTITY = 0x01,
ESEEK_KEEP_TO_PAVEMENTS = 0x02
};
void CommandTaskGotoEntityOffset( int iPedID, int iEntityID, int iTime, float fSeekRadius, float fSeekAngleDeg, float fMoveBlendRatio, int iGotoEntityOffsetFlags )
{
if (SCRIPT_VERIFY((iTime == -1) || (iTime > 0), "TASK_GOTO_ENTITY_OFFSET - Time must be -1 for infinite and > 0" ))
{
const float fSeekAngle=( DtoR * fSeekAngleDeg);
const CEntity* pEntity = CTheScripts::GetEntityToQueryFromGUID<CEntity>(iEntityID);
if (pEntity)
{
if (NetworkInterface::IsGameInProgress() && (!pEntity->GetIsDynamic() || !((CDynamicEntity*)pEntity)->GetNetworkObject()))
{
scriptAssertf(0, "%s:TASK_GOTO_ENTITY_OFFSET; the entity must be networked or this ped will not be able to migrate properly", CTheScripts::GetCurrentScriptNameAndProgramCounter());
}
CTask* pTask=rage_new TTaskMoveSeekEntityRadiusAngleOffset(pEntity,iTime);
CEntitySeekPosCalculatorRadiusAngleOffset seekPosCalculator(fSeekRadius,fSeekAngle);
((TTaskMoveSeekEntityRadiusAngleOffset*)pTask)->SetEntitySeekPosCalculator(seekPosCalculator);
((TTaskMoveSeekEntityRadiusAngleOffset*)pTask)->SetMoveBlendRatio(fMoveBlendRatio);
Assertf( (iGotoEntityOffsetFlags & ESEEK_OFFSET_ORIENTATES_WITH_ENTITY)==0, "Can't specify 'ESEEK_OFFSET_ORIENTATES_WITH_ENTITY' with TASK_GOTO_ENTITY_OFFSET, this task always orientates offset with target entity.");
if((iGotoEntityOffsetFlags & ESEEK_KEEP_TO_PAVEMENTS)!=0)
((TTaskMoveSeekEntityRadiusAngleOffset*)pTask)->SetPreferPavements(true);
((TTaskMoveSeekEntityRadiusAngleOffset*)pTask)->SetUseLargerSearchExtents(true);
CTaskComplexControlMovement* pSimpleControlMovement = rage_new CTaskComplexControlMovement(pTask);
CScriptPeds::GivePedScriptedTask( iPedID, pSimpleControlMovement, SCRIPT_TASK_GOTO_ENTITY_OFFSET, "TASK_GOTO_ENTITY_OFFSET");
}
}
}
void CommandTaskGotoEntityOffsetXY( int iPedID, int iEntityID, int iTime, float fTargetRadius, float fOffsetX, float fOffsetY, float fMoveBlendRatio, int iGotoEntityOffsetFlags )
{
if (SCRIPT_VERIFY((iTime == -1) || (iTime > 0), "TASK_GOTO_ENTITY_OFFSET_XY - Time must be -1 for infinite and > 0" ))
{
const CEntity* pEntity = CTheScripts::GetEntityToQueryFromGUID<CEntity>(iEntityID);
if (pEntity)
{
if (NetworkInterface::IsGameInProgress() && (!pEntity->GetIsDynamic() || !((CDynamicEntity*)pEntity)->GetNetworkObject()))
{
scriptAssertf(0, "%s:TASK_GOTO_ENTITY_OFFSET_XY; the entity must be networked or this ped will not be able to migrate properly", CTheScripts::GetCurrentScriptNameAndProgramCounter());
}
CTask * pTask;
if( (iGotoEntityOffsetFlags & ESEEK_OFFSET_ORIENTATES_WITH_ENTITY) != 0 )
{
pTask = rage_new TTaskMoveSeekEntityXYOffsetRotated(pEntity, iTime);
CEntitySeekPosCalculatorXYOffsetRotated seekPosCalculator( Vector3(fOffsetX, fOffsetY, 0.0f) );
((TTaskMoveSeekEntityXYOffsetRotated*)pTask)->SetEntitySeekPosCalculator(seekPosCalculator);
((TTaskMoveSeekEntityXYOffsetRotated*)pTask)->SetMoveBlendRatio(fMoveBlendRatio);
((TTaskMoveSeekEntityXYOffsetRotated*)pTask)->SetTargetRadius(fTargetRadius);
if((iGotoEntityOffsetFlags & ESEEK_KEEP_TO_PAVEMENTS)!=0)
((TTaskMoveSeekEntityXYOffsetRotated*)pTask)->SetPreferPavements(true);
((TTaskMoveSeekEntityXYOffsetRotated*)pTask)->SetUseLargerSearchExtents(true);
}
else
{
pTask = rage_new TTaskMoveSeekEntityXYOffsetFixed(pEntity, iTime);
CEntitySeekPosCalculatorXYOffsetFixed seekPosCalculator( Vector3(fOffsetX, fOffsetY, 0.0f) );
((TTaskMoveSeekEntityXYOffsetFixed*)pTask)->SetEntitySeekPosCalculator(seekPosCalculator);
((TTaskMoveSeekEntityXYOffsetFixed*)pTask)->SetMoveBlendRatio(fMoveBlendRatio);
((TTaskMoveSeekEntityXYOffsetFixed*)pTask)->SetTargetRadius(fTargetRadius);
if((iGotoEntityOffsetFlags & ESEEK_KEEP_TO_PAVEMENTS)!=0)
((TTaskMoveSeekEntityXYOffsetFixed*)pTask)->SetPreferPavements(true);
((TTaskMoveSeekEntityXYOffsetFixed*)pTask)->SetUseLargerSearchExtents(true);
}
CTaskComplexControlMovement* pSimpleControlMovement = rage_new CTaskComplexControlMovement(pTask);
CScriptPeds::GivePedScriptedTask( iPedID, pSimpleControlMovement, SCRIPT_TASK_GOTO_ENTITY_OFFSET, "TASK_GOTO_ENTITY_OFFSET_XY");
}
}
}
// Remember to update eScriptInvestigateFlags in commands_task.sch
enum eScriptInvestigateFlags
{
SIF_DONT_RETURN_TO_ORIGINAL_POSITION = 1,
};
void CommandTaskInvestigateCoords (int iPedID, const scrVector & vCoords, int timeToSpendAtSearchPointInMS, int investigateFlags)
{
Vector3 vInvestigationPosition(vCoords);
// As there's only one flag right now, I'm just passing in a bool to the constructor of CTaskInvestigate. [1/9/2013 mdawe]
const bool bReturnToPosition = !(investigateFlags & SIF_DONT_RETURN_TO_ORIGINAL_POSITION);
CTask* pTask = rage_new CTaskInvestigate(vInvestigationPosition, NULL, EVENT_SUSPICIOUS_ACTIVITY, timeToSpendAtSearchPointInMS, bReturnToPosition);
CScriptPeds::GivePedScriptedTask( iPedID, pTask, SCRIPT_TASK_INVESTIGATE_COORDS, "TASK_INVESTIGATE");
}
// Remember to update the scripts if you change these flags
// eScriptLookAtFlags in commands_task.sch
// Please leave as numbers so its easy to compare with the flags in commands_task.sch
// i.e dont change 4 to (1<<2)
enum eScriptLookatFlags
{
SLF_SLOW_TURN_RATE = 1, // turn the head toward the target slowly
SLF_FAST_TURN_RATE = 2, // turn the head toward the target quickly
SLF_EXTEND_YAW_LIMIT = 4, // wide yaw head limits
SLF_EXTEND_PITCH_LIMIT = 8, // wide pitch head limit
SLF_WIDEST_YAW_LIMIT = 16, // widest yaw head limit
SLF_WIDEST_PITCH_LIMIT = 32, // widest pitch head limit
SLF_NARROW_YAW_LIMIT = 64, // narrow yaw head limits
SLF_NARROW_PITCH_LIMIT = 128, // narrow pitch head limit
SLF_NARROWEST_YAW_LIMIT = 256, // narrowest yaw head limit
SLF_NARROWEST_PITCH_LIMIT = 512, // narrowest pitch head limit
SLF_USE_TORSO = 1024, // use the torso aswell as the neck and head (currently disabled)
SLF_WHILE_NOT_IN_FOV = 2048, // keep tracking the target even if they are not in the hard coded FOV
SLF_USE_CAMERA_FOCUS = 4096, // use the camera as the target
SLF_USE_EYES_ONLY = 8192, // only track the target with the eyes
SLF_USE_LOOK_DIR = 16384, // use information in look dir DOF
SLF_FROM_SCRIPT = 32768, // internal use only
SLF_USE_REF_DIR_ABSOLUTE = 65536 // use absolute reference direction mode for solver
};
int ConvertScriptLookatFlags(int scriptFlags)
{
int lookatFlags = LF_FROM_SCRIPT;
scriptFlags & SLF_SLOW_TURN_RATE ? lookatFlags |= LF_SLOW_TURN_RATE : 0;
scriptFlags & SLF_FAST_TURN_RATE ? lookatFlags |= LF_FAST_TURN_RATE : 0;
scriptFlags & SLF_EXTEND_YAW_LIMIT ? lookatFlags |= LF_WIDEST_YAW_LIMIT : 0;
scriptFlags & SLF_EXTEND_PITCH_LIMIT ? lookatFlags |= LF_WIDEST_PITCH_LIMIT : 0;
scriptFlags & SLF_WIDEST_YAW_LIMIT ? lookatFlags |= LF_WIDEST_YAW_LIMIT : 0;
scriptFlags & SLF_WIDEST_PITCH_LIMIT ? lookatFlags |= LF_WIDEST_PITCH_LIMIT : 0;
scriptFlags & SLF_NARROW_YAW_LIMIT ? lookatFlags |= LF_NARROW_YAW_LIMIT : 0;
scriptFlags & SLF_NARROW_PITCH_LIMIT ? lookatFlags |= LF_NARROW_PITCH_LIMIT : 0;
scriptFlags & SLF_NARROWEST_YAW_LIMIT ? lookatFlags |= LF_NARROWEST_YAW_LIMIT : 0;
scriptFlags & SLF_NARROWEST_PITCH_LIMIT ? lookatFlags |= LF_NARROWEST_PITCH_LIMIT : 0;
scriptFlags & SLF_USE_TORSO ? lookatFlags |= LF_USE_TORSO : 0;
scriptFlags & SLF_WHILE_NOT_IN_FOV ? lookatFlags |= LF_WHILE_NOT_IN_FOV : 0;
scriptFlags & SLF_USE_CAMERA_FOCUS ? lookatFlags |= LF_USE_CAMERA_FOCUS : 0;
scriptFlags & SLF_USE_EYES_ONLY ? lookatFlags |= LF_USE_EYES_ONLY : 0;
scriptFlags & SLF_USE_LOOK_DIR ? lookatFlags |= LF_USE_LOOK_DIR : 0;
scriptFlags & SLF_USE_REF_DIR_ABSOLUTE ? lookatFlags |= LF_USE_REF_DIR_ABSOLUTE : 0;
return lookatFlags;
}
void CommandTaskLookAtCoord(int iPedID, const scrVector & scrVecCoors, int iTime, int flags, int priority)
{
if (SCRIPT_VERIFY((iTime == -1) || (iTime > 0), "TASK_LOOK_AT_COORD - Time must be -1 for infinite and > 0" ))
{
int lookatFlags = ConvertScriptLookatFlags(flags);
if(NULL_IN_SCRIPTING_LANGUAGE!=iPedID)
{
if (SCRIPT_VERIFY(-1==CTaskSequences::ms_iActiveSequence, "TASK_LOOK_AT_COORD - Sequence opened unexpectedly"))
{
CPed *pPed=CTheScripts::GetEntityToModifyFromGUID<CPed>(iPedID);
if (pPed)
{
ikDebugf3("%u TASK_LOOK_AT_COORD(pPed %p %s, scrVecCoors %.3f,%.3f,%.3f, iTime %i, flags %i, priority %i) LookAt",
fwTimer::GetFrameCount(), pPed, pPed->GetModelName(), scrVecCoors.x, scrVecCoors.y, scrVecCoors.z, iTime, flags, priority);
// this script command is not approved for use in network scripts
Vector3 offset(scrVecCoors);
pPed->GetIkManager().LookAt(0, 0, iTime, BONETAG_INVALID, &offset, lookatFlags, 500, 500, (CIkManager::eLookAtPriority)priority);
}
else
{
ikDebugf3("%u TASK_LOOK_AT_COORD(iPedID %i, scrVecCoors %.3f,%.3f,%.3f, iTime %i, flags %i, priority %i) Could not find ped!\n%s",
fwTimer::GetFrameCount(), iPedID, scrVecCoors.x, scrVecCoors.y, scrVecCoors.z, iTime, flags, priority,
CTheScripts::GetCurrentScriptNameAndProgramCounter());
}
}
else
{
ikDebugf3("%u TASK_LOOK_AT_COORD(iPedID %i, scrVecCoors %.3f,%.3f,%.3f, iTime %i, flags %i, priority %i) Sequence opened unexpectedly!\n%s",
fwTimer::GetFrameCount(), iPedID, scrVecCoors.x, scrVecCoors.y, scrVecCoors.z, iTime, flags, priority,
CTheScripts::GetCurrentScriptNameAndProgramCounter());
}
}
else
{
Vector3 offset(scrVecCoors);
if (SCRIPT_VERIFY(CTaskSequences::ms_iActiveSequence >=0 && CTaskSequences::ms_iActiveSequence<CTaskSequences::MAX_NUM_SEQUENCE_TASKS, "TASK_LOOK_AT_COORD - Sequence task closed"))
{
if (SCRIPT_VERIFY(CTaskSequences::ms_bIsOpened[CTaskSequences::ms_iActiveSequence], "TASK_LOOK_AT_COORD - sequence task closed"))
{
ikDebugf3("%u TASK_LOOK_AT_COORD(iPedID %i, scrVecCoors %.3f,%.3f,%.3f, iTime %i, flags %i, priority %i) CTaskTriggerLookAt",
fwTimer::GetFrameCount(), iPedID, scrVecCoors.x, scrVecCoors.y, scrVecCoors.z, iTime, flags, priority);
CTask* pTask = rage_new CTaskTriggerLookAt(NULL, iTime, BONETAG_INVALID, offset, lookatFlags);
CTaskSequences::ms_TaskSequenceLists[CTaskSequences::ms_iActiveSequence].AddTask(pTask);
}
else
{
ikDebugf3("%u TASK_LOOK_AT_COORD(iPedID %i, scrVecCoors %.3f,%.3f,%.3f, iTime %i, flags %i, priority %i) Sequence task closed!\n%s",
fwTimer::GetFrameCount(), iPedID, scrVecCoors.x, scrVecCoors.y, scrVecCoors.z, iTime, flags, priority,
CTheScripts::GetCurrentScriptNameAndProgramCounter());
}
}
else
{
ikDebugf3("%u TASK_LOOK_AT_COORD(iPedID %i, scrVecCoors %.3f,%.3f,%.3f, iTime %i, flags %i, priority %i) Sequence task closed!\n%s",
fwTimer::GetFrameCount(), iPedID, scrVecCoors.x, scrVecCoors.y, scrVecCoors.z, iTime, flags, priority,
CTheScripts::GetCurrentScriptNameAndProgramCounter());
}
}
}
}
void CommandTaskLookAtEntity(int iPedID, int iEntityID, int iTime, int flags, int priority)
{
if (SCRIPT_VERIFY((iTime == -1) || (iTime > 0), "TASK_LOOK_AT_ENTITY - Time must be -1 for infinite and > 0" ))
{
int lookatFlags = ConvertScriptLookatFlags(flags);
const CEntity* pEntity = CTheScripts::GetEntityToQueryFromGUID<CEntity>(iEntityID, CTheScripts::GUID_ASSERT_FLAGS_NO_DEAD_CHECK);
if (pEntity)
{
eAnimBoneTag boneTag = BONETAG_INVALID;
// Use the head bone as the target (if possible)
if ( pEntity->GetIsTypePed() )
{
// Some animals e.g A_C_Stingray dont have a head fall back to the entity position
s32 boneIdx = -1;
if ( pEntity->GetSkeletonData().ConvertBoneIdToIndex((u16)BONETAG_HEAD, boneIdx) )
{
boneTag = BONETAG_HEAD;
}
}
if(NULL_IN_SCRIPTING_LANGUAGE!=iPedID)
{
if (SCRIPT_VERIFY(-1==CTaskSequences::ms_iActiveSequence, "TASK_LOOK_AT_ENTITY - Sequence opened unexpectedly"))
{
CPed *pPed = CTheScripts::GetEntityToModifyFromGUID<CPed>(iPedID, CTheScripts::GUID_ASSERT_FLAGS_NO_DEAD_CHECK & CTheScripts::GUID_ASSERT_FLAGS_INCLUDE_CLONES);
if(pPed)
{
scriptAssertf(pPed != pEntity, "TASK_LOOK_AT_ENTITY - Target and source entities are the same (entityId = %d)", iPedID);
if(NetworkUtils::IsNetworkCloneOrMigrating(pPed))
{
if(SCRIPT_VERIFY(pEntity->GetIsDynamic(), "TASK_LOOK_AT_ENTITY - Entity for clone is not dynamic!"))
{
netObject* pNetObj = static_cast<const CDynamicEntity*>(pEntity)->GetNetworkObject();
if(SCRIPT_VERIFY(pNetObj, "TASK_LOOK_AT_ENTITY - Entity for clone is not networked!"))
{
ikDebugf3("%u TASK_LOOK_AT_ENTITY(pPed %p %s, pEntity %p %s, iTime %i, flags %i, priority %i) CSettingOfLookAtEntity",
fwTimer::GetFrameCount(), pPed, pPed->GetModelName(), pEntity, pEntity->GetModelName(), iTime, flags, priority);
CScriptEntityStateChangeEvent::CSettingOfLookAtEntity parameters(pNetObj, lookatFlags, iTime);
CScriptEntityStateChangeEvent::Trigger(pPed->GetNetworkObject(), parameters);
}
else
{
ikDebugf3("%u TASK_LOOK_AT_ENTITY(pPed %p %s, pEntity %p %s, iTime %i, flags %i, priority %i) Entity for clone is not networked!\n%s",
fwTimer::GetFrameCount(), pPed, pPed->GetModelName(), pEntity, pEntity->GetModelName(), iTime, flags, priority,
CTheScripts::GetCurrentScriptNameAndProgramCounter());
}
}
else
{
ikDebugf3("%u TASK_LOOK_AT_ENTITY(pPed %p %s, pEntity %p %s, iTime %i, flags %i, priority %i) Entity for clone is not dynamic!\n%s",
fwTimer::GetFrameCount(), pPed, pPed->GetModelName(), pEntity, pEntity->GetModelName(), iTime, flags, priority,
CTheScripts::GetCurrentScriptNameAndProgramCounter());
}
}
else
{
ikDebugf3("%u TASK_LOOK_AT_ENTITY(pPed %p %s, pEntity %p %s, iTime %i, flags %i, priority %i) LookAt",
fwTimer::GetFrameCount(), pPed, pPed->GetModelName(), pEntity, pEntity->GetModelName(), iTime, flags, priority);
pPed->GetIkManager().LookAt(0, pEntity, iTime, boneTag, NULL, lookatFlags, 500, 500, (CIkManager::eLookAtPriority)priority);
}
}
else
{
ikDebugf3("%u TASK_LOOK_AT_ENTITY(iPedID %i, pEntity %p %s, iTime %i, flags %i, priority %i) Entity for clone is not dynamic!\n%s",
fwTimer::GetFrameCount(), iPedID, pEntity, pEntity->GetModelName(), iTime, flags, priority,
CTheScripts::GetCurrentScriptNameAndProgramCounter());
}
}
}
else
{
Vector3 offset(0,0,0);
if (SCRIPT_VERIFY(CTaskSequences::ms_iActiveSequence >=0 && CTaskSequences::ms_iActiveSequence<CTaskSequences::MAX_NUM_SEQUENCE_TASKS, "TASK_LOOK_AT_ENTITY - Sequence task closed"))
{
if (SCRIPT_VERIFY(CTaskSequences::ms_bIsOpened[CTaskSequences::ms_iActiveSequence], "TASK_LOOK_AT_ENTITY - sequence task closed"))
{
ikDebugf3("%u TASK_LOOK_AT_ENTITY(iPedID %i, pEntity %p %s, iTime %i, flags %i, priority %i) CTaskTriggerLookAt",
fwTimer::GetFrameCount(), iPedID, pEntity, pEntity->GetModelName(), iTime, flags, priority);
CTask* pTask = rage_new CTaskTriggerLookAt(pEntity, iTime, boneTag, offset, lookatFlags);
CTaskSequences::ms_TaskSequenceLists[CTaskSequences::ms_iActiveSequence].AddTask(pTask);
}
else
{
ikDebugf3("%u TASK_LOOK_AT_ENTITY(iPedID %i, pEntity %p %s, iTime %i, flags %i, priority %i) Sequence task closed!\n%s",
fwTimer::GetFrameCount(), iPedID, pEntity, pEntity->GetModelName(), iTime, flags, priority,
CTheScripts::GetCurrentScriptNameAndProgramCounter());
}
}
else
{
ikDebugf3("%u TASK_LOOK_AT_ENTITY(iPedID %i, pEntity %p %s, iTime %i, flags %i, priority %i) Sequence task closed!\n%s",
fwTimer::GetFrameCount(), iPedID, pEntity, pEntity->GetModelName(), iTime, flags, priority,
CTheScripts::GetCurrentScriptNameAndProgramCounter());
}
}
}
else
{
ikDebugf3("%u TASK_LOOK_AT_ENTITY(iPedID %i, iEntityID %i, iTime %i, flags %i, priority %i) Could not find entity!\n%s",
fwTimer::GetFrameCount(), iPedID, iEntityID, iTime, flags, priority,
CTheScripts::GetCurrentScriptNameAndProgramCounter());
}
}
else
{
ikDebugf3("%u TASK_LOOK_AT_ENTITY(iPedID %i, iEntityID %i, iTime %i, flags %i, priority %i) Time must be -1 for infinite and > 0!\n%s",
fwTimer::GetFrameCount(), iPedID, iEntityID, iTime, flags, priority,
CTheScripts::GetCurrentScriptNameAndProgramCounter());
}
}
void CommandClearLookAt(int iPedID)
{
if(NULL_IN_SCRIPTING_LANGUAGE!=iPedID)
{
if(SCRIPT_VERIFY(-1==CTaskSequences::ms_iActiveSequence, "TASK_CLEAR_LOOK_AT - Sequence opened unexpectedly"))
{
CPed* pPed = CTheScripts::GetEntityToModifyFromGUID<CPed>(iPedID);
if(pPed)
{
if(pPed->GetIkManager().IsLooking())
{
ikDebugf3("%u CLEAR_LOOK_AT(pPed %p %s) AbortLookAt(500)",
fwTimer::GetFrameCount(), pPed, pPed->GetModelName());
pPed->GetIkManager().AbortLookAt(500);
}
else
{
ikDebugf3("%u CLEAR_LOOK_AT(pPed %p %s) Ped is not looking!\n%s",
fwTimer::GetFrameCount(), pPed, pPed->GetModelName(),
CTheScripts::GetCurrentScriptNameAndProgramCounter());
}
}
else
{
ikDebugf3("%u CLEAR_LOOK_AT(iPedID %i) Could not find ped!\n%s",
fwTimer::GetFrameCount(), iPedID,
CTheScripts::GetCurrentScriptNameAndProgramCounter());
}
}
else
{
ikDebugf3("%u CLEAR_LOOK_AT(iPedID %i) Sequence opened unexpectedly!\n%s",
fwTimer::GetFrameCount(), iPedID,
CTheScripts::GetCurrentScriptNameAndProgramCounter());
}
}
else
{
if(SCRIPT_VERIFY(CTaskSequences::ms_iActiveSequence >=0 && CTaskSequences::ms_iActiveSequence<CTaskSequences::MAX_NUM_SEQUENCE_TASKS, "CLEAR_LOOK_AT - Sequence task closed"))
{
if(SCRIPT_VERIFY(CTaskSequences::ms_bIsOpened[CTaskSequences::ms_iActiveSequence], "TASK_CLEAR_LOOK_AT - sequence task closed"))
{
ikDebugf3("%u CLEAR_LOOK_AT(iPedID %i) CTaskClearLookAt",
fwTimer::GetFrameCount(), iPedID);
CTask* pTask = rage_new CTaskClearLookAt();
CTaskSequences::ms_TaskSequenceLists[CTaskSequences::ms_iActiveSequence].AddTask(pTask);
}
else
{
ikDebugf3("%u CLEAR_LOOK_AT(iPedID %i) Sequence task closed!\n%s",
fwTimer::GetFrameCount(), iPedID,
CTheScripts::GetCurrentScriptNameAndProgramCounter());
}
}
else
{
ikDebugf3("%u CLEAR_LOOK_AT(iPedID %i) Sequence task closed!\n%s",
fwTimer::GetFrameCount(), iPedID,
CTheScripts::GetCurrentScriptNameAndProgramCounter());
}
}
}
static u32 giSearchModelIndex = fwModelId::MI_INVALID;
static CEntity* gpClosestEntity = NULL;
static float gfClosestDistSq = 0.0f;
static Vector3 gvSearchPos;
bool FindNearestEntityCB (CEntity* pEntity, void* UNUSED_PARAM(pData) )
{
C2dEffect* pSpawnPoint = pEntity->GetClosest2dEffect(ET_SPAWN_POINT, gvSearchPos);
if(!pSpawnPoint)
{
return true;
}
if( pEntity->GetModelIndex() == giSearchModelIndex ||
!CModelInfo::IsValidModelInfo(giSearchModelIndex))
{
float fDistSq = DistSquared(pEntity->GetTransform().GetPosition(), RCC_VEC3V(gvSearchPos)).Getf();
if(gpClosestEntity == NULL ||
gfClosestDistSq > fDistSq )
{
gpClosestEntity = pEntity;
gfClosestDistSq = fDistSq;
}
}
return true;
}
bool CommandIsPedInvestigatingWhistlingEvent( int iPedID )
{
const CPed *pPed = CTheScripts::GetEntityToQueryFromGUID<CPed>(iPedID);
if(pPed)
{
CTaskInvestigate* pInvestigateTask = (CTaskInvestigate*) pPed->GetPedIntelligence()->FindTaskActiveByType(CTaskTypes::TASK_INVESTIGATE);
if (pInvestigateTask && pInvestigateTask->IsInvestigatingWhistlingEvent())
{
return true;
}
}
return false;
}
void CommandSetInvestigationPosition( int iPedID, const scrVector & scrVecInvestigationPosition)
{
CPed *pPed = CTheScripts::GetEntityToModifyFromGUID<CPed>(iPedID);
if(pPed)
{
CTaskInvestigate* pInvestigateTask = (CTaskInvestigate*) pPed->GetPedIntelligence()->FindTaskActiveByType(CTaskTypes::TASK_INVESTIGATE);
if (pInvestigateTask)
{
pInvestigateTask->SetInvestigationPos(scrVecInvestigationPosition);
}
}
}
void CommandTaskTurnPedToFaceCoord( int iPedID, const scrVector & scrVecCoors, int iTime )
{
float fTime;
if(iTime < 0)
{
fTime = -1.0f;
}
else if(iTime == 0)
{
fTime = 0.0f;
}
else
{
fTime = ((float)iTime)/1000.0f;
}
CTask* pTask = rage_new CTaskTurnToFaceEntityOrCoord(Vector3(scrVecCoors), CTaskMoveAchieveHeading::ms_fHeadingChangeRateFrac, CTaskMoveAchieveHeading::ms_fHeadingTolerance, fTime);
CScriptPeds::GivePedScriptedTask(iPedID, pTask, SCRIPT_TASK_TURN_PED_TO_FACE_COORD, "TASK_TURN_PED_TO_FACE_COORD");
}
void CommandTaskDrivePointRoute( int iPedID, int iVehicleID, float fCruiseSpeed )
{
if(SCRIPT_VERIFY(CTaskMoveFollowPointRoute::ms_pointRoute.GetSize() > 0,"TASK_DRIVE_POINT_ROUTE: Point route didn't have any points in it."))
{
CTask* pTask;
CVehicle *pVehicle = NULL;
if(iVehicleID>=0)
{
pVehicle = CTheScripts::GetEntityToModifyFromGUID<CVehicle>(iVehicleID, CTheScripts::GUID_ASSERT_FLAGS_INCLUDE_CLONES);
if(!pVehicle)
return;
}
pTask=rage_new CTaskDrivePointRoute(pVehicle,CTaskMoveFollowPointRoute::ms_pointRoute, fCruiseSpeed);
CScriptPeds::GivePedScriptedTask( iPedID, pTask, SCRIPT_TASK_DRIVE_POINT_ROUTE, "TASK_DRIVE_POINT_ROUTE");
}
}
void GivePedGoToPointAimingTask(
int iPedID, const CAITarget& goToTarget, const CAITarget& aimAtTarget, float fMoveBlendRatio,
float TargetRadius, float SlowDistance, bool bShoot, bool bUseNavmesh, int iNavFlags, bool bInstantBlendToAim, int iFiringPatternHash,
int iScriptTaskType, const char* commandName, const int iTime )
{
#if __ASSERT Vector3 vGoToPosition; Vector3 vAimAtPosition;
if(goToTarget.GetPosition(vGoToPosition))
{
scriptAssertf(!vGoToPosition.IsClose(VEC3_ZERO, SMALL_FLOAT), "%s - Goto position is too close to the origin. %s", commandName, CTheScripts::GetCurrentScriptNameAndProgramCounter());
}
if(aimAtTarget.GetPosition(vAimAtPosition))
{
scriptAssertf(!vAimAtPosition.IsClose(VEC3_ZERO, SMALL_FLOAT), "%s - Aim at position is too close to the origin. %s", commandName, CTheScripts::GetCurrentScriptNameAndProgramCounter());
}
#endif
CTaskGoToPointAiming* pTask = rage_new CTaskGoToPointAiming(goToTarget, aimAtTarget, fMoveBlendRatio, bShoot, iTime);
pTask->SetTargetRadius(TargetRadius);
pTask->SetSlowDownDistance(SlowDistance);
pTask->SetUseNavmesh(bUseNavmesh);
pTask->SetScriptNavFlags(iNavFlags);
pTask->SetInstantBlendToAim(bInstantBlendToAim);
if(bShoot)
{
pTask->SetFiringPattern(iFiringPatternHash);
}
CScriptPeds::GivePedScriptedTask(iPedID, pTask, iScriptTaskType, commandName);
}
void CommandTaskGoToCoordWhileAimingAtCoord(
int iPedID, const scrVector & scrVecGoToCoord, const scrVector & scrVecAimAtCoord, float fMoveBlendRatio,
bool bShoot, float TargetRadius, float SlowDistance, bool bUseNavmesh, int iNavFlags, bool bInstantBlendToAim, int iFiringPatternHash )
{
GivePedGoToPointAimingTask(
iPedID, CAITarget(Vector3(scrVecGoToCoord)), CAITarget(Vector3(scrVecAimAtCoord)), fMoveBlendRatio,
TargetRadius, SlowDistance, bShoot, bUseNavmesh, iNavFlags, bInstantBlendToAim, iFiringPatternHash, SCRIPT_TASK_GO_TO_COORD_WHILE_AIMING_AT_COORD,
"TASK_GO_TO_COORD_WHILE_AIMING_AT_COORD", -1);
}
void CommandTaskGoToCoordWhileAimingAtEntity(
int iPedID, const scrVector & scrVecGoToCoord, int iAimAtEntityID, float fMoveBlendRatio,
bool bShoot, float TargetRadius, float SlowDistance, bool bUseNavmesh, int iNavFlags, bool bInstantBlendToAim, int iFiringPatternHash, const int iTime )
{
const CEntity* pAimAtEntity = CTheScripts::GetEntityToQueryFromGUID<CEntity>(iAimAtEntityID);
if(pAimAtEntity)
{
GivePedGoToPointAimingTask(
iPedID, CAITarget(Vector3(scrVecGoToCoord)), CAITarget(pAimAtEntity), fMoveBlendRatio,
TargetRadius, SlowDistance, bShoot, bUseNavmesh, iNavFlags, bInstantBlendToAim, iFiringPatternHash, SCRIPT_TASK_GO_TO_COORD_WHILE_AIMING_AT_ENTITY,
"TASK_GO_TO_COORD_WHILE_AIMING_AT_ENTITY", iTime);
}
}
void CommandTaskGoToCoordAndAimAtHatedEntitiesNearCoord(
int iPedID, const scrVector & scrVecGoToCoord, const scrVector & scrAimNearCoord, float fMoveBlendRatio,
bool bShoot, float TargetRadius, float SlowDistance, bool bUseNavmesh, int iNavFlags, int iTaskFlags, int iFiringPatternHash )
{
Vector3 vGoToPosition(scrVecGoToCoord);
scriptAssertf(!vGoToPosition.IsClose(VEC3_ZERO, SMALL_FLOAT), "TASK_GO_TO_COORD_AND_AIM_AT_HATED_ENTITIES_NEAR_COORD - Go to position is too close to the origin. %s", CTheScripts::GetCurrentScriptNameAndProgramCounter());
Vector3 vAimNearPosition(scrAimNearCoord);
scriptAssertf(!vAimNearPosition.IsClose(VEC3_ZERO, SMALL_FLOAT), "TASK_GO_TO_COORD_AND_AIM_AT_HATED_ENTITIES_NEAR_COORD - Aim near position is too close to the origin. %s", CTheScripts::GetCurrentScriptNameAndProgramCounter());
CTaskGoToPointAiming* pTask = rage_new CTaskGoToPointAiming(CAITarget(vGoToPosition), CAITarget(vAimNearPosition), fMoveBlendRatio, bShoot);
pTask->SetTargetRadius(TargetRadius);
pTask->SetSlowDownDistance(SlowDistance);
pTask->SetUseNavmesh(bUseNavmesh);
pTask->SetAimAtHatedEntitiesNearAimCoord(true);
pTask->SetScriptNavFlags(iNavFlags);
pTask->SetConfigFlags(iTaskFlags);
if(bShoot)
{
pTask->SetFiringPattern(iFiringPatternHash);
}
CScriptPeds::GivePedScriptedTask(iPedID, pTask, SCRIPT_TASK_GO_TO_COORD_AND_AIM_AT_HATED_ENTITIES_NEAR_COORD,
"TASK_GO_TO_COORD_AND_AIM_AT_HATED_ENTITIES_NEAR_COORD");
}
void CommandTaskGoToEntityWhileAimingAtCoord(
int iPedID, int iEntityID, const scrVector & scrVecAimAtCoord, float fMoveBlendRatio,
bool bShoot, float TargetRadius, float SlowDistance, bool bUseNavmesh, bool bInstantBlendToAim, int iFiringPatternHash )
{
const CEntity* pEntity = CTheScripts::GetEntityToQueryFromGUID<CEntity>(iEntityID);
if(pEntity)
{
GivePedGoToPointAimingTask(
iPedID, CAITarget(pEntity), CAITarget(Vector3(scrVecAimAtCoord)), fMoveBlendRatio,
TargetRadius, SlowDistance, bShoot, bUseNavmesh, 0, bInstantBlendToAim, iFiringPatternHash, SCRIPT_TASK_GO_TO_ENTITY_WHILE_AIMING_AT_COORD,
"TASK_GO_TO_ENTITY_WHILE_AIMING_AT_COORD", -1);
}
}
void CommandTaskGoToEntityWhileAimingAtEntity(
int iPedID, int iGoToEntityID, int iAimAtEntityID, float fMoveBlendRatio,
bool bShoot, float TargetRadius, float SlowDistance, bool bUseNavmesh, bool bInstantBlendToAim, int iFiringPatternHash )
{
const CEntity* pGoToEntity = CTheScripts::GetEntityToQueryFromGUID<CEntity>(iGoToEntityID);
const CEntity* pAimAtEntity = CTheScripts::GetEntityToQueryFromGUID<CEntity>(iAimAtEntityID);
if(pGoToEntity && pAimAtEntity)
{
GivePedGoToPointAimingTask(
iPedID, CAITarget(pGoToEntity), CAITarget(pAimAtEntity), fMoveBlendRatio,
TargetRadius, SlowDistance, bShoot, bUseNavmesh, 0, bInstantBlendToAim, iFiringPatternHash, SCRIPT_TASK_GO_TO_ENTITY_WHILE_AIMING_AT_ENTITY,
"TASK_GO_TO_ENTITY_WHILE_AIMING_AT_ENTITY", -1);
}
}
void CommandTaskVehicleTempAction( int iPedID, int iVehicleID, int iAction, int iTime )
{
if (SCRIPT_VERIFY((iTime == -1) || (iTime > 0) ,"TASK_VEHICLE_TEMP_ACTION - Time must be -1 for infinite and > 0" ))
{
CVehicle *pVehicle = 0;
CTask* pTask;
{
if(iVehicleID!=NULL_IN_SCRIPTING_LANGUAGE)
{
pVehicle = CTheScripts::GetEntityToModifyFromGUID<CVehicle>(iVehicleID, CTheScripts::GUID_ASSERT_FLAGS_INCLUDE_CLONES);
if(!pVehicle)
return;
}
if(pVehicle)
{
if(iPedID!=NULL_IN_SCRIPTING_LANGUAGE)
{
CPed *pPed = CTheScripts::GetEntityToModifyFromGUID<CPed>(iPedID, CTheScripts::GUID_ASSERT_FLAGS_NO_DEAD_CHECK & CTheScripts::GUID_ASSERT_FLAGS_INCLUDE_CLONES);
if(pPed && NetworkUtils::IsNetworkCloneOrMigrating(pPed))
{
netObject* pNetObj = pPed->GetNetworkObject();
if(pNetObj)
{
CScriptEntityStateChangeEvent::CSettingOfTaskVehicleTempAction parameters(pVehicle->GetNetworkObject(),iAction,iTime);
CScriptEntityStateChangeEvent::Trigger(pNetObj, parameters);
}
}
else
{
if (NetworkInterface::IsGameInProgress() && iPedID==NULL_IN_SCRIPTING_LANGUAGE)
{
scriptAssertf(0, "TASK_VEHICLE_TEMP_ACTION - temp actions cannot be added to a sequence in MP");
return;
}
pTask=rage_new CTaskCarSetTempAction(pVehicle,iAction,iTime);
CScriptPeds::GivePedScriptedTask( iPedID, pTask, SCRIPT_TASK_VEHICLE_TEMP_ACTION, "TASK_VEHICLE_TEMP_ACTION");
}
}
}
}
}
}
void CommandTaskVehicleMission_Internal( int iPedID, int iVehicleID, int iTargetVehicleID,
int iMission, float fCruiseSpeed, int iDrivingStyle, float fTargetReached, float fStraightLineDistance, bool bAllowedToGoAgainstTraffic, Vector3* vTarget)
{
CVehicle *pVehicle=0;
if(NULL_IN_SCRIPTING_LANGUAGE!=iVehicleID)
{
pVehicle = CTheScripts::GetEntityToModifyFromGUID<CVehicle>(iVehicleID, CTheScripts::GUID_ASSERT_FLAGS_INCLUDE_CLONES);
}
if(!SCRIPT_VERIFY(pVehicle, "TASK_VEHICLE_MISSION needs a valid vehicle!"))
return;
CVehicle *pTargetVehicle = NULL;
if (NULL_IN_SCRIPTING_LANGUAGE!=iTargetVehicleID)
{
pTargetVehicle = CTheScripts::GetEntityToModifyFromGUID<CVehicle>(iTargetVehicleID, CTheScripts::GUID_ASSERT_FLAGS_INCLUDE_CLONES);
if(!pTargetVehicle)
return;
}
if (fStraightLineDistance < 0.0f)
{
fStraightLineDistance = sVehicleMissionParams::DEFAULT_SWITCH_TO_STRAIGHT_LINE_DIST;
}
fStraightLineDistance = MIN(255.0f, fStraightLineDistance);
if (fTargetReached < 0.0f)
{
fTargetReached = sVehicleMissionParams::DEFAULT_TARGET_REACHED_DIST;
}
#if __ASSERT if (iMission == MISSION_CRASH) { VehicleType vehicleType = pVehicle->GetVehicleType(); if (vehicleType != VEHICLE_TYPE_PLANE && vehicleType != VEHICLE_TYPE_HELI && vehicleType != VEHICLE_TYPE_BLIMP && vehicleType != VEHICLE_TYPE_AUTOGYRO) { scriptErrorf("%s:%s Non PLANE, HELI, BLIMP or AUTOGYRO has been told to crash", CTheScripts::GetCurrentScriptNameAndProgramCounter(), "TASK_VEHICLE_MISSION"); } } #endif //__ASSERT
aiTask *pCarTask = CVehicleIntelligence::GetTaskFromMissionIdentifier(pVehicle, iMission, pTargetVehicle, vTarget, iDrivingStyle, fTargetReached, fStraightLineDistance, fCruiseSpeed, bAllowedToGoAgainstTraffic);
CTask* pTask = rage_new CTaskControlVehicle(pVehicle, pCarTask);
CScriptPeds::GivePedScriptedTask( iPedID, pTask, SCRIPT_TASK_VEHICLE_MISSION, "TASK_VEHICLE_MISSION");
}
void CommandTaskVehicleMission( int iPedID, int iVehicleID, int iTargetVehicleID,
int iMission, float fCruiseSpeed, int iDrivingStyle, float fTargetReached, float fStraightLineDistance, bool bDriveAgainstTraffic)
{
CommandTaskVehicleMission_Internal(iPedID, iVehicleID, iTargetVehicleID, iMission, fCruiseSpeed, iDrivingStyle, fTargetReached, fStraightLineDistance, bDriveAgainstTraffic, NULL);
}
void CommandTaskVehicleMissionPedTarget_Internal( int iPedID, int iVehicleID, int iTargetPedID,
int iMission, float fCruiseSpeed, int iDrivingStyle, float fTargetReached, float fStraightLineDistance, bool bAllowedToGoAgainstTraffic)
{
CVehicle *pVehicle=0;
if(NULL_IN_SCRIPTING_LANGUAGE!=iVehicleID)
{
pVehicle = CTheScripts::GetEntityToModifyFromGUID<CVehicle>(iVehicleID, CTheScripts::GUID_ASSERT_FLAGS_INCLUDE_CLONES);
if(!pVehicle)
return;
}
CPed *pTargetPed = NULL;
if (NULL_IN_SCRIPTING_LANGUAGE!=iTargetPedID)
{
pTargetPed = CTheScripts::GetEntityToModifyFromGUID<CPed>(iTargetPedID, CTheScripts::GUID_ASSERT_FLAGS_INCLUDE_CLONES);
if(!pTargetPed)
return;
}
if (fStraightLineDistance < 0.0f)
{
fStraightLineDistance = sVehicleMissionParams::DEFAULT_SWITCH_TO_STRAIGHT_LINE_DIST;
}
fStraightLineDistance = MIN(255.0f, fStraightLineDistance);
if (fTargetReached < 0.0f)
{
fTargetReached = sVehicleMissionParams::DEFAULT_TARGET_REACHED_DIST;
}
#if __ASSERT if (iMission == MISSION_CRASH) { VehicleType vehicleType = pVehicle->GetVehicleType(); if (vehicleType != VEHICLE_TYPE_PLANE && vehicleType != VEHICLE_TYPE_HELI && vehicleType != VEHICLE_TYPE_BLIMP && vehicleType != VEHICLE_TYPE_AUTOGYRO) { scriptErrorf("%s:%s Non PLANE, HELI, BLIMP or AUTOGYRO has been told to crash", CTheScripts::GetCurrentScriptNameAndProgramCounter(), "TASK_VEHICLE_MISSION_PED_TARGET"); } } #endif //__ASSERT
aiTask *pCarTask = CVehicleIntelligence::GetTaskFromMissionIdentifier(pVehicle, iMission, pTargetPed, NULL, iDrivingStyle, fTargetReached, fStraightLineDistance, fCruiseSpeed, bAllowedToGoAgainstTraffic);
CTask* pTask = rage_new CTaskControlVehicle(pVehicle, pCarTask);
CScriptPeds::GivePedScriptedTask( iPedID, pTask, SCRIPT_TASK_VEHICLE_MISSION, "TASK_VEHICLE_MISSION_PED_TARGET");
}
void CommandTaskVehicleMissionPedTarget( int iPedID, int iVehicleID, int iTargetPedID,
int iMission, float fCruiseSpeed, int iDrivingStyle, float fTargetReached, float fStraightLineDistance, bool bDriveAgainstTraffic)
{
CommandTaskVehicleMissionPedTarget_Internal( iPedID, iVehicleID, iTargetPedID,
iMission, fCruiseSpeed, iDrivingStyle, fTargetReached, fStraightLineDistance, bDriveAgainstTraffic);
}
void CommandTaskVehicleMissionCoorsTarget( int iPedID, int iVehicleID, const scrVector & scrVecCoors,
int iMission, float fCruiseSpeed, int iDrivingStyle, float fTargetReached, float fStraightLineDistance, bool bDriveAgainstTraffic)
{
Vector3 VecCoors = Vector3 (scrVecCoors);
CommandTaskVehicleMission_Internal( iPedID, iVehicleID, NULL_IN_SCRIPTING_LANGUAGE,
iMission, fCruiseSpeed, iDrivingStyle, fTargetReached, fStraightLineDistance, bDriveAgainstTraffic, &VecCoors);
}
void AddVehicleSubtaskInternal(int iPedID, CTask* pSubTask, const char* ASSERT_ONLY(szTaskName))
{
if(NULL_IN_SCRIPTING_LANGUAGE!=iPedID)
{
CPed *pPed = CTheScripts::GetEntityToModifyFromGUID<CPed>(iPedID);
if( !pPed )
{
delete pSubTask;
return;
}
CEventScriptCommand* pEvent = static_cast<CEventScriptCommand*>(pPed->GetPedIntelligence()->GetEventOfType(EVENT_SCRIPT_COMMAND));
if( !scriptVerifyf(pEvent, "%s:%s - You must have previously given the ped a valid driving task!", CTheScripts::GetCurrentScriptNameAndProgramCounter(), szTaskName) )
{
delete pSubTask;
return;
}
aiTask* pTask = pEvent->GetTask();
if( !scriptVerifyf(pTask && (pTask->GetTaskType() == CTaskTypes::TASK_CONTROL_VEHICLE || pTask->GetTaskType() == CTaskTypes::TASK_CAR_DRIVE_POINT_ROUTE), "%s:%s - You must have previously given the ped a valid driving task!", CTheScripts::GetCurrentScriptNameAndProgramCounter(), szTaskName) )
{
delete pSubTask;
return;
}
if( pTask->GetTaskType() == CTaskTypes::TASK_CONTROL_VEHICLE )
{
CTaskControlVehicle* pVehicleTask = static_cast<CTaskControlVehicle*>(pTask);
pVehicleTask->SetDesiredSubtask(pSubTask);
}
else if( pTask->GetTaskType() == CTaskTypes::TASK_CAR_DRIVE_POINT_ROUTE )
{
CTaskDrivePointRoute* pVehicleTask = static_cast<CTaskDrivePointRoute*>(pTask);
pVehicleTask->SetDesiredSubtask(pSubTask);
}
else
{
#if __ASSERT scriptErrorf( "%s:%s unknown task type", CTheScripts::GetCurrentScriptNameAndProgramCounter(), szTaskName); #endif delete pSubTask; return; }
}
// Add task to last sequence thats open
else
{
if( !scriptVerifyf(CTaskSequences::ms_iActiveSequence >=0 && CTaskSequences::ms_iActiveSequence<CTaskSequences::MAX_NUM_SEQUENCE_TASKS, "%s:%s Sequence task closed", CTheScripts::GetCurrentScriptNameAndProgramCounter(), szTaskName))
{
delete pSubTask;
return;
}
// Add task to sequence
if( !scriptVerifyf(CTaskSequences::ms_bIsOpened[CTaskSequences::ms_iActiveSequence], "%s:%s Sequence task closed", CTheScripts::GetCurrentScriptNameAndProgramCounter(), szTaskName) )
{
delete pSubTask;
return;
}
aiTask* pTask = CTaskSequences::ms_TaskSequenceLists[CTaskSequences::ms_iActiveSequence].GetLastAddedTask();
if( scriptVerifyf(pTask && (pTask->GetTaskType() == CTaskTypes::TASK_CONTROL_VEHICLE || pTask->GetTaskType() == CTaskTypes::TASK_CAR_DRIVE_POINT_ROUTE), "%s:%s Last task added to sequence not a valid driving task", CTheScripts::GetCurrentScriptNameAndProgramCounter(), szTaskName ) )
{
if( pTask->GetTaskType() == CTaskTypes::TASK_CONTROL_VEHICLE )
{
CTaskControlVehicle* pVehicleTask = static_cast<CTaskControlVehicle*>(pTask);
pVehicleTask->SetDesiredSubtask(pSubTask);
}
else if( pTask->GetTaskType() == CTaskTypes::TASK_CAR_DRIVE_POINT_ROUTE )
{
CTaskDrivePointRoute* pVehicleTask = static_cast<CTaskDrivePointRoute*>(pTask);
pVehicleTask->SetDesiredSubtask(pSubTask);
}
else
{
#if __ASSERT scriptErrorf( "%s:%s unknown task type", CTheScripts::GetCurrentScriptNameAndProgramCounter(), szTaskName); #endif delete pSubTask; return; } } else { delete pSubTask; } } }
void CommandAddVehicleSubtaskAttackCoord( int iPedID, const scrVector & scrVecCoors )
{
Vector3 vTarget(scrVecCoors);
CAITarget target(vTarget);
AddVehicleSubtaskInternal(iPedID, rage_new CTaskVehicleCombat(&target), "ADD_VEHICLE_SUBTASK_ATTACK_COORD");
}
void CommandAddVehicleSubtaskAttackPed( int iPedID, int iOtherPedID )
{
CPed* pOtherPed = CTheScripts::GetEntityToModifyFromGUID<CPed>(iOtherPedID);
if( !pOtherPed )
{
return;
}
CAITarget target(pOtherPed);
AddVehicleSubtaskInternal(iPedID, rage_new CTaskVehicleCombat(&target), "ADD_VEHICLE_SUBTASK_ATTACK_PED");
}
void CommandTaskHeliMission( int iPedID, int iVehicleID, int iTargetVehicleID, int iTargetPedID, const scrVector & scrVecCoors,
int iMission, float fCruiseSpeed, float fTargetReached, float fHeliOrientation, int iFlightHeight, int iMinHeightAboveTerrain, float fSlowDownDistance, int iHeliFlags)
{
CVehicle *pVehicle=0;
Vector3 VecTargetCoors = Vector3 (scrVecCoors);
if(SCRIPT_VERIFY(NULL_IN_SCRIPTING_LANGUAGE!=iVehicleID, "TASK_HELI_MISSION - You must specify a heli to be flown"))
{
pVehicle = CTheScripts::GetEntityToModifyFromGUID<CVehicle>(iVehicleID, CTheScripts::GUID_ASSERT_FLAGS_INCLUDE_CLONES);
if(!pVehicle)
return;
if(!SCRIPT_VERIFY(pVehicle->GetVehicleType() == VEHICLE_TYPE_HELI, "TASK_HELI_MISSION - Vehicle to be used (2nd parameter) is not actually a heli"))
return;
}
else
{
return;
}
CPhysical* pPhysical = NULL;
const CVehicle *pTargetVehicle = NULL;
if (NULL_IN_SCRIPTING_LANGUAGE!=iTargetVehicleID)
{
pTargetVehicle = CTheScripts::GetEntityToQueryFromGUID<CVehicle>(iTargetVehicleID);
if(!pTargetVehicle)
return;
pPhysical = const_cast<CVehicle*>(pTargetVehicle);
}
const CPed *pTargetPed = NULL;
if (NULL_IN_SCRIPTING_LANGUAGE!=iTargetPedID)
{
pTargetPed = CTheScripts::GetEntityToQueryFromGUID<CPed>(iTargetPedID);
if(!pTargetPed)
return;
pPhysical = const_cast<CPed*>(pTargetPed);
}
if (fTargetReached < 0.0f)
{
fTargetReached = sVehicleMissionParams::DEFAULT_TARGET_REACHED_DIST;
}
if (fHeliOrientation < 0.0f)
{
fHeliOrientation = -1.0f;
}
else
{
fHeliOrientation = ( DtoR * fHeliOrientation);
// For whatever reason the helicopter AI treats the X axis as 0, so we have to rotate a Y axis heading request by 90
fHeliOrientation += 90.0f*DtoR;
}
aiTask *pHeliTask = CVehicleIntelligence::GetHeliTaskFromMissionIdentifier(pVehicle, iMission, pPhysical, &VecTargetCoors, fTargetReached, fCruiseSpeed, fHeliOrientation, iFlightHeight, iMinHeightAboveTerrain, fSlowDownDistance, iHeliFlags);
CTask* pTask = rage_new CTaskControlVehicle(pVehicle, pHeliTask);
CScriptPeds::GivePedScriptedTask( iPedID, pTask, SCRIPT_TASK_VEHICLE_MISSION, "TASK_HELI_MISSION");
}
void CommandTaskHeliEscort( int iPedID, int iVehicleID, int iTargetVehicleID, const scrVector & offsetVec)
{
CVehicle *pVehicle=0;
CVehicle *pTargetVehicle=0;
if(SCRIPT_VERIFY(NULL_IN_SCRIPTING_LANGUAGE!=iVehicleID, "TASK_HELI_ESCORT_HELI - You must specify a heli to be flown"))
{
pVehicle = CTheScripts::GetEntityToModifyFromGUID<CVehicle>(iVehicleID, CTheScripts::GUID_ASSERT_FLAGS_INCLUDE_CLONES);
if(!pVehicle)
return;
if(!SCRIPT_VERIFY(pVehicle->GetVehicleType() == VEHICLE_TYPE_HELI, "TASK_HELI_ESCORT_HELI - Vehicle to be used (2nd parameter) is not actually a heli"))
return;
}
else
{
return;
}
if(SCRIPT_VERIFY(NULL_IN_SCRIPTING_LANGUAGE!=iTargetVehicleID, "TASK_HELI_ESCORT_HELI - You must specify a heli to be targetted"))
{
pTargetVehicle = CTheScripts::GetEntityToModifyFromGUID<CVehicle>(iTargetVehicleID, CTheScripts::GUID_ASSERT_FLAGS_INCLUDE_CLONES);
if(!pTargetVehicle)
return;
if(!SCRIPT_VERIFY(pTargetVehicle->GetVehicleType() == VEHICLE_TYPE_HELI, "TASK_HELI_ESCORT_HELI - Vehicle to be targetted (2nd parameter) is not actually a heli"))
return;
}
else
{
return;
}
Vector3 vOffset(offsetVec);
sVehicleMissionParams params;
params.SetTargetEntity(pTargetVehicle);
params.SetTargetPosition(vOffset);
CTaskVehicleEscort *pHeliTask = rage_new CTaskVehicleEscort(params, CTaskVehicleEscort::VEHICLE_ESCORT_HELI);
CTask* pTask = rage_new CTaskControlVehicle(pVehicle, pHeliTask);
CScriptPeds::GivePedScriptedTask( iPedID, pTask, SCRIPT_TASK_VEHICLE_MISSION, "TASK_HELI_ESCORT_HELI");
}
void CommandTaskPlaneMission( int iPedID, int iVehicleID, int iTargetVehicleID, int iTargetPedID, const scrVector & scrVecCoors,
int iMission, float fCruiseSpeed, float fTargetReached, float fOrientation, int iFlightHeight, int iMinHeightAboveTerrain, bool bPrecise)
{
CVehicle *pVehicle=0;
Vector3 VecTargetCoors = Vector3 (scrVecCoors);
if(SCRIPT_VERIFY(NULL_IN_SCRIPTING_LANGUAGE!=iVehicleID, "TASK_PLANE_MISSION - You must specify a plane to be flown"))
{
pVehicle = CTheScripts::GetEntityToModifyFromGUID<CVehicle>(iVehicleID, CTheScripts::GUID_ASSERT_FLAGS_INCLUDE_CLONES);
if(!pVehicle)
return;
if(!SCRIPT_VERIFY(pVehicle->GetVehicleType() == VEHICLE_TYPE_PLANE, "TASK_PLANE_MISSION - Vehicle to be used (2nd parameter) is not actually a plane"))
return;
}
else
{
return;
}
CPhysical* pPhysical = NULL;
const CVehicle *pTargetVehicle = NULL;
if (NULL_IN_SCRIPTING_LANGUAGE!=iTargetVehicleID)
{
pTargetVehicle = CTheScripts::GetEntityToQueryFromGUID<CVehicle>(iTargetVehicleID);
if(!pTargetVehicle)
return;
pPhysical = const_cast<CVehicle*>(pTargetVehicle);
}
const CPed *pTargetPed = NULL;
if (NULL_IN_SCRIPTING_LANGUAGE!=iTargetPedID)
{
pTargetPed = CTheScripts::GetEntityToQueryFromGUID<CPed>(iTargetPedID);
if(!pTargetPed)
return;
pPhysical = const_cast<CPed*>(pTargetPed);
}
if (fTargetReached < 0.0f)
{
fTargetReached = sVehicleMissionParams::DEFAULT_TARGET_REACHED_DIST;
}
if (fOrientation < 0.0f)
{
fOrientation = -1.0f;
}
else
{
fOrientation = ( DtoR * fOrientation);
// For whatever reason the helicopter AI treats the X axis as 0, so we have to rotate a Y axis heading request by 90
fOrientation += 90.0f*DtoR;
}
aiTask *pPlaneTask = CVehicleIntelligence::GetPlaneTaskFromMissionIdentifier(pVehicle, iMission, pPhysical, &VecTargetCoors, fTargetReached, fCruiseSpeed, fOrientation, iFlightHeight, iMinHeightAboveTerrain, bPrecise);
if( pPlaneTask )
{
CTask* pTask = rage_new CTaskControlVehicle(pVehicle, pPlaneTask);
CScriptPeds::GivePedScriptedTask( iPedID, pTask, SCRIPT_TASK_VEHICLE_MISSION, "TASK_PLANE_MISSION");
}
}
void CommandTaskPlaneTaxi(int iPedID, int iVehicleID, const scrVector& scrVecCoors, float fCruiseSpeed, float fTargetReached)
{
CVehicle *pVehicle=0;
Vector3 VecTargetCoors = Vector3 (scrVecCoors);
if(SCRIPT_VERIFY(NULL_IN_SCRIPTING_LANGUAGE!=iVehicleID, "TASK_PLANE_TAXI - You must specify a plane to taxi"))
{
pVehicle = CTheScripts::GetEntityToModifyFromGUID<CVehicle>(iVehicleID, CTheScripts::GUID_ASSERT_FLAGS_INCLUDE_CLONES);
if(!pVehicle)
return;
if(!SCRIPT_VERIFY(pVehicle->GetVehicleType() == VEHICLE_TYPE_PLANE, "TASK_PLANE_TAXI - Vehicle to be used (2nd parameter) is not actually a plane"))
return;
}
else
{
return;
}
if (fTargetReached < 0.0f)
{
fTargetReached = sVehicleMissionParams::DEFAULT_TARGET_REACHED_DIST;
}
sVehicleMissionParams params;
params.SetTargetPosition(VecTargetCoors);
params.m_fTargetArriveDist = fTargetReached;
params.m_fCruiseSpeed = fCruiseSpeed;
aiTask* pGotoTask = rage_new CTaskVehicleGoToPointAutomobile(params);
if( pGotoTask )
{
CTask* pTask = rage_new CTaskControlVehicle(pVehicle, pGotoTask);
CScriptPeds::GivePedScriptedTask( iPedID, pTask, SCRIPT_TASK_VEHICLE_MISSION, "TASK_PLANE_TAXI");
}
}
void CommandTaskBoatMission( int iPedID, int iVehicleID, int iTargetVehicleID, int iTargetPedID, const scrVector & scrVecCoors,
int iMission, float fCruiseSpeed, int iDrivingStyle, float fTargetReached, int iBoatFlags)
{
CVehicle *pVehicle=0;
Vector3 VecTargetCoors = Vector3 (scrVecCoors);
if(SCRIPT_VERIFY(NULL_IN_SCRIPTING_LANGUAGE!=iVehicleID, "TASK_BOAT_MISSION - You must specify a boat"))
{
pVehicle = CTheScripts::GetEntityToModifyFromGUID<CVehicle>(iVehicleID, CTheScripts::GUID_ASSERT_FLAGS_INCLUDE_CLONES);
if(!pVehicle)
return;
if(!SCRIPT_VERIFY(pVehicle->GetVehicleType() == VEHICLE_TYPE_BOAT, "TASK_BOAT_MISSION - Vehicle to be used (2nd parameter) is not actually a boat"))
return;
}
else
{
return;
}
CPhysical* pPhysical = NULL;
const CVehicle *pTargetVehicle = NULL;
if (NULL_IN_SCRIPTING_LANGUAGE!=iTargetVehicleID)
{
pTargetVehicle = CTheScripts::GetEntityToQueryFromGUID<CVehicle>(iTargetVehicleID);
if(!pTargetVehicle)
return;
pPhysical = const_cast<CVehicle*>(pTargetVehicle);
}
const CPed *pTargetPed = NULL;
if (NULL_IN_SCRIPTING_LANGUAGE!=iTargetPedID)
{
pTargetPed = CTheScripts::GetEntityToQueryFromGUID<CPed>(iTargetPedID);
if(!pTargetPed)
return;
pPhysical = const_cast<CPed*>(pTargetPed);
}
if (fTargetReached < 0.0f)
{
fTargetReached = sVehicleMissionParams::DEFAULT_TARGET_REACHED_DIST;
}
aiTask *pBoatTask = CVehicleIntelligence::GetBoatTaskFromMissionIdentifier(pVehicle, iMission, pPhysical, &VecTargetCoors, iDrivingStyle, fTargetReached, fCruiseSpeed, iBoatFlags);
if( pBoatTask )
{
CTask* pTask = rage_new CTaskControlVehicle(pVehicle, pBoatTask);
CScriptPeds::GivePedScriptedTask( iPedID, pTask, SCRIPT_TASK_VEHICLE_MISSION, "TASK_BOAT_MISSION");
}
}
void CommandTaskVehiclePark( int iPedID, int iVehicleID, const scrVector & vecMoveTarget, float HeadingDegrees, int ParkType, float ToleranceDegrees, bool bKeepLightsOn)
{
CVehicle* pVehicle = NULL;
Vector3 VecTargetCoors = Vector3 (vecMoveTarget);
if(SCRIPT_VERIFY(NULL_IN_SCRIPTING_LANGUAGE != iVehicleID, "TASK_VEHICLE_PARK - You must specify a vehicle to be parked"))
{
pVehicle = CTheScripts::GetEntityToModifyFromGUID<CVehicle>(iVehicleID, CTheScripts::GUID_ASSERT_FLAGS_INCLUDE_CLONES);
}
if(!pVehicle)
{
return;
}
const float HeadingRadians = HeadingDegrees*DtoR;
Vector3 direction;
direction.x = -rage::Sinf(HeadingRadians);
direction.y = rage::Cosf(HeadingRadians);
direction.z = 0.0f;
sVehicleMissionParams params;
params.SetTargetPosition(VecTargetCoors);
CTaskVehicleParkNew* pParkTask = rage_new CTaskVehicleParkNew(params, direction, (CTaskVehicleParkNew::ParkType)ParkType, ToleranceDegrees*DtoR, bKeepLightsOn);
CTask* pTask = rage_new CTaskControlVehicle(pVehicle, pParkTask);
CScriptPeds::GivePedScriptedTask( iPedID, pTask, SCRIPT_TASK_VEHICLE_PARK, "TASK_VEHICLE_PARK");
}
void CommandTaskStealthKill( int iPedID, int iTargetPedID, int iStealthKillActionResultId, float fDesiredMoveBlendRatio, int iStealthFlags )
{
if( iPedID != NULL_IN_SCRIPTING_LANGUAGE )
{
// Apparently sequence tasks rely on the iPedID to be NULL
CPed* pPed = CTheScripts::GetEntityToModifyFromGUID<CPed>(iPedID);
if( pPed )
{
// Check to make sure the ped has a weapon equipped
const CWeaponInfo* pEquippedWeaponInfo = pPed->GetWeaponManager()->GetEquippedWeaponInfo();
if( !SCRIPT_VERIFY( pEquippedWeaponInfo, "TASK_STEALTH_KILL - The ped doesn't have a weapon equipped. Please use GIVE_WEAPON_TO_PED" ) )
{
return;
}
}
}
// Ensure target ped is valid
CPed* pTargetPed = CTheScripts::GetEntityToModifyFromGUID<CPed>(iTargetPedID);
if( !SCRIPT_VERIFY( pTargetPed, "TASK_STEALTH_KILL - The target ped is invalid." ) )
{
return;
}
// Check to make sure the ped has a weapon equipped
const CWeaponInfo* pTargetEquippedWeaponInfo = pTargetPed->GetWeaponManager()->GetEquippedWeaponInfo();
if( !SCRIPT_VERIFY( pTargetEquippedWeaponInfo, "TASK_STEALTH_KILL - The target ped doesn't have a weapon equipped. Please use GIVE_WEAPON_TO_PED" ) )
{
return;
}
// Ensure the stealth kill id is valid
u32 uActionIdx = 0;
const CActionResult* pStealthKillActionResult = ACTIONMGR.FindActionResult( uActionIdx, (u32)iStealthKillActionResultId );
if( !SCRIPT_VERIFY( pStealthKillActionResult, "TASK_STEALTH_KILL - Invalid stealth kill action." ) )
{
return;
}
CTask* pTask = rage_new CTaskStealthKill( pTargetPed, pStealthKillActionResult, fDesiredMoveBlendRatio, iStealthFlags );
CScriptPeds::GivePedScriptedTask( iPedID, pTask, SCRIPT_TASK_STEALTH_KILL, "TASK_STEALTH_KILL" );
}
void CommandTaskPlantBomb( int iPedID, const scrVector &, float )
{
if( iPedID != NULL_IN_SCRIPTING_LANGUAGE )
{
// Apparently sequence tasks rely on the iPedID to be NULL
CPed* pPed = CTheScripts::GetEntityToModifyFromGUID<CPed>(iPedID);
if( pPed )
{
// Check to make sure the ped has a weapon equipped
const CWeaponInfo* pEquippedWeaponInfo = pPed->GetWeaponManager()->GetEquippedWeaponInfo();
if( !SCRIPT_VERIFY( pEquippedWeaponInfo && pEquippedWeaponInfo->GetProjectileCanBePlaced(), "TASK_PLANT_BOMB - The ped doesn't have a weapon that can be placed. Please use GIVE_WEAPON_TO_PED" ) )
{
return;
}
}
}
CTask* pTask = rage_new CTaskBomb();
CScriptPeds::GivePedScriptedTask( iPedID, pTask, SCRIPT_TASK_PLANT_BOMB, "TASK_PLANT_BOMB" );
}
void CommandTaskSharkCircleCoord(int iPedID, const scrVector & vCoord, float fMBR, float fRadius)
{
CAITarget aiTarget;
aiTarget.SetPosition(vCoord);
float fSpeed = CTaskSharkAttack::GetTunables().m_CirclingAngularSpeed;
CTask* pTask = rage_new CTaskComplexControlMovement(rage_new CTaskSharkCircle(fMBR, aiTarget, fRadius, fSpeed));
CScriptPeds::GivePedScriptedTask(iPedID, pTask, SCRIPT_TASK_SHARK_CIRCLE_COORD, "TASK_SHARK_CIRCLE_COORD");
}
void CommandTaskSharkCirclePed(int iPedID, int iOtherPedID, float fMBR, float fRadius)
{
CAITarget aiTarget;
const CPed* pOtherPed = CTheScripts::GetEntityToQueryFromGUID<CPed>(iOtherPedID);
aiTarget.SetEntity(pOtherPed);
float fSpeed = CTaskSharkAttack::GetTunables().m_CirclingAngularSpeed;
CTask* pTask = rage_new CTaskComplexControlMovement(rage_new CTaskSharkCircle(fMBR, aiTarget, fRadius, fSpeed));
CScriptPeds::GivePedScriptedTask(iPedID, pTask, SCRIPT_TASK_SHARK_CIRCLE_PED, "TASK_SHARK_CIRCLE_COORD");
}
void CommandTaskPlaneGotoPreciseVtol(int iPedID, int iVehicleID, const scrVector & vecMoveTarget, int iFlightHeight, int iMinHeightAboveTerrain, bool bUseDesiredOrientation, float fDesiredOrientation, bool bAutoPilot)
{
CVehicle* pVehicle = NULL;
Vector3 VecTargetCoors = Vector3 (vecMoveTarget);
if(SCRIPT_VERIFY(NULL_IN_SCRIPTING_LANGUAGE != iVehicleID, "TASK_PLANE_GOTO_PRECISE_VTOL - You must specify a vehicle to be parked"))
{
pVehicle = CTheScripts::GetEntityToModifyFromGUID<CVehicle>(iVehicleID);
}
if(!pVehicle)
{
return;
}
if (!SCRIPT_VERIFY(pVehicle->InheritsFromPlane(), "TASK_PLANE_GOTO_PRECISE_VTOL - Must be used on a plane"))
{
return;
}
CPlane* pPlane = static_cast<CPlane*>(pVehicle);
if (!SCRIPT_VERIFY(pPlane->GetVerticalFlightModeAvaliable(), "TASK_PLANE_GOTO_PRECISE_VTOL - Plane must support VTOL (vertical takeoff and landing)"))
{
return;
}
sVehicleMissionParams params;
params.SetTargetPosition(VecTargetCoors);
fDesiredOrientation *= DtoR;
fDesiredOrientation += 90.0f*DtoR;
fDesiredOrientation = fwAngle::LimitRadianAngleSafe(fDesiredOrientation);
if (bAutoPilot)
{
params.m_iDrivingFlags.SetFlag(DF_DontTerminateTaskWhenAchieved);
}
CTaskVehicleGoToPlane* pPlaneTask = rage_new CTaskVehicleGoToPlane(params, iFlightHeight, iMinHeightAboveTerrain, true, bUseDesiredOrientation, fDesiredOrientation);
if (bAutoPilot)
{
// Apply task directly to the vehicle
pVehicle->GetIntelligence()->GetTaskManager()->SetTask(VEHICLE_TASK_TREE_PRIMARY, pPlaneTask, VEHICLE_TASK_PRIORITY_PRIMARY, false);
pVehicle->GetIntelligence()->SetUsingScriptAutopilot(true);
CVehicleNodeList * pNodeList = pVehicle->GetIntelligence()->GetNodeList();
if(pNodeList)
{
pNodeList->ClearPathNodes();
}
pVehicle->SwitchEngineOn(true);
}
else
{
// Apply task to the ped as part of CTaskControlVehicle
CTask* pTask = rage_new CTaskControlVehicle(pVehicle, pPlaneTask);
CScriptPeds::GivePedScriptedTask( iPedID, pTask, SCRIPT_TASK_VEHICLE_MISSION, "TASK_PLANE_GOTO_PRECISE_VTOL");
}
}
void CommandTaskSubmarineGotoAndStop(int iPedID, int iVehicleID, const scrVector & vecMoveTarget, bool bAutoPilot)
{
CVehicle* pVehicle = NULL;
Vector3 VecTargetCoors = Vector3 (vecMoveTarget);
if(SCRIPT_VERIFY(NULL_IN_SCRIPTING_LANGUAGE != iVehicleID, "TASK_PLANE_GOTO_PRECISE_VTOL - You must specify a vehicle to be parked"))
{
pVehicle = CTheScripts::GetEntityToModifyFromGUID<CVehicle>(iVehicleID);
}
if(!pVehicle)
{
return;
}
sVehicleMissionParams params;
params.SetTargetPosition(VecTargetCoors);
s32 subFlags = 0;
if (bAutoPilot)
{
params.m_iDrivingFlags.SetFlag(DF_DontTerminateTaskWhenAchieved);
subFlags = CTaskVehicleGoToSubmarine::SF_HoverAtEnd;
params.m_fTargetArriveDist = 30.0f;
}
CTaskVehicleGoToSubmarine* pSubTask = rage_new CTaskVehicleGoToSubmarine(params, subFlags);
if (bAutoPilot)
{
// Apply task directly to the vehicle
pVehicle->GetIntelligence()->GetTaskManager()->SetTask(VEHICLE_TASK_TREE_PRIMARY, pSubTask, VEHICLE_TASK_PRIORITY_PRIMARY, false);
pVehicle->GetIntelligence()->SetUsingScriptAutopilot(true);
CVehicleNodeList * pNodeList = pVehicle->GetIntelligence()->GetNodeList();
if(pNodeList)
{
pNodeList->ClearPathNodes();
}
pVehicle->SwitchEngineOn(true);
}
else
{
// Apply task to the ped as part of CTaskControlVehicle
CTask* pTask = rage_new CTaskControlVehicle(pVehicle, pSubTask);
CScriptPeds::GivePedScriptedTask( iPedID, pTask, SCRIPT_TASK_VEHICLE_MISSION, "TASK_SUBMARINE_GOTO_AND_STOP");
}
}
void CommandClearDefaultPrimaryTask(int iPedID)
{
if (SCRIPT_VERIFY(NULL_IN_SCRIPTING_LANGUAGE != iPedID, "CLEAR_DEFAULT_PRIMARY_TASK - Can't have a NULL ped"))
{
if (CPed* pPed = CTheScripts::GetEntityToModifyFromGUID<CPed>(iPedID))
{
AI_LOG_WITH_ARGS("[Script] - Script %s has restarted the default primary task for ped %s", CTheScripts::GetCurrentScriptName(), AILogging::GetDynamicEntityNameSafe(pPed));
pPed->GetPedIntelligence()->AddTaskDefault(pPed->ComputeDefaultTask(*pPed));
}
}
}
void CommandClearPrimaryVehicleTask( int iVehicleID )
{
CVehicle* pVehicle = NULL;
pVehicle = CTheScripts::GetEntityToModifyFromGUID<CVehicle>(iVehicleID);
if (SCRIPT_VERIFYF(pVehicle, "CLEAR_PRIMARY_VEHICLE_TASK - Could not find vehicle with provided ID %i", iVehicleID))
{
if (pVehicle->GetIntelligence() && pVehicle->GetIntelligence()->GetTaskManager())
{
pVehicle->GetIntelligence()->GetTaskManager()->ClearTask(VEHICLE_TASK_TREE_PRIMARY, VEHICLE_TASK_PRIORITY_PRIMARY);
}
}
}
void CommandClearVehicleCrashTask( int iVehicleID )
{
CVehicle* pVehicle = NULL;
pVehicle = CTheScripts::GetEntityToModifyFromGUID<CVehicle>(iVehicleID);
if (SCRIPT_VERIFYF(pVehicle, "CLEAR_VEHICLE_CRASH_TASK - Could not find vehicle with provided ID %i", iVehicleID))
{
if (pVehicle->GetIntelligence() && pVehicle->GetIntelligence()->GetTaskManager())
{
pVehicle->GetIntelligence()->GetTaskManager()->ClearTask(VEHICLE_TASK_TREE_PRIMARY, VEHICLE_TASK_PRIORITY_CRASH);
}
}
}
void CommandTaskVehicleEscort( int iPedID, int iVehicleID, int iEscortEntityID, int iEscortType, float fCruiseSpeed, int iDrivingFlags, float fCustomOffset, int iMinHeightAboveTerrain, float fStraightLineDist)
{
CVehicle* pVehicle = NULL;
if(SCRIPT_VERIFY(NULL_IN_SCRIPTING_LANGUAGE != iVehicleID, "TASK_VEHICLE_ESCORT - You must specify a vehicle to drive"))
{
pVehicle = CTheScripts::GetEntityToModifyFromGUID<CVehicle>(iVehicleID, CTheScripts::GUID_ASSERT_FLAGS_INCLUDE_CLONES);
}
if(!pVehicle)
{
return;
}
CEntity *pEntity = CTheScripts::GetEntityToModifyFromGUID<CEntity>(iEscortEntityID, CTheScripts::GUID_ASSERT_FLAGS_INCLUDE_CLONES);
if (!pEntity)
{
return;
}
sVehicleMissionParams params;
params.m_iDrivingFlags = iDrivingFlags;
params.SetTargetEntity(pEntity);
params.m_fCruiseSpeed = fCruiseSpeed;
if (iMinHeightAboveTerrain < 0)
{
iMinHeightAboveTerrain = CTaskVehicleGoToHelicopter::DEFAULT_MIN_HEIGHT_ABOVE_TERRAIN;
}
CTaskVehicleEscort* pEscortTask = rage_new CTaskVehicleEscort(params, (CTaskVehicleEscort::VehicleEscortType)iEscortType, fCustomOffset, iMinHeightAboveTerrain, fStraightLineDist);
CTask* pTask = rage_new CTaskControlVehicle(pVehicle, pEscortTask);
CScriptPeds::GivePedScriptedTask(iPedID, pTask, SCRIPT_TASK_VEHICLE_MISSION, "TASK_VEHICLE_ESCORT");
}
void CommandTaskVehicleFollow( int iPedID, int iVehicleID, int iFollowEntityID, float fCruiseSpeed, int iDrivingFlags, int iFollowDistance)
{
CVehicle* pVehicle = NULL;
if(SCRIPT_VERIFY(NULL_IN_SCRIPTING_LANGUAGE != iVehicleID, "TASK_VEHICLE_FOLLOW - You must specify a vehicle to drive"))
{
pVehicle = CTheScripts::GetEntityToModifyFromGUID<CVehicle>(iVehicleID, CTheScripts::GUID_ASSERT_FLAGS_INCLUDE_CLONES);
}
if(!pVehicle)
{
return;
}
CEntity *pEntity = CTheScripts::GetEntityToModifyFromGUID<CEntity>(iFollowEntityID, CTheScripts::GUID_ASSERT_FLAGS_INCLUDE_CLONES);
if (!pEntity)
{
return;
}
sVehicleMissionParams params;
params.m_iDrivingFlags = iDrivingFlags;
params.SetTargetEntity(pEntity);
params.m_fCruiseSpeed = fCruiseSpeed;
CTaskVehicleFollow* pFollowTask = rage_new CTaskVehicleFollow(params, iFollowDistance);
CTask* pTask = rage_new CTaskControlVehicle(pVehicle, pFollowTask);
CScriptPeds::GivePedScriptedTask(iPedID, pTask, SCRIPT_TASK_VEHICLE_MISSION, "TASK_VEHICLE_FOLLOW");
}
void CommandTaskHeliProtect( int iPedID, int iVehicleID, int iEscortEntityID, float fCruiseSpeed, int iDrivingFlags, float fCustomOffset, int iMinHeightAboveTerrain, int iHeliFlags)
{
CVehicle* pVehicle = NULL;
if(SCRIPT_VERIFY(NULL_IN_SCRIPTING_LANGUAGE != iVehicleID, "TASK_VEHICLE_HELI_PROTECT - You must specify a vehicle to drive"))
{
pVehicle = CTheScripts::GetEntityToModifyFromGUID<CVehicle>(iVehicleID, CTheScripts::GUID_ASSERT_FLAGS_INCLUDE_CLONES);
}
if(!pVehicle)
{
return;
}
CEntity *pEntity = CTheScripts::GetEntityToModifyFromGUID<CEntity>(iEscortEntityID, CTheScripts::GUID_ASSERT_FLAGS_INCLUDE_CLONES);
if (!pEntity)
{
return;
}
sVehicleMissionParams params;
params.m_iDrivingFlags = iDrivingFlags;
params.SetTargetEntity(pEntity);
params.m_fCruiseSpeed = fCruiseSpeed;
if (iMinHeightAboveTerrain < 0)
{
iMinHeightAboveTerrain = CTaskVehicleGoToHelicopter::DEFAULT_MIN_HEIGHT_ABOVE_TERRAIN;
}
CTask* pHeliTask = rage_new CTaskVehicleHeliProtect(params, fCustomOffset, iMinHeightAboveTerrain, iHeliFlags);
CTask* pTask = rage_new CTaskControlVehicle(pVehicle, pHeliTask);
CScriptPeds::GivePedScriptedTask(iPedID, pTask, SCRIPT_TASK_VEHICLE_MISSION, "TASK_VEHICLE_HELI_PROTECT");
}
void CommandTaskVehicleChase(int iPedID, int iTargetID)
{
//Ensure the ped is valid.
CPed* pPed = CTheScripts::GetEntityToModifyFromGUID<CPed>(iPedID);
if(!SCRIPT_VERIFY(pPed, "TASK_VEHICLE_CHASE - The ped is invalid."))
{
return;
}
//Ensure the ped is in a vehicle.
if(!SCRIPT_VERIFY(pPed->GetVehiclePedInside(), "TASK_VEHICLE_CHASE - The ped is not in a vehicle."))
{
return;
}
//Ensure the target is valid.
CPed* pTarget = CTheScripts::GetEntityToModifyFromGUID<CPed>(iTargetID, CTheScripts::GUID_ASSERT_FLAGS_INCLUDE_CLONES);
if(!SCRIPT_VERIFY(pTarget, "TASK_VEHICLE_CHASE - The target is invalid."))
{
return;
}
//Ensure the target is in a vehicle.
if(!SCRIPT_VERIFY(pTarget->GetVehiclePedInside(), "TASK_VEHICLE_CHASE - The target is not in a vehicle."))
{
return;
}
//Create the task.
CTask* pTask = rage_new CTaskVehicleChase(pTarget);
//Give the task to the ped.
CScriptPeds::GivePedScriptedTask(iPedID, pTask, SCRIPT_TASK_VEHICLE_CHASE, "TASK_VEHICLE_CHASE");
}
void CommandSetTaskVehicleChaseBehaviorFlag(int iPedID, int iFlag, bool bValue)
{
//Ensure the ped is valid.
CPed* pPed = CTheScripts::GetEntityToModifyFromGUID<CPed>(iPedID);
if(!SCRIPT_VERIFY(pPed, "SET_TASK_VEHICLE_CHASE_BEHAVIOR_FLAG - The ped is invalid."))
{
return;
}
//Ensure the vehicle chase task is valid.
CTaskVehicleChase* pTask = static_cast<CTaskVehicleChase *>(pPed->GetPedIntelligence()->FindTaskActiveByType(CTaskTypes::TASK_VEHICLE_CHASE));
if(!SCRIPT_VERIFY(pTask, "SET_TASK_VEHICLE_CHASE_BEHAVIOR_FLAG - The task is invalid."))
{
return;
}
//Change the behavior flag.
pTask->ChangeBehaviorFlag(CTaskVehicleChase::Overrides::Script, (CTaskVehicleChase::BehaviorFlags)iFlag, bValue);
}
void CommandSetTaskVehicleChaseIdealPursuitDistance(int iPedID, float fIdealPursuitDistance)
{
//Ensure the ped is valid.
CPed* pPed = CTheScripts::GetEntityToModifyFromGUID<CPed>(iPedID);
if(!SCRIPT_VERIFY(pPed, "SET_TASK_VEHICLE_CHASE_IDEAL_PURSUIT_DISTANCE - The ped is invalid."))
{
return;
}
//Ensure the vehicle chase task is valid.
CTaskVehicleChase* pTask = static_cast<CTaskVehicleChase *>(pPed->GetPedIntelligence()->FindTaskActiveByType(CTaskTypes::TASK_VEHICLE_CHASE));
if(!SCRIPT_VERIFY(pTask, "SET_TASK_VEHICLE_CHASE_IDEAL_PURSUIT_DISTANCE - The task is invalid."))
{
return;
}
//Set the ideal distance.
pTask->SetIdealDistanceForPursue(CTaskVehicleChase::Overrides::Script, fIdealPursuitDistance);
}
void CommandTaskPlaneChase(int iPedID, int iTargetID, const scrVector & vTargetOffset)
{
//Ensure the ped is valid.
CPed* pPed = CTheScripts::GetEntityToModifyFromGUID<CPed>(iPedID, CTheScripts::GUID_ASSERT_FLAGS_INCLUDE_CLONES);
if(!SCRIPT_VERIFY(pPed, "TASK_PLANE_CHASE - The ped is invalid."))
{
return;
}
//Ensure the target is valid.
CEntity const* pTarget = CTheScripts::GetEntityToQueryFromGUID<CEntity>(iTargetID);
if(!SCRIPT_VERIFY(pTarget, "TASK_PLANE_CHASE - The target is invalid."))
{
return;
}
CAITarget target;
target.SetEntityAndOffsetUnlimited(pTarget, vTargetOffset);
CTask* pTask = rage_new CTaskPlaneChase(target);
//Give the task to the ped.
CScriptPeds::GivePedScriptedTask(iPedID, pTask, SCRIPT_TASK_PLANE_CHASE, "TASK_PLANE_CHASE");
}
void CommandTaskPlaneLand(int iPedID, int iVehicleID, const scrVector & vRunWayStart, const scrVector & vRunWayEnd)
{
//Ensure the ped is valid.
CPed* pPed = CTheScripts::GetEntityToModifyFromGUID<CPed>(iPedID);
if(!SCRIPT_VERIFY(pPed, "TASK_PLANE_LAND - The ped is invalid."))
{
return;
}
CVehicle* pVehicle = NULL;
if(SCRIPT_VERIFY(NULL_IN_SCRIPTING_LANGUAGE != iVehicleID, "TASK_PLANE_LAND - You must specify a vehicle!"))
{
pVehicle = CTheScripts::GetEntityToModifyFromGUID<CVehicle>(iVehicleID);
}
if(!pVehicle)
{
return;
}
//Create the task.
CTask* pTaskVehicleLandPlane = rage_new CTaskVehicleLandPlane((Vec3V)vRunWayStart, (Vec3V)vRunWayEnd);
CTask* pTask = rage_new CTaskControlVehicle(pVehicle, pTaskVehicleLandPlane);
//Give the task to the ped.
CScriptPeds::GivePedScriptedTask(iPedID, pTask, SCRIPT_TASK_PLANE_LAND, "TASK_PLANE_CHASE");
}
void CommandTaskHeliChase(int iPedID, int iTargetID, const scrVector & vTargetOffset)
{
//Ensure the ped is valid.
CPed* pPed = CTheScripts::GetEntityToModifyFromGUID<CPed>(iPedID, CTheScripts::GUID_ASSERT_FLAGS_INCLUDE_CLONES);
if(!SCRIPT_VERIFY(pPed, "TASK_HELI_CHASE - The ped is invalid."))
{
return;
}
//Ensure the target is valid.
const CEntity* pTarget = CTheScripts::GetEntityToQueryFromGUID<CEntity>(iTargetID);
if(!SCRIPT_VERIFY(pTarget, "TASK_HELI_CHASE - The target is invalid."))
{
return;
}
//Create the task.
CTask* pTask = rage_new CTaskHeliChase(CAITarget(pTarget), (Vec3V)vTargetOffset);
//Give the task to the ped.
CScriptPeds::GivePedScriptedTask(iPedID, pTask, SCRIPT_TASK_HELI_CHASE, "TASK_HELI_CHASE");
}
void CommandSetTaskHeliChaseTargetOffset(int iPedID, const scrVector & vTargetOffset)
{
//Ensure the ped is valid.
CPed* pPed = CTheScripts::GetEntityToModifyFromGUID<CPed>(iPedID, CTheScripts::GUID_ASSERT_FLAGS_INCLUDE_CLONES);
if(!SCRIPT_VERIFY(pPed, "SET_TASK_HELI_CHASE_TARGET_OFFSET - The ped is invalid."))
{
return;
}
//Ensure the vehicle chase task is valid.
CTaskHeliChase* pTask = static_cast<CTaskHeliChase *>(pPed->GetPedIntelligence()->FindTaskActiveByType(CTaskTypes::TASK_HELI_CHASE));
if(!SCRIPT_VERIFY(pTask, "SET_TASK_HELI_CHASE_TARGET_OFFSET - The task is invalid."))
{
return;
}
//Set the target offset.
pTask->SetTargetOffset((Vec3V)vTargetOffset);
}
void CommandSetTaskHeliChaseTargetOffsetWorldSpace(int iPedID, bool bTargetOffsetWorldSpace)
{
//Ensure the ped is valid.
CPed* pPed = CTheScripts::GetEntityToModifyFromGUID<CPed>(iPedID, CTheScripts::GUID_ASSERT_FLAGS_INCLUDE_CLONES);
if(!SCRIPT_VERIFY(pPed, "SET_TASK_HELI_CHASE_TARGET_OFFSET_WORLD_SPACE - The ped is invalid."))
{
return;
}
//Ensure the vehicle chase task is valid.
CTaskHeliChase* pTask = static_cast<CTaskHeliChase *>(pPed->GetPedIntelligence()->FindTaskActiveByType(CTaskTypes::TASK_HELI_CHASE));
if(!SCRIPT_VERIFY(pTask, "SET_TASK_HELI_CHASE_TARGET_OFFSET_WORLD_SPACE - The task is invalid."))
{
return;
}
//Set the target offset.
pTask->SetTargetOffsetRelative(bTargetOffsetWorldSpace ? CTaskHeliChase::OffsetRelative_World : CTaskHeliChase::OffsetRelative_Local );
}
void CommandSetTaskHeliChaseOrientation(int iPedID, int iOrientationMode, int iOrientationRelative, float in_orientation)
{
//Ensure the ped is valid.
CPed* pPed = CTheScripts::GetEntityToModifyFromGUID<CPed>(iPedID, CTheScripts::GUID_ASSERT_FLAGS_INCLUDE_CLONES);
if(!SCRIPT_VERIFY(pPed, "SET_TASK_HELI_CHASE_ORIENTATION - The ped is invalid."))
{
return;
}
//Ensure the vehicle chase task is valid.
CTaskHeliChase* pTask = static_cast<CTaskHeliChase *>(pPed->GetPedIntelligence()->FindTaskActiveByType(CTaskTypes::TASK_HELI_CHASE));
if(!SCRIPT_VERIFY(pTask, "SET_TASK_HELI_CHASE_ORIENTATION - The task is invalid."))
{
return;
}
pTask->SetOrientationMode(static_cast<CTaskHeliChase::OrientationMode>(iOrientationMode));
pTask->SetOrientationRelative(static_cast<CTaskHeliChase::OrientationRelative>(iOrientationRelative));
pTask->SetOrientationOffset(in_orientation);
}
void CommandTaskWeaponRoll( int UNUSED_PARAM(iPedID), bool UNUSED_PARAM(bRight))
{
Assertf(false, "unsupported command TASK_WEAPON_ROLL");
MUST_FIX_THIS(anim missing);
}
bool CommandControlMountedWeapon( int iPedID )
{
if( SCRIPT_VERIFY( NULL_IN_SCRIPTING_LANGUAGE != iPedID, "CONTROL_MOUNTED_WEAPON - Can't have a NULL ped" ))
{
CPed* pPed = CTheScripts::GetEntityToModifyFromGUID<CPed>(iPedID);
if(pPed)
{
bool inVehicle = pPed->GetPedConfigFlag( CPED_CONFIG_FLAG_InVehicle );
if(SCRIPT_VERIFY(inVehicle , "CONTROL_MOUNTED_WEAPON: ped is not in vehicle!"))
{
if(CTaskVehicleMountedWeapon::IsTaskValid(pPed))
{
CTask* pControlVehicleTask = pPed->GetPedIntelligence()->FindTaskPrimaryByType( CTaskTypes::TASK_CONTROL_VEHICLE );
if( pControlVehicleTask )
{
CTaskControlVehicle* pTaskControlVehicle=static_cast<CTaskControlVehicle*>(pControlVehicleTask);
pTaskControlVehicle->SetDesiredSubtask(NULL);
return true;
}
}
}
}
}
return false;
}
void CommandSetMountedWeaponTarget(int iPedID, int iOtherPedID, int iTargetVehicleID, const scrVector & scrVecCoors, int TaskMode, bool bIgnoreTargetVehDeadCheck)
{
if( SCRIPT_VERIFY( NULL_IN_SCRIPTING_LANGUAGE != iPedID, "SET_MOUNTED_WEAPON_TARGET - Can't have a NULL ped" ) )
{
CPed* pPed = CTheScripts::GetEntityToModifyFromGUID<CPed>( iPedID );
if( pPed )
{
// Determine the type of target to updateSET_MOUNTED_WEAPON_TARGET
const CEntity *pTargetEntity = NULL;
// Ped target
if( iOtherPedID != NULL_IN_SCRIPTING_LANGUAGE )
{
if( !SCRIPT_VERIFY( iTargetVehicleID == NULL_IN_SCRIPTING_LANGUAGE, "SET_MOUNTED_WEAPON_TARGET - Can't have a target ped and a target car" ) )
return;
const CPed* pTargetPed = CTheScripts::GetEntityToQueryFromGUID<CPed>( iOtherPedID );
if( !SCRIPT_VERIFY( pTargetPed, "SET_MOUNTED_WEAPON_TARGET - Target ped doesn't exist" ) )
return;
pTargetEntity = pTargetPed;
}
// Vehicle target
if( iTargetVehicleID != NULL_IN_SCRIPTING_LANGUAGE )
{
const CVehicle *pTargetVehicle = CTheScripts::GetEntityToQueryFromGUID<CVehicle>( iTargetVehicleID, bIgnoreTargetVehDeadCheck ? CTheScripts::GUID_ASSERT_FLAGS_NO_DEAD_CHECK : CTheScripts::GUID_ASSERT_FLAGS_ALL );
if( !SCRIPT_VERIFY( pTargetVehicle, "SET_MOUNTED_WEAPON_TARGET - Target vehicle doesn't exist" ) )
return;
pTargetEntity = pTargetVehicle;
}
// Set the target
const Vector3 vTargetCoords( scrVecCoors );
aiTask* pMountedWeaponBase = pPed->GetPedIntelligence()->FindTaskActiveByType( CTaskTypes::TASK_VEHICLE_MOUNTED_WEAPON );
if( pMountedWeaponBase )
{
//Updated the mode
static_cast<CTaskVehicleMountedWeapon*>(pMountedWeaponBase)->SetMode((CTaskVehicleMountedWeapon::eTaskMode)TaskMode);
//Set the target
if( pTargetEntity )
static_cast<CTaskVehicleMountedWeapon*>(pMountedWeaponBase)->SetTarget( pTargetEntity, &vTargetCoords );
else
static_cast<CTaskVehicleMountedWeapon*>(pMountedWeaponBase)->SetTargetPosition( vTargetCoords );
}
Assertf( pMountedWeaponBase, "SET_MOUNTED_WEAPON_TARGET - Native function invoked but ped has no gun or vehicle gun task." );
}
}
}
void CommandClearMountedWeaponTaskUnderneathDrivingTask(int iPedID)
{
CPed* pPed = CTheScripts::GetEntityToModifyFromGUID<CPed>(iPedID);
if(pPed)
{
bool inVehicle = pPed->GetPedConfigFlag( CPED_CONFIG_FLAG_InVehicle );
if(SCRIPT_VERIFY(inVehicle , "CLEAR_MOUNTED_WEAPON_TASK_UNDERNEATH_DRIVING_TASK: ped is not in vehicle!"))
{
CTask* pCurrent=pPed->GetPedIntelligence()->FindTaskActiveByType(CTaskTypes::TASK_CONTROL_VEHICLE );
if( pCurrent )
{
CTaskControlVehicle* pTaskControlVehicle=static_cast<CTaskControlVehicle*>(pCurrent);
if( scriptVerifyf( pTaskControlVehicle->GetDesiredSubtask() && pTaskControlVehicle->GetDesiredSubtask()->GetTaskType() == CTaskTypes::TASK_VEHICLE_MOUNTED_WEAPON, "CLEAR_MOUNTED_WEAPON_TASK_UNDERNEATH_DRIVING_TASK no mounted weapon task running, use IS_MOUNTED_WEAPON_TASK_UNDERNEATH_DRIVING_TASK" ) )
{
pTaskControlVehicle->SetDesiredSubtask(NULL);
}
}
}
}
}
bool CommandIsMountedWeaponTaskUnderneathDrivingTask(int iPedID)
{
const CPed *pPed = CTheScripts::GetEntityToQueryFromGUID<CPed>(iPedID);
if(pPed)
{
bool inVehicle = pPed->GetPedConfigFlag( CPED_CONFIG_FLAG_InVehicle );
if(SCRIPT_VERIFY(inVehicle, "IS_MOUNTED_WEAPON_TASK_UNDERNEATH_DRIVING_TASK: ped is not in vehicle or on a mount!"))
{
CTask* pCurrent = pPed->GetPedIntelligence()->FindTaskActiveByType(CTaskTypes::TASK_VEHICLE_MOUNTED_WEAPON);
if( pCurrent )
{
return true;
}
}
}
return false;
}
void CommandTaskDriveBy( int iPedID, int iOtherPedID, int iTargetVehicleID,
const scrVector & scrVecCoors, float fAbortRange, int iFrequencyPercentage, bool bPushUnderneathDrivingTaskIfDriving, int iFiringPatternHash )
{
Vector3 TempVec, CentreVec, VecDiff;
CPed *pPed;
const CPed *pSecondPed;
const CVehicle *pSecondVehicle;
CTask* pTask;
TempVec = Vector3(scrVecCoors);
if(!SCRIPT_VERIFY( (iFrequencyPercentage >= 0) && (iFrequencyPercentage <= 100), "TASK_DRIVE_BY - Frequency should be between 0 and 100"))
return;
const CEntity *pTargetEntity = NULL;
if (iOtherPedID != NULL_IN_SCRIPTING_LANGUAGE) // >= 0)
{
if(SCRIPT_VERIFY(iTargetVehicleID == NULL_IN_SCRIPTING_LANGUAGE, "TASK_DRIVE_BY - Can't have a target ped and a target car"))
{
pSecondPed = CTheScripts::GetEntityToQueryFromGUID<CPed>(iOtherPedID);
if(!pSecondPed)
return;
pTargetEntity = pSecondPed;
}
else
{
return;
}
}
else
{
pSecondPed = NULL;
}
if (iTargetVehicleID != NULL_IN_SCRIPTING_LANGUAGE) // >= 0)
{
if(SCRIPT_VERIFY(iOtherPedID == NULL_IN_SCRIPTING_LANGUAGE, "TASK_DRIVE_BY - Can't have a target ped and a target car"))
{
pSecondVehicle = CTheScripts::GetEntityToQueryFromGUID<CVehicle>(iTargetVehicleID);
if(!SCRIPT_VERIFY(pSecondVehicle, "TASK_DRIVE_BY - Target vehicle doesn't exist"))
return;
pTargetEntity = pSecondVehicle;
}
else
{
return;
}
}
else
{
pSecondVehicle = NULL;
}
// Set up the arguments
CAITarget target;
if( pTargetEntity )
{
target.SetEntityAndOffset(pTargetEntity,TempVec);
}
else
{
target.SetPosition(TempVec);
}
const u32 uFiringPattern = iFiringPatternHash != 0 ? (u32)iFiringPatternHash : ATSTRINGHASH("FIRING_PATTERN_BURST_FIRE_DRIVEBY", 0x0d31265f2);
bool bAlreadydoingDriveBy=false;
if(NULL_IN_SCRIPTING_LANGUAGE!=iPedID)
{
pPed = CTheScripts::GetEntityToModifyFromGUID<CPed>(iPedID);
if(pPed)
{
bool inVehicle = pPed->GetPedConfigFlag( CPED_CONFIG_FLAG_InVehicle );
bool onMount = (pPed->GetMyMount() != NULL);
if(SCRIPT_VERIFY(inVehicle || onMount, "TASK_DRIVE_BY: char is not in vehicle or on a mount!"))
{
CTask* pControlVehicleTask = pPed->GetPedIntelligence()->FindTaskPrimaryByType( CTaskTypes::TASK_CONTROL_VEHICLE );
CTask* pCurrent=pPed->GetPedIntelligence()->GetTaskAtPriority(PED_TASK_PRIORITY_PRIMARY);
if(pCurrent && pCurrent->GetTaskType()==CTaskTypes::TASK_VEHICLE_GUN)
{
CTaskVehicleGun* pTaskDriveBy=(CTaskVehicleGun*)pCurrent;
if(pTaskDriveBy->GetTarget().GetEntity()==pSecondPed)
{
bAlreadydoingDriveBy=true;
}
}
else if( bPushUnderneathDrivingTaskIfDriving && pControlVehicleTask )
{
CTaskControlVehicle* pTaskControlVehicle=static_cast<CTaskControlVehicle*>(pControlVehicleTask);
pTask = rage_new CTaskVehicleGun(CTaskVehicleGun::Mode_Fire,uFiringPattern,&target,((float)iFrequencyPercentage)/100.0f,fAbortRange);
pTaskControlVehicle->SetDesiredSubtask(pTask);
bAlreadydoingDriveBy=true;
}
else if(onMount && bPushUnderneathDrivingTaskIfDriving)
{
CTaskComplexControlMovement* pControlTask = static_cast<CTaskComplexControlMovement*>(pPed->GetPedIntelligence()->FindTaskActiveByType(CTaskTypes::TASK_COMPLEX_CONTROL_MOVEMENT));
if(pControlTask)
{
const int existingSubTask = pControlTask->GetMainSubTaskType();
if(existingSubTask == CTaskTypes::TASK_NONE || existingSubTask == CTaskTypes::TASK_VEHICLE_GUN)
{
pTask = rage_new CTaskVehicleGun(CTaskVehicleGun::Mode_Fire,uFiringPattern,&target,((float)iFrequencyPercentage)/100.0f,fAbortRange);
pControlTask->SetNewMainSubtask(pTask);
bAlreadydoingDriveBy=true;
}
// Note: not entirely sure what to do in the case of there being a subtask that's something
// else than CTaskVehicleGun. Now, it would still give you the driveby task, but running as the
// main task. This seems consistent with the vehicle case and is probably acceptable.
}
}
}
}
}
if(!bAlreadydoingDriveBy)
{
pTask = rage_new CTaskVehicleGun(CTaskVehicleGun::Mode_Fire,uFiringPattern,&target,((float)iFrequencyPercentage)/100.0f,fAbortRange);
CScriptPeds::GivePedScriptedTask( iPedID, pTask, SCRIPT_TASK_DRIVE_BY, "TASK_DRIVE_BY");
}
}
void CommandSetDriveByTarget(int iPedID, int iOtherPedID, int iTargetVehicleID, const scrVector & scrVecCoors)
{
if( SCRIPT_VERIFY( NULL_IN_SCRIPTING_LANGUAGE != iPedID, "SET_DRIVERBY_TASK_TARGET - Can't have a NULL ped" ) )
{
CPed* pPed = CTheScripts::GetEntityToModifyFromGUID<CPed>( iPedID );
if( pPed )
{
// Determine the type of target to update
const CEntity *pTargetEntity = NULL;
// Ped target
if( iOtherPedID != NULL_IN_SCRIPTING_LANGUAGE )
{
if( !SCRIPT_VERIFY( iTargetVehicleID == NULL_IN_SCRIPTING_LANGUAGE, "SET_DRIVERBY_TASK_TARGET - Can't have a target ped and a target car" ) )
return;
const CPed* pTargetPed = CTheScripts::GetEntityToQueryFromGUID<CPed>( iOtherPedID );
if( !SCRIPT_VERIFY( pTargetPed, "SET_DRIVERBY_TASK_TARGET - Target ped doesn't exist" ) )
return;
pTargetEntity = pTargetPed;
}
// Vehicle target
if( iTargetVehicleID != NULL_IN_SCRIPTING_LANGUAGE )
{
const CVehicle *pTargetVehicle = CTheScripts::GetEntityToQueryFromGUID<CVehicle>( iTargetVehicleID );
if( !SCRIPT_VERIFY( pTargetVehicle, "SET_DRIVERBY_TASK_TARGET - Target vehicle doesn't exist" ) )
return;
pTargetEntity = pTargetVehicle;
}
// Set the target
const Vector3 vTargetCoords( scrVecCoors );
// Check the gun task
aiTask* pGunTaskBase = pPed->GetPedIntelligence()->FindTaskActiveByType( CTaskTypes::TASK_GUN );
if( pGunTaskBase )
{
CWeaponTarget target;
if( pTargetEntity )
target.SetEntityAndOffset( pTargetEntity, vTargetCoords );
else
target.SetPosition( vTargetCoords );
static_cast<CTaskGun*>(pGunTaskBase)->SetTarget( target );
}
// Check vehicle gun task just in case
aiTask* pVehicleGunTaskBase = pPed->GetPedIntelligence()->FindTaskActiveByType( CTaskTypes::TASK_VEHICLE_GUN );
if( pVehicleGunTaskBase )
{
if( pTargetEntity )
static_cast<CTaskVehicleGun*>(pVehicleGunTaskBase)->SetTarget( pTargetEntity, &vTargetCoords );
else
static_cast<CTaskVehicleGun*>(pVehicleGunTaskBase)->SetTargetPosition( vTargetCoords );
}
Assertf( pGunTaskBase || pVehicleGunTaskBase, "SET_DRIVERBY_TASK_TARGET - Native function invoked but ped has no gun or vehicle gun task." );
}
}
}
void CommandClearDrivebyTaskUnderneathDrivingTask(int iPedID)
{
CPed* pPed = CTheScripts::GetEntityToModifyFromGUID<CPed>(iPedID);
if(pPed)
{
bool inVehicle = pPed->GetPedConfigFlag( CPED_CONFIG_FLAG_InVehicle );
bool onMount = (pPed->GetMyMount() != NULL);
if(SCRIPT_VERIFY(inVehicle || onMount, "CLEAR_DRIVEBY_TASK_UNDERNEATH_DRIVING_TASK: char is not in vehicle or on a mount!"))
{
CTask* pCurrent=pPed->GetPedIntelligence()->FindTaskActiveByType(CTaskTypes::TASK_CONTROL_VEHICLE );
if( pCurrent )
{
CTaskControlVehicle* pTaskControlVehicle=static_cast<CTaskControlVehicle*>(pCurrent);
if( scriptVerifyf( pTaskControlVehicle->GetDesiredSubtask() && pTaskControlVehicle->GetDesiredSubtask()->GetTaskType() == CTaskTypes::TASK_VEHICLE_GUN, "CLEAR_DRIVEBY_TASK_UNDERNEATH_DRIVING_TASK no driveby task running, use IS_DRIVEBY_TASK_UNDERNEATH_DRIVING_TASK" ) )
{
pTaskControlVehicle->SetDesiredSubtask(NULL);
}
}
else if(onMount)
{
CTaskComplexControlMovement* pControlTask = static_cast<CTaskComplexControlMovement*>(pPed->GetPedIntelligence()->FindTaskActiveByType(CTaskTypes::TASK_COMPLEX_CONTROL_MOVEMENT));
if(pControlTask)
{
const int existingSubTask = pControlTask->GetMainSubTaskType();
if(existingSubTask == CTaskTypes::TASK_VEHICLE_GUN)
{
pControlTask->SetNewMainSubtask(NULL);
}
}
}
}
}
}
bool CommandIsDrivebyTaskUnderneathDrivingTask(int iPedID)
{
const CPed *pPed = CTheScripts::GetEntityToQueryFromGUID<CPed>(iPedID);
if(pPed)
{
bool inVehicle = pPed->GetPedConfigFlag( CPED_CONFIG_FLAG_InVehicle );
bool onMount = (pPed->GetMyMount() != NULL);
if(SCRIPT_VERIFY(inVehicle || onMount, "IS_DRIVEBY_TASK_UNDERNEATH_DRIVING_TASK: char is not in vehicle or on a mount!"))
{
CTask* pCurrent=pPed->GetPedIntelligence()->FindTaskActiveByType(CTaskTypes::TASK_CONTROL_VEHICLE);
if( pCurrent )
{
CTaskControlVehicle* pTaskControlVehicle=static_cast<CTaskControlVehicle*>(pCurrent);
return (pTaskControlVehicle->GetDesiredSubtask() && pTaskControlVehicle->GetDesiredSubtask()->GetTaskType() == CTaskTypes::TASK_VEHICLE_GUN);
}
else if(onMount)
{
CTaskComplexControlMovement* pControlTask = static_cast<CTaskComplexControlMovement*>(pPed->GetPedIntelligence()->FindTaskActiveByType(CTaskTypes::TASK_COMPLEX_CONTROL_MOVEMENT));
if(pControlTask)
{
const int existingSubTask = pControlTask->GetMainSubTaskType();
return existingSubTask == CTaskTypes::TASK_VEHICLE_GUN;
}
}
}
}
return false;
}
void CommandTaskUseMobilePhone( int iPedID, bool bUsePhone, int eDesiredPhoneMode )
{
if (bUsePhone)
{
if (NULL_IN_SCRIPTING_LANGUAGE != iPedID)
{
// pulled inside due to the NULL check
bool bShouldCreatePhoneTask = true;
CPed* pPed = CTheScripts::GetEntityToModifyFromGUID<CPed>(iPedID, CTheScripts::GUID_ASSERT_FLAGS_INCLUDE_CLONES);
if (pPed)
{
CTask* pTask = (bShouldCreatePhoneTask ? pPed->GetPedIntelligence()->FindTaskActiveByTreeAndType(PED_TASK_TREE_SECONDARY, CTaskTypes::TASK_MOBILE_PHONE) : NULL);
if (pTask)
{
CTaskMobilePhone* pTaskMobilePhone = static_cast<CTaskMobilePhone*>(pTask);
pTaskMobilePhone->PutUpToEar();
bShouldCreatePhoneTask = false;
}
pTask = (bShouldCreatePhoneTask ? pPed->GetPedIntelligence()->FindTaskByType(CTaskTypes::TASK_MOTION_IN_COVER) : NULL);
if (pTask && pTask->GetTaskType() == CTaskTypes::TASK_MOTION_IN_COVER)
{
CTaskMotionInCover* pTaskCover = (CTaskMotionInCover*)pTask;
pTaskCover->ProcessUseMobilePhone(true); // Pick up phone
bShouldCreatePhoneTask = false;
}
}
if (bShouldCreatePhoneTask)
{
CTask* pTask = rage_new CTaskMobilePhone(CTaskMobilePhone::PhoneMode(eDesiredPhoneMode));
pPed->GetPedIntelligence()->AddTaskSecondary(pTask, PED_TASK_SECONDARY_PARTIAL_ANIM);
}
}
else
{
// We still have to try and send the task if this is called from script in a sequence.
CTask* pTask = rage_new CTaskMobilePhone(CTaskMobilePhone::PhoneMode(eDesiredPhoneMode), -1, false);
CScriptPeds::GivePedScriptedTask(iPedID, pTask, SCRIPT_TASK_USE_MOBILE_PHONE, "TASK_USE_MOBILE_PHONE");
}
}
else
{
if(SCRIPT_VERIFY( NULL_IN_SCRIPTING_LANGUAGE != iPedID, "TASK_USE_MOBILE_PHONE( ped, FALSE ) Cannot be used in a sequence"))
{
CPed* pPed = CTheScripts::GetEntityToModifyFromGUID<CPed>(iPedID);
if (pPed)
{
CTask* pTask = pPed->GetPedIntelligence()->FindTaskActiveByTreeAndType(PED_TASK_TREE_SECONDARY, CTaskTypes::TASK_MOBILE_PHONE);
if (pTask)
{
CTaskMobilePhone* pTaskPhone = (CTaskMobilePhone*)pTask;
pTaskPhone->PutDownToPrevState();
}
// Make sure any mobile phone tasks in the event queue are removed.
for (s32 i = 0; i < pPed->GetPedIntelligence()->GetNumEventsInQueue(); i++)
{
CEvent* pEvent = pPed->GetPedIntelligence()->GetEventByIndex(i);
if (pEvent && pEvent->GetEventType() == EVENT_SCRIPT_COMMAND)
{
CEventScriptCommand* pEventScript = static_cast<CEventScriptCommand*>(pEvent);
if (pEventScript->GetTask() && pEventScript->GetTask()->GetTaskType() == CTaskTypes::TASK_MOBILE_PHONE)
{
pPed->GetPedIntelligence()->RemoveEvent(pEvent);
}
}
}
}
}
}
}
void CommandAddFollowNavmeshToPhoneTask( int iPedID, const scrVector & svTargetPos, float fMoveBlendRatio )
{
Assert(fMoveBlendRatio >= MOVEBLENDRATIO_WALK && fMoveBlendRatio <= MOVEBLENDRATIO_SPRINT);
Vector3 vTargetPos = svTargetPos;
if(SCRIPT_VERIFY( NULL_IN_SCRIPTING_LANGUAGE != iPedID, "ADD_FOLLOW_NAVMESH_TO_PHONE_TASK Cannot be used in a sequence"))
{
CPed *pPed = CTheScripts::GetEntityToModifyFromGUID<CPed>(iPedID);
if (pPed)
{
CTask* pTaskSecondary = pPed->GetPedIntelligence()->FindTaskActiveByTreeAndType(PED_TASK_TREE_SECONDARY, CTaskTypes::TASK_MOBILE_PHONE);
if(pTaskSecondary)
{
CTaskComplexControlMovement* pControlTask = static_cast<CTaskComplexControlMovement*>(pPed->GetPedIntelligence()->FindTaskActiveByType(CTaskTypes::TASK_COMPLEX_CONTROL_MOVEMENT));
if(pControlTask)
{
CTaskMoveFollowNavMesh * pNavMeshTask = rage_new CTaskMoveFollowNavMesh(fMoveBlendRatio, vTargetPos);
pNavMeshTask->SetIsScriptedRoute(true);
pControlTask->SetNewMoveTask(pNavMeshTask);
}
}
}
}
}
void CommandTaskUseMobilePhoneTimed( int iPedID, int iTime )
{
if (SCRIPT_VERIFY((iTime == -1) || (iTime > 0) ,"TASK_USE_MOBILE_PHONE_TIMED - Time must be -1 for infinite and > 0" ))
{
if (NULL_IN_SCRIPTING_LANGUAGE != iPedID)
{
CPed *pPed = CTheScripts::GetEntityToModifyFromGUID<CPed>(iPedID);
CTask* pTask = pPed->GetPedIntelligence()->FindTaskActiveByTreeAndType(PED_TASK_TREE_SECONDARY, CTaskTypes::TASK_MOBILE_PHONE);
if (!pTask)
{
pTask = rage_new CTaskMobilePhone(CTaskMobilePhone::Mode_ToCall, iTime);
pPed->GetPedIntelligence()->AddTaskSecondary(pTask, PED_TASK_SECONDARY_PARTIAL_ANIM);
}
else
{
// we already have one, just reset it
CTaskMobilePhone* pTaskMobilePhone = static_cast<CTaskMobilePhone*>(pTask);
pTaskMobilePhone->ResetTaskMobilePhone(CTaskMobilePhone::Mode_ToCall, iTime);
}
}
else
{
// We still have to try and send the task if this is called from script in a sequence.
CTask* pTask = rage_new CTaskMobilePhone(CTaskMobilePhone::Mode_ToCall, iTime, false);
CScriptPeds::GivePedScriptedTask( iPedID, pTask, SCRIPT_TASK_USE_MOBILE_PHONE, "TASK_USE_MOBILE_PHONE_TIMED");
}
}
}
void CommandTaskUseWalkieTalkie( int UNUSED_PARAM(iPedID), const char* UNUSED_PARAM(szContext) )
{
scriptAssertf(0, "TASK_USE_WALKIE_TALKIE has been deprecated");
}
void CommandTaskCapturePed(int UNUSED_PARAM(iPedID), int UNUSED_PARAM(iOtherPedID), float UNUSED_PARAM(fCaptureTime), float UNUSED_PARAM(fTimeToQuestion))
{
scriptAssertf(0, "TASK_CAPTURE_PED is deprecated");
}
void CommandTaskAdvanceToTargetInLine(int iPedID, int iOtherPedID, const scrVector & svTargetLocation, float fDesiredDist, float fTimeToHoldAtEnd, int iFlags)
{
// If we aren't running this in a sequence, assert on the peds group
const CPed* pPed = CTheScripts::GetEntityToQueryFromGUID<CPed>(iPedID);
if(pPed)
{
Assertf(pPed->GetPedsGroup(), "Ped running TASK_ADVANCE_TO_TARGET_IN_LINE must have a valid group");
}
// Get the other ped or location or both to determine the target type
CPed* pOtherPed = CTheScripts::GetEntityToModifyFromGUID<CPed>(iOtherPedID);
Vector3 vTargetLoc = svTargetLocation;
Assertf(pOtherPed || vTargetLoc.IsNonZero(), "Target must be a valid ped or a non-origin position");
CAITarget target;
if(pOtherPed)
{
target = vTargetLoc.IsZero() ? CAITarget(pOtherPed) : CAITarget(pOtherPed, vTargetLoc);
}
else
{
target = CAITarget(vTargetLoc);
}
// Create our new task and give it to the ped
CTask* pTask = rage_new CTaskSwatFollowInLine(target, fDesiredDist, fTimeToHoldAtEnd, iFlags);
CScriptPeds::GivePedScriptedTask(iPedID, pTask, SCRIPT_TASK_ADVANCE_TO_TARGET_IN_LINE, "TASK_ADVANCE_TO_TARGET_IN_LINE");
}
void CommandSetChargeTargetEnabled(bool bEnabled)
{
CTaskCombat::ms_Tunables.m_ChargeTuning.m_bChargeTargetEnabled = bEnabled;
}
void CommandSetMaxNumActiveChargers(int iMaxActiveChargers)
{
if( SCRIPT_VERIFY(iMaxActiveChargers >= 0, "SET_MAX_NUM_ACTIVE_CHARGERS -- negative MAX_NUM_ACTIVE_CHARGERS requested") )
{
CTaskCombat::ms_Tunables.m_ChargeTuning.m_uMaxNumActiveChargers = (u8)iMaxActiveChargers;
}
}
void CommandSetMinTimeBetweenChargesAtSameTarget(float fMinTimeSeconds)
{
if( SCRIPT_VERIFY(fMinTimeSeconds >= 0.0f, "SET_MIN_TIME_BETWEEN_CHARGES_AT_SAME_TARGET -- negative MIN_TIME_SECONDS requested") )
{
CTaskCombat::ms_Tunables.m_ChargeTuning.m_uMinTimeBetweenChargesAtSameTargetMS = (u32)(fMinTimeSeconds * 1000.0f);
}
}
void CommandTaskChatToPed(int iPedID, int iOtherPedID, int iFlags, const scrVector & vGoToPos, float fHeadingDegs, float fIdleTime)
{
CPed* pOtherPed = CTheScripts::GetEntityToModifyFromGUID<CPed>(iOtherPedID);
if (pOtherPed)
{
// Convert the heading to radians, in the -PI..PI range.
float fHeading = CanonicalizeAngle(fHeadingDegs*DtoR);
CTask* pTask = rage_new CTaskChat(pOtherPed, iFlags, vGoToPos, fHeading, fIdleTime);
CScriptPeds::GivePedScriptedTask(iPedID, pTask, SCRIPT_TASK_CHAT_TO_PED, "TASK_CHAT_TO_PED");
}
}
bool CommandIsChattingPedInPosition(int iPedID)
{
const CPed* pPed = CTheScripts::GetEntityToQueryFromGUID<CPed>(iPedID);
if(pPed)
{
CTask* pTask = pPed->GetPedIntelligence()->FindTaskActiveByType(CTaskTypes::TASK_CHAT);
if (pTask && static_cast<CTaskChat*>(pTask)->IsInPosition())
{
return true;
}
}
return false;
}
bool CommandIsChattingPedPlayingAnim(int iPedID)
{
const CPed* pPed = CTheScripts::GetEntityToQueryFromGUID<CPed>(iPedID);
if(pPed)
{
CTask* pTask = pPed->GetPedIntelligence()->FindTaskActiveByType(CTaskTypes::TASK_CHAT);
if (pTask && static_cast<CTaskChat*>(pTask)->IsPlayingClip())
{
return true;
}
}
return false;
}
void CommandMakeChattingPedPlayAnim(int UNUSED_PARAM(iPedID), const char *UNUSED_PARAM(pAnimDictName), const char *UNUSED_PARAM(pAnimName), float UNUSED_PARAM(fBlendInDelta), int UNUSED_PARAM(nTimeToPlay), int UNUSED_PARAM(nControlFlags))
{
// GSALES - killing this so I can get rid of the old anim control flag stuff. It doesn't seem to be used anywhere any more.
scriptAssertf(0, "MAKE_CHATTING_PED_PLAY_ANIM - This command is deprecated. See an animation programmer.");
}
void CommandMakeChattingPedLeave(int iPedID, bool bPlayGoodByeGestures)
{
CPed* pPed = CTheScripts::GetEntityToModifyFromGUID<CPed>(iPedID);
if(pPed)
{
CTask* pTask = pPed->GetPedIntelligence()->FindTaskActiveByType(CTaskTypes::TASK_CHAT);
if (pTask)
{
static_cast<CTaskChat*>(pTask)->LeaveChat(bPlayGoodByeGestures);
}
}
}
enum {
MOBILE_SUB_TASK_PHONE_IN,
MOBILE_SUB_TASK_PHONE_TALK,
MOBILE_SUB_TASK_PHONE_OUT,
MOBILE_SUB_TASK_PHONE_OTHER
};
bool CommandGetMobilePhoneTaskSubTask( int iPedID, int &ReturnSubTask)
{
const CPed *pPed = CTheScripts::GetEntityToQueryFromGUID<CPed>(iPedID);
if(pPed)
{
ReturnSubTask = MOBILE_SUB_TASK_PHONE_IN;
CTaskComplexUseMobilePhone *pTaskUseMobile = (CTaskComplexUseMobilePhone*)pPed->GetPedIntelligence()->FindTaskByType(CTaskTypes::TASK_COMPLEX_USE_MOBILE_PHONE);
// Assertf(pTaskUseMobile, "%s:GET_MOBILE_PHONE_TASK_SUB_TASK - ped is not performing the mobile phone task", CTheScripts::GetCurrentScriptNameAndProgramCounter());
if (pTaskUseMobile)
{
CTask *pSubTask = pTaskUseMobile->GetSubTask();
if (pSubTask)
{
switch (pSubTask->GetTaskType())
{
case CTaskTypes::TASK_SIMPLE_PHONE_IN:
ReturnSubTask = MOBILE_SUB_TASK_PHONE_IN;
break;
case CTaskTypes::TASK_SIMPLE_PHONE_TALK:
ReturnSubTask = MOBILE_SUB_TASK_PHONE_TALK;
break;
case CTaskTypes::TASK_SIMPLE_PHONE_OUT:
ReturnSubTask = MOBILE_SUB_TASK_PHONE_OUT;
break;
default: // return the same value for all other sub task types?
ReturnSubTask = MOBILE_SUB_TASK_PHONE_OTHER;
break;
}
}
return true;
}
// if the ped isn't performing TASK_COMPLEX_USE_MOBILE_PHONE then ReturnSubTask will be MOBILE_SUB_TASK_PHONE_IN
}
return false;
}
void CommandTaskWarpPedIntoVehicle( int iPedID, int iVehicleID, int iSeat )
{
scriptAssertf(!NetworkInterface::IsGameInProgress(), "%s:TASK_WARP_PED_INTO_VEHICLE is not safe in network games! Use TASK_ENTER_VEHICLE with the warp flag set instead!", CTheScripts::GetCurrentScriptNameAndProgramCounter());
CVehicle *pVehicle = CTheScripts::GetEntityToModifyFromGUID<CVehicle>(iVehicleID);
if(pVehicle)
{
s32 iSeatIndex = iSeat+1;
if( iSeatIndex == -1 )
{
// If -2 is passed in, we should put the ped into any passenger seat
for (s32 seatIndex=1; seatIndex<pVehicle->GetSeatManager()->GetMaxSeats(); seatIndex++)
{
if (!pVehicle->GetSeatManager()->GetPedInSeat(seatIndex))
{
iSeatIndex = seatIndex;
break;
}
}
if (!SCRIPT_VERIFY(iSeatIndex != -1, "TASK_WARP_PED_INTO_VEHICLE - Couldn't find free passenger seat to put ped in"))
return;
}
if( iSeatIndex != -1 )
{
if(!SCRIPT_VERIFY((iSeatIndex < pVehicle->GetSeatManager()->GetMaxSeats()), "TASK_WARP_PED_INTO_VEHICLE - Seat number is too large"))
return;
if(!SCRIPT_VERIFY(!pVehicle->GetSeatManager()->GetPedInSeat(iSeatIndex), "TASK_WARP_PED_INTO_VEHICLE - Vehicle already has a passenger in the specified seat"))
return;
}
CTaskSetPedInVehicle* pTask=rage_new CTaskSetPedInVehicle(pVehicle, iSeatIndex, CPed::PVF_Warp);
CScriptPeds::GivePedScriptedTask( iPedID, pTask, SCRIPT_TASK_WARP_PED_INTO_VEHICLE, "TASK_WARP_PED_INTO_VEHICLE");
}
}
// Warps a ped to a position on an entity with defined combination of limbs attached and sets the ped to ragdoll.
void CommandTaskNMAttachPedToEntity(int iPedID, int iEntityID, int iAttachParentBone, const scrVector & vOffset, const scrVector & vRotation, int iAttachFlags, const char* pAnimDict, const char * pGetOnAnimName, const char* pIdleAnimName, int RotOrder)
{
s32 animDictIndex;
CPhysical* pEntity = CTheScripts::GetEntityToModifyFromGUID<CPhysical>(iEntityID);
if(scriptVerifyf(!NetworkInterface::IsGameInProgress(), "TASK_NM_ATTACH_PED_TO_ENTITY - This script command is not allowed in network game scripts!"))
{
if(pEntity)
{
if(scriptVerifyf(fwAnimManager::GetClipIfExistsByName(pAnimDict, pGetOnAnimName), "Check that the dictionary: %s is loaded and the anim: %s is contained with the dictionary",pAnimDict ,pGetOnAnimName ))
{
if(scriptVerifyf(fwAnimManager::GetClipIfExistsByName(pAnimDict, pIdleAnimName), "Check that the dictionary: %s is loaded and the anim: %s is contained with the dictionary",pAnimDict ,pIdleAnimName))
{
animDictIndex = fwAnimManager::FindSlot(pAnimDict).Get();
Quaternion rotationQuaternion;
CScriptEulers::QuaternionFromEulers(rotationQuaternion, vRotation, static_cast<EulerAngleOrder>(RotOrder));
CTaskAnimatedAttach* pTaskAttach=rage_new CTaskAnimatedAttach(pEntity, iAttachParentBone, vOffset, rotationQuaternion, iAttachFlags, animDictIndex, atStringHash(pGetOnAnimName), atStringHash(pIdleAnimName) );
CScriptPeds::GivePedScriptedTask( iPedID, pTaskAttach, SCRIPT_TASK_NM_ATTACH_TO_VEHICLE, "TASK_NM_ATTACH_PED_TO_ENTITY");
}
}
}
}
}
void CommandTaskShootAtEntity( int iPedID, int iEntityID, int iTime, int iFiringPatternHash )
{
if (SCRIPT_VERIFY((iTime == -1) || (iTime > 0) ,"TASK_SHOOT_AT_ENTITY - Time must be -1 for infinite and > 0" ))
{
const CEntity *pEntity = CTheScripts::GetEntityToQueryFromGUID<CEntity>(iEntityID);
if(pEntity)
{
CTaskGun* pTaskGun = rage_new CTaskGun(CWeaponController::WCT_Fire, CTaskTypes::TASK_AIM_GUN_ON_FOOT, CWeaponTarget(pEntity), ((float) iTime) / 1000.0f);
pTaskGun->SetAllowRestartAfterAbort(true);
if(iFiringPatternHash)
{
pTaskGun->SetFiringPatternHash(iFiringPatternHash);
}
CScriptPeds::GivePedScriptedTask(iPedID, pTaskGun, SCRIPT_TASK_SHOOT_AT_ENTITY, "TASK_SHOOT_AT_ENTITY");
#if 0 // This block of code is an attempt to make this task work for a mounted ped, left in // for reference. Was hoping that we could just use CTaskGun with CTaskAimGunVehicleDriveBy, // but there were some complications. Basically, if we bypass CTaskVehicleGun, there is nothing // streaming in the animations that CTaskAimGunVehicleDriveBy needs. If on the other hand // we create a CTaskVehicleGun instead of CTaskGun, we probably won't have support for // the time parameter. /FF
CTaskTypes::eTaskType aimTaskType = CTaskTypes::TASK_AIM_GUN_ON_FOOT;
const CPed* pPed = CTheScripts::GetEntityToQueryFromGUID<CPed>(iPedID);
if(pPed && pPed->GetMyMount())
{
aimTaskType = CTaskTypes::TASK_AIM_GUN_VEHICLE_DRIVE_BY;
}
CTaskGun* pTaskGun = rage_new CTaskGun(CWeaponController::WCT_Fire, aimTaskType, CWeaponTarget(pEntity), ((float) iTime) / 1000.0f);
if(aimTaskType == CTaskTypes::TASK_AIM_GUN_VEHICLE_DRIVE_BY)
{
const CVehicleDriveByInfo* pDrivebyInfo = CVehicleMetadataMgr::GetVehicleDriveByInfoFromPed(pPed);
taskAssert(pDrivebyInfo);
const CVehicleDriveByAnimInfo* pAnimInfo = CVehicleMetadataMgr::GetDriveByAnimInfoForWeapon(pPed, pPed->GetWeaponManager()->GetEquippedWeaponHash());
pTaskGun->SetOverrideClipSetId(pAnimInfo->GetClipSet());
}
#endif } } }
void CommandTaskClimb( int iPedID, bool UNUSED_PARAM(bUsePlayerLaunchForce) )
{
CTask* pTask = rage_new CTaskJumpVault(JF_ForceVault);
CScriptPeds::GivePedScriptedTask( iPedID, pTask, SCRIPT_TASK_CLIMB, "TASK_CLIMB" );
}
void CommandTaskClimbLadder( int iPedID, bool bFast )
{
CTask *pTask=rage_new CTaskClimbLadderFully(bFast);
CScriptPeds::GivePedScriptedTask( iPedID,pTask, SCRIPT_TASK_CLIMB_LADDER, "TASK_CLIMB_LADDER");
}
void CommandTaskRappelDownWall( int iPedID, const scrVector & scrVecStartPos, const scrVector & scrVecRopeAnchorPos, float fDestinationHeight, int ropeID )
{
ropeManager* pRopeManager = CPhysics::GetRopeManager();
if( SCRIPT_VERIFY(pRopeManager, "Rope Manager doesn't exist or is damaged!") )
{
ropeInstance* pRope = pRopeManager->FindRope( ropeID );
if( scriptVerifyf(pRope, "Rope with ID: %d, doesn't exist or is damaged!", ropeID) )
{
Vector3 vStartPos(scrVecStartPos);
Vector3 vAnchorPos(scrVecRopeAnchorPos);
CTask *pTask = rage_new CTaskRappel(fDestinationHeight, vStartPos, vAnchorPos, ropeID, CLIP_SET_ID_INVALID);
CScriptPeds::GivePedScriptedTask(iPedID, pTask, SCRIPT_TASK_RAPPEL_DOWN_WALL, "TASK_RAPPEL_DOWN_WALL");
}
}
}
void CommandTaskRappelDownWallUsingClipsetOverride(int iPedID, const scrVector & scrVecStartPos, const scrVector & scrVecRopeAnchorPos, float fDestinationHeight, int ropeID, const char* szOverrideRappelClipset, bool bSkipClimbOverWall)
{
ropeManager* pRopeManager = CPhysics::GetRopeManager();
if (SCRIPT_VERIFY(pRopeManager, "Rope Manager doesn't exist or is damaged!"))
{
ropeInstance* pRope = pRopeManager->FindRope(ropeID);
if (scriptVerifyf(pRope, "Rope with ID: %d, doesn't exist or is damaged!", ropeID))
{
if (szOverrideRappelClipset)
{
fwMvClipSetId setId(szOverrideRappelClipset);
if (SCRIPT_VERIFYF(fwClipSetManager::GetClipSet(setId) != NULL, "ClipSet %s did not exist. Are you sure it is in clip_sets.xml?", szOverrideRappelClipset))
{
Vector3 vStartPos(scrVecStartPos);
Vector3 vAnchorPos(scrVecRopeAnchorPos);
CTask *pTask = rage_new CTaskRappel(fDestinationHeight, vStartPos, vAnchorPos, ropeID, setId, bSkipClimbOverWall);
CScriptPeds::GivePedScriptedTask(iPedID, pTask, SCRIPT_TASK_RAPPEL_DOWN_WALL, "TASK_RAPPEL_DOWN_WALL");
}
}
}
}
}
int CommandsGetTaskRappelDownWallState( int iPedID )
{
const CPed *pPed = CTheScripts::GetEntityToQueryFromGUID<CPed>(iPedID);
if(pPed && pPed->GetPedIntelligence()->GetQueriableInterface()->IsTaskCurrentlyRunning(CTaskTypes::TASK_RAPPEL))
{
return pPed->GetPedIntelligence()->GetQueriableInterface()->GetStateForTaskType(CTaskTypes::TASK_RAPPEL);
}
return -1;
}
void CommandClearPedTasksImmediately(int iPedID)
{
CPed *pPed = CTheScripts::GetEntityToModifyFromGUID<CPed>(iPedID, CTheScripts::GUID_ASSERT_FLAGS_INCLUDE_CLONES);
if(pPed)
{
pPed->SetPedResetFlag(CPED_RESET_FLAG_ScriptClearingPedTasks, true);
if(pPed->IsNetworkClone())
{
bool bClearTasksImmediately = true;
CClearPedTasksEvent::Trigger(pPed, bClearTasksImmediately);
}
else
{
AI_LOG_WITH_ARGS_IF_SCRIPT_OR_PLAYER_PED(pPed, "[Script] - Ped %s has had tasks cleared immediately by script %s\n", AILogging::GetDynamicEntityNameSafe(pPed), CTheScripts::GetCurrentScriptName());
// instantly blend out any remaining animation before the flush
pPed->GetMovePed().SwitchToAnimated(0, false, true);
pPed->GetPedIntelligence()->FlushImmediately(true);
pPed->SetIsCrouching(false);
pPed->StopAllMotion(true);
// B*2979918 - too late to change for SP, but don't clear the helmet in MP when clearing tasks. It should be managed separately
if (!NetworkInterface::IsGameInProgress())
{
if (pPed->GetHelmetComponent())
pPed->GetHelmetComponent()->DisableHelmet();
}
pPed->SetPedResetFlag( CPED_RESET_FLAG_IsDrowning, false );
}
pPed->SetTimeSincePedInWater(60.0f); //B* 1150689
#if __DEV // Record the task in the debug list static char stringName[] = "CLEAR_PED_TASKS_IMMEDIATELY"; pPed->GetPedIntelligence()->AddScriptHistoryString(stringName, stringName, CTheScripts::GetCurrentScriptName(), CTheScripts::GetCurrentGtaScriptThread()->GetThreadPC()); #endif } }
void CommandTaskPerformSequenceFromProgress( int iPedID, int iTaskIndex, int iProgress1, int iProgress2 )
{
const int iTaskID = GetActualSequenceId(iTaskIndex);
if(SCRIPT_VERIFY(iTaskID>=0 && iTaskID<CTaskSequences::MAX_NUM_SEQUENCE_TASKS, "TASK_PERFORM_SEQUENCE_FROM_PROGRESS - Sequence task ID too big"))
{
if(SCRIPT_VERIFY(!CTaskSequences::ms_bIsOpened[iTaskID], "TASK_PERFORM_SEQUENCE_FROM_PROGRESS - Sequence task is still open"))
{
if(SCRIPT_VERIFY(!CTaskSequences::ms_TaskSequenceLists[iTaskID].IsEmpty(), "TASK_PERFORM_SEQUENCE_FROM_PROGRESS - sequence task empty"))
{
if(SCRIPT_VERIFY(iProgress1>=0 && iProgress1<CTaskList::MAX_LIST_SIZE, "TASK_PERFORM_SEQUENCE_FROM_PROGRESS - Sequence task ID too big"))
{
if(SCRIPT_VERIFY(iProgress2<CTaskList::MAX_LIST_SIZE, "TASK_PERFORM_SEQUENCE_FROM_PROGRESS - Sequence task ID too big"))
{
CTaskUseSequence* pTask=rage_new CTaskUseSequence(iTaskID, iTaskIndex);
pTask->SetProgress((u32)iProgress1,iProgress2);
CScriptPeds::GivePedScriptedTask( iPedID,pTask, SCRIPT_TASK_PERFORM_SEQUENCE_FROM_PROGRESS, "TASK_PERFORM_SEQUENCE_FROM_PROGRESS");
}
}
}
}
}
}
float CommandGetPedDesiredMoveBlendRatio( int iPedIndex )
{
const CPed *pPed = CTheScripts::GetEntityToQueryFromGUID<CPed>(iPedIndex);
if (pPed)
{
return pPed->GetMotionData()->GetDesiredMbrY();
}
return 0;
}
void CommandSetNextDesiredMoveState( float /*NextMoveState*/ )
{
scriptAssertf(0, "%s:SET_NEXT_DESIRED_MOVE_STATE - Function is deprecated - do not use anymore", CTheScripts::GetCurrentScriptNameAndProgramCounter());
}
void CommandSetPedDesiredMoveBlendRatio( int iPedID, float fNewMoveBlendRatio )
{
if(!scriptVerifyf(fNewMoveBlendRatio >= MOVEBLENDRATIO_STILL && fNewMoveBlendRatio <= MOVEBLENDRATIO_SPRINT, "SET_PED_DESIRED_MOVE_BLEND_RATIO - move blend ratio %f out of range (%.2f:%.2f)", fNewMoveBlendRatio, MOVEBLENDRATIO_STILL, MOVEBLENDRATIO_SPRINT))
{
fNewMoveBlendRatio = Clamp(fNewMoveBlendRatio, MOVEBLENDRATIO_STILL, MOVEBLENDRATIO_SPRINT);
}
CPed *pPed = CTheScripts::GetEntityToModifyFromGUID<CPed>(iPedID);
if(pPed)
{
//Assertf(fMoveBlendRatio >= MOVEBLENDRATIO_STILL && fMoveBlendRatio <= MOVEBLENDRATIO_SPRINT, "MODIFY_PED_MOVE_BLEND_RATIO - Ratio must be between 0..3 inclusive");
// Generally speaking we will want to look for the control-movement task in the primary (script) slot.
// However there's an exception to this rule : if the ped is in a group, they may be entering a vehicle
// via a task which has been given them in response to CEventLeaderEnteredCarAsDriver (etc), in which
// case we will want to find the control movement in the TASK_PRIORITY_EVENT_RESPONSE_NONTEMP slot.
CTaskComplexControlMovement * pCtrlMove = NULL;
CPedIntelligence * pPedAi = pPed->GetPedIntelligence();
const int iTaskPriority = pPedAi->GetTaskManager()->GetActiveTaskPriority(PED_TASK_TREE_PRIMARY);
if(pPed->GetPedsGroup()!=NULL && iTaskPriority==PED_TASK_PRIORITY_EVENT_RESPONSE_NONTEMP
&& pPedAi->GetCurrentEventType()==EVENT_LEADER_ENTERED_CAR_AS_DRIVER)
{
pCtrlMove = (CTaskComplexControlMovement*)pPed->GetPedIntelligence()->FindTaskActiveByType(CTaskTypes::TASK_COMPLEX_CONTROL_MOVEMENT);
}
else
{
pCtrlMove = (CTaskComplexControlMovement*)pPed->GetPedIntelligence()->FindTaskPrimaryByType(CTaskTypes::TASK_COMPLEX_CONTROL_MOVEMENT);
}
if(!pCtrlMove)
{
return;
}
CTask * pRunningMoveTask = pCtrlMove->GetRunningMovementTask(pPed);
CTask * pBackUpMoveTask = pCtrlMove->GetBackupCopyOfMovementSubtask();
if(pRunningMoveTask)
{
Assert(pRunningMoveTask->IsMoveTask());
pRunningMoveTask->PropagateNewMoveSpeed(fNewMoveBlendRatio);
}
if(pBackUpMoveTask)
{
Assert(pBackUpMoveTask->IsMoveTask());
pBackUpMoveTask->PropagateNewMoveSpeed(fNewMoveBlendRatio);
}
}
}
void CommandTaskGotoEntityAiming( int iPedID, int iEntityID, float fSeekRadius, float fAimRadius )
{
CTask *pTask;
const CEntity* pEntity = CTheScripts::GetEntityToQueryFromGUID<CEntity>(iEntityID);
if(pEntity)
{
Assert(fAimRadius>=fSeekRadius);
pTask=rage_new CTaskSeekEntityAiming(pEntity,fSeekRadius,fAimRadius);
CScriptPeds::GivePedScriptedTask( iPedID,pTask, SCRIPT_TASK_GOTO_ENTITY_AIMING, "TASK_GOTO_ENTITY_AIMING");
}
}
void CommandTaskSetDecisionMaker( int iPedID, int iDecisionMakerId )
{
if(SCRIPT_VERIFY(iDecisionMakerId != NULL_IN_SCRIPTING_LANGUAGE, "TASK_SET_DECISION_MAKER - NULL passed for decision maker, or variable not initialised"))
{
if(NULL_IN_SCRIPTING_LANGUAGE!=iPedID)
{
CPed* pPed = CTheScripts::GetEntityToModifyFromGUID<CPed>(iPedID);
if(pPed)
{
if(SCRIPT_VERIFY(pPed->IsPlayer() == false, "TASK_SET_PED_DECISION_MAKER - Can't change a player's decision maker"))
{
pPed->GetPedIntelligence()->SetDecisionMakerId(iDecisionMakerId);
}
}
}
else
{
CTask* pTask=rage_new CTaskSetCharDecisionMaker(iDecisionMakerId);
CScriptPeds::GivePedScriptedTask(iPedID, pTask, SCRIPT_TASK_SET_PED_DECISION_MAKER, "TASK_SET_DECISION_MAKER");
}
}
}
void SetPedDefensiveIfNeeded( CPed* pPed )
{
if(pPed)
{
// If our ped is set as will advance movement then change it to defensive
CCombatBehaviour& pedCombatBehaviour = pPed->GetPedIntelligence()->GetCombatBehaviour();
if(pedCombatBehaviour.GetCombatMovement() == CCombatData::CM_WillAdvance)
{
pedCombatBehaviour.SetCombatMovement(CCombatData::CM_Defensive);
}
}
}
void CommandTaskSetSphereDefensiveArea(int iPedID, const scrVector & scrVecCenter, float fRadius )
{
Vector3 vCenter(scrVecCenter);
if(NULL_IN_SCRIPTING_LANGUAGE != iPedID)
{
CPed *pPed = CTheScripts::GetEntityToModifyFromGUID<CPed>(iPedID);
if (pPed)
{
pPed->GetPedIntelligence()->GetDefensiveAreaManager()->GetPrimaryDefensiveArea()->SetAsSphere( vCenter, fRadius, NULL );
SetPedDefensiveIfNeeded(pPed);
}
}
else
{
CTask* pTask = rage_new CTaskSetPedDefensiveArea(vCenter, fRadius);
CScriptPeds::GivePedScriptedTask(iPedID, pTask, SCRIPT_TASK_SET_PED_DEFENSIVE_AREA, "TASK_SET_PED_SPHERE_DEFENSIVE_AREA");
}
}
void CommandTaskClearDefensiveArea(int iPedID)
{
bool bGivePedTask = true;
if(NULL_IN_SCRIPTING_LANGUAGE != iPedID)
{
CPed *pPed = CTheScripts::GetEntityToModifyFromGUID<CPed>(iPedID);
if (pPed && !pPed->IsNetworkClone())
{
pPed->GetPedIntelligence()->GetDefensiveAreaManager()->GetPrimaryDefensiveArea()->Reset();
bGivePedTask = false;
}
}
if(bGivePedTask)
{
CTask* pTask = rage_new CTaskSetPedDefensiveArea();
CScriptPeds::GivePedScriptedTask(iPedID, pTask, SCRIPT_TASK_SET_PED_DEFENSIVE_AREA, "TASK_CLEAR_DEFENSIVE_AREA");
}
}
void CommandTaskPedSlideToCoordWithHeadingChangeRate(int iPedID, const scrVector & scrVecCoors, float fHeadingDegs, float fSpeed, float fHdgChangeRate)
{
while(fHeadingDegs < 0.0f) fHeadingDegs += 360.0f;
while(fHeadingDegs >= 360.0f) fHeadingDegs -= 360.0f;
const float heading=( DtoR * fHeadingDegs);
float speed=fSpeed;
if(speed<0)
{
speed=0.1f;
}
Vector3 v(scrVecCoors);
#if __DEV if(NULL_IN_SCRIPTING_LANGUAGE != iPedID) { const CPed *pPed = CTheScripts::GetEntityToQueryFromGUID(iPedID); if(pPed) scriptAssertf(DistSquared(RCC_VEC3V(v), pPed->GetTransform().GetPosition()).Getf() < 100.0f, "TASK_PED_SLIDE_TO_COORD_HDG_RATE is moving a ped over 10m."); } #endif
static dev_float fTargetRadius = 0.125f; //CTaskMoveGoToPointAndStandStill::ms_fTargetRadius;
CTaskSequenceList* pTaskList = rage_new CTaskSequenceList();
CTaskMoveGoToPointAndStandStill * pGotoTask = rage_new CTaskMoveGoToPointAndStandStill(MOVEBLENDRATIO_WALK, v, fTargetRadius);
pTaskList->AddTask(rage_new CTaskComplexControlMovement(pGotoTask));
CTaskSlideToCoord * pTaskSlide = rage_new CTaskSlideToCoord(v,heading,speed);
pTaskSlide->SetHeadingIncrement( ( DtoR * fHdgChangeRate) );
pTaskList->AddTask(pTaskSlide);
CScriptPeds::GivePedScriptedTask( iPedID, pTaskList, SCRIPT_TASK_PED_SLIDE_TO_COORD, "TASK_PED_SLIDE_TO_COORD_HDG_RATE");
}
void CommandTaskPedSlideToCoord(int iPedID, const scrVector & scrVecCoors, float fHeadingDegs, float fSpeed)
{
CommandTaskPedSlideToCoordWithHeadingChangeRate(iPedID, scrVecCoors, fHeadingDegs, fSpeed, 0.0f);
}
//This command is not called by any include_command.sch but needs to be incorporated into CommandTaskPedSlideToCoordAndPlayAnim
void CommandTaskPedSlideToCoordAndPlayAnimWithHeadingChangeRate( int iPedID,
const scrVector & scrVecCoors,
float fHeadingDegrees, float fSpeed,
const char* AnimName, const char* AnimDictName,
float fBlendDelta,
bool bLooped, bool bExtractBackwardsVelocity, bool bExtractSidewaysVelocity, bool bHoldOnLastFrame,
int iTime, float fHdgChangeRate)
{
while(fHeadingDegrees < 0.0f) fHeadingDegrees += 360.0f;
while(fHeadingDegrees >= 360.0f) fHeadingDegrees -= 360.0f;
const float heading=( DtoR * fHeadingDegrees);
float speed=fSpeed;
if(speed<0)
{
speed=0.1f;
}
s32 flags = 0;
if ( bLooped || (iTime > 0) )
{
flags |= APF_ISLOOPED;
}
if (bExtractBackwardsVelocity)
{
//flags |= APF_CANEXTRACTYVELOCITY; //These flags no longer exist: GS 09/12/2009
}
if (bHoldOnLastFrame == false)
{
flags |= APF_ISFINISHAUTOREMOVE;
}
if (bExtractSidewaysVelocity)
{
//scriptAssertf(bExtractBackwardsVelocity, "%s:TASK_PLAY_ANIM - If you want to extract sideways velocity you have to extract forwards velocity too", CTheScripts::GetCurrentScriptNameAndProgramCounter());
//flags |= APF_CANEXTRACTXVELOCITY; //These flags no longer exist: GS 09/12/2009
}
bool bRunInSequence=false;
if(CTaskSequences::ms_iActiveSequence>=0)
{
bRunInSequence=true;
}
Vector3 v(scrVecCoors);
#if __DEV const CPed *pPed = CTheScripts::GetEntityToQueryFromGUID(iPedID); if(pPed) scriptAssertf(DistSquared(RCC_VEC3V(v), pPed->GetTransform().GetPosition()).Getf() < 100.0f, "TASK_PED_SLIDE_TO_COORD_HDG_RATE is moving a ped over 10m."); #endif
static dev_float fTargetRadius = 0.125f; //CTaskMoveGoToPointAndStandStill::ms_fTargetRadius;
CTaskSequenceList* pTaskList = rage_new CTaskSequenceList();
// JB: Slightly larger target radius, since peds were occasionally overshooting their target & then sliding back
CTaskMoveGoToPointAndStandStill * pTaskGoto = rage_new CTaskMoveGoToPointAndStandStill(MOVEBLENDRATIO_WALK, v, fTargetRadius);
pTaskList->AddTask(rage_new CTaskComplexControlMovement(pTaskGoto) );
CTaskSlideToCoord * pTaskSlide;
if (iTime > 0)
{
pTaskSlide = rage_new CTaskSlideToCoord(v,heading,speed,AnimName,AnimDictName,flags,fBlendDelta,bRunInSequence,iTime);
}
else
{
pTaskSlide = rage_new CTaskSlideToCoord(v,heading,speed,AnimName,AnimDictName,flags,fBlendDelta,bRunInSequence);
}
pTaskSlide->SetHeadingIncrement( ( DtoR * fHdgChangeRate) );
pTaskList->AddTask(pTaskSlide);
CScriptPeds::GivePedScriptedTask( iPedID, pTaskList, SCRIPT_TASK_PED_SLIDE_TO_COORD_AND_PLAY_ANIM, "TASK_PED_SLIDE_TO_COORD_AND_PLAY_ANIM_HDG_RATE");
}
void CommandTaskPedSlideToCoordAndPlayAnim(
int iPedID,
const scrVector & scrVecCoors,
float fHeadingDegrees, float fSpeed,
const char* AnimName, const char* AnimDictName,
float fBlendDelta,
bool bLooped, bool bExtractBackwardsVelocity, bool bExtractSidewaysVelocity, bool bHoldOnLastFrame,
int iTime)
{
CommandTaskPedSlideToCoordAndPlayAnimWithHeadingChangeRate(
iPedID, scrVecCoors, fHeadingDegrees, fSpeed, AnimName, AnimDictName, fBlendDelta, bLooped,
bExtractBackwardsVelocity, bExtractSidewaysVelocity, bHoldOnLastFrame, iTime, 0.0f);
}
void CommandTaskDrivePointRouteAdvanced( int iPedID, int iVehicleID, float fCruiseSpeed, int iMode, int VehicleModelHashKey, int iDrivingStyle)
{
CVehicle* pVehicle = CTheScripts::GetEntityToModifyFromGUID<CVehicle>(iVehicleID, CTheScripts::GUID_ASSERT_FLAGS_INCLUDE_CLONES);
if(pVehicle)
{
fwModelId VehicleModelId;
if (VehicleModelHashKey != DUMMY_ENTRY_IN_MODEL_ENUM_FOR_SCRIPTING_LANGUAGE)
{
CModelInfo::GetBaseModelInfoFromHashKey((u32) VehicleModelHashKey, &VehicleModelId); // ignores return value
scriptAssertf( VehicleModelId.IsValid(), "%s:TASK_DRIVE_POINT_ROUTE_ADVANCED - this is not a valid model index", CTheScripts::GetCurrentScriptNameAndProgramCounter());
}
CTask* pTask=rage_new CTaskDrivePointRoute(pVehicle,CTaskMoveFollowPointRoute::ms_pointRoute,fCruiseSpeed,iMode,VehicleModelId.GetModelIndex(),7.0f,iDrivingStyle); // 7.0 was -1.0 (finished radius)
CScriptPeds::GivePedScriptedTask( iPedID, pTask, SCRIPT_TASK_DRIVE_POINT_ROUTE_ADVANCED, "TASK_DRIVE_POINT_ROUTE_ADVANCED");
}
}
void CommandTaskGuardAssignedDefensiveArea(int iPedIndex, const scrVector & vDefendPosition, float fHeading, float fMaxPatrolProximity, int nTimer)
{
if (SCRIPT_VERIFY((nTimer == -1) || (nTimer > 0) ,"TASK_GUARD_ASSIGNED_DEFENSIVE_AREA - Time must be -1 for infinite and > 0" ))
{
Vector3 vDefendPosV3 = vDefendPosition;
float fNewPedHeading = fHeading;
float fTimer = ((float) nTimer)/1000.0f;
while (fNewPedHeading < 0.0f)
{
fNewPedHeading += 360.0f;
}
while (fNewPedHeading > 360.0f)
{
fNewPedHeading -= 360.0f;
}
CTask* pTask = rage_new CTaskStandGuard( vDefendPosV3, ( DtoR * fNewPedHeading), fMaxPatrolProximity, GM_PatrolDefensiveArea, fTimer);
CScriptPeds::GivePedScriptedTask(iPedIndex, pTask, SCRIPT_TASK_GUARD_DEFENSIVE_AREA, "TASK_GUARD_ASSIGNED_DEFENSIVE_AREA");
}
}
void CommandTaskGuardAngledDefensiveArea(int iPedIndex, const scrVector & vDefendPosition, float fHeading, float fMaxPatrolProximity, int iTime, const scrVector & sv1, const scrVector & sv2, float fDefensiveAreaWidth)
{
if (SCRIPT_VERIFY((iTime == -1) || (iTime > 0) ,"TASK_GUARD_ANGLED_DEFENSIVE_AREA - Time must be -1 for infinite and > 0" ))
{
scriptAssertf(fDefensiveAreaWidth >= CDefensiveArea::GetMinRadius(), "TASK_GUARD_ANGLED_DEFENSIVE_AREA - defensive area radius should be at least %.2f, but passed in - %.2f",CDefensiveArea::GetMinRadius(),fDefensiveAreaWidth);
Vector3 vDefendPosV3 = vDefendPosition;
float fNewPedHeading = fHeading;
float fTimer = ((float) iTime)/1000.0f;
if (fNewPedHeading < 0.0f)
{
fNewPedHeading += 360.0f;
}
if (fNewPedHeading > 360.0f)
{
fNewPedHeading -= 360.0f;
}
Vector3 v1 = sv1;
Vector3 v2 = sv2;
CDefensiveArea area;
area.Set(v1, v2, fDefensiveAreaWidth);
CTask* pTask = rage_new CTaskSetAndGuardArea( vDefendPosV3, ( DtoR * fNewPedHeading), fMaxPatrolProximity, GM_PatrolDefensiveArea, fTimer, area );
CScriptPeds::GivePedScriptedTask(iPedIndex, pTask, SCRIPT_TASK_GUARD_ANGLED_DEFENSIVE_AREA, "TASK_GUARD_ANGLED_DEFENSIVE_AREA");
}
}
void CommandTaskGuardSphereDefensiveArea(int iPedIndex, const scrVector & vDefendPosition, float fHeading, float fMaxPatrolProximity, int iTime, const scrVector & sv1, float fDefensiveAreaRadius)
{
if (SCRIPT_VERIFY((iTime == -1) || (iTime > 0) ,"TASK_GUARD_SPHERE_DEFENSIVE_AREA - Time must be -1 for infinite and > 0" ))
{
Vector3 v1 = sv1;
Vector3 vDefendPosV3 = vDefendPosition;
float fNewPedHeading = fHeading;
float fTimer = ((float) iTime)/1000.0f;
scriptAssertf(!vDefendPosV3.IsClose(VEC3_ZERO, SMALL_FLOAT), "TASK_GUARD_SPHERE_DEFENSIVE_AREA is tasking a ped to defend the origin. This is is very likely an error.");
scriptAssertf(fDefensiveAreaRadius >= CDefensiveArea::GetMinRadius(),"TASK_GUARD_SPHERE_DEFENSIVE_AREA - defensive area radius should be at least %.2f, but passed in - %.2f",CDefensiveArea::GetMinRadius(),fDefensiveAreaRadius);
if (fNewPedHeading < 0.0f)
{
fNewPedHeading += 360.0f;
}
if (fNewPedHeading > 360.0f)
{
fNewPedHeading -= 360.0f;
}
CDefensiveArea area;
area.SetAsSphere(v1, fDefensiveAreaRadius);
CTask* pTask = rage_new CTaskSetAndGuardArea( vDefendPosV3, ( DtoR * fNewPedHeading), fMaxPatrolProximity, GM_PatrolDefensiveArea, fTimer, area );
CScriptPeds::GivePedScriptedTask(iPedIndex, pTask, SCRIPT_TASK_GUARD_SPHERE_DEFENSIVE_AREA, "TASK_GUARD_SPHERE_DEFENSIVE_AREA");
}
}
void CommandTaskGuardCurrentPosition(int iPedIndex, float fMaxPatrolProximity, float fDefensiveAreaRadius, bool bSetDefensiveArea)
{
const CPed* pPed = CTheScripts::GetEntityToQueryFromGUID<CPed>(iPedIndex);
if (SCRIPT_VERIFY(pPed, "Invalid ped tasked with TASK_GUARD_CURRENT_POSITION"))
{
scriptAssertf(fDefensiveAreaRadius >= CDefensiveArea::GetMinRadius(),"TASK_GUARD_CURRENT_POSITION - defensive area radius should be at least %.2f, but passed in - %.2f",CDefensiveArea::GetMinRadius(),fDefensiveAreaRadius);
Vector3 vDefendPosV3 = VEC3V_TO_VECTOR3(pPed->GetTransform().GetPosition());
CDefensiveArea area;
area.SetAsSphere(vDefendPosV3, fDefensiveAreaRadius);
float fTimer = -1.0f;
eGuardMode guardMode = bSetDefensiveArea ? GM_PatrolDefensiveArea : GM_PatrolProximity;
CTask* pTask = rage_new CTaskSetAndGuardArea( vDefendPosV3, pPed->GetCurrentHeading(), fMaxPatrolProximity, guardMode, fTimer, area, true, bSetDefensiveArea );
CScriptPeds::GivePedScriptedTask(iPedIndex, pTask, SCRIPT_TASK_GUARD_CURRENT_POSITION, "TASK_GUARD_CURRENT_POSITION");
}
}
// Stand guard at a position
void CommandTaskStandGuard(int iPedIndex, const scrVector & vDefendPosition, float fHeading, const char* szContext)
{
Vector3 vDefendPosV3 = vDefendPosition;
float fNewPedHeading = fHeading;
fwAngle::LimitDegreeAngle(fNewPedHeading);
if (strcmp(szContext,"Default") == 0)
{
CTask* pTask = rage_new CTaskStandGuardFSM( vDefendPosV3, ( DtoR * fNewPedHeading));
CScriptPeds::GivePedScriptedTask(iPedIndex, pTask, SCRIPT_TASK_STAND_GUARD, "TASK_STAND_GUARD");
}
else
{
s32 scenarioType = CScenarioManager::GetScenarioTypeFromHashKey(atStringHash(szContext));
CTask* pTask = rage_new CTaskStandGuardFSM( vDefendPosV3, ( DtoR * fNewPedHeading),scenarioType);
CScriptPeds::GivePedScriptedTask(iPedIndex, pTask, SCRIPT_TASK_STAND_GUARD, "TASK_STAND_GUARD");
}
}
// Add a scripted cover point
int CommandAddCoverPoint( const scrVector & scrVecCoors, float fDirection, s32 iUsage, s32 iHeight, s32 iArc, bool bIsPriority)
{
AI_LOG_WITH_ARGS("[Script] - Script %s is adding a coverpoint at position (%.2f, %.2f, %.2f)", CTheScripts::GetCurrentScriptName(), scrVecCoors.x, scrVecCoors.y, scrVecCoors.z);
AI_LOG_STACK_TRACE(8);
CScriptResource_Coverpoint coverPoint(Vector3(scrVecCoors), fDirection, iUsage, iHeight, iArc, bIsPriority);
return CTheScripts::GetCurrentGtaScriptHandler()->RegisterScriptResourceAndGetRef(coverPoint);
}
// Remove a scripted cover point
void CommandRemoveCoverPoint( int iIdentifier )
{
AI_LOG_WITH_ARGS("[Script] - Script %s is removing a cover point with ID %d", CTheScripts::GetCurrentScriptName(), iIdentifier);
AI_LOG_STACK_TRACE(8);
CTheScripts::GetCurrentGtaScriptHandler()->RemoveScriptResource(CGameScriptResource::SCRIPT_RESOURCE_COVERPOINT, iIdentifier);
}
bool CommandDoesScriptedCoverPointExistAtCoords( const scrVector & scrVecCoors )
{
CCoverPoint* pOverlappingCoverPoint = NULL;
if (!CCoverPointsContainer::CheckIfNoOverlapAndGetGridCell(scrVecCoors, CCoverPoint::COVTYPE_SCRIPTED, NULL, pOverlappingCoverPoint, false))
{
return true;
}
else
{
return false;
}
}
scrVector CommandGetScriptedCoverPointCoords( int iIdentifier )
{
CScriptedCoverPoint* pScriptedCoverPoint = CTheScripts::GetScriptedCoverPointToModifyFromGUID(iIdentifier);
if (SCRIPT_VERIFY(pScriptedCoverPoint ,"GET_SCRIPTED_COVER_POINT_COORDS - Identifier is invalid" ))
{
CCoverPoint* pCoverPoint = CCover::FindCoverPointWithIndex(pScriptedCoverPoint->GetScriptIndex());
if (scriptVerifyf(pCoverPoint, "GET_SCRIPTED_COVER_POINT_COORDS - Cover Point %i Doesn't Exist", iIdentifier))
{
Vector3 vCoverPos(Vector3::ZeroType);
if (scriptVerifyf(pCoverPoint->GetCoverPointPosition(vCoverPos), "GET_SCRIPTED_COVER_POINT_COORDS - Couldn't get cover point coords for cover point with index %i", iIdentifier))
{
return vCoverPos;
}
}
}
return VEC3_ZERO;
}
// Add a scripted cover area which will be appended to the streamed cover area array
void CommandAddScriptedCoverArea(const scrVector & scrVecCoors, const float fRadius)
{
if (CPed* pPlayer = CGameWorld::FindLocalPlayer())
{
Vector3 vFrom(scrVecCoors);
Vector3 vDistance = VEC3V_TO_VECTOR3(pPlayer->GetTransformPtr()->GetPosition()) - vFrom;
float fDistance2 = vDistance.Mag2();
if (scriptVerifyf(fDistance2 < rage::square(200), "ADD_SCRIPTED_COVER_AREA - Scripted Area Cover distance from player is %fm, it must be within 200m to add.", vDistance.Mag()))
{
AI_LOG_WITH_ARGS("[Script] - Script %s is adding a scripted cover area at position (%.2f, %.2f, %.2f) with a radius of %.2f", CTheScripts::GetCurrentScriptName(), scrVecCoors.x, scrVecCoors.y, scrVecCoors.z, fRadius);
CCover::AddNewScriptedCoverArea(scrVecCoors, fRadius);
}
}
}
/*int CommandGetScriptedCoverPointStatus( int iIdentifier )
{
CScriptedCoverPoint* pScriptedCoverPoint = CTheScripts::GetScriptedCoverPointToModifyFromGUID(iIdentifier);
if (scriptVerifyf(pScriptedCoverPoint, "GET_SCRIPTED_COVER_POINT_STATUS - Cover Point %i Doesn't Exist", iIdentifier))
{
CCoverPoint* pCoverPoint = CCover::FindCoverPointWithIndex(pScriptedCoverPoint->GetScriptIndex());
if (scriptVerifyf(pCoverPoint, "GET_SCRIPTED_COVER_POINT_STATUS - Cover Point %i Doesn't Exist", iIdentifier))
{
return pCoverPoint->GetStatus();
}
}
return CCoverPoint::COVSTATUS_Invalid;
}*/
// Seek cover from the given position
void CommandTaskSeekCoverFromPos( int PedIndex, const scrVector & scrVecCoors, int iTime, bool bAllowPeekingAndFiring )
{
if (SCRIPT_VERIFY((iTime == -1) || (iTime > 0) ,"TASK_SEEK_COVER_FROM_POS - Time must be -1 for infinite and > 0" ))
{
float fTime = ( ( float )iTime ) / 1000.0f;
Vector3 vFrom(scrVecCoors);
CTaskCover* pCoverTask = rage_new CTaskCover(CAITarget(vFrom), bAllowPeekingAndFiring ? 0 : CTaskCover::CF_DisableAimingAndPeeking);
pCoverTask->SetSearchFlags(CTaskCover::CF_SeekCover | CTaskCover::CF_CoverSearchAny | CTaskCover::CF_ScriptedSeekCover);
pCoverTask->SetTimeInCover(fTime);
CScriptPeds::GivePedScriptedTask(PedIndex, pCoverTask, SCRIPT_TASK_SEEK_COVER_FROM_POS, "TASK_SEEK_COVER_FROM_POS");
}
}
// Seek cover from the given ped
void CommandTaskSeekCoverFromPed( int iPedIndex, int iOtherPedIndex, int iTime, bool bAllowPeekingAndFiring )
{
if (SCRIPT_VERIFY((iTime == -1) || (iTime > 0) ,"TASK_SEEK_COVER_FROM_PED - Time must be -1 for infinite and > 0" ))
{
float fTime = ( ( float )iTime ) / 1000.0f;
const CPed *pOtherPed = CTheScripts::GetEntityToQueryFromGUID<CPed>(iOtherPedIndex);
if(!pOtherPed)
return;
CTaskCover* pCoverTask = rage_new CTaskCover(CAITarget(pOtherPed), bAllowPeekingAndFiring ? 0 : CTaskCover::CF_DisableAimingAndPeeking);
pCoverTask->SetSearchFlags(CTaskCover::CF_SeekCover | CTaskCover::CF_CoverSearchAny | CTaskCover::CF_ScriptedSeekCover);
pCoverTask->SetTimeInCover(fTime);
CScriptPeds::GivePedScriptedTask(iPedIndex, pCoverTask, SCRIPT_TASK_SEEK_COVER_FROM_PED, "TASK_SEEK_COVER_FROM_PED");
}
}
// Seek cover to the given cover point, away from the position specified
void CommandTaskSeekCoverToCoverPoint( int iPedIndex, int iIdentifier, const scrVector & scrVecCoors, int iTime, bool bAllowPeekingAndFiring )
{
if (SCRIPT_VERIFY((iTime == -1) || (iTime > 0) ,"TASK_SEEK_COVER_TO_COVER_POINT - Time must be -1 for infinite and > 0" ))
{
float fTime = ( ( float )iTime ) / 1000.0f;
CScriptedCoverPoint* pScriptedCoverPoint = CTheScripts::GetScriptedCoverPointToModifyFromGUID(iIdentifier, "TASK_SEEK_COVER_TO_COVER_POINT");
if (scriptVerifyf(pScriptedCoverPoint, "Cover point with id %i didn't exist", iIdentifier))
{
s32 iCoverIndex = pScriptedCoverPoint->GetScriptIndex();
// Find the cover point specified by the identifier
#if __ASSERT
CCoverPoint* pCoverPoint = CCover::FindCoverPointWithIndex( iCoverIndex );
scriptAssertf(pCoverPoint, "%s:TASK_SEEK_COVER_TO_COVER_POINT - Invalid cover point specified", CTheScripts::GetCurrentScriptNameAndProgramCounter());
Assert( pCoverPoint->GetType() == CCoverPoint::COVTYPE_SCRIPTED );
#endif Vector3 vFrom(scrVecCoors);
CTaskCover* pCoverTask = rage_new CTaskCover(CAITarget(vFrom), bAllowPeekingAndFiring ? 0 : CTaskCover::CF_DisableAimingAndPeeking);
pCoverTask->SetSearchFlags(CTaskCover::CF_SeekCover | CTaskCover::CF_CoverSearchScripted | CTaskCover::CF_ScriptedSeekCover);
pCoverTask->SetScriptedCoverIndex(iCoverIndex);
pCoverTask->SetTimeInCover(fTime);
CScriptPeds::GivePedScriptedTask(iPedIndex, pCoverTask, SCRIPT_TASK_SEEK_COVER_TO_COVER_POINT, "TASK_SEEK_COVER_TO_COVER_POINT");
}
}
}
// Seek cover to the given coords, away from the position specified
void CommandTaskSeekCoverToCoords( int iPedIndex, const scrVector & scrVecCoverCoors, const scrVector & scrVecFromCoors, int iTime, bool bAllowPeekingAndFiring )
{
if (SCRIPT_VERIFY((iTime == -1) || (iTime > 0) ,"TASK_SEEK_COVER_TO_COVER_COORD - Time must be -1 for infinite and > 0" ))
{
float fTime = ( ( float )iTime ) / 1000.0f;
Vector3 vCover(scrVecCoverCoors);
Vector3 vFrom(scrVecFromCoors);
CTaskCover* pCoverTask = rage_new CTaskCover(CAITarget(vFrom), bAllowPeekingAndFiring ? 0 : CTaskCover::CF_DisableAimingAndPeeking);
pCoverTask->SetSearchFlags(CTaskCover::CF_SeekCover | CTaskCover::CF_CoverSearchByPos | CTaskCover::CF_ScriptedSeekCover);
pCoverTask->SetSearchPosition(vCover);
pCoverTask->SetTimeInCover(fTime);
CScriptPeds::GivePedScriptedTask(iPedIndex, pCoverTask, SCRIPT_TASK_SEEK_COVER_TO_COORDS, "TASK_SEEK_COVER_TO_COVER_COORD");
}
}
CTaskCover* CreatePutPedDirectlyIntoCoverTask( const scrVector & vscStart, const CAITarget& aiTarget, int iTime, bool bAllowPeekingAndFiring, float fBlendInDuration, bool bForceInitialFacingDirection, bool bForceFaceLeft, int iIdentifier, bool bDoEntry )
{
scriptAssertf(fBlendInDuration < 10.0f, "Setting a long blend in duration (%.2f) are you sure you want the anims to blend in this slowly?", fBlendInDuration);
float fTime = ( ( float )iTime ) / 1000.0f;
Vector3 vStart = vscStart;
s32 iCoverFlags = bAllowPeekingAndFiring ? CTaskCover::CF_PutPedDirectlyIntoCover : CTaskCover::CF_PutPedDirectlyIntoCover | CTaskCover::CF_DisableAimingAndPeeking;
if (bForceInitialFacingDirection)
{
aiDisplayf("TASK_PUT_PED_DIRECTLY_INTO_COVER called forcing ped to face %s at <<%.2f,%.2f,%.2f>>", bForceFaceLeft ? "Left" : "Right", vscStart.x, vscStart.y, vscStart.z);
iCoverFlags |= CTaskCover::CF_SpecifyInitialHeading;
if (bForceFaceLeft)
{
iCoverFlags |= CTaskCover::CF_FacingLeft;
}
}
// Set whether we want to skip the cover entry anims
if (!bDoEntry)
{
iCoverFlags |= CTaskCover::CF_SkipIdleCoverTransition;
}
CTaskCover* pCoverTask = rage_new CTaskCover(aiTarget, iCoverFlags);
CScriptedCoverPoint* pScriptedCoverPoint = NULL;
if (iIdentifier != NULL_IN_SCRIPTING_LANGUAGE)
{
pScriptedCoverPoint = CTheScripts::GetScriptedCoverPointToModifyFromGUID(iIdentifier, "TASK_PUT_PED_DIRECTLY_INTO_COVER");
}
if (pScriptedCoverPoint)
{
s32 iCoverIndex = pScriptedCoverPoint->GetScriptIndex();
#if __ASSERT // Find the cover point specified by the identifier CCoverPoint* pCoverPoint = CCover::FindCoverPointWithIndex( iCoverIndex ); scriptAssertf(pCoverPoint, "%s:TASK_SEEK_COVER_TO_COVER_POINT - Invalid cover point specified", CTheScripts::GetCurrentScriptNameAndProgramCounter()); Assert( pCoverPoint->GetType() == CCoverPoint::COVTYPE_SCRIPTED ); #endif pCoverTask->SetSearchFlags(CTaskCover::CF_CoverSearchScripted | CTaskCover::CF_ScriptedSeekCover); pCoverTask->SetScriptedCoverIndex(iCoverIndex); } else { pCoverTask->SetSearchFlags(CTaskCover::CF_FindClosestPointAtStart | CTaskCover::CF_ScriptedSeekCover); }
pCoverTask->SetBlendInDuration(fBlendInDuration);
pCoverTask->SetSearchPosition(vStart);
pCoverTask->SetTimeInCover(fTime);
return pCoverTask;
}
// Seek cover from the given position
void CommandTaskPutPedDirectlyIntoCover( int iPedIndex, const scrVector & vscStart, int iTime, bool bAllowPeekingAndFiring, float fBlendInDuration, bool bForceInitialFacingDirection, bool bForceFaceLeft, int iIdentifier, bool bDoEntry )
{
if (SCRIPT_VERIFY((iTime == -1) || (iTime > 0) ,"TASK_PUT_PED_DIRECTLY_INTO_COVER - Time must be -1 for infinite and > 0" ))
{
CTaskCover* pCoverTask = CreatePutPedDirectlyIntoCoverTask(vscStart, CAITarget(), iTime, bAllowPeekingAndFiring, fBlendInDuration, bForceInitialFacingDirection, bForceFaceLeft, iIdentifier, bDoEntry);
CScriptPeds::GivePedScriptedTask(iPedIndex, pCoverTask, SCRIPT_TASK_PUT_PED_DIRECTLY_INTO_COVER, "TASK_PUT_PED_DIRECTLY_INTO_COVER" );
}
}
bool GetAiTarget(CAITarget& target, int iOtherPedIndex, int iTargetVehicleIndex, const scrVector & vscTargetCoords)
{
Vector3 TempVec, CentreVec, VecDiff;
const CPed *pSecondPed;
const CVehicle *pSecondVehicle;
TempVec = Vector3(vscTargetCoords);
const CEntity *pTargetEntity = NULL;
if (iOtherPedIndex != NULL_IN_SCRIPTING_LANGUAGE) // >= 0)
{
if(SCRIPT_VERIFY(iTargetVehicleIndex == NULL_IN_SCRIPTING_LANGUAGE, "TASK_PUT_PED_DIRECTLY_INTO_COVER_FROM_TARGET - Can't have a target ped and a target car"))
{
pSecondPed = CTheScripts::GetEntityToQueryFromGUID<CPed>(iOtherPedIndex);
if(!pSecondPed)
return false;
pTargetEntity = pSecondPed;
}
else
{
return false;
}
}
else
{
pSecondPed = NULL;
}
if (iTargetVehicleIndex != NULL_IN_SCRIPTING_LANGUAGE) // >= 0)
{
if(SCRIPT_VERIFY(iOtherPedIndex == NULL_IN_SCRIPTING_LANGUAGE, "TASK_PUT_PED_DIRECTLY_INTO_COVER_FROM_TARGET - Can't have a target ped and a target car"))
{
pSecondVehicle = CTheScripts::GetEntityToQueryFromGUID<CVehicle>(iTargetVehicleIndex);
if(!SCRIPT_VERIFY(pSecondVehicle, "TASK_PUT_PED_DIRECTLY_INTO_COVER_FROM_TARGET - Target vehicle doesn't exist"))
return false;
pTargetEntity = pSecondVehicle;
}
else
{
return false;
}
}
else
{
pSecondVehicle = NULL;
}
// Set up the arguments
if (pTargetEntity)
{
target.SetEntityAndOffset(pTargetEntity,TempVec);
}
else
{
target.SetPosition(TempVec);
}
return true;
}
// Seek cover from the given position
void CommandTaskPutPedDirectlyIntoCoverFromTarget( int iPedIndex, int iOtherPedIndex, int iTargetVehicleIndex, const scrVector & vscTargetCoords, const scrVector & vscStart, int iTime, bool bAllowPeekingAndFiring, float fBlendInDuration, bool bForceInitialFacingDirection, bool bForceFaceLeft, int iIdentifier, bool bDoEntry )
{
if (SCRIPT_VERIFY((iTime == -1) || (iTime > 0) ,"TASK_PUT_PED_DIRECTLY_INTO_COVER_FROM_TARGET - Time must be -1 for infinite and > 0" ))
{
CAITarget target;
if (GetAiTarget(target, iOtherPedIndex, iTargetVehicleIndex, vscTargetCoords))
{
CTaskCover* pCoverTask = CreatePutPedDirectlyIntoCoverTask(vscStart, target, iTime, bAllowPeekingAndFiring, fBlendInDuration, bForceInitialFacingDirection, bForceFaceLeft, iIdentifier, bDoEntry);
CScriptPeds::GivePedScriptedTask(iPedIndex, pCoverTask, SCRIPT_TASK_PUT_PED_DIRECTLY_INTO_COVER_FROM_TARGET, "TASK_PUT_PED_DIRECTLY_INTO_COVER" );
}
}
}
void CommandTaskWarpPedDirectlyIntoCover(const int iPedIndex, const int iTime, const bool bAllowPeekingAndFiring, const bool bForceInitialFacingDirection, const bool bForceFaceLeft, const int iIdentifier)
{
if (SCRIPT_VERIFY((iTime == -1) || (iTime > 0), "TASK_WARP_PED_DIRECTLY_INTO_COVER - Time must be -1 for infinite and > 0") &&
SCRIPT_VERIFY(NULL_IN_SCRIPTING_LANGUAGE != iPedIndex, "TASK_WARP_PED_DIRECTLY_INTO_COVER - Can't warp a NULL ped"))
{
if (CPed* pPed = CTheScripts::GetEntityToModifyFromGUID<CPed>(iPedIndex, CTheScripts::GUID_ASSERT_FLAGS_INCLUDE_CLONES))
{
Vector3 vPedPosition = VEC3V_TO_VECTOR3(pPed->GetTransform().GetPosition());
CTaskCover* pCoverTask = CreatePutPedDirectlyIntoCoverTask(vPedPosition, CAITarget(), iTime, bAllowPeekingAndFiring, 0.0f, bForceInitialFacingDirection, bForceFaceLeft, iIdentifier, false);
pCoverTask->SetCoverFlag(CTaskCover::CF_WarpPedToCoverPosition);
CScriptPeds::GivePedScriptedTask(iPedIndex, pCoverTask, SCRIPT_TASK_WARP_PED_DIRECTLY_INTO_COVER, "TASK_WARP_PED_DIRECTLY_INTO_COVER");
}
}
}
void CommandSetCoverTarget(int iPedIndex, int iOtherPedIndex, int iTargetVehicleIndex, const scrVector & vscTargetCoords)
{
if( SCRIPT_VERIFY( NULL_IN_SCRIPTING_LANGUAGE != iPedIndex, "SET_COVER_TARGET - Can't have a NULL ped" ) )
{
CPed* pPed = CTheScripts::GetEntityToModifyFromGUID<CPed>( iPedIndex );
if( pPed && SCRIPT_VERIFY(!pPed->IsNetworkClone(), "SET_COVER_TARGET - Can't call this command on a network clone!"))
{
CAITarget aiTarget;
if (GetAiTarget(aiTarget, iOtherPedIndex, iTargetVehicleIndex, vscTargetCoords))
{
CTaskCover* pCoverTask = static_cast<CTaskCover*>(pPed->GetPedIntelligence()->FindTaskActiveByType(CTaskTypes::TASK_COVER));
if( pCoverTask )
{
CWeaponTarget& weaponTarget = pCoverTask->GetWeaponTarget();
const CEntity* pEntity = aiTarget.GetEntity();
if( pEntity )
{
Vector3 vOffset(Vector3::ZeroType);
if (aiTarget.GetPositionOffset(vOffset))
{
weaponTarget.SetEntityAndOffset(pEntity, vOffset);
}
else
{
weaponTarget.SetEntity(pEntity);
}
}
else
{
Vector3 vPosition(Vector3::ZeroType);
if (aiTarget.GetPosition(vPosition))
{
weaponTarget.SetPosition(vPosition);
}
}
}
}
}
}
}
// Exit cover
void CommandTaskExitCover( int iPedIndex, int iExitType, const scrVector & vscTargetCoords )
{
s32 iFlags = 0;
CPed* pPed = CTheScripts::GetEntityToModifyFromGUID<CPed>( iPedIndex, 0 );
if (pPed)
{
// Early out if called on network clone or ped doesn't have a cover point
if (!SCRIPT_VERIFY(!pPed->IsNetworkClone(), "SCRIPT_TASK_EXIT_COVER - Cannot call on network clone"))
{
return;
}
if (!SCRIPT_VERIFY(pPed->GetCoverPoint(), "SCRIPT_TASK_EXIT_COVER - Called on a ped without a cover point"))
{
return;
}
if (pPed->GetPedResetFlag(CPED_RESET_FLAG_InCoverFacingLeft))
{
iFlags |= CTaskCover::CF_FacingLeft;
}
}
CAITarget target;
if (iExitType == CTaskCover::FE_Aim)
{
target.SetPosition(vscTargetCoords);
}
// Maybe given as part of a sequence, can't detect if ped will be in cover now if this is the case
CScriptPeds::GivePedScriptedTask(iPedIndex, rage_new CTaskCover(target, iFlags, (CTaskCover::eForcedExit) iExitType), SCRIPT_TASK_EXIT_COVER, "SCRIPT_TASK_EXIT_COVER");
}
// Seek cover from the given position
void CommandTaskPutPedDirectlyIntoMelee( int iPedIndex, int iTargetIndex, float fBlendInDuration, float fTimeInMelee, float fStrafePhaseSync, const int iAiCombatFlags )
{
CPed* pPed = CTheScripts::GetEntityToModifyFromGUID<CPed>(iPedIndex);
if( pPed )
{
// Force the default unarmed weapon
CPedWeaponManager* pWeaponManager = pPed->GetWeaponManager();
if( pWeaponManager )
{
const CWeaponInfo* pWeaponInfo = pWeaponManager->GetEquippedWeaponInfo();
if( pWeaponInfo && !pWeaponInfo->GetIsMelee() )
pWeaponManager->EquipWeapon( pPed->GetDefaultUnarmedWeaponHash(), -1, true );
}
CTaskMotionPed* pCurrentMotionTask = static_cast<CTaskMotionPed*>(pPed->GetPedIntelligence()->GetTaskManager()->FindTaskByTypeActive(PED_TASK_TREE_MOTION, CTaskTypes::TASK_MOTION_PED));
if( pCurrentMotionTask )
{
pCurrentMotionTask->SetTaskFlag( CTaskMotionPed::PMF_SkipStrafeIntroAnim );
pCurrentMotionTask->SetInstantStrafePhaseSync( fStrafePhaseSync );
pCurrentMotionTask->SetStrafeDurationOverride( fBlendInDuration );
}
CPed* pTargetPed = CTheScripts::GetEntityToModifyFromGUID<CPed>(iTargetIndex);
aiTask* pCombatTask = NULL;
if( pPed->IsAPlayerPed() )
{
u32 uMeleeFlags = CTaskMelee::MF_ShouldBeInMeleeMode | CTaskMelee::MF_AllowStrafeMode;
// Would the invoker like to keep the player in strafe?
// NOTE: they also need to set CPED_RESET_FLAG_ForcePedToStrafe
if( fTimeInMelee < 0.0f )
uMeleeFlags |= CTaskMelee::MF_ForceStrafe;
pCombatTask = rage_new CTaskMelee( NULL, pTargetPed, uMeleeFlags, CSimpleImpulseTest::ImpulseNone, (s32)( fTimeInMelee * 1000.0f ) );
}
else
{
CTaskThreatResponse* pTask = rage_new CTaskThreatResponse( pTargetPed );
pTask->SetThreatResponseOverride( CTaskThreatResponse::TR_Fight );
pTask->SetConfigFlagsForCombat( CTaskCombat::ComF_DisableAimIntro | CTaskCombat::ComF_MeleeAnimPhaseSync | iAiCombatFlags );
pTask->SetConfigFlags( CTaskThreatResponse::CF_CanFightArmedPedsWhenNotArmed );
pCombatTask = pTask;
}
CScriptPeds::GivePedScriptedTask( iPedIndex, pCombatTask, SCRIPT_TASK_PUT_PED_DIRECTLY_INTO_MELEE, "SCRIPT_TASK_PUT_PED_DIRECTLY_INTO_MELEE" );
}
}
void CommandSetDriveTaskCruiseSpeed(int iPedIndex, float CruiseSpeed )
{
CPed *pPed = CTheScripts::GetEntityToModifyFromGUID<CPed>(iPedIndex, CTheScripts::GUID_ASSERT_FLAGS_NO_DEAD_CHECK & CTheScripts::GUID_ASSERT_FLAGS_INCLUDE_CLONES);
if(pPed)
{
if(SCRIPT_VERIFY(pPed->GetMyVehicle() && pPed->GetPedConfigFlag( CPED_CONFIG_FLAG_InVehicle ), "SET_DRIVE_TASK_CRUISE_SPEED - Ped is not in car"))
{
if(SCRIPT_VERIFY(pPed->GetMyVehicle()->GetDriver() == pPed, "SET_DRIVE_TASK_CRUISE_SPEED - Ped is not driver of car"))
{
if(NetworkUtils::IsNetworkCloneOrMigrating(pPed))
{
CScriptEntityStateChangeEvent::CSettingOfDriveTaskCruiseSpeed parameters(CruiseSpeed);
CScriptEntityStateChangeEvent::Trigger(pPed->GetNetworkObject(), parameters);
}
else
{
CTaskVehicleMissionBase *pCarTask = pPed->GetMyVehicle()->GetIntelligence()->GetActiveTask();
if(pCarTask)
{
pCarTask->SetCruiseSpeed(CruiseSpeed);
}
}
}
}
}
}
void CommandSetDriveTaskMaxCruiseSpeed(int iPedIndex, float MaxCruiseSpeed )
{
CPed *pPed = CTheScripts::GetEntityToModifyFromGUID<CPed>(iPedIndex);
if(pPed)
{
if(SCRIPT_VERIFY(pPed->GetMyVehicle() && pPed->GetPedConfigFlag( CPED_CONFIG_FLAG_InVehicle ), "SET_DRIVE_TASK_MAX_CRUISE_SPEED - Ped is not in car"))
{
if(SCRIPT_VERIFY(pPed->GetMyVehicle()->GetDriver() == pPed, "SET_DRIVE_TASK_MAX_CRUISE_SPEED - Ped is not driver of car"))
{
CTaskVehicleMissionBase *pCarTask = pPed->GetMyVehicle()->GetIntelligence()->GetActiveTask();
if(pCarTask)
pCarTask->SetMaxCruiseSpeed((u8) MaxCruiseSpeed);
}
}
}
}
void CommandSetDriveTaskDrivingStyle(int iPedIndex, int iDrivingFlags)
{
CPed *pPed = CTheScripts::GetEntityToModifyFromGUID<CPed>(iPedIndex);
if(pPed)
{
if(SCRIPT_VERIFY(pPed->GetMyVehicle() && pPed->GetPedConfigFlag( CPED_CONFIG_FLAG_InVehicle ), "SET_DRIVE_TASK_DRIVING_STYLE - Ped is not in car"))
{
if(SCRIPT_VERIFY(pPed->GetMyVehicle()->GetDriver() == pPed, "SET_DRIVE_TASK_DRIVING_STYLE - Ped is not driver of car"))
{
CTaskVehicleMissionBase *pCarTask = pPed->GetMyVehicle()->GetIntelligence()->GetActiveTask();
if(pCarTask)
pCarTask->SetDrivingFlags(iDrivingFlags);
}
}
}
}
void CommandSetPursueTaskIdealDistance(int iPedIndex, float fIdealDistance)
{
CPed *pPed = CTheScripts::GetEntityToModifyFromGUID<CPed>(iPedIndex);
if(pPed)
{
if(SCRIPT_VERIFY(pPed->GetMyVehicle() && pPed->GetPedConfigFlag( CPED_CONFIG_FLAG_InVehicle ), "SET_PURSUE_TASK_IDEAL_DISTANCE - Ped is not in car"))
{
if(SCRIPT_VERIFY(pPed->GetMyVehicle()->GetDriver() == pPed, "SET_PURSUE_TASK_IDEAL_DISTANCE - Ped is not driver of car"))
{
CTaskVehiclePursue* pPursueTask = static_cast<CTaskVehiclePursue*>(pPed->GetMyVehicle()->GetIntelligence()->GetTaskManager()->FindTaskByTypeActive(VEHICLE_TASK_TREE_PRIMARY, CTaskTypes::TASK_VEHICLE_PURSUE));
if(SCRIPT_VERIFY(pPursueTask, "SET_PURSUE_TASK_IDEAL_DISTANCE - Vehicle is not running TASK_VEHICLE_PURSUE"))
{
pPursueTask->SetIdealDistance(fIdealDistance);
}
}
}
}
}
// Add a cover blocking area
void CommandAddCoverBlockingArea( const scrVector & vStart, const scrVector & vEnd, bool bBlockObjects, bool bBlockVehicles, bool bBlockMap, bool bBlockPlayer )
{
Vector3 vStartV3 = vStart;
Vector3 vEndV3 = vEnd;
CCover::AddCoverBlockingArea( vStartV3, vEndV3, bBlockObjects, bBlockVehicles, bBlockMap, bBlockPlayer );
}
// Add a scripted cover point
void CommandFlushCoverBlockingAreas()
{
CCover::FlushCoverBlockingAreas();
}
// Remove any scripted cover points that contain the specified position.
void CommandRemoveCoverBlockingAreasAtPosition(const scrVector &vPosition)
{
Vector3 vPositionV3 = vPosition;
CCover::RemoveCoverBlockingAreasAtPosition(vPositionV3);
}
// Remove any scripter cover points that have the specified params.
void CommandRemoveSpecificCoverBlockingAreas(const scrVector & vStart, const scrVector & vEnd, bool bBlockObjects, bool bBlockVehicles, bool bBlockMap, bool bBlockPlayer)
{
Vector3 vStartV3 = vStart;
Vector3 vEndV3 = vEnd;
CCover::RemoveSpecificCoverBlockingArea( vStartV3, vEndV3, bBlockObjects, bBlockVehicles, bBlockMap, bBlockPlayer );
}
void CommandTaskStartScenarioInPlace( int PedIndex, const char* szScenario, int iTimeToLeave, bool playIntro)
{
s32 type = CScenarioManager::GetScenarioTypeFromName(szScenario);
if (scriptVerifyf(type!=Scenario_Invalid, "TASK_START_SCENARIO_IN_PLACE: Unknown scenario type (%s)", szScenario ))
{
int flags = CTaskUseScenario::SF_StartInCurrentPosition;
if (!playIntro)
{
flags |= CTaskUseScenario::SF_SkipEnterClip;
}
if (iTimeToLeave < 0)
{
flags |= CTaskUseScenario::SF_IdleForever;
}
CTaskUseScenario* pTask = rage_new CTaskUseScenario(type, flags );
#if __ASSERT //If assigning a task with a prop, make sure the ped has an inventory if (PedIndex != NULL_IN_SCRIPTING_LANGUAGE) { CPed* pPed = CTheScripts::GetEntityToModifyFromGUID(PedIndex, CTheScripts::GUID_ASSERT_FLAGS_INCLUDE_CLONES); scriptAssertf(!pTask->GetScenarioInfo().HasProp() || pPed->GetInventory(), "%s: Attempting to assign a ped a scenario (%s) that has a prop, but the ped(%s) has no inventory", CTheScripts::GetCurrentScriptNameAndProgramCounter(), pTask->GetScenarioInfo().GetName(), pPed->GetModelName()); } #endif
if( iTimeToLeave > 0 )
{
float fTimeToLeave = (float) iTimeToLeave;
pTask->SetTimeToLeave(fTimeToLeave/1000.0f);
}
pTask->CreateProp();
CScriptPeds::GivePedScriptedTask(PedIndex, pTask, SCRIPT_TASK_START_SCENARIO_IN_PLACE, "TASK_START_SCENARIO_IN_PLACE");
}
}
void CommandTaskStartScenarioAtPosition( int iPedIndex, const char* szScenario, const scrVector & svScenarioPlace, float fHeading, int iTimeToLeave, bool playIntro, bool bWarp)
{
Vector3 vScenarioPoint = svScenarioPlace;
s32 type = CScenarioManager::GetScenarioTypeFromName(szScenario);
if (scriptVerifyf(type!=Scenario_Invalid, "TASK_START_SCENARIO_AT_POSITION: Unknown scenario type (%s)", szScenario ))
{
int flags = 0;
if (bWarp)
{
flags |= CTaskUseScenario::SF_Warp;
}
if (!playIntro)
{
flags |= CTaskUseScenario::SF_SkipEnterClip;
}
if (iTimeToLeave < 0)
{
flags |= CTaskUseScenario::SF_IdleForever;
}
CTaskUseScenario* pTask = rage_new CTaskUseScenario(type, vScenarioPoint, fwAngle::LimitRadianAngle( (DtoR * fHeading) ), flags );
if( iTimeToLeave > 0 )
{
float fTimeToLeave = (float) iTimeToLeave;
pTask->SetTimeToLeave(fTimeToLeave/1000.0f);
}
pTask->CreateProp();
CScriptPeds::GivePedScriptedTask(iPedIndex, pTask, SCRIPT_TASK_START_SCENARIO_AT_POSITION, "TASK_START_SCENARIO_AT_POSITION");
}
}
void CommandTaskStartVehicleScenario( int iPedIndex, int iVehicleIndex, const char* szScenario, bool bWarp )
{
if( iPedIndex != NULL_IN_SCRIPTING_LANGUAGE && iVehicleIndex != NULL_IN_SCRIPTING_LANGUAGE)
{
CVehicle* pVehicle = CTheScripts::GetEntityToModifyFromGUID<CVehicle>(iVehicleIndex);
if(!pVehicle)
return;
s32 type = CScenarioManager::GetScenarioTypeFromName(szScenario);
if (scriptVerifyf(type!=Scenario_Invalid, "TASK_START_VEHICLE_SCENARIO: Unknown scenario type (%s)", szScenario ))
{
scriptAssertf(SCENARIOINFOMGR.GetScenarioInfoByIndex(type) && SCENARIOINFOMGR.GetScenarioInfoByIndex(type)->GetIsClass<CScenarioParkedVehicleInfo>(), "Invalid Vehicle Scenario");
CTaskParkedVehicleScenario* pTask = rage_new CTaskParkedVehicleScenario(type, pVehicle, bWarp);
CScriptPeds::GivePedScriptedTask(iPedIndex, pTask, SCRIPT_TASK_START_VEHICLE_SCENARIO, "TASK_START_VEHICLE_SCENARIO");
}
}
}
bool CommandDoesScenarioExistInArea( const scrVector & svScenarioPlace, float fMaxRange, bool bMustBeFree )
{
Vector3 vScenarioPoint = svScenarioPlace;
CPedPopulation::GetScenarioPointInAreaArgs args(RCC_VEC3V(vScenarioPoint), fMaxRange);
args.m_MustBeFree = bMustBeFree;
args.m_CheckPopulation = bMustBeFree;
CScenarioPoint* pScenarioPoint = NULL;
if(!CPedPopulation::GetScenarioPointInArea(args, &pScenarioPoint))
{
return false;
}
return true;
}
bool CommandDoesScenarioOfTypeExistInArea ( const scrVector & svScenarioPlace, const char* szScenario, float fMaxRange, bool bMustBeFree )
{
Vector3 vScenarioPoint = svScenarioPlace;
CPedPopulation::GetScenarioPointInAreaArgs args(RCC_VEC3V(vScenarioPoint), fMaxRange);
args.m_MustBeFree = bMustBeFree;
args.m_CheckPopulation = bMustBeFree;
args.m_NumTypes = 1;
s32 type = CScenarioManager::GetScenarioTypeFromName(szScenario);
args.m_Types = &type;
scriptAssertf(type!=Scenario_Invalid, "DOES_SCENARIO_OF_TYPE_EXIST_IN_AREA: Unknown scenario type (%s)", szScenario );
CScenarioPoint* pScenarioPoint = NULL;
if(!CPedPopulation::GetScenarioPointInArea(args, &pScenarioPoint))
{
return false;
}
return true;
}
bool CommandIsScenarioOccupied(const scrVector & svScenarioPlace, float fMaxRange, bool onlyUsersActuallyAtScenario)
{
Vector3 vScenarioPoint = svScenarioPlace;
CScenarioPoint* pScenarioPoint = NULL;
CPedPopulation::GetScenarioPointInAreaArgs args(RCC_VEC3V(vScenarioPoint), fMaxRange);
args.m_MustBeFree = false;
args.m_CheckPopulation = false;
if(!CPedPopulation::GetScenarioPointInArea(args, &pScenarioPoint))
{
return false;
}
// If onlyUsersActuallyAtScenario is set, we need to loop over the peds later.
bool needToCheckPeds = onlyUsersActuallyAtScenario;
// Note: CPedPopulation::IsEffectInUse() is a bit unfortunate in how it always
// returns true if the scenario is attached to anything but a CObject. This is
// different than how the check is done in GetScenarioPointInArea()
// and GeneratePedsFromScenarioPointList(), where a scenario attached to something
// else is considered not in use. Thus, we check the type here.
if(!pScenarioPoint->GetEntity() || pScenarioPoint->GetEntity()->GetIsTypeObject())
{
if(!CPedPopulation::IsEffectInUse(*pScenarioPoint))
{
return false;
}
}
else if(pScenarioPoint->GetEntity() && !pScenarioPoint->GetEntity()->GetIsTypeObject())
{
// Since we don't keep track of use for non-CObject entities,
// we need to check the ped tasks.
needToCheckPeds = true;
}
if(needToCheckPeds)
{
int scenarioTypeFoundInLocation = pScenarioPoint->GetScenarioTypeVirtualOrReal();
bool isVirtual = SCENARIOINFOMGR.IsVirtualIndex(scenarioTypeFoundInLocation);
bool foundNearby = false;
CPed::Pool* pool = CPed::GetPool();
const int maxPeds = pool->GetSize();
for(int i = 0; i < maxPeds; i++)
{
CPed* pPed = pool->GetSlot(i);
if(!pPed)
{
continue;
}
// Note: for virtual scenario types, we won't ever match GetScenarioType(). We could loop over
// all the real types, but the code below looks like it may work well enough without that.
if(!isVirtual && scenarioTypeFoundInLocation != CPed::GetScenarioType(*pPed))
{
continue;
}
const CTaskUseScenario* pTaskUseScenario = static_cast<const CTaskUseScenario*>(pPed->GetPedIntelligence()->FindTaskActiveByType(CTaskTypes::TASK_USE_SCENARIO));
if(pTaskUseScenario)
{
if (pTaskUseScenario->GetScenarioPoint() != pScenarioPoint)
{
continue;
}
const int taskState = pTaskUseScenario->GetState();
if(onlyUsersActuallyAtScenario && (taskState == CTaskUseScenario::State_Start || taskState == CTaskUseScenario::State_GoToStartPosition))
{
// In this case, we certainly appear to have found the ped that's considered the user
// of the scenario point, but it hasn't actually arrived yet. In that case, we don't consider
// the scenario occupied, so we return false.
return false;
}
else
{
// Found the true user of this scenario.
return true;
}
}
else if(!foundNearby && !isVirtual)
{
// Somehow, according to CPed::GetScenarioType(), we are using a scenario of the type we are looking for,
// but we can't find the CTaskUseScenario. It might be possible for this to happen for some scenario that's
// using a different task, or perhaps in some networking situation, so we try to fall back on a distance
// check.
static float s_DistThresholdSq = square(1.0f); // MAGIC!
const Vec3V scenarioWorldPosV = pScenarioPoint->GetPosition();
const Vec3V pedPosV = pPed->GetTransform().GetPosition();
const ScalarV distThresholdSqV = LoadScalar32IntoScalarV(s_DistThresholdSq);
const ScalarV distSqV = DistSquared(scenarioWorldPosV, pedPosV);
if(IsLessThanAll(distSqV, distThresholdSqV))
{
// This ped is close, set this variable. Note that we don't return true right away here,
// because we might still find a ped that's actually using this scenario through a CTaskUseScenario,
// in which case returning false is still an option.
foundNearby = true;
}
}
}
if(foundNearby)
{
// We didn't find anybody running a CTaskUseScenario on this scenario, but we found
// somebody using a scenario of the right type, close enough to the point.
return true;
}
else
{
// Nobody nearby is using a scenario of this type.
return false;
}
}
else
{
return true;
}
}
bool CommandPedHasUseScenarioTask(int iPedIndex)
{
const CPed* pPed = CTheScripts::GetEntityToQueryFromGUID<CPed>(iPedIndex);
if (SCRIPT_VERIFY(pPed, "PedIndex was invalid for PED_HAS_USE_SCENARIO_TASK!"))
{
CTaskUseScenario* pTaskScenario = static_cast<CTaskUseScenario*>(pPed->GetPedIntelligence()->FindTaskActiveByType(CTaskTypes::TASK_USE_SCENARIO));
if (pTaskScenario)
{
return true;
}
}
return false;
}
void CommandOverrideTaskedScenarioBaseAnim(int iPedIndex, const char* clipSet, const char* clip)
{
const CPed* pPed = CTheScripts::GetEntityToQueryFromGUID<CPed>(iPedIndex);
if (SCRIPT_VERIFY(pPed, "PedIndex was invalid for OVERRIDE_TASKED_SCENARIO_BASE_ANIM!"))
{
CTaskUseScenario* pTaskScenario = static_cast<CTaskUseScenario*>(pPed->GetPedIntelligence()->FindTaskActiveByType(CTaskTypes::TASK_USE_SCENARIO));
if (pTaskScenario)
{
fwMvClipSetId setId(clipSet);
fwMvClipId clipId(clip);
pTaskScenario->OverrideBaseClip(setId, clipId);
}
// if we are already running the ambient clips task then we should set the override on there as well.
CTaskAmbientClips* pTaskAmbientClips = static_cast<CTaskAmbientClips*>(pPed->GetPedIntelligence()->FindTaskActiveByType(CTaskTypes::TASK_AMBIENT_CLIPS));
if (pTaskAmbientClips)
{
fwMvClipSetId setId(clipSet);
fwMvClipId clipId(clip);
pTaskAmbientClips->OverrideBaseClip(setId, clipId);
}
}
}
void CommandPlayAnimOnRunnningScenario(int iPedIndex, const char* clipSet, const char* clip)
{
const CPed* pPed = CTheScripts::GetEntityToQueryFromGUID<CPed>(iPedIndex);
if (SCRIPT_VERIFY(pPed, "PedIndex was invalid for TASK_SCENARIO_PLAY_AS_IDLE!"))
{
CTaskAmbientClips* pTaskAmbientClips = static_cast<CTaskAmbientClips*>(pPed->GetPedIntelligence()->FindTaskActiveByType(CTaskTypes::TASK_AMBIENT_CLIPS));
if (SCRIPT_VERIFY(pTaskAmbientClips, "Ped is currently not running the right task to run TASK_SCENARIO_PLAY_AS_IDLE"))
{
fwMvClipSetId setId(clipSet);
fwMvClipId clipId(clip);
if (SCRIPT_VERIFYF(fwClipSetManager::GetClipSet(setId) != NULL, "ClipSet %s did not exist. Are you sure it is in clip_sets.xml?", clipSet))
{
pTaskAmbientClips->PlayAnimAsIdle(setId, clipId);
}
}
}
}
int GetScenarioGroupHelper(const char* groupName, const char* ASSERT_ONLY(cmdName), bool ASSERT_ONLY(mayNotExist))
{
int groupId = CScenarioPointManager::kNoGroup;
if(groupName && groupName[0])
{
groupId = SCENARIOPOINTMGR.FindGroupByNameHash(atHashString(groupName), true);
}
scriptAssertf(groupId != CScenarioPointManager::kNoGroup || mayNotExist, "%s used with group name %s, which doesn't exist.", cmdName, groupName ? groupName : "<NULL>");
return groupId;
}
bool CommandDoesScenarioGroupExist(const char* groupName)
{
return GetScenarioGroupHelper(groupName, "DOES_SCENARIO_GROUP_EXIST", true) != CScenarioPointManager::kNoGroup;
}
bool CommandIsScenarioGroupEnabled(const char* groupName)
{
int groupId = GetScenarioGroupHelper(groupName, "IS_SCENARIO_GROUP_ENABLED", false);
if(groupId != CScenarioPointManager::kNoGroup)
{
const int groupIndex = groupId - 1;
return SCENARIOPOINTMGR.IsGroupEnabled(groupIndex);
}
return false;
}
void CommandSetScenarioGroupEnabled(const char* groupName, bool enabled)
{
int groupId = GetScenarioGroupHelper(groupName, "IS_SCENARIO_GROUP_ENABLED", false);
if(groupId != CScenarioPointManager::kNoGroup)
{
const int groupIndex = groupId - 1;
SCENARIOPOINTMGR.SetGroupEnabled(groupIndex, enabled);
}
}
void CommandResetScenarioGroupsEnabled()
{
SCENARIOPOINTMGR.ResetGroupsEnabledToDefaults();
}
void CommandSetExclusiveScenarioGroup(const char* groupName)
{
int groupId = GetScenarioGroupHelper(groupName, "SET_EXCLUSIVE_SCENARIO_GROUP", false);
if(groupId != CScenarioPointManager::kNoGroup)
{
const int groupIndex = groupId - 1;
SCENARIOPOINTMGR.SetExclusivelyEnabledScenarioGroupIndex(groupIndex);
}
}
void CommandResetExclusiveScenarioGroup()
{
SCENARIOPOINTMGR.SetExclusivelyEnabledScenarioGroupIndex(-1);
}
int GetScenarioTypeHelper(const char* typeName, const char* ASSERT_ONLY(cmdName))
{
int ret = -1;
if(typeName && typeName[0])
{
const u32 hash = atStringHash(typeName);
// Note: this is currently an O(n) operation.
ret = SCENARIOINFOMGR.GetScenarioIndex(hash, false);
}
scriptAssertf(ret >= 0, "%s used with type name %s, which doesn't exist.", cmdName, typeName ? typeName : "<NULL>");
return ret;
}
void CommandForceScenarioGroupPriority(const char* groupName, bool bIsHighPriority)
{
int groupId = GetScenarioGroupHelper(groupName, "FORCE_SCENARIO_GROUP_PRIORITY", true);
if(groupId != CScenarioPointManager::kNoGroup)
{
CScenarioPointPriorityManager::GetInstance().ForceScenarioPointGroupPriority((u8)groupId, bIsHighPriority);
}
}
void CommandResetScenarioGroupsPriority()
{
CScenarioPointPriorityManager::GetInstance().RestoreGroupsToOriginalPriorities();
}
bool CommandIsScenarioTypeEnabled(const char* typeName)
{
int typeIndex = GetScenarioTypeHelper(typeName, "IS_SCENARIO_TYPE_ENABLED");
if(typeIndex >= 0)
{
return SCENARIOINFOMGR.IsScenarioTypeEnabled(typeIndex);
}
return true;
}
void CommandSetScenarioTypeEnabled(const char* typeName, bool enabled)
{
int typeIndex = GetScenarioTypeHelper(typeName, "SET_SCENARIO_TYPE_ENABLED");
if(typeIndex >= 0)
{
SCENARIOINFOMGR.SetScenarioTypeEnabled(typeIndex, enabled);
}
}
void CommandResetScenarioTypesEnabled()
{
SCENARIOINFOMGR.ResetScenarioTypesEnabledToDefaults();
}
void CommandSuppressNormalScenarioExitsNextFrame()
{
CScenarioManager::SetScenarioExitsSuppressed(true);
}
void CommandSuppressScenarioAttractionNextFrame()
{
CScenarioManager::SetScenarioAttractionSuppressed(true);
}
void CommandSuppressBreakoutScenarioExitsNextFrame()
{
CScenarioManager::SetScenarioBreakoutExitsSuppressed(true);
}
CTask* CommonUseNearestScenarioToPos( CPed* pPed, const scrVector & svScenarioPlace, float fMaxRange, bool bWarp, bool ASSERT_ONLY(bCalledFromTask), int iTimeToLeave, bool bMustBeTrainScenario )
{
Vector3 vScenarioPoint = svScenarioPlace;
CScenarioPoint* pScenarioPoint = NULL;
CPedPopulation::GetScenarioPointInAreaArgs args(RCC_VEC3V(vScenarioPoint), fMaxRange);
args.m_MustBeFree = true;
args.m_PedOrDummyToUsePoint = pPed;
args.m_Random = false;
args.m_MustBeAttachedToTrain = bMustBeTrainScenario;
bool bCheckPeds = false;
if( !CPedPopulation::GetScenarioPointInArea( args, &pScenarioPoint ) )
{
// do it again and process it further...the actual use count on the scenario point isn't
// always what we want if they are going to the point on a long chain and the player is much closer
args.m_MustBeFree = false;
args.m_CheckPopulation = false;
if( !CPedPopulation::GetScenarioPointInArea( args, &pScenarioPoint ) )
{
#if __ASSERT if( !bCalledFromTask ) scriptAssertf(0, "%s:TASK_USE_NEAREST_SCENARIO_TO_POS(_WARP) - No scenario found within range", CTheScripts::GetCurrentScriptNameAndProgramCounter()); #endif // __ASSERT return NULL; } else { bCheckPeds = true; } }
if(bCheckPeds)
{
// Really check if the ped is actually using the scenario...
// The CScenarioPoint.m_iUses won't get reset until the cleanup function is called in CTaskUseScenario
// Other states here may be valid for us to start the scenario
CPed::Pool* pool = CPed::GetPool();
const int maxPeds = pool->GetSize();
for(int i = 0; i < maxPeds; i++)
{
CPed* pCurPed = pool->GetSlot(i);
if(!pCurPed || pCurPed == args.m_PedOrDummyToUsePoint || pCurPed->PopTypeIsMission())
{
continue;
}
CTaskUseScenario* pTaskUseScenario = static_cast<CTaskUseScenario*>(pCurPed->GetPedIntelligence()->FindTaskActiveByType(CTaskTypes::TASK_USE_SCENARIO));
if(pTaskUseScenario)
{
if (pTaskUseScenario->GetScenarioPoint() != pScenarioPoint)
{
continue;
}
const int taskState = pTaskUseScenario->GetState();
if(taskState != CTaskUseScenario::State_Start && taskState != CTaskUseScenario::State_GoToStartPosition)
{
#if __ASSERT if( !bCalledFromTask ) scriptAssertf(0, "%s:TASK_USE_NEAREST_SCENARIO_TO_POS(_WARP) - No scenario found within range -- Scenario State For Another Ped Is Actively Using The Scenario", CTheScripts::GetCurrentScriptNameAndProgramCounter()); #endif // __ASSERT return NULL; } else if (pCurPed->PopTypeIsRandom()) { // Scripted peds take priority over ambient/scenario peds // This will prevent undesirable conflicts at atms, vending machines, etc pTaskUseScenario->MakeAbortable(aiTask::ABORT_PRIORITY_URGENT, NULL); } } } }
s32 scenarioType = CScenarioManager::ChooseRealScenario(pScenarioPoint->GetScenarioTypeVirtualOrReal(), pPed);
bool bStartInCurrentPos = !bWarp;
float fHeading = 0.0f;
Vector3 vPedPos;
CTask* pScenarioTask = CScenarioManager::SetupScenarioAndTask(scenarioType, vPedPos, fHeading, *pScenarioPoint, 0, bStartInCurrentPos);
#if AI_DEBUG_OUTPUT_ENABLED CNetObjGame* pNetObjPed = (NetworkInterface::IsGameInProgress() && pPed) ? pPed->GetNetworkObject() : NULL; CAILogManager::GetLog().Log("CommonUseNearestScenarioToPos: [0x%p][%s], (%.2f,%.2f,%.2f), Range (%.2f), Warp (%d), ScenarioType %d, ScenarioPoint 0x%p (%.2f,%.2f,%.2f)\r\n", pPed, pNetObjPed ? pNetObjPed->GetLogName() : "unknown", svScenarioPlace.x, svScenarioPlace.y, svScenarioPlace.z, fMaxRange, bWarp, scenarioType, pScenarioPoint, pScenarioPoint->GetWorldPosition().GetXf(), pScenarioPoint->GetWorldPosition().GetYf(), pScenarioPoint->GetWorldPosition().GetZf()); #endif
if(pScenarioTask)
{
if (pScenarioTask->GetTaskType() == CTaskTypes::TASK_USE_SCENARIO)
{
if (iTimeToLeave < 0)
{
((CTaskUseScenario*)pScenarioTask)->SetDontLeaveEver();
}
if( iTimeToLeave > 0)
{
float fTimeToLeave = (float) iTimeToLeave;
((CTaskUseScenario*)pScenarioTask)->SetTimeToLeave(fTimeToLeave/1000.0f);
}
}
// This is probably not strictly necessary, as CTaskUseScenario should warp us into
// place anyway. But, may still be safest, in case the script gets the position of the ped
// before the task has run, or if we're using a ragdoll.
if(bWarp && pPed)
{
// If we are using ragdoll, the calls to SetPosition() and other functions wouldn't work
// well. FlushImmediately() should take care of this by ending tasks and doing other things
// to restore the ped to a normal state. See B* 333114: "Ignorable Assert - Error: false:
// CPed::UpdatePhysicsFromEntity called while ragdoll active - fired after starting private dance".
// Note: we could potentially do this in the non-ragdoll case too, but to start out with, that
// seemed a bit risky.
if(pPed->GetUsingRagdoll())
{
pPed->GetPedIntelligence()->FlushImmediately(true);
}
pPed->SetPosition(vPedPos);
pPed->SetHeading(fHeading);
pPed->SetDesiredHeading(fHeading);
}
}
else
{
#if __ASSERT if( !bCalledFromTask ) scriptAssertf(0, "%s:TASK_USE_NEAREST_SCENARIO_TO_POS(_WARP) - scenario type found of invalid type", CTheScripts::GetCurrentScriptNameAndProgramCounter()); #endif // __ASSERT }
// We could probably do this if we wanted to wrap the scenario task in a CTaskUnalerted. The main
// reason for that would probably be if we needed to support chaining when done using the current scenario.
// aiTask* pControlTask = CScenarioManager::SetupScenarioControlTask(*pScenarioInfo, pScenarioTask, *pPropScenarioPoint);
return pScenarioTask;
}
CTask* CommonUseNearestScenarioChainToPos(CPed* pPed, const scrVector & svScenarioPlace, float fMaxRange, bool bWarp, bool bCalledFromTask, int iTimeToLeave )
{
CTask* pControlTask = NULL;
if (SCRIPT_VERIFY(pPed, "Invalid ped in CommonUseNearestScenarioChainToPos!"))
{
// Construct CTaskUseScenario for the nearest scenario point.
CTask* pScenarioTask = CommonUseNearestScenarioToPos(pPed, svScenarioPlace, fMaxRange, bWarp, bCalledFromTask, iTimeToLeave);
if (SCRIPT_VERIFY(pScenarioTask, "Invalid scenario task!"))
{
CScenarioPoint* pScenarioPoint = pScenarioTask->GetScenarioPoint();
if (SCRIPT_VERIFY(pScenarioPoint, "Generated scenario task did not have a valid scenario point!"))
{
s32 iScenarioType = CScenarioManager::ChooseRealScenario(pScenarioPoint->GetScenarioTypeVirtualOrReal(), pPed);
const CScenarioInfo* pScenarioInfo = CScenarioManager::GetScenarioInfo(iScenarioType);
if (SCRIPT_VERIFY(pScenarioInfo, "Invalid scenario info for type!"))
{
// Wrap the scenario point task in CTaskUnalerted so the ped can follow the chain.
pControlTask = CScenarioManager::SetupScenarioControlTask(*pPed, *pScenarioInfo, pScenarioTask, pScenarioPoint, iScenarioType);
}
}
}
}
return pControlTask;
}
void CommandTaskUseNearestScenarioToPos( int iPedIndex, const scrVector & svScenarioPlace, float fMaxRange, int iTimeToLeave )
{
// NULL peds are valid since this task can run in a sequence
CPed *pPed = NULL;
if(iPedIndex != NULL_IN_SCRIPTING_LANGUAGE)
{
pPed = CTheScripts::GetEntityToModifyFromGUID<CPed>(iPedIndex, CTheScripts::GUID_ASSERT_FLAGS_INCLUDE_CLONES);
}
CTask* pTask = CommonUseNearestScenarioToPos(pPed, svScenarioPlace, fMaxRange, false, false, iTimeToLeave);
if( pTask )
CScriptPeds::GivePedScriptedTask(iPedIndex, pTask, SCRIPT_TASK_USE_NEAREST_SCENARIO_TO_POS, "TASK_USE_NEAREST_SCENARIO_TO_COORD");
}
void CommandTaskUseNearestScenarioToPosWarp( int iPedIndex, const scrVector & svScenarioPlace, float fMaxRange, int iTimeToLeave )
{
// NULL peds are valid since this task can run in a sequence
CPed *pPed = NULL;
if(iPedIndex != NULL_IN_SCRIPTING_LANGUAGE)
{
pPed = CTheScripts::GetEntityToModifyFromGUID<CPed>(iPedIndex, CTheScripts::GUID_ASSERT_FLAGS_INCLUDE_CLONES);
}
CTask* pTask = CommonUseNearestScenarioToPos(pPed, svScenarioPlace, fMaxRange, true, false, iTimeToLeave);
if( pTask )
CScriptPeds::GivePedScriptedTask(iPedIndex, pTask, SCRIPT_TASK_USE_NEAREST_SCENARIO_TO_POS, "TASK_USE_NEAREST_SCENARIO_TO_COORD_WARP");
}
void CommandTaskUseNearestTrainScenarioToPosWarp( int iPedIndex, const scrVector & svScenarioPlace, float fMaxRange )
{
// NULL peds are valid since this task can run in a sequence
CPed *pPed = NULL;
if(iPedIndex != NULL_IN_SCRIPTING_LANGUAGE)
{
pPed = CTheScripts::GetEntityToModifyFromGUID<CPed>(iPedIndex, CTheScripts::GUID_ASSERT_FLAGS_INCLUDE_CLONES);
}
CTask* pUseScenarioTask = CommonUseNearestScenarioToPos(pPed, svScenarioPlace, fMaxRange, true, false, 0, true);
CTaskRideTrain* pTaskRideTrain = NULL;
if (pUseScenarioTask)
{
const CScenarioPoint* pScenarioPoint = pUseScenarioTask->GetScenarioPoint();
if (pScenarioPoint)
{
//Check if the scenario is on a train.
CEntity* pEntity = pScenarioPoint->GetEntity();
if(pEntity && pEntity->GetIsTypeVehicle())
{
CVehicle* pVehicle = static_cast<CVehicle *>(pEntity);
if(pVehicle->InheritsFromTrain())
{
//Grab the train.
CTrain* pTrain = static_cast<CTrain *>(pVehicle);
//Ride the train with the scenario point.
pTaskRideTrain = rage_new CTaskRideTrain(pTrain, pUseScenarioTask);
}
}
}
}
if (pTaskRideTrain)
{
CScriptPeds::GivePedScriptedTask(iPedIndex, pTaskRideTrain, SCRIPT_TASK_USE_NEAREST_TRAIN_SCENARIO_TO_POS, "TASK_USE_NEAREST_TRAIN_SCENARIO_TO_COORD_WARP");
}
}
void CommandTaskUseNearestScenarioChainToPos( int iPedIndex, const scrVector & svScenarioInPlace, float fMaxRange, int iTimeToLeave )
{
if(SCRIPT_VERIFY(iPedIndex != NULL_IN_SCRIPTING_LANGUAGE, "Ped index was NULL!"))
{
// Find the ped.
CPed* pPed = CTheScripts::GetEntityToModifyFromGUID<CPed>(iPedIndex, CTheScripts::GUID_ASSERT_FLAGS_INCLUDE_CLONES);
if (pPed)
{
CTask* pTask = CommonUseNearestScenarioChainToPos(pPed, svScenarioInPlace, fMaxRange, false, false, iTimeToLeave);
if(pTask)
{
// Give the ped the scenario following task.
CScriptPeds::GivePedScriptedTask(iPedIndex, pTask, SCRIPT_TASK_USE_NEAREST_SCENARIO_CHAIN_TO_POS, "TASK_USE_NEAREST_SCENARIO_CHAIN_TO_COORD");
}
}
}
}
void CommandTaskUseNearestScenarioChainToPosWarp( int iPedIndex, const scrVector & svScenarioPlace, float fMaxRange, int iTimeToLeave )
{
if(SCRIPT_VERIFY(iPedIndex != NULL_IN_SCRIPTING_LANGUAGE, "Ped index was NULL!"))
{
// Find the ped.
CPed* pPed = CTheScripts::GetEntityToModifyFromGUID<CPed>(iPedIndex, CTheScripts::GUID_ASSERT_FLAGS_INCLUDE_CLONES);
if (pPed)
{
CTask* pTask = CommonUseNearestScenarioChainToPos(pPed, svScenarioPlace, fMaxRange, true, false, iTimeToLeave);
if(pTask)
{
// Give the ped the scenario following task.
CScriptPeds::GivePedScriptedTask(iPedIndex, pTask, SCRIPT_TASK_USE_NEAREST_SCENARIO_CHAIN_TO_POS, "TASK_USE_NEAREST_SCENARIO_CHAIN_TO_COORD_WARP");
}
}
}
}
bool CommandIsPedActiveInScenario(int iPedIndex)
{
const CPed* pPed = CTheScripts::GetEntityToQueryFromGUID<CPed>(iPedIndex);
if (SCRIPT_VERIFY(pPed, "PedIndex was invalid for IS_PED_ACTIVE_IN_SCENARIO or IS_PED_PLAYING_BASE_CLIP_IN_SCENARIO!"))
{
CTaskUseScenario* pTaskScenario = static_cast<CTaskUseScenario*>(pPed->GetPedIntelligence()->FindTaskActiveByType(CTaskTypes::TASK_USE_SCENARIO));
if (pTaskScenario)
{
// The ped is really only "in" the scenario when they are playing the ambient animations associated with it.
return pTaskScenario->GetState() == CTaskUseScenario::State_PlayAmbients;
}
}
return false;
}
bool CommandIsPedPlayingBaseClipInScenario(int iPedIndex)
{
if (CommandIsPedActiveInScenario(iPedIndex))
{
const CPed* pPed = CTheScripts::GetEntityToQueryFromGUID<CPed>(iPedIndex);
if (pPed)
{
CTaskAmbientClips* pTaskAmbientClips = static_cast<CTaskAmbientClips*>(pPed->GetPedIntelligence()->FindTaskActiveByType(CTaskTypes::TASK_AMBIENT_CLIPS));
if (pTaskAmbientClips)
{
return pTaskAmbientClips->IsBaseClipFullyBlended();
}
}
}
return false;
}
void CommandSetCanPlayAmbientIdles(int PedIndex, bool bBlockIdleClips, bool bRemoveIdleClipIfPlaying)
{
CPed* pPed = CTheScripts::GetEntityToModifyFromGUID<CPed>(PedIndex);
if (pPed)
{
CTaskAmbientClips* pTaskAmbientClips = static_cast<CTaskAmbientClips*>(pPed->GetPedIntelligence()->FindTaskActiveByType(CTaskTypes::TASK_AMBIENT_CLIPS));
if (pTaskAmbientClips)
{
pTaskAmbientClips->SetBlockAmbientIdles(bBlockIdleClips);
pTaskAmbientClips->SetRemoveAmbientIdles(bRemoveIdleClipIfPlaying);
}
}
}
void CommandTaskSwapWeapon(int PedIndex, bool bDrawWeapon)
{
u32 nFlags = SWAP_HOLSTER;
if(bDrawWeapon)
nFlags |= SWAP_DRAW;
CTask* pTask = rage_new CTaskSwapWeapon(nFlags);
CScriptPeds::GivePedScriptedTask(PedIndex, pTask, SCRIPT_TASK_SWAP_WEAPON, "TASK_SWAP_WEAPON");
}
void CommandTaskReloadWeapon(int PedIndex, bool UNUSED_PARAM(bDrawWeapon))
{
const CPed* pPed = CTheScripts::GetEntityToQueryFromGUID<CPed>(PedIndex);
if( SCRIPT_VERIFY(pPed , "PedIndex was invalid for TASK_RELOAD_WEAPON!") &&
SCRIPT_VERIFY(pPed->GetWeaponManager() , "WeaponManager was invalid for TASK_RELOAD_WEAPON!") &&
SCRIPT_VERIFY(pPed->GetWeaponManager()->GetEquippedWeapon() , "Equipped weapon was invalid for TASK_RELOAD_WEAPON!") )
{
CTaskReloadGun* pTaskToGiveToPed = rage_new CTaskReloadGun(CWeaponController::WCT_Reload);
if (SCRIPT_VERIFY(pTaskToGiveToPed, "TASK_RELOAD_WEAPON - Unable to create reload gun task"))
{
CScriptPeds::GivePedScriptedTask(PedIndex, pTaskToGiveToPed, SCRIPT_TASK_RELOAD_WEAPON, "TASK_RELOAD_WEAPON");
}
}
}
void CommandTaskCombatRoll(int UNUSED_PARAM(PedIndex), s32 UNUSED_PARAM(iDirection))
{
scriptAssertf(0, "TASK_COMBAT_ROLL removed");
}
void CommandTaskSkyDive(int iPedIndex, bool bInstant)
{
fwFlags32 fallFlags = FF_ForceSkyDive;
if(bInstant)
{
fallFlags.SetFlag(FF_InstantBlend);
fallFlags.SetFlag(FF_DisableSkydiveTransition);
}
CTaskComplexControlMovement * pCtrlTask;
pCtrlTask = rage_new CTaskComplexControlMovement( rage_new CTaskMoveInAir(), rage_new CTaskFall(fallFlags), CTaskComplexControlMovement::TerminateOnSubtask );
CScriptPeds::GivePedScriptedTask(iPedIndex, pCtrlTask, SCRIPT_TASK_SKY_DIVE, "TASK_SKY_DIVE");
}
void CommandTaskParachute(int iPedID, bool UNUSED_PARAM(bGiveParachuteItem), bool bInstant)
{
//Note: The 'give parachute' param is being ignored -- it is
// too error prone, and causes asserts and failed tasks.
fwFlags32 paraFlags = CTaskParachute::PF_GiveParachute;
if(bInstant)
{
paraFlags.SetFlag(CTaskParachute::PF_InstantBlend);
}
CTaskParachute *pTask = rage_new CTaskParachute(paraFlags);
CScriptPeds::GivePedScriptedTask(iPedID, pTask, SCRIPT_TASK_PARACHUTE, "TASK_PARACHUTE");
}
void CommandTaskParachuteToTarget(int iPedID, const scrVector & svTargetLocation)
{
CTaskParachute *pTask = rage_new CTaskParachute(CTaskParachute::PF_GiveParachute | CTaskParachute::PF_SkipSkydiving);
pTask->SetTargetPosition(VECTOR3_TO_VEC3V((Vector3)svTargetLocation));
CScriptPeds::GivePedScriptedTask(iPedID, pTask, SCRIPT_TASK_PARACHUTE_TO_TARGET, "TASK_PARACHUTE_TO_TARGET");
}
void CommandSetParachuteTaskTarget(int iPedID, const scrVector & svTargetLocation)
{
CPed *pPed = CTheScripts::GetEntityToModifyFromGUID<CPed>(iPedID);
if (pPed)
{
CTaskParachute *pTaskParachute = (CTaskParachute *)pPed->GetPedIntelligence()->FindTaskByType(CTaskTypes::TASK_PARACHUTE);
if (SCRIPT_VERIFY(pTaskParachute, "Ped isn't running parachute task, please use GET_PED_PARACHUTE_STATE != PPS_INVALID to check") )
{
pTaskParachute->GetParachuteFlags().SetFlag(CTaskParachute::PF_SkipSkydiving);
pTaskParachute->SetTargetPosition(VECTOR3_TO_VEC3V((Vector3)svTargetLocation));
}
}
}
void CommandSetParachuteTaskThrust(int iPedID, float fThrust)
{
CPed *pPed = CTheScripts::GetEntityToModifyFromGUID<CPed>(iPedID);
if (pPed)
{
CTaskParachute *pTaskParachute = (CTaskParachute *)pPed->GetPedIntelligence()->FindTaskByType(CTaskTypes::TASK_PARACHUTE);
if (SCRIPT_VERIFY(pTaskParachute, "Ped isn't running parachute task, please use GET_PED_PARACHUTE_STATE != PPS_INVALID to check") )
{
pTaskParachute->SetParachuteThrust(fThrust);
}
}
}
void CommandSetParachuteTaskTargetEntity(int iPedID, int iTargetID, const scrVector & vOffset)
{
CPed* pPed = CTheScripts::GetEntityToModifyFromGUID<CPed>(iPedID);
if(pPed)
{
const CPhysical* pTarget = CTheScripts::GetEntityToModifyFromGUID<CPhysical>(iTargetID);
if(pTarget)
{
CTaskParachute* pTaskParachute = static_cast<CTaskParachute *>(pPed->GetPedIntelligence()->FindTaskByType(CTaskTypes::TASK_PARACHUTE));
if(SCRIPT_VERIFY(pTaskParachute, "Ped isn't running parachute task, please use GET_PED_PARACHUTE_STATE != PPS_INVALID to check") )
{
pTaskParachute->SetTarget(pTarget, VECTOR3_TO_VEC3V((Vector3)vOffset));
}
}
}
}
void CommandTaskJetpack(int iPedID)
{
CPed* pPed = CTheScripts::GetEntityToModifyFromGUID<CPed>(iPedID);
if(pPed)
{
//Ensure the inventory is valid.
CPedInventory* pPedInventory = pPed->GetInventory();
if(pPedInventory)
{
//! Give ped a jetpack.
pPedInventory->AddWeapon(GADGETTYPE_JETPACK);
//! Equip it.
pPed->SetPedConfigFlag(CPED_CONFIG_FLAG_EquipJetpack, true);
}
}
}
void CommandTaskJetpackGoToCoord(int JETPACK_ONLY(iPedID), const scrVector & JETPACK_ONLY(scrVecCoors), float JETPACK_ONLY(fMinHeightFromGround), bool JETPACK_ONLY(bDisableThrustAtDestination))
{
#if ENABLE_JETPACK CPed* pPed = CTheScripts::GetEntityToModifyFromGUID(iPedID); if(pPed) { CTask* pTask = pPed->GetPedIntelligence()->FindTaskActiveByType(CTaskTypes::TASK_JETPACK); if (SCRIPT_VERIFY(pTask, "TASK_JETPACK_GO_TO_COORD - Not running jetpack task!")) { CTaskJetpack pTaskJetpack = static_cast<CTaskJetpack>(pTask); if (SCRIPT_VERIFY(pTaskJetpack, "TASK_JETPACK_GO_TO_COORD - Not running jetpack task!")) { Vector3 vCoord = Vector3(scrVecCoors); pTaskJetpack->SetGoToParametersForAI(NULL, vCoord, fMinHeightFromGround, bDisableThrustAtDestination); } } } #endif }
void CommandTaskJetpackGoToEntity(int JETPACK_ONLY(iPedID), int JETPACK_ONLY(iTargetEntityID), const scrVector & JETPACK_ONLY(scrVecCoorsOffset), float JETPACK_ONLY(fMinHeightFromGround), bool JETPACK_ONLY(bDisableThrustAtDestination), bool JETPACK_ONLY(bUseRandomTimerWhenClose))
{
#if ENABLE_JETPACK CPed* pPed = CTheScripts::GetEntityToModifyFromGUID(iPedID); if(pPed) { CTask* pTask = pPed->GetPedIntelligence()->FindTaskActiveByType(CTaskTypes::TASK_JETPACK); if (SCRIPT_VERIFY(pTask, "TASK_JETPACK_GO_TO_ENTITY - Not running jetpack task!")) { CTaskJetpack pTaskJetpack = static_cast<CTaskJetpack>(pTask); if (SCRIPT_VERIFY(pTaskJetpack, "TASK_JETPACK_GO_TO_ENTITY - Not running jetpack task!")) { CPhysical* pTargetPhysical = CTheScripts::GetEntityToModifyFromGUID(iTargetEntityID); if (SCRIPT_VERIFY(pTargetPhysical, "TASK_JETPACK_GO_TO_ENTITY - Target entity is not valid!")) { Vector3 vCoord = Vector3(scrVecCoorsOffset); pTaskJetpack->SetGoToParametersForAI(pTargetPhysical, vCoord, fMinHeightFromGround, bDisableThrustAtDestination, bUseRandomTimerWhenClose); } } } } #endif }
void CommandTaskJetpackShootAtCoord(int JETPACK_ONLY(iPedID), const scrVector & JETPACK_ONLY(scrVecCoors), float JETPACK_ONLY(fAbortRange), int JETPACK_ONLY(iFrequencyPercentage), int JETPACK_ONLY(iFiringPatternHash))
{
#if ENABLE_JETPACK CPed* pPed = CTheScripts::GetEntityToModifyFromGUID(iPedID); if(pPed) { CTask* pTask = pPed->GetPedIntelligence()->FindTaskActiveByType(CTaskTypes::TASK_JETPACK); if (SCRIPT_VERIFY(pTask, "TASK_JETPACK_SHOOT_AT_COORD - Not running jetpack task!")) { CTaskJetpack pTaskJetpack = static_cast<CTaskJetpack>(pTask); if (SCRIPT_VERIFY(pTaskJetpack, "TASK_JETPACK_SHOOT_AT_COORD - Not running jetpack task!")) { Vector3 vCoord = Vector3(scrVecCoors); pTaskJetpack->SetShootAtParametersForAI(NULL, vCoord, fAbortRange, iFrequencyPercentage, iFiringPatternHash); } } } #endif }
void CommandTaskJetpackShootAtEntity(int JETPACK_ONLY(iPedID), int JETPACK_ONLY(iTargetEntityID), const scrVector & JETPACK_ONLY(scrVecCoorsOffset), float JETPACK_ONLY(fAbortRange), int JETPACK_ONLY(iFrequencyPercentage), int JETPACK_ONLY(iFiringPatternHash))
{
#if ENABLE_JETPACK CPed* pPed = CTheScripts::GetEntityToModifyFromGUID(iPedID); if(pPed) { CTask* pTask = pPed->GetPedIntelligence()->FindTaskActiveByType(CTaskTypes::TASK_JETPACK); if (SCRIPT_VERIFY(pTask, "TASK_JETPACK_SHOOT_AT_ENTITY - Not running jetpack task!")) { CTaskJetpack pTaskJetpack = static_cast<CTaskJetpack>(pTask); if (SCRIPT_VERIFY(pTaskJetpack, "TASK_JETPACK_SHOOT_AT_ENTITY - Not running jetpack task!")) { Vector3 vCoord = Vector3(scrVecCoorsOffset);
CPhysical* pTargetPhysical = CTheScripts::GetEntityToModifyFromGUID<CPhysical>(iTargetEntityID);
if (SCRIPT_VERIFY(pTargetPhysical, "TASK_JETPACK_SHOOT_AT_ENTITY - Target entity is not valid!"))
{
pTaskJetpack->SetShootAtParametersForAI(pTargetPhysical, vCoord, fAbortRange, iFrequencyPercentage, iFiringPatternHash);
}
}
}
}
#endif }
void CommandTaskJetpackStopShooting(int JETPACK_ONLY(iPedID))
{
#if ENABLE_JETPACK CPed* pPed = CTheScripts::GetEntityToModifyFromGUID(iPedID); if(pPed) { CTask* pTask = pPed->GetPedIntelligence()->FindTaskActiveByType(CTaskTypes::TASK_JETPACK); if (SCRIPT_VERIFY(pTask, "TASK_JETPACK_SHOOT_AT_COORD - Not running jetpack task!")) { CTaskJetpack pTaskJetpack = static_cast<CTaskJetpack>(pTask); if (SCRIPT_VERIFY(pTaskJetpack, "TASK_JETPACK_SHOOT_AT_COORD - Not running jetpack task!")) { pTaskJetpack->RequestDrivebyTermination(true); } } } #endif }
void CommandTaskRappelFromHeli(int iPedIndex, float fMinRappelHeight)
{
CTaskHeliPassengerRappel* pRappelTask = rage_new CTaskHeliPassengerRappel(fMinRappelHeight);
CScriptPeds::GivePedScriptedTask(iPedIndex, pRappelTask, SCRIPT_TASK_RAPPEL_FROM_HELI, "TASK_RAPPEL_FROM_HELI");
}
void CommandTaskDragPedToCoord(int iDraggerIndex, int iDraggedIndex, const scrVector & vCoords, float fMoveBlendRatioForApproach)
{
CPed* pDragged = CTheScripts::GetEntityToModifyFromGUID<CPed>(iDraggedIndex, CTheScripts::GUID_ASSERT_FLAGS_NO_DEAD_CHECK);
if(pDragged)
{
CTaskDraggingToSafety* pTask = rage_new CTaskDraggingToSafety(pDragged, NULL, CTaskDraggingToSafety::CF_CoverNotRequired);
pTask->DragToPosition(vCoords);
pTask->SetMoveBlendRatioForApproach(fMoveBlendRatioForApproach);
CScriptPeds::GivePedScriptedTask(iDraggerIndex, pTask, SCRIPT_TASK_DRAG_PED_TO_COORD, "TASK_DRAG_PED_TO_COORD");
}
}
bool CommandIsPedGettingUp(int PedIndex)
{
const CPed *pPed = CTheScripts::GetEntityToQueryFromGUID<CPed>(PedIndex);
if(pPed)
{
return pPed->GetPedIntelligence()->IsPedGettingUp();
}
return false;
}
void CommandTaskWrithe(int iPedID, int iPedTargetID, int nMinFireLoops, int UNUSED_PARAM(StartState), bool bForceShootOnGround, int nShootFromGroundTimer)
{
const CPed* pTargetPed = CTheScripts::GetEntityToQueryFromGUID<CPed>(iPedTargetID);
if (SCRIPT_VERIFY(pTargetPed, "SCRIPT_TASK_WRITHE - Invalid target"))
{
bool bFromGetUp = true;
bool bEnableRagdollOnCollision = true;
if (bForceShootOnGround)
{
bEnableRagdollOnCollision = false;
}
CTaskWrithe* pTask = rage_new CTaskWrithe(CWeaponTarget(pTargetPed), bFromGetUp, bEnableRagdollOnCollision , bForceShootOnGround);
pTask->SetMinFireLoops(nMinFireLoops);
pTask->SetShootFromGroundTimer(nShootFromGroundTimer);
CScriptPeds::GivePedScriptedTask(iPedID, pTask, SCRIPT_TASK_WRITHE, "TASK_WRITHE");
}
}
bool CommandIsPedInWrithe(int iPedID)
{
const CPed* pPed = CTheScripts::GetEntityToQueryFromGUID<CPed>(iPedID);
if (SCRIPT_VERIFY(pPed, "SCRIPT_TASK_WRITHE - Invalid target"))
{
return pPed->GetPedResetFlag(CPED_RESET_FLAG_IsInWrithe);
}
return false;
}
void CommandOpenPatrolRoute(const char* RouteName)
{
CTheScripts::GetScriptPatrol().OpenPatrolRoute(RouteName);
}
void CommandClosePatrolRoute()
{
CTheScripts::GetScriptPatrol().ClosePatrolRoute();
}
void CommandAddPatrolNode(int NodeId, const char* NodeType, const scrVector & scrNodePos, const scrVector & scrNodeHeading, int Duration)
{
Vector3 vNodePos(scrNodePos);
Vector3 vNodeHeading(scrNodeHeading);
CTheScripts::GetScriptPatrol().AddPatrolNode(NodeId, NodeType, vNodePos, vNodeHeading, Duration);
}
void CommandAddPatrolNodeLink(int NodeID1, int NodeID2)
{
CTheScripts::GetScriptPatrol().AddPatrolLink(NodeID1, NodeID2);
}
void CommandCreatePatrolRoute()
{
CTheScripts::GetScriptPatrol().CreatePatrolRoute();
}
void CommandDeletePatrolRoute(const char * RouteName)
{
u32 HashedRouteName = atStringHash(RouteName);
CTheScripts::GetCurrentGtaScriptHandler()->RemoveScriptResource(CGameScriptResource::SCRIPT_RESOURCE_PATROL_ROUTE, static_cast<ScriptResourceRef>(HashedRouteName));
}
void CommandTaskPatrol (int PedIndex, const char* cPatrolRouteName, int iAlertState, bool bCanChatToPeds, bool bUseHeadLookAt)
{
SCRIPT_ASSERT(cPatrolRouteName,"Error, NULL patrol route name, did you forget to initialise the route name?");
int iRouteNameHash =atStringHash(cPatrolRouteName);
CTaskPatrol::AlertStatus asAlertState = CTaskPatrol::AlertStatus (iAlertState);
u32 iPatrolFlags = 0;
if (bCanChatToPeds)
{
iPatrolFlags |= GF_CanChatToPeds;
}
if (bUseHeadLookAt)
{
iPatrolFlags |= GF_UseHeadLookAt;
}
CTask* pTask = rage_new CTaskPatrol(iRouteNameHash, asAlertState, iPatrolFlags);
CScriptPeds::GivePedScriptedTask(PedIndex, pTask, SCRIPT_TASK_PATROL, "TASK_PATROL");
}
void CommandTaskStayInCover (int PedIndex)
{
CTask* pTask = rage_new CTaskStayInCover();
CScriptPeds::GivePedScriptedTask(PedIndex, pTask, SCRIPT_TASK_STAY_IN_COVER, "TASK_STAY_IN_COVER");
}
bool CommandGetPatrolNodeInfo (int PedIndex, int &iTimeLeftAtNode, int &iNodeId)
{
const CPed* pPed = CTheScripts::GetEntityToQueryFromGUID<CPed>(PedIndex);
bool bHaveVaildTask = false;
if (pPed)
{
CTask* pTask = pPed->GetPedIntelligence()->FindTaskActiveByType(CTaskTypes::TASK_PATROL);
//CTask* pTask = pPedAI->GetTaskManager()->GetActiveTask();
if (pTask && pTask->GetTaskType()==CTaskTypes::TASK_PATROL)
{
CTaskPatrol* pPatrolTask = (CTaskPatrol*)pTask;
iNodeId = pPatrolTask->CTaskPatrol::GetCurrentNode();
iTimeLeftAtNode = pPatrolTask->CTaskPatrol::GetTimeLeftAtNode();
bHaveVaildTask = true;
}
}
return bHaveVaildTask;
}
void CommandTaskHangGlider(int UNUSED_PARAM(PedIndex), int UNUSED_PARAM(HangGliderObjectIndex))
{
Assertf(0, "HangGlider is deprecated functionality");
}
void CommandSetHangGliderAirSpeed(int UNUSED_PARAM(PedIndex), const scrVector & UNUSED_PARAM(scrVAirSpeed))
{
Assertf(0, "HangGlider is deprecated functionality");
}
void CommandVehicleShootAtPed(int PedIndex, int OtherPedIndex, float fFireTolerance)
{
const CPed* pOtherPed = CTheScripts::GetEntityToQueryFromGUID<CPed>(OtherPedIndex);
if (pOtherPed)
{
CAITarget target(pOtherPed);
CTask* pTask=rage_new CTaskVehicleCombat(&target, 0, fFireTolerance);
CScriptPeds::GivePedScriptedTask(PedIndex, pTask, SCRIPT_TASK_VEHICLE_SHOOT_AT_ENTITY, "TASK_VEHICLE_SHOOT_AT_PED");
}
}
void CommandVehicleAimAtPed(int PedIndex, int OtherPedIndex)
{
const CPed* pOtherPed = CTheScripts::GetEntityToQueryFromGUID<CPed>(OtherPedIndex);
if (pOtherPed)
{
CAITarget target(pOtherPed);
CTask* pTask=rage_new CTaskVehicleCombat(&target, CTaskVehicleCombat::Flag_justAim);
CScriptPeds::GivePedScriptedTask(PedIndex, pTask, SCRIPT_TASK_VEHICLE_AIM_AT_ENTITY, "TASK_VEHICLE_AIM_AT_PED");
}
}
void CommandVehicleShootAtCoord(int PedIndex, const scrVector & svTarget, float fFireTolerance)
{
Vector3 vTarget(svTarget);
CAITarget target(vTarget);
CTask* pTask=rage_new CTaskVehicleCombat(&target, 0, fFireTolerance);
CScriptPeds::GivePedScriptedTask(PedIndex, pTask, SCRIPT_TASK_VEHICLE_SHOOT_AT_COORD, "TASK_VEHICLE_SHOOT_AT_COORD");
}
void CommandVehicleAimAtCoord(int PedIndex, const scrVector & svTarget)
{
Vector3 vTarget(svTarget);
CAITarget target(vTarget);
CTask* pTask=rage_new CTaskVehicleCombat(&target, CTaskVehicleCombat::Flag_justAim);
CScriptPeds::GivePedScriptedTask(PedIndex, pTask, SCRIPT_TASK_VEHICLE_AIM_AT_COORD, "TASK_VEHICLE_AIM_AT_COORD");
}
void CommandVehicleAimUsingCamera(int PedIndex)
{
CTask* pTask=rage_new CTaskVehicleCombat(NULL, CTaskVehicleCombat::Flag_useCamera);
CScriptPeds::GivePedScriptedTask(PedIndex, pTask, SCRIPT_TASK_VEHICLE_AIM_USING_CAMERA, "TASK_VEHICLE_AIM_USING_CAMERA");
}
// Give a ped the bind-pose task to examine the transition from NM to animation.
// DEV ONLY!
void CommandTaskBindPose(int DEV_ONLY(iPedID), bool DEV_ONLY(bDoBlendFromNM))
{
#if __DEV CTask* pTask = rage_new CTaskBindPose(bDoBlendFromNM); CScriptPeds::GivePedScriptedTask(iPedID, pTask, SCRIPT_TASK_BIND_POSE, "TASK_BIND_POSE"); #endif // __DEV }
// Give ped an NM electrocution task.
void CommandElectrocute(int iPedID, int nMinTime, int nMaxTime)
{
CPed* pPed = CTheScripts::GetEntityToModifyFromGUID<CPed>(iPedID);
if (pPed && CTaskNMBehaviour::CanUseRagdoll(pPed, RAGDOLL_TRIGGER_SCRIPT) )
{
UpdatePedRagdollBoundsForScriptActivation(pPed);
CTask* pNmTask = rage_new CTaskNMElectrocute(nMinTime, nMaxTime);
CEventSwitch2NM event(nMaxTime, pNmTask, true, nMinTime);
pPed->SwitchToRagdoll(event);
}
}
// Give ped a high fall task.
void CommandHighFall(int iPedID, int nMinTime, int nMaxTime, int eEntryType)
{
CPed* pPed = CTheScripts::GetEntityToModifyFromGUID<CPed>(iPedID);
if (pPed && CTaskNMBehaviour::CanUseRagdoll(pPed, RAGDOLL_TRIGGER_SCRIPT) )
{
UpdatePedRagdollBoundsForScriptActivation(pPed);
CTask* pNmTask = rage_new CTaskNMHighFall(nMinTime, NULL, (CTaskNMHighFall::eHighFallEntryType)eEntryType);
CEventSwitch2NM event(nMaxTime, pNmTask, true, nMinTime);
pPed->SwitchToRagdoll(event);
}
}
// Give ped an NM dangle-from-meathook task.
void CommandDangleFromMeathook(bool bStart, int iPedID, int iHookID, const scrVector & scrPos, bool bDoGrab, float fFrequency, int UNUSED_PARAM(nMinTime), int nMaxTime,
bool bFixRotation, float fRotMinX, float fRotMinY, float fRotMinZ, float fRotMaxX, float fRotMaxY, float fRotMaxZ)
{
Vector3 pos = Vector3(scrPos.x, scrPos.y, scrPos.z);
Vector3 vecRotMinLimits = Vector3(fRotMinX, fRotMinY, fRotMinZ);
Vector3 vecRotMaxLimits = Vector3(fRotMaxX, fRotMaxY, fRotMaxZ);
CPed* pPed = CTheScripts::GetEntityToModifyFromGUID<CPed>(iPedID);
if (pPed)
{
// First time activating?
if (bStart && CTaskNMBehaviour::CanUseRagdoll(pPed, RAGDOLL_TRIGGER_SCRIPT))
{
UpdatePedRagdollBoundsForScriptActivation(pPed);
// Give it the dangle task
CTask* pNmTask = rage_new CTaskNMDangle(pos);
CEventSwitch2NM event(nMaxTime, pNmTask, true);
pPed->SwitchToRagdoll(event);
// Set grab state
((CTaskNMDangle*)pNmTask)->SetGrabParams(pPed, bDoGrab, fFrequency);
// Create the hook to world constraint
if (pPed->GetRagdollConstraintData())
{
CPhysical* pHook = CTheScripts::GetEntityToModifyFromGUID<CPhysical>(iHookID);
AssertMsg(pHook && pHook->GetCurrentPhysicsInst(), "CommandDangleFromMeathook - valid hookID not provided");
if (pHook && pHook->GetCurrentPhysicsInst())
pPed->GetRagdollConstraintData()->CreateHookToWorldConstraint(pHook, pos, bFixRotation, vecRotMinLimits, vecRotMaxLimits);
}
}
// Set grab state
if (CTaskNMDangle* pTaskDangle = static_cast<CTaskNMDangle*>(
pPed->GetPedIntelligence()->FindTaskActiveByType(CTaskTypes::TASK_NM_DANGLE)))
{
pTaskDangle->SetGrabParams(pPed, bDoGrab, fFrequency);
pTaskDangle->UpdateHookConstraint(pos, vecRotMinLimits, vecRotMaxLimits);
}
else if (pPed->GetRagdollConstraintData())
{
// Update the hook to world constraint manually if the dangle task has ended
pPed->GetRagdollConstraintData()->UpdateHookToWorldConstraint(pos, vecRotMinLimits, vecRotMaxLimits);
}
}
}
// Give ped an NM slung-over-shoulder task.
void CommandSlungOverShoulder(int iPedIDSlungPed, int iPedIDCarrier, int nMinTime, int nMaxTime)
{
CPed* pPedSlung = CTheScripts::GetEntityToModifyFromGUID<CPed>(iPedIDSlungPed);
CPed* pPedCarrier = CTheScripts::GetEntityToModifyFromGUID<CPed>(iPedIDCarrier);
if (pPedSlung && pPedCarrier && CTaskNMBehaviour::CanUseRagdoll(pPedSlung, RAGDOLL_TRIGGER_SLUNG_OVER_SHOULDER))
{
// Perform normal collision to avoid popping upon activation
pPedSlung->GetRagdollInst()->SetDontZeroMatricesOnActivation();
UpdatePedRagdollBoundsForScriptActivation(pPedSlung);
// Give it the slung over shoulder task
CTask* pNmTask = rage_new CTaskNMSlungOverShoulder(pPedSlung, pPedCarrier);
CEventSwitch2NM event(nMaxTime, pNmTask, true, nMinTime);
pPedSlung->SwitchToRagdoll(event);
}
}
// Give ped an NM stumble task.
void CommandStumble(int iPedID, int nMinTime, int nMaxTime)
{
Assertf(0, "CommandStumble is no longer supported");
CPed* pPed = CTheScripts::GetEntityToModifyFromGUID<CPed>(iPedID);
if (pPed && CTaskNMBehaviour::CanUseRagdoll(pPed, RAGDOLL_TRIGGER_SCRIPT) )
{
UpdatePedRagdollBoundsForScriptActivation(pPed);
CTask* pNmTask = rage_new CTaskNMRelax(nMinTime, nMaxTime);
CEventSwitch2NM event(nMaxTime, pNmTask, true, nMinTime);
pPed->SwitchToRagdoll(event);
}
}
void CommandTaskSetBlockingOfNonTemporaryEvents (int PedIndex, bool bSet)
{
CTask* pTask=rage_new CTaskSetBlockingOfNonTemporaryEvents(bSet);
CScriptPeds::GivePedScriptedTask(PedIndex, pTask, SCRIPT_TASK_SET_BLOCKING_OF_NON_TEMPORARY_EVENTS, "TASK_SET_BLOCKING_OF_NON_TEMPORARY_EVENTS");
}
void CommandTaskForceMotionState (int PedIndex, int motionState, bool bForceRestart)
{
const CPed* pPed = CTheScripts::GetEntityToQueryFromGUID<CPed>(PedIndex, 0);
if (scriptVerifyf(CPed::IsAllowedToForceMotionState((CPedMotionStates::eMotionState)motionState, pPed), "%s: TASK_FORCE_MOTION_STATE - Failed to force state %d - See TTY for details", CTheScripts::GetCurrentScriptNameAndProgramCounter(), motionState))
{
CTask* pTask=rage_new CTaskForceMotionState((CPedMotionStates::eMotionState)motionState, bForceRestart);
CScriptPeds::GivePedScriptedTask(PedIndex, pTask, SCRIPT_TASK_FORCE_MOTION_STATE, "TASK_FORCE_MOTION_STATE");
}
}
void CommandTaskMoveNetworkByName(int PedIndex, const char *network, float blendDuration, bool bAllowOverrideCloneUpdate, const char* szDictionary, s32 flags)
{
if (scriptVerifyf(g_NetworkDefStore.FindSlot(network)!=-1, "TASK_MOVE_NETWORK_BY_NAME - Network def '%s' does not exist!", network ))
{
u32 iFlags = (u32)flags;
if(bAllowOverrideCloneUpdate)
{
iFlags |= CTaskMoVEScripted::Flag_AllowOverrideCloneUpdate;
}
CTaskMoVEScripted* pTask=rage_new CTaskMoVEScripted(fwMvNetworkDefId(network), iFlags, blendDuration, VEC3_ZERO, Quaternion::sm_I);
if(szDictionary && szDictionary[0] != '\0')
{
pTask->SetCloneSyncDictHash(atStringHash(szDictionary));
}
bool bPartOfASequence = (PedIndex == NULL_IN_SCRIPTING_LANGUAGE);
if (iFlags&CTaskMoVEScripted::Flag_Secondary)
{
if(SCRIPT_VERIFY( !bPartOfASequence, "TASK_MOVE_NETWORK_BY_NAME_SECONDARY* Cant be used in a sequence!" ))
{
CPed * pPed = CTheScripts::GetEntityToModifyFromGUID<CPed>(PedIndex);
if(pPed)
{
pPed->GetPedIntelligence()->AddTaskSecondary( pTask, PED_TASK_SECONDARY_PARTIAL_ANIM );
}
}
return;
}
CScriptPeds::GivePedScriptedTask(PedIndex, pTask, SCRIPT_TASK_MOVE_NETWORK, "TASK_MOVE_NETWORK");
}
}
void CommandTaskMoveNetworkByNameWithInitParams(int PedIndex, const char *network, int& initialParameters, float blendDuration, bool bAllowOverrideCloneUpdate, const char* szDictionary, s32 flags)
{
if (scriptVerifyf(g_NetworkDefStore.FindSlot(network)!=-1, "TASK_MOVE_NETWORK_BY_NAME - Network def '%s' does not exist!", network ))
{
u32 iFlags = (u32)flags;
if(bAllowOverrideCloneUpdate)
{
iFlags |= CTaskMoVEScripted::Flag_AllowOverrideCloneUpdate;
}
CTaskMoVEScripted::ScriptInitialParameters* pInitParams = reinterpret_cast<CTaskMoVEScripted::ScriptInitialParameters*>(&initialParameters);
CTaskMoVEScripted* pTask=rage_new CTaskMoVEScripted(fwMvNetworkDefId(network), iFlags, blendDuration, VEC3_ZERO, Quaternion::sm_I, pInitParams);
if(szDictionary && szDictionary[0] != '\0')
{
pTask->SetCloneSyncDictHash(atStringHash(szDictionary));
}
CScriptPeds::GivePedScriptedTask(PedIndex, pTask, SCRIPT_TASK_MOVE_NETWORK, "TASK_MOVE_NETWORK");
}
}
void CommandTaskMoveNetworkAdvancedByName(int PedIndex, const char *network, const scrVector & pos, const scrVector & rot, s32 RotOrder, float blendDuration, bool bAllowOverrideCloneUpdate, const char* szDictionary, s32 flags)
{
if (scriptVerifyf(g_NetworkDefStore.FindSlot(network)!=-1, "TASK_MOVE_NETWORK_ADVANCED_BY_NAME - Network def '%s' does not exist!", network ))
{
u32 iFlags = ((u32)flags);
iFlags |= CTaskMoVEScripted::Flag_SetInitialPosition;
if(bAllowOverrideCloneUpdate)
{
iFlags |= CTaskMoVEScripted::Flag_AllowOverrideCloneUpdate;
}
Vector3 vPos(pos);
Vector3 vRot(rot);
vRot*= DtoR;
Quaternion qRot;
CScriptEulers::QuaternionFromEulers(qRot, vRot, static_cast<EulerAngleOrder>(RotOrder));
CTaskMoVEScripted* pTask=rage_new CTaskMoVEScripted(fwMvNetworkDefId(network), iFlags, blendDuration, vPos, qRot);
if(szDictionary && szDictionary[0] != '\0')
{
pTask->SetCloneSyncDictHash(atStringHash(szDictionary));
}
bool bPartOfASequence = (PedIndex == NULL_IN_SCRIPTING_LANGUAGE);
if (iFlags&CTaskMoVEScripted::Flag_Secondary)
{
if(SCRIPT_VERIFY( !bPartOfASequence, "TASK_MOVE_NETWORK_ADVANCED_BY_NAME_SECONDARY* Cant be used in a sequence!" ))
{
CPed * pPed = CTheScripts::GetEntityToModifyFromGUID<CPed>(PedIndex);
if(pPed)
{
pPed->GetPedIntelligence()->AddTaskSecondary( pTask, PED_TASK_SECONDARY_PARTIAL_ANIM );
}
}
return;
}
CScriptPeds::GivePedScriptedTask(PedIndex, pTask, SCRIPT_TASK_MOVE_NETWORK, "TASK_MOVE_NETWORK_ADVANCED");
}
}
CTaskMoVEScripted* FindScriptedMoveTask(const CPed* pPed)
{
CTask* pTask = pPed->GetPedIntelligence()->FindTaskByType(CTaskTypes::TASK_MOVE_SCRIPTED);
if (!pTask)
{
pTask = pPed->GetPedIntelligence()->FindTaskSecondaryByType(CTaskTypes::TASK_MOVE_SCRIPTED);
}
return static_cast<CTaskMoVEScripted*>(pTask);
}
void CommandTaskMoveNetworkAdvancedByNameWithInitParams(int PedIndex, const char *network, int& initialParameters, const scrVector & pos, const scrVector & rot, s32 RotOrder, float blendDuration, bool bAllowOverrideCloneUpdate, const char* szDictionary, s32 flags)
{
if (scriptVerifyf(g_NetworkDefStore.FindSlot(network)!=-1, "TASK_MOVE_NETWORK_ADVANCED_BY_NAME - Network def '%s' does not exist!", network ))
{
u32 iFlags = ((u32)flags);
iFlags |= CTaskMoVEScripted::Flag_SetInitialPosition;
if(bAllowOverrideCloneUpdate)
{
iFlags |= CTaskMoVEScripted::Flag_AllowOverrideCloneUpdate;
}
CTaskMoVEScripted::ScriptInitialParameters* pInitParams = reinterpret_cast<CTaskMoVEScripted::ScriptInitialParameters*>(&initialParameters);
Vector3 vPos(pos);
Vector3 vRot(rot);
vRot*= DtoR;
Quaternion qRot;
CScriptEulers::QuaternionFromEulers(qRot, vRot, static_cast<EulerAngleOrder>(RotOrder));
CTaskMoVEScripted* pTask=rage_new CTaskMoVEScripted(fwMvNetworkDefId(network), iFlags, blendDuration, vPos, qRot, pInitParams);
if(szDictionary && szDictionary[0] != '\0')
{
pTask->SetCloneSyncDictHash(atStringHash(szDictionary));
}
CScriptPeds::GivePedScriptedTask(PedIndex, pTask, SCRIPT_TASK_MOVE_NETWORK, "TASK_MOVE_NETWORK_ADVANCED");
}
}
bool CommandIsTaskMoveNetworkActive(int PedIndex)
{
const CPed* pPed = CTheScripts::GetEntityToQueryFromGUID<CPed>(PedIndex);
if (pPed && pPed->GetPedIntelligence())
{
CTaskMoVEScripted* pTaskMoVE = FindScriptedMoveTask(pPed);
if( pTaskMoVE && pTaskMoVE->GetIsNetworkActive() )
{
return true;
}
}
return false;
}
void CommandSetTaskMoveNetworkClipSet(s32 pedIndex, s32 clipSetHash, s32 variableClipSetHash = 0)
{
const CPed* pPed = CTheScripts::GetEntityToQueryFromGUID<CPed>(pedIndex);
if (pPed && pPed->GetPedIntelligence())
{
CTaskMoVEScripted* pTaskMoVE = FindScriptedMoveTask(pPed);
if( SCRIPT_VERIFY (pTaskMoVE, "SET_TASK_MOVE_NETWORK_CLIP_SET - task not running! Have you called TASK_MOVE_NETWORK_BY_NAME yet?" ) )
{
fwMvClipSetVarId varId;
fwMvClipSetId setId;
if (variableClipSetHash==0)
{
variableClipSetHash = CLIP_SET_VAR_ID_INVALID;
}
varId.SetHash((u32)variableClipSetHash);
setId.SetHash((u32)clipSetHash);
pTaskMoVE->SetClipSet(varId, setId);
}
}
}
bool CommandIsTaskMoveNetworkReadyForTransition(int PedIndex)
{
const CPed* pPed = CTheScripts::GetEntityToQueryFromGUID<CPed>(PedIndex);
if (pPed && pPed->GetPedIntelligence())
{
CTaskMoVEScripted* pTaskMoVE = FindScriptedMoveTask(pPed);
if (SCRIPT_VERIFY (pTaskMoVE, "IS_TASK_MOVE_NETWORK_READY_FOR_TRANSITION - task is not running!"))
{
if( SCRIPT_VERIFY (pTaskMoVE->GetIsNetworkActive(), "IS_TASK_MOVE_NETWORK_READY_FOR_TRANSITION - task not active! Check IS_TASK_MOVE_NETWORK_ACTIVE!" ) )
{
return pTaskMoVE->GetState() == CTaskMoVEScripted::State_InState;
}
}
}
return false;
}
void CommandRequestTaskMoveNetworkStateTransition(int PedIndex, const char* szState)
{
CPed* pPed = CTheScripts::GetEntityToModifyFromGUID<CPed>(PedIndex, CTheScripts::GUID_ASSERT_FLAGS_INCLUDE_CLONES);
if (pPed && pPed->GetPedIntelligence())
{
CTaskMoVEScripted* pTaskMoVE = FindScriptedMoveTask(pPed);
if (SCRIPT_VERIFY (pTaskMoVE, "REQUEST_TASK_MOVE_NETWORK_STATE_TRANSITION - task is not running!"))
{
if( SCRIPT_VERIFY (pTaskMoVE->GetIsNetworkActive(), "REQUEST_TASK_MOVE_NETWORK_STATE_TRANSITION - task not active! Check IS_TASK_MOVE_NETWORK_ACTIVE!" ) )
{
if( SCRIPT_VERIFY (pTaskMoVE->GetState() == CTaskMoVEScripted::State_InState, "REQUEST_TASK_MOVE_NETWORK_STATE_TRANSITION - task not ready for a transition! Check IS_TASK_MOVE_NETWORK_READY_FOR_TRANSITION!" ) )
{
pTaskMoVE->RequestStateTransition(szState);
}
}
}
}
}
void CommandSetExpectedCloneNextTaskMoveNetworkState(int PedIndex, const char* szState)
{
CPed* pPed = CTheScripts::GetEntityToModifyFromGUID<CPed>(PedIndex, CTheScripts::GUID_ASSERT_FLAGS_INCLUDE_CLONES);
if (pPed && pPed->GetPedIntelligence())
{
CTaskMoVEScripted* pTaskMoVE = FindScriptedMoveTask(pPed);
if (SCRIPT_VERIFY (pTaskMoVE, "SET_EXPECTED_CLONE_NEXT_TASK_MOVE_NETWORK_STATE - task is not running!"))
{
if( SCRIPT_VERIFY (pTaskMoVE->GetIsNetworkActive(), "SET_EXPECTED_CLONE_NEXT_TASK_MOVE_NETWORK_STATE - task not active! Check IS_TASK_MOVE_NETWORK_ACTIVE!" ) )
{
if( SCRIPT_VERIFY (pTaskMoVE->GetState() == CTaskMoVEScripted::State_InState, "SET_EXPECTED_CLONE_NEXT_TASK_MOVE_NETWORK_STATE - task not ready for a transition! Check IS_TASK_MOVE_NETWORK_READY_FOR_TRANSITION!" ) )
{
pTaskMoVE->SetExpectedCloneNextStateTransition(szState);
}
}
}
}
}
const char* CommandGetTaskMoveNetworkState(int PedIndex)
{
const CPed* pPed = CTheScripts::GetEntityToQueryFromGUID<CPed>(PedIndex);
if (pPed && pPed->GetPedIntelligence())
{
CTaskMoVEScripted* pTaskMoVE = FindScriptedMoveTask(pPed);
if (SCRIPT_VERIFY (pTaskMoVE, "GET_TASK_MOVE_NETWORK_STATE - task is not running!"))
{
if( SCRIPT_VERIFY (pTaskMoVE->GetIsNetworkActive(), "GET_TASK_MOVE_NETWORK_STATE - task not active! Check IS_TASK_MOVE_NETWORK_ACTIVE!" ) )
{
return pTaskMoVE->GetScriptStateName();
}
}
}
return "Unknown";
}
void CommandSetTaskMoveNetworkSignalFloat(int PedIndex, const char* szSignal, float fSignal)
{
CPed* pPed = CTheScripts::GetEntityToModifyFromGUID<CPed>(PedIndex, CTheScripts::GUID_ASSERT_FLAGS_INCLUDE_CLONES);
if (pPed && pPed->GetPedIntelligence())
{
CTaskMoVEScripted* pTaskMoVE = FindScriptedMoveTask(pPed);
if (SCRIPT_VERIFY (pTaskMoVE, "SET_TASK_MOVE_NETWORK_SIGNAL_FLOAT - task is not running!"))
{
if( SCRIPT_VERIFY (pTaskMoVE->GetIsNetworkActive(), "SET_TASK_MOVE_NETWORK_SIGNAL_FLOAT - task not active! Check IS_TASK_MOVE_NETWORK_ACTIVE!" ) )
{
if( SCRIPT_VERIFY ((!pPed->IsNetworkClone() || pTaskMoVE->GetAllowOverrideCloneUpdate()),
"SET_TASK_MOVE_NETWORK_SIGNAL_FLOAT - Can't set float on cloned ped if its task is not being overridden!" ) )
{
pTaskMoVE->SetSignalFloat(szSignal, fSignal);
}
}
}
}
}
void CommandSetTaskMoveNetworkSignalFloatLerpRate(int PedIndex, const char* szSignal, float fLerpRate)
{
scriptAssertf(fLerpRate!=0.0f, "CommandSetTaskMoveNetworkSignalFloatLerpRate don't expect fLerpRate to be 0.0f");
CPed* pPed = CTheScripts::GetEntityToModifyFromGUID<CPed>(PedIndex);
if (pPed && pPed->GetPedIntelligence())
{
CTaskMoVEScripted* pTaskMoVE = FindScriptedMoveTask(pPed);
if (SCRIPT_VERIFY (pTaskMoVE, "SET_TASK_MOVE_NETWORK_SIGNAL_FLOAT_LERP_RATE - task is not running!"))
{
if( SCRIPT_VERIFY (pTaskMoVE->GetIsNetworkActive(), "SET_TASK_MOVE_NETWORK_SIGNAL_FLOAT_LERP_RATE - task not active! Check IS_TASK_MOVE_NETWORK_ACTIVE!" ) )
{
return pTaskMoVE->SetSignalFloatLerpRate(szSignal, fLerpRate);
}
}
}
}
float CommandGetTaskMoveNetworkSignalFloat(int PedIndex, const char* szSignal)
{
const CPed* pPed = CTheScripts::GetEntityToQueryFromGUID<CPed>(PedIndex);
if (pPed && pPed->GetPedIntelligence())
{
CTaskMoVEScripted* pTaskMoVE = FindScriptedMoveTask(pPed);
if (SCRIPT_VERIFY (pTaskMoVE, "GET_TASK_MOVE_NETWORK_SIGNAL_FLOAT - task is not running!"))
{
if( SCRIPT_VERIFY (pTaskMoVE->GetIsNetworkActive(), "GET_TASK_MOVE_NETWORK_SIGNAL_FLOAT - task not active! Check IS_TASK_MOVE_NETWORK_ACTIVE!" ) )
{
return pTaskMoVE->GetSignalFloat(szSignal);
}
}
}
return 0.0f;
}
void CommandSetTaskMoveNetworkSignalBool(int PedIndex, const char* szSignal, bool bSignal)
{
CPed* pPed = CTheScripts::GetEntityToModifyFromGUID<CPed>(PedIndex, CTheScripts::GUID_ASSERT_FLAGS_INCLUDE_CLONES);
if (pPed && pPed->GetPedIntelligence())
{
CTaskMoVEScripted* pTaskMoVE = FindScriptedMoveTask(pPed);
if (SCRIPT_VERIFY (pTaskMoVE, "SET_TASK_MOVE_NETWORK_SIGNAL_BOOL - task is not running!"))
{
if( SCRIPT_VERIFY (pTaskMoVE->GetIsNetworkActive(), "SET_TASK_MOVE_NETWORK_SIGNAL_BOOL - task not active! Check IS_TASK_MOVE_NETWORK_ACTIVE!" ) )
{
if( SCRIPT_VERIFY ((!pPed->IsNetworkClone() || pTaskMoVE->GetAllowOverrideCloneUpdate()),
"SET_TASK_MOVE_NETWORK_SIGNAL_BOOL - Can't set bool on cloned ped if its task is not being overridden!" ) )
{
pTaskMoVE->SetSignalBool(szSignal, bSignal);
}
}
}
}
}
void CommandSetTaskMoveNetworkSignalLocalBool(int PedIndex, const char* szSignal, bool bSignal)
{
CPed* pPed = CTheScripts::GetEntityToModifyFromGUID<CPed>(PedIndex, CTheScripts::GUID_ASSERT_FLAGS_INCLUDE_CLONES);
if (pPed && pPed->GetPedIntelligence())
{
CTaskMoVEScripted* pTaskMoVE = FindScriptedMoveTask(pPed);
if (SCRIPT_VERIFY (pTaskMoVE, "SET_TASK_MOVE_NETWORK_SIGNAL_LOCAL_BOOL - task is not running!"))
{
if( SCRIPT_VERIFY (pTaskMoVE->GetIsNetworkActive(), "SET_TASK_MOVE_NETWORK_SIGNAL_LOCAL_BOOL - task not active! Check IS_TASK_MOVE_NETWORK_ACTIVE!" ) )
{
pTaskMoVE->SetSignalBool(szSignal, bSignal, false);
}
}
}
}
void CommandSetTaskMoveNetworkSignalLocalFloat(int PedIndex, const char* szSignal, float signal)
{
CPed* pPed = CTheScripts::GetEntityToModifyFromGUID<CPed>(PedIndex, CTheScripts::GUID_ASSERT_FLAGS_INCLUDE_CLONES);
if (pPed && pPed->GetPedIntelligence())
{
CTaskMoVEScripted* pTaskMoVE = FindScriptedMoveTask(pPed);
if (SCRIPT_VERIFY (pTaskMoVE, "SET_TASK_MOVE_NETWORK_SIGNAL_LOCAL_FLOAT - task is not running!"))
{
if( SCRIPT_VERIFY (pTaskMoVE->GetIsNetworkActive(), "SET_TASK_MOVE_NETWORK_SIGNAL_LOCAL_FLOAT - task not active! Check IS_TASK_MOVE_NETWORK_ACTIVE!" ) )
{
pTaskMoVE->SetSignalFloat(szSignal, signal, false);
}
}
}
}
bool CommandGetTaskMoveNetworkSignalBool(int PedIndex, const char* szSignal)
{
const CPed* pPed = CTheScripts::GetEntityToQueryFromGUID<CPed>(PedIndex);
if (pPed && pPed->GetPedIntelligence())
{
CTaskMoVEScripted* pTaskMoVE = FindScriptedMoveTask(pPed);
if (SCRIPT_VERIFY (pTaskMoVE, "GET_TASK_MOVE_NETWORK_SIGNAL_BOOL - task is not running!"))
{
if( SCRIPT_VERIFY (pTaskMoVE->GetIsNetworkActive(), "GET_TASK_MOVE_NETWORK_SIGNAL_BOOL - task not active! Check IS_TASK_MOVE_NETWORK_ACTIVE!" ) )
{
return pTaskMoVE->GetSignalBool(szSignal);
}
}
}
return false;
}
bool CommandGetTaskMoveNetworkEvent(int PedIndex, const char * eventName)
{
const CPed* pPed = CTheScripts::GetEntityToQueryFromGUID<CPed>(PedIndex);
if (pPed && pPed->GetPedIntelligence())
{
CTaskMoVEScripted* pTaskMoVE = FindScriptedMoveTask(pPed);
if (SCRIPT_VERIFY (pTaskMoVE, "GET_TASK_MOVE_NETWORK_EVENT - task is not running!"))
{
if( SCRIPT_VERIFY (pTaskMoVE && pTaskMoVE->GetIsNetworkActive(), "GET_TASK_MOVE_NETWORK_EVENT - task not active! Check IS_TASK_MOVE_NETWORK_ACTIVE!" ) )
{
return pTaskMoVE->GetMoveEvent(eventName);
}
}
}
return false;
}
void CommandSetTaskMoveNetworkEnableCollisionOnNetworkCloneWhenFixed(int PedIndex, bool bEnableCollisionOnNetworkCloneWhenFixed)
{
CPed* pPed = CTheScripts::GetEntityToModifyFromGUID<CPed>(PedIndex);
if (pPed && pPed->GetPedIntelligence())
{
CTaskMoVEScripted* pTaskMoVE = FindScriptedMoveTask(pPed);
if (SCRIPT_VERIFY(pTaskMoVE, "SET_TASK_MOVE_NETWORK_ENABLE_COLLISION_ON_NETWORK_CLONE_WHEN_FIXED - task is not running!"))
{
if (SCRIPT_VERIFY(pTaskMoVE && pTaskMoVE->GetIsNetworkActive(), "SET_TASK_MOVE_NETWORK_ENABLE_COLLISION_ON_NETWORK_CLONE_WHEN_FIXED - task not active! Check IS_TASK_MOVE_NETWORK_ACTIVE!"))
{
return pTaskMoVE->SetEnableCollisionOnNetworkCloneWhenFixed(bEnableCollisionOnNetworkCloneWhenFixed);
}
}
}
}
void PlayVehicleAnimScriptCommand(int VehicleIndex, const char *pAnimName, const char *pAnimDictNameStr)
{
const strStreamingObjectName pAnimDictName( pAnimDictNameStr );
if(!SCRIPT_VERIFY(pAnimName, "VEHICLE_TASK_PLAY_ANIM - Animation name is null"))
{
return;
}
if(!SCRIPT_VERIFY(pAnimDictName.IsNotNull(), "VEHICLE_TASK_PLAY_ANIM - Animation dictionary name is null"))
{
return;
}
CVehicle *pVehicle = NULL;
if(NULL_IN_SCRIPTING_LANGUAGE!=VehicleIndex)
{
pVehicle = CTheScripts::GetEntityToModifyFromGUID<CVehicle>(VehicleIndex);
if(!pVehicle)
{
return;
}
}
//scriptAssertf(strlen(pAnimName)<ANIM_NAMELEN, "%s:TASK_PLAY_ANIM - Animation name is null : %s", CTheScripts::GetCurrentScriptNameAndProgramCounter(), pAnimName);
aiTask* pTask = rage_new CTaskVehicleAnimation(pAnimDictName, pAnimName);
if(pVehicle)
{
pVehicle->GetIntelligence()->AddTask(VEHICLE_TASK_TREE_SECONDARY, pTask, VEHICLE_TASK_SECONDARY_ANIM);
}
}
void CommandVehicleTaskPlayAnim(int VehicleIndex, const char *pAnimDictName, const char *pAnimName)
{
PlayVehicleAnimScriptCommand(VehicleIndex, pAnimName, pAnimDictName);
}
bool CommandIsMoveBlendRatioStill(float fMoveBlendRatio)
{
return CPedMotionData::GetIsStill(fMoveBlendRatio);
}
bool CommandIsMoveBlendRatioWalking(float fMoveBlendRatio)
{
return CPedMotionData::GetIsWalking(fMoveBlendRatio);
}
bool CommandIsMoveBlendRatioRunning(float fMoveBlendRatio)
{
return CPedMotionData::GetIsRunning(fMoveBlendRatio);
}
bool CommandIsMoveBlendRatioSprinting(float fMoveBlendRatio)
{
return CPedMotionData::GetIsSprinting(fMoveBlendRatio);
}
bool CommandIsPedStill(int PedIndex)
{
const CPed* pPed = CTheScripts::GetEntityToQueryFromGUID<CPed>(PedIndex);
if (pPed)
{
return pPed->GetMotionData()->GetIsStill();
}
return false;
}
bool CommandIsPedWalking(int PedIndex)
{
const CPed* pPed = CTheScripts::GetEntityToQueryFromGUID<CPed>(PedIndex);
if (pPed)
{
return pPed->GetMotionData()->GetIsWalking();
}
return false;
}
bool CommandPedIsRunning(int PedIndex)
{
const CPed* pPed = CTheScripts::GetEntityToQueryFromGUID<CPed>(PedIndex);
if (pPed)
{
return pPed->GetMotionData()->GetIsRunning();
}
return false;
}
bool CommandPedIsSprinting(int PedIndex)
{
const CPed* pPed = CTheScripts::GetEntityToQueryFromGUID<CPed>(PedIndex);
if (pPed)
{
return pPed->GetMotionData()->GetIsSprinting();
}
return false;
}
bool CommandPedIsStrafing(int PedIndex)
{
const CPed* pPed = CTheScripts::GetEntityToQueryFromGUID<CPed>(PedIndex);
if (pPed)
{
return pPed->GetMotionData()->GetIsStrafing();
}
return false;
}
/////////////////////////////////////////////////
// Start the sweep task and point at an entity
/////////////////////////////////////////////////
void CommandTaskSweepAimEntity(int PedIndex, const char* pAnimDictName, const char* pLowAnimName, const char* pMedAnimName, const char* pHiAnimName, int runTime, int TargetEntityIndex, float turnRate, float fBlendInDuration)
{
const CEntity *pEntity = CTheScripts::GetEntityToQueryFromGUID<CEntity>(TargetEntityIndex);
if( pEntity )
{
int clipDictId = fwAnimManager::FindSlot(strStreamingObjectName(pAnimDictName)).Get();
fwMvClipId lowClipId(pLowAnimName);
fwMvClipId medClipId(pMedAnimName);
fwMvClipId highClipId(pHiAnimName);
aiTask *pTask = rage_new CTaskGeneralSweep(clipDictId, lowClipId, medClipId, highClipId, runTime, pEntity, turnRate, fBlendInDuration);
CScriptPeds::GivePedScriptedTask(PedIndex, pTask, SCRIPT_TASK_GENERAL_SWEEP, "TASK_GENERAL_SWEEP");
}
}
// Update the sweep task and point at an entity
void CommandUpdateTaskSweepAimEntity(int PedIndex, int TargetEntityIndex)
{
CPed* pPed = CTheScripts::GetEntityToModifyFromGUID<CPed>(PedIndex);
if(pPed)
{
// Check if the task is running
CTask* pTask = pPed->GetPedIntelligence()->FindTaskActiveByType( CTaskTypes::TASK_GENERAL_SWEEP );
if( Verifyf( pTask, "TaskGeneralSweep Isn't running, so cannot be updated!" ) )
{
const CEntity *pEntity = CTheScripts::GetEntityToQueryFromGUID<CEntity>(TargetEntityIndex);
if( Verifyf( pEntity, "Tracking Entity doesn't exist!" ) )
{
static_cast<CTaskGeneralSweep*>(pTask)->SetTrackEntity(pEntity);
}
}
}
}
// Start the sweep task and point at a position
void CommandTaskSweepAimPosition(int PedIndex, const char* pAnimDictName, const char* pLowAnimName, const char* pMedAnimName, const char* pHiAnimName, int runTime, const scrVector & scrVecCoors, float turnRate, float fBlendInDuration)
{
int clipDictId = fwAnimManager::FindSlot(strStreamingObjectName(pAnimDictName)).Get();
fwMvClipId lowClipId(pLowAnimName);
fwMvClipId medClipId(pMedAnimName);
fwMvClipId highClipId(pHiAnimName);
const Vector3 AimCoords = Vector3(scrVecCoors);
aiTask *pTask = rage_new CTaskGeneralSweep(clipDictId, lowClipId, medClipId, highClipId, runTime, &AimCoords, turnRate, fBlendInDuration);
CScriptPeds::GivePedScriptedTask(PedIndex, pTask, SCRIPT_TASK_GENERAL_SWEEP, "TASK_GENERAL_SWEEP");
}
// Update the sweep task and point at a position
void CommandUpdateTaskSweepAimPosition(int PedIndex, const scrVector & scrVecCoors)
{
CPed* pPed = CTheScripts::GetEntityToModifyFromGUID<CPed>(PedIndex);
if(pPed)
{
// Check if the task is running
CTask* pTask = pPed->GetPedIntelligence()->FindTaskActiveByType( CTaskTypes::TASK_GENERAL_SWEEP );
if( Verifyf( pTask, "TaskGeneralSweep Isn't running, so cannot be updated!" ) )
{
const Vector3 AimCoords = Vector3(scrVecCoors);
static_cast<CTaskGeneralSweep*>(pTask)->SetTrackPosition(&AimCoords);
}
}
}
void CommandTaskArrestPed(int CopPedIndex, int CrookPedIndex)
{
scriptDisplayf("CommandTaskArrestPed\n");
CPed *pCopPed = CTheScripts::GetEntityToModifyFromGUID<CPed>(CopPedIndex, 0);
CPed *pCrookPed = CTheScripts::GetEntityToModifyFromGUID<CPed>(CrookPedIndex, CTheScripts::GUID_ASSERT_FLAGS_INCLUDE_CLONES);
SCRIPT_ASSERT(pCrookPed, "TASK_ARREST_PED - You must specify the crook ped!");
if(pCrookPed)
{
if(!pCopPed || !pCopPed->IsAPlayerPed())
{
CTask* pTask = rage_new CTaskArrestPed(pCrookPed);
CScriptPeds::GivePedScriptedTask(CopPedIndex, pTask, SCRIPT_TASK_ARREST_PED, "TASK_ARREST_PED");
}
}
}
bool CommandIsPedRunningArrestTask(int PedIndex)
{
const CPed *pPed = CTheScripts::GetEntityToQueryFromGUID<CPed>(PedIndex);
SCRIPT_ASSERT(pPed, "IS_PED_RUNNING_ARREST_TASK - You must specify the ped!");
if(pPed)
{
CTaskPlayerOnFoot *pTaskPlayerOnFoot = static_cast< CTaskPlayerOnFoot * >(pPed->GetPedIntelligence()->FindTaskByType(CTaskTypes::TASK_PLAYER_ON_FOOT));
if(pTaskPlayerOnFoot)
{
aiTask *pTask = pTaskPlayerOnFoot->GetScriptedTask();
if(pTask && pTask->GetTaskType() == CTaskTypes::TASK_ARREST_PED2)
{
return true;
}
}
CTaskArrestPed2 *pTaskArrestPed2 = static_cast< CTaskArrestPed2 * >(pPed->GetPedIntelligence()->FindTaskByType(CTaskTypes::TASK_ARREST_PED2));
if(pTaskArrestPed2)
{
return true;
}
}
return false;
}
bool CommandIsArrestTypeValid(int CopPedIndex, int CrookPedIndex, int ArrestType)
{
const CPed *pCopPed = CTheScripts::GetEntityToQueryFromGUID<CPed>(CopPedIndex);
SCRIPT_ASSERT(pCopPed, "IS_ARREST_TYPE_VALID - You must specify the cop ped!");
const CPed *pCrookPed = CTheScripts::GetEntityToQueryFromGUID<CPed>(CrookPedIndex);
SCRIPT_ASSERT(pCrookPed, "IS_ARREST_TYPE_VALID - You must specify the crook ped!");
SCRIPT_ASSERT(ArrestType >= 0 && ArrestType < CArrestHelpers::ARREST_COUNT, "IS_ARREST_TYPE_VALID - You must specify a valid ArrestType!");
if(pCopPed && pCrookPed && ArrestType >= 0 && ArrestType < CArrestHelpers::ARREST_COUNT)
{
return CArrestHelpers::IsArrestTypeValid(pCopPed, pCrookPed, ArrestType);
}
return false;
}
bool CommandIsPedBeingArrested(int ENABLE_TASKS_ARREST_CUFFED_ONLY(iPedIndex))
{
#if ENABLE_TASKS_ARREST_CUFFED if (const CPed* pPed = CTheScripts::GetEntityToQueryFromGUID(iPedIndex)) { CTaskCuffed* pTaskCuffed = static_cast<CTaskCuffed*>(pPed->GetPedIntelligence()->FindTaskActiveByType(CTaskTypes::TASK_CUFFED)); return pTaskCuffed && pTaskCuffed->IsBeingCuffed(); } #endif // ENABLE_TASKS_ARREST_CUFFED return false; }
int CommandGetPedArrester(int ENABLE_TASKS_ARREST_CUFFED_ONLY(iPedIndex))
{
#if ENABLE_TASKS_ARREST_CUFFED if (const CPed* pPed = CTheScripts::GetEntityToQueryFromGUID(iPedIndex)) { CTaskCuffed* pTaskCuffed = static_cast<CTaskCuffed*>(pPed->GetPedIntelligence()->FindTaskActiveByType(CTaskTypes::TASK_CUFFED)); if (pTaskCuffed && pTaskCuffed->IsBeingCuffed()) { if (CPed* pCustodianPed = pTaskCuffed->GetArrestPed()) { return CTheScripts::GetGUIDFromEntity(*pCustodianPed); } } } #endif // ENABLE_TASKS_ARREST_CUFFED return 0; }
bool CommandIsPedCuffed(int iPedIndex)
{
if (const CPed* pPed = CTheScripts::GetEntityToQueryFromGUID<CPed>(iPedIndex))
{
// Just check the handcuffed flag rather than checking for the cuffed state,
// as other higher priority states may have bumped it off temporarily.
return pPed->GetPedConfigFlag(CPED_CONFIG_FLAG_IsHandCuffed);
}
return false;
}
int CommandGetPedCustodian(int iPedIndex)
{
if (const CPed* pPed = CTheScripts::GetEntityToQueryFromGUID<CPed>(iPedIndex))
{
if (CPed* pCustodianPed = pPed->GetCustodian())
{
return CTheScripts::GetGUIDFromEntity(*pCustodianPed);
}
}
return 0;
}
bool CommandIsPedBeingUncuffed(int ENABLE_TASKS_ARREST_CUFFED_ONLY(iPedIndex))
{
#if ENABLE_TASKS_ARREST_CUFFED if (const CPed* pPed = CTheScripts::GetEntityToQueryFromGUID(iPedIndex)) { CTaskCuffed* pTaskCuffed = static_cast<CTaskCuffed*>(pPed->GetPedIntelligence()->FindTaskActiveByType(CTaskTypes::TASK_CUFFED)); return pTaskCuffed && pTaskCuffed->IsBeingUncuffed(); } #endif // ENABLE_TASKS_ARREST_CUFFED return false; }
int CommandGetPedUncuffer(int ENABLE_TASKS_ARREST_CUFFED_ONLY(iPedIndex))
{
#if ENABLE_TASKS_ARREST_CUFFED if (const CPed* pPed = CTheScripts::GetEntityToQueryFromGUID(iPedIndex)) { CTaskCuffed* pTaskCuffed = static_cast<CTaskCuffed*>(pPed->GetPedIntelligence()->FindTaskActiveByType(CTaskTypes::TASK_CUFFED)); if (pTaskCuffed && pTaskCuffed->IsBeingUncuffed()) { if (CPed* pCustodianPed = pTaskCuffed->GetArrestPed()) { return CTheScripts::GetGUIDFromEntity(*pCustodianPed); } } } #endif // ENABLE_TASKS_ARREST_CUFFED return 0; }
bool CommandIsPedArresting(int ENABLE_TASKS_ARREST_CUFFED_ONLY(iPedIndex))
{
#if ENABLE_TASKS_ARREST_CUFFED if (const CPed* pPed = CTheScripts::GetEntityToQueryFromGUID(iPedIndex)) { if (CTaskArrest* pTaskArrest = static_cast<CTaskArrest*>(pPed->GetPedIntelligence()->FindTaskActiveByType(CTaskTypes::TASK_ARREST))) { return pTaskArrest->IsArresting(); } } #endif // ENABLE_TASKS_ARREST_CUFFED return false; }
int CommandGetPedArrestingTarget(int ENABLE_TASKS_ARREST_CUFFED_ONLY(iPedIndex))
{
#if ENABLE_TASKS_ARREST_CUFFED if (const CPed* pPed = CTheScripts::GetEntityToQueryFromGUID(iPedIndex)) { if (CTaskArrest* pTaskArrest = static_cast<CTaskArrest*>(pPed->GetPedIntelligence()->FindTaskActiveByType(CTaskTypes::TASK_ARREST))) { if (pTaskArrest->IsArresting()) { if (CPed* pTargetPed = pTaskArrest->GetTargetPed()) { return CTheScripts::GetGUIDFromEntity(*pTargetPed); } } } } #endif // ENABLE_TASKS_ARREST_CUFFED return 0; }
bool CommandIsPedTakingCustody(int ENABLE_TASKS_ARREST_CUFFED_ONLY(iPedIndex))
{
#if ENABLE_TASKS_ARREST_CUFFED if (const CPed* pPed = CTheScripts::GetEntityToQueryFromGUID(iPedIndex)) { if (CTaskArrest* pTaskArrest = static_cast<CTaskArrest*>(pPed->GetPedIntelligence()->FindTaskActiveByType(CTaskTypes::TASK_ARREST))) { return pTaskArrest->IsTakingCustody(); }
}
#endif // ENABLE_TASKS_ARREST_CUFFED return false; }
int CommandGetPedTakingCustodyTarget(int ENABLE_TASKS_ARREST_CUFFED_ONLY(iPedIndex))
{
#if ENABLE_TASKS_ARREST_CUFFED if (const CPed* pPed = CTheScripts::GetEntityToQueryFromGUID(iPedIndex)) { if (CTaskArrest* pTaskArrest = static_cast<CTaskArrest*>(pPed->GetPedIntelligence()->FindTaskActiveByType(CTaskTypes::TASK_ARREST))) { if (pTaskArrest->IsTakingCustody()) { if (CPed* pTargetPed = pTaskArrest->GetTargetPed()) { return CTheScripts::GetGUIDFromEntity(*pTargetPed); } } } } #endif // ENABLE_TASKS_ARREST_CUFFED return 0; }
bool CommandIsPedBeingTakenIntoCustody(int ENABLE_TASKS_ARREST_CUFFED_ONLY(iPedIndex))
{
#if ENABLE_TASKS_ARREST_CUFFED if (const CPed* pPed = CTheScripts::GetEntityToQueryFromGUID(iPedIndex)) { if(!pPed->GetPedConfigFlag(CPED_CONFIG_FLAG_IsInCustody)) { CTaskInCustody* pTaskInCustody = static_cast<CTaskInCustody*>(pPed->GetPedIntelligence()->FindTaskByType(CTaskTypes::TASK_IN_CUSTODY)); if (pTaskInCustody) { //! Ask in custody task. return pTaskInCustody->IsBeingTakenIntoCustody(); } else if(pPed->GetCustodian()) { //! Having a custodian indicates that someone is trying to put you into custody. return true; } } } #endif // ENABLE_TASKS_ARREST_CUFFED return false; }
bool CommandIsPedUncuffing(int ENABLE_TASKS_ARREST_CUFFED_ONLY(iPedIndex))
{
#if ENABLE_TASKS_ARREST_CUFFED if (const CPed* pPed = CTheScripts::GetEntityToQueryFromGUID(iPedIndex)) { if (CTaskArrest* pTaskArrest = static_cast<CTaskArrest*>(pPed->GetPedIntelligence()->FindTaskActiveByType(CTaskTypes::TASK_ARREST))) { return pTaskArrest->IsUnCuffing(); } } #endif // ENABLE_TASKS_ARREST_CUFFED return false; }
int CommandGetPedUncuffingTarget(int ENABLE_TASKS_ARREST_CUFFED_ONLY(iPedIndex))
{
#if ENABLE_TASKS_ARREST_CUFFED if (const CPed* pPed = CTheScripts::GetEntityToQueryFromGUID(iPedIndex)) { if (CTaskArrest* pTaskArrest = static_cast<CTaskArrest*>(pPed->GetPedIntelligence()->FindTaskActiveByType(CTaskTypes::TASK_ARREST))) { if(pTaskArrest->IsUnCuffing()) { if (CPed* pTargetPed = pTaskArrest->GetTargetPed()) { return CTheScripts::GetGUIDFromEntity(*pTargetPed); } } } } #endif // ENABLE_TASKS_ARREST_CUFFED return 0; }
void CommandCuffPed(int iPedIndex)
{
if (CPed* pPed = CTheScripts::GetEntityToModifyFromGUID<CPed>(iPedIndex))
{
if(SCRIPT_VERIFY(!pPed->IsNetworkClone(), "CUFF_PED - Can't cuff cloned ped!"))
{
// Force the ped to be handcuffed immediately
pPed->SetPedConfigFlag(CPED_CONFIG_FLAG_IsHandCuffed, true);
}
}
}
void CommandUncuffPed(int iPedIndex)
{
if (CPed* pPed = CTheScripts::GetEntityToModifyFromGUID<CPed>(iPedIndex))
{
if(SCRIPT_VERIFY(!pPed->IsNetworkClone(), "UNCUFF_PED - Can't remove clone ped from cuffs!"))
{
// Just unset the handcuffed flag, this will kick the ped out of the cuffed task
pPed->SetPedConfigFlag(CPED_CONFIG_FLAG_IsHandCuffed, false);
}
}
}
void CommandTaskTakeCustody(int ENABLE_TASKS_ARREST_CUFFED_ONLY(iCustodianIndex), int ENABLE_TASKS_ARREST_CUFFED_ONLY(iPedIndex))
{
#if ENABLE_TASKS_ARREST_CUFFED if (CPed* pCustodianPed = CTheScripts::GetEntityToModifyFromGUID(iCustodianIndex)) { CPed* pPed = CTheScripts::GetEntityToModifyFromGUID(iPedIndex, 0); if(pPed) { if(SCRIPT_VERIFY(!pPed->IsNetworkClone(), "TASK_TAKE_CUSTODY - Must set on ped owner's, not clone!")) { pPed->SetInCustody(true, pCustodianPed); CTaskInCustody* pTaskInCustody = rage_new CTaskInCustody(pCustodianPed, true); CScriptPeds::GivePedScriptedTask(iPedIndex, pTaskInCustody, SCRIPT_TASK_IN_CUSTODY, "TASK_IN_CUSTODY"); } } } #endif //ENABLE_TASKS_ARREST_CUFFED }
void CommandRemovePedFromCustody(int iPedIndex)
{
if (CPed* pPed = CTheScripts::GetEntityToModifyFromGUID<CPed>(iPedIndex))
{
if(SCRIPT_VERIFY(!pPed->IsNetworkClone(), "REMOVE_PED_FROM_CUSTODY - Can't remove clone ped from custody!"))
{
pPed->SetInCustody(false, NULL);
}
}
}
float CommandGetPedArrestPhase(int ENABLE_TASKS_ARREST_CUFFED_ONLY(iPedIndex))
{
#if ENABLE_TASKS_ARREST_CUFFED if (const CPed* pPed = CTheScripts::GetEntityToQueryFromGUID(iPedIndex)) { //! Arrest Task. CTaskArrest* pTaskArrest = static_cast<CTaskArrest*>(pPed->GetPedIntelligence()->FindTaskActiveByType(CTaskTypes::TASK_ARREST)); if (pTaskArrest) { return pTaskArrest->GetPhase(); } //! Cuffed Task CTaskCuffed* pTaskCuffed = static_cast<CTaskCuffed*>(pPed->GetPedIntelligence()->FindTaskActiveByType(CTaskTypes::TASK_CUFFED)); if (pTaskCuffed) { return pTaskCuffed->GetPhase(); } //! In Custody Task. if(pPed->GetCustodian()) { CTaskArrest* pTaskArrest = static_cast<CTaskArrest*>(pPed->GetCustodian()->GetPedIntelligence()->FindTaskActiveByType(CTaskTypes::TASK_ARREST)); if(pTaskArrest && pTaskArrest->IsTakingCustody()) { return pTaskArrest->GetPhase(); } } } #endif // ENABLE_TASKS_ARREST_CUFFED return 0.0f; }
int CommandGetPedPotentialArrestTarget(int iPedIndex)
{
if (const CPed* pPed = CTheScripts::GetEntityToQueryFromGUID<CPed>(iPedIndex))
{
if (CPed* pTargetPed = pPed->GetArrestTarget())
{
return CTheScripts::GetGUIDFromEntity(*pTargetPed);
}
}
return 0;
}
int CommandGetPedPotentialUncuffTarget(int iPedIndex)
{
if (const CPed* pPed = CTheScripts::GetEntityToQueryFromGUID<CPed>(iPedIndex))
{
if (CPed* pTargetPed = pPed->GetUncuffTarget())
{
return CTheScripts::GetGUIDFromEntity(*pTargetPed);
}
}
return 0;
}
void CommandSetPedCustodyOverrideFollowDistance(int iPedIndex, float fFollowDistance)
{
if (CPed* pPed = CTheScripts::GetEntityToModifyFromGUID<CPed>(iPedIndex))
{
pPed->SetCustodyFollowDistanceOverride(fFollowDistance);
}
}
void CommandWarpIntoLeadersVehicle(int iPedIndex)
{
if (CPed* pPed = CTheScripts::GetEntityToModifyFromGUID<CPed>(iPedIndex))
{
pPed->SetPedConfigFlag(CPED_CONFIG_FLAG_WarpIntoLeadersVehicle, true);
}
}
void CommandTaskVehicleGotoNavmesh(int iPedID, int iVehicleID, const scrVector & scrVecCoors,
float fCruiseSpeed, int iDrivingFlags, float fTargetReached)
{
CVehicle* pVehicle = NULL;
if(SCRIPT_VERIFY(NULL_IN_SCRIPTING_LANGUAGE != iVehicleID, "TASK_VEHICLE_GOTO_NAVMESH - You must specify a vehicle!"))
{
pVehicle = CTheScripts::GetEntityToModifyFromGUID<CVehicle>(iVehicleID);
}
if(!pVehicle)
{
return;
}
sVehicleMissionParams params;
params.m_iDrivingFlags = iDrivingFlags;
if (fCruiseSpeed > 0.0f)
{
params.m_fCruiseSpeed = fCruiseSpeed;
}
else
{
params.m_fCruiseSpeed = 64.0f;
}
Vector3 vTargetPos(scrVecCoors);
params.SetTargetPosition(vTargetPos);
params.m_fTargetArriveDist = fTargetReached;
ASSERT_ONLY(params.IsTargetValid());
CTaskVehicleGoToNavmesh* pNavmeshTask = rage_new CTaskVehicleGoToNavmesh(params);
CTask* pTask = rage_new CTaskControlVehicle(pVehicle, pNavmeshTask);
CScriptPeds::GivePedScriptedTask( iPedID, pTask, SCRIPT_TASK_VEHICLE_GOTO_NAVMESH, "TASK_VEHICLE_GOTO_NAVMESH");
}
void CommandGivePedAgitatedTaskConfront(int iPedID, int iAgitatorPedID)
{
if( SCRIPT_VERIFYF((iPedID != NULL_IN_SCRIPTING_LANGUAGE && iAgitatorPedID != NULL_IN_SCRIPTING_LANGUAGE), "TASK_AGITATED_ACTION_CONFRONT_RESPONSE - iPedID (%i) or iAgitatorPedID(%i) is NULL",iPedID,iAgitatorPedID) )
{
CPed* pTargetPed = CTheScripts::GetEntityToModifyFromGUID<CPed>(iPedID);
if (SCRIPT_VERIFYF((pTargetPed && !pTargetPed->IsAPlayerPed()),"TASK_AGITATED_ACTION_CONFRONT_RESPONSE is trying to give agitated task to a player ped or could not find ped with this ID - %i!", iPedID))
{
CPed* pAgitatorPed = CTheScripts::GetEntityToModifyFromGUID<CPed>(iAgitatorPedID);
if (SCRIPT_VERIFYF(pAgitatorPed,"TASK_AGITATED_ACTION_CONFRONT_RESPONSE could not find agitator ped with this ID - %i", iAgitatorPedID))
{
CTaskConfront* pConfrontTask = rage_new CTaskConfront(pAgitatorPed);
CTask* pTask = rage_new CTaskAgitatedAction(pConfrontTask);
pTargetPed->SetPedConfigFlag(CPED_CONFIG_FLAG_CanBeAgitated, true);
pTargetPed->SetPedConfigFlag(CPED_CONFIG_FLAG_IsAgitated, true);
CTaskAgitated* pAgitatedTask = rage_new CTaskAgitated(pAgitatorPed);
pAgitatedTask->SetStartedFromScript(true);
pTargetPed->GetPedIntelligence()->AddTaskSecondary( pAgitatedTask, PED_TASK_SECONDARY_PARTIAL_ANIM );
CScriptPeds::GivePedScriptedTask( iPedID, pTask, SCRIPT_TASK_AGITATED_ACTION, "TASK_AGITATED_ACTION");
}
}
}
}
/////////////////////////////////////////////////
void SetupScriptCommands()
{
SCR_REGISTER_SECURE(TASK_PAUSE,0x19c58ba8a663b64b, CommandTaskPause );
SCR_REGISTER_SECURE(TASK_STAND_STILL,0x83f5bcfffba26699, CommandTaskStandStill );
SCR_REGISTER_SECURE(TASK_JUMP,0x012983f49702416c, CommandTaskJump );
SCR_REGISTER_SECURE(TASK_COWER,0x402a537158a551bd, CommandTaskCower );
SCR_REGISTER_SECURE(TASK_HANDS_UP,0x3598f95a00026dd8, CommandTaskHandsUp );
SCR_REGISTER_SECURE(UPDATE_TASK_HANDS_UP_DURATION,0x46a203feec0ecef4, CommandUpdateTaskHandsUpDuration );
SCR_REGISTER_UNUSED(TASK_DUCK,0x54b5addaf8a132f7, CommandTaskDuck );
SCR_REGISTER_SECURE(TASK_OPEN_VEHICLE_DOOR,0xf9d446af83e7a624, CommandTaskOpenVehicleDoor );
SCR_REGISTER_SECURE(TASK_ENTER_VEHICLE,0xb486640392ec50bb, CommandTaskEnterVehicle );
SCR_REGISTER_SECURE(TASK_LEAVE_VEHICLE,0x02f1caac7cb77e47, CommandTaskLeaveVehicle );
SCR_REGISTER_UNUSED(TASK_MOUNT_ANIMAL,0x3f0ad0f6b2f34df6, CommandTaskMountAnimal );
SCR_REGISTER_UNUSED(TASK_DISMOUNT_ANIMAL,0xfe2e56c600a68fce, CommandTaskDismountAnimal );
SCR_REGISTER_SECURE(TASK_GET_OFF_BOAT,0x9aef335a2f73e00a, CommandTaskGetOffBoat );
SCR_REGISTER_SECURE(TASK_SKY_DIVE,0x622c61505349f582, CommandTaskSkyDive );
SCR_REGISTER_SECURE(TASK_PARACHUTE,0xb7121915a3797c65, CommandTaskParachute );
SCR_REGISTER_SECURE(TASK_PARACHUTE_TO_TARGET,0xf323d744a727a4a2, CommandTaskParachuteToTarget );
SCR_REGISTER_SECURE(SET_PARACHUTE_TASK_TARGET,0x878fd7e3c8110527, CommandSetParachuteTaskTarget );
SCR_REGISTER_SECURE(SET_PARACHUTE_TASK_THRUST,0x3ca038370f6e3223, CommandSetParachuteTaskThrust );
SCR_REGISTER_UNUSED(SET_PARACHUTE_TASK_TARGET_ENTITY,0x63b1ba4dbcd822ac, CommandSetParachuteTaskTargetEntity );
SCR_REGISTER_UNUSED(TASK_JETPACK,0x23c36cbde291e36c, CommandTaskJetpack );
SCR_REGISTER_UNUSED(TASK_JETPACK_GO_TO_COORD,0x586dae563b9e50c6, CommandTaskJetpackGoToCoord );
SCR_REGISTER_UNUSED(TASK_JETPACK_GO_TO_ENTITY,0x67794f749799bd7d, CommandTaskJetpackGoToEntity );
SCR_REGISTER_UNUSED(TASK_JETPACK_SHOOT_AT_COORD,0x6ebd50cacaab197e, CommandTaskJetpackShootAtCoord );
SCR_REGISTER_UNUSED(TASK_JETPACK_SHOOT_AT_ENTITY,0xa767f2d717d074f9, CommandTaskJetpackShootAtEntity );
SCR_REGISTER_UNUSED(TASK_JETPACK_STOP_SHOOTING,0xafd3096512ccc6cd, CommandTaskJetpackStopShooting );
SCR_REGISTER_SECURE(TASK_RAPPEL_FROM_HELI,0x01ddcf3e0afad31b, CommandTaskRappelFromHeli );
SCR_REGISTER_UNUSED(TASK_DRAG_PED_TO_COORD,0xb269aa2c4e7f407c, CommandTaskDragPedToCoord );
SCR_REGISTER_SECURE(TASK_VEHICLE_DRIVE_TO_COORD,0x3b8f94419979a0b1, CommandTaskVehicleDriveToCoord );
SCR_REGISTER_SECURE(TASK_VEHICLE_DRIVE_TO_COORD_LONGRANGE,0x70d024128ce0c114, CommandTaskVehicleDriveToCoordLongRange);
SCR_REGISTER_SECURE(TASK_VEHICLE_DRIVE_WANDER,0xad6cdbcda713560a, CommandTaskVehicleDriveWander );
SCR_REGISTER_SECURE(TASK_FOLLOW_TO_OFFSET_OF_ENTITY,0x6fce069e4940878c, CommandTaskFollowToOffsetOfEntity );
SCR_REGISTER_UNUSED(TASK_FOLLOW_TO_OFFSET_OF_PICKUP,0x6f91735acae34873, CommandTaskFollowToOffsetOfPickup);
SCR_REGISTER_SECURE(TASK_GO_STRAIGHT_TO_COORD,0x13c3030981ea7c3b, CommandTaskGoStraightToCoord );
SCR_REGISTER_SECURE(TASK_GO_STRAIGHT_TO_COORD_RELATIVE_TO_ENTITY,0xc98e8d7f0d9d4795, CommandTaskGoStraightToCoordRelativeToEntity );
SCR_REGISTER_SECURE(TASK_ACHIEVE_HEADING,0x30e00b59448ab97e, CommandTaskAchieveHeading );
SCR_REGISTER_SECURE(TASK_FLUSH_ROUTE,0x83a64e1fe4669225, CommandFlushRoute );
SCR_REGISTER_SECURE(TASK_EXTEND_ROUTE,0x9d38259cb54342be, CommandExtendRoute );
SCR_REGISTER_SECURE(TASK_FOLLOW_POINT_ROUTE,0x790dea4e63d61baa, CommandTaskFollowPointRoute );
SCR_REGISTER_SECURE(TASK_GO_TO_ENTITY,0xc149e50fbb27dd70, CommandTaskGoToEntity );
SCR_REGISTER_SECURE(TASK_SMART_FLEE_COORD,0x84918839a90c954c, CommandTaskSmartFleeCoord );
SCR_REGISTER_SECURE(TASK_SMART_FLEE_PED,0x7734082b0edb0be0, CommandTaskSmartFleePed );
SCR_REGISTER_UNUSED(TASK_REACT_AND_FLEE_COORD,0x596713d55325f5c9, CommandTaskReactAndFleeCoord );
SCR_REGISTER_SECURE(TASK_REACT_AND_FLEE_PED,0x7a9da0518e81ec15, CommandTaskReactAndFleePed );
SCR_REGISTER_UNUSED(TASK_SHOCKING_EVENT_BACK_AWAY,0xa19ac1e1c0d01b42, CommandTaskShockingEventBackAway );
SCR_REGISTER_UNUSED(TASK_SHOCKING_EVENT_HURRY_AWAY,0x4e742aa861140b96, CommandTaskShockingEventHurryAway );
SCR_REGISTER_SECURE(TASK_SHOCKING_EVENT_REACT,0xb5bc9e2b43334cef, CommandTaskShockingEventReact );
SCR_REGISTER_SECURE(TASK_WANDER_IN_AREA,0x5315f7ac22dc95f1, CommandTaskWanderInArea );
SCR_REGISTER_SECURE(TASK_WANDER_STANDARD,0xd86a0bc9cc0a625a, CommandTaskWanderStandard );
SCR_REGISTER_SECURE(TASK_WANDER_SPECIFIC,0x26f1da9738c260f2, CommandTaskWanderSpecific);
SCR_REGISTER_SECURE(TASK_VEHICLE_PARK,0x5b7af57d366861f2, CommandTaskVehiclePark );
SCR_REGISTER_SECURE(TASK_STEALTH_KILL,0xe2c1d6fa4e5ea991, CommandTaskStealthKill );
SCR_REGISTER_SECURE(TASK_PLANT_BOMB,0xd9ab2b08ce49a043, CommandTaskPlantBomb );
SCR_REGISTER_UNUSED(TASK_SHARK_CIRCLE_COORD,0xfff1232e7a485388, CommandTaskSharkCircleCoord );
SCR_REGISTER_UNUSED(TASK_SHARK_CIRCLE_PED,0xfd4e7488138e4f25, CommandTaskSharkCirclePed );
SCR_REGISTER_SECURE(TASK_FOLLOW_NAV_MESH_TO_COORD,0x7d1424753688ee7a, CommandTaskFollowNavMeshToCoord );
scrThread::RegisterCommand(SCRHASH("TASK_FOLLOW_NAV_MESH_TO_COORD_ADVANCED",0x72f317bc03266125), CommandTaskFollowNavMeshToCoordAdvanced_ScrStruct SCRIPT_DEBUGGING_ONLY(, "TASK_FOLLOW_NAV_MESH_TO_COORD_ADVANCED", __FILE__, scrSignature()));
SCR_REGISTER_SECURE(SET_PED_PATH_CAN_USE_CLIMBOVERS,0xcacf57ad414acc75, CommandSetPedPathCanUseClimbOvers );
SCR_REGISTER_SECURE(SET_PED_PATH_CAN_USE_LADDERS,0x32bb80e6e576379a, CommandSetPedPathCanUseLadders );
SCR_REGISTER_SECURE(SET_PED_PATH_CAN_DROP_FROM_HEIGHT,0x91d9c55e11392690, CommandSetPedPathCanDropFromHeight );
SCR_REGISTER_SECURE(SET_PED_PATH_CLIMB_COST_MODIFIER,0xd0b0e285f00a8b61, CommandSetPedPathClimbCostModifier );
SCR_REGISTER_SECURE(SET_PED_PATH_MAY_ENTER_WATER,0xbe74e997fb714956, CommandSetPedToMayEnterWater );
SCR_REGISTER_SECURE(SET_PED_PATH_PREFER_TO_AVOID_WATER,0x8bb90eda0a7b150e, CommandSetPedPreferToAvoidWater );
SCR_REGISTER_SECURE(SET_PED_PATH_AVOID_FIRE,0x9ef69bf12b6fbcb3, CommandSetPedPathAvoidFire );
SCR_REGISTER_SECURE(SET_GLOBAL_MIN_BIRD_FLIGHT_HEIGHT,0xb133bc406357c5a5, CommandSetGlobalMinBirdFlightHeight );
SCR_REGISTER_SECURE(GET_NAVMESH_ROUTE_DISTANCE_REMAINING,0x9fa616df1ef7172a, CommandGetNavMeshRouteDistanceRemaining );
SCR_REGISTER_SECURE(GET_NAVMESH_ROUTE_RESULT,0xb02b2cd950b6ba04, CommandGetNavMeshRouteResult );
SCR_REGISTER_SECURE(IS_CONTROLLED_VEHICLE_UNABLE_TO_GET_TO_ROAD,0xa8a55d2ba7497f6f, CommandIsControlledVehicleUnableToGetToRoad );
SCR_REGISTER_SECURE(TASK_GO_TO_COORD_ANY_MEANS,0x9603c0ec536c6425, CommandTaskGoToCoordAnyMeans );
SCR_REGISTER_SECURE(TASK_GO_TO_COORD_ANY_MEANS_EXTRA_PARAMS,0x110dedd855267ad4, CommandTaskGoToCoordAnyMeansExtraParams );
SCR_REGISTER_SECURE(TASK_GO_TO_COORD_ANY_MEANS_EXTRA_PARAMS_WITH_CRUISE_SPEED,0xfaaa6a6a67097054, CommandTaskGoToCoordAnyMeansExtraParamsWithCruiseSpeed );
//////////////////////////////////////////////////////////////////////////
//Animation task commands
//////////////////////////////////////////////////////////////////////////
SCR_REGISTER_SECURE(TASK_PLAY_ANIM,0x49d97b076e3590ac, CommandTaskPlayAnim );
SCR_REGISTER_SECURE(TASK_PLAY_ANIM_ADVANCED,0x246c656f8e525dc7, CommandTaskPlayAnimAdvanced );
SCR_REGISTER_SECURE(STOP_ANIM_TASK,0x227b2dd85a708e68, CommandStopAnimTask );
SCR_REGISTER_SECURE(TASK_SCRIPTED_ANIMATION,0x86577f7f045f84c7, CommandTaskScriptedAnimation );
SCR_REGISTER_SECURE(PLAY_ENTITY_SCRIPTED_ANIM,0xc51d165944c64ca6, CommandPlayEntityScriptedAnimation );
SCR_REGISTER_UNUSED(START_ANIM_PLAYBACK,0x8fc2aa42fd9fa172, CommandStartAnimPlayback );
SCR_REGISTER_SECURE(STOP_ANIM_PLAYBACK,0xe3258b995b832e6a, CommandStopAnimPlayback );
SCR_REGISTER_UNUSED(SET_ANIM_CLIP,0xf962040546b0d2d7, CommandTaskClipSetClip );
SCR_REGISTER_SECURE(SET_ANIM_WEIGHT,0xecd4da16b454528f, CommandTaskClipSetBlendWeight );
SCR_REGISTER_UNUSED(SET_ANIM_FILTER,0x979aba5e5d177c74, CommandTaskClipSetFilter );
SCR_REGISTER_SECURE(SET_ANIM_PHASE,0x60f9850ce23ed209, CommandTaskClipSetPhase );
SCR_REGISTER_SECURE(SET_ANIM_RATE,0x1cbf84e41b1bfe92, CommandTaskClipSetRate );
SCR_REGISTER_SECURE(SET_ANIM_LOOPED,0x8bf7b8753e6fadd0, CommandTaskClipSetLooped );
SCR_REGISTER_SECURE(TASK_PLAY_PHONE_GESTURE_ANIMATION,0xb8ea44dc2c77645c, CommandTaskPlayPhoneGestureAnimation );
SCR_REGISTER_SECURE(TASK_STOP_PHONE_GESTURE_ANIMATION,0xfcd42d914e921580, CommandTaskStopPhoneGestureAnimation );
SCR_REGISTER_SECURE(IS_PLAYING_PHONE_GESTURE_ANIM,0x7ce0cfe0533867b0, CommandIsPlayingPhoneGestureAnim );
SCR_REGISTER_SECURE(GET_PHONE_GESTURE_ANIM_CURRENT_TIME,0x198866ca14785166, CommandGetPhoneGestureAnimCurrentTime );
SCR_REGISTER_SECURE(GET_PHONE_GESTURE_ANIM_TOTAL_TIME,0xc20701b83e0998c5, CommandGetPhoneGestureAnimTotalTime );
SCR_REGISTER_SECURE(TASK_VEHICLE_PLAY_ANIM,0x8da8932b29e225ed, CommandVehicleTaskPlayAnim );
SCR_REGISTER_SECURE(TASK_LOOK_AT_COORD,0xe1e1af00ca06a2b7, CommandTaskLookAtCoord );
SCR_REGISTER_SECURE(TASK_LOOK_AT_ENTITY,0xf30f15f203736de4, CommandTaskLookAtEntity );
SCR_REGISTER_SECURE(TASK_CLEAR_LOOK_AT,0xc89ea639a6f338a6, CommandClearLookAt );
SCR_REGISTER_SECURE(OPEN_SEQUENCE_TASK,0xa888f8cc04f25cc8, CommandOpenSequenceTask );
SCR_REGISTER_SECURE(CLOSE_SEQUENCE_TASK,0xc963a45b50851768, CommandCloseSequenceTask );
SCR_REGISTER_SECURE(TASK_PERFORM_SEQUENCE,0x8acada903fcaa42f, CommandTaskPerformSequence );
SCR_REGISTER_SECURE(TASK_PERFORM_SEQUENCE_LOCALLY,0x7bcccccdabd49a93, CommandTaskPerformSequenceLocally );
SCR_REGISTER_SECURE(CLEAR_SEQUENCE_TASK,0x7461d7c5ba953bc7, CommandClearSequenceTask );
SCR_REGISTER_SECURE(SET_SEQUENCE_TO_REPEAT,0x3f2b528df27c8a9f, CommandSetSequenceToRepeat );
SCR_REGISTER_UNUSED(SET_SEQUENCE_PREVENT_MIGRATION,0x6a177d7d156481ae, CommandSetSequencePreventMigration );
SCR_REGISTER_SECURE(GET_SEQUENCE_PROGRESS,0x0829092f169950ab, CommandGetSequenceProgress );
SCR_REGISTER_SECURE(GET_IS_TASK_ACTIVE,0x7f528e84564c4d10, CommandGetIsTaskActive );
SCR_REGISTER_SECURE(GET_SCRIPT_TASK_STATUS,0x174ced88b97c78d9, CommandGetScriptTaskStatus );
SCR_REGISTER_SECURE(GET_ACTIVE_VEHICLE_MISSION_TYPE,0xf9eec73ae0b9c439, CommandGetActiveVehicleMissionType);
SCR_REGISTER_SECURE(TASK_LEAVE_ANY_VEHICLE,0xab7639d658bbccee, CommandTaskLeaveAnyVehicle );
SCR_REGISTER_SECURE(TASK_AIM_GUN_SCRIPTED,0xccf862b807fe3901, CommandTaskAimGunScripted );
SCR_REGISTER_SECURE(TASK_AIM_GUN_SCRIPTED_WITH_TARGET,0x30cd3d58df974a16, CommandTaskAimGunScriptedWithTarget );
SCR_REGISTER_SECURE(UPDATE_TASK_AIM_GUN_SCRIPTED_TARGET,0x20a2aeaf04674323, CommmandUpdateTaskAimGunScriptedTarget );
SCR_REGISTER_SECURE(GET_CLIP_SET_FOR_SCRIPTED_GUN_TASK,0x3943988de42ef74a, CommandGetClipSetForScriptedGunTask );
SCR_REGISTER_UNUSED(SET_ROPE_TRACK_ENTITY_FOR_SCRIPTED_GUN_TASK,0x87ac327b490ecccc, CommandSetRopeTrackEntityForGunTask );
SCR_REGISTER_SECURE(TASK_AIM_GUN_AT_ENTITY,0x636b3584208a6d73, CommandTaskAimGunAtEntity );
SCR_REGISTER_SECURE(TASK_TURN_PED_TO_FACE_ENTITY,0x529d306014d3c29a, CommandTaskTurnPedToFaceEntity );
SCR_REGISTER_SECURE(TASK_AIM_GUN_AT_COORD,0x2ea72cdbfacd9e92, CommandTaskAimGunAtCoord );
SCR_REGISTER_SECURE(TASK_SHOOT_AT_COORD,0xa99ad9dee4794c48, CommandTaskShootAtCoord );
SCR_REGISTER_SECURE(TASK_SHUFFLE_TO_NEXT_VEHICLE_SEAT,0x8625186d3a8ddd7a, CommandTaskShuffleToNextVehicleSeat );
SCR_REGISTER_SECURE(CLEAR_PED_TASKS,0x03a927199a2dfe46, CommandClearPedTasks );
SCR_REGISTER_UNUSED(CLEAR_PED_SCRIPT_TASK_IF_RUNNING_THREAT_RESPONSE_NON_TEMP_TASK,0xf3642376bf6ac7a8, CommandClearPedScriptTaskIfRunningThreatResponseNonTempTask );
SCR_REGISTER_SECURE(CLEAR_PED_SECONDARY_TASK,0xca2872f050840231, CommandClearPedSecondaryTask );
SCR_REGISTER_SECURE(TASK_EVERYONE_LEAVE_VEHICLE,0x417047b1f659225c, CommandTaskEveryoneLeaveVehicle );
SCR_REGISTER_SECURE(TASK_GOTO_ENTITY_OFFSET,0x6624b56c8f9a7bbf, CommandTaskGotoEntityOffset );
SCR_REGISTER_SECURE(TASK_GOTO_ENTITY_OFFSET_XY,0xb17a6034b9f1bcc2, CommandTaskGotoEntityOffsetXY );
SCR_REGISTER_UNUSED(TASK_INVESTIGATE_COORDS,0xb834945c258dac7b, CommandTaskInvestigateCoords);
SCR_REGISTER_SECURE(TASK_TURN_PED_TO_FACE_COORD,0x1a96b8b416bc07d0, CommandTaskTurnPedToFaceCoord );
SCR_REGISTER_UNUSED(TASK_DRIVE_POINT_ROUTE,0x8c4f2dd2f4b46da9, CommandTaskDrivePointRoute );
SCR_REGISTER_SECURE(TASK_VEHICLE_TEMP_ACTION,0xcd41d6f721cb9c3a, CommandTaskVehicleTempAction );
SCR_REGISTER_SECURE(TASK_VEHICLE_MISSION,0xfe5a02cf2178b6a8, CommandTaskVehicleMission );
SCR_REGISTER_SECURE(TASK_VEHICLE_MISSION_PED_TARGET,0xb69d13e19147910f, CommandTaskVehicleMissionPedTarget );
SCR_REGISTER_SECURE(TASK_VEHICLE_MISSION_COORS_TARGET,0xfdb121077308e944, CommandTaskVehicleMissionCoorsTarget );
SCR_REGISTER_UNUSED(IS_PED_INVESTIGATING_WHISTLING_EVENT,0x7fd44d022e2a2e07, CommandIsPedInvestigatingWhistlingEvent );
SCR_REGISTER_UNUSED(SET_INVESTIGATION_POSITION,0x00f6e31f2f0528cc, CommandSetInvestigationPosition );
SCR_REGISTER_SECURE(TASK_VEHICLE_ESCORT,0xdbee353c7ca6e88e, CommandTaskVehicleEscort );
SCR_REGISTER_SECURE(TASK_VEHICLE_FOLLOW,0xbb97101b3b2dbef5, CommandTaskVehicleFollow );
SCR_REGISTER_SECURE(TASK_VEHICLE_CHASE,0x9286a110a3fd81f1, CommandTaskVehicleChase );
SCR_REGISTER_SECURE(TASK_VEHICLE_HELI_PROTECT,0x69ac7dd318a3e1ba, CommandTaskHeliProtect );
SCR_REGISTER_SECURE(SET_TASK_VEHICLE_CHASE_BEHAVIOR_FLAG,0xc8d0b0d2cfd76bb5, CommandSetTaskVehicleChaseBehaviorFlag );
SCR_REGISTER_SECURE(SET_TASK_VEHICLE_CHASE_IDEAL_PURSUIT_DISTANCE,0xdfad0df477fd9eb3, CommandSetTaskVehicleChaseIdealPursuitDistance);
SCR_REGISTER_SECURE(TASK_HELI_CHASE,0x42935fa7528ffce8, CommandTaskHeliChase );
SCR_REGISTER_UNUSED(SET_TASK_HELI_CHASE_TARGET_OFFSET,0x4caff843df59d524, CommandSetTaskHeliChaseTargetOffset );
SCR_REGISTER_UNUSED(SET_TASK_HELI_CHASE_TARGET_OFFSET_WORLD_SPACE,0x8d6ba126f7ac98e4, CommandSetTaskHeliChaseTargetOffsetWorldSpace );
SCR_REGISTER_UNUSED(SET_TASK_HELI_CHASE_ORIENTATION,0xe97d050a690da21c, CommandSetTaskHeliChaseOrientation );
SCR_REGISTER_SECURE(TASK_PLANE_CHASE,0xe8f8c382b0eb7478, CommandTaskPlaneChase );
SCR_REGISTER_SECURE(TASK_PLANE_LAND,0x214f418bf9481244, CommandTaskPlaneLand );
SCR_REGISTER_SECURE(CLEAR_DEFAULT_PRIMARY_TASK,0xeb6fbc20375e72c2, CommandClearDefaultPrimaryTask );
SCR_REGISTER_SECURE(CLEAR_PRIMARY_VEHICLE_TASK,0xe4a094de05c0210c, CommandClearPrimaryVehicleTask );
SCR_REGISTER_SECURE(CLEAR_VEHICLE_CRASH_TASK,0x273bc6472375634c, CommandClearVehicleCrashTask );
SCR_REGISTER_SECURE(TASK_PLANE_GOTO_PRECISE_VTOL,0xce661a3c8cf58b44, CommandTaskPlaneGotoPreciseVtol );
SCR_REGISTER_SECURE(TASK_SUBMARINE_GOTO_AND_STOP,0x835cbdb247b09c67, CommandTaskSubmarineGotoAndStop );
SCR_REGISTER_SECURE(TASK_HELI_MISSION,0x545c59578966d5b8, CommandTaskHeliMission );
SCR_REGISTER_SECURE(TASK_HELI_ESCORT_HELI,0x53a1d75e294fdb30, CommandTaskHeliEscort );
SCR_REGISTER_SECURE(TASK_PLANE_MISSION,0xcdaacb23d43f080d, CommandTaskPlaneMission );
SCR_REGISTER_SECURE(TASK_PLANE_TAXI,0x908b77e6d8aa83d8, CommandTaskPlaneTaxi );
SCR_REGISTER_SECURE(TASK_BOAT_MISSION,0xc5a824d6ee9c9cd3, CommandTaskBoatMission );
SCR_REGISTER_UNUSED(TASK_WEAPON_ROLL, 0x123b2716, CommandTaskWeaponRoll );
SCR_REGISTER_SECURE(TASK_DRIVE_BY,0x0e6c3a4efa9d9d35, CommandTaskDriveBy );
SCR_REGISTER_SECURE(SET_DRIVEBY_TASK_TARGET,0x8217f7dfe30383b0, CommandSetDriveByTarget );
SCR_REGISTER_SECURE(CLEAR_DRIVEBY_TASK_UNDERNEATH_DRIVING_TASK,0xd639b91d6baf25c6, CommandClearDrivebyTaskUnderneathDrivingTask);
SCR_REGISTER_SECURE(IS_DRIVEBY_TASK_UNDERNEATH_DRIVING_TASK,0x99d3be8c39ba34ff, CommandIsDrivebyTaskUnderneathDrivingTask);
SCR_REGISTER_SECURE(CONTROL_MOUNTED_WEAPON,0xb604014eee3ca5f8, CommandControlMountedWeapon );
SCR_REGISTER_SECURE(SET_MOUNTED_WEAPON_TARGET,0x748e7aee8deb2a3a, CommandSetMountedWeaponTarget );
SCR_REGISTER_UNUSED(CLEAR_MOUNTED_WEAPON_TASK_UNDERNEATH_DRIVING_TASK,0xf4dedafc0c550318, CommandClearMountedWeaponTaskUnderneathDrivingTask);
SCR_REGISTER_SECURE(IS_MOUNTED_WEAPON_TASK_UNDERNEATH_DRIVING_TASK,0xcb8e14dc7871f52c, CommandIsMountedWeaponTaskUnderneathDrivingTask);
SCR_REGISTER_SECURE(TASK_USE_MOBILE_PHONE,0x57caa5fbf134d4ae, CommandTaskUseMobilePhone );
SCR_REGISTER_SECURE(TASK_USE_MOBILE_PHONE_TIMED,0x9bd5d84c8c3f0b2c, CommandTaskUseMobilePhoneTimed );
SCR_REGISTER_UNUSED(TASK_USE_WALKIE_TALKIE,0x46f7b490eb75e92c, CommandTaskUseWalkieTalkie );
SCR_REGISTER_SECURE(TASK_CHAT_TO_PED,0x2966111306fa6611, CommandTaskChatToPed );
SCR_REGISTER_UNUSED(IS_CHATTING_PED_IN_POSITION,0xd701a91d13919148, CommandIsChattingPedInPosition );
SCR_REGISTER_UNUSED(IS_CHATTING_PED_PLAYING_ANIM,0xae8fabcda3959d22, CommandIsChattingPedPlayingAnim );
SCR_REGISTER_UNUSED(MAKE_CHATTING_PED_PLAY_ANIM,0x3f4bfc1622d674be, CommandMakeChattingPedPlayAnim );
SCR_REGISTER_UNUSED(MAKE_CHATTING_PED_LEAVE,0x9dfbb232fdaa2244, CommandMakeChattingPedLeave );
SCR_REGISTER_UNUSED(ADD_FOLLOW_NAVMESH_TO_PHONE_TASK,0xe12df85ba18a27f8, CommandAddFollowNavmeshToPhoneTask );
SCR_REGISTER_UNUSED(GET_MOBILE_PHONE_TASK_SUB_TASK,0xeb6576b40ae232f5, CommandGetMobilePhoneTaskSubTask );
SCR_REGISTER_SECURE(TASK_WARP_PED_INTO_VEHICLE,0x73a521eac1ef5c1b, CommandTaskWarpPedIntoVehicle );
SCR_REGISTER_SECURE(TASK_SHOOT_AT_ENTITY,0x913e191f1f726271, CommandTaskShootAtEntity );
SCR_REGISTER_SECURE(TASK_CLIMB,0x893ddd76cc7c67b1, CommandTaskClimb );
SCR_REGISTER_SECURE(TASK_CLIMB_LADDER,0x12425bd281be5f3c, CommandTaskClimbLadder );
SCR_REGISTER_UNUSED(TASK_RAPPEL_DOWN_WALL,0x42ee24d502e263b3, CommandTaskRappelDownWall );
SCR_REGISTER_SECURE(TASK_RAPPEL_DOWN_WALL_USING_CLIPSET_OVERRIDE,0x80f9b0598b0c9c85, CommandTaskRappelDownWallUsingClipsetOverride);
SCR_REGISTER_SECURE(GET_TASK_RAPPEL_DOWN_WALL_STATE,0xa0584425edd6ec9d, CommandsGetTaskRappelDownWallState );
SCR_REGISTER_SECURE(CLEAR_PED_TASKS_IMMEDIATELY,0x51bb443b279e4104, CommandClearPedTasksImmediately );
SCR_REGISTER_SECURE(TASK_PERFORM_SEQUENCE_FROM_PROGRESS,0x23378ce912d5b544, CommandTaskPerformSequenceFromProgress );
SCR_REGISTER_SECURE(SET_NEXT_DESIRED_MOVE_STATE,0x8ff5f2b541a0e471, CommandSetNextDesiredMoveState );
SCR_REGISTER_SECURE(SET_PED_DESIRED_MOVE_BLEND_RATIO,0x98f7e0916b6b5a0b, CommandSetPedDesiredMoveBlendRatio );
SCR_REGISTER_SECURE(GET_PED_DESIRED_MOVE_BLEND_RATIO,0x5e9b3bbf63a5e2f6, CommandGetPedDesiredMoveBlendRatio );
SCR_REGISTER_SECURE(TASK_GOTO_ENTITY_AIMING,0x27c6152f3e5f2933, CommandTaskGotoEntityAiming );
SCR_REGISTER_SECURE(TASK_SET_DECISION_MAKER,0xd029ba670c8df65b, CommandTaskSetDecisionMaker );
SCR_REGISTER_SECURE(TASK_SET_SPHERE_DEFENSIVE_AREA,0x223133feb94059cd, CommandTaskSetSphereDefensiveArea );
SCR_REGISTER_SECURE(TASK_CLEAR_DEFENSIVE_AREA,0x4b16afbb0c12b630, CommandTaskClearDefensiveArea );
SCR_REGISTER_SECURE(TASK_PED_SLIDE_TO_COORD,0xed2842d9cc50eb6e, CommandTaskPedSlideToCoord );
SCR_REGISTER_UNUSED(TASK_PED_SLIDE_TO_COORD_AND_PLAY_ANIM,0x93a741ed3ed7f56f, CommandTaskPedSlideToCoordAndPlayAnim );
SCR_REGISTER_UNUSED(TASK_PED_SLIDE_TO_COORD_AND_PLAY_ANIM_HDG_RATE, 0x95abc676, CommandTaskPedSlideToCoordAndPlayAnimWithHeadingChangeRate );
SCR_REGISTER_SECURE(TASK_PED_SLIDE_TO_COORD_HDG_RATE,0xd6711eee6b632dae, CommandTaskPedSlideToCoordWithHeadingChangeRate );
SCR_REGISTER_UNUSED(TASK_DRIVE_POINT_ROUTE_ADVANCED,0x730dad3cf7f02fa7, CommandTaskDrivePointRouteAdvanced );
// Combat and cover
SCR_REGISTER_SECURE(ADD_COVER_POINT,0x41ba9dba367c9c12, CommandAddCoverPoint );
SCR_REGISTER_SECURE(REMOVE_COVER_POINT,0x5990dad3727a1b45, CommandRemoveCoverPoint );
SCR_REGISTER_SECURE(DOES_SCRIPTED_COVER_POINT_EXIST_AT_COORDS,0x7fd113b09d96c678, CommandDoesScriptedCoverPointExistAtCoords );
SCR_REGISTER_SECURE(GET_SCRIPTED_COVER_POINT_COORDS,0x137fb6fc6e40a0a8, CommandGetScriptedCoverPointCoords );
SCR_REGISTER_SECURE(ADD_SCRIPTED_COVER_AREA, 0x28b7b9bfdaf274aa, CommandAddScriptedCoverArea);
//SCR_REGISTER_UNUSED(GET_SCRIPTED_COVER_POINT_STATUS, 0x56c9de8d, CommandGetScriptedCoverPointStatus );
SCR_REGISTER_SECURE(TASK_COMBAT_PED,0xc1a74225341aa9fb, CommandTaskCombat );
SCR_REGISTER_SECURE(TASK_COMBAT_PED_TIMED,0x5fc4a511155d6f9a, CommandTaskCombatTimed );
SCR_REGISTER_SECURE(TASK_SEEK_COVER_FROM_POS,0x3f58924930345d8d, CommandTaskSeekCoverFromPos );
SCR_REGISTER_SECURE(TASK_SEEK_COVER_FROM_PED,0xb67d1d267c666dc4, CommandTaskSeekCoverFromPed );
SCR_REGISTER_SECURE(TASK_SEEK_COVER_TO_COVER_POINT,0x419e449559bf60b4, CommandTaskSeekCoverToCoverPoint );
SCR_REGISTER_SECURE(TASK_SEEK_COVER_TO_COORDS,0x264cd1b504831626, CommandTaskSeekCoverToCoords );
SCR_REGISTER_SECURE(TASK_PUT_PED_DIRECTLY_INTO_COVER,0x809dfa39515d5981, CommandTaskPutPedDirectlyIntoCover );
SCR_REGISTER_UNUSED(TASK_PUT_PED_DIRECTLY_INTO_COVER_FROM_TARGET,0x9f8e54193d416a78, CommandTaskPutPedDirectlyIntoCoverFromTarget );
SCR_REGISTER_SECURE(TASK_WARP_PED_DIRECTLY_INTO_COVER,0x6e01e9e8d89f8276, CommandTaskWarpPedDirectlyIntoCover);
SCR_REGISTER_UNUSED(SET_COVER_TASK_TARGET,0x778c4e702f2a65e5, CommandSetCoverTarget );
SCR_REGISTER_SECURE(TASK_EXIT_COVER,0x412ed6ee0b28c20d, CommandTaskExitCover );
SCR_REGISTER_SECURE(TASK_PUT_PED_DIRECTLY_INTO_MELEE,0x957211dc68d2869f, CommandTaskPutPedDirectlyIntoMelee );
SCR_REGISTER_UNUSED(TASK_ADVANCE_TO_TARGET_IN_LINE,0xd9c691ad25d0d5eb, CommandTaskAdvanceToTargetInLine );
SCR_REGISTER_UNUSED(SET_CHARGE_TARGET_ENABLED,0x9dea9d830bfc9937, CommandSetChargeTargetEnabled );
SCR_REGISTER_UNUSED(SET_MAX_NUM_ACTIVE_CHARGERS,0xa2d85c968ea44e3d, CommandSetMaxNumActiveChargers );
SCR_REGISTER_UNUSED(SET_MIN_TIME_BETWEEN_CHARGES_AT_SAME_TARGET,0xfbb868ae331debcd, CommandSetMinTimeBetweenChargesAtSameTarget );
SCR_REGISTER_SECURE(TASK_TOGGLE_DUCK,0xa5af895dd224fdc0, CommandTaskToggleDuck );
SCR_REGISTER_SECURE(TASK_GUARD_CURRENT_POSITION,0x274a180d57a0d9a6, CommandTaskGuardCurrentPosition );
SCR_REGISTER_SECURE(TASK_GUARD_ASSIGNED_DEFENSIVE_AREA,0x4182d960e26d40bb, CommandTaskGuardAssignedDefensiveArea );
SCR_REGISTER_UNUSED(TASK_GUARD_ANGLED_DEFENSIVE_AREA,0xf035a69189e11b7a, CommandTaskGuardAngledDefensiveArea );
SCR_REGISTER_SECURE(TASK_GUARD_SPHERE_DEFENSIVE_AREA,0x061a42ebc9ceb366, CommandTaskGuardSphereDefensiveArea );
SCR_REGISTER_SECURE(TASK_STAND_GUARD,0x4b551665e9b2e8f6, CommandTaskStandGuard );
SCR_REGISTER_SECURE(SET_DRIVE_TASK_CRUISE_SPEED,0xbb3480bb855cdb33, CommandSetDriveTaskCruiseSpeed );
SCR_REGISTER_SECURE(SET_DRIVE_TASK_MAX_CRUISE_SPEED,0x3d2ebac0a745e60c, CommandSetDriveTaskMaxCruiseSpeed );
SCR_REGISTER_SECURE(SET_DRIVE_TASK_DRIVING_STYLE,0x27be5555cdf6f983, CommandSetDriveTaskDrivingStyle );
SCR_REGISTER_UNUSED(SET_PURSUE_TASK_IDEAL_DISTANCE,0x971919670679e003, CommandSetPursueTaskIdealDistance );
SCR_REGISTER_SECURE(ADD_COVER_BLOCKING_AREA,0x5af3192f3c3d45ec, CommandAddCoverBlockingArea );
SCR_REGISTER_SECURE(REMOVE_ALL_COVER_BLOCKING_AREAS,0x71fcd88fc7f98621, CommandFlushCoverBlockingAreas );
SCR_REGISTER_SECURE(REMOVE_COVER_BLOCKING_AREAS_AT_POSITION,0xac7ab29fe3c36266, CommandRemoveCoverBlockingAreasAtPosition );
SCR_REGISTER_SECURE(REMOVE_SPECIFIC_COVER_BLOCKING_AREAS,0xaa443863046f380a, CommandRemoveSpecificCoverBlockingAreas);
SCR_REGISTER_SECURE(TASK_START_SCENARIO_IN_PLACE,0xc9fefb406c44f60b, CommandTaskStartScenarioInPlace );
SCR_REGISTER_SECURE(TASK_START_SCENARIO_AT_POSITION,0xdb4f67aafbf32aa5, CommandTaskStartScenarioAtPosition );
SCR_REGISTER_UNUSED(TASK_START_VEHICLE_SCENARIO,0xbfb160b082e439fa, CommandTaskStartVehicleScenario );
SCR_REGISTER_SECURE(TASK_USE_NEAREST_SCENARIO_TO_COORD,0x1d698ecdff42ac58, CommandTaskUseNearestScenarioToPos );
SCR_REGISTER_SECURE(TASK_USE_NEAREST_SCENARIO_TO_COORD_WARP,0x8ceb5d8b56025aa2, CommandTaskUseNearestScenarioToPosWarp );
SCR_REGISTER_UNUSED(TASK_USE_NEAREST_TRAIN_SCENARIO_TO_COORD_WARP,0x97deba5039a7f6c7, CommandTaskUseNearestTrainScenarioToPosWarp);
SCR_REGISTER_SECURE(TASK_USE_NEAREST_SCENARIO_CHAIN_TO_COORD,0xaf0492886bc6c105, CommandTaskUseNearestScenarioChainToPos );
SCR_REGISTER_SECURE(TASK_USE_NEAREST_SCENARIO_CHAIN_TO_COORD_WARP,0x6d44636281842060, CommandTaskUseNearestScenarioChainToPosWarp );
SCR_REGISTER_SECURE(DOES_SCENARIO_EXIST_IN_AREA,0x5b138084858689ac, CommandDoesScenarioExistInArea );
SCR_REGISTER_SECURE(DOES_SCENARIO_OF_TYPE_EXIST_IN_AREA,0x48d8c2729764de01, CommandDoesScenarioOfTypeExistInArea);
SCR_REGISTER_SECURE(IS_SCENARIO_OCCUPIED,0xc85b76c87214bd87, CommandIsScenarioOccupied );
SCR_REGISTER_SECURE(PED_HAS_USE_SCENARIO_TASK,0x23bf8abbc9594609, CommandPedHasUseScenarioTask );
SCR_REGISTER_UNUSED(OVERRIDE_TASKED_SCENARIO_BASE_ANIM,0xdd7e39f6a9fa3ce0, CommandOverrideTaskedScenarioBaseAnim );
SCR_REGISTER_SECURE(PLAY_ANIM_ON_RUNNING_SCENARIO,0x8b90895f7d0bee59, CommandPlayAnimOnRunnningScenario );
SCR_REGISTER_SECURE(DOES_SCENARIO_GROUP_EXIST,0x1e63be2394148da0, CommandDoesScenarioGroupExist );
SCR_REGISTER_SECURE(IS_SCENARIO_GROUP_ENABLED,0x96a05000ccd43584, CommandIsScenarioGroupEnabled );
SCR_REGISTER_SECURE(SET_SCENARIO_GROUP_ENABLED,0xa3d2c191df3cb742, CommandSetScenarioGroupEnabled );
SCR_REGISTER_SECURE(RESET_SCENARIO_GROUPS_ENABLED,0xb750df5029a6790a, CommandResetScenarioGroupsEnabled );
SCR_REGISTER_SECURE(SET_EXCLUSIVE_SCENARIO_GROUP,0xedf1af96b1a92325, CommandSetExclusiveScenarioGroup );
SCR_REGISTER_SECURE(RESET_EXCLUSIVE_SCENARIO_GROUP,0xa7fee431b0d22e80, CommandResetExclusiveScenarioGroup );
SCR_REGISTER_UNUSED(FORCE_SCENARIO_GROUP_PRIORITY,0xb2a385f314986d7d, CommandForceScenarioGroupPriority );
SCR_REGISTER_UNUSED(RESET_SCENARIO_GROUPS_PRIORITY,0xf842c44cfffb8884, CommandResetScenarioGroupsPriority );
SCR_REGISTER_SECURE(IS_SCENARIO_TYPE_ENABLED,0xaec3fb024079cf27, CommandIsScenarioTypeEnabled );
SCR_REGISTER_SECURE(SET_SCENARIO_TYPE_ENABLED,0x247f21b1803f0ec4, CommandSetScenarioTypeEnabled );
SCR_REGISTER_SECURE(RESET_SCENARIO_TYPES_ENABLED,0xa9fc42dea687033d, CommandResetScenarioTypesEnabled );
SCR_REGISTER_UNUSED(SUPPRESS_NORMAL_SCENARIO_EXITS_NEXT_FRAME,0x462559c9bfdb51d1, CommandSuppressNormalScenarioExitsNextFrame);
SCR_REGISTER_UNUSED(SUPPRESS_SCENARIO_ATTRACTION_NEXT_FRAME,0xf50d4dd468864fca, CommandSuppressScenarioAttractionNextFrame);
SCR_REGISTER_UNUSED(SUPPRESS_BREAKOUT_SCENARIO_EXITS_NEXT_FRAME,0x743ef6f4b8c462a8,CommandSuppressBreakoutScenarioExitsNextFrame);
SCR_REGISTER_SECURE(IS_PED_ACTIVE_IN_SCENARIO,0x67360b9474054c5e, CommandIsPedActiveInScenario );
SCR_REGISTER_SECURE(IS_PED_PLAYING_BASE_CLIP_IN_SCENARIO,0x2dc1bc483b6a3316, CommandIsPedPlayingBaseClipInScenario );
SCR_REGISTER_SECURE(SET_PED_CAN_PLAY_AMBIENT_IDLES,0xe72d9eb9db4b874d, CommandSetCanPlayAmbientIdles );
SCR_REGISTER_SECURE(TASK_COMBAT_HATED_TARGETS_IN_AREA,0xe45039a194d735de, CommandTaskCombatHatedTargetsInArea );
SCR_REGISTER_SECURE(TASK_COMBAT_HATED_TARGETS_AROUND_PED,0x766d377a16f499e3, CommandTaskCombatHatedTargetsAroundPed );
SCR_REGISTER_SECURE(TASK_COMBAT_HATED_TARGETS_AROUND_PED_TIMED,0x34ad04c1e7cb67d8, CommandTaskCombatHatedTargetsAroundPedTimed );
SCR_REGISTER_SECURE(TASK_THROW_PROJECTILE,0xa43ab969c8956eb8, CommandTaskThrowProjectile );
SCR_REGISTER_SECURE(TASK_SWAP_WEAPON,0xd4834169f570e6d2, CommandTaskSwapWeapon );
SCR_REGISTER_SECURE(TASK_RELOAD_WEAPON,0x62f1ebed7a072b40, CommandTaskReloadWeapon );
SCR_REGISTER_UNUSED(TASK_COMBAT_ROLL,0x8eddf98bab0a7bc9, CommandTaskCombatRoll );
SCR_REGISTER_SECURE(IS_PED_GETTING_UP,0x03454821a9ecf4aa, CommandIsPedGettingUp );
SCR_REGISTER_SECURE(TASK_WRITHE,0x99e9c3c2d6af9a52, CommandTaskWrithe );
SCR_REGISTER_SECURE(IS_PED_IN_WRITHE,0x645f244ecddef6cf, CommandIsPedInWrithe );
SCR_REGISTER_SECURE(OPEN_PATROL_ROUTE,0x9d3e7062e40f2049, CommandOpenPatrolRoute );
SCR_REGISTER_SECURE(CLOSE_PATROL_ROUTE,0xc65dee4d8f9f02eb, CommandClosePatrolRoute );
SCR_REGISTER_SECURE(ADD_PATROL_ROUTE_NODE,0xad84831de60c1442, CommandAddPatrolNode );
SCR_REGISTER_SECURE(ADD_PATROL_ROUTE_LINK,0x23c767cf5993cf13, CommandAddPatrolNodeLink );
SCR_REGISTER_SECURE(CREATE_PATROL_ROUTE,0x274f700901c096dd, CommandCreatePatrolRoute );
SCR_REGISTER_SECURE(DELETE_PATROL_ROUTE,0x6bd70dca1fdc1c56, CommandDeletePatrolRoute );
SCR_REGISTER_SECURE(GET_PATROL_TASK_INFO,0x52f734cebe20dfba, CommandGetPatrolNodeInfo );
SCR_REGISTER_SECURE(TASK_PATROL,0xac81ed4a4f2fec9c, CommandTaskPatrol );
SCR_REGISTER_SECURE(TASK_STAY_IN_COVER,0xf21f1b3825b46822, CommandTaskStayInCover );
SCR_REGISTER_SECURE(ADD_VEHICLE_SUBTASK_ATTACK_COORD,0xf2e8f4bd20869ab2, CommandAddVehicleSubtaskAttackCoord );
SCR_REGISTER_SECURE(ADD_VEHICLE_SUBTASK_ATTACK_PED,0x80e8bfe6e62212c1, CommandAddVehicleSubtaskAttackPed );
SCR_REGISTER_SECURE(TASK_VEHICLE_SHOOT_AT_PED,0xbba695ad5315cdd8, CommandVehicleShootAtPed );
SCR_REGISTER_SECURE(TASK_VEHICLE_AIM_AT_PED,0xc514d16960a4fa43, CommandVehicleAimAtPed );
SCR_REGISTER_SECURE(TASK_VEHICLE_SHOOT_AT_COORD,0xe5d96c43ab0b0dc6, CommandVehicleShootAtCoord );
SCR_REGISTER_SECURE(TASK_VEHICLE_AIM_AT_COORD,0x7d49955a299139e9, CommandVehicleAimAtCoord );
SCR_REGISTER_UNUSED(TASK_VEHICLE_AIM_USING_CAMERA,0x6614a146419eb189, CommandVehicleAimUsingCamera );
SCR_REGISTER_UNUSED(TASK_HANG_GLIDER,0xbdbadc2ff688e5b2, CommandTaskHangGlider );
SCR_REGISTER_UNUSED(SET_HANG_GLIDER_AIR_SPEED,0x23b2c655efd82c53, CommandSetHangGliderAirSpeed );
SCR_REGISTER_SECURE(TASK_VEHICLE_GOTO_NAVMESH,0xdf44785f7bc09dd2, CommandTaskVehicleGotoNavmesh );
SCR_REGISTER_SECURE(TASK_GO_TO_COORD_WHILE_AIMING_AT_COORD,0x642c58f4ca259448, CommandTaskGoToCoordWhileAimingAtCoord );
SCR_REGISTER_SECURE(TASK_GO_TO_COORD_WHILE_AIMING_AT_ENTITY,0x98db2abd53b8d70b, CommandTaskGoToCoordWhileAimingAtEntity );
SCR_REGISTER_SECURE(TASK_GO_TO_COORD_AND_AIM_AT_HATED_ENTITIES_NEAR_COORD,0x2a83cd9941ec44d0, CommandTaskGoToCoordAndAimAtHatedEntitiesNearCoord);
SCR_REGISTER_SECURE(TASK_GO_TO_ENTITY_WHILE_AIMING_AT_COORD,0x60fad147bb45a92a, CommandTaskGoToEntityWhileAimingAtCoord );
SCR_REGISTER_SECURE(TASK_GO_TO_ENTITY_WHILE_AIMING_AT_ENTITY,0x0b47872e9d74882c, CommandTaskGoToEntityWhileAimingAtEntity);
SCR_REGISTER_UNUSED(TASK_BIND_POSE,0xac5fea0754bcc7cf, CommandTaskBindPose );
SCR_REGISTER_UNUSED(ELECTROCUTE_PED,0x9eebf0c360e75bef, CommandElectrocute );
SCR_REGISTER_SECURE(SET_HIGH_FALL_TASK,0xdb1174c6546afc65, CommandHighFall );
SCR_REGISTER_UNUSED(DANGLE_FROM_MEATHOOK,0xd9c1a873ff69a447, CommandDangleFromMeathook );
SCR_REGISTER_UNUSED(SLUNG_OVER_SHOULDER,0xcbdd75b6dfb92714, CommandSlungOverShoulder );
SCR_REGISTER_UNUSED(MAKE_PED_STUMBLE,0x6b0ebf2507baba30, CommandStumble );
SCR_REGISTER_SECURE(REQUEST_WAYPOINT_RECORDING,0x70f260358d1a42c4, waypoint_commands::CommandRequestWaypointRecording );
SCR_REGISTER_SECURE(GET_IS_WAYPOINT_RECORDING_LOADED,0xbd3cea9cd36e271e, waypoint_commands::CommandGetIsWaypointRecordingLoaded );
SCR_REGISTER_SECURE(REMOVE_WAYPOINT_RECORDING,0x10f7bfe3a88cb99b, waypoint_commands::CommandRemoveWaypointRecording );
SCR_REGISTER_SECURE(WAYPOINT_RECORDING_GET_NUM_POINTS,0x042959494b85e155, waypoint_commands::CommandWaypointRecordingGetNumPoints );
SCR_REGISTER_SECURE(WAYPOINT_RECORDING_GET_COORD,0x76263b6f2b150aff, waypoint_commands::CommandWaypointRecordingGetCoord );
SCR_REGISTER_SECURE(WAYPOINT_RECORDING_GET_SPEED_AT_POINT,0xaa4b93a8c0d05be3, waypoint_commands::CommandWaypointRecordingGetSpeedAtPoint);
SCR_REGISTER_SECURE(WAYPOINT_RECORDING_GET_CLOSEST_WAYPOINT,0xe49fae8c75dfe3b0, waypoint_commands::CommandWaypointRecordingGetClosestWaypoint );
SCR_REGISTER_SECURE(TASK_FOLLOW_WAYPOINT_RECORDING,0x4218764824f31173, waypoint_commands::CommandTaskFollowWaypointRecording );
SCR_REGISTER_SECURE(IS_WAYPOINT_PLAYBACK_GOING_ON_FOR_PED,0xb4ae2a423a4176ce, waypoint_commands::CommandIsWaypointPlaybackGoingOnForPed );
SCR_REGISTER_SECURE(GET_PED_WAYPOINT_PROGRESS,0x0b331f8dc5c61933, waypoint_commands::CommandGetPedWaypointProgress );
SCR_REGISTER_UNUSED(SET_PED_WAYPOINT_PROGRESS,0xadc4c24903027450, waypoint_commands::CommandSetPedWaypointProgress );
SCR_REGISTER_SECURE(GET_PED_WAYPOINT_DISTANCE,0xb80b2f3bfb68df1a, waypoint_commands::CommandGetPedWaypointDistance );
SCR_REGISTER_SECURE(SET_PED_WAYPOINT_ROUTE_OFFSET,0x455e0249f399ef4c, waypoint_commands::CommandSetPedWaypointRouteOffset );
SCR_REGISTER_SECURE(GET_WAYPOINT_DISTANCE_ALONG_ROUTE,0xd2fe51a38e9a1946, waypoint_commands::CommandGetWaypointDistanceAlongRoute );
SCR_REGISTER_SECURE(WAYPOINT_PLAYBACK_GET_IS_PAUSED,0x656f70678f75d966, waypoint_commands::CommandWaypointPlaybackGetIsPaused );
SCR_REGISTER_SECURE(WAYPOINT_PLAYBACK_PAUSE,0x499c4b0d70f4097c, waypoint_commands::CommandWaypointPlaybackPause );
SCR_REGISTER_SECURE(WAYPOINT_PLAYBACK_RESUME,0x4ffeb98e621afb27, waypoint_commands::CommandWaypointPlaybackResume );
SCR_REGISTER_SECURE(WAYPOINT_PLAYBACK_OVERRIDE_SPEED,0x369b082b04a4f619, waypoint_commands::CommandWaypointPlaybackOverrideSpeed );
SCR_REGISTER_SECURE(WAYPOINT_PLAYBACK_USE_DEFAULT_SPEED,0x5039c5050b42f1e0, waypoint_commands::CommandWaypointPlaybackUseDefaultSpeed );
SCR_REGISTER_SECURE(USE_WAYPOINT_RECORDING_AS_ASSISTED_MOVEMENT_ROUTE,0xbb6589e0d27bd54e, waypoint_commands::CommandUseWaypointRecordingAsAssistedMovementRoute);
SCR_REGISTER_SECURE(WAYPOINT_PLAYBACK_START_AIMING_AT_PED,0x9b4dd143cd0c78fe, waypoint_commands::CommandWaypointPlaybackStartAimingAtPed );
SCR_REGISTER_UNUSED(WAYPOINT_PLAYBACK_START_AIMING_AT_ENTITY,0x47e2d6d68a34062a, waypoint_commands::CommandWaypointPlaybackStartAimingAtEntity );
SCR_REGISTER_SECURE(WAYPOINT_PLAYBACK_START_AIMING_AT_COORD,0xa142fd669ff80016, waypoint_commands::CommandWaypointPlaybackStartAimingAtCoord );
SCR_REGISTER_SECURE(WAYPOINT_PLAYBACK_START_SHOOTING_AT_PED,0xa9b13da1d075a160, waypoint_commands::CommandWaypointPlaybackStartShootingAtPed );
SCR_REGISTER_UNUSED(WAYPOINT_PLAYBACK_START_SHOOTING_AT_ENTITY,0x4f6e75c1ca97a1ef, waypoint_commands::CommandWaypointPlaybackStartShootingAtEntity );
SCR_REGISTER_SECURE(WAYPOINT_PLAYBACK_START_SHOOTING_AT_COORD,0x4f826adf9bdb6bd8, waypoint_commands::CommandWaypointPlaybackStartShootingAtCoord );
SCR_REGISTER_SECURE(WAYPOINT_PLAYBACK_STOP_AIMING_OR_SHOOTING,0x282cae6fb0e3b2fc, waypoint_commands::CommandWaypointPlaybackStopAimingOrShooting );
SCR_REGISTER_SECURE(ASSISTED_MOVEMENT_REQUEST_ROUTE,0xb5549ea4fcf75870, waypoint_commands::CommandAssistedMovementRequestRoute);
SCR_REGISTER_SECURE(ASSISTED_MOVEMENT_REMOVE_ROUTE,0xed4af6b9266b55c9, waypoint_commands::CommandAssistedMovementRemoveRoute);
SCR_REGISTER_SECURE(ASSISTED_MOVEMENT_IS_ROUTE_LOADED,0x632b7d3b9b85016a, waypoint_commands::CommandAssistedMovementIsRouteLoaded);
SCR_REGISTER_UNUSED(ASSISTED_MOVEMENT_GET_ROUTE_PROPERTIES,0xec6dfa1a86cf270a, waypoint_commands::CommandAssistedMovementGetRouteProperties);
SCR_REGISTER_SECURE(ASSISTED_MOVEMENT_SET_ROUTE_PROPERTIES,0x50569e4320bc8e92, waypoint_commands::CommandAssistedMovementSetRouteProperties);
SCR_REGISTER_SECURE(ASSISTED_MOVEMENT_OVERRIDE_LOAD_DISTANCE_THIS_FRAME,0xd7e4e11cc0659bb6, waypoint_commands::CommandAssistedMovementOverrideLoadDistanceThisFrame);
SCR_REGISTER_SECURE(TASK_VEHICLE_FOLLOW_WAYPOINT_RECORDING,0xa24707688ba83cea, waypoint_commands::CommandTaskVehicleFollowWaypointRecording);
SCR_REGISTER_SECURE(IS_WAYPOINT_PLAYBACK_GOING_ON_FOR_VEHICLE,0x22ff01f89d3006c0, waypoint_commands::CommandIsWaypointPlaybackGoingOnForVehicle);
SCR_REGISTER_SECURE(GET_VEHICLE_WAYPOINT_PROGRESS,0x46ea6598acefacc1, waypoint_commands::CommandGetVehicleWaypointProgress);
SCR_REGISTER_SECURE(GET_VEHICLE_WAYPOINT_TARGET_POINT,0x0e9d3608e0ae9ee3, waypoint_commands::CommandGetVehicleWaypointTargetPoint);
SCR_REGISTER_SECURE(VEHICLE_WAYPOINT_PLAYBACK_PAUSE,0xe3948de25c763434, waypoint_commands::CommandVehicleWaypointPlaybackPause);
SCR_REGISTER_UNUSED(VEHICLE_WAYPOINT_PLAYBACK_GET_IS_PAUSED,0xa84a1cf14183e169, waypoint_commands::CommandVehicleWaypointPlaybackGetIsPaused);
SCR_REGISTER_SECURE(VEHICLE_WAYPOINT_PLAYBACK_RESUME,0x211bb80656beac0f, waypoint_commands::CommandVehicleWaypointPlaybackResume);
SCR_REGISTER_SECURE(VEHICLE_WAYPOINT_PLAYBACK_USE_DEFAULT_SPEED,0x502f9fce448f5724, waypoint_commands::CommandVehicleWaypointPlaybackUseDefaultSpeed);
SCR_REGISTER_SECURE(VEHICLE_WAYPOINT_PLAYBACK_OVERRIDE_SPEED,0xf248aeaab65d17cd, waypoint_commands::CommandVehicleWaypointPlaybackOverrideSpeed);
SCR_REGISTER_UNUSED(TASK_NM_ATTACH_PED_TO_ENTITY,0x7ed90e7321ac4a87, CommandTaskNMAttachPedToEntity);
SCR_REGISTER_SECURE(TASK_SET_BLOCKING_OF_NON_TEMPORARY_EVENTS,0xf7b73727a8f72f54, CommandTaskSetBlockingOfNonTemporaryEvents);
SCR_REGISTER_SECURE(TASK_FORCE_MOTION_STATE,0x57374b880e0a67bd, CommandTaskForceMotionState);
// MoVE interface
SCR_REGISTER_SECURE(TASK_MOVE_NETWORK_BY_NAME,0x84a70ae1a2393914, CommandTaskMoveNetworkByName);
SCR_REGISTER_SECURE(TASK_MOVE_NETWORK_ADVANCED_BY_NAME,0xad3d17c7e426d09d, CommandTaskMoveNetworkAdvancedByName);
SCR_REGISTER_SECURE(TASK_MOVE_NETWORK_BY_NAME_WITH_INIT_PARAMS,0x4601817fd87b48e3, CommandTaskMoveNetworkByNameWithInitParams);
SCR_REGISTER_SECURE(TASK_MOVE_NETWORK_ADVANCED_BY_NAME_WITH_INIT_PARAMS,0xca9cbdbc10f9d281, CommandTaskMoveNetworkAdvancedByNameWithInitParams);
SCR_REGISTER_SECURE(IS_TASK_MOVE_NETWORK_ACTIVE,0xfcd53f51d587f4c6, CommandIsTaskMoveNetworkActive);
SCR_REGISTER_SECURE(IS_TASK_MOVE_NETWORK_READY_FOR_TRANSITION,0x0422aefd9002867b, CommandIsTaskMoveNetworkReadyForTransition);
SCR_REGISTER_SECURE(REQUEST_TASK_MOVE_NETWORK_STATE_TRANSITION,0xdcd29be535921736, CommandRequestTaskMoveNetworkStateTransition);
SCR_REGISTER_SECURE(SET_EXPECTED_CLONE_NEXT_TASK_MOVE_NETWORK_STATE,0x2029bef342249fb1, CommandSetExpectedCloneNextTaskMoveNetworkState);
SCR_REGISTER_SECURE(GET_TASK_MOVE_NETWORK_STATE,0x111890991356db66, CommandGetTaskMoveNetworkState);
SCR_REGISTER_SECURE(SET_TASK_MOVE_NETWORK_ANIM_SET,0x2d9f06756211492a, CommandSetTaskMoveNetworkClipSet);
SCR_REGISTER_SECURE(SET_TASK_MOVE_NETWORK_SIGNAL_FLOAT,0x8e11f085404a3100, CommandSetTaskMoveNetworkSignalFloat);
SCR_REGISTER_SECURE(SET_TASK_MOVE_NETWORK_SIGNAL_LOCAL_FLOAT,0x357c016ef8883bad, CommandSetTaskMoveNetworkSignalLocalFloat);
SCR_REGISTER_SECURE(SET_TASK_MOVE_NETWORK_SIGNAL_FLOAT_LERP_RATE,0x6e3f82dd454ea5b1, CommandSetTaskMoveNetworkSignalFloatLerpRate);
SCR_REGISTER_SECURE(SET_TASK_MOVE_NETWORK_SIGNAL_BOOL,0xdde2a56a49baf5b0, CommandSetTaskMoveNetworkSignalBool);
SCR_REGISTER_UNUSED(SET_TASK_MOVE_NETWORK_SIGNAL_LOCAL_BOOL,0xbe46dff5c216a2b0, CommandSetTaskMoveNetworkSignalLocalBool);
SCR_REGISTER_SECURE(GET_TASK_MOVE_NETWORK_SIGNAL_FLOAT,0x103bce39f925945e, CommandGetTaskMoveNetworkSignalFloat);
SCR_REGISTER_SECURE(GET_TASK_MOVE_NETWORK_SIGNAL_BOOL,0x501632a36a6512aa, CommandGetTaskMoveNetworkSignalBool);
SCR_REGISTER_SECURE(GET_TASK_MOVE_NETWORK_EVENT,0xce3f029a4833b5e1, CommandGetTaskMoveNetworkEvent);
SCR_REGISTER_SECURE(SET_TASK_MOVE_NETWORK_ENABLE_COLLISION_ON_NETWORK_CLONE_WHEN_FIXED,0x4a5f1661be58e97e, CommandSetTaskMoveNetworkEnableCollisionOnNetworkCloneWhenFixed);
// End MoVE interface
SCR_REGISTER_SECURE(IS_MOVE_BLEND_RATIO_STILL,0x98daeb6e7093895e, CommandIsMoveBlendRatioStill);
SCR_REGISTER_SECURE(IS_MOVE_BLEND_RATIO_WALKING,0x6b46f0285c770b5b, CommandIsMoveBlendRatioWalking);
SCR_REGISTER_SECURE(IS_MOVE_BLEND_RATIO_RUNNING,0x833a52f892a42353, CommandIsMoveBlendRatioRunning);
SCR_REGISTER_SECURE(IS_MOVE_BLEND_RATIO_SPRINTING,0x3861da7f20602340, CommandIsMoveBlendRatioSprinting);
SCR_REGISTER_SECURE(IS_PED_STILL,0x443c6afb940b3c83, CommandIsPedStill);
SCR_REGISTER_SECURE(IS_PED_WALKING,0x834c649d79d5128d, CommandIsPedWalking);
SCR_REGISTER_SECURE(IS_PED_RUNNING,0x81bbcaf9fe3b469d, CommandPedIsRunning);
SCR_REGISTER_SECURE(IS_PED_SPRINTING,0xe02d8bdf4b18d48d, CommandPedIsSprinting);
SCR_REGISTER_SECURE(IS_PED_STRAFING,0xfe3baaf47e48d31f, CommandPedIsStrafing);
// synchronized scenes
SCR_REGISTER_SECURE(TASK_SYNCHRONIZED_SCENE,0x950b26f4c891073f, CommandTaskSynchronizedScene);
SCR_REGISTER_SECURE(TASK_AGITATED_ACTION_CONFRONT_RESPONSE,0x3e7d91f4eece76b8, CommandGivePedAgitatedTaskConfront);
//////////////////////////////////////////////////////////////////////////
// Ped SweepTask commands
//////////////////////////////////////////////////////////////////////////
SCR_REGISTER_SECURE(TASK_SWEEP_AIM_ENTITY,0x26d2934cf2d5b32c, CommandTaskSweepAimEntity);
SCR_REGISTER_SECURE(UPDATE_TASK_SWEEP_AIM_ENTITY,0x878b7bb84cc31442, CommandUpdateTaskSweepAimEntity);
SCR_REGISTER_SECURE(TASK_SWEEP_AIM_POSITION,0x07c9c36e1a3234e9, CommandTaskSweepAimPosition);
SCR_REGISTER_SECURE(UPDATE_TASK_SWEEP_AIM_POSITION,0xc82e4267a5f18820, CommandUpdateTaskSweepAimPosition);
// @DEPRECATED: Old arrest commands
SCR_REGISTER_SECURE(TASK_ARREST_PED,0x463d4f9c4826a59b, CommandTaskArrestPed);
SCR_REGISTER_SECURE(IS_PED_RUNNING_ARREST_TASK,0x64152dd440e37f50, CommandIsPedRunningArrestTask);
SCR_REGISTER_UNUSED(IS_ARREST_TYPE_VALID,0x1c805a9f43140ae6, CommandIsArrestTypeValid);
// Arrest/uncuff commands
SCR_REGISTER_SECURE(IS_PED_BEING_ARRESTED,0x1c7f03843c4541ad, CommandIsPedBeingArrested);
SCR_REGISTER_UNUSED(IS_PED_BEING_UNCUFFED,0x522ef0aaa44cd03a, CommandIsPedBeingUncuffed);
SCR_REGISTER_UNUSED(IS_PED_ARRESTING,0x2a706f5c5d386b6e, CommandIsPedArresting);
SCR_REGISTER_UNUSED(IS_PED_UNCUFFING,0x1590a589bdbbf96c, CommandIsPedUncuffing);
SCR_REGISTER_UNUSED(GET_PED_ARRESTER,0x1d081ef24f8c6203, CommandGetPedArrester);
SCR_REGISTER_UNUSED(GET_PED_UNCUFFER,0x79a3054bf21c9039, CommandGetPedUncuffer);
SCR_REGISTER_UNUSED(GET_PED_ARRESTING_TARGET,0x9def9d10068f6f46, CommandGetPedArrestingTarget);
SCR_REGISTER_UNUSED(GET_PED_UNCUFFING_TARGET,0x08c5c742c9b17f90, CommandGetPedUncuffingTarget);
SCR_REGISTER_UNUSED(CUFF_PED,0x7b9873a2f170f8b0, CommandCuffPed);
SCR_REGISTER_SECURE(UNCUFF_PED,0x9a89b72b9931965c, CommandUncuffPed);
SCR_REGISTER_SECURE(IS_PED_CUFFED,0xea266e5f12328e62, CommandIsPedCuffed);
SCR_REGISTER_UNUSED(IS_PED_TAKING_CUSTODY,0xb178acc0bca5b82c, CommandIsPedTakingCustody);
SCR_REGISTER_UNUSED(GET_PED_TAKING_CUSTODY_TARGET,0x2f6461d574428769, CommandGetPedTakingCustodyTarget);
SCR_REGISTER_UNUSED(IS_PED_BEING_TAKEN_INTO_CUSTODY,0xcaff880c04b723c0, CommandIsPedBeingTakenIntoCustody);
SCR_REGISTER_UNUSED(TASK_TAKE_CUSTODY,0x53baad9817f5de01, CommandTaskTakeCustody);
SCR_REGISTER_UNUSED(GET_PED_CUSTODIAN,0x670b52c53b47a811, CommandGetPedCustodian);
SCR_REGISTER_UNUSED(REMOVE_PED_FROM_CUSTODY,0x512b985df2d0e125, CommandRemovePedFromCustody);
SCR_REGISTER_UNUSED(GET_PED_ARREST_PHASE,0x44559d9a1dd62526, CommandGetPedArrestPhase);
SCR_REGISTER_UNUSED(GET_PED_POTENTIAL_ARREST_TARGET,0x1214edf270c95469, CommandGetPedPotentialArrestTarget);
SCR_REGISTER_UNUSED(GET_PED_POTENTIAL_UNCUFF_TARGET,0x346aeaa1e63abaeb, CommandGetPedPotentialUncuffTarget);
SCR_REGISTER_UNUSED(SET_PED_CUSTODY_FOLLOW_DISTANCE,0x006f134efa946bd1, CommandSetPedCustodyOverrideFollowDistance);
SCR_REGISTER_UNUSED(WARP_INTO_LEADERS_VEHICLE,0x196931342f1803a2, CommandWarpIntoLeadersVehicle);
}
} // end of namespace task_commands