x/gtav-src
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
a6770644bb24d2fc66a35fb9db6d70df5d108b1c
gtav-src/script/dev_ng/singleplayer/include/public/route_manager_public.sch
T
x a6770644bb init gta
2025-09-29 00:52:08 +02:00

2468 lines
85 KiB
Scheme
Executable File
Raw Blame History

USING "RC_helper_functions.sch"
USING "RC_threat_public.sch"
//USING "commands_task.sch"
ENUM DELIVER_PED_TYPE
DRIVER = 0,
PASSENGER,
MAX_DELIVERY_PEDS
ENDENUM
ENUM DELIVER_PED_CONTROL_STATES
DPCS_DELIVERING,
DPCS_REACTING
ENDENUM
ENUM DELIVER_PED_DELIVERY_STATES
DPDS_NULL,
DPDS_WALKING_TO_VAN_DOOR,
DPDS_ENTER_VAN,
DPDS_WAITING_IN_VAN,
DPDS_DRIVE_TO_DELIVERY_POINT,
DPDS_BREAKING,
DPDS_PULLINGOVER,
DPDS_WAIT_PASSENGER_DELIVER,
DPDS_EXIT_VAN_DELIVER,
DPDS_MAKE_DELIVERY,
DPDS_WANDERING
ENDENUM
ENUM SUB_DELIVERY_STATES
SDS_NULL = 0,
SDS_WALKING_TO_BAG,
SDS_PICK_UP_BIN_BAG,
SDS_WALK_TO_BACK_OF_TRUCK,
SDS_THROW_BAG_IN_TO_TRUCK,
SDS_DROP_BAG
ENDENUM
ENUM DELIVER_PED_REACTION_STATES
DPRS_NULL,
DPRS_EXIT_VAN_FLEE,
DPRS_BEING_JACKED,
DPRS_WAIT_RING_COPS,
DPRS_RING_COPS,
DPRS_WAIT_REACT_TO_PLAYER_FLEE,
DPRS_REACT_TO_PLAYER_INITAL_FLEE,
DPRS_REACT_TO_PLAYER_FLEE,
DPRS_FLEE_AFTER_RINGING_COPS,
DPRS_REACT_TO_PLAYER_ANGER,
DPRS_WAIT_REACT_TO_PLAYER_COWER,
DPRS_WAIT_REACT_SEARCH,
DPRS_REACT_TO_PLAYER_COWER,
DPRS_REACT_TO_PLAYER_BLOCKING_DOOR,
DPRS_REACT_TO_PLAYER_BLOCKING_BINS,
DPRS_REACT_TO_PLAYER_BLOCKING_BAC_OF_TRUCK,
DPRS_REACT_TO_PLAYER_BLOCKING_FRONT_OF_TRUCK,
DPRS_REACT_TO_PLAYER_BUMP,
DPRS_WAIT_FLIM_BLOCKING,
DPRS_WAIT_FLIM_DEAD,
DPRS_REACT_FLIM,
DPRS_WAIT_REACT_BRAWL,
DPRS_REACT_BRAWL,
DPRS_REACT_SEARCH
ENDENUM
REL_GROUP_HASH HASH_ENEMIES //Relationship hash for all ranchers
//PASSENGER_PED_STATES ePrevPassengerPed = PPS_NULL
//PERCEPTION CONSTANTS
CONST_FLOAT MAX_VISION_RANGE 20.0 //The distance a ped can identify that the player is a threat
CONST_FLOAT MAX_VISION_ARC_RANGE 170.0 //the vision arc that the player needs to be in before they are spotted
//DEILIVERY PED
CONST_INT MAX_DELIVERIES 21
INT iNumDeliveries = MAX_DELIVERIES
STRUCT PED_STRUCT
PED_INDEX id
INT iReactionTimer
INT iReactionDelay
INT iQuickReactionDelay
BLIP_INDEX blip
DELIVER_PED_CONTROL_STATES eControlState = DPCS_DELIVERING
DELIVER_PED_REACTION_STATES eReactionState = DPRS_NULL
DELIVER_PED_DELIVERY_STATES eDeliverState = DPDS_NULL
DELIVER_PED_DELIVERY_STATES ePrevDeliverState = DPDS_NULL
SUB_DELIVERY_STATES eDeliverSubState = SDS_NULL
DELIVER_PED_TYPE eDeliverPedType
ENDSTRUCT
STRUCT VEHICLE_STRUCT
VEHICLE_INDEX id
BLIP_INDEX blip
ENDSTRUCT
STRUCT DELIVERY_POINT
VECTOR vDriveTo
VECTOR vParkingVec
FLOAT fDriveToTargetDist
FLOAT fDriveToStraightDist
FLOAT fParkHeading
BOOL bDoActionAtDeliveryPoint = TRUE
PARK_TYPE eParkType = PARK_TYPE_PULL_OVER
VECTOR vBlockingAreaCentre
VECTOR vBlockingAreaSize
OBJECT_INDEX oiObject
BOOL bDelivered = FALSE
VECTOR vPedSpawn
FLOAT fPedHeading
MODEL_NAMES pedModel
BOOL bSpawned = FALSE
ENDSTRUCT
STRUCT SHAPE_TEST_STRUCT
SHAPETEST_INDEX ShapeTest
SHAPETEST_TYPE eShapeTestType
//Input
VECTOR vStartPos
VECTOR vEndPos
VECTOR vSize //For box
VECTOR vEulerRot //For box
EULER_ROT_ORDER eEulerOrder = EULER_XYZ //For box
FLOAT fRadius
BOOL bRequested
ENTITY_INDEX EntityIndex //For bounding box test
ENTITY_INDEX HitEntity //For who we hit
//Results
BOOL bResultIsNew
VECTOR vHitPos
VECTOR vHitNormal
BOOL bIsHit
ENDSTRUCT
SHAPE_TEST_STRUCT mGotoBlockingShape
PROC RESET_SHAPE_TEST()
mGotoBlockingShape.ShapeTest = NULL
mGotoBlockingShape.bIsHit = FALSE
mGotoBlockingShape.HitEntity = NULL
ENDPROC
VEHICLE_STRUCT mRoutedVehicle
PED_STRUCT mPed[MAX_DELIVERY_PEDS]
DELIVERY_POINT mDeliveryPoint[MAX_DELIVERIES]
FLOAT fTruckBootOpenRatio = -1.0
INT iDeliveryIndex
BOOL bIsLooped = FALSE
BOOL bIsSetRoute = FALSE
BOOL bPassengerDoDeliveries = FALSE
BOOL bCheckSeenPedDie = FALSE
BOOL bWantedLevelSet = FALSE
VECTOR vSearchPos = <<0,0,0>>
INT iPlayerBlockingTruckTimer = -1
///
///
/// DEBUG ONLY MISSION STUFF ------------------------------------------------------------
///
///
#IF IS_DEBUG_BUILD
// BLIP_INDEX DebugBlip
BOOL bShowDeliveryDebugText = TRUE
WIDGET_GROUP_ID DeliverswidgetGroup
/// PURPOSE:
/// Prints a string to a TTY Channel
/// PARAMS:
/// s - The string to print
/// ddc - The debug channel to print to
PROC SK_PRINT(String s, DEBUG_CHANNELS ddc = DEBUG_MISSION)
IF bShowDeliveryDebugText
CPRINTLN(ddc, s)
PRINTNL()
PRINTNL()
ENDIF
ENDPROC
/// PURPOSE:
/// Prints a string and an int to a TTY Channel
/// PARAMS:
/// s - The string to print
/// i - the int to print
/// ddc - the debug channel to print to
PROC SK_PRINT_INT(String s, INT i, DEBUG_CHANNELS ddc = DEBUG_MISSION)
IF bShowDeliveryDebugText
CPRINTLN(ddc, s,i)
PRINTNL()
PRINTNL()
ENDIF
ENDPROC
/// PURPOSE:
/// Prints a string and a Float to a TTY Channel
/// PARAMS:
/// s - the string to print
/// f - the float to print
/// ddc - the debug channel
PROC SK_PRINT_FLOAT(String s, FLOAT f, DEBUG_CHANNELS ddc = DEBUG_MISSION)
IF bShowDeliveryDebugText
CPRINTLN(ddc, s,f)
PRINTNL()
PRINTNL()
ENDIF
ENDPROC
/// PURPOSE:
/// Sets up a widget for this mission
PROC SETUP_DELIVERY_RAGE_WIDGETS()
DeliverswidgetGroup = START_WIDGET_GROUP("Delivery Header file")
START_WIDGET_GROUP("Debug")
ADD_WIDGET_BOOL("Toggle Debug spew", bShowDeliveryDebugText)
STOP_WIDGET_GROUP()
STOP_WIDGET_GROUP()
ENDPROC
/// PURPOSE:
/// Deletes the mission widget
PROC CLEANUP_DELIVERY_OBJECT_WIDGETS()
IF DOES_WIDGET_GROUP_EXIST(DeliverswidgetGroup)
DELETE_WIDGET_GROUP(DeliverswidgetGroup)
ENDIF
ENDPROC
/// PURPOSE:
/// Checks for any updates needed for the widgets
PROC UPDATE_DELIVERY_RAG_WIDGETS()
ENDPROC
#ENDIF
/// PURPOSE:
/// Requests a model and waits for it to load
/// PARAMS:
/// _modname - The name of the model to load
/// _debugstring - used to debug
/// i - used to debug
/// RETURNS:
/// TRUE when the model is loaded
FUNC BOOL REQUEST_AND_CHECK_MODEL(MODEL_NAMES _modname, STRING _debugstring, INT i = 0)
REQUEST_MODEL(_modname)
IF NOT Is_String_Null_Or_Empty(_debugstring)
AND i <> -1
#IF IS_DEBUG_BUILD
SK_PRINT_INT(_debugstring, i)
#ENDIF
ENDIF
IF HAS_MODEL_LOADED(_modname)
#IF IS_DEBUG_BUILD
SK_PRINT("MODEL LOADED")
#ENDIF
RETURN TRUE
ENDIF
RETURN FALSE
ENDFUNC
/// PURPOSE:
/// Unloads a model - Sets it as no longer needed
/// PARAMS:
/// _modname - The model to unload
PROC UNLOAD_MODEL(MODEL_NAMES _modname, BOOL bCheckLoaded = TRUE)
IF bCheckLoaded
IF HAS_MODEL_LOADED(_modname)
SET_MODEL_AS_NO_LONGER_NEEDED(_modname)
ENDIF
ELSE
SET_MODEL_AS_NO_LONGER_NEEDED(_modname)
ENDIF
ENDPROC
/// PURPOSE:
/// Spawns a ped and returns true if it was succesful. Requests the model and unloads it
/// PARAMS:
/// pedindex - The PED_INDEX to write the newly create ped to
/// model - The model to load and use to create the ped
/// pos - The position the ped should be created
/// dir - The heading the ped should have when created
/// bUnloadAfterSpawn - If true we unload the model after spawning the ped
/// bFreeze - if true we freeze the ped after spawning
/// bTempEvents - if true we block temp events
/// bTargetable - if false we set the ped to not be targetted
/// RETURNS:
/// TRUE if the ped was created
FUNC BOOL SPAWN_PED(PED_INDEX &pedindex, MODEL_NAMES model, VECTOR pos, FLOAT dir, BOOL bUnloadAfterSpawn = TRUE, BOOL bFreeze = FALSE, BOOL bTempEvents = TRUE, BOOL bTargetable = TRUE)
IF NOT DOES_ENTITY_EXIST(pedindex)
IF REQUEST_AND_CHECK_MODEL(model,"Loading")
pedindex = CREATE_PED(PEDTYPE_MISSION, model, pos, dir)
//SET_PED_DEFAULT_COMPONENT_VARIATION(pedindex)
IF IS_PED_UNINJURED(pedindex)
#IF IS_DEBUG_BUILD SK_PRINT("PED CREATED !") #ENDIF
IF bFreeze
FREEZE_ENTITY_POSITION(pedindex, TRUE)
ENDIF
IF bTempEvents
SET_BLOCKING_OF_NON_TEMPORARY_EVENTS(pedindex, bTempEvents)
ENDIF
IF NOT bTargetable
SET_PED_CAN_BE_TARGETTED(pedindex, bTargetable)
ENDIF
IF bUnloadAfterSpawn
UNLOAD_MODEL(model)
ENDIF
RETURN TRUE
ENDIF
ENDIF
ELSE
IF IS_PED_UNINJURED(pedindex)
RETURN TRUE
ENDIF
ENDIF
RETURN FALSE
ENDFUNC
/// PURPOSE:
/// Spawns an object. And activates its physics
/// PARAMS:
/// objectindex - The OBJECT_INDEX to write the newly create object to
/// model - The model to load and use to create the object
/// pos - The position the object should be created
/// dir - The heading the object should have when created
/// RETURNS:
/// TRUE if the object was created
FUNC BOOL SPAWN_OBJECT(OBJECT_INDEX &objectindex, MODEL_NAMES model, VECTOR pos, FLOAT dir = 0.0, BOOL bUnloadAfterSpawn = TRUE)
IF NOT DOES_ENTITY_EXIST(objectindex)
IF REQUEST_AND_CHECK_MODEL(model,"Loading")
objectindex = CREATE_OBJECT(model, pos)
IF DOES_ENTITY_EXIST(objectindex)
SET_ENTITY_HEADING(objectindex, dir)
ACTIVATE_PHYSICS(objectindex)
IF bUnloadAfterSpawn
UNLOAD_MODEL(model)
ENDIF
RETURN TRUE
ENDIF
ENDIF
ELSE
IF IS_ENTITY_ALIVE(objectindex)
RETURN TRUE
ENDIF
ENDIF
RETURN FALSE
ENDFUNC
/// PURPOSE:
/// Spawns a vehicle and returns true if it was succesful - why does the is mission entity check return true
/// no matter what the out come of said check?
/// PARAMS:
/// vehicleindex - The VEHICLE_INDEX to write the newly create vehicle to
/// model - The model to load and use to create the vehicle
/// pos - The position the vehicle should be created
/// dir - The heading the vehicle should have when created
/// RETURNS:
/// TRUE if the vehicle was created
FUNC BOOL SPAWN_VEHICLE(VEHICLE_INDEX &vehicleindex, MODEL_NAMES model, VECTOR pos, FLOAT dir, BOOL bUnloadAfterSpawn = TRUE)
IF NOT DOES_ENTITY_EXIST(vehicleindex)
IF REQUEST_AND_CHECK_MODEL(model,"Loading")
vehicleindex = CREATE_VEHICLE(model, pos, dir)
IF DOES_ENTITY_EXIST(vehicleindex)
IF NOT IS_ENTITY_A_MISSION_ENTITY(vehicleindex)
SET_ENTITY_AS_MISSION_ENTITY(vehicleindex)
ENDIF
SET_VEHICLE_ON_GROUND_PROPERLY(vehicleindex)
IF bUnloadAfterSpawn
UNLOAD_MODEL(model)
ENDIF
RETURN TRUE
ENDIF
ENDIF
ELSE
IF IS_VEHICLE_OK(vehicleindex)
SET_ENTITY_COORDS(vehicleindex, pos)
SET_ENTITY_HEADING(vehicleindex, dir)
ENDIF
IF NOT IS_ENTITY_A_MISSION_ENTITY(vehicleindex)
SET_ENTITY_AS_MISSION_ENTITY(vehicleindex)
RETURN TRUE
ELSE
RETURN TRUE
ENDIF
ENDIF
RETURN FALSE
ENDFUNC
/// PURPOSE:
/// Spawns a ped inside a vehicle
/// PARAMS:
/// pedindex - The index to write the newly created ped back to (ref)
/// Car - The vehicle to create the ped in
/// modelName - The model of the ped to create
/// seat - the seat to create the ped in
/// bUnloadAfterSpawn - should we unload the ped model after creation
/// RETURNS:
/// TRUE if the ped was spawned correctly
FUNC BOOL SPAWN_PED_IN_VEHICLE(PED_INDEX &pedindex, VEHICLE_INDEX Car, MODEL_NAMES modelName, VEHICLE_SEAT seat = VS_DRIVER, BOOL bUnloadAfterSpawn = TRUE)
IF IS_VEHICLE_OK(Car)
IF NOT DOES_ENTITY_EXIST(pedindex)
IF REQUEST_AND_CHECK_MODEL(modelName,"Loading")
pedindex = CREATE_PED_INSIDE_VEHICLE(Car, PEDTYPE_MISSION, modelName, seat)
IF DOES_ENTITY_EXIST(pedindex)
IF bUnloadAfterSpawn
UNLOAD_MODEL(modelName)
ENDIF
RETURN TRUE
ENDIF
ENDIF
ELSE
RETURN TRUE
ENDIF
ELSE
RETURN TRUE
ENDIF
RETURN FALSE
ENDFUNC
/// PURPOSE:
/// Gets the heading between to vectors
/// PARAMS:
/// V1 - First vector
/// V2 - Second vector
/// RETURNS:
/// FLOAT - the heading between the two
FUNC FLOAT GET_HEADING_BETWEEN_VECTORS(VECTOR V1, VECTOR V2)
RETURN GET_HEADING_FROM_VECTOR_2D(V2.x-V1.x,V2.y-V1.y)
ENDFUNC
/// PURPOSE:
/// Picks a new delivery point at random
/// RETURNS:
/// returns the index of the new delivery point
FUNC INT PICK_RANDOM_DELIVERY_POINT()
INT i = GET_RANDOM_INT_IN_RANGE(0, iNumDeliveries-1)
WHILE mDeliveryPoint[i].bDelivered
i = GET_RANDOM_INT_IN_RANGE(0, iNumDeliveries-1)
ENDWHILE
RETURN i
ENDFUNC
PROC CHOOSE_NEXT_DELIVERY_POINT()
INT i = 0
IF bIsSetRoute
//Find an index that hasnt had a delivery
WHILE mDeliveryPoint[iDeliveryIndex].bDelivered
AND i <> -1
iDeliveryIndex++
IF iDeliveryIndex >= iNumDeliveries-1
i = -1
iDeliveryIndex = iNumDeliveries-1
ENDIF
ENDWHILE
IF iDeliveryIndex = iNumDeliveries-1
IF bIsLooped
iDeliveryIndex = 0
FOR i=0 TO (iNumDeliveries-1)
mDeliveryPoint[i].bDelivered = FALSE
ENDFOR
ELSE
iDeliveryIndex = iNumDeliveries-1
EXIT
ENDIF
ENDIF
ELSE
INT iCount
iCount = 0
FOR i=0 TO (iNumDeliveries-1)
IF mDeliveryPoint[i].bDelivered
iCount++
ENDIF
ENDFOR
IF iCount = iNumDeliveries-1
iDeliveryIndex = iNumDeliveries-1
ELIF iCount = iNumDeliveries
IF bIsLooped
FOR i=0 TO (iNumDeliveries-1)
mDeliveryPoint[i].bDelivered = FALSE
ENDFOR
iDeliveryIndex = PICK_RANDOM_DELIVERY_POINT()
ELSE
iDeliveryIndex = -1
EXIT
ENDIF
ELSE
iDeliveryIndex = PICK_RANDOM_DELIVERY_POINT()
ENDIF
ENDIF
ENDPROC
FUNC INT GET_CLOSEST_DELIVERY_POINT()
INT iClosestID
VECTOR vCurrentPos
INT i
#IF USE_TU_CHANGES
INT iTestID
#ENDIF
FLOAT fDistances[MAX_DELIVERIES]
IF IS_VEHICLE_OK(mRoutedVehicle.id)
vCurrentPos = GET_ENTITY_COORDS(mRoutedVehicle.id)
FOR i=0 TO (iNumDeliveries-1)
FLOAT fDist = GET_DISTANCE_BETWEEN_COORDS(vCurrentPos, mDeliveryPoint[i].vDriveTo)
IF NOT IS_VECTOR_ZERO(mDeliveryPoint[i].vDriveTo)
AND fDist > 25
fDistances[i] = fDist
ELSE
fDistances[i] = -1.0
ENDIF
ENDFOR
FLOAT lowestFloat = fDistances[0]
FOR i = 0 TO (iNumDeliveries-1)
IF fDistances[i] != -1.0
IF fDistances[i] < lowestFloat
lowestFloat = fDistances[i]
iClosestID = i
ENDIF
ENDIF
ENDFOR
FLOAT dot = DOT_PRODUCT((mDeliveryPoint[iClosestID].vDriveTo- vCurrentPos), GET_ENTITY_FORWARD_VECTOR(mRoutedVehicle.id))
#IF NOT USE_TU_CHANGES
#IF IS_DEBUG_BUILD SK_PRINT_FLOAT("dot FROM CURRENT TO CLOSEST ========== ", dot) #ENDIF
//Check the point isnt behind us
INT p = GET_GAME_TIMER()
WHILE dot < 0
AND (GET_GAME_TIMER() - p) < 100
iClosestID++
IF iClosestID >= MAX_DELIVERIES
iClosestID = 0
ENDIF
vCurrentPos = GET_ENTITY_COORDS(mRoutedVehicle.id)
dot = DOT_PRODUCT((mDeliveryPoint[iClosestID].vDriveTo- vCurrentPos), GET_ENTITY_FORWARD_VECTOR(mRoutedVehicle.id))
p = GET_GAME_TIMER()
#IF IS_DEBUG_BUILD SK_PRINT_FLOAT("FROM WHILE dot FROM CURRENT TO CLOSEST ========== ", dot)#ENDIF
ENDWHILE
#ENDIF
#IF USE_TU_CHANGES
iTestID = iClosestID
INT p = 0
WHILE dot < 0
AND p < 40
iTestID++
IF iTestID >= MAX_DELIVERIES
iTestID = 0
ENDIF
vCurrentPos = GET_ENTITY_COORDS(mRoutedVehicle.id)
dot = DOT_PRODUCT((mDeliveryPoint[iTestID].vDriveTo- vCurrentPos), GET_ENTITY_FORWARD_VECTOR(mRoutedVehicle.id))
p++
#IF IS_DEBUG_BUILD SK_PRINT_FLOAT("FROM WHILE dot FROM CURRENT TO CLOSEST ========== ", dot)#ENDIF
#IF IS_DEBUG_BUILD SK_PRINT_INT("Current test ID ========== ", iTestID)#ENDIF
#IF IS_DEBUG_BUILD SK_PRINT_INT("TIME ========== ", p)#ENDIF
ENDWHILE
IF p >= 40
#IF IS_DEBUG_BUILD SK_PRINT_INT("Current test ID ========== ", iTestID)#ENDIF
#IF IS_DEBUG_BUILD SK_PRINT_INT("Current test ID ========== ", p)
SCRIPT_ASSERT("COULDN't FIND DELIVERY ID.")#ENDIF
iTestID = iNumDeliveries-1
ENDIF
#ENDIF
ENDIF
#IF USE_TU_CHANGES
iClosestID = iTestID
#ENDIF
RETURN iClosestID
ENDFUNC
/// PURPOSE:
/// Removes a previous car gen blocking area
/// picks a new delivery point at randomm unless we are on the last point
/// sets up a new car gen blocking area at the new delivery point
PROC DO_DELIVERY_POINT_SETUP(BOOL FirstTimeActivate = FALSE)
IF iDeliveryIndex != -1
IF NOT IS_VECTOR_ZERO(mDeliveryPoint[iDeliveryIndex].vBlockingAreaCentre)
AND NOT IS_VECTOR_ZERO(mDeliveryPoint[iDeliveryIndex].vBlockingAreaSize)
// Remove previous car gen blocking
SET_ALL_VEHICLE_GENERATORS_ACTIVE_IN_AREA(
mDeliveryPoint[iDeliveryIndex].vBlockingAreaCentre - mDeliveryPoint[iDeliveryIndex].vBlockingAreaSize,
mDeliveryPoint[iDeliveryIndex].vBlockingAreaCentre + mDeliveryPoint[iDeliveryIndex].vBlockingAreaSize,
TRUE)
ENDIF
ENDIF
IF NOT FirstTimeActivate
CHOOSE_NEXT_DELIVERY_POINT()
ELSE
iDeliveryIndex = GET_CLOSEST_DELIVERY_POINT()
ENDIF
IF iDeliveryIndex != -1
#IF IS_DEBUG_BUILD SK_PRINT_INT("iDeliveryIndex ==== ", iDeliveryIndex) #ENDIF
IF NOT IS_VECTOR_ZERO(mDeliveryPoint[iDeliveryIndex].vBlockingAreaCentre)
AND NOT IS_VECTOR_ZERO(mDeliveryPoint[iDeliveryIndex].vBlockingAreaSize)
// Add vehicle gen blocking
SET_ALL_VEHICLE_GENERATORS_ACTIVE_IN_AREA(
mDeliveryPoint[iDeliveryIndex].vBlockingAreaCentre - mDeliveryPoint[iDeliveryIndex].vBlockingAreaSize,
mDeliveryPoint[iDeliveryIndex].vBlockingAreaCentre + mDeliveryPoint[iDeliveryIndex].vBlockingAreaSize,
FALSE)
ENDIF
ENDIF
ENDPROC
/// PURPOSE:
/// Tells the ped to drive to a delivery point and park if mDeliveryPoint[iDeliveryIndex].bDoActionAtDeliveryPoint
/// is set
/// If all delivery points have been visited the ped is told to wander in the vehicle
/// can add so specific behaviour to this point
PROC TELL_DRIVER_PED_DRIVE_TO_DELIVERY_POINT(BOOL FirstTimeActivate = FALSE)
IF NOT IS_VEHICLE_SEAT_FREE(mRoutedVehicle.id, VS_FRONT_RIGHT)
DO_DELIVERY_POINT_SETUP(FirstTimeActivate)
IF iDeliveryIndex <> iNumDeliveries-1
IF iDeliveryIndex = 4
TASK_VEHICLE_GOTO_NAVMESH(mPed[DRIVER].id, mRoutedVehicle.id, mDeliveryPoint[iDeliveryIndex].vDriveTo, 15, DRIVINGMODE_STOPFORCARS|DF_UseSwitchedOffNodes, mDeliveryPoint[iDeliveryIndex].fDriveToTargetDist)
// TASK_VEHICLE_DRIVE_TO_COORD(mPed[DRIVER].id, mRoutedVehicle.id, mDeliveryPoint[iDeliveryIndex].vDriveTo, 15, DRIVINGSTYLE_NORMAL, DUMMY_MODEL_FOR_SCRIPT, DRIVINGMODE_AVOIDCARS_STOPFORPEDS_OBEYLIGHTS|DF_UseSwitchedOffNodes, mDeliveryPoint[iDeliveryIndex].fDriveToTargetDist, mDeliveryPoint[iDeliveryIndex].fDriveToStraightDist)//B*1397821
ELSE
TASK_VEHICLE_DRIVE_TO_COORD(mPed[DRIVER].id, mRoutedVehicle.id, mDeliveryPoint[iDeliveryIndex].vDriveTo, 15, DRIVINGSTYLE_NORMAL, DUMMY_MODEL_FOR_SCRIPT, DRIVINGMODE_STOPFORCARS|DF_UseSwitchedOffNodes, mDeliveryPoint[iDeliveryIndex].fDriveToTargetDist, mDeliveryPoint[iDeliveryIndex].fDriveToStraightDist)
ENDIF
#IF IS_DEBUG_BUILD SK_PRINT("TELL_DRIVER_PED_DRIVE_TO_DELIVERY_POINT - eDeliveryPed = DPS_DRIVE_TO_DELIVERY_POINT") #ENDIF
mPed[DRIVER].ePrevDeliverState = mPed[DRIVER].eDeliverState
mPed[DRIVER].eDeliverState = DPDS_DRIVE_TO_DELIVERY_POINT
ELSE
TASK_VEHICLE_DRIVE_WANDER(mPed[DRIVER].id, mRoutedVehicle.id, 15, DRIVINGMODE_AVOIDCARS_STOPFORPEDS_OBEYLIGHTS)
mPed[DRIVER].ePrevDeliverState = mPed[DRIVER].eDeliverState
mPed[DRIVER].eDeliverState = DPDS_WANDERING
ENDIF
ELSE
mPed[DRIVER].ePrevDeliverState = mPed[DRIVER].eDeliverState
mPed[DRIVER].eDeliverState = DPDS_WAIT_PASSENGER_DELIVER
ENDIF
ENDPROC
PROC TELL_PED_TO_MAKE_DELIVERY(PED_STRUCT &ped)
IF NOT IsPedPerformingTask(ped.id, SCRIPT_TASK_PUT_PED_DIRECTLY_INTO_MELEE)
IF mDeliveryPoint[iDeliveryIndex].pedModel <> DUMMY_MODEL_FOR_SCRIPT
IF IS_ENTITY_ALIVE(mDeliveryPoint[iDeliveryIndex].oiObject)
TASK_GOTO_ENTITY_OFFSET( ped.id, mDeliveryPoint[iDeliveryIndex].oiObject, DEFAULT_TIME_NEVER_WARP, 0.0, 180.0, PEDMOVEBLENDRATIO_WALK)
// TASK_GO_TO_ENTITY(ped.id, mDeliveryPoint[iDeliveryIndex].oiObject, DEFAULT_TIME_NEVER_WARP, 0.1, PEDMOVEBLENDRATIO_WALK, 1)
// TASK_FOLLOW_NAV_MESH_TO_COORD(ped.id, mDeliveryPoint[iDeliveryIndex].vPedSpawn, PEDMOVEBLENDRATIO_WALK, DEFAULT_TIME_BEFORE_WARP, 2, ENAV_DEFAULT)
ENDIF
ELSE
TASK_FOLLOW_NAV_MESH_TO_COORD(ped.id, mDeliveryPoint[iDeliveryIndex].vPedSpawn, PEDMOVEBLENDRATIO_WALK, DEFAULT_TIME_BEFORE_WARP, -1, ENAV_DEFAULT, GET_HEADING_FROM_COORDS_TO_COORDS(mDeliveryPoint[iDeliveryIndex].vPedSpawn, GET_ENTITY_COORDS(ped.id)))
ENDIF
IF IS_VEHICLE_OK(mRoutedVehicle.id)
SET_VEHICLE_DOOR_OPEN(mRoutedVehicle.id, SC_DOOR_BOOT)
ENDIF
ped.ePrevDeliverState = ped.eDeliverState
ped.eDeliverState = DPDS_MAKE_DELIVERY
ped.eDeliverSubState = SDS_WALKING_TO_BAG
ENDIF
ENDPROC
/// PURPOSE:
/// Finds a road node 100m in front and 5m to the right of a vehicle
/// and then looks for a point by the side of the road from that road node
/// also makes sure there isnt already a vehicle or an object in a 2m radius from the point
/// PARAMS:
/// vh - the vehicle to find the point from
/// RETURNS:
/// A position at the side of the road about 100m in front of the vehicle
/// Will return vSafeVec if any of the checks failed
FUNC VECTOR FIND_PARKING_SPOT()
// #IF IS_DEBUG_BUILD SAFE_REMOVE_BLIP(DebugBlip) #ENDIF
VECTOR vTestParkPos = <<0,0,0>>
// IF GET_CLOSEST_VEHICLE_NODE(vTestPos, vTestParkPos)
IF GET_POSITION_BY_SIDE_OF_ROAD(mDeliveryPoint[iDeliveryIndex].vDriveTo, 0, vTestParkPos)
IF NOT IS_ANY_VEHICLE_NEAR_POINT(vTestParkPos, 2)
AND NOT IS_ANY_OBJECT_NEAR_POINT(vTestParkPos, 2)
// #IF IS_DEBUG_BUILD DebugBlip = CREATE_BLIP_FOR_COORD(vTestParkPos) #ENDIF
RETURN vTestParkPos
ENDIF
ENDIF
// ENDIF
RETURN <<0,0,0>>
ENDFUNC
PROC TELL_DRIVER_PED_PULLOVER(PED_STRUCT &ped)
IF IS_VEHICLE_OK(mRoutedVehicle.id)
// VECTOR vTempParkingPos = FIND_PARKING_SPOT()
//
// IF ARE_VECTORS_EQUAL(vTempParkingPos, <<0,0,0>>)
// vTempParkingPos = GET_ENTITY_COORDS(ped.id)
// ENDIF //GET_ENTITY_HEADING(mRoutedVehicle.id)
SEQUENCE_INDEX Seq
OPEN_SEQUENCE_TASK(Seq)
TASK_VEHICLE_DRIVE_TO_COORD(NULL, mRoutedVehicle.id, mDeliveryPoint[iDeliveryIndex].vParkingVec, 8, DRIVINGSTYLE_ACCURATE,TRASH, DRIVINGMODE_AVOIDCARS, 10, 15)
TASK_VEHICLE_PARK(NULL, mRoutedVehicle.id, mDeliveryPoint[iDeliveryIndex].vParkingVec, mDeliveryPoint[iDeliveryIndex].fParkHeading, mDeliveryPoint[iDeliveryIndex].eParkType, 5, TRUE)
CLOSE_SEQUENCE_TASK(Seq)
TASK_PERFORM_SEQUENCE(ped.id, Seq)
CLEAR_SEQUENCE_TASK(Seq)
#IF IS_DEBUG_BUILD SK_PRINT("ped.ePrevDeliverState ===== DPDS_DRIVE_TO_DELIVERY_POINT") #ENDIF
ped.eDeliverState = DPDS_PULLINGOVER
ENDIF
ENDPROC
/// PURPOSE:
///
PROC ROUTE_POINT_MANAGER()
INT i
FOR i=0 TO(iNumDeliveries-1)
IF mDeliveryPoint[i].pedModel <> DUMMY_MODEL_FOR_SCRIPT
IF mDeliveryPoint[i].bSpawned
//Manage the ped here
IF i != iDeliveryIndex
AND IS_ENTITY_ALIVE(mDeliveryPoint[i].oiObject)
AND GET_DISTANCE_BETWEEN_ENTITIES(mDeliveryPoint[i].oiObject, PLAYER_PED_ID()) > 200
DELETE_OBJECT(mDeliveryPoint[i].oiObject)
mDeliveryPoint[i].bSpawned = FALSE
ENDIF
ELSE
IF mDeliveryPoint[i].pedModel <> DUMMY_MODEL_FOR_SCRIPT
IF IS_ENTITY_IN_RANGE_COORDS(PLAYER_PED_ID(), mDeliveryPoint[i].vDriveTo, 100)
OR IS_ENTITY_IN_RANGE_COORDS(mPed[DRIVER].id, mDeliveryPoint[i].vDriveTo, 120)
mDeliveryPoint[i].bSpawned = SPAWN_OBJECT(mDeliveryPoint[i].oiObject, mDeliveryPoint[i].pedModel, mDeliveryPoint[i].vPedSpawn, mDeliveryPoint[i].fPedHeading)
ENDIF
ENDIF
ENDIF
ENDIF
ENDFOR
ENDPROC
FUNC VECTOR GET_ENTRYPOINT_AREA_OFFSET(BOOL bDriver = FALSE)
VECTOR vPos
INT i
IF NOT bDriver
i = GET_ENTITY_BONE_INDEX_BY_NAME(mRoutedVehicle.id, "wheel_rf")
ELSE
i = GET_ENTITY_BONE_INDEX_BY_NAME(mRoutedVehicle.id, "wheel_lf")
ENDIF
vPos = GET_WORLD_POSITION_OF_ENTITY_BONE(mRoutedVehicle.id, i)
vPos = GET_OFFSET_FROM_ENTITY_GIVEN_WORLD_COORDS(mRoutedVehicle.id, vPos)
IF NOT bDriver
vPos += <<1, 0, 0.5>>
ELSE
vPos += <<-1, 0, 0.5>>
ENDIF
RETURN vPos
ENDFUNC
/// PURPOSE:
/// Tells the driver ped to enter the route vehicle
PROC ACTIVATE_DRIVER_PED()
IF NOT IS_PED_IN_VEHICLE(mPed[DRIVER].id, mRoutedVehicle.id)
TASK_FOLLOW_NAV_MESH_TO_COORD(mPed[DRIVER].id, GET_OFFSET_FROM_ENTITY_IN_WORLD_COORDS(mRoutedVehicle.id, GET_ENTRYPOINT_AREA_OFFSET(TRUE)), 1, -1)
mPed[DRIVER].eDeliverState = DPDS_WALKING_TO_VAN_DOOR
ELSE
TELL_DRIVER_PED_DRIVE_TO_DELIVERY_POINT(TRUE)
ENDIF
ENDPROC
PROC REACTIVATE_PED(PED_STRUCT &ped)
SET_RELATIONSHIP_BETWEEN_GROUPS(ACQUAINTANCE_TYPE_PED_IGNORE, HASH_ENEMIES, RELGROUPHASH_PLAYER)
SWITCH ped.ePrevDeliverState
CASE DPDS_DRIVE_TO_DELIVERY_POINT
#IF IS_DEBUG_BUILD SK_PRINT("REACTIVATE_PED ped.ePrevDeliverState ===== DPDS_DRIVE_TO_DELIVERY_POINT") #ENDIF
BREAK
CASE DPDS_WANDERING
#IF IS_DEBUG_BUILD SK_PRINT(" REACTIVATE_PED ped.ePrevDeliverState ===== DPDS_WANDERING") #ENDIF
BREAK
CASE DPDS_EXIT_VAN_DELIVER
#IF IS_DEBUG_BUILD SK_PRINT("REACTIVATE_PED ped.ePrevDeliverState ===== DPDS_EXIT_VAN_DELIVER") #ENDIF
ACTIVATE_DRIVER_PED()
BREAK
CASE DPDS_WAITING_IN_VAN
#IF IS_DEBUG_BUILD SK_PRINT("REACTIVATE_PED ped.ePrevDeliverState ===== DPDS_WAITING_IN_VAN") #ENDIF
IF NOT IsPedPerformingTask(ped.id, SCRIPT_TASK_PERFORM_SEQUENCE)
IF iDeliveryIndex <= MAX_DELIVERIES-1
AND iDeliveryIndex != -1
mDeliveryPoint[iDeliveryIndex].bDelivered = TRUE
ENDIF
IF NOT IS_PED_IN_VEHICLE(ped.id, mRoutedVehicle.id)
#IF IS_DEBUG_BUILD SK_PRINT(" REACTIVATE_PED Tasking ped to walk vehicle") #ENDIF
IF ped.eDeliverPedType = DRIVER
TASK_FOLLOW_NAV_MESH_TO_COORD(ped.id, GET_OFFSET_FROM_ENTITY_IN_WORLD_COORDS(mRoutedVehicle.id, GET_ENTRYPOINT_AREA_OFFSET(TRUE)), 1, -1)
ped.eDeliverState = DPDS_WALKING_TO_VAN_DOOR
ELSE
TASK_FOLLOW_NAV_MESH_TO_COORD(ped.id, GET_OFFSET_FROM_ENTITY_IN_WORLD_COORDS(mRoutedVehicle.id, GET_ENTRYPOINT_AREA_OFFSET()), 1, -1)
ped.eDeliverState = DPDS_WALKING_TO_VAN_DOOR
ENDIF
ENDIF
ENDIF
BREAK
CASE DPDS_ENTER_VAN
IF NOT IS_PED_IN_VEHICLE(ped.id, mRoutedVehicle.id)
IF ped.eDeliverPedType = DRIVER
TASK_FOLLOW_NAV_MESH_TO_COORD(ped.id, GET_OFFSET_FROM_ENTITY_IN_WORLD_COORDS(mRoutedVehicle.id, GET_ENTRYPOINT_AREA_OFFSET(TRUE)), 1, -1)
ped.eDeliverState = DPDS_WALKING_TO_VAN_DOOR
ELSE
TASK_FOLLOW_NAV_MESH_TO_COORD(ped.id, GET_OFFSET_FROM_ENTITY_IN_WORLD_COORDS(mRoutedVehicle.id, GET_ENTRYPOINT_AREA_OFFSET()), 1, -1)
ped.eDeliverState = DPDS_WALKING_TO_VAN_DOOR
ENDIF
ENDIF
#IF IS_DEBUG_BUILD SK_PRINT(" REACTIVATE_PED ped.ePrevDeliverState ===== DPDS_ENTER_VAN") #ENDIF
BREAK
CASE DPDS_MAKE_DELIVERY
IF NOT mDeliveryPoint[iDeliveryIndex].bDelivered
IF ped.eDeliverSubState = SDS_WALKING_TO_BAG
TELL_PED_TO_MAKE_DELIVERY(ped)
ELSE
IF ped.eDeliverPedType = DRIVER
TASK_FOLLOW_NAV_MESH_TO_COORD(ped.id, GET_OFFSET_FROM_ENTITY_IN_WORLD_COORDS(mRoutedVehicle.id, GET_ENTRYPOINT_AREA_OFFSET(TRUE)), 1, -1)
ped.eDeliverState = DPDS_WALKING_TO_VAN_DOOR
ELSE
TASK_FOLLOW_NAV_MESH_TO_COORD(ped.id, GET_OFFSET_FROM_ENTITY_IN_WORLD_COORDS(mRoutedVehicle.id, GET_ENTRYPOINT_AREA_OFFSET()), 1, -1)
ped.eDeliverState = DPDS_WALKING_TO_VAN_DOOR
ENDIF
ENDIF
ELSE
IF NOT IS_PED_IN_VEHICLE(ped.id, mRoutedVehicle.id)
IF ped.eDeliverPedType = DRIVER
TASK_FOLLOW_NAV_MESH_TO_COORD(ped.id, GET_OFFSET_FROM_ENTITY_IN_WORLD_COORDS(mRoutedVehicle.id, GET_ENTRYPOINT_AREA_OFFSET(TRUE)), 1, -1)
ped.eDeliverState = DPDS_WALKING_TO_VAN_DOOR
ELSE
TASK_FOLLOW_NAV_MESH_TO_COORD(ped.id, GET_OFFSET_FROM_ENTITY_IN_WORLD_COORDS(mRoutedVehicle.id, GET_ENTRYPOINT_AREA_OFFSET()), 1, -1)
ped.eDeliverState = DPDS_WALKING_TO_VAN_DOOR
ENDIF
ENDIF
ENDIF
BREAK
DEFAULT
BREAK
ENDSWITCH
#IF IS_DEBUG_BUILD SK_PRINT_INT("REACTIVATE_PED ped.ePrevDeliverState ===== DEFAULT ", ENUM_TO_INT(ped.ePrevDeliverState)) #ENDIF
ped.iReactionTimer = GET_GAME_TIMER()
ped.eControlState = DPCS_DELIVERING
ENDPROC
/// PURPOSE:
/// Checks to see if the mRoutedVehicle car has burst tyres
/// RETURNS:
/// TRUE if the mRoutedVehicle car has burst tyres.
FUNC BOOL HAS_PLAYER_BURST_ROUTECAR_TYRES()
INT i
INT iDamagedTyres = 0
FOR i = (ENUM_TO_INT(SC_WHEEL_CAR_FRONT_LEFT)) TO (ENUM_TO_INT(SC_WHEEL_CAR_REAR_RIGHT))
IF IS_VEHICLE_TYRE_BURST(mRoutedVehicle.id, INT_TO_ENUM(SC_WHEEL_LIST, i))
iDamagedTyres++
ENDIF
ENDFOR
IF iDamagedTyres >= 3
RETURN TRUE
ENDIF
RETURN FALSE
ENDFUNC
/// PURPOSE:
/// Monitors the hunters car for damage and plays hunter dialogue if appropriate.
FUNC BOOL MONITER_PLAYER_DAMAGING_ROUTE_CAR()
IF IS_VEHICLE_OK(mRoutedVehicle.id)
AND IS_PED_UNINJURED(PLAYER_PED_ID())
IF HAS_ENTITY_BEEN_DAMAGED_BY_ENTITY(mRoutedVehicle.id, PLAYER_PED_ID())
CLEAR_ENTITY_LAST_DAMAGE_ENTITY(mRoutedVehicle.id)
IF HAS_PLAYER_BURST_ROUTECAR_TYRES()
OR GET_ENTITY_HEALTH(mRoutedVehicle.id) < 851
RETURN TRUE
ENDIF
ENDIF
ENDIF
RETURN FALSE
ENDFUNC
PROC TELL_PED_DROP_BIN_BAG(PED_STRUCT &ped)
IF ped.eDeliverState = DPDS_MAKE_DELIVERY
IF ped.eDeliverSubState >= SDS_PICK_UP_BIN_BAG
IF NOT IS_PED_INJURED(ped.id)
#IF IS_DEBUG_BUILD SK_PRINT("Playing break out bag drop anim") #ENDIF
RESET_PED_MOVEMENT_CLIPSET(ped.id)
RESET_PED_WEAPON_MOVEMENT_CLIPSET(ped.id)
TASK_PLAY_ANIM(ped.id, "missfbi4prepp1", "_bag_drop_garbage_man", NORMAL_BLEND_IN, NORMAL_BLEND_OUT, -1, AF_NOT_INTERRUPTABLE|AF_SECONDARY|AF_UPPERBODY)
ENDIF
ENDIF
ENDIF
ENDPROC
PROC TELL_PED_RING_COPS(PED_STRUCT &ped)
IF ped.eReactionState != DPRS_WAIT_RING_COPS
AND ped.eReactionState != DPRS_RING_COPS
TELL_PED_DROP_BIN_BAG(ped)
ped.iReactionTimer = GET_GAME_TIMER()
ped.eReactionState = DPRS_WAIT_RING_COPS
ped.eControlState = DPCS_REACTING
#IF IS_DEBUG_BUILD SK_PRINT("TELL_PED_RING_COPS()") #ENDIF
ENDIF
ENDPROC
/// PURPOSE:
/// Driver is told to head over to either the spawned ped or
/// the point the ped would of been spawned at if DUMMY_MODEL_FOR_SCRIPT
/// was set as the peds model
PROC TELL_PASSENGER_PED_TO_MAKE_DELIVERY()
TELL_PED_TO_MAKE_DELIVERY(mPed[PASSENGER])
//EPREVPASSENGERPED = ePassengerPed
#IF IS_DEBUG_BUILD SK_PRINT("TELL_PASSENGER_PED_TO_MAKE_DELIVERY - ePassengerPed = PPS_MAKE_DELIVERY") #ENDIF
ENDPROC
FUNC DELIVER_PED_TYPE GET_THE_OTHER_GUY(DELIVER_PED_TYPE type)
IF type = DRIVER
RETURN PASSENGER
ENDIF
RETURN DRIVER
ENDFUNC
PROC PICK_FLEE_REACTION(PED_STRUCT &ped, BOOL bForceFlee = FALSE)
TELL_PED_DROP_BIN_BAG(ped)
IF IS_PED_ARMED(PLAYER_PED_ID(), WF_INCLUDE_GUN|WF_INCLUDE_PROJECTILE)
OR bForceFlee
OR ped.eReactionState = DPRS_REACT_SEARCH
IF NOT IS_ENTITY_IN_RANGE_ENTITY(PLAYER_PED_ID(), ped.id, 10)
#IF IS_DEBUG_BUILD SK_PRINT("PICK_FLEE_REACTION = TGS_FLEE") #ENDIF
IF NOT IsPedPerformingTask(ped.id, SCRIPT_TASK_SMART_FLEE_PED)
ped.eReactionState = DPRS_WAIT_REACT_TO_PLAYER_FLEE
ped.eControlState = DPCS_REACTING
ped.iReactionTimer = GET_GAME_TIMER()
ENDIF
ELSE
ped.eReactionState = DPRS_WAIT_REACT_TO_PLAYER_COWER
ped.eControlState = DPCS_REACTING
ped.iReactionTimer = GET_GAME_TIMER()
ENDIF
ELSE
IF ped.eControlState <> DPCS_REACTING
#IF IS_DEBUG_BUILD SK_PRINT("PICK_FLEE_REACTION = TGS_ATTACK") #ENDIF
IF NOT IsPedPerformingTask(ped.id, SCRIPT_TASK_COMBAT)
AND NOT IsPedPerformingTask(ped.id, SCRIPT_TASK_PUT_PED_DIRECTLY_INTO_MELEE)
ped.eControlState = DPCS_REACTING
ped.eReactionState = DPRS_WAIT_REACT_BRAWL
ped.iReactionTimer = GET_GAME_TIMER()
ENDIF
ENDIF
ENDIF
ENDPROC
FUNC BOOL IS_PLAYER_BEHIND_UNARMED_STEALTH(PED_STRUCT &ped)
IF IS_ENTITY_AT_COORD(PLAYER_PED_ID(), GET_OFFSET_FROM_ENTITY_IN_WORLD_COORDS(ped.id, <<0,-2,0>>), <<2,3,2>>)
AND NOT IS_PED_ARMED(PLAYER_PED_ID(), WF_INCLUDE_GUN|WF_INCLUDE_PROJECTILE)
AND GET_PED_STEALTH_MOVEMENT(PLAYER_PED_ID())
RETURN TRUE
ENDIF
RETURN FALSE
ENDFUNC
FUNC BOOL HAS_PLAYER_BUMPED_PED(PED_INDEX ped)
IF IS_ENTITY_IN_RANGE_ENTITY(ped, PLAYER_PED_ID(), 6)
IF NOT IS_PED_IN_ANY_VEHICLE(ped)
IF IS_ENTITY_TOUCHING_ENTITY(ped, PLAYER_PED_ID())
RETURN TRUE
ENDIF
ENDIF
ENDIF
RETURN FALSE
ENDFUNC
PROC START_SHAPETEST (SHAPE_TEST_STRUCT &lShapeTest, ENTITY_INDEX ExcludeEntityIndex)
SWITCH lShapeTest.eShapeTestType
CASE SHAPETEST_INVALID
BREAK
CASE SHAPETEST_LOSPROBE
lShapeTest.ShapeTest = START_SHAPE_TEST_LOS_PROBE(lShapeTest.vStartPos, lShapeTest.vEndPos, SCRIPT_INCLUDE_ALL, ExcludeEntityIndex)
BREAK
// Since nobody was using async sphere tests we disabled them
//CASE SHAPETEST_SPHERE
//lShapeTest.ShapeTest = START_SHAPE_TEST_SPHERE(lShapeTest.vStartPos, lShapeTest.fRadius, SCRIPT_INCLUDE_ALL)
//BREAK
CASE SHAPETEST_BOUND
lShapeTest.ShapeTest = START_SHAPE_TEST_BOUND(lShapeTest.EntityIndex, SCRIPT_INCLUDE_ALL)
BREAK
CASE SHAPETEST_BOUNDINGBOX
lShapeTest.ShapeTest = START_SHAPE_TEST_BOUNDING_BOX(lShapeTest.EntityIndex, SCRIPT_INCLUDE_ALL)
BREAK
CASE SHAPETEST_BOX
lShapeTest.ShapeTest = START_SHAPE_TEST_BOX(lShapeTest.vStartPos, lShapeTest.vSize, lShapeTest.vEulerRot, lShapeTest.eEulerOrder, SCRIPT_INCLUDE_VEHICLE|SCRIPT_INCLUDE_PED, ExcludeEntityIndex)
BREAK
CASE SHAPETEST_CAPSULE
lShapeTest.ShapeTest = START_SHAPE_TEST_CAPSULE(lShapeTest.vStartPos, lShapeTest.vEndPos, lShapeTest.fRadius, SCRIPT_INCLUDE_ALL, ExcludeEntityIndex)
BREAK
ENDSWITCH
lShapeTest.bRequested = (lShapeTest.ShapeTest <> NULL)
ENDPROC
//Keep renewing the shape test (call this every frame)
PROC UPDATE_PERSISTENT_SHAPETEST (SHAPE_TEST_STRUCT &lShapeTest, ENTITY_INDEX ExcludeEntityIndex)
INT iHit // int as bool
SHAPETEST_STATUS Status = GET_SHAPE_TEST_RESULT(lShapeTest.ShapeTest, iHit, lShapeTest.vHitPos, lShapeTest.vHitNormal, lShapeTest.HitEntity)
lShapeTest.bResultIsNew = (SHAPETEST_STATUS_RESULTS_READY = Status)
//Convert the int as bool to a bool
IF lShapeTest.bResultIsNew
IF 0 = iHit
lShapeTest.bIsHit = FALSE
ELSE
lShapeTest.bIsHit = TRUE
ENDIF
ENDIF
//Try to keep all shape tests requested at all times
IF Status <> SHAPETEST_STATUS_RESULTS_NOTREADY //Result was just returned or request was nonexistent
START_SHAPETEST (lShapeTest, ExcludeEntityIndex)
ENDIF
ENDPROC
PROC INIT_GOTO_BLOCKING_SHAPE_TEST(VECTOR vSize, VECTOR vEulerRot)
mGotoBlockingShape.vSize = vSize
mGotoBlockingShape.vEulerRot = vEulerRot
mGotoBlockingShape.eShapeTestType = SHAPETEST_BOX
ENDPROC
FUNC BOOL IS_GOTO_BLOCKED(VECTOR vPos, ENTITY_INDEX ent, VECTOR vSize)
mGotoBlockingShape.vStartPos = vPos
mGotoBlockingShape.vSize = vSize
UPDATE_PERSISTENT_SHAPETEST(mGotoBlockingShape, ent)
#IF IS_DEBUG_BUILD
// DRAW_DEBUG_SPHERE(vPos, vSize.x, 0, 0, 255, 150)
#ENDIF
IF mGotoBlockingShape.bIsHit
// CPRINTLN(DEBUG_MISSION, "Shape test hit something")
IF IS_PED_IN_ANY_VEHICLE(PLAYER_PED_ID())
IF IS_ENTITY_A_VEHICLE(mGotoBlockingShape.HitEntity)
IF IS_ENTITY_ALIVE(mGotoBlockingShape.HitEntity)
IF GET_VEHICLE_INDEX_FROM_ENTITY_INDEX(mGotoBlockingShape.HitEntity) = GET_VEHICLE_PED_IS_IN(PLAYER_PED_ID(), TRUE)
CPRINTLN(DEBUG_MISSION, "Player in vehicle blocking go to")
RETURN TRUE
ENDIF
ENDIF
ENDIF
ELSE
IF IS_ENTITY_A_PED(mGotoBlockingShape.HitEntity)
IF IS_ENTITY_ALIVE(mGotoBlockingShape.HitEntity)
IF GET_PED_INDEX_FROM_ENTITY_INDEX(mGotoBlockingShape.HitEntity) = PLAYER_PED_ID()
CPRINTLN(DEBUG_MISSION, "Player on foot blocking go to")
RETURN TRUE
ENDIF
ENDIF
ENDIF
ENDIF
ENDIF
RETURN FALSE
ENDFUNC
FUNC BOOL IS_PLAYER_BLOCKING_TRUCK_PROGRESSION(PED_STRUCT &ped)
IF IS_ENTITY_IN_ANGLED_AREA(PLAYER_PED_ID(), GET_OFFSET_FROM_ENTITY_IN_WORLD_COORDS(mRoutedVehicle.id, <<0, 10, -2>>), GET_OFFSET_FROM_ENTITY_IN_WORLD_COORDS(mRoutedVehicle.id, <<0,3,2>>), 5)
AND IS_PED_STOPPED(ped.id)
RETURN TRUE
ENDIF
RETURN FALSE
ENDFUNC
/// PURPOSE:
/// Has the player pointed a gun at the ped or has the player fired near the ped
PROC MONITER_PLAYER_THREATEN(PED_STRUCT &ped, DELIVER_PED_TYPE type, BOOL bForceMonitor = FALSE)
IF ped.eControlState <> DPCS_REACTING
OR bForceMonitor
IF NOT IS_PED_UNINJURED(mPed[GET_THE_OTHER_GUY(type)].id)
IF NOT bCheckSeenPedDie
IF DOES_ENTITY_EXIST(mPed[GET_THE_OTHER_GUY(type)].id)
IF IS_PED_IN_PED_VIEW_CONE(ped.id, mPed[GET_THE_OTHER_GUY(type)].id, 140)
OR IS_ENTITY_IN_RANGE_ENTITY(mPed[GET_THE_OTHER_GUY(type)].id, ped.id, 3)
PICK_FLEE_REACTION(ped)
bCheckSeenPedDie = TRUE
CPRINTLN(DEBUG_MISSION, "Seen other guy is dead react = ", type)
EXIT
ELSE
vSearchPos = GET_ENTITY_COORDS(mPed[GET_THE_OTHER_GUY(type)].id)
ped.iReactionTimer = GET_GAME_TIMER()
ped.ePrevDeliverState = ped.eDeliverState
ped.eControlState = DPCS_REACTING
ped.eReactionState = DPRS_WAIT_REACT_SEARCH
CPRINTLN(DEBUG_MISSION, "entering search = ", type)
ENDIF
ELSE
PICK_FLEE_REACTION(ped)
ENDIF
ENDIF
ELSE
IF mPed[GET_THE_OTHER_GUY(type)].eReactionState = DPRS_REACT_BRAWL
IF IS_PED_IN_PED_VIEW_CONE(ped.id, mPed[GET_THE_OTHER_GUY(type)].id, 140)
AND IS_ENTITY_IN_RANGE_ENTITY(mPed[GET_THE_OTHER_GUY(type)].id, PLAYER_PED_ID(), 15)
ped.eControlState = DPCS_REACTING
ped.eReactionState = DPRS_WAIT_REACT_BRAWL
CPRINTLN(DEBUG_MISSION, "ped can see other ped brawling with player = ", type)
ENDIF
ELIF mPed[GET_THE_OTHER_GUY(type)].eReactionState = DPRS_WAIT_REACT_TO_PLAYER_FLEE
OR mPed[GET_THE_OTHER_GUY(type)].eReactionState = DPRS_REACT_TO_PLAYER_FLEE
IF IS_ENTITY_IN_RANGE_ENTITY(mPed[GET_THE_OTHER_GUY(type)].id, ped.id, 10)
PICK_FLEE_REACTION(ped)
ENDIF
ENDIF
ENDIF
IF HAS_PLAYER_BUMPED_PED(ped.id)
TELL_PED_DROP_BIN_BAG(ped)
CPRINTLN(DEBUG_MISSION, "React brawl ", type)
ped.iReactionTimer = GET_GAME_TIMER()
ped.ePrevDeliverState = ped.eDeliverState
ped.eControlState = DPCS_REACTING
ped.eReactionState = DPRS_WAIT_REACT_BRAWL
ENDIF
IF ped.eDeliverPedType = DRIVER
AND ped.eDeliverState = DPDS_DRIVE_TO_DELIVERY_POINT
IF IS_PLAYER_BLOCKING_TRUCK_PROGRESSION(ped)
IF IS_PED_IN_VEHICLE(ped.id, mRoutedVehicle.id)
TASK_DRIVE_BY(ped.id, PLAYER_PED_ID(), NULL, <<0,0,0>>, 10, 100, TRUE, FIRING_PATTERN_FULL_AUTO)
SET_HORN_PERMANENTLY_ON_TIME(mRoutedVehicle.id, 2000)
iPlayerBlockingTruckTimer = GET_GAME_TIMER()
ped.iReactionTimer = GET_GAME_TIMER()
ped.eReactionState= DPRS_REACT_TO_PLAYER_BLOCKING_FRONT_OF_TRUCK
ped.eControlState = DPCS_REACTING
ENDIF
ENDIF
ENDIF
IF HAS_PLAYER_THREATENED_PED(ped.id, TRUE, 70, 170, FALSE, TRUE)
AND NOT IS_PLAYER_BEHIND_UNARMED_STEALTH(ped)
IF IS_PED_ARMED(PLAYER_PED_ID(), WF_INCLUDE_PROJECTILE|WF_INCLUDE_GUN)
IF IS_VEHICLE_OK(mRoutedVehicle.id)
IF IS_PED_IN_VEHICLE(ped.id, mRoutedVehicle.id)
IF GET_ENTITY_SPEED(mRoutedVehicle.id) > 5
IF type = DRIVER
#IF IS_DEBUG_BUILD SK_PRINT("FLEE 1") #ENDIF
TASK_VEHICLE_MISSION_PED_TARGET(ped.id, mRoutedVehicle.id, PLAYER_PED_ID(), MISSION_FLEE, 30, DRIVINGMODE_AVOIDCARS, 300, 2)
ped.eReactionState = DPRS_REACT_TO_PLAYER_FLEE
TASK_COWER(mPed[GET_THE_OTHER_GUY(type)].id)
mPed[GET_THE_OTHER_GUY(type)].eReactionState = DPRS_WAIT_REACT_TO_PLAYER_COWER
mPed[GET_THE_OTHER_GUY(type)].eControlState = DPCS_REACTING
ped.eControlState = DPCS_REACTING
ped.iReactionTimer = GET_GAME_TIMER()
mPed[GET_THE_OTHER_GUY(type)].iReactionTimer = GET_GAME_TIMER()
ELSE
#IF IS_DEBUG_BUILD SK_PRINT("FLEE 2") #ENDIF
TASK_COWER(ped.id)
ped.eReactionState = DPRS_REACT_TO_PLAYER_COWER
TASK_VEHICLE_MISSION_PED_TARGET(mPed[GET_THE_OTHER_GUY(type)].id, mRoutedVehicle.id, PLAYER_PED_ID(), MISSION_FLEE, 30, DRIVINGMODE_AVOIDCARS, 300, 2)
mPed[GET_THE_OTHER_GUY(type)].eReactionState = DPRS_WAIT_REACT_TO_PLAYER_FLEE
mPed[GET_THE_OTHER_GUY(type)].eControlState = DPCS_REACTING
ped.eControlState = DPCS_REACTING
ped.iReactionTimer = GET_GAME_TIMER()
mPed[GET_THE_OTHER_GUY(type)].iReactionTimer = GET_GAME_TIMER()
ENDIF
ELSE
PICK_FLEE_REACTION(ped)
IF DOES_ENTITY_EXIST(mPed[GET_THE_OTHER_GUY(type)].id)
IF IS_PED_IN_PED_VIEW_CONE(mPed[GET_THE_OTHER_GUY(type)].id, PLAYER_PED_ID())
PICK_FLEE_REACTION(mPed[GET_THE_OTHER_GUY(type)])
CPRINTLN(DEBUG_MISSION, "other guy can see the player threaten the = ", type)
ENDIF
ENDIF
ENDIF
CLEAR_ENTITY_LAST_DAMAGE_ENTITY(ped.id)
ELSE
PICK_FLEE_REACTION(ped)
IF DOES_ENTITY_EXIST(mPed[GET_THE_OTHER_GUY(type)].id)
IF CAN_PED_SEE_PED(mPed[GET_THE_OTHER_GUY(type)].id, ped.id)
PICK_FLEE_REACTION(mPed[GET_THE_OTHER_GUY(type)])
CPRINTLN(DEBUG_MISSION, "other ped can see the player threatening and not in a car = ", type)
ENDIF
ENDIF
ENDIF
ENDIF
ELSE
ped.iReactionTimer = GET_GAME_TIMER()
ped.ePrevDeliverState = ped.eDeliverState
ped.eControlState = DPCS_REACTING
ped.eReactionState = DPRS_WAIT_REACT_BRAWL
CPRINTLN(DEBUG_MISSION, "ped threatened by player without gun = ", type)
CLEAR_ENTITY_LAST_DAMAGE_ENTITY(ped.id)
IF CAN_PED_SEE_PED(mPed[GET_THE_OTHER_GUY(type)].id, ped.id)
mPed[GET_THE_OTHER_GUY(type)].iReactionTimer = GET_GAME_TIMER()
mPed[GET_THE_OTHER_GUY(type)].ePrevDeliverState = ped.eDeliverState
mPed[GET_THE_OTHER_GUY(type)].eControlState = DPCS_REACTING
mPed[GET_THE_OTHER_GUY(type)].eReactionState = DPRS_WAIT_REACT_BRAWL
CLEAR_ENTITY_LAST_DAMAGE_ENTITY(mPed[GET_THE_OTHER_GUY(type)].id)
CPRINTLN(DEBUG_MISSION, "ped can see other ped being threatened without gun = ", type)
ENDIF
ENDIF
ped.eControlState = DPCS_REACTING
ELIF IS_PED_BEING_JACKED(ped.id)
TELL_PED_DROP_BIN_BAG(ped)
TASK_SMART_FLEE_PED(ped.id, PLAYER_PED_ID(), 500, -1, FALSE, TRUE)
ped.eReactionState = DPRS_BEING_JACKED
ped.eControlState = DPCS_REACTING
ped.iReactionTimer = GET_GAME_TIMER()
CPRINTLN(DEBUG_MISSION, "Ped is being jacked = ", type)
ENDIF
IF IS_PED_RAGDOLL(ped.id)
IF IS_ENTITY_ALIVE(mDeliveryPoint[iDeliveryIndex].oiObject)
IF IS_ENTITY_ATTACHED(mDeliveryPoint[iDeliveryIndex].oiObject)
DETACH_ENTITY(mDeliveryPoint[iDeliveryIndex].oiObject, TRUE, FALSE)
APPLY_FORCE_TO_ENTITY_CENTER_OF_MASS(mDeliveryPoint[iDeliveryIndex].oiObject, APPLY_TYPE_IMPULSE, GET_ENTITY_FORWARD_VECTOR(ped.id),0, TRUE, TRUE)
CPRINTLN(DEBUG_MISSION, "Detaching the bin bag = ", type)
ENDIF
ENDIF
ENDIF
ENDIF
IF ped.eControlState <> DPCS_REACTING
IF IS_PED_UNINJURED(mPed[GET_THE_OTHER_GUY(type)].id)
IF IS_PED_BEING_JACKED(mPed[GET_THE_OTHER_GUY(type)].id)
TELL_PED_DROP_BIN_BAG(ped)
CPRINTLN(DEBUG_MISSION, "other guy is being jacked = ", type)
TASK_SMART_FLEE_PED(ped.id, PLAYER_PED_ID(), 120, -1)
// TASK_LEAVE_ANY_VEHICLE(ped.id, 0, ECF_DONT_WAIT_FOR_VEHICLE_TO_STOP)
ped.iReactionTimer = GET_GAME_TIMER()
ped.eReactionState = DPRS_REACT_TO_PLAYER_FLEE
ped.eControlState = DPCS_REACTING
ENDIF
ENDIF
ENDIF
ENDPROC
/// PURPOSE:
/// Checks to see if the player is in the
/// truck while the other ped isn't in (normally the driver)
/// and if they start to drive off
PROC MONITOR_PLAYER_DRIVING_OFF_IN_VAN(PED_STRUCT &ped)
IF IS_VEHICLE_OK(mRoutedVehicle.id)
AND (IS_PED_IN_VEHICLE(PLAYER_PED_ID(), mRoutedVehicle.id)
AND NOT IS_PED_IN_VEHICLE(ped.id, mRoutedVehicle.id))
IF GET_ENTITY_SPEED(mRoutedVehicle.id) > 0
ped.iReactionTimer = GET_GAME_TIMER()
ped.ePrevDeliverState = ped.eDeliverState
ped.eControlState = DPCS_REACTING
ped.eReactionState = DPRS_WAIT_REACT_BRAWL
CPRINTLN(DEBUG_MISSION, "MONITOR_PLAYER_DRIVING_OFF_IN_VAN(), DPRS_WAIT_REACT_BRAWL")
ELSE
CPRINTLN(DEBUG_MISSION, "GET_ENTITY_SPEED(mRoutedVehicle.id)", GET_ENTITY_SPEED(mRoutedVehicle.id))
ENDIF
ELSE
#IF IS_DEBUG_BUILD
IF IS_PED_IN_VEHICLE(PLAYER_PED_ID(), mRoutedVehicle.id)
CPRINTLN(DEBUG_MISSION, "IS_PED_IN_VEHICLE(PLAYER_PED_ID(), mRoutedVehicle.id)")
ENDIF
IF NOT IS_PED_IN_VEHICLE(ped.id, mRoutedVehicle.id)
CPRINTLN(DEBUG_MISSION, "NOT IS_PED_IN_VEHICLE(ped.id, mRoutedVehicle.id)")
ENDIF
#ENDIF
ENDIF
ENDPROC
/// PURPOSE:
/// Checks to see if the play damages the delivery van
/// If they do the ped gets out and turns to the player and plays an angry gesture
/// if the damage is done while the player is armed and shooting then the ped flees
/// [TODO] Need to check for bullet/explosion damage
PROC MONITER_PLAYER_BUMPING_VAN(PED_STRUCT &ped)
IF ped.eControlState <> DPCS_REACTING
IF IS_VEHICLE_OK(mRoutedVehicle.id)
AND IS_PED_IN_ANY_VEHICLE(PLAYER_PED_ID())
IF NOT IsPedPerformingTask(ped.id, SCRIPT_TASK_DRIVE_BY)
AND IS_PED_IN_VEHICLE(ped.id, mRoutedVehicle.id)
IF IS_ENTITY_IN_RANGE_ENTITY(PLAYER_PED_ID(), mRoutedVehicle.id, 10)
IF IS_ENTITY_TOUCHING_ENTITY(mRoutedVehicle.id, PLAYER_PED_ID())
// #IF IS_DEBUG_BUILD SK_PRINT("MONITER_PLAYER_BUMPING_VAN - eDeliveryPed = DPS_REACT_TO_PLAYER_ANGER") #ENDIF
TASK_DRIVE_BY(ped.id, PLAYER_PED_ID(), NULL, <<0,0,0>>, 10, 100, TRUE, FIRING_PATTERN_FULL_AUTO)
ped.iReactionTimer = GET_GAME_TIMER()
ped.eReactionState= DPRS_REACT_TO_PLAYER_ANGER
ENDIF
ENDIF
ENDIF
ENDIF
ENDIF
ENDPROC
PROC TELL_PED_REACT_PLAYER_BLOCKING_DOOR(PED_STRUCT &ped)
#IF IS_DEBUG_BUILD SK_PRINT("ped.eReactionState ===== DPRS_REACT_TO_PLAYER_BLOCKING_DOOR") #ENDIF
SET_RELATIONSHIP_BETWEEN_GROUPS(ACQUAINTANCE_TYPE_PED_HATE, HASH_ENEMIES, RELGROUPHASH_PLAYER)
TELL_PED_DROP_BIN_BAG(ped)
IF NOT IS_PED_IN_ANY_VEHICLE(PLAYER_PED_ID())
IF NOT IS_PED_IN_ANY_VEHICLE(ped.id)
TASK_PUT_PED_DIRECTLY_INTO_MELEE(ped.id, PLAYER_PED_ID(), NORMAL_BLEND_IN, -1, 10)
ELSE
SEQUENCE_INDEX Seq
OPEN_SEQUENCE_TASK(Seq)
TASK_LEAVE_ANY_VEHICLE(NULL)
TASK_COMBAT_PED(NULL, PLAYER_PED_ID())
CLOSE_SEQUENCE_TASK(Seq)
TASK_PERFORM_SEQUENCE(ped.id, Seq)
CLEAR_SEQUENCE_TASK(Seq)
ENDIF
ELSE
SEQUENCE_INDEX Seq
OPEN_SEQUENCE_TASK(Seq)
TASK_TURN_PED_TO_FACE_ENTITY(NULL, PLAYER_PED_ID())
TASK_COMBAT_PED(NULL, PLAYER_PED_ID())
CLOSE_SEQUENCE_TASK(Seq)
TASK_PERFORM_SEQUENCE(ped.id, Seq)
CLEAR_SEQUENCE_TASK(Seq)
ENDIF
RESET_PED_MOVEMENT_CLIPSET(ped.id)
RESET_PED_WEAPON_MOVEMENT_CLIPSET(ped.id)
RESET_SHAPE_TEST()
ped.iReactionTimer = GET_GAME_TIMER()
ped.ePrevDeliverState = ped.eDeliverState
ped.eControlState = DPCS_REACTING
ped.eReactionState = DPRS_REACT_TO_PLAYER_BLOCKING_DOOR
ENDPROC
PROC TELL_PED_REACT_TO_PLAYER_BLOCKING_BINS(PED_STRUCT &ped)
#IF IS_DEBUG_BUILD SK_PRINT("ped.eReactionState ===== DPRS_REACT_TO_PLAYER_BLOCKING_BINS") #ENDIF
SET_RELATIONSHIP_BETWEEN_GROUPS(ACQUAINTANCE_TYPE_PED_HATE, HASH_ENEMIES, RELGROUPHASH_PLAYER)
TELL_PED_DROP_BIN_BAG(ped)
IF NOT IS_PED_IN_ANY_VEHICLE(PLAYER_PED_ID())
IF NOT IS_PED_IN_ANY_VEHICLE(ped.id)
TASK_PUT_PED_DIRECTLY_INTO_MELEE(ped.id, PLAYER_PED_ID(), NORMAL_BLEND_IN, -1, 10)
ELSE
SEQUENCE_INDEX Seq
OPEN_SEQUENCE_TASK(Seq)
TASK_LEAVE_ANY_VEHICLE(NULL)
TASK_COMBAT_PED(NULL, PLAYER_PED_ID())
CLOSE_SEQUENCE_TASK(Seq)
TASK_PERFORM_SEQUENCE(ped.id, Seq)
CLEAR_SEQUENCE_TASK(Seq)
ENDIF
ELSE
SEQUENCE_INDEX Seq
OPEN_SEQUENCE_TASK(Seq)
TASK_TURN_PED_TO_FACE_ENTITY(NULL, PLAYER_PED_ID())
TASK_COMBAT_PED(NULL, PLAYER_PED_ID())
CLOSE_SEQUENCE_TASK(Seq)
TASK_PERFORM_SEQUENCE(ped.id, Seq)
CLEAR_SEQUENCE_TASK(Seq)
ENDIF
RESET_PED_MOVEMENT_CLIPSET(ped.id)
RESET_PED_WEAPON_MOVEMENT_CLIPSET(ped.id)
RESET_SHAPE_TEST()
IF NOT DOES_BLIP_EXIST(ped.blip)
ped.blip = CREATE_BLIP_FOR_PED(ped.id, TRUE)
ENDIF
ped.iReactionTimer = GET_GAME_TIMER()
ped.ePrevDeliverState = ped.eDeliverState
ped.eControlState = DPCS_REACTING
ped.eReactionState = DPRS_REACT_TO_PLAYER_BLOCKING_BINS
ENDPROC
PROC TELL_PED_REACT_TO_PLAYER_BLOCKING_BAC_OF_TRUCK(PED_STRUCT &ped)
#IF IS_DEBUG_BUILD SK_PRINT("ped.eReactionState ===== DPRS_REACT_TO_PLAYER_BLOCKING_BAC_OF_TRUCK") #ENDIF
SET_RELATIONSHIP_BETWEEN_GROUPS(ACQUAINTANCE_TYPE_PED_HATE, HASH_ENEMIES, RELGROUPHASH_PLAYER)
TELL_PED_DROP_BIN_BAG(ped)
IF NOT IS_PED_IN_ANY_VEHICLE(PLAYER_PED_ID())
IF NOT IS_PED_IN_ANY_VEHICLE(ped.id)
TASK_PUT_PED_DIRECTLY_INTO_MELEE(ped.id, PLAYER_PED_ID(), NORMAL_BLEND_IN, -1, 10)
ELSE
SEQUENCE_INDEX Seq
OPEN_SEQUENCE_TASK(Seq)
TASK_LEAVE_ANY_VEHICLE(NULL)
TASK_COMBAT_PED(NULL, PLAYER_PED_ID())
CLOSE_SEQUENCE_TASK(Seq)
TASK_PERFORM_SEQUENCE(ped.id, Seq)
CLEAR_SEQUENCE_TASK(Seq)
ENDIF
ELSE
SEQUENCE_INDEX Seq
OPEN_SEQUENCE_TASK(Seq)
TASK_TURN_PED_TO_FACE_ENTITY(NULL, PLAYER_PED_ID())
TASK_COMBAT_PED(NULL, PLAYER_PED_ID())
CLOSE_SEQUENCE_TASK(Seq)
TASK_PERFORM_SEQUENCE(ped.id, Seq)
CLEAR_SEQUENCE_TASK(Seq)
ENDIF
RESET_PED_MOVEMENT_CLIPSET(ped.id)
RESET_PED_WEAPON_MOVEMENT_CLIPSET(ped.id)
RESET_SHAPE_TEST()
IF NOT DOES_BLIP_EXIST(ped.blip)
ped.blip = CREATE_BLIP_FOR_PED(ped.id, TRUE)
ENDIF
ped.iReactionTimer = GET_GAME_TIMER()
ped.ePrevDeliverState = ped.eDeliverState
ped.eControlState = DPCS_REACTING
ped.eReactionState = DPRS_REACT_TO_PLAYER_BLOCKING_BAC_OF_TRUCK
ENDPROC
PROC OPEN_TRUCK_BOOT()
IF fTruckBootOpenRatio != 1.0
IF IS_VEHICLE_OK(mRoutedVehicle.id)
SET_VEHICLE_DOOR_CONTROL(mRoutedVehicle.id, SC_DOOR_BOOT, DT_DOOR_INTACT, fTruckBootOpenRatio)
fTruckBootOpenRatio = fTruckBootOpenRatio +@ 0.1
// #IF IS_DEBUG_BUILD
// SK_PRINT_FLOAT("OPEN_TRUCK_BOOT = ", fTruckBootOpenRatio)
// #ENDIF
IF fTruckBootOpenRatio >= 1.0
SET_VEHICLE_DOOR_OPEN(mRoutedVehicle.id, SC_DOOR_BOOT)
fTruckBootOpenRatio = 1.0
ENDIF
ENDIF
ENDIF
ENDPROC
PROC CLOSE_TRUCK_BOOT()
IF fTruckBootOpenRatio != 0.0
SET_VEHICLE_DOOR_CONTROL(mRoutedVehicle.id, SC_DOOR_BOOT, DT_DOOR_INTACT, fTruckBootOpenRatio)
fTruckBootOpenRatio = fTruckBootOpenRatio -@ 0.1
// #IF IS_DEBUG_BUILD
//// SK_PRINT_FLOAT("CLOSE_TRUCK_BOOT = ", fTruckBootOpenRatio)
// #ENDIF
IF fTruckBootOpenRatio <= 0.0
SET_VEHICLE_DOOR_SHUT(mRoutedVehicle.id, SC_DOOR_BOOT, FALSE)
fTruckBootOpenRatio = 0.0
ENDIF
ENDIF
ENDPROC
PROC DELIVERY_SUBSTATES(PED_STRUCT &ped)
IF ped.eDeliverSubState >= SDS_WALKING_TO_BAG
AND ped.eDeliverSubState != SDS_NULL
// OPEN_TRUCK_BOOT()
ENDIF
SWITCH ped.eDeliverSubState
CASE SDS_WALKING_TO_BAG
IF NOT IsPedPerformingTask(ped.id, SCRIPT_TASK_GOTO_ENTITY_OFFSET)
SEQUENCE_INDEX Seq
OPEN_SEQUENCE_TASK(Seq)
IF GET_HEADING_BETWEEN_VECTORS(GET_ENTITY_COORDS(ped.id), mDeliveryPoint[iDeliveryIndex].vPedSpawn) > 1.5
TASK_TURN_PED_TO_FACE_COORD(NULL, mDeliveryPoint[iDeliveryIndex].vPedSpawn)
ENDIF
TASK_PLAY_ANIM(NULL, "missfbi4prepp1", "_bag_pickup_garbage_man", NORMAL_BLEND_IN, FAST_BLEND_OUT, -1, AF_USE_MOVER_EXTRACTION|AF_EXTRACT_INITIAL_OFFSET)
CLOSE_SEQUENCE_TASK(Seq)
TASK_PERFORM_SEQUENCE(ped.id, Seq)
CLEAR_SEQUENCE_TASK(Seq)
#IF IS_DEBUG_BUILD SK_PRINT("Finished getting out of vehicle picking up bin bag") #ENDIF
ped.eDeliverSubState = SDS_PICK_UP_BIN_BAG
ELSE
IF IS_GOTO_BLOCKED(mDeliveryPoint[iDeliveryIndex].vPedSpawn, ped.id, <<1,1,8>>)
TELL_PED_REACT_TO_PLAYER_BLOCKING_BINS(ped)
EXIT
ENDIF
ENDIF
SET_PED_CAPSULE(ped.id, 0.2)
BREAK
CASE SDS_PICK_UP_BIN_BAG
IF IsPedPerformingTask(ped.id, SCRIPT_TASK_PERFORM_SEQUENCE)
IF IS_ENTITY_PLAYING_ANIM(ped.id, "missfbi4prepp1", "_bag_pickup_garbage_man")
IF GET_ENTITY_ANIM_CURRENT_TIME(ped.id, "missfbi4prepp1", "_bag_pickup_garbage_man") >= 0.333
SET_PED_MOVEMENT_CLIPSET(ped.id, "missfbi4prepp1_garbageman", INSTANT_BLEND_DURATION)
SET_PED_WEAPON_MOVEMENT_CLIPSET(ped.id, "missfbi4prepp1_garbageman")
IF IS_ENTITY_ALIVE(mDeliveryPoint[iDeliveryIndex].oiObject)
AND NOT IS_ENTITY_ATTACHED(mDeliveryPoint[iDeliveryIndex].oiObject)
#IF IS_DEBUG_BUILD SK_PRINT("Attaching bin bag to Right hand") #ENDIF
ATTACH_ENTITY_TO_ENTITY(mDeliveryPoint[iDeliveryIndex].oiObject, ped.id, GET_PED_BONE_INDEX(ped.id, BONETAG_PH_R_HAND), <<0,0,0>>, <<0,0,0>>, TRUE, TRUE)
ENDIF
ENDIF
ENDIF
IF IS_GOTO_BLOCKED(mDeliveryPoint[iDeliveryIndex].vPedSpawn, ped.id, <<1,1,8>>)
TELL_PED_REACT_TO_PLAYER_BLOCKING_BINS(ped)
EXIT
ENDIF
ELSE
IF NOT IsPedPerformingTask(ped.id, SCRIPT_TASK_FOLLOW_NAV_MESH_TO_COORD)
#IF IS_DEBUG_BUILD SK_PRINT("bag picked up changing substate to walk to back of truck") #ENDIF
IF IS_VEHICLE_OK(mRoutedVehicle.id)
// TASK_PLAY_ANIM(ped.id, "missfbi4prepp1", "_bag_walk_garbage_man", INSTANT_BLEND_IN, NORMAL_BLEND_OUT, -1, AF_UPPERBODY|AF_SECONDARY|AF_LOOPING)
TASK_FOLLOW_NAV_MESH_TO_COORD(ped.id, GET_OFFSET_FROM_ENTITY_IN_WORLD_COORDS(mRoutedVehicle.id, <<0,-4.8,0>>), PEDMOVEBLENDRATIO_WALK, DEFAULT_TIME_NEVER_WARP, DEFAULT_NAVMESH_RADIUS, ENAV_DEFAULT, GET_ENTITY_HEADING(mRoutedVehicle.id))
ENDIF
ped.eDeliverSubState = SDS_WALK_TO_BACK_OF_TRUCK
ENDIF
ENDIF
SET_PED_CAPSULE(ped.id, 0.2)
BREAK
CASE SDS_WALK_TO_BACK_OF_TRUCK
IF IS_VEHICLE_OK(mRoutedVehicle.id)
IF NOT IS_GOTO_BLOCKED(GET_OFFSET_FROM_ENTITY_IN_WORLD_COORDS(mRoutedVehicle.id, <<0, -5.5, 0>>), mRoutedVehicle.id, <<1.9,1.9,8>>)
IF IS_ENTITY_AT_COORD(ped.id, GET_OFFSET_FROM_ENTITY_IN_WORLD_COORDS(mRoutedVehicle.id, <<0, -5.5, 0>>), <<0.9,0.9,2>>)
IF NOT IsPedPerformingTask(ped.id, SCRIPT_TASK_FOLLOW_NAV_MESH_TO_COORD)
#IF IS_DEBUG_BUILD SK_PRINT("Reached back of truck start throw bag seq") #ENDIF
// CLEAR_PED_SECONDARY_TASK(ped.id)
SEQUENCE_INDEX Seq
OPEN_SEQUENCE_TASK(Seq)
IF GET_HEADING_BETWEEN_VECTORS(GET_ENTITY_COORDS(ped.id), GET_ENTITY_COORDS(mRoutedVehicle.id)) > 3.0
TASK_ACHIEVE_HEADING(NULL, GET_ENTITY_HEADING(mRoutedVehicle.id))
ENDIF
TASK_PLAY_ANIM(NULL, "missfbi4prepp1", "_bag_throw_garbage_man")
CLOSE_SEQUENCE_TASK(Seq)
TASK_PERFORM_SEQUENCE(ped.id, Seq)
CLEAR_SEQUENCE_TASK(Seq)
#IF IS_DEBUG_BUILD SK_PRINT("Clearing alt walk anim override") #ENDIF
ped.eDeliverSubState = SDS_THROW_BAG_IN_TO_TRUCK
ENDIF
ELSE
IF NOT IsPedPerformingTask(ped.id, SCRIPT_TASK_FOLLOW_NAV_MESH_TO_COORD)
TASK_FOLLOW_NAV_MESH_TO_COORD(ped.id, GET_OFFSET_FROM_ENTITY_IN_WORLD_COORDS(mRoutedVehicle.id, <<0,-4.8,0>>), PEDMOVEBLENDRATIO_WALK, DEFAULT_TIME_NEVER_WARP, DEFAULT_NAVMESH_RADIUS, ENAV_DEFAULT, GET_ENTITY_HEADING(mRoutedVehicle.id))
ENDIF
ENDIF
ELSE
TELL_PED_REACT_TO_PLAYER_BLOCKING_BAC_OF_TRUCK(ped)
ENDIF
ENDIF
BREAK
CASE SDS_THROW_BAG_IN_TO_TRUCK
IF NOT IS_GOTO_BLOCKED(GET_OFFSET_FROM_ENTITY_IN_WORLD_COORDS(mRoutedVehicle.id, <<0, -5.5, 0>>), ped.id, <<1.9,1.9,8>>)
IF IsPedPerformingTask(ped.id, SCRIPT_TASK_PERFORM_SEQUENCE)
IF IS_ENTITY_PLAYING_ANIM(ped.id, "missfbi4prepp1", "_bag_throw_garbage_man")
IF GET_ENTITY_ANIM_CURRENT_TIME(ped.id, "missfbi4prepp1", "_bag_throw_garbage_man") >= 0.391
IF IS_ENTITY_ALIVE(mDeliveryPoint[iDeliveryIndex].oiObject)
IF IS_ENTITY_ATTACHED(mDeliveryPoint[iDeliveryIndex].oiObject)
RESET_PED_MOVEMENT_CLIPSET(ped.id)
RESET_PED_WEAPON_MOVEMENT_CLIPSET(ped.id)
#IF IS_DEBUG_BUILD SK_PRINT("Detaching bin bag") #ENDIF
DETACH_ENTITY(mDeliveryPoint[iDeliveryIndex].oiObject, TRUE, FALSE)
SET_OBJECT_PHYSICS_PARAMS(mDeliveryPoint[iDeliveryIndex].oiObject, 2, -1, <<-1,-1,-1>>, <<-1,-1,-1>>)
APPLY_FORCE_TO_ENTITY_CENTER_OF_MASS(mDeliveryPoint[iDeliveryIndex].oiObject, APPLY_TYPE_IMPULSE, GET_ENTITY_FORWARD_VECTOR(ped.id),0, TRUE, TRUE)
ENDIF
IF IS_ENTITY_TOUCHING_ENTITY(mDeliveryPoint[iDeliveryIndex].oiObject, mRoutedVehicle.id)
SAFE_DELETE_OBJECT(mDeliveryPoint[iDeliveryIndex].oiObject)
ENDIF
ENDIF
ENDIF
ENDIF
ELSE
#IF IS_DEBUG_BUILD SK_PRINT("Reactivating ped") #ENDIF
ped.eDeliverSubState = SDS_NULL
IF IS_VEHICLE_OK(mRoutedVehicle.id)
SET_VEHICLE_DOOR_SHUT(mRoutedVehicle.id, SC_DOOR_BOOT, FALSE)
SAFE_DELETE_OBJECT(mDeliveryPoint[iDeliveryIndex].oiObject)
ENDIF
REACTIVATE_PED(ped)
ENDIF
ELSE
TELL_PED_REACT_TO_PLAYER_BLOCKING_BAC_OF_TRUCK(ped)
ENDIF
BREAK
CASE SDS_DROP_BAG
BREAK
ENDSWITCH
ENDPROC
PROC MONITOR_DRIVER_DOOR_BLOCKED(PED_STRUCT &ped)
IF IS_PED_IN_ANY_VEHICLE(PLAYER_PED_ID())
VEHICLE_INDEX Veh
Veh = GET_VEHICLE_PED_IS_IN(PLAYER_PED_ID())
IF IS_VEHICLE_OK(Veh)
IF NOT IS_ENTRY_POINT_FOR_SEAT_CLEAR(ped.id, Veh, VS_DRIVER)
ped.eReactionState = DPRS_WAIT_FLIM_BLOCKING
ped.iReactionTimer = GET_GAME_TIMER()
ENDIF
ENDIF
ENDIF
ENDPROC
PROC WAIT_PED_AT_VAN_DOOR(PED_STRUCT &ped, BOOL bDriver = FALSE)
IF IS_GOTO_BLOCKED(GET_OFFSET_FROM_ENTITY_IN_WORLD_COORDS(mRoutedVehicle.id, GET_ENTRYPOINT_AREA_OFFSET(bDriver)), mRoutedVehicle.id, <<1.9,1.9,8>>)
IF IS_ENTITY_IN_ANGLED_AREA(ped.id, GET_OFFSET_FROM_ENTITY_IN_WORLD_COORDS(mRoutedVehicle.id, <<5, 0, -2>>), (GET_ENTITY_COORDS(mRoutedVehicle.id)+ <<0,0,2>>), 9)
AND IS_ENTITY_IN_ANGLED_AREA(PLAYER_PED_ID(), GET_OFFSET_FROM_ENTITY_IN_WORLD_COORDS(mRoutedVehicle.id, <<5, 0, -2>>), (GET_ENTITY_COORDS(mRoutedVehicle.id)+ <<0,0,2>>), 9)
TELL_PED_REACT_PLAYER_BLOCKING_DOOR(ped)
ELSE
IF NOT IsPedPerformingTask(ped.id, SCRIPT_TASK_GO_TO_ENTITY)
AND IS_ENTITY_IN_ANGLED_AREA(PLAYER_PED_ID(), GET_OFFSET_FROM_ENTITY_IN_WORLD_COORDS(mRoutedVehicle.id, <<5, 0, -2>>), (GET_ENTITY_COORDS(mRoutedVehicle.id)+ <<0,0,2>>), 9)
CLEAR_PED_TASKS(ped.id)
TASK_GO_TO_ENTITY(ped.id, PLAYER_PED_ID(), DEFAULT_TIME_NEVER_WARP, 4, PEDMOVEBLENDRATIO_WALK)
ENDIF
ENDIF
ELSE
IF IS_ENTITY_IN_RANGE_COORDS(ped.id, GET_OFFSET_FROM_ENTITY_IN_WORLD_COORDS(mRoutedVehicle.id, GET_ENTRYPOINT_AREA_OFFSET(bDriver)), 5)
#IF IS_DEBUG_BUILD SK_PRINT(" WAIT_PED_AT_VAN_DOOR Tasking ped to enter vehicle") #ENDIF
VEHICLE_SEAT v = VS_DRIVER
IF NOT bDriver
v = VS_FRONT_RIGHT
ENDIF
TASK_ENTER_VEHICLE(ped.id, mRoutedVehicle.id, -1, v, PEDMOVEBLENDRATIO_WALK, ECF_DONT_JACK_ANYONE|ECF_RESUME_IF_INTERRUPTED)
//EPREVPASSENGERPED = ePassengerPed
ped.eDeliverState = DPDS_ENTER_VAN
ENDIF
ENDIF
ENDPROC
PROC DO_DELIVERIES(PED_STRUCT &ped)
IF ped.eDeliverSubState = SDS_NULL
AND ped.eDeliverPedType = PASSENGER
// CLOSE_TRUCK_BOOT()
ENDIF
SWITCH ped.eDeliverState
CASE DPDS_WALKING_TO_VAN_DOOR
IF IS_PED_IN_VEHICLE(PLAYER_PED_ID(), mRoutedVehicle.id, TRUE)
PICK_FLEE_REACTION(ped)
#IF IS_DEBUG_BUILD SK_PRINT("Player is in vehicle Picked flee reaction") #ENDIF
EXIT
ENDIF
IF ped.eDeliverPedType = DRIVER
WAIT_PED_AT_VAN_DOOR(ped, TRUE)
ELSE
WAIT_PED_AT_VAN_DOOR(ped, FALSE)
ENDIF
BREAK
CASE DPDS_ENTER_VAN
IF IS_PED_SITTING_IN_VEHICLE(ped.id, mRoutedVehicle.id)
IF NOT IsPedPerformingTask(ped.id, SCRIPT_TASK_ENTER_VEHICLE)
IF ped.eDeliverPedType = DRIVER
TELL_DRIVER_PED_DRIVE_TO_DELIVERY_POINT()
ELSE
ped.eDeliverState = DPDS_WAITING_IN_VAN
ENDIF
ENDIF
ELSE
IF IS_PED_IN_VEHICLE(PLAYER_PED_ID(), mRoutedVehicle.id, TRUE)
PICK_FLEE_REACTION(ped)
#IF IS_DEBUG_BUILD SK_PRINT("Player is in vehicle Picked flee reaction") #ENDIF
EXIT
ENDIF
ENDIF
BREAK
CASE DPDS_WAITING_IN_VAN
IF IS_PED_IN_VEHICLE(PLAYER_PED_ID(), mRoutedVehicle.id, TRUE)
PICK_FLEE_REACTION(ped)
#IF IS_DEBUG_BUILD SK_PRINT("Player is in vehicle Picked flee reaction") #ENDIF
EXIT
ENDIF
IF bPassengerDoDeliveries
IF iDeliveryIndex <= MAX_DELIVERIES-1
AND iDeliveryIndex != -1
IF NOT mDeliveryPoint[iDeliveryIndex].bDelivered
IF IS_ENTITY_IN_RANGE_COORDS(ped.id, mDeliveryPoint[iDeliveryIndex].vDriveTo, 20)
#IF IS_DEBUG_BUILD SK_PRINT("ped.ePrevDeliverState ===== DPDS_WAITING_IN_VAN") #ENDIF
IF mDeliveryPoint[iDeliveryIndex].bDoActionAtDeliveryPoint
AND IS_VEHICLE_STOPPED(mRoutedVehicle.id)
TELL_PASSENGER_PED_TO_MAKE_DELIVERY()
ENDIF
ENDIF
ENDIF
ELSE
ped.eDeliverState = DPDS_WANDERING
ENDIF
ENDIF
BREAK
CASE DPDS_DRIVE_TO_DELIVERY_POINT
#IF IS_DEBUG_BUILD
IF bShowDeliveryDebugText
// DRAW_DEBUG_SPHERE(mDeliveryPoint[iDeliveryIndex].vDriveTo, 25, 0, 255, 0, 100)
ENDIF
#ENDIF
IF IS_ENTITY_IN_RANGE_COORDS(ped.id, mDeliveryPoint[iDeliveryIndex].vDriveTo, 25)
#IF IS_DEBUG_BUILD SK_PRINT("ped.ePrevDeliverState ===== DPDS_DRIVE_TO_DELIVERY_POINT") #ENDIF
IF mDeliveryPoint[iDeliveryIndex].bDoActionAtDeliveryPoint
TELL_DRIVER_PED_PULLOVER(ped)
// ped.eDeliverState = DPDS_BREAKING
ELSE
mDeliveryPoint[iDeliveryIndex].bDelivered = TRUE
TELL_DRIVER_PED_DRIVE_TO_DELIVERY_POINT()
ENDIF
ENDIF
BREAK
CASE DPDS_BREAKING
IF IS_VEHICLE_OK(mRoutedVehicle.id)
BRING_VEHICLE_TO_HALT(mRoutedVehicle.id, 25, 10)
FLOAT fSpeed
fSpeed = GET_ENTITY_SPEED(mRoutedVehicle.id)
#IF IS_DEBUG_BUILD SK_PRINT_FLOAT("fSpeed = = = = = ", fSpeed) #ENDIF
IF fSpeed < 8
#IF IS_DEBUG_BUILD SK_PRINT_FLOAT("fSpeed < 8 --- fSpeed = = = = = ", fSpeed) #ENDIF
TELL_DRIVER_PED_PULLOVER(ped)
ENDIF
ENDIF
BREAK
CASE DPDS_PULLINGOVER
#IF IS_DEBUG_BUILD
IF bShowDeliveryDebugText
// DRAW_DEBUG_SPHERE(mDeliveryPoint[iDeliveryIndex].vParkingVec, 5, 255, 0, 0, 100)
ENDIF
#ENDIF
IF NOT IsPedPerformingTask(ped.id, SCRIPT_TASK_PERFORM_SEQUENCE)
AND IS_VEHICLE_STOPPED(mRoutedVehicle.id)
// AND IS_ENTITY_IN_RANGE_COORDS(mRoutedVehicle.id, mDeliveryPoint[iDeliveryIndex].vParkingVec, 5)
// #IF IS_DEBUG_BUILD SAFE_REMOVE_BLIP(DebugBlip) #ENDIF
#IF IS_DEBUG_BUILD SK_PRINT("ped.ePrevDeliverState ===== DPDS_PULLINGOVER") #ENDIF
IF bPassengerDoDeliveries
ped.ePrevDeliverState = ped.eDeliverState
ped.eDeliverState = DPDS_WAIT_PASSENGER_DELIVER
ELSE
TASK_LEAVE_ANY_VEHICLE(ped.id)
ped.ePrevDeliverState = ped.eDeliverState
ped.eDeliverState = DPDS_EXIT_VAN_DELIVER
ENDIF
ENDIF
BREAK
CASE DPDS_WAIT_PASSENGER_DELIVER
IF IS_PED_UNINJURED(mPed[PASSENGER].id)
IF IS_PED_IN_VEHICLE(mPed[PASSENGER].id, mRoutedVehicle.id)
AND mPed[PASSENGER].eDeliverState = DPDS_WAITING_IN_VAN
#IF IS_DEBUG_BUILD SK_PRINT("ped.ePrevDeliverState ===== DPDS_EXIT_VAN_DELIVER") #ENDIF
TELL_DRIVER_PED_DRIVE_TO_DELIVERY_POINT()
ENDIF
ENDIF
BREAK
CASE DPDS_EXIT_VAN_DELIVER
IF NOT IS_PED_IN_VEHICLE(ped.id, mRoutedVehicle.id)
TELL_PED_TO_MAKE_DELIVERY(ped)
ENDIF
BREAK
CASE DPDS_MAKE_DELIVERY
DELIVERY_SUBSTATES(ped)
// IF NOT IsPedPerformingTask(ped.id, SCRIPT_TASK_PERFORM_SEQUENCE)
//// mDeliveryPoint[iDeliveryIndex].bDelivered = TRUE
//// REACTIVATE_PED(ped)
// ELSE
// IF (GET_GAME_TIMER() - ped.iReactionTimer) > ped.iReactionDelay
// IF IS_ENTITY_AT_COORD(PLAYER_PED_ID(), mDeliveryPoint[iDeliveryIndex].vPedSpawn, <<2,2,2>>)
// TELL_PED_REACT_TO_PLAYER_BLOCKING_BINS(ped)
// ENDIF
// ENDIF
// ENDIF
BREAK
ENDSWITCH
ENDPROC
PROC DO_REACTIONS(PED_STRUCT &ped)
SWITCH ped.eReactionState
CASE DPRS_WAIT_REACT_TO_PLAYER_FLEE
IF (GET_GAME_TIMER() - ped.iReactionTimer) > ped.iQuickReactionDelay
IF IsPedPerformingTask(ped.id, SCRIPT_TASK_COMBAT)
CLEAR_PED_TASKS(ped.id)
ENDIF
#IF IS_DEBUG_BUILD SK_PRINT("Setting state to initial flee state") #ENDIF
TASK_SMART_FLEE_PED(ped.id, PLAYER_PED_ID(), 30, -1, FALSE)
ped.eReactionState = DPRS_REACT_TO_PLAYER_INITAL_FLEE
ped.iReactionTimer = GET_GAME_TIMER()
ENDIF
BREAK
CASE DPRS_WAIT_REACT_BRAWL
IF IS_PED_ARMED(PLAYER_PED_ID(), WF_INCLUDE_GUN|WF_INCLUDE_PROJECTILE)
IF CAN_PED_SEE_PED(ped.id, PLAYER_PED_ID())
PICK_FLEE_REACTION(ped, TRUE)
#IF IS_DEBUG_BUILD SK_PRINT("player is armed flee 1") #ENDIF
EXIT
ENDIF
ENDIF
IF (GET_GAME_TIMER() - ped.iReactionTimer) > ped.iQuickReactionDelay
IF NOT IS_PED_IN_ANY_VEHICLE(ped.id)
TASK_PUT_PED_DIRECTLY_INTO_MELEE(ped.id, PLAYER_PED_ID(), NORMAL_BLEND_IN, -1, 10)
ELSE
SEQUENCE_INDEX Seq
OPEN_SEQUENCE_TASK(Seq)
TASK_LEAVE_ANY_VEHICLE(NULL)
TASK_COMBAT_PED(NULL, PLAYER_PED_ID())
CLOSE_SEQUENCE_TASK(Seq)
TASK_PERFORM_SEQUENCE(ped.id, Seq)
CLEAR_SEQUENCE_TASK(Seq)
ENDIF
IF NOT DOES_BLIP_EXIST(ped.blip)
ped.blip = CREATE_BLIP_FOR_PED(ped.id, TRUE)
ENDIF
#IF IS_DEBUG_BUILD SK_PRINT("setting combat task") #ENDIF
ped.eReactionState = DPRS_REACT_BRAWL
ped.iReactionTimer = GET_GAME_TIMER()
ENDIF
BREAK
CASE DPRS_WAIT_REACT_TO_PLAYER_COWER
IF (GET_GAME_TIMER() - ped.iReactionTimer) > ped.iQuickReactionDelay
IF IS_PED_IN_ANY_VEHICLE(ped.id)
SET_PED_RESET_FLAG(ped.id, PRF_PanicInVehicle, TRUE)
ped.eReactionState = DPRS_REACT_TO_PLAYER_COWER
ped.iReactionTimer = GET_GAME_TIMER()
ELSE
#IF IS_DEBUG_BUILD SK_PRINT("PICK_FLEE_REACTION = TGS_COWER") #ENDIF
IF NOT IsPedPerformingTask(ped.id, SCRIPT_TASK_COWER)
IF IsPedPerformingTask(ped.id, SCRIPT_TASK_COMBAT)
CLEAR_PED_TASKS(ped.id)
ENDIF
TASK_COWER(ped.id)
ped.eReactionState = DPRS_REACT_TO_PLAYER_COWER
ped.iReactionTimer = GET_GAME_TIMER()
ENDIF
ENDIF
ENDIF
BREAK
CASE DPRS_WAIT_RING_COPS
IF (GET_GAME_TIMER() - ped.iReactionTimer) > ped.iQuickReactionDelay
TASK_USE_MOBILE_PHONE(ped.id, TRUE)
TASK_SMART_FLEE_PED(ped.id, PLAYER_PED_ID(), 500, -1, FALSE, TRUE)
CPRINTLN(DEBUG_MISSION, "ped Will now ring cops = ", ped.eDeliverPedType)
ped.iReactionTimer = GET_GAME_TIMER()
ped.eReactionState = DPRS_RING_COPS
ped.eControlState = DPCS_REACTING
ENDIF
BREAK
CASE DPRS_WAIT_REACT_SEARCH
MONITOR_PLAYER_DRIVING_OFF_IN_VAN(ped)
IF (GET_GAME_TIMER() - ped.iReactionTimer) > 5000
IF NOT IsPedPerformingTask(ped.id, SCRIPT_TASK_FOLLOW_NAV_MESH_TO_COORD)
IF DOES_ENTITY_EXIST(mPed[GET_THE_OTHER_GUY(ped.eDeliverPedType)].id)
TASK_FOLLOW_NAV_MESH_TO_COORD(ped.id, vSearchPos, PEDMOVEBLENDRATIO_WALK,DEFAULT_TIME_NEVER_WARP, 2)
ENDIF
ENDIF
CPRINTLN(DEBUG_MISSION, "ped Will search for friend = ", ped.eDeliverPedType)
ped.iReactionTimer = GET_GAME_TIMER()
ped.eReactionState = DPRS_REACT_SEARCH
ped.eControlState = DPCS_REACTING
ENDIF
BREAK
CASE DPRS_WAIT_FLIM_BLOCKING
IF NOT IsPedPerformingTask(ped.id, SCRIPT_TASK_PLAY_ANIM)
CPRINTLN(DEBUG_MISSION, "ped Will now film player = ", ped.eDeliverPedType)
SEQUENCE_INDEX Seq
OPEN_SEQUENCE_TASK(Seq)
IF GET_HEADING_BETWEEN_VECTORS(GET_ENTITY_COORDS(ped.id), GET_ENTITY_COORDS(PLAYER_PED_ID())) > 1.5
TASK_TURN_PED_TO_FACE_COORD(NULL, GET_ENTITY_COORDS(PLAYER_PED_ID()))
ENDIF
TASK_START_SCENARIO_IN_PLACE( NULL, "WORLD_HUMAN_MOBILE_FILM_SHOCKING", 6000, TRUE )
CLOSE_SEQUENCE_TASK(Seq)
TASK_PERFORM_SEQUENCE(ped.id, Seq)
CLEAR_SEQUENCE_TASK(Seq)
ped.eControlState = DPCS_REACTING
ped.eReactionState = DPRS_REACT_FLIM
ped.iReactionTimer = GET_GAME_TIMER()
ENDIF
BREAK
CASE DPRS_WAIT_FLIM_DEAD
MONITOR_PLAYER_DRIVING_OFF_IN_VAN(ped)
IF NOT IsPedPerformingTask(ped.id, SCRIPT_TASK_PLAY_ANIM)
CPRINTLN(DEBUG_MISSION, "ped Will now film dead ped = ", ped.eDeliverPedType)
TASK_START_SCENARIO_IN_PLACE( ped.id, "WORLD_HUMAN_MOBILE_FILM_SHOCKING", 6000, TRUE )
ped.eControlState = DPCS_REACTING
ped.eReactionState = DPRS_REACT_FLIM
ped.iReactionTimer = GET_GAME_TIMER()
ENDIF
BREAK
CASE DPRS_EXIT_VAN_FLEE
IF NOT IS_PED_IN_VEHICLE(ped.id, mRoutedVehicle.id)
TELL_PED_RING_COPS(ped)
ENDIF
BREAK
CASE DPRS_BEING_JACKED
IF NOT IS_PED_SITTING_IN_ANY_VEHICLE(ped.id)
AND (GET_GAME_TIMER() - ped.iReactionTimer) > 3000
// AND NOT GET_IS_TASK_ACTIVE(mPed[DRIVER].id, CODE_TASK_EXIT_VEHICLE)
TELL_PED_RING_COPS(ped)
ENDIF
BREAK
CASE DPRS_RING_COPS
IF (GET_GAME_TIMER() - ped.iReactionTimer) > 8000
TASK_SMART_FLEE_PED(ped.id, PLAYER_PED_ID(), 500, -1)
IF NOT bWantedLevelSet
IF GET_PLAYER_WANTED_LEVEL(PLAYER_ID()) = 0
SET_PLAYER_WANTED_LEVEL(PLAYER_ID(), 2)
SET_PLAYER_WANTED_LEVEL_NOW(PLAYER_ID())
bWantedLevelSet = TRUE
CPRINTLN(DEBUG_MISSION, "Giving player 2 star wanted script = ", GET_THIS_SCRIPT_NAME())
ENDIF
ENDIF
TASK_USE_MOBILE_PHONE(ped.id, FALSE)
ped.iReactionTimer = GET_GAME_TIMER()
ped.eReactionState = DPRS_FLEE_AFTER_RINGING_COPS
ELSE
IF GET_PLAYER_WANTED_LEVEL(PLAYER_ID()) > 1
TASK_USE_MOBILE_PHONE(ped.id, FALSE)
ped.iReactionTimer = GET_GAME_TIMER()
ped.eReactionState = DPRS_FLEE_AFTER_RINGING_COPS
ENDIF
ENDIF
BREAK
CASE DPRS_REACT_TO_PLAYER_INITAL_FLEE
IF (GET_GAME_TIMER() - ped.iReactionTimer) > ped.iReactionDelay
IF NOT IS_ENTITY_IN_RANGE_ENTITY(ped.id, PLAYER_PED_ID(), 15)
#IF IS_DEBUG_BUILD SK_PRINT("ped out of range set to normal flee state") #ENDIF
SAFE_REMOVE_BLIP(ped.blip)
ped.eReactionState = DPRS_REACT_TO_PLAYER_FLEE
ped.iReactionTimer = GET_GAME_TIMER()
ENDIF
ENDIF
BREAK
CASE DPRS_REACT_TO_PLAYER_FLEE
IF IS_PED_IN_VEHICLE(ped.id, mRoutedVehicle.id, TRUE)
IF ped.eReactionState <> DPRS_RING_COPS
AND ped.eReactionState <> DPRS_EXIT_VAN_FLEE
IF MONITER_PLAYER_DAMAGING_ROUTE_CAR()
IF IS_PED_UNINJURED(ped.id)
CLEAR_PED_TASKS(ped.id)
TASK_SMART_FLEE_PED(ped.id, PLAYER_PED_ID(), 500, -1, FALSE, TRUE)
ped.eReactionState = DPRS_EXIT_VAN_FLEE
ENDIF
ENDIF
ENDIF
IF NOT IS_ENTITY_IN_RANGE_ENTITY(ped.id, PLAYER_PED_ID(), 120)
CPRINTLN(DEBUG_MISSION, "Released one of the delivery peds = ", ped.eDeliverPedType)
SAFE_RELEASE_PED(ped.id)
ENDIF
ELSE
TELL_PED_RING_COPS(ped)
ENDIF
BREAK
CASE DPRS_FLEE_AFTER_RINGING_COPS
IF NOT IS_ENTITY_IN_RANGE_ENTITY(ped.id, PLAYER_PED_ID(), 120)
CPRINTLN(DEBUG_MISSION, "Released one of the delivery peds = ", ped.eDeliverPedType)
SAFE_RELEASE_PED(ped.id)
ENDIF
BREAK
CASE DPRS_REACT_TO_PLAYER_ANGER
IF IS_PED_BEING_JACKED(ped.id)
PICK_FLEE_REACTION(ped, TRUE)
EXIT
ENDIF
IF (GET_GAME_TIMER() - ped.iReactionTimer) > ped.iReactionDelay
OR NOT IsPedPerformingTask(ped.id, SCRIPT_TASK_DRIVE_BY)
REACTIVATE_PED(ped)
ENDIF
BREAK
CASE DPRS_REACT_TO_PLAYER_COWER
IF (GET_GAME_TIMER() - ped.iReactionTimer) >= ped.iReactionDelay
TASK_SMART_FLEE_PED(ped.id, PLAYER_PED_ID(), 500, -1, FALSE, TRUE)
ped.eReactionState = DPRS_WAIT_REACT_TO_PLAYER_FLEE
ELSE
SET_PED_RESET_FLAG(ped.id, PRF_PanicInVehicle, TRUE)
ENDIF
BREAK
CASE DPRS_REACT_TO_PLAYER_BLOCKING_DOOR
IF (GET_GAME_TIMER() - ped.iReactionTimer) >= ped.iReactionDelay
//Line
IF NOT IS_ENTITY_IN_RANGE_ENTITY(ped.id, PLAYER_PED_ID(), 15)
//Line
REACTIVATE_PED(ped)
ped.iReactionTimer = GET_GAME_TIMER()
ELSE
IF CAN_PED_SEE_PED(mPed[GET_THE_OTHER_GUY(ped.eDeliverPedType)].id, ped.id)
PICK_FLEE_REACTION(ped)
#IF IS_DEBUG_BUILD SK_PRINT("player is armed flee 2") #ENDIF
ELSE
MONITOR_DRIVER_DOOR_BLOCKED(ped)
ped.iReactionTimer = GET_GAME_TIMER()
ENDIF
ENDIF
ENDIF
BREAK
CASE DPRS_REACT_TO_PLAYER_BLOCKING_BAC_OF_TRUCK
IF (GET_GAME_TIMER() - ped.iReactionTimer) >= ped.iReactionDelay
//Line
IF NOT IS_ENTITY_IN_RANGE_ENTITY(ped.id, PLAYER_PED_ID(), 15)
//Line
REACTIVATE_PED(ped)
ped.iReactionTimer = GET_GAME_TIMER()
ELSE
IF CAN_PED_SEE_PED(mPed[GET_THE_OTHER_GUY(ped.eDeliverPedType)].id, ped.id)
PICK_FLEE_REACTION(ped)
#IF IS_DEBUG_BUILD SK_PRINT("player is armed flee 5") #ENDIF
ELSE
MONITOR_DRIVER_DOOR_BLOCKED(ped)
ped.iReactionTimer = GET_GAME_TIMER()
ENDIF
ENDIF
ENDIF
BREAK
CASE DPRS_REACT_TO_PLAYER_BLOCKING_FRONT_OF_TRUCK
IF IS_PED_BEING_JACKED(ped.id)
PICK_FLEE_REACTION(ped, TRUE)
EXIT
ENDIF
IF (GET_GAME_TIMER() - iPlayerBlockingTruckTimer) >= 9000
//Line
IF NOT IS_PLAYER_BLOCKING_TRUCK_PROGRESSION(ped)
//Line
REACTIVATE_PED(ped)
ped.iReactionTimer = GET_GAME_TIMER()
ELSE
ped.iReactionTimer = GET_GAME_TIMER()
ped.eControlState = DPCS_REACTING
ped.eReactionState = DPRS_REACT_TO_PLAYER_BLOCKING_FRONT_OF_TRUCK
ENDIF
ELIF (GET_GAME_TIMER() - iPlayerBlockingTruckTimer) >= 5000
AND (GET_GAME_TIMER() - iPlayerBlockingTruckTimer) <= 5500
IF IS_PED_IN_ANY_VEHICLE(ped.id)
IF IS_DRIVEBY_TASK_UNDERNEATH_DRIVING_TASK(ped.id)
CLEAR_DRIVEBY_TASK_UNDERNEATH_DRIVING_TASK(ped.id)
ENDIF
ENDIF
ENDIF
BREAK
CASE DPRS_REACT_TO_PLAYER_BLOCKING_BINS
IF (GET_GAME_TIMER() - ped.iReactionTimer) >= ped.iReactionDelay
IF NOT IS_ENTITY_IN_RANGE_ENTITY(ped.id, PLAYER_PED_ID(), 15)
//Line
REACTIVATE_PED(ped)
ped.iReactionTimer = GET_GAME_TIMER()
ELSE
IF CAN_PED_SEE_PED(mPed[GET_THE_OTHER_GUY(ped.eDeliverPedType)].id, ped.id)
PICK_FLEE_REACTION(ped)
#IF IS_DEBUG_BUILD SK_PRINT("player is armed flee 4") #ENDIF
ELSE
MONITOR_DRIVER_DOOR_BLOCKED(ped)
ped.iReactionTimer = GET_GAME_TIMER()
ENDIF
ENDIF
ENDIF
BREAK
CASE DPRS_REACT_TO_PLAYER_BUMP
IF (GET_GAME_TIMER() - ped.iReactionTimer) >= ped.iReactionDelay
IF NOT IS_ENTITY_IN_RANGE_ENTITY(ped.id, PLAYER_PED_ID(), 15)
//Line
REACTIVATE_PED(ped)
ped.iReactionTimer = GET_GAME_TIMER()
ELSE
IF CAN_PED_SEE_PED(mPed[GET_THE_OTHER_GUY(ped.eDeliverPedType)].id, ped.id)
PICK_FLEE_REACTION(ped)
#IF IS_DEBUG_BUILD SK_PRINT("player is armed flee 5") #ENDIF
ELSE
MONITOR_DRIVER_DOOR_BLOCKED(ped)
ped.iReactionTimer = GET_GAME_TIMER()
ENDIF
ENDIF
ENDIF
BREAK
CASE DPRS_REACT_FLIM
IF IS_PED_ARMED(PLAYER_PED_ID(), WF_INCLUDE_GUN|WF_INCLUDE_PROJECTILE)
AND NOT IS_PED_IN_ANY_VEHICLE(PLAYER_PED_ID())
IF CAN_PED_SEE_PED(ped.id, PLAYER_PED_ID())
PICK_FLEE_REACTION(ped, TRUE)
#IF IS_DEBUG_BUILD SK_PRINT("player is armed flee 6") #ENDIF
EXIT
ENDIF
ENDIF
IF (GET_GAME_TIMER() - ped.iReactionTimer) >= 6000
IF NOT IS_ENTITY_IN_ANGLED_AREA(ped.id, GET_OFFSET_FROM_ENTITY_IN_WORLD_COORDS(mRoutedVehicle.id, <<5, 0, -2>>), (GET_ENTITY_COORDS(mRoutedVehicle.id)+ <<0,0,2>>), 9)
REACTIVATE_PED(ped)
ELSE
TELL_PED_RING_COPS(ped)
TELL_PED_RING_COPS(mPed[GET_THE_OTHER_GUY(ped.eDeliverPedType)])
ENDIF
ped.iReactionTimer = GET_GAME_TIMER()
ENDIF
MONITOR_PLAYER_DRIVING_OFF_IN_VAN(ped)
BREAK
CASE DPRS_REACT_BRAWL
IF IS_PED_ARMED(PLAYER_PED_ID(), WF_INCLUDE_GUN|WF_INCLUDE_PROJECTILE)
IF CAN_PED_SEE_PED(ped.id, PLAYER_PED_ID())
PICK_FLEE_REACTION(ped, TRUE)
#IF IS_DEBUG_BUILD SK_PRINT("player is armed flee 7") #ENDIF
EXIT
ENDIF
ENDIF
// SET_PED_MIN_MOVE_BLEND_RATIO(ped.id, PEDMOVEBLENDRATIO_RUN)
IF (GET_GAME_TIMER() - ped.iReactionTimer) >= ped.iReactionDelay
IF NOT IS_ENTITY_IN_RANGE_ENTITY(ped.id, PLAYER_PED_ID(), 15)
//Line
REACTIVATE_PED(ped)
ped.iReactionTimer = GET_GAME_TIMER()
EXIT
ELSE
MONITOR_DRIVER_DOOR_BLOCKED(ped)
ped.iReactionTimer = GET_GAME_TIMER()
ENDIF
ENDIF
BREAK
CASE DPRS_REACT_SEARCH
MONITER_PLAYER_THREATEN(ped, ped.eDeliverPedType, TRUE)
MONITOR_PLAYER_DRIVING_OFF_IN_VAN(ped)
// IF DOES_ENTITY_EXIST(mPed[GET_THE_OTHER_GUY(ped.eDeliverPedType)].id)
IF IS_ENTITY_IN_RANGE_COORDS(ped.id, vSearchPos, 2)
IF IS_POSITION_IN_PED_VIEW_CONE(ped.id, vSearchPos)
CLEAR_PED_TASKS(ped.id)
ped.eReactionState = DPRS_WAIT_FLIM_DEAD
ped.eControlState = DPCS_REACTING
ped.iReactionTimer = GET_GAME_TIMER()
ENDIF
ENDIF
// ELSE
// TASK_VEHICLE_DRIVE_WANDER(ped.id, mRoutedVehicle.id, 20, DRIVINGMODE_STOPFORCARS_STRICT)
// ped.iReactionTimer = GET_GAME_TIMER()
// ped.eControlState = DPCS_DELIVERING
// ped.eDeliverState = DPDS_WANDERING
// ENDIF
BREAK
ENDSWITCH
ENDPROC
PROC DELIVERY_PED_STATE(PED_STRUCT &ped, DELIVER_PED_TYPE type)
IF IS_PED_UNINJURED(ped.id)
MONITER_PLAYER_THREATEN(ped, type)
IF IS_ENTITY_PLAYING_ANIM(ped.id, "missfbi4prepp1", "_bag_drop_garbage_man")
IF GET_ENTITY_ANIM_CURRENT_TIME(ped.id, "missfbi4prepp1", "_bag_drop_garbage_man") >= 0.172
// CPRINTLN(DEBUG_MISSION, "ped is playing drop garbage = ", type)
IF IS_ENTITY_ALIVE(mDeliveryPoint[iDeliveryIndex].oiObject)
AND IS_ENTITY_ATTACHED(mDeliveryPoint[iDeliveryIndex].oiObject)
RESET_PED_MOVEMENT_CLIPSET(ped.id)
RESET_PED_WEAPON_MOVEMENT_CLIPSET(ped.id)
IF iDeliveryIndex <= MAX_DELIVERIES-1
AND iDeliveryIndex != -1
mDeliveryPoint[iDeliveryIndex].bDelivered = TRUE
ped.eDeliverSubState = SDS_NULL
ENDIF
CPRINTLN(DEBUG_MISSION, "Detaching bin bag = ", type)
DETACH_ENTITY(mDeliveryPoint[iDeliveryIndex].oiObject, TRUE, FALSE)
APPLY_FORCE_TO_ENTITY_CENTER_OF_MASS(mDeliveryPoint[iDeliveryIndex].oiObject, APPLY_TYPE_IMPULSE, GET_ENTITY_FORWARD_VECTOR(ped.id),0, TRUE, TRUE)
ENDIF
ENDIF
ENDIF
SWITCH ped.eControlState
CASE DPCS_DELIVERING
IF type = DRIVER
ROUTE_POINT_MANAGER()
MONITER_PLAYER_BUMPING_VAN(ped)
ENDIF
DO_DELIVERIES(ped)
BREAK
CASE DPCS_REACTING
DO_REACTIONS(ped)
BREAK
ENDSWITCH
ELSE
IF IS_ENTITY_ALIVE(mDeliveryPoint[iDeliveryIndex].oiObject)
IF IS_ENTITY_ATTACHED(mDeliveryPoint[iDeliveryIndex].oiObject)
DETACH_ENTITY(mDeliveryPoint[iDeliveryIndex].oiObject, TRUE, FALSE)
APPLY_FORCE_TO_ENTITY_CENTER_OF_MASS(mDeliveryPoint[iDeliveryIndex].oiObject, APPLY_TYPE_IMPULSE, GET_ENTITY_FORWARD_VECTOR(ped.id),0, TRUE, TRUE)
CPRINTLN(DEBUG_MISSION, "ped dead detach bag")
ENDIF
ENDIF
SAFE_REMOVE_BLIP(ped.blip)
IF DOES_ENTITY_EXIST(ped.id)
IF NOT IS_ENTITY_IN_RANGE_ENTITY(PLAYER_PED_ID(), ped.id, 150)
AND NOT bCheckSeenPedDie
CPRINTLN(DEBUG_MISSION, "Released one of the dead delivery peds = ", ped.eDeliverPedType)
SAFE_RELEASE_PED(ped.id)
ENDIF
ENDIF
ENDIF
ENDPROC
PROC UPDATE_ROUTE_MANAGER()
INT i
FOR i= ENUM_TO_INT(DRIVER) TO (ENUM_TO_INT(MAX_DELIVERY_PEDS)-1)
DELIVERY_PED_STATE(mPed[i], INT_TO_ENUM(DELIVER_PED_TYPE, i))
ENDFOR
ENDPROC
/// PURPOSE:
/// Fills a new delivery point with a position and info for spawning a ped that the Driver ped will walk over to
/// If the Model is set to DUMMY_MODEL_FOR_SCRIPT then no ped will be spawned but the Driver ped will still get out of the vehicle and
/// head to the point the ped would of been
/// PARAMS:
/// vpos - The position of the point to drive to
/// vPedPos - the position the ped should be spawned at or where the driver will walk to
/// fPedDir - the direction the ped should face when spawned
/// mod - the model that should be used to spawn the ped
/// RETURNS:
/// A new instance of a DELIVERY_POINT
FUNC DELIVERY_POINT FILL_DELIVERY_POINT_DEST_PED(VECTOR vpos, VECTOR vPedPos, FLOAT fPedDir, MODEL_NAMES mod)
DELIVERY_POINT mTemp
mTemp.vDriveTo = vpos
mTemp.vPedSpawn = vPedPos
mTemp.fPedHeading = fPedDir
mTemp.pedModel = mod
RETURN mTemp
ENDFUNC
/// PURPOSE:
/// Fills in a delivery point with all the needed data for the Vehicle to
/// park when reaching the delivery point
/// PARAMS:
/// DelPoint - The Delivery point to populate
/// UseParkTask - Should we use the park task or just coast to a stop (peds apply breaks when they dont have a task in a car
/// DriveToTargetDist - The distance at which the vehicle has reached its destination
/// DriveToStraightDist - The disatance before the vehicle will use straight line pathing
/// ParkHeading - If the vehicle's heading isn't within this amount of the Direction param, the vehicle will back up and try to straighten itself out
/// ParkType - The type of parking TO perform
/// BlockingAreaCentre - The point we should block veh gens
/// BlockingAreaSize - the size of the area we should block
PROC FILL_DELIVERY_POINT_PARKING(DELIVERY_POINT &DelPoint, VECTOR parkingpos, BOOL UseParkTask, FLOAT DriveToTargetDist, FLOAT DriveToStraightDist, FLOAT ParkHeading, PARK_TYPE ParkType, VECTOR BlockingAreaCentre, VECTOR BlockingAreaSize)
DelPoint.vParkingVec = parkingpos
DelPoint.fDriveToTargetDist = DriveToTargetDist
DelPoint.fDriveToStraightDist = DriveToStraightDist
DelPoint.fParkHeading = ParkHeading
DelPoint.bDoActionAtDeliveryPoint = UseParkTask
DelPoint.eParkType = ParkType
DelPoint.vBlockingAreaCentre = BlockingAreaCentre
DelPoint.vBlockingAreaSize = BlockingAreaSize
ENDPROC
PROC REGISTER_PED_AS_DRIVER(PED_INDEX ped)
IF IS_PED_UNINJURED(ped)
mPed[DRIVER].id = ped
ELSE
SCRIPT_ASSERT("Ped was invaild when trying to register as a delivery driver")
ENDIF
ENDPROC
PROC REGISTER_PED_AS_PASSENGER(PED_INDEX ped)
IF IS_PED_UNINJURED(ped)
mPed[PASSENGER].id = ped
ELSE
SCRIPT_ASSERT("Ped was invaild when trying to register as a passenger")
ENDIF
ENDPROC
/// PURPOSE:
/// Sets a Vehicle as the Route Vehicle
/// PARAMS:
/// vhe -
PROC REGISTER_VEHICLE(VEHICLE_INDEX vhe)
IF IS_VEHICLE_OK(vhe)
mRoutedVehicle.id = vhe
ELSE
SCRIPT_ASSERT("Ped was invaild when trying to register as a delivery vehicle")
ENDIF
ENDPROC
/// PURPOSE:
/// Releases the ped and the vehicle
PROC RELEASE_DELIVERY_ENTITIES()
SAFE_REMOVE_BLIP(mPed[DRIVER].blip)
SAFE_REMOVE_BLIP(mPed[PASSENGER].blip)
SAFE_RELEASE_VEHICLE(mRoutedVehicle.id)
SAFE_RELEASE_PED(mPed[DRIVER].id)
SAFE_RELEASE_PED(mPed[PASSENGER].id)
SAFE_RELEASE_OBJECT(mDeliveryPoint[iDeliveryIndex].oiObject)
REMOVE_RELATIONSHIP_GROUP(HASH_ENEMIES)
REMOVE_ANIM_DICT("missfbi4prepp1")
REMOVE_ANIM_SET("missfbi4prepp1_garbageman")
ENDPROC
/// PURPOSE:
/// Starts the Delivery peds state machine
/// PARAMS:
/// NumDeliveries -
/// IsSetRoute -
/// IsLooped -
/// DoActionAtDeliveryPoint -
PROC ACTIVATE_DELIVERY_MANAGER(INT NumDeliveries = MAX_DELIVERIES, BOOL IsSetRoute = FALSE, BOOL IsLooped = FALSE, BOOL PassengerDoDeliveries = FALSE)
iNumDeliveries = NumDeliveries
bIsSetRoute = IsSetRoute
bIsLooped = IsLooped
bPassengerDoDeliveries = PassengerDoDeliveries
mPed[DRIVER].iReactionTimer = 0
mPed[PASSENGER].iReactionTimer = 0
INT i
FOR i=0 TO (iNumDeliveries-1)
mDeliveryPoint[i].bDelivered = FALSE
ENDFOR
fTruckBootOpenRatio = 0
ACTIVATE_DRIVER_PED()
mPed[PASSENGER].eDeliverState = DPDS_WAITING_IN_VAN
mPed[PASSENGER].eControlState = DPCS_DELIVERING
mPed[PASSENGER].eDeliverPedType = PASSENGER
mPed[PASSENGER].iReactionDelay = 1500
mPed[PASSENGER].iQuickReactionDelay = 500
mPed[DRIVER].eControlState = DPCS_DELIVERING
mPed[DRIVER].eDeliverPedType = DRIVER
mPed[DRIVER].iReactionDelay = 1000
mPed[DRIVER].iQuickReactionDelay = 100
ADD_RELATIONSHIP_GROUP("Enemies", HASH_ENEMIES)
SET_PED_RELATIONSHIP_GROUP_HASH(mPed[DRIVER].id, HASH_ENEMIES)
SET_PED_RELATIONSHIP_GROUP_HASH(mPed[PASSENGER].id, HASH_ENEMIES)
SET_ENTITY_IS_TARGET_PRIORITY(mPed[DRIVER].id, TRUE)
SET_ENTITY_IS_TARGET_PRIORITY(mPed[PASSENGER].id, TRUE)
INIT_GOTO_BLOCKING_SHAPE_TEST(<<1.9,1.9,8>>, <<0,0,0>>)
ENDPROC
/// PURPOSE:
/// Loads Anims required for ped reactions or behaviours
///
/// PARAMS:
/// bWait - If TRUE we wait in a while loop (holting the script) till the
/// anims are loaded
/// RETURNS:
/// TRUE when all anims are loaded
FUNC BOOL LOAD_DELIVERY_ANIMS(BOOL bWait = FALSE)
REQUEST_ANIM_DICT("missfbi4prepp1")
REQUEST_ANIM_SET("missfbi4prepp1_garbageman")
IF bWait
WHILE NOT HAS_ANIM_DICT_LOADED("missfbi4prepp1")
AND NOT HAS_ANIM_SET_LOADED("missfbi4prepp1_garbageman")
WAIT(0)
ENDWHILE
RETURN TRUE
ELSE
IF HAS_ANIM_DICT_LOADED("missfbi4prepp1")
AND HAS_ANIM_SET_LOADED("missfbi4prepp1_garbageman")
RETURN TRUE
ENDIF
ENDIF
RETURN FALSE
ENDFUNC
Reference in New Issue View Git Blame Copy Permalink