18943 lines
623 KiB
Python
Executable File
18943 lines
623 KiB
Python
Executable File
//+-----------------------------------------------------------------------------+
|
|
//¦ Author: Rob Bray Date: 21/02/11 ¦
|
|
//¦-----------------------------------------------------------------------------¦
|
|
//¦ ¦
|
|
//¦ ¦
|
|
//¦ Franklin 0: Foot Chase ¦
|
|
//¦ ¦
|
|
//¦ ¦
|
|
//+-----------------------------------------------------------------------------+
|
|
|
|
//Compile out Title Update changes to header functions.
|
|
//Must be before includes.
|
|
//CONST_INT USE_TU_CHANGES 0 // Removed by Kenneth R.
|
|
|
|
CONST_INT TOTAL_NUMBER_OF_TRAFFIC_CARS 51
|
|
CONST_INT TOTAL_NUMBER_OF_PARKED_CARS 1
|
|
CONST_INT TOTAL_NUMBER_OF_SET_PIECE_CARS 15
|
|
|
|
CONST_INT MAX_NUMBER_OF_TRAFFIC_CARS_PLAYING_BACK 8
|
|
CONST_INT MAX_NUMBER_OF_SET_PIECE_CARS_PLAYING_BACK 8
|
|
CONST_INT MAX_NUMBER_OF_PARKED_CARS_PLAYING_BACK 6
|
|
|
|
USING "rage_builtins.sch"
|
|
USING "globals.sch"
|
|
USING "brains.sch"
|
|
USING "script_player.sch"
|
|
USING "commands_script.sch"
|
|
USING "commands_pad.sch"
|
|
USING "commands_graphics.sch"
|
|
USING "commands_camera.sch"
|
|
USING "commands_streaming.sch"
|
|
USING "commands_interiors.sch"
|
|
USING "commands_object.sch"
|
|
USING "commands_vehicle.sch"
|
|
USING "commands_physics.sch"
|
|
USING "commands_fire.sch"
|
|
USING "selector_public.sch"
|
|
USING "dialogue_public.sch"
|
|
USING "cellphone_public.sch"
|
|
USING "flow_public_core_override.sch"
|
|
USING "flow_help_public.sch"
|
|
USING "chase_hint_cam.sch" CHASE_HINT_CAM_STRUCT localChaseHintCamStruct
|
|
USING "script_ped.sch"
|
|
USING "script_blips.sch"
|
|
USING "script_buttons.sch"
|
|
USING "select_mission_stage.sch"
|
|
USING "traffic.sch"
|
|
USING "replay_public.sch"
|
|
USING "cutscene_public.sch"
|
|
USING "cam_recording_public.sch"
|
|
USING "mission_stat_public.sch"
|
|
USING "vehicle_gen_public.sch"
|
|
USING "chop_cam_public.sch"
|
|
USING "clearMissionArea.sch"
|
|
USING "CompletionPercentage_public.sch"
|
|
USING "social_public.sch"
|
|
USING "locates_public.sch"
|
|
USING "chop_van_public.sch"
|
|
USING "timelapse.sch"
|
|
USING "fake_cellphone_public.sch"
|
|
USING "cheat_controller_public.sch"
|
|
USING "commands_recording.sch"
|
|
|
|
|
|
// Enums
|
|
ENUM MISSION_INIT_STAGE_ENUM
|
|
MISSION_INIT_PRE_INTRO = 0,
|
|
MISSION_INIT_REQUEST_INTRO,
|
|
MISSION_INIT_WAIT_FOR_INTRO,
|
|
MISSION_INIT_PLAY_INTRO,
|
|
MISSION_INIT_DONE
|
|
ENDENUM
|
|
|
|
ENUM MISSION_STAGE_ENUM
|
|
STAGE_GET_TO_BAD_GUY = 0,
|
|
STAGE_VAN_CHASE,
|
|
STAGE_FOOT_CHASE,
|
|
STAGE_FIND_BAD_GUY,
|
|
STAGE_GET_TO_HOUSE
|
|
ENDENUM
|
|
|
|
ENUM FAIL_REASON_ENUM
|
|
FAIL_FRANKLIN_DEAD = 0,
|
|
FAIL_LAMAR_DEAD,
|
|
FAIL_CHOP_DEAD,
|
|
FAIL_LOST_BAD_GUY,
|
|
FAIL_KILLED_BAD_GUY,
|
|
FAIL_VAN_DESTROYED,
|
|
FAIL_SPOOKED_BAD_GUY,
|
|
FAIL_ABANDONED_LAMAR,
|
|
FAIL_ABANDONED_VAN,
|
|
FAIL_ABANDONED_CHOP,
|
|
FAIL_VAN_STUCK,
|
|
FAIL_POLICE_ATTENTION
|
|
ENDENUM
|
|
|
|
ENUM MISSION_FAIL_STATE_ENUM
|
|
MISSION_FAIL_STATE_NOT_FAILED = 0,
|
|
MISSION_FAIL_STATE_WAIT_FOR_FADE
|
|
ENDENUM
|
|
|
|
ENUM MISSION_HOTSWAP_STAGE_ENUM
|
|
MISSION_HOTSWAP_STAGE_SELECT_CHARACTER = 0,
|
|
MISSION_HOTSWAP_STAGE_DO_SPLINE_CAM
|
|
ENDENUM
|
|
|
|
ENUM MISSION_STREAMING_STAGE_ENUM
|
|
MISSION_STREAMING_STAGE_REQUEST = 0,
|
|
MISSION_STREAMING_STAGE_WAIT,
|
|
MISSION_STREAMING_STAGE_COMPLETE
|
|
ENDENUM
|
|
|
|
ENUM MOCAP_STREAMING_STAGE_ENUM
|
|
MOCAP_STREAMING_STAGE_REQUEST = 0,
|
|
MOCAP_STREAMING_STAGE_WAIT,
|
|
MOCAP_STREAMING_STAGE_COMPLETE
|
|
ENDENUM
|
|
|
|
ENUM HOOD_MODEL_ENUM
|
|
HM_FRANKLIN = 0,
|
|
HM_LAMAR,
|
|
HM_BAD_GUY,
|
|
HM_CHOP,
|
|
HM_COLLIE,
|
|
HM_GIRL,
|
|
HM_WORKER,
|
|
HM_FRANKLIN_VAN,
|
|
HM_BIKE,
|
|
HM_TRAFFIC_CAR1,
|
|
HM_TRAFFIC_CAR2,
|
|
HM_BUS,
|
|
HM_TRAILER,
|
|
HM_ENGINE,
|
|
HM_TANKER_CARRIAGE,
|
|
HM_CONTAINER_CARRIAGE,
|
|
HM_BLOCKING_TRUCK,
|
|
HM_BLOCKING_CAR,
|
|
HM_BOXCAR_DOOR,
|
|
HM_BOXCAR_HANDLE,
|
|
HM_LAMAR_PHONE,
|
|
HM_FRANKLIN_MASK,
|
|
HM_ANCHOR,
|
|
HM_START_VEHICLE
|
|
ENDENUM
|
|
|
|
ENUM HOOD_VECTOR_ENUM
|
|
HVEC_FRANKLIN_VAN_INIT = 0,
|
|
HVEC_PLAYER_INIT,
|
|
HVEC_BAD_GUY_HANGOUT,
|
|
HVEC_HOUSE,
|
|
HVEC_REC,
|
|
HVEC_FOOT_CHASE_INIT,
|
|
HVEC_VAN_CHASE_INIT,
|
|
HVEC_DRIVE_INIT,
|
|
HVEC_VAN_IN_ALLEY,
|
|
HVEC_CONTAINER_ATTACH_ROT,
|
|
HVEC_GIRL_INIT,
|
|
HVEC_FRANKLIN_ALLEY_INIT,
|
|
HVEC_LAMAR_WALK_INIT,
|
|
HVEC_LAMAR_ALLEY_INIT,
|
|
HVEC_RUNNER_CHASE_INIT,
|
|
HVEC_CHOP_WALK_INIT,
|
|
HVEC_CHOP_CHASE_INIT,
|
|
HVEC_OFF_ROOF,
|
|
HVEC_CHASE_TRAIN,
|
|
HVEC_TRAINYARD,
|
|
HVEC_LOSE_RUNNER,
|
|
HVEC_RUNNER_HIDE,
|
|
HVEC_FIND_GANGSTER,
|
|
HVEC_CHOP_FIND_INIT,
|
|
HVEC_COLLIE_INIT,
|
|
HVEC_CHOP_HUMP_ENTRY,
|
|
HVEC_CHOP_BEHAVIOUR_SETPIECE_LAUNCH,
|
|
HVEC_CHOP_BEHAVIOUR_SETPIECE_TERMINATE,
|
|
HVEC_BLIP_ALLEY,
|
|
HVEC_LAMAR_SPRINT_TO_VAN,
|
|
HVEC_MOVE_LAST_PLAYER_VEHICLE,
|
|
HVEC_VAN_HIDDEN
|
|
ENDENUM
|
|
|
|
ENUM HOOD_VEHICLE_ENUM
|
|
HV_FRANKLIN_VAN = 0,
|
|
HV_BAD_GUY_BIKE
|
|
ENDENUM
|
|
|
|
ENUM HOOD_SHOT_DETAILS_ENUM
|
|
H_SHOT_FLIRT = 0,
|
|
H_SHOT_FLIRTB,
|
|
H_SHOT_SHOUT,
|
|
H_SHOT_SHOUTB,
|
|
H_SHOT_ESCAPE,
|
|
H_SHOT_ESCAPEB,
|
|
H_SHOT_LAMAR_SHOUT,
|
|
H_SHOT_LAMAR_SHOUTB,
|
|
H_SHOT_CRASH,
|
|
H_SHOT_LEAVE_CAR,
|
|
H_SHOT_OFF_ROOF,
|
|
H_SHOT_OFF_ROOFB,
|
|
H_SHOT_THROUGH_FENCE,
|
|
H_SHOT_THROUGH_FENCEB,
|
|
H_SHOT_ONTO_TRAIN,
|
|
H_SHOT_ONTO_TRAINB,
|
|
H_SHOT_LOST,
|
|
H_SHOT_LOSTB,
|
|
H_SHOT_FIND,
|
|
H_SHOT_FINDB,
|
|
H_SHOT_BOXCAR_FLEE,
|
|
H_SHOT_TRAPPED,
|
|
H_SHOT_TRAPPEDB,
|
|
H_SHOT_INTO_VAN,
|
|
H_SHOT_INTO_VANB,
|
|
H_SHOT_HOUSE
|
|
ENDENUM
|
|
|
|
ENUM HOOD_ANIM_DICT_ENUM
|
|
//H_ANIM_DICT_MISSION = 0,
|
|
//H_ANIM_DICT_TAKEDOWN,
|
|
H_ANIM_DICT_SHARED = 0,
|
|
H_ANIM_DICT_TO_VAN,
|
|
H_ANIM_DICT_FOOT_CHASE,
|
|
H_ANIM_DICT_FIND,
|
|
H_ANIM_DICT_DRIVE_HOME,
|
|
H_ANIM_DICT_CHOP_VAN
|
|
//H_ANIM_DICT_GESTURE_ENT,
|
|
//H_ANIM_DICT_GESTURE_IDLE1,
|
|
//H_ANIM_DICT_GESTURE_IDLE2,
|
|
//H_ANIM_DICT_GESTURE_EXT
|
|
//H_ANIM_DICT_TAXI
|
|
ENDENUM
|
|
|
|
ENUM HOOD_WEAPON_ENUM
|
|
H_WEAPON_PISTOL = 0
|
|
ENDENUM
|
|
|
|
ENUM HOOD_PTFX_ENUM
|
|
H_PTFX_SCRIPT = 0
|
|
ENDENUM
|
|
|
|
ENUM HOOD_SFX_ENUM
|
|
H_SFX_BOXCARS = 0,
|
|
H_SFX_GENERAL
|
|
ENDENUM
|
|
|
|
ENUM HOOD_MISC_ASSET_ENUM
|
|
H_MISC_ASSET_VAN_ANIMS = 0,
|
|
H_MISC_ASSET_INJURED_CLIPSET,
|
|
H_MISC_ASSET_FAKE_CELLPHONE,
|
|
H_MISC_ASSET_GESTURES
|
|
//H_MISC_ASSET_CHOP_CAM_SFX
|
|
ENDENUM
|
|
|
|
ENUM HOOD_CUTSCENE_STAGE_ENUM
|
|
H_CUT_STAGE_INIT = 0,
|
|
H_CUT_STAGE_RUNNING,
|
|
H_CUT_STAGE_CLEANUP
|
|
ENDENUM
|
|
|
|
ENUM ONTO_TRAIN_SHOT_ENUM
|
|
ONTO_TRAIN_JUMP = 0,
|
|
ONTO_TRAIN_LOSE
|
|
ENDENUM
|
|
|
|
ENUM LET_OUT_SHOT_ENUM
|
|
LET_OUT_PHONE = 0,
|
|
LET_OUT_DOOR
|
|
ENDENUM
|
|
|
|
ENUM CHASE_SPEED_STAGE_ENUM
|
|
CHASE_SPEED_START = 0,
|
|
CHASE_SPEED_ROUND_FIRST_CORNER,
|
|
CHASE_SPEED_DOWN_HILL,
|
|
CHASE_SPEED_THROUGH_JUNCTION,
|
|
CHASE_SPEED_FOR_SHARP_TURN,
|
|
CHASE_SPEED_CATCH_BACK_UP,
|
|
CHASE_SPEED_UNDER_HIGHWAY,
|
|
CHASE_SPEED_TO_ALLEY,
|
|
CHASE_SPEED_ALLEY_CORNER,
|
|
CHASE_SPEED_IN_ALLEY
|
|
ENDENUM
|
|
|
|
ENUM RUNNER_STAGE_ENUM
|
|
RUNNER_START_FLEE = 0,
|
|
RUNNER_TO_CONTAINER,
|
|
RUNNER_TO_CAR,
|
|
RUNNER_TO_FENCE,
|
|
RUNNER_TO_FLATBEDS,
|
|
RUNNER_TO_BOXCAR,
|
|
RUNNER_TO_TRAIN,
|
|
RUNNER_DONE
|
|
ENDENUM
|
|
|
|
ENUM CHOP_STAGE_ENUM
|
|
CHOP_START_CHASE = 0,
|
|
CHOP_TO_ROOF_EDGE,
|
|
CHOP_TO_CAR,
|
|
CHOP_TO_FENCE,
|
|
CHOP_TO_FLATBEDS,
|
|
CHOP_TO_BOXCAR,
|
|
CHOP_TO_TRAIN,
|
|
CHOP_DONE
|
|
ENDENUM
|
|
|
|
ENUM SETPIECE_STAGE_ENUM
|
|
SETPIECE_FREE_INTO_STATION = 0,
|
|
SETPIECE_LOCK_BUS_REVERSING,
|
|
SETPIECE_FREE_TO_ROOF,
|
|
SETPIECE_LOCK_CAR_SLIDE,
|
|
SETPIECE_FREE_ACROSS_CONSTRUCTION,
|
|
SETPIECE_LOCK_TRAIN_CUT_ACROSS,
|
|
SETPIECE_FREE_THROUGH_CARRIAGES,
|
|
SETPIECE_FREE_BACK_OF_CARRIAGES,
|
|
SETPIECE_LOCK_TRAIN_JUMP
|
|
ENDENUM
|
|
|
|
ENUM CHASE_ANIM_ENUM
|
|
CHASE_ANIM_NONE = -1,
|
|
CHASE_ANIM_G_TOP_FENCE,
|
|
CHASE_ANIM_G_DOWN_CONTAINER,
|
|
CHASE_ANIM_G_OVER_CAR,
|
|
CHASE_ANIM_G_OVER_YARD_FENCE,
|
|
CHASE_ANIM_G_FLATBEDS,
|
|
CHASE_ANIM_G_BOXCAR,
|
|
CHASE_ANIM_G_WAITING_ON_GROUND,
|
|
CHASE_ANIM_G_GET_UP_FROM_GROUND,
|
|
CHASE_ANIM_G_ONTO_TRAIN,
|
|
CHASE_ANIM_F_OFF_ROOF,
|
|
CHASE_ANIM_F_THROUGH_YARD_FENCE,
|
|
CHASE_ANIM_C_TOP_FENCE,
|
|
CHASE_ANIM_C_OFF_ROOF,
|
|
CHASE_ANIM_C_OVER_CAR,
|
|
CHASE_ANIM_C_FLATBEDS,
|
|
CHASE_ANIM_C_BOXCAR,
|
|
CHASE_ANIM_BAD
|
|
ENDENUM
|
|
|
|
ENUM CHASE_STATE_ENUM
|
|
CHASE_STATE_MOVING = 0,
|
|
CHASE_STATE_PERFORMING_ANIM
|
|
ENDENUM
|
|
|
|
ENUM RUNNER_FOLLOW_TYPE_ENUM
|
|
RUNNER_FOLLOW_WAYPOINT = 0,
|
|
RUNNER_FOLLOW_STRAIGHT,
|
|
RUNNER_FOLLOW_SPECIAL
|
|
ENDENUM
|
|
|
|
ENUM YARD_VEHICLE_ENUM
|
|
//YV_CAR_CARPARK_COME_ROUND_CORNER = 0,
|
|
YV_CAR_CARPARK_PULL_OUT_FOR_JUMP_OVER = 0,
|
|
//YV_CAR_STATION_PULL_OUT_TO_LEAVE,
|
|
YV_CAR_STATION_PULL_INTO_DEPOT,
|
|
//YV_CAR_ROAD_FROM_RIGHT,
|
|
YV_BUS_ROAD_FROM_LEFT,
|
|
YV_CAR_CARPARK_STATIC,
|
|
YV_BUS_REVERSE,
|
|
YV_BUS_PULL_OUT,
|
|
YV_BUS_STATIC
|
|
ENDENUM
|
|
|
|
ENUM YARD_PED_ENUM
|
|
YP_STATION_WALK_TO_GATE = 0,
|
|
YP_STATION_CONV_KNOCK_OVER,
|
|
YP_STATION_CONV_LOOK,
|
|
YP_STATION_BACK_TURNED_KNOCK_OVER,
|
|
//YP_CONSTRUCT_CONV_LOOK1,
|
|
//YP_CONSTRUCT_CONV_LOOK2,
|
|
YP_CONSTRUCT_WALK_SOUTH,
|
|
YP_CONSTRUCT_WALK_NORTH
|
|
ENDENUM
|
|
|
|
ENUM YARD_PED_TRIGGER_ENUM
|
|
YARD_PED_TRIGGER_TIME = 0,
|
|
YARD_PED_TRIGGER_PROXIMITY,
|
|
YARD_PED_TRIGGER_DEPENDENCY
|
|
ENDENUM
|
|
|
|
ENUM YARD_PED_STATE_ENUM
|
|
YARD_PED_STATE_IDLE = 0,
|
|
YARD_PED_STATE_TALKING,
|
|
YARD_PED_STATE_ENTER_SHOCKED,
|
|
YARD_PED_STATE_LOOPING_SHOCKED,
|
|
YARD_PED_STATE_EXIT_SHOCKED,
|
|
YARD_PED_STATE_WALKING,
|
|
YARD_PED_STATE_RAGDOLL,
|
|
YARD_PED_STATE_TURN_TO_FACE,
|
|
YARD_PED_STATE_WANDER,
|
|
YARD_PED_STATE_FLEE
|
|
ENDENUM
|
|
|
|
ENUM BOXCAR_DOOR_STATE_ENUM
|
|
BOXCAR_DOOR_AWAITING_PLAYER = 0,
|
|
BOXCAR_DOOR_TRIGGERED,
|
|
BOXCAR_DOOR_OPENING,
|
|
BOXCAR_DOOR_OPEN
|
|
ENDENUM
|
|
|
|
ENUM CHOP_BEHAVIOUR_SETPIECE_STAGE_ENUM
|
|
CBS_NOT_STARTED = 0,
|
|
CBS_WAIT_FOR_FRANKLIN,
|
|
CBS_SPOT_COLLIE,
|
|
CBS_GO_TO_COLLIE,
|
|
CBS_HUMP_AWAY,
|
|
CBS_OBEY,
|
|
CBS_RETURN,
|
|
CBS_DONE
|
|
ENDENUM
|
|
|
|
ENUM UBER_TRAILER_STATE_ENUM
|
|
UBER_TRAILER_NOT_CREATED = 0,
|
|
UBER_TRAILER_STREAMING,
|
|
UBER_TRAILER_CREATED,
|
|
UBER_TRAILER_REMOVED
|
|
ENDENUM
|
|
|
|
ENUM LAMAR_PHONE_STATE_ENUM
|
|
LAMAR_PHONE_STATE_NOT_STARTED = 0,
|
|
LAMAR_PHONE_STATE_PRE_CALL,
|
|
LAMAR_PHONE_STATE_PHONE_UP,
|
|
LAMAR_PHONE_STATE_ON_PHONE,
|
|
LAMAR_PHONE_STATE_PHONE_DOWN,
|
|
LAMAR_PHONE_STATE_POST_CALL,
|
|
LAMAR_PHONE_STATE_SNATCH,
|
|
LAMAR_PHONE_STATE_DONE
|
|
ENDENUM
|
|
|
|
ENUM CHOP_HUMP_STATE_ENUM
|
|
CHOP_HUMP_STATE_NOT_STARTED = 0,
|
|
CHOP_HUMP_STATE_ENTERING,
|
|
CHOP_HUMP_STATE_LOOPING,
|
|
CHOP_HUMP_STATE_EXITING,
|
|
CHOP_HUMP_STATE_DONE
|
|
ENDENUM
|
|
|
|
ENUM CHOP_SNIFF_STATE_ENUM
|
|
CHOP_SNIFF_STATE_NOT_STARTED = 0,
|
|
CHOP_SNIFF_STATE_SLOW_DOWN,
|
|
CHOP_SNIFF_STATE_STOPPED,
|
|
CHOP_SNIFF_STATE_PLAYING_ANIM,
|
|
CHOP_SNIFF_STATE_WAIT_AT_BOXCAR
|
|
ENDENUM
|
|
|
|
ENUM CHOP_WAIT_STATE_ENUM
|
|
CHOP_WAIT_STATE_NOT_STARTED = 0,
|
|
CHOP_WAIT_STATE_SLOW_TO_STOP,
|
|
CHOP_WAIT_STATE_WAITING,
|
|
CHOP_WAIT_STATE_DONE
|
|
ENDENUM
|
|
|
|
ENUM CHOP_AUDIO_CONTEXT_ENUM
|
|
CHOP_AUDIO_CONTEXT_BARK = 0,
|
|
CHOP_AUDIO_CONTEXT_GROWL,
|
|
CHOP_AUDIO_CONTEXT_ATTACK,
|
|
CHOP_AUDIO_CONTEXT_SNARL,
|
|
CHOP_AUDIO_CONTEXT_LICKS_MOUTH,
|
|
CHOP_AUDIO_CONTEXT_PANT,
|
|
CHOP_AUDIO_CONTEXT_SNIFF,
|
|
CHOP_AUDIO_CONTEXT_PLAYFUL,
|
|
CHOP_AUDIO_CONTEXT_WHINE_SHORT,
|
|
CHOP_AUDIO_CONTEXT_WHINE_LONG,
|
|
CHOP_AUDIO_CONTEXT_WHINE_STOP
|
|
ENDENUM
|
|
|
|
ENUM CHOP_AUDIO_STATE_ENUM
|
|
CHOP_AUDIO_STATE_WALK_TO_VAN = 0,
|
|
CHOP_AUDIO_STATE_IN_VAN_PLACID,
|
|
CHOP_AUDIO_STATE_IN_VAN_AGITATED,
|
|
CHOP_AUDIO_STATE_IN_VAN_GUARDING,
|
|
CHOP_AUDIO_STATE_CHASING,
|
|
CHOP_AUDIO_STATE_SEARCHING,
|
|
CHOP_AUDIO_STATE_RUNNING_TO_HUMP,
|
|
CHOP_AUDIO_STATE_HUMPING,
|
|
CHOP_AUDIO_STATE_FOUND_SOMETHING,
|
|
CHOP_AUDIO_STATE_WAITING
|
|
ENDENUM
|
|
|
|
ENUM DROPOFF_STAGE_ENUM
|
|
DROPOFF_STAGE_NOT_STARTED = 0,
|
|
DROPOFF_STAGE_BRIEF,
|
|
DROPOFF_STAGE_BANTER,
|
|
DROPOFF_STAGE_PRE_CALL,
|
|
DROPOFF_STAGE_CALL,
|
|
DROPOFF_STAGE_POST_CALL,
|
|
DROPOFF_STAGE_STOP_VAN,
|
|
DROPOFF_STAGE_END
|
|
ENDENUM
|
|
|
|
ENUM DRIVER_OUT_STATE_ENUM
|
|
DRIVER_OUT_INACTIVE = 0,
|
|
DRIVER_OUT_WAIT,
|
|
DRIVER_OUT_LEAVE_VEHICLE,
|
|
DRIVER_OUT_GET_HEADING,
|
|
DRIVER_OUT_INTO_ANIM,
|
|
DRIVER_OUT_PLAY_ANIM,
|
|
DRIVER_OUT_DONE,
|
|
DRIVER_OUT_FLEE
|
|
ENDENUM
|
|
|
|
ENUM FRANKLIN_WARP_ENUM
|
|
FRANKLIN_WARP_TOP_FENCE = 0,
|
|
FRANKLIN_WARP_FLATBEDS,
|
|
FRANKLIN_WARP_BOXCAR
|
|
ENDENUM
|
|
|
|
ENUM VAN_CAMERA_ENUM
|
|
VAN_CAMERA_REAR = 0,
|
|
VAN_CAMERA_FRONT
|
|
ENDENUM
|
|
|
|
ENUM CREATE_POST_INTRO_STAGE_ENUM
|
|
CREATE_POST_INTRO_STAGE_NOT_STARTED = 0,
|
|
CREATE_POST_INTRO_STAGE_WAITING,
|
|
CREATE_POST_INTRO_STAGE_DONE
|
|
ENDENUM
|
|
|
|
ENUM CREATE_BAD_GUY_STAGE_ENUM
|
|
CREATE_BAD_GUY_STAGE_NOT_STARTED = 0,
|
|
CREATE_BAD_GUY_STAGE_WAITING1,
|
|
CREATE_BAD_GUY_STAGE_WAITING2,
|
|
CREATE_BAD_GUY_STAGE_WAITING3,
|
|
CREATE_BAD_GUY_STAGE_CREATE_GIRL,
|
|
CREATE_BAD_GUY_STAGE_DONE
|
|
ENDENUM
|
|
|
|
ENUM CREATE_BLOCKING_VEHICLES_STAGE_ENUM
|
|
CREATE_BLOCKING_VEHICLES_STAGE_NOT_STARTED = 0,
|
|
CREATE_BLOCKING_VEHICLES_STAGE_WAITING1,
|
|
CREATE_BLOCKING_VEHICLES_STAGE_WAITING2,
|
|
CREATE_BLOCKING_VEHICLES_STAGE_DONE
|
|
ENDENUM
|
|
|
|
ENUM CRASH_TRIGGER_STATE_ENUM
|
|
CRASH_TRIGGER_WAITING = 0,
|
|
CRASH_TRIGGER_SLOW_DOWN,
|
|
CRASH_TRIGGER_GET_CHOP_OUT,
|
|
CRASH_TRIGGER_RUN
|
|
ENDENUM
|
|
|
|
ENUM CREATE_YARD_STAGE_ENUM
|
|
CREATE_YARD_STAGE_NOT_STARTED = 0,
|
|
CREATE_YARD_STAGE_WAITING,
|
|
CREATE_YARD_STAGE_DONE
|
|
ENDENUM
|
|
|
|
ENUM CREATE_CARS_STAGE_ENUM
|
|
CREATE_CARS_STAGE_NOT_STARTED = 0,
|
|
CREATE_CARS_STAGE_WAITING,
|
|
CREATE_CARS_STAGE_DONE
|
|
ENDENUM
|
|
|
|
ENUM CREATE_TRAINS_STAGE_ENUM
|
|
CREATE_TRAINS_STAGE_NOT_STARTED = 0,
|
|
CREATE_TRAINS_STAGE_WAITING,
|
|
CREATE_TRAINS_STAGE_DONE
|
|
ENDENUM
|
|
|
|
ENUM CARRIAGE_SEARCH_STATE_ENUM
|
|
CARRIAGE_SEARCH_STATE_NOT_BLIPPED = 0,
|
|
CARRIAGE_SEARCH_STATE_BLIPPED,
|
|
CARRIAGE_SEARCH_STATE_SEARCHED
|
|
ENDENUM
|
|
|
|
ENUM OPEN_TARGET_CONTAINER_STATE_ENUM
|
|
OPEN_TARGET_CONTAINER_STATE_NOT_STARTED = 0,
|
|
OPEN_TARGET_CONTAINER_STATE_OPENING,
|
|
OPEN_TARGET_CONTAINER_STATE_ESCAPING
|
|
ENDENUM
|
|
|
|
ENUM CHOP_INTO_VAN_STATE_ENUM
|
|
CHOP_INTO_VAN_STATE_NOT_STARTED = 0,
|
|
CHOP_INTO_VAN_WALK_ROUND_BACK,
|
|
CHOP_INTO_VAN_STATE_GET_IN_POSITION,
|
|
CHOP_INTO_VAN_STATE_PLAYING,
|
|
CHOP_INTO_VAN_STATE_DONE
|
|
ENDENUM
|
|
|
|
ENUM BALLA_DISCOVERED_STATE_ENUM
|
|
BALLA_DISCOVERED_STATE_NOT_STARTED = 0,
|
|
BALLA_DISCOVERED_STATE_DOOR_OPENING,
|
|
BALLA_DISCOVERED_STATE_LEAVE_BOXCAR,
|
|
BALLA_DISCOVERED_STATE_ESCAPING
|
|
ENDENUM
|
|
|
|
ENUM RUN_HELP_STATE_ENUM
|
|
RUN_HELP_STATE_NOT_STARTED = 0,
|
|
RUN_HELP_PART_2,
|
|
RUN_HELP_STATE_DONE
|
|
ENDENUM
|
|
|
|
ENUM FRANKLIN_MASK_REMOVE_STATE_ENUM
|
|
FRANKLIN_MASK_REMOVE_STATE_NOT_STARTED = 0,
|
|
FRANKLIN_MASK_REMOVE_STATE_PLAYING_ANIM,
|
|
FRANKLIN_MASK_REMOVE_STATE_PUTTING_AWAY,
|
|
FRANKLIN_MASK_REMOVE_STATE_DONE
|
|
ENDENUM
|
|
|
|
ENUM CALL_CHOP_BACK_STATE_ENUM
|
|
CALL_CHOP_BACK_STATE_NOT_STARTED = 0,
|
|
CALL_CHOP_BACK_STATE_QUEUED,
|
|
CALL_CHOP_BACK_STATE_SUCCESS
|
|
ENDENUM
|
|
|
|
ENUM HOOD_AUDIO_SCENE_ENUM
|
|
HOOD_AUDIO_SCENE_WALK_TO_VAN = 0,
|
|
HOOD_AUDIO_SCENE_DRIVE_TO_VINEWOOD,
|
|
HOOD_AUDIO_SCENE_CAR_CHASE,
|
|
HOOD_AUDIO_SCENE_FOOT_CHASE_START,
|
|
HOOD_AUDIO_SCENE_BREAK_THROUGH_FENCE,
|
|
HOOD_AUDIO_SCENE_D_ESCAPES,
|
|
HOOD_AUDIO_SCENE_SEARCH_BOXCARS,
|
|
HOOD_AUDIO_SCENE_DRIVE_TO_LAMARS,
|
|
HOOD_AUDIO_SCENE_TAKE_LAMAR_BACK,
|
|
HOOD_AUDIO_SCENE_CHOP_CAM,
|
|
HOOD_AUDIO_SCENE_FOCUS_CAM
|
|
ENDENUM
|
|
|
|
ENUM CHOP_BYPASS_FENCE_STATE_ENUM
|
|
CHOP_BYPASS_FENCE_NOT_STARTED = 0,
|
|
CHOP_BYPASS_FENCE_PERFORMING_BYPASS,
|
|
CHOP_BYPASS_FENCE_DONE
|
|
ENDENUM
|
|
|
|
ENUM GRAB_SCENARIO_PED_STATE_ENUM
|
|
GRAB_SCENARIO_PED_STATE_NOT_GRABBED = 0,
|
|
GRAB_SCENARIO_PED_STATE_GRABBED
|
|
ENDENUM
|
|
|
|
ENUM CHOP_BEHAVIOUR_SPEECH_STATE_ENUM
|
|
CHOP_BEHAVIOUR_SPEECH_NOT_STARTED = 0,
|
|
CHOP_BEHAVIOUR_SPEECH_SAY_GOOD,
|
|
CHOP_BEHAVIOUR_SPEECH_BARK,
|
|
CHOP_BEHAVIOUR_SPEECH_SAY_BAD,
|
|
CHOP_BEHAVIOUR_SPEECH_DONE
|
|
ENDENUM
|
|
|
|
ENUM SHAPE_TEST_STATE_ENUM
|
|
SHAPE_TEST_STATE_NOT_STARTED = 0,
|
|
SHAPE_TEST_STATE_WAITING
|
|
ENDENUM
|
|
|
|
|
|
|
|
// Consts
|
|
CONST_INT NUMBER_MODEL_REQUEST_SLOTS COUNT_OF(HOOD_MODEL_ENUM)
|
|
CONST_INT NUMBER_RECORDING_REQUEST_SLOTS 14
|
|
CONST_INT NUMBER_WAYPOINT_REQUEST_SLOTS 12
|
|
CONST_INT MAX_SKIP_MENU_LENGTH 11
|
|
CONST_INT SKIP_FADE_WAIT_TIME 200
|
|
CONST_INT PLAYER_VEHICLE_SEARCH_FLAGS VEHICLE_SEARCH_FLAG_RETURN_MISSION_VEHICLES | VEHICLE_SEARCH_FLAG_RETURN_RANDOM_VEHICLES | VEHICLE_SEARCH_FLAG_RETURN_VEHICLES_CONTAINING_GROUP_MEMBERS | VEHICLE_SEARCH_FLAG_RETURN_VEHICLES_CONTAINING_A_PLAYER | VEHICLE_SEARCH_FLAG_RETURN_VEHICLES_CONTAINING_A_DEAD_OR_DYING_PED | VEHICLE_SEARCH_FLAG_RETURN_VEHICLES_WITH_PEDS_ENTERING_OR_EXITING | VEHICLE_SEARCH_FLAG_ALLOW_VEHICLE_OCCUPANTS_TO_BE_PERFORMING_A_SCRIPTED_TASK
|
|
|
|
CONST_INT NUMBER_TRAINS 3
|
|
CONST_INT NUMBER_YARD_VEHICLES COUNT_OF(YARD_VEHICLE_ENUM)
|
|
CONST_INT NUMBER_YARD_PEDS COUNT_OF(YARD_PED_ENUM)
|
|
CONST_INT NUMBER_BOXCARS 5
|
|
CONST_INT NUMBER_BLOCKING_VEHICLES 2
|
|
CONST_INT CRASH_BUS_ID 14
|
|
CONST_INT NUMBER_GRAB_SCENARIO_PEDS 7
|
|
|
|
CONST_INT MIN_RANDOM_SPEECH_TIME 8000
|
|
CONST_INT MAX_RANDOM_SPEECH_TIME 14000
|
|
|
|
CONST_FLOAT STREAM_FOOT_CHASE_TIME 78000.0
|
|
|
|
CONST_FLOAT CLEAR_POS_RADIUS 3.2
|
|
|
|
CONST_FLOAT BOXCAR_DOOR_Z_OFFSET 1.3
|
|
|
|
//CONST_FLOAT ASSISTED_PATH_WIDTH 1.2
|
|
//CONST_FLOAT ASSISTED_TENSION 1.0
|
|
|
|
CONST_FLOAT CHOP_TURN_MIN_PHASE 0.25
|
|
CONST_FLOAT CHOP_TURN_MAX_PHASE 0.80
|
|
|
|
CONST_FLOAT MAX_LAMAR_SPEED 1.10
|
|
CONST_FLOAT MIN_LAMAR_SPEED 0.80
|
|
|
|
CONST_FLOAT PLAYER_INIT_ROT 93.3
|
|
CONST_FLOAT FRANKLIN_VAN_INIT_ROT 210.17
|
|
CONST_FLOAT FOOT_CHASE_INIT_ROT -19.4
|
|
CONST_FLOAT VAN_CHASE_INIT_ROT 289.94
|
|
CONST_FLOAT LAMAR_WALK_INIT_ROT 95.7
|
|
CONST_FLOAT LAMAR_ALLEY_INIT_ROT 167.35
|
|
CONST_FLOAT FRANKLIN_ALLEY_INIT_ROT 164.80
|
|
CONST_FLOAT RUNNER_CHASE_INIT_ROT -8.69
|
|
CONST_FLOAT CHOP_CHASE_INIT_ROT 27.1
|
|
CONST_FLOAT CHOP_WALK_INIT_ROT 91.93
|
|
CONST_FLOAT CHASE_TRAIN_ROT 141.22
|
|
CONST_FLOAT CAR_IN_ALLEY_ROT -12.7
|
|
CONST_FLOAT DRIVE_INIT_ROT 175.46
|
|
CONST_FLOAT RUNNER_HIDE_ROT 173.0//84.92
|
|
CONST_FLOAT LOSE_RUNNER_ROT 137.26
|
|
CONST_FLOAT BOXCAR_DOOR_ROT 83.89
|
|
CONST_FLOAT CHOP_FIND_INIT_ROT 156.2
|
|
CONST_FLOAT COLLIE_INIT_ROT 81.09
|
|
CONST_FLOAT MOVE_LAST_PLAYER_VEHICLE_ROT 95.68
|
|
CONST_FLOAT VAN_HIDDEN_ROT 87.3
|
|
|
|
// Structs
|
|
STRUCT CHASE_PROPERTIES
|
|
PED_INDEX ped
|
|
CHASE_STATE_ENUM chaseState
|
|
CHASE_ANIM_ENUM chaseAnim
|
|
VECTOR vAnimPos
|
|
VECTOR vAnimRot
|
|
INT iSyncScene
|
|
INT iMovingTime
|
|
BOOL bWaiting
|
|
ENDSTRUCT
|
|
|
|
STRUCT BOXCAR_DOOR
|
|
OBJECT_INDEX obj
|
|
OBJECT_INDEX handleObject
|
|
BOXCAR_DOOR_STATE_ENUM state
|
|
FLOAT fOffset
|
|
ENDSTRUCT
|
|
|
|
STRUCT BOXCAR_CARRIAGE
|
|
OBJECT_INDEX anchorObject
|
|
BLIP_INDEX blip
|
|
CARRIAGE_SEARCH_STATE_ENUM searchState
|
|
BOXCAR_DOOR boxcarDoor[2]
|
|
ENDSTRUCT
|
|
|
|
STRUCT YARD_PED
|
|
PED_INDEX ped
|
|
YARD_PED_STATE_ENUM state
|
|
INT iStateTime
|
|
INT iRecheckLookTime
|
|
BOOL bReactedToChop
|
|
ENDSTRUCT
|
|
|
|
STRUCT GRAB_SCENARIO_PED
|
|
GRAB_SCENARIO_PED_STATE_ENUM state
|
|
PED_INDEX ped
|
|
INT iUpdateTime
|
|
BOOL bDoneSpeech
|
|
ENDSTRUCT
|
|
|
|
// Script-specific variables
|
|
MISSION_INIT_STAGE_ENUM missionInitStage = MISSION_INIT_PRE_INTRO
|
|
MISSION_FAIL_STATE_ENUM missionFailState = MISSION_FAIL_STATE_NOT_FAILED
|
|
MISSION_STAGE_ENUM currentMissionStage
|
|
FAIL_REASON_ENUM savedFailReason
|
|
MISSION_STREAMING_STAGE_ENUM streamingStage
|
|
MOCAP_STREAMING_STAGE_ENUM mocapStreamingStage
|
|
HOOD_CUTSCENE_STAGE_ENUM cutsceneStage
|
|
SELECTOR_PED_STRUCT sSelectorPeds
|
|
ONTO_TRAIN_SHOT_ENUM ontoTrainShot
|
|
LET_OUT_SHOT_ENUM letOutShot
|
|
CHASE_SPEED_STAGE_ENUM chaseSpeedStage
|
|
CHASE_PROPERTIES runnerChaseProperties
|
|
CHASE_PROPERTIES chopChaseProperties
|
|
RUNNER_STAGE_ENUM runnerStage
|
|
CHOP_STAGE_ENUM chopStage
|
|
CHOP_VIEW_CAM_DATA chopViewCamData
|
|
CHOP_BEHAVIOUR_ENUM chopBehaviour
|
|
CHOP_BEHAVIOUR_SETPIECE_STAGE_ENUM chopBehaviourSetpieceStage
|
|
SETPIECE_STAGE_ENUM setpieceStage
|
|
YARD_PED yardPed[COUNT_OF(YARD_PED_ENUM)]
|
|
BOXCAR_CARRIAGE boxcarCarriage[NUMBER_BOXCARS]
|
|
GRAB_SCENARIO_PED grabScenarioPed[NUMBER_GRAB_SCENARIO_PEDS]
|
|
UBER_TRAILER_STATE_ENUM uberTrailerState
|
|
LAMAR_PHONE_STATE_ENUM lamarPhoneState
|
|
CHOP_HUMP_STATE_ENUM chopHumpState
|
|
CHOP_SNIFF_STATE_ENUM chopSniffState
|
|
CHOP_WAIT_STATE_ENUM chopWaitState
|
|
CHOP_AUDIO_CONTEXT_ENUM lastChopAudioContext
|
|
CHOP_BYPASS_FENCE_STATE_ENUM chopBypassFenceState
|
|
|
|
DROPOFF_STAGE_ENUM dropoffStage
|
|
DRIVER_OUT_STATE_ENUM driverOutState
|
|
CREATE_POST_INTRO_STAGE_ENUM createPostIntroStage
|
|
CREATE_BAD_GUY_STAGE_ENUM createBadGuyStage
|
|
CREATE_BLOCKING_VEHICLES_STAGE_ENUM createBlockingVehiclesStage
|
|
CRASH_TRIGGER_STATE_ENUM crashTriggerState
|
|
CHOP_INTO_VAN_STATE_ENUM chopIntoVanState
|
|
CREATE_YARD_STAGE_ENUM createYardStage
|
|
CREATE_CARS_STAGE_ENUM createCarsStage
|
|
CREATE_TRAINS_STAGE_ENUM createTrainsStage
|
|
OPEN_TARGET_CONTAINER_STATE_ENUM openTargetContainerState
|
|
BALLA_DISCOVERED_STATE_ENUM ballaDiscoveredState
|
|
RUN_HELP_STATE_ENUM runHelpState
|
|
CHOP_LEAN_IN_VAN_STATE_ENUM chopLeanInVanState
|
|
FRANKLIN_MASK_REMOVE_STATE_ENUM franklinMaskRemoveState
|
|
CALL_CHOP_BACK_STATE_ENUM callChopBackState
|
|
FAKE_CELLPHONE_DATA fakeCellphoneData
|
|
CHOP_BEHAVIOUR_SPEECH_STATE_ENUM chopBehaviourSpeechState
|
|
SHAPE_TEST_STATE_ENUM shapeTestState
|
|
|
|
|
|
// Peds
|
|
PED_INDEX lamarPed
|
|
PED_INDEX chopPed
|
|
PED_INDEX girlPed
|
|
PED_INDEX colliePed
|
|
PED_INDEX driverPed[NUMBER_YARD_VEHICLES + NUMBER_TRAINS]
|
|
|
|
// Vehicles
|
|
VEHICLE_INDEX hoodVehicle[COUNT_OF(HOOD_VEHICLE_ENUM)]
|
|
VEHICLE_INDEX yardVehicle[NUMBER_YARD_VEHICLES]
|
|
VEHICLE_INDEX trainVehicle[NUMBER_TRAINS]
|
|
VEHICLE_INDEX blockingVehicle[NUMBER_BLOCKING_VEHICLES]
|
|
VEHICLE_INDEX uberTrailerVehicle
|
|
//VEHICLE_INDEX cameraVehicle
|
|
|
|
// Objects
|
|
OBJECT_INDEX lamarPhoneObject
|
|
OBJECT_INDEX franklinBandanaObject
|
|
|
|
// Blips
|
|
BLIP_INDEX franklinVanBlip
|
|
BLIP_INDEX lamarBlip
|
|
BLIP_INDEX runnerBlip
|
|
BLIP_INDEX badGuyCarBlip
|
|
BLIP_INDEX destinationBlip
|
|
//BLIP_INDEX trainBlip
|
|
BLIP_INDEX chopBlip
|
|
//BLIP_INDEX alleyBlip
|
|
|
|
// Cameras
|
|
CAMERA_INDEX staticCam
|
|
CAMERA_INDEX interpCam
|
|
//CAMERA_INDEX chaseCam
|
|
CAMERA_INDEX animCam
|
|
CAMERA_INDEX chopSwitchCam
|
|
|
|
// Bools
|
|
BOOL bModelRequestTracker[COUNT_OF(HOOD_MODEL_ENUM)]
|
|
BOOL bVehicleRecordingRequestTracker[NUMBER_RECORDING_REQUEST_SLOTS]
|
|
BOOL bAnimDictRequestTracker[COUNT_OF(HOOD_ANIM_DICT_ENUM)]
|
|
BOOL bWaypointRequestTracker[NUMBER_WAYPOINT_REQUEST_SLOTS]
|
|
BOOL bWeaponRequestTracker[COUNT_OF(HOOD_WEAPON_ENUM)]
|
|
BOOL bPTFXRequestTracker[COUNT_OF(HOOD_PTFX_ENUM)]
|
|
BOOL bSFXRequestTracker[COUNT_OF(HOOD_SFX_ENUM)]
|
|
BOOL bMiscAssetRequestTracker[COUNT_OF(HOOD_MISC_ASSET_ENUM)]
|
|
BOOL bThoroughCleanup
|
|
BOOL bForcePassOnShitskip
|
|
BOOL bRunningCutscene
|
|
BOOL bSkippedCutscene
|
|
BOOL bClearedForCutscene
|
|
BOOL bCutsceneWaitStarted
|
|
BOOL bShownGodText
|
|
BOOL bShouldDoGetInText
|
|
BOOL bDoneBanter
|
|
BOOL bSavedBanter
|
|
BOOL bCheckedKillBanter
|
|
BOOL bDoneReturnSpeech
|
|
BOOL bKilledSpeechForArrive
|
|
BOOL bTriggeredLamarDamageReaction
|
|
BOOL bDoneIntroCreateEntities
|
|
BOOL bDoneIntroClearStart
|
|
//BOOL bDoneConversationAnim[8]
|
|
BOOL bDoneHurrySpeech
|
|
BOOL bShownHurryPrompt
|
|
BOOL bTurnedOffPhoneForWalk
|
|
BOOL bKilledOnFootConversation
|
|
BOOL bDoneWaitForLamarPrompt
|
|
BOOL bDoneGetLamarPrompt
|
|
BOOL bLamarWalkPaused
|
|
BOOL bDoneChopGetInSpeech
|
|
BOOL bDoneLamarIntoVan
|
|
BOOL bDoneArriveSpeech
|
|
BOOL bDoneChopBehaviourSpeech
|
|
BOOL bDoneCreepSpeech
|
|
BOOL bDoneUphillSpeech
|
|
BOOL bDoneBadGuySpookedReact
|
|
BOOL bClearedPlayerRun
|
|
BOOL bUsingActionCam
|
|
BOOL bTempLamarvan
|
|
BOOL bDoneBusSmash
|
|
BOOL bKnockedOffBike
|
|
BOOL bPedOffBikeAI
|
|
BOOL bDoneCrashReactionSpeech
|
|
BOOL bKilledSpeechForCrashReaction
|
|
BOOL bResetScriptRagdoll
|
|
BOOL bForcedRunnerDismount
|
|
BOOL bDoneGetChopSpeech
|
|
BOOL bDoneReleaseChopSpeech
|
|
BOOL bDoneLamarEncourageSpeech
|
|
BOOL bBlipAlley
|
|
BOOL bSetWorkerDefault
|
|
//BOOL bShownAlleyPrompt
|
|
//BOOL bRemoveAlleyBlip
|
|
BOOL bDoneWontCatchComplainSpeech
|
|
BOOL bDoneWontCatchReplySpeech
|
|
BOOL bDoneDownhillSpeech
|
|
BOOL bDoneGoingLeftSpeech
|
|
BOOL bDoneGoingDownAlleySpeech
|
|
BOOL bDoneUseAbilitySpeech
|
|
BOOL bShownSpecialAbilityHelp
|
|
BOOL bSpeedUpBikeInAlley
|
|
BOOL bPausedBlockingTraffic
|
|
BOOL bPausedCrashBus
|
|
BOOL bStartedRunnerMovement
|
|
BOOL bStartedChopMovement
|
|
//BOOL bForcedJumpOffRoof
|
|
BOOL bStartedYardVehicle[NUMBER_YARD_VEHICLES]
|
|
BOOL bStartedTrain[NUMBER_TRAINS]
|
|
BOOL bFranklinWarp[COUNT_OF(FRANKLIN_WARP_ENUM)]
|
|
//BOOL bDoneOffRoofCut
|
|
BOOL bDoneDriverSwear
|
|
BOOL bDoneDriverLookAtChop
|
|
//BOOL bShownChopFenceHelp
|
|
//BOOL bPlayingChopWaitTurnAnim
|
|
BOOL bCheckedContainerWait
|
|
BOOL bBypassedFence
|
|
BOOL bDoneThroughFenceCut
|
|
BOOL bDoRunAfterFence
|
|
BOOL bSmashedFence
|
|
BOOL bFranklinShoutBeforeTrain
|
|
BOOL bDoneOnTrainCut
|
|
BOOL bRepositionedFranklinForTrain
|
|
BOOL bGotToTrain
|
|
BOOL bDoneChopGoToTrain
|
|
BOOL bDoneSecondFindSpeech
|
|
BOOL bDoneWhereGoingSpeech
|
|
BOOL bDoneThisWillGetBumpySpeech
|
|
BOOL bDoneNoChopSpeech
|
|
BOOL bDoneThreatenChopSpeech
|
|
BOOL bDoingChopPull
|
|
BOOL bDoneCommentOnBehaviourSpeech
|
|
BOOL bShouldCommentOnBehaviour
|
|
BOOL bDoneGetBackOnSpeech
|
|
BOOL bDoneGetClosePrompt
|
|
BOOL bDoneGoAwaySpeech
|
|
BOOL bDoneItsADudeSpeech
|
|
BOOL bRepositionedBallaHiding
|
|
BOOL bDoneChopSniffSFX
|
|
//BOOL bShownFranklinSwitchPrompt
|
|
BOOL bDoneReactToRunStatSpeech
|
|
BOOL bBlippedFirstBoxcars
|
|
BOOL bBlippedSecondBoxcars
|
|
BOOL bShownBoxcarPrompt
|
|
BOOL bOpeningBoxcarInProgress
|
|
BOOL bDoneBoxcarSpeech
|
|
BOOL bDoneSearchBoxcarSpeech
|
|
BOOL bDoneEmptyBoxcarSpeech
|
|
BOOL bRestoredBoxcarGameplayCam
|
|
BOOL bDoneDoorSlideSound
|
|
BOOL bDoneDoorLimitSound
|
|
BOOL bFoundBadGuy
|
|
BOOL bDoneFoundBadGuySpeech
|
|
BOOL bDoneChopChaseFoundBalla
|
|
BOOL bDoneRunnerFallOver
|
|
BOOL bAllowKidnapCutscene
|
|
BOOL bDoneChopTakeDown
|
|
BOOL bDoneRunnerRelax
|
|
BOOL bDoneGetHisAssSpeech
|
|
BOOL bDoneDRunSpeech
|
|
BOOL bDoneDFallSpeech
|
|
BOOL bShownLetOutPrompt
|
|
BOOL bInLoseWantedState
|
|
BOOL bShownLoseWantedPrompt
|
|
BOOL bRemovedGirl
|
|
BOOL bRemovedTraffic
|
|
BOOL bShownChopViewHelp
|
|
BOOL bShownQuickSwitchHelp
|
|
BOOL bCancelledChopHint
|
|
BOOL bRemovedBusStation
|
|
BOOL bRemovedChaseSetpieces
|
|
BOOL bDoneGotoSpeech
|
|
BOOL bPhoneForceApplied
|
|
BOOL bChopTurnToIdle
|
|
BOOL bChopResetInIdle
|
|
BOOL bDoneLoseWantedSpeech
|
|
BOOL bDoneLoseReactSpeech
|
|
BOOL bRemovedBlipsForWanted
|
|
BOOL bShownCallChopHelp
|
|
BOOL bShownChopBehaviourHelp
|
|
BOOL bDoneChaseScent
|
|
BOOL bDoneGetOutSpeech
|
|
BOOL bDoneLetOut
|
|
BOOL bDoneThreatenResponseSpeech
|
|
BOOL bDoneLamarShoutSpeech
|
|
BOOL bDoneFranklinShoutSpeech
|
|
//BOOL bKilledConversationOnLetOut
|
|
//BOOL bBadGuyRun
|
|
BOOL bRemovedBike
|
|
BOOL bFrozenVan
|
|
BOOL bRestoredBadGuyDamage
|
|
BOOL bLamarOutOfVan
|
|
BOOL bCallChopBackSuccess
|
|
BOOL bDoneFranklinIntoVanSpeech
|
|
BOOL bKilledSpeechForVan
|
|
BOOL bResetDirectEntryFlag
|
|
BOOL bShownFirstDownloadHelp
|
|
BOOL bDoneBreakFenceAudioScene
|
|
BOOL bKilledTalkAboutMichaelSpeech
|
|
BOOL bStoppedChopExcitement
|
|
BOOL bInterpedToGameCam
|
|
BOOL bRepositionedPlayerForTOD
|
|
BOOL bCleanedUpPhone
|
|
BOOL bCleanedUpBalla
|
|
BOOL bApplyStartBoost
|
|
BOOL bShownSwitchToCallHelp
|
|
BOOL bSetBikeAsSmoking
|
|
BOOL bShownSwitchToOpenHelp
|
|
BOOL bOpenedAnyCarriage
|
|
BOOL bResetOpenedAnyCarriage
|
|
BOOL bLamarWaitingAtVan
|
|
BOOL bFranklinWentAhead
|
|
BOOL bLamarWasInGroup
|
|
BOOL bDoneLamarWalkToVan
|
|
BOOL bDoneJumpHelp
|
|
BOOL bDoingDistantSiren
|
|
BOOL bShownNoStaminaHelp
|
|
BOOL bSetDamageOnBadGuy
|
|
BOOL bStartedLetOutCutscene
|
|
BOOL bAllowRunnerMovement
|
|
BOOL bShutLDoor
|
|
BOOL bShutRDoor
|
|
BOOL bWasTimeLapseRunning
|
|
BOOL bClearedChopTask
|
|
BOOL bWarpedVanToAlley
|
|
BOOL bWarpedToChaseEnd
|
|
BOOL bLamarShouldBeInGroup
|
|
BOOL bAddedChopToMixGroup
|
|
BOOL bShownHoodSlideHelp
|
|
BOOL bStoppedVanAnim
|
|
BOOL bRunningWhenTriggeredChopCam
|
|
BOOL bDisabledCamOnMediumSwitch
|
|
BOOL bEnabledCamOnMediumSwitch
|
|
BOOL bSkippedIntro
|
|
BOOL bKilledSpeechAtCutscene
|
|
BOOL bRemovedBuses
|
|
BOOL bRemovedCarpark
|
|
BOOL bDoneCutsceneBlood
|
|
BOOL bDoneWhistleSound
|
|
BOOL bFirstDownloadHelpOnCutscene
|
|
BOOL bSetIssiNoCollision
|
|
BOOL bForcedIntoVan
|
|
BOOL bDoneHelloChopSpeech
|
|
BOOL bDoneAreYouOKChopSpeech
|
|
BOOL bDoneLaughAtFranklinSpeech
|
|
BOOL bUsedAbility
|
|
BOOL bDoneBoxcarCutsceneCam
|
|
BOOL bKilledPreloadSpeech
|
|
BOOL bDoneFocusOnBikeAudioScene
|
|
BOOL bWarpedLamarToVan
|
|
BOOL bBlockedCustoms
|
|
BOOL bResetBallaGetUp
|
|
|
|
BOOL bDoneLamarPullGunCue
|
|
BOOL bDoneBikeSpeedOffCue
|
|
BOOL bDoneInVanCue
|
|
BOOL bDoneGetOutCue
|
|
BOOL bDoneChopCamCue
|
|
BOOL bPreparedSmashFenceCue
|
|
BOOL bDoneSmashFenceCue
|
|
BOOL bDoneBypassFenceCue
|
|
BOOL bDoneGotoCollieCue
|
|
BOOL bDoneMountCue
|
|
BOOL bDoneDismountCue
|
|
BOOL bDoneBlipSecondBoxcarsCue
|
|
BOOL bDoneFoundCue
|
|
BOOL bPreparedBaddyCue
|
|
BOOL bDoneBaddyCue
|
|
BOOL bSuppressFutureReplaySetups
|
|
BOOL bShutVanDoors
|
|
BOOL bSetTrevorUnavailable
|
|
BOOL bBackBlocked
|
|
BOOL bHadFirstLineOfBanter
|
|
BOOL bDoneTrainingSpeech
|
|
BOOL bFailForLost
|
|
BOOL bDonePoliceReport
|
|
BOOL bRevertedReverseBusAudio // NG
|
|
BOOL bDoneFlash
|
|
|
|
|
|
// Vectors
|
|
VECTOR vRunnerAttachToVanPos
|
|
VECTOR vRunnerAttachToVanRot
|
|
VECTOR vHumpPos
|
|
VECTOR vHumpEntry
|
|
VECTOR vLamarSyncScenePos
|
|
VECTOR vChopSyncScenePos
|
|
VECTOR vLamarSyncSceneRot
|
|
VECTOR vChopSyncSceneRot
|
|
VECTOR vTargetTakedownPos
|
|
VECTOR vTargetTakedownRot
|
|
VECTOR vPlayerSyncScenePos
|
|
VECTOR vPlayerSyncSceneRot
|
|
VECTOR vTargetOpenPos
|
|
VECTOR vTargetOpenRot
|
|
//VECTOR vLastChopPTFXPos
|
|
|
|
// Floats
|
|
FLOAT fCarChaseSpeed
|
|
FLOAT fDesiredSpeed
|
|
FLOAT fHumpRot
|
|
FLOAT fLamarWalkSpeed
|
|
FLOAT fNoSpeechTime
|
|
FLOAT fCachedVanSpeed
|
|
FLOAT fDisplayBadPositionTime
|
|
FLOAT fLamarJammedTime
|
|
|
|
FLOAT fChopOverride
|
|
FLOAT fChopThroughBoxcarSpeed
|
|
FLOAT fTrainCruiseSpeed[NUMBER_TRAINS]
|
|
|
|
// Ints
|
|
INT iCachedVanHealth
|
|
INT iReplayAttempt
|
|
INT iAllowSkipCutsceneTime
|
|
INT iHoodCutsceneTime
|
|
INT iCutsceneTriggerTime
|
|
INT iGetInTextStage
|
|
INT iNextRandomSpeechTime
|
|
INT iNextChopSoundTime
|
|
INT iStageStartTime
|
|
INT iNextLamarHurrySpeechTime
|
|
INT iVanChaseSpeechStage
|
|
INT iDontShootSpeechStage
|
|
INT iNextDontShootSpeechTime
|
|
INT iUseAbilitySpeechTime
|
|
INT iRunnerStageStartTime
|
|
INT iRunnerWaitTime
|
|
INT iSetpieceStageStartTime
|
|
INT iNextCheckVanHealthTime
|
|
INT iTriggerPostBanterSpeechTime
|
|
//INT iNextMaulTime
|
|
INT iTrainStartedTime[NUMBER_TRAINS]
|
|
//INT iActivateChopCamTime
|
|
INT iShowChopHelpTime
|
|
INT iClearHelpTime
|
|
INT iChopBehaviourHelpTime
|
|
INT iChopBehaviourStageTime
|
|
INT iLastCallSpeechTime
|
|
INT iLetOutPromptTime
|
|
INT iCurrentFootChaseCutscene
|
|
INT iChopSniffStateTime
|
|
INT iNextChopSniffTime
|
|
INT iLamarSyncScene
|
|
INT iCollieSyncScene
|
|
//INT iChopWaitTime
|
|
INT iChopWaypointProgress
|
|
INT iScentWaypoint
|
|
INT iDriverOutTime
|
|
INT iSpeedZone
|
|
INT iChopBounceOnCarStage
|
|
//INT iBusSmashTime
|
|
INT iOpenTargetBoxcarTime
|
|
INT iStartHumpTime
|
|
INT iCreateVanTime
|
|
INT iOpenBoxcarTime
|
|
INT iSyncScene
|
|
INT iDoorSyncScene
|
|
INT iHandleSyncScene
|
|
INT iBoxcarCamSyncScene
|
|
INT iRunnerFallOverTime
|
|
INT iLastChopGotoTime
|
|
INT iThroughFenceTime
|
|
INT iRestoreBadGuyDamageTime
|
|
INT iLamarOutOfVanTime
|
|
INT iFranklinMaskRemoveTime
|
|
INT iStopChopExcitementTime
|
|
INT iNextChopExcitementTime
|
|
INT iNextFindSpeechTime
|
|
INT iGetHisAssSpeechTime
|
|
INT iInitialStaminaValue
|
|
INT iKnockOffBikeTime
|
|
INT iOpenVanDoorSoundStage
|
|
INT iLoseWantedTime
|
|
INT iDidCallBackAnimTime
|
|
INT iNextChopAnimTime
|
|
INT iNextBarkTime
|
|
INT iStartedLetOutCutsceneTime
|
|
INT iLetOutShotTime
|
|
INT iLeftBoxcarCam
|
|
INT iRightBoxcarCam
|
|
INT iNextBallaVanChaseSpeechTime
|
|
INT iCurrentChopCollar
|
|
INT iSlowDownTime
|
|
INT iEnterVanTaskTime
|
|
INT iForceChopIntoVanTime
|
|
INT iLastChopMoveCommandTime
|
|
INT iDoLetOutPromptTime
|
|
INT iLaughAtFranklinTime
|
|
INT iFailWantedTime
|
|
INT iWhistleSoundID = GET_SOUND_ID()
|
|
INT iFailForLostTime
|
|
INT iBoxcarTriggerTime
|
|
INT iBlockJumpTime
|
|
INT iCreateBadGuyTime
|
|
INT iCreateBlockingVehiclesTime
|
|
FLOAT fLamarSpeedCount
|
|
|
|
// Other variables
|
|
SEQUENCE_INDEX sequence
|
|
PTFX_ID scentPTFX
|
|
//PTFX_ID bloodPTFX
|
|
SCRIPTTASKSTATUS taskStatus
|
|
structPedsForConversation hoodConversation
|
|
RAGDOLL_BLOCKING_FLAGS chaseRagdollBlockingFlags = RBF_PLAYER_IMPACT | RBF_VEHICLE_IMPACT
|
|
TEXT_LABEL_23 tSavedBanterRoot
|
|
TEXT_LABEL_23 tResumeBanterLabel
|
|
structTimelapse sTimelapse
|
|
SCENARIO_BLOCKING_INDEX entranceScenarioBlocking
|
|
SCENARIO_BLOCKING_INDEX recScenarioBlocking
|
|
SCENARIO_BLOCKING_INDEX alleyScenarioBlocking
|
|
SCENARIO_BLOCKING_INDEX outsideYardScenarioBlocking
|
|
SCENARIO_BLOCKING_INDEX offPathScenarioBlocking
|
|
SHAPETEST_INDEX vanShapeTest
|
|
STREAMVOL_ID missionStreamingVolume
|
|
|
|
// Debug
|
|
#IF IS_DEBUG_BUILD
|
|
WIDGET_GROUP_ID hoodWidgets
|
|
TEXT_WIDGET_ID RBCamPosWidget, RBCamRotWidget
|
|
BOOL bRBDebugCamDoDump
|
|
VECTOR vRBDebugCamPos
|
|
VECTOR vRBDebugCamRot
|
|
FLOAT fRBDebugCamFOV
|
|
VECTOR vDebugVanCamOffset = <<0,0,0>>
|
|
VECTOR vDebugVanCamPoint = <<0,0,0>>
|
|
FLOAT fDebugVanCamFOV = 50
|
|
VECTOR vDebugBoxcarCamOffset = <<1.800,-0.400,1.050>>
|
|
VECTOR vDebugBoxcarCamPoint = <<0.500,1.800,1.440>>
|
|
FLOAT fDebugBoxcarCamFOV = 26.500
|
|
|
|
MissionStageMenuTextStruct stageMenu[MAX_SKIP_MENU_LENGTH]
|
|
INT iMenuMissionStage
|
|
|
|
INT iDebugStage = -1
|
|
|
|
BOOl bDebugDoUber = FALSE
|
|
BOOL bDebugDoneFootChaseSkip
|
|
BOOL bDrawVehicleRecordingDebug = FALSE
|
|
BOOL bDebugForceOpenBoxcar = FALSE
|
|
#ENDIF
|
|
|
|
// get cutscene name
|
|
FUNC STRING GET_FRANKLIN0_INTRO_CUTSCENE_NAME()
|
|
RETURN "fra_0_int"
|
|
ENDFUNC
|
|
|
|
// get recording prefix
|
|
FUNC STRING GET_HOOD_RECORDING_PREFIX()
|
|
RETURN "fchase"
|
|
ENDFUNC
|
|
|
|
FUNC STRING GET_HOOD_UBER_RECORDING_PREFIX()
|
|
RETURN "fcuber"
|
|
ENDFUNC
|
|
|
|
FUNC STRING GET_INJURED_CLIPSET_NAME()
|
|
RETURN "move_injured_generic"
|
|
ENDFUNC
|
|
|
|
FUNC STRING GET_DESCRIPTION_FOR_STAGE_AS_STRING(MISSION_STAGE_ENUM thisStage)
|
|
SWITCH thisStage
|
|
CASE STAGE_GET_TO_BAD_GUY
|
|
RETURN "Get to Vinewood"
|
|
BREAK
|
|
CASE STAGE_VAN_CHASE
|
|
RETURN "Van chase"
|
|
BREAK
|
|
CASE STAGE_FOOT_CHASE
|
|
RETURN "Foot chase"
|
|
BREAK
|
|
CASE STAGE_FIND_BAD_GUY
|
|
RETURN "Find hiding bad guy"
|
|
BREAK
|
|
CASE STAGE_GET_TO_HOUSE
|
|
RETURN "Drop off gangster"
|
|
BREAK
|
|
ENDSWITCH
|
|
|
|
RETURN "invalid"
|
|
ENDFUNC
|
|
|
|
// can advance mission
|
|
FUNC BOOL CAN_ADVANCE_MISSION()
|
|
IF missionFailState = MISSION_FAIL_STATE_NOT_FAILED
|
|
AND NOT IS_PLAYER_BROWSING_ITEMS_IN_ANY_SHOP()
|
|
RETURN TRUE
|
|
ENDIF
|
|
|
|
RETURN FALSE
|
|
ENDFUNC
|
|
|
|
// do mission god text
|
|
FUNC BOOL DO_MISSION_GOD_TEXT(STRING sGodText, BOOL bSupercedeText = TRUE, BOOL bSupercedeSpeech = FALSE, INT iTime = DEFAULT_GOD_TEXT_TIME)
|
|
IF bSupercedeText OR NOT IS_MESSAGE_BEING_DISPLAYED()
|
|
IF bSupercedeSpeech
|
|
OR NOT IS_ANY_CONVERSATION_ONGOING_OR_QUEUED()
|
|
OR NOT IS_SUBTITLE_PREFERENCE_SWITCHED_ON()
|
|
IF CAN_ADVANCE_MISSION()
|
|
PRINT_NOW(sGodText, iTime, 1)
|
|
RETURN TRUE
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
|
|
RETURN FALSE
|
|
ENDFUNC
|
|
|
|
// do mission help text
|
|
FUNC BOOL DO_MISSION_HELP_TEXT(STRING sHelpText, BOOL bSupercedeHelp = TRUE, INT iOverrideTime = -1)
|
|
IF bSupercedeHelp OR NOT IS_HELP_MESSAGE_BEING_DISPLAYED()
|
|
IF CAN_ADVANCE_MISSION()
|
|
PRINT_HELP(sHelpText, iOverrideTime)
|
|
RETURN TRUE
|
|
ENDIF
|
|
ENDIF
|
|
|
|
RETURN FALSE
|
|
ENDFUNC
|
|
|
|
// do mission speech
|
|
FUNC BOOL DO_MISSION_SPEECH(STRING sSpeech, BOOL bSupercedeText = FALSE, INT iLine = 0, BOOL bFromSpecifiedLine = FALSE, BOOL bDisplaySubtitles = TRUE)
|
|
IF bSupercedeText OR NOT IS_MESSAGE_BEING_DISPLAYED() OR NOT IS_SUBTITLE_PREFERENCE_SWITCHED_ON()
|
|
IF NOT IS_ANY_CONVERSATION_ONGOING_OR_QUEUED()
|
|
IF CAN_ADVANCE_MISSION()
|
|
|
|
enumSubtitlesState subtitlesState
|
|
IF bDisplaySubtitles
|
|
subtitlesState = DISPLAY_SUBTITLES
|
|
ELSE
|
|
subtitlesState = DO_NOT_DISPLAY_SUBTITLES
|
|
ENDIF
|
|
|
|
IF iLine = 0
|
|
RETURN CREATE_CONVERSATION(hoodConversation, "FKN0AUD", sSpeech, CONV_PRIORITY_HIGH, subtitlesState)
|
|
ELSE
|
|
TEXT_LABEL tLine
|
|
tLine = sSpeech
|
|
tLine+="_"
|
|
tLine+=iLine
|
|
IF NOT bFromSpecifiedLine
|
|
RETURN PLAY_SINGLE_LINE_FROM_CONVERSATION(hoodConversation, "FKN0AUD", sSpeech, tLine, CONV_PRIORITY_HIGH, subtitlesState)
|
|
ELSE
|
|
RETURN CREATE_CONVERSATION_FROM_SPECIFIC_LINE(hoodConversation, "FKN0AUD", sSpeech, tLine, CONV_PRIORITY_HIGH, subtitlesState)
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
|
|
RETURN FALSE
|
|
ENDFUNC
|
|
|
|
// remove mission text
|
|
PROC REMOVE_MISSION_TEXT(BOOL bClearSpeech = TRUE, BOOL bClearGodText = TRUE, BOOL bClearHelpText = TRUE, BOOL bKeepSubs = FALSE)
|
|
IF bClearSpeech
|
|
KILL_ANY_CONVERSATION()
|
|
ENDIF
|
|
|
|
IF bClearGodText
|
|
IF NOT IS_ANY_CONVERSATION_ONGOING_OR_QUEUED()
|
|
OR (bClearSpeech AND NOT bKeepSubs)
|
|
CLEAR_PRINTS()
|
|
ENDIF
|
|
CLEAR_REMINDER_MESSAGE()
|
|
ENDIF
|
|
|
|
IF bClearHelpText
|
|
CLEAR_HELP()
|
|
ENDIF
|
|
ENDPROC
|
|
|
|
FUNC BLIP_INDEX CREATE_MISSION_BLIP_FOR_VEHICLE(VEHICLE_INDEX vehicle, bool isEnemyVehicle=FALSE)
|
|
IF CAN_ADVANCE_MISSION()
|
|
RETURN CREATE_BLIP_FOR_VEHICLE(vehicle, isEnemyVehicle)
|
|
ENDIF
|
|
RETURN NULL
|
|
ENDFUNC
|
|
|
|
FUNC BLIP_INDEX CREATE_MISSION_BLIP_FOR_PED(PED_INDEX ped, BOOL isEnemyPed=FALSE, enumCharacterList useCharsheetName = NO_CHARACTER)
|
|
IF CAN_ADVANCE_MISSION()
|
|
RETURN CREATE_BLIP_FOR_PED(ped, isEnemyPed, useCharsheetName)
|
|
ENDIF
|
|
RETURN NULL
|
|
ENDFUNC
|
|
|
|
FUNC BLIP_INDEX CREATE_MISSION_BLIP_FOR_OBJECT(OBJECT_INDEX object)
|
|
IF CAN_ADVANCE_MISSION()
|
|
RETURN CREATE_BLIP_FOR_OBJECT(object)
|
|
ENDIF
|
|
RETURN NULL
|
|
ENDFUNC
|
|
|
|
FUNC BLIP_INDEX CREATE_MISSION_BLIP_FOR_COORD(VECTOR vCoords, BOOL bSetRoute = FALSE)
|
|
IF CAN_ADVANCE_MISSION()
|
|
RETURN CREATE_BLIP_FOR_COORD(vCoords, bSetRoute)
|
|
ENDIF
|
|
RETURN NULL
|
|
ENDFUNC
|
|
|
|
FUNC BOOL TRIGGER_MISSION_MUSIC_EVENT(STRING sEvent)
|
|
RETURN TRIGGER_MUSIC_EVENT(sEvent)
|
|
ENDFUNC
|
|
|
|
// get model for a hood model enum
|
|
FUNC MODEL_NAMES GET_MODEL_FOR_HOOD_MODEL_ENUM(HOOD_MODEL_ENUM hModel)
|
|
SWITCH hModel
|
|
CASE HM_FRANKLIN
|
|
RETURN GET_PLAYER_PED_MODEL(CHAR_FRANKLIN)
|
|
BREAK
|
|
CASE HM_LAMAR
|
|
RETURN GET_NPC_PED_MODEL(CHAR_LAMAR)
|
|
BREAK
|
|
CASE HM_BAD_GUY
|
|
RETURN IG_BALLASOG
|
|
BREAK
|
|
CASE HM_CHOP
|
|
RETURN GET_CHOP_MODEL()
|
|
BREAK
|
|
CASE HM_COLLIE
|
|
RETURN A_C_ROTTWEILER
|
|
BREAK
|
|
CASE HM_GIRL
|
|
RETURN A_F_Y_GENHOT_01
|
|
BREAK
|
|
CASE HM_WORKER
|
|
RETURN S_M_Y_Construct_02
|
|
BREAK
|
|
CASE HM_FRANKLIN_VAN
|
|
RETURN GET_NPC_VEH_MODEL(CHAR_LAMAR)
|
|
BREAK
|
|
CASE HM_BIKE
|
|
RETURN BATI
|
|
BREAK
|
|
CASE HM_TRAFFIC_CAR1
|
|
RETURN EMPEROR
|
|
BREAK
|
|
CASE HM_TRAFFIC_CAR2
|
|
RETURN BISON
|
|
BREAK
|
|
CASE HM_BUS
|
|
RETURN BUS
|
|
BREAK
|
|
CASE HM_TRAILER
|
|
RETURN TRAILERS2
|
|
BREAK
|
|
CASE HM_ENGINE
|
|
RETURN FREIGHT
|
|
BREAK
|
|
CASE HM_TANKER_CARRIAGE
|
|
RETURN TANKERCAR
|
|
BREAK
|
|
CASE HM_CONTAINER_CARRIAGE
|
|
RETURN FREIGHTCONT2
|
|
BREAK
|
|
CASE HM_BLOCKING_TRUCK
|
|
RETURN RUBBLE
|
|
BREAK
|
|
CASE HM_BLOCKING_CAR
|
|
RETURN ROCOTO
|
|
BREAK
|
|
CASE HM_BOXCAR_DOOR
|
|
RETURN PROP_RAIL_BOXCAR5_D
|
|
BREAK
|
|
CASE HM_BOXCAR_HANDLE
|
|
RETURN PROP_BOXCAR5_HANDLE
|
|
BREAK
|
|
CASE HM_LAMAR_PHONE
|
|
RETURN PROP_NPC_PHONE
|
|
BREAK
|
|
CASE HM_FRANKLIN_MASK
|
|
RETURN P_CS_BANDANA_S
|
|
BREAK
|
|
CASE HM_ANCHOR
|
|
RETURN Prop_LD_Test_01
|
|
BREAK
|
|
CASE HM_START_VEHICLE
|
|
RETURN GET_REPLAY_START_VEHICLE_MODEL()
|
|
BREAK
|
|
ENDSWITCH
|
|
|
|
RETURN DUMMY_MODEL_FOR_SCRIPT
|
|
ENDFUNC
|
|
|
|
// suppress vehicles
|
|
PROC SUPPRESS_MISSION_MODELS(BOOL bSuppress)
|
|
SET_VEHICLE_MODEL_IS_SUPPRESSED(GET_MODEL_FOR_HOOD_MODEL_ENUM(HM_FRANKLIN_VAN), bSuppress)
|
|
SET_VEHICLE_MODEL_IS_SUPPRESSED(GET_MODEL_FOR_HOOD_MODEL_ENUM(HM_BIKE), bSuppress)
|
|
SET_VEHICLE_MODEL_IS_SUPPRESSED(FORKLIFT, bSuppress)
|
|
SET_VEHICLE_MODEL_IS_SUPPRESSED(GET_MODEL_FOR_HOOD_MODEL_ENUM(HM_BLOCKING_TRUCK), bSuppress)
|
|
SET_VEHICLE_MODEL_IS_SUPPRESSED(GET_MODEL_FOR_HOOD_MODEL_ENUM(HM_BLOCKING_CAR), bSuppress)
|
|
SET_PED_MODEL_IS_SUPPRESSED(GET_MODEL_FOR_HOOD_MODEL_ENUM(HM_BAD_GUY), bSuppress)
|
|
SET_PED_MODEL_IS_SUPPRESSED(GET_MODEL_FOR_HOOD_MODEL_ENUM(HM_LAMAR), bSuppress)
|
|
|
|
IF bSuppress = FALSE
|
|
SET_VEHICLE_MODEL_IS_SUPPRESSED(BUS, bSuppress)
|
|
ENDIF
|
|
ENDPROC
|
|
|
|
// set player out of any vehicle
|
|
PROC SET_PLAYER_OUT_OF_ANY_VEHICLE()
|
|
IF NOT IS_PED_INJURED(PLAYER_PED_ID())
|
|
IF IS_PED_IN_ANY_VEHICLE(PLAYER_PED_ID())
|
|
VECTOR vCoords = GET_ENTITY_COORDS(PLAYER_PED_ID())
|
|
SET_ENTITY_COORDS(PLAYER_PED_ID(), <<vCoords.x, vCoords.y, vCoords.z + 1>>)
|
|
ENDIF
|
|
ENDIF
|
|
ENDPROC
|
|
|
|
// disable/reenable cargens
|
|
PROC ENABLE_CARGENS_FOR_MISSION(BOOL bEnable)
|
|
SET_ALL_VEHICLE_GENERATORS_ACTIVE_IN_AREA(<<428.19, -688.97, 10.0>>, <<677.84, -388.92, 36.0>>, bEnable)
|
|
SET_ALL_VEHICLE_GENERATORS_ACTIVE_IN_AREA(<<-233, -1505.74, -10.0>>, <<-199, -1467, 110.0>>, bEnable)
|
|
SET_ALL_VEHICLE_GENERATORS_ACTIVE_IN_AREA(<<495.9, -652.6, -10.0>>, <<513.0, -635.9, 110.0>>, bEnable)
|
|
//SET_PARKED_VEHICLE_DENSITY_MULTIPLIER_THIS_FRAME(0.0)
|
|
ENDPROC
|
|
|
|
// clear cargens for foot chase
|
|
PROC CLEAR_CARGENS_FOR_FOOT_CHASE()
|
|
CLEAR_AREA(<<466, -579, 28>>, 5.0, TRUE)
|
|
REMOVE_VEHICLES_FROM_GENERATORS_IN_AREA(<<461, -584, 23>>, <<471, -574, 33>>)
|
|
CLEAR_AREA(<<512, -509, 25>>, 5.0, TRUE)
|
|
REMOVE_VEHICLES_FROM_GENERATORS_IN_AREA(<<507, -514, 20>>, <<517, -504, 30>>)
|
|
ENDPROC
|
|
|
|
// switch off roads for mission
|
|
PROC SET_HOOD_ROADS_OFF(BOOL bSwitchOff, BOOL bSwitchOffJunction = FALSE)
|
|
INT i
|
|
VECTOR vMin
|
|
VECTOR vMax
|
|
|
|
// roads
|
|
REPEAT 4 i
|
|
SWITCH i
|
|
CASE 0
|
|
vMin = <<271.58, -842.98, 16.61>>
|
|
vMax = <<554.26, -619.07, 48.80>>
|
|
BREAK
|
|
CASE 1
|
|
vMin = <<365.07, 67.98, 75.12>>
|
|
vMax = <<509.20, 151.22, 121.17>>
|
|
BREAK
|
|
CASE 2
|
|
vMin = <<-91.34664, -1457.38464, 0.78976>>
|
|
vMax = <<-73.12756, -1381.66003, 48.33570>>
|
|
BREAK
|
|
CASE 3
|
|
vMin = <<454.75815, -817.23328, 0.70810>>
|
|
vMax = <<459.41602, -685.39819, 56.66263>>
|
|
BREAK
|
|
ENDSWITCH
|
|
|
|
IF bSwitchOff
|
|
IF bSwitchOffJunction
|
|
OR i < 3
|
|
SET_ROADS_IN_AREA(vMin, vMax, FALSE)
|
|
ENDIF
|
|
ELSE
|
|
SET_ROADS_BACK_TO_ORIGINAL(vMin, vMax)
|
|
ENDIF
|
|
ENDREPEAT
|
|
|
|
PRINTSTRING("turn off ped paths") PRINTNL()
|
|
// ped paths
|
|
REPEAT 4 i
|
|
SWITCH i
|
|
CASE 0
|
|
vMin = <<-76.73, -1477.92, 21.17>>
|
|
vMax = <<16.05, -1447.28, 59.54>>
|
|
BREAK
|
|
CASE 1
|
|
vMin = <<487.24, -670.92, 0>>
|
|
vMax = <<591.02, -527.37, 100>>
|
|
BREAK
|
|
CASE 2
|
|
vMin = <<515.81, -729.95, 0>>
|
|
vMax = <<567.66, -647.36, 100>>
|
|
BREAK
|
|
CASE 3
|
|
vMin = <<454.75815, -817.23328, 0.70810>>
|
|
vMax = <<459.41602, -685.39819, 56.66263>>
|
|
BREAK
|
|
ENDSWITCH
|
|
|
|
IF bSwitchOff
|
|
PRINTSTRING("OFF ") PRINTINT(i) PRINTNL()
|
|
SET_PED_PATHS_IN_AREA(vMin, vMax, FALSE)
|
|
IF i=3
|
|
PRINTSTRING("set the non creation area") PRINTINT(i) PRINTNL()
|
|
SET_PED_NON_CREATION_AREA(vMin, vMax)
|
|
ENDIF
|
|
ELSE
|
|
SET_PED_PATHS_BACK_TO_ORIGINAL(vMin, vMax)
|
|
CLEAR_PED_NON_CREATION_AREA()
|
|
ENDIF
|
|
ENDREPEAT
|
|
ENDPROC
|
|
|
|
FUNC STRING GET_HOOD_AUDIO_SCENE_AS_STRING(HOOD_AUDIO_SCENE_ENUM thisScene)
|
|
SWITCH thisScene
|
|
CASE HOOD_AUDIO_SCENE_WALK_TO_VAN
|
|
RETURN "FRANKLIN_0_WALK_TO_VAN"
|
|
BREAK
|
|
CASE HOOD_AUDIO_SCENE_DRIVE_TO_VINEWOOD
|
|
RETURN "FRANKLIN_0_DRIVE_TO_VINEWOOD"
|
|
BREAK
|
|
CASE HOOD_AUDIO_SCENE_CAR_CHASE
|
|
RETURN "FRANKLIN_0_CAR_CHASE"
|
|
BREAK
|
|
CASE HOOD_AUDIO_SCENE_FOOT_CHASE_START
|
|
RETURN "FRANKLIN_0_FOOT_CHASE_START"
|
|
BREAK
|
|
CASE HOOD_AUDIO_SCENE_BREAK_THROUGH_FENCE
|
|
RETURN "FRANKLIN_0_BREAK_THROUGH_FENCE"
|
|
BREAK
|
|
CASE HOOD_AUDIO_SCENE_D_ESCAPES
|
|
RETURN "FRANKLIN_0_D_ESCAPES"
|
|
BREAK
|
|
CASE HOOD_AUDIO_SCENE_SEARCH_BOXCARS
|
|
RETURN "FRANKLIN_0_SEARCH_BOXCARS"
|
|
BREAK
|
|
CASE HOOD_AUDIO_SCENE_DRIVE_TO_LAMARS
|
|
RETURN "FRANKLIN_0_DRIVE_TO_LAMARS"
|
|
BREAK
|
|
CASE HOOD_AUDIO_SCENE_TAKE_LAMAR_BACK
|
|
RETURN "FRANKLIN_0_TAKE_LAMAR_BACK"
|
|
BREAK
|
|
CASE HOOD_AUDIO_SCENE_CHOP_CAM
|
|
RETURN "FRANKLIN_0_CHOP_CAM"
|
|
BREAK
|
|
CASE HOOD_AUDIO_SCENE_FOCUS_CAM
|
|
RETURN "FRANKLIN_0_FOCUS_ON_BIKER"
|
|
BREAK
|
|
ENDSWITCH
|
|
|
|
RETURN ""
|
|
ENDFUNC
|
|
|
|
// start train crash audio scene
|
|
FUNC BOOL START_HOOD_AUDIO_SCENE(HOOD_AUDIO_SCENE_ENUM thisScene)
|
|
RETURN START_AUDIO_SCENE(GET_HOOD_AUDIO_SCENE_AS_STRING(thisScene))
|
|
ENDFUNC
|
|
|
|
// stop train crash audio scene
|
|
PROC STOP_HOOD_AUDIO_SCENE(HOOD_AUDIO_SCENE_ENUM thisScene)
|
|
STOP_AUDIO_SCENE(GET_HOOD_AUDIO_SCENE_AS_STRING(thisScene))
|
|
ENDPROC
|
|
|
|
// stop all train crash audio scenes
|
|
PROC STOP_ALL_HOOD_AUDIO_SCENES()
|
|
INT i
|
|
REPEAT COUNT_OF(HOOD_AUDIO_SCENE_ENUM) i
|
|
STOP_HOOD_AUDIO_SCENE(INT_TO_ENUM(HOOD_AUDIO_SCENE_ENUM, i))
|
|
ENDREPEAT
|
|
ENDPROC
|
|
|
|
// set franklin mask
|
|
PROC SET_FRANKLIN_MASK(BOOL bSet)
|
|
IF NOT IS_PED_INJURED(PLAYER_PED_ID())
|
|
IF bSet
|
|
SET_PED_COMP_ITEM_CURRENT_SP(PLAYER_PED_ID(),COMP_TYPE_SPECIAL, SPECIAL_P1_MASK, FALSE)
|
|
//SET_PED_COMPONENT_VARIATION(PLAYER_PED_ID(), PED_COMP_SPECIAL, 9, 0)
|
|
ELSE
|
|
REMOVE_PED_COMP_ITEM_SP(PLAYER_PED_ID(), COMP_TYPE_SPECIAL, SPECIAL_P1_MASK)
|
|
//SET_PED_COMPONENT_VARIATION(PLAYER_PED_ID(), PED_COMP_SPECIAL, 0, 0)
|
|
ENDIF
|
|
ENDIF
|
|
ENDPROC
|
|
|
|
// set lamar mask
|
|
PROC SET_LAMAR_MASK(BOOL bSet)
|
|
IF NOT IS_PED_INJURED(lamarPed)
|
|
IF bSet
|
|
SET_PED_COMPONENT_VARIATION(lamarPed, PED_COMP_SPECIAL, 1, 0)
|
|
ELSE
|
|
SET_PED_COMPONENT_VARIATION(lamarPed, PED_COMP_SPECIAL, 0, 0)
|
|
ENDIF
|
|
ENDIF
|
|
ENDPROC
|
|
|
|
// remove blips
|
|
PROC REMOVE_ALL_BLIPS()
|
|
IF DOES_BLIP_EXIST(franklinVanBlip)
|
|
REMOVE_BLIP(franklinVanBlip)
|
|
ENDIF
|
|
IF DOES_BLIP_EXIST(lamarBlip)
|
|
REMOVE_BLIP(lamarBlip)
|
|
ENDIF
|
|
IF DOES_BLIP_EXIST(runnerBlip)
|
|
REMOVE_BLIP(runnerBlip)
|
|
ENDIF
|
|
IF DOES_BLIP_EXIST(badGuyCarBlip)
|
|
REMOVE_BLIP(badGuyCarBlip)
|
|
ENDIF
|
|
IF DOES_BLIP_EXIST(destinationBlip)
|
|
REMOVE_BLIP(destinationBlip)
|
|
ENDIF
|
|
//IF DOES_BLIP_EXIST(trainBlip)
|
|
// REMOVE_BLIP(trainBlip)
|
|
//ENDIF
|
|
IF DOES_BLIP_EXIST(chopBlip)
|
|
REMOVE_BLIP(chopBlip)
|
|
ENDIF
|
|
//IF DOES_BLIP_EXIST(alleyBlip)
|
|
// REMOVE_BLIP(alleyBlip)
|
|
//ENDIF
|
|
|
|
INT i
|
|
REPEAT NUMBER_BOXCARS i
|
|
IF DOES_BLIP_EXIST(boxcarCarriage[i].blip)
|
|
REMOVE_BLIP(boxcarCarriage[i].blip)
|
|
ENDIF
|
|
ENDREPEAT
|
|
ENDPROC
|
|
|
|
// common player and cam cleanup stuff
|
|
PROC DO_COMMON_PLAYER_AND_CAM_CLEANUP()
|
|
IF IS_PLAYER_PLAYING(PLAYER_ID())
|
|
SET_PLAYER_CONTROL(PLAYER_ID(), TRUE)
|
|
SET_PLAYER_INVINCIBLE(PLAYER_ID(), FALSE)
|
|
ENDIF
|
|
DISPLAY_HUD(TRUE)
|
|
DISPLAY_RADAR(TRUE)
|
|
RENDER_SCRIPT_CAMS(FALSE, FALSE)
|
|
CLEAR_TIMECYCLE_MODIFIER()
|
|
SET_SCRIPTS_SAFE_FOR_CUTSCENE(FALSE)
|
|
DISABLE_CELLPHONE(FALSE)
|
|
KILL_CHASE_HINT_CAM(localChaseHintCamStruct)
|
|
ENDPROC
|
|
|
|
// remove chop scent
|
|
PROC REMOVE_CHOP_SCENT(BOOL bInstant)
|
|
IF DOES_PARTICLE_FX_LOOPED_EXIST(scentPTFX)
|
|
IF bInstant
|
|
REMOVE_PARTICLE_FX(scentPTFX)
|
|
ELSE
|
|
STOP_PARTICLE_FX_LOOPED(scentPTFX)
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF bInstant
|
|
REMOVE_PARTICLE_FX_IN_RANGE(chopViewCamData.vLastPTFXPos, 2)
|
|
ENDIF
|
|
ENDPROC
|
|
|
|
PROC TOGGLE_CAR_MOD_SHOPS_UNAVAILABLE(BOOL bToggleFlag)
|
|
SET_SHOP_IS_TEMPORARILY_UNAVAILABLE(CARMOD_SHOP_01_AP, bToggleFlag)
|
|
SET_SHOP_IS_TEMPORARILY_UNAVAILABLE(CARMOD_SHOP_05_ID2, bToggleFlag)
|
|
SET_SHOP_IS_TEMPORARILY_UNAVAILABLE(CARMOD_SHOP_06_BT1, bToggleFlag)
|
|
SET_SHOP_IS_TEMPORARILY_UNAVAILABLE(CARMOD_SHOP_07_CS1, bToggleFlag)
|
|
SET_SHOP_IS_TEMPORARILY_UNAVAILABLE(CARMOD_SHOP_08_CS6, bToggleFlag)
|
|
SET_SHOP_IS_TEMPORARILY_UNAVAILABLE(CARMOD_SHOP_SUPERMOD, bToggleFlag)
|
|
ENDPROC
|
|
|
|
// cleanup the mission
|
|
PROC MISSION_CLEANUP()
|
|
TRIGGER_MUSIC_EVENT("FRA0_MISSION_FAIL")
|
|
|
|
REMOVE_MISSION_TEXT()
|
|
RELEASE_CHOP_CAM_SFX(chopViewCamData)
|
|
|
|
IF ANIMPOSTFX_IS_RUNNING("ChopVision")
|
|
ANIMPOSTFX_STOP("ChopVision")
|
|
ENDIF
|
|
|
|
CLEAR_CONTROL_LIGHT_EFFECT(PLAYER_CONTROL)
|
|
|
|
DISTANT_COP_CAR_SIRENS(FALSE)
|
|
STOP_ALL_HOOD_AUDIO_SCENES()
|
|
|
|
SET_PARTICLE_FX_FOOT_LODRANGE_SCALE(1.0)
|
|
|
|
KILL_FACE_TO_FACE_CONVERSATION_DO_NOT_FINISH_LAST_LINE()
|
|
|
|
SET_AUDIO_FLAG("DisableAbortConversationForRagdoll", FALSE)
|
|
|
|
DISABLE_CHEAT(CHEAT_TYPE_SUPER_JUMP, FALSE)
|
|
DISABLE_CHEAT(CHEAT_TYPE_FAST_RUN, FALSE)
|
|
|
|
SET_WANTED_LEVEL_MULTIPLIER(1.0)
|
|
SET_MAX_WANTED_LEVEL(5)
|
|
RESET_WANTED_LEVEL_DIFFICULTY(PLAYER_ID())
|
|
|
|
IF STREAMVOL_IS_VALID(missionStreamingVolume)
|
|
STREAMVOL_DELETE(missionStreamingVolume)
|
|
ENDIF
|
|
|
|
TOGGLE_CAR_MOD_SHOPS_UNAVAILABLE(FALSE)
|
|
|
|
ENABLE_DISPATCH_SERVICE(DT_AMBULANCE_DEPARTMENT, TRUE)
|
|
ENABLE_DISPATCH_SERVICE(DT_FIRE_DEPARTMENT, TRUE)
|
|
|
|
REMOVE_CHOP_SCENT(TRUE)
|
|
|
|
//IF mocapStreamingStage >= MOCAP_STREAMING_STAGE_WAIT
|
|
REMOVE_CUTSCENE()
|
|
//ENDIF
|
|
|
|
SET_INSTANCE_PRIORITY_HINT(INSTANCE_HINT_NONE)
|
|
|
|
ENABLE_CARGENS_FOR_MISSION(TRUE)
|
|
//DISABLE_VEHICLE_GEN_ON_MISSION(FALSE)
|
|
SET_HOOD_ROADS_OFF(FALSE)
|
|
SUPPRESS_MISSION_MODELS(FALSE)
|
|
SET_GPS_DISABLED_ZONE(<<0,0,0>>, <<0,0,0>>)
|
|
REMOVE_ROAD_NODE_SPEED_ZONE(iSpeedZone)
|
|
REMOVE_SCENARIO_BLOCKING_AREA(entranceScenarioBlocking)
|
|
REMOVE_SCENARIO_BLOCKING_AREA(recScenarioBlocking)
|
|
REMOVE_SCENARIO_BLOCKING_AREA(alleyScenarioBlocking)
|
|
REMOVE_SCENARIO_BLOCKING_AREA(outsideYardScenarioBlocking)
|
|
REMOVE_SCENARIO_BLOCKING_AREA(offPathScenarioBlocking)
|
|
//SET_FRANKLIN_MASK(FALSE)
|
|
|
|
RELEASE_NPC_PHONE_RENDERTARGET()
|
|
|
|
// reenable shops and shop robberies
|
|
SET_ALL_SHOPS_TEMPORARILY_UNAVAILABLE(FALSE)
|
|
g_bBlockShopRoberies = FALSE
|
|
|
|
SET_PED_POPULATION_BUDGET(3)
|
|
SET_VEHICLE_POPULATION_BUDGET(3)
|
|
|
|
//SET_REQUESTED_MODEL_ASSERT(TRUE)
|
|
|
|
IF IS_VEHICLE_DRIVEABLE(hoodVehicle[HV_FRANKLIN_VAN])
|
|
SET_VEHICLE_IS_CONSIDERED_BY_PLAYER(hoodVehicle[HV_FRANKLIN_VAN], TRUE)
|
|
SET_VEHICLE_STRONG(hoodVehicle[HV_FRANKLIN_VAN], FALSE)
|
|
SET_DISABLE_VEHICLE_PETROL_TANK_FIRES(hoodVehicle[HV_FRANKLIN_VAN], FALSE)
|
|
SET_VEHICLE_CAN_LEAK_OIL(hoodVehicle[HV_FRANKLIN_VAN], TRUE)
|
|
SET_VEHICLE_CAN_LEAK_PETROL(hoodVehicle[HV_FRANKLIN_VAN], TRUE)
|
|
SET_VEHICLE_HAS_STRONG_AXLES(hoodVehicle[HV_FRANKLIN_VAN], FALSE)
|
|
SET_VEHICLE_TYRES_CAN_BURST(hoodVehicle[HV_FRANKLIN_VAN], TRUE)
|
|
//SET_VEHICLE_RADIO_ENABLED(hoodVehicle[HV_FRANKLIN_VAN], TRUE)
|
|
ENDIF
|
|
IF IS_VEHICLE_DRIVEABLE(hoodVehicle[HV_BAD_GUY_BIKE])
|
|
SET_VEHICLE_IS_CONSIDERED_BY_PLAYER(hoodVehicle[HV_BAD_GUY_BIKE], TRUE)
|
|
SET_ENTITY_PROOFS(hoodVehicle[HV_BAD_GUY_BIKE], FALSE, FALSE, FALSE, FALSE, FALSE)
|
|
SET_DISABLE_VEHICLE_PETROL_TANK_FIRES(hoodVehicle[HV_BAD_GUY_BIKE], FALSE)
|
|
SET_VEHICLE_CAN_LEAK_OIL(hoodVehicle[HV_BAD_GUY_BIKE], TRUE)
|
|
SET_VEHICLE_CAN_LEAK_PETROL(hoodVehicle[HV_BAD_GUY_BIKE], TRUE)
|
|
SET_ENTITY_ONLY_DAMAGED_BY_PLAYER(hoodVehicle[HV_BAD_GUY_BIKE], FALSE)
|
|
ENDIF
|
|
|
|
// NG
|
|
IF IS_VEHICLE_DRIVEABLE(yardVehicle[YV_BUS_REVERSE])
|
|
SET_AUDIO_VEHICLE_PRIORITY(yardVehicle[YV_BUS_REVERSE], AUDIO_VEHICLE_PRIORITY_NORMAL)
|
|
ENDIF
|
|
|
|
IF NOT IS_PED_INJURED(lamarPed)
|
|
IF IS_PED_GROUP_MEMBER(lamarPed, PLAYER_GROUP_ID())
|
|
REMOVE_PED_FROM_GROUP(lamarPed)
|
|
ENDIF
|
|
ENDIF
|
|
|
|
STOP_SOUND(iWhistleSoundID)
|
|
RELEASE_SOUND_ID(iWhistleSoundID)
|
|
|
|
IF bThoroughCleanup
|
|
IF DOES_ENTITY_EXIST(lamarPhoneObject)
|
|
DELETE_OBJECT(lamarPhoneObject)
|
|
ENDIF
|
|
IF DOES_ENTITY_EXIST(lamarPed)
|
|
DELETE_PED(lamarPed)
|
|
ENDIF
|
|
IF DOES_ENTITY_EXIST(runnerChaseProperties.ped)
|
|
DELETE_PED(runnerChaseProperties.ped)
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF NOT IS_PED_INJURED(PLAYER_PED_ID())
|
|
TASK_CLEAR_LOOK_AT(PLAYER_PED_ID())
|
|
|
|
IF GET_SCRIPT_TASK_STATUS(PLAYER_PED_ID(), SCRIPT_TASK_FOLLOW_TO_OFFSET_OF_ENTITY) <> FINISHED_TASK
|
|
OR GET_SCRIPT_TASK_STATUS(PLAYER_PED_ID(), SCRIPT_TASK_GO_TO_ENTITY) <> FINISHED_TASK
|
|
OR GET_SCRIPT_TASK_STATUS(PLAYER_PED_ID(), SCRIPT_TASK_FOLLOW_WAYPOINT_ROUTE) <> FINISHED_TASK
|
|
OR GET_SCRIPT_TASK_STATUS(PLAYER_PED_ID(), SCRIPT_TASK_TURN_PED_TO_FACE_ENTITY) <> FINISHED_TASK
|
|
CLEAR_PED_TASKS(PLAYER_PED_ID())
|
|
ENDIF
|
|
|
|
IF IS_ENTITY_ATTACHED(PLAYER_PED_ID())
|
|
IF NOT GET_IS_PED_GADGET_EQUIPPED(PLAYER_PED_ID(), GADGETTYPE_PARACHUTE)
|
|
IF GET_VEHICLE_PED_IS_USING(PLAYER_PED_ID()) = NULL
|
|
CLEAR_PED_TASKS(PLAYER_PED_ID())
|
|
DETACH_ENTITY(PLAYER_PED_ID())
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
IF NOT IS_PED_INJURED(chopPed)
|
|
CLEAR_PED_TASKS(chopPed)
|
|
ENDIF
|
|
IF NOT IS_PED_INJURED(colliePed)
|
|
CLEAR_PED_TASKS(colliePed)
|
|
ENDIF
|
|
IF NOT IS_PED_INJURED(runnerChaseProperties.ped)
|
|
CLEAR_PED_TASKS(runnerChaseProperties.ped)
|
|
ENDIF
|
|
IF DOES_CAM_EXIST(animCam)
|
|
DESTROY_CAM(animCam)
|
|
ENDIF
|
|
|
|
INT i
|
|
INT j
|
|
|
|
REPEAT NUMBER_BOXCARS i
|
|
REPEAT 2 j
|
|
IF DOES_ENTITY_EXIST(boxcarCarriage[i].boxcarDoor[j].obj)
|
|
DETACH_ENTITY(boxcarCarriage[i].boxcarDoor[j].obj, TRUE)
|
|
FREEZE_ENTITY_POSITION(boxcarCarriage[i].boxcarDoor[j].obj, TRUE)
|
|
ENDIF
|
|
ENDREPEAT
|
|
ENDREPEAT
|
|
|
|
// get rid of trains
|
|
|
|
REPEAT NUMBER_TRAINS i
|
|
IF DOES_ENTITY_EXIST(trainVehicle[i])
|
|
IF bThoroughCleanup
|
|
DELETE_MISSION_TRAIN(trainVehicle[i])
|
|
ELSE
|
|
SET_MISSION_TRAIN_AS_NO_LONGER_NEEDED(trainVehicle[i], ENUM_TO_INT(RTF_KEEP_OLD_SPEED))
|
|
ENDIF
|
|
ENDIF
|
|
ENDREPEAT
|
|
|
|
DO_COMMON_PLAYER_AND_CAM_CLEANUP()
|
|
|
|
CLEANUP_UBER_PLAYBACK()
|
|
//SET_ALL_RANDOM_PEDS_FLEE(PLAYER_ID(), FALSE)
|
|
//CLEANUP_HOOD_ASSISTED_MOVEMENT()
|
|
//SET_MISSION_FLOW_FLAG_STATE(FLOWFLAG_PLAYER_PED_INTRODUCED_T, FALSE)
|
|
|
|
IF bSetTrevorUnavailable
|
|
SET_PLAYER_PED_AVAILABLE(CHAR_TREVOR, TRUE)
|
|
ENDIF
|
|
SET_SCRIPTS_SAFE_FOR_CUTSCENE(FALSE)
|
|
|
|
#IF IS_DEBUG_BUILD
|
|
IF DOES_WIDGET_GROUP_EXIST(hoodWidgets)
|
|
DELETE_WIDGET_GROUP(hoodWidgets)
|
|
ENDIF
|
|
#ENDIF
|
|
|
|
TERMINATE_THIS_THREAD()
|
|
ENDPROC
|
|
|
|
// mission passed
|
|
PROC MISSION_PASSED()
|
|
Mission_Flow_Mission_Passed()
|
|
MISSION_CLEANUP()
|
|
ENDPROC
|
|
|
|
// mission failed
|
|
PROC MISSION_FAILED(FAIL_REASON_ENUM reasonForFail)
|
|
IF CAN_ADVANCE_MISSION()
|
|
REMOVE_ALL_BLIPS()
|
|
REMOVE_MISSION_TEXT(TRUE, TRUE, TRUE, TRUE)
|
|
TRIGGER_MUSIC_EVENT("FRA0_MISSION_FAIL")
|
|
missionFailState = MISSION_FAIL_STATE_WAIT_FOR_FADE
|
|
savedFailReason = reasonForFail
|
|
|
|
STRING failText
|
|
SWITCH savedFailReason
|
|
CASE FAIL_LAMAR_DEAD
|
|
failText = "FC_FAIL1"
|
|
BREAK
|
|
CASE FAIL_CHOP_DEAD
|
|
failText = "FC_FAIL4"
|
|
BREAK
|
|
CASE FAIL_LOST_BAD_GUY
|
|
failText = "FC_FAIL2"
|
|
BREAK
|
|
CASE FAIL_KILLED_BAD_GUY
|
|
failText = "FC_FAIL3"
|
|
BREAK
|
|
CASE FAIL_VAN_DESTROYED
|
|
failText = "FC_FAIL5"
|
|
BREAK
|
|
CASE FAIL_SPOOKED_BAD_GUY
|
|
failText = "FC_FAIL6"
|
|
BREAK
|
|
CASE FAIL_ABANDONED_LAMAR
|
|
failText = "FC_FAIL7"
|
|
BREAK
|
|
CASE FAIL_ABANDONED_VAN
|
|
failText = "FC_FAIL8"
|
|
BREAK
|
|
CASE FAIL_ABANDONED_CHOP
|
|
failText = "FC_FAIL11"
|
|
BREAK
|
|
CASE FAIL_VAN_STUCK
|
|
failText = "FC_FAIL10"
|
|
BREAK
|
|
CASE FAIL_POLICE_ATTENTION
|
|
failText = "FC_FAIL9"
|
|
BREAK
|
|
ENDSWITCH
|
|
|
|
MISSION_FLOW_MISSION_FAILED_WITH_REASON(failText)
|
|
ENDIF
|
|
ENDPROC
|
|
|
|
// remove van blip and text
|
|
PROC REMOVE_VAN_BLIP_AND_TEXT()
|
|
IF DOES_BLIP_EXIST(franklinVanBlip)
|
|
REMOVE_BLIP(franklinVanBlip)
|
|
ENDIF
|
|
IF IS_THIS_PRINT_BEING_DISPLAYED("FC_GOVAN2")
|
|
OR IS_THIS_PRINT_BEING_DISPLAYED("FC_GOVAN1")
|
|
REMOVE_MISSION_TEXT(TRUE, TRUE, FALSE)
|
|
ENDIF
|
|
ENDPROC
|
|
|
|
// check all peds and vehicles for fail
|
|
PROC HANDLE_MISSION_FAIL_CHECKS()
|
|
IF NOT bRunningCutscene
|
|
IF IS_PED_INJURED(lamarPed)
|
|
IF DOES_BLIP_EXIST(lamarBlip)
|
|
REMOVE_BLIP(lamarBlip)
|
|
ENDIF
|
|
IF IS_THIS_PRINT_BEING_DISPLAYED("FC_FOLLAM")
|
|
REMOVE_MISSION_TEXT(TRUE, TRUE, FALSE)
|
|
ENDIF
|
|
MISSION_FAILED(FAIL_LAMAR_DEAD)
|
|
ELSE
|
|
// abandon
|
|
IF currentMissionStage = STAGE_GET_TO_BAD_GUY
|
|
IF NOT bDoneLamarIntoVan
|
|
IF NOT bForcePassOnShitskip
|
|
IF GET_DISTANCE_BETWEEN_ENTITIES(PLAYER_PED_ID(), lamarPed, FALSE) > ABANDON_BUDDY_FAIL_RANGE
|
|
MISSION_FAILED(FAIL_ABANDONED_LAMAR)
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF IS_PED_INJURED(chopPed)
|
|
IF DOES_BLIP_EXIST(chopBlip)
|
|
REMOVE_BLIP(chopBlip)
|
|
ENDIF
|
|
IF IS_THIS_PRINT_BEING_DISPLAYED("FC_GOCHOP")
|
|
OR IS_THIS_PRINT_BEING_DISPLAYED("FC_CLOSER")
|
|
REMOVE_MISSION_TEXT(TRUE, TRUE, FALSE)
|
|
ENDIF
|
|
MISSION_FAILED(FAIL_CHOP_DEAD)
|
|
ENDIF
|
|
|
|
IF DOES_ENTITY_EXIST(runnerChaseProperties.ped)
|
|
IF IS_PED_INJURED(runnerChaseProperties.ped)
|
|
IF DOES_BLIP_EXIST(runnerBlip)
|
|
REMOVE_BLIP(runnerBlip)
|
|
ENDIF
|
|
IF IS_THIS_PRINT_BEING_DISPLAYED("FC_CHASE")
|
|
REMOVE_MISSION_TEXT(TRUE, TRUE, FALSE)
|
|
ENDIF
|
|
|
|
IF currentMissionStage = STAGE_VAN_CHASE
|
|
IF IS_VEHICLE_DRIVEABLE(hoodVehicle[HV_BAD_GUY_BIKE])
|
|
IF IS_PLAYBACK_GOING_ON_FOR_VEHICLE(hoodVehicle[HV_BAD_GUY_BIKE])
|
|
STOP_PLAYBACK_RECORDED_VEHICLE(hoodVehicle[HV_BAD_GUY_BIKE])
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
|
|
MISSION_FAILED(FAIL_KILLED_BAD_GUY)
|
|
ELSE
|
|
IF currentMissionStage = STAGE_FOOT_CHASE
|
|
FLOAT fFailDist
|
|
IF NOT IS_TRACKED_PED_VISIBLE(runnerChaseProperties.ped)
|
|
VECTOR vPlayerPos = GET_ENTITY_COORDS(PLAYER_PED_ID())
|
|
IF vPlayerPos.x >= 487.3
|
|
AND vPlayerPos.y <= -614.0
|
|
AND vPlayerPos.z <= 27.2
|
|
fFailDist = 70.0
|
|
ELSE
|
|
fFailDist = 90.0
|
|
ENDIF
|
|
ELSE
|
|
fFailDist = 160.0
|
|
ENDIF
|
|
|
|
UPDATE_CHASE_BLIP(runnerBlip, runnerChaseProperties.ped, fFailDist)
|
|
|
|
IF GET_DISTANCE_BETWEEN_ENTITIES(PLAYER_PED_ID(), runnerChaseProperties.ped, FALSE) >= fFailDist
|
|
AND chopViewCamData.state = CHOP_VIEW_CAM_DISABLED
|
|
IF DOES_BLIP_EXIST(runnerBlip)
|
|
REMOVE_BLIP(runnerBlip)
|
|
ENDIF
|
|
MISSION_FAILED(FAIL_LOST_BAD_GUY)
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF DOES_ENTITY_EXIST(hoodVehicle[HV_FRANKLIN_VAN])
|
|
IF NOT IS_VEHICLE_DRIVEABLE(hoodVehicle[HV_FRANKLIN_VAN], TRUE)
|
|
MISSION_FAILED(FAIL_VAN_DESTROYED)
|
|
ELSE
|
|
IF (currentMissionStage = STAGE_GET_TO_BAD_GUY AND bDoneLamarIntoVan)
|
|
OR currentMissionStage = STAGE_VAN_CHASE
|
|
OR currentMissionStage = STAGE_GET_TO_HOUSE
|
|
IF NOT bForcePassOnShitskip
|
|
IF GET_DISTANCE_BETWEEN_ENTITIES(PLAYER_PED_ID(), hoodVehicle[HV_FRANKLIN_VAN], FALSE) > STUCK_FAIL_RANGE_m
|
|
MISSION_FAILED(FAIL_ABANDONED_VAN)
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF IS_VEHICLE_STUCK_TIMER_UP(hoodVehicle[HV_FRANKLIN_VAN], VEH_STUCK_JAMMED, JAMMED_TIME)
|
|
OR IS_VEHICLE_STUCK_TIMER_UP(hoodVehicle[HV_FRANKLIN_VAN], VEH_STUCK_HUNG_UP, HUNG_UP_TIME)
|
|
OR IS_VEHICLE_STUCK_TIMER_UP(hoodVehicle[HV_FRANKLIN_VAN], VEH_STUCK_ON_SIDE, SIDE_TIME)
|
|
OR IS_VEHICLE_STUCK_TIMER_UP(hoodVehicle[HV_FRANKLIN_VAN], VEH_STUCK_ON_ROOF, ROOF_TIME)
|
|
MISSION_FAILED(FAIL_VAN_STUCK)
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDPROC
|
|
|
|
// handle the mission fail state
|
|
PROC HANDLE_MISSION_FAIL_STATE()
|
|
HANDLE_MISSION_FAIL_CHECKS()
|
|
|
|
SWITCH missionFailState
|
|
CASE MISSION_FAIL_STATE_NOT_FAILED
|
|
BREAK
|
|
CASE MISSION_FAIL_STATE_WAIT_FOR_FADE
|
|
IF GET_MISSION_FLOW_SAFE_TO_CLEANUP()
|
|
SET_FRANKLIN_MASK(FALSE)
|
|
// check if we need to respawn the player in a different position,
|
|
// if so call MISSION_FLOW_SET_FAIL_WARP_LOCATION() + SET_REPLAY_DECLINED_VEHICLE_WARP_LOCATION here
|
|
|
|
bThoroughCleanup = TRUE
|
|
|
|
MISSION_CLEANUP() // must only take 1 frame and terminate the thread
|
|
ELSE
|
|
//Maintain anything that could look weird during fade out (e.g. enemies walking off).
|
|
ENDIF
|
|
BREAK
|
|
ENDSWITCH
|
|
ENDPROC
|
|
|
|
// get mission vector
|
|
FUNC VECTOR GET_HOOD_VECTOR(HOOD_VECTOR_ENUM hVec)
|
|
SWITCH hVec
|
|
CASE HVEC_FRANKLIN_VAN_INIT
|
|
RETURN <<-77.80, -1456.70, 31.03>>
|
|
BREAK
|
|
CASE HVEC_PLAYER_INIT
|
|
//RETURN <<-18.56, -1451.07, 29.59>>
|
|
RETURN <<-15.79069, -1451.12012, 29.55704>>
|
|
BREAK
|
|
CASE HVEC_BAD_GUY_HANGOUT
|
|
//RETURN <<363.82, 322.32, 102.70>>
|
|
RETURN <<363.74927, 323.37021, 102.71001>>
|
|
BREAK
|
|
CASE HVEC_HOUSE
|
|
RETURN <<-52.78, -1456.56, 31.03>>
|
|
BREAK
|
|
CASE HVEC_REC
|
|
RETURN <<-216.77869, -1494.96509, 30.23503>>//<<-214.96, -1492.64, 30.24>>
|
|
BREAK
|
|
CASE HVEC_FOOT_CHASE_INIT
|
|
RETURN <<456.04520, -691.47260, 26.83633>>
|
|
BREAK
|
|
CASE HVEC_VAN_CHASE_INIT
|
|
RETURN <<360.19, 323.68, 102.81>>
|
|
BREAK
|
|
CASE HVEC_VAN_IN_ALLEY
|
|
//RETURN <<455.83, -706.46, 27.37>>
|
|
RETURN <<458.02, -691.39, 27.43>>
|
|
BREAK
|
|
CASE HVEC_DRIVE_INIT
|
|
RETURN <<509.78, -654.11, 23.75>>
|
|
BREAK
|
|
CASE HVEC_GIRL_INIT
|
|
RETURN <<387.98, 358.86, 101.45>>
|
|
BREAK
|
|
CASE HVEC_FRANKLIN_ALLEY_INIT
|
|
RETURN <<372.32019, 353.49075, 101.71169>>
|
|
BREAK
|
|
CASE HVEC_LAMAR_WALK_INIT
|
|
RETURN <<-17.96112, -1452.73389, 29.57574>>
|
|
BREAK
|
|
CASE HVEC_LAMAR_ALLEY_INIT
|
|
RETURN <<369.86670, 350.72247, 101.84525>>
|
|
BREAK
|
|
CASE HVEC_CONTAINER_ATTACH_ROT
|
|
RETURN <<0,0,-90>>
|
|
BREAK
|
|
CASE HVEC_RUNNER_CHASE_INIT
|
|
//RETURN <<461.16, -648.93, 27.17>>
|
|
RETURN <<460.10, -656.61, 26.67>>
|
|
BREAK
|
|
CASE HVEC_CHOP_WALK_INIT
|
|
RETURN <<-15.26298, -1453.30530, 29.50939>>
|
|
BREAK
|
|
CASE HVEC_CHOP_CHASE_INIT
|
|
RETURN <<459.37540, -679.71918, 26.55455>>
|
|
BREAK
|
|
CASE HVEC_OFF_ROOF
|
|
RETURN <<491.34, -556.23, 26.54>>
|
|
BREAK
|
|
CASE HVEC_CHASE_TRAIN
|
|
RETURN <<552.57, -561.89, 23.80>>
|
|
BREAK
|
|
CASE HVEC_TRAINYARD
|
|
RETURN <<514.25, -640.73, 23.75>>
|
|
BREAK
|
|
CASE HVEC_LOSE_RUNNER
|
|
RETURN <<556.65, -565.12, 23.80>>
|
|
BREAK
|
|
CASE HVEC_RUNNER_HIDE
|
|
RETURN <<525.98217, -679.14313, 24.80665>>//<<526.05, -679.82, 24.91>>
|
|
BREAK
|
|
CASE HVEC_FIND_GANGSTER
|
|
RETURN <<529.37, -679.52, 23.76>>
|
|
BREAK
|
|
CASE HVEC_CHOP_FIND_INIT
|
|
RETURN <<558.05817, -566.79877, 23.78100>>
|
|
BREAK
|
|
CASE HVEC_COLLIE_INIT
|
|
RETURN <<501.49, -647.84, 23.75>>
|
|
BREAK
|
|
CASE HVEC_CHOP_HUMP_ENTRY
|
|
RETURN <<503.14, -648.65, 23.75>>
|
|
BREAK
|
|
CASE HVEC_CHOP_BEHAVIOUR_SETPIECE_LAUNCH
|
|
RETURN <<533.38, -664.49, 23.80>>
|
|
BREAK
|
|
CASE HVEC_CHOP_BEHAVIOUR_SETPIECE_TERMINATE
|
|
RETURN <<531.43, -669.40, 23.80>>
|
|
BREAK
|
|
CASE HVEC_BLIP_ALLEY
|
|
RETURN <<456.95, -805.38, 26.46>>
|
|
BREAK
|
|
CASE HVEC_LAMAR_SPRINT_TO_VAN
|
|
RETURN <<363.46, 322.00, 102.71>>
|
|
BREAK
|
|
CASE HVEC_MOVE_LAST_PLAYER_VEHICLE
|
|
RETURN <<-19.31, -1457.80, 29.47>>
|
|
BREAK
|
|
CASE HVEC_VAN_HIDDEN
|
|
RETURN <<444.75775, -816.03680, 27.24718>>
|
|
BREAK
|
|
ENDSWITCH
|
|
|
|
RETURN <<0,0,0>>
|
|
ENDFUNC
|
|
|
|
// fill position, rotation, FOV for a camera shot
|
|
PROC FILL_CAMERA_PROPERTIES_FOR_HOOD_SHOT(HOOD_SHOT_DETAILS_ENUM cutsceneShot, VECTOR &vCamPos, VECTOR &vCamRot, FLOAT &fCamFOV)
|
|
SWITCH cutsceneShot
|
|
CASE H_SHOT_FLIRT
|
|
vCamPos = <<383.42, 357.86, 102.65>>
|
|
vCamRot = <<-1.53, 0.0, -89.85>>
|
|
fCamFOV = 31.64
|
|
BREAK
|
|
CASE H_SHOT_FLIRTB
|
|
vCamPos = <<383.42, 357.86, 102.65>>
|
|
vCamRot = <<-1.53, 0.0, -89.85>>
|
|
fCamFOV = 29.64
|
|
BREAK
|
|
CASE H_SHOT_SHOUT
|
|
vCamPos = <<390.96, 357.80, 102.85>>
|
|
vCamRot = <<-1.62, 0.0, 85.38>>
|
|
fCamFOV = 31.24
|
|
BREAK
|
|
CASE H_SHOT_SHOUTB
|
|
vCamPos = <<390.96, 357.80, 102.85>>
|
|
vCamRot = <<-1.62, 0.0, 85.38>>
|
|
fCamFOV = 29.24
|
|
BREAK
|
|
CASE H_SHOT_ESCAPE
|
|
vCamPos = <<374.79, 360.54, 101.92>>
|
|
vCamRot = <<8.38, 0.0, -102.25>>
|
|
fCamFOV = 41.09
|
|
BREAK
|
|
CASE H_SHOT_ESCAPEB
|
|
vCamPos = <<374.79, 360.54, 101.92>>
|
|
vCamRot = <<8.38, 0.0, -102.25>>
|
|
fCamFOV = 39.09
|
|
BREAK
|
|
CASE H_SHOT_LAMAR_SHOUT
|
|
vCamPos = <<367.78, 366.68, 108.92>>
|
|
vCamRot = <<-22.82, 0.0, -145.50>>
|
|
fCamFOV = 41.09
|
|
BREAK
|
|
CASE H_SHOT_LAMAR_SHOUTB
|
|
vCamPos = <<367.78, 366.68, 108.92>>
|
|
vCamRot = <<-22.82, 0.0, -145.50>>
|
|
fCamFOV = 39.09
|
|
BREAK
|
|
CASE H_SHOT_CRASH
|
|
vCamPos = <<457.50, -704.22, 27.60>>
|
|
vCamRot = <<-6.90, 0.0, -24.43>>
|
|
fCamFOV = 38.53
|
|
BREAK
|
|
CASE H_SHOT_LEAVE_CAR
|
|
vCamPos = <<456.10, -696.84, 26.64>>
|
|
vCamRot = <<10.45, 0.0, -138.80>>
|
|
fCamFOV = 33.53
|
|
BREAK
|
|
CASE H_SHOT_OFF_ROOF
|
|
vCamPos = <<494.95, -562.77, 26.80>>
|
|
vCamRot = <<36.68, 0.31, 98.29>>
|
|
fCamFOV = 39.01
|
|
BREAK
|
|
CASE H_SHOT_OFF_ROOFB
|
|
vCamPos = <<494.95, -562.77, 26.80>>
|
|
vCamRot = <<7.33, 1.25, 42.55>>
|
|
fCamFOV = 39.01
|
|
BREAK
|
|
CASE H_SHOT_THROUGH_FENCE
|
|
vCamPos = <<493.14, -519.10, 24.76>>
|
|
vCamRot = <<6.54, 0.98, -39.25>>
|
|
fCamFOV = 50.0
|
|
BREAK
|
|
CASE H_SHOT_THROUGH_FENCEB
|
|
vCamPos = <<494.61, -516.30, 25.27>>//<<494.20, -518.85, 24.78>>
|
|
vCamRot = <<-2.87, 0.57, -15.58>>//<<6.55, 0.99, -8.69>>
|
|
fCamFOV = 50.0
|
|
BREAK
|
|
CASE H_SHOT_ONTO_TRAIN
|
|
vCamPos = <<555.54, -559.33, 27.13>>
|
|
vCamRot = <<-10.37, 4.4, 143.73>>
|
|
fCamFOV = 46.164
|
|
BREAK
|
|
CASE H_SHOT_ONTO_TRAINB
|
|
vCamPos = <<555.54, -559.33, 27.13>>
|
|
vCamRot = <<-10.37, 4.4, 135.10>>
|
|
fCamFOV = 46.164
|
|
BREAK
|
|
CASE H_SHOT_LOST
|
|
vCamPos = <<563.90, -560.71, 29.68>>
|
|
vCamRot = <<-19.32, 5.88, 130.27>>
|
|
fCamFOV = 55
|
|
BREAK
|
|
CASE H_SHOT_LOSTB
|
|
vCamPos = <<563.90, -560.71, 29.68>>
|
|
vCamRot = <<-15.81, 5.88, 130.27>>
|
|
fCamFOV = 55
|
|
BREAK
|
|
CASE H_SHOT_FIND
|
|
vCamPos = <<532.45, -678.69, 25.22>>
|
|
vCamRot = <<-2.12, 0.0, 99.72>>
|
|
fCamFOV = 37.88
|
|
BREAK
|
|
CASE H_SHOT_FINDB
|
|
vCamPos = <<531.91, -677.94, 25.20>>
|
|
vCamRot = <<-2.12, 0.0, 111.87>>
|
|
fCamFOV = 37.88
|
|
BREAK
|
|
CASE H_SHOT_BOXCAR_FLEE
|
|
vCamPos = <<527.40, -674.36, 25.92>>
|
|
vCamRot = <<-7.43, 0.0, 162.87>>
|
|
fCamFOV = 43.79
|
|
BREAK
|
|
CASE H_SHOT_TRAPPED
|
|
vCamPos = <<506.18, -643.42, 24.17>>
|
|
vCamRot = <<3.93, 0.0, -119.93>>
|
|
fCamFOV = 24.91
|
|
BREAK
|
|
CASE H_SHOT_TRAPPEDB
|
|
vCamPos = <<506.18, -643.42, 24.17>>
|
|
vCamRot = <<3.93, 0.0, -119.93>>
|
|
fCamFOV = 21.91
|
|
BREAK
|
|
CASE H_SHOT_INTO_VAN
|
|
vCamPos = <<510.37, -639.15, 25.56>>
|
|
vCamRot = <<-6.17, 0.0, -170.88>>
|
|
fCamFOV = 27.60
|
|
BREAK
|
|
CASE H_SHOT_INTO_VANB
|
|
vCamPos = <<510.37, -639.15, 25.56>>
|
|
vCamRot = <<-6.17, 0.0, -170.88>>
|
|
fCamFOV = 24.60
|
|
BREAK
|
|
CASE H_SHOT_HOUSE
|
|
vCamPos = <<-24.62, -1472.97, 36.19>>
|
|
vCamRot = <<-13.11, 0.0, -21.69>>
|
|
fCamFOV = 45.00
|
|
BREAK
|
|
ENDSWITCH
|
|
ENDPROC
|
|
|
|
// destroy a scripted cam if it exists
|
|
PROC DESTROY_MISSION_STATIC_CAM(CAMERA_INDEX &camIndex)
|
|
IF DOES_CAM_EXIST(camIndex)
|
|
DESTROY_CAM(camIndex)
|
|
ENDIF
|
|
ENDPROC
|
|
|
|
// create a scripted stationary cam if it doesn't already exist
|
|
PROC CREATE_MISSION_STATIC_CAM(CAMERA_INDEX &camIndex)
|
|
// get rid of any existing interp cams
|
|
IF DOES_CAM_EXIST(interpCam)
|
|
DESTROY_CAM(interpCam)
|
|
ENDIF
|
|
|
|
IF DOES_CAM_EXIST(camIndex)
|
|
DESTROY_CAM(camIndex)
|
|
ENDIF
|
|
|
|
IF NOT DOES_CAM_EXIST(camIndex)
|
|
camIndex = CREATE_CAM("DEFAULT_SCRIPTED_CAMERA", TRUE)
|
|
ENDIF
|
|
ENDPROC
|
|
|
|
// cam for a cutscene shot
|
|
PROC CREATE_CAM_FOR_HOOD_SHOT(HOOD_SHOT_DETAILS_ENUM cutsceneShot, BOOL bIsInterp = FALSE, INT iInterpTime = 10000)
|
|
VECTOR vCamPos, vCamRot
|
|
FLOAT fCamFOV
|
|
FILL_CAMERA_PROPERTIES_FOR_HOOD_SHOT(cutsceneShot, vCamPos, vCamRot, fCamFOV)
|
|
CREATE_MISSION_STATIC_CAM(staticCam)
|
|
DETACH_CAM(staticCam)
|
|
STOP_CAM_POINTING(staticCam)
|
|
|
|
SET_CAM_COORD(staticCam, vCamPos)
|
|
SET_CAM_ROT(staticCam, vCamRot)
|
|
SET_CAM_FOV(staticCam, fCamFOV)
|
|
|
|
// setup for interpolation
|
|
IF bIsInterp
|
|
FILL_CAMERA_PROPERTIES_FOR_HOOD_SHOT(INT_TO_ENUM(HOOD_SHOT_DETAILS_ENUM, ENUM_TO_INT(cutsceneShot)+1), vCamPos, vCamRot, fCamFOV)
|
|
CREATE_MISSION_STATIC_CAM(interpCam)
|
|
SET_CAM_COORD(interpCam, vCamPos)
|
|
SET_CAM_ROT(interpCam, vCamRot)
|
|
SET_CAM_FOV(interpCam, fCamFOV)
|
|
SET_CAM_ACTIVE_WITH_INTERP(interpCam, staticCam, iInterpTime)
|
|
ENDIF
|
|
|
|
RENDER_SCRIPT_CAMS(TRUE, FALSE)
|
|
ENDPROC
|
|
|
|
// create an anim cam for sync scenes
|
|
PROC CREATE_MISSION_ANIM_CAM()
|
|
IF DOES_CAM_EXIST(animCam)
|
|
DESTROY_CAM(animCam)
|
|
ENDIF
|
|
animCam = CREATE_CAM("DEFAULT_ANIMATED_CAMERA", TRUE)
|
|
RENDER_SCRIPT_CAMS(TRUE, FALSE)
|
|
ENDPROC
|
|
|
|
// cam attached to car
|
|
PROC CREATE_CAM_ATTACHED_TO_VAN(VAN_CAMERA_ENUM vanCamera)
|
|
IF IS_VEHICLE_DRIVEABLE(hoodVehicle[HV_FRANKLIN_VAN])
|
|
CREATE_MISSION_STATIC_CAM(staticCam)
|
|
SWITCH vanCamera
|
|
CASE VAN_CAMERA_REAR
|
|
//ATTACH_CAM_TO_ENTITY(staticCam, hoodVehicle[HV_FRANKLIN_VAN], <<-1.0, -5.7, 0.1>>)
|
|
//POINT_CAM_AT_ENTITY(staticCam, hoodVehicle[HV_FRANKLIN_VAN], <<3.3,0.0,1.75>>)
|
|
//SET_CAM_FOV(staticCam, 40.0)
|
|
ATTACH_CAM_TO_ENTITY(staticCam, hoodVehicle[HV_FRANKLIN_VAN], <<-0.600, -2.400, 0.600>>)
|
|
POINT_CAM_AT_ENTITY(staticCam, hoodVehicle[HV_FRANKLIN_VAN], <<0.800,-1.300,0.800>>)
|
|
SET_CAM_FOV(staticCam, 55.0)
|
|
BREAK
|
|
CASE VAN_CAMERA_FRONT
|
|
ATTACH_CAM_TO_ENTITY(staticCam, hoodVehicle[HV_FRANKLIN_VAN], <<-1.8, 2.400, 1.100>>)
|
|
POINT_CAM_AT_ENTITY(staticCam, hoodVehicle[HV_FRANKLIN_VAN], <<0.300,0.200,0.350>>)
|
|
SET_CAM_FOV(staticCam, 45.0)
|
|
//ATTACH_CAM_TO_ENTITY(staticCam, hoodVehicle[HV_FRANKLIN_VAN], <<-1.5, 2.8, 1.2>>)
|
|
//POINT_CAM_AT_ENTITY(staticCam, hoodVehicle[HV_FRANKLIN_VAN], <<0.3,0.0,0.45>>)
|
|
//SET_CAM_FOV(staticCam, 40.0)
|
|
BREAK
|
|
ENDSWITCH
|
|
RENDER_SCRIPT_CAMS(TRUE, FALSE)
|
|
ENDIF
|
|
ENDPROC
|
|
|
|
// cam attached to car
|
|
PROC CREATE_CAM_ATTACHED_TO_TRAIN()
|
|
IF IS_VEHICLE_DRIVEABLE(GET_TRAIN_CARRIAGE(trainVehicle[1], 2))
|
|
CREATE_MISSION_STATIC_CAM(staticCam)
|
|
|
|
ATTACH_CAM_TO_ENTITY(staticCam, GET_TRAIN_CARRIAGE(trainVehicle[1], 2), <<0.8, -3.2, 2.0>>)
|
|
POINT_CAM_AT_ENTITY(staticCam, GET_TRAIN_CARRIAGE(trainVehicle[1], 2), <<0.8,-12.0,1.5>>)
|
|
SET_CAM_FOV(staticCam, 58.72)
|
|
SHAKE_CAM(staticCam, "road_vibration_shake")
|
|
|
|
RENDER_SCRIPT_CAMS(TRUE, FALSE)
|
|
ENDIF
|
|
ENDPROC
|
|
|
|
//HUD elements
|
|
PROC SET_CUTSCENE_HUD_ELEMENTS()
|
|
DISABLE_CELLPHONE(TRUE)
|
|
SET_CHOP_VIEW_CAM_DISABLED(chopViewCamData, sSelectorPeds)
|
|
CLEAR_CONTROL_LIGHT_EFFECT(PLAYER_CONTROL)
|
|
STOP_HOOD_AUDIO_SCENE(HOOD_AUDIO_SCENE_CHOP_CAM)
|
|
INFORM_MISSION_STATS_SYSTEM_OF_TIME_WINDOW_CLOSED()
|
|
REMOVE_CHOP_SCENT(TRUE)
|
|
SET_PLAYER_CONTROL(PLAYER_ID(), FALSE)
|
|
ENDPROC
|
|
|
|
// setup mocap cutscene
|
|
PROC SET_MISSION_MOCAP_CUTSCENE()
|
|
REMOVE_MISSION_TEXT()
|
|
SET_CUTSCENE_HUD_ELEMENTS()
|
|
SET_SCRIPTS_SAFE_FOR_CUTSCENE(TRUE)
|
|
ENDPROC
|
|
|
|
PROC COMMON_MISSION_CUTSCENE_BLENDOUT(FLOAT fBlend = 0.0, CAM_SPLINE_SMOOTHING_FLAGS smoothFlags = CAM_SPLINE_SLOW_IN_OUT_SMOOTH, BOOL bSpecifyModelForVan = FALSE)
|
|
SET_PLAYER_CONTROL(PLAYER_ID(), TRUE)
|
|
DISPLAY_RADAR(TRUE)
|
|
DISPLAY_HUD(TRUE)
|
|
DISABLE_CELLPHONE(FALSE)
|
|
|
|
IF bSpecifyModelForVan
|
|
SET_FIRST_PERSON_FLASH_EFFECT_VEHICLE_MODEL_NAME("SPEEDO")
|
|
DISABLE_FIRST_PERSON_FLASH_EFFECT_THIS_UPDATE()
|
|
ENDIF
|
|
|
|
STOP_RENDERING_SCRIPT_CAMS_USING_CATCH_UP(FALSE, fBlend, smoothFlags)
|
|
SET_SCRIPTS_SAFE_FOR_CUTSCENE(FALSE)
|
|
|
|
bRunningCutscene = FALSE
|
|
bSkippedCutscene = FALSE
|
|
bClearedForCutscene = FALSE
|
|
bCutsceneWaitStarted = FALSE
|
|
cutsceneStage = H_CUT_STAGE_INIT
|
|
IF IS_SCREEN_FADED_OUT()
|
|
IF DOES_CAM_EXIST(animCam)
|
|
DESTROY_CAM(animCam)
|
|
ENDIF
|
|
DO_SCREEN_FADE_IN(DEFAULT_FADE_TIME)
|
|
ENDIF
|
|
ENDPROC
|
|
|
|
// setup stuff for hood cutscene
|
|
PROC SET_MISSION_CUTSCENE(BOOL bStart, BOOL bResetControlAndCameras = TRUE, INT iInterpCams = -1, BOOL bResetCamHeading = TRUE, BOOL bRemoveText = TRUE, BOOL bDoFade = TRUE, BOOL bRenderScriptCams = TRUE, BOOL bToggleMultihead = TRUE)
|
|
IF bRemoveText
|
|
REMOVE_MISSION_TEXT()
|
|
ENDIF
|
|
|
|
IF bStart
|
|
SET_CUTSCENE_HUD_ELEMENTS()
|
|
SET_SCRIPTS_SAFE_FOR_CUTSCENE(TRUE,DEFAULT,bToggleMultihead) //Only toggle multihead blinders in some cases
|
|
DISPLAY_RADAR(FALSE)
|
|
DISPLAY_HUD(FALSE)
|
|
iAllowSkipCutsceneTime = GET_GAME_TIMER()
|
|
ELSE
|
|
SET_SCRIPTS_SAFE_FOR_CUTSCENE(FALSE, DEFAULT, bToggleMultihead)
|
|
IF bResetControlAndCameras
|
|
SET_PLAYER_CONTROL(PLAYER_ID(), TRUE)
|
|
DISPLAY_RADAR(TRUE)
|
|
DISPLAY_HUD(TRUE)
|
|
DISABLE_CELLPHONE(FALSE)
|
|
|
|
BOOL bInterpCams
|
|
IF iInterpCams < 0
|
|
bInterpCams = FALSE
|
|
ELSE
|
|
bInterpCams = TRUE
|
|
ENDIF
|
|
|
|
IF bRenderScriptCams
|
|
RENDER_SCRIPT_CAMS(FALSE, bInterpCams, iInterpCams)
|
|
ENDIF
|
|
|
|
IF DOES_CAM_EXIST(animCam)
|
|
DESTROY_CAM(animCam)
|
|
ENDIF
|
|
IF DOES_CAM_EXIST(chopSwitchCam)
|
|
DESTROY_CAM(chopSwitchCam)
|
|
ENDIF
|
|
|
|
DESTROY_MISSION_STATIC_CAM(staticCam)
|
|
DESTROY_MISSION_STATIC_CAM(interpCam)
|
|
|
|
IF bResetCamHeading
|
|
SET_GAMEPLAY_CAM_RELATIVE_HEADING(0.0)
|
|
ENDIF
|
|
ENDIF
|
|
bRunningCutscene = FALSE
|
|
bSkippedCutscene = FALSE
|
|
bClearedForCutscene = FALSE
|
|
bCutsceneWaitStarted = FALSE
|
|
cutsceneStage = H_CUT_STAGE_INIT
|
|
|
|
IF bDoFade
|
|
IF IS_SCREEN_FADED_OUT()
|
|
DO_SCREEN_FADE_IN(DEFAULT_FADE_TIME)
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDPROC
|
|
|
|
// prevent wanted level for cut
|
|
PROC PREVENT_WANTED_LEVEL_FOR_CUTSCENE()
|
|
SET_WANTED_LEVEL_MULTIPLIER(0.0)
|
|
SET_MAX_WANTED_LEVEL(0)
|
|
SET_PLAYER_WANTED_LEVEL(PLAYER_ID(), 0)
|
|
SET_PLAYER_WANTED_LEVEL_NOW(PLAYER_ID())
|
|
ENDPROC
|
|
|
|
// get correct model for mission vehicle
|
|
FUNC HOOD_MODEL_ENUM GET_MODEL_ENUM_FOR_HOOD_VEHICLE(HOOD_VEHICLE_ENUM hVehicle)
|
|
SWITCH hVehicle
|
|
CASE HV_FRANKLIN_VAN
|
|
RETURN HM_FRANKLIN_VAN
|
|
BREAK
|
|
CASE HV_BAD_GUY_BIKE
|
|
RETURN HM_BIKE
|
|
BREAK
|
|
ENDSWITCH
|
|
|
|
RETURN HM_FRANKLIN_VAN
|
|
ENDFUNC
|
|
|
|
// load objects if screen faded out
|
|
PROC LOAD_ALL_OBJECTS_IF_SCREEN_FADED_OUT()
|
|
IF IS_SCREEN_FADED_OUT()
|
|
LOAD_ALL_OBJECTS_NOW()
|
|
ENDIF
|
|
ENDPROC
|
|
|
|
// is this model required on this stage?
|
|
FUNC BOOL IS_MODEL_REQUIRED_FOR_MISSION_STAGE(HOOD_MODEL_ENUM pfModel, MISSION_STAGE_ENUM reqStage)
|
|
SWITCH pfModel
|
|
CASE HM_FRANKLIN
|
|
RETURN TRUE
|
|
BREAK
|
|
CASE HM_LAMAR
|
|
RETURN TRUE
|
|
BREAK
|
|
CASE HM_BAD_GUY
|
|
IF reqStage > STAGE_GET_TO_BAD_GUY
|
|
RETURN TRUE
|
|
ENDIF
|
|
BREAK
|
|
CASE HM_CHOP
|
|
RETURN TRUE
|
|
BREAK
|
|
CASE HM_COLLIE
|
|
IF reqStage = STAGE_FIND_BAD_GUY
|
|
RETURN TRUE
|
|
ENDIF
|
|
BREAK
|
|
CASE HM_GIRL
|
|
IF reqStage = STAGE_VAN_CHASE
|
|
RETURN TRUE
|
|
ENDIF
|
|
BREAK
|
|
CASE HM_WORKER
|
|
IF reqStage = STAGE_FOOT_CHASE
|
|
RETURN TRUE
|
|
ENDIF
|
|
BREAK
|
|
CASE HM_FRANKLIN_VAN
|
|
IF reqStage > STAGE_GET_TO_BAD_GUY
|
|
RETURN TRUE
|
|
ENDIF
|
|
BREAK
|
|
CASE HM_BIKE
|
|
IF reqStage <= STAGE_FOOT_CHASE
|
|
AND reqStage > STAGE_GET_TO_BAD_GUY
|
|
RETURN TRUE
|
|
ENDIF
|
|
BREAK
|
|
CASE HM_BUS
|
|
CASE HM_TRAFFIC_CAR1
|
|
CASE HM_TRAFFIC_CAR2
|
|
IF reqStage = STAGE_FOOT_CHASE
|
|
RETURN TRUE
|
|
ENDIF
|
|
BREAK
|
|
|
|
CASE HM_LAMAR_PHONE
|
|
CASE HM_FRANKLIN_MASK
|
|
IF reqStage = STAGE_GET_TO_HOUSE
|
|
RETURN TRUE
|
|
ENDIF
|
|
BREAK
|
|
|
|
CASE HM_START_VEHICLE
|
|
IF reqStage = STAGE_GET_TO_BAD_GUY
|
|
IF Is_Replay_In_Progress()
|
|
IF IS_REPLAY_START_VEHICLE_AVAILABLE()
|
|
IF IS_REPLAY_VEHICLE_MODEL_UNDER_SIZE_LIMIT(GET_REPLAY_START_VEHICLE_MODEL(), <<0,0,0>>)
|
|
RETURN TRUE
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
BREAK
|
|
|
|
CASE HM_ENGINE
|
|
CASE HM_TANKER_CARRIAGE
|
|
CASE HM_CONTAINER_CARRIAGE
|
|
CASE HM_BOXCAR_DOOR
|
|
CASE HM_BOXCAR_HANDLE
|
|
CASE HM_ANCHOR
|
|
//IF reqStage = STAGE_FOOT_CHASE
|
|
IF reqStage = STAGE_FIND_BAD_GUY
|
|
RETURN TRUE
|
|
ENDIF
|
|
BREAK
|
|
ENDSWITCH
|
|
|
|
RETURN FALSE
|
|
ENDFUNC
|
|
|
|
// add a request for a model
|
|
PROC ADD_MODEL_REQUEST(INT i)
|
|
MODEL_NAMES mModelToRequest = GET_MODEL_FOR_HOOD_MODEL_ENUM(INT_TO_ENUM(HOOD_MODEL_ENUM, i))
|
|
REQUEST_MODEL(mModelToRequest)
|
|
bModelRequestTracker[i] = TRUE
|
|
ENDPROC
|
|
|
|
// remove request
|
|
PROC CLEAR_MODEL_REQUEST(INT i)
|
|
IF bModelRequestTracker[i]
|
|
MODEL_NAMES mModelToRequest = GET_MODEL_FOR_HOOD_MODEL_ENUM(INT_TO_ENUM(HOOD_MODEL_ENUM, i))
|
|
IF HAS_MODEL_LOADED(mModelToRequest)
|
|
SET_MODEL_AS_NO_LONGER_NEEDED(mModelToRequest)
|
|
ENDIF
|
|
bModelRequestTracker[i] = FALSE
|
|
ENDIF
|
|
ENDPROC
|
|
|
|
// have all requests for models succeeded?
|
|
FUNC BOOL HAVE_ALL_MODEL_REQUESTS_SUCCEEDED()
|
|
INT i
|
|
|
|
// loop through and check for empty
|
|
REPEAT NUMBER_MODEL_REQUEST_SLOTS i
|
|
IF bModelRequestTracker[i] = TRUE
|
|
IF NOT HAS_MODEL_LOADED(GET_MODEL_FOR_HOOD_MODEL_ENUM(INT_TO_ENUM(HOOD_MODEL_ENUM, i)))
|
|
// a full slot is not loaded, return false
|
|
RETURN FALSE
|
|
ENDIF
|
|
ENDIF
|
|
ENDREPEAT
|
|
|
|
RETURN TRUE
|
|
ENDFUNC
|
|
|
|
// request the models for a particular stage
|
|
PROC REQUEST_MODELS_FOR_STAGE(MISSION_STAGE_ENUM requestStage, BOOL bWaitForLoad, BOOL bKeepModelsForCurrentStage)
|
|
|
|
INT i
|
|
REPEAT NUMBER_MODEL_REQUEST_SLOTS i
|
|
IF IS_MODEL_REQUIRED_FOR_MISSION_STAGE(INT_TO_ENUM(HOOD_MODEL_ENUM, i), requestStage)
|
|
// if we need this model, request it
|
|
ADD_MODEL_REQUEST(i)
|
|
ELSE
|
|
// otherwise try and get rid of it
|
|
IF NOT IS_MODEL_REQUIRED_FOR_MISSION_STAGE(INT_TO_ENUM(HOOD_MODEL_ENUM, i), currentMissionStage)
|
|
OR NOT bKeepModelsForCurrentStage
|
|
CLEAR_MODEL_REQUEST(i)
|
|
ENDIF
|
|
ENDIF
|
|
ENDREPEAT
|
|
|
|
// if wait for load, don't quit out 'til all the models are in
|
|
IF bWaitForLoad
|
|
IF NOT HAVE_ALL_MODEL_REQUESTS_SUCCEEDED()
|
|
LOAD_ALL_OBJECTS_IF_SCREEN_FADED_OUT()
|
|
WHILE NOT HAVE_ALL_MODEL_REQUESTS_SUCCEEDED()
|
|
WAIT(0)
|
|
ENDWHILE
|
|
ENDIF
|
|
ENDIF
|
|
ENDPROC
|
|
|
|
// is this recording required on this stage?
|
|
FUNC BOOL IS_RECORDING_REQUIRED_FOR_MISSION_STAGE(INT iRec, MISSION_STAGE_ENUM reqStage)
|
|
SWITCH iRec
|
|
CASE 001 // setpieces
|
|
//CASE 002
|
|
//CASE 003
|
|
//CASE 004
|
|
//CASE 005
|
|
//CASE 006
|
|
//CASE 007
|
|
CASE 011
|
|
CASE 012
|
|
IF reqStage = STAGE_FOOT_CHASE
|
|
RETURN TRUE
|
|
ENDIF
|
|
BREAK
|
|
//CASE 008 // crash cut
|
|
//CASE 009
|
|
// IF reqStage = STAGE_VAN_CHASE
|
|
// RETURN TRUE
|
|
// ENDIF
|
|
//BREAK
|
|
//CASE 010 // lamar backs van up
|
|
// IF reqStage = STAGE_FIND_BAD_GUY
|
|
// RETURN TRUE
|
|
// ENDIF
|
|
//BREAK
|
|
//CASE 013 // camera recording for bike
|
|
// IF reqStage = STAGE_VAN_CHASE
|
|
// RETURN TRUE
|
|
// ENDIF
|
|
//BREAK
|
|
CASE 014 // bad guy alley escape
|
|
IF reqStage = STAGE_GET_TO_BAD_GUY
|
|
RETURN TRUE
|
|
ENDIF
|
|
BREAK
|
|
ENDSWITCH
|
|
|
|
RETURN FALSE
|
|
ENDFUNC
|
|
|
|
// add a request for a recording
|
|
PROC ADD_RECORDING_REQUEST(INT iRec)
|
|
bVehicleRecordingRequestTracker[iRec-1] = TRUE
|
|
REQUEST_VEHICLE_RECORDING(iRec, GET_HOOD_RECORDING_PREFIX())
|
|
ENDPROC
|
|
|
|
// clear a recording request slot
|
|
PROC CLEAR_RECORDING_REQUEST(INT iRec)
|
|
IF bVehicleRecordingRequestTracker[iRec-1]
|
|
bVehicleRecordingRequestTracker[iRec-1] = FALSE
|
|
IF HAS_VEHICLE_RECORDING_BEEN_LOADED(iRec, GET_HOOD_RECORDING_PREFIX())
|
|
REMOVE_VEHICLE_RECORDING(iRec, GET_HOOD_RECORDING_PREFIX())
|
|
ENDIF
|
|
ENDIF
|
|
ENDPROC
|
|
|
|
// have all requests for recordings succeeded?
|
|
FUNC BOOL HAVE_ALL_RECORDING_REQUESTS_SUCCEEDED()
|
|
INT i
|
|
|
|
// loop through and check for empty
|
|
REPEAT NUMBER_RECORDING_REQUEST_SLOTS i
|
|
IF bVehicleRecordingRequestTracker[i]
|
|
IF NOT HAS_VEHICLE_RECORDING_BEEN_LOADED(i+1, GET_HOOD_RECORDING_PREFIX())
|
|
// a full slot is not loaded, return false
|
|
RETURN FALSE
|
|
ENDIF
|
|
ENDIF
|
|
ENDREPEAT
|
|
|
|
RETURN TRUE
|
|
ENDFUNC
|
|
|
|
// get recordings for particular stage
|
|
PROC REQUEST_VEHICLE_RECORDINGS_FOR_STAGE(MISSION_STAGE_ENUM requestStage, BOOL bWaitForLoad, BOOL bKeepRecordingsForCurrentStage)
|
|
|
|
INT i
|
|
REPEAT NUMBER_RECORDING_REQUEST_SLOTS i
|
|
IF IS_RECORDING_REQUIRED_FOR_MISSION_STAGE(i+1, requestStage)
|
|
// if we need this recording, request it
|
|
ADD_RECORDING_REQUEST(i+1)
|
|
ELSE
|
|
// otherwise try and get rid of it
|
|
IF NOT IS_RECORDING_REQUIRED_FOR_MISSION_STAGE(i+1, currentMissionStage)
|
|
OR NOT bKeepRecordingsForCurrentStage
|
|
CLEAR_RECORDING_REQUEST(i+1)
|
|
ENDIF
|
|
ENDIF
|
|
ENDREPEAT
|
|
|
|
// this is decidedly unpleasant but what are you gonna do
|
|
IF requestStage = STAGE_VAN_CHASE
|
|
OR requestStage = STAGE_GET_TO_BAD_GUY // TEMP
|
|
REQUEST_VEHICLE_RECORDING(001, GET_HOOD_UBER_RECORDING_PREFIX())
|
|
ENDIF
|
|
|
|
// if wait for load, don't quit out 'til all the recordings are in
|
|
IF bWaitForLoad
|
|
IF NOT HAVE_ALL_RECORDING_REQUESTS_SUCCEEDED()
|
|
LOAD_ALL_OBJECTS_IF_SCREEN_FADED_OUT()
|
|
WHILE NOT HAVE_ALL_RECORDING_REQUESTS_SUCCEEDED()
|
|
WAIT(0)
|
|
ENDWHILE
|
|
ENDIF
|
|
IF requestStage = STAGE_VAN_CHASE
|
|
WHILE NOT HAS_VEHICLE_RECORDING_BEEN_LOADED(001, GET_HOOD_UBER_RECORDING_PREFIX())
|
|
WAIT(0)
|
|
ENDWHILE
|
|
ENDIF
|
|
ENDIF
|
|
ENDPROC
|
|
|
|
// is this waypoint required on this stage?
|
|
FUNC BOOL IS_WAYPOINT_REQUIRED_FOR_MISSION_STAGE(INT iWaypoint, MISSION_STAGE_ENUM reqStage)
|
|
SWITCH iWaypoint + 1
|
|
CASE 1 // bad guy on foot chase
|
|
IF reqStage = STAGE_FOOT_CHASE
|
|
OR reqStage = STAGE_VAN_CHASE
|
|
RETURN TRUE
|
|
ENDIF
|
|
BREAK
|
|
CASE 2
|
|
CASE 3
|
|
IF reqStage = STAGE_FOOT_CHASE
|
|
RETURN TRUE
|
|
ENDIF
|
|
BREAK
|
|
CASE 4 // franklin chase
|
|
IF reqStage = STAGE_FOOT_CHASE
|
|
RETURN TRUE
|
|
ENDIF
|
|
BREAK
|
|
CASE 5 // bad guy escape attempt
|
|
IF reqStage = STAGE_FIND_BAD_GUY
|
|
RETURN TRUE
|
|
ENDIF
|
|
BREAK
|
|
CASE 6 // chop follow to van
|
|
IF reqStage = STAGE_GET_TO_BAD_GUY
|
|
RETURN TRUE
|
|
ENDIF
|
|
BREAK
|
|
CASE 7 // chop chase
|
|
IF reqStage = STAGE_FOOT_CHASE
|
|
OR reqStage = STAGE_VAN_CHASE
|
|
RETURN TRUE
|
|
ENDIF
|
|
BREAK
|
|
CASE 8 // chop find
|
|
IF reqStage = STAGE_FIND_BAD_GUY
|
|
RETURN TRUE
|
|
ENDIF
|
|
BREAK
|
|
CASE 9 // lamar walk at end
|
|
CASE 10 // chop walk at end
|
|
IF reqStage = STAGE_GET_TO_HOUSE
|
|
RETURN TRUE
|
|
ENDIF
|
|
BREAK
|
|
CASE 11 // chop bypass fence
|
|
IF reqStage = STAGE_FOOT_CHASE
|
|
RETURN TRUE
|
|
ENDIF
|
|
BREAK
|
|
CASE 12 // chop enter van
|
|
IF reqStage = STAGE_GET_TO_BAD_GUY
|
|
RETURN TRUE
|
|
ENDIF
|
|
BREAK
|
|
ENDSWITCH
|
|
|
|
RETURN FALSE
|
|
ENDFUNC
|
|
|
|
FUNC TEXT_LABEL GET_WAYPOINT_LABEL_FROM_INT(INT iWaypoint)
|
|
TEXT_LABEL tWaypoint = "hood"
|
|
tWaypoint += (iWaypoint+1)
|
|
RETURN tWaypoint
|
|
ENDFUNC
|
|
|
|
// add a request for a waypoint
|
|
PROC ADD_WAYPOINT_REQUEST(INT iWaypoint)
|
|
bWaypointRequestTracker[iWaypoint] = TRUE
|
|
TEXT_LABEL tWaypoint = GET_WAYPOINT_LABEL_FROM_INT(iWaypoint)
|
|
REQUEST_WAYPOINT_RECORDING(tWaypoint)
|
|
ENDPROC
|
|
|
|
// clear a waypoint request slot
|
|
PROC CLEAR_WAYPOINT_REQUEST(INT iWaypoint)
|
|
IF bWaypointRequestTracker[iWaypoint]
|
|
bWaypointRequestTracker[iWaypoint] = FALSE
|
|
TEXT_LABEL tWaypoint = GET_WAYPOINT_LABEL_FROM_INT(iWaypoint)
|
|
IF GET_IS_WAYPOINT_RECORDING_LOADED(tWaypoint) = FALSE
|
|
REMOVE_WAYPOINT_RECORDING(tWaypoint)
|
|
ENDIF
|
|
ENDIF
|
|
ENDPROC
|
|
|
|
// have all requests for waypoints succeeded?
|
|
FUNC BOOL HAVE_ALL_WAYPOINT_REQUESTS_SUCCEEDED()
|
|
INT i
|
|
|
|
// loop through and check for empty
|
|
REPEAT NUMBER_WAYPOINT_REQUEST_SLOTS i
|
|
IF bWaypointRequestTracker[i]
|
|
TEXT_LABEL tWaypoint = GET_WAYPOINT_LABEL_FROM_INT(i)
|
|
IF NOT GET_IS_WAYPOINT_RECORDING_LOADED(tWaypoint)
|
|
// a full slot is not loaded, return false
|
|
RETURN FALSE
|
|
ENDIF
|
|
ENDIF
|
|
ENDREPEAT
|
|
|
|
RETURN TRUE
|
|
ENDFUNC
|
|
|
|
// get recordings for particular stage
|
|
PROC REQUEST_WAYPOINT_RECORDINGS_FOR_STAGE(MISSION_STAGE_ENUM requestStage, BOOL bWaitForLoad, BOOL bKeepWaypointsForCurrentStage)
|
|
INT i
|
|
REPEAT NUMBER_WAYPOINT_REQUEST_SLOTS i
|
|
IF IS_WAYPOINT_REQUIRED_FOR_MISSION_STAGE(i, requestStage)
|
|
// if we need this waypoint, request it
|
|
ADD_WAYPOINT_REQUEST(i)
|
|
ELSE
|
|
// otherwise try and get rid of it
|
|
IF NOT IS_WAYPOINT_REQUIRED_FOR_MISSION_STAGE(i, currentMissionStage)
|
|
OR NOT bKeepWaypointsForCurrentStage
|
|
CLEAR_WAYPOINT_REQUEST(i)
|
|
ENDIF
|
|
ENDIF
|
|
ENDREPEAT
|
|
|
|
// if wait for load, don't quit out 'til all the waypoints are in
|
|
IF bWaitForLoad
|
|
IF NOT HAVE_ALL_WAYPOINT_REQUESTS_SUCCEEDED()
|
|
LOAD_ALL_OBJECTS_IF_SCREEN_FADED_OUT()
|
|
WHILE NOT HAVE_ALL_WAYPOINT_REQUESTS_SUCCEEDED()
|
|
WAIT(0)
|
|
ENDWHILE
|
|
ENDIF
|
|
ENDIF
|
|
ENDPROC
|
|
|
|
// get an anim dict enum as string
|
|
FUNC STRING GET_HOOD_ANIM_DICT_AS_STRING(HOOD_ANIM_DICT_ENUM animDict)
|
|
SWITCH animDict
|
|
CASE H_ANIM_DICT_SHARED
|
|
RETURN "missfra0_chop_shared"
|
|
BREAK
|
|
CASE H_ANIM_DICT_TO_VAN
|
|
RETURN "missfra0_chop_tovan"
|
|
BREAK
|
|
CASE H_ANIM_DICT_FOOT_CHASE
|
|
RETURN "missfra0_chop_fchase"
|
|
BREAK
|
|
CASE H_ANIM_DICT_FIND
|
|
RETURN "missfra0_chop_find"
|
|
BREAK
|
|
CASE H_ANIM_DICT_DRIVE_HOME
|
|
RETURN "missfra0_chop_drhome"
|
|
BREAK
|
|
CASE H_ANIM_DICT_CHOP_VAN
|
|
RETURN GET_CHOP_IN_VAN_ANIM_DICT()
|
|
BREAK
|
|
|
|
ENDSWITCH
|
|
|
|
RETURN "invalid!"
|
|
ENDFUNC
|
|
|
|
// is this anim dict required on this stage?
|
|
FUNC BOOL IS_ANIM_DICT_REQUIRED_FOR_MISSION_STAGE(HOOD_ANIM_DICT_ENUM animDict, MISSION_STAGE_ENUM reqStage)
|
|
reqStage=reqStage
|
|
SWITCH animDict
|
|
CASE H_ANIM_DICT_SHARED
|
|
RETURN TRUE
|
|
BREAK
|
|
CASE H_ANIM_DICT_TO_VAN
|
|
IF reqStage = STAGE_GET_TO_BAD_GUY
|
|
RETURN TRUE
|
|
ENDIF
|
|
BREAK
|
|
CASE H_ANIM_DICT_FOOT_CHASE
|
|
IF reqStage = STAGE_FOOT_CHASE
|
|
RETURN TRUE
|
|
ENDIF
|
|
BREAK
|
|
CASE H_ANIM_DICT_FIND
|
|
IF reqStage = STAGE_FIND_BAD_GUY
|
|
RETURN TRUE
|
|
ENDIF
|
|
BREAK
|
|
CASE H_ANIM_DICT_DRIVE_HOME
|
|
IF reqStage = STAGE_GET_TO_HOUSE
|
|
OR reqStage = STAGE_VAN_CHASE
|
|
RETURN TRUE
|
|
ENDIF
|
|
BREAK
|
|
//CASE H_ANIM_DICT_TAKEDOWN
|
|
// IF reqStage = STAGE_FIND_BAD_GUY
|
|
// RETURN TRUE
|
|
// ENDIF
|
|
//BREAK
|
|
CASE H_ANIM_DICT_CHOP_VAN
|
|
IF reqStage <= STAGE_VAN_CHASE
|
|
OR reqStage = STAGE_GET_TO_HOUSE
|
|
RETURN TRUE
|
|
ENDIF
|
|
BREAK
|
|
//CASE H_ANIM_DICT_GESTURE_ENT
|
|
//CASE H_ANIM_DICT_GESTURE_IDLE1
|
|
//CASE H_ANIM_DICT_GESTURE_IDLE2
|
|
//CASE H_ANIM_DICT_GESTURE_EXT
|
|
// IF reqStage = STAGE_FOOT_CHASE
|
|
// RETURN TRUE
|
|
// ENDIF
|
|
//BREAK
|
|
//CASE H_ANIM_DICT_TAXI
|
|
// IF reqStage = STAGE_FIND_BAD_GUY
|
|
/// RETURN TRUE
|
|
// ENDIF
|
|
//BREAK
|
|
ENDSWITCH
|
|
|
|
RETURN FALSE
|
|
ENDFUNC
|
|
|
|
// add a request for an anim
|
|
PROC ADD_ANIM_DICT_REQUEST(HOOD_ANIM_DICT_ENUM animDict)
|
|
bAnimDictRequestTracker[animDict] = TRUE
|
|
STRING sAnimDict = GET_HOOD_ANIM_DICT_AS_STRING(animDict)
|
|
REQUEST_ANIM_DICT(sAnimDict)
|
|
ENDPROC
|
|
|
|
// clear an anim request slot
|
|
PROC CLEAR_ANIM_DICT_REQUEST(HOOD_ANIM_DICT_ENUM animDict)
|
|
IF bAnimDictRequestTracker[animDict]
|
|
bAnimDictRequestTracker[animDict] = FALSE
|
|
STRING sAnimDict = GET_HOOD_ANIM_DICT_AS_STRING(animDict)
|
|
IF HAS_ANIM_DICT_LOADED(sAnimDict)
|
|
REMOVE_ANIM_DICT(sAnimDict)
|
|
ENDIF
|
|
ENDIF
|
|
ENDPROC
|
|
|
|
// have all requests for anims succeeded?
|
|
FUNC BOOL HAVE_ALL_ANIM_DICT_REQUESTS_SUCCEEDED()
|
|
INT i
|
|
|
|
// loop through and check for empty
|
|
REPEAT COUNT_OF(HOOD_ANIM_DICT_ENUM) i
|
|
IF bAnimDictRequestTracker[i]
|
|
IF NOT HAS_ANIM_DICT_LOADED(GET_HOOD_ANIM_DICT_AS_STRING(INT_TO_ENUM(HOOD_ANIM_DICT_ENUM, i)))
|
|
// a full slot is not loaded, return false
|
|
RETURN FALSE
|
|
ENDIF
|
|
ENDIF
|
|
ENDREPEAT
|
|
|
|
RETURN TRUE
|
|
ENDFUNC
|
|
|
|
// get anims for particular stage
|
|
PROC REQUEST_ANIM_DICTS_FOR_STAGE(MISSION_STAGE_ENUM requestStage, BOOL bWaitForLoad, BOOL bKeepAnimsForCurrentStage)
|
|
|
|
INT i
|
|
REPEAT COUNT_OF(HOOD_ANIM_DICT_ENUM) i
|
|
HOOD_ANIM_DICT_ENUM thisAnimDict = INT_TO_ENUM(HOOD_ANIM_DICT_ENUM, i)
|
|
|
|
IF IS_ANIM_DICT_REQUIRED_FOR_MISSION_STAGE(thisAnimDict, requestStage)
|
|
// if we need this recording, request it
|
|
ADD_ANIM_DICT_REQUEST(thisAnimDict)
|
|
ELSE
|
|
// otherwise try and get rid of it
|
|
IF NOT IS_ANIM_DICT_REQUIRED_FOR_MISSION_STAGE(thisAnimDict, currentMissionStage)
|
|
OR NOT bKeepAnimsForCurrentStage
|
|
CLEAR_ANIM_DICT_REQUEST(thisAnimDict)
|
|
ENDIF
|
|
ENDIF
|
|
ENDREPEAT
|
|
|
|
// if wait for load, don't quit out 'til all the recordings are in
|
|
IF bWaitForLoad
|
|
IF NOT HAVE_ALL_ANIM_DICT_REQUESTS_SUCCEEDED()
|
|
LOAD_ALL_OBJECTS_IF_SCREEN_FADED_OUT()
|
|
WHILE NOT HAVE_ALL_ANIM_DICT_REQUESTS_SUCCEEDED()
|
|
WAIT(0)
|
|
ENDWHILE
|
|
ENDIF
|
|
ENDIF
|
|
ENDPROC
|
|
|
|
// get a weapon enum as a weapontype
|
|
FUNC WEAPON_TYPE GET_HOOD_WEAPON_TYPE(HOOD_WEAPON_ENUM weapon)
|
|
SWITCH weapon
|
|
CASE H_WEAPON_PISTOL
|
|
RETURN WEAPONTYPE_PISTOL
|
|
BREAK
|
|
ENDSWITCH
|
|
|
|
RETURN WEAPONTYPE_UNARMED
|
|
ENDFUNC
|
|
|
|
// is this weapon required on this stage?
|
|
FUNC BOOL IS_WEAPON_REQUIRED_FOR_MISSION_STAGE(HOOD_WEAPON_ENUM weapon, MISSION_STAGE_ENUM reqStage)
|
|
SWITCH weapon
|
|
CASE H_WEAPON_PISTOL
|
|
IF reqStage <= STAGE_VAN_CHASE
|
|
RETURN TRUE
|
|
ENDIF
|
|
BREAK
|
|
ENDSWITCH
|
|
|
|
RETURN FALSE
|
|
ENDFUNC
|
|
|
|
// add a request for a weapon
|
|
PROC ADD_WEAPON_REQUEST(HOOD_WEAPON_ENUM weapon)
|
|
bWeaponRequestTracker[weapon] = TRUE
|
|
WEAPON_TYPE weaponType = GET_HOOD_WEAPON_TYPE(weapon)
|
|
REQUEST_WEAPON_ASSET(weaponType)
|
|
ENDPROC
|
|
|
|
// clear a weapon request slot
|
|
PROC CLEAR_WEAPON_REQUEST(HOOD_WEAPON_ENUM weapon)
|
|
IF bWeaponRequestTracker[weapon]
|
|
bWeaponRequestTracker[weapon] = FALSE
|
|
WEAPON_TYPE weaponType = GET_HOOD_WEAPON_TYPE(weapon)
|
|
IF HAS_WEAPON_ASSET_LOADED(weaponType)
|
|
REMOVE_WEAPON_ASSET(weaponType)
|
|
ENDIF
|
|
ENDIF
|
|
ENDPROC
|
|
|
|
// have all requests for weapons succeeded?
|
|
FUNC BOOL HAVE_ALL_WEAPON_REQUESTS_SUCCEEDED()
|
|
INT i
|
|
|
|
// loop through and check for empty
|
|
REPEAT COUNT_OF(HOOD_WEAPON_ENUM) i
|
|
IF bWeaponRequestTracker[i]
|
|
IF NOT HAS_WEAPON_ASSET_LOADED(GET_HOOD_WEAPON_TYPE(INT_TO_ENUM(HOOD_WEAPON_ENUM, i)))
|
|
// a full slot is not loaded, return false
|
|
RETURN FALSE
|
|
ENDIF
|
|
ENDIF
|
|
ENDREPEAT
|
|
|
|
RETURN TRUE
|
|
ENDFUNC
|
|
|
|
// get weapons for particular stage
|
|
PROC REQUEST_WEAPONS_FOR_STAGE(MISSION_STAGE_ENUM requestStage, BOOL bWaitForLoad, BOOL bKeepWeaponsForCurrentStage)
|
|
|
|
INT i
|
|
REPEAT COUNT_OF(HOOD_WEAPON_ENUM) i
|
|
HOOD_WEAPON_ENUM thisWeapon = INT_TO_ENUM(HOOD_WEAPON_ENUM, i)
|
|
|
|
IF IS_WEAPON_REQUIRED_FOR_MISSION_STAGE(thisWeapon, requestStage)
|
|
// if we need this recording, request it
|
|
ADD_WEAPON_REQUEST(thisWeapon)
|
|
ELSE
|
|
// otherwise try and get rid of it
|
|
IF NOT IS_WEAPON_REQUIRED_FOR_MISSION_STAGE(thisWeapon, currentMissionStage)
|
|
OR NOT bKeepWeaponsForCurrentStage
|
|
CLEAR_WEAPON_REQUEST(thisWeapon)
|
|
ENDIF
|
|
ENDIF
|
|
ENDREPEAT
|
|
|
|
|
|
// if wait for load, don't quit out 'til all the recordings are in
|
|
IF bWaitForLoad
|
|
IF NOT HAVE_ALL_WEAPON_REQUESTS_SUCCEEDED()
|
|
LOAD_ALL_OBJECTS_IF_SCREEN_FADED_OUT()
|
|
WHILE NOT HAVE_ALL_WEAPON_REQUESTS_SUCCEEDED()
|
|
WAIT(0)
|
|
ENDWHILE
|
|
ENDIF
|
|
ENDIF
|
|
ENDPROC
|
|
|
|
/*
|
|
// get a ptfx enum as string
|
|
FUNC STRING GET_HOOD_PTFX_AS_STRING(HOOD_PTFX_ENUM ptfx)
|
|
SWITCH ptfx
|
|
CASE H_PTFX_SCRIPT
|
|
RETURN "script"
|
|
BREAK
|
|
ENDSWITCH
|
|
|
|
RETURN "invalid!"
|
|
ENDFUNC
|
|
*/
|
|
|
|
// is this ptfx required on this stage?
|
|
FUNC BOOL IS_PTFX_REQUIRED_FOR_MISSION_STAGE(HOOD_PTFX_ENUM ptfx, MISSION_STAGE_ENUM reqStage)
|
|
SWITCH ptfx
|
|
CASE H_PTFX_SCRIPT
|
|
IF reqStage >= STAGE_FOOT_CHASE
|
|
RETURN TRUE
|
|
ENDIF
|
|
BREAK
|
|
ENDSWITCH
|
|
|
|
RETURN FALSE
|
|
ENDFUNC
|
|
|
|
// add a request for a ptfx
|
|
PROC ADD_PTFX_REQUEST(HOOD_PTFX_ENUM ptfx)
|
|
bPTFXRequestTracker[ptfx] = TRUE
|
|
// STRING sPTFX = GET_HOOD_PTFX_AS_STRING(ptfx)
|
|
REQUEST_PTFX_ASSET()
|
|
ENDPROC
|
|
|
|
// clear a ptfx request slot
|
|
PROC CLEAR_PTFX_REQUEST(HOOD_PTFX_ENUM ptfx)
|
|
IF bPTFXRequestTracker[ptfx]
|
|
bPTFXRequestTracker[ptfx] = FALSE
|
|
// STRING sPTFX = GET_HOOD_PTFX_AS_STRING(ptfx)
|
|
IF HAS_PTFX_ASSET_LOADED()
|
|
REMOVE_PTFX_ASSET()
|
|
ENDIF
|
|
ENDIF
|
|
ENDPROC
|
|
|
|
// have all requests for ptfx succeeded?
|
|
FUNC BOOL HAVE_ALL_PTFX_REQUESTS_SUCCEEDED()
|
|
INT i
|
|
|
|
// loop through and check for empty
|
|
REPEAT COUNT_OF(HOOD_PTFX_ENUM) i
|
|
IF bPTFXRequestTracker[i]
|
|
IF NOT HAS_PTFX_ASSET_LOADED()
|
|
// a full slot is not loaded, return false
|
|
RETURN FALSE
|
|
ENDIF
|
|
ENDIF
|
|
ENDREPEAT
|
|
|
|
RETURN TRUE
|
|
ENDFUNC
|
|
|
|
// get ptfx for particular stage
|
|
PROC REQUEST_PTFX_FOR_STAGE(MISSION_STAGE_ENUM requestStage, BOOL bWaitForLoad, BOOL bKeepPTFXForCurrentStage)
|
|
|
|
INT i
|
|
REPEAT COUNT_OF(HOOD_PTFX_ENUM) i
|
|
HOOD_PTFX_ENUM thisPTFX = INT_TO_ENUM(HOOD_PTFX_ENUM, i)
|
|
|
|
IF IS_PTFX_REQUIRED_FOR_MISSION_STAGE(thisPTFX, requestStage)
|
|
// if we need this recording, request it
|
|
ADD_PTFX_REQUEST(thisPTFX)
|
|
ELSE
|
|
// otherwise try and get rid of it
|
|
IF NOT IS_PTFX_REQUIRED_FOR_MISSION_STAGE(thisPTFX, currentMissionStage)
|
|
OR NOT bKeepPTFXForCurrentStage
|
|
CLEAR_PTFX_REQUEST(thisPTFX)
|
|
ENDIF
|
|
ENDIF
|
|
ENDREPEAT
|
|
|
|
|
|
// if wait for load, don't quit out 'til all the recordings are in
|
|
IF bWaitForLoad
|
|
IF NOT HAVE_ALL_PTFX_REQUESTS_SUCCEEDED()
|
|
LOAD_ALL_OBJECTS_IF_SCREEN_FADED_OUT()
|
|
WHILE NOT HAVE_ALL_PTFX_REQUESTS_SUCCEEDED()
|
|
WAIT(0)
|
|
ENDWHILE
|
|
ENDIF
|
|
ENDIF
|
|
ENDPROC
|
|
|
|
// get a sfx enum as string
|
|
FUNC STRING GET_HOOD_SFX_AS_STRING(HOOD_SFX_ENUM sfx)
|
|
SWITCH sfx
|
|
CASE H_SFX_BOXCARS
|
|
RETURN "FRANKLIN_0_BOXCARS"
|
|
BREAK
|
|
CASE H_SFX_GENERAL
|
|
RETURN "FRANKLIN_0_GENERAL"
|
|
BREAK
|
|
ENDSWITCH
|
|
|
|
RETURN "invalid!"
|
|
ENDFUNC
|
|
|
|
// is this sfx required on this stage?
|
|
FUNC BOOL IS_SFX_REQUIRED_FOR_MISSION_STAGE(HOOD_SFX_ENUM sfx, MISSION_STAGE_ENUM reqStage)
|
|
|
|
SWITCH sfx
|
|
CASE H_SFX_BOXCARS
|
|
IF reqStage = STAGE_FIND_BAD_GUY
|
|
RETURN TRUE
|
|
ENDIF
|
|
BREAK
|
|
CASE H_SFX_GENERAL
|
|
IF reqStage = STAGE_FOOT_CHASE
|
|
OR reqStage = STAGE_VAN_CHASE
|
|
RETURN TRUE
|
|
ENDIF
|
|
BREAK
|
|
ENDSWITCH
|
|
|
|
RETURN FALSE
|
|
ENDFUNC
|
|
|
|
// add a request for a sfx
|
|
PROC ADD_SFX_REQUEST(HOOD_SFX_ENUM sfx)
|
|
bSFXRequestTracker[sfx] = TRUE
|
|
STRING sSFX = GET_HOOD_SFX_AS_STRING(sfx)
|
|
REQUEST_SCRIPT_AUDIO_BANK(sSFX)
|
|
ENDPROC
|
|
|
|
// clear a sfx request slot
|
|
PROC CLEAR_SFX_REQUEST(HOOD_SFX_ENUM sfx)
|
|
IF bSFXRequestTracker[sfx]
|
|
bSFXRequestTracker[sfx] = FALSE
|
|
STRING sSFX = GET_HOOD_SFX_AS_STRING(sfx)
|
|
RELEASE_NAMED_SCRIPT_AUDIO_BANK(sSFX)
|
|
ENDIF
|
|
ENDPROC
|
|
|
|
// have all requests for sfx succeeded?
|
|
FUNC BOOL HAVE_ALL_SFX_REQUESTS_SUCCEEDED()
|
|
INT i
|
|
|
|
// loop through and check for empty
|
|
REPEAT COUNT_OF(HOOD_SFX_ENUM) i
|
|
IF bSFXRequestTracker[i]
|
|
IF NOT REQUEST_SCRIPT_AUDIO_BANK(GET_HOOD_SFX_AS_STRING(INT_TO_ENUM(HOOD_SFX_ENUM, i)))
|
|
// a full slot is not loaded, return false
|
|
RETURN FALSE
|
|
ENDIF
|
|
ENDIF
|
|
ENDREPEAT
|
|
|
|
RETURN TRUE
|
|
ENDFUNC
|
|
|
|
// get sfx for particular stage
|
|
PROC REQUEST_SFX_FOR_STAGE(MISSION_STAGE_ENUM requestStage, BOOL bWaitForLoad, BOOL bKeepSFXForCurrentStage)
|
|
|
|
INT i
|
|
REPEAT COUNT_OF(HOOD_SFX_ENUM) i
|
|
HOOD_SFX_ENUM thisSFX = INT_TO_ENUM(HOOD_SFX_ENUM, i)
|
|
|
|
IF IS_SFX_REQUIRED_FOR_MISSION_STAGE(thisSFX, requestStage)
|
|
// if we need this recording, request it
|
|
ADD_SFX_REQUEST(thisSFX)
|
|
ELSE
|
|
// otherwise try and get rid of it
|
|
IF NOT IS_SFX_REQUIRED_FOR_MISSION_STAGE(thisSFX, currentMissionStage)
|
|
OR NOT bKeepSFXForCurrentStage
|
|
CLEAR_SFX_REQUEST(thisSFX)
|
|
ENDIF
|
|
ENDIF
|
|
ENDREPEAT
|
|
|
|
// if wait for load, don't quit out 'til all the recordings are in
|
|
IF bWaitForLoad
|
|
IF NOT HAVE_ALL_SFX_REQUESTS_SUCCEEDED()
|
|
LOAD_ALL_OBJECTS_IF_SCREEN_FADED_OUT()
|
|
WHILE NOT HAVE_ALL_SFX_REQUESTS_SUCCEEDED()
|
|
WAIT(0)
|
|
ENDWHILE
|
|
ENDIF
|
|
ENDIF
|
|
ENDPROC
|
|
|
|
// is this misc asset required on this stage?
|
|
FUNC BOOL IS_MISC_ASSET_REQUIRED_FOR_MISSION_STAGE(HOOD_MISC_ASSET_ENUM miscAsset, MISSION_STAGE_ENUM reqStage)
|
|
SWITCH miscAsset
|
|
CASE H_MISC_ASSET_VAN_ANIMS
|
|
IF reqStage = STAGE_GET_TO_HOUSE
|
|
OR reqStage = STAGE_VAN_CHASE
|
|
RETURN TRUE
|
|
ENDIF
|
|
BREAK
|
|
CASE H_MISC_ASSET_INJURED_CLIPSET
|
|
//IF reqStage = STAGE_GET_TO_HOUSE
|
|
// RETURN TRUE
|
|
//ENDIF
|
|
BREAK
|
|
//CASE H_MISC_ASSET_CHOP_CAM_SFX
|
|
// IF reqStage = STAGE_FOOT_CHASE
|
|
// OR reqStage = STAGE_FIND_BAD_GUY
|
|
// RETURN TRUE
|
|
// ENDIF
|
|
//BREAK
|
|
CASE H_MISC_ASSET_FAKE_CELLPHONE
|
|
IF reqStage = STAGE_GET_TO_HOUSE
|
|
RETURN TRUE
|
|
ENDIF
|
|
BREAK
|
|
CASE H_MISC_ASSET_GESTURES
|
|
IF reqStage = STAGE_GET_TO_BAD_GUY
|
|
RETURN TRUE
|
|
ENDIF
|
|
BREAK
|
|
ENDSWITCH
|
|
|
|
RETURN FALSE
|
|
ENDFUNC
|
|
|
|
// add a request for a misc asset
|
|
PROC ADD_MISC_ASSET_REQUEST(HOOD_MISC_ASSET_ENUM miscAsset)
|
|
bMiscAssetRequestTracker[miscAsset] = TRUE
|
|
|
|
SWITCH miscAsset
|
|
CASE H_MISC_ASSET_VAN_ANIMS
|
|
REQUEST_VEHICLE_ASSET(GET_MODEL_FOR_HOOD_MODEL_ENUM(HM_FRANKLIN_VAN))
|
|
BREAK
|
|
CASE H_MISC_ASSET_INJURED_CLIPSET
|
|
REQUEST_ANIM_SET(GET_INJURED_CLIPSET_NAME())
|
|
BREAK
|
|
CASE H_MISC_ASSET_FAKE_CELLPHONE
|
|
REQUEST_FAKE_CELLPHONE_MOVIE(fakeCellphoneData)
|
|
BREAK
|
|
CASE H_MISC_ASSET_GESTURES
|
|
REQUEST_CLIP_SET("ANIM_GROUP_GESTURE_MISS_FRA0")
|
|
BREAK
|
|
//CASE H_MISC_ASSET_CHOP_CAM_SFX
|
|
// REQUEST_CHOP_CAM_SFX()
|
|
//BREAK
|
|
ENDSWITCH
|
|
ENDPROC
|
|
|
|
// clear a misc asset slot
|
|
PROC CLEAR_MISC_ASSET_REQUEST(HOOD_MISC_ASSET_ENUM miscAsset)
|
|
IF bMiscAssetRequestTracker[miscAsset]
|
|
bMiscAssetRequestTracker[miscAsset] = FALSE
|
|
SWITCH miscAsset
|
|
CASE H_MISC_ASSET_VAN_ANIMS
|
|
REMOVE_VEHICLE_ASSET(GET_MODEL_FOR_HOOD_MODEL_ENUM(HM_FRANKLIN_VAN))
|
|
BREAK
|
|
CASE H_MISC_ASSET_INJURED_CLIPSET
|
|
REMOVE_ANIM_SET(GET_INJURED_CLIPSET_NAME())
|
|
BREAK
|
|
CASE H_MISC_ASSET_FAKE_CELLPHONE
|
|
RELEASE_FAKE_CELLPHONE_MOVIE(fakeCellphoneData)
|
|
BREAK
|
|
CASE H_MISC_ASSET_GESTURES
|
|
REMOVE_CLIP_SET("ANIM_GROUP_GESTURE_MISS_FRA0")
|
|
BREAK
|
|
//CASE H_MISC_ASSET_CHOP_CAM_SFX
|
|
// RELEASE_CHOP_CAM_SFX(chopViewCamData)
|
|
//BREAK
|
|
ENDSWITCH
|
|
ENDIF
|
|
ENDPROC
|
|
|
|
// have all requests for misc assets succeeded?
|
|
FUNC BOOL HAVE_ALL_MISC_ASSET_REQUESTS_SUCCEEDED()
|
|
INT i
|
|
|
|
// loop through and check for empty
|
|
REPEAT COUNT_OF(HOOD_MISC_ASSET_ENUM) i
|
|
IF bMiscAssetRequestTracker[i]
|
|
SWITCH INT_TO_ENUM(HOOD_MISC_ASSET_ENUM, i)
|
|
CASE H_MISC_ASSET_VAN_ANIMS
|
|
IF NOT HAS_VEHICLE_ASSET_LOADED(GET_MODEL_FOR_HOOD_MODEL_ENUM(HM_FRANKLIN_VAN))
|
|
RETURN FALSE
|
|
ENDIF
|
|
BREAK
|
|
CASE H_MISC_ASSET_INJURED_CLIPSET
|
|
IF NOT HAS_ANIM_SET_LOADED(GET_INJURED_CLIPSET_NAME())
|
|
RETURN FALSE
|
|
ENDIF
|
|
BREAK
|
|
CASE H_MISC_ASSET_FAKE_CELLPHONE
|
|
IF NOT HAS_FAKE_CELLPHONE_MOVIE_LOADED(fakeCellphoneData)
|
|
RETURN FALSE
|
|
ENDIF
|
|
BREAK
|
|
CASE H_MISC_ASSET_GESTURES
|
|
IF NOT HAS_CLIP_SET_LOADED("ANIM_GROUP_GESTURE_MISS_FRA0")
|
|
RETURN FALSE
|
|
ENDIF
|
|
BREAK
|
|
//CASE H_MISC_ASSET_CHOP_CAM_SFX
|
|
// IF NOT REQUEST_CHOP_CAM_SFX()
|
|
// RETURN FALSE
|
|
// ENDIF
|
|
//BREAK
|
|
ENDSWITCH
|
|
ENDIF
|
|
ENDREPEAT
|
|
|
|
RETURN TRUE
|
|
ENDFUNC
|
|
|
|
// get misc assets for particular stage
|
|
PROC REQUEST_MISC_ASSETS_FOR_STAGE(MISSION_STAGE_ENUM requestStage, BOOL bWaitForLoad, BOOL bKeepMiscAssetsForCurrentStage)
|
|
|
|
INT i
|
|
REPEAT COUNT_OF(HOOD_MISC_ASSET_ENUM) i
|
|
HOOD_MISC_ASSET_ENUM thisMiscAsset = INT_TO_ENUM(HOOD_MISC_ASSET_ENUM, i)
|
|
|
|
IF IS_MISC_ASSET_REQUIRED_FOR_MISSION_STAGE(thisMiscAsset, requestStage)
|
|
// if we need this asset, request it
|
|
ADD_MISC_ASSET_REQUEST(thisMiscAsset)
|
|
ELSE
|
|
// otherwise try and get rid of it
|
|
IF NOT IS_MISC_ASSET_REQUIRED_FOR_MISSION_STAGE(thisMiscAsset, currentMissionStage)
|
|
OR NOT bKeepMiscAssetsForCurrentStage
|
|
CLEAR_MISC_ASSET_REQUEST(thisMiscAsset)
|
|
ENDIF
|
|
ENDIF
|
|
ENDREPEAT
|
|
|
|
// if wait for load, don't quit out 'til all the recordings are in
|
|
IF bWaitForLoad
|
|
IF NOT HAVE_ALL_MISC_ASSET_REQUESTS_SUCCEEDED()
|
|
LOAD_ALL_OBJECTS_IF_SCREEN_FADED_OUT()
|
|
WHILE NOT HAVE_ALL_MISC_ASSET_REQUESTS_SUCCEEDED()
|
|
WAIT(0)
|
|
ENDWHILE
|
|
ENDIF
|
|
ENDIF
|
|
ENDPROC
|
|
|
|
// request the text for the mission
|
|
PROC REQUEST_TEXT(BOOL bWaitForLoad)
|
|
REQUEST_ADDITIONAL_TEXT("FCHASE", MISSION_TEXT_SLOT)
|
|
IF bWaitForLoad
|
|
WHILE NOT HAS_ADDITIONAL_TEXT_LOADED(MISSION_TEXT_SLOT)
|
|
WAIT(0)
|
|
ENDWHILE
|
|
ENDIF
|
|
ENDPROC
|
|
|
|
// reset foot chase values
|
|
PROC RESET_FOOT_CHASE_VALUES()
|
|
INT i
|
|
|
|
runnerStage = RUNNER_START_FLEE
|
|
chopStage = CHOP_START_CHASE
|
|
setpieceStage = SETPIECE_FREE_INTO_STATION
|
|
runnerChaseProperties.chaseState = CHASE_STATE_MOVING
|
|
runnerChaseProperties.chaseAnim = CHASE_ANIM_NONE
|
|
runnerChaseProperties.bWaiting = FALSE
|
|
REPEAT NUMBER_YARD_VEHICLES i
|
|
bStartedYardVehicle[i] = FALSE
|
|
ENDREPEAT
|
|
REPEAT NUMBER_TRAINS i
|
|
bStartedTrain[i] = FALSE
|
|
ENDREPEAT
|
|
REPEAT NUMBER_YARD_PEDS i
|
|
yardPed[i].state = YARD_PED_STATE_IDLE
|
|
ENDREPEAT
|
|
REPEAT COUNT_OF(FRANKLIN_WARP_ENUM) i
|
|
bFranklinWarp[i] = FALSE
|
|
ENDREPEAT
|
|
iChopBounceOnCarStage = 0
|
|
bStartedRunnerMovement = FALSE
|
|
bDoneDriverSwear = FALSE
|
|
bDoneDriverLookAtChop = FALSE
|
|
driverOutState = DRIVER_OUT_INACTIVE
|
|
ENDPROC
|
|
|
|
// set all common variables to what they should be when a new stage starts
|
|
PROC RESET_ALL_COMMON_VARIABLES()
|
|
streamingStage = MISSION_STREAMING_STAGE_REQUEST
|
|
sSelectorPeds.eNewSelectorPed = NUMBER_OF_SELECTOR_PEDS
|
|
cutsceneStage = H_CUT_STAGE_INIT
|
|
bRunningCutscene = FALSE
|
|
bSkippedCutscene = FALSE
|
|
bClearedForCutscene = FALSE
|
|
bCutsceneWaitStarted = FALSE
|
|
bShownGodText = FALSE
|
|
bShouldDoGetInText = FALSE
|
|
bDoneBanter = FALSE
|
|
bSavedBanter = FALSE
|
|
bCheckedKillBanter = FALSE
|
|
bDoneReturnSpeech = FALSE
|
|
//bKilledInVanConversationOnGetOut = FALSE
|
|
//bKilledVanConversationOnWanted = FALSE
|
|
bDoneLoseWantedSpeech = FALSE
|
|
bShownLoseWantedPrompt = FALSE
|
|
bRemovedBlipsForWanted = FALSE
|
|
bTriggeredLamarDamageReaction = FALSE
|
|
iNextRandomSpeechTime = -1
|
|
iNextCheckVanHealthTime = -1
|
|
ENDPROC
|
|
|
|
// get all variables in the correct state for this stage
|
|
PROC RESET_VARIABLES_FOR_STAGE(MISSION_STAGE_ENUM resetStage)
|
|
INT i
|
|
RESET_ALL_COMMON_VARIABLES()
|
|
|
|
SWITCH resetStage
|
|
CASE STAGE_GET_TO_BAD_GUY
|
|
createPostIntroStage = CREATE_POST_INTRO_STAGE_NOT_STARTED
|
|
createBadGuyStage = CREATE_BAD_GUY_STAGE_NOT_STARTED
|
|
createBlockingVehiclesStage = CREATE_BLOCKING_VEHICLES_STAGE_NOT_STARTED
|
|
chopIntoVanState = CHOP_INTO_VAN_STATE_NOT_STARTED
|
|
chopBehaviourSpeechState = CHOP_BEHAVIOUR_SPEECH_NOT_STARTED
|
|
bDoneWaitForLamarPrompt = FALSE
|
|
bDoneHurrySpeech = FALSE
|
|
bShownHurryPrompt = FALSE
|
|
bTurnedOffPhoneForWalk = FALSE
|
|
bKilledOnFootConversation = FALSE
|
|
bDoneGetLamarPrompt = FALSE
|
|
bDoneLamarIntoVan = FALSE
|
|
bDoneChopGetInSpeech = FALSE
|
|
bDoneArriveSpeech = FALSE
|
|
bDoneGotoSpeech = FALSE
|
|
bLamarWalkPaused = FALSE
|
|
bDoneChopBehaviourSpeech = FALSE
|
|
bDoneUphillSpeech = FALSE
|
|
bDoneCreepSpeech = FALSE
|
|
bDoneBadGuySpookedReact = FALSE
|
|
bKilledSpeechForArrive = FALSE
|
|
bFrozenVan = FALSE
|
|
bDoneLamarPullGunCue = FALSE
|
|
bDoneBikeSpeedOffCue = FALSE
|
|
bClearedPlayerRun = FALSE
|
|
bDoneFranklinIntoVanSpeech = FALSE
|
|
bShownFirstDownloadHelp = FALSE
|
|
bKilledSpeechForVan = FALSE
|
|
bLamarWaitingAtVan = FALSE
|
|
bFranklinWentAhead = FALSE
|
|
bLamarWasInGroup = FALSE
|
|
bDoneLamarWalkToVan = FALSE
|
|
bStoppedChopExcitement = FALSE
|
|
bWarpedVanToAlley = FALSE
|
|
bKilledSpeechAtCutscene = FALSE
|
|
bShutVanDoors = FALSE
|
|
bForcedIntoVan = FALSE
|
|
bHadFirstLineOfBanter = FALSE
|
|
bDoneHelloChopSpeech = FALSE
|
|
bDoneAreYouOKChopSpeech = FALSE
|
|
bWarpedLamarToVan = FALSE
|
|
iOpenVanDoorSoundStage = 0
|
|
fLamarSpeedCount = 0
|
|
fLamarJammedTime = 0
|
|
|
|
//REPEAT COUNT_OF(bDoneConversationAnim) i
|
|
// bDoneConversationAnim[i] = FALSE
|
|
//ENDREPEAT
|
|
iFailWantedTime = -1
|
|
iGetInTextStage = 0
|
|
iTriggerPostBanterSpeechTime = -1
|
|
fLamarWalkSpeed = MIN_LAMAR_SPEED
|
|
BREAK
|
|
|
|
CASE STAGE_VAN_CHASE
|
|
chaseSpeedStage = CHASE_SPEED_START
|
|
crashTriggerState = CRASH_TRIGGER_WAITING
|
|
uberTrailerState = UBER_TRAILER_NOT_CREATED
|
|
createYardStage = CREATE_YARD_STAGE_NOT_STARTED
|
|
fCarChaseSpeed = 1.0
|
|
fDesiredSpeed = 1.0
|
|
fNoSpeechTime = 0.0
|
|
iGetInTextStage = 2
|
|
iVanChaseSpeechStage = 0
|
|
iDontShootSpeechStage = 0
|
|
bUsingActionCam = FALSE
|
|
bTempLamarvan = FALSE
|
|
bKnockedOffBike = FALSE
|
|
bPedOffBikeAI = FALSE
|
|
bResetScriptRagdoll = FALSE
|
|
bForcedRunnerDismount = FALSE
|
|
bDoneWontCatchComplainSpeech = FALSE
|
|
bDoneWontCatchReplySpeech = FALSE
|
|
bDoneCrashReactionSpeech = FALSE
|
|
bKilledSpeechForCrashReaction = FALSE
|
|
bDoneGetChopSpeech = FALSE
|
|
bDoneReleaseChopSpeech = FALSE
|
|
bDoneBusSmash = FALSE
|
|
bDoneDownhillSpeech = FALSE
|
|
bDoneGoingLeftSpeech = FALSE
|
|
bDoneGoingDownAlleySpeech = FALSE
|
|
bDoneUseAbilitySpeech = FALSE
|
|
bShownSpecialAbilityHelp = FALSE
|
|
bKilledSpeechAtCutscene = FALSE
|
|
bRemovedGirl = FALSE
|
|
bSpeedUpBikeInAlley = FALSE
|
|
bPausedBlockingTraffic = FALSE
|
|
bPausedCrashBus = FALSE
|
|
bClearedPlayerRun = FALSE
|
|
bBlipAlley = FALSE
|
|
bSetWorkerDefault = FALSE
|
|
bDoneInVanCue = FALSE
|
|
bDoneGetOutCue = FALSE
|
|
bResetDirectEntryFlag = FALSE
|
|
bStoppedChopExcitement = FALSE
|
|
bSetBikeAsSmoking = FALSE
|
|
bClearedChopTask = FALSE
|
|
bAllowRunnerMovement = FALSE
|
|
bLamarShouldBeInGroup = FALSE
|
|
bDoneThisWillGetBumpySpeech = FALSE
|
|
bSetIssiNoCollision = FALSE
|
|
bDoneLaughAtFranklinSpeech = FALSE
|
|
bUsedAbility = FALSE
|
|
bDoneFocusOnBikeAudioScene = FALSE
|
|
iOpenVanDoorSoundStage = 0
|
|
iLaughAtFranklinTime = -1
|
|
//bRemoveAlleyBlip = FALSE
|
|
//bShownAlleyPrompt = FALSE
|
|
|
|
RESET_FOOT_CHASE_VALUES()
|
|
BREAK
|
|
|
|
CASE STAGE_FOOT_CHASE
|
|
ontoTrainShot = ONTO_TRAIN_JUMP
|
|
chopChaseProperties.chaseState = CHASE_STATE_MOVING
|
|
chopChaseProperties.chaseAnim = CHASE_ANIM_NONE
|
|
chopChaseProperties.bWaiting = FALSE
|
|
chopViewCamData.state = CHOP_VIEW_CAM_DISABLED
|
|
chopBehaviourSetpieceStage = CBS_NOT_STARTED
|
|
chopWaitState = CHOP_WAIT_STATE_NOT_STARTED
|
|
createTrainsStage = CREATE_TRAINS_STAGE_NOT_STARTED
|
|
chopBypassFenceState = CHOP_BYPASS_FENCE_NOT_STARTED
|
|
createCarsStage = CREATE_CARS_STAGE_NOT_STARTED
|
|
bDoneLamarEncourageSpeech = FALSE
|
|
bStartedChopMovement = FALSE
|
|
bDoneChaseScent = FALSE
|
|
//bForcedJumpOffRoof = FALSE
|
|
bClearedPlayerRun = FALSE
|
|
//bShownChopFenceHelp = FALSE
|
|
bCheckedContainerWait = FALSE
|
|
bDoneThroughFenceCut = FALSE
|
|
bBypassedFence = FALSE
|
|
bSmashedFence = FALSE
|
|
bDoRunAfterFence = FALSE
|
|
bFranklinShoutBeforeTrain = FALSE
|
|
//bPlayingChopWaitTurnAnim = FALSE
|
|
bDoneOnTrainCut = FALSE
|
|
bRepositionedFranklinForTrain = FALSE
|
|
bRemovedTraffic = FALSE
|
|
bRemovedBusStation = FALSE
|
|
bShownChopViewHelp = FALSE
|
|
bCancelledChopHint = FALSE
|
|
bDoneLoseReactSpeech = FALSE
|
|
bRemovedBike = FALSE
|
|
bDoneReactToRunStatSpeech = FALSE
|
|
bPreparedSmashFenceCue = FALSE
|
|
bDoneSmashFenceCue = FALSE
|
|
bDoneBypassFenceCue = FALSE
|
|
bDoneChopCamCue = FALSE
|
|
bDoneBreakFenceAudioScene = FALSE
|
|
bInterpedToGameCam = FALSE
|
|
bDoneJumpHelp = FALSE
|
|
bShownNoStaminaHelp = FALSE
|
|
bShownHoodSlideHelp = FALSE
|
|
bRemovedBuses = FALSE
|
|
bRemovedCarpark = FALSE
|
|
bFailForLost = FALSE
|
|
bResetBallaGetUp = FALSE
|
|
runHelpState = RUN_HELP_STATE_NOT_STARTED
|
|
iInitialStaminaValue = GET_SP_PLAYER_PED_STAT_VALUE(CHAR_FRANKLIN, PS_STAMINA)
|
|
|
|
REPEAT NUMBER_GRAB_SCENARIO_PEDS i
|
|
grabScenarioPed[i].ped = NULL
|
|
grabScenarioPed[i].state = GRAB_SCENARIO_PED_STATE_NOT_GRABBED
|
|
grabScenarioPed[i].bDoneSpeech = FALSE
|
|
ENDREPEAT
|
|
BREAK
|
|
|
|
CASE STAGE_FIND_BAD_GUY
|
|
chopViewCamData.state = CHOP_VIEW_CAM_DISABLED
|
|
chopBehaviourSetpieceStage = CBS_NOT_STARTED
|
|
chopHumpState = CHOP_HUMP_STATE_NOT_STARTED
|
|
chopSniffState = CHOP_SNIFF_STATE_NOT_STARTED
|
|
openTargetContainerState = OPEN_TARGET_CONTAINER_STATE_NOT_STARTED
|
|
ballaDiscoveredState = BALLA_DISCOVERED_STATE_NOT_STARTED
|
|
callChopBackState = CALL_CHOP_BACK_STATE_NOT_STARTED
|
|
bDoneChaseScent = FALSE
|
|
bShownChopBehaviourHelp = FALSE
|
|
bShownCallChopHelp = FALSE
|
|
bDoneGotoSpeech = FALSE
|
|
bGotToTrain = FALSE
|
|
bDoneChopGoToTrain = FALSE
|
|
bDoneWhereGoingSpeech = FALSE
|
|
bDoneNoChopSpeech = FALSE
|
|
bDoneThreatenChopSpeech = FALSE
|
|
bDoneGetBackOnSpeech = FALSE
|
|
bDoneCommentOnBehaviourSpeech = FALSE
|
|
bShouldCommentOnBehaviour = FALSE
|
|
bDoingChopPull = FALSE
|
|
bDoneGetClosePrompt = FALSE
|
|
bDoneGoAwaySpeech = FALSE
|
|
bDoneItsADudeSpeech = FALSE
|
|
bRepositionedBallaHiding = FALSE
|
|
bDoneChopSniffSFX = FALSE
|
|
bFoundBadGuy = FALSE
|
|
bDoneFoundBadGuySpeech = FALSE
|
|
bDoneChopChaseFoundBalla = FALSE
|
|
bDoneRunnerFallOver = FALSE
|
|
bAllowKidnapCutscene = FALSE
|
|
bDoneRunnerRelax = FALSE
|
|
bDoneChopTakeDown = FALSE
|
|
bClearedPlayerRun = FALSE
|
|
bDoneSecondFindSpeech = FALSE
|
|
//bShownFranklinSwitchPrompt = FALSE
|
|
bBlippedFirstBoxcars = FALSE
|
|
bBlippedSecondBoxcars = FALSE
|
|
bShownBoxcarPrompt = FALSE
|
|
bDoneBoxcarSpeech = FALSE
|
|
bDoneSearchBoxcarSpeech = FALSE
|
|
bDoneEmptyBoxcarSpeech = FALSE
|
|
bRestoredBoxcarGameplayCam = FALSE
|
|
bDoneDoorSlideSound = FALSE
|
|
bDoneDoorLimitSound = FALSE
|
|
bPreparedBaddyCue = FALSE
|
|
bDoneBaddyCue = FALSE
|
|
bDoneGotoCollieCue = FALSE
|
|
bDoneMountCue = FALSE
|
|
bDoneDismountCue = FALSE
|
|
bDoneBlipSecondBoxcarsCue = FALSE
|
|
bDoneFoundCue = FALSE
|
|
bCallChopBackSuccess = FALSE
|
|
bDoneDRunSpeech = FALSE
|
|
bDoneDFallSpeech = FALSE
|
|
bDoneGetHisAssSpeech = FALSE
|
|
bDoneCutsceneBlood = FALSE
|
|
bShownSwitchToOpenHelp = FALSE
|
|
bShownSwitchToCallHelp = FALSE
|
|
bOpenedAnyCarriage = FALSE
|
|
bResetOpenedAnyCarriage = FALSE
|
|
bShownQuickSwitchHelp = FALSE
|
|
bSetDamageOnBadGuy = FALSE
|
|
bWarpedToChaseEnd = FALSE
|
|
bDoneWhistleSound = FALSE
|
|
bDoneBoxcarCutsceneCam = FALSE
|
|
iScentWaypoint = 0
|
|
iChopBehaviourHelpTime = 0
|
|
iChopWaypointProgress = 0
|
|
iLeftBoxcarCam = 0
|
|
iRightBoxcarCam = 0
|
|
fChopOverride = 1.0
|
|
bStartedTrain[0] = TRUE
|
|
bStartedTrain[1] = TRUE
|
|
bStartedTrain[2] = TRUE
|
|
|
|
fChopThroughBoxcarSpeed = 0.1
|
|
|
|
#IF IS_DEBUG_BUILD
|
|
bDebugForceOpenBoxcar = FALSE
|
|
#ENDIF
|
|
BREAK
|
|
|
|
CASE STAGE_GET_TO_HOUSE
|
|
dropoffStage = DROPOFF_STAGE_NOT_STARTED
|
|
lamarPhoneState = LAMAR_PHONE_STATE_NOT_STARTED
|
|
franklinMaskRemoveState = FRANKLIN_MASK_REMOVE_STATE_NOT_STARTED
|
|
shapeTestState = SHAPE_TEST_STATE_NOT_STARTED
|
|
letOutShot = LET_OUT_PHONE
|
|
vRunnerAttachToVanPos = <<0,0,0>>
|
|
vRunnerAttachToVanRot = <<0,0,0>>
|
|
bDoneGotoSpeech = FALSE
|
|
bShownLetOutPrompt = FALSE
|
|
bInLoseWantedState = FALSE
|
|
bRemovedChaseSetpieces = FALSE
|
|
bPhoneForceApplied = FALSE
|
|
bChopTurnToIdle = FALSE
|
|
bChopResetInIdle = FALSE
|
|
bDoneGetOutSpeech = FALSE
|
|
bDoneLetOut = FALSE
|
|
// bKilledConversationOnLetOut = FALSE
|
|
bDoneThreatenResponseSpeech = FALSE
|
|
bDoneLamarShoutSpeech = FALSE
|
|
bDoneFranklinShoutSpeech = FALSE
|
|
//bBadGuyRun = FALSE
|
|
bRestoredBadGuyDamage = FALSE
|
|
bLamarOutOfVan = FALSE
|
|
bKilledTalkAboutMichaelSpeech = FALSE
|
|
bCleanedUpPhone = FALSE
|
|
bCleanedUpBalla = FALSE
|
|
bDoingDistantSiren = FALSE
|
|
bSetDamageOnBadGuy = FALSE
|
|
bStartedLetOutCutscene = FALSE
|
|
bShutLDoor = FALSE
|
|
bShutRDoor = FALSE
|
|
bStoppedVanAnim = FALSE
|
|
bBackBlocked = TRUE
|
|
bDoneTrainingSpeech = FALSE
|
|
bKilledPreloadSpeech = FALSE
|
|
bDonePoliceReport = FALSE
|
|
bBlockedCustoms = FALSE
|
|
iGetInTextStage = 2
|
|
fDisplayBadPositionTime = 0.0
|
|
BREAK
|
|
ENDSWITCH
|
|
ENDPROC
|
|
|
|
// return the correct character to start a particular stage on
|
|
FUNC enumCharacterList GET_CHARACTER_FOR_MISSION_STAGE(MISSION_STAGE_ENUM getStage)
|
|
getStage = getStage
|
|
RETURN CHAR_FRANKLIN
|
|
ENDFUNC
|
|
|
|
// create a player vehicle for the mission
|
|
PROC HOOD_CREATE_VEHICLE(HOOD_VEHICLE_ENUM hVehicle, VECTOR vCreatePos, FLOAT fCreateRot, BOOL bKeepModel = TRUE, BOOL bKeepVehicle = TRUE, BOOL bMakeInvincible = FALSE)
|
|
IF NOT IS_VEHICLE_DRIVEABLE(hoodVehicle[hVehicle])
|
|
HOOD_MODEL_ENUM vehicleModelEnum = GET_MODEL_ENUM_FOR_HOOD_VEHICLE(hVehicle)
|
|
|
|
IF hVehicle = HV_FRANKLIN_VAN
|
|
CREATE_NPC_VEHICLE(hoodVehicle[hVehicle], CHAR_LAMAR, vCreatePos, fCreateRot, FALSE)
|
|
ELSE
|
|
hoodVehicle[hVehicle] = CREATE_VEHICLE(GET_MODEL_FOR_HOOD_MODEL_ENUM(vehicleModelEnum), vCreatePos, fCreateRot)
|
|
ENDIF
|
|
|
|
SET_VEHICLE_ON_GROUND_PROPERLY(hoodVehicle[hVehicle])
|
|
|
|
IF NOT bKeepModel
|
|
CLEAR_MODEL_REQUEST(ENUM_TO_INT(vehicleModelEnum))
|
|
ENDIF
|
|
|
|
IF bMakeInvincible
|
|
SET_VEHICLE_CAN_BE_VISIBLY_DAMAGED(hoodVehicle[hVehicle], FALSE)
|
|
SET_VEHICLE_CAN_BREAK(hoodVehicle[hVehicle], FALSE)
|
|
SET_ENTITY_PROOFS(hoodVehicle[hVehicle], TRUE, TRUE, TRUE, TRUE, TRUE)
|
|
ENDIF
|
|
|
|
IF NOT bKeepVehicle
|
|
SET_VEHICLE_AS_NO_LONGER_NEEDED(hoodVehicle[hVehicle])
|
|
ENDIF
|
|
|
|
SET_VEHICLE_CAN_LEAK_OIL(hoodVehicle[hVehicle], FALSE)
|
|
SET_VEHICLE_CAN_LEAK_PETROL(hoodVehicle[hVehicle], FALSE)
|
|
SET_DISABLE_VEHICLE_PETROL_TANK_FIRES(hoodVehicle[hVehicle], TRUE)
|
|
|
|
SWITCH hVehicle
|
|
CASE HV_FRANKLIN_VAN
|
|
//SET_VEHICLE_COLOUR_COMBINATION(hoodVehicle[hVehicle], 1)
|
|
//SET_VEHICLE_DIRT_LEVEL(hoodVehicle[hVehicle], 10.0)
|
|
SET_VEHICLE_STRONG(hoodVehicle[hVehicle], TRUE)
|
|
//INT i
|
|
//FOR i=1 TO 8
|
|
// SET_VEHICLE_EXTRA(hoodVehicle[hVehicle], i, TRUE)
|
|
//ENDFOR
|
|
SET_VEHICLE_CAN_BREAK(hoodVehicle[hVehicle], FALSE)
|
|
SET_DOOR_ALLOWED_TO_BE_BROKEN_OFF(hoodVehicle[hVehicle], SC_DOOR_FRONT_LEFT, FALSE)
|
|
SET_DOOR_ALLOWED_TO_BE_BROKEN_OFF(hoodVehicle[hVehicle], SC_DOOR_FRONT_RIGHT, FALSE)
|
|
SET_DOOR_ALLOWED_TO_BE_BROKEN_OFF(hoodVehicle[hVehicle], SC_DOOR_REAR_LEFT, FALSE)
|
|
SET_DOOR_ALLOWED_TO_BE_BROKEN_OFF(hoodVehicle[hVehicle], SC_DOOR_REAR_RIGHT, FALSE)
|
|
|
|
SET_VEHICLE_HAS_STRONG_AXLES(hoodVehicle[hVehicle], TRUE)
|
|
SET_VEHICLE_TYRES_CAN_BURST(hoodVehicle[hVehicle], FALSE)
|
|
|
|
INFORM_MISSION_STATS_OF_DAMAGE_WATCH_ENTITY(hoodVehicle[hVehicle])
|
|
INFORM_MISSION_STATS_OF_SPEED_WATCH_ENTITY(hoodVehicle[hVehicle])
|
|
iCachedVanHealth = GET_ENTITY_HEALTH(hoodVehicle[hVehicle])
|
|
BREAK
|
|
CASE HV_BAD_GUY_BIKE
|
|
SET_VEHICLE_COLOUR_COMBINATION(hoodVehicle[hVehicle], 1)
|
|
SET_ENTITY_ONLY_DAMAGED_BY_PLAYER(hoodVehicle[hVehicle], TRUE)
|
|
SET_AUDIO_VEHICLE_PRIORITY(hoodVehicle[hVehicle], AUDIO_VEHICLE_PRIORITY_MAX)
|
|
BREAK
|
|
ENDSWITCH
|
|
ENDIF
|
|
ENDPROC
|
|
|
|
// setup player character with their correct variations
|
|
PROC SETUP_PLAYER_CHARACTER_WITH_MISSION_VARIATIONS(PED_INDEX ped, enumCharacterList createChar, MISSION_STAGE_ENUM setStage)
|
|
setStage = setStage // temp
|
|
|
|
IF NOT IS_PED_INJURED(ped)
|
|
SWITCH createChar
|
|
CASE CHAR_FRANKLIN
|
|
BREAK
|
|
CASE CHAR_TREVOR
|
|
BREAK
|
|
ENDSWITCH
|
|
ENDIF
|
|
ENDPROC
|
|
|
|
// create player character
|
|
PROC HOOD_CREATE_PLAYER_CHARACTER(enumCharacterList createChar, MISSION_STAGE_ENUM setStage, VECTOR vPos, FLOAT fRot, VEHICLE_INDEX veh = NULL, VEHICLE_SEAT seat = VS_DRIVER)
|
|
SELECTOR_SLOTS_ENUM selectorSlot = GET_SELECTOR_SLOT_FROM_PLAYER_PED_ENUM(createChar)
|
|
|
|
IF NOT DOES_ENTITY_EXIST(sSelectorPeds.pedID[selectorSlot])
|
|
IF NOT IS_ENTITY_DEAD(veh)
|
|
// create in vehicle
|
|
WHILE NOT(CREATE_PLAYER_PED_INSIDE_VEHICLE(sSelectorPeds.pedID[selectorSlot], createChar, veh, seat, FALSE))
|
|
WAIT(0)
|
|
ENDWHILE
|
|
ELSE
|
|
// create on foot
|
|
WHILE NOT(CREATE_PLAYER_PED_ON_FOOT(sSelectorPeds.pedID[selectorSlot], createChar, vPos, fRot, FALSE))
|
|
WAIT(0)
|
|
ENDWHILE
|
|
ENDIF
|
|
|
|
SWITCH createChar
|
|
CASE CHAR_TREVOR
|
|
BREAK
|
|
CASE CHAR_FRANKLIN
|
|
BREAK
|
|
ENDSWITCH
|
|
|
|
SETUP_PLAYER_CHARACTER_WITH_MISSION_VARIATIONS(sSelectorPeds.pedID[selectorSlot], createChar, setStage)
|
|
SET_PED_RELATIONSHIP_GROUP_HASH(sSelectorPeds.pedID[selectorSlot], RELGROUPHASH_PLAYER)
|
|
SET_BLOCKING_OF_NON_TEMPORARY_EVENTS(sSelectorPeds.pedID[selectorSlot], TRUE)
|
|
ENDIF
|
|
ENDPROC
|
|
|
|
// set player in vehicle if not already in
|
|
PROC SET_PLAYER_PED_INTO_HOOD_VEHICLE(HOOD_VEHICLE_ENUM hVehicle, VEHICLE_SEAT seat, BOOL bKeepVehicle = TRUE)
|
|
IF NOT IS_PED_INJURED(PLAYER_PED_ID())
|
|
IF IS_VEHICLE_DRIVEABLE(hoodVehicle[hVehicle])
|
|
IF NOT IS_PED_IN_VEHICLE(PLAYER_PED_ID(), hoodVehicle[hVehicle])
|
|
SET_PED_INTO_VEHICLE(PLAYER_PED_ID(), hoodVehicle[hVehicle], seat)
|
|
IF NOT bKeepVehicle
|
|
SET_VEHICLE_AS_NO_LONGER_NEEDED(hoodVehicle[hVehicle])
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDPROC
|
|
|
|
// create the player characters, and transport if appropriate, for a mission stage
|
|
PROC CREATE_PLAYER_CHARACTERS_WITH_TRANSPORT_IN_MISSION_STAGE(MISSION_STAGE_ENUM setStage)
|
|
// create transport
|
|
SWITCH setStage
|
|
CASE STAGE_GET_TO_BAD_GUY
|
|
//HOOD_CREATE_VEHICLE(HV_FRANKLIN_VAN, GET_HOOD_VECTOR(HVEC_FRANKLIN_VAN_INIT), FRANKLIN_VAN_INIT_ROT)
|
|
BREAK
|
|
CASE STAGE_VAN_CHASE
|
|
HOOD_CREATE_VEHICLE(HV_FRANKLIN_VAN, GET_HOOD_VECTOR(HVEC_VAN_CHASE_INIT), VAN_CHASE_INIT_ROT)
|
|
BREAK
|
|
CASE STAGE_FOOT_CHASE
|
|
HOOD_CREATE_VEHICLE(HV_FRANKLIN_VAN, GET_HOOD_VECTOR(HVEC_VAN_IN_ALLEY), CAR_IN_ALLEY_ROT)
|
|
BREAK
|
|
CASE STAGE_FIND_BAD_GUY
|
|
HOOD_CREATE_VEHICLE(HV_FRANKLIN_VAN, GET_HOOD_VECTOR(HVEC_VAN_HIDDEN), VAN_HIDDEN_ROT)
|
|
BREAK
|
|
CASE STAGE_GET_TO_HOUSE
|
|
IF NOT bForcePassOnShitskip
|
|
HOOD_CREATE_VEHICLE(HV_FRANKLIN_VAN, GET_HOOD_VECTOR(HVEC_DRIVE_INIT), DRIVE_INIT_ROT)
|
|
ELSE
|
|
HOOD_CREATE_VEHICLE(HV_FRANKLIN_VAN, GET_HOOD_VECTOR(HVEC_REC), 143.1)
|
|
ENDIF
|
|
BREAK
|
|
ENDSWITCH
|
|
|
|
IF setStage >= STAGE_VAN_CHASE
|
|
AND setStage < STAGE_GET_TO_HOUSE
|
|
//SET_VEHICLE_RADIO_ENABLED(hoodVehicle[HV_FRANKLIN_VAN], FALSE)
|
|
ENDIF
|
|
|
|
// create the player characters
|
|
SWITCH setStage
|
|
CASE STAGE_GET_TO_BAD_GUY
|
|
BREAK
|
|
CASE STAGE_VAN_CHASE
|
|
IF NOT IS_PED_INJURED(PLAYER_PED_ID())
|
|
SET_ENTITY_COORDS(PLAYER_PED_ID(), GET_HOOD_VECTOR(HVEC_FRANKLIN_ALLEY_INIT))
|
|
SET_ENTITY_HEADING(PLAYER_PED_ID(), FRANKLIN_ALLEY_INIT_ROT)
|
|
ENDIF
|
|
BREAK
|
|
CASE STAGE_FOOT_CHASE
|
|
IF NOT IS_PED_INJURED(PLAYER_PED_ID())
|
|
SET_ENTITY_COORDS(PLAYER_PED_ID(), GET_HOOD_VECTOR(HVEC_FOOT_CHASE_INIT))
|
|
SET_ENTITY_HEADING(PLAYER_PED_ID(), FOOT_CHASE_INIT_ROT)
|
|
ENDIF
|
|
BREAK
|
|
CASE STAGE_FIND_BAD_GUY
|
|
IF NOT IS_PED_INJURED(PLAYER_PED_ID())
|
|
SET_ENTITY_COORDS(PLAYER_PED_ID(), GET_HOOD_VECTOR(HVEC_LOSE_RUNNER))
|
|
SET_ENTITY_HEADING(PLAYER_PED_ID(), LOSE_RUNNER_ROT)
|
|
ENDIF
|
|
BREAK
|
|
CASE STAGE_GET_TO_HOUSE
|
|
IF NOT IS_PED_INJURED(PLAYER_PED_ID())
|
|
SET_PED_INTO_VEHICLE(PLAYER_PED_ID(), hoodVehicle[HV_FRANKLIN_VAN], VS_DRIVER)
|
|
ENDIF
|
|
BREAK
|
|
ENDSWITCH
|
|
ENDPROC
|
|
|
|
// lamar sprint to van
|
|
PROC SET_LAMAR_SPRINT_TO_VAN(BOOL bReposition = FALSE)
|
|
IF NOT IS_PED_INJURED(lamarPed)
|
|
IF bReposition
|
|
SET_ENTITY_COORDS(lamarPed, GET_HOOD_VECTOR(HVEC_LAMAR_ALLEY_INIT))
|
|
SET_ENTITY_HEADING(lamarPed, LAMAR_ALLEY_INIT_ROT)
|
|
CLEAR_PED_TASKS_IMMEDIATELY(lamarPed)
|
|
ENDIF
|
|
|
|
TASK_GO_STRAIGHT_TO_COORD(lamarPed, GET_HOOD_VECTOR(HVEC_LAMAR_SPRINT_TO_VAN), PEDMOVE_SPRINT)
|
|
FORCE_PED_MOTION_STATE(lamarPed, MS_ON_FOOT_SPRINT, bReposition, FAUS_CUTSCENE_EXIT)
|
|
SET_PED_MIN_MOVE_BLEND_RATIO(lamarPed, PEDMOVE_SPRINT)
|
|
ENDIF
|
|
ENDPROC
|
|
|
|
// create lamar
|
|
PROC CREATE_LAMAR_FOR_STAGE(MISSION_STAGE_ENUM createStage, BOOL bWaitForStreaming = TRUE)
|
|
IF NOT DOES_ENTITY_EXIST(lamarPed)
|
|
printstring("creating new lamar ped!") printnl()
|
|
|
|
SWITCH createStage
|
|
CASE STAGE_GET_TO_BAD_GUY
|
|
CREATE_NPC_PED_ON_FOOT(lamarPed, CHAR_LAMAR, GET_HOOD_VECTOR(HVEC_LAMAR_WALK_INIT), LAMAR_WALK_INIT_ROT, FALSE)
|
|
BREAK
|
|
CASE STAGE_VAN_CHASE
|
|
IF IS_VEHICLE_DRIVEABLE(hoodVehicle[HV_FRANKLIN_VAN])
|
|
CREATE_NPC_PED_ON_FOOT(lamarPed, CHAR_LAMAR, GET_HOOD_VECTOR(HVEC_LAMAR_ALLEY_INIT), LAMAR_ALLEY_INIT_ROT, FALSE)
|
|
SET_LAMAR_SPRINT_TO_VAN()
|
|
ENDIF
|
|
BREAK
|
|
DEFAULT
|
|
IF IS_VEHICLE_DRIVEABLE(hoodVehicle[HV_FRANKLIN_VAN])
|
|
VEHICLE_SEAT seat
|
|
IF createStage < STAGE_GET_TO_HOUSE
|
|
seat = VS_DRIVER
|
|
ELSE
|
|
seat = VS_FRONT_RIGHT
|
|
ENDIF
|
|
CREATE_NPC_PED_INSIDE_VEHICLE(lamarPed, CHAR_LAMAR, hoodVehicle[HV_FRANKLIN_VAN], seat, FALSE)
|
|
ENDIF
|
|
BREAK
|
|
ENDSWITCH
|
|
|
|
IF NOT IS_PED_INJURED(lamarPed)
|
|
// UPDATE CS VARS IF UPDATING
|
|
SET_PED_COMPONENT_VARIATION(lamarPed, PED_COMP_HEAD, 0, 0)
|
|
SET_PED_COMPONENT_VARIATION(lamarPed, PED_COMP_BERD, 1, 0)
|
|
SET_PED_COMPONENT_VARIATION(lamarPed, PED_COMP_HAIR, 2, 0)
|
|
SET_PED_COMPONENT_VARIATION(lamarPed, PED_COMP_TORSO, 2, 1)
|
|
SET_PED_COMPONENT_VARIATION(lamarPed, PED_COMP_LEG, 4, 0)
|
|
SET_PED_COMPONENT_VARIATION(lamarPed, PED_COMP_HAND, 0, 0)
|
|
SET_PED_COMPONENT_VARIATION(lamarPed, PED_COMP_SPECIAL, 0, 0)
|
|
SET_PED_COMPONENT_VARIATION(lamarPed, PED_COMP_SPECIAL2, 0, 0)
|
|
SET_PED_COMPONENT_VARIATION(lamarPed, PED_COMP_FEET, 1, 0)
|
|
ENDIF
|
|
|
|
IF bWaitForStreaming
|
|
LOAD_ALL_OBJECTS_IF_SCREEN_FADED_OUT()
|
|
|
|
BOOL bLamarStreamingCompleted = FALSE
|
|
WHILE NOT bLamarStreamingCompleted
|
|
IF NOT IS_PED_INJURED(lamarPed)
|
|
IF HAVE_ALL_STREAMING_REQUESTS_COMPLETED(lamarPed)
|
|
bLamarStreamingCompleted = TRUE
|
|
ENDIF
|
|
ELSE
|
|
bLamarStreamingCompleted = TRUE
|
|
ENDIF
|
|
WAIT(0)
|
|
ENDWHILE
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF NOT IS_PED_INJURED(lamarPed)
|
|
// temp
|
|
//IF createStage = STAGE_GET_TO_BAD_GUY
|
|
// SET_ENTITY_COORDS(lamarPed, <<-22.04, -1453.26, 29.64>>)
|
|
// SET_ENTITY_HEADING(lamarPed, 94.5)
|
|
//ENDIF
|
|
|
|
SET_PED_GROUP_MEMBER_PASSENGER_INDEX(lamarPed, VS_FRONT_RIGHT)
|
|
|
|
SET_PED_RELATIONSHIP_GROUP_HASH(lamarPed, RELGROUPHASH_PLAYER)
|
|
SET_PED_CAN_BE_TARGETTED(lamarPed, FALSE)
|
|
SET_BLOCKING_OF_NON_TEMPORARY_EVENTS(lamarPed, TRUE)
|
|
SET_ENTITY_ONLY_DAMAGED_BY_PLAYER(lamarPed, TRUE)
|
|
//SET_PED_CAN_FLY_THROUGH_WINDSCREEN(lamarPed, FALSE)
|
|
SET_PED_GET_OUT_UPSIDE_DOWN_VEHICLE(lamarPed, FALSE)
|
|
SET_PED_CONFIG_FLAG(lamarPed, PCF_WillFlyThroughWindscreen, FALSE)
|
|
SET_PED_CONFIG_FLAG(lamarPed, PCF_DontAllowToBeDraggedOutOfVehicle, TRUE)
|
|
SET_PED_CONFIG_FLAG(lamarPed, PCF_RunFromFiresAndExplosions, FALSE)
|
|
SET_PED_CONFIG_FLAG(lamarPed, PCF_ForcedToUseSpecificGroupSeatIndex, TRUE)
|
|
SET_PED_CONFIG_FLAG(lamarPed, PCF_LawWillOnlyAttackIfPlayerIsWanted, TRUE)
|
|
SET_PED_CONFIG_FLAG(lamarPed, PCF_OnlyAttackLawIfPlayerIsWanted, TRUE)
|
|
|
|
SET_PED_KEEP_TASK(lamarPed, TRUE)
|
|
SET_PED_DIES_WHEN_INJURED(lamarPed, TRUE)
|
|
GIVE_WEAPON_TO_PED(lamarPed, GET_HOOD_WEAPON_TYPE(H_WEAPON_PISTOL), INFINITE_AMMO, FALSE, FALSE)
|
|
ADD_PED_FOR_DIALOGUE(hoodConversation, 3, lamarPed, "LAMAR")
|
|
ENDIF
|
|
ENDPROC
|
|
|
|
// lamar follow pavement
|
|
PROC DO_LAMAR_FOLLOW_PAVEMENT()
|
|
INT iClosestLamarWaypoint
|
|
WAYPOINT_RECORDING_GET_CLOSEST_WAYPOINT("hood6", GET_ENTITY_COORDS(lamarPed), iClosestLamarWaypoint)
|
|
IF iClosestLamarWaypoint < 2
|
|
iClosestLamarWaypoint = 2
|
|
ENDIF
|
|
//IF iClosestLamarWaypoint < 33
|
|
TASK_FOLLOW_WAYPOINT_RECORDING(lamarPed, "hood6", iClosestLamarWaypoint+1, EWAYPOINT_NAVMESH_BACK_TO_WAYPOINT_IF_LEFT_ROUTE | EWAYPOINT_TURN_TO_FACE_WAYPOINT_HEADING_AT_END | EWAYPOINT_USE_TIGHTER_TURN_SETTINGS)
|
|
//ENDIF
|
|
ENDPROC
|
|
|
|
// create chop
|
|
PROC CREATE_CHOP_FOR_STAGE(MISSION_STAGE_ENUM createStage, BOOL bWaitForStreaming = TRUE)
|
|
//BOOL bJustCreated = FALSE
|
|
|
|
IF NOT DOES_ENTITY_EXIST(chopPed)
|
|
VECTOR vPos = <<0,0,0>>
|
|
FLOAT fRot = 0.0
|
|
|
|
SWITCH createStage
|
|
CASE STAGE_GET_TO_BAD_GUY
|
|
vPos = GET_HOOD_VECTOR(HVEC_CHOP_WALK_INIT)
|
|
fRot = CHOP_WALK_INIT_ROT
|
|
BREAK
|
|
CASE STAGE_FOOT_CHASE
|
|
vPos = GET_HOOD_VECTOR(HVEC_CHOP_CHASE_INIT)
|
|
fRot = CHOP_CHASE_INIT_ROT
|
|
BREAK
|
|
CASE STAGE_FIND_BAD_GUY
|
|
vPos = GET_HOOD_VECTOR(HVEC_CHOP_FIND_INIT)
|
|
fRot = CHOP_FIND_INIT_ROT
|
|
BREAK
|
|
ENDSWITCH
|
|
|
|
CREATE_CHOP(chopPed, vPos, fRot, FALSE)
|
|
bAddedChopToMixGroup = FALSE
|
|
// bJustCreated = TRUE
|
|
ENDIF
|
|
|
|
IF NOT IS_PED_INJURED(chopPed)
|
|
SET_BLOCKING_OF_NON_TEMPORARY_EVENTS(chopPed, TRUE)
|
|
SET_PED_KEEP_TASK(chopPed, TRUE)
|
|
SET_PED_DIES_WHEN_INJURED(chopPed, TRUE)
|
|
SET_PED_CAN_BE_TARGETTED(chopPed, FALSE)
|
|
SET_ENTITY_ONLY_DAMAGED_BY_PLAYER(chopPed, TRUE)
|
|
SET_PED_RELATIONSHIP_GROUP_HASH(chopPed, RELGROUPHASH_PLAYER)
|
|
ADD_PED_FOR_DIALOGUE(hoodConversation, 5, chopPed, "CHOP")
|
|
SET_PED_COMPONENT_VARIATION(chopPed, PED_COMP_TORSO, 0, iCurrentChopCollar)
|
|
sSelectorPeds.pedID[SELECTOR_PED_MICHAEL] = chopPed
|
|
chopViewCamData.chopPed = chopPed
|
|
|
|
IF bWaitForStreaming
|
|
LOAD_ALL_OBJECTS_IF_SCREEN_FADED_OUT()
|
|
|
|
BOOL bChopStreamingCompleted = FALSE
|
|
WHILE NOT bChopStreamingCompleted
|
|
IF NOT IS_PED_INJURED(chopPed)
|
|
IF HAVE_ALL_STREAMING_REQUESTS_COMPLETED(chopPed)
|
|
bChopStreamingCompleted = TRUE
|
|
ENDIF
|
|
ELSE
|
|
bChopStreamingCompleted = TRUE
|
|
ENDIF
|
|
WAIT(0)
|
|
ENDWHILE
|
|
ENDIF
|
|
|
|
IF NOT IS_PED_INJURED(chopPed)
|
|
SWITCH createStage
|
|
CASE STAGE_GET_TO_BAD_GUY
|
|
STOP_PED_SPEAKING(chopPed, TRUE)
|
|
SET_ENTITY_PROOFS(chopPed, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, TRUE)
|
|
//IF NOT bJustCreated
|
|
/// SET_ENTITY_COORDS(chopPed, GET_HOOD_VECTOR(HVEC_CHOP_WALK_INIT))
|
|
// SET_ENTITY_HEADING(chopPed, CHOP_WALK_INIT_ROT)
|
|
//ENDIF
|
|
//TASK_GO_STRAIGHT_TO_COORD(chopPed, <<-25.52, -1453.39, 29.77>>, 2.8, DEFAULT_TIME_NEVER_WARP)
|
|
BREAK
|
|
CASE STAGE_VAN_CHASE
|
|
SET_CHOP_INTO_VAN(chopPed, hoodVehicle[HV_FRANKLIN_VAN], chopLeanInVanState, fCachedVanSpeed, FALSE)
|
|
SET_ENTITY_PROOFS(chopPed, FALSE, TRUE, TRUE, FALSE, FALSE, FALSE, FALSE, TRUE)
|
|
SET_PED_CAN_RAGDOLL(chopPed, FALSE)
|
|
BREAK
|
|
CASE STAGE_GET_TO_HOUSE
|
|
SET_CHOP_INTO_VAN(chopPed, hoodVehicle[HV_FRANKLIN_VAN], chopLeanInVanState, fCachedVanSpeed, TRUE)
|
|
SET_ENTITY_PROOFS(chopPed, FALSE, TRUE, TRUE, FALSE, FALSE, FALSE, FALSE, TRUE)
|
|
SET_PED_CAN_RAGDOLL(chopPed, FALSE)
|
|
BREAK
|
|
DEFAULT
|
|
SET_ENTITY_PROOFS(chopPed, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, TRUE)
|
|
BREAK
|
|
ENDSWITCH
|
|
ENDIF
|
|
ENDIF
|
|
ENDPROC
|
|
|
|
PROC HANDLE_GRAB_SCENARIO_PEDS()
|
|
INT i
|
|
|
|
REPEAT NUMBER_GRAB_SCENARIO_PEDS i
|
|
SWITCH grabScenarioPed[i].state
|
|
CASE GRAB_SCENARIO_PED_STATE_NOT_GRABBED
|
|
IF GET_GAME_TIMER() >= grabScenarioPed[i].iUpdateTime
|
|
VECTOR vGrabPos
|
|
SWITCH i
|
|
CASE 0
|
|
vGrabPos = <<505.19144, -498.64182, 23.79694>>
|
|
BREAK
|
|
CASE 1
|
|
vGrabPos = <<505.66849, -499.35410, 23.86925>>
|
|
BREAK
|
|
CASE 2
|
|
vGrabPos = <<508.44058, -499.53983, 23.84134>>
|
|
BREAK
|
|
CASE 3
|
|
vGrabPos = <<508.14767, -508.43143, 23.88753>>
|
|
BREAK
|
|
CASE 4
|
|
vGrabPos = <<507.51636, -509.31439, 23.89202>>
|
|
BREAK
|
|
CASE 5
|
|
vGrabPos = <<508.47632, -509.69901, 23.83075>>
|
|
BREAK
|
|
CASE 6
|
|
vGrabPos = <<492.78287, -506.41846, 23.79152>>
|
|
BREAK
|
|
ENDSWITCH
|
|
|
|
SET_SCENARIO_PEDS_TO_BE_RETURNED_BY_NEXT_COMMAND(TRUE)
|
|
GET_CLOSEST_PED(vGrabPos, 1, TRUE, FALSE, grabScenarioPed[i].ped)
|
|
|
|
IF NOT IS_PED_INJURED(grabScenarioPed[i].ped)
|
|
grabScenarioPed[i].state = GRAB_SCENARIO_PED_STATE_GRABBED
|
|
grabScenarioPed[i].iUpdateTime = GET_GAME_TIMER() + GET_RANDOM_INT_IN_RANGE(0, 2000)
|
|
ELSE
|
|
grabScenarioPed[i].iUpdateTime = GET_GAME_TIMER() + GET_RANDOM_INT_IN_RANGE(500, 1500)
|
|
ENDIF
|
|
ENDIF
|
|
BREAK
|
|
|
|
CASE GRAB_SCENARIO_PED_STATE_GRABBED
|
|
IF GET_GAME_TIMER() >= grabScenarioPed[i].iUpdateTime
|
|
IF NOT IS_PED_INJURED(grabScenarioPed[i].ped)
|
|
AND NOT IS_PED_INJURED(runnerChaseProperties.ped)
|
|
AND NOT IS_PED_INJURED(chopPed)
|
|
PED_INDEX targetPedLookAt
|
|
|
|
FLOAT fDistanceToPlayer
|
|
fDistanceToPlayer = GET_DISTANCE_BETWEEN_COORDS(GET_ENTITY_COORDS(PLAYER_PED_ID()), GET_ENTITY_COORDS(grabScenarioPed[i].ped))
|
|
FLOAT fDistanceToBalla
|
|
fDistanceToBalla = GET_DISTANCE_BETWEEN_COORDS(GET_ENTITY_COORDS(runnerChaseProperties.ped), GET_ENTITY_COORDS(grabScenarioPed[i].ped))
|
|
FLOAT fDistanceToChop
|
|
fDistanceToChop = GET_DISTANCE_BETWEEN_COORDS(GET_ENTITY_COORDS(chopPed), GET_ENTITY_COORDS(grabScenarioPed[i].ped))
|
|
|
|
IF fDistanceToPlayer < fDistanceToChop
|
|
IF fDistanceToPlayer < fDistanceToBalla
|
|
targetPedLookAt = PLAYER_PED_ID()
|
|
ELSE
|
|
targetPedLookAt = runnerChaseProperties.ped
|
|
ENDIF
|
|
ELSE
|
|
IF fDistanceToBalla < fDistanceToChop
|
|
targetPedLookAt = runnerChaseProperties.ped
|
|
ELSE
|
|
targetPedLookAt = chopPed
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF NOT IS_PED_HEADTRACKING_ENTITY(grabScenarioPed[i].ped, targetPedLookAt)
|
|
TASK_LOOK_AT_ENTITY(grabScenarioPed[i].ped, targetPedLookAt, -1, SLF_WHILE_NOT_IN_FOV, SLF_LOOKAT_VERY_HIGH)
|
|
ENDIF
|
|
|
|
IF NOT grabScenarioPed[i].bDoneSpeech
|
|
IF IS_ENTITY_AT_ENTITY(grabScenarioPed[i].ped, chopPed, <<6,6,6>>, FALSE)
|
|
IF NOT IS_ANY_CONVERSATION_ONGOING_OR_QUEUED()
|
|
PLAY_PED_AMBIENT_SPEECH(grabScenarioPed[i].ped, "GENERIC_SHOCKED_MED", SPEECH_PARAMS_FORCE_SHOUTED)
|
|
grabScenarioPed[i].bDoneSpeech = TRUE
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
|
|
grabScenarioPed[i].iUpdateTime = GET_GAME_TIMER() + GET_RANDOM_INT_IN_RANGE(500, 2000)
|
|
ENDIF
|
|
ENDIF
|
|
BREAK
|
|
ENDSWITCH
|
|
ENDREPEAT
|
|
ENDPROC
|
|
|
|
// do damage from Chop takedown on bad guy
|
|
PROC SET_DAMAGE_ON_BAD_GUY(BOOL bForce = FALSE)
|
|
IF bForce
|
|
OR NOT bSetDamageOnBadGuy
|
|
IF NOT IS_PED_INJURED(runnerChaseProperties.ped)
|
|
APPLY_PED_BLOOD_SPECIFIC(runnerChaseProperties.ped, ENUM_TO_INT(PDZ_LEFT_ARM), 0.536, 0.601, 93.240, 0.695, -1, 0, "stab")
|
|
APPLY_PED_BLOOD_SPECIFIC(runnerChaseProperties.ped, ENUM_TO_INT(PDZ_LEFT_ARM), 0.536, 0.561, 95.040, 0.695, -1, 0, "stab")
|
|
APPLY_PED_BLOOD_SPECIFIC(runnerChaseProperties.ped, ENUM_TO_INT(PDZ_LEFT_ARM), 0.476, 0.531, 95.140, 0.695, -1, 0, "stab")
|
|
bSetDamageOnBadGuy = TRUE
|
|
ENDIF
|
|
ENDIF
|
|
ENDPROC
|
|
|
|
// create runner
|
|
PROC CREATE_BAD_GUY_FOR_STAGE(MISSION_STAGE_ENUM createStage)
|
|
VECTOR vPos
|
|
FLOAT fRot
|
|
|
|
SWITCH createStage
|
|
CASE STAGE_GET_TO_BAD_GUY
|
|
CASE STAGE_VAN_CHASE
|
|
CASE STAGE_GET_TO_HOUSE
|
|
vPos = <<0,10,0>>
|
|
fRot = 0.0
|
|
BREAK
|
|
CASE STAGE_FOOT_CHASE
|
|
vPos = GET_HOOD_VECTOR(HVEC_RUNNER_CHASE_INIT)
|
|
fRot = RUNNER_CHASE_INIT_ROT
|
|
BREAK
|
|
CASE STAGE_FIND_BAD_GUY
|
|
vPos = GET_HOOD_VECTOR(HVEC_RUNNER_HIDE)
|
|
fRot = RUNNER_HIDE_ROT
|
|
BREAK
|
|
ENDSWITCH
|
|
|
|
runnerChaseProperties.ped = CREATE_PED(PEDTYPE_MISSION, GET_MODEL_FOR_HOOD_MODEL_ENUM(HM_BAD_GUY), vPos, fRot)
|
|
IF createStage <= STAGE_GET_TO_HOUSE
|
|
//SET_PED_CAN_BE_TARGETTED(runnerChaseProperties.ped, FALSE)
|
|
SET_ENTITY_PROOFS(runnerChaseProperties.ped, FALSE, FALSE, FALSE, TRUE, TRUE)
|
|
ENDIF
|
|
|
|
SET_BLOCKING_OF_NON_TEMPORARY_EVENTS(runnerChaseProperties.ped, TRUE)
|
|
SET_PED_DIES_WHEN_INJURED(runnerChaseProperties.ped, TRUE)
|
|
SET_ENTITY_ONLY_DAMAGED_BY_PLAYER(runnerChaseProperties.ped, TRUE)
|
|
SET_PED_KEEP_TASK(runnerChaseProperties.ped, TRUE)
|
|
SET_PED_GET_OUT_UPSIDE_DOWN_VEHICLE(runnerChaseProperties.ped, FALSE)
|
|
//SET_PED_LOD_MULTIPLIER(runnerChaseProperties.ped, 10.0)
|
|
|
|
SET_PED_CAN_BE_KNOCKED_OFF_VEHICLE(runnerChaseProperties.ped, KNOCKOFFVEHICLE_NEVER)
|
|
|
|
CLEAR_ALL_PED_PROPS(runnerChaseProperties.ped)
|
|
SET_PED_PROP_INDEX(runnerChaseProperties.ped, ANCHOR_HEAD, 0, 0)
|
|
|
|
SET_PED_COMPONENT_VARIATION(runnerChaseProperties.ped, PED_COMP_TORSO, 0, 0)
|
|
SET_PED_COMPONENT_VARIATION(runnerChaseProperties.ped, PED_COMP_LEG, 0, 0)
|
|
SET_PED_COMPONENT_VARIATION(runnerChaseProperties.ped, PED_COMP_DECL, 0, 0)
|
|
|
|
SET_PED_CONFIG_FLAG(runnerChaseProperties.ped, PCF_DisableExplosionReactions, TRUE)
|
|
SET_PED_CONFIG_FLAG(runnerChaseProperties.ped, PCF_RunFromFiresAndExplosions, FALSE)
|
|
SET_PED_CONFIG_FLAG(runnerChaseProperties.ped, PCF_DontAllowToBeDraggedOutOfVehicle, TRUE)
|
|
//SET_PED_CAN_RAGDOLL(runnerChaseProperties.ped, FALSE) // TEMP
|
|
|
|
ADD_PED_FOR_DIALOGUE(hoodConversation, 4, runnerChaseProperties.ped, "BALLASOG")
|
|
|
|
IF createStage <= STAGE_FOOT_CHASE
|
|
HOOD_CREATE_VEHICLE(HV_BAD_GUY_BIKE, <<0,2,4>>, 0.0)
|
|
IF createStage < STAGE_FOOT_CHASE
|
|
SET_PED_INTO_VEHICLE(runnerChaseProperties.ped, hoodVehicle[HV_BAD_GUY_BIKE])
|
|
SET_ENTITY_PROOFS(hoodVehicle[HV_BAD_GUY_BIKE], FALSE, FALSE, FALSE, TRUE, TRUE)
|
|
SET_DISABLE_VEHICLE_PETROL_TANK_FIRES(hoodVehicle[HV_BAD_GUY_BIKE], TRUE)
|
|
SET_VEHICLE_CAN_LEAK_OIL(hoodVehicle[HV_BAD_GUY_BIKE], FALSE)
|
|
SET_VEHICLE_CAN_LEAK_PETROL(hoodVehicle[HV_BAD_GUY_BIKE], FALSE)
|
|
ENDIF
|
|
SET_VEHICLE_IS_CONSIDERED_BY_PLAYER(hoodVehicle[HV_BAD_GUY_BIKE], FALSE)
|
|
ENDIF
|
|
|
|
// mix group
|
|
IF createStage >= STAGE_FOOT_CHASE
|
|
ADD_ENTITY_TO_AUDIO_MIX_GROUP(runnerChaseProperties.ped, "FRANKLIN_0_D_Group")
|
|
ENDIF
|
|
|
|
SWITCH createStage
|
|
CASE STAGE_GET_TO_BAD_GUY
|
|
START_PLAYBACK_RECORDED_VEHICLE(hoodVehicle[HV_BAD_GUY_BIKE], 014, GET_HOOD_RECORDING_PREFIX())
|
|
PAUSE_PLAYBACK_RECORDED_VEHICLE(hoodVehicle[HV_BAD_GUY_BIKE])
|
|
BREAK
|
|
CASE STAGE_VAN_CHASE
|
|
START_PLAYBACK_RECORDED_VEHICLE(hoodVehicle[HV_BAD_GUY_BIKE], 001, GET_HOOD_UBER_RECORDING_PREFIX())
|
|
BREAK
|
|
CASE STAGE_FOOT_CHASE
|
|
SET_ENTITY_COORDS_NO_OFFSET(hoodVehicle[HV_BAD_GUY_BIKE], << 460.669, -682.118, 26.5919 >>)
|
|
SET_ENTITY_ROTATION(hoodVehicle[HV_BAD_GUY_BIKE], << 0.0150743, 85.4796, 10.1482 >>)
|
|
BREAK
|
|
CASE STAGE_GET_TO_HOUSE
|
|
//IF IS_VEHICLE_DRIVEABLE(hoodVehicle[HV_FRANKLIN_VAN])
|
|
//SET_PED_CAN_PLAY_AMBIENT_BASE_ANIMS(runnerChaseProperties.ped, FALSE)
|
|
//SET_PED_CAN_PLAY_AMBIENT_ANIMS(runnerChaseProperties.ped, FALSE)
|
|
//SET_PED_INTO_VEHICLE(runnerChaseProperties.ped, hoodVehicle[HV_FRANKLIN_VAN], VS_BACK_RIGHT)
|
|
//ENDIF
|
|
BREAK
|
|
CASE STAGE_FIND_BAD_GUY
|
|
//TASK_COWER(runnerChaseProperties.ped)
|
|
FREEZE_ENTITY_POSITION(runnerChaseProperties.ped, TRUE)
|
|
BREAK
|
|
ENDSWITCH
|
|
ENDPROC
|
|
|
|
// create girl for bad guy to flirt with
|
|
PROC CREATE_GIRL_FOR_STAGE(MISSION_STAGE_ENUM createStage)
|
|
girlPed = CREATE_PED(PEDTYPE_MISSION, GET_MODEL_FOR_HOOD_MODEL_ENUM(HM_GIRL), GET_HOOD_VECTOR(HVEC_GIRL_INIT), 157.24)
|
|
SET_BLOCKING_OF_NON_TEMPORARY_EVENTS(girlPed, TRUE)
|
|
SET_PED_KEEP_TASK(girlPed, TRUE)
|
|
|
|
SET_PED_COMPONENT_VARIATION(girlPed, PED_COMP_HEAD, 0, 1)
|
|
SET_PED_COMPONENT_VARIATION(girlPed, PED_COMP_HAIR, 2, 2)
|
|
SET_PED_COMPONENT_VARIATION(girlPed, PED_COMP_TORSO, 0, 2)
|
|
SET_PED_COMPONENT_VARIATION(girlPed, PED_COMP_LEG, 1, 2)
|
|
SET_PED_COMPONENT_VARIATION(girlPed, PED_COMP_SPECIAL, 0, 1)
|
|
CLEAR_ALL_PED_PROPS(girlPed)
|
|
|
|
IF createStage = STAGE_GET_TO_BAD_GUY
|
|
IF NOT IS_PED_INJURED(runnerChaseProperties.ped)
|
|
TASK_LOOK_AT_ENTITY(girlPed, runnerChaseProperties.ped, -1, SLF_WHILE_NOT_IN_FOV)
|
|
TASK_LOOK_AT_ENTITY(runnerChaseProperties.ped, girlPed, -1, SLF_WHILE_NOT_IN_FOV)
|
|
ENDIF
|
|
ELSE
|
|
TASK_LOOK_AT_ENTITY(girlPed, PLAYER_PED_ID(), -1, SLF_WHILE_NOT_IN_FOV)
|
|
ENDIF
|
|
ENDPROC
|
|
|
|
// create blocking vehicle
|
|
PROC CREATE_BLOCKING_VEHICLES()
|
|
INT i
|
|
HOOD_MODEL_ENUM thisModel
|
|
VECTOR vPos
|
|
FLOAT fRot
|
|
|
|
REPEAT NUMBER_BLOCKING_VEHICLES i
|
|
SWITCH i
|
|
CASE 0
|
|
thisModel = HM_BLOCKING_TRUCK
|
|
vPos = <<343.02, 333.05, 104.87>>
|
|
fRot = -138.08
|
|
BREAK
|
|
CASE 1
|
|
thisModel = HM_BLOCKING_CAR
|
|
vPos = <<338.54, 340.18, 105.06>>
|
|
fRot = -15.46
|
|
BREAK
|
|
ENDSWITCH
|
|
blockingVehicle[i] = CREATE_VEHICLE(GET_MODEL_FOR_HOOD_MODEL_ENUM(thisModel), vPos, fRot)
|
|
SET_VEHICLE_ON_GROUND_PROPERLY(blockingVehicle[i])
|
|
SET_VEHICLE_DOORS_LOCKED(blockingVehicle[i], VEHICLELOCK_LOCKOUT_PLAYER_ONLY)
|
|
ENDREPEAT
|
|
ENDPROC
|
|
|
|
// create collie to tempt chop
|
|
PROC CREATE_COLLIE()
|
|
colliePed = CREATE_PED(PEDTYPE_MISSION, GET_MODEL_FOR_HOOD_MODEL_ENUM(HM_COLLIE), GET_HOOD_VECTOR(HVEC_COLLIE_INIT), COLLIE_INIT_ROT)
|
|
SET_PED_COMPONENT_VARIATION(colliePed, PED_COMP_TORSO, 0, 0)
|
|
SET_PED_COMPONENT_VARIATION(colliePed, PED_COMP_LEG, 0, 1)
|
|
|
|
SET_BLOCKING_OF_NON_TEMPORARY_EVENTS(colliePed, TRUE)
|
|
SET_PED_KEEP_TASK(colliePed, TRUE)
|
|
SET_PED_DIES_WHEN_INJURED(colliePed, TRUE)
|
|
SET_PED_CAN_BE_TARGETTED(colliePed, FALSE)
|
|
|
|
SET_ENTITY_PROOFS(colliePed, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, TRUE)
|
|
|
|
TASK_PLAY_ANIM(colliePed, GET_HOOD_ANIM_DICT_AS_STRING(H_ANIM_DICT_FIND), "FRA_0_IG_15_FEMALE_DOG_IDLE", NORMAL_BLEND_IN, NORMAL_BLEND_OUT, -1, AF_LOOPING | AF_NOT_INTERRUPTABLE | AF_USE_KINEMATIC_PHYSICS)
|
|
ENDPROC
|
|
|
|
// set bike as smoking
|
|
PROC SET_BIKE_AS_SMOKING()
|
|
IF IS_VEHICLE_DRIVEABLE(hoodVehicle[HV_BAD_GUY_BIKE])
|
|
IF GET_VEHICLE_ENGINE_HEALTH(hoodVehicle[HV_BAD_GUY_BIKE]) > 300
|
|
SET_VEHICLE_ENGINE_HEALTH(hoodVehicle[HV_BAD_GUY_BIKE], 300)
|
|
ENDIF
|
|
bSetBikeAsSmoking = TRUE
|
|
ENDIF
|
|
ENDPROC
|
|
|
|
// create driver in a train yard vehicle
|
|
PROC CREATE_DRIVER_FOR_SETPIECE_VEHICLE(BOOL bIsTrain, INT iVehicle, BOOL bBlockEvents = TRUE, BOOL bIsWorker = FALSE)
|
|
VEHICLE_INDEX thisVehicle
|
|
INT iDriver
|
|
IF bIsTrain
|
|
thisVehicle = trainVehicle[iVehicle]
|
|
iDriver = iVehicle + NUMBER_YARD_VEHICLES
|
|
ELSE
|
|
thisVehicle = yardVehicle[iVehicle]
|
|
iDriver = iVehicle
|
|
ENDIF
|
|
|
|
IF IS_VEHICLE_DRIVEABLE(thisVehicle)
|
|
BOOL bCreateAsWorker = bIsWorker
|
|
|
|
IF NOT DOES_ENTITY_EXIST(driverPed[iDriver])
|
|
IF NOT bCreateAsWorker
|
|
IF CAN_CREATE_RANDOM_DRIVER()
|
|
driverPed[iDriver] = CREATE_RANDOM_PED_AS_DRIVER(thisVehicle)
|
|
ELSE
|
|
bCreateAsWorker = TRUE
|
|
ENDIF
|
|
ENDIF
|
|
IF bCreateAsWorker
|
|
REQUEST_MODEL(GET_MODEL_FOR_HOOD_MODEL_ENUM(HM_WORKER)) // idiocy to get around assert
|
|
IF HAS_MODEL_LOADED(GET_MODEL_FOR_HOOD_MODEL_ENUM(HM_WORKER))
|
|
driverPed[iDriver] = CREATE_PED_INSIDE_VEHICLE(thisVehicle, PEDTYPE_MISSION, GET_MODEL_FOR_HOOD_MODEL_ENUM(HM_WORKER))
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
IF NOT IS_PED_INJURED(driverPed[iDriver])
|
|
IF bBlockEvents
|
|
SET_BLOCKING_OF_NON_TEMPORARY_EVENTS(driverPed[iDriver], TRUE)
|
|
ENDIF
|
|
TASK_LOOK_AT_ENTITY(driverPed[iDriver], PLAYER_PED_ID(), -1, SLF_WHILE_NOT_IN_FOV)
|
|
ENDIF
|
|
ENDIF
|
|
ENDPROC
|
|
|
|
PROC CREATE_YARD_TRAIN_FOR_STAGE(INT iTrain, MISSION_STAGE_ENUM createStage, BOOL bIsCutscene = FALSE)
|
|
INT iConfig
|
|
VECTOR vPos
|
|
BOOL bDirection
|
|
FLOAT fSpeed
|
|
|
|
SWITCH iTrain
|
|
CASE 0
|
|
iConfig = 18
|
|
vPos = <<526.88, -534.26, 24.12>>
|
|
bDirection = FALSE
|
|
fSpeed = 0.0
|
|
BREAK
|
|
CASE 1
|
|
iConfig = 19
|
|
IF createStage = STAGE_FOOT_CHASE
|
|
vPos = <<543.18, -579.82, 25.41>>
|
|
fSpeed = 0.0
|
|
ELSE
|
|
vPos = <<538.92, -615.0, 24.22>>
|
|
fSpeed = 2.67
|
|
ENDIF
|
|
bDirection = TRUE
|
|
|
|
BREAK
|
|
CASE 2
|
|
iConfig = 20
|
|
bDirection = TRUE
|
|
IF createStage = STAGE_FOOT_CHASE
|
|
IF bIsCutscene
|
|
vPos = <<547.80, -608.82, 24.90>>
|
|
fSpeed = 8.0
|
|
ELSE
|
|
vPos = <<532.1, -741.2, 24.0>>
|
|
fSpeed = 0.0
|
|
ENDIF
|
|
ELSE
|
|
vPos = <<556.5, -530.7, 24.2>>
|
|
fSpeed = 5.5
|
|
ENDIF
|
|
BREAK
|
|
ENDSWITCH
|
|
|
|
trainVehicle[iTrain] = CREATE_MISSION_TRAIN(iConfig, vPos, bDirection)
|
|
SET_TRAIN_CRUISE_SPEED(trainVehicle[iTrain], fSpeed)
|
|
SET_TRAIN_SPEED(trainVehicle[iTrain], fSpeed)
|
|
IF createStage = STAGE_FOOT_CHASE
|
|
CREATE_DRIVER_FOR_SETPIECE_VEHICLE(TRUE, iTrain, TRUE, TRUE)
|
|
ENDIF
|
|
|
|
fTrainCruiseSpeed[iTrain] = fSpeed
|
|
|
|
SWITCH iTrain
|
|
CASE 1
|
|
SET_VEHICLE_EXTRA(GET_TRAIN_CARRIAGE(trainVehicle[iTrain], 1), 1, TRUE)
|
|
SET_VEHICLE_EXTRA(GET_TRAIN_CARRIAGE(trainVehicle[iTrain], 2), 1, FALSE)
|
|
BREAK
|
|
CASE 2
|
|
SET_VEHICLE_COLOUR_COMBINATION(GET_TRAIN_CARRIAGE(trainVehicle[iTrain], 1), 3)
|
|
SET_VEHICLE_COLOUR_COMBINATION(GET_TRAIN_CARRIAGE(trainVehicle[iTrain], 2), 1)
|
|
SET_VEHICLE_COLOUR_COMBINATION(GET_TRAIN_CARRIAGE(trainVehicle[iTrain], 3), 2)
|
|
//SET_VEHICLE_EXTRA(GET_TRAIN_CARRIAGE(trainVehicle[iTrain], 1), 1, TRUE)
|
|
//SET_VEHICLE_EXTRA(GET_TRAIN_CARRIAGE(trainVehicle[iTrain], 2), 1, TRUE)
|
|
//SET_VEHICLE_EXTRA(GET_TRAIN_CARRIAGE(trainVehicle[iTrain], 3), 1, TRUE)
|
|
BREAK
|
|
ENDSWITCH
|
|
ENDPROC
|
|
|
|
// create yard trains
|
|
PROC CREATE_YARD_TRAINS()
|
|
CREATE_YARD_TRAIN_FOR_STAGE(0, STAGE_FOOT_CHASE)
|
|
CREATE_YARD_TRAIN_FOR_STAGE(1, STAGE_FOOT_CHASE)
|
|
CREATE_YARD_TRAIN_FOR_STAGE(2, STAGE_FOOT_CHASE)
|
|
ENDPROC
|
|
|
|
PROC CREATE_CHASE_SETPIECES(BOOL bJumpingTo, BOOL bCreateTrains, BOOL bCreateCars, BOOL bCreateBuses, BOOL bCreatePeds)
|
|
INT i
|
|
INT iRec
|
|
INT iColour
|
|
VECTOR vPos
|
|
FLOAT fRot
|
|
FLOAT fSkip
|
|
FLOAT fSpeed
|
|
BOOL bJustCreated
|
|
|
|
// vehicles
|
|
REPEAT NUMBER_YARD_VEHICLES i
|
|
BOOL bVehicleHasDriver = TRUE
|
|
BOOL bVehicleDriverIsWorker = FALSE
|
|
BOOL bNoRec = FALSE
|
|
|
|
bJustCreated = FALSE
|
|
|
|
HOOD_MODEL_ENUM trafficModelEnum
|
|
vPos = <<i*20,i*10,-10>>
|
|
fRot = 0.0
|
|
iRec = 000
|
|
iColour = -1
|
|
fSkip = 0.0
|
|
fSpeed = 1.0
|
|
|
|
SWITCH INT_TO_ENUM(YARD_VEHICLE_ENUM, i)
|
|
CASE YV_CAR_CARPARK_PULL_OUT_FOR_JUMP_OVER
|
|
vPos = <<491.43, -537.62, 23.75>>
|
|
fRot = -92.24
|
|
iColour = 2
|
|
bNoRec = TRUE
|
|
trafficModelEnum = HM_TRAFFIC_CAR1
|
|
bVehicleDriverIsWorker = TRUE
|
|
BREAK
|
|
CASE YV_CAR_STATION_PULL_INTO_DEPOT
|
|
iRec = 011
|
|
iColour = 2
|
|
trafficModelEnum = HM_TRAFFIC_CAR2
|
|
fSpeed = 0.7
|
|
BREAK
|
|
//CASE YV_CAR_ROAD_FROM_RIGHT
|
|
// vPos = <<479.36, -674.25, 25.28>>
|
|
// fRot = 91.05
|
|
// iColour = 3
|
|
// trafficModelEnum = HM_TRAFFIC_CAR1
|
|
//BREAK
|
|
CASE YV_BUS_ROAD_FROM_LEFT
|
|
vPos = <<451.5, -681.2, 28.1>>
|
|
fRot = -95.1
|
|
iColour = 0
|
|
trafficModelEnum = HM_BUS
|
|
bVehicleDriverIsWorker = TRUE
|
|
BREAK
|
|
CASE YV_CAR_CARPARK_STATIC
|
|
vPos = <<488.74, -541.46, 23.75>>
|
|
fRot = 85.92
|
|
iColour = 1
|
|
trafficModelEnum = HM_TRAFFIC_CAR2
|
|
bVehicleHasDriver = FALSE
|
|
BREAK
|
|
CASE YV_BUS_REVERSE
|
|
iRec = 001
|
|
fSkip = 700
|
|
fSpeed = 0.80
|
|
iColour = 0
|
|
trafficModelEnum = HM_BUS
|
|
bVehicleDriverIsWorker = TRUE
|
|
BREAK
|
|
CASE YV_BUS_PULL_OUT
|
|
bNoRec = TRUE
|
|
vPos = <<464.37, -651.16, 28.06>>
|
|
fRot = 173.0
|
|
iColour = 0
|
|
trafficModelEnum = HM_BUS
|
|
bVehicleDriverIsWorker = TRUE
|
|
BREAK
|
|
CASE YV_BUS_STATIC
|
|
iRec = 012
|
|
iColour = 1
|
|
trafficModelEnum = HM_BUS
|
|
bVehicleHasDriver = FALSE
|
|
BREAK
|
|
ENDSWITCH
|
|
|
|
IF INT_TO_ENUM(YARD_VEHICLE_ENUM, i) <> YV_BUS_ROAD_FROM_LEFT
|
|
OR bJumpingTo
|
|
IF (trafficModelEnum = HM_BUS AND bCreateBuses)
|
|
OR (trafficModelEnum <> HM_BUS AND bCreateCars)
|
|
IF NOT DOES_ENTITY_EXIST(yardVehicle[i])
|
|
yardVehicle[i] = CREATE_VEHICLE(GET_MODEL_FOR_HOOD_MODEL_ENUM(trafficModelEnum), vPos, fRot)
|
|
bJustCreated = TRUE
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF IS_VEHICLE_DRIVEABLE(yardVehicle[i])
|
|
AND bJustCreated
|
|
IF bVehicleHasDriver
|
|
CREATE_DRIVER_FOR_SETPIECE_VEHICLE(FALSE, i, TRUE, bVehicleDriverIsWorker)
|
|
ENDIF
|
|
|
|
IF iColour >= 0
|
|
SET_VEHICLE_COLOUR_COMBINATION(yardVehicle[i], iColour)
|
|
ENDIF
|
|
|
|
IF INT_TO_ENUM(YARD_VEHICLE_ENUM, i) = YV_BUS_REVERSE
|
|
ADD_ENTITY_TO_AUDIO_MIX_GROUP(yardVehicle[i], "FRANKLIN_0_Reversing_Bus")
|
|
ENDIF
|
|
|
|
//SET_VEHICLE_IS_CONSIDERED_BY_PLAYER(yardVehicle[i], FALSE)
|
|
SET_ENTITY_SHOULD_FREEZE_WAITING_ON_COLLISION(yardVehicle[i], TRUE)
|
|
SET_VEHICLE_DOORS_LOCKED(yardVehicle[i], VEHICLELOCK_LOCKOUT_PLAYER_ONLY)
|
|
IF iRec > 000
|
|
AND NOT bNoRec
|
|
START_PLAYBACK_RECORDED_VEHICLE(yardVehicle[i], iRec, GET_HOOD_RECORDING_PREFIX())
|
|
SKIP_TIME_IN_PLAYBACK_RECORDED_VEHICLE(yardVehicle[i], fSkip)
|
|
SET_PLAYBACK_SPEED(yardVehicle[i], fSpeed)
|
|
FORCE_PLAYBACK_RECORDED_VEHICLE_UPDATE(yardVehicle[i])
|
|
PAUSE_PLAYBACK_RECORDED_VEHICLE(yardVehicle[i])
|
|
ELSE
|
|
SET_VEHICLE_ON_GROUND_PROPERLY(yardVehicle[i])
|
|
IF bVehicleHasDriver
|
|
PED_INDEX thisDriverPed = GET_PED_IN_VEHICLE_SEAT(yardVehicle[i])
|
|
IF NOT IS_PED_INJURED(thisDriverPed)
|
|
SWITCH INT_TO_ENUM(YARD_VEHICLE_ENUM, i)
|
|
//CASE YV_CAR_ROAD_FROM_RIGHT
|
|
// TASK_VEHICLE_DRIVE_TO_COORD(thisDriverPed, yardVehicle[i], <<470.28, -674.36, 26.09>>, 7.0, DRIVINGSTYLE_NORMAL, GET_ENTITY_MODEL(yardVehicle[i]), DRIVINGMODE_STOPFORCARS, 2.0, 100000)
|
|
//BREAK
|
|
CASE YV_BUS_ROAD_FROM_LEFT
|
|
TASK_VEHICLE_TEMP_ACTION(thisDriverPed, yardVehicle[i], TEMPACT_BRAKE, 20000)
|
|
BREAK
|
|
|
|
DEFAULT
|
|
IF NOT bNoRec
|
|
TASK_VEHICLE_DRIVE_WANDER(thisDriverPed, yardVehicle[i], 2.5, DRIVINGMODE_STOPFORCARS)
|
|
ENDIF
|
|
BREAK
|
|
ENDSWITCH
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDREPEAT
|
|
|
|
// trains
|
|
IF bCreateTrains
|
|
CREATE_YARD_TRAINS()
|
|
ENDIF
|
|
|
|
// peds
|
|
IF bCreatePeds
|
|
REPEAT NUMBER_YARD_PEDS i
|
|
BOOL bWorkerPed = FALSE
|
|
|
|
YARD_PED_ENUM thisPed = INT_TO_ENUM(YARD_PED_ENUM, i)
|
|
|
|
IF thisPed <> YP_STATION_CONV_KNOCK_OVER
|
|
AND thisPed <> YP_STATION_CONV_LOOK
|
|
SWITCH thisPed
|
|
// in bus station
|
|
CASE YP_STATION_WALK_TO_GATE
|
|
vPos = <<459.48, -618.58, 27.51>>
|
|
fRot = 168.82
|
|
bWorkerPed = TRUE
|
|
BREAK
|
|
CASE YP_STATION_CONV_KNOCK_OVER
|
|
vPos = <<466.44, -630.26, 27.51>>
|
|
fRot = 61.25
|
|
BREAK
|
|
CASE YP_STATION_CONV_LOOK
|
|
vPos = <<464.38, -629.01, 27.51>>
|
|
fRot = 240.21
|
|
BREAK
|
|
CASE YP_STATION_BACK_TURNED_KNOCK_OVER
|
|
vPos = <<471.04, -591.71, 27.51>>
|
|
fRot = -27.00
|
|
bWorkerPed = TRUE
|
|
BREAK
|
|
|
|
// in construction site
|
|
//CASE YP_CONSTRUCT_CONV_LOOK1
|
|
// vPos = <<503.53, -510.70, 23.75>>
|
|
// fRot = -7.33
|
|
// bWorkerPed = TRUE
|
|
//BREAK
|
|
//CASE YP_CONSTRUCT_CONV_LOOK2
|
|
// vPos = <<503.60, -509.09, 23.75>>
|
|
// fRot = -187.33
|
|
// bWorkerPed = TRUE
|
|
//BREAK
|
|
CASE YP_CONSTRUCT_WALK_SOUTH
|
|
vPos = <<525.01, -475.66, 23.73>>
|
|
fRot = 173.22
|
|
bWorkerPed = TRUE
|
|
BREAK
|
|
CASE YP_CONSTRUCT_WALK_NORTH
|
|
vPos = <<515.01, -512.17, 23.75>>
|
|
fRot = -4.39
|
|
bWorkerPed = TRUE
|
|
BREAK
|
|
ENDSWITCH
|
|
|
|
BOOL bCreateAsWorker = bWorkerPed
|
|
IF NOT bCreateAsWorker
|
|
IF CAN_CREATE_RANDOM_PED(RPM_DONT_CARE)
|
|
yardPed[i].ped = CREATE_RANDOM_PED(vPos)
|
|
SET_ENTITY_HEADING(yardPed[i].ped, fRot)
|
|
ELSE
|
|
bCreateAsWorker = TRUE
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF bCreateAsWorker
|
|
yardPed[i].ped = CREATE_PED(PEDTYPE_MISSION, GET_MODEL_FOR_HOOD_MODEL_ENUM(HM_WORKER), vPos, fRot)
|
|
ENDIF
|
|
|
|
IF NOT IS_PED_INJURED(yardPed[i].ped)
|
|
SET_BLOCKING_OF_NON_TEMPORARY_EVENTS(yardPed[i].ped, TRUE)
|
|
SET_PED_KEEP_TASK(yardPed[i].ped, TRUE)
|
|
ENDIF
|
|
|
|
yardPed[i].bReactedToChop = FALSE
|
|
ENDIF
|
|
ENDREPEAT
|
|
ENDIF
|
|
ENDPROC
|
|
|
|
|
|
CONST_FLOAT SHIFT_POS_SPEED 0.85
|
|
CONST_FLOAT SHIFT_ROT_SPEED 7.5
|
|
|
|
PROC SET_FLOAT_CLOSEST_TO_IDEAL(FLOAT &fFloat, FLOAT fIdeal)
|
|
FLOAT fPositiveFloat
|
|
FLOAT fNegativeFloat
|
|
IF fFloat > 0
|
|
fPositiveFloat = fFloat
|
|
fNegativeFloat = fFloat - 360
|
|
ELIF fFloat < 0
|
|
fPositiveFloat = fFloat + 360
|
|
fNegativeFloat = fFloat
|
|
ENDIF
|
|
|
|
FLOAT fPositiveDiff = fPositiveFloat - fIdeal
|
|
IF fPositiveDiff < 0
|
|
fPositiveDiff *= -1
|
|
ENDIF
|
|
|
|
FLOAT fNegativeDiff = fNegativeFloat - fIdeal
|
|
IF fNegativeDiff < 0
|
|
fNegativeDiff *= -1
|
|
ENDIF
|
|
|
|
IF fPositiveDiff < fNegativeDiff
|
|
fFloat = fPositiveFloat
|
|
ELSE
|
|
fFloat = fNegativeFloat
|
|
ENDIF
|
|
ENDPROC
|
|
|
|
PROC SET_VECTOR_CLOSEST_TO_IDEAL(VECTOR &vVector, VECTOR vIdeal)
|
|
SET_FLOAT_CLOSEST_TO_IDEAL(vVector.x, vIdeal.x)
|
|
SET_FLOAT_CLOSEST_TO_IDEAL(vVector.y, vIdeal.y)
|
|
SET_FLOAT_CLOSEST_TO_IDEAL(vVector.z, vIdeal.z)
|
|
ENDPROC
|
|
|
|
PROC SHIFT_FLOAT_TO_IDEAL_FLOAT(FLOAT &fCurrent, FLOAT fIdeal, FLOAT fSpeed)
|
|
IF fCurrent < fIdeal
|
|
fCurrent = fCurrent +@ fSpeed
|
|
IF fCurrent > fIdeal
|
|
fCurrent = fIdeal
|
|
ENDIF
|
|
ELIF fCurrent > fIdeal
|
|
fCurrent = fCurrent -@ fSpeed
|
|
IF fCurrent < fIdeal
|
|
fCurrent = fIdeal
|
|
ENDIF
|
|
ENDIF
|
|
ENDPROC
|
|
|
|
PROC SHIFT_VECTOR_TO_IDEAL_VECTOR(VECTOR &vCurrent, VECTOR vIdeal, FLOAT fSpeed)
|
|
SHIFT_FLOAT_TO_IDEAL_FLOAT(vCurrent.x, vIdeal.x, fSpeed)
|
|
SHIFT_FLOAT_TO_IDEAL_FLOAT(vCurrent.y, vIdeal.y, fSpeed)
|
|
SHIFT_FLOAT_TO_IDEAL_FLOAT(vCurrent.z, vIdeal.z, fSpeed)
|
|
ENDPROC
|
|
|
|
CONST_FLOAT BOXCAR_WIDTH 1.468 // 1.45
|
|
CONST_FLOAT BOXCAR_HEIGHT 2.4635//2.43//2.40
|
|
|
|
// attach door to boxcar
|
|
PROC ATTACH_DOOR_TO_BOXCAR(INT iBoxcar, INT iDoor)
|
|
FLOAT fAttachX
|
|
FLOAT fAttachY
|
|
FLOAT fAttachRot
|
|
IF iDoor=0
|
|
fAttachX = -boxcarCarriage[iBoxcar].boxcarDoor[iDoor].fOffset
|
|
fAttachY = BOXCAR_WIDTH
|
|
fAttachRot = 180
|
|
ELSE
|
|
fAttachX = boxcarCarriage[iBoxcar].boxcarDoor[iDoor].fOffset
|
|
fAttachY = -BOXCAR_WIDTH
|
|
fAttachRot = 0
|
|
ENDIF
|
|
ATTACH_ENTITY_TO_ENTITY(boxcarCarriage[iBoxcar].boxcarDoor[iDoor].obj, boxcarCarriage[iBoxcar].anchorObject, 0, <<fAttachX,fAttachY,BOXCAR_HEIGHT>>, <<0,0,fAttachRot>>, FALSE, FALSE, TRUE)
|
|
|
|
ENDPROC
|
|
|
|
|
|
FUNC FLOAT GET_BOXCAR_DOOR_Z_MOD(INT iBoxcar, INT iDoor)
|
|
SWITCH iBoxcar
|
|
CASE 0
|
|
IF iDoor = 0
|
|
RETURN -0.145
|
|
ELSE
|
|
RETURN -0.105
|
|
ENDIF
|
|
BREAK
|
|
CASE 1
|
|
IF iDoor = 0
|
|
RETURN -0.148
|
|
ELSE
|
|
RETURN -0.145
|
|
ENDIF
|
|
BREAK
|
|
CASE 3
|
|
IF iDoor = 0
|
|
RETURN -0.07
|
|
ELSE
|
|
RETURN -0.05
|
|
ENDIF
|
|
BREAK
|
|
CASE 4
|
|
IF iDoor = 0
|
|
RETURN -0.02
|
|
ELSE
|
|
RETURN -0.065
|
|
ENDIF
|
|
BREAK
|
|
ENDSWITCH
|
|
|
|
RETURN 0.0
|
|
ENDFUNC
|
|
|
|
// attach handle to boxcar
|
|
PROC ATTACH_HANDLE_TO_BOXCAR(INT iBoxcar, INT iDoor)
|
|
/*
|
|
VECTOR vOffset
|
|
FLOAT fHandleRot
|
|
IF iDoor=0
|
|
vOffset = <<1.581, 1.516, 1.282>>
|
|
fHandleRot = 180
|
|
ELSE
|
|
vOffset = <<-1.572, -1.515, 1.272>>
|
|
fHandleRot = 0
|
|
ENDIF
|
|
|
|
vOffset += <<0,0,GET_BOXCAR_DOOR_Z_MOD(iBoxcar,iDoor)>>
|
|
*/
|
|
|
|
VECTOR vPos
|
|
VECTOR vRot
|
|
|
|
SWITCH iBoxcar
|
|
CASE 0
|
|
IF iDoor = 0
|
|
vPos = <<547.6336, -625.1866, 25.0932>>
|
|
vRot = <<0,0,-97.00>>
|
|
ELSE
|
|
vPos = <<550.2516, -628.7438, 25.1332>>
|
|
vRot = <<0,0,83.00>>
|
|
ENDIF
|
|
BREAK
|
|
|
|
CASE 1
|
|
IF iDoor = 0
|
|
vPos = <<545.6388, -641.4614, 25.0902>>
|
|
vRot = <<0,0,-97.00>>
|
|
ELSE
|
|
vPos = <<548.2568, -645.0185, 25.0932>>
|
|
vRot = <<0,0,83.00>>
|
|
ENDIF
|
|
BREAK
|
|
|
|
CASE 2
|
|
vPos = <<528.0478, -680.6921, 25.1482>>
|
|
vRot = <<0,0,83.36>>
|
|
BREAK
|
|
|
|
CASE 3
|
|
IF iDoor = 0
|
|
vPos = <<523.6058, -693.3036, 25.1182>>
|
|
vRot = <<0,0,-96.00>>
|
|
ELSE
|
|
vPos = <<526.2855, -696.8145, 25.1382>>
|
|
vRot = <<0,0,84.00>>
|
|
ENDIF
|
|
BREAK
|
|
|
|
CASE 4
|
|
IF iDoor = 0
|
|
vPos = <<517.8303, -704.0568, 25.1782>>
|
|
vRot = <<0,0,-95.66>>
|
|
ELSE
|
|
vPos = <<520.5307, -707.5518, 25.1332>>
|
|
vRot = <<0,0,84.34>>
|
|
ENDIF
|
|
BREAK
|
|
|
|
ENDSWITCH
|
|
|
|
SET_ENTITY_COORDS_NO_OFFSET(boxcarCarriage[iBoxcar].boxcarDoor[iDoor].handleObject, vPos)
|
|
SET_ENTITY_ROTATION(boxcarCarriage[iBoxcar].boxcarDoor[iDoor].handleObject, vRot)
|
|
FREEZE_ENTITY_POSITION(boxcarCarriage[iBoxcar].boxcarDoor[iDoor].handleObject, TRUE)
|
|
|
|
//ATTACH_ENTITY_TO_ENTITY(boxcarCarriage[iBoxcar].boxcarDoor[iDoor].handleObject, boxcarCarriage[iBoxcar].anchorObject, -1, vOffset, <<0,fRot,fHandleRot>>, FALSE, FALSE, TRUE)
|
|
ENDPROC
|
|
|
|
FUNC VECTOR GET_BOXCAR_POS(INT iBoxcar)
|
|
SWITCH iBoxcar
|
|
CASE 0
|
|
RETURN <<548.9426, -626.9652, 23.91>>
|
|
BREAK
|
|
CASE 1
|
|
RETURN <<546.9478, -643.2399, 23.91>>
|
|
BREAK
|
|
CASE 2
|
|
RETURN <<526.7276, -678.9218, 23.82>>
|
|
BREAK
|
|
CASE 3
|
|
RETURN <<524.9456, -695.0590, 23.86>>
|
|
BREAK
|
|
CASE 4
|
|
RETURN <<519.1805, -705.8043, 23.87>>
|
|
BREAK
|
|
ENDSWITCH
|
|
|
|
RETURN <<0,0,0>>
|
|
ENDFUNC
|
|
|
|
FUNC FLOAT GET_BOXCAR_ROT(INT iBoxcar)
|
|
SWITCH iBoxcar
|
|
CASE 0
|
|
RETURN 83.0
|
|
BREAK
|
|
CASE 1
|
|
RETURN 83.0
|
|
BREAK
|
|
CASE 2
|
|
RETURN 83.36
|
|
BREAK
|
|
CASE 3
|
|
RETURN 84.0
|
|
BREAK
|
|
CASE 4
|
|
RETURN 84.34
|
|
BREAK
|
|
ENDSWITCH
|
|
|
|
RETURN 0.0
|
|
ENDFUNC
|
|
|
|
// create the doors for hiding boxcar
|
|
PROC CREATE_BOXCAR_DOORS()
|
|
INT i,j
|
|
|
|
REPEAT NUMBER_BOXCARS i
|
|
VECTOR vPos = GET_BOXCAR_POS(i)
|
|
FLOAT fRot = GET_BOXCAR_ROT(i)
|
|
|
|
boxcarCarriage[i].anchorObject = CREATE_OBJECT(GET_MODEL_FOR_HOOD_MODEL_ENUM(HM_ANCHOR), vPos)
|
|
SET_ENTITY_COORDS_NO_OFFSET(boxcarCarriage[i].anchorObject, vPos)
|
|
SET_ENTITY_HEADING(boxcarCarriage[i].anchorObject, fRot)
|
|
SET_ENTITY_COLLISION(boxcarCarriage[i].anchorObject, FALSE)
|
|
SET_ENTITY_VISIBLE(boxcarCarriage[i].anchorObject, FALSE)
|
|
FREEZE_ENTITY_POSITION(boxcarCarriage[i].anchorObject, TRUE)
|
|
|
|
boxcarCarriage[i].searchState = CARRIAGE_SEARCH_STATE_NOT_BLIPPED
|
|
|
|
REPEAT 2 j
|
|
boxcarCarriage[i].boxcarDoor[j].state = BOXCAR_DOOR_AWAITING_PLAYER
|
|
boxcarCarriage[i].boxcarDoor[j].fOffset = 0.0348647
|
|
boxcarCarriage[i].boxcarDoor[j].obj = CREATE_OBJECT(GET_MODEL_FOR_HOOD_MODEL_ENUM(HM_BOXCAR_DOOR), vPos)
|
|
ATTACH_DOOR_TO_BOXCAR(i,j)
|
|
|
|
IF NOT (i=2 AND j=0) // disable back one of target carriage
|
|
boxcarCarriage[i].boxcarDoor[j].handleObject = CREATE_OBJECT(GET_MODEL_FOR_HOOD_MODEL_ENUM(HM_BOXCAR_HANDLE), vPos)
|
|
ATTACH_HANDLE_TO_BOXCAR(i,j)
|
|
ENDIF
|
|
ENDREPEAT
|
|
ENDREPEAT
|
|
ENDPROC
|
|
|
|
CONST_FLOAT BOXCAR_CAM_X_OFFSET 1.800
|
|
CONST_FLOAT BOXCAR_CAM_Y_OFFSET -0.400
|
|
CONST_FLOAT BOXCAR_CAM_Z_OFFSET 1.050
|
|
|
|
CONST_FLOAT BOXCAR_CAM_X_POINT 0.500
|
|
CONST_FLOAT BOXCAR_CAM_Y_POINT 1.800
|
|
CONST_FLOAT BOXCAR_CAM_Z_POINT 1.440
|
|
|
|
CONST_FLOAT BOXCAR_CAM_FOV 26.500
|
|
|
|
PROC UPDATE_INSIDE_BOXCAR_CAM(INT iBoxcar, INT iDoor)
|
|
/*
|
|
VECTOR vOffset
|
|
IF iDoor = 0
|
|
vOffset.x = BOXCAR_CAM_X_OFFSET
|
|
vOffset.y = BOXCAR_CAM_Y_OFFSET
|
|
ELSE
|
|
vOffset.x = -BOXCAR_CAM_X_OFFSET
|
|
vOffset.y = -BOXCAR_CAM_Y_OFFSET
|
|
ENDIF
|
|
vOffset.z = BOXCAR_CAM_Z_OFFSET
|
|
|
|
VECTOR vPoint
|
|
IF iDoor = 0
|
|
vPoint.x = BOXCAR_CAM_X_POINT
|
|
vPoint.y = BOXCAR_CAM_Y_POINT
|
|
ELSE
|
|
vPoint.x = -BOXCAR_CAM_X_POINT
|
|
vPoint.y = -BOXCAR_CAM_Y_POINT
|
|
ENDIF
|
|
vPoint.z = BOXCAR_CAM_Z_POINT
|
|
|
|
ATTACH_CAM_TO_ENTITY(staticCam, boxcarCarriage[iBoxcar].anchorObject, vOffset)
|
|
POINT_CAM_AT_ENTITY(staticCam, boxcarCarriage[iBoxcar].anchorObject, vPoint)
|
|
SET_CAM_FOV(staticCam, BOXCAR_CAM_FOV)
|
|
*/
|
|
|
|
VECTOR vPos
|
|
VECTOR vRot
|
|
FLOAT fFOV
|
|
|
|
vPos = <<549.67, -624.49, 25.65>>
|
|
vRot = <<2.11, 0.0, 121.17>>
|
|
fFOV = 50.0
|
|
|
|
SWITCH iBoxcar
|
|
CASE 0
|
|
SWITCH iDoor
|
|
CASE 0
|
|
vPos = <<548.45, -625.39, 25.12>>
|
|
vRot = <<1.69, 3.86, 115.96>>
|
|
fFOV = 42.79
|
|
BREAK
|
|
CASE 1
|
|
vPos = <<549.40, -627.56, 25.12>>
|
|
vRot = <<7.45, 2.51, -119.90>>
|
|
fFOV = 38.65
|
|
BREAK
|
|
ENDSWITCH
|
|
BREAK
|
|
|
|
CASE 1
|
|
SWITCH iDoor
|
|
CASE 0
|
|
vPos = <<546.21, -642.82, 24.98>>
|
|
vRot = <<15.40, 7.15, 45.11>>
|
|
fFOV = 42.55
|
|
BREAK
|
|
CASE 1
|
|
vPos = <<547.78, -644.89, 25.43>>
|
|
vRot = <<-9.66, 5.28, -46.60>>
|
|
fFOV = 43.85
|
|
BREAK
|
|
ENDSWITCH
|
|
BREAK
|
|
|
|
CASE 2
|
|
SWITCH iDoor
|
|
CASE 0
|
|
vPos = <<546.21, -642.82, 24.98>>
|
|
vRot = <<15.40, 7.15, 45.11>>
|
|
fFOV = 49.38
|
|
BREAK
|
|
CASE 1
|
|
vPos = <<527.46, -679.55, 24.82>>
|
|
vRot = <<21.60, 4.67, -134.84>>
|
|
fFOV = 48.47
|
|
BREAK
|
|
ENDSWITCH
|
|
BREAK
|
|
|
|
CASE 3
|
|
SWITCH iDoor
|
|
CASE 0
|
|
vPos = <<526.34, -695.16, 27.80>>
|
|
vRot = <<-39.4, 7.88, 76.29>>
|
|
fFOV = 19.69
|
|
BREAK
|
|
CASE 1
|
|
vPos = <<525.24, -695.54, 25.17>>
|
|
vRot = <<2.83, -1.28, -120.16>>
|
|
fFOV = 44.53
|
|
BREAK
|
|
ENDSWITCH
|
|
BREAK
|
|
|
|
CASE 4
|
|
SWITCH iDoor
|
|
CASE 0
|
|
vPos = <<519.53, -707.70, 25.22>>
|
|
vRot = <<4.41, 0.0, 37.62>>
|
|
fFOV = 24.44
|
|
BREAK
|
|
CASE 1
|
|
vPos = <<519.56, -707.48, 25.10>>
|
|
vRot = <<7.97, 0.0, -56.17>>
|
|
fFOV = 41.51
|
|
BREAK
|
|
ENDSWITCH
|
|
BREAK
|
|
ENDSWITCH
|
|
|
|
SET_CAM_COORD(staticCam, vPos)
|
|
SET_CAM_ROT(staticCam, vRot)
|
|
SET_CAM_FOV(staticCam, fFOV)
|
|
|
|
//#IF IS_DEBUG_BUILD
|
|
// ATTACH_CAM_TO_ENTITY(staticCam, boxcarCarriage[iBoxcar].anchorObject, vDebugBoxcarCamOffset)
|
|
// POINT_CAM_AT_ENTITY(staticCam, boxcarCarriage[iBoxcar].anchorObject, vDebugBoxcarCamPoint)
|
|
// SET_CAM_FOV(staticCam, fDebugBoxcarCamFOV)
|
|
//#ENDIF
|
|
ENDPROC
|
|
|
|
PROC CREATE_INSIDE_BOXCAR_CAM(INT iBoxcar, INT iDoor)
|
|
|
|
// comment out to test animated cam
|
|
//CREATE_MISSION_STATIC_CAM(staticCam)
|
|
//UPDATE_INSIDE_BOXCAR_CAM(iBoxcar, iDoor)
|
|
|
|
// animated cam stuff
|
|
|
|
CREATE_MISSION_ANIM_CAM()
|
|
|
|
STRING sBoxcarCam
|
|
IF iBoxcar=2
|
|
sBoxcarCam = "open_train_car_cam"
|
|
PRINTSTRING("open_train_car_cam") PRINTNL()
|
|
PRINTSTRING("clear area of vehicles") PRINTNL()
|
|
//CLEAR_ANGLED_AREA_OF_VEHICLES(<<525.33466, -679.05676, 22.22347>>, <<509.89377, -676.02429, 28.29614>>, 12, FALSE, FALSE, FALSE, FALSE, FALSE)
|
|
//CLEAR_ANGLED_AREA_OF_VEHICLES(<<510.64154, -677.39349, 22.28662>>, <<515.40167, -626.52264, 23.75104>>, 12, FALSE, FALSE, FALSE, FALSE, FALSE)
|
|
CLEAR_AREA(<<516.24835, -677.81812, 24.24440>>, 10, TRUE)
|
|
CLEAR_AREA(<<511.58005, -651.00690, 23.75105>>, 24, TRUE)
|
|
CLEAR_AREA_OF_PROJECTILES(<<517.10986, -665.34436, 23.80532>>, 25)
|
|
STOP_FIRE_IN_RANGE(<<517.10986, -665.34436, 23.80532>>, 25)
|
|
REMOVE_PARTICLE_FX_IN_RANGE(<<517.10986, -665.34436, 23.80532>>, 25)
|
|
ELSE
|
|
VECTOR vOffset = GET_OFFSET_FROM_ENTITY_GIVEN_WORLD_COORDS(boxcarCarriage[iBoxcar].boxcarDoor[iDoor].obj, GET_ENTITY_COORDS(PLAYER_PED_ID()))
|
|
PRINTSTRING("offset = ") PRINTVECTOR(vOffset) PRINTNL()
|
|
IF vOffset.x <= 0
|
|
IF iLeftBoxcarCam = 0
|
|
sBoxcarCam = "open_train_car_CAML1"
|
|
PRINTSTRING("open_train_car_CAML1") PRINTNL()
|
|
iLeftBoxcarCam = 1
|
|
ELSE
|
|
sBoxcarCam = "open_train_car_CAML2"
|
|
PRINTSTRING("open_train_car_CAML2") PRINTNL()
|
|
iLeftBoxcarCam = 0
|
|
ENDIF
|
|
ELSE
|
|
IF iRightBoxcarCam = 0
|
|
sBoxcarCam = "open_train_car_CAMR1"
|
|
PRINTSTRING("open_train_car_CAMR1") PRINTNL()
|
|
iRightBoxcarCam = 1
|
|
ELSE
|
|
sBoxcarCam = "open_train_car_CAMR2"
|
|
PRINTSTRING("open_train_car_CAMR2") PRINTNL()
|
|
iRightBoxcarCam = 0
|
|
ENDIF
|
|
ENDIF
|
|
|
|
CLEAR_AREA_OF_PROJECTILES(GET_ENTITY_COORDS(PLAYER_PED_ID()), 8)
|
|
STOP_FIRE_IN_RANGE(GET_ENTITY_COORDS(PLAYER_PED_ID()), 8)
|
|
REMOVE_PARTICLE_FX_IN_RANGE(GET_ENTITY_COORDS(PLAYER_PED_ID()), 8)
|
|
ENDIF
|
|
|
|
|
|
|
|
PLAY_SYNCHRONIZED_CAM_ANIM(animCam, iBoxcarCamSyncScene, sBoxcarCam, GET_HOOD_ANIM_DICT_AS_STRING(H_ANIM_DICT_FIND))
|
|
SET_SYNCHRONIZED_SCENE_HOLD_LAST_FRAME(iBoxcarCamSyncScene, FALSE)
|
|
|
|
ENDPROC
|
|
|
|
CONST_FLOAT GOTO_BOXCAR_HANDLE_OFFSET 1.6//1.7
|
|
CONST_FLOAT GOTO_BOXCAR_SIDE_OFFSET 2.36//2.0
|
|
CONST_FLOAT INITIAL_DOOR_OPEN_PHASE 0.36 //0.0
|
|
|
|
|
|
// handle boxcar doors
|
|
PROC HANDLE_BOXCAR_DOORS()
|
|
INT i,j
|
|
|
|
BOOL bDisplayHelp = FALSE
|
|
|
|
REPEAT NUMBER_BOXCARS i
|
|
REPEAT 2 j
|
|
IF DOES_ENTITY_EXIST(boxcarCarriage[i].boxcarDoor[j].obj)
|
|
SWITCH boxcarCarriage[i].boxcarDoor[j].state
|
|
CASE BOXCAR_DOOR_AWAITING_PLAYER
|
|
IF chopViewCamData.state = CHOP_VIEW_CAM_DISABLED
|
|
|
|
IF boxcarCarriage[i].searchState > CARRIAGE_SEARCH_STATE_NOT_BLIPPED
|
|
IF NOT IS_PED_IN_ANY_VEHICLE(PLAYER_PED_ID())
|
|
AND NOT IS_PHONE_ONSCREEN()
|
|
AND CAN_ADVANCE_MISSION()
|
|
AND NOT bFoundBadGuy
|
|
IF IS_ENTITY_AT_ENTITY(PLAYER_PED_ID(), boxcarCarriage[i].boxcarDoor[j].obj, <<3.7,3.7,LOCATE_SIZE_HEIGHT>>)
|
|
IF NOT (i=2 AND j=0) // disable back one of target carriage
|
|
//AND NOT (i=0 AND j=1)
|
|
VECTOR vPlayerOffset
|
|
vPlayerOffset = GET_OFFSET_FROM_ENTITY_GIVEN_WORLD_COORDS(boxcarCarriage[i].boxcarDoor[j].obj, GET_ENTITY_COORDS(PLAYER_PED_ID()))
|
|
|
|
VEHICLE_INDEX closestVehicle
|
|
closestVehicle = GET_CLOSEST_VEHICLE(GET_ENTITY_COORDS(boxcarCarriage[i].boxcarDoor[j].obj), 3.5, DUMMY_MODEL_FOR_SCRIPT, VEHICLE_SEARCH_FLAG_RETURN_LAW_ENFORCER_VEHICLES | VEHICLE_SEARCH_FLAG_RETURN_MISSION_VEHICLES | VEHICLE_SEARCH_FLAG_RETURN_RANDOM_VEHICLES)
|
|
|
|
//PRINTSTRING("offset = ") PRINTVECTOR(vPlayerOffset) PRINTNL()
|
|
IF vPlayerOffset.y < 0
|
|
AND NOT DOES_ENTITY_EXIST(closestVehicle)
|
|
AND (i <> 0 OR j <> 1 OR vPlayerOffset.x < 0) // disable door if blocked by crane legs
|
|
//
|
|
bDisplayHelp = TRUE
|
|
|
|
IF (IS_CONTROL_JUST_PRESSED(PLAYER_CONTROL, INPUT_CONTEXT)
|
|
AND NOT IS_CONTROL_PRESSED(PLAYER_CONTROL, INPUT_SELECT_WEAPON))
|
|
|
|
#IF IS_DEBUG_BUILD
|
|
OR bDebugForceOpenBoxcar
|
|
#ENDIF
|
|
|
|
VECTOR vGotoOffset
|
|
vGotoOffset = <<0,0,0>>
|
|
FLOAT fGotoHeading
|
|
IF j=0
|
|
vGotoOffset.x = GOTO_BOXCAR_HANDLE_OFFSET
|
|
vGotoOffset.y = GOTO_BOXCAR_SIDE_OFFSET
|
|
fGotoHeading = GET_BOXCAR_ROT(i) - 180 + 6.7
|
|
ELSE
|
|
vGotoOffset.x = -GOTO_BOXCAR_HANDLE_OFFSET
|
|
vGotoOffset.y = -GOTO_BOXCAR_SIDE_OFFSET
|
|
fGotoHeading = GET_BOXCAR_ROT(i) + 6.7
|
|
ENDIF
|
|
|
|
VECTOR vGo
|
|
vGo = GET_OFFSET_FROM_ENTITY_IN_WORLD_COORDS(boxcarCarriage[i].anchorObject, vGotoOffset)
|
|
|
|
SET_PLAYER_CONTROL(PLAYER_ID(), FALSE, SPC_LEAVE_CAMERA_CONTROL_ON)
|
|
|
|
CLEAR_SEQUENCE_TASK(sequence)
|
|
OPEN_SEQUENCE_TASK(sequence)
|
|
TASK_CLEAR_LOOK_AT(NULL)
|
|
PRINTSTRING("speed = ") printfloat(GET_ENTITY_SPEED(PLAYER_PED_ID())) PRINTNL()
|
|
IF GET_ENTITY_SPEED(PLAYER_PED_ID()) > 1.8
|
|
TASK_STAND_STILL(NULL, 1000)
|
|
ENDIF
|
|
//IF IS_PED_RUNNING(PLAYER_PED_ID())
|
|
// PRINTSTRING("STAND STILL 1") PRINTNL()
|
|
// TASK_STAND_STILL(NULL, 1000)
|
|
//ELIF IS_PED_SPRINTING(PLAYER_PED_ID())
|
|
// PRINTSTRING("STAND STILL 2") PRINTNL()
|
|
// TASK_STAND_STILL(NULL, 1200)
|
|
//ENDIF
|
|
|
|
IF (i=0 AND j=1) OR (i=1 AND j=1)
|
|
TASK_GO_STRAIGHT_TO_COORD(NULL, vGo, PEDMOVE_WALK, DEFAULT_TIME_BEFORE_WARP, fGotoHeading)
|
|
ELSE
|
|
TASK_FOLLOW_NAV_MESH_TO_COORD(NULL, vGo, PEDMOVE_WALK, DEFAULT_TIME_BEFORE_WARP, DEFAULT_NAVMESH_RADIUS,ENAV_DEFAULT, fGotoHeading)
|
|
ENDIF
|
|
//TASK_TURN_PED_TO_FACE_COORD(NULL, GET_OFFSET_FROM_ENTITY_IN_WORLD_COORDS(boxcarCarriage[i].anchorObject, <<vGotoOffset.x,0,0>>), 3000)
|
|
CLOSE_SEQUENCE_TASK(sequence)
|
|
TASK_PERFORM_SEQUENCE(PLAYER_PED_ID(), sequence)
|
|
|
|
IF GET_FOLLOW_PED_CAM_VIEW_MODE() = CAM_VIEW_MODE_FIRST_PERSON
|
|
SET_PED_DESIRED_HEADING(PLAYER_PED_ID(), fGotoHeading)
|
|
ENDIF
|
|
|
|
bDisplayHelp = FALSE
|
|
|
|
iBoxcarTriggerTime = GET_GAME_TIMER()
|
|
boxcarCarriage[i].boxcarDoor[j].state = BOXCAR_DOOR_TRIGGERED
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
BREAK
|
|
|
|
CASE BOXCAR_DOOR_TRIGGERED
|
|
DISABLE_CELLPHONE_THIS_FRAME_ONLY()
|
|
|
|
IF GET_FOLLOW_PED_CAM_VIEW_MODE() = CAM_VIEW_MODE_FIRST_PERSON
|
|
// If the player is running the FPS mode force the aiming state
|
|
// to make sure that he faces the door instead of face the next
|
|
// point in the navmesh
|
|
IF NOT GET_PED_CONFIG_FLAG(PLAYER_PED_ID(), PCF_IsAimingGun)
|
|
FORCE_PED_MOTION_STATE(PLAYER_PED_ID(), MS_AIMING)
|
|
ENDIF
|
|
|
|
SET_PED_RESET_FLAG(PLAYER_PED_ID(), PRF_ForcePedToStrafe, TRUE)
|
|
ENDIF
|
|
|
|
SET_PED_MAX_MOVE_BLEND_RATIO(PLAYER_PED_ID(), PEDMOVE_WALK)
|
|
|
|
BOOL bShouldTrigger
|
|
bShouldTrigger = FALSE
|
|
IF GET_SCRIPT_TASK_STATUS(PLAYER_PED_ID(), SCRIPT_TASK_PERFORM_SEQUENCE) = FINISHED_TASK
|
|
OR GET_GAME_TIMER() >= iBoxcarTriggerTime + 21000
|
|
bShouldTrigger = TRUE
|
|
ENDIF
|
|
|
|
IF bShouldTrigger
|
|
FLOAT fGotoHeading
|
|
IF j=0
|
|
fGotoHeading = 180//-96.921
|
|
ELSE
|
|
fGotoHeading = 0//83.079
|
|
ENDIF
|
|
|
|
bShownBoxcarPrompt = TRUE
|
|
IF IS_THIS_PRINT_BEING_DISPLAYED("FC_GOBOX")
|
|
REMOVE_MISSION_TEXT(FALSE, TRUE, FALSE)
|
|
ENDIF
|
|
CLEAR_HELP()
|
|
|
|
IF boxcarCarriage[i].searchState = CARRIAGE_SEARCH_STATE_SEARCHED
|
|
bDoneSearchBoxcarSpeech = TRUE
|
|
bDoneEmptyBoxcarSpeech = TRUE
|
|
ELSE
|
|
bDoneSearchBoxcarSpeech = FALSE
|
|
bDoneEmptyBoxcarSpeech = FALSE
|
|
ENDIF
|
|
|
|
bRestoredBoxcarGameplayCam = FALSE
|
|
bDoneDoorSlideSound = FALSE
|
|
bDoneDoorLimitSound = FALSE
|
|
|
|
bOpenedAnyCarriage = TRUE
|
|
|
|
SET_PLAYER_CONTROL(PLAYER_ID(), FALSE, SPC_LEAVE_CAMERA_CONTROL_ON)
|
|
|
|
TASK_CLEAR_LOOK_AT(PLAYER_PED_ID())
|
|
|
|
boxcarCarriage[i].boxcarDoor[j].state = BOXCAR_DOOR_OPENING
|
|
|
|
SET_PED_STEALTH_MOVEMENT(PLAYER_PED_ID(), FALSE)
|
|
|
|
iSyncScene = CREATE_SYNCHRONIZED_SCENE(<<0,0,0>>, <<0,0,0>>)
|
|
//IF i = 2
|
|
// ATTACH_SYNCHRONIZED_SCENE_TO_ENTITY(iSyncScene, boxcarCarriage[i].anchorObject, -1)
|
|
// SET_SYNCHRONIZED_SCENE_ORIGIN(iSyncScene, <<0,0,GET_BOXCAR_DOOR_Z_MOD(i,j)>>, <<0,0,fGotoHeading>>)
|
|
//ELSE
|
|
vPlayerSyncScenePos = GET_OFFSET_FROM_ENTITY_IN_WORLD_COORDS(PLAYER_PED_ID(), <<1.9, 2.2, -1.0>>)
|
|
vPlayerSyncSceneRot = <<0,0,GET_ENTITY_HEADING(PLAYER_PED_ID()) - 6.650>>
|
|
|
|
vTargetOpenPos = GET_ENTITY_COORDS(boxcarCarriage[i].anchorObject) + <<0,0,GET_BOXCAR_DOOR_Z_MOD(i,j)>>
|
|
vTargetOpenRot = <<0,0,fGotoHeading + GET_BOXCAR_ROT(i)>>
|
|
|
|
SET_SYNCHRONIZED_SCENE_ORIGIN(iSyncScene, vPlayerSyncScenePos, vPlayerSyncSceneRot)
|
|
//ENDIF
|
|
|
|
SET_SYNCHRONIZED_SCENE_HOLD_LAST_FRAME(iSyncScene, FALSE)
|
|
|
|
iDoorSyncScene = CREATE_SYNCHRONIZED_SCENE(<<0,0,0>>, <<0,0,0>>)
|
|
ATTACH_SYNCHRONIZED_SCENE_TO_ENTITY(iDoorSyncScene, boxcarCarriage[i].anchorObject, -1)
|
|
SET_SYNCHRONIZED_SCENE_ORIGIN(iDoorSyncScene, <<0,0,0>>, <<0,0,fGotoHeading>>)
|
|
SET_SYNCHRONIZED_SCENE_HOLD_LAST_FRAME(iDoorSyncScene, FALSE)
|
|
|
|
iHandleSyncScene = CREATE_SYNCHRONIZED_SCENE(<<0,0,0>>, <<0,0,0>>)
|
|
SET_SYNCHRONIZED_SCENE_ORIGIN(iHandleSyncScene, vTargetOpenPos, vTargetOpenRot)
|
|
SET_SYNCHRONIZED_SCENE_HOLD_LAST_FRAME(iHandleSyncScene, FALSE)
|
|
|
|
SET_CURRENT_PED_WEAPON(PLAYER_PED_ID(), WEAPONTYPE_UNARMED, TRUE)
|
|
TASK_SYNCHRONIZED_SCENE(PLAYER_PED_ID(), iSyncScene, GET_HOOD_ANIM_DICT_AS_STRING(H_ANIM_DICT_FIND), "open_train_car_fra", SLOW_BLEND_IN, REALLY_SLOW_BLEND_OUT, SYNCED_SCENE_DONT_INTERRUPT | SYNCED_SCENE_USE_PHYSICS)
|
|
|
|
|
|
|
|
DETACH_ENTITY(boxcarCarriage[i].boxcarDoor[j].obj)
|
|
PLAY_SYNCHRONIZED_ENTITY_ANIM(boxcarCarriage[i].boxcarDoor[j].obj, iDoorSyncScene, "open_train_car_door", GET_HOOD_ANIM_DICT_AS_STRING(H_ANIM_DICT_FIND), SLOW_BLEND_IN)
|
|
//SET_ENTITY_COLLISION(boxcarCarriage[i].boxcarDoor[j].obj, FALSE)
|
|
|
|
DETACH_ENTITY(boxcarCarriage[i].boxcarDoor[j].handleObject)
|
|
FREEZE_ENTITY_POSITION(boxcarCarriage[i].boxcarDoor[j].handleObject, FALSE)
|
|
PLAY_SYNCHRONIZED_ENTITY_ANIM(boxcarCarriage[i].boxcarDoor[j].handleObject, iHandleSyncScene, "open_train_car_handle", GET_HOOD_ANIM_DICT_AS_STRING(H_ANIM_DICT_FIND), INSTANT_BLEND_IN)
|
|
SET_ENTITY_COLLISION(boxcarCarriage[i].boxcarDoor[j].handleObject, FALSE)
|
|
FORCE_ENTITY_AI_AND_ANIMATION_UPDATE(boxcarCarriage[i].boxcarDoor[j].handleObject)
|
|
|
|
//IF i = 2
|
|
// SET_SYNCHRONIZED_SCENE_PHASE(iSyncScene, INITIAL_DOOR_OPEN_PHASE)
|
|
// SET_SYNCHRONIZED_SCENE_PHASE(iDoorSyncScene, INITIAL_DOOR_OPEN_PHASE)
|
|
|
|
// FORCE_ENTITY_AI_AND_ANIMATION_UPDATE(boxcarCarriage[i].boxcarDoor[j].obj)
|
|
// FORCE_PED_AI_AND_ANIMATION_UPDATE(PLAYER_PED_ID())
|
|
//ENDIF
|
|
|
|
//ATTACH_HANDLE_TO_BOXCAR(i,j,77)
|
|
|
|
//DETACH_ENTITY(boxcarCarriage[i].boxcarDoor[j].handleObject)
|
|
//FREEZE_ENTITY_POSITION(boxcarCarriage[i].boxcarDoor[j].handleObject, FALSE)
|
|
//PLAY_SYNCHRONIZED_ENTITY_ANIM(boxcarCarriage[i].boxcarDoor[j].handleObject, iDoorSyncScene, "open_train_car_boxcar", GET_HOOD_ANIM_DICT_AS_STRING(H_ANIM_DICT_FIND), INSTANT_BLEND_IN)
|
|
//SET_ENTITY_COLLISION(boxcarCarriage[i].boxcarDoor[j].handleObject, FALSE)
|
|
|
|
iOpenBoxcarTime = GET_GAME_TIMER()
|
|
ENDIF
|
|
BREAK
|
|
|
|
CASE BOXCAR_DOOR_OPENING
|
|
//PRINTSTRING("HERE1") PRINTNL()
|
|
DISABLE_CELLPHONE_THIS_FRAME_ONLY()
|
|
|
|
IF NOT bRestoredBoxcarGameplayCam
|
|
IF GET_GAME_TIMER() >= iOpenBoxcarTime + 3500
|
|
IF i <> 2
|
|
SET_PLAYER_CONTROL(PLAYER_ID(), TRUE)
|
|
//RENDER_SCRIPT_CAMS(FALSE, FALSE)
|
|
//DISPLAY_HUD(TRUE)
|
|
//DISPLAY_RADAR(TRUE)
|
|
//SET_GAMEPLAY_CAM_RELATIVE_HEADING()
|
|
//SET_GAMEPLAY_CAM_RELATIVE_PITCH()
|
|
bRestoredBoxcarGameplayCam = TRUE
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF IS_SYNCHRONIZED_SCENE_RUNNING(iSyncScene)
|
|
SHIFT_VECTOR_TO_IDEAL_VECTOR(vPlayerSyncScenePos, vTargetOpenPos, SHIFT_POS_SPEED/2)
|
|
SHIFT_VECTOR_TO_IDEAL_VECTOR(vPlayerSyncSceneRot, vTargetOpenRot, SHIFT_ROT_SPEED/2)
|
|
SET_SYNCHRONIZED_SCENE_ORIGIN(iSyncScene, vPlayerSyncScenePos, vPlayerSyncSceneRot)
|
|
|
|
FLOAT fDoorPhase
|
|
fDoorPhase = GET_SYNCHRONIZED_SCENE_PHASE(iSyncScene)
|
|
|
|
IF IS_SYNCHRONIZED_SCENE_RUNNING(iDoorSyncScene)
|
|
SET_SYNCHRONIZED_SCENE_PHASE(iDoorSyncScene, fDoorPhase)
|
|
ENDIF
|
|
IF IS_SYNCHRONIZED_SCENE_RUNNING(iHandleSyncScene)
|
|
SET_SYNCHRONIZED_SCENE_PHASE(iHandleSyncScene, fDoorPhase)
|
|
ENDIF
|
|
|
|
|
|
IF i=2
|
|
IF NOT bDoneBoxcarCutsceneCam
|
|
IF fDoorPhase >= INITIAL_DOOR_OPEN_PHASE
|
|
iBoxcarCamSyncScene = CREATE_SYNCHRONIZED_SCENE(<<0,0,0>>, <<0,0,0>>)
|
|
ATTACH_SYNCHRONIZED_SCENE_TO_ENTITY(iBoxcarCamSyncScene, boxcarCarriage[i].anchorObject, -1)
|
|
SET_SYNCHRONIZED_SCENE_ORIGIN(iBoxcarCamSyncScene, <<0,0,0>>, <<0,0,0>>)
|
|
SET_SYNCHRONIZED_SCENE_HOLD_LAST_FRAME(iBoxcarCamSyncScene, FALSE)
|
|
|
|
CREATE_INSIDE_BOXCAR_CAM(i,j)
|
|
SET_SYNCHRONIZED_SCENE_PHASE(iBoxcarCamSyncScene, 0.273)
|
|
|
|
DISPLAY_RADAR(FALSE)
|
|
DISPLAY_HUD(FALSE)
|
|
RENDER_SCRIPT_CAMS(TRUE, FALSE)
|
|
|
|
bDoneBoxcarCutsceneCam = TRUE
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
|
|
|
|
// sounds
|
|
IF NOT bDoneDoorSlideSound
|
|
IF fDoorPhase >= 0.51
|
|
PLAY_SOUND_FROM_ENTITY(-1, "Boxcar_Door_Slide", boxcarCarriage[i].boxcarDoor[j].obj, "FRANKLIN_0_SOUNDS")
|
|
bDoneDoorSlideSound = TRUE
|
|
ENDIF
|
|
ENDIF
|
|
IF NOT bDoneDoorLimitSound
|
|
IF fDoorPhase >= 0.843
|
|
PLAY_SOUND_FROM_ENTITY(-1, "Boxcar_Door_Limit", boxcarCarriage[i].boxcarDoor[j].obj, "FRANKLIN_0_SOUNDS")
|
|
bDoneDoorLimitSound = TRUE
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
|
|
FLOAT fPhase
|
|
BOOL bIsSceneRunning
|
|
IF i=2
|
|
|
|
IF IS_SYNCHRONIZED_SCENE_RUNNING(iBoxcarCamSyncScene)
|
|
bIsSceneRunning = TRUE
|
|
fPhase = GET_SYNCHRONIZED_SCENE_PHASE(iBoxcarCamSyncScene)
|
|
ELSE
|
|
IF bDoneBoxcarCutsceneCam
|
|
bIsSceneRunning = FALSE
|
|
else
|
|
bIsSceneRunning = TRUE
|
|
ENDIF
|
|
ENDIF
|
|
|
|
ELSE
|
|
IF IS_SYNCHRONIZED_SCENE_RUNNING(iSyncScene)
|
|
bIsSceneRunning = TRUE
|
|
fPhase = GET_SYNCHRONIZED_SCENE_PHASE(iSyncScene)
|
|
ELSE
|
|
bIsSceneRunning = FALSE
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF bIsSceneRunning
|
|
|
|
IF NOT bDoneSearchBoxcarSpeech
|
|
IF fPhase >= 0.3
|
|
bDoneSearchBoxcarSpeech = DO_MISSION_SPEECH("FKN0_ISHE2")
|
|
IF bDoneSearchBoxcarSpeech
|
|
REPLAY_RECORD_BACK_FOR_TIME(1.0, 5.0, REPLAY_IMPORTANCE_HIGHEST)
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF i <> 2
|
|
IF fPhase >= 0.88
|
|
IF NOT bDoneEmptyBoxcarSpeech
|
|
bDoneEmptyBoxcarSpeech = DO_MISSION_SPEECH("FKN0_ISHE3")
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ELSE
|
|
PRINTSTRING("HERE3") PRINTNL()
|
|
FREEZE_ENTITY_POSITION(boxcarCarriage[i].boxcarDoor[j].obj, TRUE)
|
|
SET_ENTITY_COLLISION(boxcarCarriage[i].boxcarDoor[j].obj, TRUE)
|
|
FREEZE_ENTITY_POSITION(boxcarCarriage[i].boxcarDoor[j].handleObject, TRUE)
|
|
SET_ENTITY_COLLISION(boxcarCarriage[i].boxcarDoor[j].handleObject, TRUE)
|
|
boxcarCarriage[i].boxcarDoor[j].state = BOXCAR_DOOR_OPEN
|
|
bRestoredBoxcarGameplayCam = TRUE
|
|
IF i=2
|
|
COMMON_MISSION_CUTSCENE_BLENDOUT()
|
|
ENDIF
|
|
ENDIF
|
|
BREAK
|
|
|
|
CASE BOXCAR_DOOR_OPEN
|
|
BREAK
|
|
ENDSWITCH
|
|
|
|
IF boxcarCarriage[i].boxcarDoor[j].state = BOXCAR_DOOR_TRIGGERED
|
|
OR boxcarCarriage[i].boxcarDoor[j].state = BOXCAR_DOOR_OPENING
|
|
bOpeningBoxcarInProgress = TRUE
|
|
ENDIF
|
|
ENDIF
|
|
ENDREPEAT
|
|
ENDREPEAT
|
|
|
|
|
|
IF bDisplayHelp
|
|
IF NOT IS_THIS_HELP_MESSAGE_BEING_DISPLAYED("FC_BOXHLP")
|
|
PRINT_HELP_FOREVER("FC_BOXHLP")
|
|
ENDIF
|
|
ELSE
|
|
IF IS_THIS_HELP_MESSAGE_BEING_DISPLAYED("FC_BOXHLP")
|
|
CLEAR_HELP(TRUE)
|
|
ENDIF
|
|
ENDIF
|
|
ENDPROC
|
|
|
|
// handle the searching of the boxcars
|
|
PROC HANDLE_BOXCAR_SEARCHING()
|
|
INT i, j
|
|
REPEAT NUMBER_BOXCARS i
|
|
SWITCH boxcarCarriage[i].searchState
|
|
CASE CARRIAGE_SEARCH_STATE_NOT_BLIPPED
|
|
BOOL bDoBlip
|
|
bDoBlip = FALSE
|
|
|
|
IF NOT IS_PED_INJURED(chopPed)
|
|
VECTOR vChopPos
|
|
vChopPos = GET_ENTITY_COORDS(chopPed)
|
|
|
|
IF i<2
|
|
IF IS_ENTITY_AT_COORD(PLAYER_PED_ID(), <<547.56909, -635.45868, 27.41334>>, <<28,28,28>>)
|
|
IF IS_ENTITY_IN_AREA(chopPed, <<534.9, -648.8,-20>>, <<550.8, -620.1, 100>>, FALSE, FALSE)
|
|
OR vChopPos.y < -643.6
|
|
bBlippedFirstBoxcars = TRUE
|
|
bDoBlip = TRUE
|
|
ENDIF
|
|
ENDIF
|
|
ELSE
|
|
IF IS_ENTITY_AT_COORD(PLAYER_PED_ID(), <<522.83582, -691.15991, 23.76571>>, <<40,40,40>>)
|
|
IF chopBehaviourSetpieceStage = CBS_DONE
|
|
IF IS_ENTITY_IN_AREA(chopPed, <<526.3, -685.8,-20>>, <<534.8, -665.1, 100>>, FALSE, FALSE)
|
|
bBlippedSecondBoxcars = TRUE
|
|
bDoBlip = TRUE
|
|
|
|
IF NOT bResetOpenedAnyCarriage
|
|
bShownSwitchToOpenHelp = FALSE
|
|
bOpenedAnyCarriage = FALSE
|
|
bDoneChopGoToTrain = TRUE
|
|
bResetOpenedAnyCarriage = TRUE
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF bDoBlip
|
|
boxcarCarriage[i].blip = CREATE_MISSION_BLIP_FOR_COORD(GET_BOXCAR_POS(i))
|
|
boxcarCarriage[i].searchState = CARRIAGE_SEARCH_STATE_BLIPPED
|
|
ENDIF
|
|
BREAK
|
|
|
|
CASE CARRIAGE_SEARCH_STATE_BLIPPED
|
|
REPEAT 2 j
|
|
IF boxcarCarriage[i].boxcarDoor[j].state >= BOXCAR_DOOR_OPENING
|
|
IF DOES_BLIP_EXIST(boxcarCarriage[i].blip)
|
|
REMOVE_BLIP(boxcarCarriage[i].blip)
|
|
ENDIF
|
|
boxcarCarriage[i].searchState = CARRIAGE_SEARCH_STATE_SEARCHED
|
|
ENDIF
|
|
ENDREPEAT
|
|
BREAK
|
|
|
|
CASE CARRIAGE_SEARCH_STATE_SEARCHED
|
|
BREAK
|
|
ENDSWITCH
|
|
ENDREPEAT
|
|
|
|
|
|
IF NOT bBlippedFirstBoxcars
|
|
|
|
ELSE
|
|
IF NOT bShownBoxcarPrompt
|
|
IF NOT bDoneBoxcarSpeech
|
|
bDoneBoxcarSpeech = DO_MISSION_SPEECH("FKN0_ISHE1")
|
|
ELSE
|
|
IF chopViewCamData.state = CHOP_VIEW_CAM_DISABLED
|
|
bShownBoxcarPrompt = DO_MISSION_GOD_TEXT("FC_GOBOX")
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF bDoneBoxcarSpeech
|
|
IF NOT bShownSwitchToOpenHelp
|
|
IF (chopBehaviourSetpieceStage = CBS_NOT_STARTED OR chopBehaviourSetpieceStage = CBS_DONE OR bBlippedSecondBoxcars)
|
|
AND bDoneChopGoToTrain
|
|
AND NOT bOpenedAnyCarriage
|
|
IF chopViewCamData.state = CHOP_VIEW_CAM_ON_CHOP
|
|
IF bBlippedSecondBoxcars
|
|
OR NOT IS_ANY_CONVERSATION_ONGOING_OR_QUEUED()
|
|
IF DO_MISSION_HELP_TEXT("FC_SWFHLP2", FALSE)
|
|
SET_SELECTOR_PED_HINT(sSelectorPeds, SELECTOR_PED_FRANKLIN, TRUE)
|
|
bShownSwitchToOpenHelp = TRUE
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDPROC
|
|
|
|
PROC LOAD_CHASE_UBER_DATA()
|
|
TrafficCarPos[0] = << 370.608, 148.292, 102.507 >>
|
|
TrafficCarQuatX[0] = -0.006632
|
|
TrafficCarQuatY[0] = 0.014155
|
|
TrafficCarQuatZ[0] = -0.182076
|
|
TrafficCarQuatW[0] = 0.983160
|
|
TrafficCarRecording[0] = 3
|
|
TrafficCarStartime[0] = 6300.000000
|
|
TrafficCarModel[0] = emperor
|
|
|
|
TrafficCarPos[1] = << 331.042, 319.164, 104.564 >>
|
|
TrafficCarQuatX[1] = 0.003140
|
|
TrafficCarQuatY[1] = -0.035098
|
|
TrafficCarQuatZ[1] = 0.793992
|
|
TrafficCarQuatW[1] = -0.606906
|
|
TrafficCarRecording[1] = 6
|
|
TrafficCarStartime[1] = 6900.000000
|
|
TrafficCarModel[1] = emperor
|
|
|
|
TrafficCarPos[2] = << 354.004, 101.885, 101.654 >>
|
|
TrafficCarQuatX[2] = 0.074331
|
|
TrafficCarQuatY[2] = 0.014374
|
|
TrafficCarQuatZ[2] = -0.163023
|
|
TrafficCarQuatW[2] = 0.983713
|
|
TrafficCarRecording[2] = 5
|
|
TrafficCarStartime[2] = 9000.000000
|
|
TrafficCarModel[2] = surfer
|
|
|
|
TrafficCarPos[3] = << 338.717, 94.4636, 99.6961 >>
|
|
TrafficCarQuatX[3] = -0.047298
|
|
TrafficCarQuatY[3] = -0.086009
|
|
TrafficCarQuatZ[3] = 0.979703
|
|
TrafficCarQuatW[3] = 0.174778
|
|
TrafficCarRecording[3] = 4
|
|
TrafficCarStartime[3] = 10800.000000
|
|
TrafficCarModel[3] = surfer
|
|
|
|
TrafficCarPos[6] = <<289.1492, -78.1900, 69.8117>>
|
|
TrafficCarQuatX[6] = -0.0056
|
|
TrafficCarQuatY[6] = 0.0028
|
|
TrafficCarQuatZ[6] = -0.1669 // HERE
|
|
TrafficCarQuatW[6] = 0.9860
|
|
TrafficCarRecording[6] = 9
|
|
TrafficCarStartime[6] = 22029.0000
|
|
TrafficCarModel[6] = surge
|
|
|
|
TrafficCarPos[7] = << 277.135, -76.6118, 69.5846 >>
|
|
TrafficCarQuatX[7] = -0.018861
|
|
TrafficCarQuatY[7] = -0.000088
|
|
TrafficCarQuatZ[7] = 0.983353
|
|
TrafficCarQuatW[7] = 0.180722
|
|
TrafficCarRecording[7] = 10
|
|
TrafficCarStartime[7] = 22491.000000
|
|
TrafficCarModel[7] = emperor
|
|
|
|
TrafficCarPos[8] = << 290.813, -40.5747, 71.6218 >>
|
|
TrafficCarQuatX[8] = -0.031225
|
|
TrafficCarQuatY[8] = -0.068270
|
|
TrafficCarQuatZ[8] = 0.981420
|
|
TrafficCarQuatW[8] = 0.176577
|
|
TrafficCarRecording[8] = 8
|
|
TrafficCarStartime[8] = 22577.000000
|
|
TrafficCarModel[8] = picador
|
|
|
|
TrafficCarPos[9] = <<283.2936, -92.4837, 69.7937>> // HERE
|
|
TrafficCarQuatX[9] = -0.0028
|
|
TrafficCarQuatY[9] = 0.0039
|
|
TrafficCarQuatZ[9] = -0.2089
|
|
TrafficCarQuatW[9] = 0.9779
|
|
TrafficCarRecording[9] = 11
|
|
TrafficCarStartime[9] = 22100.0000
|
|
TrafficCarModel[9] = picador
|
|
|
|
TrafficCarPos[10] = << 260.135, -121.876, 67.5997 >>
|
|
TrafficCarQuatX[10] = -0.032570
|
|
TrafficCarQuatY[10] = -0.065471
|
|
TrafficCarQuatZ[10] = 0.982638
|
|
TrafficCarQuatW[10] = 0.170511
|
|
TrafficCarRecording[10] = 12
|
|
TrafficCarStartime[10] = 22200.000000
|
|
TrafficCarModel[10] = dominator
|
|
|
|
// crossing
|
|
|
|
TrafficCarPos[11] = << 181.29, -208.808, 53.4241 >>
|
|
TrafficCarQuatX[11] = 0.000229
|
|
TrafficCarQuatY[11] = -0.000583
|
|
TrafficCarQuatZ[11] = 0.818823
|
|
TrafficCarQuatW[11] = -0.574044
|
|
TrafficCarRecording[11] = 15
|
|
TrafficCarStartime[11] = 25705.000000
|
|
TrafficCarModel[11] = dominator
|
|
|
|
TrafficCarPos[12] = << 193.856, -218.429, 53.6124 >>
|
|
TrafficCarQuatX[12] = -0.019551
|
|
TrafficCarQuatY[12] = -0.006410
|
|
TrafficCarQuatZ[12] = 0.817768
|
|
TrafficCarQuatW[12] = -0.575179
|
|
TrafficCarRecording[12] = 16
|
|
TrafficCarStartime[12] = 26211.0
|
|
TrafficCarModel[12] = picador
|
|
|
|
TrafficCarPos[13] = << 179.383, -213.776, 53.5721 >>
|
|
TrafficCarQuatX[13] = -0.009170
|
|
TrafficCarQuatY[13] = -0.024153
|
|
TrafficCarQuatZ[13] = 0.815156
|
|
TrafficCarQuatW[13] = -0.578666
|
|
TrafficCarRecording[13] = 18
|
|
TrafficCarStartime[13] = 26100.000000
|
|
TrafficCarModel[13] = emperor
|
|
|
|
TrafficCarPos[14] = << 250.805, -222.757, 53.7297 >>
|
|
TrafficCarQuatX[14] = -0.008553
|
|
TrafficCarQuatY[14] = -0.006151
|
|
TrafficCarQuatZ[14] = 0.578679
|
|
TrafficCarQuatW[14] = 0.815488
|
|
TrafficCarRecording[14] = 13
|
|
TrafficCarStartime[14] = 26500.000000
|
|
TrafficCarModel[14] = issi2
|
|
|
|
TrafficCarPos[15] = << 268.287, -229.843, 53.546 >>
|
|
TrafficCarQuatX[15] = -0.011404
|
|
TrafficCarQuatY[15] = -0.006868
|
|
TrafficCarQuatZ[15] = 0.562785
|
|
TrafficCarQuatW[15] = 0.826496
|
|
TrafficCarRecording[15] = 17
|
|
TrafficCarStartime[15] = 26800.000000
|
|
TrafficCarModel[15] = DUMMY_MODEL_FOR_SCRIPT
|
|
|
|
|
|
// end of crossing
|
|
|
|
TrafficCarPos[20] = << 184.405, -360.884, 43.522 >>
|
|
TrafficCarQuatX[20] = 0.028156
|
|
TrafficCarQuatY[20] = -0.004063
|
|
TrafficCarQuatZ[20] = -0.187644
|
|
TrafficCarQuatW[20] = 0.981825
|
|
TrafficCarRecording[20] = 19
|
|
TrafficCarStartime[20] = 27100.000000
|
|
TrafficCarModel[20] = picador
|
|
|
|
TrafficCarPos[21] = << 149.265, -402.928, 40.8279 >>
|
|
TrafficCarQuatX[21] = -0.016245
|
|
TrafficCarQuatY[21] = -0.006338
|
|
TrafficCarQuatZ[21] = 0.988408
|
|
TrafficCarQuatW[21] = 0.150818
|
|
TrafficCarRecording[21] = 25
|
|
TrafficCarStartime[21] = 30000.000000
|
|
TrafficCarModel[21] = picador
|
|
|
|
TrafficCarPos[22] = << 184.745, -374.707, 42.5835 >>
|
|
TrafficCarQuatX[22] = 0.023113
|
|
TrafficCarQuatY[22] = 0.022802
|
|
TrafficCarQuatZ[22] = -0.207431
|
|
TrafficCarQuatW[22] = 0.977711
|
|
TrafficCarRecording[22] = 22
|
|
TrafficCarStartime[22] = 31000.000000
|
|
TrafficCarModel[22] = emperor
|
|
|
|
TrafficCarPos[23] = << 142.21, -473.939, 42.6967 >>
|
|
TrafficCarQuatX[23] = -0.015556
|
|
TrafficCarQuatY[23] = 0.005188
|
|
TrafficCarQuatZ[23] = -0.163600
|
|
TrafficCarQuatW[23] = 0.986390
|
|
TrafficCarRecording[23] = 27
|
|
TrafficCarStartime[23] = 32500.000000
|
|
TrafficCarModel[23] = ruiner
|
|
|
|
TrafficCarPos[24] = <<163.8123, -430.8667, 40.8155>>
|
|
TrafficCarQuatX[24] = -0.0114
|
|
TrafficCarQuatY[24] = 0.0023
|
|
TrafficCarQuatZ[24] = -0.1527
|
|
TrafficCarQuatW[24] = 0.9882
|
|
TrafficCarRecording[24] = 24
|
|
TrafficCarStartime[24] = 33039.0000
|
|
TrafficCarModel[24] = surge
|
|
|
|
TrafficCarPos[25] = << 141.901, -496.677, 42.9011 >>
|
|
TrafficCarQuatX[25] = -0.008686
|
|
TrafficCarQuatY[25] = 0.008488
|
|
TrafficCarQuatZ[25] = -0.139259
|
|
TrafficCarQuatW[25] = 0.990182
|
|
TrafficCarRecording[25] = 29
|
|
TrafficCarStartime[25] = 34000.000000
|
|
TrafficCarModel[25] = surge
|
|
|
|
TrafficCarPos[27] = << 151.388, -465.998, 41.923 >>
|
|
TrafficCarQuatX[27] = -0.035501
|
|
TrafficCarQuatY[27] = 0.005991
|
|
TrafficCarQuatZ[27] = -0.151597
|
|
TrafficCarQuatW[27] = 0.987786
|
|
TrafficCarRecording[27] = 28
|
|
TrafficCarStartime[27] = 35500.000000
|
|
TrafficCarModel[27] = serrano
|
|
|
|
TrafficCarPos[29] = << 126.577, -495.934, 42.7229 >>
|
|
TrafficCarQuatX[29] = 0.004987
|
|
TrafficCarQuatY[29] = 0.000985
|
|
TrafficCarQuatZ[29] = 0.986378
|
|
TrafficCarQuatW[29] = 0.164417
|
|
TrafficCarRecording[29] = 30
|
|
TrafficCarStartime[29] = 37500.000000
|
|
TrafficCarModel[29] = serrano
|
|
|
|
TrafficCarPos[30] = << 109.107, -551.095, 42.9767 >>
|
|
TrafficCarQuatX[30] = 0.003323
|
|
TrafficCarQuatY[30] = 0.006051
|
|
TrafficCarQuatZ[30] = 0.985997
|
|
TrafficCarQuatW[30] = 0.166621
|
|
TrafficCarRecording[30] = 34
|
|
TrafficCarStartime[30] = 38300.000000
|
|
TrafficCarModel[30] = picador
|
|
|
|
TrafficCarPos[33] = << 138.572, -587.025, 43.6916 >>
|
|
TrafficCarQuatX[33] = -0.009659
|
|
TrafficCarQuatY[33] = -0.014386
|
|
TrafficCarQuatZ[33] = 0.824594
|
|
TrafficCarQuatW[33] = -0.565459
|
|
TrafficCarRecording[33] = 35
|
|
TrafficCarStartime[33] = 40500.000000
|
|
TrafficCarModel[33] = issi2
|
|
|
|
TrafficCarPos[34] = << 231.514, -688.146, 36.2398 >>
|
|
TrafficCarQuatX[34] = 0.034012
|
|
TrafficCarQuatY[34] = 0.021372
|
|
TrafficCarQuatZ[34] = -0.157919
|
|
TrafficCarQuatW[34] = 0.986635
|
|
TrafficCarRecording[34] = 40
|
|
TrafficCarStartime[34] = 44000.000000
|
|
TrafficCarModel[34] = dilettante
|
|
|
|
TrafficCarPos[35] = << 244.913, -595.018, 42.6265 >>
|
|
TrafficCarQuatX[35] = -0.022264
|
|
TrafficCarQuatY[35] = -0.018083
|
|
TrafficCarQuatZ[35] = 0.975585
|
|
TrafficCarQuatW[35] = 0.217742
|
|
TrafficCarRecording[35] = 36
|
|
TrafficCarStartime[35] = 45000.000000
|
|
TrafficCarModel[35] = surge
|
|
|
|
TrafficCarPos[36] = << 232.357, -637.287, 39.5948 >>
|
|
TrafficCarQuatX[36] = -0.007482
|
|
TrafficCarQuatY[36] = -0.045975
|
|
TrafficCarQuatZ[36] = 0.982940
|
|
TrafficCarQuatW[36] = 0.177930
|
|
TrafficCarRecording[36] = 37
|
|
TrafficCarStartime[36] = 45800.000000
|
|
TrafficCarModel[36] = issi2
|
|
|
|
TrafficCarPos[37] = << 190.257, -798.034, 31.049 >>
|
|
TrafficCarQuatX[37] = 0.023148
|
|
TrafficCarQuatY[37] = 0.011794
|
|
TrafficCarQuatZ[37] = -0.181103
|
|
TrafficCarQuatW[37] = 0.983120
|
|
TrafficCarRecording[37] = 41
|
|
TrafficCarStartime[37] = 47700.000000
|
|
TrafficCarModel[37] = ruiner
|
|
|
|
TrafficCarPos[38] = << 185.226, -799.949, 30.9391 >>
|
|
TrafficCarQuatX[38] = 0.009881
|
|
TrafficCarQuatY[38] = -0.000991
|
|
TrafficCarQuatZ[38] = -0.157923
|
|
TrafficCarQuatW[38] = 0.987401
|
|
TrafficCarRecording[38] = 42
|
|
TrafficCarStartime[38] = 47700.000000
|
|
TrafficCarModel[38] = issi2
|
|
|
|
TrafficCarPos[39] = << 209.914, -698.063, 35.545 >>
|
|
TrafficCarQuatX[39] = -0.006113
|
|
TrafficCarQuatY[39] = -0.035622
|
|
TrafficCarQuatZ[39] = 0.983831
|
|
TrafficCarQuatW[39] = 0.175416
|
|
TrafficCarRecording[39] = 38
|
|
TrafficCarStartime[39] = 49000.000000
|
|
TrafficCarModel[39] = surge
|
|
|
|
TrafficCarPos[40] = << 210.827, -712.926, 34.6642 >>
|
|
TrafficCarQuatX[40] = -0.003782
|
|
TrafficCarQuatY[40] = -0.025728
|
|
TrafficCarQuatZ[40] = 0.980536
|
|
TrafficCarQuatW[40] = 0.194608
|
|
TrafficCarRecording[40] = 39
|
|
TrafficCarStartime[40] = 49000.000000
|
|
TrafficCarModel[40] = dilettante
|
|
|
|
TrafficCarPos[41] = << 178.818, -847.36, 30.6204 >>
|
|
TrafficCarQuatX[41] = 0.013997
|
|
TrafficCarQuatY[41] = 0.004302
|
|
TrafficCarQuatZ[41] = -0.155335
|
|
TrafficCarQuatW[41] = 0.987753
|
|
TrafficCarRecording[41] = 44
|
|
TrafficCarStartime[41] = 51000.000000
|
|
TrafficCarModel[41] = ruiner
|
|
|
|
// CHANGE THE UBER TRAILER PROC IF NUMBER CHANGES
|
|
TrafficCarPos[42] = << 389.96, -854.675, 29.5846 >>
|
|
TrafficCarQuatX[42] = 0.005696
|
|
TrafficCarQuatY[42] = 0.002982
|
|
TrafficCarQuatZ[42] = 0.725659
|
|
TrafficCarQuatW[42] = 0.688024
|
|
TrafficCarRecording[42] = 48
|
|
TrafficCarStartime[42] = 51600.000000
|
|
TrafficCarModel[42] = hauler
|
|
|
|
TrafficCarPos[43] = << 146.167, -815.117, 30.7372 >>
|
|
TrafficCarQuatX[43] = 0.000773
|
|
TrafficCarQuatY[43] = -0.001176
|
|
TrafficCarQuatZ[43] = 0.802925
|
|
TrafficCarQuatW[43] = -0.596078
|
|
TrafficCarRecording[43] = 46
|
|
TrafficCarStartime[43] = 52000.000000
|
|
TrafficCarModel[43] = dilettante
|
|
|
|
TrafficCarPos[45] = << 269.023, -847.023, 28.8521 >>
|
|
TrafficCarQuatX[45] = -0.008970
|
|
TrafficCarQuatY[45] = -0.000601
|
|
TrafficCarQuatZ[45] = 0.549913
|
|
TrafficCarQuatW[45] = 0.835174
|
|
TrafficCarRecording[45] = 45
|
|
TrafficCarStartime[45] = 54500.000000
|
|
TrafficCarModel[45] = emperor
|
|
|
|
TrafficCarPos[46] = << 474.185, -848.452, 36.2803 >>
|
|
TrafficCarQuatX[46] = -0.036736
|
|
TrafficCarQuatY[46] = -0.035333
|
|
TrafficCarQuatZ[46] = 0.709033
|
|
TrafficCarQuatW[46] = 0.703331
|
|
TrafficCarRecording[46] = 51
|
|
TrafficCarStartime[46] = 56000.000000
|
|
TrafficCarModel[46] = dilettante
|
|
|
|
TrafficCarPos[48] = << 338.219, -865.494, 28.824 >>
|
|
TrafficCarQuatX[48] = 0.015373
|
|
TrafficCarQuatY[48] = 0.015142
|
|
TrafficCarQuatZ[48] = -0.706160
|
|
TrafficCarQuatW[48] = 0.707723
|
|
TrafficCarRecording[48] = 50
|
|
TrafficCarStartime[48] = 59000.000000
|
|
TrafficCarModel[48] = dilettante
|
|
|
|
// setpieces
|
|
SetpieceCarPos[1] = << 285.644, 159.194, 103.819 >>
|
|
SetpieceCarQuatX[1] = 0.009833
|
|
SetpieceCarQuatY[1] = -0.014362
|
|
SetpieceCarQuatZ[1] = 0.808141
|
|
SetpieceCarQuatW[1] = -0.588732
|
|
SetpieceCarRecording[1] = 7
|
|
SetpieceCarStartime[1] = 14800.000000
|
|
SetPieceCarRecordingSpeed[1] = 1.0
|
|
SetpieceCarModel[1] = emperor
|
|
|
|
SetpieceCarPos[2] = << 443.814, 112.308, 99.295 >>
|
|
SetpieceCarQuatX[2] = 0.017590
|
|
SetpieceCarQuatY[2] = 0.011825
|
|
SetpieceCarQuatZ[2] = 0.579222
|
|
SetpieceCarQuatW[2] = 0.814895
|
|
SetpieceCarRecording[2] = 2
|
|
SetpieceCarStartime[2] = 15500.000000
|
|
SetPieceCarRecordingSpeed[2] = 1.0
|
|
SetpieceCarModel[2] = surge
|
|
|
|
SetpieceCarPos[3] = << 265.923, 167.687, 104.4 >>
|
|
SetpieceCarQuatX[3] = 0.011139
|
|
SetpieceCarQuatY[3] = -0.011657
|
|
SetpieceCarQuatZ[3] = 0.806724
|
|
SetpieceCarQuatW[3] = -0.590708
|
|
SetpieceCarRecording[3] = 14
|
|
SetpieceCarStartime[3] = 16100.000000
|
|
SetPieceCarRecordingSpeed[3] = 0.9
|
|
SetpieceCarModel[3] = surge
|
|
|
|
SetpieceCarPos[4] = << 278.781, -233.142, 53.7075 >>
|
|
SetpieceCarQuatX[4] = -0.001098
|
|
SetpieceCarQuatY[4] = 0.002631
|
|
SetpieceCarQuatZ[4] = 0.574218
|
|
SetpieceCarQuatW[4] = 0.818697
|
|
SetpieceCarRecording[4] = 20
|
|
SetpieceCarStartime[4] = 28500.000000
|
|
SetPieceCarRecordingSpeed[4] = 0.8
|
|
SetpieceCarModel[4] = picador
|
|
|
|
SetpieceCarPos[5] = << 294.562, -239.728, 53.3336 >>
|
|
SetpieceCarQuatX[5] = 0.006082
|
|
SetpieceCarQuatY[5] = 0.003727
|
|
SetpieceCarQuatZ[5] = 0.558519
|
|
SetpieceCarQuatW[5] = 0.829461
|
|
SetpieceCarRecording[5] = 21
|
|
SetpieceCarStartime[5] = 28600.000000
|
|
SetPieceCarRecordingSpeed[5] = 0.8
|
|
SetpieceCarModel[5] = Dominator
|
|
|
|
SetpieceCarPos[6] = << 160.448, -202.345, 53.9951 >>
|
|
SetpieceCarQuatX[6] = 0.006110
|
|
SetpieceCarQuatY[6] = -0.010066
|
|
SetpieceCarQuatZ[6] = 0.799184
|
|
SetpieceCarQuatW[6] = -0.600971
|
|
SetpieceCarRecording[6] = 23
|
|
SetpieceCarStartime[6] = 28300.000000
|
|
SetPieceCarRecordingSpeed[6] = 0.9
|
|
SetpieceCarModel[6] = issi2
|
|
|
|
SetpieceCarPos[7] = << 236.955, -354.8, 43.9326 >>
|
|
SetpieceCarQuatX[7] = -0.012410
|
|
SetpieceCarQuatY[7] = -0.009908
|
|
SetpieceCarQuatZ[7] = 0.575418
|
|
SetpieceCarQuatW[7] = 0.817706
|
|
SetpieceCarRecording[7] = 26
|
|
SetpieceCarStartime[7] = 32500.000000
|
|
SetPieceCarRecordingSpeed[7] = 0.9
|
|
SetpieceCarModel[7] = emperor
|
|
|
|
SetpieceCarPos[8] = << 243.385, -350.767, 44.1248 >>
|
|
SetpieceCarQuatX[8] = -0.011465
|
|
SetpieceCarQuatY[8] = 0.013013
|
|
SetpieceCarQuatZ[8] = 0.588918
|
|
SetpieceCarQuatW[8] = 0.808007
|
|
SetpieceCarRecording[8] = 31
|
|
SetpieceCarStartime[8] = 33500.000000
|
|
SetPieceCarRecordingSpeed[8] = 0.9
|
|
SetpieceCarModel[8] = ruiner
|
|
|
|
SetpieceCarPos[9] = << 113.611, -316.672, 45.3552 >>
|
|
SetpieceCarQuatX[9] = 0.008460
|
|
SetpieceCarQuatY[9] = -0.018241
|
|
SetpieceCarQuatZ[9] = 0.827523
|
|
SetpieceCarQuatW[9] = -0.561072
|
|
SetpieceCarRecording[9] = 32
|
|
SetpieceCarStartime[9] = 32200.000000
|
|
SetPieceCarRecordingSpeed[9] = 0.9
|
|
SetpieceCarModel[9] = surge
|
|
|
|
SetPieceCarPos[10] = << 110.55, -592.478, 44.2156 >>
|
|
SetpieceCarQuatX[10] = -0.007297
|
|
SetpieceCarQuatY[10] = 0.028491
|
|
SetpieceCarQuatZ[10] = -0.184284
|
|
SetpieceCarQuatW[10] = 0.982433
|
|
SetpieceCarRecording[10] = 33
|
|
SetpieceCarStartime[10] = 33300.0
|
|
SetPieceCarRecordingSpeed[10] = 0.0000001
|
|
SetpieceCarModel[10] = hauler
|
|
|
|
SetpieceCarPos[11] = << 105.86, -590.119, 43.7371 >>
|
|
SetpieceCarQuatX[11] = -0.003333
|
|
SetpieceCarQuatY[11] = 0.011106
|
|
SetpieceCarQuatZ[11] = -0.189616
|
|
SetpieceCarQuatW[11] = 0.981790
|
|
SetpieceCarRecording[11] = 49
|
|
SetpieceCarStartime[11] = 33300.000000
|
|
SetPieceCarRecordingSpeed[11] = 0.0000001
|
|
SetpieceCarModel[11] = ruiner
|
|
|
|
SetpieceCarPos[12] = << 498.819, -821.764, 24.9128 >>
|
|
SetpieceCarQuatX[12] = -0.006844
|
|
SetpieceCarQuatY[12] = 0.004888
|
|
SetpieceCarQuatZ[12] = 0.711778
|
|
SetpieceCarQuatW[12] = 0.702352
|
|
SetpieceCarRecording[12] = 53
|
|
SetpieceCarStartime[12] = 58500.000000
|
|
SetPieceCarRecordingSpeed[12] = 1.0
|
|
SetpieceCarModel[12] = BUS
|
|
|
|
SetpieceCarPos[13] = << 457.43, -827.98, 27.4745 >>
|
|
SetpieceCarQuatX[13] = 0.001460
|
|
SetpieceCarQuatY[13] = -0.052743
|
|
SetpieceCarQuatZ[13] = 0.710800
|
|
SetpieceCarQuatW[13] = -0.701412
|
|
SetpieceCarRecording[13] = 52
|
|
SetpieceCarStartime[13] = 65000.000000
|
|
SetPieceCarRecordingSpeed[13] = 1.0
|
|
SetpieceCarModel[13] = bus
|
|
|
|
SetpieceCarPos[14] = << 427.612, -680.204, 29.2124 >>
|
|
SetpieceCarQuatX[14] = 0.009204
|
|
SetpieceCarQuatY[14] = 0.021699
|
|
SetpieceCarQuatZ[14] = -0.705913
|
|
SetpieceCarQuatW[14] = 0.707905
|
|
SetpieceCarRecording[14] = 54
|
|
SetpieceCarStartime[14] = 69570//70100.000000
|
|
SetPieceCarRecordingSpeed[14] = 1.0
|
|
SetpieceCarModel[14] = bus
|
|
|
|
|
|
ENDPROC
|
|
|
|
// set Balla on bike
|
|
PROC SET_BALLA_ON_BIKE()
|
|
IF NOT IS_PED_INJURED(runnerChaseProperties.ped)
|
|
AND IS_VEHICLE_DRIVEABLE(hoodVehicle[HV_BAD_GUY_BIKE])
|
|
//FREEZE_ENTITY_POSITION(runnerChaseProperties.ped, FALSE)
|
|
SET_PED_INTO_VEHICLE(runnerChaseProperties.ped, hoodVehicle[HV_BAD_GUY_BIKE])
|
|
ENDIF
|
|
ENDPROC
|
|
|
|
// set bike to escape
|
|
PROC SET_BIKE_TO_ESCAPE()
|
|
IF IS_VEHICLE_DRIVEABLE(hoodVehicle[HV_BAD_GUY_BIKE])
|
|
IF IS_PLAYBACK_GOING_ON_FOR_VEHICLE(hoodVehicle[HV_BAD_GUY_BIKE])
|
|
STOP_PLAYBACK_RECORDED_VEHICLE(hoodVehicle[HV_BAD_GUY_BIKE])
|
|
ENDIF
|
|
|
|
SET_VEHICLE_ENGINE_ON(hoodVehicle[HV_BAD_GUY_BIKE], TRUE, TRUE)
|
|
START_PLAYBACK_RECORDED_VEHICLE(hoodVehicle[HV_BAD_GUY_BIKE], 001, GET_HOOD_UBER_RECORDING_PREFIX())
|
|
SKIP_TIME_IN_PLAYBACK_RECORDED_VEHICLE(hoodVehicle[HV_BAD_GUY_BIKE], 6500)
|
|
FORCE_PLAYBACK_RECORDED_VEHICLE_UPDATE(hoodVehicle[HV_BAD_GUY_BIKE])
|
|
ENDIF
|
|
ENDPROC
|
|
|
|
// calculate correct time
|
|
PROC HANDLE_CHASE_SPEED(FLOAT fPlaybackTime)
|
|
// should update chase stage
|
|
FLOAT fAdvanceSpeedTime
|
|
SWITCH chaseSpeedStage
|
|
CASE CHASE_SPEED_START
|
|
fAdvanceSpeedTime = 15710
|
|
BREAK
|
|
CASE CHASE_SPEED_ROUND_FIRST_CORNER
|
|
fAdvanceSpeedTime = 20500
|
|
BREAK
|
|
CASE CHASE_SPEED_DOWN_HILL
|
|
fAdvanceSpeedTime = 24900
|
|
BREAK
|
|
CASE CHASE_SPEED_THROUGH_JUNCTION
|
|
fAdvanceSpeedTime = 36000
|
|
BREAK
|
|
CASE CHASE_SPEED_FOR_SHARP_TURN
|
|
fAdvanceSpeedTime = 44100
|
|
BREAK
|
|
CASE CHASE_SPEED_CATCH_BACK_UP
|
|
fAdvanceSpeedTime = 50000
|
|
BREAK
|
|
CASE CHASE_SPEED_UNDER_HIGHWAY
|
|
fAdvanceSpeedTime = 56000
|
|
BREAK
|
|
CASE CHASE_SPEED_TO_ALLEY
|
|
fAdvanceSpeedTime = 64000
|
|
BREAK
|
|
CASE CHASE_SPEED_ALLEY_CORNER
|
|
fAdvanceSpeedTime = 67500
|
|
BREAK
|
|
CASE CHASE_SPEED_IN_ALLEY
|
|
fAdvanceSpeedTime = 99999999
|
|
BREAK
|
|
ENDSWITCH
|
|
|
|
IF fPlaybackTime >= fAdvanceSpeedTime
|
|
chaseSpeedStage = INT_TO_ENUM(CHASE_SPEED_STAGE_ENUM, ENUM_TO_INT(chaseSpeedStage)+1)
|
|
ENDIF
|
|
|
|
FLOAT fDefaultSpeed = 1.0
|
|
FLOAT fMinDist = 10.0
|
|
FLOAT fIdealDist = 25.0
|
|
FLOAT fSlowDownDist = 52.0
|
|
FLOAT fMaxPlaybackSpeed = 2.2
|
|
FLOAT fMinSpeedIfBehind = 0.60
|
|
FLOAT fMinSpeedIfLosingTrigger = 0.45
|
|
|
|
FLOAT fAccel = 0.03
|
|
|
|
SWITCH chaseSpeedStage
|
|
CASE CHASE_SPEED_START
|
|
fMinSpeedIfBehind = 0.60
|
|
fMinSpeedIfLosingTrigger = 0.60
|
|
BREAK
|
|
CASE CHASE_SPEED_ROUND_FIRST_CORNER
|
|
fSlowDownDist = 110.0
|
|
fMinSpeedIfBehind = 0.60
|
|
fMinSpeedIfLosingTrigger = 0.50
|
|
BREAK
|
|
CASE CHASE_SPEED_DOWN_HILL
|
|
|
|
BREAK
|
|
CASE CHASE_SPEED_THROUGH_JUNCTION
|
|
fMinDist = 13.0
|
|
fIdealDist = 35.0
|
|
BREAK
|
|
CASE CHASE_SPEED_FOR_SHARP_TURN
|
|
fMinDist = 15.0
|
|
fIdealDist = 40.0
|
|
BREAK
|
|
CASE CHASE_SPEED_CATCH_BACK_UP
|
|
|
|
BREAK
|
|
CASE CHASE_SPEED_UNDER_HIGHWAY
|
|
|
|
BREAK
|
|
CASE CHASE_SPEED_TO_ALLEY
|
|
|
|
BREAK
|
|
CASE CHASE_SPEED_ALLEY_CORNER
|
|
IF NOT IS_SPECIAL_ABILITY_ACTIVE(PLAYER_ID())
|
|
OR NOT IS_ENTITY_AT_ENTITY(PLAYER_PED_ID(), hoodVehicle[HV_BAD_GUY_BIKE], <<15,15,15>>, false, false)
|
|
fMinDist = 12.0
|
|
fIdealDist = 28.0
|
|
ELSE
|
|
fMinDist = 22.0
|
|
fIdealDist = 28.0
|
|
fMaxPlaybackSpeed = 2.5
|
|
fAccel = 0.1
|
|
ENDIF
|
|
BREAK
|
|
CASE CHASE_SPEED_IN_ALLEY
|
|
IF bSpeedUpBikeInAlley
|
|
VECTOR vBikePos
|
|
vBikePos = GET_ENTITY_COORDS(hoodVehicle[HV_BAD_GUY_BIKE])
|
|
VECTOR vPlayerPos
|
|
vPlayerPos = GET_ENTITY_COORDS(PLAYER_PED_ID())
|
|
IF IS_ENTITY_AT_ENTITY(PLAYER_PED_ID(), hoodVehicle[HV_BAD_GUY_BIKE], <<8,8,8>>, FALSE, FALSE)
|
|
OR vPlayerPos.y > vBikePos.y - 3
|
|
fMinDist = 260.0
|
|
fIdealDist = 300.0
|
|
fSlowDownDist = 550.0
|
|
fMinSpeedIfBehind = 1.0
|
|
fMinSpeedIfLosingTrigger = 1.0
|
|
fMaxPlaybackSpeed = 2.5
|
|
fAccel = 0.2
|
|
ELSE
|
|
fMinDist = 8.0
|
|
fIdealDist = 12.0
|
|
fSlowDownDist = 18.0
|
|
fMinSpeedIfBehind = 0.85
|
|
fMinSpeedIfLosingTrigger = 0.7
|
|
ENDIF
|
|
ELSE
|
|
fMinDist = 0.9
|
|
fIdealDist = 1.0
|
|
fSlowDownDist = 2.0
|
|
fMinSpeedIfBehind = 0.05
|
|
fMinSpeedIfLosingTrigger = 0.05
|
|
ENDIF
|
|
BREAK
|
|
ENDSWITCH
|
|
|
|
// offset
|
|
CONST_FLOAT SPEED_UP_DISTANCE_SIDE 60.0
|
|
VECTOR vOffset = GET_OFFSET_FROM_ENTITY_GIVEN_WORLD_COORDS(hoodVehicle[HV_BAD_GUY_BIKE], GET_ENTITY_COORDS(PLAYER_PED_ID()))
|
|
IF chaseSpeedStage = CHASE_SPEED_THROUGH_JUNCTION
|
|
OR chaseSpeedStage = CHASE_SPEED_FOR_SHARP_TURN
|
|
IF (vOffset.x < -SPEED_UP_DISTANCE_SIDE
|
|
OR vOffset.x > SPEED_UP_DISTANCE_SIDE
|
|
OR vOffset.y > 0)
|
|
AND vOffset.y > -130
|
|
printstring("apply") printnl()
|
|
fMinDist = 260.0
|
|
fIdealDist = 300.0
|
|
fSlowDownDist = 550.0
|
|
fMinSpeedIfBehind = 1.0
|
|
fMinSpeedIfLosingTrigger = 1.0
|
|
fMaxPlaybackSpeed = 2.5
|
|
fAccel = 0.1
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF fPlaybackTime >= 8000
|
|
IF IS_PED_IN_VEHICLE(PLAYER_PED_ID(), hoodVehicle[HV_FRANKLIN_VAN])
|
|
OR fPlaybackTime < 22000
|
|
CALCULATE_DESIRED_PLAYBACK_SPEED_FROM_TRIGGER_CAR(fDesiredSpeed, hoodVehicle[HV_FRANKLIN_VAN], hoodVehicle[HV_BAD_GUY_BIKE],
|
|
|
|
fMinDist, // fClosestDist = 5.0
|
|
fIdealDist, // fIdealDist = 10.0
|
|
fSlowDownDist,// fMaxDist = 50.0
|
|
DEFAULT, // fLosingTriggerDist = 100.0
|
|
DEFAULT, // fMaxDistInFront = 30.0
|
|
fDefaultSpeed, // fDefaultPlaybackSpeed = 1.0
|
|
fMinSpeedIfBehind, // fMinSpeedIfBehind = 0.7
|
|
fMinSpeedIfLosingTrigger, // fMinSpeedIfLosingTrigger = 0.5
|
|
fMaxPlaybackSpeed,// fMaxSpeedIfTooClose = 2.0
|
|
TRUE)
|
|
ELSE
|
|
fDesiredSpeed = 0.75
|
|
ENDIF
|
|
|
|
//printstring("fdesiredspeed = ") printfloat(fDesiredSpeed) printnl()
|
|
|
|
UPDATE_CURRENT_PLAYBACK_SPEED_WITH_SMOOTHING(fCarChaseSpeed, fDesiredSpeed, fAccel)//0.06)
|
|
ELSE
|
|
fCarChaseSpeed = 1.0
|
|
ENDIF
|
|
|
|
//CALCULATE_NEW_PLAYBACK_SPEED_FROM_CHAR(hoodVehicle[HV_BAD_GUY_BIKE], PLAYER_PED_ID(), fCarChaseSpeed, fDefaultSpeed, fMinDist, fIdealDist, fSlowDownDist, fMaxPlaybackSpeed, fAirResistanceMultiplier, fCatchupSpeedMultiplier)
|
|
|
|
//IF GET_DISTANCE_BETWEEN_ENTITIES(hoodVehicle[HV_BAD_GUY_BIKE], PLAYER_PED_ID(), FALSE) < fMegaSpeedDistance
|
|
// fCarChaseSpeed = fCarChaseSpeed +@ fMegaSpeedAccel
|
|
//ELIF fPlaybackTime <= 8000
|
|
// fCarChaseSpeed = 1.0
|
|
//ENDIF
|
|
|
|
//printstring("speed = ") printfloat(fCarChaseSpeed) printnl()
|
|
ENDPROC
|
|
|
|
// move the last player vehicle if at coord
|
|
PROC CLEAR_INIT_POS(VECTOR vCheckPos)
|
|
CLEAR_AREA(vCheckPos, CLEAR_POS_RADIUS, TRUE)
|
|
ENDPROC
|
|
|
|
// set next random speech time
|
|
PROC SET_NEXT_RANDOM_SPEECH_TIME(INT iTime = -1, INT iRandomMin = -1, INT iRandomMax = -1)
|
|
IF iTime >= 0
|
|
// if supplied an argument, set it to that
|
|
iNextRandomSpeechTime = GET_GAME_TIMER() + iTime
|
|
ELSE
|
|
INT iNextTimeMin
|
|
INT iNextTimeMax
|
|
|
|
IF iRandomMin < 0
|
|
iNextTimeMin = MIN_RANDOM_SPEECH_TIME
|
|
ELSE
|
|
iNextTimeMin = iRandomMin
|
|
ENDIF
|
|
|
|
IF iRandomMax < 0
|
|
iNextTimeMax = MAX_RANDOM_SPEECH_TIME
|
|
ELSE
|
|
iNextTimeMax = iRandomMax
|
|
ENDIF
|
|
|
|
iNextRandomSpeechTime = GET_GAME_TIMER() + GET_RANDOM_INT_IN_RANGE(iNextTimeMin, iNextTimeMax)
|
|
ENDIF
|
|
ENDPROC
|
|
|
|
// handle random speech
|
|
PROC DO_RANDOM_SPEECH(STRING sSpeech, INT iNextTime = -1, INT iRandomMin = -1, INT iRandomMax = -1, BOOL bOverrideText = FALSE)
|
|
// initialise next speech time if not yet done so
|
|
IF iNextRandomSpeechTime < 0
|
|
SET_NEXT_RANDOM_SPEECH_TIME()
|
|
ENDIF
|
|
|
|
IF GET_GAME_TIMER() >= iNextRandomSpeechTime
|
|
IF DO_MISSION_SPEECH(sSpeech, bOverrideText)
|
|
IF iNextTime >= 0
|
|
SET_NEXT_RANDOM_SPEECH_TIME(iNextTime)
|
|
ELSE
|
|
SET_NEXT_RANDOM_SPEECH_TIME(-1, iRandomMin, iRandomMax)
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDPROC
|
|
|
|
// handle reaction to run stat increasing while on mission
|
|
PROC HANDLE_REACT_TO_RUN_STAT()
|
|
// help text teaching run stat
|
|
SWITCH runHelpState
|
|
CASE RUN_HELP_STATE_NOT_STARTED
|
|
IF IS_ENTITY_IN_ANGLED_AREA(PLAYER_PED_ID(), <<488.903, -495.385, 23.597>>, <<562.402, -504.983, 26.316>>, 41.0)
|
|
OR currentMissionStage = STAGE_FIND_BAD_GUY
|
|
OR bDoneReactToRunStatSpeech
|
|
IF NOT bRunningCutscene
|
|
IF chopViewCamData.state = CHOP_VIEW_CAM_DISABLED
|
|
IF DO_MISSION_HELP_TEXT("FC_RUNHLP1", FALSE)
|
|
runHelpState = RUN_HELP_PART_2
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
BREAK
|
|
CASE RUN_HELP_PART_2
|
|
IF NOT bRunningCutscene
|
|
IF chopViewCamData.state = CHOP_VIEW_CAM_DISABLED
|
|
IF DO_MISSION_HELP_TEXT("FC_RUNHLP2", FALSE)
|
|
runHelpState = RUN_HELP_STATE_DONE
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
BREAK
|
|
CASE RUN_HELP_STATE_DONE
|
|
BREAK
|
|
ENDSWITCH
|
|
|
|
IF NOT bDoneReactToRunStatSpeech
|
|
IF GET_SP_PLAYER_PED_STAT_VALUE(CHAR_FRANKLIN, PS_STAMINA) > iInitialStaminaValue
|
|
AND NOT bRunningCutscene
|
|
IF DO_MISSION_SPEECH("FKN0_RUNUP")
|
|
SET_NEXT_RANDOM_SPEECH_TIME()
|
|
bDoneReactToRunStatSpeech = TRUE
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDPROC
|
|
|
|
// get string for audio context
|
|
FUNC STRING GET_STRING_FOR_CHOP_AUDIO_CONTEXT(CHOP_AUDIO_CONTEXT_ENUM audioContext)
|
|
SWITCH audioContext
|
|
CASE CHOP_AUDIO_CONTEXT_BARK
|
|
RETURN "BARK"
|
|
BREAK
|
|
CASE CHOP_AUDIO_CONTEXT_GROWL
|
|
RETURN "GROWL"
|
|
BREAK
|
|
CASE CHOP_AUDIO_CONTEXT_ATTACK
|
|
RETURN "ATTACK"
|
|
BREAK
|
|
CASE CHOP_AUDIO_CONTEXT_SNARL
|
|
RETURN "SNARL"
|
|
BREAK
|
|
CASE CHOP_AUDIO_CONTEXT_LICKS_MOUTH
|
|
RETURN "CHOP_LICKS_MOUTH"
|
|
BREAK
|
|
CASE CHOP_AUDIO_CONTEXT_PANT
|
|
RETURN "CHOP_PANT"
|
|
BREAK
|
|
CASE CHOP_AUDIO_CONTEXT_SNIFF
|
|
RETURN "CHOP_SNIFF_SEQ"
|
|
BREAK
|
|
CASE CHOP_AUDIO_CONTEXT_PLAYFUL
|
|
RETURN "CHOP_PLAYFUL"
|
|
BREAK
|
|
CASE CHOP_AUDIO_CONTEXT_WHINE_SHORT
|
|
RETURN "CHOP_WHINE"
|
|
BREAK
|
|
CASE CHOP_AUDIO_CONTEXT_WHINE_LONG
|
|
RETURN "CHOP_LONG_WHINE"
|
|
BREAK
|
|
CASE CHOP_AUDIO_CONTEXT_WHINE_STOP
|
|
RETURN "CHOP_WHINE_STOP"
|
|
BREAK
|
|
ENDSWITCH
|
|
|
|
RETURN ""
|
|
ENDFUNC
|
|
|
|
PROC PLAY_CHOP_AUDIO_CONTEXT(CHOP_AUDIO_CONTEXT_ENUM audioContext)
|
|
IF NOT IS_PED_INJURED(chopPed)
|
|
//PLAY_ANIMAL_VOCALIZATION(chopPed, AUD_ANIMAL_DOG_ROTTWEILER, GET_STRING_FOR_CHOP_AUDIO_CONTEXT(audioContext))
|
|
lastChopAudioContext = audioContext
|
|
//PRINTSTRING("playing chop audio!") PRINTNL()
|
|
ENDIF
|
|
ENDPROC
|
|
|
|
CONST_INT SHORT_NEXT_TIME_MIN 400
|
|
CONST_INT MED_NEXT_TIME_MIN 800
|
|
CONST_INT LONG_NEXT_TIME_MIN 2000
|
|
|
|
CONST_INT SHORT_NEXT_TIME_MAX 700
|
|
CONST_INT MED_NEXT_TIME_MAX 3000
|
|
CONST_INT LONG_NEXT_TIME_MAX 6000
|
|
|
|
// do chop audio
|
|
PROC DO_CHOP_AUDIO(CHOP_AUDIO_STATE_ENUM audioState)
|
|
IF GET_GAME_TIMER() >= iNextChopSoundTime
|
|
INT iNextTimeMin = MED_NEXT_TIME_MIN
|
|
INT iNextTimeMax = MED_NEXT_TIME_MAX
|
|
INT iRandom = GET_RANDOM_INT_IN_RANGE(0,100)
|
|
CHOP_AUDIO_CONTEXT_ENUM audioContext
|
|
|
|
SWITCH audioState
|
|
CASE CHOP_AUDIO_STATE_WALK_TO_VAN
|
|
SWITCH GET_RANDOM_INT_IN_RANGE(0,2)
|
|
CASE 0
|
|
audioContext = CHOP_AUDIO_CONTEXT_BARK
|
|
BREAK
|
|
CASE 1
|
|
audioContext = CHOP_AUDIO_CONTEXT_PANT
|
|
BREAK
|
|
ENDSWITCH
|
|
iNextTimeMin = LONG_NEXT_TIME_MIN
|
|
iNextTimeMax = LONG_NEXT_TIME_MAX
|
|
BREAK
|
|
|
|
CASE CHOP_AUDIO_STATE_IN_VAN_PLACID
|
|
IF iRandom >= 90
|
|
audioContext = CHOP_AUDIO_CONTEXT_LICKS_MOUTH
|
|
ELIF iRandom >= 70
|
|
audioContext = CHOP_AUDIO_CONTEXT_PLAYFUL
|
|
ELIF iRandom >= 40
|
|
audioContext = CHOP_AUDIO_CONTEXT_BARK
|
|
ELSE
|
|
audioContext = CHOP_AUDIO_CONTEXT_PANT
|
|
ENDIF
|
|
iNextTimeMin = LONG_NEXT_TIME_MIN
|
|
iNextTimeMax = LONG_NEXT_TIME_MAX - 500
|
|
BREAK
|
|
|
|
CASE CHOP_AUDIO_STATE_IN_VAN_AGITATED
|
|
IF lastChopAudioContext = CHOP_AUDIO_CONTEXT_WHINE_SHORT
|
|
OR lastChopAudioContext = CHOP_AUDIO_CONTEXT_WHINE_LONG
|
|
IF iRandom >= 80
|
|
audioContext = CHOP_AUDIO_CONTEXT_WHINE_STOP
|
|
ELIF iRandom <= 20
|
|
audioContext = CHOP_AUDIO_CONTEXT_WHINE_LONG
|
|
iNextTimeMin = SHORT_NEXT_TIME_MIN
|
|
iNextTimeMax = SHORT_NEXT_TIME_MAX
|
|
ELSE
|
|
audioContext = CHOP_AUDIO_CONTEXT_WHINE_SHORT
|
|
iNextTimeMin = SHORT_NEXT_TIME_MIN
|
|
iNextTimeMax = SHORT_NEXT_TIME_MAX
|
|
ENDIF
|
|
ELSE
|
|
SWITCH GET_RANDOM_INT_IN_RANGE(0,4)
|
|
CASE 0
|
|
audioContext = CHOP_AUDIO_CONTEXT_BARK
|
|
BREAK
|
|
CASE 1
|
|
audioContext = CHOP_AUDIO_CONTEXT_PANT
|
|
BREAK
|
|
CASE 2
|
|
audioContext = CHOP_AUDIO_CONTEXT_WHINE_SHORT
|
|
iNextTimeMin = SHORT_NEXT_TIME_MIN
|
|
iNextTimeMax = SHORT_NEXT_TIME_MAX
|
|
BREAK
|
|
CASE 3
|
|
audioContext = CHOP_AUDIO_CONTEXT_WHINE_LONG
|
|
iNextTimeMin = SHORT_NEXT_TIME_MIN
|
|
iNextTimeMax = SHORT_NEXT_TIME_MAX
|
|
BREAK
|
|
ENDSWITCH
|
|
ENDIF
|
|
BREAK
|
|
|
|
CASE CHOP_AUDIO_STATE_IN_VAN_GUARDING
|
|
SWITCH GET_RANDOM_INT_IN_RANGE(0,2)
|
|
CASE 0
|
|
audioContext = CHOP_AUDIO_CONTEXT_GROWL
|
|
BREAK
|
|
CASE 1
|
|
audioContext = CHOP_AUDIO_CONTEXT_SNARL
|
|
BREAK
|
|
ENDSWITCH
|
|
BREAK
|
|
|
|
CASE CHOP_AUDIO_STATE_SEARCHING
|
|
audioContext = CHOP_AUDIO_CONTEXT_PANT
|
|
IF chopViewCamData.state = CHOP_VIEW_CAM_ON_CHOP
|
|
OR chopViewCamData.state = CHOP_VIEW_CAM_TO_CHOP
|
|
iNextTimeMin = SHORT_NEXT_TIME_MIN
|
|
iNextTimeMax = SHORT_NEXT_TIME_MAX
|
|
ENDIF
|
|
BREAK
|
|
|
|
CASE CHOP_AUDIO_STATE_RUNNING_TO_HUMP
|
|
SWITCH GET_RANDOM_INT_IN_RANGE(0,2)
|
|
CASE 0
|
|
audioContext = CHOP_AUDIO_CONTEXT_BARK
|
|
BREAK
|
|
CASE 1
|
|
audioContext = CHOP_AUDIO_CONTEXT_PANT
|
|
BREAK
|
|
ENDSWITCH
|
|
IF chopViewCamData.state = CHOP_VIEW_CAM_ON_CHOP
|
|
OR chopViewCamData.state = CHOP_VIEW_CAM_TO_CHOP
|
|
iNextTimeMin = SHORT_NEXT_TIME_MIN
|
|
iNextTimeMax = SHORT_NEXT_TIME_MAX
|
|
ELSE
|
|
iNextTimeMin -= 100
|
|
iNextTimeMax -= 800
|
|
ENDIF
|
|
BREAK
|
|
|
|
CASE CHOP_AUDIO_STATE_HUMPING
|
|
IF lastChopAudioContext = CHOP_AUDIO_CONTEXT_WHINE_SHORT
|
|
OR lastChopAudioContext = CHOP_AUDIO_CONTEXT_WHINE_LONG
|
|
IF iRandom >= 90
|
|
audioContext = CHOP_AUDIO_CONTEXT_WHINE_STOP
|
|
iNextTimeMin = SHORT_NEXT_TIME_MIN
|
|
iNextTimeMax = SHORT_NEXT_TIME_MAX
|
|
ELIF iRandom <= 20
|
|
audioContext = CHOP_AUDIO_CONTEXT_WHINE_LONG
|
|
iNextTimeMin = SHORT_NEXT_TIME_MIN
|
|
iNextTimeMax = SHORT_NEXT_TIME_MAX
|
|
ELSE
|
|
audioContext = CHOP_AUDIO_CONTEXT_WHINE_SHORT
|
|
ENDIF
|
|
ELSE
|
|
SWITCH GET_RANDOM_INT_IN_RANGE(0,3)
|
|
CASE 0
|
|
audioContext = CHOP_AUDIO_CONTEXT_WHINE_SHORT
|
|
iNextTimeMin = SHORT_NEXT_TIME_MIN
|
|
iNextTimeMax = SHORT_NEXT_TIME_MAX
|
|
BREAK
|
|
CASE 1
|
|
audioContext = CHOP_AUDIO_CONTEXT_WHINE_LONG
|
|
iNextTimeMin = SHORT_NEXT_TIME_MIN
|
|
iNextTimeMax = SHORT_NEXT_TIME_MAX
|
|
BREAK
|
|
CASE 2
|
|
audioContext = CHOP_AUDIO_CONTEXT_PLAYFUL
|
|
BREAK
|
|
ENDSWITCH
|
|
ENDIF
|
|
BREAK
|
|
|
|
CASE CHOP_AUDIO_STATE_CHASING
|
|
SWITCH GET_RANDOM_INT_IN_RANGE(0,4)
|
|
CASE 0
|
|
audioContext = CHOP_AUDIO_CONTEXT_BARK
|
|
BREAK
|
|
CASE 1
|
|
audioContext = CHOP_AUDIO_CONTEXT_GROWL
|
|
BREAK
|
|
CASE 2
|
|
audioContext = CHOP_AUDIO_CONTEXT_ATTACK
|
|
BREAK
|
|
CASE 3
|
|
audioContext = CHOP_AUDIO_CONTEXT_SNARL
|
|
BREAK
|
|
ENDSWITCH
|
|
IF chopViewCamData.state = CHOP_VIEW_CAM_ON_CHOP
|
|
OR chopViewCamData.state = CHOP_VIEW_CAM_TO_CHOP
|
|
OR (currentMissionStage = STAGE_FOOT_CHASE AND GET_GAME_TIMER() < iStageStartTime + 6000)
|
|
iNextTimeMin = SHORT_NEXT_TIME_MIN
|
|
iNextTimeMax = SHORT_NEXT_TIME_MAX
|
|
ELSE
|
|
iNextTimeMin -= 100
|
|
iNextTimeMax -= 800
|
|
ENDIF
|
|
BREAK
|
|
|
|
CASE CHOP_AUDIO_STATE_FOUND_SOMETHING
|
|
SWITCH GET_RANDOM_INT_IN_RANGE(0,3)
|
|
CASE 0
|
|
audioContext = CHOP_AUDIO_CONTEXT_BARK
|
|
BREAK
|
|
CASE 1
|
|
audioContext = CHOP_AUDIO_CONTEXT_GROWL
|
|
BREAK
|
|
CASE 2
|
|
audioContext = CHOP_AUDIO_CONTEXT_SNARL
|
|
BREAK
|
|
ENDSWITCH
|
|
iNextTimeMin -= 100
|
|
iNextTimeMax -= 800
|
|
BREAK
|
|
|
|
CASE CHOP_AUDIO_STATE_WAITING
|
|
IF lastChopAudioContext = CHOP_AUDIO_CONTEXT_WHINE_SHORT
|
|
OR lastChopAudioContext = CHOP_AUDIO_CONTEXT_WHINE_LONG
|
|
IF iRandom >= 80
|
|
audioContext = CHOP_AUDIO_CONTEXT_WHINE_STOP
|
|
ELIF iRandom <= 20
|
|
audioContext = CHOP_AUDIO_CONTEXT_WHINE_LONG
|
|
iNextTimeMin = SHORT_NEXT_TIME_MIN
|
|
iNextTimeMax = SHORT_NEXT_TIME_MAX
|
|
ELSE
|
|
audioContext = CHOP_AUDIO_CONTEXT_WHINE_SHORT
|
|
iNextTimeMin = SHORT_NEXT_TIME_MIN
|
|
iNextTimeMax = SHORT_NEXT_TIME_MAX
|
|
ENDIF
|
|
ELSE
|
|
SWITCH GET_RANDOM_INT_IN_RANGE(0,2)
|
|
CASE 0
|
|
audioContext = CHOP_AUDIO_CONTEXT_WHINE_SHORT
|
|
iNextTimeMin = SHORT_NEXT_TIME_MIN
|
|
iNextTimeMax = SHORT_NEXT_TIME_MAX
|
|
BREAK
|
|
CASE 1
|
|
audioContext = CHOP_AUDIO_CONTEXT_WHINE_LONG
|
|
iNextTimeMin = SHORT_NEXT_TIME_MIN
|
|
iNextTimeMax = SHORT_NEXT_TIME_MAX
|
|
BREAK
|
|
ENDSWITCH
|
|
ENDIF
|
|
BREAK
|
|
ENDSWITCH
|
|
|
|
PLAY_CHOP_AUDIO_CONTEXT(audioContext)
|
|
iNextChopSoundTime = GET_GAME_TIMER() + GET_RANDOM_INT_IN_RANGE(iNextTimeMin, iNextTimeMax)
|
|
ENDIF
|
|
ENDPROC
|
|
|
|
|
|
PROC DO_NO_STAMINA_HELP_TEXT
|
|
IF NOT bShownNoStaminaHelp
|
|
//PRINTFLOAT(GET_PLAYER_SPRINT_TIME_REMAINING(PLAYER_ID())) PRINTNL()
|
|
|
|
IF NOT IS_HELP_MESSAGE_BEING_DISPLAYED()
|
|
IF GET_PLAYER_SPRINT_TIME_REMAINING(PLAYER_ID()) <= 5.0
|
|
|
|
BOOL bCanDisplay
|
|
|
|
IF currentMissionStage = STAGE_FOOT_CHASE
|
|
bCanDisplay = TRUE
|
|
ELSE
|
|
IF bShownChopViewHelp
|
|
bCanDisplay = TRUE
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF bCanDisplay
|
|
bShownNoStaminaHelp = DO_MISSION_HELP_TEXT("AM_H_NOSTAM", FALSE)
|
|
IF bShownNoStaminaHelp
|
|
SET_ONE_TIME_HELP_MESSAGE_DISPLAYED(FHM_NO_STAMINA)
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDPROC
|
|
|
|
|
|
CONST_INT CHOP_HELP_TIME 14000
|
|
// do chop cam help
|
|
PROC DO_CHOP_CAM_HELP()
|
|
// chop view help
|
|
IF NOT bShownChopViewHelp
|
|
IF chopViewCamData.state <> CHOP_VIEW_CAM_DISABLED
|
|
bShownChopViewHelp = TRUE
|
|
ELSE
|
|
IF NOT IS_HELP_MESSAGE_BEING_DISPLAYED()
|
|
IF GET_GAME_TIMER() >= iStageStartTime + 5000
|
|
IF DO_MISSION_HELP_TEXT("FC_CHOPHLP", FALSE, CHOP_HELP_TIME)
|
|
SET_CHOP_SELECT_HINT(chopViewCamData, sSelectorPeds, TRUE)
|
|
iShowChopHelpTime = GET_GAME_TIMER()
|
|
bShownChopViewHelp = TRUE
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ELSE
|
|
IF NOT bCancelledChopHint
|
|
IF GET_GAME_TIMER() >= iShowChopHelpTime + CHOP_HELP_TIME
|
|
SET_CHOP_SELECT_HINT(chopViewCamData, sSelectorPeds, FALSE)
|
|
bCancelledChopHint = TRUE
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF chopViewCamData.state >= CHOP_VIEW_CAM_TO_CHOP
|
|
IF IS_THIS_HELP_MESSAGE_BEING_DISPLAYED("FC_CHOPHLP")
|
|
IF GET_GAME_TIMER() >= iClearHelpTime + 500
|
|
CLEAR_HELP(FALSE)
|
|
iClearHelpTime = GET_GAME_TIMER()
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF NOT bShownQuickSwitchHelp
|
|
IF chopViewCamData.state = CHOP_VIEW_CAM_ON_CHOP
|
|
OR chopViewCamData.state = CHOP_VIEW_CAM_DISABLED
|
|
IF NOT bOpeningBoxcarInProgress
|
|
bShownQuickSwitchHelp = DO_MISSION_HELP_TEXT("FC_QSWHLP", FALSE)
|
|
ENDIF
|
|
ENDIF
|
|
ELSE
|
|
IF IS_THIS_HELP_MESSAGE_BEING_DISPLAYED("FC_QSWHLP")
|
|
IF chopViewCamData.state = CHOP_VIEW_CAM_TO_CHOP
|
|
OR chopViewCamData.state = CHOP_VIEW_CAM_TO_PLAYER
|
|
IF GET_GAME_TIMER() >= iClearHelpTime + 500
|
|
CLEAR_HELP(FALSE)
|
|
iClearHelpTime = GET_GAME_TIMER()
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDPROC
|
|
|
|
// draw chop scent
|
|
PROC DRAW_SCENT(BOOL bScentIsHiding)
|
|
BOOL bDoScent
|
|
bDoScent = FALSE
|
|
|
|
IF bScentIsHiding
|
|
IF NOT IS_PED_INJURED(chopPed)
|
|
IF IS_WAYPOINT_PLAYBACK_GOING_ON_FOR_PED(chopPed)
|
|
bDoScent = TRUE
|
|
ENDIF
|
|
ENDIF
|
|
ELSE
|
|
bDoScent = TRUE
|
|
ENDIF
|
|
|
|
IF bDoScent
|
|
IF bScentIsHiding
|
|
INT iProgress
|
|
iProgress = GET_PED_WAYPOINT_PROGRESS(chopPed)
|
|
IF iProgress > iScentWaypoint
|
|
REMOVE_CHOP_SCENT(FALSE)
|
|
|
|
INT iStartWaypoint
|
|
iStartWaypoint = iProgress + 3
|
|
INT iEndWaypoint
|
|
iEndWaypoint = iProgress + 7
|
|
INT iMaxWaypoint
|
|
WAYPOINT_RECORDING_GET_NUM_POINTS("hood8", iMaxWaypoint)
|
|
iMaxWaypoint -= 1
|
|
VECTOR vStart
|
|
VECTOR vEnd
|
|
FLOAT fHeading
|
|
IF iStartWaypoint <= iMaxWaypoint
|
|
AND iEndWaypoint <= iMaxWaypoint
|
|
WAYPOINT_RECORDING_GET_COORD("hood8", iStartWaypoint, vStart)
|
|
WAYPOINT_RECORDING_GET_COORD("hood8", iEndWaypoint, vEnd)
|
|
|
|
fHeading = GET_HEADING_FROM_VECTOR_2D(vEnd.x-vStart.x, vEnd.y-vStart.y) + 90
|
|
scentPTFX = START_PARTICLE_FX_LOOPED_AT_COORD("scr_franklin0_chop_trail", vStart + <<0,0,0.3>>, <<0,0,fHeading>>, 7.0)
|
|
|
|
chopViewCamData.vLastPTFXPos = vStart
|
|
iScentWaypoint = iStartWaypoint
|
|
|
|
// PRINTSTRING("start = ") PRINTINT(iStartWaypoint) PRINTVECTOR(vStart) PRINTNL()
|
|
// PRINTSTRING("end = ") PRINTINT(iEndWaypoint)PRINTVECTOR(vEnd) PRINTNL()
|
|
// PRINTSTRING("heading = ") PRINTFLOAT(fHeading) PRINTNL()
|
|
ELSE
|
|
vStart = <<533.86, -679.24, 25.27>>
|
|
vEnd = <<527.99, -678.71, 24.75>>
|
|
fHeading = GET_HEADING_FROM_VECTOR_2D(vEnd.x-vStart.x, vEnd.y-vStart.y) + 90
|
|
scentPTFX = START_PARTICLE_FX_LOOPED_AT_COORD("scr_franklin0_chop_trail", vStart + <<0,0,0.3>>, <<0,0,fHeading>>, 8.0)
|
|
chopViewCamData.vLastPTFXPos = vStart
|
|
|
|
iScentWaypoint = iMaxWaypoint
|
|
ENDIF
|
|
ENDIF
|
|
ELSE
|
|
// draw on bad guy
|
|
IF NOT bDoneChaseScent
|
|
REMOVE_CHOP_SCENT(TRUE)
|
|
|
|
scentPTFX = START_PARTICLE_FX_LOOPED_ON_PED_BONE("scr_franklin0_chop_trail", runnerChaseProperties.ped, <<0,0,0>>, <<0,0,270>>, BONETAG_SPINE, 5.0)
|
|
|
|
bDoneChaseScent = TRUE
|
|
ENDIF
|
|
ENDIF
|
|
ELSE
|
|
REMOVE_CHOP_SCENT(FALSE)
|
|
ENDIF
|
|
ENDPROC
|
|
|
|
PROC DO_FRANKLIN_FOLLOW_CHOP_ROUTE()
|
|
INT iWaypoint
|
|
WAYPOINT_RECORDING_GET_CLOSEST_WAYPOINT("hood4", GET_ENTITY_COORDS(PLAYER_PED_ID()), iWaypoint)
|
|
// check to see if the waypoint is behind the player
|
|
//VECTOR vWaypointOffset
|
|
VECTOR vWaypointCoord
|
|
VECTOR vPlayerCoord = GET_ENTITY_COORDS(PLAYER_PED_ID())
|
|
WAYPOINT_RECORDING_GET_COORD("hood4", iWaypoint, vWaypointCoord)
|
|
|
|
// add a few waypoints
|
|
INT iNumPoints
|
|
WAYPOINT_RECORDING_GET_NUM_POINTS("hood4", iNumPoints)
|
|
|
|
//PRINTSTRING("iWaypoint orig = ") printint(iWaypoint) printnl()
|
|
|
|
INT iAdjustedWaypoint
|
|
iAdjustedWaypoint = iWaypoint + 5
|
|
|
|
//PRINTSTRING("iAdjustedWaypoint = ") printint(iAdjustedWaypoint) printnl()
|
|
|
|
IF iAdjustedWaypoint >= iNumPoints -1
|
|
iAdjustedWaypoint = iNumPoints -1
|
|
ENDIF
|
|
|
|
BOOL bDontAdjustWaypoint = FALSE
|
|
// check to make sure we're not trying to get to an inaccessible place
|
|
IF vWaypointCoord.z > 27.3
|
|
AND vPlayerCoord.z < 28.1
|
|
iWaypoint = 109
|
|
WAYPOINT_RECORDING_GET_COORD("hood4", iWaypoint, vWaypointCoord)
|
|
bDontAdjustWaypoint = TRUE
|
|
ELIF (iWaypoint >= 242 AND iWaypoint <= 248)
|
|
iWaypoint = 245
|
|
bDontAdjustWaypoint = TRUE
|
|
ELIF (iWaypoint >= 72 AND iWaypoint <= 79)
|
|
iWaypoint = 76
|
|
bDontAdjustWaypoint = TRUE
|
|
ELIF (iWaypoint >= 225 AND iWaypoint <= 231)
|
|
iWaypoint = 229
|
|
bDontAdjustWaypoint = TRUE
|
|
ENDIF
|
|
|
|
IF NOT bDontAdjustWaypoint
|
|
iWaypoint = iAdjustedWaypoint
|
|
ENDIF
|
|
|
|
//PRINTSTRING("iWaypoint = ") printint(iWaypoint) printnl()
|
|
|
|
TASK_FOLLOW_WAYPOINT_RECORDING(PLAYER_PED_ID(), "hood4", iWaypoint, EWAYPOINT_DO_NOT_RESPOND_TO_COLLISION_EVENTS | EWAYPOINT_NAVMESH_TO_INITIAL_WAYPOINT | EWAYPOINT_NAVMESH_BACK_TO_WAYPOINT_IF_LEFT_ROUTE)
|
|
ENDPROC
|
|
|
|
PROC HANDLE_FRANKLIN_FOLLOW_CHOP_SEARCH(BOOL bRetask = TRUE)
|
|
IF currentMissionStage = STAGE_FIND_BAD_GUY
|
|
// follow player
|
|
IF NOT IS_PED_INJURED(chopPed)
|
|
IF NOT IS_ENTITY_AT_ENTITY(PLAYER_PED_ID(), chopPed, <<7,7,2>>)//<<2.5,2.5,2>>)
|
|
//taskStatus = GET_SCRIPT_TASK_STATUS(PLAYER_PED_ID(), SCRIPT_TASK_FOLLOW_TO_OFFSET_OF_ENTITY)
|
|
taskStatus = GET_SCRIPT_TASK_STATUS(PLAYER_PED_ID(), SCRIPT_TASK_GO_TO_ENTITY)
|
|
|
|
IF taskStatus = FINISHED_TASK
|
|
IF bRetask
|
|
TASK_GO_TO_ENTITY(PLAYER_PED_ID(), chopPed, DEFAULT_TIME_NEVER_WARP, 6.5)
|
|
ENDIF
|
|
//TASK_FOLLOW_TO_OFFSET_OF_ENTITY(PLAYER_PED_ID(), chopPed, <<0,-5.6,0>>, PEDMOVE_RUN)
|
|
//SET_PED_MIN_MOVE_BLEND_RATIO(PLAYER_PED_ID(), PEDMOVE_RUN)
|
|
ELIF taskStatus = PERFORMING_TASK
|
|
IF IS_ENTITY_AT_ENTITY(PLAYER_PED_ID(), chopPed, <<12,12,12>>, FALSE, FALSE)
|
|
OR ((chopViewCamData.state = CHOP_VIEW_CAM_TO_CHOP OR chopViewCamData.state = CHOP_VIEW_CAM_TO_PLAYER) AND NOT bRunningWhenTriggeredChopCam)
|
|
SET_PED_MAX_MOVE_BLEND_RATIO(PLAYER_PED_ID(), PEDMOVE_WALK)
|
|
ELSE
|
|
SET_PED_MAX_MOVE_BLEND_RATIO(PLAYER_PED_ID(), PEDMOVE_RUN)
|
|
ENDIF
|
|
ENDIF
|
|
ELSE
|
|
IF bRetask
|
|
IF GET_SCRIPT_TASK_STATUS(chopPed, SCRIPT_TASK_TURN_PED_TO_FACE_ENTITY) = FINISHED_TASK
|
|
TASK_TURN_PED_TO_FACE_ENTITY(PLAYER_PED_ID(), chopPed)
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDPROC
|
|
|
|
FUNC BOOL IS_FRANKLIN_AT_FENCE()
|
|
IF IS_ENTITY_AT_COORD(PLAYER_PED_ID(), <<494.57, -516.88, 25.56>>, <<11,11,11>>, FALSE, FALSE)
|
|
RETURN TRUE
|
|
ENDIF
|
|
|
|
RETURN FALSE
|
|
ENDFUNC
|
|
|
|
// handle chop view cam
|
|
PROC HANDLE_CHOP_VIEW_CAM()
|
|
UPDATE_SELECTOR_HUD(sSelectorPeds, chopViewCamData.state <> CHOP_VIEW_CAM_ON_CHOP)
|
|
HANDLE_CHOP_CAM_AUDIO(chopViewCamData)
|
|
HANDLE_CHOP_CAM_HIDOF(chopViewCamData)
|
|
|
|
SWITCH chopViewCamData.state
|
|
CASE CHOP_VIEW_CAM_DISABLED
|
|
IF chopViewCamData.bClearPendingTask
|
|
IF GET_SCRIPT_TASK_STATUS(PLAYER_PED_ID(), SCRIPT_TASK_FOLLOW_TO_OFFSET_OF_ENTITY) <> FINISHED_TASK
|
|
OR GET_SCRIPT_TASK_STATUS(PLAYER_PED_ID(), SCRIPT_TASK_FOLLOW_WAYPOINT_ROUTE) <> FINISHED_TASK
|
|
OR GET_SCRIPT_TASK_STATUS(PLAYER_PED_ID(), SCRIPT_TASK_TURN_PED_TO_FACE_ENTITY) <> FINISHED_TASK
|
|
OR GET_SCRIPT_TASK_STATUS(PLAYER_PED_ID(), SCRIPT_TASK_GO_TO_ENTITY) <> FINISHED_TASK
|
|
IF GET_SCRIPT_TASK_STATUS(PLAYER_PED_ID(), SCRIPT_TASK_FOLLOW_TO_OFFSET_OF_ENTITY) <> WAITING_TO_START_TASK
|
|
AND GET_SCRIPT_TASK_STATUS(PLAYER_PED_ID(), SCRIPT_TASK_FOLLOW_WAYPOINT_ROUTE) <> WAITING_TO_START_TASK
|
|
AND GET_SCRIPT_TASK_STATUS(PLAYER_PED_ID(), SCRIPT_TASK_TURN_PED_TO_FACE_ENTITY) <> WAITING_TO_START_TASK
|
|
AND GET_SCRIPT_TASK_STATUS(PLAYER_PED_ID(), SCRIPT_TASK_GO_TO_ENTITY) <> WAITING_TO_START_TASK
|
|
CLEAR_PED_TASKS(PLAYER_PED_ID())
|
|
chopViewCamData.bClearPendingTask = FALSE
|
|
ENDIF
|
|
ELSE
|
|
chopViewCamData.bClearPendingTask = FALSE
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF IS_CHOP_SELECTED(chopViewCamData, sSelectorPeds)
|
|
IF currentMissionStage = STAGE_FOOT_CHASE
|
|
OR bGotToTrain
|
|
/*
|
|
FLOAT fMoveBlend
|
|
FLOAT fOffset
|
|
IF currentMissionStage = STAGE_FOOT_CHASE
|
|
fMoveBlend = PEDMOVE_SPRINT
|
|
fOffset = -5
|
|
ELSE
|
|
fMoveBlend = PEDMOVE_RUN
|
|
fOffset = -2
|
|
ENDIF
|
|
*/
|
|
IF currentMissionStage = STAGE_FOOT_CHASE
|
|
IF bSmashedFence
|
|
OR NOT IS_FRANKLIN_AT_FENCE()
|
|
DO_FRANKLIN_FOLLOW_CHOP_ROUTE()
|
|
ENDIF
|
|
ELSE
|
|
//TASK_FOLLOW_TO_OFFSET_OF_ENTITY(PLAYER_PED_ID(), chopPed, <<0,fOffset,0>>, fMoveBlend)
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF IS_PED_RUNNING(PLAYER_PED_ID())
|
|
OR IS_PED_SPRINTING(PLAYER_PED_ID())
|
|
bRunningWhenTriggeredChopCam = TRUE
|
|
ELSE
|
|
bRunningWhenTriggeredChopCam = FALSE
|
|
ENDIF
|
|
|
|
bEnabledCamOnMediumSwitch = FALSE
|
|
SET_CHOP_VIEW_CAM_TO_CHOP(chopViewCamData, TRUE, TRUE, FALSE, FALSE, 2000, TRUE, TRUE, SWITCH_TYPE_SHORT)
|
|
|
|
//SET_CHOP_VIEW_CAM_ON_CHOP(chopViewCamData, sSelectorPeds)
|
|
SET_CHOP_SELECT_HINT(chopViewCamData, sSelectorPeds, FALSE)
|
|
INFORM_MISSION_STATS_OF_INCREMENT(FRA0_SWITCHES)
|
|
//CREATE_CHOP_SWITCH_CAM(CHOP_VIEW_CAM_TO_CHOP)
|
|
|
|
IF currentMissionStage = STAGE_FOOT_CHASE
|
|
IF NOT bDoneChopCamCue
|
|
bDoneChopCamCue = TRIGGER_MUSIC_EVENT("FRA0_SWITCH_1")
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
BREAK
|
|
CASE CHOP_VIEW_CAM_ON_CHOP
|
|
SET_GAMEPLAY_CAM_RELATIVE_HEADING()
|
|
SET_GAMEPLAY_CAM_RELATIVE_PITCH()
|
|
IF sSelectorPeds.eNewSelectorPed = SELECTOR_PED_FRANKLIN
|
|
INFORM_MISSION_STATS_SYSTEM_OF_TIME_WINDOW_CLOSED()
|
|
INFORM_MISSION_STATS_OF_INCREMENT(FRA0_SWITCHES)
|
|
bRunningWhenTriggeredChopCam = FALSE
|
|
bDisabledCamOnMediumSwitch = FALSE
|
|
SET_CHOP_VIEW_CAM_TO_PLAYER(chopViewCamData, sSelectorPeds, TRUE, TRUE, TRUE, TRUE, SWITCH_TYPE_SHORT)
|
|
//CREATE_CHOP_SWITCH_CAM(CHOP_VIEW_CAM_TO_PLAYER)
|
|
ELSE
|
|
// handle speed
|
|
IF currentMissionStage = STAGE_FOOT_CHASE
|
|
IF IS_WAYPOINT_PLAYBACK_GOING_ON_FOR_PED(PLAYER_PED_ID())
|
|
WAYPOINT_PLAYBACK_OVERRIDE_SPEED(PLAYER_PED_ID(), PEDMOVE_SPRINT)
|
|
VECTOR vOffset
|
|
VECTOR vPlayerPos
|
|
vPlayerPos = GET_ENTITY_COORDS(PLAYER_PED_ID())
|
|
vOffset = GET_OFFSET_FROM_ENTITY_GIVEN_WORLD_COORDS(chopPed, vPlayerPos)
|
|
IF vOffset.y < -20
|
|
SET_PED_MOVE_RATE_OVERRIDE(PLAYER_PED_ID(), 1.15)
|
|
ENDIF
|
|
|
|
INT iProgress
|
|
VECTOR vProgressCoord
|
|
iProgress = GET_PED_WAYPOINT_PROGRESS(PLAYER_PED_ID())
|
|
WAYPOINT_RECORDING_GET_COORD("hood4", iProgress, vProgressCoord)
|
|
IF vProgressCoord.z > vPlayerPos.z + 3
|
|
OR (iProgress < 100 AND vPlayerPos.y > -560.8)
|
|
OR (iProgress < 106 AND vPlayerPos.y > -554.1)
|
|
DO_FRANKLIN_FOLLOW_CHOP_ROUTE()
|
|
ENDIF
|
|
ELSE
|
|
DO_FRANKLIN_FOLLOW_CHOP_ROUTE()
|
|
ENDIF
|
|
ENDIF
|
|
|
|
HANDLE_FRANKLIN_FOLLOW_CHOP_SEARCH()
|
|
ENDIF
|
|
|
|
// stop player if close to fence
|
|
IF NOT bSmashedFence
|
|
IF GET_SCRIPT_TASK_STATUS(PLAYER_PED_ID(), SCRIPT_TASK_FOLLOW_WAYPOINT_ROUTE) <> FINISHED_TASK
|
|
IF IS_FRANKLIN_AT_FENCE()
|
|
CLEAR_PED_TASKS(PLAYER_PED_ID())
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
BREAK
|
|
CASE CHOP_VIEW_CAM_TO_PLAYER
|
|
//IF NOT IS_CAM_INTERPOLATING(chopSwitchCam)
|
|
|
|
HANDLE_FRANKLIN_FOLLOW_CHOP_SEARCH(false)
|
|
|
|
FAKE_SELECTOR_IS_PLAYER(chopViewCamData, sselectorPeds, FALSE)
|
|
|
|
IF NOT bDisabledCamOnMediumSwitch
|
|
IF IS_PLAYER_SWITCH_IN_PROGRESS()
|
|
IF GET_PLAYER_SWITCH_TYPE() = SWITCH_TYPE_MEDIUM
|
|
IF GET_PLAYER_SWITCH_STATE() >= SWITCH_STATE_PAN
|
|
COMMON_DISABLE_CHOP_VIEW_CAM(chopViewCamData, sSelectorPeds)
|
|
RENDER_SCRIPT_CAMS(FALSE, FALSE)
|
|
bDisabledCamOnMediumSwitch = TRUE
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF NOT IS_PLAYER_SWITCH_IN_PROGRESS()
|
|
SET_CHOP_VIEW_CAM_DISABLED(chopViewCamData, sSelectorPeds, TRUE, TRUE, TRUE, TRUE, FALSE, 1500)
|
|
CLEAR_CONTROL_LIGHT_EFFECT(PLAYER_CONTROL)
|
|
STOP_HOOD_AUDIO_SCENE(HOOD_AUDIO_SCENE_CHOP_CAM)
|
|
INFORM_MISSION_STATS_SYSTEM_OF_TIME_WINDOW_CLOSED()
|
|
ENDIF
|
|
|
|
|
|
//ELSE
|
|
// SET_CAM_COORD(splineCam[iNumberSplineCams-1], GET_GAMEPLAY_CAM_COORD())
|
|
// SET_CAM_ROT(splineCam[iNumberSplineCams-1], GET_GAMEPLAY_CAM_ROT())
|
|
// SET_CAM_FOV(splineCam[iNumberSplineCams-1], GET_GAMEPLAY_CAM_FOV())
|
|
//ENDIF
|
|
BREAK
|
|
CASE CHOP_VIEW_CAM_TO_CHOP
|
|
//IF GET_SCRIPT_TASK_STATUS(PLAYER_PED_ID(), SCRIPT_TASK_FOLLOW_WAYPOINT_ROUTE) <> FINISHED_TASK
|
|
//OR GET_SCRIPT_TASK_STATUS(PLAYER_PED_ID(), SCRIPT_TASK_FOLLOW_TO_OFFSET_OF_ENTITY) <> FINISHED_TASK
|
|
//SET_PED_MIN_MOVE_BLEND_RATIO(PLAYER_PED_ID(), PEDMOVE_RUN)
|
|
//ENDIF
|
|
|
|
FAKE_SELECTOR_IS_PLAYER(chopViewCamData, sselectorPeds, TRUE)
|
|
|
|
HANDLE_FRANKLIN_FOLLOW_CHOP_SEARCH()
|
|
|
|
//IF NOT IS_CAM_INTERPOLATING(chopSwitchCam)
|
|
IF NOT IS_PLAYER_SWITCH_IN_PROGRESS()
|
|
INFORM_MISSION_STATS_SYSTEM_OF_TIME_WINDOW_OPEN(FRA0_DOGCAM)
|
|
SET_CHOP_VIEW_CAM_ON_CHOP(chopViewCamData, sSelectorPeds)
|
|
START_HOOD_AUDIO_SCENE(HOOD_AUDIO_SCENE_CHOP_CAM)
|
|
INT r,g,b,a
|
|
get_hud_colour(HUD_COLOUR_CONTROLLER_CHOP, r, g, b, a)
|
|
SET_CONTROL_LIGHT_EFFECT_COLOR(PLAYER_CONTROL, r, g, b)
|
|
|
|
ELSE
|
|
IF NOT bEnabledCamOnMediumSwitch
|
|
IF GET_PLAYER_SWITCH_TYPE() = SWITCH_TYPE_MEDIUM
|
|
IF GET_PLAYER_SWITCH_STATE() >= SWITCH_STATE_PAN
|
|
SET_CAM_ACTIVE(chopViewCamData.chopCam, TRUE)
|
|
// prevent chop speaking
|
|
IF NOT IS_PED_INJURED(chopViewCamData.chopPed)
|
|
SET_ENTITY_VISIBLE(chopViewCamData.chopPed, FALSE)
|
|
STOP_PED_SPEAKING(chopViewCamData.chopPed, TRUE)
|
|
ENDIF
|
|
RENDER_SCRIPT_CAMS(TRUE, FALSE)
|
|
bEnabledCamOnMediumSwitch = TRUE
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
//ELSE
|
|
// SET_CAM_COORD(splineCam[iNumberSplineCams-1], GET_CAM_COORD(chopViewCamData.chopCam))
|
|
/// SET_CAM_ROT(splineCam[iNumberSplineCams-1], GET_CAM_ROT(chopViewCamData.chopCam))
|
|
// SET_CAM_FOV(splineCam[iNumberSplineCams-1], GET_CAM_FOV(chopViewCamData.chopCam))
|
|
//ENDIF
|
|
BREAK
|
|
ENDSWITCH
|
|
|
|
IF chopViewCamData.state <> CHOP_VIEW_CAM_DISABLED
|
|
IF IS_THIS_PRINT_BEING_DISPLAYED("FC_GOCHOP")
|
|
OR IS_THIS_PRINT_BEING_DISPLAYED("FC_CLOSER")
|
|
//OR IS_THIS_PRINT_BEING_DISPLAYED("FC_GOTRAIN")
|
|
OR IS_THIS_PRINT_BEING_DISPLAYED("FC_GOBOX")
|
|
REMOVE_MISSION_TEXT(FALSE, TRUE, FALSE)
|
|
ENDIF
|
|
|
|
/*
|
|
IF IS_THIS_HELP_MESSAGE_BEING_DISPLAYED("FC_RUNHLP1")
|
|
IF GET_GAME_TIMER() >= iClearHelpTime + 500
|
|
CLEAR_HELP(FALSE)
|
|
iClearHelpTime = GET_GAME_TIMER()
|
|
ENDIF
|
|
ENDIF
|
|
*/
|
|
ENDIF
|
|
|
|
IF chopViewCamData.state <> CHOP_VIEW_CAM_ON_CHOP
|
|
//IF IS_THIS_HELP_MESSAGE_BEING_DISPLAYED("FC_FENHLP")
|
|
IF IS_THIS_HELP_MESSAGE_BEING_DISPLAYED("FC_SWFHLP1")
|
|
OR IS_THIS_HELP_MESSAGE_BEING_DISPLAYED("FC_SWFHLP2")
|
|
IF GET_GAME_TIMER() >= iClearHelpTime + 1000
|
|
CLEAR_HELP(FALSE)
|
|
iClearHelpTime = GET_GAME_TIMER()
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDPROC
|
|
|
|
// ensure he doesn't shoot off halfway through turning
|
|
FUNC BOOL CAN_CHOP_TRANSITION_BACK_FROM_WAIT(BOOL bAllowBreakoutWhileTurned = FALSE)
|
|
BOOL bReturn
|
|
bReturn = FALSE
|
|
|
|
IF IS_ENTITY_PLAYING_ANIM(chopPed, GET_HOOD_ANIM_DICT_AS_STRING(H_ANIM_DICT_SHARED), "FRA0_IG_12_CHOP_WAITING_B")
|
|
FLOAT fPhase
|
|
fPhase = GET_ENTITY_ANIM_CURRENT_TIME(chopPed, GET_HOOD_ANIM_DICT_AS_STRING(H_ANIM_DICT_SHARED), "FRA0_IG_12_CHOP_WAITING_B")
|
|
IF fPhase <= CHOP_TURN_MIN_PHASE
|
|
OR fPhase >= CHOP_TURN_MAX_PHASE
|
|
bReturn = TRUE
|
|
ENDIF
|
|
|
|
IF bAllowBreakoutWhileTurned
|
|
IF fPhase >= 0.408
|
|
AND fPhase <= 0.650
|
|
bReturn = TRUE
|
|
ENDIF
|
|
ENDIF
|
|
ELIF IS_ENTITY_PLAYING_ANIM(chopPed, GET_HOOD_ANIM_DICT_AS_STRING(H_ANIM_DICT_SHARED), "FRA0_IG_12_CHOP_WAITING_A")
|
|
TASK_PLAY_ANIM(chopChaseProperties.ped, GET_HOOD_ANIM_DICT_AS_STRING(H_ANIM_DICT_SHARED), "FRA0_IG_12_CHOP_FAST_TURN_B", NORMAL_BLEND_IN, NORMAL_BLEND_OUT, -1, AF_HOLD_LAST_FRAME) // "FRA0_IG_12_CHOP_RUN_STOP_TURN"
|
|
ELIF IS_ENTITY_PLAYING_ANIM(chopPed, GET_HOOD_ANIM_DICT_AS_STRING(H_ANIM_DICT_SHARED), "FRA0_IG_12_CHOP_FAST_TURN_B")
|
|
IF GET_ENTITY_ANIM_CURRENT_TIME(chopPed, GET_HOOD_ANIM_DICT_AS_STRING(H_ANIM_DICT_SHARED), "FRA0_IG_12_CHOP_FAST_TURN_B") >= 0.98
|
|
bReturn = TRUE
|
|
ENDIF
|
|
ELSE
|
|
bReturn = TRUE
|
|
ENDIF
|
|
|
|
RETURN bReturn
|
|
ENDFUNC
|
|
|
|
// set stage of chop behaviour setpiece
|
|
PROC SET_CHOP_BEHAVIOUR_SETPIECE_STAGE(CHOP_BEHAVIOUR_SETPIECE_STAGE_ENUM newStage)
|
|
IF NOT IS_PED_INJURED(chopPed)
|
|
SWITCH newStage
|
|
CASE CBS_SPOT_COLLIE
|
|
TASK_PLAY_ANIM(chopPed, GET_HOOD_ANIM_DICT_AS_STRING(H_ANIM_DICT_FIND), "FRA_0_IG_15_CHOP_SPOTS_DOG", NORMAL_BLEND_IN, NORMAL_BLEND_OUT)
|
|
bShownBoxcarPrompt = TRUE
|
|
bDoneChopSniffSFX = FALSE
|
|
BREAK
|
|
CASE CBS_WAIT_FOR_FRANKLIN
|
|
TASK_PLAY_ANIM(chopPed, GET_HOOD_ANIM_DICT_AS_STRING(H_ANIM_DICT_SHARED), "FRA0_IG_12_CHOP_WAITING_B", NORMAL_BLEND_IN, NORMAL_BLEND_OUT, -1, AF_LOOPING)
|
|
BREAK
|
|
CASE CBS_GO_TO_COLLIE
|
|
IF NOT IS_PED_INJURED(colliePed)
|
|
CLEAR_SEQUENCE_TASK(sequence)
|
|
OPEN_SEQUENCE_TASK(sequence)
|
|
vHumpEntry = <<502.91777, -648.68180, 23.75121>>//
|
|
TASK_FOLLOW_NAV_MESH_TO_COORD(NULL, <<506.25156, -650.00487, 23.75121>>, PEDMOVE_SPRINT, DEFAULT_TIME_BEFORE_WARP, 10.0, ENAV_DEFAULT, 69.6)
|
|
TASK_FOLLOW_NAV_MESH_TO_COORD(NULL, <<506.25156, -650.00487, 23.75121>>, PEDMOVE_RUN, DEFAULT_TIME_BEFORE_WARP, 1.1, ENAV_DEFAULT, 69.6)
|
|
TASK_FOLLOW_NAV_MESH_TO_COORD(NULL, vHumpEntry, PEDMOVE_WALK, DEFAULT_TIME_BEFORE_WARP, 0.08, ENAV_DEFAULT, 71.1)
|
|
//TASK_PED_SLIDE_TO_COORD(NULL, GET_HOOD_VECTOR(HVEC_CHOP_HUMP_ENTRY), GET_ENTITY_HEADING(colliePed))
|
|
CLOSE_SEQUENCE_TASK(sequence)
|
|
TASK_PERFORM_SEQUENCE(chopPed, sequence)
|
|
|
|
//SET_PED_MIN_MOVE_BLEND_RATIO(chopPed, PEDMOVEBLENDRATIO_SPRINT)
|
|
ENDIF
|
|
BREAK
|
|
CASE CBS_HUMP_AWAY
|
|
//SET_CHOP_VIEW_CAM_THIRD_PERSON(chopViewCamData)
|
|
SET_NEXT_RANDOM_SPEECH_TIME(8000)
|
|
iStartHumpTime = GET_GAME_TIMER()
|
|
BREAK
|
|
CASE CBS_OBEY
|
|
IF IS_THIS_PRINT_BEING_DISPLAYED("FC_CLOSER")
|
|
REMOVE_MISSION_TEXT(FALSE, TRUE, FALSE)
|
|
ENDIF
|
|
INFORM_MISSION_STATS_SYSTEM_OF_TIME_WINDOW_CLOSED()
|
|
BREAK
|
|
CASE CBS_RETURN
|
|
iChopBehaviourHelpTime = GET_GAME_TIMER()
|
|
|
|
INFORM_MISSION_STATS_SYSTEM_OF_TIME_WINDOW_CLOSED()
|
|
|
|
//SET_CHOP_VIEW_CAM_FIRST_PERSON(chopViewCamData)
|
|
IF NOT IS_PED_INJURED(colliePed)
|
|
IF chopBehaviourSetpieceStage >= CBS_HUMP_AWAY
|
|
//TASK_WANDER_STANDARD(colliePed)
|
|
TASK_SMART_FLEE_PED(colliePed, PLAYER_PED_ID(), 1000, -1)
|
|
ENDIF
|
|
ENDIF
|
|
SET_PED_CAN_RAGDOLL(chopPed, TRUE)
|
|
SET_PED_CAN_RAGDOLL_FROM_PLAYER_IMPACT(chopPed, TRUE)
|
|
|
|
CLEAR_SEQUENCE_TASK(sequence)
|
|
OPEN_SEQUENCE_TASK(sequence)
|
|
TASK_FOLLOW_NAV_MESH_TO_COORD(NULL, <<519.48, -657.47, 23.79>>, PEDMOVE_SPRINT, DEFAULT_TIME_BEFORE_WARP, 2.0)
|
|
TASK_FOLLOW_NAV_MESH_TO_COORD(NULL, GET_HOOD_VECTOR(HVEC_CHOP_BEHAVIOUR_SETPIECE_TERMINATE), PEDMOVE_SPRINT, DEFAULT_TIME_BEFORE_WARP, 1.0)
|
|
CLOSE_SEQUENCE_TASK(sequence)
|
|
TASK_PERFORM_SEQUENCE(chopPed, sequence)
|
|
BREAK
|
|
CASE CBS_DONE
|
|
bDoneChopSniffSFX = FALSE
|
|
BREAK
|
|
ENDSWITCH
|
|
|
|
iChopBehaviourStageTime = GET_GAME_TIMER()
|
|
chopBehaviourSetpieceStage = newStage
|
|
ENDIF
|
|
ENDPROC
|
|
|
|
// should we be able to call chop back?
|
|
FUNC BOOL CAN_CALL_CHOP_BACK()
|
|
IF NOT IS_PED_INJURED(chopPed)
|
|
IF IS_ENTITY_AT_ENTITY(PLAYER_PED_ID(), chopPed, <<15,15,8>>)
|
|
OR IS_ENTITY_IN_ANGLED_AREA(PLAYER_PED_ID(), <<514.064, -674.668, 23.392>>, <<521.808, -612.832, 28.734>>, 45.0)
|
|
RETURN TRUE
|
|
ENDIF
|
|
ENDIF
|
|
|
|
RETURN FALSE
|
|
ENDFUNC
|
|
|
|
// call chop back
|
|
PROC HANDLE_CALL_CHOP_BACK()
|
|
IF GET_GAME_TIMER() <= iDidCallbackAnimTime + 4100
|
|
DISABLE_CONTROL_ACTION(PLAYER_CONTROL, INPUT_SPRINT)
|
|
ENDIF
|
|
|
|
SWITCH callChopBackState
|
|
CASE CALL_CHOP_BACK_STATE_NOT_STARTED
|
|
IF CAN_CALL_CHOP_BACK()
|
|
IF IS_CONTROL_JUST_PRESSED(PLAYER_CONTROL, INPUT_CONTEXT)
|
|
AND NOT IS_CONTROL_PRESSED(PLAYER_CONTROL, INPUT_SELECT_WEAPON)
|
|
IF GET_GAME_TIMER() >= iLastCallSpeechTime + 5000
|
|
SWITCH chopBehaviour
|
|
CASE CHOP_BEHAVIOUR_BAD
|
|
bCallChopBackSuccess = FALSE
|
|
BREAK
|
|
CASE CHOP_BEHAVIOUR_MEDIUM
|
|
IF chopBehaviourSetpieceStage >= CBS_HUMP_AWAY
|
|
bCallChopBackSuccess = TRUE
|
|
ELSE
|
|
bCallChopBackSuccess = FALSE
|
|
ENDIF
|
|
BREAK
|
|
CASE CHOP_BEHAVIOUR_GOOD
|
|
bCallChopBackSuccess = TRUE
|
|
BREAK
|
|
ENDSWITCH
|
|
|
|
WEAPON_TYPE weapon
|
|
GET_CURRENT_PED_WEAPON(PLAYER_PED_ID(), weapon)
|
|
|
|
IF IS_PED_FACING_PED(PLAYER_PED_ID(), chopPed, 40)
|
|
AND NOT IS_PED_RUNNING(PLAYER_PED_ID())
|
|
AND NOT IS_PED_SPRINTING(PLAYER_PED_ID())
|
|
AND NOT IS_PED_WALKING(PLAYER_PED_ID())
|
|
AND IS_ENTITY_AT_ENTITY(PLAYER_PED_ID(), chopPed, <<20,20,2>>)
|
|
AND weapon = WEAPONTYPE_UNARMED
|
|
VECTOR vOffset
|
|
vOffset = GET_OFFSET_FROM_ENTITY_GIVEN_WORLD_COORDS(PLAYER_PED_ID(), GET_ENTITY_COORDS(chopPed))
|
|
STRING sAnim
|
|
IF vOffset.x > 0
|
|
sAnim = "Call_Chop_R"
|
|
ELSE
|
|
sAnim = "Call_Chop_L"
|
|
ENDIF
|
|
|
|
TASK_PLAY_ANIM(PLAYER_PED_ID(), GET_HOOD_ANIM_DICT_AS_STRING(H_ANIM_DICT_FIND), sAnim, NORMAL_BLEND_IN, SLOW_BLEND_OUT, -1, AF_UPPERBODY|AF_SECONDARY)
|
|
iDidCallbackAnimTime = GET_GAME_TIMER()
|
|
ENDIF
|
|
|
|
bDoneWhistleSound = FALSE
|
|
callChopBackState = CALL_CHOP_BACK_STATE_QUEUED
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
BREAK
|
|
|
|
CASE CALL_CHOP_BACK_STATE_QUEUED
|
|
IF NOT bDoneWhistleSound
|
|
BOOL bDoWhistle
|
|
bDoWhistle = FALSE
|
|
BOOL bPlayingAnim
|
|
bPlayingAnim = FALSE
|
|
|
|
IF IS_ENTITY_PLAYING_ANIM(PLAYER_PED_ID(), GET_HOOD_ANIM_DICT_AS_STRING(H_ANIM_DICT_FIND), "Call_Chop_R")
|
|
OR IS_ENTITY_PLAYING_ANIM(PLAYER_PED_ID(), GET_HOOD_ANIM_DICT_AS_STRING(H_ANIM_DICT_FIND), "Call_Chop_L")
|
|
bPlayingAnim = TRUE
|
|
ENDIF
|
|
|
|
IF bPlayingAnim
|
|
IF GET_GAME_TIMER() >= iDidCallbackAnimTime + 600
|
|
bDoWhistle = TRUE
|
|
ENDIF
|
|
ELSE
|
|
bDoWhistle = TRUE
|
|
ENDIF
|
|
|
|
IF bDoWhistle
|
|
KILL_FACE_TO_FACE_CONVERSATION_DO_NOT_FINISH_LAST_LINE()
|
|
PLAY_SOUND_FROM_ENTITY(iWhistleSoundID, "Franklin_Whistle_For_Chop", PLAYER_PED_ID(), "SPEECH_RELATED_SOUNDS")
|
|
bDoneWhistleSound = TRUE
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF NOT IS_ANY_CONVERSATION_ONGOING_OR_QUEUED()
|
|
AND HAS_SOUND_FINISHED(iWhistleSoundID)
|
|
AND bDoneWhistleSound
|
|
IF chopHumpState >= CHOP_HUMP_STATE_LOOPING
|
|
IF DO_MISSION_SPEECH("FC_HUMP")
|
|
iNextRandomSpeechTime = GET_GAME_TIMER() + 5000
|
|
ENDIF
|
|
ELSE
|
|
DO_MISSION_SPEECH("FC_WHISTLE")
|
|
ENDIF
|
|
|
|
IF bCallChopBackSuccess
|
|
|
|
REPLAY_RECORD_BACK_FOR_TIME(8.0, 3.0, REPLAY_IMPORTANCE_HIGHEST)
|
|
|
|
callChopBackState = CALL_CHOP_BACK_STATE_SUCCESS
|
|
ELSE
|
|
callChopBackState = CALL_CHOP_BACK_STATE_NOT_STARTED
|
|
ENDIF
|
|
|
|
iLastCallSpeechTime = GET_GAME_TIMER()
|
|
ENDIF
|
|
BREAK
|
|
|
|
CASE CALL_CHOP_BACK_STATE_SUCCESS
|
|
IF GET_GAME_TIMER() >= iLastCallSpeechTime + 800
|
|
IF chopBehaviourSetpieceStage < CBS_HUMP_AWAY
|
|
SET_CHOP_BEHAVIOUR_SETPIECE_STAGE(CBS_RETURN)
|
|
ELSE
|
|
SET_CHOP_BEHAVIOUR_SETPIECE_STAGE(CBS_OBEY)
|
|
ENDIF
|
|
bShouldCommentOnBehaviour = TRUE
|
|
ENDIF
|
|
BREAK
|
|
ENDSWITCH
|
|
ENDPROC
|
|
|
|
PROC DO_GET_BACK_ON_SPEECH()
|
|
IF NOT bDoneGetBackOnSpeech
|
|
IF IS_ENTITY_AT_COORD(chopPed, GET_HOOD_VECTOR(HVEC_CHOP_BEHAVIOUR_SETPIECE_TERMINATE), <<28,28,LOCATE_SIZE_HEIGHT>>, FALSE, FALSE)
|
|
IF DO_MISSION_SPEECH("FC_BACKON")
|
|
bDoneGetBackOnSpeech = TRUE
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDPROC
|
|
|
|
// do the setpiece where chop shows off behaviour
|
|
PROC HANDLE_CHOP_BEHAVIOUR_SETPIECE()
|
|
//printstring("pos = ") printvector(get_entity_coords(chopped)) printnl()
|
|
//printstring("rot = ") printfloat(get_entity_heading(chopped)) printnl()
|
|
|
|
IF NOT IS_PED_INJURED(chopPed)
|
|
// handle the anims
|
|
IF NOT IS_PED_INJURED(colliePed)
|
|
SWITCH chopHumpState
|
|
CASE CHOP_HUMP_STATE_NOT_STARTED
|
|
IF chopBehaviourSetpieceStage = CBS_HUMP_AWAY
|
|
//vHumpPos = GET_OFFSET_FROM_ENTITY_IN_WORLD_COORDS(colliePed, <<0.0, -1.049, -0.45>>)
|
|
//fHumpRot = GET_ENTITY_HEADING(colliePed) + 12.8
|
|
|
|
vHumpPos = GET_ENTITY_COORDS(colliePed) + <<0,0,-0.435374>>
|
|
fHumpRot = GET_ENTITY_HEADING(colliePed)
|
|
|
|
chopChaseProperties.vAnimPos = GET_OFFSET_FROM_ENTITY_IN_WORLD_COORDS(chopPed, <<0.129763, 2.11939,-0.435374>>)
|
|
chopChaseProperties.vAnimRot = GET_ENTITY_ROTATION(chopPed) + <<0,0, 16.033447>>
|
|
|
|
chopChaseProperties.iSyncScene = CREATE_SYNCHRONIZED_SCENE(chopChaseProperties.vAnimPos, chopChaseProperties.vAnimRot)
|
|
iCollieSyncScene = CREATE_SYNCHRONIZED_SCENE(vHumpPos, <<0,0,fHumpRot>>)
|
|
|
|
SET_PED_CAN_RAGDOLL(chopPed, FALSE)
|
|
TASK_SYNCHRONIZED_SCENE(chopPed, chopChaseProperties.iSyncScene, GET_HOOD_ANIM_DICT_AS_STRING(H_ANIM_DICT_FIND), "Hump_enter_chop", NORMAL_BLEND_IN, NORMAL_BLEND_OUT, SYNCED_SCENE_USE_PHYSICS | SYNCED_SCENE_DONT_INTERRUPT)
|
|
TASK_SYNCHRONIZED_SCENE(colliePed, iCollieSyncScene, GET_HOOD_ANIM_DICT_AS_STRING(H_ANIM_DICT_FIND), "Hump_enter_ladydog", NORMAL_BLEND_IN, NORMAL_BLEND_OUT, SYNCED_SCENE_USE_PHYSICS | SYNCED_SCENE_DONT_INTERRUPT)
|
|
SET_SYNCHRONIZED_SCENE_LOOPED(chopChaseProperties.iSyncScene, FALSE)
|
|
SET_SYNCHRONIZED_SCENE_LOOPED(iCollieSyncScene, FALSE)
|
|
|
|
chopHumpState = CHOP_HUMP_STATE_ENTERING
|
|
ENDIF
|
|
BREAK
|
|
CASE CHOP_HUMP_STATE_ENTERING
|
|
//PRINTSTRING("chop pos = ") PRINTVECTOR(GET_ENTITY_COORDS(chopPed)) PRINTNL()
|
|
//PRINTSTRING("collie pos = ") PRINTVECTOR(GET_ENTITY_COORDS(colliePed)) PRINTNL()
|
|
//PRINTSTRING("chop rot = ") PRINTVECTOR(GET_ENTITY_ROTATION(colliePed)) PRINTNL()
|
|
//PRINTSTRING("collie rot = ") PRINTVECTOR(GET_ENTITY_ROTATION(colliePed)) PRINTNL()
|
|
IF NOT bDoneMountCue
|
|
bDoneMountCue = TRIGGER_MUSIC_EVENT("FRA0_MOUNT")
|
|
ENDIF
|
|
|
|
IF GET_SYNCHRONIZED_SCENE_PHASE(chopChaseProperties.iSyncScene) >= 0.98
|
|
PLAY_CHOP_AUDIO_CONTEXT(CHOP_AUDIO_CONTEXT_PLAYFUL)
|
|
chopChaseProperties.iSyncScene = CREATE_SYNCHRONIZED_SCENE(vHumpPos, <<0,0,fHumpRot>>)
|
|
TASK_SYNCHRONIZED_SCENE(chopPed, chopChaseProperties.iSyncScene, GET_HOOD_ANIM_DICT_AS_STRING(H_ANIM_DICT_FIND), "Hump_loop_chop", SLOW_BLEND_IN, NORMAL_BLEND_OUT, SYNCED_SCENE_USE_PHYSICS | SYNCED_SCENE_DONT_INTERRUPT)
|
|
TASK_SYNCHRONIZED_SCENE(colliePed, chopChaseProperties.iSyncScene, GET_HOOD_ANIM_DICT_AS_STRING(H_ANIM_DICT_FIND), "Hump_loop_ladydog", SLOW_BLEND_IN, NORMAL_BLEND_OUT, SYNCED_SCENE_USE_PHYSICS | SYNCED_SCENE_DONT_INTERRUPT)
|
|
SET_SYNCHRONIZED_SCENE_LOOPED(chopChaseProperties.iSyncScene, TRUE)
|
|
INFORM_MISSION_STATS_SYSTEM_OF_TIME_WINDOW_OPEN(FRA0_DOGGY_STYLE)
|
|
chopHumpState = CHOP_HUMP_STATE_LOOPING
|
|
ELSE
|
|
IF GET_SYNCHRONIZED_SCENE_PHASE(chopChaseProperties.iSyncScene) >= 0.69
|
|
// slide chop
|
|
SHIFT_VECTOR_TO_IDEAL_VECTOR(chopChaseProperties.vAnimPos, vHumpPos, 0.1)///5)///5)
|
|
SHIFT_VECTOR_TO_IDEAL_VECTOR(chopChaseProperties.vAnimRot, <<0,0,fHumpRot>>, 5)
|
|
SET_SYNCHRONIZED_SCENE_ORIGIN(chopChaseProperties.iSyncScene, chopChaseProperties.vAnimPos, chopChaseProperties.vAnimRot)
|
|
ENDIF
|
|
ENDIF
|
|
BREAK
|
|
CASE CHOP_HUMP_STATE_LOOPING
|
|
DO_CHOP_AUDIO(CHOP_AUDIO_STATE_HUMPING)
|
|
IF chopBehaviourSetpieceStage = CBS_OBEY
|
|
PLAY_CHOP_AUDIO_CONTEXT(CHOP_AUDIO_CONTEXT_WHINE_STOP)
|
|
chopChaseProperties.iSyncScene = CREATE_SYNCHRONIZED_SCENE(vHumpPos, <<0,0,fHumpRot>>)
|
|
TASK_SYNCHRONIZED_SCENE(chopPed, chopChaseProperties.iSyncScene, GET_HOOD_ANIM_DICT_AS_STRING(H_ANIM_DICT_FIND), "Hump_exit_chop", NORMAL_BLEND_IN, NORMAL_BLEND_OUT, SYNCED_SCENE_USE_PHYSICS | SYNCED_SCENE_DONT_INTERRUPT)
|
|
TASK_SYNCHRONIZED_SCENE(colliePed, chopChaseProperties.iSyncScene, GET_HOOD_ANIM_DICT_AS_STRING(H_ANIM_DICT_FIND), "Hump_exit_ladydog", NORMAL_BLEND_IN, NORMAL_BLEND_OUT, SYNCED_SCENE_USE_PHYSICS | SYNCED_SCENE_DONT_INTERRUPT)
|
|
SET_SYNCHRONIZED_SCENE_LOOPED(chopChaseProperties.iSyncScene, FALSE)
|
|
|
|
IF NOT bDoneDismountCue
|
|
bDoneDismountCue = TRIGGER_MUSIC_EVENT("FRA0_DISMOUNT")
|
|
ENDIF
|
|
|
|
chopHumpState = CHOP_HUMP_STATE_EXITING
|
|
ENDIF
|
|
BREAK
|
|
CASE CHOP_HUMP_STATE_EXITING
|
|
IF GET_SYNCHRONIZED_SCENE_PHASE(chopChaseProperties.iSyncScene) >= 0.98
|
|
SET_PED_CAN_RAGDOLL(chopPed, TRUE)
|
|
chopHumpState = CHOP_HUMP_STATE_DONE
|
|
ENDIF
|
|
BREAK
|
|
ENDSWITCH
|
|
ENDIF
|
|
|
|
SWITCH chopBehaviourSetpieceStage
|
|
CASE CBS_NOT_STARTED
|
|
IF IS_ENTITY_AT_COORD(chopPed, GET_HOOD_VECTOR(HVEC_CHOP_BEHAVIOUR_SETPIECE_LAUNCH), <<1.5, 1.5, LOCATE_SIZE_HEIGHT>>)
|
|
//IF chopBehaviour = CHOP_BEHAVIOUR_GOOD
|
|
IF IS_PED_INJURED(colliePed)
|
|
SET_CHOP_BEHAVIOUR_SETPIECE_STAGE(CBS_DONE)
|
|
ELSE
|
|
SET_CHOP_BEHAVIOUR_SETPIECE_STAGE(CBS_WAIT_FOR_FRANKLIN)
|
|
ENDIF
|
|
ENDIF
|
|
BREAK
|
|
CASE CBS_WAIT_FOR_FRANKLIN
|
|
IF IS_ENTITY_AT_ENTITY(PLAYER_PED_ID(), chopPed, <<8,8,8>>)
|
|
IF CAN_CHOP_TRANSITION_BACK_FROM_WAIT()
|
|
SET_CHOP_BEHAVIOUR_SETPIECE_STAGE(CBS_SPOT_COLLIE)
|
|
ENDIF
|
|
ENDIF
|
|
BREAK
|
|
CASE CBS_SPOT_COLLIE
|
|
IF IS_PED_INJURED(colliePed)
|
|
SET_CHOP_BEHAVIOUR_SETPIECE_STAGE(CBS_RETURN)
|
|
ELSE
|
|
IF NOT IS_ENTITY_PLAYING_ANIM(chopPed, GET_HOOD_ANIM_DICT_AS_STRING(H_ANIM_DICT_FIND), "FRA_0_IG_15_CHOP_SPOTS_DOG")
|
|
SET_CHOP_BEHAVIOUR_SETPIECE_STAGE(CBS_GO_TO_COLLIE)
|
|
ELSE
|
|
FLOAT fLookPhase
|
|
fLookPhase = GET_ENTITY_ANIM_CURRENT_TIME(chopPed, GET_HOOD_ANIM_DICT_AS_STRING(H_ANIM_DICT_FIND), "FRA_0_IG_15_CHOP_SPOTS_DOG")
|
|
IF NOT bDoneChopSniffSFX
|
|
IF fLookPhase >= 0.3
|
|
PLAY_CHOP_AUDIO_CONTEXT(CHOP_AUDIO_CONTEXT_SNIFF)
|
|
bDoneChopSniffSFX = TRUE
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF fLookPhase >= 0.8
|
|
SET_CHOP_BEHAVIOUR_SETPIECE_STAGE(CBS_GO_TO_COLLIE)
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
BREAK
|
|
CASE CBS_GO_TO_COLLIE
|
|
IF NOT bDoneGoToCollieCue
|
|
bDoneGoToCollieCue = TRIGGER_MUSIC_EVENT("FRA0_BOY")
|
|
ENDIF
|
|
|
|
IF IS_PED_INJURED(colliePed)
|
|
SET_CHOP_BEHAVIOUR_SETPIECE_STAGE(CBS_RETURN)
|
|
ELSE
|
|
IF GET_GAME_TIMER() <= iChopBehaviourStageTime + 1500
|
|
//SET_PED_MIN_MOVE_BLEND_RATIO(chopPed, PEDMOVEBLENDRATIO_RUN)
|
|
ENDIF
|
|
IF IS_ENTITY_AT_COORD(chopPed, vHumpEntry, <<0.5, 0.5, LOCATE_SIZE_HEIGHT>>)
|
|
SET_CHOP_BEHAVIOUR_SETPIECE_STAGE(CBS_HUMP_AWAY)
|
|
ELSE
|
|
IF IS_ENTITY_AT_COORD(chopPed, vHumpEntry, <<6, 6, LOCATE_SIZE_HEIGHT>>, FALSE, FALSE)
|
|
SET_PED_RESET_FLAG(chopPed, PRF_UseKinematicPhysics, TRUE)
|
|
SET_PED_CAN_RAGDOLL_FROM_PLAYER_IMPACT(chopPed, FALSE)
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF NOT bDoneWhereGoingSpeech
|
|
DO_CHOP_AUDIO(CHOP_AUDIO_STATE_RUNNING_TO_HUMP)
|
|
IF GET_GAME_TIMER() >= iChopBehaviourStageTime + 2000
|
|
AND NOT bCallChopBackSuccess
|
|
bDoneWhereGoingSpeech = DO_MISSION_SPEECH("FC_WHEREGO")
|
|
ENDIF
|
|
ELSE
|
|
IF NOT bDoneNoChopSpeech
|
|
IF GET_GAME_TIMER() >= iChopBehaviourStageTime + 5000
|
|
IF NOT IS_PED_INJURED(colliePed)
|
|
IF IS_ENTITY_ON_SCREEN(colliePed)
|
|
IF NOT bCallChopBackSuccess
|
|
bDoneNoChopSpeech = DO_MISSION_SPEECH("FC_SEEDOG")
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF bShownCallChopHelp
|
|
IF CAN_ADVANCE_MISSION()
|
|
HANDLE_CALL_CHOP_BACK()
|
|
ENDIF
|
|
ENDIF
|
|
BREAK
|
|
CASE CBS_HUMP_AWAY
|
|
IF NOT bCallChopBackSuccess
|
|
IF IS_ENTITY_AT_ENTITY(PLAYER_PED_ID(), chopPed, <<15,15,2>>)
|
|
IF NOT bDoneItsADudeSpeech
|
|
IF GET_GAME_TIMER() >= iNextRandomSpeechTime
|
|
IF DO_MISSION_SPEECH("FKN0_MALE")
|
|
iNextRandomSpeechTime = GET_GAME_TIMER() + 9000
|
|
bDoneItsADudeSpeech = TRUE
|
|
ENDIF
|
|
ENDIF
|
|
ELSE
|
|
DO_RANDOM_SPEECH("FKN0_WHUMP", -1, 7000, 11000)
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF IS_PED_INJURED(colliePed)
|
|
SET_CHOP_BEHAVIOUR_SETPIECE_STAGE(CBS_RETURN)
|
|
ELSE
|
|
VECTOR vChopPos
|
|
vChopPos = GET_ENTITY_COORDS(chopPed)
|
|
IF HAS_ENTITY_BEEN_DAMAGED_BY_ENTITY(colliePed, PLAYER_PED_ID())
|
|
OR HAS_ENTITY_BEEN_DAMAGED_BY_ENTITY(chopPed, PLAYER_PED_ID())
|
|
OR IS_PED_SHOOTING_IN_AREA(PLAYER_PED_ID(), vChopPos - <<8,8,8>>, vChopPos + <<8,8,8>>, FALSE)
|
|
OR IS_BULLET_IN_AREA(vChopPos, 3.0)
|
|
OR IS_SNIPER_BULLET_IN_AREA(vChopPos - <<3,3,3>>, vChopPos + <<3,3,3>>)
|
|
OR GET_GAME_TIMER() >= iStartHumpTime + 60000
|
|
IF chopBehaviour = CHOP_BEHAVIOUR_BAD
|
|
bShouldCommentOnBehaviour = TRUE
|
|
ENDIF
|
|
SET_CHOP_BEHAVIOUR_SETPIECE_STAGE(CBS_OBEY)
|
|
ELSE
|
|
IF NOT bDoneThreatenChopSpeech
|
|
IF IS_ENTITY_AT_ENTITY(PLAYER_PED_ID(), chopPed, <<18, 18, LOCATE_SIZE_HEIGHT>>)
|
|
AND IS_PED_FACING_PED(PLAYER_PED_ID(), chopPed, 35)
|
|
AND NOT IS_PED_STOPPED(PLAYER_PED_ID())
|
|
AND NOT IS_ENTITY_AT_ENTITY(PLAYER_PED_ID(), chopPed, <<11, 11, LOCATE_SIZE_HEIGHT>>)
|
|
IF NOT bCallChopBackSuccess
|
|
bDoneThreatenChopSpeech = DO_MISSION_SPEECH("FC_RUNOVER")
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF CAN_ADVANCE_MISSION()
|
|
HANDLE_CALL_CHOP_BACK()
|
|
|
|
IF chopBehaviour = CHOP_BEHAVIOUR_BAD
|
|
IF NOT bDoneGoAwaySpeech
|
|
IF GET_GAME_TIMER() >= iChopBehaviourStageTime + 14000
|
|
IF IS_ENTITY_AT_ENTITY(PLAYER_PED_ID(), chopPed, <<2,2,LOCATE_SIZE_HEIGHT>>)
|
|
AND chopViewCamData.state = CHOP_VIEW_CAM_DISABLED
|
|
IF NOT IS_PED_IN_ANY_VEHICLE(PLAYER_PED_ID())
|
|
AND CAN_PLAYER_START_CUTSCENE()
|
|
AND NOT IS_ANY_CONVERSATION_ONGOING_OR_QUEUED()
|
|
bDoingChopPull = TRUE
|
|
bRunningCutscene = TRUE
|
|
ENDIF
|
|
ELSE
|
|
IF NOT bDoneGetClosePrompt
|
|
IF chopViewCamData.state = CHOP_VIEW_CAM_DISABLED
|
|
bDoneGetClosePrompt = DO_MISSION_GOD_TEXT("FC_CLOSER")
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
BREAK
|
|
CASE CBS_OBEY
|
|
IF chopHumpState = CHOP_HUMP_STATE_DONE
|
|
OR IS_PED_INJURED(colliePed)
|
|
SET_CHOP_BEHAVIOUR_SETPIECE_STAGE(CBS_RETURN)
|
|
ENDIF
|
|
BREAK
|
|
CASE CBS_RETURN
|
|
IF bDoneMountCue
|
|
IF NOT bDoneDismountCue
|
|
bDoneDismountCue = TRIGGER_MUSIC_EVENT("FRA0_DISMOUNT")
|
|
ENDIF
|
|
ENDIF
|
|
DO_CHOP_AUDIO(CHOP_AUDIO_STATE_SEARCHING)
|
|
|
|
IF NOT bDoneCommentOnBehaviourSpeech
|
|
IF bShouldCommentOnBehaviour
|
|
SWITCH chopBehaviour
|
|
CASE CHOP_BEHAVIOUR_GOOD
|
|
bDoneCommentOnBehaviourSpeech = DO_MISSION_SPEECH("FKN0_CGOOD")
|
|
BREAK
|
|
CASE CHOP_BEHAVIOUR_MEDIUM
|
|
bDoneCommentOnBehaviourSpeech = DO_MISSION_SPEECH("FKN0_CMED")
|
|
BREAK
|
|
CASE CHOP_BEHAVIOUR_BAD
|
|
bDoneCommentOnBehaviourSpeech = DO_MISSION_SPEECH("FKN0_CBAD")
|
|
BREAK
|
|
ENDSWITCH
|
|
ELSE
|
|
bDoneCommentOnBehaviourSpeech = TRUE
|
|
ENDIF
|
|
ELSE
|
|
DO_GET_BACK_ON_SPEECH()
|
|
ENDIF
|
|
|
|
IF IS_ENTITY_AT_COORD(chopPed, GET_HOOD_VECTOR(HVEC_CHOP_BEHAVIOUR_SETPIECE_TERMINATE), <<4,4,LOCATE_SIZE_HEIGHT>>)
|
|
SET_CHOP_BEHAVIOUR_SETPIECE_STAGE(CBS_DONE)
|
|
SET_NEXT_RANDOM_SPEECH_TIME(3000)
|
|
chopSniffState = CHOP_SNIFF_STATE_NOT_STARTED
|
|
iNextChopSniffTime = GET_GAME_TIMER() + 1000
|
|
iNextChopSoundTime = GET_GAME_TIMER() + GET_RANDOM_INT_IN_RANGE(1000, 3000)
|
|
TASK_FOLLOW_WAYPOINT_RECORDING(chopPed, "hood8", 43, EWAYPOINT_NAVMESH_TO_INITIAL_WAYPOINT | EWAYPOINT_NAVMESH_BACK_TO_WAYPOINT_IF_LEFT_ROUTE)
|
|
ENDIF
|
|
BREAK
|
|
CASE CBS_DONE
|
|
DO_GET_BACK_ON_SPEECH()
|
|
BREAK
|
|
ENDSWITCH
|
|
|
|
// help to download app
|
|
IF NOT bShownChopBehaviourHelp
|
|
IF chopBehaviourSetpieceStage >= CBS_RETURN
|
|
IF NOT HAS_PLAYER_USED_CHOP_APP()
|
|
AND NOT HAS_ONE_TIME_HELP_DISPLAYED(FHM_DOWNLOAD_CHOP_APP)
|
|
IF iChopBehaviourHelpTime > 0
|
|
IF GET_GAME_TIMER() >= iChopBehaviourHelpTime + 1000
|
|
#IF NOT FEATURE_GEN9_STANDALONE // url:bugstar:7806385 App currently not supported in Gen9.
|
|
bShownChopBehaviourHelp = DO_MISSION_HELP_TEXT("FC_APPHLP", FALSE)
|
|
#ENDIF
|
|
#IF FEATURE_GEN9_STANDALONE
|
|
bShownChopBehaviourHelp = TRUE
|
|
#ENDIF
|
|
IF bShownChopBehaviourHelp
|
|
SET_ONE_TIME_HELP_MESSAGE_DISPLAYED(FHM_DOWNLOAD_CHOP_APP)
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ELSE
|
|
bShownChopBehaviourHelp = TRUE
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
|
|
BOOL bDoCallBackHelp = FALSE
|
|
// help to call back
|
|
IF ((chopBehaviourSetpieceStage = CBS_GO_TO_COLLIE AND GET_GAME_TIMER() >= iChopBehaviourStageTime + 2700)
|
|
OR chopBehaviourSetpieceStage = CBS_HUMP_AWAY)
|
|
AND CAN_CALL_CHOP_BACK()
|
|
IF chopViewCamData.state = CHOP_VIEW_CAM_DISABLED
|
|
IF NOT bShownCallChopHelp
|
|
IF NOT IS_HELP_MESSAGE_BEING_DISPLAYED()
|
|
bShownCallChopHelp = TRUE
|
|
iLastCallSpeechTime = 0
|
|
ENDIF
|
|
ELSE
|
|
IF NOT bCallChopBackSuccess
|
|
bDoCallBackHelp = TRUE
|
|
IF NOT IS_HELP_MESSAGE_BEING_DISPLAYED()
|
|
PRINT_HELP_FOREVER("FC_CALLHLP")
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ELIF chopViewCamData.state = CHOP_VIEW_CAM_ON_CHOP
|
|
IF NOT bShownSwitchToCallHelp
|
|
IF DO_MISSION_HELP_TEXT("FC_SWFHLP1", FALSE)
|
|
SET_SELECTOR_PED_HINT(sSelectorPeds, SELECTOR_PED_FRANKLIN, TRUE)
|
|
bShownSwitchToCallHelp = TRUE
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF NOT bDoCallBackHelp
|
|
IF IS_THIS_HELP_MESSAGE_BEING_DISPLAYED("FC_CALLHLP")
|
|
CLEAR_HELP()
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDPROC
|
|
|
|
// handle chop cam warps
|
|
PROC HANDLE_CHOP_CAM_WARPS()
|
|
INT i
|
|
IF NOT IS_PED_INJURED(PLAYER_PED_ID())
|
|
AND NOT IS_PED_INJURED(chopPed)
|
|
VECTOR vChopPos = GET_ENTITY_COORDS(chopPed)
|
|
VECTOR vPlayerPos = GET_ENTITY_COORDS(PLAYER_PED_ID())
|
|
|
|
IF chopViewCamData.state = CHOP_VIEW_CAM_ON_CHOP
|
|
REPEAT COUNT_OF(FRANKLIN_WARP_ENUM) i
|
|
FRANKLIN_WARP_ENUM thisWarpEnum = INT_TO_ENUM(FRANKLIN_WARP_ENUM, i)
|
|
|
|
IF NOT bFranklinWarp[thisWarpEnum]
|
|
VECTOR vWarpPos
|
|
FLOAT fWarpRot
|
|
BOOL bCanDoWarp = FALSE
|
|
|
|
SWITCH thisWarpEnum
|
|
CASE FRANKLIN_WARP_TOP_FENCE
|
|
// details
|
|
vWarpPos = <<483.96, -583.25, 28.35>>
|
|
fWarpRot = -7.2
|
|
|
|
// check
|
|
IF chopStage <= CHOP_TO_FENCE
|
|
IF vChopPos.x >= 481.2
|
|
AND vChopPos.y >= -579.3
|
|
AND vPlayerPos.z >= 27.5
|
|
IF IS_ENTITY_AT_COORD(PLAYER_PED_ID(), vWarpPos, <<13,13,13>>)
|
|
bCanDoWarp = TRUE
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
BREAK
|
|
|
|
CASE FRANKLIN_WARP_FLATBEDS
|
|
// details
|
|
vWarpPos = <<539.29, -501.58, 25.13>>
|
|
fWarpRot = -96.4
|
|
|
|
// check
|
|
IF chopStage = CHOP_TO_BOXCAR
|
|
bCanDoWarp = TRUE
|
|
ENDIF
|
|
BREAK
|
|
|
|
CASE FRANKLIN_WARP_BOXCAR
|
|
// details
|
|
vWarpPos = <<568.37, -506.11, 23.79>>
|
|
fWarpRot = 168.9
|
|
|
|
// check
|
|
IF chopStage >= CHOP_TO_TRAIN
|
|
bCanDoWarp = TRUE
|
|
ENDIF
|
|
BREAK
|
|
ENDSWITCH
|
|
|
|
IF bCanDoWarp
|
|
IF NOT IS_ENTITY_ON_SCREEN(PLAYER_PED_ID())
|
|
SET_ENTITY_COORDS(PLAYER_PED_ID(), vWarpPos)
|
|
SET_ENTITY_HEADING(PLAYER_PED_ID(), fWarpRot)
|
|
DO_FRANKLIN_FOLLOW_CHOP_ROUTE()
|
|
bFranklinWarp[thisWarpEnum] = TRUE
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDREPEAT
|
|
ENDIF
|
|
ENDIF
|
|
ENDPROC
|
|
|
|
// setup lamar for walk
|
|
PROC SETUP_LAMAR_FOR_WALK()
|
|
IF NOT IS_PED_INJURED(lamarPed)
|
|
lamarBlip = CREATE_MISSION_BLIP_FOR_PED(lamarPed)
|
|
SET_ENTITY_HEADING(lamarPed, LAMAR_WALK_INIT_ROT)//temp
|
|
//TASK_LOOK_AT_ENTITY(lamarPed, PLAYER_PED_ID(), -1, SLF_WHILE_NOT_IN_FOV)
|
|
DO_LAMAR_FOLLOW_PAVEMENT()
|
|
FORCE_PED_MOTION_STATE(lamarPed,MS_ON_FOOT_WALK, FALSE, FAUS_CUTSCENE_EXIT)
|
|
SET_PED_MIN_MOVE_BLEND_RATIO(lamarPed,PEDMOVE_WALK)
|
|
ENDIF
|
|
ENDPROC
|
|
|
|
// setup player for walk
|
|
PROC SETUP_PLAYER_FOR_WALK()
|
|
IF NOT IS_PED_INJURED(PLAYER_PED_ID())
|
|
SET_CURRENT_PED_WEAPON(PLAYER_PED_ID(), WEAPONTYPE_UNARMED, TRUE)
|
|
SET_PED_STEALTH_MOVEMENT(PLAYER_PED_ID(), FALSE)
|
|
|
|
IF GET_FOLLOW_PED_CAM_VIEW_MODE() <> CAM_VIEW_MODE_FIRST_PERSON
|
|
FORCE_PED_MOTION_STATE(PLAYER_PED_ID(), MS_ON_FOOT_WALK, FALSE, FAUS_CUTSCENE_EXIT)
|
|
SET_PED_MIN_MOVE_BLEND_RATIO(PLAYER_PED_ID(), PEDMOVE_WALK)
|
|
ELSE
|
|
FORCE_PED_MOTION_STATE(PLAYER_PED_ID(), MS_AIMING, FALSE, FAUS_CUTSCENE_EXIT)
|
|
SIMULATE_PLAYER_INPUT_GAIT(PLAYER_ID(), PEDMOVE_WALK, 2000)
|
|
ENDIF
|
|
//TASK_GO_STRAIGHT_TO_COORD(PLAYER_PED_ID(), <<-22.20569, -1451.75293, 29.70968>>, PEDMOVE_WALK)
|
|
//TASK_LOOK_AT_ENTITY(PLAYER_PED_ID(), lamarPed, -1, SLF_WHILE_NOT_IN_FOV)
|
|
ENDIF
|
|
ENDPROC
|
|
|
|
// chop follow task
|
|
PROC GIVE_CHOP_FOLLOW_TASK()
|
|
//TASK_GOTO_ENTITY_OFFSET_XY(chopPed, lamarPed, DEFAULT_TIME_BEFORE_WARP, 0.1, -0.8, 1.0, PEDMOVE_RUN, ESEEK_OFFSET_ORIENTATES_WITH_ENTITY)
|
|
TASK_GOTO_ENTITY_OFFSET_XY(chopPed, lamarPed, -1, 0.2, -0.8, 3.0, 1.25, ESEEK_OFFSET_ORIENTATES_WITH_ENTITY)
|
|
//TASK_FOLLOW_TO_OFFSET_OF_ENTITY(chopPed, lamarPed, <<-0.7,-0.5,0>>, PEDMOVE_RUN, -1, 0.3)
|
|
|
|
ENDPROC
|
|
|
|
// setup chop for walk
|
|
PROC SETUP_CHOP_FOR_WALK()
|
|
IF NOT IS_PED_INJURED(chopPed)
|
|
SET_ENTITY_HEADING(chopPed, CHOP_WALK_INIT_ROT)
|
|
FORCE_PED_MOTION_STATE(chopPed, MS_ON_FOOT_WALK, FALSE, FAUS_CUTSCENE_EXIT)
|
|
SET_PED_MIN_MOVE_BLEND_RATIO(chopPed,1.0)
|
|
GIVE_CHOP_FOLLOW_TASK()
|
|
ENDIF
|
|
ENDPROC
|
|
|
|
// trains
|
|
PROC HANDLE_TRAINS()
|
|
INT i
|
|
REPEAT NUMBER_TRAINS i
|
|
SETPIECE_STAGE_ENUM startStage
|
|
INT iStartTime
|
|
INT iRunTime
|
|
FLOAT fCruiseSpeed
|
|
|
|
SWITCH i
|
|
CASE 0
|
|
startStage = SETPIECE_LOCK_TRAIN_CUT_ACROSS
|
|
iStartTime = 0
|
|
iRunTime = 1300
|
|
fCruiseSpeed = 4.0
|
|
BREAK
|
|
CASE 1
|
|
startStage = SETPIECE_LOCK_TRAIN_JUMP
|
|
iStartTime = 0
|
|
iRunTime = 20000//23500
|
|
fCruiseSpeed = 2.67
|
|
BREAK
|
|
CASE 2
|
|
startStage = SETPIECE_FREE_BACK_OF_CARRIAGES
|
|
iStartTime = 0
|
|
IF currentMissionStage = STAGE_FIND_BAD_GUY
|
|
OR bRunningCutscene
|
|
iRunTime = 7400//10400
|
|
fCruiseSpeed = 6.5
|
|
ELSE
|
|
iRunTime = 30000//10400
|
|
fCruiseSpeed = 10.0
|
|
ENDIF
|
|
|
|
BREAK
|
|
ENDSWITCH
|
|
|
|
IF IS_VEHICLE_DRIVEABLE(trainVehicle[i])
|
|
IF NOT bStartedTrain[i]
|
|
IF setpieceStage = startStage
|
|
IF GET_GAME_TIMER() >= iSetpieceStageStartTime + iStartTime
|
|
bStartedTrain[i] = TRUE
|
|
iTrainStartedTime[i] = GET_GAME_TIMER()
|
|
fTrainCruiseSpeed[i] = fCruiseSpeed
|
|
SET_TRAIN_CRUISE_SPEED(trainVehicle[i], fTrainCruiseSpeed[i])
|
|
//SET_TRAIN_SPEED(trainVehicle[i], fTrainCruiseSpeed[i])
|
|
ENDIF
|
|
ENDIF
|
|
ELSE
|
|
IF GET_GAME_TIMER() >= iTrainStartedTime[i] + iRunTime
|
|
fTrainCruiseSpeed[i] = fTrainCruiseSpeed[i] -@ 1.0
|
|
IF fTrainCruiseSpeed[i] <= 0
|
|
fTrainCruiseSpeed[i] = 0
|
|
ENDIF
|
|
|
|
SET_TRAIN_CRUISE_SPEED(trainVehicle[i], fTrainCruiseSpeed[i])
|
|
SET_TRAIN_SPEED(trainVehicle[i], fTrainCruiseSpeed[i])
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDREPEAT
|
|
ENDPROC
|
|
|
|
// position player at init pos for mission
|
|
PROC POSITION_PLAYER_AT_MISSION_INIT()
|
|
IF NOT IS_PED_INJURED(PLAYER_PED_ID())
|
|
SET_ENTITY_COORDS(PLAYER_PED_ID(), GET_HOOD_VECTOR(HVEC_PLAYER_INIT))
|
|
SET_ENTITY_HEADING(PLAYER_PED_ID(), PLAYER_INIT_ROT)
|
|
SET_GAMEPLAY_CAM_RELATIVE_HEADING()
|
|
ENDIF
|
|
ENDPROC
|
|
|
|
// should we set the checkpoint for replay on this stage init?
|
|
FUNC BOOL SHOULD_SET_CHECKPOINT_FOR_THIS_STAGE(MISSION_STAGE_ENUM setStage)
|
|
SWITCH setStage
|
|
CASE STAGE_GET_TO_BAD_GUY
|
|
CASE STAGE_VAN_CHASE
|
|
CASE STAGE_FOOT_CHASE
|
|
CASE STAGE_FIND_BAD_GUY
|
|
CASE STAGE_GET_TO_HOUSE
|
|
RETURN TRUE
|
|
BREAK
|
|
ENDSWITCH
|
|
|
|
RETURN FALSE
|
|
ENDFUNC
|
|
|
|
// clear the start area
|
|
PROC CLEAR_START_AREA()
|
|
// clear init areas
|
|
CLEAR_INIT_POS(GET_HOOD_VECTOR(HVEC_PLAYER_INIT))
|
|
CLEAR_INIT_POS(GET_HOOD_VECTOR(HVEC_FRANKLIN_VAN_INIT))
|
|
//WAIT(0)
|
|
ENDPROC
|
|
|
|
// start a particular stage of the mission
|
|
PROC SET_MISSION_STAGE(MISSION_STAGE_ENUM setStage, BOOL bJumpingToStage = FALSE, BOOL bClearTextAndSpeech = TRUE, BOOL bRenderScriptCamsFalse = TRUE, BOOL bInitialisingAfterIntro = FALSE, BOOL bClearMap = TRUE, BOOL bRemoveBlips = TRUE, BOOL bHandleFadeIn = TRUE)
|
|
bHandleFadeIn=bHandleFadeIn
|
|
|
|
IF bJumpingToStage
|
|
// clear area and load scene around start pos
|
|
VECTOR vStartPos
|
|
FLOAT fStartRot
|
|
|
|
SWITCH setStage
|
|
CASE STAGE_GET_TO_BAD_GUY
|
|
IF NOT bForcePassOnShitskip
|
|
vStartPos = GET_HOOD_VECTOR(HVEC_PLAYER_INIT)
|
|
fStartRot = PLAYER_INIT_ROT
|
|
ELSE
|
|
vStartPos = GET_HOOD_VECTOR(HVEC_BAD_GUY_HANGOUT)
|
|
fStartRot = -106.5
|
|
ENDIF
|
|
BREAK
|
|
CASE STAGE_VAN_CHASE
|
|
vStartPos = GET_HOOD_VECTOR(HVEC_FRANKLIN_ALLEY_INIT)
|
|
fStartRot = FRANKLIN_ALLEY_INIT_ROT
|
|
BREAK
|
|
CASE STAGE_FOOT_CHASE
|
|
vStartPos = GET_HOOD_VECTOR(HVEC_FOOT_CHASE_INIT)
|
|
fStartRot = FOOT_CHASE_INIT_ROT
|
|
BREAK
|
|
CASE STAGE_FIND_BAD_GUY
|
|
IF NOT bForcePassOnShitskip
|
|
vStartPos = GET_HOOD_VECTOR(HVEC_LOSE_RUNNER)
|
|
fStartRot = LOSE_RUNNER_ROT
|
|
ELSE
|
|
vStartPos = <<517.1, -647.4, 24.2>>
|
|
fStartRot = -86.0
|
|
ENDIF
|
|
BREAK
|
|
CASE STAGE_GET_TO_HOUSE
|
|
IF NOT bForcePassOnShitskip
|
|
vStartPos = GET_HOOD_VECTOR(HVEC_DRIVE_INIT)
|
|
fStartRot = DRIVE_INIT_ROT
|
|
ELSE
|
|
vStartPos = GET_HOOD_VECTOR(HVEC_REC)
|
|
fStartRot = 143.1
|
|
ENDIF
|
|
BREAK
|
|
ENDSWITCH
|
|
|
|
// clear area for replay
|
|
SET_PLAYER_OUT_OF_ANY_VEHICLE()
|
|
IF bClearMap
|
|
CLEAR_AREA(vStartPos, 10000, TRUE)
|
|
// temp
|
|
IF setStage = STAGE_FIND_BAD_GUY
|
|
REMOVE_PARTICLE_FX_IN_RANGE(<<539.11841, -626.19080, 23.78954>>, 40)
|
|
ENDIF
|
|
ENDIF
|
|
WAIT(0)
|
|
|
|
SET_WEATHER_TYPE_NOW_PERSIST("extrasunny")
|
|
|
|
// set to coords and wait for streaming
|
|
IF IS_REPLAY_IN_PROGRESS()
|
|
AND NOT bSuppressFutureReplaySetups
|
|
START_REPLAY_SETUP(vStartPos, fStartRot)
|
|
ELSE
|
|
SET_ENTITY_COORDS(PLAYER_PED_ID(), vStartPos)
|
|
SET_ENTITY_HEADING(PLAYER_PED_ID(), fStartRot)
|
|
ENDIF
|
|
ENDIF
|
|
|
|
// get the models and force their load
|
|
REQUEST_MODELS_FOR_STAGE(setStage, TRUE, FALSE)
|
|
|
|
// get the recordings and force their load
|
|
REQUEST_VEHICLE_RECORDINGS_FOR_STAGE(setStage, TRUE, FALSE)
|
|
|
|
// get the anims and force their load
|
|
REQUEST_ANIM_DICTS_FOR_STAGE(setStage, TRUE, FALSE)
|
|
|
|
// get the waypoints and force their load
|
|
REQUEST_WAYPOINT_RECORDINGS_FOR_STAGE(setStage, TRUE, FALSE)
|
|
|
|
// get the weapons and force their load
|
|
REQUEST_WEAPONS_FOR_STAGE(setStage, TRUE, FALSE)
|
|
|
|
// get the ptfx and force their load
|
|
REQUEST_PTFX_FOR_STAGE(setStage, TRUE, FALSE)
|
|
|
|
// get the sfx and force their load
|
|
REQUEST_SFX_FOR_STAGE(setStage, TRUE, FALSE)
|
|
|
|
// get the misc assets and force their load
|
|
REQUEST_MISC_ASSETS_FOR_STAGE(setStage, TRUE, FALSE)
|
|
|
|
// get the text and force its load
|
|
REQUEST_TEXT(TRUE)
|
|
|
|
// reset mocap streaming
|
|
//IF mocapStreamingStage >= MOCAP_STREAMING_STAGE_WAIT
|
|
REMOVE_CUTSCENE()
|
|
mocapStreamingStage = MOCAP_STREAMING_STAGE_REQUEST
|
|
//ENDIF
|
|
|
|
// reset vars
|
|
RESET_VARIABLES_FOR_STAGE(setStage)
|
|
|
|
// get rid of blips and text
|
|
IF bRemoveBlips
|
|
REMOVE_ALL_BLIPS()
|
|
ENDIF
|
|
|
|
REMOVE_MISSION_TEXT(bClearTextAndSpeech OR bJumpingToStage, bClearTextAndSpeech OR bJumpingToStage)
|
|
|
|
// kill chase cam
|
|
KILL_CHASE_HINT_CAM(localChaseHintCamStruct)
|
|
|
|
IF bJumpingToStage
|
|
// set the correct player character if not already
|
|
enumCharacterList stageCharacter = GET_CHARACTER_FOR_MISSION_STAGE(setStage)
|
|
SELECTOR_SLOTS_ENUM selectorSlot = GET_SELECTOR_SLOT_FROM_PLAYER_PED_ENUM(stageCharacter)
|
|
|
|
IF GET_CURRENT_PLAYER_PED_ENUM() <> stageCharacter
|
|
WHILE NOT CREATE_PLAYER_PED_ON_FOOT(sSelectorPeds.pedID[selectorSlot], stageCharacter, GET_ENTITY_COORDS(PLAYER_PED_ID()), GET_ENTITY_HEADING(PLAYER_PED_ID()), FALSE)
|
|
WAIT(0)
|
|
ENDWHILE
|
|
WHILE NOT MAKE_SELECTOR_PED_SELECTION(sSelectorPeds, selectorSlot)
|
|
WAIT(0)
|
|
ENDWHILE
|
|
WHILE NOT TAKE_CONTROL_OF_SELECTOR_PED(sSelectorPeds, TRUE)
|
|
WAIT(0)
|
|
ENDWHILE
|
|
INT i
|
|
REPEAT 3 i
|
|
IF DOES_ENTITY_EXIST(sSelectorPeds.pedID[i])
|
|
DELETE_PED(sSelectorPeds.pedID[i])
|
|
ENDIF
|
|
ENDREPEAT
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF bJumpingToStage
|
|
OR bInitialisingAfterIntro
|
|
// remove all dialogue
|
|
IF bJumpingToStage
|
|
INT i
|
|
FOR i=0 TO 9
|
|
REMOVE_PED_FOR_DIALOGUE(hoodConversation, i)
|
|
ENDFOR
|
|
ENDIF
|
|
|
|
// setup with speech
|
|
ADD_PED_FOR_DIALOGUE(hoodConversation, 2, PLAYER_PED_ID(), "FRANKLIN")
|
|
|
|
sSelectorPeds.eCurrentSelectorPed = GET_SELECTOR_SLOT_FROM_PLAYER_PED_ENUM(GET_CHARACTER_FOR_MISSION_STAGE(setStage))
|
|
// create the player characters for the stage
|
|
CREATE_PLAYER_CHARACTERS_WITH_TRANSPORT_IN_MISSION_STAGE(setStage)
|
|
SETUP_PLAYER_CHARACTER_WITH_MISSION_VARIATIONS(PLAYER_PED_ID(), GET_CHARACTER_FOR_MISSION_STAGE(setStage), setStage)
|
|
|
|
IF bJumpingToStage
|
|
LOAD_ALL_OBJECTS_IF_SCREEN_FADED_OUT()
|
|
WHILE NOT HAVE_ALL_STREAMING_REQUESTS_COMPLETED(PLAYER_PED_ID())
|
|
WAIT(0)
|
|
ENDWHILE
|
|
ENDIF
|
|
|
|
// roll down van window
|
|
IF IS_VEHICLE_DRIVEABLE(hoodVehicle[HV_FRANKLIN_VAN])
|
|
IF setStage >= STAGE_GET_TO_HOUSE
|
|
REMOVE_VEHICLE_WINDOW(hoodVehicle[HV_FRANKLIN_VAN], SC_WINDOW_FRONT_LEFT)
|
|
ENDIF
|
|
ENDIF
|
|
|
|
// create bad guy
|
|
IF setStage > STAGE_GET_TO_BAD_GUY
|
|
CREATE_BAD_GUY_FOR_STAGE(setStage)
|
|
ENDIF
|
|
ENDIF
|
|
|
|
// setup player control/cameras
|
|
IF bRenderScriptCamsFalse
|
|
RENDER_SCRIPT_CAMS(FALSE, FALSE)
|
|
ENDIF
|
|
|
|
IF bJumpingToSTage
|
|
DELETE_ALL_TRAINS()
|
|
ENDIF
|
|
|
|
// prevent annoying assert on van chase
|
|
//IF setStage = STAGE_VAN_CHASE
|
|
// SET_REQUESTED_MODEL_ASSERT(FALSE)
|
|
//ELSE
|
|
// SET_REQUESTED_MODEL_ASSERT(TRUE)
|
|
//ENDIF
|
|
|
|
// reset state fakery
|
|
FAKE_SELECTOR_IS_PLAYER(chopViewCamData, sselectorPeds, FALSE)
|
|
|
|
// do any other necessary setup for the stage
|
|
SWITCH setStage
|
|
CASE STAGE_GET_TO_BAD_GUY
|
|
// temp?
|
|
IF bJumpingToStage
|
|
POSITION_PLAYER_AT_MISSION_INIT()
|
|
IF Is_Replay_In_Progress()
|
|
IF IS_REPLAY_START_VEHICLE_AVAILABLE()
|
|
IF IS_REPLAY_VEHICLE_MODEL_UNDER_SIZE_LIMIT(GET_REPLAY_START_VEHICLE_MODEL(), <<0,0,0>>)
|
|
VEHICLE_INDEX startVehicle
|
|
startVehicle = CREATE_REPLAY_START_VEHICLE(GET_HOOD_VECTOR(HVEC_MOVE_LAST_PLAYER_VEHICLE), MOVE_LAST_PLAYER_VEHICLE_ROT)
|
|
SET_MISSION_VEHICLE_GEN_VEHICLE(startVehicle, GET_HOOD_VECTOR(HVEC_MOVE_LAST_PLAYER_VEHICLE), MOVE_LAST_PLAYER_VEHICLE_ROT)
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
bModelRequestTracker[HM_START_VEHICLE] = FALSE
|
|
CREATE_LAMAR_FOR_STAGE(setStage)
|
|
CREATE_CHOP_FOR_STAGE(setStage)
|
|
SET_HOOD_ROADS_OFF(TRUE)
|
|
ENABLE_CARGENS_FOR_MISSION(FALSE)
|
|
IF NOT bForcePassOnShitSkip
|
|
START_HOOD_AUDIO_SCENE(HOOD_AUDIO_SCENE_WALK_TO_VAN)
|
|
ENDIF
|
|
|
|
SET_GPS_DISABLED_ZONE(<<164, -257, -80>>, <<436, 62, 120>>)
|
|
|
|
IF bJumpingToStage
|
|
printstring("jumping to stage") printnl()
|
|
IF NOT IS_PED_INJURED(lamarPed)
|
|
SET_ENTITY_COORDS(lamarPed, GET_HOOD_VECTOR(HVEC_LAMAR_WALK_INIT))
|
|
ENDIF
|
|
IF NOT IS_PED_INJURED(chopPed)
|
|
SET_ENTITY_COORDS(chopPed, GET_HOOD_VECTOR(HVEC_CHOP_WALK_INIT))
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF NOT IS_PED_INJURED(chopPed)
|
|
SET_ANIMAL_MOOD(chopPed, AUD_ANIMAL_MOOD_PLAYFUL)
|
|
ENDIF
|
|
|
|
iNextChopExcitementTime = GET_GAME_TIMER() + 100
|
|
iStopChopExcitementTime = GET_GAME_TIMER() + 1500
|
|
|
|
iBlockJumpTime = GET_GAME_TIMER() + 2000
|
|
|
|
SET_PLAYER_CONTROL(PLAYER_ID(), TRUE)
|
|
BREAK
|
|
CASE STAGE_VAN_CHASE
|
|
IF bJumpingToStage
|
|
bDoneAreYouOKChopSpeech = FALSE
|
|
CREATE_LAMAR_FOR_STAGE(setStage)
|
|
CREATE_CHOP_FOR_STAGE(setStage)
|
|
CREATE_GIRL_FOR_STAGE(setStage)
|
|
IF NOT IS_PED_INJURED(PLAYER_PED_ID())
|
|
AND IS_VEHICLE_DRIVEABLE(hoodVehicle[HV_FRANKLIN_VAN])
|
|
SET_VEHICLE_ENGINE_ON(hoodVehicle[HV_FRANKLIN_VAN], TRUE, TRUE)
|
|
ENDIF
|
|
ELSE
|
|
IF NOT IS_PED_INJURED(chopPed)
|
|
DETACH_ENTITY(chopPed)
|
|
ENDIF
|
|
SET_CHOP_INTO_VAN(chopPed, hoodVehicle[HV_FRANKLIN_VAN], chopLeanInVanState, fCachedVanSpeed, FALSE)
|
|
SET_ENTITY_PROOFS(chopPed, FALSE, TRUE, TRUE, FALSE, FALSE, FALSE, FALSE, TRUE)
|
|
SET_PED_CAN_RAGDOLL(chopPed, FALSE)
|
|
ENDIF
|
|
|
|
REQUEST_PED_VISIBILITY_TRACKING(chopPed)
|
|
|
|
SET_HOOD_ROADS_OFF(TRUE, TRUE)
|
|
|
|
IF NOT bJumpingToStage
|
|
CLEAR_AREA(<<143.22, -458.90, 41.05>>, 810, TRUE)
|
|
ENDIF
|
|
|
|
SET_FRANKLIN_MASK(TRUE)
|
|
SET_LAMAR_MASK(TRUE)
|
|
|
|
SET_PED_CONFIG_FLAG(PLAYER_PED_ID(), PCF_ForceDirectEntry, TRUE)
|
|
|
|
IF NOT IS_PED_INJURED(girlPed)
|
|
TASK_COWER(girlPed, -1)
|
|
ENDIF
|
|
|
|
SPECIAL_ABILITY_FILL_METER(PLAYER_ID(), TRUE)
|
|
SET_GPS_DISABLED_ZONE(<<0,0,0>>, <<0,0,0>>)
|
|
|
|
IF IS_VEHICLE_DRIVEABLE(hoodVehicle[HV_FRANKLIN_VAN])
|
|
iCachedVanHealth = GET_ENTITY_HEALTH(hoodVehicle[HV_FRANKLIN_VAN])
|
|
SET_VEHICLE_IS_CONSIDERED_BY_PLAYER(hoodVehicle[HV_FRANKLIN_VAN], TRUE)
|
|
//SET_VEHICLE_RADIO_ENABLED(hoodVehicle[HV_FRANKLIN_VAN], FALSE)
|
|
ENDIF
|
|
|
|
//IF NOT IS_PED_INJURED(lamarPed)
|
|
// SET_PED_CAN_RAGDOLL(lamarPed, FALSE)
|
|
//ENDIF
|
|
|
|
fSwitchOffRoadDist = 50.0
|
|
switch_SetPieceCar_to_ai_on_collision = TRUE
|
|
//bTrafficOnlySwitchToAIOnCollision = TRUE
|
|
allow_veh_to_stop_on_PLAYER_impact = TRUE
|
|
|
|
iSpeedZone = ADD_ROAD_NODE_SPEED_ZONE(<<293.12726, -83.67029, 69.13698>>, 5.1, 0)
|
|
|
|
INITIALISE_UBER_PLAYBACK(GET_HOOD_UBER_RECORDING_PREFIX(), 001)
|
|
SET_FORCE_UBER_PLAYBACK_TO_USE_DEFAULT_PED_MODEL(FALSE)
|
|
SET_UBER_PLAYBACK_TO_CLEANUP_DEFAULT_PED_MODEL(TRUE)
|
|
LOAD_CHASE_UBER_DATA()
|
|
CREATE_ALL_WAITING_UBER_CARS()
|
|
|
|
START_HOOD_AUDIO_SCENE(HOOD_AUDIO_SCENE_CAR_CHASE)
|
|
|
|
SET_PED_POPULATION_BUDGET(2)
|
|
|
|
IF NOT IS_PED_INJURED(chopPed)
|
|
STOP_PED_SPEAKING(chopPed, TRUE)
|
|
ENDIF
|
|
|
|
IF IS_VEHICLE_DRIVEABLE(hoodVehicle[HV_BAD_GUY_BIKE])
|
|
ADD_ENTITY_TO_AUDIO_MIX_GROUP(hoodVehicle[HV_BAD_GUY_BIKE], "FRANKLIN_0_Bike_Group")
|
|
ENDIF
|
|
|
|
IF bJumpingToStage
|
|
IF NOT IS_PED_INJURED(PLAYER_PED_ID())
|
|
SET_BIKE_TO_ESCAPE()
|
|
ENDIF
|
|
|
|
TRIGGER_MISSION_MUSIC_EVENT("FRA0_CHASE_RESTART")
|
|
ENDIF
|
|
BREAK
|
|
CASE STAGE_FOOT_CHASE
|
|
IF bJumpingToStage
|
|
createCarsStage = CREATE_CARS_STAGE_DONE
|
|
RESET_FOOT_CHASE_VALUES()
|
|
CREATE_LAMAR_FOR_STAGE(setStage)
|
|
CREATE_CHOP_FOR_STAGE(setStage)
|
|
IF IS_VEHICLE_DRIVEABLE(hoodVehicle[HV_FRANKLIN_VAN])
|
|
SET_VEHICLE_ENGINE_ON(hoodVehicle[HV_FRANKLIN_VAN], TRUE, TRUE)
|
|
ENDIF
|
|
ENDIF
|
|
|
|
//IF DOES_CAM_EXIST(chaseCam)
|
|
// DESTROY_CAM(chaseCam)
|
|
//ENDIF
|
|
//IF DOES_ENTITY_EXIST(cameraVehicle)
|
|
// DELETE_VEHICLE(cameraVehicle)
|
|
//ENDIF
|
|
REMOVE_ROAD_NODE_SPEED_ZONE(iSpeedZone)
|
|
ENABLE_CARGENS_FOR_MISSION(FALSE)
|
|
CLEAR_CARGENS_FOR_FOOT_CHASE()
|
|
IF bJumpingToStage
|
|
CLEAR_AREA(<<466, -579, 28>>, 10000, TRUE)
|
|
ENDIF
|
|
SET_HOOD_ROADS_OFF(TRUE, TRUE)
|
|
|
|
// clear fence
|
|
IF bJumpingToStage
|
|
CLEAR_AREA_OF_OBJECTS(<<494, -516, 23>>, 10.0, CLEAROBJ_FLAG_FORCE)
|
|
ENDIF
|
|
|
|
chopChaseProperties.ped = chopPed
|
|
|
|
IF IS_VEHICLE_DRIVEABLE(hoodVehicle[HV_FRANKLIN_VAN])
|
|
SET_VEHICLE_IS_CONSIDERED_BY_PLAYER(hoodVehicle[HV_FRANKLIN_VAN], FALSE)
|
|
ENDIF
|
|
|
|
SET_NEXT_RANDOM_SPEECH_TIME(11000)
|
|
|
|
// switch on assisted route
|
|
//USE_WAYPOINT_RECORDING_AS_ASSISTED_MOVEMENT_ROUTE("hood5", TRUE, ASSISTED_PATH_WIDTH, ASSISTED_TENSION)
|
|
|
|
IF NOT IS_PED_INJURED(runnerChaseProperties.ped)
|
|
IF NOT bJumpingToStage
|
|
ADD_ENTITY_TO_AUDIO_MIX_GROUP(runnerChaseProperties.ped, "FRANKLIN_0_D_Group")
|
|
ENDIF
|
|
|
|
REQUEST_PED_VISIBILITY_TRACKING(runnerChaseProperties.ped)
|
|
IF NOT DOES_BLIP_EXIST(runnerBlip)
|
|
runnerBlip = CREATE_MISSION_BLIP_FOR_PED(runnerChaseProperties.ped, TRUE)
|
|
ENDIF
|
|
SET_BLOCKING_OF_NON_TEMPORARY_EVENTS(runnerChaseProperties.ped, TRUE)
|
|
//SET_ENTITY_ONLY_DAMAGED_BY_PLAYER(runnerChaseProperties.ped, TRUE)
|
|
SET_RAGDOLL_BLOCKING_FLAGS(runnerChaseProperties.ped, chaseRagdollBlockingFlags)
|
|
|
|
IF bJumpingToStage
|
|
FORCE_PED_MOTION_STATE(runnerChaseProperties.ped,MS_ON_FOOT_SPRINT,TRUE,FAUS_CUTSCENE_EXIT)
|
|
ENDIF
|
|
SET_PED_MIN_MOVE_BLEND_RATIO(runnerChaseProperties.ped,PEDMOVE_SPRINT)
|
|
ENDIF
|
|
|
|
IF NOT IS_PED_INJURED(chopPed)
|
|
SET_ENTITY_PROOFS(chopPed, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, TRUE)
|
|
DETACH_ENTITY(chopPed)
|
|
SET_RAGDOLL_BLOCKING_FLAGS(chopPed, chaseRagdollBlockingFlags)
|
|
IF bJumpingToStage
|
|
//FORCE_PED_MOTION_STATE(chopPed,MS_ON_FOOT_SPRINT,TRUE,FAUS_CUTSCENE_EXIT)
|
|
ENDIF
|
|
SET_PED_CAN_RAGDOLL(chopPed, TRUE)
|
|
SET_PED_MIN_MOVE_BLEND_RATIO(chopPed,PEDMOVE_SPRINT)
|
|
chopBlip = CREATE_MISSION_BLIP_FOR_PED(chopPed, FALSE, CHAR_CHOP)
|
|
ENDIF
|
|
|
|
IF NOT IS_PED_INJURED(lamarPed)
|
|
AND IS_VEHICLE_DRIVEABLE(hoodVehicle[HV_FRANKLIN_VAN])
|
|
IF NOT bJumpingToStage
|
|
IF NOT IS_PED_IN_VEHICLE(lamarPed, hoodVehicle[HV_FRANKLIN_VAN])
|
|
DETACH_ENTITY(lamarPed)
|
|
SET_PED_INTO_VEHICLE(lamarPed, hoodVehicle[HV_FRANKLIN_VAN])
|
|
ENDIF
|
|
ENDIF
|
|
|
|
SET_ENTITY_ONLY_DAMAGED_BY_PLAYER(hoodVehicle[HV_FRANKLIN_VAN], TRUE)
|
|
TASK_LOOK_AT_ENTITY(lamarPed, PLAYER_PED_ID(), -1, SLF_WHILE_NOT_IN_FOV)
|
|
//TASK_VEHICLE_TEMP_ACTION(lamarPed, hoodVehicle[HV_FRANKLIN_VAN], TEMPACT_REVERSE, 10000)
|
|
ENDIF
|
|
|
|
CREATE_CHOP_CAM(chopViewCamData)
|
|
|
|
IF bJumpingToStage
|
|
CREATE_CHASE_SETPIECES(TRUE, FALSE, TRUE, TRUE, TRUE)
|
|
bApplyStartBoost = FALSE
|
|
ELSE
|
|
bApplyStartBoost = TRUE
|
|
ENDIF
|
|
|
|
CREATE_BOXCAR_DOORS()
|
|
//iActivateChopCamTime = GET_GAME_TIMER()
|
|
|
|
SET_BIKE_AS_SMOKING()
|
|
|
|
IF bJumpingToStage
|
|
TRIGGER_MISSION_MUSIC_EVENT("FRA0_FOOT_CHASE_RESTART")
|
|
START_HOOD_AUDIO_SCENE(HOOD_AUDIO_SCENE_FOOT_CHASE_START)
|
|
ELSE
|
|
TRIGGER_MISSION_MUSIC_EVENT("FRA0_FRANK_CHASE")
|
|
IF IS_VEHICLE_DRIVEABLE(hoodVehicle[HV_BAD_GUY_BIKE])
|
|
REMOVE_ENTITY_FROM_AUDIO_MIX_GROUP(hoodVehicle[HV_BAD_GUY_BIKE])
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF NOT bJumpingToStage
|
|
bShownGodText = TRUE
|
|
ENDIF
|
|
BREAK
|
|
CASE STAGE_FIND_BAD_GUY
|
|
CREATE_COLLIE()
|
|
SET_HOOD_ROADS_OFF(TRUE, TRUE)
|
|
ENABLE_CARGENS_FOR_MISSION(FALSE)
|
|
iBoxcarCamSyncScene = 123
|
|
IF bJumpingToStage
|
|
CREATE_LAMAR_FOR_STAGE(setStage)
|
|
CREATE_CHOP_FOR_STAGE(setStage)
|
|
IF IS_VEHICLE_DRIVEABLE(hoodVehicle[HV_FRANKLIN_VAN])
|
|
SET_ENTITY_ONLY_DAMAGED_BY_PLAYER(hoodVehicle[HV_FRANKLIN_VAN], TRUE)
|
|
SET_VEHICLE_ENGINE_ON(hoodVehicle[HV_FRANKLIN_VAN], TRUE, TRUE)
|
|
ENDIF
|
|
bDoneReactToRunStatSpeech = FALSE
|
|
iInitialStaminaValue = GET_SP_PLAYER_PED_STAT_VALUE(CHAR_FRANKLIN, PS_STAMINA)
|
|
bShownChopViewHelp = FALSE
|
|
bCancelledChopHint = FALSE
|
|
bShownNoStaminaHelp = FALSE
|
|
runHelpState = RUN_HELP_STATE_DONE
|
|
iRunnerStageStartTime = GET_GAME_TIMER()
|
|
iRunnerStageStartTime=iRunnerStageStartTime
|
|
|
|
CREATE_YARD_TRAIN_FOR_STAGE(1, STAGE_FIND_BAD_GUY)
|
|
CREATE_YARD_TRAIN_FOR_STAGE(2, STAGE_FIND_BAD_GUY)
|
|
|
|
iTrainStartedTime[0] = GET_GAME_TIMER()
|
|
iTrainStartedTime[1] = GET_GAME_TIMER() - 10000
|
|
iTrainStartedTime[2] = GET_GAME_TIMER() - 10000
|
|
|
|
HANDLE_TRAINS()
|
|
WAIT(0)
|
|
CREATE_BOXCAR_DOORS()
|
|
CREATE_CHOP_CAM(chopViewCamData)
|
|
ENDIF
|
|
|
|
IF IS_VEHICLE_DRIVEABLE(hoodVehicle[HV_FRANKLIN_VAN])
|
|
SET_ENTITY_COORDS(hoodVehicle[HV_FRANKLIN_VAN], GET_HOOD_VECTOR(HVEC_VAN_HIDDEN))
|
|
SET_ENTITY_HEADING(hoodVehicle[HV_FRANKLIN_VAN], VAN_HIDDEN_ROT)
|
|
FREEZE_ENTITY_POSITION(hoodVehicle[HV_FRANKLIN_VAN], TRUE)
|
|
ENDIF
|
|
|
|
INT i
|
|
REPEAT NUMBER_YARD_PEDS i
|
|
IF DOES_ENTITY_EXIST(yardPed[i].ped)
|
|
DELETE_PED(yardPed[i].ped)
|
|
ENDIF
|
|
ENDREPEAT
|
|
REPEAT COUNT_OF(driverPed) i
|
|
IF DOES_ENTITY_EXIST(driverPed[i])
|
|
DELETE_PED(driverPed[i])
|
|
ENDIF
|
|
ENDREPEAT
|
|
REPEAT NUMBER_YARD_VEHICLES i
|
|
IF DOES_ENTITY_EXIST(yardVehicle[i])
|
|
DELETE_VEHICLE(yardVehicle[i])
|
|
ENDIF
|
|
ENDREPEAT
|
|
|
|
IF NOT IS_PED_INJURED(chopPed)
|
|
CLEAR_RAGDOLL_BLOCKING_FLAGS(chopPed, chaseRagdollBlockingFlags)
|
|
chopBlip = CREATE_MISSION_BLIP_FOR_PED(chopPed, FALSE, CHAR_CHOP)
|
|
TASK_CLEAR_LOOK_AT(chopPed)
|
|
VECTOR vGotoPos
|
|
WAYPOINT_RECORDING_GET_COORD("hood8", 6, vGotoPos)
|
|
CLEAR_SEQUENCE_TASK(sequence)
|
|
OPEN_SEQUENCE_TASK(sequence)
|
|
IF NOT bJumpingToStage
|
|
TASK_PAUSE(NULL, 3500)
|
|
ENDIF
|
|
TASK_FOLLOW_NAV_MESH_TO_COORD(NULL, vGotoPos, PEDMOVE_SPRINT, DEFAULT_TIME_BEFORE_WARP, DEFAULT_NAVMESH_RADIUS, ENAV_DEFAULT, 175.5)
|
|
CLOSE_SEQUENCE_TASK(sequence)
|
|
TASK_PERFORM_SEQUENCE(chopPed, sequence)
|
|
SET_PED_CAN_RAGDOLL(chopPed, TRUE)
|
|
ENDIF
|
|
IF NOT IS_PED_INJURED(runnerChaseProperties.ped)
|
|
SET_RAGDOLL_BLOCKING_FLAGS(runnerChaseProperties.ped, chaseRagdollBlockingFlags)
|
|
ENDIF
|
|
IF NOT IS_PED_INJURED(lamarPed)
|
|
TASK_LOOK_AT_ENTITY(lamarPed, PLAYER_PED_ID(), -1, SLF_WHILE_NOT_IN_FOV)
|
|
ENDIF
|
|
IF IS_VEHICLE_DRIVEABLE(hoodVehicle[HV_FRANKLIN_VAN])
|
|
REMOVE_VEHICLE_WINDOW(hoodVehicle[HV_FRANKLIN_VAN], SC_WINDOW_FRONT_LEFT)
|
|
ENDIF
|
|
IF NOT bForcePassOnShitSkip
|
|
STOP_HOOD_AUDIO_SCENE(HOOD_AUDIO_SCENE_BREAK_THROUGH_FENCE)
|
|
STOP_HOOD_AUDIO_SCENE(HOOD_AUDIO_SCENE_FOOT_CHASE_START)
|
|
START_HOOD_AUDIO_SCENE(HOOD_AUDIO_SCENE_SEARCH_BOXCARS)
|
|
|
|
IF bJumpingToStage
|
|
TRIGGER_MISSION_MUSIC_EVENT("FRA0_HIDING_RESTART")
|
|
ELSE
|
|
TRIGGER_MISSION_MUSIC_EVENT("FRA0_SEARCH")
|
|
ENDIF
|
|
ENDIF
|
|
|
|
//iActivateChopCamTime = GET_GAME_TIMER()
|
|
BREAK
|
|
CASE STAGE_GET_TO_HOUSE
|
|
SET_HOOD_ROADS_OFF(FALSE)
|
|
IF bJumpingToStage
|
|
bDoneTrainingSpeech = TRUE
|
|
CREATE_LAMAR_FOR_STAGE(setStage)
|
|
CREATE_CHOP_FOR_STAGE(setStage)
|
|
ENDIF
|
|
ENABLE_CARGENS_FOR_MISSION(FALSE)
|
|
IF IS_VEHICLE_DRIVEABLE(hoodVehicle[HV_FRANKLIN_VAN])
|
|
REMOVE_VEHICLE_WINDOW(hoodVehicle[HV_FRANKLIN_VAN], SC_WINDOW_FRONT_LEFT)
|
|
SET_ENTITY_ONLY_DAMAGED_BY_PLAYER(hoodVehicle[HV_FRANKLIN_VAN], FALSE)
|
|
SET_VEHICLE_IS_CONSIDERED_BY_PLAYER(hoodVehicle[HV_FRANKLIN_VAN], TRUE)
|
|
SET_VEHICLE_ENGINE_ON(hoodVehicle[HV_FRANKLIN_VAN], TRUE, TRUE)
|
|
ENDIF
|
|
IF NOT IS_PED_INJURED(runnerChaseProperties.ped)
|
|
CLEAR_RAGDOLL_BLOCKING_FLAGS(runnerChaseProperties.ped, chaseRagdollBlockingFlags)
|
|
SET_PED_CAN_RAGDOLL(runnerChaseProperties.ped, TRUE)
|
|
SET_DAMAGE_ON_BAD_GUY()
|
|
//SET_PED_CAN_BE_TARGETTED(runnerChaseProperties.ped, TRUE)
|
|
SET_ENTITY_PROOFS(runnerChaseProperties.ped, FALSE, FALSE, FALSE, FALSE, FALSE)
|
|
SET_PED_CAN_PLAY_AMBIENT_BASE_ANIMS(runnerChaseProperties.ped, FALSE)
|
|
SET_PED_CAN_PLAY_AMBIENT_ANIMS(runnerChaseProperties.ped, FALSE)
|
|
IF bJumpingToStage
|
|
SET_PED_INTO_VEHICLE(runnerChaseProperties.ped, hoodVehicle[HV_FRANKLIN_VAN], VS_BACK_RIGHT)
|
|
ENDIF
|
|
TASK_LOOK_AT_ENTITY(runnerChaseProperties.ped, hoodVehicle[HV_FRANKLIN_VAN], -1, SLF_WHILE_NOT_IN_FOV)
|
|
SET_PED_RELATIONSHIP_GROUP_HASH(runnerChaseProperties.ped, RELGROUPHASH_PLAYER)
|
|
ENDIF
|
|
|
|
START_HOOD_AUDIO_SCENE(HOOD_AUDIO_SCENE_DRIVE_TO_LAMARS)
|
|
|
|
IF bJumpingToStage
|
|
IF bForcePassOnShitskip
|
|
//IF IS_VEHICLE_DRIVEABLE(hoodVehicle[HV_FRANKLIN_VAN])
|
|
// SET_ENTITY_COORDS(hoodVehicle[HV_FRANKLIN_VAN], GET_HOOD_VECTOR(HVEC_REC))
|
|
// SET_ENTITY_HEADING(hoodVehicle[HV_FRANKLIN_VAN], 73.92)
|
|
// SET_VEHICLE_ON_GROUND_PROPERLY(hoodVehicle[HV_FRANKLIN_VAN])
|
|
//LOAD_SCENE(GET_HOOD_VECTOR(HVEC_REC))
|
|
dropoffStage = DROPOFF_STAGE_END
|
|
bDoneLetOut = TRUE
|
|
lamarPhoneState = LAMAR_PHONE_STATE_DONE
|
|
//ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
BREAK
|
|
ENDSWITCH
|
|
|
|
IF bJumpingToStage
|
|
//IF ENUM_TO_INT(setStage) > 0
|
|
SET_GAMEPLAY_CAM_RELATIVE_HEADING(0.0)
|
|
//ENDIF
|
|
ENDIF
|
|
|
|
// masks
|
|
IF bJumpingToStage
|
|
IF setStage >= STAGE_GET_TO_HOUSE
|
|
SET_FRANKLIN_MASK(TRUE)
|
|
SET_LAMAR_MASK(FALSE)
|
|
ELIF setStage >= STAGE_FOOT_CHASE
|
|
SET_FRANKLIN_MASK(TRUE)
|
|
SET_LAMAR_MASK(TRUE)
|
|
ELIF setStage < STAGE_VAN_CHASE
|
|
SET_FRANKLIN_MASK(FALSE)
|
|
SET_LAMAR_MASK(FALSE)
|
|
ENDIF
|
|
ENDIF
|
|
|
|
// instance priority
|
|
IF setStage = STAGE_VAN_CHASE
|
|
SET_INSTANCE_PRIORITY_HINT(INSTANCE_HINT_DRIVING)
|
|
ELSE
|
|
SET_INSTANCE_PRIORITY_HINT(INSTANCE_HINT_NONE)
|
|
ENDIF
|
|
|
|
// suppress bus
|
|
IF setStage >= STAGE_VAN_CHASE
|
|
AND setStage <= STAGE_FIND_BAD_GUY
|
|
SET_VEHICLE_MODEL_IS_SUPPRESSED(BUS, TRUE)
|
|
ELSE
|
|
SET_VEHICLE_MODEL_IS_SUPPRESSED(BUS, FALSE)
|
|
ENDIF
|
|
|
|
// block shops and shop robberies?
|
|
IF setStage >= STAGE_VAN_CHASE
|
|
AND setStage <= STAGE_FIND_BAD_GUY
|
|
SET_ALL_SHOPS_TEMPORARILY_UNAVAILABLE(TRUE)
|
|
g_bBlockShopRoberies = TRUE
|
|
ELSE
|
|
SET_ALL_SHOPS_TEMPORARILY_UNAVAILABLE(FALSE)
|
|
g_bBlockShopRoberies = FALSE
|
|
ENDIF
|
|
g_bBlockShopRoberies = TRUE
|
|
|
|
// foot ptfx range
|
|
IF setStage = STAGE_FOOT_CHASE
|
|
SET_PARTICLE_FX_FOOT_LODRANGE_SCALE(4.0)
|
|
ELSE
|
|
SET_PARTICLE_FX_FOOT_LODRANGE_SCALE(1.0)
|
|
ENDIF
|
|
|
|
// cheats
|
|
IF setStage = STAGE_FOOT_CHASE
|
|
DISABLE_CHEAT(CHEAT_TYPE_SUPER_JUMP, TRUE)
|
|
DISABLE_CHEAT(CHEAT_TYPE_FAST_RUN, TRUE)
|
|
ELSE
|
|
DISABLE_CHEAT(CHEAT_TYPE_SUPER_JUMP, FALSE)
|
|
DISABLE_CHEAT(CHEAT_TYPE_FAST_RUN, FALSE)
|
|
ENDIF
|
|
|
|
IF setStage <> STAGE_VAN_CHASE
|
|
SET_PED_POPULATION_BUDGET(3)
|
|
ENDIF
|
|
|
|
// wanted level, emergency services
|
|
IF setStage >= STAGE_VAN_CHASE
|
|
AND setStage <= STAGE_FIND_BAD_GUY
|
|
SET_WANTED_LEVEL_MULTIPLIER(0.0)
|
|
SET_MAX_WANTED_LEVEL(0)
|
|
ENABLE_DISPATCH_SERVICE(DT_AMBULANCE_DEPARTMENT, FALSE)
|
|
ENABLE_DISPATCH_SERVICE(DT_FIRE_DEPARTMENT, FALSE)
|
|
SET_CREATE_RANDOM_COPS(FALSE)
|
|
ELSE
|
|
SET_WANTED_LEVEL_MULTIPLIER(1.0)
|
|
SET_MAX_WANTED_LEVEL(5)
|
|
ENABLE_DISPATCH_SERVICE(DT_AMBULANCE_DEPARTMENT, TRUE)
|
|
ENABLE_DISPATCH_SERVICE(DT_FIRE_DEPARTMENT, TRUE)
|
|
SET_CREATE_RANDOM_COPS(TRUE)
|
|
ENDIF
|
|
|
|
// set value for replay
|
|
BOOL bFinalCheckpoint = FALSE
|
|
IF ENUM_TO_INT(setStage) >= ENUM_TO_INT(STAGE_GET_TO_HOUSE)
|
|
bFinalCheckpoint = TRUE // skipping from this point would end the mission
|
|
ENDIF
|
|
IF SHOULD_SET_CHECKPOINT_FOR_THIS_STAGE(setStage)
|
|
Set_Replay_Mid_Mission_Stage_With_Name(ENUM_TO_INT(setStage), GET_DESCRIPTION_FOR_STAGE_AS_STRING(setStage), bFinalCheckpoint)
|
|
IF ENUM_TO_INT(setStage) <> 0
|
|
AND NOT bJumpingToStage
|
|
iReplayAttempt = 0
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF bJumpingToStage
|
|
WHILE IS_SCREEN_FADING_OUT()
|
|
WAIT(0)
|
|
ENDWHILE
|
|
|
|
IF NOT bSuppressFutureReplaySetups
|
|
IF IS_REPLAY_IN_PROGRESS()
|
|
IF IS_REPLAY_BEING_SET_UP()
|
|
|
|
VEHICLE_INDEX endReplayVehicle
|
|
SWITCH setStage
|
|
CASE STAGE_GET_TO_HOUSE
|
|
endReplayVehicle = hoodVehicle[HV_FRANKLIN_VAN]
|
|
BREAK
|
|
ENDSWITCH
|
|
|
|
BOOL bReturnControl = TRUE
|
|
|
|
VEHICLE_SEAT seat = VS_DRIVER
|
|
|
|
END_REPLAY_SETUP(endReplayVehicle, seat, bReturnControl)
|
|
|
|
bSuppressFutureReplaySetups = TRUE
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
|
|
// post replay setup specific skip stuff
|
|
SWITCH setStage
|
|
CASE STAGE_GET_TO_BAD_GUY
|
|
IF NOT bForcePassOnShitSkip
|
|
printstring("setup for walk") printnl()
|
|
SETUP_LAMAR_FOR_WALK()
|
|
SETUP_PLAYER_FOR_WALK()
|
|
SETUP_CHOP_FOR_WALK()
|
|
ENDIF
|
|
BREAK
|
|
CASE STAGE_VAN_CHASE
|
|
SET_PED_STEALTH_MOVEMENT(PLAYER_PED_ID(), FALSE)
|
|
|
|
IF GET_FOLLOW_PED_CAM_VIEW_MODE() <> CAM_VIEW_MODE_FIRST_PERSON
|
|
FORCE_PED_MOTION_STATE(PLAYER_PED_ID(), MS_ON_FOOT_SPRINT, FALSE, FAUS_CUTSCENE_EXIT)
|
|
SET_PED_MIN_MOVE_BLEND_RATIO(PLAYER_PED_ID(), PEDMOVE_SPRINT)
|
|
ELSE
|
|
FORCE_PED_MOTION_STATE(PLAYER_PED_ID(), MS_AIMING, FALSE, FAUS_CUTSCENE_EXIT)
|
|
SIMULATE_PLAYER_INPUT_GAIT(PLAYER_ID(), PEDMOVE_SPRINT, 2000)
|
|
ENDIF
|
|
BREAK
|
|
CASE STAGE_FOOT_CHASE
|
|
IF GET_FOLLOW_PED_CAM_VIEW_MODE() <> CAM_VIEW_MODE_FIRST_PERSON
|
|
FORCE_PED_MOTION_STATE(PLAYER_PED_ID(),MS_ON_FOOT_SPRINT,TRUE,FAUS_CUTSCENE_EXIT)
|
|
ELSE
|
|
FORCE_PED_MOTION_STATE(PLAYER_PED_ID(),MS_AIMING,TRUE,FAUS_CUTSCENE_EXIT)
|
|
ENDIF
|
|
IF NOT IS_PED_INJURED(chopPed)
|
|
FORCE_PED_MOTION_STATE(chopPed,MS_ON_FOOT_SPRINT,TRUE,FAUS_CUTSCENE_EXIT)
|
|
SET_PED_MIN_MOVE_BLEND_RATIO(chopPed,PEDMOVE_SPRINT)
|
|
ENDIF
|
|
BREAK
|
|
ENDSWITCH
|
|
ENDIF
|
|
|
|
// after rest of setup common stuff
|
|
SWITCH setStage
|
|
CASE STAGE_FOOT_CHASE
|
|
IF GET_FOLLOW_PED_CAM_VIEW_MODE() <> CAM_VIEW_MODE_FIRST_PERSON
|
|
SET_PED_MIN_MOVE_BLEND_RATIO(PLAYER_PED_ID(), PEDMOVE_RUN)
|
|
ELSE
|
|
SIMULATE_PLAYER_INPUT_GAIT(PLAYER_ID(), PEDMOVE_RUN, 2000)
|
|
ENDIF
|
|
BREAK
|
|
ENDSWITCH
|
|
|
|
|
|
IF setStage <> STAGE_FOOT_CHASE
|
|
iNextChopSoundTime = GET_GAME_TIMER() + GET_RANDOM_INT_IN_RANGE(1500, 3000)
|
|
ELSE
|
|
iNextChopSoundTime = GET_GAME_TIMER() + 300
|
|
ENDIF
|
|
iStageStartTime = GET_GAME_TIMER()
|
|
currentMissionStage = setStage
|
|
ENDPROC
|
|
|
|
// handle streaming mocap
|
|
PROC HANDLE_STREAMING_MOCAP(STRING sMocap, VECTOR vStreamPos, FLOAT fStreamInDistance, FLOAT fStreamOutDistance)
|
|
SWITCH mocapStreamingStage
|
|
CASE MOCAP_STREAMING_STAGE_REQUEST
|
|
IF IS_ENTITY_AT_COORD(PLAYER_PED_ID(), vStreamPos, <<fStreamInDistance, fStreamInDistance, fStreamInDistance>>)
|
|
REQUEST_CUTSCENE(sMocap)
|
|
mocapStreamingStage = MOCAP_STREAMING_STAGE_WAIT
|
|
ENDIF
|
|
BREAK
|
|
CASE MOCAP_STREAMING_STAGE_WAIT
|
|
IF HAS_CUTSCENE_LOADED()
|
|
mocapStreamingStage = MOCAP_STREAMING_STAGE_COMPLETE
|
|
ENDIF
|
|
BREAK
|
|
CASE MOCAP_STREAMING_STAGE_COMPLETE
|
|
IF NOT IS_ENTITY_AT_COORD(PLAYER_PED_ID(), vStreamPos, <<fStreamOutDistance, fStreamOutDistance, fStreamOutDistance>>)
|
|
REMOVE_CUTSCENE()
|
|
mocapStreamingStage = MOCAP_STREAMING_STAGE_REQUEST
|
|
ENDIF
|
|
BREAK
|
|
ENDSWITCH
|
|
ENDPROC
|
|
|
|
// should we start streaming for next mission stage?
|
|
FUNC BOOL SHOULD_START_STREAMING_FOR_NEXT_MISSION_STAGE()
|
|
SWITCH currentMissionStage
|
|
CASE STAGE_GET_TO_BAD_GUY
|
|
IF bRunningCutscene
|
|
RETURN TRUE
|
|
ENDIF
|
|
//IF IS_ENTITY_AT_COORD(PLAYER_PED_ID(), GET_HOOD_VECTOR(HVEC_GIRL_INIT), <<150,150,150>>, FALSE, FALSE)
|
|
// RETURN TRUE
|
|
//ENDIF
|
|
BREAK
|
|
CASE STAGE_VAN_CHASE
|
|
//IF bRunningCutscene
|
|
// RETURN TRUE
|
|
//ENDIF
|
|
|
|
IF IS_VEHICLE_DRIVEABLE(hoodVehicle[HV_BAD_GUY_BIKE])
|
|
IF IS_PLAYBACK_GOING_ON_FOR_VEHICLE(hoodVehicle[HV_BAD_GUY_BIKE])
|
|
//IF GET_TIME_POSITION_IN_RECORDING(hoodVehicle[HV_BAD_GUY_BIKE]) >= STREAM_FOOT_CHASE_TIME
|
|
// RETURN TRUE
|
|
//ENDIF
|
|
ELSE
|
|
RETURN TRUE
|
|
ENDIF
|
|
ENDIF
|
|
BREAK
|
|
CASE STAGE_FOOT_CHASE
|
|
IF setpieceStage >= SETPIECE_LOCK_TRAIN_JUMP
|
|
RETURN TRUE
|
|
ENDIF
|
|
BREAK
|
|
CASE STAGE_FIND_BAD_GUY
|
|
IF bFoundBadGuy
|
|
RETURN TRUE
|
|
ENDIF
|
|
BREAK
|
|
BREAK
|
|
CASE STAGE_GET_TO_HOUSE
|
|
RETURN FALSE
|
|
BREAK
|
|
ENDSWITCH
|
|
|
|
RETURN FALSE
|
|
ENDFUNC
|
|
|
|
// stream in assets for next mission stage during gameplay to cut down on load times
|
|
PROC DO_STREAMING_FOR_NEXT_MISSION_STAGE(BOOL bStreamDuringIntro)
|
|
SWITCH streamingStage
|
|
CASE MISSION_STREAMING_STAGE_REQUEST
|
|
IF SHOULD_START_STREAMING_FOR_NEXT_MISSION_STAGE()
|
|
OR bStreamDuringIntro
|
|
MISSION_STAGE_ENUM nextStageEnum
|
|
IF bStreamDuringIntro
|
|
nextStageEnum = INT_TO_ENUM(MISSION_STAGE_ENUM, 0)
|
|
ELSE
|
|
nextStageEnum = INT_TO_ENUM(MISSION_STAGE_ENUM, ENUM_TO_INT(currentMissionStage) + 1)
|
|
ENDIF
|
|
REQUEST_MODELS_FOR_STAGE(nextStageEnum, FALSE, TRUE)
|
|
REQUEST_VEHICLE_RECORDINGS_FOR_STAGE(nextStageEnum, FALSE, TRUE)
|
|
REQUEST_ANIM_DICTS_FOR_STAGE(nextStageEnum, FALSE, TRUE)
|
|
REQUEST_WAYPOINT_RECORDINGS_FOR_STAGE(nextStageEnum, FALSE, TRUE)
|
|
REQUEST_WEAPONS_FOR_STAGE(nextStageEnum, FALSE, TRUE)
|
|
REQUEST_PTFX_FOR_STAGE(nextStageEnum, FALSE, TRUE)
|
|
REQUEST_SFX_FOR_STAGE(nextStageEnum, FALSE, TRUE)
|
|
REQUEST_MISC_ASSETS_FOR_STAGE(nextStageEnum, FALSE, TRUE)
|
|
REQUEST_TEXT(FALSE)
|
|
streamingStage = MISSION_STREAMING_STAGE_WAIT
|
|
ENDIF
|
|
BREAK
|
|
CASE MISSION_STREAMING_STAGE_WAIT
|
|
IF HAVE_ALL_MODEL_REQUESTS_SUCCEEDED()
|
|
AND HAVE_ALL_RECORDING_REQUESTS_SUCCEEDED()
|
|
AND HAVE_ALL_ANIM_DICT_REQUESTS_SUCCEEDED()
|
|
AND HAVE_ALL_WAYPOINT_REQUESTS_SUCCEEDED()
|
|
AND HAVE_ALL_WEAPON_REQUESTS_SUCCEEDED()
|
|
AND HAVE_ALL_PTFX_REQUESTS_SUCCEEDED()
|
|
AND HAVE_ALL_SFX_REQUESTS_SUCCEEDED()
|
|
AND HAVE_ALL_MISC_ASSET_REQUESTS_SUCCEEDED()
|
|
AND HAS_ADDITIONAL_TEXT_LOADED(MISSION_TEXT_SLOT)
|
|
streamingStage = MISSION_STREAMING_STAGE_COMPLETE
|
|
ENDIF
|
|
BREAK
|
|
ENDSWITCH
|
|
ENDPROC
|
|
|
|
// debug skip mocap
|
|
#IF IS_DEBUG_BUILD
|
|
PROC DEBUG_SKIP_MOCAP()
|
|
IF IS_KEYBOARD_KEY_JUST_PRESSED(KEY_J)
|
|
STOP_CUTSCENE()
|
|
WHILE NOT IS_SCREEN_FADED_OUT()
|
|
WAIT(0)
|
|
ENDWHILE
|
|
ENDIF
|
|
ENDPROC
|
|
#ENDIF
|
|
|
|
// get rid of everything
|
|
PROC CLEAR_MISSION_FOR_SKIP()
|
|
INT i
|
|
|
|
DISTANT_COP_CAR_SIRENS(FALSE)
|
|
SET_PLAYER_OUT_OF_ANY_VEHICLE()
|
|
SET_CHOP_VIEW_CAM_DISABLED(chopViewCamData, sSelectorPeds)
|
|
INFORM_MISSION_STATS_SYSTEM_OF_TIME_WINDOW_CLOSED()
|
|
STOP_ALL_HOOD_AUDIO_SCENES()
|
|
CLEAR_CONTROL_LIGHT_EFFECT(PLAYER_CONTROL)
|
|
|
|
IF STREAMVOL_IS_VALID(missionStreamingVolume)
|
|
STREAMVOL_DELETE(missionStreamingVolume)
|
|
ENDIF
|
|
|
|
REMOVE_ROAD_NODE_SPEED_ZONE(iSpeedZone)
|
|
RESET_WANTED_LEVEL_DIFFICULTY(PLAYER_ID())
|
|
REMOVE_CHOP_SCENT(TRUE)
|
|
|
|
TOGGLE_CAR_MOD_SHOPS_UNAVAILABLE(FALSE)
|
|
|
|
//IF DOES_PARTICLE_FX_LOOPED_EXIST(bloodPTFX)
|
|
// REMOVE_PARTICLE_FX(bloodPTFX)
|
|
//ENDIF
|
|
|
|
// delete entities
|
|
REPEAT 3 i
|
|
IF DOES_ENTITY_EXIST(sSelectorPeds.pedID[i])
|
|
DELETE_PED(sSelectorPeds.pedID[i])
|
|
ENDIF
|
|
ENDREPEAT
|
|
|
|
IF DOES_ENTITY_EXIST(runnerChaseProperties.ped)
|
|
DELETE_PED(runnerChaseProperties.ped)
|
|
ENDIF
|
|
|
|
REPEAT COUNT_OF(driverPed) i
|
|
IF DOES_ENTITY_EXIST(driverPed[i])
|
|
DELETE_PED(driverPed[i])
|
|
ENDIF
|
|
ENDREPEAT
|
|
|
|
IF DOES_ENTITY_EXIST(lamarPed)
|
|
DELETE_PED(lamarPed)
|
|
ENDIF
|
|
|
|
IF DOES_ENTITY_EXIST(chopPed)
|
|
DELETE_PED(chopPed)
|
|
ENDIF
|
|
|
|
//IF DOES_ENTITY_EXIST(tempHelperPed)
|
|
// DELETE_PED(tempHelperPed)
|
|
//ENDIF
|
|
|
|
IF DOES_ENTITY_EXIST(girlPed)
|
|
DELETE_PED(girlPed)
|
|
ENDIF
|
|
|
|
IF DOES_ENTITY_EXIST(colliePed)
|
|
DELETE_PED(colliePed)
|
|
ENDIF
|
|
|
|
REPEAT COUNT_OF(HOOD_VEHICLE_ENUM) i
|
|
IF DOES_ENTITY_EXIST(hoodVehicle[i])
|
|
DELETE_VEHICLE(hoodVehicle[i])
|
|
ENDIF
|
|
ENDREPEAT
|
|
|
|
//IF DOES_ENTITY_EXIST(cameraVehicle)
|
|
// DELETE_VEHICLE(cameraVehicle)
|
|
//ENDIF
|
|
|
|
REPEAT NUMBER_YARD_VEHICLES i
|
|
IF DOES_ENTITY_EXIST(yardVehicle[i])
|
|
DELETE_VEHICLE(yardVehicle[i])
|
|
ENDIF
|
|
ENDREPEAT
|
|
|
|
REPEAT NUMBER_TRAINS i
|
|
IF DOES_ENTITY_EXIST(trainVehicle[i])
|
|
DELETE_MISSION_TRAIN(trainVehicle[i])
|
|
ENDIF
|
|
ENDREPEAT
|
|
|
|
REPEAT NUMBER_BLOCKING_VEHICLES i
|
|
IF DOES_ENTITY_EXIST(blockingVehicle[i])
|
|
DELETE_VEHICLE(blockingVehicle[i])
|
|
ENDIF
|
|
ENDREPEAT
|
|
|
|
IF DOES_ENTITY_EXIST(uberTrailerVehicle)
|
|
DELETE_VEHICLE(uberTrailerVehicle)
|
|
ENDIF
|
|
|
|
REPEAT NUMBER_YARD_PEDS i
|
|
IF DOES_ENTITY_EXIST(yardPed[i].ped)
|
|
DELETE_PED(yardPed[i].ped)
|
|
ENDIF
|
|
ENDREPEAT
|
|
|
|
REPEAT NUMBER_BOXCARS i
|
|
INT j
|
|
REPEAT 2 j
|
|
IF DOES_ENTITY_EXIST(boxcarCarriage[i].boxcarDoor[j].obj)
|
|
DELETE_OBJECT(boxcarCarriage[i].boxcarDoor[j].obj)
|
|
ENDIF
|
|
IF DOES_ENTITY_EXIST(boxcarCarriage[i].boxcarDoor[j].handleObject)
|
|
DELETE_OBJECT(boxcarCarriage[i].boxcarDoor[j].handleObject)
|
|
ENDIF
|
|
ENDREPEAT
|
|
|
|
IF DOES_ENTITY_EXIST(boxcarCarriage[i].anchorObject)
|
|
DELETE_OBJECT(boxcarCarriage[i].anchorObject)
|
|
ENDIF
|
|
ENDREPEAT
|
|
|
|
IF DOES_ENTITY_EXIST(lamarPhoneObject)
|
|
DELETE_OBJECT(lamarPhoneObject)
|
|
ENDIF
|
|
|
|
IF DOES_ENTITY_EXIST(franklinBandanaObject)
|
|
DELETE_OBJECT(franklinBandanaObject)
|
|
ENDIF
|
|
|
|
IF DOES_CAM_EXIST(staticCam)
|
|
DESTROY_CAM(staticCam)
|
|
ENDIF
|
|
|
|
IF DOES_CAM_EXIST(animCam)
|
|
DESTROY_CAM(animCam)
|
|
ENDIF
|
|
|
|
IF DOES_CAM_EXIST(chopSwitchCam)
|
|
DESTROY_CAM(chopSwitchCam)
|
|
ENDIF
|
|
|
|
IF DOES_CAM_EXIST(chopViewCamData.chopCam)
|
|
DESTROY_CAM(chopViewCamData.chopCam)
|
|
ENDIF
|
|
|
|
//IF DOES_CAM_EXIST(chaseCam)
|
|
// DESTROY_CAM(chaseCam)
|
|
//ENDIF
|
|
|
|
//IF DOES_CAM_EXIST(chopViewCamData.copiedGameCam)
|
|
// DESTROY_CAM(chopViewCamData.copiedGameCam)
|
|
//ENDIF
|
|
|
|
CLEAR_AREA(GET_HOOD_VECTOR(HVEC_FRANKLIN_VAN_INIT), 10000, TRUE)
|
|
ENDPROC
|
|
|
|
// common stuff to clear mission for a skip
|
|
PROC COMMON_MISSION_CLEAR()
|
|
IF IS_ENTITY_ATTACHED(PLAYER_PED_ID())
|
|
IF NOT GET_IS_PED_GADGET_EQUIPPED(PLAYER_PED_ID(), GADGETTYPE_PARACHUTE)
|
|
IF GET_VEHICLE_PED_IS_USING(PLAYER_PED_ID()) = NULL
|
|
CLEAR_PED_TASKS(PLAYER_PED_ID())
|
|
DETACH_ENTITY(PLAYER_PED_ID())
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
|
|
TASK_CLEAR_LOOK_AT(PLAYER_PED_ID())
|
|
WAIT(1000)
|
|
CLEAR_PED_TASKS_IMMEDIATELY(PLAYER_PED_ID())
|
|
|
|
KILL_CHASE_HINT_CAM(localChaseHintCamStruct)
|
|
CLEANUP_UBER_PLAYBACK(TRUE)
|
|
DISPLAY_RADAR(TRUE)
|
|
DISPLAY_HUD(TRUE)
|
|
SET_PLAYER_CONTROL(PLAYER_ID(), TRUE)
|
|
#IF IS_DEBUG_BUILD
|
|
bDebugDoneFootChaseSkip = FALSE
|
|
#ENDIF
|
|
SET_SCRIPTS_SAFE_FOR_CUTSCENE(FALSE)
|
|
CLEAR_MISSION_FOR_SKIP()
|
|
ENDPROC
|
|
|
|
// handle shitskip
|
|
FUNC BOOL HANDLE_MISSION_SHITSKIP()
|
|
// new shitskip system
|
|
IF IS_REPLAY_IN_PROGRESS()
|
|
IF g_bShitskipAccepted = TRUE
|
|
CPRINTLN(DEBUG_REPLAY, "Franklin 0: starting shitskip")
|
|
// get next replay stage
|
|
MISSION_STAGE_ENUM nextReplayStage
|
|
//BOOL bPassMission = FALSE
|
|
SWITCH INT_TO_ENUM(MISSION_STAGE_ENUM, Get_Replay_Mid_Mission_Stage())
|
|
CASE STAGE_GET_TO_BAD_GUY
|
|
nextReplayStage = STAGE_GET_TO_BAD_GUY
|
|
bForcePassOnShitskip = TRUE
|
|
BREAK
|
|
CASE STAGE_VAN_CHASE
|
|
nextReplayStage = STAGE_FOOT_CHASE
|
|
BREAK
|
|
CASE STAGE_FOOT_CHASE
|
|
nextReplayStage = STAGE_FIND_BAD_GUY
|
|
BREAK
|
|
CASE STAGE_FIND_BAD_GUY
|
|
nextReplayStage = STAGE_FIND_BAD_GUY
|
|
bForcePassOnShitskip = TRUE
|
|
BREAK
|
|
CASE STAGE_GET_TO_HOUSE
|
|
nextReplayStage = STAGE_GET_TO_HOUSE
|
|
bForcePassOnShitskip = TRUE
|
|
BREAK
|
|
ENDSWITCH
|
|
|
|
// set the next mission stage nicely
|
|
COMMON_MISSION_CLEAR()
|
|
SET_MISSION_STAGE(nextReplayStage, TRUE, TRUE, TRUE, FALSE, TRUE, TRUE, FALSE)
|
|
IF NOT bForcePassOnShitskip
|
|
DO_SCREEN_FADE_IN(DEFAULT_FADE_TIME)
|
|
ENDIF
|
|
|
|
RETURN TRUE
|
|
ELSE
|
|
CPRINTLN(DEBUG_REPLAY, "Franklin 0: no shitskip")
|
|
ENDIF
|
|
ENDIF
|
|
RETURN FALSE // did not do a shitskip
|
|
ENDFUNC
|
|
|
|
// do mission init start mission
|
|
PROC DO_MISSION_INIT_START_MISSION()
|
|
// stats
|
|
//INFORM_MISSION_STATS_OF_MISSION_START_FRANKLIN_ZERO()
|
|
|
|
SET_PLAYER_CONTROL(PLAYER_ID(), TRUE)
|
|
|
|
IF NOT IS_PED_INJURED(PLAYER_PED_ID())
|
|
IF NOT Is_Replay_In_Progress()
|
|
// no replay - kick mission off normally
|
|
IF NOT bSkippedIntro
|
|
PRINTSTRING("cutscene was not skipped")
|
|
#IF IS_DEBUG_BUILD
|
|
IF iDebugStage >= 0
|
|
SET_MISSION_STAGE(INT_TO_ENUM(MISSION_STAGE_ENUM, iDebugStage), TRUE, TRUE, TRUE, FALSE)
|
|
ELSE
|
|
#ENDIF
|
|
SET_MISSION_STAGE(STAGE_GET_TO_BAD_GUY, FALSE, TRUE, TRUE, TRUE, TRUE, FALSE)
|
|
#IF IS_DEBUG_BUILD
|
|
ENDIF
|
|
#ENDIF
|
|
ELSE
|
|
PRINTSTRING("cutscene was skipped")
|
|
CLEAR_START_AREA()
|
|
//WAIT(SKIP_FADE_WAIT_TIME) temp remove??
|
|
SET_MISSION_STAGE(STAGE_GET_TO_BAD_GUY, TRUE, TRUE, TRUE, FALSE, FALSE)
|
|
ENDIF
|
|
ELSE
|
|
IF HANDLE_MISSION_SHITSKIP()
|
|
CPRINTLN(DEBUG_REPLAY, "Franklin 0: shitskip done")
|
|
ELSE
|
|
INT iReplayStage
|
|
iReplayStage = Get_Replay_Mid_Mission_Stage()
|
|
IF iReplayStage = 0
|
|
POSITION_PLAYER_AT_MISSION_INIT()
|
|
ENDIF
|
|
SET_MISSION_STAGE(INT_TO_ENUM(MISSION_STAGE_ENUM, iReplayStage), TRUE)
|
|
//WAIT(SKIP_FADE_WAIT_TIME) temp remove???
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF NOT bForcePassOnShitskip
|
|
IF IS_SCREEN_FADED_OUT()
|
|
OR IS_SCREEN_FADING_OUT()
|
|
DO_SCREEN_FADE_IN(DEFAULT_FADE_TIME)
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
|
|
missionInitStage = MISSION_INIT_DONE
|
|
ENDPROC
|
|
|
|
PROC RESOLVE_FOR_CUTSCENE()
|
|
RESOLVE_VEHICLES_INSIDE_ANGLED_AREA_WITH_SIZE_LIMIT(<<-42.555, -1458.951, 28.994>>, <<-43.144, -1452.933, 35.456>>, 62, GET_HOOD_VECTOR(HVEC_MOVE_LAST_PLAYER_VEHICLE), MOVE_LAST_PLAYER_VEHICLE_ROT, GET_DEFAULT_ALLOWABLE_VEHICLE_SIZE_VECTOR(), TRUE, FALSE, TRUE)
|
|
RESOLVE_VEHICLES_INSIDE_ANGLED_AREA_WITH_SIZE_LIMIT(<<-19.634, -1431.664, 28.812>>, <<-18.772, -1456.846, 35.471>>, 30, GET_HOOD_VECTOR(HVEC_MOVE_LAST_PLAYER_VEHICLE), MOVE_LAST_PLAYER_VEHICLE_ROT, GET_DEFAULT_ALLOWABLE_VEHICLE_SIZE_VECTOR(), TRUE, FALSE, TRUE)
|
|
RESOLVE_VEHICLES_INSIDE_ANGLED_AREA_WITH_SIZE_LIMIT(<<-75.69051, -1460.39551, 31.11074>>, <<-80.50679, -1452.11475, 30.98960>>, 7.15, <<-64.4662, -1463.3616, 31.6336>>, 112.38, GET_DEFAULT_ALLOWABLE_VEHICLE_SIZE_VECTOR(), TRUE, FALSE, TRUE)
|
|
ENDPROC
|
|
|
|
PROC SET_CHOP_COLLAR()
|
|
// get chop collar
|
|
IF HAS_PLAYER_USED_CHOP_APP()
|
|
iCurrentChopCollar = GET_CHOP_COLLAR_FROM_APP()
|
|
ELSE
|
|
iCurrentChopCollar = 4
|
|
ENDIF
|
|
ENDPROC
|
|
|
|
FUNC VECTOR CONVERT_ROTATION_TO_DIRECTION_VECTOR(VECTOR vRot)
|
|
RETURN <<-SIN(vRot.z) * COS(vRot.x), COS(vRot.z) * COS(vRot.x), SIN(vRot.x)>>
|
|
ENDFUNC
|
|
|
|
// 1st download help
|
|
PROC DO_FIRST_DOWNLOAD_HELP()
|
|
IF NOT bShownFirstDownloadHelp
|
|
AND NOT bFirstDownloadHelpOnCutscene
|
|
IF NOT HAS_PLAYER_USED_CHOP_APP()
|
|
IF GET_GAME_TIMER() >= iStageStartTime + 5000
|
|
#IF NOT FEATURE_GEN9_STANDALONE // url:bugstar:7806385 App currently not supported in Gen9.
|
|
IF DO_MISSION_HELP_TEXT("FC_DOWNLHLP", FALSE)
|
|
#ENDIF
|
|
IF IS_CUTSCENE_PLAYING()
|
|
bFirstDownloadHelpOnCutscene = TRUE
|
|
ENDIF
|
|
bShownFirstDownloadHelp = TRUE
|
|
#IF NOT FEATURE_GEN9_STANDALONE
|
|
ENDIF
|
|
#ENDIF
|
|
ENDIF
|
|
ELSE
|
|
bShownFirstDownloadHelp = TRUE
|
|
ENDIF
|
|
ENDIF
|
|
ENDPROC
|
|
|
|
|
|
// initialise mission
|
|
FUNC BOOL INIT_MISSION()
|
|
SWITCH missionInitStage
|
|
CASE MISSION_INIT_PRE_INTRO
|
|
|
|
SET_PED_NON_CREATION_AREA(<<-61.06803, -1462.89331, 11.02068>>, <<5.86775, -1444.14880, 49.55160>>)
|
|
|
|
REMOVE_MISSION_TEXT()
|
|
SUPPRESS_MISSION_MODELS(TRUE)
|
|
SET_PLAYER_CONTROL(PLAYER_ID(), FALSE, SPC_LEAVE_CAMERA_CONTROL_ON)
|
|
chopBehaviour = GET_CHOP_BEHAVIOUR_FROM_APP()
|
|
|
|
SET_CHOP_COLLAR()
|
|
|
|
IF IS_PLAYER_PED_AVAILABLE(CHAR_TREVOR)
|
|
SET_PLAYER_PED_AVAILABLE(CHAR_TREVOR, FALSE)
|
|
bSetTrevorUnavailable = TRUE
|
|
ENDIF
|
|
|
|
SET_WEATHER_TYPE_OVERTIME_PERSIST("extrasunny", 30.0)
|
|
|
|
// clear franklin bike gen
|
|
//DISABLE_VEHICLE_GEN_ON_MISSION(TRUE)
|
|
|
|
// custom SWITCH icon
|
|
SET_SELECTOR_PED_ICON(sSelectorPeds, SELECTOR_PED_MICHAEL, SELECTOR_ICON_CHOP)
|
|
chopViewCamData.selectorSlot = SELECTOR_PED_MICHAEL
|
|
chopViewCamData.chopMission = CHOP_MISSION_FRANKLIN0
|
|
|
|
g_bBlockShopRoberies = TRUE
|
|
chopViewCamData.bNeverTrevor = TRUE
|
|
|
|
entranceScenarioBlocking = ADD_SCENARIO_BLOCKING_AREA(<<480.4, -776.7, -100>>, <<569.3, -610.7, 76>>)
|
|
recScenarioBlocking = ADD_SCENARIO_BLOCKING_AREA(<<-225.51924, -1513.04578, -100>>, <<-218.96721, -1507.19189, 100.46210>>)
|
|
alleyScenarioBlocking = ADD_SCENARIO_BLOCKING_AREA(<<-91.34664, -1457.38464, 0>>, <<-73.12756, -1381.66003, 100.33570>>)
|
|
outsideYardScenarioBlocking = ADD_SCENARIO_BLOCKING_AREA(<<449.96005, -698.94513, 0.66434>>, <<467.13477, -680.62457, 100.33570>>)
|
|
offPathScenarioBlocking = ADD_SCENARIO_BLOCKING_AREA(<<454.75815, -817.23328, 0.70810>>, <<459.41602, -685.39819, 56.66263>>)
|
|
|
|
// replay attempt
|
|
IF NOT Is_Replay_In_Progress()
|
|
iReplayAttempt = 0
|
|
ELSE
|
|
iReplayAttempt = g_savedGlobals.sFlow.missionSavedData[SP_MISSION_FRANKLIN_0].missionFailsNoProgress + 1
|
|
ENDIF
|
|
|
|
missionInitStage = MISSION_INIT_REQUEST_INTRO
|
|
BREAK
|
|
|
|
CASE MISSION_INIT_REQUEST_INTRO
|
|
IF NOT Is_Replay_In_Progress()
|
|
#IF IS_DEBUG_BUILD
|
|
AND iDebugStage < 0
|
|
#ENDIF
|
|
PREVENT_WANTED_LEVEL_FOR_CUTSCENE()
|
|
|
|
CONST_INT FRANKLIN0_STREAMING_SPECIAL_CUT 4
|
|
IF IS_BIT_SET(g_sTriggerSceneAssets.id, FRANKLIN0_STREAMING_SPECIAL_CUT)
|
|
REQUEST_CUTSCENE_WITH_PLAYBACK_LIST(GET_FRANKLIN0_INTRO_CUTSCENE_NAME(), CS_SECTION_1|CS_SECTION_3|CS_SECTION_4)
|
|
ELSE
|
|
REQUEST_CUTSCENE_WITH_PLAYBACK_LIST(GET_FRANKLIN0_INTRO_CUTSCENE_NAME(), CS_SECTION_2|CS_SECTION_3|CS_SECTION_4)
|
|
ENDIF
|
|
missionInitStage = MISSION_INIT_WAIT_FOR_INTRO
|
|
ELSE
|
|
STOP_CUTSCENE()
|
|
DO_MISSION_INIT_START_MISSION()
|
|
ENDIF
|
|
BREAK
|
|
|
|
CASE MISSION_INIT_WAIT_FOR_INTRO
|
|
SET_ALL_RANDOM_PEDS_FLEE_THIS_FRAME(PLAYER_ID())
|
|
|
|
IF DO_TIMELAPSE(SP_MISSION_FRANKLIN_0, sTimelapse, FALSE, FALSE)
|
|
IF HAS_CUTSCENE_LOADED_WITH_FAILSAFE()
|
|
// register entities and start cutscene
|
|
REGISTER_ENTITY_FOR_CUTSCENE(PLAYER_PED_ID(), "Franklin", CU_ANIMATE_EXISTING_SCRIPT_ENTITY, GET_MODEL_FOR_HOOD_MODEL_ENUM(HM_FRANKLIN))
|
|
REGISTER_ENTITY_FOR_CUTSCENE(lamarPed, "Lamar", CU_CREATE_AND_ANIMATE_NEW_SCRIPT_ENTITY, GET_MODEL_FOR_HOOD_MODEL_ENUM(HM_LAMAR))
|
|
printstring("registered lamar!") printnl()
|
|
REGISTER_ENTITY_FOR_CUTSCENE(chopPed, "Chop", CU_CREATE_AND_ANIMATE_NEW_SCRIPT_ENTITY, GET_MODEL_FOR_HOOD_MODEL_ENUM(HM_CHOP))
|
|
|
|
MISSION_FLOW_RELEASE_TRIGGER_SCENE_ASSETS(SP_MISSION_FRANKLIN_0)
|
|
START_CUTSCENE()
|
|
|
|
REPLAY_START_EVENT(REPLAY_IMPORTANCE_HIGHEST)
|
|
|
|
SET_CUTSCENE_FADE_VALUES(FALSE, FALSE, FALSE, FALSE)
|
|
missionInitStage = MISSION_INIT_PLAY_INTRO
|
|
ENDIF
|
|
ELSE
|
|
IF NOT bRepositionedPlayerForTOD
|
|
IF DOES_CAM_EXIST(sTimelapse.splineCamera)
|
|
IF STREAMVOL_IS_VALID(missionStreamingVolume)
|
|
STREAMVOL_DELETE(missionStreamingVolume)
|
|
ENDIF
|
|
missionStreamingVolume = STREAMVOL_CREATE_FRUSTUM(<<-13.6, -1449.2, 31.1>>, CONVERT_ROTATION_TO_DIRECTION_VECTOR(<<-0.7, 0.8, 4.3>>), 30, FLAG_MAPDATA)
|
|
bWasTimeLapseRunning = TRUE
|
|
printstring("set Timelapse") printnl()
|
|
RESOLVE_FOR_CUTSCENE()
|
|
//CLEAR_PED_TASKS_IMMEDIATELY(PLAYER_PED_ID())
|
|
//SET_ENTITY_COORDS(PLAYER_PED_ID(), <<8.40950, -1453.26440, 29.51403>>)
|
|
bRepositionedPlayerForTOD = TRUE
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
BREAK
|
|
|
|
CASE MISSION_INIT_PLAY_INTRO
|
|
SET_ALL_RANDOM_PEDS_FLEE_THIS_FRAME(PLAYER_ID())
|
|
DISABLE_CONTROL_ACTION(PLAYER_CONTROL, INPUT_JUMP)
|
|
|
|
IF NOT bClearedForCutscene
|
|
IF IS_CUTSCENE_PLAYING()
|
|
IF bWasTimeLapseRunning
|
|
SET_TODS_CUTSCENE_RUNNING(sTimelapse, FALSE)
|
|
ENDIF
|
|
SET_MISSION_MOCAP_CUTSCENE()
|
|
|
|
REQUEST_TEXT(FALSE)
|
|
|
|
DELETE_ALL_TRAINS()
|
|
|
|
IF IS_REPLAY_START_VEHICLE_UNDER_SIZE_LIMIT(<<0,0,0>>, TRUE)
|
|
VEHICLE_INDEX thisVehicle
|
|
thisVehicle = GET_MISSION_START_VEHICLE_INDEX()
|
|
IF IS_VEHICLE_DRIVEABLE(thisVehicle)
|
|
IF GET_ENTITY_MODEL(thisVehicle) = SPEEDO
|
|
IF GET_VEHICLE_COLOUR_COMBINATION(thisVehicle) = 5
|
|
SET_ENTITY_AS_MISSION_ENTITY(thisVehicle)
|
|
DELETE_VEHICLE(thisVehicle)
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
|
|
SET_MISSION_START_VEHICLE_AS_VEHICLE_GEN(GET_HOOD_VECTOR(HVEC_MOVE_LAST_PLAYER_VEHICLE), MOVE_LAST_PLAYER_VEHICLE_ROT, FALSE)
|
|
//SET_MISSION_START_VEHICLE_AS_VEHICLE_GEN(<<0,0,0>>, 0)
|
|
ENDIF
|
|
RESOLVE_FOR_CUTSCENE()
|
|
|
|
CLEAR_AREA_OF_PROJECTILES(<<-14.20779, -1448.72607, 30.01975>>, 25)
|
|
STOP_FIRE_IN_RANGE(<<-14.20779, -1448.72607, 30.01975>>, 25)
|
|
REMOVE_PARTICLE_FX_IN_RANGE(<<-14.20779, -1448.72607, 30.01975>>, 25)
|
|
CLEAR_AREA_OF_OBJECTS(<<-14.20779, -1448.72607, 30.01975>>, 25, CLEAROBJ_FLAG_FORCE)
|
|
|
|
//DELETE_VEHICLE_GEN_VEHICLES_IN_AREA(<< -25.4577, -1436.6381, 29.6542 >>, 100)
|
|
//RESOLVE_VEHICLES_AT_MISSION_TRIGGER()
|
|
SET_FRANKLIN_MASK(FALSE)
|
|
SET_LAMAR_MASK(FALSE)
|
|
|
|
IF STREAMVOL_IS_VALID(missionStreamingVolume)
|
|
STREAMVOL_DELETE(missionStreamingVolume)
|
|
ENDIF
|
|
|
|
// clear the area
|
|
//CLEAR_AREA(<<-14.41, -1442.56, 30.10>>, 20, TRUE)
|
|
|
|
IF IS_SCREEN_FADED_OUT()
|
|
DO_SCREEN_FADE_IN(DEFAULT_FADE_TIME)
|
|
ENDIF
|
|
|
|
bClearedForCutscene = TRUE
|
|
ENDIF
|
|
ENDIF
|
|
|
|
|
|
IF WAS_CUTSCENE_SKIPPED()
|
|
bSkippedCutscene = TRUE
|
|
ENDIF
|
|
|
|
// download help
|
|
IF GET_CUTSCENE_TIME() >= 55554
|
|
AND NOT bSkippedCutscene
|
|
DO_FIRST_DOWNLOAD_HELP()
|
|
ENDIF
|
|
|
|
//IF GET_CUTSCENE_TIME() >= 69205
|
|
// DISABLE_CONTROL_ACTION(FRONTEND_CONTROL, INPUT_SKIP_CUTSCENE)
|
|
//ENDIF
|
|
|
|
// get cutscene-created peds
|
|
IF NOT DOES_ENTITY_EXIST(lamarPed)
|
|
//PRINTSTRING("lamar does not exist") printnl()
|
|
IF DOES_ENTITY_EXIST(GET_ENTITY_INDEX_OF_REGISTERED_ENTITY("Lamar"))
|
|
PRINTSTRING("GRABBED LAMAR") printnl()
|
|
lamarPed = GET_PED_INDEX_FROM_ENTITY_INDEX(GET_ENTITY_INDEX_OF_REGISTERED_ENTITY("Lamar"))
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF NOT DOES_ENTITY_EXIST(chopPed)
|
|
IF DOES_ENTITY_EXIST(GET_ENTITY_INDEX_OF_REGISTERED_ENTITY("Chop"))
|
|
PRINTSTRING("GRABBED CHOP") printnl()
|
|
chopPed = GET_PED_INDEX_FROM_ENTITY_INDEX(GET_ENTITY_INDEX_OF_REGISTERED_ENTITY("Chop"))
|
|
//SET_CUTSCENE_PED_COMPONENT_VARIATION("Chop", PED_COMP_TORSO, 0, 1)
|
|
//SET_CUTSCENE_PED_COMPONENT_VARIATION("Chop", PED_COMP_LEG, 0, 0)
|
|
ENDIF
|
|
ENDIF
|
|
|
|
//ENTITY_INDEX introEntity
|
|
// preload assets
|
|
IF GET_CUTSCENE_TIME() >= 40000
|
|
DO_STREAMING_FOR_NEXT_MISSION_STAGE(TRUE)
|
|
ENDIF
|
|
|
|
// pre-create mission entities not involved in cut
|
|
IF NOT bDoneIntroCreateEntities
|
|
IF streamingStage = MISSION_STREAMING_STAGE_COMPLETE
|
|
IF NOT bDoneIntroClearStart
|
|
CLEAR_START_AREA()
|
|
bDoneIntroClearStart = TRUE
|
|
ELSE
|
|
CREATE_PLAYER_CHARACTERS_WITH_TRANSPORT_IN_MISSION_STAGE(STAGE_GET_TO_BAD_GUY)
|
|
bDoneIntroCreateEntities = TRUE
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF NOT bSkippedCutscene
|
|
IF CAN_SET_EXIT_STATE_FOR_REGISTERED_ENTITY("Lamar")
|
|
IF NOT IS_PED_INJURED(lamarPed)
|
|
SET_ENTITY_COORDS(lamarPed, GET_HOOD_VECTOR(HVEC_LAMAR_WALK_INIT))
|
|
ENDIF
|
|
SETUP_LAMAR_FOR_WALK()
|
|
ENDIF
|
|
IF CAN_SET_EXIT_STATE_FOR_REGISTERED_ENTITY("Chop")
|
|
IF NOT IS_PED_INJURED(chopPed)
|
|
SET_ENTITY_COORDS(chopPed, GET_HOOD_VECTOR(HVEC_CHOP_WALK_INIT))
|
|
ENDIF
|
|
SETUP_CHOP_FOR_WALK()
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF CAN_SET_EXIT_STATE_FOR_CAMERA()
|
|
SET_GAMEPLAY_CAM_RELATIVE_HEADING(0.0)
|
|
ENDIF
|
|
|
|
// set exit state
|
|
IF CAN_SET_EXIT_STATE_FOR_REGISTERED_ENTITY("Franklin")
|
|
IF bSkippedCutscene
|
|
POSITION_PLAYER_AT_MISSION_INIT()
|
|
ENDIF
|
|
SETUP_PLAYER_FOR_WALK()
|
|
ELSE
|
|
IF GET_FOLLOW_PED_CAM_VIEW_MODE() <> CAM_VIEW_MODE_FIRST_PERSON
|
|
SET_PED_MIN_MOVE_BLEND_RATIO(PLAYER_PED_ID(), PEDMOVE_WALK)
|
|
ELSE
|
|
SIMULATE_PLAYER_INPUT_GAIT(PLAYER_ID(), PEDMOVE_WALK, 2000)
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF NOT IS_CUTSCENE_PLAYING()
|
|
IF DOES_CAM_EXIST(sTimelapse.splineCamera)
|
|
DESTROY_CAM(sTimelapse.splineCamera)
|
|
ENDIF
|
|
|
|
REPLAY_STOP_EVENT()
|
|
|
|
bSkippedIntro = bSkippedCutscene
|
|
SET_MISSION_CUTSCENE(FALSE, TRUE, -1, FALSE, TRUE, FALSE)
|
|
|
|
DO_MISSION_INIT_START_MISSION()
|
|
DISABLE_CONTROL_ACTION(PLAYER_CONTROL, INPUT_JUMP)
|
|
ENDIF
|
|
|
|
#IF IS_DEBUG_BUILD
|
|
DEBUG_SKIP_MOCAP()
|
|
#ENDIF
|
|
BREAK
|
|
|
|
CASE MISSION_INIT_DONE
|
|
RETURN TRUE
|
|
BREAK
|
|
ENDSWITCH
|
|
|
|
RETURN FALSE
|
|
ENDFUNC
|
|
|
|
// all player peds block non-temporary events
|
|
PROC REAPPLY_PLAYER_PED_ATTRIBUTES()
|
|
INT i
|
|
REPEAT COUNT_OF(sSelectorPeds.pedID) i
|
|
IF NOT IS_PED_INJURED(sSelectorPeds.pedID[i])
|
|
SET_BLOCKING_OF_NON_TEMPORARY_EVENTS(sSelectorPeds.pedID[i], TRUE)
|
|
SET_PED_RELATIONSHIP_GROUP_HASH(sSelectorPeds.pedID[i], RELGROUPHASH_PLAYER)
|
|
ENDIF
|
|
ENDREPEAT
|
|
ENDPROC
|
|
|
|
// store banter
|
|
FUNC BOOL STORE_BANTER()
|
|
IF IS_ANY_CONVERSATION_ONGOING_OR_QUEUED()
|
|
TEXT_LABEL_23 tBanter = GET_CURRENTLY_PLAYING_STANDARD_CONVERSATION_ROOT()
|
|
IF ARE_STRINGS_EQUAL(tBanter, "FKN0_WALK")
|
|
OR ARE_STRINGS_EQUAL(tBanter, "FKN0_WALK2")
|
|
OR ARE_STRINGS_EQUAL(tBanter, "FKN0_B1AV1")
|
|
OR ARE_STRINGS_EQUAL(tBanter, "FKN0_B1AV2")
|
|
OR ARE_STRINGS_EQUAL(tBanter, "FKN0_B2AV1")
|
|
OR ARE_STRINGS_EQUAL(tBanter, "FKN0_B2AV2")
|
|
OR ARE_STRINGS_EQUAL(tBanter, "FKN0_B3AV1")
|
|
OR ARE_STRINGS_EQUAL(tBanter, "FKN0_NOARM2")
|
|
bSavedBanter = TRUE
|
|
tSavedBanterRoot = tBanter
|
|
tResumeBanterLabel = GET_STANDARD_CONVERSATION_LABEL_FOR_FUTURE_RESUMPTION()
|
|
RETURN TRUE
|
|
ENDIF
|
|
ENDIF
|
|
|
|
RETURN FALSE
|
|
ENDFUNC
|
|
|
|
// restore banter
|
|
FUNC BOOL RESTORE_BANTER()
|
|
IF bSavedBanter
|
|
IF CAN_ADVANCE_MISSION()
|
|
IF CREATE_CONVERSATION_FROM_SPECIFIC_LINE(hoodConversation, "FKN0AUD", tSavedBanterRoot, tResumeBanterLabel, CONV_PRIORITY_HIGH)
|
|
RETURN TRUE
|
|
ENDIF
|
|
ENDIF
|
|
ELSE
|
|
RETURN TRUE
|
|
ENDIF
|
|
|
|
RETURN FALSE
|
|
ENDFUNC
|
|
|
|
// handle lamar reaction to damaging vehicle
|
|
PROC HANDLE_LAMAR_REACTION_TO_DAMAGE()
|
|
INT iCurrentVanHealth = GET_ENTITY_HEALTH(hoodVehicle[HV_FRANKLIN_VAN])
|
|
IF NOT bTriggeredLamarDamageReaction
|
|
//PRINTSTRING("checking = ") PRINTINT(ICurrentVanHealth) PRINTNL()
|
|
IF iCurrentVanHealth < iCachedVanHealth
|
|
IF GET_GAME_TIMER() >= iNextCheckVanHealthTime
|
|
iNextCheckVanHealthTime = GET_GAME_TIMER() + 800
|
|
bTriggeredLamarDamageReaction = TRUE
|
|
ENDIF
|
|
ENDIF
|
|
iCachedVanHealth = iCurrentVanHealth
|
|
ELSE
|
|
IF IS_PED_IN_VEHICLE(PLAYER_PED_ID(), hoodVehicle[HV_FRANKLIN_VAN])
|
|
STRING sString
|
|
IF NOT bDoneAreYouOKChopSpeech
|
|
sString = "FKN0_CRASH"
|
|
ELSE
|
|
sString = "FC_WARNF"
|
|
ENDIF
|
|
|
|
IF DO_MISSION_SPEECH(sString)
|
|
bDoneAreYouOKChopSpeech = TRUE
|
|
bTriggeredLamarDamageReaction = FALSE
|
|
iCachedVanHealth = iCurrentVanHealth
|
|
iNextCheckVanHealthTime = GET_GAME_TIMER() + 12000
|
|
ELSE
|
|
IF GET_GAME_TIMER() >= iNextCheckVanHealthTime
|
|
iCachedVanHealth = iCurrentVanHealth
|
|
bTriggeredLamarDamageReaction = FALSE
|
|
ENDIF
|
|
ENDIF
|
|
ELSE
|
|
iCachedVanHealth = iCurrentVanHealth
|
|
bTriggeredLamarDamageReaction = FALSE
|
|
ENDIF
|
|
ENDIF
|
|
|
|
ENDPROC
|
|
|
|
// handle text for in car
|
|
PROC HANDLE_IN_CAR_PROMPTS(BOOL bDisplayDestinationBlip = TRUE, BOOL bLamarInGroup = FALSE, BOOL bEnforceWantedLevel = FALSE, BOOL bAddToGroup = TRUE)
|
|
BOOL bPlayerVanOK = TRUE
|
|
BOOL bLamarVanOK = TRUE
|
|
BOOL bLamarGroupOK = TRUE
|
|
BOOL bWantedLevelOK = TRUE
|
|
BOOL bAllOK = FALSE
|
|
|
|
IF bLamarInGroup
|
|
IF NOT IS_PED_INJURED(lamarPed)
|
|
IF NOT IS_PED_GROUP_MEMBER(lamarPed, PLAYER_GROUP_ID())
|
|
AND NOT (currentMissionStage = STAGE_GET_TO_BAD_GUY AND chopIntoVanState < CHOP_INTO_VAN_STATE_DONE)
|
|
IF NOT bForcedIntoVan
|
|
bLamarGroupOK = FALSE
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF IS_VEHICLE_DRIVEABLE(hoodVehicle[HV_FRANKLIN_VAN])
|
|
IF bLamarInGroup
|
|
OR NOT bLamarWasInGroup
|
|
IF NOT IS_PED_INJURED(lamarPed)
|
|
IF NOT IS_PED_IN_VEHICLE(lamarPed, hoodVehicle[HV_FRANKLIN_VAN])
|
|
IF NOT bForcedIntoVan
|
|
bLamarVanOK = FALSE
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
IF NOT IS_PED_IN_VEHICLE(PLAYER_PED_ID(), hoodVehicle[HV_FRANKLIN_VAN])
|
|
bPlayerVanOK = FALSE
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF bEnforceWantedLevel
|
|
IF GET_PLAYER_WANTED_LEVEL(PLAYER_ID()) > 0
|
|
bWantedLevelOK = FALSE
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF bLamarGroupOK
|
|
// lamar is group member / not required to be in group
|
|
IF bPlayerVanOK
|
|
// player is in vehicle
|
|
IF iGetInTextStage < 2
|
|
iGetInTextStage = 2
|
|
ENDIF
|
|
|
|
IF bLamarVanOK
|
|
|
|
bDoneReturnSpeech = FALSE
|
|
|
|
IF bWantedLevelOk
|
|
bRemovedBlipsForWanted = FALSE
|
|
IF currentMissionStage <> STAGE_GET_TO_HOUSE
|
|
OR dropoffStage <= DROPOFF_STAGE_POST_CALL // only want wanted speech once here
|
|
bDoneLoseWantedSpeech = FALSE
|
|
ENDIF
|
|
bShownLoseWantedPrompt = FALSE
|
|
|
|
// lamar is in the vehicle / not required to be in vehicle
|
|
IF currentMissionStage = STAGE_GET_TO_BAD_GUY
|
|
OR currentMissionStage = STAGE_GET_TO_HOUSE
|
|
bAllOK = TRUE
|
|
bCheckedKillBanter = FALSE
|
|
|
|
//blip the destination
|
|
IF NOT DOES_BLIP_EXIST(destinationBlip)
|
|
IF bDisplayDestinationBlip
|
|
REMOVE_MISSION_TEXT(FALSE, TRUE, FALSE)
|
|
REMOVE_ALL_BLIPS()
|
|
|
|
VECTOR vBlipPos
|
|
SWITCH currentMissionStage
|
|
CASE STAGE_GET_TO_BAD_GUY
|
|
vBlipPos = GET_HOOD_VECTOR(HVEC_BAD_GUY_HANGOUT)
|
|
BREAK
|
|
CASE STAGE_GET_TO_HOUSE
|
|
IF dropoffStage < DROPOFF_STAGE_STOP_VAN
|
|
vBlipPos = GET_HOOD_VECTOR(HVEC_HOUSE)
|
|
ELSE
|
|
vBlipPos = GET_HOOD_VECTOR(HVEC_REC)
|
|
ENDIF
|
|
BREAK
|
|
ENDSWITCH
|
|
destinationBlip = CREATE_MISSION_BLIP_FOR_COORD(vBlipPos, TRUE)
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF DOES_BLIP_EXIST(franklinVanBlip)
|
|
REMOVE_BLIP(franklinVanBlip)
|
|
ENDIF
|
|
|
|
// display god text
|
|
IF NOT bShownGodText
|
|
IF bDoneGotoSpeech
|
|
SWITCH currentMissionStage
|
|
CASE STAGE_GET_TO_BAD_GUY
|
|
bShownGodText = DO_MISSION_GOD_TEXT("FC_GOVINEW")
|
|
BREAK
|
|
CASE STAGE_GET_TO_HOUSE
|
|
IF dropoffStage < DROPOFF_STAGE_STOP_VAN
|
|
bShownGodText = DO_MISSION_GOD_TEXT("FC_GOHOUSE1")
|
|
ELSE
|
|
IF dropoffStage >= DROPOFF_STAGE_END
|
|
bShownGodText = DO_MISSION_GOD_TEXT("FC_GOREC")
|
|
ENDIF
|
|
ENDIF
|
|
BREAK
|
|
ENDSWITCH
|
|
ENDIF
|
|
ENDIF
|
|
ELSE
|
|
// blip the bad guy car
|
|
IF NOT DOES_BLIP_EXIST(badGuyCarBlip)
|
|
AND NOT DOES_BLIP_EXIST(runnerBlip)
|
|
IF IS_VEHICLE_DRIVEABLE(hoodVehicle[HV_BAD_GUY_BIKE])
|
|
AND NOT IS_PED_INJURED(runnerChaseProperties.ped)
|
|
IF CAN_ADVANCE_MISSION()
|
|
REMOVE_MISSION_TEXT(FALSE, TRUE, FALSE)
|
|
REMOVE_ALL_BLIPS()
|
|
IF IS_PED_IN_ANY_VEHICLE(runnerChaseProperties.ped)
|
|
badGuyCarBlip = CREATE_MISSION_BLIP_FOR_VEHICLE(hoodVehicle[HV_BAD_GUY_BIKE], TRUE)
|
|
ELSE
|
|
runnerBlip = CREATE_MISSION_BLIP_FOR_PED(runnerChaseProperties.ped, TRUE)
|
|
ENDIF
|
|
IF NOT bShownGodText
|
|
//DO_MISSION_GOD_TEXT("FC_CHASE")
|
|
bShownGodText = TRUE
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ELSE
|
|
IF NOT bRemovedBlipsForWanted
|
|
REMOVE_ALL_BLIPS()
|
|
bRemovedBlipsForWanted = TRUE
|
|
ELSE
|
|
REMOVE_VAN_BLIP_AND_TEXT()
|
|
ENDIF
|
|
|
|
IF NOT bDoneLoseWantedSpeech
|
|
IF IS_PED_IN_VEHICLE(PLAYER_PED_ID(), hoodVehicle[HV_FRANKLIN_VAN])
|
|
IF bCheckedKillBanter
|
|
IF currentMissionStage = STAGE_GET_TO_BAD_GUY
|
|
bDoneLoseWantedSpeech = DO_MISSION_SPEECH("FC_WANTBEF")
|
|
ELIF currentMissionStage = STAGE_GET_TO_HOUSE
|
|
AND dropoffStage = DROPOFF_STAGE_STOP_VAN
|
|
IF iLoseWantedTime < 0
|
|
iLoseWantedTime = GET_GAME_TIMER()
|
|
ELSE
|
|
IF GET_GAME_TIMER() >= iLoseWantedTime + 1500
|
|
bDoneLoseWantedSpeech = DO_MISSION_SPEECH("FC_WANTED")
|
|
ENDIF
|
|
ENDIF
|
|
ELIF currentMissionStage = STAGE_GET_TO_HOUSE
|
|
AND dropoffStage <= DROPOFF_STAGE_POST_CALL
|
|
bDoneLoseWantedSpeech = DO_MISSION_SPEECH("FC_WANTVAN")
|
|
ELSE
|
|
bDoneLoseWantedSpeech = TRUE
|
|
ENDIF
|
|
ENDIF
|
|
ELSE
|
|
bDoneLoseWantedSpeech = TRUE
|
|
ENDIF
|
|
ELSE
|
|
IF NOT bShownLoseWantedPrompt
|
|
bShownLoseWantedPrompt = DO_MISSION_GOD_TEXT("LOSE_WANTED")
|
|
SET_NEXT_RANDOM_SPEECH_TIME(10000)
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ELSE
|
|
// lamar is not in the vehicle - blip him
|
|
IF NOT DOES_BLIP_EXIST(lamarBlip)
|
|
REMOVE_MISSION_TEXT(FALSE, TRUE, FALSE)
|
|
REMOVE_ALL_BLIPS()
|
|
lamarBlip = CREATE_MISSION_BLIP_FOR_PED(lamarPed)
|
|
ENDIF
|
|
|
|
IF NOT bDoneWaitForLamarPrompt
|
|
bDoneWaitForLamarPrompt = DO_MISSION_GOD_TEXT("FC_WAIT")
|
|
ENDIF
|
|
ENDIF
|
|
ELSE
|
|
IF NOT DOES_BLIP_EXIST(franklinVanBlip)
|
|
REMOVE_MISSION_TEXT(FALSE, TRUE, FALSE)
|
|
REMOVE_ALL_BLIPS()
|
|
IF iGetInTextStage = 0
|
|
OR iGetInTextStage = 2
|
|
bShouldDoGetInText = TRUE
|
|
ENDIF
|
|
franklinVanBlip = CREATE_MISSION_BLIP_FOR_VEHICLE(hoodVehicle[HV_FRANKLIN_VAN])
|
|
ENDIF
|
|
|
|
IF bShouldDoGetInText
|
|
IF bDoneReturnSpeech
|
|
STRING sGetInString
|
|
SWITCH iGetInTextStage
|
|
CASE 0
|
|
sGetInString = "FC_GOVAN1"
|
|
BREAK
|
|
CASE 2
|
|
sGetInString = "FC_GOVAN2"
|
|
BREAK
|
|
ENDSWITCH
|
|
|
|
IF DO_MISSION_GOD_TEXT(sGetInString)
|
|
bShouldDoGetInText = FALSE
|
|
|
|
REPLAY_RECORD_BACK_FOR_TIME(4.0, 4.0, REPLAY_IMPORTANCE_HIGH)
|
|
|
|
iGetInTextStage++
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
|
|
// special case return speech
|
|
IF NOT bDoneReturnSpeech
|
|
IF bCheckedKillBanter
|
|
IF currentMissionStage = STAGE_VAN_CHASE
|
|
AND NOT IS_PED_IN_VEHICLE(lamarPed, hoodVehicle[HV_FRANKLIN_VAN])
|
|
bDoneReturnSpeech = DO_MISSION_SPEECH("FC_VANNOW")
|
|
ELSE
|
|
IF currentMissionStage <> STAGE_GET_TO_BAD_GUY
|
|
OR bDoneLamarIntoVan
|
|
bDoneReturnSpeech = DO_MISSION_SPEECH("FC_FGOTOUT")
|
|
ELSE
|
|
bDoneReturnSpeech = TRUE
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ELSE
|
|
// lamar is not group member
|
|
IF IS_ENTITY_AT_ENTITY(PLAYER_PED_ID(), lamarPed, <<12, 12, 6>>)
|
|
// re-add to group
|
|
IF bAddToGroup
|
|
IF chopIntoVanState = CHOP_INTO_VAN_STATE_DONE
|
|
OR currentMissionStage > STAGE_GET_TO_BAD_GUY
|
|
SET_PED_AS_GROUP_MEMBER(lamarPed, PLAYER_GROUP_ID())
|
|
ENDIF
|
|
ENDIF
|
|
ELSE
|
|
// do blip and god text
|
|
IF NOT DOES_BLIP_EXIST(lamarBlip)
|
|
REMOVE_MISSION_TEXT(FALSE, TRUE, FALSE)
|
|
REMOVE_ALL_BLIPS()
|
|
lamarBlip = CREATE_MISSION_BLIP_FOR_PED(lamarPed)
|
|
ENDIF
|
|
IF NOT bDoneGetLamarPrompt
|
|
bDoneGetLamarPrompt = DO_MISSION_GOD_TEXT("FC_LEAVE")
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF bAllOK
|
|
IF IS_PLAYER_BROWSING_ITEMS_IN_ANY_SHOP()
|
|
bAllOK = FALSE
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF NOT bAllOK
|
|
IF NOT bSavedBanter
|
|
IF STORE_BANTER()
|
|
KILL_ANY_CONVERSATION()
|
|
ENDIF
|
|
bCheckedKillBanter = TRUE
|
|
ENDIF
|
|
ENDIF
|
|
ENDPROC
|
|
|
|
// is player threatening ped?
|
|
FUNC BOOL IS_PLAYER_THREATENING_PED(PED_INDEX ped, BOOL bDoShootingInAreaCheck = TRUE)
|
|
VECTOR vPos
|
|
vPos = GET_ENTITY_COORDS(ped)
|
|
|
|
IF IS_PLAYER_TARGETTING_ENTITY(PLAYER_ID(), ped)
|
|
OR IS_PLAYER_FREE_AIMING_AT_ENTITY(PLAYER_ID(), ped)
|
|
IF IS_ENTITY_IN_ANGLED_AREA(PLAYER_PED_ID(), vPos, GET_OFFSET_FROM_ENTITY_IN_WORLD_COORDS(ped, <<0,20,0>>), 8, FALSE, FALSE)
|
|
RETURN TRUE
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF bDoShootingInAreaCheck
|
|
IF IS_PED_SHOOTING_IN_AREA(PLAYER_PED_ID(), vPos - <<35,35,35>>, vPos + <<35,35,35>>, FALSE, FALSE)
|
|
RETURN TRUE
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF HAS_ENTITY_BEEN_DAMAGED_BY_ENTITY(ped, PLAYER_PED_ID())
|
|
RETURN TRUE
|
|
ENDIF
|
|
|
|
RETURN FALSE
|
|
ENDFUNC
|
|
|
|
|
|
FUNC VECTOR GET_CHASE_ANIM_COORDS(CHASE_ANIM_ENUM getAnim)
|
|
SWITCH getAnim
|
|
CASE CHASE_ANIM_G_TOP_FENCE
|
|
//RETURN <<477.92, -582.25, 27.51>>
|
|
RETURN <<475.59, -586.06, 27.51>>
|
|
BREAK
|
|
CASE CHASE_ANIM_G_DOWN_CONTAINER
|
|
RETURN <<487.07, -569.60, 28.46>>
|
|
BREAK
|
|
CASE CHASE_ANIM_G_OVER_CAR
|
|
RETURN <<493.20, -545.27, 23.75>>
|
|
BREAK
|
|
CASE CHASE_ANIM_G_OVER_YARD_FENCE
|
|
RETURN <<493.80, -523.79, 23.75>>
|
|
BREAK
|
|
CASE CHASE_ANIM_G_FLATBEDS
|
|
RETURN <<531.66, -502.47, 23.80>>
|
|
BREAK
|
|
CASE CHASE_ANIM_G_BOXCAR
|
|
RETURN <<555.470, -504.140, 23.800>>
|
|
BREAK
|
|
CASE CHASE_ANIM_G_ONTO_TRAIN
|
|
RETURN <<552.98, -564.71, 23.83>>
|
|
BREAK
|
|
CASE CHASE_ANIM_F_THROUGH_YARD_FENCE
|
|
RETURN <<493.38, -519.92, 24.25>>
|
|
BREAK
|
|
|
|
CASE CHASE_ANIM_C_TOP_FENCE
|
|
RETURN <<478.300, -582.000, 27.850>>
|
|
BREAK
|
|
CASE CHASE_ANIM_C_OFF_ROOF
|
|
RETURN <<486.530, -570.450, 28.700>>
|
|
BREAK
|
|
CASE CHASE_ANIM_C_OVER_CAR
|
|
RETURN <<492.530, -544.550, 24.180>>
|
|
BREAK
|
|
CASE CHASE_ANIM_C_FLATBEDS
|
|
RETURN <<532.000, -501.100, 24.250>>
|
|
BREAK
|
|
CASE CHASE_ANIM_C_BOXCAR
|
|
RETURN <<556.720, -503.840, 24.250>>
|
|
BREAK
|
|
ENDSWITCH
|
|
|
|
RETURN <<0,0,0>>
|
|
ENDFUNC
|
|
|
|
FUNC VECTOR GET_CHASE_IDEAL_ANIM_COORDS(CHASE_ANIM_ENUM getAnim)
|
|
SWITCH getAnim
|
|
CASE CHASE_ANIM_G_TOP_FENCE
|
|
RETURN <<475.450, -585.300, 28.560>>
|
|
BREAK
|
|
CASE CHASE_ANIM_G_DOWN_CONTAINER
|
|
RETURN <<486.800, -569.620, 29.130>>
|
|
BREAK
|
|
CASE CHASE_ANIM_G_OVER_CAR
|
|
RETURN <<492.630, -544.440, 24.75>>
|
|
BREAK
|
|
CASE CHASE_ANIM_G_OVER_YARD_FENCE
|
|
RETURN <<493.74, -524.130, 24.75>>
|
|
BREAK
|
|
CASE CHASE_ANIM_G_FLATBEDS
|
|
RETURN <<530.870, -502.050, 24.830>>
|
|
BREAK
|
|
CASE CHASE_ANIM_G_BOXCAR
|
|
RETURN <<555.470, -504.140, 24.800>>
|
|
BREAK
|
|
CASE CHASE_ANIM_G_ONTO_TRAIN
|
|
RETURN <<549.06, -565.13, 24.75>>
|
|
BREAK
|
|
CASE CHASE_ANIM_F_THROUGH_YARD_FENCE
|
|
RETURN <<493.38, -519.92, 25.25>>
|
|
BREAK
|
|
CASE CHASE_ANIM_C_TOP_FENCE
|
|
RETURN <<478.300, -582.000, 27.950>>
|
|
BREAK
|
|
CASE CHASE_ANIM_C_OFF_ROOF
|
|
RETURN <<486.530, -570.450, 28.700>>
|
|
BREAK
|
|
CASE CHASE_ANIM_C_OVER_CAR
|
|
RETURN <<492.530, -544.550, 24.180>>
|
|
BREAK
|
|
CASE CHASE_ANIM_C_FLATBEDS
|
|
RETURN <<532.000, -501.100, 24.250>>
|
|
BREAK
|
|
CASE CHASE_ANIM_C_BOXCAR
|
|
RETURN <<556.690, -503.840, 24.190>>
|
|
BREAK
|
|
ENDSWITCH
|
|
|
|
RETURN <<0,0,0>>
|
|
ENDFUNC
|
|
|
|
FUNC FLOAT GET_CHASE_ANIM_HEADING(CHASE_ANIM_ENUM getAnim)
|
|
SWITCH getAnim
|
|
CASE CHASE_ANIM_G_TOP_FENCE
|
|
RETURN -96.59
|
|
BREAK
|
|
CASE CHASE_ANIM_G_DOWN_CONTAINER
|
|
RETURN 7.300
|
|
BREAK
|
|
CASE CHASE_ANIM_G_OVER_CAR
|
|
RETURN -8.93
|
|
BREAK
|
|
CASE CHASE_ANIM_G_OVER_YARD_FENCE
|
|
CASE CHASE_ANIM_F_THROUGH_YARD_FENCE
|
|
RETURN -4.64
|
|
BREAK
|
|
CASE CHASE_ANIM_G_FLATBEDS
|
|
RETURN -96.770
|
|
BREAK
|
|
CASE CHASE_ANIM_G_BOXCAR
|
|
RETURN -99.36
|
|
BREAK
|
|
CASE CHASE_ANIM_G_ONTO_TRAIN
|
|
RETURN 79.23
|
|
BREAK
|
|
CASE CHASE_ANIM_F_OFF_ROOF
|
|
RETURN -6.37
|
|
BREAK
|
|
CASE CHASE_ANIM_C_TOP_FENCE
|
|
RETURN -110.000
|
|
BREAK
|
|
CASE CHASE_ANIM_C_OFF_ROOF
|
|
RETURN -30.000
|
|
BREAK
|
|
CASE CHASE_ANIM_C_OVER_CAR
|
|
RETURN -4.000
|
|
BREAK
|
|
CASE CHASE_ANIM_C_FLATBEDS
|
|
RETURN -97.330
|
|
BREAK
|
|
CASE CHASE_ANIM_C_BOXCAR
|
|
RETURN -96.500
|
|
BREAK
|
|
ENDSWITCH
|
|
|
|
RETURN 0.0
|
|
ENDFUNC
|
|
|
|
FUNC FLOAT GET_CHASE_IDEAL_ANIM_HEADING(CHASE_ANIM_ENUM getAnim)
|
|
SWITCH getAnim
|
|
CASE CHASE_ANIM_G_TOP_FENCE
|
|
RETURN -95.660
|
|
BREAK
|
|
CASE CHASE_ANIM_G_DOWN_CONTAINER
|
|
RETURN -8.0
|
|
BREAK
|
|
CASE CHASE_ANIM_G_OVER_CAR
|
|
RETURN -3.000
|
|
BREAK
|
|
CASE CHASE_ANIM_G_OVER_YARD_FENCE
|
|
RETURN -3.99
|
|
BREAK
|
|
CASE CHASE_ANIM_G_FLATBEDS
|
|
RETURN -96.59
|
|
BREAK
|
|
CASE CHASE_ANIM_G_BOXCAR
|
|
RETURN -97.530
|
|
BREAK
|
|
CASE CHASE_ANIM_G_ONTO_TRAIN
|
|
RETURN 79.23
|
|
BREAK
|
|
CASE CHASE_ANIM_F_OFF_ROOF
|
|
RETURN -6.37
|
|
BREAK
|
|
CASE CHASE_ANIM_C_TOP_FENCE
|
|
RETURN -110.000
|
|
BREAK
|
|
CASE CHASE_ANIM_C_OFF_ROOF
|
|
RETURN -30.000
|
|
BREAK
|
|
CASE CHASE_ANIM_C_OVER_CAR
|
|
RETURN -4.000
|
|
BREAK
|
|
CASE CHASE_ANIM_C_FLATBEDS
|
|
RETURN -97.330
|
|
BREAK
|
|
CASE CHASE_ANIM_C_BOXCAR
|
|
RETURN -96.500
|
|
BREAK
|
|
ENDSWITCH
|
|
|
|
RETURN 0.0
|
|
ENDFUNC
|
|
|
|
FUNC BOOL IS_PED_AT_EMERGENCY_CHASE_ANIM_TRIGGER(PED_INDEX ped, CHASE_ANIM_ENUM thisAnim)
|
|
IF NOT IS_PED_INJURED(ped)
|
|
VECTOR vPedCoords = GET_ENTITY_COORDS(ped)
|
|
SWITCH thisAnim
|
|
CASE CHASE_ANIM_G_TOP_FENCE
|
|
IF vPedCoords.x >= 475.59
|
|
RETURN TRUE
|
|
ENDIF
|
|
BREAK
|
|
CASE CHASE_ANIM_G_DOWN_CONTAINER
|
|
IF vPedCoords.y >= -569.60
|
|
RETURN TRUE
|
|
ENDIF
|
|
BREAK
|
|
CASE CHASE_ANIM_G_OVER_CAR
|
|
IF vPedCoords.y >= -545.27
|
|
RETURN TRUE
|
|
ENDIF
|
|
BREAK
|
|
CASE CHASE_ANIM_G_OVER_YARD_FENCE
|
|
IF vPedCoords.y >= -523.79
|
|
RETURN TRUE
|
|
ENDIF
|
|
BREAK
|
|
CASE CHASE_ANIM_G_FLATBEDS
|
|
IF vPedCoords.x >= 531.66
|
|
RETURN TRUE
|
|
ENDIF
|
|
BREAK
|
|
CASE CHASE_ANIM_G_BOXCAR
|
|
IF vPedCoords.x >= 555.470
|
|
RETURN TRUE
|
|
ENDIF
|
|
BREAK
|
|
CASE CHASE_ANIM_G_ONTO_TRAIN
|
|
IF vPedCoords.x <= 552.98
|
|
RETURN TRUE
|
|
ENDIF
|
|
BREAK
|
|
CASE CHASE_ANIM_F_OFF_ROOF
|
|
RETURN FALSE
|
|
BREAK
|
|
CASE CHASE_ANIM_C_TOP_FENCE
|
|
IF vPedCoords.x >= 478.300
|
|
RETURN TRUE
|
|
ENDIF
|
|
BREAK
|
|
CASE CHASE_ANIM_C_OFF_ROOF
|
|
IF vPedCoords.y >= -570.450
|
|
RETURN TRUE
|
|
ENDIF
|
|
BREAK
|
|
CASE CHASE_ANIM_C_OVER_CAR
|
|
IF vPedCoords.y >= -544.550
|
|
RETURN TRUE
|
|
ENDIF
|
|
BREAK
|
|
CASE CHASE_ANIM_C_FLATBEDS
|
|
IF vPedCoords.x >= 532.000
|
|
RETURN TRUE
|
|
ENDIF
|
|
BREAK
|
|
CASE CHASE_ANIM_C_BOXCAR
|
|
IF vPedCoords.x >= 556.720
|
|
RETURN TRUE
|
|
ENDIF
|
|
BREAK
|
|
ENDSWITCH
|
|
ENDIF
|
|
|
|
RETURN FALSE
|
|
ENDFUNC
|
|
|
|
FUNC VECTOR GET_CHASE_ANIM_DIMENSIONS(CHASE_ANIM_ENUM getAnim)
|
|
SWITCH getAnim
|
|
CASE CHASE_ANIM_C_TOP_FENCE
|
|
BREAK
|
|
ENDSWITCH
|
|
RETURN <<0.5, 0.5, 2.5>>
|
|
ENDFUNC
|
|
|
|
FUNC STRING GET_CHASE_ANIM_NAME(CHASE_ANIM_ENUM getAnim)
|
|
SWITCH getAnim
|
|
CASE CHASE_ANIM_G_TOP_FENCE
|
|
RETURN "ballasog_fenceclimb"
|
|
BREAK
|
|
CASE CHASE_ANIM_G_DOWN_CONTAINER
|
|
RETURN "ballasog_containerrun"
|
|
BREAK
|
|
CASE CHASE_ANIM_G_OVER_CAR
|
|
RETURN "ballasog_carbonnetslide"
|
|
BREAK
|
|
CASE CHASE_ANIM_G_OVER_YARD_FENCE
|
|
RETURN "ballasog_fenceclimb_ig4"
|
|
BREAK
|
|
CASE CHASE_ANIM_F_THROUGH_YARD_FENCE
|
|
RETURN "franklin_wallcrash"
|
|
BREAK
|
|
CASE CHASE_ANIM_G_FLATBEDS
|
|
RETURN "ballasog_hoptrainbreak_ig5"
|
|
BREAK
|
|
CASE CHASE_ANIM_G_BOXCAR
|
|
//RETURN "ballasog_rollthroughtraincar_ig6"
|
|
RETURN "ballasog_rollthroughtraincar_ig6_in"
|
|
BREAK
|
|
CASE CHASE_ANIM_G_WAITING_ON_GROUND
|
|
RETURN "ballasog_rollthroughtraincar_ig6_loop"
|
|
BREAK
|
|
CASE CHASE_ANIM_G_GET_UP_FROM_GROUND
|
|
RETURN "ballasog_rollthroughtraincar_ig6_out"
|
|
BREAK
|
|
CASE CHASE_ANIM_G_ONTO_TRAIN
|
|
RETURN "ballasog_jumpontrain_ig7"
|
|
BREAK
|
|
CASE CHASE_ANIM_C_TOP_FENCE
|
|
RETURN "FRA_0_IG_8_P1_CHOP_JUMPS_UNDER_FENCE"
|
|
BREAK
|
|
CASE CHASE_ANIM_C_OFF_ROOF
|
|
RETURN "FRA_0_CHOP_JUMPS_DOWN"
|
|
BREAK
|
|
CASE CHASE_ANIM_C_OVER_CAR
|
|
RETURN "FRA_0_IG_9_CHOP_JUMP_OVER_CAR_HOOD"
|
|
BREAK
|
|
CASE CHASE_ANIM_C_FLATBEDS
|
|
RETURN "FRA_0_IG_10_CHOP_JUMPS_OVER_FLATBED"
|
|
BREAK
|
|
CASE CHASE_ANIM_C_BOXCAR
|
|
RETURN "FRA_0_IG_11_CHOP_JUMPS_THROUGH_BOXCAR"
|
|
BREAK
|
|
ENDSWITCH
|
|
|
|
RETURN "invalid"
|
|
ENDFUNC
|
|
|
|
FUNC CHASE_ANIM_ENUM GET_NEXT_CHASE_ANIM_FOR_RUNNER()
|
|
SWITCH runnerStage
|
|
CASE RUNNER_START_FLEE
|
|
RETURN CHASE_ANIM_G_TOP_FENCE
|
|
BREAK
|
|
CASE RUNNER_TO_CONTAINER
|
|
RETURN CHASE_ANIM_G_DOWN_CONTAINER
|
|
BREAK
|
|
CASE RUNNER_TO_CAR
|
|
RETURN CHASE_ANIM_G_OVER_CAR
|
|
BREAK
|
|
CASE RUNNER_TO_FENCE
|
|
RETURN CHASE_ANIM_G_OVER_YARD_FENCE
|
|
BREAK
|
|
CASE RUNNER_TO_FLATBEDS
|
|
RETURN CHASE_ANIM_G_FLATBEDS
|
|
BREAK
|
|
CASE RUNNER_TO_BOXCAR
|
|
RETURN CHASE_ANIM_G_BOXCAR
|
|
BREAK
|
|
ENDSWITCH
|
|
|
|
RETURN CHASE_ANIM_BAD
|
|
ENDFUNC
|
|
|
|
FUNC CHASE_ANIM_ENUM GET_NEXT_CHASE_ANIM_FOR_CHOP()
|
|
SWITCH chopStage
|
|
CASE CHOP_START_CHASE
|
|
RETURN CHASE_ANIM_C_TOP_FENCE
|
|
BREAK
|
|
CASE CHOP_TO_ROOF_EDGE
|
|
RETURN CHASE_ANIM_C_OFF_ROOF
|
|
BREAK
|
|
CASE CHOP_TO_CAR
|
|
RETURN CHASE_ANIM_C_OVER_CAR
|
|
BREAK
|
|
CASE CHOP_TO_FENCE
|
|
RETURN CHASE_ANIM_C_FLATBEDS
|
|
BREAK
|
|
CASE CHOP_TO_FLATBEDS
|
|
RETURN CHASE_ANIM_C_FLATBEDS
|
|
BREAK
|
|
CASE CHOP_TO_BOXCAR
|
|
RETURN CHASE_ANIM_C_BOXCAR
|
|
BREAK
|
|
ENDSWITCH
|
|
|
|
RETURN CHASE_ANIM_BAD
|
|
ENDFUNC
|
|
|
|
// get a heading normalised between 0 and 360
|
|
FUNC FLOAT NORMALISE_HEADING(FLOAT fHeading)
|
|
FLOAT fReturn = fHeading
|
|
IF fReturn < 0
|
|
fReturn += 360
|
|
ELIF fReturn > 360
|
|
fReturn -= 360
|
|
ENDIF
|
|
RETURN fReturn
|
|
ENDFUNC
|
|
|
|
FUNC BOOL IS_PED_AT_CORRECT_HEADING_FOR_CHASE_ANIM(PED_INDEX ped, CHASE_ANIM_ENUM checkAnim, FLOAT allowAngleFrom0 = 25.0)
|
|
FLOAT fPedHeading = NORMALISE_HEADING(GET_ENTITY_HEADING(ped))
|
|
FLOAT fAnimHeading = NORMALISE_HEADING(GET_CHASE_ANIM_HEADING(checkAnim))
|
|
FLOAT fHeadingDiff = fPedHeading - fAnimHeading
|
|
IF fHeadingDiff < 0
|
|
fHeadingDiff *= -1
|
|
ENDIF
|
|
IF fHeadingDiff <= allowAngleFrom0
|
|
OR fHeadingDiff >= 360 - allowAngleFrom0
|
|
RETURN TRUE
|
|
ENDIF
|
|
|
|
RETURN FALSE
|
|
ENDFUNC
|
|
|
|
FUNC BOOL IS_PED_AT_CORRECT_HEADING(PED_INDEX ped, FLOAT fAngle, FLOAT allowAngleFrom0 = 25.0)
|
|
FLOAT fPedHeading = NORMALISE_HEADING(GET_ENTITY_HEADING(ped))
|
|
FLOAT fHeadingDiff = fPedHeading - fAngle
|
|
IF fHeadingDiff < 0
|
|
fHeadingDiff *= -1
|
|
ENDIF
|
|
IF fHeadingDiff <= allowAngleFrom0
|
|
OR fHeadingDiff >= 360 - allowAngleFrom0
|
|
RETURN TRUE
|
|
ENDIF
|
|
|
|
RETURN FALSE
|
|
ENDFUNC
|
|
|
|
// yard vehicles
|
|
PROC HANDLE_YARD_VEHICLES()
|
|
INT i
|
|
|
|
REPEAT NUMBER_YARD_VEHICLES i
|
|
IF NOT bStartedYardVehicle[i]
|
|
IF IS_VEHICLE_DRIVEABLE(yardVehicle[i])
|
|
SETPIECE_STAGE_ENUM startStage
|
|
INT iStartTime
|
|
FLOAT fStartDistance
|
|
|
|
SWITCH INT_TO_ENUM(YARD_VEHICLE_ENUM, i)
|
|
// CASE YV_CAR_CARPARK_COME_ROUND_CORNER
|
|
// iStartTime = 12000
|
|
// startStage = SETPIECE_FREE_TO_ROOF
|
|
// BREAK
|
|
CASE YV_CAR_CARPARK_PULL_OUT_FOR_JUMP_OVER
|
|
iStartTime = 800
|
|
startStage = SETPIECE_LOCK_CAR_SLIDE
|
|
BREAK
|
|
//CASE YV_CAR_STATION_PULL_OUT_TO_LEAVE
|
|
// startStage = SETPIECE_LOCK_BUS_REVERSING
|
|
// iStartTime = 0
|
|
//BREAK
|
|
CASE YV_CAR_STATION_PULL_INTO_DEPOT
|
|
startStage = SETPIECE_LOCK_BUS_REVERSING
|
|
iStartTime = 200 // 1500
|
|
BREAK
|
|
//CASE YV_CAR_ROAD_FROM_RIGHT
|
|
CASE YV_BUS_ROAD_FROM_LEFT
|
|
CASE YV_CAR_CARPARK_STATIC
|
|
iStartTime = -1
|
|
fStartDistance = -1
|
|
BREAK
|
|
CASE YV_BUS_REVERSE
|
|
startStage = SETPIECE_LOCK_BUS_REVERSING
|
|
iStartTime = 0
|
|
BREAK
|
|
CASE YV_BUS_PULL_OUT
|
|
startStage = SETPIECE_FREE_INTO_STATION
|
|
iStartTime = -1
|
|
fStartDistance = 35.0
|
|
BREAK
|
|
CASE YV_BUS_STATIC
|
|
iStartTime = -1
|
|
fStartDistance = -1
|
|
BREAK
|
|
ENDSWITCH
|
|
|
|
BOOL bDoStartVehicle = FALSE
|
|
IF iStartTime >= 0
|
|
IF setpieceStage = startStage
|
|
IF GET_GAME_TIMER() >= iSetpieceStageStartTime + iStartTime
|
|
bDoStartVehicle = TRUE
|
|
ENDIF
|
|
ENDIF
|
|
ELIF fStartDistance >= 0
|
|
IF IS_ENTITY_AT_ENTITY(PLAYER_PED_ID(), yardVehicle[i], <<fStartDistance,fStartDistance,fStartDistance>>, FALSE, FALSE)
|
|
bDoStartVehicle = TRUE
|
|
ENDIF
|
|
ELSE
|
|
bStartedYardVehicle[i] = TRUE
|
|
ENDIF
|
|
|
|
PED_INDEX thisDriverPed = GET_PED_IN_VEHICLE_SEAT(yardVehicle[i], VS_DRIVER)
|
|
|
|
IF bDoStartVehicle
|
|
AND bStartedRunnerMovement
|
|
// NG - prioritise reversing bus audio so hear it beeping
|
|
IF INT_TO_ENUM(YARD_VEHICLE_ENUM, i) = YV_BUS_REVERSE
|
|
SET_AUDIO_VEHICLE_PRIORITY(yardVehicle[i], AUDIO_VEHICLE_PRIORITY_HIGH )
|
|
printstring("bus audio on") printnl()
|
|
bRevertedReverseBusAudio = FALSE
|
|
ENDIF
|
|
|
|
IF IS_PLAYBACK_GOING_ON_FOR_VEHICLE(yardVehicle[i])
|
|
UNPAUSE_PLAYBACK_RECORDED_VEHICLE(yardVehicle[i])
|
|
ELSE
|
|
IF NOT IS_PED_INJURED(thisDriverPed)
|
|
IF INT_TO_ENUM(YARD_VEHICLE_ENUM, i) = YV_BUS_PULL_OUT
|
|
|
|
CLEAR_SEQUENCE_TASK(sequence)
|
|
OPEN_SEQUENCE_TASK(sequence)
|
|
TASK_VEHICLE_DRIVE_TO_COORD(NULL, yardVehicle[i], <<462.88696, -678.77960, 26.42194>>, 5.0, DRIVINGSTYLE_NORMAL, GET_ENTITY_MODEL(yardVehicle[i]), DRIVINGMODE_STOPFORCARS, 2.0, 100000)
|
|
TASK_VEHICLE_DRIVE_TO_COORD(NULL, yardVehicle[i], <<472.43823, -680.04065, 25.72182>>, 5.0, DRIVINGSTYLE_NORMAL, GET_ENTITY_MODEL(yardVehicle[i]), DRIVINGMODE_STOPFORCARS, 2.0, 100000)
|
|
TASK_VEHICLE_DRIVE_TO_COORD(NULL, yardVehicle[i], <<500.40128, -772.94299, 23.84175>>, 5.0, DRIVINGSTYLE_NORMAL, GET_ENTITY_MODEL(yardVehicle[i]), DRIVINGMODE_STOPFORCARS, -1, -1)
|
|
|
|
CLOSE_SEQUENCE_TASK(sequence)
|
|
TASK_PERFORM_SEQUENCE(thisDriverPed, sequence)
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
bStartedYardVehicle[i] = TRUE
|
|
ENDIF
|
|
|
|
IF IS_PLAYBACK_GOING_ON_FOR_VEHICLE(yardVehicle[i])
|
|
IF IS_PED_INJURED(thisDriverPed)
|
|
STOP_PLAYBACK_RECORDED_VEHICLE(yardVehicle[i])
|
|
// NG
|
|
SET_AUDIO_VEHICLE_PRIORITY(yardVehicle[i], AUDIO_VEHICLE_PRIORITY_NORMAL)
|
|
printstring("bus audio off 2") printnl()
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ELSE
|
|
// NG
|
|
IF NOT bRevertedReverseBusAudio
|
|
IF INT_TO_ENUM(YARD_VEHICLE_ENUM, i) = YV_BUS_REVERSE
|
|
IF IS_VEHICLE_DRIVEABLE(yardVehicle[i])
|
|
IF NOT IS_PLAYBACK_GOING_ON_FOR_VEHICLE(yardVehicle[i])
|
|
printstring("bus audio off 1") printnl()
|
|
SET_AUDIO_VEHICLE_PRIORITY(yardVehicle[i], AUDIO_VEHICLE_PRIORITY_NORMAL)
|
|
bRevertedReverseBusAudio = TRUE
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDREPEAT
|
|
|
|
// driver that bad guys slid on swears
|
|
IF NOT IS_PED_INJURED(driverPed[YV_CAR_CARPARK_PULL_OUT_FOR_JUMP_OVER])
|
|
AND NOT IS_PED_INJURED(chopPed)
|
|
AND NOT IS_PED_INJURED(runnerChaseProperties.ped)
|
|
AND IS_VEHICLE_DRIVEABLE(yardVehicle[YV_CAR_CARPARK_PULL_OUT_FOR_JUMP_OVER])
|
|
SWITCH driverOutState
|
|
CASE DRIVER_OUT_INACTIVE
|
|
VECTOR vRunnerPos
|
|
vRunnerPos = GET_ENTITY_COORDS(runnerChaseProperties.ped)
|
|
|
|
//IF NOT IS_PLAYBACK_GOING_ON_FOR_VEHICLE(yardVehicle[YV_CAR_CARPARK_PULL_OUT_FOR_JUMP_OVER])
|
|
IF vRunnerPos.y > -538.4
|
|
TASK_LOOK_AT_ENTITY(driverPed[YV_CAR_CARPARK_PULL_OUT_FOR_JUMP_OVER], runnerChaseProperties.ped, -1, SLF_WHILE_NOT_IN_FOV)
|
|
iDriverOutTime = GET_GAME_TIMER()
|
|
driverOutState = DRIVER_OUT_WAIT
|
|
ENDIF
|
|
BREAK
|
|
CASE DRIVER_OUT_WAIT
|
|
IF GET_GAME_TIMER() >= iDriverOutTime + 10
|
|
TASK_LEAVE_VEHICLE(driverPed[YV_CAR_CARPARK_PULL_OUT_FOR_JUMP_OVER], yardVehicle[YV_CAR_CARPARK_PULL_OUT_FOR_JUMP_OVER], ECF_DONT_CLOSE_DOOR)
|
|
driverOutState = DRIVER_OUT_LEAVE_VEHICLE
|
|
ENDIF
|
|
BREAK
|
|
|
|
CASE DRIVER_OUT_LEAVE_VEHICLE
|
|
IF GET_SCRIPT_TASK_STATUS(driverPed[YV_CAR_CARPARK_PULL_OUT_FOR_JUMP_OVER], SCRIPT_TASK_LEAVE_VEHICLE) = FINISHED_TASK
|
|
iDriverOutTime = GET_GAME_TIMER()
|
|
TASK_ACHIEVE_HEADING(driverPed[YV_CAR_CARPARK_PULL_OUT_FOR_JUMP_OVER], -3.26)
|
|
driverOutState = DRIVER_OUT_GET_HEADING
|
|
ENDIF
|
|
BREAK
|
|
CASE DRIVER_OUT_GET_HEADING
|
|
IF IS_PED_AT_CORRECT_HEADING(driverPed[YV_CAR_CARPARK_PULL_OUT_FOR_JUMP_OVER], -3.26, 20)
|
|
//TASK_PLAY_ANIM(driverPed[YV_CAR_CARPARK_PULL_OUT_FOR_JUMP_OVER], GET_HOOD_ANIM_DICT_AS_STRING(H_ANIM_DICT_MISSION), "react_left_small_intro_a", NORMAL_BLEND_IN, NORMAL_BLEND_OUT, -1, AF_HOLD_LAST_FRAME)
|
|
driverOutState = DRIVER_OUT_INTO_ANIM
|
|
ENDIF
|
|
BREAK
|
|
|
|
CASE DRIVER_OUT_INTO_ANIM
|
|
//IF IS_ENTITY_PLAYING_ANIM(driverPed[YV_CAR_CARPARK_PULL_OUT_FOR_JUMP_OVER], GET_HOOD_ANIM_DICT_AS_STRING(H_ANIM_DICT_MISSION), "react_left_small_intro_a")
|
|
//IF GET_ENTITY_ANIM_CURRENT_TIME(driverPed[YV_CAR_CARPARK_PULL_OUT_FOR_JUMP_OVER], GET_HOOD_ANIM_DICT_AS_STRING(H_ANIM_DICT_MISSION), "react_left_small_intro_a") >= 0.98
|
|
TASK_PLAY_ANIM(driverPed[YV_CAR_CARPARK_PULL_OUT_FOR_JUMP_OVER], GET_HOOD_ANIM_DICT_AS_STRING(H_ANIM_DICT_FOOT_CHASE), "REACT_SMALL_VARIATIONS_H", NORMAL_BLEND_IN, NORMAL_BLEND_OUT, -1, AF_LOOPING)
|
|
iDriverOutTime = GET_GAME_TIMER()
|
|
driverOutState = DRIVER_OUT_PLAY_ANIM
|
|
//ENDIF
|
|
//ENDIF
|
|
BREAK
|
|
|
|
CASE DRIVER_OUT_PLAY_ANIM
|
|
//IF GET_GAME_TIMER() >= iDriverOutTime + 30000
|
|
// TASK_PLAY_ANIM(driverPed[YV_CAR_CARPARK_PULL_OUT_FOR_JUMP_OVER], GET_HOOD_ANIM_DICT_AS_STRING(H_ANIM_DICT_GESTURE_EXT), "exit", NORMAL_BLEND_IN, NORMAL_BLEND_OUT, -1)
|
|
// driverOutState = DRIVER_OUT_DONE
|
|
//ENDIF
|
|
BREAK
|
|
ENDSWITCH
|
|
|
|
IF NOT bDoneDriverLookAtChop
|
|
IF IS_ENTITY_AT_ENTITY(driverPed[YV_CAR_CARPARK_PULL_OUT_FOR_JUMP_OVER], chopPed, <<3,3,3>>, FALSE, FALSE)
|
|
TASK_LOOK_AT_ENTITY(driverPed[YV_CAR_CARPARK_PULL_OUT_FOR_JUMP_OVER], chopPed, -1, SLF_WHILE_NOT_IN_FOV)
|
|
bDoneDriverLookAtChop = TRUE
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF NOT bDoneDriverSwear
|
|
IF driverOutState >= DRIVER_OUT_LEAVE_VEHICLE
|
|
IF IS_ENTITY_AT_ENTITY(PLAYER_PED_ID(), driverPed[YV_CAR_CARPARK_PULL_OUT_FOR_JUMP_OVER], <<8, 8, LOCATE_SIZE_HEIGHT>>)
|
|
// bDoneDriverSwear = DO_MISSION_SPEECH("FC_DRIVER")
|
|
IF NOT IS_ANY_CONVERSATION_ONGOING_OR_QUEUED()
|
|
|
|
TASK_LOOK_AT_ENTITY(driverPed[YV_CAR_CARPARK_PULL_OUT_FOR_JUMP_OVER], PLAYER_PED_ID(), -1, SLF_WHILE_NOT_IN_FOV)
|
|
PLAY_PED_AMBIENT_SPEECH(driverPed[YV_CAR_CARPARK_PULL_OUT_FOR_JUMP_OVER], "GENERIC_INSULT_HIGH", SPEECH_PARAMS_FORCE_SHOUTED)
|
|
bDoneDriverSwear = TRUE
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF IS_SYNCHRONIZED_SCENE_RUNNING(chopChaseProperties.iSyncScene)
|
|
IF chopChaseProperties.chaseAnim = CHASE_ANIM_C_OVER_CAR
|
|
SWITCH iChopBounceOnCarStage
|
|
CASE 0
|
|
IF GET_SYNCHRONIZED_SCENE_PHASE(chopChaseProperties.iSyncScene) >= 0.45
|
|
APPLY_FORCE_TO_ENTITY(yardVehicle[YV_CAR_CARPARK_PULL_OUT_FOR_JUMP_OVER], APPLY_TYPE_IMPULSE, <<0,0,-0.1>>, <<0,3,0>>, 0, TRUE, TRUE, TRUE)
|
|
iChopBounceOnCarStage++
|
|
ENDIF
|
|
BREAK
|
|
CASE 1
|
|
IF GET_SYNCHRONIZED_SCENE_PHASE(chopChaseProperties.iSyncScene) >= 0.595
|
|
APPLY_FORCE_TO_ENTITY(yardVehicle[YV_CAR_CARPARK_PULL_OUT_FOR_JUMP_OVER], APPLY_TYPE_IMPULSE, <<0,0,-0.1>>, <<0,3,0>>, 0, TRUE, TRUE, TRUE)
|
|
iChopBounceOnCarStage++
|
|
ENDIF
|
|
BREAK
|
|
ENDSWITCH
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
|
|
// leave vehicle and flee on threaten
|
|
REPEAT COUNT_OF(driverPed) i
|
|
IF NOT IS_PED_INJURED(driverPed[i])
|
|
IF GET_SCRIPT_TASK_STATUS(driverPed[i], SCRIPT_TASK_SMART_FLEE_PED) = FINISHED_TASK
|
|
AND GET_SCRIPT_TASK_STATUS(driverPed[i], SCRIPT_TASK_LEAVE_ANY_VEHICLE) = FINISHED_TASK
|
|
AND GET_SCRIPT_TASK_STATUS(driverPed[i], SCRIPT_TASK_PERFORM_SEQUENCE) = FINISHED_TASK
|
|
IF IS_PLAYER_THREATENING_PED(driverPed[i])
|
|
VEHICLE_INDEX thisVehicle
|
|
IF IS_PED_IN_ANY_VEHICLE(driverPed[i])
|
|
thisVehicle = GET_VEHICLE_PED_IS_IN(driverPed[i])
|
|
IF NOT IS_ENTITY_DEAD(thisVehicle)
|
|
// NG
|
|
SET_AUDIO_VEHICLE_PRIORITY(thisVehicle, AUDIO_VEHICLE_PRIORITY_NORMAL)
|
|
printstring("bus audio off 3") printnl()
|
|
|
|
IF IS_PLAYBACK_GOING_ON_FOR_VEHICLE(thisVehicle)
|
|
STOP_PLAYBACK_RECORDED_VEHICLE(thisVehicle)
|
|
ENDIF
|
|
SET_VEHICLE_IS_CONSIDERED_BY_PLAYER(thisVehicle, FALSE)
|
|
ENDIF
|
|
ENDIF
|
|
|
|
BOOL bCanDoSequence = TRUE
|
|
IF DOES_ENTITY_EXIST(thisVehicle)
|
|
IF IS_THIS_MODEL_A_TRAIN(GET_ENTITY_MODEL(thisVehicle))
|
|
bCanDoSequence = FALSE
|
|
ENDIF
|
|
ENDIF
|
|
IF bCanDoSequence
|
|
CLEAR_SEQUENCE_TASK(sequence)
|
|
OPEN_SEQUENCE_TASK(sequence)
|
|
IF NOT IS_ENTITY_DEAD(thisVehicle)
|
|
TASK_LEAVE_ANY_VEHICLE(NULL, 0, ECF_DONT_CLOSE_DOOR)
|
|
ENDIF
|
|
TASK_SMART_FLEE_PED(NULL, PLAYER_PED_ID(), 1000, -1)
|
|
CLOSE_SEQUENCE_TASK(sequence)
|
|
TASK_PERFORM_SEQUENCE(driverPed[i], sequence)
|
|
|
|
IF i=ENUM_TO_INT(YV_CAR_CARPARK_PULL_OUT_FOR_JUMP_OVER)
|
|
bDoneDriverSwear = TRUE
|
|
driverOutState = DRIVER_OUT_FLEE
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDREPEAT
|
|
ENDPROC
|
|
|
|
|
|
FUNC STRING GET_WAYPOINT_RECORDING_FOR_RUNNER()
|
|
SWITCH runnerStage
|
|
CASE RUNNER_START_FLEE
|
|
RETURN "hood1"
|
|
BREAK
|
|
|
|
CASE RUNNER_TO_CONTAINER
|
|
CASE RUNNER_TO_CAR
|
|
CASE RUNNER_TO_FENCE
|
|
RETURN "hood2"
|
|
BREAK
|
|
|
|
CASE RUNNER_TO_FLATBEDS
|
|
CASE RUNNER_TO_BOXCAR
|
|
CASE RUNNER_TO_TRAIN
|
|
RETURN "hood3"
|
|
BREAK
|
|
ENDSWITCH
|
|
|
|
RETURN "invalid"
|
|
ENDFUNC
|
|
|
|
FUNC INT GET_START_WAYPOINT_FOR_RUNNER()
|
|
SWITCH runnerStage
|
|
CASE RUNNER_START_FLEE
|
|
RETURN 9
|
|
BREAK
|
|
CASE RUNNER_TO_CONTAINER
|
|
RETURN 6
|
|
BREAK
|
|
CASE RUNNER_TO_CAR
|
|
RETURN 15
|
|
BREAK
|
|
CASE RUNNER_TO_FENCE
|
|
RETURN 22
|
|
BREAK
|
|
CASE RUNNER_TO_FLATBEDS
|
|
RETURN 10
|
|
BREAK
|
|
CASE RUNNER_TO_BOXCAR
|
|
RETURN 35
|
|
BREAK
|
|
CASE RUNNER_TO_TRAIN
|
|
RETURN 44
|
|
BREAK
|
|
//CASE RUNNER_ESCAPE
|
|
// RETURN 0
|
|
//BREAK
|
|
ENDSWITCH
|
|
|
|
RETURN 0
|
|
ENDFUNC
|
|
|
|
FUNC VECTOR GET_TARGET_COORD_FOR_RUNNER()
|
|
SWITCH runnerStage
|
|
CASE RUNNER_TO_BOXCAR
|
|
RETURN <<567.55, -505.19, 23.79>>
|
|
BREAK
|
|
ENDSWITCH
|
|
|
|
RETURN <<0,0,0>>
|
|
ENDFUNC
|
|
|
|
|
|
PROC DO_CHASE_ANIM(CHASE_PROPERTIES &chaseProperties, CHASE_ANIM_ENUM doChaseAnim)
|
|
IF NOT IS_PED_INJURED(chaseProperties.ped)
|
|
chaseProperties.vAnimPos = GET_ENTITY_COORDS(chaseProperties.ped)
|
|
chaseProperties.vAnimRot = GET_ENTITY_ROTATION(chaseProperties.ped)
|
|
SET_VECTOR_CLOSEST_TO_IDEAL(chaseProperties.vAnimRot, <<0,0,GET_CHASE_IDEAL_ANIM_HEADING(doChaseAnim)>>)
|
|
|
|
chaseProperties.iSyncscene = CREATE_SYNCHRONIZED_SCENE(chaseProperties.vAnimPos, chaseProperties.vAnimRot)
|
|
|
|
//BOOL bHoldLastFrame
|
|
BOOL bLooping
|
|
/*
|
|
IF doChaseAnim = CHASE_ANIM_G_BOXCAR
|
|
bHoldLastFrame = TRUE
|
|
ELSE
|
|
bHoldLastFrame = FALSE
|
|
ENDIF
|
|
*/
|
|
IF doChaseAnim = CHASE_ANIM_G_WAITING_ON_GROUND
|
|
bLooping = TRUE
|
|
ELSE
|
|
bLooping = FALSE
|
|
ENDIF
|
|
|
|
//SET_SYNCHRONIZED_SCENE_HOLD_LAST_FRAME(chaseProperties.iSyncscene, bHoldLastFrame)
|
|
SET_SYNCHRONIZED_SCENE_LOOPED(chaseProperties.iSyncscene, bLooping)
|
|
SET_SYNCHRONIZED_SCENE_PHASE(chaseProperties.iSyncscene, 0.0)
|
|
|
|
SYNCED_SCENE_PLAYBACK_FLAGS playbackFlags
|
|
IF chaseProperties.ped = chopPed
|
|
playbackFlags = SYNCED_SCENE_TAG_SYNC_OUT | SYNCED_SCENE_DONT_INTERRUPT | SYNCED_SCENE_USE_PHYSICS
|
|
ELSE
|
|
IF doChaseAnim = CHASE_ANIM_G_BOXCAR
|
|
OR doChaseAnim = CHASE_ANIM_G_WAITING_ON_GROUND
|
|
OR doChaseAnim = CHASE_ANIM_G_GET_UP_FROM_GROUND
|
|
playbackFlags = SYNCED_SCENE_TAG_SYNC_OUT | SYNCED_SCENE_DONT_INTERRUPT | SYNCED_SCENE_USE_PHYSICS
|
|
ELSE
|
|
playbackFlags = SYNCED_SCENE_TAG_SYNC_OUT | SYNCED_SCENE_DONT_INTERRUPT
|
|
ENDIF
|
|
ENDIF
|
|
|
|
TASK_SYNCHRONIZED_SCENE(chaseProperties.ped, chaseProperties.iSyncscene, GET_HOOD_ANIM_DICT_AS_STRING(H_ANIM_DICT_FOOT_CHASE), GET_CHASE_ANIM_NAME(doChaseAnim), NORMAL_BLEND_IN, NORMAL_BLEND_OUT, playbackFlags)
|
|
|
|
IF doChaseAnim = CHASE_ANIM_G_ONTO_TRAIN
|
|
OR doChaseAnim = CHASE_ANIM_C_TOP_FENCE
|
|
OR doChaseAnim = CHASE_ANIM_G_FLATBEDS
|
|
REPLAY_RECORD_BACK_FOR_TIME(3.0, 5.0)
|
|
ENDIF
|
|
|
|
// debug for horrible once every blue moon bug
|
|
#IF IS_DEBUG_BUILD
|
|
PRINTSTRING("creating synced scene ")
|
|
IF chaseProperties.ped = chopPed
|
|
PRINTSTRING("for CHOP") PRINTNL()
|
|
PRINTSTRING("chop stage = ") PRINTINT(ENUM_TO_INT(chopStage)) PRINTNL()
|
|
ELIF chaseProperties.ped = runnerChaseProperties.ped
|
|
PRINTSTRING("for BALLA") PRINTNL()
|
|
PRINTSTRING("balla stage = ") PRINTINT(ENUM_TO_INT(runnerStage)) PRINTNL()
|
|
ELSE
|
|
PRINTSTRING("for UNKNOWN") PRINTNL()
|
|
ENDIF
|
|
PRINTSTRING("synced scene id = ") PRINTINT(chaseProperties.iSyncscene) PRINTNL()
|
|
PRINTSTRING("playing anim ") PRINTSTRING(GET_CHASE_ANIM_NAME(doChaseAnim)) PRINTNL()
|
|
|
|
PRINTNL()
|
|
#ENDIF
|
|
ENDIF
|
|
|
|
chaseProperties.chaseAnim = doChaseAnim
|
|
chaseProperties.chaseState = CHASE_STATE_PERFORMING_ANIM
|
|
ENDPROC
|
|
|
|
FUNC INT GET_START_WAYPOINT_FOR_CHOP()
|
|
SWITCH chopStage
|
|
CASE CHOP_TO_ROOF_EDGE
|
|
RETURN 64
|
|
BREAK
|
|
CASE CHOP_TO_CAR
|
|
RETURN 89
|
|
BREAK
|
|
CASE CHOP_TO_FENCE
|
|
RETURN 106
|
|
BREAK
|
|
CASE CHOP_TO_FLATBEDS
|
|
RETURN 109
|
|
BREAK
|
|
CASE CHOP_TO_BOXCAR
|
|
RETURN 158
|
|
BREAK
|
|
CASE CHOP_TO_TRAIN
|
|
RETURN 185
|
|
BREAK
|
|
ENDSWITCH
|
|
|
|
RETURN 0
|
|
ENDFUNC
|
|
|
|
PROC HANDLE_TRANSITION_BACK_TO_CHASE_MOVING(CHASE_PROPERTIES &chaseProperties, BOOL bIsChop = FALSE, BOOL bForceSprint = TRUE, INT iForceWaypoint = -1, BOOL bIncrement = TRUE, BOOL bUseNavmesh = TRUE)
|
|
IF NOT IS_PED_INJURED(chaseProperties.ped)
|
|
IF NOT chaseProperties.bWaiting
|
|
IF NOT IS_SYNCHRONIZED_SCENE_RUNNING(chaseProperties.iSyncScene)
|
|
EWAYPOINT_FOLLOW_FLAGS followFlags
|
|
IF bUseNavmesh
|
|
followFlags = EWAYPOINT_DO_NOT_RESPOND_TO_COLLISION_EVENTS | EWAYPOINT_NAVMESH_TO_INITIAL_WAYPOINT
|
|
ELSE
|
|
followFlags = EWAYPOINT_DO_NOT_RESPOND_TO_COLLISION_EVENTS
|
|
ENDIF
|
|
|
|
TASK_CLEAR_LOOK_AT(chaseProperties.ped)
|
|
|
|
IF NOT bIsChop
|
|
IF bIncrement
|
|
runnerStage = INT_TO_ENUM(RUNNER_STAGE_ENUM, ENUM_TO_INT(runnerStage) + 1)
|
|
ENDIF
|
|
TASK_FOLLOW_WAYPOINT_RECORDING(chaseProperties.ped, GET_WAYPOINT_RECORDING_FOR_RUNNER(), GET_START_WAYPOINT_FOR_RUNNER(), EWAYPOINT_DO_NOT_RESPOND_TO_COLLISION_EVENTS)
|
|
iRunnerStageStartTime = GET_GAME_TIMER()
|
|
ELSE
|
|
IF bIncrement
|
|
chopStage = INT_TO_ENUM(CHOP_STAGE_ENUM, ENUM_TO_INT(chopStage) + 1)
|
|
chopWaitState = CHOP_WAIT_STATE_NOT_STARTED
|
|
ENDIF
|
|
INT iWaypoint
|
|
IF iForceWaypoint < 0
|
|
iWaypoint = GET_START_WAYPOINT_FOR_CHOP()
|
|
ELSE
|
|
iWaypoint = iForceWaypoint
|
|
ENDIF
|
|
|
|
TASK_FOLLOW_WAYPOINT_RECORDING(chaseProperties.ped, "hood7", iWaypoint, followFlags | EWAYPOINT_USE_TIGHTER_TURN_SETTINGS)
|
|
ENDIF
|
|
IF bForceSprint
|
|
SET_PED_MIN_MOVE_BLEND_RATIO(chaseProperties.ped, PEDMOVE_SPRINT)
|
|
ENDIF
|
|
chaseProperties.iSyncScene = -1
|
|
chaseProperties.iMovingTime = GET_GAME_TIMER()
|
|
chaseProperties.chaseAnim = CHASE_ANIM_NONE
|
|
chaseProperties.chaseState = CHASE_STATE_MOVING
|
|
ELSE
|
|
BOOL bMinBlend = TRUE
|
|
IF chaseProperties.chaseAnim <> CHASE_ANIM_G_GET_UP_FROM_GROUND
|
|
// reposition
|
|
SHIFT_VECTOR_TO_IDEAL_VECTOR(chaseProperties.vAnimPos, GET_CHASE_IDEAL_ANIM_COORDS(chaseProperties.chaseAnim), SHIFT_POS_SPEED)
|
|
//PRINTVECTOR(chaseProperties.vAnimPos) PRINTNL()
|
|
|
|
// rotate
|
|
SHIFT_VECTOR_TO_IDEAL_VECTOR(chaseProperties.vAnimRot, <<0,0,GET_CHASE_IDEAL_ANIM_HEADING(chaseProperties.chaseAnim)>>, SHIFT_ROT_SPEED)
|
|
SET_SYNCHRONIZED_SCENE_ORIGIN(chaseProperties.iSyncScene, chaseProperties.vAnimPos, chaseProperties.vAnimRot)
|
|
ELSE
|
|
IF NOT bResetBallaGetUp
|
|
IF NOT IS_ENTITY_ON_SCREEN(chaseProperties.ped)
|
|
SET_SYNCHRONIZED_SCENE_PHASE(chaseProperties.iSyncScene, 0.98)
|
|
bResetBallaGetUp = TRUE
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
|
|
// convert into looped wait
|
|
FLOAT fPhase = GET_SYNCHRONIZED_SCENE_PHASE(chaseProperties.iSyncScene)
|
|
IF fPhase >= 0.98
|
|
IF chaseProperties.chaseAnim = CHASE_ANIM_G_BOXCAR
|
|
DO_CHASE_ANIM(chaseProperties, CHASE_ANIM_G_WAITING_ON_GROUND)
|
|
CLEAR_ENTITY_LAST_DAMAGE_ENTITY(chaseProperties.ped)
|
|
iRunnerWaitTime = GET_GAME_TIMER()
|
|
chaseProperties.bWaiting = TRUE
|
|
ELIF chaseProperties.chaseAnim = CHASE_ANIM_G_DOWN_CONTAINER
|
|
IF NOT bCheckedContainerWait
|
|
//IF NOT IS_ENTITY_AT_ENTITY(PLAYER_PED_ID(), chaseProperties.ped, <<12,12,12>>, FALSE, FALSE)
|
|
IF NOT IS_ENTITY_AT_ENTITY(PLAYER_PED_ID(), chaseProperties.ped, <<20,20,20>>, FALSE, FALSE)
|
|
iRunnerWaitTime = GET_GAME_TIMER()
|
|
chaseProperties.bWaiting = TRUE
|
|
ELSE
|
|
chaseProperties.bWaiting = FALSE
|
|
ENDIF
|
|
CLEAR_PED_TASKS(chaseProperties.ped)
|
|
CLEAR_ENTITY_LAST_DAMAGE_ENTITY(chaseProperties.ped)
|
|
bCheckedContainerWait = TRUE
|
|
ENDIF
|
|
ELSE
|
|
SET_SYNCHRONIZED_SCENE_HOLD_LAST_FRAME(chaseProperties.iSyncscene, FALSE)
|
|
ENDIF
|
|
ELIF fPhase >= 0.50
|
|
IF chaseProperties.chaseAnim = CHASE_ANIM_G_DOWN_CONTAINER
|
|
OR chaseProperties.chaseAnim = CHASE_ANIM_C_TOP_FENCE
|
|
bMinBlend = FALSE
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF bMinBlend
|
|
SET_PED_MIN_MOVE_BLEND_RATIO(chaseProperties.ped, PEDMOVE_SPRINT)
|
|
ENDIF
|
|
ENDIF
|
|
ELSE
|
|
IF NOT IS_PED_INJURED(chopPed)
|
|
// special case to handle wait
|
|
IF chaseProperties.chaseAnim = CHASE_ANIM_G_WAITING_ON_GROUND
|
|
IF IS_ENTITY_AT_ENTITY(PLAYER_PED_ID(), chaseProperties.ped, <<16,16,16>>, FALSE, FALSE)
|
|
OR (IS_ENTITY_AT_ENTITY(PLAYER_PED_ID(), chaseProperties.ped, <<20,20,20>>, FALSE, FALSE) AND GET_FOLLOW_PED_CAM_VIEW_MODE() = CAM_VIEW_MODE_FIRST_PERSON)
|
|
OR IS_ENTITY_IN_ANGLED_AREA(PLAYER_PED_ID(), <<537.228, -540.125, 23.679>>, <<557.910, -542.702, 29.000>>, 63)
|
|
OR IS_ENTITY_AT_ENTITY(chopPed, chaseProperties.ped, <<18,18,18>>, FALSE, FALSE)
|
|
OR HAS_ENTITY_BEEN_DAMAGED_BY_ENTITY(chaseProperties.ped, PLAYER_PED_ID())
|
|
OR IS_ENTITY_ON_FIRE(chaseProperties.ped)
|
|
OR GET_GAME_TIMER() >= iRunnerWaitTime + 12000
|
|
OR chopStage >= CHOP_TO_TRAIN
|
|
DO_CHASE_ANIM(chaseProperties, CHASE_ANIM_G_GET_UP_FROM_GROUND)
|
|
chaseProperties.bWaiting = FALSE
|
|
ENDIF
|
|
ELIF chaseProperties.chaseAnim = CHASE_ANIM_G_DOWN_CONTAINER
|
|
IF IS_ENTITY_AT_ENTITY(PLAYER_PED_ID(), chaseProperties.ped, <<25,25,25>>, FALSE, FALSE)
|
|
OR IS_ENTITY_AT_ENTITY(chopPed, chaseProperties.ped, <<11,11,11>>, FALSE, FALSE)
|
|
OR IS_TRACKED_PED_VISIBLE(runnerChaseProperties.ped)
|
|
OR HAS_ENTITY_BEEN_DAMAGED_BY_ENTITY(chaseProperties.ped, PLAYER_PED_ID())
|
|
OR IS_ENTITY_ON_FIRE(chaseProperties.ped)
|
|
OR GET_GAME_TIMER() >= iRunnerWaitTime + 11000
|
|
chaseProperties.bWaiting = FALSE
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDPROC
|
|
|
|
FUNC BOOL SHOULD_INCREMENT_SETPIECE_STAGE()
|
|
VECTOR vPedPos = GET_ENTITY_COORDS(runnerChaseProperties.ped)
|
|
SWITCH setpieceStage
|
|
CASE SETPIECE_FREE_INTO_STATION
|
|
IF vPedPos.y >= -641.49
|
|
RETURN TRUE
|
|
ENDIF
|
|
BREAK
|
|
CASE SETPIECE_LOCK_BUS_REVERSING
|
|
IF vPedPos.y >= -635.98//-616.98
|
|
RETURN TRUE
|
|
ENDIF
|
|
BREAK
|
|
CASE SETPIECE_FREE_TO_ROOF
|
|
IF vPedPos.y >= -552.7//-574.02
|
|
IF NOT runnerChaseProperties.bWaiting
|
|
RETURN TRUE
|
|
ENDIF
|
|
ENDIF
|
|
BREAK
|
|
CASE SETPIECE_LOCK_CAR_SLIDE
|
|
IF vPedPos.y >= -532.48
|
|
RETURN TRUE
|
|
ENDIF
|
|
BREAK
|
|
CASE SETPIECE_FREE_ACROSS_CONSTRUCTION
|
|
IF vPedPos.x >= 512.69
|
|
RETURN TRUE
|
|
ENDIF
|
|
BREAK
|
|
CASE SETPIECE_LOCK_TRAIN_CUT_ACROSS
|
|
IF vPedPos.x >= 535.19
|
|
RETURN TRUE
|
|
ENDIF
|
|
BREAK
|
|
CASE SETPIECE_FREE_THROUGH_CARRIAGES
|
|
IF vPedPos.y <= -509.27
|
|
RETURN TRUE
|
|
ENDIF
|
|
BREAK
|
|
CASE SETPIECE_FREE_BACK_OF_CARRIAGES
|
|
IF vPedPos.y <= -547.42
|
|
RETURN TRUE
|
|
ENDIF
|
|
BREAK
|
|
CASE SETPIECE_LOCK_TRAIN_JUMP
|
|
RETURN FALSE
|
|
BREAK
|
|
ENDSWITCH
|
|
|
|
RETURN FALSE
|
|
ENDFUNC
|
|
|
|
FUNC FLOAT CALCULATE_RUNNER_SPEED_FROM_DISTANCE(FLOAT fCatchupDistance, FLOAT fMinSpeed, FLOAT fMaxSpeed)
|
|
FLOAT fDist = GET_DISTANCE_BETWEEN_ENTITIES(PLAYER_PED_ID(), runnerChaseProperties.ped)
|
|
IF fDist < fCatchupDistance
|
|
RETURN fMaxSpeed
|
|
ELSE
|
|
RETURN fMinSpeed
|
|
ENDIF
|
|
|
|
RETURN 3.0
|
|
ENDFUNC
|
|
|
|
PROC HANDLE_RUNNER_SPEED()
|
|
//PRINTSTRING("stage = ") PRINTINT(ENUM_TO_INT(setpieceStage)) PRINTNL()
|
|
|
|
IF SHOULD_INCREMENT_SETPIECE_STAGE()
|
|
setpieceStage = INT_TO_ENUM(SETPIECE_STAGE_ENUM, (ENUM_TO_INT(setpieceStage)+1))
|
|
iSetpieceStageStartTime = GET_GAME_TIMER()
|
|
ENDIF
|
|
|
|
taskStatus = GET_SCRIPT_TASK_STATUS(runnerChaseProperties.ped, SCRIPT_TASK_FOLLOW_WAYPOINT_ROUTE)
|
|
IF taskStatus = PERFORMING_TASK
|
|
// calculate the speed
|
|
FLOAT fSpeed
|
|
SWITCH setpieceStage
|
|
// lock at max for setpieces
|
|
CASE SETPIECE_LOCK_BUS_REVERSING
|
|
CASE SETPIECE_LOCK_CAR_SLIDE
|
|
CASE SETPIECE_LOCK_TRAIN_CUT_ACROSS
|
|
CASE SETPIECE_LOCK_TRAIN_JUMP
|
|
fSpeed = 3.0
|
|
BREAK
|
|
|
|
CASE SETPIECE_FREE_INTO_STATION
|
|
CASE SETPIECE_FREE_TO_ROOF
|
|
CASE SETPIECE_FREE_ACROSS_CONSTRUCTION
|
|
CASE SETPIECE_FREE_THROUGH_CARRIAGES
|
|
fSpeed = CALCULATE_RUNNER_SPEED_FROM_DISTANCE(40.0, 2.0, 3.0) // 28
|
|
BREAK
|
|
CASE SETPIECE_FREE_BACK_OF_CARRIAGES
|
|
//
|
|
VECTOR vOffset
|
|
vOffset = GET_OFFSET_FROM_ENTITY_GIVEN_WORLD_COORDS(runnerChaseProperties.ped, GET_ENTITY_COORDS(PLAYER_PED_ID()))
|
|
IF vOffset.y < -4
|
|
fSpeed = CALCULATE_RUNNER_SPEED_FROM_DISTANCE(35.0, 2.0, 3.0) // 35
|
|
ELSE
|
|
fSpeed = 3
|
|
ENDIF
|
|
BREAK
|
|
ENDSWITCH
|
|
|
|
IF currentMissionStage = STAGE_VAN_CHASE
|
|
fSpeed = 2.0
|
|
ENDIF
|
|
|
|
//PRINTSTRING("runner speed = ") PRINTFLOAT(fspeed) PRINTNL()
|
|
IF currentMissionStage <> STAGE_VAN_CHASE
|
|
IF IS_WAYPOINT_PLAYBACK_GOING_ON_FOR_PED(runnerChaseProperties.ped)
|
|
IF fSpeed >= 2.5
|
|
SET_PED_MOVE_RATE_OVERRIDE(runnerChaseProperties.ped, 1.15)
|
|
//SET_PED_MIN_MOVE_BLEND_RATIO(runnerChaseProperties.ped, 3.0)
|
|
ELSE
|
|
//SET_PED_MIN_MOVE_BLEND_RATIO(runnerChaseProperties.ped, 2.0)
|
|
ENDIF
|
|
WAYPOINT_PLAYBACK_OVERRIDE_SPEED(runnerChaseProperties.ped, fSpeed)
|
|
ENDIF
|
|
ELSE
|
|
//printstring("here1") printnl()
|
|
SET_PED_MAX_MOVE_BLEND_RATIO(runnerChaseProperties.ped, 2.0)
|
|
WAYPOINT_PLAYBACK_OVERRIDE_SPEED(runnerChaseProperties.ped, 2.0)
|
|
SET_PED_MOVE_RATE_OVERRIDE(runnerChaseProperties.ped, 0.98)
|
|
ENDIF
|
|
ENDIF
|
|
ENDPROC
|
|
|
|
// can car be jumped?
|
|
FUNC BOOL CAN_CAR_BE_JUMPED_OVER()
|
|
IF NOT IS_ENTITY_DEAD(yardVehicle[YV_CAR_CARPARK_PULL_OUT_FOR_JUMP_OVER])
|
|
IF IS_VEHICLE_DRIVEABLE(yardVehicle[YV_CAR_CARPARK_PULL_OUT_FOR_JUMP_OVER])
|
|
IF IS_ENTITY_IN_ANGLED_AREA(yardVehicle[YV_CAR_CARPARK_PULL_OUT_FOR_JUMP_OVER], <<495.362, -537.695, 20.751>>, <<485.086, -537.464, 26.751>>, 3)
|
|
RETURN TRUE
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
|
|
RETURN FALSE
|
|
ENDFUNC
|
|
|
|
// should chop wait at roof?
|
|
FUNC BOOL SHOULD_CHOP_WAIT_AT_ROOF(BOOL bCheckStart = FALSE)
|
|
IF runnerStage >= RUNNER_TO_CAR
|
|
OR IS_ENTITY_IN_ANGLED_AREA(PLAYER_PED_ID(), <<482.130, -575.220, 26.460>>, <<494.610, -576.590, 31.460>>, 24, FALSE, FALSE)
|
|
OR (IS_ENTITY_AT_COORD(PLAYER_PED_ID(), <<488.47430, -576.73560, 28.29393>>, <<18.5, 18.5, 18.5>>, FALSE, FALSE) AND bCheckStart)
|
|
OR chopViewCamData.state = CHOP_VIEW_CAM_ON_CHOP
|
|
RETURN FALSE
|
|
ENDIF
|
|
|
|
RETURN TRUE
|
|
ENDFUNC
|
|
|
|
// should chop wait at flatbeds
|
|
FUNC BOOL SHOULD_CHOP_WAIT_AT_FLATBEDS(BOOL bCheckStart = FALSE)
|
|
VECTOR vPlayerPos
|
|
vPlayerPos = GET_ENTITY_COORDS(PLAYER_PED_ID())
|
|
VECTOR vRunnerPos
|
|
IF NOT IS_PED_INJURED(runnerChaseProperties.ped)
|
|
vRunnerPos = GET_ENTITY_COORDS(runnerChaseProperties.ped)
|
|
ENDIF
|
|
IF (vPlayerPos.x >= 525
|
|
AND vRunnerPos.x >= 552)
|
|
OR chopViewCamData.state = CHOP_VIEW_CAM_ON_CHOP
|
|
OR (vPlayerPos.x >= -517 AND bCheckStart)
|
|
RETURN FALSE
|
|
ENDIF
|
|
|
|
RETURN TRUE
|
|
ENDFUNC
|
|
|
|
// handle runner on chase
|
|
PROC HANDLE_RUNNER_CHASE()
|
|
IF NOT IS_PED_INJURED(runnerChaseProperties.ped)
|
|
IF bStartedRunnerMovement
|
|
SWITCH runnerChaseProperties.chaseState
|
|
CASE CHASE_STATE_MOVING
|
|
HANDLE_RUNNER_SPEED()
|
|
//IF GET_GAME_TIMER() <= runnerChaseProperties.iMovingTime + 2000
|
|
//SET_PED_MIN_MOVE_BLEND_RATIO(runnerChaseProperties.ped, PEDMOVE_SPRINT)
|
|
//ENDIF
|
|
CHASE_ANIM_ENUM nextChaseAnim
|
|
nextChaseAnim = GET_NEXT_CHASE_ANIM_FOR_RUNNER()
|
|
IF IS_ENTITY_AT_COORD(runnerChaseProperties.ped, GET_CHASE_ANIM_COORDS(nextChaseAnim), GET_CHASE_ANIM_DIMENSIONS(nextChaseAnim), FALSE, TRUE, TM_ON_FOOT)
|
|
OR (IS_PED_AT_EMERGENCY_CHASE_ANIM_TRIGGER(runnerChaseProperties.ped, nextChaseAnim) AND nextChaseAnim < CHASE_ANIM_BAD AND IS_ENTITY_AT_COORD(runnerChaseProperties.ped, GET_CHASE_ANIM_COORDS(nextChaseAnim), <<10,10,10>>, FALSE, FALSE, TM_ON_FOOT))
|
|
BOOL bCanDoRunnerAnim
|
|
bCanDoRunnerAnim = TRUE
|
|
|
|
IF nextChaseAnim = CHASE_ANIM_G_OVER_CAR
|
|
IF NOT CAN_CAR_BE_JUMPED_OVER()
|
|
bCanDoRunnerAnim = FALSE
|
|
ELSE
|
|
SET_ENTITY_NO_COLLISION_ENTITY(runnerChaseProperties.ped, yardVehicle[YV_CAR_CARPARK_PULL_OUT_FOR_JUMP_OVER], FALSE)
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF bCanDoRunnerAnim
|
|
DO_CHASE_ANIM(runnerChaseProperties, nextChaseAnim)
|
|
ELSE
|
|
runnerStage = INT_TO_ENUM(RUNNER_STAGE_ENUM, ENUM_TO_INT(runnerStage) + 1)
|
|
ENDIF
|
|
ENDIF
|
|
BREAK
|
|
|
|
CASE CHASE_STATE_PERFORMING_ANIM
|
|
IF IS_SYNCHRONIZED_SCENE_RUNNING(runnerChaseProperties.iSyncScene)
|
|
FLOAT fAnimSpeed
|
|
fAnimSpeed = 1.04
|
|
IF NOT IS_TRACKED_PED_VISIBLE(runnerChaseProperties.ped)
|
|
IF runnerChaseProperties.chaseAnim = CHASE_ANIM_G_DOWN_CONTAINER
|
|
IF GET_SYNCHRONIZED_SCENE_PHASE(runnerChaseProperties.iSyncScene) >= 0.392
|
|
fAnimSpeed = 3.3
|
|
ENDIF
|
|
ELSE
|
|
IF runnerChaseProperties.chaseAnim < CHASE_ANIM_G_BOXCAR
|
|
fAnimSpeed = 1.21
|
|
ENDIF
|
|
ENDIF
|
|
ELSE
|
|
IF NOT IS_ENTITY_AT_ENTITY(PLAYER_PED_ID(), runnerChaseProperties.ped, <<50,50,50>>, FALSE, FALSE)
|
|
fAnimSpeed = 1.0
|
|
ELIF IS_ENTITY_AT_ENTITY(PLAYER_PED_ID(), runnerChaseProperties.ped, <<7,7,7>>, FALSE, FALSE)
|
|
fAnimSpeed = 1.12
|
|
ENDIF
|
|
ENDIF
|
|
|
|
SET_SYNCHRONIZED_SCENE_RATE(runnerChaseProperties.iSyncScene, fAnimSpeed)
|
|
ENDIF
|
|
|
|
HANDLE_TRANSITION_BACK_TO_CHASE_MOVING(runnerChaseProperties)
|
|
BREAK
|
|
ENDSWITCH
|
|
ELSE
|
|
TASK_FOLLOW_WAYPOINT_RECORDING(runnerChaseProperties.ped, "hood1", GET_START_WAYPOINT_FOR_RUNNER(), EWAYPOINT_DO_NOT_RESPOND_TO_COLLISION_EVENTS | EWAYPOINT_NAVMESH_BACK_TO_WAYPOINT_IF_LEFT_ROUTE)
|
|
iRunnerStageStartTime = GET_GAME_TIMER()
|
|
iSetpieceStageStartTime = GET_GAME_TIMER()
|
|
bStartedRunnerMovement = TRUE
|
|
ENDIF
|
|
ENDIF
|
|
ENDPROC
|
|
|
|
// handle chop during chase
|
|
PROC HANDLE_CHOP_CHASE()
|
|
IF NOT IS_PED_INJURED(chopChaseProperties.ped)
|
|
IF bStartedChopMovement
|
|
SWITCH chopChaseProperties.chaseState
|
|
CASE CHASE_STATE_MOVING
|
|
IF chopWaitState = CHOP_WAIT_STATE_NOT_STARTED
|
|
OR chopWaitState = CHOP_WAIT_STATE_DONE
|
|
// temp?
|
|
IF IS_WAYPOINT_PLAYBACK_GOING_ON_FOR_PED(chopChaseProperties.ped)
|
|
AND NOT IS_PED_INJURED(runnerChaseProperties.ped)
|
|
FLOAT fOverrideSpeed
|
|
FLOAT fMoveRateOverride
|
|
FLOAT fVeryCloseDistance
|
|
fVeryCloseDistance = 6
|
|
FLOAT fQuiteCloseDistance
|
|
fQuiteCloseDistance = 14
|
|
BOOL bAllowOverride
|
|
bAllowOverride = TRUE
|
|
//FLOAT fMinMoveBlend
|
|
|
|
IF chopStage = CHOP_TO_FLATBEDS
|
|
fVeryCloseDistance = 20
|
|
fQuiteCloseDistance = 50
|
|
ENDIF
|
|
|
|
VECTOR vOffset
|
|
vOffset = GET_OFFSET_FROM_ENTITY_GIVEN_WORLD_COORDS(chopPed, GET_ENTITY_COORDS(runnerChaseProperties.ped))
|
|
|
|
// slow down if too close to runner
|
|
IF IS_ENTITY_AT_ENTITY(chopChaseProperties.ped, runnerChaseProperties.ped, <<fVeryCloseDistance, fVeryCloseDistance, 10>>, FALSE, FALSE)
|
|
OR vOffset.y < 0
|
|
fOverrideSpeed = 2.4//2.2
|
|
fMoveRateOverride = 1.0//0.5
|
|
bAllowOverride = FALSE
|
|
//fMinMoveBlend = 2.1//2.1
|
|
ELIF IS_ENTITY_AT_ENTITY(chopChaseProperties.ped, runnerChaseProperties.ped, <<fQuiteCloseDistance, fQuiteCloseDistance, 10>>, FALSE, FALSE)
|
|
fOverrideSpeed = 2.8//2.5
|
|
fMoveRateOverride = 1.02//0.8
|
|
//bAllowOverride = FALSE
|
|
//fMinMoveBlend = 2.3//2.4
|
|
// speed up if too close to player
|
|
ELIF IS_ENTITY_AT_ENTITY(chopChaseProperties.ped, PLAYER_PED_ID(), <<10, 10, 20>>, FALSE, FALSE)
|
|
fOverrideSpeed = 3.0 // 3.0
|
|
fMoveRateOverride = 1.15//1.15
|
|
//fMinMoveBlend = 3.0//3.0
|
|
ELSE
|
|
fOverrideSpeed = 3.0//2.6
|
|
fMoveRateOverride = 1.15
|
|
//fMinMoveBlend = 2.7//2.3
|
|
ENDIF
|
|
|
|
// override
|
|
IF bAllowOverride
|
|
IF chopStage = CHOP_TO_ROOF_EDGE
|
|
fOverrideSpeed = 2.8
|
|
fMoveRateOverride = 1.0//1.15
|
|
//fMinMoveBlend = 2.8
|
|
ENDIF
|
|
IF chopStage = CHOP_TO_FLATBEDS
|
|
fOverrideSpeed = 3.0//2.7
|
|
fMoveRateOverride = 1.15
|
|
//fMinMoveBlend = 2.8//2.6
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF chopBypassFenceState = CHOP_BYPASS_FENCE_PERFORMING_BYPASS
|
|
VECTOR vPlayerPos
|
|
vPlayerPos = GET_ENTITY_COORDS(PLAYER_PED_ID())
|
|
IF vPlayerPos.y >= -516.9
|
|
fOverrideSpeed = 3.0//2.6
|
|
fMoveRateOverride = 1.15
|
|
ENDIF
|
|
ENDIF
|
|
//IF chopStage = CHOP_TO_FENCE
|
|
// fOverrideSpeed = 3.0//2.7
|
|
// fMoveRateOverride = 1.0
|
|
//ENDIF
|
|
WAYPOINT_PLAYBACK_OVERRIDE_SPEED(chopChaseProperties.ped, fOverrideSpeed)
|
|
SET_PED_MOVE_RATE_OVERRIDE(chopChaseProperties.ped, fMoveRateOverride)
|
|
|
|
IF chopStage = CHOP_TO_FENCE
|
|
VECTOR vPosToFence
|
|
vPosToFence = GET_ENTITY_COORDS(chopPed)
|
|
IF vPosToFence.y >= -524.0
|
|
SET_PED_MIN_MOVE_BLEND_RATIO(chopChaseProperties.ped, 2.0)
|
|
ELSE
|
|
SET_PED_MIN_MOVE_BLEND_RATIO(chopChaseProperties.ped, 3.0)
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF bApplyStartBoost
|
|
IF GET_GAME_TIMER() <= iStageStartTime + 2000
|
|
SET_PED_MIN_MOVE_BLEND_RATIO(chopChaseProperties.ped, 3.0)
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
|
|
CHASE_ANIM_ENUM nextChaseAnim
|
|
nextChaseAnim = GET_NEXT_CHASE_ANIM_FOR_CHOP()
|
|
IF IS_ENTITY_AT_COORD(chopChaseProperties.ped, GET_CHASE_ANIM_COORDS(nextChaseAnim), GET_CHASE_ANIM_DIMENSIONS(nextChaseAnim), FALSE, TRUE, TM_ON_FOOT)
|
|
OR (IS_PED_AT_EMERGENCY_CHASE_ANIM_TRIGGER(chopChaseProperties.ped, nextChaseAnim) AND nextChaseAnim <= CHASE_ANIM_BAD)
|
|
BOOL bCanDoChopAnim
|
|
bCanDoChopAnim = TRUE
|
|
|
|
IF nextChaseAnim = CHASE_ANIM_C_OVER_CAR
|
|
IF NOT CAN_CAR_BE_JUMPED_OVER()
|
|
bCanDoChopAnim = FALSE
|
|
ELSE
|
|
SET_ENTITY_NO_COLLISION_ENTITY(chopPed, yardVehicle[YV_CAR_CARPARK_PULL_OUT_FOR_JUMP_OVER], FALSE)
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF bCanDoChopAnim
|
|
DO_CHASE_ANIM(chopChaseProperties, nextChaseAnim)
|
|
ELSE
|
|
chopStage = INT_TO_ENUM(CHOP_STAGE_ENUM, ENUM_TO_INT(chopStage) + 1)
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
BREAK
|
|
|
|
CASE CHASE_STATE_PERFORMING_ANIM
|
|
IF IS_SYNCHRONIZED_SCENE_RUNNING(chopChaseProperties.iSyncScene)
|
|
IF chopChaseProperties.chaseAnim = CHASE_ANIM_C_TOP_FENCE
|
|
OR chopChaseProperties.chaseAnim = CHASE_ANIM_C_OFF_ROOF
|
|
IF IS_ENTITY_AT_ENTITY(PLAYER_PED_ID(), chopPed, <<25,25,25>>, FALSE, FALSE)
|
|
SET_SYNCHRONIZED_SCENE_RATE(chopChaseProperties.iSyncScene, 1.25)
|
|
ELSE
|
|
SET_SYNCHRONIZED_SCENE_RATE(chopChaseProperties.iSyncScene, 1.0)
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
|
|
BOOL bUseNavmesh
|
|
bUseNavmesh = TRUE
|
|
IF chopStage = CHOP_START_CHASE
|
|
OR chopStage = CHOP_TO_FLATBEDS
|
|
OR chopStage = CHOP_TO_BOXCAR
|
|
OR chopStage = CHOP_TO_fence
|
|
bUseNavmesh = FALSE
|
|
ENDIF
|
|
|
|
HANDLE_TRANSITION_BACK_TO_CHASE_MOVING(chopChaseProperties, TRUE, DEFAULT, DEFAULT, DEFAULT, bUseNavmesh)
|
|
BREAK
|
|
ENDSWITCH
|
|
|
|
// handle chop wait
|
|
SWITCH chopWaitState
|
|
CASE CHOP_WAIT_STATE_NOT_STARTED
|
|
IF chopChaseProperties.chaseState = CHASE_STATE_MOVING
|
|
BOOL bWait
|
|
bWait = FALSE
|
|
BOOL bFrantic
|
|
bFrantic = FALSE
|
|
BOOL bSlowToStop
|
|
SWITCH chopStage
|
|
CASE CHOP_TO_FLATBEDS
|
|
IF SHOULD_CHOP_WAIT_AT_FLATBEDS(TRUE)
|
|
IF IS_ENTITY_AT_COORD(chopChaseProperties.ped, <<539.66, -501.66, 25.13>>, <<13,13,13>>, FALSE, FALSE)
|
|
IF chopViewCamData.state = CHOP_VIEW_CAM_DISABLED
|
|
OR chopViewCamData.state = CHOP_VIEW_CAM_TO_PLAYER
|
|
bWait = TRUE
|
|
bSlowToStop = TRUE
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
BREAK
|
|
CASE CHOP_TO_FENCE
|
|
IF IS_ENTITY_AT_COORD(chopChaseProperties.ped, <<494.48, -516.88, 23.75>>, <<4,4,4>>)
|
|
bWait = TRUE
|
|
bSlowToStop = FALSE
|
|
bFrantic = TRUE
|
|
ENDIF
|
|
BREAK
|
|
CASE CHOP_TO_ROOF_EDGE
|
|
IF SHOULD_CHOP_WAIT_AT_ROOF(TRUE)
|
|
IF chopViewCamData.state = CHOP_VIEW_CAM_DISABLED
|
|
OR chopViewCamData.state = CHOP_VIEW_CAM_TO_PLAYER
|
|
bWait = TRUE
|
|
bSlowToStop = TRUE
|
|
ENDIF
|
|
ENDIF
|
|
BREAK
|
|
ENDSWITCH
|
|
|
|
IF bWait
|
|
IF bSlowToStop
|
|
TASK_PLAY_ANIM(chopChaseProperties.ped, GET_HOOD_ANIM_DICT_AS_STRING(H_ANIM_DICT_SHARED), "FRA0_IG_12_CHOP_FAST_TURN_A", NORMAL_BLEND_IN, NORMAL_BLEND_OUT, -1, AF_HOLD_LAST_FRAME) // "FRA0_IG_12_CHOP_RUN_STOP_TURN"
|
|
chopWaitState = CHOP_WAIT_STATE_SLOW_TO_STOP
|
|
ELSE
|
|
IF NOT bFrantic
|
|
TASK_PLAY_ANIM(chopChaseProperties.ped, GET_HOOD_ANIM_DICT_AS_STRING(H_ANIM_DICT_SHARED), "FRA0_IG_12_CHOP_WAITING_B", NORMAL_BLEND_IN, NORMAL_BLEND_OUT, -1, AF_LOOPING)
|
|
ELSE
|
|
TASK_PLAY_ANIM(chopChaseProperties.ped, GET_HOOD_ANIM_DICT_AS_STRING(H_ANIM_DICT_SHARED), "CHOP_BARK_AT_CARRIAGE", NORMAL_BLEND_IN, NORMAL_BLEND_OUT, -1, AF_LOOPING)
|
|
ENDIF
|
|
|
|
chopWaitState = CHOP_WAIT_STATE_WAITING
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
BREAK
|
|
|
|
CASE CHOP_WAIT_STATE_SLOW_TO_STOP
|
|
IF IS_ENTITY_PLAYING_ANIM(chopChaseProperties.ped, GET_HOOD_ANIM_DICT_AS_STRING(H_ANIM_DICT_SHARED), "FRA0_IG_12_CHOP_FAST_TURN_A")
|
|
IF GET_ENTITY_ANIM_CURRENT_TIME(chopChaseProperties.ped, GET_HOOD_ANIM_DICT_AS_STRING(H_ANIM_DICT_SHARED), "FRA0_IG_12_CHOP_FAST_TURN_A") >= 0.98
|
|
//TASK_LOOK_AT_ENTITY(chopChaseProperties.ped, PLAYER_PED_ID(), -1, SLF_WHILE_NOT_IN_FOV)
|
|
TASK_PLAY_ANIM(chopChaseProperties.ped, GET_HOOD_ANIM_DICT_AS_STRING(H_ANIM_DICT_SHARED), "FRA0_IG_12_CHOP_WAITING_A", NORMAL_BLEND_IN, NORMAL_BLEND_OUT, -1, AF_LOOPING)
|
|
chopWaitState = CHOP_WAIT_STATE_WAITING
|
|
ENDIF
|
|
ENDIF
|
|
BREAK
|
|
|
|
CASE CHOP_WAIT_STATE_WAITING
|
|
IF chopStage = CHOP_TO_FENCE
|
|
|
|
SET_PED_RESET_FLAG(chopPed, PRF_UseKinematicPhysics, TRUE)
|
|
|
|
IF bSmashedFence
|
|
HANDLE_TRANSITION_BACK_TO_CHASE_MOVING(chopChaseProperties, TRUE, FALSE, -1, TRUE, FALSE)
|
|
ELSE
|
|
/*
|
|
IF NOT bPlayingChopWaitTurnAnim
|
|
IF GET_GAME_TIMER() >= iChopWaitTime + 1000
|
|
TASK_PLAY_ANIM(chopChaseProperties.ped, GET_HOOD_ANIM_DICT_AS_STRING(H_ANIM_DICT_MISSION), "FRA0_IG_12_CHOP_WAITING_B", NORMAL_BLEND_IN, NORMAL_BLEND_OUT, -1, AF_HOLD_LAST_FRAME | AF_NOT_INTERRUPTABLE)
|
|
bPlayingChopWaitTurnAnim = TRUE
|
|
ENDIF
|
|
ELSE
|
|
IF IS_ENTITY_PLAYING_ANIM(chopChaseProperties.ped, GET_HOOD_ANIM_DICT_AS_STRING(H_ANIM_DICT_MISSION), "FRA0_IG_12_CHOP_WAITING_B")
|
|
IF GET_ENTITY_ANIM_CURRENT_TIME(chopChaseProperties.ped, GET_HOOD_ANIM_DICT_AS_STRING(H_ANIM_DICT_MISSION), "FRA0_IG_12_CHOP_WAITING_B") >= 0.98
|
|
TASK_PLAY_ANIM(chopChaseProperties.ped, GET_HOOD_ANIM_DICT_AS_STRING(H_ANIM_DICT_MISSION), "FRA0_IG_12_CHOP_WAITING_A", NORMAL_BLEND_IN, NORMAL_BLEND_OUT, -1, AF_LOOPING | AF_NOT_INTERRUPTABLE)
|
|
iChopWaitTime = GET_GAME_TIMER() + GET_RANDOM_INT_IN_RANGE(2000, 5000)
|
|
bPlayingChopWaitTurnAnim = FALSE
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
*/
|
|
ENDIF
|
|
ELIF chopStage = CHOP_TO_FLATBEDS
|
|
IF NOT SHOULD_CHOP_WAIT_AT_FLATBEDS()
|
|
IF CAN_CHOP_TRANSITION_BACK_FROM_WAIT()
|
|
chopWaitState = CHOP_WAIT_STATE_DONE
|
|
HANDLE_TRANSITION_BACK_TO_CHASE_MOVING(chopChaseProperties, TRUE, FALSE, 146, FALSE, FALSE)
|
|
ENDIF
|
|
ENDIF
|
|
ELIF chopStage = CHOP_TO_ROOF_EDGE
|
|
IF NOT SHOULD_CHOP_WAIT_AT_ROOF()
|
|
IF CAN_CHOP_TRANSITION_BACK_FROM_WAIT()
|
|
chopWaitState = CHOP_WAIT_STATE_DONE
|
|
HANDLE_TRANSITION_BACK_TO_CHASE_MOVING(chopChaseProperties, TRUE, FALSE, -1, FALSE)
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
BREAK
|
|
ENDSWITCH
|
|
ELSE
|
|
VECTOR vChopPos = GET_ENTITY_COORDS(chopPed)
|
|
INT iInitWaypoint
|
|
IF vChopPos.y < -682.7
|
|
iInitWaypoint = 7
|
|
ELSE
|
|
iInitWaypoint = 11
|
|
ENDIF
|
|
|
|
//IF GET_SCRIPT_TASK_STATUS(chopChaseProperties.ped, SCRIPT_TASK_FOLLOW_WAYPOINT_ROUTE) = FINISHED_TASK
|
|
TASK_FOLLOW_WAYPOINT_RECORDING(chopChaseProperties.ped, "hood7", iInitWaypoint, EWAYPOINT_DO_NOT_RESPOND_TO_COLLISION_EVENTS | EWAYPOINT_NAVMESH_BACK_TO_WAYPOINT_IF_LEFT_ROUTE)
|
|
//ENDIF
|
|
bStartedChopMovement = TRUE
|
|
ENDIF
|
|
ENDIF
|
|
ENDPROC
|
|
|
|
// block ragdoll on chop and runner
|
|
PROC BLOCK_FOOT_CHASE_RAGDOLL()
|
|
//IF NOT IS_PED_INJURED(chopPed)
|
|
// SET_PED_RESET_FLAG(chopPed, PRF_BlockWeaponReactionsUnlessDead, TRUE)
|
|
//ENDIF
|
|
IF NOT IS_PED_INJURED(runnerChaseProperties.ped)
|
|
IF NOT IS_PED_RAGDOLL(runnerChaseProperties.ped)
|
|
SET_PED_RESET_FLAG(runnerChaseProperties.ped, PRF_BlockWeaponReactionsUnlessDead, TRUE)
|
|
SET_PED_RESET_FLAG(runnerChaseProperties.ped, PRF_DisableSecondaryAnimationTasks, TRUE)
|
|
ENDIF
|
|
ENDIF
|
|
ENDPROC
|
|
|
|
// get dict for shocked
|
|
FUNC STRING GET_DICT_FOR_SHOCKED_ANIM(YARD_PED_ENUM thisYardPed)
|
|
SWITCH thisYardPed
|
|
CASE YP_STATION_WALK_TO_GATE
|
|
RETURN GET_HOOD_ANIM_DICT_AS_STRING(H_ANIM_DICT_FOOT_CHASE)
|
|
BREAK
|
|
CASE YP_STATION_CONV_KNOCK_OVER
|
|
RETURN GET_HOOD_ANIM_DICT_AS_STRING(H_ANIM_DICT_FOOT_CHASE)
|
|
BREAK
|
|
CASE YP_STATION_CONV_LOOK
|
|
RETURN GET_HOOD_ANIM_DICT_AS_STRING(H_ANIM_DICT_FOOT_CHASE)
|
|
BREAK
|
|
CASE YP_STATION_BACK_TURNED_KNOCK_OVER
|
|
RETURN GET_HOOD_ANIM_DICT_AS_STRING(H_ANIM_DICT_FOOT_CHASE)
|
|
BREAK
|
|
|
|
// construction site
|
|
//CASE YP_CONSTRUCT_CONV_LOOK1
|
|
// RETURN GET_HOOD_ANIM_DICT_AS_STRING(H_ANIM_DICT_GESTURE_IDLE1)
|
|
//BREAK
|
|
//CASE YP_CONSTRUCT_CONV_LOOK2
|
|
// RETURN GET_HOOD_ANIM_DICT_AS_STRING(H_ANIM_DICT_GESTURE_IDLE2)
|
|
//BREAK
|
|
CASE YP_CONSTRUCT_WALK_SOUTH
|
|
RETURN GET_HOOD_ANIM_DICT_AS_STRING(H_ANIM_DICT_FOOT_CHASE)
|
|
BREAK
|
|
CASE YP_CONSTRUCT_WALK_NORTH
|
|
RETURN GET_HOOD_ANIM_DICT_AS_STRING(H_ANIM_DICT_FOOT_CHASE)
|
|
BREAK
|
|
ENDSWITCH
|
|
|
|
RETURN "badstring"
|
|
ENDFUNC
|
|
|
|
// get anim for shocked
|
|
FUNC STRING GET_ANIM_FOR_SHOCKED_ANIM(YARD_PED_ENUM thisYardPed)
|
|
SWITCH thisYardPed
|
|
CASE YP_STATION_WALK_TO_GATE
|
|
RETURN "EXIT_TO_GENERIC"
|
|
BREAK
|
|
CASE YP_STATION_CONV_KNOCK_OVER
|
|
RETURN "EXIT_TO_GENERIC"
|
|
BREAK
|
|
CASE YP_STATION_CONV_LOOK
|
|
RETURN "EXIT_TO_GENERIC"
|
|
BREAK
|
|
CASE YP_STATION_BACK_TURNED_KNOCK_OVER
|
|
RETURN "EXIT_TO_GENERIC"
|
|
BREAK
|
|
|
|
// construction site
|
|
//CASE YP_CONSTRUCT_CONV_LOOK1
|
|
// RETURN "idle_b"
|
|
//BREAK
|
|
//CASE YP_CONSTRUCT_CONV_LOOK2
|
|
// RETURN "idle_e"
|
|
//BREAK
|
|
CASE YP_CONSTRUCT_WALK_SOUTH
|
|
RETURN "EXIT_TO_GENERIC"
|
|
BREAK
|
|
CASE YP_CONSTRUCT_WALK_NORTH
|
|
RETURN "EXIT_TO_GENERIC"
|
|
BREAK
|
|
ENDSWITCH
|
|
|
|
RETURN "badstring"
|
|
ENDFUNC
|
|
|
|
// get time for shocked
|
|
FUNC INT GET_TIME_FOR_SHOCKED_ANIM(YARD_PED_ENUM thisYardPed)
|
|
thisYardPed=thisYardPed
|
|
//SWITCH thisYardPed
|
|
//CASE YP_CONSTRUCT_CONV_LOOK1
|
|
// RETURN 8000
|
|
//BREAK
|
|
//CASE YP_CONSTRUCT_CONV_LOOK2
|
|
// RETURN 8500
|
|
//BREAK
|
|
//ENDSWITCH
|
|
|
|
RETURN 6000
|
|
ENDFUNC
|
|
|
|
// get end state for yard ped
|
|
FUNC YARD_PED_STATE_ENUM GET_END_YARD_PED_STATE(YARD_PED_ENUM thisYardPed)
|
|
SWITCH thisYardPed
|
|
CASE YP_STATION_CONV_KNOCK_OVER
|
|
RETURN YARD_PED_STATE_WANDER
|
|
BREAK
|
|
CASE YP_STATION_CONV_LOOK
|
|
RETURN YARD_PED_STATE_WANDER
|
|
BREAK
|
|
CASE YP_STATION_BACK_TURNED_KNOCK_OVER
|
|
RETURN YARD_PED_STATE_WALKING
|
|
BREAK
|
|
|
|
// construction site
|
|
//CASE YP_CONSTRUCT_CONV_LOOK1
|
|
// RETURN YARD_PED_STATE_WANDER
|
|
//BREAK
|
|
//CASE YP_CONSTRUCT_CONV_LOOK2
|
|
// RETURN YARD_PED_STATE_WANDER
|
|
//BREAK
|
|
ENDSWITCH
|
|
|
|
RETURN YARD_PED_STATE_TURN_TO_FACE
|
|
ENDFUNC
|
|
|
|
// set yard ped state
|
|
PROC SET_YARD_PED_STATE(YARD_PED_ENUM thisYardPed, YARD_PED_STATE_ENUM newState, VECTOR vPos, PED_INDEX otherPed = NULL, FLOAT fFloat = -1.0)
|
|
IF NOT IS_PED_INJURED(yardPed[thisYardPed].ped)
|
|
SWITCH newState
|
|
CASE YARD_PED_STATE_WALKING
|
|
//IF NOT IS_PED_INJURED(otherPed)
|
|
TASK_GO_STRAIGHT_TO_COORD(yardPed[thisYardPed].ped, vPos, PEDMOVE_WALK, DEFAULT_TIME_NEVER_WARP)
|
|
//ENDIF
|
|
BREAK
|
|
CASE YARD_PED_STATE_TALKING
|
|
IF NOT IS_PED_INJURED(otherPed)
|
|
TASK_LOOK_AT_ENTITY(yardPed[thisYardPed].ped, otherPed, -1, SLF_WHILE_NOT_IN_FOV)
|
|
TASK_CHAT_TO_PED(yardPed[thisYardPed].ped, otherPed, CF_AUTO_CHAT, <<0,0,0>>, -1, -1)
|
|
ENDIF
|
|
BREAK
|
|
CASE YARD_PED_STATE_RAGDOLL
|
|
//SET_PED_TO_RAGDOLL(yardPed[thisYardPed].ped, 2500, 2500, TASK_RELAX)
|
|
SET_PED_TO_RAGDOLL_WITH_FALL(yardPed[thisYardPed].ped, 3000, 3000, TYPE_DOWN_STAIRS, NORMALISE_VECTOR(vPos), 0, << 0.0, 0.0, 0.0 >>, << 0.0, 0.0, 0.0 >>)
|
|
IF thisYardPed = YP_STATION_CONV_KNOCK_OVER
|
|
TASK_TURN_PED_TO_FACE_ENTITY(yardPed[thisYardPed].ped, runnerChaseProperties.ped, 30000)
|
|
ENDIF
|
|
BREAK
|
|
CASE YARD_PED_STATE_ENTER_SHOCKED
|
|
CLEAR_SEQUENCE_TASK(sequence)
|
|
OPEN_SEQUENCE_TASK(sequence)
|
|
IF NOT IS_PED_INJURED(otherPed)
|
|
TASK_TURN_PED_TO_FACE_ENTITY(NULL, otherPed, 1000)
|
|
ELIF fFloat >= 0.0
|
|
TASK_ACHIEVE_HEADING(NULL, fFloat)
|
|
ENDIF
|
|
TASK_PLAY_ANIM(NULL, GET_HOOD_ANIM_DICT_AS_STRING(H_ANIM_DICT_FOOT_CHASE), "REACTION_FORWARD_BIG_INTRO_A", NORMAL_BLEND_IN, NORMAL_BLEND_OUT, -1)
|
|
CLOSE_SEQUENCE_TASK(sequence)
|
|
TASK_PERFORM_SEQUENCE(yardPed[thisYardPed].ped, sequence)
|
|
BREAK
|
|
CASE YARD_PED_STATE_LOOPING_SHOCKED
|
|
TASK_PLAY_ANIM(yardPed[thisYardPed].ped, GET_DICT_FOR_SHOCKED_ANIM(thisYardPed), GET_ANIM_FOR_SHOCKED_ANIM(thisYardPed), NORMAL_BLEND_IN, NORMAL_BLEND_OUT, -1, AF_LOOPING)
|
|
BREAK
|
|
CASE YARD_PED_STATE_EXIT_SHOCKED
|
|
TASK_PLAY_ANIM(yardPed[thisYardPed].ped, GET_HOOD_ANIM_DICT_AS_STRING(H_ANIM_DICT_FOOT_CHASE), "BIG_EXIT_TO_GENERIC", NORMAL_BLEND_IN, NORMAL_BLEND_OUT, -1, AF_HOLD_LAST_FRAME)
|
|
BREAK
|
|
CASE YARD_PED_STATE_TURN_TO_FACE
|
|
TASK_LOOK_AT_ENTITY(yardPed[thisYardPed].ped, PLAYER_PED_ID(), -1, SLF_WHILE_NOT_IN_FOV)
|
|
BREAK
|
|
CASE YARD_PED_STATE_WANDER
|
|
TASK_LOOK_AT_ENTITY(yardPed[thisYardPed].ped, PLAYER_PED_ID(), -1, SLF_WHILE_NOT_IN_FOV)
|
|
TASK_WANDER_STANDARD(yardPed[thisYardPed].ped)
|
|
BREAK
|
|
CASE YARD_PED_STATE_FLEE
|
|
TASK_LOOK_AT_ENTITY(yardPed[thisYardPed].ped, PLAYER_PED_ID(), -1, SLF_WHILE_NOT_IN_FOV)
|
|
TASK_SMART_FLEE_PED(yardPed[thisYardPed].ped, PLAYER_PED_ID(), 1000, -1)
|
|
BREAK
|
|
ENDSWITCH
|
|
ENDIF
|
|
|
|
yardPed[thisYardPed].iStateTime = GET_GAME_TIMER()
|
|
yardPed[thisYardPed].state = newState
|
|
ENDPROC
|
|
|
|
// peds on foot
|
|
PROC HANDLE_YARD_PEDS()
|
|
INT i
|
|
|
|
VECTOR vPlayerPos = GET_ENTITY_COORDS(PLAYER_PED_ID())
|
|
|
|
IF NOT IS_PED_INJURED(runnerChaseProperties.ped)
|
|
REPEAT NUMBER_YARD_PEDS i
|
|
IF NOT IS_PED_INJURED(yardPed[i].ped)
|
|
YARD_PED_ENUM thisYardPed = INT_TO_ENUM(YARD_PED_ENUM, i)
|
|
// individual behaviour by ped
|
|
SWITCH yardPed[thisYardPed].state
|
|
CASE YARD_PED_STATE_IDLE
|
|
SWITCH thisYardPed
|
|
CASE YP_STATION_WALK_TO_GATE
|
|
IF GET_GAME_TIMER() >= iSetpieceStageStartTime + 1500
|
|
AND setpieceStage >= SETPIECE_FREE_INTO_STATION
|
|
SET_YARD_PED_STATE(thisYardPed, YARD_PED_STATE_WALKING, <<456.90, -636.52, 27.51>>, runnerChaseProperties.ped)
|
|
ENDIF
|
|
BREAK
|
|
CASE YP_STATION_CONV_KNOCK_OVER
|
|
SET_YARD_PED_STATE(thisYardPed, YARD_PED_STATE_TALKING, <<0,0,0>>, yardPed[YP_STATION_CONV_LOOK].ped)
|
|
BREAK
|
|
CASE YP_STATION_CONV_LOOK
|
|
SET_YARD_PED_STATE(thisYardPed, YARD_PED_STATE_TALKING, <<0,0,0>>, yardPed[YP_STATION_CONV_KNOCK_OVER].ped)
|
|
BREAK
|
|
CASE YP_STATION_BACK_TURNED_KNOCK_OVER
|
|
BREAK
|
|
|
|
// construction site
|
|
//CASE YP_CONSTRUCT_CONV_LOOK1
|
|
// SET_YARD_PED_STATE(thisYardPed, YARD_PED_STATE_TALKING, <<0,0,0>>, yardPed[YP_CONSTRUCT_CONV_LOOK2].ped)
|
|
//BREAK
|
|
//CASE YP_CONSTRUCT_CONV_LOOK2
|
|
// SET_YARD_PED_STATE(thisYardPed, YARD_PED_STATE_TALKING, <<0,0,0>>, yardPed[YP_CONSTRUCT_CONV_LOOK1].ped)
|
|
//BREAK
|
|
CASE YP_CONSTRUCT_WALK_SOUTH
|
|
IF GET_GAME_TIMER() >= iSetpieceStageStartTime + 2000
|
|
AND setpieceStage >= SETPIECE_FREE_ACROSS_CONSTRUCTION
|
|
SET_YARD_PED_STATE(thisYardPed, YARD_PED_STATE_WALKING, <<515.99988, -567.98999, 23.79971>>, runnerChaseProperties.ped)
|
|
ENDIF
|
|
BREAK
|
|
CASE YP_CONSTRUCT_WALK_NORTH
|
|
IF GET_GAME_TIMER() >= iSetpieceStageStartTime + 6000
|
|
AND setpieceStage >= SETPIECE_FREE_ACROSS_CONSTRUCTION
|
|
SET_YARD_PED_STATE(thisYardPed, YARD_PED_STATE_WALKING, <<525.27997, -458.12784, 23.81619>>, runnerChaseProperties.ped)
|
|
ENDIF
|
|
BREAK
|
|
ENDSWITCH
|
|
BREAK
|
|
|
|
CASE YARD_PED_STATE_TALKING
|
|
IF GET_SCRIPT_TASK_STATUS(yardPed[thisYardPed].ped, SCRIPT_TASK_CHAT_TO_PED) = FINISHED_TASK
|
|
SET_YARD_PED_STATE(thisYardPed, YARD_PED_STATE_IDLE, <<0,0,0>>)
|
|
ENDIF
|
|
BREAK
|
|
|
|
CASE YARD_PED_STATE_WALKING
|
|
FLOAT fPlayerDist
|
|
FLOAT fChopDist
|
|
FLOAT fRunnerDist
|
|
|
|
IF GET_GAME_TIMER() >= yardPed[thisYardPed].iRecheckLookTime
|
|
IF NOT IS_PED_INJURED(PLAYER_PED_ID())
|
|
AND NOT IS_PED_INJURED(chopPed)
|
|
AND NOT IS_PED_INJURED(runnerChaseProperties.ped)
|
|
fPlayerDist = GET_DISTANCE_BETWEEN_ENTITIES(yardPed[thisYardPed].ped, PLAYER_PED_ID(), FALSE)
|
|
fChopDist = GET_DISTANCE_BETWEEN_ENTITIES(yardPed[thisYardPed].ped, chopPed, FALSE)
|
|
fRunnerDist = GET_DISTANCE_BETWEEN_ENTITIES(yardPed[thisYardPed].ped, runnerChaseProperties.ped, FALSE)
|
|
|
|
PED_INDEX lookAtPed
|
|
IF fPlayerDist < fChopDist
|
|
IF fPlayerDist < fRunnerDist
|
|
lookAtPed = PLAYER_PED_ID()
|
|
ELSE
|
|
IF fRunnerDist < fChopDist
|
|
lookAtPed = runnerChaseProperties.ped
|
|
ELSE
|
|
lookAtPed = chopPed
|
|
ENDIF
|
|
ENDIF
|
|
ELSE
|
|
IF fChopDist < fRunnerDist
|
|
lookAtPed = chopPed
|
|
ELSE
|
|
lookAtPed = runnerChaseProperties.ped
|
|
ENDIF
|
|
ENDIF
|
|
TASK_LOOK_AT_ENTITY(yardPed[thisYardPed].ped, lookAtPed, -1, SLF_WHILE_NOT_IN_FOV)
|
|
yardPed[thisYardPed].iRecheckLookTime = GET_GAME_TIMER() + 1000
|
|
ENDIF
|
|
ENDIF
|
|
BREAK
|
|
|
|
CASE YARD_PED_STATE_ENTER_SHOCKED
|
|
IF IS_ENTITY_PLAYING_ANIM(yardPed[thisYardPed].ped, GET_HOOD_ANIM_DICT_AS_STRING(H_ANIM_DICT_FOOT_CHASE), "REACTION_FORWARD_BIG_INTRO_A")
|
|
IF GET_ENTITY_ANIM_CURRENT_TIME(yardPed[thisYardPed].ped, GET_HOOD_ANIM_DICT_AS_STRING(H_ANIM_DICT_FOOT_CHASE), "REACTION_FORWARD_BIG_INTRO_A") >= 0.98
|
|
IF thisYardPed = YP_STATION_BACK_TURNED_KNOCK_OVER
|
|
//SET_YARD_PED_STATE(thisYardPed, YARD_PED_STATE_LOOPING_SHOCKED, <<0,0,0>>)
|
|
//SET_YARD_PED_STATE(thisYardPed, YARD_PED_STATE_EXIT_SHOCKED, <<0,0,0>>)
|
|
SET_YARD_PED_STATE(thisYardPed, GET_END_YARD_PED_STATE(thisYardPed), <<0,0,0>>)
|
|
ENDIF
|
|
ENDIF
|
|
ELSE
|
|
IF (GET_GAME_TIMER() >= yardPed[thisYardPed].iStateTime + 3000 AND thisYardPed = YP_STATION_BACK_TURNED_KNOCK_OVER)
|
|
OR GET_GAME_TIMER() >= yardPed[thisYardPed].iStateTime + 10000
|
|
OR vPlayerPos.y > -625
|
|
SET_YARD_PED_STATE(thisYardPed, GET_END_YARD_PED_STATE(thisYardPed), <<0,0,0>>)
|
|
ELSE
|
|
IF GET_GAME_TIMER() >= yardPed[thisYardPed].iStateTime + 1000
|
|
IF thisYardPed = YP_STATION_CONV_LOOK
|
|
IF GET_SCRIPT_TASK_STATUS(yardPed[thisYardPed].ped, SCRIPT_TASK_TURN_PED_TO_FACE_ENTITY) = FINISHED_TASK
|
|
AND GET_SCRIPT_TASK_STATUS(yardPed[thisYardPed].ped, SCRIPT_TASK_PERFORM_SEQUENCE) = FINISHED_TASK
|
|
TASK_TURN_PED_TO_FACE_ENTITY(yardPed[thisYardPed].ped, runnerChaseProperties.ped, 30000)
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
BREAK
|
|
|
|
CASE YARD_PED_STATE_LOOPING_SHOCKED
|
|
IF GET_GAME_TIMER() >= yardPed[thisYardPed].iStateTime + GET_TIME_FOR_SHOCKED_ANIM(thisYardPed)
|
|
SET_YARD_PED_STATE(thisYardPed, YARD_PED_STATE_EXIT_SHOCKED, <<0,0,0>>)
|
|
ENDIF
|
|
BREAK
|
|
|
|
CASE YARD_PED_STATE_EXIT_SHOCKED
|
|
IF IS_ENTITY_PLAYING_ANIM(yardPed[thisYardPed].ped, GET_HOOD_ANIM_DICT_AS_STRING(H_ANIM_DICT_FOOT_CHASE), "BIG_EXIT_TO_GENERIC")
|
|
IF GET_ENTITY_ANIM_CURRENT_TIME(yardPed[thisYardPed].ped, GET_HOOD_ANIM_DICT_AS_STRING(H_ANIM_DICT_FOOT_CHASE), "BIG_EXIT_TO_GENERIC") >= 0.98
|
|
SET_YARD_PED_STATE(thisYardPed, GET_END_YARD_PED_STATE(thisYardPed), <<0,0,0>>)
|
|
ENDIF
|
|
ELSE
|
|
IF GET_GAME_TIMER() >= yardPed[thisYardPed].iStateTime + 1000
|
|
SET_YARD_PED_STATE(thisYardPed, GET_END_YARD_PED_STATE(thisYardPed), <<0,0,0>>)
|
|
ENDIF
|
|
ENDIF
|
|
BREAK
|
|
|
|
CASE YARD_PED_STATE_RAGDOLL
|
|
IF NOT IS_PED_RAGDOLL(yardPed[thisYardPed].ped)
|
|
IF (thisYardPed = YP_STATION_BACK_TURNED_KNOCK_OVER AND GET_GAME_TIMER() >= yardPed[thisYardPed].iStateTime + 1000)
|
|
OR GET_GAME_TIMER() >= yardPed[thisYardPed].iStateTime + 8000
|
|
OR vPlayerPos.y > -626
|
|
VECTOR vEndPos
|
|
vEndPos=<<0,0,0>>
|
|
vEndPos=vEndPos
|
|
SWITCH thisYardPed
|
|
CASE YP_STATION_BACK_TURNED_KNOCK_OVER
|
|
vEndPos = <<432.37698, -589.83594, 27.49981>>
|
|
BREAK
|
|
ENDSWITCH
|
|
|
|
SET_YARD_PED_STATE(thisYardPed, GET_END_YARD_PED_STATE(thisYardPed), vEndPos)
|
|
ENDIF
|
|
ENDIF
|
|
BREAK
|
|
|
|
CASE YARD_PED_STATE_WANDER
|
|
IF GET_SCRIPT_TASK_STATUS(yardPed[thisYardPed].ped, SCRIPT_TASK_WANDER_STANDARD) = FINISHED_TASK
|
|
SET_YARD_PED_STATE(thisYardPed, YARD_PED_STATE_WANDER, <<0,0,0>>)
|
|
ENDIF
|
|
BREAK
|
|
|
|
CASE YARD_PED_STATE_FLEE
|
|
IF GET_SCRIPT_TASK_STATUS(yardPed[thisYardPed].ped, SCRIPT_TASK_SMART_FLEE_PED) = FINISHED_TASK
|
|
SET_YARD_PED_STATE(thisYardPed, YARD_PED_STATE_FLEE, <<0,0,0>>)
|
|
ENDIF
|
|
BREAK
|
|
ENDSWITCH
|
|
|
|
// specific changes
|
|
IF yardPed[thisYardPed].state <> YARD_PED_STATE_FLEE
|
|
SWITCH thisYardPed
|
|
CASE YP_STATION_CONV_KNOCK_OVER
|
|
IF IS_ENTITY_AT_ENTITY(yardPed[thisYardPed].ped, runnerChaseProperties.ped, <<1.5, 1.5, 0>>, FALSE, FALSE)
|
|
AND NOT IS_PED_RAGDOLL(yardPed[thisYardPed].ped)
|
|
SET_YARD_PED_STATE(thisYardPed, YARD_PED_STATE_RAGDOLL, <<2,0,0>>)
|
|
ENDIF
|
|
BREAK
|
|
CASE YP_STATION_CONV_LOOK
|
|
IF yardPed[YP_STATION_CONV_KNOCK_OVER].state = YARD_PED_STATE_RAGDOLL
|
|
AND (yardPed[thisYardPed].state = YARD_PED_STATE_TALKING OR yardPed[thisYardPed].state = YARD_PED_STATE_IDLE)
|
|
SET_YARD_PED_STATE(thisYardPed, YARD_PED_STATE_ENTER_SHOCKED, <<0,0,0>>)
|
|
ENDIF
|
|
BREAK
|
|
CASE YP_STATION_BACK_TURNED_KNOCK_OVER
|
|
IF IS_ENTITY_AT_ENTITY(yardPed[thisYardPed].ped, runnerChaseProperties.ped, <<1.5, 1.5, 0>>, FALSE, FALSE)
|
|
AND NOT IS_PED_RAGDOLL(yardPed[thisYardPed].ped)
|
|
SET_YARD_PED_STATE(thisYardPed, YARD_PED_STATE_RAGDOLL, <<-2,0,0>>)
|
|
ENDIF
|
|
BREAK
|
|
//CASE YP_CONSTRUCT_CONV_LOOK1
|
|
// IF IS_ENTITY_AT_ENTITY(yardPed[thisYardPed].ped, runnerChaseProperties.ped, <<1.5, 1.5, 0>>, FALSE, FALSE)
|
|
// AND (yardPed[thisYardPed].state = YARD_PED_STATE_TALKING OR yardPed[thisYardPed].state = YARD_PED_STATE_IDLE)
|
|
// SET_YARD_PED_STATE(thisYardPed, YARD_PED_STATE_ENTER_SHOCKED, <<0,0,0>>, NULL, 279)
|
|
// ENDIF
|
|
//BREAK
|
|
//CASE YP_CONSTRUCT_CONV_LOOK2
|
|
// IF IS_ENTITY_AT_ENTITY(yardPed[thisYardPed].ped, runnerChaseProperties.ped, <<1.5, 1.5, 0>>, FALSE, FALSE)
|
|
// AND (yardPed[thisYardPed].state = YARD_PED_STATE_TALKING OR yardPed[thisYardPed].state = YARD_PED_STATE_IDLE)
|
|
// SET_YARD_PED_STATE(thisYardPed, YARD_PED_STATE_ENTER_SHOCKED, <<0,0,0>>, NULL, 281)
|
|
// ENDIF
|
|
//BREAK
|
|
ENDSWITCH
|
|
|
|
// handle the peds reacting to chop
|
|
IF NOT yardPed[thisYardPed].bReactedToChop
|
|
IF NOT IS_PED_INJURED(chopPed)
|
|
FLOAT fChopReactDistance
|
|
SWITCH thisYardPed
|
|
CASE YP_STATION_WALK_TO_GATE
|
|
fChopReactDistance = 20.0
|
|
BREAK
|
|
CASE YP_STATION_CONV_KNOCK_OVER
|
|
fChopReactDistance = -1
|
|
BREAK
|
|
CASE YP_STATION_CONV_LOOK
|
|
fChopReactDistance = 3.0
|
|
BREAK
|
|
CASE YP_STATION_BACK_TURNED_KNOCK_OVER
|
|
fChopReactDistance = 6.0
|
|
BREAK
|
|
CASE YP_CONSTRUCT_WALK_SOUTH
|
|
fChopReactDistance = 6.0
|
|
BREAK
|
|
CASE YP_CONSTRUCT_WALK_NORTH
|
|
fChopReactDistance = 16.0
|
|
BREAK
|
|
ENDSWITCH
|
|
|
|
IF fChopReactDistance >= 0
|
|
//IF IS_ENTITY_AT_ENTITY(yardPed[thisYardPed].ped, chopPed, <<fChopReactDistance,fChopReactDistance,fChopReactDistance>>, FALSE, FALSE)
|
|
IF IS_ENTITY_AT_ENTITY(yardPed[thisYardPed].ped, PLAYER_PED_ID(), <<6,6,6>>, FALSE, FALSE)
|
|
IF NOT IS_ANY_CONVERSATION_ONGOING_OR_QUEUED()
|
|
PLAY_PED_AMBIENT_SPEECH(yardPed[thisYardPed].ped, "GENERIC_SHOCKED_MED", SPEECH_PARAMS_FORCE_SHOUTED)
|
|
yardPed[thisYardPed].bReactedToChop = TRUE
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
|
|
// run if player threatens them
|
|
IF IS_PLAYER_THREATENING_PED(yardPed[thisYardPed].ped)
|
|
SET_YARD_PED_STATE(thisYardPed, YARD_PED_STATE_FLEE, <<0,0,0>>)
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDREPEAT
|
|
ENDIF
|
|
ENDPROC
|
|
|
|
// attach the balla
|
|
PROC ATTACH_BALLA_TO_VAN(BOOL bSetCoords = FALSE)
|
|
IF NOT IS_PED_INJURED(runnerChaseProperties.ped)
|
|
AND IS_VEHICLE_DRIVEABLE(hoodVehicle[HV_FRANKLIN_VAN])
|
|
IF bSetCoords
|
|
SET_ENTITY_COORDS(runnerChaseProperties.ped, <<0,0,0>>, TRUE, TRUE)
|
|
ENDIF
|
|
|
|
INT iBone = GET_ENTITY_BONE_INDEX_BY_NAME(hoodVehicle[HV_FRANKLIN_VAN], "seat_pside_r")
|
|
ATTACH_ENTITY_TO_ENTITY(runnerChaseProperties.ped, hoodVehicle[HV_FRANKLIN_VAN], iBone, vRunnerAttachToVanPos, vRunnerAttachToVanRot, FALSE, FALSE, TRUE, TRUE)
|
|
ENDIF
|
|
ENDPROC
|
|
|
|
// bad guy flee
|
|
PROC MAINTAIN_BAD_GUY_FLEE()
|
|
// ensure bad guy runs away
|
|
IF NOT IS_PED_INJURED(runnerChaseProperties.ped)
|
|
AND NOT IS_PED_INJURED(PLAYER_PED_ID())
|
|
IF NOT IS_PED_IN_ANY_VEHICLE(runnerChaseProperties.ped)
|
|
AND NOT IS_ENTITY_ATTACHED_TO_ANY_VEHICLE(runnerChaseProperties.ped)
|
|
AND NOT IS_SYNCHRONIZED_SCENE_RUNNING(runnerChaseProperties.iSyncScene)
|
|
//IF NOT IS_ENTITY_PLAYING_ANIM(runnerChaseProperties.ped, GET_HOOD_ANIM_DICT_AS_STRING(H_ANIM_DICT_DRIVE_HOME), "Incar_GetOutofBack_Ballas")
|
|
IF NOT bRunningCutscene
|
|
/*
|
|
IF NOT bBadGuyRun
|
|
VECTOR vBadGuyPos = GET_ENTITY_COORDS(runnerChaseProperties.ped)
|
|
IF IS_PLAYER_THREATENING_PED(runnerChaseProperties.ped, FALSE)
|
|
OR IS_SNIPER_BULLET_IN_AREA(vBadGuyPos - <<5,5,5>>, vBadGuyPos + <<5,5,5>>)
|
|
OR IS_BULLET_IN_AREA(vBadGuyPos, 5.0)
|
|
bBadGuyRun = TRUE
|
|
ELSE
|
|
IF GET_SCRIPT_TASK_STATUS(runnerChaseProperties.ped, SCRIPT_TASK_WANDER_STANDARD) = FINISHED_TASK
|
|
AND GET_SCRIPT_TASK_STATUS(runnerChaseProperties.ped, SCRIPT_TASK_FOLLOW_NAV_MESH_TO_COORD) = FINISHED_TASK
|
|
TASK_WANDER_STANDARD(runnerChaseProperties.ped)
|
|
ENDIF
|
|
ENDIF
|
|
ELSE
|
|
*/
|
|
IF GET_SCRIPT_TASK_STATUS(runnerChaseProperties.ped, SCRIPT_TASK_SMART_FLEE_PED) = FINISHED_TASK
|
|
TASK_SMART_FLEE_PED(runnerChaseProperties.ped, PLAYER_PED_ID(), 1000, -1)
|
|
ENDIF
|
|
//ENDIF
|
|
ENDIF
|
|
//ENDIF
|
|
ELSE
|
|
/*
|
|
IF IS_ENTITY_PLAYING_ANIM(runnerChaseProperties.ped, GET_HOOD_ANIM_DICT_AS_STRING(H_ANIM_DICT_DRIVE_HOME), "Incar_GetOutofBack_Ballas")
|
|
FLOAT fPhase = GET_ENTITY_ANIM_CURRENT_TIME(runnerChaseProperties.ped, GET_HOOD_ANIM_DICT_AS_STRING(H_ANIM_DICT_DRIVE_HOME), "Incar_GetOutofBack_Ballas")
|
|
IF fPhase >= 0
|
|
IF fPhase >= 0.222
|
|
IF NOT bSetVanDoorsFree
|
|
IF IS_VEHICLE_DRIVEABLE(hoodVehicle[HV_FRANKLIN_VAN])
|
|
STOP_ENTITY_ANIM(hoodVehicle[HV_FRANKLIN_VAN], "Incar_GetOutofBack_Speedo", GET_HOOD_ANIM_DICT_AS_STRING(H_ANIM_DICT_DRIVE_HOME), INSTANT_BLEND_OUT)
|
|
ENDIF
|
|
bSetVanDoorsFree = TRUE
|
|
ENDIF
|
|
|
|
IF IS_ENTITY_ATTACHED(runnerChaseProperties.ped)
|
|
DETACH_ENTITY(runnerChaseProperties.ped, FALSE, FALSE)
|
|
ENDIF
|
|
ELSE
|
|
vRunnerAttachToVanRot = GET_ANIM_INITIAL_OFFSET_ROTATION(GET_HOOD_ANIM_DICT_AS_STRING(H_ANIM_DICT_DRIVE_HOME), "Incar_GetOutofBack_Ballas", <<0,0,0>>, <<0,0,0>>, fPhase)
|
|
vRunnerAttachToVanPos = GET_ANIM_INITIAL_OFFSET_POSITION(GET_HOOD_ANIM_DICT_AS_STRING(H_ANIM_DICT_DRIVE_HOME), "Incar_GetOutofBack_Ballas", <<0,0,0>>, <<0,0,0>>, fPhase)
|
|
ATTACH_BALLA_TO_VAN()
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
*/
|
|
ENDIF
|
|
ENDIF
|
|
ENDPROC
|
|
|
|
// chop
|
|
PROC HANDLE_CHOP()
|
|
/*
|
|
IF IS_VEHICLE_DRIVEABLE(dogVehicle)
|
|
IF NOT IS_PLAYBACK_GOING_ON_FOR_VEHICLE(dogVehicle)
|
|
IF iChopStage < 5
|
|
INT iRec
|
|
FLOAT fSkipTime
|
|
FLOAT fPlaybackSpeed
|
|
INT iStartTime
|
|
RUNNER_STAGE_ENUM startStage
|
|
|
|
SWITCH iChopStage
|
|
CASE 0
|
|
iRec = 013
|
|
startStage = RUNNER_START_FLEE
|
|
BREAK
|
|
CASE 1
|
|
iRec = 014
|
|
startStage = RUNNER_TO_CAR
|
|
fSkipTime = 1800
|
|
BREAK
|
|
CASE 2
|
|
iRec = 015
|
|
fSkipTime = 1500
|
|
startStage = RUNNER_TO_FLATBEDS
|
|
BREAK
|
|
CASE 3
|
|
iRec = 016
|
|
startStage = RUNNER_TO_BOXCAR
|
|
BREAK
|
|
CASE 4
|
|
iRec = 017
|
|
startStage = RUNNER_TO_TRAIN
|
|
BREAK
|
|
ENDSWITCH
|
|
|
|
IF runnerStage >= startStage
|
|
IF GET_GAME_TIMER() >= iRunnerStageStartTime + iStartTime
|
|
IF iChopStage <> 2 // temp vehicle recording fudge to wait at fence
|
|
OR bDoneThroughFenceCut
|
|
START_PLAYBACK_RECORDED_VEHICLE(dogVehicle, iRec, GET_HOOD_RECORDING_PREFIX())
|
|
SKIP_TIME_IN_PLAYBACK_RECORDED_VEHICLE(dogVehicle, fSkipTime)
|
|
fChopSpeed = 0.85
|
|
SET_PLAYBACK_SPEED(dogVehicle, fChopSpeed)
|
|
iChopStage++
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ELSE
|
|
IF iChopStage = 5
|
|
SET_ENTITY_COORDS(dogVehicle, <<517.47, -617.94, 23.75>>)
|
|
SET_ENTITY_HEADING(dogVehicle, 172.65)
|
|
SET_VEHICLE_ON_GROUND_PROPERLY(dogVehicle)
|
|
iChopStage++
|
|
ENDIF
|
|
ENDIF
|
|
ELSE
|
|
// calculate speed
|
|
FLOAT fDistance = GET_DISTANCE_BETWEEN_ENTITIES(dogVehicle, runnerChaseProperties.ped)
|
|
IF fDistance >= 6.0
|
|
fChopSpeed = fChopSpeed +@ 1.5
|
|
IF fChopSpeed >= 0.85
|
|
fChopSpeed = 0.85
|
|
ENDIF
|
|
ELSE
|
|
fChopSpeed = fChopSpeed -@ 1.5
|
|
IF fChopSpeed <= 0.3
|
|
fChopSpeed = 0.3
|
|
ENDIF
|
|
ENDIF
|
|
|
|
SET_PLAYBACK_SPEED(dogVehicle, fChopSpeed)
|
|
ENDIF
|
|
ENDIF
|
|
*/
|
|
ENDPROC
|
|
|
|
// setpieces for foot chase
|
|
PROC HANDLE_CHASE_SETPIECES()
|
|
HANDLE_YARD_VEHICLES()
|
|
HANDLE_TRAINS()
|
|
HANDLE_YARD_PEDS()
|
|
HANDLE_CHOP()
|
|
ENDPROC
|
|
|
|
PROC REMOVE_SETPIECE_VEHICLE_DRIVER(VEHICLE_INDEX veh)
|
|
IF IS_VEHICLE_DRIVEABLE(veh)
|
|
PED_INDEX ped = GET_PED_IN_VEHICLE_SEAT(veh)
|
|
IF DOES_ENTITY_EXIST(ped)
|
|
SET_PED_AS_NO_LONGER_NEEDED(ped)
|
|
ENDIF
|
|
ENDIF
|
|
ENDPROC
|
|
|
|
// get rid of initial traffic
|
|
PROC REMOVE_TRAFFIC_OUTSIDE_STATION()
|
|
INT i
|
|
|
|
REPEAT NUMBER_YARD_VEHICLES i
|
|
IF i=2
|
|
IF DOES_ENTITY_EXIST(yardVehicle[i])
|
|
REMOVE_SETPIECE_VEHICLE_DRIVER(yardVehicle[i])
|
|
SET_VEHICLE_AS_NO_LONGER_NEEDED(yardVehicle[i])
|
|
ENDIF
|
|
ENDIF
|
|
ENDREPEAT
|
|
|
|
bRemovedTraffic = TRUE
|
|
ENDPROC
|
|
|
|
// get rid of everything in bus station
|
|
PROC REMOVE_BUS_STATION()
|
|
INT i
|
|
|
|
REPEAT NUMBER_YARD_VEHICLES i
|
|
IF i=2
|
|
OR i=3
|
|
OR i=7
|
|
OR i=8
|
|
OR i=9
|
|
IF DOES_ENTITY_EXIST(yardVehicle[i])
|
|
REMOVE_SETPIECE_VEHICLE_DRIVER(yardVehicle[i])
|
|
SET_VEHICLE_AS_NO_LONGER_NEEDED(yardVehicle[i])
|
|
ENDIF
|
|
ENDIF
|
|
ENDREPEAT
|
|
|
|
REPEAT NUMBER_YARD_PEDS i
|
|
IF i<4
|
|
IF DOES_ENTITY_EXIST(yardPed[i].ped)
|
|
SET_PED_AS_NO_LONGER_NEEDED(yardPed[i].ped)
|
|
ENDIF
|
|
ENDIF
|
|
ENDREPEAT
|
|
|
|
bRemovedBusStation = TRUE
|
|
ENDPROC
|
|
|
|
PROC REMOVE_CHASE_SETPIECES()
|
|
INT i
|
|
|
|
REPEAT COUNT_OF(driverPed) i
|
|
IF DOES_ENTITY_EXIST(driverPed[i])
|
|
SET_PED_AS_NO_LONGER_NEEDED(driverPed[i])
|
|
ENDIF
|
|
ENDREPEAT
|
|
|
|
REPEAT NUMBER_YARD_VEHICLES i
|
|
IF DOES_ENTITY_EXIST(yardVehicle[i])
|
|
SET_VEHICLE_AS_NO_LONGER_NEEDED(yardVehicle[i])
|
|
ENDIF
|
|
ENDREPEAT
|
|
REPEAT NUMBER_TRAINS i
|
|
IF DOES_ENTITY_EXIST(trainVehicle[i])
|
|
SET_MISSION_TRAIN_AS_NO_LONGER_NEEDED(trainVehicle[i], ENUM_TO_INT(RTF_KEEP_OLD_SPEED))
|
|
ENDIF
|
|
ENDREPEAT
|
|
REPEAT NUMBER_YARD_PEDS i
|
|
IF DOES_ENTITY_EXIST(yardPed[i].ped)
|
|
SET_PED_AS_NO_LONGER_NEEDED(yardPed[i].ped)
|
|
ENDIF
|
|
ENDREPEAT
|
|
IF DOES_ENTITY_EXIST(colliePed)
|
|
SET_PED_AS_NO_LONGER_NEEDED(colliePed)
|
|
ENDIF
|
|
REPEAT NUMBER_BOXCARS i
|
|
INT j
|
|
REPEAT 2 j
|
|
IF DOES_ENTITY_EXIST(boxcarCarriage[i].boxcarDoor[j].obj)
|
|
DELETE_OBJECT(boxcarCarriage[i].boxcarDoor[j].obj)
|
|
ENDIF
|
|
IF DOES_ENTITY_EXIST(boxcarCarriage[i].boxcarDoor[j].handleObject)
|
|
DELETE_OBJECT(boxcarCarriage[i].boxcarDoor[j].handleObject)
|
|
ENDIF
|
|
ENDREPEAT
|
|
|
|
IF DOES_ENTITY_EXIST(boxcarCarriage[i].anchorObject)
|
|
DELETE_OBJECT(boxcarCarriage[i].anchorObject)
|
|
ENDIF
|
|
ENDREPEAT
|
|
|
|
bRemovedChaseSetpieces = TRUE
|
|
ENDPROC
|
|
|
|
PROC DO_LAMAR_WALK_TO_VAN()
|
|
IF NOT bDoneLamarWalkToVan
|
|
IF NOT IS_PED_GROUP_MEMBER(lamarPed, PLAYER_GROUP_ID())
|
|
BOOL bDoWalk = FALSE
|
|
IF GET_SCRIPT_TASK_STATUS(lamarPed, SCRIPT_TASK_SYNCHRONIZED_SCENE) = FINISHED_TASK
|
|
bDoWalk = TRUE
|
|
ELSE
|
|
// IF GET_SYNCHRONIZED_SCENE_PHASE(iLamarSyncScene) >= 0.73
|
|
// bDoWalk = TRUE
|
|
// ENDIF
|
|
ENDIF
|
|
|
|
IF bDoWalk
|
|
TASK_CLEAR_LOOK_AT(lamarPed)
|
|
SET_ENTITY_NO_COLLISION_ENTITY(lamarPed, hoodVehicle[HV_FRANKLIN_VAN], TRUE)
|
|
TASK_ENTER_VEHICLE(lamarPed, hoodVehicle[HV_FRANKLIN_VAN], DEFAULT_TIME_BEFORE_WARP, VS_FRONT_RIGHT, PEDMOVE_WALK)
|
|
iEnterVanTaskTime = GET_GAME_TIMER()
|
|
bDoneLamarWalkToVan = TRUE
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDPROC
|
|
|
|
// close all van doors
|
|
PROC SHUT_ALL_VAN_DOORS()
|
|
IF IS_VEHICLE_DRIVEABLE(hoodVehicle[HV_FRANKLIN_VAN])
|
|
SET_VEHICLE_DOOR_SHUT(hoodVehicle[HV_FRANKLIN_VAN], SC_DOOR_FRONT_RIGHT)
|
|
SET_VEHICLE_DOOR_SHUT(hoodVehicle[HV_FRANKLIN_VAN], SC_DOOR_FRONT_LEFT)
|
|
SET_VEHICLE_DOOR_SHUT(hoodVehicle[HV_FRANKLIN_VAN], SC_DOOR_REAR_LEFT)
|
|
SET_VEHICLE_DOOR_SHUT(hoodVehicle[HV_FRANKLIN_VAN], SC_DOOR_REAR_RIGHT)
|
|
ENDIF
|
|
ENDPROC
|
|
|
|
#IF IS_DEBUG_BUILD
|
|
PROC DO_DEBUG_VAN_CAM_POSITION()
|
|
IF DOES_CAM_EXIST(staticCam)
|
|
IF IS_VEHICLE_DRIVEABLE(hoodVehicle[HV_FRANKLIN_VAN])
|
|
ATTACH_CAM_TO_ENTITY(staticCam, hoodVehicle[HV_FRANKLIN_VAN], vDebugVanCamOffset)
|
|
POINT_CAM_AT_ENTITY(staticCam, hoodVehicle[HV_FRANKLIN_VAN], vDebugVanCamPoint)
|
|
SET_CAM_FOV(staticCam, fDebugVanCamFOV)
|
|
ENDIF
|
|
ENDIF
|
|
ENDPROC
|
|
#ENDIF
|
|
|
|
// common stuff for cutscene skip
|
|
PROC HANDLE_SKIP_CUTSCENE()
|
|
IF IS_CUTSCENE_SKIP_BUTTON_JUST_PRESSED()
|
|
AND GET_GAME_TIMER() >= iAllowSkipCutsceneTime + 1000
|
|
DO_SCREEN_FADE_OUT(DEFAULT_FADE_TIME)
|
|
WHILE NOT IS_SCREEN_FADED_OUT()
|
|
WAIT(0)
|
|
ENDWHILE
|
|
|
|
HANG_UP_AND_PUT_AWAY_PHONE()
|
|
KILL_FACE_TO_FACE_CONVERSATION_DO_NOT_FINISH_LAST_LINE()
|
|
bSkippedCutscene = TRUE
|
|
cutsceneStage = H_CUT_STAGE_CLEANUP
|
|
ENDIF
|
|
ENDPROC
|
|
|
|
/*
|
|
// into van cutscene
|
|
PROC DO_INTO_VAN_CUTSCENE()
|
|
SWITCH cutsceneStage
|
|
CASE H_CUT_STAGE_INIT
|
|
//SET_MISSION_CUTSCENE(TRUE)
|
|
iHoodCutsceneTime = GET_GAME_TIMER()
|
|
|
|
IF NOT IS_PED_INJURED(PLAYER_PED_ID())
|
|
TASK_CLEAR_LOOK_AT(PLAYER_PED_ID())
|
|
REGISTER_ENTITY_FOR_CUTSCENE(PLAYER_PED_ID(), "Franklin", CU_ANIMATE_EXISTING_SCRIPT_ENTITY)
|
|
ENDIF
|
|
|
|
IF NOT IS_PED_INJURED(lamarPed)
|
|
TASK_CLEAR_LOOK_AT(lamarPed)
|
|
IF IS_VEHICLE_DRIVEABLE(hoodVehicle[HV_FRANKLIN_VAN])
|
|
SET_ENTITY_NO_COLLISION_ENTITY(lamarPed, hoodVehicle[HV_FRANKLIN_VAN], TRUE)
|
|
ENDIF
|
|
REGISTER_ENTITY_FOR_CUTSCENE(lamarPed, "Lamar", CU_ANIMATE_EXISTING_SCRIPT_ENTITY)
|
|
ENDIF
|
|
|
|
IF NOT IS_PED_INJURED(chopPed)
|
|
DETACH_ENTITY(chopPed)
|
|
IF IS_VEHICLE_DRIVEABLE(hoodVehicle[HV_FRANKLIN_VAN])
|
|
SET_ENTITY_NO_COLLISION_ENTITY(chopPed, hoodVehicle[HV_FRANKLIN_VAN], TRUE)
|
|
ENDIF
|
|
REGISTER_ENTITY_FOR_CUTSCENE(chopPed, "Chop", CU_ANIMATE_EXISTING_SCRIPT_ENTITY)
|
|
ENDIF
|
|
|
|
IF IS_VEHICLE_DRIVEABLE(hoodVehicle[HV_FRANKLIN_VAN])
|
|
FREEZE_ENTITY_POSITION(hoodVehicle[HV_FRANKLIN_VAN], FALSE)
|
|
REGISTER_ENTITY_FOR_CUTSCENE(hoodVehicle[HV_FRANKLIN_VAN], "Kidnapping_van", CU_ANIMATE_EXISTING_SCRIPT_ENTITY)
|
|
ENDIF
|
|
|
|
START_CUTSCENE()
|
|
SET_CUTSCENE_FADE_VALUES(FALSE, FALSE, FALSE, FALSE)
|
|
cutsceneStage = H_CUT_STAGE_RUNNING
|
|
BREAK
|
|
|
|
CASE H_CUT_STAGE_RUNNING
|
|
// clear the area
|
|
IF NOT bClearedForCutscene
|
|
IF IS_CUTSCENE_PLAYING()
|
|
SET_MISSION_MOCAP_CUTSCENE()
|
|
CLEAR_AREA(<<-76.63, -1456.25, 31.05>>, 6.0, TRUE)
|
|
|
|
bClearedForCutscene = TRUE
|
|
ENDIF
|
|
ENDIF
|
|
|
|
// exit state for van
|
|
IF CAN_SET_EXIT_STATE_FOR_REGISTERED_ENTITY("Kidnapping_van")
|
|
IF IS_VEHICLE_DRIVEABLE(hoodVehicle[HV_FRANKLIN_VAN])
|
|
SHUT_ALL_VAN_DOORS()
|
|
SET_VEHICLE_ON_GROUND_PROPERLY(hoodVehicle[HV_FRANKLIN_VAN])
|
|
SET_VEHICLE_IS_CONSIDERED_BY_PLAYER(hoodVehicle[HV_FRANKLIN_VAN], TRUE)
|
|
ENDIF
|
|
ENDIF
|
|
|
|
// exit state for lamar
|
|
IF CAN_SET_EXIT_STATE_FOR_REGISTERED_ENTITY("Lamar")
|
|
IF NOT IS_PED_INJURED(lamarPed)
|
|
IF NOT IS_PED_IN_VEHICLE(lamarPed, hoodVehicle[HV_FRANKLIN_VAN])
|
|
SET_PED_INTO_VEHICLE(lamarPed, hoodVehicle[HV_FRANKLIN_VAN], VS_FRONT_RIGHT)
|
|
FORCE_PED_AI_AND_ANIMATION_UPDATE(lamarPed)
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
|
|
// exit state for chop
|
|
IF CAN_SET_EXIT_STATE_FOR_REGISTERED_ENTITY("Chop")
|
|
SET_CHOP_INTO_VAN(chopPed, hoodVehicle[HV_FRANKLIN_VAN], chopLeanInVanState, fCachedVanSpeed)
|
|
ENDIF
|
|
|
|
// exit state for franklin
|
|
IF CAN_SET_EXIT_STATE_FOR_REGISTERED_ENTITY("Franklin")
|
|
IF NOT IS_PED_INJURED(PLAYER_PED_ID())
|
|
IF NOT IS_PED_IN_VEHICLE(PLAYER_PED_ID(), hoodVehicle[HV_FRANKLIN_VAN])
|
|
SET_PED_INTO_VEHICLE(PLAYER_PED_ID(), hoodVehicle[HV_FRANKLIN_VAN], VS_DRIVER)
|
|
FORCE_PED_AI_AND_ANIMATION_UPDATE(PLAYER_PED_ID())
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
|
|
// exit state for camera
|
|
IF CAN_SET_EXIT_STATE_FOR_CAMERA()
|
|
SET_ALL_RANDOM_PEDS_FLEE(PLAYER_ID(), FALSE)
|
|
|
|
bDoneBanter = FALSE
|
|
bSavedBanter = FALSE
|
|
bShownGodText = FALSE
|
|
bDoneLamarIntoVan = TRUE
|
|
iNextChopSoundTime = GET_GAME_TIMER() + GET_RANDOM_INT_IN_RANGE(2000, 3000)
|
|
iGetInTextStage = 2
|
|
SET_WANTED_LEVEL_MULTIPLIER(1.0)
|
|
|
|
SET_MISSION_CUTSCENE(FALSE)
|
|
ENDIF
|
|
|
|
|
|
#IF IS_DEBUG_BUILD
|
|
DEBUG_SKIP_MOCAP()
|
|
#ENDIF
|
|
BREAK
|
|
|
|
CASE H_CUT_STAGE_CLEANUP
|
|
BREAK
|
|
ENDSWITCH
|
|
ENDPROC
|
|
*/
|
|
|
|
PROC SET_FRANKLIN_SPRINT_TO_VAN(BOOL bReposition)
|
|
IF bReposition
|
|
SET_ENTITY_COORDS(PLAYER_PED_ID(), GET_HOOD_VECTOR(HVEC_FRANKLIN_ALLEY_INIT))
|
|
SET_ENTITY_HEADING(PLAYER_PED_ID(), FRANKLIN_ALLEY_INIT_ROT)
|
|
ENDIF
|
|
|
|
//TASK_GO_STRAIGHT_TO_COORD(PLAYER_PED_ID(), <<368.58, 344.62, 102.09>>, PEDMOVE_SPRINT)
|
|
|
|
IF GET_FOLLOW_PED_CAM_VIEW_MODE() <> CAM_VIEW_MODE_FIRST_PERSON
|
|
FORCE_PED_MOTION_STATE(PLAYER_PED_ID(), MS_ON_FOOT_SPRINT, bReposition, FAUS_CUTSCENE_EXIT)
|
|
SET_PED_MIN_MOVE_BLEND_RATIO(PLAYER_PED_ID(), PEDMOVE_SPRINT)
|
|
ELSE
|
|
FORCE_PED_MOTION_STATE(PLAYER_PED_ID(), MS_AIMING, bReposition, FAUS_CUTSCENE_EXIT)
|
|
SIMULATE_PLAYER_INPUT_GAIT(PLAYER_ID(), PEDMOVE_SPRINT, 2000)
|
|
ENDIF
|
|
ENDPROC
|
|
|
|
FUNC BOOL IS_PLAYER_AT_VAN()
|
|
RETURN IS_ENTITY_IN_ANGLED_AREA(PLAYER_PED_ID(), <<-81.93492, -1453.06018, 30.99545>>, <<-73.88771, -1467.59851, 34.96272>>, 10.5)
|
|
ENDFUNC
|
|
|
|
// bad guy escapes cutscene
|
|
PROC DO_BAD_GUY_ESCAPE_CUTSCENE()
|
|
SET_ALL_RANDOM_PEDS_FLEE_THIS_FRAME(PLAYER_ID())
|
|
SET_VEHICLE_DENSITY_MULTIPLIER_THIS_FRAME(0.0)
|
|
SET_PED_DENSITY_MULTIPLIER_THIS_FRAME(0.0)
|
|
SET_PARKED_VEHICLE_DENSITY_MULTIPLIER_THIS_FRAME(0.0)
|
|
|
|
SWITCH cutsceneStage
|
|
CASE H_CUT_STAGE_INIT
|
|
//SET_MISSION_CUTSCENE(TRUE)
|
|
iHoodCutsceneTime = GET_GAME_TIMER()
|
|
|
|
// clear the area
|
|
IF NOT IS_PED_INJURED(PLAYER_PED_ID())
|
|
SET_PED_STEALTH_MOVEMENT(PLAYER_PED_ID(), FALSE)
|
|
REGISTER_ENTITY_FOR_CUTSCENE(PLAYER_PED_ID(), "Franklin", CU_ANIMATE_EXISTING_SCRIPT_ENTITY)
|
|
ENDIF
|
|
|
|
IF NOT IS_PED_INJURED(lamarPed)
|
|
REGISTER_ENTITY_FOR_CUTSCENE(lamarPed, "Lamar", CU_ANIMATE_EXISTING_SCRIPT_ENTITY)
|
|
SET_BLOCKING_OF_NON_TEMPORARY_EVENTS(lamarPed, TRUE)
|
|
ENDIF
|
|
|
|
IF NOT IS_PED_INJURED(runnerChaseProperties.ped)
|
|
TASK_CLEAR_LOOK_AT(runnerChaseProperties.ped)
|
|
REGISTER_ENTITY_FOR_CUTSCENE(runnerChaseProperties.ped, "Ballas_OG", CU_ANIMATE_EXISTING_SCRIPT_ENTITY)
|
|
ENDIF
|
|
|
|
IF NOT IS_PED_INJURED(girlPed)
|
|
REGISTER_ENTITY_FOR_CUTSCENE(girlPed, "Hoodrat_girl", CU_ANIMATE_EXISTING_SCRIPT_ENTITY)
|
|
ENDIF
|
|
|
|
IF IS_VEHICLE_DRIVEABLE(hoodVehicle[HV_BAD_GUY_BIKE])
|
|
IF IS_PLAYBACK_GOING_ON_FOR_VEHICLE(hoodVehicle[HV_BAD_GUY_BIKE])
|
|
STOP_PLAYBACK_RECORDED_VEHICLE(hoodVehicle[HV_BAD_GUY_BIKE])
|
|
ENDIF
|
|
REGISTER_ENTITY_FOR_CUTSCENE(hoodVehicle[HV_BAD_GUY_BIKE], "BallasOG_Bike", CU_ANIMATE_EXISTING_SCRIPT_ENTITY)
|
|
ENDIF
|
|
|
|
START_CUTSCENE()
|
|
|
|
REPLAY_START_EVENT(REPLAY_IMPORTANCE_HIGHEST)
|
|
|
|
SET_CUTSCENE_FADE_VALUES(FALSE, FALSE, FALSE, FALSE)
|
|
cutsceneStage = H_CUT_STAGE_RUNNING
|
|
BREAK
|
|
|
|
CASE H_CUT_STAGE_RUNNING
|
|
// clear the area
|
|
IF NOT bClearedForCutscene
|
|
IF IS_CUTSCENE_PLAYING()
|
|
SET_MISSION_MOCAP_CUTSCENE()
|
|
|
|
PED_COMP_NAME_ENUM eHeadProp
|
|
eHeadProp = GET_PED_COMP_ITEM_CURRENT_SP(PLAYER_PED_ID(), COMP_TYPE_PROPS, ENUM_TO_INT(ANCHOR_HEAD))
|
|
IF IS_ITEM_A_MASK(GET_ENTITY_MODEL(PLAYER_PED_ID()), COMP_TYPE_PROPS, eHeadProp)
|
|
SET_PED_COMP_ITEM_CURRENT_SP(PLAYER_PED_ID(),COMP_TYPE_PROPS, PROPS_HEAD_NONE, FALSE)
|
|
ENDIF
|
|
|
|
IF IS_VEHICLE_DRIVEABLE(hoodVehicle[HV_FRANKLIN_VAN])
|
|
DETACH_VEHICLE_FROM_ANY_TOW_TRUCK(hoodVehicle[HV_FRANKLIN_VAN])
|
|
ENDIF
|
|
|
|
CLEAR_AREA(<<369.24, 344.64, 102.08>>, 27.0, TRUE)
|
|
CLEAR_AREA(<<363.57892, 322.47748, 102.70776>>, 16.0, TRUE)
|
|
CLEAR_AREA_OF_VEHICLES(<<340.95465, 247.10138, 102.75685>>, 92.0, FALSE)
|
|
CLEAR_AREA_OF_PEDS(<<364.94711, 313.03796, 102.63920>>, 114.0, TRUE)
|
|
CLEAR_AREA_OF_PROJECTILES(<<370.34372, 343.42828, 102.09016>>, 52)
|
|
STOP_FIRE_IN_RANGE(<<370.34372, 343.42828, 102.09016>>, 52)
|
|
REMOVE_PARTICLE_FX_IN_RANGE(<<370.34372, 343.42828, 102.09016>>, 52)
|
|
|
|
STOP_HOOD_AUDIO_SCENE(HOOD_AUDIO_SCENE_DRIVE_TO_VINEWOOD)
|
|
|
|
INT i
|
|
REPEAT NUMBER_BLOCKING_VEHICLES i
|
|
IF DOES_ENTITY_EXIST(blockingVehicle[i])
|
|
DELETE_VEHICLE(blockingVehicle[i])
|
|
ENDIF
|
|
ENDREPEAT
|
|
CLEAR_MODEL_REQUEST(ENUM_TO_INT(HM_BLOCKING_TRUCK))
|
|
CLEAR_MODEL_REQUEST(ENUM_TO_INT(HM_BLOCKING_CAR))
|
|
|
|
IF IS_VEHICLE_DRIVEABLE(hoodVehicle[HV_FRANKLIN_VAN])
|
|
//CLOSE_ALL_VAN_DOORS()
|
|
DETACH_VEHICLE_FROM_ANY_TOW_TRUCK(hoodVehicle[HV_FRANKLIN_VAN])
|
|
SET_VEH_RADIO_STATION(hoodVehicle[HV_FRANKLIN_VAN], "OFF")
|
|
SHUT_ALL_VAN_DOORS()
|
|
FREEZE_ENTITY_POSITION(hoodVehicle[HV_FRANKLIN_VAN], FALSE)
|
|
SET_ENTITY_COORDS(hoodVehicle[HV_FRANKLIN_VAN], GET_HOOD_VECTOR(HVEC_VAN_CHASE_INIT))
|
|
SET_ENTITY_HEADING(hoodVehicle[HV_FRANKLIN_VAN], VAN_CHASE_INIT_ROT)
|
|
SET_VEHICLE_ON_GROUND_PROPERLY(hoodVehicle[HV_FRANKLIN_VAN])
|
|
SET_VEHICLE_ENGINE_ON(hoodVehicle[HV_FRANKLIN_VAN], TRUE, TRUE)
|
|
STOP_VEHICLE_FIRE(hoodVehicle[HV_FRANKLIN_VAN])
|
|
ENDIF
|
|
|
|
IF bForcePassOnShitskip
|
|
DO_SCREEN_FADE_IN(DEFAULT_FADE_TIME)
|
|
bForcePassOnShitskip = FALSE
|
|
ELSE
|
|
IF IS_SCREEN_FADED_OUT()
|
|
DO_SCREEN_FADE_IN(DEFAULT_FADE_TIME)
|
|
ENDIF
|
|
ENDIF
|
|
|
|
bClearedForCutscene = TRUE
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF GET_CUTSCENE_TIME() >= 45231
|
|
DISABLE_CONTROL_ACTION(FRONTEND_CONTROL, INPUT_SKIP_CUTSCENE)
|
|
ENDIF
|
|
|
|
IF NOT bDoneLamarPullGunCue
|
|
IF GET_CUTSCENE_TIME() >= 37400
|
|
bDoneLamarPullGunCue = TRIGGER_MISSION_MUSIC_EVENT("FRA0_MISSION_START")
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF NOT bDoneBikeSpeedOffCue
|
|
IF GET_CUTSCENE_TIME() >= 42200
|
|
bDoneBikeSpeedOffCue = TRIGGER_MISSION_MUSIC_EVENT("FRA0_SPEED_OFF")
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF CAN_SET_EXIT_STATE_FOR_REGISTERED_ENTITY("Lamar", IG_LAMARDAVIS)
|
|
SET_LAMAR_SPRINT_TO_VAN(FALSE)
|
|
ENDIF
|
|
|
|
IF CAN_SET_EXIT_STATE_FOR_REGISTERED_ENTITY("BallasOG_Bike")
|
|
SET_BIKE_TO_ESCAPE()
|
|
ENDIF
|
|
|
|
IF CAN_SET_EXIT_STATE_FOR_REGISTERED_ENTITY("Ballas_OG")
|
|
SET_BALLA_ON_BIKE()
|
|
ENDIF
|
|
|
|
IF WAS_CUTSCENE_SKIPPED()
|
|
WHILE NOT IS_SCREEN_FADED_OUT()
|
|
WAIT(0)
|
|
ENDWHILE
|
|
WHILE NOT HAS_CUTSCENE_FINISHED()
|
|
WAIT(0)
|
|
ENDWHILE
|
|
|
|
SET_BALLA_ON_BIKE()
|
|
|
|
SET_ENTITY_COORDS(PLAYER_PED_ID(), <<371.09839, 359.33514, 101.60266>>)
|
|
SET_ENTITY_HEADING(PLAYER_PED_ID(), 170)
|
|
LOAD_SCENE(<<371.09839, 359.33514, 101.60266>>)
|
|
WAIT(0)
|
|
REPLAY_STOP_EVENT()
|
|
SET_LAMAR_SPRINT_TO_VAN(TRUE)
|
|
|
|
SET_BIKE_TO_ESCAPE()
|
|
SET_GAMEPLAY_CAM_RELATIVE_HEADING()
|
|
SET_GAMEPLAY_CAM_RELATIVE_PITCH()
|
|
|
|
IF NOT bDoneLamarPullGunCue
|
|
bDoneLamarPullGunCue = TRIGGER_MISSION_MUSIC_EVENT("FRA0_CHASE_RESTART")
|
|
ENDIF
|
|
SET_MISSION_STAGE(STAGE_VAN_CHASE)
|
|
SET_FRANKLIN_SPRINT_TO_VAN(TRUE)
|
|
SET_MISSION_CUTSCENE(FALSE)
|
|
ELSE
|
|
IF HAS_CUTSCENE_FINISHED()
|
|
|
|
REPLAY_STOP_EVENT()
|
|
|
|
SET_MISSION_CUTSCENE(FALSE, TRUE, -1, FALSE)
|
|
SET_MISSION_STAGE(STAGE_VAN_CHASE)
|
|
ENDIF
|
|
|
|
IF CAN_SET_EXIT_STATE_FOR_REGISTERED_ENTITY("Franklin")
|
|
SET_FRANKLIN_SPRINT_TO_VAN(FALSE)
|
|
ENDIF
|
|
IF GET_FOLLOW_PED_CAM_VIEW_MODE() <> CAM_VIEW_MODE_FIRST_PERSON
|
|
SET_PED_MIN_MOVE_BLEND_RATIO(PLAYER_PED_ID(), PEDMOVE_SPRINT)
|
|
ELSE
|
|
SIMULATE_PLAYER_INPUT_GAIT(PLAYER_ID(), PEDMOVE_SPRINT, 2000)
|
|
ENDIF
|
|
|
|
ENDIF
|
|
|
|
#IF IS_DEBUG_BUILD
|
|
DEBUG_SKIP_MOCAP()
|
|
#ENDIF
|
|
BREAK
|
|
|
|
CASE H_CUT_STAGE_CLEANUP
|
|
BREAK
|
|
ENDSWITCH
|
|
ENDPROC
|
|
|
|
CONST_FLOAT LAMAR_PAUSE_DIST 3.6//7.0
|
|
CONST_FLOAT LAMAR_UNPAUSE_DIST 3.2//4.1//3.2
|
|
|
|
// get to the bad guy's hangout
|
|
PROC DO_STAGE_GET_TO_BAD_GUY()
|
|
// help to download app
|
|
IF NOT bForcePassOnShitskip
|
|
DO_FIRST_DOWNLOAD_HELP()
|
|
ENDIF
|
|
|
|
IF NOT bRunningCutscene
|
|
DISABLE_CONTROL_ACTION(FRONTEND_CONTROL, INPUT_SKIP_CUTSCENE)
|
|
|
|
// create stuff post intro
|
|
SWITCH createPostIntroStage
|
|
CASE CREATE_POST_INTRO_STAGE_NOT_STARTED
|
|
ADD_MODEL_REQUEST(ENUM_TO_INT(HM_FRANKLIN_VAN))
|
|
createPostIntroStage = CREATE_POST_INTRO_STAGE_WAITING
|
|
BREAK
|
|
CASE CREATE_POST_INTRO_STAGE_WAITING
|
|
IF HAVE_ALL_MODEL_REQUESTS_SUCCEEDED()
|
|
HOOD_CREATE_VEHICLE(HV_FRANKLIN_VAN, GET_HOOD_VECTOR(HVEC_FRANKLIN_VAN_INIT), FRANKLIN_VAN_INIT_ROT)
|
|
SET_VEHICLE_IS_CONSIDERED_BY_PLAYER(hoodVehicle[HV_FRANKLIN_VAN], FALSE)
|
|
createPostIntroStage = CREATE_POST_INTRO_STAGE_DONE
|
|
iCreateVanTime = GET_GAME_TIMER()
|
|
ENDIF
|
|
BREAK
|
|
CASE CREATE_POST_INTRO_STAGE_DONE
|
|
IF NOT bFrozenVan
|
|
IF NOT bDoneLamarIntoVan
|
|
IF GET_GAME_TIMER() >= iCreateVanTime + 2000
|
|
FREEZE_ENTITY_POSITION(hoodVehicle[HV_FRANKLIN_VAN], TRUE)
|
|
bFrozenVan = TRUE
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
BREAK
|
|
ENDSWITCH
|
|
|
|
IF bForcePassOnShitskip
|
|
IF NOT bWarpedVanToAlley
|
|
IF IS_VEHICLE_DRIVEABLE(hoodVehicle[HV_FRANKLIN_VAN])
|
|
IF NOT IS_PED_IN_VEHICLE(PLAYER_PED_ID(), hoodVehicle[HV_FRANKLIN_VAN])
|
|
SET_ENTITY_COORDS(hoodVehicle[HV_FRANKLIN_VAN], GET_HOOD_VECTOR(HVEC_BAD_GUY_HANGOUT))
|
|
SET_VEHICLE_IS_CONSIDERED_BY_PLAYER(hoodVehicle[HV_FRANKLIN_VAN], TRUE)
|
|
SET_PED_INTO_VEHICLE(PLAYER_PED_ID(), hoodVehicle[HV_FRANKLIN_VAN])
|
|
SET_PED_INTO_VEHICLE(lamarPed, hoodVehicle[HV_FRANKLIN_VAN], VS_FRONT_RIGHT)
|
|
SET_CHOP_INTO_VAN(chopPed, hoodVehicle[HV_FRANKLIN_VAN], chopLeanInVanState, fCachedVanSpeed, FALSE, TRUE, TRUE)
|
|
SET_ENTITY_PROOFS(chopPed, FALSE, TRUE, TRUE, FALSE, FALSE, FALSE, FALSE, TRUE)
|
|
SET_PED_CAN_RAGDOLL(chopPed, FALSE)
|
|
TASK_CLEAR_LOOK_AT(lamarPed)
|
|
SET_ENTITY_NO_COLLISION_ENTITY(lamarPed, hoodVehicle[HV_FRANKLIN_VAN], TRUE)
|
|
bDoneFranklinIntoVanSpeech = TRUE
|
|
|
|
FREEZE_ENTITY_POSITION(hoodVehicle[HV_FRANKLIN_VAN], FALSE)
|
|
// LOAD_SCENE(GET_HOOD_VECTOR(HVEC_BAD_GUY_HANGOUT))
|
|
WAIT(0)
|
|
chopIntoVanState = CHOP_INTO_VAN_STATE_DONE
|
|
bDoneLamarIntoVan = TRUE
|
|
bCutsceneWaitStarted = TRUE
|
|
bWarpedVanToAlley = TRUE
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
|
|
SWITCH createBadGuyStage
|
|
CASE CREATE_BAD_GUY_STAGE_NOT_STARTED
|
|
IF IS_ENTITY_AT_COORD(PLAYER_PED_ID(), GET_HOOD_VECTOR(HVEC_GIRL_INIT), <<700,700,700>>, FALSE, FALSE)
|
|
ADD_MODEL_REQUEST(ENUM_TO_INT(HM_BAD_GUY))
|
|
iCreateBadGuyTime = GET_GAME_TIMER() + 2000
|
|
createBadGuyStage = CREATE_BAD_GUY_STAGE_WAITING1
|
|
ENDIF
|
|
BREAK
|
|
CASE CREATE_BAD_GUY_STAGE_WAITING1
|
|
IF GET_GAME_TIMER() >= iCreateBadGuyTime
|
|
AND IS_ENTITY_AT_COORD(PLAYER_PED_ID(), GET_HOOD_VECTOR(HVEC_GIRL_INIT), <<600,600,600>>, FALSE, FALSE)
|
|
ADD_MODEL_REQUEST(ENUM_TO_INT(HM_GIRL))
|
|
iCreateBadGuyTime = GET_GAME_TIMER() + 2000
|
|
createBadGuyStage = CREATE_BAD_GUY_STAGE_WAITING2
|
|
ENDIF
|
|
BREAK
|
|
CASE CREATE_BAD_GUY_STAGE_WAITING2
|
|
IF GET_GAME_TIMER() >= iCreateBadGuyTime
|
|
AND IS_ENTITY_AT_COORD(PLAYER_PED_ID(), GET_HOOD_VECTOR(HVEC_GIRL_INIT), <<500,500,500>>, FALSE, FALSE)
|
|
ADD_MODEL_REQUEST(ENUM_TO_INT(HM_BIKE))
|
|
createBadGuyStage = CREATE_BAD_GUY_STAGE_WAITING3
|
|
ENDIF
|
|
BREAK
|
|
CASE CREATE_BAD_GUY_STAGE_WAITING3
|
|
IF HAVE_ALL_MODEL_REQUESTS_SUCCEEDED()
|
|
// bad guy and girl
|
|
CREATE_BAD_GUY_FOR_STAGE(STAGE_GET_TO_BAD_GUY)
|
|
createBadGuyStage = CREATE_BAD_GUY_STAGE_CREATE_GIRL
|
|
ENDIF
|
|
BREAK
|
|
|
|
CASE CREATE_BAD_GUY_STAGE_CREATE_GIRL
|
|
CREATE_GIRL_FOR_STAGE(STAGE_GET_TO_BAD_GUY)
|
|
createBadGuyStage = CREATE_BAD_GUY_STAGE_DONE
|
|
BREAK
|
|
CASE CREATE_BAD_GUY_STAGE_DONE
|
|
// handle girl
|
|
IF missionFailState = MISSION_FAIL_STATE_NOT_FAILED
|
|
IF NOT IS_PED_INJURED(girlPed)
|
|
AND NOT IS_PED_INJURED(runnerChaseProperties.ped)
|
|
IF GET_SCRIPT_TASK_STATUS(girlPed, SCRIPT_TASK_CHAT_TO_PED) = FINISHED_TASK
|
|
TASK_CHAT_TO_PED(girlPed, runnerChaseProperties.ped, CF_IS_INITIATOR, <<0,0,0>>, 0, 0)
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
BREAK
|
|
ENDSWITCH
|
|
|
|
IF NOT bForcePassOnShitskip
|
|
SWITCH createBlockingVehiclesStage
|
|
CASE CREATE_BLOCKING_VEHICLES_STAGE_NOT_STARTED
|
|
IF IS_ENTITY_AT_COORD(PLAYER_PED_ID(), <<335.21927, 338.35443, 104.20057>>, <<900,900,900>>, FALSE, FALSE)
|
|
ADD_MODEL_REQUEST(ENUM_TO_INT(HM_BLOCKING_TRUCK))
|
|
iCreateBlockingVehiclesTime = GET_GAME_TIMER() + 2000
|
|
createBlockingVehiclesStage = CREATE_BLOCKING_VEHICLES_STAGE_WAITING1
|
|
ENDIF
|
|
BREAK
|
|
CASE CREATE_BLOCKING_VEHICLES_STAGE_WAITING1
|
|
IF GET_GAME_TIMER() >= iCreateBlockingVehiclesTime
|
|
AND IS_ENTITY_AT_COORD(PLAYER_PED_ID(), <<335.21927, 338.35443, 104.20057>>, <<800,800,800>>, FALSE, FALSE)
|
|
ADD_MODEL_REQUEST(ENUM_TO_INT(HM_BLOCKING_CAR))
|
|
createBlockingVehiclesStage = CREATE_BLOCKING_VEHICLES_STAGE_WAITING2
|
|
ENDIF
|
|
BREAK
|
|
CASE CREATE_BLOCKING_VEHICLES_STAGE_WAITING2
|
|
IF HAVE_ALL_MODEL_REQUESTS_SUCCEEDED()
|
|
CREATE_BLOCKING_VEHICLES()
|
|
createBlockingVehiclesStage = CREATE_BLOCKING_VEHICLES_STAGE_DONE
|
|
ENDIF
|
|
BREAK
|
|
CASE CREATE_BLOCKING_VEHICLES_STAGE_DONE
|
|
|
|
BREAK
|
|
ENDSWITCH
|
|
ENDIF
|
|
|
|
// can't move van til chop in
|
|
IF IS_VEHICLE_DRIVEABLE(hoodVehicle[HV_FRANKLIN_VAN])
|
|
IF IS_PED_IN_VEHICLE(PLAYER_PED_ID(), hoodVehicle[HV_FRANKLIN_VAN])
|
|
IF chopIntoVanState < CHOP_INTO_VAN_STATE_DONE
|
|
DISABLE_CONTROL_ACTION(PLAYER_CONTROL, INPUT_VEH_ACCELERATE)
|
|
DISABLE_CONTROL_ACTION(PLAYER_CONTROL, INPUT_VEH_BRAKE)
|
|
DISABLE_CONTROL_ACTION(PLAYER_CONTROL, INPUT_VEH_HANDBRAKE)
|
|
DISABLE_CONTROL_ACTION(PLAYER_CONTROL, INPUT_VEH_DUCK)
|
|
DISABLE_CONTROL_ACTION(PLAYER_CONTROL, INPUT_VEH_MOVE_LR)
|
|
DISABLE_CONTROL_ACTION(PLAYER_CONTROL, INPUT_VEH_MOVE_UD)
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF NOT bForcePassOnShitskip
|
|
// chop bark at start
|
|
IF NOT IS_PED_INJURED(chopPed)
|
|
IF NOT bStoppedChopExcitement
|
|
IF GET_GAME_TIMER() >= iNextChopExcitementTime
|
|
STOP_PED_SPEAKING(chopPed, FALSE)
|
|
PLAY_ANIMAL_VOCALIZATION(chopPed, AUD_ANIMAL_DOG_ROTTWEILER, "BARK")
|
|
STOP_PED_SPEAKING(chopPed, TRUE)
|
|
iNextChopExcitementTime = GET_GAME_TIMER() + GET_RANDOM_INT_IN_RANGE(300, 800)
|
|
ENDIF
|
|
|
|
IF GET_GAME_TIMER() >= iStopChopExcitementTime
|
|
STOP_PED_SPEAKING(chopPed, FALSE)
|
|
bStoppedChopExcitement = TRUE
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF NOT bForcePassOnShitSkip
|
|
// check to see if spooked bad guy
|
|
BOOL bBadGuySpooked = FALSE
|
|
IF NOT IS_PED_INJURED(runnerChaseProperties.ped)
|
|
IF HAS_ENTITY_BEEN_DAMAGED_BY_ENTITY(runnerChaseProperties.ped, PLAYER_PED_ID())
|
|
OR GET_DISTANCE_BETWEEN_ENTITIES(runnerChaseProperties.ped, PLAYER_PED_ID(), FALSE) < 5.0
|
|
bBadGuySpooked = TRUE
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF DOES_ENTITY_EXIST(girlPed)
|
|
IF NOT IS_PED_INJURED(girlPed)
|
|
IF HAS_ENTITY_BEEN_DAMAGED_BY_ENTITY(girlPed, PLAYER_PED_ID())
|
|
bBadGuySpooked = TRUE
|
|
ENDIF
|
|
ELSE
|
|
bBadGuySpooked = TRUE
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF IS_ENTITY_IN_ANGLED_AREA(PLAYER_PED_ID(), <<385.480, 354.650, 101.400>>, <<386.540, 360.310, 104.710>>, 23.5) //13.4
|
|
OR IS_PED_SHOOTING_IN_AREA(PLAYER_PED_ID(), <<361.21, 334.32, 95.0>>, <<435.91, 351.51, 113.0>>, FALSE)
|
|
OR IS_SNIPER_BULLET_IN_AREA(GET_HOOD_VECTOR(HVEC_GIRL_INIT) - <<5,5,5>>, GET_HOOD_VECTOR(HVEC_GIRL_INIT) + <<5,5,5>>)
|
|
OR IS_BULLET_IN_AREA(GET_HOOD_VECTOR(HVEC_GIRL_INIT), 5.0)
|
|
OR GET_NUMBER_OF_FIRES_IN_RANGE(GET_HOOD_VECTOR(HVEC_GIRL_INIT), 18.8) > 0
|
|
bBadGuySpooked = TRUE
|
|
ENDIF
|
|
|
|
IF bBadGuySpooked
|
|
IF NOT bDoneBadGuySpookedReact
|
|
IF NOT IS_PED_INJURED(runnerChaseProperties.ped)
|
|
GIVE_WEAPON_TO_PED(runnerChaseProperties.ped, GET_HOOD_WEAPON_TYPE(H_WEAPON_PISTOL), INFINITE_AMMO)
|
|
CLEAR_SEQUENCE_TASK(sequence)
|
|
OPEN_SEQUENCE_TASK(sequence)
|
|
TASK_LEAVE_ANY_VEHICLE(NULL)
|
|
TASK_COMBAT_PED(NULL, PLAYER_PED_ID())
|
|
CLOSE_SEQUENCE_TASK(sequence)
|
|
TASK_PERFORM_SEQUENCE(runnerChaseProperties.ped, sequence)
|
|
//SET_PED_CAN_BE_TARGETTED(runnerChaseProperties.ped, TRUE)
|
|
ENDIF
|
|
IF NOT IS_PED_INJURED(girlPed)
|
|
TASK_COWER(girlPed, -1)
|
|
ENDIF
|
|
bDoneBadGuySpookedReact = TRUE
|
|
ENDIF
|
|
MISSION_FAILED(FAIL_SPOOKED_BAD_GUY)
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF bDoneLamarIntoVan
|
|
|
|
IF createBadGuyStage = CREATE_BAD_GUY_STAGE_DONE
|
|
HANDLE_STREAMING_MOCAP("fra_0_mcs_1", GET_HOOD_VECTOR(HVEC_BAD_GUY_HANGOUT), DEFAULT_CUTSCENE_LOAD_DIST-5, DEFAULT_CUTSCENE_UNLOAD_DIST-10)
|
|
ENDIF
|
|
|
|
IF GET_PLAYER_WANTED_LEVEL(PLAYER_ID()) > 0
|
|
//IF NOT IS_PED_IN_VEHICLE(PLAYER_PED_ID(), hoodVehicle[HV_FRANKLIN_VAN])
|
|
// IF NOT IS_PED_HEADTRACKING_ENTITY(lamarPed, PLAYER_PED_ID())
|
|
// TASK_LOOK_AT_ENTITY(lamarPed, PLAYER_PED_ID(), -1, SLF_WHILE_NOT_IN_FOV)
|
|
// ENDIF
|
|
//ENDIF
|
|
|
|
IF IS_ENTITY_AT_ENTITY(PLAYER_PED_ID(), lamarPed, <<20,20,4>>)
|
|
IF NOT bDoneLoseWantedSpeech
|
|
bDoneLoseWantedSpeech = DO_MISSION_SPEECH("FC_WANTBEF")
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF CAN_REQUEST_ASSETS_FOR_CUTSCENE_ENTITY()
|
|
IF NOT IS_PED_INJURED(lamarPed)
|
|
SET_CUTSCENE_PED_COMPONENT_VARIATION_FROM_PED("Lamar", lamarPed)
|
|
ENDIF
|
|
IF NOT IS_PED_INJURED(runnerChaseProperties.ped)
|
|
SET_CUTSCENE_PED_COMPONENT_VARIATION_FROM_PED("Ballas_OG", runnerChaseProperties.ped)
|
|
SET_CUTSCENE_PED_PROP_VARIATION("Ballas_OG", ANCHOR_HEAD, 0, 0)
|
|
ENDIF
|
|
IF NOT IS_PED_INJURED(girlPed)
|
|
SET_CUTSCENE_PED_COMPONENT_VARIATION_FROM_PED("Hoodrat_girl", girlPed)
|
|
ENDIF
|
|
ENDIF
|
|
|
|
HANDLE_CHOP_LEAN_IN_VAN(chopPed, hoodVehicle[HV_FRANKLIN_VAN], chopLeanInVanState, fCachedVanSpeed, iNextChopAnimTime, iNextBarkTime)
|
|
|
|
// get to the alley
|
|
IF IS_VEHICLE_DRIVEABLE(hoodVehicle[HV_FRANKLIN_VAN])
|
|
AND NOT IS_PED_INJURED(lamarPed)
|
|
IF IS_PED_IN_VEHICLE(PLAYER_PED_ID(), hoodVehicle[HV_FRANKLIN_VAN])
|
|
AND IS_PED_IN_VEHICLE(lamarPed, hoodVehicle[HV_FRANKLIN_VAN])
|
|
IF NOT bForcePassOnShitskip
|
|
IF chopBehaviour = CHOP_BEHAVIOUR_BAD
|
|
DO_CHOP_AUDIO(CHOP_AUDIO_STATE_IN_VAN_AGITATED)
|
|
ELSE
|
|
DO_CHOP_AUDIO(CHOP_AUDIO_STATE_IN_VAN_PLACID)
|
|
ENDIF
|
|
ENDIF
|
|
|
|
INT iWantedLevel = GET_PLAYER_WANTED_LEVEL(PLAYER_ID())
|
|
IF iWantedLevel = 0
|
|
IF NOT bForcePassOnShitSkip
|
|
// do goto speech
|
|
IF NOT bDoneGotoSpeech
|
|
bDoneGotoSpeech = DO_MISSION_SPEECH("FKN0_GOVINE")
|
|
ELSE
|
|
// banter
|
|
IF bShownGodText
|
|
IF NOT bDoneHelloChopSpeech
|
|
IF iReplayAttempt % 2 = 0
|
|
bDoneHelloChopSpeech = DO_MISSION_SPEECH("FKN0_CHOP")
|
|
ELSE
|
|
bDoneHelloChopSpeech = TRUE
|
|
ENDIF
|
|
ELSE
|
|
IF NOT bDoneBanter
|
|
STRING sBanter
|
|
IF iReplayAttempt % 2 = 0
|
|
IF GET_MISSION_COMPLETE_STATE(SP_MISSION_ARMENIAN_3)
|
|
sBanter = "FKN0_WALK"
|
|
ELSE
|
|
sBanter = "FKN0_NOARM2"
|
|
ENDIF
|
|
ELSE
|
|
IF GET_MISSION_COMPLETE_STATE(SP_MISSION_ARMENIAN_3)
|
|
sBanter = "FKN0_B1AV1"
|
|
ELSE
|
|
sBanter = "FKN0_B1AV2"
|
|
ENDIF
|
|
ENDIF
|
|
bDoneBanter = DO_MISSION_SPEECH(sBanter, FALSE)
|
|
ELSE
|
|
IF bSavedBanter
|
|
IF NOT bTriggeredLamarDamageReaction
|
|
AND NOT bCutsceneWaitStarted
|
|
IF RESTORE_BANTER()
|
|
bSavedBanter = FALSE
|
|
ENDIF
|
|
ENDIF
|
|
ELSE
|
|
// we creeping... speech
|
|
IF NOT bDoneCreepSpeech
|
|
IF IS_ENTITY_AT_COORD(PLAYER_PED_ID(), <<368.27, 355.67, 101.96>>, <<15, 15, LOCATE_SIZE_HEIGHT>>)
|
|
IF NOT bKilledSpeechForArrive
|
|
KILL_ANY_CONVERSATION()
|
|
bKilledSpeechForArrive = TRUE
|
|
ELSE
|
|
bDoneCreepSpeech = DO_MISSION_SPEECH("FKN0_CREEP")
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF NOT bDoneChopBehaviourSpeech
|
|
OR NOT bDoneUphillSpeech
|
|
IF IS_ANY_CONVERSATION_ONGOING_OR_QUEUED()
|
|
iTriggerPostBanterSpeechTime = -1
|
|
ELSE
|
|
IF iTriggerPostBanterSpeechTime < 0
|
|
iTriggerPostBanterSpeechTime = GET_GAME_TIMER()
|
|
ELSE
|
|
IF GET_GAME_TIMER() >= iTriggerPostBanterSpeechTime + 3000
|
|
AND NOT bCutsceneWaitStarted
|
|
BOOL bTriggeredSomeSpeech
|
|
bTriggeredSomeSpeech = FALSE
|
|
|
|
IF NOT bDoneUphillSpeech
|
|
IF chopBehaviourSpeechState = CHOP_BEHAVIOUR_SPEECH_NOT_STARTED
|
|
OR chopBehaviourSpeechState = CHOP_BEHAVIOUR_SPEECH_DONE
|
|
VECTOR vVanRot
|
|
FLOAT fVanSpeed
|
|
vVanRot = GET_ENTITY_ROTATION(hoodVehicle[HV_FRANKLIN_VAN])
|
|
fVanSpeed = GET_ENTITY_SPEED(hoodVehicle[HV_FRANKLIN_VAN])
|
|
IF vVanRot.x >= 9
|
|
IF fVanSpeed <= 21.0
|
|
AND fVanSpeed >= 4.0
|
|
IF IS_VEHICLE_ON_ALL_WHEELS(hoodVehicle[HV_FRANKLIN_VAN])
|
|
IF DO_MISSION_SPEECH("FC_UPHILL")
|
|
bDoneUphillSpeech = TRUE
|
|
bTriggeredSomeSpeech = TRUE
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF NOT bTriggeredSomeSpeech
|
|
SWITCH chopBehaviourSpeechState
|
|
CASE CHOP_BEHAVIOUR_SPEECH_NOT_STARTED
|
|
SWITCH chopBehaviour
|
|
CASE CHOP_BEHAVIOUR_GOOD
|
|
chopBehaviourSpeechState = CHOP_BEHAVIOUR_SPEECH_SAY_GOOD
|
|
BREAK
|
|
CASE CHOP_BEHAVIOUR_BAD
|
|
chopBehaviourSpeechState = CHOP_BEHAVIOUR_SPEECH_BARK
|
|
iStopChopExcitementTime = GET_GAME_TIMER() + 6000
|
|
BREAK
|
|
CASE CHOP_BEHAVIOUR_MEDIUM
|
|
chopBehaviourSpeechState = CHOP_BEHAVIOUR_SPEECH_DONE
|
|
BREAK
|
|
ENDSWITCH
|
|
BREAK
|
|
|
|
CASE CHOP_BEHAVIOUR_SPEECH_SAY_GOOD
|
|
IF DO_MISSION_SPEECH("FC_CBEHAVE")
|
|
chopBehaviourSpeechState = CHOP_BEHAVIOUR_SPEECH_DONE
|
|
ENDIF
|
|
BREAK
|
|
|
|
CASE CHOP_BEHAVIOUR_SPEECH_BARK
|
|
IF GET_GAME_TIMER() >= iNextChopExcitementTime
|
|
STOP_PED_SPEAKING(chopPed, FALSE)
|
|
IF GET_RANDOM_INT_IN_RANGE(0,2) = 0
|
|
PLAY_ANIMAL_VOCALIZATION(chopPed, AUD_ANIMAL_DOG_ROTTWEILER, "BARK")
|
|
ELSE
|
|
PLAY_ANIMAL_VOCALIZATION(chopPed, AUD_ANIMAL_DOG_ROTTWEILER, "BARK_SEQ")
|
|
ENDIF
|
|
STOP_PED_SPEAKING(chopPed, TRUE)
|
|
iNextChopExcitementTime = GET_GAME_TIMER() + GET_RANDOM_INT_IN_RANGE(200, 1000)
|
|
ENDIF
|
|
|
|
IF GET_GAME_TIMER() >= iStopChopExcitementTime
|
|
STOP_PED_SPEAKING(chopPed, FALSE)
|
|
chopBehaviourSpeechState = CHOP_BEHAVIOUR_SPEECH_SAY_BAD
|
|
ENDIF
|
|
BREAK
|
|
|
|
CASE CHOP_BEHAVIOUR_SPEECH_SAY_BAD
|
|
IF DO_MISSION_SPEECH("FC_CMBEHAVE")
|
|
chopBehaviourSpeechState = CHOP_BEHAVIOUR_SPEECH_DONE
|
|
ENDIF
|
|
BREAK
|
|
ENDSWITCH
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF NOT bForcePassOnShitSkip
|
|
IF NOT bDoneArriveSpeech
|
|
IF IS_ENTITY_AT_COORD(PLAYER_PED_ID(), GET_HOOD_VECTOR(HVEC_BAD_GUY_HANGOUT), <<50, 50, 4>>)
|
|
IF NOT bKilledSpeechForArrive
|
|
KILL_ANY_CONVERSATION()
|
|
bKilledSpeechForArrive = TRUE
|
|
ELSE
|
|
IF iReplayAttempt % 2 = 0
|
|
bDoneArriveSpeech = DO_MISSION_SPEECH("FC_INALLEY")
|
|
IF bDoneArriveSpeech
|
|
REPLAY_RECORD_BACK_FOR_TIME(3.0, 3.0, REPLAY_IMPORTANCE_HIGH)
|
|
ENDIF
|
|
ELSE
|
|
bDoneArriveSpeech = DO_MISSION_SPEECH("FKN0_ALLEY")
|
|
IF bDoneArriveSpeech
|
|
REPLAY_RECORD_BACK_FOR_TIME(3.0, 3.0, REPLAY_IMPORTANCE_HIGH)
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
|
|
// handle getting to objective
|
|
IF NOT bCutsceneWaitStarted
|
|
IF iWantedLevel = 0
|
|
IF IS_ENTITY_AT_COORD(PLAYER_PED_ID(), GET_HOOD_VECTOR(HVEC_BAD_GUY_HANGOUT), <<5, 5, LOCATE_SIZE_HEIGHT>>, TRUE)
|
|
IF IS_PED_SITTING_IN_VEHICLE(PLAYER_PED_ID(), hoodVehicle[HV_FRANKLIN_VAN])
|
|
IF CAN_PLAYER_START_CUTSCENE()
|
|
PRINTSTRING("HIT BLIP - KILLING CONVERSATION") PRINTNL()
|
|
//KILL_ANY_CONVERSATION()
|
|
//SET_PLAYER_CONTROL(PLAYER_ID(), FALSE, SPC_LEAVE_CAMERA_CONTROL_ON)
|
|
|
|
//Activate multihead blinders early
|
|
SET_MULTIHEAD_SAFE(TRUE,FALSE)
|
|
|
|
REMOVE_ALL_BLIPS()
|
|
PREVENT_WANTED_LEVEL_FOR_CUTSCENE()
|
|
iCutsceneTriggerTime = GET_GAME_TIMER()
|
|
bCutsceneWaitStarted = TRUE
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ELSE
|
|
PRINTSTRING("waiting on ready for cutscene") PRINTNL()
|
|
PREVENT_WANTED_LEVEL_FOR_CUTSCENE()
|
|
|
|
IF BRING_VEHICLE_TO_HALT_AND_DISABLE_VEH_CONTROLS(hoodVehicle[HV_FRANKLIN_VAN], 6)
|
|
PRINTSTRING("vehicle has been brought to halt") PRINTNL()
|
|
IF GET_GAME_TIMER() >= iCutsceneTriggerTime + DEFAULT_CAR_STOPPING_TO_CUTSCENE
|
|
IF NOT bKilledSpeechAtCutscene
|
|
IF GET_GAME_TIMER() >= iCutsceneTriggerTime + 3000
|
|
bKilledSpeechForArrive = TRUE
|
|
bDoneArriveSpeech = TRUE
|
|
bDoneChopBehaviourSpeech = TRUE
|
|
bDoneUphillSpeech = TRUE
|
|
bDoneCreepSpeech = TRUE
|
|
KILL_ANY_CONVERSATION()
|
|
bKilledSpeechAtCutscene = TRUE
|
|
ENDIF
|
|
ENDIF
|
|
|
|
PRINTSTRING("timer has passed wait time") PRINTNL()
|
|
IF NOT IS_ANY_CONVERSATION_ONGOING_OR_QUEUED()
|
|
PRINTSTRING("there is no conversation ongoing or queued") PRINTNL()
|
|
|
|
IF CAN_ADVANCE_MISSION()
|
|
IF mocapStreamingStage > MOCAP_STREAMING_STAGE_REQUEST
|
|
IF HAS_CUTSCENE_LOADED_WITH_FAILSAFE()
|
|
PRINTSTRING("mission has not failed - RUN THE CUTSCENE") PRINTNL()
|
|
bRunningCutscene = TRUE
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ELSE
|
|
|
|
PRINTSTRING("a conversation is ongoing or queued") PRINTNL()
|
|
|
|
|
|
IF g_ConversationStatus <> CONV_STATE_FREE
|
|
PRINTSTRING("conversation status is NOT free") PRINTNL()
|
|
ELSE
|
|
PRINTSTRING("conversation status is free") PRINTNL()
|
|
ENDIF
|
|
|
|
IF IS_SCRIPTED_CONVERSATION_ONGOING() //caters for last line being finished by audio after a kill even if conv_state if free.
|
|
PRINTSTRING("a scripted conversation is ongoing") PRINTNL()
|
|
ELSE
|
|
PRINTSTRING("a scripted conversation is NOT ongoing") PRINTNL()
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF NOT bCutsceneWaitStarted
|
|
HANDLE_IN_CAR_PROMPTS(TRUE, FALSE, TRUE)
|
|
HANDLE_LAMAR_REACTION_TO_DAMAGE()
|
|
ENDIF
|
|
ENDIF
|
|
ELSE
|
|
DO_CHOP_AUDIO(CHOP_AUDIO_STATE_WALK_TO_VAN)
|
|
SET_ALL_RANDOM_PEDS_FLEE_THIS_FRAME(PLAYER_ID())
|
|
|
|
IF iFailWantedTime < 0
|
|
IF GET_PLAYER_WANTED_LEVEL(PLAYER_ID()) > 0
|
|
iFailWantedTime = GET_GAME_TIMER()
|
|
ENDIF
|
|
ELSE
|
|
IF GET_GAME_TIMER() >= iFailWantedTime + 2000
|
|
MISSION_FAILED(FAIL_POLICE_ATTENTION)
|
|
ENDIF
|
|
ENDIF
|
|
|
|
// unfreeze vehicle if exploded
|
|
IF NOT IS_VEHICLE_DRIVEABLE(hoodVehicle[HV_FRANKLIN_VAN])
|
|
IF DOES_ENTITY_EXIST(hoodVehicle[HV_FRANKLIN_VAN])
|
|
IF IS_ENTITY_DEAD(hoodVehicle[HV_FRANKLIN_VAN])
|
|
OR NOT IS_ENTITY_DEAD(hoodVehicle[HV_FRANKLIN_VAN])
|
|
FREEZE_ENTITY_POSITION(hoodVehicle[HV_FRANKLIN_VAN], FALSE)
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF NOT IS_PED_INJURED(lamarPed)
|
|
|
|
// force walk
|
|
IF GET_GAME_TIMER() <= iStageStartTime + 1500
|
|
SET_PED_MIN_MOVE_BLEND_RATIO(lamarPed,PEDMOVE_WALK)
|
|
ENDIF
|
|
IF GET_GAME_TIMER() <= iStageStartTime + 2000
|
|
IF GET_FOLLOW_PED_CAM_VIEW_MODE() <> CAM_VIEW_MODE_FIRST_PERSON
|
|
SET_PED_MIN_MOVE_BLEND_RATIO(PLAYER_PED_ID(), PEDMOVE_WALK)
|
|
ENDIF
|
|
ELSE
|
|
IF NOT bClearedPlayerRun
|
|
CLEAR_PED_TASKS(PLAYER_PED_ID())
|
|
bClearedPlayerRun = TRUE
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF GET_GAME_TIMER() < iBlockJumpTime
|
|
DISABLE_CONTROL_ACTION(PLAYER_CONTROL, INPUT_JUMP)
|
|
ENDIF
|
|
|
|
VECTOR vPlayerPos = GET_ENTITY_COORDS(PLAYER_PED_ID())
|
|
VECTOR vLamarPos = GET_ENTITY_COORDS(lamarPed)
|
|
|
|
IF NOT bLamarWalkPaused
|
|
IF chopIntoVanState = CHOP_INTO_VAN_STATE_NOT_STARTED
|
|
FLOAT fDistAhead = vLamarPos.x - vPlayerPos.x
|
|
IF fDistAhead > 0.0
|
|
fLamarWalkSpeed = fLamarWalkSpeed +@ 0.060
|
|
ELIF fDistAhead < -1.2
|
|
fLamarWalkSpeed = fLamarWalkSpeed -@ 0.060
|
|
ELSE
|
|
// try and get to 1.0
|
|
IF fLamarWalkSpeed > 1.0
|
|
fLamarWalkSpeed = fLamarWalkSpeed -@ 0.060
|
|
IF fLamarWalkSpeed < 1.0
|
|
fLamarWalkSpeed = 1.0
|
|
ENDIF
|
|
ELIF fLamarWalkSpeed < 1.0
|
|
fLamarWalkSpeed = fLamarWalkSpeed +@ 0.060
|
|
IF fLamarWalkSpeed > 1.0
|
|
fLamarWalkSpeed = 1.0
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF fLamarWalkSpeed > MAX_LAMAR_SPEED
|
|
fLamarWalkSpeed = MAX_LAMAR_SPEED
|
|
ELIF fLamarWalkSpeed < MIN_LAMAR_SPEED
|
|
fLamarWalkSpeed = MIN_LAMAR_SPEED
|
|
ENDIF
|
|
ELSE
|
|
IF fLamarWalkSpeed > 1.0
|
|
fLamarWalkSpeed = fLamarWalkSpeed -@ 0.1
|
|
IF fLamarWalkSpeed < 1.0
|
|
fLamarWalkSpeed = 1.0
|
|
ENDIF
|
|
ELIF fLamarWalkSpeed < 1.0
|
|
fLamarWalkSpeed = fLamarWalkSpeed +@ 0.1
|
|
IF fLamarWalkSpeed > 1.0
|
|
fLamarWalkSpeed = 1.0
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
|
|
SET_PED_MOVE_RATE_OVERRIDE(lamarPed, fLamarWalkSpeed)
|
|
//printstring("lamar speed = ") printfloat(fLamarWalkSpeed) printnl()
|
|
|
|
IF GET_ENTITY_SPEED(lamarPed) < 0.1
|
|
fLamarJammedTime = fLamarJammedTime +@ 1.0
|
|
ELSE
|
|
fLamarJammedTime = fLamarJammedTime -@ 1.0
|
|
IF fLamarJammedTime < 0
|
|
fLamarJammedTime = 0
|
|
ENDIF
|
|
ENDIF
|
|
ELSE
|
|
fLamarJammedTime = fLamarJammedTime -@ 2.0
|
|
IF fLamarJammedTime < 0
|
|
fLamarJammedTime = 0
|
|
ENDIF
|
|
ENDIF
|
|
|
|
//PRINTSTRING("jammed = ") PRINTFLOAT(fLamarJammedTime) PRINTNL()
|
|
|
|
// fix for ng - disable walk when van not yet created
|
|
IF createPostIntroStage < CREATE_POST_INTRO_STAGE_DONE
|
|
DISABLE_CONTROL_ACTION(PLAYER_CONTROL, INPUT_SPRINT)
|
|
DISABLE_CONTROL_ACTION(PLAYER_CONTROL, INPUT_JUMP)
|
|
DISABLE_CONTROL_ACTION(PLAYER_CONTROL, INPUT_MELEE_ATTACK_HEAVY)
|
|
DISABLE_CONTROL_ACTION(PLAYER_CONTROL, INPUT_MELEE_ATTACK_LIGHT)
|
|
DISABLE_CONTROL_ACTION(PLAYER_CONTROL, INPUT_MELEE_ATTACK_ALTERNATE)
|
|
|
|
IF NOT GET_PED_STEALTH_MOVEMENT(PLAYER_PED_ID())
|
|
DISABLE_CONTROL_ACTION(PLAYER_CONTROL, INPUT_DUCK)
|
|
ENDIF
|
|
|
|
IF NOT bTurnedOffPhoneForWalk
|
|
DISABLE_CELLPHONE(TRUE)
|
|
bTurnedOffPhoneForWalk = TRUE
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF IS_VEHICLE_DRIVEABLE(hoodVehicle[HV_FRANKLIN_VAN])
|
|
IF NOT bDoneLamarIntoVan
|
|
IF NOT bShownGodText
|
|
bShownGodText = TRUE
|
|
ENDIF
|
|
|
|
IF IS_ENTITY_AT_ENTITY(PLAYER_PED_ID(), lamarPed, <<LAMAR_PAUSE_DIST, LAMAR_PAUSE_DIST + 1.5, 4>>)
|
|
AND NOT bDoneFranklinIntoVanSpeech
|
|
DISABLE_CONTROL_ACTION(PLAYER_CONTROL, INPUT_SPRINT)
|
|
DISABLE_CONTROL_ACTION(PLAYER_CONTROL, INPUT_JUMP)
|
|
DISABLE_CONTROL_ACTION(PLAYER_CONTROL, INPUT_MELEE_ATTACK_HEAVY)
|
|
DISABLE_CONTROL_ACTION(PLAYER_CONTROL, INPUT_MELEE_ATTACK_LIGHT)
|
|
DISABLE_CONTROL_ACTION(PLAYER_CONTROL, INPUT_MELEE_ATTACK_ALTERNATE)
|
|
|
|
IF NOT GET_PED_STEALTH_MOVEMENT(PLAYER_PED_ID())
|
|
DISABLE_CONTROL_ACTION(PLAYER_CONTROL, INPUT_DUCK)
|
|
ENDIF
|
|
|
|
IF NOT bTurnedOffPhoneForWalk
|
|
DISABLE_CELLPHONE(TRUE)
|
|
bTurnedOffPhoneForWalk = TRUE
|
|
ENDIF
|
|
ELSE
|
|
IF bTurnedOffPhoneForWalk
|
|
DISABLE_CELLPHONE(FALSE)
|
|
bTurnedOffPhoneForWalk = FALSE
|
|
ENDIF
|
|
ENDIF
|
|
|
|
//BOOL bCanDoPlayerAnims = TRUE
|
|
//IF GET_ENTITY_SPEED(PLAYER_PED_ID()) < 1.20
|
|
//OR IS_PED_RUNNING(PLAYER_PED_ID())
|
|
//OR IS_PED_IN_ANY_VEHICLE(PLAYER_PED_ID())
|
|
//bCanDoPlayerAnims = FALSE
|
|
//CLEAR_PED_SECONDARY_TASK(PLAYER_PED_ID())
|
|
//ENDIF
|
|
|
|
IF GET_ENTITY_SPEED(lamarPed) < 1.20
|
|
AND GET_SCRIPT_TASK_STATUS(lamarPed, SCRIPT_TASK_FOLLOW_WAYPOINT_ROUTE) = FINISHED_TASK
|
|
CLEAR_PED_SECONDARY_TASK(lamarPed)
|
|
ENDIF
|
|
|
|
//VECTOR vLamarPos = GET_ENTITY_COORDS(lamarPed)
|
|
//VECTOR vDiff = vLamarPos - GET_ENTITY_COORDS(PLAYER_PED_ID())
|
|
|
|
|
|
IF chopIntoVanState = CHOP_INTO_VAN_STATE_NOT_STARTED
|
|
IF NOT IS_PED_HEADTRACKING_ENTITY(lamarPed, PLAYER_PED_ID())
|
|
TASK_LOOK_AT_ENTITY(lamarPed, PLAYER_PED_ID(), -1, SLF_WHILE_NOT_IN_FOV)
|
|
ENDIF
|
|
|
|
IF NOT bLamarWalkPaused
|
|
IF NOT bKilledSpeechForVan
|
|
IF IS_ENTITY_AT_ENTITY(lamarPed, hoodVehicle[HV_FRANKLIN_VAN], <<11, 11, 4>>)
|
|
KILL_ANY_CONVERSATION()
|
|
bKilledSpeechForVan = TRUE
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF (NOT IS_ENTITY_AT_ENTITY(PLAYER_PED_ID(), lamarPed, <<LAMAR_PAUSE_DIST, LAMAR_PAUSE_DIST, 4>>) OR IS_PED_IN_ANY_VEHICLE(PLAYER_PED_ID()))
|
|
AND GET_GAME_TIMER() >= iStageStartTime + 3000
|
|
IF vPlayerPos.x > vLamarPos.x
|
|
OR bLamarWaitingAtVan
|
|
IF NOT IS_PLAYER_AT_VAN()
|
|
CLEAR_SEQUENCE_TASK(sequence)
|
|
OPEN_SEQUENCE_TASK(sequence)
|
|
TASK_LOOK_AT_ENTITY(NULL, PLAYER_PED_ID(), -1, SLF_WHILE_NOT_IN_FOV)
|
|
TASK_TURN_PED_TO_FACE_ENTITY(NULL, PLAYER_PED_ID(), -1)
|
|
CLOSE_SEQUENCE_TASK(sequence)
|
|
TASK_PERFORM_SEQUENCE(lamarPed, sequence)
|
|
|
|
CLEAR_PED_SECONDARY_TASK(lamarPed)
|
|
CLEAR_PED_SECONDARY_TASK(PLAYER_PED_ID())
|
|
|
|
TASK_CLEAR_LOOK_AT(PLAYER_PED_ID())
|
|
bKilledOnFootConversation = FALSE
|
|
bDoneHurrySpeech = FALSE
|
|
bLamarWalkPaused = TRUE
|
|
ENDIF
|
|
ELSE
|
|
// kill speech if ahead
|
|
IF bDoneBanter
|
|
IF NOT bKilledOnFootConversation
|
|
IF NOT STORE_BANTER()
|
|
IF NOT bHadFirstLineOfBanter
|
|
bDoneBanter = FALSE
|
|
ENDIF
|
|
ENDIF
|
|
KILL_ANY_CONVERSATION()
|
|
bKilledOnFootConversation = TRUE
|
|
ENDIF
|
|
ENDIF
|
|
bFranklinWentAhead = TRUE
|
|
ENDIF
|
|
ELSE
|
|
bFranklinWentAhead = FALSE
|
|
|
|
IF NOT IS_PED_HEADTRACKING_ENTITY(PLAYER_PED_ID(), lamarPed)
|
|
TASK_LOOK_AT_ENTITY(PLAYER_PED_ID(), lamarPed, -1, SLF_WHILE_NOT_IN_FOV)
|
|
ENDIF
|
|
|
|
// banter
|
|
IF bShownGodText
|
|
IF CAN_ADVANCE_MISSION()
|
|
AND NOT IS_PED_IN_ANY_VEHICLE(PLAYER_PED_ID())
|
|
IF NOT bDoneBanter
|
|
IF IS_ENTITY_AT_ENTITY(PLAYER_PED_ID(), lamarPed, <<LAMAR_UNPAUSE_DIST, LAMAR_UNPAUSE_DIST, 4>>)
|
|
AND bStoppedChopExcitement
|
|
IF IS_THIS_PRINT_BEING_DISPLAYED("FC_FOLLAM")
|
|
REMOVE_MISSION_TEXT(FALSE, TRUE, FALSE)
|
|
ENDIF
|
|
bDoneBanter = DO_MISSION_SPEECH("FKN0_WALK2")
|
|
ENDIF
|
|
ELSE
|
|
IF bSavedBanter
|
|
IF NOT bTriggeredLamarDamageReaction
|
|
AND NOT bKilledSpeechForVan
|
|
IF RESTORE_BANTER()
|
|
bSavedBanter = FALSE
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF NOT bHadFirstLineOfBanter
|
|
IF IS_ANY_CONVERSATION_ONGOING_OR_QUEUED()
|
|
AND bDoneBanter
|
|
TEXT_LABEL_23 tCurrentLabel = GET_CURRENTLY_PLAYING_STANDARD_CONVERSATION_LABEL()
|
|
IF ARE_STRINGS_EQUAL(tCurrentLabel, "FKN0_WALK2_1")
|
|
bHadFirstLineOfBanter = TRUE
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
|
|
// conversation anims
|
|
/*
|
|
IF IS_ANY_CONVERSATION_ONGOING_OR_QUEUED()
|
|
AND bDoneBanter
|
|
//INT iCurrentConversationLine = GET_CURRENT_SCRIPTED_CONVERSATION_LINE()
|
|
//PRINTSTRING("line = ") PRINTINT(iCurrentConversationLine) PRINTNL()
|
|
TEXT_LABEL_23 tCurrentLabel = GET_CURRENTLY_PLAYING_STANDARD_CONVERSATION_LABEL()
|
|
INT iLineMatch = -1
|
|
IF ARE_STRINGS_EQUAL(tCurrentLabel, "FKN0_WALK2_1")
|
|
iLineMatch = 0
|
|
ELIF ARE_STRINGS_EQUAL(tCurrentLabel, "FKN0_WALK2_3")
|
|
iLineMatch = 1
|
|
ELIF ARE_STRINGS_EQUAL(tCurrentLabel, "FKN0_WALK2_5")
|
|
iLineMatch = 2
|
|
ELIF ARE_STRINGS_EQUAL(tCurrentLabel, "FKN0_WALK2_7")
|
|
iLineMatch = 3
|
|
ELIF ARE_STRINGS_EQUAL(tCurrentLabel, "FKN0_WALK2_9")
|
|
iLineMatch = 4
|
|
ELIF ARE_STRINGS_EQUAL(tCurrentLabel, "FKN0_WALK2_11")
|
|
iLineMatch = 5
|
|
ELIF ARE_STRINGS_EQUAL(tCurrentLabel, "FKN0_WALK2_13")
|
|
iLineMatch = 6
|
|
ELIF ARE_STRINGS_EQUAL(tCurrentLabel, "FKN0_WALK2_15")
|
|
iLineMatch = 7
|
|
ENDIF
|
|
|
|
//PRINTSTRING("label = ") PRINTSTRING(tCurrentLabel) PRINTNL()
|
|
|
|
IF iLineMatch >= 0
|
|
AND bCanDoPlayerAnims
|
|
|
|
IF NOT bDoneConversationAnim[iLineMatch]
|
|
STRING sFranklinLine
|
|
STRING sLamarLine
|
|
BOOL bDoFranklinAnim = TRUE
|
|
BOOL bDoLamarAnim = TRUE
|
|
SWITCH iLineMatch
|
|
CASE 0
|
|
//sFranklinLine = "franklin_line1_ig0"
|
|
bDoFranklinAnim = FALSE
|
|
sLamarLine = "lemar_line1_ig0"
|
|
BREAK
|
|
CASE 1
|
|
sFranklinLine = "franklin_line1_ig0"
|
|
//sLamarLine = "lemar_line1_ig0"
|
|
bDoLamarAnim = FALSE
|
|
BREAK
|
|
CASE 2
|
|
//sFranklinLine = "franklin_line2_ig0"
|
|
bDoFranklinAnim = FALSE
|
|
sLamarLine = "lemar_line2_ig0"
|
|
BREAK
|
|
CASE 3
|
|
sFranklinLine = "franklin_line3_ig0"
|
|
bDoLamarAnim = FALSE
|
|
BREAK
|
|
CASE 4
|
|
//sFranklinLine = "franklin_line4_ig0"
|
|
bDoFranklinAnim = FALSE
|
|
sLamarLine = "lemar_line4_ig0"
|
|
BREAK
|
|
CASE 5
|
|
sFranklinLine = "franklin_line5_ig0"
|
|
//sLamarLine = "lemar_line5_ig0"
|
|
bDoLamarAnim = FALSE
|
|
BREAK
|
|
CASE 6
|
|
//sFranklinLine = "franklin_line6_ig0"
|
|
bDoFranklinAnim = FALSE
|
|
sLamarLine = "lemar_line6_ig0"
|
|
BREAK
|
|
CASE 7
|
|
sFranklinLine = "franklin_line7_ig0"
|
|
bDoLamarAnim = FALSE
|
|
BREAK
|
|
ENDSWITCH
|
|
|
|
IF bDoFranklinAnim
|
|
WEAPON_TYPE currentWeapon
|
|
GET_CURRENT_PED_WEAPON(PLAYER_PED_ID(), currentWeapon)
|
|
IF currentWeapon = WEAPONTYPE_UNARMED
|
|
AND NOT GET_PED_STEALTH_MOVEMENT(PLAYER_PED_ID())
|
|
//TASK_PLAY_ANIM(PLAYER_PED_ID(), GET_HOOD_ANIM_DICT_AS_STRING(H_ANIM_DICT_MISSION), sFranklinLine, SLOW_BLEND_IN, SLOW_BLEND_OUT, -1, AF_UPPERBODY | AF_SECONDARY | AF_TAG_SYNC_IN | AF_TAG_SYNC_OUT | AF_TAG_SYNC_CONTINUOUS )
|
|
|
|
ANIM_DATA none
|
|
ANIM_DATA animDataBlend
|
|
animDataBlend.type = APT_SINGLE_ANIM
|
|
animDataBlend.anim0 = sFranklinLine
|
|
animDataBlend.dictionary0 = GET_HOOD_ANIM_DICT_AS_STRING(H_ANIM_DICT_TO_VAN)
|
|
animDataBlend.phase0 = 0.0
|
|
animDataBlend.rate0 = 1.0
|
|
animDataBlend.filter = GET_HASH_KEY("BONEMASK_HEAD_NECK_AND_ARMS")
|
|
animDataBlend.flags = AF_UPPERBODY | AF_SECONDARY | AF_TAG_SYNC_IN | AF_TAG_SYNC_OUT | AF_TAG_SYNC_CONTINUOUS
|
|
TASK_SCRIPTED_ANIMATION(PLAYER_PED_ID(), animDataBlend, none, none, SLOW_BLEND_DURATION, SLOW_BLEND_DURATION)
|
|
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF bDoLamarAnim
|
|
//TASK_PLAY_ANIM(lamarPed, GET_HOOD_ANIM_DICT_AS_STRING(H_ANIM_DICT_MISSION), sLamarLine, SLOW_BLEND_IN, SLOW_BLEND_OUT, -1, AF_UPPERBODY | AF_SECONDARY | AF_TAG_SYNC_IN | AF_TAG_SYNC_OUT | AF_TAG_SYNC_CONTINUOUS )
|
|
|
|
ANIM_DATA none
|
|
ANIM_DATA animDataBlend
|
|
animDataBlend.type = APT_SINGLE_ANIM
|
|
animDataBlend.anim0 = sLamarLine
|
|
animDataBlend.dictionary0 = GET_HOOD_ANIM_DICT_AS_STRING(H_ANIM_DICT_TO_VAN)
|
|
animDataBlend.phase0 = 0.0
|
|
animDataBlend.rate0 = 1.0
|
|
animDataBlend.filter = GET_HASH_KEY("BONEMASK_HEAD_NECK_AND_ARMS")
|
|
animDataBlend.flags = AF_UPPERBODY | AF_SECONDARY | AF_TAG_SYNC_IN | AF_TAG_SYNC_OUT | AF_TAG_SYNC_CONTINUOUS
|
|
TASK_SCRIPTED_ANIMATION(lamarPed, animDataBlend, none, none, SLOW_BLEND_IN, SLOW_BLEND_OUT)
|
|
|
|
ENDIF
|
|
|
|
bDoneConversationAnim[iLineMatch] = TRUE
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
*/
|
|
ENDIF
|
|
ELSE
|
|
IF bDoneBanter
|
|
IF NOT bKilledOnFootConversation
|
|
STORE_BANTER()
|
|
KILL_ANY_CONVERSATION()
|
|
bKilledOnFootConversation = TRUE
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF NOT bDoneHurrySpeech
|
|
IF CAN_ADVANCE_MISSION()
|
|
IF (bKilledOnFootConversation
|
|
OR NOT bDoneBanter)
|
|
AND NOT bFranklinWentAhead
|
|
AND NOT IS_PED_IN_ANY_VEHICLE(PLAYER_PED_ID())
|
|
IF GET_GAME_TIMER() >= iNextLamarHurrySpeechTime
|
|
IF IS_ENTITY_AT_ENTITY(PLAYER_PED_ID(), lamarPed, <<15,15,15>>, FALSE, FALSE)
|
|
STRING sHurryString
|
|
IF GET_ENTITY_SPEED(PLAYER_PED_ID()) >= 1.2
|
|
AND NOT IS_PED_FACING_PED(PLAYER_PED_ID(), lamarPed, 45)
|
|
sHurryString = "FKN0_LFOL2"
|
|
ELSE
|
|
sHurryString = "FKN0_LFOL1"
|
|
ENDIF
|
|
|
|
IF DO_MISSION_SPEECH(sHurryString)
|
|
bDoneHurrySpeech = TRUE
|
|
iNextLamarHurrySpeechTime = GET_GAME_TIMER() + 10000
|
|
ENDIF
|
|
ELSE
|
|
bDoneHurrySpeech = TRUE
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ELSE
|
|
IF NOT bShownHurryPrompt
|
|
bShownHurryPrompt = DO_MISSION_GOD_TEXT("FC_FOLLAM")
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF (IS_ENTITY_AT_ENTITY(PLAYER_PED_ID(), lamarPed, <<LAMAR_UNPAUSE_DIST, LAMAR_UNPAUSE_DIST, 4>>) OR vPlayerPos.x < vLamarPos.x)
|
|
AND (NOT IS_PED_IN_ANY_VEHICLE(PLAYER_PED_ID()) OR vPlayerPos.x < vLamarPos.x)
|
|
//TASK_LOOK_AT_ENTITY(lamarPed, PLAYER_PED_ID(), -1, SLF_WHILE_NOT_IN_FOV)
|
|
//TASK_LOOK_AT_ENTITY(PLAYER_PED_ID(), lamarPed, -1, SLF_WHILE_NOT_IN_FOV)
|
|
|
|
IF IS_ENTITY_AT_ENTITY(PLAYER_PED_ID(), lamarPed, <<LAMAR_UNPAUSE_DIST, LAMAR_UNPAUSE_DIST, 4>>)
|
|
OR IS_PLAYER_AT_VAN()
|
|
OR NOT bLamarWaitingAtVan
|
|
DO_LAMAR_FOLLOW_PAVEMENT()
|
|
bKilledOnFootConversation = FALSE
|
|
bLamarWalkPaused = FALSE
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF NOT IS_PED_INJURED(chopPed)
|
|
IF GET_GAME_TIMER() <= iStageStartTime + 2000
|
|
SET_PED_MIN_MOVE_BLEND_RATIO(chopPed, PEDMOVE_WALK)
|
|
ENDIF
|
|
|
|
IF GET_ENTITY_SPEED(lamarPed) >= 0.3
|
|
fLamarSpeedCount = 0
|
|
ELSE
|
|
fLamarSpeedCount = fLamarSpeedCount +@ 1.0
|
|
ENDIF
|
|
|
|
IF (fLamarSpeedCount < 0.6
|
|
AND NOT bLamarWalkPaused)
|
|
OR bWarpedLamarToVan
|
|
//IF GET_GAME_TIMER() >= iStageStartTime + 1000
|
|
IF GET_SCRIPT_TASK_STATUS(chopPed, SCRIPT_TASK_GOTO_ENTITY_OFFSET) = FINISHED_TASK
|
|
AND CAN_CHOP_TRANSITION_BACK_FROM_WAIT(TRUE)
|
|
//AND GET_SCRIPT_TASK_STATUS(chopPed, SCRIPT_TASK_PLAY_ANIM) = FINISHED_TASK
|
|
AND GET_GAME_TIMER() >= iLastChopMoveCommandTime + 2000
|
|
//AND GET_ENTITY_SPEED(chopPed) <= 0.05
|
|
//IF GET_SCRIPT_TASK_STATUS(chopPed, SCRIPT_TASK_FOLLOW_TO_OFFSET_OF_ENTITY) = FINISHED_TASK
|
|
GIVE_CHOP_FOLLOW_TASK()
|
|
iLastChopMoveCommandTime = GET_GAME_TIMER()
|
|
//TASK_GOTO_ENTITY_OFFSET(chopPed, lamarPed, DEFAULT_TIME_NEVER_WARP, 1.0, 130, PEDMOVE_RUN)
|
|
//TASK_FOLLOW_TO_OFFSET_OF_ENTITY(chopPed, lamarPed, <<-2, -10, 0>>, PEDMOVE_RUN, -1, 0.1)
|
|
ENDIF
|
|
//ENDIF
|
|
ELSE
|
|
IF GET_SCRIPT_TASK_STATUS(chopPed, SCRIPT_TASK_GOTO_ENTITY_OFFSET) <> FINISHED_TASK
|
|
AND GET_GAME_TIMER() >= iLastChopMoveCommandTime + 2000
|
|
CLEAR_SEQUENCE_TASK(sequence)
|
|
OPEN_SEQUENCE_TASK(sequence)
|
|
//TASK_PAUSE(NULL, 500)
|
|
IF NOT IS_ENTITY_AT_ENTITY(chopPed, lamarPed, <<6,6,6>>, false, false)
|
|
TASK_GO_TO_ENTITY(NULL, lamarPed, DEFAULT_TIME_NEVER_WARP, 1.8, PEDMOVE_RUN)
|
|
ELIF NOT IS_ENTITY_AT_ENTITY(chopPed, lamarPed, <<3,3,3>>, false, false)
|
|
TASK_GO_TO_ENTITY(NULL, lamarPed, DEFAULT_TIME_NEVER_WARP, 1.6, PEDMOVE_WALK)
|
|
ENDIF
|
|
TASK_PAUSE(NULL, 1000)
|
|
TASK_PLAY_ANIM(NULL, GET_HOOD_ANIM_DICT_AS_STRING(H_ANIM_DICT_SHARED), "FRA0_IG_12_CHOP_WAITING_B", SLOW_BLEND_IN, REALLY_SLOW_BLEND_OUT, -1, AF_LOOPING)
|
|
CLOSE_SEQUENCE_TASK(sequence)
|
|
TASK_PERFORM_SEQUENCE(chopPed, sequence)
|
|
iLastChopMoveCommandTime = GET_GAME_TIMER()
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ELSE
|
|
IF NOT bDoneFranklinIntoVanSpeech
|
|
IF IS_ENTITY_AT_ENTITY(PLAYER_PED_ID(), lamarPed, <<15,15,15>>, FALSE, FALSE)
|
|
bDoneFranklinIntoVanSpeech = DO_MISSION_SPEECH("FKN0_DRIVE")
|
|
ELSE
|
|
bDoneFranklinIntoVanSpeech = TRUE
|
|
ENDIF
|
|
ELSE
|
|
HANDLE_IN_CAR_PROMPTS(FALSE, bLamarWasInGroup, FALSE, bLamarWasInGroup)
|
|
ENDIF
|
|
ENDIF
|
|
|
|
SWITCH chopIntoVanState
|
|
CASE CHOP_INTO_VAN_STATE_NOT_STARTED
|
|
IF IS_VEHICLE_DRIVEABLE(hoodVehicle[HV_FRANKLIN_VAN])
|
|
AND NOT IS_PED_INJURED(lamarPed)
|
|
AND NOT IS_PED_INJURED(chopPed)
|
|
SET_PED_GESTURE_GROUP(PLAYER_PED_ID(), "ANIM_GROUP_GESTURE_MISS_FRA0")
|
|
SET_PED_GESTURE_GROUP(lamarPed, "ANIM_GROUP_GESTURE_MISS_FRA0")
|
|
|
|
IF NOT bWarpedLamarToVan
|
|
IF fLamarJammedTime >= 10.0
|
|
CLEAR_PED_TASKS(lamarPed)
|
|
SET_ENTITY_COORDS(lamarPed, <<-77.03740, -1461.03149, 31.12035>>)
|
|
SET_ENTITY_HEADING(lamarPed, 46.7)
|
|
bWarpedLamarToVan = TRUE
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF IS_ENTITY_AT_ENTITY(lamarPed, hoodVehicle[HV_FRANKLIN_VAN], <<7,7,LOCATE_SIZE_HEIGHT>>)
|
|
AND NOT bLamarWalkPaused
|
|
IF NOT IS_ENTITY_AT_ENTITY(PLAYER_PED_ID(), lamarPed, <<LAMAR_PAUSE_DIST, LAMAR_PAUSE_DIST, 4>>)
|
|
AND NOT IS_PLAYER_AT_VAN()
|
|
bLamarWaitingAtVan = TRUE
|
|
ELSE
|
|
//CLEAR_PED_SECONDARY_TASK(lamarPed)
|
|
TASK_LOOK_AT_ENTITY(lamarPed, chopPed, -1, SLF_WHILE_NOT_IN_FOV)
|
|
TASK_CLEAR_LOOK_AT(PLAYER_PED_ID())
|
|
|
|
KILL_ANY_CONVERSATION()
|
|
SET_VEHICLE_IS_CONSIDERED_BY_PLAYER(hoodVehicle[HV_FRANKLIN_VAN], TRUE)
|
|
|
|
IF DOES_BLIP_EXIST(lamarBlip)
|
|
REMOVE_BLIP(lamarBlip)
|
|
ENDIF
|
|
bSavedBanter = FALSE
|
|
|
|
// chop goto van
|
|
//CLEAR_SEQUENCE_TASK(sequence)
|
|
//OPEN_SEQUENCE_TASK(sequence)
|
|
// TASK_FOLLOW_NAV_MESH_TO_COORD(NULL, <<-78.02858, -1452.29309, 31.03300>>, PEDMOVE_RUN, DEFAULT_TIME_BEFORE_WARP, DEFAULT_NAVMESH_RADIUS, ENAV_DEFAULT, 144.5)
|
|
// TASK_GO_STRAIGHT_TO_COORD(NULL, <<-79.04949, -1453.70010, 31.01084>>, PEDMOVE_WALK, DEFAULT_TIME_BEFORE_WARP, 151.5)
|
|
//CLOSE_SEQUENCE_TASK(sequence)
|
|
//TASK_PERFORM_SEQUENCE(chopPed, sequence)
|
|
EWAYPOINT_FOLLOW_FLAGS flags
|
|
IF IS_ENTITY_AT_COORD(chopPed, <<-72.67596, -1459.41016, 31.11492>>, <<7,7,7>>, FALSE, FALSE)
|
|
flags = EWAYPOINT_TURN_TO_FACE_WAYPOINT_HEADING_AT_END | EWAYPOINT_START_TASK_EXACTSTOP | EWAYPOINT_NAVMESH_BACK_TO_WAYPOINT_IF_LEFT_ROUTE
|
|
ELSE
|
|
flags = EWAYPOINT_TURN_TO_FACE_WAYPOINT_HEADING_AT_END | EWAYPOINT_START_TASK_EXACTSTOP | EWAYPOINT_NAVMESH_TO_INITIAL_WAYPOINT | EWAYPOINT_NAVMESH_BACK_TO_WAYPOINT_IF_LEFT_ROUTE
|
|
ENDIF
|
|
TASK_FOLLOW_WAYPOINT_RECORDING(chopPed, "hood12", 2, flags)
|
|
|
|
|
|
iForceChopIntoVanTime = GET_GAME_TIMER() + 30000
|
|
chopIntoVanState = CHOP_INTO_VAN_STATE_GET_IN_POSITION
|
|
ENDIF
|
|
ELSE
|
|
IF IS_ENTITY_AT_ENTITY(chopPed, lamarPed, <<1.1,1.1,1.1>>, FALSE, FALSE)
|
|
SET_PED_MOVE_RATE_OVERRIDE(chopPed, 1.01)
|
|
ELIF IS_ENTITY_AT_ENTITY(chopPed, lamarPed, <<1.8,1.8,1.8>>, FALSE, FALSE)
|
|
SET_PED_MOVE_RATE_OVERRIDE(chopPed, 1.06)
|
|
ELIF NOT IS_ENTITY_AT_ENTITY(chopPed, lamarPed, <<7,7,7>>, FALSE, FALSE)
|
|
IF GET_ENTITY_SPEED(chopPed) >= 1.0
|
|
IF GET_GAME_TIMER() >= iStageStartTime + 2000
|
|
SET_PED_MIN_MOVE_BLEND_RATIO(chopPed, 1.5)
|
|
SET_PED_MOVE_RATE_OVERRIDE(chopPed, 1.06)
|
|
ENDIF
|
|
ENDIF
|
|
//SET_PED_MOVE_RATE_OVERRIDE(chopPed, 1.15)
|
|
ELSE
|
|
SET_PED_MOVE_RATE_OVERRIDE(chopPed, 1.10)
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
BREAK
|
|
|
|
CASE CHOP_INTO_VAN_STATE_GET_IN_POSITION
|
|
IF IS_VEHICLE_DRIVEABLE(hoodVehicle[HV_FRANKLIN_VAN])
|
|
AND NOT IS_PED_INJURED(lamarPed)
|
|
AND NOT IS_PED_INJURED(chopPed)
|
|
SET_PED_MOVE_RATE_OVERRIDE(lamarPed, 1.00)//0.90)
|
|
SET_PED_MOVE_RATE_OVERRIDE(chopPed, 1.15)
|
|
|
|
IF IS_WAYPOINT_PLAYBACK_GOING_ON_FOR_PED(chopPed)
|
|
WAYPOINT_PLAYBACK_OVERRIDE_SPEED(chopPed, PEDMOVE_WALK)
|
|
SET_PED_WAYPOINT_ROUTE_OFFSET(chopPed, <<0,0.2,0>>)
|
|
ENDIF
|
|
|
|
IF IS_ENTITY_AT_COORD(lamarPed, <<-79.15181, -1454.35547, 31.02351>>, <<2.5,2.5,2.5>>, FALSE, FALSE)
|
|
SET_PED_RESET_FLAG(lamarPed, PRF_UseKinematicPhysics, TRUE)
|
|
SET_PED_CAN_RAGDOLL_FROM_PLAYER_IMPACT(lamarPed, FALSE)
|
|
ENDIF
|
|
|
|
IF IS_ENTITY_AT_COORD(chopPed, <<-79.15181, -1454.35547, 31.02351>>, <<2.5,2.5,2.5>>, FALSE, FALSE)
|
|
SET_PED_RESET_FLAG(chopPed, PRF_UseKinematicPhysics, TRUE)
|
|
SET_PED_CAN_RAGDOLL_FROM_PLAYER_IMPACT(chopPed, FALSE)
|
|
ENDIF
|
|
|
|
BOOL bDoForce
|
|
bDoForce = FALSE
|
|
|
|
IF GET_GAME_TIMER() >= iForceChopIntoVanTime
|
|
bDoForce = TRUE
|
|
ELSE
|
|
IF GET_SCRIPT_TASK_STATUS(lamarPed, SCRIPT_TASK_FOLLOW_WAYPOINT_ROUTE) = FINISHED_TASK
|
|
AND GET_SCRIPT_TASK_STATUS(chopPed, SCRIPT_TASK_FOLLOW_WAYPOINT_ROUTE) = FINISHED_TASK
|
|
IF NOT IS_ENTITY_AT_COORD(lamarPed, <<-79.51687, -1453.27686, 31.12119>>, <<1.0,1.0,1>>, FALSE, FALSE)
|
|
OR NOT IS_ENTITY_AT_COORD(lamarPed, <<-79.08290, -1453.59009, 31.53415>>, <<1.0,1.0,1>>, FALSE, FALSE)
|
|
bDoForce = TRUE
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF bDoForce
|
|
SET_CHOP_INTO_VAN(chopPed, hoodVehicle[HV_FRANKLIN_VAN], chopLeanInVanState, fCachedVanSpeed, FALSE, TRUE, TRUE)
|
|
SET_ENTITY_PROOFS(chopPed, FALSE, TRUE, TRUE, FALSE, FALSE, FALSE, FALSE, TRUE)
|
|
SET_PED_CAN_RAGDOLL(chopPed, FALSE)
|
|
CLEAR_PED_TASKS_IMMEDIATELY(lamarPed)
|
|
TASK_CLEAR_LOOK_AT(lamarPed)
|
|
SET_PED_INTO_VEHICLE(lamarPed, hoodVehicle[HV_FRANKLIN_VAN], VS_FRONT_RIGHT)
|
|
bLamarWasInGroup = TRUE
|
|
bShutVanDoors = TRUE
|
|
bDoneChopGetInSpeech = TRUE
|
|
bForcedIntoVan = TRUE
|
|
chopIntoVanState = CHOP_INTO_VAN_STATE_DONE
|
|
ELSE
|
|
IF GET_SCRIPT_TASK_STATUS(lamarPed, SCRIPT_TASK_FOLLOW_WAYPOINT_ROUTE) = FINISHED_TASK
|
|
AND GET_SCRIPT_TASK_STATUS(chopPed, SCRIPT_TASK_FOLLOW_WAYPOINT_ROUTE) = FINISHED_TASK
|
|
vLamarSyncScenePos = GET_OFFSET_FROM_ENTITY_IN_WORLD_COORDS(lamarPed, <<-1.990, 3.210, -0.242>>)
|
|
vLamarSyncSceneRot = <<0,0,GET_ENTITY_HEADING(lamarPed) + 36.655>>
|
|
|
|
vChopSyncScenePos = GET_OFFSET_FROM_ENTITY_IN_WORLD_COORDS(chopPed, <<-2.596, 1.970, 0.332>>)
|
|
vChopSyncSceneRot = <<0,0,GET_ENTITY_HEADING(chopPed) + 60.546>>
|
|
|
|
SET_VECTOR_CLOSEST_TO_IDEAL(vLamarSyncSceneRot, GET_ENTITY_ROTATION(hoodVehicle[HV_FRANKLIN_VAN]))
|
|
SET_VECTOR_CLOSEST_TO_IDEAL(vChopSyncSceneRot, GET_ENTITY_ROTATION(hoodVehicle[HV_FRANKLIN_VAN]))
|
|
|
|
TASK_CLEAR_LOOK_AT(lamarPed)
|
|
iLamarSyncScene = CREATE_SYNCHRONIZED_SCENE(vLamarSyncScenePos, vLamarSyncSceneRot)
|
|
//ATTACH_SYNCHRONIZED_SCENE_TO_ENTITY(iLamarSyncScene, hoodVehicle[HV_FRANKLIN_VAN], 0)
|
|
SET_SYNCHRONIZED_SCENE_HOLD_LAST_FRAME (iLamarSyncScene, FALSE)
|
|
TASK_SYNCHRONIZED_SCENE(lamarPed, iLamarSyncScene, GET_HOOD_ANIM_DICT_AS_STRING(H_ANIM_DICT_TO_VAN), "put_chop_in_van_lam", NORMAL_BLEND_IN, NORMAL_BLEND_OUT, SYNCED_SCENE_USE_PHYSICS | SYNCED_SCENE_DONT_INTERRUPT, RBF_PLAYER_IMPACT | RBF_MELEE | RBF_VEHICLE_IMPACT)
|
|
|
|
chopChaseProperties.iSyncScene = CREATE_SYNCHRONIZED_SCENE(vChopSyncScenePos, vChopSyncSceneRot)
|
|
//ATTACH_SYNCHRONIZED_SCENE_TO_ENTITY(chopChaseProperties.iSyncScene, hoodVehicle[HV_FRANKLIN_VAN], 0)
|
|
TASK_SYNCHRONIZED_SCENE(chopPed, chopChaseProperties.iSyncScene, GET_HOOD_ANIM_DICT_AS_STRING(H_ANIM_DICT_TO_VAN), "put_chop_in_van_chop", NORMAL_BLEND_IN, REALLY_SLOW_BLEND_OUT, SYNCED_SCENE_USE_PHYSICS | SYNCED_SCENE_DONT_INTERRUPT, RBF_PLAYER_IMPACT | RBF_MELEE | RBF_VEHICLE_IMPACT)
|
|
SET_SYNCHRONIZED_SCENE_HOLD_LAST_FRAME (chopChaseProperties.iSyncScene, FALSE)
|
|
|
|
SET_ENTITY_NO_COLLISION_ENTITY(chopPed, hoodVehicle[HV_FRANKLIN_VAN], FALSE)
|
|
SET_ENTITY_NO_COLLISION_ENTITY(lamarPed, hoodVehicle[HV_FRANKLIN_VAN], FALSE)
|
|
|
|
PLAY_ENTITY_ANIM(hoodVehicle[HV_FRANKLIN_VAN], "put_chop_in_van_van", GET_HOOD_ANIM_DICT_AS_STRING(H_ANIM_DICT_TO_VAN), NORMAL_BLEND_IN, FALSE, FALSE, FALSE, 0, ENUM_TO_INT(AF_USE_KINEMATIC_PHYSICS))
|
|
|
|
chopIntoVanState = CHOP_INTO_VAN_STATE_PLAYING
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
BREAK
|
|
|
|
CASE CHOP_INTO_VAN_STATE_PLAYING
|
|
|
|
IF IS_ENTITY_PLAYING_ANIM(hoodVehicle[HV_FRANKLIN_VAN], GET_HOOD_ANIM_DICT_AS_STRING(H_ANIM_DICT_TO_VAN), "put_chop_in_van_van")
|
|
IF IS_SYNCHRONIZED_SCENE_RUNNING(chopChaseProperties.iSyncScene)
|
|
SET_ENTITY_ANIM_CURRENT_TIME(hoodVehicle[HV_FRANKLIN_VAN], GET_HOOD_ANIM_DICT_AS_STRING(H_ANIM_DICT_TO_VAN), "put_chop_in_van_van", GET_SYNCHRONIZED_SCENE_PHASE(chopChaseProperties.iSyncScene))
|
|
ENDIF
|
|
|
|
FLOAT fVanPhase
|
|
fVanPhase = GET_ENTITY_ANIM_CURRENT_TIME(hoodVehicle[HV_FRANKLIN_VAN], GET_HOOD_ANIM_DICT_AS_STRING(H_ANIM_DICT_TO_VAN), "put_chop_in_van_van")
|
|
|
|
SWITCH iOpenVanDoorSoundStage
|
|
CASE 0
|
|
IF fVanPhase >= 0.113
|
|
PLAY_VEHICLE_DOOR_OPEN_SOUND(hoodVehicle[HV_FRANKLIN_VAN], 3)
|
|
PRINTSTRING("OPEN sound 1") printnl()
|
|
iOpenVanDoorSoundStage++
|
|
ENDIF
|
|
BREAK
|
|
CASE 1
|
|
IF fVanPhase >= 0.68
|
|
//PLAY_VEHICLE_DOOR_CLOSE_SOUND(hoodVehicle[HV_FRANKLIN_VAN], 3)
|
|
PRINTSTRING("CLOSE sound 1") printnl()
|
|
iOpenVanDoorSoundStage++
|
|
ENDIF
|
|
BREAK
|
|
ENDSWITCH
|
|
ENDIF
|
|
|
|
IF IS_SYNCHRONIZED_SCENE_RUNNING(chopChaseProperties.iSyncScene)
|
|
VECTOR vVanPos
|
|
vVanPos = GET_ENTITY_COORDS(hoodVehicle[HV_FRANKLIN_VAN])
|
|
VECTOR vVanRot
|
|
vVanRot = GET_ENTITY_ROTATION(hoodVehicle[HV_FRANKLIN_VAN])
|
|
|
|
CONST_FLOAT VAN_SHIFT_POS_SPEED 1.0
|
|
CONST_FLOAT VAN_SHIFT_ROT_SPEED 20.0
|
|
|
|
IF IS_SYNCHRONIZED_SCENE_RUNNING(iLamarSyncScene)
|
|
SHIFT_VECTOR_TO_IDEAL_VECTOR(vLamarSyncScenePos, vVanPos, VAN_SHIFT_POS_SPEED/3)
|
|
SHIFT_VECTOR_TO_IDEAL_VECTOR(vLamarSyncSceneRot, vVanRot, VAN_SHIFT_ROT_SPEED/3)
|
|
SET_SYNCHRONIZED_SCENE_ORIGIN(iLamarSyncScene, vLamarSyncScenePos, vLamarSyncSceneRot)
|
|
ENDIF
|
|
|
|
SHIFT_VECTOR_TO_IDEAL_VECTOR(vChopSyncScenePos, vVanPos, VAN_SHIFT_POS_SPEED/4)
|
|
SHIFT_VECTOR_TO_IDEAL_VECTOR(vChopSyncSceneRot, vVanRot, VAN_SHIFT_ROT_SPEED/4)
|
|
SET_SYNCHRONIZED_SCENE_ORIGIN(chopChaseProperties.iSyncScene, vChopSyncScenePos, vChopSyncSceneRot)
|
|
|
|
DO_LAMAR_WALK_TO_VAN()
|
|
|
|
//IF GET_SYNCHRONIZED_SCENE_PHASE(chopChaseProperties.iSyncScene) >= 0.98
|
|
//DETACH_SYNCHRONIZED_SCENE(chopChaseProperties.iSyncScene)
|
|
// SET_CHOP_INTO_VAN(chopPed, hoodVehicle[HV_FRANKLIN_VAN], chopLeanInVanState, fCachedVanSpeed, FALSE, FALSE, TRUE)
|
|
//TASK_FOLLOW_NAV_MESH_TO_COORD(lamarPed, <<-79.09520, -1457.45752, 31.05803>>, PEDMOVE_WALK, DEFAULT_TIME_BEFORE_WARP, DEFAULT_NAVMESH_RADIUS, ENAV_DEFAULT, -139.7)
|
|
//TASK_LOOK_AT_ENTITY(lamarPed, PLAYER_PED_ID(), -1, SLF_WHILE_NOT_IN_FOV)
|
|
|
|
//SET_PED_AS_GROUP_MEMBER(lamarPed, PLAYER_GROUP_ID())
|
|
// chopIntoVanState = CHOP_INTO_VAN_STATE_DONE
|
|
//ENDIF
|
|
ELSE
|
|
SET_CHOP_INTO_VAN(chopPed, hoodVehicle[HV_FRANKLIN_VAN], chopLeanInVanState, fCachedVanSpeed, FALSE, FALSE, TRUE)
|
|
SET_ENTITY_PROOFS(chopPed, FALSE, TRUE, TRUE, FALSE, FALSE, FALSE, FALSE, TRUE)
|
|
SET_PED_CAN_RAGDOLL(chopPed, FALSE)
|
|
chopIntoVanState = CHOP_INTO_VAN_STATE_DONE
|
|
ENDIF
|
|
BREAK
|
|
|
|
CASE CHOP_INTO_VAN_STATE_DONE
|
|
IF NOT bForcedIntoVan
|
|
DO_LAMAR_WALK_TO_VAN()
|
|
SET_PED_CAN_RAGDOLL_FROM_PLAYER_IMPACT(lamarPed, TRUE)
|
|
ENDIF
|
|
BREAK
|
|
ENDSWITCH
|
|
|
|
IF IS_CHAR_USING_VEHICLE(PLAYER_PED_ID(), hoodVehicle[HV_FRANKLIN_VAN])
|
|
OR chopIntoVanState > CHOP_INTO_VAN_STATE_GET_IN_POSITION
|
|
FREEZE_ENTITY_POSITION(hoodVehicle[HV_FRANKLIN_VAN], FALSE)
|
|
ENDIF
|
|
|
|
IF NOT bLamarWasInGroup
|
|
IF chopIntoVanState = CHOP_INTO_VAN_STATE_DONE
|
|
IF NOT IS_PED_GROUP_MEMBER(lamarPed, PLAYER_GROUP_ID())
|
|
IF NOT IS_ENTITY_AT_ENTITY(lamarPed, hoodVehicle[HV_FRANKLIN_VAN], <<7.5,7.5,7.5>>, FALSE, FALSE)
|
|
OR (bDoneLamarWalkToVan AND GET_SCRIPT_TASK_STATUS(lamarPed, SCRIPT_TASK_ENTER_VEHICLE) = FINISHED_TASK AND GET_GAME_TIMER() >= iEnterVanTaskTime + 1000)
|
|
CLEAR_PED_TASKS(lamarPed)
|
|
TASK_LOOK_AT_ENTITY(lamarPed, PLAYER_PED_ID(), -1, SLF_WHILE_NOT_IN_FOV)
|
|
SET_PED_AS_GROUP_MEMBER(lamarPed, PLAYER_GROUP_ID())
|
|
bLamarWasInGroup = TRUE
|
|
ENDIF
|
|
ELSE
|
|
bLamarWasInGroup = TRUE
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF chopIntoVanState > CHOP_INTO_VAN_STATE_NOT_STARTED
|
|
IF NOT bDoneChopGetInSpeech
|
|
IF NOT bCutsceneWaitStarted
|
|
IF iGetInTextStage > 0
|
|
IF chopIntoVanState >= CHOP_INTO_VAN_STATE_PLAYING
|
|
AND chopIntoVanState < CHOP_INTO_VAN_STATE_DONE
|
|
IF IS_ENTITY_AT_ENTITY(PLAYER_PED_ID(), lamarPed, <<15,15,15>>, FALSE, FALSE)
|
|
BOOL bAllowGoodDog
|
|
bAllowGoodDog = TRUE
|
|
IF IS_ENTITY_PLAYING_ANIM(hoodVehicle[HV_FRANKLIN_VAN], GET_HOOD_ANIM_DICT_AS_STRING(H_ANIM_DICT_TO_VAN), "put_chop_in_van_van")
|
|
IF GET_ENTITY_ANIM_CURRENT_TIME(hoodVehicle[HV_FRANKLIN_VAN], GET_HOOD_ANIM_DICT_AS_STRING(H_ANIM_DICT_TO_VAN), "put_chop_in_van_van") >= 0.34
|
|
bAllowGoodDog = FALSE
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF bAllowGoodDog
|
|
bDoneChopGetInSpeech = DO_MISSION_SPEECH("FKN0_GDDOG", TRUE, 0, FALSE, NOT IS_MESSAGE_BEING_DISPLAYED())
|
|
ELSE
|
|
bDoneChopGetInSpeech = TRUE
|
|
ENDIF
|
|
ELSE
|
|
bDoneChopGetInSpeech = TRUE
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF chopIntoVanState >= CHOP_INTO_VAN_STATE_PLAYING
|
|
IF NOT bShutVanDoors
|
|
BOOL bDoShut
|
|
bDoShut = FALSE
|
|
IF IS_ENTITY_PLAYING_ANIM(hoodVehicle[HV_FRANKLIN_VAN], GET_HOOD_ANIM_DICT_AS_STRING(H_ANIM_DICT_TO_VAN), "put_chop_in_van_van")
|
|
IF GET_ENTITY_ANIM_CURRENT_TIME(hoodVehicle[HV_FRANKLIN_VAN], GET_HOOD_ANIM_DICT_AS_STRING(H_ANIM_DICT_TO_VAN), "put_chop_in_van_van") >= 0.885
|
|
bDoShut = TRUE
|
|
ENDIF
|
|
ELSE
|
|
// bDoShut = TRUE
|
|
ENDIF
|
|
|
|
IF bDoShut
|
|
STOP_ENTITY_ANIM(hoodVehicle[HV_FRANKLIN_VAN], "put_chop_in_van_van", GET_HOOD_ANIM_DICT_AS_STRING(H_ANIM_DICT_TO_VAN), INSTANT_BLEND_OUT)
|
|
SET_VEHICLE_DOOR_SHUT(hoodVehicle[HV_FRANKLIN_VAN], SC_DOOR_REAR_LEFT)
|
|
SET_VEHICLE_DOOR_SHUT(hoodVehicle[HV_FRANKLIN_VAN], SC_DOOR_REAR_RIGHT)
|
|
printstring("done shut doors3!") printnl()
|
|
bShutVanDoors = TRUE
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF IS_PED_SITTING_IN_VEHICLE(lamarPed, hoodVehicle[HV_FRANKLIN_VAN])
|
|
IF IS_PED_GROUP_MEMBER(lamarPed, PLAYER_GROUP_ID())
|
|
REMOVE_PED_FROM_GROUP(lamarPed)
|
|
SET_BLOCKING_OF_NON_TEMPORARY_EVENTS(lamarPed, FALSE)
|
|
SET_PED_COMBAT_ATTRIBUTES(lamarPed, CA_LEAVE_VEHICLES, FALSE)
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF IS_PED_SITTING_IN_VEHICLE(PLAYER_PED_ID(), hoodVehicle[HV_FRANKLIN_VAN])
|
|
AND IS_PED_IN_VEHICLE(lamarPed, hoodVehicle[HV_FRANKLIN_VAN])
|
|
IF chopIntoVanState = CHOP_INTO_VAN_STATE_DONE
|
|
AND NOT IS_ANY_CONVERSATION_ONGOING_OR_QUEUED()
|
|
IF CAN_ADVANCE_MISSION()
|
|
IF NOT IS_PED_INJURED(chopPed)
|
|
SET_PED_CAN_RAGDOLL_FROM_PLAYER_IMPACT(chopPed, TRUE)
|
|
ENDIF
|
|
IF NOT IS_PED_INJURED(lamarPed)
|
|
SET_PED_CAN_RAGDOLL_FROM_PLAYER_IMPACT(lamarPed, TRUE)
|
|
ENDIF
|
|
|
|
STOP_HOOD_AUDIO_SCENE(HOOD_AUDIO_SCENE_WALK_TO_VAN)
|
|
START_HOOD_AUDIO_SCENE(HOOD_AUDIO_SCENE_DRIVE_TO_VINEWOOD)
|
|
|
|
SET_BLOCKING_OF_NON_TEMPORARY_EVENTS(lamarPed, FALSE)
|
|
SET_PED_COMBAT_ATTRIBUTES(lamarPed, CA_LEAVE_VEHICLES, FALSE)
|
|
|
|
CLEAR_MISC_ASSET_REQUEST(H_MISC_ASSET_GESTURES)
|
|
bDoneBanter = FALSE
|
|
bSavedBanter = FALSE
|
|
bShownGodText = FALSE
|
|
bDoneLamarIntoVan = TRUE
|
|
iNextChopSoundTime = GET_GAME_TIMER() + GET_RANDOM_INT_IN_RANGE(2000, 3000)
|
|
iGetInTextStage = 2
|
|
SET_WANTED_LEVEL_MULTIPLIER(1.0)
|
|
SET_MAX_WANTED_LEVEL(5)
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ELSE
|
|
//IF NOT bDoneLamarIntoVan
|
|
// DO_INTO_VAN_CUTSCENE()
|
|
//ELSE
|
|
DO_BAD_GUY_ESCAPE_CUTSCENE()
|
|
//ENDIF
|
|
ENDIF
|
|
ENDPROC
|
|
|
|
|
|
// trigger crash cut
|
|
PROC HANDLE_CRASH_TRIGGER()
|
|
|
|
IF IS_VEHICLE_DRIVEABLE(hoodVehicle[HV_FRANKLIN_VAN])
|
|
AND NOT IS_PED_INJURED(PLAYER_PED_ID())
|
|
AND NOT IS_PED_INJURED(chopPed)
|
|
AND NOT IS_PED_INJURED(lamarPed)
|
|
AND NOT IS_PED_INJURED(runnerChaseProperties.ped)
|
|
|
|
SWITCH crashTriggerState
|
|
CASE CRASH_TRIGGER_WAITING
|
|
IF createYardStage = CREATE_YARD_STAGE_DONE
|
|
IF IS_PED_SITTING_IN_VEHICLE(PLAYER_PED_ID(), hoodVehicle[HV_FRANKLIN_VAN])
|
|
IF IS_ENTITY_AT_COORD(PLAYER_PED_ID(), <<454.84790, -688.87665, 26.97397>>, <<17,17,17>>, FALSE, FALSE)
|
|
OR IS_ENTITY_AT_COORD(PLAYER_PED_ID(), <<458.08105, -660.48938, 26.48790>>, <<35,35,35>>, FALSE, FALSE)
|
|
IF DOES_ENTITY_EXIST(uberTrailerVehicle)
|
|
SET_VEHICLE_AS_NO_LONGER_NEEDED(uberTrailerVehicle)
|
|
ENDIF
|
|
CLEAR_MODEL_REQUEST(ENUM_TO_INT(HM_TRAILER))
|
|
SetpieceCarID[CRASH_BUS_ID] = NULL
|
|
|
|
IF STREAMVOL_IS_VALID(missionStreamingVolume)
|
|
STREAMVOL_DELETE(missionStreamingVolume)
|
|
ENDIF
|
|
//missionStreamingVolume = STREAMVOL_CREATE_FRUSTUM(<<456.8, -686.9, 28.5>>, CONVERT_ROTATION_TO_DIRECTION_VECTOR(<<-11.9,-1.6,-152.7>>), 15, FLAG_MAPDATA)
|
|
missionStreamingVolume = STREAMVOL_CREATE_FRUSTUM(<<456.5, -686.2, 28.9>>, CONVERT_ROTATION_TO_DIRECTION_VECTOR(<<-2.5,0.0,-178.1>>), 100, FLAG_MAPDATA)
|
|
|
|
iSlowDownTime = GET_GAME_TIMER()
|
|
crashTriggerState = CRASH_TRIGGER_SLOW_DOWN
|
|
ENDIF
|
|
ELSE
|
|
IF NOT IS_PED_IN_ANY_VEHICLE(PLAYER_PED_ID())
|
|
IF IS_ENTITY_AT_ENTITY(PLAYER_PED_ID(), runnerChaseProperties.ped, <<7,7,7>>)
|
|
IF NOT IS_ANY_CONVERSATION_ONGOING_OR_QUEUED()
|
|
IF DOES_ENTITY_EXIST(uberTrailerVehicle)
|
|
SET_VEHICLE_AS_NO_LONGER_NEEDED(uberTrailerVehicle)
|
|
ENDIF
|
|
CLEAR_MODEL_REQUEST(ENUM_TO_INT(HM_TRAILER))
|
|
SetpieceCarID[CRASH_BUS_ID] = NULL
|
|
|
|
bRunningCutscene = TRUE
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
BREAK
|
|
|
|
CASE CRASH_TRIGGER_SLOW_DOWN
|
|
REQUEST_ADDITIONAL_COLLISION_AT_COORD(<<457.7, -690.7, 27.7>>)
|
|
|
|
IF NOT bKilledSpeechAtCutscene
|
|
IF GET_GAME_TIMER() >= iSlowDownTime + 3000
|
|
KILL_ANY_CONVERSATION()
|
|
bDoneCrashReactionSpeech = TRUE
|
|
bKilledSpeechAtCutscene = TRUE
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF BRING_VEHICLE_TO_HALT_AND_DISABLE_VEH_CONTROLS(hoodVehicle[HV_FRANKLIN_VAN], 14.0)
|
|
AND bKnockedOffBike
|
|
AND NOT IS_ANY_CONVERSATION_ONGOING_OR_QUEUED()
|
|
bRunningCutscene = TRUE
|
|
ENDIF
|
|
BREAK
|
|
|
|
CASE CRASH_TRIGGER_GET_CHOP_OUT
|
|
BOOL bLaunchFootChase
|
|
bLaunchFootChase = FALSE
|
|
FLOAT fPhase
|
|
|
|
IF NOT bDoneGetOutCue
|
|
bDoneGetOutCue = TRIGGER_MISSION_MUSIC_EVENT("FRA0_CHASE_MID")
|
|
ENDIF
|
|
|
|
IF NOT bDoneGetChopSpeech
|
|
bDoneGetChopSpeech = DO_MISSION_SPEECH("FKN0_GOGET")
|
|
ENDIF
|
|
|
|
//IF IS_ENTITY_PLAYING_ANIM(PLAYER_PED_ID(), GET_HOOD_ANIM_DICT_AS_STRING(H_ANIM_DICT_DRIVE_HOME), "van_get_out_franklin")
|
|
IF IS_SYNCHRONIZED_SCENE_RUNNING(iSyncScene)
|
|
fPhase = GET_SYNCHRONIZED_SCENE_PHASE(iSyncScene)
|
|
IF fPhase >= 0
|
|
IF bDoneGetChopSpeech
|
|
IF NOT bDoneReleaseChopSpeech
|
|
IF fPhase >= 0.60
|
|
bDoneReleaseChopSpeech = DO_MISSION_SPEECH("FKN0_GOGET2")
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF NOT bClearedChopTask
|
|
IF fPhase >= 0.845
|
|
CLEAR_PED_TASKS_IMMEDIATELY(chopPed)
|
|
SET_ENTITY_COORDS(chopPed, <<457.75085, -686.55273, 26.77712>>)
|
|
SET_ENTITY_HEADING(chopPed, -24.2)
|
|
FORCE_PED_MOTION_STATE(chopPed, MS_ON_FOOT_SPRINT, TRUE, FAUS_CUTSCENE_EXIT)
|
|
TASK_FOLLOW_WAYPOINT_RECORDING(chopPed, "hood7", 7, EWAYPOINT_DO_NOT_RESPOND_TO_COLLISION_EVENTS | EWAYPOINT_NAVMESH_BACK_TO_WAYPOINT_IF_LEFT_ROUTE)
|
|
bClearedChopTask = TRUE
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ELSE
|
|
bLaunchFootChase = TRUE
|
|
ENDIF
|
|
SET_PED_MIN_MOVE_BLEND_RATIO(PLAYER_PED_ID(),PEDMOVE_SPRINT)
|
|
SET_PED_MIN_MOVE_BLEND_RATIO(chopPed,PEDMOVE_SPRINT)
|
|
|
|
IF IS_ENTITY_PLAYING_ANIM(hoodVehicle[HV_FRANKLIN_VAN], GET_HOOD_ANIM_DICT_AS_STRING(H_ANIM_DICT_DRIVE_HOME), "van_get_out_van")
|
|
FLOAT fVanPhase
|
|
fVanPhase = GET_ENTITY_ANIM_CURRENT_TIME(hoodVehicle[HV_FRANKLIN_VAN], GET_HOOD_ANIM_DICT_AS_STRING(H_ANIM_DICT_DRIVE_HOME), "van_get_out_van")
|
|
|
|
SWITCH iOpenVanDoorSoundStage
|
|
CASE 0
|
|
IF fVanPhase >= 0.16
|
|
PLAY_VEHICLE_DOOR_OPEN_SOUND(hoodVehicle[HV_FRANKLIN_VAN], 0)
|
|
PRINTSTRING("OPEN sound 1") printnl()
|
|
iOpenVanDoorSoundStage++
|
|
ENDIF
|
|
BREAK
|
|
CASE 1
|
|
IF fVanPhase >= 0.569
|
|
PLAY_VEHICLE_DOOR_OPEN_SOUND(hoodVehicle[HV_FRANKLIN_VAN], 3)
|
|
PRINTSTRING("OPEN sound 2") printnl()
|
|
iOpenVanDoorSoundStage++
|
|
ENDIF
|
|
BREAK
|
|
CASE 2
|
|
IF fVanPhase >= 0.581
|
|
//PLAY_VEHICLE_DOOR_CLOSE_SOUND(hoodVehicle[HV_FRANKLIN_VAN], 0)
|
|
PRINTSTRING("CLOSE sound 1") printnl()
|
|
iOpenVanDoorSoundStage++
|
|
ENDIF
|
|
BREAK
|
|
ENDSWITCH
|
|
ENDIF
|
|
|
|
IF bLaunchFootChase
|
|
//AND NOT bRunningCutscene
|
|
|
|
//ENDIF
|
|
ENDIF
|
|
BREAK
|
|
ENDSWITCH
|
|
ENDIF
|
|
ENDPROC
|
|
|
|
// knock runner off bike
|
|
PROC KNOCK_RUNNER_OFF_BIKE()
|
|
IF NOT bKnockedOffBike
|
|
//SET_ENTITY_ONLY_DAMAGED_BY_PLAYER(runnerChaseProperties.ped, FALSE)
|
|
SET_PED_CAN_BE_KNOCKED_OFF_VEHICLE(runnerChaseProperties.ped, KNOCKOFFVEHICLE_DEFAULT)
|
|
|
|
IF CAN_KNOCK_PED_OFF_VEHICLE(runnerChaseProperties.ped)
|
|
KNOCK_PED_OFF_VEHICLE(runnerChaseProperties.ped)
|
|
bPedOffBikeAI = FALSE
|
|
ELSE
|
|
bPedOffBikeAI = TRUE
|
|
ENDIF
|
|
|
|
IF IS_VEHICLE_DRIVEABLE(hoodVehicle[HV_BAD_GUY_BIKE])
|
|
SET_ENTITY_PROOFS(hoodVehicle[HV_BAD_GUY_BIKE], FALSE, FALSE, FALSE, FALSE, FALSE)
|
|
SET_DISABLE_VEHICLE_PETROL_TANK_FIRES(hoodVehicle[HV_BAD_GUY_BIKE], FALSE)
|
|
SET_VEHICLE_CAN_LEAK_OIL(hoodVehicle[HV_BAD_GUY_BIKE], TRUE)
|
|
SET_VEHICLE_CAN_LEAK_PETROL(hoodVehicle[HV_BAD_GUY_BIKE], TRUE)
|
|
ENDIF
|
|
|
|
REPLAY_RECORD_BACK_FOR_TIME(3.0)
|
|
|
|
iKnockOffBikeTime = GET_GAME_TIMER()
|
|
bKnockedOffBike = TRUE
|
|
ENDIF
|
|
ENDPROC
|
|
|
|
// request common models
|
|
PROC REQUEST_COMMON_MODELS_TO_VAN_AND_FOOT_CHASE()
|
|
IF streamingStage >= MISSION_STREAMING_STAGE_WAIT
|
|
OR createYardStage >= CREATE_YARD_STAGE_WAITING
|
|
ADD_MODEL_REQUEST(ENUM_TO_INT(HM_BUS))
|
|
ADD_MODEL_REQUEST(ENUM_TO_INT(HM_TRAFFIC_CAR1))
|
|
ENDIF
|
|
ENDPROC
|
|
|
|
// do crash cutscene
|
|
PROC DO_CRASH_CUTSCENE()
|
|
HANDLE_CRASH_TRIGGER()
|
|
SET_ALL_RANDOM_PEDS_FLEE_THIS_FRAME(PLAYER_ID())
|
|
|
|
SWITCH cutsceneStage
|
|
CASE H_CUT_STAGE_INIT
|
|
REQUEST_ADDITIONAL_COLLISION_AT_COORD(<<457.7, -690.7, 27.7>>)
|
|
|
|
SET_MISSION_CUTSCENE(TRUE, TRUE, -1, TRUE, FALSE)
|
|
crashTriggerState = CRASH_TRIGGER_GET_CHOP_OUT
|
|
//CREATE_CAM_ATTACHED_TO_VAN(VAN_CAMERA_FRONT)
|
|
|
|
KILL_CHASE_HINT_CAM(localChaseHintCamStruct)
|
|
CREATE_MISSION_ANIM_CAM()
|
|
iSyncScene = CREATE_SYNCHRONIZED_SCENE(<<0,0,0>>, <<0,0,0>>)
|
|
IF IS_VEHICLE_DRIVEABLE(hoodVehicle[HV_FRANKLIN_VAN])
|
|
ATTACH_SYNCHRONIZED_SCENE_TO_ENTITY(iSyncScene, hoodVehicle[HV_FRANKLIN_VAN], GET_ENTITY_BONE_INDEX_BY_NAME(hoodVehicle[HV_FRANKLIN_VAN], "seat_dside_f"))
|
|
PLAY_SYNCHRONIZED_CAM_ANIM(animCam, iSyncScene, "VAN_GET_OUT_CAM", GET_HOOD_ANIM_DICT_AS_STRING(H_ANIM_DICT_DRIVE_HOME))
|
|
ENDIF
|
|
SET_SYNCHRONIZED_SCENE_HOLD_LAST_FRAME(iSyncScene, FALSE)
|
|
|
|
IF NOT IS_ENTITY_DEAD(hoodVehicle[HV_BAD_GUY_BIKE])
|
|
IF IS_ENTITY_IN_AREA(hoodVehicle[HV_BAD_GUY_BIKE], <<457.70029, -684.90436, 26.79034>>, <<463.63626, -670.48119, 26.35947>>, FALSE, FALSE)
|
|
VECTOR vSetCoords
|
|
vSetCoords = GET_ENTITY_COORDS(hoodVehicle[HV_BAD_GUY_BIKE]) + <<1.2,0,0>>
|
|
vSetCoords.z = 26.5919
|
|
|
|
SET_ENTITY_COORDS_NO_OFFSET(hoodVehicle[HV_BAD_GUY_BIKE], vSetCoords)
|
|
SET_ENTITY_ROTATION(hoodVehicle[HV_BAD_GUY_BIKE], << 0.0150743, 85.4796, 10.1482 >>)
|
|
SET_ENTITY_VELOCITY(hoodVehicle[HV_BAD_GUY_BIKE], <<0,0,0>>)
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF IS_VEHICLE_DRIVEABLE(hoodVehicle[HV_FRANKLIN_VAN])
|
|
AND NOT IS_PED_INJURED(PLAYER_PED_ID())
|
|
AND NOT IS_PED_INJURED(chopPed)
|
|
AND NOT IS_PED_INJURED(lamarPed)
|
|
AND NOT IS_PED_INJURED(runnerChaseProperties.ped)
|
|
CLEANUP_UBER_PLAYBACK(TRUE)
|
|
CLEAR_AREA_OF_VEHICLES(<<458.02, -691.40, 27.46>>, 400, TRUE)
|
|
CLEAR_AREA(<<457.75021, -692.06537, 26.66529>>, 8.0, TRUE)
|
|
CLEAR_AREA_OF_PROJECTILES(<<456.80389, -689.57758, 26.84026>>, 26)
|
|
STOP_FIRE_IN_RANGE(<<456.80389, -689.57758, 26.84026>>, 26)
|
|
REMOVE_PARTICLE_FX_IN_RANGE(<<456.80389, -689.57758, 26.84026>>, 26)
|
|
|
|
STOP_VEHICLE_FIRE(hoodVehicle[HV_FRANKLIN_VAN])
|
|
|
|
SET_HOOD_ROADS_OFF(TRUE, TRUE)
|
|
ENABLE_CARGENS_FOR_MISSION(FALSE)
|
|
|
|
SET_ENTITY_COORDS(hoodVehicle[HV_FRANKLIN_VAN], <<458.02, -691.40, 26.70>>)
|
|
SET_ENTITY_HEADING(hoodVehicle[HV_FRANKLIN_VAN], -13.4)
|
|
SET_VEHICLE_ON_GROUND_PROPERLY(hoodVehicle[HV_FRANKLIN_VAN])
|
|
|
|
iSyncScene = CREATE_SYNCHRONIZED_SCENE(<<0,0,0>>, <<0,0,0>>)
|
|
ATTACH_SYNCHRONIZED_SCENE_TO_ENTITY(iSyncScene, hoodVehicle[HV_FRANKLIN_VAN], 0)
|
|
|
|
SET_ENTITY_COORDS(PLAYER_PED_ID(), GET_ENTITY_COORDS(PLAYER_PED_ID()))
|
|
//ATTACH_ENTITY_TO_ENTITY(PLAYER_PED_ID(), hoodVehicle[HV_FRANKLIN_VAN], 0, GET_ANIM_INITIAL_OFFSET_POSITION(GET_HOOD_ANIM_DICT_AS_STRING(H_ANIM_DICT_DRIVE_HOME), "van_get_out_franklin", <<0,0,0>>, <<0,0,0>>, 0), GET_ANIM_INITIAL_OFFSET_ROTATION(GET_HOOD_ANIM_DICT_AS_STRING(H_ANIM_DICT_DRIVE_HOME), "van_get_out_franklin", <<0,0,0>>, <<0,0,0>>, 0), FALSE, FALSE, FALSE, TRUE)
|
|
//TASK_PLAY_ANIM(PLAYER_PED_ID(), GET_HOOD_ANIM_DICT_AS_STRING(H_ANIM_DICT_DRIVE_HOME), "van_get_out_franklin", INSTANT_BLEND_IN, NORMAL_BLEND_OUT, -1, AF_TAG_SYNC_OUT)
|
|
TASK_SYNCHRONIZED_SCENE(PLAYER_PED_ID(), iSyncScene, GET_HOOD_ANIM_DICT_AS_STRING(H_ANIM_DICT_DRIVE_HOME), "VAN_GET_OUT_FRANKLIN", INSTANT_BLEND_IN, NORMAL_BLEND_OUT, SYNCED_SCENE_TAG_SYNC_OUT)
|
|
FORCE_PED_AI_AND_ANIMATION_UPDATE(PLAYER_PED_ID())
|
|
|
|
SET_ENTITY_COORDS(lamarPed, GET_ENTITY_COORDS(lamarPed))
|
|
//ATTACH_ENTITY_TO_ENTITY(lamarPed, hoodVehicle[HV_FRANKLIN_VAN], 0, GET_ANIM_INITIAL_OFFSET_POSITION(GET_HOOD_ANIM_DICT_AS_STRING(H_ANIM_DICT_DRIVE_HOME), "van_get_out_lamar", <<0,0,0>>, <<0,0,0>>, 0), GET_ANIM_INITIAL_OFFSET_ROTATION(GET_HOOD_ANIM_DICT_AS_STRING(H_ANIM_DICT_DRIVE_HOME), "van_get_out_lamar", <<0,0,0>>, <<0,0,0>>, 0), FALSE, FALSE, FALSE, TRUE)
|
|
//TASK_PLAY_ANIM(lamarPed, GET_HOOD_ANIM_DICT_AS_STRING(H_ANIM_DICT_DRIVE_HOME), "van_get_out_lamar", INSTANT_BLEND_IN, NORMAL_BLEND_OUT, -1)
|
|
TASK_SYNCHRONIZED_SCENE(lamarPed, iSyncScene, GET_HOOD_ANIM_DICT_AS_STRING(H_ANIM_DICT_DRIVE_HOME), "van_get_out_lamar", INSTANT_BLEND_IN, NORMAL_BLEND_OUT, SYNCED_SCENE_TAG_SYNC_OUT)
|
|
FORCE_PED_AI_AND_ANIMATION_UPDATE(lamarPed)
|
|
|
|
DETACH_ENTITY(chopPed)
|
|
///ATTACH_ENTITY_TO_ENTITY(chopPed, hoodVehicle[HV_FRANKLIN_VAN], 0, GET_ANIM_INITIAL_OFFSET_POSITION(GET_HOOD_ANIM_DICT_AS_STRING(H_ANIM_DICT_DRIVE_HOME), "van_get_out_chop", <<0,0,0>>, <<0,0,0>>, 0), GET_ANIM_INITIAL_OFFSET_ROTATION(GET_HOOD_ANIM_DICT_AS_STRING(H_ANIM_DICT_DRIVE_HOME), "van_get_out_chop", <<0,0,0>>, <<0,0,0>>, 0), FALSE, FALSE, FALSE, TRUE)
|
|
//TASK_PLAY_ANIM(chopPed, GET_HOOD_ANIM_DICT_AS_STRING(H_ANIM_DICT_DRIVE_HOME), "van_get_out_chop", INSTANT_BLEND_IN, NORMAL_BLEND_OUT, -1, AF_TAG_SYNC_OUT)
|
|
TASK_SYNCHRONIZED_SCENE(chopPed, iSyncScene, GET_HOOD_ANIM_DICT_AS_STRING(H_ANIM_DICT_DRIVE_HOME), "van_get_out_chop", INSTANT_BLEND_IN, NORMAL_BLEND_OUT, SYNCED_SCENE_TAG_SYNC_OUT)
|
|
FORCE_PED_AI_AND_ANIMATION_UPDATE(chopPed)
|
|
|
|
CLEAR_PED_TASKS_IMMEDIATELY(runnerChaseProperties.ped)
|
|
SET_ENTITY_COORDS(runnerChaseProperties.ped, <<465.88248, -677.43469, 26.25079>>)
|
|
SET_ENTITY_HEADING(runnerChaseProperties.ped, 23.7)
|
|
|
|
SET_VEHICLE_DOOR_LATCHED(hoodVehicle[HV_FRANKLIN_VAN], SC_DOOR_FRONT_LEFT, TRUE, TRUE, FALSE)
|
|
PLAY_ENTITY_ANIM(hoodVehicle[HV_FRANKLIN_VAN], "van_get_out_van", GET_HOOD_ANIM_DICT_AS_STRING(H_ANIM_DICT_DRIVE_HOME), INSTANT_BLEND_IN, FALSE, FALSE)
|
|
FORCE_ENTITY_AI_AND_ANIMATION_UPDATE(hoodVehicle[HV_FRANKLIN_VAN])
|
|
|
|
SET_SYNCHRONIZED_SCENE_HOLD_LAST_FRAME(iSyncScene, FALSE)
|
|
|
|
STOP_HOOD_AUDIO_SCENE(HOOD_AUDIO_SCENE_FOCUS_CAM)
|
|
STOP_HOOD_AUDIO_SCENE(HOOD_AUDIO_SCENE_CAR_CHASE)
|
|
START_HOOD_AUDIO_SCENE(HOOD_AUDIO_SCENE_FOOT_CHASE_START)
|
|
|
|
IF STREAMVOL_IS_VALID(missionStreamingVolume)
|
|
STREAMVOL_DELETE(missionStreamingVolume)
|
|
ENDIF
|
|
|
|
REPLAY_START_EVENT(REPLAY_IMPORTANCE_HIGHEST)
|
|
|
|
iHoodCutsceneTime = GET_GAME_TIMER()
|
|
cutsceneStage = H_CUT_STAGE_RUNNING
|
|
ENDIF
|
|
BREAK
|
|
|
|
CASE H_CUT_STAGE_RUNNING
|
|
IF NOT bAllowRunnerMovement
|
|
IF GET_GAME_TIMER() >= iHoodCutsceneTime + 3800
|
|
bAllowRunnerMovement = TRUE
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF NOT IS_SYNCHRONIZED_SCENE_RUNNING(iSyncScene)
|
|
REPLAY_STOP_EVENT()
|
|
COMMON_MISSION_CUTSCENE_BLENDOUT(10, CAM_SPLINE_SLOW_IN_SMOOTH)
|
|
SET_MISSION_STAGE(STAGE_FOOT_CHASE, FALSE, FALSE, FALSE)
|
|
bRunningCutscene = FALSE
|
|
ENDIF
|
|
BREAK
|
|
|
|
CASE H_CUT_STAGE_CLEANUP
|
|
REPLAY_STOP_EVENT()
|
|
//SET_MISSION_CUTSCENE(FALSE, TRUE, -1, TRUE, FALSE)
|
|
BREAK
|
|
ENDSWITCH
|
|
ENDPROC
|
|
|
|
// car chase to the bus station
|
|
PROC DO_STAGE_VAN_CHASE()
|
|
IF NOT bRunningCutscene
|
|
DISABLE_CONTROL_ACTION(FRONTEND_CONTROL, INPUT_SKIP_CUTSCENE)
|
|
REQUEST_COMMON_MODELS_TO_VAN_AND_FOOT_CHASE()
|
|
|
|
IF NOT bDoneFocusOnBikeAudioScene
|
|
IF IS_GAMEPLAY_HINT_ACTIVE()
|
|
bDoneFocusOnBikeAudioScene = START_HOOD_AUDIO_SCENE(HOOD_AUDIO_SCENE_FOCUS_CAM)
|
|
ENDIF
|
|
ELSE
|
|
IF NOT IS_GAMEPLAY_HINT_ACTIVE()
|
|
STOP_HOOD_AUDIO_SCENE(HOOD_AUDIO_SCENE_FOCUS_CAM)
|
|
bDoneFocusOnBikeAudioScene = FALSE
|
|
ENDIF
|
|
ENDIF
|
|
|
|
// ped density in alley
|
|
//IF IS_ENTITY_AT_COORD(PLAYER_PED_ID(), <<457.31238, -769.91650, 26.35762>>, <<150, 150, 150>>, FALSE, FALSE)
|
|
//SET_SCENARIO_PED_DENSITY_MULTIPLIER_THIS_FRAME(1.0, 0.5)
|
|
// SET_PED_DENSITY_MULTIPLIER_THIS_FRAME(0.8)
|
|
// ENDIF
|
|
|
|
// get rid of girl
|
|
IF NOT bRemovedGirl
|
|
IF NOT IS_ENTITY_AT_COORD(PLAYER_PED_ID(), GET_HOOD_VECTOR(HVEC_GIRL_INIT), <<80, 80, 80>>, FALSE, FALSE)
|
|
IF DOES_ENTITY_EXIST(girlPed)
|
|
SET_PED_AS_NO_LONGER_NEEDED(girlPed)
|
|
ENDIF
|
|
CLEAR_MODEL_REQUEST(ENUM_TO_INT(HM_GIRL))
|
|
bRemovedGirl = TRUE
|
|
ENDIF
|
|
ENDIF
|
|
|
|
// chop bark as you approach
|
|
IF NOT bStoppedChopExcitement
|
|
IF NOT IS_PED_INJURED(chopPed)
|
|
AND NOT IS_PED_INJURED(lamarPed)
|
|
IF IS_ENTITY_AT_ENTITY(lamarPed, chopPed, <<14,14,14>>, FALSE, FALSE)
|
|
IF NOT IS_TRACKED_PED_VISIBLE(chopPed)
|
|
printstring("not visible") printnl()
|
|
IF GET_GAME_TIMER() >= iNextChopExcitementTime
|
|
STOP_PED_SPEAKING(chopPed, FALSE)
|
|
IF GET_RANDOM_INT_IN_RANGE(0,2) = 0
|
|
PLAY_ANIMAL_VOCALIZATION(chopPed, AUD_ANIMAL_DOG_ROTTWEILER, "BARK")
|
|
ELSE
|
|
PLAY_ANIMAL_VOCALIZATION(chopPed, AUD_ANIMAL_DOG_ROTTWEILER, "BARK_SEQ")
|
|
ENDIF
|
|
STOP_PED_SPEAKING(chopPed, TRUE)
|
|
iNextChopExcitementTime = GET_GAME_TIMER() + GET_RANDOM_INT_IN_RANGE(200, 1000)
|
|
ENDIF
|
|
ELSE
|
|
printstring("is visible") printnl()
|
|
STOP_PED_SPEAKING(chopPed, FALSE)
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
|
|
// create the setpieces
|
|
SWITCH createYardStage
|
|
CASE CREATE_YARD_STAGE_NOT_STARTED
|
|
//IF IS_ENTITY_AT_COORD(PLAYER_PED_ID(), <<460.50562, -660.79364, 26.42570>>, <<200,200,200>>, FALSE, FALSE)
|
|
IF IS_ENTITY_IN_AREA(PLAYER_PED_ID(), <<394.53989, -869.11523, 20.28647>>, <<652.68286, -666.74109, 54.06824>>)
|
|
OR IS_ENTITY_IN_AREA(PLAYER_PED_ID(), <<277.28827, -831.68213, 20.24340>>, <<390.69489, -646.09259, 54.50041>>)
|
|
//ADD_MODEL_REQUEST(ENUM_TO_INT(HM_TRAFFIC_CAR1))
|
|
//ADD_MODEL_REQUEST(ENUM_TO_INT(HM_TRAFFIC_CAR2))
|
|
ADD_MODEL_REQUEST(ENUM_TO_INT(HM_BUS))
|
|
ADD_MODEL_REQUEST(ENUM_TO_INT(HM_WORKER))
|
|
// ADD_MODEL_REQUEST(ENUM_TO_INT(HM_ENGINE))
|
|
// ADD_MODEL_REQUEST(ENUM_TO_INT(HM_TANKER_CARRIAGE))
|
|
// ADD_MODEL_REQUEST(ENUM_TO_INT(HM_CONTAINER_CARRIAGE))
|
|
// ADD_RECORDING_REQUEST(002)
|
|
// ADD_RECORDING_REQUEST(007)
|
|
// ADD_RECORDING_REQUEST(006)
|
|
ADD_RECORDING_REQUEST(011)
|
|
ADD_RECORDING_REQUEST(001)
|
|
//ADD_RECORDING_REQUEST(005)
|
|
ADD_RECORDING_REQUEST(012)
|
|
createYardStage = CREATE_YARD_STAGE_WAITING
|
|
ENDIF
|
|
BREAK
|
|
CASE CREATE_YARD_STAGE_WAITING
|
|
//IF HAS_MODEL_LOADED(GET_MODEL_FOR_HOOD_MODEL_ENUM(HM_TRAFFIC_CAR1))
|
|
//AND HAS_MODEL_LOADED(GET_MODEL_FOR_HOOD_MODEL_ENUM(HM_TRAFFIC_CAR2))
|
|
IF HAS_MODEL_LOADED(GET_MODEL_FOR_HOOD_MODEL_ENUM(HM_BUS))
|
|
AND HAS_MODEL_LOADED(GET_MODEL_FOR_HOOD_MODEL_ENUM(HM_WORKER))
|
|
//AND HAS_MODEL_LOADED(GET_MODEL_FOR_HOOD_MODEL_ENUM(HM_ENGINE))
|
|
//AND HAS_MODEL_LOADED(GET_MODEL_FOR_HOOD_MODEL_ENUM(HM_TANKER_CARRIAGE))
|
|
//AND HAS_MODEL_LOADED(GET_MODEL_FOR_HOOD_MODEL_ENUM(HM_CONTAINER_CARRIAGE))
|
|
//AND HAS_VEHICLE_RECORDING_BEEN_LOADED(002, GET_HOOD_RECORDING_PREFIX())
|
|
//AND HAS_VEHICLE_RECORDING_BEEN_LOADED(007, GET_HOOD_RECORDING_PREFIX())
|
|
//AND HAS_VEHICLE_RECORDING_BEEN_LOADED(006, GET_HOOD_RECORDING_PREFIX())
|
|
AND HAS_VEHICLE_RECORDING_BEEN_LOADED(011, GET_HOOD_RECORDING_PREFIX())
|
|
AND HAS_VEHICLE_RECORDING_BEEN_LOADED(001, GET_HOOD_RECORDING_PREFIX())
|
|
//AND HAS_VEHICLE_RECORDING_BEEN_LOADED(005, GET_HOOD_RECORDING_PREFIX())
|
|
AND HAS_VEHICLE_RECORDING_BEEN_LOADED(012, GET_HOOD_RECORDING_PREFIX())
|
|
CREATE_CHASE_SETPIECES(FALSE, FALSE, FALSE, TRUE, TRUE)
|
|
createYardStage = CREATE_YARD_STAGE_DONE
|
|
ENDIF
|
|
BREAK
|
|
ENDSWITCH
|
|
|
|
IF NOT bClearedPlayerRun
|
|
IF GET_GAME_TIMER() >= iStageStartTime + 1000
|
|
bClearedPlayerRun = TRUE
|
|
ELSE
|
|
IF GET_FOLLOW_PED_CAM_VIEW_MODE() <> CAM_VIEW_MODE_FIRST_PERSON
|
|
SET_PED_MIN_MOVE_BLEND_RATIO(PLAYER_PED_ID(), PEDMOVE_RUN)
|
|
ENDIF
|
|
IF NOT IS_PED_INJURED(chopPed)
|
|
SET_PED_MIN_MOVE_BLEND_RATIO(chopPed,PEDMOVE_SPRINT)
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
|
|
// chop
|
|
IF crashTriggerState < CRASH_TRIGGER_GET_CHOP_OUT
|
|
HANDLE_CHOP_LEAN_IN_VAN(chopPed, hoodVehicle[HV_FRANKLIN_VAN], chopLeanInVanState, fCachedVanSpeed, iNextChopAnimTime, iNextBarkTime, TRUE)
|
|
ENDIF
|
|
|
|
IF NOT bKnockedOffBike
|
|
IF NOT IS_PED_INJURED(runnerChaseProperties.ped)
|
|
IF NOT IS_PED_IN_ANY_VEHICLE(runnerChaseProperties.ped)
|
|
APPLY_DAMAGE_TO_PED(runnerChaseProperties.ped, 1000, TRUE)
|
|
ELSE
|
|
IF HAS_ENTITY_BEEN_DAMAGED_BY_ENTITY(runnerChaseProperties.ped, PLAYER_PED_ID())
|
|
IF CAN_KNOCK_PED_OFF_VEHICLE(runnerChaseProperties.ped)
|
|
KNOCK_PED_OFF_VEHICLE(runnerChaseProperties.ped)
|
|
ELSE
|
|
SET_PED_CAN_BE_KNOCKED_OFF_VEHICLE(runnerChaseProperties.ped, KNOCKOFFVEHICLE_DEFAULT)
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF IS_VEHICLE_DRIVEABLE(hoodVehicle[HV_BAD_GUY_BIKE])
|
|
AND IS_VEHICLE_DRIVEABLE(hoodVehicle[HV_FRANKLIN_VAN])
|
|
AND NOT IS_PED_INJURED(runnerChaseProperties.ped)
|
|
AND NOT IS_PED_INJURED(lamarPed)
|
|
CONTROL_VEHICLE_CHASE_HINT_CAM_IN_VEHICLE(localChaseHintCamStruct, hoodVehicle[HV_BAD_GUY_BIKE]) //temp, remove
|
|
|
|
// lamar run to van
|
|
IF NOT bTempLamarvan
|
|
IF IS_ENTITY_AT_COORD(lamarPed, GET_HOOD_VECTOR(HVEC_LAMAR_SPRINT_TO_VAN), <<2.0,2.0,3>>)
|
|
TASK_ENTER_VEHICLE(lamarPed, hoodVehicle[HV_FRANKLIN_VAN], DEFAULT_TIME_BEFORE_WARP, VS_FRONT_RIGHT)
|
|
SET_PED_MIN_MOVE_BLEND_RATIO(lamarPed, PEDMOVE_RUN)
|
|
bTempLamarvan = TRUE
|
|
ELSE
|
|
SET_PED_MOVE_RATE_OVERRIDE(lamarPed, 1.15)
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF NOT bResetDirectEntryFlag
|
|
IF IS_PED_IN_VEHICLE(lamarPed, hoodVehicle[HV_FRANKLIN_VAN])
|
|
REMOVE_PED_FROM_GROUP(lamarPed)
|
|
SET_PED_CONFIG_FLAG(PLAYER_PED_ID(), PCF_ForceDirectEntry, FALSE)
|
|
bResetDirectEntryFlag = TRUE
|
|
ENDIF
|
|
ENDIF
|
|
|
|
// handle the chase
|
|
IF IS_PLAYBACK_GOING_ON_FOR_VEHICLE(hoodVehicle[HV_BAD_GUY_BIKE])
|
|
FLOAT fPlaybackTime = GET_TIME_POSITION_IN_RECORDING(hoodVehicle[HV_BAD_GUY_BIKE])
|
|
VECTOR vPlayerPos = GET_ENTITY_COORDS(PLAYER_PED_ID())
|
|
HANDLE_CHASE_SPEED(fPlaybackTime)
|
|
|
|
IF crashTriggerState = CRASH_TRIGGER_WAITING
|
|
UPDATE_UBER_PLAYBACK(hoodVehicle[HV_BAD_GUY_BIKE], fCarChaseSpeed)
|
|
ENDIF
|
|
//PRINTSTRING("speed = ") PRINTFLOAT(fCarChaseSpeed) PRINTNL() PRINTNL()
|
|
//PRINTSTRING("time = ") PRINTFLOAT(fPlaybackTime) PRINTNL()
|
|
|
|
IF fPlaybackTime >= 66300
|
|
SET_VEHICLE_BRAKE_LIGHTS(hoodVehicle[HV_BAD_GUY_BIKE], FALSE)
|
|
ENDIF
|
|
|
|
// load worker
|
|
IF fPlaybackTime >= 55000
|
|
AND createYardStage = CREATE_YARD_STAGE_DONE
|
|
IF NOT bSetWorkerDefault
|
|
SET_UBER_PLAYBACK_DEFAULT_PED_MODEL(GET_MODEL_FOR_HOOD_MODEL_ENUM(HM_WORKER))
|
|
SET_FORCE_UBER_PLAYBACK_TO_USE_DEFAULT_PED_MODEL(TRUE)
|
|
SET_UBER_PLAYBACK_TO_CLEANUP_DEFAULT_PED_MODEL(FALSE)
|
|
bSetWorkerDefault = TRUE
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF NOT bSetIssiNoCollision
|
|
IF IS_VEHICLE_DRIVEABLE(trafficCarID[33])
|
|
SET_ENTITY_NO_COLLISION_ENTITY(trafficCarID[33], hoodVehicle[HV_BAD_GUY_BIKE], FALSE)
|
|
bSetIssiNoCollision = TRUE
|
|
PRINTSTRING("set issi no collision") PRINTNL()
|
|
ENDIF
|
|
ENDIF
|
|
|
|
// knock off
|
|
IF NOT bDoneBusSmash
|
|
BOOL bDoBusSmash = FALSE
|
|
|
|
IF IS_VEHICLE_DRIVEABLE(SetpieceCarID[CRASH_BUS_ID])
|
|
IF IS_ENTITY_TOUCHING_ENTITY(hoodVehicle[HV_BAD_GUY_BIKE], SetpieceCarID[CRASH_BUS_ID])
|
|
bDoBusSmash = TRUE
|
|
ENDIF
|
|
ENDIF
|
|
IF fPlaybackTime >= 73092//600
|
|
bDoBusSmash = TRUE
|
|
ENDIF
|
|
|
|
IF bDoBusSmash
|
|
IF IS_PLAYBACK_GOING_ON_FOR_VEHICLE(hoodVehicle[HV_BAD_GUY_BIKE])
|
|
STOP_PLAYBACK_RECORDED_VEHICLE(hoodVehicle[HV_BAD_GUY_BIKE])
|
|
ENDIF
|
|
//APPLY_FORCE_TO_ENTITY(hoodVehicle[HV_BAD_GUY_BIKE], APPLY_TYPE_IMPULSE, <<20,-5,0>>, <<0,0,2>>, 0, FALSE, TRUE, TRUE)
|
|
//iBusSmashTime = GET_GAME_TIMER()
|
|
bDoneBusSmash = TRUE
|
|
ENDIF
|
|
ELSE
|
|
IF IS_VEHICLE_DRIVEABLE(SetpieceCarID[CRASH_BUS_ID])
|
|
IF NOT bPausedCrashBus
|
|
IF IS_PLAYBACK_GOING_ON_FOR_VEHICLE(SetpieceCarID[CRASH_BUS_ID])
|
|
IF SetpieceCarProgress[CRASH_BUS_ID] = 4
|
|
//SetpieceCarProgress[CRASH_BUS_ID] = 75
|
|
bPausedCrashBus = TRUE
|
|
ENDIF
|
|
ENDIF
|
|
ELSE
|
|
IF IS_VEHICLE_DRIVEABLE(SetpieceCarID[CRASH_BUS_ID])
|
|
BRING_VEHICLE_TO_HALT(SetpieceCarID[CRASH_BUS_ID], 2, 1)
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
|
|
// pass the crash bus over to the foot chase
|
|
IF NOT DOES_ENTITY_EXIST(yardVehicle[YV_BUS_ROAD_FROM_LEFT])
|
|
IF DOES_ENTITY_EXIST(SetpieceCarID[CRASH_BUS_ID])
|
|
yardVehicle[YV_BUS_ROAD_FROM_LEFT] = SetpieceCarID[CRASH_BUS_ID]
|
|
IF IS_VEHICLE_DRIVEABLE(yardVehicle[YV_BUS_ROAD_FROM_LEFT])
|
|
SET_VEHICLE_DOORS_LOCKED(yardVehicle[YV_BUS_ROAD_FROM_LEFT], VEHICLELOCK_LOCKOUT_PLAYER_ONLY)
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
IF NOT DOES_ENTITY_EXIST(driverPed[YV_BUS_ROAD_FROM_LEFT])
|
|
IF IS_VEHICLE_DRIVEABLE(yardVehicle[YV_BUS_ROAD_FROM_LEFT])
|
|
PED_INDEX busDriverPed = GET_PED_IN_VEHICLE_SEAT(yardVehicle[YV_BUS_ROAD_FROM_LEFT])
|
|
IF NOT IS_PED_INJURED(busDriverPed)
|
|
SET_ENTITY_AS_MISSION_ENTITY(busDriverPed, TRUE, TRUE)
|
|
driverPed[YV_BUS_ROAD_FROM_LEFT] = busDriverPed
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
|
|
// handle the blocking bus
|
|
CONST_INT BLOCKING_TRAFFIC_ID 12
|
|
printint(SetpieceCarProgress[BLOCKING_TRAFFIC_ID]) printnl()
|
|
|
|
IF IS_VEHICLE_DRIVEABLE(SetpieceCarID[BLOCKING_TRAFFIC_ID])
|
|
printstring("here1") printnl()
|
|
IF NOT bPausedBlockingTraffic
|
|
printstring("here2") printnl()
|
|
IF IS_PLAYBACK_GOING_ON_FOR_VEHICLE(SetpieceCarID[BLOCKING_TRAFFIC_ID])
|
|
printstring("here3") printnl()
|
|
IF SetpieceCarProgress[BLOCKING_TRAFFIC_ID] = 4
|
|
printstring("here4") printnl()
|
|
bPausedBlockingTraffic = TRUE
|
|
ENDIF
|
|
ELSE
|
|
IF SetpieceCarProgress[BLOCKING_TRAFFIC_ID] >= 3
|
|
bPausedBlockingTraffic = TRUE
|
|
ENDIF
|
|
ENDIF
|
|
ELSE
|
|
printstring("here5") printnl()
|
|
BRING_VEHICLE_TO_HALT(SetpieceCarID[BLOCKING_TRAFFIC_ID], 2, 1)
|
|
ENDIF
|
|
ENDIF
|
|
|
|
// handle the static bus
|
|
CONST_INT STATIC_TRAFFIC_ID 13
|
|
IF IS_VEHICLE_DRIVEABLE(SetpieceCarID[STATIC_TRAFFIC_ID])
|
|
IF NOT IS_PLAYBACK_GOING_ON_FOR_VEHICLE(SetpieceCarID[STATIC_TRAFFIC_ID])
|
|
BRING_VEHICLE_TO_HALT(SetpieceCarID[STATIC_TRAFFIC_ID], 2, 1)
|
|
ENDIF
|
|
ENDIF
|
|
|
|
// handle the uber trailer
|
|
CONST_INT TRAILER_CAB_TRAFFIC_ID 42
|
|
CONST_INT TRAILER_RECORDING 43
|
|
SWITCH uberTrailerState
|
|
CASE UBER_TRAILER_NOT_CREATED
|
|
// start streaming
|
|
IF fPlaybackTime >= 50000
|
|
ADD_MODEL_REQUEST(ENUM_TO_INT(HM_TRAILER))
|
|
//REQUEST_VEHICLE_RECORDING(TRAILER_RECORDING, GET_HOOD_UBER_RECORDING_PREFIX())
|
|
uberTrailerState = UBER_TRAILER_STREAMING
|
|
ENDIF
|
|
BREAK
|
|
CASE UBER_TRAILER_STREAMING
|
|
IF bModelRequestTracker[HM_TRAILER]
|
|
IF HAS_MODEL_LOADED(GET_MODEL_FOR_HOOD_MODEL_ENUM(HM_TRAILER))
|
|
//AND HAS_VEHICLE_RECORDING_BEEN_LOADED(TRAILER_RECORDING, GET_HOOD_UBER_RECORDING_PREFIX())
|
|
AND IS_VEHICLE_DRIVEABLE(TrafficCarID[TRAILER_CAB_TRAFFIC_ID])
|
|
//IF IS_PLAYBACK_GOING_ON_FOR_VEHICLE(TrafficCarID[TRAILER_CAB_TRAFFIC_ID])
|
|
uberTrailerVehicle = CREATE_VEHICLE(GET_MODEL_FOR_HOOD_MODEL_ENUM(HM_TRAILER), <<396.0168,-854.3585,31.0555>>, 93.05)
|
|
ATTACH_VEHICLE_TO_TRAILER(TrafficCarID[TRAILER_CAB_TRAFFIC_ID], uberTrailerVehicle)
|
|
//START_PLAYBACK_RECORDED_VEHICLE(uberTrailerVehicle, TRAILER_RECORDING, GET_HOOD_UBER_RECORDING_PREFIX())
|
|
//SKIP_TIME_IN_PLAYBACK_RECORDED_VEHICLE(uberTrailerVehicle, GET_TIME_POSITION_IN_RECORDING(TrafficCarID[TRAILER_CAB_TRAFFIC_ID]))
|
|
//SET_PLAYBACK_SPEED(uberTrailerVehicle, fCarChaseSpeed)
|
|
//SET_POSITION_OFFSET_FOR_RECORDED_VEHICLE_PLAYBACK(uberTrailerVehicle, <<0.5,-0.1,-0.25>>)
|
|
uberTrailerState = UBER_TRAILER_CREATED
|
|
//ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
BREAK
|
|
CASE UBER_TRAILER_CREATED
|
|
IF DOES_ENTITY_EXIST(uberTrailerVehicle)
|
|
IF IS_VEHICLE_DRIVEABLE(uberTrailerVehicle)
|
|
IF IS_PLAYBACK_GOING_ON_FOR_VEHICLE(uberTrailerVehicle)
|
|
IF IS_VEHICLE_DRIVEABLE(TrafficCarID[TRAILER_CAB_TRAFFIC_ID])
|
|
IF IS_PLAYBACK_GOING_ON_FOR_VEHICLE(TrafficCarID[TRAILER_CAB_TRAFFIC_ID])
|
|
SET_PLAYBACK_SPEED(uberTrailerVehicle, fCarChaseSpeed)
|
|
ELSE
|
|
STOP_PLAYBACK_RECORDED_VEHICLE(uberTrailerVehicle)
|
|
ENDIF
|
|
ELSE
|
|
STOP_PLAYBACK_RECORDED_VEHICLE(uberTrailerVehicle)
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
IF NOT DOES_ENTITY_EXIST(TrafficCarID[TRAILER_CAB_TRAFFIC_ID])
|
|
SET_VEHICLE_AS_NO_LONGER_NEEDED(uberTrailerVehicle)
|
|
CLEAR_MODEL_REQUEST(ENUM_TO_INT(HM_TRAILER))
|
|
uberTrailerState = UBER_TRAILER_REMOVED
|
|
ENDIF
|
|
ENDIF
|
|
BREAK
|
|
ENDSWITCH
|
|
|
|
// handle speed up in alley
|
|
IF NOT bSpeedUpBikeInAlley
|
|
IF fPlaybackTime >= 65000
|
|
IF vPlayerPos.x >= 420.49
|
|
bSpeedUpBikeInAlley = TRUE
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
|
|
// check distance
|
|
CONST_FLOAT VAN_CHASE_FAIL_DISTANCE 300.0
|
|
FLOAT fDistanceToBadGuy = GET_DISTANCE_BETWEEN_ENTITIES(PLAYER_PED_ID(), hoodVehicle[HV_BAD_GUY_BIKE])
|
|
UPDATE_CHASE_BLIP(badGuyCarBlip, hoodVehicle[HV_BAD_GUY_BIKE], VAN_CHASE_FAIL_DISTANCE)
|
|
IF fDistanceToBadGuy >= VAN_CHASE_FAIL_DISTANCE
|
|
IF DOES_BLIP_EXIST(badGuyCarBlip)
|
|
REMOVE_BLIP(badGuyCarBlip)
|
|
ENDIF
|
|
IF DOES_BLIP_EXIST(runnerBlip)
|
|
REMOVE_BLIP(runnerBlip)
|
|
ENDIF
|
|
MISSION_FAILED(FAIL_LOST_BAD_GUY)
|
|
ENDIF
|
|
|
|
// do speech
|
|
IF bShownGodText
|
|
IF IS_PED_IN_VEHICLE(PLAYER_PED_ID(), hoodVehicle[HV_FRANKLIN_VAN])
|
|
AND IS_PED_IN_VEHICLE(lamarPed, hoodVehicle[HV_FRANKLIN_VAN])
|
|
IF NOT bDoneInVanCue
|
|
bDoneInVanCue = TRIGGER_MISSION_MUSIC_EVENT("FRA0_CHASE_START")
|
|
ENDIF
|
|
|
|
IF NOT bStoppedChopExcitement
|
|
IF NOT IS_PED_INJURED(chopPed)
|
|
STOP_PED_SPEAKING(chopPed, FALSE)
|
|
SET_ANIMAL_MOOD(chopPed, AUD_ANIMAL_MOOD_ANGRY)
|
|
ENDIF
|
|
bStoppedChopExcitement = TRUE
|
|
ENDIF
|
|
|
|
DO_CHOP_AUDIO(CHOP_AUDIO_STATE_IN_VAN_AGITATED)
|
|
|
|
IF NOT bDoneLaughAtFranklinSpeech
|
|
IF iLaughAtFranklinTime >= 0
|
|
IF GET_GAME_TIMER() >= iLaughAtFranklinTime + 2000
|
|
bDoneLaughAtFranklinSpeech = TRUE
|
|
ELSE
|
|
bDoneLaughAtFranklinSpeech = DO_MISSION_SPEECH("FKN0_SPEC")
|
|
ENDIF
|
|
ELSE
|
|
IF bDoneUseAbilitySpeech
|
|
AND bDoneThisWillGetBumpySpeech
|
|
IF NOT IS_SPECIAL_ABILITY_ACTIVE(PLAYER_ID())
|
|
IF bUsedAbility
|
|
iLaughAtFranklinTime = GET_GAME_TIMER()
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
|
|
// say speech if manage to get close to bad guy
|
|
IF NOT bKnockedOffBike
|
|
IF fPlaybackTime < 66000
|
|
IF GET_GAME_TIMER() >= iNextBallaVanChaseSpeechTime
|
|
IF fDistanceToBadGuy <= 40.0
|
|
IF DO_MISSION_SPEECH("FKN0_OG1")
|
|
iNextBallaVanChaseSpeechTime = GET_GAME_TIMER() + 20000
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF fDistanceToBadGuy >= 150.0
|
|
AND bDoneThisWillGetBumpySpeech
|
|
// getting away speech
|
|
IF iNextRandomSpeechTime < 0
|
|
iNextRandomSpeechTime = GET_GAME_TIMER()
|
|
ENDIF
|
|
IF NOT bKnockedOffBike
|
|
DO_RANDOM_SPEECH("FKN0_LOSING")
|
|
ENDIF
|
|
ELSE
|
|
|
|
//PRINTSTRING("distance = ") PRINTFLOAT(fDistanceToBadGuy) PRINTNL()
|
|
//PRINTSTRING("playback time = ") PRINTFLOAT(fPlaybackTime) PRINTNL()
|
|
|
|
IF NOT IS_ANY_CONVERSATION_ONGOING_OR_QUEUED()
|
|
fNoSpeechTime = fNoSpeechTime +@ 1.0
|
|
ELSE
|
|
fNoSpeechTime = 0.0
|
|
ENDIF
|
|
|
|
IF NOT bDoneWontCatchComplainSpeech
|
|
bDoneWontCatchComplainSpeech = DO_MISSION_SPEECH("FKN0_NOCAT1")
|
|
|
|
IF bDoneWontCatchComplainSpeech
|
|
REPLAY_RECORD_BACK_FOR_TIME(3.0, 8.5, REPLAY_IMPORTANCE_HIGH)
|
|
ENDIF
|
|
ELSE
|
|
IF NOT bDoneWontCatchReplySpeech
|
|
IF DO_MISSION_SPEECH("FKN0_NOCAT2")
|
|
bDoneWontCatchReplySpeech = TRUE
|
|
ENDIF
|
|
ELSE
|
|
IF NOT bDoneThisWillGetBumpySpeech
|
|
bDoneThisWillGetBumpySpeech = DO_MISSION_SPEECH("FKN0_HOLDON")
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
|
|
// don't shoot! speech
|
|
IF iDontShootSpeechStage < 2
|
|
IF GET_GAME_TIMER() >= iNextDontShootSpeechTime
|
|
IF IS_PED_SHOOTING(PLAYER_PED_ID())
|
|
AND IS_ENTITY_ON_SCREEN(runnerChaseProperties.ped)
|
|
AND bDoneWontCatchReplySpeech
|
|
STRING sSpeech
|
|
IF iDontShootSpeechStage = 0
|
|
sSpeech = "FKN0_FSHOOT1"
|
|
ELSE
|
|
sSpeech = "FKN0_FSHOOT2"
|
|
ENDIF
|
|
IF DO_MISSION_SPEECH(sSpeech)
|
|
iDontShootSpeechStage++
|
|
iNextDontShootSpeechTime = GET_GAME_TIMER() + 8000
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
|
|
// heading down hill speech
|
|
IF NOT bDoneDownHillSpeech
|
|
IF fPlaybackTime >= 40000
|
|
bDoneDownHillSpeech = TRUE
|
|
ELSE
|
|
IF IS_ENTITY_IN_ANGLED_AREA(hoodVehicle[HV_FRANKLIN_VAN], <<277.51, -66.64, 48.00>>, <<293.19, -72.39, 102.00>>, 340)
|
|
AND GET_ENTITY_SPEED(hoodVehicle[HV_FRANKLIN_VAN]) >= 23.0
|
|
AND IS_PED_CLOSE_TO_IDEAL_HEADING(PLAYER_PED_ID(), 156.70, 30)
|
|
AND bDoneUseAbilitySpeech
|
|
AND fNoSpeechTime >= 1.2
|
|
bDoneDownHillSpeech = DO_MISSION_SPEECH("FKN0_VCHAS6")
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
|
|
// special ability speech
|
|
IF NOT IS_SPECIAL_ABILITY_ACTIVE(PLAYER_ID())
|
|
IF NOT bDoneUseAbilitySpeech
|
|
IF fPlaybackTime >= 12000
|
|
AND iVanChaseSpeechStage > 0
|
|
AND fNoSpeechTime >= 1.0
|
|
IF NOT IS_ENTITY_AT_COORD(hoodVehicle[HV_FRANKLIN_VAN], <<364.11, 323.00, 102.70>>, <<60,60,60>>, FALSE, FALSE)
|
|
IF DO_MISSION_SPEECH("FKN0_FSPEC")
|
|
bDoneUseAbilitySpeech = TRUE
|
|
|
|
REPLAY_RECORD_BACK_FOR_TIME(0.0, 10.0, REPLAY_IMPORTANCE_HIGH)
|
|
|
|
iUseAbilitySpeechTime = GET_GAME_TIMER()
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF NOT bDoneGoingLeftSpeech
|
|
IF fPlaybackTime >= 43000
|
|
bDoneGoingLeftSpeech = TRUE
|
|
ELSE
|
|
IF fPlaybackTime >= 42000
|
|
IF fDistanceToBadGuy <= 70
|
|
AND IS_ENTITY_ON_SCREEN(runnerChaseProperties.ped)
|
|
IF iReplayAttempt % 2 = 0
|
|
bDoneGoingLeftSpeech = DO_MISSION_SPEECH("FKN0_VCHAS7")
|
|
ELSE
|
|
bDoneGoingLeftSpeech = DO_MISSION_SPEECH("FKN0_VCHAS8")
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF NOT bBlipAlley
|
|
IF fPlaybackTime >= 65800
|
|
IF IS_ENTITY_AT_COORD(PLAYER_PED_ID(), GET_HOOD_VECTOR(HVEC_BLIP_ALLEY), <<70,70,70>>, FALSE, FALSE)
|
|
bBlipAlley = TRUE
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF NOT bDoneGoingDownAlleySpeech
|
|
IF fPlaybackTime >= 67400
|
|
bDoneGoingDownAlleySpeech = TRUE
|
|
ELSE
|
|
IF bBlipAlley
|
|
IF IS_ENTITY_ON_SCREEN(runnerChaseProperties.ped)
|
|
bDoneGoingDownAlleySpeech = DO_MISSION_SPEECH("FC_VANALL")
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
|
|
iNextRandomSpeechTime = -1
|
|
// banter
|
|
FLOAT fSpeechTime
|
|
SWITCH iVanChaseSpeechStage
|
|
CASE 0
|
|
fSpeechTime = 13000
|
|
BREAK
|
|
CASE 1
|
|
fSpeechTime = 32000
|
|
BREAK
|
|
CASE 2
|
|
fSpeechTime = 48000
|
|
BREAK
|
|
CASE 3
|
|
fSpeechTime = 52000
|
|
BREAK
|
|
DEFAULT
|
|
fSpeechTime = 99999999
|
|
BREAK
|
|
ENDSWITCH
|
|
|
|
IF fPlaybackTime >= fSpeechTime
|
|
AND fNoSpeechTime >= 1.3
|
|
AND NOT bDoneGoingDownAlleySpeech
|
|
AND bDoneWontCatchReplySpeech
|
|
AND NOT bKilledSpeechForCrashReaction
|
|
STRING sSpeech
|
|
SWITCH iVanChaseSpeechStage
|
|
CASE 0
|
|
SWITCH GET_RANDOM_INT_IN_RANGE(0,2)
|
|
CASE 0
|
|
sSpeech = "FKN0_VCHAS4"//"FKN0_VCHAS1"
|
|
BREAK
|
|
CASE 1
|
|
sSpeech = "FKN0_VCHAS5"//"FKN0_VCHAS2"
|
|
BREAK
|
|
ENDSWITCH
|
|
BREAK
|
|
CASE 1
|
|
SWITCH GET_RANDOM_INT_IN_RANGE(0,8)
|
|
|
|
CASE 0
|
|
sSpeech = "FC_CCHAT9"
|
|
BREAK
|
|
CASE 1
|
|
sSpeech = "FKN0_VCHAS3"
|
|
BREAK
|
|
CASE 2
|
|
sSpeech = "FKN0_VCHAS1"
|
|
BREAK
|
|
CASE 3
|
|
sSpeech = "FKN0_VCHAS2"
|
|
BREAK
|
|
CASE 4
|
|
sSpeech = "FC_CCHAT7"
|
|
BREAK
|
|
CASE 5
|
|
sSpeech = "FC_CHAT10"
|
|
BREAK
|
|
CASE 6
|
|
sSpeech = "FC_CCHAT8"
|
|
BREAK
|
|
CASE 7
|
|
sSpeech = "FC_CCHAT6"
|
|
BREAK
|
|
ENDSWITCH
|
|
BREAK
|
|
CASE 2
|
|
sSpeech = "FKN0_AGAIN"
|
|
//sSpeech = "FKN0_VCHAS8"
|
|
BREAK
|
|
CASE 3
|
|
IF iReplayAttempt % 2 = 0
|
|
sSpeech = "FKN0_PHONE1"
|
|
ELSE
|
|
sSpeech = "FKN0_PHONE2"
|
|
ENDIF
|
|
/*
|
|
SWITCH GET_RANDOM_INT_IN_RANGE(0,3)
|
|
CASE 0
|
|
sSpeech = "FC_CCHAT7"
|
|
BREAK
|
|
CASE 1
|
|
sSpeech = "FC_CHAT10"
|
|
BREAK
|
|
CASE 2
|
|
sSpeech = "FC_CCHAT8"
|
|
BREAK
|
|
ENDSWITCH
|
|
*/
|
|
BREAK
|
|
BREAK
|
|
ENDSWITCH
|
|
IF DO_MISSION_SPEECH(sSpeech)
|
|
iVanChaseSpeechStage++
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
|
|
// special ability help
|
|
IF IS_SPECIAL_ABILITY_ACTIVE(PLAYER_ID())
|
|
bUsedAbility = TRUE
|
|
bDoneUseAbilitySpeech = TRUE
|
|
bShownSpecialAbilityHelp = TRUE
|
|
IF IS_THIS_HELP_MESSAGE_BEING_DISPLAYED("FC_SPCHLP")
|
|
IF GET_GAME_TIMER() >= iClearHelpTime + 500
|
|
CLEAR_HELP(FALSE)
|
|
iClearHelpTime = GET_GAME_TIMER()
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF IS_PC_VERSION()
|
|
IF IS_THIS_HELP_MESSAGE_BEING_DISPLAYED("FC_SPCHLP_KM")
|
|
IF GET_GAME_TIMER() >= iClearHelpTime + 500
|
|
CLEAR_HELP(FALSE)
|
|
iClearHelpTime = GET_GAME_TIMER()
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
|
|
ELSE
|
|
IF bDoneUseAbilitySpeech
|
|
IF NOT bShownSpecialAbilityHelp
|
|
IF GET_GAME_TIMER() >= iUseAbilitySpeechTime + 600
|
|
|
|
IF IS_USING_KEYBOARD_AND_MOUSE(PLAYER_CONTROL)
|
|
bShownSpecialAbilityHelp = DO_MISSION_HELP_TEXT("FC_SPCHLP_KM", TRUE, 14000)
|
|
ELSE
|
|
bShownSpecialAbilityHelp = DO_MISSION_HELP_TEXT("FC_SPCHLP", TRUE, 14000)
|
|
ENDIF
|
|
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
|
|
bUsingActionCam = bUsingActionCam
|
|
/*
|
|
// handle action cam
|
|
UPDATE_CAM_PLAYBACK(chaseCam, cameraVehicle, fCarChaseSpeed)
|
|
IF IS_CONTROL_PRESSED
|
|
IF NOT bUsingActionCam
|
|
RENDER_SCRIPT_CAMS(TRUE, FALSE)
|
|
bUsingActionCam = TRUE
|
|
ENDIF
|
|
ELSE
|
|
IF bUsingActionCam
|
|
RENDER_SCRIPT_CAMS(FALSE, FALSE)
|
|
bUsingActionCam = FALSE
|
|
ENDIF
|
|
ENDIF
|
|
*/
|
|
HANDLE_CRASH_TRIGGER()
|
|
ELSE
|
|
IF NOT IS_ENTITY_AT_ENTITY(PLAYER_PED_ID(), runnerChaseProperties.ped, <<200,200,200>>, FALSE, FALSE)
|
|
MISSION_FAILED(FAIL_LOST_BAD_GUY)
|
|
ENDIF
|
|
|
|
IF bKnockedOffBike
|
|
IF streamingStage = MISSION_STREAMING_STAGE_COMPLETE
|
|
// handle runner blip
|
|
IF NOT IS_PED_IN_ANY_VEHICLE(runnerChaseProperties.ped)
|
|
IF DOES_BLIP_EXIST(badGuyCarBlip)
|
|
REMOVE_BLIP(badGuyCarBlip)
|
|
ENDIF
|
|
ENDIF
|
|
|
|
// knock the bike over
|
|
IF IS_VEHICLE_DRIVEABLE(hoodVehicle[HV_BAD_GUY_BIKE])
|
|
IF GET_ENTITY_SPEED(hoodVehicle[HV_BAD_GUY_BIKE]) >= 1
|
|
//SET_VEHICLE_FORWARD_SPEED(hoodVehicle[HV_BAD_GUY_BIKE], GET_ENTITY_SPEED(hoodVehicle[HV_BAD_GUY_BIKE]) -@ 10.0)
|
|
//IF IS_PED_IN_VEHICLE(runnerChaseProperties.ped, hoodVehicle[HV_BAD_GUY_BIKE])
|
|
// BRING_VEHICLE_TO_HALT(hoodVehicle[HV_BAD_GUY_BIKE], 3, 1)
|
|
//ENDIF
|
|
ELSE
|
|
IF bPedOffBikeAI
|
|
VECTOR vBikeRot = GET_ENTITY_ROTATION(hoodVehicle[HV_BAD_GUY_BIKE])
|
|
//printstring("BIKE ROT = ") PRINTVECTOR(vBikeRot) PRINTNL()
|
|
IF (vBikeRot.y < 0 AND vBikeRot.y > -50)
|
|
OR (vBikeRot.y > 0 AND vBikeRot.y < 50)
|
|
IF NOT IS_PED_IN_VEHICLE(runnerChaseProperties.ped, hoodVehicle[HV_BAD_GUY_BIKE])
|
|
// APPLY_FORCE_TO_ENTITY(hoodVehicle[HV_BAD_GUY_BIKE], APPLY_TYPE_TORQUE, <<0,100,0>>, <<0,0,0>>, 0, TRUE, TRUE, TRUE)
|
|
//APPLY_FORCE_TO_ENTITY(hoodVehicle[HV_BAD_GUY_BIKE], APPLY_TYPE_FORCE, <<0,0,20>>, <<0,0,0>>, 0, TRUE, TRUE, TRUE)
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF NOT bKilledSpeechForCrashReaction
|
|
IF crashTriggerState <= CRASH_TRIGGER_SLOW_DOWN
|
|
IF IS_ENTITY_ON_SCREEN(runnerChaseProperties.ped)
|
|
AND IS_ENTITY_AT_ENTITY(PLAYER_PED_ID(), runnerChaseProperties.ped, <<60,60,4>>)
|
|
KILL_ANY_CONVERSATION()
|
|
bKilledSpeechForCrashReaction = TRUE
|
|
ENDIF
|
|
ENDIF
|
|
ELSE
|
|
IF NOT bDoneCrashReactionSpeech
|
|
bDoneCrashReactionSpeech = DO_MISSION_SPEECH("FKN0_CRSHED")
|
|
IF bDoneCrashReactionSpeech
|
|
REPLAY_RECORD_BACK_FOR_TIME(4.0, 6.0, REPLAY_IMPORTANCE_HIGHEST)
|
|
ENDIF
|
|
ELSE
|
|
IF IS_PED_SITTING_IN_VEHICLE(PLAYER_PED_ID(), hoodVehicle[HV_FRANKLIN_VAN])
|
|
DISABLE_CONTROL_ACTION(PLAYER_CONTROL, INPUT_VEH_EXIT)
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF crashTriggerState > CRASH_TRIGGER_SLOW_DOWN
|
|
|
|
ELSE
|
|
IF NOT bForcedRunnerDismount
|
|
IF IS_PED_SITTING_IN_ANY_VEHICLE(runnerChaseProperties.ped)
|
|
AND NOT CAN_KNOCK_PED_OFF_VEHICLE(runnerChaseProperties.ped)
|
|
TASK_LEAVE_ANY_VEHICLE(runnerChaseProperties.ped, 0, ECF_DONT_WAIT_FOR_VEHICLE_TO_STOP | ECF_JUMP_OUT)
|
|
ENDIF
|
|
bForcedRunnerDismount = TRUE
|
|
ELSE
|
|
IF NOT bResetScriptRagdoll
|
|
IF CAN_PED_RAGDOLL(runnerChaseProperties.ped)
|
|
bResetScriptRagdoll = SET_PED_TO_RAGDOLL(runnerChaseProperties.ped, 5000, 5000, TASK_RELAX, TRUE, TRUE, FALSE)
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF IS_PED_RUNNING_RAGDOLL_TASK(runnerChaseProperties.ped)
|
|
RESET_PED_RAGDOLL_TIMER(runnerChaseProperties.ped)
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF NOT bSetBikeAsSmoking
|
|
IF GET_GAME_TIMER() >= iKnockOffBikeTime + 3000
|
|
SET_BIKE_AS_SMOKING()
|
|
ENDIF
|
|
ENDIF
|
|
ELSE
|
|
//IF GET_GAME_TIMER() >= iBusSmashTime + 200
|
|
KNOCK_RUNNER_OFF_BIKE()
|
|
//ENDIF
|
|
ENDIF
|
|
|
|
HANDLE_CRASH_TRIGGER()
|
|
ENDIF
|
|
|
|
IF crashTriggerState = CRASH_TRIGGER_WAITING
|
|
// should get Lamar into van?
|
|
IF NOT bLamarShouldBeInGroup
|
|
IF IS_PED_IN_VEHICLE(PLAYER_PED_ID(), hoodVehicle[HV_FRANKLIN_VAN])
|
|
AND NOT IS_PED_IN_VEHICLE(lamarPed, hoodVehicle[HV_FRANKLIN_VAN])
|
|
bLamarShouldBeInGroup = TRUE
|
|
ENDIF
|
|
ENDIF
|
|
|
|
HANDLE_IN_CAR_PROMPTS(TRUE, bLamarShouldBeInGroup AND NOT bResetDirectEntryFlag, FALSE)
|
|
HANDLE_LAMAR_REACTION_TO_DAMAGE()
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF NOT bKnockedOffBike
|
|
IF NOT IS_VEHICLE_DRIVEABLE(hoodVehicle[HV_BAD_GUY_BIKE])
|
|
IF NOT IS_PED_INJURED(runnerChaseProperties.ped)
|
|
SET_PED_CAN_BE_KNOCKED_OFF_VEHICLE(runnerChaseProperties.ped, KNOCKOFFVEHICLE_DEFAULT)
|
|
APPLY_DAMAGE_TO_PED(runnerChaseProperties.ped, 1000, TRUE)
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF IS_PED_INJURED(runnerChaseProperties.ped)
|
|
IF DOES_BLIP_EXIST(badGuyCarBlip)
|
|
REMOVE_BLIP(badGuyCarBlip)
|
|
ENDIF
|
|
ENDIF
|
|
|
|
REQUEST_COMMON_MODELS_TO_VAN_AND_FOOT_CHASE()
|
|
ELSE
|
|
DO_CRASH_CUTSCENE()
|
|
IF bAllowRunnerMovement
|
|
IF NOT IS_PED_RAGDOLL(runnerChaseProperties.ped)
|
|
HANDLE_RUNNER_CHASE()
|
|
HANDLE_CHASE_SETPIECES()
|
|
BLOCK_FOOT_CHASE_RAGDOLL()
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDPROC
|
|
|
|
// through fence cutscene
|
|
PROC DO_THROUGH_FENCE_CUTSCENE()
|
|
SWITCH cutsceneStage
|
|
CASE H_CUT_STAGE_INIT
|
|
SET_MISSION_CUTSCENE(TRUE, TRUE, -1, TRUE, FALSE,DEFAULT,DEFAULT,FALSE)
|
|
CREATE_CAM_FOR_HOOD_SHOT(H_SHOT_THROUGH_FENCE, TRUE, 1800)//1100)//1500) // 1500
|
|
|
|
//iSyncscene = CREATE_SYNCHRONIZED_SCENE(<<493.480, -525.110, 24.750>>, <<0,0,-7.1>>)
|
|
//TASK_SYNCHRONIZED_SCENE(PLAYER_PED_ID(), iSyncScene, "MISSFRA0_CHOP", "franklin_wallcrash", INSTANT_BLEND_IN, NORMAL_BLEND_OUT, SYNCED_SCENE_TAG_SYNC_OUT | SYNCED_SCENE_USE_PHYSICS | SYNCED_SCENE_EXPAND_PED_CAPSULE_FROM_SKELETON)
|
|
//SET_SYNCHRONIZED_SCENE_PHASE(iSyncScene, 0.52)
|
|
//SET_SYNCHRONIZED_SCENE_HOLD_LAST_FRAME(iSyncScene, FALSE)
|
|
|
|
CLEAR_AREA_OF_PROJECTILES(<<494.35767, -516.89404, 23.81950>>, 8)
|
|
STOP_FIRE_IN_RANGE(<<494.35767, -516.89404, 23.81950>>, 8)
|
|
REMOVE_PARTICLE_FX_IN_RANGE(<<494.35767, -516.89404, 23.81950>>, 8)
|
|
|
|
SET_CURRENT_PED_WEAPON(PLAYER_PED_ID(), WEAPONTYPE_UNARMED, TRUE)
|
|
SET_PED_STEALTH_MOVEMENT(PLAYER_PED_ID(), FALSE)
|
|
CLEAR_PED_TASKS_IMMEDIATELY(PLAYER_PED_ID())
|
|
SET_ENTITY_COORDS(PLAYER_PED_ID(), <<493.480, -525.110, 23.75148>>)
|
|
SET_ENTITY_HEADING(PLAYER_PED_ID(), -7.1)
|
|
TASK_PLAY_ANIM(PLAYER_PED_ID(), GET_HOOD_ANIM_DICT_AS_STRING(H_ANIM_DICT_FOOT_CHASE), "franklin_wallcrash", INSTANT_BLEND_IN, NORMAL_BLEND_OUT, -1, AF_USE_MOVER_EXTRACTION | AF_USE_KINEMATIC_PHYSICS | AF_TAG_SYNC_OUT, 0.52)
|
|
|
|
START_HOOD_AUDIO_SCENE(HOOD_AUDIO_SCENE_BREAK_THROUGH_FENCE)
|
|
|
|
FORCE_PED_AI_AND_ANIMATION_UPDATE(PLAYER_PED_ID())
|
|
|
|
IF NOT IS_PED_INJURED(chopPed)
|
|
SET_ENTITY_COORDS(chopPed, <<492.90, -521.53, 23.75>>)
|
|
CLEAR_PED_TASKS_IMMEDIATELY(chopPed)
|
|
ENDIF
|
|
|
|
SHAKE_CAM(staticCam, "HAND_SHAKE", 1.0)
|
|
|
|
REPLAY_START_EVENT(REPLAY_IMPORTANCE_HIGHEST)
|
|
|
|
bDoneFlash = FALSE
|
|
|
|
iHoodCutsceneTime = GET_GAME_TIMER()
|
|
cutsceneStage = H_CUT_STAGE_RUNNING
|
|
BREAK
|
|
|
|
CASE H_CUT_STAGE_RUNNING
|
|
SET_PED_RESET_FLAG(PLAYER_PED_ID(), PRF_ForceRunningSpeedForFragSmashing, TRUE)
|
|
//SET_PED_RESET_FLAG(PLAYER_PED_ID(), PRF_ExpandPedCapsuleFromSkeleton, TRUE)
|
|
SET_PED_MIN_MOVE_BLEND_RATIO(PLAYER_PED_ID(), PEDMOVE_RUN)
|
|
|
|
//SET_GAMEPLAY_CAM_RELATIVE_HEADING(0)
|
|
//SET_GAMEPLAY_CAM_RELATIVE_PITCH(0)
|
|
|
|
IF NOT bInterpedToGameCam
|
|
IF GET_GAME_TIMER() >= iHoodCutsceneTime //+ 200
|
|
//RENDER_SCRIPT_CAMS(FALSE, TRUE, 2500)
|
|
bInterpedToGameCam = TRUE
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF GET_GAME_TIMER() >= iHoodCutsceneTime + 400
|
|
IF bPreparedSmashFenceCue
|
|
IF NOT bDoneBypassFenceCue
|
|
IF NOT bDoneSmashFenceCue
|
|
bDoneSmashFenceCue = TRIGGER_MISSION_MUSIC_EVENT("FRA0_FENCE")
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF NOT bDoneBreakFenceAudioScene
|
|
SHAKE_CAM(staticCam, "SMALL_EXPLOSION_SHAKE", 0.3)
|
|
SET_CONTROL_SHAKE(PLAYER_CONTROL, 500, 128)
|
|
//SHAKE_GAMEPLAY_CAM("SMALL_EXPLOSION_SHAKE", CAM_SHAKE_AMPLITUDE)
|
|
PLAY_SOUND_FROM_COORD(-1, "Crash_Through_Fence", <<494.4, -516.9, 24.9>>, "FRANKLIN_0_SOUNDS")
|
|
bDoneBreakFenceAudioScene = TRUE
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF GET_GAME_TIMER() >= iHoodCutsceneTime + 1000
|
|
|
|
IF NOT IS_PED_INJURED(chopPed)
|
|
SET_ENTITY_COORDS(chopPed, <<494.01862, -518.84265, 23.75159>>)
|
|
SET_ENTITY_HEADING(chopPed, -15.75)
|
|
CLEAR_PED_TASKS_IMMEDIATELY(chopPed)
|
|
FORCE_PED_MOTION_STATE(chopPed, MS_ON_FOOT_RUN, TRUE, FAUS_CUTSCENE_EXIT)
|
|
SET_PED_MIN_MOVE_BLEND_RATIO(chopPed, PEDMOVE_RUN)
|
|
chopStage = CHOP_TO_FENCE
|
|
chopWaitState = CHOP_WAIT_STATE_WAITING
|
|
ENDIF
|
|
|
|
cutsceneStage = H_CUT_STAGE_CLEANUP
|
|
ENDIF
|
|
BREAK
|
|
|
|
CASE H_CUT_STAGE_CLEANUP
|
|
IF NOT IS_PED_INJURED(PLAYER_PED_ID())
|
|
IF GET_FOLLOW_PED_CAM_VIEW_MODE() <> CAM_VIEW_MODE_FIRST_PERSON
|
|
SET_PED_MIN_MOVE_BLEND_RATIO(PLAYER_PED_ID(), PEDMOVE_RUN)
|
|
ELSE
|
|
SIMULATE_PLAYER_INPUT_GAIT(PLAYER_ID(), PEDMOVE_RUN, 2000)
|
|
ENDIF
|
|
//CLEAR_PED_TASKS_IMMEDIATELY(PLAYER_PED_ID())
|
|
//SET_ENTITY_COORDS(PLAYER_PED_ID(), <<494.64, -514.27, 23.75>>)
|
|
//SET_ENTITY_HEADING(PLAYER_PED_ID(), -55.44)
|
|
ENDIF
|
|
|
|
IF NOT IS_PED_INJURED(chopPed)
|
|
SET_PED_MIN_MOVE_BLEND_RATIO(chopPed, PEDMOVE_RUN)
|
|
ENDIF
|
|
|
|
REPLAY_STOP_EVENT()
|
|
|
|
//SET_GAMEPLAY_CAM_RELATIVE_HEADING(0)
|
|
//SET_GAMEPLAY_CAM_RELATIVE_PITCH(0)
|
|
// back to gameplay
|
|
SET_MISSION_CUTSCENE(FALSE, TRUE, -1, FALSE, FALSE, TRUE, FALSE, FALSE)
|
|
STOP_RENDERING_SCRIPT_CAMS_USING_CATCH_UP(FALSE, 0, CAM_SPLINE_SLOW_OUT_SMOOTH)
|
|
|
|
bDoRunAfterFence = TRUE
|
|
iThroughFenceTime = GET_GAME_TIMER()
|
|
bSmashedFence = TRUE
|
|
bDoneThroughFenceCut = TRUE
|
|
BREAK
|
|
ENDSWITCH
|
|
ENDPROC
|
|
|
|
// on train cutscene
|
|
PROC DO_ON_TRAIN_CUTSCENE()
|
|
SET_ALL_RANDOM_PEDS_FLEE_THIS_FRAME(PLAYER_ID())
|
|
SWITCH cutsceneStage
|
|
CASE H_CUT_STAGE_INIT
|
|
OVERRIDE_LODSCALE_THIS_FRAME(1.0)
|
|
//SET_CHOP_VIEW_CAM_STATE(CHOP_VIEW_CAM_DISABLED)
|
|
SET_MISSION_CUTSCENE(TRUE, TRUE, -1, TRUE, FALSE)
|
|
//CREATE_CAM_FOR_HOOD_SHOT(H_SHOT_ONTO_TRAIN, TRUE, 4000)
|
|
|
|
START_HOOD_AUDIO_SCENE(HOOD_AUDIO_SCENE_D_ESCAPES)
|
|
|
|
SET_PED_STEALTH_MOVEMENT(PLAYER_PED_ID(), FALSE)
|
|
SET_CURRENT_PED_WEAPON(PLAYER_PED_ID(), WEAPONTYPE_UNARMED, TRUE)
|
|
|
|
iSyncScene = CREATE_SYNCHRONIZED_SCENE(<<559.729, -569.216, 23.967>>,<<0,0,-6.50>>)
|
|
CREATE_MISSION_ANIM_CAM()
|
|
PLAY_SYNCHRONIZED_CAM_ANIM(animCam, iSyncScene, "BallasOG_JumpOnTrain_IG7_CAMERA", GET_HOOD_ANIM_DICT_AS_STRING(H_ANIM_DICT_FOOT_CHASE))
|
|
|
|
CLEAR_AREA(<<551.07, -573.04, 23.80>>, 18.0, TRUE)
|
|
CLEAR_AREA_OF_PROJECTILES(<<551.07, -573.04, 23.80>>, 18)
|
|
STOP_FIRE_IN_RANGE(<<551.07, -573.04, 23.80>>, 18)
|
|
REMOVE_PARTICLE_FX_IN_RANGE(<<551.07, -573.04, 23.80>>, 18)
|
|
|
|
IF NOT IS_PED_INJURED(PLAYER_PED_ID())
|
|
CLEAR_PED_TASKS_IMMEDIATELY(PLAYER_PED_ID())
|
|
SET_ENTITY_COORDS(PLAYER_PED_ID(), <<562.88, -545.27, 23.79>>)
|
|
ENDIF
|
|
|
|
IF NOT IS_PED_INJURED(chopPed)
|
|
SET_ENTITY_COORDS(chopPed, <<561.94, -543.40, 23.77>>)
|
|
CLEAR_PED_TASKS_IMMEDIATELY(chopPed)
|
|
ENDIF
|
|
|
|
IF DOES_ENTITY_EXIST(trainVehicle[2])
|
|
DELETE_MISSION_TRAIN(trainVehicle[2])
|
|
ENDIF
|
|
CREATE_YARD_TRAIN_FOR_STAGE(2, STAGE_FOOT_CHASE, TRUE)
|
|
bStartedTrain[2] = TRUE
|
|
iTrainStartedTime[2] = GET_GAME_TIMER()
|
|
|
|
// setup train
|
|
IF IS_VEHICLE_DRIVEABLE(trainVehicle[1])
|
|
AND NOT IS_PED_INJURED(runnerChaseProperties.ped)
|
|
CONST_FLOAT TRAIN_SPEED 2.67
|
|
CLEAR_PED_TASKS_IMMEDIATELY(runnerChaseProperties.ped)
|
|
//ATTACH_ENTITY_TO_ENTITY(runnerChaseProperties.ped, GET_TRAIN_CARRIAGE(trainVehicle[1], 2), 0, <<0,0,0>>, <<0,0,0>>)
|
|
//TASK_PLAY_ANIM(runnerChaseProperties.ped, GET_HOOD_ANIM_DICT_AS_STRING(H_ANIM_DICT_MISSION), "BallasOG_JumpOnTrain_IG7", INSTANT_BLEND_IN, INSTANT_BLEND_OUT, -1, AF_HOLD_LAST_FRAME)
|
|
runnerChaseProperties.iSyncScene = CREATE_SYNCHRONIZED_SCENE(<<0,0.8,0>>,<<0,0,180>>)
|
|
ATTACH_SYNCHRONIZED_SCENE_TO_ENTITY(runnerChaseProperties.iSyncScene, GET_TRAIN_CARRIAGE(trainVehicle[1], 2), 0)
|
|
TASK_SYNCHRONIZED_SCENE(runnerChaseProperties.ped, runnerChaseProperties.iSyncScene, GET_HOOD_ANIM_DICT_AS_STRING(H_ANIM_DICT_FOOT_CHASE), "BallasOG_JumpOnTrain_IG7", INSTANT_BLEND_IN, INSTANT_BLEND_OUT)
|
|
FORCE_PED_AI_AND_ANIMATION_UPDATE(runnerChaseProperties.ped)
|
|
ENDIF
|
|
|
|
// get rid of yard peds
|
|
INT i
|
|
REPEAT NUMBER_YARD_PEDS i
|
|
IF DOES_ENTITY_EXIST(yardPed[i].ped)
|
|
DELETE_PED(yardPed[i].ped)
|
|
ENDIF
|
|
ENDREPEAT
|
|
|
|
bDoneFlash = FALSE
|
|
|
|
REPLAY_START_EVENT(REPLAY_IMPORTANCE_HIGHEST)
|
|
|
|
iHoodCutsceneTime = GET_GAME_TIMER()
|
|
cutsceneStage = H_CUT_STAGE_RUNNING
|
|
BREAK
|
|
|
|
CASE H_CUT_STAGE_RUNNING
|
|
OVERRIDE_LODSCALE_THIS_FRAME(1.0)
|
|
|
|
SWITCH ontoTrainShot
|
|
CASE ONTO_TRAIN_JUMP
|
|
IF NOT bRepositionedFranklinForTrain
|
|
IF NOT IS_PED_INJURED(PLAYER_PED_ID())
|
|
IF GET_GAME_TIMER() >= iHoodCutsceneTime + 3800
|
|
CLEAR_PED_TASKS_IMMEDIATELY(PLAYER_PED_ID())
|
|
SET_ENTITY_COORDS(PLAYER_PED_ID(), <<561.64, -559.80, 23.79>>)
|
|
SET_ENTITY_HEADING(PLAYER_PED_ID(), 137.43)
|
|
TASK_GO_STRAIGHT_TO_COORD(PLAYER_PED_ID(), GET_HOOD_VECTOR(HVEC_LOSE_RUNNER), PEDMOVE_RUN)
|
|
bRepositionedFranklinForTrain = TRUE
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF GET_GAME_TIMER() >= iHoodCutsceneTime + 4000
|
|
//CREATE_CAM_FOR_HOOD_SHOT(H_SHOT_LOST, TRUE, 4000)
|
|
iHoodCutsceneTime = GET_GAME_TIMER()
|
|
ontoTrainShot = ONTO_TRAIN_LOSE
|
|
ENDIF
|
|
BREAK
|
|
CASE ONTO_TRAIN_LOSE
|
|
IF NOT bDoneLoseReactSpeech
|
|
bDoneLoseReactSpeech = DO_MISSION_SPEECH("FKN0_LOST", TRUE, 1)
|
|
ENDIF
|
|
|
|
IF NOT bRepositionedBallaHiding
|
|
IF GET_GAME_TIMER() >= iHoodCutsceneTime + 1000
|
|
IF NOT IS_PED_INJURED(runnerChaseProperties.ped)
|
|
//STOP_SYNCHRONIZED_ENTITY_ANIM(runnerChaseProperties.ped, 1, FA)
|
|
CLEAR_PED_TASKS_IMMEDIATELY(runnerChaseProperties.ped)
|
|
DETACH_ENTITY(runnerChaseProperties.ped)
|
|
SET_ENTITY_COORDS(runnerChaseProperties.ped, GET_HOOD_VECTOR(HVEC_RUNNER_HIDE))
|
|
SET_ENTITY_HEADING(runnerChaseProperties.ped, RUNNER_HIDE_ROT)
|
|
FREEZE_ENTITY_POSITION(runnerChaseProperties.ped, TRUE)
|
|
//TASK_COWER(runnerChaseProperties.ped)
|
|
ENDIF
|
|
bRepositionedBallaHiding = TRUE
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF NOT bDoneFlash
|
|
IF GET_FOLLOW_PED_CAM_VIEW_MODE() = CAM_VIEW_MODE_FIRST_PERSON
|
|
IF GET_GAME_TIMER() >= iHoodCutsceneTime + 1700
|
|
ANIMPOSTFX_PLAY("CamPushInNeutral", 0, FALSE)
|
|
PLAY_SOUND_FRONTEND(-1, "1st_Person_Transition", "PLAYER_SWITCH_CUSTOM_SOUNDSET")
|
|
bDoneFlash = TRUE
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF GET_GAME_TIMER() >= iHoodCutsceneTime + 2000
|
|
cutsceneStage = H_CUT_STAGE_CLEANUP
|
|
ENDIF
|
|
BREAK
|
|
ENDSWITCH
|
|
|
|
BREAK
|
|
|
|
CASE H_CUT_STAGE_CLEANUP
|
|
/*
|
|
IF NOT IS_PED_INJURED(runnerChaseProperties.ped)
|
|
DETACH_ENTITY(runnerChaseProperties.ped)
|
|
SET_ENTITY_COORDS(runnerChaseProperties.ped, GET_HOOD_VECTOR(HVEC_RUNNER_HIDE))
|
|
SET_ENTITY_HEADING(runnerChaseProperties.ped, RUNNER_HIDE_ROT)
|
|
FREEZE_ENTITY_POSITION(runnerChaseProperties.ped, TRUE)
|
|
TASK_COWER(runnerChaseProperties.ped)
|
|
ENDIF
|
|
*/
|
|
|
|
REPLAY_STOP_EVENT()
|
|
|
|
IF NOT IS_PED_INJURED(chopPed)
|
|
DETACH_ENTITY(chopPed)
|
|
IF NOT IS_ENTITY_AT_ENTITY(chopPed, PLAYER_PED_ID(), <<3,3,3>>)
|
|
SET_ENTITY_COORDS(chopPed, GET_HOOD_VECTOR(HVEC_CHOP_FIND_INIT))
|
|
SET_ENTITY_HEADING(chopPed, CHOP_FIND_INIT_ROT)
|
|
ENDIF
|
|
ENDIF
|
|
|
|
//IF DOES_ENTITY_EXIST(tempHelperPed)
|
|
// DELETE_PED(tempHelperPed)
|
|
//ENDIF
|
|
|
|
STOP_HOOD_AUDIO_SCENE(HOOD_AUDIO_SCENE_D_ESCAPES)
|
|
|
|
// back to gameplay
|
|
SET_MISSION_CUTSCENE(FALSE)
|
|
|
|
SET_MISSION_STAGE(STAGE_FIND_BAD_GUY, FALSE, TRUE, FALSE)
|
|
BREAK
|
|
ENDSWITCH
|
|
ENDPROC
|
|
|
|
// foot chase round train yards
|
|
PROC DO_STAGE_FOOT_CHASE()
|
|
IF NOT bDoneThroughFenceCut
|
|
DISABLE_PLAYER_PED_STAT_UPDATES_THIS_FRAME()
|
|
ENDIF
|
|
|
|
VECTOR vPlayerPos = GET_ENTITY_COORDS(PLAYER_PED_ID())
|
|
|
|
IF NOT bDoneLamarEncourageSpeech
|
|
bDoneLamarEncourageSpeech = DO_MISSION_SPEECH("FKN0_GOGET3")
|
|
ELSE
|
|
IF NOT bShownGodText
|
|
bShownGodText = DO_MISSION_GOD_TEXT("FC_CHASE")
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF NOT bPreparedSmashFenceCue
|
|
bPreparedSmashFenceCue = PREPARE_MUSIC_EVENT("FRA0_FENCE")
|
|
ENDIF
|
|
|
|
HANDLE_GRAB_SCENARIO_PEDS()
|
|
|
|
SWITCH createCarsStage
|
|
CASE CREATE_CARS_STAGE_NOT_STARTED
|
|
ADD_MODEL_REQUEST(ENUM_TO_INT(HM_TRAFFIC_CAR1))
|
|
ADD_MODEL_REQUEST(ENUM_TO_INT(HM_TRAFFIC_CAR2))
|
|
createCarsStage = CREATE_CARS_STAGE_WAITING
|
|
BREAK
|
|
CASE CREATE_CARS_STAGE_WAITING
|
|
IF HAS_MODEL_LOADED(GET_MODEL_FOR_HOOD_MODEL_ENUM(HM_TRAFFIC_CAR1))
|
|
AND HAS_MODEL_LOADED(GET_MODEL_FOR_HOOD_MODEL_ENUM(HM_TRAFFIC_CAR2))
|
|
CREATE_CHASE_SETPIECES(FALSE, FALSE, TRUE, FALSE, FALSE)
|
|
createCarsStage = CREATE_CARS_STAGE_DONE
|
|
ENDIF
|
|
BREAK
|
|
ENDSWITCH
|
|
|
|
IF NOT bRemovedBuses
|
|
IF vPlayerPos.y >= -550.1
|
|
AND vPlayerPos.x >= 481.8
|
|
AND vPlayerPos.z <= 25.3
|
|
INT i
|
|
REPEAT NUMBER_YARD_VEHICLES i
|
|
YARD_VEHICLE_ENUM thisYardVehicle = INT_TO_ENUM(YARD_VEHICLE_ENUM, i)
|
|
IF thisYardVehicle = YV_BUS_ROAD_FROM_LEFT
|
|
OR thisYardVehicle = YV_BUS_REVERSE
|
|
OR thisYardVehicle = YV_BUS_PULL_OUT
|
|
OR thisYardVehicle = YV_BUS_STATIC
|
|
OR thisYardVehicle = YV_CAR_STATION_PULL_INTO_DEPOT
|
|
IF DOES_ENTITY_EXIST(yardVehicle[i])
|
|
IF NOT IS_ENTITY_DEAD(yardVehicle[i])
|
|
PED_INDEX thisDriverPed = GET_PED_IN_VEHICLE_SEAT(yardVehicle[i])
|
|
IF DOES_ENTITY_EXIST(thisDriverPed)
|
|
SET_PED_AS_NO_LONGER_NEEDED(thisDriverPed)
|
|
ENDIF
|
|
ENDIF
|
|
|
|
SET_VEHICLE_AS_NO_LONGER_NEEDED(yardVehicle[i])
|
|
ENDIF
|
|
ENDIF
|
|
ENDREPEAT
|
|
|
|
REPEAT NUMBER_YARD_PEDS i
|
|
YARD_PED_ENUM thisYardPed = INT_TO_ENUM(YARD_PED_ENUM, i)
|
|
IF thisYardPed = YP_STATION_WALK_TO_GATE
|
|
OR thisYardPed = YP_STATION_CONV_KNOCK_OVER
|
|
OR thisYardPed = YP_STATION_CONV_LOOK
|
|
OR thisYardPed = YP_STATION_BACK_TURNED_KNOCK_OVER
|
|
IF DOES_ENTITY_EXIST(yardPed[i].ped)
|
|
SET_PED_AS_NO_LONGER_NEEDED(yardPed[i].ped)
|
|
ENDIF
|
|
ENDIF
|
|
ENDREPEAT
|
|
|
|
CLEAR_MODEL_REQUEST(ENUM_TO_INT(HM_BUS))
|
|
|
|
bRemovedBuses = TRUE
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF NOT bRemovedCarpark
|
|
IF bDoneThroughFenceCut
|
|
IF vPlayerPos.y >= -517.4
|
|
AND vPlayerPos.x >= 519.3
|
|
CLEAR_MODEL_REQUEST(ENUM_TO_INT(HM_TRAFFIC_CAR1))
|
|
CLEAR_MODEL_REQUEST(ENUM_TO_INT(HM_TRAFFIC_CAR2))
|
|
|
|
INT i
|
|
REPEAT NUMBER_YARD_VEHICLES i
|
|
YARD_VEHICLE_ENUM thisYardVehicle = INT_TO_ENUM(YARD_VEHICLE_ENUM, i)
|
|
IF thisYardVehicle = YV_CAR_CARPARK_PULL_OUT_FOR_JUMP_OVER
|
|
OR thisYardVehicle = YV_CAR_CARPARK_STATIC
|
|
IF DOES_ENTITY_EXIST(yardVehicle[i])
|
|
IF NOT IS_ENTITY_DEAD(yardVehicle[i])
|
|
PED_INDEX thisDriverPed = GET_PED_IN_VEHICLE_SEAT(yardVehicle[i])
|
|
IF DOES_ENTITY_EXIST(thisDriverPed)
|
|
SET_PED_AS_NO_LONGER_NEEDED(thisDriverPed)
|
|
ENDIF
|
|
ENDIF
|
|
|
|
SET_VEHICLE_AS_NO_LONGER_NEEDED(yardVehicle[i])
|
|
ENDIF
|
|
ENDIF
|
|
ENDREPEAT
|
|
|
|
bRemovedCarpark = TRUE
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
|
|
HANDLE_RUNNER_CHASE()
|
|
IF NOT bRunningCutscene
|
|
HANDLE_CHOP_CHASE()
|
|
ENDIF
|
|
HANDLE_CHASE_SETPIECES()
|
|
BLOCK_FOOT_CHASE_RAGDOLL()
|
|
|
|
HANDLE_REACT_TO_RUN_STAT()
|
|
|
|
DO_NO_STAMINA_HELP_TEXT()
|
|
|
|
//ENABLE_CARGENS_FOR_MISSION(FALSE)
|
|
|
|
//SET_PARKED_VEHICLE_DENSITY_MULTIPLIER_THIS_FRAME(0.0) // temp? OR NOT????
|
|
|
|
IF chopWaitState <> CHOP_WAIT_STATE_WAITING
|
|
DO_CHOP_AUDIO(CHOP_AUDIO_STATE_CHASING)
|
|
ELSE
|
|
IF chopStage = CHOP_TO_FENCE
|
|
DO_CHOP_AUDIO(CHOP_AUDIO_STATE_FOUND_SOMETHING)
|
|
ELSE
|
|
DO_CHOP_AUDIO(CHOP_AUDIO_STATE_WAITING)
|
|
ENDIF
|
|
ENDIF
|
|
|
|
// remove bike
|
|
IF NOT bRemovedBike
|
|
IF DOES_ENTITY_EXIST(hoodVehicle[HV_BAD_GUY_BIKE])
|
|
BOOL bDoRemove = FALSE
|
|
IF NOT IS_ENTITY_DEAD(hoodVehicle[HV_BAD_GUY_BIKE])
|
|
IF NOT IS_ENTITY_AT_ENTITY(PLAYER_PED_ID(), hoodVehicle[HV_BAD_GUY_BIKE], <<70,70,70>>, FALSE, FALSE)
|
|
bDoRemove = TRUE
|
|
ENDIF
|
|
ELSE
|
|
bDoRemove = TRUE
|
|
ENDIF
|
|
|
|
IF bDoRemove
|
|
SET_VEHICLE_AS_NO_LONGER_NEEDED(hoodVehicle[HV_BAD_GUY_BIKE])
|
|
CLEAR_MODEL_REQUEST(ENUM_TO_INT(HM_BIKE))
|
|
bRemovedBike = TRUE
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
|
|
// create the setpieces
|
|
SWITCH createTrainsStage
|
|
CASE CREATE_TRAINS_STAGE_NOT_STARTED
|
|
ADD_MODEL_REQUEST(ENUM_TO_INT(HM_ENGINE))
|
|
ADD_MODEL_REQUEST(ENUM_TO_INT(HM_TANKER_CARRIAGE))
|
|
ADD_MODEL_REQUEST(ENUM_TO_INT(HM_CONTAINER_CARRIAGE))
|
|
createTrainsStage = CREATE_TRAINS_STAGE_WAITING
|
|
BREAK
|
|
CASE CREATE_TRAINS_STAGE_WAITING
|
|
IF HAS_MODEL_LOADED(GET_MODEL_FOR_HOOD_MODEL_ENUM(HM_ENGINE))
|
|
AND HAS_MODEL_LOADED(GET_MODEL_FOR_HOOD_MODEL_ENUM(HM_TANKER_CARRIAGE))
|
|
AND HAS_MODEL_LOADED(GET_MODEL_FOR_HOOD_MODEL_ENUM(HM_CONTAINER_CARRIAGE))
|
|
CREATE_YARD_TRAINS()
|
|
createTrainsStage = CREATE_TRAINS_STAGE_DONE
|
|
ENDIF
|
|
BREAK
|
|
ENDSWITCH
|
|
|
|
IF NOT bRunningCutscene
|
|
/*
|
|
IF GET_GAME_TIMER() >= iActivateChopCamTime + 8000
|
|
|
|
HANDLE_CHOP_VIEW_CAM()
|
|
|
|
IF chopViewCamData.state = CHOP_VIEW_CAM_ON_CHOP
|
|
DRAW_SCENT(FALSE)
|
|
ELSE
|
|
REMOVE_CHOP_SCENT(TRUE)
|
|
ENDIF
|
|
DO_CHOP_CAM_HELP()
|
|
ENDIF
|
|
*/
|
|
|
|
|
|
// handle chop cam warps
|
|
// HANDLE_CHOP_CAM_WARPS()
|
|
|
|
BOOL bAllowDogSpeech = FALSE
|
|
BOOL bAllowBallaSpeech = FALSE
|
|
BOOL bDoDogSpeech = FALSE
|
|
BOOL bDoBallaSpeech = FALSE
|
|
|
|
IF NOT IS_PED_INJURED(chopPed)
|
|
AND NOT IS_PED_INJURED(runnerChaseProperties.ped)
|
|
IF (chopViewCamData.state = CHOP_VIEW_CAM_DISABLED OR IS_ENTITY_AT_ENTITY(PLAYER_PED_ID(), chopPed, <<22,22,22>>, FALSE, FALSE))
|
|
IF IS_ENTITY_AT_ENTITY(PLAYER_PED_ID(), chopPed, <<30,30,30>>, FALSE, FALSE)
|
|
AND GET_ENTITY_SPEED(PLAYER_PED_ID()) >= 3.5
|
|
AND (GET_ENTITY_SPEED(chopPed) >= 3.5 OR chopChaseProperties.chaseState = CHASE_STATE_PERFORMING_ANIM)
|
|
AND chopWaitState = CHOP_WAIT_STATE_NOT_STARTED
|
|
bAllowDogSpeech = TRUE
|
|
ENDIF
|
|
|
|
IF IS_ENTITY_AT_ENTITY(PLAYER_PED_ID(), runnerChaseProperties.ped, <<40,40,40>>, FALSE, FALSE)
|
|
AND GET_ENTITY_SPEED(PLAYER_PED_ID()) >= 3.5
|
|
AND (GET_ENTITY_SPEED(runnerChaseProperties.ped) >= 3.5 OR runnerChaseProperties.chaseState = CHASE_STATE_PERFORMING_ANIM)
|
|
bAllowBallaSpeech = TRUE
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF NOT IS_PED_INJURED(driverPed[YV_CAR_CARPARK_PULL_OUT_FOR_JUMP_OVER])
|
|
IF IS_AMBIENT_SPEECH_PLAYING(driverPed[YV_CAR_CARPARK_PULL_OUT_FOR_JUMP_OVER])
|
|
bAllowDogSpeech = FALSE
|
|
bAllowBallaSpeech = FALSE
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF NOT bDoneJumpHelp
|
|
//IF NOT HAS_ONE_TIME_HELP_DISPLAYED(FHM_CLIMB_HELP)
|
|
IF IS_ENTITY_IN_ANGLED_AREA(PLAYER_PED_ID(), <<480.145, -590.657, 30.419>>, <<467.195, -589.278, 27.000>>, 30.00)
|
|
bDoneJumpHelp = DO_MISSION_HELP_TEXT("FC_JUMHLP", FALSE)
|
|
//IF bDoneJumpHelp
|
|
// SET_ONE_TIME_HELP_MESSAGE_DISPLAYED(FHM_CLIMB_HELP)
|
|
//ENDIF
|
|
ENDIF
|
|
//ELSE
|
|
// bDoneJumpHelp = TRUE
|
|
//ENDIF
|
|
ELSE
|
|
IF IS_THIS_HELP_MESSAGE_BEING_DISPLAYED("FC_JUMHLP")
|
|
IF IS_PED_CLIMBING(PLAYER_PED_ID())
|
|
IF GET_GAME_TIMER() >= iClearHelpTime + 500
|
|
CLEAR_HELP(FALSE)
|
|
iClearHelpTime = GET_GAME_TIMER()
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
|
|
// hood slide help
|
|
IF NOT bShownHoodSlideHelp
|
|
IF IS_ENTITY_IN_ANGLED_AREA(PLAYER_PED_ID(), <<494.46729, -538.49683, 23.75095>>, <<493.09793, -552.72064, 26.25095>>, 7.9)
|
|
AND (runnerChaseProperties.chaseAnim >= CHASE_ANIM_G_OVER_CAR OR runnerStage >= RUNNER_TO_FENCE)
|
|
bShownHoodSlideHelp = DO_MISSION_HELP_TEXT("FC_SLDHLP", FALSE)
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF vPlayerPos.y >= -538.0740
|
|
OR IS_ENTITY_PLAYING_ANIM(PLAYER_PED_ID(), "move_climb", "bonnet_slide_r_in")
|
|
OR IS_ENTITY_PLAYING_ANIM(PLAYER_PED_ID(), "move_climb", "bonnet_slide_l_in")
|
|
bShownHoodSlideHelp = TRUE
|
|
IF IS_THIS_HELP_MESSAGE_BEING_DISPLAYED("FC_SLDHLP")
|
|
IF GET_GAME_TIMER() >= iClearHelpTime + 500
|
|
|
|
REPLAY_RECORD_BACK_FOR_TIME(3.0, 4.0, REPLAY_IMPORTANCE_HIGH)
|
|
|
|
CLEAR_HELP(FALSE)
|
|
iClearHelpTime = GET_GAME_TIMER()
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
|
|
|
|
IF bAllowDogSpeech
|
|
IF bAllowBallaSpeech
|
|
SWITCH GET_RANDOM_INT_IN_RANGE(0,3)
|
|
CASE 1
|
|
CASE 2
|
|
bDoBallaSpeech = TRUE
|
|
BREAK
|
|
CASE 0
|
|
bDoDogSpeech = TRUE
|
|
BREAK
|
|
ENDSWITCH
|
|
ELSE
|
|
bDoDogSpeech = TRUE
|
|
ENDIF
|
|
ELSE
|
|
IF bAllowBallaSpeech
|
|
bDoBallaSpeech = TRUE
|
|
ELSE
|
|
IF GET_GAME_TIMER() >= iNextRandomSpeechTime
|
|
SET_NEXT_RANDOM_SPEECH_TIME(500, 2000)
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF NOT bFranklinShoutBeforeTrain
|
|
IF runnerStage <> RUNNER_TO_TRAIN
|
|
IF bDoBallaSpeech
|
|
IF GET_RANDOM_INT_IN_RANGE(0,2) = 0
|
|
DO_RANDOM_SPEECH("FKN0_FCHASE", -1, 7000, 10000)
|
|
ELSE
|
|
DO_RANDOM_SPEECH("FKN0_OG2", -1, 7000, 10000)
|
|
ENDIF
|
|
ELIF bDoDogSpeech
|
|
DO_RANDOM_SPEECH("FKN0_DOGCHS", -1, 7000, 10000)
|
|
ENDIF
|
|
ELSE
|
|
IF NOT IS_PED_INJURED(chopPed)
|
|
IF IS_ENTITY_IN_ANGLED_AREA(chopPed, <<560.952,-532.453,28.700>>, <<574.626,-533.877,13.742>>, 50)
|
|
AND IS_ENTITY_IN_ANGLED_AREA(PLAYER_PED_ID(), <<560.952,-532.453,28.700>>, <<574.626,-533.877,13.742>>, 50)
|
|
IF IS_ENTITY_ON_SCREEN(chopPed)
|
|
bFranklinShoutBeforeTrain = DO_MISSION_SPEECH("FKN0_GETHIM")
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF NOT bClearedPlayerRun
|
|
IF GET_GAME_TIMER() >= iStageStartTime + 1000
|
|
bClearedPlayerRun = TRUE
|
|
ELSE
|
|
IF GET_FOLLOW_PED_CAM_VIEW_MODE() <> CAM_VIEW_MODE_FIRST_PERSON
|
|
SET_PED_MIN_MOVE_BLEND_RATIO(PLAYER_PED_ID(), PEDMOVE_SPRINT)
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF bDoneThroughFenceCut
|
|
IF bDoRunAfterFence
|
|
IF GET_GAME_TIMER() <= iThroughFenceTime + 400//140
|
|
IF GET_FOLLOW_PED_CAM_VIEW_MODE() <> CAM_VIEW_MODE_FIRST_PERSON
|
|
SET_PED_MIN_MOVE_BLEND_RATIO(PLAYER_PED_ID(), PEDMOVE_RUN)
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
|
|
// remove traffic
|
|
IF NOT bRemovedTraffic
|
|
IF NOT IS_ENTITY_AT_COORD(PLAYER_PED_ID(), GET_HOOD_VECTOR(HVEC_VAN_IN_ALLEY), <<80,80,80>>, FALSE, FALSE)
|
|
REMOVE_TRAFFIC_OUTSIDE_STATION()
|
|
ENDIF
|
|
ENDIF
|
|
|
|
// remove bus station
|
|
IF NOT bRemovedBusStation
|
|
IF vPlayerPos.x > 485.92
|
|
AND vPlayerPos.y > -519
|
|
AND vPlayerPos.z < 29.32
|
|
REMOVE_BUS_STATION()
|
|
ENDIF
|
|
ENDIF
|
|
|
|
// slow down franklin
|
|
IF NOT IS_PED_INJURED(runnerChaseProperties.ped)
|
|
IF IS_ENTITY_AT_ENTITY(PLAYER_PED_ID(), runnerChaseProperties.ped, <<18,18,18>>, FALSE, FALSE)
|
|
SET_PED_MOVE_RATE_OVERRIDE(PLAYER_PED_ID(), 0.94)
|
|
ELSE
|
|
SET_PED_MOVE_RATE_OVERRIDE(PLAYER_PED_ID(), 0.97)
|
|
ENDIF
|
|
ELSE
|
|
SET_PED_MOVE_RATE_OVERRIDE(PLAYER_PED_ID(), 0.97)
|
|
ENDIF
|
|
|
|
|
|
|
|
/*
|
|
IF NOT bForcedJumpOffRoof
|
|
IF IS_ENTITY_IN_ANGLED_AREA(PLAYER_PED_ID(), <<490.150, -564.190, 30.500>>, <<489.840, -566.660, 28.010>>, 11.600, FALSE, TRUE, TM_ON_FOOT)
|
|
IF IS_PED_AT_CORRECT_HEADING_FOR_CHASE_ANIM(PLAYER_PED_ID(), CHASE_ANIM_F_OFF_ROOF, 20)
|
|
AND GET_ENTITY_SPEED(PLAYER_PED_ID()) >= 3.2
|
|
AND chopViewCamData.state = CHOP_VIEW_CAM_DISABLED
|
|
TASK_JUMP(PLAYER_PED_ID(), TRUE)
|
|
bForcedJumpOffRoof = TRUE
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
*/
|
|
|
|
|
|
// cut smashing through fence
|
|
IF NOT bDoneThroughFenceCut
|
|
// disable ragdoll jump when really near
|
|
IF IS_ENTITY_IN_AREA(PLAYER_PED_ID(), <<488.71494, -527.19843, 23.75116>>, <<499.25632, -517.15485, 25.89596>>)
|
|
IF IS_PED_JUMPING(PLAYER_PED_ID())
|
|
DISABLE_CONTROL_ACTION(PLAYER_CONTROL, INPUT_MELEE_ATTACK_LIGHT)
|
|
DISABLE_CONTROL_ACTION(PLAYER_CONTROL, INPUT_MELEE_ATTACK_HEAVY)
|
|
DISABLE_CONTROL_ACTION(PLAYER_CONTROL, INPUT_MELEE_ATTACK_ALTERNATE)
|
|
DISABLE_CONTROL_ACTION(PLAYER_CONTROL, INPUT_MELEE_BLOCK)
|
|
DISABLE_CONTROL_ACTION(PLAYER_CONTROL, INPUT_ATTACK)
|
|
DISABLE_CONTROL_ACTION(PLAYER_CONTROL, INPUT_ATTACK2)
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF chopViewCamData.state = CHOP_VIEW_CAM_DISABLED
|
|
//PRINTFLOAT(GET_ENTITY_SPEED(PLAYER_PED_ID())) PRINTNL()
|
|
IF IS_ENTITY_IN_ANGLED_AREA(PLAYER_PED_ID(), <<494.300, -516.890, 23.050>>, <<494.070, -519.450, 25.850>>, 7.800, FALSE, TRUE, TM_ON_FOOT) // 4.8
|
|
IF IS_PED_AT_CORRECT_HEADING_FOR_CHASE_ANIM(PLAYER_PED_ID(), CHASE_ANIM_F_THROUGH_YARD_FENCE, 50)
|
|
//IF GET_ENTITY_SPEED(PLAYER_PED_ID()) >= 3.0
|
|
IF NOT IS_PED_IN_ANY_VEHICLE(PLAYER_PED_ID())
|
|
AND NOT IS_PED_RAGDOLL(PLAYER_PED_ID())
|
|
IF CAN_PLAYER_START_CUTSCENE()
|
|
iCurrentFootChaseCutscene = 1
|
|
IF CAN_ADVANCE_MISSION()
|
|
bRunningCutscene = TRUE
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ELIF vPlayerPos.y >= -516.9
|
|
OR runnerStage >= RUNNER_TO_TRAIN
|
|
OR IS_ENTITY_IN_ANGLED_AREA(PLAYER_PED_ID(), <<521.171, -552.487, 23.781>>, <<526.091, -519.091, 29.735>>, 40.0)
|
|
bBypassedFence = TRUE
|
|
bDoneThroughFenceCut = TRUE
|
|
ELSE
|
|
OBJECT_INDEX fenceObject = GET_CLOSEST_OBJECT_OF_TYPE(<<494.3488, -516.8829, 23.8982>>, 2, PROP_FNCCONSTRUC_01D, FALSE)
|
|
IF DOES_ENTITY_EXIST(fenceObject)
|
|
IF HAS_OBJECT_BEEN_BROKEN(fenceObject)
|
|
bBypassedFence = TRUE
|
|
bDoneThroughFenceCut = TRUE
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ELSE
|
|
/*
|
|
IF NOT bShownChopFenceHelp
|
|
IF IS_ENTITY_AT_COORD(chopPed, <<493.12, -519.17, 23.75>>, <<2.0, 3.0, LOCATE_SIZE_HEIGHT>>, FALSE, FALSE)
|
|
IF GET_ENTITY_SPEED(chopPed) <= 1.0
|
|
DO_MISSION_HELP_TEXT("FC_FENHLP")
|
|
bShownChopFenceHelp = TRUE
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
*/
|
|
ENDIF
|
|
ELSE
|
|
IF NOT bDoneBypassFenceCue
|
|
IF NOT bDoneSmashFenceCue
|
|
bDoneBypassFenceCue = TRIGGER_MISSION_MUSIC_EVENT("FRA0_BYPASS_FENCE")
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF NOT bDoneBreakFenceAudioScene
|
|
STOP_HOOD_AUDIO_SCENE(HOOD_AUDIO_SCENE_FOOT_CHASE_START)
|
|
START_HOOD_AUDIO_SCENE(HOOD_AUDIO_SCENE_BREAK_THROUGH_FENCE)
|
|
bDoneBreakFenceAudioScene = TRUE
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF bBypassedFence
|
|
SWITCH chopBypassFenceState
|
|
CASE CHOP_BYPASS_FENCE_NOT_STARTED
|
|
IF chopChaseProperties.chaseState = CHASE_STATE_MOVING
|
|
INT iClosestWaypointToChop
|
|
WAYPOINT_RECORDING_GET_CLOSEST_WAYPOINT("hood11", GET_ENTITY_COORDS(chopPed), iClosestWaypointToChop)
|
|
TASK_FOLLOW_WAYPOINT_RECORDING(chopPed, "hood11", iClosestWaypointToChop, EWAYPOINT_NAVMESH_BACK_TO_WAYPOINT_IF_LEFT_ROUTE)
|
|
|
|
chopChaseProperties.bWaiting = FALSE
|
|
chopWaitState = CHOP_WAIT_STATE_DONE
|
|
chopChaseProperties.chaseState = CHASE_STATE_MOVING
|
|
chopChaseProperties.iSyncScene = -1
|
|
chopChaseProperties.iMovingTime = GET_GAME_TIMER()
|
|
chopStage = CHOP_TO_FLATBEDS
|
|
chopBypassFenceState = CHOP_BYPASS_FENCE_PERFORMING_BYPASS
|
|
ENDIF
|
|
BREAK
|
|
|
|
CASE CHOP_BYPASS_FENCE_PERFORMING_BYPASS
|
|
IF chopChaseProperties.chaseState <> CHASE_STATE_MOVING
|
|
chopBypassFenceState = CHOP_BYPASS_FENCE_DONE
|
|
ENDIF
|
|
BREAK
|
|
ENDSWITCH
|
|
ENDIF
|
|
|
|
IF bFailForLost
|
|
IF GET_GAME_TIMER() >= iFailForLostTime + 3000
|
|
MISSION_FAILED(FAIL_LOST_BAD_GUY)
|
|
ENDIF
|
|
ENDIF
|
|
|
|
// do jump on train cut
|
|
IF NOT bDoneOnTrainCut
|
|
IF NOT IS_PED_INJURED(runnerChaseProperties.ped)
|
|
IF runnerStage = RUNNER_TO_TRAIN
|
|
IF IS_ENTITY_AT_COORD(runnerChaseProperties.ped, GET_CHASE_ANIM_COORDS(CHASE_ANIM_G_ONTO_TRAIN), <<1.0, 1.0, 3.0>>)
|
|
IF IS_ENTITY_IN_ANGLED_AREA(PLAYER_PED_ID(), <<542.683, -531.091, 23.268>>, <<588.103, -536.543, 30.591>>, 80)
|
|
OR IS_ENTITY_AT_ENTITY(PLAYER_PED_ID(), runnerChaseProperties.ped, <<18,18,18>>, FALSE, FALSE)
|
|
OR (IS_ENTITY_ON_SCREEN(runnerChaseProperties.ped) AND NOT IS_ENTITY_OCCLUDED(runnerChaseProperties.ped))
|
|
OR chopViewCamData.state <> CHOP_VIEW_CAM_DISABLED
|
|
iCurrentFootChaseCutscene = 2
|
|
IF CAN_ADVANCE_MISSION()
|
|
bRunningCutscene = TRUE
|
|
ENDIF
|
|
ELSE
|
|
IF DOES_BLIP_EXIST(runnerBlip)
|
|
REMOVE_BLIP(runnerBlip)
|
|
ENDIF
|
|
IF DOES_ENTITY_EXIST(runnerChaseProperties.ped)
|
|
DELETE_PED(runnerChaseProperties.ped)
|
|
ENDIF
|
|
bFailForLost = TRUE
|
|
iFailForLostTime = GET_GAME_TIMER()
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ELSE
|
|
SWITCH iCurrentFootChaseCutscene
|
|
CASE 0
|
|
// DO_OFF_ROOF_CUTSCENE()
|
|
BREAK
|
|
CASE 1
|
|
DO_THROUGH_FENCE_CUTSCENE()
|
|
BREAK
|
|
CASE 2
|
|
DO_ON_TRAIN_CUTSCENE()
|
|
BREAK
|
|
ENDSWITCH
|
|
ENDIF
|
|
ENDPROC
|
|
|
|
// pull chop off dog cutscene
|
|
PROC DO_CHOP_PULL_CUTSCENE()
|
|
SWITCH cutsceneStage
|
|
CASE H_CUT_STAGE_INIT
|
|
SET_MISSION_CUTSCENE(TRUE)
|
|
//CREATE_CAM_FOR_HOOD_SHOT(H_SHOT_FIND, TRUE, 3000)
|
|
CLEAR_AREA(<<502.85, -648.35, 23.75>>, 4.0, TRUE)
|
|
IF NOT IS_PED_INJURED(chopPed)
|
|
AND NOT IS_PED_INJURED(colliePed)
|
|
AND NOT IS_PED_INJURED(PLAYER_PED_ID())
|
|
chopChaseProperties.iSyncScene = CREATE_SYNCHRONIZED_SCENE(GET_ENTITY_COORDS(colliePed), GET_ENTITY_ROTATION(colliePed))
|
|
|
|
CLEAR_PED_TASKS_IMMEDIATELY(PLAYER_PED_ID())
|
|
CLEAR_PED_SECONDARY_TASK(PLAYER_PED_ID())
|
|
TASK_CLEAR_LOOK_AT(PLAYER_PED_ID())
|
|
SET_CURRENT_PED_WEAPON(PLAYER_PED_ID(), WEAPONTYPE_UNARMED, TRUE)
|
|
SET_PED_STEALTH_MOVEMENT(PLAYER_PED_ID(), FALSE)
|
|
|
|
TASK_SYNCHRONIZED_SCENE(PLAYER_PED_ID(), chopChaseProperties.iSyncScene, GET_HOOD_ANIM_DICT_AS_STRING(H_ANIM_DICT_FIND), "Hump_Exit_Scene_FRANKLIN", INSTANT_BLEND_IN, SLOW_BLEND_OUT)
|
|
TASK_SYNCHRONIZED_SCENE(chopPed, chopChaseProperties.iSyncScene, GET_HOOD_ANIM_DICT_AS_STRING(H_ANIM_DICT_FIND), "Hump_Exit_Scene_CHOP", INSTANT_BLEND_IN, SLOW_BLEND_OUT)
|
|
TASK_SYNCHRONIZED_SCENE(colliePed, chopChaseProperties.iSyncScene, GET_HOOD_ANIM_DICT_AS_STRING(H_ANIM_DICT_FIND), "Hump_Exit_Scene_LADYDOG", INSTANT_BLEND_IN, SLOW_BLEND_OUT)
|
|
SET_SYNCHRONIZED_SCENE_HOLD_LAST_FRAME(chopChaseProperties.iSyncScene, FALSE)
|
|
FORCE_PED_AI_AND_ANIMATION_UPDATE(PLAYER_PED_ID())
|
|
FORCE_PED_AI_AND_ANIMATION_UPDATE(chopPed)
|
|
FORCE_PED_AI_AND_ANIMATION_UPDATE(colliePed)
|
|
|
|
CREATE_MISSION_ANIM_CAM()
|
|
PLAY_SYNCHRONIZED_CAM_ANIM(animCam, chopChaseProperties.iSyncScene, "Hump_Exit_Scene_CAM", GET_HOOD_ANIM_DICT_AS_STRING(H_ANIM_DICT_FIND))
|
|
ENDIF
|
|
|
|
iHoodCutsceneTime = GET_GAME_TIMER()
|
|
cutsceneStage = H_CUT_STAGE_RUNNING
|
|
BREAK
|
|
|
|
CASE H_CUT_STAGE_RUNNING
|
|
IF NOT bDoneGoAwaySpeech
|
|
IF NOT bDoneItsADudeSpeech
|
|
IF DO_MISSION_SPEECH("FKN0_MALE", TRUE)
|
|
bDoneItsADudeSpeech = TRUE
|
|
bDoneGoAwaySpeech = TRUE
|
|
ENDIF
|
|
ELSE
|
|
bDoneGoAwaySpeech = DO_MISSION_SPEECH("FC_GOAWAY", TRUE)
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF IS_SYNCHRONIZED_SCENE_RUNNING(chopChaseProperties.iSyncScene)
|
|
//IF GET_SYNCHRONIZED_SCENE_PHASE(chopChaseProperties.iSyncScene) >= 0.73
|
|
// cutsceneStage = H_CUT_STAGE_CLEANUP
|
|
//ENDIF
|
|
ELSE
|
|
cutsceneStage = H_CUT_STAGE_CLEANUP
|
|
ENDIF
|
|
BREAK
|
|
|
|
CASE H_CUT_STAGE_CLEANUP
|
|
// back to gameplay
|
|
//CLEAR_PED_TASKS_IMMEDIATELY(PLAYER_PED_ID())
|
|
//FORCE_PED_AI_AND_ANIMATION_UPDATE(PLAYER_PED_ID())
|
|
//IF NOT IS_PED_INJURED(chopPed)
|
|
// CLEAR_PED_TASKS_IMMEDIATELY(chopPed)
|
|
// FORCE_PED_AI_AND_ANIMATION_UPDATE(chopPed)
|
|
//ENDIF
|
|
//IF NOT IS_PED_INJURED(colliePed)
|
|
//// CLEAR_PED_TASKS_IMMEDIATELY(colliePed)
|
|
// FORCE_PED_AI_AND_ANIMATION_UPDATE(colliePed)
|
|
//ENDIF
|
|
SET_CHOP_BEHAVIOUR_SETPIECE_STAGE(CBS_RETURN)
|
|
|
|
//SET_MISSION_CUTSCENE(FALSE, FALSE)
|
|
|
|
COMMON_MISSION_CUTSCENE_BLENDOUT()
|
|
|
|
bShouldCommentOnBehaviour = TRUE
|
|
bDoingChopPull = FALSE
|
|
bRunningCutscene = FALSE
|
|
BREAK
|
|
ENDSWITCH
|
|
ENDPROC
|
|
|
|
/*
|
|
// cleanup found cutscene
|
|
PROC CLEANUP_FOUND_CUTSCENE()
|
|
IF bSkippedCutscene
|
|
ENDIF
|
|
|
|
CLEAR_PED_TASKS_IMMEDIATELY(PLAYER_PED_ID())
|
|
SET_ENTITY_COORDS(PLAYER_PED_ID(), <<526.76, -679.98, 24.81>>)
|
|
SET_ENTITY_HEADING(PLAYER_PED_ID(), 82.97)
|
|
|
|
IF NOT IS_PED_INJURED(runnerChaseProperties.ped)
|
|
CLEAR_PED_TASKS_IMMEDIATELY(runnerChaseProperties.ped)
|
|
SET_ENTITY_COORDS(runnerChaseProperties.ped, <<523.41, -679.45, 23.79>>)
|
|
SET_ENTITY_HEADING(runnerChaseProperties.ped, 99.91)
|
|
TASK_FOLLOW_WAYPOINT_RECORDING(runnerChaseProperties.ped, "hood5", 5, EWAYPOINT_DO_NOT_RESPOND_TO_COLLISION_EVENTS)
|
|
ENDIF
|
|
|
|
IF NOT IS_PED_INJURED(chopPed)
|
|
CLEAR_PED_TASKS_IMMEDIATELY(chopPed)
|
|
|
|
SET_ENTITY_COORDS(chopPed, <<525.47, -679.09, 24.81>>)
|
|
SET_ENTITY_HEADING(chopPed, 93.91)
|
|
CLEAR_SEQUENCE_TASK(sequence)
|
|
OPEN_SEQUENCE_TASK(sequence)
|
|
TASK_PAUSE(NULL, 400)
|
|
TASK_FOLLOW_WAYPOINT_RECORDING(NULL, "hood5", 6)
|
|
CLOSE_SEQUENCE_TASK(sequence)
|
|
TASK_PERFORM_SEQUENCE(chopPed, sequence)
|
|
ENDIF
|
|
|
|
IF NOT DOES_BLIP_EXIST(chopBlip)
|
|
chopBlip = CREATE_MISSION_BLIP_FOR_PED(chopPed)
|
|
ENDIF
|
|
|
|
// back to gameplay
|
|
mocapStreamingStage = MOCAP_STREAMING_STAGE_REQUEST
|
|
iRunnerStageStartTime = GET_GAME_TIMER()
|
|
SET_MISSION_CUTSCENE(FALSE)
|
|
bShownGodText = FALSE
|
|
bDoneGotoSpeech = FALSE
|
|
bFoundBadGuy = TRUE
|
|
ENDPROC
|
|
|
|
// find bad guy hiding cutscene
|
|
PROC DO_FOUND_CUTSCENE()
|
|
SWITCH cutsceneStage
|
|
CASE H_CUT_STAGE_INIT
|
|
//SET_MISSION_CUTSCENE(TRUE)
|
|
iHoodCutsceneTime = GET_GAME_TIMER()
|
|
|
|
IF NOT IS_PED_INJURED(PLAYER_PED_ID())
|
|
SET_PED_STEALTH_MOVEMENT(PLAYER_PED_ID(), FALSE)
|
|
TASK_CLEAR_LOOK_AT(PLAYER_PED_ID())
|
|
REGISTER_ENTITY_FOR_CUTSCENE(PLAYER_PED_ID(), "Franklin", CU_ANIMATE_EXISTING_SCRIPT_ENTITY)
|
|
ENDIF
|
|
|
|
IF NOT IS_PED_INJURED(runnerChaseProperties.ped)
|
|
FREEZE_ENTITY_POSITION(runnerChaseProperties.ped, FALSE)
|
|
REGISTER_ENTITY_FOR_CUTSCENE(runnerChaseProperties.ped, "Ballas_OG", CU_ANIMATE_EXISTING_SCRIPT_ENTITY)
|
|
ENDIF
|
|
|
|
IF NOT IS_PED_INJURED(chopPed)
|
|
REGISTER_ENTITY_FOR_CUTSCENE(chopPed, "Chop", CU_ANIMATE_EXISTING_SCRIPT_ENTITY)
|
|
ENDIF
|
|
|
|
INT i,j
|
|
REPEAT NUMBER_BOXCARS i
|
|
REPEAT 2 j
|
|
IF DOES_ENTITY_EXIST(boxcarCarriage[i].boxcarDoor[j].obj)
|
|
DELETE_OBJECT(boxcarCarriage[i].boxcarDoor[j].obj)
|
|
ENDIF
|
|
ENDREPEAT
|
|
ENDREPEAT
|
|
|
|
START_CUTSCENE()
|
|
SET_CUTSCENE_FADE_VALUES(FALSE, FALSE, FALSE, FALSE)
|
|
cutsceneStage = H_CUT_STAGE_RUNNING
|
|
BREAK
|
|
|
|
CASE H_CUT_STAGE_RUNNING
|
|
// clear the area
|
|
IF NOT bClearedForCutscene
|
|
IF IS_CUTSCENE_PLAYING()
|
|
SET_MISSION_MOCAP_CUTSCENE()
|
|
|
|
// clear the area
|
|
CLEAR_AREA(<<526.77, -679.35, 24.89>>, 12, TRUE)
|
|
|
|
// get rid of collie ped
|
|
IF DOES_ENTITY_EXIST(colliePed)
|
|
DELETE_PED(colliePed)
|
|
ENDIF
|
|
|
|
bClearedForCutscene = TRUE
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF CAN_SET_EXIT_STATE_FOR_REGISTERED_ENTITY("Franklin")
|
|
IF WAS_CUTSCENE_SKIPPED()
|
|
bSkippedCutscene = TRUE
|
|
ENDIF
|
|
CLEANUP_FOUND_CUTSCENE()
|
|
ENDIF
|
|
|
|
#IF IS_DEBUG_BUILD
|
|
DEBUG_SKIP_MOCAP()
|
|
#ENDIF
|
|
BREAK
|
|
|
|
CASE H_CUT_STAGE_CLEANUP
|
|
|
|
BREAK
|
|
ENDSWITCH
|
|
ENDPROC
|
|
*/
|
|
|
|
// kidnap cutscene
|
|
PROC DO_KIDNAP_CUTSCENE()
|
|
SET_ALL_RANDOM_PEDS_FLEE_THIS_FRAME(PLAYER_ID())
|
|
IF IS_VEHICLE_DRIVEABLE(hoodVehicle[HV_FRANKLIN_VAN])
|
|
SET_VEHICLE_BRAKE_LIGHTS(hoodVehicle[HV_FRANKLIN_VAN], FALSE)
|
|
ENDIF
|
|
|
|
SWITCH cutsceneStage
|
|
CASE H_CUT_STAGE_INIT
|
|
//SET_MISSION_CUTSCENE(TRUE)
|
|
iHoodCutsceneTime = GET_GAME_TIMER()
|
|
|
|
SET_AUDIO_FLAG("DisableAbortConversationForRagdoll", FALSE)
|
|
|
|
IF NOT IS_PED_INJURED(PLAYER_PED_ID())
|
|
REGISTER_ENTITY_FOR_CUTSCENE(PLAYER_PED_ID(), "Franklin", CU_ANIMATE_EXISTING_SCRIPT_ENTITY)
|
|
ENDIF
|
|
|
|
IF NOT IS_PED_INJURED(lamarPed)
|
|
TASK_CLEAR_LOOK_AT(lamarPed)
|
|
REGISTER_ENTITY_FOR_CUTSCENE(lamarPed, "Lamar", CU_ANIMATE_EXISTING_SCRIPT_ENTITY)
|
|
ENDIF
|
|
|
|
IF NOT IS_PED_INJURED(chopPed)
|
|
DETACH_ENTITY(chopPed)
|
|
REGISTER_ENTITY_FOR_CUTSCENE(chopPed, "Chop", CU_ANIMATE_EXISTING_SCRIPT_ENTITY)
|
|
ENDIF
|
|
|
|
IF NOT IS_PED_INJURED(runnerChaseProperties.ped)
|
|
REGISTER_ENTITY_FOR_CUTSCENE(runnerChaseProperties.ped, "Ballas_OG", CU_ANIMATE_EXISTING_SCRIPT_ENTITY)
|
|
ENDIF
|
|
|
|
IF IS_VEHICLE_DRIVEABLE(hoodVehicle[HV_FRANKLIN_VAN])
|
|
FREEZE_ENTITY_POSITION(hoodVehicle[HV_FRANKLIN_VAN], FALSE)
|
|
REGISTER_ENTITY_FOR_CUTSCENE(hoodVehicle[HV_FRANKLIN_VAN], "Kidnapping_Van", CU_ANIMATE_EXISTING_SCRIPT_ENTITY, DUMMY_MODEL_FOR_SCRIPT, CEO_IS_CASCADE_SHADOW_FOCUS_ENTITY_DURING_EXIT)
|
|
ENDIF
|
|
|
|
KILL_FACE_TO_FACE_CONVERSATION_DO_NOT_FINISH_LAST_LINE()
|
|
|
|
START_CUTSCENE(CUTSCENE_SUPPRESS_FP_TRANSITION_FLASH)
|
|
//SET_VEHICLE_MODEL_PLAYER_WILL_EXIT_SCENE(SPEEDO)
|
|
bDoneFlash = FALSE
|
|
|
|
REPLAY_START_EVENT(REPLAY_IMPORTANCE_HIGHEST)
|
|
|
|
SET_CUTSCENE_FADE_VALUES(FALSE, FALSE, FALSE, FALSE)
|
|
cutsceneStage = H_CUT_STAGE_RUNNING
|
|
BREAK
|
|
|
|
CASE H_CUT_STAGE_RUNNING
|
|
IF NOT bClearedForCutscene
|
|
IF IS_CUTSCENE_PLAYING()
|
|
SET_MISSION_MOCAP_CUTSCENE()
|
|
// clear the area
|
|
CLEAR_AREA(<<511.55, -652.05, 23.75>>, 20.0, TRUE, TRUE)
|
|
CLEAR_AREA_OF_PROJECTILES(<<511.96359, -658.37054, 23.75104>>, 25)
|
|
STOP_FIRE_IN_RANGE(<<511.96359, -658.37054, 23.75104>>, 25)
|
|
REMOVE_PARTICLE_FX_IN_RANGE(<<511.96359, -658.37054, 23.75104>>, 25)
|
|
|
|
SET_SELECTOR_PED_HINT(sSelectorPeds, SELECTOR_PED_FRANKLIN, FALSE)
|
|
|
|
IF IS_VEHICLE_DRIVEABLE(hoodVehicle[HV_FRANKLIN_VAN])
|
|
//SET_VEHICLE_RADIO_ENABLED(hoodVehicle[HV_FRANKLIN_VAN], TRUE)
|
|
REMOVE_VEHICLE_WINDOW(hoodVehicle[HV_FRANKLIN_VAN], SC_WINDOW_FRONT_LEFT)
|
|
SET_VEHICLE_DOOR_CONTROL(hoodVehicle[HV_FRANKLIN_VAN], SC_DOOR_FRONT_LEFT, DT_DOOR_INTACT, 0.0)
|
|
SET_VEHICLE_DOOR_CONTROL(hoodVehicle[HV_FRANKLIN_VAN], SC_DOOR_REAR_RIGHT, DT_DOOR_INTACT, 0.0)
|
|
SET_VEHICLE_DOOR_CONTROL(hoodVehicle[HV_FRANKLIN_VAN], SC_DOOR_REAR_LEFT, DT_DOOR_INTACT, 0.0)
|
|
ENDIF
|
|
|
|
STOP_VEHICLE_FIRE(hoodVehicle[HV_FRANKLIN_VAN])
|
|
|
|
//SET_DAMAGE_ON_BAD_GUY(TRUE)
|
|
|
|
STOP_HOOD_AUDIO_SCENE(HOOD_AUDIO_SCENE_SEARCH_BOXCARS)
|
|
|
|
IF bForcePassOnShitskip
|
|
DO_SCREEN_FADE_IN(DEFAULT_FADE_TIME)
|
|
bForcePassOnShitskip = FALSE
|
|
ELSE
|
|
IF IS_SCREEN_FADED_OUT()
|
|
DO_SCREEN_FADE_IN(DEFAULT_FADE_TIME)
|
|
ENDIF
|
|
ENDIF
|
|
|
|
bClearedForCutscene = TRUE
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF NOT bDoneCutsceneBlood
|
|
IF DOES_ENTITY_EXIST(GET_ENTITY_INDEX_OF_CUTSCENE_ENTITY("Ballas_OG"))
|
|
PED_INDEX cutscenePed
|
|
cutscenePed = GET_PED_INDEX_FROM_ENTITY_INDEX(GET_ENTITY_INDEX_OF_CUTSCENE_ENTITY("Ballas_OG", csb_ballasog))
|
|
IF NOT IS_PED_INJURED(cutscenePed)
|
|
APPLY_PED_BLOOD_SPECIFIC(cutscenePed, ENUM_TO_INT(PDZ_LEFT_ARM), 0.536, 0.601, 93.240, 0.695, -1, 0, "stab")
|
|
APPLY_PED_BLOOD_SPECIFIC(cutscenePed, ENUM_TO_INT(PDZ_LEFT_ARM), 0.536, 0.561, 95.040, 0.695, -1, 0, "stab")
|
|
APPLY_PED_BLOOD_SPECIFIC(cutscenePed, ENUM_TO_INT(PDZ_LEFT_ARM), 0.476, 0.531, 95.140, 0.695, -1, 0, "stab")
|
|
bDoneCutsceneBlood = TRUE
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF NOT bDoneBaddyCue
|
|
IF bPreparedBaddyCue
|
|
bDoneBaddyCue = TRIGGER_MISSION_MUSIC_EVENT("FRA0_BADDY")
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF GET_CUTSCENE_TIME() >= 37400
|
|
// CLOSE_ALL_VAN_DOORS()
|
|
ENDIF
|
|
|
|
//IF CAN_SET_EXIT_STATE_FOR_CAMERA()
|
|
//SET_MISSION_CUTSCENE(FALSE)
|
|
//SET_MISSION_STAGE(STAGE_GET_TO_HOUSE)
|
|
//ENDIF
|
|
|
|
IF NOT bDoneFlash
|
|
IF GET_FOLLOW_VEHICLE_CAM_VIEW_MODE() = CAM_VIEW_MODE_FIRST_PERSON
|
|
IF GET_CUTSCENE_TIME() >= GET_CUTSCENE_TOTAL_DURATION() - 300
|
|
ANIMPOSTFX_PLAY("CamPushInNeutral", 0, FALSE)
|
|
PLAY_SOUND_FRONTEND(-1, "1st_Person_Transition", "PLAYER_SWITCH_CUSTOM_SOUNDSET")
|
|
bDoneFlash = TRUE
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF CAN_SET_EXIT_STATE_FOR_REGISTERED_ENTITY("Franklin")
|
|
|
|
REPLAY_STOP_EVENT()
|
|
|
|
IF IS_VEHICLE_DRIVEABLE(hoodVehicle[HV_FRANKLIN_VAN])
|
|
SET_PED_INTO_VEHICLE(PLAYER_PED_ID(), hoodVehicle[HV_FRANKLIN_VAN], VS_DRIVER)
|
|
FORCE_PED_AI_AND_ANIMATION_UPDATE(PLAYER_PED_ID())
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF CAN_SET_EXIT_STATE_FOR_REGISTERED_ENTITY("Ballas_OG")
|
|
IF IS_VEHICLE_DRIVEABLE(hoodVehicle[HV_FRANKLIN_VAN])
|
|
AND NOT IS_PED_INJURED(runnerChaseProperties.ped)
|
|
SET_PED_CAN_PLAY_AMBIENT_BASE_ANIMS(runnerChaseProperties.ped, FALSE)
|
|
SET_PED_CAN_PLAY_AMBIENT_ANIMS(runnerChaseProperties.ped, FALSE)
|
|
|
|
SET_PED_INTO_VEHICLE(runnerChaseProperties.ped, hoodVehicle[HV_FRANKLIN_VAN], VS_BACK_RIGHT)
|
|
FORCE_PED_AI_AND_ANIMATION_UPDATE(runnerChaseProperties.ped)
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF CAN_SET_EXIT_STATE_FOR_REGISTERED_ENTITY("Chop")
|
|
IF IS_VEHICLE_DRIVEABLE(hoodVehicle[HV_FRANKLIN_VAN])
|
|
AND NOT IS_PED_INJURED(chopPed)
|
|
SET_CHOP_INTO_VAN(chopPed, hoodVehicle[HV_FRANKLIN_VAN], chopLeanInVanState, fCachedVanSpeed, TRUE)
|
|
SET_ENTITY_PROOFS(chopPed, FALSE, TRUE, TRUE, FALSE, FALSE, FALSE, FALSE, TRUE)
|
|
SET_PED_CAN_RAGDOLL(chopPed, FALSE)
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF CAN_SET_EXIT_STATE_FOR_REGISTERED_ENTITY("Lamar")
|
|
IF IS_VEHICLE_DRIVEABLE(hoodVehicle[HV_FRANKLIN_VAN])
|
|
AND NOT IS_PED_INJURED(lamarPed)
|
|
SET_LAMAR_MASK(FALSE)
|
|
SET_PED_INTO_VEHICLE(lamarPed, hoodVehicle[HV_FRANKLIN_VAN], VS_FRONT_RIGHT)
|
|
TASK_PLAY_ANIM(lamarPed, GET_HOOD_ANIM_DICT_AS_STRING(H_ANIM_DICT_DRIVE_HOME), "InCar_PhoneIdle_Lem", INSTANT_BLEND_IN, NORMAL_BLEND_OUT, -1, AF_LOOPING)
|
|
FORCE_PED_AI_AND_ANIMATION_UPDATE(lamarPed)
|
|
ENDIF
|
|
ENDIF
|
|
|
|
//IF IS_VEHICLE_DRIVEABLE(hoodVehicle[HV_FRANKLIN_VAN])
|
|
// SET_VEHICLE_USE_CUTSCENE_WHEEL_COMPRESSION(hoodVehicle[HV_FRANKLIN_VAN])
|
|
//ENDIF
|
|
|
|
IF CAN_SET_EXIT_STATE_FOR_REGISTERED_ENTITY("Kidnapping_Van")
|
|
IF IS_VEHICLE_DRIVEABLE(hoodVehicle[HV_FRANKLIN_VAN])
|
|
SHUT_ALL_VAN_DOORS()
|
|
//
|
|
//SET_VEHICLE_ON_GROUND_PROPERLY(hoodVehicle[HV_FRANKLIN_VAN])
|
|
|
|
SET_MISSION_CUTSCENE(FALSE, TRUE, -1, WAS_CUTSCENE_SKIPPED())
|
|
SET_MISSION_STAGE(STAGE_GET_TO_HOUSE)
|
|
ENDIF
|
|
ELSE
|
|
IF IS_VEHICLE_DRIVEABLE(hoodVehicle[HV_FRANKLIN_VAN])
|
|
SET_VEHICLE_USE_CUTSCENE_WHEEL_COMPRESSION(hoodVehicle[HV_FRANKLIN_VAN])
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF WAS_CUTSCENE_SKIPPED()
|
|
CAN_SET_EXIT_STATE_FOR_CAMERA()
|
|
ENDIF
|
|
|
|
#IF IS_DEBUG_BUILD
|
|
DEBUG_SKIP_MOCAP()
|
|
#ENDIF
|
|
BREAK
|
|
|
|
CASE H_CUT_STAGE_CLEANUP
|
|
BREAK
|
|
ENDSWITCH
|
|
|
|
HIDE_HUD_AND_RADAR_THIS_FRAME()
|
|
ENDPROC
|
|
|
|
PROC INCREMENT_CHOP_THROUGH_BOXCAR_SPEED()
|
|
IF IS_SYNCHRONIZED_SCENE_RUNNING(chopChaseProperties.iSyncScene)
|
|
fChopThroughBoxcarSpeed = fChopThroughBoxcarSpeed +@ 0.83
|
|
IF fChopThroughBoxcarSpeed >= 0.93
|
|
fChopThroughBoxcarSpeed = 0.93
|
|
ENDIF
|
|
SET_SYNCHRONIZED_SCENE_RATE(chopChaseProperties.iSyncScene, fChopThroughBoxcarSpeed)
|
|
ENDIF
|
|
ENDPROC
|
|
|
|
// find the bad guy in the trainyard
|
|
PROC DO_STAGE_FIND_BAD_GUY()
|
|
HANDLE_TRAINS()
|
|
bOpeningBoxcarInProgress = FALSE
|
|
|
|
IF chopViewCamData.state <> CHOP_VIEW_CAM_ON_CHOP
|
|
SET_SELECTOR_PED_HINT(sSelectorPeds, SELECTOR_PED_FRANKLIN, FALSE)
|
|
ENDIF
|
|
|
|
IF NOT IS_PED_INJURED(chopPed)
|
|
IF GET_GAME_TIMER() <= iStageStartTime + 3000
|
|
SET_PED_MIN_MOVE_BLEND_RATIO(chopPed, PEDMOVE_RUN)
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF NOT bRunningCutscene
|
|
IF NOT bPreparedBaddyCue
|
|
IF NOT bForcePassOnShitSkip
|
|
bPreparedBaddyCue = PREPARE_MUSIC_EVENT("FRA0_BADDY")
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF bForcePassOnShitSkip
|
|
IF NOT bWarpedToChaseEnd
|
|
//IF NOT IS_PED_INJURED(PLAYER_PED_ID())
|
|
// SET_ENTITY_COORDS(PLAYER_PED_ID(), <<517.17352, -626.64124, 23.75108>>)
|
|
//ENDIF
|
|
IF NOT IS_PED_INJURED(chopPed)
|
|
SET_ENTITY_COORDS(chopPed, <<517.26697, -648.65112, 23.75121>>)
|
|
ENDIF
|
|
IF NOT IS_PED_INJURED(runnerChaseProperties.ped)
|
|
SET_ENTITY_COORDS(runnerChaseProperties.ped, <<516.20947, -646.30573, 23.75121>>)
|
|
ENDIF
|
|
|
|
//LOAD_SCENE(<<517.17352, -626.64124, 23.75108>>)
|
|
//WAIT(0)
|
|
bFoundBadGuy = TRUE
|
|
bDoneRunnerFallOver = TRUE
|
|
bWarpedToChaseEnd = TRUE
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF NOT bForcePassOnShitSkip
|
|
// kill the dog if damaged
|
|
IF NOT IS_PED_INJURED(colliePed)
|
|
IF HAS_ENTITY_BEEN_DAMAGED_BY_ENTITY(colliePed, PLAYER_PED_ID())
|
|
APPLY_DAMAGE_TO_PED(colliePed, 1000, TRUE)
|
|
ENDIF
|
|
ENDIF
|
|
|
|
//HANDLE_CHOP_VIEW_CAM(chopViewCamData, sSelectorPeds, bGotToTrain)
|
|
IF chopViewCamData.state = CHOP_VIEW_CAM_ON_CHOP
|
|
DRAW_SCENT(NOT bFoundBadGuy)
|
|
ELSE
|
|
REMOVE_CHOP_SCENT(TRUE)
|
|
ENDIF
|
|
|
|
HANDLE_REACT_TO_RUN_STAT()
|
|
|
|
HANDLE_BOXCAR_DOORS()
|
|
|
|
DO_CHOP_CAM_HELP()
|
|
DO_NO_STAMINA_HELP_TEXT()
|
|
|
|
// music for 2nd boxcars
|
|
IF NOT bDoneBlipSecondBoxcarsCue
|
|
IF bBlippedSecondBoxcars
|
|
bDoneBlipSecondBoxcarsCue = TRIGGER_MUSIC_EVENT("FRA0_OPEN_CAR")
|
|
ENDIF
|
|
ENDIF
|
|
|
|
//IF NOT bOpeningBoxcarInProgress
|
|
HANDLE_CHOP_VIEW_CAM()
|
|
//ENDIF
|
|
|
|
IF bOpeningBoxcarInProgress
|
|
DISABLE_SELECTOR_THIS_FRAME()
|
|
ENDIF
|
|
|
|
// abandon fail chop
|
|
IF NOT bForcePassOnShitskip
|
|
IF NOT IS_PED_INJURED(chopPed)
|
|
IF GET_DISTANCE_BETWEEN_ENTITIES(PLAYER_PED_ID(), chopPed, FALSE) > ABANDON_BUDDY_FAIL_RANGE
|
|
MISSION_FAILED(FAIL_ABANDONED_CHOP)
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
|
|
// handle bad guy
|
|
SWITCH ballaDiscoveredState
|
|
CASE BALLA_DISCOVERED_STATE_NOT_STARTED
|
|
IF IS_SYNCHRONIZED_SCENE_RUNNING(iBoxcarCamSyncScene)
|
|
AND bDoneBoxcarCutsceneCam
|
|
IF openTargetContainerState >= OPEN_TARGET_CONTAINER_STATE_OPENING
|
|
IF DOES_ENTITY_EXIST(colliePed)
|
|
DELETE_PED(colliePed)
|
|
ENDIF
|
|
CLEAR_PED_TASKS_IMMEDIATELY(runnerChaseProperties.ped)
|
|
TASK_PLAY_ANIM(runnerChaseProperties.ped, GET_HOOD_ANIM_DICT_AS_STRING(H_ANIM_DICT_FIND), "open_train_car_og", INSTANT_BLEND_IN, NORMAL_BLEND_OUT, -1, AF_HOLD_LAST_FRAME, 0.2)
|
|
FORCE_PED_AI_AND_ANIMATION_UPDATE(runnerChaseProperties.ped)
|
|
ballaDiscoveredState = BALLA_DISCOVERED_STATE_DOOR_OPENING
|
|
ENDIF
|
|
ENDIF
|
|
BREAK
|
|
CASE BALLA_DISCOVERED_STATE_DOOR_OPENING
|
|
IF NOT bDoneFoundCue
|
|
bDoneFoundCue = TRIGGER_MUSIC_EVENT("FRA0_FOUND")
|
|
ENDIF
|
|
|
|
IF IS_ENTITY_PLAYING_ANIM(runnerChaseProperties.ped, GET_HOOD_ANIM_DICT_AS_STRING(H_ANIM_DICT_FIND), "open_train_car_og")
|
|
IF GET_ENTITY_ANIM_CURRENT_TIME(runnerChaseProperties.ped, GET_HOOD_ANIM_DICT_AS_STRING(H_ANIM_DICT_FIND), "open_train_car_og") >= 0.98
|
|
TASK_PLAY_ANIM(runnerChaseProperties.ped, GET_HOOD_ANIM_DICT_AS_STRING(H_ANIM_DICT_FIND), "find_ballasog_og", NORMAL_BLEND_OUT, NORMAL_BLEND_OUT, -1, AF_TAG_SYNC_OUT)
|
|
ballaDiscoveredState = BALLA_DISCOVERED_STATE_LEAVE_BOXCAR
|
|
ENDIF
|
|
ENDIF
|
|
BREAK
|
|
CASE BALLA_DISCOVERED_STATE_LEAVE_BOXCAR
|
|
SET_PED_MIN_MOVE_BLEND_RATIO(runnerChaseProperties.ped, PEDMOVE_RUN)
|
|
IF NOT IS_ENTITY_PLAYING_ANIM(runnerChaseProperties.ped, GET_HOOD_ANIM_DICT_AS_STRING(H_ANIM_DICT_FIND), "find_ballasog_og")
|
|
TASK_FOLLOW_WAYPOINT_RECORDING(runnerChaseProperties.ped, "hood5", 5, EWAYPOINT_DO_NOT_RESPOND_TO_COLLISION_EVENTS)
|
|
iRunnerStageStartTime = GET_GAME_TIMER()
|
|
ballaDiscoveredState = BALLA_DISCOVERED_STATE_ESCAPING
|
|
ENDIF
|
|
BREAK
|
|
ENDSWITCH
|
|
ENDIF
|
|
|
|
IF NOT bFoundBadGuy
|
|
HANDLE_BOXCAR_SEARCHING()
|
|
|
|
// looking for bad guy following chop
|
|
IF NOT bDoneGotoSpeech
|
|
IF DO_MISSION_SPEECH("FKN0_FIND")//2")
|
|
bDoneGotoSpeech = TRUE
|
|
iNextFindSpeechTime = GET_GAME_TIMER() + 6000
|
|
ENDIF
|
|
ELSE
|
|
IF NOT bShownGodText
|
|
IF bGotToTrain
|
|
bShownGodText = TRUE
|
|
ELSE
|
|
IF chopViewCamData.state = CHOP_VIEW_CAM_DISABLED
|
|
bShownGodText = DO_MISSION_GOD_TEXT("FC_GOCHOP")
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF NOT bDoneSecondFindSpeech
|
|
IF GET_GAME_TIMER() >= iNextFindSpeechTime
|
|
bDoneSecondFindSpeech = DO_MISSION_SPEECH("FKN0_FIND2")
|
|
ENDIF
|
|
ENDIF
|
|
|
|
HANDLE_CHOP_BEHAVIOUR_SETPIECE()
|
|
|
|
// look ats
|
|
FLOAT fLookDistance
|
|
IF chopBehaviourSetpieceStage = CBS_NOT_STARTED
|
|
OR chopBehaviourSetpieceStage = CBS_DONE
|
|
fLookDistance = 20.0
|
|
ELSE
|
|
fLookDistance = 40.0
|
|
ENDIF
|
|
|
|
IF NOT IS_PED_INJURED(chopPed)
|
|
IF IS_ENTITY_AT_ENTITY(PLAYER_PED_ID(), chopPed, <<fLookDistance, fLookDistance, 4>>)
|
|
AND NOT bOpeningBoxcarInProgress
|
|
IF NOT IS_PED_HEADTRACKING_ENTITY(PLAYER_PED_ID(), chopPed)
|
|
TASK_LOOK_AT_ENTITY(PLAYER_PED_ID(), chopPed, -1, SLF_WHILE_NOT_IN_FOV, SLF_LOOKAT_VERY_HIGH)
|
|
ENDIF
|
|
ELSE
|
|
IF IS_PED_HEADTRACKING_ENTITY(PLAYER_PED_ID(), chopPed)
|
|
TASK_CLEAR_LOOK_AT(PLAYER_PED_ID())
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF bGotToTrain
|
|
IF chopBehaviourSetpieceStage = CBS_NOT_STARTED OR chopBehaviourSetpieceStage = CBS_DONE
|
|
|
|
IF NOT IS_PED_INJURED(chopPed)
|
|
BOOL bAtChop = IS_ENTITY_AT_ENTITY(PLAYER_PED_ID(), chopPed, <<fLookDistance, fLookDistance, LOCATE_SIZE_HEIGHT>>)
|
|
BOOL bChopFinishedRoute = IS_ENTITY_AT_COORD(chopPed, <<530.02509, -678.95294, 23.70727>>, <<2.5,2.5,2.5>>) //iChopWaypointProgress >= 47 AND NOT IS_WAYPOINT_PLAYBACK_GOING_ON_FOR_PED(chopPed)
|
|
|
|
//IF bAtChop
|
|
//OR IS_ENTITY_AT_COORD(chopPed, <<543.35, -618.24, 23.75>>, <<3,3,3>>)
|
|
// random speech
|
|
IF bAtChop
|
|
AND NOT bOpeningBoxcarInProgress
|
|
IF bShownGodText
|
|
DO_RANDOM_SPEECH("FKN0_FOLLOW", -1, 6000, 9000)
|
|
ENDIF
|
|
ENDIF
|
|
|
|
SWITCH chopSniffState
|
|
CASE CHOP_SNIFF_STATE_NOT_STARTED
|
|
IF NOT bChopFinishedRoute
|
|
DO_CHOP_AUDIO(CHOP_AUDIO_STATE_SEARCHING)
|
|
IF IS_WAYPOINT_PLAYBACK_GOING_ON_FOR_PED(chopPed)
|
|
WAYPOINT_PLAYBACK_OVERRIDE_SPEED(chopPed, PEDMOVE_WALK)
|
|
ENDIF
|
|
IF NOT IS_ENTITY_AT_COORD(chopPed, <<528.33459, -679.31793, 23.79582>>, <<3,3,3>>, FALSE, FALSE)
|
|
IF GET_GAME_TIMER() >= iNextChopSniffTime
|
|
chopSniffState = CHOP_SNIFF_STATE_SLOW_DOWN
|
|
ENDIF
|
|
ENDIF
|
|
ELSE
|
|
CLEAR_SEQUENCE_TASK(sequence)
|
|
OPEN_SEQUENCE_TASK(sequence)
|
|
TASK_GO_STRAIGHT_TO_COORD(NULL, <<529.89215, -679.12616, 23.71802>>, PEDMOVE_WALK, DEFAULT_TIME_BEFORE_WARP, 83.2)
|
|
TASK_PLAY_ANIM(NULL, GET_HOOD_ANIM_DICT_AS_STRING(H_ANIM_DICT_SHARED), "CHOP_BARK_AT_CARRIAGE", NORMAL_BLEND_IN, NORMAL_BLEND_OUT, -1, AF_LOOPING)
|
|
CLOSE_SEQUENCE_TASK(sequence)
|
|
TASK_PERFORM_SEQUENCE(chopPed, sequence)
|
|
SET_PED_CAN_RAGDOLL_FROM_PLAYER_IMPACT(chopPed, FALSE)
|
|
bShownSwitchToOpenHelp = FALSE
|
|
chopSniffState = CHOP_SNIFF_STATE_WAIT_AT_BOXCAR
|
|
ENDIF
|
|
BREAK
|
|
|
|
CASE CHOP_SNIFF_STATE_SLOW_DOWN
|
|
IF IS_WAYPOINT_PLAYBACK_GOING_ON_FOR_PED(chopPed)
|
|
WAYPOINT_PLAYBACK_OVERRIDE_SPEED(chopPed, 0.0)
|
|
ENDIF
|
|
IF GET_ENTITY_SPEED(chopPed) <= 0.2
|
|
chopSniffState = CHOP_SNIFF_STATE_STOPPED
|
|
iChopSniffStateTime = GET_GAME_TIMER()
|
|
ENDIF
|
|
BREAK
|
|
|
|
CASE CHOP_SNIFF_STATE_STOPPED
|
|
IF IS_WAYPOINT_PLAYBACK_GOING_ON_FOR_PED(chopPed)
|
|
WAYPOINT_PLAYBACK_OVERRIDE_SPEED(chopPed, 0.0)
|
|
ENDIF
|
|
IF GET_GAME_TIMER() >= iChopSniffStateTime + 100
|
|
TASK_PLAY_ANIM(chopPed, GET_HOOD_ANIM_DICT_AS_STRING(H_ANIM_DICT_FIND), "FRA0_IG_14_CHOP_SNIFF_FWDS", 2, 2)
|
|
iChopSniffStateTime = GET_GAME_TIMER()
|
|
chopSniffState = CHOP_SNIFF_STATE_PLAYING_ANIM
|
|
ENDIF
|
|
BREAK
|
|
|
|
CASE CHOP_SNIFF_STATE_PLAYING_ANIM
|
|
SET_PED_MIN_MOVE_BLEND_RATIO(chopPed, PEDMOVE_WALK)
|
|
IF NOT IS_ENTITY_PLAYING_ANIM(chopPed, GET_HOOD_ANIM_DICT_AS_STRING(H_ANIM_DICT_FIND), "FRA0_IG_14_CHOP_SNIFF_FWDS")
|
|
chopSniffState = CHOP_SNIFF_STATE_NOT_STARTED
|
|
bDoneChopSniffSFX = FALSE
|
|
iChopSniffStateTime = GET_GAME_TIMER()
|
|
iNextChopSniffTime = GET_GAME_TIMER() + GET_RANDOM_INT_IN_RANGE(7000, 11000)
|
|
ELSE
|
|
IF NOT bDoneChopSniffSFX
|
|
IF GET_GAME_TIMER() >= iChopSniffStateTime + 600
|
|
PLAY_CHOP_AUDIO_CONTEXT(CHOP_AUDIO_CONTEXT_SNIFF)
|
|
bDoneChopSniffSFX = TRUE
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
BREAK
|
|
|
|
CASE CHOP_SNIFF_STATE_WAIT_AT_BOXCAR
|
|
SET_PED_RESET_FLAG(chopPed, PRF_UseKinematicPhysics, TRUE)
|
|
DO_CHOP_AUDIO(CHOP_AUDIO_STATE_FOUND_SOMETHING)
|
|
BREAK
|
|
ENDSWITCH
|
|
|
|
//PRINTINT(ENUM_TO_INT(chopSniffState)) PRINTNL()
|
|
|
|
IF chopSniffState = CHOP_SNIFF_STATE_NOT_STARTED
|
|
IF NOT IS_WAYPOINT_PLAYBACK_GOING_ON_FOR_PED(chopPed)
|
|
VECTOR vChopPos = GET_ENTITY_COORDS(chopPed)
|
|
IF vChopPos.y <-607.75
|
|
INT iClosestWaypoint
|
|
WAYPOINT_RECORDING_GET_CLOSEST_WAYPOINT("hood8", GET_OFFSET_FROM_ENTITY_IN_WORLD_COORDS(chopPed, <<0,1.5,0>>), iClosestWaypoint)
|
|
TASK_FOLLOW_WAYPOINT_RECORDING(chopPed, "hood8", iClosestWaypoint, EWAYPOINT_NAVMESH_BACK_TO_WAYPOINT_IF_LEFT_ROUTE)
|
|
iNextChopSniffTime = GET_GAME_TIMER() + GET_RANDOM_INT_IN_RANGE(4000, 7000)
|
|
ENDIF
|
|
ELSE
|
|
INT iProgress = GET_PED_WAYPOINT_PROGRESS(chopPed)
|
|
IF iProgress > iChopWaypointProgress
|
|
iChopWaypointProgress = iProgress
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
//ELSE
|
|
//IF IS_WAYPOINT_PLAYBACK_GOING_ON_FOR_PED(chopPed)
|
|
//AND chopSniffState = CHOP_SNIFF_STATE_NOT_STARTED
|
|
// CLEAR_PED_TASKS(chopPed)
|
|
//ENDIF
|
|
//ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ELSE
|
|
IF NOT IS_PED_INJURED(chopPed)
|
|
VECTOR vChopPos2 = GET_ENTITY_COORDS(chopPed)
|
|
IF vChopPos2.y <-614.75
|
|
SET_PED_MAX_MOVE_BLEND_RATIO(chopPed, PEDMOVE_WALK)
|
|
ELIF vChopPos2.y <-608.75
|
|
SET_PED_MAX_MOVE_BLEND_RATIO(chopPed, PEDMOVE_RUN)
|
|
ENDIF
|
|
IF NOT bDoneChopGoToTrain
|
|
//IF GET_SCRIPT_TASK_STATUS(chopPed, SCRIPT_TASK_PERFORM_SEQUENCE) = FINISHED_TASK
|
|
IF IS_ENTITY_AT_COORD(chopPed, <<542.47552, -618.73151, 23.74781>>, <<2,2,2>>)
|
|
IF NOT IS_ENTITY_AT_ENTITY(PLAYER_PED_ID(), chopPed, <<30,30,30>>, FALSE, FALSE)
|
|
TASK_PLAY_ANIM(chopPed, GET_HOOD_ANIM_DICT_AS_STRING(H_ANIM_DICT_SHARED), "FRA0_IG_12_CHOP_WAITING_B", NORMAL_BLEND_IN, NORMAL_BLEND_OUT, -1, AF_LOOPING)
|
|
ENDIF
|
|
iNextChopSniffTime = GET_GAME_TIMER() + 1000
|
|
bDoneChopGoToTrain = TRUE
|
|
ENDIF
|
|
ELSE
|
|
IF IS_ENTITY_AT_ENTITY(PLAYER_PED_ID(), chopPed, <<30,30,30>>, FALSE, FALSE)
|
|
IF CAN_CHOP_TRANSITION_BACK_FROM_WAIT()
|
|
bGotToTrain = TRUE
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
|
|
// handle opening target container
|
|
SWITCH openTargetContainerState
|
|
CASE OPEN_TARGET_CONTAINER_STATE_NOT_STARTED
|
|
IF boxcarCarriage[2].boxcarDoor[1].state = BOXCAR_DOOR_OPENING
|
|
AND ((IS_SYNCHRONIZED_SCENE_RUNNING(iBoxcarCamSyncScene) AND bDoneBoxcarCutsceneCam) OR GET_GAME_TIMER() >= iOpenBoxcarTime + 5000)
|
|
IF DOES_ENTITY_EXIST(colliePed)
|
|
//SET_PED_AS_NO_LONGER_NEEDED(colliePed)
|
|
DELETE_PED(colliePed)
|
|
ENDIF
|
|
|
|
IF NOT IS_PED_INJURED(chopPed)
|
|
CLEAR_PED_TASKS_IMMEDIATELY(chopPed)
|
|
//SET_ENTITY_COORDS(chopPed, <<529.917, -680.218, 23.75>>)
|
|
//SET_ENTITY_HEADING(chopPed, 107.7)
|
|
|
|
REQUEST_PED_VISIBILITY_TRACKING(chopPed)
|
|
chopChaseProperties.iSyncscene = CREATE_SYNCHRONIZED_SCENE(GET_BOXCAR_POS(2), <<0,0,83.079>>)
|
|
SET_SYNCHRONIZED_SCENE_LOOPED(chopChaseProperties.iSyncscene, FALSE)
|
|
//SET_SYNCHRONIZED_SCENE_PHASE(chopChaseProperties.iSyncscene, 0.355)
|
|
TASK_SYNCHRONIZED_SCENE(chopPed, chopChaseProperties.iSyncscene, GET_HOOD_ANIM_DICT_AS_STRING(H_ANIM_DICT_FIND), "find_ballasog_chop", INSTANT_BLEND_IN, NORMAL_BLEND_OUT, SYNCED_SCENE_TAG_SYNC_OUT | SYNCED_SCENE_DONT_INTERRUPT)
|
|
SET_SYNCHRONIZED_SCENE_RATE(chopChaseProperties.iSyncscene, fChopThroughBoxcarSpeed)
|
|
|
|
chopSniffState = CHOP_SNIFF_STATE_WAIT_AT_BOXCAR
|
|
ENDIF
|
|
|
|
TASK_CLEAR_LOOK_AT(PLAYER_PED_ID())
|
|
FREEZE_ENTITY_POSITION(runnerChaseProperties.ped, FALSE)
|
|
KILL_ANY_CONVERSATION()
|
|
REMOVE_ALL_BLIPS()
|
|
IF NOT DOES_BLIP_EXIST(chopBlip)
|
|
chopBlip = CREATE_MISSION_BLIP_FOR_PED(chopPed, FALSE, CHAR_CHOP)
|
|
ENDIF
|
|
IF NOT DOES_BLIP_EXIST(runnerBlip)
|
|
runnerBlip = CREATE_MISSION_BLIP_FOR_PED(runnerChaseProperties.ped, TRUE)
|
|
ENDIF
|
|
|
|
boxcarCarriage[2].boxcarDoor[0].fOffset = 3.0
|
|
ATTACH_DOOR_TO_BOXCAR(2,0)
|
|
iOpenTargetBoxcarTime = GET_GAME_TIMER()
|
|
|
|
SET_CHOP_VIEW_CAM_CUSTOM_ATTACH(chopViewCamData, -0.75, 0)
|
|
|
|
openTargetContainerState = OPEN_TARGET_CONTAINER_STATE_OPENING
|
|
ENDIF
|
|
BREAK
|
|
|
|
CASE OPEN_TARGET_CONTAINER_STATE_OPENING
|
|
DISABLE_CELLPHONE_THIS_FRAME_ONLY()
|
|
|
|
IF GET_GAME_TIMER() >= iOpenTargetBoxcarTime + 3400
|
|
IF NOT bDoneFoundBadGuySpeech
|
|
bDoneFoundBadGuySpeech = DO_MISSION_SPEECH("FKN0_FOUND1")
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF NOT IS_SYNCHRONIZED_SCENE_RUNNING(iSyncScene)// IS_ENTITY_PLAYING_ANIM(PLAYER_PED_ID(), GET_HOOD_ANIM_DICT_AS_STRING(H_ANIM_DICT_MISSION), "open_train_car_fra")//GET_GAME_TIMER() >= iOpenTargetBoxcarTime + 7000
|
|
IF NOT IS_PED_INJURED(PLAYER_PED_ID())
|
|
TASK_PLAY_ANIM(PLAYER_PED_ID(), GET_HOOD_ANIM_DICT_AS_STRING(H_ANIM_DICT_FIND), "find_ballasOG_Fra", NORMAL_BLEND_IN, -1.0)
|
|
ENDIF
|
|
|
|
INCREMENT_CHOP_THROUGH_BOXCAR_SPEED()
|
|
|
|
//IF NOT IS_PED_INJURED(chopPed)
|
|
//REQUEST_PED_VISIBILITY_TRACKING(chopPed)
|
|
//chopChaseProperties.iSyncscene = CREATE_SYNCHRONIZED_SCENE(GET_BOXCAR_POS(2), <<0,0,83.079>>)
|
|
//SET_SYNCHRONIZED_SCENE_LOOPED(chopChaseProperties.iSyncscene, FALSE)
|
|
//SET_SYNCHRONIZED_SCENE_PHASE(chopChaseProperties.iSyncscene, 0.355)
|
|
//TASK_SYNCHRONIZED_SCENE(chopPed, chopChaseProperties.iSyncscene, GET_HOOD_ANIM_DICT_AS_STRING(H_ANIM_DICT_FIND), "find_ballasog_chop", NORMAL_BLEND_IN, NORMAL_BLEND_OUT, SYNCED_SCENE_TAG_SYNC_OUT | SYNCED_SCENE_DONT_INTERRUPT)
|
|
//SET_SYNCHRONIZED_SCENE_RATE(chopChaseProperties.iSyncscene, 0.9)
|
|
//ENDIF
|
|
|
|
IF NOT IS_PED_INJURED(runnerChaseProperties.ped)
|
|
REQUEST_PED_VISIBILITY_TRACKING(runnerChaseProperties.ped)
|
|
ENDIF
|
|
|
|
iRunnerStageStartTime = GET_GAME_TIMER()
|
|
bShownGodText = FALSE
|
|
bDoneGotoSpeech = FALSE
|
|
bFoundBadGuy = TRUE
|
|
|
|
openTargetContainerState = OPEN_TARGET_CONTAINER_STATE_ESCAPING
|
|
ENDIF
|
|
BREAK
|
|
ENDSWITCH
|
|
ENDIF
|
|
ELSE
|
|
IF NOT bForcePassOnShitSkip
|
|
SET_PED_MOVE_RATE_OVERRIDE(PLAYER_PED_ID(), 0.97)
|
|
|
|
IF NOT bDoneChopChaseFoundBalla
|
|
INCREMENT_CHOP_THROUGH_BOXCAR_SPEED()
|
|
ENDIF
|
|
|
|
IF IS_ENTITY_PLAYING_ANIM(PLAYER_PED_ID(), GET_HOOD_ANIM_DICT_AS_STRING(H_ANIM_DICT_FIND), "find_ballasOG_Fra")
|
|
DISABLE_CELLPHONE_THIS_FRAME_ONLY()
|
|
ENDIF
|
|
|
|
BLOCK_FOOT_CHASE_RAGDOLL()
|
|
DO_CHOP_AUDIO(CHOP_AUDIO_STATE_CHASING)
|
|
ENDIF
|
|
|
|
IF NOT IS_PED_INJURED(runnerChaseProperties.ped)
|
|
IF IS_ENTITY_ON_FIRE(runnerChaseProperties.ped)
|
|
MISSION_FAILED(FAIL_KILLED_BAD_GUY)
|
|
ENDIF
|
|
ENDIF
|
|
|
|
HANDLE_STREAMING_MOCAP("FRA_0_MCS_4_P2_T3", GET_HOOD_VECTOR(HVEC_FIND_GANGSTER), DEFAULT_CUTSCENE_LOAD_DIST, DEFAULT_CUTSCENE_UNLOAD_DIST)
|
|
|
|
IF CAN_REQUEST_ASSETS_FOR_CUTSCENE_ENTITY()
|
|
IF NOT IS_PED_INJURED(lamarPed)
|
|
PRINTSTRING("setting component from lamar") printnl()
|
|
SET_CUTSCENE_PED_COMPONENT_VARIATION_FROM_PED("Lamar", lamarPed)
|
|
SET_CUTSCENE_PED_COMPONENT_VARIATION("Lamar", PED_COMP_SPECIAL, 0, 0)
|
|
ENDIF
|
|
IF NOT IS_PED_INJURED(chopPed)
|
|
SET_CUTSCENE_PED_COMPONENT_VARIATION_FROM_PED("Chop", chopPed)
|
|
ENDIF
|
|
IF NOT IS_PED_INJURED(runnerChaseProperties.ped)
|
|
SET_CUTSCENE_PED_COMPONENT_VARIATION_FROM_PED("Ballas_OG", runnerChaseProperties.ped)
|
|
SET_CUTSCENE_PED_PROP_VARIATION("Ballas_OG", ANCHOR_HEAD, 0, 0)
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF NOT IS_PED_INJURED(runnerChaseProperties.ped)
|
|
AND NOT IS_PED_INJURED(chopPed)
|
|
BOOL bBothOffScreen = FALSE
|
|
VECTOR vRunnerPos = GET_ENTITY_COORDS(runnerChaseProperties.ped)
|
|
|
|
SET_PED_RESET_FLAG(chopPed, PRF_UseKinematicPhysics, TRUE)
|
|
SET_PED_RESET_FLAG(runnerChaseProperties.ped, PRF_UseKinematicPhysics, TRUE)
|
|
|
|
IF NOT bForcePassOnShitskip
|
|
IF NOT bDoneRunnerFallOver
|
|
// calculate override speed for runner
|
|
IF IS_WAYPOINT_PLAYBACK_GOING_ON_FOR_PED(runnerChaseProperties.ped)
|
|
WAYPOINT_PLAYBACK_OVERRIDE_SPEED(runnerChaseProperties.ped, 3.0)
|
|
IF bBothOffScreen
|
|
SET_PED_MOVE_RATE_OVERRIDE(runnerChaseProperties.ped, 0.5)
|
|
ELSE
|
|
SET_PED_MOVE_RATE_OVERRIDE(runnerChaseProperties.ped, 0.99)
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF IS_WAYPOINT_PLAYBACK_GOING_ON_FOR_PED(chopPed)
|
|
FLOAT fChopTargetOverride
|
|
|
|
WAYPOINT_PLAYBACK_OVERRIDE_SPEED(chopPed, 3.0)
|
|
IF vRunnerPos.y <= -670
|
|
IF NOT IS_ENTITY_AT_ENTITY(chopPed, runnerChaseProperties.ped, <<3,3,3>>, FALSE, FALSE)
|
|
fChopTargetOverride = 1.15
|
|
ELSE
|
|
fChopTargetOverride = 1.05
|
|
ENDIF
|
|
ELSE
|
|
IF IS_ENTITY_AT_ENTITY(chopPed, runnerChaseProperties.ped, <<2,2,2>>, FALSE, FALSE)
|
|
fChopTargetOverride = 1.13
|
|
ELSE
|
|
fChopTargetOverride = 1.15
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF fChopTargetOverride > fChopOverride
|
|
fChopOverride = fChopOverride +@ 0.1
|
|
IF fChopOverride > fChopTargetOverride
|
|
fChopOverride = fChopTargetOverride
|
|
ENDIF
|
|
ELIF fChopTargetOverride < fChopOverride
|
|
fChopOverride = fChopOverride -@ 0.1
|
|
IF fChopOverride < fChopTargetOverride
|
|
fChopOverride = fChopTargetOverride
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF bBothOffScreen
|
|
SET_PED_MOVE_RATE_OVERRIDE(chopPed,fChopOverride/2)
|
|
ELSE
|
|
SET_PED_MOVE_RATE_OVERRIDE(chopPed,fChopOverride)
|
|
ENDIF
|
|
ELSE
|
|
IF NOT bDoneChopChaseFoundBalla
|
|
//SET_PED_MIN_MOVE_BLEND_RATIO(chopPed,PEDMOVE_SPRINT)
|
|
IF IS_SYNCHRONIZED_SCENE_RUNNING(chopChaseProperties.iSyncScene)
|
|
IF GET_SYNCHRONIZED_SCENE_PHASE(chopChaseProperties.iSyncScene) >= 0.98
|
|
SET_RAGDOLL_BLOCKING_FLAGS(chopPed, chaseRagdollBlockingFlags)
|
|
//SET_ENTITY_NO_COLLISION_ENTITY(chopPed, PLAYER_PED_ID(), FALSE)
|
|
TASK_FOLLOW_WAYPOINT_RECORDING(chopPed, "hood5", 5, EWAYPOINT_DO_NOT_RESPOND_TO_COLLISION_EVENTS)
|
|
bDoneChopChaseFoundBalla = TRUE
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
|
|
// speech and follow prompt
|
|
IF NOT bForcePassOnShitSkip
|
|
IF NOT bDoneDRunSpeech
|
|
bDoneDRunSpeech = DO_MISSION_SPEECH("FKN0_DFYOU")
|
|
ELSE
|
|
IF NOT bDoneGotoSpeech
|
|
IF chopHumpState < CHOP_HUMP_STATE_ENTERING
|
|
bDoneGotoSpeech = DO_MISSION_SPEECH("FKN0_DOWN")
|
|
ELSE
|
|
bDoneGotoSpeech = DO_MISSION_SPEECH("FKN0_DOWN2")
|
|
ENDIF
|
|
iGetHisAssSpeechTime = GET_GAME_TIMER() + 2800
|
|
ELSE
|
|
IF NOT bShownGodText
|
|
IF chopViewCamData.state = CHOP_VIEW_CAM_DISABLED
|
|
//bShownGodText = DO_MISSION_GOD_TEXT("FC_CHASE")
|
|
bShownGodText = TRUE
|
|
ENDIF
|
|
ELSE
|
|
//DO_RANDOM_SPEECH("FC_CGROWL", -1, 6000, 7000)
|
|
ENDIF
|
|
|
|
IF NOT bDoneGetHisAssSpeech
|
|
IF GET_GAME_TIMER() >= iGetHisAssSpeechTime
|
|
bDoneGetHisAssSpeech = DO_MISSION_SPEECH("FKN0_FOUND2")
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
|
|
//IF GET_GAME_TIMER() >= iNextMaulTime
|
|
// START_PARTICLE_FX_NON_LOOPED_ON_PED_BONE("scr_franklin0_mauling_blood", runnerChaseProperties.ped, <<0,0,0>>, <<0,0,0>>, BONETAG_R_CALF)
|
|
// iNextMaulTime = GET_GAME_TIMER() + GET_RANDOM_INT_IN_RANGE(1500, 2500)
|
|
//ENDIF
|
|
|
|
IF NOT IS_PED_INJURED(runnerChaseProperties.ped)
|
|
AND NOT IS_PED_INJURED(chopPed)
|
|
VECTOR vRunnerPos = GET_ENTITY_COORDS(runnerChaseProperties.ped)
|
|
IF NOT bDoneRunnerFallOver
|
|
IF NOT bDoneChopTakeDown
|
|
IF vRunnerPos.y >= -647.20
|
|
OR (vRunnerPos.y >= -660 AND IS_ENTITY_AT_ENTITY(chopPed, runnerChaseProperties.ped, <<1.6,1.6,3>>, FALSE, FALSE))
|
|
// TASK_PLAY_ANIM(chopPed, GET_HOOD_ANIM_DICT_AS_STRING(H_ANIM_DICT_FIND), "FRA_0_IG_CHOP_TAKE_DOWN_BALLA_CHOP", NORMAL_BLEND_IN, NORMAL_BLEND_OUT, -1, AF_NOT_INTERRUPTABLE)
|
|
chopChaseProperties.vAnimPos = GET_ENTITY_COORDS(chopPed)
|
|
chopChaseProperties.vAnimRot = GET_ENTITY_ROTATION(chopPed)
|
|
|
|
chopChaseProperties.vAnimRot.z = NORMALISE_HEADING(chopChaseProperties.vAnimRot.z)
|
|
|
|
chopChaseProperties.iSyncscene = CREATE_SYNCHRONIZED_SCENE(chopChaseProperties.vAnimPos, chopChaseProperties.vAnimRot)
|
|
TASK_SYNCHRONIZED_SCENE(chopPed, chopChaseProperties.iSyncscene, GET_HOOD_ANIM_DICT_AS_STRING(H_ANIM_DICT_FIND), "FRA_0_IG_CHOP_TAKE_DOWN_BALLA_CHOP", SLOW_BLEND_IN, NORMAL_BLEND_OUT, SYNCED_SCENE_DONT_INTERRUPT | SYNCED_SCENE_USE_PHYSICS)
|
|
SET_SYNCHRONIZED_SCENE_PHASE(chopChaseProperties.iSyncscene, 0.03)
|
|
|
|
runnerChaseProperties.vAnimPos = GET_ENTITY_COORDS(runnerChaseProperties.ped)
|
|
runnerChaseProperties.vAnimRot = GET_ENTITY_ROTATION(runnerChaseProperties.ped)
|
|
|
|
runnerChaseProperties.vAnimRot.z = NORMALISE_HEADING(runnerChaseProperties.vAnimRot.z)
|
|
|
|
vTargetTakedownPos = GET_OFFSET_FROM_COORD_AND_HEADING_IN_WORLD_COORDS(runnerChaseProperties.vAnimPos, runnerChaseProperties.vAnimRot.z, <<0, -1.5, -0.6>>)
|
|
vTargetTakedownRot = runnerChaseProperties.vAnimRot
|
|
|
|
runnerChaseProperties.iSyncscene = CREATE_SYNCHRONIZED_SCENE(runnerChaseProperties.vAnimPos, runnerChaseProperties.vAnimRot)
|
|
TASK_SYNCHRONIZED_SCENE(runnerChaseProperties.ped, runnerChaseProperties.iSyncscene, GET_HOOD_ANIM_DICT_AS_STRING(H_ANIM_DICT_FIND), "FRA_0_IG_CHOP_TAKE_DOWN_BALLA_VICTIM", SLOW_BLEND_IN, NORMAL_BLEND_OUT, SYNCED_SCENE_DONT_INTERRUPT | SYNCED_SCENE_USE_PHYSICS)
|
|
SET_SYNCHRONIZED_SCENE_PHASE(runnerChaseProperties.iSyncscene, 0.03)
|
|
|
|
REPLAY_RECORD_BACK_FOR_TIME(2.0)
|
|
|
|
SET_AUDIO_FLAG("DisableAbortConversationForRagdoll", TRUE)
|
|
bDoneChopTakeDown = TRUE
|
|
ENDIF
|
|
ELSE
|
|
SHIFT_VECTOR_TO_IDEAL_VECTOR(chopChaseProperties.vAnimPos, vTargetTakedownPos, SHIFT_POS_SPEED * 2)
|
|
SHIFT_VECTOR_TO_IDEAL_VECTOR(chopChaseProperties.vAnimRot, vTargetTakedownRot, SHIFT_ROT_SPEED * 2)
|
|
SET_SYNCHRONIZED_SCENE_ORIGIN(chopChaseProperties.iSyncScene, chopChaseProperties.vAnimPos, chopChaseProperties.vAnimRot)
|
|
|
|
IF IS_SYNCHRONIZED_SCENE_RUNNING(runnerChaseProperties.iSyncScene)
|
|
IF GET_SYNCHRONIZED_SCENE_PHASE(runnerChaseProperties.iSyncScene) >= 0.237
|
|
SET_DAMAGE_ON_BAD_GUY()
|
|
ENDIF
|
|
|
|
IF NOT bAllowKidnapCutscene
|
|
IF GET_SYNCHRONIZED_SCENE_PHASE(runnerChaseProperties.iSyncScene) >= 0.147
|
|
bAllowKidnapCutscene = TRUE
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF GET_SYNCHRONIZED_SCENE_PHASE(runnerChaseProperties.iSyncScene) >= 0.98
|
|
bDoneRunnerFallOver = TRUE
|
|
ENDIF
|
|
ELSE
|
|
SET_DAMAGE_ON_BAD_GUY()
|
|
bDoneRunnerFallOver = TRUE
|
|
ENDIF
|
|
|
|
IF NOT bDoneDFallSpeech
|
|
IF DO_MISSION_SPEECH("FKN0_DFALL")
|
|
bDoneDFallSpeech = TRUE
|
|
iNextRandomSpeechTime = GET_GAME_TIMER() + 3000
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ELSE
|
|
IF NOT bForcePassOnShitSkip
|
|
IF IS_ENTITY_AT_ENTITY(PLAYER_PED_ID(), runnerChaseProperties.ped, <<30, 30, 8>>)
|
|
DO_RANDOM_SPEECH("FKN0_DHELP", -1, 5000, 10000)
|
|
ENDIF
|
|
|
|
|
|
//IF GET_SCRIPT_TASK_STATUS(chopPed, SCRIPT_TASK_PLAY_ANIM) = FINISHED_TASK
|
|
IF NOT IS_ENTITY_AT_ENTITY(chopPed, runnerChaseProperties.ped, <<2,2,2>>)
|
|
IF GET_GAME_TIMER() >= iLastChopGotoTime + 2000//GET_SCRIPT_TASK_STATUS(chopPed, SCRIPT_TASK_PERFORM_SEQUENCE) = FINISHED_TASK
|
|
CLEAR_SEQUENCE_TASK(sequence)
|
|
OPEN_SEQUENCE_TASK(sequence)
|
|
TASK_GO_STRAIGHT_TO_COORD(NULL, GET_ENTITY_COORDS(runnerChaseProperties.ped) + <<1.5,0.0,0>>, PEDMOVE_RUN, DEFAULT_TIME_BEFORE_WARP)
|
|
// TASK_TURN_PED_TO_FACE_ENTITY(NULL, runnerChaseProperties.ped)
|
|
// TASK_PLAY_ANIM(NULL, GET_HOOD_ANIM_DICT_AS_STRING(H_ANIM_DICT_MISSION), "CHOP_BARK_AT_BALLAS", NORMAL_BLEND_IN, NORMAL_BLEND_OUT, -1, AF_LOOPING | AF_NOT_INTERRUPTABLE)
|
|
CLOSE_SEQUENCE_TASK(sequence)
|
|
TASK_PERFORM_SEQUENCE(chopPed, sequence)
|
|
iLastChopGotoTime = GET_GAME_TIMER()
|
|
ENDIF
|
|
ELSE
|
|
IF GET_SCRIPT_TASK_STATUS(chopPed, SCRIPT_TASK_PERFORM_SEQUENCE) = FINISHED_TASK
|
|
CLEAR_SEQUENCE_TASK(sequence)
|
|
OPEN_SEQUENCE_TASK(sequence)
|
|
TASK_TURN_PED_TO_FACE_ENTITY(NULL, runnerChaseProperties.ped)
|
|
TASK_PLAY_ANIM(NULL, GET_HOOD_ANIM_DICT_AS_STRING(H_ANIM_DICT_FIND), "CHOP_BARK_AT_BALLAS", NORMAL_BLEND_IN, NORMAL_BLEND_OUT, -1, AF_LOOPING)
|
|
CLOSE_SEQUENCE_TASK(sequence)
|
|
TASK_PERFORM_SEQUENCE(chopPed, sequence)
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF NOT bDoneRunnerRelax
|
|
IF GET_GAME_TIMER() >= iRunnerFallOverTime + 2500
|
|
IF IS_ENTITY_AT_ENTITY(PLAYER_PED_ID(), runnerChaseProperties.ped, <<35,35,35>>, FALSE, FALSE)
|
|
SET_PED_TO_RAGDOLL(runnerChaseProperties.ped,2000,3000,TASK_NM_SCRIPT,TRUE,TRUE,FALSE)
|
|
CREATE_NM_MESSAGE(NM_START_START, NM_RELAX_MSG)
|
|
GIVE_PED_NM_MESSAGE(runnerChaseProperties.ped)
|
|
|
|
bDoneRunnerRelax = TRUE
|
|
ENDIF
|
|
ENDIF
|
|
ELSE
|
|
IF IS_PED_RUNNING_RAGDOLL_TASK(runnerChaseProperties.ped)
|
|
RESET_PED_RAGDOLL_TIMER(runnerChaseProperties.ped)
|
|
ELSE
|
|
IF CAN_PED_RAGDOLL(runnerChaseProperties.ped)
|
|
SET_PED_TO_RAGDOLL(runnerChaseProperties.ped,2000,3000,TASK_NM_SCRIPT,TRUE,TRUE,FALSE)
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF IS_ENTITY_AT_ENTITY(PLAYER_PED_ID(), chopPed, <<7.0, 7.0, LOCATE_SIZE_HEIGHT>>)
|
|
OR bForcePassOnShitskip
|
|
IF bDoneRunnerFallOver
|
|
OR bAllowKidnapCutscene
|
|
OR bForcePassOnShitskip
|
|
IF CAN_ADVANCE_MISSION()
|
|
OR bForcePassOnShitskip
|
|
IF HAS_CUTSCENE_LOADED_WITH_FAILSAFE()
|
|
bRunningCutscene = TRUE
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ELSE
|
|
IF NOT bDoingChopPull
|
|
IF NOT bFoundBadGuy
|
|
//DO_FOUND_CUTSCENE()
|
|
ELSE
|
|
DO_KIDNAP_CUTSCENE()
|
|
ENDIF
|
|
ELSE
|
|
DO_CHOP_PULL_CUTSCENE()
|
|
ENDIF
|
|
ENDIF
|
|
ENDPROC
|
|
|
|
// let bad guy out cutscene
|
|
PROC DO_LET_OUT_CUTSCENE()
|
|
SET_ALL_RANDOM_PEDS_FLEE_THIS_FRAME(PLAYER_ID())
|
|
|
|
SWITCH cutsceneStage
|
|
CASE H_CUT_STAGE_INIT
|
|
IF NOT bStartedLetOutCutscene
|
|
REMOVE_MISSION_TEXT(FALSE, TRUE, FALSE)
|
|
SET_PLAYER_CONTROL(PLAYER_ID(), FALSE, SPC_LEAVE_CAMERA_CONTROL_ON)
|
|
iStartedLetOutCutsceneTime = GET_GAME_TIMER()
|
|
bStartedLetOutCutscene = TRUE
|
|
ELSE
|
|
IF NOT bDoneGetOutSpeech
|
|
BOOL bPlayAsPreloaded
|
|
bPlayAsPreloaded = FALSE
|
|
IF NOT bKilledPreloadSpeech
|
|
IF GET_IS_PRELOADED_CONVERSATION_READY()
|
|
bPlayAsPreloaded = TRUE
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF bPlayAsPreloaded
|
|
BEGIN_PRELOADED_CONVERSATION()
|
|
PRINTSTRING("played speech as preloaded") PRINTNL()
|
|
iStartedLetOutCutsceneTime = GET_GAME_TIMER()
|
|
bDoneGetOutSpeech = TRUE
|
|
ELSE
|
|
IF DO_MISSION_SPEECH("FKN0_OPEN")
|
|
PRINTSTRING("played speech as normal") PRINTNL()
|
|
iStartedLetOutCutsceneTime = GET_GAME_TIMER()
|
|
bDoneGetOutSpeech = TRUE
|
|
ENDIF
|
|
ENDIF
|
|
ELSE
|
|
IF IS_SCRIPTED_CONVERSATION_LOADED()
|
|
PRINTSTRING("loaded convo") PRINTNL()
|
|
ELSE
|
|
PRINTSTRING("not yet loaded convo") PRINTNL()
|
|
ENDIF
|
|
|
|
IF (GET_GAME_TIMER() >= iStartedLetOutCutsceneTime + 1800
|
|
AND IS_SCRIPTED_CONVERSATION_LOADED())
|
|
OR GET_GAME_TIMER() >= iStartedLetOutCutsceneTime + 5000 // early-out
|
|
SET_MISSION_CUTSCENE(TRUE, TRUE, -1, TRUE, FALSE)
|
|
//CREATE_CAM_ATTACHED_TO_VAN(VAN_CAMERA_FRONT)
|
|
|
|
CREATE_MISSION_ANIM_CAM()
|
|
iSyncScene = CREATE_SYNCHRONIZED_SCENE(<<0,0,0>>, <<0,0,0>>)
|
|
IF IS_VEHICLE_DRIVEABLE(hoodVehicle[HV_FRANKLIN_VAN])
|
|
ATTACH_SYNCHRONIZED_SCENE_TO_ENTITY(iSyncScene, hoodVehicle[HV_FRANKLIN_VAN], GET_ENTITY_BONE_INDEX_BY_NAME(hoodVehicle[HV_FRANKLIN_VAN], "seat_dside_f"))
|
|
PLAY_SYNCHRONIZED_CAM_ANIM(animCam, iSyncScene, "incar_phonesnatch_cam", GET_HOOD_ANIM_DICT_AS_STRING(H_ANIM_DICT_DRIVE_HOME))
|
|
ENDIF
|
|
SET_SYNCHRONIZED_SCENE_HOLD_LAST_FRAME(iSyncScene, FALSE)
|
|
SET_PED_CAN_PLAY_GESTURE_ANIMS(PLAYER_PED_ID(), FALSE)
|
|
|
|
VECTOR vVanRear
|
|
vVanRear = GET_OFFSET_FROM_ENTITY_IN_WORLD_COORDS(hoodVehicle[HV_FRANKLIN_VAN], <<0,-3.1,-0.75>>)
|
|
CLEAR_AREA(vVanRear, 2.5, TRUE)
|
|
CLEAR_AREA_OF_PROJECTILES(vVanRear, 20)
|
|
STOP_FIRE_IN_RANGE(vVanRear, 8)
|
|
REMOVE_PARTICLE_FX_IN_RANGE(vVanRear, 8)
|
|
|
|
IF NOT IS_PED_INJURED(lamarPed)
|
|
TASK_LOOK_AT_ENTITY(PLAYER_PED_ID(), lamarPed, -1, SLF_WHILE_NOT_IN_FOV | SLF_SLOW_TURN_RATE)
|
|
ENDIF
|
|
|
|
IF IS_VEHICLE_DRIVEABLE(hoodVehicle[HV_FRANKLIN_VAN])
|
|
AND NOT IS_PED_INJURED(runnerChaseProperties.ped)
|
|
SET_VEHICLE_INTERIORLIGHT(hoodVehicle[HV_FRANKLIN_VAN],TRUE)
|
|
SET_VEHICLE_ON_GROUND_PROPERLY(hoodVehicle[HV_FRANKLIN_VAN])
|
|
// clear position behind van
|
|
CLEAR_AREA(GET_OFFSET_FROM_ENTITY_IN_WORLD_COORDS(hoodVehicle[HV_FRANKLIN_VAN], <<0,0,-8>>), 7.0, TRUE)
|
|
iSpeedZone = ADD_ROAD_NODE_SPEED_ZONE(GET_OFFSET_FROM_ENTITY_IN_WORLD_COORDS(hoodVehicle[HV_FRANKLIN_VAN], <<0,0,-10>>), 10.0, 0.0)
|
|
STOP_VEHICLE_FIRE(hoodVehicle[HV_FRANKLIN_VAN])
|
|
ENDIF
|
|
|
|
bDoneFlash = FALSE
|
|
|
|
iHoodCutsceneTime = GET_GAME_TIMER()
|
|
cutsceneStage = H_CUT_STAGE_RUNNING
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
BREAK
|
|
|
|
CASE H_CUT_STAGE_RUNNING
|
|
|
|
|
|
#IF IS_DEBUG_BUILD
|
|
//DO_DEBUG_VAN_CAM_POSITION()
|
|
#ENDIF
|
|
|
|
DO_CHOP_AUDIO(CHOP_AUDIO_STATE_IN_VAN_GUARDING)
|
|
|
|
IF NOT IS_PED_INJURED(runnerChaseProperties.ped)
|
|
AND IS_VEHICLE_DRIVEABLE(hoodVehicle[HV_FRANKLIN_VAN])
|
|
SWITCH letOutShot
|
|
CASE LET_OUT_PHONE
|
|
BOOL bNextShot
|
|
bNextShot = FALSE
|
|
IF NOT IS_SYNCHRONIZED_SCENE_RUNNING(iSyncScene)
|
|
bNextShot = TRUE
|
|
ELSE
|
|
IF GET_SYNCHRONIZED_SCENE_PHASE(iSyncScene) >= 0.98
|
|
bNextShot = TRUE
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF bNextShot
|
|
//bloodPTFX = START_PARTICLE_FX_LOOPED_ON_PED_BONE("scr_franklin0_leg_blood", runnerChaseProperties.ped, <<0,0,0>>, <<0,0,0>>, BONETAG_L_FOREARM)
|
|
TASK_CLEAR_LOOK_AT(runnerChaseProperties.ped)
|
|
|
|
//vRunnerAttachToVanPos = GET_ANIM_INITIAL_OFFSET_POSITION(GET_HOOD_ANIM_DICT_AS_STRING(H_ANIM_DICT_DRIVE_HOME), "Incar_GetOutofBack_Ballas", <<0,0,0>>, <<0,0,0>>, 0)
|
|
//vRunnerAttachToVanRot = GET_ANIM_INITIAL_OFFSET_ROTATION(GET_HOOD_ANIM_DICT_AS_STRING(H_ANIM_DICT_DRIVE_HOME), "Incar_GetOutofBack_Ballas", <<0,0,0>>, <<0,0,0>>, 0)
|
|
//ATTACH_BALLA_TO_VAN(TRUE)
|
|
SET_ENTITY_COORDS(runnerChaseProperties.ped, GET_ENTITY_COORDS(runnerChaseProperties.ped))
|
|
//TASK_PLAY_ANIM(runnerChaseProperties.ped, GET_HOOD_ANIM_DICT_AS_STRING(H_ANIM_DICT_DRIVE_HOME), "InCar_GetOutofBack_Ballas", INSTANT_BLEND_IN, NORMAL_BLEND_OUT, -1, AF_EXTRACT_INITIAL_OFFSET | AF_FORCE_START)
|
|
runnerChaseProperties.iSyncScene = CREATE_SYNCHRONIZED_SCENE(<<0,0,0>>,<<0,0,0>>)
|
|
ATTACH_SYNCHRONIZED_SCENE_TO_ENTITY(runnerChaseProperties.iSyncScene, hoodVehicle[HV_FRANKLIN_VAN], 0)
|
|
TASK_SYNCHRONIZED_SCENE(runnerChaseProperties.ped, runnerChaseProperties.iSyncScene, GET_HOOD_ANIM_DICT_AS_STRING(H_ANIM_DICT_DRIVE_HOME), "InCar_GetOutofBack_Ballas", INSTANT_BLEND_IN, NORMAL_BLEND_OUT)
|
|
SET_SYNCHRONIZED_SCENE_HOLD_LAST_FRAME(runnerChaseProperties.iSyncScene, FALSE)
|
|
FORCE_PED_AI_AND_ANIMATION_UPDATE(runnerChaseProperties.ped)
|
|
|
|
TASK_VEHICLE_PLAY_ANIM(hoodVehicle[HV_FRANKLIN_VAN], GET_HOOD_ANIM_DICT_AS_STRING(H_ANIM_DICT_DRIVE_HOME), "InCar_GetOutofBack_Speedo")
|
|
//PLAY_ENTITY_ANIM(hoodVehicle[HV_FRANKLIN_VAN], "InCar_GetOutofBack_Speedo", GET_HOOD_ANIM_DICT_AS_STRING(H_ANIM_DICT_DRIVE_HOME), INSTANT_BLEND_IN, FALSE, FALSE)
|
|
FORCE_ENTITY_AI_AND_ANIMATION_UPDATE(hoodVehicle[HV_FRANKLIN_VAN])
|
|
|
|
iSyncScene = CREATE_SYNCHRONIZED_SCENE(<<0,0,0>>, <<0,0,0>>)
|
|
ATTACH_SYNCHRONIZED_SCENE_TO_ENTITY(iSyncScene, hoodVehicle[HV_FRANKLIN_VAN], 0)
|
|
PLAY_SYNCHRONIZED_CAM_ANIM(animCam, iSyncScene, "Incar_GetOutofBack_CAM", GET_HOOD_ANIM_DICT_AS_STRING(H_ANIM_DICT_DRIVE_HOME))
|
|
SET_SYNCHRONIZED_SCENE_HOLD_LAST_FRAME(iSyncScene, FALSE)
|
|
//CREATE_CAM_ATTACHED_TO_VAN(VAN_CAMERA_REAR)
|
|
|
|
iLetOutShotTime = GET_GAME_TIMER()
|
|
letOutShot = LET_OUT_DOOR
|
|
ENDIF
|
|
BREAK
|
|
CASE LET_OUT_DOOR
|
|
MAINTAIN_BAD_GUY_FLEE()
|
|
BREAK
|
|
ENDSWITCH
|
|
ENDIF
|
|
|
|
// IF NOT bKilledConversationOnLetOut
|
|
// IF GET_GAME_TIMER() >= iHoodCutsceneTime + 5000
|
|
// KILL_ANY_CONVERSATION()
|
|
// bKilledConversationOnLetOut = TRUE
|
|
// ENDIF
|
|
//ENDIF
|
|
|
|
//IF GET_GAME_TIMER() >= iHoodCutsceneTime + 6500
|
|
//AND NOT IS_ANY_CONVERSATION_ONGOING_OR_QUEUED()
|
|
|
|
IF letOutShot = LET_OUT_DOOR
|
|
|
|
|
|
|
|
|
|
BOOL bNextShot
|
|
bNextShot = FALSE
|
|
IF NOT IS_SYNCHRONIZED_SCENE_RUNNING(iSyncScene)
|
|
IF GET_GAME_TIMER() >= iLetOutShotTime + 100
|
|
bNextShot = TRUE
|
|
ENDIF
|
|
ELSE
|
|
printstring("here1") printnl()
|
|
FLOAT fPhase
|
|
fPhase = GET_SYNCHRONIZED_SCENE_PHASE(iSyncScene)
|
|
|
|
IF NOT bDoneFlash
|
|
IF GET_FOLLOW_VEHICLE_CAM_VIEW_MODE() = CAM_VIEW_MODE_FIRST_PERSON
|
|
IF fPhase >= 0.276
|
|
PRINTSTRING("start time = ") PRINTINT(GET_GAME_TIMER() - iLetOutShotTime) PRINTNL()
|
|
ANIMPOSTFX_PLAY("CamPushInNeutral", 0, FALSE)
|
|
PLAY_SOUND_FRONTEND(-1, "1st_Person_Transition", "PLAYER_SWITCH_CUSTOM_SOUNDSET")
|
|
bDoneFlash = TRUE
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF IS_VEHICLE_DRIVEABLE(hoodVehicle[HV_FRANKLIN_VAN])
|
|
printstring("here2") printnl()
|
|
IF NOT bShutLDoor
|
|
IF fPhase >= 0.25
|
|
//SET_VEHICLE_DOOR_SHUT(hoodVehicle[HV_FRANKLIN_VAN], SC_DOOR_REAR_LEFT, FALSE)
|
|
bShutLDoor = TRUE
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF NOT bShutRDoor
|
|
printstring("here3") printnl()
|
|
IF fPhase >= 0.21
|
|
//IF IS_ENTITY_PLAYING_ANIM(hoodVehicle[HV_FRANKLIN_VAN], GET_HOOD_ANIM_DICT_AS_STRING(H_ANIM_DICT_DRIVE_HOME), "Incar_GetOutofBack_Speedo")
|
|
printstring("here4") printnl()
|
|
//STOP_ENTITY_ANIM(hoodVehicle[HV_FRANKLIN_VAN], "Incar_GetOutofBack_Speedo", GET_HOOD_ANIM_DICT_AS_STRING(H_ANIM_DICT_DRIVE_HOME), INSTANT_BLEND_OUT)
|
|
//ENDIF
|
|
//SET_VEHICLE_DOOR_SHUT(hoodVehicle[HV_FRANKLIN_VAN], SC_DOOR_REAR_RIGHT, FALSE)
|
|
bShutRDoor = TRUE
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF fPhase >= 0.30
|
|
bNextShot = TRUE
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF bNextShot
|
|
cutsceneStage = H_CUT_STAGE_CLEANUP
|
|
ENDIF
|
|
ENDIF
|
|
|
|
HANDLE_SKIP_CUTSCENE()
|
|
BREAK
|
|
|
|
CASE H_CUT_STAGE_CLEANUP
|
|
PRINTSTRING("end time = ") PRINTINT(GET_GAME_TIMER() - iLetOutShotTime) PRINTNL()
|
|
STOP_HOOD_AUDIO_SCENE(HOOD_AUDIO_SCENE_DRIVE_TO_LAMARS)
|
|
START_HOOD_AUDIO_SCENE(HOOD_AUDIO_SCENE_TAKE_LAMAR_BACK)
|
|
|
|
TOGGLE_CAR_MOD_SHOPS_UNAVAILABLE(FALSE)
|
|
|
|
REMOVE_ROAD_NODE_SPEED_ZONE(iSpeedZone)
|
|
|
|
SET_PED_CAN_PLAY_GESTURE_ANIMS(PLAYER_PED_ID(), TRUE)
|
|
|
|
IF NOT IS_PED_INJURED(lamarPed)
|
|
CLEAR_PED_TASKS(lamarPed)
|
|
SET_BLOCKING_OF_NON_TEMPORARY_EVENTS(lamarPed, FALSE)
|
|
SET_PED_COMBAT_ATTRIBUTES(lamarPed, CA_LEAVE_VEHICLES, FALSE)
|
|
ENDIF
|
|
IF NOT IS_PED_INJURED(PLAYER_PED_ID())
|
|
CLEAR_PED_TASKS(PLAYER_PED_ID())
|
|
ENDIF
|
|
IF IS_VEHICLE_DRIVEABLE(hoodVehicle[HV_FRANKLIN_VAN])
|
|
SET_VEHICLE_INTERIORLIGHT(hoodVehicle[HV_FRANKLIN_VAN],FALSE)
|
|
|
|
IF NOT IS_PED_INJURED(runnerChaseProperties.ped)
|
|
IF IS_ENTITY_ATTACHED(runnerChaseProperties.ped)
|
|
AND NOT IS_PED_IN_ANY_VEHICLE(runnerChaseProperties.ped)
|
|
DETACH_ENTITY(runnerChaseProperties.ped)
|
|
ENDIF
|
|
|
|
IF bSkippedCutscene
|
|
CLEAR_PED_TASKS_IMMEDIATELY(runnerChaseProperties.ped)
|
|
SET_ENTITY_COORDS(runnerChaseProperties.ped, GET_OFFSET_FROM_ENTITY_IN_WORLD_COORDS(hoodVehicle[HV_FRANKLIN_VAN], <<0,-3.1,-0.75>>))
|
|
SET_ENTITY_HEADING(runnerChaseProperties.ped, GET_ENTITY_HEADING(hoodVehicle[HV_FRANKLIN_VAN]) - 180)
|
|
IF IS_ENTITY_PLAYING_ANIM(hoodVehicle[HV_FRANKLIN_VAN], GET_HOOD_ANIM_DICT_AS_STRING(H_ANIM_DICT_DRIVE_HOME), "InCar_GetOutofBack_Speedo")
|
|
STOP_ENTITY_ANIM(hoodVehicle[HV_FRANKLIN_VAN], "InCar_GetOutofBack_Speedo", GET_HOOD_ANIM_DICT_AS_STRING(H_ANIM_DICT_DRIVE_HOME), INSTANT_BLEND_OUT)
|
|
SET_VEHICLE_DOOR_SHUT(hoodVehicle[HV_FRANKLIN_VAN], SC_DOOR_REAR_LEFT)
|
|
SET_VEHICLE_DOOR_SHUT(hoodVehicle[HV_FRANKLIN_VAN], SC_DOOR_REAR_RIGHT)
|
|
ENDIF
|
|
ENDIF
|
|
FORCE_PED_MOTION_STATE(runnerChaseProperties.ped, MS_ON_FOOT_RUN, TRUE, FAUS_CUTSCENE_EXIT)
|
|
SET_PED_MIN_MOVE_BLEND_RATIO(runnerChaseProperties.ped, PEDMOVE_RUN)
|
|
TASK_FOLLOW_NAV_MESH_TO_COORD(runnerChaseProperties.ped, GET_OFFSET_FROM_ENTITY_IN_WORLD_COORDS(hoodVehicle[HV_FRANKLIN_VAN], <<0,-12.0,0.4>>), PEDMOVE_RUN)
|
|
//SET_ENTITY_ONLY_DAMAGED_BY_PLAYER(runnerChaseProperties.ped, FALSE)
|
|
SET_PED_RELATIONSHIP_GROUP_HASH(runnerChaseProperties.ped, RELGROUPHASH_AMBIENT_GANG_BALLAS)
|
|
iRestoreBadGuyDamageTime = GET_GAME_TIMER() + 6000
|
|
//FORCE_PED_AI_AND_ANIMATION_UPDATE(runnerChaseProperties.ped)
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF DOES_ENTITY_EXIST(lamarPhoneObject)
|
|
|
|
//DELETE_OBJECT(lamarPhoneObject)
|
|
ENDIF
|
|
|
|
lamarPhoneState = LAMAR_PHONE_STATE_DONE
|
|
|
|
REMOVE_ALL_BLIPS()
|
|
|
|
IF NOT IS_PED_INJURED(runnerChaseProperties.ped)
|
|
|
|
ENDIF
|
|
|
|
bShownGodText = FALSE
|
|
bDoneGotoSpeech = FALSE
|
|
iGetInTextStage = 2
|
|
bShouldDoGetInText = TRUE
|
|
SET_PLAYER_WANTED_LEVEL(PLAYER_ID(), 0)
|
|
SET_PLAYER_WANTED_LEVEL_NOW(PLAYER_ID())
|
|
|
|
// back to gameplay
|
|
//SET_MISSION_CUTSCENE(FALSE)
|
|
|
|
IF bSkippedCutscene
|
|
SET_MISSION_CUTSCENE(FALSE)
|
|
ELSE
|
|
COMMON_MISSION_CUTSCENE_BLENDOUT(0, CAM_SPLINE_SLOW_IN_OUT_SMOOTH, TRUE)
|
|
ENDIF
|
|
|
|
|
|
bDoneLetOut = TRUE
|
|
bRunningCutscene = FALSE
|
|
BREAK
|
|
ENDSWITCH
|
|
ENDPROC
|
|
// dropoff cutscene
|
|
PROC DO_DROPOFF_CUTSCENE()
|
|
SET_ALL_RANDOM_PEDS_FLEE_THIS_FRAME(PLAYER_ID())
|
|
|
|
SWITCH cutsceneStage
|
|
CASE H_CUT_STAGE_INIT
|
|
//SET_MISSION_CUTSCENE(TRUE)
|
|
iHoodCutsceneTime = GET_GAME_TIMER()
|
|
|
|
// clear the area
|
|
IF NOT IS_PED_INJURED(PLAYER_PED_ID())
|
|
REGISTER_ENTITY_FOR_CUTSCENE(PLAYER_PED_ID(), "Franklin", CU_ANIMATE_EXISTING_SCRIPT_ENTITY)
|
|
ENDIF
|
|
|
|
IF NOT IS_PED_INJURED(lamarPed)
|
|
TASK_CLEAR_LOOK_AT(lamarPed)
|
|
REGISTER_ENTITY_FOR_CUTSCENE(lamarPed, "Lamar", CU_ANIMATE_EXISTING_SCRIPT_ENTITY)
|
|
ENDIF
|
|
|
|
IF NOT IS_PED_INJURED(chopPed)
|
|
DETACH_ENTITY(chopPed)
|
|
REGISTER_ENTITY_FOR_CUTSCENE(chopPed, "Chop", CU_ANIMATE_EXISTING_SCRIPT_ENTITY)
|
|
ENDIF
|
|
|
|
IF IS_VEHICLE_DRIVEABLE(hoodVehicle[HV_FRANKLIN_VAN])
|
|
REGISTER_ENTITY_FOR_CUTSCENE(hoodVehicle[HV_FRANKLIN_VAN], "Kidnapping_van", CU_ANIMATE_EXISTING_SCRIPT_ENTITY)
|
|
ENDIF
|
|
|
|
START_CUTSCENE()
|
|
|
|
REPLAY_START_EVENT(REPLAY_IMPORTANCE_HIGHEST)
|
|
|
|
SET_CUTSCENE_FADE_VALUES(FALSE, FALSE, FALSE, FALSE)
|
|
cutsceneStage = H_CUT_STAGE_RUNNING
|
|
BREAK
|
|
|
|
CASE H_CUT_STAGE_RUNNING
|
|
IF NOT bClearedForCutscene
|
|
IF IS_CUTSCENE_PLAYING()
|
|
SET_MISSION_MOCAP_CUTSCENE()
|
|
|
|
// clear the area
|
|
CLEAR_AREA(<<-214.27998, -1488.48682, 30.23007>>, 8.7, TRUE)
|
|
CLEAR_AREA_OF_PROJECTILES(<<-217.50893, -1498.44348, 30.23968>>, 15)
|
|
STOP_FIRE_IN_RANGE(<<-217.50893, -1498.44348, 30.23968>>, 15)
|
|
REMOVE_PARTICLE_FX_IN_RANGE(<<-217.50893, -1498.44348, 30.23968>>, 15)
|
|
|
|
IF DOES_ENTITY_EXIST(runnerChaseProperties.ped)
|
|
DELETE_PED(runnerChaseProperties.ped)
|
|
ENDIF
|
|
|
|
IF IS_VEHICLE_DRIVEABLE(hoodVehicle[HV_FRANKLIN_VAN])
|
|
SET_VEHICLE_DOOR_CONTROL(hoodVehicle[HV_FRANKLIN_VAN], SC_DOOR_FRONT_RIGHT, DT_DOOR_INTACT, 0.0)
|
|
SET_VEHICLE_DOOR_CONTROL(hoodVehicle[HV_FRANKLIN_VAN], SC_DOOR_REAR_RIGHT, DT_DOOR_INTACT, 0.0)
|
|
SET_VEHICLE_DOOR_CONTROL(hoodVehicle[HV_FRANKLIN_VAN], SC_DOOR_REAR_LEFT, DT_DOOR_INTACT, 0.0)
|
|
ENDIF
|
|
STOP_VEHICLE_FIRE(hoodVehicle[HV_FRANKLIN_VAN])
|
|
|
|
SET_FRANKLIN_MASK(FALSE)
|
|
SET_LAMAR_MASK(FALSE)
|
|
|
|
STOP_HOOD_AUDIO_SCENE(HOOD_AUDIO_SCENE_TAKE_LAMAR_BACK)
|
|
|
|
IF DOES_ENTITY_EXIST(runnerChaseProperties.ped)
|
|
DELETE_PED(runnerChaseProperties.ped)
|
|
ENDIF
|
|
|
|
IF IS_SCREEN_FADED_OUT()
|
|
DO_SCREEN_FADE_IN(DEFAULT_FADE_TIME)
|
|
ENDIF
|
|
|
|
bClearedForCutscene = TRUE
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF CAN_SET_EXIT_STATE_FOR_REGISTERED_ENTITY("Lamar")
|
|
//IF DOES_ENTITY_EXIST(lamarPed)
|
|
// DELETE_PED(lamarPed)
|
|
//ENDIF
|
|
IF NOT IS_PED_INJURED(lamarPed)
|
|
//IF NOT WAS_CUTSCENE_SKIPPED()
|
|
SET_ENTITY_COORDS(lamarPed, <<-220.96648, -1506.37732, 30.44023>>)
|
|
SET_ENTITY_HEADING(lamarPed, 152.7)
|
|
TASK_FOLLOW_WAYPOINT_RECORDING(lamarPed, "hood9", 5)
|
|
//ELSE
|
|
// SET_ENTITY_COORDS(lamarPed, <<-220.49052, -1505.15405, 30.63244>>)
|
|
// SET_ENTITY_HEADING(lamarPed, 159.8)
|
|
// TASK_FOLLOW_WAYPOINT_RECORDING(lamarPed, "hood9", 5)
|
|
//ENDIF
|
|
FORCE_PED_MOTION_STATE(lamarPed, MS_ON_FOOT_WALK, TRUE, FAUS_CUTSCENE_EXIT)
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF CAN_SET_EXIT_STATE_FOR_REGISTERED_ENTITY("Chop")
|
|
//IF DOES_ENTITY_EXIST(chopPed)
|
|
// DELETE_PED(chopPed)
|
|
//ENDIF
|
|
|
|
IF NOT IS_PED_INJURED(chopPed)
|
|
SET_ENTITY_PROOFS(chopPed, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, TRUE)
|
|
//IF NOT WAS_CUTSCENE_SKIPPED()
|
|
SET_ENTITY_COORDS(chopPed, <<-219.74655, -1505.89856, 30.45473>>)
|
|
SET_ENTITY_HEADING(chopPed, 144.0)
|
|
TASK_FOLLOW_WAYPOINT_RECORDING(chopPed, "hood10", 5)
|
|
//ELSE
|
|
// SET_ENTITY_COORDS(chopPed, <<-219.74655, -1505.89856, 30.45473>>)
|
|
// SET_ENTITY_HEADING(chopPed, 160.4)
|
|
// TASK_FOLLOW_WAYPOINT_RECORDING(chopPed, "hood10", 5)
|
|
//ENDIF
|
|
FORCE_PED_MOTION_STATE(chopPed, MS_ON_FOOT_RUN, TRUE, FAUS_CUTSCENE_EXIT)
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF CAN_SET_EXIT_STATE_FOR_REGISTERED_ENTITY("Franklin")
|
|
IF IS_VEHICLE_DRIVEABLE(hoodVehicle[HV_FRANKLIN_VAN])
|
|
AND NOT IS_PED_INJURED(PLAYER_PED_ID())
|
|
SET_PED_INTO_VEHICLE(PLAYER_PED_ID(), hoodVehicle[HV_FRANKLIN_VAN])
|
|
FORCE_PED_AI_AND_ANIMATION_UPDATE(PLAYER_PED_ID())
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF CAN_SET_EXIT_STATE_FOR_REGISTERED_ENTITY("Kidnapping_van")
|
|
IF IS_VEHICLE_DRIVEABLE(hoodVehicle[HV_FRANKLIN_VAN])
|
|
SET_VEHICLE_ON_GROUND_PROPERLY(hoodVehicle[HV_FRANKLIN_VAN])
|
|
SHUT_ALL_VAN_DOORS()
|
|
//SET_VEHICLE_ON_GROUND_PROPERLY(hoodVehicle[HV_FRANKLIN_VAN])
|
|
ENDIF
|
|
|
|
iLamarOutOfVanTime = GET_GAME_TIMER()
|
|
bLamarOutOfVan = TRUE
|
|
ELSE
|
|
IF NOT bLamarOutOfVan
|
|
IF IS_VEHICLE_DRIVEABLE(hoodVehicle[HV_FRANKLIN_VAN])
|
|
// SET_VEHICLE_USE_CUTSCENE_WHEEL_COMPRESSION(hoodVehicle[HV_FRANKLIN_VAN])
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF CAN_SET_EXIT_STATE_FOR_CAMERA()
|
|
|
|
REPLAY_STOP_EVENT()
|
|
|
|
SET_MISSION_CUTSCENE(FALSE)
|
|
SET_PLAYER_CONTROL(PLAYER_ID(), FALSE, SPC_LEAVE_CAMERA_CONTROL_ON)
|
|
ENDIF
|
|
|
|
//IF WAS_CUTSCENE_SKIPPED()
|
|
// IF CAN_SET_EXIT_STATE_FOR_CAMERA()
|
|
// ENDIF
|
|
//ENDIF
|
|
|
|
//IF CAN_SET_EXIT_STATE_FOR_CAMERA()
|
|
//STOP_RENDERING_SCRIPT_CAMS_USING_CATCH_UP(FALSE)
|
|
//MISSION_PASSED()
|
|
//ENDIF
|
|
|
|
#IF IS_DEBUG_BUILD
|
|
DEBUG_SKIP_MOCAP()
|
|
#ENDIF
|
|
BREAK
|
|
|
|
CASE H_CUT_STAGE_CLEANUP
|
|
BREAK
|
|
ENDSWITCH
|
|
ENDPROC
|
|
|
|
// get bad guy back to the house
|
|
PROC DO_STAGE_GET_TO_HOUSE()
|
|
// prevent bad guy from playing ambient anims
|
|
IF NOT IS_PED_INJURED(runnerChaseProperties.ped)
|
|
SET_PED_CAN_PLAY_AMBIENT_BASE_ANIMS(runnerChaseProperties.ped, FALSE)
|
|
SET_PED_CAN_PLAY_AMBIENT_ANIMS(runnerChaseProperties.ped, FALSE)
|
|
ENDIF
|
|
|
|
IF NOT bBlockedCustoms
|
|
IF GET_GAME_TIMER() >= iStageStartTime + 5000
|
|
TOGGLE_CAR_MOD_SHOPS_UNAVAILABLE(TRUE)
|
|
bBlockedCustoms = TRUE
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF NOT bRunningCutscene
|
|
IF NOT bLamarOutOfVan
|
|
IF IS_VEHICLE_DRIVEABLE(hoodVehicle[HV_FRANKLIN_VAN])
|
|
// handle chop audio
|
|
IF bInLoseWantedState
|
|
DO_CHOP_AUDIO(CHOP_AUDIO_STATE_IN_VAN_AGITATED)
|
|
ELIF dropoffStage = DROPOFF_STAGE_END
|
|
IF NOT IS_PED_INJURED(runnerChaseProperties.ped)
|
|
AND IS_ENTITY_ATTACHED_TO_ANY_VEHICLE(runnerChaseProperties.ped)
|
|
DO_CHOP_AUDIO(CHOP_AUDIO_STATE_IN_VAN_GUARDING)
|
|
ELSE
|
|
DO_CHOP_AUDIO(CHOP_AUDIO_STATE_IN_VAN_PLACID)
|
|
ENDIF
|
|
ELSE
|
|
DO_CHOP_AUDIO(CHOP_AUDIO_STATE_IN_VAN_GUARDING)
|
|
ENDIF
|
|
|
|
// restore bad guy damage after letting him out
|
|
IF NOT bRestoredBadGuyDamage
|
|
IF bDoneLetOut
|
|
IF GET_GAME_TIMER() >= iRestoreBadGuyDamageTime
|
|
IF NOT IS_PED_INJURED(runnerChaseProperties.ped)
|
|
SET_ENTITY_ONLY_DAMAGED_BY_PLAYER(runnerChaseProperties.ped, TRUE)
|
|
bRestoredBadGuyDamage = TRUE
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
|
|
// wanted reactions
|
|
INT iWantedLevel = GET_PLAYER_WANTED_LEVEL(PLAYER_ID())
|
|
IF iWantedLevel > 0
|
|
IF NOT bCutsceneWaitStarted
|
|
IF bDoneLoseWantedSpeech
|
|
IF dropoffStage <= DROPOFF_STAGE_STOP_VAN
|
|
DO_RANDOM_SPEECH("FC_LOSECOP", -1, 16000, 28000)
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
|
|
SWITCH dropoffStage
|
|
CASE DROPOFF_STAGE_NOT_STARTED
|
|
IF iWantedLevel = 0
|
|
IF IS_PED_SITTING_IN_VEHICLE(PLAYER_PED_ID(), hoodVehicle[HV_FRANKLIN_VAN])
|
|
IF NOT bDoneTrainingSpeech
|
|
STRING sSpeech
|
|
SWITCH chopBehaviour
|
|
CASE CHOP_BEHAVIOUR_BAD
|
|
sSpeech = "FKN0_VAN3"
|
|
BREAK
|
|
CASE CHOP_BEHAVIOUR_MEDIUM
|
|
sSpeech = "FKN0_VAN2"
|
|
BREAK
|
|
CASE CHOP_BEHAVIOUR_GOOD
|
|
sSpeech = "FKN0_VAN1"
|
|
BREAK
|
|
ENDSWITCH
|
|
IF DO_MISSION_SPEECH(sSpeech)
|
|
bDoneTrainingSpeech = TRUE
|
|
ENDIF
|
|
ELSE
|
|
IF DO_MISSION_SPEECH("FKN0_GOLAM")
|
|
bDoneGotoSpeech = TRUE
|
|
dropoffStage = DROPOFF_STAGE_BRIEF
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
HANDLE_IN_CAR_PROMPTS(TRUE, FALSE, TRUE)
|
|
BREAK
|
|
CASE DROPOFF_STAGE_BRIEF
|
|
IF iWantedLevel = 0
|
|
IF bShownGodText
|
|
IF IS_PED_SITTING_IN_VEHICLE(PLAYER_PED_ID(), hoodVehicle[HV_FRANKLIN_VAN])
|
|
STRING sBanterSpeech
|
|
IF iReplayAttempt % 2 = 0
|
|
sBanterSpeech = "FKN0_B2AV1"
|
|
ELSE
|
|
sBanterSpeech = "FKN0_B2AV2"
|
|
ENDIF
|
|
|
|
IF DO_MISSION_SPEECH(sBanterSpeech)
|
|
dropoffStage = DROPOFF_STAGE_BANTER
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
HANDLE_IN_CAR_PROMPTS(TRUE, FALSE, TRUE)
|
|
BREAK
|
|
CASE DROPOFF_STAGE_BANTER
|
|
IF iWantedLevel = 0
|
|
IF IS_PED_SITTING_IN_VEHICLE(PLAYER_PED_ID(), hoodVehicle[HV_FRANKLIN_VAN])
|
|
IF bSavedBanter
|
|
IF RESTORE_BANTER()
|
|
bSavedBanter = FALSE
|
|
ENDIF
|
|
ELSE
|
|
STRING sMakeCallSpeech
|
|
IF iReplayAttempt % 2 = 0
|
|
sMakeCallSpeech = "FKN0_MKCALL"
|
|
ELSE
|
|
sMakeCallSpeech = "FKN0_MKCALL2"
|
|
ENDIF
|
|
IF DO_MISSION_SPEECH(sMakeCallSpeech)
|
|
dropoffStage = DROPOFF_STAGE_PRE_CALL
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
HANDLE_IN_CAR_PROMPTS(TRUE, FALSE, TRUE)
|
|
BREAK
|
|
CASE DROPOFF_STAGE_PRE_CALL
|
|
IF iWantedLevel = 0
|
|
IF IS_PED_SITTING_IN_VEHICLE(PLAYER_PED_ID(), hoodVehicle[HV_FRANKLIN_VAN])
|
|
AND lamarPhoneState >= LAMAR_PHONE_STATE_ON_PHONE
|
|
STRING sCallSpeech
|
|
IF iReplayAttempt % 2 = 0
|
|
sCallSpeech = "FKN0_LACALL"
|
|
ELSE
|
|
sCallSpeech = "FKN0_LACALL2"
|
|
ENDIF
|
|
IF DO_MISSION_SPEECH(sCallSpeech)
|
|
REPLAY_RECORD_BACK_FOR_TIME(1.5, 11.0, REPLAY_IMPORTANCE_HIGH)
|
|
dropoffStage = DROPOFF_STAGE_CALL
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
HANDLE_IN_CAR_PROMPTS(TRUE, FALSE, TRUE)
|
|
BREAK
|
|
CASE DROPOFF_STAGE_CALL
|
|
IF iWantedLevel = 0
|
|
IF IS_PED_SITTING_IN_VEHICLE(PLAYER_PED_ID(), hoodVehicle[HV_FRANKLIN_VAN])
|
|
STRING sAfterCallSpeech
|
|
IF iReplayAttempt % 2 = 0
|
|
sAfterCallSpeech = "FKN0_AFCALL"
|
|
ELSE
|
|
sAfterCallSpeech = "FKN0_AFCALL2"
|
|
ENDIF
|
|
IF DO_MISSION_SPEECH(sAfterCallSpeech)
|
|
//REMOVE_ALL_BLIPS()
|
|
dropoffStage = DROPOFF_STAGE_POST_CALL
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
|
|
HANDLE_IN_CAR_PROMPTS(NOT (dropoffStage = DROPOFF_STAGE_POST_CALL), FALSE, TRUE)
|
|
BREAK
|
|
CASE DROPOFF_STAGE_POST_CALL
|
|
IF iWantedLevel = 0
|
|
IF NOT IS_ANY_CONVERSATION_ONGOING_OR_QUEUED()
|
|
IF IS_PED_SITTING_IN_VEHICLE(PLAYER_PED_ID(), hoodVehicle[HV_FRANKLIN_VAN])
|
|
REMOVE_ALL_BLIPS()
|
|
iLetOutPromptTime = GET_GAME_TIMER()
|
|
iNextRandomSpeechTime = GET_GAME_TIMER() + 15000
|
|
|
|
PRELOAD_CONVERSATION(hoodConversation, "FKN0AUD", "FKN0_OPEN", CONV_PRIORITY_MEDIUM)
|
|
dropoffStage = DROPOFF_STAGE_STOP_VAN
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
HANDLE_IN_CAR_PROMPTS(FALSE, FALSE, TRUE)
|
|
BREAK
|
|
CASE DROPOFF_STAGE_STOP_VAN
|
|
BOOL bDisplayHelp
|
|
bDisplayHelp = FALSE
|
|
|
|
IF NOT bKilledPreloadSpeech
|
|
IF GET_GAME_TIMER() >= iNextRandomSpeechTime
|
|
OR NOT IS_PED_IN_ANY_VEHICLE(PLAYER_PED_ID())
|
|
KILL_ANY_CONVERSATION()
|
|
bKilledPreloadSpeech = TRUE
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF IS_PED_SITTING_IN_VEHICLE(PLAYER_PED_ID(), hoodVehicle[HV_FRANKLIN_VAN])
|
|
DO_RANDOM_SPEECH("FKN0_STOP", -1, 15000, 25000, TRUE)
|
|
ENDIF
|
|
|
|
IF iWantedLevel = 0
|
|
iLoseWantedTime = -1
|
|
IF bDoingDistantSiren
|
|
DISTANT_COP_CAR_SIRENS(FALSE)
|
|
bDoingDistantSiren = FALSE
|
|
ENDIF
|
|
|
|
IF GET_GAME_TIMER() >= iLetOutPromptTime + 22000
|
|
SET_PLAYER_WANTED_LEVEL(PLAYER_ID(), 2)
|
|
SET_PLAYER_WANTED_LEVEL_NOW(PLAYER_ID())
|
|
SET_WANTED_LEVEL_DIFFICULTY(PLAYER_ID(), 0)
|
|
ELSE
|
|
// figure out whether in a suitable spot to get out
|
|
FLOAT fLastGroundHeight
|
|
FLOAT fThisGroundHeight
|
|
|
|
GET_GROUND_Z_FOR_3D_COORD(GET_OFFSET_FROM_ENTITY_IN_WORLD_COORDS(hoodVehicle[HV_FRANKLIN_VAN], <<0,-2, 0>>), fLastGroundHeight)
|
|
|
|
IF GET_ENTITY_SPEED(hoodVehicle[HV_FRANKLIN_VAN]) <= 0.5
|
|
AND IS_ENTITY_UPRIGHT(hoodVehicle[HV_FRANKLIN_VAN])
|
|
iDoLetOutPromptTime = GET_GAME_TIMER()
|
|
//PRINTSTRING("THIS HEIGHT 0 = ") PRINTFLOAT(fLastGroundHeight) PRINTNL()
|
|
|
|
BOOL bOKToGetOut
|
|
bOKToGetOut = TRUE
|
|
|
|
VECTOR vBallaPos
|
|
vBallaPos = GET_ENTITY_COORDS(runnerChaseProperties.ped)
|
|
|
|
INT i
|
|
FOR i=1 TO 5
|
|
IF bOKToGetOut
|
|
VECTOR vThisCoord
|
|
vThisCoord = GET_OFFSET_FROM_ENTITY_IN_WORLD_COORDS(hoodVehicle[HV_FRANKLIN_VAN], <<0,-2 - (i*0.6), 0>>)
|
|
|
|
GET_GROUND_Z_FOR_3D_COORD(vThisCoord, fThisGroundHeight)
|
|
|
|
//PRINTSTRING("THIS HEIGHT ") PRINTINT(i) PRINTSTRING(" = ") PRINTFLOAT(fThisGroundHeight) PRINTNL()
|
|
|
|
FLOAT fDiff
|
|
fDiff = fThisGroundHeight - fLastGroundHeight
|
|
IF fDiff < 0
|
|
fDiff *= -1
|
|
ENDIF
|
|
IF fDiff > 0.5
|
|
bOKToGetOut = FALSE
|
|
ENDIF
|
|
fLastGroundHeight = fThisGroundHeight
|
|
|
|
IF fLastGroundHeight < vBallaPos.z - 2.0
|
|
bOKToGetOut = FALSE
|
|
ENDIF
|
|
ENDIF
|
|
ENDFOR
|
|
|
|
SWITCH shapeTestState
|
|
CASE SHAPE_TEST_STATE_NOT_STARTED
|
|
//PRINTSTRING("start shape test") printnl()
|
|
VECTOR vTestOffset
|
|
VECTOR vVanCoords
|
|
vVanCoords = GET_ENTITY_COORDS(hoodVehicle[HV_FRANKLIN_VAN])
|
|
vTestOffset = GET_OFFSET_FROM_ENTITY_IN_WORLD_COORDS(hoodVehicle[HV_FRANKLIN_VAN], <<0,-5,0>>)
|
|
vTestOffset.z = vTestOffset.z
|
|
|
|
bBackBlocked = TRUE
|
|
vanShapeTest = START_SHAPE_TEST_CAPSULE(vVanCoords, vTestOffset, 0.5, SCRIPT_INCLUDE_MOVER, hoodVehicle[HV_FRANKLIN_VAN])
|
|
shapeTestState = SHAPE_TEST_STATE_WAITING
|
|
BREAK
|
|
CASE SHAPE_TEST_STATE_WAITING
|
|
//PRINTSTRING("waiting on shape test") printnl()
|
|
SHAPETEST_STATUS shapeTestResult
|
|
INT iHitSomething
|
|
VECTOR vPos
|
|
VECTOR vNormal
|
|
ENTITY_INDEX hitEntity
|
|
shapeTestResult = GET_SHAPE_TEST_RESULT(vanShapeTest, iHitSomething, vPos, vNormal, hitEntity)
|
|
IF shapeTestResult = SHAPETEST_STATUS_RESULTS_READY
|
|
//PRINTSTRING("shape test results ready") printnl()
|
|
IF iHitSomething = 0
|
|
//PRINTSTRING("didn't hit!") printnl()
|
|
bBackBlocked = FALSE
|
|
shapeTestState = SHAPE_TEST_STATE_NOT_STARTED
|
|
ELSE
|
|
bBackBlocked = TRUE
|
|
//PRINTSTRING("hit something!") printnl()
|
|
shapeTestState = SHAPE_TEST_STATE_NOT_STARTED
|
|
ENDIF
|
|
ELIF shapeTestResult = SHAPETEST_STATUS_NONEXISTENT
|
|
//PRINTSTRING("reset shape test") printnl()
|
|
bBackBlocked = TRUE
|
|
shapeTestState = SHAPE_TEST_STATE_NOT_STARTED
|
|
ENDIF
|
|
BREAK
|
|
ENDSWITCH
|
|
|
|
|
|
IF bBackBlocked
|
|
OR NOT bOKToGetOut
|
|
OR IS_ENTITY_IN_WATER(hoodVehicle[HV_FRANKLIN_VAN])
|
|
fDisplayBadPositionTime = fDisplayBadPositionTime +@ 1.0
|
|
IF fDisplayBadPositionTime >= 1.0
|
|
bDisplayHelp = TRUE
|
|
ENDIF
|
|
ELSE
|
|
fDisplayBadPositionTime = 0.0
|
|
ENDIF
|
|
|
|
|
|
|
|
IF IS_PED_SITTING_IN_VEHICLE(PLAYER_PED_ID(), hoodVehicle[HV_FRANKLIN_VAN])
|
|
AND lamarPhoneState >= LAMAR_PHONE_STATE_POST_CALL
|
|
AND CAN_ADVANCE_MISSION()
|
|
AND IS_ENTITY_UPRIGHT(hoodVehicle[HV_FRANKLIN_VAN], 10)
|
|
AND bOKToGetOut
|
|
AND NOT bBackBlocked
|
|
AND NOT IS_ENTITY_IN_WATER(hoodVehicle[HV_FRANKLIN_VAN])
|
|
IF NOT IS_ANY_CONVERSATION_ONGOING_OR_QUEUED()
|
|
OR NOT bKilledPreloadSpeech
|
|
IF GET_PLAYER_WANTED_LEVEL(PLAYER_ID()) = 0
|
|
SET_PLAYER_WANTED_LEVEL(PLAYER_ID(), 0)
|
|
SET_PLAYER_WANTED_LEVEL_NOW(PLAYER_ID())
|
|
ENDIF
|
|
dropoffStage = DROPOFF_STAGE_END
|
|
CLEAR_HELP()
|
|
bRunningCutscene = TRUE
|
|
ENDIF
|
|
ENDIF
|
|
ELSE
|
|
bBackBlocked = TRUE
|
|
fDisplayBadPositionTime = 0.0
|
|
IF NOT bShownLetOutPrompt
|
|
RESET_WANTED_LEVEL_DIFFICULTY(PLAYER_ID())
|
|
iLetOutPromptTime = GET_GAME_TIMER()
|
|
iNextRandomSpeechTime = GET_GAME_TIMER() + 11000
|
|
bShownLetOutPrompt = TRUE
|
|
ELSE
|
|
IF IS_PED_SITTING_IN_VEHICLE(PLAYER_PED_ID(), hoodVehicle[HV_FRANKLIN_VAN])
|
|
IF GET_GAME_TIMER() >= iDoLetOutPromptTime + 300
|
|
DO_MISSION_GOD_TEXT("FC_LETOUT", TRUE, NOT bKilledPreloadSpeech, 100)
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ELSE
|
|
IF NOT bDoingDistantSiren
|
|
DISTANT_COP_CAR_SIRENS(TRUE)
|
|
bDoingDistantSiren = TRUE
|
|
ENDIF
|
|
|
|
IF NOT bDonePoliceReport
|
|
PLAY_POLICE_REPORT("SCRIPTED_SCANNER_REPORT_FRANLIN_0_KIDNAP", 0.0)
|
|
bDonePoliceReport = TRUE
|
|
ENDIF
|
|
|
|
bBackBlocked = TRUE
|
|
bShownLetOutPrompt = FALSE
|
|
iLetOutPromptTime = GET_GAME_TIMER()
|
|
ENDIF
|
|
|
|
IF bDisplayHelp
|
|
IF NOT IS_THIS_HELP_MESSAGE_BEING_DISPLAYED("FC_POSHLP")
|
|
PRINT_HELP_FOREVER("FC_POSHLP")
|
|
ENDIF
|
|
ELSE
|
|
IF IS_THIS_HELP_MESSAGE_BEING_DISPLAYED("FC_POSHLP")
|
|
CLEAR_HELP(TRUE)
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF NOT bRunningCutscene
|
|
HANDLE_IN_CAR_PROMPTS(FALSE, FALSE, TRUE)
|
|
ENDIF
|
|
BREAK
|
|
|
|
CASE DROPOFF_STAGE_END
|
|
IF NOT bStoppedVanAnim
|
|
DISABLE_CONTROL_ACTION(PLAYER_CONTROL, INPUT_VEH_EXIT)
|
|
|
|
IF IS_ENTITY_PLAYING_ANIM(hoodVehicle[HV_FRANKLIN_VAN], GET_HOOD_ANIM_DICT_AS_STRING(H_ANIM_DICT_DRIVE_HOME), "InCar_GetOutofBack_Speedo")
|
|
//PRINTFLOAT(GET_ENTITY_ANIM_CURRENT_TIME(hoodVehicle[HV_FRANKLIN_VAN], GET_HOOD_ANIM_DICT_AS_STRING(H_ANIM_DICT_DRIVE_HOME), "InCar_GetOutofBack_Speedo")) PRINTNL()
|
|
|
|
IF GET_ENTITY_ANIM_CURRENT_TIME(hoodVehicle[HV_FRANKLIN_VAN], GET_HOOD_ANIM_DICT_AS_STRING(H_ANIM_DICT_DRIVE_HOME), "InCar_GetOutofBack_Speedo") >= 0.33
|
|
STOP_ENTITY_ANIM(hoodVehicle[HV_FRANKLIN_VAN], "InCar_GetOutofBack_Speedo", GET_HOOD_ANIM_DICT_AS_STRING(H_ANIM_DICT_DRIVE_HOME), INSTANT_BLEND_OUT)
|
|
SET_VEHICLE_DOOR_SHUT(hoodVehicle[HV_FRANKLIN_VAN], SC_DOOR_REAR_LEFT)
|
|
SET_VEHICLE_DOOR_SHUT(hoodVehicle[HV_FRANKLIN_VAN], SC_DOOR_REAR_RIGHT)
|
|
|
|
REPLAY_RECORD_BACK_FOR_TIME(8.0, 8.0, REPLAY_IMPORTANCE_HIGHEST)
|
|
|
|
bStoppedVanAnim = TRUE
|
|
ENDIF
|
|
ELSE
|
|
bStoppedVanAnim = TRUE
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF NOT bCleanedUpPhone
|
|
IF DOES_ENTITY_EXIST(lamarPhoneObject)
|
|
IF NOT IS_ENTITY_AT_ENTITY(PLAYER_PED_ID(), lamarPhoneObject, <<100,100,100>>, FALSE, FALSE)
|
|
SET_OBJECT_AS_NO_LONGER_NEEDED(lamarPhoneObject)
|
|
CLEAR_MODEL_REQUEST(ENUM_TO_INT(HM_LAMAR_PHONE))
|
|
bCleanedUpPhone = TRUE
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF NOT bCleanedUpBalla
|
|
IF DOES_ENTITY_EXIST(runnerChaseProperties.ped)
|
|
IF NOT IS_PED_INJURED(runnerChaseProperties.ped)
|
|
IF NOT IS_ENTITY_AT_ENTITY(PLAYER_PED_ID(), runnerChaseProperties.ped, <<150,150,150>>, FALSE, FALSE)
|
|
IF NOT IS_ENTITY_ON_SCREEN(runnerChaseProperties.ped)
|
|
SET_PED_AS_NO_LONGER_NEEDED(runnerChaseProperties.ped)
|
|
CLEAR_MODEL_REQUEST(ENUM_TO_INT(HM_BAD_GUY))
|
|
bCleanedUpBalla = TRUE
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF franklinMaskRemoveState <> FRANKLIN_MASK_REMOVE_STATE_DONE
|
|
FLOAT fMaskPhase
|
|
IF franklinMaskRemoveState > FRANKLIN_MASK_REMOVE_STATE_NOT_STARTED
|
|
IF IS_ENTITY_PLAYING_ANIM(PLAYER_PED_ID(), GET_HOOD_ANIM_DICT_AS_STRING(H_ANIM_DICT_DRIVE_HOME), "Take_off_Bandana")
|
|
fMaskPhase = GET_ENTITY_ANIM_CURRENT_TIME(PLAYER_PED_ID(), GET_HOOD_ANIM_DICT_AS_STRING(H_ANIM_DICT_DRIVE_HOME), "Take_off_Bandana")
|
|
ELSE
|
|
IF GET_GAME_TIMER() >= iFranklinMaskRemoveTime + 500
|
|
SET_FRANKLIN_MASK(FALSE)
|
|
IF DOES_ENTITY_EXIST(franklinBandanaObject)
|
|
DELETE_OBJECT(franklinBandanaObject)
|
|
ENDIF
|
|
franklinMaskRemoveState = FRANKLIN_MASK_REMOVE_STATE_DONE
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
|
|
SWITCH franklinMaskRemoveState
|
|
CASE FRANKLIN_MASK_REMOVE_STATE_NOT_STARTED
|
|
BOOL bCanRemoveMask
|
|
bCanRemoveMask = FALSE
|
|
IF IS_PED_SITTING_IN_VEHICLE(PLAYER_PED_ID(), hoodVehicle[HV_FRANKLIN_VAN])
|
|
IF NOT IS_PED_INJURED(runnerChaseProperties.ped)
|
|
IF IS_ENTITY_AT_COORD(PLAYER_PED_ID(), GET_HOOD_VECTOR(HVEC_REC), <<120,120,120>>, FALSE, FALSE)
|
|
OR NOT IS_ENTITY_AT_ENTITY(PLAYER_PED_ID(), runnerChaseProperties.ped, <<75,75,75>>, FALSE, FALSE)
|
|
bCanRemoveMask = TRUE
|
|
ENDIF
|
|
ELSE
|
|
bCanRemoveMask = TRUE
|
|
ENDIF
|
|
|
|
IF bCanRemoveMask
|
|
IF GET_FOLLOW_VEHICLE_CAM_VIEW_MODE() <> CAM_VIEW_MODE_FIRST_PERSON
|
|
TASK_PLAY_ANIM(PLAYER_PED_ID(), GET_HOOD_ANIM_DICT_AS_STRING(H_ANIM_DICT_DRIVE_HOME), "Take_off_Bandana", NORMAL_BLEND_IN, NORMAL_BLEND_OUT, -1, AF_UPPERBODY | AF_SECONDARY)
|
|
FORCE_PED_AI_AND_ANIMATION_UPDATE(PLAYER_PED_ID())
|
|
franklinBandanaObject = CREATE_OBJECT(GET_MODEL_FOR_HOOD_MODEL_ENUM(HM_FRANKLIN_MASK), <<0,1,2>>)
|
|
|
|
SET_ENTITY_VISIBLE(franklinBandanaObject, FALSE)
|
|
ATTACH_ENTITY_TO_ENTITY(franklinBandanaObject, PLAYER_PED_ID(), GET_PED_BONE_INDEX(PLAYER_PED_ID(), BONETAG_PH_L_HAND), <<0.0, 0.0, 0.0>>, <<0.0, 0.0, 0.0>>)
|
|
PLAY_ENTITY_ANIM(franklinBandanaObject, "take_off_bandana_bandana", GET_HOOD_ANIM_DICT_AS_STRING(H_ANIM_DICT_DRIVE_HOME), NORMAL_BLEND_IN, FALSE, FALSE)
|
|
iFranklinMaskRemoveTime = GET_GAME_TIMER()
|
|
franklinMaskRemoveState = FRANKLIN_MASK_REMOVE_STATE_PLAYING_ANIM
|
|
ELSE
|
|
SET_FRANKLIN_MASK(FALSE)
|
|
franklinMaskRemoveState = FRANKLIN_MASK_REMOVE_STATE_DONE
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
BREAK
|
|
|
|
CASE FRANKLIN_MASK_REMOVE_STATE_PLAYING_ANIM
|
|
CONST_FLOAT CREATE_BANDANA_PHASE 0.2
|
|
|
|
//PRINTSTRING("franklinPhase = ") PRINTFLOAT(GET_ENTITY_ANIM_CURRENT_TIME(PLAYER_PED_ID(), GET_HOOD_ANIM_DICT_AS_STRING(H_ANIM_DICT_MISSION), "Take_off_Bandana")) PRINTNL()
|
|
//PRINTSTRING("bandanaPhase = ") PRINTFLOAT(GET_ENTITY_ANIM_CURRENT_TIME(franklinBandanaObject, GET_HOOD_ANIM_DICT_AS_STRING(H_ANIM_DICT_MISSION), "Take_off_Bandana_bandana")) PRINTNL()
|
|
|
|
IF fMaskPhase >= CREATE_BANDANA_PHASE
|
|
SET_FRANKLIN_MASK(FALSE)
|
|
IF DOES_ENTITY_EXIST(franklinBandanaObject)
|
|
SET_ENTITY_VISIBLE(franklinBandanaObject, TRUE)
|
|
ENDIF
|
|
//printstring("set entity visible!") printnl()
|
|
franklinMaskRemoveState = FRANKLIN_MASK_REMOVE_STATE_PUTTING_AWAY
|
|
ENDIF
|
|
BREAK
|
|
|
|
CASE FRANKLIN_MASK_REMOVE_STATE_PUTTING_AWAY
|
|
IF fMaskPhase >= 0.95
|
|
IF DOES_ENTITY_EXIST(franklinBandanaObject)
|
|
DELETE_OBJECT(franklinBandanaObject)
|
|
ENDIF
|
|
franklinMaskRemoveState = FRANKLIN_MASK_REMOVE_STATE_DONE
|
|
ENDIF
|
|
BREAK
|
|
ENDSWITCH
|
|
ELSE
|
|
HANDLE_STREAMING_MOCAP("fra_0_mcs_5_p1", GET_HOOD_VECTOR(HVEC_REC), DEFAULT_CUTSCENE_LOAD_DIST, DEFAULT_CUTSCENE_UNLOAD_DIST)
|
|
IF CAN_REQUEST_ASSETS_FOR_CUTSCENE_ENTITY()
|
|
IF NOT IS_PED_INJURED(lamarPed)
|
|
SET_CUTSCENE_PED_COMPONENT_VARIATION_FROM_PED("Lamar", lamarPed)
|
|
ENDIF
|
|
IF NOT IS_PED_INJURED(chopPed)
|
|
SET_CUTSCENE_PED_COMPONENT_VARIATION_FROM_PED("Chop", chopPed)
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF NOT bForcePassOnShitskip
|
|
IF iWantedLevel = 0
|
|
AND NOT bCutsceneWaitStarted
|
|
IF IS_PED_SITTING_IN_VEHICLE(PLAYER_PED_ID(), hoodVehicle[HV_FRANKLIN_VAN])
|
|
IF NOT bDoneBanter
|
|
IF NOT bDoneThreatenResponseSpeech
|
|
IF NOT IS_PED_INJURED(runnerChaseProperties.ped)
|
|
IF IS_ENTITY_AT_ENTITY(PLAYER_PED_ID(), runnerChaseProperties.ped, <<30,30,4>>)
|
|
bDoneThreatenResponseSpeech = DO_MISSION_SPEECH("FKN0_DSHOUT")
|
|
ELSE
|
|
bDoneThreatenResponseSpeech = TRUE
|
|
ENDIF
|
|
ELSE
|
|
bDoneThreatenResponseSpeech = TRUE
|
|
ENDIF
|
|
ELSE
|
|
IF NOT bDoneFranklinShoutSpeech
|
|
IF NOT IS_PED_INJURED(runnerChaseProperties.ped)
|
|
IF IS_ENTITY_AT_ENTITY(PLAYER_PED_ID(), runnerChaseProperties.ped, <<30,30,4>>)
|
|
bDoneFranklinShoutSpeech = DO_MISSION_SPEECH("FKN0_FSHOUT")
|
|
ELSE
|
|
bDoneFranklinShoutSpeech = TRUE
|
|
ENDIF
|
|
ELSE
|
|
bDoneFranklinShoutSpeech = TRUE
|
|
ENDIF
|
|
ELSE
|
|
IF NOT bDoneLamarShoutSpeech
|
|
IF NOT IS_PED_INJURED(runnerChaseProperties.ped)
|
|
IF IS_ENTITY_AT_ENTITY(PLAYER_PED_ID(), runnerChaseProperties.ped, <<30,30,4>>)
|
|
bDoneLamarShoutSpeech = DO_MISSION_SPEECH("FKN0_LAMFU")
|
|
ELSE
|
|
bDoneLamarShoutSpeech = TRUE
|
|
ENDIF
|
|
ELSE
|
|
bDoneLamarShoutSpeech = TRUE
|
|
ENDIF
|
|
ELSE
|
|
IF NOT bDoneGotoSpeech
|
|
bDoneGotoSpeech = DO_MISSION_SPEECH("FKN0_GOREC")
|
|
ELSE
|
|
IF bShownGodText
|
|
IF NOT bCutsceneWaitStarted
|
|
bDoneBanter = DO_MISSION_SPEECH("FKN0_B3AV1")
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ELSE
|
|
IF NOT bKilledTalkAboutMichaelSpeech
|
|
IF bSavedBanter
|
|
IF RESTORE_BANTER()
|
|
bSavedBanter = FALSE
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF NOT GET_MISSION_COMPLETE_STATE(SP_MISSION_ARMENIAN_3)
|
|
IF IS_ANY_CONVERSATION_ONGOING_OR_QUEUED()
|
|
TEXT_LABEL_23 tCurrentLabel
|
|
tCurrentLabel = GET_CURRENTLY_PLAYING_STANDARD_CONVERSATION_LABEL()
|
|
PRINTSTRING(tCurrentLabel) PRINTNL()
|
|
IF ARE_STRINGS_EQUAL(tCurrentLabel, "FKN0_B3AV1_12")
|
|
KILL_ANY_CONVERSATION()
|
|
bKilledTalkAboutMichaelSpeech = TRUE
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF NOT bCutsceneWaitStarted
|
|
IF IS_PED_SITTING_IN_VEHICLE(PLAYER_PED_ID(), hoodVehicle[HV_FRANKLIN_VAN])
|
|
IF CAN_ADVANCE_MISSION()
|
|
IF iWantedLevel = 0
|
|
IF bStoppedVanAnim
|
|
IF IS_ENTITY_AT_COORD(PLAYER_PED_ID(), GET_HOOD_VECTOR(HVEC_REC), g_vAnyMeansLocate, TRUE)
|
|
IF CAN_PLAYER_START_CUTSCENE()
|
|
//SET_PLAYER_CONTROL(PLAYER_ID(), FALSE, SPC_LEAVE_CAMERA_CONTROL_ON)
|
|
PREVENT_WANTED_LEVEL_FOR_CUTSCENE()
|
|
REMOVE_ALL_BLIPS()
|
|
KILL_ANY_CONVERSATION()
|
|
iCutsceneTriggerTime = GET_GAME_TIMER()
|
|
bCutsceneWaitStarted = TRUE
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ELSE
|
|
PREVENT_WANTED_LEVEL_FOR_CUTSCENE()
|
|
IF BRING_VEHICLE_TO_HALT_AND_DISABLE_VEH_CONTROLS(hoodVehicle[HV_FRANKLIN_VAN], 10.0)
|
|
IF GET_GAME_TIMER() >= iCutsceneTriggerTime + DEFAULT_CAR_STOPPING_TO_CUTSCENE
|
|
IF NOT IS_ANY_CONVERSATION_ONGOING_OR_QUEUED()
|
|
IF CAN_ADVANCE_MISSION()
|
|
IF mocapStreamingStage > MOCAP_STREAMING_STAGE_REQUEST
|
|
IF HAS_CUTSCENE_LOADED_WITH_FAILSAFE()
|
|
bRunningCutscene = TRUE
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
|
|
MAINTAIN_BAD_GUY_FLEE()
|
|
IF NOT bCutsceneWaitStarted
|
|
HANDLE_IN_CAR_PROMPTS(TRUE, FALSE, TRUE)
|
|
ENDIF
|
|
BREAK
|
|
ENDSWITCH
|
|
|
|
// chop returns to sitting pos
|
|
IF NOT bChopTurnToIdle
|
|
IF NOT IS_PED_INJURED(runnerChaseProperties.ped)
|
|
IF NOT IS_ENTITY_ATTACHED(runnerChaseProperties.ped)
|
|
VECTOR vInitRot = GET_ANIM_INITIAL_OFFSET_ROTATION(GET_HOOD_ANIM_DICT_AS_STRING(H_ANIM_DICT_CHOP_VAN), "CHOP_GROWL_TO_SIT", <<0,0,0>>, <<0,0,0>>, 0) + <<0,0,CHOP_GROWL_ROT>>
|
|
//PRINTSTRING("Initheader = ") PRINTVECTOR(vInitRot) PRINTNL()
|
|
ATTACH_CHOP_TO_VAN(chopPed, hoodVehicle[HV_FRANKLIN_VAN], vInitRot.z)
|
|
SET_ENTITY_PROOFS(chopPed, FALSE, TRUE, TRUE, FALSE, FALSE, FALSE, FALSE, TRUE)
|
|
TASK_PLAY_ANIM(chopPed, GET_HOOD_ANIM_DICT_AS_STRING(H_ANIM_DICT_CHOP_VAN), "CHOP_GROWL_TO_SIT", NORMAL_BLEND_IN, NORMAL_BLEND_OUT, -1, AF_HOLD_LAST_FRAME | AF_EXTRACT_INITIAL_OFFSET)
|
|
FORCE_PED_AI_AND_ANIMATION_UPDATE(chopPed)
|
|
bChopTurnToIdle = TRUE
|
|
ENDIF
|
|
ENDIF
|
|
ELSE
|
|
IF NOT bChopResetInIdle
|
|
IF NOT IS_PED_INJURED(chopPed)
|
|
IF IS_ENTITY_PLAYING_ANIM(chopPed, GET_HOOD_ANIM_DICT_AS_STRING(H_ANIM_DICT_CHOP_VAN), "CHOP_GROWL_TO_SIT")
|
|
FLOAT fPhase = GET_ENTITY_ANIM_CURRENT_TIME(chopPed, GET_HOOD_ANIM_DICT_AS_STRING(H_ANIM_DICT_CHOP_VAN), "CHOP_GROWL_TO_SIT")
|
|
IF fPhase >= 0.98
|
|
TASK_PLAY_ANIM(chopPed, GET_HOOD_ANIM_DICT_AS_STRING(H_ANIM_DICT_CHOP_VAN), "CHOP_SIT_LOOP", NORMAL_BLEND_IN, NORMAL_BLEND_OUT, -1, AF_LOOPING | AF_EXTRACT_INITIAL_OFFSET)
|
|
bChopResetInIdle = TRUE
|
|
ELSE
|
|
IF fPhase >= 0
|
|
VECTOR vExtractedRot = GET_ANIM_INITIAL_OFFSET_ROTATION(GET_HOOD_ANIM_DICT_AS_STRING(H_ANIM_DICT_CHOP_VAN), "CHOP_GROWL_TO_SIT", <<0,0,0>>, <<0,0,0>>, fPhase) + <<0,0,CHOP_GROWL_ROT>>
|
|
//PRINTSTRING("heading = ") PRINTVECTOR(vExtractedRot) PRINTNL()
|
|
ATTACH_CHOP_TO_VAN(chopPed, hoodVehicle[HV_FRANKLIN_VAN], vExtractedRot.z)
|
|
SET_ENTITY_PROOFS(chopPed, FALSE, TRUE, TRUE, FALSE, FALSE, FALSE, FALSE, TRUE)
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ELSE
|
|
HANDLE_CHOP_LEAN_IN_VAN(chopPed, hoodVehicle[HV_FRANKLIN_VAN], chopLeanInVanState, fCachedVanSpeed, iNextChopAnimTime, iNextBarkTime)
|
|
ENDIF
|
|
ENDIF
|
|
|
|
// remove trainyard
|
|
IF NOT bRemovedChaseSetpieces
|
|
IF NOT IS_ENTITY_AT_COORD(PLAYER_PED_ID(), GET_HOOD_VECTOR(HVEC_TRAINYARD), <<150,150,150>>, FALSE, FALSE)
|
|
REMOVE_CHASE_SETPIECES()
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ELSE
|
|
// lamar walk round corner and leave
|
|
IF NOT IS_PED_INJURED(chopPed)
|
|
SET_PED_MOVE_RATE_OVERRIDE(chopPed, 1.00)
|
|
IF IS_WAYPOINT_PLAYBACK_GOING_ON_FOR_PED(chopPed)
|
|
WAYPOINT_PLAYBACK_OVERRIDE_SPEED(chopPed, PEDMOVE_RUN)
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF NOT IS_PED_INJURED(lamarPed)
|
|
SET_PED_MOVE_RATE_OVERRIDE(lamarPed, 1.15)
|
|
ENDIF
|
|
|
|
IF GET_GAME_TIMER() >= iLamarOutOfVanTime + 3200
|
|
IF DOES_ENTITY_EXIST(lamarPed)
|
|
DELETE_PED(lamarPed)
|
|
ENDIF
|
|
IF DOES_ENTITY_EXIST(chopPed)
|
|
DELETE_PED(chopPed)
|
|
ENDIF
|
|
MISSION_PASSED()
|
|
ENDIF
|
|
ENDIF
|
|
ELSE
|
|
IF NOT bDoneLetOut
|
|
DO_LET_OUT_CUTSCENE()
|
|
ELSE
|
|
DO_DROPOFF_CUTSCENE()
|
|
ENDIF
|
|
ENDIF
|
|
|
|
// handle lamar phone state
|
|
IF NOT IS_PED_INJURED(lamarPed)
|
|
AND NOT IS_PED_INJURED(PLAYER_PED_ID())
|
|
SWITCH lamarPhoneState
|
|
CASE LAMAR_PHONE_STATE_NOT_STARTED
|
|
lamarPhoneObject = CREATE_OBJECT(GET_MODEL_FOR_HOOD_MODEL_ENUM(HM_LAMAR_PHONE), <<0,1,2>>)
|
|
ATTACH_ENTITY_TO_ENTITY(lamarPhoneObject, lamarPed, GET_PED_BONE_INDEX(lamarPed, BONETAG_PH_L_HAND), <<0.0, 0.0, 0.0>>, <<0.0, 0.0, 0.0>>)
|
|
IF NOT IS_ENTITY_PLAYING_ANIM(lamarPed, GET_HOOD_ANIM_DICT_AS_STRING(H_ANIM_DICT_DRIVE_HOME), "InCar_PhoneIdle_Lem")
|
|
TASK_PLAY_ANIM(lamarPed, GET_HOOD_ANIM_DICT_AS_STRING(H_ANIM_DICT_DRIVE_HOME), "InCar_PhoneIdle_Lem", NORMAL_BLEND_IN, NORMAL_BLEND_OUT, -1, AF_LOOPING)
|
|
ENDIF
|
|
|
|
lamarPhoneState = LAMAR_PHONE_STATE_PRE_CALL
|
|
BREAK
|
|
CASE LAMAR_PHONE_STATE_PRE_CALL
|
|
DRAW_FAKE_CELLPHONE_SCREEN(fakeCellphoneData, FALSE, FAKE_CELLPHONE_SCREEN_GENERIC_MENU)
|
|
IF dropoffStage >= DROPOFF_STAGE_PRE_CALL
|
|
|
|
TASK_PLAY_ANIM(lamarPed, GET_HOOD_ANIM_DICT_AS_STRING(H_ANIM_DICT_DRIVE_HOME), "Incar_Phonetalk_enter_Lem", NORMAL_BLEND_IN, NORMAL_BLEND_OUT, -1, AF_HOLD_LAST_FRAME)
|
|
lamarPhoneState = LAMAR_PHONE_STATE_PHONE_UP
|
|
ENDIF
|
|
BREAK
|
|
CASE LAMAR_PHONE_STATE_PHONE_UP
|
|
DRAW_FAKE_CELLPHONE_SCREEN(fakeCellphoneData, FALSE, FAKE_CELLPHONE_SCREEN_GENERIC_CALL)
|
|
IF IS_ENTITY_PLAYING_ANIM(lamarPed, GET_HOOD_ANIM_DICT_AS_STRING(H_ANIM_DICT_DRIVE_HOME), "Incar_Phonetalk_enter_Lem")
|
|
IF GET_ENTITY_ANIM_CURRENT_TIME(lamarPed, GET_HOOD_ANIM_DICT_AS_STRING(H_ANIM_DICT_DRIVE_HOME), "Incar_Phonetalk_enter_Lem") >= 0.98
|
|
TASK_PLAY_ANIM(lamarPed, GET_HOOD_ANIM_DICT_AS_STRING(H_ANIM_DICT_DRIVE_HOME), "Incar_Phonetalk_loop_Lem", NORMAL_BLEND_IN, NORMAL_BLEND_OUT, -1, AF_LOOPING)
|
|
lamarPhoneState = LAMAR_PHONE_STATE_ON_PHONE
|
|
ENDIF
|
|
ENDIF
|
|
BREAK
|
|
CASE LAMAR_PHONE_STATE_ON_PHONE
|
|
DRAW_FAKE_CELLPHONE_SCREEN(fakeCellphoneData, FALSE, FAKE_CELLPHONE_SCREEN_GENERIC_CALL)
|
|
IF dropoffStage >= DROPOFF_STAGE_POST_CALL
|
|
TASK_PLAY_ANIM(lamarPed, GET_HOOD_ANIM_DICT_AS_STRING(H_ANIM_DICT_DRIVE_HOME), "Incar_Phonetalk_exit_Lem", NORMAL_BLEND_IN, NORMAL_BLEND_OUT, -1, AF_HOLD_LAST_FRAME)
|
|
lamarPhoneState = LAMAR_PHONE_STATE_PHONE_DOWN
|
|
ENDIF
|
|
BREAK
|
|
CASE LAMAR_PHONE_STATE_PHONE_DOWN
|
|
DRAW_FAKE_CELLPHONE_SCREEN(fakeCellphoneData, FALSE, FAKE_CELLPHONE_SCREEN_GENERIC_MENU)
|
|
IF IS_ENTITY_PLAYING_ANIM(lamarPed, GET_HOOD_ANIM_DICT_AS_STRING(H_ANIM_DICT_DRIVE_HOME), "Incar_Phonetalk_exit_Lem")
|
|
IF GET_ENTITY_ANIM_CURRENT_TIME(lamarPed, GET_HOOD_ANIM_DICT_AS_STRING(H_ANIM_DICT_DRIVE_HOME), "Incar_Phonetalk_exit_Lem") >= 0.98
|
|
TASK_PLAY_ANIM(lamarPed, GET_HOOD_ANIM_DICT_AS_STRING(H_ANIM_DICT_DRIVE_HOME), "InCar_PhoneIdle_Lem", NORMAL_BLEND_IN, NORMAL_BLEND_OUT, -1, AF_LOOPING)
|
|
lamarPhoneState = LAMAR_PHONE_STATE_POST_CALL
|
|
ENDIF
|
|
ENDIF
|
|
BREAK
|
|
CASE LAMAR_PHONE_STATE_POST_CALL
|
|
DRAW_FAKE_CELLPHONE_SCREEN(fakeCellphoneData, FALSE, FAKE_CELLPHONE_SCREEN_GENERIC_MENU)
|
|
IF dropoffStage = DROPOFF_STAGE_END
|
|
IF bStartedLetOutCutscene
|
|
AND cutsceneStage = H_CUT_STAGE_RUNNING
|
|
TASK_CLEAR_LOOK_AT(PLAYER_PED_ID())
|
|
TASK_PLAY_ANIM(lamarPed, GET_HOOD_ANIM_DICT_AS_STRING(H_ANIM_DICT_DRIVE_HOME), "InCar_PhoneSnatch_Lem", NORMAL_BLEND_IN, NORMAL_BLEND_OUT, -1)
|
|
TASK_PLAY_ANIM(PLAYER_PED_ID(), GET_HOOD_ANIM_DICT_AS_STRING(H_ANIM_DICT_DRIVE_HOME), "InCar_PhoneSnatch_Fra", NORMAL_BLEND_IN, NORMAL_BLEND_OUT, -1, AF_SECONDARY)
|
|
|
|
lamarPhoneState = LAMAR_PHONE_STATE_SNATCH
|
|
ENDIF
|
|
ENDIF
|
|
BREAK
|
|
CASE LAMAR_PHONE_STATE_SNATCH
|
|
DRAW_FAKE_CELLPHONE_SCREEN(fakeCellphoneData, FALSE, FAKE_CELLPHONE_SCREEN_GENERIC_MENU)
|
|
IF NOT IS_ENTITY_PLAYING_ANIM(PLAYER_PED_ID(), GET_HOOD_ANIM_DICT_AS_STRING(H_ANIM_DICT_DRIVE_HOME), "InCar_PhoneSnatch_Fra")
|
|
lamarPhoneState = LAMAR_PHONE_STATE_DONE
|
|
ELSE
|
|
IF NOT bPhoneForceApplied
|
|
IF GET_ENTITY_ANIM_CURRENT_TIME(PLAYER_PED_ID(), GET_HOOD_ANIM_DICT_AS_STRING(H_ANIM_DICT_DRIVE_HOME), "InCar_PhoneSnatch_Fra") >= 0.47
|
|
IF DOES_ENTITY_EXIST(lamarPhoneObject)
|
|
DETACH_ENTITY(lamarPhoneObject)
|
|
APPLY_FORCE_TO_ENTITY_CENTER_OF_MASS(lamarPhoneObject, APPLY_TYPE_IMPULSE, <<3,0.5,0>>, 0, TRUE, TRUE)
|
|
bPhoneForceApplied = TRUE
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
BREAK
|
|
CASE LAMAR_PHONE_STATE_DONE
|
|
DRAW_FAKE_CELLPHONE_SCREEN(fakeCellphoneData, FALSE, FAKE_CELLPHONE_SCREEN_GENERIC_MENU)
|
|
BREAK
|
|
ENDSWITCH
|
|
ENDIF
|
|
ENDPROC
|
|
|
|
// debug only
|
|
#IF IS_DEBUG_BUILD
|
|
// create widgets
|
|
PROC CREATE_HOOD_WIDGETS()
|
|
hoodWidgets = START_WIDGET_GROUP("Foot Chase")
|
|
RBCamPosWidget = ADD_TEXT_WIDGET("Cam Position")
|
|
RBCamRotWidget = ADD_TEXT_WIDGET("Cam Rotation")
|
|
ADD_WIDGET_FLOAT_SLIDER("Cam FOV", fRBDebugCamFOV, 0, 80, 1.0)
|
|
|
|
ADD_WIDGET_VECTOR_SLIDER("Van cam Offset", vDebugVanCamOffset, -20, 20, 0.1)
|
|
ADD_WIDGET_VECTOR_SLIDER("Van cam Point", vDebugVanCamPoint, -20, 20, 0.1)
|
|
ADD_WIDGET_FLOAT_SLIDER("Van cam FOV", fDebugVanCamFOV, 0.0, 360.0, 0.5)
|
|
|
|
ADD_WIDGET_VECTOR_SLIDER("Boxcar cam Offset", vDebugBoxcarCamOffset, -20, 20, 0.1)
|
|
ADD_WIDGET_VECTOR_SLIDER("Boxcar cam Point", vDebugBoxcarCamPoint, -20, 20, 0.1)
|
|
ADD_WIDGET_FLOAT_SLIDER("Boxcar cam FOV", fDebugBoxcarCamFOV, 0.0, 360.0, 0.5)
|
|
|
|
ADD_WIDGET_BOOL("Do Dump", bRBDebugCamDoDump)
|
|
STOP_WIDGET_GROUP()
|
|
set_uber_parent_widget_group(hoodWidgets)
|
|
IF bDebugDoUber
|
|
CREATE_TRAFFIC_WIDGET()
|
|
INIT_UBER_RECORDING(GET_HOOD_UBER_RECORDING_PREFIX())
|
|
ENDIF
|
|
ENDPROC
|
|
|
|
// setup the debug menu
|
|
PROC SETUP_HOOD_DEBUG_MENU()
|
|
stageMenu[0].sTxtLabel = "Cutscene FRA_0_INT"
|
|
stageMenu[0].bSelectable = FALSE
|
|
stageMenu[1].sTxtLabel = GET_DESCRIPTION_FOR_STAGE_AS_STRING(STAGE_GET_TO_BAD_GUY)
|
|
stageMenu[2].sTxtLabel = "Cutscene FRA_0_MCS_0"
|
|
stageMenu[2].bSelectable = FALSE
|
|
stageMenu[3].sTxtLabel = "Cutscene FRA_0_MCS_1"
|
|
stageMenu[3].bSelectable = FALSE
|
|
stageMenu[4].sTxtLabel = GET_DESCRIPTION_FOR_STAGE_AS_STRING(STAGE_VAN_CHASE)
|
|
stageMenu[5].sTxtLabel = "Cutscene FRA_0_MCS_2"
|
|
stageMenu[5].bSelectable = FALSE
|
|
stageMenu[6].sTxtLabel = GET_DESCRIPTION_FOR_STAGE_AS_STRING(STAGE_FOOT_CHASE)
|
|
stageMenu[7].sTxtLabel = GET_DESCRIPTION_FOR_STAGE_AS_STRING(STAGE_FIND_BAD_GUY)
|
|
stageMenu[8].sTxtLabel = "Cutscene FRA_0_MCS_4"
|
|
stageMenu[8].bSelectable = FALSE
|
|
stageMenu[9].sTxtLabel = GET_DESCRIPTION_FOR_STAGE_AS_STRING(STAGE_GET_TO_HOUSE)
|
|
stageMenu[10].sTxtLabel = "Cutscene FRA_0_EXT"
|
|
stageMenu[10].bSelectable = FALSE
|
|
ENDPROC
|
|
|
|
// debug skips
|
|
PROC DO_DEBUG_SKIPS()
|
|
// mission pass S
|
|
IF IS_KEYBOARD_KEY_JUST_PRESSED(KEY_S)
|
|
SET_FRANKLIN_MASK(FALSE)
|
|
bThoroughCleanup = TRUE
|
|
MISSION_PASSED()
|
|
ENDIF
|
|
|
|
// mission fail F
|
|
IF IS_KEYBOARD_KEY_JUST_PRESSED(KEY_F)
|
|
MISSION_FAILED(FAIL_LOST_BAD_GUY)
|
|
ENDIF
|
|
|
|
// skip stage J
|
|
IF IS_KEYBOARD_KEY_JUST_PRESSED(KEY_J)
|
|
IF NOT bRunningCutscene
|
|
IF NOT IS_PED_INJURED(PLAYER_PED_ID())
|
|
SET_PLAYER_CONTROL(PLAYER_ID(), TRUE)
|
|
|
|
SWITCH currentMissionStage
|
|
CASE STAGE_GET_TO_BAD_GUY
|
|
IF NOT bDoneLamarIntoVan
|
|
IF chopIntoVanState = CHOP_INTO_VAN_STATE_NOT_STARTED
|
|
IF NOT IS_PED_INJURED(PLAYER_PED_ID())
|
|
SET_ENTITY_COORDS(PLAYER_PED_ID(), <<-76.99, -1459.45, 31.09>>)
|
|
CLEAR_PED_TASKS_IMMEDIATELY(PLAYER_PED_ID())
|
|
ENDIF
|
|
IF NOT IS_PED_INJURED(lamarPed)
|
|
SET_ENTITY_COORDS(lamarPed, <<-76.06, -1458.92, 31.09>>)
|
|
CLEAR_PED_TASKS_IMMEDIATELY(lamarPed)
|
|
ENDIF
|
|
IF NOT IS_PED_INJURED(chopPed)
|
|
SET_ENTITY_COORDS(chopPed, <<-73.93819, -1458.51807, 31.10075>>)
|
|
CLEAR_PED_TASKS_IMMEDIATELY(chopPed)
|
|
ENDIF
|
|
bLamarWalkPaused = TRUE
|
|
|
|
KILL_FACE_TO_FACE_CONVERSATION_DO_NOT_FINISH_LAST_LINE()
|
|
bDoneBanter = TRUE
|
|
ELSE
|
|
IF IS_VEHICLE_DRIVEABLE(hoodVehicle[HV_FRANKLIN_VAN])
|
|
IF NOT IS_PED_IN_VEHICLE(PLAYER_PED_ID(), hoodVehicle[HV_FRANKLIN_VAN])
|
|
SET_VEHICLE_IS_CONSIDERED_BY_PLAYER(hoodVehicle[HV_FRANKLIN_VAN], TRUE)
|
|
SET_PED_INTO_VEHICLE(PLAYER_PED_ID(), hoodVehicle[HV_FRANKLIN_VAN])
|
|
SET_PED_INTO_VEHICLE(lamarPed, hoodVehicle[HV_FRANKLIN_VAN], VS_FRONT_RIGHT)
|
|
SET_CHOP_INTO_VAN(chopPed, hoodVehicle[HV_FRANKLIN_VAN], chopLeanInVanState, fCachedVanSpeed, FALSE, TRUE, TRUE)
|
|
SET_ENTITY_PROOFS(chopPed, FALSE, TRUE, TRUE, FALSE, FALSE, FALSE, FALSE, TRUE)
|
|
SET_PED_CAN_RAGDOLL(chopPed, FALSE)
|
|
TASK_CLEAR_LOOK_AT(lamarPed)
|
|
SET_ENTITY_NO_COLLISION_ENTITY(lamarPed, hoodVehicle[HV_FRANKLIN_VAN], TRUE)
|
|
bDoneFranklinIntoVanSpeech = TRUE
|
|
chopIntoVanState = CHOP_INTO_VAN_STATE_DONE
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ELSE
|
|
IF IS_VEHICLE_DRIVEABLE(hoodVehicle[HV_FRANKLIN_VAN])
|
|
IF NOT IS_PED_IN_VEHICLE(PLAYER_PED_ID(), hoodVehicle[HV_FRANKLIN_VAN])
|
|
SET_VEHICLE_IS_CONSIDERED_BY_PLAYER(hoodVehicle[HV_FRANKLIN_VAN], TRUE)
|
|
SET_PED_INTO_VEHICLE(PLAYER_PED_ID(), hoodVehicle[HV_FRANKLIN_VAN])
|
|
IF NOT IS_PED_INJURED(lamarPed)
|
|
IF NOT IS_PED_IN_VEHICLE(lamarPed, hoodVehicle[HV_FRANKLIN_VAN])
|
|
SET_PED_INTO_VEHICLE(lamarPed, hoodVehicle[HV_FRANKLIN_VAN], VS_FRONT_RIGHT)
|
|
ENDIF
|
|
ENDIF
|
|
SET_CHOP_INTO_VAN(chopPed, hoodVehicle[HV_FRANKLIN_VAN], chopLeanInVanState, fCachedVanSpeed)
|
|
SET_ENTITY_PROOFS(chopPed, FALSE, TRUE, TRUE, FALSE, FALSE, FALSE, FALSE, TRUE)
|
|
SET_PED_CAN_RAGDOLL(chopPed, FALSE)
|
|
bDoneLamarIntoVan = TRUE
|
|
ELSE
|
|
KILL_FACE_TO_FACE_CONVERSATION_DO_NOT_FINISH_LAST_LINE()
|
|
SET_ENTITY_COORDS(hoodVehicle[HV_FRANKLIN_VAN], GET_HOOD_VECTOR(HVEC_VAN_CHASE_INIT))
|
|
SET_ENTITY_HEADING(hoodVehicle[HV_FRANKLIN_VAN], VAN_CHASE_INIT_ROT)
|
|
SET_VEHICLE_ON_GROUND_PROPERLY(hoodVehicle[HV_FRANKLIN_VAN])
|
|
APPLY_FORCE_TO_ENTITY(hoodVehicle[HV_FRANKLIN_VAN], APPLY_TYPE_IMPULSE, <<0,0,-0.1>>, <<0,0,0>>, 0, TRUE, TRUE, TRUE)
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
BREAK
|
|
CASE STAGE_VAN_CHASE
|
|
/*
|
|
IF IS_VEHICLE_DRIVEABLE(hoodVehicle[HV_FRANKLIN_VAN])
|
|
SET_ENTITY_COORDS(hoodVehicle[HV_FRANKLIN_VAN], GET_HOOD_VECTOR(HVEC_VAN_IN_ALLEY))
|
|
SET_ENTITY_HEADING(hoodVehicle[HV_FRANKLIN_VAN], CAR_IN_ALLEY_ROT)
|
|
SET_VEHICLE_ON_GROUND_PROPERLY(hoodVehicle[HV_FRANKLIN_VAN])
|
|
|
|
IF NOT IS_PED_IN_VEHICLE(PLAYER_PED_ID(), hoodVehicle[HV_FRANKLIN_VAN])
|
|
SET_PED_INTO_VEHICLE(PLAYER_PED_ID(), hoodVehicle[HV_FRANKLIN_VAN], VS_DRIVER)
|
|
ENDIF
|
|
|
|
IF NOT IS_PED_INJURED(lamarPed)
|
|
IF NOT IS_PED_IN_VEHICLE(lamarPed, hoodVehicle[HV_FRANKLIN_VAN])
|
|
SET_PED_INTO_VEHICLE(lamarPed, hoodVehicle[HV_FRANKLIN_VAN], VS_FRONT_RIGHT)
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF IS_VEHICLE_DRIVEABLE(hoodVehicle[HV_BAD_GUY_BIKE])
|
|
IF IS_PLAYBACK_GOING_ON_FOR_VEHICLE(hoodVehicle[HV_BAD_GUY_BIKE])
|
|
SKIP_TO_END_AND_STOP_PLAYBACK_RECORDED_VEHICLE(hoodVehicle[HV_BAD_GUY_BIKE])
|
|
ENDIF
|
|
ENDIF
|
|
*/
|
|
DO_SCREEN_FADE_OUT(500)
|
|
WHILE NOT IS_SCREEN_FADED_OUT()
|
|
WAIT(0)
|
|
ENDWHILE
|
|
COMMON_MISSION_CLEAR()
|
|
SET_MISSION_STAGE(STAGE_FOOT_CHASE, TRUE)
|
|
|
|
DO_SCREEN_FADE_IN(500)
|
|
//bRunningCutscene = TRUE
|
|
BREAK
|
|
CASE STAGE_FOOT_CHASE
|
|
DO_SCREEN_FADE_OUT(500)
|
|
WHILE NOT IS_SCREEN_FADED_OUT()
|
|
WAIT(0)
|
|
ENDWHILE
|
|
|
|
COMMON_MISSION_CLEAR()
|
|
SET_MISSION_STAGE(STAGE_FIND_BAD_GUY, TRUE)
|
|
|
|
DO_SCREEN_FADE_IN(500)
|
|
BREAK
|
|
CASE STAGE_FIND_BAD_GUY
|
|
IF NOT bFoundBadGuy
|
|
IF chopBehaviourSetpieceStage = CBS_NOT_STARTED
|
|
IF NOT IS_PED_INJURED(chopPed)
|
|
SET_ENTITY_COORDS(chopPed, GET_HOOD_VECTOR(HVEC_CHOP_BEHAVIOUR_SETPIECE_LAUNCH))
|
|
SET_ENTITY_HEADING(chopPed, 147)
|
|
CLEAR_PED_TASKS_IMMEDIATELY(chopPed)
|
|
SET_ENTITY_COORDS(PLAYER_PED_ID(), <<537.10, -668.21, 23.76>>)
|
|
SET_ENTITY_HEADING(PLAYER_PED_ID(), 77.13)
|
|
ENDIF
|
|
KILL_ANY_CONVERSATION()
|
|
bShownGodText = TRUE
|
|
//bShownDebugBehaviourHelp = TRUE
|
|
bShownChopViewHelp = TRUE
|
|
bGotToTrain = TRUE
|
|
ELSE
|
|
IF NOT bOpeningBoxcarInProgress
|
|
IF NOT IS_PED_INJURED(chopPed)
|
|
DETACH_ENTITY(chopPed)
|
|
SET_ENTITY_COORDS(chopPed, <<528.49, -680.80, 23.80>>)
|
|
CLEAR_PED_TASKS_IMMEDIATELY(chopPed)
|
|
SET_ENTITY_COORDS(PLAYER_PED_ID(), <<529.02, -677.67, 23.80>>)
|
|
iChopWaypointProgress = 999
|
|
SET_CHOP_BEHAVIOUR_SETPIECE_STAGE(CBS_DONE)
|
|
bDebugForceOpenBoxcar = TRUE
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ELSE
|
|
IF NOT IS_PED_INJURED(runnerChaseProperties.ped)
|
|
CLEAR_PED_TASKS_IMMEDIATELY(runnerChaseProperties.ped)
|
|
SET_ENTITY_COORDS(runnerChaseProperties.ped, <<512.96, -623.70, 23.75>>)
|
|
SET_ENTITY_COORDS(PLAYER_PED_ID(), GET_ENTITY_COORDS(runnerChaseProperties.ped))
|
|
|
|
IF NOT IS_PED_INJURED(chopPed)
|
|
SET_ENTITY_COORDS(chopPed, GET_ENTITY_COORDS(runnerChaseProperties.ped))
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
BREAK
|
|
CASE STAGE_GET_TO_HOUSE
|
|
IF NOT bLamarOutOfVan
|
|
IF IS_VEHICLE_DRIVEABLE(hoodVehicle[HV_FRANKLIN_VAN])
|
|
IF NOT IS_PED_IN_VEHICLE(PLAYER_PED_ID(), hoodVehicle[HV_FRANKLIN_VAN])
|
|
SET_PED_INTO_VEHICLE(PLAYER_PED_ID(), hoodVehicle[HV_FRANKLIN_VAN])
|
|
ELSE
|
|
IF dropoffStage <= DROPOFF_STAGE_STOP_VAN
|
|
dropoffStage = DROPOFF_STAGE_STOP_VAN
|
|
iLetOutPromptTime = GET_GAME_TIMER()
|
|
KILL_ANY_CONVERSATION()
|
|
ELSE
|
|
KILL_FACE_TO_FACE_CONVERSATION_DO_NOT_FINISH_LAST_LINE()
|
|
SET_ENTITY_COORDS(hoodVehicle[HV_FRANKLIN_VAN], GET_HOOD_VECTOR(HVEC_REC))
|
|
SET_ENTITY_HEADING(hoodVehicle[HV_FRANKLIN_VAN], 73.92)
|
|
SET_VEHICLE_ON_GROUND_PROPERLY(hoodVehicle[HV_FRANKLIN_VAN])
|
|
//APPLY_FORCE_TO_ENTITY(hoodVehicle[HV_FRANKLIN_VAN], APPLY_TYPE_IMPULSE, <<0,0,-0.1>>, <<0,0,0>>, 0, TRUE, TRUE, TRUE)
|
|
dropoffStage = DROPOFF_STAGE_END
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
BREAK
|
|
ENDSWITCH
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
|
|
// previous stage P
|
|
IF IS_KEYBOARD_KEY_JUST_PRESSED(KEY_P)
|
|
IF NOT IS_PED_INJURED(PLAYER_PED_ID())
|
|
TRIGGER_MUSIC_EVENT("FRA0_MISSION_FAIL")
|
|
|
|
DO_SCREEN_FADE_OUT(500)
|
|
WHILE NOT IS_SCREEN_FADED_OUT()
|
|
WAIT(0)
|
|
ENDWHILE
|
|
|
|
COMMON_MISSION_CLEAR()
|
|
|
|
SWITCH currentMissionStage
|
|
CASE STAGE_GET_TO_BAD_GUY
|
|
POSITION_PLAYER_AT_MISSION_INIT()
|
|
WAIT(1000)
|
|
SET_MISSION_STAGE(STAGE_GET_TO_BAD_GUY, TRUE)
|
|
BREAK
|
|
CASE STAGE_VAN_CHASE
|
|
bModelRequestTracker[ENUM_TO_INT(HM_TRAFFIC_CAR1)] = FALSE
|
|
bModelRequestTracker[ENUM_TO_INT(HM_BUS)] = FALSE
|
|
POSITION_PLAYER_AT_MISSION_INIT()
|
|
WAIT(1000)
|
|
SET_MISSION_STAGE(STAGE_GET_TO_BAD_GUY, TRUE)
|
|
BREAK
|
|
CASE STAGE_FOOT_CHASE
|
|
bModelRequestTracker[ENUM_TO_INT(HM_TRAFFIC_CAR1)] = FALSE
|
|
bModelRequestTracker[ENUM_TO_INT(HM_BUS)] = FALSE
|
|
SET_MISSION_STAGE(STAGE_VAN_CHASE, TRUE)
|
|
BREAK
|
|
CASE STAGE_FIND_BAD_GUY
|
|
SET_MISSION_STAGE(STAGE_FOOT_CHASE, TRUE)
|
|
BREAK
|
|
CASE STAGE_GET_TO_HOUSE
|
|
SET_MISSION_STAGE(STAGE_FIND_BAD_GUY, TRUE)
|
|
BREAK
|
|
ENDSWITCH
|
|
|
|
DO_SCREEN_FADE_IN(500)
|
|
ENDIF
|
|
ENDIF
|
|
|
|
// stage menu
|
|
IF NOT IS_PED_INJURED(PLAYER_PED_ID())
|
|
IF LAUNCH_MISSION_STAGE_MENU(stageMenu, iMenuMissionStage)
|
|
TRIGGER_MUSIC_EVENT("FRA0_MISSION_FAIL")
|
|
COMMON_MISSION_CLEAR()
|
|
|
|
DO_SCREEN_FADE_OUT(500)
|
|
WHILE NOT IS_SCREEN_FADED_OUT()
|
|
WAIT(0)
|
|
ENDWHILE
|
|
|
|
// convert debug stage to mission stage
|
|
MISSION_STAGE_ENUM setStage
|
|
SWITCH iMenuMissionStage
|
|
CASE 1
|
|
setStage = STAGE_GET_TO_BAD_GUY
|
|
BREAK
|
|
CASE 4
|
|
setStage = STAGE_VAN_CHASE
|
|
BREAK
|
|
CASE 6
|
|
setStage = STAGE_FOOT_CHASE
|
|
BREAK
|
|
CASE 7
|
|
setStage = STAGE_FIND_BAD_GUY
|
|
BREAK
|
|
CASE 9
|
|
setStage = STAGE_GET_TO_HOUSE
|
|
BREAK
|
|
ENDSWITCH
|
|
|
|
IF currentMissionStage = STAGE_VAN_CHASE
|
|
OR currentMissionStage = STAGE_FOOT_CHASE
|
|
bModelRequestTracker[ENUM_TO_INT(HM_TRAFFIC_CAR1)] = FALSE
|
|
bModelRequestTracker[ENUM_TO_INT(HM_BUS)] = FALSE
|
|
ENDIF
|
|
|
|
IF setStage = STAGE_GET_TO_BAD_GUY
|
|
POSITION_PLAYER_AT_MISSION_INIT()
|
|
WAIT(1000)
|
|
ENDIF
|
|
|
|
SET_MISSION_STAGE(setStage, TRUE)
|
|
|
|
DO_SCREEN_FADE_IN(500)
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF IS_KEYBOARD_KEY_JUST_PRESSED(KEY_NUMPAD3)
|
|
SET_PED_CAN_BE_KNOCKED_OFF_VEHICLE(runnerChaseProperties.ped, KNOCKOFFVEHICLE_DEFAULT)
|
|
//SET_ENTITY_PROOFS(runnerChaseProperties.ped, FALSE, FALSE, FALSE, FALSE, FALSE)
|
|
//SET_ENTITY_ONLY_DAMAGED_BY_PLAYER(runnerChaseProperties.ped, FALSE)
|
|
KNOCK_PED_OFF_VEHICLE(runnerChaseProperties.ped)
|
|
ENDIF
|
|
|
|
//IF IS_KEYBOARD_KEY_JUST_PRESSED(KEY_NUMPAD4)
|
|
// SET_PED_TO_RAGDOLL(runnerChaseProperties.ped, 1000, 1000, TASK_RELAX, TRUE, TRUE, TRUE)
|
|
// printstring("ragdoll") printnl()
|
|
//ENDIF
|
|
|
|
IF IS_KEYBOARD_KEY_JUST_PRESSED(KEY_NUMPAD5)
|
|
PRINTSTRING("BB") PRINTNL()
|
|
OBJECT_INDEX thisCar = GET_CLOSEST_OBJECT_OF_TYPE(GET_ENTITY_COORDS(PLAYER_PED_ID()), 20.0, prop_rail_boxcar5)
|
|
IF DOES_ENTITY_EXIST(thisCar)
|
|
PRINTSTRING("exists") PRINTNL()
|
|
PLAY_ENTITY_ANIM(thisCar, "open_train_car_boxcar", GET_HOOD_ANIM_DICT_AS_STRING(H_ANIM_DICT_FIND), NORMAL_BLEND_IN, FALSE, TRUE)
|
|
ENDIF
|
|
ENDIF
|
|
|
|
// stage specific stuff
|
|
IF IS_KEYBOARD_KEY_JUST_PRESSED(KEY_NUMPAD4)
|
|
IF currentMissionStage = STAGE_FOOT_CHASE
|
|
SET_ENTITY_COORDS(PLAYER_PED_ID(), <<493.82770, -524.23358, 23.75095>>)
|
|
SET_ENTITY_HEADING(PLAYER_PED_ID(), -3.8)
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF IS_KEYBOARD_KEY_JUST_PRESSED(KEY_NUMPAD2)
|
|
IF currentMissionStage = STAGE_FOOT_CHASE
|
|
IF NOT bDebugDoneFootChaseSkip
|
|
/*
|
|
// after fence bust
|
|
IF NOT IS_PED_INJURED(PLAYER_PED_ID())
|
|
SET_ENTITY_COORDS(PLAYER_PED_ID(), <<489.29, -514.77, 23.76>>)
|
|
SET_ENTITY_HEADING(PLAYER_PED_ID(), -66.16)
|
|
SET_GAMEPLAY_CAM_RELATIVE_HEADING()
|
|
ENDIF
|
|
|
|
IF NOT IS_PED_INJURED(runnerChaseProperties.ped)
|
|
SET_ENTITY_COORDS(runnerChaseProperties.ped, <<493.81, -514.50, 23.76>>)
|
|
SET_ENTITY_HEADING(runnerChaseProperties.ped, -15.69)
|
|
runnerStage = RUNNER_TO_FENCE
|
|
HANDLE_TRANSITION_BACK_TO_CHASE_MOVING(runnerChaseProperties, TRUE)
|
|
ENDIF
|
|
bDoneOffRoofCut = TRUE
|
|
bDoneThroughFenceCut = TRUE
|
|
*/
|
|
|
|
|
|
// after boxcar
|
|
IF NOT IS_PED_INJURED(PLAYER_PED_ID())
|
|
SET_ENTITY_COORDS(PLAYER_PED_ID(), <<567.74, -498.82, 23.76>>)
|
|
SET_ENTITY_HEADING(PLAYER_PED_ID(), 162.28)
|
|
SET_GAMEPLAY_CAM_RELATIVE_HEADING()
|
|
ENDIF
|
|
|
|
IF NOT IS_PED_INJURED(runnerChaseProperties.ped)
|
|
SET_ENTITY_COORDS(runnerChaseProperties.ped, <<566.12, -505.28, 23.76>>)
|
|
SET_ENTITY_HEADING(runnerChaseProperties.ped, 176.73)
|
|
runnerStage = RUNNER_TO_BOXCAR
|
|
HANDLE_TRANSITION_BACK_TO_CHASE_MOVING(runnerChaseProperties)
|
|
ENDIF
|
|
//bDoneOffRoofCut = TRUE
|
|
bDoneThroughFenceCut = TRUE
|
|
|
|
//bRunningCutscene = TRUE
|
|
iCurrentFootChaseCutscene = 2
|
|
|
|
/*
|
|
// last cut
|
|
IF DOES_ENTITY_EXIST(containerObject)
|
|
DETACH_ENTITY(containerObject)
|
|
SET_ENTITY_COORDS(containerObject, << 516.291, -625.819, 23.775 >>)
|
|
SET_ENTITY_ROTATION(containerObject, << 0.148364, 0.0395208, 173.176 >>)
|
|
FREEZE_ENTITY_POSITION(containerObject, TRUE)
|
|
ENDIF
|
|
|
|
IF NOT IS_PED_INJURED(PLAYER_PED_ID())
|
|
SET_ENTITY_COORDS(PLAYER_PED_ID(), <<517.10, -615.99, 23.76>>)
|
|
SET_ENTITY_HEADING(PLAYER_PED_ID(), 172.39)
|
|
SET_GAMEPLAY_CAM_RELATIVE_HEADING()
|
|
ENDIF
|
|
|
|
craneSetpieceState = CRANE_SETPIECE_DONE
|
|
runnerStage = RUNNER_DONE
|
|
bDoneOffRoofCut = TRUE
|
|
bDoneThroughFenceCut = TRUE
|
|
bDoneOnTrainCut = TRUE
|
|
*/
|
|
|
|
bDebugDoneFootChaseSkip = TRUE
|
|
ENDIF
|
|
ELIF currentMissionStage = STAGE_GET_TO_HOUSE
|
|
dropoffStage = DROPOFF_STAGE_STOP_VAN
|
|
iLetOutPromptTime = GET_GAME_TIMER()
|
|
KILL_ANY_CONVERSATION()
|
|
ENDIF
|
|
ENDIF
|
|
ENDPROC
|
|
|
|
// there must be an easier way to do this
|
|
PROC FORMAT_FLOAT_FOR_RB_CAM_DUMP(FLOAT fInputFloat, INT &iBeforeDec, INT &iAfterDec)
|
|
IF fInputFloat >= 0
|
|
iBeforeDec = FLOOR(fInputFloat)
|
|
ELSE
|
|
iBeforeDec = CEIL(fInputFloat)
|
|
ENDIF
|
|
|
|
fInputFloat -= iBeforeDec
|
|
fInputFloat *= 100
|
|
IF fInputFloat < 0
|
|
fInputFloat *= (-1)
|
|
ENDIF
|
|
IF fInputFloat < 10
|
|
fInputFloat *= 10
|
|
ENDIF
|
|
|
|
iAfterDec = FLOOR(fInputFloat)
|
|
ENDPROC
|
|
|
|
// dump the cam coords to a widget
|
|
PROC DO_RB_DEBUG_CAM_DUMP()
|
|
IF bRBDebugCamDoDump
|
|
CAMERA_INDEX tempCam = GET_DEBUG_CAM()
|
|
|
|
vRBDebugCamPos = GET_CAM_COORD(tempCam)
|
|
vRBDebugCamRot = GET_CAM_ROT(tempCam)
|
|
fRBDebugCamFOV = GET_CAM_FOV(tempCam)
|
|
|
|
TEXT_LABEL_63 tPos
|
|
TEXT_LABEL_63 tRot
|
|
INT iBefore, iAfter
|
|
|
|
// fill position
|
|
tPos = "<<"
|
|
FORMAT_FLOAT_FOR_RB_CAM_DUMP(vRBDebugCamPos.x, iBefore, iAfter)
|
|
tPos += iBefore
|
|
tPos += "."
|
|
tPos += iAfter
|
|
tPos += ", "
|
|
FORMAT_FLOAT_FOR_RB_CAM_DUMP(vRBDebugCamPos.y, iBefore, iAfter)
|
|
tPos += iBefore
|
|
tPos += "."
|
|
tPos += iAfter
|
|
tPos += ", "
|
|
FORMAT_FLOAT_FOR_RB_CAM_DUMP(vRBDebugCamPos.z, iBefore, iAfter)
|
|
tPos += iBefore
|
|
tPos += "."
|
|
tPos += iAfter
|
|
tPos += ">>"
|
|
|
|
// fill rotation
|
|
tRot = "<<"
|
|
FORMAT_FLOAT_FOR_RB_CAM_DUMP(vRBDebugCamRot.x, iBefore, iAfter)
|
|
tRot += iBefore
|
|
tRot += "."
|
|
tRot += iAfter
|
|
tRot += ", "
|
|
FORMAT_FLOAT_FOR_RB_CAM_DUMP(vRBDebugCamRot.y, iBefore, iAfter)
|
|
tRot += iBefore
|
|
tRot += "."
|
|
tRot += iAfter
|
|
tRot += ", "
|
|
FORMAT_FLOAT_FOR_RB_CAM_DUMP(vRBDebugCamRot.z, iBefore, iAfter)
|
|
tRot += iBefore
|
|
tRot += "."
|
|
tRot += iAfter
|
|
tRot += ">>"
|
|
|
|
// set widgets
|
|
SET_CONTENTS_OF_TEXT_WIDGET(RBCamPosWidget, tPos)
|
|
SET_CONTENTS_OF_TEXT_WIDGET(RBCamRotWidget, tRot)
|
|
|
|
bRBDebugCamDoDump = FALSE
|
|
ENDIF
|
|
ENDPROC
|
|
#ENDIF
|
|
|
|
//INT iSoundTest
|
|
// main script
|
|
SCRIPT
|
|
SET_MISSION_FLAG(TRUE)
|
|
IF HAS_FORCE_CLEANUP_OCCURRED()
|
|
Mission_Flow_Mission_Force_Cleanup()
|
|
MISSION_CLEANUP()
|
|
ENDIF
|
|
|
|
#IF IS_DEBUG_BUILD
|
|
CREATE_HOOD_WIDGETS()
|
|
SETUP_HOOD_DEBUG_MENU()
|
|
IF bDrawVehicleRecordingDebug
|
|
SET_DEBUG_LINES_AND_SPHERES_DRAWING_ACTIVE(TRUE)
|
|
ENDIF
|
|
#ENDIF
|
|
|
|
#IF IS_DEBUG_BUILD
|
|
// TRACE_NATIVE_COMMAND("SET_ALL_VEHICLE_GENERATORS_ACTIVE_IN_AREA")
|
|
TRACE_NATIVE_COMMAND("SET_WANTED_LEVEL_MULTIPLIER")
|
|
#ENDIF
|
|
|
|
bSkippedCutscene = bSkippedCutscene
|
|
|
|
WHILE TRUE
|
|
REPLAY_CHECK_FOR_EVENT_THIS_FRAME("M_Chop")
|
|
|
|
#IF IS_DEBUG_BUILD
|
|
IF NOT bDebugDoUber
|
|
#ENDIF
|
|
|
|
IF INIT_MISSION()
|
|
// PRINTSTRING("line = ") PRINTINT(GET_CURRENT_SCRIPTED_CONVERSATION_LINE()) PRINTNL()
|
|
// printstring("runner = ") printint(runnerChaseProperties.iSyncScene) PRINTNL()
|
|
// printstring("chop = ") PRINTVECTOR(GET_ENTITY_COORDS(chopPed)) PRINTNL()
|
|
|
|
//printvector(get_entity_coords(hoodVehicle[hv_bad_guy_bike])) printnl()
|
|
//printvector(get_entity_rotation(hoodVehicle[hv_bad_guy_bike])) printnl()
|
|
|
|
|
|
|
|
//IF IS_KEYBOARD_KEY_JUST_PRESSED(KEY_NUMPAD1)
|
|
// bRunningCutscene = TRUE
|
|
//ENDIF
|
|
|
|
/*
|
|
IF IS_KEYBOARD_KEY_JUST_PRESSED(KEY_NUMPAD2)
|
|
TASK_PLAY_ANIM(chopPed, GET_HOOD_ANIM_DICT_AS_STRING(H_ANIM_DICT_MISSION), "FRA_0_IG_1_CHOP_GROWL", NORMAL_BLEND_IN, NORMAL_BLEND_OUT, -1, AF_LOOPING)
|
|
ENDIF
|
|
IF IS_KEYBOARD_KEY_JUST_PRESSED(KEY_NUMPAD3)
|
|
TASK_PLAY_ANIM(chopPed, GET_HOOD_ANIM_DICT_AS_STRING(H_ANIM_DICT_MISSION), "FRA_0_IG_1_CHOP_GROWL_TO_SIT", NORMAL_BLEND_IN, NORMAL_BLEND_OUT, -1, AF_LOOPING)
|
|
ENDIF
|
|
*/
|
|
|
|
IF NOT IS_PED_INJURED(PLAYER_PED_ID())
|
|
// do streaming for next stage
|
|
DO_STREAMING_FOR_NEXT_MISSION_STAGE(FALSE)
|
|
|
|
//SET_PED_CAN_PLAY_GESTURE_ANIMS(PLAYER_PED_ID(), FALSE)
|
|
// do fail checks
|
|
HANDLE_MISSION_FAIL_STATE()
|
|
|
|
// head tracking
|
|
HANDLE_BUDDY_HEAD_TRACK_WHILE_ENTERING_VEHICLE()
|
|
|
|
// handle mix group
|
|
IF NOT IS_PED_INJURED(chopPed)
|
|
IF chopViewCamData.state <> CHOP_VIEW_CAM_ON_CHOP
|
|
IF NOT bAddedChopToMixGroup
|
|
ADD_ENTITY_TO_AUDIO_MIX_GROUP(chopPed, "FRANKLIN_0_CHOP_Group")
|
|
bAddedChopToMixGroup = TRUE
|
|
ENDIF
|
|
ELSE
|
|
IF bAddedChopToMixGroup
|
|
REMOVE_ENTITY_FROM_AUDIO_MIX_GROUP(chopPed)
|
|
bAddedChopToMixGroup = FALSE
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
|
|
// run appropriate stage
|
|
SWITCH currentMissionStage
|
|
CASE STAGE_GET_TO_BAD_GUY
|
|
DO_STAGE_GET_TO_BAD_GUY()
|
|
BREAK
|
|
CASE STAGE_VAN_CHASE
|
|
DO_STAGE_VAN_CHASE()
|
|
BREAK
|
|
CASE STAGE_FOOT_CHASE
|
|
DO_STAGE_FOOT_CHASE()
|
|
BREAK
|
|
CASE STAGE_FIND_BAD_GUY
|
|
DO_STAGE_FIND_BAD_GUY()
|
|
BREAK
|
|
CASE STAGE_GET_TO_HOUSE
|
|
DO_STAGE_GET_TO_HOUSE()
|
|
BREAK
|
|
ENDSWITCH
|
|
ENDIF
|
|
|
|
#IF IS_DEBUG_BUILD
|
|
INT i
|
|
TEXT_LABEL tLabel
|
|
|
|
IF bDrawVehicleRecordingDebug
|
|
REPEAT COUNT_OF(TrafficCarID) i
|
|
IF IS_VEHICLE_DRIVEABLE(TrafficCarID[i])
|
|
tLabel = "CAR "
|
|
tLabel += i
|
|
DRAW_DEBUG_TEXT(tLabel, GET_ENTITY_COORDS(TrafficCarID[i]) + <<0,0,1.5>>)
|
|
ENDIF
|
|
ENDREPEAT
|
|
ENDIF
|
|
|
|
IF CAN_ADVANCE_MISSION()
|
|
DO_DEBUG_SKIPS()
|
|
ENDIF
|
|
DO_RB_DEBUG_CAM_DUMP()
|
|
#ENDIF
|
|
ELSE
|
|
IF CAN_REQUEST_ASSETS_FOR_CUTSCENE_ENTITY()
|
|
PRINTSTRING("requested lamar assets from mission script!") PRINTNL()
|
|
SET_CUTSCENE_PED_COMPONENT_VARIATION("Lamar", PED_COMP_HEAD, 0, 0)
|
|
SET_CUTSCENE_PED_COMPONENT_VARIATION("Lamar", PED_COMP_BERD, 1, 0)
|
|
SET_CUTSCENE_PED_COMPONENT_VARIATION("Lamar", PED_COMP_HAIR, 2, 0)
|
|
SET_CUTSCENE_PED_COMPONENT_VARIATION("Lamar", PED_COMP_TORSO, 2, 1)
|
|
SET_CUTSCENE_PED_COMPONENT_VARIATION("Lamar", PED_COMP_LEG, 4, 0)
|
|
SET_CUTSCENE_PED_COMPONENT_VARIATION("Lamar", PED_COMP_HAND, 0, 0)
|
|
SET_CUTSCENE_PED_COMPONENT_VARIATION("Lamar", PED_COMP_SPECIAL, 0, 0)
|
|
SET_CUTSCENE_PED_COMPONENT_VARIATION("Lamar", PED_COMP_SPECIAL2, 0, 0)
|
|
SET_CUTSCENE_PED_COMPONENT_VARIATION("Lamar", PED_COMP_FEET, 1, 0)
|
|
|
|
SET_CHOP_COLLAR()
|
|
SET_CUTSCENE_PED_COMPONENT_VARIATION("Chop", PED_COMP_TORSO, 0, iCurrentChopCollar)
|
|
ENDIF
|
|
ENDIF
|
|
|
|
#IF IS_DEBUG_BUILD
|
|
ELSE
|
|
UPDATE_UBER_RECORDING()
|
|
ENDIF
|
|
#ENDIF
|
|
|
|
WAIT(0)
|
|
ENDWHILE
|
|
ENDSCRIPT
|