26028 lines
899 KiB
Python
Executable File
26028 lines
899 KiB
Python
Executable File
//+-----------------------------------------------------------------------------+
|
|
//¦ Author: Ben Rollinson and Rob Bray Date: 06/04/10 ¦
|
|
//¦-----------------------------------------------------------------------------¦
|
|
//¦ ¦
|
|
//¦ ¦
|
|
//¦ FBI 2 - Snatch and Grab ¦
|
|
//¦ ¦
|
|
//¦ ¦
|
|
//+-----------------------------------------------------------------------------+
|
|
|
|
//Compile out Title Update changes to header functions.
|
|
//Must be before includes.
|
|
//CONST_INT USE_TU_CHANGES 0 // Removed by Kenneth R.
|
|
|
|
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 "commands_cutscene.sch"
|
|
USING "selector_public.sch"
|
|
USING "dialogue_public.sch"
|
|
USING "cellphone_public.sch"
|
|
USING "flow_public_core_override.sch"
|
|
USING "rappel_public.sch"
|
|
USING "script_ped.sch"
|
|
USING "script_blips.sch"
|
|
USING "script_buttons.sch"
|
|
USING "select_mission_stage.sch"
|
|
USING "replay_public.sch"
|
|
USING "cutscene_public.sch"
|
|
USING "player_ped_public.sch"
|
|
USING "mission_stat_public.sch"
|
|
USING "clearMissionArea.sch"
|
|
USING "CompletionPercentage_public.sch"
|
|
USING "locates_public.sch"
|
|
USING "timelapse.sch"
|
|
USING "commands_shapetest.sch"
|
|
USING "building_control_public.sch"
|
|
USING "chase_hint_cam.sch"
|
|
USING "cheat_controller_public.sch"
|
|
USING "spline_cam_edit.sch"
|
|
USING "commands_recording.sch"
|
|
USING "push_in_public.sch"
|
|
|
|
// REMOVE TEMP WEATHER CALLS
|
|
// REMOVE SKY SCENARIO BLOCKING
|
|
// NEED TO DO SOMETHING ABOUT IF THE PLAYER DIES HOLDING THE ADVANCED RIFLE, HE WILL PROB HAVE IT ON RETURN
|
|
|
|
// 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_FOOD_COURT = 0,
|
|
STAGE_GET_TO_CHOPPER,
|
|
STAGE_GET_TO_BUILDING,
|
|
STAGE_RAPPEL_DOWN,
|
|
STAGE_SNIPE_GUARDS,
|
|
STAGE_CHOPPER_CHASE,
|
|
STAGE_DROPOFF
|
|
ENDENUM
|
|
|
|
ENUM MISSION_FAIL_STATE_ENUM
|
|
MISSION_FAIL_STATE_NOT_FAILED = 0,
|
|
MISSION_FAIL_STATE_WAIT_FOR_FADE
|
|
ENDENUM
|
|
|
|
ENUM FAIL_REASON_ENUM
|
|
FAIL_FRANKLIN_DEAD = 0,
|
|
FAIL_MICHAEL_DEAD,
|
|
FAIL_TREVOR_DEAD,
|
|
FAIL_DAVE_DEAD,
|
|
FAIL_ABANDONED_DAVE,
|
|
FAIL_PRISONER_DEAD,
|
|
FAIL_CHOPPER_DESTROYED,
|
|
FAIL_CAR_DESTROYED,
|
|
FAIL_ABANDONED_CAR,
|
|
FAIL_ABANDONED_CHOPPER,
|
|
FAIL_TREVOR_ABANDONED_CHOPPER,
|
|
FAIL_ATTACKED_FBI,
|
|
FAIL_FELL_FROM_ROPE,
|
|
FAIL_ROPE_CUT,
|
|
FAIL_SEEN,
|
|
FAIL_ATTRACTED_COPS,
|
|
FAIL_CAR_STUCK,
|
|
FAIL_CHOPPER_STUCK,
|
|
FAIL_CAUSED_TROUBLE,
|
|
FAIL_UNCOUPLED_ROPE,
|
|
FAIL_DROWNED,
|
|
FAIL_STEVE_DEAD,
|
|
FAIL_ANDREAS_DEAD,
|
|
FAIL_TROUBLE_FOOD_COURT
|
|
ENDENUM
|
|
|
|
ENUM MISSION_HOTSWAP_STAGE_ENUM
|
|
MISSION_HOTSWAP_STAGE_SELECT_CHARACTER = 0,
|
|
MISSION_HOTSWAP_STAGE_DO_SPLINE_CAM,
|
|
MISSION_HOTSWAP_STAGE_DONE
|
|
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 SNATCH_AND_GRAB_MODEL_ENUM
|
|
SAGM_MICHAEL = 0,
|
|
SAGM_FRANKLIN,
|
|
SAGM_TREVOR,
|
|
SAGM_DAVE,
|
|
SAGM_STEVE,
|
|
SAGM_ANDREAS,
|
|
SAGM_PRISONER_HIGH,
|
|
SAGM_PRISONER_LOW,
|
|
SAGM_PILOT,
|
|
SAGM_GUARD,
|
|
SAGM_MICHELLE,
|
|
SAGM_FBI,
|
|
SAGM_FBIEND,
|
|
SAGM_CHOPPER,
|
|
SAGM_ENEMY_CHOPPER,
|
|
SAGM_MICHAEL_CAR,
|
|
// SAGM_TREVOR_JEEP,
|
|
SAGM_FRANKLIN_BIKE,
|
|
SAGM_FBI_VAN,
|
|
SAGM_FBI_CAR,
|
|
SAGM_UTIL_TRUCK_1,
|
|
SAGM_UTIL_TRUCK_2,
|
|
SAGM_DRIVE_AWAY_CAR,
|
|
//SAGM_HOOK,
|
|
//SAGM_BLOCK,
|
|
SAGM_HARNESS,
|
|
SAGM_PULLEY,
|
|
SAGM_TORCH,
|
|
SAGM_CHAIR,
|
|
SAGM_COFFEE
|
|
ENDENUM
|
|
|
|
ENUM SNATCH_AND_GRAB_VECTOR_ENUM
|
|
SAGVEC_PLAYER_INIT = 0,
|
|
SAGVEC_PLAYER_INIT2,
|
|
SAGVEC_DAVE_INIT,
|
|
SAGVEC_DAVE_INIT2,
|
|
SAGVEC_MICHAEL_CAR_INIT,
|
|
SAGVEC_CHOPPER_INIT,
|
|
SAGVEC_PICKUP_CHOPPER_LEADIN,
|
|
SAGVEC_CHOPPER_HOVER,
|
|
SAGVEC_HOVER_TARGET,
|
|
SAGVEC_TREVOR_INIT,
|
|
SAGVEC_FRANKLIN_INIT,
|
|
SAGVEC_FRANKLIN_SNIPER,
|
|
SAGVEC_BIKE_INIT,
|
|
SAGVEC_JEEP_INIT,
|
|
SAGVEC_ROPE_ANCHOR_OFFSET,
|
|
SAGVEC_ROPE_ANCHOR_ROT,
|
|
SAGVEC_ROPE_HARNESS_OFFSET,
|
|
SAGVEC_ROPE_WEIGHT_OFFSET,
|
|
SAGVEC_ROPE_PLAYER_SWING_ATTACH,
|
|
SAGVEC_ROPE_PRISONER_SWING_ATTACH,
|
|
SAGVEC_MEETING_POINT,
|
|
SAGVEC_WINDOW_FRAME,
|
|
SAGVEC_WINDOW_FRAME_2,
|
|
SAGVEC_WINDOW_SWING_RIGHT,
|
|
SAGVEC_WINDOW_SWING_LEFT,
|
|
SAGVEC_WINDOW_SOUND,
|
|
SAGVEC_BREAK_IN,
|
|
SAGVEC_PRISONER_INIT,
|
|
SAGVEC_MICHELLE_INIT,
|
|
SAGVEC_INTERROGATION,
|
|
SAGVEC_HEADSHOT,
|
|
SAGVEC_GUARD_DOOR_INSIDE,
|
|
SAGVEC_GUARD_DOOR_OUTSIDE,
|
|
SAGVEC_GUARD_ANIM_ORIGIN,
|
|
SAGVEC_SNIPER,
|
|
SAGVEC_REMOTE_VIEW,
|
|
SAGVEC_BEHIND_SNIPER,
|
|
SAGVEC_SNIPER_AI_SHOT_ORIGIN,
|
|
SAGVEC_CHASE_END,
|
|
SAGVEC_DROPOFF,
|
|
SAGVEC_DROPOFF_DIMENSIONS,
|
|
SAGVEC_DROPOFF_PASS_DIMENSIONS,
|
|
SAGVEC_END,
|
|
SAGVEC_MICHAEL_AT_FOOD_COURT,
|
|
SAGVEC_MOVE_LAST_PLAYER_VEHICLE
|
|
ENDENUM
|
|
|
|
ENUM SNATCH_AND_GRAB_VEHICLE_ENUM
|
|
SAGV_PLAYER_CHOPPER = 0,
|
|
//SAGV_TREVOR_JEEP,
|
|
SAGV_MICHAEL_CAR,
|
|
SAGV_FRANKLIN_BIKE
|
|
ENDENUM
|
|
|
|
ENUM SNATCH_AND_GRAB_SHOT_DETAILS_ENUM
|
|
SAG_SHOT_ARRIVE = 0,
|
|
SAG_SHOT_ARRIVEB,
|
|
SAG_SHOT_ARRIVE2,
|
|
SAG_SHOT_ARRIVE2B,
|
|
SAG_SHOT_ARRIVE3,
|
|
SAG_SHOT_ARRIVE3B,
|
|
SAG_SHOT_INSIDE,
|
|
SAG_SHOT_SMASH_IN,
|
|
SAG_SHOT_WAIT_FOR_SWITCH,
|
|
SAG_SHOT_WAIT_FOR_SWITCHB,
|
|
SAG_SHOT_WINCHING,
|
|
SAG_SHOT_WINCHINGB,
|
|
SAG_SHOT_FIB1,
|
|
SAG_SHOT_FIB1B,
|
|
SAG_SHOT_FIB2,
|
|
SAG_SHOT_FIB2B
|
|
ENDENUM
|
|
|
|
ENUM SNATCH_AND_GRAB_ANIM_DICT_ENUM
|
|
SAG_ANIM_DICT_MISSION = 0,
|
|
SAG_ANIM_DICT_RAPPEL,
|
|
SAG_ANIM_DICT_GUARDS,
|
|
SAG_ANIM_DICT_CUTSCENES,
|
|
SAG_ANIM_DICT_INTRO,
|
|
SAG_ANIM_DICT_TOWER_SEATED,
|
|
SAG_ANIM_DICT_TOWER_SEATED_REACT,
|
|
SAG_ANIM_DICT_TOWER_STANDING,
|
|
SAG_ANIM_DICT_TOWER_STANDING_REACT_ENTER_L,
|
|
SAG_ANIM_DICT_TOWER_STANDING_REACT_ENTER_R,
|
|
SAG_ANIM_DICT_TOWER_STANDING_REACT_IDLE,
|
|
SAG_ANIM_DICT_AIM_VARIATIONS,
|
|
SAG_ANIM_DICT_COMBAT_GLANCES,
|
|
SAG_ANIM_DICT_OVER_THERE,
|
|
SAG_ANIM_DICT_PANIC,
|
|
SAG_ANIM_DICT_BECKON,
|
|
SAG_ANIM_DICT_FOOD_COURT,
|
|
SAG_ANIM_DICT_AT_LOT,
|
|
SAG_ANIM_DICT_IN_OFFICE,
|
|
SAG_ANIM_DICT_FLY_HOME,
|
|
SAG_ANIM_CAM_SHAKE_LIBRARY,
|
|
SAG_ANIM_DICT_SNIPER
|
|
ENDENUM
|
|
|
|
ENUM SNATCH_AND_GRAB_WEAPON_ENUM
|
|
SAG_WEAPON_MICHAEL_PISTOL = 0,
|
|
SAG_WEAPON_CIA_PISTOL,
|
|
SAG_WEAPON_CIA_SMG,
|
|
SAG_WEAPON_CIA_HELI,
|
|
SAG_WEAPON_SNIPER_RIFLE,
|
|
SAG_WEAPON_MICHAEL_RIFLE
|
|
ENDENUM
|
|
|
|
ENUM SNATCH_AND_GRAB_PTFX_ENUM
|
|
SAG_PTFX_PLACEHOLDER = 0
|
|
ENDENUM
|
|
|
|
ENUM SNATCH_AND_GRAB_SFX_ENUM
|
|
SAG_SFX_MISSION = 0,
|
|
SAG_SFX_HELIS
|
|
//SAG_SFX_RAPPEL
|
|
ENDENUM
|
|
|
|
ENUM SNATCH_AND_GRAB_MISC_ASSET_ENUM
|
|
SAG_MISC_ASSET_CAR_ANIMS = 0,
|
|
SAG_MISC_ASSET_CHOPPER_ANIMS,
|
|
SAG_MISC_ASSET_HELI_DRIVEBY_ANIMS,
|
|
SAG_MISC_ASSET_DAVE_WALK
|
|
//SAG_MISC_ASSET_FOOD_COURT_ANIMS
|
|
ENDENUM
|
|
|
|
ENUM SNATCH_AND_GRAB_CUTSCENE_STAGE_ENUM
|
|
SAG_CUT_STAGE_INIT = 0,
|
|
SAG_CUT_STAGE_RUNNING,
|
|
SAG_CUT_STAGE_CLEANUP
|
|
ENDENUM
|
|
|
|
/*
|
|
ENUM MEETING_SHOT_ENUM
|
|
MEETING_ARRIVE = 0,
|
|
MEETING_FADED,
|
|
MEETING_DRESSED
|
|
ENDENUM
|
|
*/
|
|
|
|
ENUM START_RAPPEL_SHOT_ENUM
|
|
START_RAPPEL_ARRIVE = 0,
|
|
START_RAPPEL_JUMP
|
|
ENDENUM
|
|
|
|
ENUM SMASH_THROUGH_SHOT_ENUM
|
|
SMASH_THROUGH_MOCAP = 0,
|
|
SMASH_THROUGH_WAIT_FOR_SWITCH,
|
|
SMASH_THROUGH_PAN
|
|
//SMASH_THROUGH_MOCAP_2
|
|
ENDENUM
|
|
|
|
ENUM DROPOFF_SHOT_ENUM
|
|
DROPOFF_ESTABLISH = 0,
|
|
DROPOFF_HANDOVER,
|
|
DROPOFF_DRIVE
|
|
ENDENUM
|
|
|
|
ENUM ROPE_TYPE_ENUM
|
|
ROPE_TYPE_FURLED = 0,
|
|
ROPE_TYPE_CUTSCENE,
|
|
ROPE_TYPE_RAPPELLING,
|
|
ROPE_TYPE_INSIDE,
|
|
ROPE_TYPE_SWINGING,
|
|
ROPE_TYPE_DROPOFF
|
|
ENDENUM
|
|
|
|
ENUM FBI_AI_STAGE_ENUM
|
|
FBI_AI_WATCH_ARRIVE = 0,
|
|
FBI_AI_ENTER_CAR,
|
|
FBI_AI_FOLLOW_RECORDING,
|
|
FBI_AI_CLEANUP,
|
|
FBI_AI_DONT_EXIST
|
|
ENDENUM
|
|
|
|
ENUM FRANKLIN_AI_STAGE_ENUM
|
|
FRANKLIN_AI_WATCH_ARRIVE = 0,
|
|
FRANKLIN_AI_MOUNT_BIKE,
|
|
FRANKLIN_AI_FOLLOW_RECORDING,
|
|
FRANKLIN_AI_CLEANUP,
|
|
FRANKLIN_AI_DONT_EXIST
|
|
ENDENUM
|
|
|
|
ENUM EXTRACT_STAGE_ENUM
|
|
EXTRACT_STAGE_KILL_INITIAL_GUARDS = 0,
|
|
EXTRACT_STAGE_REINFORCEMENTS_ENTER,
|
|
EXTRACT_STAGE_DO_ANIMATION,
|
|
EXTRACT_STAGE_KILL_REINFORCEMENTS
|
|
ENDENUM
|
|
|
|
ENUM HANGING_HOTSWAP_STATE_ENUM
|
|
HANGING_HOTSWAP_ON_TREVOR = 0,
|
|
HANGING_HOTSWAP_ON_MICHAEL,
|
|
HANGING_HOTSWAP_ON_FRANKLIN,
|
|
HANGING_HOTSWAP_MICHAEL_TO_TREVOR,
|
|
HANGING_HOTSWAP_FRANKLIN_TO_TREVOR,
|
|
HANGING_HOTSWAP_FRANKLIN_TO_MICHAEL,
|
|
HANGING_HOTSWAP_TREVOR_TO_MICHAEL,
|
|
HANGING_HOTSWAP_MICHAEL_TO_FRANKLIN,
|
|
HANGING_HOTSWAP_TREVOR_TO_FRANKLIN
|
|
ENDENUM
|
|
|
|
ENUM GUARD_SYNCED_SCENE_ENUM
|
|
GSS_STANDARD = 0,
|
|
GSS_LAST_GUARD,
|
|
//GSS_REIN_ADJUSTED,
|
|
GSS_REIN_FIRST_EXTRA,
|
|
GSS_REIN_SECOND_EXTRA,
|
|
GSS_REIN_THIRD_EXTRA,
|
|
GSS_REIN_FOURTH_EXTRA
|
|
ENDENUM
|
|
|
|
ENUM GUARD_SITUATION_REACT_ENUM
|
|
GS_REACT_NONE = 0,
|
|
GS_REACT_BULLET_NEAR,
|
|
GS_REACT_FIRST_SHOT
|
|
ENDENUM
|
|
|
|
ENUM GUARD_ACTION_ENUM
|
|
GA_AIM_AT_MICHAEL = 0,
|
|
GA_AIM_AT_SNIPER,
|
|
GA_FIRE_ON_SNIPER
|
|
ENDENUM
|
|
|
|
ENUM PRISONER_GRAB_STATE_ENUM
|
|
PRISONER_GRAB_STATE_INIT = 0,
|
|
PRISONER_GRAB_STATE_DUCK_INTRO,
|
|
PRISONER_GRAB_STATE_DUCK_LOOPING,
|
|
//PRISONER_GRAB_STATE_DUCK_OUTRO,
|
|
PRISONER_GRAB_STATE_EXTRACT,
|
|
PRISONER_GRAB_STATE_DANGLING,
|
|
PRISONER_GRAB_STATE_WINCHING
|
|
ENDENUM
|
|
|
|
ENUM HOTSWAP_CAM_ENUM
|
|
HOTSWAP_CAM_DEFAULT = 0,
|
|
HOTSWAP_CAM_INSIDE_CHOPPER,
|
|
HOTSWAP_CAM_OUTSIDE_CHOPPER,
|
|
HOTSWAP_CAM_CHOPPER_TO_FRANKLIN,
|
|
HOTSWAP_CAM_FRANKLIN_TO_CHOPPER,
|
|
HOTSWAP_CAM_HANGING_TO_SNIPER,
|
|
HOTSWAP_CAM_SNIPER_TO_HANGING
|
|
ENDENUM
|
|
|
|
ENUM CREATE_MEETING_STAGE_ENUM
|
|
CREATE_MEETING_STAGE_NOT_STARTED = 0,
|
|
CREATE_MEETING_STAGE_WAITING_FOR_VEHICLES,
|
|
CREATE_MEETING_STAGE_VEHICLES_CREATED,
|
|
CREATE_MEETING_STAGE_WAITING_FOR_PEDS,
|
|
CREATE_MEETING_STAGE_DONE
|
|
ENDENUM
|
|
|
|
ENUM CREATE_UTIL_TRUCKS_STAGE_ENUM
|
|
CREATE_UTIL_TRUCKS_STAGE_NOT_STARTED = 0,
|
|
CREATE_UTIL_TRUCKS_STAGE_WAITING,
|
|
CREATE_UTIL_TRUCKS_STAGE_DONE
|
|
ENDENUM
|
|
|
|
ENUM CREATE_INTERROGATION_STAGE_ENUM
|
|
CREATE_INTERROGATION_STAGE_NOT_STARTED = 0,
|
|
CREATE_INTERROGATION_STAGE_WAITING,
|
|
CREATE_INTERROGATION_STAGE_DONE
|
|
ENDENUM
|
|
|
|
ENUM CREATE_FBI_AT_END_STAGE_ENUM
|
|
CREATE_FBI_AT_END_STAGE_NOT_STARTED = 0,
|
|
CREATE_FBI_AT_END_STAGE_WAITING,
|
|
CREATE_FBI_AT_END_STAGE_DONE
|
|
ENDENUM
|
|
|
|
ENUM REPLACE_MR_K_STAGE_ENUM
|
|
REPLACE_MR_K_STAGE_NOT_STARTED = 0,
|
|
REPLACE_MR_K_STAGE_WAITING,
|
|
REPLACE_MR_K_STAGE_DONE
|
|
ENDENUM
|
|
|
|
ENUM FALL_ENUM
|
|
FALL_FELL = 0,
|
|
FALL_ROPE_CUT,
|
|
FALL_KNOCKED,
|
|
FALL_DROWNED
|
|
ENDENUM
|
|
|
|
ENUM SHAPETEST_STATE_ENUM
|
|
SHAPETEST_STATE_NOT_STARTED = 0,
|
|
SHAPETEST_STATE_PROBING
|
|
ENDENUM
|
|
|
|
ENUM HELI_STRAFE_STATE_ENUM
|
|
HELI_STRAFE_MOVE = 0,
|
|
HELI_STRAFE_ATTACK
|
|
ENDENUM
|
|
|
|
ENUM JUMP_GRUNT_STATE_ENUM
|
|
JUMP_GRUNT_READY = 0,
|
|
JUMP_GRUNT_DO_ON_LAND,
|
|
JUMP_GRUNT_DO_ON_PUSH,
|
|
JUMP_GRUNT_WAIT_FOR_RESET
|
|
ENDENUM
|
|
|
|
ENUM MICHAEL_RELOAD_STATE_ENUM
|
|
MICHAEL_RELOAD_HAS_AMMO = 0,
|
|
MICHAEL_RELOAD_IS_RELOADING
|
|
ENDENUM
|
|
|
|
ENUM TOWER_PED_STATE_ENUM
|
|
TOWER_PED_STATE_UNALERTED = 0,
|
|
TOWER_PED_STATE_ENTER_REACT,
|
|
TOWER_PED_STATE_REACTING
|
|
ENDENUM
|
|
|
|
ENUM LEAD_OUT_STATE_ENUM
|
|
LEAD_OUT_STATE_NOT_STARTED = 0,
|
|
LEAD_OUT_STATE_WAIT_TO_REVERT,
|
|
LEAD_OUT_STATE_DONE,
|
|
LEAD_OUT_STATE_FLEEING
|
|
ENDENUM
|
|
|
|
ENUM SNATCH_AND_GRAB_AUDIO_SCENE_ENUM
|
|
SNATCH_AND_GRAB_AUDIO_SCENE_DRIVE_TO_LOT = 0,
|
|
SNATCH_AND_GRAB_AUDIO_SCENE_FLY_TO_AGENCY,
|
|
SNATCH_AND_GRAB_AUDIO_SCENE_FOCUS_ON_ROOF,
|
|
SNATCH_AND_GRAB_AUDIO_SCENE_RAPPEL,
|
|
SNATCH_AND_GRAB_AUDIO_SCENE_INDOOR,
|
|
SNATCH_AND_GRAB_AUDIO_SCENE_BREAK_THE_GLASS,
|
|
SNATCH_AND_GRAB_AUDIO_SCENE_MR_K_HOSTAGE,
|
|
SNATCH_AND_GRAB_AUDIO_SCENE_FRANKLIN_SNIPE_ENEMIES,
|
|
SNATCH_AND_GRAB_AUDIO_SCENE_MICHAEL_SHOOT_ENEMIES,
|
|
SNATCH_AND_GRAB_AUDIO_SCENE_CHOPPERS_ARRIVE_FRANKLIN,
|
|
SNATCH_AND_GRAB_AUDIO_SCENE_CHOPPERS_ARRIVE_MICHAEL,
|
|
SNATCH_AND_GRAB_AUDIO_SCENE_CHOPPERS_ARRIVE_TREVOR,
|
|
SNATCH_AND_GRAB_AUDIO_SCENE_FLY_BACK_AS_TREVOR,
|
|
SNATCH_AND_GRAB_AUDIO_SCENE_FLY_BACK_AS_MICHAEL,
|
|
SNATCH_AND_GRAB_AUDIO_SCENE_LAND_THE_HELI
|
|
ENDENUM
|
|
|
|
ENUM PICKUP_CHOPPER_LEADIN_STAGE_ENUM
|
|
PICKUP_CHOPPER_LEADIN_NOT_STARTED = 0,
|
|
PICKUP_CHOPPER_LEADIN_LOOPING,
|
|
PICKUP_CHOPPER_LEADIN_ACTION,
|
|
PICKUP_CHOPPER_LEADIN_DONE
|
|
ENDENUM
|
|
|
|
ENUM DAVE_INTO_CAR_STATE_ENUM
|
|
DAVE_INTO_CAR_STATE_WALKING = 0,
|
|
DAVE_INTO_CAR_STATE_ENTER,
|
|
DAVE_INTO_CAR_STATE_PAUSED
|
|
ENDENUM
|
|
|
|
|
|
// Structs
|
|
STRUCT GUARD_AI
|
|
GUARD_ACTION_ENUM currentAction
|
|
GUARD_SITUATION_REACT_ENUM currentSituation
|
|
INT iRevertActionTime
|
|
ENDSTRUCT
|
|
|
|
|
|
// Consts
|
|
CONST_INT NUMBER_MODEL_REQUEST_SLOTS COUNT_OF(SNATCH_AND_GRAB_MODEL_ENUM)
|
|
CONST_INT NUMBER_RECORDING_REQUEST_SLOTS 13
|
|
CONST_INT NUMBER_FBI_AGENTS 2
|
|
CONST_INT NUMBER_FBI_CARS 2
|
|
CONST_INT NUMBER_GUARDS 6
|
|
CONST_INT NUMBER_ENEMY_CHOPPERS 4
|
|
CONST_INT GUARD_FIRST_WAVE_INDEX 0
|
|
CONST_INT GUARD_SECOND_WAVE_INDEX 3
|
|
CONST_INT NUMBER_FROZEN_CHAIRS 2
|
|
CONST_INT NUMBER_TOWER_CHAIRS 3
|
|
CONST_INT NUMBER_TOWER_WINDOWS 3
|
|
CONST_INT NUMBER_FOOD_COURT_CHAIRS 7
|
|
CONST_INT NUMBER_TOWER_PEDS 5
|
|
CONST_INT GUARD_LAST_INDEX 4
|
|
CONST_INT NUMBER_REINFORCEMENTS 8
|
|
CONST_INT NUMBER_TRAFFIC_VEHICLES 15
|
|
CONST_INT NUMBER_LEAVE_HIGH_RISE_AREA_POINTS 10
|
|
CONST_INT NUMBER_ESCAPE_ROUTE_POINTS 45
|
|
CONST_INT MAX_SKIP_MENU_LENGTH 13
|
|
CONST_INT SKIP_FADE_WAIT_TIME 200
|
|
CONST_INT SKIP_FADE_LONG_WAIT_TIME 1600
|
|
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 FREE_AIM_THRESHOLD 11
|
|
CONST_INT GUARD_ATTACK_TIME_INIT 90000
|
|
CONST_INT GUARD_ATTACK_TIME_SHOOTING 35000
|
|
CONST_INT CHOPPER_HELP_TIME 7000
|
|
CONST_INT FOCUS_HELP_TIME 4000
|
|
CONST_INT MIN_RANDOM_SPEECH_TIME 7000
|
|
CONST_INT MAX_RANDOM_SPEECH_TIME 12000
|
|
CONST_INT WINCH_CUTSCENE_TIME 7000
|
|
|
|
CONST_INT DOORHASH_OPEN_DOOR HASH("DOORHASH_OPEN_DOOR")
|
|
CONST_INT DOORHASH_CLOSED_DOOR1 HASH("DOORHASH_CLOSED_DOOR1")
|
|
CONST_INT DOORHASH_CLOSED_DOOR2 HASH("DOORHASH_CLOSED_DOOR2")
|
|
|
|
CONST_INT FRANKLIN_SMART_FEET 9
|
|
CONST_INT FRANKLIN_SMART_TORSO 18
|
|
CONST_INT FRANKLIN_SMART_LEG 15
|
|
|
|
CONST_FLOAT CLEAR_POS_RADIUS 3.2
|
|
|
|
CONST_FLOAT RAPPEL_VEHICLE_RANGE_MULTIPLIER 0.8
|
|
CONST_FLOAT CHOPPER_HOVER_SPEED 0.5
|
|
CONST_FLOAT CHOPPER_ESCAPE_SPEED 0.9
|
|
CONST_FLOAT ROPE_SHOOT_TURN_SPEED 80.0
|
|
CONST_FLOAT CHASE_START_WINDING_TIME 4000.0
|
|
CONST_FLOAT CHASE_STOP_WINDING_TIME 20000.0
|
|
CONST_FLOAT WINDING_LENGTH 16000.0
|
|
CONST_FLOAT CHASE_UNPIN_INTERIOR_TIME 36000.0
|
|
CONST_FLOAT CHASE_FORCE_SWITCH_TIME 20500.0
|
|
CONST_FLOAT CHASE_SPOT_CHOPPER_TIME 23000.0
|
|
CONST_FLOAT SKIP_CHOPPER_PLAYBACK_TIME 10000.0
|
|
CONST_FLOAT AFTER_CUTSCENE_TIME 2000.0
|
|
CONST_FLOAT AFTER_CUTSCENE_LONG_TIME 4000.0
|
|
|
|
CONST_FLOAT ROPE_ATTACH_Z - 0.9
|
|
CONST_FLOAT RAPPEL_ROPE_LENGTH_LONG 72.7//64.7
|
|
CONST_FLOAT RAPPEL_ROPE_LENGTH_DANGLING 63.0
|
|
CONST_FLOAT RAPPEL_ROPE_LENGTH_WOUND 25.0//65.1
|
|
CONST_FLOAT RAPPEL_ROPE_STORE_Y_OFFSET 0.4
|
|
CONST_FLOAT RAPPEL_ROPE_STORE_Z_OFFSET 0.01
|
|
CONST_FLOAT RAPPEL_ROPE_FALL_ACCELERATION 6.0
|
|
CONST_FLOAT RAPPEL_ROPE_FALL_MAX_SPEED 12.0
|
|
CONST_FLOAT RAPPEL_READY_Z -61.0
|
|
CONST_FLOAT RAPPEL_ROPE_WEIGHT 30.0
|
|
CONST_FLOAT INIT_ROPE_ATTACH_HEADING 234.3
|
|
CONST_FLOAT START_RAPPEL_Z 13.5
|
|
|
|
CONST_FLOAT WEIGHT_PHYSICAL_MASS 150.0
|
|
CONST_FLOAT WEIGHT_PHYSICAL_GRAVITY 1.0
|
|
|
|
CONST_FLOAT ATTACH_CAM_OFFSET_MOD_X 0.03
|
|
CONST_FLOAT ATTACH_CAM_OFFSET_LIMIT_X 3.0
|
|
CONST_FLOAT ATTACH_CAM_OFFSET_MOD_Y 0.03
|
|
CONST_FLOAT ATTACH_CAM_OFFSET_LIMIT_Y 3.0
|
|
CONST_FLOAT ATTACH_CAM_OFFSET_MOD_Z -0.03
|
|
CONST_FLOAT ATTACH_CAM_OFFSET_LIMIT_Z 3.0
|
|
CONST_FLOAT ATTACH_CAM_OFFSET_PLUS_Z -0.03
|
|
|
|
CONST_FLOAT DOOR_OPEN_RATIO -1.28
|
|
|
|
CONST_FLOAT ESCAPE_ROUTE_HEIGHT 190.0
|
|
|
|
CONST_FLOAT PLAYER_INIT_ROT 70.2//-63.0//-45.33
|
|
CONST_FLOAT PLAYER_INIT_ROT2 135.8
|
|
CONST_FLOAT DAVE_INIT_ROT 24.84
|
|
CONST_FLOAT DAVE_INIT_ROT2 79.1
|
|
CONST_FLOAT TREVOR_INIT_ROT 137.37
|
|
CONST_FLOAT FRANKLIN_INIT_ROT 6.54
|
|
CONST_FLOAT FRANKLIN_SNIPER_ROT -96.9
|
|
CONST_FLOAT MICHAEL_CAR_INIT_ROT -19.9//339.68
|
|
CONST_FLOAT BIKE_INIT_ROT -78.9
|
|
CONST_FLOAT JEEP_INIT_ROT 16.67
|
|
CONST_FLOAT CHOPPER_INIT_ROT -15.08
|
|
CONST_FLOAT PICKUP_CHOPPER_LEADIN_ROT -15.47
|
|
CONST_FLOAT CHOPPER_HOVER_ROT 167.90
|
|
CONST_FLOAT CHOPPER_CHASE_END_ROT -129.27
|
|
CONST_FLOAT WINDOW_ROT -103.14
|
|
CONST_FLOAT BREAK_IN_ROT -96.20
|
|
CONST_FLOAT PRISONER_INIT_ROT 255.98
|
|
CONST_FLOAT MICHELLE_INIT_ROT 78.59
|
|
CONST_FLOAT INTERROGATION_ROT -125.7// -126.19
|
|
CONST_FLOAT SNIPER_ROT 85.67
|
|
CONST_FLOAT REMOTE_ROT -100.63
|
|
CONST_FLOAT END_ROT -22.4
|
|
CONST_FLOAT GUARD_ANIM_ORIGIN_ROT 145.500
|
|
CONST_FLOAT MOVE_LAST_PLAYER_VEHICLE_ROT -18.98
|
|
CONST_FLOAT MICHAEL_AT_FOOD_COURT_ROT -65.4
|
|
|
|
CONST_FLOAT MAX_DAVE_WALK_SPEED 1.15
|
|
CONST_FLOAT MIN_DAVE_WALK_SPEED 0.9
|
|
|
|
CONST_FLOAT RAPPEL_CAM_X_Y_INPUT_TO_DEGREES_FACTOR 1.2
|
|
CONST_FLOAT RAPPEL_CAM_X_Y_SPEED 0.4
|
|
CONST_FLOAT RAPPEL_CAM_Z_UPPER_LIMIT 7.0
|
|
CONST_FLOAT RAPPEL_CAM_Z_LOWER_LIMIT -6.0
|
|
CONST_FLOAT RAPPEL_CAM_FOV 44.2
|
|
|
|
CONST_FLOAT INIT_SNIPER_ZOOM 3.0
|
|
CONST_FLOAT CASCADE_SHADOWS_MULTIPLIER_EXTERIOR_OVERRIDE 2.0
|
|
CONST_FLOAT CASCADE_SHADOWS_MULTIPLIER_INTERIOR_OVERRIDE 0.25
|
|
CONST_FLOAT CASCADE_SHADOWS_MULTIPLIER_NO_OVERRIDE 1.0
|
|
CONST_FLOAT CASCADE_SHADOWS_ROPE_OVERRIDE 2.1
|
|
CONST_FLOAT GUARD_ANIM_BLEND_OUT -0.25
|
|
|
|
CONST_FLOAT DAVE_PAUSE_DIST 3.6//7.0
|
|
CONST_FLOAT DAVE_UNPAUSE_DIST 3.2//4.1//3.2
|
|
|
|
CONST_FLOAT MAX_TRANSITION_BLUR 10.0
|
|
|
|
// 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_HOTSWAP_STAGE_ENUM hotswapStage
|
|
MISSION_STREAMING_STAGE_ENUM streamingStage
|
|
MOCAP_STREAMING_STAGE_ENUM mocapStreamingStage
|
|
SNATCH_AND_GRAB_CUTSCENE_STAGE_ENUM cutsceneStage
|
|
EXTRACT_STAGE_ENUM extractStage
|
|
HANGING_HOTSWAP_STATE_ENUM hangingHotswapState
|
|
PRISONER_GRAB_STATE_ENUM prisonerGrabState
|
|
CREATE_MEETING_STAGE_ENUM createMeetingStage
|
|
CREATE_UTIL_TRUCKS_STAGE_ENUM createUtilTrucksStage
|
|
CREATE_INTERROGATION_STAGE_ENUM createInterrogationStage
|
|
CREATE_FBI_AT_END_STAGE_ENUM createFBIAtEndStage
|
|
REPLACE_MR_K_STAGE_ENUM replaceMrKStage
|
|
GUARD_AI guardAI[NUMBER_GUARDS]
|
|
SELECTOR_PED_STRUCT sSelectorPeds
|
|
SELECTOR_CAM_STRUCT sCamDetails
|
|
//MEETING_SHOT_ENUM meetingShot
|
|
SMASH_THROUGH_SHOT_ENUM smashThroughShot
|
|
//DROPOFF_SHOT_ENUM dropoffShot
|
|
JUMP_GRUNT_STATE_ENUM jumpGruntState
|
|
HELI_STRAFE_STATE_ENUM heliStrafeState
|
|
TOWER_PED_STATE_ENUM towerPedState[NUMBER_TOWER_PEDS]
|
|
//MICHAEL_RELOAD_STATE_ENUM michaelReloadState
|
|
//LEAD_OUT_STATE_ENUM steveLeadOutState
|
|
//LEAD_OUT_STATE_ENUM andreasLeadOutState
|
|
RAGDOLL_BLOCKING_FLAGS steveRagdollBlocking = RBF_PLAYER_IMPACT | RBF_VEHICLE_IMPACT | RBF_IMPACT_OBJECT
|
|
PICKUP_CHOPPER_LEADIN_STAGE_ENUM pickupChopperLeadinStage
|
|
DAVE_INTO_CAR_STATE_ENUM daveIntoCarState
|
|
|
|
// Peds
|
|
PED_INDEX davePed
|
|
PED_INDEX stevePed
|
|
PED_INDEX andreasPed
|
|
PED_INDEX prisonerPed
|
|
PED_INDEX michellePed
|
|
PED_INDEX towerPed[NUMBER_TOWER_PEDS]
|
|
PED_INDEX fbiPed[NUMBER_FBI_AGENTS]
|
|
PED_INDEX guardPed[NUMBER_GUARDS]
|
|
PED_INDEX reinforcementPed[NUMBER_REINFORCEMENTS]
|
|
PED_INDEX enemyChopperPed[NUMBER_ENEMY_CHOPPERS*3]
|
|
PED_INDEX michaelTargetPed
|
|
PED_INDEX dummyFranklinPed
|
|
PED_INDEX dummyTrevorPed
|
|
|
|
// Vehicles
|
|
VEHICLE_INDEX snatchAndGrabVehicle[COUNT_OF(SNATCH_AND_GRAB_VEHICLE_ENUM)]
|
|
VEHICLE_INDEX enemyChopperVehicle[NUMBER_ENEMY_CHOPPERS]
|
|
VEHICLE_INDEX fbiVanVehicle
|
|
VEHICLE_INDEX trafficVehicle[NUMBER_TRAFFIC_VEHICLES]
|
|
VEHICLE_INDEX michaelTargetVehicle
|
|
VEHICLE_INDEX franklinTargetVehicle
|
|
VEHICLE_INDEX utilTruckVehicle[3]
|
|
VEHICLE_INDEX driveAwayVehicle
|
|
|
|
// Objects
|
|
OBJECT_INDEX harnessObject
|
|
OBJECT_INDEX torchObject
|
|
OBJECT_INDEX chairObject
|
|
OBJECT_INDEX towerChairObject[NUMBER_TOWER_CHAIRS]
|
|
OBJECT_INDEX frozenChairObject[NUMBER_FROZEN_CHAIRS]
|
|
OBJECT_INDEX foodCourtChairObject[NUMBER_FOOD_COURT_CHAIRS]
|
|
//OBJECT_INDEX hookObject
|
|
OBJECT_INDEX franklinAnchorObject
|
|
OBJECT_INDEX michaelGunObject
|
|
OBJECT_INDEX coffeeObject[3]
|
|
OBJECT_INDEX cutsceneChairObject[6]
|
|
|
|
// Blips
|
|
BLIP_INDEX vehicleBlip
|
|
BLIP_INDEX getToBlip
|
|
BLIP_INDEX buddyBlip
|
|
BLIP_INDEX guardBlip[NUMBER_GUARDS]
|
|
BLIP_INDEX reinforcementBlip[NUMBER_REINFORCEMENTS]
|
|
BLIP_INDEX enemyChopperBlip[NUMBER_ENEMY_CHOPPERS]
|
|
BLIP_INDEX playerChopperBlip
|
|
BLIP_INDEX franklinSniperBlip
|
|
|
|
// Cameras
|
|
CAMERA_INDEX staticCam
|
|
CAMERA_INDEX interpCam
|
|
//CAMERA_INDEX holdShotCam
|
|
CAMERA_INDEX animCam
|
|
CAMERA_INDEX ropeCam
|
|
//CAMERA_INDEX followCam
|
|
|
|
// Bools
|
|
BOOL bModelRequestTracker[COUNT_OF(SNATCH_AND_GRAB_MODEL_ENUM)]
|
|
BOOL bVehicleRecordingRequestTracker[NUMBER_RECORDING_REQUEST_SLOTS]
|
|
BOOL bAnimDictRequestTracker[COUNT_OF(SNATCH_AND_GRAB_ANIM_DICT_ENUM)]
|
|
BOOL bWeaponRequestTracker[COUNT_OF(SNATCH_AND_GRAB_WEAPON_ENUM)]
|
|
BOOL bPTFXRequestTracker[COUNT_OF(SNATCH_AND_GRAB_PTFX_ENUM)]
|
|
BOOL bSFXRequestTracker[COUNT_OF(SNATCH_AND_GRAB_SFX_ENUM)]
|
|
BOOL bMiscAssetRequestTracker[COUNT_OF(SNATCH_AND_GRAB_MISC_ASSET_ENUM)]
|
|
BOOL bThoroughCleanup
|
|
BOOL bForcePassOnShitskip
|
|
BOOL bRunningCutscene
|
|
BOOL bSkippedCutscene
|
|
BOOL bClearedForCutscene
|
|
BOOL bCutsceneWaitStarted
|
|
BOOL bShownGodText
|
|
BOOL bDoneChopperLandSpeech
|
|
BOOL bSniperMusicStarted
|
|
BOOL bDoneGotoSpeech
|
|
BOOL bShouldDoGetInText
|
|
BOOL bDoneBanter
|
|
BOOL bSavedBanter
|
|
BOOL bRemovedBlipsForWanted
|
|
//BOOL bKilledConversationOnWanted
|
|
BOOL bShownLoseWantedPrompt
|
|
BOOL bCloseToBuilding
|
|
BOOL bWaitForBuddyPrompt
|
|
BOOL bGetBuddyPrompt
|
|
BOOL bInteriorPinned
|
|
//BOOL bFadedOut
|
|
BOOL bMusicFaded
|
|
BOOL bMeetingCutsceneMusicStart
|
|
BOOL bMeetingCutsceneMusicEnd
|
|
BOOL bSteveSeated
|
|
BOOL bAndreasSeated
|
|
BOOL bDaveSeated
|
|
BOOL bLoopSteveAndAndreas
|
|
BOOL bRemovedSteveAndAndreas
|
|
BOOL bDoneGetToLotSpeech
|
|
//BOOL bForceIntoCar
|
|
BOOL bCarIsMoving
|
|
BOOL bRegisteredCall
|
|
//BOOL bRestoredControlOnStart
|
|
BOOL bChangedClothes
|
|
BOOL bRemovedFBICar
|
|
//BOOL bLatchedChopperDoors
|
|
BOOL bRemovedAltitudeHelp
|
|
//BOOL bStartedRappelSound
|
|
BOOL bDoneGetInPositionSpeech
|
|
BOOL bKilledBanterInChopper
|
|
BOOL bArrivedAtBuilding
|
|
BOOL bPlayingHoverBackwards
|
|
BOOL bAlertedWindow[NUMBER_TOWER_WINDOWS]
|
|
BOOL bCreatedOfficePedsForRappel
|
|
BOOL bInitialisedInterrogation
|
|
//BOOL bTakeOverRappelControl
|
|
//BOOL bFocusRappelCamIntoOffice
|
|
//BOOL bRestoreRappelCamToPlayer
|
|
BOOL bTortureMusicStart
|
|
BOOL bDoneSeeHelp
|
|
//BOOL bDoneWaitHelp
|
|
BOOL bHasDoneJump
|
|
//BOOL bSetSmashHelp
|
|
//BOOL bDisplayJumpHelp
|
|
BOOL bUsingOfficeCam
|
|
//BOOL bHoldingShot
|
|
BOOL bAllowSmashIn
|
|
BOOL bDeletedTraffic
|
|
BOOL bCreatedSniper
|
|
//BOOL bDrewWeapon
|
|
BOOL bGaveGuardWeapon
|
|
BOOL bTriggeredGuardShoot
|
|
BOOL bDoGuardsKillMichael
|
|
BOOL bFakeKillMichael
|
|
BOOL bResetGuardAim
|
|
BOOL bRegisteredSmash
|
|
//BOOL bDoneSmashInSpeech
|
|
BOOL bPinRopeToWindow
|
|
BOOL bShownSwitchText
|
|
BOOL bFrozenFranklin
|
|
//BOOL bSniperOneshot
|
|
BOOL bDoneFranklinSniperSpeech
|
|
BOOL bKilledSpeechOnPan
|
|
BOOL bGuardsHeardSniper
|
|
BOOL bDoneGuardBeckon
|
|
BOOL bRappelMusicStart
|
|
//BOOL bRemovedGuardDialogue
|
|
BOOL bAdvancedGuardAttackTime
|
|
BOOL bSelectedMichaelDuringExtract
|
|
BOOL bActivatedRopeSwingFromSynced
|
|
//BOOL bKilledSmashOS
|
|
BOOL bDoneExtractSpeech
|
|
//BOOL bDoneExtractHelp
|
|
BOOL bReactedToFirstShot
|
|
BOOL bAdditionalGuardsToShoot
|
|
BOOL bDoneGetOutSpeech
|
|
BOOL bCreatedAdditionalReinforcement[4]
|
|
BOOL bReinforcementToShoot[NUMBER_REINFORCEMENTS]
|
|
BOOL bUnpinnedInteriorForChase
|
|
BOOL bStartedWinding
|
|
BOOL bStoppedWinding
|
|
BOOL bSwingingRight
|
|
BOOL bRopePhysical
|
|
BOOL bDoneDangleHelp
|
|
BOOL bDoneReattach
|
|
BOOL bEnemyChopperShootersToAttack[NUMBER_ENEMY_CHOPPERS]
|
|
BOOL bShownChopperPrompt
|
|
BOOL bEnemyChopperToAI[NUMBER_ENEMY_CHOPPERS]
|
|
BOOL bDoneDestroyedChopperSpeech[NUMBER_ENEMY_CHOPPERS]
|
|
BOOL bKilledEnemyChopperPed[NUMBER_ENEMY_CHOPPERS * 3]
|
|
BOOL bSpottedChopper
|
|
BOOL bDoneChopperChoiceSpeech
|
|
BOOL bDoneMakeMichaelMoreLethal
|
|
BOOL bDoneTrevorFly
|
|
BOOL bAllowStartEscapeRoute
|
|
BOOL bStartedRotateToLeaveHighRiseArea
|
|
BOOL bStartedJourneyToLeaveHighRiseArea
|
|
//BOOL bAttachedBlock
|
|
BOOL bKnockedOff
|
|
BOOL bLoadedExtractSpeech
|
|
BOOL bDoneGoHomeSpeech
|
|
BOOL bDoChopperSpinOut[NUMBER_ENEMY_CHOPPERS]
|
|
BOOL bRemovedEnemyChopper
|
|
BOOL bSwitchedBackDuringDropoff
|
|
BOOL bDoneForceTrevorLow
|
|
BOOL bDoneFBITurnToFaceChopper
|
|
BOOL bDoneFBIWaveDownChopper
|
|
BOOL bDoneLandSpeech
|
|
BOOL bDoneLandAudioScene
|
|
BOOL bKilledSpeechForLand
|
|
//BOOL bLockedToTrevor
|
|
//BOOL bMichaelToRagdoll
|
|
//BOOL bBackedUpZoom
|
|
BOOL bSkippedGlassSmash
|
|
BOOL bDoForceHeliUpwards
|
|
BOOL bAlternateChopper
|
|
BOOL bShortRope
|
|
BOOL bStartExtraction
|
|
BOOL bDonePanicSpeech
|
|
BOOL bDoneRealPanicSpeech
|
|
BOOL bReattachedMichael
|
|
BOOL bDoneTrevorEncourageSpeech
|
|
BOOL bKilledBanter
|
|
//BOOL bDoneBriefTroopsSpeech
|
|
BOOL bSetSniperZoom
|
|
//BOOL bDoneFranklinDangerHelp
|
|
BOOL bRemovedUtilTrucks
|
|
BOOL bDoneChopperAttackFranklinSpeech
|
|
BOOL bDoneFranklinReactToChopperSpeech
|
|
BOOL bDoneLastOneSpeech
|
|
BOOL bDoneRocketReactionSpeech
|
|
BOOL bDoneTrevorRemindFranklinSpeech
|
|
BOOL bDoneFranklinSayChopperDownSpeech
|
|
BOOL bDoneTrevorCongratulateFranklinSpeech
|
|
BOOL bDoneWeHitSpeech
|
|
BOOL bDoneWayHomeSpeech
|
|
BOOL bDoneWayHomeSpeech2
|
|
BOOL bDoneGetOffRoofSpeech
|
|
//BOOL bDoneKeepSniperSpeech
|
|
BOOL bRequestedGuardAnims
|
|
BOOL bRequestedAtBuildingAssets
|
|
BOOL bDoneSmashSound
|
|
BOOL bHeliLiftedOff
|
|
BOOL bDoneInterpBackToGame
|
|
BOOL bDoneApproachLotCue
|
|
BOOL bDoneHalfwayThereCue
|
|
BOOL bDoneSwitchToFranklinCue
|
|
BOOL bDoneKill3GuardsCue
|
|
BOOL bPreparedChoppersApproachingCue
|
|
BOOL bDoneChoppersApproachingCue
|
|
BOOL bDoneMichaelFightsChoppersCue
|
|
BOOL bDoneNoMoreThreatCue
|
|
BOOL bDoneMissionCompleteCue
|
|
BOOL bUnmuffledRappelAudioScene
|
|
BOOL bInteriorCamIsOutside
|
|
BOOL bDoneDontShootSpeech
|
|
BOOL bClearedAutopilot
|
|
//BOOL bKilledTrevorDiscussionSpeech
|
|
//BOOL bRestartedDiscussionSpeech
|
|
BOOL bDisableSwitchDuringMagDemoEndScene
|
|
BOOL bKeepTorch
|
|
BOOL bCheckedInitialSniper
|
|
BOOL bGuardsAttackPrisoner
|
|
BOOL bGuardsStoppedShooting
|
|
BOOL bDoLeadHeliFireRockets
|
|
BOOL bDoneDaveLetsGoSpeech
|
|
BOOL bDaveInCar
|
|
BOOL bDoneSteveLook
|
|
BOOL bDoneAndreasLook
|
|
BOOL bDoneInCarAudioScene
|
|
BOOL bTrevorGone
|
|
BOOL bDoneMichaelLeaveCarSpeech
|
|
BOOL bStuckOnOfficeCam
|
|
BOOL bWaitingOnOfficeCamRelease
|
|
BOOL bPreparedTrevorRantAudio
|
|
BOOL bSetSceneAudioEntity
|
|
BOOL bCanRunPickupChopperScene
|
|
BOOL bDaveActionModeTrack
|
|
BOOL bDoneDaveShuffle
|
|
BOOL bKilledDaveSpeechForDamage
|
|
BOOL bKilledDaveSpeechForWanted
|
|
BOOL bDoneDaveWantedSpeech
|
|
BOOL bWarpedToLot
|
|
BOOL bWarpedChopperToBuilding
|
|
BOOL bResetTimeForBelowHeight
|
|
BOOL bChangedPriorityFromSniperToTrevor
|
|
BOOL bDoneFocusCamAudioScene
|
|
BOOL bDoneCantGetShotSpeech
|
|
BOOL bDoneTroubleFlashHelp
|
|
BOOL bLastReinforcementIsLast
|
|
BOOL bDoneTopOfTowerShot
|
|
BOOL bTriggeredGreetingAnim
|
|
BOOL bTriggeredGreetingSpeech
|
|
BOOL bPlayerLeaveVehicle
|
|
BOOL bDoneIntroCreateEntities
|
|
BOOL bDoneIntroClearStart
|
|
BOOL bWasTimeLapseRunning
|
|
BOOL bDoneDaveCarSpeech
|
|
BOOL bKilledSpeechForDaveCar
|
|
BOOL bCuedFriendlyFireSpeech
|
|
BOOL bDoneForceGetOutOfThereSpeech
|
|
BOOL bDoneLastGuardEnter
|
|
BOOL bLastGuardToShoot
|
|
BOOL bSuppressFutureReplaySetups
|
|
BOOL bForceStartedChopper
|
|
BOOL bSetMichaelToWalk
|
|
BOOL bDoneTowerHintCamHelp
|
|
BOOL bDisabledBlurOnRifle
|
|
BOOL bRocketsAccurate
|
|
BOOL bCreatedGuysAtFoodCourt
|
|
BOOL bKilledLookAtInCar
|
|
BOOL bKilledMichaelLeaveCarSpeechForTime
|
|
BOOL bUnproofedChoppers
|
|
BOOL bDoMichaelBoom
|
|
BOOL bHitCutsceneFailsafe
|
|
BOOL bSetNavmesh
|
|
BOOL bHitFranklinSound
|
|
BOOL bPrestreamedLine
|
|
BOOL bCreatedExtraHeli
|
|
BOOL bFrozeChairs
|
|
BOOL bShownSlowmoHelp
|
|
BOOL bFilledMichaelMeter
|
|
BOOL bCacheAt
|
|
BOOL bTurnedOffRadarForSuppressHud
|
|
BOOL bApplyOffsetToWinchRope
|
|
BOOL bFadedIn
|
|
BOOL bStartPushIn
|
|
BOOL bDoneHitSound
|
|
BOOL bWooshStarted
|
|
BOOL bDoneFlash
|
|
BOOL bFlashOnTimeLapse
|
|
|
|
BOOL bSwitchToFirstPerson
|
|
|
|
// Floats
|
|
FLOAT fHoverPlaybackSpeed
|
|
FLOAT fRopeAttachHeading
|
|
FLOAT fPlaybackTime
|
|
FLOAT fTargetChopperRotate
|
|
//FLOAT fPointCamY
|
|
//FLOAT fPointCamZ
|
|
//FLOAT fPointCamYSpeed
|
|
//FLOAT fPointCamZSpeed
|
|
FLOAT fLockDoorOpen
|
|
//FLOAT fTempPhase
|
|
FLOAT fAtDropOffTime
|
|
FLOAT fSpinForce
|
|
FLOAT fUpwardsForce
|
|
FLOAT fChopperAccuracy
|
|
FLOAT fRopeTransitionPhase
|
|
//FLOAT fDrownTime
|
|
FLOAT fRappelCamTransitionPhase
|
|
FLOAT fRappelCamTransitionPhaseSpeed
|
|
FLOAT fHeliCircleAngle
|
|
FLOAT fBelowWaveHeightTime
|
|
FLOAT fAtWindowTime[NUMBER_TOWER_WINDOWS]
|
|
FLOAT fDaveWalkSpeed
|
|
FLOAT fCircleCentreMod
|
|
FLOAT g_fSavedMaxMotionBlur = -1.0
|
|
|
|
// Ints
|
|
INT iReplayAttempt
|
|
INT iAllowSkipCutsceneTime
|
|
INT iSnatchAndGrabCutsceneTime
|
|
INT iCutsceneTriggerTime
|
|
INT iNextRandomSpeechTime
|
|
INT iGetInTextStage
|
|
INT iChopperHelpTime
|
|
INT iHelpStage
|
|
INT iDriveBanterStage
|
|
//INT iInterrogationSpeechStage
|
|
INT iKillMichaelTime
|
|
//INT iHoldShotStage
|
|
//INT iHoldShotTime
|
|
//INT iDeactivateHoldShotTime
|
|
INT iGuardReactionStage
|
|
INT ireactionDelay //added Reaction delay so that guards dont perform reactions dead in sync - Craig
|
|
INT iGuardAttackTime
|
|
INT iGuardSpeech
|
|
INT iGuardShot
|
|
//INT iTriggerGuardShootTime
|
|
INT iPostKilledGuardsTime
|
|
INT iChopperChaseTime
|
|
INT iStartWindingTime
|
|
INT iAlertedWindowTime[NUMBER_TOWER_WINDOWS]
|
|
//INT iTrevorTime
|
|
INT iEnemyChopperAITime[NUMBER_ENEMY_CHOPPERS]
|
|
INT iEnemyChopperSpeechStage
|
|
INT iNextEnemyChopperSpeechTime
|
|
INT iTrevorRouteStage
|
|
INT iLeaveHighRiseAreaPoint
|
|
INT iAllowGoHomeTime
|
|
INT iStartMissionStageTime
|
|
INT iSyncScene
|
|
INT iSyncScene2
|
|
INT iGuardSyncScene[COUNT_OF(GUARD_SYNCED_SCENE_ENUM)]
|
|
INT iNextGuardAnimationTime[NUMBER_GUARDS]
|
|
INT iLastGuardAnimationTime[NUMBER_GUARDS]
|
|
INT iReinforcementShootWhileMovingStage[NUMBER_REINFORCEMENTS]
|
|
//INT iDangleMichaelSyncScene
|
|
//INT iDanglePrisonerSyncScene
|
|
INT iFoodCourtSyncScene
|
|
INT iWindowSmashStage
|
|
INT iClearHelpTime
|
|
INT iShownGodTextTime
|
|
INT iTrevorEscapeRoutePoint
|
|
INT iRecheckMichaelShootTime
|
|
INT iNextFranklinSnipeTime
|
|
INT iRecheckFranklinShootTime
|
|
INT iNextMichaelRappelSpeechTime
|
|
//INT iNextTrafficCarTime
|
|
INT iMichaelRappelSpeechStage
|
|
INT iFranklinTargetPed
|
|
INT iSpinModifier
|
|
INT iFadeInTime
|
|
INT iForceHeliUpwardsTime
|
|
INT iDangleSoundID = GET_SOUND_ID()
|
|
INT iSmashSoundID = GET_SOUND_ID()
|
|
INT iRappelWindSoundID = GET_SOUND_ID()
|
|
INT iFaintHeliSoundID = GET_SOUND_ID()
|
|
INT iSniperSwitchSoundID = GET_SOUND_ID()
|
|
//INT iTrafficRec[NUMBER_TRAFFIC_VEHICLES]
|
|
INT iDangleTime
|
|
INT iWinchTime
|
|
INT iFranklinPanicTime
|
|
INT iSwitchToMichaelPromptTime
|
|
//INT iFranklinDamageCount
|
|
INT iNextFranklinDamageCheckTime
|
|
//INT iDidPanicSpeechTime
|
|
INT iFranklinDeathTime
|
|
INT iNextMrKSpeechTime
|
|
INT iMrKSpeechStage
|
|
INT iTrevorRemindFranklinTime
|
|
INT iTrevorSayWeHitTime
|
|
INT iNextGetInPositionSpeechTime
|
|
INT iInterpBackToGameTime
|
|
INT iLastEnemyRocketsTime
|
|
INT iNextFranklinRocketReactionTime
|
|
INT iDuckAnim
|
|
INT iFlinchLeftAnim
|
|
INT iFlinchRightAnim
|
|
INT iClearAutopilotTime
|
|
INT iNextTrevorAITime
|
|
INT iHeliFlyOffState
|
|
INT iInitialSniperAmmo
|
|
INT iLeadHeli
|
|
INT iLeadHeliFireRocketsTime
|
|
INT iLastFBITaskTime
|
|
//INT iWaitForFadeTime
|
|
INT iNextRocketInBarrageTime
|
|
INT iLoopSteveAndAndreasTime
|
|
INT iTrevorFlyOffTime
|
|
INT iWaitToKillCam
|
|
INT iActivatedOfficeCamTime
|
|
INT iDaveActionModeDelay
|
|
INT iNextCheckPlayerDealDamageTime
|
|
INT iSteveSyncScene
|
|
INT iAndreasSyncScene
|
|
INT iDaveSyncScene
|
|
INT iReinforcementsEnterTime
|
|
INT iCreatedLastReinforcementTime
|
|
INT iCantGetShotSpeechTime
|
|
INT iLastFakeDamagedMichaelTime
|
|
INT iDaveDamageSpeechCount
|
|
INT iNextKickbackTime
|
|
INT iNextFriendlyFireSpeechTime
|
|
INT iCueFriendlyFireSpeechTime
|
|
INT iInterrogationSubCount
|
|
INT iReactToFirstShotTime
|
|
INT iNextExplosionCheckTime
|
|
INT iMichaelLeaveCarSpeechTime
|
|
INT iSkipTime
|
|
INT iPushInTime
|
|
INT iSetNavmeshTime
|
|
INT iLoadedExtractSpeechTime
|
|
INT iCreateExtraHeliTime
|
|
INT iSlowmoHelpTime
|
|
INT iSavedAmmo = -1
|
|
INT iBlockMichaelShootTime
|
|
INT iSelectorPressedTime
|
|
INT iHitTime
|
|
INT iSwitchTime
|
|
//INT iSteveRevertTime
|
|
//INT iAndreasRevertTime
|
|
|
|
// Vectors
|
|
VECTOR vShiftVectorSpeed
|
|
//VECTOR vCurrentKickBackOffset
|
|
VECTOR vCurrentKickBackForce
|
|
VECTOR vTrevorRoutePoint[3]
|
|
VECTOR vCachedPrisonerPos
|
|
|
|
// cache trevor mission
|
|
FLOAT fTrevorDist
|
|
BOOL bTrevorCachedTarget
|
|
|
|
// Other variables
|
|
RAPPEL_DATA rappelData
|
|
SCENARIO_BLOCKING_INDEX lotScenarioBlocking
|
|
SCENARIO_BLOCKING_INDEX tableScenarioBlocking
|
|
SCENARIO_BLOCKING_INDEX rampScenarioBlocking
|
|
//SCENARIO_BLOCKING_INDEX skyScenarioBlocking
|
|
INTERIOR_INSTANCE_INDEX officeInterior
|
|
RAYFIRE_INDEX windowRayfire
|
|
SEQUENCE_INDEX sequence
|
|
STREAMVOL_ID officeVolume
|
|
STREAMVOL_ID sniperVolume
|
|
ROPE_INDEX choppedRope1
|
|
ROPE_INDEX choppedRope2
|
|
//CHECKPOINT_INDEX jumpCheckpoint
|
|
structPedsForConversation snatchAndGrabConversation
|
|
REL_GROUP_HASH agencyRelGroup
|
|
structTimelapse sTimelapse
|
|
CHASE_HINT_CAM_STRUCT localChaseHintCamStruct
|
|
STREAMVOL_ID foodCourtStreamingVolume
|
|
TEXT_LABEL_23 tSavedBanterRoot
|
|
TEXT_LABEL_23 tResumeBanterLabel
|
|
PUSH_IN_DATA pushInData
|
|
|
|
//VECTOR vSniperNodePos1 = <<109.385162,-618.262939,206.679871>>//<<109.195,-619.290,206.681>>
|
|
//VECTOR vSniperNodeRot1 = <<-5.776209,0.000091,-104.552910>>//<<-0.658756,0.010757,-95.572708>>//<<-0.0969, 0.0, -83.3608>>
|
|
|
|
/*
|
|
VECTOR vSniperNodePos2 = <<-135.569, -592.585, 211.870>> //<<-137.246,-592.720,211.842>>
|
|
VECTOR vSniperNodeRot2 = <<-1.681, 0.0, -100.0>> //<<-1.680723,0.0,-93.077797>> //<<-0.658756,0.010757,-95.572708>>
|
|
|
|
VECTOR vSniperNodePos3 = <<-136.085, -592.5285, 211.910>> //<<-137.700,-592.700,211.842>>
|
|
VECTOR vSniperNodeRot3 = <<-1.681, 0.0, -100.0>> //<<-1.680723,0.0,-93.077797>> //<<-0.658756,0.010757,-95.572708>>
|
|
|
|
VECTOR vSniperNodePos4 = <<-136.601, -592.472, 211.950>> //<<-137.700,-592.700,211.842>>
|
|
VECTOR vSniperNodeRot4 = <<-1.681, 0.0, -100.0>> //<<-1.680723,0.0,-93.077797>> //<<-0.658756,0.010757,-95.572708>>
|
|
|
|
VECTOR vSniperNodePos5 = <<-136.005, -592.540, 211.880>>//<<-137.700,-592.700,211.842>>
|
|
VECTOR vSniperNodeRot5 = <<-3.473, 0.0, -97.369>> //<<-1.680723,0.0,-93.077797>>//<<-6.112012, 0.0, -93.078186>>
|
|
|
|
VECTOR vSniperNodePos6 = <<-135.729,-592.570,211.850>>//<<-135.915, -592.551, 211.862>>
|
|
VECTOR vSniperNodeRot6 = <<-3.473, 0.0, -97.369>> //<<-1.680723,0.0,-93.077797>>//<<-3.837169, 0.000000, -93.078186>>
|
|
*/
|
|
|
|
// NEW VALUES - ROB
|
|
|
|
|
|
VECTOR vSniperNodePos3 = <<-136.7, -592.6, 211.870>>//<<-136.085, -592.640, 211.910>> //<<-137.700,-592.700,211.842>>
|
|
VECTOR vSniperNodeRot3 = <<-1.7, 0.0, -98.1>>//<<-1.681, 0.0, -100.0>> //<<-1.680723,0.0,-93.077797>> //<<-0.658756,0.010757,-95.572708>>
|
|
|
|
//VECTOR vSniperNodePos4 = <<-136.601, -592.472, 211.950>> //<<-137.700,-592.700,211.842>>
|
|
//VECTOR vSniperNodeRot4 = <<-1.681, 0.0, -100.0>> //<<-1.680723,0.0,-93.077797>> //<<-0.658756,0.010757,-95.572708>>
|
|
|
|
//VECTOR vSniperNodePos5 = <<-136.005, -592.540, 211.880>>//<<-137.700,-592.700,211.842>>
|
|
//VECTOR vSniperNodeRot5 = <<-1.680723,0.0,-93.077797>>//<<-6.112012, 0.0, -93.078186>>
|
|
|
|
//VECTOR vSniperNodePos6 = <<-135.915, -592.551, 211.862>>
|
|
//VECTOR vSniperNodeRot6 = <<-1.680723,0.0,-93.077797>>//<<-3.837169, 0.000000, -93.078186>>
|
|
|
|
|
|
INT iSuppressHUDTime
|
|
|
|
// Debug
|
|
#IF IS_DEBUG_BUILD
|
|
WIDGET_GROUP_ID snatchAndGrabWidgets
|
|
TEXT_WIDGET_ID RBCamPosWidget, RBCamRotWidget
|
|
BOOL bRBDebugCamDoDump
|
|
VECTOR vRBDebugCamPos
|
|
VECTOR vRBDebugCamRot
|
|
BOOL bDebugJSkip
|
|
|
|
MissionStageMenuTextStruct stageMenu[MAX_SKIP_MENU_LENGTH]
|
|
INT iMenuMissionStage
|
|
|
|
INT iDebugStage = -1
|
|
|
|
BOOL bDebugUseAlternateRappelCam
|
|
BOOL bDebugDontFailOnKnockoff
|
|
#ENDIF
|
|
|
|
BOOL bDebugCanWinch = FALSE
|
|
BOOL bDebugSwingOutEarlier = TRUE
|
|
BOOL bDebugSkipMagdemoStart
|
|
BOOL bDebugSkipMagdemoZskipped
|
|
//BOOL bDebugSkipMagdemoUseRing = TRUE
|
|
|
|
// get recording prefix
|
|
FUNC STRING GET_FBI2_INTRO_CUTSCENE_NAME()
|
|
RETURN "fbi_2_int"
|
|
ENDFUNC
|
|
|
|
FUNC STRING GET_SNATCH_AND_GRAB_RECORDING_PREFIX()
|
|
RETURN "SnatchNGrab"
|
|
ENDFUNC
|
|
|
|
// get mission audio bank
|
|
FUNC STRING GET_MISSION_AUDIO_BANK_NAME()
|
|
RETURN "FBI_02_Snatch_and_Grab_01"
|
|
ENDFUNC
|
|
|
|
FUNC STRING GET_HELI_DRIVEBY_ANIMS_AS_STRING()
|
|
RETURN "clipset@missfbi2_driveby"
|
|
ENDFUNC
|
|
|
|
FUNC STRING GET_DESCRIPTION_FOR_STAGE_AS_STRING(MISSION_STAGE_ENUM thisStage)
|
|
SWITCH thisStage
|
|
CASE STAGE_FOOD_COURT
|
|
RETURN "Meet at food court"
|
|
BREAK
|
|
CASE STAGE_GET_TO_CHOPPER
|
|
RETURN "Get to chopper"
|
|
BREAK
|
|
CASE STAGE_GET_TO_BUILDING
|
|
RETURN "Get to Agency building"
|
|
BREAK
|
|
CASE STAGE_RAPPEL_DOWN
|
|
RETURN "Rappel to window"
|
|
BREAK
|
|
CASE STAGE_SNIPE_GUARDS
|
|
RETURN "Snipe guards"
|
|
BREAK
|
|
CASE STAGE_CHOPPER_CHASE
|
|
RETURN "Escape enemy chopper"
|
|
BREAK
|
|
CASE STAGE_DROPOFF
|
|
RETURN "Drop off Mr K"
|
|
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)
|
|
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, DEFAULT_GOD_TEXT_TIME, 1)
|
|
RETURN TRUE
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
|
|
RETURN FALSE
|
|
ENDFUNC
|
|
|
|
// do mission help text
|
|
FUNC BOOL DO_MISSION_HELP_TEXT(STRING sHelpText, BOOL bForever = FALSE, INT iTime = -1)
|
|
IF NOT IS_HELP_MESSAGE_BEING_DISPLAYED()
|
|
IF CAN_ADVANCE_MISSION()
|
|
IF NOT bForever
|
|
PRINT_HELP(sHelpText, iTime)
|
|
ELSE
|
|
PRINT_HELP_FOREVER(sHelpText)
|
|
ENDIF
|
|
RETURN TRUE
|
|
ENDIF
|
|
ENDIF
|
|
RETURN FALSE
|
|
ENDFUNC
|
|
|
|
// do mission speech
|
|
FUNC BOOL DO_MISSION_SPEECH(STRING sSpeech, BOOL bSupercedeText = FALSE, INT iLine = 0, BOOL bAllowOverrideSpeech = FALSE, BOOL bDisplaySubtitles = TRUE, BOOL bFromSpecifiedLine = FALSE)
|
|
IF bSupercedeText OR NOT IS_MESSAGE_BEING_DISPLAYED() OR NOT IS_SUBTITLE_PREFERENCE_SWITCHED_ON()
|
|
IF NOT IS_ANY_CONVERSATION_ONGOING_OR_QUEUED()
|
|
OR bAllowOverrideSpeech
|
|
IF CAN_ADVANCE_MISSION()
|
|
enumSubtitlesState subtitlesState
|
|
IF bDisplaySubtitles
|
|
subtitlesState = DISPLAY_SUBTITLES
|
|
ELSE
|
|
subtitlesState = DO_NOT_DISPLAY_SUBTITLES
|
|
ENDIF
|
|
|
|
IF iLine = 0
|
|
RETURN CREATE_CONVERSATION(snatchAndGrabConversation, "FBI2AUD", sSpeech, CONV_PRIORITY_HIGH, subtitlesState)
|
|
ELSE
|
|
TEXT_LABEL tLine
|
|
tLine = sSpeech
|
|
tLine+="_"
|
|
tLine+=iLine
|
|
IF NOT bFromSpecifiedLine
|
|
RETURN PLAY_SINGLE_LINE_FROM_CONVERSATION(snatchAndGrabConversation, "FBI2AUD", sSpeech, tLine, CONV_PRIORITY_HIGH, subtitlesState)
|
|
ELSE
|
|
RETURN CREATE_CONVERSATION_FROM_SPECIFIC_LINE(snatchAndGrabConversation, "FBI2AUD", 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)
|
|
IF CAN_ADVANCE_MISSION()
|
|
RETURN CREATE_BLIP_FOR_PED(ped, isEnemyPed)
|
|
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
|
|
|
|
FUNC BOOL SHOULD_USE_MISSION_START_VEHICLE_AT_END()
|
|
IF IS_REPLAY_START_VEHICLE_AVAILABLE()
|
|
IF IS_REPLAY_START_VEHICLE_UNDER_SIZE_LIMIT(GET_DEFAULT_ALLOWABLE_VEHICLE_SIZE_VECTOR())
|
|
RETURN TRUE
|
|
ENDIF
|
|
ENDIF
|
|
|
|
RETURN FALSE
|
|
ENDFUNC
|
|
|
|
FUNC STRING GET_RECORD_PREFIX()
|
|
RETURN "M_FIB2"
|
|
ENDFUNC
|
|
|
|
PROC WAIT_WITH_RECORD()
|
|
WAIT(0)
|
|
REPLAY_CHECK_FOR_EVENT_THIS_FRAME(GET_RECORD_PREFIX())
|
|
ENDPROC
|
|
|
|
// get model for a snatch and grab model enum
|
|
FUNC MODEL_NAMES GET_MODEL_FOR_SNATCH_AND_GRAB_MODEL_ENUM(SNATCH_AND_GRAB_MODEL_ENUM sagModel)
|
|
SWITCH sagModel
|
|
CASE SAGM_MICHAEL
|
|
RETURN GET_PLAYER_PED_MODEL(CHAR_MICHAEL)
|
|
BREAK
|
|
CASE SAGM_FRANKLIN
|
|
RETURN GET_PLAYER_PED_MODEL(CHAR_FRANKLIN)
|
|
BREAK
|
|
CASE SAGM_TREVOR
|
|
RETURN GET_PLAYER_PED_MODEL(CHAR_TREVOR)
|
|
BREAK
|
|
CASE SAGM_DAVE
|
|
RETURN GET_NPC_PED_MODEL(CHAR_DAVE)
|
|
BREAK
|
|
CASE SAGM_STEVE
|
|
RETURN GET_NPC_PED_MODEL(CHAR_STEVE)
|
|
BREAK
|
|
CASE SAGM_ANDREAS
|
|
RETURN GET_NPC_PED_MODEL(CHAR_ANDREAS)
|
|
BREAK
|
|
CASE SAGM_PRISONER_HIGH
|
|
RETURN CS_MRK
|
|
BREAK
|
|
CASE SAGM_PRISONER_LOW
|
|
RETURN IG_MRK
|
|
BREAK
|
|
CASE SAGM_GUARD
|
|
RETURN S_M_M_CIASEC_01
|
|
BREAK
|
|
case SAGM_PILOT
|
|
RETURN S_M_M_PILOT_02
|
|
break
|
|
CASE SAGM_MICHELLE
|
|
RETURN CS_MICHELLE
|
|
BREAK
|
|
CASE SAGM_FBI
|
|
RETURN IG_FBISUIT_01
|
|
BREAK
|
|
CASE SAGM_FBIEND
|
|
RETURN S_M_M_FIBOFFICE_01
|
|
BREAK
|
|
CASE SAGM_CHOPPER
|
|
RETURN FROGGER
|
|
BREAK
|
|
CASE SAGM_ENEMY_CHOPPER
|
|
RETURN BUZZARD
|
|
BREAK
|
|
CASE SAGM_MICHAEL_CAR
|
|
RETURN GET_NPC_VEH_MODEL(CHAR_DAVE)
|
|
BREAK
|
|
// CASE SAGM_TREVOR_JEEP
|
|
// RETURN GET_PLAYER_VEH_MODEL(CHAR_TREVOR)
|
|
// BREAK
|
|
CASE SAGM_FRANKLIN_BIKE
|
|
PED_VEH_DATA_STRUCT sVehData
|
|
GET_PLAYER_VEH_DATA(CHAR_FRANKLIN, sVehData, VEHICLE_TYPE_BIKE)
|
|
RETURN sVehData.model
|
|
BREAK
|
|
CASE SAGM_FBI_VAN
|
|
RETURN BURRITO
|
|
BREAK
|
|
CASE SAGM_FBI_CAR
|
|
RETURN FBI2
|
|
BREAK
|
|
CASE SAGM_UTIL_TRUCK_1
|
|
RETURN UTILLITRUCK2
|
|
BREAK
|
|
CASE SAGM_UTIL_TRUCK_2
|
|
RETURN UTILLITRUCK3
|
|
BREAK
|
|
CASE SAGM_DRIVE_AWAY_CAR
|
|
IF SHOULD_USE_MISSION_START_VEHICLE_AT_END()
|
|
RETURN GET_REPLAY_START_VEHICLE_MODEL()
|
|
ELSE
|
|
RETURN VOLTIC
|
|
ENDIF
|
|
BREAK
|
|
//CASE SAGM_HOOK
|
|
// RETURN PROP_ROPE_HOOK_01
|
|
//BREAK
|
|
//CASE SAGM_BLOCK
|
|
// RETURN PROP_BOX_WOOD08A
|
|
//BREAK
|
|
CASE SAGM_HARNESS
|
|
RETURN GET_RAPPEL_ANCHOR_MODEL_NAME()
|
|
BREAK
|
|
CASE SAGM_PULLEY
|
|
RETURN GET_RAPPEL_PULLEY_MODEL_NAME()
|
|
BREAK
|
|
CASE SAGM_TORCH
|
|
RETURN PROP_CS_POLICE_TORCH
|
|
BREAK
|
|
CASE SAGM_CHAIR
|
|
RETURN V_CORP_OFFCHAIR
|
|
BREAK
|
|
CASE SAGM_COFFEE
|
|
RETURN P_ING_COFFEECUP_01
|
|
BREAK
|
|
ENDSWITCH
|
|
|
|
RETURN DUMMY_MODEL_FOR_SCRIPT
|
|
ENDFUNC
|
|
|
|
// get a weapon enum as a weapontype
|
|
FUNC WEAPON_TYPE GET_SNATCH_AND_GRAB_WEAPON_TYPE(SNATCH_AND_GRAB_WEAPON_ENUM weapon)
|
|
SWITCH weapon
|
|
CASE SAG_WEAPON_MICHAEL_PISTOL
|
|
RETURN WEAPONTYPE_APPISTOL
|
|
BREAK
|
|
CASE SAG_WEAPON_CIA_PISTOL
|
|
RETURN WEAPONTYPE_PISTOL
|
|
BREAK
|
|
CASE SAG_WEAPON_CIA_SMG
|
|
RETURN WEAPONTYPE_SMG
|
|
BREAK
|
|
CASE SAG_WEAPON_CIA_HELI
|
|
RETURN WEAPONTYPE_CARBINERIFLE
|
|
BREAK
|
|
CASE SAG_WEAPON_SNIPER_RIFLE
|
|
RETURN WEAPONTYPE_HEAVYSNIPER
|
|
BREAK
|
|
CASE SAG_WEAPON_MICHAEL_RIFLE
|
|
RETURN WEAPONTYPE_ADVANCEDRIFLE
|
|
BREAK
|
|
ENDSWITCH
|
|
|
|
RETURN WEAPONTYPE_UNARMED
|
|
ENDFUNC
|
|
|
|
// suppress vehicles
|
|
PROC SUPPRESS_MISSION_MODELS(BOOL bSuppress)
|
|
SET_VEHICLE_MODEL_IS_SUPPRESSED(GET_MODEL_FOR_SNATCH_AND_GRAB_MODEL_ENUM(SAGM_MICHAEL_CAR), bSuppress)
|
|
SET_VEHICLE_MODEL_IS_SUPPRESSED(GET_MODEL_FOR_SNATCH_AND_GRAB_MODEL_ENUM(SAGM_CHOPPER), bSuppress)
|
|
SET_VEHICLE_MODEL_IS_SUPPRESSED(GET_MODEL_FOR_SNATCH_AND_GRAB_MODEL_ENUM(SAGM_ENEMY_CHOPPER), bSuppress)
|
|
SET_VEHICLE_MODEL_IS_SUPPRESSED(GET_MODEL_FOR_SNATCH_AND_GRAB_MODEL_ENUM(SAGM_FBI_VAN), bSuppress)
|
|
SET_VEHICLE_MODEL_IS_SUPPRESSED(GET_MODEL_FOR_SNATCH_AND_GRAB_MODEL_ENUM(SAGM_FRANKLIN_BIKE), bSuppress)
|
|
SET_VEHICLE_MODEL_IS_SUPPRESSED(GET_MODEL_FOR_SNATCH_AND_GRAB_MODEL_ENUM(SAGM_UTIL_TRUCK_1), bSuppress)
|
|
SET_VEHICLE_MODEL_IS_SUPPRESSED(GET_MODEL_FOR_SNATCH_AND_GRAB_MODEL_ENUM(SAGM_UTIL_TRUCK_2), bSuppress)
|
|
|
|
SET_VEHICLE_MODEL_IS_SUPPRESSED(MAVERICK, bSuppress)
|
|
SET_VEHICLE_MODEL_IS_SUPPRESSED(POLMAV, bSuppress)
|
|
SET_VEHICLE_MODEL_IS_SUPPRESSED(BUZZARD2, bSuppress)
|
|
SET_VEHICLE_MODEL_IS_SUPPRESSED(CARGOBOB, bSuppress)
|
|
SET_VEHICLE_MODEL_IS_SUPPRESSED(ANNIHILATOR, bSuppress)
|
|
|
|
SET_PED_MODEL_IS_SUPPRESSED(GET_MODEL_FOR_SNATCH_AND_GRAB_MODEL_ENUM(SAGM_DAVE), bSuppress)
|
|
SET_PED_MODEL_IS_SUPPRESSED(GET_MODEL_FOR_SNATCH_AND_GRAB_MODEL_ENUM(SAGM_STEVE), bSuppress)
|
|
SET_PED_MODEL_IS_SUPPRESSED(GET_MODEL_FOR_SNATCH_AND_GRAB_MODEL_ENUM(SAGM_ANDREAS), bSuppress)
|
|
SET_PED_MODEL_IS_SUPPRESSED(GET_MODEL_FOR_SNATCH_AND_GRAB_MODEL_ENUM(SAGM_MICHELLE), bSuppress)
|
|
SET_PED_MODEL_IS_SUPPRESSED(GET_MODEL_FOR_SNATCH_AND_GRAB_MODEL_ENUM(SAGM_GUARD), bSuppress)
|
|
SET_PED_MODEL_IS_SUPPRESSED(GET_MODEL_FOR_SNATCH_AND_GRAB_MODEL_ENUM(SAGM_PILOT), bSuppress)
|
|
SET_PED_MODEL_IS_SUPPRESSED(GET_MODEL_FOR_SNATCH_AND_GRAB_MODEL_ENUM(SAGM_PRISONER_HIGH), bSuppress)
|
|
SET_PED_MODEL_IS_SUPPRESSED(GET_MODEL_FOR_SNATCH_AND_GRAB_MODEL_ENUM(SAGM_FBI), bSuppress)
|
|
SET_PED_MODEL_IS_SUPPRESSED(GET_MODEL_FOR_SNATCH_AND_GRAB_MODEL_ENUM(SAGM_FBIEND), bSuppress)
|
|
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
|
|
|
|
// remove blips
|
|
PROC REMOVE_ALL_BLIPS()
|
|
INT i
|
|
|
|
IF DOES_BLIP_EXIST(vehicleBlip)
|
|
REMOVE_BLIP(vehicleBlip)
|
|
ENDIF
|
|
IF DOES_BLIP_EXIST(getToBlip)
|
|
REMOVE_BLIP(getToBlip)
|
|
ENDIF
|
|
g_sMagDemoFBI2Entities.bBlipActive = FALSE
|
|
|
|
IF DOES_BLIP_EXIST(buddyBlip)
|
|
REMOVE_BLIP(buddyBlip)
|
|
ENDIF
|
|
REPEAT NUMBER_GUARDS i
|
|
IF DOES_BLIP_EXIST(guardBlip[i])
|
|
REMOVE_BLIP(guardBlip[i])
|
|
ENDIF
|
|
ENDREPEAT
|
|
REPEAT NUMBER_REINFORCEMENTS i
|
|
IF DOES_BLIP_EXIST(reinforcementBlip[i])
|
|
REMOVE_BLIP(reinforcementBlip[i])
|
|
ENDIF
|
|
ENDREPEAT
|
|
REPEAT NUMBER_ENEMY_CHOPPERS i
|
|
IF DOES_BLIP_EXIST(enemyChopperBlip[i])
|
|
REMOVE_BLIP(enemyChopperBlip[i])
|
|
ENDIF
|
|
ENDREPEAT
|
|
IF DOES_BLIP_EXIST(playerChopperBlip)
|
|
REMOVE_BLIP(playerChopperBlip)
|
|
ENDIF
|
|
IF DOES_BLIP_EXIST(franklinSniperBlip)
|
|
REMOVE_BLIP(franklinSniperBlip)
|
|
ENDIF
|
|
ENDPROC
|
|
|
|
// which ped is michael?
|
|
FUNC PED_INDEX GET_MICHAEL_PED()
|
|
IF GET_CURRENT_PLAYER_PED_ENUM() = CHAR_MICHAEL
|
|
RETURN PLAYER_PED_ID()
|
|
ELSE
|
|
RETURN sSelectorPeds.pedID[SELECTOR_PED_MICHAEL]
|
|
ENDIF
|
|
ENDFUNC
|
|
|
|
// which ped is trevor?
|
|
FUNC PED_INDEX GET_TREVOR_PED()
|
|
IF GET_CURRENT_PLAYER_PED_ENUM() = CHAR_TREVOR
|
|
RETURN PLAYER_PED_ID()
|
|
ELSE
|
|
RETURN sSelectorPeds.pedID[SELECTOR_PED_TREVOR]
|
|
ENDIF
|
|
ENDFUNC
|
|
|
|
// which ped is franklin?
|
|
FUNC PED_INDEX GET_FRANKLIN_PED()
|
|
IF GET_CURRENT_PLAYER_PED_ENUM() = CHAR_FRANKLIN
|
|
RETURN PLAYER_PED_ID()
|
|
ELSE
|
|
RETURN sSelectorPeds.pedID[SELECTOR_PED_FRANKLIN]
|
|
ENDIF
|
|
ENDFUNC
|
|
|
|
// use stream volume for office
|
|
PROC DO_STREAM_VOLUME_ON_OFFICE(BOOL bUseVolume)
|
|
IF bUseVolume
|
|
IF IS_NEW_LOAD_SCENE_ACTIVE()
|
|
NEW_LOAD_SCENE_STOP()
|
|
ENDIF
|
|
officeVolume = STREAMVOL_CREATE_SPHERE(<<115.08, -619.93, 207.00>>, 5.0, FLAG_COLLISIONS_MOVER | FLAG_MAPDATA)
|
|
ELSE
|
|
IF NOT IS_NEW_LOAD_SCENE_ACTIVE()
|
|
STREAMVOL_DELETE(officeVolume)
|
|
ENDIF
|
|
ENDIF
|
|
ENDPROC
|
|
|
|
// headsets
|
|
PROC SET_PLAYER_PED_WITH_HEADSET(enumCharacterList headSetCharacter, BOOL bHasHeadset)
|
|
PED_INDEX headsetPed
|
|
PED_COMP_NAME_ENUM componentEnum
|
|
SWITCH headSetCharacter
|
|
CASE CHAR_MICHAEL
|
|
componentEnum = PROPS_P0_HEADSET
|
|
BREAK
|
|
CASE CHAR_FRANKLIN
|
|
componentEnum = PROPS_P1_HEADSET
|
|
BREAK
|
|
CASE CHAR_TREVOR
|
|
componentEnum = PROPS_P2_HEADSET
|
|
BREAK
|
|
ENDSWITCH
|
|
|
|
IF GET_CURRENT_PLAYER_PED_ENUM() = headSetCharacter
|
|
headsetPed = PLAYER_PED_ID()
|
|
ELSE
|
|
headsetPed = sSelectorPeds.pedID[GET_SELECTOR_SLOT_FROM_PLAYER_PED_ENUM(headSetCharacter)]
|
|
ENDIF
|
|
|
|
IF NOT IS_PED_INJURED(headsetPed)
|
|
IF bHasHeadset
|
|
SET_PED_COMP_ITEM_CURRENT_SP(headsetPed, COMP_TYPE_PROPS, componentEnum)
|
|
ELSE
|
|
REMOVE_PED_COMP_ITEM_SP(headsetPed, COMP_TYPE_PROPS, componentEnum)
|
|
ENDIF
|
|
ENDIF
|
|
ENDPROC
|
|
|
|
// switch off roads for mission
|
|
PROC SET_SNATCH_AND_GRAB_ROADS(BOOL bRoads)
|
|
INT i
|
|
VECTOR vMin
|
|
VECTOR vMax
|
|
|
|
REPEAT 2 i
|
|
SWITCH i
|
|
CASE 0
|
|
vMin = <<-375.94440, -548.54968, -100.0>>
|
|
vMax = <<244.94885, -449.56308, 39.3>>
|
|
BREAK
|
|
CASE 1
|
|
vMin = <<1337.56860, -2129.30542, -100.69554>>
|
|
vMax = <<1440.82471, -2028.34973, 100.23717>>
|
|
BREAK
|
|
ENDSWITCH
|
|
|
|
IF bRoads
|
|
SET_ROADS_BACK_TO_ORIGINAL(vMin, vMax)
|
|
ELSE
|
|
SET_ROADS_IN_AREA(vMin, vMax, FALSE)
|
|
ENDIF
|
|
ENDREPEAT
|
|
ENDPROC
|
|
|
|
// disable/reenable cargens
|
|
PROC ENABLE_CARGENS_FOR_MISSION(BOOL bEnable)
|
|
SET_ALL_VEHICLE_GENERATORS_ACTIVE_IN_AREA(<<76.37175, -676.25598, 28.27041>>, <<93.24977, -660.14941, 53.22037>>, bEnable)
|
|
ENDPROC
|
|
|
|
FUNC STRING GET_SNATCH_AND_GRAB_AUDIO_SCENE_AS_STRING(SNATCH_AND_GRAB_AUDIO_SCENE_ENUM thisScene)
|
|
SWITCH thisScene
|
|
CASE SNATCH_AND_GRAB_AUDIO_SCENE_DRIVE_TO_LOT
|
|
RETURN "FBI_2_DRIVE_TO_LOT"
|
|
BREAK
|
|
CASE SNATCH_AND_GRAB_AUDIO_SCENE_FLY_TO_AGENCY
|
|
RETURN "FBI_2_FLY_TO_AGENCY"
|
|
BREAK
|
|
CASE SNATCH_AND_GRAB_AUDIO_SCENE_FOCUS_ON_ROOF
|
|
RETURN "FBI_2_FOCUS_ON_ROOF"
|
|
BREAK
|
|
CASE SNATCH_AND_GRAB_AUDIO_SCENE_RAPPEL
|
|
RETURN "SNATCH_AND_GRAB_RAPPEL"
|
|
BREAK
|
|
CASE SNATCH_AND_GRAB_AUDIO_SCENE_INDOOR
|
|
RETURN "SNATCH_AND_GRAB_INDOOR"
|
|
BREAK
|
|
CASE SNATCH_AND_GRAB_AUDIO_SCENE_BREAK_THE_GLASS
|
|
RETURN "FBI_2_BREAK_THE_GLASS"
|
|
BREAK
|
|
CASE SNATCH_AND_GRAB_AUDIO_SCENE_MR_K_HOSTAGE
|
|
RETURN "FBI_2_MR_K_HOSTAGE"
|
|
BREAK
|
|
CASE SNATCH_AND_GRAB_AUDIO_SCENE_FRANKLIN_SNIPE_ENEMIES
|
|
RETURN "FBI_2_FRANKLIN_SNIPE_ENEMIES"
|
|
BREAK
|
|
CASE SNATCH_AND_GRAB_AUDIO_SCENE_MICHAEL_SHOOT_ENEMIES
|
|
RETURN "FBI_2_MICHAEL_SHOOT_ENEMIES"
|
|
BREAK
|
|
CASE SNATCH_AND_GRAB_AUDIO_SCENE_CHOPPERS_ARRIVE_FRANKLIN
|
|
RETURN "FBI_2_CHOPPERS_ARRIVE_FRANKLIN"
|
|
BREAK
|
|
CASE SNATCH_AND_GRAB_AUDIO_SCENE_CHOPPERS_ARRIVE_MICHAEL
|
|
RETURN "FBI_2_CHOPPERS_ARRIVE_MICHAEL"
|
|
BREAK
|
|
CASE SNATCH_AND_GRAB_AUDIO_SCENE_CHOPPERS_ARRIVE_TREVOR
|
|
RETURN "FBI_2_CHOPPERS_ARRIVE_TREVOR"
|
|
BREAK
|
|
CASE SNATCH_AND_GRAB_AUDIO_SCENE_FLY_BACK_AS_TREVOR
|
|
RETURN "FBI_2_FLY_BACK_AS_TREVOR"
|
|
BREAK
|
|
CASE SNATCH_AND_GRAB_AUDIO_SCENE_FLY_BACK_AS_MICHAEL
|
|
RETURN "FBI_2_RIDE_BACK_AS_MICHAEL"
|
|
BREAK
|
|
CASE SNATCH_AND_GRAB_AUDIO_SCENE_LAND_THE_HELI
|
|
RETURN "FBI_2_LAND_THE_HELI"
|
|
BREAK
|
|
ENDSWITCH
|
|
|
|
RETURN ""
|
|
ENDFUNC
|
|
|
|
// start train crash audio scene
|
|
FUNC BOOL START_SNATCH_AND_GRAB_AUDIO_SCENE(SNATCH_AND_GRAB_AUDIO_SCENE_ENUM thisScene)
|
|
RETURN START_AUDIO_SCENE(GET_SNATCH_AND_GRAB_AUDIO_SCENE_AS_STRING(thisScene))
|
|
ENDFUNC
|
|
|
|
// stop train crash audio scene
|
|
PROC STOP_SNATCH_AND_GRAB_AUDIO_SCENE(SNATCH_AND_GRAB_AUDIO_SCENE_ENUM thisScene)
|
|
STOP_AUDIO_SCENE(GET_SNATCH_AND_GRAB_AUDIO_SCENE_AS_STRING(thisScene))
|
|
ENDPROC
|
|
|
|
// stop all train crash audio scenes
|
|
PROC STOP_ALL_SNATCH_AND_GRAB_AUDIO_SCENES()
|
|
INT i
|
|
REPEAT COUNT_OF(SNATCH_AND_GRAB_AUDIO_SCENE_ENUM) i
|
|
STOP_SNATCH_AND_GRAB_AUDIO_SCENE(INT_TO_ENUM(SNATCH_AND_GRAB_AUDIO_SCENE_ENUM, i))
|
|
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)
|
|
SET_SCRIPTS_SAFE_FOR_CUTSCENE(FALSE)
|
|
KILL_CHASE_HINT_CAM(localChaseHintCamStruct)
|
|
DISABLE_CELLPHONE(FALSE)
|
|
ENDPROC
|
|
|
|
// unfreeze player
|
|
PROC CUSTOM_UNFREEZE_PLAYER()
|
|
IF NOT IS_PED_INJURED(PLAYER_PED_ID())
|
|
IF NOT IS_ENTITY_ATTACHED(PLAYER_PED_ID())
|
|
FREEZE_ENTITY_POSITION(PLAYER_PED_ID(), FALSE)
|
|
ENDIF
|
|
ENDIF
|
|
ENDPROC
|
|
|
|
// delete enemy chopper
|
|
PROC DELETE_ENEMY_CHOPPER()
|
|
INT i
|
|
REPEAT COUNT_OF(enemyChopperPed) i
|
|
IF DOES_ENTITY_EXIST(enemyChopperPed[i])
|
|
DELETE_PED(enemyChopperPed[i])
|
|
ENDIF
|
|
ENDREPEAT
|
|
|
|
REPEAT NUMBER_ENEMY_CHOPPERS i
|
|
IF DOES_ENTITY_EXIST(enemyChopperVehicle[i])
|
|
DELETE_VEHICLE(enemyChopperVehicle[i])
|
|
ENDIF
|
|
ENDREPEAT
|
|
ENDPROC
|
|
|
|
// delete everything
|
|
PROC DELETE_ALL_ENTITIES_IN_FADE()
|
|
INT i
|
|
|
|
IF NOT IS_PED_INJURED(PLAYER_PED_ID())
|
|
SET_ENTITY_COORDS(PLAYER_PED_ID(), <<1315.36, -1979.53, 45.69>>)
|
|
ENDIF
|
|
|
|
REPEAT 3 i
|
|
SET_SELECTOR_PED_DAMAGED(sSelectorPeds, INT_TO_ENUM(SELECTOR_SLOTS_ENUM, i), FALSE)
|
|
IF DOES_ENTITY_EXIST(sSelectorPeds.pedID[i])
|
|
DELETE_PED(sSelectorPeds.pedID[i])
|
|
ENDIF
|
|
ENDREPEAT
|
|
|
|
IF DOES_ENTITY_EXIST(davePed)
|
|
DELETE_PED(davePed)
|
|
ENDIF
|
|
|
|
IF DOES_ENTITY_EXIST(prisonerPed)
|
|
DELETE_PED(prisonerPed)
|
|
ENDIF
|
|
|
|
IF DOES_ENTITY_EXIST(michellePed)
|
|
DELETE_PED(michellePed)
|
|
ENDIF
|
|
|
|
IF DOES_ENTITY_EXIST(dummyFranklinPed)
|
|
DELETE_PED(dummyFranklinPed)
|
|
ENDIF
|
|
|
|
REPEAT NUMBER_FBI_AGENTS i
|
|
IF DOES_ENTITY_EXIST(fbiPed[i])
|
|
DELETE_PED(fbiPed[i])
|
|
ENDIF
|
|
ENDREPEAT
|
|
|
|
IF DOES_ENTITY_EXIST(fbiVanVehicle)
|
|
DELETE_VEHICLE(fbiVanVehicle)
|
|
ENDIF
|
|
|
|
REPEAT NUMBER_ENEMY_CHOPPERS i
|
|
IF DOES_ENTITY_EXIST(enemyChopperVehicle[i])
|
|
DELETE_VEHICLE(enemyChopperVehicle[i])
|
|
ENDIF
|
|
ENDREPEAT
|
|
|
|
REPEAT COUNT_OF(utilTruckVehicle) i
|
|
IF DOES_ENTITY_EXIST(utilTruckVehicle[i])
|
|
DELETE_VEHICLE(utilTruckVehicle[i])
|
|
ENDIF
|
|
ENDREPEAT
|
|
|
|
REPEAT NUMBER_GUARDS i
|
|
IF DOES_ENTITY_EXIST(guardPed[i])
|
|
DELETE_PED(guardPed[i])
|
|
ENDIF
|
|
ENDREPEAT
|
|
|
|
REPEAT NUMBER_REINFORCEMENTS i
|
|
IF DOES_ENTITY_EXIST(reinforcementPed[i])
|
|
DELETE_PED(reinforcementPed[i])
|
|
ENDIF
|
|
ENDREPEAT
|
|
|
|
REPEAT NUMBER_ENEMY_CHOPPERS*3 i
|
|
IF DOES_ENTITY_EXIST(enemyChopperPed[i])
|
|
DELETE_PED(enemyChopperPed[i])
|
|
ENDIF
|
|
ENDREPEAT
|
|
|
|
REPEAT COUNT_OF(snatchAndGrabVehicle) i
|
|
IF DOES_ENTITY_EXIST(snatchAndGrabVehicle[i])
|
|
DELETE_VEHICLE(snatchAndGrabVehicle[i])
|
|
ENDIF
|
|
ENDREPEAT
|
|
|
|
REPEAT COUNT_OF(trafficVehicle) i
|
|
IF DOES_ENTITY_EXIST(trafficVehicle[i])
|
|
DELETE_VEHICLE(trafficVehicle[i])
|
|
ENDIF
|
|
ENDREPEAT
|
|
|
|
WAIT(0)
|
|
|
|
IF DOES_ENTITY_EXIST(harnessObject)
|
|
DELETE_OBJECT(harnessObject)
|
|
ENDIF
|
|
IF DOES_ENTITY_EXIST(torchObject)
|
|
DELETE_OBJECT(torchObject)
|
|
ENDIF
|
|
IF DOES_ENTITY_EXIST(chairObject)
|
|
DELETE_OBJECT(chairObject)
|
|
ENDIF
|
|
REPEAT NUMBER_FROZEN_CHAIRS i
|
|
IF DOES_ENTITY_EXIST(frozenChairObject[i])
|
|
DELETE_OBJECT(frozenChairObject[i])
|
|
ENDIF
|
|
ENDREPEAT
|
|
|
|
//IF DOES_ENTITY_EXIST(hookObject)
|
|
// DELETE_OBJECT(hookObject)
|
|
//ENDIF
|
|
IF DOES_ENTITY_EXIST(franklinAnchorObject)
|
|
DELETE_OBJECT(franklinAnchorObject)
|
|
ENDIF
|
|
IF DOES_ENTITY_EXIST(michaelGunObject)
|
|
DELETE_OBJECT(michaelGunObject)
|
|
ENDIF
|
|
|
|
IF DOES_CAM_EXIST(staticCam)
|
|
DESTROY_CAM(staticCam)
|
|
ENDIF
|
|
|
|
IF DOES_CAM_EXIST(animCam)
|
|
DESTROY_CAM(animCam)
|
|
ENDIF
|
|
|
|
//IF DOES_CAM_EXIST(followCam)
|
|
// DESTROY_CAM(followCam)
|
|
//ENDIF
|
|
|
|
IF DOES_CAM_EXIST(ropeCam)
|
|
DESTROY_CAM(ropeCam)
|
|
ENDIF
|
|
|
|
DESTROY_PUSH_IN_CAMS(pushInData)
|
|
ENDPROC
|
|
|
|
PROC CLEANUP_MICHAEL_WEAPON_OVERRIDES()
|
|
PED_INDEX michaelPed = GET_MICHAEL_PED()
|
|
|
|
SET_PED_INFINITE_AMMO(PLAYER_PED_ID(), FALSE)
|
|
|
|
IF DOES_ENTITY_EXIST(michaelPed)
|
|
SET_PED_INFINITE_AMMO(michaelPed, FALSE)
|
|
ENDIF
|
|
|
|
IF NOT IS_PED_INJURED(PLAYER_PED_ID())
|
|
SET_PED_INFINITE_AMMO_CLIP(PLAYER_PED_ID(), FALSE)
|
|
RESET_PED_IN_VEHICLE_CONTEXT(PLAYER_PED_ID())
|
|
CLEAR_PED_DRIVE_BY_CLIPSET_OVERRIDE(PLAYER_PED_ID())
|
|
SET_PLAYER_FORCED_AIM(PLAYER_ID(), FALSE)
|
|
SET_PED_CAN_SWITCH_WEAPON(PLAYER_PED_ID(), TRUE)
|
|
ENDIF
|
|
|
|
IF NOT IS_PED_INJURED(michaelPed)
|
|
SET_PED_INFINITE_AMMO_CLIP(michaelPed, FALSE)
|
|
RESET_PED_IN_VEHICLE_CONTEXT(michaelPed)
|
|
CLEAR_PED_DRIVE_BY_CLIPSET_OVERRIDE(michaelPed)
|
|
SET_PED_CAN_SWITCH_WEAPON(michaelPed, TRUE)
|
|
ENDIF
|
|
|
|
IF iSavedAmmo >= 0
|
|
PRINTINT(iSavedAmmo) printnl()
|
|
|
|
IF DOES_ENTITY_EXIST(michaelPed)
|
|
IF HAS_PED_GOT_WEAPON(michaelPed, WEAPONTYPE_CARBINERIFLE)
|
|
IF NOT IS_PED_INJURED(michaelPed)
|
|
SET_PED_AMMO(michaelPed, WEAPONTYPE_CARBINERIFLE, iSavedAmmo)
|
|
ENDIF
|
|
SET_PED_INFINITE_AMMO(michaelPed, FALSE, WEAPONTYPE_CARBINERIFLE)
|
|
ENDIF
|
|
|
|
IF HAS_PED_GOT_WEAPON(michaelPed, WEAPONTYPE_ASSAULTRIFLE)
|
|
IF NOT IS_PED_INJURED(michaelPed)
|
|
SET_PED_AMMO(michaelPed, WEAPONTYPE_ASSAULTRIFLE, iSavedAmmo)
|
|
ENDIF
|
|
SET_PED_INFINITE_AMMO(michaelPed, FALSE, WEAPONTYPE_ASSAULTRIFLE)
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF HAS_PED_GOT_WEAPON(PLAYER_PED_ID(), WEAPONTYPE_CARBINERIFLE)
|
|
SET_PED_INFINITE_AMMO(PLAYER_PED_ID(), FALSE, WEAPONTYPE_CARBINERIFLE)
|
|
ENDIF
|
|
|
|
IF HAS_PED_GOT_WEAPON(PLAYER_PED_ID(), WEAPONTYPE_ASSAULTRIFLE)
|
|
SET_PED_INFINITE_AMMO(PLAYER_PED_ID(), FALSE, WEAPONTYPE_ASSAULTRIFLE)
|
|
ENDIF
|
|
|
|
IF HAS_PED_GOT_WEAPON(PLAYER_PED_ID(), GET_SNATCH_AND_GRAB_WEAPON_TYPE(SAG_WEAPON_MICHAEL_RIFLE))
|
|
SET_PED_INFINITE_AMMO(PLAYER_PED_ID(), FALSE, GET_SNATCH_AND_GRAB_WEAPON_TYPE(SAG_WEAPON_MICHAEL_RIFLE))
|
|
REMOVE_WEAPON_FROM_PED(PLAYER_PED_ID(), GET_SNATCH_AND_GRAB_WEAPON_TYPE(SAG_WEAPON_MICHAEL_RIFLE))
|
|
ENDIF
|
|
|
|
IF DOES_ENTITY_EXIST(michaelPed)
|
|
IF HAS_PED_GOT_WEAPON(michaelPed, WEAPONTYPE_CARBINERIFLE)
|
|
SET_PED_INFINITE_AMMO(michaelPed, FALSE, WEAPONTYPE_CARBINERIFLE)
|
|
ENDIF
|
|
|
|
IF HAS_PED_GOT_WEAPON(michaelPed, WEAPONTYPE_ASSAULTRIFLE)
|
|
SET_PED_INFINITE_AMMO(michaelPed, FALSE, WEAPONTYPE_ASSAULTRIFLE)
|
|
ENDIF
|
|
|
|
IF HAS_PED_GOT_WEAPON(michaelPed, GET_SNATCH_AND_GRAB_WEAPON_TYPE(SAG_WEAPON_MICHAEL_RIFLE))
|
|
SET_PED_INFINITE_AMMO(michaelPed, FALSE, GET_SNATCH_AND_GRAB_WEAPON_TYPE(SAG_WEAPON_MICHAEL_RIFLE))
|
|
REMOVE_WEAPON_FROM_PED(michaelPed, GET_SNATCH_AND_GRAB_WEAPON_TYPE(SAG_WEAPON_MICHAEL_RIFLE))
|
|
ENDIF
|
|
ENDIF
|
|
ENDPROC
|
|
|
|
|
|
// get mission vector
|
|
FUNC VECTOR GET_SNATCH_AND_GRAB_VECTOR(SNATCH_AND_GRAB_VECTOR_ENUM sagVec)
|
|
SWITCH sagVec
|
|
CASE SAGVEC_PLAYER_INIT
|
|
//RETURN <<76.16, -689.51, 43.16>>
|
|
//RETURN <<75.60, -689.83, 43.18>>
|
|
RETURN <<147.91399, -678.00134, 41.02758>>
|
|
BREAK
|
|
CASE SAGVEC_PLAYER_INIT2
|
|
RETURN <<147.9, -678.2, 41.02758>>
|
|
BREAK
|
|
CASE SAGVEC_DAVE_INIT
|
|
RETURN <<148.95930, -677.50409, 41.02758>>
|
|
BREAK
|
|
CASE SAGVEC_DAVE_INIT2
|
|
RETURN <<149.57080, -678.42639, 41.02729>>
|
|
BREAK
|
|
CASE SAGVEC_MICHAEL_CAR_INIT
|
|
// RETURN <<77.70, -689.40, 43.22>>
|
|
RETURN <<84.65, -670.03, 43.73>>
|
|
BREAK
|
|
CASE SAGVEC_CHOPPER_INIT
|
|
RETURN <<1368.4725, -2076.7312, 51.00>>
|
|
BREAK
|
|
CASE SAGVEC_PICKUP_CHOPPER_LEADIN
|
|
// MAKE SAME AS ABOVE
|
|
RETURN <<1368.4725, -2076.7312, 51.685>>
|
|
BREAK
|
|
CASE SAGVEC_CHOPPER_HOVER
|
|
RETURN <<110.62, -619.50, 269.85>>
|
|
BREAK
|
|
CASE SAGVEC_HOVER_TARGET
|
|
RETURN <<111.6, -619.50, 270.85>>
|
|
BREAK
|
|
CASE SAGVEC_TREVOR_INIT
|
|
RETURN <<1373.39, -2072.44, 51.38>>
|
|
BREAK
|
|
CASE SAGVEC_FRANKLIN_INIT
|
|
RETURN <<1373.06, -2079.65, 51.00>>
|
|
BREAK
|
|
CASE SAGVEC_FRANKLIN_SNIPER
|
|
RETURN <<-139.69, -591.94, 207.58>>
|
|
BREAK
|
|
CASE SAGVEC_BIKE_INIT
|
|
RETURN <<1373.42, -2079.67, 51.00>>
|
|
BREAK
|
|
CASE SAGVEC_JEEP_INIT
|
|
RETURN <<1381.31, -2077.68, 51.00>>
|
|
BREAK
|
|
CASE SAGVEC_ROPE_ANCHOR_OFFSET
|
|
RETURN <<-1.20, 0.90, 1.60>>
|
|
BREAK
|
|
CASE SAGVEC_ROPE_ANCHOR_ROT
|
|
RETURN <<0,0,-99.76>>
|
|
BREAK
|
|
CASE SAGVEC_ROPE_WEIGHT_OFFSET
|
|
RETURN <<0.00, 0.00, 3.00>>
|
|
BREAK
|
|
CASE SAGVEC_ROPE_PLAYER_SWING_ATTACH
|
|
//RETURN <<0.00, 0.00, -0.55>>
|
|
RETURN <<0.00, 0.00, 0.0>>
|
|
BREAK
|
|
CASE SAGVEC_ROPE_PRISONER_SWING_ATTACH
|
|
RETURN <<-0.12, 0.165, -0.212>>
|
|
BREAK
|
|
CASE SAGVEC_MEETING_POINT
|
|
//RETURN <<1374.77, -2043.06, 51.06>>
|
|
//RETURN <<1368.54919, -2032.53784, 51.04349>>
|
|
RETURN <<1375.16589, -2065.92920, 50.99826>>
|
|
BREAK
|
|
CASE SAGVEC_WINDOW_FRAME
|
|
RETURN <<111.67, -619.11, 207.60>>
|
|
BREAK
|
|
CASE SAGVEC_WINDOW_FRAME_2
|
|
RETURN <<110.5, -618.5, 207.8>>
|
|
BREAK
|
|
CASE SAGVEC_WINDOW_SWING_RIGHT
|
|
//RETURN <<110.35, -618.2, 206.8>>
|
|
RETURN <<110.15, -618.2, 207.1>>
|
|
BREAK
|
|
CASE SAGVEC_WINDOW_SWING_LEFT
|
|
//RETURN <<111.10, -615.81, 207.10>>
|
|
RETURN <<110.90, -615.81, 207.1>>
|
|
BREAK
|
|
CASE SAGVEC_WINDOW_SOUND
|
|
RETURN <<112.15, -619.09, 206.78>>
|
|
BREAK
|
|
CASE SAGVEC_BREAK_IN
|
|
RETURN <<112.92, -619.09, 205.94>>
|
|
BREAK
|
|
CASE SAGVEC_PRISONER_INIT
|
|
RETURN <<113.47, -619.19, 205.49>>
|
|
BREAK
|
|
CASE SAGVEC_MICHELLE_INIT
|
|
RETURN <<113.77, -619.37, 205.48>>
|
|
BREAK
|
|
CASE SAGVEC_INTERROGATION
|
|
RETURN <<112.082, -619.063, 206.05>>
|
|
BREAK
|
|
CASE SAGVEC_HEADSHOT
|
|
RETURN <<112.85, -619.72, 206.33>>
|
|
BREAK
|
|
CASE SAGVEC_GUARD_DOOR_INSIDE
|
|
RETURN <<117.97, -618.96, 205.05>>
|
|
BREAK
|
|
CASE SAGVEC_GUARD_DOOR_OUTSIDE
|
|
RETURN <<119.57, -619.96, 205.05>>
|
|
BREAK
|
|
CASE SAGVEC_GUARD_ANIM_ORIGIN
|
|
RETURN <<118.704, -620.003, 205.05>>
|
|
BREAK
|
|
CASE SAGVEC_SNIPER
|
|
RETURN <<-137.9, -593.0, 207.55>>
|
|
BREAK
|
|
CASE SAGVEC_REMOTE_VIEW
|
|
// RETURN <<17.39, -602.71, 211.52>> good before draw dist change
|
|
RETURN <<98.25, -617.81, 205.50>>
|
|
BREAK
|
|
CASE SAGVEC_BEHIND_SNIPER
|
|
RETURN <<99.2, -618.0, 206.9>>
|
|
BREAK
|
|
CASE SAGVEC_SNIPER_AI_SHOT_ORIGIN
|
|
RETURN <<-129.43, -561.09, 209.27>>
|
|
BREAK
|
|
CASE SAGVEC_CHASE_END
|
|
RETURN <<173.95, -990.51, 136.94>>
|
|
BREAK
|
|
CASE SAGVEC_DROPOFF
|
|
RETURN <<1373.92822, -2070.67017, 51.00>>
|
|
BREAK
|
|
CASE SAGVEC_DROPOFF_DIMENSIONS
|
|
RETURN <<75,75,85>>
|
|
BREAK
|
|
CASE SAGVEC_DROPOFF_PASS_DIMENSIONS
|
|
RETURN <<15,15,4>>
|
|
BREAK
|
|
CASE SAGVEC_END
|
|
RETURN <<1378.58630, -2074.40503, 50.99809>>
|
|
BREAK
|
|
CASE SAGVEC_MICHAEL_AT_FOOD_COURT
|
|
RETURN <<122.02104, -692.21143, 41.02729>>
|
|
BREAK
|
|
CASE SAGVEC_MOVE_LAST_PLAYER_VEHICLE
|
|
RETURN <<55.089, -750.924, 43.084>>
|
|
BREAK
|
|
ENDSWITCH
|
|
|
|
RETURN <<0,0,0>>
|
|
ENDFUNC
|
|
|
|
|
|
// get an anim dict enum as string
|
|
FUNC STRING GET_SNATCH_AND_GRAB_ANIM_DICT_AS_STRING(SNATCH_AND_GRAB_ANIM_DICT_ENUM animDict)
|
|
SWITCH animDict
|
|
CASE SAG_ANIM_DICT_MISSION
|
|
RETURN "MISSSAGRAB"
|
|
BREAK
|
|
CASE SAG_ANIM_DICT_RAPPEL
|
|
RETURN GET_RAPPEL_ANIM_DICT_NAME()
|
|
BREAK
|
|
CASE SAG_ANIM_DICT_GUARDS
|
|
RETURN "MISSFBI2"
|
|
BREAK
|
|
CASE SAG_ANIM_DICT_CUTSCENES
|
|
RETURN "MISSFBI2CUTS"
|
|
BREAK
|
|
CASE SAG_ANIM_DICT_INTRO
|
|
RETURN "MISSFBI2_intro"
|
|
BREAK
|
|
CASE SAG_ANIM_DICT_TOWER_SEATED
|
|
RETURN "amb@prop_human_seat_computer@male@base"
|
|
BREAK
|
|
CASE SAG_ANIM_DICT_TOWER_SEATED_REACT
|
|
RETURN "amb@prop_human_seat_computer@male@react_shock"
|
|
BREAK
|
|
CASE SAG_ANIM_DICT_TOWER_STANDING
|
|
RETURN "amb@world_human_stand_guard@male@base"
|
|
BREAK
|
|
CASE SAG_ANIM_DICT_TOWER_STANDING_REACT_ENTER_L
|
|
RETURN "reaction@male_stand@small_intro@left"
|
|
BREAK
|
|
CASE SAG_ANIM_DICT_TOWER_STANDING_REACT_ENTER_R
|
|
RETURN "reaction@male_stand@small_intro@right"
|
|
BREAK
|
|
CASE SAG_ANIM_DICT_TOWER_STANDING_REACT_IDLE
|
|
RETURN "reaction@male_stand@small_variations@idle_a"
|
|
BREAK
|
|
CASE SAG_ANIM_DICT_AIM_VARIATIONS
|
|
RETURN "combat@aim_variations@pistol"
|
|
BREAK
|
|
CASE SAG_ANIM_DICT_COMBAT_GLANCES
|
|
RETURN "combat@gestures@pistol@panic"
|
|
BREAK
|
|
CASE SAG_ANIM_DICT_OVER_THERE
|
|
RETURN "combat@gestures@pistol@overthere"
|
|
BREAK
|
|
CASE SAG_ANIM_DICT_PANIC
|
|
RETURN "combat@panic@pistol"
|
|
BREAK
|
|
CASE SAG_ANIM_DICT_BECKON
|
|
RETURN "combat@gestures@pistol@beckon"
|
|
BREAK
|
|
CASE SAG_ANIM_DICT_FOOD_COURT
|
|
RETURN "MISSFBI2@LeadInOut"
|
|
BREAK
|
|
CASE SAG_ANIM_DICT_AT_LOT
|
|
RETURN "MISSFBI2@LeadInOutFBI_2_MCS_1"
|
|
BREAK
|
|
CASE SAG_ANIM_DICT_IN_OFFICE
|
|
RETURN "MISSSAGRAB_INOFFICE"
|
|
BREAK
|
|
CASE SAG_ANIM_DICT_FLY_HOME
|
|
RETURN "MISSSAGRAB_FLYHOME"
|
|
BREAK
|
|
CASE SAG_ANIM_CAM_SHAKE_LIBRARY
|
|
RETURN "shake_cam_all@"
|
|
BREAK
|
|
CASE SAG_ANIM_DICT_SNIPER
|
|
RETURN "missheistdocks2aswitchig_7"
|
|
BREAK
|
|
ENDSWITCH
|
|
|
|
RETURN "invalid!"
|
|
ENDFUNC
|
|
|
|
// cleanup the mission
|
|
PROC MISSION_CLEANUP()
|
|
//IF IS_PED_INJURED(PLAYER_PED_ID())
|
|
TRIGGER_MUSIC_EVENT("FIB2_DEATH_FAIL")
|
|
//ENDIF
|
|
SET_HIDOF_OVERRIDE(FALSE, TRUE, 0, 0, 0, 0)
|
|
|
|
CLEAR_PED_NON_CREATION_AREA()
|
|
SET_PED_PATHS_BACK_TO_ORIGINAL(<<80.15606, -689.07544, 40.22030>>, <<153.51270, -671.06488, 45.02924>>)
|
|
CASCADE_SHADOWS_ENABLE_FREEZER(TRUE)
|
|
|
|
KILL_FACE_TO_FACE_CONVERSATION_DO_NOT_FINISH_LAST_LINE()
|
|
|
|
DISABLE_SELECTOR_QUICK_SWITCH_TO_DAMAGED_PED(FALSE)
|
|
|
|
ROPE_UNLOAD_TEXTURES()
|
|
|
|
DISABLE_CHEAT(CHEAT_TYPE_GIVE_WEAPONS, FALSE)
|
|
|
|
CLEAR_WEATHER_TYPE_PERSIST()
|
|
|
|
SHUTDOWN_PC_SCRIPTED_CONTROLS()
|
|
|
|
OVERRIDE_PLAYER_GROUND_MATERIAL(GET_HASH_KEY("AM_BASE_GLASS_STRONG"),FALSE)
|
|
|
|
DISABLE_DOWNWASH_PTFX(FALSE)
|
|
|
|
//CLEAR_WEATHER_TYPE_PERSIST()
|
|
PAUSE_CLOCK(FALSE)
|
|
|
|
IF STREAMVOL_IS_VALID(foodCourtStreamingVolume)
|
|
STREAMVOL_DELETE(foodCourtStreamingVolume)
|
|
ENDIF
|
|
IF STREAMVOL_IS_VALID(officeVolume)
|
|
STREAMVOL_DELETE(officeVolume)
|
|
ENDIF
|
|
IF STREAMVOL_IS_VALID(sniperVolume)
|
|
STREAMVOL_DELETE(sniperVolume)
|
|
ENDIF
|
|
|
|
NEW_LOAD_SCENE_STOP()
|
|
|
|
STOP_ALL_SNATCH_AND_GRAB_AUDIO_SCENES()
|
|
|
|
REMOVE_MISSION_TEXT()
|
|
KILL_ANY_CONVERSATION()
|
|
//SET_SNATCH_AND_GRAB_ROADS(TRUE)
|
|
ENABLE_CARGENS_FOR_MISSION(TRUE)
|
|
REMOVE_SCENARIO_BLOCKING_AREA(lotScenarioBlocking)
|
|
REMOVE_SCENARIO_BLOCKING_AREA(tableScenarioBlocking)
|
|
REMOVE_SCENARIO_BLOCKING_AREA(rampScenarioBlocking)
|
|
//REMOVE_SCENARIO_BLOCKING_AREA(skyScenarioBlocking)
|
|
|
|
//SET_FRONTEND_RADIO_ACTIVE(TRUE)
|
|
|
|
//SCRIPT_OVERRIDES_WIND_TYPES(FALSE, "","")
|
|
// SET_PLAYER_PED_DATA_IN_CUTSCENES(TRUE)
|
|
|
|
RELEASE_WEAPON_AUDIO()//TEMP
|
|
|
|
REMOVE_PORTAL_SETTINGS_OVERRIDE("V_CIA_PS_WINDOW_UNBROKEN")
|
|
|
|
REMOVE_DOOR_FROM_SYSTEM(DOORHASH_OPEN_DOOR)
|
|
REMOVE_DOOR_FROM_SYSTEM(DOORHASH_CLOSED_DOOR1)
|
|
REMOVE_DOOR_FROM_SYSTEM(DOORHASH_CLOSED_DOOR2)
|
|
|
|
IF g_fSavedMaxMotionBlur > 0.0
|
|
SET_MOTIONBLUR_MAX_VEL_SCALER(g_fSavedMaxMotionBlur)
|
|
ENDIF
|
|
|
|
STOP_SOUND(iDangleSoundID)
|
|
RELEASE_SOUND_ID(iDangleSoundID)
|
|
STOP_SOUND(iSmashSoundID)
|
|
RELEASE_SOUND_ID(iSmashSoundID)
|
|
STOP_SOUND(iRappelWindSoundID)
|
|
RELEASE_SOUND_ID(iRappelWindSoundID)
|
|
STOP_SOUND(iFaintHeliSoundID)
|
|
RELEASE_SOUND_ID(iFaintHeliSoundID)
|
|
STOP_SOUND(iSniperSwitchSoundID)
|
|
RELEASE_SOUND_ID(iSniperSwitchSoundID)
|
|
RELEASE_NAMED_SCRIPT_AUDIO_BANK(GET_MISSION_AUDIO_BANK_NAME())
|
|
|
|
//DELETE_CHECKPOINT(jumpCheckpoint)
|
|
|
|
CLEANUP_MICHAEL_WEAPON_OVERRIDES()
|
|
|
|
// remove heavy sniper from franklin
|
|
PED_INDEX franklinPed = GET_FRANKLIN_PED()
|
|
WEAPON_TYPE sniperWeapon = GET_SNATCH_AND_GRAB_WEAPON_TYPE(SAG_WEAPON_SNIPER_RIFLE)
|
|
IF NOT IS_PED_INJURED(franklinPed)
|
|
IF HAS_PED_GOT_WEAPON(franklinPed, sniperWeapon)
|
|
IF bCheckedInitialSniper
|
|
IF iInitialSniperAmmo > 0
|
|
SET_PED_AMMO(franklinPed, sniperWeapon, iInitialSniperAmmo)
|
|
ELSE
|
|
REMOVE_WEAPON_FROM_PED(franklinPed, sniperWeapon)
|
|
ENDIF
|
|
ELSE
|
|
REMOVE_WEAPON_FROM_PED(franklinPed, sniperWeapon)
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
STORE_PLAYER_PED_WEAPONS(franklinPed)
|
|
|
|
SET_BUILDING_STATE(BUILDINGNAME_IPL_FIB2_TOWER, BUILDINGSTATE_NORMAL)
|
|
remove_ipl("DT1_05_FIB_Reflection")
|
|
PRINTSTRING("remove reflection ipl 4") printnl()
|
|
CASCADE_SHADOWS_SET_CASCADE_BOUNDS_SCALE(CASCADE_SHADOWS_MULTIPLIER_NO_OVERRIDE)
|
|
CASCADE_SHADOWS_SET_ENTITY_TRACKER_SCALE(1.0)
|
|
CASCADE_SHADOWS_SET_AIRCRAFT_MODE(FALSE)
|
|
|
|
SET_PARTICLE_FX_BULLET_IMPACT_SCALE(1.0)
|
|
|
|
IF NOT IS_PED_INJURED(PLAYER_PED_ID())
|
|
SET_PED_CAN_SWITCH_WEAPON(PLAYER_PED_ID(), TRUE)
|
|
TASK_CLEAR_LOOK_AT(PLAYER_PED_ID())
|
|
SET_ENTITY_VISIBLE(PLAYER_PED_ID(), TRUE)
|
|
SET_PED_RELATIONSHIP_GROUP_HASH(PLAYER_PED_ID(), RELGROUPHASH_PLAYER)
|
|
CUSTOM_UNFREEZE_PLAYER()
|
|
ENDIF
|
|
|
|
//IF NOT IS_PED_INJURED(GET_MICHAEL_PED())
|
|
// RESTORE_PLAYER_PED_VARIATIONS(GET_MICHAEL_PED())
|
|
//ENDIF
|
|
|
|
CLEANUP_RAPPEL(rappelData)
|
|
IF DOES_ROPE_EXIST(choppedRope1)
|
|
DELETE_ROPE(choppedRope1)
|
|
ENDIF
|
|
IF DOES_ROPE_EXIST(choppedRope2)
|
|
DELETE_ROPE(choppedRope2)
|
|
ENDIF
|
|
|
|
//IF mocapStreamingStage >= MOCAP_STREAMING_STAGE_WAIT
|
|
REMOVE_CUTSCENE()
|
|
//ENDIF
|
|
|
|
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_FAR_DRAW_VEHICLES(FALSE)
|
|
|
|
// reset budgets
|
|
SET_VEHICLE_POPULATION_BUDGET(3)
|
|
SET_PED_POPULATION_BUDGET(3)
|
|
|
|
IF currentMissionStage = STAGE_RAPPEL_DOWN
|
|
IF bDoGuardsKillMichael
|
|
IF IS_PED_INJURED(PLAYER_PED_ID())
|
|
IF NOT IS_PED_INJURED(guardPed[2])
|
|
TASK_AIM_GUN_AT_COORD(guardPed[2], <<112.85, -619.72, 206.33>>, -1)
|
|
ENDIF
|
|
|
|
IF NOT IS_PED_INJURED(prisonerPed)
|
|
VECTOR vSceneMod = <<0,0,1.05>>
|
|
iSyncScene = CREATE_SYNCHRONIZED_SCENE(GET_SNATCH_AND_GRAB_VECTOR(SAGVEC_INTERROGATION) - vSceneMod, <<0.0, 0.0, INTERROGATION_ROT>>)
|
|
IF NOT IS_PED_INJURED(prisonerPed)
|
|
TASK_SYNCHRONIZED_SCENE(prisonerPed, iSyncScene, GET_SNATCH_AND_GRAB_ANIM_DICT_AS_STRING(SAG_ANIM_DICT_IN_OFFICE), "hostage_low_intro_mrk", NORMAL_BLEND_IN, NORMAL_BLEND_OUT)
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF bInteriorPinned
|
|
IF IS_INTERIOR_READY(officeInterior)
|
|
UNPIN_INTERIOR(officeInterior)
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF IS_NEW_LOAD_SCENE_ACTIVE()
|
|
NEW_LOAD_SCENE_STOP()
|
|
ENDIF
|
|
|
|
DO_STREAM_VOLUME_ON_OFFICE(FALSE)
|
|
|
|
// detach if needed
|
|
IF NOT IS_PED_INJURED(PLAYER_PED_ID())
|
|
SET_ENTITY_PROOFS(PLAYER_PED_ID(), FALSE, FALSE, FALSE, FALSE, FALSE)
|
|
STOP_PED_SPEAKING(PLAYER_PED_ID(), FALSE)
|
|
SET_ENTITY_SHOULD_FREEZE_WAITING_ON_COLLISION(PLAYER_PED_ID(), FALSE)
|
|
CUSTOM_UNFREEZE_PLAYER()
|
|
SET_ENTITY_ONLY_DAMAGED_BY_PLAYER(PLAYER_PED_ID(), FALSE)
|
|
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
|
|
|
|
INT i
|
|
REPEAT NUMBER_FOOD_COURT_CHAIRS i
|
|
IF DOES_ENTITY_EXIST(foodCourtChairObject[i])
|
|
SET_OBJECT_AS_NO_LONGER_NEEDED(foodCourtChairObject[i])
|
|
ENDIF
|
|
ENDREPEAT
|
|
|
|
IF NOT IS_PED_INJURED(prisonerPed)
|
|
IF IS_ENTITY_ATTACHED(prisonerPed)
|
|
IF GET_VEHICLE_PED_IS_USING(prisonerPed) = NULL
|
|
DETACH_ENTITY(prisonerPed)
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
|
|
// remove dave
|
|
IF NOT IS_PED_INJURED(davePed)
|
|
REMOVE_PED_FROM_GROUP(davePed)
|
|
ENDIF
|
|
|
|
IF bThoroughCleanup
|
|
IF DOES_ENTITY_EXIST(davePed)
|
|
DELETE_PED(davePed)
|
|
ENDIF
|
|
IF DOES_ENTITY_EXIST(prisonerPed)
|
|
DELETE_PED(prisonerPed)
|
|
ENDIF
|
|
IF DOES_ENTITY_EXIST(sSelectorPeds.pedID[SELECTOR_PED_FRANKLIN])
|
|
#if USE_CLF_DLC
|
|
g_savedGlobalsClifford.sPlayerData.sInfo.vLastKnownCoords[CHAR_FRANKLIN] = <<0,0,0>>
|
|
g_savedGlobalsClifford.sPlayerData.sInfo.fLastKnownHead[CHAR_FRANKLIN] = 0
|
|
g_savedGlobalsClifford.sPlayerData.sInfo.iLastKnownRoomKey[CHAR_FRANKLIN] = 0
|
|
g_savedGlobalsClifford.sPlayerData.sInfo.vLastKnownVelocity[CHAR_FRANKLIN] = <<0,0,0>>
|
|
#endif
|
|
#if USE_NRM_DLC
|
|
g_savedGlobalsZombie.sPlayerData.sInfo.vLastKnownCoords[CHAR_FRANKLIN] = <<0,0,0>>
|
|
g_savedGlobalsZombie.sPlayerData.sInfo.fLastKnownHead[CHAR_FRANKLIN] = 0
|
|
g_savedGlobalsZombie.sPlayerData.sInfo.iLastKnownRoomKey[CHAR_FRANKLIN] = 0
|
|
g_savedGlobalsZombie.sPlayerData.sInfo.vLastKnownVelocity[CHAR_FRANKLIN] = <<0,0,0>>
|
|
#endif
|
|
|
|
#if not USE_CLF_DLC
|
|
#if not USE_NRM_DLC
|
|
g_savedGlobals.sPlayerData.sInfo.vLastKnownCoords[CHAR_FRANKLIN] = <<0,0,0>>
|
|
g_savedGlobals.sPlayerData.sInfo.fLastKnownHead[CHAR_FRANKLIN] = 0
|
|
g_savedGlobals.sPlayerData.sInfo.iLastKnownRoomKey[CHAR_FRANKLIN] = 0
|
|
g_savedGlobals.sPlayerData.sInfo.vLastKnownVelocity[CHAR_FRANKLIN] = <<0,0,0>>
|
|
#endif
|
|
#endif
|
|
DELETE_PED(sSelectorPeds.pedID[SELECTOR_PED_FRANKLIN])
|
|
ENDIF
|
|
IF DOES_ENTITY_EXIST(sSelectorPeds.pedID[SELECTOR_PED_MICHAEL])
|
|
DELETE_PED(sSelectorPeds.pedID[SELECTOR_PED_MICHAEL])
|
|
ENDIF
|
|
IF DOES_ENTITY_EXIST(sSelectorPeds.pedID[SELECTOR_PED_TREVOR])
|
|
DELETE_PED(sSelectorPeds.pedID[SELECTOR_PED_TREVOR])
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF currentMissionStage = STAGE_SNIPE_GUARDS
|
|
IF DOES_ENTITY_EXIST(sSelectorPeds.pedID[SELECTOR_PED_FRANKLIN])
|
|
DELETE_PED(sSelectorPeds.pedID[SELECTOR_PED_FRANKLIN])
|
|
ENDIF
|
|
ENDIF
|
|
|
|
REPEAT COUNT_OF(utilTruckVehicle) i
|
|
IF IS_VEHICLE_DRIVEABLE(utilTruckVehicle[i])
|
|
SET_ENTITY_SHOULD_FREEZE_WAITING_ON_COLLISION(utilTruckVehicle[i], FALSE)
|
|
SET_VEHICLE_DOORS_LOCKED(utilTruckVehicle[i], VEHICLELOCK_UNLOCKED)
|
|
ENDIF
|
|
ENDREPEAT
|
|
|
|
IF IS_VEHICLE_DRIVEABLE(driveAwayVehicle)
|
|
SET_ENTITY_SHOULD_FREEZE_WAITING_ON_COLLISION(driveAwayVehicle, FALSE)
|
|
ENDIF
|
|
|
|
IF IS_VEHICLE_DRIVEABLE(snatchAndGrabVehicle[SAGV_PLAYER_CHOPPER])
|
|
SET_HELI_TURBULENCE_SCALAR(snatchAndGrabVehicle[SAGV_PLAYER_CHOPPER],1.0)
|
|
SET_AIRCRAFT_PILOT_SKILL_NOISE_SCALAR(snatchAndGrabVehicle[SAGV_PLAYER_CHOPPER],1.0)
|
|
ENDIF
|
|
|
|
// get rid of anim cam
|
|
IF DOES_CAM_EXIST(animCam)
|
|
DESTROY_CAM(animCam)
|
|
ENDIF
|
|
|
|
IF currentMissionStage >= STAGE_CHOPPER_CHASE
|
|
IF DOES_ENTITY_EXIST(GET_FRANKLIN_PED())
|
|
IF PLAYER_PED_ID() = GET_FRANKLIN_PED()
|
|
IF IS_ENTITY_DEAD(GET_FRANKLIN_PED())
|
|
OR NOT IS_ENTITY_DEAD(GET_FRANKLIN_PED())
|
|
SET_ENTITY_VISIBLE(GET_FRANKLIN_PED(), TRUE)
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
|
|
DO_COMMON_PLAYER_AND_CAM_CLEANUP()
|
|
|
|
// IF IS_VEHICLE_DRIVEABLE(snatchAndGrabVehicle[SAGV_TREVOR_JEEP])
|
|
// SET_VEHICLE_IS_CONSIDERED_BY_PLAYER(snatchAndGrabVehicle[SAGV_TREVOR_JEEP], TRUE)
|
|
// ENDIF
|
|
IF IS_VEHICLE_DRIVEABLE(snatchAndGrabVehicle[SAGV_FRANKLIN_BIKE])
|
|
SET_VEHICLE_IS_CONSIDERED_BY_PLAYER(snatchAndGrabVehicle[SAGV_FRANKLIN_BIKE], TRUE)
|
|
ENDIF
|
|
|
|
IF IS_VEHICLE_DRIVEABLE(snatchAndGrabVehicle[SAGV_MICHAEL_CAR])
|
|
SET_VEHICLE_HAS_STRONG_AXLES(snatchAndGrabVehicle[SAGV_MICHAEL_CAR], FALSE)
|
|
ENDIF
|
|
|
|
//RESET_TO_BACKED_UP_ZOOM()
|
|
SUPPRESS_MISSION_MODELS(FALSE)
|
|
|
|
SET_TIME_SCALE(1.0)
|
|
|
|
#IF IS_DEBUG_BUILD
|
|
IF DOES_WIDGET_GROUP_EXIST(snatchAndGrabWidgets)
|
|
DELETE_WIDGET_GROUP(snatchAndGrabWidgets)
|
|
ENDIF
|
|
#ENDIF
|
|
|
|
TERMINATE_THIS_THREAD()
|
|
ENDPROC
|
|
|
|
// mission passed
|
|
PROC MISSION_PASSED()
|
|
|
|
// Fading any active music out.
|
|
//TRIGGER_MISSION_MUSIC_EVENT("FBI2_TEST_END_MISSION")
|
|
|
|
// remove enemy chopper
|
|
DELETE_ENEMY_CHOPPER()
|
|
|
|
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("FIB2_DEATH_FAIL")
|
|
missionFailState = MISSION_FAIL_STATE_WAIT_FOR_FADE
|
|
savedFailReason = reasonForFail
|
|
SET_TIME_SCALE(1.0)
|
|
|
|
STRING failText
|
|
SWITCH savedFailReason
|
|
CASE FAIL_MICHAEL_DEAD
|
|
failText = "CMN_MDIED"
|
|
//PRINTSTRING("FAIL REASON MICHAEL DEAD!") PRINTNL()
|
|
BREAK
|
|
CASE FAIL_FRANKLIN_DEAD
|
|
failText = "CMN_FDIED"
|
|
//PRINTSTRING("FAIL REASON FRANKLIN DEAD!") PRINTNL()
|
|
BREAK
|
|
CASE FAIL_TREVOR_DEAD
|
|
failText = "CMN_TDIED"
|
|
//PRINTSTRING("FAIL REASON TREVOR DEAD!") PRINTNL()
|
|
BREAK
|
|
CASE FAIL_DAVE_DEAD
|
|
failText = "SG_FAIL3"
|
|
//PRINTSTRING("FAIL REASON DAVE DEAD!") PRINTNL()
|
|
BREAK
|
|
CASE FAIL_ABANDONED_DAVE
|
|
failText = "SG_FAIL2"
|
|
//PRINTSTRING("FAIL REASON DAVE ABANDONED!") PRINTNL()
|
|
BREAK
|
|
CASE FAIL_PRISONER_DEAD
|
|
failText = "SG_FAIL4"
|
|
//PRINTSTRING("FAIL REASON K DEAD!") PRINTNL()
|
|
BREAK
|
|
CASE FAIL_CHOPPER_DESTROYED
|
|
failText = "SG_FAIL5"
|
|
//PRINTSTRING("FAIL REASON HELI DEAD!") PRINTNL()
|
|
BREAK
|
|
CASE FAIL_CAR_DESTROYED
|
|
failText = "SG_FAIL20"
|
|
//PRINTSTRING("FAIL REASON CAR DEAD!") PRINTNL()
|
|
BREAK
|
|
CASE FAIL_ABANDONED_CAR
|
|
failText = "SG_FAIL9"
|
|
//PRINTSTRING("FAIL REASON CAR ABA!") PRINTNL()
|
|
BREAK
|
|
CASE FAIL_ABANDONED_CHOPPER
|
|
failText = "SG_FAIL1"
|
|
//PRINTSTRING("FAIL REASON HELI ABA!") PRINTNL()
|
|
BREAK
|
|
CASE FAIL_TREVOR_ABANDONED_CHOPPER
|
|
failText = "SG_FAIL10"
|
|
//PRINTSTRING("FAIL REASON T HELI ABA!") PRINTNL()
|
|
BREAK
|
|
CASE FAIL_ATTACKED_FBI
|
|
failText = "SG_FAIL6"
|
|
//PRINTSTRING("FAIL REASON ATTACKED!") PRINTNL()
|
|
BREAK
|
|
CASE FAIL_FELL_FROM_ROPE
|
|
failText = "SG_FAIL7"
|
|
//PRINTSTRING("FAIL REASON1111!") PRINTNL()
|
|
BREAK
|
|
CASE FAIL_ROPE_CUT
|
|
failText = "SG_FAIL8"
|
|
//PRINTSTRING("FAIL REASON1111!") PRINTNL()
|
|
BREAK
|
|
CASE FAIL_SEEN
|
|
failText = "SG_FAIL11"
|
|
//PRINTSTRING("FAIL REASON1111!") PRINTNL()
|
|
BREAK
|
|
CASE FAIL_ATTRACTED_COPS
|
|
failText = "SG_FAIL12"
|
|
//PRINTSTRING("FAIL REASON COPS!") PRINTNL()
|
|
BREAK
|
|
CASE FAIL_CAR_STUCK
|
|
failText = "SG_FAIL13"
|
|
//PRINTSTRING("FAIL REASON CSTUCK!") PRINTNL()
|
|
BREAK
|
|
CASE FAIL_CHOPPER_STUCK
|
|
failText = "SG_FAIL14"
|
|
//PRINTSTRING("FAIL REASON CHSTUCK!") PRINTNL()
|
|
BREAK
|
|
CASE FAIL_CAUSED_TROUBLE
|
|
failText = "SG_FAIL15"
|
|
//PRINTSTRING("FAIL REASON TROUBLE!") PRINTNL()
|
|
BREAK
|
|
CASE FAIL_UNCOUPLED_ROPE
|
|
failText = "SG_FAIL17"
|
|
//PRINTSTRING("FAIL REASON1111!") PRINTNL()
|
|
BREAK
|
|
CASE FAIL_DROWNED
|
|
failText = "SG_FAIL16"
|
|
//PRINTSTRING("FAIL REASON1111!") PRINTNL()
|
|
BREAK
|
|
CASE FAIL_STEVE_DEAD
|
|
failText = "SG_FAIL18"
|
|
//PRINTSTRING("FAIL REASON1111!") PRINTNL()
|
|
BREAK
|
|
CASE FAIL_ANDREAS_DEAD
|
|
failText = "SG_FAIL19"
|
|
//PRINTSTRING("FAIL REASON1111!") PRINTNL()
|
|
BREAK
|
|
CASE FAIL_TROUBLE_FOOD_COURT
|
|
failText = "SG_FAIL21"
|
|
BREAK
|
|
ENDSWITCH
|
|
|
|
MISSION_FLOW_MISSION_FAILED_WITH_REASON(failText)
|
|
ENDIF
|
|
ENDPROC
|
|
|
|
// remove heli blip and text
|
|
PROC REMOVE_HELI_BLIP_AND_TEXT()
|
|
IF DOES_BLIP_EXIST(vehicleBlip)
|
|
REMOVE_BLIP(vehicleBlip)
|
|
ENDIF
|
|
IF IS_THIS_PRINT_BEING_DISPLAYED("CMN_GENGETINHE")
|
|
OR IS_THIS_PRINT_BEING_DISPLAYED("CMN_GENGETBCKHE")
|
|
REMOVE_MISSION_TEXT(TRUE, TRUE, FALSE)
|
|
ENDIF
|
|
ENDPROC
|
|
|
|
// remove car blip and text
|
|
PROC REMOVE_CAR_BLIP_AND_TEXT()
|
|
IF DOES_BLIP_EXIST(vehicleBlip)
|
|
REMOVE_BLIP(vehicleBlip)
|
|
ENDIF
|
|
IF IS_THIS_PRINT_BEING_DISPLAYED("SG_GETDCAR1")
|
|
OR IS_THIS_PRINT_BEING_DISPLAYED("SG_GETDCAR2")
|
|
REMOVE_MISSION_TEXT(TRUE, TRUE, FALSE)
|
|
ENDIF
|
|
ENDPROC
|
|
|
|
// check all peds and vehicles for fail
|
|
PROC HANDLE_MISSION_FAIL_CHECKS()
|
|
INT i
|
|
|
|
IF NOT bRunningCutscene
|
|
// character peds
|
|
REPEAT COUNT_OF(sSelectorPeds.pedID) i
|
|
IF DOES_ENTITY_EXIST(sSelectorPeds.pedID[i])
|
|
IF IS_PED_INJURED(sSelectorPeds.pedID[i])
|
|
enumCharacterList injuredChar = INT_TO_ENUM(enumCharacterList, i)
|
|
IF injuredChar <> GET_CURRENT_PLAYER_PED_ENUM()
|
|
SWITCH injuredChar
|
|
CASE CHAR_MICHAEL
|
|
// michael
|
|
IF NOT IS_PED_INJURED(prisonerPed)
|
|
IF IS_ENTITY_ATTACHED(prisonerPed)
|
|
AND NOT IS_PED_IN_ANY_VEHICLE(prisonerPed)
|
|
DETACH_ENTITY(prisonerPed)
|
|
ENDIF
|
|
ENDIF
|
|
MISSION_FAILED(FAIL_MICHAEL_DEAD)
|
|
BREAK
|
|
CASE CHAR_TREVOR
|
|
// trevor
|
|
MISSION_FAILED(FAIL_TREVOR_DEAD)
|
|
BREAK
|
|
CASE CHAR_FRANKLIN
|
|
// franklin
|
|
IF currentMissionStage = STAGE_GET_TO_CHOPPER
|
|
OR currentMissionStage = STAGE_CHOPPER_CHASE
|
|
OR currentMissionStage = STAGE_DROPOFF
|
|
MISSION_FAILED(FAIL_FRANKLIN_DEAD)
|
|
ENDIF
|
|
BREAK
|
|
ENDSWITCH
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDREPEAT
|
|
|
|
// dave
|
|
IF currentMissionStage = STAGE_GET_TO_CHOPPER
|
|
IF IS_PED_INJURED(davePed)
|
|
MISSION_FAILED(FAIL_DAVE_DEAD)
|
|
ELSE
|
|
// abandon fail
|
|
IF NOT bDaveInCar
|
|
IF GET_DISTANCE_BETWEEN_ENTITIES(PLAYER_PED_ID(), davePed, FALSE) > ABANDON_BUDDY_FAIL_RANGE
|
|
IF NOT bForcePassOnShitskip
|
|
MISSION_FAILED(FAIL_ABANDONED_DAVE)
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
|
|
// prisoner
|
|
IF currentMissionStage > STAGE_RAPPEL_DOWN
|
|
OR bCreatedOfficePedsForRappel
|
|
IF DOES_ENTITY_EXIST(prisonerPed)
|
|
IF IS_PED_INJURED(prisonerPed)
|
|
MISSION_FAILED(FAIL_PRISONER_DEAD)
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
|
|
// vehicles
|
|
IF DOES_ENTITY_EXIST(snatchAndGrabVehicle[SAGV_PLAYER_CHOPPER])
|
|
IF NOT IS_VEHICLE_DRIVEABLE(snatchAndGrabVehicle[SAGV_PLAYER_CHOPPER])
|
|
REMOVE_HELI_BLIP_AND_TEXT()
|
|
MISSION_FAILED(FAIL_CHOPPER_DESTROYED)
|
|
ELSE
|
|
IF currentMissionStage = STAGE_GET_TO_BUILDING
|
|
OR currentMissionStage = STAGE_DROPOFF
|
|
OR (currentMissionStage = STAGE_CHOPPER_CHASE AND GET_GAME_TIMER() >= iStartMissionStageTime + 3000)
|
|
IF GET_CURRENT_PLAYER_PED_ENUM() = CHAR_TREVOR
|
|
IF GET_DISTANCE_BETWEEN_ENTITIES(PLAYER_PED_ID(), snatchAndGrabVehicle[SAGV_PLAYER_CHOPPER]) > STUCK_FAIL_RANGE_m
|
|
MISSION_FAILED(FAIL_ABANDONED_CHOPPER)
|
|
ENDIF
|
|
|
|
IF IS_VEHICLE_STUCK_TIMER_UP(snatchAndGrabVehicle[SAGV_PLAYER_CHOPPER], VEH_STUCK_JAMMED, JAMMED_TIME)
|
|
OR IS_VEHICLE_STUCK_TIMER_UP(snatchAndGrabVehicle[SAGV_PLAYER_CHOPPER], VEH_STUCK_ON_SIDE, SIDE_TIME)
|
|
OR IS_VEHICLE_STUCK_TIMER_UP(snatchAndGrabVehicle[SAGV_PLAYER_CHOPPER], VEH_STUCK_ON_ROOF, ROOF_TIME)
|
|
REMOVE_HELI_BLIP_AND_TEXT()
|
|
MISSION_FAILED(FAIL_CHOPPER_STUCK)
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF currentMissionStage = STAGE_GET_TO_CHOPPER
|
|
IF NOT IS_VEHICLE_DRIVEABLE(snatchAndGrabVehicle[SAGV_MICHAEL_CAR])
|
|
REMOVE_CAR_BLIP_AND_TEXT()
|
|
MISSION_FAILED(FAIL_CAR_DESTROYED)
|
|
ELSE
|
|
IF IS_VEHICLE_STUCK_TIMER_UP(snatchAndGrabVehicle[SAGV_MICHAEL_CAR], VEH_STUCK_JAMMED, JAMMED_TIME)
|
|
OR IS_VEHICLE_STUCK_TIMER_UP(snatchAndGrabVehicle[SAGV_MICHAEL_CAR], VEH_STUCK_HUNG_UP, HUNG_UP_TIME)
|
|
OR IS_VEHICLE_STUCK_TIMER_UP(snatchAndGrabVehicle[SAGV_MICHAEL_CAR], VEH_STUCK_ON_SIDE, SIDE_TIME)
|
|
OR IS_VEHICLE_STUCK_TIMER_UP(snatchAndGrabVehicle[SAGV_MICHAEL_CAR], VEH_STUCK_ON_ROOF, ROOF_TIME)
|
|
REMOVE_CAR_BLIP_AND_TEXT()
|
|
MISSION_FAILED(FAIL_CAR_STUCK)
|
|
ENDIF
|
|
|
|
IF GET_DISTANCE_BETWEEN_ENTITIES(PLAYER_PED_ID(), snatchAndGrabVehicle[SAGV_MICHAEL_CAR], FALSE) > STUCK_FAIL_RANGE_m
|
|
MISSION_FAILED(FAIL_ABANDONED_CAR)
|
|
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()
|
|
// safe to cleanup
|
|
IF NOT IS_PED_INJURED(PLAYER_PED_ID())
|
|
RESTORE_PLAYER_PED_VARIATIONS(PLAYER_PED_ID())
|
|
ENDIF
|
|
|
|
// 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
|
|
//
|
|
SWITCH currentMissionStage
|
|
CASE STAGE_RAPPEL_DOWN
|
|
CASE STAGE_SNIPE_GUARDS
|
|
CASE STAGE_CHOPPER_CHASE
|
|
CASE STAGE_DROPOFF
|
|
SWITCH GET_CURRENT_PLAYER_PED_ENUM()
|
|
CASE CHAR_MICHAEL
|
|
BOOL bCreateAtBottomOfTower
|
|
bCreateAtBottomOfTower = TRUE
|
|
IF currentMissionStage >= STAGE_CHOPPER_CHASE
|
|
IF IS_VEHICLE_DRIVEABLE(snatchAndGrabVehicle[SAGV_PLAYER_CHOPPER])
|
|
IF IS_PED_IN_VEHICLE(PLAYER_PED_ID(), snatchAndGrabVehicle[SAGV_PLAYER_CHOPPER])
|
|
PED_INDEX pilotPed
|
|
pilotPed = GET_PED_IN_VEHICLE_SEAT(snatchAndGrabVehicle[SAGV_PLAYER_CHOPPER])
|
|
IF DOES_ENTITY_EXIST(pilotPed)
|
|
DELETE_PED(pilotPed)
|
|
ENDIF
|
|
SET_PED_INTO_VEHICLE(PLAYER_PED_ID(), snatchAndGrabVehicle[SAGV_PLAYER_CHOPPER])
|
|
bCreateAtBottomOfTower = FALSE
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF bCreateAtBottomOfTower
|
|
MISSION_FLOW_SET_FAIL_WARP_LOCATION(<<111.05540, -612.03613, 43.22037>>, 53.7)
|
|
SET_REPLAY_DECLINED_VEHICLE_WARP_LOCATION(<<107.17, -607.66, 43.81>>, -20.0)
|
|
ENDIF
|
|
BREAK
|
|
CASE CHAR_FRANKLIN
|
|
MISSION_FLOW_SET_FAIL_WARP_LOCATION(<<-111.59071, -609.55170, 35.28290>>, -127.0)
|
|
SET_REPLAY_DECLINED_VEHICLE_WARP_LOCATION(<<-107.15, -611.71, 35.76>>, 160.2)
|
|
BREAK
|
|
ENDSWITCH
|
|
BREAK
|
|
ENDSWITCH
|
|
|
|
//SET_REPLAY_DECLINED_VEHICLE_WARP_LOCATION(<< 79.2596, -692.3523, 43.2205 >>, 336.9140)
|
|
|
|
// get rid of enemy chopper
|
|
DELETE_ENEMY_CHOPPER()
|
|
|
|
IF g_bMagDemoActive
|
|
DELETE_ALL_ENTITIES_IN_FADE()
|
|
ENDIF
|
|
|
|
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
|
|
|
|
|
|
// fill position, rotation, FOV for a camera shot
|
|
PROC FILL_CAMERA_PROPERTIES_FOR_SNATCH_AND_GRAB_SHOT(SNATCH_AND_GRAB_SHOT_DETAILS_ENUM cutsceneShot, VECTOR &vCamPos, VECTOR &vCamRot, FLOAT &fCamFOV)
|
|
SWITCH cutsceneShot
|
|
CASE SAG_SHOT_ARRIVE
|
|
vCamPos = <<96.46, -622.69, 262.29>>
|
|
vCamRot = <<19.41, 0.0, -103.44>>
|
|
fCamFOV = 29.75
|
|
BREAK
|
|
|
|
CASE SAG_SHOT_ARRIVEB
|
|
vCamPos = <<96.46, -622.69, 262.29>>
|
|
vCamRot = <<19.41, 0.0, -85.27>>
|
|
fCamFOV = 29.75
|
|
BREAK
|
|
|
|
CASE SAG_SHOT_ARRIVE2
|
|
vCamPos = <<81.82, -669.82, 274.21>>
|
|
vCamRot = <<0.61, 0.60, -21.81>>
|
|
fCamFOV = 22.04
|
|
BREAK
|
|
|
|
CASE SAG_SHOT_ARRIVE2B
|
|
vCamPos = <<81.82, -669.82, 274.21>>
|
|
vCamRot = <<-6.98, 0.60, -21.80>>
|
|
fCamFOV = 22.04
|
|
BREAK
|
|
|
|
CASE SAG_SHOT_ARRIVE3
|
|
vCamPos = <<110.16, -590.50, 254.40>>
|
|
vCamRot = <<15.76, 0.28, 158.27>>
|
|
fCamFOV = 28.054
|
|
BREAK
|
|
|
|
CASE SAG_SHOT_ARRIVE3B
|
|
vCamPos = <<110.16, -590.50, 254.40>>
|
|
vCamRot = <<21.49, 0.47, -166.12>>
|
|
fCamFOV = 28.054
|
|
BREAK
|
|
|
|
CASE SAG_SHOT_INSIDE
|
|
vCamPos = <<119.15, -618.77, 206.46>>
|
|
vCamRot = <<0.64, 0.0, 99.40>>
|
|
fCamFOV = 39.54
|
|
BREAK
|
|
|
|
CASE SAG_SHOT_SMASH_IN
|
|
vCamPos = <<118.88, -618.60, 206.81>>
|
|
vCamRot = <<-12.44, 0.0, 105.89>>
|
|
fCamFOV = 53.16
|
|
BREAK
|
|
|
|
CASE SAG_SHOT_WAIT_FOR_SWITCH
|
|
vCamPos = <<109.385162,-618.262939,206.679871>>
|
|
vCamRot = <<-5.776211,0.000091,-104.552917>>
|
|
fCamFOV = 35.00
|
|
BREAK
|
|
|
|
CASE SAG_SHOT_WAIT_FOR_SWITCHB
|
|
vCamPos = <<109.385162,-618.262939,206.679871>>
|
|
vCamRot = <<-5.776211,0.000091,-104.552917>>
|
|
fCamFOV = 35.00
|
|
BREAK
|
|
|
|
// the alt
|
|
/*
|
|
CASE SAG_SHOT_WINCHING
|
|
vCamPos = <<110.84, -619.28, 216.49>>
|
|
vCamRot = <<-57.33, -14.65, -8.90>>
|
|
fCamFOV = 24.755
|
|
BREAK
|
|
|
|
CASE SAG_SHOT_WINCHINGB
|
|
vCamPos = <<110.84, -619.28, 216.49>>
|
|
vCamRot = <<9.20, -5.80, -9.65>>
|
|
fCamFOV = 24.755
|
|
BREAK
|
|
*/
|
|
|
|
CASE SAG_SHOT_WINCHING
|
|
vCamPos = <<111.93, -614.87, 209.10>>
|
|
vCamRot = <<-5.14, -4.85, 155.18>>
|
|
fCamFOV = 32.662
|
|
BREAK
|
|
|
|
CASE SAG_SHOT_WINCHINGB
|
|
vCamPos = <<111.93, -614.87, 209.10>>
|
|
vCamRot = <<10.86, -4.85, 155.18>>
|
|
fCamFOV = 32.662
|
|
BREAK
|
|
|
|
CASE SAG_SHOT_FIB1
|
|
vCamPos = <<60.9, -753.7, 46.0>>
|
|
vCamRot = <<5.8, 0.0, -75.0>>
|
|
fCamFOV = 46.6
|
|
BREAK
|
|
|
|
CASE SAG_SHOT_FIB1B
|
|
vCamPos = <<59.3, -751.7, 46.8>>
|
|
vCamRot = <<61.9, 0.0, -63.8>>
|
|
fCamFOV = 46.6
|
|
BREAK
|
|
|
|
CASE SAG_SHOT_FIB2
|
|
vCamPos = <<50.3, -734.0, 230.0>>
|
|
vCamRot = <<18.2, 0.0, -65.5>>
|
|
fCamFOV = 46.6
|
|
BREAK
|
|
|
|
CASE SAG_SHOT_FIB2B
|
|
vCamPos = <<50.1, -733.5, 230.0>>
|
|
vCamRot = <<18.2, 0.0, -61.9>>
|
|
fCamFOV = 46.6
|
|
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_SNATCH_AND_GRAB_SHOT(SNATCH_AND_GRAB_SHOT_DETAILS_ENUM cutsceneShot, BOOL bIsInterp = FALSE, INT iInterpTime = 10000)
|
|
VECTOR vCamPos, vCamRot
|
|
FLOAT fCamFOV
|
|
FILL_CAMERA_PROPERTIES_FOR_SNATCH_AND_GRAB_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
|
|
SNATCH_AND_GRAB_SHOT_DETAILS_ENUM shotDetails = INT_TO_ENUM(SNATCH_AND_GRAB_SHOT_DETAILS_ENUM, ENUM_TO_INT(cutsceneShot)+1)
|
|
FILL_CAMERA_PROPERTIES_FOR_SNATCH_AND_GRAB_SHOT(shotDetails, 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(BOOL bStartActivated = TRUE)
|
|
IF DOES_CAM_EXIST(animCam)
|
|
DESTROY_CAM(animCam)
|
|
ENDIF
|
|
animCam = CREATE_CAM("DEFAULT_ANIMATED_CAMERA", bStartActivated)
|
|
RENDER_SCRIPT_CAMS(TRUE, FALSE)
|
|
ENDPROC
|
|
|
|
// create follow cam for come back from MCS_1 skip
|
|
//PROC CREATE_FOLLOW_CAM()
|
|
// CREATE_MISSION_STATIC_CAM(followCam)
|
|
// RENDER_SCRIPT_CAMS(TRUE, FALSE)
|
|
//ENDPROC
|
|
|
|
// create the follow cam
|
|
/*
|
|
PROC HANDLE_CREATE_FOLLOW_CAM_ON_FLY()
|
|
IF NOT DOES_CAM_EXIST(followCam)
|
|
CREATE_MISSION_STATIC_CAM(followCam)
|
|
SET_CAM_COORD(followCam,<<10,10,10>>)
|
|
RENDER_SCRIPT_CAMS(TRUE,FALSE)
|
|
ELSE
|
|
SET_CAM_COORD(followCam,GET_FINAL_RENDERED_CAM_COORD())
|
|
SET_CAM_FAR_CLIP(followCam,GET_FINAL_RENDERED_CAM_FAR_CLIP())
|
|
SET_CAM_FAR_DOF(followCam,GET_FINAL_RENDERED_CAM_FAR_DOF())
|
|
SET_CAM_FOV(followCam,GET_FINAL_RENDERED_CAM_FOV())
|
|
SET_CAM_MOTION_BLUR_STRENGTH(followCam,GET_FINAL_RENDERED_CAM_MOTION_BLUR_STRENGTH())
|
|
SET_CAM_NEAR_CLIP(followCam,GET_FINAL_RENDERED_CAM_NEAR_CLIP())
|
|
SET_CAM_NEAR_DOF(followCam,GET_FINAL_RENDERED_CAM_NEAR_DOF())
|
|
SET_CAM_ROT(followCam,GET_FINAL_RENDERED_CAM_ROT())
|
|
|
|
|
|
//PRINTSTRING("coord = ") PRINTVECTOR(GET_FINAL_RENDERED_CAM_COORD()) PRINTNL()
|
|
//PRINTSTRING("rot = ") PRINTVECTOR(GET_FINAL_RENDERED_CAM_ROT()) PRINTNL()
|
|
//PRINTSTRING("farclip = ") PRINTFLOAT(GET_FINAL_RENDERED_CAM_FAR_CLIP()) PRINTNL()
|
|
//PRINTSTRING("fardof = ") PRINTFLOAT(GET_FINAL_RENDERED_CAM_FAR_DOF()) PRINTNL()
|
|
//PRINTSTRING("fov = ") PRINTFLOAT(GET_FINAL_RENDERED_CAM_FOV()) PRINTNL()
|
|
//PRINTSTRING("blur = ") PRINTFLOAT(GET_FINAL_RENDERED_CAM_MOTION_BLUR_STRENGTH()) PRINTNL()
|
|
//PRINTSTRING("nearclip = ") PRINTFLOAT(GET_FINAL_RENDERED_CAM_NEAR_CLIP()) PRINTNL()
|
|
//PRINTSTRING("neardof= ") PRINTFLOAT(GET_FINAL_RENDERED_CAM_NEAR_DOF()) PRINTNL()
|
|
|
|
ENDIF
|
|
ENDPROC
|
|
|
|
|
|
// create fake follow cam
|
|
PROC CREATE_FAKE_FOLLOW_CAM()
|
|
IF NOT DOES_CAM_EXIST(followCam)
|
|
CREATE_MISSION_STATIC_CAM(followCam)
|
|
SET_CAM_COORD(followCam,<< 1370.51, -2089.4, 53.2142 >>)
|
|
SET_CAM_FAR_CLIP(followCam,5000.000000)
|
|
SET_CAM_FAR_DOF(followCam,150.000000)
|
|
SET_CAM_FOV(followCam, 40.000000)
|
|
SET_CAM_MOTION_BLUR_STRENGTH(followCam,0.000000)
|
|
SET_CAM_NEAR_CLIP(followCam,0.5)
|
|
SET_CAM_NEAR_DOF(followCam,0.100000)
|
|
SET_CAM_ROT(followCam,<< 0.000454265, 0.000252917, 12.5 >>)
|
|
RENDER_SCRIPT_CAMS(TRUE,FALSE)
|
|
ENDIF
|
|
ENDPROC
|
|
*/
|
|
|
|
PROC CLEANUP_HOTSWAP_CAMERAS()
|
|
INT i
|
|
REPEAT COUNT_OF(sCamDetails.camInterpIDs) i
|
|
IF DOES_CAM_EXIST(sCamDetails.camInterpIDs[i])
|
|
DESTROY_CAM(sCamDetails.camInterpIDs[i])
|
|
ENDIF
|
|
ENDREPEAT
|
|
ENDPROC
|
|
|
|
/*
|
|
// create cam interping from sniper
|
|
PROC CREATE_INTERP_FROM_SNIPER(VECTOR vRiflePos, VECTOR vRifleRot, FLOAT fRifleFOV)
|
|
DESTROY_MISSION_STATIC_CAM(staticCam)
|
|
DESTROY_MISSION_STATIC_CAM(interpCam)
|
|
IF DOES_CAM_EXIST(animCam)
|
|
DESTROY_CAM(animCam)
|
|
ENDIF
|
|
|
|
CREATE_MISSION_STATIC_CAM(staticCam)
|
|
|
|
// set cam coords to sniper pos
|
|
SET_CAM_COORD(staticCam, vRiflePos)
|
|
SET_CAM_ROT(staticCam, vRifleRot)
|
|
SET_CAM_FOV(staticCam, fRifleFOV)
|
|
|
|
// setup interp
|
|
VECTOR vCamPos, vCamRot
|
|
FLOAT fCamFOV
|
|
FILL_CAMERA_PROPERTIES_FOR_SNATCH_AND_GRAB_SHOT(SAG_SHOT_PRE_EXTRACT, 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, 2000)
|
|
|
|
// render
|
|
RENDER_SCRIPT_CAMS(TRUE, FALSE)
|
|
ENDPROC
|
|
*/
|
|
|
|
// create a spline cam for between interp and franklin
|
|
PROC CREATE_SPLINE_INTERP_TO_FRANKLIN()
|
|
IF DOES_CAM_EXIST(interpCam)
|
|
DESTROY_MISSION_STATIC_CAM(staticCam)
|
|
IF DOES_CAM_EXIST(animCam)
|
|
DESTROY_CAM(animCam)
|
|
ENDIF
|
|
|
|
FLOAT fInterpFOV = GET_CAM_FOV(interpCam)
|
|
VECTOR vEaseFromMichael
|
|
|
|
DESTROY_MISSION_STATIC_CAM(interpCam)
|
|
|
|
// Re-using these camera indices
|
|
CLEANUP_HOTSWAP_CAMERAS()
|
|
|
|
////interpCam = CREATE_CAM("SMOOTHED_SPLINE_CAMERA", TRUE)
|
|
interpCam = CREATE_CAMERA(CAMTYPE_SPLINE_TIMED_CUSTOM, FALSE)
|
|
//// SET_CAM_FOV(interpCam, fInterpFov)
|
|
|
|
////sCamDetails.camInterpIDs[0] = CREATE_CAMERA_WITH_PARAMS(CAMTYPE_SCRIPTED, vSniperNodePos1, vSniperNodeRot1, fInterpFov, TRUE)
|
|
sCamDetails.camInterpIDs[0] = CREATE_CAMERA_WITH_PARAMS(CAMTYPE_SCRIPTED, GET_FINAL_RENDERED_CAM_COORD(), GET_FINAL_RENDERED_CAM_ROT(), GET_FINAL_RENDERED_CAM_FOV(), TRUE)
|
|
ADD_CAM_SPLINE_NODE_USING_CAMERA(interpCam, sCamDetails.camInterpIDs[0], 0, CAM_SPLINE_NODE_SMOOTH_LENS_PARAMS)
|
|
SET_CAM_MOTION_BLUR_STRENGTH(sCamDetails.camInterpIDs[0], 0.5)
|
|
////ADD_CAM_SPLINE_NODE(interpCam, GET_FINAL_RENDERED_CAM_COORD(), GET_FINAL_RENDERED_CAM_ROT(), 0, CAM_SPLINE_NODE_SMOOTH_ROT|CAM_SPLINE_NODE_SMOOTH_LENS_PARAMS)
|
|
|
|
vEaseFromMichael = LERP_VECTOR(GET_FINAL_RENDERED_CAM_COORD(), vSniperNodePos3, 0.1)
|
|
sCamDetails.camInterpIDs[1] = CREATE_CAMERA_WITH_PARAMS(CAMTYPE_SCRIPTED, vEaseFromMichael, GET_FINAL_RENDERED_CAM_ROT(), GET_FINAL_RENDERED_CAM_FOV(), TRUE)
|
|
ADD_CAM_SPLINE_NODE_USING_CAMERA(interpCam, sCamDetails.camInterpIDs[1], 1200, CAM_SPLINE_NODE_SMOOTH_ROT | CAM_SPLINE_NODE_SMOOTH_LENS_PARAMS)
|
|
SET_CAM_MOTION_BLUR_STRENGTH(sCamDetails.camInterpIDs[1], 0.8)
|
|
|
|
sCamDetails.camInterpIDs[3] = CREATE_CAMERA_WITH_PARAMS(CAMTYPE_SCRIPTED, vSniperNodePos3, vSniperNodeRot3, fInterpFov, TRUE)
|
|
ADD_CAM_SPLINE_NODE_USING_CAMERA(interpCam, sCamDetails.camInterpIDs[3], 900, CAM_SPLINE_NODE_SMOOTH_LENS_PARAMS)
|
|
SET_CAM_MOTION_BLUR_STRENGTH(sCamDetails.camInterpIDs[3], 1.0)
|
|
|
|
SET_CAM_SPLINE_DURATION(interpCam, 1000)
|
|
|
|
SET_CAM_SPLINE_SMOOTHING_STYLE(interpCam, CAM_SPLINE_SLOW_IN_OUT_SMOOTH)
|
|
//SET_CAM_SPLINE_DURATION(interpCam, iSniperNodeTime2+iSniperNodeTime3+iSniperNodeTime4+iSniperNodeTime5+iSniperNodeTime6-33)
|
|
//SET_CAM_MOTION_BLUR_STRENGTH(interpCam, 0.8)
|
|
|
|
SET_CAM_ACTIVE(interpCam, TRUE) // Set active last so it will be the final camera.
|
|
RENDER_SCRIPT_CAMS(TRUE, FALSE)
|
|
ENDIF
|
|
ENDPROC
|
|
|
|
// 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
|
|
|
|
// do a fadein post cutscene
|
|
PROC DO_POST_CUTSCENE_FADE_IN()
|
|
IF IS_SCREEN_FADED_OUT()
|
|
DO_SCREEN_FADE_IN(DEFAULT_FADE_TIME)
|
|
ENDIF
|
|
ENDPROC
|
|
|
|
//HUD elements
|
|
PROC SET_CUTSCENE_HUD_ELEMENTS()
|
|
DISABLE_CELLPHONE(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
|
|
|
|
// setup stuff for snatch and grab cutscene
|
|
PROC SET_MISSION_CUTSCENE(BOOL bStart, BOOL bResetControlAndCameras = TRUE, BOOL bDoFade = TRUE, BOOL bRemoveText = TRUE, BOOL bSetRelativeHeading = TRUE, BOOL bSetMultiHeadBlinders = TRUE)
|
|
IF bRemoveText
|
|
REMOVE_MISSION_TEXT()
|
|
ENDIF
|
|
|
|
IF bStart
|
|
SET_CUTSCENE_HUD_ELEMENTS()
|
|
SET_SCRIPTS_SAFE_FOR_CUTSCENE(TRUE,DEFAULT,bSetMultiHeadBlinders)
|
|
DISPLAY_RADAR(FALSE)
|
|
DISPLAY_HUD(FALSE)
|
|
iAllowSkipCutsceneTime = GET_GAME_TIMER()
|
|
ELSE
|
|
SET_SCRIPTS_SAFE_FOR_CUTSCENE(FALSE,DEFAULT,bSetMultiHeadBlinders)
|
|
|
|
IF bResetControlAndCameras
|
|
SET_PLAYER_CONTROL(PLAYER_ID(), TRUE)
|
|
DISPLAY_RADAR(TRUE)
|
|
DISPLAY_HUD(TRUE)
|
|
DISABLE_CELLPHONE(FALSE)
|
|
|
|
RENDER_SCRIPT_CAMS(FALSE, FALSE)
|
|
|
|
IF DOES_CAM_EXIST(animCam)
|
|
DESTROY_CAM(animCam)
|
|
ENDIF
|
|
DESTROY_MISSION_STATIC_CAM(staticCam)
|
|
DESTROY_MISSION_STATIC_CAM(interpCam)
|
|
IF bSetRelativeHeading
|
|
SET_GAMEPLAY_CAM_RELATIVE_HEADING(0.0)
|
|
ENDIF
|
|
ENDIF
|
|
bRunningCutscene = FALSE
|
|
bClearedForCutscene = FALSE
|
|
bSkippedCutscene = FALSE
|
|
bCutsceneWaitStarted = FALSE
|
|
cutsceneStage = SAG_CUT_STAGE_INIT
|
|
|
|
IF bDoFade
|
|
DO_POST_CUTSCENE_FADE_IN()
|
|
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
|
|
|
|
// is office ready
|
|
FUNC BOOL IS_OFFICE_READY()
|
|
IF bInteriorPinned
|
|
IF IS_INTERIOR_READY(officeInterior)
|
|
RETURN TRUE
|
|
ENDIF
|
|
ENDIF
|
|
RETURN FALSE
|
|
ENDFUNC
|
|
|
|
// pin the office in memory
|
|
PROC PIN_OFFICE_INTERIOR(BOOL bDoPin, BOOL bWait)
|
|
IF bDoPin
|
|
IF NOT bInteriorPinned
|
|
officeInterior = GET_INTERIOR_AT_COORDS(<<116.08, -620.64, 206.53>>)
|
|
IF IS_VALID_INTERIOR(officeInterior)
|
|
PIN_INTERIOR_IN_MEMORY(officeInterior)
|
|
bInteriorPinned = TRUE
|
|
IF bWait
|
|
WHILE NOT IS_OFFICE_READY()
|
|
WAIT(0)
|
|
ENDWHILE
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ELSE
|
|
IF bInteriorPinned
|
|
UNPIN_INTERIOR(officeInterior)
|
|
bInteriorPinned = FALSE
|
|
ENDIF
|
|
ENDIF
|
|
ENDPROC
|
|
|
|
// get correct model for mission vehicle
|
|
FUNC SNATCH_AND_GRAB_MODEL_ENUM GET_MODEL_ENUM_FOR_SNATCH_AND_GRAB_VEHICLE(SNATCH_AND_GRAB_VEHICLE_ENUM sagVehicle)
|
|
SWITCH sagVehicle
|
|
CASE SAGV_PLAYER_CHOPPER
|
|
RETURN SAGM_CHOPPER
|
|
BREAK
|
|
CASE SAGV_MICHAEL_CAR
|
|
RETURN SAGM_MICHAEL_CAR
|
|
BREAK
|
|
// CASE SAGV_TREVOR_JEEP
|
|
// RETURN SAGM_TREVOR_JEEP
|
|
// BREAK
|
|
CASE SAGV_FRANKLIN_BIKE
|
|
RETURN SAGM_FRANKLIN_BIKE
|
|
BREAK
|
|
ENDSWITCH
|
|
|
|
RETURN SAGM_CHOPPER
|
|
ENDFUNC
|
|
|
|
// is this model required on this stage?
|
|
FUNC BOOL IS_MODEL_REQUIRED_FOR_MISSION_STAGE(SNATCH_AND_GRAB_MODEL_ENUM sagModel, MISSION_STAGE_ENUM reqStage)
|
|
SWITCH sagModel
|
|
CASE SAGM_MICHAEL
|
|
RETURN TRUE
|
|
BREAK
|
|
CASE SAGM_FRANKLIN
|
|
IF reqStage = STAGE_RAPPEL_DOWN
|
|
OR reqStage = STAGE_SNIPE_GUARDS
|
|
RETURN TRUE
|
|
ENDIF
|
|
BREAK
|
|
CASE SAGM_TREVOR
|
|
IF reqStage >= STAGE_GET_TO_BUILDING
|
|
RETURN TRUE
|
|
ENDIF
|
|
BREAK
|
|
CASE SAGM_DAVE
|
|
IF reqStage <= STAGE_GET_TO_CHOPPER
|
|
RETURN TRUE
|
|
ENDIF
|
|
BREAK
|
|
CASE SAGM_STEVE
|
|
CASE SAGM_ANDREAS
|
|
CASE SAGM_COFFEE
|
|
IF reqStage <= STAGE_GET_TO_CHOPPER
|
|
RETURN TRUE
|
|
ENDIF
|
|
BREAK
|
|
CASE SAGM_CHOPPER
|
|
IF reqStage >= STAGE_GET_TO_BUILDING
|
|
RETURN TRUE
|
|
ENDIF
|
|
BREAK
|
|
CASE SAGM_ENEMY_CHOPPER
|
|
//CASE SAGM_ENEMY_CHOPPER_TEST
|
|
IF reqStage = STAGE_CHOPPER_CHASE
|
|
RETURN TRUE
|
|
ENDIF
|
|
BREAK
|
|
CASE SAGM_PRISONER_HIGH
|
|
//IF reqStage >= STAGE_SNIPE_GUARDS
|
|
// RETURN TRUE
|
|
//ENDIF
|
|
BREAK
|
|
CASE SAGM_PRISONER_LOW
|
|
IF reqStage >= STAGE_SNIPE_GUARDS
|
|
RETURN TRUE
|
|
ENDIF
|
|
BREAK
|
|
CASE SAGM_GUARD
|
|
IF reqStage >= STAGE_SNIPE_GUARDS
|
|
AND reqStage <= STAGE_CHOPPER_CHASE
|
|
RETURN TRUE
|
|
ENDIF
|
|
BREAK
|
|
CASE SAGM_PILOT
|
|
IF reqStage = STAGE_CHOPPER_CHASE
|
|
RETURN TRUE
|
|
ENDIF
|
|
BREAK
|
|
CASE SAGM_MICHELLE
|
|
CASE SAGM_TORCH
|
|
|
|
BREAK
|
|
CASE SAGM_FBI
|
|
//IF reqStage >= STAGE_CHOPPER_CHASE
|
|
// RETURN TRUE
|
|
//ENDIF
|
|
BREAK
|
|
CASE SAGM_MICHAEL_CAR
|
|
IF reqStage = STAGE_GET_TO_CHOPPER
|
|
RETURN TRUE
|
|
ENDIF
|
|
BREAK
|
|
CASE SAGM_FRANKLIN_BIKE
|
|
|
|
BREAK
|
|
CASE SAGM_PULLEY
|
|
IF reqStage = STAGE_RAPPEL_DOWN
|
|
RETURN TRUE
|
|
ENDIF
|
|
BREAK
|
|
/*
|
|
CASE SAGM_TREVOR_JEEP
|
|
IF reqStage <= STAGE_GET_TO_BUILDING
|
|
OR reqStage = STAGE_CHOPPER_CHASE
|
|
RETURN TRUE
|
|
ENDIF
|
|
BREAK
|
|
*/
|
|
CASE SAGM_FBI_VAN
|
|
// IF reqStage >= STAGE_CHOPPER_CHASE
|
|
// RETURN TRUE
|
|
// ENDIF
|
|
BREAK
|
|
CASE SAGM_UTIL_TRUCK_1
|
|
CASE SAGM_UTIL_TRUCK_2
|
|
IF reqStage = STAGE_GET_TO_BUILDING
|
|
RETURN TRUE
|
|
ENDIF
|
|
BREAK
|
|
CASE SAGM_HARNESS
|
|
IF reqStage >= STAGE_RAPPEL_DOWN
|
|
RETURN TRUE
|
|
ENDIF
|
|
BREAK
|
|
//CASE SAGM_HOOK
|
|
// IF reqStage >= STAGE_RAPPEL_DOWN
|
|
// RETURN TRUE
|
|
// ENDIF
|
|
//BREAK
|
|
|
|
//CASE SAGM_BLOCK
|
|
// IF reqStage >= STAGE_CHOPPER_CHASE
|
|
// 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_SNATCH_AND_GRAB_MODEL_ENUM(INT_TO_ENUM(SNATCH_AND_GRAB_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_SNATCH_AND_GRAB_MODEL_ENUM(INT_TO_ENUM(SNATCH_AND_GRAB_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_SNATCH_AND_GRAB_MODEL_ENUM(INT_TO_ENUM(SNATCH_AND_GRAB_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(SNATCH_AND_GRAB_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(SNATCH_AND_GRAB_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 // chopper hover
|
|
SWITCH reqStage
|
|
//CASE STAGE_GET_TO_BUILDING
|
|
CASE STAGE_RAPPEL_DOWN
|
|
RETURN TRUE
|
|
BREAK
|
|
ENDSWITCH
|
|
BREAK
|
|
CASE 002 // chopper escape
|
|
IF reqStage = STAGE_SNIPE_GUARDS
|
|
OR reqStage = STAGE_CHOPPER_CHASE
|
|
OR reqStage = STAGE_RAPPEL_DOWN
|
|
RETURN TRUE
|
|
ENDIF
|
|
BREAK
|
|
CASE 003 // enemy chopper 1
|
|
IF reqStage = STAGE_CHOPPER_CHASE
|
|
RETURN TRUE
|
|
ENDIF
|
|
BREAK
|
|
//CASE 004 // chopper arrive at building - over roof
|
|
//CASE 005 // chopper arrive at building - opposite dir
|
|
//CASE 006 // chopper arrive at building - same dir
|
|
//IF reqStage = STAGE_GET_TO_BUILDING
|
|
// RETURN TRUE
|
|
//ENDIF
|
|
//BREAK
|
|
//CASE 007 // traffic 1
|
|
//CASE 008 // traffic 2
|
|
//CASE 009 // traffic 3
|
|
//CASE 010 // traffic 4
|
|
//IF reqStage = STAGE_RAPPEL_DOWN
|
|
//OR reqStage = STAGE_GET_TO_BUILDING
|
|
// RETURN TRUE
|
|
//ENDIF
|
|
//BREAK
|
|
CASE 011 // escape v2
|
|
IF reqStage = STAGE_CHOPPER_CHASE
|
|
RETURN TRUE
|
|
ENDIF
|
|
BREAK
|
|
CASE 012 // enemy chopper 2
|
|
CASE 013 // enemy chopper 3
|
|
IF reqStage = STAGE_CHOPPER_CHASE
|
|
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_SNATCH_AND_GRAB_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_SNATCH_AND_GRAB_RECORDING_PREFIX())
|
|
REMOVE_VEHICLE_RECORDING(iRec, GET_SNATCH_AND_GRAB_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_SNATCH_AND_GRAB_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
|
|
|
|
// 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
|
|
ENDIF
|
|
ENDPROC
|
|
|
|
|
|
// is this anim dict required on this stage?
|
|
FUNC BOOL IS_ANIM_DICT_REQUIRED_FOR_MISSION_STAGE(SNATCH_AND_GRAB_ANIM_DICT_ENUM animDict, MISSION_STAGE_ENUM reqStage)
|
|
SWITCH animDict
|
|
CASE SAG_ANIM_DICT_MISSION
|
|
IF currentMissionStage = STAGE_SNIPE_GUARDS
|
|
RETURN TRUE
|
|
ENDIF
|
|
BREAK
|
|
CASE SAG_ANIM_DICT_RAPPEL
|
|
IF reqStage = STAGE_RAPPEL_DOWN
|
|
RETURN TRUE
|
|
ENDIF
|
|
BREAK
|
|
CASE SAG_ANIM_DICT_GUARDS
|
|
IF reqStage = STAGE_SNIPE_GUARDS
|
|
RETURN TRUE
|
|
ENDIF
|
|
BREAK
|
|
CASE SAG_ANIM_DICT_CUTSCENES
|
|
BREAK
|
|
CASE SAG_ANIM_DICT_INTRO
|
|
|
|
BREAK
|
|
CASE SAG_ANIM_DICT_AIM_VARIATIONS
|
|
CASE SAG_ANIM_DICT_COMBAT_GLANCES
|
|
CASE SAG_ANIM_DICT_OVER_THERE
|
|
CASE SAG_ANIM_DICT_PANIC
|
|
CASE SAG_ANIM_DICT_BECKON
|
|
IF reqStage = STAGE_SNIPE_GUARDS
|
|
RETURN TRUE
|
|
ENDIF
|
|
BREAK
|
|
CASE SAG_ANIM_DICT_FOOD_COURT
|
|
IF reqStage <= STAGE_GET_TO_CHOPPER
|
|
RETURN TRUE
|
|
ENDIF
|
|
BREAK
|
|
CASE SAG_ANIM_DICT_IN_OFFICE
|
|
IF reqStage = STAGE_SNIPE_GUARDS
|
|
RETURN TRUE
|
|
ENDIF
|
|
BREAK
|
|
CASE SAG_ANIM_DICT_FLY_HOME
|
|
CASE SAG_ANIM_CAM_SHAKE_LIBRARY
|
|
IF reqStage >= STAGE_CHOPPER_CHASE
|
|
RETURN TRUE
|
|
ENDIF
|
|
BREAK
|
|
CASE SAG_ANIM_DICT_SNIPER
|
|
IF reqStage >= STAGE_SNIPE_GUARDS
|
|
RETURN TRUE
|
|
ENDIF
|
|
BREAK
|
|
ENDSWITCH
|
|
|
|
RETURN FALSE
|
|
ENDFUNC
|
|
|
|
// add a request for an anim
|
|
PROC ADD_ANIM_DICT_REQUEST(SNATCH_AND_GRAB_ANIM_DICT_ENUM animDict)
|
|
bAnimDictRequestTracker[animDict] = TRUE
|
|
STRING sAnimDict = GET_SNATCH_AND_GRAB_ANIM_DICT_AS_STRING(animDict)
|
|
REQUEST_ANIM_DICT(sAnimDict)
|
|
ENDPROC
|
|
|
|
// clear an anim request slot
|
|
PROC CLEAR_ANIM_DICT_REQUEST(SNATCH_AND_GRAB_ANIM_DICT_ENUM animDict)
|
|
IF bAnimDictRequestTracker[animDict]
|
|
bAnimDictRequestTracker[animDict] = FALSE
|
|
STRING sAnimDict = GET_SNATCH_AND_GRAB_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(SNATCH_AND_GRAB_ANIM_DICT_ENUM) i
|
|
IF bAnimDictRequestTracker[i]
|
|
IF NOT HAS_ANIM_DICT_LOADED(GET_SNATCH_AND_GRAB_ANIM_DICT_AS_STRING(INT_TO_ENUM(SNATCH_AND_GRAB_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(SNATCH_AND_GRAB_ANIM_DICT_ENUM) i
|
|
SNATCH_AND_GRAB_ANIM_DICT_ENUM thisAnimDict = INT_TO_ENUM(SNATCH_AND_GRAB_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
|
|
|
|
// is this weapon required on this stage?
|
|
FUNC BOOL IS_WEAPON_REQUIRED_FOR_MISSION_STAGE(SNATCH_AND_GRAB_WEAPON_ENUM weapon, MISSION_STAGE_ENUM reqStage)
|
|
SWITCH weapon
|
|
CASE SAG_WEAPON_MICHAEL_PISTOL
|
|
IF reqStage >= STAGE_RAPPEL_DOWN
|
|
RETURN TRUE
|
|
ENDIF
|
|
BREAK
|
|
CASE SAG_WEAPON_CIA_PISTOL
|
|
RETURN TRUE
|
|
BREAK
|
|
CASE SAG_WEAPON_CIA_SMG
|
|
IF reqStage = STAGE_SNIPE_GUARDS
|
|
OR reqStage = STAGE_CHOPPER_CHASE
|
|
RETURN TRUE
|
|
ENDIF
|
|
BREAK
|
|
CASE SAG_WEAPON_CIA_HELI
|
|
IF reqStage = STAGE_CHOPPER_CHASE
|
|
RETURN TRUE
|
|
ENDIF
|
|
BREAK
|
|
CASE SAG_WEAPON_SNIPER_RIFLE
|
|
IF reqStage >= STAGE_RAPPEL_DOWN
|
|
RETURN TRUE
|
|
ENDIF
|
|
BREAK
|
|
CASE SAG_WEAPON_MICHAEL_RIFLE
|
|
IF reqStage >= STAGE_CHOPPER_CHASE
|
|
RETURN TRUE
|
|
ENDIF
|
|
BREAK
|
|
ENDSWITCH
|
|
|
|
RETURN FALSE
|
|
ENDFUNC
|
|
|
|
// add a request for a weapon
|
|
PROC ADD_WEAPON_REQUEST(SNATCH_AND_GRAB_WEAPON_ENUM weapon)
|
|
bWeaponRequestTracker[weapon] = TRUE
|
|
WEAPON_TYPE weaponType = GET_SNATCH_AND_GRAB_WEAPON_TYPE(weapon)
|
|
REQUEST_WEAPON_ASSET(weaponType)
|
|
ENDPROC
|
|
|
|
// clear a weapon request slot
|
|
PROC CLEAR_WEAPON_REQUEST(SNATCH_AND_GRAB_WEAPON_ENUM weapon)
|
|
IF bWeaponRequestTracker[weapon]
|
|
bWeaponRequestTracker[weapon] = FALSE
|
|
WEAPON_TYPE weaponType = GET_SNATCH_AND_GRAB_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(SNATCH_AND_GRAB_WEAPON_ENUM) i
|
|
IF bWeaponRequestTracker[i]
|
|
IF NOT HAS_WEAPON_ASSET_LOADED(GET_SNATCH_AND_GRAB_WEAPON_TYPE(INT_TO_ENUM(SNATCH_AND_GRAB_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(SNATCH_AND_GRAB_WEAPON_ENUM) i
|
|
SNATCH_AND_GRAB_WEAPON_ENUM thisWeapon = INT_TO_ENUM(SNATCH_AND_GRAB_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_SNATCH_AND_GRAB_PTFX_AS_STRING(SNATCH_AND_GRAB_PTFX_ENUM ptfx)
|
|
SWITCH ptfx
|
|
CASE SAG_PTFX_PLACEHOLDER
|
|
BREAK
|
|
ENDSWITCH
|
|
|
|
RETURN "invalid!"
|
|
ENDFUNC
|
|
*/
|
|
|
|
// is this ptfx required on this stage?
|
|
FUNC BOOL IS_PTFX_REQUIRED_FOR_MISSION_STAGE(SNATCH_AND_GRAB_PTFX_ENUM ptfx, MISSION_STAGE_ENUM reqStage)
|
|
reqStage = reqStage // TEMP
|
|
|
|
SWITCH ptfx
|
|
CASE SAG_PTFX_PLACEHOLDER
|
|
BREAK
|
|
ENDSWITCH
|
|
|
|
RETURN FALSE
|
|
ENDFUNC
|
|
|
|
// add a request for a ptfx
|
|
PROC ADD_PTFX_REQUEST(SNATCH_AND_GRAB_PTFX_ENUM ptfx)
|
|
bPTFXRequestTracker[ptfx] = TRUE
|
|
// STRING sPTFX = GET_SNATCH_AND_GRAB_PTFX_AS_STRING(ptfx)
|
|
REQUEST_PTFX_ASSET()
|
|
ENDPROC
|
|
|
|
// clear a ptfx request slot
|
|
PROC CLEAR_PTFX_REQUEST(SNATCH_AND_GRAB_PTFX_ENUM ptfx)
|
|
IF bPTFXRequestTracker[ptfx]
|
|
bPTFXRequestTracker[ptfx] = FALSE
|
|
// STRING sPTFX = GET_SNATCH_AND_GRAB_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(SNATCH_AND_GRAB_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(SNATCH_AND_GRAB_PTFX_ENUM) i
|
|
SNATCH_AND_GRAB_PTFX_ENUM thisPTFX = INT_TO_ENUM(SNATCH_AND_GRAB_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_SNATCH_AND_GRAB_SFX_AS_STRING(SNATCH_AND_GRAB_SFX_ENUM sfx)
|
|
SWITCH sfx
|
|
CASE SAG_SFX_MISSION
|
|
RETURN GET_MISSION_AUDIO_BANK_NAME()
|
|
BREAK
|
|
CASE SAG_SFX_HELIS
|
|
RETURN "FBI_02_Snatch_And_Grab_HELI_CHASE"
|
|
BREAK
|
|
//CASE SAG_SFX_RAPPEL
|
|
// RETURN GET_RAPPEL_AUDIO_BANK_NAME()
|
|
//BREAK
|
|
ENDSWITCH
|
|
|
|
RETURN "invalid!"
|
|
ENDFUNC
|
|
|
|
// is this sfx required on this stage?
|
|
FUNC BOOL IS_SFX_REQUIRED_FOR_MISSION_STAGE(SNATCH_AND_GRAB_SFX_ENUM sfx, MISSION_STAGE_ENUM reqStage)
|
|
SWITCH sfx
|
|
CASE SAG_SFX_MISSION
|
|
IF reqStage >= STAGE_RAPPEL_DOWN
|
|
RETURN TRUE
|
|
ENDIF
|
|
BREAK
|
|
CASE SAG_SFX_HELIS
|
|
IF reqStage = STAGE_CHOPPER_CHASE
|
|
RETURN TRUE
|
|
ENDIF
|
|
BREAK
|
|
//CASE SAG_SFX_RAPPEL
|
|
// IF reqStage >= STAGE_RAPPEL_DOWN
|
|
// RETURN TRUE
|
|
// ENDIF
|
|
//BREAK
|
|
ENDSWITCH
|
|
|
|
RETURN FALSE
|
|
ENDFUNC
|
|
|
|
// add a request for a sfx
|
|
PROC ADD_SFX_REQUEST(SNATCH_AND_GRAB_SFX_ENUM sfx)
|
|
bSFXRequestTracker[sfx] = TRUE
|
|
STRING sSFX = GET_SNATCH_AND_GRAB_SFX_AS_STRING(sfx)
|
|
REQUEST_SCRIPT_AUDIO_BANK(sSFX)
|
|
ENDPROC
|
|
|
|
// clear a sfx request slot
|
|
PROC CLEAR_SFX_REQUEST(SNATCH_AND_GRAB_SFX_ENUM sfx)
|
|
IF bSFXRequestTracker[sfx]
|
|
bSFXRequestTracker[sfx] = FALSE
|
|
STRING sSFX = GET_SNATCH_AND_GRAB_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(SNATCH_AND_GRAB_SFX_ENUM) i
|
|
IF bSFXRequestTracker[i]
|
|
IF NOT REQUEST_SCRIPT_AUDIO_BANK(GET_SNATCH_AND_GRAB_SFX_AS_STRING(INT_TO_ENUM(SNATCH_AND_GRAB_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(SNATCH_AND_GRAB_SFX_ENUM) i
|
|
SNATCH_AND_GRAB_SFX_ENUM thisSFX = INT_TO_ENUM(SNATCH_AND_GRAB_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(SNATCH_AND_GRAB_MISC_ASSET_ENUM miscAsset, MISSION_STAGE_ENUM reqStage)
|
|
SWITCH miscAsset
|
|
CASE SAG_MISC_ASSET_CAR_ANIMS
|
|
IF reqStage = STAGE_GET_TO_CHOPPER
|
|
RETURN TRUE
|
|
ENDIF
|
|
BREAK
|
|
CASE SAG_MISC_ASSET_CHOPPER_ANIMS
|
|
IF reqStage > STAGE_GET_TO_CHOPPER
|
|
RETURN TRUE
|
|
ENDIF
|
|
BREAK
|
|
CASE SAG_MISC_ASSET_HELI_DRIVEBY_ANIMS
|
|
IF reqStage >= STAGE_CHOPPER_CHASE
|
|
RETURN TRUE
|
|
ENDIF
|
|
BREAK
|
|
CASE SAG_MISC_ASSET_DAVE_WALK
|
|
IF reqStage = STAGE_GET_TO_CHOPPER
|
|
RETURN TRUE
|
|
ENDIF
|
|
BREAK
|
|
//CASE SAG_MISC_ASSET_FOOD_COURT_ANIMS
|
|
// IF reqStage = STAGE_GET_TO_CHOPPER
|
|
// RETURN TRUE
|
|
// ENDIF
|
|
//BREAK
|
|
ENDSWITCH
|
|
|
|
RETURN FALSE
|
|
ENDFUNC
|
|
|
|
// add a request for a misc asset
|
|
PROC ADD_MISC_ASSET_REQUEST(SNATCH_AND_GRAB_MISC_ASSET_ENUM miscAsset)
|
|
bMiscAssetRequestTracker[miscAsset] = TRUE
|
|
|
|
SWITCH miscAsset
|
|
CASE SAG_MISC_ASSET_CAR_ANIMS
|
|
REQUEST_VEHICLE_ASSET(GET_MODEL_FOR_SNATCH_AND_GRAB_MODEL_ENUM(SAGM_MICHAEL_CAR))
|
|
BREAK
|
|
CASE SAG_MISC_ASSET_CHOPPER_ANIMS
|
|
REQUEST_VEHICLE_ASSET(GET_MODEL_FOR_SNATCH_AND_GRAB_MODEL_ENUM(SAGM_CHOPPER))
|
|
BREAK
|
|
CASE SAG_MISC_ASSET_HELI_DRIVEBY_ANIMS
|
|
REQUEST_CLIP_SET(GET_HELI_DRIVEBY_ANIMS_AS_STRING())
|
|
printstring("requesting driveby anims") printnl()
|
|
BREAK
|
|
CASE SAG_MISC_ASSET_DAVE_WALK
|
|
REQUEST_WAYPOINT_RECORDING("davewalk")
|
|
BREAK
|
|
//CASE SAG_MISC_ASSET_FOOD_COURT_ANIMS
|
|
// REQUEST_CLIP_SET("missFBI2@LeadInOutAndreas")
|
|
// REQUEST_CLIP_SET("missFBI2@LeadInOutDaveN")
|
|
// REQUEST_CLIP_SET("missFBI2@LeadInOutSteve")
|
|
//BREAK
|
|
ENDSWITCH
|
|
ENDPROC
|
|
|
|
// clear a misc asset slot
|
|
PROC CLEAR_MISC_ASSET_REQUEST(SNATCH_AND_GRAB_MISC_ASSET_ENUM miscAsset)
|
|
IF bMiscAssetRequestTracker[miscAsset]
|
|
bMiscAssetRequestTracker[miscAsset] = FALSE
|
|
SWITCH miscAsset
|
|
CASE SAG_MISC_ASSET_CAR_ANIMS
|
|
REMOVE_VEHICLE_ASSET(GET_MODEL_FOR_SNATCH_AND_GRAB_MODEL_ENUM(SAGM_MICHAEL_CAR))
|
|
BREAK
|
|
CASE SAG_MISC_ASSET_CHOPPER_ANIMS
|
|
REMOVE_VEHICLE_ASSET(GET_MODEL_FOR_SNATCH_AND_GRAB_MODEL_ENUM(SAGM_CHOPPER))
|
|
BREAK
|
|
CASE SAG_MISC_ASSET_HELI_DRIVEBY_ANIMS
|
|
REMOVE_CLIP_SET(GET_HELI_DRIVEBY_ANIMS_AS_STRING())
|
|
printstring("removing driveby anims") printnl()
|
|
BREAK
|
|
CASE SAG_MISC_ASSET_DAVE_WALK
|
|
REMOVE_WAYPOINT_RECORDING("davewalk")
|
|
BREAK
|
|
//CASE SAG_MISC_ASSET_FOOD_COURT_ANIMS
|
|
// REMOVE_CLIP_SET("missFBI2@LeadInOutAndreas")
|
|
// REMOVE_CLIP_SET("missFBI2@LeadInOutDaveN")
|
|
// REMOVE_CLIP_SET("missFBI2@LeadInOutSteve")
|
|
//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(SNATCH_AND_GRAB_MISC_ASSET_ENUM) i
|
|
IF bMiscAssetRequestTracker[i]
|
|
SWITCH INT_TO_ENUM(SNATCH_AND_GRAB_MISC_ASSET_ENUM, i)
|
|
CASE SAG_MISC_ASSET_CAR_ANIMS
|
|
IF NOT HAS_VEHICLE_ASSET_LOADED(GET_MODEL_FOR_SNATCH_AND_GRAB_MODEL_ENUM(SAGM_MICHAEL_CAR))
|
|
RETURN FALSE
|
|
ENDIF
|
|
BREAK
|
|
CASE SAG_MISC_ASSET_CHOPPER_ANIMS
|
|
IF NOT HAS_VEHICLE_ASSET_LOADED(GET_MODEL_FOR_SNATCH_AND_GRAB_MODEL_ENUM(SAGM_CHOPPER))
|
|
RETURN FALSE
|
|
ENDIF
|
|
BREAK
|
|
CASE SAG_MISC_ASSET_HELI_DRIVEBY_ANIMS
|
|
IF NOT HAS_CLIP_SET_LOADED(GET_HELI_DRIVEBY_ANIMS_AS_STRING())
|
|
printstring("driveby anims not loaded") printnl()
|
|
RETURN FALSE
|
|
ELSE
|
|
printstring("driveby anims are loaded!") printnl()
|
|
ENDIF
|
|
BREAK
|
|
CASE SAG_MISC_ASSET_DAVE_WALK
|
|
IF NOT GET_IS_WAYPOINT_RECORDING_LOADED("davewalk")
|
|
RETURN FALSE
|
|
ENDIF
|
|
BREAK
|
|
//CASE SAG_MISC_ASSET_FOOD_COURT_ANIMS
|
|
// IF NOT HAS_CLIP_SET_LOADED("missFBI2@LeadInOutAndreas")
|
|
// OR NOT HAS_CLIP_SET_LOADED("missFBI2@LeadInOutDaveN")
|
|
// OR NOT HAS_CLIP_SET_LOADED("missFBI2@LeadInOutSteve")
|
|
// 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(SNATCH_AND_GRAB_MISC_ASSET_ENUM) i
|
|
SNATCH_AND_GRAB_MISC_ASSET_ENUM thisMiscAsset = INT_TO_ENUM(SNATCH_AND_GRAB_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)
|
|
printstring("waiting on misc asset requests") printnl()
|
|
ENDWHILE
|
|
ENDIF
|
|
ENDIF
|
|
ENDPROC
|
|
|
|
// request the text for the mission
|
|
PROC REQUEST_TEXT(BOOL bWaitForLoad)
|
|
REQUEST_ADDITIONAL_TEXT("SAGRAB", MISSION_TEXT_SLOT)
|
|
IF bWaitForLoad
|
|
WHILE NOT HAS_ADDITIONAL_TEXT_LOADED(MISSION_TEXT_SLOT)
|
|
WAIT(0)
|
|
ENDWHILE
|
|
ENDIF
|
|
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
|
|
cutsceneStage = SAG_CUT_STAGE_INIT
|
|
bRunningCutscene = FALSE
|
|
bSkippedCutscene = FALSE
|
|
bClearedForCutscene = FALSE
|
|
bCutsceneWaitStarted = FALSE
|
|
bShownGodText = FALSE
|
|
bSniperMusicStarted = FALSE
|
|
bDoneGotoSpeech = FALSE
|
|
bShouldDoGetInText = FALSE
|
|
fLockDoorOpen = DOOR_OPEN_RATIO
|
|
bDoneBanter = FALSE
|
|
bSavedBanter = FALSE
|
|
bRemovedBlipsForWanted = FALSE
|
|
//bKilledConversationOnWanted = FALSE
|
|
bShownLoseWantedPrompt = FALSE
|
|
bArrivedAtBuilding = FALSE
|
|
bCloseToBuilding = FALSE
|
|
bDisableSwitchDuringMagDemoEndScene = FALSE
|
|
bHitCutsceneFailsafe = FALSE
|
|
//iNextRandomSpeechTime = -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_FOOD_COURT
|
|
bTriggeredGreetingAnim = FALSE
|
|
bPlayerLeaveVehicle = FALSE
|
|
bTriggeredGreetingSpeech = FALSE
|
|
bDoneIntroCreateEntities = FALSE
|
|
bDoneIntroClearStart = FALSE
|
|
bPrestreamedLine= FALSE
|
|
bCreatedGuysAtFoodCourt = FALSE
|
|
BREAK
|
|
|
|
CASE STAGE_GET_TO_CHOPPER
|
|
hotswapStage = MISSION_HOTSWAP_STAGE_SELECT_CHARACTER
|
|
createMeetingStage = CREATE_MEETING_STAGE_NOT_STARTED
|
|
createUtilTrucksStage = CREATE_UTIL_TRUCKS_STAGE_NOT_STARTED
|
|
pickupChopperLeadinStage = PICKUP_CHOPPER_LEADIN_NOT_STARTED
|
|
daveIntoCarState = DAVE_INTO_CAR_STATE_WALKING
|
|
//steveLeadOutState = LEAD_OUT_STATE_NOT_STARTED
|
|
//andreasLeadOutState = LEAD_OUT_STATE_NOT_STARTED
|
|
bSetMichaelToWalk = FALSE
|
|
bMusicFaded = FALSE
|
|
bMeetingCutsceneMusicStart = FALSE
|
|
bMeetingCutsceneMusicEnd = FALSE
|
|
//bForceIntoCar = FALSE
|
|
bCarIsMoving = FALSE
|
|
bRegisteredCall = FALSE
|
|
//bRestoredControlOnStart = FALSE
|
|
bChangedClothes = FALSE
|
|
bWaitForBuddyPrompt = FALSE
|
|
bGetBuddyPrompt = FALSE
|
|
bKilledBanter = FALSE
|
|
bKilledLookAtInCar = FALSE
|
|
//bDoneBriefTroopsSpeech = FALSE
|
|
bRemovedFBICar = FALSE
|
|
bDoneApproachLotCue = FALSE
|
|
//bKilledTrevorDiscussionSpeech = FALSE
|
|
//bRestartedDiscussionSpeech = FALSE
|
|
bDaveInCar = FALSE
|
|
bDoneDaveLetsGoSpeech = FALSE
|
|
bRemovedSteveAndAndreas = FALSE
|
|
bLoopSteveAndAndreas = FALSE
|
|
bDoneGetToLotSpeech = FALSE
|
|
bDoneSteveLook = FALSE
|
|
bDoneAndreasLook = FALSE
|
|
bDoneInCarAudioScene = FALSE
|
|
bDoneMichaelLeaveCarSpeech = FALSE
|
|
bPreparedTrevorRantAudio = FALSE
|
|
bSetSceneAudioEntity = FALSE
|
|
bCanRunPickupChopperScene = FALSE
|
|
bDaveActionModeTrack = FALSE
|
|
bDoneDaveShuffle = FALSE
|
|
bKilledDaveSpeechForDamage = FALSE
|
|
bKilledDaveSpeechForWanted = FALSE
|
|
bDoneDaveWantedSpeech = FALSE
|
|
bWarpedToLot = FALSE
|
|
bDoneDaveCarSpeech = FALSE
|
|
bKilledSpeechForDaveCar = FALSE
|
|
bKilledMichaelLeaveCarSpeechForTime = FALSE
|
|
bSetNavmesh = FALSE
|
|
bFrozeChairs = FALSE
|
|
bCacheAt = FALSE
|
|
iGetInTextStage = 0
|
|
iDriveBanterStage = 0
|
|
iDaveActionModeDelay = 0
|
|
iDaveDamageSpeechCount = 0
|
|
iPushInTime = -1
|
|
fDaveWalkSpeed = MAX_DAVE_WALK_SPEED
|
|
BREAK
|
|
|
|
CASE STAGE_GET_TO_BUILDING
|
|
hotswapStage = MISSION_HOTSWAP_STAGE_SELECT_CHARACTER
|
|
bRequestedAtBuildingAssets = FALSE
|
|
//bLatchedChopperDoors = FALSE
|
|
bRemovedAltitudeHelp = FALSE
|
|
bDoneGetInPositionSpeech = FALSE
|
|
bKilledBanterInChopper = FALSE
|
|
bRemovedUtilTrucks = FALSE
|
|
bDoneHalfwayThereCue = FALSE
|
|
bHeliLiftedOff = FALSE
|
|
bDoneInterpBackToGame = FALSE
|
|
bDoneFocusCamAudioScene = FALSE
|
|
bDoneTowerHintCamHelp = FALSE
|
|
iHelpStage = 0
|
|
iGetInTextStage = 2
|
|
BREAK
|
|
|
|
CASE STAGE_RAPPEL_DOWN
|
|
hotswapStage = MISSION_HOTSWAP_STAGE_SELECT_CHARACTER
|
|
createInterrogationStage = CREATE_INTERROGATION_STAGE_NOT_STARTED
|
|
replaceMrKStage = REPLACE_MR_K_STAGE_NOT_STARTED
|
|
prisonerGrabState = PRISONER_GRAB_STATE_INIT
|
|
smashThroughShot = SMASH_THROUGH_MOCAP
|
|
jumpGruntState = JUMP_GRUNT_DO_ON_LAND
|
|
pushInData.state = PUSH_IN_NOT_CREATED
|
|
//bLatchedChopperDoors = FALSE
|
|
bPlayingHoverBackwards = FALSE
|
|
bCreatedOfficePedsForRappel = FALSE
|
|
bRappelMusicStart = FALSE
|
|
bHasDoneJump = FALSE
|
|
//bSetSmashHelp = FALSE
|
|
//bDisplayJumpHelp = FALSE
|
|
bAllowSmashIn = FALSE
|
|
bRegisteredSmash = FALSE
|
|
bDeletedTraffic = FALSE
|
|
bCreatedSniper = FALSE
|
|
bGaveGuardWeapon = FALSE
|
|
bTriggeredGuardShoot = FALSE
|
|
bDoGuardsKillMichael = FALSE
|
|
bFakeKillMichael = FALSE
|
|
bResetGuardAim = FALSE
|
|
bReactedToFirstShot = FALSE
|
|
//bDrewWeapon = FALSE
|
|
// bTakeOverRappelControl = FALSE
|
|
// bFocusRappelCamIntoOffice = FALSE
|
|
// bRestoreRappelCamToPlayer = FALSE
|
|
bTortureMusicStart = FALSE
|
|
bInitialisedInterrogation = FALSE
|
|
bDoneSeeHelp = FALSE
|
|
bUsingOfficeCam = FALSE
|
|
// bHoldingShot = FALSE
|
|
// bDoneSmashInSpeech = FALSE
|
|
bFrozenFranklin = FALSE
|
|
bDoneFranklinSniperSpeech = FALSE
|
|
bKilledSpeechOnPan = FALSE
|
|
//bSecretaryCower = FALSE
|
|
bShownSwitchText = FALSE
|
|
bRequestedGuardAnims = FALSE
|
|
bDoneSmashSound = FALSE
|
|
bDoneSwitchToFranklinCue = FALSE
|
|
bUnmuffledRappelAudioScene = FALSE
|
|
bInteriorCamIsOutside = FALSE
|
|
bKeepTorch = FALSE
|
|
bStuckOnOfficeCam = FALSE
|
|
bWaitingOnOfficeCamRelease = FALSE
|
|
bWarpedChopperToBuilding = FALSE
|
|
bDisabledBlurOnRifle = FALSE
|
|
bHitFranklinSound = FALSE
|
|
bDoneHitSound = FALSE
|
|
bWooshStarted = FALSE
|
|
|
|
//bSniperOneshot = FALSE
|
|
//bKilledSmashOS = FALSE
|
|
//iTriggerGuardShootTime = -1
|
|
iWindowSmashStage = 0
|
|
iGuardSpeech = 0
|
|
iMichaelRappelSpeechStage = 0
|
|
// iInterrogationSpeechStage = 0
|
|
//iHoldShotStage = -1
|
|
fRopeTransitionPhase = 0.0
|
|
fRappelCamTransitionPhase = 0.0
|
|
fRappelCamTransitionPhaseSpeed = 0.0
|
|
iGuardAttackTime = -1
|
|
iGuardShot = 0
|
|
iInterrogationSubCount = 0
|
|
|
|
REPEAT NUMBER_TOWER_WINDOWS i
|
|
fAtWindowTime[i] = 0.0
|
|
bAlertedWindow[i] = FALSE
|
|
ENDREPEAT
|
|
|
|
REPEAT NUMBER_TOWER_PEDS i
|
|
towerPedState[i] = TOWER_PED_STATE_UNALERTED
|
|
ENDREPEAT
|
|
//fPointCamY = 0.0
|
|
//fPointCamZ = 0.0
|
|
//fPointCamYSpeed = 0.0
|
|
//fPointCamZSpeed = 0.0
|
|
BREAK
|
|
|
|
CASE STAGE_SNIPE_GUARDS
|
|
hotswapStage = MISSION_HOTSWAP_STAGE_SELECT_CHARACTER
|
|
michaelTargetPed = NULL
|
|
extractStage = EXTRACT_STAGE_KILL_INITIAL_GUARDS
|
|
hangingHotswapState = HANGING_HOTSWAP_ON_FRANKLIN
|
|
iDuckAnim = 0
|
|
iFlinchLeftAnim = 0
|
|
iFlinchRightAnim = 0
|
|
vShiftVectorSpeed = <<0.2,-0.08,0>>
|
|
//vCurrentKickBackOffset = <<0,0,0>>
|
|
vCurrentKickBackForce = <<0,0,0>>
|
|
|
|
iGuardAttackTime = -1
|
|
iGuardReactionStage = -1
|
|
iReinforcementsEnterTime = -1
|
|
iPostKilledGuardsTime = 0
|
|
|
|
bAdvancedGuardAttackTime = FALSE
|
|
bSelectedMichaelDuringExtract = FALSE
|
|
bDoneExtractSpeech = FALSE
|
|
//bDoneExtractHelp = FALSE
|
|
bGuardsHeardSniper = FALSE
|
|
bDoneGuardBeckon = FALSE
|
|
bFrozenFranklin = FALSE
|
|
//bRemovedGuardDialogue = FALSE
|
|
bReactedToFirstShot = FALSE
|
|
bAdditionalGuardsToShoot = FALSE
|
|
bSwingingRight = TRUE
|
|
bStartExtraction = FALSE
|
|
bReattachedMichael = FALSE
|
|
bSetSniperZoom = FALSE
|
|
bDoneKill3GuardsCue = FALSE
|
|
bPreparedChoppersApproachingCue = FALSE
|
|
bDoneChoppersApproachingCue = FALSE
|
|
bDoneDontShootSpeech = FALSE
|
|
bGuardsAttackPrisoner = FALSE
|
|
bGuardsStoppedShooting = FALSE
|
|
bDoneCantGetShotSpeech = FALSE
|
|
bDoneTroubleFlashHelp = FALSE
|
|
bLastReinforcementIsLast = FALSE
|
|
bDoneLastGuardEnter = FALSE
|
|
bLastGuardToShoot = FALSE
|
|
bLoadedExtractSpeech = FALSE
|
|
bTurnedOffRadarForSuppressHud = FALSE
|
|
bApplyOffsetToWinchRope = TRUE
|
|
bStartPushIn = FALSE
|
|
bDoneHitSound = FALSE
|
|
|
|
REPEAT COUNT_OF(bCreatedAdditionalReinforcement) i
|
|
bCreatedAdditionalReinforcement[i] = FALSE
|
|
ENDREPEAT
|
|
REPEAT COUNT_OF(bReinforcementToShoot) i
|
|
bReinforcementToShoot[i] = FALSE
|
|
ENDREPEAT
|
|
REPEAT COUNT_OF(reinforcementPed) i
|
|
iReinforcementShootWhileMovingStage[i] = 0
|
|
ENDREPEAT
|
|
bActivatedRopeSwingFromSynced = FALSE
|
|
bRopePhysical = FALSE
|
|
fRopeAttachHeading = INIT_ROPE_ATTACH_HEADING
|
|
fRopeTransitionPhase = 0.0
|
|
bDebugCanWinch = FALSE
|
|
//fTempPhase = 0
|
|
BREAK
|
|
|
|
CASE STAGE_CHOPPER_CHASE
|
|
hotswapStage = MISSION_HOTSWAP_STAGE_SELECT_CHARACTER
|
|
createFBIAtEndStage = CREATE_FBI_AT_END_STAGE_NOT_STARTED
|
|
heliStrafeState = HELI_STRAFE_ATTACK
|
|
michaelTargetPed = NULL
|
|
michaelTargetVehicle = NULL
|
|
franklinTargetVehicle = NULL
|
|
hangingHotswapState = HANGING_HOTSWAP_ON_FRANKLIN
|
|
// michaelReloadState = MICHAEL_RELOAD_HAS_AMMO
|
|
bDoneGetOutSpeech = FALSE
|
|
bStartedWinding = FALSE
|
|
bStoppedWinding = FALSE
|
|
bDoneDangleHelp = FALSE
|
|
REPEAT NUMBER_ENEMY_CHOPPERS i
|
|
bEnemyChopperShootersToAttack[i] = FALSE
|
|
bEnemyChopperToAI[i] = FALSE
|
|
bDoChopperSpinOut[i] = FALSE
|
|
bDoneDestroyedChopperSpeech[i] = FALSE
|
|
ENDREPEAT
|
|
bShownChopperPrompt = FALSE
|
|
bSpottedChopper = FALSE
|
|
bDoneChopperChoiceSpeech = FALSE
|
|
bUnpinnedInteriorForChase = FALSE
|
|
bDoneTrevorFly = FALSE
|
|
bDoneGoHomeSpeech = FALSE
|
|
bDoneReattach = FALSE
|
|
bDoneMakeMichaelMoreLethal = FALSE
|
|
//bDoneFranklinDangerHelp = FALSE
|
|
bDoneChopperAttackFranklinSpeech = FALSE
|
|
bDoneFranklinReactToChopperSpeech = FALSE
|
|
bDoneChopperLandSpeech = FALSE
|
|
bDoneMichaelFightsChoppersCue = FALSE
|
|
bDoneNoMoreThreatCue = FALSE
|
|
bDoneRocketReactionSpeech = FALSE
|
|
bTrevorCachedTarget = FALSE
|
|
bDoneGotoSpeech = TRUE
|
|
bChangedPriorityFromSniperToTrevor = FALSE
|
|
bCuedFriendlyFireSpeech = FALSE
|
|
bRocketsAccurate = FALSE
|
|
bUnproofedChoppers = FALSE
|
|
bCreatedExtraHeli = FALSE
|
|
bShownSlowmoHelp = FALSE
|
|
bFilledMichaelMeter = FALSE
|
|
bTurnedOffRadarForSuppressHud = FALSE
|
|
|
|
iWaitToKillCam = 4
|
|
|
|
//bAttachedBlock = FALSE
|
|
iAllowGoHomeTime = -1
|
|
fSpinForce = 0.0
|
|
fCircleCentreMod = 2.0
|
|
fUpwardsForce = 16.0
|
|
fChopperAccuracy = 0.0
|
|
fHeliCircleAngle = 0.0
|
|
fBelowWaveHeightTime = 0.0
|
|
// fDrownTime = 0.0
|
|
iSpinModifier = 0
|
|
bAllowStartEscapeRoute = FALSE
|
|
bStartedJourneyToLeaveHighRiseArea = FALSE
|
|
bStartedRotateToLeaveHighRiseArea = FALSE
|
|
bKnockedOff = FALSE
|
|
bStartExtraction = FALSE
|
|
bDonePanicSpeech = FALSE
|
|
bDoneRealPanicSpeech = FALSE
|
|
bDoneTrevorEncourageSpeech = FALSE
|
|
bDoneLastOneSpeech = FALSE
|
|
bDoneTrevorRemindFranklinSpeech = FALSE
|
|
bDoneFranklinSayChopperDownSpeech = FALSE
|
|
bDoneTrevorCongratulateFranklinSpeech = FALSE
|
|
bDoneWeHitSpeech = FALSE
|
|
bClearedAutopilot = FALSE
|
|
bDoneFBITurnToFaceChopper = FALSE
|
|
bDoneFBIWaveDownChopper = FALSE
|
|
bDoLeadHeliFireRockets = FALSE
|
|
|
|
iEnemyChopperSpeechStage = 0
|
|
iGetInTextStage = 2
|
|
iFranklinTargetPed = -1
|
|
iRecheckMichaelShootTime = 0
|
|
iTrevorEscapeRoutePoint = -1
|
|
iLeaveHighRiseAreaPoint = -1
|
|
//iFranklinDamageCount = 0
|
|
iMrKSpeechStage = 0
|
|
iLeadHeli = 1
|
|
iCreateExtraHeliTime = -1
|
|
iSlowmoHelpTime = -1
|
|
BREAK
|
|
|
|
CASE STAGE_DROPOFF
|
|
bDoneLandSpeech = FALSE
|
|
bDoneLandAudioScene = FALSE
|
|
bKilledSpeechForLand = FALSE
|
|
bDoneGetOutSpeech = TRUE
|
|
bDoneDangleHelp = TRUE
|
|
bDoneForceTrevorLow = FALSE
|
|
bSwitchedBackDuringDropoff = FALSE
|
|
bRemovedEnemyChopper = FALSE
|
|
//bAttachedBlock = FALSE
|
|
bDoneFBIWaveDownChopper = FALSE
|
|
bResetTimeForBelowHeight = FALSE
|
|
bDoMichaelBoom = FALSE
|
|
bTurnedOffRadarForSuppressHud = FALSE
|
|
|
|
bChangedClothes = FALSE
|
|
bDoneWayHomeSpeech = FALSE
|
|
bDoneWayHomeSpeech2 = FALSE
|
|
bDoneGetOffRoofSpeech = FALSE
|
|
//bDoneKeepSniperSpeech = FALSE
|
|
bDoneMissionCompleteCue = FALSE
|
|
bTrevorGone = FALSE
|
|
bDoneForceGetOutOfThereSpeech = FALSE
|
|
bForceStartedChopper = FALSE
|
|
|
|
iHeliFlyOffState = 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)
|
|
SWITCH getStage
|
|
CASE STAGE_FOOD_COURT
|
|
RETURN CHAR_MICHAEL
|
|
BREAK
|
|
CASE STAGE_GET_TO_CHOPPER
|
|
RETURN CHAR_MICHAEL
|
|
BREAK
|
|
CASE STAGE_GET_TO_BUILDING
|
|
RETURN CHAR_TREVOR
|
|
BREAK
|
|
CASE STAGE_RAPPEL_DOWN
|
|
RETURN CHAR_MICHAEL
|
|
BREAK
|
|
CASE STAGE_SNIPE_GUARDS
|
|
RETURN CHAR_FRANKLIN
|
|
BREAK
|
|
CASE STAGE_CHOPPER_CHASE
|
|
RETURN CHAR_FRANKLIN
|
|
BREAK
|
|
CASE STAGE_DROPOFF
|
|
RETURN CHAR_TREVOR
|
|
BREAK
|
|
ENDSWITCH
|
|
|
|
RETURN CHAR_FRANKLIN
|
|
ENDFUNC
|
|
|
|
// create a player vehicle for the mission
|
|
PROC SNATCH_AND_GRAB_CREATE_VEHICLE(SNATCH_AND_GRAB_VEHICLE_ENUM sagVehicle, VECTOR vCreatePos, FLOAT fCreateRot, BOOL bKeepModel = TRUE, BOOL bKeepVehicle = TRUE, BOOL bMakeInvincible = FALSE, BOOL bSetHeliBladesOn = TRUE)
|
|
IF NOT IS_VEHICLE_DRIVEABLE(snatchAndGrabVehicle[sagVehicle])
|
|
SNATCH_AND_GRAB_MODEL_ENUM vehicleModelEnum = GET_MODEL_ENUM_FOR_SNATCH_AND_GRAB_VEHICLE(sagVehicle)
|
|
|
|
// if using a specific player vehicle
|
|
IF sagVehicle = SAGV_MICHAEL_CAR
|
|
IF NOT g_bMagDemoActive
|
|
//CREATE_PLAYER_VEHICLE(snatchAndGrabVehicle[sagVehicle], CHAR_MICHAEL, vCreatePos, fCreateRot, FALSE)
|
|
CREATE_NPC_VEHICLE(snatchAndGrabVehicle[sagVehicle], CHAR_DAVE, vCreatePos, fCreateRot, FALSE)
|
|
ELSE
|
|
IF IS_PED_IN_ANY_VEHICLE(PLAYER_PED_ID())
|
|
snatchAndGrabVehicle[sagVehicle] = GET_VEHICLE_PED_IS_IN(PLAYER_PED_ID())
|
|
IF IS_VEHICLE_DRIVEABLE(snatchAndGrabVehicle[sagVehicle])
|
|
SET_ENTITY_AS_MISSION_ENTITY(snatchAndGrabVehicle[sagVehicle], TRUE, TRUE)
|
|
PRINTSTRING("successfully got tailgater from switch!") PRINTNL()
|
|
ELSE
|
|
CREATE_PLAYER_VEHICLE(snatchAndGrabVehicle[sagVehicle], CHAR_MICHAEL, vCreatePos, fCreateRot, FALSE)
|
|
PRINTSTRING("failed getting tailgater from switch!") PRINTNL()
|
|
ENDIF
|
|
ELSE
|
|
IF bDebugSkipMagdemoStart
|
|
CREATE_PLAYER_VEHICLE(snatchAndGrabVehicle[sagVehicle], CHAR_MICHAEL, <<1367.8052, -2028.5865, 51.0436>>, 205.2015, FALSE)
|
|
ELSE
|
|
CREATE_PLAYER_VEHICLE(snatchAndGrabVehicle[sagVehicle], CHAR_MICHAEL, vCreatePos, fCreateRot, FALSE)
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ELIF sagVehicle = SAGV_FRANKLIN_BIKE
|
|
IF NOT g_bMagDemoActive
|
|
CREATE_PLAYER_VEHICLE(snatchAndGrabVehicle[sagVehicle], CHAR_FRANKLIN, vCreatePos, fCreateRot, FALSE, VEHICLE_TYPE_BIKE)
|
|
FREEZE_ENTITY_POSITION(snatchAndGrabVehicle[sagVehicle], TRUE)
|
|
ELSE
|
|
snatchAndGrabVehicle[sagVehicle] = g_sMagDemoFBI2Entities.bikeVehicle
|
|
IF IS_VEHICLE_DRIVEABLE(snatchAndGrabVehicle[sagVehicle])
|
|
SET_ENTITY_AS_MISSION_ENTITY(snatchAndGrabVehicle[sagVehicle], TRUE, TRUE)
|
|
PRINTSTRING("successfully got bike from switch!") PRINTNL()
|
|
ELSE
|
|
CREATE_PLAYER_VEHICLE(snatchAndGrabVehicle[sagVehicle], CHAR_FRANKLIN, vCreatePos, fCreateRot, FALSE, VEHICLE_TYPE_BIKE)
|
|
PRINTSTRING("failed getting bike from switch!") PRINTNL()
|
|
ENDIF
|
|
ENDIF
|
|
ELIF sagVehicle = SAGV_PLAYER_CHOPPER
|
|
IF NOT g_bMagDemoActive
|
|
snatchAndGrabVehicle[sagVehicle] = CREATE_VEHICLE(GET_MODEL_FOR_SNATCH_AND_GRAB_MODEL_ENUM(vehicleModelEnum), vCreatePos, fCreateRot)
|
|
ELSE
|
|
snatchAndGrabVehicle[sagVehicle] = g_sMagDemoFBI2Entities.heliVehicle
|
|
IF IS_VEHICLE_DRIVEABLE(snatchAndGrabVehicle[sagVehicle])
|
|
SET_ENTITY_AS_MISSION_ENTITY(snatchAndGrabVehicle[sagVehicle], TRUE, TRUE)
|
|
PRINTSTRING("successfully got heli from switch!") PRINTNL()
|
|
ELSE
|
|
snatchAndGrabVehicle[sagVehicle] = CREATE_VEHICLE(GET_MODEL_FOR_SNATCH_AND_GRAB_MODEL_ENUM(vehicleModelEnum), vCreatePos, fCreateRot)
|
|
PRINTSTRING("failed getting heli from switch!") PRINTNL()
|
|
ENDIF
|
|
ENDIF
|
|
ELSE
|
|
snatchAndGrabVehicle[sagVehicle] = CREATE_VEHICLE(GET_MODEL_FOR_SNATCH_AND_GRAB_MODEL_ENUM(vehicleModelEnum), vCreatePos, fCreateRot)
|
|
ENDIF
|
|
|
|
//IF NOT g_bMagDemoActive
|
|
SET_VEHICLE_ON_GROUND_PROPERLY(snatchAndGrabVehicle[sagVehicle])
|
|
//ENDIF
|
|
|
|
IF NOT bKeepModel
|
|
CLEAR_MODEL_REQUEST(ENUM_TO_INT(vehicleModelEnum))
|
|
ENDIF
|
|
|
|
IF bMakeInvincible
|
|
SET_VEHICLE_CAN_BE_VISIBLY_DAMAGED(snatchAndGrabVehicle[sagVehicle], FALSE)
|
|
SET_VEHICLE_CAN_BREAK(snatchAndGrabVehicle[sagVehicle], FALSE)
|
|
SET_ENTITY_PROOFS(snatchAndGrabVehicle[sagVehicle], TRUE, TRUE, TRUE, TRUE, TRUE)
|
|
ELSE
|
|
SET_ENTITY_INVINCIBLE(snatchAndGrabVehicle[sagVehicle], FALSE)
|
|
ENDIF
|
|
|
|
SET_VEHICLE_CAN_LEAK_OIL(snatchAndGrabVehicle[sagVehicle], FALSE)
|
|
SET_VEHICLE_CAN_LEAK_PETROL(snatchAndGrabVehicle[sagVehicle], FALSE)
|
|
SET_DISABLE_VEHICLE_PETROL_TANK_FIRES(snatchAndGrabVehicle[sagVehicle], TRUE)
|
|
|
|
SWITCH sagVehicle
|
|
CASE SAGV_PLAYER_CHOPPER
|
|
IF bSetHeliBladesOn
|
|
SET_VEHICLE_ENGINE_ON(snatchAndGrabVehicle[sagVehicle], TRUE, TRUE)
|
|
SET_HELI_BLADES_FULL_SPEED(snatchAndGrabVehicle[sagVehicle])
|
|
ENDIF
|
|
//SET_VEHICLE_COLOUR_COMBINATION(snatchAndGrabVehicle[sagVehicle], 2)
|
|
SET_VEHICLE_COLOURS(snatchAndGrabVehicle[sagVehicle], 34, 34)
|
|
SET_VEHICLE_EXTRA_COLOURS(snatchAndGrabVehicle[sagVehicle], 0, 0)
|
|
|
|
SET_ENTITY_CAN_BE_DAMAGED_BY_RELATIONSHIP_GROUP(snatchAndGrabVehicle[sagVehicle], FALSE, agencyRelGroup)
|
|
SET_DOOR_ALLOWED_TO_BE_BROKEN_OFF(snatchAndGrabVehicle[sagVehicle], SC_DOOR_FRONT_LEFT, FALSE)
|
|
SET_VEHICLE_ENGINE_CAN_DEGRADE(snatchAndGrabVehicle[sagVehicle], FALSE)
|
|
|
|
SET_VEH_RADIO_STATION(snatchAndGrabVehicle[sagVehicle], GET_RADIO_STATION_NAME(ENUM_TO_INT(RADIO_GENRE_OFF)))
|
|
//SET_ENTITY_ALWAYS_PRERENDER(snatchAndGrabVehicle[sagVehicle], TRUE)
|
|
|
|
// temp? turn radio off
|
|
//SET_VEHICLE_RADIO_ENABLED(snatchAndGrabVehicle[sagVehicle], FALSE)
|
|
BREAK
|
|
CASE SAGV_FRANKLIN_BIKE
|
|
// SET_ENTITY_LOD_DIST(snatchAndGrabVehicle[sagVehicle], 1000)
|
|
SET_VEHICLE_IS_CONSIDERED_BY_PLAYER(snatchAndGrabVehicle[sagVehicle], FALSE)
|
|
BREAK
|
|
CASE SAGV_MICHAEL_CAR
|
|
SET_VEH_RADIO_STATION(snatchAndGrabVehicle[sagVehicle], GET_RADIO_STATION_NAME(ENUM_TO_INT(RADIO_GENRE_CLASSIC_ROCK)))
|
|
SET_DOOR_ALLOWED_TO_BE_BROKEN_OFF(snatchAndGrabVehicle[sagVehicle], SC_DOOR_FRONT_LEFT, FALSE)
|
|
SET_VEHICLE_HAS_STRONG_AXLES(snatchAndGrabVehicle[sagVehicle], TRUE)
|
|
//SET_VEHICLE_INDIVIDUAL_DOORS_LOCKED(snatchAndGrabVehicle[sagVehicle], ENUM_TO_INT(VS_FRONT_RIGHT), VEHICLELOCK_LOCKOUT_PLAYER_ONLY)
|
|
//SET_VEHICLE_RADIO_ENABLED(snatchAndGrabVehicle[sagVehicle], FALSE)
|
|
BREAK
|
|
ENDSWITCH
|
|
|
|
IF NOT bKeepVehicle
|
|
SET_VEHICLE_AS_NO_LONGER_NEEDED(snatchAndGrabVehicle[sagVehicle])
|
|
ENDIF
|
|
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)
|
|
IF NOT IS_PED_INJURED(ped)
|
|
SWITCH createChar
|
|
CASE CHAR_MICHAEL
|
|
IF setStage > STAGE_GET_TO_CHOPPER
|
|
SET_PED_COMP_ITEM_CURRENT_SP(ped, COMP_TYPE_OUTFIT, OUTFIT_P0_RAPPEL, FALSE)
|
|
IF setStage <= STAGE_GET_TO_BUILDING // no mask
|
|
OR setStage >= STAGE_CHOPPER_CHASE
|
|
SET_PED_COMP_ITEM_CURRENT_SP(ped, COMP_TYPE_PROPS, PROPS_EYES_NONE, FALSE)
|
|
ELSE // mask
|
|
//SET_PED_PROP_INDEX(ped, ANCHOR_EYES, 2, 0)
|
|
SET_PED_COMP_ITEM_CURRENT_SP(ped, COMP_TYPE_PROPS, PROPS_P0_EXTERMINATOR_MASK, FALSE)
|
|
ENDIF
|
|
|
|
// temp
|
|
IF setStage = STAGE_GET_TO_BUILDING
|
|
OR setStage >= STAGE_CHOPPER_CHASE
|
|
//SET_PED_PROP_INDEX(ped, ANCHOR_HEAD, 3, 0)
|
|
ELSE
|
|
REMOVE_PED_HELMET(ped, TRUE)
|
|
//CLEAR_PED_PROP(ped, ANCHOR_HEAD)
|
|
ENDIF
|
|
|
|
RELEASE_PED_PRELOAD_PROP_DATA(ped)
|
|
ENDIF
|
|
BREAK
|
|
|
|
CASE CHAR_FRANKLIN
|
|
SET_PED_COMP_ITEM_CURRENT_SP(ped, COMP_TYPE_OUTFIT, OUTFIT_P1_HOODIE_AND_JEANS_1, FALSE) // remember to change at dummy!
|
|
BREAK
|
|
|
|
CASE CHAR_TREVOR
|
|
SET_PED_COMP_ITEM_CURRENT_SP(ped, COMP_TYPE_OUTFIT, OUTFIT_P2_TSHIRT_CARGOPANTS_2, FALSE)
|
|
BREAK
|
|
ENDSWITCH
|
|
ENDIF
|
|
ENDPROC
|
|
|
|
// muffle heli sound indoors
|
|
PROC MUFFLE_HELI_SOUND_INDOORS(BOOL bMuffle)
|
|
IF bMuffle
|
|
START_SNATCH_AND_GRAB_AUDIO_SCENE(SNATCH_AND_GRAB_AUDIO_SCENE_INDOOR)
|
|
PLAY_SOUND_FRONTEND(iFaintHeliSoundID, "FBI_02_SNATCH_AND_GRAB_AMB_HELI")
|
|
ELSE
|
|
STOP_SNATCH_AND_GRAB_AUDIO_SCENE(SNATCH_AND_GRAB_AUDIO_SCENE_INDOOR)
|
|
STOP_SOUND(iFaintHeliSoundID)
|
|
ENDIF
|
|
ENDPROC
|
|
|
|
// michael sit in chopper
|
|
PROC DO_MICHAEL_SIT_IN_CHOPPER()
|
|
IF NOT IS_PED_INJURED(sSelectorPeds.pedID[SELECTOR_PED_MICHAEL])
|
|
// TASK_PLAY_ANIM(sSelectorPeds.pedID[SELECTOR_PED_MICHAEL], "VEH@STD@PS@BASE", "sit", INSTANT_BLEND_IN, INSTANT_BLEND_OUT, -1, AF_LOOPING)
|
|
ENDIF
|
|
ENDPROC
|
|
|
|
// apply attributes
|
|
PROC APPLY_PLAYER_ATTRIBUTES(PED_INDEX ped)
|
|
SET_BLOCKING_OF_NON_TEMPORARY_EVENTS(ped, TRUE)
|
|
SET_PED_RELATIONSHIP_GROUP_HASH(ped, RELGROUPHASH_PLAYER)
|
|
SET_PED_CAN_BE_TARGETTED(ped, FALSE)
|
|
SET_PED_KEEP_TASK(ped, TRUE)
|
|
SET_PED_CONFIG_FLAG(ped, PCF_WillFlyThroughWindscreen, FALSE)
|
|
SET_PED_CONFIG_FLAG(ped, PCF_DisableExplosionReactions, TRUE)
|
|
SET_PED_CONFIG_FLAG(ped, PCF_RunFromFiresAndExplosions, FALSE)
|
|
SET_ENTITY_ONLY_DAMAGED_BY_PLAYER(ped, TRUE)
|
|
SET_ENTITY_AS_MISSION_ENTITY(ped, TRUE, TRUE)
|
|
ENDPROC
|
|
|
|
// create player character
|
|
PROC SNATCH_AND_GRAB_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
|
|
ENDIF
|
|
|
|
IF NOT IS_PED_INJURED(sSelectorPeds.pedID[selectorSlot])
|
|
APPLY_PLAYER_ATTRIBUTES(sSelectorPeds.pedID[selectorSlot])
|
|
|
|
SWITCH createChar
|
|
CASE CHAR_FRANKLIN
|
|
SET_PED_HELMET(sSelectorPeds.pedID[selectorSlot], FALSE)
|
|
ADD_PED_FOR_DIALOGUE(snatchAndGrabConversation, 2, sSelectorPeds.pedID[selectorSlot], "FRANKLIN")
|
|
BREAK
|
|
CASE CHAR_MICHAEL
|
|
// passenger index 1
|
|
SET_PED_GROUP_MEMBER_PASSENGER_INDEX(sSelectorPeds.pedID[selectorSlot], VS_BACK_LEFT)
|
|
SET_PED_GET_OUT_UPSIDE_DOWN_VEHICLE(sSelectorPeds.pedID[selectorSlot], FALSE)
|
|
|
|
IF setStage = STAGE_GET_TO_BUILDING
|
|
DO_MICHAEL_SIT_IN_CHOPPER()
|
|
ENDIF
|
|
|
|
ADD_PED_FOR_DIALOGUE(snatchAndGrabConversation, 0, sSelectorPeds.pedID[selectorSlot], "MICHAEL")
|
|
BREAK
|
|
CASE CHAR_TREVOR
|
|
ADD_PED_FOR_DIALOGUE(snatchAndGrabConversation, 1, sSelectorPeds.pedID[selectorSlot], "TREVOR")
|
|
BREAK
|
|
ENDSWITCH
|
|
|
|
SETUP_PLAYER_CHARACTER_WITH_MISSION_VARIATIONS(sSelectorPeds.pedID[selectorSlot], createChar, setStage)
|
|
ENDIF
|
|
ENDPROC
|
|
|
|
// set player in vehicle if not already in
|
|
PROC SET_PLAYER_PED_INTO_SNATCH_AND_GRAB_VEHICLE(SNATCH_AND_GRAB_VEHICLE_ENUM sagVehicle, VEHICLE_SEAT seat, BOOL bKeepVehicle = TRUE)
|
|
IF NOT IS_PED_INJURED(PLAYER_PED_ID())
|
|
IF IS_VEHICLE_DRIVEABLE(snatchAndGrabVehicle[sagVehicle])
|
|
IF NOT IS_PED_IN_VEHICLE(PLAYER_PED_ID(), snatchAndGrabVehicle[sagVehicle])
|
|
SET_PED_INTO_VEHICLE(PLAYER_PED_ID(), snatchAndGrabVehicle[sagVehicle], seat)
|
|
IF NOT bKeepVehicle
|
|
SET_VEHICLE_AS_NO_LONGER_NEEDED(snatchAndGrabVehicle[sagVehicle])
|
|
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)
|
|
VECTOR vCreatePos
|
|
FLOAT fCreateRot
|
|
|
|
// create transport
|
|
SWITCH setStage
|
|
CASE STAGE_GET_TO_CHOPPER
|
|
SNATCH_AND_GRAB_CREATE_VEHICLE(SAGV_MICHAEL_CAR, GET_SNATCH_AND_GRAB_VECTOR(SAGVEC_MICHAEL_CAR_INIT), MICHAEL_CAR_INIT_ROT)
|
|
|
|
// SNATCH_AND_GRAB_CREATE_VEHICLE(SAGV_TREVOR_JEEP, GET_SNATCH_AND_GRAB_VECTOR(SAGVEC_JEEP_INIT), JEEP_INIT_ROT)
|
|
BREAK
|
|
CASE STAGE_GET_TO_BUILDING
|
|
IF NOT bForcePassOnShitskip
|
|
vCreatePos = GET_SNATCH_AND_GRAB_VECTOR(SAGVEC_CHOPPER_INIT)
|
|
fCreateRot = CHOPPER_INIT_ROT
|
|
ELSE
|
|
vCreatePos = GET_SNATCH_AND_GRAB_VECTOR(SAGVEC_HOVER_TARGET)
|
|
fCreateRot = CHOPPER_HOVER_ROT
|
|
ENDIF
|
|
|
|
SNATCH_AND_GRAB_CREATE_VEHICLE(SAGV_PLAYER_CHOPPER, vCreatePos, fCreateRot, TRUE, TRUE, FALSE, FALSE)
|
|
// SNATCH_AND_GRAB_CREATE_VEHICLE(SAGV_TREVOR_JEEP, GET_SNATCH_AND_GRAB_VECTOR(SAGVEC_TREVOR_INIT), TREVOR_INIT_ROT)
|
|
BREAK
|
|
CASE STAGE_RAPPEL_DOWN
|
|
SNATCH_AND_GRAB_CREATE_VEHICLE(SAGV_PLAYER_CHOPPER, GET_SNATCH_AND_GRAB_VECTOR(SAGVEC_CHOPPER_HOVER), CHOPPER_HOVER_ROT)
|
|
BREAK
|
|
CASE STAGE_SNIPE_GUARDS
|
|
SNATCH_AND_GRAB_CREATE_VEHICLE(SAGV_PLAYER_CHOPPER, GET_SNATCH_AND_GRAB_VECTOR(SAGVEC_CHOPPER_HOVER), CHOPPER_HOVER_ROT)
|
|
BREAK
|
|
CASE STAGE_CHOPPER_CHASE
|
|
SNATCH_AND_GRAB_CREATE_VEHICLE(SAGV_PLAYER_CHOPPER, GET_SNATCH_AND_GRAB_VECTOR(SAGVEC_CHOPPER_HOVER), CHOPPER_HOVER_ROT)
|
|
// SNATCH_AND_GRAB_CREATE_VEHICLE(SAGV_TREVOR_JEEP, GET_SNATCH_AND_GRAB_VECTOR(SAGVEC_TREVOR_INIT), TREVOR_INIT_ROT)
|
|
BREAK
|
|
CASE STAGE_DROPOFF
|
|
IF NOT bForcePassOnShitskip
|
|
vCreatePos = GET_SNATCH_AND_GRAB_VECTOR(SAGVEC_CHASE_END)
|
|
fCreateRot = CHOPPER_CHASE_END_ROT
|
|
ELSE
|
|
vCreatePos = GET_SNATCH_AND_GRAB_VECTOR(SAGVEC_DROPOFF)
|
|
fCreateRot = -124
|
|
ENDIF
|
|
|
|
SNATCH_AND_GRAB_CREATE_VEHICLE(SAGV_PLAYER_CHOPPER, vCreatePos, fCreateRot)
|
|
// SNATCH_AND_GRAB_CREATE_VEHICLE(SAGV_TREVOR_JEEP, GET_SNATCH_AND_GRAB_VECTOR(SAGVEC_TREVOR_INIT), TREVOR_INIT_ROT)
|
|
BREAK
|
|
ENDSWITCH
|
|
|
|
// create the player characters
|
|
SWITCH setStage
|
|
CASE STAGE_GET_TO_CHOPPER
|
|
|
|
BREAK
|
|
CASE STAGE_GET_TO_BUILDING
|
|
// michael
|
|
SNATCH_AND_GRAB_CREATE_PLAYER_CHARACTER(CHAR_MICHAEL, setStage, <<0,0,0>>, 0.0, snatchAndGrabVehicle[SAGV_PLAYER_CHOPPER], VS_BACK_LEFT)
|
|
// trevor
|
|
//SET_PED_INTO_VEHICLE(PLAYER_PED_ID(), snatchAndGrabVehicle[SAGV_PLAYER_CHOPPER])
|
|
BREAK
|
|
CASE STAGE_RAPPEL_DOWN
|
|
// trevor
|
|
SNATCH_AND_GRAB_CREATE_PLAYER_CHARACTER(CHAR_TREVOR, setStage, <<0,0,0>>, 0.0, snatchAndGrabVehicle[SAGV_PLAYER_CHOPPER], VS_DRIVER)
|
|
BREAK
|
|
CASE STAGE_SNIPE_GUARDS
|
|
// trevor
|
|
SNATCH_AND_GRAB_CREATE_PLAYER_CHARACTER(CHAR_TREVOR, setStage, <<0,0,0>>, 0.0, snatchAndGrabVehicle[SAGV_PLAYER_CHOPPER], VS_DRIVER)
|
|
// michael
|
|
SNATCH_AND_GRAB_CREATE_PLAYER_CHARACTER(CHAR_MICHAEL, setStage, GET_SNATCH_AND_GRAB_VECTOR(SAGVEC_BREAK_IN), BREAK_IN_ROT)
|
|
// franklin
|
|
//SET_ENTITY_COORDS(PLAYER_PED_ID(), GET_SNATCH_AND_GRAB_VECTOR(SAGVEC_BEHIND_SNIPER))
|
|
//SET_ENTITY_HEADING(PLAYER_PED_ID(), FRANKLIN_SNIPER_ROT)
|
|
//FREEZE_ENTITY_POSITION(PLAYER_PED_ID(), TRUE)
|
|
BREAK
|
|
CASE STAGE_CHOPPER_CHASE
|
|
// trevor
|
|
SNATCH_AND_GRAB_CREATE_PLAYER_CHARACTER(CHAR_TREVOR, setStage, <<0,0,0>>, 0.0, snatchAndGrabVehicle[SAGV_PLAYER_CHOPPER], VS_DRIVER)
|
|
// michael
|
|
SNATCH_AND_GRAB_CREATE_PLAYER_CHARACTER(CHAR_MICHAEL, setStage, <<0,0,0>>, 0.0, snatchAndGrabVehicle[SAGV_PLAYER_CHOPPER], VS_BACK_LEFT)
|
|
// franklin
|
|
//SET_ENTITY_COORDS(PLAYER_PED_ID(), <<-139.47, -594.88, 210.77>>)
|
|
//SET_ENTITY_HEADING(PLAYER_PED_ID(), FRANKLIN_SNIPER_ROT)
|
|
BREAK
|
|
CASE STAGE_DROPOFF
|
|
// trevor
|
|
//SET_PLAYER_PED_INTO_SNATCH_AND_GRAB_VEHICLE(SAGV_PLAYER_CHOPPER, VS_DRIVER)
|
|
// michael
|
|
SNATCH_AND_GRAB_CREATE_PLAYER_CHARACTER(CHAR_MICHAEL, setStage, <<0,0,0>>, 0.0, snatchAndGrabVehicle[SAGV_PLAYER_CHOPPER], VS_BACK_LEFT)
|
|
BREAK
|
|
ENDSWITCH
|
|
ENDPROC
|
|
|
|
// set dave at the car
|
|
PROC SET_DAVE_AT_CAR()
|
|
IF NOT IS_PED_INJURED(davePed)
|
|
CLEAR_PED_TASKS_IMMEDIATELY(davePed)
|
|
SET_ENTITY_COORDS(davePed, GET_SNATCH_AND_GRAB_VECTOR(SAGVEC_DAVE_INIT))
|
|
SET_ENTITY_HEADING(davePed, DAVE_INIT_ROT)
|
|
// FORCE_PED_MOTION_STATE(davePed, MS_ON_FOOT_IDLE, TRUE, FAUS_CUTSCENE_EXIT)
|
|
ENDIF
|
|
ENDPROC
|
|
|
|
// create dave
|
|
PROC CREATE_DAVE(BOOL bWait)
|
|
IF IS_PED_INJURED(davePed)
|
|
IF NOT g_bMagDemoActive
|
|
CREATE_NPC_PED_ON_FOOT(davePed, CHAR_DAVE, GET_SNATCH_AND_GRAB_VECTOR(SAGVEC_DAVE_INIT2), DAVE_INIT_ROT2, FALSE)
|
|
ELSE
|
|
/*
|
|
IF IS_VEHICLE_DRIVEABLE(snatchAndGrabVehicle[SAGV_MICHAEL_CAR])
|
|
davePed = GET_PED_IN_VEHICLE_SEAT(snatchAndGrabVehicle[SAGV_MICHAEL_CAR], VS_FRONT_RIGHT)
|
|
IF NOT IS_PED_INJURED(davePed)
|
|
SET_ENTITY_AS_MISSION_ENTITY(davePed, TRUE, TRUE)
|
|
CLEAR_PED_TASKS(davePed)
|
|
PRINTSTRING("successfully got dave from switch!") PRINTNL()
|
|
ELSE
|
|
PRINTSTRING("failed getting dave from switch!") PRINTNL()
|
|
IF bDebugSkipMagdemoStart
|
|
CREATE_NPC_PED_INSIDE_VEHICLE(davePed, CHAR_DAVE, snatchAndGrabVehicle[SAGV_MICHAEL_CAR], VS_FRONT_RIGHT, FALSE)
|
|
ELSE
|
|
CREATE_NPC_PED_ON_FOOT(davePed, CHAR_DAVE, GET_SNATCH_AND_GRAB_VECTOR(SAGVEC_DAVE_INIT), DAVE_INIT_ROT, FALSE)
|
|
ENDIF
|
|
ENDIF
|
|
ELSE
|
|
CREATE_NPC_PED_ON_FOOT(davePed, CHAR_DAVE, GET_SNATCH_AND_GRAB_VECTOR(SAGVEC_DAVE_INIT), DAVE_INIT_ROT, FALSE)
|
|
ENDIF
|
|
*/
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF NOT IS_PED_INJURED(davePed)
|
|
//SET_BLOCKING_OF_NON_TEMPORARY_EVENTS(davePed, TRUE)
|
|
SET_PED_DIES_WHEN_INJURED(davePed, TRUE)
|
|
SET_PED_KEEP_TASK(davePed, TRUE)
|
|
SET_PED_GROUP_MEMBER_PASSENGER_INDEX(davePed, VS_FRONT_RIGHT)
|
|
SET_PED_CONFIG_FLAG(davePed, PCF_WillFlyThroughWindscreen, FALSE)
|
|
SET_PED_CONFIG_FLAG(davePed, PCF_DontAllowToBeDraggedOutOfVehicle, TRUE)
|
|
SET_PED_CONFIG_FLAG(davePed, PCF_RunFromFiresAndExplosions, FALSE)
|
|
SET_PED_CONFIG_FLAG(davePed, PCF_ForcedToUseSpecificGroupSeatIndex, TRUE)
|
|
SET_PED_CONFIG_FLAG(davePed, PCF_ForceIgnoreMeleeActiveCombatant, TRUE)
|
|
SET_PED_CONFIG_FLAG(davePed, PCF_LawWillOnlyAttackIfPlayerIsWanted, TRUE)
|
|
SET_PED_GET_OUT_UPSIDE_DOWN_VEHICLE(davePed, FALSE)
|
|
SET_PED_RELATIONSHIP_GROUP_HASH(davePed, RELGROUPHASH_PLAYER)
|
|
SET_PED_CAN_BE_TARGETTED(davePed, FALSE)
|
|
SET_ENTITY_PROOFS(davePed, FALSE, FALSE, FALSE, FALSE, FALSE)
|
|
ADD_PED_FOR_DIALOGUE(snatchAndGrabConversation, 4, davePed, "DAVE")
|
|
ENDIF
|
|
|
|
IF bWait
|
|
BOOL bFullyStreamed = FALSE
|
|
WHILE NOT bFullyStreamed
|
|
WAIT(0)
|
|
IF NOT IS_PED_INJURED(davePed)
|
|
IF HAVE_ALL_STREAMING_REQUESTS_COMPLETED(davePed)
|
|
bFullyStreamed = TRUE
|
|
ENDIF
|
|
ELSE
|
|
bFullyStreamed = TRUE
|
|
ENDIF
|
|
ENDWHILE
|
|
ENDIF
|
|
|
|
bDaveSeated = FALSE
|
|
ENDPROC
|
|
|
|
PROC CREATE_COFFEE()
|
|
INT i
|
|
VECTOR vCoffeePos
|
|
FLOAT fCoffeeRot
|
|
REPEAT 3 i
|
|
|
|
SWITCH i
|
|
CASE 0
|
|
vCoffeePos = <<148.2658, -677.0385, 41.9132>>
|
|
fCoffeeRot = 0
|
|
BREAK
|
|
CASE 1
|
|
vCoffeePos = <<148.0695, -677.3365, 41.9132>>
|
|
fCoffeeRot = 179.9
|
|
BREAK
|
|
CASE 2
|
|
vCoffeePos = <<148.5073, -677.2362, 41.9132>>
|
|
fCoffeeRot = 115.18
|
|
BREAK
|
|
ENDSWITCH
|
|
|
|
IF NOT DOES_ENTITY_EXIST(coffeeObject[i])
|
|
coffeeObject[i] = CREATE_OBJECT_NO_OFFSET(P_ING_COFFEECUP_01, vCoffeePos)
|
|
ELSE
|
|
SET_ENTITY_COORDS_NO_OFFSET(coffeeObject[i], vCoffeePos)
|
|
ENDIF
|
|
|
|
FREEZE_ENTITY_POSITION(coffeeObject[i], TRUE)
|
|
SET_ENTITY_HEADING(coffeeObject[i], fCoffeeRot)
|
|
|
|
ENDREPEAT
|
|
ENDPROC
|
|
|
|
// create steve and andreas
|
|
PROC CREATE_STEVE_AND_ANDREAS(BOOL bWait)
|
|
IF NOT DOES_ENTITY_EXIST(stevePed)
|
|
CREATE_NPC_PED_ON_FOOT(stevePed, CHAR_STEVE, <<156.89864, -672.97455, 41.02924>>, 0, FALSE)
|
|
ENDIF
|
|
IF NOT DOES_ENTITY_EXIST(andreasPed)
|
|
CREATE_NPC_PED_ON_FOOT(andreasPed, CHAR_ANDREAS, <<159.77484, -678.42975, 41.02924>>, 0, FALSE)
|
|
ENDIF
|
|
|
|
IF NOT IS_PED_INJURED(stevePed)
|
|
SET_BLOCKING_OF_NON_TEMPORARY_EVENTS(stevePed, TRUE)
|
|
SET_PED_DIES_WHEN_INJURED(stevePed, TRUE)
|
|
SET_PED_KEEP_TASK(stevePed, TRUE)
|
|
SET_PED_CONFIG_FLAG(stevePed, PCF_RunFromFiresAndExplosions, FALSE)
|
|
SET_PED_CONFIG_FLAG(stevePed, PCF_DisableExplosionReactions, TRUE)
|
|
SET_ENTITY_ONLY_DAMAGED_BY_PLAYER(stevePed, TRUE)
|
|
SET_PED_RELATIONSHIP_GROUP_HASH(stevePed, RELGROUPHASH_PLAYER)
|
|
SET_PED_CAN_BE_TARGETTED(stevePed, FALSE)
|
|
ADD_PED_FOR_DIALOGUE(snatchAndGrabConversation, 5, stevePed, "Steve")
|
|
bSteveSeated = FALSE
|
|
ENDIF
|
|
|
|
IF NOT IS_PED_INJURED(andreasPed)
|
|
SET_BLOCKING_OF_NON_TEMPORARY_EVENTS(andreasPed, TRUE)
|
|
SET_PED_DIES_WHEN_INJURED(andreasPed, TRUE)
|
|
SET_PED_KEEP_TASK(andreasPed, TRUE)
|
|
SET_PED_CONFIG_FLAG(andreasPed, PCF_RunFromFiresAndExplosions, FALSE)
|
|
SET_PED_CONFIG_FLAG(andreasPed, PCF_DisableExplosionReactions, TRUE)
|
|
SET_ENTITY_ONLY_DAMAGED_BY_PLAYER(andreasPed, TRUE)
|
|
SET_PED_RELATIONSHIP_GROUP_HASH(andreasPed, RELGROUPHASH_PLAYER)
|
|
SET_PED_CAN_BE_TARGETTED(andreasPed, FALSE)
|
|
ADD_PED_FOR_DIALOGUE(snatchAndGrabConversation, 6, andreasPed, "Andreas")
|
|
bAndreasSeated = FALSE
|
|
ENDIF
|
|
|
|
IF bWait
|
|
BOOL bFullyStreamed = FALSE
|
|
WHILE NOT bFullyStreamed
|
|
WAIT(0)
|
|
IF NOT IS_PED_INJURED(stevePed)
|
|
AND NOT IS_PED_INJURED(andreasPed)
|
|
IF HAVE_ALL_STREAMING_REQUESTS_COMPLETED(stevePed)
|
|
AND HAVE_ALL_STREAMING_REQUESTS_COMPLETED(andreasPed)
|
|
bFullyStreamed = TRUE
|
|
ENDIF
|
|
ELSE
|
|
bFullyStreamed = TRUE
|
|
ENDIF
|
|
ENDWHILE
|
|
ENDIF
|
|
ENDPROC
|
|
|
|
// create the fbi
|
|
PROC CREATE_FBI_FOR_STAGE(MISSION_STAGE_ENUM createStage)
|
|
INT i
|
|
SNATCH_AND_GRAB_MODEL_ENUM thisModel
|
|
INT iHead
|
|
INT iHeadTexture
|
|
INT iTorsoTexture
|
|
INT iLegTexture
|
|
VECTOR vPos
|
|
FLOAT fRot
|
|
|
|
iHead=iHead
|
|
iHeadTexture=iHeadTexture
|
|
iTorsoTexture=iTorsoTexture
|
|
iLegTexture=iLegTexture
|
|
|
|
IF createStage = STAGE_GET_TO_CHOPPER
|
|
thisModel = SAGM_FBI
|
|
ELSE
|
|
thisModel = SAGM_FBIEND
|
|
ENDIF
|
|
|
|
// fbi van
|
|
IF createStage >= STAGE_CHOPPER_CHASE
|
|
fbiVanVehicle = CREATE_VEHICLE(GET_MODEL_FOR_SNATCH_AND_GRAB_MODEL_ENUM(SAGM_FBI_VAN), <<1386.65, -2064.32, 51.08>>, -14.9)
|
|
SET_VEHICLE_ON_GROUND_PROPERLY(fbiVanVehicle)
|
|
SET_VEHICLE_COLOUR_COMBINATION(fbiVanVehicle, 0)
|
|
SET_VEHICLE_DIRT_LEVEL(fbiVanVehicle, 0.2)
|
|
SET_VEHICLE_LIVERY(fbiVanVehicle, 0)
|
|
SET_ENTITY_ONLY_DAMAGED_BY_PLAYER(fbiVanVehicle, TRUE)
|
|
SET_VEHICLE_DOORS_LOCKED(fbiVanVehicle, VEHICLELOCK_LOCKOUT_PLAYER_ONLY)
|
|
SET_DOOR_ALLOWED_TO_BE_BROKEN_OFF(fbiVanVehicle, SC_DOOR_REAR_LEFT, FALSE)
|
|
SET_DOOR_ALLOWED_TO_BE_BROKEN_OFF(fbiVanVehicle, SC_DOOR_REAR_RIGHT, FALSE)
|
|
FOR i=1 TO 8
|
|
SET_VEHICLE_EXTRA(fbiVanVehicle, i, TRUE)
|
|
ENDFOR
|
|
ENDIF
|
|
|
|
IF NOT g_bMagDemoActive
|
|
OR bDebugSkipMagdemoZskipped
|
|
OR createStage >= STAGE_CHOPPER_CHASE
|
|
// fbi peds
|
|
INT iNumber
|
|
IF createStage = STAGE_GET_TO_CHOPPER
|
|
iNumber = 1
|
|
ELSE
|
|
iNumber = 2
|
|
ENDIF
|
|
|
|
REPEAT iNumber i
|
|
// get create attributes
|
|
SWITCH i
|
|
CASE 0
|
|
IF createStage = STAGE_GET_TO_CHOPPER
|
|
vPos = <<1372.20, -2073.76, 51.12>>
|
|
fRot = -38.38
|
|
ELSE
|
|
vPos = <<1384.95251, -2062.89404, 50.99809>>
|
|
fRot = 79.0
|
|
ENDIF
|
|
iHead = 1
|
|
iHeadTexture = 0
|
|
iTorsoTexture = 2
|
|
iLegTexture = 2
|
|
BREAK
|
|
CASE 1
|
|
IF createStage = STAGE_GET_TO_CHOPPER
|
|
vPos = <<1361.57, -2075.04, 51.00>>
|
|
fRot = -55.99
|
|
ELSE
|
|
vPos = <<1381.77979, -2066.46875, 50.99809>>
|
|
fRot = 68.6
|
|
ENDIF
|
|
iHead = 0
|
|
iHeadTexture = 1
|
|
iTorsoTexture = 1
|
|
iLegTexture = 1
|
|
BREAK
|
|
ENDSWITCH
|
|
|
|
fbiPed[i] = CREATE_PED(PEDTYPE_MISSION, GET_MODEL_FOR_SNATCH_AND_GRAB_MODEL_ENUM(thisModel), vPos, fRot)
|
|
|
|
IF createStage >= STAGE_CHOPPER_CHASE
|
|
SET_PED_COMPONENT_VARIATION(fbiPed[i], PED_COMP_HEAD, iHead, iHeadTexture)
|
|
SET_PED_COMPONENT_VARIATION(fbiPed[i], PED_COMP_TORSO, 0, iTorsoTexture)
|
|
SET_PED_COMPONENT_VARIATION(fbiPed[i], PED_COMP_LEG, 0, iLegTexture)
|
|
SET_PED_CONFIG_FLAG(fbiPed[i], PCF_DisableShockingEvents, TRUE)
|
|
SET_PED_CONFIG_FLAG(fbiPed[i], PCF_DisableShockingDrivingOnPavementEvents, TRUE)
|
|
ELSE
|
|
SET_ENTITY_LOD_DIST(fbiPed[i], 200)
|
|
ENDIF
|
|
|
|
GIVE_WEAPON_TO_PED(fbiPed[i], GET_SNATCH_AND_GRAB_WEAPON_TYPE(SAG_WEAPON_CIA_PISTOL), INFINITE_AMMO, FALSE)
|
|
SET_BLOCKING_OF_NON_TEMPORARY_EVENTS(fbiPed[i], TRUE)
|
|
SET_PED_CAN_BE_TARGETTED(fbiPed[i], FALSE)
|
|
SET_PED_RELATIONSHIP_GROUP_HASH(fbiPed[i], RELGROUPHASH_PLAYER)
|
|
SET_PED_KEEP_TASK(fbiPed[i], TRUE)
|
|
SET_PED_DIES_WHEN_INJURED(fbiPed[i], TRUE)
|
|
SET_ENTITY_ONLY_DAMAGED_BY_PLAYER(fbiPed[i], TRUE)
|
|
ENDREPEAT
|
|
ELSE
|
|
fbiPed[0] = g_sMagDemoFBI2Entities.fibPed
|
|
IF NOT IS_PED_INJURED(fbiPed[0])
|
|
PRINTSTRING("successfully got agent from switch!") PRINTNL()
|
|
SET_ENTITY_AS_MISSION_ENTITY(fbiPed[0], TRUE, TRUE)
|
|
SET_BLOCKING_OF_NON_TEMPORARY_EVENTS(fbiPed[0], TRUE)
|
|
SET_PED_KEEP_TASK(fbiPed[0], TRUE)
|
|
SET_PED_DIES_WHEN_INJURED(fbiPed[0], TRUE)
|
|
SET_ENTITY_ONLY_DAMAGED_BY_PLAYER(fbiPed[0], TRUE)
|
|
ELSE
|
|
PRINTSTRING("failed getting agent from switch!") PRINTNL()
|
|
ENDIF
|
|
ENDIF
|
|
ENDPROC
|
|
|
|
// create FBI meeting
|
|
PROC CREATE_FBI_MEETING_VEHICLES()
|
|
SNATCH_AND_GRAB_CREATE_VEHICLE(SAGV_PLAYER_CHOPPER, GET_SNATCH_AND_GRAB_VECTOR(SAGVEC_CHOPPER_INIT), CHOPPER_INIT_ROT, TRUE, TRUE, FALSE, FALSE)
|
|
SNATCH_AND_GRAB_CREATE_VEHICLE(SAGV_FRANKLIN_BIKE, GET_SNATCH_AND_GRAB_VECTOR(SAGVEC_BIKE_INIT), BIKE_INIT_ROT)
|
|
|
|
SET_ENTITY_SHOULD_FREEZE_WAITING_ON_COLLISION(snatchAndGrabVehicle[SAGV_PLAYER_CHOPPER], TRUE)
|
|
SET_VEHICLE_DOORS_LOCKED(snatchAndGrabVehicle[SAGV_PLAYER_CHOPPER], VEHICLELOCK_LOCKOUT_PLAYER_ONLY)
|
|
ENDPROC
|
|
|
|
PROC CREATE_FBI_MEETING_PEDS()
|
|
CREATE_FBI_FOR_STAGE(STAGE_GET_TO_CHOPPER)
|
|
SNATCH_AND_GRAB_CREATE_PLAYER_CHARACTER(CHAR_TREVOR, STAGE_GET_TO_CHOPPER, GET_SNATCH_AND_GRAB_VECTOR(SAGVEC_TREVOR_INIT), TREVOR_INIT_ROT)
|
|
SNATCH_AND_GRAB_CREATE_PLAYER_CHARACTER(CHAR_FRANKLIN, STAGE_GET_TO_CHOPPER, <<1374.30, -2076.91, 51.00>>, 0)
|
|
ENDPROC
|
|
|
|
PROC CREATE_UTIL_TRUCKS(MISSION_STAGE_ENUM createStage)
|
|
VECTOR vPos
|
|
FLOAT fRot
|
|
FLOAT fDirt
|
|
SNATCH_AND_GRAB_MODEL_ENUM model
|
|
|
|
INT i, j
|
|
INT iCountTo
|
|
IF createStage = STAGE_GET_TO_CHOPPER
|
|
iCountTo = 2
|
|
ELSE
|
|
iCountTo = 1
|
|
ENDIF
|
|
|
|
FOR i=0 TO iCountTo
|
|
SWITCH i
|
|
CASE 0
|
|
model = SAGM_UTIL_TRUCK_2
|
|
vPos = <<1390.31, -2050.63, 51.00>>
|
|
fRot = 74.2
|
|
fDirt = 0.19
|
|
BREAK
|
|
CASE 1
|
|
model = SAGM_UTIL_TRUCK_1
|
|
vPos = <<1400.29, -2053.63, 51.00>>
|
|
fRot = 166.8
|
|
fDirt = 0.37
|
|
BREAK
|
|
CASE 2
|
|
model = SAGM_FBI_CAR
|
|
vPos = <<1365.29, -2065.67, 51.00>>
|
|
fRot = -83.30
|
|
fDirt = 0.0
|
|
BREAK
|
|
ENDSWITCH
|
|
|
|
IF g_bMagDemoActive
|
|
SWITCH i
|
|
CASE 0
|
|
utilTruckVehicle[i] = g_sMagDemoFBI2Entities.truck01Vehicle
|
|
BREAK
|
|
CASE 1
|
|
utilTruckVehicle[i] = g_sMagDemoFBI2Entities.truck02Vehicle
|
|
BREAK
|
|
CASE 2
|
|
utilTruckVehicle[i] = g_sMagDemoFBI2Entities.fibVehicle
|
|
BREAK
|
|
ENDSWITCH
|
|
|
|
IF IS_VEHICLE_DRIVEABLE(utilTruckVehicle[i])
|
|
PRINTSTRING("successfully got vehicle from switch! ") PRINTINT(i) PRINTNL()
|
|
SET_ENTITY_AS_MISSION_ENTITY(utilTruckVehicle[i], TRUE, TRUE)
|
|
SET_ENTITY_INVINCIBLE(utilTruckVehicle[i], FALSE)
|
|
ELSE
|
|
PRINTSTRING("failed getting vehicle from switch! ") PRINTINT(i) PRINTNL()
|
|
ENDIF
|
|
ELSE
|
|
utilTruckVehicle[i] = CREATE_VEHICLE(GET_MODEL_FOR_SNATCH_AND_GRAB_MODEL_ENUM(model), vPos, fRot)
|
|
SET_VEHICLE_ON_GROUND_PROPERLY(utilTruckVehicle[i])
|
|
SET_VEHICLE_DIRT_LEVEL(utilTruckVehicle[i], fDirt)
|
|
SET_VEHICLE_DOORS_LOCKED(utilTruckVehicle[i], VEHICLELOCK_LOCKED)
|
|
SET_ENTITY_SHOULD_FREEZE_WAITING_ON_COLLISION(utilTruckVehicle[i], TRUE)
|
|
|
|
FOR j=1 TO 8
|
|
SET_VEHICLE_EXTRA(utilTruckVehicle[i], j, TRUE)
|
|
ENDFOR
|
|
|
|
IF i=1
|
|
SET_VEHICLE_EXTRA(utilTruckVehicle[i], 3, FALSE)
|
|
ELIF i=0
|
|
SET_VEHICLE_EXTRA(utilTruckVehicle[i], 1, FALSE)
|
|
SET_VEHICLE_EXTRA(utilTruckVehicle[i], 3, FALSE)
|
|
ENDIF
|
|
ENDIF
|
|
ENDFOR
|
|
ENDPROC
|
|
|
|
// cleanup a ped
|
|
PROC CLEANUP_PED(PED_INDEX entity, BOOL bDelete)
|
|
IF DOES_ENTITY_EXIST(entity)
|
|
IF NOT bDelete
|
|
SET_PED_AS_NO_LONGER_NEEDED(entity)
|
|
ELSE
|
|
DELETE_PED(entity)
|
|
ENDIF
|
|
ENDIF
|
|
ENDPROC
|
|
|
|
// cleanup a vehicle
|
|
PROC CLEANUP_VEHICLE(VEHICLE_INDEX entity, BOOL bDelete)
|
|
IF DOES_ENTITY_EXIST(entity)
|
|
IF NOT bDelete
|
|
SET_VEHICLE_AS_NO_LONGER_NEEDED(entity)
|
|
ELSE
|
|
DELETE_VEHICLE(entity)
|
|
ENDIF
|
|
ENDIF
|
|
ENDPROC
|
|
|
|
// cleanup FBI
|
|
PROC CLEANUP_FBI(BOOL bDelete = FALSE)
|
|
INT i
|
|
|
|
// peds
|
|
REPEAT NUMBER_FBI_AGENTS i
|
|
CLEANUP_PED(fbiPed[i], bDelete)
|
|
ENDREPEAT
|
|
|
|
// van
|
|
CLEANUP_VEHICLE(fbiVanVehicle, bDelete)
|
|
|
|
CLEAR_MODEL_REQUEST(ENUM_TO_INT(SAGM_FBI))
|
|
CLEAR_MODEL_REQUEST(ENUM_TO_INT(SAGM_FBIEND))
|
|
CLEAR_MODEL_REQUEST(ENUM_TO_INT(SAGM_FBI_VAN))
|
|
ENDPROC
|
|
|
|
// cleanup dave
|
|
PROC CLEANUP_DAVE(BOOL bDelete = FALSE)
|
|
CLEANUP_PED(davePed, bDelete)
|
|
CLEANUP_VEHICLE(snatchAndGrabVehicle[SAGV_MICHAEL_CAR], bDelete)
|
|
REMOVE_PED_FOR_DIALOGUE(snatchAndGrabConversation, 4)
|
|
CLEAR_MODEL_REQUEST(ENUM_TO_INT(SAGM_DAVE))
|
|
ENDPROC
|
|
|
|
// create the prisoner
|
|
PROC CREATE_PRISONER_FOR_STAGE(MISSION_STAGE_ENUM createStage)
|
|
IF NOT DOES_ENTITY_EXIST(prisonerPed)
|
|
VECTOR vPos
|
|
FLOAT fRot
|
|
SWITCH createStage
|
|
CASE STAGE_RAPPEL_DOWN
|
|
CASE STAGE_SNIPE_GUARDS
|
|
CASE STAGE_CHOPPER_CHASE
|
|
CASE STAGE_DROPOFF
|
|
vPos = GET_SNATCH_AND_GRAB_VECTOR(SAGVEC_PRISONER_INIT)
|
|
fRot = PRISONER_INIT_ROT
|
|
BREAK
|
|
ENDSWITCH
|
|
|
|
SNATCH_AND_GRAB_MODEL_ENUM modelEnum
|
|
IF createStage = STAGE_RAPPEL_DOWN
|
|
modelEnum = SAGM_PRISONER_HIGH
|
|
ELSE
|
|
modelEnum = SAGM_PRISONER_LOW
|
|
ENDIF
|
|
|
|
prisonerPed = CREATE_PED(PEDTYPE_MISSION, GET_MODEL_FOR_SNATCH_AND_GRAB_MODEL_ENUM(modelEnum), vPos, fRot)
|
|
|
|
SET_PED_COMPONENT_VARIATION(prisonerPed, PED_COMP_HEAD, 0, 0)
|
|
SET_PED_COMPONENT_VARIATION(prisonerPed, PED_COMP_BERD, 0, 0)
|
|
SET_PED_COMPONENT_VARIATION(prisonerPed, PED_COMP_TORSO, 0, 0)
|
|
SET_PED_COMPONENT_VARIATION(prisonerPed, PED_COMP_FEET, 0, 0)
|
|
SET_PED_COMPONENT_VARIATION(prisonerPed, PED_COMP_TEETH, 0, 0)
|
|
IF createStage = STAGE_SNIPE_GUARDS
|
|
SET_PED_COMPONENT_VARIATION(prisonerPed, PED_COMP_SPECIAL, 1, 0)
|
|
ELSE
|
|
SET_PED_COMPONENT_VARIATION(prisonerPed, PED_COMP_SPECIAL, 0, 0)
|
|
ENDIF
|
|
SET_PED_COMPONENT_VARIATION(prisonerPed, PED_COMP_SPECIAL2, 0, 0)
|
|
SET_PED_COMPONENT_VARIATION(prisonerPed, PED_COMP_DECL, 0, 0)
|
|
SET_PED_COMPONENT_VARIATION(prisonerPed, PED_COMP_JBIB, 0, 0)
|
|
|
|
SET_BLOCKING_OF_NON_TEMPORARY_EVENTS(prisonerPed, TRUE)
|
|
SET_PED_RELATIONSHIP_GROUP_HASH(prisonerPed, RELGROUPHASH_PLAYER)
|
|
//IF g_bMagDemoActive
|
|
// SET_ENTITY_CAN_BE_DAMAGED_BY_RELATIONSHIP_GROUP(prisonerPed, FALSE, RELGROUPHASH_PLAYER)
|
|
//ENDIF
|
|
SET_ENTITY_ONLY_DAMAGED_BY_PLAYER(prisonerPed, TRUE) // magdemo only
|
|
SET_PED_CAN_BE_TARGETTED(prisonerPed, FALSE)
|
|
SET_PED_CONFIG_FLAG(prisonerPed, PCF_DisableExplosionReactions, TRUE)
|
|
SET_PED_CONFIG_FLAG(prisonerPed, PCF_RunFromFiresAndExplosions, FALSE)
|
|
SET_ENTITY_ONLY_DAMAGED_BY_PLAYER(prisonerPed, TRUE)
|
|
SET_PED_KEEP_TASK(prisonerPed, TRUE)
|
|
SET_PED_DIES_WHEN_INJURED(prisonerPed, TRUE)
|
|
SET_ENTITY_LOAD_COLLISION_FLAG(prisonerPed, TRUE)
|
|
|
|
IF createStage >= STAGE_SNIPE_GUARDS
|
|
SET_PED_PRELOAD_VARIATION_DATA(prisonerPed, PED_COMP_SPECIAL, 2, 0)
|
|
ELSE
|
|
SET_PED_PRELOAD_VARIATION_DATA(prisonerPed, PED_COMP_SPECIAL, 1, 0)
|
|
ENDIF
|
|
|
|
ADD_PED_FOR_DIALOGUE(snatchAndGrabConversation, 3, prisonerPed, "MisterK")
|
|
ENDIF
|
|
ENDPROC
|
|
|
|
// setup prisoner with belt
|
|
PROC SETUP_PRISONER_WITH_BELT(BOOL bWait, MISSION_STAGE_ENUM setStage)
|
|
IF NOT IS_PED_INJURED(prisonerPed)
|
|
IF setStage >= STAGE_SNIPE_GUARDS
|
|
SET_PED_COMPONENT_VARIATION(prisonerPed, PED_COMP_SPECIAL, 1, 0)
|
|
ELSE
|
|
SET_PED_COMPONENT_VARIATION(prisonerPed, PED_COMP_SPECIAL, 1, 0)
|
|
ENDIF
|
|
|
|
IF bWait
|
|
BOOL bFullyStreamed = FALSE
|
|
WHILE NOT bFullyStreamed
|
|
WAIT(0)
|
|
IF NOT IS_PED_INJURED(prisonerPed)
|
|
IF HAVE_ALL_STREAMING_REQUESTS_COMPLETED(prisonerPed)
|
|
bFullyStreamed = TRUE
|
|
ENDIF
|
|
ELSE
|
|
bFullyStreamed = TRUE
|
|
ENDIF
|
|
ENDWHILE
|
|
ENDIF
|
|
ENDIF
|
|
ENDPROC
|
|
|
|
// belt off
|
|
PROC TAKE_OFF_PRISONER_BELT
|
|
IF NOT IS_PED_INJURED(prisonerPed)
|
|
SET_PED_COMPONENT_VARIATION(prisonerPed, PED_COMP_SPECIAL, 0, 0)
|
|
ENDIF
|
|
ENDPROC
|
|
|
|
// create michelle
|
|
PROC CREATE_MICHELLE_FOR_STAGE(MISSION_STAGE_ENUM createStage)
|
|
createstage = createstage
|
|
|
|
IF NOT DOES_ENTITY_EXIST(michellePed)
|
|
VECTOR vPos = GET_SNATCH_AND_GRAB_VECTOR(SAGVEC_MICHELLE_INIT)
|
|
FLOAT fRot = MICHELLE_INIT_ROT
|
|
|
|
michellePed = CREATE_PED(PEDTYPE_MISSION, GET_MODEL_FOR_SNATCH_AND_GRAB_MODEL_ENUM(SAGM_MICHELLE), vPos, fRot)
|
|
SET_PED_COMPONENT_VARIATION(michellePed,PED_COMP_HAIR,1,0)
|
|
SET_PED_COMPONENT_VARIATION(michellePed,PED_COMP_HEAD,0,0)
|
|
SET_PED_COMPONENT_VARIATION(michellePed,PED_COMP_TORSO,0,0)
|
|
SET_PED_COMPONENT_VARIATION(michellePed,PED_COMP_LEG,0,0)
|
|
|
|
ADD_PED_FOR_DIALOGUE(snatchAndGrabConversation, 6, michellePed, "MICHELLE")
|
|
|
|
torchObject = CREATE_OBJECT(GET_MODEL_FOR_SNATCH_AND_GRAB_MODEL_ENUM(SAGM_TORCH), <<1,2,3>>)
|
|
ATTACH_ENTITY_TO_ENTITY(torchObject, michellePed, GET_PED_BONE_INDEX(michellePed, BONETAG_PH_R_HAND), <<0, 0, 0>>, <<0, 0, 0>>)
|
|
SET_BLOCKING_OF_NON_TEMPORARY_EVENTS(michellePed, TRUE)
|
|
SET_ENTITY_ONLY_DAMAGED_BY_PLAYER(michellePed, TRUE)
|
|
SET_PED_CAN_BE_TARGETTED(michellePed, FALSE)
|
|
SET_PED_KEEP_TASK(michellePed, TRUE)
|
|
ENDIF
|
|
ENDPROC
|
|
|
|
FUNC VECTOR GET_ENEMY_CHOPPER_POS(INT i)
|
|
SWITCH i
|
|
CASE 0
|
|
RETURN <<-429, -507, 322>>
|
|
BREAK
|
|
CASE 1
|
|
RETURN <<-402, -794, 219>>
|
|
BREAK
|
|
CASE 2
|
|
RETURN <<83, -1025, 316>>
|
|
BREAK
|
|
CASE 3
|
|
RETURN <<336, -527, 338>>
|
|
BREAK
|
|
CASE 4
|
|
RETURN <<-20, -402, 257>>
|
|
BREAK
|
|
CASE 5
|
|
RETURN <<-84, -689, 211>>
|
|
BREAK
|
|
CASE 6
|
|
RETURN <<44, -1170, 106>>
|
|
BREAK
|
|
CASE 7
|
|
RETURN <<-390, -1085, 160>>
|
|
BREAK
|
|
CASE 8
|
|
RETURN <<-33, -518, 230>>
|
|
BREAK
|
|
CASE 9
|
|
RETURN <<39, -801, 177>>
|
|
BREAK
|
|
ENDSWITCH
|
|
|
|
RETURN <<-429, -507, 322>>
|
|
ENDFUNC
|
|
|
|
// create enemy chopper
|
|
PROC CREATE_ENEMY_CHOPPER(BOOL bInCutscene, BOOL bExtra = FALSE)
|
|
INT i
|
|
BOOL bDontCreate = FALSE
|
|
|
|
INT iStart
|
|
INT iEnd
|
|
|
|
IF NOT bExtra
|
|
iStart = 0
|
|
iEnd = 2
|
|
ELSE
|
|
iStart = 3
|
|
iEnd = 3
|
|
ENDIF
|
|
|
|
FOR i=iStart TO iEnd
|
|
VECTOR vPos
|
|
FLOAT fRot
|
|
INT iRec
|
|
FLOAT fSkip
|
|
SWITCH i
|
|
CASE 0
|
|
vPos = <<38.28, -692.31, 281.46>>
|
|
fRot= -41.9
|
|
iRec = 003
|
|
|
|
// the alt 8500
|
|
IF NOT bInCutscene
|
|
fSkip = WINCH_CUTSCENE_TIME + AFTER_CUTSCENE_TIME
|
|
ELSE
|
|
fSkip = 2000
|
|
ENDIF
|
|
BREAK
|
|
CASE 1
|
|
vPos = <<69.13, -710.32, 254.99>>
|
|
fRot = 8.26
|
|
iRec = 012
|
|
|
|
IF NOT bInCutscene
|
|
fSkip = WINCH_CUTSCENE_TIME + AFTER_CUTSCENE_TIME
|
|
ELSE
|
|
fSkip = 2000
|
|
ENDIF
|
|
BREAK
|
|
CASE 2
|
|
vPos = <<99.72, -628.75, 207.56>>
|
|
fRot = -19.67
|
|
iRec = 013
|
|
|
|
IF NOT bInCutscene
|
|
fSkip = WINCH_CUTSCENE_TIME + AFTER_CUTSCENE_LONG_TIME
|
|
ELSE
|
|
fSkip = 2000
|
|
ENDIF
|
|
BREAK
|
|
|
|
CASE 3
|
|
//vPos = <<99.72, -628.75, 207.56>>
|
|
//fRot = -19.67
|
|
INT iClosest
|
|
iClosest = -1
|
|
INT j
|
|
FLOAT fClosestDist
|
|
fClosestDist = 99999999.0
|
|
|
|
REPEAT 5 j
|
|
VECTOR vSpawnPos
|
|
vSpawnPos = GET_ENEMY_CHOPPER_POS(j)
|
|
FLOAT fThisDistance
|
|
fThisDistance = GET_DISTANCE_BETWEEN_COORDS(vSpawnPos, GET_ENTITY_COORDS(snatchAndGrabVehicle[SAGV_PLAYER_CHOPPER]), FALSE)
|
|
IF fThisDistance < fClosestDist
|
|
IF fThisDistance > 150
|
|
AND fThisDistance < 900
|
|
IF NOT IS_SPHERE_VISIBLE(vSpawnPos, 5.0)
|
|
fClosestDist = fThisDistance
|
|
iClosest = j
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDREPEAT
|
|
|
|
IF iClosest >= 0
|
|
vPos = GET_ENEMY_CHOPPER_POS(iClosest)
|
|
fRot = GET_HEADING_BETWEEN_VECTORS_2D(vPos, GET_ENTITY_COORDS(snatchAndGrabVehicle[SAGV_PLAYER_CHOPPER]))
|
|
ELSE
|
|
bDontCreate = TRUE
|
|
ENDIF
|
|
|
|
iRec = -1
|
|
BREAK
|
|
ENDSWITCH
|
|
|
|
IF NOT bDontCreate
|
|
// chopper
|
|
enemyChopperVehicle[i] = CREATE_VEHICLE(GET_MODEL_FOR_SNATCH_AND_GRAB_MODEL_ENUM(SAGM_ENEMY_CHOPPER), vPos, fRot)
|
|
SET_HELI_BLADES_FULL_SPEED(enemyChopperVehicle[i])
|
|
SET_VEHICLE_ENGINE_ON(enemyChopperVehicle[i], TRUE, TRUE)
|
|
SET_VEHICLE_CAN_BE_TARGETTED(enemyChopperVehicle[i], TRUE)
|
|
|
|
iEnemyChopperAITime[i] = GET_GAME_TIMER()
|
|
|
|
//SET_VEHICLE_COLOUR_COMBINATION(enemyChopperVehicle[i], 2)
|
|
|
|
IF iRec >= 0
|
|
START_PLAYBACK_RECORDED_VEHICLE(enemyChopperVehicle[i], iRec, GET_SNATCH_AND_GRAB_RECORDING_PREFIX())
|
|
SET_PLAYBACK_SPEED(enemyChopperVehicle[i], 1.0)
|
|
SKIP_TIME_IN_PLAYBACK_RECORDED_VEHICLE(enemyChopperVehicle[i], fSkip)
|
|
FORCE_PLAYBACK_RECORDED_VEHICLE_UPDATE(enemyChopperVehicle[i])
|
|
ELSE
|
|
SET_VEHICLE_FORWARD_SPEED(enemyChopperVehicle[i], 30)
|
|
ENDIF
|
|
SET_ENTITY_PROOFS(enemyChopperVehicle[i], FALSE, FALSE, FALSE, TRUE, TRUE)
|
|
|
|
IF i <= 2
|
|
SET_ENTITY_ONLY_DAMAGED_BY_PLAYER(enemyChopperVehicle[i], TRUE)
|
|
ENDIF
|
|
ENDIF
|
|
ENDFOR
|
|
|
|
IF NOT bDontCreate
|
|
// crew
|
|
VEHICLE_SEAT seat
|
|
|
|
IF NOT bExtra
|
|
iStart = 0
|
|
iEnd = 8
|
|
ELSE
|
|
iStart = 9
|
|
iEnd = 11
|
|
ENDIF
|
|
|
|
FOR i=iStart TO iEnd
|
|
INT iChopper
|
|
SWITCH i
|
|
CASE 0
|
|
seat = VS_DRIVER
|
|
iChopper = 0
|
|
BREAK
|
|
CASE 1
|
|
seat = VS_BACK_LEFT
|
|
iChopper = 0
|
|
BREAK
|
|
CASE 2
|
|
seat = VS_BACK_RIGHT
|
|
iChopper = 0
|
|
BREAK
|
|
CASE 3
|
|
seat = VS_DRIVER
|
|
iChopper = 1
|
|
BREAK
|
|
CASE 4
|
|
seat = VS_BACK_LEFT
|
|
iChopper = 1
|
|
BREAK
|
|
CASE 5
|
|
seat = VS_BACK_RIGHT
|
|
iChopper = 1
|
|
BREAK
|
|
CASE 6
|
|
seat = VS_DRIVER
|
|
iChopper = 2
|
|
BREAK
|
|
CASE 7
|
|
seat = VS_BACK_LEFT
|
|
iChopper = 2
|
|
BREAK
|
|
CASE 8
|
|
seat = VS_BACK_RIGHT
|
|
iChopper = 2
|
|
BREAK
|
|
CASE 9
|
|
seat = VS_DRIVER
|
|
iChopper = 3
|
|
BREAK
|
|
CASE 10
|
|
seat = VS_BACK_LEFT
|
|
iChopper = 3
|
|
BREAK
|
|
CASE 11
|
|
seat = VS_BACK_RIGHT
|
|
iChopper = 3
|
|
BREAK
|
|
ENDSWITCH
|
|
if i = 0
|
|
or i = 3
|
|
or i = 6
|
|
or i = 9
|
|
enemyChopperPed[i] = CREATE_PED_INSIDE_VEHICLE(enemyChopperVehicle[iChopper], PEDTYPE_MISSION, GET_MODEL_FOR_SNATCH_AND_GRAB_MODEL_ENUM(SAGM_PILOT), seat)
|
|
SET_PED_PROP_INDEX(enemyChopperPed[i], ANCHOR_HEAD, 0)
|
|
else
|
|
enemyChopperPed[i] = CREATE_PED_INSIDE_VEHICLE(enemyChopperVehicle[iChopper], PEDTYPE_MISSION, GET_MODEL_FOR_SNATCH_AND_GRAB_MODEL_ENUM(SAGM_GUARD), seat)
|
|
endif
|
|
SET_BLOCKING_OF_NON_TEMPORARY_EVENTS(enemyChopperPed[i], TRUE)
|
|
SET_PED_KEEP_TASK(enemyChopperPed[i], TRUE)
|
|
if i = 0
|
|
or i = 3
|
|
or i = 6
|
|
or i = 9
|
|
SET_PED_ACCURACY(enemyChopperPed[i], 100)
|
|
ELSE
|
|
SET_PED_ACCURACY(enemyChopperPed[i], FLOOR(fChopperAccuracy))
|
|
ENDIF
|
|
SET_PED_RELATIONSHIP_GROUP_HASH(enemyChopperPed[i], agencyRelGroup)
|
|
SET_ENTITY_CAN_BE_DAMAGED_BY_RELATIONSHIP_GROUP(enemyChopperPed[i], FALSE, agencyRelGroup)
|
|
INFORM_MISSION_STATS_OF_HEADSHOT_WATCH_ENTITY(enemyChopperPed[i])
|
|
bKilledEnemyChopperPed[i] = FALSE
|
|
|
|
IF i <> 0
|
|
AND i <> 3
|
|
AND i <> 6
|
|
AND i <> 9
|
|
GIVE_WEAPON_TO_PED(enemyChopperPed[i], GET_SNATCH_AND_GRAB_WEAPON_TYPE(SAG_WEAPON_CIA_HELI), INFINITE_AMMO, TRUE)
|
|
CLEAR_PED_PROP(enemyChopperPed[i], ANCHOR_EYES)
|
|
//PRINTSTRING("LOD DIST = ") PRINTINT(GET_ENTITY_LOD_DIST(enemyChopperPed[i])) PRINTNL()
|
|
SET_ENTITY_LOD_DIST(enemyChopperPed[i], 240)
|
|
//TASK_VEHICLE_SHOOT_AT_PED(enemyChopperPed[i], PLAYER_PED_ID())
|
|
ENDIF
|
|
ENDFOR
|
|
|
|
//ADD_PED_FOR_DIALOGUE(snatchAndGrabConversation, 5, enemyChopperPed[0], "FBI2CIACHOP")
|
|
IF NOT bExtra
|
|
ADD_PED_FOR_DIALOGUE(snatchAndGrabConversation, 4, enemyChopperPed[0], "FBI2CIACHOP2")
|
|
ENDIF
|
|
ENDIF
|
|
ENDPROC
|
|
|
|
// set bad guys to driveby
|
|
PROC SET_ENEMY_CHOPPER_SHOOTERS_TO_ATTACK(INT iChopper)
|
|
INT i
|
|
PED_INDEX michaelPed = GET_MICHAEL_PED()
|
|
PED_INDEX franklinPed = GET_FRANKLIN_PED()
|
|
|
|
IF NOT IS_PED_INJURED(michaelPed)
|
|
INT iFirst
|
|
INT iLast
|
|
|
|
SWITCH iChopper
|
|
CASE 0
|
|
iFirst = 1
|
|
iLast = 2
|
|
BREAK
|
|
CASE 1
|
|
iFirst = 4
|
|
iLast = 5
|
|
BREAK
|
|
CASE 2
|
|
iFirst = 7
|
|
iLast = 8
|
|
BREAK
|
|
ENDSWITCH
|
|
|
|
FOR i=iFirst TO iLast
|
|
IF NOT IS_PED_INJURED(enemyChopperPed[i])
|
|
IF iChopper < 2
|
|
TASK_DRIVE_BY(enemyChopperPed[i], michaelPed, NULL, <<0,0,0>>, 1000, 100)
|
|
ELSE
|
|
TASK_DRIVE_BY(enemyChopperPed[i], franklinPed, NULL, <<0,0,0>>, 1000, 100)
|
|
ENDIF
|
|
ENDIF
|
|
ENDFOR
|
|
ENDIF
|
|
bEnemyChopperShootersToAttack[iChopper] = TRUE
|
|
ENDPROC
|
|
|
|
// set enemy chopper no longer needed
|
|
PROC SET_ENEMY_CHOPPER_AS_GAVE_UP_CHASE(INT iChopper)
|
|
INT iDriver
|
|
SWITCH iChopper
|
|
CASE 0
|
|
iDriver = 0
|
|
BREAK
|
|
CASE 1
|
|
iDriver = 3
|
|
BREAK
|
|
CASE 2
|
|
iDriver = 6
|
|
BREAK
|
|
ENDSWITCH
|
|
|
|
IF NOT IS_PED_INJURED(enemyChopperPed[iDriver])
|
|
IF IS_VEHICLE_DRIVEABLE(enemyChopperVehicle[iChopper])
|
|
VECTOR vChopperPos = GET_ENTITY_COORDS(enemyChopperVehicle[iChopper])
|
|
TASK_HELI_MISSION(enemyChopperPed[iDriver], enemyChopperVehicle[iChopper], NULL, NULL, vChopperPos, MISSION_GOTO, 100.0, 30, -1, ROUND(vChopperPos.z), 10)
|
|
ENDIF
|
|
ENDIF
|
|
ENDPROC
|
|
|
|
// initialise the interrogation
|
|
PROC INIT_INTERROGATION()
|
|
INT i
|
|
|
|
iSyncScene = CREATE_SYNCHRONIZED_SCENE(GET_SNATCH_AND_GRAB_VECTOR(SAGVEC_INTERROGATION), <<0.0, 0.0, INTERROGATION_ROT>>)
|
|
//iSyncScene = CREATE_SYNCHRONIZED_SCENE(GET_SNATCH_AND_GRAB_VECTOR(SAGVEC_BREAK_IN) + <<0,0,1>>, <<0.0, 0.0, BREAK_IN_ROT>>)
|
|
|
|
// michelle
|
|
IF NOT IS_PED_INJURED(michellePed)
|
|
TASK_SYNCHRONIZED_SCENE(michellePed, iSyncScene, GET_SNATCH_AND_GRAB_ANIM_DICT_AS_STRING(SAG_ANIM_DICT_CUTSCENES), "Interrogation_Michelle", INSTANT_BLEND_IN, INSTANT_BLEND_OUT)
|
|
ENDIF
|
|
|
|
// mr k
|
|
IF NOT IS_PED_INJURED(prisonerPed)
|
|
TASK_SYNCHRONIZED_SCENE(prisonerPed, iSyncScene, GET_SNATCH_AND_GRAB_ANIM_DICT_AS_STRING(SAG_ANIM_DICT_CUTSCENES), "Interrogation_MRK", INSTANT_BLEND_IN, INSTANT_BLEND_OUT)
|
|
ENDIF
|
|
|
|
// guards
|
|
TEXT_LABEL tGuardAnim
|
|
FOR i=0 TO 2
|
|
IF NOT IS_PED_INJURED(guardPed[i])
|
|
SWITCH i
|
|
CASE 0
|
|
tGuardAnim = "Interrogation_B"
|
|
BREAK
|
|
CASE 1
|
|
tGuardAnim = "Interrogation_C"
|
|
BREAK
|
|
CASE 2
|
|
tGuardAnim = "Interrogation_A"
|
|
BREAK
|
|
ENDSWITCH
|
|
TASK_SYNCHRONIZED_SCENE(guardPed[i], iSyncScene, GET_SNATCH_AND_GRAB_ANIM_DICT_AS_STRING(SAG_ANIM_DICT_CUTSCENES), tGuardAnim, INSTANT_BLEND_IN, GUARD_ANIM_BLEND_OUT)
|
|
ENDIF
|
|
ENDFOR
|
|
|
|
// chair
|
|
IF DOES_ENTITY_EXIST(chairObject)
|
|
FREEZE_ENTITY_POSITION(chairObject, FALSE)
|
|
PLAY_SYNCHRONIZED_ENTITY_ANIM(chairObject, iSyncScene, "interrogation_chair", GET_SNATCH_AND_GRAB_ANIM_DICT_AS_STRING(SAG_ANIM_DICT_CUTSCENES), INSTANT_BLEND_IN)
|
|
ENDIF
|
|
|
|
// camera
|
|
CREATE_MISSION_ANIM_CAM(FALSE)
|
|
PLAY_SYNCHRONIZED_CAM_ANIM(animCam, iSyncScene, "interrogation_cam", GET_SNATCH_AND_GRAB_ANIM_DICT_AS_STRING(SAG_ANIM_DICT_CUTSCENES))
|
|
|
|
// audio
|
|
PLAY_SYNCHRONIZED_AUDIO_EVENT(iSyncScene)
|
|
|
|
// rob 674211
|
|
IF NOT bUsingOfficeCam
|
|
SET_VARIABLE_ON_SYNCH_SCENE_AUDIO("INOUT", 0)
|
|
ELSE
|
|
SET_VARIABLE_ON_SYNCH_SCENE_AUDIO("INOUT", 1)
|
|
ENDIF
|
|
|
|
TRIGGER_MISSION_MUSIC_EVENT("FIB2_TORTURE_CS")
|
|
ENDPROC
|
|
|
|
// fill guard pos for stage
|
|
PROC FILL_GUARD_POSITION_FOR_STAGE(INT iGuard, MISSION_STAGE_ENUM guardStage, VECTOR &vPos, FLOAT &fRot)
|
|
IF iGuard <= 2
|
|
SWITCH guardStage
|
|
// init - before come crashing through
|
|
CASE STAGE_RAPPEL_DOWN
|
|
SWITCH iGuard
|
|
CASE 0
|
|
vPos = <<116.39, -626.53, 205.05>>
|
|
fRot = -22.30
|
|
BREAK
|
|
CASE 1
|
|
vPos = <<123.70, -622.05, 205.05>>
|
|
fRot = 109.05
|
|
BREAK
|
|
CASE 2
|
|
vPos = <<120.01, -620.25, 205.05>>
|
|
fRot = 50.78
|
|
BREAK
|
|
ENDSWITCH
|
|
BREAK
|
|
|
|
// during - move to for snipe stage
|
|
CASE STAGE_SNIPE_GUARDS
|
|
SWITCH iGuard
|
|
CASE 0
|
|
vPos = <<117.05, -618.45, 205.05>>
|
|
//vPos = <<117.87, -619.47, 205.05>>
|
|
BREAK
|
|
CASE 1
|
|
vPos = <<116.5, -620.0, 205.05>>
|
|
//vPos = <<117.34, -621.14, 205.05>>
|
|
BREAK
|
|
CASE 2
|
|
vPos = <<115.9, -620.9, 205.05>>
|
|
//vPos = <<116.04, -622.41, 205.05>>
|
|
BREAK
|
|
ENDSWITCH
|
|
BREAK
|
|
ENDSWITCH
|
|
ELSE
|
|
SWITCH iGuard
|
|
CASE 3
|
|
vPos = <<115.4, -626.8, 205.05>>
|
|
fRot = -30.95
|
|
BREAK
|
|
CASE 4
|
|
vPos = <<123.7, -617.3, 205.05>>
|
|
fRot = 83.48
|
|
BREAK
|
|
CASE 5
|
|
vPos = <<120.10, -625.8, 205.05>>
|
|
fRot = 83.48
|
|
BREAK
|
|
ENDSWITCH
|
|
ENDIF
|
|
ENDPROC
|
|
|
|
// create the guards
|
|
PROC CREATE_GUARDS_FOR_STAGE(MISSION_STAGE_ENUM createStage)
|
|
INT i
|
|
STRING sName
|
|
//INT iHead
|
|
//INT iTorso
|
|
VECTOR vPos
|
|
FLOAT fRot
|
|
BOOL bForceWeapons
|
|
INT iHead
|
|
INT iHeadTexture
|
|
INT iTorso
|
|
INT iTorsoTexture
|
|
INT iLegTexture
|
|
INT iHair
|
|
INT iTask
|
|
|
|
REPEAT NUMBER_GUARDS i
|
|
IF NOT DOES_ENTITY_EXIST(guardPed[i])
|
|
FILL_GUARD_POSITION_FOR_STAGE(i, createStage, vPos, fRot)
|
|
guardPed[i] = CREATE_PED(PEDTYPE_MISSION, GET_MODEL_FOR_SNATCH_AND_GRAB_MODEL_ENUM(SAGM_GUARD), vPos, fRot)
|
|
IF createStage = STAGE_RAPPEL_DOWN
|
|
AND i <= 2
|
|
bForceWeapons = FALSE
|
|
ELSE
|
|
bForceWeapons = TRUE
|
|
ENDIF
|
|
GIVE_WEAPON_TO_PED(guardPed[i], GET_SNATCH_AND_GRAB_WEAPON_TYPE(SAG_WEAPON_CIA_PISTOL), INFINITE_AMMO, bForceWeapons)
|
|
SET_BLOCKING_OF_NON_TEMPORARY_EVENTS(guardPed[i], TRUE)
|
|
STOP_PED_WEAPON_FIRING_WHEN_DROPPED(guardPed[i])
|
|
SET_PED_DIES_WHEN_INJURED(guardPed[i], TRUE)
|
|
SET_PED_KEEP_TASK(guardPed[i], TRUE)
|
|
SET_PED_ACCURACY(guardPed[i], 2)
|
|
SET_ENTITY_PROOFS(guardPed[i], FALSE, FALSE, FALSE, TRUE, TRUE)
|
|
SET_PED_RELATIONSHIP_GROUP_HASH(guardPed[i], agencyRelGroup)
|
|
|
|
SET_PED_CONFIG_FLAG(guardPed[i], PCF_DisableHurt, TRUE)
|
|
SET_PED_CONFIG_FLAG(guardPed[i], PCF_DisableExplosionReactions, TRUE)
|
|
SET_PED_CONFIG_FLAG(guardPed[i], PCF_RunFromFiresAndExplosions, FALSE)
|
|
SET_PED_CONFIG_FLAG(guardPed[i], PCF_DontReactivateRagdollOnPedCollisionWhenDead, TRUE)
|
|
SET_PED_COMBAT_ATTRIBUTES(guardPed[i], CA_DISABLE_BULLET_REACTIONS, TRUE)
|
|
DISABLE_PED_INJURED_ON_GROUND_BEHAVIOUR(guardPed[i])
|
|
|
|
SET_RAGDOLL_BLOCKING_FLAGS(guardPed[i], RBF_PLAYER_IMPACT)
|
|
|
|
INFORM_MISSION_STATS_OF_HEADSHOT_WATCH_ENTITY(guardPed[i])
|
|
|
|
guardAI[i].currentAction = GA_AIM_AT_MICHAEL
|
|
guardAI[i].currentSituation = GS_REACT_NONE
|
|
guardAI[i].iRevertActionTime = -1
|
|
|
|
// variations
|
|
SWITCH i
|
|
CASE 0
|
|
iHead = 0
|
|
iHeadTexture = 2
|
|
iTorso = 0
|
|
iTorsoTexture = 0
|
|
iLegTexture = 1
|
|
iTask = 1
|
|
IF createStage = STAGE_RAPPEL_DOWN
|
|
iHair = 1
|
|
ELSE
|
|
iHair = 3
|
|
ENDIF
|
|
sName = "GUARD0"
|
|
BREAK
|
|
CASE 1
|
|
iHead = 1
|
|
iHeadTexture = 1
|
|
iTorso = 1
|
|
iTorsoTexture = 0
|
|
iLegTexture = 2
|
|
iTask = 0
|
|
IF createStage = STAGE_RAPPEL_DOWN
|
|
iHair = 1
|
|
ELSE
|
|
iHair = 3
|
|
ENDIF
|
|
sName = "GUARD1"
|
|
BREAK
|
|
CASE 2
|
|
iHead = 0
|
|
iHeadTexture = 0
|
|
iTorso = 0
|
|
iTorsoTexture = 3
|
|
iLegTexture = 0
|
|
iTask = 1
|
|
IF createStage = STAGE_RAPPEL_DOWN
|
|
iHair = 1
|
|
ELSE
|
|
iHair = 3
|
|
ENDIF
|
|
sName = "GUARD2"
|
|
BREAK
|
|
CASE 3
|
|
iHead = 1
|
|
iHeadTexture = 0
|
|
iTorso = 0
|
|
iTorsoTexture = 2
|
|
iLegTexture = 2
|
|
iTask = 0
|
|
iHair = 2
|
|
sName = "GUARD3"
|
|
BREAK
|
|
CASE 4
|
|
iHead = 2
|
|
iHeadTexture = 0
|
|
iTorso = 2
|
|
iTorsoTexture = 0
|
|
iLegTexture = 1
|
|
iTask = 0
|
|
iHair = 3
|
|
sName = "GUARD4"
|
|
BREAK
|
|
CASE 5
|
|
iHead = 1
|
|
iHeadTexture = 0
|
|
iTorso = 2
|
|
iTorsoTexture = 0
|
|
iLegTexture = 2
|
|
iTask = 0
|
|
iHair = 3
|
|
sName = "GUARD5"
|
|
BREAK
|
|
ENDSWITCH
|
|
|
|
SET_PED_COMPONENT_VARIATION(guardPed[i], PED_COMP_HEAD, iHead, iHeadTexture)
|
|
SET_PED_COMPONENT_VARIATION(guardPed[i], PED_COMP_TORSO, iTorso, iTorsoTexture)
|
|
SET_PED_COMPONENT_VARIATION(guardPed[i], PED_COMP_LEG, 0, iLegTexture)
|
|
SET_PED_COMPONENT_VARIATION(guardPed[i], PED_COMP_SPECIAL2, iTask, 0)
|
|
SET_PED_COMPONENT_VARIATION(guardPed[i], PED_COMP_HAIR, iHair, 0)
|
|
|
|
IF createStage = STAGE_RAPPEL_DOWN
|
|
IF i >= 3
|
|
SET_ENTITY_VISIBLE(guardPed[i], FALSE)
|
|
ENDIF
|
|
ENDIF
|
|
|
|
SET_PED_NAME_DEBUG(guardPed[i], sName)
|
|
ENDIF
|
|
ENDREPEAT
|
|
ENDPROC
|
|
|
|
// setup guards for dialogue
|
|
PROC SETUP_GUARDS_FOR_DIALOGUE()
|
|
INT i
|
|
|
|
REPEAT NUMBER_GUARDS i
|
|
IF NOT IS_PED_INJURED(guardPed[i])
|
|
INT iSpeaker
|
|
STRING sName
|
|
|
|
SWITCH i
|
|
CASE 0
|
|
iSpeaker = 4
|
|
sName = "FBI2AGENT1"
|
|
BREAK
|
|
CASE 1
|
|
iSpeaker = 5
|
|
sName = "FBI2AGENT2"
|
|
BREAK
|
|
CASE 2
|
|
iSpeaker = 6
|
|
sName = "FBI2AGENT6"
|
|
BREAK
|
|
CASE 3
|
|
iSpeaker = 7
|
|
sName = "FBI2AGENT4"
|
|
BREAK
|
|
CASE 4
|
|
iSpeaker = 8
|
|
sName = "FBI2AGENT3"
|
|
BREAK
|
|
ENDSWITCH
|
|
|
|
ADD_PED_FOR_DIALOGUE(snatchAndGrabConversation, iSpeaker, guardPed[i], sName)
|
|
ENDIF
|
|
ENDREPEAT
|
|
ENDPROC
|
|
|
|
// set guards no longer needed
|
|
PROC SET_GUARDS_NO_LONGER_NEEDED()
|
|
INT i
|
|
|
|
REPEAT NUMBER_GUARDS i
|
|
IF DOES_ENTITY_EXIST(guardPed[i])
|
|
SET_PED_AS_NO_LONGER_NEEDED(guardPed[i])
|
|
ENDIF
|
|
ENDREPEAT
|
|
ENDPROC
|
|
|
|
// get a random aim coord
|
|
FUNC VECTOR GET_RANDOM_AIM_COORD()
|
|
INT iInvert
|
|
//VECTOR vMod = <<GET_RANDOM_FLOAT_IN_RANGE(0,0.5), GET_RANDOM_FLOAT_IN_RANGE(0,0.5), GET_RANDOM_FLOAT_IN_RANGE(0,0.5)>>
|
|
VECTOR vMod = <<GET_RANDOM_FLOAT_IN_RANGE(0,1), GET_RANDOM_FLOAT_IN_RANGE(0,1), GET_RANDOM_FLOAT_IN_RANGE(0,0.5)>>
|
|
iInvert = GET_RANDOM_INT_IN_RANGE(0,2)
|
|
IF iInvert = 0
|
|
vMod.x *= -1
|
|
ENDIF
|
|
iInvert = GET_RANDOM_INT_IN_RANGE(0,2)
|
|
IF iInvert = 0
|
|
vMod.y *= -1
|
|
ENDIF
|
|
iInvert = GET_RANDOM_INT_IN_RANGE(0,2)
|
|
IF iInvert = 0
|
|
vMod.z *= -1
|
|
ENDIF
|
|
|
|
RETURN GET_SNATCH_AND_GRAB_VECTOR(SAGVEC_REMOTE_VIEW) + vMod
|
|
ENDFUNC
|
|
|
|
// guards come in when they hear the sniper
|
|
PROC SET_GUARDS_HEAR_SNIPER()
|
|
INT i
|
|
//VECTOR vPos
|
|
STRING sAnim
|
|
//VECTOR vAimCoord
|
|
|
|
iGuardSyncScene[GSS_STANDARD] = CREATE_SYNCHRONIZED_SCENE(GET_SNATCH_AND_GRAB_VECTOR(SAGVEC_GUARD_ANIM_ORIGIN), <<0,0,GUARD_ANIM_ORIGIN_ROT>>)
|
|
|
|
FOR i=GUARD_SECOND_WAVE_INDEX TO GUARD_LAST_INDEX
|
|
IF NOT IS_PED_INJURED(guardPed[i])
|
|
SWITCH i
|
|
CASE 3
|
|
sAnim = "Wave_1_B"
|
|
BREAK
|
|
CASE 4
|
|
sAnim = "Wave_1_A"
|
|
BREAK
|
|
ENDSWITCH
|
|
|
|
CLEAR_PED_TASKS_IMMEDIATELY(guardPed[i])
|
|
PED_INDEX michaelped = GET_MICHAEL_PED()
|
|
IF NOT IS_PED_INJURED(michaelPed)
|
|
TASK_LOOK_AT_ENTITY(guardPed[i], michaelPed, -1, SLF_USE_EYES_ONLY)
|
|
ENDIF
|
|
TASK_SYNCHRONIZED_SCENE(guardPed[i], iGuardSyncScene[GSS_STANDARD], GET_SNATCH_AND_GRAB_ANIM_DICT_AS_STRING(SAG_ANIM_DICT_GUARDS), sAnim, INSTANT_BLEND_IN, GUARD_ANIM_BLEND_OUT, SYNCED_SCENE_USE_PHYSICS | SYNCED_SCENE_DONT_INTERRUPT)
|
|
ENDIF
|
|
ENDFOR
|
|
ENDPROC
|
|
|
|
// last guard for good luck
|
|
PROC SET_LAST_GUARD_ENTER()
|
|
STRING sAnim
|
|
|
|
iGuardSyncScene[GSS_LAST_GUARD] = CREATE_SYNCHRONIZED_SCENE(GET_SNATCH_AND_GRAB_VECTOR(SAGVEC_GUARD_ANIM_ORIGIN), <<0,0,GUARD_ANIM_ORIGIN_ROT>>)
|
|
|
|
IF NOT IS_PED_INJURED(guardPed[5])
|
|
sAnim = "Wave_2_D"
|
|
|
|
CLEAR_PED_TASKS_IMMEDIATELY(guardPed[5])
|
|
PED_INDEX michaelped = GET_MICHAEL_PED()
|
|
IF NOT IS_PED_INJURED(michaelPed)
|
|
TASK_LOOK_AT_ENTITY(guardPed[5], michaelPed, -1, SLF_USE_EYES_ONLY)
|
|
ENDIF
|
|
TASK_SYNCHRONIZED_SCENE(guardPed[5], iGuardSyncScene[GSS_LAST_GUARD], GET_SNATCH_AND_GRAB_ANIM_DICT_AS_STRING(SAG_ANIM_DICT_GUARDS), sAnim, INSTANT_BLEND_IN, GUARD_ANIM_BLEND_OUT, SYNCED_SCENE_USE_PHYSICS | SYNCED_SCENE_DONT_INTERRUPT)
|
|
SET_SYNCHRONIZED_SCENE_PHASE(iGuardSyncScene[GSS_LAST_GUARD], 0.77)
|
|
ENDIF
|
|
ENDPROC
|
|
|
|
// swap the duck anim
|
|
PROC SWAP_DUCK_ANIM()
|
|
iDuckAnim++
|
|
IF iDuckAnim > 2
|
|
iDuckAnim = 0
|
|
ENDIF
|
|
ENDPROC
|
|
|
|
// get duck anim
|
|
FUNC STRING GET_DUCK_ANIM()
|
|
SWITCH iDuckAnim
|
|
CASE 0
|
|
RETURN "Guard_React_A"
|
|
BREAK
|
|
CASE 1
|
|
RETURN "Guard_React_B"
|
|
BREAK
|
|
CASE 2
|
|
RETURN "Guard_React_C"
|
|
BREAK
|
|
ENDSWITCH
|
|
RETURN "Guard_React_A"
|
|
ENDFUNC
|
|
|
|
// swap the flinch anim
|
|
PROC SWAP_FLINCH_LEFT_ANIM()
|
|
iFlinchLeftAnim++
|
|
IF iFlinchLeftAnim > 1
|
|
iFlinchLeftAnim = 0
|
|
ENDIF
|
|
ENDPROC
|
|
|
|
// swap the flinch anim
|
|
PROC SWAP_FLINCH_RIGHT_ANIM()
|
|
iFlinchRightAnim++
|
|
IF iFlinchRightAnim > 1
|
|
iFlinchRightAnim = 0
|
|
ENDIF
|
|
ENDPROC
|
|
|
|
// get flinch anim
|
|
FUNC STRING GET_FLINCH_LEFT_ANIM()
|
|
SWITCH iFlinchLeftAnim
|
|
CASE 0
|
|
RETURN "Guard_Flinch_L"
|
|
BREAK
|
|
CASE 1
|
|
RETURN "Guard_Flinch_R_2"
|
|
BREAK
|
|
ENDSWITCH
|
|
RETURN "Guard_Flinch_L"
|
|
ENDFUNC
|
|
|
|
// get flinch anim
|
|
FUNC STRING GET_FLINCH_RIGHT_ANIM()
|
|
SWITCH iFlinchRightAnim
|
|
CASE 0
|
|
RETURN "Guard_Flinch_R"
|
|
BREAK
|
|
CASE 1
|
|
RETURN "Guard_Flinch_L_2"
|
|
BREAK
|
|
ENDSWITCH
|
|
RETURN "Guard_Flinch_R"
|
|
ENDFUNC
|
|
|
|
// guards react to shooting
|
|
PROC DO_GUARD_REACTIONS(INT iKilledGuards)
|
|
INT i
|
|
INT iCountTo
|
|
IF NOT bAdditionalGuardsToShoot
|
|
iCountTo = 2
|
|
ELSE
|
|
IF NOT bLastGuardToShoot
|
|
iCountTo = 4
|
|
ELSE
|
|
iCountTo = 5
|
|
ENDIF
|
|
ENDIF
|
|
|
|
PED_INDEX michaelPed = GET_MICHAEL_PED()
|
|
GUARD_SITUATION_REACT_ENUM thisSituation
|
|
thisSituation = GS_REACT_NONE
|
|
BOOL bBulletIsToLeft
|
|
VECTOR vAimCoord
|
|
|
|
// check for sniper bullet in the entire office
|
|
BOOL bIsSniperBulletInOffice
|
|
bIsSniperBulletInOffice = FALSE
|
|
IF (IS_SNIPER_BULLET_IN_AREA(<<109.26, -622.75, 206.16>>, <<121.75, -618.34, 208.45>>)
|
|
OR iKilledGuards > 0)
|
|
AND NOT bGuardsAttackPrisoner
|
|
IF NOT bReactedToFirstShot
|
|
thisSituation = GS_REACT_FIRST_SHOT
|
|
bReactedToFirstShot = TRUE
|
|
ENDIF
|
|
bIsSniperBulletInOffice = TRUE
|
|
ENDIF
|
|
|
|
IF NOT IS_PED_INJURED(michaelPed)
|
|
FOR i=0 TO iCountTo
|
|
IF thisSituation <> GS_REACT_FIRST_SHOT
|
|
thisSituation = GS_REACT_NONE
|
|
ENDIF
|
|
|
|
vAimCoord = GET_RANDOM_AIM_COORD()
|
|
IF NOT IS_PED_INJURED(guardPed[i])
|
|
// check to see if sniper bullet is close to the ped
|
|
IF thisSituation = GS_REACT_NONE
|
|
IF bIsSniperBulletInOffice
|
|
VECTOR vGuardPos
|
|
vGuardPos = GET_ENTITY_COORDS(guardPed[i])
|
|
IF IS_BULLET_IN_AREA(vGuardPos, 1.5, TRUE)
|
|
IF IS_SNIPER_BULLET_IN_AREA(<<vGuardPos.x-1, vGuardPos.y-1, vGuardPos.z-1>>, <<vGuardPos.x+1, vGuardPos.y+1, vGuardPos.z+1>>)
|
|
IF IS_SNIPER_BULLET_IN_AREA(<<vGuardPos.x-1, vGuardPos.y, vGuardPos.z-1>>, <<vGuardPos.x+1, vGuardPos.y+1, vGuardPos.z+1>>)
|
|
bBulletIsToLeft = TRUE
|
|
ELSE
|
|
bBulletIsToLeft = FALSE
|
|
ENDIF
|
|
thisSituation = GS_REACT_BULLET_NEAR
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
|
|
// react to any situation that has arisen
|
|
IF thisSituation <> GS_REACT_NONE
|
|
// react to any situation different than the one currently reacting to
|
|
IF guardAI[i].currentSituation <> thisSituation
|
|
INT iReactionLength
|
|
iReactionLength = -1
|
|
CLEAR_PED_SECONDARY_TASK(guardPed[i])
|
|
CLEAR_SEQUENCE_TASK(sequence)
|
|
OPEN_SEQUENCE_TASK(sequence)
|
|
|
|
TASK_CLEAR_LOOK_AT(NULL)
|
|
SWITCH thisSituation
|
|
CASE GS_REACT_BULLET_NEAR
|
|
IF bBulletIsToLeft
|
|
TASK_PLAY_ANIM(NULL, GET_SNATCH_AND_GRAB_ANIM_DICT_AS_STRING(SAG_ANIM_DICT_IN_OFFICE), GET_FLINCH_LEFT_ANIM(), NORMAL_BLEND_IN, GUARD_ANIM_BLEND_OUT)
|
|
SWAP_FLINCH_LEFT_ANIM()
|
|
ELSE
|
|
TASK_PLAY_ANIM(NULL, GET_SNATCH_AND_GRAB_ANIM_DICT_AS_STRING(SAG_ANIM_DICT_IN_OFFICE), GET_FLINCH_RIGHT_ANIM(), NORMAL_BLEND_IN, GUARD_ANIM_BLEND_OUT)
|
|
SWAP_FLINCH_RIGHT_ANIM()
|
|
ENDIF
|
|
TASK_AIM_GUN_AT_ENTITY(NULL, michaelPed, -1)
|
|
iNextGuardAnimationTime[i] = GET_GAME_TIMER() + GET_RANDOM_INT_IN_RANGE(3000, 6000)
|
|
iReactionLength = GET_RANDOM_INT_IN_RANGE(1500, 2000)
|
|
BREAK
|
|
|
|
CASE GS_REACT_FIRST_SHOT
|
|
if ireactionDelay > 200
|
|
ireactionDelay = 0
|
|
endif
|
|
TASK_AIM_GUN_AT_ENTITY(null,michaelPed,ireactionDelay)
|
|
ireactionDelay += 100
|
|
TASK_PLAY_ANIM(NULL, GET_SNATCH_AND_GRAB_ANIM_DICT_AS_STRING(SAG_ANIM_DICT_IN_OFFICE), GET_DUCK_ANIM(), NORMAL_BLEND_IN, GUARD_ANIM_BLEND_OUT)
|
|
SWAP_DUCK_ANIM()
|
|
TASK_AIM_GUN_AT_ENTITY(NULL, michaelPed, -1)
|
|
guardAI[i].currentAction = GA_AIM_AT_MICHAEL
|
|
iNextGuardAnimationTime[i] = GET_GAME_TIMER() + GET_RANDOM_INT_IN_RANGE(3000, 7000)
|
|
iReactionLength = GET_RANDOM_INT_IN_RANGE(2800, 3500)
|
|
BREAK
|
|
ENDSWITCH
|
|
CLOSE_SEQUENCE_TASK(sequence)
|
|
TASK_PERFORM_SEQUENCE(guardPed[i], sequence)
|
|
|
|
guardAI[i].currentSituation = thisSituation
|
|
|
|
IF iReactionLength >= 0
|
|
guardAI[i].iRevertActionTime = GET_GAME_TIMER() + iReactionLength
|
|
ELSE
|
|
guardAI[i].iRevertActionTime = -1
|
|
ENDIF
|
|
|
|
ENDIF
|
|
ELSE
|
|
// if this situation is none then see if can return to normal
|
|
IF guardAI[i].iRevertActionTime >= 0
|
|
//printint(get_game_timer()) PRINTNL()
|
|
IF GET_GAME_TIMER() >= guardAI[i].iRevertActionTime
|
|
//CLEAR_SEQUENCE_TASK(sequence)
|
|
//OPEN_SEQUENCE_TASK(sequence)
|
|
INT iRandomState
|
|
|
|
iRandomState = GET_RANDOM_INT_IN_RANGE(0,8)
|
|
IF iKilledGuards > 0
|
|
OR GET_GAME_TIMER() >= iReactToFirstShotTime + 6000
|
|
iRandomState += 2
|
|
ENDIF
|
|
|
|
SWITCH iRandomState
|
|
CASE 0
|
|
CASE 1
|
|
TASK_AIM_GUN_AT_ENTITY(guardPed[i], michaelPed, -1)
|
|
guardAI[i].currentAction = GA_AIM_AT_MICHAEL
|
|
guardAI[i].iRevertActionTime = GET_GAME_TIMER() + GET_RANDOM_INT_IN_RANGE(3000, 6000)
|
|
BREAK
|
|
CASE 2
|
|
CASE 3
|
|
CASE 4
|
|
CASE 5
|
|
CASE 6
|
|
TASK_AIM_GUN_AT_COORD(guardPed[i], vAimCoord, -1)
|
|
guardAI[i].currentAction = GA_AIM_AT_SNIPER
|
|
guardAI[i].iRevertActionTime = GET_GAME_TIMER() + GET_RANDOM_INT_IN_RANGE(3000, 6000)
|
|
BREAK
|
|
CASE 7
|
|
CASE 8
|
|
CASE 9
|
|
CASE 10
|
|
TASK_SHOOT_AT_COORD(guardPed[i], vAimCoord, -1, FIRING_TYPE_CONTINUOUS)
|
|
guardAI[i].currentAction = GA_FIRE_ON_SNIPER
|
|
guardAI[i].iRevertActionTime = GET_GAME_TIMER() + GET_RANDOM_INT_IN_RANGE(5000, 7000)
|
|
BREAK
|
|
ENDSWITCH
|
|
//CLOSE_SEQUENCE_TASK(sequence)
|
|
//TASK_PERFORM_SEQUENCE(guardPed[i], sequence)
|
|
guardAI[i].currentSituation = GS_REACT_NONE
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDFOR
|
|
ENDIF
|
|
ENDPROC
|
|
|
|
// set guards up and aim at current michael
|
|
PROC SET_GUARDS_AIMING_AT_MICHAEL(BOOL bSetPositions = FALSE, BOOL b2AimHigh = FALSE)
|
|
INT i
|
|
VECTOR vPos
|
|
FLOAT fRot
|
|
PED_INDEX michaelPed = GET_MICHAEL_PED()
|
|
|
|
REPEAT NUMBER_GUARDS i
|
|
IF NOT IS_PED_INJURED(guardPed[i])
|
|
//CLEAR_PED_TASKS(guardPed[i])
|
|
SET_CURRENT_PED_WEAPON(guardPed[i], GET_SNATCH_AND_GRAB_WEAPON_TYPE(SAG_WEAPON_CIA_PISTOL), TRUE)
|
|
|
|
IF bSetPositions
|
|
FILL_GUARD_POSITION_FOR_STAGE(i, STAGE_SNIPE_GUARDS, vPos, fRot)
|
|
SET_ENTITY_COORDS(guardPed[i], vPos)
|
|
ENDIF
|
|
|
|
FLOAT fHeading
|
|
SWITCH i
|
|
CASE 0
|
|
fHeading = 107.80
|
|
BREAK
|
|
CASE 1
|
|
fHeading = 79.65
|
|
BREAK
|
|
CASE 2
|
|
fHeading = 65.18
|
|
BREAK
|
|
CASE 3
|
|
fHeading = 20.96
|
|
BREAK
|
|
CASE 4
|
|
fHeading = 93.09
|
|
BREAK
|
|
ENDSWITCH
|
|
SET_ENTITY_HEADING(guardPed[i], fHeading)
|
|
TASK_CLEAR_LOOK_AT(guardPed[i])
|
|
|
|
IF i<>2 OR NOT b2AimHigh
|
|
IF NOT IS_PED_INJURED(michaelPed)
|
|
TASK_AIM_GUN_AT_ENTITY(guardPed[i], michaelPed, -1, TRUE)
|
|
ENDIF
|
|
ELSE
|
|
TASK_AIM_GUN_AT_COORD(guardPed[2], GET_SNATCH_AND_GRAB_VECTOR(SAGVEC_HEADSHOT), -1, TRUE)
|
|
ENDIF
|
|
FORCE_PED_MOTION_STATE(guardPed[i], MS_AIMING, TRUE)
|
|
FORCE_PED_AI_AND_ANIMATION_UPDATE(guardPed[i], TRUE)
|
|
ENDIF
|
|
ENDREPEAT
|
|
ENDPROC
|
|
|
|
// create chair for stage
|
|
PROC CREATE_CHAIR_FOR_STAGE(MISSION_STAGE_ENUM createStage)
|
|
VECTOR vPos
|
|
FLOAT fRot
|
|
|
|
SWITCH createStage
|
|
CASE STAGE_RAPPEL_DOWN
|
|
vPos = <<114.35, -619.46, 205.05>>
|
|
fRot = 42.6912
|
|
BREAK
|
|
CASE STAGE_SNIPE_GUARDS
|
|
vPos = <<113.62, -617.81, 205.05>>
|
|
fRot = -76.1837
|
|
BREAK
|
|
ENDSWITCH
|
|
|
|
IF NOT DOES_ENTITY_EXIST(chairObject)
|
|
chairObject = CREATE_OBJECT(GET_MODEL_FOR_SNATCH_AND_GRAB_MODEL_ENUM(SAGM_CHAIR), vPos)
|
|
ELSE
|
|
SET_ENTITY_COORDS_NO_OFFSET(chairObject, vPos)
|
|
ENDIF
|
|
|
|
SET_ENTITY_HEADING(chairObject, fRot)
|
|
|
|
IF createStage = STAGE_RAPPEL_DOWN
|
|
FREEZE_ENTITY_POSITION(chairObject, TRUE)
|
|
ELSE
|
|
FREEZE_ENTITY_POSITION(chairObject, FALSE)
|
|
ENDIF
|
|
ENDPROC
|
|
|
|
// create office peds on the rappel stage
|
|
PROC CREATE_OFFICE_PEDS_FOR_RAPPEL()
|
|
CREATE_PRISONER_FOR_STAGE(STAGE_RAPPEL_DOWN)
|
|
CREATE_GUARDS_FOR_STAGE(STAGE_RAPPEL_DOWN)
|
|
SETUP_GUARDS_FOR_DIALOGUE()
|
|
CREATE_MICHELLE_FOR_STAGE(STAGE_RAPPEL_DOWN)
|
|
CREATE_CHAIR_FOR_STAGE(STAGE_RAPPEL_DOWN)
|
|
|
|
bCreatedOfficePedsForRappel = TRUE
|
|
ENDPROC
|
|
|
|
// get correct synced scene for reinforcement
|
|
FUNC GUARD_SYNCED_SCENE_ENUM GET_SYNCED_SCENE_FOR_REINFORCEMENT(INT i)
|
|
SWITCH i
|
|
CASE 4
|
|
RETURN GSS_REIN_FIRST_EXTRA
|
|
BREAK
|
|
CASE 5
|
|
RETURN GSS_REIN_SECOND_EXTRA
|
|
BREAK
|
|
CASE 6
|
|
RETURN GSS_REIN_THIRD_EXTRA
|
|
BREAK
|
|
CASE 7
|
|
RETURN GSS_REIN_FOURTH_EXTRA
|
|
BREAK
|
|
ENDSWITCH
|
|
|
|
RETURN GSS_STANDARD
|
|
ENDFUNC
|
|
|
|
// create the reinforcements
|
|
PROC CREATE_REINFORCEMENTS(INT iWave)
|
|
INT i
|
|
VECTOR vPos
|
|
FLOAT fRot
|
|
STRING sAnim
|
|
WEAPON_TYPE weapon
|
|
|
|
INT iHead
|
|
INT iHeadTexture
|
|
INT iTorso
|
|
INT iTorsoTexture
|
|
INT iLegTexture
|
|
INT iHair
|
|
INT iTask
|
|
|
|
INT iFirstIndex
|
|
INT iLastIndex
|
|
|
|
IF iWave = 1
|
|
iFirstIndex = 0
|
|
iLastIndex = 3
|
|
iGuardSyncScene[GSS_STANDARD] = CREATE_SYNCHRONIZED_SCENE(GET_SNATCH_AND_GRAB_VECTOR(SAGVEC_GUARD_ANIM_ORIGIN), <<0,0,GUARD_ANIM_ORIGIN_ROT>>)
|
|
ELIF iWave = 2
|
|
iFirstIndex = 4
|
|
iLastIndex = 4
|
|
iGuardSyncScene[GSS_REIN_FIRST_EXTRA] = CREATE_SYNCHRONIZED_SCENE(GET_SNATCH_AND_GRAB_VECTOR(SAGVEC_GUARD_ANIM_ORIGIN), <<0,0,GUARD_ANIM_ORIGIN_ROT>>)
|
|
ELIF iWave = 3
|
|
iFirstIndex = 5
|
|
iLastIndex = 5
|
|
iGuardSyncScene[GSS_REIN_SECOND_EXTRA] = CREATE_SYNCHRONIZED_SCENE(GET_SNATCH_AND_GRAB_VECTOR(SAGVEC_GUARD_ANIM_ORIGIN) + <<0.4,0.4,0>>, <<0,0,GUARD_ANIM_ORIGIN_ROT>>)
|
|
ELIF iWave = 4
|
|
iFirstIndex = 6
|
|
iLastIndex = 6
|
|
iGuardSyncScene[GSS_REIN_THIRD_EXTRA] = CREATE_SYNCHRONIZED_SCENE(GET_SNATCH_AND_GRAB_VECTOR(SAGVEC_GUARD_ANIM_ORIGIN) + <<-0.6,-2.5,0>>, <<0,0,GUARD_ANIM_ORIGIN_ROT>>)
|
|
ELIF iWave = 5
|
|
iFirstIndex = 7
|
|
iLastIndex = 7
|
|
iGuardSyncScene[GSS_REIN_FOURTH_EXTRA] = CREATE_SYNCHRONIZED_SCENE(GET_SNATCH_AND_GRAB_VECTOR(SAGVEC_GUARD_ANIM_ORIGIN), <<0,0,GUARD_ANIM_ORIGIN_ROT>>)
|
|
ENDIF
|
|
|
|
FOR i=iFirstIndex TO iLastIndex
|
|
IF NOT DOES_ENTITY_EXIST(reinforcementPed[i])
|
|
weapon = GET_SNATCH_AND_GRAB_WEAPON_TYPE(SAG_WEAPON_CIA_PISTOL)
|
|
SWITCH i
|
|
CASE 0
|
|
vPos = <<116.45, -626.87, 205.05>>
|
|
fRot = -32.35
|
|
sAnim = "WAVE_2_A"
|
|
weapon = GET_SNATCH_AND_GRAB_WEAPON_TYPE(SAG_WEAPON_CIA_SMG)
|
|
|
|
iHead = 1
|
|
iHeadTexture = 2
|
|
iTorso = 0
|
|
iTorsoTexture = 1
|
|
iLegTexture = 0
|
|
iHair = 2
|
|
iTask = 0
|
|
BREAK
|
|
|
|
CASE 1
|
|
vPos = <<133.85, -614.77, 205.05>>
|
|
fRot = 150.59
|
|
sAnim = "WAVE_2_B"
|
|
|
|
iHead = 1
|
|
iHeadTexture = 1
|
|
iTorso = 1
|
|
iTorsoTexture = 1
|
|
iLegTexture = 2
|
|
iHair = 3
|
|
iTask = 0
|
|
BREAK
|
|
|
|
CASE 2
|
|
vPos = <<125.73, -617.68, 205.05>>
|
|
fRot = 141.07
|
|
sAnim = "WAVE_2_C"
|
|
|
|
iHead = 2
|
|
iHeadTexture = 0
|
|
iTorso = 0
|
|
iTorsoTexture = 0
|
|
iLegTexture = 0
|
|
iHair = 3
|
|
iTask = 1
|
|
BREAK
|
|
|
|
CASE 3
|
|
vPos = <<126.11, -617.95, 205.05>>
|
|
fRot = 121.76
|
|
sAnim = "WAVE_2_D"
|
|
|
|
iHead = 0
|
|
iHeadTexture = 1
|
|
iTorso = 1
|
|
iTorsoTexture = 2
|
|
iLegTexture = 1
|
|
iHair = 3
|
|
iTask = 0
|
|
BREAK
|
|
|
|
CASE 4
|
|
vPos = <<117.16, -628.03, 205.05>>
|
|
fRot = -44.96
|
|
sAnim = "WAVE_3_A"
|
|
weapon = GET_SNATCH_AND_GRAB_WEAPON_TYPE(SAG_WEAPON_CIA_SMG)
|
|
|
|
iHead = 0
|
|
iHeadTexture = 2
|
|
iTorso = 2
|
|
iTorsoTexture = 0
|
|
iLegTexture = 2
|
|
iHair = 3
|
|
iTask = 0
|
|
BREAK
|
|
|
|
CASE 5
|
|
vPos = <<130.94, -614.26, 205.05>>
|
|
fRot = 123.36
|
|
sAnim = "WAVE_3_B"
|
|
weapon = GET_SNATCH_AND_GRAB_WEAPON_TYPE(SAG_WEAPON_CIA_SMG)
|
|
|
|
iHead = 1
|
|
iHeadTexture = 0
|
|
iTorso = 1
|
|
iTorsoTexture = 2
|
|
iLegTexture = 1
|
|
BREAK
|
|
|
|
CASE 6
|
|
vPos = <<126.11, -617.95, 205.05>>
|
|
fRot = 121.76
|
|
sAnim = "WAVE_2_D"
|
|
|
|
iHead = 0
|
|
iHeadTexture = 0
|
|
iTorso = 1
|
|
iTorsoTexture = 0
|
|
iLegTexture = 1
|
|
iHair = 3
|
|
iTask = 1
|
|
BREAK
|
|
|
|
CASE 7
|
|
vPos = <<133.85, -614.77, 205.05>>
|
|
fRot = 150.59
|
|
sAnim = "WAVE_1_A"
|
|
|
|
iHead = 0
|
|
iHeadTexture = 2
|
|
iTorso = 0
|
|
iTorsoTexture = 5
|
|
iLegTexture = 1
|
|
iTask = 1
|
|
iHair = 3
|
|
BREAK
|
|
ENDSWITCH
|
|
|
|
reinforcementPed[i] = CREATE_PED(PEDTYPE_MISSION, GET_MODEL_FOR_SNATCH_AND_GRAB_MODEL_ENUM(SAGM_GUARD), vPos, fRot)
|
|
GIVE_WEAPON_TO_PED(reinforcementPed[i], weapon, INFINITE_AMMO, TRUE)
|
|
SET_BLOCKING_OF_NON_TEMPORARY_EVENTS(reinforcementPed[i], TRUE)
|
|
STOP_PED_WEAPON_FIRING_WHEN_DROPPED(reinforcementPed[i])
|
|
SET_PED_DIES_WHEN_INJURED(reinforcementPed[i], TRUE)
|
|
SET_PED_ACCURACY(reinforcementPed[i], 20)
|
|
//SET_PED_CHANCE_OF_FIRING_BLANKS(reinforcementPed[i], 0.0, 0.75)
|
|
SET_PED_AS_ENEMY(reinforcementPed[i], TRUE)
|
|
SET_PED_KEEP_TASK(reinforcementPed[i], TRUE)
|
|
SET_ENTITY_PROOFS(reinforcementPed[i], FALSE, FALSE, FALSE, TRUE, TRUE)
|
|
SET_PED_CAN_BE_TARGETTED(reinforcementPed[i], TRUE)
|
|
SET_PED_CAN_BE_TARGETED_WITHOUT_LOS(reinforcementPed[i], TRUE)
|
|
SET_ENTITY_IS_TARGET_PRIORITY(reinforcementPed[i], TRUE)
|
|
SET_PED_RELATIONSHIP_GROUP_HASH(reinforcementPed[i], agencyRelGroup)
|
|
reinforcementBlip[i] = CREATE_MISSION_BLIP_FOR_PED(reinforcementPed[i], TRUE)
|
|
INFORM_MISSION_STATS_OF_HEADSHOT_WATCH_ENTITY(reinforcementPed[i])
|
|
SET_PED_CONFIG_FLAG(reinforcementPed[i], PCF_DisableHurt, TRUE)
|
|
SET_PED_CONFIG_FLAG(reinforcementPed[i], PCF_DisableExplosionReactions, TRUE)
|
|
SET_PED_CONFIG_FLAG(reinforcementPed[i], PCF_RunFromFiresAndExplosions, FALSE)
|
|
SET_PED_CONFIG_FLAG(reinforcementPed[i], PCF_DontReactivateRagdollOnPedCollisionWhenDead, TRUE)
|
|
DISABLE_PED_INJURED_ON_GROUND_BEHAVIOUR(reinforcementPed[i])
|
|
|
|
// variation
|
|
SET_PED_COMPONENT_VARIATION(reinforcementPed[i], PED_COMP_HEAD, iHead, iHeadTexture)
|
|
SET_PED_COMPONENT_VARIATION(reinforcementPed[i], PED_COMP_TORSO, iTorso, iTorsoTexture)
|
|
SET_PED_COMPONENT_VARIATION(reinforcementPed[i], PED_COMP_LEG, 0, iLegTexture)
|
|
SET_PED_COMPONENT_VARIATION(reinforcementPed[i], PED_COMP_SPECIAL2, iTask, 0)
|
|
SET_PED_COMPONENT_VARIATION(reinforcementPed[i], PED_COMP_HAIR, iHair, 0)
|
|
|
|
// task ped
|
|
PED_INDEX michaelped = GET_MICHAEL_PED()
|
|
IF NOT IS_PED_INJURED(michaelPed)
|
|
TASK_LOOK_AT_ENTITY(reinforcementPed[i], michaelPed, -1, SLF_USE_EYES_ONLY)
|
|
ENDIF
|
|
|
|
TASK_SYNCHRONIZED_SCENE(reinforcementPed[i], iGuardSyncScene[GET_SYNCED_SCENE_FOR_REINFORCEMENT(i)], GET_SNATCH_AND_GRAB_ANIM_DICT_AS_STRING(SAG_ANIM_DICT_GUARDS), sAnim, INSTANT_BLEND_IN, GUARD_ANIM_BLEND_OUT, SYNCED_SCENE_NONE)
|
|
IF i=6
|
|
SET_SYNCHRONIZED_SCENE_PHASE(iGuardSyncScene[GSS_REIN_THIRD_EXTRA], 0.71)
|
|
ELIF i=7
|
|
SET_SYNCHRONIZED_SCENE_PHASE(iGuardSyncScene[GSS_REIN_FOURTH_EXTRA], 0.2)
|
|
ENDIF
|
|
|
|
|
|
/*
|
|
CLEAR_SEQUENCE_TASK(sequence)
|
|
OPEN_SEQUENCE_TASK(sequence)
|
|
IF i<=1
|
|
TASK_FOLLOW_NAV_MESH_TO_COORD(NULL, GET_SNATCH_AND_GRAB_VECTOR(SAGVEC_GUARD_DOOR_OUTSIDE), PEDMOVE_RUN, DEFAULT_TIME_BEFORE_WARP, 0.25)
|
|
TASK_GO_TO_COORD_WHILE_AIMING_AT_ENTITY(NULL, GET_SNATCH_AND_GRAB_VECTOR(SAGVEC_GUARD_DOOR_OUTSIDE), PLAYER_PED_ID(), PEDMOVE_WALK, FALSE)
|
|
TASK_GO_TO_COORD_WHILE_AIMING_AT_ENTITY(NULL, GET_SNATCH_AND_GRAB_VECTOR(SAGVEC_GUARD_DOOR_INSIDE), PLAYER_PED_ID(), PEDMOVE_WALK, FALSE)
|
|
TASK_GO_TO_COORD_WHILE_AIMING_AT_ENTITY(NULL, vGotoPos, PLAYER_PED_ID(), PEDMOVE_WALK, FALSE, 0.5, 4, FALSE)
|
|
ELSE
|
|
TASK_FOLLOW_NAV_MESH_TO_COORD(NULL, vGotoPos, PEDMOVE_RUN)
|
|
ENDIF
|
|
TASK_AIM_GUN_AT_ENTITY(NULL, PLAYER_PED_ID(), 6000)
|
|
TASK_SHOOT_AT_ENTITY(NULL, PLAYER_PED_ID(), 50000, FIRING_TYPE_RANDOM_BURSTS)
|
|
CLOSE_SEQUENCE_TASK(sequence)
|
|
TASK_PERFORM_SEQUENCE(reinforcementPed[i], sequence)
|
|
*/
|
|
|
|
IF i=0
|
|
ADD_PED_FOR_DIALOGUE(snatchAndGrabConversation, 4, reinforcementPed[i], "FBI2AGENT5")
|
|
ELIF i=1
|
|
ADD_PED_FOR_DIALOGUE(snatchAndGrabConversation, 5, reinforcementPed[i], "FBI2AGENT7")
|
|
ELIF i=3
|
|
ADD_PED_FOR_DIALOGUE(snatchAndGrabConversation, 6, reinforcementPed[i], "FBI2AGENT8")
|
|
ELIF i=5
|
|
SET_ENTITY_ONLY_DAMAGED_BY_PLAYER(reinforcementPed[i], TRUE)
|
|
ENDIF
|
|
ENDIF
|
|
ENDFOR
|
|
ENDPROC
|
|
|
|
// give franklin the sniper rifle
|
|
PROC GIVE_FRANKLIN_SNIPER_RIFLE()
|
|
PED_INDEX franklinPed = GET_FRANKLIN_PED()
|
|
IF NOT IS_PED_INJURED(franklinPed)
|
|
WEAPON_TYPE sniperWeapon = GET_SNATCH_AND_GRAB_WEAPON_TYPE(SAG_WEAPON_SNIPER_RIFLE)
|
|
|
|
IF NOT bCheckedInitialSniper
|
|
IF HAS_PED_GOT_WEAPON(franklinPed, sniperWeapon)
|
|
iInitialSniperAmmo = GET_AMMO_IN_PED_WEAPON(franklinPed, sniperWeapon)
|
|
ELSE
|
|
iInitialSniperAmmo = -1
|
|
ENDIF
|
|
bCheckedInitialSniper = TRUE
|
|
ENDIF
|
|
|
|
GIVE_WEAPON_TO_PED(franklinPed, sniperWeapon, 200, TRUE)
|
|
|
|
PRINTSTRING("gave franklin a rifle!") PRINTNL()
|
|
ENDIF
|
|
ENDPROC
|
|
|
|
// give michael the advanced rifle
|
|
PROC GIVE_MICHAEL_RIFLE()
|
|
PED_INDEX michaelPed = GET_MICHAEL_PED()
|
|
|
|
IF NOT IS_PED_INJURED(michaelPed)
|
|
IF iSavedAmmo < 0
|
|
IF HAS_PED_GOT_WEAPON(PLAYER_PED_ID(), WEAPONTYPE_ASSAULTRIFLE)
|
|
iSavedAmmo = GET_AMMO_IN_PED_WEAPON(PLAYER_PED_ID(), WEAPONTYPE_ASSAULTRIFLE)
|
|
ELIF HAS_PED_GOT_WEAPON(PLAYER_PED_ID(), WEAPONTYPE_CARBINERIFLE)
|
|
iSavedAmmo = GET_AMMO_IN_PED_WEAPON(PLAYER_PED_ID(), WEAPONTYPE_CARBINERIFLE)
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF GET_AMMO_IN_PED_WEAPON(michaelPed, GET_SNATCH_AND_GRAB_WEAPON_TYPE(SAG_WEAPON_MICHAEL_RIFLE)) = 0
|
|
SET_PED_AMMO(michaelPed, GET_SNATCH_AND_GRAB_WEAPON_TYPE(SAG_WEAPON_MICHAEL_RIFLE), 1)
|
|
ENDIF
|
|
GIVE_WEAPON_TO_PED(michaelPed, GET_SNATCH_AND_GRAB_WEAPON_TYPE(SAG_WEAPON_MICHAEL_RIFLE), INFINITE_AMMO, TRUE)
|
|
SET_PED_INFINITE_AMMO(michaelPed, TRUE, GET_SNATCH_AND_GRAB_WEAPON_TYPE(SAG_WEAPON_MICHAEL_RIFLE))
|
|
SET_PED_INFINITE_AMMO_CLIP(michaelPed, TRUE)
|
|
|
|
//REQUEST_WEAPON_AUDIO("WEAPON_ADVANCEDRIFLE") // temp
|
|
ENDIF
|
|
ENDPROC
|
|
|
|
// freeze franklin at sniper
|
|
PROC FREEZE_FRANKLIN_AT_SNIPER(BOOL bFakeClose = TRUE)
|
|
PED_INDEX franklinPed = GET_FRANKLIN_PED()
|
|
|
|
IF NOT IS_PED_INJURED(franklinPed)
|
|
IF DOES_ENTITY_EXIST(franklinAnchorObject)
|
|
DELETE_OBJECT(franklinAnchorObject)
|
|
ENDIF
|
|
|
|
VECTOR vCreatePos
|
|
IF bFakeClose
|
|
vCreatePos = GET_SNATCH_AND_GRAB_VECTOR(SAGVEC_BEHIND_SNIPER)
|
|
ELSE
|
|
vCreatePos = <<-139.44, -594.43, 211.77>>
|
|
ENDIF
|
|
|
|
//FREEZE_ENTITY_POSITION(franklinPed, FALSE)
|
|
|
|
franklinAnchorObject = CREATE_OBJECT(GET_MODEL_FOR_SNATCH_AND_GRAB_MODEL_ENUM(SAGM_HARNESS), vCreatePos)
|
|
SET_ENTITY_HEADING(franklinAnchorObject, FRANKLIN_SNIPER_ROT)
|
|
FREEZE_ENTITY_POSITION(franklinAnchorObject, TRUE)
|
|
SET_ENTITY_VISIBLE(franklinAnchorObject, FALSE)
|
|
SET_ENTITY_COLLISION(franklinAnchorObject, FALSE)
|
|
FREEZE_ENTITY_POSITION(franklinPed, FALSE)
|
|
ATTACH_ENTITY_TO_ENTITY(franklinPed, franklinAnchorObject, 0, <<0,0,0>>, <<0,0,0>>)
|
|
|
|
IF bFakeClose
|
|
SET_ENTITY_VISIBLE(franklinPed, FALSE)
|
|
ENDIF
|
|
//SET_ENTITY_COLLISION(franklinPed, FALSE)
|
|
ENDIF
|
|
ENDPROC
|
|
|
|
// ensure franklin invisible
|
|
PROC ENSURE_FRANKLIN_INVISIBLE()
|
|
PED_INDEX franklinPed = GET_FRANKLIN_PED()
|
|
|
|
IF NOT IS_PED_INJURED(franklinPed)
|
|
SET_ENTITY_VISIBLE(franklinPed, FALSE)
|
|
ENDIF
|
|
ENDPROC
|
|
|
|
// create remote sniper object
|
|
PROC CREATE_SNIPER_OBJECT()
|
|
// create franklin
|
|
SNATCH_AND_GRAB_CREATE_PLAYER_CHARACTER(CHAR_FRANKLIN, STAGE_SNIPE_GUARDS, GET_SNATCH_AND_GRAB_VECTOR(SAGVEC_BEHIND_SNIPER), FRANKLIN_SNIPER_ROT)
|
|
FREEZE_FRANKLIN_AT_SNIPER()
|
|
GIVE_FRANKLIN_SNIPER_RIFLE()
|
|
//TASK_PLAY_ANIM(sSelectorPeds.pedID[SELECTOR_PED_FRANKLIN], "move_crouch", "idle", INSTANT_BLEND_IN, NORMAL_BLEND_OUT, -1, AF_LOOPING)
|
|
ENDPROC
|
|
|
|
// create dummy franklin
|
|
PROC CREATE_DUMMY_FRANKLIN(BOOL bCreatePed = TRUE)
|
|
VECTOR vPos = <<-135.52, -592.39, 210.68>>
|
|
FLOAT fRot = -96.1
|
|
IF bCreatePed
|
|
CREATE_PLAYER_PED_ON_FOOT(dummyFranklinPed, CHAR_FRANKLIN, vPos, fRot, FALSE)
|
|
GIVE_WEAPON_TO_PED(dummyFranklinPed, GET_SNATCH_AND_GRAB_WEAPON_TYPE(SAG_WEAPON_SNIPER_RIFLE), 800, TRUE)
|
|
SET_ENTITY_SHOULD_FREEZE_WAITING_ON_COLLISION(dummyFranklinPed, FALSE)
|
|
SET_PED_COMP_ITEM_CURRENT_SP(dummyFranklinPed, COMP_TYPE_PROPS, PROPS_P1_HEADSET)
|
|
FREEZE_ENTITY_POSITION(dummyFranklinPed, TRUE)
|
|
SET_BLOCKING_OF_NON_TEMPORARY_EVENTS(dummyFranklinPed, TRUE)
|
|
SET_ENTITY_PROOFS(dummyFranklinPed, TRUE, TRUE, TRUE, TRUE, TRUE)
|
|
SET_FACIAL_IDLE_ANIM_OVERRIDE(dummyFranklinPed, "Mood_Angry_1")
|
|
|
|
SET_PED_COMP_ITEM_CURRENT_SP(dummyFranklinPed, COMP_TYPE_OUTFIT, OUTFIT_P1_HOODIE_AND_JEANS_1, FALSE) // remember to change at lot!
|
|
//SET_PED_COMPONENT_VARIATION(dummyFranklinPed, PED_COMP_FEET, FRANKLIN_SMART_FEET, 0)
|
|
////SET_PED_COMPONENT_VARIATION(dummyFranklinPed, PED_COMP_TORSO, FRANKLIN_SMART_TORSO, 0)
|
|
//SET_PED_COMPONENT_VARIATION(dummyFranklinPed, PED_COMP_LEG, FRANKLIN_SMART_LEG, 0)
|
|
ELSE
|
|
IF NOT IS_PED_INJURED(dummyFranklinPed)
|
|
SET_ENTITY_COORDS(dummyFranklinPed, vPos)
|
|
SET_ENTITY_HEADING(dummyFranklinPed, fRot)
|
|
FREEZE_ENTITY_POSITION(dummyFranklinPed, TRUE)
|
|
SET_CURRENT_PED_WEAPON(dummyFranklinPed, GET_SNATCH_AND_GRAB_WEAPON_TYPE(SAG_WEAPON_SNIPER_RIFLE), TRUE)
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF NOT IS_PED_INJURED(dummyFranklinPed)
|
|
TASK_PLAY_ANIM(dummyFranklinPed, GET_SNATCH_AND_GRAB_ANIM_DICT_AS_STRING(SAG_ANIM_DICT_GUARDS), "FRANKLIN_SNIPER_CROUCH", INSTANT_BLEND_IN, NORMAL_BLEND_OUT, -1, AF_LOOPING)
|
|
FORCE_PED_AI_AND_ANIMATION_UPDATE(dummyFranklinPed)
|
|
ENDIF
|
|
ENDPROC
|
|
|
|
/*
|
|
// set the chopper to arrive
|
|
FUNC INT SET_CHOPPER_TO_ARRIVE()
|
|
IF IS_VEHICLE_DRIVEABLE(snatchAndGrabVehicle[SAGV_PLAYER_CHOPPER])
|
|
IF IS_PLAYBACK_GOING_ON_FOR_VEHICLE(snatchAndGrabVehicle[SAGV_PLAYER_CHOPPER])
|
|
STOP_PLAYBACK_RECORDED_VEHICLE(snatchAndGrabVehicle[SAGV_PLAYER_CHOPPER])
|
|
ENDIF
|
|
INT iRec
|
|
FLOAT fSpeed
|
|
VECTOR vChopperPos = GET_ENTITY_COORDS(snatchAndGrabVehicle[SAGV_PLAYER_CHOPPER])
|
|
IF vChopperPos.x >= 177.64
|
|
OR IS_ENTITY_IN_ANGLED_AREA(snatchAndGrabVehicle[SAGV_PLAYER_CHOPPER], <<124.640, -625.900, 266.970>>, <<183.060, -657.460, 241.660>>, 150, FALSE, FALSE)
|
|
iRec = 004
|
|
fPlaybackTime = 1000
|
|
fSpeed = 1.0
|
|
ELSE
|
|
IF vChopperPos.y >= -629.58
|
|
iRec = 005
|
|
fPlaybackTime = 2400
|
|
fSpeed = 1.0
|
|
ELSE
|
|
iRec = 006
|
|
fPlaybackTime = 1000
|
|
fSpeed = 0.87
|
|
ENDIF
|
|
ENDIF
|
|
|
|
START_PLAYBACK_RECORDED_VEHICLE(snatchAndGrabVehicle[SAGV_PLAYER_CHOPPER], iRec, GET_SNATCH_AND_GRAB_RECORDING_PREFIX())
|
|
SET_PLAYBACK_SPEED(snatchAndGrabVehicle[SAGV_PLAYER_CHOPPER], fSpeed)
|
|
SET_VEHICLE_ENGINE_ON(snatchAndGrabVehicle[SAGV_PLAYER_CHOPPER], TRUE, TRUE)
|
|
SET_HELI_BLADES_FULL_SPEED(snatchAndGrabVehicle[SAGV_PLAYER_CHOPPER])
|
|
SKIP_TIME_IN_PLAYBACK_RECORDED_VEHICLE(snatchAndGrabVehicle[SAGV_PLAYER_CHOPPER], fPlaybackTime)
|
|
FORCE_PLAYBACK_RECORDED_VEHICLE_UPDATE(snatchAndGrabVehicle[SAGV_PLAYER_CHOPPER])
|
|
|
|
RETURN iRec
|
|
ENDIF
|
|
|
|
RETURN -1
|
|
ENDFUNC
|
|
*/
|
|
|
|
// set the chopper to hover
|
|
PROC SET_CHOPPER_TO_HOVER(BOOL bForceUpdate = TRUE)
|
|
IF IS_VEHICLE_DRIVEABLE(snatchAndGrabVehicle[SAGV_PLAYER_CHOPPER])
|
|
IF NOT IS_PLAYBACK_GOING_ON_FOR_VEHICLE(snatchAndGrabVehicle[SAGV_PLAYER_CHOPPER])
|
|
SET_ENTITY_COORDS(snatchAndGrabVehicle[SAGV_PLAYER_CHOPPER],GET_SNATCH_AND_GRAB_VECTOR(SAGVEC_CHOPPER_HOVER))
|
|
SET_ENTITY_HEADING(snatchAndGrabVehicle[SAGV_PLAYER_CHOPPER], CHOPPER_HOVER_ROT)
|
|
FREEZE_ENTITY_POSITION(snatchAndGrabVehicle[SAGV_PLAYER_CHOPPER], FALSE)
|
|
SET_VEHICLE_ENGINE_ON(snatchAndGrabVehicle[SAGV_PLAYER_CHOPPER], TRUE, TRUE)
|
|
START_PLAYBACK_RECORDED_VEHICLE(snatchAndGrabVehicle[SAGV_PLAYER_CHOPPER], 001, GET_SNATCH_AND_GRAB_RECORDING_PREFIX())
|
|
IF bForceUpdate
|
|
FORCE_PLAYBACK_RECORDED_VEHICLE_UPDATE(snatchAndGrabVehicle[SAGV_PLAYER_CHOPPER])
|
|
ENDIF
|
|
//SET_PLAYBACK_SPEED(snatchAndGrabVehicle[SAGV_PLAYER_CHOPPER], CHOPPER_HOVER_SPEED)
|
|
SET_PLAYBACK_SPEED(snatchAndGrabVehicle[SAGV_PLAYER_CHOPPER], 0.0)
|
|
SET_HELI_BLADES_FULL_SPEED(snatchAndGrabVehicle[SAGV_PLAYER_CHOPPER])
|
|
fHoverPlaybackSpeed = CHOPPER_HOVER_SPEED
|
|
ENDIF
|
|
ENDIF
|
|
ENDPROC
|
|
|
|
// set the chopper to escape
|
|
PROC SET_CHOPPER_TO_ESCAPE(BOOL bSkipToGetaway = FALSE)
|
|
IF IS_VEHICLE_DRIVEABLE(snatchAndGrabVehicle[SAGV_PLAYER_CHOPPER])
|
|
IF IS_PLAYBACK_GOING_ON_FOR_VEHICLE(snatchAndGrabVehicle[SAGV_PLAYER_CHOPPER])
|
|
STOP_PLAYBACK_RECORDED_VEHICLE(snatchAndGrabVehicle[SAGV_PLAYER_CHOPPER])
|
|
ENDIF
|
|
IF NOT bSkipToGetaway
|
|
START_PLAYBACK_RECORDED_VEHICLE(snatchAndGrabVehicle[SAGV_PLAYER_CHOPPER], 002, GET_SNATCH_AND_GRAB_RECORDING_PREFIX())
|
|
ELSE
|
|
START_PLAYBACK_RECORDED_VEHICLE(snatchAndGrabVehicle[SAGV_PLAYER_CHOPPER], 011, GET_SNATCH_AND_GRAB_RECORDING_PREFIX())
|
|
ENDIF
|
|
|
|
|
|
SET_VEHICLE_ENGINE_ON(snatchAndGrabVehicle[SAGV_PLAYER_CHOPPER], TRUE, TRUE)
|
|
SET_HELI_BLADES_FULL_SPEED(snatchAndGrabVehicle[SAGV_PLAYER_CHOPPER])
|
|
|
|
IF NOT bSkipToGetaway
|
|
fPlaybackTime = CHASE_FORCE_SWITCH_TIME//SKIP_CHOPPER_PLAYBACK_TIME
|
|
SET_PLAYBACK_SPEED(snatchAndGrabVehicle[SAGV_PLAYER_CHOPPER], 0.0)
|
|
ELSE
|
|
fPlaybackTime = 2500
|
|
SET_PLAYBACK_SPEED(snatchAndGrabVehicle[SAGV_PLAYER_CHOPPER], CHOPPER_ESCAPE_SPEED)
|
|
ENDIF
|
|
SKIP_TIME_IN_PLAYBACK_RECORDED_VEHICLE(snatchAndGrabVehicle[SAGV_PLAYER_CHOPPER], fPlaybackTime)
|
|
FORCE_PLAYBACK_RECORDED_VEHICLE_UPDATE(snatchAndGrabVehicle[SAGV_PLAYER_CHOPPER])
|
|
ENDIF
|
|
ENDPROC
|
|
|
|
// enemy peds on foot during chase
|
|
FUNC INT HANDLE_ENEMY_FOOT_PEDS()
|
|
INT i
|
|
INT iAlive = 0
|
|
|
|
REPEAT NUMBER_REINFORCEMENTS i
|
|
//IF DOES_BLIP_EXIST(reinforcementBlip[i])
|
|
IF IS_PED_INJURED(reinforcementPed[i])
|
|
OR fPlaybackTime >= CHASE_UNPIN_INTERIOR_TIME
|
|
IF DOES_BLIP_EXIST(reinforcementBlip[i])
|
|
REMOVE_BLIP(reinforcementBlip[i])
|
|
INFORM_MISSION_STATS_OF_INCREMENT(FBI2_KILLS)
|
|
ENDIF
|
|
ELSE
|
|
iAlive++
|
|
ENDIF
|
|
//ENDIF
|
|
ENDREPEAT
|
|
|
|
RETURN iAlive
|
|
ENDFUNC
|
|
|
|
// franklin sniping
|
|
PROC HANDLE_FRANKLIN_SNIPING()
|
|
INT i
|
|
|
|
IF GET_GAME_TIMER() >= iRecheckFranklinShootTime
|
|
BOOL bTargetIsValid[NUMBER_REINFORCEMENTS]
|
|
REPEAT NUMBER_REINFORCEMENTS i
|
|
IF NOT IS_PED_INJURED(reinforcementPed[i])
|
|
SWITCH i
|
|
CASE 0
|
|
// WAVE_2_A
|
|
bTargetIsValid[i] = FALSE
|
|
BREAK
|
|
CASE 1
|
|
// WAVE_2_B
|
|
IF bReinforcementToShoot[i]
|
|
bTargetIsValid[i] = TRUE
|
|
ELSE
|
|
IF GET_SYNCHRONIZED_SCENE_PHASE(iGuardSyncScene[GSS_STANDARD]) >= 0.475
|
|
bTargetIsValid[i] = TRUE
|
|
ENDIF
|
|
ENDIF
|
|
BREAK
|
|
CASE 2
|
|
// WAVE_2_C
|
|
IF bReinforcementToShoot[i]
|
|
bTargetIsValid[i] = TRUE
|
|
ELSE
|
|
IF GET_SYNCHRONIZED_SCENE_PHASE(iGuardSyncScene[GSS_STANDARD]) >= 0.328
|
|
bTargetIsValid[i] = TRUE
|
|
ENDIF
|
|
ENDIF
|
|
BREAK
|
|
CASE 3
|
|
// WAVE_2_D
|
|
IF bReinforcementToShoot[i]
|
|
bTargetIsValid[i] = TRUE
|
|
ELSE
|
|
IF GET_SYNCHRONIZED_SCENE_PHASE(iGuardSyncScene[GSS_STANDARD]) >= 0.843
|
|
bTargetIsValid[i] = TRUE
|
|
ENDIF
|
|
ENDIF
|
|
BREAK
|
|
CASE 4
|
|
// WAVE_3_A
|
|
IF bReinforcementToShoot[i]
|
|
bTargetIsValid[i] = TRUE
|
|
ELSE
|
|
IF GET_SYNCHRONIZED_SCENE_PHASE(iGuardSyncScene[GSS_REIN_FIRST_EXTRA]) >= 0.542
|
|
bTargetIsValid[i] = TRUE
|
|
ENDIF
|
|
ENDIF
|
|
BREAK
|
|
CASE 5
|
|
// WAVE_3_B
|
|
bTargetIsValid[i] = FALSE
|
|
BREAK
|
|
CASE 6
|
|
bTargetIsValid[i] = FALSE
|
|
/*
|
|
// WAVE_2_D
|
|
IF bReinforcementToShoot[i]
|
|
bTargetIsValid[i] = TRUE
|
|
ELSE
|
|
IF GET_SYNCHRONIZED_SCENE_PHASE(iGuardSyncScene[GSS_REIN_THIRD_EXTRA]) >= 0.843
|
|
bTargetIsValid[i] = TRUE
|
|
ENDIF
|
|
ENDIF
|
|
*/
|
|
BREAK
|
|
CASE 7
|
|
bTargetIsValid[i] = FALSE
|
|
/*
|
|
// WAVE_2_D
|
|
IF bReinforcementToShoot[i]
|
|
bTargetIsValid[i] = TRUE
|
|
ELSE
|
|
IF GET_SYNCHRONIZED_SCENE_PHASE(iGuardSyncScene[GSS_REIN_THIRD_EXTRA]) >= 0.843
|
|
bTargetIsValid[i] = TRUE
|
|
ENDIF
|
|
ENDIF
|
|
*/
|
|
BREAK
|
|
ENDSWITCH
|
|
ENDIF
|
|
ENDREPEAT
|
|
|
|
BOOL bFoundTarget = FALSE
|
|
INT iTargetCheckCounter = 0
|
|
WHILE iTargetCheckCounter < 20 AND NOT bFoundTarget
|
|
INT iRandom = GET_RANDOM_INT_IN_RANGE(0, NUMBER_REINFORCEMENTS)
|
|
IF bTargetIsValid[iRandom]
|
|
iFranklinTargetPed = iRandom
|
|
bFoundTarget = TRUE
|
|
ENDIF
|
|
iTargetCheckCounter++
|
|
ENDWHILE
|
|
|
|
IF NOT bFoundTarget
|
|
iFranklinTargetPed = -1
|
|
iRecheckFranklinShootTime = GET_GAME_TIMER() + 2000
|
|
ELSE
|
|
iRecheckFranklinShootTime = GET_GAME_TIMER() + GET_RANDOM_INT_IN_RANGE(5000, 10000)
|
|
ENDIF
|
|
ELSE
|
|
IF GET_GAME_TIMER() >= iNextFranklinSnipeTime
|
|
IF iFranklinTargetPed >= 0
|
|
IF NOT IS_PED_INJURED(reinforcementPed[iFranklinTargetPed])
|
|
VECTOR vTargetPos = GET_ENTITY_COORDS(reinforcementPed[iFranklinTargetPed]) + <<0,0,0.5>>
|
|
|
|
// apply random inaccuracy
|
|
VECTOR vInaccuracy
|
|
vInaccuracy.x = GET_RANDOM_FLOAT_IN_RANGE(0,0.05)
|
|
vInaccuracy.y = GET_RANDOM_FLOAT_IN_RANGE(0,0.05)
|
|
vInaccuracy.z = GET_RANDOM_FLOAT_IN_RANGE(0,0.05)
|
|
IF GET_RANDOM_INT_IN_RANGE(0,2) = 0
|
|
vInaccuracy.x *= -1
|
|
ENDIF
|
|
IF GET_RANDOM_INT_IN_RANGE(0,2) = 0
|
|
vInaccuracy.y *= -1
|
|
ENDIF
|
|
IF GET_RANDOM_INT_IN_RANGE(0,2) = 0
|
|
vInaccuracy.z *= -1
|
|
ENDIF
|
|
vTargetPos += vInaccuracy
|
|
|
|
PLAY_SOUND_FRONTEND(-1, "Remote_Sniper_Rifle_Fire")
|
|
SHOOT_SINGLE_BULLET_BETWEEN_COORDS(GET_SNATCH_AND_GRAB_VECTOR(SAGVEC_SNIPER_AI_SHOT_ORIGIN), vTargetPos, 1000, TRUE, WEAPONTYPE_HEAVYSNIPER, PLAYER_PED_ID())
|
|
ELSE
|
|
iRecheckFranklinShootTime = 0
|
|
ENDIF
|
|
ELSE
|
|
iRecheckFranklinShootTime = 0
|
|
ENDIF
|
|
|
|
iNextFranklinSnipeTime = GET_GAME_TIMER() + GET_RANDOM_INT_IN_RANGE(1300, 2300)
|
|
ENDIF
|
|
ENDIF
|
|
ENDPROC
|
|
|
|
CONST_FLOAT MICHAEL_TARGET_MAX_RANGE 100.0
|
|
// michael shooting
|
|
PROC HANDLE_MICHAEL_SHOOTING()
|
|
INT i
|
|
IF NOT IS_PED_INJURED(sSelectorPeds.pedID[SELECTOR_PED_MICHAEL])
|
|
IF GET_GAME_TIMER() >= iRecheckMichaelShootTime
|
|
// get closest enemy ped
|
|
INT iClosestPed = -1
|
|
FLOAT fClosestDistance = 999999.0
|
|
FLOAT fThisDistance
|
|
|
|
REPEAT COUNT_OF(reinforcementPed) i
|
|
IF NOT IS_PED_INJURED(reinforcementPed[i])
|
|
fThisDistance = GET_DISTANCE_BETWEEN_ENTITIES(sSelectorPeds.pedID[SELECTOR_PED_MICHAEL], reinforcementPed[i], FALSE)
|
|
IF fThisDistance < MICHAEL_TARGET_MAX_RANGE
|
|
IF fThisDistance < fClosestDistance
|
|
IF (bLastReinforcementIsLast OR i <> 5)
|
|
AND NOT IS_ENTITY_AT_COORD(reinforcementPed[i], <<125.42207, -620.20752, 205.10718>>, <<1,1,1>>, FALSE, FALSE)
|
|
//IF IS_ENTITY_IN_AREA(reinforcementPed[i], <<109.87708, -625.67480, 205.04633>>, <<124.29398, -620.27441, 205.04680>>, FALSE, FALSE)
|
|
//IF IS_PED_SHOOTING(reinforcementPed[i])
|
|
IF GET_SCRIPT_TASK_STATUS(reinforcementPed[i], SCRIPT_TASK_SYNCHRONIZED_SCENE) = FINISHED_TASK
|
|
OR IS_ENTITY_IN_AREA(reinforcementPed[i], <<117.89629, -623.78284, 205.04694>>, <<123.42686, -621.71790, 205.04678>>, FALSE, FALSE)
|
|
iClosestPed = i
|
|
fClosestDistance = fThisDistance
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDREPEAT
|
|
|
|
IF iClosestPed >= 0
|
|
IF reinforcementPed[iClosestPed] <> michaelTargetPed
|
|
TASK_AIM_GUN_SCRIPTED_WITH_TARGET(sSelectorPeds.pedID[SELECTOR_PED_MICHAEL], reinforcementPed[iClosestPed], <<0,0,0>>, SCRIPTED_GUN_TASK_ON_ROPE)
|
|
michaelTargetPed = reinforcementPed[iClosestPed]
|
|
ENDIF
|
|
iRecheckMichaelShootTime = GET_GAME_TIMER() + 2000
|
|
ELSE
|
|
IF DOES_ENTITY_EXIST(michaelTargetPed)
|
|
TASK_PLAY_ANIM(sSelectorPeds.pedID[SELECTOR_PED_MICHAEL], GET_SNATCH_AND_GRAB_ANIM_DICT_AS_STRING(SAG_ANIM_DICT_MISSION), "idle", NORMAL_BLEND_IN, NORMAL_BLEND_OUT, -1, AF_LOOPING)
|
|
michaelTargetPed = NULL
|
|
ENDIF
|
|
iRecheckMichaelShootTime = GET_GAME_TIMER() + 1000
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDPROC
|
|
|
|
// michael shooting
|
|
PROC HANDLE_MICHAEL_DRIVEBY()
|
|
INT i
|
|
IF NOT IS_PED_INJURED(sSelectorPeds.pedID[SELECTOR_PED_MICHAEL])
|
|
SET_AMMO_IN_CLIP(sSelectorPeds.pedID[SELECTOR_PED_MICHAEL], GET_SNATCH_AND_GRAB_WEAPON_TYPE(SAG_WEAPON_MICHAEL_RIFLE), GET_MAX_AMMO_IN_CLIP(sSelectorPeds.pedID[SELECTOR_PED_MICHAEL], GET_SNATCH_AND_GRAB_WEAPON_TYPE(SAG_WEAPON_MICHAEL_RIFLE)))
|
|
|
|
IF GET_GAME_TIMER() >= iRecheckMichaelShootTime
|
|
// get closest enemy ped
|
|
INT iClosestChopper = -1
|
|
FLOAT fClosestDistance = 999999.0
|
|
FLOAT fThisDistance
|
|
|
|
BOOL bTakeOutFranklinChopper
|
|
IF DOES_BLIP_EXIST(enemyChopperBlip[0])
|
|
OR DOES_BLIP_EXIST(enemyChopperBlip[1])
|
|
OR DOES_BLIP_EXIST(enemyChopperBlip[3])
|
|
bTakeOutFranklinChopper = FALSE
|
|
ELSE
|
|
bTakeOutFranklinChopper = TRUE
|
|
ENDIF
|
|
/*
|
|
INT iCheckToChopper
|
|
IF DOES_BLIP_EXIST(enemyChopperBlip[0])
|
|
AND NOT DOES_BLIP_EXIST(enemyChopperBlip[1])
|
|
AND NOT DOES_BLIP_EXIST(enemyChopperBlip[3])
|
|
iCheckToChopper = 2
|
|
ELSE
|
|
iCheckToChopper = 3
|
|
ENDIF
|
|
*/
|
|
|
|
FOR i=0 TO 3
|
|
IF i <> 2
|
|
OR bTakeOutFranklinChopper
|
|
IF DOES_BLIP_EXIST(enemyChopperBlip[i])
|
|
IF IS_VEHICLE_DRIVEABLE(enemyChopperVehicle[i])
|
|
fThisDistance = GET_DISTANCE_BETWEEN_ENTITIES(sSelectorPeds.pedID[SELECTOR_PED_MICHAEL], enemyChopperVehicle[i], FALSE)
|
|
IF fThisDistance < MICHAEL_TARGET_MAX_RANGE
|
|
IF fThisDistance < fClosestDistance
|
|
iClosestChopper = i
|
|
fClosestDistance = fThisDistance
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDFOR
|
|
|
|
IF iClosestChopper >= 0
|
|
IF enemyChopperVehicle[iClosestChopper] <> michaelTargetVehicle
|
|
TASK_DRIVE_BY(sSelectorPeds.pedID[SELECTOR_PED_MICHAEL], NULL, enemyChopperVehicle[iClosestChopper], <<0,0,0>>, 1000, 100)
|
|
michaelTargetVehicle = enemyChopperVehicle[iClosestChopper]
|
|
ENDIF
|
|
iRecheckMichaelShootTime = GET_GAME_TIMER() + 2000
|
|
ELSE
|
|
IF DOES_ENTITY_EXIST(michaelTargetPed)
|
|
TASK_PAUSE(sSelectorPeds.pedID[SELECTOR_PED_MICHAEL], 100)
|
|
michaelTargetVehicle = NULL
|
|
ENDIF
|
|
iRecheckMichaelShootTime = GET_GAME_TIMER() + 1000
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDPROC
|
|
|
|
// franklin shooting
|
|
PROC HANDLE_FRANKLIN_SHOOT_FROM_ROOF()
|
|
IF NOT IS_PED_INJURED(sSelectorPeds.pedID[SELECTOR_PED_FRANKLIN])
|
|
SET_AMMO_IN_CLIP(sSelectorPeds.pedID[SELECTOR_PED_FRANKLIN], GET_SNATCH_AND_GRAB_WEAPON_TYPE(SAG_WEAPON_SNIPER_RIFLE), 6)
|
|
IF GET_GAME_TIMER() >= iRecheckFranklinShootTime
|
|
INT iTarget = -1
|
|
IF IS_VEHICLE_DRIVEABLE(enemyChopperVehicle[2])
|
|
iTarget = 2
|
|
ELIF IS_VEHICLE_DRIVEABLE(enemyChopperVehicle[0])
|
|
iTarget = 0
|
|
ELIF IS_VEHICLE_DRIVEABLE(enemyChopperVehicle[1])
|
|
iTarget = 1
|
|
ENDIF
|
|
|
|
IF iTarget >= 0
|
|
IF enemyChopperVehicle[iTarget] <> franklinTargetVehicle
|
|
TASK_SHOOT_AT_ENTITY(sSelectorPeds.pedID[SELECTOR_PED_FRANKLIN], enemyChopperVehicle[iTarget], -1, FIRING_TYPE_CONTINUOUS)
|
|
iRecheckFranklinShootTime = GET_GAME_TIMER() + 2000
|
|
franklinTargetVehicle = enemyChopperVehicle[iTarget]
|
|
ENDIF
|
|
ELSE
|
|
TASK_PAUSE(sSelectorPeds.pedID[SELECTOR_PED_FRANKLIN], 100)
|
|
iRecheckFranklinShootTime = GET_GAME_TIMER() + 2000
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDPROC
|
|
|
|
// attach michael non physically to the rope
|
|
PROC ATTACH_MICHAEL_TO_ROPE(BOOL bForce = TRUE)
|
|
PED_INDEX michaelPed = GET_MICHAEL_PED()
|
|
IF NOT IS_PED_INJURED(michaelPed)
|
|
DETACH_ENTITY(michaelPed)
|
|
IF DOES_ENTITY_EXIST(harnessObject)
|
|
ATTACH_ENTITY_TO_ENTITY(michaelPed, harnessObject, 0, GET_SNATCH_AND_GRAB_VECTOR(SAGVEC_ROPE_PLAYER_SWING_ATTACH), <<0,0,0>>, TRUE)
|
|
IF michaelPed = PLAYER_PED_ID()
|
|
TASK_AIM_GUN_SCRIPTED(michaelPed, SCRIPTED_GUN_TASK_ON_ROPE)
|
|
IF bForce
|
|
FORCE_PED_AI_AND_ANIMATION_UPDATE(michaelPed)
|
|
ENDIF
|
|
SET_GAMEPLAY_CAM_RELATIVE_HEADING(0.0)
|
|
SET_GAMEPLAY_CAM_RELATIVE_PITCH()
|
|
ELSE
|
|
FLOAT fBlendIn
|
|
IF bForce
|
|
CLEAR_PED_TASKS_IMMEDIATELY(michaelPed)
|
|
fBlendIn = INSTANT_BLEND_IN
|
|
ELSE
|
|
fBlendIn = NORMAL_BLEND_IN
|
|
ENDIF
|
|
TASK_PLAY_ANIM(michaelPed, GET_SNATCH_AND_GRAB_ANIM_DICT_AS_STRING(SAG_ANIM_DICT_MISSION), "idle", fBlendIn, INSTANT_BLEND_OUT, -1, AF_LOOPING)
|
|
IF bForce
|
|
FORCE_PED_AI_AND_ANIMATION_UPDATE(michaelPed)
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDPROC
|
|
|
|
// attach prisoner to michael
|
|
PROC ATTACH_PRISONER_TO_ROPE(BOOL bForce = TRUE)
|
|
IF NOT IS_PED_INJURED(prisonerPed)
|
|
SET_PED_CAN_RAGDOLL(prisonerPed, FALSE)
|
|
IF DOES_ENTITY_EXIST(harnessObject)
|
|
VECTOR vAttach = GET_SNATCH_AND_GRAB_VECTOR(SAGVEC_ROPE_PLAYER_SWING_ATTACH) + GET_SNATCH_AND_GRAB_VECTOR(SAGVEC_ROPE_PRISONER_SWING_ATTACH)
|
|
FLOAT fBlendIn
|
|
IF bForce
|
|
fBlendIn = INSTANT_BLEND_IN
|
|
ELSE
|
|
fBlendIn = NORMAL_BLEND_IN
|
|
ENDIF
|
|
ATTACH_ENTITY_TO_ENTITY(prisonerPed, harnessObject, 0, vAttach, <<0,0,0>>, TRUE)
|
|
TASK_PLAY_ANIM(prisonerPed, GET_SNATCH_AND_GRAB_ANIM_DICT_AS_STRING(SAG_ANIM_DICT_MISSION), "Hang_idle_mrk", fBlendIn, INSTANT_BLEND_OUT, -1, AF_LOOPING)
|
|
IF bForce
|
|
FORCE_PED_AI_AND_ANIMATION_UPDATE(prisonerPed)
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDPROC
|
|
|
|
// start prisoner grab
|
|
PROC UPDATE_PRISONER_GRAB(PRISONER_GRAB_STATE_ENUM newState)
|
|
STRING sMichaelAnim
|
|
STRING sPrisonerAnim
|
|
STRING sMichaelDict
|
|
STRING sPrisonerDict
|
|
BOOL bLooping
|
|
BOOL bForceIn
|
|
BOOL bForceOut
|
|
FLOAT fBlendIn
|
|
FLOAT fBlendOut
|
|
|
|
SWITCH newState
|
|
CASE PRISONER_GRAB_STATE_INIT
|
|
sMichaelAnim = "hostage_loop"
|
|
sPrisonerAnim = "hostage_loop_mrk"
|
|
sMichaelDict = GET_SNATCH_AND_GRAB_ANIM_DICT_AS_STRING(SAG_ANIM_DICT_IN_OFFICE)
|
|
sPrisonerDict = GET_SNATCH_AND_GRAB_ANIM_DICT_AS_STRING(SAG_ANIM_DICT_IN_OFFICE)
|
|
bLooping = TRUE
|
|
bForceIn = TRUE
|
|
bForceOut = FALSE
|
|
BREAK
|
|
CASE PRISONER_GRAB_STATE_DUCK_INTRO
|
|
sMichaelAnim = "hostage_low_intro"
|
|
sPrisonerAnim = "hostage_low_intro_mrk"
|
|
sMichaelDict = GET_SNATCH_AND_GRAB_ANIM_DICT_AS_STRING(SAG_ANIM_DICT_IN_OFFICE)
|
|
sPrisonerDict = GET_SNATCH_AND_GRAB_ANIM_DICT_AS_STRING(SAG_ANIM_DICT_IN_OFFICE)
|
|
bLooping = FALSE
|
|
bForceIn = FALSE
|
|
bForceOut = FALSE
|
|
BREAK
|
|
CASE PRISONER_GRAB_STATE_DUCK_LOOPING
|
|
sMichaelAnim = "hostage_loop_low"
|
|
sPrisonerAnim = "hostage_loop_low_mrk"
|
|
sMichaelDict = GET_SNATCH_AND_GRAB_ANIM_DICT_AS_STRING(SAG_ANIM_DICT_IN_OFFICE)
|
|
sPrisonerDict = GET_SNATCH_AND_GRAB_ANIM_DICT_AS_STRING(SAG_ANIM_DICT_IN_OFFICE)
|
|
bLooping = TRUE
|
|
bForceIn = FALSE
|
|
bForceOut = FALSE
|
|
BREAK
|
|
//CASE PRISONER_GRAB_STATE_DUCK_OUTRO
|
|
// sMichaelAnim = "hostage_low_outro"
|
|
// sPrisonerAnim = "hostage_low_outro_mrk"
|
|
// bLooping = FALSE
|
|
// bForceIn = FALSE
|
|
// bForceOut = FALSE
|
|
//BREAK
|
|
CASE PRISONER_GRAB_STATE_EXTRACT
|
|
sMichaelAnim = "extraction_sweep"
|
|
sPrisonerAnim = "extraction_sweep_mrk"
|
|
sMichaelDict = GET_SNATCH_AND_GRAB_ANIM_DICT_AS_STRING(SAG_ANIM_DICT_MISSION)
|
|
sPrisonerDict = GET_SNATCH_AND_GRAB_ANIM_DICT_AS_STRING(SAG_ANIM_DICT_MISSION)
|
|
bLooping = FALSE
|
|
bForceIn = FALSE
|
|
bForceOut = TRUE
|
|
BREAK
|
|
ENDSWITCH
|
|
|
|
IF bForceIn
|
|
fBlendIn = INSTANT_BLEND_IN
|
|
ELSE
|
|
fBlendIn = NORMAL_BLEND_IN
|
|
ENDIF
|
|
|
|
IF bForceOut
|
|
fBlendOut = INSTANT_BLEND_OUT
|
|
ELSE
|
|
fBlendOut = NORMAL_BLEND_OUT
|
|
ENDIF
|
|
|
|
PED_INDEX michaelPed = GET_MICHAEL_PED()
|
|
|
|
IF NOT IS_PED_INJURED(prisonerPed)
|
|
VECTOR vSceneMod = <<0,0,1.05>>
|
|
iSyncScene = CREATE_SYNCHRONIZED_SCENE(GET_SNATCH_AND_GRAB_VECTOR(SAGVEC_INTERROGATION) - vSceneMod, <<0.0, 0.0, INTERROGATION_ROT>>)
|
|
IF NOT IS_PED_INJURED(michaelPed)
|
|
TASK_SYNCHRONIZED_SCENE(michaelPed, iSyncScene, sMichaelDict, sMichaelAnim, fBlendIn, fBlendOut)
|
|
IF bForceIn
|
|
FORCE_PED_AI_AND_ANIMATION_UPDATE(michaelPed)
|
|
ENDIF
|
|
ENDIF
|
|
IF NOT IS_PED_INJURED(prisonerPed)
|
|
TASK_SYNCHRONIZED_SCENE(prisonerPed, iSyncScene, sPrisonerDict, sPrisonerAnim, fBlendIn, fBlendOut)
|
|
IF bForceIn
|
|
FORCE_PED_AI_AND_ANIMATION_UPDATE(prisonerPed)
|
|
ENDIF
|
|
ENDIF
|
|
SET_SYNCHRONIZED_SCENE_LOOPED(iSyncScene, bLooping)
|
|
ENDIF
|
|
|
|
prisonerGrabState = newState
|
|
ENDPROC
|
|
|
|
// window smash
|
|
PROC HANDLE_WINDOW_SMASH(BOOL bDoSmashWhenPrimed, BOOL bSkipStraightToEnd = FALSE)
|
|
|
|
//PRINTINT(iWindowSmashStage) PRINTNL()
|
|
|
|
SWITCH iWindowSmashStage
|
|
CASE 0
|
|
windowRayfire = GET_RAYFIRE_MAP_OBJECT(GET_SNATCH_AND_GRAB_VECTOR(SAGVEC_BREAK_IN), 3, "DES_FIB_Glass")
|
|
IF DOES_RAYFIRE_MAP_OBJECT_EXIST(windowRayfire)
|
|
SET_STATE_OF_RAYFIRE_MAP_OBJECT(windowRayfire, RFMO_STATE_RESET)
|
|
iWindowSmashStage++
|
|
ENDIF
|
|
BREAK
|
|
|
|
CASE 1
|
|
IF DOES_RAYFIRE_MAP_OBJECT_EXIST(windowRayfire)
|
|
IF GET_STATE_OF_RAYFIRE_MAP_OBJECT(windowRayfire) = RFMO_STATE_START
|
|
SET_STATE_OF_RAYFIRE_MAP_OBJECT(windowRayfire, RFMO_STATE_PRIMING)
|
|
iWindowSmashStage++
|
|
ENDIF
|
|
ELSE
|
|
iWindowSmashStage = 0
|
|
ENDIF
|
|
BREAK
|
|
|
|
CASE 2
|
|
IF DOES_RAYFIRE_MAP_OBJECT_EXIST(windowRayfire)
|
|
RAY_FIRE_MAP_OBJECT_STATE rayfireState
|
|
rayfireState = GET_STATE_OF_RAYFIRE_MAP_OBJECT(windowRayfire)
|
|
IF rayfireState = RFMO_STATE_PRIMED
|
|
IF bDoSmashWhenPrimed
|
|
IF NOT bSkipStraightToEnd
|
|
SET_STATE_OF_RAYFIRE_MAP_OBJECT(windowRayfire, RFMO_STATE_START_ANIM)
|
|
//PLAY_SOUND_FROM_COORD(iSmashSoundID, "FBI_02_SNATCH_AND_GRAB_SMASH_WINDOW", GET_SNATCH_AND_GRAB_VECTOR(SAGVEC_WINDOW_SOUND))
|
|
iWindowSmashStage++
|
|
ELSE
|
|
SET_STATE_OF_RAYFIRE_MAP_OBJECT(windowRayfire, RFMO_STATE_ENDING)
|
|
iWindowSmashStage++
|
|
ENDIF
|
|
ENDIF
|
|
ELIF rayfireState <> RFMO_STATE_PRIMING
|
|
iWindowSmashStage = 0
|
|
ENDIF
|
|
ELSE
|
|
iWindowSmashStage = 0
|
|
ENDIF
|
|
BREAK
|
|
ENDSWITCH
|
|
ENDPROC
|
|
|
|
// interp between 2 vals
|
|
PROC INTERP_VALUE_TO_VALUE(FLOAT &fValue, FLOAT &fSpeed, FLOAT fStart, FLOAT fTarget, FLOAT fAcceleration)
|
|
FLOAT fMidpoint = (fStart + fTarget) / 2
|
|
|
|
IF fTarget > fStart
|
|
// speed
|
|
IF fValue < fMidpoint
|
|
fSpeed = fSpeed +@ fAcceleration
|
|
ELSE
|
|
fSpeed = fSpeed -@ fAcceleration
|
|
ENDIF
|
|
|
|
IF fSpeed < 0
|
|
fSpeed = 0
|
|
ENDIF
|
|
|
|
// increment value
|
|
fValue = fValue +@ fSpeed
|
|
IF fValue > fTarget
|
|
fValue = fTarget
|
|
ENDIF
|
|
ELSE
|
|
// speed
|
|
IF fValue > fMidpoint
|
|
fSpeed = fSpeed -@ fAcceleration
|
|
ELSE
|
|
fSpeed = fSpeed +@ fAcceleration
|
|
ENDIF
|
|
|
|
IF fSpeed > 0
|
|
fSpeed = 0
|
|
ENDIF
|
|
|
|
// increment value
|
|
fValue = fValue +@ fSpeed
|
|
IF fValue < fTarget
|
|
fValue = fTarget
|
|
ENDIF
|
|
ENDIF
|
|
ENDPROC
|
|
|
|
// create the rappel rope
|
|
PROC CREATE_CHOPPER_ROPE(ROPE_TYPE_ENUM ropeType, MISSION_STAGE_ENUM createStage = STAGE_GET_TO_CHOPPER)
|
|
IF IS_VEHICLE_DRIVEABLE(snatchAndGrabVehicle[SAGV_PLAYER_CHOPPER])
|
|
SWITCH ropeType
|
|
CASE ROPE_TYPE_FURLED
|
|
rappelData.rope = ADD_ROPE(GET_ENTITY_COORDS(rappelData.anchorObject), <<0.0, 90.0, 0.0>>, 40.0, PHYSICS_ROPE_THIN_WIRE_32, 0.5, 0.5, 1.2, FALSE, FALSE, TRUE, 50)
|
|
ATTACH_ROPE_TO_ENTITY(rappelData.rope, snatchAndGrabVehicle[SAGV_PLAYER_CHOPPER], GET_OFFSET_FROM_ENTITY_IN_WORLD_COORDS(snatchAndGrabVehicle[SAGV_PLAYER_CHOPPER], GET_SNATCH_AND_GRAB_VECTOR(SAGVEC_ROPE_ANCHOR_OFFSET)),0)
|
|
START_ROPE_UNWINDING_FRONT(rappelData.rope)
|
|
BREAK
|
|
|
|
CASE ROPE_TYPE_CUTSCENE
|
|
rappelData.rope = ADD_ROPE(<< 111.136, -617.365, 271.284 >>, <<0.0, 90.0, 0.0>>, 20.0, PHYSICS_ROPE_THIN_WIRE_32, -1, 0.5, 1.2, FALSE, FALSE, TRUE, 2)
|
|
|
|
//PIN_ROPE_VERTEX(rappelData.rope, i,
|
|
//ATTACH_ROPE_TO_ENTITY(rappelData.rope, snatchAndGrabVehicle[SAGV_PLAYER_CHOPPER], GET_OFFSET_FROM_ENTITY_IN_WORLD_COORDS(snatchAndGrabVehicle[SAGV_PLAYER_CHOPPER], GET_SNATCH_AND_GRAB_VECTOR(SAGVEC_ROPE_ANCHOR_OFFSET)),0)
|
|
BREAK
|
|
|
|
CASE ROPE_TYPE_RAPPELLING
|
|
CREATE_RAPPEL_ROPE(rappelData, RAPPEL_ROPE_LENGTH_LONG, TRUE, TRUE, DEFAULT_ROPE_WEIGHT, 60.7)//52.7)
|
|
BREAK
|
|
|
|
CASE ROPE_TYPE_INSIDE
|
|
CASE ROPE_TYPE_SWINGING
|
|
FLOAT fLength
|
|
FLOAT fModLength
|
|
FLOAT fMinLength
|
|
FLOAT fWeight
|
|
FLOAT fLengthChangeRate
|
|
//FLOAT fSegmentLength
|
|
IF createStage <> STAGE_DROPOFF
|
|
fLength = RAPPEL_ROPE_LENGTH_DANGLING
|
|
fModLength = RAPPEL_ROPE_LENGTH_DANGLING
|
|
IF NOT bShortRope
|
|
fLengthChangeRate = 2.0//1.0
|
|
fMinLength = 15.0
|
|
IF createStage < STAGE_SNIPE_GUARDS
|
|
fWeight = 1.0
|
|
ELSE
|
|
fWeight = 0.7 // 0.8
|
|
ENDIF
|
|
ELSE
|
|
fLengthChangeRate = 6.0
|
|
fMinLength = 1.3
|
|
fWeight = 15.0
|
|
ENDIF
|
|
ELSE
|
|
//fLength = RAPPEL_ROPE_LENGTH_WOUND
|
|
//fModLength = 16.6
|
|
fLength = RAPPEL_ROPE_LENGTH_DANGLING
|
|
fModLength = RAPPEL_ROPE_LENGTH_DANGLING
|
|
fLengthChangeRate = 10.0
|
|
fMinLength = 15.0
|
|
fWeight = 1.0
|
|
ENDIF
|
|
rappelData.rope = ADD_ROPE(GET_ENTITY_COORDS(rappelData.anchorObject), <<0.0, 90.0, 0.0>>, fModLength, PHYSICS_ROPE_THIN_WIRE_32, -1, fMinLength, fLengthChangeRate, FALSE, FALSE, TRUE, fWeight)
|
|
FILL_ROPE_PROPERTIES(rappelData, fLength)
|
|
//PRINTSTRING("segment length = ") PRINTFLOAT(rappelData.fRopeSegmentLength) printnl()
|
|
INT i
|
|
VECTOR vAnchorPos
|
|
vAnchorPos = GET_ENTITY_COORDS(rappelData.anchorObject)
|
|
REPEAT rappelData.iRopeVertexCount i
|
|
PIN_ROPE_VERTEX(rappelData.rope, i, <<vAnchorPos.x, vAnchorPos.y, vAnchorPos.z -(rappelData.fRopeSegmentLength * i)>>)
|
|
ENDREPEAT
|
|
rappelData.bAllowRopeMovement = TRUE
|
|
rappelData.bRopeCreated = TRUE
|
|
BREAK
|
|
|
|
CASE ROPE_TYPE_DROPOFF
|
|
// CREATE_RAPPEL_ROPE(rappelData, RAPPEL_ROPE_LENGTH_DROPOFF)
|
|
BREAK
|
|
ENDSWITCH
|
|
ENDIF
|
|
ENDPROC
|
|
|
|
// set the rope to dangling
|
|
PROC SET_ROPE_DANGLING(BOOL bForce = TRUE, BOOL bUnpin = TRUE)
|
|
INT i
|
|
IF bUnpin
|
|
REPEAT rappelData.iRopeVertexCount i
|
|
UNPIN_ROPE_VERTEX(rappelData.rope, i)
|
|
ENDREPEAT
|
|
ENDIF
|
|
|
|
VECTOR vCreateHarness = GET_ROPE_LAST_VERTEX_COORD(rappelData.rope) //- <<0,0,2>>
|
|
harnessObject = CREATE_OBJECT(GET_MODEL_FOR_SNATCH_AND_GRAB_MODEL_ENUM(SAGM_HARNESS), vCreateHarness)
|
|
|
|
//hookObject = CREATE_OBJECT(GET_MODEL_FOR_SNATCH_AND_GRAB_MODEL_ENUM(SAGM_HOOK), vCreateHarness)
|
|
SET_ENTITY_VISIBLE(harnessObject, FALSE)
|
|
SET_ENTITY_COLLISION(harnessObject, FALSE)
|
|
//ATTACH_ENTITY_TO_ENTITY(hookObject, harnessObject, 0, <<0,0,0.2>>, <<0,0,0>>)
|
|
ATTACH_MICHAEL_TO_ROPE(bForce)
|
|
ATTACH_PRISONER_TO_ROPE(bForce)
|
|
ENDPROC
|
|
|
|
// set rope physical
|
|
PROC SET_ROPE_PHYSICAL()
|
|
INT i
|
|
|
|
IF rappelData.bRopeCreated
|
|
REPEAT rappelData.iRopeVertexCount i
|
|
UNPIN_ROPE_VERTEX(rappelData.rope, i)
|
|
ENDREPEAT
|
|
|
|
IF IS_VEHICLE_DRIVEABLE(snatchAndGrabVehicle[SAGV_PLAYER_CHOPPER])
|
|
ATTACH_ROPE_TO_ENTITY(rappelData.rope, snatchAndGrabVehicle[SAGV_PLAYER_CHOPPER], GET_OFFSET_FROM_ENTITY_IN_WORLD_COORDS(snatchAndGrabVehicle[SAGV_PLAYER_CHOPPER], GET_SNATCH_AND_GRAB_VECTOR(SAGVEC_ROPE_ANCHOR_OFFSET)), 0)
|
|
// ROPE_CREATE_VIRTUAL_BOUND( rappelData.rope, snatchAndGrabVehicle[SAGV_PLAYER_CHOPPER], 2 )
|
|
//ROPE_ATTACH_VIRTUAL_BOUND_CAPSULE( rappelData.rope, 0.3, 7.5, 0, << -1.0, -0.2, -0.7 >> )
|
|
//ROPE_ATTACH_VIRTUAL_BOUND_CAPSULE( rappelData.rope, 1.3, 3.5, 1, << 0.0, -0.2, 0.0 >> )
|
|
ENDIF
|
|
bRopePhysical = TRUE
|
|
ENDIF
|
|
ENDPROC
|
|
|
|
CONST_FLOAT SHIFT_FLOAT_ACCEL 0.29
|
|
CONST_FLOAT SHIFT_FLOAT_SPEED_LIMIT 0.31
|
|
|
|
PROC SHIFT_FLOAT_TO_IDEAL_FLOAT(FLOAT &fCurrent, FLOAT fIdeal, FLOAT &fSpeed)
|
|
IF fCurrent < fIdeal
|
|
fSpeed = fSpeed +@ SHIFT_FLOAT_ACCEL
|
|
IF fSpeed > SHIFT_FLOAT_SPEED_LIMIT
|
|
fSpeed = SHIFT_FLOAT_SPEED_LIMIT
|
|
ENDIF
|
|
|
|
fCurrent = fCurrent +@ fSpeed
|
|
ELIF fCurrent > fIdeal
|
|
fSpeed = fSpeed -@ SHIFT_FLOAT_ACCEL
|
|
IF fSpeed < -SHIFT_FLOAT_SPEED_LIMIT
|
|
fSpeed = -SHIFT_FLOAT_SPEED_LIMIT
|
|
ENDIF
|
|
|
|
fCurrent = fCurrent +@ fSpeed
|
|
ENDIF
|
|
ENDPROC
|
|
|
|
PROC SHIFT_VECTOR_TO_IDEAL_VECTOR(VECTOR &vCurrent, VECTOR vIdeal)
|
|
SHIFT_FLOAT_TO_IDEAL_FLOAT(vCurrent.x, vIdeal.x, vShiftVectorSpeed.x)
|
|
SHIFT_FLOAT_TO_IDEAL_FLOAT(vCurrent.y, vIdeal.y, vShiftVectorSpeed.y)
|
|
SHIFT_FLOAT_TO_IDEAL_FLOAT(vCurrent.z, vIdeal.z, vShiftVectorSpeed.z)
|
|
ENDPROC
|
|
|
|
// get clip pos
|
|
FUNC VECTOR GET_MICHAEL_CLIP_POS()
|
|
PED_INDEX michaelPed = GET_MICHAEL_PED()
|
|
IF NOT IS_PED_INJURED(michaelPed)
|
|
PROCESS_ENTITY_ATTACHMENTS(michaelPed)
|
|
//SET_DEBUG_LINES_AND_SPHERES_DRAWING_ACTIVE(TRUE)
|
|
//DRAW_DEBUG_SPHERE( GET_PED_BONE_COORDS(michaelPed, INT_TO_ENUM(PED_BONETAG, 42114), <<0,0,0>>), 0.02, 0, 0, 255)
|
|
RETURN GET_PED_BONE_COORDS(michaelPed, INT_TO_ENUM(PED_BONETAG, 42114), <<0,0,0>>)
|
|
ENDIF
|
|
|
|
RETURN <<0,0,0>>
|
|
ENDFUNC
|
|
|
|
// proportion down the rope a vertex should be drawn
|
|
FUNC FLOAT GET_ROPE_PROPORTION_FOR_VERTEX(INT iVertex, MISSION_STAGE_ENUM thisStage)
|
|
SWITCH iVertex
|
|
CASE 0
|
|
RETURN 0.0
|
|
BREAK
|
|
CASE 1
|
|
RETURN 0.031465
|
|
BREAK
|
|
CASE 2
|
|
RETURN 0.062912
|
|
BREAK
|
|
CASE 3
|
|
RETURN 0.094346
|
|
BREAK
|
|
CASE 4
|
|
RETURN 0.125768
|
|
BREAK
|
|
CASE 5
|
|
RETURN 0.157177
|
|
BREAK
|
|
CASE 6
|
|
RETURN 0.188572
|
|
BREAK
|
|
CASE 7
|
|
RETURN 0.219954
|
|
BREAK
|
|
CASE 8
|
|
RETURN 0.251322
|
|
BREAK
|
|
CASE 9
|
|
RETURN 0.282676
|
|
BREAK
|
|
CASE 10
|
|
RETURN 0.314017
|
|
BREAK
|
|
CASE 11
|
|
RETURN 0.345343
|
|
BREAK
|
|
CASE 12
|
|
RETURN 0.376657
|
|
BREAK
|
|
CASE 13
|
|
RETURN 0.407956
|
|
BREAK
|
|
CASE 14
|
|
RETURN 0.439242
|
|
BREAK
|
|
CASE 15
|
|
RETURN 0.470513
|
|
BREAK
|
|
CASE 16
|
|
RETURN 0.501771
|
|
BREAK
|
|
CASE 17
|
|
RETURN 0.533015
|
|
BREAK
|
|
CASE 18
|
|
RETURN 0.564245
|
|
BREAK
|
|
CASE 19
|
|
RETURN 0.595462
|
|
BREAK
|
|
CASE 20
|
|
RETURN 0.626664
|
|
BREAK
|
|
CASE 21
|
|
RETURN 0.657853
|
|
BREAK
|
|
CASE 22
|
|
RETURN 0.689027
|
|
BREAK
|
|
CASE 23
|
|
RETURN 0.720188
|
|
BREAK
|
|
CASE 24
|
|
RETURN 0.751334
|
|
BREAK
|
|
CASE 25
|
|
RETURN 0.782467
|
|
BREAK
|
|
CASE 26
|
|
RETURN 0.813585
|
|
BREAK
|
|
CASE 27
|
|
RETURN 0.844690
|
|
BREAK
|
|
CASE 28
|
|
IF thisStage < STAGE_SNIPE_GUARDS
|
|
RETURN 0.875780
|
|
ELSE
|
|
RETURN 0.855780
|
|
ENDIF
|
|
BREAK
|
|
CASE 29
|
|
IF thisStage < STAGE_SNIPE_GUARDS
|
|
RETURN 0.906856
|
|
ELSE
|
|
RETURN 0.886856
|
|
ENDIF
|
|
BREAK
|
|
CASE 30
|
|
IF thisStage < STAGE_SNIPE_GUARDS
|
|
RETURN 0.937918
|
|
ELSE
|
|
RETURN 0.917918
|
|
ENDIF
|
|
BREAK
|
|
CASE 31
|
|
RETURN 0.968966
|
|
BREAK
|
|
CASE 32
|
|
RETURN 1.000
|
|
BREAK
|
|
ENDSWITCH
|
|
|
|
RETURN 0.0
|
|
ENDFUNC
|
|
|
|
// position for rope vertex
|
|
PROC DRAW_ROPE_TO_POINT(BOOL bToRopeEnd, VECTOR vRopeEndPos, BOOL bApplyAnchorModifierForCut = FALSE, BOOL bForceRopePin = FALSE, BOOL bUseChopperAsAnchor = FALSE)
|
|
//SET_DEBUG_LINES_AND_SPHERES_DRAWING_ACTIVE(TRUE)
|
|
IF rappelData.bRopeCreated
|
|
IF IS_VEHICLE_DRIVEABLE(snatchAndGrabVehicle[SAGV_PLAYER_CHOPPER])
|
|
PED_INDEX michaelPed = GET_MICHAEL_PED()
|
|
IF NOT IS_PED_INJURED(michaelPed)
|
|
INT i
|
|
|
|
VECTOR vClipPos
|
|
IF NOT bToRopeEnd
|
|
vClipPos = GET_MICHAEL_CLIP_POS()
|
|
ELSE
|
|
vClipPos = vRopeEndPos
|
|
ENDIF
|
|
|
|
VECTOR vWindowPos
|
|
IF currentMissionStage < STAGE_SNIPE_GUARDS
|
|
OR bForceRopePin
|
|
vWindowPos = GET_SNATCH_AND_GRAB_VECTOR(SAGVEC_WINDOW_FRAME)
|
|
ELSE
|
|
vWindowPos = GET_SNATCH_AND_GRAB_VECTOR(SAGVEC_WINDOW_FRAME_2)
|
|
ENDIF
|
|
VECTOR vAnchorPos = GET_ENTITY_COORDS(rappelData.anchorObject)
|
|
IF bUseChopperAsAnchor
|
|
vAnchorPos = GET_OFFSET_FROM_ENTITY_IN_WORLD_COORDS(snatchAndGrabVehicle[SAGV_PLAYER_CHOPPER], GET_SNATCH_AND_GRAB_VECTOR(SAGVEC_ROPE_ANCHOR_OFFSET))
|
|
ENDIF
|
|
|
|
IF bApplyAnchorModifierForCut
|
|
vAnchorPos += <<0,-1,0>>
|
|
ENDIF
|
|
|
|
VECTOR vClipToAnchor = vClipPos - vAnchorPos
|
|
VECTOR vWindowToAnchor = vWindowPos - vAnchorPos
|
|
|
|
INT iVerticesToWindow = rappelData.iRopeVertexCount-2
|
|
//INT iVerticesToClip = rappelData.iRopeVertexCount-1
|
|
|
|
VECTOR vModClipToAnchor
|
|
VECTOR vModWindowToAnchor = vWindowToAnchor / <<iVerticesToWindow, iVerticesToWindow, iVerticesToWindow>>
|
|
|
|
REPEAT rappelData.iRopeVertexCount i
|
|
IF i=0
|
|
PIN_ROPE_VERTEX(rappelData.rope, i, GET_OFFSET_FROM_ENTITY_IN_WORLD_COORDS(snatchAndGrabVehicle[SAGV_PLAYER_CHOPPER], GET_SNATCH_AND_GRAB_VECTOR(SAGVEC_ROPE_ANCHOR_OFFSET)))
|
|
ELIF i=rappelData.iRopeVertexCount-1
|
|
PIN_ROPE_VERTEX(rappelData.rope, i, vClipPos)
|
|
ELSE
|
|
VECTOR vPosToWindow
|
|
VECTOR vPosToClip
|
|
VECTOR vDistBetweenWindowAndClip
|
|
VECTOR vPhasedTransition
|
|
BOOL bSet = FALSE
|
|
|
|
// fully to window
|
|
IF fRopeTransitionPhase > 0.0
|
|
FLOAT fProportion
|
|
fProportion = GET_ROPE_PROPORTION_FOR_VERTEX(i, currentMissionStage)
|
|
vModClipToAnchor = vClipToAnchor * <<-fProportion, -fProportion, -fProportion>>
|
|
vPosToClip = <<vAnchorPos.x - vModClipToAnchor.x, vAnchorPos.y - vModClipToAnchor.y, vAnchorPos.z - vModClipToAnchor.z>>
|
|
|
|
IF fRopeTransitionPhase = 1.0
|
|
vPhasedTransition = vPosToClip
|
|
bSet = TRUE
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF fRopeTransitionPhase < 1.0
|
|
vPosToWindow = <<vAnchorPos.x + (vModWindowToAnchor.x * i), vAnchorPos.y + (vModWindowToAnchor.y * i), vAnchorPos.z + (vModWindowToAnchor.z * i)>>
|
|
IF fRopeTransitionPhase = 0.0
|
|
vPhasedTransition = vPosToWindow
|
|
bSet = TRUE
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF NOT bSet
|
|
vDistBetweenWindowAndClip = vPosToClip - vPosToWindow
|
|
vPhasedTransition = vPosToWindow + (vDistBetweenWindowAndClip * fRopeTransitionPhase)
|
|
ENDIF
|
|
|
|
IF currentMissionStage < STAGE_SNIPE_GUARDS
|
|
OR bForceRopePin
|
|
PIN_ROPE_VERTEX(rappelData.rope, i, vPhasedTransition)
|
|
ELSE
|
|
IF i < 31
|
|
IF prisonerGrabState < PRISONER_GRAB_STATE_EXTRACT
|
|
OR fRopeTransitionPhase < 0.3
|
|
PIN_ROPE_VERTEX(rappelData.rope, i, vPhasedTransition)
|
|
ELSE
|
|
UNPIN_ROPE_VERTEX(rappelData.rope, i)
|
|
ENDIF
|
|
ELIF i < 30
|
|
//UNPIN_ROPE_VERTEX(rappelData.rope, i)
|
|
ELSE
|
|
IF prisonerGrabState >= PRISONER_GRAB_STATE_EXTRACT
|
|
// UNPIN_ROPE_VERTEX(rappelData.rope, i)
|
|
ELSE
|
|
// PIN_ROPE_VERTEX(rappelData.rope, i, vPhasedTransition)
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
//DRAW_DEBUG_SPHERE(GET_ROPE_VERTEX_COORD(rappelData.rope, i), 0.05)
|
|
ENDREPEAT
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDPROC
|
|
|
|
// 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
|
|
|
|
// draw the rappel rope
|
|
PROC HANDLE_CHOPPER_ROPE(ROPE_TYPE_ENUM ropeType)
|
|
INT i
|
|
PED_INDEX michaelPed = GET_MICHAEL_PED()
|
|
|
|
SWITCH ropeType
|
|
CASE ROPE_TYPE_FURLED
|
|
|
|
BREAK
|
|
|
|
CASE ROPE_TYPE_RAPPELLING
|
|
HANDLE_RAPPEL_ROPE(rappelData)
|
|
BREAK
|
|
|
|
CASE ROPE_TYPE_INSIDE
|
|
DRAW_ROPE_TO_POINT(FALSE, <<0,0,0>>)
|
|
BREAK
|
|
|
|
CASE ROPE_TYPE_SWINGING
|
|
IF DOES_ENTITY_EXIST(harnessObject)
|
|
AND DOES_ROPE_EXIST(rappelData.rope)
|
|
VECTOR vRopeEndPos
|
|
vRopeEndPos = GET_ROPE_LAST_VERTEX_COORD(rappelData.rope)
|
|
|
|
// handle the rope if not physical
|
|
IF NOT bRopePhysical
|
|
IF bSwingingRight
|
|
SHIFT_VECTOR_TO_IDEAL_VECTOR(vRopeEndPos, GET_SNATCH_AND_GRAB_VECTOR(SAGVEC_WINDOW_SWING_RIGHT))
|
|
IF GET_DISTANCE_BETWEEN_COORDS(vRopeEndPos, GET_SNATCH_AND_GRAB_VECTOR(SAGVEC_WINDOW_SWING_RIGHT)) < 0.4
|
|
bSwingingRight = FALSE
|
|
ENDIF
|
|
ELSE
|
|
SHIFT_VECTOR_TO_IDEAL_VECTOR(vRopeEndPos, GET_SNATCH_AND_GRAB_VECTOR(SAGVEC_WINDOW_SWING_LEFT))
|
|
IF GET_DISTANCE_BETWEEN_COORDS(vRopeEndPos, GET_SNATCH_AND_GRAB_VECTOR(SAGVEC_WINDOW_SWING_LEFT)) < 0.4
|
|
bSwingingRight = TRUE
|
|
ENDIF
|
|
ENDIF
|
|
|
|
//Matt B test for 831987 - Adding a jolt when shooting. Needs to be gone through before implementing.
|
|
IF prisonerGrabState = PRISONER_GRAB_STATE_DANGLING
|
|
AND currentMissionStage = STAGE_SNIPE_GUARDS
|
|
IF GET_CURRENT_PLAYER_PED_ENUM() = CHAR_MICHAEL
|
|
IF IS_PED_SHOOTING(PLAYER_PED_ID())
|
|
AND GET_GAME_TIMER() >= iNextKickbackTime
|
|
AND NOT IS_SPECIAL_ABILITY_ACTIVE(PLAYER_ID())
|
|
//Calculate kickback direction
|
|
VECTOR vKickbackDir, vCamRot
|
|
vCamRot = GET_GAMEPLAY_CAM_ROT()
|
|
vKickBackDir = <<SIN(vCamRot.z), -COS(vCamRot.z), 0.0>>
|
|
vCurrentKickBackForce += vKickbackDir * <<1,1,1>>
|
|
iNextKickbackTime = GET_GAME_TIMER() + 100
|
|
ENDIF
|
|
ENDIF
|
|
|
|
CONST_FLOAT KICKBACK_FORCE_DEPLETE_SPEED 5.0//13.75
|
|
CONST_FLOAT KICKBACK_OFFSET_DEPLETE_SPEED 2.0
|
|
|
|
// reduce force
|
|
IF vCurrentKickBackForce.x > 0
|
|
vCurrentKickBackForce.x = vCurrentKickBackForce.x -@ KICKBACK_FORCE_DEPLETE_SPEED
|
|
IF vCurrentKickBackForce.x < 0
|
|
vCurrentKickBackForce.x = 0
|
|
ENDIF
|
|
ELIF vCurrentKickBackForce.x < 0
|
|
vCurrentKickBackForce.x = vCurrentKickBackForce.x +@ KICKBACK_FORCE_DEPLETE_SPEED
|
|
IF vCurrentKickBackForce.x > 0
|
|
vCurrentKickBackForce.x = 0
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF vCurrentKickBackForce.y > 0
|
|
vCurrentKickBackForce.y = vCurrentKickBackForce.y -@ KICKBACK_FORCE_DEPLETE_SPEED
|
|
IF vCurrentKickBackForce.y < 0
|
|
vCurrentKickBackForce.y = 0
|
|
ENDIF
|
|
ELIF vCurrentKickBackForce.y < 0
|
|
vCurrentKickBackForce.y = vCurrentKickBackForce.y +@ KICKBACK_FORCE_DEPLETE_SPEED
|
|
IF vCurrentKickBackForce.y > 0
|
|
vCurrentKickBackForce.y = 0
|
|
ENDIF
|
|
ENDIF
|
|
|
|
vCurrentKickBackForce.z = 0
|
|
|
|
//PRINTSTRING("kickback force = ") PRINTVECTOR(vCurrentKickBackForce) PRINTNL()
|
|
//PRINTSTRING("kickback offset = ") PRINTVECTOR(vCurrentKickBackOffset) PRINTNL()
|
|
|
|
vRopeEndPos.x = vRopeEndPos.x +@ vCurrentKickBackForce.x
|
|
vRopeEndPos.y = vRopeEndPos.y +@ vCurrentKickBackForce.y
|
|
ENDIF
|
|
|
|
DRAW_ROPE_TO_POINT(TRUE, vRopeEndPos)
|
|
ENDIF
|
|
|
|
|
|
IF NOT IS_PED_INJURED(michaelPed)
|
|
|
|
VECTOR vClipOffsetFromRoot
|
|
VECTOR vClipPos
|
|
vClipPos = GET_MICHAEL_CLIP_POS()
|
|
vClipOffsetFromRoot = GET_ENTITY_COORDS(michaelPed) - vClipPos
|
|
|
|
SET_ENTITY_COORDS_NO_OFFSET(harnessObject, vRopeEndPos + vClipOffsetFromRoot)
|
|
ENDIF
|
|
|
|
IF IS_VEHICLE_DRIVEABLE(snatchAndGrabVehicle[SAGV_PLAYER_CHOPPER])
|
|
SET_ENTITY_ROTATION(harnessObject, <<0,0,fRopeAttachHeading>>)
|
|
//printstring("heading = ") printfloat(fRopeAttachHeading) PRINTNL()
|
|
ENDIF
|
|
ENDIF
|
|
BREAK
|
|
|
|
CASE ROPE_TYPE_DROPOFF
|
|
IF rappelData.bRopeCreated
|
|
|
|
IF IS_VEHICLE_DRIVEABLE(snatchAndGrabVehicle[SAGV_PLAYER_CHOPPER])
|
|
PIN_ROPE_VERTEX(rappelData.rope, 0, GET_OFFSET_FROM_ENTITY_IN_WORLD_COORDS(snatchAndGrabVehicle[SAGV_PLAYER_CHOPPER], GET_SNATCH_AND_GRAB_VECTOR(SAGVEC_ROPE_ANCHOR_OFFSET)))
|
|
|
|
IF NOT rappelData.bAllowRopeMovement
|
|
FOR i=1 TO rappelData.iRopeVertexCount-2
|
|
UNPIN_ROPE_VERTEX(rappelData.rope, i)
|
|
ENDFOR
|
|
rappelData.bAllowRopeMovement = TRUE
|
|
ENDIF
|
|
|
|
IF NOT IS_PED_INJURED(michaelPed)
|
|
VECTOR vVelocity
|
|
VECTOR vRoot
|
|
vVelocity = GET_ENTITY_VELOCITY(snatchAndGrabVehicle[SAGV_PLAYER_CHOPPER]) * GET_FRAME_TIME()
|
|
vRoot = GET_PED_BONE_COORDS(michaelPed, BONETAG_ROOT, <<0,0,0>>) + vVelocity
|
|
PIN_ROPE_VERTEX(rappelData.rope, rappelData.iRopeVertexCount-1, vRoot)
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
BREAK
|
|
ENDSWITCH
|
|
ENDPROC
|
|
|
|
/*
|
|
// is a coord intersecting the rotor blades?
|
|
FUNC BOOL IS_COORD_INTERSECTING_ROTOR_BLADES(VECTOR vCoord, VEHICLE_INDEX chopperVehicle)
|
|
IF IS_VEHICLE_DRIVEABLE(chopperVehicle)
|
|
VECTOR vOffsetFromChopper = GET_OFFSET_FROM_ENTITY_GIVEN_WORLD_COORDS(chopperVehicle, vCoord)
|
|
|
|
BOOL bIntersectingBlades = TRUE
|
|
// check Z
|
|
IF vOffsetFromChopper.z >= 2.3//2.3
|
|
OR vOffsetFromChopper.z <= 1.7//1.7
|
|
bIntersectingBlades = FALSE
|
|
ENDIF
|
|
|
|
// check X
|
|
IF bIntersectingBlades
|
|
IF vOffsetFromChopper.x >= 4.3
|
|
OR vOffsetFromChopper.x <= -4.3
|
|
bIntersectingBlades = FALSE
|
|
ENDIF
|
|
ENDIF
|
|
|
|
// check Y
|
|
IF bIntersectingBlades
|
|
IF vOffsetFromChopper.y >= 4.3
|
|
OR vOffsetFromChopper.y <= -4.3
|
|
bIntersectingBlades = FALSE
|
|
ENDIF
|
|
ENDIF
|
|
|
|
RETURN bIntersectingBlades
|
|
ENDIF
|
|
|
|
RETURN FALSE
|
|
ENDFUNC
|
|
|
|
// check knockoff
|
|
PROC CHECK_KNOCKOFF_FOR_CHOPPER_ROTORS(VEHICLE_INDEX chopperVehicle)
|
|
IF IS_VEHICLE_DRIVEABLE(chopperVehicle)
|
|
PED_INDEX michaelPed = GET_MICHAEL_PED()
|
|
IF NOT IS_PED_INJURED(michaelPed)
|
|
// if player is intersecting rotors
|
|
IF IS_COORD_INTERSECTING_ROTOR_BLADES(GET_ENTITY_COORDS(michaelPed), chopperVehicle)
|
|
// DO_KNOCKOFF()
|
|
ENDIF
|
|
|
|
// if rope is intersecting rotors
|
|
INT i
|
|
FOR i=2 TO GET_ROPE_VERTEX_COUNT(rappelData.rope) - 1
|
|
IF IS_COORD_INTERSECTING_ROTOR_BLADES(GET_ROPE_VERTEX_COORD(rappelData.rope, i), chopperVehicle)
|
|
//PRINTSTRING("knocking off ") PRINTINT(i) PRINTNL()
|
|
//PRINTVECTOR(GET_ROPE_VERTEX_COORD(rappelData.rope, i)) PRINTNL()
|
|
//DO_KNOCKOFF(TRUE)
|
|
ENDIF
|
|
ENDFOR
|
|
|
|
//PRINTSTRING("offset = ") PRINTVECTOR(vOffsetFromChopper) PRINTNL()
|
|
//PRINTSTRING("rotorPos = ") PRINTVECTOR(GET_WORLD_POSITION_OF_ENTITY_BONE(snatchAndGrabVehicle[SAGV_PLAYER_CHOPPER], 7)) PRINTNL()
|
|
//PRINTSTRING("rootPos = ") PRINTVECTOR(GET_WORLD_POSITION_OF_ENTITY_BONE(snatchAndGrabVehicle[SAGV_PLAYER_CHOPPER], 0)) PRINTNL()
|
|
ENDIF
|
|
ENDIF
|
|
ENDPROC
|
|
*/
|
|
|
|
|
|
// move the last player vehicle if at coord
|
|
PROC CLEAR_INIT_POS(VECTOR vCheckPos)
|
|
CLEAR_AREA(vCheckPos, CLEAR_POS_RADIUS, TRUE)
|
|
ENDPROC
|
|
|
|
// give player the pistol for the mission
|
|
PROC GIVE_PLAYER_MISSION_PISTOL(BOOL bNPC = FALSE, BOOL bForceIntoHand = TRUE)
|
|
PED_INDEX pistolPed
|
|
IF NOT bNPC
|
|
pistolPed = PLAYER_PED_ID()
|
|
ELSE
|
|
pistolPed = sSelectorPeds.pedID[SELECTOR_PED_MICHAEL]
|
|
ENDIF
|
|
|
|
WEAPON_TYPE missionPistol = GET_SNATCH_AND_GRAB_WEAPON_TYPE(SAG_WEAPON_MICHAEL_PISTOL)
|
|
CONST_INT MISSION_AMMO 160
|
|
|
|
IF NOT IS_PED_INJURED(pistolPed)
|
|
IF NOT HAS_PED_GOT_WEAPON(pistolPed, missionPistol)
|
|
GIVE_WEAPON_TO_PED(pistolPed, missionPistol, MISSION_AMMO, bForceIntoHand)
|
|
ELSE
|
|
INT iAmmo = GET_AMMO_IN_PED_WEAPON(pistolPed, missionPistol)
|
|
IF iAmmo < MISSION_AMMO
|
|
ADD_AMMO_TO_PED(pistolPed, missionPistol, MISSION_AMMO - iAmmo)
|
|
ENDIF
|
|
SET_CURRENT_PED_WEAPON(pistolPed, missionPistol, bForceIntoHand)
|
|
ENDIF
|
|
ENDIF
|
|
ENDPROC
|
|
|
|
// set next random speech time
|
|
PROC SET_NEXT_RANDOM_SPEECH_TIME(INT iTime = -1)
|
|
IF iTime >= 0
|
|
// if supplied an argument, set it to that
|
|
iNextRandomSpeechTime = GET_GAME_TIMER() + iTime
|
|
ELSE
|
|
iNextRandomSpeechTime = GET_GAME_TIMER() + GET_RANDOM_INT_IN_RANGE(MIN_RANDOM_SPEECH_TIME, MAX_RANDOM_SPEECH_TIME)
|
|
ENDIF
|
|
ENDPROC
|
|
|
|
// handle random speech
|
|
PROC DO_RANDOM_SPEECH(STRING sSpeech, INT iNextTime = -1)
|
|
// 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)
|
|
SET_NEXT_RANDOM_SPEECH_TIME(iNextTime)
|
|
ENDIF
|
|
ENDIF
|
|
ENDPROC
|
|
|
|
/*
|
|
// position player at init pos for mission
|
|
PROC POSITION_PLAYER_AT_MISSION_INIT(BOOL bRepositionConveniently)
|
|
IF NOT IS_PED_INJURED(PLAYER_PED_ID())
|
|
|
|
IF NOT bRepositionConveniently
|
|
//SET_ENTITY_COORDS(PLAYER_PED_ID(), GET_SNATCH_AND_GRAB_VECTOR(SAGVEC_PLAYER_INIT))
|
|
//SET_ENTITY_HEADING(PLAYER_PED_ID(), PLAYER_INIT_ROT)
|
|
ELSE
|
|
CLEAR_PED_TASKS_IMMEDIATELY(PLAYER_PED_ID())
|
|
SET_ENTITY_COORDS(PLAYER_PED_ID(), GET_SNATCH_AND_GRAB_VECTOR(SAGVEC_PLAYER_INIT2))
|
|
SET_ENTITY_HEADING(PLAYER_PED_ID(), PLAYER_INIT_ROT2)
|
|
FORCE_PED_MOTION_STATE(PLAYER_PED_ID(), MS_ON_FOOT_IDLE, TRUE, FAUS_CUTSCENE_EXIT)
|
|
|
|
SET_GAMEPLAY_CAM_RELATIVE_HEADING()
|
|
ENDIF
|
|
|
|
ENDIF
|
|
ENDPROC
|
|
*/
|
|
|
|
// position dave at init pos
|
|
PROC POSITION_DAVE_AT_MISSION_INIT(BOOL bRepositionConveniently)
|
|
IF NOT IS_PED_INJURED(davePed)
|
|
CLEAR_PED_TASKS_IMMEDIATELY(davePed)
|
|
IF NOT bRepositionConveniently
|
|
SET_ENTITY_COORDS(davePed, GET_SNATCH_AND_GRAB_VECTOR(SAGVEC_DAVE_INIT))
|
|
SET_ENTITY_HEADING(davePed, DAVE_INIT_ROT)
|
|
ELSE
|
|
SET_ENTITY_COORDS(davePed, GET_SNATCH_AND_GRAB_VECTOR(SAGVEC_DAVE_INIT2))
|
|
SET_ENTITY_HEADING(davePed, DAVE_INIT_ROT2)
|
|
ENDIF
|
|
//FORCE_PED_MOTION_STATE(davePed, MS_ON_FOOT_IDLE, TRUE, FAUS_CUTSCENE_EXIT)
|
|
ENDIF
|
|
ENDPROC
|
|
|
|
// set steve seated
|
|
PROC SET_STEVE_SEATED(BOOL bPreCutscene)
|
|
IF NOT bSteveSeated
|
|
iSteveSyncScene = CREATE_SYNCHRONIZED_SCENE(<<148.31, -677.19, 41.02>>, <<0,0,0>>)
|
|
IF NOT IS_PED_INJURED(stevePed)
|
|
STRING sAnim
|
|
IF bPreCutscene
|
|
sAnim = "FBI_2_INT_LeadInOut_loop_Steve"
|
|
ELSE
|
|
sAnim = "FBI_2_INT_LeadOut_action_Steve"
|
|
ENDIF
|
|
|
|
TASK_SYNCHRONIZED_SCENE(stevePed, iSteveSyncScene, GET_SNATCH_AND_GRAB_ANIM_DICT_AS_STRING(SAG_ANIM_DICT_FOOD_COURT), sAnim, INSTANT_BLEND_IN, NORMAL_BLEND_OUT, SYNCED_SCENE_USE_PHYSICS | SYNCED_SCENE_DONT_INTERRUPT, steveRagdollBlocking)
|
|
|
|
IF bPreCutscene
|
|
SET_SYNCHRONIZED_SCENE_LOOPED(iSteveSyncScene, TRUE)
|
|
ELSE
|
|
SET_SYNCHRONIZED_SCENE_LOOPED(iSteveSyncScene, FALSE)
|
|
ENDIF
|
|
|
|
|
|
FORCE_PED_AI_AND_ANIMATION_UPDATE(stevePed)
|
|
ENDIF
|
|
|
|
bSteveSeated = TRUE
|
|
ENDIF
|
|
ENDPROC
|
|
|
|
// set andreas seated
|
|
PROC SET_ANDREAS_SEATED(BOOL bPreCutscene)
|
|
IF NOT bAndreasSeated
|
|
iAndreasSyncScene = CREATE_SYNCHRONIZED_SCENE(<<148.31, -677.19, 41.02>>, <<0,0,0>>)
|
|
|
|
IF NOT IS_PED_INJURED(andreasPed)
|
|
STRING sAnim
|
|
IF bPreCutscene
|
|
sAnim = "FBI_2_INT_LeadInOut_loop_Andreas"
|
|
ELSE
|
|
sAnim = "FBI_2_INT_LeadOut_action_Andreas"
|
|
ENDIF
|
|
|
|
TASK_SYNCHRONIZED_SCENE(andreasPed, iAndreasSyncScene, GET_SNATCH_AND_GRAB_ANIM_DICT_AS_STRING(SAG_ANIM_DICT_FOOD_COURT), sAnim, INSTANT_BLEND_IN, NORMAL_BLEND_OUT, SYNCED_SCENE_USE_PHYSICS | SYNCED_SCENE_DONT_INTERRUPT, steveRagdollBlocking)
|
|
|
|
IF bPreCutscene
|
|
SET_SYNCHRONIZED_SCENE_LOOPED(iAndreasSyncScene, TRUE)
|
|
ELSE
|
|
SET_SYNCHRONIZED_SCENE_LOOPED(iAndreasSyncScene, FALSE)
|
|
ENDIF
|
|
|
|
FORCE_PED_AI_AND_ANIMATION_UPDATE(andreasPed)
|
|
ENDIF
|
|
|
|
bAndreasSeated = TRUE
|
|
ENDIF
|
|
ENDPROC
|
|
|
|
// set andreas seated
|
|
PROC SET_DAVE_SEATED()
|
|
IF NOT bDaveSeated
|
|
iDaveSyncScene = CREATE_SYNCHRONIZED_SCENE(<<148.31, -677.19, 41.02>>, <<0,0,0>>)
|
|
|
|
IF NOT IS_PED_INJURED(davePed)
|
|
TASK_SYNCHRONIZED_SCENE(davePed, iDaveSyncScene, GET_SNATCH_AND_GRAB_ANIM_DICT_AS_STRING(SAG_ANIM_DICT_FOOD_COURT), "FBI_2_INT_LeadInOut_loop_DaveN", INSTANT_BLEND_IN, NORMAL_BLEND_OUT, SYNCED_SCENE_USE_PHYSICS | SYNCED_SCENE_DONT_INTERRUPT, steveRagdollBlocking)
|
|
SET_SYNCHRONIZED_SCENE_LOOPED(iDaveSyncScene, TRUE)
|
|
FORCE_PED_AI_AND_ANIMATION_UPDATE(davePed)
|
|
ENDIF
|
|
|
|
bDaveSeated = TRUE
|
|
ENDIF
|
|
ENDPROC
|
|
|
|
// set steve and andreas loop
|
|
PROC SET_STEVE_AND_ANDREAS_LOOP()
|
|
IF NOT bLoopSteveAndAndreas
|
|
iFoodCourtSyncScene = CREATE_SYNCHRONIZED_SCENE(<<148.31, -677.19, 41.02>>, <<0,0,0>>)
|
|
SET_SYNCHRONIZED_SCENE_LOOPED(iFoodCourtSyncScene, TRUE)
|
|
|
|
IF NOT IS_PED_INJURED(stevePed)
|
|
TASK_SYNCHRONIZED_SCENE(stevePed, iFoodCourtSyncScene, GET_SNATCH_AND_GRAB_ANIM_DICT_AS_STRING(SAG_ANIM_DICT_FOOD_COURT), "FBI_2_INT_LeadInOut_loop_steve", NORMAL_BLEND_IN, NORMAL_BLEND_OUT, SYNCED_SCENE_USE_PHYSICS | SYNCED_SCENE_DONT_INTERRUPT, steveRagdollBlocking)
|
|
ENDIF
|
|
|
|
IF NOT IS_PED_INJURED(andreasPed)
|
|
TASK_SYNCHRONIZED_SCENE(andreasPed, iFoodCourtSyncScene, GET_SNATCH_AND_GRAB_ANIM_DICT_AS_STRING(SAG_ANIM_DICT_FOOD_COURT), "FBI_2_INT_LeadInOut_loop_ANDREAS", REALLY_SLOW_BLEND_IN, NORMAL_BLEND_OUT, SYNCED_SCENE_USE_PHYSICS | SYNCED_SCENE_DONT_INTERRUPT, steveRagdollBlocking)
|
|
ENDIF
|
|
|
|
iLoopSteveAndAndreasTime = GET_GAME_TIMER()
|
|
bLoopSteveAndAndreas = TRUE
|
|
ENDIF
|
|
ENDPROC
|
|
|
|
// grab and freeze food court
|
|
PROC UPDATE_FOOD_COURT(BOOL bForCutscene, MISSION_STAGE_ENUM forStage)
|
|
VECTOR vActualPos
|
|
VECTOR vDesiredPos
|
|
VECTOR vDesiredRot
|
|
STRING sChairRegister
|
|
MODEL_NAMES chairModel
|
|
BOOL bRegister
|
|
BOOL bFreeze
|
|
INT i
|
|
|
|
REPEAT NUMBER_FOOD_COURT_CHAIRS i
|
|
BOOL bNewlyGrabbed = FALSE
|
|
|
|
SWITCH i
|
|
CASE 0
|
|
sChairRegister = "prop_chair_01a"
|
|
vActualPos = << 147.8187, -677.8579, 41.0298 >> // bottom
|
|
vDesiredPos = << 147.4805, -677.4504, 41.0238 >>
|
|
vDesiredRot = << 0, 0, 100.84 >>
|
|
bRegister = TRUE
|
|
bFreeze = TRUE
|
|
chairModel = prop_chair_01a
|
|
BREAK
|
|
CASE 1
|
|
sChairRegister = "prop_chair_01a^1"
|
|
vActualPos = << 149.2163, -677.5004, 41.0282 >> // right
|
|
vDesiredPos = << 149.0850, -676.7021, 41.0238 >>
|
|
vDesiredRot = << 0, 0, -62.4523 >>
|
|
bRegister = TRUE
|
|
IF forStage = STAGE_FOOD_COURT
|
|
bFreeze = TRUE
|
|
ELSE
|
|
bFreeze = FALSE
|
|
ENDIF
|
|
chairModel = prop_chair_01a
|
|
BREAK
|
|
CASE 2
|
|
sChairRegister = "prop_chair_01a^2"
|
|
vActualPos = << 148.6975, -676.0681, 41.0299 >> // top
|
|
vDesiredPos = << 147.8508, -676.3236, 41.0238 >>
|
|
vDesiredRot = << 0, 0, 36.0963 >>
|
|
bRegister = TRUE
|
|
bFreeze = TRUE
|
|
chairModel = prop_chair_01a
|
|
BREAK
|
|
CASE 3
|
|
sChairRegister = "prop_chair_01a^3"
|
|
vActualPos = << 147.4372, -676.6362, 41.0288 >> // left
|
|
vDesiredPos = << 148.673, -678.057, 41.0239 >>
|
|
vDesiredRot = << 0, 0, -138.767 >>
|
|
bRegister = TRUE
|
|
IF forStage = STAGE_FOOD_COURT
|
|
bFreeze = TRUE
|
|
ELSE
|
|
bFreeze = FALSE
|
|
ENDIF
|
|
chairModel = prop_chair_01a
|
|
BREAK
|
|
CASE 4
|
|
vActualPos = << 148.3025, -677.1946, 41.0219 >>
|
|
vDesiredPos = << 148.305, -677.189, 41.0206 >>
|
|
vDesiredRot = << 0, 0, -60.1606 >>
|
|
bRegister = FALSE
|
|
bFreeze = TRUE
|
|
chairModel = prop_table_07
|
|
BREAK
|
|
CASE 5
|
|
vActualPos = << 149.2603, -675.4150, 41.0215 >>
|
|
vDesiredPos = << 149.2603, -675.4150, 41.0215 >>
|
|
vDesiredRot = << 0, 0, 30.87 >>
|
|
bRegister = FALSE
|
|
bFreeze = TRUE
|
|
chairModel = prop_parasol_01
|
|
BREAK
|
|
CASE 6
|
|
vActualPos = << 143.2394, -678.7330, 41.0230 >>
|
|
vDesiredPos = << 143.2394, -678.7330, 41.0230 >>
|
|
vDesiredRot = << 0, 0, -72.56 >>
|
|
bRegister = FALSE
|
|
bFreeze = TRUE
|
|
chairModel = prop_parasol_01
|
|
BREAK
|
|
ENDSWITCH
|
|
|
|
IF NOT DOES_ENTITY_EXIST(foodCourtChairObject[i])
|
|
foodCourtChairObject[i] = GET_CLOSEST_OBJECT_OF_TYPE(vActualPos, 0.3, chairModel)
|
|
bNewlyGrabbed = TRUE
|
|
ENDIF
|
|
|
|
IF DOES_ENTITY_EXIST(foodCourtChairObject[i])
|
|
//printstring("got food court ") printint(i) printnl()
|
|
IF bForCutscene
|
|
IF bRegister
|
|
FREEZE_ENTITY_POSITION(foodCourtChairObject[i], FALSE)
|
|
REGISTER_ENTITY_FOR_CUTSCENE(foodCourtChairObject[i], sChairRegister, CU_ANIMATE_EXISTING_SCRIPT_ENTITY, chairModel)
|
|
ENDIF
|
|
ELSE
|
|
IF bNewlyGrabbed
|
|
SET_ENTITY_COORDS(foodCourtChairObject[i], vDesiredPos)
|
|
SET_ENTITY_ROTATION(foodCourtChairObject[i], vDesiredRot)
|
|
IF bFreeze
|
|
FREEZE_ENTITY_POSITION(foodCourtChairObject[i], TRUE)
|
|
ELSE
|
|
FREEZE_ENTITY_POSITION(foodCourtChairObject[i], FALSE)
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDREPEAT
|
|
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_FOOD_COURT
|
|
CASE STAGE_GET_TO_CHOPPER
|
|
CASE STAGE_GET_TO_BUILDING
|
|
CASE STAGE_RAPPEL_DOWN
|
|
CASE STAGE_SNIPE_GUARDS
|
|
CASE STAGE_CHOPPER_CHASE
|
|
CASE STAGE_DROPOFF
|
|
RETURN TRUE
|
|
BREAK
|
|
ENDSWITCH
|
|
|
|
RETURN FALSE
|
|
ENDFUNC
|
|
|
|
// clear the start area
|
|
PROC CLEAR_START_AREA()
|
|
// clear init areas
|
|
CLEAR_INIT_POS(GET_SNATCH_AND_GRAB_VECTOR(SAGVEC_PLAYER_INIT))
|
|
CLEAR_INIT_POS(GET_SNATCH_AND_GRAB_VECTOR(SAGVEC_DAVE_INIT))
|
|
CLEAR_INIT_POS(GET_SNATCH_AND_GRAB_VECTOR(SAGVEC_MICHAEL_CAR_INIT))
|
|
//CLEAR_INIT_POS(<<86.03587, -665.29846, 44.30413>>)
|
|
CLEAR_AREA(<<86.04990, -665.26123, 43.10414>>, 5, TRUE)
|
|
//WAIT(0)
|
|
ENDPROC
|
|
|
|
/*
|
|
// michael into car
|
|
PROC SET_MICHAEL_INTO_CAR()
|
|
IF NOT bForceIntoCar
|
|
IF IS_VEHICLE_DRIVEABLE(snatchAndGrabVehicle[SAGV_MICHAEL_CAR])
|
|
AND NOT IS_PED_INJURED(PLAYER_PED_ID())
|
|
TASK_ENTER_VEHICLE(PLAYER_PED_ID(), snatchAndGrabVehicle[SAGV_MICHAEL_CAR], DEFAULT_TIME_BEFORE_WARP, VS_DRIVER, PEDMOVEBLENDRATIO_WALK)
|
|
bForceIntoCar = TRUE
|
|
ENDIF
|
|
ENDIF
|
|
ENDPROC
|
|
*/
|
|
|
|
// force chopper up
|
|
PROC FORCE_CHOPPER_UP()
|
|
// force chopper up
|
|
IF bDoForceHeliUpwards
|
|
IF GET_GAME_TIMER() >= iForceHeliUpwardsTime + 1300
|
|
bDoForceHeliUpwards = FALSE
|
|
ELSE
|
|
IF IS_VEHICLE_DRIVEABLE(snatchAndGrabVehicle[SAGV_PLAYER_CHOPPER])
|
|
APPLY_FORCE_TO_ENTITY(snatchAndGrabVehicle[SAGV_PLAYER_CHOPPER], APPLY_TYPE_EXTERNAL_FORCE, <<0,0,1>>, <<0,1,0>>, 0, TRUE, TRUE, TRUE)
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDPROC
|
|
|
|
|
|
// setup the rifle
|
|
PROC SETUP_SNIPER_RIFLE(BOOL bTweakAim, BOOL bMoveOut)
|
|
PED_INDEX franklinPed = GET_FRANKLIN_PED()
|
|
IF NOT IS_PED_INJURED(franklinPed)
|
|
SET_CURRENT_PED_WEAPON(franklinPed, GET_SNATCH_AND_GRAB_WEAPON_TYPE(SAG_WEAPON_SNIPER_RIFLE), TRUE)
|
|
PRINTSTRING("setting rifle as current from CUTSCENE SWITCH!") PRINTNL()
|
|
ENDIF
|
|
|
|
IF NOT bMoveOut
|
|
SET_FIRST_PERSON_AIM_CAM_ZOOM_FACTOR(INIT_SNIPER_ZOOM)
|
|
SET_GAMEPLAY_CAM_RELATIVE_PITCH(-2.7)
|
|
|
|
IF bTweakAim
|
|
SET_GAMEPLAY_CAM_RELATIVE_HEADING(0.3)
|
|
ELSE
|
|
SET_GAMEPLAY_CAM_RELATIVE_HEADING(0.0)
|
|
ENDIF
|
|
ELSE
|
|
SET_FIRST_PERSON_AIM_CAM_ZOOM_FACTOR(1.0)
|
|
SET_GAMEPLAY_CAM_RELATIVE_PITCH(4.0)
|
|
SET_GAMEPLAY_CAM_RELATIVE_HEADING(0.0)
|
|
ENDIF
|
|
ENDPROC
|
|
|
|
// mr k agitated
|
|
PROC DO_MR_K_AGITATED_ANIM()
|
|
IF NOT IS_PED_INJURED(prisonerPed)
|
|
TASK_PLAY_ANIM(prisonerPed, GET_SNATCH_AND_GRAB_ANIM_DICT_AS_STRING(SAG_ANIM_DICT_FLY_HOME), "mrk_in_chopper", INSTANT_BLEND_IN, NORMAL_BLEND_OUT, -1, AF_LOOPING)
|
|
ENDIF
|
|
ENDPROC
|
|
|
|
// set mike custom driveby in chopper
|
|
PROC SET_MICHAEL_CUSTOM_DRIVEBY_IN_CHOPPER()
|
|
PED_INDEX michaelPed = GET_MICHAEL_PED()
|
|
IF NOT IS_PED_INJURED(michaelPed)
|
|
AND IS_VEHICLE_DRIVEABLE(snatchAndGrabVehicle[SAGV_PLAYER_CHOPPER])
|
|
SET_PED_INTO_VEHICLE(michaelPed, snatchAndGrabVehicle[SAGV_PLAYER_CHOPPER], VS_BACK_LEFT)
|
|
SET_PED_IN_VEHICLE_CONTEXT(michaelPed, GET_HASH_KEY("MISSFBI2_MICHAEL_DRIVEBY"))
|
|
SET_PED_DRIVE_BY_CLIPSET_OVERRIDE(michaelPed, "clipset@missfbi2_driveby")
|
|
ENDIF
|
|
ENDPROC
|
|
|
|
CONST_FLOAT START_CAM_CHANGE_Z 40.0
|
|
CONST_FLOAT END_CAM_CHANGE_Z 50.0
|
|
|
|
// custom rappel cam
|
|
PROC APPLY_CUSTOM_RAPPEL_CAM()
|
|
// calculate the properties for the cam
|
|
// distance down
|
|
|
|
FLOAT fDistanceDown = (rappelData.vAttachPos.z * -1) - START_RAPPEL_Z
|
|
|
|
/*
|
|
IF fDistanceDown < START_CAM_CHANGE_Z
|
|
fPhaseDown = 0.0
|
|
ELSE
|
|
fPhaseDown = ((fDistanceDown - START_CAM_CHANGE_Z) / (END_CAM_CHANGE_Z - START_CAM_CHANGE_Z))
|
|
ENDIF
|
|
|
|
//PRINTSTRING("phasedown = ") PRINTFLOAT(fPhaseDown) PRINTNL()
|
|
//PRINTSTRING("distancedown = ") PRINTFLOAT(fDistanceDown) PRINTNL()
|
|
|
|
IF fPhaseDown < 0
|
|
fPhaseDown = 0
|
|
ELIF fPhaseDown > 1
|
|
fPhaseDown = 1
|
|
ENDIF
|
|
|
|
*/
|
|
|
|
IF fDistanceDown >= 45.0
|
|
IF fRappelCamTransitionPhase < 0.7
|
|
fRappelCamTransitionPhaseSpeed = fRappelCamTransitionPhaseSpeed +@ 0.07
|
|
IF fRappelCamTransitionPhaseSpeed > 0.14
|
|
fRappelCamTransitionPhaseSpeed = 0.14
|
|
ENDIF
|
|
ELSE
|
|
fRappelCamTransitionPhaseSpeed = fRappelCamTransitionPhaseSpeed -@ 0.038
|
|
IF fRappelCamTransitionPhaseSpeed < 0
|
|
fRappelCamTransitionPhaseSpeed = 0
|
|
ENDIF
|
|
ENDIF
|
|
|
|
fRappelCamTransitionPhase = fRappelCamTransitionPhase +@ fRappelCamTransitionPhaseSpeed
|
|
ENDIF
|
|
|
|
IF fRappelCamTransitionPhase < 0
|
|
fRappelCamTransitionPhase = 0
|
|
ELIF fRappelCamTransitionPhase > 1
|
|
fRappelCamTransitionPhase = 1
|
|
ENDIF
|
|
|
|
CONST_FLOAT RAPPEL_CAM_Z_SPEED 2.0
|
|
CONST_FLOAT RAPPEL_CAM_Z_INPUT_TO_HEIGHT_FACTOR 0.02
|
|
|
|
FLOAT fRappelCamDefaultHeading
|
|
FLOAT fRappelCamYDist
|
|
FLOAT fRappelCamZDist
|
|
FLOAT fRappelCamClockwiseLimit
|
|
FLOAT fRappelCamAnticlockwiseLimit
|
|
|
|
#IF IS_DEBUG_BUILD
|
|
IF NOT bDebugUseAlternateRappelCam
|
|
#ENDIF
|
|
CONST_FLOAT ALT_RAPPEL_CAM_DEFAULT_HEADING_TOP -83.0
|
|
CONST_FLOAT ALT_RAPPEL_CAM_Y_DIST_TOP -4.5//-3.5//-4.5
|
|
CONST_FLOAT ALT_RAPPEL_CAM_Z_DIST_TOP 2.8
|
|
CONST_FLOAT ALT_RAPPEL_CAM_CLOCKWISE_LIMIT_TOP 10.0
|
|
CONST_FLOAT ALT_RAPPEL_CAM_ANTICLOCKWISE_LIMIT_TOP 170.0
|
|
|
|
CONST_FLOAT ALT_RAPPEL_CAM_DEFAULT_HEADING_BOTTOM -18.0//-75.0
|
|
CONST_FLOAT ALT_RAPPEL_CAM_Y_DIST_BOTTOM -4.0//-4.0//-4.5
|
|
CONST_FLOAT ALT_RAPPEL_CAM_Z_DIST_BOTTOM 2.0//1.0
|
|
CONST_FLOAT ALT_RAPPEL_CAM_CLOCKWISE_LIMIT_BOTTOM 60.0
|
|
CONST_FLOAT ALT_RAPPEL_CAM_ANTICLOCKWISE_LIMIT_BOTTOM 90.0
|
|
|
|
fRappelCamDefaultHeading = ALT_RAPPEL_CAM_DEFAULT_HEADING_TOP + ((ALT_RAPPEL_CAM_DEFAULT_HEADING_BOTTOM - ALT_RAPPEL_CAM_DEFAULT_HEADING_TOP) * fRappelCamTransitionPhase)
|
|
fRappelCamYDist = ALT_RAPPEL_CAM_Y_DIST_TOP + ((ALT_RAPPEL_CAM_Y_DIST_BOTTOM - ALT_RAPPEL_CAM_Y_DIST_TOP) * fRappelCamTransitionPhase)
|
|
fRappelCamZDist = ALT_RAPPEL_CAM_Z_DIST_TOP + ((ALT_RAPPEL_CAM_Z_DIST_BOTTOM - ALT_RAPPEL_CAM_Z_DIST_TOP) * fRappelCamTransitionPhase)
|
|
fRappelCamClockwiseLimit = ALT_RAPPEL_CAM_CLOCKWISE_LIMIT_TOP + ((ALT_RAPPEL_CAM_CLOCKWISE_LIMIT_BOTTOM - ALT_RAPPEL_CAM_CLOCKWISE_LIMIT_TOP) * fRappelCamTransitionPhase)
|
|
fRappelCamAnticlockwiseLimit = ALT_RAPPEL_CAM_ANTICLOCKWISE_LIMIT_TOP + ((ALT_RAPPEL_CAM_ANTICLOCKWISE_LIMIT_BOTTOM - ALT_RAPPEL_CAM_ANTICLOCKWISE_LIMIT_TOP) * fRappelCamTransitionPhase)
|
|
|
|
//POINT_CAM_AT_PED_BONE(rappelData.cam, PLAYER_PED_ID(), BONETAG_HEAD, <<0,0.0,0.0>>)
|
|
#IF IS_DEBUG_BUILD
|
|
ELSE
|
|
CONST_FLOAT RAPPEL_CAM_DEFAULT_HEADING_TOP 78.0
|
|
CONST_FLOAT RAPPEL_CAM_Y_DIST_TOP -4.5//-3.5
|
|
CONST_FLOAT RAPPEL_CAM_Z_DIST_TOP 1.7
|
|
|
|
CONST_FLOAT RAPPEL_CAM_DEFAULT_HEADING_BOTTOM 68.0
|
|
CONST_FLOAT RAPPEL_CAM_Y_DIST_BOTTOM -4.5//-3.5
|
|
CONST_FLOAT RAPPEL_CAM_Z_DIST_BOTTOM 1.0
|
|
|
|
fRappelCamClockwiseLimit = 150.0
|
|
fRappelCamAnticlockwiseLimit = 20.0
|
|
|
|
fRappelCamDefaultHeading = RAPPEL_CAM_DEFAULT_HEADING_TOP + ((RAPPEL_CAM_DEFAULT_HEADING_BOTTOM - RAPPEL_CAM_DEFAULT_HEADING_TOP) * fRappelCamTransitionPhase)
|
|
fRappelCamYDist = RAPPEL_CAM_Y_DIST_TOP + ((RAPPEL_CAM_Y_DIST_BOTTOM - RAPPEL_CAM_Y_DIST_TOP) * fRappelCamTransitionPhase)
|
|
fRappelCamZDist = RAPPEL_CAM_Z_DIST_TOP + ((RAPPEL_CAM_Z_DIST_BOTTOM - RAPPEL_CAM_Z_DIST_TOP) * fRappelCamTransitionPhase)
|
|
|
|
//POINT_CAM_AT_ENTITY(rappelData.cam, PLAYER_PED_ID(), <<0,-0.3,0.6>>)
|
|
ENDIF
|
|
#ENDIF
|
|
|
|
DEFINE_RAPPEL_CAM_PROPERTIES(rappelData, fRappelCamDefaultHeading, fRappelCamYDist, RAPPEL_CAM_X_Y_INPUT_TO_DEGREES_FACTOR, fRappelCamClockwiseLimit, fRappelCamAnticlockwiseLimit, RAPPEL_CAM_X_Y_SPEED, fRappelCamZDist, RAPPEL_CAM_Z_INPUT_TO_HEIGHT_FACTOR, RAPPEL_CAM_Z_UPPER_LIMIT, RAPPEL_CAM_Z_LOWER_LIMIT, RAPPEL_CAM_Z_SPEED, RAPPEL_CAM_FOV)
|
|
ENDPROC
|
|
|
|
|
|
// init guard animation times
|
|
PROC INIT_GUARD_ANIMATION_TIME(INT i)
|
|
iNextGuardAnimationTime[i] = GET_GAME_TIMER() + GET_RANDOM_INT_IN_RANGE(300, 3000)
|
|
ENDPROC
|
|
|
|
PROC INIT_ALL_GUARD_ANIMATION_TIMES()
|
|
INT i
|
|
REPEAT NUMBER_GUARDS i
|
|
INIT_GUARD_ANIMATION_TIME(i)
|
|
ENDREPEAT
|
|
ENDPROC
|
|
|
|
// can guard look left?
|
|
FUNC BOOL CAN_GUARD_LOOK_LEFT(INT i)
|
|
SWITCH i
|
|
CASE 0
|
|
IF NOT IS_PED_INJURED(guardPed[4])
|
|
OR NOT IS_PED_INJURED(guardPed[1])
|
|
OR NOT IS_PED_INJURED(guardPed[2])
|
|
OR NOT IS_PED_INJURED(guardPed[3])
|
|
RETURN TRUE
|
|
ENDIF
|
|
BREAK
|
|
CASE 1
|
|
IF NOT IS_PED_INJURED(guardPed[2])
|
|
OR NOT IS_PED_INJURED(guardPed[3])
|
|
RETURN TRUE
|
|
ENDIF
|
|
BREAK
|
|
CASE 2
|
|
IF NOT IS_PED_INJURED(guardPed[3])
|
|
RETURN TRUE
|
|
ENDIF
|
|
BREAK
|
|
CASE 3
|
|
BREAK
|
|
CASE 4
|
|
IF NOT IS_PED_INJURED(guardPed[1])
|
|
OR NOT IS_PED_INJURED(guardPed[2])
|
|
OR NOT IS_PED_INJURED(guardPed[3])
|
|
RETURN TRUE
|
|
ENDIF
|
|
BREAK
|
|
ENDSWITCH
|
|
|
|
RETURN FALSE
|
|
ENDFUNC
|
|
|
|
// can guard look right?
|
|
FUNC BOOL CAN_GUARD_LOOK_RIGHT(INT i)
|
|
SWITCH i
|
|
CASE 0
|
|
BREAK
|
|
CASE 1
|
|
IF NOT IS_PED_INJURED(guardPed[0])
|
|
RETURN TRUE
|
|
ENDIF
|
|
BREAK
|
|
CASE 2
|
|
IF NOT IS_PED_INJURED(guardPed[1])
|
|
OR NOT IS_PED_INJURED(guardPed[4])
|
|
OR NOT IS_PED_INJURED(guardPed[0])
|
|
RETURN TRUE
|
|
ENDIF
|
|
BREAK
|
|
CASE 3
|
|
IF NOT IS_PED_INJURED(guardPed[4])
|
|
OR NOT IS_PED_INJURED(guardPed[1])
|
|
OR NOT IS_PED_INJURED(guardPed[2])
|
|
OR NOT IS_PED_INJURED(guardPed[0])
|
|
RETURN TRUE
|
|
ENDIF
|
|
BREAK
|
|
CASE 4
|
|
IF NOT IS_PED_INJURED(guardPed[0])
|
|
RETURN TRUE
|
|
ENDIF
|
|
BREAK
|
|
ENDSWITCH
|
|
|
|
RETURN FALSE
|
|
ENDFUNC
|
|
|
|
// handle guard animations
|
|
PROC HANDLE_GUARD_ANIMATIONS(INT iKilledGuards)
|
|
INT i
|
|
REPEAT NUMBER_GUARDS i
|
|
IF NOT IS_PED_INJURED(guardPed[i])
|
|
IF GET_SCRIPT_TASK_STATUS(guardPed[i], SCRIPT_TASK_AIM_GUN_AT_ENTITY) = PERFORMING_TASK
|
|
OR GET_SCRIPT_TASK_STATUS(guardPed[i], SCRIPT_TASK_AIM_GUN_AT_COORD) = PERFORMING_TASK
|
|
BOOL bDoAnim = FALSE
|
|
INT iAnim
|
|
INT iDict
|
|
STRING sAnim
|
|
STRING sDict
|
|
|
|
INT iNextMinTime = 3000
|
|
INT iNextMaxTime = 6000
|
|
|
|
IF NOT bReactedToFirstShot
|
|
IF GET_GAME_TIMER() >= iNextGuardAnimationTime[i]
|
|
iAnim = GET_RANDOM_INT_IN_RANGE(0,5)
|
|
sAnim = "var_a"
|
|
sDict = GET_SNATCH_AND_GRAB_ANIM_DICT_AS_STRING(SAG_ANIM_DICT_AIM_VARIATIONS)
|
|
|
|
// variations of aim adjustment
|
|
SWITCH i
|
|
CASE 0
|
|
CASE 4
|
|
IF iAnim = 2
|
|
iAnim = 3
|
|
ENDIF
|
|
BREAK
|
|
CASE 2
|
|
CASE 3
|
|
IF iAnim = 3
|
|
iAnim = 2
|
|
ENDIF
|
|
BREAK
|
|
ENDSWITCH
|
|
|
|
SWITCH iAnim
|
|
CASE 0
|
|
sAnim = "var_a"
|
|
BREAK
|
|
CASE 1
|
|
sAnim = "var_b"
|
|
BREAK
|
|
CASE 2
|
|
sAnim = "var_d"
|
|
BREAK
|
|
CASE 3
|
|
sAnim = "var_e"
|
|
BREAK
|
|
CASE 4
|
|
sAnim = "var_f"
|
|
BREAK
|
|
ENDSWITCH
|
|
|
|
bDoAnim = TRUE
|
|
ENDIF
|
|
ELSE
|
|
iNextMinTime = 2500
|
|
iNextMaxTime = 4500
|
|
|
|
// variations on combat glances
|
|
BOOL bDoingSpecialAnim = FALSE
|
|
IF NOT bDoneGuardBeckon
|
|
IF GET_GAME_TIMER() >= iLastGuardAnimationTime[i] + 1600
|
|
IF IS_SYNCHRONIZED_SCENE_RUNNING(iGuardSyncScene[GSS_STANDARD])
|
|
IF GET_SYNCHRONIZED_SCENE_PHASE(iGuardSyncScene[GSS_STANDARD]) >= 0.40
|
|
IF GET_RANDOM_INT_IN_RANGE(0,4) = 0
|
|
IF NOT IS_PED_INJURED(guardPed[3])
|
|
OR NOT IS_PED_INJURED(guardPed[4])
|
|
sDict = GET_SNATCH_AND_GRAB_ANIM_DICT_AS_STRING(SAG_ANIM_DICT_BECKON)
|
|
IF i=0
|
|
sAnim = "-180"
|
|
ELSE
|
|
sAnim = "90"
|
|
ENDIF
|
|
bDoneGuardBeckon = TRUE
|
|
bDoingSpecialAnim = TRUE
|
|
bDoAnim = TRUE
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF NOT bDoingSpecialAnim
|
|
IF GET_GAME_TIMER() >= iNextGuardAnimationTime[i]
|
|
INT iRandDict = GET_RANDOM_INT_IN_RANGE(0,9)
|
|
SWITCH iRandDict
|
|
CASE 0
|
|
CASE 1
|
|
CASE 2
|
|
CASE 3
|
|
CASE 4
|
|
iDict = 0
|
|
sDict = GET_SNATCH_AND_GRAB_ANIM_DICT_AS_STRING(SAG_ANIM_DICT_COMBAT_GLANCES)
|
|
BREAK
|
|
CASE 5
|
|
CASE 6
|
|
CASE 7
|
|
iDict = 1
|
|
sDict = GET_SNATCH_AND_GRAB_ANIM_DICT_AS_STRING(SAG_ANIM_DICT_OVER_THERE)
|
|
BREAK
|
|
CASE 8
|
|
iDict = 2
|
|
sDict = GET_SNATCH_AND_GRAB_ANIM_DICT_AS_STRING(SAG_ANIM_DICT_PANIC)
|
|
BREAK
|
|
ENDSWITCH
|
|
|
|
IF iKilledGuards >= 4
|
|
IF iDict = 1
|
|
iDict = 0
|
|
ENDIF
|
|
ENDIF
|
|
|
|
BOOL bCanLookLeft = CAN_GUARD_LOOK_LEFT(i)
|
|
BOOL bCanLookRight = CAN_GUARD_LOOK_RIGHT(i)
|
|
|
|
SWITCH iDict
|
|
CASE 0
|
|
CASE 1
|
|
|
|
sAnim = "0"
|
|
|
|
// glances, over theres
|
|
// can we look left?
|
|
|
|
IF NOT bCanLookLeft
|
|
AND NOT bCanLookRight
|
|
iAnim = 2
|
|
ELIF NOT bCanLookLeft
|
|
iAnim = GET_RANDOM_INT_IN_RANGE(2,5)
|
|
ELIF NOT bCanLookRight
|
|
iAnim = GET_RANDOM_INT_IN_RANGE(0,3)
|
|
ELSE
|
|
iAnim = GET_RANDOM_INT_IN_RANGE(0,5)
|
|
ENDIF
|
|
|
|
SWITCH iAnim
|
|
CASE 0
|
|
sAnim = "-180"
|
|
BREAK
|
|
CASE 1
|
|
sAnim = "-90"
|
|
BREAK
|
|
CASE 2
|
|
sAnim = "0"
|
|
BREAK
|
|
CASE 3
|
|
sAnim = "180"
|
|
BREAK
|
|
CASE 4
|
|
sAnim = "90"
|
|
BREAK
|
|
ENDSWITCH
|
|
BREAK
|
|
|
|
CASE 2
|
|
sAnim = "panic_aim_var_a"
|
|
|
|
IF NOT bCanLookLeft
|
|
AND NOT bCanLookRight
|
|
iAnim = 1
|
|
ELIF NOT bCanLookLeft
|
|
iAnim = GET_RANDOM_INT_IN_RANGE(1,4)
|
|
ELIF NOT bCanLookRight
|
|
iAnim = GET_RANDOM_INT_IN_RANGE(0,2)
|
|
ELSE
|
|
iAnim = GET_RANDOM_INT_IN_RANGE(0,4)
|
|
ENDIF
|
|
|
|
SWITCH iAnim
|
|
CASE 0
|
|
sAnim = "panic_aim_var_b"
|
|
BREAK
|
|
CASE 1
|
|
sAnim = "panic_aim_var_a"
|
|
BREAK
|
|
CASE 2
|
|
sAnim = "panic_aim_var_c"
|
|
BREAK
|
|
CASE 3
|
|
sAnim = "panic_aim_var_d"
|
|
BREAK
|
|
ENDSWITCH
|
|
BREAK
|
|
ENDSWITCH
|
|
|
|
bDoAnim = TRUE
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF bDoAnim
|
|
TASK_PLAY_ANIM(guardPed[i], sDict, sAnim, SLOW_BLEND_IN, -1.0, -1, AF_SECONDARY)
|
|
iNextGuardAnimationTime[i] = GET_GAME_TIMER() + GET_RANDOM_INT_IN_RANGE(iNextMinTime, iNextMaxTime)
|
|
iLastGuardAnimationTime[i] = GET_GAME_TIMER()
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDREPEAT
|
|
ENDPROC
|
|
|
|
// correct audio scene for chopper chase stage
|
|
PROC DO_CHOPPER_TO_PED_AUDIO_SCENE(enumCharacterList toChar, BOOL bForceDropoff = FALSE)
|
|
SWITCH toChar
|
|
CASE CHAR_MICHAEL
|
|
STOP_SNATCH_AND_GRAB_AUDIO_SCENE(SNATCH_AND_GRAB_AUDIO_SCENE_CHOPPERS_ARRIVE_FRANKLIN)
|
|
STOP_SNATCH_AND_GRAB_AUDIO_SCENE(SNATCH_AND_GRAB_AUDIO_SCENE_CHOPPERS_ARRIVE_TREVOR)
|
|
STOP_SNATCH_AND_GRAB_AUDIO_SCENE(SNATCH_AND_GRAB_AUDIO_SCENE_FLY_BACK_AS_TREVOR)
|
|
IF currentMissionStage = STAGE_CHOPPER_CHASE
|
|
AND NOT bForceDropoff
|
|
STOP_SNATCH_AND_GRAB_AUDIO_SCENE(SNATCH_AND_GRAB_AUDIO_SCENE_FLY_BACK_AS_MICHAEL)
|
|
START_SNATCH_AND_GRAB_AUDIO_SCENE(SNATCH_AND_GRAB_AUDIO_SCENE_CHOPPERS_ARRIVE_MICHAEL)
|
|
ELSE
|
|
STOP_SNATCH_AND_GRAB_AUDIO_SCENE(SNATCH_AND_GRAB_AUDIO_SCENE_CHOPPERS_ARRIVE_MICHAEL)
|
|
START_SNATCH_AND_GRAB_AUDIO_SCENE(SNATCH_AND_GRAB_AUDIO_SCENE_FLY_BACK_AS_MICHAEL)
|
|
ENDIF
|
|
BREAK
|
|
CASE CHAR_TREVOR
|
|
STOP_SNATCH_AND_GRAB_AUDIO_SCENE(SNATCH_AND_GRAB_AUDIO_SCENE_CHOPPERS_ARRIVE_FRANKLIN)
|
|
STOP_SNATCH_AND_GRAB_AUDIO_SCENE(SNATCH_AND_GRAB_AUDIO_SCENE_CHOPPERS_ARRIVE_MICHAEL)
|
|
STOP_SNATCH_AND_GRAB_AUDIO_SCENE(SNATCH_AND_GRAB_AUDIO_SCENE_FLY_BACK_AS_MICHAEL)
|
|
IF currentMissionStage = STAGE_CHOPPER_CHASE
|
|
AND NOT bForceDropoff
|
|
STOP_SNATCH_AND_GRAB_AUDIO_SCENE(SNATCH_AND_GRAB_AUDIO_SCENE_FLY_BACK_AS_TREVOR)
|
|
START_SNATCH_AND_GRAB_AUDIO_SCENE(SNATCH_AND_GRAB_AUDIO_SCENE_CHOPPERS_ARRIVE_TREVOR)
|
|
ELSE
|
|
STOP_SNATCH_AND_GRAB_AUDIO_SCENE(SNATCH_AND_GRAB_AUDIO_SCENE_CHOPPERS_ARRIVE_TREVOR)
|
|
START_SNATCH_AND_GRAB_AUDIO_SCENE(SNATCH_AND_GRAB_AUDIO_SCENE_FLY_BACK_AS_TREVOR)
|
|
ENDIF
|
|
BREAK
|
|
CASE CHAR_FRANKLIN
|
|
STOP_SNATCH_AND_GRAB_AUDIO_SCENE(SNATCH_AND_GRAB_AUDIO_SCENE_CHOPPERS_ARRIVE_TREVOR)
|
|
STOP_SNATCH_AND_GRAB_AUDIO_SCENE(SNATCH_AND_GRAB_AUDIO_SCENE_CHOPPERS_ARRIVE_MICHAEL)
|
|
STOP_SNATCH_AND_GRAB_AUDIO_SCENE(SNATCH_AND_GRAB_AUDIO_SCENE_FLY_BACK_AS_MICHAEL)
|
|
STOP_SNATCH_AND_GRAB_AUDIO_SCENE(SNATCH_AND_GRAB_AUDIO_SCENE_FLY_BACK_AS_TREVOR)
|
|
START_SNATCH_AND_GRAB_AUDIO_SCENE(SNATCH_AND_GRAB_AUDIO_SCENE_CHOPPERS_ARRIVE_FRANKLIN)
|
|
BREAK
|
|
ENDSWITCH
|
|
ENDPROC
|
|
|
|
PROC CREATE_GUYS_AT_FOOD_COURT(BOOL bJumpingToStage)
|
|
IF NOT bCreatedGuysAtFoodCourt
|
|
UPDATE_FOOD_COURT(FALSE, STAGE_FOOD_COURT)
|
|
CREATE_STEVE_AND_ANDREAS(bJumpingToStage)
|
|
CREATE_DAVE(bJumpingToStage)
|
|
SET_STEVE_SEATED(TRUE)
|
|
SET_ANDREAS_SEATED(TRUE)
|
|
SET_DAVE_SEATED()
|
|
bCreatedGuysAtFoodCourt = TRUE
|
|
ENDIF
|
|
ENDPROC
|
|
|
|
PROC DISABLE_PEDS_AT_FOOD_COURT()
|
|
SET_PED_NON_CREATION_AREA(<<80.15606, -689.07544, 35.22030>>, <<153.51270, -671.06488, 47.32924>>)
|
|
SET_PED_PATHS_IN_AREA(<<80.15606, -689.07544, 35.22030>>, <<153.51270, -671.06488, 47.02924>>, FALSE)
|
|
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 bHandleFadeIn = TRUE, BOOL bRemoveCutscene = TRUE)
|
|
PRINTSTRING("setting mission stage") PRINTNL()
|
|
|
|
INT i
|
|
|
|
IF bJumpingToStage
|
|
// clear area and load scene around start pos
|
|
VECTOR vStartPos
|
|
FLOAT fStartRot
|
|
|
|
SWITCH setStage
|
|
CASE STAGE_FOOD_COURT
|
|
vStartPos = GET_SNATCH_AND_GRAB_VECTOR(SAGVEC_MICHAEL_AT_FOOD_COURT)
|
|
fStartRot = MICHAEL_AT_FOOD_COURT_ROT
|
|
BREAK
|
|
CASE STAGE_GET_TO_CHOPPER
|
|
IF NOT bForcePassOnShitskip
|
|
vStartPos = GET_SNATCH_AND_GRAB_VECTOR(SAGVEC_PLAYER_INIT2)
|
|
fStartRot = PLAYER_INIT_ROT2
|
|
ELSE
|
|
vStartPos = GET_SNATCH_AND_GRAB_VECTOR(SAGVEC_MEETING_POINT)
|
|
fStartRot = -158.1
|
|
ENDIF
|
|
BREAK
|
|
CASE STAGE_GET_TO_BUILDING
|
|
IF NOT bForcePassOnShitskip
|
|
vStartPos = GET_SNATCH_AND_GRAB_VECTOR(SAGVEC_CHOPPER_INIT)
|
|
fStartRot = CHOPPER_INIT_ROT
|
|
ELSE
|
|
vStartPos = GET_SNATCH_AND_GRAB_VECTOR(SAGVEC_HOVER_TARGET)
|
|
fStartRot = CHOPPER_HOVER_ROT
|
|
ENDIF
|
|
BREAK
|
|
CASE STAGE_RAPPEL_DOWN
|
|
vStartPos = <<110.2, -618.2, 258.3>>
|
|
fStartRot = 157.8
|
|
BREAK
|
|
CASE STAGE_SNIPE_GUARDS
|
|
vStartPos = <<99.2, -618.0, 206.9>>
|
|
fStartRot = -96.5
|
|
BREAK
|
|
CASE STAGE_CHOPPER_CHASE
|
|
vStartPos = <<-139.47, -594.4, 210.8>>
|
|
fStartRot = -96.9
|
|
BREAK
|
|
CASE STAGE_DROPOFF
|
|
IF NOT bForcePassOnShitskip
|
|
vStartPos = GET_SNATCH_AND_GRAB_VECTOR(SAGVEC_CHASE_END)
|
|
fStartRot = CHOPPER_CHASE_END_ROT
|
|
ELSE
|
|
vStartPos = GET_SNATCH_AND_GRAB_VECTOR(SAGVEC_DROPOFF)
|
|
fStartRot = -124
|
|
ENDIF
|
|
BREAK
|
|
ENDSWITCH
|
|
|
|
// set to coords and wait for streaming
|
|
IF NOT g_bMagDemoActive
|
|
OR bDebugSkipMagdemoZskipped
|
|
// clear area for replay
|
|
SET_PLAYER_OUT_OF_ANY_VEHICLE()
|
|
IF bClearMap
|
|
CLEAR_AREA(vStartPos, 10000, TRUE)
|
|
ENDIF
|
|
WAIT(0)
|
|
|
|
IF NOT bInitialisingAfterIntro
|
|
IF IS_REPLAY_IN_PROGRESS()
|
|
AND NOT bSuppressFutureReplaySetups
|
|
IF setStage >= STAGE_GET_TO_BUILDING
|
|
request_ipl("DT1_05_FIB_Reflection")
|
|
PRINTSTRING("request reflection ipl 1") printnl()
|
|
ENDIF
|
|
START_REPLAY_SETUP(vStartPos, fStartRot)
|
|
ELSE
|
|
SET_ENTITY_COORDS(PLAYER_PED_ID(), vStartPos)
|
|
SET_ENTITY_HEADING(PLAYER_PED_ID(), fStartRot)
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
WAIT(0)
|
|
ENDIF
|
|
|
|
PRINTSTRING("here1") PRINTNL()
|
|
|
|
// set roads
|
|
//IF setStage = STAGE_RAPPEL_DOWN
|
|
// SET_SNATCH_AND_GRAB_ROADS(FALSE)
|
|
//ELSE
|
|
// SET_SNATCH_AND_GRAB_ROADS(TRUE)
|
|
//ENDIF
|
|
|
|
// ensure office interior is in memory
|
|
IF setStage = STAGE_RAPPEL_DOWN
|
|
PIN_OFFICE_INTERIOR(TRUE, FALSE)
|
|
ELIF setStage = STAGE_SNIPE_GUARDS
|
|
PIN_OFFICE_INTERIOR(TRUE, TRUE)
|
|
ELSE
|
|
PIN_OFFICE_INTERIOR(FALSE, FALSE)
|
|
ENDIF
|
|
|
|
PRINTSTRING("unpinned interior") PRINTNL()
|
|
|
|
// get the models and force their load
|
|
BOOL bForceLoad = TRUE
|
|
IF g_bMagDemoActive
|
|
AND setStage = STAGE_GET_TO_CHOPPER
|
|
AND NOT bDebugSkipMagdemoZskipped
|
|
bForceLoad = FALSE
|
|
ENDIF
|
|
|
|
REQUEST_MODELS_FOR_STAGE(setStage, bForceLoad, FALSE)
|
|
PRINTSTRING("requested models") PRINTNL()
|
|
|
|
// get the recordings and force their load
|
|
REQUEST_VEHICLE_RECORDINGS_FOR_STAGE(setStage, bForceLoad, FALSE)
|
|
PRINTSTRING("requested recs") PRINTNL()
|
|
|
|
// get the anims and force their load
|
|
REQUEST_ANIM_DICTS_FOR_STAGE(setStage, bForceLoad, FALSE)
|
|
PRINTSTRING("requested anims") PRINTNL()
|
|
|
|
// get the weapons and force their load
|
|
REQUEST_WEAPONS_FOR_STAGE(setStage, bForceLoad, FALSE)
|
|
PRINTSTRING("requested weapons") PRINTNL()
|
|
|
|
// reset vars
|
|
RESET_VARIABLES_FOR_STAGE(setStage)
|
|
PRINTSTRING("reset vars") PRINTNL()
|
|
|
|
// get rid of blips and text
|
|
REMOVE_ALL_BLIPS()
|
|
PRINTSTRING("removed blips") PRINTNL()
|
|
|
|
// get the ptfx and force their load
|
|
REQUEST_PTFX_FOR_STAGE(setStage, bForceLoad, FALSE)
|
|
PRINTSTRING("requested ptfx") PRINTNL()
|
|
|
|
// get the sfx and force their load
|
|
REQUEST_SFX_FOR_STAGE(setStage, bForceLoad, FALSE)
|
|
PRINTSTRING("requested sfx") PRINTNL()
|
|
|
|
// get the misc assets and force their load
|
|
REQUEST_MISC_ASSETS_FOR_STAGE(setStage, bForceLoad, FALSE)
|
|
PRINTSTRING("requested misc") PRINTNL()
|
|
|
|
// get the text and force its load
|
|
REQUEST_TEXT(TRUE)
|
|
PRINTSTRING("requested text") PRINTNL()
|
|
|
|
// reset mocap streaming
|
|
//IF mocapStreamingStage >= MOCAP_STREAMING_STAGE_WAIT
|
|
IF bRemoveCutscene
|
|
REMOVE_CUTSCENE()
|
|
mocapStreamingStage = MOCAP_STREAMING_STAGE_REQUEST
|
|
ENDIF
|
|
//ENDIF
|
|
|
|
REMOVE_MISSION_TEXT(bClearTextAndSpeech OR bJumpingToStage, bClearTextAndSpeech OR bJumpingToStage)
|
|
|
|
PRINTSTRING("stop conversations") PRINTNL()
|
|
|
|
// rope textures
|
|
IF setStage >= STAGE_GET_TO_BUILDING
|
|
AND setStage <= STAGE_SNIPE_GUARDS
|
|
ROPE_LOAD_TEXTURES()
|
|
IF bJumpingToStage
|
|
WHILE NOT ROPE_ARE_TEXTURES_LOADED()
|
|
WAIT(0)
|
|
ENDWHILE
|
|
ENDIF
|
|
ELSE
|
|
ROPE_UNLOAD_TEXTURES()
|
|
ENDIF
|
|
|
|
#IF IS_DEBUG_BUILD
|
|
bDebugJSkip = FALSE
|
|
#ENDIF
|
|
|
|
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()) + <<0,0,-1>>, 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
|
|
|
|
REPEAT 3 i
|
|
IF DOES_ENTITY_EXIST(sSelectorPeds.pedID[i])
|
|
DELETE_PED(sSelectorPeds.pedID[i])
|
|
ENDIF
|
|
ENDREPEAT
|
|
ENDIF
|
|
ENDIF
|
|
|
|
PRINTSTRING("here2") PRINTNL()
|
|
|
|
IF bJumpingToStage
|
|
OR bInitialisingAfterIntro
|
|
// remove all dialogue
|
|
IF bJumpingToStage
|
|
FOR i=0 TO 9
|
|
REMOVE_PED_FOR_DIALOGUE(snatchAndGrabConversation, i)
|
|
ENDFOR
|
|
ENDIF
|
|
|
|
// setup player with dialogue
|
|
SWITCH GET_CURRENT_PLAYER_PED_ENUM()
|
|
CASE CHAR_MICHAEL
|
|
ADD_PED_FOR_DIALOGUE(snatchAndGrabConversation, 0, PLAYER_PED_ID(), "MICHAEL")
|
|
BREAK
|
|
CASE CHAR_TREVOR
|
|
ADD_PED_FOR_DIALOGUE(snatchAndGrabConversation, 1, PLAYER_PED_ID(), "TREVOR")
|
|
BREAK
|
|
CASE CHAR_FRANKLIN
|
|
ADD_PED_FOR_DIALOGUE(snatchAndGrabConversation, 2, PLAYER_PED_ID(), "FRANKLIN")
|
|
BREAK
|
|
ENDSWITCH
|
|
|
|
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)
|
|
|
|
IF setStage = STAGE_RAPPEL_DOWN
|
|
SET_PED_PRELOAD_PROP_DATA(PLAYER_PED_ID(), ANCHOR_EYES, 2, 0)
|
|
INT iLoadMaskTime = GET_GAME_TIMER() + 2000
|
|
BOOL bTimedMaskLoadOut = FALSE
|
|
WHILE NOT bTimedMaskLoadOut
|
|
WAIT(0)
|
|
IF GET_GAME_TIMER() >= iLoadMaskTime
|
|
OR HAS_PED_PRELOAD_PROP_DATA_FINISHED(PLAYER_PED_ID())
|
|
bTimedMaskLoadOut = TRUE
|
|
ENDIF
|
|
ENDWHILE
|
|
ENDIF
|
|
|
|
SETUP_PLAYER_CHARACTER_WITH_MISSION_VARIATIONS(PLAYER_PED_ID(), GET_CHARACTER_FOR_MISSION_STAGE(setStage), setStage)
|
|
|
|
IF bJumpingToStage
|
|
IF NOT g_bMagDemoActive
|
|
LOAD_ALL_OBJECTS_IF_SCREEN_FADED_OUT()
|
|
WHILE NOT HAVE_ALL_STREAMING_REQUESTS_COMPLETED(PLAYER_PED_ID())
|
|
WAIT(0)
|
|
ENDWHILE
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
|
|
|
|
// set stage
|
|
IF bJumpingToStage
|
|
IF setStage = STAGE_CHOPPER_CHASE
|
|
bSelectedMichaelDuringExtract = TRUE
|
|
ENDIF
|
|
ENDIF
|
|
|
|
// setup selector ped activities
|
|
SET_SELECTOR_PED_ACTIVITY(sSelectorPeds, SELECTOR_PED_FRANKLIN, SELECTOR_ACTIVITY_SNIPER)
|
|
IF setStage = STAGE_SNIPE_GUARDS
|
|
SET_SELECTOR_PED_ACTIVITY(sSelectorPeds, SELECTOR_PED_MICHAEL, SELECTOR_ACTIVITY_ATTACHED_TO_HELI)
|
|
ELSE
|
|
SET_SELECTOR_PED_ACTIVITY(sSelectorPeds, SELECTOR_PED_MICHAEL, SELECTOR_ACTIVITY_DEFAULT)
|
|
ENDIF
|
|
|
|
PRINTSTRING("here4") PRINTNL()
|
|
|
|
// setup IPL group
|
|
IF setStage >= STAGE_GET_TO_BUILDING
|
|
SET_BUILDING_STATE(BUILDINGNAME_IPL_FIB2_TOWER, BUILDINGSTATE_DESTROYED)
|
|
IF NOT IS_REPLAY_BEING_SET_UP()
|
|
request_ipl("DT1_05_FIB_Reflection")
|
|
PRINTSTRING("request reflection ipl 2") printnl()
|
|
ENDIF
|
|
ELSE
|
|
SET_BUILDING_STATE(BUILDINGNAME_IPL_FIB2_TOWER, BUILDINGSTATE_NORMAL)
|
|
IF NOT IS_REPLAY_BEING_SET_UP()
|
|
remove_ipl("DT1_05_FIB_Reflection")
|
|
PRINTSTRING("remove reflection ipl 3") printnl()
|
|
ENDIF
|
|
ENDIF
|
|
|
|
PRINTSTRING("here5") PRINTNL()
|
|
|
|
// setup cascade shadows
|
|
IF setStage = STAGE_RAPPEL_DOWN
|
|
OR setStage = STAGE_CHOPPER_CHASE
|
|
CASCADE_SHADOWS_SET_CASCADE_BOUNDS_SCALE(CASCADE_SHADOWS_MULTIPLIER_EXTERIOR_OVERRIDE)
|
|
ELSE
|
|
CASCADE_SHADOWS_SET_CASCADE_BOUNDS_SCALE(CASCADE_SHADOWS_MULTIPLIER_NO_OVERRIDE)
|
|
ENDIF
|
|
|
|
IF setStage = STAGE_RAPPEL_DOWN
|
|
CASCADE_SHADOWS_SET_ENTITY_TRACKER_SCALE(CASCADE_SHADOWS_ROPE_OVERRIDE)
|
|
ELSE
|
|
CASCADE_SHADOWS_SET_ENTITY_TRACKER_SCALE(1.0)
|
|
ENDIF
|
|
|
|
IF bJumpingToStage
|
|
SET_WEATHER_TYPE_NOW_PERSIST("extrasunny")
|
|
ENDIF
|
|
|
|
PRINTSTRING("here6") PRINTNL()
|
|
|
|
// set reverb
|
|
IF setStage >= STAGE_RAPPEL_DOWN
|
|
SET_AUDIO_FLAG("ListenerReverbDisabled", TRUE)
|
|
ELSE
|
|
SET_AUDIO_FLAG("ListenerReverbDisabled", FALSE)
|
|
ENDIF
|
|
|
|
PRINTSTRING("here7") PRINTNL()
|
|
|
|
// setup player control/cameras
|
|
IF bRenderScriptCamsFalse
|
|
IF setStage <> STAGE_CHOPPER_CHASE
|
|
OR bSelectedMichaelDuringExtract
|
|
RENDER_SCRIPT_CAMS(FALSE, FALSE)
|
|
ENDIF
|
|
ENDIF
|
|
|
|
// headsets
|
|
IF bJumpingToStage
|
|
IF setStage >= STAGE_GET_TO_BUILDING
|
|
SET_PLAYER_PED_WITH_HEADSET(CHAR_TREVOR, TRUE)
|
|
SET_PLAYER_PED_WITH_HEADSET(CHAR_MICHAEL, TRUE)
|
|
SET_PLAYER_PED_WITH_HEADSET(CHAR_FRANKLIN, TRUE)
|
|
ENDIF
|
|
ENDIF
|
|
|
|
// downwash
|
|
IF setStage = STAGE_RAPPEL_DOWN
|
|
OR setStage = STAGE_SNIPE_GUARDS
|
|
DISABLE_DOWNWASH_PTFX(TRUE)
|
|
ELSE
|
|
DISABLE_DOWNWASH_PTFX(FALSE)
|
|
ENDIF
|
|
|
|
SET_SELECTOR_PED_PRIORITY(sSelectorPeds, SELECTOR_PED_FRANKLIN, SELECTOR_PED_MICHAEL, SELECTOR_PED_TREVOR)
|
|
|
|
KILL_CHASE_HINT_CAM(localChaseHintCamStruct)
|
|
|
|
PRINTSTRING("here9") PRINTNL()
|
|
|
|
// do any other necessary setup for the stage
|
|
SWITCH setStage
|
|
CASE STAGE_FOOD_COURT
|
|
CREATE_GUYS_AT_FOOD_COURT(bJumpingToStage)
|
|
CREATE_COFFEE()
|
|
buddyBlip = CREATE_MISSION_BLIP_FOR_PED(davePed)
|
|
SET_CURRENT_PED_WEAPON(PLAYER_PED_ID(), WEAPONTYPE_UNARMED, TRUE)
|
|
//CLEAR_PED_TASKS_IMMEDIATELY(PLAYER_PED_ID())
|
|
//SET_ENTITY_COORDS(PLAYER_PED_ID(), GET_SNATCH_AND_GRAB_VECTOR(SAGVEC_MICHAEL_AT_FOOD_COURT))
|
|
//SET_ENTITY_HEADING(PLAYER_PED_ID(), MICHAEL_AT_FOOD_COURT_ROT)
|
|
//FORCE_PED_MOTION_STATE(PLAYER_PED_ID(), MS_ON_FOOT_WALK, TRUE, FAUS_CUTSCENE_EXIT)
|
|
//SET_PED_MIN_MOVE_BLEND_RATIO(PLAYER_PED_ID(), PEDMOVE_WALK)
|
|
SET_GAMEPLAY_CAM_RELATIVE_HEADING()
|
|
SET_ENTITY_COORDS(PLAYER_PED_ID(), GET_SNATCH_AND_GRAB_VECTOR(SAGVEC_MICHAEL_AT_FOOD_COURT))
|
|
SET_ENTITY_HEADING(PLAYER_PED_ID(), MICHAEL_AT_FOOD_COURT_ROT)
|
|
|
|
IF bWasTimeLapseRunning
|
|
SET_TODS_CUTSCENE_RUNNING(sTimelapse, FALSE)
|
|
ENDIF
|
|
BREAK
|
|
|
|
CASE STAGE_GET_TO_CHOPPER
|
|
DISABLE_PEDS_AT_FOOD_COURT()
|
|
IF bJumpingToStage
|
|
IF IS_REPLAY_IN_PROGRESS()
|
|
bFrozeChairs = TRUE
|
|
ENDIF
|
|
CLEAR_AREA_OF_PEDS(<<119.47105, -686.39063, 41.02894>>, 30)
|
|
CLEAR_START_AREA()
|
|
ENDIF
|
|
|
|
SET_CURRENT_PED_WEAPON(PLAYER_PED_ID(), WEAPONTYPE_UNARMED, TRUE)
|
|
CLEAR_PLAYER_HAS_DAMAGED_AT_LEAST_ONE_PED(PLAYER_ID())
|
|
|
|
IF NOT g_bMagDemoActive
|
|
VEHICLE_INDEX lastPlayerVehicle
|
|
lastPlayerVehicle = GET_PLAYERS_LAST_VEHICLE()
|
|
IF IS_VEHICLE_DRIVEABLE(lastPlayerVehicle)
|
|
SET_ENTITY_AS_MISSION_ENTITY(lastPlayerVehicle, TRUE, TRUE)
|
|
ENDIF
|
|
//CLEAR_AREA(GET_SNATCH_AND_GRAB_VECTOR(SAGVEC_MICHAEL_CAR_INIT), 50, TRUE)
|
|
IF IS_VEHICLE_DRIVEABLE(lastPlayerVehicle)
|
|
SET_ENTITY_AS_MISSION_ENTITY(lastPlayerVehicle, TRUE, TRUE)
|
|
SET_VEHICLE_AS_NO_LONGER_NEEDED(lastPlayerVehicle)
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF bJumpingToStage
|
|
IF NOT g_bMagDemoActive
|
|
//POSITION_PLAYER_AT_MISSION_INIT(TRUE)
|
|
//SET_MICHAEL_INTO_CAR()
|
|
ELSE
|
|
IF bDebugSkipMagdemoStart
|
|
IF IS_VEHICLE_DRIVEABLE(snatchAndGrabVehicle[SAGV_MICHAEL_CAR])
|
|
SET_PED_INTO_VEHICLE(PLAYER_PED_ID(), snatchAndGrabVehicle[SAGV_MICHAEL_CAR])
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
IF NOT g_bMagDemoActive
|
|
IF NOT bForcePassOnShitskip
|
|
CREATE_STEVE_AND_ANDREAS(bJumpingToStage)
|
|
ENDIF
|
|
ENDIF
|
|
IF bJumpingToStage
|
|
CREATE_COFFEE()
|
|
ENDIF
|
|
|
|
CREATE_DAVE(bJumpingToStage)
|
|
IF bJumpingToStage
|
|
IF NOT bForcePassOnShitskip
|
|
IF NOT bInitialisingAfterIntro
|
|
PRINTSTRING("update food court for chopper") printnl()
|
|
UPDATE_FOOD_COURT(FALSE, STAGE_GET_TO_CHOPPER)
|
|
ENDIF
|
|
bSteveSeated = FALSE
|
|
bAndreasSeated = FALSE
|
|
SET_STEVE_SEATED(FALSE)
|
|
SET_ANDREAS_SEATED(FALSE)
|
|
WAIT(200)
|
|
ELSE
|
|
IF IS_VEHICLE_DRIVEABLE(snatchAndGrabVehicle[SAGV_MICHAEL_CAR])
|
|
SET_ENTITY_COORDS(snatchAndGrabVehicle[SAGV_MICHAEL_CAR], GET_SNATCH_AND_GRAB_VECTOR(SAGVEC_MEETING_POINT))
|
|
SET_ENTITY_HEADING(snatchAndGrabVehicle[SAGV_MICHAEL_CAR], -158.1)
|
|
ENDIF
|
|
ENDIF
|
|
|
|
//POSITION_DAVE_AT_MISSION_INIT()
|
|
ENDIF
|
|
|
|
IF IS_VEHICLE_DRIVEABLE(snatchAndGrabVehicle[SAGV_PLAYER_CHOPPER])
|
|
FREEZE_ENTITY_POSITION(snatchAndGrabVehicle[SAGV_PLAYER_CHOPPER], FALSE)
|
|
SET_VEHICLE_ON_GROUND_PROPERLY(snatchAndGrabVehicle[SAGV_PLAYER_CHOPPER])
|
|
ENDIF
|
|
|
|
//SET_CURRENT_PED_WEAPON(PLAYER_PED_ID(), WEAPONTYPE_UNARMED, FALSE)
|
|
//CREATE_FBI_FOR_STAGE(STAGE_GET_TO_CHOPPER)
|
|
|
|
// setup franklin for phone dialogue
|
|
ADD_PED_FOR_DIALOGUE(snatchAndGrabConversation, 2, NULL, "FRANKLIN")
|
|
|
|
iNextRandomSpeechTime = GET_GAME_TIMER() + 45000
|
|
|
|
IF NOT DOES_BLIP_EXIST(g_sMagDemoFBI2Entities.blip)
|
|
// getToBlip = CREATE_MISSION_BLIP_FOR_COORD(GET_SNATCH_AND_GRAB_VECTOR(SAGVEC_MEETING_POINT), TRUE)
|
|
ELSE
|
|
g_sMagDemoFBI2Entities.bBlipActive = TRUE
|
|
ENDIF
|
|
|
|
//IF NOT g_bMagDemoActive
|
|
// SET_PLAYER_CONTROL(PLAYER_ID(), FALSE, SPC_LEAVE_CAMERA_CONTROL_ON)
|
|
//ENDIF
|
|
|
|
IF IS_VEHICLE_DRIVEABLE(snatchAndGrabVehicle[SAGV_MICHAEL_CAR])
|
|
SET_VEH_RADIO_STATION(snatchAndGrabVehicle[SAGV_MICHAEL_CAR], "RADIO_01_CLASS_ROCK")
|
|
ENDIF
|
|
|
|
IF g_bMagDemoActive
|
|
IF g_bMagDemoFBI2Retry
|
|
TRIGGER_MISSION_MUSIC_EVENT("FIB2_CAR_TO_CS")
|
|
ELSE
|
|
//
|
|
TRIGGER_MISSION_MUSIC_EVENT("FIB2_CAR_TO_CS")
|
|
ENDIF
|
|
ENDIF
|
|
BREAK
|
|
|
|
CASE STAGE_GET_TO_BUILDING
|
|
//jumpCheckpoint = CREATE_CHECKPOINT(CHECKPOINT_RACE_AIR_FLAG, GET_SNATCH_AND_GRAB_VECTOR(SAGVEC_HOVER_TARGET), <<0,0,0>>, 20.0)
|
|
|
|
|
|
IF bJumpingToStage
|
|
IF NOT bForcePassOnShitskip
|
|
CREATE_UTIL_TRUCKS(STAGE_GET_TO_BUILDING)
|
|
ENDIF
|
|
bWaitForBuddyPrompt = FALSE
|
|
bGetBuddyPrompt = FALSE
|
|
// TRIGGER_MISSION_MUSIC_EVENT("FBI2_TEST_HELI_RIDE_MUSIC")
|
|
ELSE
|
|
IF IS_VEHICLE_DRIVEABLE(snatchAndGrabVehicle[SAGV_PLAYER_CHOPPER])
|
|
SET_ENTITY_SHOULD_FREEZE_WAITING_ON_COLLISION(snatchAndGrabVehicle[SAGV_PLAYER_CHOPPER], FALSE)
|
|
SET_VEHICLE_DOORS_LOCKED(snatchAndGrabVehicle[SAGV_PLAYER_CHOPPER], VEHICLELOCK_UNLOCKED)
|
|
ENDIF
|
|
IF NOT IS_PED_INJURED(sSelectorPeds.pedID[SELECTOR_PED_MICHAEL])
|
|
REMOVE_PED_FROM_GROUP(sSelectorPeds.pedID[SELECTOR_PED_MICHAEL])
|
|
ENDIF
|
|
ENDIF
|
|
IF NOT IS_PED_INJURED(sSelectorPeds.pedID[SELECTOR_PED_MICHAEL])
|
|
SET_PED_PRELOAD_PROP_DATA(sSelectorPeds.pedID[SELECTOR_PED_MICHAEL], ANCHOR_EYES, 2, 0)
|
|
SET_PED_GET_OUT_UPSIDE_DOWN_VEHICLE(sSelectorPeds.pedID[SELECTOR_PED_MICHAEL], FALSE)
|
|
SET_PED_CONFIG_FLAG(sSelectorPeds.pedID[SELECTOR_PED_MICHAEL], PCF_DontAllowToBeDraggedOutOfVehicle, TRUE)
|
|
SET_PED_CONFIG_FLAG(sSelectorPeds.pedID[SELECTOR_PED_MICHAEL], PCF_RunFromFiresAndExplosions, FALSE)
|
|
ENDIF
|
|
IF bJumpingToStage
|
|
//CREATE_FAKE_FOLLOW_CAM()
|
|
ELSE
|
|
IF GET_CAM_VIEW_MODE_FOR_CONTEXT(CAM_VIEW_MODE_CONTEXT_IN_HELI) <> CAM_VIEW_MODE_FIRST_PERSON
|
|
ANIMPOSTFX_PLAY("SwitchSceneTrevor", 0, FALSE)
|
|
PLAY_SOUND_FRONTEND(-1, "Hit_In", "PLAYER_SWITCH_CUSTOM_SOUNDSET")
|
|
ENDIF
|
|
ENDIF
|
|
|
|
START_SNATCH_AND_GRAB_AUDIO_SCENE(SNATCH_AND_GRAB_AUDIO_SCENE_FLY_TO_AGENCY)
|
|
TRIGGER_MISSION_MUSIC_EVENT("FIB2_HELI_LIFT_OFF")
|
|
BREAK
|
|
|
|
CASE STAGE_RAPPEL_DOWN
|
|
CASCADE_SHADOWS_ENABLE_FREEZER(FALSE)
|
|
|
|
OVERRIDE_PLAYER_GROUND_MATERIAL(GET_HASH_KEY("AM_BASE_GLASS_STRONG"),TRUE)
|
|
|
|
SET_CHOPPER_TO_HOVER()
|
|
michaelGunObject = CREATE_WEAPON_OBJECT(GET_SNATCH_AND_GRAB_WEAPON_TYPE(SAG_WEAPON_MICHAEL_PISTOL), 999, <<124.27, -623.83, 261.85>>, TRUE)
|
|
|
|
SET_CURRENT_PED_WEAPON(PLAYER_PED_ID(), WEAPONTYPE_UNARMED, TRUE)
|
|
PRINTSTRING("set current weapon as unarmed!") PRINTNL()
|
|
|
|
IF bJumpingToStage
|
|
//SET_WEATHER_TYPE_NOW_PERSIST("extrasunny")
|
|
//SET_CLOCK_TIME(18,0,0)
|
|
//PAUSE_CLOCK(TRUE)
|
|
|
|
//DISPLAY_RADAR(FALSE)
|
|
//DISPLAY_HUD(FALSE)
|
|
|
|
//INT iStopTrafficTime
|
|
///iStopTrafficTime = GET_GAME_TIMER() + 1000
|
|
//CLEAR_AREA(<<91.91, -630.54, 43.27>>, 300, TRUE)
|
|
//WHILE GET_GAME_TIMER() < iStopTrafficTime
|
|
//WAIT(0)
|
|
//HANDLE_RANDOM_VEHICLE_GENERATION(TRUE)
|
|
//ENDWHILE
|
|
|
|
// TRIGGER_MISSION_MUSIC_EVENT("FBI2_TEST_BEGIN_RAPPEL_ST")
|
|
ELSE
|
|
ANIMPOSTFX_PLAY("SwitchSceneMichael", 0, FALSE)
|
|
PLAY_SOUND_FRONTEND(-1, "Hit_In", "PLAYER_SWITCH_CUSTOM_SOUNDSET")
|
|
ENDIF
|
|
|
|
REPEAT NUMBER_TRAFFIC_VEHICLES i
|
|
IF IS_VEHICLE_DRIVEABLE(trafficVehicle[i])
|
|
IF IS_PLAYBACK_GOING_ON_FOR_VEHICLE(trafficVehicle[i])
|
|
UNPAUSE_PLAYBACK_RECORDED_VEHICLE(trafficVehicle[i])
|
|
ENDIF
|
|
ENDIF
|
|
ENDREPEAT
|
|
|
|
SET_FAR_DRAW_VEHICLES(TRUE)
|
|
//INSTANTLY_FILL_VEHICLE_POPULATION()
|
|
|
|
RAPPEL_STATE_ENUM initState
|
|
FLOAT fInitPhase
|
|
FLOAT fInitHeight
|
|
IF NOT bJumpingToStage
|
|
initState = RAPPEL_STATE_JUMPING_DOWN
|
|
fInitPhase = 0.40
|
|
fInitHeight = -8.2
|
|
ELSE
|
|
initState = RAPPEL_STATE_IDLING
|
|
fInitPhase = 0.0
|
|
fInitHeight = -START_RAPPEL_Z
|
|
ENDIF
|
|
|
|
INIT_RAPPEL(rappelData, snatchAndGrabVehicle[SAGV_PLAYER_CHOPPER], GET_SNATCH_AND_GRAB_VECTOR(SAGVEC_ROPE_ANCHOR_OFFSET), GET_SNATCH_AND_GRAB_VECTOR(SAGVEC_ROPE_ANCHOR_ROT), fInitHeight, -63.0, TRUE, TRUE, FALSE, NULL, FALSE, initState, fInitPhase, TRUE)
|
|
INIT_RAPPEL_CAM_MOUSE_PARAMS(rappelData, 0.9, 0.3, 0.1, 0.005) // Needed because for some reason gamepad never gets to the full extents, but mouse does - Steve R LDS.
|
|
|
|
IF NOT bJumpingToStage
|
|
rappelData.fStopDescendPhase = 1.0
|
|
rappelData.fCurrentJumpStrength = 1.0
|
|
rappelData.fSpeed = JUMP_DOWN_SPEED_ACCELERATING
|
|
rappelData.fJumpDeceleration = JUMP_DOWN_MAX_DECELERATION_SMALL
|
|
ENDIF
|
|
|
|
APPLY_CUSTOM_RAPPEL_CAM()
|
|
SET_CAM_NEAR_DOF(rappelData.cam, 2.0)
|
|
SET_CAM_FAR_DOF(rappelData.cam, 18.0)
|
|
SET_CAM_DOF_STRENGTH(rappelData.cam, 0.2)
|
|
|
|
//SET_ENTITY_COORDS(rappelData.anchorObject, GET_OFFSET_FROM_ENTITY_IN_WORLD_COORDS(snatchAndGrabVehicle[SAGV_PLAYER_CHOPPER], GET_SNATCH_AND_GRAB_VECTOR(SAGVEC_ROPE_ANCHOR_OFFSET)))
|
|
SET_RAPPEL_MATERIAL(rappelData, RAPPEL_MATERIAL_GLASS)
|
|
//SETUP_RAPPEL_CAM(rappelData, <<109.12, -619.77, 260.90>>, TRUE, TRUE)
|
|
|
|
CREATE_CHOPPER_ROPE(ROPE_TYPE_RAPPELLING)
|
|
rappelData.bAllowRopeMovement = TRUE
|
|
|
|
|
|
IF NOT bJumpingToStage
|
|
rappelData.iLastRopeVertex = 3
|
|
rappelData.iNextRopeVertex = 4
|
|
rappelData.vOverrideHand = <<110.11, -617.99, 264.15>>
|
|
ELSE
|
|
rappelData.iLastRopeVertex = 6
|
|
rappelData.iNextRopeVertex = 7
|
|
rappelData.vOverrideHand = <<111.5, -618.8, 258.81>>
|
|
ENDIF
|
|
rappelData.fSlowDownByLimitRange = 0.6
|
|
HANDLE_RAPPEL_ROPE(rappelData, FALSE, TRUE, TRUE)
|
|
|
|
rappelData.bDisabledPainAudio = TRUE
|
|
|
|
FLOAT fForceInitOffset
|
|
IF NOT bJumpingToStage
|
|
//rappelData.fSpeed = 2.6
|
|
fForceInitOffset = -0.247676
|
|
ELSE
|
|
rappelData.fSpeed = 0.0
|
|
fForceInitOffset = 0.0
|
|
ENDIF
|
|
|
|
DO_RAPPEL_CAM(rappelData, TRUE, 0, 0, FALSE, fForceInitOffset)
|
|
|
|
CASCADE_SHADOWS_SET_CASCADE_BOUNDS_SCALE(CASCADE_SHADOWS_MULTIPLIER_EXTERIOR_OVERRIDE)
|
|
CASCADE_SHADOWS_SET_ENTITY_TRACKER_SCALE(CASCADE_SHADOWS_ROPE_OVERRIDE)
|
|
|
|
INFORM_MISSION_STATS_SYSTEM_OF_TIME_WINDOW_OPEN(FBI2_RAPPEL_TIME)
|
|
|
|
START_SNATCH_AND_GRAB_AUDIO_SCENE(SNATCH_AND_GRAB_AUDIO_SCENE_RAPPEL)
|
|
|
|
IF bJumpingToStage
|
|
WAIT(0)
|
|
ENDIF
|
|
|
|
IF NOT bJumpingToStage
|
|
DO_POST_CUTSCENE_FADE_IN()
|
|
ENDIF
|
|
iNextMichaelRappelSpeechTime = GET_GAME_TIMER() + 9000
|
|
DO_MISSION_GOD_TEXT("SG_RAPPEL")
|
|
IF bJumpingToStage
|
|
TRIGGER_MISSION_MUSIC_EVENT("FIB2_RAPPEL_RESTART")
|
|
ENDIF
|
|
BREAK
|
|
|
|
CASE STAGE_SNIPE_GUARDS
|
|
IF bJumpingToStage
|
|
|
|
//REQUEST_REMOTE_SNIPER_ASSETS_AND_WAIT()
|
|
//SET_CHOPPER_TO_HOVER()
|
|
|
|
SET_CHOPPER_TO_ESCAPE()
|
|
CREATE_DUMMY_FRANKLIN()
|
|
|
|
CREATE_PRISONER_FOR_STAGE(STAGE_SNIPE_GUARDS)
|
|
|
|
CREATE_GUARDS_FOR_STAGE(STAGE_SNIPE_GUARDS)
|
|
GET_RAPPEL_SOUND_ID(rappelData)
|
|
GIVE_PLAYER_MISSION_PISTOL(TRUE)
|
|
GIVE_FRANKLIN_SNIPER_RIFLE()
|
|
FREEZE_FRANKLIN_AT_SNIPER()
|
|
CLEAR_PED_TASKS_IMMEDIATELY(PLAYER_PED_ID())
|
|
SETUP_PRISONER_WITH_BELT(TRUE, STAGE_SNIPE_GUARDS)
|
|
// TRIGGER_MISSION_MUSIC_EVENT("FBI2_TEST_BEGIN_RAPPEL_ST")
|
|
bSkippedGlassSmash = TRUE
|
|
bDisabledBlurOnRifle = FALSE
|
|
iWindowSmashStage = 0
|
|
iGuardSpeech = 0
|
|
ELSE
|
|
SETUP_PRISONER_WITH_BELT(FALSE, STAGE_SNIPE_GUARDS)
|
|
// reset guard speech based on where we got to last time
|
|
IF iGuardSpeech <= 2
|
|
iGuardSpeech = 0
|
|
ELIF iGuardSpeech <= 3
|
|
iGuardSpeech = 1
|
|
ELIF iGuardSpeech <= 4
|
|
iGuardSpeech = 2
|
|
ELIF iGuardSpeech <= 6
|
|
iGuardSpeech = 3
|
|
ELIF iGuardSpeech <= 7
|
|
iGuardSpeech = 4
|
|
ELIF iGuardSpeech <= 8
|
|
iGuardSpeech = 5
|
|
ELIF iGuardSpeech <= 9
|
|
iGuardSpeech = 6
|
|
ELIF iGuardSpeech <= 10
|
|
iGuardSpeech = 7
|
|
ELSE
|
|
iGuardSpeech = 8
|
|
ENDIF
|
|
ENDIF
|
|
|
|
//iWindowSmashStage = 0 // MEGA TEMP
|
|
SET_FAR_DRAW_VEHICLES(FALSE)
|
|
|
|
HIDE_CELLPHONE_SIGNIFIERS_FOR_CUTSCENE(TRUE)
|
|
DISABLE_CELLPHONE(TRUE)
|
|
|
|
IF IS_VEHICLE_DRIVEABLE(snatchAndGrabVehicle[SAGV_PLAYER_CHOPPER])
|
|
SET_VEHICLE_CAN_BE_TARGETTED(snatchAndGrabVehicle[SAGV_PLAYER_CHOPPER], FALSE)
|
|
ENDIF
|
|
|
|
IF NOT IS_PED_INJURED(sSelectorPeds.pedID[SELECTOR_PED_MICHAEL])
|
|
SET_BLOCKING_OF_NON_TEMPORARY_EVENTS(sSelectorPeds.pedID[SELECTOR_PED_MICHAEL], TRUE)
|
|
SET_ENTITY_ONLY_DAMAGED_BY_PLAYER(sSelectorPeds.pedID[SELECTOR_PED_MICHAEL], TRUE)
|
|
ENDIF
|
|
|
|
IF DOES_ENTITY_EXIST(chairObject)
|
|
IF IS_SYNCHRONIZED_SCENE_RUNNING(iSyncScene)
|
|
STOP_SYNCHRONIZED_ENTITY_ANIM(chairObject, INSTANT_BLEND_OUT, TRUE)
|
|
ENDIF
|
|
ENDIF
|
|
CREATE_CHAIR_FOR_STAGE(STAGE_SNIPE_GUARDS)
|
|
|
|
// temp?
|
|
IF DOES_ENTITY_EXIST(michellePed)
|
|
DELETE_PED(michellePed)
|
|
REMOVE_PED_FOR_DIALOGUE(snatchAndGrabConversation, 6)
|
|
ENDIF
|
|
|
|
SETUP_GUARDS_FOR_DIALOGUE()
|
|
IF bJumpingToStage
|
|
INIT_ALL_GUARD_ANIMATION_TIMES()
|
|
ENDIF
|
|
|
|
//SETUP_REMOTE_SNIPER(TRUE, TRUE, bJumpingToStage, TRUE, FALSE)
|
|
|
|
// IF NOT bCreatedSniper
|
|
// CREATE_SNIPER_OBJECT()
|
|
// bCreatedSniper = TRUE
|
|
// ENDIF
|
|
|
|
IF bJumpingToStage
|
|
CREATE_RAPPEL_ANCHOR(rappelData, snatchAndGrabVehicle[SAGV_PLAYER_CHOPPER], GET_SNATCH_AND_GRAB_VECTOR(SAGVEC_ROPE_ANCHOR_OFFSET), GET_SNATCH_AND_GRAB_VECTOR(SAGVEC_ROPE_ANCHOR_ROT))
|
|
CREATE_CHOPPER_ROPE(ROPE_TYPE_INSIDE, STAGE_SNIPE_GUARDS)
|
|
ENDIF
|
|
bPinRopeToWindow = TRUE
|
|
|
|
CLEAR_ROOM_FOR_GAME_VIEWPORT()
|
|
|
|
// blip the guards
|
|
REPEAT NUMBER_GUARDS i
|
|
IF NOT IS_PED_INJURED(guardPed[i])
|
|
SET_ENTITY_VISIBLE(guardPed[i], TRUE)
|
|
guardBlip[i] = CREATE_MISSION_BLIP_FOR_PED(guardPed[i], TRUE)
|
|
ENDIF
|
|
ENDREPEAT
|
|
UPDATE_PRISONER_GRAB(PRISONER_GRAB_STATE_INIT)
|
|
SET_GUARDS_AIMING_AT_MICHAEL(TRUE)
|
|
|
|
ADD_ANIM_DICT_REQUEST(SAG_ANIM_DICT_MISSION)
|
|
|
|
// temp?
|
|
//GIVE_PLAYER_MISSION_PISTOL(TRUE)
|
|
SET_CURRENT_PED_WEAPON(sSelectorPeds.pedID[SELECTOR_PED_MICHAEL], GET_SNATCH_AND_GRAB_WEAPON_TYPE(SAG_WEAPON_MICHAEL_PISTOL), TRUE)
|
|
|
|
//iGuardAttackTime = GET_GAME_TIMER() + GUARD_ATTACK_TIME_INIT
|
|
|
|
IF GET_ALLOW_MOVEMENT_WHILE_ZOOMED()
|
|
AND NOT IS_USING_KEYBOARD_AND_MOUSE(PLAYER_CONTROL)
|
|
DO_MISSION_HELP_TEXT("SG_SNHLP")
|
|
ELSE
|
|
DO_MISSION_HELP_TEXT("SG_SNHLP2")
|
|
ENDIF
|
|
|
|
START_SNATCH_AND_GRAB_AUDIO_SCENE(SNATCH_AND_GRAB_AUDIO_SCENE_FRANKLIN_SNIPE_ENEMIES)
|
|
|
|
SET_PLAYER_FORCED_AIM(PLAYER_ID(), TRUE)
|
|
SETUP_SNIPER_RIFLE(TRUE, FALSE)
|
|
// DO_MISSION_GOD_TEXT("SG_SNIPE")
|
|
IF bJumpingToStage
|
|
//iWaitForFadeTime = GET_GAME_TIMER()
|
|
//WHILE GET_GAME_TIMER() <= iWaitForFadeTime + 500
|
|
// HANDLE_WINDOW_SMASH(TRUE, TRUE)
|
|
// WAIT(0)
|
|
//ENDWHILE
|
|
TRIGGER_MISSION_MUSIC_EVENT("FIB2_SNIPE_RESTART")
|
|
ENDIF
|
|
BREAK
|
|
|
|
CASE STAGE_CHOPPER_CHASE
|
|
IF bJumpingToStage
|
|
bDoneTroubleFlashHelp = FALSE
|
|
//hangingHotswapState = HANGING_HOTSWAP_ON_FRANKLIN
|
|
//REQUEST_REMOTE_SNIPER_ASSETS_AND_WAIT()
|
|
//SETUP_REMOTE_SNIPER(TRUE, FALSE, FALSE, TRUE, TRUE)
|
|
ENDIF
|
|
|
|
DISABLE_CELLPHONE(FALSE)
|
|
//CLEANUP_FRANKLIN(TRUE)
|
|
IF DOES_ROPE_EXIST(rappelData.rope)
|
|
DELETE_ROPE(rappelData.rope)
|
|
ENDIF
|
|
REMOVE_PED_FOR_DIALOGUE(snatchAndGrabConversation, 7)
|
|
REMOVE_PED_FOR_DIALOGUE(snatchAndGrabConversation, 8)
|
|
|
|
IF DOES_ENTITY_EXIST(torchObject)
|
|
DELETE_OBJECT(torchObject)
|
|
ENDIF
|
|
|
|
STOP_SOUND(iDangleSoundID)
|
|
|
|
HIDE_CELLPHONE_SIGNIFIERS_FOR_CUTSCENE(FALSE)
|
|
|
|
IF DOES_ENTITY_EXIST(dummyFranklinPed)
|
|
DELETE_PED(dummyFranklinPed)
|
|
ENDIF
|
|
|
|
IF NOT IS_PED_INJURED(PLAYER_PED_ID())
|
|
SET_ENTITY_ONLY_DAMAGED_BY_PLAYER(PLAYER_PED_ID(), FALSE)
|
|
SET_PED_RELATIONSHIP_GROUP_HASH(PLAYER_PED_ID(), RELGROUPHASH_PLAYER)
|
|
ENDIF
|
|
|
|
IF NOT bJumpingToStage
|
|
DO_STREAM_VOLUME_ON_OFFICE(FALSE)
|
|
ENDIF
|
|
TAKE_OFF_PRISONER_BELT()
|
|
|
|
IF bJumpingToStage
|
|
bSkippedGlassSmash = TRUE
|
|
iWindowSmashStage = 0
|
|
|
|
GIVE_FRANKLIN_SNIPER_RIFLE()
|
|
SET_CHOPPER_TO_ESCAPE(TRUE)
|
|
CREATE_PRISONER_FOR_STAGE(STAGE_CHOPPER_CHASE)
|
|
//SETUP_PRISONER_WITH_BELT(TRUE)
|
|
|
|
CREATE_ENEMY_CHOPPER(FALSE)
|
|
SET_PED_INTO_VEHICLE(prisonerPed, snatchAndGrabVehicle[SAGV_PLAYER_CHOPPER], VS_BACK_RIGHT)
|
|
DO_MR_K_AGITATED_ANIM()
|
|
|
|
GIVE_MICHAEL_RIFLE()
|
|
SET_MICHAEL_CUSTOM_DRIVEBY_IN_CHOPPER()
|
|
FORCE_PED_AI_AND_ANIMATION_UPDATE(GET_MICHAEL_PED())
|
|
ENDIF
|
|
|
|
|
|
|
|
START_SNATCH_AND_GRAB_AUDIO_SCENE(SNATCH_AND_GRAB_AUDIO_SCENE_CHOPPERS_ARRIVE_FRANKLIN)
|
|
|
|
IF IS_VEHICLE_DRIVEABLE(snatchAndGrabVehicle[SAGV_PLAYER_CHOPPER])
|
|
SET_VEHICLE_CAN_BE_TARGETTED(snatchAndGrabVehicle[SAGV_PLAYER_CHOPPER], FALSE)
|
|
ENDIF
|
|
|
|
IF NOT IS_PED_INJURED(prisonerPed)
|
|
SET_ENTITY_ONLY_DAMAGED_BY_PLAYER(prisonerPed, TRUE)
|
|
SET_ENTITY_PROOFS(prisonerPed, TRUE, TRUE, TRUE, TRUE, TRUE)
|
|
ENDIF
|
|
|
|
IF NOT IS_PED_INJURED(sSelectorPeds.pedID[SELECTOR_PED_TREVOR])
|
|
SET_ENTITY_ONLY_DAMAGED_BY_PLAYER(sSelectorPeds.pedID[SELECTOR_PED_TREVOR], TRUE)
|
|
ENDIF
|
|
|
|
IF NOT IS_PED_INJURED(GET_MICHAEL_PED())
|
|
SET_PED_COMP_ITEM_CURRENT_SP(GET_MICHAEL_PED(), COMP_TYPE_PROPS, PROPS_EYES_NONE, FALSE)
|
|
//CLEAR_PED_PROP(GET_MICHAEL_PED(), ANCHOR_EYES)
|
|
ENDIF
|
|
|
|
// FROM DROPOFF STAGE
|
|
//CREATE_FBI_FOR_STAGE(STAGE_CHOPPER_CHASE)
|
|
// END FROM DROPOFF STAGE
|
|
|
|
FREEZE_FRANKLIN_AT_SNIPER(FALSE)
|
|
IF GET_CURRENT_PLAYER_PED_ENUM() = CHAR_FRANKLIN
|
|
//printstring("hit here AB!!") PRINTNL()
|
|
SET_PLAYER_FORCE_SKIP_AIM_INTRO(PLAYER_ID(), TRUE)
|
|
SET_PLAYER_FORCED_AIM(PLAYER_ID(), TRUE)
|
|
FORCE_PED_AI_AND_ANIMATION_UPDATE(PLAYER_PED_ID(), TRUE)
|
|
DISPLAY_SNIPER_SCOPE_THIS_FRAME()
|
|
ENDIF
|
|
SETUP_SNIPER_RIFLE(FALSE, TRUE)
|
|
|
|
//SET_PARTICLE_FX_BULLET_IMPACT_SCALE(2.2)
|
|
|
|
iNextMrKSpeechTime = GET_GAME_TIMER() + 25000
|
|
iFranklinPanicTime = GET_GAME_TIMER() + 35000
|
|
iTrevorSayWeHitTime = GET_GAME_TIMER() + 120000
|
|
iLastEnemyRocketsTime = GET_GAME_TIMER() + 60000
|
|
iLeadHeliFireRocketsTime = GET_GAME_TIMER() + 24000
|
|
|
|
CLEAR_ANIM_DICT_REQUEST(SAG_ANIM_DICT_MISSION)
|
|
|
|
iChopperChaseTime = GET_GAME_TIMER()
|
|
IF bJumpingToStage
|
|
WAIT(500)
|
|
TRIGGER_MISSION_MUSIC_EVENT("FIB2_ESCAPE_CHOPPER_RESTART")
|
|
ENDIF
|
|
BREAK
|
|
|
|
CASE STAGE_DROPOFF
|
|
REMOVE_PED_FOR_DIALOGUE(snatchAndGrabConversation, 6)
|
|
|
|
SET_SELECTOR_PED_DAMAGED(sSelectorPeds, SELECTOR_PED_FRANKLIN, FALSE)
|
|
|
|
IF bJumpingToStage
|
|
GIVE_MICHAEL_RIFLE()
|
|
SET_MICHAEL_CUSTOM_DRIVEBY_IN_CHOPPER()
|
|
ENDIF
|
|
|
|
IF NOT IS_PED_INJURED(sSelectorPeds.pedID[SELECTOR_PED_MICHAEL])
|
|
TASK_PAUSE(sSelectorPeds.pedID[SELECTOR_PED_MICHAEL], 100)
|
|
michaelTargetVehicle = NULL
|
|
ENDIF
|
|
|
|
SET_PARTICLE_FX_BULLET_IMPACT_SCALE(1.0)
|
|
|
|
SET_SELECTOR_PED_BLOCKED(sSelectorPeds, SELECTOR_PED_FRANKLIN, TRUE)
|
|
|
|
DO_CHOPPER_TO_PED_AUDIO_SCENE(GET_CURRENT_PLAYER_PED_ENUM(), TRUE)
|
|
|
|
IF bJumpingToStage
|
|
hotswapStage = MISSION_HOTSWAP_STAGE_SELECT_CHARACTER
|
|
|
|
//CREATE_FBI_FOR_STAGE(STAGE_DROPOFF)
|
|
CREATE_PRISONER_FOR_STAGE(STAGE_DROPOFF)
|
|
// SETUP_PRISONER_WITH_BELT(TRUE)
|
|
//CREATE_RAPPEL_ANCHOR(rappelData, snatchAndGrabVehicle[SAGV_PLAYER_CHOPPER], GET_SNATCH_AND_GRAB_VECTOR(SAGVEC_ROPE_ANCHOR_OFFSET), GET_SNATCH_AND_GRAB_VECTOR(SAGVEC_ROPE_ANCHOR_ROT))
|
|
//CREATE_CHOPPER_ROPE(ROPE_TYPE_SWINGING, STAGE_DROPOFF)
|
|
//SET_ROPE_DANGLING(TRUE, FALSE)
|
|
///WAIT(0)
|
|
///SET_ROPE_PHYSICAL()
|
|
///
|
|
IF IS_VEHICLE_DRIVEABLE(snatchAndGrabVehicle[SAGV_PLAYER_CHOPPER])
|
|
AND NOT IS_PED_INJURED(PLAYER_PED_ID())
|
|
AND NOT IS_PED_INJURED(prisonerPed)
|
|
SET_PED_INTO_VEHICLE(prisonerPed, snatchAndGrabVehicle[SAGV_PLAYER_CHOPPER], VS_BACK_RIGHT)
|
|
DO_MR_K_AGITATED_ANIM()
|
|
//SET_VEHICLE_FORWARD_SPEED(snatchAndGrabVehicle[SAGV_PLAYER_CHOPPER]
|
|
ENDIF
|
|
|
|
IF NOT IS_PED_INJURED(prisonerPed)
|
|
SET_ENTITY_PROOFS(prisonerPed, TRUE, TRUE, TRUE, TRUE, TRUE)
|
|
SET_ENTITY_ONLY_DAMAGED_BY_PLAYER(prisonerPed, TRUE)
|
|
ENDIF
|
|
createFBIAtEndStage = CREATE_FBI_AT_END_STAGE_NOT_STARTED
|
|
hangingHotswapState = HANGING_HOTSWAP_ON_TREVOR
|
|
// michaelReloadState = MICHAEL_RELOAD_HAS_AMMO
|
|
// fDrownTime = 0.0
|
|
bDoneTrevorFly = FALSE
|
|
bDoneGotoSpeech = TRUE
|
|
bDoneGoHomeSpeech = TRUE
|
|
bDoForceHeliUpwards = TRUE
|
|
bStartedWinding = FALSE
|
|
bStoppedWinding = FALSE
|
|
bDoneReattach = FALSE
|
|
bStartedJourneyToLeaveHighRiseArea = FALSE
|
|
bStartedRotateToLeaveHighRiseArea = FALSE
|
|
bKnockedOff = FALSE
|
|
bDoneTrevorCongratulateFranklinSpeech = TRUE
|
|
bDoneFranklinSayChopperDownSpeech = TRUE
|
|
iGetInTextStage = 2
|
|
bClearedAutopilot = FALSE
|
|
bTrevorCachedTarget = FALSE
|
|
bDoneFBITurnToFaceChopper = FALSE
|
|
bDoneFBIWaveDownChopper = FALSE
|
|
//iTrevorAbandonChopperTime = -1
|
|
iLeaveHighRiseAreaPoint = -1
|
|
//iTrevorTime = GET_GAME_TIMER()
|
|
iChopperHelpTime = GET_GAME_TIMER() + 7000
|
|
iForceHeliUpwardsTime = GET_GAME_TIMER()
|
|
iHeliFlyOffState = 0
|
|
fBelowWaveHeightTime = 0.0
|
|
//TRIGGER_MISSION_MUSIC_EVENT("FBI2_TEST_CHOPPER_DONE_ST")
|
|
|
|
IF bForcePassOnShitskip
|
|
//SET_PED_COORDS_KEEP_VEHICLE(PLAYER_PED_ID(), GET_SNATCH_AND_GRAB_VECTOR(SAGVEC_DROPOFF))
|
|
//LOAD_SCENE(GET_SNATCH_AND_GRAB_VECTOR(SAGVEC_DROPOFF))
|
|
SET_PLAYER_CONTROL(PLAYER_ID(), FALSE)
|
|
ELSE
|
|
TRIGGER_MISSION_MUSIC_EVENT("FIB2_FLIGHT_BACK_RT")
|
|
ENDIF
|
|
ENDIF
|
|
|
|
BREAK
|
|
ENDSWITCH
|
|
|
|
PRINTSTRING("here10") PRINTNL()
|
|
|
|
// set wanted level
|
|
IF setStage <= STAGE_GET_TO_BUILDING
|
|
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)
|
|
ELSE
|
|
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)
|
|
ENDIF
|
|
|
|
// set budgets
|
|
IF setStage = STAGE_RAPPEL_DOWN
|
|
SET_VEHICLE_POPULATION_BUDGET(3)
|
|
SET_PED_POPULATION_BUDGET(0)
|
|
ELIF setStage = STAGE_SNIPE_GUARDS
|
|
SET_VEHICLE_POPULATION_BUDGET(1)
|
|
SET_PED_POPULATION_BUDGET(0)
|
|
ELIF setStage = STAGE_CHOPPER_CHASE
|
|
SET_VEHICLE_POPULATION_BUDGET(2)
|
|
SET_PED_POPULATION_BUDGET(0)
|
|
ELIF setStage = STAGE_DROPOFF
|
|
SET_VEHICLE_POPULATION_BUDGET(3)
|
|
SET_PED_POPULATION_BUDGET(1)
|
|
ELSE
|
|
SET_VEHICLE_POPULATION_BUDGET(3)
|
|
SET_PED_POPULATION_BUDGET(3)
|
|
ENDIF
|
|
|
|
IF bJumpingToStage
|
|
IF setStage <> STAGE_SNIPE_GUARDS
|
|
AND setStage <> STAGE_CHOPPER_CHASE
|
|
IF ENUM_TO_INT(setStage) > 0
|
|
IF NOT g_bMagDemoActive
|
|
SET_GAMEPLAY_CAM_RELATIVE_HEADING(0.0)
|
|
ELSE
|
|
IF bDebugSkipMagdemoStart
|
|
SET_GAMEPLAY_CAM_RELATIVE_HEADING(0.0)
|
|
ENDIF
|
|
ENDIF
|
|
ELSE
|
|
IF g_bMagDemoActive
|
|
IF bDebugSkipMagdemoStart
|
|
SET_GAMEPLAY_CAM_RELATIVE_HEADING(0.0)
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
|
|
// damage and speed stats
|
|
IF setStage = STAGE_GET_TO_CHOPPER
|
|
IF IS_VEHICLE_DRIVEABLE(snatchAndGrabVehicle[SAGV_MICHAEL_CAR])
|
|
INFORM_MISSION_STATS_OF_DAMAGE_WATCH_ENTITY(snatchAndGrabVehicle[SAGV_MICHAEL_CAR])
|
|
INFORM_MISSION_STATS_OF_SPEED_WATCH_ENTITY(snatchAndGrabVehicle[SAGV_MICHAEL_CAR])
|
|
ENDIF
|
|
ELSE
|
|
IF IS_VEHICLE_DRIVEABLE(snatchAndGrabVehicle[SAGV_PLAYER_CHOPPER])
|
|
INFORM_MISSION_STATS_OF_DAMAGE_WATCH_ENTITY(snatchAndGrabVehicle[SAGV_PLAYER_CHOPPER])
|
|
INFORM_MISSION_STATS_OF_SPEED_WATCH_ENTITY(snatchAndGrabVehicle[SAGV_PLAYER_CHOPPER])
|
|
ENDIF
|
|
ENDIF
|
|
|
|
// cheats
|
|
IF setStage >= STAGE_RAPPEL_DOWN
|
|
DISABLE_CHEAT(CHEAT_TYPE_GIVE_WEAPONS, TRUE)
|
|
ELSE
|
|
DISABLE_CHEAT(CHEAT_TYPE_GIVE_WEAPONS, FALSE)
|
|
ENDIF
|
|
|
|
SET_SELECTOR_PED_HINT(sSelectorPeds, SELECTOR_PED_MICHAEL, FALSE)
|
|
SET_SELECTOR_PED_HINT(sSelectorPeds, SELECTOR_PED_FRANKLIN, FALSE)
|
|
SET_SELECTOR_PED_HINT(sSelectorPeds, SELECTOR_PED_TREVOR, FALSE)
|
|
SET_SELECTOR_PED_DAMAGED(sSelectorPeds, SELECTOR_PED_MICHAEL, FALSE)
|
|
SET_SELECTOR_PED_DAMAGED(sSelectorPeds, SELECTOR_PED_FRANKLIN, FALSE)
|
|
SET_SELECTOR_PED_DAMAGED(sSelectorPeds, SELECTOR_PED_TREVOR, FALSE)
|
|
|
|
IF setStage < STAGE_SNIPE_GUARDS
|
|
REMOVE_PORTAL_SETTINGS_OVERRIDE("V_CIA_PS_WINDOW_UNBROKEN")
|
|
ELSE
|
|
SET_PORTAL_SETTINGS_OVERRIDE("V_CIA_PS_WINDOW_UNBROKEN", "V_CIA_PS_WINDOW_BROKEN")
|
|
ENDIF
|
|
|
|
// set value for replay
|
|
BOOL bFinalCheckpoint = FALSE
|
|
IF ENUM_TO_INT(setStage) >= ENUM_TO_INT(STAGE_DROPOFF)
|
|
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
|
|
|
|
PRINTSTRING("here11") PRINTNL()
|
|
|
|
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_BUILDING
|
|
CASE STAGE_DROPOFF
|
|
endReplayVehicle = snatchAndGrabVehicle[SAGV_PLAYER_CHOPPER]
|
|
BREAK
|
|
CASE STAGE_GET_TO_CHOPPER
|
|
IF bForcePassOnShitskip
|
|
endReplayVehicle = snatchAndGrabVehicle[SAGV_MICHAEL_CAR]
|
|
ENDIF
|
|
BREAK
|
|
ENDSWITCH
|
|
|
|
BOOL bReturnControl = TRUE
|
|
IF setStage = STAGE_RAPPEL_DOWN
|
|
bReturnControl = FALSE
|
|
ENDIF
|
|
|
|
END_REPLAY_SETUP(endReplayVehicle, VS_DRIVER, bReturnControl)
|
|
|
|
bSuppressFutureReplaySetups = TRUE
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
|
|
// post replay setup specific skip stuff
|
|
SWITCH setStage
|
|
CASE STAGE_GET_TO_CHOPPER
|
|
|
|
IF bJumpingToStage
|
|
PRINTSTRING("update food court for chopper 2") PRINTNL()
|
|
UPDATE_FOOD_COURT(FALSE, STAGE_GET_TO_CHOPPER)
|
|
ENDIF
|
|
|
|
IF GET_FOLLOW_PED_CAM_VIEW_MODE() <> CAM_VIEW_MODE_FIRST_PERSON
|
|
FORCE_PED_MOTION_STATE(PLAYER_PED_ID(), MS_ON_FOOT_WALK, TRUE, FAUS_CUTSCENE_EXIT)
|
|
SET_PED_MIN_MOVE_BLEND_RATIO(PLAYER_PED_ID(), PEDMOVE_WALK)
|
|
ELSE
|
|
FORCE_PED_MOTION_STATE(PLAYER_PED_ID(), MS_AIMING, TRUE, FAUS_CUTSCENE_EXIT)
|
|
SIMULATE_PLAYER_INPUT_GAIT(PLAYER_ID(), PEDMOVE_WALK, 2000)
|
|
ENDIF
|
|
|
|
SET_GAMEPLAY_CAM_RELATIVE_HEADING(0.0)
|
|
|
|
BREAK
|
|
CASE STAGE_SNIPE_GUARDS
|
|
IF bJumpingToStage
|
|
DO_STREAM_VOLUME_ON_OFFICE(TRUE)
|
|
ENDIF
|
|
|
|
INT iWindowSmashTime
|
|
iWindowSmashTime = GET_GAME_TIMER() + 1000
|
|
WHILE GET_GAME_TIMER() < iWindowSmashTime
|
|
//AND iWindowSmashStage < 3
|
|
WAIT(0)
|
|
HANDLE_WINDOW_SMASH(TRUE, TRUE)
|
|
ENDWHILE
|
|
SETUP_SNIPER_RIFLE(TRUE, FALSE)
|
|
BREAK
|
|
CASE STAGE_CHOPPER_CHASE
|
|
SETUP_SNIPER_RIFLE(FALSE, TRUE)
|
|
BREAK
|
|
CASE STAGE_GET_TO_BUILDING
|
|
CASE STAGE_DROPOFF
|
|
IF NOT IS_PED_IN_VEHICLE(PLAYER_PED_ID(), snatchAndGrabVehicle[SAGV_PLAYER_CHOPPER])
|
|
SET_PED_INTO_VEHICLE(PLAYER_PED_ID(), snatchAndGrabVehicle[SAGV_PLAYER_CHOPPER])
|
|
ENDIF
|
|
IF setStage = STAGE_GET_TO_BUILDING
|
|
SET_GAMEPLAY_CAM_RELATIVE_HEADING(18.0)
|
|
SET_GAMEPLAY_CAM_RELATIVE_PITCH(20.0)
|
|
ENDIF
|
|
IF setStage = STAGE_DROPOFF
|
|
IF NOT IS_PED_INJURED(GET_MICHAEL_PED())
|
|
SET_CURRENT_PED_WEAPON(GET_MICHAEL_PED(), GET_SNATCH_AND_GRAB_WEAPON_TYPE(SAG_WEAPON_MICHAEL_RIFLE), TRUE)
|
|
ENDIF
|
|
ENDIF
|
|
BREAK
|
|
ENDSWITCH
|
|
ENDIF
|
|
|
|
// after rest of setup common stuff
|
|
SWITCH setStage
|
|
CASE STAGE_FOOD_COURT
|
|
|
|
IF GET_FOLLOW_PED_CAM_VIEW_MODE() <> CAM_VIEW_MODE_FIRST_PERSON
|
|
FORCE_PED_MOTION_STATE(PLAYER_PED_ID(), MS_ON_FOOT_WALK, TRUE, FAUS_CUTSCENE_EXIT)
|
|
SET_PED_MIN_MOVE_BLEND_RATIO(PLAYER_PED_ID(), PEDMOVE_WALK)
|
|
ELSE
|
|
FORCE_PED_MOTION_STATE(PLAYER_PED_ID(), MS_AIMING, TRUE, FAUS_CUTSCENE_EXIT)
|
|
SIMULATE_PLAYER_INPUT_GAIT(PLAYER_ID(), PEDMOVE_WALK, 1300)
|
|
ENDIF
|
|
BREAK
|
|
ENDSWITCH
|
|
|
|
IF bJumpingToStage
|
|
PRINTSTRING("HEREA") PRINTNL()
|
|
IF bHandleFadeIn
|
|
PRINTSTRING("HEREB") PRINTNL()
|
|
IF setStage = STAGE_GET_TO_CHOPPER
|
|
WAIT(0)
|
|
ENDIF
|
|
IF setStage = STAGE_DROPOFF
|
|
iFadeInTime = GET_GAME_TIMER() + 500
|
|
WHILE GET_GAME_TIMER() < iFadeInTime
|
|
WAIT(0)
|
|
FORCE_CHOPPER_UP()
|
|
ENDWHILE
|
|
IF IS_VEHICLE_DRIVEABLE(snatchAndGrabVehicle[SAGV_PLAYER_CHOPPER])
|
|
APPLY_FORCE_TO_ENTITY(snatchAndGrabVehicle[SAGV_PLAYER_CHOPPER], APPLY_TYPE_IMPULSE, <<0,0,0.15>>, <<0,-7,0>>, 0, TRUE, TRUE, TRUE)
|
|
SET_VEHICLE_FORWARD_SPEED(snatchAndGrabVehicle[SAGV_PLAYER_CHOPPER], 25)
|
|
ENDIF
|
|
WAIT(0)
|
|
ENDIF
|
|
IF setStage <> STAGE_CHOPPER_CHASE
|
|
IF IS_SCREEN_FADED_OUT()
|
|
PRINTSTRING("HEREC") PRINTNL()
|
|
DO_SCREEN_FADE_IN(DEFAULT_FADE_TIME)
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
|
|
STOP_PED_SPEAKING(PLAYER_PED_ID(), FALSE)
|
|
|
|
PRINTSTRING("here12") PRINTNL()
|
|
|
|
iStartMissionStageTime = 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_FOOD_COURT
|
|
IF bRunningCutscene
|
|
AND GET_CUTSCENE_TIME() >= 110000
|
|
RETURN TRUE
|
|
ENDIF
|
|
BREAK
|
|
|
|
CASE STAGE_GET_TO_CHOPPER
|
|
//IF IS_ENTITY_AT_COORD(PLAYER_PED_ID(), GET_SNATCH_AND_GRAB_VECTOR(SAGVEC_CHOPPER_INIT), <<100, 100, 100>>)
|
|
IF bRunningCutscene
|
|
RETURN TRUE
|
|
ENDIF
|
|
BREAK
|
|
|
|
CASE STAGE_GET_TO_BUILDING
|
|
IF IS_ENTITY_AT_COORD(PLAYER_PED_ID(), GET_SNATCH_AND_GRAB_VECTOR(SAGVEC_HOVER_TARGET), <<120, 120, 120>>)
|
|
RETURN TRUE
|
|
ENDIF
|
|
BREAK
|
|
|
|
CASE STAGE_RAPPEL_DOWN
|
|
//IF bAllowSmashIn
|
|
IF bRunningCutscene
|
|
AND smashThroughShot >= SMASH_THROUGH_WAIT_FOR_SWITCH
|
|
RETURN TRUE
|
|
ENDIF
|
|
BREAK
|
|
|
|
CASE STAGE_SNIPE_GUARDS
|
|
IF prisonerGrabState >= PRISONER_GRAB_STATE_EXTRACT
|
|
RETURN TRUE
|
|
ENDIF
|
|
BREAK
|
|
|
|
CASE STAGE_CHOPPER_CHASE
|
|
RETURN TRUE
|
|
BREAK
|
|
|
|
CASE STAGE_DROPOFF
|
|
RETURN FALSE
|
|
BREAK
|
|
|
|
//CASE STAGE_DROPOFF_PRISONER
|
|
// 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_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_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)
|
|
// PRINTSTRING("debug skip mocap!!") PRINTNL()
|
|
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
|
|
|
|
STOP_GAMEPLAY_HINT()
|
|
CANCEL_RAPPEL(rappelData)
|
|
DELETE_RAPPEL_ROPE(rappelData)
|
|
//DELETE_CHECKPOINT(jumpCheckpoint)
|
|
SET_HIDOF_OVERRIDE(FALSE, TRUE, 0, 0, 0, 0)
|
|
|
|
IF STREAMVOL_IS_VALID(foodCourtStreamingVolume)
|
|
STREAMVOL_DELETE(foodCourtStreamingVolume)
|
|
ENDIF
|
|
IF STREAMVOL_IS_VALID(officeVolume)
|
|
STREAMVOL_DELETE(officeVolume)
|
|
ENDIF
|
|
IF STREAMVOL_IS_VALID(sniperVolume)
|
|
STREAMVOL_DELETE(sniperVolume)
|
|
ENDIF
|
|
|
|
NEW_LOAD_SCENE_STOP()
|
|
|
|
IF NOT IS_PED_INJURED(PLAYER_PED_ID())
|
|
RESET_PED_IN_VEHICLE_CONTEXT(PLAYER_PED_ID())
|
|
CLEAR_PED_DRIVE_BY_CLIPSET_OVERRIDE(PLAYER_PED_ID())
|
|
SET_PLAYER_FORCED_AIM(PLAYER_ID(), FALSE)
|
|
CUSTOM_UNFREEZE_PLAYER()
|
|
IF IS_ENTITY_ATTACHED(PLAYER_PED_ID())
|
|
IF NOT IS_PED_IN_ANY_VEHICLE(PLAYER_PED_ID())
|
|
AND GET_VEHICLE_PED_IS_USING(PLAYER_PED_ID()) = NULL
|
|
DETACH_ENTITY(PLAYER_PED_ID())
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
|
|
RESET_MISSION_STATS_ENTITY_WATCH()
|
|
OVERRIDE_PLAYER_GROUND_MATERIAL(GET_HASH_KEY("AM_BASE_GLASS_STRONG"),FALSE)
|
|
|
|
bCreatedOfficePedsForRappel = FALSE
|
|
SET_PLAYER_OUT_OF_ANY_VEHICLE()
|
|
|
|
IF IS_NEW_LOAD_SCENE_ACTIVE()
|
|
NEW_LOAD_SCENE_STOP()
|
|
ENDIF
|
|
DO_STREAM_VOLUME_ON_OFFICE(FALSE)
|
|
STOP_ALL_SNATCH_AND_GRAB_AUDIO_SCENES()
|
|
//SCRIPT_OVERRIDES_WIND_TYPES(FALSE, "", "")
|
|
|
|
STOP_SOUND(iDangleSoundID)
|
|
STOP_SOUND(iSmashSoundID)
|
|
STOP_SOUND(iRappelWindSoundID)
|
|
STOP_SOUND(iFaintHeliSoundID)
|
|
STOP_SOUND(iSniperSwitchSoundID)
|
|
|
|
sSelectorPeds.bBlockSelectorPed[SELECTOR_PED_MICHAEL] = FALSE
|
|
sSelectorPeds.bBlockSelectorPed[SELECTOR_PED_FRANKLIN] = FALSE
|
|
sSelectorPeds.bBlockSelectorPed[SELECTOR_PED_TREVOR] = FALSE
|
|
|
|
// delete entities
|
|
REPEAT 3 i
|
|
IF DOES_ENTITY_EXIST(sSelectorPeds.pedID[i])
|
|
DELETE_PED(sSelectorPeds.pedID[i])
|
|
ENDIF
|
|
ENDREPEAT
|
|
|
|
IF DOES_ENTITY_EXIST(davePed)
|
|
DELETE_PED(davePed)
|
|
ENDIF
|
|
|
|
IF DOES_ENTITY_EXIST(stevePed)
|
|
DELETE_PED(stevePed)
|
|
ENDIF
|
|
|
|
IF DOES_ENTITY_EXIST(andreasPed)
|
|
DELETE_PED(andreasPed)
|
|
ENDIF
|
|
|
|
IF DOES_ENTITY_EXIST(prisonerPed)
|
|
DELETE_PED(prisonerPed)
|
|
ENDIF
|
|
|
|
IF DOES_ENTITY_EXIST(michellePed)
|
|
DELETE_PED(michellePed)
|
|
ENDIF
|
|
|
|
IF DOES_ENTITY_EXIST(dummyFranklinPed)
|
|
DELETE_PED(dummyFranklinPed)
|
|
ENDIF
|
|
|
|
IF DOES_ENTITY_EXIST(dummyTrevorPed)
|
|
DELETE_PED(dummyTrevorPed)
|
|
ENDIF
|
|
|
|
REPEAT NUMBER_FBI_AGENTS i
|
|
IF DOES_ENTITY_EXIST(fbiPed[i])
|
|
DELETE_PED(fbiPed[i])
|
|
ENDIF
|
|
ENDREPEAT
|
|
|
|
IF DOES_ENTITY_EXIST(fbiVanVehicle)
|
|
DELETE_VEHICLE(fbiVanVehicle)
|
|
ENDIF
|
|
|
|
REPEAT NUMBER_ENEMY_CHOPPERS i
|
|
IF DOES_ENTITY_EXIST(enemyChopperVehicle[i])
|
|
DELETE_VEHICLE(enemyChopperVehicle[i])
|
|
ENDIF
|
|
ENDREPEAT
|
|
|
|
REPEAT COUNT_OF(utilTruckVehicle) i
|
|
IF DOES_ENTITY_EXIST(utilTruckVehicle[i])
|
|
DELETE_VEHICLE(utilTruckVehicle[i])
|
|
ENDIF
|
|
ENDREPEAT
|
|
|
|
IF DOES_ENTITY_EXIST(driveAwayVehicle)
|
|
DELETE_VEHICLE(driveAwayVehicle)
|
|
ENDIF
|
|
|
|
REPEAT NUMBER_GUARDS i
|
|
IF DOES_ENTITY_EXIST(guardPed[i])
|
|
DELETE_PED(guardPed[i])
|
|
ENDIF
|
|
ENDREPEAT
|
|
|
|
REPEAT NUMBER_REINFORCEMENTS i
|
|
IF DOES_ENTITY_EXIST(reinforcementPed[i])
|
|
DELETE_PED(reinforcementPed[i])
|
|
ENDIF
|
|
ENDREPEAT
|
|
|
|
REPEAT NUMBER_TOWER_PEDS i
|
|
IF DOES_ENTITY_EXIST(towerPed[i])
|
|
DELETE_PED(towerPed[i])
|
|
ENDIF
|
|
ENDREPEAT
|
|
|
|
REPEAT NUMBER_ENEMY_CHOPPERS*3 i
|
|
IF DOES_ENTITY_EXIST(enemyChopperPed[i])
|
|
DELETE_PED(enemyChopperPed[i])
|
|
ENDIF
|
|
ENDREPEAT
|
|
|
|
REPEAT COUNT_OF(snatchAndGrabVehicle) i
|
|
IF DOES_ENTITY_EXIST(snatchAndGrabVehicle[i])
|
|
DELETE_VEHICLE(snatchAndGrabVehicle[i])
|
|
ENDIF
|
|
ENDREPEAT
|
|
|
|
REPEAT COUNT_OF(trafficVehicle) i
|
|
IF DOES_ENTITY_EXIST(trafficVehicle[i])
|
|
DELETE_VEHICLE(trafficVehicle[i])
|
|
ENDIF
|
|
ENDREPEAT
|
|
|
|
WAIT(0)
|
|
|
|
IF DOES_ENTITY_EXIST(harnessObject)
|
|
DELETE_OBJECT(harnessObject)
|
|
ENDIF
|
|
IF DOES_ENTITY_EXIST(torchObject)
|
|
DELETE_OBJECT(torchObject)
|
|
ENDIF
|
|
IF DOES_ENTITY_EXIST(chairObject)
|
|
DELETE_OBJECT(chairObject)
|
|
ENDIF
|
|
REPEAT NUMBER_FROZEN_CHAIRS i
|
|
IF DOES_ENTITY_EXIST(frozenChairObject[i])
|
|
SET_OBJECT_AS_NO_LONGER_NEEDED(frozenChairObject[i])
|
|
ENDIF
|
|
ENDREPEAT
|
|
REPEAT NUMBER_TOWER_CHAIRS i
|
|
IF DOES_ENTITY_EXIST(towerChairObject[i])
|
|
SET_OBJECT_AS_NO_LONGER_NEEDED(towerChairObject[i])
|
|
ENDIF
|
|
ENDREPEAT
|
|
REPEAT NUMBER_FOOD_COURT_CHAIRS i
|
|
IF DOES_ENTITY_EXIST(foodCourtChairObject[i])
|
|
SET_OBJECT_AS_NO_LONGER_NEEDED(foodCourtChairObject[i])
|
|
ENDIF
|
|
ENDREPEAT
|
|
REPEAT 3 i
|
|
IF DOES_ENTITY_EXIST(coffeeObject[i])
|
|
DELETE_OBJECT(coffeeObject[i])
|
|
ENDIF
|
|
ENDREPEAT
|
|
// IF DOES_ENTITY_EXIST(hookObject)
|
|
// DELETE_OBJECT(hookObject)
|
|
// ENDIF
|
|
// IF DOES_ENTITY_EXIST(sniperObject)
|
|
// DELETE_OBJECT(sniperObject)
|
|
// bCreatedSniper = FALSE
|
|
// ENDIF
|
|
// IF DOES_ENTITY_EXIST(waterTestObject)
|
|
// DELETE_OBJECT(waterTestObject)
|
|
// ENDIF
|
|
IF DOES_ENTITY_EXIST(franklinAnchorObject)
|
|
DELETE_OBJECT(franklinAnchorObject)
|
|
ENDIF
|
|
IF DOES_ENTITY_EXIST(michaelGunObject)
|
|
DELETE_OBJECT(michaelGunObject)
|
|
ENDIF
|
|
|
|
|
|
//CLEANUP_REMOTE_SNIPER(remoteSniperData)
|
|
|
|
IF DOES_CAM_EXIST(staticCam)
|
|
DESTROY_CAM(staticCam)
|
|
ENDIF
|
|
|
|
IF DOES_CAM_EXIST(animCam)
|
|
DESTROY_CAM(animCam)
|
|
ENDIF
|
|
|
|
IF DOES_CAM_EXIST(ropeCam)
|
|
DESTROY_CAM(ropeCam)
|
|
ENDIF
|
|
|
|
//IF DOES_CAM_EXIST(followCam)
|
|
// DESTROY_CAM(followCam)
|
|
//ENDIF
|
|
|
|
#IF IS_DEBUG_BUILD
|
|
bDebugDontFailOnKnockoff = FALSE
|
|
#ENDIF
|
|
|
|
CLEAR_AREA(GET_SNATCH_AND_GRAB_VECTOR(SAGVEC_CHOPPER_INIT), 10000, TRUE)
|
|
ENDPROC
|
|
|
|
// common stuff to clear mission
|
|
PROC COMMON_MISSION_CLEAR()
|
|
CANCEL_RAPPEL(rappelData)
|
|
KILL_CHASE_HINT_CAM(localChaseHintCamStruct)
|
|
|
|
fHoverPlaybackSpeed = CHOPPER_HOVER_SPEED
|
|
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
|
|
|
|
DISPLAY_HUD(TRUE)
|
|
DISPLAY_RADAR(TRUE)
|
|
SET_TIME_SCALE(1.0)
|
|
|
|
//CLEAR_WEATHER_TYPE_PERSIST()
|
|
PAUSE_CLOCK(FALSE)
|
|
|
|
SET_VEHICLE_POPULATION_BUDGET(3)
|
|
SET_PED_POPULATION_BUDGET(3)
|
|
SET_FAR_DRAW_VEHICLES(FALSE)
|
|
CASCADE_SHADOWS_SET_CASCADE_BOUNDS_SCALE(CASCADE_SHADOWS_MULTIPLIER_NO_OVERRIDE)
|
|
CASCADE_SHADOWS_SET_ENTITY_TRACKER_SCALE(1.0)
|
|
CASCADE_SHADOWS_SET_AIRCRAFT_MODE(FALSE)
|
|
SET_PARTICLE_FX_BULLET_IMPACT_SCALE(1.0)
|
|
SET_PLAYER_CONTROL(PLAYER_ID(), TRUE)
|
|
TASK_CLEAR_LOOK_AT(PLAYER_PED_ID())
|
|
SET_PED_RELATIONSHIP_GROUP_HASH(PLAYER_PED_ID(), RELGROUPHASH_PLAYER)
|
|
SET_SCRIPTS_SAFE_FOR_CUTSCENE(FALSE)
|
|
DISABLE_CELLPHONE(FALSE)
|
|
SET_PLAYER_FORCED_AIM(PLAYER_ID(), 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, "FBI 2: 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_FOOD_COURT
|
|
nextReplayStage = STAGE_GET_TO_CHOPPER
|
|
BREAK
|
|
CASE STAGE_GET_TO_CHOPPER
|
|
nextReplayStage = STAGE_GET_TO_CHOPPER
|
|
bForcePassOnShitskip = TRUE
|
|
BREAK
|
|
CASE STAGE_GET_TO_BUILDING
|
|
nextReplayStage = STAGE_GET_TO_BUILDING
|
|
bForcePassOnShitskip = TRUE
|
|
BREAK
|
|
CASE STAGE_RAPPEL_DOWN
|
|
nextReplayStage = STAGE_RAPPEL_DOWN
|
|
bForcePassOnShitskip = TRUE
|
|
BREAK
|
|
CASE STAGE_SNIPE_GUARDS
|
|
nextReplayStage = STAGE_CHOPPER_CHASE
|
|
BREAK
|
|
CASE STAGE_CHOPPER_CHASE
|
|
nextReplayStage = STAGE_DROPOFF
|
|
BREAK
|
|
CASE STAGE_DROPOFF
|
|
nextReplayStage = STAGE_DROPOFF
|
|
bForcePassOnShitskip = TRUE
|
|
//bPassMission = TRUE
|
|
BREAK
|
|
ENDSWITCH
|
|
|
|
//IF NOT bPassMission
|
|
// set the next mission stage nicely
|
|
COMMON_MISSION_CLEAR()
|
|
IF NOT bForcePassOnShitskip
|
|
SET_MISSION_STAGE(nextReplayStage, TRUE)
|
|
ELSE
|
|
SET_MISSION_STAGE(nextReplayStage, TRUE, TRUE, TRUE, FALSE, TRUE, FALSE)
|
|
ENDIF
|
|
//WAIT(SKIP_FADE_WAIT_TIME)
|
|
//DO_SCREEN_FADE_IN(DEFAULT_FADE_TIME)
|
|
//ELSE
|
|
// terminate the mission for last stage
|
|
// DO_SCREEN_FADE_IN(DEFAULT_FADE_TIME)
|
|
// MISSION_PASSED()
|
|
//ENDIF
|
|
|
|
RETURN TRUE
|
|
ELSE
|
|
CPRINTLN(DEBUG_REPLAY, "FBI 2: 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_FBI_TWO()
|
|
|
|
// relgroups
|
|
ADD_RELATIONSHIP_GROUP("Agency Group", agencyRelGroup)
|
|
|
|
SET_PLAYER_CONTROL(PLAYER_ID(), TRUE)
|
|
|
|
IF STREAMVOL_IS_VALID(foodCourtStreamingVolume)
|
|
STREAMVOL_DELETE(foodCourtStreamingVolume)
|
|
ENDIF
|
|
|
|
IF NOT IS_PED_INJURED(PLAYER_PED_ID())
|
|
IF NOT Is_Replay_In_Progress()
|
|
// no replay - kick mission off normally
|
|
IF NOT WAS_CUTSCENE_SKIPPED()
|
|
#IF IS_DEBUG_BUILD
|
|
IF iDebugStage >= 0
|
|
SET_MISSION_STAGE(INT_TO_ENUM(MISSION_STAGE_ENUM, iDebugStage), TRUE, TRUE, TRUE)
|
|
ELSE
|
|
#ENDIF
|
|
IF g_bMagDemoActive
|
|
SET_PLAYER_PED_AVAILABLE(CHAR_FRANKLIN, TRUE)
|
|
SET_PLAYER_PED_AVAILABLE(CHAR_MICHAEL, TRUE)
|
|
SET_PLAYER_PED_AVAILABLE(CHAR_TREVOR, TRUE)
|
|
SET_MISSION_FLOW_FLAG_STATE(FLOWFLAG_PLAYER_PED_INTRODUCED_M, TRUE)
|
|
SET_MISSION_FLOW_FLAG_STATE(FLOWFLAG_PLAYER_PED_INTRODUCED_T, TRUE)
|
|
SET_MISSION_FLOW_FLAG_STATE(FLOWFLAG_PLAYER_PED_INTRODUCED_F, TRUE)
|
|
SET_MISSION_STAGE(STAGE_GET_TO_CHOPPER, TRUE, TRUE, TRUE, FALSE, TRUE, TRUE, FALSE)
|
|
ELSE
|
|
SET_MISSION_STAGE(STAGE_FOOD_COURT, FALSE, TRUE, FALSE, TRUE)
|
|
SET_MISSION_CUTSCENE(FALSE)
|
|
ENDIF
|
|
#IF IS_DEBUG_BUILD
|
|
ENDIF
|
|
#ENDIF
|
|
ELSE
|
|
//CLEAR_START_AREA()
|
|
SET_MISSION_STAGE(STAGE_GET_TO_CHOPPER, TRUE, TRUE, TRUE, TRUE, FALSE, TRUE)
|
|
ENDIF
|
|
ELSE
|
|
IF HANDLE_MISSION_SHITSKIP()
|
|
CPRINTLN(DEBUG_REPLAY, "FBI 2: shitskip done")
|
|
ELSE
|
|
INT iReplayStage
|
|
iReplayStage = Get_Replay_Mid_Mission_Stage()
|
|
IF iReplayStage = 0
|
|
SET_MISSION_STAGE(STAGE_FOOD_COURT, TRUE, TRUE, TRUE, FALSE, TRUE, TRUE)
|
|
ELSE
|
|
SET_MISSION_STAGE(INT_TO_ENUM(MISSION_STAGE_ENUM, iReplayStage), TRUE)
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
|
|
//IF IS_SCREEN_FADED_OUT()
|
|
//OR IS_SCREEN_FADING_OUT()
|
|
// IF NOT bForcePassOnShitskip
|
|
// don't fade in straight away for end stage - special case
|
|
// DO_SCREEN_FADE_IN(DEFAULT_FADE_TIME)
|
|
// ENDIF
|
|
//ENDIF
|
|
ENDIF
|
|
|
|
missionInitStage = MISSION_INIT_DONE
|
|
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
|
|
|
|
PROC ADD_STREAMING_VOLUME_FOR_FOOD_COURT()
|
|
IF STREAMVOL_IS_VALID(foodCourtStreamingVolume)
|
|
STREAMVOL_DELETE(foodCourtStreamingVolume)
|
|
ENDIF
|
|
foodCourtStreamingVolume = STREAMVOL_CREATE_FRUSTUM(GET_SNATCH_AND_GRAB_VECTOR(SAGVEC_MICHAEL_AT_FOOD_COURT), CONVERT_ROTATION_TO_DIRECTION_VECTOR(<<0,0,MICHAEL_AT_FOOD_COURT_ROT>>), 150, FLAG_MAPDATA)
|
|
ENDPROC
|
|
|
|
// initialise mission
|
|
FUNC BOOL INIT_MISSION()
|
|
SWITCH missionInitStage
|
|
CASE MISSION_INIT_PRE_INTRO
|
|
SUPPRESS_MISSION_MODELS(TRUE)
|
|
|
|
DISABLE_SELECTOR_QUICK_SWITCH_TO_DAMAGED_PED(TRUE)
|
|
|
|
SET_GROUP_FORMATION_SPACING(PLAYER_GROUP_ID(), 3.5)
|
|
|
|
//ADD_MISC_ASSET_REQUEST(SAG_MISC_ASSET_FOOD_COURT_ANIMS)
|
|
ENABLE_CARGENS_FOR_MISSION(FALSE)
|
|
|
|
g_savedGlobals.sAmbient.iChaseHelpTextDisplayed_mission = iCHASE_HINT_HELP_DISPLAY_MAX
|
|
|
|
IF NOT Is_Replay_In_Progress()
|
|
iReplayAttempt = 0
|
|
ELSE
|
|
iReplayAttempt = g_savedGlobals.sFlow.missionSavedData[SP_MISSION_FBI_2].missionFailsNoProgress + 1
|
|
ENDIF
|
|
|
|
IF NOT IS_PED_INJURED(PLAYER_PED_ID())
|
|
STOP_PED_SPEAKING(PLAYER_PED_ID(), TRUE)
|
|
ENDIF
|
|
|
|
ADD_DOOR_TO_SYSTEM(DOORHASH_OPEN_DOOR, V_iLev_FIB_door1, <<119.40, -618.92, 206.20>>)
|
|
ADD_DOOR_TO_SYSTEM(DOORHASH_CLOSED_DOOR1, V_iLev_FIB_door1, <<123.22, -626.67, 206.2>>)
|
|
ADD_DOOR_TO_SYSTEM(DOORHASH_CLOSED_DOOR2, V_iLev_FIB_door1, <<121.22, -626.31, 206.20>>)
|
|
|
|
IF NOT g_bMagDemoActive
|
|
//SET_PLAYER_CONTROL(PLAYER_ID(), FALSE, SPC_LEAVE_CAMERA_CONTROL_ON)
|
|
lotScenarioBlocking = ADD_SCENARIO_BLOCKING_AREA(<<1321.17, -2143.95, -10>>, <<1468.61, -2001.32, 110>>)
|
|
ENDIF
|
|
|
|
tableScenarioBlocking = ADD_SCENARIO_BLOCKING_AREA(<<145.69, -678.70, -10>>, <<153.69, -671.30, 110>>)
|
|
rampScenarioBlocking = ADD_SCENARIO_BLOCKING_AREA(<<116.38534, -685.83795, -10.04556>>, <<123.69625, -680.50031, 50.02924>>)
|
|
//skyScenarioBlocking = ADD_SCENARIO_BLOCKING_AREA(<<-574.4, -1176, 50>>, <<554, -387, 600>>) // temp
|
|
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
|
|
AND NOT g_bMagDemoActive
|
|
REMOVE_MISSION_TEXT(TRUE, TRUE, FALSE)
|
|
missionInitStage = MISSION_INIT_WAIT_FOR_INTRO
|
|
ELSE
|
|
REMOVE_MISSION_TEXT()
|
|
DO_MISSION_INIT_START_MISSION()
|
|
ENDIF
|
|
BREAK
|
|
|
|
CASE MISSION_INIT_WAIT_FOR_INTRO
|
|
SET_MISSION_CUTSCENE(TRUE)
|
|
|
|
PREVENT_WANTED_LEVEL_FOR_CUTSCENE()
|
|
|
|
ADD_MODEL_REQUEST(ENUM_TO_INT(SAGM_STEVE))
|
|
ADD_MODEL_REQUEST(ENUM_TO_INT(SAGM_DAVE))
|
|
ADD_MODEL_REQUEST(ENUM_TO_INT(SAGM_ANDREAS))
|
|
ADD_MODEL_REQUEST(ENUM_TO_INT(SAGM_COFFEE))
|
|
ADD_ANIM_DICT_REQUEST(SAG_ANIM_DICT_FOOD_COURT)
|
|
REQUEST_TEXT(FALSE)
|
|
|
|
printstring("check weather") printnl()
|
|
|
|
SET_WEATHER_TYPE_OVERTIME_PERSIST("EXTRASUNNY", 12.0)
|
|
|
|
IF NOT IS_PED_INJURED(PLAYER_PED_ID())
|
|
SET_CURRENT_PED_WEAPON(PLAYER_PED_ID(), WEAPONTYPE_UNARMED, TRUE)
|
|
CLEAR_PED_TASKS_IMMEDIATELY(PLAYER_PED_ID())
|
|
SET_ENTITY_COORDS(PLAYER_PED_ID(), <<69.20226, -748.92065, 43.22582>>)
|
|
SET_ENTITY_HEADING(PLAYER_PED_ID(), -86.60)
|
|
|
|
//IF GET_FOLLOW_PED_CAM_VIEW_MODE() <> CAM_VIEW_MODE_FIRST_PERSON
|
|
FORCE_PED_MOTION_STATE(PLAYER_PED_ID(), MS_ON_FOOT_WALK, TRUE, FAUS_CUTSCENE_EXIT)
|
|
SET_PED_MIN_MOVE_BLEND_RATIO(PLAYER_PED_ID(), PEDMOVE_WALK)
|
|
//ELSE
|
|
// FORCE_PED_MOTION_STATE(PLAYER_PED_ID(), MS_AIMING, TRUE, FAUS_CUTSCENE_EXIT)
|
|
// SIMULATE_PLAYER_INPUT_GAIT(PLAYER_ID(), PEDMOVE_WALK, 1300)
|
|
//ENDIF
|
|
|
|
TASK_GO_STRAIGHT_TO_COORD(PLAYER_PED_ID(), <<85.37592, -747.95929, 44.75402>>, PEDMOVE_WALK)
|
|
SET_PLAYER_CLOTH_PIN_FRAMES(PLAYER_ID(), 1)
|
|
ENDIF
|
|
|
|
PAUSE_CLOCK(TRUE)
|
|
|
|
RESOLVE_VEHICLES_INSIDE_ANGLED_AREA_WITH_SIZE_LIMIT(<<66.39131, -749.31171, 42.22663>>, <<86.92158, -746.64587, 45.5075422>>, 5, GET_SNATCH_AND_GRAB_VECTOR(SAGVEC_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(<<60.45767, -749.65277, 43.22444>>, <<57.86939, -756.62573, 48.21973>>, 6.56, GET_SNATCH_AND_GRAB_VECTOR(SAGVEC_MOVE_LAST_PLAYER_VEHICLE), MOVE_LAST_PLAYER_VEHICLE_ROT, GET_DEFAULT_ALLOWABLE_VEHICLE_SIZE_VECTOR(), TRUE, FALSE, TRUE)
|
|
|
|
CLEAR_AREA_OF_PROJECTILES(<<69.40771, -748.54315, 43.22363>>, 20)
|
|
STOP_FIRE_IN_RANGE(<<69.40771, -748.54315, 43.22363>>, 20)
|
|
REMOVE_PARTICLE_FX_IN_RANGE(<<69.40771, -748.54315, 43.22363>>, 20)
|
|
|
|
CREATE_CAM_FOR_SNATCH_AND_GRAB_SHOT(SAG_SHOT_FIB1, TRUE, 8000)
|
|
|
|
IF NOT IS_TIME_BETWEEN_THESE_HOURS(g_sMissionStaticData[SP_MISSION_FBI_2].startHour, g_sMissionStaticData[SP_MISSION_FBI_2].endHour)
|
|
|
|
printstring("tower vol added") printnl()
|
|
bFlashOnTimeLapse = TRUE
|
|
foodCourtStreamingVolume = STREAMVOL_CREATE_FRUSTUM(<<50.3, -734.0, 230.0>>, CONVERT_ROTATION_TO_DIRECTION_VECTOR(<<18.2, 0.0, -65.5>>), 3000, FLAG_MAPDATA)
|
|
ELSE
|
|
printstring("food court vol added") printnl()
|
|
bFlashOnTimeLapse = FALSE
|
|
ADD_STREAMING_VOLUME_FOR_FOOD_COURT()
|
|
ENDIF
|
|
|
|
IF IS_SCREEN_FADED_OUT()
|
|
DO_SCREEN_FADE_IN(DEFAULT_FADE_TIME)
|
|
ENDIF
|
|
|
|
bDoneFlash = FALSE
|
|
|
|
iSnatchAndGrabCutsceneTime = GET_GAME_TIMER()
|
|
missionInitStage = MISSION_INIT_PLAY_INTRO
|
|
BREAK
|
|
|
|
CASE MISSION_INIT_PLAY_INTRO
|
|
SET_ALL_RANDOM_PEDS_FLEE_THIS_FRAME(PLAYER_ID())
|
|
|
|
BOOL bAllSucceeded
|
|
bAllSucceeded = FALSE
|
|
IF HAVE_ALL_MODEL_REQUESTS_SUCCEEDED()
|
|
AND HAVE_ALL_ANIM_DICT_REQUESTS_SUCCEEDED()
|
|
bAllSucceeded = TRUE
|
|
ENDIF
|
|
|
|
IF bAllSucceeded
|
|
CREATE_GUYS_AT_FOOD_COURT(FALSE)
|
|
// clear parasols
|
|
CLEAR_AREA_OF_OBJECTS(<<145.77409, -676.72235, 41.02924>>, 30.0, CLEAROBJ_FLAG_FORCE)
|
|
ENDIF
|
|
|
|
UPDATE_FOOD_COURT(FALSE, STAGE_FOOD_COURT)
|
|
|
|
IF NOT bDoneFlash
|
|
IF GET_FOLLOW_PED_CAM_VIEW_MODE() = CAM_VIEW_MODE_FIRST_PERSON
|
|
INT iFlashTime
|
|
IF NOT bFlashOnTimeLapse
|
|
iFlashTime = 8330
|
|
ELSE
|
|
IF bDoneTopOfTowerShot
|
|
iFlashTime = 6230
|
|
ELSE
|
|
iFlashTime = 999999
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF GET_GAME_TIMER() >= iSnatchAndGrabCutsceneTime + iFlashTime
|
|
IF bAllSucceeded
|
|
ANIMPOSTFX_PLAY("CamPushInNeutral", 0, FALSE)
|
|
PLAY_SOUND_FRONTEND(-1, "1st_Person_Transition", "PLAYER_SWITCH_CUSTOM_SOUNDSET")
|
|
ENDIF
|
|
bDoneFlash = TRUE
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF NOT bDoneTopOfTowerShot
|
|
IF NOT bSkippedCutscene
|
|
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
|
|
iSkipTime = GET_GAME_TIMER()
|
|
bSkippedCutscene = TRUE
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF (GET_GAME_TIMER() >= iSnatchAndGrabCutsceneTime + 8600 OR bSkippedCutscene)
|
|
AND bAllSucceeded
|
|
CLEAR_PED_TASKS_IMMEDIATELY(PLAYER_PED_ID())
|
|
SET_ENTITY_COORDS(PLAYER_PED_ID(), GET_SNATCH_AND_GRAB_VECTOR(SAGVEC_MICHAEL_AT_FOOD_COURT))
|
|
SET_ENTITY_HEADING(PLAYER_PED_ID(), MICHAEL_AT_FOOD_COURT_ROT)
|
|
|
|
IF bSkippedCutscene
|
|
WHILE GET_GAME_TIMER() <= iSkipTime + 5000
|
|
AND NOT STREAMVOL_HAS_LOADED(foodCourtStreamingVolume)
|
|
WAIT(0)
|
|
ENDWHILE
|
|
ENDIF
|
|
|
|
//CREATE_CAM_FOR_SNATCH_AND_GRAB_SHOT(SAG_SHOT_FIB2, TRUE, 7000)
|
|
iSnatchAndGrabCutsceneTime = GET_GAME_TIMER()
|
|
bDoneTopOfTowerShot = TRUE
|
|
|
|
ENDIF
|
|
ELSE
|
|
BOOL bResetShadowsOnTimeLapse
|
|
bResetShadowsOnTimeLapse = TRUE
|
|
|
|
IF DO_TIMELAPSE(SP_MISSION_FBI_2, sTimelapse)
|
|
IF GET_GAME_TIMER() >= iSnatchAndGrabCutsceneTime + 6500
|
|
OR NOT bWasTimeLapseRunning
|
|
OR IS_SCREEN_FADED_OUT()
|
|
PAUSE_CLOCK(FALSE)
|
|
IF IS_SCREEN_FADED_OUT()
|
|
iSkipTime = GET_GAME_TIMER()
|
|
WHILE GET_GAME_TIMER() <= iSkipTime + 5000
|
|
AND NOT STREAMVOL_HAS_LOADED(foodCourtStreamingVolume)
|
|
WAIT(0)
|
|
ENDWHILE
|
|
ENDIF
|
|
|
|
MISSION_FLOW_RELEASE_TRIGGER_SCENE_ASSETS(SP_MISSION_FBI_2)
|
|
DO_MISSION_INIT_START_MISSION()
|
|
bResetShadowsOnTimeLapse = FALSE
|
|
//DO_SCREEN_FADE_IN(DEFAULT_FADE_TIME)
|
|
ENDIF
|
|
ELSE
|
|
IF NOT bWasTimeLapseRunning
|
|
IF DOES_CAM_EXIST(sTimelapse.splineCamera)
|
|
IF IS_SCREEN_FADED_OUT()
|
|
DO_SCREEN_FADE_IN(DEFAULT_FADE_TIME)
|
|
ENDIF
|
|
ADD_STREAMING_VOLUME_FOR_FOOD_COURT()
|
|
bWasTimeLapseRunning = TRUE
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF bResetShadowsOnTimeLapse
|
|
CASCADE_SHADOWS_SET_CASCADE_BOUNDS_SCALE(0.6)
|
|
CASCADE_SHADOWS_ENABLE_ENTITY_TRACKER(FALSE)
|
|
CASCADE_SHADOWS_ENABLE_FREEZER(FALSE) //#1439834
|
|
ELSE
|
|
CASCADE_SHADOWS_INIT_SESSION()
|
|
CASCADE_SHADOWS_ENABLE_FREEZER(TRUE)
|
|
CASCADE_SHADOWS_ENABLE_ENTITY_TRACKER(TRUE)
|
|
ENDIF
|
|
//IF GET_GAME_TIMER() >= iSnatchAndGrabCutsceneTime + 8000
|
|
//
|
|
//ENDIF
|
|
ENDIF
|
|
BREAK
|
|
|
|
CASE MISSION_INIT_DONE
|
|
RETURN TRUE
|
|
BREAK
|
|
ENDSWITCH
|
|
|
|
RETURN FALSE
|
|
ENDFUNC
|
|
|
|
// all player peds block non-temporary events and reset relationships
|
|
PROC REAPPLY_PLAYER_PED_ATTRIBUTES(BOOL bResetPlayer = TRUE)
|
|
INT i
|
|
REPEAT COUNT_OF(sSelectorPeds.pedID) i
|
|
IF NOT IS_PED_INJURED(sSelectorPeds.pedID[i])
|
|
APPLY_PLAYER_ATTRIBUTES(sSelectorPeds.pedID[i])
|
|
ENDIF
|
|
ENDREPEAT
|
|
IF bResetPlayer
|
|
IF NOT IS_PED_INJURED(PLAYER_PED_ID())
|
|
SET_ENTITY_ONLY_DAMAGED_BY_PLAYER(PLAYER_PED_ID(), FALSE)
|
|
SET_ENTITY_PROOFS(PLAYER_PED_ID(), FALSE, FALSE, FALSE, FALSE, FALSE)
|
|
ENDIF
|
|
ENDIF
|
|
ENDPROC
|
|
|
|
// common start functions for creating a custom hotswap
|
|
PROC DO_COMMON_CUSTOM_HOTSWAP_START(CAMERA_TYPE type = CAMTYPE_SPLINE_DEFAULT)
|
|
CLEANUP_HOTSWAP_CAMERAS()
|
|
|
|
IF DOES_CAM_EXIST(sCamDetails.camID)
|
|
DESTROY_CAM(sCamDetails.camID)
|
|
ENDIF
|
|
|
|
sCamDetails.camID = CREATE_CAMERA(type, FALSE)
|
|
ENDPROC
|
|
|
|
// common end functions for creating a custom hotswap
|
|
PROC DO_COMMON_CUSTOM_HOTSWAP_END()
|
|
SET_CAM_SPLINE_PHASE(sCamDetails.camID, 0.0)
|
|
sCamDetails.bSplineCreated = TRUE
|
|
sCamDetails.pedTo = sSelectorPeds.pedID[sSelectorPeds.eNewSelectorPed]
|
|
sCamDetails.bRun = TRUE
|
|
ENDPROC
|
|
|
|
//SWITCH CAM VARIABLES AND PROCEDURES
|
|
|
|
ENUM FIB2_SWITCH_CAM_STATE
|
|
SWITCH_CAM_IDLE,
|
|
SWITCH_CAM_REQUEST_ASSETS,
|
|
SWITCH_CAM_SETUP_SPLINE,
|
|
SWITCH_CAM_PLAYING_SPLINE,
|
|
SWITCH_CAM_SHUTDOWN_SPLINE,
|
|
SWITCH_CAM_RETURN_TO_GAMEPLAY
|
|
ENDENUM
|
|
FIB2_SWITCH_CAM_STATE eSwitchCamState = SWITCH_CAM_IDLE
|
|
|
|
//[MF] Monitor the currently active branched switches.
|
|
ENUM FIB2_CURRENT_BRANCHED_SWITCH_ACTIVE
|
|
BRANCHED_SWITCH_INACTIVE,
|
|
BRANCHED_SWITCH_FRANKLIN_TO_TREVOR_ACTIVE,
|
|
BRANCHED_SWITCH_FRANKLIN_TO_MICHAEL_ACTIVE,
|
|
BRANCHED_SWITCH_MICHAEL_TO_FRANKLIN_ACTIVE,
|
|
BRANCHED_SWITCH_TREVOR_TO_FRANKLIN_ACTIVE
|
|
ENDENUM
|
|
|
|
FIB2_CURRENT_BRANCHED_SWITCH_ACTIVE eCurrentBranchedSwitchState
|
|
|
|
SWITCH_CAM_STRUCT scsSwitch_HangingToSniper
|
|
|
|
SWITCH_CAM_STRUCT scsSwitch_Heli_TrevorToMichael
|
|
SWITCH_CAM_STRUCT scsSwitch_Heli_MichaelToTrevor
|
|
SWITCH_CAM_STRUCT scsSwitch_Heli_Trevor_ToFranklin
|
|
SWITCH_CAM_STRUCT scsSwitch_Heli_Michael_ToFranklin
|
|
SWITCH_CAM_STRUCT scsSwitch_FranklinToHeli_Trev
|
|
SWITCH_CAM_STRUCT scsSwitch_FranklinToHeli_Mike
|
|
|
|
#IF IS_DEBUG_BUILD
|
|
BOOL bSwitchCamDebugScenarioEnabled = FALSE
|
|
FLOAT fDEBUG_OverrideMichaelAim = -1.0
|
|
//BOOL bResetDebugScenario = FALSE
|
|
#ENDIF
|
|
|
|
BOOL bPlayerControlGiven
|
|
|
|
//INT iMikeHangingToSniper_PulseInAudID
|
|
//INT iMikeHangingToSniper_PulseCamMoveAudID
|
|
//INT iMikeHangingToSniper_PulsePulseOutAudID
|
|
//BOOL bHangingToSniper_InFXPlayed
|
|
//BOOL bHangingToSniper_OutFXPlayed
|
|
|
|
#IF IS_DEBUG_BUILD
|
|
FLOAT fMikeHangingToSniperCamEaseMultiplier = 0.4
|
|
INT iMikeHangingToSniperEaseNodeIndex = 0
|
|
#ENDIF
|
|
|
|
//FLOAT fMikeHangingToSniper_SwitchInFX_Phase = 0.1
|
|
//FLOAT fMikeHangingToSniper_SwitchOutFX_Phase = 0.8
|
|
|
|
BOOL bHangingToFranklin_FranklinAimAnimPlayed
|
|
FLOAT fHangingToFranklin_AimAnimStartPhase = 0.449
|
|
|
|
BOOL bTrevorToMichaelHeliSwitch_TrevorTasked
|
|
BOOL bTrevorToFranklin_TrevorTasked
|
|
|
|
#IF IS_DEBUG_BUILD
|
|
FLOAT fMikeToFranklin_ReloadAnimStartPhase = 0.11
|
|
FLOAT fHeliToFrank_ReloadBlendInDelta = 1000
|
|
#ENDIF
|
|
|
|
FLOAT fHeliToFranklin_FranklinStartAITaskPhase = 0.0
|
|
FLOAT fMikeToFranklin_FranklinStartAITaskPhase = 0.0
|
|
FLOAT fTrevToFranklin_FranklinStartAITaskPhase = 0.0
|
|
|
|
FLOAT fSwitchToMike_AimingHeading = 165.0
|
|
|
|
FLOAT fHangOnTrevor_HintCamFollowDist = 0.95
|
|
VECTOR vHangOnTrevor_HintCamLookAtLoc = <<0.0, 350.0, -10.0>>
|
|
|
|
INT iHeliToFranklin_SwitchPedIndexOffset = 1
|
|
ENTITY_INDEX eiHeliToFranklin_FranklinTarget
|
|
|
|
PROC SETUP_SPLINE_CAM_NODE_ARRAY_HANGING_TO_SNIPER(SWITCH_CAM_STRUCT &thisSwitchCam, PED_INDEX piFranklin)
|
|
CDEBUG3LN(DEBUG_MISSION, "SETUP_SPLINE_CAM_NODE_ARRAY_HANGING_TO_SNIPER")
|
|
|
|
//IF NOT thisSwitchCam.bInitialized
|
|
|
|
|
|
//--- Start of Cam Data ---
|
|
|
|
|
|
thisSwitchCam.nodes[0].SwitchCamType = SWITCH_CAM_WORLD_POS
|
|
thisSwitchCam.nodes[0].iForceCamPointAtEntityIndex = -1
|
|
thisSwitchCam.nodes[0].bIsGameplayCamCopy = FALSE
|
|
thisSwitchCam.nodes[0].iNodeTime = 0
|
|
thisSwitchCam.nodes[0].vNodePos = <<-134.2022, -592.6018, 211.9194>>
|
|
thisSwitchCam.nodes[0].vWorldPosLookAt = <<0.0000, 0.0000, 0.0000>>
|
|
thisSwitchCam.nodes[0].fNodeOffsetDist = 0.0000
|
|
thisSwitchCam.nodes[0].fNodeVerticleOffset = 0.0000
|
|
thisSwitchCam.nodes[0].bAttachToOriginPed = FALSE
|
|
thisSwitchCam.nodes[0].vNodeDir = <<5.9428, -0.6980, 102.2135>>
|
|
thisSwitchCam.nodes[0].bPointAtEntity = FALSE
|
|
thisSwitchCam.nodes[0].bPointAtOffsetIsRelative = FALSE
|
|
thisSwitchCam.nodes[0].bAttachOffsetIsRelative = TRUE
|
|
thisSwitchCam.nodes[0].fNodeFOV = 43.0000
|
|
thisSwitchCam.nodes[0].vClonedNodeOffset = <<0.0000, 0.0000, 0.0000>>
|
|
thisSwitchCam.nodes[0].iNodeToClone = 0
|
|
thisSwitchCam.nodes[0].NodeTimePostFX_Type = NO_EFFECT
|
|
thisSwitchCam.nodes[0].fNodeTimePostFXBlendTime = 0.0000
|
|
thisSwitchCam.nodes[0].fNodeTimePostFXTimeOffset = 0.0000
|
|
thisSwitchCam.nodes[0].fNodeMotionBlur = 0.3000
|
|
thisSwitchCam.nodes[0].NodeCamShakeType = CAM_SHAKE_DEFAULT
|
|
thisSwitchCam.nodes[0].fNodeCamShake = 0.0000
|
|
thisSwitchCam.nodes[0].iCamEaseType = 0
|
|
thisSwitchCam.nodes[0].fCamEaseScaler = 0.0000
|
|
thisSwitchCam.nodes[0].fCamNodeVelocityScale = 0.0000
|
|
thisSwitchCam.nodes[0].bCamEaseForceLinear = TRUE
|
|
thisSwitchCam.nodes[0].bCamEaseForceLevel = FALSE
|
|
thisSwitchCam.nodes[0].fTimeScale = 0.0100
|
|
thisSwitchCam.nodes[0].iTimeScaleEaseType = 0
|
|
thisSwitchCam.nodes[0].fTimeScaleEaseScaler = 0.0000
|
|
thisSwitchCam.nodes[0].bFlashEnabled = FALSE
|
|
thisSwitchCam.nodes[0].SCFE_FlashEffectUsed = SCFE_CODE_FLASH
|
|
thisSwitchCam.nodes[0].fMinExposure = 0.0000
|
|
thisSwitchCam.nodes[0].fMaxExposure = 0.0000
|
|
thisSwitchCam.nodes[0].iRampUpDuration = 0
|
|
thisSwitchCam.nodes[0].iRampDownDuration = 0
|
|
thisSwitchCam.nodes[0].iHoldDuration = 0
|
|
thisSwitchCam.nodes[0].fFlashNodePhaseOffset = 0.0000
|
|
thisSwitchCam.nodes[0].bIsLowDetailNode = FALSE
|
|
thisSwitchCam.nodes[0].bUseCustomDOF = FALSE
|
|
thisSwitchCam.nodes[0].NodeDOF_Info.fDOF_NearDOF = 0.0000
|
|
thisSwitchCam.nodes[0].NodeDOF_Info.fDOF_FarDOF = 0.0000
|
|
thisSwitchCam.nodes[0].NodeDOF_Info.fDOF_EffectStrength = 0.0000
|
|
|
|
thisSwitchCam.nodes[1].SwitchCamType = SWITCH_CAM_WORLD_POS
|
|
thisSwitchCam.nodes[1].iForceCamPointAtEntityIndex = -1
|
|
thisSwitchCam.nodes[1].bIsGameplayCamCopy = FALSE
|
|
thisSwitchCam.nodes[1].iNodeTime = 1500
|
|
thisSwitchCam.nodes[1].vNodePos = <<-134.2023, -592.6019, 211.9195>>
|
|
thisSwitchCam.nodes[1].vWorldPosLookAt = <<-1662.8572, -1116.3562, 17.8841>>
|
|
thisSwitchCam.nodes[1].fNodeOffsetDist = 5.0000
|
|
thisSwitchCam.nodes[1].fNodeVerticleOffset = 0.0000
|
|
thisSwitchCam.nodes[1].bAttachToOriginPed = FALSE
|
|
thisSwitchCam.nodes[1].vNodeDir = <<5.9428, -0.6980, 102.2135>>
|
|
thisSwitchCam.nodes[1].bPointAtEntity = FALSE
|
|
thisSwitchCam.nodes[1].bPointAtOffsetIsRelative = FALSE
|
|
thisSwitchCam.nodes[1].bAttachOffsetIsRelative = TRUE
|
|
thisSwitchCam.nodes[1].fNodeFOV = 43.0000
|
|
thisSwitchCam.nodes[1].vClonedNodeOffset = <<0.0000, 0.0000, 0.0000>>
|
|
thisSwitchCam.nodes[1].iNodeToClone = 0
|
|
thisSwitchCam.nodes[1].NodeTimePostFX_Type = NO_EFFECT
|
|
thisSwitchCam.nodes[1].fNodeTimePostFXBlendTime = 0.0000
|
|
thisSwitchCam.nodes[1].fNodeTimePostFXTimeOffset = 0.0000
|
|
thisSwitchCam.nodes[1].fNodeMotionBlur = 0.8000
|
|
thisSwitchCam.nodes[1].NodeCamShakeType = CAM_SHAKE_DEFAULT
|
|
thisSwitchCam.nodes[1].fNodeCamShake = 0.0000
|
|
thisSwitchCam.nodes[1].iCamEaseType = 2
|
|
thisSwitchCam.nodes[1].fCamEaseScaler = 0.9000
|
|
thisSwitchCam.nodes[1].fCamNodeVelocityScale = 0.0000
|
|
thisSwitchCam.nodes[1].bCamEaseForceLinear = TRUE
|
|
thisSwitchCam.nodes[1].bCamEaseForceLevel = FALSE
|
|
thisSwitchCam.nodes[1].fTimeScale = 1.0000
|
|
thisSwitchCam.nodes[1].iTimeScaleEaseType = 0
|
|
thisSwitchCam.nodes[1].fTimeScaleEaseScaler = 0.0000
|
|
thisSwitchCam.nodes[1].bFlashEnabled = TRUE
|
|
thisSwitchCam.nodes[1].SCFE_FlashEffectUsed = SCFE_SwitchSceneFranklin
|
|
thisSwitchCam.nodes[1].fMinExposure = 0.0000
|
|
thisSwitchCam.nodes[1].fMaxExposure = 0.0000
|
|
thisSwitchCam.nodes[1].iRampUpDuration = 0
|
|
thisSwitchCam.nodes[1].iRampDownDuration = 0
|
|
thisSwitchCam.nodes[1].iHoldDuration = 0
|
|
thisSwitchCam.nodes[1].fFlashNodePhaseOffset = 0.0000
|
|
thisSwitchCam.nodes[1].bIsLowDetailNode = FALSE
|
|
thisSwitchCam.nodes[1].bUseCustomDOF = FALSE
|
|
thisSwitchCam.nodes[1].NodeDOF_Info.fDOF_NearDOF = 0.0000
|
|
thisSwitchCam.nodes[1].NodeDOF_Info.fDOF_FarDOF = 0.0000
|
|
thisSwitchCam.nodes[1].NodeDOF_Info.fDOF_EffectStrength = 0.0000
|
|
|
|
|
|
|
|
thisSwitchCam.iNumNodes = 2
|
|
thisSwitchCam.iCamSwitchFocusNode = 0
|
|
thisSwitchCam.fSwitchSoundAudioStartPhase = -1.0000
|
|
thisSwitchCam.fSwitchSoundAudioEndPhase = -1.0000
|
|
thisSwitchCam.bSwitchSoundPlayOpeningPulse = TRUE
|
|
thisSwitchCam.bSwitchSoundPlayMoveLoop = TRUE
|
|
thisSwitchCam.bSwitchSoundPlayExitPulse = TRUE
|
|
thisSwitchCam.bSplineNoSmoothing = FALSE
|
|
thisSwitchCam.bAddGameplayCamAsLastNode = FALSE
|
|
thisSwitchCam.iGameplayNodeBlendDuration = 0
|
|
|
|
|
|
//--- End of Cam Data ---
|
|
|
|
|
|
|
|
|
|
thisSwitchCam.strOutputStructName = "thisSwitchCam"
|
|
thisSwitchCam.strOutputFileName = "CameraInfo_FIB2_HangingToSniper.txt"
|
|
thisSwitchCam.strXMLFileName = "CameraInfo_FIB2_HangingToSniper.xml"
|
|
|
|
thisSwitchCam.bInitialized = TRUE
|
|
//ENDIF
|
|
|
|
thisSwitchCam.piPeds[0] = piFranklin
|
|
|
|
|
|
ENDPROC
|
|
|
|
/// PURPOSE:
|
|
/// Handle the playback of the switch cam. The will setup, play, shut down and cleanup the switch cam spline
|
|
/// PARAMS:
|
|
/// thisSwitchCam - Switch camera to playback
|
|
/// bReturnTrueOnce - If you only want this function to return TRUE once upon completion. Set to FALSE to have this function to return true every time this is called once the camera is finished playback.
|
|
/// RETURNS:
|
|
/// TRUE when camera is complete, FALSE if playback is still active, or if the camera has completed playback and bReturnTrueOnce is set to TRUE.
|
|
FUNC BOOL HANDLE_SWITCH_CAM_HANGING_TO_SNIPER(SWITCH_CAM_STRUCT &thisSwitchCam, BOOL bReturnTrueOnce = TRUE)
|
|
|
|
INT iCurrentNode
|
|
STRING sFranklinAimAnimLibrary = GET_SNATCH_AND_GRAB_ANIM_DICT_AS_STRING(SAG_ANIM_DICT_SNIPER)
|
|
|
|
SWITCH eSwitchCamState
|
|
|
|
CASE SWITCH_CAM_IDLE
|
|
CDEBUG3LN(DEBUG_MISSION, "eSwitchCamState = SWITCH_CAM_IDLE")
|
|
//RETURN FALSE
|
|
BREAK
|
|
|
|
CASE SWITCH_CAM_REQUEST_ASSETS
|
|
CDEBUG3LN(DEBUG_MISSION, "eSwitchCamState = SWITCH_CAM_REQUEST_ASSETS")
|
|
IF IS_NEW_LOAD_SCENE_ACTIVE()
|
|
NEW_LOAD_SCENE_STOP()
|
|
ENDIF
|
|
IF STREAMVOL_IS_VALID(sniperVolume)
|
|
STREAMVOL_DELETE(sniperVolume)
|
|
ENDIF
|
|
IF STREAMVOL_IS_VALID(officeVolume)
|
|
STREAMVOL_DELETE(officeVolume)
|
|
ENDIF
|
|
NEW_LOAD_SCENE_START_SPHERE((<<-144.6, -593.7, 211.8>>), 20.0, NEWLOADSCENE_FLAG_LONGSWITCH_CUTSCENE )
|
|
//REQUEST_ANIM_DICT(sFranklinAimAnimLibrary)
|
|
BREAK
|
|
|
|
CASE SWITCH_CAM_SETUP_SPLINE
|
|
CDEBUG3LN(DEBUG_MISSION, "eSwitchCamState = SWITCH_CAM_SETUP_SPLINE")
|
|
|
|
SETUP_SPLINE_CAM_NODE_ARRAY_HANGING_TO_SNIPER(thisSwitchCam, GET_FRANKLIN_PED())
|
|
|
|
IF DOES_SWITCH_CAM_EXIST(thisSwitchCam)
|
|
DESTROY_SWITCH_CAM(thisSwitchCam)
|
|
ENDIF
|
|
|
|
//REQUEST_ANIM_DICT(sFranklinAimAnimLibrary)
|
|
|
|
CREATE_SPLINE_CAM(thisSwitchCam)
|
|
|
|
SET_CAM_ACTIVE(thisSwitchCam.ciSpline, TRUE)
|
|
RENDER_SCRIPT_CAMS(TRUE, FALSE)
|
|
|
|
DISPLAY_RADAR(FALSE)
|
|
DISPLAY_HUD(FALSE)
|
|
|
|
SETTIMERB(0)
|
|
|
|
SET_PLAYER_CONTROL(PLAYER_ID(), FALSE)
|
|
|
|
bPlayerControlGiven = FALSE
|
|
bHangingToFranklin_FranklinAimAnimPlayed = false
|
|
|
|
eSwitchCamState = SWITCH_CAM_PLAYING_SPLINE
|
|
FALLTHRU
|
|
|
|
CASE SWITCH_CAM_PLAYING_SPLINE
|
|
CDEBUG3LN(DEBUG_MISSION, "eSwitchCamState = SWITCH_CAM_PLAYING_SPLINE")
|
|
CDEBUG3LN(DEBUG_MISSION, GET_CAM_SPLINE_PHASE(thisSwitchCam.ciSpline))
|
|
|
|
iCurrentNode = UPDATE_SPLINE_CAM(thisSwitchCam)
|
|
|
|
//IF HAS_ANIM_DICT_LOADED(sFranklinAimAnimLibrary)
|
|
IF NOT bHangingToFranklin_FranklinAimAnimPlayed
|
|
PRINTLN("Assigning Franklin Sniper Task...")
|
|
TASK_PLAY_ANIM(dummyFranklinPed, sFranklinAimAnimLibrary, "ig_7_m_door_f_sniping_franklin", INSTANT_BLEND_IN, DEFAULT, DEFAULT, DEFAULT, fHangingToFranklin_AimAnimStartPhase)
|
|
FORCE_PED_AI_AND_ANIMATION_UPDATE(dummyFranklinPed, TRUE)
|
|
bHangingToFranklin_FranklinAimAnimPlayed = TRUE
|
|
ENDIF
|
|
//ENDIF
|
|
|
|
IF IS_CAM_ACTIVE(thisSwitchCam.ciSpline)
|
|
IF iCurrentNode >= thisSwitchCam.iCamSwitchFocusNode
|
|
sCamDetails.bOKToSwitchPed = TRUE
|
|
ENDIF
|
|
|
|
IF DOES_CAM_EXIST(thisSwitchCam.ciSpline)
|
|
IF NOT bDoneHitSound
|
|
IF GET_CAM_SPLINE_PHASE(thisSwitchCam.ciSpline) >= 0.00
|
|
PLAY_SOUND_FRONTEND(-1, "Hit_In", "PLAYER_SWITCH_CUSTOM_SOUNDSET")
|
|
bDoneHitSound = TRUE
|
|
ENDIF
|
|
ENDIF
|
|
|
|
//[MF] Once cam is at the end, reset the gameplay cam positon and advance to next state.
|
|
IF GET_CAM_SPLINE_PHASE(thisSwitchCam.ciSpline) >= 1.00
|
|
CDEBUG3LN(DEBUG_MISSION, "eSwitchCamState = SWITCH_CAM_RETURN_TO_GAMEPLAY")
|
|
eSwitchCamState = SWITCH_CAM_RETURN_TO_GAMEPLAY
|
|
ENDIF
|
|
ELSE
|
|
SCRIPT_ASSERT("Cam Prematurely Deleted! WTF?")
|
|
eSwitchCamState = SWITCH_CAM_RETURN_TO_GAMEPLAY
|
|
ENDIF
|
|
|
|
ENDIF
|
|
|
|
BREAK
|
|
|
|
CASE SWITCH_CAM_RETURN_TO_GAMEPLAY
|
|
|
|
SET_TIME_SCALE(1.0)
|
|
|
|
RENDER_SCRIPT_CAMS(FALSE, FALSE)
|
|
|
|
IF DOES_CAM_EXIST(thisSwitchCam.ciSpline)
|
|
SET_CAM_ACTIVE(thisSwitchCam.ciSpline, FALSE)
|
|
ENDIF
|
|
|
|
IF DOES_SWITCH_CAM_EXIST(thisSwitchCam)
|
|
DESTROY_SWITCH_CAM(thisSwitchCam)
|
|
ENDIF
|
|
|
|
IF NOT bPlayerControlGiven
|
|
SET_PLAYER_CONTROL(PLAYER_ID(), TRUE)
|
|
DISPLAY_RADAR(TRUE)
|
|
DISPLAY_HUD(TRUE)
|
|
bPlayerControlGiven = TRUE
|
|
ENDIF
|
|
|
|
SETTIMERA(0)
|
|
|
|
eSwitchCamState = SWITCH_CAM_IDLE
|
|
|
|
NEW_LOAD_SCENE_STOP()
|
|
//REMOVE_ANIM_DICT(sFranklinAimAnimLibrary)
|
|
|
|
thisSwitchCam.bIsSplineCamFinishedPlaying = TRUE
|
|
|
|
sCamDetails.bSplineCreated = FALSE
|
|
|
|
sCamDetails.bOKToSwitchPed = FALSE
|
|
|
|
SET_PLAYER_CONTROL(PLAYER_ID(), true)
|
|
|
|
RETURN TRUE
|
|
BREAK
|
|
|
|
ENDSWITCH
|
|
|
|
IF bReturnTrueOnce
|
|
RETURN FALSE
|
|
ELSE
|
|
RETURN thisSwitchCam.bIsSplineCamFinishedPlaying
|
|
ENDIF
|
|
ENDFUNC
|
|
|
|
|
|
PROC SETUP_SPLINE_CAM_NODE_ARRAY_HELI_TREVOR_TO_MICHAEL(SWITCH_CAM_STRUCT &thisSwitchCam, PED_INDEX piTrevor, PED_INDEX piMichael)
|
|
CDEBUG3LN(DEBUG_MISSION, "SETUP_SPLINE_CAM_NODE_ARRAY_HELI_TREVOR_TO_MICHAEL")
|
|
|
|
//IF NOT thisSwitchCam.bInitialized
|
|
|
|
|
|
//--- Start of Cam Data ---
|
|
|
|
|
|
thisSwitchCam.nodes[0].SwitchCamType = SWITCH_CAM_GAMEPLAY_CAM_COPY
|
|
thisSwitchCam.nodes[0].iForceCamPointAtEntityIndex = 1
|
|
thisSwitchCam.nodes[0].bIsGameplayCamCopy = TRUE
|
|
thisSwitchCam.nodes[0].iNodeTime = 0
|
|
thisSwitchCam.nodes[0].vNodePos = <<94.2251, -1245.5797, 145.5685>>
|
|
thisSwitchCam.nodes[0].vWorldPosLookAt = <<0.0000, 0.0000, 0.0000>>
|
|
thisSwitchCam.nodes[0].fNodeOffsetDist = 0.0000
|
|
thisSwitchCam.nodes[0].fNodeVerticleOffset = 0.0000
|
|
thisSwitchCam.nodes[0].bAttachToOriginPed = FALSE
|
|
thisSwitchCam.nodes[0].vNodeDir = <<-23.5406, 9.1208, -84.6748>>
|
|
thisSwitchCam.nodes[0].bPointAtEntity = TRUE
|
|
thisSwitchCam.nodes[0].bPointAtOffsetIsRelative = TRUE
|
|
thisSwitchCam.nodes[0].bAttachOffsetIsRelative = TRUE
|
|
thisSwitchCam.nodes[0].fNodeFOV = 0.0
|
|
thisSwitchCam.nodes[0].vClonedNodeOffset = <<0.0000, 0.0000, 0.0000>>
|
|
thisSwitchCam.nodes[0].iNodeToClone = 0
|
|
thisSwitchCam.nodes[0].NodeTimePostFX_Type = NO_EFFECT
|
|
thisSwitchCam.nodes[0].fNodeTimePostFXBlendTime = 0.0000
|
|
thisSwitchCam.nodes[0].fNodeTimePostFXTimeOffset = 0.0000
|
|
thisSwitchCam.nodes[0].fNodeMotionBlur = 0.2000
|
|
thisSwitchCam.nodes[0].NodeCamShakeType = CAM_SHAKE_DEFAULT
|
|
thisSwitchCam.nodes[0].fNodeCamShake = 0.0000
|
|
thisSwitchCam.nodes[0].iCamEaseType = 0
|
|
thisSwitchCam.nodes[0].fCamEaseScaler = 0.0000
|
|
thisSwitchCam.nodes[0].fCamNodeVelocityScale = 0.0000
|
|
thisSwitchCam.nodes[0].bCamEaseForceLinear = FALSE
|
|
thisSwitchCam.nodes[0].bCamEaseForceLevel = FALSE
|
|
thisSwitchCam.nodes[0].fTimeScale = 0.0100
|
|
thisSwitchCam.nodes[0].iTimeScaleEaseType = 0
|
|
thisSwitchCam.nodes[0].fTimeScaleEaseScaler = 0.0000
|
|
thisSwitchCam.nodes[0].bFlashEnabled = TRUE
|
|
thisSwitchCam.nodes[0].SCFE_FlashEffectUsed = SCFE_SwitchShortTrevorIn
|
|
thisSwitchCam.nodes[0].fMinExposure = 0.0000
|
|
thisSwitchCam.nodes[0].fMaxExposure = 0.0000
|
|
thisSwitchCam.nodes[0].iRampUpDuration = 0
|
|
thisSwitchCam.nodes[0].iRampDownDuration = 0
|
|
thisSwitchCam.nodes[0].iHoldDuration = 0
|
|
thisSwitchCam.nodes[0].fFlashNodePhaseOffset = 0.0000
|
|
thisSwitchCam.nodes[0].bIsLowDetailNode = FALSE
|
|
thisSwitchCam.nodes[0].bUseCustomDOF = FALSE
|
|
thisSwitchCam.nodes[0].NodeDOF_Info.fDOF_NearDOF = 0.0000
|
|
thisSwitchCam.nodes[0].NodeDOF_Info.fDOF_FarDOF = 0.0000
|
|
thisSwitchCam.nodes[0].NodeDOF_Info.fDOF_EffectStrength = 0.0000
|
|
|
|
thisSwitchCam.nodes[1].SwitchCamType = SWITCH_ENTITY_ATTACHED_CAM
|
|
thisSwitchCam.nodes[1].iForceCamPointAtEntityIndex = 1
|
|
thisSwitchCam.nodes[1].bIsGameplayCamCopy = FALSE
|
|
thisSwitchCam.nodes[1].iNodeTime = 100
|
|
thisSwitchCam.nodes[1].vNodePos = <<4.0000, -11.0000, 1.1000>>
|
|
thisSwitchCam.nodes[1].vWorldPosLookAt = <<0.0000, 0.0000, 0.8000>>
|
|
thisSwitchCam.nodes[1].fNodeOffsetDist = 5.0000
|
|
thisSwitchCam.nodes[1].fNodeVerticleOffset = 0.0000
|
|
thisSwitchCam.nodes[1].bAttachToOriginPed = FALSE
|
|
thisSwitchCam.nodes[1].vNodeDir = <<0.0000, 0.0000, 0.8000>>
|
|
thisSwitchCam.nodes[1].bPointAtEntity = TRUE
|
|
thisSwitchCam.nodes[1].bPointAtOffsetIsRelative = TRUE
|
|
thisSwitchCam.nodes[1].bAttachOffsetIsRelative = TRUE
|
|
thisSwitchCam.nodes[1].fNodeFOV = 69.0000
|
|
thisSwitchCam.nodes[1].vClonedNodeOffset = <<0.0000, 0.0000, 0.0000>>
|
|
thisSwitchCam.nodes[1].iNodeToClone = 0
|
|
thisSwitchCam.nodes[1].NodeTimePostFX_Type = NO_EFFECT
|
|
thisSwitchCam.nodes[1].fNodeTimePostFXBlendTime = 0.0000
|
|
thisSwitchCam.nodes[1].fNodeTimePostFXTimeOffset = 0.0000
|
|
thisSwitchCam.nodes[1].fNodeMotionBlur = 0.3000
|
|
thisSwitchCam.nodes[1].NodeCamShakeType = CAM_SHAKE_DEFAULT
|
|
thisSwitchCam.nodes[1].fNodeCamShake = 0.0000
|
|
thisSwitchCam.nodes[1].iCamEaseType = 0
|
|
thisSwitchCam.nodes[1].fCamEaseScaler = 0.0000
|
|
thisSwitchCam.nodes[1].fCamNodeVelocityScale = 0.0000
|
|
thisSwitchCam.nodes[1].bCamEaseForceLinear = FALSE
|
|
thisSwitchCam.nodes[1].bCamEaseForceLevel = FALSE
|
|
thisSwitchCam.nodes[1].fTimeScale = 0.0100
|
|
thisSwitchCam.nodes[1].iTimeScaleEaseType = 0
|
|
thisSwitchCam.nodes[1].fTimeScaleEaseScaler = 0.0000
|
|
thisSwitchCam.nodes[1].bFlashEnabled = FALSE
|
|
thisSwitchCam.nodes[1].SCFE_FlashEffectUsed = SCFE_CODE_FLASH
|
|
thisSwitchCam.nodes[1].fMinExposure = 0.0000
|
|
thisSwitchCam.nodes[1].fMaxExposure = 0.0000
|
|
thisSwitchCam.nodes[1].iRampUpDuration = 0
|
|
thisSwitchCam.nodes[1].iRampDownDuration = 0
|
|
thisSwitchCam.nodes[1].iHoldDuration = 0
|
|
thisSwitchCam.nodes[1].fFlashNodePhaseOffset = 0.0000
|
|
thisSwitchCam.nodes[1].bIsLowDetailNode = FALSE
|
|
thisSwitchCam.nodes[1].bUseCustomDOF = FALSE
|
|
thisSwitchCam.nodes[1].NodeDOF_Info.fDOF_NearDOF = 0.0000
|
|
thisSwitchCam.nodes[1].NodeDOF_Info.fDOF_FarDOF = 0.0000
|
|
thisSwitchCam.nodes[1].NodeDOF_Info.fDOF_EffectStrength = 0.0000
|
|
|
|
thisSwitchCam.nodes[2].SwitchCamType = SWITCH_ENTITY_ATTACHED_CAM
|
|
thisSwitchCam.nodes[2].iForceCamPointAtEntityIndex = 1
|
|
thisSwitchCam.nodes[2].bIsGameplayCamCopy = FALSE
|
|
thisSwitchCam.nodes[2].iNodeTime = 900
|
|
thisSwitchCam.nodes[2].vNodePos = <<5.0000, -5.0000, 0.6000>>
|
|
thisSwitchCam.nodes[2].vWorldPosLookAt = <<0.0000, 0.0000, 0.8000>>
|
|
thisSwitchCam.nodes[2].fNodeOffsetDist = 0.0000
|
|
thisSwitchCam.nodes[2].fNodeVerticleOffset = 0.0000
|
|
thisSwitchCam.nodes[2].bAttachToOriginPed = FALSE
|
|
thisSwitchCam.nodes[2].vNodeDir = <<0.0000, 0.0000, 0.8000>>
|
|
thisSwitchCam.nodes[2].bPointAtEntity = TRUE
|
|
thisSwitchCam.nodes[2].bPointAtOffsetIsRelative = TRUE
|
|
thisSwitchCam.nodes[2].bAttachOffsetIsRelative = TRUE
|
|
thisSwitchCam.nodes[2].fNodeFOV = 50.0000
|
|
thisSwitchCam.nodes[2].vClonedNodeOffset = <<0.0000, 0.0000, 0.0000>>
|
|
thisSwitchCam.nodes[2].iNodeToClone = 0
|
|
thisSwitchCam.nodes[2].NodeTimePostFX_Type = NO_EFFECT
|
|
thisSwitchCam.nodes[2].fNodeTimePostFXBlendTime = 0.0000
|
|
thisSwitchCam.nodes[2].fNodeTimePostFXTimeOffset = 0.0000
|
|
thisSwitchCam.nodes[2].fNodeMotionBlur = 0.3000
|
|
thisSwitchCam.nodes[2].NodeCamShakeType = CAM_SHAKE_DEFAULT
|
|
thisSwitchCam.nodes[2].fNodeCamShake = 0.0000
|
|
thisSwitchCam.nodes[2].iCamEaseType = 0
|
|
thisSwitchCam.nodes[2].fCamEaseScaler = 0.0000
|
|
thisSwitchCam.nodes[2].fCamNodeVelocityScale = 0.0000
|
|
thisSwitchCam.nodes[2].bCamEaseForceLinear = FALSE
|
|
thisSwitchCam.nodes[2].bCamEaseForceLevel = FALSE
|
|
thisSwitchCam.nodes[2].fTimeScale = 0.0100
|
|
thisSwitchCam.nodes[2].iTimeScaleEaseType = 0
|
|
thisSwitchCam.nodes[2].fTimeScaleEaseScaler = 0.0000
|
|
thisSwitchCam.nodes[2].bFlashEnabled = FALSE
|
|
thisSwitchCam.nodes[2].SCFE_FlashEffectUsed = SCFE_CODE_FLASH
|
|
thisSwitchCam.nodes[2].fMinExposure = 0.0000
|
|
thisSwitchCam.nodes[2].fMaxExposure = 0.0000
|
|
thisSwitchCam.nodes[2].iRampUpDuration = 0
|
|
thisSwitchCam.nodes[2].iRampDownDuration = 0
|
|
thisSwitchCam.nodes[2].iHoldDuration = 0
|
|
thisSwitchCam.nodes[2].fFlashNodePhaseOffset = 0.0000
|
|
thisSwitchCam.nodes[2].bIsLowDetailNode = FALSE
|
|
thisSwitchCam.nodes[2].bUseCustomDOF = FALSE
|
|
thisSwitchCam.nodes[2].NodeDOF_Info.fDOF_NearDOF = 0.0000
|
|
thisSwitchCam.nodes[2].NodeDOF_Info.fDOF_FarDOF = 0.0000
|
|
thisSwitchCam.nodes[2].NodeDOF_Info.fDOF_EffectStrength = 0.0000
|
|
|
|
thisSwitchCam.nodes[3].SwitchCamType = SWITCH_ENTITY_ATTACHED_CAM
|
|
thisSwitchCam.nodes[3].iForceCamPointAtEntityIndex = 1
|
|
thisSwitchCam.nodes[3].bIsGameplayCamCopy = FALSE
|
|
thisSwitchCam.nodes[3].iNodeTime = 1000
|
|
thisSwitchCam.nodes[3].vNodePos = <<2.5000, -0.4000, 0.3000>>
|
|
thisSwitchCam.nodes[3].vWorldPosLookAt = <<0.0000, 0.0000, 0.8000>>
|
|
thisSwitchCam.nodes[3].fNodeOffsetDist = 0.0000
|
|
thisSwitchCam.nodes[3].fNodeVerticleOffset = 0.0000
|
|
thisSwitchCam.nodes[3].bAttachToOriginPed = FALSE
|
|
thisSwitchCam.nodes[3].vNodeDir = <<0.0000, 0.0000, 0.8000>>
|
|
thisSwitchCam.nodes[3].bPointAtEntity = TRUE
|
|
thisSwitchCam.nodes[3].bPointAtOffsetIsRelative = TRUE
|
|
thisSwitchCam.nodes[3].bAttachOffsetIsRelative = TRUE
|
|
thisSwitchCam.nodes[3].fNodeFOV = 50.0000
|
|
thisSwitchCam.nodes[3].vClonedNodeOffset = <<0.0000, 0.0000, 0.0000>>
|
|
thisSwitchCam.nodes[3].iNodeToClone = 0
|
|
thisSwitchCam.nodes[3].NodeTimePostFX_Type = NO_EFFECT
|
|
thisSwitchCam.nodes[3].fNodeTimePostFXBlendTime = 0.0000
|
|
thisSwitchCam.nodes[3].fNodeTimePostFXTimeOffset = 0.0000
|
|
thisSwitchCam.nodes[3].fNodeMotionBlur = 0.3000
|
|
thisSwitchCam.nodes[3].NodeCamShakeType = CAM_SHAKE_DEFAULT
|
|
thisSwitchCam.nodes[3].fNodeCamShake = 0.0000
|
|
thisSwitchCam.nodes[3].iCamEaseType = 0
|
|
thisSwitchCam.nodes[3].fCamEaseScaler = 0.0000
|
|
thisSwitchCam.nodes[3].fCamNodeVelocityScale = 0.3720
|
|
thisSwitchCam.nodes[3].bCamEaseForceLinear = FALSE
|
|
thisSwitchCam.nodes[3].bCamEaseForceLevel = FALSE
|
|
thisSwitchCam.nodes[3].fTimeScale = 0.0100
|
|
thisSwitchCam.nodes[3].iTimeScaleEaseType = 0
|
|
thisSwitchCam.nodes[3].fTimeScaleEaseScaler = 0.0000
|
|
thisSwitchCam.nodes[3].bFlashEnabled = TRUE
|
|
thisSwitchCam.nodes[3].SCFE_FlashEffectUsed = SCFE_SwitchShortMichaelMid
|
|
thisSwitchCam.nodes[3].fMinExposure = 0.0000
|
|
thisSwitchCam.nodes[3].fMaxExposure = 0.0000
|
|
thisSwitchCam.nodes[3].iRampUpDuration = 0
|
|
thisSwitchCam.nodes[3].iRampDownDuration = 0
|
|
thisSwitchCam.nodes[3].iHoldDuration = 0
|
|
thisSwitchCam.nodes[3].fFlashNodePhaseOffset = 0.9000
|
|
thisSwitchCam.nodes[3].bIsLowDetailNode = FALSE
|
|
thisSwitchCam.nodes[3].bUseCustomDOF = FALSE
|
|
thisSwitchCam.nodes[3].NodeDOF_Info.fDOF_NearDOF = 0.0000
|
|
thisSwitchCam.nodes[3].NodeDOF_Info.fDOF_FarDOF = 0.0000
|
|
thisSwitchCam.nodes[3].NodeDOF_Info.fDOF_EffectStrength = 0.0000
|
|
|
|
INT i
|
|
REPEAT COUNT_OF(thisSwitchCam.camVelocityOverrides) i
|
|
thisSwitchCam.camVelocityOverrides[i].fStartPoint = 0.0
|
|
thisSwitchCam.camVelocityOverrides[i].fSpeed = -1
|
|
ENDREPEAT
|
|
|
|
|
|
thisSwitchCam.camVelocityOverrides[0].fStartPoint = 0.0000
|
|
thisSwitchCam.camVelocityOverrides[0].fSpeed = 10.0000
|
|
thisSwitchCam.camVelocityOverrides[1].fStartPoint = 1.0000
|
|
thisSwitchCam.camVelocityOverrides[1].fSpeed = 50.0000
|
|
thisSwitchCam.camVelocityOverrides[2].fStartPoint = 3.0000
|
|
thisSwitchCam.camVelocityOverrides[2].fSpeed = 50.0000
|
|
thisSwitchCam.camVelocityOverrides[3].fStartPoint = 3.6000
|
|
thisSwitchCam.camVelocityOverrides[3].fSpeed = 20.0000
|
|
thisSwitchCam.camVelocityOverrides[4].fStartPoint = 3.9000
|
|
thisSwitchCam.camVelocityOverrides[4].fSpeed = 10.0000
|
|
thisSwitchCam.camVelocityOverrides[5].fStartPoint = 4.0000
|
|
thisSwitchCam.camVelocityOverrides[5].fSpeed = 5.0000
|
|
|
|
|
|
thisSwitchCam.iNumNodes = 4
|
|
thisSwitchCam.iCamSwitchFocusNode = 1
|
|
thisSwitchCam.fSwitchSoundAudioStartPhase = 0.01
|
|
thisSwitchCam.fSwitchSoundAudioEndPhase = 0.6
|
|
thisSwitchCam.bSwitchSoundPlayOpeningPulse = TRUE
|
|
thisSwitchCam.bSwitchSoundPlayMoveLoop = TRUE
|
|
thisSwitchCam.bSwitchSoundPlayExitPulse = TRUE
|
|
thisSwitchCam.bSplineNoSmoothing = FALSE
|
|
thisSwitchCam.bAddGameplayCamAsLastNode = TRUE
|
|
thisSwitchCam.iGameplayNodeBlendDuration = 100
|
|
|
|
|
|
//--- End of Cam Data ---
|
|
|
|
|
|
thisSwitchCam.strOutputStructName = "thisSwitchCam"
|
|
thisSwitchCam.strOutputFileName = "CameraInfo_FIB2_HeliTrevorToMichael.txt"
|
|
thisSwitchCam.strXMLFileName = "CameraInfo_FIB2_HeliTrevorToMichael.xml"
|
|
|
|
thisSwitchCam.bInitialized = TRUE
|
|
//ENDIF
|
|
|
|
thisSwitchCam.piPeds[0] = piTrevor
|
|
thisSwitchCam.piPeds[1] = piMichael
|
|
|
|
|
|
ENDPROC
|
|
|
|
PROC SETUP_SPLINE_CAM_NODE_ARRAY_HELI_TREVOR_TO_MICHAEL_FIRST_PERSON(SWITCH_CAM_STRUCT &thisSwitchCam, PED_INDEX piTrevor, PED_INDEX piMichael)
|
|
CDEBUG3LN(DEBUG_MISSION, "SETUP_SPLINE_CAM_NODE_ARRAY_HELI_MICHAEL_TO_FRANKLIN")
|
|
|
|
//IF NOT thisSwitchCam.bInitialized
|
|
|
|
|
|
//--- Start of Cam Data ---
|
|
|
|
|
|
thisSwitchCam.nodes[0].SwitchCamType = SWITCH_CAM_OLD_SYSTEM
|
|
thisSwitchCam.nodes[0].iForceCamPointAtEntityIndex = -1
|
|
thisSwitchCam.nodes[0].bIsGameplayCamCopy = FALSE
|
|
thisSwitchCam.nodes[0].iNodeTime = 0
|
|
thisSwitchCam.nodes[0].vNodePos = <<-1.6125, 2.0081, 0.6774>>
|
|
thisSwitchCam.nodes[0].vWorldPosLookAt = <<0.0000, 0.0000, 0.0000>>
|
|
thisSwitchCam.nodes[0].fNodeOffsetDist = 0.0000
|
|
thisSwitchCam.nodes[0].fNodeVerticleOffset = 0.0000
|
|
thisSwitchCam.nodes[0].bAttachToOriginPed = FALSE
|
|
thisSwitchCam.nodes[0].vNodeDir = <<-0.5, 0.9, 0.3>>
|
|
thisSwitchCam.nodes[0].bPointAtEntity = TRUE
|
|
thisSwitchCam.nodes[0].bPointAtOffsetIsRelative = TRUE
|
|
thisSwitchCam.nodes[0].bAttachOffsetIsRelative = TRUE
|
|
thisSwitchCam.nodes[0].fNodeFOV = 40.0000
|
|
thisSwitchCam.nodes[0].vClonedNodeOffset = <<0.0000, 0.0000, 0.0000>>
|
|
thisSwitchCam.nodes[0].iNodeToClone = 0
|
|
thisSwitchCam.nodes[0].NodeTimePostFX_Type = NO_EFFECT
|
|
thisSwitchCam.nodes[0].fNodeTimePostFXBlendTime = 0.0000
|
|
thisSwitchCam.nodes[0].fNodeTimePostFXTimeOffset = 0.0000
|
|
thisSwitchCam.nodes[0].fNodeMotionBlur = 0.0000
|
|
thisSwitchCam.nodes[0].NodeCamShakeType = CAM_SHAKE_DEFAULT
|
|
thisSwitchCam.nodes[0].fNodeCamShake = 0.5000
|
|
thisSwitchCam.nodes[0].iCamEaseType = 0
|
|
thisSwitchCam.nodes[0].fCamEaseScaler = 0.0000
|
|
thisSwitchCam.nodes[0].fCamNodeVelocityScale = 0.0000
|
|
thisSwitchCam.nodes[0].bCamEaseForceLinear = FALSE
|
|
thisSwitchCam.nodes[0].bCamEaseForceLevel = FALSE
|
|
thisSwitchCam.nodes[0].fTimeScale = 1.0000
|
|
thisSwitchCam.nodes[0].iTimeScaleEaseType = 0
|
|
thisSwitchCam.nodes[0].fTimeScaleEaseScaler = 0.0000
|
|
thisSwitchCam.nodes[0].bFlashEnabled = TRUE
|
|
thisSwitchCam.nodes[0].SCFE_FlashEffectUsed = SCFE_SwitchShortTrevorIn
|
|
thisSwitchCam.nodes[0].fMinExposure = 0.0000
|
|
thisSwitchCam.nodes[0].fMaxExposure = 0.0000
|
|
thisSwitchCam.nodes[0].iRampUpDuration = 0
|
|
thisSwitchCam.nodes[0].iRampDownDuration = 0
|
|
thisSwitchCam.nodes[0].iHoldDuration = 0
|
|
thisSwitchCam.nodes[0].fFlashNodePhaseOffset = 0.0000
|
|
thisSwitchCam.nodes[0].bIsLowDetailNode = FALSE
|
|
thisSwitchCam.nodes[0].bUseCustomDOF = FALSE
|
|
thisSwitchCam.nodes[0].NodeDOF_Info.fDOF_NearDOF = 0.0000
|
|
thisSwitchCam.nodes[0].NodeDOF_Info.fDOF_FarDOF = 0.0000
|
|
thisSwitchCam.nodes[0].NodeDOF_Info.fDOF_EffectStrength = 0.0000
|
|
|
|
thisSwitchCam.nodes[1].SwitchCamType = SWITCH_CAM_OLD_SYSTEM
|
|
thisSwitchCam.nodes[1].iForceCamPointAtEntityIndex = -1
|
|
thisSwitchCam.nodes[1].bIsGameplayCamCopy = FALSE
|
|
thisSwitchCam.nodes[1].iNodeTime = 400
|
|
thisSwitchCam.nodes[1].vNodePos = <<-1.7125, 1.8081, 0.5774>>
|
|
thisSwitchCam.nodes[1].vWorldPosLookAt = <<0.0000, 0.0000, 0.0000>>
|
|
thisSwitchCam.nodes[1].fNodeOffsetDist = 0.0000
|
|
thisSwitchCam.nodes[1].fNodeVerticleOffset = 0.0000
|
|
thisSwitchCam.nodes[1].bAttachToOriginPed = FALSE
|
|
thisSwitchCam.nodes[1].vNodeDir = <<-0.5, 0.6, 0.3>>
|
|
thisSwitchCam.nodes[1].bPointAtEntity = TRUE
|
|
thisSwitchCam.nodes[1].bPointAtOffsetIsRelative = TRUE
|
|
thisSwitchCam.nodes[1].bAttachOffsetIsRelative = TRUE
|
|
thisSwitchCam.nodes[1].fNodeFOV = 40.0000
|
|
thisSwitchCam.nodes[1].vClonedNodeOffset = <<0.0000, 0.0000, 0.0000>>
|
|
thisSwitchCam.nodes[1].iNodeToClone = 0
|
|
thisSwitchCam.nodes[1].NodeTimePostFX_Type = NO_EFFECT
|
|
thisSwitchCam.nodes[1].fNodeTimePostFXBlendTime = 0.0000
|
|
thisSwitchCam.nodes[1].fNodeTimePostFXTimeOffset = 0.0000
|
|
thisSwitchCam.nodes[1].fNodeMotionBlur = 1.0000
|
|
thisSwitchCam.nodes[1].NodeCamShakeType = CAM_SHAKE_MEDIUM
|
|
thisSwitchCam.nodes[1].fNodeCamShake = 0.5000
|
|
thisSwitchCam.nodes[1].iCamEaseType = 0
|
|
thisSwitchCam.nodes[1].fCamEaseScaler = 0.0000
|
|
thisSwitchCam.nodes[1].fCamNodeVelocityScale = 0.0000
|
|
thisSwitchCam.nodes[1].bCamEaseForceLinear = FALSE
|
|
thisSwitchCam.nodes[1].bCamEaseForceLevel = FALSE
|
|
thisSwitchCam.nodes[1].fTimeScale = 0.3
|
|
thisSwitchCam.nodes[1].iTimeScaleEaseType = 0
|
|
thisSwitchCam.nodes[1].fTimeScaleEaseScaler = 0.0000
|
|
thisSwitchCam.nodes[1].bFlashEnabled = FALSE
|
|
thisSwitchCam.nodes[1].SCFE_FlashEffectUsed = SCFE_CODE_FLASH
|
|
thisSwitchCam.nodes[1].fMinExposure = 0.0000
|
|
thisSwitchCam.nodes[1].fMaxExposure = 0.0000
|
|
thisSwitchCam.nodes[1].iRampUpDuration = 0
|
|
thisSwitchCam.nodes[1].iRampDownDuration = 0
|
|
thisSwitchCam.nodes[1].iHoldDuration = 0
|
|
thisSwitchCam.nodes[1].fFlashNodePhaseOffset = 0.3000
|
|
thisSwitchCam.nodes[1].bIsLowDetailNode = FALSE
|
|
thisSwitchCam.nodes[1].bUseCustomDOF = FALSE
|
|
thisSwitchCam.nodes[1].NodeDOF_Info.fDOF_NearDOF = 0.0000
|
|
thisSwitchCam.nodes[1].NodeDOF_Info.fDOF_FarDOF = 0.0000
|
|
thisSwitchCam.nodes[1].NodeDOF_Info.fDOF_EffectStrength = 0.0000
|
|
|
|
thisSwitchCam.nodes[2].SwitchCamType = SWITCH_CAM_OLD_SYSTEM
|
|
thisSwitchCam.nodes[2].iForceCamPointAtEntityIndex = -1
|
|
thisSwitchCam.nodes[2].bIsGameplayCamCopy = FALSE
|
|
thisSwitchCam.nodes[2].iNodeTime = 600
|
|
thisSwitchCam.nodes[2].vNodePos = <<-1.9125, 1.3081, -0.1774>>
|
|
thisSwitchCam.nodes[2].vWorldPosLookAt = <<0.0000, 0.0000, 0.0000>>
|
|
thisSwitchCam.nodes[2].fNodeOffsetDist = 0.0000
|
|
thisSwitchCam.nodes[2].fNodeVerticleOffset = 0.0000
|
|
thisSwitchCam.nodes[2].bAttachToOriginPed = FALSE
|
|
thisSwitchCam.nodes[2].vNodeDir = <<0, -1, 0.6>>
|
|
thisSwitchCam.nodes[2].bPointAtEntity = TRUE
|
|
thisSwitchCam.nodes[2].bPointAtOffsetIsRelative = TRUE
|
|
thisSwitchCam.nodes[2].bAttachOffsetIsRelative = TRUE
|
|
thisSwitchCam.nodes[2].fNodeFOV = 40.0000
|
|
thisSwitchCam.nodes[2].vClonedNodeOffset = <<0.0000, 0.0000, 0.0000>>
|
|
thisSwitchCam.nodes[2].iNodeToClone = 0
|
|
thisSwitchCam.nodes[2].NodeTimePostFX_Type = NO_EFFECT
|
|
thisSwitchCam.nodes[2].fNodeTimePostFXBlendTime = 0.0000
|
|
thisSwitchCam.nodes[2].fNodeTimePostFXTimeOffset = 0.0000
|
|
thisSwitchCam.nodes[2].fNodeMotionBlur = 1.0000
|
|
thisSwitchCam.nodes[2].NodeCamShakeType = CAM_SHAKE_MEDIUM
|
|
thisSwitchCam.nodes[2].fNodeCamShake = 0.5000
|
|
thisSwitchCam.nodes[2].iCamEaseType = 0
|
|
thisSwitchCam.nodes[2].fCamEaseScaler = 0.0000
|
|
thisSwitchCam.nodes[2].fCamNodeVelocityScale = 0.6000
|
|
thisSwitchCam.nodes[2].bCamEaseForceLinear = FALSE
|
|
thisSwitchCam.nodes[2].bCamEaseForceLevel = FALSE
|
|
thisSwitchCam.nodes[2].fTimeScale = 0.3
|
|
thisSwitchCam.nodes[2].iTimeScaleEaseType = 0
|
|
thisSwitchCam.nodes[2].fTimeScaleEaseScaler = 0.0000
|
|
thisSwitchCam.nodes[2].bFlashEnabled = TRUE
|
|
thisSwitchCam.nodes[2].SCFE_FlashEffectUsed = SCFE_SwitchShortMichaelMid
|
|
thisSwitchCam.nodes[2].fMinExposure = 0.0000
|
|
thisSwitchCam.nodes[2].fMaxExposure = 0.0000
|
|
thisSwitchCam.nodes[2].iRampUpDuration = 0
|
|
thisSwitchCam.nodes[2].iRampDownDuration = 0
|
|
thisSwitchCam.nodes[2].iHoldDuration = 0
|
|
thisSwitchCam.nodes[2].fFlashNodePhaseOffset = 0.0000
|
|
thisSwitchCam.nodes[2].bIsLowDetailNode = FALSE
|
|
thisSwitchCam.nodes[2].bUseCustomDOF = FALSE
|
|
thisSwitchCam.nodes[2].NodeDOF_Info.fDOF_NearDOF = 0.0000
|
|
thisSwitchCam.nodes[2].NodeDOF_Info.fDOF_FarDOF = 0.0000
|
|
thisSwitchCam.nodes[2].NodeDOF_Info.fDOF_EffectStrength = 0.0000
|
|
|
|
thisSwitchCam.nodes[3].SwitchCamType = SWITCH_CAM_OLD_SYSTEM
|
|
thisSwitchCam.nodes[3].iForceCamPointAtEntityIndex = -1
|
|
thisSwitchCam.nodes[3].bIsGameplayCamCopy = FALSE
|
|
thisSwitchCam.nodes[3].iNodeTime = 400
|
|
thisSwitchCam.nodes[3].vNodePos = <<-1.9125, 1.3081, -0.1774>>
|
|
thisSwitchCam.nodes[3].vWorldPosLookAt = <<0.0000, 0.0000, 0.0000>>
|
|
thisSwitchCam.nodes[3].fNodeOffsetDist = 0.0000
|
|
thisSwitchCam.nodes[3].fNodeVerticleOffset = 0.0000
|
|
thisSwitchCam.nodes[3].bAttachToOriginPed = FALSE
|
|
thisSwitchCam.nodes[3].vNodeDir = <<0, -1, 0.6>>
|
|
thisSwitchCam.nodes[3].bPointAtEntity = TRUE
|
|
thisSwitchCam.nodes[3].bPointAtOffsetIsRelative = TRUE
|
|
thisSwitchCam.nodes[3].bAttachOffsetIsRelative = TRUE
|
|
thisSwitchCam.nodes[3].fNodeFOV = 40.0000
|
|
thisSwitchCam.nodes[3].vClonedNodeOffset = <<0.0000, 0.0000, 0.0000>>
|
|
thisSwitchCam.nodes[3].iNodeToClone = 0
|
|
thisSwitchCam.nodes[3].NodeTimePostFX_Type = NO_EFFECT
|
|
thisSwitchCam.nodes[3].fNodeTimePostFXBlendTime = 0.0000
|
|
thisSwitchCam.nodes[3].fNodeTimePostFXTimeOffset = 0.0000
|
|
thisSwitchCam.nodes[3].fNodeMotionBlur = 0.0000
|
|
thisSwitchCam.nodes[3].NodeCamShakeType = CAM_SHAKE_MEDIUM
|
|
thisSwitchCam.nodes[3].fNodeCamShake = 0.5000
|
|
thisSwitchCam.nodes[3].iCamEaseType = 0
|
|
thisSwitchCam.nodes[3].fCamEaseScaler = 0.0000
|
|
thisSwitchCam.nodes[3].fCamNodeVelocityScale = 0.0000
|
|
thisSwitchCam.nodes[3].bCamEaseForceLinear = FALSE
|
|
thisSwitchCam.nodes[3].bCamEaseForceLevel = FALSE
|
|
thisSwitchCam.nodes[3].fTimeScale = 1.0000
|
|
thisSwitchCam.nodes[3].iTimeScaleEaseType = 0
|
|
thisSwitchCam.nodes[3].fTimeScaleEaseScaler = 0.0000
|
|
thisSwitchCam.nodes[3].bFlashEnabled = FALSE
|
|
thisSwitchCam.nodes[3].SCFE_FlashEffectUsed = SCFE_CODE_FLASH
|
|
thisSwitchCam.nodes[3].fMinExposure = 0.0000
|
|
thisSwitchCam.nodes[3].fMaxExposure = 0.0000
|
|
thisSwitchCam.nodes[3].iRampUpDuration = 0
|
|
thisSwitchCam.nodes[3].iRampDownDuration = 0
|
|
thisSwitchCam.nodes[3].iHoldDuration = 0
|
|
thisSwitchCam.nodes[3].fFlashNodePhaseOffset = 0.0000
|
|
thisSwitchCam.nodes[3].bIsLowDetailNode = FALSE
|
|
thisSwitchCam.nodes[3].bUseCustomDOF = FALSE
|
|
thisSwitchCam.nodes[3].NodeDOF_Info.fDOF_NearDOF = 0.0000
|
|
thisSwitchCam.nodes[3].NodeDOF_Info.fDOF_FarDOF = 0.0000
|
|
thisSwitchCam.nodes[3].NodeDOF_Info.fDOF_EffectStrength = 0.0000
|
|
|
|
thisSwitchCam.iNumNodes = 4
|
|
thisSwitchCam.iCamSwitchFocusNode = 2
|
|
thisSwitchCam.fSwitchSoundAudioStartPhase = 0.25
|
|
thisSwitchCam.fSwitchSoundAudioEndPhase = 0.45
|
|
thisSwitchCam.bSwitchSoundPlayOpeningPulse = FALSE
|
|
thisSwitchCam.bSwitchSoundPlayMoveLoop = FALSE
|
|
thisSwitchCam.bSwitchSoundPlayExitPulse = FALSE
|
|
thisSwitchCam.bSplineNoSmoothing = FALSE
|
|
thisSwitchCam.bAddGameplayCamAsLastNode = FALSE
|
|
thisSwitchCam.iGameplayNodeBlendDuration = 0
|
|
|
|
INT i
|
|
REPEAT COUNT_OF(thisSwitchCam.camVelocityOverrides) i
|
|
thisSwitchCam.camVelocityOverrides[i].fStartPoint = 0.0
|
|
thisSwitchCam.camVelocityOverrides[i].fSpeed = -1
|
|
ENDREPEAT
|
|
|
|
//--- End of Cam Data ---
|
|
|
|
|
|
thisSwitchCam.strOutputStructName = "thisSwitchCam"
|
|
thisSwitchCam.strOutputFileName = "CameraInfo_FIB2_HeliMichaelToFranklin.txt"
|
|
thisSwitchCam.strXMLFileName = "CameraInfo_FIB2_HeliMichaelToFranklin.xml"
|
|
|
|
thisSwitchCam.bInitialized = TRUE
|
|
//ENDIF
|
|
|
|
thisSwitchCam.piPeds[0] = piTrevor
|
|
thisSwitchCam.piPeds[1] = piMichael
|
|
|
|
ENDPROC
|
|
|
|
/// PURPOSE:
|
|
/// Handle the playback of the switch cam. The will setup, play, shut down and cleanup the switch cam spline
|
|
/// PARAMS:
|
|
/// thisSwitchCam - Switch camera to playback
|
|
/// bReturnTrueOnce - If you only want this function to return TRUE once upon completion. Set to FALSE to have this function to return true every time this is called once the camera is finished playback.
|
|
/// RETURNS:
|
|
/// TRUE when camera is complete, FALSE if playback is still active, or if the camera has completed playback and bReturnTrueOnce is set to TRUE.
|
|
FUNC BOOL HANDLE_SWITCH_CAM_HELI_TREVOR_TO_MICHAEL(SWITCH_CAM_STRUCT &thisSwitchCam, BOOL bReturnTrueOnce = TRUE)
|
|
IS_PED_INJURED(GET_FRANKLIN_PED())
|
|
IS_PED_INJURED(GET_MICHAEL_PED())
|
|
IS_PED_INJURED(GET_TREVOR_PED())
|
|
IS_VEHICLE_DRIVEABLE(snatchAndGrabVehicle[SAGV_PLAYER_CHOPPER])
|
|
|
|
INT iCurrentNode
|
|
VECTOR vMichaelAimOutSideHeliLoc
|
|
VECTOR vHeliLocDebug
|
|
VECTOR vHeliForwardDebug
|
|
VECTOR vMichaelAimDirection
|
|
|
|
SWITCH eSwitchCamState
|
|
|
|
CASE SWITCH_CAM_IDLE
|
|
CDEBUG3LN(DEBUG_MISSION, "eSwitchCamState = SWITCH_CAM_IDLE")
|
|
RETURN FALSE
|
|
BREAK
|
|
|
|
CASE SWITCH_CAM_SETUP_SPLINE
|
|
CDEBUG3LN(DEBUG_MISSION, "eSwitchCamState = SWITCH_CAM_SETUP_SPLINE")
|
|
|
|
IF NOT bSwitchToFirstPerson
|
|
SETUP_SPLINE_CAM_NODE_ARRAY_HELI_TREVOR_TO_MICHAEL(thisSwitchCam, GET_TREVOR_PED(), GET_MICHAEL_PED())
|
|
ELSE
|
|
SETUP_SPLINE_CAM_NODE_ARRAY_HELI_TREVOR_TO_MICHAEL_FIRST_PERSON(thisSwitchCam, GET_TREVOR_PED(), GET_MICHAEL_PED())
|
|
ENDIF
|
|
|
|
IF DOES_SWITCH_CAM_EXIST(thisSwitchCam)
|
|
DESTROY_SWITCH_CAM(thisSwitchCam)
|
|
ENDIF
|
|
|
|
//[MF] Fix for the gameplay cam if it gets WAY outta position.
|
|
IF NOT bSwitchToFirstPerson
|
|
SET_THIRD_PERSON_CAM_RELATIVE_HEADING_LIMITS_THIS_UPDATE(-30.0, 20.0)
|
|
SET_THIRD_PERSON_CAM_RELATIVE_PITCH_LIMITS_THIS_UPDATE(-40.0, 40.0)
|
|
ENDIF
|
|
WAIT_WITH_RECORD()
|
|
|
|
CREATE_SPLINE_CAM(thisSwitchCam)
|
|
|
|
IF bSwitchToFirstPerson
|
|
INT i
|
|
REPEAT COUNT_OF(thisSwitchCam.nodes) i
|
|
IF DOES_CAM_EXIST(thisSwitchCam.nodes[i].ciSwitchNode)
|
|
SET_CAM_INHERIT_ROLL_VEHICLE(thisSwitchCam.nodes[i].ciSwitchNode, snatchAndGrabVehicle[SAGV_PLAYER_CHOPPER])
|
|
ENDIF
|
|
ENDREPEAT
|
|
ENDIF
|
|
|
|
SET_CAM_ACTIVE(thisSwitchCam.ciSpline, TRUE)
|
|
|
|
WAIT_WITH_RECORD()
|
|
|
|
RENDER_SCRIPT_CAMS(TRUE, FALSE)
|
|
|
|
DISPLAY_RADAR(FALSE)
|
|
DISPLAY_HUD(FALSE)
|
|
|
|
SETTIMERB(0)
|
|
|
|
SET_PLAYER_CONTROL(PLAYER_ID(), FALSE)
|
|
|
|
SET_GAME_PAUSES_FOR_STREAMING(FALSE)
|
|
|
|
IF NOT bSwitchToFirstPerson
|
|
IF NOT IS_PED_INJURED(GET_MICHAEL_PED())
|
|
CLEAR_PED_TASKS(GET_MICHAEL_PED())
|
|
SET_PED_FIRING_PATTERN(GET_MICHAEL_PED(), FIRING_PATTERN_FULL_AUTO)
|
|
ENDIF
|
|
ENDIF
|
|
|
|
bPlayerControlGiven = FALSE
|
|
|
|
IF IS_GAMEPLAY_HINT_ACTIVE()
|
|
STOP_GAMEPLAY_HINT(FALSE)
|
|
ENDIF
|
|
|
|
eSwitchCamState = SWITCH_CAM_PLAYING_SPLINE
|
|
RETURN TRUE
|
|
FALLTHRU
|
|
|
|
CASE SWITCH_CAM_PLAYING_SPLINE
|
|
CDEBUG3LN(DEBUG_MISSION, "eSwitchCamState = SWITCH_CAM_PLAYING_SPLINE")
|
|
CDEBUG3LN(DEBUG_MISSION, GET_CAM_SPLINE_PHASE(thisSwitchCam.ciSpline))
|
|
|
|
iCurrentNode = UPDATE_SPLINE_CAM(thisSwitchCam)
|
|
|
|
IF IS_CAM_ACTIVE(thisSwitchCam.ciSpline)
|
|
IF (iCurrentNode >= thisSwitchCam.iCamSwitchFocusNode AND NOT bSwitchToFirstPerson)
|
|
OR (GET_CAM_SPLINE_PHASE(thisSwitchCam.ciSpline) >= 1.00 AND bSwitchToFirstPerson)
|
|
sCamDetails.bOKToSwitchPed = TRUE
|
|
STOP_GAMEPLAY_HINT(TRUE)
|
|
ENDIF
|
|
|
|
IF bSwitchToFirstPerson
|
|
IF NOT bDoneHitSound
|
|
IF GET_GAME_TIMER() >= (iSnatchAndGrabCutsceneTime + 20)
|
|
PLAY_SOUND_FRONTEND(-1, "Hit_Out", "PLAYER_SWITCH_CUSTOM_SOUNDSET")
|
|
iHitTime = GET_GAME_TIMER()
|
|
bDoneHitSound = TRUE
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF NOT bWooshStarted
|
|
IF bDoneHitSound
|
|
IF GET_GAME_TIMER() >= iHitTime + 150
|
|
PLAY_SOUND_FRONTEND(-1, "Short_Transition_In", "PLAYER_SWITCH_CUSTOM_SOUNDSET")
|
|
bWooshStarted = TRUE
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF DOES_CAM_EXIST(thisSwitchCam.ciSpline)
|
|
IF NOT IS_PED_INJURED(GET_MICHAEL_PED())
|
|
//[MF] Have Michael already aiming behind the heli
|
|
//IF NOT bSwitchToFirstPerson
|
|
//OR GET_CAM_SPLINE_PHASE(thisSwitchCam.ciSpline) >= 0.25
|
|
IF NOT IS_SCRIPT_TASK_RUNNING_OR_STARTING(GET_MICHAEL_PED(), SCRIPT_TASK_DRIVE_BY)
|
|
//OR bSwitchToFirstPerson
|
|
//CLEAR_PED_TASKS(GET_MICHAEL_PED())
|
|
|
|
vHeliLocDebug = GET_ENTITY_COORDS(snatchAndGrabVehicle[SAGV_PLAYER_CHOPPER])
|
|
vHeliForwardDebug = GET_ENTITY_FORWARD_VECTOR(snatchAndGrabVehicle[SAGV_PLAYER_CHOPPER])
|
|
|
|
vMichaelAimDirection = ROTATE_VECTOR_ABOUT_Z(vHeliForwardDebug, fSwitchToMike_AimingHeading)
|
|
vMichaelAimDirection.Z = 0.0
|
|
|
|
vMichaelAimDirection = GET_VECTOR_OF_LENGTH(vMichaelAimDirection, 150)
|
|
|
|
vMichaelAimOutSideHeliLoc = (vHeliLocDebug + vMichaelAimDirection)
|
|
|
|
TASK_DRIVE_BY(GET_MICHAEL_PED(), NULL, NULL, vMichaelAimOutSideHeliLoc, 10000, 0, FALSE, FIRING_PATTERN_SINGLE_SHOT)
|
|
|
|
ENDIF
|
|
//ENDIF
|
|
|
|
ENDIF
|
|
|
|
//[MF] Once cam is at the end, reset the gameplay cam positon and advance to next state.
|
|
IF GET_CAM_SPLINE_PHASE(thisSwitchCam.ciSpline) >= 1.00
|
|
AND (GET_CURRENT_PLAYER_PED_ENUM() = CHAR_MICHAEL)
|
|
CDEBUG3LN(DEBUG_MISSION, "eSwitchCamState = SWITCH_CAM_RETURN_TO_GAMEPLAY")
|
|
RENDER_SCRIPT_CAMS(FALSE, FALSE)
|
|
eSwitchCamState = SWITCH_CAM_RETURN_TO_GAMEPLAY
|
|
ENDIF
|
|
|
|
ELSE
|
|
SCRIPT_ASSERT("Cam Prematurely Deleted! WTF?")
|
|
RENDER_SCRIPT_CAMS(FALSE, FALSE)
|
|
eSwitchCamState = SWITCH_CAM_RETURN_TO_GAMEPLAY
|
|
ENDIF
|
|
ENDIF
|
|
|
|
RETURN TRUE
|
|
BREAK
|
|
|
|
CASE SWITCH_CAM_RETURN_TO_GAMEPLAY
|
|
|
|
SET_TIME_SCALE(1.0)
|
|
|
|
RENDER_SCRIPT_CAMS(FALSE, FALSE)
|
|
|
|
IF DOES_CAM_EXIST(thisSwitchCam.ciSpline)
|
|
SET_CAM_ACTIVE(thisSwitchCam.ciSpline, FALSE)
|
|
ENDIF
|
|
|
|
IF DOES_SWITCH_CAM_EXIST(thisSwitchCam)
|
|
DESTROY_SWITCH_CAM(thisSwitchCam)
|
|
ENDIF
|
|
|
|
IF NOT bPlayerControlGiven
|
|
SET_PLAYER_CONTROL(PLAYER_ID(), TRUE)
|
|
DISPLAY_RADAR(TRUE)
|
|
DISPLAY_HUD(TRUE)
|
|
bPlayerControlGiven = TRUE
|
|
ENDIF
|
|
|
|
SETTIMERA(0)
|
|
|
|
eSwitchCamState = SWITCH_CAM_IDLE
|
|
|
|
thisSwitchCam.bIsSplineCamFinishedPlaying = TRUE
|
|
|
|
IF NOT IS_PED_INJURED(GET_MICHAEL_PED())
|
|
SET_PED_FIRING_PATTERN(GET_MICHAEL_PED(), FIRING_PATTERN_FULL_AUTO)
|
|
ENDIF
|
|
|
|
SET_PLAYER_CONTROL(PLAYER_ID(), true)
|
|
SET_GAME_PAUSES_FOR_STREAMING(TRUE)
|
|
|
|
sCamDetails.bSplineCreated = FALSE
|
|
|
|
sCamDetails.bOKToSwitchPed = FALSE
|
|
|
|
RETURN FALSE
|
|
BREAK
|
|
|
|
ENDSWITCH
|
|
|
|
IF bReturnTrueOnce
|
|
RETURN FALSE
|
|
ELSE
|
|
RETURN thisSwitchCam.bIsSplineCamFinishedPlaying
|
|
ENDIF
|
|
ENDFUNC
|
|
|
|
|
|
PROC SETUP_SPLINE_CAM_NODE_ARRAY_HELI_MICHAEL_TO_TREVOR(SWITCH_CAM_STRUCT &thisSwitchCam, PED_INDEX piTrevor, PED_INDEX piMichael)
|
|
CDEBUG3LN(DEBUG_MISSION, "SETUP_SPLINE_CAM_NODE_ARRAY_HELI_MICHAEL_TO_TREVOR")
|
|
|
|
//IF NOT thisSwitchCam.bInitialized
|
|
|
|
|
|
//--- Start of Cam Data ---
|
|
|
|
|
|
thisSwitchCam.nodes[0].SwitchCamType = SWITCH_CAM_GAMEPLAY_CAM_COPY
|
|
thisSwitchCam.nodes[0].iForceCamPointAtEntityIndex = 1
|
|
thisSwitchCam.nodes[0].bIsGameplayCamCopy = TRUE
|
|
thisSwitchCam.nodes[0].iNodeTime = 0
|
|
thisSwitchCam.nodes[0].vNodePos = <<296.6279, -1209.5647, 139.0910>>
|
|
thisSwitchCam.nodes[0].vWorldPosLookAt = <<0.0000, 0.0000, 0.0000>>
|
|
thisSwitchCam.nodes[0].fNodeOffsetDist = 0.0000
|
|
thisSwitchCam.nodes[0].fNodeVerticleOffset = 0.0000
|
|
thisSwitchCam.nodes[0].bAttachToOriginPed = FALSE
|
|
thisSwitchCam.nodes[0].vNodeDir = <<-2.8198, -7.8459, 83.1772>>
|
|
thisSwitchCam.nodes[0].bPointAtEntity = TRUE
|
|
thisSwitchCam.nodes[0].bPointAtOffsetIsRelative = TRUE
|
|
thisSwitchCam.nodes[0].bAttachOffsetIsRelative = TRUE
|
|
thisSwitchCam.nodes[0].fNodeFOV = 35.0000
|
|
thisSwitchCam.nodes[0].vClonedNodeOffset = <<0.0000, 0.0000, 0.0000>>
|
|
thisSwitchCam.nodes[0].iNodeToClone = 0
|
|
thisSwitchCam.nodes[0].NodeTimePostFX_Type = NO_EFFECT
|
|
thisSwitchCam.nodes[0].fNodeTimePostFXBlendTime = 0.0000
|
|
thisSwitchCam.nodes[0].fNodeTimePostFXTimeOffset = 0.0000
|
|
thisSwitchCam.nodes[0].fNodeMotionBlur = 0.2000
|
|
thisSwitchCam.nodes[0].NodeCamShakeType = CAM_SHAKE_DEFAULT
|
|
thisSwitchCam.nodes[0].fNodeCamShake = 0.0000
|
|
thisSwitchCam.nodes[0].iCamEaseType = 0
|
|
thisSwitchCam.nodes[0].fCamEaseScaler = 0.0000
|
|
thisSwitchCam.nodes[0].fCamNodeVelocityScale = 0.3000
|
|
thisSwitchCam.nodes[0].bCamEaseForceLinear = FALSE
|
|
thisSwitchCam.nodes[0].bCamEaseForceLevel = FALSE
|
|
thisSwitchCam.nodes[0].fTimeScale = 0.0100
|
|
thisSwitchCam.nodes[0].iTimeScaleEaseType = 0
|
|
thisSwitchCam.nodes[0].fTimeScaleEaseScaler = 0.0000
|
|
thisSwitchCam.nodes[0].bFlashEnabled = FALSE
|
|
thisSwitchCam.nodes[0].SCFE_FlashEffectUsed = SCFE_CODE_FLASH
|
|
thisSwitchCam.nodes[0].fMinExposure = 0.0000
|
|
thisSwitchCam.nodes[0].fMaxExposure = 0.0000
|
|
thisSwitchCam.nodes[0].iRampUpDuration = 0
|
|
thisSwitchCam.nodes[0].iRampDownDuration = 0
|
|
thisSwitchCam.nodes[0].iHoldDuration = 0
|
|
thisSwitchCam.nodes[0].fFlashNodePhaseOffset = 0.0000
|
|
thisSwitchCam.nodes[0].bIsLowDetailNode = FALSE
|
|
thisSwitchCam.nodes[0].bUseCustomDOF = FALSE
|
|
thisSwitchCam.nodes[0].NodeDOF_Info.fDOF_NearDOF = 0.0000
|
|
thisSwitchCam.nodes[0].NodeDOF_Info.fDOF_FarDOF = 0.0000
|
|
thisSwitchCam.nodes[0].NodeDOF_Info.fDOF_EffectStrength = 0.0000
|
|
|
|
thisSwitchCam.nodes[1].SwitchCamType = SWITCH_ENTITY_ATTACHED_CAM
|
|
thisSwitchCam.nodes[1].iForceCamPointAtEntityIndex = 1
|
|
thisSwitchCam.nodes[1].bIsGameplayCamCopy = FALSE
|
|
thisSwitchCam.nodes[1].iNodeTime = 1000
|
|
thisSwitchCam.nodes[1].vNodePos = <<2.5000, -1.1000, 0.3000>>
|
|
thisSwitchCam.nodes[1].vWorldPosLookAt = <<0.6000, 0.0000, 0.8000>>
|
|
thisSwitchCam.nodes[1].fNodeOffsetDist = 5.0000
|
|
thisSwitchCam.nodes[1].fNodeVerticleOffset = 0.0000
|
|
thisSwitchCam.nodes[1].bAttachToOriginPed = FALSE
|
|
thisSwitchCam.nodes[1].vNodeDir = <<0.0000, 0.0000, 0.8000>>
|
|
thisSwitchCam.nodes[1].bPointAtEntity = TRUE
|
|
thisSwitchCam.nodes[1].bPointAtOffsetIsRelative = TRUE
|
|
thisSwitchCam.nodes[1].bAttachOffsetIsRelative = TRUE
|
|
thisSwitchCam.nodes[1].fNodeFOV = 50.0000
|
|
thisSwitchCam.nodes[1].vClonedNodeOffset = <<0.0000, 0.0000, 0.0000>>
|
|
thisSwitchCam.nodes[1].iNodeToClone = 0
|
|
thisSwitchCam.nodes[1].NodeTimePostFX_Type = NO_EFFECT
|
|
thisSwitchCam.nodes[1].fNodeTimePostFXBlendTime = 0.0000
|
|
thisSwitchCam.nodes[1].fNodeTimePostFXTimeOffset = 0.0000
|
|
thisSwitchCam.nodes[1].fNodeMotionBlur = 0.5000
|
|
thisSwitchCam.nodes[1].NodeCamShakeType = CAM_SHAKE_DEFAULT
|
|
thisSwitchCam.nodes[1].fNodeCamShake = 0.0000
|
|
thisSwitchCam.nodes[1].iCamEaseType = 0
|
|
thisSwitchCam.nodes[1].fCamEaseScaler = 0.0000
|
|
thisSwitchCam.nodes[1].fCamNodeVelocityScale = 0.0000
|
|
thisSwitchCam.nodes[1].bCamEaseForceLinear = FALSE
|
|
thisSwitchCam.nodes[1].bCamEaseForceLevel = FALSE
|
|
thisSwitchCam.nodes[1].fTimeScale = 1.0000
|
|
thisSwitchCam.nodes[1].iTimeScaleEaseType = 0
|
|
thisSwitchCam.nodes[1].fTimeScaleEaseScaler = 0.0000
|
|
thisSwitchCam.nodes[1].bFlashEnabled = TRUE
|
|
thisSwitchCam.nodes[1].SCFE_FlashEffectUsed = SCFE_SwitchShortMichaelIn
|
|
thisSwitchCam.nodes[1].fMinExposure = 0.0000
|
|
thisSwitchCam.nodes[1].fMaxExposure = 0.0000
|
|
thisSwitchCam.nodes[1].iRampUpDuration = 0
|
|
thisSwitchCam.nodes[1].iRampDownDuration = 0
|
|
thisSwitchCam.nodes[1].iHoldDuration = 0
|
|
thisSwitchCam.nodes[1].fFlashNodePhaseOffset = 0.3000
|
|
thisSwitchCam.nodes[1].bIsLowDetailNode = FALSE
|
|
thisSwitchCam.nodes[1].bUseCustomDOF = FALSE
|
|
thisSwitchCam.nodes[1].NodeDOF_Info.fDOF_NearDOF = 0.0000
|
|
thisSwitchCam.nodes[1].NodeDOF_Info.fDOF_FarDOF = 0.0000
|
|
thisSwitchCam.nodes[1].NodeDOF_Info.fDOF_EffectStrength = 0.0000
|
|
|
|
thisSwitchCam.nodes[2].SwitchCamType = SWITCH_ENTITY_ATTACHED_CAM
|
|
thisSwitchCam.nodes[2].iForceCamPointAtEntityIndex = 1
|
|
thisSwitchCam.nodes[2].bIsGameplayCamCopy = FALSE
|
|
thisSwitchCam.nodes[2].iNodeTime = 1000
|
|
thisSwitchCam.nodes[2].vNodePos = <<5.0000, -5.0000, 0.6000>>
|
|
thisSwitchCam.nodes[2].vWorldPosLookAt = <<0.6000, 0.0000, 0.8000>>
|
|
thisSwitchCam.nodes[2].fNodeOffsetDist = 0.0000
|
|
thisSwitchCam.nodes[2].fNodeVerticleOffset = 0.0000
|
|
thisSwitchCam.nodes[2].bAttachToOriginPed = FALSE
|
|
thisSwitchCam.nodes[2].vNodeDir = <<0.0000, 0.0000, 0.8000>>
|
|
thisSwitchCam.nodes[2].bPointAtEntity = TRUE
|
|
thisSwitchCam.nodes[2].bPointAtOffsetIsRelative = TRUE
|
|
thisSwitchCam.nodes[2].bAttachOffsetIsRelative = TRUE
|
|
thisSwitchCam.nodes[2].fNodeFOV = 50.0000
|
|
thisSwitchCam.nodes[2].vClonedNodeOffset = <<0.0000, 0.0000, 0.0000>>
|
|
thisSwitchCam.nodes[2].iNodeToClone = 0
|
|
thisSwitchCam.nodes[2].NodeTimePostFX_Type = NO_EFFECT
|
|
thisSwitchCam.nodes[2].fNodeTimePostFXBlendTime = 0.0000
|
|
thisSwitchCam.nodes[2].fNodeTimePostFXTimeOffset = 0.0000
|
|
thisSwitchCam.nodes[2].fNodeMotionBlur = 0.5000
|
|
thisSwitchCam.nodes[2].NodeCamShakeType = CAM_SHAKE_DEFAULT
|
|
thisSwitchCam.nodes[2].fNodeCamShake = 0.0000
|
|
thisSwitchCam.nodes[2].iCamEaseType = 0
|
|
thisSwitchCam.nodes[2].fCamEaseScaler = 0.0000
|
|
thisSwitchCam.nodes[2].fCamNodeVelocityScale = 0.0000
|
|
thisSwitchCam.nodes[2].bCamEaseForceLinear = FALSE
|
|
thisSwitchCam.nodes[2].bCamEaseForceLevel = FALSE
|
|
thisSwitchCam.nodes[2].fTimeScale = 1.0000
|
|
thisSwitchCam.nodes[2].iTimeScaleEaseType = 0
|
|
thisSwitchCam.nodes[2].fTimeScaleEaseScaler = 0.0000
|
|
thisSwitchCam.nodes[2].bFlashEnabled = FALSE
|
|
thisSwitchCam.nodes[2].SCFE_FlashEffectUsed = SCFE_CODE_FLASH
|
|
thisSwitchCam.nodes[2].fMinExposure = 0.0000
|
|
thisSwitchCam.nodes[2].fMaxExposure = 0.0000
|
|
thisSwitchCam.nodes[2].iRampUpDuration = 0
|
|
thisSwitchCam.nodes[2].iRampDownDuration = 0
|
|
thisSwitchCam.nodes[2].iHoldDuration = 0
|
|
thisSwitchCam.nodes[2].fFlashNodePhaseOffset = 0.0000
|
|
thisSwitchCam.nodes[2].bIsLowDetailNode = FALSE
|
|
thisSwitchCam.nodes[2].bUseCustomDOF = FALSE
|
|
thisSwitchCam.nodes[2].NodeDOF_Info.fDOF_NearDOF = 0.0000
|
|
thisSwitchCam.nodes[2].NodeDOF_Info.fDOF_FarDOF = 0.0000
|
|
thisSwitchCam.nodes[2].NodeDOF_Info.fDOF_EffectStrength = 0.0000
|
|
|
|
thisSwitchCam.nodes[3].SwitchCamType = SWITCH_ENTITY_ATTACHED_CAM
|
|
thisSwitchCam.nodes[3].iForceCamPointAtEntityIndex = 1
|
|
thisSwitchCam.nodes[3].bIsGameplayCamCopy = FALSE
|
|
thisSwitchCam.nodes[3].iNodeTime = 1000
|
|
thisSwitchCam.nodes[3].vNodePos = <<3.9762, -10.9954, 1.5856>>
|
|
thisSwitchCam.nodes[3].vWorldPosLookAt = <<0.6000, 0.0000, 0.8000>>
|
|
thisSwitchCam.nodes[3].fNodeOffsetDist = 0.0000
|
|
thisSwitchCam.nodes[3].fNodeVerticleOffset = 0.0000
|
|
thisSwitchCam.nodes[3].bAttachToOriginPed = FALSE
|
|
thisSwitchCam.nodes[3].vNodeDir = <<0.6412, -1.7077, 0.7227>>
|
|
thisSwitchCam.nodes[3].bPointAtEntity = TRUE
|
|
thisSwitchCam.nodes[3].bPointAtOffsetIsRelative = TRUE
|
|
thisSwitchCam.nodes[3].bAttachOffsetIsRelative = TRUE
|
|
thisSwitchCam.nodes[3].fNodeFOV = 50.0000
|
|
thisSwitchCam.nodes[3].vClonedNodeOffset = <<0.0000, 0.0000, 0.0000>>
|
|
thisSwitchCam.nodes[3].iNodeToClone = 0
|
|
thisSwitchCam.nodes[3].NodeTimePostFX_Type = NO_EFFECT
|
|
thisSwitchCam.nodes[3].fNodeTimePostFXBlendTime = 0.0000
|
|
thisSwitchCam.nodes[3].fNodeTimePostFXTimeOffset = 0.0000
|
|
thisSwitchCam.nodes[3].fNodeMotionBlur = 0.3000
|
|
thisSwitchCam.nodes[3].NodeCamShakeType = CAM_SHAKE_DEFAULT
|
|
thisSwitchCam.nodes[3].fNodeCamShake = 0.0000
|
|
thisSwitchCam.nodes[3].iCamEaseType = 0
|
|
thisSwitchCam.nodes[3].fCamEaseScaler = 0.0000
|
|
thisSwitchCam.nodes[3].fCamNodeVelocityScale = 0.0000
|
|
thisSwitchCam.nodes[3].bCamEaseForceLinear = FALSE
|
|
thisSwitchCam.nodes[3].bCamEaseForceLevel = FALSE
|
|
thisSwitchCam.nodes[3].fTimeScale = 1.0000
|
|
thisSwitchCam.nodes[3].iTimeScaleEaseType = 0
|
|
thisSwitchCam.nodes[3].fTimeScaleEaseScaler = 0.0000
|
|
thisSwitchCam.nodes[3].bFlashEnabled = TRUE
|
|
thisSwitchCam.nodes[3].SCFE_FlashEffectUsed = SCFE_SwitchShortTrevorMid
|
|
thisSwitchCam.nodes[3].fMinExposure = 0.0000
|
|
thisSwitchCam.nodes[3].fMaxExposure = 0.0000
|
|
thisSwitchCam.nodes[3].iRampUpDuration = 0
|
|
thisSwitchCam.nodes[3].iRampDownDuration = 0
|
|
thisSwitchCam.nodes[3].iHoldDuration = 0
|
|
thisSwitchCam.nodes[3].fFlashNodePhaseOffset = 0.75
|
|
thisSwitchCam.nodes[3].bIsLowDetailNode = FALSE
|
|
thisSwitchCam.nodes[3].bUseCustomDOF = FALSE
|
|
thisSwitchCam.nodes[3].NodeDOF_Info.fDOF_NearDOF = 0.0000
|
|
thisSwitchCam.nodes[3].NodeDOF_Info.fDOF_FarDOF = 0.0000
|
|
thisSwitchCam.nodes[3].NodeDOF_Info.fDOF_EffectStrength = 0.0000
|
|
|
|
INT i
|
|
REPEAT COUNT_OF(thisSwitchCam.camVelocityOverrides) i
|
|
thisSwitchCam.camVelocityOverrides[i].fStartPoint = 0.0
|
|
thisSwitchCam.camVelocityOverrides[i].fSpeed = -1
|
|
ENDREPEAT
|
|
|
|
thisSwitchCam.camVelocityOverrides[0].fStartPoint = 0.0000
|
|
thisSwitchCam.camVelocityOverrides[0].fSpeed = 5.0000
|
|
thisSwitchCam.camVelocityOverrides[1].fStartPoint = 1.5000
|
|
thisSwitchCam.camVelocityOverrides[1].fSpeed = 20.0000
|
|
thisSwitchCam.camVelocityOverrides[2].fStartPoint = 2.0000
|
|
thisSwitchCam.camVelocityOverrides[2].fSpeed = 50.0000
|
|
thisSwitchCam.camVelocityOverrides[3].fStartPoint = 3.0000
|
|
thisSwitchCam.camVelocityOverrides[3].fSpeed = 50.0000
|
|
thisSwitchCam.camVelocityOverrides[4].fStartPoint = 3.2000
|
|
thisSwitchCam.camVelocityOverrides[4].fSpeed = 50.0000
|
|
thisSwitchCam.camVelocityOverrides[5].fStartPoint = 3.6000
|
|
thisSwitchCam.camVelocityOverrides[5].fSpeed = 30.0000
|
|
thisSwitchCam.camVelocityOverrides[6].fStartPoint = 4.0000
|
|
thisSwitchCam.camVelocityOverrides[6].fSpeed = 7.0000
|
|
|
|
|
|
thisSwitchCam.iNumNodes = 4
|
|
thisSwitchCam.iCamSwitchFocusNode = 1
|
|
thisSwitchCam.fSwitchSoundAudioStartPhase = 0.03
|
|
thisSwitchCam.fSwitchSoundAudioEndPhase = 0.6
|
|
thisSwitchCam.bSwitchSoundPlayOpeningPulse = TRUE
|
|
thisSwitchCam.bSwitchSoundPlayMoveLoop = TRUE
|
|
thisSwitchCam.bSwitchSoundPlayExitPulse = TRUE
|
|
thisSwitchCam.bSplineNoSmoothing = FALSE
|
|
thisSwitchCam.bAddGameplayCamAsLastNode = TRUE
|
|
thisSwitchCam.iGameplayNodeBlendDuration = 286
|
|
|
|
|
|
//--- End of Cam Data ---
|
|
|
|
|
|
|
|
|
|
thisSwitchCam.strOutputStructName = "thisSwitchCam"
|
|
thisSwitchCam.strOutputFileName = "CameraInfo_FIB2_HeliMichaelToTrevor.txt"
|
|
thisSwitchCam.strXMLFileName = "CameraInfo_FIB2_HeliMichaelToTrevor.xml"
|
|
|
|
thisSwitchCam.bInitialized = TRUE
|
|
//ENDIF
|
|
|
|
thisSwitchCam.piPeds[0] = piTrevor
|
|
thisSwitchCam.piPeds[1] = piMichael
|
|
|
|
|
|
ENDPROC
|
|
|
|
PROC SETUP_SPLINE_CAM_NODE_ARRAY_HELI_MICHAEL_TO_TREVOR_FIRST_PERSON(SWITCH_CAM_STRUCT &thisSwitchCam, PED_INDEX piMichael, PED_INDEX piTrevor)
|
|
CDEBUG3LN(DEBUG_MISSION, "SETUP_SPLINE_CAM_NODE_ARRAY_HELI_MICHAEL_TO_FRANKLIN")
|
|
|
|
//IF NOT thisSwitchCam.bInitialized
|
|
|
|
|
|
//--- Start of Cam Data ---
|
|
thisSwitchCam.nodes[0].SwitchCamType = SWITCH_CAM_OLD_SYSTEM
|
|
thisSwitchCam.nodes[0].iForceCamPointAtEntityIndex = -1
|
|
thisSwitchCam.nodes[0].bIsGameplayCamCopy = FALSE
|
|
thisSwitchCam.nodes[0].iNodeTime = 0
|
|
thisSwitchCam.nodes[0].vNodePos = <<-1.9125, 1.3081, -0.1774>>
|
|
thisSwitchCam.nodes[0].vWorldPosLookAt = <<0.0000, 0.0000, 0.0000>>
|
|
thisSwitchCam.nodes[0].fNodeOffsetDist = 0.0000
|
|
thisSwitchCam.nodes[0].fNodeVerticleOffset = 0.0000
|
|
thisSwitchCam.nodes[0].bAttachToOriginPed = FALSE
|
|
thisSwitchCam.nodes[0].vNodeDir = <<0, -1, 0.7>>
|
|
thisSwitchCam.nodes[0].bPointAtEntity = TRUE
|
|
thisSwitchCam.nodes[0].bPointAtOffsetIsRelative = TRUE
|
|
thisSwitchCam.nodes[0].bAttachOffsetIsRelative = TRUE
|
|
thisSwitchCam.nodes[0].fNodeFOV = 40.0000
|
|
thisSwitchCam.nodes[0].vClonedNodeOffset = <<0.0000, 0.0000, 0.0000>>
|
|
thisSwitchCam.nodes[0].iNodeToClone = 0
|
|
thisSwitchCam.nodes[0].NodeTimePostFX_Type = NO_EFFECT
|
|
thisSwitchCam.nodes[0].fNodeTimePostFXBlendTime = 0.0000
|
|
thisSwitchCam.nodes[0].fNodeTimePostFXTimeOffset = 0.0000
|
|
thisSwitchCam.nodes[0].fNodeMotionBlur = 0.0000
|
|
thisSwitchCam.nodes[0].NodeCamShakeType = CAM_SHAKE_MEDIUM
|
|
thisSwitchCam.nodes[0].fNodeCamShake = 0.5000
|
|
thisSwitchCam.nodes[0].iCamEaseType = 0
|
|
thisSwitchCam.nodes[0].fCamEaseScaler = 0.0000
|
|
thisSwitchCam.nodes[0].fCamNodeVelocityScale = 0.0000
|
|
thisSwitchCam.nodes[0].bCamEaseForceLinear = FALSE
|
|
thisSwitchCam.nodes[0].bCamEaseForceLevel = FALSE
|
|
thisSwitchCam.nodes[0].fTimeScale = 1.0000
|
|
thisSwitchCam.nodes[0].iTimeScaleEaseType = 0
|
|
thisSwitchCam.nodes[0].fTimeScaleEaseScaler = 0.0000
|
|
thisSwitchCam.nodes[0].bFlashEnabled = TRUE
|
|
thisSwitchCam.nodes[0].SCFE_FlashEffectUsed = SCFE_SwitchShortMichaelIn
|
|
thisSwitchCam.nodes[0].fMinExposure = 0.0000
|
|
thisSwitchCam.nodes[0].fMaxExposure = 0.0000
|
|
thisSwitchCam.nodes[0].iRampUpDuration = 0
|
|
thisSwitchCam.nodes[0].iRampDownDuration = 0
|
|
thisSwitchCam.nodes[0].iHoldDuration = 0
|
|
thisSwitchCam.nodes[0].fFlashNodePhaseOffset = 0.0000
|
|
thisSwitchCam.nodes[0].bIsLowDetailNode = FALSE
|
|
thisSwitchCam.nodes[0].bUseCustomDOF = FALSE
|
|
thisSwitchCam.nodes[0].NodeDOF_Info.fDOF_NearDOF = 0.0000
|
|
thisSwitchCam.nodes[0].NodeDOF_Info.fDOF_FarDOF = 0.0000
|
|
thisSwitchCam.nodes[0].NodeDOF_Info.fDOF_EffectStrength = 0.0000
|
|
|
|
|
|
thisSwitchCam.nodes[1].SwitchCamType = SWITCH_CAM_OLD_SYSTEM
|
|
thisSwitchCam.nodes[1].iForceCamPointAtEntityIndex = -1
|
|
thisSwitchCam.nodes[1].bIsGameplayCamCopy = FALSE
|
|
thisSwitchCam.nodes[1].iNodeTime = 400
|
|
thisSwitchCam.nodes[1].vNodePos = <<-1.8625, 1.5081, -0.0774>>
|
|
thisSwitchCam.nodes[1].vWorldPosLookAt = <<0.0000, 0.0000, 0.0000>>
|
|
thisSwitchCam.nodes[1].fNodeOffsetDist = 0.0000
|
|
thisSwitchCam.nodes[1].fNodeVerticleOffset = 0.0000
|
|
thisSwitchCam.nodes[1].bAttachToOriginPed = FALSE
|
|
thisSwitchCam.nodes[1].vNodeDir = <<0, -0.8, 0.5>>
|
|
thisSwitchCam.nodes[1].bPointAtEntity = TRUE
|
|
thisSwitchCam.nodes[1].bPointAtOffsetIsRelative = TRUE
|
|
thisSwitchCam.nodes[1].bAttachOffsetIsRelative = TRUE
|
|
thisSwitchCam.nodes[1].fNodeFOV = 40.0000
|
|
thisSwitchCam.nodes[1].vClonedNodeOffset = <<0.0000, 0.0000, 0.0000>>
|
|
thisSwitchCam.nodes[1].iNodeToClone = 0
|
|
thisSwitchCam.nodes[1].NodeTimePostFX_Type = NO_EFFECT
|
|
thisSwitchCam.nodes[1].fNodeTimePostFXBlendTime = 0.0000
|
|
thisSwitchCam.nodes[1].fNodeTimePostFXTimeOffset = 0.0000
|
|
thisSwitchCam.nodes[1].fNodeMotionBlur = 1.0000
|
|
thisSwitchCam.nodes[1].NodeCamShakeType = CAM_SHAKE_MEDIUM
|
|
thisSwitchCam.nodes[1].fNodeCamShake = 0.5000
|
|
thisSwitchCam.nodes[1].iCamEaseType = 0
|
|
thisSwitchCam.nodes[1].fCamEaseScaler = 0.0000
|
|
thisSwitchCam.nodes[1].fCamNodeVelocityScale = 0.6000
|
|
thisSwitchCam.nodes[1].bCamEaseForceLinear = FALSE
|
|
thisSwitchCam.nodes[1].bCamEaseForceLevel = FALSE
|
|
thisSwitchCam.nodes[1].fTimeScale = 0.3
|
|
thisSwitchCam.nodes[1].iTimeScaleEaseType = 0
|
|
thisSwitchCam.nodes[1].fTimeScaleEaseScaler = 0.0000
|
|
thisSwitchCam.nodes[1].bFlashEnabled = FALSE
|
|
thisSwitchCam.nodes[1].SCFE_FlashEffectUsed = SCFE_CODE_FLASH
|
|
thisSwitchCam.nodes[1].fMinExposure = 0.0000
|
|
thisSwitchCam.nodes[1].fMaxExposure = 0.0000
|
|
thisSwitchCam.nodes[1].iRampUpDuration = 0
|
|
thisSwitchCam.nodes[1].iRampDownDuration = 0
|
|
thisSwitchCam.nodes[1].iHoldDuration = 0
|
|
thisSwitchCam.nodes[1].fFlashNodePhaseOffset = 0.0000
|
|
thisSwitchCam.nodes[1].bIsLowDetailNode = FALSE
|
|
thisSwitchCam.nodes[1].bUseCustomDOF = FALSE
|
|
thisSwitchCam.nodes[1].NodeDOF_Info.fDOF_NearDOF = 0.0000
|
|
thisSwitchCam.nodes[1].NodeDOF_Info.fDOF_FarDOF = 0.0000
|
|
thisSwitchCam.nodes[1].NodeDOF_Info.fDOF_EffectStrength = 0.0000
|
|
|
|
thisSwitchCam.nodes[2].SwitchCamType = SWITCH_CAM_OLD_SYSTEM
|
|
thisSwitchCam.nodes[2].iForceCamPointAtEntityIndex = -1
|
|
thisSwitchCam.nodes[2].bIsGameplayCamCopy = FALSE
|
|
thisSwitchCam.nodes[2].iNodeTime = 600
|
|
thisSwitchCam.nodes[2].vNodePos = <<-1.6125, 2.0081, 0.6774>>
|
|
thisSwitchCam.nodes[2].vWorldPosLookAt = <<0.0000, 0.0000, 0.0000>>
|
|
thisSwitchCam.nodes[2].fNodeOffsetDist = 0.0000
|
|
thisSwitchCam.nodes[2].fNodeVerticleOffset = 0.0000
|
|
thisSwitchCam.nodes[2].bAttachToOriginPed = FALSE
|
|
thisSwitchCam.nodes[2].vNodeDir = <<-0.5, 0.9, 0.3>>
|
|
thisSwitchCam.nodes[2].bPointAtEntity = TRUE
|
|
thisSwitchCam.nodes[2].bPointAtOffsetIsRelative = TRUE
|
|
thisSwitchCam.nodes[2].bAttachOffsetIsRelative = TRUE
|
|
thisSwitchCam.nodes[2].fNodeFOV = 40.0000
|
|
thisSwitchCam.nodes[2].vClonedNodeOffset = <<0.0000, 0.0000, 0.0000>>
|
|
thisSwitchCam.nodes[2].iNodeToClone = 0
|
|
thisSwitchCam.nodes[2].NodeTimePostFX_Type = NO_EFFECT
|
|
thisSwitchCam.nodes[2].fNodeTimePostFXBlendTime = 0.0000
|
|
thisSwitchCam.nodes[2].fNodeTimePostFXTimeOffset = 0.0000
|
|
thisSwitchCam.nodes[2].fNodeMotionBlur = 1.0000
|
|
thisSwitchCam.nodes[2].NodeCamShakeType = CAM_SHAKE_MEDIUM
|
|
thisSwitchCam.nodes[2].fNodeCamShake = 0.5000
|
|
thisSwitchCam.nodes[2].iCamEaseType = 0
|
|
thisSwitchCam.nodes[2].fCamEaseScaler = 0.0000
|
|
thisSwitchCam.nodes[2].fCamNodeVelocityScale = 0.0000
|
|
thisSwitchCam.nodes[2].bCamEaseForceLinear = FALSE
|
|
thisSwitchCam.nodes[2].bCamEaseForceLevel = FALSE
|
|
thisSwitchCam.nodes[2].fTimeScale = 0.3
|
|
thisSwitchCam.nodes[2].iTimeScaleEaseType = 0
|
|
thisSwitchCam.nodes[2].fTimeScaleEaseScaler = 0.0000
|
|
thisSwitchCam.nodes[2].bFlashEnabled = TRUE
|
|
thisSwitchCam.nodes[2].SCFE_FlashEffectUsed = SCFE_SwitchShortTrevorMid
|
|
thisSwitchCam.nodes[2].fMinExposure = 0.0000
|
|
thisSwitchCam.nodes[2].fMaxExposure = 0.0000
|
|
thisSwitchCam.nodes[2].iRampUpDuration = 0
|
|
thisSwitchCam.nodes[2].iRampDownDuration = 0
|
|
thisSwitchCam.nodes[2].iHoldDuration = 0
|
|
thisSwitchCam.nodes[2].fFlashNodePhaseOffset = 0.3000
|
|
thisSwitchCam.nodes[2].bIsLowDetailNode = FALSE
|
|
thisSwitchCam.nodes[2].bUseCustomDOF = FALSE
|
|
thisSwitchCam.nodes[2].NodeDOF_Info.fDOF_NearDOF = 0.0000
|
|
thisSwitchCam.nodes[2].NodeDOF_Info.fDOF_FarDOF = 0.0000
|
|
thisSwitchCam.nodes[2].NodeDOF_Info.fDOF_EffectStrength = 0.0000
|
|
|
|
thisSwitchCam.nodes[3].SwitchCamType = SWITCH_CAM_OLD_SYSTEM
|
|
thisSwitchCam.nodes[3].iForceCamPointAtEntityIndex = -1
|
|
thisSwitchCam.nodes[3].bIsGameplayCamCopy = FALSE
|
|
thisSwitchCam.nodes[3].iNodeTime = 400
|
|
thisSwitchCam.nodes[3].vNodePos = <<-1.6125, 2.0081, 0.6774>>
|
|
thisSwitchCam.nodes[3].vWorldPosLookAt = <<0.0000, 0.0000, 0.0000>>
|
|
thisSwitchCam.nodes[3].fNodeOffsetDist = 0.0000
|
|
thisSwitchCam.nodes[3].fNodeVerticleOffset = 0.0000
|
|
thisSwitchCam.nodes[3].bAttachToOriginPed = FALSE
|
|
thisSwitchCam.nodes[3].vNodeDir = <<-0.5, 0.9, 0.3>>
|
|
thisSwitchCam.nodes[3].bPointAtEntity = TRUE
|
|
thisSwitchCam.nodes[3].bPointAtOffsetIsRelative = TRUE
|
|
thisSwitchCam.nodes[3].bAttachOffsetIsRelative = TRUE
|
|
thisSwitchCam.nodes[3].fNodeFOV = 40.0000
|
|
thisSwitchCam.nodes[3].vClonedNodeOffset = <<0.0000, 0.0000, 0.0000>>
|
|
thisSwitchCam.nodes[3].iNodeToClone = 0
|
|
thisSwitchCam.nodes[3].NodeTimePostFX_Type = NO_EFFECT
|
|
thisSwitchCam.nodes[3].fNodeTimePostFXBlendTime = 0.0000
|
|
thisSwitchCam.nodes[3].fNodeTimePostFXTimeOffset = 0.0000
|
|
thisSwitchCam.nodes[3].fNodeMotionBlur = 0.0000
|
|
thisSwitchCam.nodes[3].NodeCamShakeType = CAM_SHAKE_DEFAULT
|
|
thisSwitchCam.nodes[3].fNodeCamShake = 0.5000
|
|
thisSwitchCam.nodes[3].iCamEaseType = 0
|
|
thisSwitchCam.nodes[3].fCamEaseScaler = 0.0000
|
|
thisSwitchCam.nodes[3].fCamNodeVelocityScale = 0.0000
|
|
thisSwitchCam.nodes[3].bCamEaseForceLinear = FALSE
|
|
thisSwitchCam.nodes[3].bCamEaseForceLevel = FALSE
|
|
thisSwitchCam.nodes[3].fTimeScale = 1.0000
|
|
thisSwitchCam.nodes[3].iTimeScaleEaseType = 0
|
|
thisSwitchCam.nodes[3].fTimeScaleEaseScaler = 0.0000
|
|
thisSwitchCam.nodes[3].bFlashEnabled = FALSE
|
|
thisSwitchCam.nodes[3].SCFE_FlashEffectUsed = SCFE_CODE_FLASH
|
|
thisSwitchCam.nodes[3].fMinExposure = 0.0000
|
|
thisSwitchCam.nodes[3].fMaxExposure = 0.0000
|
|
thisSwitchCam.nodes[3].iRampUpDuration = 0
|
|
thisSwitchCam.nodes[3].iRampDownDuration = 0
|
|
thisSwitchCam.nodes[3].iHoldDuration = 0
|
|
thisSwitchCam.nodes[3].fFlashNodePhaseOffset = 0.0000
|
|
thisSwitchCam.nodes[3].bIsLowDetailNode = FALSE
|
|
thisSwitchCam.nodes[3].bUseCustomDOF = FALSE
|
|
thisSwitchCam.nodes[3].NodeDOF_Info.fDOF_NearDOF = 0.0000
|
|
thisSwitchCam.nodes[3].NodeDOF_Info.fDOF_FarDOF = 0.0000
|
|
thisSwitchCam.nodes[3].NodeDOF_Info.fDOF_EffectStrength = 0.0000
|
|
|
|
INT i
|
|
REPEAT COUNT_OF(thisSwitchCam.camVelocityOverrides) i
|
|
thisSwitchCam.camVelocityOverrides[i].fStartPoint = 0.0
|
|
thisSwitchCam.camVelocityOverrides[i].fSpeed = -1
|
|
ENDREPEAT
|
|
|
|
|
|
thisSwitchCam.iNumNodes = 4
|
|
thisSwitchCam.iCamSwitchFocusNode = 2
|
|
thisSwitchCam.fSwitchSoundAudioStartPhase = 0.25
|
|
thisSwitchCam.fSwitchSoundAudioEndPhase = 0.48
|
|
thisSwitchCam.bSwitchSoundPlayOpeningPulse = FALSE
|
|
thisSwitchCam.bSwitchSoundPlayMoveLoop = FALSE
|
|
thisSwitchCam.bSwitchSoundPlayExitPulse = FALSE
|
|
thisSwitchCam.bSplineNoSmoothing = FALSE
|
|
thisSwitchCam.bAddGameplayCamAsLastNode = FALSE
|
|
thisSwitchCam.iGameplayNodeBlendDuration = 0
|
|
|
|
|
|
//--- End of Cam Data ---
|
|
|
|
|
|
thisSwitchCam.strOutputStructName = "thisSwitchCam"
|
|
thisSwitchCam.strOutputFileName = "CameraInfo_FIB2_HeliMichaelToFranklin.txt"
|
|
thisSwitchCam.strXMLFileName = "CameraInfo_FIB2_HeliMichaelToFranklin.xml"
|
|
|
|
thisSwitchCam.bInitialized = TRUE
|
|
//ENDIF
|
|
|
|
thisSwitchCam.piPeds[0] = piMichael
|
|
thisSwitchCam.piPeds[1] = piTrevor
|
|
ENDPROC
|
|
|
|
/// PURPOSE:
|
|
/// Handle the playback of the switch cam. The will setup, play, shut down and cleanup the switch cam spline
|
|
/// PARAMS:
|
|
/// thisSwitchCam - Switch camera to playback
|
|
/// bReturnTrueOnce - If you only want this function to return TRUE once upon completion. Set to FALSE to have this function to return true every time this is called once the camera is finished playback.
|
|
/// RETURNS:
|
|
/// TRUE when camera is complete, FALSE if playback is still active, or if the camera has completed playback and bReturnTrueOnce is set to TRUE.
|
|
FUNC BOOL HANDLE_SWITCH_CAM_HELI_MICHAEL_TO_TREVOR(SWITCH_CAM_STRUCT &thisSwitchCam, BOOL bReturnTrueOnce = TRUE)
|
|
IS_PED_INJURED(GET_FRANKLIN_PED())
|
|
IS_PED_INJURED(GET_MICHAEL_PED())
|
|
IS_PED_INJURED(GET_TREVOR_PED())
|
|
IS_VEHICLE_DRIVEABLE(snatchAndGrabVehicle[SAGV_PLAYER_CHOPPER])
|
|
|
|
|
|
INT iCurrentNode
|
|
|
|
SWITCH eSwitchCamState
|
|
|
|
CASE SWITCH_CAM_IDLE
|
|
CDEBUG3LN(DEBUG_MISSION, "eSwitchCamState = SWITCH_CAM_IDLE")
|
|
RETURN FALSE
|
|
BREAK
|
|
|
|
CASE SWITCH_CAM_SETUP_SPLINE
|
|
CDEBUG3LN(DEBUG_MISSION, "eSwitchCamState = SWITCH_CAM_SETUP_SPLINE")
|
|
|
|
IF NOT bSwitchToFirstPerson
|
|
SETUP_SPLINE_CAM_NODE_ARRAY_HELI_MICHAEL_TO_TREVOR(thisSwitchCam, GET_MICHAEL_PED(), GET_TREVOR_PED())
|
|
ELSE
|
|
SETUP_SPLINE_CAM_NODE_ARRAY_HELI_MICHAEL_TO_TREVOR_FIRST_PERSON(thisSwitchCam, GET_MICHAEL_PED(), GET_TREVOR_PED())
|
|
ENDIF
|
|
|
|
IF DOES_SWITCH_CAM_EXIST(thisSwitchCam)
|
|
DESTROY_SWITCH_CAM(thisSwitchCam)
|
|
ENDIF
|
|
|
|
CREATE_SPLINE_CAM(thisSwitchCam)
|
|
|
|
IF bSwitchToFirstPerson
|
|
INT i
|
|
REPEAT COUNT_OF(thisSwitchCam.nodes) i
|
|
IF DOES_CAM_EXIST(thisSwitchCam.nodes[i].ciSwitchNode)
|
|
SET_CAM_INHERIT_ROLL_VEHICLE(thisSwitchCam.nodes[i].ciSwitchNode, snatchAndGrabVehicle[SAGV_PLAYER_CHOPPER])
|
|
ENDIF
|
|
ENDREPEAT
|
|
ENDIF
|
|
|
|
SET_GAME_PAUSES_FOR_STREAMING(FALSE)
|
|
|
|
SET_CAM_ACTIVE(thisSwitchCam.ciSpline, TRUE)
|
|
RENDER_SCRIPT_CAMS(TRUE, FALSE)
|
|
|
|
DISPLAY_RADAR(FALSE)
|
|
DISPLAY_HUD(FALSE)
|
|
|
|
SETTIMERB(0)
|
|
|
|
SET_PLAYER_CONTROL(PLAYER_ID(), FALSE)
|
|
|
|
bPlayerControlGiven = FALSE
|
|
|
|
IF currentMissionStage = STAGE_DROPOFF
|
|
IF NOT bSwitchToFirstPerson
|
|
CLEAR_PED_TASKS(GET_MICHAEL_PED())
|
|
ENDIF
|
|
ENDIF
|
|
|
|
eSwitchCamState = SWITCH_CAM_PLAYING_SPLINE
|
|
RETURN TRUE
|
|
BREAK
|
|
|
|
CASE SWITCH_CAM_PLAYING_SPLINE
|
|
CDEBUG3LN(DEBUG_MISSION, "eSwitchCamState = SWITCH_CAM_PLAYING_SPLINE")
|
|
CDEBUG3LN(DEBUG_MISSION, GET_CAM_SPLINE_PHASE(thisSwitchCam.ciSpline))
|
|
|
|
iCurrentNode = UPDATE_SPLINE_CAM(thisSwitchCam)
|
|
|
|
PRINTSTRING("spline pos = ") PRINTINT(iCurrentNode) PRINTNL()
|
|
|
|
IF IS_CAM_ACTIVE(thisSwitchCam.ciSpline)
|
|
IF iCurrentNode >= thisSwitchCam.iCamSwitchFocusNode
|
|
sCamDetails.bOKToSwitchPed = TRUE
|
|
ENDIF
|
|
|
|
IF bSwitchToFirstPerson
|
|
IF NOT bDoneHitSound
|
|
IF GET_GAME_TIMER() >= (iSnatchAndGrabCutsceneTime + 20)
|
|
PLAY_SOUND_FRONTEND(-1, "Hit_Out", "PLAYER_SWITCH_CUSTOM_SOUNDSET")
|
|
iHitTime = GET_GAME_TIMER()
|
|
bDoneHitSound = TRUE
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF NOT bWooshStarted
|
|
IF bDoneHitSound
|
|
IF GET_GAME_TIMER() >= iHitTime + 150
|
|
PLAY_SOUND_FRONTEND(-1, "Short_Transition_In", "PLAYER_SWITCH_CUSTOM_SOUNDSET")
|
|
bWooshStarted = TRUE
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
|
|
//[MF] Once cam is at the end, reset the gameplay cam positon and advance to next state.
|
|
IF DOES_CAM_EXIST(thisSwitchCam.ciSpline)
|
|
IF GET_CAM_SPLINE_PHASE(thisSwitchCam.ciSpline) >= 1.00
|
|
CDEBUG3LN(DEBUG_MISSION, "eSwitchCamState = SWITCH_CAM_RETURN_TO_GAMEPLAY")
|
|
RENDER_SCRIPT_CAMS(FALSE, FALSE)
|
|
eSwitchCamState = SWITCH_CAM_RETURN_TO_GAMEPLAY
|
|
ENDIF
|
|
ELSE
|
|
SCRIPT_ASSERT("Cam Prematurely Deleted! WTF?")
|
|
RENDER_SCRIPT_CAMS(FALSE, FALSE)
|
|
eSwitchCamState = SWITCH_CAM_RETURN_TO_GAMEPLAY
|
|
ENDIF
|
|
ENDIF
|
|
|
|
RETURN TRUE
|
|
BREAK
|
|
|
|
CASE SWITCH_CAM_RETURN_TO_GAMEPLAY
|
|
|
|
SET_TIME_SCALE(1.0)
|
|
|
|
RENDER_SCRIPT_CAMS(FALSE, FALSE)
|
|
|
|
IF DOES_CAM_EXIST(thisSwitchCam.ciSpline)
|
|
SET_CAM_ACTIVE(thisSwitchCam.ciSpline, FALSE)
|
|
ENDIF
|
|
|
|
IF DOES_SWITCH_CAM_EXIST(thisSwitchCam)
|
|
DESTROY_SWITCH_CAM(thisSwitchCam)
|
|
ENDIF
|
|
|
|
IF NOT bPlayerControlGiven
|
|
SET_PLAYER_CONTROL(PLAYER_ID(), TRUE)
|
|
DISPLAY_RADAR(TRUE)
|
|
DISPLAY_HUD(TRUE)
|
|
bPlayerControlGiven = TRUE
|
|
ENDIF
|
|
|
|
SETTIMERA(0)
|
|
|
|
SET_GAME_PAUSES_FOR_STREAMING(TRUE)
|
|
|
|
eSwitchCamState = SWITCH_CAM_IDLE
|
|
|
|
thisSwitchCam.bIsSplineCamFinishedPlaying = TRUE
|
|
|
|
SET_PLAYER_CONTROL(PLAYER_ID(), true)
|
|
|
|
sCamDetails.bSplineCreated = FALSE
|
|
|
|
sCamDetails.bOKToSwitchPed = FALSE
|
|
|
|
CLEAR_PED_TASKS(GET_MICHAEL_PED())
|
|
|
|
RETURN FALSE
|
|
BREAK
|
|
|
|
ENDSWITCH
|
|
|
|
IF bReturnTrueOnce
|
|
RETURN FALSE
|
|
ELSE
|
|
RETURN thisSwitchCam.bIsSplineCamFinishedPlaying
|
|
ENDIF
|
|
ENDFUNC
|
|
|
|
|
|
/// PURPOSE:
|
|
/// Rotate an euler rotation vector to an equivalent upward pointing directional vector
|
|
/// PARAMS:
|
|
/// vEuler - Euler rotation vector to convert to upwards facing direction vector
|
|
/// RETURNS:
|
|
/// VECTOR for upward direction of Euler rotation
|
|
FUNC VECTOR CONVERT_EULER_TO_UPWARD_VECTOR(VECTOR vEuler)
|
|
|
|
// Euler angles assumed to be in YXZ order
|
|
VECTOR vResult
|
|
//c.Set( sy*cz + cy*sx*sz, sy*sz - cy*sx*cz, cy*cx);
|
|
vResult.z = Cos(vEuler.y)
|
|
|
|
FLOAT sy = Sin(vEuler.y)
|
|
FLOAT cz = Cos(vEuler.z)
|
|
FLOAT sz = Sin(vEuler.z)
|
|
FLOAT cy_sx = vResult.z * Sin(vEuler.x)
|
|
|
|
vResult.y = sy * sz
|
|
vResult.y -= cy_sx * cz
|
|
|
|
vResult.x = cy_sx * sz
|
|
vResult.x += sy * cz
|
|
|
|
vResult.z *= Cos(vEuler.x)
|
|
|
|
RETURN vResult
|
|
ENDFUNC
|
|
|
|
|
|
|
|
PROC SETUP_SPLINE_CAM_NODE_ARRAY_HELI_MICHAEL_TO_FRANKLIN(SWITCH_CAM_STRUCT &thisSwitchCam, PED_INDEX piMichael, PED_INDEX piFranklin)
|
|
CDEBUG3LN(DEBUG_MISSION, "SETUP_SPLINE_CAM_NODE_ARRAY_HELI_MICHAEL_TO_FRANKLIN")
|
|
|
|
//IF NOT thisSwitchCam.bInitialized
|
|
|
|
|
|
//--- Start of Cam Data ---
|
|
|
|
|
|
thisSwitchCam.nodes[0].SwitchCamType = SWITCH_CAM_OLD_SYSTEM
|
|
thisSwitchCam.nodes[0].iForceCamPointAtEntityIndex = -1
|
|
thisSwitchCam.nodes[0].bIsGameplayCamCopy = FALSE
|
|
thisSwitchCam.nodes[0].iNodeTime = 0
|
|
thisSwitchCam.nodes[0].vNodePos = <<-0.9162, 1.8503, 0.4801>>
|
|
thisSwitchCam.nodes[0].vWorldPosLookAt = <<0.0000, 0.0000, 0.0000>>
|
|
thisSwitchCam.nodes[0].fNodeOffsetDist = 0.0000
|
|
thisSwitchCam.nodes[0].fNodeVerticleOffset = 0.0000
|
|
thisSwitchCam.nodes[0].bAttachToOriginPed = FALSE
|
|
thisSwitchCam.nodes[0].vNodeDir = <<-0.9487, -0.0063, 0.3628>>
|
|
thisSwitchCam.nodes[0].bPointAtEntity = TRUE
|
|
thisSwitchCam.nodes[0].bPointAtOffsetIsRelative = TRUE
|
|
thisSwitchCam.nodes[0].bAttachOffsetIsRelative = TRUE
|
|
thisSwitchCam.nodes[0].fNodeFOV = 45.0000
|
|
thisSwitchCam.nodes[0].vClonedNodeOffset = <<0.0000, 0.0000, 0.0000>>
|
|
thisSwitchCam.nodes[0].iNodeToClone = 0
|
|
thisSwitchCam.nodes[0].NodeTimePostFX_Type = NO_EFFECT
|
|
thisSwitchCam.nodes[0].fNodeTimePostFXBlendTime = 0.0000
|
|
thisSwitchCam.nodes[0].fNodeTimePostFXTimeOffset = 0.0000
|
|
thisSwitchCam.nodes[0].fNodeMotionBlur = 0.0000
|
|
thisSwitchCam.nodes[0].NodeCamShakeType = CAM_SHAKE_DEFAULT
|
|
thisSwitchCam.nodes[0].fNodeCamShake = 0.5000
|
|
thisSwitchCam.nodes[0].iCamEaseType = 0
|
|
thisSwitchCam.nodes[0].fCamEaseScaler = 0.0000
|
|
thisSwitchCam.nodes[0].fCamNodeVelocityScale = 0.0000
|
|
thisSwitchCam.nodes[0].bCamEaseForceLinear = FALSE
|
|
thisSwitchCam.nodes[0].bCamEaseForceLevel = FALSE
|
|
thisSwitchCam.nodes[0].fTimeScale = 0.0000
|
|
thisSwitchCam.nodes[0].iTimeScaleEaseType = 0
|
|
thisSwitchCam.nodes[0].fTimeScaleEaseScaler = 0.0000
|
|
thisSwitchCam.nodes[0].bFlashEnabled = FALSE
|
|
thisSwitchCam.nodes[0].SCFE_FlashEffectUsed = SCFE_CODE_FLASH
|
|
thisSwitchCam.nodes[0].fMinExposure = 0.0000
|
|
thisSwitchCam.nodes[0].fMaxExposure = 0.0000
|
|
thisSwitchCam.nodes[0].iRampUpDuration = 0
|
|
thisSwitchCam.nodes[0].iRampDownDuration = 0
|
|
thisSwitchCam.nodes[0].iHoldDuration = 0
|
|
thisSwitchCam.nodes[0].fFlashNodePhaseOffset = 0.0000
|
|
thisSwitchCam.nodes[0].bIsLowDetailNode = FALSE
|
|
thisSwitchCam.nodes[0].bUseCustomDOF = FALSE
|
|
thisSwitchCam.nodes[0].NodeDOF_Info.fDOF_NearDOF = 0.0000
|
|
thisSwitchCam.nodes[0].NodeDOF_Info.fDOF_FarDOF = 0.0000
|
|
thisSwitchCam.nodes[0].NodeDOF_Info.fDOF_EffectStrength = 0.0000
|
|
|
|
thisSwitchCam.nodes[1].SwitchCamType = SWITCH_CAM_OLD_SYSTEM
|
|
thisSwitchCam.nodes[1].iForceCamPointAtEntityIndex = -1
|
|
thisSwitchCam.nodes[1].bIsGameplayCamCopy = FALSE
|
|
thisSwitchCam.nodes[1].iNodeTime = 300
|
|
thisSwitchCam.nodes[1].vNodePos = <<-0.9664, 2.2593, 0.5063>>
|
|
thisSwitchCam.nodes[1].vWorldPosLookAt = <<0.0000, 0.0000, 0.0000>>
|
|
thisSwitchCam.nodes[1].fNodeOffsetDist = 0.0000
|
|
thisSwitchCam.nodes[1].fNodeVerticleOffset = 0.0000
|
|
thisSwitchCam.nodes[1].bAttachToOriginPed = FALSE
|
|
thisSwitchCam.nodes[1].vNodeDir = <<-1.0457, 0.0132, 0.3572>>
|
|
thisSwitchCam.nodes[1].bPointAtEntity = TRUE
|
|
thisSwitchCam.nodes[1].bPointAtOffsetIsRelative = TRUE
|
|
thisSwitchCam.nodes[1].bAttachOffsetIsRelative = TRUE
|
|
thisSwitchCam.nodes[1].fNodeFOV = 45.0000
|
|
thisSwitchCam.nodes[1].vClonedNodeOffset = <<0.0000, 0.0000, 0.0000>>
|
|
thisSwitchCam.nodes[1].iNodeToClone = 0
|
|
thisSwitchCam.nodes[1].NodeTimePostFX_Type = NO_EFFECT
|
|
thisSwitchCam.nodes[1].fNodeTimePostFXBlendTime = 0.0000
|
|
thisSwitchCam.nodes[1].fNodeTimePostFXTimeOffset = 0.0000
|
|
thisSwitchCam.nodes[1].fNodeMotionBlur = 0.0000
|
|
thisSwitchCam.nodes[1].NodeCamShakeType = CAM_SHAKE_MEDIUM
|
|
thisSwitchCam.nodes[1].fNodeCamShake = 0.5000
|
|
thisSwitchCam.nodes[1].iCamEaseType = 0
|
|
thisSwitchCam.nodes[1].fCamEaseScaler = 0.0000
|
|
thisSwitchCam.nodes[1].fCamNodeVelocityScale = 0.0000
|
|
thisSwitchCam.nodes[1].bCamEaseForceLinear = FALSE
|
|
thisSwitchCam.nodes[1].bCamEaseForceLevel = FALSE
|
|
thisSwitchCam.nodes[1].fTimeScale = 1.0000
|
|
thisSwitchCam.nodes[1].iTimeScaleEaseType = 0
|
|
thisSwitchCam.nodes[1].fTimeScaleEaseScaler = 0.0000
|
|
thisSwitchCam.nodes[1].bFlashEnabled = TRUE
|
|
thisSwitchCam.nodes[1].SCFE_FlashEffectUsed = SCFE_SwitchShortMichaelIn
|
|
thisSwitchCam.nodes[1].fMinExposure = 0.0000
|
|
thisSwitchCam.nodes[1].fMaxExposure = 0.0000
|
|
thisSwitchCam.nodes[1].iRampUpDuration = 0
|
|
thisSwitchCam.nodes[1].iRampDownDuration = 0
|
|
thisSwitchCam.nodes[1].iHoldDuration = 0
|
|
thisSwitchCam.nodes[1].fFlashNodePhaseOffset = 0.3000
|
|
thisSwitchCam.nodes[1].bIsLowDetailNode = FALSE
|
|
thisSwitchCam.nodes[1].bUseCustomDOF = FALSE
|
|
thisSwitchCam.nodes[1].NodeDOF_Info.fDOF_NearDOF = 0.0000
|
|
thisSwitchCam.nodes[1].NodeDOF_Info.fDOF_FarDOF = 0.0000
|
|
thisSwitchCam.nodes[1].NodeDOF_Info.fDOF_EffectStrength = 0.0000
|
|
|
|
thisSwitchCam.nodes[2].SwitchCamType = SWITCH_CAM_OLD_SYSTEM
|
|
thisSwitchCam.nodes[2].iForceCamPointAtEntityIndex = -1
|
|
thisSwitchCam.nodes[2].bIsGameplayCamCopy = FALSE
|
|
thisSwitchCam.nodes[2].iNodeTime = 600
|
|
thisSwitchCam.nodes[2].vNodePos = <<-1.7246, 3.4542, -1.5665>>
|
|
thisSwitchCam.nodes[2].vWorldPosLookAt = <<0.0000, 0.0000, 0.0000>>
|
|
thisSwitchCam.nodes[2].fNodeOffsetDist = 0.0000
|
|
thisSwitchCam.nodes[2].fNodeVerticleOffset = 0.0000
|
|
thisSwitchCam.nodes[2].bAttachToOriginPed = FALSE
|
|
thisSwitchCam.nodes[2].vNodeDir = <<-1.7226, 0.0276, -1.6267>>
|
|
thisSwitchCam.nodes[2].bPointAtEntity = TRUE
|
|
thisSwitchCam.nodes[2].bPointAtOffsetIsRelative = TRUE
|
|
thisSwitchCam.nodes[2].bAttachOffsetIsRelative = TRUE
|
|
thisSwitchCam.nodes[2].fNodeFOV = 45.0000
|
|
thisSwitchCam.nodes[2].vClonedNodeOffset = <<0.0000, 0.0000, 0.0000>>
|
|
thisSwitchCam.nodes[2].iNodeToClone = 0
|
|
thisSwitchCam.nodes[2].NodeTimePostFX_Type = NO_EFFECT
|
|
thisSwitchCam.nodes[2].fNodeTimePostFXBlendTime = 0.0000
|
|
thisSwitchCam.nodes[2].fNodeTimePostFXTimeOffset = 0.0000
|
|
thisSwitchCam.nodes[2].fNodeMotionBlur = 1.0000
|
|
thisSwitchCam.nodes[2].NodeCamShakeType = CAM_SHAKE_MEDIUM
|
|
thisSwitchCam.nodes[2].fNodeCamShake = 0.5000
|
|
thisSwitchCam.nodes[2].iCamEaseType = 0
|
|
thisSwitchCam.nodes[2].fCamEaseScaler = 0.0000
|
|
thisSwitchCam.nodes[2].fCamNodeVelocityScale = 0.0000
|
|
thisSwitchCam.nodes[2].bCamEaseForceLinear = FALSE
|
|
thisSwitchCam.nodes[2].bCamEaseForceLevel = FALSE
|
|
thisSwitchCam.nodes[2].fTimeScale = 0.6000
|
|
thisSwitchCam.nodes[2].iTimeScaleEaseType = 0
|
|
thisSwitchCam.nodes[2].fTimeScaleEaseScaler = 0.0000
|
|
thisSwitchCam.nodes[2].bFlashEnabled = TRUE
|
|
thisSwitchCam.nodes[2].SCFE_FlashEffectUsed = SCFE_SwitchShortFranklinMid
|
|
thisSwitchCam.nodes[2].fMinExposure = 0.0000
|
|
thisSwitchCam.nodes[2].fMaxExposure = 0.0000
|
|
thisSwitchCam.nodes[2].iRampUpDuration = 0
|
|
thisSwitchCam.nodes[2].iRampDownDuration = 0
|
|
thisSwitchCam.nodes[2].iHoldDuration = 0
|
|
thisSwitchCam.nodes[2].fFlashNodePhaseOffset = 0.8000
|
|
thisSwitchCam.nodes[2].bIsLowDetailNode = FALSE
|
|
thisSwitchCam.nodes[2].bUseCustomDOF = FALSE
|
|
thisSwitchCam.nodes[2].NodeDOF_Info.fDOF_NearDOF = 0.0000
|
|
thisSwitchCam.nodes[2].NodeDOF_Info.fDOF_FarDOF = 0.0000
|
|
thisSwitchCam.nodes[2].NodeDOF_Info.fDOF_EffectStrength = 0.0000
|
|
|
|
thisSwitchCam.nodes[3].bIsCamCutNode = TRUE
|
|
|
|
thisSwitchCam.nodes[4].SwitchCamType = SWITCH_CAM_OLD_SYSTEM
|
|
thisSwitchCam.nodes[4].iForceCamPointAtEntityIndex = -1
|
|
thisSwitchCam.nodes[4].bIsGameplayCamCopy = FALSE
|
|
thisSwitchCam.nodes[4].iNodeTime = 0
|
|
thisSwitchCam.nodes[4].vNodePos = <<0.0646, 1.3472, 1.4595>>
|
|
thisSwitchCam.nodes[4].vWorldPosLookAt = <<0.0000, 0.0000, 1.4500>>
|
|
thisSwitchCam.nodes[4].fNodeOffsetDist = 0.0000
|
|
thisSwitchCam.nodes[4].fNodeVerticleOffset = 0.0000
|
|
thisSwitchCam.nodes[4].bAttachToOriginPed = FALSE
|
|
thisSwitchCam.nodes[4].vNodeDir = <<0.3564, 0.2439, 1.4688>>
|
|
thisSwitchCam.nodes[4].bPointAtEntity = TRUE
|
|
thisSwitchCam.nodes[4].bPointAtOffsetIsRelative = TRUE
|
|
thisSwitchCam.nodes[4].bAttachOffsetIsRelative = TRUE
|
|
thisSwitchCam.nodes[4].fNodeFOV = 40.0000
|
|
thisSwitchCam.nodes[4].vClonedNodeOffset = <<0.0000, 0.0000, 0.0000>>
|
|
thisSwitchCam.nodes[4].iNodeToClone = 0
|
|
thisSwitchCam.nodes[4].NodeTimePostFX_Type = NO_EFFECT
|
|
thisSwitchCam.nodes[4].fNodeTimePostFXBlendTime = 0.0000
|
|
thisSwitchCam.nodes[4].fNodeTimePostFXTimeOffset = 0.0000
|
|
thisSwitchCam.nodes[4].fNodeMotionBlur = 1.0000
|
|
thisSwitchCam.nodes[4].NodeCamShakeType = CAM_SHAKE_MEDIUM
|
|
thisSwitchCam.nodes[4].fNodeCamShake = 0.5000
|
|
thisSwitchCam.nodes[4].iCamEaseType = 1
|
|
thisSwitchCam.nodes[4].fCamEaseScaler = 1.0000
|
|
thisSwitchCam.nodes[4].fCamNodeVelocityScale = 0.0000
|
|
thisSwitchCam.nodes[4].bCamEaseForceLinear = TRUE
|
|
thisSwitchCam.nodes[4].bCamEaseForceLevel = FALSE
|
|
thisSwitchCam.nodes[4].fTimeScale = 0.3000
|
|
thisSwitchCam.nodes[4].iTimeScaleEaseType = 0
|
|
thisSwitchCam.nodes[4].fTimeScaleEaseScaler = 0.0000
|
|
thisSwitchCam.nodes[4].bFlashEnabled = FALSE
|
|
thisSwitchCam.nodes[4].SCFE_FlashEffectUsed = SCFE_CODE_FLASH
|
|
thisSwitchCam.nodes[4].fMinExposure = 0.0000
|
|
thisSwitchCam.nodes[4].fMaxExposure = 0.0000
|
|
thisSwitchCam.nodes[4].iRampUpDuration = 0
|
|
thisSwitchCam.nodes[4].iRampDownDuration = 0
|
|
thisSwitchCam.nodes[4].iHoldDuration = 0
|
|
thisSwitchCam.nodes[4].fFlashNodePhaseOffset = 0.0000
|
|
thisSwitchCam.nodes[4].bIsLowDetailNode = FALSE
|
|
thisSwitchCam.nodes[4].bUseCustomDOF = FALSE
|
|
thisSwitchCam.nodes[4].NodeDOF_Info.fDOF_NearDOF = 0.0000
|
|
thisSwitchCam.nodes[4].NodeDOF_Info.fDOF_FarDOF = 0.0000
|
|
thisSwitchCam.nodes[4].NodeDOF_Info.fDOF_EffectStrength = 0.0000
|
|
|
|
thisSwitchCam.nodes[5].SwitchCamType = SWITCH_CAM_OLD_SYSTEM
|
|
thisSwitchCam.nodes[5].iForceCamPointAtEntityIndex = -1
|
|
thisSwitchCam.nodes[5].bIsGameplayCamCopy = FALSE
|
|
thisSwitchCam.nodes[5].iNodeTime = 600
|
|
thisSwitchCam.nodes[5].vNodePos = <<-0.0083, 1.3912, 0.2997>>
|
|
thisSwitchCam.nodes[5].vWorldPosLookAt = <<0.0000, 0.0000, 0.4000>>
|
|
thisSwitchCam.nodes[5].fNodeOffsetDist = 0.0000
|
|
thisSwitchCam.nodes[5].fNodeVerticleOffset = 0.0000
|
|
thisSwitchCam.nodes[5].bAttachToOriginPed = FALSE
|
|
thisSwitchCam.nodes[5].vNodeDir = <<0.4002, 0.1876, 0.4090>>
|
|
thisSwitchCam.nodes[5].bPointAtEntity = TRUE
|
|
thisSwitchCam.nodes[5].bPointAtOffsetIsRelative = TRUE
|
|
thisSwitchCam.nodes[5].bAttachOffsetIsRelative = TRUE
|
|
thisSwitchCam.nodes[5].fNodeFOV = 40.0000
|
|
thisSwitchCam.nodes[5].vClonedNodeOffset = <<0.0000, 0.0000, 0.0000>>
|
|
thisSwitchCam.nodes[5].iNodeToClone = 0
|
|
thisSwitchCam.nodes[5].NodeTimePostFX_Type = NO_EFFECT
|
|
thisSwitchCam.nodes[5].fNodeTimePostFXBlendTime = 0.0000
|
|
thisSwitchCam.nodes[5].fNodeTimePostFXTimeOffset = 0.0000
|
|
thisSwitchCam.nodes[5].fNodeMotionBlur = 1.0000
|
|
thisSwitchCam.nodes[5].NodeCamShakeType = CAM_SHAKE_MEDIUM
|
|
thisSwitchCam.nodes[5].fNodeCamShake = 0.5000
|
|
thisSwitchCam.nodes[5].iCamEaseType = 0
|
|
thisSwitchCam.nodes[5].fCamEaseScaler = 0.0000
|
|
thisSwitchCam.nodes[5].fCamNodeVelocityScale = 0.0000
|
|
thisSwitchCam.nodes[5].bCamEaseForceLinear = TRUE
|
|
thisSwitchCam.nodes[5].bCamEaseForceLevel = FALSE
|
|
thisSwitchCam.nodes[5].fTimeScale = 0.3000
|
|
thisSwitchCam.nodes[5].iTimeScaleEaseType = 0
|
|
thisSwitchCam.nodes[5].fTimeScaleEaseScaler = 0.0000
|
|
thisSwitchCam.nodes[5].bFlashEnabled = FALSE
|
|
thisSwitchCam.nodes[5].SCFE_FlashEffectUsed = SCFE_CODE_FLASH
|
|
thisSwitchCam.nodes[5].fMinExposure = 0.0000
|
|
thisSwitchCam.nodes[5].fMaxExposure = 0.0000
|
|
thisSwitchCam.nodes[5].iRampUpDuration = 0
|
|
thisSwitchCam.nodes[5].iRampDownDuration = 0
|
|
thisSwitchCam.nodes[5].iHoldDuration = 0
|
|
thisSwitchCam.nodes[5].fFlashNodePhaseOffset = 0.0000
|
|
thisSwitchCam.nodes[5].bIsLowDetailNode = FALSE
|
|
thisSwitchCam.nodes[5].bUseCustomDOF = FALSE
|
|
thisSwitchCam.nodes[5].NodeDOF_Info.fDOF_NearDOF = 0.0000
|
|
thisSwitchCam.nodes[5].NodeDOF_Info.fDOF_FarDOF = 0.0000
|
|
thisSwitchCam.nodes[5].NodeDOF_Info.fDOF_EffectStrength = 0.0000
|
|
|
|
thisSwitchCam.nodes[6].SwitchCamType = SWITCH_CAM_OLD_SYSTEM
|
|
thisSwitchCam.nodes[6].iForceCamPointAtEntityIndex = -1
|
|
thisSwitchCam.nodes[6].bIsGameplayCamCopy = FALSE
|
|
thisSwitchCam.nodes[6].iNodeTime = 400
|
|
thisSwitchCam.nodes[6].vNodePos = <<-0.0083, 1.3912, 0.2997>>
|
|
thisSwitchCam.nodes[6].vWorldPosLookAt = <<0.0000, 0.0000, 0.4000>>
|
|
thisSwitchCam.nodes[6].fNodeOffsetDist = 0.0000
|
|
thisSwitchCam.nodes[6].fNodeVerticleOffset = 0.0000
|
|
thisSwitchCam.nodes[6].bAttachToOriginPed = FALSE
|
|
thisSwitchCam.nodes[6].vNodeDir = <<0.4002, 0.1876, 0.4090>>
|
|
thisSwitchCam.nodes[6].bPointAtEntity = TRUE
|
|
thisSwitchCam.nodes[6].bPointAtOffsetIsRelative = TRUE
|
|
thisSwitchCam.nodes[6].bAttachOffsetIsRelative = TRUE
|
|
thisSwitchCam.nodes[6].fNodeFOV = 40.0000
|
|
thisSwitchCam.nodes[6].vClonedNodeOffset = <<0.0000, 0.0000, 0.0000>>
|
|
thisSwitchCam.nodes[6].iNodeToClone = 0
|
|
thisSwitchCam.nodes[6].NodeTimePostFX_Type = NO_EFFECT
|
|
thisSwitchCam.nodes[6].fNodeTimePostFXBlendTime = 0.0000
|
|
thisSwitchCam.nodes[6].fNodeTimePostFXTimeOffset = 0.0000
|
|
thisSwitchCam.nodes[6].fNodeMotionBlur = 0.0000
|
|
thisSwitchCam.nodes[6].NodeCamShakeType = CAM_SHAKE_MEDIUM
|
|
thisSwitchCam.nodes[6].fNodeCamShake = 0.5000
|
|
thisSwitchCam.nodes[6].iCamEaseType = 0
|
|
thisSwitchCam.nodes[6].fCamEaseScaler = 0.0000
|
|
thisSwitchCam.nodes[6].fCamNodeVelocityScale = 0.0000
|
|
thisSwitchCam.nodes[6].bCamEaseForceLinear = TRUE
|
|
thisSwitchCam.nodes[6].bCamEaseForceLevel = FALSE
|
|
thisSwitchCam.nodes[6].fTimeScale = 1.0000
|
|
thisSwitchCam.nodes[6].iTimeScaleEaseType = 0
|
|
thisSwitchCam.nodes[6].fTimeScaleEaseScaler = 0.0000
|
|
thisSwitchCam.nodes[6].bFlashEnabled = FALSE
|
|
thisSwitchCam.nodes[6].SCFE_FlashEffectUsed = SCFE_CODE_FLASH
|
|
thisSwitchCam.nodes[6].fMinExposure = 0.0000
|
|
thisSwitchCam.nodes[6].fMaxExposure = 0.0000
|
|
thisSwitchCam.nodes[6].iRampUpDuration = 0
|
|
thisSwitchCam.nodes[6].iRampDownDuration = 0
|
|
thisSwitchCam.nodes[6].iHoldDuration = 0
|
|
thisSwitchCam.nodes[6].fFlashNodePhaseOffset = 0.0000
|
|
thisSwitchCam.nodes[6].bIsLowDetailNode = FALSE
|
|
thisSwitchCam.nodes[6].bUseCustomDOF = FALSE
|
|
thisSwitchCam.nodes[6].NodeDOF_Info.fDOF_NearDOF = 0.0000
|
|
thisSwitchCam.nodes[6].NodeDOF_Info.fDOF_FarDOF = 0.0000
|
|
thisSwitchCam.nodes[6].NodeDOF_Info.fDOF_EffectStrength = 0.0000
|
|
|
|
|
|
|
|
thisSwitchCam.iNumNodes = 7
|
|
thisSwitchCam.iCamSwitchFocusNode = 3
|
|
thisSwitchCam.fSwitchSoundAudioStartPhase = 0.07
|
|
thisSwitchCam.fSwitchSoundAudioEndPhase = 0.45
|
|
thisSwitchCam.bSwitchSoundPlayOpeningPulse = FALSE
|
|
thisSwitchCam.bSwitchSoundPlayMoveLoop = FALSE
|
|
thisSwitchCam.bSwitchSoundPlayExitPulse = FALSE
|
|
thisSwitchCam.bSplineNoSmoothing = FALSE
|
|
thisSwitchCam.bAddGameplayCamAsLastNode = FALSE
|
|
thisSwitchCam.iGameplayNodeBlendDuration = 0
|
|
|
|
|
|
//--- End of Cam Data ---
|
|
|
|
|
|
thisSwitchCam.strOutputStructName = "thisSwitchCam"
|
|
thisSwitchCam.strOutputFileName = "CameraInfo_FIB2_HeliMichaelToFranklin.txt"
|
|
thisSwitchCam.strXMLFileName = "CameraInfo_FIB2_HeliMichaelToFranklin.xml"
|
|
|
|
thisSwitchCam.bInitialized = TRUE
|
|
//ENDIF
|
|
|
|
thisSwitchCam.piPeds[0] = piMichael
|
|
thisSwitchCam.piPeds[1] = piFranklin
|
|
|
|
|
|
ENDPROC
|
|
|
|
|
|
PROC SETUP_SPLINE_CAM_NODE_ARRAY_HELI_MICHAEL_TO_FRANKLIN_FIRST_PERSON(SWITCH_CAM_STRUCT &thisSwitchCam, PED_INDEX piMichael, PED_INDEX piFranklin)
|
|
CDEBUG3LN(DEBUG_MISSION, "SETUP_SPLINE_CAM_NODE_ARRAY_HELI_MICHAEL_TO_FRANKLIN")
|
|
|
|
//IF NOT thisSwitchCam.bInitialized
|
|
|
|
|
|
//--- Start of Cam Data ---
|
|
|
|
|
|
thisSwitchCam.nodes[0].SwitchCamType = SWITCH_CAM_OLD_SYSTEM
|
|
thisSwitchCam.nodes[0].iForceCamPointAtEntityIndex = -1
|
|
thisSwitchCam.nodes[0].bIsGameplayCamCopy = FALSE
|
|
thisSwitchCam.nodes[0].iNodeTime = 0
|
|
thisSwitchCam.nodes[0].vNodePos = <<-1.9125, 1.3081, -0.1774>>
|
|
thisSwitchCam.nodes[0].vWorldPosLookAt = <<0.0000, 0.0000, 0.0000>>
|
|
thisSwitchCam.nodes[0].fNodeOffsetDist = 0.0000
|
|
thisSwitchCam.nodes[0].fNodeVerticleOffset = 0.0000
|
|
thisSwitchCam.nodes[0].bAttachToOriginPed = FALSE
|
|
thisSwitchCam.nodes[0].vNodeDir = <<0, -1, 0.6>>
|
|
thisSwitchCam.nodes[0].bPointAtEntity = TRUE
|
|
thisSwitchCam.nodes[0].bPointAtOffsetIsRelative = TRUE
|
|
thisSwitchCam.nodes[0].bAttachOffsetIsRelative = TRUE
|
|
thisSwitchCam.nodes[0].fNodeFOV = 40.0000
|
|
thisSwitchCam.nodes[0].vClonedNodeOffset = <<0.0000, 0.0000, 0.0000>>
|
|
thisSwitchCam.nodes[0].iNodeToClone = 0
|
|
thisSwitchCam.nodes[0].NodeTimePostFX_Type = NO_EFFECT
|
|
thisSwitchCam.nodes[0].fNodeTimePostFXBlendTime = 0.0000
|
|
thisSwitchCam.nodes[0].fNodeTimePostFXTimeOffset = 0.0000
|
|
thisSwitchCam.nodes[0].fNodeMotionBlur = 0.0000
|
|
thisSwitchCam.nodes[0].NodeCamShakeType = CAM_SHAKE_DEFAULT
|
|
thisSwitchCam.nodes[0].fNodeCamShake = 0.5000
|
|
thisSwitchCam.nodes[0].iCamEaseType = 0
|
|
thisSwitchCam.nodes[0].fCamEaseScaler = 0.0000
|
|
thisSwitchCam.nodes[0].fCamNodeVelocityScale = 0.0000
|
|
thisSwitchCam.nodes[0].bCamEaseForceLinear = FALSE
|
|
thisSwitchCam.nodes[0].bCamEaseForceLevel = FALSE
|
|
thisSwitchCam.nodes[0].fTimeScale = 0.0000
|
|
thisSwitchCam.nodes[0].iTimeScaleEaseType = 0
|
|
thisSwitchCam.nodes[0].fTimeScaleEaseScaler = 0.0000
|
|
thisSwitchCam.nodes[0].bFlashEnabled = TRUE
|
|
thisSwitchCam.nodes[0].SCFE_FlashEffectUsed = SCFE_SwitchShortMichaelIn
|
|
thisSwitchCam.nodes[0].fMinExposure = 0.0000
|
|
thisSwitchCam.nodes[0].fMaxExposure = 0.0000
|
|
thisSwitchCam.nodes[0].iRampUpDuration = 0
|
|
thisSwitchCam.nodes[0].iRampDownDuration = 0
|
|
thisSwitchCam.nodes[0].iHoldDuration = 0
|
|
thisSwitchCam.nodes[0].fFlashNodePhaseOffset = 0.0000
|
|
thisSwitchCam.nodes[0].bIsLowDetailNode = FALSE
|
|
thisSwitchCam.nodes[0].bUseCustomDOF = FALSE
|
|
thisSwitchCam.nodes[0].NodeDOF_Info.fDOF_NearDOF = 0.0000
|
|
thisSwitchCam.nodes[0].NodeDOF_Info.fDOF_FarDOF = 0.0000
|
|
thisSwitchCam.nodes[0].NodeDOF_Info.fDOF_EffectStrength = 0.0000
|
|
|
|
thisSwitchCam.nodes[1].SwitchCamType = SWITCH_CAM_OLD_SYSTEM
|
|
thisSwitchCam.nodes[1].iForceCamPointAtEntityIndex = -1
|
|
thisSwitchCam.nodes[1].bIsGameplayCamCopy = FALSE
|
|
thisSwitchCam.nodes[1].iNodeTime = 400
|
|
thisSwitchCam.nodes[1].vNodePos = <<-1.9125, 1.3081, -0.3774>>
|
|
thisSwitchCam.nodes[1].vWorldPosLookAt = <<0.0000, 0.0000, 0.0000>>
|
|
thisSwitchCam.nodes[1].fNodeOffsetDist = 0.0000
|
|
thisSwitchCam.nodes[1].fNodeVerticleOffset = 0.0000
|
|
thisSwitchCam.nodes[1].bAttachToOriginPed = FALSE
|
|
thisSwitchCam.nodes[1].vNodeDir = <<0, -1, 0.4>>
|
|
thisSwitchCam.nodes[1].bPointAtEntity = TRUE
|
|
thisSwitchCam.nodes[1].bPointAtOffsetIsRelative = TRUE
|
|
thisSwitchCam.nodes[1].bAttachOffsetIsRelative = TRUE
|
|
thisSwitchCam.nodes[1].fNodeFOV = 40.0000
|
|
thisSwitchCam.nodes[1].vClonedNodeOffset = <<0.0000, 0.0000, 0.0000>>
|
|
thisSwitchCam.nodes[1].iNodeToClone = 0
|
|
thisSwitchCam.nodes[1].NodeTimePostFX_Type = NO_EFFECT
|
|
thisSwitchCam.nodes[1].fNodeTimePostFXBlendTime = 0.0000
|
|
thisSwitchCam.nodes[1].fNodeTimePostFXTimeOffset = 0.0000
|
|
thisSwitchCam.nodes[1].fNodeMotionBlur = 0.0000
|
|
thisSwitchCam.nodes[1].NodeCamShakeType = CAM_SHAKE_MEDIUM
|
|
thisSwitchCam.nodes[1].fNodeCamShake = 0.5000
|
|
thisSwitchCam.nodes[1].iCamEaseType = 0
|
|
thisSwitchCam.nodes[1].fCamEaseScaler = 0.0000
|
|
thisSwitchCam.nodes[1].fCamNodeVelocityScale = 0.0000
|
|
thisSwitchCam.nodes[1].bCamEaseForceLinear = FALSE
|
|
thisSwitchCam.nodes[1].bCamEaseForceLevel = FALSE
|
|
thisSwitchCam.nodes[1].fTimeScale = 1.0000
|
|
thisSwitchCam.nodes[1].iTimeScaleEaseType = 0
|
|
thisSwitchCam.nodes[1].fTimeScaleEaseScaler = 0.0000
|
|
thisSwitchCam.nodes[1].bFlashEnabled = FALSE
|
|
thisSwitchCam.nodes[1].SCFE_FlashEffectUsed = SCFE_CODE_FLASH
|
|
thisSwitchCam.nodes[1].fMinExposure = 0.0000
|
|
thisSwitchCam.nodes[1].fMaxExposure = 0.0000
|
|
thisSwitchCam.nodes[1].iRampUpDuration = 0
|
|
thisSwitchCam.nodes[1].iRampDownDuration = 0
|
|
thisSwitchCam.nodes[1].iHoldDuration = 0
|
|
thisSwitchCam.nodes[1].fFlashNodePhaseOffset = 0.3000
|
|
thisSwitchCam.nodes[1].bIsLowDetailNode = FALSE
|
|
thisSwitchCam.nodes[1].bUseCustomDOF = FALSE
|
|
thisSwitchCam.nodes[1].NodeDOF_Info.fDOF_NearDOF = 0.0000
|
|
thisSwitchCam.nodes[1].NodeDOF_Info.fDOF_FarDOF = 0.0000
|
|
thisSwitchCam.nodes[1].NodeDOF_Info.fDOF_EffectStrength = 0.0000
|
|
|
|
thisSwitchCam.nodes[2].SwitchCamType = SWITCH_CAM_OLD_SYSTEM
|
|
thisSwitchCam.nodes[2].iForceCamPointAtEntityIndex = -1
|
|
thisSwitchCam.nodes[2].bIsGameplayCamCopy = FALSE
|
|
thisSwitchCam.nodes[2].iNodeTime = 600
|
|
thisSwitchCam.nodes[2].vNodePos = <<-1.9125, 1.3081, -2.1774>>
|
|
thisSwitchCam.nodes[2].vWorldPosLookAt = <<0.0000, 0.0000, 0.0000>>
|
|
thisSwitchCam.nodes[2].fNodeOffsetDist = 0.0000
|
|
thisSwitchCam.nodes[2].fNodeVerticleOffset = 0.0000
|
|
thisSwitchCam.nodes[2].bAttachToOriginPed = FALSE
|
|
thisSwitchCam.nodes[2].vNodeDir = <<0, -1, -1.4>>
|
|
thisSwitchCam.nodes[2].bPointAtEntity = TRUE
|
|
thisSwitchCam.nodes[2].bPointAtOffsetIsRelative = TRUE
|
|
thisSwitchCam.nodes[2].bAttachOffsetIsRelative = TRUE
|
|
thisSwitchCam.nodes[2].fNodeFOV = 40.0000
|
|
thisSwitchCam.nodes[2].vClonedNodeOffset = <<0.0000, 0.0000, 0.0000>>
|
|
thisSwitchCam.nodes[2].iNodeToClone = 0
|
|
thisSwitchCam.nodes[2].NodeTimePostFX_Type = NO_EFFECT
|
|
thisSwitchCam.nodes[2].fNodeTimePostFXBlendTime = 0.0000
|
|
thisSwitchCam.nodes[2].fNodeTimePostFXTimeOffset = 0.0000
|
|
thisSwitchCam.nodes[2].fNodeMotionBlur = 1.0000
|
|
thisSwitchCam.nodes[2].NodeCamShakeType = CAM_SHAKE_MEDIUM
|
|
thisSwitchCam.nodes[2].fNodeCamShake = 0.5000
|
|
thisSwitchCam.nodes[2].iCamEaseType = 0
|
|
thisSwitchCam.nodes[2].fCamEaseScaler = 0.0000
|
|
thisSwitchCam.nodes[2].fCamNodeVelocityScale = 0.0000
|
|
thisSwitchCam.nodes[2].bCamEaseForceLinear = FALSE
|
|
thisSwitchCam.nodes[2].bCamEaseForceLevel = FALSE
|
|
thisSwitchCam.nodes[2].fTimeScale = 0.6000
|
|
thisSwitchCam.nodes[2].iTimeScaleEaseType = 0
|
|
thisSwitchCam.nodes[2].fTimeScaleEaseScaler = 0.0000
|
|
thisSwitchCam.nodes[2].bFlashEnabled = TRUE
|
|
thisSwitchCam.nodes[2].SCFE_FlashEffectUsed = SCFE_SwitchShortFranklinMid
|
|
thisSwitchCam.nodes[2].fMinExposure = 0.0000
|
|
thisSwitchCam.nodes[2].fMaxExposure = 0.0000
|
|
thisSwitchCam.nodes[2].iRampUpDuration = 0
|
|
thisSwitchCam.nodes[2].iRampDownDuration = 0
|
|
thisSwitchCam.nodes[2].iHoldDuration = 0
|
|
thisSwitchCam.nodes[2].fFlashNodePhaseOffset = 0.8000
|
|
thisSwitchCam.nodes[2].bIsLowDetailNode = FALSE
|
|
thisSwitchCam.nodes[2].bUseCustomDOF = FALSE
|
|
thisSwitchCam.nodes[2].NodeDOF_Info.fDOF_NearDOF = 0.0000
|
|
thisSwitchCam.nodes[2].NodeDOF_Info.fDOF_FarDOF = 0.0000
|
|
thisSwitchCam.nodes[2].NodeDOF_Info.fDOF_EffectStrength = 0.0000
|
|
|
|
thisSwitchCam.nodes[3].bIsCamCutNode = TRUE
|
|
|
|
thisSwitchCam.nodes[4].SwitchCamType = SWITCH_CAM_OLD_SYSTEM
|
|
thisSwitchCam.nodes[4].iForceCamPointAtEntityIndex = -1
|
|
thisSwitchCam.nodes[4].bIsGameplayCamCopy = FALSE
|
|
thisSwitchCam.nodes[4].iNodeTime = 0
|
|
thisSwitchCam.nodes[4].vNodePos = <<0.0646, 1.3472, 1.4595>>
|
|
thisSwitchCam.nodes[4].vWorldPosLookAt = <<0.0000, 0.0000, 1.4500>>
|
|
thisSwitchCam.nodes[4].fNodeOffsetDist = 0.0000
|
|
thisSwitchCam.nodes[4].fNodeVerticleOffset = 0.0000
|
|
thisSwitchCam.nodes[4].bAttachToOriginPed = FALSE
|
|
thisSwitchCam.nodes[4].vNodeDir = <<0.3564, 0.2439, 1.4688>>
|
|
thisSwitchCam.nodes[4].bPointAtEntity = TRUE
|
|
thisSwitchCam.nodes[4].bPointAtOffsetIsRelative = TRUE
|
|
thisSwitchCam.nodes[4].bAttachOffsetIsRelative = TRUE
|
|
thisSwitchCam.nodes[4].fNodeFOV = 40.0000
|
|
thisSwitchCam.nodes[4].vClonedNodeOffset = <<0.0000, 0.0000, 0.0000>>
|
|
thisSwitchCam.nodes[4].iNodeToClone = 0
|
|
thisSwitchCam.nodes[4].NodeTimePostFX_Type = NO_EFFECT
|
|
thisSwitchCam.nodes[4].fNodeTimePostFXBlendTime = 0.0000
|
|
thisSwitchCam.nodes[4].fNodeTimePostFXTimeOffset = 0.0000
|
|
thisSwitchCam.nodes[4].fNodeMotionBlur = 1.0000
|
|
thisSwitchCam.nodes[4].NodeCamShakeType = CAM_SHAKE_MEDIUM
|
|
thisSwitchCam.nodes[4].fNodeCamShake = 0.5000
|
|
thisSwitchCam.nodes[4].iCamEaseType = 1
|
|
thisSwitchCam.nodes[4].fCamEaseScaler = 1.0000
|
|
thisSwitchCam.nodes[4].fCamNodeVelocityScale = 0.0000
|
|
thisSwitchCam.nodes[4].bCamEaseForceLinear = TRUE
|
|
thisSwitchCam.nodes[4].bCamEaseForceLevel = FALSE
|
|
thisSwitchCam.nodes[4].fTimeScale = 0.3000
|
|
thisSwitchCam.nodes[4].iTimeScaleEaseType = 0
|
|
thisSwitchCam.nodes[4].fTimeScaleEaseScaler = 0.0000
|
|
thisSwitchCam.nodes[4].bFlashEnabled = FALSE
|
|
thisSwitchCam.nodes[4].SCFE_FlashEffectUsed = SCFE_CODE_FLASH
|
|
thisSwitchCam.nodes[4].fMinExposure = 0.0000
|
|
thisSwitchCam.nodes[4].fMaxExposure = 0.0000
|
|
thisSwitchCam.nodes[4].iRampUpDuration = 0
|
|
thisSwitchCam.nodes[4].iRampDownDuration = 0
|
|
thisSwitchCam.nodes[4].iHoldDuration = 0
|
|
thisSwitchCam.nodes[4].fFlashNodePhaseOffset = 0.0000
|
|
thisSwitchCam.nodes[4].bIsLowDetailNode = FALSE
|
|
thisSwitchCam.nodes[4].bUseCustomDOF = FALSE
|
|
thisSwitchCam.nodes[4].NodeDOF_Info.fDOF_NearDOF = 0.0000
|
|
thisSwitchCam.nodes[4].NodeDOF_Info.fDOF_FarDOF = 0.0000
|
|
thisSwitchCam.nodes[4].NodeDOF_Info.fDOF_EffectStrength = 0.0000
|
|
|
|
thisSwitchCam.nodes[5].SwitchCamType = SWITCH_CAM_OLD_SYSTEM
|
|
thisSwitchCam.nodes[5].iForceCamPointAtEntityIndex = -1
|
|
thisSwitchCam.nodes[5].bIsGameplayCamCopy = FALSE
|
|
thisSwitchCam.nodes[5].iNodeTime = 600
|
|
thisSwitchCam.nodes[5].vNodePos = <<-0.0083, 1.3912, 0.2997>>
|
|
thisSwitchCam.nodes[5].vWorldPosLookAt = <<0.0000, 0.0000, 0.4000>>
|
|
thisSwitchCam.nodes[5].fNodeOffsetDist = 0.0000
|
|
thisSwitchCam.nodes[5].fNodeVerticleOffset = 0.0000
|
|
thisSwitchCam.nodes[5].bAttachToOriginPed = FALSE
|
|
thisSwitchCam.nodes[5].vNodeDir = <<0.4002, 0.1876, 0.4090>>
|
|
thisSwitchCam.nodes[5].bPointAtEntity = TRUE
|
|
thisSwitchCam.nodes[5].bPointAtOffsetIsRelative = TRUE
|
|
thisSwitchCam.nodes[5].bAttachOffsetIsRelative = TRUE
|
|
thisSwitchCam.nodes[5].fNodeFOV = 40.0000
|
|
thisSwitchCam.nodes[5].vClonedNodeOffset = <<0.0000, 0.0000, 0.0000>>
|
|
thisSwitchCam.nodes[5].iNodeToClone = 0
|
|
thisSwitchCam.nodes[5].NodeTimePostFX_Type = NO_EFFECT
|
|
thisSwitchCam.nodes[5].fNodeTimePostFXBlendTime = 0.0000
|
|
thisSwitchCam.nodes[5].fNodeTimePostFXTimeOffset = 0.0000
|
|
thisSwitchCam.nodes[5].fNodeMotionBlur = 1.0000
|
|
thisSwitchCam.nodes[5].NodeCamShakeType = CAM_SHAKE_MEDIUM
|
|
thisSwitchCam.nodes[5].fNodeCamShake = 0.5000
|
|
thisSwitchCam.nodes[5].iCamEaseType = 0
|
|
thisSwitchCam.nodes[5].fCamEaseScaler = 0.0000
|
|
thisSwitchCam.nodes[5].fCamNodeVelocityScale = 0.0000
|
|
thisSwitchCam.nodes[5].bCamEaseForceLinear = TRUE
|
|
thisSwitchCam.nodes[5].bCamEaseForceLevel = FALSE
|
|
thisSwitchCam.nodes[5].fTimeScale = 0.3000
|
|
thisSwitchCam.nodes[5].iTimeScaleEaseType = 0
|
|
thisSwitchCam.nodes[5].fTimeScaleEaseScaler = 0.0000
|
|
thisSwitchCam.nodes[5].bFlashEnabled = FALSE
|
|
thisSwitchCam.nodes[5].SCFE_FlashEffectUsed = SCFE_CODE_FLASH
|
|
thisSwitchCam.nodes[5].fMinExposure = 0.0000
|
|
thisSwitchCam.nodes[5].fMaxExposure = 0.0000
|
|
thisSwitchCam.nodes[5].iRampUpDuration = 0
|
|
thisSwitchCam.nodes[5].iRampDownDuration = 0
|
|
thisSwitchCam.nodes[5].iHoldDuration = 0
|
|
thisSwitchCam.nodes[5].fFlashNodePhaseOffset = 0.0000
|
|
thisSwitchCam.nodes[5].bIsLowDetailNode = FALSE
|
|
thisSwitchCam.nodes[5].bUseCustomDOF = FALSE
|
|
thisSwitchCam.nodes[5].NodeDOF_Info.fDOF_NearDOF = 0.0000
|
|
thisSwitchCam.nodes[5].NodeDOF_Info.fDOF_FarDOF = 0.0000
|
|
thisSwitchCam.nodes[5].NodeDOF_Info.fDOF_EffectStrength = 0.0000
|
|
|
|
thisSwitchCam.nodes[6].SwitchCamType = SWITCH_CAM_OLD_SYSTEM
|
|
thisSwitchCam.nodes[6].iForceCamPointAtEntityIndex = -1
|
|
thisSwitchCam.nodes[6].bIsGameplayCamCopy = FALSE
|
|
thisSwitchCam.nodes[6].iNodeTime = 400
|
|
thisSwitchCam.nodes[6].vNodePos = <<-0.0083, 1.3912, 0.2997>>
|
|
thisSwitchCam.nodes[6].vWorldPosLookAt = <<0.0000, 0.0000, 0.4000>>
|
|
thisSwitchCam.nodes[6].fNodeOffsetDist = 0.0000
|
|
thisSwitchCam.nodes[6].fNodeVerticleOffset = 0.0000
|
|
thisSwitchCam.nodes[6].bAttachToOriginPed = FALSE
|
|
thisSwitchCam.nodes[6].vNodeDir = <<0.4002, 0.1876, 0.4090>>
|
|
thisSwitchCam.nodes[6].bPointAtEntity = TRUE
|
|
thisSwitchCam.nodes[6].bPointAtOffsetIsRelative = TRUE
|
|
thisSwitchCam.nodes[6].bAttachOffsetIsRelative = TRUE
|
|
thisSwitchCam.nodes[6].fNodeFOV = 40.0000
|
|
thisSwitchCam.nodes[6].vClonedNodeOffset = <<0.0000, 0.0000, 0.0000>>
|
|
thisSwitchCam.nodes[6].iNodeToClone = 0
|
|
thisSwitchCam.nodes[6].NodeTimePostFX_Type = NO_EFFECT
|
|
thisSwitchCam.nodes[6].fNodeTimePostFXBlendTime = 0.0000
|
|
thisSwitchCam.nodes[6].fNodeTimePostFXTimeOffset = 0.0000
|
|
thisSwitchCam.nodes[6].fNodeMotionBlur = 0.0000
|
|
thisSwitchCam.nodes[6].NodeCamShakeType = CAM_SHAKE_MEDIUM
|
|
thisSwitchCam.nodes[6].fNodeCamShake = 0.5000
|
|
thisSwitchCam.nodes[6].iCamEaseType = 0
|
|
thisSwitchCam.nodes[6].fCamEaseScaler = 0.0000
|
|
thisSwitchCam.nodes[6].fCamNodeVelocityScale = 0.0000
|
|
thisSwitchCam.nodes[6].bCamEaseForceLinear = TRUE
|
|
thisSwitchCam.nodes[6].bCamEaseForceLevel = FALSE
|
|
thisSwitchCam.nodes[6].fTimeScale = 1.0000
|
|
thisSwitchCam.nodes[6].iTimeScaleEaseType = 0
|
|
thisSwitchCam.nodes[6].fTimeScaleEaseScaler = 0.0000
|
|
thisSwitchCam.nodes[6].bFlashEnabled = FALSE
|
|
thisSwitchCam.nodes[6].SCFE_FlashEffectUsed = SCFE_CODE_FLASH
|
|
thisSwitchCam.nodes[6].fMinExposure = 0.0000
|
|
thisSwitchCam.nodes[6].fMaxExposure = 0.0000
|
|
thisSwitchCam.nodes[6].iRampUpDuration = 0
|
|
thisSwitchCam.nodes[6].iRampDownDuration = 0
|
|
thisSwitchCam.nodes[6].iHoldDuration = 0
|
|
thisSwitchCam.nodes[6].fFlashNodePhaseOffset = 0.0000
|
|
thisSwitchCam.nodes[6].bIsLowDetailNode = FALSE
|
|
thisSwitchCam.nodes[6].bUseCustomDOF = FALSE
|
|
thisSwitchCam.nodes[6].NodeDOF_Info.fDOF_NearDOF = 0.0000
|
|
thisSwitchCam.nodes[6].NodeDOF_Info.fDOF_FarDOF = 0.0000
|
|
thisSwitchCam.nodes[6].NodeDOF_Info.fDOF_EffectStrength = 0.0000
|
|
|
|
|
|
|
|
thisSwitchCam.iNumNodes = 7
|
|
thisSwitchCam.iCamSwitchFocusNode = 3
|
|
thisSwitchCam.fSwitchSoundAudioStartPhase = 0.07
|
|
thisSwitchCam.fSwitchSoundAudioEndPhase = 0.45
|
|
thisSwitchCam.bSwitchSoundPlayOpeningPulse = FALSE
|
|
thisSwitchCam.bSwitchSoundPlayMoveLoop = FALSE
|
|
thisSwitchCam.bSwitchSoundPlayExitPulse = FALSE
|
|
thisSwitchCam.bSplineNoSmoothing = FALSE
|
|
thisSwitchCam.bAddGameplayCamAsLastNode = FALSE
|
|
thisSwitchCam.iGameplayNodeBlendDuration = 0
|
|
|
|
|
|
//--- End of Cam Data ---
|
|
|
|
|
|
thisSwitchCam.strOutputStructName = "thisSwitchCam"
|
|
thisSwitchCam.strOutputFileName = "CameraInfo_FIB2_HeliMichaelToFranklin.txt"
|
|
thisSwitchCam.strXMLFileName = "CameraInfo_FIB2_HeliMichaelToFranklin.xml"
|
|
|
|
thisSwitchCam.bInitialized = TRUE
|
|
//ENDIF
|
|
|
|
thisSwitchCam.piPeds[0] = piMichael
|
|
thisSwitchCam.piPeds[1] = piFranklin
|
|
|
|
|
|
ENDPROC
|
|
|
|
|
|
PROC SETUP_SPLINE_CAM_NODE_ARRAY_HELI_TREVOR_TO_FRANKLIN(SWITCH_CAM_STRUCT &thisSwitchCam, VEHICLE_INDEX viHeli, PED_INDEX piFranklin)
|
|
CDEBUG3LN(DEBUG_MISSION, "SETUP_SPLINE_CAM_NODE_ARRAY_HELI_TREVOR_TO_FRANKLIN")
|
|
|
|
//IF NOT thisSwitchCam.bInitialized
|
|
|
|
|
|
//--- Start of Cam Data ---
|
|
|
|
|
|
thisSwitchCam.nodes[0].SwitchCamType = SWITCH_CAM_OLD_SYSTEM
|
|
thisSwitchCam.nodes[0].iForceCamPointAtEntityIndex = -1
|
|
thisSwitchCam.nodes[0].bIsGameplayCamCopy = TRUE
|
|
thisSwitchCam.nodes[0].iNodeTime = 0
|
|
thisSwitchCam.nodes[0].vNodePos = <<-425.2161, -1215.4039, 195.0455>>
|
|
thisSwitchCam.nodes[0].vWorldPosLookAt = <<0.0000, 0.0000, 0.2000>>
|
|
thisSwitchCam.nodes[0].fNodeOffsetDist = 0.0000
|
|
thisSwitchCam.nodes[0].fNodeVerticleOffset = 0.0000
|
|
thisSwitchCam.nodes[0].bAttachToOriginPed = FALSE
|
|
thisSwitchCam.nodes[0].vNodeDir = <<-14.1385, -8.8904, -171.0823>>
|
|
thisSwitchCam.nodes[0].bPointAtEntity = FALSE
|
|
thisSwitchCam.nodes[0].bPointAtOffsetIsRelative = FALSE
|
|
thisSwitchCam.nodes[0].bAttachOffsetIsRelative = FALSE
|
|
thisSwitchCam.nodes[0].fNodeFOV = 64.7053
|
|
thisSwitchCam.nodes[0].vClonedNodeOffset = <<0.0000, 0.0000, 0.0000>>
|
|
thisSwitchCam.nodes[0].iNodeToClone = 0
|
|
thisSwitchCam.nodes[0].NodeTimePostFX_Type = NO_EFFECT
|
|
thisSwitchCam.nodes[0].fNodeTimePostFXBlendTime = 0.0000
|
|
thisSwitchCam.nodes[0].fNodeTimePostFXTimeOffset = 0.0000
|
|
thisSwitchCam.nodes[0].fNodeMotionBlur = 0.0000
|
|
thisSwitchCam.nodes[0].NodeCamShakeType = CAM_SHAKE_DEFAULT
|
|
thisSwitchCam.nodes[0].fNodeCamShake = 0.0000
|
|
thisSwitchCam.nodes[0].iCamEaseType = 0
|
|
thisSwitchCam.nodes[0].fCamEaseScaler = 0.0000
|
|
thisSwitchCam.nodes[0].fCamNodeVelocityScale = 0.0000
|
|
thisSwitchCam.nodes[0].bCamEaseForceLinear = FALSE
|
|
thisSwitchCam.nodes[0].bCamEaseForceLevel = FALSE
|
|
thisSwitchCam.nodes[0].fTimeScale = 0.0100
|
|
thisSwitchCam.nodes[0].iTimeScaleEaseType = 0
|
|
thisSwitchCam.nodes[0].fTimeScaleEaseScaler = 0.0000
|
|
thisSwitchCam.nodes[0].bFlashEnabled = FALSE
|
|
thisSwitchCam.nodes[0].SCFE_FlashEffectUsed = SCFE_CODE_FLASH
|
|
thisSwitchCam.nodes[0].fMinExposure = 0.0000
|
|
thisSwitchCam.nodes[0].fMaxExposure = 0.0000
|
|
thisSwitchCam.nodes[0].iRampUpDuration = 0
|
|
thisSwitchCam.nodes[0].iRampDownDuration = 0
|
|
thisSwitchCam.nodes[0].iHoldDuration = 0
|
|
thisSwitchCam.nodes[0].fFlashNodePhaseOffset = 0.0000
|
|
thisSwitchCam.nodes[0].bIsLowDetailNode = FALSE
|
|
thisSwitchCam.nodes[0].bUseCustomDOF = FALSE
|
|
thisSwitchCam.nodes[0].NodeDOF_Info.fDOF_NearDOF = 0.0000
|
|
thisSwitchCam.nodes[0].NodeDOF_Info.fDOF_FarDOF = 0.0000
|
|
thisSwitchCam.nodes[0].NodeDOF_Info.fDOF_EffectStrength = 0.0000
|
|
|
|
thisSwitchCam.nodes[1].SwitchCamType = SWITCH_CAM_OLD_SYSTEM
|
|
thisSwitchCam.nodes[1].iForceCamPointAtEntityIndex = -1
|
|
thisSwitchCam.nodes[1].bIsGameplayCamCopy = TRUE
|
|
thisSwitchCam.nodes[1].iNodeTime = 100
|
|
thisSwitchCam.nodes[1].vNodePos = <<0.1000, 0.1000, 0.1000>>
|
|
thisSwitchCam.nodes[1].vWorldPosLookAt = <<0.0000, 0.0000, 0.2000>>
|
|
thisSwitchCam.nodes[1].fNodeOffsetDist = 0.0000
|
|
thisSwitchCam.nodes[1].fNodeVerticleOffset = 0.0000
|
|
thisSwitchCam.nodes[1].bAttachToOriginPed = FALSE
|
|
thisSwitchCam.nodes[1].vNodeDir = <<0.0000, 0.0000, 0.0000>>
|
|
thisSwitchCam.nodes[1].bPointAtEntity = TRUE
|
|
thisSwitchCam.nodes[1].bPointAtOffsetIsRelative = TRUE
|
|
thisSwitchCam.nodes[1].bAttachOffsetIsRelative = TRUE
|
|
thisSwitchCam.nodes[1].fNodeFOV = 45.0000
|
|
thisSwitchCam.nodes[1].vClonedNodeOffset = <<0.0000, 0.0000, 0.0000>>
|
|
thisSwitchCam.nodes[1].iNodeToClone = 0
|
|
thisSwitchCam.nodes[1].NodeTimePostFX_Type = NO_EFFECT
|
|
thisSwitchCam.nodes[1].fNodeTimePostFXBlendTime = 0.0000
|
|
thisSwitchCam.nodes[1].fNodeTimePostFXTimeOffset = 0.0000
|
|
thisSwitchCam.nodes[1].fNodeMotionBlur = 0.0000
|
|
thisSwitchCam.nodes[1].NodeCamShakeType = CAM_SHAKE_DEFAULT
|
|
thisSwitchCam.nodes[1].fNodeCamShake = 0.0000
|
|
thisSwitchCam.nodes[1].iCamEaseType = 0
|
|
thisSwitchCam.nodes[1].fCamEaseScaler = 0.0000
|
|
thisSwitchCam.nodes[1].fCamNodeVelocityScale = 0.0000
|
|
thisSwitchCam.nodes[1].bCamEaseForceLinear = FALSE
|
|
thisSwitchCam.nodes[1].bCamEaseForceLevel = FALSE
|
|
thisSwitchCam.nodes[1].fTimeScale = 0.5000
|
|
thisSwitchCam.nodes[1].iTimeScaleEaseType = 0
|
|
thisSwitchCam.nodes[1].fTimeScaleEaseScaler = 0.0000
|
|
thisSwitchCam.nodes[1].bFlashEnabled = TRUE
|
|
thisSwitchCam.nodes[1].SCFE_FlashEffectUsed = SCFE_SwitchShortTrevorIn
|
|
thisSwitchCam.nodes[1].fMinExposure = 0.0000
|
|
thisSwitchCam.nodes[1].fMaxExposure = 0.0000
|
|
thisSwitchCam.nodes[1].iRampUpDuration = 0
|
|
thisSwitchCam.nodes[1].iRampDownDuration = 0
|
|
thisSwitchCam.nodes[1].iHoldDuration = 0
|
|
thisSwitchCam.nodes[1].fFlashNodePhaseOffset = 0.5000
|
|
thisSwitchCam.nodes[1].bIsLowDetailNode = FALSE
|
|
thisSwitchCam.nodes[1].bUseCustomDOF = FALSE
|
|
thisSwitchCam.nodes[1].NodeDOF_Info.fDOF_NearDOF = 0.0000
|
|
thisSwitchCam.nodes[1].NodeDOF_Info.fDOF_FarDOF = 0.0000
|
|
thisSwitchCam.nodes[1].NodeDOF_Info.fDOF_EffectStrength = 0.0000
|
|
|
|
thisSwitchCam.nodes[2].SwitchCamType = SWITCH_CAM_CLONE_NODE_WITH_OFFSET
|
|
thisSwitchCam.nodes[2].iForceCamPointAtEntityIndex = -1
|
|
thisSwitchCam.nodes[2].bIsGameplayCamCopy = FALSE
|
|
thisSwitchCam.nodes[2].iNodeTime = 600
|
|
thisSwitchCam.nodes[2].vNodePos = <<-311.0187, -440.2700, 187.0327>>
|
|
thisSwitchCam.nodes[2].vWorldPosLookAt = <<0.0000, 0.0000, 0.2000>>
|
|
thisSwitchCam.nodes[2].fNodeOffsetDist = 0.0000
|
|
thisSwitchCam.nodes[2].fNodeVerticleOffset = 0.0000
|
|
thisSwitchCam.nodes[2].bAttachToOriginPed = FALSE
|
|
thisSwitchCam.nodes[2].vNodeDir = <<-2.8659, 0.2449, 118.1404>>
|
|
thisSwitchCam.nodes[2].bPointAtEntity = FALSE
|
|
thisSwitchCam.nodes[2].bPointAtOffsetIsRelative = FALSE
|
|
thisSwitchCam.nodes[2].bAttachOffsetIsRelative = FALSE
|
|
thisSwitchCam.nodes[2].fNodeFOV = 64.7053
|
|
thisSwitchCam.nodes[2].vClonedNodeOffset = <<0.0000, 0.0000, -10.0000>>
|
|
thisSwitchCam.nodes[2].iNodeToClone = 0
|
|
thisSwitchCam.nodes[2].NodeTimePostFX_Type = NO_EFFECT
|
|
thisSwitchCam.nodes[2].fNodeTimePostFXBlendTime = 0.0000
|
|
thisSwitchCam.nodes[2].fNodeTimePostFXTimeOffset = 0.0000
|
|
thisSwitchCam.nodes[2].fNodeMotionBlur = 1.0000
|
|
thisSwitchCam.nodes[2].NodeCamShakeType = CAM_SHAKE_DEFAULT
|
|
thisSwitchCam.nodes[2].fNodeCamShake = 0.0000
|
|
thisSwitchCam.nodes[2].iCamEaseType = 0
|
|
thisSwitchCam.nodes[2].fCamEaseScaler = 0.0000
|
|
thisSwitchCam.nodes[2].fCamNodeVelocityScale = 0.0000
|
|
thisSwitchCam.nodes[2].bCamEaseForceLinear = FALSE
|
|
thisSwitchCam.nodes[2].bCamEaseForceLevel = TRUE
|
|
thisSwitchCam.nodes[2].fTimeScale = 0.3000
|
|
thisSwitchCam.nodes[2].iTimeScaleEaseType = 0
|
|
thisSwitchCam.nodes[2].fTimeScaleEaseScaler = 0.0000
|
|
thisSwitchCam.nodes[2].bFlashEnabled = TRUE
|
|
thisSwitchCam.nodes[2].SCFE_FlashEffectUsed = SCFE_SwitchShortFranklinMid
|
|
thisSwitchCam.nodes[2].fMinExposure = 0.0000
|
|
thisSwitchCam.nodes[2].fMaxExposure = 0.0000
|
|
thisSwitchCam.nodes[2].iRampUpDuration = 0
|
|
thisSwitchCam.nodes[2].iRampDownDuration = 0
|
|
thisSwitchCam.nodes[2].iHoldDuration = 0
|
|
thisSwitchCam.nodes[2].fFlashNodePhaseOffset = 0.5000
|
|
thisSwitchCam.nodes[2].bIsLowDetailNode = FALSE
|
|
thisSwitchCam.nodes[2].bUseCustomDOF = FALSE
|
|
thisSwitchCam.nodes[2].NodeDOF_Info.fDOF_NearDOF = 0.0000
|
|
thisSwitchCam.nodes[2].NodeDOF_Info.fDOF_FarDOF = 0.0000
|
|
thisSwitchCam.nodes[2].NodeDOF_Info.fDOF_EffectStrength = 0.0000
|
|
|
|
thisSwitchCam.nodes[3].bIsCamCutNode = TRUE
|
|
|
|
thisSwitchCam.nodes[4].SwitchCamType = SWITCH_CAM_OLD_SYSTEM
|
|
thisSwitchCam.nodes[4].iForceCamPointAtEntityIndex = -1
|
|
thisSwitchCam.nodes[4].bIsGameplayCamCopy = FALSE
|
|
thisSwitchCam.nodes[4].iNodeTime = 0
|
|
thisSwitchCam.nodes[4].vNodePos = <<0.0646, 1.3472, 1.4595>>
|
|
thisSwitchCam.nodes[4].vWorldPosLookAt = <<0.0000, 0.0000, 0.4000>>
|
|
thisSwitchCam.nodes[4].fNodeOffsetDist = 0.0000
|
|
thisSwitchCam.nodes[4].fNodeVerticleOffset = 0.0000
|
|
thisSwitchCam.nodes[4].bAttachToOriginPed = FALSE
|
|
thisSwitchCam.nodes[4].vNodeDir = <<0.3564, 0.2439, 1.4688>>
|
|
thisSwitchCam.nodes[4].bPointAtEntity = TRUE
|
|
thisSwitchCam.nodes[4].bPointAtOffsetIsRelative = TRUE
|
|
thisSwitchCam.nodes[4].bAttachOffsetIsRelative = TRUE
|
|
thisSwitchCam.nodes[4].fNodeFOV = 40.0000
|
|
thisSwitchCam.nodes[4].vClonedNodeOffset = <<0.0000, 0.0000, 0.0000>>
|
|
thisSwitchCam.nodes[4].iNodeToClone = 0
|
|
thisSwitchCam.nodes[4].NodeTimePostFX_Type = NO_EFFECT
|
|
thisSwitchCam.nodes[4].fNodeTimePostFXBlendTime = 0.0000
|
|
thisSwitchCam.nodes[4].fNodeTimePostFXTimeOffset = 0.0000
|
|
thisSwitchCam.nodes[4].fNodeMotionBlur = 1.0
|
|
thisSwitchCam.nodes[4].NodeCamShakeType = CAM_SHAKE_MEDIUM
|
|
thisSwitchCam.nodes[4].fNodeCamShake = 0.5000
|
|
thisSwitchCam.nodes[4].iCamEaseType = 1
|
|
thisSwitchCam.nodes[4].fCamEaseScaler = 1.0000
|
|
thisSwitchCam.nodes[4].fCamNodeVelocityScale = 0.0000
|
|
thisSwitchCam.nodes[4].bCamEaseForceLinear = TRUE
|
|
thisSwitchCam.nodes[4].bCamEaseForceLevel = FALSE
|
|
thisSwitchCam.nodes[4].fTimeScale = 0.3000
|
|
thisSwitchCam.nodes[4].iTimeScaleEaseType = 0
|
|
thisSwitchCam.nodes[4].fTimeScaleEaseScaler = 0.0000
|
|
thisSwitchCam.nodes[4].bFlashEnabled = FALSE
|
|
thisSwitchCam.nodes[4].SCFE_FlashEffectUsed = SCFE_CODE_FLASH
|
|
thisSwitchCam.nodes[4].fMinExposure = 0.0000
|
|
thisSwitchCam.nodes[4].fMaxExposure = 0.0000
|
|
thisSwitchCam.nodes[4].iRampUpDuration = 0
|
|
thisSwitchCam.nodes[4].iRampDownDuration = 0
|
|
thisSwitchCam.nodes[4].iHoldDuration = 0
|
|
thisSwitchCam.nodes[4].fFlashNodePhaseOffset = 0.0000
|
|
thisSwitchCam.nodes[4].bIsLowDetailNode = FALSE
|
|
thisSwitchCam.nodes[4].bUseCustomDOF = FALSE
|
|
thisSwitchCam.nodes[4].NodeDOF_Info.fDOF_NearDOF = 0.0000
|
|
thisSwitchCam.nodes[4].NodeDOF_Info.fDOF_FarDOF = 0.0000
|
|
thisSwitchCam.nodes[4].NodeDOF_Info.fDOF_EffectStrength = 0.0000
|
|
|
|
thisSwitchCam.nodes[5].SwitchCamType = SWITCH_CAM_OLD_SYSTEM
|
|
thisSwitchCam.nodes[5].iForceCamPointAtEntityIndex = -1
|
|
thisSwitchCam.nodes[5].bIsGameplayCamCopy = FALSE
|
|
thisSwitchCam.nodes[5].iNodeTime = 600
|
|
thisSwitchCam.nodes[5].vNodePos = <<-0.0083, 1.3912, 0.2997>>
|
|
thisSwitchCam.nodes[5].vWorldPosLookAt = <<0.0000, 0.0000, 0.4000>>
|
|
thisSwitchCam.nodes[5].fNodeOffsetDist = 0.0000
|
|
thisSwitchCam.nodes[5].fNodeVerticleOffset = 0.0000
|
|
thisSwitchCam.nodes[5].bAttachToOriginPed = FALSE
|
|
thisSwitchCam.nodes[5].vNodeDir = <<0.4002, 0.1876, 0.4090>>
|
|
thisSwitchCam.nodes[5].bPointAtEntity = TRUE
|
|
thisSwitchCam.nodes[5].bPointAtOffsetIsRelative = TRUE
|
|
thisSwitchCam.nodes[5].bAttachOffsetIsRelative = TRUE
|
|
thisSwitchCam.nodes[5].fNodeFOV = 40.0000
|
|
thisSwitchCam.nodes[5].vClonedNodeOffset = <<0.0000, 0.0000, 0.0000>>
|
|
thisSwitchCam.nodes[5].iNodeToClone = 0
|
|
thisSwitchCam.nodes[5].NodeTimePostFX_Type = NO_EFFECT
|
|
thisSwitchCam.nodes[5].fNodeTimePostFXBlendTime = 0.0000
|
|
thisSwitchCam.nodes[5].fNodeTimePostFXTimeOffset = 0.0000
|
|
thisSwitchCam.nodes[5].fNodeMotionBlur = 1.0
|
|
thisSwitchCam.nodes[5].NodeCamShakeType = CAM_SHAKE_MEDIUM
|
|
thisSwitchCam.nodes[5].fNodeCamShake = 0.5000
|
|
thisSwitchCam.nodes[5].iCamEaseType = 0
|
|
thisSwitchCam.nodes[5].fCamEaseScaler = 0.0000
|
|
thisSwitchCam.nodes[5].fCamNodeVelocityScale = 0.0000
|
|
thisSwitchCam.nodes[5].bCamEaseForceLinear = TRUE
|
|
thisSwitchCam.nodes[5].bCamEaseForceLevel = FALSE
|
|
thisSwitchCam.nodes[5].fTimeScale = 0.3
|
|
thisSwitchCam.nodes[5].iTimeScaleEaseType = 0
|
|
thisSwitchCam.nodes[5].fTimeScaleEaseScaler = 0.0000
|
|
thisSwitchCam.nodes[5].bFlashEnabled = FALSE
|
|
thisSwitchCam.nodes[5].SCFE_FlashEffectUsed = SCFE_CODE_FLASH
|
|
thisSwitchCam.nodes[5].fMinExposure = 0.0000
|
|
thisSwitchCam.nodes[5].fMaxExposure = 0.0000
|
|
thisSwitchCam.nodes[5].iRampUpDuration = 0
|
|
thisSwitchCam.nodes[5].iRampDownDuration = 0
|
|
thisSwitchCam.nodes[5].iHoldDuration = 0
|
|
thisSwitchCam.nodes[5].fFlashNodePhaseOffset = 0.0000
|
|
thisSwitchCam.nodes[5].bIsLowDetailNode = FALSE
|
|
thisSwitchCam.nodes[5].bUseCustomDOF = FALSE
|
|
thisSwitchCam.nodes[5].NodeDOF_Info.fDOF_NearDOF = 0.0000
|
|
thisSwitchCam.nodes[5].NodeDOF_Info.fDOF_FarDOF = 0.0000
|
|
thisSwitchCam.nodes[5].NodeDOF_Info.fDOF_EffectStrength = 0.0000
|
|
|
|
thisSwitchCam.nodes[6].SwitchCamType = SWITCH_CAM_OLD_SYSTEM
|
|
thisSwitchCam.nodes[6].iForceCamPointAtEntityIndex = -1
|
|
thisSwitchCam.nodes[6].bIsGameplayCamCopy = FALSE
|
|
thisSwitchCam.nodes[6].iNodeTime = 400
|
|
thisSwitchCam.nodes[6].vNodePos = <<-0.0083, 1.3912, 0.2997>>
|
|
thisSwitchCam.nodes[6].vWorldPosLookAt = <<0.0000, 0.0000, 0.0000>>
|
|
thisSwitchCam.nodes[6].fNodeOffsetDist = 0.0000
|
|
thisSwitchCam.nodes[6].fNodeVerticleOffset = 0.0000
|
|
thisSwitchCam.nodes[6].bAttachToOriginPed = FALSE
|
|
thisSwitchCam.nodes[6].vNodeDir = <<0.4002, 0.1876, 0.4090>>
|
|
thisSwitchCam.nodes[6].bPointAtEntity = TRUE
|
|
thisSwitchCam.nodes[6].bPointAtOffsetIsRelative = TRUE
|
|
thisSwitchCam.nodes[6].bAttachOffsetIsRelative = TRUE
|
|
thisSwitchCam.nodes[6].fNodeFOV = 40.0000
|
|
thisSwitchCam.nodes[6].vClonedNodeOffset = <<0.0000, 0.0000, 0.0000>>
|
|
thisSwitchCam.nodes[6].iNodeToClone = 0
|
|
thisSwitchCam.nodes[6].NodeTimePostFX_Type = NO_EFFECT
|
|
thisSwitchCam.nodes[6].fNodeTimePostFXBlendTime = 0.0000
|
|
thisSwitchCam.nodes[6].fNodeTimePostFXTimeOffset = 0.0000
|
|
thisSwitchCam.nodes[6].fNodeMotionBlur = 0.0000
|
|
thisSwitchCam.nodes[6].NodeCamShakeType = CAM_SHAKE_MEDIUM
|
|
thisSwitchCam.nodes[6].fNodeCamShake = 0.5000
|
|
thisSwitchCam.nodes[6].iCamEaseType = 0
|
|
thisSwitchCam.nodes[6].fCamEaseScaler = 0.0000
|
|
thisSwitchCam.nodes[6].fCamNodeVelocityScale = 0.0000
|
|
thisSwitchCam.nodes[6].bCamEaseForceLinear = TRUE
|
|
thisSwitchCam.nodes[6].bCamEaseForceLevel = FALSE
|
|
thisSwitchCam.nodes[6].fTimeScale = 1.0000
|
|
thisSwitchCam.nodes[6].iTimeScaleEaseType = 0
|
|
thisSwitchCam.nodes[6].fTimeScaleEaseScaler = 0.0000
|
|
thisSwitchCam.nodes[6].bFlashEnabled = FALSE
|
|
thisSwitchCam.nodes[6].SCFE_FlashEffectUsed = SCFE_CODE_FLASH
|
|
thisSwitchCam.nodes[6].fMinExposure = 0.0000
|
|
thisSwitchCam.nodes[6].fMaxExposure = 0.0000
|
|
thisSwitchCam.nodes[6].iRampUpDuration = 0
|
|
thisSwitchCam.nodes[6].iRampDownDuration = 0
|
|
thisSwitchCam.nodes[6].iHoldDuration = 0
|
|
thisSwitchCam.nodes[6].fFlashNodePhaseOffset = 0.0000
|
|
thisSwitchCam.nodes[6].bIsLowDetailNode = FALSE
|
|
thisSwitchCam.nodes[6].bUseCustomDOF = FALSE
|
|
thisSwitchCam.nodes[6].NodeDOF_Info.fDOF_NearDOF = 0.0000
|
|
thisSwitchCam.nodes[6].NodeDOF_Info.fDOF_FarDOF = 0.0000
|
|
thisSwitchCam.nodes[6].NodeDOF_Info.fDOF_EffectStrength = 0.0000
|
|
|
|
|
|
|
|
thisSwitchCam.iNumNodes = 7
|
|
thisSwitchCam.iCamSwitchFocusNode = 3
|
|
thisSwitchCam.fSwitchSoundAudioStartPhase = 0.06
|
|
thisSwitchCam.fSwitchSoundAudioEndPhase = 0.38
|
|
thisSwitchCam.bSwitchSoundPlayOpeningPulse = FALSE
|
|
thisSwitchCam.bSwitchSoundPlayMoveLoop = FALSE
|
|
thisSwitchCam.bSwitchSoundPlayExitPulse = FALSE
|
|
thisSwitchCam.bSplineNoSmoothing = FALSE
|
|
thisSwitchCam.bAddGameplayCamAsLastNode = FALSE
|
|
thisSwitchCam.iGameplayNodeBlendDuration = 0
|
|
|
|
|
|
//--- End of Cam Data ---
|
|
|
|
|
|
|
|
thisSwitchCam.strOutputStructName = "thisSwitchCam"
|
|
thisSwitchCam.strOutputFileName = "CameraInfo_FIB2_HeliTrevorToFranklin.txt"
|
|
thisSwitchCam.strXMLFileName = "CameraInfo_FIB2_HeliTrevorToFranklin.xml"
|
|
|
|
thisSwitchCam.bInitialized = TRUE
|
|
//ENDIF
|
|
|
|
thisSwitchCam.viVehicles[0] = viHeli
|
|
thisSwitchCam.piPeds[1] = piFranklin
|
|
|
|
|
|
ENDPROC
|
|
|
|
|
|
|
|
PROC SETUP_SPLINE_CAM_NODE_ARRAY_HELI_TREVOR_TO_FRANKLIN_FIRST_PERSON(SWITCH_CAM_STRUCT &thisSwitchCam, PED_INDEX piTrevor, PED_INDEX piFranklin)
|
|
CDEBUG3LN(DEBUG_MISSION, "SETUP_SPLINE_CAM_NODE_ARRAY_HELI_MICHAEL_TO_FRANKLIN")
|
|
|
|
//IF NOT thisSwitchCam.bInitialized
|
|
|
|
|
|
//--- Start of Cam Data ---
|
|
|
|
|
|
thisSwitchCam.nodes[0].SwitchCamType = SWITCH_CAM_OLD_SYSTEM
|
|
thisSwitchCam.nodes[0].iForceCamPointAtEntityIndex = -1
|
|
thisSwitchCam.nodes[0].bIsGameplayCamCopy = FALSE
|
|
thisSwitchCam.nodes[0].iNodeTime = 0
|
|
thisSwitchCam.nodes[0].vNodePos = <<-1.6125, 2.0081, 0.6774>>
|
|
thisSwitchCam.nodes[0].vWorldPosLookAt = <<0.0000, 0.0000, 0.0000>>
|
|
thisSwitchCam.nodes[0].fNodeOffsetDist = 0.0000
|
|
thisSwitchCam.nodes[0].fNodeVerticleOffset = 0.0000
|
|
thisSwitchCam.nodes[0].bAttachToOriginPed = FALSE
|
|
thisSwitchCam.nodes[0].vNodeDir = <<-0.5, 0.9, 0.3>>
|
|
thisSwitchCam.nodes[0].bPointAtEntity = TRUE
|
|
thisSwitchCam.nodes[0].bPointAtOffsetIsRelative = TRUE
|
|
thisSwitchCam.nodes[0].bAttachOffsetIsRelative = TRUE
|
|
thisSwitchCam.nodes[0].fNodeFOV = 40.0000
|
|
thisSwitchCam.nodes[0].vClonedNodeOffset = <<0.0000, 0.0000, 0.0000>>
|
|
thisSwitchCam.nodes[0].iNodeToClone = 0
|
|
thisSwitchCam.nodes[0].NodeTimePostFX_Type = NO_EFFECT
|
|
thisSwitchCam.nodes[0].fNodeTimePostFXBlendTime = 0.0000
|
|
thisSwitchCam.nodes[0].fNodeTimePostFXTimeOffset = 0.0000
|
|
thisSwitchCam.nodes[0].fNodeMotionBlur = 0.0000
|
|
thisSwitchCam.nodes[0].NodeCamShakeType = CAM_SHAKE_DEFAULT
|
|
thisSwitchCam.nodes[0].fNodeCamShake = 0.5000
|
|
thisSwitchCam.nodes[0].iCamEaseType = 0
|
|
thisSwitchCam.nodes[0].fCamEaseScaler = 0.0000
|
|
thisSwitchCam.nodes[0].fCamNodeVelocityScale = 0.0000
|
|
thisSwitchCam.nodes[0].bCamEaseForceLinear = FALSE
|
|
thisSwitchCam.nodes[0].bCamEaseForceLevel = FALSE
|
|
thisSwitchCam.nodes[0].fTimeScale = 0.0000
|
|
thisSwitchCam.nodes[0].iTimeScaleEaseType = 0
|
|
thisSwitchCam.nodes[0].fTimeScaleEaseScaler = 0.0000
|
|
thisSwitchCam.nodes[0].bFlashEnabled = TRUE
|
|
thisSwitchCam.nodes[0].SCFE_FlashEffectUsed = SCFE_SwitchShortTrevorIn
|
|
thisSwitchCam.nodes[0].fMinExposure = 0.0000
|
|
thisSwitchCam.nodes[0].fMaxExposure = 0.0000
|
|
thisSwitchCam.nodes[0].iRampUpDuration = 0
|
|
thisSwitchCam.nodes[0].iRampDownDuration = 0
|
|
thisSwitchCam.nodes[0].iHoldDuration = 0
|
|
thisSwitchCam.nodes[0].fFlashNodePhaseOffset = 0.0000
|
|
thisSwitchCam.nodes[0].bIsLowDetailNode = FALSE
|
|
thisSwitchCam.nodes[0].bUseCustomDOF = FALSE
|
|
thisSwitchCam.nodes[0].NodeDOF_Info.fDOF_NearDOF = 0.0000
|
|
thisSwitchCam.nodes[0].NodeDOF_Info.fDOF_FarDOF = 0.0000
|
|
thisSwitchCam.nodes[0].NodeDOF_Info.fDOF_EffectStrength = 0.0000
|
|
|
|
thisSwitchCam.nodes[1].SwitchCamType = SWITCH_CAM_OLD_SYSTEM
|
|
thisSwitchCam.nodes[1].iForceCamPointAtEntityIndex = -1
|
|
thisSwitchCam.nodes[1].bIsGameplayCamCopy = FALSE
|
|
thisSwitchCam.nodes[1].iNodeTime = 400
|
|
thisSwitchCam.nodes[1].vNodePos = <<-1.6125, 2.0081, 0.4774>>
|
|
thisSwitchCam.nodes[1].vWorldPosLookAt = <<0.0000, 0.0000, 0.0000>>
|
|
thisSwitchCam.nodes[1].fNodeOffsetDist = 0.0000
|
|
thisSwitchCam.nodes[1].fNodeVerticleOffset = 0.0000
|
|
thisSwitchCam.nodes[1].bAttachToOriginPed = FALSE
|
|
thisSwitchCam.nodes[1].vNodeDir = <<-0.5, 0.9, 0.1>>
|
|
thisSwitchCam.nodes[1].bPointAtEntity = TRUE
|
|
thisSwitchCam.nodes[1].bPointAtOffsetIsRelative = TRUE
|
|
thisSwitchCam.nodes[1].bAttachOffsetIsRelative = TRUE
|
|
thisSwitchCam.nodes[1].fNodeFOV = 40.0000
|
|
thisSwitchCam.nodes[1].vClonedNodeOffset = <<0.0000, 0.0000, 0.0000>>
|
|
thisSwitchCam.nodes[1].iNodeToClone = 0
|
|
thisSwitchCam.nodes[1].NodeTimePostFX_Type = NO_EFFECT
|
|
thisSwitchCam.nodes[1].fNodeTimePostFXBlendTime = 0.0000
|
|
thisSwitchCam.nodes[1].fNodeTimePostFXTimeOffset = 0.0000
|
|
thisSwitchCam.nodes[1].fNodeMotionBlur = 0.0000
|
|
thisSwitchCam.nodes[1].NodeCamShakeType = CAM_SHAKE_MEDIUM
|
|
thisSwitchCam.nodes[1].fNodeCamShake = 0.5000
|
|
thisSwitchCam.nodes[1].iCamEaseType = 0
|
|
thisSwitchCam.nodes[1].fCamEaseScaler = 0.0000
|
|
thisSwitchCam.nodes[1].fCamNodeVelocityScale = 0.0000
|
|
thisSwitchCam.nodes[1].bCamEaseForceLinear = FALSE
|
|
thisSwitchCam.nodes[1].bCamEaseForceLevel = FALSE
|
|
thisSwitchCam.nodes[1].fTimeScale = 1.0000
|
|
thisSwitchCam.nodes[1].iTimeScaleEaseType = 0
|
|
thisSwitchCam.nodes[1].fTimeScaleEaseScaler = 0.0000
|
|
thisSwitchCam.nodes[1].bFlashEnabled = FALSE
|
|
thisSwitchCam.nodes[1].SCFE_FlashEffectUsed = SCFE_CODE_FLASH
|
|
thisSwitchCam.nodes[1].fMinExposure = 0.0000
|
|
thisSwitchCam.nodes[1].fMaxExposure = 0.0000
|
|
thisSwitchCam.nodes[1].iRampUpDuration = 0
|
|
thisSwitchCam.nodes[1].iRampDownDuration = 0
|
|
thisSwitchCam.nodes[1].iHoldDuration = 0
|
|
thisSwitchCam.nodes[1].fFlashNodePhaseOffset = 0.3000
|
|
thisSwitchCam.nodes[1].bIsLowDetailNode = FALSE
|
|
thisSwitchCam.nodes[1].bUseCustomDOF = FALSE
|
|
thisSwitchCam.nodes[1].NodeDOF_Info.fDOF_NearDOF = 0.0000
|
|
thisSwitchCam.nodes[1].NodeDOF_Info.fDOF_FarDOF = 0.0000
|
|
thisSwitchCam.nodes[1].NodeDOF_Info.fDOF_EffectStrength = 0.0000
|
|
|
|
thisSwitchCam.nodes[2].SwitchCamType = SWITCH_CAM_OLD_SYSTEM
|
|
thisSwitchCam.nodes[2].iForceCamPointAtEntityIndex = -1
|
|
thisSwitchCam.nodes[2].bIsGameplayCamCopy = FALSE
|
|
thisSwitchCam.nodes[2].iNodeTime = 600
|
|
thisSwitchCam.nodes[2].vNodePos = <<-1.6125, 2.0081, -1.4774>>
|
|
thisSwitchCam.nodes[2].vWorldPosLookAt = <<0.0000, 0.0000, 0.0000>>
|
|
thisSwitchCam.nodes[2].fNodeOffsetDist = 0.0000
|
|
thisSwitchCam.nodes[2].fNodeVerticleOffset = 0.0000
|
|
thisSwitchCam.nodes[2].bAttachToOriginPed = FALSE
|
|
thisSwitchCam.nodes[2].vNodeDir = <<-0.5, 0.9, -1.7>>
|
|
thisSwitchCam.nodes[2].bPointAtEntity = TRUE
|
|
thisSwitchCam.nodes[2].bPointAtOffsetIsRelative = TRUE
|
|
thisSwitchCam.nodes[2].bAttachOffsetIsRelative = TRUE
|
|
thisSwitchCam.nodes[2].fNodeFOV = 40.0000
|
|
thisSwitchCam.nodes[2].vClonedNodeOffset = <<0.0000, 0.0000, 0.0000>>
|
|
thisSwitchCam.nodes[2].iNodeToClone = 0
|
|
thisSwitchCam.nodes[2].NodeTimePostFX_Type = NO_EFFECT
|
|
thisSwitchCam.nodes[2].fNodeTimePostFXBlendTime = 0.0000
|
|
thisSwitchCam.nodes[2].fNodeTimePostFXTimeOffset = 0.0000
|
|
thisSwitchCam.nodes[2].fNodeMotionBlur = 1.0000
|
|
thisSwitchCam.nodes[2].NodeCamShakeType = CAM_SHAKE_MEDIUM
|
|
thisSwitchCam.nodes[2].fNodeCamShake = 0.5000
|
|
thisSwitchCam.nodes[2].iCamEaseType = 0
|
|
thisSwitchCam.nodes[2].fCamEaseScaler = 0.0000
|
|
thisSwitchCam.nodes[2].fCamNodeVelocityScale = 0.0000
|
|
thisSwitchCam.nodes[2].bCamEaseForceLinear = FALSE
|
|
thisSwitchCam.nodes[2].bCamEaseForceLevel = FALSE
|
|
thisSwitchCam.nodes[2].fTimeScale = 0.6000
|
|
thisSwitchCam.nodes[2].iTimeScaleEaseType = 0
|
|
thisSwitchCam.nodes[2].fTimeScaleEaseScaler = 0.0000
|
|
thisSwitchCam.nodes[2].bFlashEnabled = TRUE
|
|
thisSwitchCam.nodes[2].SCFE_FlashEffectUsed = SCFE_SwitchShortFranklinMid
|
|
thisSwitchCam.nodes[2].fMinExposure = 0.0000
|
|
thisSwitchCam.nodes[2].fMaxExposure = 0.0000
|
|
thisSwitchCam.nodes[2].iRampUpDuration = 0
|
|
thisSwitchCam.nodes[2].iRampDownDuration = 0
|
|
thisSwitchCam.nodes[2].iHoldDuration = 0
|
|
thisSwitchCam.nodes[2].fFlashNodePhaseOffset = 0.8000
|
|
thisSwitchCam.nodes[2].bIsLowDetailNode = FALSE
|
|
thisSwitchCam.nodes[2].bUseCustomDOF = FALSE
|
|
thisSwitchCam.nodes[2].NodeDOF_Info.fDOF_NearDOF = 0.0000
|
|
thisSwitchCam.nodes[2].NodeDOF_Info.fDOF_FarDOF = 0.0000
|
|
thisSwitchCam.nodes[2].NodeDOF_Info.fDOF_EffectStrength = 0.0000
|
|
|
|
thisSwitchCam.nodes[3].bIsCamCutNode = TRUE
|
|
|
|
thisSwitchCam.nodes[4].SwitchCamType = SWITCH_CAM_OLD_SYSTEM
|
|
thisSwitchCam.nodes[4].iForceCamPointAtEntityIndex = -1
|
|
thisSwitchCam.nodes[4].bIsGameplayCamCopy = FALSE
|
|
thisSwitchCam.nodes[4].iNodeTime = 0
|
|
thisSwitchCam.nodes[4].vNodePos = <<0.0646, 1.3472, 1.4595>>
|
|
thisSwitchCam.nodes[4].vWorldPosLookAt = <<0.0000, 0.0000, 1.4500>>
|
|
thisSwitchCam.nodes[4].fNodeOffsetDist = 0.0000
|
|
thisSwitchCam.nodes[4].fNodeVerticleOffset = 0.0000
|
|
thisSwitchCam.nodes[4].bAttachToOriginPed = FALSE
|
|
thisSwitchCam.nodes[4].vNodeDir = <<0.3564, 0.2439, 1.4688>>
|
|
thisSwitchCam.nodes[4].bPointAtEntity = TRUE
|
|
thisSwitchCam.nodes[4].bPointAtOffsetIsRelative = TRUE
|
|
thisSwitchCam.nodes[4].bAttachOffsetIsRelative = TRUE
|
|
thisSwitchCam.nodes[4].fNodeFOV = 40.0000
|
|
thisSwitchCam.nodes[4].vClonedNodeOffset = <<0.0000, 0.0000, 0.0000>>
|
|
thisSwitchCam.nodes[4].iNodeToClone = 0
|
|
thisSwitchCam.nodes[4].NodeTimePostFX_Type = NO_EFFECT
|
|
thisSwitchCam.nodes[4].fNodeTimePostFXBlendTime = 0.0000
|
|
thisSwitchCam.nodes[4].fNodeTimePostFXTimeOffset = 0.0000
|
|
thisSwitchCam.nodes[4].fNodeMotionBlur = 1.0000
|
|
thisSwitchCam.nodes[4].NodeCamShakeType = CAM_SHAKE_MEDIUM
|
|
thisSwitchCam.nodes[4].fNodeCamShake = 0.5000
|
|
thisSwitchCam.nodes[4].iCamEaseType = 1
|
|
thisSwitchCam.nodes[4].fCamEaseScaler = 1.0000
|
|
thisSwitchCam.nodes[4].fCamNodeVelocityScale = 0.0000
|
|
thisSwitchCam.nodes[4].bCamEaseForceLinear = TRUE
|
|
thisSwitchCam.nodes[4].bCamEaseForceLevel = FALSE
|
|
thisSwitchCam.nodes[4].fTimeScale = 0.3000
|
|
thisSwitchCam.nodes[4].iTimeScaleEaseType = 0
|
|
thisSwitchCam.nodes[4].fTimeScaleEaseScaler = 0.0000
|
|
thisSwitchCam.nodes[4].bFlashEnabled = FALSE
|
|
thisSwitchCam.nodes[4].SCFE_FlashEffectUsed = SCFE_CODE_FLASH
|
|
thisSwitchCam.nodes[4].fMinExposure = 0.0000
|
|
thisSwitchCam.nodes[4].fMaxExposure = 0.0000
|
|
thisSwitchCam.nodes[4].iRampUpDuration = 0
|
|
thisSwitchCam.nodes[4].iRampDownDuration = 0
|
|
thisSwitchCam.nodes[4].iHoldDuration = 0
|
|
thisSwitchCam.nodes[4].fFlashNodePhaseOffset = 0.0000
|
|
thisSwitchCam.nodes[4].bIsLowDetailNode = FALSE
|
|
thisSwitchCam.nodes[4].bUseCustomDOF = FALSE
|
|
thisSwitchCam.nodes[4].NodeDOF_Info.fDOF_NearDOF = 0.0000
|
|
thisSwitchCam.nodes[4].NodeDOF_Info.fDOF_FarDOF = 0.0000
|
|
thisSwitchCam.nodes[4].NodeDOF_Info.fDOF_EffectStrength = 0.0000
|
|
|
|
thisSwitchCam.nodes[5].SwitchCamType = SWITCH_CAM_OLD_SYSTEM
|
|
thisSwitchCam.nodes[5].iForceCamPointAtEntityIndex = -1
|
|
thisSwitchCam.nodes[5].bIsGameplayCamCopy = FALSE
|
|
thisSwitchCam.nodes[5].iNodeTime = 600
|
|
thisSwitchCam.nodes[5].vNodePos = <<-0.0083, 1.3912, 0.2997>>
|
|
thisSwitchCam.nodes[5].vWorldPosLookAt = <<0.0000, 0.0000, 0.4000>>
|
|
thisSwitchCam.nodes[5].fNodeOffsetDist = 0.0000
|
|
thisSwitchCam.nodes[5].fNodeVerticleOffset = 0.0000
|
|
thisSwitchCam.nodes[5].bAttachToOriginPed = FALSE
|
|
thisSwitchCam.nodes[5].vNodeDir = <<0.4002, 0.1876, 0.4090>>
|
|
thisSwitchCam.nodes[5].bPointAtEntity = TRUE
|
|
thisSwitchCam.nodes[5].bPointAtOffsetIsRelative = TRUE
|
|
thisSwitchCam.nodes[5].bAttachOffsetIsRelative = TRUE
|
|
thisSwitchCam.nodes[5].fNodeFOV = 40.0000
|
|
thisSwitchCam.nodes[5].vClonedNodeOffset = <<0.0000, 0.0000, 0.0000>>
|
|
thisSwitchCam.nodes[5].iNodeToClone = 0
|
|
thisSwitchCam.nodes[5].NodeTimePostFX_Type = NO_EFFECT
|
|
thisSwitchCam.nodes[5].fNodeTimePostFXBlendTime = 0.0000
|
|
thisSwitchCam.nodes[5].fNodeTimePostFXTimeOffset = 0.0000
|
|
thisSwitchCam.nodes[5].fNodeMotionBlur = 1.0000
|
|
thisSwitchCam.nodes[5].NodeCamShakeType = CAM_SHAKE_MEDIUM
|
|
thisSwitchCam.nodes[5].fNodeCamShake = 0.5000
|
|
thisSwitchCam.nodes[5].iCamEaseType = 0
|
|
thisSwitchCam.nodes[5].fCamEaseScaler = 0.0000
|
|
thisSwitchCam.nodes[5].fCamNodeVelocityScale = 0.0000
|
|
thisSwitchCam.nodes[5].bCamEaseForceLinear = TRUE
|
|
thisSwitchCam.nodes[5].bCamEaseForceLevel = FALSE
|
|
thisSwitchCam.nodes[5].fTimeScale = 0.3000
|
|
thisSwitchCam.nodes[5].iTimeScaleEaseType = 0
|
|
thisSwitchCam.nodes[5].fTimeScaleEaseScaler = 0.0000
|
|
thisSwitchCam.nodes[5].bFlashEnabled = FALSE
|
|
thisSwitchCam.nodes[5].SCFE_FlashEffectUsed = SCFE_CODE_FLASH
|
|
thisSwitchCam.nodes[5].fMinExposure = 0.0000
|
|
thisSwitchCam.nodes[5].fMaxExposure = 0.0000
|
|
thisSwitchCam.nodes[5].iRampUpDuration = 0
|
|
thisSwitchCam.nodes[5].iRampDownDuration = 0
|
|
thisSwitchCam.nodes[5].iHoldDuration = 0
|
|
thisSwitchCam.nodes[5].fFlashNodePhaseOffset = 0.0000
|
|
thisSwitchCam.nodes[5].bIsLowDetailNode = FALSE
|
|
thisSwitchCam.nodes[5].bUseCustomDOF = FALSE
|
|
thisSwitchCam.nodes[5].NodeDOF_Info.fDOF_NearDOF = 0.0000
|
|
thisSwitchCam.nodes[5].NodeDOF_Info.fDOF_FarDOF = 0.0000
|
|
thisSwitchCam.nodes[5].NodeDOF_Info.fDOF_EffectStrength = 0.0000
|
|
|
|
thisSwitchCam.nodes[6].SwitchCamType = SWITCH_CAM_OLD_SYSTEM
|
|
thisSwitchCam.nodes[6].iForceCamPointAtEntityIndex = -1
|
|
thisSwitchCam.nodes[6].bIsGameplayCamCopy = FALSE
|
|
thisSwitchCam.nodes[6].iNodeTime = 400
|
|
thisSwitchCam.nodes[6].vNodePos = <<-0.0083, 1.3912, 0.2997>>
|
|
thisSwitchCam.nodes[6].vWorldPosLookAt = <<0.0000, 0.0000, 0.4000>>
|
|
thisSwitchCam.nodes[6].fNodeOffsetDist = 0.0000
|
|
thisSwitchCam.nodes[6].fNodeVerticleOffset = 0.0000
|
|
thisSwitchCam.nodes[6].bAttachToOriginPed = FALSE
|
|
thisSwitchCam.nodes[6].vNodeDir = <<0.4002, 0.1876, 0.4090>>
|
|
thisSwitchCam.nodes[6].bPointAtEntity = TRUE
|
|
thisSwitchCam.nodes[6].bPointAtOffsetIsRelative = TRUE
|
|
thisSwitchCam.nodes[6].bAttachOffsetIsRelative = TRUE
|
|
thisSwitchCam.nodes[6].fNodeFOV = 40.0000
|
|
thisSwitchCam.nodes[6].vClonedNodeOffset = <<0.0000, 0.0000, 0.0000>>
|
|
thisSwitchCam.nodes[6].iNodeToClone = 0
|
|
thisSwitchCam.nodes[6].NodeTimePostFX_Type = NO_EFFECT
|
|
thisSwitchCam.nodes[6].fNodeTimePostFXBlendTime = 0.0000
|
|
thisSwitchCam.nodes[6].fNodeTimePostFXTimeOffset = 0.0000
|
|
thisSwitchCam.nodes[6].fNodeMotionBlur = 0.0000
|
|
thisSwitchCam.nodes[6].NodeCamShakeType = CAM_SHAKE_MEDIUM
|
|
thisSwitchCam.nodes[6].fNodeCamShake = 0.5000
|
|
thisSwitchCam.nodes[6].iCamEaseType = 0
|
|
thisSwitchCam.nodes[6].fCamEaseScaler = 0.0000
|
|
thisSwitchCam.nodes[6].fCamNodeVelocityScale = 0.0000
|
|
thisSwitchCam.nodes[6].bCamEaseForceLinear = TRUE
|
|
thisSwitchCam.nodes[6].bCamEaseForceLevel = FALSE
|
|
thisSwitchCam.nodes[6].fTimeScale = 1.0000
|
|
thisSwitchCam.nodes[6].iTimeScaleEaseType = 0
|
|
thisSwitchCam.nodes[6].fTimeScaleEaseScaler = 0.0000
|
|
thisSwitchCam.nodes[6].bFlashEnabled = FALSE
|
|
thisSwitchCam.nodes[6].SCFE_FlashEffectUsed = SCFE_CODE_FLASH
|
|
thisSwitchCam.nodes[6].fMinExposure = 0.0000
|
|
thisSwitchCam.nodes[6].fMaxExposure = 0.0000
|
|
thisSwitchCam.nodes[6].iRampUpDuration = 0
|
|
thisSwitchCam.nodes[6].iRampDownDuration = 0
|
|
thisSwitchCam.nodes[6].iHoldDuration = 0
|
|
thisSwitchCam.nodes[6].fFlashNodePhaseOffset = 0.0000
|
|
thisSwitchCam.nodes[6].bIsLowDetailNode = FALSE
|
|
thisSwitchCam.nodes[6].bUseCustomDOF = FALSE
|
|
thisSwitchCam.nodes[6].NodeDOF_Info.fDOF_NearDOF = 0.0000
|
|
thisSwitchCam.nodes[6].NodeDOF_Info.fDOF_FarDOF = 0.0000
|
|
thisSwitchCam.nodes[6].NodeDOF_Info.fDOF_EffectStrength = 0.0000
|
|
|
|
|
|
|
|
thisSwitchCam.iNumNodes = 7
|
|
thisSwitchCam.iCamSwitchFocusNode = 3
|
|
thisSwitchCam.fSwitchSoundAudioStartPhase = 0.08
|
|
thisSwitchCam.fSwitchSoundAudioEndPhase = 0.45
|
|
thisSwitchCam.bSwitchSoundPlayOpeningPulse = FALSE
|
|
thisSwitchCam.bSwitchSoundPlayMoveLoop = FALSE
|
|
thisSwitchCam.bSwitchSoundPlayExitPulse = FALSE
|
|
thisSwitchCam.bSplineNoSmoothing = FALSE
|
|
thisSwitchCam.bAddGameplayCamAsLastNode = FALSE
|
|
thisSwitchCam.iGameplayNodeBlendDuration = 0
|
|
|
|
|
|
//--- End of Cam Data ---
|
|
|
|
|
|
thisSwitchCam.strOutputStructName = "thisSwitchCam"
|
|
thisSwitchCam.strOutputFileName = "CameraInfo_FIB2_HeliMichaelToFranklin.txt"
|
|
thisSwitchCam.strXMLFileName = "CameraInfo_FIB2_HeliMichaelToFranklin.xml"
|
|
|
|
thisSwitchCam.bInitialized = TRUE
|
|
//ENDIF
|
|
|
|
thisSwitchCam.piPeds[0] = piTrevor
|
|
thisSwitchCam.piPeds[1] = piFranklin
|
|
|
|
|
|
ENDPROC
|
|
|
|
|
|
|
|
/// PURPOSE:
|
|
/// Handle the playback of the switch cam. The will setup, play, shut down and cleanup the switch cam spline
|
|
/// PARAMS:
|
|
/// thisSwitchCam - Switch camera to playback
|
|
/// bReturnTrueOnce - If you only want this function to return TRUE once upon completion. Set to FALSE to have this function to return true every time this is called once the camera is finished playback.
|
|
/// RETURNS:
|
|
/// TRUE when camera is complete, FALSE if playback is still active, or if the camera has completed playback and bReturnTrueOnce is set to TRUE.
|
|
FUNC BOOL HANDLE_SWITCH_CAM_HELI_TO_FRANKLIN(SWITCH_CAM_STRUCT &thisSwitchCam, BOOL bReturnTrueOnce = TRUE)
|
|
|
|
IS_PED_INJURED(GET_FRANKLIN_PED())
|
|
IS_PED_INJURED(GET_MICHAEL_PED())
|
|
IS_PED_INJURED(GET_TREVOR_PED())
|
|
IS_VEHICLE_DRIVEABLE(snatchAndGrabVehicle[SAGV_PLAYER_CHOPPER])
|
|
|
|
INT iCurrentNode
|
|
|
|
SWITCH eSwitchCamState
|
|
|
|
CASE SWITCH_CAM_IDLE
|
|
CDEBUG3LN(DEBUG_MISSION, "eSwitchCamState = SWITCH_CAM_IDLE")
|
|
RETURN FALSE
|
|
BREAK
|
|
|
|
CASE SWITCH_CAM_SETUP_SPLINE
|
|
CDEBUG3LN(DEBUG_MISSION, "eSwitchCamState = SWITCH_CAM_SETUP_SPLINE")
|
|
|
|
IF DOES_SWITCH_CAM_EXIST(thisSwitchCam)
|
|
DESTROY_SWITCH_CAM(thisSwitchCam)
|
|
ENDIF
|
|
|
|
CREATE_SPLINE_CAM(thisSwitchCam)
|
|
|
|
IF bSwitchToFirstPerson
|
|
INT i
|
|
REPEAT COUNT_OF(thisSwitchCam.nodes) i
|
|
IF DOES_CAM_EXIST(thisSwitchCam.nodes[i].ciSwitchNode)
|
|
IF i < 3
|
|
SET_CAM_INHERIT_ROLL_VEHICLE(thisSwitchCam.nodes[i].ciSwitchNode, snatchAndGrabVehicle[SAGV_PLAYER_CHOPPER])
|
|
ENDIF
|
|
ENDIF
|
|
ENDREPEAT
|
|
ENDIF
|
|
|
|
SET_CAM_ACTIVE(thisSwitchCam.ciSpline, TRUE)
|
|
RENDER_SCRIPT_CAMS(TRUE, FALSE)
|
|
|
|
DISPLAY_RADAR(FALSE)
|
|
DISPLAY_HUD(FALSE)
|
|
|
|
SETTIMERB(0)
|
|
|
|
SET_PLAYER_CONTROL(PLAYER_ID(), FALSE)
|
|
|
|
bPlayerControlGiven = FALSE
|
|
|
|
NEW_LOAD_SCENE_START_SPHERE((<<-144.6, -593.7, 211.8>>), 20.0, NEWLOADSCENE_FLAG_REQUIRE_COLLISION)
|
|
|
|
CLEAR_PED_TASKS_IMMEDIATELY(GET_FRANKLIN_PED())
|
|
|
|
//[MF] Set Franklin's target for during the switch
|
|
IF IS_VEHICLE_DRIVEABLE(enemyChopperVehicle[2])
|
|
eiHeliToFranklin_FranklinTarget = enemyChopperVehicle[2]
|
|
ELIF IS_VEHICLE_DRIVEABLE(enemyChopperVehicle[iLeadHeli])
|
|
eiHeliToFranklin_FranklinTarget = enemyChopperVehicle[iLeadHeli]
|
|
ELSE
|
|
eiHeliToFranklin_FranklinTarget = snatchAndGrabVehicle[SAGV_PLAYER_CHOPPER]
|
|
ENDIF
|
|
|
|
TASK_AIM_GUN_AT_ENTITY(GET_FRANKLIN_PED(), eiHeliToFranklin_FranklinTarget, 8000, TRUE)
|
|
|
|
IF eCurrentBranchedSwitchState = BRANCHED_SWITCH_TREVOR_TO_FRANKLIN_ACTIVE
|
|
fHeliToFranklin_FranklinStartAITaskPhase = fTrevToFranklin_FranklinStartAITaskPhase
|
|
ELIF eCurrentBranchedSwitchState = BRANCHED_SWITCH_MICHAEL_TO_FRANKLIN_ACTIVE
|
|
fHeliToFranklin_FranklinStartAITaskPhase = fMikeToFranklin_FranklinStartAITaskPhase
|
|
ENDIF
|
|
|
|
CLEAR_AREA(GET_ENTITY_COORDS(GET_FRANKLIN_PED()), 10.0, TRUE, TRUE, TRUE)
|
|
|
|
CLEAR_PED_TASKS(GET_FRANKLIN_PED())
|
|
|
|
IF eCurrentBranchedSwitchState = BRANCHED_SWITCH_TREVOR_TO_FRANKLIN_ACTIVE
|
|
iNextTrevorAITime = GET_GAME_TIMER() + 2000 //[MF] Delay helicopter course corrections for a bit while we transition the cam off of Trevor
|
|
PRINTLN("Updating iNextTrevorAITime To: ", iNextTrevorAITime)
|
|
ENDIF
|
|
|
|
eSwitchCamState = SWITCH_CAM_PLAYING_SPLINE
|
|
RETURN TRUE
|
|
BREAK
|
|
|
|
CASE SWITCH_CAM_PLAYING_SPLINE
|
|
CDEBUG3LN(DEBUG_MISSION, "eSwitchCamState = SWITCH_CAM_PLAYING_SPLINE")
|
|
CDEBUG3LN(DEBUG_MISSION, GET_CAM_SPLINE_PHASE(thisSwitchCam.ciSpline))
|
|
|
|
IF IS_CAM_ACTIVE(thisSwitchCam.ciSpline)
|
|
|
|
IF NOT bDoneHitSound
|
|
IF GET_GAME_TIMER() >= (iSnatchAndGrabCutsceneTime + 20)
|
|
PLAY_SOUND_FRONTEND(-1, "Hit_Out", "PLAYER_SWITCH_CUSTOM_SOUNDSET")
|
|
iHitTime = GET_GAME_TIMER()
|
|
bDoneHitSound = TRUE
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF NOT bWooshStarted
|
|
IF bDoneHitSound
|
|
IF GET_GAME_TIMER() >= iHitTime + 250
|
|
PLAY_SOUND_FRONTEND(-1, "Short_Transition_In", "PLAYER_SWITCH_CUSTOM_SOUNDSET")
|
|
bWooshStarted = TRUE
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
|
|
iCurrentNode = UPDATE_SPLINE_CAM(thisSwitchCam)
|
|
|
|
IF iCurrentNode >= thisSwitchCam.iCamSwitchFocusNode - iHeliToFranklin_SwitchPedIndexOffset
|
|
IF NOT sCamDetails.bOKToSwitchPed
|
|
sCamDetails.bOKToSwitchPed = TRUE
|
|
CLEAR_AREA(GET_ENTITY_COORDS(GET_FRANKLIN_PED()), 10.0, TRUE, TRUE, TRUE)
|
|
ENDIF
|
|
ELSE
|
|
PRINTLN("Updating cam to match gameplay cam...")
|
|
|
|
SET_CAM_COORD(thisSwitchCam.nodes[2].ciSwitchNode, (GET_GAMEPLAY_CAM_COORD() + GET_VECTOR_FROM_DIRECTION_AND_MAGNITUDE(CONVERT_EULER_TO_UPWARD_VECTOR(GET_GAMEPLAY_CAM_ROT()), thisSwitchCam.nodes[2].vClonedNodeOffset.z)))
|
|
|
|
SET_CAM_ROT(thisSwitchCam.nodes[2].ciSwitchNode, GET_GAMEPLAY_CAM_ROT())
|
|
ENDIF
|
|
|
|
IF GET_CAM_SPLINE_PHASE(thisSwitchCam.ciSpline) > fHeliToFranklin_FranklinStartAITaskPhase
|
|
IF NOT IS_SCRIPT_TASK_RUNNING_OR_STARTING(GET_FRANKLIN_PED(), SCRIPT_TASK_PLAY_ANIM)
|
|
CLEAR_PED_TASKS_IMMEDIATELY(GET_FRANKLIN_PED())
|
|
TASK_PLAY_ANIM(GET_FRANKLIN_PED(), GET_SNATCH_AND_GRAB_ANIM_DICT_AS_STRING(SAG_ANIM_DICT_SNIPER), "ig_7_m_door_f_sniping_franklin", INSTANT_BLEND_IN, INSTANT_BLEND_OUT, DEFAULT, AF_HOLD_LAST_FRAME, 0.55)
|
|
|
|
FORCE_PED_AI_AND_ANIMATION_UPDATE(GET_FRANKLIN_PED(), TRUE)
|
|
WAIT_WITH_RECORD() //[MF] Fix an issue where the Force Ped AI and Animation Update was getting called twice consecutively.
|
|
ENDIF
|
|
ENDIF
|
|
|
|
//[MF] Once cam is at the end, reset the gameplay cam positon and advance to next state.
|
|
IF GET_CAM_SPLINE_PHASE(thisSwitchCam.ciSpline) >= 1.00
|
|
CDEBUG3LN(DEBUG_MISSION, "eSwitchCamState = SWITCH_CAM_RETURN_TO_GAMEPLAY")
|
|
IF NOT IS_PED_INJURED(GET_FRANKLIN_PED())
|
|
CLEAR_PED_TASKS_IMMEDIATELY(GET_FRANKLIN_PED())
|
|
SET_PED_RESET_FLAG(GET_FRANKLIN_PED(), PRF_InstantBlendToAim, TRUE)
|
|
SET_PLAYER_FORCE_SKIP_AIM_INTRO(PLAYER_ID(), TRUE)
|
|
SET_PLAYER_FORCED_AIM(PLAYER_ID(), TRUE)
|
|
ENDIF
|
|
eSwitchCamState = SWITCH_CAM_RETURN_TO_GAMEPLAY
|
|
ENDIF
|
|
ELSE
|
|
SCRIPT_ASSERT("Cam Prematurely Deleted! WTF?")
|
|
RENDER_SCRIPT_CAMS(FALSE, FALSE)
|
|
CLEAR_PED_TASKS_IMMEDIATELY(GET_FRANKLIN_PED())
|
|
SET_PLAYER_FORCED_AIM(PLAYER_ID(), TRUE)
|
|
eSwitchCamState = SWITCH_CAM_SETUP_SPLINE
|
|
ENDIF
|
|
|
|
RETURN TRUE
|
|
BREAK
|
|
|
|
CASE SWITCH_CAM_RETURN_TO_GAMEPLAY
|
|
|
|
SET_TIME_SCALE(1.0)
|
|
|
|
RENDER_SCRIPT_CAMS(FALSE, FALSE)
|
|
|
|
IF DOES_CAM_EXIST(thisSwitchCam.ciSpline)
|
|
SET_CAM_ACTIVE(thisSwitchCam.ciSpline, FALSE)
|
|
ENDIF
|
|
|
|
IF DOES_SWITCH_CAM_EXIST(thisSwitchCam)
|
|
DESTROY_SWITCH_CAM(thisSwitchCam)
|
|
ENDIF
|
|
|
|
IF NOT bPlayerControlGiven
|
|
SET_PLAYER_CONTROL(PLAYER_ID(), TRUE)
|
|
DISPLAY_RADAR(TRUE)
|
|
DISPLAY_HUD(TRUE)
|
|
bPlayerControlGiven = TRUE
|
|
ENDIF
|
|
|
|
SETTIMERA(0)
|
|
|
|
eSwitchCamState = SWITCH_CAM_IDLE
|
|
|
|
thisSwitchCam.bIsSplineCamFinishedPlaying = TRUE
|
|
|
|
SET_PLAYER_CONTROL(PLAYER_ID(), true)
|
|
|
|
CLEAR_PED_TASKS(GET_MICHAEL_PED())
|
|
|
|
sCamDetails.bSplineCreated = FALSE
|
|
|
|
sCamDetails.bOKToSwitchPed = FALSE
|
|
|
|
eCurrentBranchedSwitchState = BRANCHED_SWITCH_INACTIVE
|
|
|
|
NEW_LOAD_SCENE_STOP()
|
|
|
|
RETURN FALSE
|
|
BREAK
|
|
|
|
ENDSWITCH
|
|
|
|
IF bReturnTrueOnce
|
|
RETURN FALSE
|
|
ELSE
|
|
RETURN thisSwitchCam.bIsSplineCamFinishedPlaying
|
|
ENDIF
|
|
ENDFUNC
|
|
|
|
|
|
|
|
|
|
PROC SETUP_SPLINE_CAM_NODE_ARRAY_FRANKLIN_TO_TREVOR(SWITCH_CAM_STRUCT &thisSwitchCam, PED_INDEX piFranklin, VEHICLE_INDEX viHeli)
|
|
CDEBUG3LN(DEBUG_MISSION, "SETUP_SPLINE_CAM_NODE_ARRAY_FRANKLIN_TO_TREVOR")
|
|
|
|
//IF NOT thisSwitchCam.bInitialized
|
|
|
|
|
|
//--- Start of Cam Data ---
|
|
|
|
|
|
thisSwitchCam.nodes[0].SwitchCamType = SWITCH_CAM_OLD_SYSTEM
|
|
thisSwitchCam.nodes[0].iForceCamPointAtEntityIndex = -1
|
|
thisSwitchCam.nodes[0].bIsGameplayCamCopy = FALSE
|
|
thisSwitchCam.nodes[0].iNodeTime = 0
|
|
thisSwitchCam.nodes[0].vNodePos = <<-0.0083, 1.3912, 0.2997>>
|
|
thisSwitchCam.nodes[0].vWorldPosLookAt = <<0.0000, 0.0000, 0.0000>>
|
|
thisSwitchCam.nodes[0].fNodeOffsetDist = 0.0000
|
|
thisSwitchCam.nodes[0].fNodeVerticleOffset = 0.0000
|
|
thisSwitchCam.nodes[0].bAttachToOriginPed = FALSE
|
|
thisSwitchCam.nodes[0].vNodeDir = <<0.4002, 0.1876, 0.4090>>
|
|
thisSwitchCam.nodes[0].bPointAtEntity = TRUE
|
|
thisSwitchCam.nodes[0].bPointAtOffsetIsRelative = TRUE
|
|
thisSwitchCam.nodes[0].bAttachOffsetIsRelative = TRUE
|
|
thisSwitchCam.nodes[0].fNodeFOV = 40.0000
|
|
thisSwitchCam.nodes[0].vClonedNodeOffset = <<0.0000, 0.0000, 0.0000>>
|
|
thisSwitchCam.nodes[0].iNodeToClone = 0
|
|
thisSwitchCam.nodes[0].NodeTimePostFX_Type = NO_EFFECT
|
|
thisSwitchCam.nodes[0].fNodeTimePostFXBlendTime = 0.0000
|
|
thisSwitchCam.nodes[0].fNodeTimePostFXTimeOffset = 0.0000
|
|
thisSwitchCam.nodes[0].fNodeMotionBlur = 0.0000
|
|
thisSwitchCam.nodes[0].NodeCamShakeType = CAM_SHAKE_DEFAULT
|
|
thisSwitchCam.nodes[0].fNodeCamShake = 0.0000
|
|
thisSwitchCam.nodes[0].iCamEaseType = 0
|
|
thisSwitchCam.nodes[0].fCamEaseScaler = 0.0000
|
|
thisSwitchCam.nodes[0].fCamNodeVelocityScale = 0.0000
|
|
thisSwitchCam.nodes[0].bCamEaseForceLinear = FALSE
|
|
thisSwitchCam.nodes[0].bCamEaseForceLevel = FALSE
|
|
thisSwitchCam.nodes[0].fTimeScale = 0.0100
|
|
thisSwitchCam.nodes[0].iTimeScaleEaseType = 0
|
|
thisSwitchCam.nodes[0].fTimeScaleEaseScaler = 0.0000
|
|
thisSwitchCam.nodes[0].bFlashEnabled = FALSE
|
|
thisSwitchCam.nodes[0].SCFE_FlashEffectUsed = SCFE_CODE_FLASH
|
|
thisSwitchCam.nodes[0].fMinExposure = 0.0000
|
|
thisSwitchCam.nodes[0].fMaxExposure = 0.0000
|
|
thisSwitchCam.nodes[0].iRampUpDuration = 0
|
|
thisSwitchCam.nodes[0].iRampDownDuration = 0
|
|
thisSwitchCam.nodes[0].iHoldDuration = 0
|
|
thisSwitchCam.nodes[0].fFlashNodePhaseOffset = 0.0000
|
|
thisSwitchCam.nodes[0].bIsLowDetailNode = FALSE
|
|
thisSwitchCam.nodes[0].bUseCustomDOF = FALSE
|
|
thisSwitchCam.nodes[0].NodeDOF_Info.fDOF_NearDOF = 0.0000
|
|
thisSwitchCam.nodes[0].NodeDOF_Info.fDOF_FarDOF = 0.0000
|
|
thisSwitchCam.nodes[0].NodeDOF_Info.fDOF_EffectStrength = 0.0000
|
|
|
|
thisSwitchCam.nodes[1].SwitchCamType = SWITCH_CAM_OLD_SYSTEM
|
|
thisSwitchCam.nodes[1].iForceCamPointAtEntityIndex = -1
|
|
thisSwitchCam.nodes[1].bIsGameplayCamCopy = FALSE
|
|
thisSwitchCam.nodes[1].iNodeTime = 10
|
|
thisSwitchCam.nodes[1].vNodePos = <<-0.0083, 1.3912, 0.2997>>
|
|
thisSwitchCam.nodes[1].vWorldPosLookAt = <<0.0000, 0.0000, 0.2000>>
|
|
thisSwitchCam.nodes[1].fNodeOffsetDist = 0.0000
|
|
thisSwitchCam.nodes[1].fNodeVerticleOffset = 0.0000
|
|
thisSwitchCam.nodes[1].bAttachToOriginPed = FALSE
|
|
thisSwitchCam.nodes[1].vNodeDir = <<0.4002, 0.1876, 0.4090>>
|
|
thisSwitchCam.nodes[1].bPointAtEntity = TRUE
|
|
thisSwitchCam.nodes[1].bPointAtOffsetIsRelative = TRUE
|
|
thisSwitchCam.nodes[1].bAttachOffsetIsRelative = TRUE
|
|
thisSwitchCam.nodes[1].fNodeFOV = 40.0000
|
|
thisSwitchCam.nodes[1].vClonedNodeOffset = <<0.0000, 0.0000, 0.0000>>
|
|
thisSwitchCam.nodes[1].iNodeToClone = 0
|
|
thisSwitchCam.nodes[1].NodeTimePostFX_Type = NO_EFFECT
|
|
thisSwitchCam.nodes[1].fNodeTimePostFXBlendTime = 0.0000
|
|
thisSwitchCam.nodes[1].fNodeTimePostFXTimeOffset = 0.0000
|
|
thisSwitchCam.nodes[1].fNodeMotionBlur = 0.0000
|
|
thisSwitchCam.nodes[1].NodeCamShakeType = CAM_SHAKE_DEFAULT
|
|
thisSwitchCam.nodes[1].fNodeCamShake = 0.0000
|
|
thisSwitchCam.nodes[1].iCamEaseType = 2
|
|
thisSwitchCam.nodes[1].fCamEaseScaler = 1.0000
|
|
thisSwitchCam.nodes[1].fCamNodeVelocityScale = 0.0000
|
|
thisSwitchCam.nodes[1].bCamEaseForceLinear = FALSE
|
|
thisSwitchCam.nodes[1].bCamEaseForceLevel = FALSE
|
|
thisSwitchCam.nodes[1].fTimeScale = 1.0000
|
|
thisSwitchCam.nodes[1].iTimeScaleEaseType = 0
|
|
thisSwitchCam.nodes[1].fTimeScaleEaseScaler = 0.0000
|
|
thisSwitchCam.nodes[1].bFlashEnabled = TRUE
|
|
thisSwitchCam.nodes[1].SCFE_FlashEffectUsed = SCFE_SwitchShortFranklinIn
|
|
thisSwitchCam.nodes[1].fMinExposure = 0.0000
|
|
thisSwitchCam.nodes[1].fMaxExposure = 0.0000
|
|
thisSwitchCam.nodes[1].iRampUpDuration = 0
|
|
thisSwitchCam.nodes[1].iRampDownDuration = 0
|
|
thisSwitchCam.nodes[1].iHoldDuration = 0
|
|
thisSwitchCam.nodes[1].fFlashNodePhaseOffset = 0.1000
|
|
thisSwitchCam.nodes[1].bIsLowDetailNode = FALSE
|
|
thisSwitchCam.nodes[1].bUseCustomDOF = FALSE
|
|
thisSwitchCam.nodes[1].NodeDOF_Info.fDOF_NearDOF = 0.0000
|
|
thisSwitchCam.nodes[1].NodeDOF_Info.fDOF_FarDOF = 0.0000
|
|
thisSwitchCam.nodes[1].NodeDOF_Info.fDOF_EffectStrength = 0.0000
|
|
|
|
thisSwitchCam.nodes[2].SwitchCamType = SWITCH_CAM_OLD_SYSTEM
|
|
thisSwitchCam.nodes[2].iForceCamPointAtEntityIndex = -1
|
|
thisSwitchCam.nodes[2].bIsGameplayCamCopy = FALSE
|
|
thisSwitchCam.nodes[2].iNodeTime = 600
|
|
thisSwitchCam.nodes[2].vNodePos = <<0.0646, 1.3472, 1.4595>>
|
|
thisSwitchCam.nodes[2].vWorldPosLookAt = <<0.0000, 0.0000, 0.0000>>
|
|
thisSwitchCam.nodes[2].fNodeOffsetDist = 0.0000
|
|
thisSwitchCam.nodes[2].fNodeVerticleOffset = 0.0000
|
|
thisSwitchCam.nodes[2].bAttachToOriginPed = FALSE
|
|
thisSwitchCam.nodes[2].vNodeDir = <<0.3564, 0.2439, 1.4688>>
|
|
thisSwitchCam.nodes[2].bPointAtEntity = TRUE
|
|
thisSwitchCam.nodes[2].bPointAtOffsetIsRelative = TRUE
|
|
thisSwitchCam.nodes[2].bAttachOffsetIsRelative = TRUE
|
|
thisSwitchCam.nodes[2].fNodeFOV = 40.0000
|
|
thisSwitchCam.nodes[2].vClonedNodeOffset = <<0.0000, 0.0000, 0.0000>>
|
|
thisSwitchCam.nodes[2].iNodeToClone = 0
|
|
thisSwitchCam.nodes[2].NodeTimePostFX_Type = NO_EFFECT
|
|
thisSwitchCam.nodes[2].fNodeTimePostFXBlendTime = 0.0000
|
|
thisSwitchCam.nodes[2].fNodeTimePostFXTimeOffset = 0.0000
|
|
thisSwitchCam.nodes[2].fNodeMotionBlur = 1.0000
|
|
thisSwitchCam.nodes[2].NodeCamShakeType = CAM_SHAKE_DEFAULT
|
|
thisSwitchCam.nodes[2].fNodeCamShake = 0.0000
|
|
thisSwitchCam.nodes[2].iCamEaseType = 0
|
|
thisSwitchCam.nodes[2].fCamEaseScaler = 0.0000
|
|
thisSwitchCam.nodes[2].fCamNodeVelocityScale = 0.0000
|
|
thisSwitchCam.nodes[2].bCamEaseForceLinear = TRUE
|
|
thisSwitchCam.nodes[2].bCamEaseForceLevel = FALSE
|
|
thisSwitchCam.nodes[2].fTimeScale = 1.0000
|
|
thisSwitchCam.nodes[2].iTimeScaleEaseType = 0
|
|
thisSwitchCam.nodes[2].fTimeScaleEaseScaler = 0.0000
|
|
thisSwitchCam.nodes[2].bFlashEnabled = TRUE
|
|
thisSwitchCam.nodes[2].SCFE_FlashEffectUsed = SCFE_SwitchShortTrevorMid
|
|
thisSwitchCam.nodes[2].fMinExposure = 0.0000
|
|
thisSwitchCam.nodes[2].fMaxExposure = 0.0000
|
|
thisSwitchCam.nodes[2].iRampUpDuration = 0
|
|
thisSwitchCam.nodes[2].iRampDownDuration = 0
|
|
thisSwitchCam.nodes[2].iHoldDuration = 0
|
|
thisSwitchCam.nodes[2].fFlashNodePhaseOffset = 0.65
|
|
thisSwitchCam.nodes[2].bIsLowDetailNode = FALSE
|
|
thisSwitchCam.nodes[2].bUseCustomDOF = FALSE
|
|
thisSwitchCam.nodes[2].NodeDOF_Info.fDOF_NearDOF = 0.0000
|
|
thisSwitchCam.nodes[2].NodeDOF_Info.fDOF_FarDOF = 0.0000
|
|
thisSwitchCam.nodes[2].NodeDOF_Info.fDOF_EffectStrength = 0.0000
|
|
|
|
thisSwitchCam.nodes[3].SwitchCamType = SWITCH_CAM_CLONE_NODE_WITH_OFFSET
|
|
thisSwitchCam.nodes[3].iForceCamPointAtEntityIndex = -1
|
|
thisSwitchCam.nodes[3].bIsGameplayCamCopy = FALSE
|
|
thisSwitchCam.nodes[3].iNodeTime = 0
|
|
thisSwitchCam.nodes[3].vNodePos = <<-139.4391, -594.4296, 191.3729>>
|
|
thisSwitchCam.nodes[3].vWorldPosLookAt = <<0.0000, 0.0000, 0.0000>>
|
|
thisSwitchCam.nodes[3].fNodeOffsetDist = 0.0000
|
|
thisSwitchCam.nodes[3].fNodeVerticleOffset = 0.0000
|
|
thisSwitchCam.nodes[3].bAttachToOriginPed = FALSE
|
|
thisSwitchCam.nodes[3].vNodeDir = <<4.9798, -0.0338, -72.2534>>
|
|
thisSwitchCam.nodes[3].bPointAtEntity = FALSE
|
|
thisSwitchCam.nodes[3].bPointAtOffsetIsRelative = FALSE
|
|
thisSwitchCam.nodes[3].bAttachOffsetIsRelative = FALSE
|
|
thisSwitchCam.nodes[3].fNodeFOV = 69.7000
|
|
thisSwitchCam.nodes[3].vClonedNodeOffset = <<0.0000, 0.0000, -21.0000>>
|
|
thisSwitchCam.nodes[3].iNodeToClone = 5
|
|
thisSwitchCam.nodes[3].NodeTimePostFX_Type = NO_EFFECT
|
|
thisSwitchCam.nodes[3].fNodeTimePostFXBlendTime = 0.0000
|
|
thisSwitchCam.nodes[3].fNodeTimePostFXTimeOffset = 0.0000
|
|
thisSwitchCam.nodes[3].fNodeMotionBlur = 1.0000
|
|
thisSwitchCam.nodes[3].NodeCamShakeType = CAM_SHAKE_DEFAULT
|
|
thisSwitchCam.nodes[3].fNodeCamShake = 0.0000
|
|
thisSwitchCam.nodes[3].iCamEaseType = 0
|
|
thisSwitchCam.nodes[3].fCamEaseScaler = 0.0000
|
|
thisSwitchCam.nodes[3].fCamNodeVelocityScale = 0.0000
|
|
thisSwitchCam.nodes[3].bCamEaseForceLinear = TRUE
|
|
thisSwitchCam.nodes[3].bCamEaseForceLevel = TRUE
|
|
thisSwitchCam.nodes[3].fTimeScale = 0.0000
|
|
thisSwitchCam.nodes[3].iTimeScaleEaseType = 0
|
|
thisSwitchCam.nodes[3].fTimeScaleEaseScaler = 0.0000
|
|
thisSwitchCam.nodes[3].bFlashEnabled = FALSE
|
|
thisSwitchCam.nodes[3].SCFE_FlashEffectUsed = SCFE_CODE_FLASH
|
|
thisSwitchCam.nodes[3].fMinExposure = 0.0000
|
|
thisSwitchCam.nodes[3].fMaxExposure = 0.0000
|
|
thisSwitchCam.nodes[3].iRampUpDuration = 0
|
|
thisSwitchCam.nodes[3].iRampDownDuration = 0
|
|
thisSwitchCam.nodes[3].iHoldDuration = 0
|
|
thisSwitchCam.nodes[3].fFlashNodePhaseOffset = 0.0000
|
|
thisSwitchCam.nodes[3].bIsLowDetailNode = FALSE
|
|
thisSwitchCam.nodes[3].bUseCustomDOF = FALSE
|
|
thisSwitchCam.nodes[3].NodeDOF_Info.fDOF_NearDOF = 0.0000
|
|
thisSwitchCam.nodes[3].NodeDOF_Info.fDOF_FarDOF = 0.0000
|
|
thisSwitchCam.nodes[3].NodeDOF_Info.fDOF_EffectStrength = 0.0000
|
|
|
|
thisSwitchCam.nodes[4].SwitchCamType = SWITCH_CAM_CLONE_NODE_WITH_OFFSET
|
|
thisSwitchCam.nodes[4].iForceCamPointAtEntityIndex = -1
|
|
thisSwitchCam.nodes[4].bIsGameplayCamCopy = FALSE
|
|
thisSwitchCam.nodes[4].iNodeTime = 0
|
|
thisSwitchCam.nodes[4].vNodePos = <<-139.4391, -594.4296, 191.3729>>
|
|
thisSwitchCam.nodes[4].vWorldPosLookAt = <<0.0000, 0.0000, 0.0000>>
|
|
thisSwitchCam.nodes[4].fNodeOffsetDist = 0.0000
|
|
thisSwitchCam.nodes[4].fNodeVerticleOffset = 0.0000
|
|
thisSwitchCam.nodes[4].bAttachToOriginPed = FALSE
|
|
thisSwitchCam.nodes[4].vNodeDir = <<4.9798, -0.0338, -72.2534>>
|
|
thisSwitchCam.nodes[4].bPointAtEntity = FALSE
|
|
thisSwitchCam.nodes[4].bPointAtOffsetIsRelative = FALSE
|
|
thisSwitchCam.nodes[4].bAttachOffsetIsRelative = FALSE
|
|
thisSwitchCam.nodes[4].fNodeFOV = 69.7000
|
|
thisSwitchCam.nodes[4].vClonedNodeOffset = <<0.0000, 0.0000, -21.0000>>
|
|
thisSwitchCam.nodes[4].iNodeToClone = 5
|
|
thisSwitchCam.nodes[4].NodeTimePostFX_Type = NO_EFFECT
|
|
thisSwitchCam.nodes[4].fNodeTimePostFXBlendTime = 0.0000
|
|
thisSwitchCam.nodes[4].fNodeTimePostFXTimeOffset = 0.0000
|
|
thisSwitchCam.nodes[4].fNodeMotionBlur = 1.0000
|
|
thisSwitchCam.nodes[4].NodeCamShakeType = CAM_SHAKE_DEFAULT
|
|
thisSwitchCam.nodes[4].fNodeCamShake = 0.0000
|
|
thisSwitchCam.nodes[4].iCamEaseType = 0
|
|
thisSwitchCam.nodes[4].fCamEaseScaler = 0.0000
|
|
thisSwitchCam.nodes[4].fCamNodeVelocityScale = 0.0000
|
|
thisSwitchCam.nodes[4].bCamEaseForceLinear = TRUE
|
|
thisSwitchCam.nodes[4].bCamEaseForceLevel = TRUE
|
|
thisSwitchCam.nodes[4].fTimeScale = 0.0000
|
|
thisSwitchCam.nodes[4].iTimeScaleEaseType = 0
|
|
thisSwitchCam.nodes[4].fTimeScaleEaseScaler = 0.0000
|
|
thisSwitchCam.nodes[4].bFlashEnabled = FALSE
|
|
thisSwitchCam.nodes[4].SCFE_FlashEffectUsed = SCFE_CODE_FLASH
|
|
thisSwitchCam.nodes[4].fMinExposure = 0.0000
|
|
thisSwitchCam.nodes[4].fMaxExposure = 0.0000
|
|
thisSwitchCam.nodes[4].iRampUpDuration = 0
|
|
thisSwitchCam.nodes[4].iRampDownDuration = 0
|
|
thisSwitchCam.nodes[4].iHoldDuration = 0
|
|
thisSwitchCam.nodes[4].fFlashNodePhaseOffset = 0.0000
|
|
thisSwitchCam.nodes[4].bIsLowDetailNode = FALSE
|
|
thisSwitchCam.nodes[4].bUseCustomDOF = FALSE
|
|
thisSwitchCam.nodes[4].NodeDOF_Info.fDOF_NearDOF = 0.0000
|
|
thisSwitchCam.nodes[4].NodeDOF_Info.fDOF_FarDOF = 0.0000
|
|
thisSwitchCam.nodes[4].NodeDOF_Info.fDOF_EffectStrength = 0.0000
|
|
|
|
thisSwitchCam.nodes[5].SwitchCamType = SWITCH_CAM_OLD_SYSTEM
|
|
thisSwitchCam.nodes[5].iForceCamPointAtEntityIndex = -1
|
|
thisSwitchCam.nodes[5].bIsGameplayCamCopy = TRUE
|
|
thisSwitchCam.nodes[5].iNodeTime = 600
|
|
thisSwitchCam.nodes[5].vNodePos = <<323.9280, 430.4764, 24.9056>>
|
|
thisSwitchCam.nodes[5].vWorldPosLookAt = <<0.0000, 0.0000, 0.0000>>
|
|
thisSwitchCam.nodes[5].fNodeOffsetDist = 0.0000
|
|
thisSwitchCam.nodes[5].fNodeVerticleOffset = 0.0000
|
|
thisSwitchCam.nodes[5].bAttachToOriginPed = FALSE
|
|
thisSwitchCam.nodes[5].vNodeDir = <<-2.3168, -0.0333, 39.2271>>
|
|
thisSwitchCam.nodes[5].bPointAtEntity = FALSE
|
|
thisSwitchCam.nodes[5].bPointAtOffsetIsRelative = FALSE
|
|
thisSwitchCam.nodes[5].bAttachOffsetIsRelative = FALSE
|
|
thisSwitchCam.nodes[5].fNodeFOV = 69.7000
|
|
thisSwitchCam.nodes[5].vClonedNodeOffset = <<0.0000, 0.0000, 0.0000>>
|
|
thisSwitchCam.nodes[5].iNodeToClone = 0
|
|
thisSwitchCam.nodes[5].NodeTimePostFX_Type = NO_EFFECT
|
|
thisSwitchCam.nodes[5].fNodeTimePostFXBlendTime = 0.0000
|
|
thisSwitchCam.nodes[5].fNodeTimePostFXTimeOffset = 0.0000
|
|
thisSwitchCam.nodes[5].fNodeMotionBlur = 1.0000
|
|
thisSwitchCam.nodes[5].NodeCamShakeType = CAM_SHAKE_DEFAULT
|
|
thisSwitchCam.nodes[5].fNodeCamShake = 0.0000
|
|
thisSwitchCam.nodes[5].iCamEaseType = 0
|
|
thisSwitchCam.nodes[5].fCamEaseScaler = 0.0000
|
|
thisSwitchCam.nodes[5].fCamNodeVelocityScale = 0.0000
|
|
thisSwitchCam.nodes[5].bCamEaseForceLinear = FALSE
|
|
thisSwitchCam.nodes[5].bCamEaseForceLevel = FALSE
|
|
thisSwitchCam.nodes[5].fTimeScale = 0.0000
|
|
thisSwitchCam.nodes[5].iTimeScaleEaseType = 0
|
|
thisSwitchCam.nodes[5].fTimeScaleEaseScaler = 0.0000
|
|
thisSwitchCam.nodes[5].bFlashEnabled = FALSE
|
|
thisSwitchCam.nodes[5].SCFE_FlashEffectUsed = SCFE_CODE_FLASH
|
|
thisSwitchCam.nodes[5].fMinExposure = 0.0000
|
|
thisSwitchCam.nodes[5].fMaxExposure = 0.0000
|
|
thisSwitchCam.nodes[5].iRampUpDuration = 0
|
|
thisSwitchCam.nodes[5].iRampDownDuration = 0
|
|
thisSwitchCam.nodes[5].iHoldDuration = 0
|
|
thisSwitchCam.nodes[5].fFlashNodePhaseOffset = 0.0000
|
|
thisSwitchCam.nodes[5].bIsLowDetailNode = FALSE
|
|
thisSwitchCam.nodes[5].bUseCustomDOF = FALSE
|
|
thisSwitchCam.nodes[5].NodeDOF_Info.fDOF_NearDOF = 0.0000
|
|
thisSwitchCam.nodes[5].NodeDOF_Info.fDOF_FarDOF = 0.0000
|
|
thisSwitchCam.nodes[5].NodeDOF_Info.fDOF_EffectStrength = 0.0000
|
|
|
|
|
|
thisSwitchCam.camBlurOverrides[0].fBlurOverrideStartPoint = 2.9580
|
|
thisSwitchCam.camBlurOverrides[0].fBlurOverrideBlurLevel = 1.0000
|
|
thisSwitchCam.camBlurOverrides[1].fBlurOverrideStartPoint = 5.7060
|
|
thisSwitchCam.camBlurOverrides[1].fBlurOverrideBlurLevel = 0.6500
|
|
|
|
thisSwitchCam.iNumNodes = 6
|
|
thisSwitchCam.iCamSwitchFocusNode = 3
|
|
thisSwitchCam.fSwitchSoundAudioStartPhase = 0.01
|
|
thisSwitchCam.fSwitchSoundAudioEndPhase = 0.55
|
|
thisSwitchCam.bSwitchSoundPlayOpeningPulse = FALSE
|
|
thisSwitchCam.bSwitchSoundPlayMoveLoop = FALSE
|
|
thisSwitchCam.bSwitchSoundPlayExitPulse = FALSE
|
|
thisSwitchCam.bSplineNoSmoothing = FALSE
|
|
thisSwitchCam.bAddGameplayCamAsLastNode = TRUE
|
|
thisSwitchCam.iGameplayNodeBlendDuration = 1
|
|
|
|
|
|
//--- End of Cam Data ---
|
|
|
|
|
|
thisSwitchCam.strOutputStructName = "thisSwitchCam"
|
|
thisSwitchCam.strOutputFileName = "CameraInfo_FIB2_FranklinToTrevor.txt"
|
|
thisSwitchCam.strXMLFileName = "CameraInfo_FIB2_FranklinToTrevor.xml"
|
|
|
|
thisSwitchCam.bInitialized = TRUE
|
|
//ENDIF
|
|
|
|
thisSwitchCam.piPeds[0] = piFranklin
|
|
thisSwitchCam.viVehicles[1] = viHeli
|
|
|
|
|
|
ENDPROC
|
|
|
|
|
|
PROC SETUP_SPLINE_CAM_NODE_ARRAY_FRANKLIN_TO_TREVOR_FIRST_PERSON(SWITCH_CAM_STRUCT &thisSwitchCam, PED_INDEX piFranklin, PED_INDEX piTrevor)
|
|
CDEBUG3LN(DEBUG_MISSION, "SETUP_SPLINE_CAM_NODE_ARRAY_FRANKLIN_TO_TREVOR")
|
|
|
|
//IF NOT thisSwitchCam.bInitialized
|
|
|
|
|
|
//--- Start of Cam Data ---
|
|
|
|
|
|
thisSwitchCam.nodes[0].SwitchCamType = SWITCH_CAM_OLD_SYSTEM
|
|
thisSwitchCam.nodes[0].iForceCamPointAtEntityIndex = -1
|
|
thisSwitchCam.nodes[0].bIsGameplayCamCopy = FALSE
|
|
thisSwitchCam.nodes[0].iNodeTime = 0
|
|
thisSwitchCam.nodes[0].vNodePos = <<-0.0083, 1.3912, 0.2997>>
|
|
thisSwitchCam.nodes[0].vWorldPosLookAt = <<0.0000, 0.0000, 0.0000>>
|
|
thisSwitchCam.nodes[0].fNodeOffsetDist = 0.0000
|
|
thisSwitchCam.nodes[0].fNodeVerticleOffset = 0.0000
|
|
thisSwitchCam.nodes[0].bAttachToOriginPed = FALSE
|
|
thisSwitchCam.nodes[0].vNodeDir = <<0.4002, 0.1876, 0.4090>>
|
|
thisSwitchCam.nodes[0].bPointAtEntity = TRUE
|
|
thisSwitchCam.nodes[0].bPointAtOffsetIsRelative = TRUE
|
|
thisSwitchCam.nodes[0].bAttachOffsetIsRelative = TRUE
|
|
thisSwitchCam.nodes[0].fNodeFOV = 40.0000
|
|
thisSwitchCam.nodes[0].vClonedNodeOffset = <<0.0000, 0.0000, 0.0000>>
|
|
thisSwitchCam.nodes[0].iNodeToClone = 0
|
|
thisSwitchCam.nodes[0].NodeTimePostFX_Type = NO_EFFECT
|
|
thisSwitchCam.nodes[0].fNodeTimePostFXBlendTime = 0.0000
|
|
thisSwitchCam.nodes[0].fNodeTimePostFXTimeOffset = 0.0000
|
|
thisSwitchCam.nodes[0].fNodeMotionBlur = 0.0000
|
|
thisSwitchCam.nodes[0].NodeCamShakeType = CAM_SHAKE_MEDIUM
|
|
thisSwitchCam.nodes[0].fNodeCamShake = 0.3000
|
|
thisSwitchCam.nodes[0].iCamEaseType = 0
|
|
thisSwitchCam.nodes[0].fCamEaseScaler = 0.0000
|
|
thisSwitchCam.nodes[0].fCamNodeVelocityScale = 0.0000
|
|
thisSwitchCam.nodes[0].bCamEaseForceLinear = TRUE
|
|
thisSwitchCam.nodes[0].bCamEaseForceLevel = FALSE
|
|
thisSwitchCam.nodes[0].fTimeScale = 0.0100
|
|
thisSwitchCam.nodes[0].iTimeScaleEaseType = 0
|
|
thisSwitchCam.nodes[0].fTimeScaleEaseScaler = 0.0000
|
|
thisSwitchCam.nodes[0].bFlashEnabled = FALSE
|
|
thisSwitchCam.nodes[0].SCFE_FlashEffectUsed = SCFE_CODE_FLASH
|
|
thisSwitchCam.nodes[0].fMinExposure = 0.0000
|
|
thisSwitchCam.nodes[0].fMaxExposure = 0.0000
|
|
thisSwitchCam.nodes[0].iRampUpDuration = 0
|
|
thisSwitchCam.nodes[0].iRampDownDuration = 0
|
|
thisSwitchCam.nodes[0].iHoldDuration = 0
|
|
thisSwitchCam.nodes[0].fFlashNodePhaseOffset = 0.0000
|
|
thisSwitchCam.nodes[0].bIsLowDetailNode = FALSE
|
|
thisSwitchCam.nodes[0].bUseCustomDOF = FALSE
|
|
thisSwitchCam.nodes[0].NodeDOF_Info.fDOF_NearDOF = 0.0000
|
|
thisSwitchCam.nodes[0].NodeDOF_Info.fDOF_FarDOF = 0.0000
|
|
thisSwitchCam.nodes[0].NodeDOF_Info.fDOF_EffectStrength = 0.0000
|
|
|
|
thisSwitchCam.nodes[1].SwitchCamType = SWITCH_CAM_OLD_SYSTEM
|
|
thisSwitchCam.nodes[1].iForceCamPointAtEntityIndex = -1
|
|
thisSwitchCam.nodes[1].bIsGameplayCamCopy = FALSE
|
|
thisSwitchCam.nodes[1].iNodeTime = 10
|
|
thisSwitchCam.nodes[1].vNodePos = <<-0.0083, 1.3912, 0.2997>>
|
|
thisSwitchCam.nodes[1].vWorldPosLookAt = <<0.0000, 0.0000, 0.2000>>
|
|
thisSwitchCam.nodes[1].fNodeOffsetDist = 0.0000
|
|
thisSwitchCam.nodes[1].fNodeVerticleOffset = 0.0000
|
|
thisSwitchCam.nodes[1].bAttachToOriginPed = FALSE
|
|
thisSwitchCam.nodes[1].vNodeDir = <<0.4002, 0.1876, 0.4090>>
|
|
thisSwitchCam.nodes[1].bPointAtEntity = TRUE
|
|
thisSwitchCam.nodes[1].bPointAtOffsetIsRelative = TRUE
|
|
thisSwitchCam.nodes[1].bAttachOffsetIsRelative = TRUE
|
|
thisSwitchCam.nodes[1].fNodeFOV = 40.0000
|
|
thisSwitchCam.nodes[1].vClonedNodeOffset = <<0.0000, 0.0000, 0.0000>>
|
|
thisSwitchCam.nodes[1].iNodeToClone = 0
|
|
thisSwitchCam.nodes[1].NodeTimePostFX_Type = NO_EFFECT
|
|
thisSwitchCam.nodes[1].fNodeTimePostFXBlendTime = 0.0000
|
|
thisSwitchCam.nodes[1].fNodeTimePostFXTimeOffset = 0.0000
|
|
thisSwitchCam.nodes[1].fNodeMotionBlur = 0.0000
|
|
thisSwitchCam.nodes[1].NodeCamShakeType = CAM_SHAKE_MEDIUM
|
|
thisSwitchCam.nodes[1].fNodeCamShake = 0.3000
|
|
thisSwitchCam.nodes[1].iCamEaseType = 2
|
|
thisSwitchCam.nodes[1].fCamEaseScaler = 1.0000
|
|
thisSwitchCam.nodes[1].fCamNodeVelocityScale = 0.0000
|
|
thisSwitchCam.nodes[1].bCamEaseForceLinear = TRUE
|
|
thisSwitchCam.nodes[1].bCamEaseForceLevel = FALSE
|
|
thisSwitchCam.nodes[1].fTimeScale = 1.0000
|
|
thisSwitchCam.nodes[1].iTimeScaleEaseType = 0
|
|
thisSwitchCam.nodes[1].fTimeScaleEaseScaler = 0.0000
|
|
thisSwitchCam.nodes[1].bFlashEnabled = TRUE
|
|
thisSwitchCam.nodes[1].SCFE_FlashEffectUsed = SCFE_SwitchShortFranklinIn
|
|
thisSwitchCam.nodes[1].fMinExposure = 0.0000
|
|
thisSwitchCam.nodes[1].fMaxExposure = 0.0000
|
|
thisSwitchCam.nodes[1].iRampUpDuration = 0
|
|
thisSwitchCam.nodes[1].iRampDownDuration = 0
|
|
thisSwitchCam.nodes[1].iHoldDuration = 0
|
|
thisSwitchCam.nodes[1].fFlashNodePhaseOffset = 0.4000
|
|
thisSwitchCam.nodes[1].bIsLowDetailNode = FALSE
|
|
thisSwitchCam.nodes[1].bUseCustomDOF = FALSE
|
|
thisSwitchCam.nodes[1].NodeDOF_Info.fDOF_NearDOF = 0.0000
|
|
thisSwitchCam.nodes[1].NodeDOF_Info.fDOF_FarDOF = 0.0000
|
|
thisSwitchCam.nodes[1].NodeDOF_Info.fDOF_EffectStrength = 0.0000
|
|
|
|
thisSwitchCam.nodes[2].SwitchCamType = SWITCH_CAM_OLD_SYSTEM
|
|
thisSwitchCam.nodes[2].iForceCamPointAtEntityIndex = -1
|
|
thisSwitchCam.nodes[2].bIsGameplayCamCopy = FALSE
|
|
thisSwitchCam.nodes[2].iNodeTime = 600
|
|
thisSwitchCam.nodes[2].vNodePos = <<0.0646, 1.3472, 1.4595>>
|
|
thisSwitchCam.nodes[2].vWorldPosLookAt = <<0.0000, 0.0000, 0.0000>>
|
|
thisSwitchCam.nodes[2].fNodeOffsetDist = 0.0000
|
|
thisSwitchCam.nodes[2].fNodeVerticleOffset = 0.0000
|
|
thisSwitchCam.nodes[2].bAttachToOriginPed = FALSE
|
|
thisSwitchCam.nodes[2].vNodeDir = <<0.3564, 0.2439, 1.4688>>
|
|
thisSwitchCam.nodes[2].bPointAtEntity = TRUE
|
|
thisSwitchCam.nodes[2].bPointAtOffsetIsRelative = TRUE
|
|
thisSwitchCam.nodes[2].bAttachOffsetIsRelative = TRUE
|
|
thisSwitchCam.nodes[2].fNodeFOV = 40.0000
|
|
thisSwitchCam.nodes[2].vClonedNodeOffset = <<0.0000, 0.0000, 0.0000>>
|
|
thisSwitchCam.nodes[2].iNodeToClone = 0
|
|
thisSwitchCam.nodes[2].NodeTimePostFX_Type = NO_EFFECT
|
|
thisSwitchCam.nodes[2].fNodeTimePostFXBlendTime = 0.0000
|
|
thisSwitchCam.nodes[2].fNodeTimePostFXTimeOffset = 0.0000
|
|
thisSwitchCam.nodes[2].fNodeMotionBlur = 1.0000
|
|
thisSwitchCam.nodes[2].NodeCamShakeType = CAM_SHAKE_DEFAULT
|
|
thisSwitchCam.nodes[2].fNodeCamShake = 0.0000
|
|
thisSwitchCam.nodes[2].iCamEaseType = 0
|
|
thisSwitchCam.nodes[2].fCamEaseScaler = 0.0000
|
|
thisSwitchCam.nodes[2].fCamNodeVelocityScale = 0.0000
|
|
thisSwitchCam.nodes[2].bCamEaseForceLinear = TRUE
|
|
thisSwitchCam.nodes[2].bCamEaseForceLevel = FALSE
|
|
thisSwitchCam.nodes[2].fTimeScale = 1.0000
|
|
thisSwitchCam.nodes[2].iTimeScaleEaseType = 0
|
|
thisSwitchCam.nodes[2].fTimeScaleEaseScaler = 0.0000
|
|
thisSwitchCam.nodes[2].bFlashEnabled = TRUE
|
|
thisSwitchCam.nodes[2].SCFE_FlashEffectUsed = SCFE_SwitchShortTrevorMid
|
|
thisSwitchCam.nodes[2].fMinExposure = 0.0000
|
|
thisSwitchCam.nodes[2].fMaxExposure = 0.0000
|
|
thisSwitchCam.nodes[2].iRampUpDuration = 0
|
|
thisSwitchCam.nodes[2].iRampDownDuration = 0
|
|
thisSwitchCam.nodes[2].iHoldDuration = 0
|
|
thisSwitchCam.nodes[2].fFlashNodePhaseOffset = 0.5000
|
|
thisSwitchCam.nodes[2].bIsLowDetailNode = FALSE
|
|
thisSwitchCam.nodes[2].bUseCustomDOF = FALSE
|
|
thisSwitchCam.nodes[2].NodeDOF_Info.fDOF_NearDOF = 0.0000
|
|
thisSwitchCam.nodes[2].NodeDOF_Info.fDOF_FarDOF = 0.0000
|
|
thisSwitchCam.nodes[2].NodeDOF_Info.fDOF_EffectStrength = 0.0000
|
|
|
|
thisSwitchCam.nodes[3].bIsCamCutNode = TRUE
|
|
|
|
thisSwitchCam.nodes[4].SwitchCamType = SWITCH_CAM_OLD_SYSTEM
|
|
thisSwitchCam.nodes[4].iForceCamPointAtEntityIndex = -1
|
|
thisSwitchCam.nodes[4].bIsGameplayCamCopy = FALSE
|
|
thisSwitchCam.nodes[4].iNodeTime = 0
|
|
thisSwitchCam.nodes[4].vNodePos = <<-1.6125, 2.0081, -1.4774>>
|
|
thisSwitchCam.nodes[4].vWorldPosLookAt = <<0.0000, 0.0000, 0.0000>>
|
|
thisSwitchCam.nodes[4].fNodeOffsetDist = 0.0000
|
|
thisSwitchCam.nodes[4].fNodeVerticleOffset = 0.0000
|
|
thisSwitchCam.nodes[4].bAttachToOriginPed = FALSE
|
|
thisSwitchCam.nodes[4].vNodeDir = <<-0.5, 0.9, -1.7>>
|
|
thisSwitchCam.nodes[4].bPointAtEntity = TRUE
|
|
thisSwitchCam.nodes[4].bPointAtOffsetIsRelative = TRUE
|
|
thisSwitchCam.nodes[4].bAttachOffsetIsRelative = TRUE
|
|
thisSwitchCam.nodes[4].fNodeFOV = 40.0000
|
|
thisSwitchCam.nodes[4].vClonedNodeOffset = <<0.0000, 0.0000, 0.0000>>
|
|
thisSwitchCam.nodes[4].iNodeToClone = 0
|
|
thisSwitchCam.nodes[4].NodeTimePostFX_Type = NO_EFFECT
|
|
thisSwitchCam.nodes[4].fNodeTimePostFXBlendTime = 0.0000
|
|
thisSwitchCam.nodes[4].fNodeTimePostFXTimeOffset = 0.0000
|
|
thisSwitchCam.nodes[4].fNodeMotionBlur = 1.0000
|
|
thisSwitchCam.nodes[4].NodeCamShakeType = CAM_SHAKE_MEDIUM
|
|
thisSwitchCam.nodes[4].fNodeCamShake = 0.5000
|
|
thisSwitchCam.nodes[4].iCamEaseType = 0
|
|
thisSwitchCam.nodes[4].fCamEaseScaler = 0.0000
|
|
thisSwitchCam.nodes[4].fCamNodeVelocityScale = 0.0000
|
|
thisSwitchCam.nodes[4].bCamEaseForceLinear = FALSE
|
|
thisSwitchCam.nodes[4].bCamEaseForceLevel = FALSE
|
|
thisSwitchCam.nodes[4].fTimeScale = 0.3
|
|
thisSwitchCam.nodes[4].iTimeScaleEaseType = 0
|
|
thisSwitchCam.nodes[4].fTimeScaleEaseScaler = 0.0000
|
|
thisSwitchCam.nodes[4].bFlashEnabled = FALSE
|
|
thisSwitchCam.nodes[4].SCFE_FlashEffectUsed = SCFE_CODE_FLASH
|
|
thisSwitchCam.nodes[4].fMinExposure = 0.0000
|
|
thisSwitchCam.nodes[4].fMaxExposure = 0.0000
|
|
thisSwitchCam.nodes[4].iRampUpDuration = 0
|
|
thisSwitchCam.nodes[4].iRampDownDuration = 0
|
|
thisSwitchCam.nodes[4].iHoldDuration = 0
|
|
thisSwitchCam.nodes[4].fFlashNodePhaseOffset = 0.0000
|
|
thisSwitchCam.nodes[4].bIsLowDetailNode = FALSE
|
|
thisSwitchCam.nodes[4].bUseCustomDOF = FALSE
|
|
thisSwitchCam.nodes[4].NodeDOF_Info.fDOF_NearDOF = 0.0000
|
|
thisSwitchCam.nodes[4].NodeDOF_Info.fDOF_FarDOF = 0.0000
|
|
thisSwitchCam.nodes[4].NodeDOF_Info.fDOF_EffectStrength = 0.0000
|
|
|
|
thisSwitchCam.nodes[5].SwitchCamType = SWITCH_CAM_OLD_SYSTEM
|
|
thisSwitchCam.nodes[5].iForceCamPointAtEntityIndex = -1
|
|
thisSwitchCam.nodes[5].bIsGameplayCamCopy = FALSE
|
|
thisSwitchCam.nodes[5].iNodeTime = 600
|
|
thisSwitchCam.nodes[5].vNodePos = <<-1.6125, 2.0081, 0.6774>>
|
|
thisSwitchCam.nodes[5].vWorldPosLookAt = <<0.0000, 0.0000, 0.0000>>
|
|
thisSwitchCam.nodes[5].fNodeOffsetDist = 0.0000
|
|
thisSwitchCam.nodes[5].fNodeVerticleOffset = 0.0000
|
|
thisSwitchCam.nodes[5].bAttachToOriginPed = FALSE
|
|
thisSwitchCam.nodes[5].vNodeDir = <<-0.5, 0.9, 0.3>>
|
|
thisSwitchCam.nodes[5].bPointAtEntity = TRUE
|
|
thisSwitchCam.nodes[5].bPointAtOffsetIsRelative = TRUE
|
|
thisSwitchCam.nodes[5].bAttachOffsetIsRelative = TRUE
|
|
thisSwitchCam.nodes[5].fNodeFOV = 40.0000
|
|
thisSwitchCam.nodes[5].vClonedNodeOffset = <<0.0000, 0.0000, 0.0000>>
|
|
thisSwitchCam.nodes[5].iNodeToClone = 0
|
|
thisSwitchCam.nodes[5].NodeTimePostFX_Type = NO_EFFECT
|
|
thisSwitchCam.nodes[5].fNodeTimePostFXBlendTime = 0.0000
|
|
thisSwitchCam.nodes[5].fNodeTimePostFXTimeOffset = 0.0000
|
|
thisSwitchCam.nodes[5].fNodeMotionBlur = 1.0000
|
|
thisSwitchCam.nodes[5].NodeCamShakeType = CAM_SHAKE_MEDIUM
|
|
thisSwitchCam.nodes[5].fNodeCamShake = 0.5000
|
|
thisSwitchCam.nodes[5].iCamEaseType = 0
|
|
thisSwitchCam.nodes[5].fCamEaseScaler = 0.0000
|
|
thisSwitchCam.nodes[5].fCamNodeVelocityScale = 0.6000
|
|
thisSwitchCam.nodes[5].bCamEaseForceLinear = FALSE
|
|
thisSwitchCam.nodes[5].bCamEaseForceLevel = FALSE
|
|
thisSwitchCam.nodes[5].fTimeScale = 0.3
|
|
thisSwitchCam.nodes[5].iTimeScaleEaseType = 0
|
|
thisSwitchCam.nodes[5].fTimeScaleEaseScaler = 0.0000
|
|
thisSwitchCam.nodes[5].bFlashEnabled = FALSE
|
|
thisSwitchCam.nodes[5].SCFE_FlashEffectUsed = SCFE_CODE_FLASH
|
|
thisSwitchCam.nodes[5].fMinExposure = 0.0000
|
|
thisSwitchCam.nodes[5].fMaxExposure = 0.0000
|
|
thisSwitchCam.nodes[5].iRampUpDuration = 0
|
|
thisSwitchCam.nodes[5].iRampDownDuration = 0
|
|
thisSwitchCam.nodes[5].iHoldDuration = 0
|
|
thisSwitchCam.nodes[5].fFlashNodePhaseOffset = 0.0000
|
|
thisSwitchCam.nodes[5].bIsLowDetailNode = FALSE
|
|
thisSwitchCam.nodes[5].bUseCustomDOF = FALSE
|
|
thisSwitchCam.nodes[5].NodeDOF_Info.fDOF_NearDOF = 0.0000
|
|
thisSwitchCam.nodes[5].NodeDOF_Info.fDOF_FarDOF = 0.0000
|
|
thisSwitchCam.nodes[5].NodeDOF_Info.fDOF_EffectStrength = 0.0000
|
|
|
|
thisSwitchCam.nodes[6].SwitchCamType = SWITCH_CAM_OLD_SYSTEM
|
|
thisSwitchCam.nodes[6].iForceCamPointAtEntityIndex = -1
|
|
thisSwitchCam.nodes[6].bIsGameplayCamCopy = FALSE
|
|
thisSwitchCam.nodes[6].iNodeTime = 400
|
|
thisSwitchCam.nodes[6].vNodePos = <<-1.6125, 2.0081, 0.6774>>
|
|
thisSwitchCam.nodes[6].vWorldPosLookAt = <<0.0000, 0.0000, 0.0000>>
|
|
thisSwitchCam.nodes[6].fNodeOffsetDist = 0.0000
|
|
thisSwitchCam.nodes[6].fNodeVerticleOffset = 0.0000
|
|
thisSwitchCam.nodes[6].bAttachToOriginPed = FALSE
|
|
thisSwitchCam.nodes[6].vNodeDir = <<-0.5, 0.9, 0.3>>
|
|
thisSwitchCam.nodes[6].bPointAtEntity = TRUE
|
|
thisSwitchCam.nodes[6].bPointAtOffsetIsRelative = TRUE
|
|
thisSwitchCam.nodes[6].bAttachOffsetIsRelative = TRUE
|
|
thisSwitchCam.nodes[6].fNodeFOV = 40.0000
|
|
thisSwitchCam.nodes[6].vClonedNodeOffset = <<0.0000, 0.0000, 0.0000>>
|
|
thisSwitchCam.nodes[6].iNodeToClone = 0
|
|
thisSwitchCam.nodes[6].NodeTimePostFX_Type = NO_EFFECT
|
|
thisSwitchCam.nodes[6].fNodeTimePostFXBlendTime = 0.0000
|
|
thisSwitchCam.nodes[6].fNodeTimePostFXTimeOffset = 0.0000
|
|
thisSwitchCam.nodes[6].fNodeMotionBlur = 0.0000
|
|
thisSwitchCam.nodes[6].NodeCamShakeType = CAM_SHAKE_MEDIUM
|
|
thisSwitchCam.nodes[6].fNodeCamShake = 0.5000
|
|
thisSwitchCam.nodes[6].iCamEaseType = 0
|
|
thisSwitchCam.nodes[6].fCamEaseScaler = 0.0000
|
|
thisSwitchCam.nodes[6].fCamNodeVelocityScale = 0.0000
|
|
thisSwitchCam.nodes[6].bCamEaseForceLinear = FALSE
|
|
thisSwitchCam.nodes[6].bCamEaseForceLevel = FALSE
|
|
thisSwitchCam.nodes[6].fTimeScale = 1.0000
|
|
thisSwitchCam.nodes[6].iTimeScaleEaseType = 0
|
|
thisSwitchCam.nodes[6].fTimeScaleEaseScaler = 0.0000
|
|
thisSwitchCam.nodes[6].bFlashEnabled = FALSE
|
|
thisSwitchCam.nodes[6].SCFE_FlashEffectUsed = SCFE_CODE_FLASH
|
|
thisSwitchCam.nodes[6].fMinExposure = 0.0000
|
|
thisSwitchCam.nodes[6].fMaxExposure = 0.0000
|
|
thisSwitchCam.nodes[6].iRampUpDuration = 0
|
|
thisSwitchCam.nodes[6].iRampDownDuration = 0
|
|
thisSwitchCam.nodes[6].iHoldDuration = 0
|
|
thisSwitchCam.nodes[6].fFlashNodePhaseOffset = 0.0000
|
|
thisSwitchCam.nodes[6].bIsLowDetailNode = FALSE
|
|
thisSwitchCam.nodes[6].bUseCustomDOF = FALSE
|
|
thisSwitchCam.nodes[6].NodeDOF_Info.fDOF_NearDOF = 0.0000
|
|
thisSwitchCam.nodes[6].NodeDOF_Info.fDOF_FarDOF = 0.0000
|
|
thisSwitchCam.nodes[6].NodeDOF_Info.fDOF_EffectStrength = 0.0000
|
|
|
|
|
|
|
|
thisSwitchCam.iNumNodes = 7
|
|
thisSwitchCam.iCamSwitchFocusNode = 3
|
|
thisSwitchCam.fSwitchSoundAudioStartPhase = 0.015
|
|
thisSwitchCam.fSwitchSoundAudioEndPhase = 0.34
|
|
thisSwitchCam.bSwitchSoundPlayOpeningPulse = FALSE
|
|
thisSwitchCam.bSwitchSoundPlayMoveLoop = FALSE
|
|
thisSwitchCam.bSwitchSoundPlayExitPulse = FALSE
|
|
thisSwitchCam.bSplineNoSmoothing = FALSE
|
|
//thisSwitchCam.bAddGameplayCamAsLastNode = TRUE
|
|
thisSwitchCam.iGameplayNodeBlendDuration = 0
|
|
|
|
|
|
//--- End of Cam Data ---
|
|
|
|
|
|
|
|
thisSwitchCam.strOutputStructName = "thisSwitchCam"
|
|
thisSwitchCam.strOutputFileName = "CameraInfo_FIB2_FranklinToMike.txt"
|
|
thisSwitchCam.strXMLFileName = "CameraInfo_FIB2_FranklinToMike.xml"
|
|
|
|
thisSwitchCam.bInitialized = TRUE
|
|
//ENDIF
|
|
|
|
thisSwitchCam.piPeds[0] = piFranklin
|
|
thisSwitchCam.piPeds[1] = piTrevor
|
|
|
|
ENDPROC
|
|
|
|
|
|
PROC SETUP_SPLINE_CAM_NODE_ARRAY_FRANKLIN_TO_MICHAEL(SWITCH_CAM_STRUCT &thisSwitchCam, PED_INDEX piFranklin, PED_INDEX piMichael)
|
|
CDEBUG3LN(DEBUG_MISSION, "SETUP_SPLINE_CAM_NODE_ARRAY_FRANKLIN_TO_TREVOR")
|
|
|
|
//IF NOT thisSwitchCam.bInitialized
|
|
|
|
|
|
//--- Start of Cam Data ---
|
|
|
|
|
|
thisSwitchCam.nodes[0].SwitchCamType = SWITCH_CAM_OLD_SYSTEM
|
|
thisSwitchCam.nodes[0].iForceCamPointAtEntityIndex = -1
|
|
thisSwitchCam.nodes[0].bIsGameplayCamCopy = FALSE
|
|
thisSwitchCam.nodes[0].iNodeTime = 0
|
|
thisSwitchCam.nodes[0].vNodePos = <<-0.0083, 1.3912, 0.2997>>
|
|
thisSwitchCam.nodes[0].vWorldPosLookAt = <<0.0000, 0.0000, 0.0000>>
|
|
thisSwitchCam.nodes[0].fNodeOffsetDist = 0.0000
|
|
thisSwitchCam.nodes[0].fNodeVerticleOffset = 0.0000
|
|
thisSwitchCam.nodes[0].bAttachToOriginPed = FALSE
|
|
thisSwitchCam.nodes[0].vNodeDir = <<0.4002, 0.1876, 0.4090>>
|
|
thisSwitchCam.nodes[0].bPointAtEntity = TRUE
|
|
thisSwitchCam.nodes[0].bPointAtOffsetIsRelative = TRUE
|
|
thisSwitchCam.nodes[0].bAttachOffsetIsRelative = TRUE
|
|
thisSwitchCam.nodes[0].fNodeFOV = 40.0000
|
|
thisSwitchCam.nodes[0].vClonedNodeOffset = <<0.0000, 0.0000, 0.0000>>
|
|
thisSwitchCam.nodes[0].iNodeToClone = 0
|
|
thisSwitchCam.nodes[0].NodeTimePostFX_Type = NO_EFFECT
|
|
thisSwitchCam.nodes[0].fNodeTimePostFXBlendTime = 0.0000
|
|
thisSwitchCam.nodes[0].fNodeTimePostFXTimeOffset = 0.0000
|
|
thisSwitchCam.nodes[0].fNodeMotionBlur = 0.0000
|
|
thisSwitchCam.nodes[0].NodeCamShakeType = CAM_SHAKE_MEDIUM
|
|
thisSwitchCam.nodes[0].fNodeCamShake = 0.3000
|
|
thisSwitchCam.nodes[0].iCamEaseType = 0
|
|
thisSwitchCam.nodes[0].fCamEaseScaler = 0.0000
|
|
thisSwitchCam.nodes[0].fCamNodeVelocityScale = 0.0000
|
|
thisSwitchCam.nodes[0].bCamEaseForceLinear = TRUE
|
|
thisSwitchCam.nodes[0].bCamEaseForceLevel = FALSE
|
|
thisSwitchCam.nodes[0].fTimeScale = 0.0100
|
|
thisSwitchCam.nodes[0].iTimeScaleEaseType = 0
|
|
thisSwitchCam.nodes[0].fTimeScaleEaseScaler = 0.0000
|
|
thisSwitchCam.nodes[0].bFlashEnabled = FALSE
|
|
thisSwitchCam.nodes[0].SCFE_FlashEffectUsed = SCFE_CODE_FLASH
|
|
thisSwitchCam.nodes[0].fMinExposure = 0.0000
|
|
thisSwitchCam.nodes[0].fMaxExposure = 0.0000
|
|
thisSwitchCam.nodes[0].iRampUpDuration = 0
|
|
thisSwitchCam.nodes[0].iRampDownDuration = 0
|
|
thisSwitchCam.nodes[0].iHoldDuration = 0
|
|
thisSwitchCam.nodes[0].fFlashNodePhaseOffset = 0.0000
|
|
thisSwitchCam.nodes[0].bIsLowDetailNode = FALSE
|
|
thisSwitchCam.nodes[0].bUseCustomDOF = FALSE
|
|
thisSwitchCam.nodes[0].NodeDOF_Info.fDOF_NearDOF = 0.0000
|
|
thisSwitchCam.nodes[0].NodeDOF_Info.fDOF_FarDOF = 0.0000
|
|
thisSwitchCam.nodes[0].NodeDOF_Info.fDOF_EffectStrength = 0.0000
|
|
|
|
thisSwitchCam.nodes[1].SwitchCamType = SWITCH_CAM_OLD_SYSTEM
|
|
thisSwitchCam.nodes[1].iForceCamPointAtEntityIndex = -1
|
|
thisSwitchCam.nodes[1].bIsGameplayCamCopy = FALSE
|
|
thisSwitchCam.nodes[1].iNodeTime = 10
|
|
thisSwitchCam.nodes[1].vNodePos = <<-0.0083, 1.3912, 0.2997>>
|
|
thisSwitchCam.nodes[1].vWorldPosLookAt = <<0.0000, 0.0000, 0.2000>>
|
|
thisSwitchCam.nodes[1].fNodeOffsetDist = 0.0000
|
|
thisSwitchCam.nodes[1].fNodeVerticleOffset = 0.0000
|
|
thisSwitchCam.nodes[1].bAttachToOriginPed = FALSE
|
|
thisSwitchCam.nodes[1].vNodeDir = <<0.4002, 0.1876, 0.4090>>
|
|
thisSwitchCam.nodes[1].bPointAtEntity = TRUE
|
|
thisSwitchCam.nodes[1].bPointAtOffsetIsRelative = TRUE
|
|
thisSwitchCam.nodes[1].bAttachOffsetIsRelative = TRUE
|
|
thisSwitchCam.nodes[1].fNodeFOV = 40.0000
|
|
thisSwitchCam.nodes[1].vClonedNodeOffset = <<0.0000, 0.0000, 0.0000>>
|
|
thisSwitchCam.nodes[1].iNodeToClone = 0
|
|
thisSwitchCam.nodes[1].NodeTimePostFX_Type = NO_EFFECT
|
|
thisSwitchCam.nodes[1].fNodeTimePostFXBlendTime = 0.0000
|
|
thisSwitchCam.nodes[1].fNodeTimePostFXTimeOffset = 0.0000
|
|
thisSwitchCam.nodes[1].fNodeMotionBlur = 0.0000
|
|
thisSwitchCam.nodes[1].NodeCamShakeType = CAM_SHAKE_MEDIUM
|
|
thisSwitchCam.nodes[1].fNodeCamShake = 0.3000
|
|
thisSwitchCam.nodes[1].iCamEaseType = 2
|
|
thisSwitchCam.nodes[1].fCamEaseScaler = 1.0000
|
|
thisSwitchCam.nodes[1].fCamNodeVelocityScale = 0.0000
|
|
thisSwitchCam.nodes[1].bCamEaseForceLinear = TRUE
|
|
thisSwitchCam.nodes[1].bCamEaseForceLevel = FALSE
|
|
thisSwitchCam.nodes[1].fTimeScale = 1.0000
|
|
thisSwitchCam.nodes[1].iTimeScaleEaseType = 0
|
|
thisSwitchCam.nodes[1].fTimeScaleEaseScaler = 0.0000
|
|
thisSwitchCam.nodes[1].bFlashEnabled = TRUE
|
|
thisSwitchCam.nodes[1].SCFE_FlashEffectUsed = SCFE_SwitchShortFranklinIn
|
|
thisSwitchCam.nodes[1].fMinExposure = 0.0000
|
|
thisSwitchCam.nodes[1].fMaxExposure = 0.0000
|
|
thisSwitchCam.nodes[1].iRampUpDuration = 0
|
|
thisSwitchCam.nodes[1].iRampDownDuration = 0
|
|
thisSwitchCam.nodes[1].iHoldDuration = 0
|
|
thisSwitchCam.nodes[1].fFlashNodePhaseOffset = 0.4000
|
|
thisSwitchCam.nodes[1].bIsLowDetailNode = FALSE
|
|
thisSwitchCam.nodes[1].bUseCustomDOF = FALSE
|
|
thisSwitchCam.nodes[1].NodeDOF_Info.fDOF_NearDOF = 0.0000
|
|
thisSwitchCam.nodes[1].NodeDOF_Info.fDOF_FarDOF = 0.0000
|
|
thisSwitchCam.nodes[1].NodeDOF_Info.fDOF_EffectStrength = 0.0000
|
|
|
|
thisSwitchCam.nodes[2].SwitchCamType = SWITCH_CAM_OLD_SYSTEM
|
|
thisSwitchCam.nodes[2].iForceCamPointAtEntityIndex = -1
|
|
thisSwitchCam.nodes[2].bIsGameplayCamCopy = FALSE
|
|
thisSwitchCam.nodes[2].iNodeTime = 600
|
|
thisSwitchCam.nodes[2].vNodePos = <<0.0646, 1.3472, 1.4595>>
|
|
thisSwitchCam.nodes[2].vWorldPosLookAt = <<0.0000, 0.0000, 0.0000>>
|
|
thisSwitchCam.nodes[2].fNodeOffsetDist = 0.0000
|
|
thisSwitchCam.nodes[2].fNodeVerticleOffset = 0.0000
|
|
thisSwitchCam.nodes[2].bAttachToOriginPed = FALSE
|
|
thisSwitchCam.nodes[2].vNodeDir = <<0.3564, 0.2439, 1.4688>>
|
|
thisSwitchCam.nodes[2].bPointAtEntity = TRUE
|
|
thisSwitchCam.nodes[2].bPointAtOffsetIsRelative = TRUE
|
|
thisSwitchCam.nodes[2].bAttachOffsetIsRelative = TRUE
|
|
thisSwitchCam.nodes[2].fNodeFOV = 40.0000
|
|
thisSwitchCam.nodes[2].vClonedNodeOffset = <<0.0000, 0.0000, 0.0000>>
|
|
thisSwitchCam.nodes[2].iNodeToClone = 0
|
|
thisSwitchCam.nodes[2].NodeTimePostFX_Type = NO_EFFECT
|
|
thisSwitchCam.nodes[2].fNodeTimePostFXBlendTime = 0.0000
|
|
thisSwitchCam.nodes[2].fNodeTimePostFXTimeOffset = 0.0000
|
|
thisSwitchCam.nodes[2].fNodeMotionBlur = 1.0000
|
|
thisSwitchCam.nodes[2].NodeCamShakeType = CAM_SHAKE_DEFAULT
|
|
thisSwitchCam.nodes[2].fNodeCamShake = 0.0000
|
|
thisSwitchCam.nodes[2].iCamEaseType = 0
|
|
thisSwitchCam.nodes[2].fCamEaseScaler = 0.0000
|
|
thisSwitchCam.nodes[2].fCamNodeVelocityScale = 0.0000
|
|
thisSwitchCam.nodes[2].bCamEaseForceLinear = TRUE
|
|
thisSwitchCam.nodes[2].bCamEaseForceLevel = FALSE
|
|
thisSwitchCam.nodes[2].fTimeScale = 1.0000
|
|
thisSwitchCam.nodes[2].iTimeScaleEaseType = 0
|
|
thisSwitchCam.nodes[2].fTimeScaleEaseScaler = 0.0000
|
|
thisSwitchCam.nodes[2].bFlashEnabled = TRUE
|
|
thisSwitchCam.nodes[2].SCFE_FlashEffectUsed = SCFE_SwitchShortMichaelMid
|
|
thisSwitchCam.nodes[2].fMinExposure = 0.0000
|
|
thisSwitchCam.nodes[2].fMaxExposure = 0.0000
|
|
thisSwitchCam.nodes[2].iRampUpDuration = 0
|
|
thisSwitchCam.nodes[2].iRampDownDuration = 0
|
|
thisSwitchCam.nodes[2].iHoldDuration = 0
|
|
thisSwitchCam.nodes[2].fFlashNodePhaseOffset = 0.5000
|
|
thisSwitchCam.nodes[2].bIsLowDetailNode = FALSE
|
|
thisSwitchCam.nodes[2].bUseCustomDOF = FALSE
|
|
thisSwitchCam.nodes[2].NodeDOF_Info.fDOF_NearDOF = 0.0000
|
|
thisSwitchCam.nodes[2].NodeDOF_Info.fDOF_FarDOF = 0.0000
|
|
thisSwitchCam.nodes[2].NodeDOF_Info.fDOF_EffectStrength = 0.0000
|
|
|
|
thisSwitchCam.nodes[3].bIsCamCutNode = TRUE
|
|
|
|
thisSwitchCam.nodes[4].SwitchCamType = SWITCH_CAM_OLD_SYSTEM
|
|
thisSwitchCam.nodes[4].iForceCamPointAtEntityIndex = -1
|
|
thisSwitchCam.nodes[4].bIsGameplayCamCopy = FALSE
|
|
thisSwitchCam.nodes[4].iNodeTime = 0
|
|
thisSwitchCam.nodes[4].vNodePos = <<-1.5125, 2.8081, -1.8774>>
|
|
thisSwitchCam.nodes[4].vWorldPosLookAt = <<0.0000, 0.0000, 0.0000>>
|
|
thisSwitchCam.nodes[4].fNodeOffsetDist = 0.0000
|
|
thisSwitchCam.nodes[4].fNodeVerticleOffset = 0.0000
|
|
thisSwitchCam.nodes[4].bAttachToOriginPed = FALSE
|
|
thisSwitchCam.nodes[4].vNodeDir = <<-0.9322, -0.2357, -1.7781>>
|
|
thisSwitchCam.nodes[4].bPointAtEntity = TRUE
|
|
thisSwitchCam.nodes[4].bPointAtOffsetIsRelative = TRUE
|
|
thisSwitchCam.nodes[4].bAttachOffsetIsRelative = TRUE
|
|
thisSwitchCam.nodes[4].fNodeFOV = 40.0000
|
|
thisSwitchCam.nodes[4].vClonedNodeOffset = <<0.0000, 0.0000, 0.0000>>
|
|
thisSwitchCam.nodes[4].iNodeToClone = 0
|
|
thisSwitchCam.nodes[4].NodeTimePostFX_Type = NO_EFFECT
|
|
thisSwitchCam.nodes[4].fNodeTimePostFXBlendTime = 0.0000
|
|
thisSwitchCam.nodes[4].fNodeTimePostFXTimeOffset = 0.0000
|
|
thisSwitchCam.nodes[4].fNodeMotionBlur = 1.0000
|
|
thisSwitchCam.nodes[4].NodeCamShakeType = CAM_SHAKE_MEDIUM
|
|
thisSwitchCam.nodes[4].fNodeCamShake = 0.3000
|
|
thisSwitchCam.nodes[4].iCamEaseType = 0
|
|
thisSwitchCam.nodes[4].fCamEaseScaler = 0.0000
|
|
thisSwitchCam.nodes[4].fCamNodeVelocityScale = 0.0000
|
|
thisSwitchCam.nodes[4].bCamEaseForceLinear = FALSE
|
|
thisSwitchCam.nodes[4].bCamEaseForceLevel = FALSE
|
|
thisSwitchCam.nodes[4].fTimeScale = 1.0000
|
|
thisSwitchCam.nodes[4].iTimeScaleEaseType = 0
|
|
thisSwitchCam.nodes[4].fTimeScaleEaseScaler = 0.0000
|
|
thisSwitchCam.nodes[4].bFlashEnabled = FALSE
|
|
thisSwitchCam.nodes[4].SCFE_FlashEffectUsed = SCFE_CODE_FLASH
|
|
thisSwitchCam.nodes[4].fMinExposure = 0.0000
|
|
thisSwitchCam.nodes[4].fMaxExposure = 0.0000
|
|
thisSwitchCam.nodes[4].iRampUpDuration = 0
|
|
thisSwitchCam.nodes[4].iRampDownDuration = 0
|
|
thisSwitchCam.nodes[4].iHoldDuration = 0
|
|
thisSwitchCam.nodes[4].fFlashNodePhaseOffset = 0.0000
|
|
thisSwitchCam.nodes[4].bIsLowDetailNode = FALSE
|
|
thisSwitchCam.nodes[4].bUseCustomDOF = FALSE
|
|
thisSwitchCam.nodes[4].NodeDOF_Info.fDOF_NearDOF = 0.0000
|
|
thisSwitchCam.nodes[4].NodeDOF_Info.fDOF_FarDOF = 0.0000
|
|
thisSwitchCam.nodes[4].NodeDOF_Info.fDOF_EffectStrength = 0.0000
|
|
|
|
thisSwitchCam.nodes[5].SwitchCamType = SWITCH_CAM_OLD_SYSTEM
|
|
thisSwitchCam.nodes[5].iForceCamPointAtEntityIndex = -1
|
|
thisSwitchCam.nodes[5].bIsGameplayCamCopy = FALSE
|
|
thisSwitchCam.nodes[5].iNodeTime = 600
|
|
thisSwitchCam.nodes[5].vNodePos = <<-1.1357, 2.3820, 0.6090>>
|
|
thisSwitchCam.nodes[5].vWorldPosLookAt = <<0.0000, 0.0000, 0.0000>>
|
|
thisSwitchCam.nodes[5].fNodeOffsetDist = 0.0000
|
|
thisSwitchCam.nodes[5].fNodeVerticleOffset = 0.0000
|
|
thisSwitchCam.nodes[5].bAttachToOriginPed = FALSE
|
|
thisSwitchCam.nodes[5].vNodeDir = <<-1.1860, -0.0093, 0.4085>>
|
|
thisSwitchCam.nodes[5].bPointAtEntity = TRUE
|
|
thisSwitchCam.nodes[5].bPointAtOffsetIsRelative = TRUE
|
|
thisSwitchCam.nodes[5].bAttachOffsetIsRelative = TRUE
|
|
thisSwitchCam.nodes[5].fNodeFOV = 45.0000
|
|
thisSwitchCam.nodes[5].vClonedNodeOffset = <<0.0000, 0.0000, 0.0000>>
|
|
thisSwitchCam.nodes[5].iNodeToClone = 0
|
|
thisSwitchCam.nodes[5].NodeTimePostFX_Type = NO_EFFECT
|
|
thisSwitchCam.nodes[5].fNodeTimePostFXBlendTime = 0.0000
|
|
thisSwitchCam.nodes[5].fNodeTimePostFXTimeOffset = 0.0000
|
|
thisSwitchCam.nodes[5].fNodeMotionBlur = 1.0000
|
|
thisSwitchCam.nodes[5].NodeCamShakeType = CAM_SHAKE_MEDIUM
|
|
thisSwitchCam.nodes[5].fNodeCamShake = 0.3000
|
|
thisSwitchCam.nodes[5].iCamEaseType = 0
|
|
thisSwitchCam.nodes[5].fCamEaseScaler = 0.0000
|
|
thisSwitchCam.nodes[5].fCamNodeVelocityScale = 0.6000
|
|
thisSwitchCam.nodes[5].bCamEaseForceLinear = FALSE
|
|
thisSwitchCam.nodes[5].bCamEaseForceLevel = FALSE
|
|
thisSwitchCam.nodes[5].fTimeScale = 1.0000
|
|
thisSwitchCam.nodes[5].iTimeScaleEaseType = 0
|
|
thisSwitchCam.nodes[5].fTimeScaleEaseScaler = 0.0000
|
|
thisSwitchCam.nodes[5].bFlashEnabled = FALSE
|
|
thisSwitchCam.nodes[5].SCFE_FlashEffectUsed = SCFE_CODE_FLASH
|
|
thisSwitchCam.nodes[5].fMinExposure = 0.0000
|
|
thisSwitchCam.nodes[5].fMaxExposure = 0.0000
|
|
thisSwitchCam.nodes[5].iRampUpDuration = 0
|
|
thisSwitchCam.nodes[5].iRampDownDuration = 0
|
|
thisSwitchCam.nodes[5].iHoldDuration = 0
|
|
thisSwitchCam.nodes[5].fFlashNodePhaseOffset = 0.0000
|
|
thisSwitchCam.nodes[5].bIsLowDetailNode = FALSE
|
|
thisSwitchCam.nodes[5].bUseCustomDOF = FALSE
|
|
thisSwitchCam.nodes[5].NodeDOF_Info.fDOF_NearDOF = 0.0000
|
|
thisSwitchCam.nodes[5].NodeDOF_Info.fDOF_FarDOF = 0.0000
|
|
thisSwitchCam.nodes[5].NodeDOF_Info.fDOF_EffectStrength = 0.0000
|
|
|
|
thisSwitchCam.nodes[6].SwitchCamType = SWITCH_CAM_OLD_SYSTEM
|
|
thisSwitchCam.nodes[6].iForceCamPointAtEntityIndex = -1
|
|
thisSwitchCam.nodes[6].bIsGameplayCamCopy = TRUE
|
|
thisSwitchCam.nodes[6].iNodeTime = 600
|
|
thisSwitchCam.nodes[6].vNodePos = <<-1.1809, 1.3800, 0.7801>>
|
|
thisSwitchCam.nodes[6].vWorldPosLookAt = <<0.0000, 0.0000, 0.0000>>
|
|
thisSwitchCam.nodes[6].fNodeOffsetDist = 0.0000
|
|
thisSwitchCam.nodes[6].fNodeVerticleOffset = 0.0000
|
|
thisSwitchCam.nodes[6].bAttachToOriginPed = FALSE
|
|
thisSwitchCam.nodes[6].vNodeDir = <<-0.5020, -0.2914, 0.4661>>
|
|
thisSwitchCam.nodes[6].bPointAtEntity = TRUE
|
|
thisSwitchCam.nodes[6].bPointAtOffsetIsRelative = TRUE
|
|
thisSwitchCam.nodes[6].bAttachOffsetIsRelative = TRUE
|
|
thisSwitchCam.nodes[6].fNodeFOV = 45.0000
|
|
thisSwitchCam.nodes[6].vClonedNodeOffset = <<0.0000, 0.0000, 0.0000>>
|
|
thisSwitchCam.nodes[6].iNodeToClone = 0
|
|
thisSwitchCam.nodes[6].NodeTimePostFX_Type = NO_EFFECT
|
|
thisSwitchCam.nodes[6].fNodeTimePostFXBlendTime = 0.0000
|
|
thisSwitchCam.nodes[6].fNodeTimePostFXTimeOffset = 0.0000
|
|
thisSwitchCam.nodes[6].fNodeMotionBlur = 0.0000
|
|
thisSwitchCam.nodes[6].NodeCamShakeType = CAM_SHAKE_MEDIUM
|
|
thisSwitchCam.nodes[6].fNodeCamShake = 0.3000
|
|
thisSwitchCam.nodes[6].iCamEaseType = 0
|
|
thisSwitchCam.nodes[6].fCamEaseScaler = 0.0000
|
|
thisSwitchCam.nodes[6].fCamNodeVelocityScale = 0.0000
|
|
thisSwitchCam.nodes[6].bCamEaseForceLinear = FALSE
|
|
thisSwitchCam.nodes[6].bCamEaseForceLevel = FALSE
|
|
thisSwitchCam.nodes[6].fTimeScale = 1.0000
|
|
thisSwitchCam.nodes[6].iTimeScaleEaseType = 0
|
|
thisSwitchCam.nodes[6].fTimeScaleEaseScaler = 0.0000
|
|
thisSwitchCam.nodes[6].bFlashEnabled = FALSE
|
|
thisSwitchCam.nodes[6].SCFE_FlashEffectUsed = SCFE_CODE_FLASH
|
|
thisSwitchCam.nodes[6].fMinExposure = 0.0000
|
|
thisSwitchCam.nodes[6].fMaxExposure = 0.0000
|
|
thisSwitchCam.nodes[6].iRampUpDuration = 0
|
|
thisSwitchCam.nodes[6].iRampDownDuration = 0
|
|
thisSwitchCam.nodes[6].iHoldDuration = 0
|
|
thisSwitchCam.nodes[6].fFlashNodePhaseOffset = 0.0000
|
|
thisSwitchCam.nodes[6].bIsLowDetailNode = FALSE
|
|
thisSwitchCam.nodes[6].bUseCustomDOF = FALSE
|
|
thisSwitchCam.nodes[6].NodeDOF_Info.fDOF_NearDOF = 0.0000
|
|
thisSwitchCam.nodes[6].NodeDOF_Info.fDOF_FarDOF = 0.0000
|
|
thisSwitchCam.nodes[6].NodeDOF_Info.fDOF_EffectStrength = 0.0000
|
|
|
|
|
|
|
|
thisSwitchCam.iNumNodes = 7
|
|
thisSwitchCam.iCamSwitchFocusNode = 3
|
|
thisSwitchCam.fSwitchSoundAudioStartPhase = 0.015
|
|
thisSwitchCam.fSwitchSoundAudioEndPhase = 0.34
|
|
thisSwitchCam.bSwitchSoundPlayOpeningPulse = FALSE
|
|
thisSwitchCam.bSwitchSoundPlayMoveLoop = FALSE
|
|
thisSwitchCam.bSwitchSoundPlayExitPulse = FALSE
|
|
thisSwitchCam.bSplineNoSmoothing = FALSE
|
|
thisSwitchCam.bAddGameplayCamAsLastNode = TRUE
|
|
thisSwitchCam.iGameplayNodeBlendDuration = 0
|
|
|
|
|
|
//--- End of Cam Data ---
|
|
|
|
|
|
|
|
thisSwitchCam.strOutputStructName = "thisSwitchCam"
|
|
thisSwitchCam.strOutputFileName = "CameraInfo_FIB2_FranklinToMike.txt"
|
|
thisSwitchCam.strXMLFileName = "CameraInfo_FIB2_FranklinToMike.xml"
|
|
|
|
thisSwitchCam.bInitialized = TRUE
|
|
//ENDIF
|
|
|
|
thisSwitchCam.piPeds[0] = piFranklin
|
|
thisSwitchCam.piPeds[1] = piMichael
|
|
|
|
|
|
ENDPROC
|
|
|
|
|
|
PROC SETUP_SPLINE_CAM_NODE_ARRAY_FRANKLIN_TO_MICHAEL_FIRST_PERSON(SWITCH_CAM_STRUCT &thisSwitchCam, PED_INDEX piFranklin, PED_INDEX piMichael)
|
|
CDEBUG3LN(DEBUG_MISSION, "SETUP_SPLINE_CAM_NODE_ARRAY_FRANKLIN_TO_TREVOR")
|
|
|
|
//IF NOT thisSwitchCam.bInitialized
|
|
|
|
|
|
//--- Start of Cam Data ---
|
|
|
|
|
|
thisSwitchCam.nodes[0].SwitchCamType = SWITCH_CAM_OLD_SYSTEM
|
|
thisSwitchCam.nodes[0].iForceCamPointAtEntityIndex = -1
|
|
thisSwitchCam.nodes[0].bIsGameplayCamCopy = FALSE
|
|
thisSwitchCam.nodes[0].iNodeTime = 0
|
|
thisSwitchCam.nodes[0].vNodePos = <<-0.0083, 1.3912, 0.2997>>
|
|
thisSwitchCam.nodes[0].vWorldPosLookAt = <<0.0000, 0.0000, 0.0000>>
|
|
thisSwitchCam.nodes[0].fNodeOffsetDist = 0.0000
|
|
thisSwitchCam.nodes[0].fNodeVerticleOffset = 0.0000
|
|
thisSwitchCam.nodes[0].bAttachToOriginPed = FALSE
|
|
thisSwitchCam.nodes[0].vNodeDir = <<0.4002, 0.1876, 0.4090>>
|
|
thisSwitchCam.nodes[0].bPointAtEntity = TRUE
|
|
thisSwitchCam.nodes[0].bPointAtOffsetIsRelative = TRUE
|
|
thisSwitchCam.nodes[0].bAttachOffsetIsRelative = TRUE
|
|
thisSwitchCam.nodes[0].fNodeFOV = 40.0000
|
|
thisSwitchCam.nodes[0].vClonedNodeOffset = <<0.0000, 0.0000, 0.0000>>
|
|
thisSwitchCam.nodes[0].iNodeToClone = 0
|
|
thisSwitchCam.nodes[0].NodeTimePostFX_Type = NO_EFFECT
|
|
thisSwitchCam.nodes[0].fNodeTimePostFXBlendTime = 0.0000
|
|
thisSwitchCam.nodes[0].fNodeTimePostFXTimeOffset = 0.0000
|
|
thisSwitchCam.nodes[0].fNodeMotionBlur = 0.0000
|
|
thisSwitchCam.nodes[0].NodeCamShakeType = CAM_SHAKE_MEDIUM
|
|
thisSwitchCam.nodes[0].fNodeCamShake = 0.3000
|
|
thisSwitchCam.nodes[0].iCamEaseType = 0
|
|
thisSwitchCam.nodes[0].fCamEaseScaler = 0.0000
|
|
thisSwitchCam.nodes[0].fCamNodeVelocityScale = 0.0000
|
|
thisSwitchCam.nodes[0].bCamEaseForceLinear = TRUE
|
|
thisSwitchCam.nodes[0].bCamEaseForceLevel = FALSE
|
|
thisSwitchCam.nodes[0].fTimeScale = 0.0100
|
|
thisSwitchCam.nodes[0].iTimeScaleEaseType = 0
|
|
thisSwitchCam.nodes[0].fTimeScaleEaseScaler = 0.0000
|
|
thisSwitchCam.nodes[0].bFlashEnabled = FALSE
|
|
thisSwitchCam.nodes[0].SCFE_FlashEffectUsed = SCFE_CODE_FLASH
|
|
thisSwitchCam.nodes[0].fMinExposure = 0.0000
|
|
thisSwitchCam.nodes[0].fMaxExposure = 0.0000
|
|
thisSwitchCam.nodes[0].iRampUpDuration = 0
|
|
thisSwitchCam.nodes[0].iRampDownDuration = 0
|
|
thisSwitchCam.nodes[0].iHoldDuration = 0
|
|
thisSwitchCam.nodes[0].fFlashNodePhaseOffset = 0.0000
|
|
thisSwitchCam.nodes[0].bIsLowDetailNode = FALSE
|
|
thisSwitchCam.nodes[0].bUseCustomDOF = FALSE
|
|
thisSwitchCam.nodes[0].NodeDOF_Info.fDOF_NearDOF = 0.0000
|
|
thisSwitchCam.nodes[0].NodeDOF_Info.fDOF_FarDOF = 0.0000
|
|
thisSwitchCam.nodes[0].NodeDOF_Info.fDOF_EffectStrength = 0.0000
|
|
|
|
thisSwitchCam.nodes[1].SwitchCamType = SWITCH_CAM_OLD_SYSTEM
|
|
thisSwitchCam.nodes[1].iForceCamPointAtEntityIndex = -1
|
|
thisSwitchCam.nodes[1].bIsGameplayCamCopy = FALSE
|
|
thisSwitchCam.nodes[1].iNodeTime = 10
|
|
thisSwitchCam.nodes[1].vNodePos = <<-0.0083, 1.3912, 0.2997>>
|
|
thisSwitchCam.nodes[1].vWorldPosLookAt = <<0.0000, 0.0000, 0.2000>>
|
|
thisSwitchCam.nodes[1].fNodeOffsetDist = 0.0000
|
|
thisSwitchCam.nodes[1].fNodeVerticleOffset = 0.0000
|
|
thisSwitchCam.nodes[1].bAttachToOriginPed = FALSE
|
|
thisSwitchCam.nodes[1].vNodeDir = <<0.4002, 0.1876, 0.4090>>
|
|
thisSwitchCam.nodes[1].bPointAtEntity = TRUE
|
|
thisSwitchCam.nodes[1].bPointAtOffsetIsRelative = TRUE
|
|
thisSwitchCam.nodes[1].bAttachOffsetIsRelative = TRUE
|
|
thisSwitchCam.nodes[1].fNodeFOV = 40.0000
|
|
thisSwitchCam.nodes[1].vClonedNodeOffset = <<0.0000, 0.0000, 0.0000>>
|
|
thisSwitchCam.nodes[1].iNodeToClone = 0
|
|
thisSwitchCam.nodes[1].NodeTimePostFX_Type = NO_EFFECT
|
|
thisSwitchCam.nodes[1].fNodeTimePostFXBlendTime = 0.0000
|
|
thisSwitchCam.nodes[1].fNodeTimePostFXTimeOffset = 0.0000
|
|
thisSwitchCam.nodes[1].fNodeMotionBlur = 0.0000
|
|
thisSwitchCam.nodes[1].NodeCamShakeType = CAM_SHAKE_MEDIUM
|
|
thisSwitchCam.nodes[1].fNodeCamShake = 0.3000
|
|
thisSwitchCam.nodes[1].iCamEaseType = 2
|
|
thisSwitchCam.nodes[1].fCamEaseScaler = 1.0000
|
|
thisSwitchCam.nodes[1].fCamNodeVelocityScale = 0.0000
|
|
thisSwitchCam.nodes[1].bCamEaseForceLinear = TRUE
|
|
thisSwitchCam.nodes[1].bCamEaseForceLevel = FALSE
|
|
thisSwitchCam.nodes[1].fTimeScale = 1.0000
|
|
thisSwitchCam.nodes[1].iTimeScaleEaseType = 0
|
|
thisSwitchCam.nodes[1].fTimeScaleEaseScaler = 0.0000
|
|
thisSwitchCam.nodes[1].bFlashEnabled = TRUE
|
|
thisSwitchCam.nodes[1].SCFE_FlashEffectUsed = SCFE_SwitchShortFranklinIn
|
|
thisSwitchCam.nodes[1].fMinExposure = 0.0000
|
|
thisSwitchCam.nodes[1].fMaxExposure = 0.0000
|
|
thisSwitchCam.nodes[1].iRampUpDuration = 0
|
|
thisSwitchCam.nodes[1].iRampDownDuration = 0
|
|
thisSwitchCam.nodes[1].iHoldDuration = 0
|
|
thisSwitchCam.nodes[1].fFlashNodePhaseOffset = 0.4000
|
|
thisSwitchCam.nodes[1].bIsLowDetailNode = FALSE
|
|
thisSwitchCam.nodes[1].bUseCustomDOF = FALSE
|
|
thisSwitchCam.nodes[1].NodeDOF_Info.fDOF_NearDOF = 0.0000
|
|
thisSwitchCam.nodes[1].NodeDOF_Info.fDOF_FarDOF = 0.0000
|
|
thisSwitchCam.nodes[1].NodeDOF_Info.fDOF_EffectStrength = 0.0000
|
|
|
|
thisSwitchCam.nodes[2].SwitchCamType = SWITCH_CAM_OLD_SYSTEM
|
|
thisSwitchCam.nodes[2].iForceCamPointAtEntityIndex = -1
|
|
thisSwitchCam.nodes[2].bIsGameplayCamCopy = FALSE
|
|
thisSwitchCam.nodes[2].iNodeTime = 600
|
|
thisSwitchCam.nodes[2].vNodePos = <<0.0646, 1.3472, 1.4595>>
|
|
thisSwitchCam.nodes[2].vWorldPosLookAt = <<0.0000, 0.0000, 0.0000>>
|
|
thisSwitchCam.nodes[2].fNodeOffsetDist = 0.0000
|
|
thisSwitchCam.nodes[2].fNodeVerticleOffset = 0.0000
|
|
thisSwitchCam.nodes[2].bAttachToOriginPed = FALSE
|
|
thisSwitchCam.nodes[2].vNodeDir = <<0.3564, 0.2439, 1.4688>>
|
|
thisSwitchCam.nodes[2].bPointAtEntity = TRUE
|
|
thisSwitchCam.nodes[2].bPointAtOffsetIsRelative = TRUE
|
|
thisSwitchCam.nodes[2].bAttachOffsetIsRelative = TRUE
|
|
thisSwitchCam.nodes[2].fNodeFOV = 40.0000
|
|
thisSwitchCam.nodes[2].vClonedNodeOffset = <<0.0000, 0.0000, 0.0000>>
|
|
thisSwitchCam.nodes[2].iNodeToClone = 0
|
|
thisSwitchCam.nodes[2].NodeTimePostFX_Type = NO_EFFECT
|
|
thisSwitchCam.nodes[2].fNodeTimePostFXBlendTime = 0.0000
|
|
thisSwitchCam.nodes[2].fNodeTimePostFXTimeOffset = 0.0000
|
|
thisSwitchCam.nodes[2].fNodeMotionBlur = 1.0000
|
|
thisSwitchCam.nodes[2].NodeCamShakeType = CAM_SHAKE_DEFAULT
|
|
thisSwitchCam.nodes[2].fNodeCamShake = 0.0000
|
|
thisSwitchCam.nodes[2].iCamEaseType = 0
|
|
thisSwitchCam.nodes[2].fCamEaseScaler = 0.0000
|
|
thisSwitchCam.nodes[2].fCamNodeVelocityScale = 0.0000
|
|
thisSwitchCam.nodes[2].bCamEaseForceLinear = TRUE
|
|
thisSwitchCam.nodes[2].bCamEaseForceLevel = FALSE
|
|
thisSwitchCam.nodes[2].fTimeScale = 1.0000
|
|
thisSwitchCam.nodes[2].iTimeScaleEaseType = 0
|
|
thisSwitchCam.nodes[2].fTimeScaleEaseScaler = 0.0000
|
|
thisSwitchCam.nodes[2].bFlashEnabled = TRUE
|
|
thisSwitchCam.nodes[2].SCFE_FlashEffectUsed = SCFE_SwitchShortMichaelMid
|
|
thisSwitchCam.nodes[2].fMinExposure = 0.0000
|
|
thisSwitchCam.nodes[2].fMaxExposure = 0.0000
|
|
thisSwitchCam.nodes[2].iRampUpDuration = 0
|
|
thisSwitchCam.nodes[2].iRampDownDuration = 0
|
|
thisSwitchCam.nodes[2].iHoldDuration = 0
|
|
thisSwitchCam.nodes[2].fFlashNodePhaseOffset = 0.5000
|
|
thisSwitchCam.nodes[2].bIsLowDetailNode = FALSE
|
|
thisSwitchCam.nodes[2].bUseCustomDOF = FALSE
|
|
thisSwitchCam.nodes[2].NodeDOF_Info.fDOF_NearDOF = 0.0000
|
|
thisSwitchCam.nodes[2].NodeDOF_Info.fDOF_FarDOF = 0.0000
|
|
thisSwitchCam.nodes[2].NodeDOF_Info.fDOF_EffectStrength = 0.0000
|
|
|
|
thisSwitchCam.nodes[3].bIsCamCutNode = TRUE
|
|
|
|
thisSwitchCam.nodes[4].SwitchCamType = SWITCH_CAM_OLD_SYSTEM
|
|
thisSwitchCam.nodes[4].iForceCamPointAtEntityIndex = -1
|
|
thisSwitchCam.nodes[4].bIsGameplayCamCopy = FALSE
|
|
thisSwitchCam.nodes[4].iNodeTime = 0
|
|
thisSwitchCam.nodes[4].vNodePos = <<-1.9125, 1.3081, -2.1774>>
|
|
thisSwitchCam.nodes[4].vWorldPosLookAt = <<0.0000, 0.0000, 0.0000>>
|
|
thisSwitchCam.nodes[4].fNodeOffsetDist = 0.0000
|
|
thisSwitchCam.nodes[4].fNodeVerticleOffset = 0.0000
|
|
thisSwitchCam.nodes[4].bAttachToOriginPed = FALSE
|
|
thisSwitchCam.nodes[4].vNodeDir = <<0, -1, -1.4>>
|
|
thisSwitchCam.nodes[4].bPointAtEntity = TRUE
|
|
thisSwitchCam.nodes[4].bPointAtOffsetIsRelative = TRUE
|
|
thisSwitchCam.nodes[4].bAttachOffsetIsRelative = TRUE
|
|
thisSwitchCam.nodes[4].fNodeFOV = 40.0000
|
|
thisSwitchCam.nodes[4].vClonedNodeOffset = <<0.0000, 0.0000, 0.0000>>
|
|
thisSwitchCam.nodes[4].iNodeToClone = 0
|
|
thisSwitchCam.nodes[4].NodeTimePostFX_Type = NO_EFFECT
|
|
thisSwitchCam.nodes[4].fNodeTimePostFXBlendTime = 0.0000
|
|
thisSwitchCam.nodes[4].fNodeTimePostFXTimeOffset = 0.0000
|
|
thisSwitchCam.nodes[4].fNodeMotionBlur = 1.0000
|
|
thisSwitchCam.nodes[4].NodeCamShakeType = CAM_SHAKE_MEDIUM
|
|
thisSwitchCam.nodes[4].fNodeCamShake = 0.5000
|
|
thisSwitchCam.nodes[4].iCamEaseType = 0
|
|
thisSwitchCam.nodes[4].fCamEaseScaler = 0.0000
|
|
thisSwitchCam.nodes[4].fCamNodeVelocityScale = 0.0000
|
|
thisSwitchCam.nodes[4].bCamEaseForceLinear = FALSE
|
|
thisSwitchCam.nodes[4].bCamEaseForceLevel = FALSE
|
|
thisSwitchCam.nodes[4].fTimeScale = 0.3
|
|
thisSwitchCam.nodes[4].iTimeScaleEaseType = 0
|
|
thisSwitchCam.nodes[4].fTimeScaleEaseScaler = 0.0000
|
|
thisSwitchCam.nodes[4].bFlashEnabled = FALSE
|
|
thisSwitchCam.nodes[4].SCFE_FlashEffectUsed = SCFE_CODE_FLASH
|
|
thisSwitchCam.nodes[4].fMinExposure = 0.0000
|
|
thisSwitchCam.nodes[4].fMaxExposure = 0.0000
|
|
thisSwitchCam.nodes[4].iRampUpDuration = 0
|
|
thisSwitchCam.nodes[4].iRampDownDuration = 0
|
|
thisSwitchCam.nodes[4].iHoldDuration = 0
|
|
thisSwitchCam.nodes[4].fFlashNodePhaseOffset = 0.0000
|
|
thisSwitchCam.nodes[4].bIsLowDetailNode = FALSE
|
|
thisSwitchCam.nodes[4].bUseCustomDOF = FALSE
|
|
thisSwitchCam.nodes[4].NodeDOF_Info.fDOF_NearDOF = 0.0000
|
|
thisSwitchCam.nodes[4].NodeDOF_Info.fDOF_FarDOF = 0.0000
|
|
thisSwitchCam.nodes[4].NodeDOF_Info.fDOF_EffectStrength = 0.0000
|
|
|
|
thisSwitchCam.nodes[5].SwitchCamType = SWITCH_CAM_OLD_SYSTEM
|
|
thisSwitchCam.nodes[5].iForceCamPointAtEntityIndex = -1
|
|
thisSwitchCam.nodes[5].bIsGameplayCamCopy = FALSE
|
|
thisSwitchCam.nodes[5].iNodeTime = 600
|
|
thisSwitchCam.nodes[5].vNodePos = <<-1.9125, 1.3081, -0.1774>>
|
|
thisSwitchCam.nodes[5].vWorldPosLookAt = <<0.0000, 0.0000, 0.0000>>
|
|
thisSwitchCam.nodes[5].fNodeOffsetDist = 0.0000
|
|
thisSwitchCam.nodes[5].fNodeVerticleOffset = 0.0000
|
|
thisSwitchCam.nodes[5].bAttachToOriginPed = FALSE
|
|
thisSwitchCam.nodes[5].vNodeDir = <<0, -1, 0.6>>
|
|
thisSwitchCam.nodes[5].bPointAtEntity = TRUE
|
|
thisSwitchCam.nodes[5].bPointAtOffsetIsRelative = TRUE
|
|
thisSwitchCam.nodes[5].bAttachOffsetIsRelative = TRUE
|
|
thisSwitchCam.nodes[5].fNodeFOV = 40.0000
|
|
thisSwitchCam.nodes[5].vClonedNodeOffset = <<0.0000, 0.0000, 0.0000>>
|
|
thisSwitchCam.nodes[5].iNodeToClone = 0
|
|
thisSwitchCam.nodes[5].NodeTimePostFX_Type = NO_EFFECT
|
|
thisSwitchCam.nodes[5].fNodeTimePostFXBlendTime = 0.0000
|
|
thisSwitchCam.nodes[5].fNodeTimePostFXTimeOffset = 0.0000
|
|
thisSwitchCam.nodes[5].fNodeMotionBlur = 1.0000
|
|
thisSwitchCam.nodes[5].NodeCamShakeType = CAM_SHAKE_MEDIUM
|
|
thisSwitchCam.nodes[5].fNodeCamShake = 0.5000
|
|
thisSwitchCam.nodes[5].iCamEaseType = 0
|
|
thisSwitchCam.nodes[5].fCamEaseScaler = 0.0000
|
|
thisSwitchCam.nodes[5].fCamNodeVelocityScale = 0.6000
|
|
thisSwitchCam.nodes[5].bCamEaseForceLinear = FALSE
|
|
thisSwitchCam.nodes[5].bCamEaseForceLevel = FALSE
|
|
thisSwitchCam.nodes[5].fTimeScale = 0.3
|
|
thisSwitchCam.nodes[5].iTimeScaleEaseType = 0
|
|
thisSwitchCam.nodes[5].fTimeScaleEaseScaler = 0.0000
|
|
thisSwitchCam.nodes[5].bFlashEnabled = FALSE
|
|
thisSwitchCam.nodes[5].SCFE_FlashEffectUsed = SCFE_CODE_FLASH
|
|
thisSwitchCam.nodes[5].fMinExposure = 0.0000
|
|
thisSwitchCam.nodes[5].fMaxExposure = 0.0000
|
|
thisSwitchCam.nodes[5].iRampUpDuration = 0
|
|
thisSwitchCam.nodes[5].iRampDownDuration = 0
|
|
thisSwitchCam.nodes[5].iHoldDuration = 0
|
|
thisSwitchCam.nodes[5].fFlashNodePhaseOffset = 0.0000
|
|
thisSwitchCam.nodes[5].bIsLowDetailNode = FALSE
|
|
thisSwitchCam.nodes[5].bUseCustomDOF = FALSE
|
|
thisSwitchCam.nodes[5].NodeDOF_Info.fDOF_NearDOF = 0.0000
|
|
thisSwitchCam.nodes[5].NodeDOF_Info.fDOF_FarDOF = 0.0000
|
|
thisSwitchCam.nodes[5].NodeDOF_Info.fDOF_EffectStrength = 0.0000
|
|
|
|
thisSwitchCam.nodes[6].SwitchCamType = SWITCH_CAM_OLD_SYSTEM
|
|
thisSwitchCam.nodes[6].iForceCamPointAtEntityIndex = -1
|
|
thisSwitchCam.nodes[6].bIsGameplayCamCopy = FALSE
|
|
thisSwitchCam.nodes[6].iNodeTime = 400
|
|
thisSwitchCam.nodes[6].vNodePos = <<-1.9125, 1.3081, -0.1774>>
|
|
thisSwitchCam.nodes[6].vWorldPosLookAt = <<0.0000, 0.0000, 0.0000>>
|
|
thisSwitchCam.nodes[6].fNodeOffsetDist = 0.0000
|
|
thisSwitchCam.nodes[6].fNodeVerticleOffset = 0.0000
|
|
thisSwitchCam.nodes[6].bAttachToOriginPed = FALSE
|
|
thisSwitchCam.nodes[6].vNodeDir = <<0, -1, 0.6>>
|
|
thisSwitchCam.nodes[6].bPointAtEntity = TRUE
|
|
thisSwitchCam.nodes[6].bPointAtOffsetIsRelative = TRUE
|
|
thisSwitchCam.nodes[6].bAttachOffsetIsRelative = TRUE
|
|
thisSwitchCam.nodes[6].fNodeFOV = 40.0000
|
|
thisSwitchCam.nodes[6].vClonedNodeOffset = <<0.0000, 0.0000, 0.0000>>
|
|
thisSwitchCam.nodes[6].iNodeToClone = 0
|
|
thisSwitchCam.nodes[6].NodeTimePostFX_Type = NO_EFFECT
|
|
thisSwitchCam.nodes[6].fNodeTimePostFXBlendTime = 0.0000
|
|
thisSwitchCam.nodes[6].fNodeTimePostFXTimeOffset = 0.0000
|
|
thisSwitchCam.nodes[6].fNodeMotionBlur = 0.0000
|
|
thisSwitchCam.nodes[6].NodeCamShakeType = CAM_SHAKE_MEDIUM
|
|
thisSwitchCam.nodes[6].fNodeCamShake = 0.5000
|
|
thisSwitchCam.nodes[6].iCamEaseType = 0
|
|
thisSwitchCam.nodes[6].fCamEaseScaler = 0.0000
|
|
thisSwitchCam.nodes[6].fCamNodeVelocityScale = 0.0000
|
|
thisSwitchCam.nodes[6].bCamEaseForceLinear = FALSE
|
|
thisSwitchCam.nodes[6].bCamEaseForceLevel = FALSE
|
|
thisSwitchCam.nodes[6].fTimeScale = 1.0000
|
|
thisSwitchCam.nodes[6].iTimeScaleEaseType = 0
|
|
thisSwitchCam.nodes[6].fTimeScaleEaseScaler = 0.0000
|
|
thisSwitchCam.nodes[6].bFlashEnabled = FALSE
|
|
thisSwitchCam.nodes[6].SCFE_FlashEffectUsed = SCFE_CODE_FLASH
|
|
thisSwitchCam.nodes[6].fMinExposure = 0.0000
|
|
thisSwitchCam.nodes[6].fMaxExposure = 0.0000
|
|
thisSwitchCam.nodes[6].iRampUpDuration = 0
|
|
thisSwitchCam.nodes[6].iRampDownDuration = 0
|
|
thisSwitchCam.nodes[6].iHoldDuration = 0
|
|
thisSwitchCam.nodes[6].fFlashNodePhaseOffset = 0.0000
|
|
thisSwitchCam.nodes[6].bIsLowDetailNode = FALSE
|
|
thisSwitchCam.nodes[6].bUseCustomDOF = FALSE
|
|
thisSwitchCam.nodes[6].NodeDOF_Info.fDOF_NearDOF = 0.0000
|
|
thisSwitchCam.nodes[6].NodeDOF_Info.fDOF_FarDOF = 0.0000
|
|
thisSwitchCam.nodes[6].NodeDOF_Info.fDOF_EffectStrength = 0.0000
|
|
|
|
|
|
|
|
thisSwitchCam.iNumNodes = 7
|
|
thisSwitchCam.iCamSwitchFocusNode = 3
|
|
thisSwitchCam.fSwitchSoundAudioStartPhase = 0.015
|
|
thisSwitchCam.fSwitchSoundAudioEndPhase = 0.34
|
|
thisSwitchCam.bSwitchSoundPlayOpeningPulse = FALSE
|
|
thisSwitchCam.bSwitchSoundPlayMoveLoop = FALSE
|
|
thisSwitchCam.bSwitchSoundPlayExitPulse = FALSE
|
|
thisSwitchCam.bSplineNoSmoothing = FALSE
|
|
//thisSwitchCam.bAddGameplayCamAsLastNode = TRUE
|
|
thisSwitchCam.iGameplayNodeBlendDuration = 0
|
|
|
|
|
|
//--- End of Cam Data ---
|
|
|
|
|
|
|
|
thisSwitchCam.strOutputStructName = "thisSwitchCam"
|
|
thisSwitchCam.strOutputFileName = "CameraInfo_FIB2_FranklinToMike.txt"
|
|
thisSwitchCam.strXMLFileName = "CameraInfo_FIB2_FranklinToMike.xml"
|
|
|
|
thisSwitchCam.bInitialized = TRUE
|
|
//ENDIF
|
|
|
|
thisSwitchCam.piPeds[0] = piFranklin
|
|
thisSwitchCam.piPeds[1] = piMichael
|
|
|
|
|
|
ENDPROC
|
|
|
|
|
|
/// PURPOSE:
|
|
/// Handle the playback of the switch cam. The will setup, play, shut down and cleanup the switch cam spline
|
|
/// PARAMS:
|
|
/// thisSwitchCam - Switch camera to playback
|
|
/// bReturnTrueOnce - If you only want this function to return TRUE once upon completion. Set to FALSE to have this function to return true every time this is called once the camera is finished playback.
|
|
/// RETURNS:
|
|
/// TRUE when camera is complete, FALSE if playback is still active, or if the camera has completed playback and bReturnTrueOnce is set to TRUE.
|
|
FUNC BOOL HANDLE_SWITCH_CAM_FRANKLIN_TO_HELI(SWITCH_CAM_STRUCT &thisSwitchCam, BOOL bReturnTrueOnce = TRUE)
|
|
|
|
INT iCurrentNode
|
|
|
|
VECTOR vMichaelAimOutSideHeliLoc
|
|
VECTOR vHeliLocDebug
|
|
VECTOR vHeliForwardDebug
|
|
VECTOR vMichaelAimDirection
|
|
|
|
|
|
SWITCH eSwitchCamState
|
|
|
|
CASE SWITCH_CAM_IDLE
|
|
CDEBUG3LN(DEBUG_MISSION, "eSwitchCamState = SWITCH_CAM_IDLE")
|
|
RETURN FALSE
|
|
BREAK
|
|
|
|
CASE SWITCH_CAM_SETUP_SPLINE
|
|
CDEBUG3LN(DEBUG_MISSION, "eSwitchCamState = SWITCH_CAM_SETUP_SPLINE")
|
|
//SETUP_SPLINE_CAM_NODE_ARRAY_HELI_MICHAEL_TO_TREVOR(thisSwitchCam, PLAYER_PED_ID(), GET_TREVOR_PED())
|
|
|
|
IF DOES_SWITCH_CAM_EXIST(thisSwitchCam)
|
|
DESTROY_SWITCH_CAM(thisSwitchCam)
|
|
ENDIF
|
|
|
|
CREATE_SPLINE_CAM(thisSwitchCam)
|
|
|
|
IF bSwitchToFirstPerson
|
|
INT i
|
|
REPEAT COUNT_OF(thisSwitchCam.nodes) i
|
|
IF DOES_CAM_EXIST(thisSwitchCam.nodes[i].ciSwitchNode)
|
|
IF i > 3
|
|
SET_CAM_INHERIT_ROLL_VEHICLE(thisSwitchCam.nodes[i].ciSwitchNode, snatchAndGrabVehicle[SAGV_PLAYER_CHOPPER])
|
|
ENDIF
|
|
ENDIF
|
|
ENDREPEAT
|
|
ENDIF
|
|
|
|
|
|
SET_CAM_ACTIVE(thisSwitchCam.ciSpline, TRUE)
|
|
RENDER_SCRIPT_CAMS(TRUE, FALSE)
|
|
|
|
DISPLAY_RADAR(FALSE)
|
|
DISPLAY_HUD(FALSE)
|
|
|
|
SETTIMERB(0)
|
|
|
|
SET_PLAYER_CONTROL(PLAYER_ID(), FALSE)
|
|
|
|
SET_GAME_PAUSES_FOR_STREAMING(FALSE)
|
|
|
|
bPlayerControlGiven = FALSE
|
|
|
|
IF NOT bSwitchToFirstPerson
|
|
CLEAR_PED_TASKS(GET_MICHAEL_PED())
|
|
ENDIF
|
|
|
|
IF NOT IS_SCRIPT_TASK_RUNNING_OR_STARTING(GET_FRANKLIN_PED(), SCRIPT_TASK_PLAY_ANIM)
|
|
CLEAR_PED_TASKS_IMMEDIATELY(GET_FRANKLIN_PED())
|
|
TASK_PLAY_ANIM(GET_FRANKLIN_PED(), GET_SNATCH_AND_GRAB_ANIM_DICT_AS_STRING(SAG_ANIM_DICT_SNIPER), "ig_7_m_door_f_sniping_franklin", INSTANT_BLEND_IN, INSTANT_BLEND_OUT, DEFAULT, AF_FORCE_START, 0.85, FALSE, AIK_DISABLE_ARM_IK)
|
|
FORCE_PED_AI_AND_ANIMATION_UPDATE(GET_FRANKLIN_PED())
|
|
ENDIF
|
|
|
|
eSwitchCamState = SWITCH_CAM_PLAYING_SPLINE
|
|
RETURN TRUE
|
|
BREAK
|
|
|
|
CASE SWITCH_CAM_PLAYING_SPLINE
|
|
CDEBUG3LN(DEBUG_MISSION, "eSwitchCamState = SWITCH_CAM_PLAYING_SPLINE")
|
|
CDEBUG3LN(DEBUG_MISSION, GET_CAM_SPLINE_PHASE(thisSwitchCam.ciSpline))
|
|
|
|
IF bSwitchToFirstPerson
|
|
PRINTSTRING("IS FIRST PERSON") PRINTNL()
|
|
ELSE
|
|
PRINTSTRING("IS THIRD PERSON") PRINTNL()
|
|
ENDIF
|
|
|
|
IF NOT bDoneHitSound
|
|
IF GET_GAME_TIMER() >= (iSnatchAndGrabCutsceneTime + 20)
|
|
PLAY_SOUND_FRONTEND(-1, "Hit_Out", "PLAYER_SWITCH_CUSTOM_SOUNDSET")
|
|
iHitTime = GET_GAME_TIMER()
|
|
bDoneHitSound = TRUE
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF NOT bWooshStarted
|
|
IF bDoneHitSound
|
|
IF GET_GAME_TIMER() >= iHitTime + 200
|
|
PLAY_SOUND_FRONTEND(-1, "Short_Transition_In", "PLAYER_SWITCH_CUSTOM_SOUNDSET")
|
|
bWooshStarted = TRUE
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF IS_CAM_ACTIVE(thisSwitchCam.ciSpline)
|
|
|
|
iCurrentNode = UPDATE_SPLINE_CAM(thisSwitchCam)
|
|
|
|
IF iCurrentNode >= (thisSwitchCam.iCamSwitchFocusNode -2)
|
|
sCamDetails.bOKToSwitchPed = TRUE
|
|
IF NOT bSwitchToFirstPerson
|
|
UPDATE_CLONE_NODE_GAMEPLAY_CAM_DATA(thisSwitchCam, iCurrentNode, TRUE)
|
|
ENDIF
|
|
ENDIF
|
|
|
|
//[MF] Have Michael already aiming at his target helicopter.
|
|
IF eCurrentBranchedSwitchState = BRANCHED_SWITCH_FRANKLIN_TO_MICHAEL_ACTIVE
|
|
OR bSwitchToFirstPerson
|
|
IF NOT IS_SCRIPT_TASK_RUNNING_OR_STARTING(GET_MICHAEL_PED(), SCRIPT_TASK_DRIVE_BY)
|
|
OR bSwitchToFirstPerson
|
|
IF NOT bSwitchToFirstPerson
|
|
CLEAR_PED_TASKS(GET_MICHAEL_PED())
|
|
ENDIF
|
|
|
|
vHeliLocDebug = GET_ENTITY_COORDS(snatchAndGrabVehicle[SAGV_PLAYER_CHOPPER])
|
|
vHeliForwardDebug = GET_ENTITY_FORWARD_VECTOR(snatchAndGrabVehicle[SAGV_PLAYER_CHOPPER])
|
|
|
|
vMichaelAimDirection = ROTATE_VECTOR_ABOUT_Z(vHeliForwardDebug, fSwitchToMike_AimingHeading)
|
|
vMichaelAimDirection.Z = 0.0
|
|
|
|
vMichaelAimDirection = GET_VECTOR_OF_LENGTH(vMichaelAimDirection, 150)
|
|
|
|
vMichaelAimOutSideHeliLoc = (vHeliLocDebug + vMichaelAimDirection)
|
|
|
|
PRINTLN("Telling Michael To At Nothing in paricular Loc: X:", vMichaelAimOutSideHeliLoc.x, " Y:", vMichaelAimOutSideHeliLoc.Y, " Z:", vMichaelAimOutSideHeliLoc.Z)
|
|
PRINTLN("Heli Loc Loc: X:", vHeliLocDebug.x, " Y:", vHeliLocDebug.Y, " Z:", vHeliLocDebug.Z)
|
|
PRINTLN("Heli Forward X:", vHeliForwardDebug.x, " Y:", vHeliForwardDebug.Y, " Z:", vHeliForwardDebug.Z)
|
|
|
|
TASK_DRIVE_BY(GET_MICHAEL_PED(), NULL, NULL, vMichaelAimOutSideHeliLoc, 10000, 0, FALSE, FIRING_PATTERN_SINGLE_SHOT)
|
|
|
|
printstring("give driveby!") printnl()
|
|
ENDIF
|
|
ENDIF
|
|
|
|
//[MF] Once cam is at the end, reset the gameplay cam positon and advance to next state.
|
|
IF GET_CAM_SPLINE_PHASE(thisSwitchCam.ciSpline) >= 1.00
|
|
CDEBUG3LN(DEBUG_MISSION, "eSwitchCamState = SWITCH_CAM_RETURN_TO_GAMEPLAY")
|
|
RENDER_SCRIPT_CAMS(FALSE, FALSE)
|
|
eSwitchCamState = SWITCH_CAM_RETURN_TO_GAMEPLAY
|
|
ENDIF
|
|
|
|
ELSE
|
|
SCRIPT_ASSERT("Cam Prematurely Deleted! WTF?")
|
|
RENDER_SCRIPT_CAMS(FALSE, FALSE)
|
|
eSwitchCamState = SWITCH_CAM_SETUP_SPLINE
|
|
ENDIF
|
|
|
|
IF IS_GAMEPLAY_HINT_ACTIVE()
|
|
STOP_GAMEPLAY_HINT(TRUE)
|
|
ENDIF
|
|
|
|
RETURN TRUE
|
|
BREAK
|
|
|
|
CASE SWITCH_CAM_RETURN_TO_GAMEPLAY
|
|
|
|
SET_TIME_SCALE(1.0)
|
|
|
|
RENDER_SCRIPT_CAMS(FALSE, FALSE)
|
|
|
|
IF DOES_CAM_EXIST(thisSwitchCam.ciSpline)
|
|
SET_CAM_ACTIVE(thisSwitchCam.ciSpline, FALSE)
|
|
ENDIF
|
|
|
|
IF DOES_SWITCH_CAM_EXIST(thisSwitchCam)
|
|
DESTROY_SWITCH_CAM(thisSwitchCam)
|
|
ENDIF
|
|
|
|
IF NOT bPlayerControlGiven
|
|
SET_PLAYER_CONTROL(PLAYER_ID(), TRUE)
|
|
DISPLAY_RADAR(TRUE)
|
|
DISPLAY_HUD(TRUE)
|
|
bPlayerControlGiven = TRUE
|
|
ENDIF
|
|
SET_BLOCKING_OF_NON_TEMPORARY_EVENTS(GET_MICHAEL_PED(), FALSE)
|
|
|
|
SETTIMERA(0)
|
|
|
|
eSwitchCamState = SWITCH_CAM_IDLE
|
|
|
|
thisSwitchCam.bIsSplineCamFinishedPlaying = TRUE
|
|
|
|
SET_PLAYER_CONTROL(PLAYER_ID(), true)
|
|
|
|
SET_PED_FIRING_PATTERN(GET_MICHAEL_PED(), FIRING_PATTERN_FULL_AUTO)
|
|
|
|
sCamDetails.bSplineCreated = FALSE
|
|
|
|
sCamDetails.bOKToSwitchPed = FALSE
|
|
|
|
SET_GAME_PAUSES_FOR_STREAMING(TRUE)
|
|
|
|
IF IS_VEHICLE_DRIVEABLE(enemyChopperVehicle[2])
|
|
TASK_AIM_GUN_AT_ENTITY(GET_FRANKLIN_PED(), enemyChopperVehicle[2], INFINITE_TASK_TIME, TRUE)
|
|
ELIF IS_VEHICLE_DRIVEABLE(enemyChopperVehicle[iLeadHeli])
|
|
TASK_AIM_GUN_AT_ENTITY(GET_FRANKLIN_PED(), enemyChopperVehicle[iLeadHeli], INFINITE_TASK_TIME, TRUE)
|
|
ELSE
|
|
TASK_AIM_GUN_AT_ENTITY(GET_FRANKLIN_PED(), snatchAndGrabVehicle[SAGV_PLAYER_CHOPPER], INFINITE_TASK_TIME, TRUE)
|
|
ENDIF
|
|
|
|
eCurrentBranchedSwitchState = BRANCHED_SWITCH_INACTIVE
|
|
|
|
RETURN FALSE
|
|
BREAK
|
|
|
|
ENDSWITCH
|
|
|
|
IF bReturnTrueOnce
|
|
RETURN FALSE
|
|
ELSE
|
|
RETURN thisSwitchCam.bIsSplineCamFinishedPlaying
|
|
ENDIF
|
|
ENDFUNC
|
|
|
|
#IF IS_DEBUG_BUILD
|
|
PROC HANDLE_SWITCH_CAM_SPECIFIC_WIDGETS()
|
|
|
|
IF bSwitchCamDebugScenarioEnabled
|
|
|
|
SET_ENTITY_INVINCIBLE(GET_MICHAEL_PED(), TRUE)
|
|
SET_ENTITY_INVINCIBLE(GET_FRANKLIN_PED(), TRUE)
|
|
SET_ENTITY_INVINCIBLE(GET_TREVOR_PED(), TRUE)
|
|
SET_ENTITY_INVINCIBLE(snatchAndGrabVehicle[SAGV_PLAYER_CHOPPER], TRUE)
|
|
|
|
ENDIF
|
|
|
|
ENDPROC
|
|
|
|
|
|
PROC CREATE_SWITCH_CAM_SPECIFIC_WIDGETS()
|
|
|
|
START_WIDGET_GROUP("Script Specific Widgets")
|
|
START_WIDGET_GROUP("Hanging To Sniper Sequence")
|
|
START_WIDGET_GROUP("Mike TO Frank")
|
|
ADD_WIDGET_FLOAT_SLIDER("Cam Ease Multiplier", fMikeHangingToSniperCamEaseMultiplier, 0.0, 1.0, 0.1)
|
|
ADD_WIDGET_INT_SLIDER("Cam Ease Index", iMikeHangingToSniperEaseNodeIndex, 0, 5, 1)
|
|
// ADD_WIDGET_FLOAT_SLIDER("Switch FX In Phase", fMikeHangingToSniper_SwitchInFX_Phase, 0.0, 1.0, 0.1)
|
|
// ADD_WIDGET_FLOAT_SLIDER("Switch FX Out Phase", fMikeHangingToSniper_SwitchOutFX_Phase, 0.0, 1.0, 0.1)
|
|
STOP_WIDGET_GROUP()
|
|
STOP_WIDGET_GROUP()
|
|
|
|
ADD_WIDGET_FLOAT_SLIDER("Franklin Aim Anim Start Phase", fHangingToFranklin_AimAnimStartPhase, 0.0, 1.0, 0.1)
|
|
ADD_WIDGET_FLOAT_SLIDER("Michael Aim Direction Override", fDEBUG_OverrideMichaelAim, -1.0, 180.0, 1.0)
|
|
ADD_WIDGET_FLOAT_SLIDER("Franklin Reload Anim Start Phase", fMikeToFranklin_ReloadAnimStartPhase, 0.0, 1.0, 0.1)
|
|
ADD_WIDGET_FLOAT_SLIDER("Franklin Reload Anim Blend In Delta", fHeliToFrank_ReloadBlendInDelta, 0.1, 1000.0, 100.0)
|
|
ADD_WIDGET_FLOAT_SLIDER("Michael Aim At Heading", fSwitchToMike_AimingHeading, 0.0, 180.0, 5.0)
|
|
ADD_WIDGET_INT_SLIDER("Heli To Frank = Focus Ped Index Offset", iHeliToFranklin_SwitchPedIndexOffset, -3, 3, 1)
|
|
ADD_WIDGET_FLOAT_SLIDER("M To F Start AI Task Phase", fMikeToFranklin_FranklinStartAITaskPhase, 0.0, 1.0, 0.1)
|
|
ADD_WIDGET_FLOAT_SLIDER("T To F Start AI Task Phase", fTrevToFranklin_FranklinStartAITaskPhase, 0.0, 1.0, 0.1)
|
|
ADD_WIDGET_FLOAT_SLIDER("Trevor Switch Gameplay Cam Hint Dist", fHangOnTrevor_HintCamFollowDist, 0.2, 3.0, 0.2)
|
|
ADD_WIDGET_VECTOR_SLIDER("Trevor Switch Gameplay Cam Hint Target", vHangOnTrevor_HintCamLookAtLoc, -500.0, 500.0, 50.0)
|
|
STOP_WIDGET_GROUP()
|
|
|
|
ENDPROC
|
|
|
|
|
|
#ENDIF
|
|
|
|
////FUNC VECTOR CONVERT_EULER_TO_DIRECTION_VECTOR(VECTOR vEuler)
|
|
//// // Euler angles assumed to be in YXZ order
|
|
//// VECTOR vResult
|
|
//// //b.Set(-cx*sz, cx*cz, sx);
|
|
//// vResult.x = Cos(vEuler.x)
|
|
//// vResult.y = Cos(vEuler.z)
|
|
//// vResult.z = Sin(vEuler.x)
|
|
//// vResult.y *= vResult.x
|
|
//// vResult.x *= -Sin(vEuler.z)
|
|
////
|
|
//// RETURN vResult
|
|
////ENDFUNC
|
|
CONST_FLOAT c_fSwapChopperDistance 10.0
|
|
CONST_FLOAT c_fSwapSniperDistance 20.0
|
|
FUNC BOOL DO_MISSION_HOTSWAP(SELECTOR_SLOTS_ENUM targetCharacter, BOOL bInstantSwap = FALSE, BOOL bKeepTasks = FALSE, HOTSWAP_CAM_ENUM hotswapCam = HOTSWAP_CAM_DEFAULT, TAKE_CONTROL_OF_PED_FLAGS tcfFlags = TCF_NONE)
|
|
|
|
VECTOR vSniperPos = vSniperNodePos3//<<-136.387,-592.535,211.892>> //<<-136.630, -592.565, 211.899>> //<<-136.643, -592.850, 211.776>>
|
|
VECTOR vSniperRot = vSniperNodeRot3// <<-1.573389,0.000000,-96.932442>> //<<-1.997, 0.0, -96.944>> //<<-3.97, 0.0, -91.14>>
|
|
////VECTOR vHalfSniperPos = << -21.744, -605.191, 209.722 >> // halfway to sniper position
|
|
VECTOR vHangingPos = <<101.513916,-615.483154,206.740265>>
|
|
VECTOR vHangingRot = <<0.340730,0.0,-103.845039>>
|
|
|
|
// VECTOR vSource
|
|
// VECTOR vDestination
|
|
// VECTOR vChopperDirection
|
|
// VECTOR vSniperDirection
|
|
// FLOAT fMagnitude
|
|
// FLOAT fScale = 0.33
|
|
// BOOL bFlipAxis = FALSE
|
|
|
|
SWITCH hotswapStage
|
|
CASE MISSION_HOTSWAP_STAGE_SELECT_CHARACTER
|
|
REMOVE_MISSION_TEXT(FALSE)
|
|
sSelectorPeds.bInitialised = TRUE
|
|
sSelectorPeds.eNewSelectorPed = targetCharacter
|
|
sCamDetails.pedTo = sSelectorPeds.pedID[targetCharacter]
|
|
sCamDetails.bPedSwitched = FALSE
|
|
bStartPushIn = FALSE
|
|
bDoneHitSound = FALSE
|
|
bWooshStarted = FALSE
|
|
pushInData.state = PUSH_IN_NOT_CREATED
|
|
hotswapStage = MISSION_HOTSWAP_STAGE_DO_SPLINE_CAM
|
|
FALLTHRU
|
|
|
|
CASE MISSION_HOTSWAP_STAGE_DO_SPLINE_CAM
|
|
SWITCH hotswapCam
|
|
CASE HOTSWAP_CAM_SNIPER_TO_HANGING
|
|
IF NOT sCamDetails.bSplineCreated
|
|
DO_COMMON_CUSTOM_HOTSWAP_START()
|
|
|
|
/*
|
|
sCamDetails.camInterpIDs[1] = CREATE_CAMERA_WITH_PARAMS(CAMTYPE_SCRIPTED, vSniperPos, vSniperRot, 35.0, TRUE)
|
|
ADD_CAM_SPLINE_NODE_USING_CAMERA(sCamDetails.camID, sCamDetails.camInterpIDs[1], 125, CAM_SPLINE_NODE_SMOOTH_ROT | CAM_SPLINE_NODE_SMOOTH_LENS_PARAMS)
|
|
SET_CAM_MOTION_BLUR_STRENGTH(sCamDetails.camInterpIDs[1], 0.6)
|
|
SET_CAM_SPLINE_NODE_EASE(sCamDetails.camID, iFranklinToHangingEaseNodeIndex, CAM_SPLINE_NODE_EASE_OUT, fFranklinToHangingCamEaseMultiplier)
|
|
|
|
splineOffset = LERP_VECTOR(vSniperPos, vHangingPos, 0.95)
|
|
sCamDetails.camInterpIDs[3] = CREATE_CAMERA_WITH_PARAMS(CAMTYPE_SCRIPTED, splineOffset, vHangingRot, 35.0, TRUE)
|
|
ADD_CAM_SPLINE_NODE_USING_CAMERA(sCamDetails.camID, sCamDetails.camInterpIDs[3], 600, CAM_SPLINE_NODE_SMOOTH_ROT | CAM_SPLINE_NODE_SMOOTH_LENS_PARAMS)
|
|
SET_CAM_MOTION_BLUR_STRENGTH(sCamDetails.camInterpIDs[3], 0.7)
|
|
|
|
sCamDetails.camInterpIDs[2] = CREATE_CAMERA_WITH_PARAMS(CAMTYPE_SCRIPTED, vHangingPos, vHangingRot, 35.0, TRUE)
|
|
ADD_CAM_SPLINE_NODE_USING_CAMERA(sCamDetails.camID, sCamDetails.camInterpIDs[2], 100, CAM_SPLINE_NODE_SMOOTH_ROT | CAM_SPLINE_NODE_SMOOTH_LENS_PARAMS)
|
|
SET_CAM_MOTION_BLUR_STRENGTH(sCamDetails.camInterpIDs[2], 0.3)
|
|
//ADD_CAM_SPLINE_NODE_USING_GAMEPLAY_FRAME(sCamDetails.camID, 425, CAM_SPLINE_NODE_SMOOTH_ROT | CAM_SPLINE_NODE_SMOOTH_LENS_PARAMS)
|
|
|
|
SET_CAM_SPLINE_SMOOTHING_STYLE(sCamDetails.camID, CAM_SPLINE_SLOW_IN_SMOOTH)
|
|
// SET_CAM_SPLINE_DURATION(sCamDetails.camID, 600)
|
|
*/
|
|
|
|
VECTOR vEaseFromMichael
|
|
|
|
sCamDetails.camInterpIDs[0] = CREATE_CAMERA_WITH_PARAMS(CAMTYPE_SCRIPTED, vSniperPos, vSniperRot, 35.0, TRUE)
|
|
ADD_CAM_SPLINE_NODE_USING_CAMERA(sCamDetails.camID, sCamDetails.camInterpIDs[0], 0, CAM_SPLINE_NODE_SMOOTH_ROT | CAM_SPLINE_NODE_SMOOTH_LENS_PARAMS)
|
|
SET_CAM_MOTION_BLUR_STRENGTH(sCamDetails.camInterpIDs[0], 0.2)
|
|
|
|
vEaseFromMichael = LERP_VECTOR(vSniperPos, vHangingPos, 0.008)
|
|
sCamDetails.camInterpIDs[1] = CREATE_CAMERA_WITH_PARAMS(CAMTYPE_SCRIPTED, vEaseFromMichael, vSniperRot, 35, TRUE)
|
|
ADD_CAM_SPLINE_NODE_USING_CAMERA(sCamDetails.camID, sCamDetails.camInterpIDs[1], 400, CAM_SPLINE_NODE_SMOOTH_LENS_PARAMS)
|
|
SET_CAM_MOTION_BLUR_STRENGTH(sCamDetails.camInterpIDs[1], 0.4)
|
|
|
|
sCamDetails.camInterpIDs[2] = CREATE_CAMERA_WITH_PARAMS(CAMTYPE_SCRIPTED, vHangingPos, vHangingRot, 35.0, TRUE)
|
|
ADD_CAM_SPLINE_NODE_USING_CAMERA(sCamDetails.camID, sCamDetails.camInterpIDs[2], 1000, CAM_SPLINE_NODE_SMOOTH_LENS_PARAMS)
|
|
SET_CAM_MOTION_BLUR_STRENGTH(sCamDetails.camInterpIDs[2], 0.8)
|
|
|
|
SET_CAM_SPLINE_SMOOTHING_STYLE(sCamDetails.camID, CAM_SPLINE_SLOW_IN_SMOOTH)
|
|
SET_CAM_SPLINE_DURATION(sCamDetails.camID, 1000)
|
|
|
|
bDoneHitSound = FALSE
|
|
bWooshStarted = FALSE
|
|
|
|
DO_COMMON_CUSTOM_HOTSWAP_END()
|
|
DESTROY_MISSION_STATIC_CAM(staticCam)
|
|
ENDIF
|
|
BREAK
|
|
|
|
CASE HOTSWAP_CAM_HANGING_TO_SNIPER
|
|
IF NOT sCamDetails.bSplineCreated
|
|
AND NOT bStartPushIn
|
|
DO_COMMON_CUSTOM_HOTSWAP_START(CAMTYPE_SPLINE_DEFAULT)
|
|
|
|
FILL_PUSH_IN_DATA(pushInData, dummyFranklinPed, CHAR_FRANKLIN, 0.2, 500, 500, 200, 300)
|
|
SET_PUSH_IN_DIRECTION_MODIFIER(pushInData, <<0,0,5>>)
|
|
|
|
VECTOR vFinalRot
|
|
vFinalRot = GET_FINAL_RENDERED_CAM_ROT()
|
|
VECTOR vEaseFromMichael
|
|
VECTOR vDiffRot
|
|
|
|
IF vFinalRot.z > 0
|
|
vFinalRot.z -= 360
|
|
ENDIF
|
|
|
|
sCamDetails.camInterpIDs[0] = CREATE_CAMERA_WITH_PARAMS(CAMTYPE_SCRIPTED, GET_FINAL_RENDERED_CAM_COORD(), vFinalRot, GET_FINAL_RENDERED_CAM_FOV(), TRUE)
|
|
ADD_CAM_SPLINE_NODE_USING_CAMERA(sCamDetails.camID, sCamDetails.camInterpIDs[0], 0, CAM_SPLINE_NODE_SMOOTH_LENS_PARAMS)
|
|
SET_CAM_MOTION_BLUR_STRENGTH(sCamDetails.camInterpIDs[0], 0.5)
|
|
////ADD_CAM_SPLINE_NODE(sCamDetails.camID, GET_FINAL_RENDERED_CAM_COORD(), GET_FINAL_RENDERED_CAM_ROT(), 0, CAM_SPLINE_NODE_SMOOTH_ROT|CAM_SPLINE_NODE_SMOOTH_LENS_PARAMS)
|
|
|
|
vDiffRot = LERP_VECTOR(vFinalRot, vSniperNodeRot3, 0.6)
|
|
vDiffRot.y = vSniperNodeRot3.y
|
|
|
|
vEaseFromMichael = LERP_VECTOR(GET_FINAL_RENDERED_CAM_COORD(), vSniperNodePos3, 0.1)
|
|
sCamDetails.camInterpIDs[1] = CREATE_CAMERA_WITH_PARAMS(CAMTYPE_SCRIPTED, vEaseFromMichael, vDiffRot, GET_FINAL_RENDERED_CAM_FOV(), TRUE)
|
|
ADD_CAM_SPLINE_NODE_USING_CAMERA(sCamDetails.camID, sCamDetails.camInterpIDs[1], 600, CAM_SPLINE_NODE_SMOOTH_LENS_PARAMS)
|
|
SET_CAM_MOTION_BLUR_STRENGTH(sCamDetails.camInterpIDs[1], 0.8)
|
|
|
|
sCamDetails.camInterpIDs[3] = CREATE_CAMERA_WITH_PARAMS(CAMTYPE_SCRIPTED, vSniperNodePos3, vSniperNodeRot3, 35, TRUE)
|
|
ADD_CAM_SPLINE_NODE_USING_CAMERA(sCamDetails.camID, sCamDetails.camInterpIDs[3], 900, CAM_SPLINE_NODE_SMOOTH_LENS_PARAMS)
|
|
SET_CAM_MOTION_BLUR_STRENGTH(sCamDetails.camInterpIDs[3], 1.0)
|
|
|
|
SET_CAM_SPLINE_SMOOTHING_STYLE(sCamDetails.camID, CAM_SPLINE_SLOW_IN_SMOOTH)
|
|
SET_CAM_SPLINE_DURATION(sCamDetails.camID, 1000)
|
|
|
|
bDoneHitSound = FALSE
|
|
bWooshStarted = FALSE
|
|
|
|
DO_COMMON_CUSTOM_HOTSWAP_END()
|
|
ENDIF
|
|
BREAK
|
|
|
|
//[MF] Trevor to Michael
|
|
CASE HOTSWAP_CAM_INSIDE_CHOPPER
|
|
PRINTLN("HOTSWAP_CAM_INSIDE_CHOPPER")
|
|
IF NOT sCamDetails.bSplineCreated
|
|
DO_COMMON_CUSTOM_HOTSWAP_START()
|
|
|
|
eSwitchCamState = SWITCH_CAM_SETUP_SPLINE
|
|
|
|
IF IS_ALLOWED_INDEPENDENT_CAMERA_MODES()
|
|
IF GET_CAM_VIEW_MODE_FOR_CONTEXT(CAM_VIEW_MODE_CONTEXT_IN_VEHICLE) = CAM_VIEW_MODE_FIRST_PERSON
|
|
OR GET_CAM_VIEW_MODE_FOR_CONTEXT(CAM_VIEW_MODE_CONTEXT_IN_HELI) = CAM_VIEW_MODE_FIRST_PERSON
|
|
bSwitchToFirstPerson = TRUE
|
|
ELSE
|
|
bSwitchToFirstPerson = FALSE
|
|
ENDIF
|
|
ELSE
|
|
IF GET_CAM_VIEW_MODE_FOR_CONTEXT(GET_CAM_ACTIVE_VIEW_MODE_CONTEXT()) = CAM_VIEW_MODE_FIRST_PERSON
|
|
bSwitchToFirstPerson = TRUE
|
|
ELSE
|
|
bSwitchToFirstPerson = FALSE
|
|
ENDIF
|
|
ENDIF
|
|
|
|
DO_COMMON_CUSTOM_HOTSWAP_END()
|
|
//SET_TIME_SCALE(0.1)
|
|
ENDIF
|
|
BREAK
|
|
|
|
CASE HOTSWAP_CAM_OUTSIDE_CHOPPER
|
|
PRINTLN("HOTSWAP_CAM_OUTSIDE_CHOPPER")
|
|
IF NOT sCamDetails.bSplineCreated
|
|
DO_COMMON_CUSTOM_HOTSWAP_START()
|
|
|
|
eSwitchCamState = SWITCH_CAM_SETUP_SPLINE
|
|
|
|
IF IS_ALLOWED_INDEPENDENT_CAMERA_MODES()
|
|
IF GET_CAM_VIEW_MODE_FOR_CONTEXT(CAM_VIEW_MODE_CONTEXT_IN_VEHICLE) = CAM_VIEW_MODE_FIRST_PERSON
|
|
OR GET_CAM_VIEW_MODE_FOR_CONTEXT(CAM_VIEW_MODE_CONTEXT_IN_HELI) = CAM_VIEW_MODE_FIRST_PERSON
|
|
bSwitchToFirstPerson = TRUE
|
|
ELSE
|
|
bSwitchToFirstPerson = FALSE
|
|
ENDIF
|
|
ELSE
|
|
IF GET_CAM_VIEW_MODE_FOR_CONTEXT(GET_CAM_ACTIVE_VIEW_MODE_CONTEXT()) = CAM_VIEW_MODE_FIRST_PERSON
|
|
bSwitchToFirstPerson = TRUE
|
|
ELSE
|
|
bSwitchToFirstPerson = FALSE
|
|
ENDIF
|
|
ENDIF
|
|
|
|
DO_COMMON_CUSTOM_HOTSWAP_END()
|
|
ENDIF
|
|
BREAK
|
|
|
|
CASE HOTSWAP_CAM_CHOPPER_TO_FRANKLIN
|
|
PRINTLN("HOTSWAP_CAM_CHOPPER_TO_FRANKLIN")
|
|
IF NOT sCamDetails.bSplineCreated
|
|
DO_COMMON_CUSTOM_HOTSWAP_START(CAMTYPE_SPLINE_TIMED)
|
|
|
|
IF IS_ALLOWED_INDEPENDENT_CAMERA_MODES()
|
|
IF PLAYER_PED_ID() = GET_MICHAEL_PED()
|
|
IF GET_CAM_VIEW_MODE_FOR_CONTEXT(CAM_VIEW_MODE_CONTEXT_IN_VEHICLE) = CAM_VIEW_MODE_FIRST_PERSON
|
|
bSwitchToFirstPerson = TRUE
|
|
ELSE
|
|
bSwitchToFirstPerson = FALSE
|
|
ENDIF
|
|
ELSE
|
|
IF GET_CAM_VIEW_MODE_FOR_CONTEXT(CAM_VIEW_MODE_CONTEXT_IN_HELI) = CAM_VIEW_MODE_FIRST_PERSON
|
|
bSwitchToFirstPerson = TRUE
|
|
ELSE
|
|
bSwitchToFirstPerson = FALSE
|
|
ENDIF
|
|
ENDIF
|
|
ELSE
|
|
IF GET_CAM_VIEW_MODE_FOR_CONTEXT(GET_CAM_ACTIVE_VIEW_MODE_CONTEXT()) = CAM_VIEW_MODE_FIRST_PERSON
|
|
bSwitchToFirstPerson = TRUE
|
|
ELSE
|
|
bSwitchToFirstPerson = FALSE
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF PLAYER_PED_ID() = GET_MICHAEL_PED()
|
|
IF NOT bSwitchToFirstPerson
|
|
SETUP_SPLINE_CAM_NODE_ARRAY_HELI_MICHAEL_TO_FRANKLIN(scsSwitch_Heli_Michael_ToFranklin, GET_MICHAEL_PED(), GET_FRANKLIN_PED())
|
|
ELSE
|
|
SETUP_SPLINE_CAM_NODE_ARRAY_HELI_MICHAEL_TO_FRANKLIN_FIRST_PERSON(scsSwitch_Heli_Michael_ToFranklin, GET_MICHAEL_PED(), GET_FRANKLIN_PED())
|
|
ENDIF
|
|
eCurrentBranchedSwitchState = BRANCHED_SWITCH_MICHAEL_TO_FRANKLIN_ACTIVE
|
|
ELSE
|
|
IF NOT bSwitchToFirstPerson
|
|
SETUP_SPLINE_CAM_NODE_ARRAY_HELI_TREVOR_TO_FRANKLIN(scsSwitch_Heli_Trevor_ToFranklin, snatchAndGrabVehicle[SAGV_PLAYER_CHOPPER], GET_FRANKLIN_PED())
|
|
ELSE
|
|
SETUP_SPLINE_CAM_NODE_ARRAY_HELI_TREVOR_TO_FRANKLIN_FIRST_PERSON(scsSwitch_Heli_Trevor_ToFranklin, GET_TREVOR_PED(), GET_FRANKLIN_PED())
|
|
ENDIF
|
|
eCurrentBranchedSwitchState = BRANCHED_SWITCH_TREVOR_TO_FRANKLIN_ACTIVE
|
|
ENDIF
|
|
eSwitchCamState = SWITCH_CAM_SETUP_SPLINE
|
|
DO_COMMON_CUSTOM_HOTSWAP_END()
|
|
ENDIF
|
|
BREAK
|
|
|
|
CASE HOTSWAP_CAM_FRANKLIN_TO_CHOPPER
|
|
PRINTLN("HOTSWAP_CAM_FRANKLIN_TO_CHOPPER")
|
|
IF NOT sCamDetails.bSplineCreated
|
|
DO_COMMON_CUSTOM_HOTSWAP_START(CAMTYPE_SPLINE_TIMED)
|
|
|
|
IF IS_ALLOWED_INDEPENDENT_CAMERA_MODES()
|
|
IF targetCharacter = SELECTOR_PED_MICHAEL
|
|
IF GET_CAM_VIEW_MODE_FOR_CONTEXT(CAM_VIEW_MODE_CONTEXT_IN_VEHICLE) = CAM_VIEW_MODE_FIRST_PERSON
|
|
bSwitchToFirstPerson = TRUE
|
|
ELSE
|
|
bSwitchToFirstPerson = FALSE
|
|
ENDIF
|
|
ELSE
|
|
IF GET_CAM_VIEW_MODE_FOR_CONTEXT(CAM_VIEW_MODE_CONTEXT_IN_HELI) = CAM_VIEW_MODE_FIRST_PERSON
|
|
bSwitchToFirstPerson = TRUE
|
|
ELSE
|
|
bSwitchToFirstPerson = FALSE
|
|
ENDIF
|
|
ENDIF
|
|
ELSE
|
|
IF GET_CAM_VIEW_MODE_FOR_CONTEXT(GET_CAM_ACTIVE_VIEW_MODE_CONTEXT()) = CAM_VIEW_MODE_FIRST_PERSON
|
|
bSwitchToFirstPerson = TRUE
|
|
ELSE
|
|
bSwitchToFirstPerson = FALSE
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF NOT sCamDetails.bSplineCreated
|
|
IF targetCharacter = SELECTOR_PED_MICHAEL
|
|
IF NOT bSwitchToFirstPerson
|
|
SETUP_SPLINE_CAM_NODE_ARRAY_FRANKLIN_TO_MICHAEL(scsSwitch_FranklinToHeli_Mike, GET_FRANKLIN_PED(), GET_MICHAEL_PED())
|
|
ELSE
|
|
SETUP_SPLINE_CAM_NODE_ARRAY_FRANKLIN_TO_MICHAEL_FIRST_PERSON(scsSwitch_FranklinToHeli_Mike, GET_FRANKLIN_PED(), GET_MICHAEL_PED())
|
|
ENDIF
|
|
eCurrentBranchedSwitchState = BRANCHED_SWITCH_FRANKLIN_TO_MICHAEL_ACTIVE
|
|
ELSE
|
|
IF NOT bSwitchToFirstPerson
|
|
SETUP_SPLINE_CAM_NODE_ARRAY_FRANKLIN_TO_TREVOR(scsSwitch_FranklinToHeli_Trev, GET_FRANKLIN_PED(), snatchAndGrabVehicle[SAGV_PLAYER_CHOPPER])
|
|
ELSE
|
|
SETUP_SPLINE_CAM_NODE_ARRAY_FRANKLIN_TO_TREVOR_FIRST_PERSON(scsSwitch_FranklinToHeli_Trev, GET_FRANKLIN_PED(), GET_TREVOR_PED())
|
|
ENDIF
|
|
eCurrentBranchedSwitchState = BRANCHED_SWITCH_FRANKLIN_TO_TREVOR_ACTIVE
|
|
ENDIF
|
|
|
|
eSwitchCamState = SWITCH_CAM_SETUP_SPLINE
|
|
|
|
DO_COMMON_CUSTOM_HOTSWAP_END()
|
|
DESTROY_MISSION_STATIC_CAM(staticCam)
|
|
ENDIF
|
|
ENDIF
|
|
BREAK
|
|
ENDSWITCH
|
|
|
|
IF NOT bInstantSwap
|
|
BOOL bDoingSwap
|
|
SWITCH hotswapCam
|
|
CASE HOTSWAP_CAM_DEFAULT
|
|
bDoingSwap = RUN_CAM_SPLINE_FROM_PLAYER_TO_PED(sCamDetails)
|
|
BREAK
|
|
CASE HOTSWAP_CAM_INSIDE_CHOPPER
|
|
bDoingSwap = HANDLE_SWITCH_CAM_HELI_TREVOR_TO_MICHAEL(scsSwitch_Heli_TrevorToMichael, TRUE)
|
|
BREAK
|
|
CASE HOTSWAP_CAM_FRANKLIN_TO_CHOPPER
|
|
IF eCurrentBranchedSwitchState = BRANCHED_SWITCH_FRANKLIN_TO_MICHAEL_ACTIVE
|
|
bDoingSwap = HANDLE_SWITCH_CAM_FRANKLIN_TO_HELI(scsSwitch_FranklinToHeli_Mike, TRUE)
|
|
ELSE
|
|
bDoingSwap = HANDLE_SWITCH_CAM_FRANKLIN_TO_HELI(scsSwitch_FranklinToHeli_Trev, TRUE)
|
|
ENDIF
|
|
BREAK
|
|
CASE HOTSWAP_CAM_SNIPER_TO_HANGING
|
|
bDoingSwap = RUN_CAM_SPLINE_FROM_PLAYER_TO_PED(sCamDetails, 1000.0, 1000.0, SELECTOR_CAM_STRAIGHT_INTERP, 0)
|
|
BREAK
|
|
CASE HOTSWAP_CAM_CHOPPER_TO_FRANKLIN
|
|
IF eCurrentBranchedSwitchState = BRANCHED_SWITCH_MICHAEL_TO_FRANKLIN_ACTIVE
|
|
bDoingSwap = HANDLE_SWITCH_CAM_HELI_TO_FRANKLIN(scsSwitch_Heli_Michael_ToFranklin, TRUE)
|
|
ELSE
|
|
bDoingSwap = HANDLE_SWITCH_CAM_HELI_TO_FRANKLIN(scsSwitch_Heli_Trevor_ToFranklin, TRUE)
|
|
ENDIF
|
|
BREAK
|
|
CASE HOTSWAP_CAM_OUTSIDE_CHOPPER
|
|
bDoingSwap = HANDLE_SWITCH_CAM_HELI_MICHAEL_TO_TREVOR(scsSwitch_Heli_MichaelToTrevor, TRUE)
|
|
BREAK
|
|
CASE HOTSWAP_CAM_HANGING_TO_SNIPER
|
|
bDoingSwap = TRUE
|
|
IF NOT bStartPushIn
|
|
IF NOT RUN_CAM_SPLINE_FROM_PLAYER_TO_CAM(sCamDetails)
|
|
bStartPushIn = TRUE
|
|
ENDIF
|
|
ELSE
|
|
IF HANDLE_PUSH_IN(pushInData, TRUE, FALSE)
|
|
bDoingSwap = FALSE
|
|
ENDIF
|
|
ENDIF
|
|
BREAK
|
|
ENDSWITCH
|
|
|
|
// Disable camera input during transition.
|
|
DISABLE_CONTROL_ACTION(PLAYER_CONTROL, INPUT_LOOK_UD)
|
|
DISABLE_CONTROL_ACTION(PLAYER_CONTROL, INPUT_LOOK_LR)
|
|
|
|
IF bDoingSwap
|
|
IF sCamDetails.bOKToSwitchPed
|
|
IF NOT sCamDetails.bPedSwitched
|
|
IF TAKE_CONTROL_OF_SELECTOR_PED(sSelectorPeds, TRUE, bKeepTasks, tcfFlags)
|
|
REAPPLY_PLAYER_PED_ATTRIBUTES(FALSE)
|
|
sCamDetails.bPedSwitched = TRUE
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ELSE
|
|
|
|
CLEANUP_HOTSWAP_CAMERAS()
|
|
|
|
IF DOES_CAM_EXIST(sCamDetails.camID)
|
|
DESTROY_CAM(sCamDetails.camID)
|
|
ENDIF
|
|
|
|
DESTROY_PUSH_IN_CAMS(pushInData)
|
|
|
|
IF hotswapCam = HOTSWAP_CAM_HANGING_TO_SNIPER
|
|
SET_FIRST_PERSON_AIM_CAM_ZOOM_FACTOR(INIT_SNIPER_ZOOM)
|
|
ENDIF
|
|
|
|
REAPPLY_PLAYER_PED_ATTRIBUTES()
|
|
|
|
hotswapStage = MISSION_HOTSWAP_STAGE_DONE
|
|
#IF IS_DEBUG_BUILD
|
|
bDebugJSkip = FALSE
|
|
#ENDIF
|
|
RETURN TRUE
|
|
ENDIF
|
|
ELSE
|
|
IF TAKE_CONTROL_OF_SELECTOR_PED(sSelectorPeds, TRUE, bKeepTasks, tcfFlags)
|
|
sCamDetails.bPedSwitched = TRUE
|
|
REAPPLY_PLAYER_PED_ATTRIBUTES()
|
|
hotswapStage = MISSION_HOTSWAP_STAGE_DONE
|
|
#IF IS_DEBUG_BUILD
|
|
bDebugJSkip = FALSE
|
|
#ENDIF
|
|
RETURN TRUE
|
|
ENDIF
|
|
ENDIF
|
|
BREAK
|
|
ENDSWITCH
|
|
|
|
RETURN FALSE
|
|
ENDFUNC
|
|
|
|
// ensure chopper is hovering
|
|
PROC MAINTAIN_CHOPPER_HOVER()
|
|
IF IS_VEHICLE_DRIVEABLE(snatchAndGrabVehicle[SAGV_PLAYER_CHOPPER])
|
|
IF IS_PLAYBACK_GOING_ON_FOR_VEHICLE(snatchAndGrabVehicle[SAGV_PLAYER_CHOPPER])
|
|
IF NOT bPlayingHoverBackwards
|
|
INT iReverseTime
|
|
SWITCH currentMissionStage
|
|
CASE STAGE_CHOPPER_CHASE
|
|
iReverseTime = 47000
|
|
BREAK
|
|
DEFAULT
|
|
iReverseTime = 8900
|
|
BREAK
|
|
ENDSWITCH
|
|
|
|
IF GET_TIME_POSITION_IN_RECORDING(snatchAndGrabVehicle[SAGV_PLAYER_CHOPPER]) >= iReverseTime
|
|
fHoverPlaybackSpeed = -CHOPPER_HOVER_SPEED
|
|
bPlayingHoverBackwards = TRUE
|
|
ENDIF
|
|
ELSE
|
|
INT iForwardTime
|
|
SWITCH currentMissionStage
|
|
CASE STAGE_CHOPPER_CHASE
|
|
iForwardTime = 43000
|
|
BREAK
|
|
DEFAULT
|
|
iForwardTime = 1990
|
|
BREAK
|
|
ENDSWITCH
|
|
IF GET_TIME_POSITION_IN_RECORDING(snatchAndGrabVehicle[SAGV_PLAYER_CHOPPER]) <= iForwardTime
|
|
fHoverPlaybackSpeed = CHOPPER_HOVER_SPEED
|
|
bPlayingHoverBackwards = FALSE
|
|
ENDIF
|
|
ENDIF
|
|
|
|
SET_PLAYBACK_SPEED(snatchAndGrabVehicle[SAGV_PLAYER_CHOPPER], fHoverPlaybackSpeed)
|
|
ENDIF
|
|
ENDIF
|
|
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, "FBI2_B1AV1")
|
|
OR ARE_STRINGS_EQUAL(tBanter, "FBI2_B1BV1")
|
|
OR ARE_STRINGS_EQUAL(tBanter, "FBI2_B2AV1")
|
|
OR ARE_STRINGS_EQUAL(tBanter, "FBI2_B2AV2")
|
|
OR ARE_STRINGS_EQUAL(tBanter, "FBI2_B2BV2")
|
|
OR ARE_STRINGS_EQUAL(tBanter, "FBI2_MKTALK")
|
|
OR ARE_STRINGS_EQUAL(tBanter, "FBI2_MKTALK2")
|
|
OR ARE_STRINGS_EQUAL(tBanter, "FBI2_TOCAR")
|
|
OR ARE_STRINGS_EQUAL(tBanter, "FBI2_TOCAR2")
|
|
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(snatchAndGrabConversation, "FBI2AUD", tSavedBanterRoot, tResumeBanterLabel, CONV_PRIORITY_HIGH)
|
|
RETURN TRUE
|
|
ENDIF
|
|
ENDIF
|
|
ELSE
|
|
RETURN TRUE
|
|
ENDIF
|
|
|
|
RETURN FALSE
|
|
ENDFUNC
|
|
|
|
// handle text for in car
|
|
PROC HANDLE_GET_TO_LOCATION(BOOL bWithVehicle, BOOL bWithBuddy, BOOL bEnforceWantedLevel = FALSE, BOOL bRemoveOtherBlips = TRUE)
|
|
PED_INDEX buddyPed
|
|
VEHICLE_INDEX vehicle
|
|
|
|
IF currentMissionStage = STAGE_GET_TO_CHOPPER
|
|
buddyPed = davePed
|
|
vehicle = snatchAndGrabVehicle[SAGV_MICHAEL_CAR]
|
|
ELSE
|
|
buddyPed = sSelectorPeds.pedID[SELECTOR_PED_MICHAEL]
|
|
vehicle = snatchAndGrabVehicle[SAGV_PLAYER_CHOPPER]
|
|
ENDIF
|
|
|
|
BOOL bPlayerVehicleOK = TRUE
|
|
BOOL bBuddyVehicleOK = TRUE
|
|
BOOL bBuddyGroupOK = TRUE
|
|
BOOL bWantedLevelOK = TRUE
|
|
BOOL bAllOK = FALSE
|
|
|
|
IF bWithBuddy
|
|
IF NOT IS_PED_INJURED(buddyPed)
|
|
//IF NOT IS_PED_GROUP_MEMBER(buddyPed, PLAYER_GROUP_ID())
|
|
IF daveIntoCarState = DAVE_INTO_CAR_STATE_PAUSED
|
|
bBuddyGroupOK = FALSE
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF bWithVehicle
|
|
IF IS_VEHICLE_DRIVEABLE(vehicle)
|
|
IF bWithBuddy
|
|
IF NOT IS_PED_INJURED(buddyPed)
|
|
IF NOT IS_PED_IN_VEHICLE(buddyPed, vehicle)
|
|
bBuddyVehicleOK = FALSE
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
IF NOT IS_PED_IN_VEHICLE(PLAYER_PED_ID(), vehicle)
|
|
bPlayerVehicleOK = FALSE
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF bEnforceWantedLevel
|
|
IF GET_PLAYER_WANTED_LEVEL(PLAYER_ID()) > 0
|
|
bWantedLevelOK = FALSE
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF bBuddyGroupOK
|
|
// buddy is group member / not required to be in group
|
|
IF bPlayerVehicleOK
|
|
// player is in vehicle
|
|
IF bWithVehicle
|
|
IF iGetInTextStage < 2
|
|
iGetInTextStage = 2
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF bBuddyVehicleOK
|
|
// stuff for first fly chopper stage
|
|
IF currentMissionStage = STAGE_GET_TO_BUILDING
|
|
// chopper help
|
|
IF iHelpStage < 3
|
|
IF NOT IS_HELP_MESSAGE_BEING_DISPLAYED()
|
|
IF GET_GAME_TIMER() >= iChopperHelpTime
|
|
AND bDoneGotoSpeech
|
|
SWITCH iHelpStage
|
|
CASE 0
|
|
if not g_bMagDemoActive
|
|
DO_MISSION_HELP_TEXT("SG_FLYHLP1")
|
|
endif
|
|
BREAK
|
|
CASE 1
|
|
if not g_bMagDemoActive
|
|
DO_MISSION_HELP_TEXT("SG_FLYHLP2")
|
|
endif
|
|
BREAK
|
|
CASE 2
|
|
if not g_bMagDemoActive
|
|
DO_MISSION_HELP_TEXT("SG_FLYHLP3")
|
|
endif
|
|
BREAK
|
|
ENDSWITCH
|
|
iHelpStage++
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
|
|
// remove altitude help when airborne
|
|
IF NOT bRemovedAltitudeHelp
|
|
IF iHelpStage >= 2
|
|
bRemovedAltitudeHelp = TRUE
|
|
ELSE
|
|
FLOAT fGroundHeight
|
|
FLOAT fHeightAboveGround
|
|
VECTOR vPlayerPos = GET_ENTITY_COORDS(PLAYER_PED_ID())
|
|
GET_GROUND_Z_FOR_3D_COORD(vPlayerPos, fGroundHeight)
|
|
IF fGroundHeight < 0
|
|
fGroundHeight = 0
|
|
ENDIF
|
|
fHeightAboveGround = vPlayerPos.z - fGroundHeight
|
|
|
|
IF fHeightAboveGround >= 15.0
|
|
IF IS_THIS_HELP_MESSAGE_BEING_DISPLAYED("SG_FLYHLP1")
|
|
IF GET_GAME_TIMER() >= iClearHelpTime + 1000
|
|
CLEAR_HELP(FALSE)
|
|
iClearHelpTime = GET_GAME_TIMER()
|
|
ENDIF
|
|
ENDIF
|
|
bRemovedAltitudeHelp = TRUE
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF bWantedLevelOK
|
|
bAllOK = TRUE
|
|
bRemovedBlipsForWanted = FALSE
|
|
//bKilledConversationOnWanted = FALSE
|
|
bShownLoseWantedPrompt = FALSE
|
|
|
|
// buddy is in the vehicle / not required to be in vehicle
|
|
//blip the destination
|
|
IF NOT DOES_BLIP_EXIST(getToBlip)
|
|
AND currentMissionStage <> STAGE_CHOPPER_CHASE
|
|
REMOVE_MISSION_TEXT(FALSE, TRUE, FALSE)
|
|
REMOVE_ALL_BLIPS()
|
|
|
|
SWITCH currentMissionStage
|
|
CASE STAGE_GET_TO_CHOPPER
|
|
IF NOT DOES_BLIP_EXIST(g_sMagDemoFBI2Entities.blip)
|
|
getToBlip = CREATE_MISSION_BLIP_FOR_COORD(GET_SNATCH_AND_GRAB_VECTOR(SAGVEC_MEETING_POINT), TRUE)
|
|
ELSE
|
|
g_sMagDemoFBI2Entities.bBlipActive = TRUE
|
|
ENDIF
|
|
BREAK
|
|
CASE STAGE_GET_TO_BUILDING
|
|
getToBlip = CREATE_MISSION_BLIP_FOR_COORD(GET_SNATCH_AND_GRAB_VECTOR(SAGVEC_HOVER_TARGET))
|
|
BREAK
|
|
CASE STAGE_DROPOFF
|
|
getToBlip = CREATE_MISSION_BLIP_FOR_COORD(GET_SNATCH_AND_GRAB_VECTOR(SAGVEC_DROPOFF))
|
|
BREAK
|
|
ENDSWITCH
|
|
ELSE
|
|
IF DOES_BLIP_EXIST(vehicleBlip)
|
|
REMOVE_BLIP(vehicleBlip)
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF NOT bDoneGotoSpeech
|
|
SWITCH currentMissionStage
|
|
CASE STAGE_GET_TO_BUILDING
|
|
bDoneGotoSpeech = DO_MISSION_SPEECH("FBI2_MGO")
|
|
iChopperHelpTime = GET_GAME_TIMER() + 200
|
|
BREAK
|
|
ENDSWITCH
|
|
ENDIF
|
|
|
|
// show god text
|
|
IF NOT bShownGodText
|
|
SWITCH currentMissionStage
|
|
CASE STAGE_GET_TO_CHOPPER
|
|
IF bDoneGotoSpeech
|
|
AND bDoneGetToLotSpeech
|
|
bShownGodText = DO_MISSION_GOD_TEXT("SG_GOLOC")
|
|
ENDIF
|
|
BREAK
|
|
CASE STAGE_GET_TO_BUILDING
|
|
IF bDoneGotoSpeech
|
|
bShownGodText = DO_MISSION_GOD_TEXT("SG_GOBLD")
|
|
ENDIF
|
|
BREAK
|
|
//CASE STAGE_CHOPPER_CHASE
|
|
CASE STAGE_DROPOFF
|
|
IF bDoneGotoSpeech
|
|
bShownGodText = DO_MISSION_GOD_TEXT("SG_GOLND")
|
|
ENDIF
|
|
BREAK
|
|
ENDSWITCH
|
|
ENDIF
|
|
ELSE
|
|
IF NOT bRemovedBlipsForWanted
|
|
REMOVE_ALL_BLIPS()
|
|
bRemovedBlipsForWanted = TRUE
|
|
ENDIF
|
|
|
|
//IF NOT bKilledConversationOnWanted
|
|
// STORE_BANTER()
|
|
// KILL_ANY_CONVERSATION()
|
|
// REMOVE_MISSION_TEXT(FALSE, TRUE, FALSE)
|
|
// bKilledConversationOnWanted = TRUE
|
|
//ELSE
|
|
REMOVE_HELI_BLIP_AND_TEXT()
|
|
REMOVE_CAR_BLIP_AND_TEXT()
|
|
|
|
IF NOT bShownLoseWantedPrompt
|
|
IF currentMissionStage <> STAGE_GET_TO_CHOPPER
|
|
OR bDoneDaveWantedSpeech
|
|
bShownLoseWantedPrompt = DO_MISSION_GOD_TEXT("LOSE_WANTED")
|
|
ENDIF
|
|
ENDIF
|
|
//ENDIF
|
|
ENDIF
|
|
ELSE
|
|
// buddy is not in the vehicle - blip him
|
|
IF NOT DOES_BLIP_EXIST(buddyBlip)
|
|
REMOVE_MISSION_TEXT(FALSE, TRUE, FALSE)
|
|
REMOVE_ALL_BLIPS()
|
|
buddyBlip = CREATE_MISSION_BLIP_FOR_PED(buddyPed)
|
|
ENDIF
|
|
|
|
IF NOT bWaitForBuddyPrompt
|
|
IF buddyPed = davePed
|
|
bWaitForBuddyPrompt = DO_MISSION_GOD_TEXT("SG_WAITD")
|
|
ELSE
|
|
bWaitForBuddyPrompt = DO_MISSION_GOD_TEXT("SG_WAIT")
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ELSE
|
|
IF DOES_BLIP_EXIST(playerChopperBlip)
|
|
REMOVE_BLIP(playerChopperBlip)
|
|
ENDIF
|
|
|
|
// removing help text
|
|
IF currentMissionStage = STAGE_GET_TO_BUILDING
|
|
// chopper help
|
|
IF IS_THIS_HELP_MESSAGE_BEING_DISPLAYED("SG_FLYHLP1")
|
|
OR IS_THIS_HELP_MESSAGE_BEING_DISPLAYED("SG_FLYHLP2")
|
|
OR IS_THIS_HELP_MESSAGE_BEING_DISPLAYED("SG_FLYHLP3")
|
|
IF GET_GAME_TIMER() >= iClearHelpTime + 1000
|
|
CLEAR_HELP(FALSE)
|
|
iClearHelpTime = GET_GAME_TIMER()
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF NOT DOES_BLIP_EXIST(vehicleBlip)
|
|
REMOVE_MISSION_TEXT(FALSE, TRUE, FALSE)
|
|
IF bRemoveOtherBlips
|
|
REMOVE_ALL_BLIPS()
|
|
ENDIF
|
|
|
|
IF iGetInTextStage = 0
|
|
OR iGetInTextStage = 2
|
|
bShouldDoGetInText = TRUE
|
|
ENDIF
|
|
|
|
//IF currentMissionStage < STAGE_CHOPPER_CHASE
|
|
vehicleBlip = CREATE_MISSION_BLIP_FOR_VEHICLE(vehicle)
|
|
//ENDIF
|
|
ENDIF
|
|
|
|
IF bShouldDoGetInText
|
|
STRING sGetInString
|
|
IF currentMissionStage = STAGE_GET_TO_CHOPPER
|
|
SWITCH iGetInTextStage
|
|
CASE 0
|
|
sGetInString = "SG_GETDCAR1"
|
|
BREAK
|
|
CASE 2
|
|
sGetInString = "SG_GETDCAR2"
|
|
BREAK
|
|
ENDSWITCH
|
|
ELSE
|
|
SWITCH iGetInTextStage
|
|
CASE 0
|
|
sGetInString = "CMN_GENGETINHE"
|
|
BREAK
|
|
CASE 2
|
|
sGetInString = "CMN_GENGETBCKHE"
|
|
BREAK
|
|
ENDSWITCH
|
|
ENDIF
|
|
|
|
IF bDoneGotoSpeech
|
|
AND (bDoneDaveLetsGoSpeech OR currentMissionStage > STAGE_GET_TO_CHOPPER)
|
|
IF DO_MISSION_GOD_TEXT(sGetInString)
|
|
bShouldDoGetInText = FALSE
|
|
iGetInTextStage++
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ELSE
|
|
// buddy is not group member
|
|
IF IS_ENTITY_AT_ENTITY(PLAYER_PED_ID(), buddyPed, <<12, 12, 6>>)
|
|
// re-add to group
|
|
//SET_PED_AS_GROUP_MEMBER(buddyPed, PLAYER_GROUP_ID())
|
|
ELSE
|
|
// do blip and god text
|
|
IF NOT DOES_BLIP_EXIST(buddyBlip)
|
|
REMOVE_MISSION_TEXT(FALSE, TRUE, FALSE)
|
|
REMOVE_ALL_BLIPS()
|
|
buddyBlip = CREATE_MISSION_BLIP_FOR_PED(buddyPed)
|
|
ENDIF
|
|
IF NOT bGetBuddyPrompt
|
|
IF buddyPed = davePed
|
|
bGetBuddyPrompt = DO_MISSION_GOD_TEXT("SG_LEAVE")
|
|
ELSE
|
|
bGetBuddyPrompt = DO_MISSION_GOD_TEXT("CMN_MLEAVE")
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF bAllOK
|
|
IF IS_PLAYER_BROWSING_ITEMS_IN_ANY_SHOP()
|
|
bAllOK = FALSE
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF NOT bAllOK
|
|
IF currentMissionStage <> STAGE_GET_TO_CHOPPER
|
|
OR (bDaveInCar OR NOT bBuddyGroupOK)
|
|
IF NOT bSavedBanter
|
|
IF STORE_BANTER()
|
|
KILL_ANY_CONVERSATION()
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDPROC
|
|
|
|
// kill all guards
|
|
PROC KILL_ALL_GUARDS()
|
|
INT i
|
|
REPEAT NUMBER_GUARDS i
|
|
IF NOT IS_PED_INJURED(guardPed[i])
|
|
APPLY_DAMAGE_TO_PED(guardPed[i], 1000, TRUE)
|
|
ENDIF
|
|
ENDREPEAT
|
|
REPEAT NUMBER_REINFORCEMENTS i
|
|
IF NOT IS_PED_INJURED(reinforcementPed[i])
|
|
APPLY_DAMAGE_TO_PED(reinforcementPed[i], 1000, TRUE)
|
|
ENDIF
|
|
ENDREPEAT
|
|
ENDPROC
|
|
|
|
// maintain door open
|
|
PROC MAINTAIN_DOOR_OPEN()
|
|
// lock the chairs here too
|
|
INT i
|
|
REPEAT NUMBER_FROZEN_CHAIRS i
|
|
IF NOT DOES_ENTITY_EXIST(frozenChairObject[i])
|
|
VECTOR vPos
|
|
SWITCH i
|
|
CASE 0
|
|
vPos = <<117.18, -621.4, 205.57>>
|
|
BREAK
|
|
CASE 1
|
|
vPos = <<115.69, -621.74, 205.63>>
|
|
BREAK
|
|
ENDSWITCH
|
|
frozenChairObject[i] = GET_CLOSEST_OBJECT_OF_TYPE(vPos, 1.0, v_corp_offchair, FALSE)
|
|
IF DOES_ENTITY_EXIST(frozenChairObject[i])
|
|
FREEZE_ENTITY_POSITION(frozenChairObject[i], TRUE)
|
|
ENDIF
|
|
ENDIF
|
|
ENDREPEAT
|
|
|
|
// main door needs to stay open - (for david - comment out this whole block to test door system)
|
|
IF DOES_OBJECT_OF_TYPE_EXIST_AT_COORDS(<<118.78, -619.49, 205.05>>, 3.0, V_iLev_FIB_door1)
|
|
IF fLockDoorOpen <> 0
|
|
SET_STATE_OF_CLOSEST_DOOR_OF_TYPE(V_iLev_FIB_door1, <<118.78, -619.49, 205.05>>, TRUE, fLockDoorOpen)
|
|
ELSE
|
|
BOOL bLocked
|
|
FLOAT fOpenRatio
|
|
|
|
GET_STATE_OF_CLOSEST_DOOR_OF_TYPE(V_iLev_FIB_door1, <<118.78, -619.49, 205.05>>, bLocked, fOpenRatio)
|
|
|
|
IF fOpenRatio > 1.0
|
|
OR fOpenRatio < -1.0
|
|
fLockDoorOpen = fOpenRatio
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
|
|
DOOR_SYSTEM_SET_DOOR_STATE(DOORHASH_CLOSED_DOOR1, DOORSTATE_FORCE_LOCKED_THIS_FRAME)
|
|
DOOR_SYSTEM_SET_DOOR_STATE(DOORHASH_CLOSED_DOOR2, DOORSTATE_FORCE_LOCKED_THIS_FRAME)
|
|
|
|
// open door (for david - uncomment out to test door system
|
|
/*
|
|
DOOR_SYSTEM_SET_OPEN_RATIO(DOORHASH_OPEN_DOOR, DOOR_OPEN_RATIO)
|
|
DOOR_SYSTEM_SET_DOOR_STATE(DOORHASH_OPEN_DOOR, DOORSTATE_FORCE_OPEN_THIS_FRAME)
|
|
*/
|
|
ENDPROC
|
|
|
|
// handle fbi
|
|
PROC HANDLE_FBI()
|
|
INT i
|
|
BOOL bFail
|
|
|
|
// fail on attack
|
|
REPEAT COUNT_OF(fbiPed) i
|
|
IF DOES_ENTITY_EXIST(fbiPed[i])
|
|
IF NOT IS_PED_INJURED(fbiPed[i])
|
|
IF HAS_ENTITY_BEEN_DAMAGED_BY_ENTITY(fbiPed[i], PLAYER_PED_ID())
|
|
bFail = TRUE
|
|
ENDIF
|
|
|
|
IF currentMissionStage = STAGE_GET_TO_CHOPPER
|
|
IF IS_PED_RAGDOLL(fbiPed[i])
|
|
IF IS_ENTITY_AT_ENTITY(PLAYER_PED_ID(), fbiPed[i], <<10,10,10>>, FALSE, FALSE)
|
|
MISSION_FAILED(FAIL_CAUSED_TROUBLE)
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ELSE
|
|
bFail = TRUE
|
|
ENDIF
|
|
ENDIF
|
|
ENDREPEAT
|
|
|
|
IF DOES_ENTITY_EXIST(fbiVanVehicle)
|
|
IF IS_VEHICLE_DRIVEABLE(fbiVanVehicle)
|
|
// don't react to hitting the van with the chopper
|
|
BOOL bCheckDamagerVehicle = TRUE
|
|
IF IS_VEHICLE_DRIVEABLE(snatchAndGrabVehicle[SAGV_PLAYER_CHOPPER])
|
|
IF IS_PED_IN_VEHICLE(PLAYER_PED_ID(), snatchAndGrabVehicle[SAGV_PLAYER_CHOPPER])
|
|
IF GET_ENTITY_SPEED(snatchAndGrabVehicle[SAGV_PLAYER_CHOPPER]) < 25
|
|
bCheckDamagerVehicle = FALSE
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF HAS_ENTITY_BEEN_DAMAGED_BY_ENTITY(fbiVanVehicle, PLAYER_PED_ID(), bCheckDamagerVehicle)
|
|
bFail = TRUE
|
|
ENDIF
|
|
ELSE
|
|
bFail = TRUE
|
|
ENDIF
|
|
ENDIF
|
|
|
|
REPEAT COUNT_OF(utilTruckVehicle) i
|
|
IF DOES_ENTITY_EXIST(utilTruckVehicle[i])
|
|
IF IS_ENTITY_DEAD(utilTruckVehicle[i])
|
|
MISSION_FAILED(FAIL_CAUSED_TROUBLE)
|
|
ENDIF
|
|
ENDIF
|
|
ENDREPEAT
|
|
|
|
// fail for interfering with meeting
|
|
IF currentMissionStage = STAGE_GET_TO_CHOPPER
|
|
IF IS_VEHICLE_DRIVEABLE(snatchAndGrabVehicle[SAGV_PLAYER_CHOPPER])
|
|
IF HAS_ENTITY_BEEN_DAMAGED_BY_ENTITY(snatchAndGrabVehicle[SAGV_PLAYER_CHOPPER], PLAYER_PED_ID())
|
|
MISSION_FAILED(FAIL_CAUSED_TROUBLE)
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF NOT IS_PED_INJURED(sSelectorPeds.pedID[SELECTOR_PED_TREVOR])
|
|
IF IS_PED_RAGDOLL(sSelectorPeds.pedID[SELECTOR_PED_TREVOR])
|
|
IF IS_ENTITY_AT_ENTITY(PLAYER_PED_ID(), sSelectorPeds.pedID[SELECTOR_PED_TREVOR], <<10,10,10>>, FALSE, FALSE)
|
|
MISSION_FAILED(FAIL_CAUSED_TROUBLE)
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF HAS_ENTITY_BEEN_DAMAGED_BY_ENTITY(sSelectorPeds.pedID[SELECTOR_PED_TREVOR], PLAYER_PED_ID())
|
|
MISSION_FAILED(FAIL_CAUSED_TROUBLE)
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF NOT IS_PED_INJURED(PLAYER_PED_ID())
|
|
|
|
IF NOT IS_PED_INJURED(sSelectorPeds.pedID[SELECTOR_PED_FRANKLIN])
|
|
IF IS_ENTITY_AT_ENTITY(PLAYER_PED_ID(), sSelectorPeds.pedID[SELECTOR_PED_FRANKLIN], <<1.5, 1.5, 2.0>>)
|
|
DISABLE_CONTROL_ACTION(PLAYER_CONTROL, INPUT_JUMP)
|
|
ENDIF
|
|
//IF IS_VEHICLE_DRIVEABLE(snatchAndGrabVehicle[SAGV_FRANKLIN_BIKE])
|
|
// IF GET_ENTITY_SPEED(snatchAndGrabVehicle[SAGV_FRANKLIN_BIKE]) > 0.5
|
|
// bTouching = TRUE
|
|
// ENDIF
|
|
//ENDIF
|
|
|
|
IF IS_PED_RAGDOLL(sSelectorPeds.pedID[SELECTOR_PED_FRANKLIN])
|
|
IF IS_ENTITY_AT_ENTITY(PLAYER_PED_ID(), sSelectorPeds.pedID[SELECTOR_PED_FRANKLIN], <<10,10,10>>, FALSE, FALSE)
|
|
MISSION_FAILED(FAIL_CAUSED_TROUBLE)
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF HAS_ENTITY_BEEN_DAMAGED_BY_ENTITY(sSelectorPeds.pedID[SELECTOR_PED_FRANKLIN], PLAYER_PED_ID())
|
|
MISSION_FAILED(FAIL_CAUSED_TROUBLE)
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF IS_VEHICLE_DRIVEABLE(snatchAndGrabVehicle[SAGV_FRANKLIN_BIKE])
|
|
IF HAS_ENTITY_BEEN_DAMAGED_BY_ENTITY(snatchAndGrabVehicle[SAGV_FRANKLIN_BIKE], PLAYER_PED_ID())
|
|
IF NOT IS_PED_INJURED(sSelectorPeds.pedID[SELECTOR_PED_FRANKLIN])
|
|
SET_PED_TO_RAGDOLL(sSelectorPeds.pedID[SELECTOR_PED_FRANKLIN], 2500, 2500, TASK_RELAX)
|
|
//CLEAR_PED_TASKS(sSelectorPeds.pedID[SELECTOR_PED_FRANKLIN])
|
|
ENDIF
|
|
FREEZE_ENTITY_POSITION(snatchAndGrabVehicle[SAGV_FRANKLIN_BIKE], FALSE)
|
|
MISSION_FAILED(FAIL_CAUSED_TROUBLE)
|
|
ENDIF
|
|
ELSE
|
|
IF DOES_ENTITY_EXIST(snatchAndGrabVehicle[SAGV_FRANKLIN_BIKE])
|
|
IF IS_ENTITY_DEAD(snatchAndGrabVehicle[SAGV_FRANKLIN_BIKE])
|
|
OR NOT IS_ENTITY_DEAD(snatchAndGrabVehicle[SAGV_FRANKLIN_BIKE])
|
|
FREEZE_ENTITY_POSITION(snatchAndGrabVehicle[SAGV_FRANKLIN_BIKE], FALSE)
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF bFail
|
|
IF missionFailState = MISSION_FAIL_STATE_NOT_FAILED
|
|
REPEAT COUNT_OF(fbiPed) i
|
|
IF NOT IS_PED_INJURED(fbiPed[i])
|
|
SET_PED_RELATIONSHIP_GROUP_HASH(fbiPed[i], RELGROUPHASH_HATES_PLAYER)
|
|
|
|
SET_PED_CAN_BE_TARGETTED(fbiPed[i], TRUE)
|
|
CLEAR_SEQUENCE_TASK(sequence)
|
|
OPEN_SEQUENCE_TASK(sequence)
|
|
TASK_PAUSE(NULL, GET_RANDOM_INT_IN_RANGE(0, 800))
|
|
TASK_COMBAT_PED(NULL, PLAYER_PED_ID())
|
|
CLOSE_SEQUENCE_TASK(sequence)
|
|
TASK_PERFORM_SEQUENCE(fbiPed[i], sequence)
|
|
ENDIF
|
|
ENDREPEAT
|
|
|
|
MISSION_FAILED(FAIL_ATTACKED_FBI)
|
|
ENDIF
|
|
ELSE
|
|
IF currentMissionStage >= STAGE_CHOPPER_CHASE
|
|
IF IS_VEHICLE_DRIVEABLE(snatchAndGrabVehicle[SAGV_PLAYER_CHOPPER])
|
|
AND NOT IS_PED_INJURED(GET_TREVOR_PED())
|
|
REPEAT COUNT_OF(fbiPed) i
|
|
IF NOT IS_PED_INJURED(fbiPed[i])
|
|
IF i=0
|
|
IF NOT IS_PED_HEADTRACKING_ENTITY(fbiPed[i], GET_TREVOR_PED())
|
|
TASK_LOOK_AT_ENTITY(fbiPed[i], GET_TREVOR_PED(), -1, SLF_WHILE_NOT_IN_FOV)
|
|
ENDIF
|
|
ELSE
|
|
VECTOR vOffset = GET_OFFSET_FROM_ENTITY_GIVEN_WORLD_COORDS(fbiPed[i], GET_ENTITY_COORDS(GET_TREVOR_PED()))
|
|
IF vOffset.z >= 2.0
|
|
fBelowWaveHeightTime = 0.0
|
|
bResetTimeForBelowHeight = FALSE
|
|
ELSE
|
|
fBelowWaveHeightTime = fBelowWaveHeightTime +@ 1.0
|
|
IF NOT bResetTimeForBelowHeight
|
|
iLastFBITaskTime = 0
|
|
bResetTimeForBelowHeight = TRUE
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF vOffset.y >= 5
|
|
AND fBelowWaveHeightTime <= 1.0
|
|
IF NOT bDoneFBIWaveDownChopper
|
|
IF GET_GAME_TIMER() >= iLastFBITaskTime + 2000
|
|
AND fBelowWaveHeightTime = 0.0
|
|
TASK_LOOK_AT_ENTITY(fbiPed[i], GET_TREVOR_PED(), -1, SLF_WHILE_NOT_IN_FOV)
|
|
IF currentMissionStage >= STAGE_DROPOFF
|
|
TASK_PLAY_ANIM(fbiPed[i], GET_SNATCH_AND_GRAB_ANIM_DICT_AS_STRING(SAG_ANIM_DICT_FLY_HOME), "Direct_Heli_loop", REALLY_SLOW_BLEND_IN, REALLY_SLOW_BLEND_OUT, -1, AF_LOOPING)
|
|
ENDIF
|
|
bDoneFBIWaveDownChopper = TRUE
|
|
bDoneFBITurnToFaceChopper = FALSE
|
|
iLastFBITaskTime = GET_GAME_TIMER()
|
|
ENDIF
|
|
ENDIF
|
|
ELSE
|
|
IF NOT bDoneFBITurnToFaceChopper
|
|
IF GET_GAME_TIMER() >= iLastFBITaskTime + 3000
|
|
TASK_TURN_PED_TO_FACE_ENTITY(fbiPed[i], GET_TREVOR_PED())
|
|
bDoneFBITurnToFaceChopper = TRUE
|
|
bDoneFBIWaveDownChopper = FALSE
|
|
iLastFBITaskTime = GET_GAME_TIMER()
|
|
ENDIF
|
|
ELSE
|
|
IF GET_GAME_TIMER() >= iLastFBITaskTime + 4000
|
|
bDoneFBITurnToFaceChopper = FALSE
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDREPEAT
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDPROC
|
|
|
|
// get high rise area point
|
|
FUNC VECTOR GET_HIGH_RISE_AREA_POINT(INT iPoint)
|
|
SWITCH iPoint
|
|
CASE 0 // bottom left
|
|
RETURN <<-259.1, -1145.2, 200>>
|
|
BREAK
|
|
CASE 1 // bottom right
|
|
RETURN <<245.1, -1145.2, 200>>
|
|
BREAK
|
|
CASE 2 // top right
|
|
RETURN <<245.1, -483.6, 200>>
|
|
BREAK
|
|
CASE 3 // top left
|
|
RETURN <<-259.1, -483.6, 200>>
|
|
BREAK
|
|
ENDSWITCH
|
|
|
|
RETURN <<0,0,0>>
|
|
ENDFUNC
|
|
|
|
// get escape route point
|
|
FUNC VECTOR GET_ESCAPE_ROUTE_POINT(INT iPoint)
|
|
FLOAT fAngle = (360 / NUMBER_ESCAPE_ROUTE_POINTS) * TO_FLOAT(iPoint)
|
|
|
|
VECTOR vCircleCentre = <<-75.12, -819.06, ESCAPE_ROUTE_HEIGHT>>
|
|
VECTOR vCirclePoint = <<0,0,0>>
|
|
|
|
CONST_FLOAT HELI_CIRCLE_RADIUS 450.0
|
|
|
|
|
|
vCirclePoint.x = vCircleCentre.x + (HELI_CIRCLE_RADIUS * COS(fAngle))
|
|
vCirclePoint.y = vCircleCentre.y + (HELI_CIRCLE_RADIUS * SIN(fAngle))
|
|
vCirclePoint.z = vCircleCentre.z
|
|
|
|
RETURN vCirclePoint
|
|
ENDFUNC
|
|
|
|
|
|
// get leave high rise area point
|
|
FUNC VECTOR GET_LEAVE_HIGH_RISE_AREA_POINT(INT iPoint)
|
|
SWITCH iPoint
|
|
CASE 0
|
|
RETURN <<-268.58, -1165.25, ESCAPE_ROUTE_HEIGHT>>
|
|
BREAK
|
|
CASE 1
|
|
RETURN <<56.39, -1128.32, ESCAPE_ROUTE_HEIGHT>>
|
|
BREAK
|
|
CASE 2
|
|
RETURN <<104.41, -999.78, ESCAPE_ROUTE_HEIGHT>>
|
|
BREAK
|
|
CASE 3
|
|
RETURN <<237.19, -871.54, ESCAPE_ROUTE_HEIGHT>>
|
|
BREAK
|
|
CASE 4
|
|
RETURN <<288.22, -641.40, ESCAPE_ROUTE_HEIGHT>>
|
|
BREAK
|
|
CASE 5
|
|
RETURN <<288.70, -548.61, ESCAPE_ROUTE_HEIGHT>>
|
|
BREAK
|
|
CASE 6
|
|
RETURN <<136.17, -461.98, ESCAPE_ROUTE_HEIGHT>>
|
|
BREAK
|
|
CASE 7
|
|
RETURN <<-47.05, -461.51, ESCAPE_ROUTE_HEIGHT>>
|
|
BREAK
|
|
CASE 8
|
|
RETURN <<-320.04, -588.73, ESCAPE_ROUTE_HEIGHT>>
|
|
BREAK
|
|
CASE 9
|
|
RETURN <<-371.64, -863.03, ESCAPE_ROUTE_HEIGHT>>
|
|
BREAK
|
|
ENDSWITCH
|
|
|
|
RETURN <<0,0,0>>
|
|
ENDFUNC
|
|
|
|
// get escape point from high rise area point
|
|
FUNC INT GET_NEXT_ESCAPE_POINT_FROM_LEAVE_HIGH_RISE_AREA_POINT(INT iPoint)
|
|
SWITCH iPoint
|
|
CASE 0
|
|
RETURN 1
|
|
BREAK
|
|
CASE 1
|
|
RETURN 1
|
|
BREAK
|
|
CASE 2
|
|
RETURN 1
|
|
BREAK
|
|
CASE 3
|
|
RETURN 2
|
|
BREAK
|
|
CASE 4
|
|
RETURN 2
|
|
BREAK
|
|
CASE 5
|
|
RETURN 2
|
|
BREAK
|
|
CASE 6
|
|
RETURN 3
|
|
BREAK
|
|
CASE 7
|
|
RETURN 3
|
|
BREAK
|
|
CASE 8
|
|
RETURN 0
|
|
BREAK
|
|
CASE 9
|
|
RETURN 0
|
|
BREAK
|
|
ENDSWITCH
|
|
|
|
RETURN 0
|
|
ENDFUNC
|
|
|
|
// is coord in high rise area
|
|
FUNC BOOL IS_COORD_IN_HIGH_RISE_AREA(VECTOR vCoord)
|
|
VECTOR vBottomLeft = GET_HIGH_RISE_AREA_POINT(0)
|
|
VECTOR vTopRight = GET_HIGH_RISE_AREA_POINT(2)
|
|
|
|
IF vCoord.x >= vBottomLeft.x
|
|
AND vCoord.y >= vBottomLeft.y
|
|
AND vCoord.x <= vTopRight.x
|
|
AND vCoord.y <= vTopRight.y
|
|
// cut out botton right which isn't that high-rise-y
|
|
IF vCoord.x >= -46
|
|
AND vCoord.y <= -874
|
|
RETURN FALSE
|
|
ELSE
|
|
RETURN TRUE
|
|
ENDIF
|
|
ENDIF
|
|
|
|
RETURN FALSE
|
|
ENDFUNC
|
|
|
|
// does line intersect high rise area?
|
|
CONST_INT CHECK_LINE_INTERSECT_POINTS 15
|
|
FUNC BOOL DOES_LINE_INTERSECT_HIGH_RISE_AREA(VECTOR vPoint1, VECTOR vPoint2)
|
|
FLOAT fDistX = vPoint2.x - vPoint1.x
|
|
FLOAT fDistY = vPoint2.y - vPoint1.y
|
|
FLOAT fPointStepX = fDistX / CHECK_LINE_INTERSECT_POINTS
|
|
FLOAT fPointStepY = fDistY / CHECK_LINE_INTERSECT_POINTS
|
|
|
|
INT i
|
|
FOR i=1 TO CHECK_LINE_INTERSECT_POINTS-1
|
|
FLOAT fThisPointX = vPoint1.x + (i * fPointStepX)
|
|
FLOAT fThisPointY = vPoint1.y + (i * fPointStepY)
|
|
IF IS_COORD_IN_HIGH_RISE_AREA(<<fThisPointX, fThisPointY, 0>>)
|
|
RETURN TRUE
|
|
ENDIF
|
|
ENDFOR
|
|
|
|
RETURN FALSE
|
|
ENDFUNC
|
|
|
|
// does line intersect buildings
|
|
CONST_INT CHECK_BUILDING_INTERSECT_POINTS 10
|
|
FUNC BOOL DOES_LINE_INTERSECT_BUILDINGS(VECTOR vPoint1, VECTOR vPoint2)
|
|
FLOAT fCheckGroundHeight
|
|
FLOAT fStoredGroundHeight
|
|
|
|
FLOAT fDistX = vPoint2.x - vPoint1.x
|
|
FLOAT fDistY = vPoint2.y - vPoint1.y
|
|
FLOAT fPointStepX = fDistX / CHECK_BUILDING_INTERSECT_POINTS
|
|
FLOAT fPointStepY = fDistY / CHECK_BUILDING_INTERSECT_POINTS
|
|
|
|
GET_GROUND_Z_FOR_3D_COORD(vPoint1 + <<0,0,200>>, fStoredGroundHeight)
|
|
|
|
INT i
|
|
FOR i=1 TO CHECK_BUILDING_INTERSECT_POINTS-1
|
|
FLOAT fThisPointX = vPoint1.x + (i * fPointStepX)
|
|
FLOAT fThisPointY = vPoint1.y + (i * fPointStepY)
|
|
|
|
GET_GROUND_Z_FOR_3D_COORD(<<fThisPointX,fThisPointY,400>>, fCheckGroundHeight)
|
|
IF fCheckGroundHeight - fStoredGroundHeight >= 125
|
|
RETURN TRUE
|
|
ENDIF
|
|
|
|
fStoredGroundHeight = fCheckGroundHeight
|
|
ENDFOR
|
|
|
|
RETURN FALSE
|
|
ENDFUNC
|
|
|
|
// get best leave area point
|
|
FUNC INT GET_BEST_LEAVE_HIGH_RISE_AREA_POINT(VECTOR vCoords)
|
|
INT iReturnPoint = -1
|
|
FLOAT fClosestDistance = 99999999.0
|
|
FLOAT fThisDistance
|
|
|
|
// which points are allowed
|
|
INT i
|
|
REPEAT NUMBER_LEAVE_HIGH_RISE_AREA_POINTS i
|
|
VECTOR vPoint = GET_LEAVE_HIGH_RISE_AREA_POINT(i)
|
|
IF NOT DOES_LINE_INTERSECT_BUILDINGS(vCoords, vPoint)
|
|
fThisDistance = GET_DISTANCE_BETWEEN_COORDS(vCoords, vPoint, FALSE)
|
|
|
|
IF IS_VEHICLE_DRIVEABLE(snatchAndGrabVehicle[SAGV_PLAYER_CHOPPER])
|
|
// get offset
|
|
VECTOR vOffset = GET_OFFSET_FROM_ENTITY_GIVEN_WORLD_COORDS(snatchAndGrabVehicle[SAGV_PLAYER_CHOPPER], vPoint)
|
|
IF vOffset.y >= 0
|
|
fThisDistance -= 500
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF fThisDistance < fClosestDistance
|
|
fClosestDistance = fThisDistance
|
|
iReturnPoint = i
|
|
ENDIF
|
|
ENDIF
|
|
ENDREPEAT
|
|
|
|
RETURN iReturnPoint
|
|
ENDFUNC
|
|
|
|
PROC TASK_TREVOR_MISSION(VECTOR vTarget, FLOAT fSpeed, FLOAT fDist, FLOAT fRot, INT iHeight, INT iMinHeight, BOOL bIsCached = FALSE)
|
|
PED_INDEX trevorPed = GET_TREVOR_PED()
|
|
IF NOT IS_PED_INJURED(trevorPed)
|
|
AND IS_VEHICLE_DRIVEABLE(snatchAndGrabVehicle[SAGV_PLAYER_CHOPPER])
|
|
IF trevorPed <> PLAYER_PED_ID()
|
|
OR bIsCached
|
|
IF NOT bDoneForceTrevorLow
|
|
TASK_HELI_MISSION(trevorPed, snatchAndGrabVehicle[SAGV_PLAYER_CHOPPER], NULL, NULL, vTarget, MISSION_GOTO, fSpeed, fDist, fRot, iHeight, iMinHeight)
|
|
PRINTSTRING("trevor tasked mission!") printnl()
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF NOT bIsCached
|
|
bTrevorCachedTarget = TRUE
|
|
ENDIF
|
|
ENDIF
|
|
ENDPROC
|
|
|
|
// trevor fly to route point
|
|
PROC DO_TREVOR_FLY_TO_ROUTE_POINT(INT iCustomHeight = -1, INT iCustomHeightAboveGround = -1, FLOAT fCustomSpeed = -1.0, FLOAT fCustomDistance = -1.0)
|
|
IF NOT IS_PED_INJURED(sSelectorPeds.pedID[SELECTOR_PED_TREVOR])
|
|
AND IS_VEHICLE_DRIVEABLE(snatchAndGrabVehicle[SAGV_PLAYER_CHOPPER])
|
|
INT iFlightHeight
|
|
INT iMinHeightAboveGround
|
|
|
|
FLOAT fSpeed
|
|
FLOAT fDistance
|
|
|
|
IF iCustomHeight >= 0
|
|
iFlightHeight = iCustomHeight
|
|
ELSE
|
|
iFlightHeight = 220
|
|
ENDIF
|
|
|
|
IF iCustomHeightAboveGround >= 0
|
|
iMinHeightAboveGround = iCustomHeightAboveGround
|
|
ELSE
|
|
iMinHeightAboveGround = 50
|
|
ENDIF
|
|
|
|
IF fCustomSpeed >= 0
|
|
fSpeed = fCustomSpeed
|
|
ELSE
|
|
fSpeed = 40
|
|
ENDIF
|
|
|
|
IF fCustomDistance >= 0
|
|
fDistance = fCustomDistance
|
|
ELSE
|
|
fDistance = 8
|
|
ENDIF
|
|
|
|
TASK_TREVOR_MISSION(vTrevorRoutePoint[iTrevorRouteStage] + <<0,0,15>>, fSpeed, fDistance, -1, iFlightHeight, iMinHeightAboveGround)
|
|
ENDIF
|
|
ENDPROC
|
|
|
|
// trevor fly to leave area point
|
|
PROC DO_TREVOR_FLY_TO_LEAVE_AREA_POINT()
|
|
IF NOT IS_PED_INJURED(sSelectorPeds.pedID[SELECTOR_PED_TREVOR])
|
|
AND IS_VEHICLE_DRIVEABLE(snatchAndGrabVehicle[SAGV_PLAYER_CHOPPER])
|
|
VECTOR vLeavePoint = GET_LEAVE_HIGH_RISE_AREA_POINT(iLeaveHighRiseAreaPoint)
|
|
//TASK_HELI_MISSION(sSelectorPeds.pedID[SELECTOR_PED_TREVOR], snatchAndGrabVehicle[SAGV_PLAYER_CHOPPER], NULL, NULL, vLeavePoint, MISSION_GOTO, 40.0, 1.0, -1, FLOOR(vLeavePoint.z), 50)
|
|
|
|
TASK_TREVOR_MISSION(vLeavePoint, 40.0, 1.0, -1, FLOOR(vLeavePoint.z), 50)
|
|
ENDIF
|
|
ENDPROC
|
|
|
|
// does heading match
|
|
FUNC BOOL IS_VEHICLE_AT_HEADING(VEHICLE_INDEX vehicle, FLOAT fTargetHeading, FLOAT allowAngleFrom0 = 25.0)
|
|
FLOAT fVehicleHeading = NORMALISE_HEADING(GET_ENTITY_HEADING(vehicle))
|
|
FLOAT fHeadingDiff = fVehicleHeading - fTargetHeading
|
|
IF fHeadingDiff < 0
|
|
fHeadingDiff *= -1
|
|
ENDIF
|
|
IF fHeadingDiff <= allowAngleFrom0
|
|
OR fHeadingDiff >= 360 - allowAngleFrom0
|
|
RETURN TRUE
|
|
ENDIF
|
|
|
|
RETURN FALSE
|
|
ENDFUNC
|
|
|
|
// rotate to face leave area point
|
|
PROC HANDLE_LEAVE_HIGH_RISE_AREA()
|
|
IF NOT IS_PED_INJURED(sSelectorPeds.pedID[SELECTOR_PED_TREVOR])
|
|
AND IS_VEHICLE_DRIVEABLE(snatchAndGrabVehicle[SAGV_PLAYER_CHOPPER])
|
|
IF NOT bStartedRotateToLeaveHighRiseArea
|
|
// give task to rotate to the correct heading first
|
|
IF iLeaveHighRiseAreaPoint >= 0
|
|
VECTOR vChopperPos = GET_ENTITY_COORDS(snatchAndGrabVehicle[SAGV_PLAYER_CHOPPER])
|
|
VECTOR vTargetPos = GET_LEAVE_HIGH_RISE_AREA_POINT(iLeaveHighRiseAreaPoint)
|
|
fTargetChopperRotate = GET_HEADING_FROM_VECTOR_2D(vTargetPos.x - vChopperPos.x, vTargetPos.y - vChopperPos.y)
|
|
fTargetChopperRotate = NORMALISE_HEADING(fTargetChopperRotate)
|
|
//TASK_HELI_MISSION(sSelectorPeds.pedID[SELECTOR_PED_TREVOR], snatchAndGrabVehicle[SAGV_PLAYER_CHOPPER], NULL, NULL, vChopperPos, MISSION_GOTO, 10, 10, fTargetChopperRotate, FLOOR(vChopperPos.z), 1)
|
|
TASK_TREVOR_MISSION(vChopperPos, 10, 50, fTargetChopperRotate, FLOOR(vChopperPos.z), 1)
|
|
ENDIF
|
|
bStartedRotateToLeaveHighRiseArea = TRUE
|
|
ELSE
|
|
IF NOT bStartedJourneyToLeaveHighRiseArea
|
|
IF IS_VEHICLE_AT_HEADING(snatchAndGrabVehicle[SAGV_PLAYER_CHOPPER], fTargetChopperRotate, 10)
|
|
DO_TREVOR_FLY_TO_LEAVE_AREA_POINT()
|
|
bStartedJourneyToLeaveHighRiseArea = TRUE
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDPROC
|
|
|
|
// trevor fly to dropoff
|
|
PROC DO_TREVOR_FLY_TO_DROPOFF()
|
|
IF NOT IS_PED_INJURED(sSelectorPeds.pedID[SELECTOR_PED_TREVOR])
|
|
AND IS_VEHICLE_DRIVEABLE(snatchAndGrabVehicle[SAGV_PLAYER_CHOPPER])
|
|
//IF IS_PED_SITTING_IN_VEHICLE(sSelectorPeds.pedID[SELECTOR_PED_TREVOR], snatchAndGrabVehicle[SAGV_PLAYER_CHOPPER])
|
|
VECTOR vHeliCoords = GET_ENTITY_COORDS(snatchAndGrabVehicle[SAGV_PLAYER_CHOPPER])
|
|
iLeaveHighRiseAreaPoint = -1
|
|
IF IS_COORD_IN_HIGH_RISE_AREA(vHeliCoords)
|
|
// starting within high rise area. have to plot out first
|
|
iLeaveHighRiseAreaPoint = GET_BEST_LEAVE_HIGH_RISE_AREA_POINT(vHeliCoords)
|
|
ENDIF
|
|
|
|
IF iLeaveHighRiseAreaPoint < 0
|
|
// not starting within the high rise area
|
|
IF DOES_LINE_INTERSECT_HIGH_RISE_AREA(vHeliCoords, GET_SNATCH_AND_GRAB_VECTOR(SAGVEC_DROPOFF))
|
|
// can we get to 1 straight
|
|
IF NOT DOES_LINE_INTERSECT_HIGH_RISE_AREA(vHeliCoords, GET_HIGH_RISE_AREA_POINT(1))
|
|
iTrevorRouteStage = 1
|
|
vTrevorRoutePoint[1] = GET_HIGH_RISE_AREA_POINT(1)
|
|
// nope? can we get to 2 straight
|
|
ELIF NOT DOES_LINE_INTERSECT_HIGH_RISE_AREA(vHeliCoords, GET_HIGH_RISE_AREA_POINT(2))
|
|
iTrevorRouteStage = 1
|
|
vTrevorRoutePoint[1] = GET_HIGH_RISE_AREA_POINT(2)
|
|
ELSE
|
|
// can't get to either 1 or 2. plot a route to the closest of 3 and 0, then onto 2 or 1, then destination
|
|
iTrevorRouteStage = 2
|
|
FLOAT fDistTo3 = GET_DISTANCE_BETWEEN_COORDS(vHeliCoords, GET_HIGH_RISE_AREA_POINT(3), FALSE)
|
|
FLOAT fDistTo0 = GET_DISTANCE_BETWEEN_COORDS(vHeliCoords, GET_HIGH_RISE_AREA_POINT(0), FALSE)
|
|
IF fDistTo3 < fDistTo0
|
|
vTrevorRoutePoint[2] = GET_HIGH_RISE_AREA_POINT(3)
|
|
vTrevorRoutePoint[1] = GET_HIGH_RISE_AREA_POINT(2)
|
|
ELSE
|
|
vTrevorRoutePoint[2] = GET_HIGH_RISE_AREA_POINT(0)
|
|
vTrevorRoutePoint[1] = GET_HIGH_RISE_AREA_POINT(1)
|
|
ENDIF
|
|
ENDIF
|
|
ELSE
|
|
// can just go straight
|
|
iTrevorRouteStage = 0
|
|
ENDIF
|
|
vTrevorRoutePoint[0] = GET_SNATCH_AND_GRAB_VECTOR(SAGVEC_DROPOFF)
|
|
|
|
DO_TREVOR_FLY_TO_ROUTE_POINT()
|
|
ELSE
|
|
bStartedRotateToLeaveHighRiseArea = FALSE
|
|
bStartedJourneyToLeaveHighRiseArea = FALSE
|
|
ENDIF
|
|
//ENDIF
|
|
ENDIF
|
|
ENDPROC
|
|
|
|
// trevor fly to an escape route point
|
|
PROC TREVOR_FLY_TO_ESCAPE_ROUTE_POINT(INT iPoint)
|
|
IF NOT IS_PED_INJURED(sSelectorPeds.pedID[SELECTOR_PED_TREVOR])
|
|
AND IS_VEHICLE_DRIVEABLE(snatchAndGrabVehicle[SAGV_PLAYER_CHOPPER])
|
|
//IF IS_PED_SITTING_IN_VEHICLE(sSelectorPeds.pedID[SELECTOR_PED_TREVOR], snatchAndGrabVehicle[SAGV_PLAYER_CHOPPER])
|
|
// get orientation to fly
|
|
VECTOR vChopperPos = GET_ENTITY_COORDS(snatchAndGrabVehicle[SAGV_PLAYER_CHOPPER])
|
|
VECTOR vTargetPos = GET_ESCAPE_ROUTE_POINT(iPoint)
|
|
FLOAT fOrientation = GET_HEADING_FROM_VECTOR_2D(vTargetPos.x - vChopperPos.x, vTargetPos.y - vChopperPos.y)
|
|
|
|
//TASK_HELI_MISSION(sSelectorPeds.pedID[SELECTOR_PED_TREVOR], snatchAndGrabVehicle[SAGV_PLAYER_CHOPPER], NULL, NULL, vTargetPos, MISSION_GOTO, 40, 1, fOrientation, FLOOR(vTargetPos.z), 20)
|
|
TASK_TREVOR_MISSION(vTargetPos, 40, 1, fOrientation, FLOOR(vTargetPos.z), 20)
|
|
//ENDIF
|
|
ENDIF
|
|
ENDPROC
|
|
|
|
// get closest escape route point
|
|
FUNC INT GET_CLOSEST_ESCAPE_ROUTE_POINT
|
|
FLOAT fClosestDistance = 9999999.0
|
|
INT iCLosestPoint = -1
|
|
|
|
INT i
|
|
REPEAT NUMBER_ESCAPE_ROUTE_POINTS i
|
|
VECTOR vPointPos = GET_ESCAPE_ROUTE_POINT(i)
|
|
FLOAT fThisDistance = GET_DISTANCE_BETWEEN_COORDS(GET_ENTITY_COORDS(sSelectorPeds.pedID[SELECTOR_PED_TREVOR]), vPointPos )
|
|
|
|
// get offset
|
|
IF IS_VEHICLE_DRIVEABLE(snatchAndGrabVehicle[SAGV_PLAYER_CHOPPER])
|
|
VECTOR vOffset = GET_OFFSET_FROM_ENTITY_GIVEN_WORLD_COORDS(snatchAndGrabVehicle[SAGV_PLAYER_CHOPPER], vPointPos)
|
|
IF vOffset.y >= 0
|
|
fThisDistance -= 300
|
|
ELIF vOffset.y >= -150
|
|
fThisDistance -= 150
|
|
ENDIF
|
|
|
|
IF IS_ENTITY_AT_COORD(snatchAndGrabVehicle[SAGV_PLAYER_CHOPPER], vPointPos, <<100,100,100>>)
|
|
fThisDistance += 10000
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF fThisDistance < fClosestDistance
|
|
fClosestDistance = fThisDistance
|
|
iClosestPoint = i
|
|
ENDIF
|
|
ENDREPEAT
|
|
|
|
RETURN iClosestPoint
|
|
ENDFUNC
|
|
|
|
// trevor fly an escape route
|
|
PROC DO_TREVOR_FLY_ESCAPE_ROUTE()
|
|
IF NOT IS_PED_INJURED(sSelectorPeds.pedID[SELECTOR_PED_TREVOR])
|
|
AND IS_VEHICLE_DRIVEABLE(snatchAndGrabVehicle[SAGV_PLAYER_CHOPPER])
|
|
//IF IS_PED_SITTING_IN_VEHICLE(sSelectorPeds.pedID[SELECTOR_PED_TREVOR], snatchAndGrabVehicle[SAGV_PLAYER_CHOPPER])
|
|
IF iTrevorEscapeRoutePoint < 0
|
|
IF NOT IS_PLAYBACK_GOING_ON_FOR_VEHICLE(snatchAndGrabVehicle[SAGV_PLAYER_CHOPPER])
|
|
VECTOR vChopperPos = GET_ENTITY_COORDS(snatchAndGrabVehicle[SAGV_PLAYER_CHOPPER])
|
|
IF NOT bAllowStartEscapeRoute
|
|
IF iLeaveHighRiseAreaPoint < 0
|
|
IF IS_COORD_IN_HIGH_RISE_AREA(vChopperPos)
|
|
iLeaveHighRiseAreaPoint = GET_BEST_LEAVE_HIGH_RISE_AREA_POINT(vChopperPos)
|
|
bStartedRotateToLeaveHighRiseArea = FALSE
|
|
bStartedJourneyToLeaveHighRiseArea = FALSE
|
|
//PRINTSTRING("setting leave high rise point to ") PRINTINT(iLeaveHighRiseAreaPoint) PRINTNL()
|
|
// safety just in case can't find a point
|
|
IF iLeaveHighRiseAreaPoint < 0
|
|
bAllowStartEscapeRoute = TRUE
|
|
ENDIF
|
|
ELSE
|
|
bAllowStartEscapeRoute = TRUE
|
|
ENDIF
|
|
ELSE
|
|
HANDLE_LEAVE_HIGH_RISE_AREA()
|
|
// PRINTSTRING("leaving high rise area") PRINTNL()
|
|
IF GET_DISTANCE_BETWEEN_COORDS(vChopperPos, GET_LEAVE_HIGH_RISE_AREA_POINT(iLeaveHighRiseAreaPoint), FALSE) <= 30
|
|
OR NOT IS_COORD_IN_HIGH_RISE_AREA(vChopperPos)
|
|
iTrevorEscapeRoutePoint = GET_NEXT_ESCAPE_POINT_FROM_LEAVE_HIGH_RISE_AREA_POINT(iLeaveHighRiseAreaPoint)
|
|
TREVOR_FLY_TO_ESCAPE_ROUTE_POINT(iTrevorEscapeRoutePoint)
|
|
bAllowStartEscapeRoute = TRUE
|
|
ENDIF
|
|
ENDIF
|
|
ELSE
|
|
INT iClosestPoint = GET_CLOSEST_ESCAPE_ROUTE_POINT()
|
|
IF iClosestPoint >= 0
|
|
iTrevorEscapeRoutePoint = iClosestPoint
|
|
TREVOR_FLY_TO_ESCAPE_ROUTE_POINT(iTrevorEscapeRoutePoint)
|
|
ENDIF
|
|
ENDIF
|
|
ELSE
|
|
IF GET_TIME_POSITION_IN_RECORDING(snatchAndGrabVehicle[SAGV_PLAYER_CHOPPER]) >= 40000
|
|
STOP_PLAYBACK_RECORDED_VEHICLE(snatchAndGrabVehicle[SAGV_PLAYER_CHOPPER])
|
|
ENDIF
|
|
ENDIF
|
|
ELSE
|
|
IF IS_ENTITY_AT_COORD(sSelectorPeds.pedID[SELECTOR_PED_TREVOR], GET_ESCAPE_ROUTE_POINT(iTrevorEscapeRoutePoint), <<80,80,80>>)
|
|
INT iClosestPoint = GET_CLOSEST_ESCAPE_ROUTE_POINT()
|
|
IF iClosestPoint >= 0
|
|
iTrevorEscapeRoutePoint = iClosestPoint
|
|
printstring("do closest route") printnl()
|
|
TREVOR_FLY_TO_ESCAPE_ROUTE_POINT(iTrevorEscapeRoutePoint)
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
//ENDIF
|
|
ENDIF
|
|
ENDPROC
|
|
|
|
/*
|
|
// close all chopper doors
|
|
PROC CLOSE_ALL_CHOPPER_DOORS()
|
|
IF IS_VEHICLE_DRIVEABLE(snatchAndGrabVehicle[SAGV_PLAYER_CHOPPER])
|
|
SET_VEHICLE_DOOR_CONTROL(snatchAndGrabVehicle[SAGV_PLAYER_CHOPPER], SC_DOOR_FRONT_RIGHT, DT_DOOR_INTACT, 0.0)
|
|
SET_VEHICLE_DOOR_CONTROL(snatchAndGrabVehicle[SAGV_PLAYER_CHOPPER], SC_DOOR_FRONT_LEFT, DT_DOOR_INTACT, 0.0)
|
|
ENDIF
|
|
ENDPROC
|
|
*/
|
|
|
|
// close all chopper doors
|
|
PROC SHUT_ALL_CHOPPER_DOORS()
|
|
IF IS_VEHICLE_DRIVEABLE(snatchAndGrabVehicle[SAGV_PLAYER_CHOPPER])
|
|
SET_VEHICLE_DOOR_SHUT(snatchAndGrabVehicle[SAGV_PLAYER_CHOPPER], SC_DOOR_FRONT_RIGHT)
|
|
SET_VEHICLE_DOOR_SHUT(snatchAndGrabVehicle[SAGV_PLAYER_CHOPPER], SC_DOOR_FRONT_LEFT)
|
|
ENDIF
|
|
ENDPROC
|
|
|
|
/*
|
|
// latch all chopper doors
|
|
PROC LATCH_ALL_CHOPPER_DOORS()
|
|
IF IS_VEHICLE_DRIVEABLE(snatchAndGrabVehicle[SAGV_PLAYER_CHOPPER])
|
|
SET_VEHICLE_DOOR_LATCHED(snatchAndGrabVehicle[SAGV_PLAYER_CHOPPER], SC_DOOR_FRONT_RIGHT, TRUE, TRUE)
|
|
SET_VEHICLE_DOOR_LATCHED(snatchAndGrabVehicle[SAGV_PLAYER_CHOPPER], SC_DOOR_FRONT_LEFT, TRUE, TRUE)
|
|
ENDIF
|
|
ENDPROC
|
|
*/
|
|
|
|
// common stuff for cutscene skip
|
|
PROC HANDLE_SKIP_CUTSCENE()
|
|
IF IS_CUTSCENE_SKIP_BUTTON_JUST_PRESSED()
|
|
AND GET_GAME_TIMER() >= iAllowSkipCutsceneTime + 1000
|
|
// PRINTSTRING("handle skip cutscene!!!!") PRINTNL()
|
|
DO_SCREEN_FADE_OUT(DEFAULT_FADE_TIME)
|
|
WHILE NOT IS_SCREEN_FADED_OUT()
|
|
WAIT(0)
|
|
ENDWHILE
|
|
|
|
HANG_UP_AND_PUT_AWAY_PHONE()
|
|
KILL_ANY_CONVERSATION()
|
|
bSkippedCutscene = TRUE
|
|
cutsceneStage = SAG_CUT_STAGE_CLEANUP
|
|
ENDIF
|
|
ENDPROC
|
|
|
|
FUNC RAGDOLL_BLOCKING_FLAGS GET_STEVE_RAGDOLL_BLOCKING()
|
|
RETURN RBF_PLAYER_IMPACT | RBF_VEHICLE_IMPACT | RBF_IMPACT_OBJECT
|
|
ENDFUNC
|
|
|
|
// food court cutscene procedure
|
|
PROC DO_FOOD_COURT_CUTSCENE()
|
|
SET_ALL_RANDOM_PEDS_FLEE_THIS_FRAME(PLAYER_ID())
|
|
|
|
SWITCH cutsceneStage
|
|
CASE SAG_CUT_STAGE_INIT
|
|
iSnatchAndGrabCutsceneTime = GET_GAME_TIMER()
|
|
|
|
UPDATE_FOOD_COURT(TRUE, STAGE_GET_TO_CHOPPER)
|
|
|
|
REGISTER_ENTITY_FOR_CUTSCENE(PLAYER_PED_ID(), "Michael", CU_ANIMATE_EXISTING_SCRIPT_ENTITY)
|
|
|
|
IF NOT IS_PED_INJURED(davePed)
|
|
TASK_CLEAR_LOOK_AT(davePed)
|
|
REGISTER_ENTITY_FOR_CUTSCENE(davePed, "Dave_FBI", CU_ANIMATE_EXISTING_SCRIPT_ENTITY)
|
|
ENDIF
|
|
|
|
IF NOT IS_PED_INJURED(stevePed)
|
|
TASK_CLEAR_LOOK_AT(stevePed)
|
|
REGISTER_ENTITY_FOR_CUTSCENE(stevePed, "Steve_FBI", CU_ANIMATE_EXISTING_SCRIPT_ENTITY)
|
|
ENDIF
|
|
|
|
IF NOT IS_PED_INJURED(andreasPed)
|
|
TASK_CLEAR_LOOK_AT(andreasPed)
|
|
REGISTER_ENTITY_FOR_CUTSCENE(andreasPed, "Andreas_Sanchez", CU_ANIMATE_EXISTING_SCRIPT_ENTITY)
|
|
ENDIF
|
|
|
|
IF NOT IS_PED_INJURED(PLAYER_PED_ID())
|
|
TASK_CLEAR_LOOK_AT(PLAYER_PED_ID())
|
|
ENDIF
|
|
|
|
SET_VEHICLE_POPULATION_BUDGET(0)
|
|
SET_PED_POPULATION_BUDGET(0)
|
|
|
|
START_CUTSCENE()
|
|
SET_CUTSCENE_FADE_VALUES(FALSE, FALSE, FALSE, FALSE)
|
|
|
|
REPLAY_START_EVENT(REPLAY_IMPORTANCE_HIGHEST)
|
|
|
|
bSteveSeated = FALSE
|
|
bAndreasSeated = FALSE
|
|
|
|
cutsceneStage = SAG_CUT_STAGE_RUNNING
|
|
BREAK
|
|
|
|
CASE SAG_CUT_STAGE_RUNNING
|
|
IF NOT bClearedForCutscene
|
|
IF IS_CUTSCENE_PLAYING()
|
|
STOP_GAMEPLAY_HINT()
|
|
DISABLE_PEDS_AT_FOOD_COURT()
|
|
|
|
INT i
|
|
REPEAT 3 i
|
|
IF DOES_ENTITY_EXIST(coffeeObject[i])
|
|
DELETE_OBJECT(coffeeObject[i])
|
|
ENDIF
|
|
ENDREPEAT
|
|
|
|
RESOLVE_VEHICLES_INSIDE_ANGLED_AREA_WITH_SIZE_LIMIT(<<143.198, -672.684, 40.527>>, <<147.880, -682.373, 45.027>>, 11, <<137.951, -687.184, 41.02800>>, -73.60, GET_DEFAULT_ALLOWABLE_VEHICLE_SIZE_VECTOR(), TRUE, FALSE, TRUE)
|
|
RESOLVE_VEHICLES_INSIDE_ANGLED_AREA_WITH_SIZE_LIMIT(<<82.758, -675.976, 42.111>>, <<86.172, -666.734, 44.785>>, 10, <<78.49797, -686.12238, 43.10218>>, -23, GET_DEFAULT_ALLOWABLE_VEHICLE_SIZE_VECTOR(), TRUE, FALSE, TRUE)
|
|
|
|
CLEAR_AREA(<<148.27441, -677.23914, 41.84525>>, 3.5, TRUE)
|
|
CLEAR_AREA_OF_PROJECTILES(<<148.27441, -677.23914, 41.84525>>, 20)
|
|
STOP_FIRE_IN_RANGE(<<148.27441, -677.23914, 41.84525>>, 20)
|
|
REMOVE_PARTICLE_FX_IN_RANGE(<<148.27441, -677.23914, 41.84525>>, 20)
|
|
|
|
PREVENT_WANTED_LEVEL_FOR_CUTSCENE()
|
|
REMOVE_ALL_BLIPS()
|
|
SET_MISSION_MOCAP_CUTSCENE()
|
|
|
|
IF IS_SCREEN_FADED_OUT()
|
|
DO_SCREEN_FADE_IN(DEFAULT_FADE_TIME)
|
|
ENDIF
|
|
|
|
bClearedForCutscene = TRUE
|
|
ENDIF
|
|
ENDIF
|
|
|
|
SET_PED_DENSITY_MULTIPLIER_THIS_FRAME(0.0)
|
|
SET_VEHICLE_DENSITY_MULTIPLIER_THIS_FRAME(0.0)
|
|
|
|
// 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_CHOPPER)
|
|
bDoneIntroCreateEntities = TRUE
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF NOT bPrestreamedLine
|
|
IF GET_GAME_TIMER() >= 1000
|
|
PRELOAD_CONVERSATION(snatchAndGrabConversation, "FBI2AUD", "FBI2_OLDDOG", CONV_PRIORITY_MEDIUM)
|
|
bPrestreamedLine = TRUE
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF CAN_SET_EXIT_STATE_FOR_REGISTERED_ENTITY("prop_chair_01a")
|
|
AND CAN_SET_EXIT_STATE_FOR_REGISTERED_ENTITY("prop_chair_01a^1")
|
|
AND CAN_SET_EXIT_STATE_FOR_REGISTERED_ENTITY("prop_chair_01a^2")
|
|
AND CAN_SET_EXIT_STATE_FOR_REGISTERED_ENTITY("prop_chair_01a^3")
|
|
|
|
ENDIF
|
|
|
|
IF WAS_CUTSCENE_SKIPPED()
|
|
bSkippedCutscene = TRUE
|
|
ENDIF
|
|
|
|
IF CAN_SET_EXIT_STATE_FOR_REGISTERED_ENTITY("Michael")
|
|
SET_ENTITY_COORDS(PLAYER_PED_ID(), GET_SNATCH_AND_GRAB_VECTOR(SAGVEC_PLAYER_INIT2))
|
|
SET_ENTITY_HEADING(PLAYER_PED_ID(), PLAYER_INIT_ROT2)
|
|
|
|
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
|
|
bSetMichaelToWalk = TRUE
|
|
ELSE
|
|
IF bSetMichaelToWalk
|
|
SET_PED_MIN_MOVE_BLEND_RATIO(PLAYER_PED_ID(), PEDMOVE_WALK)
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF CAN_SET_EXIT_STATE_FOR_REGISTERED_ENTITY("Dave_FBI")
|
|
IF NOT IS_PED_INJURED(davePed)
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF CAN_SET_EXIT_STATE_FOR_REGISTERED_ENTITY("Steve_FBI")
|
|
SET_STEVE_SEATED(FALSE)
|
|
ENDIF
|
|
|
|
IF CAN_SET_EXIT_STATE_FOR_REGISTERED_ENTITY("Andreas_Sanchez")
|
|
SET_ANDREAS_SEATED(FALSE)
|
|
ENDIF
|
|
|
|
IF CAN_SET_EXIT_STATE_FOR_CAMERA()
|
|
BOOL bCacheSkippedCutscene
|
|
bCacheSkippedCutscene = bSkippedCutscene
|
|
IF bCacheSkippedCutscene
|
|
bPrestreamedLine = FALSE
|
|
ENDIF
|
|
SET_MISSION_CUTSCENE(FALSE, TRUE, FALSE, FALSE, FALSE, FALSE)
|
|
SET_MISSION_STAGE(STAGE_GET_TO_CHOPPER, bCacheSkippedCutscene, FALSE, TRUE, FALSE, FALSE)
|
|
SET_GAMEPLAY_CAM_RELATIVE_HEADING()
|
|
SET_GAMEPLAY_CAM_RELATIVE_PITCH()
|
|
|
|
REPLAY_STOP_EVENT()
|
|
|
|
ENDIF
|
|
|
|
#IF IS_DEBUG_BUILD
|
|
IF IS_KEYBOARD_KEY_JUST_PRESSED(KEY_J)
|
|
STOP_CUTSCENE()
|
|
WHILE NOT IS_SCREEN_FADED_OUT()
|
|
WAIT(0)
|
|
ENDWHILE
|
|
ENDIF
|
|
#ENDIF
|
|
BREAK
|
|
|
|
CASE SAG_CUT_STAGE_CLEANUP
|
|
BREAK
|
|
ENDSWITCH
|
|
ENDPROC
|
|
|
|
PROC FAIL_FOOD_COURT()
|
|
// fail for messing around at food court
|
|
IF IS_PED_SHOOTING_IN_AREA(PLAYER_PED_ID(), <<112.42545, -697.93341, 38.02730>>, <<180.05025, -654.66302, 53.14103>>, FALSE)
|
|
OR IS_EXPLOSION_IN_AREA(EXP_TAG_DONTCARE, <<112.42545, -697.93341, 38.02730>>, <<180.05025, -654.66302, 53.14103>>)
|
|
OR (currentMissionStage = STAGE_FOOD_COURT AND GET_PLAYER_WANTED_LEVEL(PLAYER_ID()) > 0)
|
|
OR (NOT bDaveInCar AND GET_PLAYER_WANTED_LEVEL(PLAYER_ID()) > 0)
|
|
MISSION_FAILED(FAIL_TROUBLE_FOOD_COURT)
|
|
ENDIF
|
|
|
|
IF IS_PED_IN_ANY_VEHICLE(PLAYER_PED_ID())
|
|
VEHICLE_INDEX playerVehicle = GET_VEHICLE_PED_IS_USING(PLAYER_PED_ID())
|
|
IF IS_VEHICLE_DRIVEABLE(playerVehicle)
|
|
IF GET_ENTITY_SPEED(playerVehicle) >= 1
|
|
IF DOES_ENTITY_EXIST(foodCourtChairObject[0])
|
|
IF IS_ENTITY_TOUCHING_ENTITY(playerVehicle, foodCourtChairObject[0])
|
|
MISSION_FAILED(FAIL_TROUBLE_FOOD_COURT)
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF DOES_ENTITY_EXIST(foodCourtChairObject[2])
|
|
IF IS_ENTITY_TOUCHING_ENTITY(playerVehicle, foodCourtChairObject[2])
|
|
MISSION_FAILED(FAIL_TROUBLE_FOOD_COURT)
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDPROC
|
|
|
|
// do food court stage
|
|
PROC DO_STAGE_FOOD_COURT()
|
|
IF NOT bRunningCutscene
|
|
UPDATE_FOOD_COURT(FALSE, STAGE_FOOD_COURT)
|
|
|
|
IF NOT bShownGodText
|
|
bShownGodText = DO_MISSION_GOD_TEXT("SG_GDAVE", TRUE, TRUE)
|
|
ENDIF
|
|
|
|
// fails
|
|
IF DOES_ENTITY_EXIST(stevePed)
|
|
IF IS_PED_INJURED(stevePed)
|
|
MISSION_FAILED(FAIL_STEVE_DEAD)
|
|
ELSE
|
|
IF HAS_ENTITY_BEEN_DAMAGED_BY_ENTITY(stevePed, PLAYER_PED_ID())
|
|
MISSION_FAILED(FAIL_TROUBLE_FOOD_COURT)
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
IF DOES_ENTITY_EXIST(andreasPed)
|
|
IF IS_PED_INJURED(andreasPed)
|
|
MISSION_FAILED(FAIL_ANDREAS_DEAD)
|
|
ELSE
|
|
IF HAS_ENTITY_BEEN_DAMAGED_BY_ENTITY(andreasPed, PLAYER_PED_ID())
|
|
MISSION_FAILED(FAIL_TROUBLE_FOOD_COURT)
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
IF DOES_ENTITY_EXIST(davePed)
|
|
IF IS_PED_INJURED(davePed)
|
|
MISSION_FAILED(FAIL_DAVE_DEAD)
|
|
ELSE
|
|
IF GET_DISTANCE_BETWEEN_ENTITIES(PLAYER_PED_ID(), davePed, FALSE) > ABANDON_BUDDY_FAIL_RANGE
|
|
MISSION_FAILED(FAIL_ABANDONED_DAVE)
|
|
ENDIF
|
|
|
|
IF HAS_ENTITY_BEEN_DAMAGED_BY_ENTITY(davePed, PLAYER_PED_ID())
|
|
MISSION_FAILED(FAIL_TROUBLE_FOOD_COURT)
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
|
|
FAIL_FOOD_COURT()
|
|
|
|
// force walk
|
|
IF GET_FOLLOW_PED_CAM_VIEW_MODE() <> CAM_VIEW_MODE_FIRST_PERSON
|
|
IF GET_GAME_TIMER() <= iStartMissionStageTime + 1300
|
|
SET_PED_MIN_MOVE_BLEND_RATIO(PLAYER_PED_ID(), PEDMOVE_WALK)
|
|
ENDIF
|
|
ENDIF
|
|
|
|
VECTOR vTriggerPosition = <<149.32559, -678.15710, 41.02899>>
|
|
VECTOR vPlayerPos = GET_ENTITY_COORDS(PLAYER_PED_ID())
|
|
FLOAT fDistanceSquaredFromTrigger = VDIST2(vPlayerPos, vTriggerPosition)
|
|
BOOL bDoHintCam = FALSE
|
|
|
|
IF fDistanceSquaredFromTrigger < (14.0 * 14.0)
|
|
IF NOT IS_PED_IN_ANY_VEHICLE(PLAYER_PED_ID())
|
|
|
|
SET_PED_MAX_MOVE_BLEND_RATIO(PLAYER_PED_ID(), PEDMOVE_WALK)
|
|
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 fDistanceSquaredFromTrigger < (8 * 8)
|
|
SET_GAMEPLAY_HINT_CAMERA_BLEND_TO_FOLLOW_PED_MEDIUM_VIEW_MODE(TRUE)
|
|
IF GET_FOLLOW_PED_CAM_VIEW_MODE() <> CAM_VIEW_MODE_FIRST_PERSON
|
|
SET_GAMEPLAY_COORD_HINT(<<147.9,-676.0, 42.2>>, -1, 2000)
|
|
SET_GAMEPLAY_HINT_CAMERA_RELATIVE_SIDE_OFFSET(0.02)
|
|
SET_GAMEPLAY_HINT_CAMERA_RELATIVE_VERTICAL_OFFSET(-0.01)
|
|
ELSE
|
|
SET_GAMEPLAY_COORD_HINT(<<148.6, -677.0, 42.3>>, -1, 2000)
|
|
SET_GAMEPLAY_HINT_CAMERA_RELATIVE_SIDE_OFFSET(0)
|
|
SET_GAMEPLAY_HINT_CAMERA_RELATIVE_VERTICAL_OFFSET(0)
|
|
ENDIF
|
|
SET_GAMEPLAY_HINT_FOLLOW_DISTANCE_SCALAR(0.4)
|
|
|
|
SET_GAMEPLAY_HINT_FOV(40)
|
|
bDoHintCam = TRUE
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF NOT bDoHintCam
|
|
STOP_GAMEPLAY_HINT()
|
|
ENDIF
|
|
|
|
IF NOT bTriggeredGreetingAnim
|
|
|
|
|
|
|
|
HANDLE_STREAMING_MOCAP("fbi_2_int", <<149.32559, -678.15710, 41.02899>>, 28, 40)
|
|
IF CAN_REQUEST_ASSETS_FOR_CUTSCENE_ENTITY()
|
|
IF NOT IS_PED_INJURED(davePed)
|
|
SET_CUTSCENE_PED_COMPONENT_VARIATION_FROM_PED("Dave_FBI", davePed)
|
|
ENDIF
|
|
IF NOT IS_PED_INJURED(stevePed)
|
|
SET_CUTSCENE_PED_COMPONENT_VARIATION_FROM_PED("Steve_FBI", stevePed)
|
|
ENDIF
|
|
IF NOT IS_PED_INJURED(andreasPed)
|
|
SET_CUTSCENE_PED_COMPONENT_VARIATION_FROM_PED("Andreas_Sanchez", andreasPed)
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF fDistanceSquaredFromTrigger < (9*9)
|
|
IF vPlayerPos.z > 41.0 AND vPlayerPos.z < 44.0
|
|
iSyncScene = CREATE_SYNCHRONIZED_SCENE(<<148.31, -677.19, 41.02>>, <<0,0,0>>)
|
|
|
|
IF NOT IS_PED_INJURED(davePed)
|
|
TASK_LOOK_AT_ENTITY(PLAYER_PED_ID(), davePed, -1, SLF_WHILE_NOT_IN_FOV)
|
|
TASK_SYNCHRONIZED_SCENE(davePed, iSyncScene, "MISSFBI2@LeadInOut", "FBI_2_INT_LeadIn_action_DaveN", NORMAL_BLEND_IN, NORMAL_BLEND_OUT, SYNCED_SCENE_USE_PHYSICS | SYNCED_SCENE_DONT_INTERRUPT, GET_STEVE_RAGDOLL_BLOCKING())
|
|
// TASK_LOOK_AT_ENTITY(davePed, PLAYER_PED_ID(), -1, SLF_WHILE_NOT_IN_FOV, SLF_LOOKAT_VERY_HIGH)
|
|
ENDIF
|
|
|
|
IF NOT IS_PED_INJURED(stevePed)
|
|
TASK_SYNCHRONIZED_SCENE(stevePed, iSyncScene, "MISSFBI2@LeadInOut", "FBI_2_INT_LeadIn_action_Steve", NORMAL_BLEND_IN, NORMAL_BLEND_OUT, SYNCED_SCENE_USE_PHYSICS | SYNCED_SCENE_DONT_INTERRUPT, GET_STEVE_RAGDOLL_BLOCKING())
|
|
TASK_LOOK_AT_ENTITY(stevePed, PLAYER_PED_ID(), -1, SLF_WHILE_NOT_IN_FOV, SLF_LOOKAT_VERY_HIGH)
|
|
ENDIF
|
|
|
|
IF NOT IS_PED_INJURED(andreasPed)
|
|
TASK_SYNCHRONIZED_SCENE(andreasPed, iSyncScene, "MISSFBI2@LeadInOut", "FBI_2_INT_LeadIn_action_Andreas", NORMAL_BLEND_IN, NORMAL_BLEND_OUT, SYNCED_SCENE_USE_PHYSICS | SYNCED_SCENE_DONT_INTERRUPT, GET_STEVE_RAGDOLL_BLOCKING())
|
|
TASK_LOOK_AT_ENTITY(andreasPed, PLAYER_PED_ID(), -1, SLF_WHILE_NOT_IN_FOV, SLF_LOOKAT_VERY_HIGH)
|
|
ENDIF
|
|
|
|
bTriggeredGreetingAnim = TRUE
|
|
ENDIF
|
|
ENDIF
|
|
ELSE
|
|
IF IS_PED_IN_ANY_VEHICLE(PLAYER_PED_ID())
|
|
IF IS_VEHICLE_DRIVEABLE(GET_VEHICLE_PED_IS_IN(PLAYER_PED_ID()))
|
|
IF BRING_VEHICLE_TO_HALT_AND_DISABLE_VEH_CONTROLS(GET_VEHICLE_PED_IS_IN(PLAYER_PED_ID()), 10)
|
|
IF NOT bPlayerLeaveVehicle
|
|
TASK_LEAVE_ANY_VEHICLE(PLAYER_PED_ID())
|
|
bPlayerLeaveVehicle = TRUE
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF NOT bTriggeredGreetingSpeech
|
|
IF NOT IS_PED_INJURED(davePed)
|
|
IF IS_SYNCHRONIZED_SCENE_RUNNING(iSyncScene)
|
|
IF GET_SYNCHRONIZED_SCENE_PHASE(iSyncScene) >= 0.25
|
|
bTriggeredGreetingSpeech = DO_MISSION_SPEECH("FBI2_INTL", TRUE)
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF CAN_PLAYER_START_CUTSCENE()
|
|
AND NOT IS_ANY_CONVERSATION_ONGOING_OR_QUEUED()
|
|
AND CAN_ADVANCE_MISSION()
|
|
IF IS_SYNCHRONIZED_SCENE_RUNNING(iSyncScene)
|
|
IF GET_SYNCHRONIZED_SCENE_PHASE(iSyncScene) >= 0.80
|
|
IF HAS_CUTSCENE_LOADED_WITH_FAILSAFE()
|
|
bRunningCutscene = TRUE
|
|
ENDIF
|
|
ENDIF
|
|
ELSE
|
|
IF HAS_CUTSCENE_LOADED_WITH_FAILSAFE()
|
|
bRunningCutscene = TRUE
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ELSE
|
|
DO_FOOD_COURT_CUTSCENE()
|
|
ENDIF
|
|
ENDPROC
|
|
|
|
// cleanup meeting cutscene
|
|
PROC CLEANUP_MEETING_CUTSCENE()
|
|
IF bSkippedCutscene
|
|
ENDIF
|
|
|
|
SETUP_PLAYER_CHARACTER_WITH_MISSION_VARIATIONS(sSelectorPeds.pedID[SELECTOR_PED_MICHAEL], CHAR_MICHAEL, STAGE_GET_TO_BUILDING)
|
|
|
|
IF g_bMagDemoActive
|
|
IF IS_VEHICLE_DRIVEABLE(snatchAndGrabVehicle[SAGV_MICHAEL_CAR])
|
|
SET_ENTITY_AS_MISSION_ENTITY(snatchAndGrabVehicle[SAGV_MICHAEL_CAR], TRUE, TRUE)
|
|
ENDIF
|
|
ENDIF
|
|
|
|
CLEANUP_FBI(TRUE)
|
|
//CLEANUP_FRANKLIN(TRUE)
|
|
CLEANUP_DAVE(TRUE)
|
|
|
|
IF IS_VEHICLE_DRIVEABLE(snatchAndGrabVehicle[SAGV_PLAYER_CHOPPER])
|
|
SET_PLAYER_PED_WITH_HEADSET(CHAR_TREVOR, TRUE)
|
|
SET_PLAYER_PED_WITH_HEADSET(CHAR_MICHAEL, TRUE)
|
|
IF NOT IS_PED_INJURED(PLAYER_PED_ID())
|
|
SET_PED_INTO_VEHICLE(PLAYER_PED_ID(), snatchAndGrabVehicle[SAGV_PLAYER_CHOPPER], VS_DRIVER)
|
|
ENDIF
|
|
IF NOT IS_PED_INJURED(sSelectorPeds.pedID[SELECTOR_PED_MICHAEL])
|
|
SET_PED_INTO_VEHICLE(sSelectorPeds.pedID[SELECTOR_PED_MICHAEL], snatchAndGrabVehicle[SAGV_PLAYER_CHOPPER], VS_BACK_LEFT)
|
|
DO_MICHAEL_SIT_IN_CHOPPER()
|
|
//SET_PED_SIT_IDLE_ANIM(sSelectorPeds.pedID[SELECTOR_PED_MICHAEL], "VEH@STD@FRONT_PS", "sit", TRUE)
|
|
ENDIF
|
|
//SET_ENTITY_COORDS(snatchAndGrabVehicle[SAGV_PLAYER_CHOPPER], GET_SNATCH_AND_GRAB_VECTOR(SAGVEC_CHOPPER_INIT))
|
|
//SET_ENTITY_HEADING(snatchAndGrabVehicle[SAGV_PLAYER_CHOPPER], CHOPPER_INIT_ROT)
|
|
//SET_VEHICLE_ON_GROUND_PROPERLY(snatchAndGrabVehicle[SAGV_PLAYER_CHOPPER])
|
|
//CLOSE_ALL_CHOPPER_DOORS()
|
|
SHUT_ALL_CHOPPER_DOORS()
|
|
ENDIF
|
|
|
|
IF bSkippedCutscene
|
|
ENDIF
|
|
|
|
//TRIGGER_MISSION_MUSIC_EVENT("FBI2_TEST_HELI_RIDE_MUSIC")
|
|
SET_MISSION_CUTSCENE(FALSE, TRUE, TRUE, TRUE, FALSE)
|
|
SET_MISSION_STAGE(STAGE_GET_TO_BUILDING, FALSE, TRUE, FALSE)
|
|
ENDPROC
|
|
|
|
// meeting cutscene procedure
|
|
PROC DO_MEETING_CUTSCENE()
|
|
SET_ALL_RANDOM_PEDS_FLEE_THIS_FRAME(PLAYER_ID())
|
|
|
|
SWITCH cutsceneStage
|
|
CASE SAG_CUT_STAGE_INIT
|
|
//SET_MISSION_CUTSCENE(TRUE)
|
|
iSnatchAndGrabCutsceneTime = GET_GAME_TIMER()
|
|
|
|
IF NOT IS_PED_INJURED(sSelectorPeds.pedID[SELECTOR_PED_TREVOR])
|
|
REGISTER_ENTITY_FOR_CUTSCENE(sSelectorPeds.pedID[SELECTOR_PED_TREVOR], "Trevor", CU_ANIMATE_EXISTING_SCRIPT_ENTITY)
|
|
ENDIF
|
|
IF NOT IS_PED_INJURED(sSelectorPeds.pedID[SELECTOR_PED_FRANKLIN])
|
|
DETACH_ENTITY(sSelectorPeds.pedID[SELECTOR_PED_FRANKLIN])
|
|
REGISTER_ENTITY_FOR_CUTSCENE(sSelectorPeds.pedID[SELECTOR_PED_FRANKLIN], "Franklin", CU_ANIMATE_AND_DELETE_EXISTING_SCRIPT_ENTITY)
|
|
ENDIF
|
|
IF NOT IS_PED_INJURED(PLAYER_PED_ID())
|
|
TASK_CLEAR_LOOK_AT(PLAYER_PED_ID())
|
|
REGISTER_ENTITY_FOR_CUTSCENE(PLAYER_PED_ID(), "Michael", CU_ANIMATE_EXISTING_SCRIPT_ENTITY)
|
|
ENDIF
|
|
IF NOT IS_PED_INJURED(davePed)
|
|
REGISTER_ENTITY_FOR_CUTSCENE(davePed, "Dave_FBI", CU_ANIMATE_AND_DELETE_EXISTING_SCRIPT_ENTITY)
|
|
ENDIF
|
|
IF NOT IS_PED_INJURED(fbiPed[0])
|
|
REGISTER_ENTITY_FOR_CUTSCENE(fbiPed[0], "FBI_Suit", CU_ANIMATE_AND_DELETE_EXISTING_SCRIPT_ENTITY)
|
|
ENDIF
|
|
IF IS_VEHICLE_DRIVEABLE(snatchAndGrabVehicle[SAGV_PLAYER_CHOPPER])
|
|
REQUEST_VEHICLE_HIGH_DETAIL_MODEL(snatchAndGrabVehicle[SAGV_PLAYER_CHOPPER])
|
|
REGISTER_ENTITY_FOR_CUTSCENE(snatchAndGrabVehicle[SAGV_PLAYER_CHOPPER], "Main_Heli", CU_ANIMATE_EXISTING_SCRIPT_ENTITY)
|
|
ENDIF
|
|
IF IS_VEHICLE_DRIVEABLE(snatchAndGrabVehicle[SAGV_MICHAEL_CAR])
|
|
REGISTER_ENTITY_FOR_CUTSCENE(snatchAndGrabVehicle[SAGV_MICHAEL_CAR], "Michaels_car", CU_ANIMATE_AND_DELETE_EXISTING_SCRIPT_ENTITY)
|
|
ENDIF
|
|
IF IS_VEHICLE_DRIVEABLE(snatchAndGrabVehicle[SAGV_FRANKLIN_BIKE])
|
|
FREEZE_ENTITY_POSITION(snatchAndGrabVehicle[SAGV_FRANKLIN_BIKE], FALSE)
|
|
SET_CAN_CLIMB_ON_ENTITY(snatchAndGrabVehicle[SAGV_FRANKLIN_BIKE], FALSE)
|
|
REGISTER_ENTITY_FOR_CUTSCENE(snatchAndGrabVehicle[SAGV_FRANKLIN_BIKE], "Franklin_Bike", CU_ANIMATE_AND_DELETE_EXISTING_SCRIPT_ENTITY)
|
|
ENDIF
|
|
|
|
REPLAY_START_EVENT(REPLAY_IMPORTANCE_HIGHEST)
|
|
|
|
START_CUTSCENE(CUTSCENE_SUPPRESS_FP_TRANSITION_FLASH)
|
|
SET_CUTSCENE_FADE_VALUES(FALSE, FALSE, FALSE, FALSE)
|
|
|
|
bDoneFlash = FALSE
|
|
|
|
cutsceneStage = SAG_CUT_STAGE_RUNNING
|
|
BREAK
|
|
|
|
CASE SAG_CUT_STAGE_RUNNING
|
|
IF NOT bClearedForCutscene
|
|
IF IS_CUTSCENE_PLAYING()
|
|
SET_MISSION_MOCAP_CUTSCENE()
|
|
|
|
STOP_GAMEPLAY_HINT()
|
|
|
|
IF IS_VEHICLE_DRIVEABLE(snatchAndGrabVehicle[SAGV_MICHAEL_CAR])
|
|
SET_VEHICLE_DOOR_CONTROL(snatchAndGrabVehicle[SAGV_MICHAEL_CAR], SC_DOOR_FRONT_LEFT, DT_DOOR_INTACT, 0.0)
|
|
ENDIF
|
|
STOP_VEHICLE_FIRE(snatchAndGrabVehicle[SAGV_MICHAEL_CAR])
|
|
|
|
IF IS_VEHICLE_DRIVEABLE(snatchAndGrabVehicle[SAGV_PLAYER_CHOPPER])
|
|
SET_VEHICLE_DOORS_LOCKED(snatchAndGrabVehicle[SAGV_PLAYER_CHOPPER], VEHICLELOCK_UNLOCKED)
|
|
ENDIF
|
|
STOP_VEHICLE_FIRE(snatchAndGrabVehicle[SAGV_PLAYER_CHOPPER])
|
|
|
|
IF NOT IS_PED_INJURED(sSelectorPeds.pedID[SELECTOR_PED_FRANKLIN])
|
|
TASK_CLEAR_LOOK_AT(sSelectorPeds.pedID[SELECTOR_PED_FRANKLIN])
|
|
ENDIF
|
|
|
|
IF DOES_ENTITY_EXIST(davePed)
|
|
DELETE_PED(davePed)
|
|
CLEAR_MODEL_REQUEST(ENUM_TO_INT(SAGM_DAVE))
|
|
ENDIF
|
|
|
|
SET_VEHICLE_POPULATION_BUDGET(2)
|
|
SET_PED_POPULATION_BUDGET(1)
|
|
|
|
STOP_SNATCH_AND_GRAB_AUDIO_SCENE(SNATCH_AND_GRAB_AUDIO_SCENE_DRIVE_TO_LOT)
|
|
|
|
// clear the area
|
|
CLEAR_AREA(GET_SNATCH_AND_GRAB_VECTOR(SAGVEC_TREVOR_INIT), 20.0, TRUE)
|
|
CLEAR_AREA_OF_PROJECTILES(GET_SNATCH_AND_GRAB_VECTOR(SAGVEC_TREVOR_INIT), 30)
|
|
STOP_FIRE_IN_RANGE(GET_SNATCH_AND_GRAB_VECTOR(SAGVEC_TREVOR_INIT), 30)
|
|
REMOVE_PARTICLE_FX_IN_RANGE(GET_SNATCH_AND_GRAB_VECTOR(SAGVEC_TREVOR_INIT), 30)
|
|
|
|
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
|
|
ELSE
|
|
IF IS_VEHICLE_DRIVEABLE(snatchAndGrabVehicle[SAGV_PLAYER_CHOPPER])
|
|
REQUEST_VEHICLE_HIGH_DETAIL_MODEL(snatchAndGrabVehicle[SAGV_PLAYER_CHOPPER])
|
|
ENDIF
|
|
ENDIF
|
|
|
|
//HANDLE_CREATE_FOLLOW_CAM_ON_FLY()
|
|
|
|
// Fading the music out over the cutscene
|
|
IF NOT bMusicFaded
|
|
IF GET_CUTSCENE_TIME() >= 0
|
|
//TRIGGER_MISSION_MUSIC_EVENT("FBI2_TEST_ARRIVE_AT_HELI")
|
|
bMusicFaded = TRUE
|
|
ENDIF
|
|
ENDIF
|
|
|
|
// Bringing in music when Michael briefs others about job.
|
|
IF NOT bMeetingCutsceneMusicStart
|
|
IF GET_CUTSCENE_TIME() >= 98000.0
|
|
//TRIGGER_MISSION_MUSIC_EVENT("FBI2_TEST_HELI_CS_JOB_TALK")
|
|
bMeetingCutsceneMusicStart = TRUE
|
|
ENDIF
|
|
ENDIF
|
|
|
|
// Bringing the music back out after briefing.
|
|
IF NOT bMeetingCutsceneMusicEnd
|
|
IF GET_CUTSCENE_TIME() >= 112000.0
|
|
//TRIGGER_MISSION_MUSIC_EVENT("FBI2_TEST_STOP_HELI_CS_MUSIC")
|
|
bMeetingCutsceneMusicEnd = TRUE
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF NOT bChangedClothes
|
|
IF GET_CUTSCENE_TIME() >= 74975.0
|
|
// CLEANUP_FBI(TRUE)
|
|
// CLEANUP_DAVE(TRUE)
|
|
SETUP_PLAYER_CHARACTER_WITH_MISSION_VARIATIONS(PLAYER_PED_ID(), CHAR_MICHAEL, STAGE_GET_TO_BUILDING)
|
|
//CLEAR_PED_PROP(PLAYER_PED_ID(), ANCHOR_HEAD)
|
|
REMOVE_PED_HELMET(PLAYER_PED_ID(), TRUE)
|
|
bChangedClothes = TRUE
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF NOT bRemovedFBICar
|
|
IF GET_CUTSCENE_TIME() >= 15423 // delete FBI car
|
|
IF DOES_ENTITY_EXIST(utilTruckVehicle[2])
|
|
DELETE_VEHICLE(utilTruckVehicle[2])
|
|
ENDIF
|
|
CLEAR_MODEL_REQUEST(ENUM_TO_INT(SAGM_FBI_CAR))
|
|
bRemovedFBICar = TRUE
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF NOT bDoneFlash
|
|
IF GET_CAM_VIEW_MODE_FOR_CONTEXT(CAM_VIEW_MODE_CONTEXT_IN_HELI) = CAM_VIEW_MODE_FIRST_PERSON
|
|
IF GET_CUTSCENE_TIME() >= GET_CUTSCENE_TOTAL_DURATION() - 300
|
|
ANIMPOSTFX_PLAY("CamPushInTrevor", 0, FALSE)
|
|
PLAY_SOUND_FRONTEND(-1, "1st_Person_Transition", "PLAYER_SWITCH_CUSTOM_SOUNDSET")
|
|
bDoneFlash = TRUE
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
|
|
|
|
PED_INDEX trevorPed
|
|
trevorPed = GET_TREVOR_PED()
|
|
PED_INDEX michaelped
|
|
michaelped = GET_MICHAEL_PED()
|
|
|
|
IF IS_VEHICLE_DRIVEABLE(snatchAndGrabVehicle[SAGV_PLAYER_CHOPPER])
|
|
AND NOT IS_PED_INJURED(trevorPed)
|
|
AND NOT IS_PED_INJURED(michaelped)
|
|
IF CAN_SET_EXIT_STATE_FOR_REGISTERED_ENTITY("Trevor")
|
|
SET_PED_INTO_VEHICLE(trevorPed, snatchAndGrabVehicle[SAGV_PLAYER_CHOPPER])
|
|
CASCADE_SHADOWS_SET_CASCADE_BOUNDS_SCALE(1.0)
|
|
ENDIF
|
|
|
|
IF CAN_SET_EXIT_STATE_FOR_REGISTERED_ENTITY("Michael")
|
|
SET_PED_INTO_VEHICLE(michaelped, snatchAndGrabVehicle[SAGV_PLAYER_CHOPPER], VS_BACK_LEFT)
|
|
SETUP_PLAYER_CHARACTER_WITH_MISSION_VARIATIONS(PLAYER_PED_ID(), CHAR_MICHAEL, STAGE_GET_TO_BUILDING)
|
|
ENDIF
|
|
|
|
IF CAN_SET_EXIT_STATE_FOR_REGISTERED_ENTITY("Main_heli")
|
|
SHUT_ALL_CHOPPER_DOORS()
|
|
|
|
// delete FBI car
|
|
IF DOES_ENTITY_EXIST(utilTruckVehicle[2])
|
|
DELETE_VEHICLE(utilTruckVehicle[2])
|
|
ENDIF
|
|
|
|
MAKE_SELECTOR_PED_SELECTION(sSelectorPeds, SELECTOR_PED_TREVOR)
|
|
TAKE_CONTROL_OF_SELECTOR_PED(sSelectorPeds, TRUE, TRUE)
|
|
REAPPLY_PLAYER_PED_ATTRIBUTES()
|
|
|
|
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF NOT IS_CUTSCENE_PLAYING()
|
|
IF WAS_CUTSCENE_SKIPPED()
|
|
bSkippedCutscene = TRUE
|
|
ENDIF
|
|
REPLAY_STOP_EVENT()
|
|
REPLAY_RECORD_BACK_FOR_TIME(0.0, 10.0)
|
|
CLEANUP_MEETING_CUTSCENE()
|
|
ENDIF
|
|
//ENDIF
|
|
|
|
#IF IS_DEBUG_BUILD
|
|
DEBUG_SKIP_MOCAP()
|
|
#ENDIF
|
|
BREAK
|
|
|
|
CASE SAG_CUT_STAGE_CLEANUP
|
|
//CLEANUP_MEETING_CUTSCENE()
|
|
BREAK
|
|
ENDSWITCH
|
|
ENDPROC
|
|
|
|
// get to the choppah
|
|
PROC DO_STAGE_GET_TO_CHOPPER()
|
|
IF NOT bRunningCutscene
|
|
|
|
IF NOT bFrozeChairs
|
|
IF NOT IS_CUTSCENE_PLAYING()
|
|
INT i
|
|
REPEAT NUMBER_FOOD_COURT_CHAIRS i
|
|
IF i=0
|
|
SET_ENTITY_COORDS(foodCourtChairObject[i], << 147.4805, -677.4504, 41.0238 >>)
|
|
SET_ENTITY_ROTATION(foodCourtChairObject[i], << 0, 0, 100.84 >>)
|
|
ENDIF
|
|
|
|
IF i=2
|
|
SET_ENTITY_COORDS(foodCourtChairObject[i], << 147.8508, -676.3236, 41.0238 >> )
|
|
SET_ENTITY_ROTATION(foodCourtChairObject[i], << 0, 0, 36.0963 >>)
|
|
ENDIF
|
|
|
|
IF i=0 OR i=2 OR i=4
|
|
IF DOES_ENTITY_EXIST(foodCourtChairObject[i])
|
|
FREEZE_ENTITY_POSITION(foodCourtChairObject[i], TRUE)
|
|
ENDIF
|
|
ENDIF
|
|
ENDREPEAT
|
|
|
|
CREATE_COFFEE()
|
|
bFrozeChairs = TRUE
|
|
ENDIF
|
|
ENDIF
|
|
|
|
// force walk
|
|
IF GET_FOLLOW_PED_CAM_VIEW_MODE() <> CAM_VIEW_MODE_FIRST_PERSON
|
|
IF GET_GAME_TIMER() <= iStartMissionStageTime + 2000
|
|
VECTOR vPlayerPosForLeadout = GET_ENTITY_COORDS(PLAYER_PED_ID())
|
|
IF vPlayerPosForLeadout.x > 145.2
|
|
SET_PED_MIN_MOVE_BLEND_RATIO(PLAYER_PED_ID(), PEDMOVE_WALK)
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
|
|
INT iWanted = GET_PLAYER_WANTED_LEVEL(PLAYER_ID())
|
|
IF NOT bForcePassOnShitskip
|
|
IF iWanted > 0
|
|
IF IS_ENTITY_IN_ANGLED_AREA(PLAYER_PED_ID(), <<1370.22, -2049.72, -10.00>>, <<1401.82, -2087.40, 110.00>>, 97.00)
|
|
MISSION_FAILED(FAIL_ATTRACTED_COPS)
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF g_bMagDemoActive
|
|
bShownGodText = TRUE
|
|
ENDIF
|
|
|
|
IF bForcePassOnShitskip
|
|
IF NOT bWarpedToLot
|
|
IF IS_VEHICLE_DRIVEABLE(snatchAndGrabVehicle[SAGV_MICHAEL_CAR])
|
|
IF NOT IS_PED_INJURED(davePed)
|
|
IF NOT IS_PED_IN_VEHICLE(davePed, snatchAndGrabVehicle[SAGV_MICHAEL_CAR])
|
|
SET_PED_INTO_VEHICLE(davePed, snatchAndGrabVehicle[SAGV_MICHAEL_CAR], VS_FRONT_RIGHT)
|
|
ENDIF
|
|
ENDIF
|
|
bDaveInCar = TRUE
|
|
bWarpedToLot = TRUE
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF NOT bForcePassOnShitskip
|
|
HANDLE_BUDDY_ACTION_MODE_WHILE_WANTED(davePed, bDaveActionModeTrack, iDaveActionModeDelay)
|
|
ENDIF
|
|
|
|
IF NOT IS_PED_INJURED(davePed)
|
|
IF NOT bForcePassOnShitskip
|
|
IF iDaveDamageSpeechCount < 3
|
|
IF GET_GAME_TIMER() >= iNextCheckPlayerDealDamageTime
|
|
IF HAS_PLAYER_DAMAGED_AT_LEAST_ONE_PED(PLAYER_ID())
|
|
IF NOT IS_ENTITY_IN_AREA(PLAYER_PED_ID(), <<140.27911, -689.82959, 41.02893>>, <<158.84610, -661.98206, 45.26525>>)
|
|
IF NOT bDaveInCar
|
|
OR NOT IS_ANY_CONVERSATION_ONGOING_OR_QUEUED()
|
|
IF IS_ENTITY_AT_ENTITY(PLAYER_PED_ID(), davePed, <<20,20,10>>)
|
|
AND NOT HAS_ENTITY_BEEN_DAMAGED_BY_ENTITY(davePed, PLAYER_PED_ID())
|
|
IF NOT bKilledDaveSpeechForDamage
|
|
KILL_ANY_CONVERSATION()
|
|
bKilledDaveSpeechForDamage = TRUE
|
|
ENDIF
|
|
|
|
STRING sSpeech
|
|
SWITCH iDaveDamageSpeechCount
|
|
CASE 0
|
|
sSpeech = "FBI2_DAVDAM"
|
|
BREAK
|
|
CASE 1
|
|
sSpeech = "FBI2_DAVDAM2"
|
|
BREAK
|
|
CASE 2
|
|
sSpeech = "FBI2_DAVDAM3"
|
|
BREAK
|
|
ENDSWITCH
|
|
|
|
IF DO_MISSION_SPEECH(sSpeech, TRUE)
|
|
CLEAR_PLAYER_HAS_DAMAGED_AT_LEAST_ONE_PED(PLAYER_ID())
|
|
iNextCheckPlayerDealDamageTime = GET_GAME_TIMER() + 10000
|
|
iNextRandomSpeechTime = GET_GAME_TIMER() + 17000
|
|
iDaveDamageSpeechCount++
|
|
bKilledDaveSpeechForDamage = FALSE
|
|
ENDIF
|
|
ELSE
|
|
CLEAR_ENTITY_LAST_DAMAGE_ENTITY(davePed)
|
|
CLEAR_PLAYER_HAS_DAMAGED_AT_LEAST_ONE_PED(PLAYER_ID())
|
|
iNextCheckPlayerDealDamageTime = GET_GAME_TIMER() + 10000
|
|
ENDIF
|
|
ELSE
|
|
CLEAR_PLAYER_HAS_DAMAGED_AT_LEAST_ONE_PED(PLAYER_ID())
|
|
iNextCheckPlayerDealDamageTime = GET_GAME_TIMER() + 10000
|
|
ENDIF
|
|
ELSE
|
|
MISSION_FAILED(FAIL_TROUBLE_FOOD_COURT)
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF GET_PLAYER_WANTED_LEVEL(PLAYER_ID()) > 0
|
|
IF IS_ENTITY_AT_ENTITY(PLAYER_PED_ID(), davePed, <<20,20,10>>)
|
|
IF NOT bKilledDaveSpeechForWanted
|
|
IF NOT bDaveInCar
|
|
KILL_ANY_CONVERSATION()
|
|
bKilledDaveSpeechForWanted = TRUE
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF NOT bDoneDaveWantedSpeech
|
|
IF DO_MISSION_SPEECH("FBI2_DAVWAN1")
|
|
CLEAR_PLAYER_HAS_DAMAGED_AT_LEAST_ONE_PED(PLAYER_ID())
|
|
bDoneDaveWantedSpeech = TRUE
|
|
iNextRandomSpeechTime = GET_GAME_TIMER() + 17000
|
|
ENDIF
|
|
ELSE
|
|
DO_RANDOM_SPEECH("FBI2_DAVWAN2", 17000)
|
|
ENDIF
|
|
ENDIF
|
|
ELSE
|
|
bKilledDaveSpeechForWanted = FALSE
|
|
bDoneDaveWantedSpeech = FALSE
|
|
ENDIF
|
|
ENDIF
|
|
|
|
// see dave's car
|
|
IF NOT bDoneDaveCarSpeech
|
|
IF iDriveBanterStage = 0
|
|
IF IS_VEHICLE_DRIVEABLE(snatchAndGrabVehicle[SAGV_MICHAEL_CAR])
|
|
IF IS_ENTITY_AT_ENTITY(PLAYER_PED_ID(), davePed, <<10,10,10>>)
|
|
IF NOT bKilledSpeechForDaveCar
|
|
IF IS_PED_GETTING_INTO_A_VEHICLE(PLAYER_PED_ID())
|
|
OR IS_PED_IN_ANY_VEHICLE(PLAYER_PED_ID())
|
|
IF GET_VEHICLE_PED_IS_USING(PLAYER_PED_ID()) = snatchAndGrabVehicle[SAGV_MICHAEL_CAR]
|
|
KILL_ANY_CONVERSATION()
|
|
bKilledSpeechForDaveCar = TRUE
|
|
ENDIF
|
|
ENDIF
|
|
ELSE
|
|
bDoneDaveCarSpeech = DO_MISSION_SPEECH("FBI2_CAR")
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
|
|
// get rid of steve and andreas
|
|
IF NOT bRemovedSteveAndAndreas
|
|
IF DOES_ENTITY_EXIST(stevePed)
|
|
IF IS_PED_INJURED(stevePed)
|
|
MISSION_FAILED(FAIL_STEVE_DEAD)
|
|
ELSE
|
|
IF HAS_ENTITY_BEEN_DAMAGED_BY_ENTITY(stevePed, PLAYER_PED_ID())
|
|
MISSION_FAILED(FAIL_TROUBLE_FOOD_COURT)
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
IF DOES_ENTITY_EXIST(andreasPed)
|
|
IF IS_PED_INJURED(andreasPed)
|
|
MISSION_FAILED(FAIL_ANDREAS_DEAD)
|
|
ELSE
|
|
IF HAS_ENTITY_BEEN_DAMAGED_BY_ENTITY(andreasPed, PLAYER_PED_ID())
|
|
MISSION_FAILED(FAIL_TROUBLE_FOOD_COURT)
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF GET_DISTANCE_BETWEEN_COORDS(<<148.34253, -677.21783, 41.84525>>, GET_ENTITY_COORDS(PLAYER_PED_ID())) < 3.5
|
|
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)
|
|
ENDIF
|
|
|
|
IF NOT IS_ENTITY_AT_COORD(PLAYER_PED_ID(), GET_SNATCH_AND_GRAB_VECTOR(SAGVEC_PLAYER_INIT), <<150,150,150>>, FALSE, FALSE)
|
|
REMOVE_PED_FOR_DIALOGUE(snatchAndGrabConversation, 5)
|
|
IF DOES_ENTITY_EXIST(stevePed)
|
|
DELETE_PED(stevePed)
|
|
ENDIF
|
|
CLEAR_MODEL_REQUEST(ENUM_TO_INT(SAGM_STEVE))
|
|
REMOVE_PED_FOR_DIALOGUE(snatchAndGrabConversation, 6)
|
|
IF DOES_ENTITY_EXIST(andreasPed)
|
|
DELETE_PED(andreasPed)
|
|
ENDIF
|
|
CLEAR_MODEL_REQUEST(ENUM_TO_INT(SAGM_ANDREAS))
|
|
CLEAR_ANIM_DICT_REQUEST(SAG_ANIM_DICT_FOOD_COURT)
|
|
CLEAR_MODEL_REQUEST(ENUM_TO_INT(SAGM_COFFEE))
|
|
//CLEAR_MISC_ASSET_REQUEST(SAG_MISC_ASSET_FOOD_COURT_ANIMS)
|
|
|
|
INT i
|
|
REPEAT NUMBER_FOOD_COURT_CHAIRS i
|
|
IF DOES_ENTITY_EXIST(foodCourtChairObject[i])
|
|
SET_OBJECT_AS_NO_LONGER_NEEDED(foodCourtChairObject[i])
|
|
ENDIF
|
|
ENDREPEAT
|
|
|
|
REPEAT 3 i
|
|
IF DOES_ENTITY_EXIST(coffeeObject[i])
|
|
DELETE_OBJECT(coffeeObject[i])
|
|
ENDIF
|
|
ENDREPEAT
|
|
bRemovedSteveAndAndreas = TRUE
|
|
ELSE
|
|
IF NOT bLoopSteveAndAndreas
|
|
IF NOT IS_PED_INJURED(stevePed)
|
|
AND NOT IS_PED_INJURED(andreasPed)
|
|
IF IS_SYNCHRONIZED_SCENE_RUNNING(iSteveSyncScene)
|
|
IF GET_SYNCHRONIZED_SCENE_PHASE(iSteveSyncScene) >= 0.98
|
|
SET_STEVE_AND_ANDREAS_LOOP()
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ELSE
|
|
IF NOT IS_PED_INJURED(stevePed)
|
|
IF NOT bDoneSteveLook
|
|
IF GET_GAME_TIMER() >= iLoopSteveAndAndreasTime + 3000
|
|
TASK_LOOK_AT_ENTITY(stevePed, PLAYER_PED_ID(), -1, SLF_WHILE_NOT_IN_FOV)
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF IS_ENTITY_ON_FIRE(stevePed)
|
|
APPLY_DAMAGE_TO_PED(stevePed, 1000, TRUE)
|
|
ENDIF
|
|
|
|
IF IS_ENTITY_AT_ENTITY(PLAYER_PED_ID(), stevePed, <<6,6,2>>)
|
|
DO_RANDOM_SPEECH("FBI2_HANG", GET_RANDOM_INT_IN_RANGE(15000, 20000))
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF NOT IS_PED_INJURED(andreasPed)
|
|
IF IS_ENTITY_ON_FIRE(andreasPed)
|
|
APPLY_DAMAGE_TO_PED(andreasPed, 1000, TRUE)
|
|
ENDIF
|
|
|
|
IF NOT bDoneAndreasLook
|
|
IF GET_GAME_TIMER() >= iLoopSteveAndAndreasTime + 3900
|
|
TASK_LOOK_AT_ENTITY(andreasPed, PLAYER_PED_ID(), -1, SLF_WHILE_NOT_IN_FOV)
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
|
|
FAIL_FOOD_COURT()
|
|
|
|
// create everything at the meeting
|
|
SWITCH createMeetingStage
|
|
CASE CREATE_MEETING_STAGE_NOT_STARTED
|
|
IF IS_ENTITY_AT_COORD(PLAYER_PED_ID(), GET_SNATCH_AND_GRAB_VECTOR(SAGVEC_MEETING_POINT), <<450,450,450>>, FALSE, FALSE)
|
|
AND bDaveInCar
|
|
ADD_MODEL_REQUEST(ENUM_TO_INT(SAGM_CHOPPER))
|
|
ADD_MODEL_REQUEST(ENUM_TO_INT(SAGM_FRANKLIN_BIKE))
|
|
createMeetingStage = CREATE_MEETING_STAGE_WAITING_FOR_VEHICLES
|
|
ENDIF
|
|
BREAK
|
|
CASE CREATE_MEETING_STAGE_WAITING_FOR_VEHICLES
|
|
IF HAVE_ALL_MODEL_REQUESTS_SUCCEEDED()
|
|
AND HAVE_ALL_ANIM_DICT_REQUESTS_SUCCEEDED()
|
|
CREATE_FBI_MEETING_VEHICLES()
|
|
createMeetingStage = CREATE_MEETING_STAGE_VEHICLES_CREATED
|
|
ENDIF
|
|
BREAK
|
|
CASE CREATE_MEETING_STAGE_VEHICLES_CREATED
|
|
IF IS_ENTITY_AT_COORD(PLAYER_PED_ID(), GET_SNATCH_AND_GRAB_VECTOR(SAGVEC_MEETING_POINT), <<380,380,380>>, FALSE, FALSE)
|
|
ADD_MODEL_REQUEST(ENUM_TO_INT(SAGM_FRANKLIN))
|
|
ADD_MODEL_REQUEST(ENUM_TO_INT(SAGM_TREVOR))
|
|
ADD_MODEL_REQUEST(ENUM_TO_INT(SAGM_FBI))
|
|
ADD_ANIM_DICT_REQUEST(SAG_ANIM_DICT_AT_LOT)
|
|
createMeetingStage = CREATE_MEETING_STAGE_WAITING_FOR_PEDS
|
|
ENDIF
|
|
BREAK
|
|
CASE CREATE_MEETING_STAGE_WAITING_FOR_PEDS
|
|
IF HAVE_ALL_MODEL_REQUESTS_SUCCEEDED()
|
|
AND HAVE_ALL_ANIM_DICT_REQUESTS_SUCCEEDED()
|
|
CREATE_FBI_MEETING_PEDS()
|
|
createMeetingStage = CREATE_MEETING_STAGE_DONE
|
|
ENDIF
|
|
BREAK
|
|
CASE CREATE_MEETING_STAGE_DONE
|
|
IF NOT IS_PED_INJURED(fbiPed[0])
|
|
AND NOT IS_PED_INJURED(sSelectorPeds.pedID[SELECTOR_PED_FRANKLIN])
|
|
AND NOT IS_PED_INJURED(sSelectorPeds.pedID[SELECTOR_PED_TREVOR])
|
|
AND IS_VEHICLE_DRIVEABLE(snatchAndGrabVehicle[SAGV_FRANKLIN_BIKE])
|
|
AND IS_VEHICLE_DRIVEABLE(snatchAndGrabVehicle[SAGV_PLAYER_CHOPPER])
|
|
IF NOT bForcePassOnShitskip
|
|
SWITCH pickupChopperLeadinStage
|
|
CASE PICKUP_CHOPPER_LEADIN_NOT_STARTED
|
|
iSyncScene = CREATE_SYNCHRONIZED_SCENE(GET_SNATCH_AND_GRAB_VECTOR(SAGVEC_PICKUP_CHOPPER_LEADIN), <<0,0,PICKUP_CHOPPER_LEADIN_ROT>>)
|
|
iSyncScene2 = CREATE_SYNCHRONIZED_SCENE(GET_SNATCH_AND_GRAB_VECTOR(SAGVEC_PICKUP_CHOPPER_LEADIN), <<0,0,PICKUP_CHOPPER_LEADIN_ROT>>)
|
|
SET_ENTITY_NO_COLLISION_ENTITY(sSelectorPeds.pedID[SELECTOR_PED_FRANKLIN], snatchAndGrabVehicle[SAGV_FRANKLIN_BIKE], TRUE)
|
|
//ATTACH_SYNCHRONIZED_SCENE_TO_ENTITY(iSyncScene, snatchAndGrabVehicle[SAGV_PLAYER_CHOPPER], 0)
|
|
SET_SYNCHRONIZED_SCENE_LOOPED(iSyncScene, TRUE)
|
|
SET_SYNCHRONIZED_SCENE_LOOPED(iSyncScene2, TRUE)
|
|
TASK_SYNCHRONIZED_SCENE(sSelectorPeds.pedID[SELECTOR_PED_TREVOR], iSyncScene, GET_SNATCH_AND_GRAB_ANIM_DICT_AS_STRING(SAG_ANIM_DICT_AT_LOT), "_leadin_loop_Trevor", NORMAL_BLEND_IN, SLOW_BLEND_OUT, SYNCED_SCENE_USE_PHYSICS)
|
|
TASK_SYNCHRONIZED_SCENE(fbiPed[0], iSyncScene, GET_SNATCH_AND_GRAB_ANIM_DICT_AS_STRING(SAG_ANIM_DICT_AT_LOT), "_leadin_loop_FBI", NORMAL_BLEND_IN, SLOW_BLEND_OUT, SYNCED_SCENE_USE_PHYSICS)
|
|
TASK_SYNCHRONIZED_SCENE(sSelectorPeds.pedID[SELECTOR_PED_FRANKLIN], iSyncScene2, GET_SNATCH_AND_GRAB_ANIM_DICT_AS_STRING(SAG_ANIM_DICT_AT_LOT), "_leadin_loop_Franklin", NORMAL_BLEND_IN, NORMAL_BLEND_OUT, SYNCED_SCENE_USE_PHYSICS)
|
|
TASK_LOOK_AT_ENTITY(sSelectorPeds.pedID[SELECTOR_PED_FRANKLIN], PLAYER_PED_ID(), -1, SLF_WHILE_NOT_IN_FOV)
|
|
pickupChopperLeadinStage = PICKUP_CHOPPER_LEADIN_LOOPING
|
|
BREAK
|
|
|
|
CASE PICKUP_CHOPPER_LEADIN_LOOPING
|
|
IF NOT bPreparedTrevorRantAudio
|
|
IF NOT bSetSceneAudioEntity
|
|
//SET_SYNCH_SCENE_AUDIO_POSITION(<<1372.76331, -2072.92212, 52.40826>>)
|
|
//SET_SYNCH_SCENE_AUDIO_ENTITY(sSelectorPeds.pedID[SELECTOR_PED_TREVOR])
|
|
INIT_SYNCH_SCENE_AUDIO_WITH_ENTITY("FBI_2_MCS_1_LeadIn", sSelectorPeds.pedID[SELECTOR_PED_TREVOR])
|
|
bSetSceneAudioEntity = TRUE
|
|
ENDIF
|
|
bPreparedTrevorRantAudio = PREPARE_SYNCHRONIZED_AUDIO_EVENT("FBI_2_MCS_1_LeadIn", 0)
|
|
ENDIF
|
|
|
|
IF missionFailState = MISSION_FAIL_STATE_NOT_FAILED
|
|
IF IS_SYNCHRONIZED_SCENE_RUNNING(iSyncScene)
|
|
IF GET_SYNCHRONIZED_SCENE_PHASE(iSyncScene) >= 0.98
|
|
IF IS_ENTITY_AT_ENTITY(PLAYER_PED_ID(), sSelectorPeds.pedID[SELECTOR_PED_TREVOR], <<57,57,57>>)
|
|
iSyncScene = CREATE_SYNCHRONIZED_SCENE(GET_SNATCH_AND_GRAB_VECTOR(SAGVEC_PICKUP_CHOPPER_LEADIN), <<0,0,PICKUP_CHOPPER_LEADIN_ROT>>)
|
|
TASK_SYNCHRONIZED_SCENE(sSelectorPeds.pedID[SELECTOR_PED_TREVOR], iSyncScene, GET_SNATCH_AND_GRAB_ANIM_DICT_AS_STRING(SAG_ANIM_DICT_AT_LOT), "_leadin_action_Trevor", SLOW_BLEND_IN, SLOW_BLEND_OUT, SYNCED_SCENE_USE_PHYSICS)
|
|
TASK_SYNCHRONIZED_SCENE(fbiPed[0], iSyncScene, GET_SNATCH_AND_GRAB_ANIM_DICT_AS_STRING(SAG_ANIM_DICT_AT_LOT), "_leadin_action_FBI", SLOW_BLEND_IN, SLOW_BLEND_OUT, SYNCED_SCENE_USE_PHYSICS)
|
|
SET_SYNCHRONIZED_SCENE_PHASE(iSyncScene, 0)
|
|
SET_SYNCHRONIZED_SCENE_LOOPED(iSyncScene, FALSE)
|
|
SET_SYNCHRONIZED_SCENE_HOLD_LAST_FRAME(iSyncScene, TRUE)
|
|
|
|
IF bPreparedTrevorRantAudio
|
|
//printstring("do leadin audio!") printnl()
|
|
PLAY_SYNCHRONIZED_AUDIO_EVENT(iSyncScene)
|
|
ENDIF
|
|
|
|
pickupChopperLeadinStage = PICKUP_CHOPPER_LEADIN_ACTION
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
BREAK
|
|
|
|
CASE PICKUP_CHOPPER_LEADIN_ACTION
|
|
IF missionFailState = MISSION_FAIL_STATE_NOT_FAILED
|
|
IF IS_SYNCHRONIZED_SCENE_RUNNING(iSyncScene)
|
|
IF GET_SYNCHRONIZED_SCENE_PHASE(iSyncScene) >= 0.75
|
|
bCanRunPickupChopperScene = TRUE
|
|
ENDIF
|
|
|
|
IF GET_SYNCHRONIZED_SCENE_PHASE(iSyncScene) >= 0.99
|
|
iSyncScene = CREATE_SYNCHRONIZED_SCENE(GET_SNATCH_AND_GRAB_VECTOR(SAGVEC_PICKUP_CHOPPER_LEADIN), <<0,0,PICKUP_CHOPPER_LEADIN_ROT>>)
|
|
TASK_SYNCHRONIZED_SCENE(sSelectorPeds.pedID[SELECTOR_PED_TREVOR], iSyncScene, GET_SNATCH_AND_GRAB_ANIM_DICT_AS_STRING(SAG_ANIM_DICT_AT_LOT), "_leadin_loop_Trevor_02_trevor",SLOW_BLEND_IN, NORMAL_BLEND_OUT, SYNCED_SCENE_USE_PHYSICS)
|
|
TASK_SYNCHRONIZED_SCENE(fbiPed[0], iSyncScene, GET_SNATCH_AND_GRAB_ANIM_DICT_AS_STRING(SAG_ANIM_DICT_AT_LOT), "_leadin_loop_FBI", SLOW_BLEND_IN, NORMAL_BLEND_OUT, SYNCED_SCENE_USE_PHYSICS)
|
|
SET_SYNCHRONIZED_SCENE_PHASE(iSyncScene, 0)
|
|
SET_SYNCHRONIZED_SCENE_LOOPED(iSyncScene, TRUE)
|
|
bCanRunPickupChopperScene = TRUE
|
|
pickupChopperLeadinStage = PICKUP_CHOPPER_LEADIN_DONE
|
|
ENDIF
|
|
ELSE
|
|
bCanRunPickupChopperScene = TRUE
|
|
ENDIF
|
|
ENDIF
|
|
BREAK
|
|
ENDSWITCH
|
|
ENDIF
|
|
ENDIF
|
|
|
|
// set chopper high lod
|
|
IF IS_VEHICLE_DRIVEABLE(snatchAndGrabVehicle[SAGV_PLAYER_CHOPPER])
|
|
IF IS_ENTITY_AT_ENTITY(PLAYER_PED_ID(), snatchAndGrabVehicle[SAGV_PLAYER_CHOPPER], <<120,120,120>>, FALSE, FALSE)
|
|
REQUEST_VEHICLE_HIGH_DETAIL_MODEL(snatchAndGrabVehicle[SAGV_PLAYER_CHOPPER])
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF NOT bForcePassOnShitskip
|
|
HANDLE_FBI()
|
|
ENDIF
|
|
BREAK
|
|
ENDSWITCH
|
|
|
|
// create util trucks
|
|
SWITCH createUtilTrucksStage
|
|
CASE CREATE_UTIL_TRUCKS_STAGE_NOT_STARTED
|
|
IF IS_ENTITY_AT_COORD(PLAYER_PED_ID(), <<1393.64, -2053.64, 51.00>>, <<330,330,330>>, FALSE, FALSE)
|
|
ADD_MODEL_REQUEST(ENUM_TO_INT(SAGM_UTIL_TRUCK_1))
|
|
ADD_MODEL_REQUEST(ENUM_TO_INT(SAGM_UTIL_TRUCK_2))
|
|
ADD_MODEL_REQUEST(ENUM_TO_INT(SAGM_FBI_CAR))
|
|
createUtilTrucksStage = CREATE_UTIL_TRUCKS_STAGE_WAITING
|
|
ENDIF
|
|
BREAK
|
|
CASE CREATE_UTIL_TRUCKS_STAGE_WAITING
|
|
IF HAVE_ALL_MODEL_REQUESTS_SUCCEEDED()
|
|
CREATE_UTIL_TRUCKS(STAGE_GET_TO_CHOPPER)
|
|
createUtilTrucksStage = CREATE_UTIL_TRUCKS_STAGE_DONE
|
|
ENDIF
|
|
BREAK
|
|
CASE CREATE_UTIL_TRUCKS_STAGE_DONE
|
|
BREAK
|
|
ENDSWITCH
|
|
|
|
//SET_MICHAEL_INTO_CAR()
|
|
|
|
// Starting music when player enters vehicle.
|
|
IF NOT bCarIsMoving
|
|
IF IS_PLAYER_DRIVING_ANY_VEHICLE()
|
|
// TRIGGER_MISSION_MUSIC_EVENT("FBI2_TEST_MISSION_START")
|
|
bCarIsMoving = TRUE
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF NOT bForcePassOnShitskip
|
|
IF NOT bDaveInCar
|
|
IF IS_VEHICLE_DRIVEABLE(snatchAndGrabVehicle[SAGV_MICHAEL_CAR])
|
|
AND NOT IS_PED_INJURED(davePed)
|
|
VECTOR vDavePos
|
|
VECTOR vPlayerPos
|
|
vDavePos = GET_ENTITY_COORDS(davePed)
|
|
vPlayerPos = GET_ENTITY_COORDS(PLAYER_PED_ID())
|
|
|
|
|
|
SWITCH daveIntoCarState
|
|
CASE DAVE_INTO_CAR_STATE_WALKING
|
|
FLOAT fDistAhead
|
|
fDistAhead = vDavePos.x - vPlayerPos.x
|
|
IF fDistAhead > 0.0
|
|
fDaveWalkSpeed = fDaveWalkSpeed +@ 0.060
|
|
ELIF fDistAhead < -1.2
|
|
fDaveWalkSpeed = fDaveWalkSpeed -@ 0.060
|
|
ELSE
|
|
// try and get to 1.0
|
|
IF fDaveWalkSpeed > 1.0
|
|
fDaveWalkSpeed = fDaveWalkSpeed -@ 0.060
|
|
IF fDaveWalkSpeed < 1.0
|
|
fDaveWalkSpeed = 1.0
|
|
ENDIF
|
|
ELIF fDaveWalkSpeed < 1.0
|
|
fDaveWalkSpeed = fDaveWalkSpeed +@ 0.060
|
|
IF fDaveWalkSpeed > 1.0
|
|
fDaveWalkSpeed = 1.0
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF fDaveWalkSpeed > MAX_DAVE_WALK_SPEED
|
|
fDaveWalkSpeed = MAX_DAVE_WALK_SPEED
|
|
ELIF fDaveWalkSpeed < MIN_DAVE_WALK_SPEED
|
|
fDaveWalkSpeed = MIN_DAVE_WALK_SPEED
|
|
ENDIF
|
|
|
|
SET_PED_MOVE_RATE_OVERRIDE(davePed, fDaveWalkSpeed)
|
|
|
|
BOOL bAt
|
|
IF IS_VEHICLE_DRIVEABLE(snatchAndGrabVehicle[SAGV_MICHAEL_CAR])
|
|
FLOAT fAtDist
|
|
fAtDist = DAVE_PAUSE_DIST
|
|
IF GET_FOLLOW_PED_CAM_VIEW_MODE() = CAM_VIEW_MODE_FIRST_PERSON
|
|
fAtDist = 4.1
|
|
ENDIF
|
|
|
|
bAt = IS_ENTITY_AT_ENTITY(PLAYER_PED_ID(), davePed, <<fAtDist, fAtDist, 4>>) OR IS_ENTITY_AT_ENTITY(PLAYER_PED_ID(), snatchAndGrabVehicle[SAGV_MICHAEL_CAR], <<5,5,5>>)
|
|
ENDIF
|
|
|
|
IF NOT bAt
|
|
OR NOT IS_ENTITY_AT_ENTITY(PLAYER_PED_ID(), davePed, <<10, 10, 4>>)
|
|
IF NOT bSavedBanter
|
|
IF STORE_BANTER()
|
|
KILL_ANY_CONVERSATION()
|
|
ENDIF
|
|
ENDIF
|
|
ELSE
|
|
IF bSavedBanter
|
|
IF RESTORE_BANTER()
|
|
bSavedBanter = FALSE
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF GET_SCRIPT_TASK_STATUS(davePed, SCRIPT_TASK_FOLLOW_WAYPOINT_ROUTE) = FINISHED_TASK
|
|
IF NOT IS_ENTITY_AT_COORD(davePed, <<84.6,-670.0,43.38>>, <<8,8,8>>, FALSE, FALSE)
|
|
TASK_CLEAR_LOOK_AT(davePed)
|
|
INT iClosestDaveWaypoint
|
|
WAYPOINT_RECORDING_GET_CLOSEST_WAYPOINT("davewalk", GET_ENTITY_COORDS(davePed), iClosestDaveWaypoint)
|
|
IF iClosestDaveWaypoint < 2
|
|
iClosestDaveWaypoint = 2
|
|
ENDIF
|
|
|
|
TASK_FOLLOW_WAYPOINT_RECORDING(davePed, "davewalk", iClosestDaveWaypoint+1, EWAYPOINT_NAVMESH_BACK_TO_WAYPOINT_IF_LEFT_ROUTE)
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF NOT bAt
|
|
IF IS_PED_HEADTRACKING_ENTITY(PLAYER_PED_ID(), davePed)
|
|
TASK_CLEAR_LOOK_AT(PLAYER_PED_ID())
|
|
ENDIF
|
|
|
|
IF vPlayerPos.x > vDavePos.x
|
|
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(davePed, sequence)
|
|
|
|
daveIntoCarState = DAVE_INTO_CAR_STATE_PAUSED
|
|
ENDIF
|
|
ELSE
|
|
|
|
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 IS_ENTITY_AT_ENTITY(davePed, snatchAndGrabVehicle[SAGV_MICHAEL_CAR], <<8,8,8>>, FALSE, FALSE)
|
|
IF NOT IS_PED_GETTING_INTO_A_VEHICLE(PLAYER_PED_ID())
|
|
SET_BLOCKING_OF_NON_TEMPORARY_EVENTS(davePed, TRUE)
|
|
TASK_ENTER_VEHICLE(davePed, snatchAndGrabVehicle[SAGV_MICHAEL_CAR], DEFAULT_TIME_BEFORE_WARP, VS_FRONT_RIGHT, PEDMOVE_WALK)
|
|
TASK_CLEAR_LOOK_AT(davePed)
|
|
daveIntoCarState = DAVE_INTO_CAR_STATE_ENTER
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
|
|
bCacheAt = bAt
|
|
BREAK
|
|
|
|
CASE DAVE_INTO_CAR_STATE_PAUSED
|
|
IF IS_PED_HEADTRACKING_ENTITY(PLAYER_PED_ID(), davePed)
|
|
TASK_CLEAR_LOOK_AT(PLAYER_PED_ID())
|
|
ENDIF
|
|
IF IS_ENTITY_AT_ENTITY(PLAYER_PED_ID(), davePed, <<DAVE_UNPAUSE_DIST, DAVE_UNPAUSE_DIST, 4>>)
|
|
OR vPlayerPos.x < vDavePos.x
|
|
daveIntoCarState = DAVE_INTO_CAR_STATE_WALKING
|
|
ENDIF
|
|
BREAK
|
|
|
|
CASE DAVE_INTO_CAR_STATE_ENTER
|
|
IF IS_PED_IN_VEHICLE(davePed, snatchAndGrabVehicle[SAGV_MICHAEL_CAR])
|
|
REMOVE_PED_FROM_GROUP(davePed)
|
|
KILL_ANY_CONVERSATION()
|
|
TASK_CLEAR_LOOK_AT(davePed)
|
|
SET_BLOCKING_OF_NON_TEMPORARY_EVENTS(davePed, TRUE)
|
|
|
|
REPLAY_RECORD_BACK_FOR_TIME(5.0, 10.0, REPLAY_IMPORTANCE_HIGHEST)
|
|
|
|
bSavedBanter = FALSE
|
|
bDaveInCar = TRUE
|
|
ENDIF
|
|
BREAK
|
|
ENDSWITCH
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF NOT bDoneInCarAudioScene
|
|
IF IS_VEHICLE_DRIVEABLE(snatchAndGrabVehicle[SAGV_MICHAEL_CAR])
|
|
IF daveIntoCarState >= DAVE_INTO_CAR_STATE_ENTER
|
|
OR IS_ENTITY_AT_ENTITY(davePed, snatchAndGrabVehicle[SAGV_MICHAEL_CAR], <<15,15,15>>, FALSE, FALSE)
|
|
IF IS_ENTITY_AT_ENTITY(PLAYER_PED_ID(), snatchAndGrabVehicle[SAGV_MICHAEL_CAR], <<30,30,30>>, FALSE, FALSE)
|
|
SET_PED_RESET_FLAG(PLAYER_PED_ID(), PRF_ForcePlayerToEnterVehicleThroughDirectDoorOnly, TRUE)
|
|
ENDIF
|
|
ENDIF
|
|
IF IS_PED_IN_VEHICLE(PLAYER_PED_ID(), snatchAndGrabVehicle[SAGV_MICHAEL_CAR])
|
|
bDoneInCarAudioScene = START_SNATCH_AND_GRAB_AUDIO_SCENE(SNATCH_AND_GRAB_AUDIO_SCENE_DRIVE_TO_LOT)
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF NOT IS_PED_INJURED(davePed)
|
|
// play the music
|
|
IF g_bMagDemoActive
|
|
IF NOT bDoneApproachLotCue
|
|
VECTOR vCarPos = GET_ENTITY_COORDS(snatchAndGrabVehicle[SAGV_MICHAEL_CAR])
|
|
IF vCarPos.y <= -1976.2
|
|
bDoneApproachLotCue = TRIGGER_MISSION_MUSIC_EVENT("FIB2_HELI_PRE_TAKEOFF")
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF createMeetingStage = CREATE_MEETING_STAGE_DONE
|
|
AND createUtilTrucksStage = CREATE_UTIL_TRUCKS_STAGE_DONE
|
|
HANDLE_STREAMING_MOCAP("fbi_2_mcs_1", GET_SNATCH_AND_GRAB_VECTOR(SAGVEC_MEETING_POINT), DEFAULT_CUTSCENE_LOAD_DIST, DEFAULT_CUTSCENE_UNLOAD_DIST)
|
|
|
|
IF CAN_REQUEST_ASSETS_FOR_CUTSCENE_ENTITY()
|
|
IF NOT IS_PED_INJURED(davePed)
|
|
SET_CUTSCENE_PED_COMPONENT_VARIATION_FROM_PED("Dave_FBI", davePed)
|
|
SET_CUTSCENE_PED_COMPONENT_VARIATION("Dave_FBI", PED_COMP_JBIB, 1, 0)
|
|
ENDIF
|
|
IF NOT IS_PED_INJURED(fbiPed[0])
|
|
SET_CUTSCENE_PED_COMPONENT_VARIATION_FROM_PED("FBI_Suit", fbiPed[0])
|
|
ENDIF
|
|
IF NOT IS_PED_INJURED(GET_FRANKLIN_PED())
|
|
SET_CUTSCENE_PED_COMPONENT_VARIATION_FROM_PED("Franklin", GET_FRANKLIN_PED())
|
|
ENDIF
|
|
IF NOT IS_PED_INJURED(GET_TREVOR_PED())
|
|
SET_CUTSCENE_PED_COMPONENT_VARIATION_FROM_PED("Trevor", GET_TREVOR_PED())
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF NOT bCutsceneWaitStarted
|
|
// banter
|
|
IF iWanted = 0
|
|
IF NOT bForcePassOnShitskip
|
|
IF NOT g_bMagDemoActive
|
|
// dave says get to the lot
|
|
IF NOT bDoneGetToLotSpeech
|
|
IF bDoneGotoSpeech
|
|
AND bDoneDaveLetsGoSpeech
|
|
IF iGetInTextStage > 0
|
|
IF IS_VEHICLE_DRIVEABLE(snatchAndGrabVehicle[SAGV_MICHAEL_CAR])
|
|
IF bDaveInCar
|
|
bDoneGetToLotSpeech = TRUE
|
|
ELSE
|
|
IF bCacheAt
|
|
IF iReplayAttempt % 2 = 0
|
|
bDoneGetToLotSpeech = DO_MISSION_SPEECH("FBI2_TOCAR")
|
|
ELSE
|
|
bDoneGetToLotSpeech = DO_MISSION_SPEECH("FBI2_TOCAR2")
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF NOT g_bMagDemoActive
|
|
IF bShownGodText
|
|
AND NOT bKilledBanter
|
|
IF IS_PED_IN_VEHICLE(PLAYER_PED_ID(), snatchAndGrabVehicle[SAGV_MICHAEL_CAR])
|
|
AND IS_PED_IN_VEHICLE(davePed, snatchAndGrabVehicle[SAGV_MICHAEL_CAR])
|
|
IF NOT bKilledLookAtInCar
|
|
TASK_CLEAR_LOOK_AT(PLAYER_PED_ID())
|
|
bKilledLookAtInCar = TRUE
|
|
ENDIF
|
|
|
|
IF bSavedBanter
|
|
IF bDaveInCar
|
|
OR IS_ENTITY_AT_ENTITY(PLAYER_PED_ID(), davePed, <<15,15,4>>)
|
|
IF RESTORE_BANTER()
|
|
bSavedBanter = FALSE
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
|
|
STRING sBanter
|
|
|
|
SWITCH iDriveBanterStage
|
|
CASE 0
|
|
IF iReplayAttempt % 2 = 0
|
|
sBanter = "FBI2_B1AV1"
|
|
ELSE
|
|
sBanter = "FBI2_B2AV2"
|
|
ENDIF
|
|
// dave and mike chat about franklin
|
|
IF DO_MISSION_SPEECH(sBanter)
|
|
iDriveBanterStage++
|
|
bSavedBanter = FALSE
|
|
ENDIF
|
|
BREAK
|
|
CASE 1
|
|
// michael phones franklin
|
|
IF NOT IS_ANY_CONVERSATION_ONGOING_OR_QUEUED()
|
|
AND NOT IS_MESSAGE_BEING_DISPLAYED()
|
|
AND IS_PED_SITTING_IN_VEHICLE(PLAYER_PED_ID(), snatchAndGrabVehicle[SAGV_MICHAEL_CAR])
|
|
IF NOT bKilledBanter
|
|
IF iReplayAttempt % 2 = 0
|
|
sBanter = "FBI2_FCALL"
|
|
ELSE
|
|
sBanter = "FBI2_FCALL2"
|
|
ENDIF
|
|
|
|
IF PLAYER_CALL_CHAR_CELLPHONE(snatchAndGrabConversation, CHAR_FRANKLIN, "FBI2AUD", sBanter, CONV_PRIORITY_HIGH)
|
|
// Music change over when Michael uses phone
|
|
//TRIGGER_MISSION_MUSIC_EVENT("FBI2_TEST_DRIVE_TO_HELI_PHONE")
|
|
iDriveBanterStage++
|
|
bSavedBanter = FALSE
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
BREAK
|
|
CASE 2
|
|
// check to see if the call has gone through properly
|
|
IF NOT bRegisteredCall
|
|
//IF NOT IS_ANY_CONVERSATION_ONGOING_OR_QUEUED()
|
|
// iDriveBanterStage--
|
|
//ELSE
|
|
IF IS_MOBILE_PHONE_CALL_ONGOING()
|
|
OR IS_PED_SITTING_IN_VEHICLE(PLAYER_PED_ID(), snatchAndGrabVehicle[SAGV_MICHAEL_CAR])
|
|
bRegisteredCall = TRUE
|
|
ENDIF
|
|
//ENDIF
|
|
ELSE
|
|
// dave and mike chat about trevor
|
|
IF NOT bKilledBanter
|
|
IF iReplayAttempt % 2 = 0
|
|
sBanter = "FBI2_B1BV1"
|
|
ELSE
|
|
sBanter = "FBI2_B2BV2"
|
|
ENDIF
|
|
IF DO_MISSION_SPEECH(sBanter)
|
|
// Music change when they chat about trev
|
|
//TRIGGER_MISSION_MUSIC_EVENT("FBI2_TEST_DRIVE_TO_HELI_TREV")
|
|
iDriveBanterStage++
|
|
bSavedBanter = FALSE
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
BREAK
|
|
CASE 3
|
|
/*
|
|
IF NOT bKilledTrevorDiscussionSpeech
|
|
IF IS_ENTITY_AT_COORD(PLAYER_PED_ID(), <<1378.04, -2063.69, 51.00>>, <<250,250,250>>, FALSE, FALSE)
|
|
TEXT_LABEL_23 tCurrentLabel
|
|
tCurrentLabel = GET_CURRENTLY_PLAYING_STANDARD_CONVERSATION_LABEL()
|
|
IF ARE_STRINGS_EQUAL(tCurrentLabel, "FBI2_B1BV1_3")
|
|
OR ARE_STRINGS_EQUAL(tCurrentLabel, "FBI2_B1BV1_5")
|
|
KILL_ANY_CONVERSATION()
|
|
bKilledTrevorDiscussionSpeech = TRUE
|
|
ENDIF
|
|
ENDIF
|
|
ELSE
|
|
IF NOT bRestartedDiscussionSpeech
|
|
IF NOT bKilledBanter
|
|
bRestartedDiscussionSpeech = DO_MISSION_SPEECH("FBI2_B1BV1", FALSE, 8, FALSE, TRUE, TRUE)
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
*/
|
|
|
|
// Change music once conversation is complete
|
|
//IF NOT IS_ANY_CONVERSATION_ONGOING_OR_QUEUED()
|
|
//TRIGGER_MISSION_MUSIC_EVENT("FBI2_TEST_DRIVE_TO_HELI")
|
|
//iDriveBanterStage++
|
|
//ENDIF
|
|
BREAK
|
|
ENDSWITCH
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF NOT bKilledBanter
|
|
IF IS_ENTITY_AT_COORD(PLAYER_PED_ID(), GET_SNATCH_AND_GRAB_VECTOR(SAGVEC_MEETING_POINT), <<50, 50, 50>>, FALSE, FALSE)
|
|
KILL_ANY_CONVERSATION()
|
|
bKilledBanter = TRUE
|
|
ENDIF
|
|
//ELSE
|
|
// IF NOT bDoneBriefTroopsSpeech
|
|
// bDoneBriefTroopsSpeech = DO_MISSION_SPEECH("FBI2_MCS1_LI")
|
|
// ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF CAN_ADVANCE_MISSION()
|
|
IF IS_PED_IN_VEHICLE(PLAYER_PED_ID(), snatchAndGrabVehicle[SAGV_MICHAEL_CAR])
|
|
AND IS_PED_IN_VEHICLE(davePed, snatchAndGrabVehicle[SAGV_MICHAEL_CAR])
|
|
IF IS_ENTITY_AT_COORD(PLAYER_PED_ID(), GET_SNATCH_AND_GRAB_VECTOR(SAGVEC_CHOPPER_INIT), <<9, 9, LOCATE_SIZE_HEIGHT>>)
|
|
//OR IS_ENTITY_IN_ANGLED_AREA(PLAYER_PED_ID(), <<1365.68, -2057.41, 50.12>>, <<1384.50, -2079.38, 53.12>>, 12)
|
|
OR IS_ENTITY_AT_COORD(PLAYER_PED_ID(), GET_SNATCH_AND_GRAB_VECTOR(SAGVEC_MEETING_POINT), <<9, 9, LOCATE_SIZE_HEIGHT>>, FALSE)
|
|
OR IS_ENTITY_AT_COORD(PLAYER_PED_ID(), <<1381.35144, -2072.18823, 50.99826>>, <<10, 10, LOCATE_SIZE_HEIGHT>>, FALSE)
|
|
OR IS_ENTITY_AT_COORD(PLAYER_PED_ID(), <<1381.99451, -2058.40039, 50.99815>>, <<9, 7, LOCATE_SIZE_HEIGHT>>, FALSE)
|
|
|
|
IF mocapStreamingStage > MOCAP_STREAMING_STAGE_REQUEST
|
|
AND IS_PED_SITTING_IN_VEHICLE(PLAYER_PED_ID(), snatchAndGrabVehicle[SAGV_MICHAEL_CAR])
|
|
AND IS_PED_SITTING_IN_VEHICLE(davePed, snatchAndGrabVehicle[SAGV_MICHAEL_CAR])
|
|
//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
|
|
ELSE
|
|
PREVENT_WANTED_LEVEL_FOR_CUTSCENE()
|
|
IF NOT bDoneMichaelLeaveCarSpeech
|
|
IF NOT bForcePassOnShitskip
|
|
IF DO_MISSION_SPEECH("FBI2_MCS1_L2")
|
|
bDoneMichaelLeaveCarSpeech = TRUE
|
|
iMichaelLeaveCarSpeechTime = GET_GAME_TIMER()
|
|
ENDIF
|
|
ENDIF
|
|
ELSE
|
|
IF NOT bKilledMichaelLeaveCarSpeechForTime
|
|
IF GET_GAME_TIMER() >= iMichaelLeaveCarSpeechTime + 6000
|
|
KILL_ANY_CONVERSATION()
|
|
bKilledMichaelLeaveCarSpeechForTime = TRUE
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF BRING_VEHICLE_TO_HALT_AND_DISABLE_VEH_CONTROLS(snatchAndGrabVehicle[SAGV_MICHAEL_CAR], 8.0) // 35
|
|
OR bForcePassOnShitskip
|
|
IF IS_PED_SITTING_IN_ANY_VEHICLE(PLAYER_PED_ID())
|
|
SET_PLAYER_CONTROL(PLAYER_ID(), FALSE, SPC_LEAVE_CAMERA_CONTROL_ON)
|
|
TASK_LEAVE_ANY_VEHICLE(PLAYER_PED_ID())
|
|
//TASK_FOLLOW_NAV_MESH_TO_COORD(PLAYER_PED_ID(), <<1372.62964, -2073.26221, 50.99822>>, PEDMOVE_WALK, DEFAULT_TIME_NEVER_WARP, 5)
|
|
ELSE
|
|
IF NOT bSetNavmesh
|
|
IF GET_SCRIPT_TASK_STATUS(PLAYER_PED_ID(), SCRIPT_TASK_FOLLOW_NAV_MESH_TO_COORD) = FINISHED_TASK
|
|
//TASK_GO_TO_ENTITY(PLAYER_PED_ID(), sSelectorPeds.pedID[SELECTOR_PED_TREVOR], DEFAULT_TIME_NEVER_WARP, 5.0, PEDMOVE_WALK)
|
|
TASK_FOLLOW_NAV_MESH_TO_COORD(PLAYER_PED_ID(), <<1372.62964, -2073.26221, 50.99822>>, PEDMOVE_WALK, DEFAULT_TIME_NEVER_WARP, 5, ENAV_NO_STOPPING)
|
|
bSetNavmesh = TRUE
|
|
iSetNavmeshTime = GET_GAME_TIMER()
|
|
ENDIF
|
|
ELSE
|
|
IF GET_GAME_TIMER() <= iSetNavmeshTime + 5000
|
|
SET_PED_MIN_MOVE_BLEND_RATIO(PLAYER_PED_ID(), PEDMOVE_WALK)
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF NOT IS_PED_IN_ANY_VEHICLE(PLAYER_PED_ID())
|
|
SET_GAMEPLAY_HINT_CAMERA_BLEND_TO_FOLLOW_PED_MEDIUM_VIEW_MODE(TRUE)
|
|
SET_GAMEPLAY_COORD_HINT(<<1373.1, -2073.4, 52.5>>, -1, 2000)
|
|
SET_GAMEPLAY_HINT_FOLLOW_DISTANCE_SCALAR(0.5)
|
|
SET_GAMEPLAY_HINT_CAMERA_RELATIVE_SIDE_OFFSET(-0.8)
|
|
SET_GAMEPLAY_HINT_CAMERA_RELATIVE_VERTICAL_OFFSET(-0.04)
|
|
SET_GAMEPLAY_HINT_FOV(30)
|
|
|
|
IF iPushInTime < 0
|
|
iPushInTime = GET_GAME_TIMER()
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF NOT IS_PED_HEADTRACKING_ENTITY(PLAYER_PED_ID(), sSelectorPeds.pedID[SELECTOR_PED_TREVOR])
|
|
TASK_LOOK_AT_ENTITY(PLAYER_PED_ID(), sSelectorPeds.pedID[SELECTOR_PED_TREVOR], -1, SLF_WHILE_NOT_IN_FOV)
|
|
ENDIF
|
|
|
|
SET_VEHICLE_IS_CONSIDERED_BY_PLAYER(snatchAndGrabVehicle[SAGV_MICHAEL_CAR], FALSE)
|
|
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 bDoneDaveShuffle
|
|
IF NOT IS_PED_IN_VEHICLE(PLAYER_PED_ID(), snatchAndGrabVehicle[SAGV_MICHAEL_CAR])
|
|
AND NOT IS_PED_INJURED(davePed)
|
|
TASK_LOOK_AT_ENTITY(davePed, PLAYER_PED_ID(), -1, SLF_WHILE_NOT_IN_FOV)
|
|
TASK_SHUFFLE_TO_NEXT_VEHICLE_SEAT(davePed, snatchAndGrabVehicle[SAGV_MICHAEL_CAR])
|
|
|
|
REPLAY_RECORD_BACK_FOR_TIME(5.0, 5.0, REPLAY_IMPORTANCE_HIGHEST)
|
|
|
|
bDoneDaveShuffle = TRUE
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF NOT IS_ANY_CONVERSATION_ONGOING_OR_QUEUED()
|
|
AND GET_GAME_TIMER() >= iPushInTime + 2000
|
|
AND (bCanRunPickupChopperScene OR bForcePassOnShitskip)
|
|
IF CAN_ADVANCE_MISSION()
|
|
IF HAS_CUTSCENE_LOADED_WITH_FAILSAFE()
|
|
bRunningCutscene = TRUE
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
|
|
//IF NOT bRestoredControlOnStart
|
|
// IF IS_PED_IN_VEHICLE(PLAYER_PED_ID(), snatchAndGrabVehicle[SAGV_MICHAEL_CAR])
|
|
// SET_PLAYER_CONTROL(PLAYER_ID(), TRUE)
|
|
// bRestoredControlOnStart = TRUE
|
|
// ENDIF
|
|
//ELSE
|
|
IF NOT bCutsceneWaitStarted
|
|
HANDLE_GET_TO_LOCATION(TRUE, NOT bDaveInCar, bDaveInCar, TRUE)
|
|
ENDIF
|
|
//ENDIF
|
|
|
|
IF NOT g_bMagDemoActive
|
|
IF NOT bDoneGotoSpeech
|
|
IF iWanted = 0
|
|
IF bPrestreamedLine
|
|
IF GET_IS_PRELOADED_CONVERSATION_READY()
|
|
BEGIN_PRELOADED_CONVERSATION()
|
|
bDoneGotoSpeech = TRUE
|
|
ELSE
|
|
KILL_ANY_CONVERSATION()
|
|
bPrestreamedLine = FALSE
|
|
ENDIF
|
|
ELSE
|
|
bDoneGotoSpeech = DO_MISSION_SPEECH("FBI2_OLDDOG")
|
|
ENDIF
|
|
ELSE
|
|
bDoneGotoSpeech = TRUE
|
|
ENDIF
|
|
ELSE
|
|
IF iWanted = 0
|
|
IF NOT bDoneDaveLetsGoSpeech
|
|
bDoneDaveLetsGoSpeech = DO_MISSION_SPEECH("FBI2_WALK", FALSE, 1)
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ELSE
|
|
DO_MEETING_CUTSCENE()
|
|
ENDIF
|
|
ENDPROC
|
|
|
|
// for rappel scene
|
|
PROC ENSURE_ENGINE_AND_BLADES_ON()
|
|
IF IS_VEHICLE_DRIVEABLE(snatchAndGrabVehicle[SAGV_PLAYER_CHOPPER])
|
|
SET_HELI_BLADES_FULL_SPEED(snatchAndGrabVehicle[SAGV_PLAYER_CHOPPER])
|
|
SET_VEHICLE_ENGINE_ON(snatchAndGrabVehicle[SAGV_PLAYER_CHOPPER], TRUE, TRUE)
|
|
ENDIF
|
|
ENDPROC
|
|
|
|
// start rappel cutscene procedure
|
|
PROC DO_START_RAPPEL_CUTSCENE()
|
|
//HANDLE_RANDOM_VEHICLE_GENERATION(TRUE)
|
|
SWITCH cutsceneStage
|
|
CASE SAG_CUT_STAGE_INIT
|
|
// jump out
|
|
IF IS_VEHICLE_DRIVEABLE(snatchAndGrabVehicle[SAGV_PLAYER_CHOPPER])
|
|
SET_HELI_TURBULENCE_SCALAR(snatchAndGrabVehicle[SAGV_PLAYER_CHOPPER],1.0)
|
|
SET_AIRCRAFT_PILOT_SKILL_NOISE_SCALAR(snatchAndGrabVehicle[SAGV_PLAYER_CHOPPER],1.0)
|
|
ENSURE_ENGINE_AND_BLADES_ON()
|
|
IF IS_PLAYBACK_GOING_ON_FOR_VEHICLE(snatchAndGrabVehicle[SAGV_PLAYER_CHOPPER])
|
|
STOP_PLAYBACK_RECORDED_VEHICLE(snatchAndGrabVehicle[SAGV_PLAYER_CHOPPER])
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF NOT IS_PED_INJURED(sSelectorPeds.pedID[SELECTOR_PED_MICHAEL])
|
|
REGISTER_ENTITY_FOR_CUTSCENE(sSelectorPeds.pedID[SELECTOR_PED_MICHAEL], "Michael", CU_ANIMATE_EXISTING_SCRIPT_ENTITY)
|
|
ENDIF
|
|
|
|
IF NOT IS_PED_INJURED(PLAYER_PED_ID())
|
|
REGISTER_ENTITY_FOR_CUTSCENE(PLAYER_PED_ID(), "Trevor", CU_ANIMATE_EXISTING_SCRIPT_ENTITY)
|
|
ENDIF
|
|
|
|
IF IS_VEHICLE_DRIVEABLE(snatchAndGrabVehicle[SAGV_PLAYER_CHOPPER])
|
|
REGISTER_ENTITY_FOR_CUTSCENE(snatchAndGrabVehicle[SAGV_PLAYER_CHOPPER], "Main_Heli", CU_ANIMATE_EXISTING_SCRIPT_ENTITY)
|
|
ENDIF
|
|
|
|
REGISTER_ENTITY_FOR_CUTSCENE(cutsceneChairObject[0], "P_CS_15M_ROPE_S", CU_CREATE_AND_ANIMATE_NEW_SCRIPT_ENTITY, P_CS_15M_ROPE_S)
|
|
REGISTER_ENTITY_FOR_CUTSCENE(cutsceneChairObject[1], "P_RPULLEY_S", CU_CREATE_AND_ANIMATE_NEW_SCRIPT_ENTITY, P_RPULLEY_S)
|
|
|
|
TRIGGER_MISSION_MUSIC_EVENT("FIB2_RAPPEL_CS_START")
|
|
START_CUTSCENE(CUTSCENE_SUPPRESS_FP_TRANSITION_FLASH)
|
|
|
|
SET_CUTSCENE_FADE_VALUES(FALSE, FALSE, FALSE, FALSE)
|
|
iSnatchAndGrabCutsceneTime = GET_GAME_TIMER()
|
|
cutsceneStage = SAG_CUT_STAGE_RUNNING
|
|
BREAK
|
|
|
|
CASE SAG_CUT_STAGE_RUNNING
|
|
ENSURE_ENGINE_AND_BLADES_ON()
|
|
|
|
IF NOT bClearedForCutscene
|
|
IF IS_CUTSCENE_PLAYING()
|
|
SET_MISSION_MOCAP_CUTSCENE()
|
|
KILL_CHASE_HINT_CAM(localChaseHintCamStruct)
|
|
//DELETE_CHECKPOINT(jumpCheckpoint)
|
|
|
|
DISABLE_DOWNWASH_PTFX(TRUE)
|
|
|
|
REPLAY_START_EVENT(REPLAY_IMPORTANCE_HIGHEST)
|
|
|
|
// mask on
|
|
IF NOT IS_PED_INJURED(sSelectorPeds.pedID[SELECTOR_PED_MICHAEL])
|
|
SETUP_PLAYER_CHARACTER_WITH_MISSION_VARIATIONS(sSelectorPeds.pedID[SELECTOR_PED_MICHAEL], CHAR_MICHAEL, STAGE_RAPPEL_DOWN)
|
|
SET_PLAYER_PED_WITH_HEADSET(CHAR_MICHAEL, TRUE)
|
|
RELEASE_PED_PRELOAD_PROP_DATA(sSelectorPeds.pedID[SELECTOR_PED_MICHAEL])
|
|
ENDIF
|
|
|
|
//SCRIPT_OVERRIDES_WIND_TYPES(TRUE, "WEATHER_TYPES_MAGDEMO_FIB2_RAPPEL","WEATHER_TYPES_MAGDEMO_FIB2_RAPPEL")
|
|
|
|
STOP_SNATCH_AND_GRAB_AUDIO_SCENE(SNATCH_AND_GRAB_AUDIO_SCENE_FLY_TO_AGENCY)
|
|
STOP_SNATCH_AND_GRAB_AUDIO_SCENE(SNATCH_AND_GRAB_AUDIO_SCENE_FOCUS_ON_ROOF)
|
|
|
|
//CLEAR_AREA(<<91.91, -630.54, 43.27>>, 300, TRUE)
|
|
//SET_SNATCH_AND_GRAB_ROADS(FALSE, TRUE, TRUE)
|
|
SET_VEHICLE_POPULATION_BUDGET(2)
|
|
SET_PED_POPULATION_BUDGET(0)
|
|
INSTANTLY_FILL_VEHICLE_POPULATION()
|
|
SET_FAR_DRAW_VEHICLES(TRUE)
|
|
|
|
IF IS_VEHICLE_DRIVEABLE(snatchAndGrabVehicle[SAGV_PLAYER_CHOPPER])
|
|
CREATE_RAPPEL_ANCHOR(rappelData, snatchAndGrabVehicle[SAGV_PLAYER_CHOPPER], GET_SNATCH_AND_GRAB_VECTOR(SAGVEC_ROPE_ANCHOR_OFFSET), GET_SNATCH_AND_GRAB_VECTOR(SAGVEC_ROPE_ANCHOR_ROT))
|
|
ENDIF
|
|
STOP_VEHICLE_FIRE(snatchAndGrabVehicle[SAGV_PLAYER_CHOPPER])
|
|
|
|
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 CAN_SET_EXIT_STATE_FOR_REGISTERED_ENTITY("Michael")
|
|
IF GET_CURRENT_PLAYER_PED_ENUM() <> CHAR_MICHAEL
|
|
MAKE_SELECTOR_PED_SELECTION(sSelectorPeds, SELECTOR_PED_MICHAEL)
|
|
TAKE_CONTROL_OF_SELECTOR_PED(sSelectorPeds, TRUE, TRUE, TCF_CLEAR_TASK_INTERRUPT_CHECKS)
|
|
REAPPLY_PLAYER_PED_ATTRIBUTES()
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF CAN_SET_EXIT_STATE_FOR_REGISTERED_ENTITY("Main_Heli")
|
|
IF IS_VEHICLE_DRIVEABLE(snatchAndGrabVehicle[SAGV_PLAYER_CHOPPER])
|
|
ENSURE_ENGINE_AND_BLADES_ON()
|
|
SHUT_ALL_CHOPPER_DOORS()
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF CAN_SET_EXIT_STATE_FOR_REGISTERED_ENTITY("Trevor")
|
|
IF IS_VEHICLE_DRIVEABLE(snatchAndGrabVehicle[SAGV_PLAYER_CHOPPER])
|
|
IF NOT IS_PED_INJURED(sSelectorPeds.pedID[SELECTOR_PED_TREVOR])
|
|
IF NOT IS_PED_IN_VEHICLE(sSelectorPeds.pedID[SELECTOR_PED_TREVOR], snatchAndGrabVehicle[SAGV_PLAYER_CHOPPER])
|
|
SET_PED_INTO_VEHICLE(sSelectorPeds.pedID[SELECTOR_PED_TREVOR], snatchAndGrabVehicle[SAGV_PLAYER_CHOPPER])
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF NOT DOES_ENTITY_EXIST(cutsceneChairObject[0])
|
|
IF DOES_ENTITY_EXIST(GET_ENTITY_INDEX_OF_REGISTERED_ENTITY("P_CS_15M_ROPE_S"))
|
|
cutsceneChairObject[0] = GET_OBJECT_INDEX_FROM_ENTITY_INDEX(GET_ENTITY_INDEX_OF_REGISTERED_ENTITY("P_CS_15M_ROPE_S"))
|
|
ENDIF
|
|
ENDIF
|
|
IF NOT DOES_ENTITY_EXIST(cutsceneChairObject[1])
|
|
IF DOES_ENTITY_EXIST(GET_ENTITY_INDEX_OF_REGISTERED_ENTITY("P_RPULLEY_S"))
|
|
cutsceneChairObject[1] = GET_OBJECT_INDEX_FROM_ENTITY_INDEX(GET_ENTITY_INDEX_OF_REGISTERED_ENTITY("P_RPULLEY_S"))
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF CAN_SET_EXIT_STATE_FOR_REGISTERED_ENTITY("P_CS_15M_ROPE_S")
|
|
DELETE_OBJECT(cutsceneChairObject[0])
|
|
ENDIF
|
|
|
|
IF CAN_SET_EXIT_STATE_FOR_REGISTERED_ENTITY("P_RPULLEY_S")
|
|
DELETE_OBJECT(cutsceneChairObject[1])
|
|
ENDIF
|
|
|
|
IF CAN_SET_EXIT_STATE_FOR_CAMERA()
|
|
|
|
REPLAY_STOP_EVENT()
|
|
|
|
rappelData.ped = PLAYER_PED_ID()
|
|
SET_MISSION_CUTSCENE(FALSE, FALSE, FALSE)
|
|
SET_MISSION_STAGE(STAGE_RAPPEL_DOWN, FALSE, TRUE, FALSE)
|
|
ENDIF
|
|
|
|
#IF IS_DEBUG_BUILD
|
|
DEBUG_SKIP_MOCAP()
|
|
#ENDIF
|
|
BREAK
|
|
|
|
CASE SAG_CUT_STAGE_CLEANUP
|
|
BREAK
|
|
ENDSWITCH
|
|
|
|
IF bClearedForCutscene
|
|
CASCADE_SHADOWS_SET_CASCADE_BOUNDS_SCALE(CASCADE_SHADOWS_MULTIPLIER_EXTERIOR_OVERRIDE)
|
|
SET_AMBIENT_VEHICLE_RANGE_MULTIPLIER_THIS_FRAME(RAPPEL_VEHICLE_RANGE_MULTIPLIER)
|
|
ENDIF
|
|
ENDPROC
|
|
|
|
// fly the chopper to the top of the FBI building
|
|
PROC DO_STAGE_GET_TO_BUILDING()
|
|
IF NOT bRunningCutscene
|
|
INT iWanted = GET_PLAYER_WANTED_LEVEL(PLAYER_ID())
|
|
|
|
IF bForcePassOnShitskip
|
|
IF NOT bWarpedChopperToBuilding
|
|
IF IS_VEHICLE_DRIVEABLE(snatchAndGrabVehicle[SAGV_PLAYER_CHOPPER])
|
|
//SET_ENTITY_COORDS(snatchAndGrabVehicle[SAGV_PLAYER_CHOPPER], GET_SNATCH_AND_GRAB_VECTOR(SAGVEC_HOVER_TARGET))
|
|
SET_HELI_BLADES_FULL_SPEED(snatchAndGrabVehicle[SAGV_PLAYER_CHOPPER])
|
|
//LOAD_SCENE(GET_SNATCH_AND_GRAB_VECTOR(SAGVEC_HOVER_TARGET))
|
|
//WAIT(0)
|
|
bWarpedChopperToBuilding = TRUE
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
|
|
// remove util trucks
|
|
IF NOT bRemovedUtilTrucks
|
|
IF NOT IS_ENTITY_AT_COORD(PLAYER_PED_ID(), <<1393.64, -2053.64, 51.00>>, <<700,700,700>>, FALSE, FALSE)
|
|
OR bForcePassOnShitskip
|
|
INT i
|
|
REPEAT COUNT_OF(utilTruckVehicle) i
|
|
IF DOES_ENTITY_EXIST(utilTruckVehicle[i])
|
|
SET_VEHICLE_AS_NO_LONGER_NEEDED(utilTruckVehicle[i])
|
|
ENDIF
|
|
ENDREPEAT
|
|
|
|
CLEAR_MODEL_REQUEST(ENUM_TO_INT(SAGM_UTIL_TRUCK_1))
|
|
CLEAR_MODEL_REQUEST(ENUM_TO_INT(SAGM_UTIL_TRUCK_2))
|
|
|
|
bRemovedUtilTrucks = TRUE
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF NOT bForcePassOnShitskip
|
|
IF bDoneGetInPositionSpeech
|
|
CONTROL_COORD_CHASE_HINT_CAM_IN_VEHICLE(localChaseHintCamStruct, GET_SNATCH_AND_GRAB_VECTOR(SAGVEC_HOVER_TARGET))
|
|
|
|
IF NOT IS_GAMEPLAY_HINT_ACTIVE()
|
|
AND GET_CAM_VIEW_MODE_FOR_CONTEXT(CAM_VIEW_MODE_CONTEXT_IN_HELI) <> CAM_VIEW_MODE_FIRST_PERSON
|
|
IF NOT bDoneTowerHintCamHelp
|
|
bDoneTowerHintCamHelp = DO_MISSION_HELP_TEXT("SG_DROHLP")
|
|
ENDIF
|
|
ELSE
|
|
IF GET_CAM_VIEW_MODE_FOR_CONTEXT(CAM_VIEW_MODE_CONTEXT_IN_HELI) <> CAM_VIEW_MODE_FIRST_PERSON
|
|
bDoneTowerHintCamHelp = TRUE
|
|
ENDIF
|
|
|
|
IF IS_THIS_HELP_MESSAGE_BEING_DISPLAYED("SG_DROHLP")
|
|
IF GET_GAME_TIMER() >= iClearHelpTime + 1000
|
|
CLEAR_HELP(FALSE)
|
|
iClearHelpTime = GET_GAME_TIMER()
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF NOT bDoneFocusCamAudioScene
|
|
IF IS_GAMEPLAY_HINT_ACTIVE()
|
|
START_SNATCH_AND_GRAB_AUDIO_SCENE(SNATCH_AND_GRAB_AUDIO_SCENE_FOCUS_ON_ROOF)
|
|
bDoneFocusCamAudioScene = TRUE
|
|
ENDIF
|
|
ELSE
|
|
IF NOT IS_GAMEPLAY_HINT_ACTIVE()
|
|
STOP_SNATCH_AND_GRAB_AUDIO_SCENE(SNATCH_AND_GRAB_AUDIO_SCENE_FOCUS_ON_ROOF)
|
|
bDoneFocusCamAudioScene = FALSE
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF IS_VEHICLE_DRIVEABLE(snatchAndGrabVehicle[SAGV_PLAYER_CHOPPER])
|
|
AND NOT IS_PED_INJURED(sSelectorPeds.pedID[SELECTOR_PED_MICHAEL])
|
|
|
|
IF IS_ENTITY_AT_COORD(PLAYER_PED_ID(), GET_SNATCH_AND_GRAB_VECTOR(SAGVEC_HOVER_TARGET), <<100,100,80>>)
|
|
SET_HELI_TURBULENCE_SCALAR(snatchAndGrabVehicle[SAGV_PLAYER_CHOPPER],0.0)
|
|
SET_AIRCRAFT_PILOT_SKILL_NOISE_SCALAR(snatchAndGrabVehicle[SAGV_PLAYER_CHOPPER],0.0)
|
|
ELSE
|
|
SET_HELI_TURBULENCE_SCALAR(snatchAndGrabVehicle[SAGV_PLAYER_CHOPPER],1.0)
|
|
SET_AIRCRAFT_PILOT_SKILL_NOISE_SCALAR(snatchAndGrabVehicle[SAGV_PLAYER_CHOPPER],1.0)
|
|
ENDIF
|
|
|
|
CONST_INT INTERP_BACK_TIME 3000
|
|
|
|
IF NOT bForcePassOnShitskip
|
|
IF NOT bDoneInterpBackToGame
|
|
//DISABLE_CONTROL_ACTION(PLAYER_CONTROL, INPUT_LOOK_LR)
|
|
//DISABLE_CONTROL_ACTION(PLAYER_CONTROL, INPUT_LOOK_UD)
|
|
//DISABLE_CONTROL_ACTION(PLAYER_CONTROL, INPUT_VEH_EXIT)
|
|
|
|
IF bHeliLiftedOff
|
|
IF GET_GAME_TIMER() >= iInterpBackToGameTime + INTERP_BACK_TIME
|
|
bDoneInterpBackToGame = TRUE
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF IS_PED_IN_VEHICLE(PLAYER_PED_ID(), snatchAndGrabVehicle[SAGV_PLAYER_CHOPPER])
|
|
IF NOT bHeliLiftedOff
|
|
FLOAT fGroundHeight
|
|
FLOAT fHeightAboveGround
|
|
VECTOR vPlayerPos = GET_ENTITY_COORDS(PLAYER_PED_ID())
|
|
GET_GROUND_Z_FOR_3D_COORD(vPlayerPos, fGroundHeight)
|
|
IF fGroundHeight < 0
|
|
fGroundHeight = 0
|
|
ENDIF
|
|
|
|
fHeightAboveGround = vPlayerPos.z - fGroundHeight
|
|
IF fHeightAboveGround > 1
|
|
//RENDER_SCRIPT_CAMS(FALSE, TRUE, INTERP_BACK_TIME)
|
|
iInterpBackToGameTime = GET_GAME_TIMER()
|
|
bHeliLiftedOff = TRUE
|
|
ENDIF
|
|
ELSE
|
|
IF NOT bDoneHalfwayThereCue
|
|
IF IS_ENTITY_AT_COORD(PLAYER_PED_ID(), <<132.47, -636.71, 261.85>>, <<950,950,950>>, FALSE, FALSE)
|
|
bDoneHalfwayThereCue = TRIGGER_MISSION_MUSIC_EVENT("FIB2_HALFWAY_THERE")
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
|
|
// advance mission on arrival
|
|
IF iWanted = 0
|
|
CONST_FLOAT HOVER_TARGET_MAX_HEIGHT 284.0
|
|
CONST_FLOAT HOVER_TARGET_MIN_HEIGHT 257.0
|
|
CONST_FLOAT MARKER_RING_SIZE 18.0
|
|
CONST_FLOAT MARKER_CYLINDER_SIZE 17.0
|
|
|
|
IF CAN_ADVANCE_MISSION()
|
|
IF IS_PED_IN_VEHICLE(PLAYER_PED_ID(), snatchAndGrabVehicle[SAGV_PLAYER_CHOPPER])
|
|
AND IS_PED_IN_VEHICLE(sSelectorPeds.pedID[SELECTOR_PED_MICHAEL], snatchAndGrabVehicle[SAGV_PLAYER_CHOPPER])
|
|
//IS_ENTITY_AT_COORD(PLAYER_PED_ID(), GET_SNATCH_AND_GRAB_VECTOR(SAGVEC_HOVER_TARGET), <<7,7,7>>, TRUE)
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF IS_PED_SITTING_IN_VEHICLE(PLAYER_PED_ID(), snatchAndGrabVehicle[SAGV_PLAYER_CHOPPER])
|
|
AND IS_PED_IN_VEHICLE(sSelectorPeds.pedID[SELECTOR_PED_MICHAEL], snatchAndGrabVehicle[SAGV_PLAYER_CHOPPER])
|
|
HANDLE_STREAMING_MOCAP("fbi_2_mcs_2", GET_SNATCH_AND_GRAB_VECTOR(SAGVEC_HOVER_TARGET), DEFAULT_CUTSCENE_LOAD_DIST, DEFAULT_CUTSCENE_UNLOAD_DIST)
|
|
|
|
IF CAN_REQUEST_ASSETS_FOR_CUTSCENE_ENTITY()
|
|
IF NOT IS_PED_INJURED(GET_MICHAEL_PED())
|
|
SET_CUTSCENE_PED_COMPONENT_VARIATION_FROM_PED("Michael", GET_MICHAEL_PED())
|
|
ENDIF
|
|
|
|
IF NOT IS_PED_INJURED(GET_TREVOR_PED())
|
|
SET_CUTSCENE_PED_PROP_VARIATION("Trevor", ANCHOR_HEAD, 12)
|
|
ENDIF
|
|
ENDIF
|
|
|
|
|
|
// IF bDebugSkipMagdemoUseRing
|
|
// DRAW_MARKER(MARKER_RING, GET_SNATCH_AND_GRAB_VECTOR(SAGVEC_HOVER_TARGET) + <<1,-1, 0>>, <<0,0,0>>, <<90,0,-123>>, <<MARKER_RING_SIZE,MARKER_RING_SIZE,MARKER_RING_SIZE>>, 255, 255, 0, 100)
|
|
// ELSE
|
|
// DRAW_MARKER(MARKER_CYLINDER, GET_SNATCH_AND_GRAB_VECTOR(SAGVEC_HOVER_TARGET) + <<1,-1,-13.5>>, <<0.0,0.0,0.0>>, <<0.0,0.0,0.0>>, <<MARKER_CYLINDER_SIZE,MARKER_CYLINDER_SIZE,MARKER_CYLINDER_SIZE + 16>>, 255, 255, 0, 180)
|
|
// ENDIF
|
|
|
|
// draw the marker
|
|
IF NOT bForcePassOnShitSkip
|
|
IF bSavedBanter
|
|
IF NOT bDoneGetInPositionSpeech
|
|
IF RESTORE_BANTER()
|
|
bSavedBanter = FALSE
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF NOT bRequestedAtBuildingAssets
|
|
ADD_RECORDING_REQUEST(001)
|
|
ADD_MODEL_REQUEST(ENUM_TO_INT(SAGM_HARNESS))
|
|
bRequestedAtBuildingAssets = TRUE
|
|
ENDIF
|
|
|
|
//IF IS_ENTITY_AT_COORD(PLAYER_PED_ID(), GET_SNATCH_AND_GRAB_VECTOR(SAGVEC_HOVER_TARGET) ,<<60,60,30>>, FALSE, TRUE)
|
|
BOOL bAtWall = IS_ENTITY_IN_ANGLED_AREA(PLAYER_PED_ID(), <<102.560, -645.660, HOVER_TARGET_MIN_HEIGHT>>, <<116.050, -609.760, HOVER_TARGET_MAX_HEIGHT>>, 20.0, FALSE, FALSE)
|
|
VECTOR vChopperPos = GET_ENTITY_COORDS(PLAYER_PED_ID())
|
|
|
|
IF (bAtWall
|
|
AND vChopperPos.z <= HOVER_TARGET_MAX_HEIGHT
|
|
AND vChopperPos.z >= HOVER_TARGET_MIN_HEIGHT)
|
|
OR bForcePassOnShitskip
|
|
OR bHitCutsceneFailsafe
|
|
IF (CAN_ADVANCE_MISSION()
|
|
AND NOT IS_ANY_CONVERSATION_ONGOING_OR_QUEUED()
|
|
AND HAVE_ALL_MODEL_REQUESTS_SUCCEEDED()
|
|
AND HAVE_ALL_RECORDING_REQUESTS_SUCCEEDED())
|
|
OR bHitCutsceneFailsafe
|
|
bHitCutsceneFailsafe = TRUE
|
|
IF HAS_CUTSCENE_LOADED_WITH_FAILSAFE()
|
|
bRunningCutscene = TRUE
|
|
ENDIF
|
|
ENDIF
|
|
ELIF IS_ENTITY_AT_COORD(PLAYER_PED_ID(), GET_SNATCH_AND_GRAB_VECTOR(SAGVEC_HOVER_TARGET) ,<<250,250,80>>, FALSE, FALSE)
|
|
IF NOT bForcePassOnShitskip
|
|
IF NOT bKilledBanterInChopper
|
|
KILL_ANY_CONVERSATION()
|
|
bKilledBanterInChopper = TRUE
|
|
ELSE
|
|
IF NOT bDoneGetInPositionSpeech
|
|
IF DO_MISSION_SPEECH("FBI2_MWHERE")
|
|
bDoneGetInPositionSpeech = TRUE
|
|
iNextGetInPositionSpeechTime = GET_GAME_TIMER() + 20000
|
|
ENDIF
|
|
ELSE
|
|
IF IS_ENTITY_AT_COORD(PLAYER_PED_ID(), GET_SNATCH_AND_GRAB_VECTOR(SAGVEC_HOVER_TARGET) ,<<125,125,100>>, FALSE, FALSE)
|
|
|
|
// give prompt about how to get in
|
|
IF GET_GAME_TIMER() >= iNextGetInPositionSpeechTime
|
|
|
|
BOOL bDoneSpeech = FALSE
|
|
IF vChopperPos.z >= 340
|
|
// too high
|
|
bDoneSpeech = DO_MISSION_SPEECH("FBI2_MLOW")
|
|
ELIF vChopperPos.z <= 190
|
|
// too low
|
|
bDoneSpeech = DO_MISSION_SPEECH("FBI2_MHIGH")
|
|
ELIF IS_ENTITY_IN_ANGLED_AREA(PLAYER_PED_ID(), <<114.020, -630.170, 266.430>>, <<149.180, -643.460, 266.410>>, 49.000, FALSE, FALSE)
|
|
AND NOT bAtWall
|
|
// over roof
|
|
bDoneSpeech = DO_MISSION_SPEECH("FBI2_MFURT")
|
|
ELIF IS_ENTITY_IN_ANGLED_AREA(PLAYER_PED_ID(), <<114.940, -628.940, 266.430>>, <<-43.220, -569.490, 266.410>>, 153.000, FALSE, FALSE)
|
|
AND NOT bAtWall
|
|
// too far from wall
|
|
bDoneSpeech = DO_MISSION_SPEECH("FBI2_MTFAR")
|
|
ELSE
|
|
IF NOT bAtWall
|
|
bDoneSpeech = DO_MISSION_SPEECH("FBI2_MWEST")
|
|
ELSE
|
|
// catch all
|
|
IF vChopperPos.z >= HOVER_TARGET_MAX_HEIGHT
|
|
// too high
|
|
bDoneSpeech = DO_MISSION_SPEECH("FBI2_MLOW")
|
|
ELIF vChopperPos.z <= HOVER_TARGET_MIN_HEIGHT
|
|
// too low
|
|
bDoneSpeech = DO_MISSION_SPEECH("FBI2_MHIGH")
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF bDoneSpeech
|
|
iNextGetInPositionSpeechTime = GET_GAME_TIMER() + GET_RANDOM_INT_IN_RANGE(28000, 33000)
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF NOT bForcePassOnShitskip
|
|
// Music changes when player gets close to the building
|
|
IF NOT bCloseToBuilding
|
|
IF IS_ENTITY_IN_AREA(snatchAndGrabVehicle[SAGV_PLAYER_CHOPPER], (<<578, -307, 165>>), (<<111, -1472, 150>>), FALSE, FALSE)
|
|
//TRIGGER_MISSION_MUSIC_EVENT("FBI2_TEST_CLOSE_TO_BUILDING")
|
|
bCloseToBuilding = TRUE
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF NOT bDoneBanter
|
|
IF bDoneGotoSpeech
|
|
AND bShownGodText
|
|
IF NOT bKilledBanterInChopper
|
|
bDoneBanter = DO_MISSION_SPEECH("FBI2_B2AV1")
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF NOT bForcePassOnShitskip
|
|
HANDLE_GET_TO_LOCATION(TRUE, FALSE, TRUE, TRUE)
|
|
ENDIF
|
|
ENDIF
|
|
ELSE
|
|
// Fading music off on arrival at building
|
|
IF NOT bArrivedAtBuilding
|
|
//TRIGGER_MISSION_MUSIC_EVENT("FBI2_TEST_ARRIVE_AT_BUILDING_E")
|
|
bArrivedAtBuilding = TRUE
|
|
ENDIF
|
|
DO_START_RAPPEL_CUTSCENE()
|
|
ENDIF
|
|
ENDPROC
|
|
|
|
PROC DISABLE_BLUR_ON_RIFLE_MODEL()
|
|
IF NOT bDisabledBlurOnRifle
|
|
IF NOT IS_PED_INJURED(dummyFranklinPed)
|
|
ENTITY_INDEX weaponEntity
|
|
OBJECT_INDEX weaponObject
|
|
WEAPON_TYPE weapon
|
|
|
|
GET_CURRENT_PED_WEAPON(dummyFranklinPed, weapon)
|
|
IF weapon = WEAPONTYPE_HEAVYSNIPER
|
|
weaponEntity = GET_CURRENT_PED_WEAPON_ENTITY_INDEX(dummyFranklinPed)
|
|
IF DOES_ENTITY_EXIST(weaponEntity)
|
|
weaponObject = GET_OBJECT_INDEX_FROM_ENTITY_INDEX(weaponEntity)
|
|
SET_ENTITY_MOTION_BLUR(weaponObject, FALSE)
|
|
//PRINTSTRING("disabled blur on rifle") PRINTNL()
|
|
//bDisabledBlurOnRifle = TRUE
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDPROC
|
|
|
|
// smash through and grab prisoner cutscene procedure
|
|
PROC DO_SMASH_IN_CUTSCENE()
|
|
|
|
|
|
INT i
|
|
SWITCH cutsceneStage
|
|
CASE SAG_CUT_STAGE_INIT
|
|
STOP_SYNCHRONIZED_AUDIO_EVENT(iSyncScene)
|
|
|
|
#IF IS_DEBUG_BUILD
|
|
bDebugJSkip = TRUE
|
|
#ENDIF
|
|
|
|
INFORM_MISSION_STATS_SYSTEM_OF_TIME_WINDOW_CLOSED()
|
|
|
|
OVERRIDE_PLAYER_GROUND_MATERIAL(GET_HASH_KEY("AM_BASE_GLASS_STRONG"),FALSE)
|
|
|
|
// michael
|
|
IF NOT IS_PED_INJURED(PLAYER_PED_ID())
|
|
TASK_CLEAR_LOOK_AT(PLAYER_PED_ID())
|
|
//GIVE_PLAYER_MISSION_PISTOL(FALSE, FALSE)
|
|
|
|
REGISTER_ENTITY_FOR_CUTSCENE(michaelGunObject, "Michaels_weapon", CU_ANIMATE_EXISTING_SCRIPT_ENTITY)
|
|
REGISTER_ENTITY_FOR_CUTSCENE(PLAYER_PED_ID(), "Michael", CU_ANIMATE_EXISTING_SCRIPT_ENTITY)
|
|
ENDIF
|
|
|
|
// michelle
|
|
IF NOT IS_PED_INJURED(michellePed)
|
|
REGISTER_ENTITY_FOR_CUTSCENE(michellePed, "Michelle", CU_ANIMATE_EXISTING_SCRIPT_ENTITY)
|
|
ENDIF
|
|
|
|
// mr k
|
|
IF NOT IS_PED_INJURED(prisonerPed)
|
|
REGISTER_ENTITY_FOR_CUTSCENE(prisonerPed, "MR_K", CU_ANIMATE_EXISTING_SCRIPT_ENTITY)
|
|
ENDIF
|
|
|
|
REGISTER_ENTITY_FOR_CUTSCENE(cutsceneChairObject[0], "CIA_Office_Chair", CU_CREATE_AND_ANIMATE_NEW_SCRIPT_ENTITY, V_CORP_OFFCHAIR)
|
|
REGISTER_ENTITY_FOR_CUTSCENE(cutsceneChairObject[1],"CIA_Office_Chair^1", CU_CREATE_AND_ANIMATE_NEW_SCRIPT_ENTITY, V_CORP_OFFCHAIR)
|
|
REGISTER_ENTITY_FOR_CUTSCENE(cutsceneChairObject[2],"CIA_Office_Chair^2", CU_CREATE_AND_ANIMATE_NEW_SCRIPT_ENTITY, V_CORP_OFFCHAIR)
|
|
REGISTER_ENTITY_FOR_CUTSCENE(cutsceneChairObject[3],"CIA_Office_Chair^3", CU_CREATE_AND_ANIMATE_NEW_SCRIPT_ENTITY, V_CORP_OFFCHAIR)
|
|
REGISTER_ENTITY_FOR_CUTSCENE(cutsceneChairObject[4],"PROP_CS_POLICE_TORCH", CU_CREATE_AND_ANIMATE_NEW_SCRIPT_ENTITY, PROP_CS_POLICE_TORCH)
|
|
REGISTER_ENTITY_FOR_CUTSCENE(cutsceneChairObject[5],"Mr_K_Harness", CU_CREATE_AND_ANIMATE_NEW_SCRIPT_ENTITY, P_MRK_HARNESS_S)
|
|
|
|
// franklin
|
|
CREATE_DUMMY_FRANKLIN()
|
|
// IF NOT IS_PED_INJURED(dummyFranklinPed)
|
|
// REGISTER_ENTITY_FOR_CUTSCENE(dummyFranklinPed, "Franklin", CU_ANIMATE_EXISTING_SCRIPT_ENTITY)
|
|
// ENDIF
|
|
|
|
// guards
|
|
TEXT_LABEL tGuardRegister
|
|
FOR i=0 TO 2
|
|
IF NOT IS_PED_INJURED(guardPed[i])
|
|
//SET_CURRENT_PED_WEAPON(guardPed[i], GET_SNATCH_AND_GRAB_WEAPON_TYPE(SAG_WEAPON_CIA_PISTOL), TRUE)
|
|
SWITCH i
|
|
CASE 0
|
|
tGuardRegister = "CIA_Goon_1"
|
|
BREAK
|
|
CASE 1
|
|
tGuardRegister = "Lead_CIA"
|
|
BREAK
|
|
CASE 2
|
|
tGuardRegister = "CIA_Goon_2"
|
|
BREAK
|
|
ENDSWITCH
|
|
REGISTER_ENTITY_FOR_CUTSCENE(guardPed[i], tGuardRegister, CU_ANIMATE_EXISTING_SCRIPT_ENTITY)
|
|
ENDIF
|
|
ENDFOR
|
|
|
|
HANDLE_WINDOW_SMASH(TRUE)
|
|
|
|
START_CUTSCENE(CUTSCENE_SUPPRESS_FP_TRANSITION_FLASH)
|
|
//KILL_FACE_TO_FACE_CONVERSATION_DO_NOT_FINISH_LAST_LINE()
|
|
iGuardSpeech = 0
|
|
iWindowSmashStage = 3
|
|
iSnatchAndGrabCutsceneTime = GET_GAME_TIMER()
|
|
cutsceneStage = SAG_CUT_STAGE_RUNNING
|
|
BREAK
|
|
|
|
CASE SAG_CUT_STAGE_RUNNING
|
|
IF NOT bClearedForCutscene
|
|
IF IS_CUTSCENE_PLAYING()
|
|
SET_MISSION_MOCAP_CUTSCENE()
|
|
|
|
IF DOES_CAM_EXIST(staticCam)
|
|
DESTROY_CAM(staticCam)
|
|
ENDIF
|
|
|
|
SET_HIDOF_OVERRIDE(FALSE, TRUE, 0, 0, 0, 0)
|
|
CASCADE_SHADOWS_ENABLE_FREEZER(TRUE)
|
|
|
|
STOP_SOUND(iRappelWindSoundID)
|
|
STOP_SNATCH_AND_GRAB_AUDIO_SCENE(SNATCH_AND_GRAB_AUDIO_SCENE_RAPPEL)
|
|
STOP_SNATCH_AND_GRAB_AUDIO_SCENE(SNATCH_AND_GRAB_AUDIO_SCENE_BREAK_THE_GLASS)
|
|
|
|
MUFFLE_HELI_SOUND_INDOORS(FALSE)
|
|
|
|
CANCEL_RAPPEL(rappelData, TRUE, WEAPONTYPE_UNARMED, TRUE, FALSE)
|
|
CLEAR_ANIM_DICT_REQUEST(SAG_ANIM_DICT_RAPPEL)
|
|
FORCE_PED_AI_AND_ANIMATION_UPDATE(PLAYER_PED_ID())
|
|
DELETE_RAPPEL_ROPE(rappelData)
|
|
CREATE_CHOPPER_ROPE(ROPE_TYPE_INSIDE, STAGE_RAPPEL_DOWN)
|
|
//HANDLE_CHOPPER_ROPE(ROPE_TYPE_INSIDE)
|
|
DRAW_ROPE_TO_POINT(TRUE, <<110.51, -618.71, 207.12>>)
|
|
|
|
printstring("created rappel rope!") printnl()
|
|
printvector(GET_ROPE_VERTEX_COORD(rappelData.rope, get_rope_vertex_count(rappelData.rope)-1)) printnl()
|
|
|
|
FOR i=0 TO 2
|
|
IF NOT IS_PED_INJURED(guardPed[i])
|
|
SET_PED_COMPONENT_VARIATION(guardPed[i], PED_COMP_HAIR, 3, 0)
|
|
ENDIF
|
|
ENDFOR
|
|
|
|
SET_CHOPPER_TO_ESCAPE()
|
|
IF DOES_ENTITY_EXIST(torchObject)
|
|
IF bKeepTorch
|
|
DETACH_ENTITY(torchObject)
|
|
SET_ENTITY_COORDS_NO_OFFSET(torchObject, <<114.72, -620.69, 205.90>>)
|
|
SET_ENTITY_ROTATION(torchObject, <<0,0, -79.068>>)
|
|
FREEZE_ENTITY_POSITION(torchObject, TRUE)
|
|
ELSE
|
|
DELETE_OBJECT(torchObject)
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF IS_SCREEN_FADED_OUT()
|
|
DO_SCREEN_FADE_IN(DEFAULT_FADE_TIME)
|
|
ENDIF
|
|
|
|
bClearedForCutscene = TRUE
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF NOT DOES_ENTITY_EXIST(cutsceneChairObject[0])
|
|
IF DOES_ENTITY_EXIST(GET_ENTITY_INDEX_OF_REGISTERED_ENTITY("CIA_Office_Chair"))
|
|
cutsceneChairObject[0] = GET_OBJECT_INDEX_FROM_ENTITY_INDEX(GET_ENTITY_INDEX_OF_REGISTERED_ENTITY("CIA_Office_Chair"))
|
|
ENDIF
|
|
ENDIF
|
|
IF NOT DOES_ENTITY_EXIST(cutsceneChairObject[1])
|
|
IF DOES_ENTITY_EXIST(GET_ENTITY_INDEX_OF_REGISTERED_ENTITY("CIA_Office_Chair^1"))
|
|
cutsceneChairObject[1] = GET_OBJECT_INDEX_FROM_ENTITY_INDEX(GET_ENTITY_INDEX_OF_REGISTERED_ENTITY("CIA_Office_Chair^1"))
|
|
ENDIF
|
|
ENDIF
|
|
IF NOT DOES_ENTITY_EXIST(cutsceneChairObject[2])
|
|
IF DOES_ENTITY_EXIST(GET_ENTITY_INDEX_OF_REGISTERED_ENTITY("CIA_Office_Chair^2"))
|
|
cutsceneChairObject[2] = GET_OBJECT_INDEX_FROM_ENTITY_INDEX(GET_ENTITY_INDEX_OF_REGISTERED_ENTITY("CIA_Office_Chair^2"))
|
|
ENDIF
|
|
ENDIF
|
|
IF NOT DOES_ENTITY_EXIST(cutsceneChairObject[3])
|
|
IF DOES_ENTITY_EXIST(GET_ENTITY_INDEX_OF_REGISTERED_ENTITY("CIA_Office_Chair^3"))
|
|
cutsceneChairObject[3] = GET_OBJECT_INDEX_FROM_ENTITY_INDEX(GET_ENTITY_INDEX_OF_REGISTERED_ENTITY("CIA_Office_Chair^3"))
|
|
ENDIF
|
|
ENDIF
|
|
IF NOT DOES_ENTITY_EXIST(cutsceneChairObject[4])
|
|
IF DOES_ENTITY_EXIST(GET_ENTITY_INDEX_OF_REGISTERED_ENTITY("PROP_CS_POLICE_TORCH"))
|
|
cutsceneChairObject[4] = GET_OBJECT_INDEX_FROM_ENTITY_INDEX(GET_ENTITY_INDEX_OF_REGISTERED_ENTITY("PROP_CS_POLICE_TORCH"))
|
|
ENDIF
|
|
ENDIF
|
|
IF NOT DOES_ENTITY_EXIST(cutsceneChairObject[5])
|
|
IF DOES_ENTITY_EXIST(GET_ENTITY_INDEX_OF_REGISTERED_ENTITY("Mr_K_Harness"))
|
|
cutsceneChairObject[5] = GET_OBJECT_INDEX_FROM_ENTITY_INDEX(GET_ENTITY_INDEX_OF_REGISTERED_ENTITY("Mr_K_Harness"))
|
|
ENDIF
|
|
ENDIF
|
|
|
|
HANDLE_CHOPPER_ROPE(ROPE_TYPE_INSIDE) // chopper rope
|
|
|
|
// get rid of traffic - staggering expensive calls throughout first few frames
|
|
IF NOT bDeletedTraffic
|
|
REPEAT COUNT_OF(trafficVehicle) i
|
|
IF DOES_ENTITY_EXIST(trafficVehicle[i])
|
|
DELETE_VEHICLE(trafficVehicle[i])
|
|
ENDIF
|
|
ENDREPEAT
|
|
bDeletedTraffic = TRUE
|
|
ELSE
|
|
// create sniper
|
|
IF NOT bCreatedSniper
|
|
CREATE_SNIPER_OBJECT()
|
|
FREEZE_FRANKLIN_AT_SNIPER()
|
|
bCreatedSniper = TRUE
|
|
ENDIF
|
|
ENDIF
|
|
|
|
SWITCH smashThroughShot
|
|
// smash in mocap
|
|
CASE SMASH_THROUGH_MOCAP
|
|
bForcePassOnShitskip = FALSE
|
|
CASCADE_SHADOWS_SET_CASCADE_BOUNDS_SCALE(CASCADE_SHADOWS_MULTIPLIER_INTERIOR_OVERRIDE)
|
|
CASCADE_SHADOWS_SET_ENTITY_TRACKER_SCALE(1.0)
|
|
|
|
IF CAN_SET_EXIT_STATE_FOR_REGISTERED_ENTITY("Michelle")
|
|
// michelle run
|
|
IF NOT IS_PED_INJURED(michellePed)
|
|
CLEAR_PED_TASKS_IMMEDIATELY(michellePed)
|
|
SET_ENTITY_COORDS(michellePed, <<118.60, -619.50, 205.05>>)
|
|
SET_ENTITY_HEADING(michellePed, -97.16)
|
|
FORCE_PED_MOTION_STATE(michellePed, MS_ON_FOOT_SPRINT, FALSE, FAUS_CUTSCENE_EXIT)
|
|
SET_PED_MIN_MOVE_BLEND_RATIO(michellePed, PEDMOVE_SPRINT)
|
|
TASK_GO_STRAIGHT_TO_COORD(michellePed, <<134.91, -616.71, 205.05>>, PEDMOVE_RUN)
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF CAN_SET_EXIT_STATE_FOR_REGISTERED_ENTITY("Michaels_weapon")
|
|
IF DOES_ENTITY_EXIST(michaelGunObject)
|
|
DELETE_OBJECT(michaelGunObject)
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF CAN_SET_EXIT_STATE_FOR_REGISTERED_ENTITY("Michael")
|
|
AND CAN_SET_EXIT_STATE_FOR_REGISTERED_ENTITY("MR_K")
|
|
CREATE_DUMMY_FRANKLIN(FALSE)
|
|
UPDATE_PRISONER_GRAB(PRISONER_GRAB_STATE_INIT)
|
|
|
|
SETUP_PRISONER_WITH_BELT(FALSE, STAGE_RAPPEL_DOWN)
|
|
DRAW_ROPE_TO_POINT(TRUE, <<112.69, -619.18, 206.48>>)
|
|
GIVE_PLAYER_MISSION_PISTOL()
|
|
|
|
SET_SELECTOR_PED_HINT(sSelectorPeds, SELECTOR_PED_FRANKLIN, TRUE)
|
|
SET_SELECTOR_PED_HINT(sSelectorPeds, SELECTOR_PED_TREVOR, FALSE)
|
|
SET_SELECTOR_PED_HINT(sSelectorPeds, SELECTOR_PED_MICHAEL, FALSE)
|
|
SET_SELECTOR_PED_BLOCKED(sSelectorPeds, SELECTOR_PED_TREVOR, TRUE)
|
|
SET_SELECTOR_PED_BLOCKED(sSelectorPeds, SELECTOR_PED_FRANKLIN, FALSE)
|
|
SET_SELECTOR_PED_BLOCKED(sSelectorPeds, SELECTOR_PED_MICHAEL, TRUE)
|
|
ENDIF
|
|
|
|
IF CAN_SET_EXIT_STATE_FOR_REGISTERED_ENTITY("CIA_Goon_1")
|
|
AND CAN_SET_EXIT_STATE_FOR_REGISTERED_ENTITY("Lead_CIA")
|
|
AND CAN_SET_EXIT_STATE_FOR_REGISTERED_ENTITY("CIA_Goon_2")
|
|
SET_GUARDS_AIMING_AT_MICHAEL(TRUE, TRUE)
|
|
ENDIF
|
|
|
|
IF CAN_SET_EXIT_STATE_FOR_REGISTERED_ENTITY("CIA_Office_Chair")
|
|
DELETE_OBJECT(cutsceneChairObject[0])
|
|
ENDIF
|
|
IF CAN_SET_EXIT_STATE_FOR_REGISTERED_ENTITY("CIA_Office_Chair^1")
|
|
DELETE_OBJECT(cutsceneChairObject[1])
|
|
ENDIF
|
|
IF CAN_SET_EXIT_STATE_FOR_REGISTERED_ENTITY("CIA_Office_Chair^2")
|
|
DELETE_OBJECT(cutsceneChairObject[2])
|
|
ENDIF
|
|
IF CAN_SET_EXIT_STATE_FOR_REGISTERED_ENTITY("CIA_Office_Chair^3")
|
|
DELETE_OBJECT(cutsceneChairObject[3])
|
|
ENDIF
|
|
IF CAN_SET_EXIT_STATE_FOR_REGISTERED_ENTITY("PROP_CS_POLICE_TORCH")
|
|
DELETE_OBJECT(cutsceneChairObject[4])
|
|
ENDIF
|
|
IF CAN_SET_EXIT_STATE_FOR_REGISTERED_ENTITY("Mr_K_Harness")
|
|
DELETE_OBJECT(cutsceneChairObject[5])
|
|
ENDIF
|
|
|
|
HIDE_SELECTOR_THIS_FRAME()
|
|
FORCE_LOAD_SELECTOR_THIS_FRAME()
|
|
UPDATE_SELECTOR_HUD(sSelectorPeds, FALSE)
|
|
|
|
|
|
IF CAN_SET_EXIT_STATE_FOR_CAMERA()
|
|
MUFFLE_HELI_SOUND_INDOORS(FALSE)
|
|
SET_PORTAL_SETTINGS_OVERRIDE("V_CIA_PS_WINDOW_UNBROKEN", "V_CIA_PS_WINDOW_BROKEN")
|
|
DO_STREAM_VOLUME_ON_OFFICE(TRUE)
|
|
|
|
START_SNATCH_AND_GRAB_AUDIO_SCENE(SNATCH_AND_GRAB_AUDIO_SCENE_MR_K_HOSTAGE)
|
|
|
|
HIDE_HUD_AND_RADAR_THIS_FRAME()
|
|
CREATE_CAM_FOR_SNATCH_AND_GRAB_SHOT(SAG_SHOT_WAIT_FOR_SWITCH, TRUE, 20000)
|
|
iSnatchAndGrabCutsceneTime = GET_GAME_TIMER()
|
|
CASCADE_SHADOWS_SET_CASCADE_BOUNDS_SCALE(CASCADE_SHADOWS_MULTIPLIER_NO_OVERRIDE)
|
|
INIT_ALL_GUARD_ANIMATION_TIMES()
|
|
smashThroughShot = SMASH_THROUGH_WAIT_FOR_SWITCH
|
|
HIDE_SELECTOR_THIS_FRAME(FALSE)
|
|
ENDIF
|
|
|
|
//HANDLE_WINDOW_SMASH(TRUE) // temp!
|
|
|
|
IF NOT bDoneSmashSound
|
|
TRIGGER_MISSION_MUSIC_EVENT("FIB2_BREAK_WINDOW")
|
|
PLAY_SOUND_FROM_COORD(iSmashSoundID, "FBI_02_SNATCH_AND_GRAB_SMASH_WINDOW", GET_SNATCH_AND_GRAB_VECTOR(SAGVEC_WINDOW_SOUND))
|
|
bDoneSmashSound = TRUE
|
|
ENDIF
|
|
|
|
#IF IS_DEBUG_BUILD
|
|
DEBUG_SKIP_MOCAP()
|
|
#ENDIF
|
|
BREAK
|
|
|
|
// wait for player to switch
|
|
CASE SMASH_THROUGH_WAIT_FOR_SWITCH
|
|
IF NOT IS_PED_INJURED(sSelectorPeds.pedID[SELECTOR_PED_FRANKLIN])
|
|
REQUEST_ADDITIONAL_COLLISION_AT_COORD(GET_ENTITY_COORDS(sSelectorPeds.pedID[SELECTOR_PED_FRANKLIN]))
|
|
ENDIF
|
|
|
|
HIDE_HUD_AND_RADAR_THIS_FRAME()
|
|
CASCADE_SHADOWS_SET_CASCADE_BOUNDS_SCALE(CASCADE_SHADOWS_MULTIPLIER_NO_OVERRIDE)
|
|
|
|
SET_ROOM_FOR_GAME_VIEWPORT_BY_NAME("V_CIA01_cur_offc3")
|
|
IF NOT bShownSwitchText
|
|
IF DO_MISSION_GOD_TEXT("SG_SWITCH")
|
|
bShownSwitchText = TRUE
|
|
ENDIF
|
|
ENDIF
|
|
|
|
HANDLE_GUARD_ANIMATIONS(0)
|
|
|
|
IF iGuardSpeech < 11
|
|
STRING sLabel
|
|
INT iLine
|
|
SWITCH iGuardSpeech
|
|
CASE 0
|
|
sLabel = "FBI2_MICH2"
|
|
iLine = 0
|
|
BREAK
|
|
CASE 1
|
|
sLabel = "FBI2_SNIPE"
|
|
iLine = 1
|
|
BREAK
|
|
CASE 2
|
|
sLabel = "FBI2_CIA1"
|
|
iLine = 0
|
|
BREAK
|
|
CASE 3
|
|
sLabel = "FBI2_MRKSHT"
|
|
iLine = 0
|
|
BREAK
|
|
CASE 4
|
|
sLabel = "FBI2_CLEAR"
|
|
iLine = 0
|
|
BREAK
|
|
CASE 5
|
|
sLabel = "FBI_2_BACKUP"
|
|
iLine = 0
|
|
BREAK
|
|
CASE 6
|
|
sLabel = "FBI2_MRKSHT"
|
|
iLine = 0
|
|
BREAK
|
|
CASE 7
|
|
sLabel = "FBI2_ASK"
|
|
iLine = 0
|
|
BREAK
|
|
CASE 8
|
|
sLabel = "FBI2_CIA2"
|
|
iLine = 0
|
|
BREAK
|
|
CASE 9
|
|
sLabel = "FBI2_MRKSHT"
|
|
iLine = 0
|
|
BREAK
|
|
CASE 10
|
|
sLabel = "FBI2_GLIGHT"
|
|
iLine = 0
|
|
BREAK
|
|
ENDSWITCH
|
|
|
|
IF DO_MISSION_SPEECH(sLabel, TRUE, iLine, FALSE, NOT IS_MESSAGE_BEING_DISPLAYED())
|
|
iGuardSpeech++
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF iGuardAttackTime < 0
|
|
IF iGuardSpeech > 10
|
|
iGuardAttackTime = GET_GAME_TIMER() + 2000
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF NOT bDoGuardsKillMichael
|
|
#IF IS_DEBUG_BUILD
|
|
IF IS_KEYBOARD_KEY_JUST_PRESSED(KEY_J)
|
|
sSelectorPeds.eNewSelectorPed = SELECTOR_PED_FRANKLIN
|
|
bDebugJSkip = TRUE
|
|
ENDIF
|
|
#ENDIF
|
|
|
|
IF GET_GAME_TIMER() >= iGuardAttackTime
|
|
AND iGuardAttackTime >= 0
|
|
SET_PLAYER_CONTROL(PLAYER_ID(), FALSE, SPC_ALLOW_PLAYER_DAMAGE)
|
|
IF NOT IS_PED_INJURED(guardPed[2])
|
|
SET_PED_ACCURACY(guardPed[2], 100)
|
|
SET_PED_SHOOT_RATE(guardPed[2], 100)
|
|
TASK_SHOOT_AT_COORD(guardPed[2], GET_SNATCH_AND_GRAB_VECTOR(SAGVEC_HEADSHOT), -1, FIRING_TYPE_CONTINUOUS)
|
|
ENDIF
|
|
iKillMichaelTime = GET_GAME_TIMER()
|
|
bDoGuardsKillMichael = TRUE
|
|
ELSE
|
|
IF CAN_ADVANCE_MISSION()
|
|
IF UPDATE_SELECTOR_HUD(sSelectorPeds, FALSE)
|
|
#IF IS_DEBUG_BUILD
|
|
OR bDebugJSkip
|
|
#ENDIF
|
|
IF sSelectorPeds.eNewSelectorPed = SELECTOR_PED_FRANKLIN
|
|
REMOVE_MISSION_TEXT()
|
|
CREATE_SPLINE_INTERP_TO_FRANKLIN()
|
|
mocapStreamingStage = MOCAP_STREAMING_STAGE_REQUEST
|
|
iSnatchAndGrabCutsceneTime = GET_GAME_TIMER()
|
|
//REQUEST_REMOTE_SNIPER_ASSETS(remoteSniperData) // moved up to load sooner
|
|
//HAVE_REMOTE_SNIPER_ASSETS_LOADED(remoteSniperData)
|
|
SET_ENTITY_HEALTH(PLAYER_PED_ID(), 200)
|
|
//SCRIPT_OVERRIDES_WIND_TYPES(true,"WEATHER_TYPES_MAGDEMO_FIB2_FRANKLIN","WEATHER_TYPES_MAGDEMO_FIB2_FRANKLIN")
|
|
//PLAY_SOUND_FRONTEND(-1, "FBI_02_SWITCH_TO_FRANKLIN_MASTER")
|
|
//PLAY_SOUND_FRONTEND(-1, "Hit_Out", "PLAYER_SWITCH_CUSTOM_SOUNDSET")//"Hit_In", "PLAYER_SWITCH_CUSTOM_SOUNDSET") "Hit_In", "PLAYER_SWITCH_CUSTOM_SOUNDSET"
|
|
//PLAY_SOUND_FRONTEND(iSniperSwitchSoundID, "Camera_Move_Loop", "PLAYER_SWITCH_CUSTOM_SOUNDSET")
|
|
|
|
bDoneFlash = FALSE
|
|
STOP_SNATCH_AND_GRAB_AUDIO_SCENE(SNATCH_AND_GRAB_AUDIO_SCENE_MR_K_HOSTAGE)
|
|
INFORM_MISSION_STATS_OF_INCREMENT(FBI2_SWITCHES)
|
|
FILL_PUSH_IN_DATA(pushInData, dummyFranklinPed, CHAR_FRANKLIN, 0.2, 500, 500, 200, 300)
|
|
SET_PUSH_IN_DIRECTION_MODIFIER(pushInData, <<0,0,5>>)
|
|
smashThroughShot = SMASH_THROUGH_PAN
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ELSE
|
|
IF NOT IS_PED_INJURED(PLAYER_PED_ID())
|
|
AND NOT bFakeKillMichael
|
|
IF GET_ENTITY_HEALTH(PLAYER_PED_ID()) >= 105
|
|
SET_ENTITY_HEALTH(PLAYER_PED_ID(), 105)
|
|
ENDIF
|
|
|
|
IF GET_GAME_TIMER() >= iKillMichaelTime + 1000
|
|
SET_PED_TO_RAGDOLL(PLAYER_PED_ID(), 8000, 8000, TASK_RELAX)
|
|
MISSION_FAILED(FAIL_MICHAEL_DEAD)
|
|
bFakeKillMichael = TRUE
|
|
ENDIF
|
|
ELSE
|
|
IF NOT bResetGuardAim
|
|
IF NOT IS_PED_INJURED(guardPed[2])
|
|
TASK_AIM_GUN_AT_COORD(guardPed[2], GET_SNATCH_AND_GRAB_VECTOR(SAGVEC_HEADSHOT), -1)
|
|
|
|
IF NOT IS_PED_INJURED(prisonerPed)
|
|
VECTOR vSceneMod
|
|
vSceneMod = <<0,0,1.05>>
|
|
iSyncScene = CREATE_SYNCHRONIZED_SCENE(GET_SNATCH_AND_GRAB_VECTOR(SAGVEC_INTERROGATION) - vSceneMod, <<0.0, 0.0, INTERROGATION_ROT>>)
|
|
IF NOT IS_PED_INJURED(prisonerPed)
|
|
TASK_SYNCHRONIZED_SCENE(prisonerPed, iSyncScene, GET_SNATCH_AND_GRAB_ANIM_DICT_AS_STRING(SAG_ANIM_DICT_IN_OFFICE), "hostage_low_intro_mrk", NORMAL_BLEND_IN, NORMAL_BLEND_OUT)
|
|
ENDIF
|
|
ENDIF
|
|
|
|
bResetGuardAim = TRUE
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
BREAK
|
|
|
|
// pan to franklin
|
|
CASE SMASH_THROUGH_PAN
|
|
IF NOT IS_PED_INJURED(sSelectorPeds.pedID[SELECTOR_PED_FRANKLIN])
|
|
REQUEST_ADDITIONAL_COLLISION_AT_COORD(GET_ENTITY_COORDS(sSelectorPeds.pedID[SELECTOR_PED_FRANKLIN]))
|
|
ENDIF
|
|
|
|
SET_RADAR_AS_INTERIOR_THIS_FRAME(GET_HASH_KEY("V_FakeDT1_05"), 150.0, -700.0, 0, 1)
|
|
IF NOT IS_PED_INJURED(GET_FRANKLIN_PED())
|
|
SET_MINIMAP_IN_SPECTATOR_MODE(TRUE, GET_FRANKLIN_PED())
|
|
ENDIF
|
|
|
|
HIDE_HUD_AND_RADAR_THIS_FRAME()
|
|
CASCADE_SHADOWS_SET_CASCADE_BOUNDS_SCALE(CASCADE_SHADOWS_MULTIPLIER_EXTERIOR_OVERRIDE)
|
|
|
|
IF NOT bKilledSpeechOnPan
|
|
IF GET_GAME_TIMER() >= (iSnatchAndGrabCutsceneTime + 100)
|
|
KILL_FACE_TO_FACE_CONVERSATION_DO_NOT_FINISH_LAST_LINE()
|
|
bKilledSpeechOnPan = TRUE
|
|
ENDIF
|
|
ELSE
|
|
IF NOT bDoneFranklinSniperSpeech
|
|
IF NOT IS_ANY_CONVERSATION_ONGOING_OR_QUEUED()
|
|
bDoneFranklinSniperSpeech = DO_MISSION_SPEECH("FBI2_SNIPE", TRUE, 3)
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF NOT bDoneFlash
|
|
ANIMPOSTFX_STOP_AND_FLUSH_REQUESTS("SwitchHUDMichaelOut")
|
|
ANIMPOSTFX_STOP_AND_FLUSH_REQUESTS("SwitchHUDFranklinOut")
|
|
ANIMPOSTFX_PLAY("SwitchShortMichaelIn", 0, FALSE)
|
|
bDoneFlash = TRUE
|
|
ENDIF
|
|
|
|
IF NOT bDoneHitSound
|
|
IF GET_GAME_TIMER() >= (iSnatchAndGrabCutsceneTime + 0)
|
|
PLAY_SOUND_FRONTEND(-1, "Hit_Out", "PLAYER_SWITCH_CUSTOM_SOUNDSET")
|
|
iHitTime = GET_GAME_TIMER()
|
|
bDoneHitSound = TRUE
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF NOT bWooshStarted
|
|
IF bDoneHitSound
|
|
IF GET_GAME_TIMER() >= iHitTime + 300
|
|
PLAY_SOUND_FRONTEND(-1, "Short_Transition_In", "PLAYER_SWITCH_CUSTOM_SOUNDSET")
|
|
bWooshStarted = TRUE
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF NOT bDoneSwitchToFranklinCue
|
|
IF GET_GAME_TIMER() >= (iSnatchAndGrabCutsceneTime + 200)
|
|
bDoneSwitchToFranklinCue = TRIGGER_MISSION_MUSIC_EVENT("FIB2_SWITCHED_TO_FRANK")
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF NOT bHitFranklinSound
|
|
IF NOT IS_PED_INJURED(dummyFranklinPed)
|
|
IF GET_GAME_TIMER() >= iSnatchAndGrabCutsceneTime + 1000
|
|
//PLAY_SOUND_FRONTEND(-1, "Hit_Out", "PLAYER_SWITCH_CUSTOM_SOUNDSET")
|
|
STOP_SOUND(iSniperSwitchSoundID)
|
|
//ANIMPOSTFX_PLAY("SwitchShortFranklinMid", 0, FALSE)
|
|
bHitFranklinSound = TRUE
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
|
|
SWITCH replaceMrKStage
|
|
CASE REPLACE_MR_K_STAGE_NOT_STARTED
|
|
IF GET_GAME_TIMER() >= (iSnatchAndGrabCutsceneTime + 400)
|
|
IF DOES_ENTITY_EXIST(prisonerPed)
|
|
DELETE_PED(prisonerPed)
|
|
ADD_MODEL_REQUEST(ENUM_TO_INT(SAGM_PRISONER_LOW))
|
|
CLEAR_MODEL_REQUEST(ENUM_TO_INT(SAGM_PRISONER_HIGH))
|
|
ENDIF
|
|
replaceMrKStage = REPLACE_MR_K_STAGE_WAITING
|
|
ENDIF
|
|
BREAK
|
|
CASE REPLACE_MR_K_STAGE_WAITING
|
|
IF HAVE_ALL_MODEL_REQUESTS_SUCCEEDED()
|
|
IF DOES_ROPE_EXIST(rappelData.rope)
|
|
DELETE_ROPE(rappelData.rope)
|
|
ENDIF
|
|
CREATE_CHOPPER_ROPE(ROPE_TYPE_INSIDE, STAGE_SNIPE_GUARDS)
|
|
|
|
CREATE_PRISONER_FOR_STAGE(STAGE_SNIPE_GUARDS)
|
|
SET_ENTITY_VISIBLE(prisonerPed, FALSE)
|
|
replaceMrKStage = REPLACE_MR_K_STAGE_DONE
|
|
ENDIF
|
|
BREAK
|
|
CASE REPLACE_MR_K_STAGE_DONE
|
|
BREAK
|
|
ENDSWITCH
|
|
|
|
IF GET_CURRENT_PLAYER_PED_ENUM() <> CHAR_FRANKLIN
|
|
WHILE NOT DO_MISSION_HOTSWAP(SELECTOR_PED_FRANKLIN, TRUE, TRUE)
|
|
WAIT_WITH_RECORD()
|
|
ENDWHILE
|
|
// Oneshot for camera pan to franklin
|
|
//TRIGGER_MISSION_MUSIC_EVENT("FBI2_TEST_SNIPER_ONESHOT")
|
|
bFrozenFranklin = FALSE
|
|
ELSE
|
|
IF NOT bFrozenFranklin
|
|
FREEZE_FRANKLIN_AT_SNIPER()
|
|
bFrozenFranklin = TRUE
|
|
ENDIF
|
|
SET_PLAYER_FORCE_SKIP_AIM_INTRO(PLAYER_ID(), TRUE)
|
|
SET_PLAYER_FORCED_AIM(PLAYER_ID(), TRUE)
|
|
ENDIF
|
|
|
|
//HAVE_REMOTE_SNIPER_ASSETS_LOADED(remoteSniperData)
|
|
|
|
#IF IS_DEBUG_BUILD
|
|
/*
|
|
IF GET_GAME_TIMER() < (iSnatchAndGrabCutsceneTime + iSniperNodeTime2+iSniperNodeTime3+iSniperNodeTime4+iSniperNodeTime5+iSniperNodeTime6)
|
|
// SET_CAM_COORD(sCamDetails.camInterpIDs[0], vSniperNodePos1)
|
|
// SET_CAM_ROT( sCamDetails.camInterpIDs[0], vSniperNodeRot1)
|
|
SET_CAM_COORD(sCamDetails.camInterpIDs[1], vSniperNodePos2)
|
|
SET_CAM_ROT( sCamDetails.camInterpIDs[1], vSniperNodeRot2)
|
|
SET_CAM_COORD(sCamDetails.camInterpIDs[2], vSniperNodePos3)
|
|
SET_CAM_ROT( sCamDetails.camInterpIDs[2], vSniperNodeRot3)
|
|
//SET_CAM_COORD(sCamDetails.camInterpIDs[3], vSniperNodePos4)
|
|
//SET_CAM_ROT( sCamDetails.camInterpIDs[3], vSniperNodeRot4)
|
|
//SET_CAM_COORD(sCamDetails.camInterpIDs[4], vSniperNodePos5)
|
|
//SET_CAM_ROT( sCamDetails.camInterpIDs[4], vSniperNodeRot5)
|
|
ENDIF
|
|
*/
|
|
#ENDIF
|
|
|
|
// Need to hide the fake Franklin floating in mid-air for the transition.
|
|
//IF IS_ENTITY_VISIBLE(GET_FRANKLIN_PED()) AND GET_GAME_TIMER() < (iSnatchAndGrabCutsceneTime + iSniperNodeTime2 - 200)
|
|
// SET_ENTITY_VISIBLE(GET_FRANKLIN_PED(), FALSE)
|
|
//ELIF NOT IS_ENTITY_VISIBLE(GET_FRANKLIN_PED()) AND GET_GAME_TIMER() >= (iSnatchAndGrabCutsceneTime + iSniperNodeTime2)
|
|
// SET_ENTITY_VISIBLE(GET_FRANKLIN_PED(), TRUE)
|
|
//ENDIF
|
|
|
|
SET_ENTITY_VISIBLE(GET_FRANKLIN_PED(), FALSE)
|
|
|
|
IF GET_GAME_TIMER() >= iSnatchAndGrabCutsceneTime + 1100//1500//(iSnatchAndGrabCutsceneTime + iSniperNodeTime2+iSniperNodeTime3+1000) // was 4000, but transition is shorter now
|
|
AND replaceMrKStage = REPLACE_MR_K_STAGE_DONE
|
|
AND NOT IS_PED_INJURED(prisonerPed)
|
|
AND HAVE_ALL_STREAMING_REQUESTS_COMPLETED(prisonerPed)
|
|
IF HANDLE_PUSH_IN(pushInData, TRUE, FALSE)
|
|
cutsceneStage = SAG_CUT_STAGE_CLEANUP
|
|
ENDIF
|
|
ENDIF
|
|
BREAK
|
|
ENDSWITCH
|
|
BREAK
|
|
|
|
CASE SAG_CUT_STAGE_CLEANUP
|
|
IF bSkippedCutscene
|
|
|
|
ENDIF
|
|
fLockDoorOpen = DOOR_OPEN_RATIO
|
|
SET_GAMEPLAY_CAM_RELATIVE_HEADING()
|
|
|
|
//SET_PLAYER_FORCE_SKIP_AIM_INTRO(PLAYER_ID(), TRUE)
|
|
//SET_PLAYER_FORCED_AIM(PLAYER_ID(), TRUE)
|
|
|
|
// back to gameplay
|
|
SET_MISSION_CUTSCENE(FALSE, TRUE, TRUE, FALSE)
|
|
|
|
// Clean up the interp cameras we created.
|
|
CLEANUP_HOTSWAP_CAMERAS()
|
|
|
|
DESTROY_PUSH_IN_CAMS(pushInData)
|
|
|
|
DISPLAY_HUD(TRUE)
|
|
DISPLAY_RADAR(TRUE)
|
|
|
|
DESTROY_MISSION_STATIC_CAM(interpCam)
|
|
|
|
IF NOT IS_PED_INJURED(GET_FRANKLIN_PED())
|
|
SET_MINIMAP_IN_SPECTATOR_MODE(FALSE, NULL)
|
|
ENDIF
|
|
|
|
IF NOT IS_PED_INJURED(prisonerPed)
|
|
SET_ENTITY_VISIBLE(prisonerPed, TRUE)
|
|
ENDIF
|
|
|
|
SET_MISSION_STAGE(STAGE_SNIPE_GUARDS, FALSE, FALSE)
|
|
BREAK
|
|
ENDSWITCH
|
|
|
|
DISABLE_BLUR_ON_RIFLE_MODEL()
|
|
ENDPROC
|
|
|
|
CONST_FLOAT SMASH_IN_HEIGHT -62.90
|
|
|
|
FUNC VECTOR GET_TOWER_PED_ATTACH_POS(INT iPed)
|
|
SWITCH iPed
|
|
CASE 0
|
|
RETURN <<0, 0.070, 0.420>>
|
|
BREAK
|
|
CASE 1
|
|
RETURN <<-1.4, 0.300, 1.010>>
|
|
BREAK
|
|
CASE 2
|
|
RETURN <<0, 0.070, 0.420>>
|
|
BREAK
|
|
CASE 3
|
|
RETURN <<0, 0.070, 0.420>>
|
|
BREAK
|
|
CASE 4
|
|
RETURN <<0.70, 0.070, 1.010>>
|
|
BREAK
|
|
ENDSWITCH
|
|
|
|
RETURN <<0,0,0>>
|
|
ENDFUNC
|
|
|
|
FUNC VECTOR GET_TOWER_PED_ATTACH_ROT(INT iPed)
|
|
SWITCH iPed
|
|
CASE 0
|
|
RETURN <<0,0,180.000>>
|
|
BREAK
|
|
CASE 1
|
|
RETURN <<0,0,225.000>>
|
|
BREAK
|
|
CASE 2
|
|
RETURN <<0,0,180.000>>
|
|
BREAK
|
|
CASE 3
|
|
RETURN <<0,0,180.000>>
|
|
BREAK
|
|
CASE 4
|
|
RETURN <<0,0,145.000>>
|
|
BREAK
|
|
ENDSWITCH
|
|
|
|
RETURN <<0,0,0>>
|
|
ENDFUNC
|
|
|
|
FUNC INT GET_TOWER_PED_ATTACH_CHAIR(INT iPed)
|
|
SWITCH iPed
|
|
CASE 0
|
|
RETURN 0
|
|
BREAK
|
|
CASE 1
|
|
RETURN 0
|
|
BREAK
|
|
CASE 2
|
|
RETURN 1
|
|
BREAK
|
|
CASE 3
|
|
RETURN 2
|
|
BREAK
|
|
CASE 4
|
|
RETURN 2
|
|
BREAK
|
|
ENDSWITCH
|
|
|
|
RETURN 0
|
|
ENDFUNC
|
|
|
|
// rappel to the window
|
|
PROC DO_STAGE_RAPPEL_DOWN()
|
|
INT i
|
|
MAINTAIN_DOOR_OPEN()
|
|
USE_SCRIPT_CAM_FOR_AMBIENT_POPULATION_ORIGIN_THIS_FRAME(TRUE, FALSE)
|
|
SET_AMBIENT_VEHICLE_RANGE_MULTIPLIER_THIS_FRAME(RAPPEL_VEHICLE_RANGE_MULTIPLIER)
|
|
DISABLE_ON_FOOT_FIRST_PERSON_VIEW_THIS_UPDATE()
|
|
|
|
IF NOT bRunningCutscene
|
|
// ensure chopper is always hovering
|
|
//MAINTAIN_CHOPPER_HOVER()
|
|
|
|
|
|
|
|
SET_RADAR_AS_INTERIOR_THIS_FRAME(GET_HASH_KEY("V_FakeDT1_05"), 150.0, -700.0, 0, 0)
|
|
|
|
// latch doors
|
|
//IF NOT bLatchedChopperDoors
|
|
//LATCH_ALL_CHOPPER_DOORS()
|
|
// SHUT_ALL_CHOPPER_DOORS()
|
|
//bLatchedChopperDoors = TRUE
|
|
//ENDIF
|
|
|
|
// random vehicle generation
|
|
//HANDLE_RANDOM_VEHICLE_GENERATION(FALSE)
|
|
|
|
BOOL bAllowResetToIdle = TRUE
|
|
// draw rope
|
|
HANDLE_CHOPPER_ROPE(ROPE_TYPE_RAPPELLING)
|
|
|
|
// prime the window to smash
|
|
HANDLE_WINDOW_SMASH(FALSE)
|
|
|
|
IF NOT bHasDoneJump
|
|
IF rappelData.state = RAPPEL_STATE_JUMPING_STATIC
|
|
OR rappelData.state = RAPPEL_STATE_JUMPING_DOWN
|
|
bHasDoneJump = TRUE
|
|
ENDIF
|
|
ENDIF
|
|
|
|
// Music change over once half way down building
|
|
IF NOT bRappelMusicStart
|
|
IF rappelData.vAttachPos.z <= -30
|
|
//TRIGGER_MISSION_MUSIC_EVENT("FBI2_TEST_RAPPEL_HALF")
|
|
bRappelMusicStart = TRUE
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF NOT bForcePassOnShitskip
|
|
// michael talks to himself
|
|
IF NOT bInitialisedInterrogation
|
|
IF rappelData.vAttachPos.z > -50
|
|
IF iMichaelRappelSpeechStage < 5
|
|
IF GET_GAME_TIMER() >= iNextMichaelRappelSpeechTime
|
|
IF IS_ENTITY_PLAYING_ANIM(PLAYER_PED_ID(), GET_RAPPEL_ANIM_DICT_NAME(), "Rappel_jump_a")
|
|
IF GET_ENTITY_ANIM_CURRENT_TIME(PLAYER_PED_ID(), GET_RAPPEL_ANIM_DICT_NAME(), "Rappel_jump_a") <= 0.1
|
|
IF DO_MISSION_SPEECH("FBI2_RAPP")
|
|
iMichaelRappelSpeechStage++
|
|
iNextMichaelRappelSpeechTime = GET_GAME_TIMER() + GET_RANDOM_INT_IN_RANGE(8000, 10000)
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
|
|
// michael does jump and land speech
|
|
IF NOT bForcePassOnShitskip
|
|
SWITCH jumpGruntState
|
|
CASE JUMP_GRUNT_READY
|
|
IF IS_ENTITY_PLAYING_ANIM(PLAYER_PED_ID(), GET_RAPPEL_ANIM_DICT_NAME(), "Rappel_jump_a")
|
|
IF GET_ENTITY_ANIM_CURRENT_TIME(PLAYER_PED_ID(), GET_RAPPEL_ANIM_DICT_NAME(), "Rappel_jump_a") <= 0.05
|
|
IF GET_RANDOM_INT_IN_RANGE(0,2) = 0
|
|
OR bAllowSmashIn
|
|
jumpGruntState = JUMP_GRUNT_DO_ON_PUSH
|
|
ELSE
|
|
jumpGruntState = JUMP_GRUNT_DO_ON_LAND
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
BREAK
|
|
|
|
CASE JUMP_GRUNT_DO_ON_PUSH
|
|
IF IS_ENTITY_PLAYING_ANIM(PLAYER_PED_ID(), GET_RAPPEL_ANIM_DICT_NAME(), "Rappel_jump_a")
|
|
IF GET_ENTITY_ANIM_CURRENT_TIME(PLAYER_PED_ID(), GET_RAPPEL_ANIM_DICT_NAME(), "Rappel_jump_a") <= 0.1
|
|
IF bInteriorCamIsOutside OR NOT bUsingOfficeCam
|
|
//IF DO_MISSION_SPEECH("FBI2_JUMP", TRUE, 0, FALSE, FALSE)
|
|
IF NOT IS_ANY_CONVERSATION_ONGOING_OR_QUEUED()
|
|
IF GET_RANDOM_INT_IN_RANGE(0,2) = 0
|
|
PLAY_PAIN(PLAYER_PED_ID(), AUD_DAMAGE_REASON_CLIMB_SMALL,0)
|
|
ELSE
|
|
PLAY_PAIN(PLAYER_PED_ID(), AUD_DAMAGE_REASON_CLIMB_LARGE,0)
|
|
ENDIF
|
|
ENDIF
|
|
jumpGruntState = JUMP_GRUNT_WAIT_FOR_RESET
|
|
//ENDIF
|
|
ELSE
|
|
jumpGruntState = JUMP_GRUNT_WAIT_FOR_RESET
|
|
ENDIF
|
|
ELSE
|
|
jumpGruntState = JUMP_GRUNT_READY
|
|
ENDIF
|
|
ELSE
|
|
jumpGruntState = JUMP_GRUNT_READY
|
|
ENDIF
|
|
BREAK
|
|
|
|
CASE JUMP_GRUNT_DO_ON_LAND
|
|
IF IS_ENTITY_PLAYING_ANIM(PLAYER_PED_ID(), GET_RAPPEL_ANIM_DICT_NAME(), "Rappel_jump_a")
|
|
IF GET_ENTITY_ANIM_CURRENT_TIME(PLAYER_PED_ID(), GET_RAPPEL_ANIM_DICT_NAME(), "Rappel_jump_a") >= 0.740
|
|
IF bInteriorCamIsOutside OR NOT bUsingOfficeCam
|
|
IF NOT IS_ANY_CONVERSATION_ONGOING_OR_QUEUED()
|
|
PLAY_PAIN(PLAYER_PED_ID(), AUD_DAMAGE_REASON_CLIMB_SMALL,0)
|
|
ENDIF
|
|
//IF DO_MISSION_SPEECH("FBI2_LAND", TRUE, 0, FALSE, FALSE)
|
|
jumpGruntState = JUMP_GRUNT_READY
|
|
//ENDIF
|
|
ELSE
|
|
jumpGruntState = JUMP_GRUNT_READY
|
|
ENDIF
|
|
ELIF GET_ENTITY_ANIM_CURRENT_TIME(PLAYER_PED_ID(), GET_RAPPEL_ANIM_DICT_NAME(), "Rappel_jump_a") >= 0.85
|
|
jumpGruntState = JUMP_GRUNT_READY
|
|
ENDIF
|
|
ELSE
|
|
jumpGruntState = JUMP_GRUNT_READY
|
|
ENDIF
|
|
BREAK
|
|
|
|
CASE JUMP_GRUNT_WAIT_FOR_RESET
|
|
IF IS_ENTITY_PLAYING_ANIM(PLAYER_PED_ID(), GET_RAPPEL_ANIM_DICT_NAME(), "Rappel_jump_a")
|
|
IF GET_ENTITY_ANIM_CURRENT_TIME(PLAYER_PED_ID(), GET_RAPPEL_ANIM_DICT_NAME(), "Rappel_jump_a") >= 0.2
|
|
jumpGruntState = JUMP_GRUNT_READY
|
|
ENDIF
|
|
ELSE
|
|
jumpGruntState = JUMP_GRUNT_READY
|
|
ENDIF
|
|
ENDSWITCH
|
|
|
|
// handle tower ped reactions
|
|
//PRINTFLOAT(rappelData.vAttachPos.z) PRINTNL()
|
|
REPEAT NUMBER_TOWER_WINDOWS i
|
|
IF NOT bAlertedWindow[i]
|
|
FLOAT fTopKick
|
|
FLOAT fBottomKick
|
|
FLOAT fTopLoiter
|
|
FLOAT fBottomLoiter
|
|
BOOL bKickedWindow = FALSE
|
|
|
|
SWITCH i
|
|
CASE 0
|
|
fTopKick = -14.77
|
|
fBottomKick = -16.98
|
|
fTopLoiter = -15.35
|
|
fBottomLoiter = -17.88
|
|
BREAK
|
|
CASE 1
|
|
fTopKick = -38.86
|
|
fBottomKick = -41.10
|
|
fTopLoiter = -39.47
|
|
fBottomLoiter = -41.91
|
|
BREAK
|
|
CASE 2
|
|
fTopKick = -46.82
|
|
fBottomKick = -49.15
|
|
fTopLoiter = -47.20
|
|
fBottomLoiter = -49.91
|
|
BREAK
|
|
ENDSWITCH
|
|
|
|
IF rappelData.vAttachPos.z <= fTopKick
|
|
AND rappelData.vAttachPos.z >= fBottomKick
|
|
IF IS_ENTITY_PLAYING_ANIM(rappelData.ped, GET_RAPPEL_ANIM_DICT_NAME(), "Rappel_jump_a")
|
|
IF GET_ENTITY_ANIM_CURRENT_TIME(rappelData.ped, GET_RAPPEL_ANIM_DICT_NAME(), "Rappel_jump_a") >= 0.77
|
|
bKickedWindow = TRUE
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF rappelData.vAttachPos.z <= fTopLoiter
|
|
AND rappelData.vAttachPos.z >= fBottomLoiter
|
|
fAtWindowTime[i] = fAtWindowTime[i] +@ 1.0
|
|
ENDIF
|
|
|
|
IF fAtWindowTime[i] >= 6.0
|
|
OR bKickedWindow
|
|
iAlertedWindowTime[i] = GET_GAME_TIMER()
|
|
bAlertedWindow[i] = TRUE
|
|
ENDIF
|
|
ELSE
|
|
FLOAT fPassedWindow
|
|
SWITCH i
|
|
CASE 0
|
|
fPassedWindow = -18.68
|
|
BREAK
|
|
CASE 1
|
|
fPassedWindow = -43.08
|
|
BREAK
|
|
CASE 2
|
|
fPassedWindow = -50.57
|
|
BREAK
|
|
ENDSWITCH
|
|
|
|
IF rappelData.vAttachPos.z >= fPassedWindow
|
|
IF GET_GAME_TIMER() >= iAlertedWindowTime[i] + 10000
|
|
MISSION_FAILED(FAIL_SEEN)
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDREPEAT
|
|
|
|
REPEAT NUMBER_TOWER_PEDS i
|
|
IF NOT IS_PED_INJURED(towerPed[i])
|
|
INT iWindow
|
|
INT iReactDelay
|
|
STRING sEnterReactDict
|
|
STRING sEnterReactAnim
|
|
STRING sLoopReactDict
|
|
STRING sLoopReactAnim
|
|
|
|
SWITCH i
|
|
CASE 0
|
|
iWindow = 1
|
|
iReactDelay = 0
|
|
sEnterReactDict = GET_SNATCH_AND_GRAB_ANIM_DICT_AS_STRING(SAG_ANIM_DICT_TOWER_SEATED_REACT)
|
|
sEnterReactAnim = "back_right"
|
|
sLoopReactDict = GET_SNATCH_AND_GRAB_ANIM_DICT_AS_STRING(SAG_ANIM_DICT_TOWER_SEATED_REACT)
|
|
sLoopReactAnim = "back_right"
|
|
BREAK
|
|
CASE 1
|
|
iWindow = 1
|
|
iReactDelay = 300
|
|
sEnterReactDict = GET_SNATCH_AND_GRAB_ANIM_DICT_AS_STRING(SAG_ANIM_DICT_TOWER_STANDING_REACT_ENTER_L)
|
|
sEnterReactAnim = "react_left_small_intro_a"
|
|
sLoopReactDict = GET_SNATCH_AND_GRAB_ANIM_DICT_AS_STRING(SAG_ANIM_DICT_TOWER_STANDING_REACT_IDLE)
|
|
sLoopReactAnim = "react_small_variations_b"
|
|
BREAK
|
|
CASE 2
|
|
iWindow = 2
|
|
iReactDelay = 0
|
|
sEnterReactDict = GET_SNATCH_AND_GRAB_ANIM_DICT_AS_STRING(SAG_ANIM_DICT_TOWER_SEATED_REACT)
|
|
sEnterReactAnim = "forward"
|
|
sLoopReactDict = GET_SNATCH_AND_GRAB_ANIM_DICT_AS_STRING(SAG_ANIM_DICT_TOWER_SEATED_REACT)
|
|
sLoopReactAnim = "forward"
|
|
BREAK
|
|
CASE 3
|
|
iWindow = 0
|
|
iReactDelay = 400
|
|
sEnterReactDict = GET_SNATCH_AND_GRAB_ANIM_DICT_AS_STRING(SAG_ANIM_DICT_TOWER_SEATED_REACT)
|
|
sEnterReactAnim = "back_right"
|
|
sLoopReactDict = GET_SNATCH_AND_GRAB_ANIM_DICT_AS_STRING(SAG_ANIM_DICT_TOWER_SEATED_REACT)
|
|
sLoopReactAnim = "back_right"
|
|
BREAK
|
|
CASE 4
|
|
iWindow = 0
|
|
iReactDelay = 0
|
|
sEnterReactDict = GET_SNATCH_AND_GRAB_ANIM_DICT_AS_STRING(SAG_ANIM_DICT_TOWER_STANDING_REACT_ENTER_R)
|
|
sEnterReactAnim = "react_right_small_intro_a"
|
|
sLoopReactDict = GET_SNATCH_AND_GRAB_ANIM_DICT_AS_STRING(SAG_ANIM_DICT_TOWER_STANDING_REACT_IDLE)
|
|
sLoopReactAnim = "react_small_variations_a"
|
|
BREAK
|
|
ENDSWITCH
|
|
|
|
FLOAT fPhase
|
|
ANIMATION_FLAGS flags
|
|
SWITCH towerPedState[i]
|
|
CASE TOWER_PED_STATE_UNALERTED
|
|
IF bAlertedWindow[iWindow]
|
|
IF GET_GAME_TIMER() >= iAlertedWindowTime[iWindow] + iReactDelay
|
|
//TASK_CLEAR_LOOK_AT(towerPed[i])
|
|
|
|
IF i=1 OR i=4
|
|
flags = AF_HOLD_LAST_FRAME | AF_IGNORE_GRAVITY
|
|
DETACH_ENTITY(towerPed[i])
|
|
ELSE
|
|
flags = AF_LOOPING
|
|
ENDIF
|
|
|
|
TASK_PLAY_ANIM(towerPed[i], sEnterReactDict, sEnterReactAnim, SLOW_BLEND_IN, SLOW_BLEND_OUT, -1, flags)
|
|
TASK_LOOK_AT_ENTITY(towerPed[i], PLAYER_PED_ID(), -1, SLF_WHILE_NOT_IN_FOV)
|
|
towerPedState[i] = TOWER_PED_STATE_ENTER_REACT
|
|
ENDIF
|
|
ENDIF
|
|
BREAK
|
|
|
|
CASE TOWER_PED_STATE_ENTER_REACT
|
|
IF IS_ENTITY_PLAYING_ANIM(towerPed[i], sEnterReactDict, sEnterReactAnim)
|
|
fPhase = GET_ENTITY_ANIM_CURRENT_TIME(towerPed[i], sEnterReactDict, sEnterReactAnim)
|
|
IF fPhase >= 0.0
|
|
AND (i=1 OR i=4)
|
|
//ATTACH_ENTITY_TO_ENTITY(towerPed[i], towerChairObject[GET_TOWER_PED_ATTACH_CHAIR(i)], 0, GET_ANIM_INITIAL_OFFSET_POSITION(sEnterReactDict, sEnterReactAnim, GET_TOWER_PED_ATTACH_POS(i), GET_TOWER_PED_ATTACH_ROT(i), fPhase) , GET_ANIM_INITIAL_OFFSET_ROTATION(sEnterReactDict, sEnterReactAnim, GET_TOWER_PED_ATTACH_POS(i), GET_TOWER_PED_ATTACH_ROT(i), fPhase))
|
|
IF fPhase >= 0.98
|
|
|
|
IF i=1 OR i=4
|
|
flags = AF_LOOPING | AF_IGNORE_GRAVITY
|
|
ELSE
|
|
flags = AF_LOOPING
|
|
ENDIF
|
|
|
|
TASK_PLAY_ANIM(towerPed[i], sLoopReactDict, sLoopReactAnim, SLOW_BLEND_IN, SLOW_BLEND_OUT, -1, flags)
|
|
towerPedState[i] = TOWER_PED_STATE_REACTING
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
BREAK
|
|
|
|
CASE TOWER_PED_STATE_REACTING
|
|
IF IS_ENTITY_PLAYING_ANIM(towerPed[i], sLoopReactDict, sLoopReactAnim)
|
|
fPhase = GET_ENTITY_ANIM_CURRENT_TIME(towerPed[i], sLoopReactDict, sLoopReactAnim)
|
|
IF fPhase >= 0.0
|
|
VECTOR vLastEnterPos
|
|
|
|
vLastEnterPos = GET_ANIM_INITIAL_OFFSET_POSITION(sEnterReactDict, sEnterReactAnim, <<0,0,0>>, <<0,0,0>>, 1.0)
|
|
vLastEnterPos=vLastEnterPos
|
|
VECTOR vLastEnterRot
|
|
|
|
vLastEnterRot = GET_ANIM_INITIAL_OFFSET_ROTATION(sEnterReactDict, sEnterReactAnim, <<0,0,0>>, <<0,0,0>>, 1.0)
|
|
vLastEnterRot=vLastEnterRot
|
|
|
|
//PRINTSTRING("last enter pos = ") PRINTVECTOR(vLastEnterPos) PRINTNL()
|
|
//PRINTSTRING("last enter rot = ") PRINTVECTOR(vLastEnterRot) PRINTNL()
|
|
|
|
//PRINTSTRING("init offset = ") PRINTVECTOR(GET_ANIM_INITIAL_OFFSET_POSITION(sLoopReactDict, sLoopReactAnim, vLastEnterPos + GET_TOWER_PED_ATTACH_POS(i), vLastEnterRot + GET_TOWER_PED_ATTACH_ROT(i), fPhase)) PRINTNL()
|
|
//PRINTSTRING("init rot = ") PRINTVECTOR(GET_ANIM_INITIAL_OFFSET_ROTATION(sLoopReactDict, sLoopReactAnim, vLastEnterPos + GET_TOWER_PED_ATTACH_POS(i), vLastEnterRot + GET_TOWER_PED_ATTACH_ROT(i), fPhase)) PRINTNL()
|
|
|
|
//PRINTSTRING("init offset unmodified = ") PRINTVECTOR(GET_ANIM_INITIAL_OFFSET_POSITION(sLoopReactDict, sLoopReactAnim, GET_TOWER_PED_ATTACH_POS(i), GET_TOWER_PED_ATTACH_ROT(i), fPhase)) PRINTNL()
|
|
//PRINTSTRING("init rot unmodified = ") PRINTVECTOR(GET_ANIM_INITIAL_OFFSET_ROTATION(sLoopReactDict, sLoopReactAnim, GET_TOWER_PED_ATTACH_POS(i), GET_TOWER_PED_ATTACH_ROT(i), fPhase)) PRINTNL()
|
|
|
|
//ATTACH_ENTITY_TO_ENTITY(towerPed[i], towerChairObject[GET_TOWER_PED_ATTACH_CHAIR(i)], 0, GET_ANIM_INITIAL_OFFSET_POSITION(sLoopReactDict, sLoopReactAnim, vLastEnterPos + GET_TOWER_PED_ATTACH_POS(i), vLastEnterRot + GET_TOWER_PED_ATTACH_ROT(i), fPhase) , GET_ANIM_INITIAL_OFFSET_ROTATION(sLoopReactDict, sLoopReactAnim, vLastEnterPos + GET_TOWER_PED_ATTACH_POS(i), vLastEnterRot + GET_TOWER_PED_ATTACH_ROT(i), fPhase))
|
|
ENDIF
|
|
ENDIF
|
|
BREAK
|
|
ENDSWITCH
|
|
ENDIF
|
|
ENDREPEAT
|
|
ENDIF
|
|
|
|
// create the interrogation
|
|
SWITCH createInterrogationStage
|
|
CASE CREATE_INTERROGATION_STAGE_NOT_STARTED
|
|
IF rappelData.vAttachPos.z <= -10
|
|
ADD_MODEL_REQUEST(ENUM_TO_INT(SAGM_PRISONER_HIGH))
|
|
ADD_MODEL_REQUEST(ENUM_TO_INT(SAGM_GUARD))
|
|
ADD_MODEL_REQUEST(ENUM_TO_INT(SAGM_MICHELLE))
|
|
ADD_MODEL_REQUEST(ENUM_TO_INT(SAGM_TORCH))
|
|
// ADD_ANIM_DICT_REQUEST(SAG_ANIM_DICT_MISSION)
|
|
ADD_ANIM_DICT_REQUEST(SAG_ANIM_DICT_CUTSCENES)
|
|
ADD_ANIM_DICT_REQUEST(SAG_ANIM_DICT_TOWER_SEATED)
|
|
ADD_ANIM_DICT_REQUEST(SAG_ANIM_DICT_TOWER_STANDING)
|
|
ADD_ANIM_DICT_REQUEST(SAG_ANIM_DICT_TOWER_SEATED_REACT)
|
|
ADD_ANIM_DICT_REQUEST(SAG_ANIM_DICT_TOWER_STANDING_REACT_ENTER_L)
|
|
ADD_ANIM_DICT_REQUEST(SAG_ANIM_DICT_TOWER_STANDING_REACT_ENTER_R)
|
|
ADD_ANIM_DICT_REQUEST(SAG_ANIM_DICT_TOWER_STANDING_REACT_IDLE)
|
|
createInterrogationStage = CREATE_INTERROGATION_STAGE_WAITING
|
|
ENDIF
|
|
BREAK
|
|
CASE CREATE_INTERROGATION_STAGE_WAITING
|
|
IF HAVE_ALL_MODEL_REQUESTS_SUCCEEDED()
|
|
AND HAVE_ALL_ANIM_DICT_REQUESTS_SUCCEEDED()
|
|
AND IS_OFFICE_READY()
|
|
IF rappelData.vAttachPos.z <= -50
|
|
CREATE_OFFICE_PEDS_FOR_RAPPEL()
|
|
createInterrogationStage = CREATE_INTERROGATION_STAGE_DONE
|
|
ENDIF
|
|
ENDIF
|
|
BREAK
|
|
CASE CREATE_INTERROGATION_STAGE_DONE
|
|
|
|
BREAK
|
|
ENDSWITCH
|
|
|
|
IF NOT bForcePassOnShitskip
|
|
// create tower peds
|
|
IF createInterrogationStage >= CREATE_INTERROGATION_STAGE_WAITING
|
|
AND HAVE_ALL_MODEL_REQUESTS_SUCCEEDED()
|
|
AND HAVE_ALL_ANIM_DICT_REQUESTS_SUCCEEDED()
|
|
// chairs
|
|
VECTOR vChairPos
|
|
FLOAT fChairRot
|
|
REPEAT NUMBER_TOWER_CHAIRS i
|
|
IF NOT DOES_ENTITY_EXIST(towerChairObject[i])
|
|
AND NOT bInitialisedInterrogation
|
|
SWITCH i
|
|
CASE 0
|
|
vChairPos = <<113.300,-618.500,229.020>>
|
|
fChairRot = 57.700
|
|
BREAK
|
|
CASE 1
|
|
vChairPos = <<113.000,-620.500,221.000>>
|
|
fChairRot = 241.700
|
|
BREAK
|
|
CASE 2
|
|
vChairPos = <<113.27467, -618.57690,253.16>>
|
|
fChairRot = 57.700
|
|
BREAK
|
|
ENDSWITCH
|
|
|
|
towerChairObject[i] = GET_CLOSEST_OBJECT_OF_TYPE(vChairPos, 2.0, V_CORP_OFFCHAIR)
|
|
//PRINTSTRING("grabbed!") PRINTNL()
|
|
IF DOES_ENTITY_EXIST(towerChairObject[i])
|
|
SET_ENTITY_COORDS(towerChairObject[i], vChairPos)
|
|
SET_ENTITY_HEADING(towerChairObject[i], fChairRot)
|
|
FREEZE_ENTITY_POSITION(towerChairObject[i], TRUE)
|
|
ENDIF
|
|
ENDIF
|
|
ENDREPEAT
|
|
|
|
// peds
|
|
STRING sAnim
|
|
STRING sDict
|
|
INT iHead
|
|
INT iHeadTexture
|
|
INT iTorso
|
|
INT iTorsoTexture
|
|
INT iLegTexture
|
|
INT iHair
|
|
INT iTask
|
|
|
|
REPEAT NUMBER_TOWER_PEDS i
|
|
IF NOT DOES_ENTITY_EXIST(towerPed[i])
|
|
AND NOT bInitialisedInterrogation
|
|
SWITCH i
|
|
CASE 0
|
|
iHead = 2
|
|
iHeadTexture = 0
|
|
iTorso = 1
|
|
iTorsoTexture = 1
|
|
iLegTexture = 2
|
|
iTask = 0
|
|
iHair = 1
|
|
|
|
sAnim = "base"
|
|
sDict = GET_SNATCH_AND_GRAB_ANIM_DICT_AS_STRING(SAG_ANIM_DICT_TOWER_SEATED)
|
|
BREAK
|
|
CASE 1
|
|
iHead = 1
|
|
iHeadTexture = 0
|
|
iTorso = 2
|
|
iTorsoTexture = 0
|
|
iLegTexture = 0
|
|
iTask = 0
|
|
iHair = 1
|
|
|
|
sAnim = "BASE"
|
|
sDict = GET_SNATCH_AND_GRAB_ANIM_DICT_AS_STRING(SAG_ANIM_DICT_TOWER_STANDING)
|
|
BREAK
|
|
CASE 2
|
|
iHead = 0
|
|
iHeadTexture = 0
|
|
iTorso = 1
|
|
iTorsoTexture = 0
|
|
iLegTexture = 2
|
|
iTask = 0
|
|
iHair = 1
|
|
|
|
sAnim = "base"
|
|
sDict = GET_SNATCH_AND_GRAB_ANIM_DICT_AS_STRING(SAG_ANIM_DICT_TOWER_SEATED)
|
|
BREAK
|
|
CASE 3
|
|
iHead = 0
|
|
iHeadTexture = 0
|
|
iTorso = 0
|
|
iTorsoTexture = 5
|
|
iLegTexture = 0
|
|
iTask = 1
|
|
iHair = 1
|
|
|
|
sAnim = "base"
|
|
sDict = GET_SNATCH_AND_GRAB_ANIM_DICT_AS_STRING(SAG_ANIM_DICT_TOWER_SEATED)
|
|
BREAK
|
|
CASE 4
|
|
iHead = 2
|
|
iHeadTexture = 0
|
|
iTorso = 1
|
|
iTorsoTexture = 0
|
|
iLegTexture = 2
|
|
iTask = 1
|
|
iHair = 1
|
|
|
|
sAnim = "BASE"
|
|
sDict = GET_SNATCH_AND_GRAB_ANIM_DICT_AS_STRING(SAG_ANIM_DICT_TOWER_STANDING)
|
|
BREAK
|
|
ENDSWITCH
|
|
|
|
IF DOES_ENTITY_EXIST(towerChairObject[GET_TOWER_PED_ATTACH_CHAIR(i)])
|
|
towerPed[i] = CREATE_PED(PEDTYPE_MISSION, GET_MODEL_FOR_SNATCH_AND_GRAB_MODEL_ENUM(SAGM_GUARD), <<i,1,2>>)
|
|
SET_BLOCKING_OF_NON_TEMPORARY_EVENTS(towerPed[i], TRUE)
|
|
ATTACH_ENTITY_TO_ENTITY(towerPed[i], towerChairObject[GET_TOWER_PED_ATTACH_CHAIR(i)], 0, GET_TOWER_PED_ATTACH_POS(i), GET_TOWER_PED_ATTACH_ROT(i))
|
|
TASK_PLAY_ANIM(towerPed[i], sDict, sAnim, NORMAL_BLEND_IN, NORMAL_BLEND_OUT, -1, AF_LOOPING)
|
|
IF i=1
|
|
TASK_LOOK_AT_COORD(towerPed[i], <<113.8, -618.9, 230.2>>, -1)
|
|
ELIF i=4
|
|
TASK_LOOK_AT_COORD(towerPed[i], <<113.8, -618.9, 254.2>>, -1)
|
|
ENDIF
|
|
|
|
SET_PED_COMPONENT_VARIATION(towerPed[i], PED_COMP_HEAD, iHead, iHeadTexture)
|
|
SET_PED_COMPONENT_VARIATION(towerPed[i], PED_COMP_TORSO, iTorso, iTorsoTexture)
|
|
SET_PED_COMPONENT_VARIATION(towerPed[i], PED_COMP_LEG, 0, iLegTexture)
|
|
SET_PED_COMPONENT_VARIATION(towerPed[i], PED_COMP_SPECIAL2, iTask, 0)
|
|
SET_PED_COMPONENT_VARIATION(towerPed[i], PED_COMP_HAIR, iHair, 0)
|
|
ENDIF
|
|
ENDIF
|
|
ENDREPEAT
|
|
ENDIF
|
|
ENDIF
|
|
|
|
//PRINTFLOAT(rappelData.vAttachPos.z) PRINTNL()
|
|
IF bForcePassOnShitskip
|
|
rappelData.vAttachPos.z = rappelData.fLimitZ
|
|
IF NOT bAllowSmashIn
|
|
IF IS_SYNCHRONIZED_SCENE_RUNNING(iSyncScene)
|
|
SET_SYNCHRONIZED_SCENE_PHASE(iSyncScene, 0.69)
|
|
STOP_SYNCHRONIZED_AUDIO_EVENT(iSyncScene)
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF createInterrogationStage = CREATE_INTERROGATION_STAGE_DONE
|
|
IF NOT bInitialisedInterrogation
|
|
BOOL bDoInitialise
|
|
bDoInitialise = FALSE
|
|
IF rappelData.vAttachPos.z <= -60
|
|
bDoInitialise = TRUE
|
|
ENDIF
|
|
|
|
IF NOT IS_PED_INJURED(prisonerPed)
|
|
IF IS_ENTITY_ON_SCREEN(prisonerPed)
|
|
bDoInitialise = TRUE
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF bDoInitialise
|
|
IF DOES_ENTITY_EXIST(chairObject)
|
|
IF DOES_ENTITY_HAVE_DRAWABLE(chairObject)
|
|
AND PREPARE_SYNCHRONIZED_AUDIO_EVENT("FBI_02_MCS_3_P1B", 0) // rob 674211
|
|
|
|
// get rid of tower peds
|
|
REPEAT NUMBER_TOWER_PEDS i
|
|
IF DOES_ENTITY_EXIST(towerPed[i])
|
|
DELETE_PED(towerPed[i])
|
|
ENDIF
|
|
ENDREPEAT
|
|
REPEAT NUMBER_TOWER_CHAIRS i
|
|
IF DOES_ENTITY_EXIST(towerChairObject[i])
|
|
SET_OBJECT_AS_NO_LONGER_NEEDED(towerChairObject[i])
|
|
ENDIF
|
|
ENDREPEAT
|
|
|
|
CLEAR_ANIM_DICT_REQUEST(SAG_ANIM_DICT_TOWER_SEATED)
|
|
CLEAR_ANIM_DICT_REQUEST(SAG_ANIM_DICT_TOWER_STANDING)
|
|
CLEAR_ANIM_DICT_REQUEST(SAG_ANIM_DICT_TOWER_SEATED_REACT)
|
|
CLEAR_ANIM_DICT_REQUEST(SAG_ANIM_DICT_TOWER_STANDING_REACT_ENTER_L)
|
|
CLEAR_ANIM_DICT_REQUEST(SAG_ANIM_DICT_TOWER_STANDING_REACT_ENTER_R)
|
|
CLEAR_ANIM_DICT_REQUEST(SAG_ANIM_DICT_TOWER_STANDING_REACT_IDLE)
|
|
|
|
INIT_INTERROGATION()
|
|
bInitialisedInterrogation = TRUE
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ELSE
|
|
// PRINTFLOAT(GET_SYNCHRONIZED_SCENE_PHASE(iSyncScene)) PRINTNL()
|
|
// handle hold shots
|
|
/*
|
|
IF iHoldShotStage < 0
|
|
IF GET_SYNCHRONIZED_SCENE_PHASE(iSyncScene) > 0
|
|
holdShotCam = CREATE_CAM("DEFAULT_SCRIPTED_CAMERA", FALSE)
|
|
iHoldShotStage = 0
|
|
ENDIF
|
|
ELSE
|
|
// update hold shot cam
|
|
FLOAT fUpdatePhase
|
|
SWITCH iHoldShotStage
|
|
CASE 0
|
|
fUpdatePhase = 0.097
|
|
BREAK
|
|
CASE 1
|
|
fUpdatePhase = 0.221
|
|
BREAK
|
|
CASE 2
|
|
fUpdatePhase = 0.357
|
|
BREAK
|
|
CASE 3
|
|
fUpdatePhase = 0.468
|
|
BREAK
|
|
CASE 4
|
|
fUpdatePhase = 0.516
|
|
BREAK
|
|
CASE 5
|
|
fUpdatePhase = 0.612
|
|
BREAK
|
|
CASE 6
|
|
fUpdatePhase = 0.685
|
|
BREAK
|
|
CASE 7
|
|
fUpdatePhase = 0.754
|
|
BREAK
|
|
CASE 8
|
|
fUpdatePhase = 0.849
|
|
BREAK
|
|
DEFAULT
|
|
fUpdatePhase = 1.1
|
|
BREAK
|
|
ENDSWITCH
|
|
|
|
IF GET_SYNCHRONIZED_SCENE_PHASE(iSyncScene) >= fUpdatePhase
|
|
// PRINTSTRING("UPDATE HOLD SHOT CAM!") PRINTNL()
|
|
SET_CAM_COORD(holdShotCam, GET_CAM_COORD(animCam))
|
|
SET_CAM_ROT(holdShotCam, GET_CAM_ROT(animCam))
|
|
SET_CAM_FOV(holdShotCam, GET_CAM_FOV(animCam))
|
|
iHoldShotTime = GET_GAME_TIMER()
|
|
iHoldShotStage++
|
|
ENDIF
|
|
ENDIF
|
|
*/
|
|
|
|
IF GET_SYNCHRONIZED_SCENE_PHASE(iSyncScene) >= 0.4
|
|
HANDLE_STREAMING_MOCAP("fbi_2_mcs_3_p1a", GET_SNATCH_AND_GRAB_VECTOR(SAGVEC_WINDOW_FRAME), DEFAULT_CUTSCENE_LOAD_DIST, DEFAULT_CUTSCENE_UNLOAD_DIST)
|
|
IF CAN_REQUEST_ASSETS_FOR_CUTSCENE_ENTITY()
|
|
IF NOT IS_PED_INJURED(GET_MICHAEL_PED())
|
|
SET_CUTSCENE_PED_COMPONENT_VARIATION_FROM_PED("Michael", GET_MICHAEL_PED())
|
|
ENDIF
|
|
IF NOT IS_PED_INJURED(prisonerPed)
|
|
SET_CUTSCENE_PED_COMPONENT_VARIATION_FROM_PED("MR_K", prisonerPed)
|
|
//SET_CUTSCENE_PED_COMPONENT_VARIATION("MR_K", PED_COMP_SPECIAL, 2, 0)
|
|
ENDIF
|
|
IF NOT IS_PED_INJURED(michellePed)
|
|
SET_CUTSCENE_PED_COMPONENT_VARIATION_FROM_PED("Michelle", michellePed)
|
|
ENDIF
|
|
IF NOT IS_PED_INJURED(guardPed[0])
|
|
SET_CUTSCENE_PED_COMPONENT_VARIATION_FROM_PED("CIA_Goon_1", guardPed[0])
|
|
ENDIF
|
|
IF NOT IS_PED_INJURED(guardPed[1])
|
|
SET_CUTSCENE_PED_COMPONENT_VARIATION_FROM_PED("Lead_CIA", guardPed[1])
|
|
ENDIF
|
|
IF NOT IS_PED_INJURED(guardPed[2])
|
|
SET_CUTSCENE_PED_COMPONENT_VARIATION_FROM_PED("CIA_Goon_2", guardPed[2])
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF NOT bKeepTorch
|
|
IF GET_SYNCHRONIZED_SCENE_PHASE(iSyncScene) >= 0.96
|
|
//PRINTVECTOR(GET_ENTITY_ROTATION(torchObject)) PRINTNL()
|
|
bKeepTorch = TRUE
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF NOT bForcePassOnShitskip
|
|
// interrogation subs
|
|
FLOAT fSubPhase
|
|
STRING sSubLabel
|
|
BOOL bIsClear = FALSE
|
|
SWITCH iInterrogationSubCount
|
|
CASE 0
|
|
fSubPhase = 0.099
|
|
sSubLabel = "SG_SUB1"
|
|
BREAK
|
|
CASE 1
|
|
fSubPhase = 0.161
|
|
bIsClear = TRUE
|
|
BREAK
|
|
CASE 2
|
|
fSubPhase = 0.183
|
|
sSubLabel = "SG_SUB2"
|
|
BREAK
|
|
CASE 3
|
|
fSubPhase = 0.218
|
|
bIsClear = TRUE
|
|
BREAK
|
|
CASE 4
|
|
fSubPhase = 0.235
|
|
sSubLabel = "SG_SUB3"
|
|
BREAK
|
|
CASE 5
|
|
fSubPhase = 0.313
|
|
bIsClear = TRUE
|
|
BREAK
|
|
CASE 6
|
|
fSubPhase = 0.323
|
|
sSubLabel = "SG_SUB4"
|
|
BREAK
|
|
CASE 7
|
|
fSubPhase = 0.339
|
|
bIsClear = TRUE
|
|
BREAK
|
|
CASE 8
|
|
fSubPhase = 0.351
|
|
sSubLabel = "SG_SUB5"
|
|
BREAK
|
|
CASE 9
|
|
fSubPhase = 0.405
|
|
bIsClear = TRUE
|
|
BREAK
|
|
CASE 10
|
|
fSubPhase = 0.463
|
|
sSubLabel = "SG_SUB6"
|
|
BREAK
|
|
CASE 11
|
|
fSubPhase = 0.480
|
|
bIsClear = TRUE
|
|
BREAK
|
|
CASE 12
|
|
fSubPhase = 0.553
|
|
sSubLabel = "SG_SUB7"
|
|
BREAK
|
|
CASE 13
|
|
fSubPhase = 0.590
|
|
bIsClear = TRUE
|
|
BREAK
|
|
CASE 14
|
|
fSubPhase = 0.606
|
|
sSubLabel = "SG_SUB8"
|
|
BREAK
|
|
CASE 15
|
|
fSubPhase = 0.649
|
|
bIsClear = TRUE
|
|
BREAK
|
|
CASE 16
|
|
fSubPhase = 0.677
|
|
sSubLabel = "SG_SUB9"
|
|
BREAK
|
|
CASE 17
|
|
fSubPhase = 0.736
|
|
bIsClear = TRUE
|
|
BREAK
|
|
CASE 18
|
|
fSubPhase = 0.745
|
|
sSubLabel = "SG_SUB10"
|
|
BREAK
|
|
CASE 19
|
|
fSubPhase = 0.756
|
|
bIsClear = TRUE
|
|
BREAK
|
|
CASE 20
|
|
fSubPhase = 0.782
|
|
sSubLabel = "SG_SUB11"
|
|
BREAK
|
|
CASE 21
|
|
fSubPhase = 0.789
|
|
bIsClear = TRUE
|
|
BREAK
|
|
CASE 22
|
|
fSubPhase = 0.810
|
|
sSubLabel = "SG_SUB12"
|
|
BREAK
|
|
CASE 23
|
|
fSubPhase = 0.834
|
|
bIsClear = TRUE
|
|
BREAK
|
|
CASE 24
|
|
fSubPhase = 0.861
|
|
sSubLabel = "SG_SUB13"
|
|
BREAK
|
|
CASE 25
|
|
fSubPhase = 0.910
|
|
bIsClear = TRUE
|
|
BREAK
|
|
ENDSWITCH
|
|
|
|
IF iInterrogationSubCount < 26
|
|
IF GET_SYNCHRONIZED_SCENE_PHASE(iSyncScene) >= fSubPhase
|
|
IF IS_SUBTITLE_PREFERENCE_SWITCHED_ON()
|
|
IF NOT bIsClear
|
|
FORCE_NEXT_MESSAGE_TO_PREVIOUS_BRIEFS_LIST(PREVIOUS_BRIEF_FORCE_DIALOGUE)
|
|
PRINT_NOW(sSubLabel, DEFAULT_GOD_TEXT_TIME, 1)
|
|
ELSE
|
|
CLEAR_PRINTS()
|
|
ENDIF
|
|
ELSE
|
|
CLEAR_PRINTS()
|
|
ENDIF
|
|
iInterrogationSubCount++
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
|
|
// request animations
|
|
IF NOT bRequestedGuardAnims
|
|
IF GET_SYNCHRONIZED_SCENE_PHASE(iSyncScene) >= 0.5
|
|
ADD_ANIM_DICT_REQUEST(SAG_ANIM_DICT_GUARDS)
|
|
bRequestedGuardAnims = TRUE
|
|
ENDIF
|
|
ENDIF
|
|
|
|
// Changing music for the torture cutscene
|
|
IF NOT bTortureMusicStart
|
|
IF rappelData.vAttachPos.z <= -60.00
|
|
//TRIGGER_MISSION_MUSIC_EVENT("FBI2_TEST_TORTURE_CS_START")
|
|
bTortureMusicStart = TRUE
|
|
ENDIF
|
|
ENDIF
|
|
|
|
//PRINTFLOAT(rappelData.vAttachPos.z) PRINTNL()
|
|
|
|
// smash in
|
|
IF NOT bAllowSmashIn
|
|
IF GET_SYNCHRONIZED_SCENE_PHASE(iSyncScene) >= 0.59
|
|
AND HAVE_ALL_ANIM_DICT_REQUESTS_SUCCEEDED()
|
|
//SET_RAPPEL_AI(rappelData, RAPPEL_AI_STOP)
|
|
// set lower limit for jumping down
|
|
rappelData.fLimitZ = -64.8
|
|
ADD_ANIM_DICT_REQUEST(SAG_ANIM_DICT_IN_OFFICE)
|
|
ADD_ANIM_DICT_REQUEST(SAG_ANIM_DICT_AIM_VARIATIONS)
|
|
bAllowSmashIn = TRUE
|
|
ENDIF
|
|
ELSE
|
|
IF NOT bRegisteredSmash
|
|
IF NOT bGaveGuardWeapon
|
|
IF GET_SYNCHRONIZED_SCENE_PHASE(iSyncScene) >= 0.800
|
|
IF NOT IS_PED_INJURED(guardPed[0])
|
|
GIVE_WEAPON_TO_PED(guardPed[0], GET_SNATCH_AND_GRAB_WEAPON_TYPE(SAG_WEAPON_CIA_PISTOL), INFINITE_AMMO, TRUE)
|
|
SET_PED_COMPONENT_VARIATION(guardPed[0], PED_COMP_HAIR, 3, 0)
|
|
bGaveGuardWeapon = TRUE
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF rappelData.vAttachPos.z <= SMASH_IN_HEIGHT
|
|
// guard shoots and kills you
|
|
|
|
IF NOT g_bMagDemoActive
|
|
AND NOT bForcePassOnShitskip
|
|
#IF IS_DEBUG_BUILD
|
|
AND NOT bDebugJSkip
|
|
#ENDIF
|
|
|
|
IF NOT bTriggeredGuardShoot
|
|
IF GET_SYNCHRONIZED_SCENE_PHASE(iSyncScene) >= 0.800
|
|
IF NOT IS_PED_INJURED(guardPed[0])
|
|
//SET_CURRENT_PED_WEAPON(guardPed[0], GET_SNATCH_AND_GRAB_WEAPON_TYPE(SAG_WEAPON_CIA_PISTOL), TRUE)
|
|
SET_PLAYER_CONTROL(PLAYER_ID(), FALSE, SPC_ALLOW_PLAYER_DAMAGE | SPC_REENABLE_CONTROL_ON_DEATH)
|
|
SET_PED_ACCURACY(guardPed[0], 100)
|
|
//TASK_SHOOT_AT_COORD(guardPed[0], GET_ENTITY_COORDS(PLAYER_PED_ID()), -1, FIRING_TYPE_CONTINUOUS)
|
|
ENDIF
|
|
bTriggeredGuardShoot = TRUE
|
|
ENDIF
|
|
ELSE
|
|
IF iGuardShot < 3
|
|
FLOAT fShotPhase
|
|
SWITCH iGuardShot
|
|
CASE 0
|
|
fShotPhase = 0.935
|
|
BREAK
|
|
CASE 1
|
|
fShotPhase = 0.940
|
|
BREAK
|
|
CASE 2
|
|
fShotPhase = 0.946
|
|
BREAK
|
|
ENDSWITCH
|
|
IF GET_SYNCHRONIZED_SCENE_PHASE(iSyncScene) >= fShotPhase
|
|
IF NOT IS_PED_INJURED(guardPed[0])
|
|
SET_PED_SHOOTS_AT_COORD(guardPed[0], GET_ENTITY_COORDS(PLAYER_PED_ID()))
|
|
iGuardShot++
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF NOT bRegisteredSmash
|
|
IF NOT IS_PED_INJURED(guardPed[0])
|
|
IF HAS_ENTITY_BEEN_DAMAGED_BY_ENTITY(PLAYER_PED_ID(), guardPed[0])
|
|
APPLY_DAMAGE_TO_PED(PLAYER_PED_ID(), 1000, TRUE)
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF NOT IS_PED_INJURED(PLAYER_PED_ID())
|
|
IF iGuardShot = 3
|
|
MISSION_FAILED(FAIL_SEEN)
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF NOT bForcePassOnShitskip
|
|
DISPLAY_HELP_TEXT_THIS_FRAME("SG_RAPHLP3B", FALSE)
|
|
ENDIF
|
|
|
|
#IF IS_DEBUG_BUILD
|
|
IF bDebugJSkip
|
|
bRegisteredSmash = TRUE
|
|
ENDIF
|
|
#ENDIF
|
|
|
|
IF bForcePassOnShitskip
|
|
bRegisteredSmash = TRUE
|
|
ENDIF
|
|
|
|
//IF IS_DISABLED_CONTROL_PRESSED(PLAYER_CONTROL, INPUT_SCRIPT_RT)
|
|
// check point in anim
|
|
IF IS_ENTITY_PLAYING_ANIM(PLAYER_PED_ID(), GET_RAPPEL_ANIM_DICT_NAME(), "Rappel_jump_a")
|
|
|
|
FLOAT fTime = GET_ENTITY_ANIM_CURRENT_TIME(PLAYER_PED_ID(), GET_RAPPEL_ANIM_DICT_NAME(), "Rappel_jump_a")
|
|
IF fTime >= 0.1
|
|
AND fTime <= 0.80
|
|
IF CAN_ADVANCE_MISSION()
|
|
START_SNATCH_AND_GRAB_AUDIO_SCENE(SNATCH_AND_GRAB_AUDIO_SCENE_BREAK_THE_GLASS)
|
|
bRegisteredSmash = TRUE
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
//ENDIF
|
|
ENDIF
|
|
ELSE
|
|
IF CAN_ADVANCE_MISSION()
|
|
IF IS_ENTITY_PLAYING_ANIM(PLAYER_PED_ID(), GET_RAPPEL_ANIM_DICT_NAME(), "Rappel_jump_a")
|
|
IF GET_ENTITY_ANIM_CURRENT_TIME(PLAYER_PED_ID(), GET_RAPPEL_ANIM_DICT_NAME(), "Rappel_jump_a") >= 0.70
|
|
IF HAS_CUTSCENE_LOADED_WITH_FAILSAFE()
|
|
REPLAY_RECORD_BACK_FOR_TIME(2.0)
|
|
STOP_SYNCHRONIZED_AUDIO_EVENT(iSyncScene)
|
|
bRunningCutscene = TRUE
|
|
ENDIF
|
|
ENDIF
|
|
ELSE
|
|
IF HAS_CUTSCENE_LOADED_WITH_FAILSAFE()
|
|
REPLAY_RECORD_BACK_FOR_TIME(2.0)
|
|
STOP_SYNCHRONIZED_AUDIO_EVENT(iSyncScene)
|
|
bRunningCutscene = TRUE
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF NOT bForcePassOnShitskip
|
|
// see in help
|
|
IF NOT bDoneSeeHelp
|
|
IF bInitialisedInterrogation
|
|
IF GET_SYNCHRONIZED_SCENE_PHASE(iSyncScene) >= 0.01
|
|
bDoneSeeHelp = DO_MISSION_HELP_TEXT("SG_SEEHLP", TRUE)
|
|
ENDIF
|
|
ENDIF
|
|
ELSE
|
|
/*
|
|
// wait help
|
|
IF NOT bDoneWaitHelp
|
|
IF bAllowSmashIn
|
|
bDoneWaitHelp = TRUE
|
|
ELSE
|
|
IF rappelData.vAttachPos.z <= -60.0
|
|
bDoneWaitHelp = DO_MISSION_HELP_TEXT("SG_WAIHLP")
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
*/
|
|
ENDIF
|
|
ENDIF
|
|
|
|
|
|
IF NOT bForcePassOnShitskip
|
|
// handle interior cam
|
|
IF bInitialisedInterrogation
|
|
IF GET_SYNCHRONIZED_SCENE_PHASE(iSyncScene) >= 0.742
|
|
bInteriorCamIsOutside = TRUE
|
|
ENDIF
|
|
ENDIF
|
|
|
|
BOOL bCancelOfficeCam = FALSE
|
|
BOOL bForceCamOff = FALSE
|
|
|
|
IF bRegisteredSmash
|
|
OR NOT DOES_CAM_EXIST(animCam)
|
|
OR NOT bInitialisedInterrogation
|
|
bForceCamOff = TRUE
|
|
ENDIF
|
|
|
|
IF IS_DISABLED_CONTROL_PRESSED(PLAYER_CONTROL, INPUT_SCRIPT_RRIGHT)
|
|
AND NOT bForceCamOff
|
|
IF NOT bUsingOfficeCam
|
|
IF NOT bWaitingOnOfficeCamRelease
|
|
IF NOT bInteriorCamIsOutside
|
|
SET_HIDOF_OVERRIDE(TRUE, TRUE, 0, 0, 100000, 100000)
|
|
MUFFLE_HELI_SOUND_INDOORS(TRUE)
|
|
SET_VARIABLE_ON_SYNCH_SCENE_AUDIO("INOUT", 1) // rob 674211
|
|
ENDIF
|
|
|
|
IF IS_THIS_HELP_MESSAGE_BEING_DISPLAYED("SG_SEEHLP")
|
|
IF GET_GAME_TIMER() >= iClearHelpTime + 1000
|
|
CLEAR_HELP(FALSE)
|
|
iClearHelpTime = GET_GAME_TIMER()
|
|
ENDIF
|
|
ENDIF
|
|
SET_CAM_ACTIVE(animCam, TRUE)
|
|
|
|
//Set multihead blinders on
|
|
SET_MULTIHEAD_SAFE(TRUE,TRUE)
|
|
|
|
DISPLAY_RADAR(FALSE)
|
|
bDoneSeeHelp = TRUE
|
|
iActivatedOfficeCamTime = GET_GAME_TIMER()
|
|
bUsingOfficeCam = TRUE
|
|
ENDIF
|
|
ELSE
|
|
IF bStuckOnOfficeCam
|
|
bCancelOfficeCam = TRUE
|
|
|
|
//Set multihead blinders off
|
|
SET_MULTIHEAD_SAFE(FALSE,TRUE)
|
|
|
|
bWaitingOnOfficeCamRelease = TRUE
|
|
ENDIF
|
|
ENDIF
|
|
ELSE
|
|
|
|
bWaitingOnOfficeCamRelease = FALSE
|
|
|
|
//CLEAR_ROOM_FOR_GAME_VIEWPORT()
|
|
IF bUsingOfficeCam
|
|
IF (GET_GAME_TIMER() >= iActivatedOfficeCamTime + 500
|
|
AND NOT bStuckOnOfficeCam)
|
|
OR bForceCamOff
|
|
bCancelOfficeCam = TRUE
|
|
|
|
//Set multihead blinders off
|
|
SET_MULTIHEAD_SAFE(FALSE,TRUE)
|
|
ELSE
|
|
bStuckOnOfficeCam = TRUE
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF NOT bUnmuffledRappelAudioScene
|
|
IF bInteriorCamIsOutside
|
|
MUFFLE_HELI_SOUND_INDOORS(FALSE)
|
|
SET_VARIABLE_ON_SYNCH_SCENE_AUDIO("INOUT", 0) // rob 674211
|
|
bUnmuffledRappelAudioScene = TRUE
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF bCancelOfficeCam
|
|
MUFFLE_HELI_SOUND_INDOORS(FALSE)
|
|
SET_VARIABLE_ON_SYNCH_SCENE_AUDIO("INOUT", 0) // rob 674211
|
|
SET_CAM_ACTIVE(animCam, FALSE)
|
|
SET_HIDOF_OVERRIDE(FALSE, TRUE, 0, 0, 0, 0)
|
|
//SET_CAM_ACTIVE(holdShotCam, FALSE)
|
|
DISPLAY_RADAR(TRUE)
|
|
printstring("radar on!") printnl()
|
|
//bHoldingShot = FALSE
|
|
bStuckOnOfficeCam = FALSE
|
|
bUsingOfficeCam = FALSE
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF NOT bRunningCutscene
|
|
BOOL bForceRappelAI = FALSE
|
|
IF NOT bForcePassOnShitskip
|
|
// handle rappel AI
|
|
|
|
IF bInitialisedInterrogation
|
|
IF rappelData.vAttachPos.z > SMASH_IN_HEIGHT
|
|
IF bUsingOfficeCam
|
|
OR GET_SYNCHRONIZED_SCENE_PHASE(iSyncScene) >= 0.58
|
|
SET_RAPPEL_AI(rappelData, RAPPEL_AI_MOVE_SLOW)
|
|
bForceRappelAI = TRUE
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
IF NOT bForceRappelAI
|
|
SET_RAPPEL_AI(rappelData, RAPPEL_AI_STOP)
|
|
ENDIF
|
|
ENDIF
|
|
|
|
// handle rappel
|
|
HANDLE_RAPPEL_PED(rappelData, bForceRappelAI, TRUE, bAllowResetToIdle, rappelData.vAttachPos.z > SMASH_IN_HEIGHT, bAllowSmashIn AND rappelData.vAttachPos.z <= SMASH_IN_HEIGHT)
|
|
|
|
APPLY_CUSTOM_RAPPEL_CAM()
|
|
ENDIF
|
|
|
|
IF bInteriorCamIsOutside
|
|
OR NOT bUsingOfficeCam
|
|
CASCADE_SHADOWS_SET_CASCADE_BOUNDS_SCALE(CASCADE_SHADOWS_MULTIPLIER_EXTERIOR_OVERRIDE)
|
|
CASCADE_SHADOWS_SET_ENTITY_TRACKER_SCALE(CASCADE_SHADOWS_ROPE_OVERRIDE)
|
|
SET_USE_HI_DOF()
|
|
ELSE
|
|
CASCADE_SHADOWS_SET_CASCADE_BOUNDS_SCALE(CASCADE_SHADOWS_MULTIPLIER_INTERIOR_OVERRIDE)
|
|
CASCADE_SHADOWS_SET_ENTITY_TRACKER_SCALE(1.0)
|
|
OVERRIDE_LODSCALE_THIS_FRAME(1.0)
|
|
ENDIF
|
|
ELSE
|
|
// run the smash in / grab prisoner cutscene
|
|
DO_SMASH_IN_CUTSCENE()
|
|
ENDIF
|
|
ENDPROC
|
|
|
|
// cutscene of being winched in
|
|
PROC DO_WINCH_CUTSCENE()
|
|
//HANDLE_CHOPPER_ROPE(ROPE_TYPE_SWINGING)
|
|
IF bApplyOffsetToWinchRope
|
|
IF GET_CUTSCENE_TIME() >= 1500
|
|
AND HAS_CUTSCENE_CUT_THIS_FRAME()
|
|
bApplyOffsetToWinchRope = FALSE
|
|
ENDIF
|
|
ENDIF
|
|
|
|
|
|
DISPLAY_SNIPER_SCOPE_THIS_FRAME()
|
|
REQUEST_ADDITIONAL_COLLISION_AT_COORD(<<-135.84, -592.13, 210.68>>)
|
|
|
|
SWITCH cutsceneStage
|
|
CASE SAG_CUT_STAGE_INIT
|
|
|
|
PED_INDEX michaelPed
|
|
michaelPed = GET_MICHAEL_PED()
|
|
PED_INDEX trevorPed
|
|
trevorPed = GET_TREVOR_PED()
|
|
PED_INDEX franklinPed
|
|
franklinPed = GET_FRANKLIN_PED()
|
|
|
|
// michael
|
|
IF NOT IS_PED_INJURED(michaelPed)
|
|
DETACH_ENTITY(michaelPed)
|
|
REGISTER_ENTITY_FOR_CUTSCENE(michaelPed, "Michael", CU_ANIMATE_EXISTING_SCRIPT_ENTITY)
|
|
ENDIF
|
|
|
|
// michael
|
|
IF NOT IS_PED_INJURED(trevorPed)
|
|
REGISTER_ENTITY_FOR_CUTSCENE(trevorPed, "Trevor", CU_ANIMATE_EXISTING_SCRIPT_ENTITY)
|
|
ENDIF
|
|
|
|
// mr k
|
|
IF NOT IS_PED_INJURED(prisonerPed)
|
|
DETACH_ENTITY(prisonerPed)
|
|
REGISTER_ENTITY_FOR_CUTSCENE(prisonerPed, "MR_K", CU_ANIMATE_EXISTING_SCRIPT_ENTITY)
|
|
ENDIF
|
|
|
|
// franklin
|
|
IF NOT IS_PED_INJURED(franklinPed)
|
|
DETACH_ENTITY(franklinPed)
|
|
ENDIF
|
|
|
|
IF IS_VEHICLE_DRIVEABLE(snatchAndGrabVehicle[SAGV_PLAYER_CHOPPER])
|
|
REGISTER_ENTITY_FOR_CUTSCENE(snatchAndGrabVehicle[SAGV_PLAYER_CHOPPER], "Main_heli", CU_ANIMATE_EXISTING_SCRIPT_ENTITY)
|
|
ENDIF
|
|
|
|
START_CUTSCENE(CUTSCENE_SUPPRESS_FP_TRANSITION_FLASH)
|
|
|
|
CLEAR_PED_TASKS(dummyFranklinPed) //[MF] Allow us to have Franklin doing AI aiming when the cutscene ends.
|
|
|
|
DRAW_ROPE_TO_POINT(TRUE, GET_ROPE_LAST_VERTEX_COORD(rappelData.rope))
|
|
|
|
//[MF] Load helipad geo around Franklin
|
|
eSwitchCamState = SWITCH_CAM_REQUEST_ASSETS
|
|
HANDLE_SWITCH_CAM_HANGING_TO_SNIPER(scsSwitch_HangingToSniper)
|
|
|
|
bDoneHitSound = FALSE
|
|
bWooshStarted = FALSE
|
|
|
|
iSnatchAndGrabCutsceneTime = GET_GAME_TIMER()
|
|
cutsceneStage = SAG_CUT_STAGE_RUNNING
|
|
BREAK
|
|
|
|
CASE SAG_CUT_STAGE_RUNNING
|
|
IF NOT bClearedForCutscene
|
|
IF IS_CUTSCENE_PLAYING()
|
|
//SCRIPT_OVERRIDES_WIND_TYPES(true,"WEATHER_TYPES_MAGDEMO_FIB2_OUTSIDE_WINDOW","WEATHER_TYPES_MAGDEMO_FIB2_OUTSIDE_WINDOW")
|
|
IF IS_NEW_LOAD_SCENE_ACTIVE()
|
|
NEW_LOAD_SCENE_STOP()
|
|
ENDIF
|
|
IF STREAMVOL_IS_VALID(sniperVolume)
|
|
STREAMVOL_DELETE(sniperVolume)
|
|
ENDIF
|
|
IF STREAMVOL_IS_VALID(officeVolume)
|
|
STREAMVOL_DELETE(officeVolume)
|
|
ENDIF
|
|
|
|
IF DOES_ROPE_EXIST(rappelData.rope)
|
|
DELETE_ROPE(rappelData.rope)
|
|
ENDIF
|
|
|
|
CREATE_CHOPPER_ROPE(ROPE_TYPE_INSIDE)
|
|
DRAW_ROPE_TO_POINT(FALSE, <<0,0,0>>, bApplyOffsetToWinchRope, TRUE)
|
|
|
|
sniperVolume = STREAMVOL_CREATE_FRUSTUM(<<-133.8, -591.8, 212.0>>, CONVERT_ROTATION_TO_DIRECTION_VECTOR(<<-0.3, 1.6, 116.4>>), 500, FLAG_MAPDATA)
|
|
|
|
//NEW_LOAD_SCENE_START_SPHERE(<<-135.84, -592.13, 210.68>>, 2, NEWLOADSCENE_FLAG_REQUIRE_COLLISION)
|
|
SET_MISSION_MOCAP_CUTSCENE()
|
|
|
|
CREATE_ENEMY_CHOPPER(TRUE)
|
|
|
|
STOP_SNATCH_AND_GRAB_AUDIO_SCENE(SNATCH_AND_GRAB_AUDIO_SCENE_FRANKLIN_SNIPE_ENEMIES)
|
|
STOP_SNATCH_AND_GRAB_AUDIO_SCENE(SNATCH_AND_GRAB_AUDIO_SCENE_MICHAEL_SHOOT_ENEMIES)
|
|
|
|
DRAW_ROPE_TO_POINT(FALSE, <<0,0,0>>, bApplyOffsetToWinchRope, TRUE, TRUE)
|
|
|
|
IF IS_SCREEN_FADED_OUT()
|
|
DO_SCREEN_FADE_IN(DEFAULT_FADE_TIME)
|
|
ENDIF
|
|
|
|
bClearedForCutscene = TRUE
|
|
ENDIF
|
|
ELSE
|
|
DRAW_ROPE_TO_POINT(FALSE, <<0,0,0>>, bApplyOffsetToWinchRope, TRUE)
|
|
ENDIF
|
|
|
|
IF NOT bDoneChoppersApproachingCue
|
|
IF GET_GAME_TIMER() >= iSnatchAndGrabCutsceneTime + 3000
|
|
bDoneChoppersApproachingCue = TRIGGER_MISSION_MUSIC_EVENT("FIB2_HELICOPTERS_APPROACHING")
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF CAN_SET_EXIT_STATE_FOR_REGISTERED_ENTITY("Main_Heli")
|
|
SET_CHOPPER_TO_ESCAPE(TRUE)
|
|
PRINTSTRING("set chopper escape") PRINTNL()
|
|
ENDIF
|
|
|
|
IF CAN_SET_EXIT_STATE_FOR_REGISTERED_ENTITY("Trevor")
|
|
IF NOT IS_PED_INJURED(GET_TREVOR_PED())
|
|
IF NOT IS_PED_IN_ANY_VEHICLE(GET_TREVOR_PED())
|
|
DETACH_ENTITY(GET_TREVOR_PED())
|
|
SET_PED_INTO_VEHICLE(GET_TREVOR_PED(), snatchAndGrabVehicle[SAGV_PLAYER_CHOPPER])
|
|
FORCE_PED_AI_AND_ANIMATION_UPDATE(GET_TREVOR_PED())
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF CAN_SET_EXIT_STATE_FOR_REGISTERED_ENTITY("MR_K")
|
|
IF NOT IS_PED_INJURED(prisonerPed)
|
|
IF NOT IS_PED_IN_ANY_VEHICLE(prisonerPed)
|
|
DETACH_ENTITY(prisonerPed)
|
|
SET_PED_INTO_VEHICLE(prisonerPed, snatchAndGrabVehicle[SAGV_PLAYER_CHOPPER], VS_BACK_RIGHT)
|
|
DO_MR_K_AGITATED_ANIM()
|
|
FORCE_PED_AI_AND_ANIMATION_UPDATE(prisonerPed)
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF CAN_SET_EXIT_STATE_FOR_REGISTERED_ENTITY("Michael")
|
|
PRINTSTRING("hit michael exit state") PRINTNL()
|
|
|
|
IF GET_CURRENT_PLAYER_PED_ENUM() <> CHAR_FRANKLIN
|
|
MAKE_SELECTOR_PED_SELECTION(sSelectorPeds, SELECTOR_PED_FRANKLIN)
|
|
TAKE_CONTROL_OF_SELECTOR_PED(sSelectorPeds)
|
|
REAPPLY_PLAYER_PED_ATTRIBUTES()
|
|
ENDIF
|
|
|
|
SET_ENTITY_VISIBLE(PLAYER_PED_ID(), FALSE)
|
|
|
|
PRINTSTRING("switched to Franklin") PRINTNL()
|
|
|
|
IF NOT IS_PED_INJURED(GET_MICHAEL_PED())
|
|
IF NOT IS_PED_IN_ANY_VEHICLE(GET_MICHAEL_PED())
|
|
DETACH_ENTITY(GET_MICHAEL_PED())
|
|
ENDIF
|
|
//SET_MICHAEL_CUSTOM_DRIVEBY_IN_CHOPPER()
|
|
//FORCE_PED_AI_AND_ANIMATION_UPDATE(GET_MICHAEL_PED())
|
|
ENDIF
|
|
|
|
SET_ENTITY_COORDS(PLAYER_PED_ID(), <<-142.83, -593.62, 210.77>>, TRUE, TRUE)
|
|
//CLEAR_PED_TASKS_IMMEDIATELY(PLAYER_PED_ID())
|
|
|
|
PRINTSTRING("set position") PRINTNL()
|
|
ENDIF
|
|
|
|
IF CAN_SET_EXIT_STATE_FOR_CAMERA()
|
|
SET_MISSION_CUTSCENE(FALSE)
|
|
|
|
PRINTSTRING("set mission cutscene false") PRINTNL()
|
|
|
|
INT i
|
|
REPEAT NUMBER_ENEMY_CHOPPERS i
|
|
IF IS_VEHICLE_DRIVEABLE(enemyChopperVehicle[i])
|
|
IF IS_PLAYBACK_GOING_ON_FOR_VEHICLE(enemyChopperVehicle[i])
|
|
IF i < 2
|
|
SKIP_TIME_IN_PLAYBACK_RECORDED_VEHICLE(enemyChopperVehicle[i], AFTER_CUTSCENE_TIME)
|
|
ELSE
|
|
SKIP_TIME_IN_PLAYBACK_RECORDED_VEHICLE(enemyChopperVehicle[i], AFTER_CUTSCENE_LONG_TIME)
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDREPEAT
|
|
|
|
DO_STREAM_VOLUME_ON_OFFICE(FALSE)
|
|
|
|
PRINTSTRING("did chopper skips") PRINTNL()
|
|
|
|
eSwitchCamState = SWITCH_CAM_SETUP_SPLINE
|
|
|
|
GIVE_MICHAEL_RIFLE()
|
|
SET_MICHAEL_CUSTOM_DRIVEBY_IN_CHOPPER()
|
|
FORCE_PED_AI_AND_ANIMATION_UPDATE(GET_MICHAEL_PED())
|
|
|
|
WHILE NOT HANDLE_SWITCH_CAM_HANGING_TO_SNIPER(scsSwitch_HangingToSniper)
|
|
//#IF IS_DEBUG_BUILD
|
|
//UPDATE_SPLINE_CAM_WIDGETS(scsSwitch_HangingToSniper)
|
|
//#ENDIF
|
|
WAIT_WITH_RECORD()
|
|
ENDWHILE
|
|
|
|
SET_MISSION_STAGE(STAGE_CHOPPER_CHASE)
|
|
SET_ENTITY_VISIBLE(PLAYER_PED_ID(), TRUE)
|
|
|
|
IF STREAMVOL_IS_VALID(sniperVolume)
|
|
STREAMVOL_DELETE(sniperVolume)
|
|
ENDIF
|
|
NEW_LOAD_SCENE_STOP()
|
|
|
|
PRINTSTRING("set stage successfully") PRINTNL()
|
|
ENDIF
|
|
|
|
#IF IS_DEBUG_BUILD
|
|
DEBUG_SKIP_MOCAP()
|
|
#ENDIF
|
|
BREAK
|
|
|
|
CASE SAG_CUT_STAGE_CLEANUP
|
|
|
|
BREAK
|
|
ENDSWITCH
|
|
ENDPROC
|
|
|
|
// take out the guards threatening Michael from an adjacent building
|
|
PROC DO_STAGE_SNIPE_GUARDS()
|
|
DISABLE_CELLPHONE_THIS_FRAME_ONLY()
|
|
|
|
REPLAY_DISABLE_CAMERA_MOVEMENT_THIS_FRAME()
|
|
|
|
DISABLE_ON_FOOT_FIRST_PERSON_VIEW_THIS_UPDATE()
|
|
DISABLE_BLUR_ON_RIFLE_MODEL()
|
|
|
|
IF NOT IS_PED_INJURED(PLAYER_PED_ID())
|
|
SET_PLAYER_SIMULATE_AIMING(PLAYER_ID(), FALSE)
|
|
ENDIF
|
|
|
|
INT i
|
|
FLOAT fPhase
|
|
|
|
IF NOT bSetSniperZoom
|
|
SET_FIRST_PERSON_AIM_CAM_ZOOM_FACTOR(INIT_SNIPER_ZOOM)
|
|
bSetSniperZoom = TRUE
|
|
ENDIF
|
|
SET_FIRST_PERSON_AIM_CAM_RELATIVE_HEADING_LIMITS_THIS_UPDATE(-25, 25)
|
|
SET_FIRST_PERSON_AIM_CAM_RELATIVE_PITCH_LIMITS_THIS_UPDATE(-10, 10)
|
|
|
|
CASCADE_SHADOWS_SET_CASCADE_BOUNDS_SCALE(CASCADE_SHADOWS_MULTIPLIER_NO_OVERRIDE)
|
|
|
|
SET_RADAR_AS_INTERIOR_THIS_FRAME(GET_HASH_KEY("V_FakeDT1_05"), 150.0, -700.0, 0, 1)
|
|
|
|
// disable michael controls
|
|
//IF GET_CURRENT_PLAYER_PED_ENUM() = CHAR_MICHAEL
|
|
/// DISABLE_CONTROL_ACTION(PLAYER_CONTROL, INPUT_SPECIAL_ABILITY)
|
|
// DISABLE_CONTROL_ACTION(PLAYER_CONTROL, INPUT_SPECIAL_ABILITY_SECONDARY)
|
|
//ENDIF
|
|
|
|
DISABLE_CONTROL_ACTION(PLAYER_CONTROL, INPUT_SELECT_WEAPON)
|
|
DISABLE_CONTROL_ACTION(PLAYER_CONTROL, INPUT_JUMP)
|
|
DISABLE_CONTROL_ACTION(PLAYER_CONTROL, INPUT_ENTER)
|
|
DISABLE_CONTROL_ACTION(PLAYER_CONTROL, INPUT_SPRINT)
|
|
IF GET_CURRENT_PLAYER_PED_ENUM() = CHAR_FRANKLIN
|
|
DISABLE_CONTROL_ACTION(PLAYER_CONTROL, INPUT_MOVE_UD)
|
|
DISABLE_CONTROL_ACTION(PLAYER_CONTROL, INPUT_MOVE_LR)
|
|
ENDIF
|
|
|
|
IF NOT IS_PED_INJURED(GET_MICHAEL_PED())
|
|
SET_PED_CAN_SWITCH_WEAPON(GET_MICHAEL_PED(), FALSE)
|
|
ENDIF
|
|
IF NOT IS_PED_INJURED(GET_FRANKLIN_PED())
|
|
SET_ENTITY_CAN_BE_DAMAGED_BY_RELATIONSHIP_GROUP(GET_FRANKLIN_PED(), FALSE, agencyRelGroup)
|
|
SET_PED_CAN_SWITCH_WEAPON(GET_FRANKLIN_PED(), FALSE)
|
|
ENDIF
|
|
IF NOT IS_PED_INJURED(GET_TREVOR_PED())
|
|
SET_PED_CAN_SWITCH_WEAPON(GET_TREVOR_PED(), FALSE)
|
|
ENDIF
|
|
|
|
// smash the window if not already smashed
|
|
HANDLE_WINDOW_SMASH(TRUE, TRUE)
|
|
|
|
// ensure the door is always open
|
|
MAINTAIN_DOOR_OPEN()
|
|
|
|
PED_INDEX fPed = GET_FRANKLIN_PED()
|
|
IF NOT IS_PED_INJURED(fPed)
|
|
IF HAS_PED_GOT_WEAPON(fPed, GET_SNATCH_AND_GRAB_WEAPON_TYPE(SAG_WEAPON_SNIPER_RIFLE))
|
|
WEAPON_TYPE weapon
|
|
GET_CURRENT_PED_WEAPON(fPed, weapon)
|
|
IF weapon <> GET_SNATCH_AND_GRAB_WEAPON_TYPE(SAG_WEAPON_SNIPER_RIFLE)
|
|
PRINTSTRING("franklin has a rifle but it is not equipped!!!") PRINTNL()
|
|
SET_CURRENT_PED_WEAPON(fPed, GET_SNATCH_AND_GRAB_WEAPON_TYPE(SAG_WEAPON_SNIPER_RIFLE), TRUE)
|
|
ENDIF
|
|
ELSE
|
|
PRINTSTRING("franklin doesn't have a rifle!!!") PRINTNL()
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF NOT bRunningCutscene
|
|
// Starting the sniping section music
|
|
IF NOT bSniperMusicStarted
|
|
IF NOT IS_PED_INJURED(PLAYER_PED_ID())
|
|
//TRIGGER_MISSION_MUSIC_EVENT("FBI2_TEST_SNIPER_SECTION_MOOD")
|
|
bSniperMusicStarted = TRUE
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF prisonerGrabState >= PRISONER_GRAB_STATE_EXTRACT
|
|
IF NOT bPreparedChoppersApproachingCue
|
|
bPreparedChoppersApproachingCue = PREPARE_MUSIC_EVENT("FIB2_HELICOPTERS_APPROACHING")
|
|
ENDIF
|
|
|
|
HANDLE_STREAMING_MOCAP("fbi_2_mcs_3b", GET_SNATCH_AND_GRAB_VECTOR(SAGVEC_WINDOW_FRAME), DEFAULT_CUTSCENE_LOAD_DIST, DEFAULT_CUTSCENE_UNLOAD_DIST)
|
|
|
|
IF CAN_REQUEST_ASSETS_FOR_CUTSCENE_ENTITY()
|
|
IF NOT IS_PED_INJURED(GET_MICHAEL_PED())
|
|
SET_CUTSCENE_PED_COMPONENT_VARIATION_FROM_PED("Michael", GET_MICHAEL_PED())
|
|
ENDIF
|
|
IF NOT IS_PED_INJURED(GET_TREVOR_PED())
|
|
SET_CUTSCENE_PED_PROP_VARIATION("Trevor", ANCHOR_HEAD, 12)
|
|
ENDIF
|
|
IF NOT IS_PED_INJURED(prisonerPed)
|
|
SET_CUTSCENE_PED_COMPONENT_VARIATION_FROM_PED("MR_K", prisonerPed)
|
|
SET_CUTSCENE_PED_COMPONENT_VARIATION("MR_K", PED_COMP_SPECIAL, 0, 0)
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
|
|
// handle the chopper
|
|
//IF extractStage < EXTRACT_STAGE_KILL_REINFORCEMENTS
|
|
// MAINTAIN_CHOPPER_HOVER()
|
|
//ENDIF
|
|
|
|
// handle the rope
|
|
IF bActivatedRopeSwingFromSynced
|
|
HANDLE_CHOPPER_ROPE(ROPE_TYPE_SWINGING)
|
|
ELSE
|
|
HANDLE_CHOPPER_ROPE(ROPE_TYPE_INSIDE)
|
|
ENDIF
|
|
|
|
// Forces closer fov while Michael is near window and shorter transition to aim camera.
|
|
SET_PLAYER_FORCE_SKIP_AIM_INTRO(PLAYER_ID(), TRUE)
|
|
SET_FOLLOW_PED_CAM_THIS_UPDATE("FOLLOW_PED_ATTACHED_TO_ROPE_CAMERA", 0)
|
|
IF NOT IS_PED_INJURED(PLAYER_PED_ID())
|
|
DISABLE_GAMEPLAY_CAM_ALTITUDE_FOV_SCALING_THIS_UPDATE()
|
|
ENDIF
|
|
//ENSURE_FRANKLIN_INVISIBLE()
|
|
|
|
// handle hotswapping between michael and franklin
|
|
IF NOT bActivatedRopeSwingFromSynced
|
|
DISABLE_SELECTOR_THIS_FRAME()
|
|
//UPDATE_REMOTE_SNIPER(remoteSniperData)
|
|
ELSE
|
|
IF bDebugSwingOutEarlier
|
|
IF hangingHotswapState <> HANGING_HOTSWAP_ON_TREVOR
|
|
AND hangingHotswapState <> HANGING_HOTSWAP_ON_FRANKLIN
|
|
AND hangingHotswapState <> HANGING_HOTSWAP_ON_MICHAEL
|
|
iSuppressHUDTime = GET_GAME_TIMER() + 100
|
|
ENDIF
|
|
|
|
IF GET_GAME_TIMER() <= iSuppressHUDTime
|
|
HIDE_SELECTOR_THIS_FRAME()
|
|
DISPLAY_RADAR(FALSE)
|
|
bTurnedOffRadarForSuppressHud = TRUE
|
|
ELSE
|
|
IF bTurnedOffRadarForSuppressHud
|
|
DISPLAY_RADAR(TRUE)
|
|
bTurnedOffRadarForSuppressHud = FALSE
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF GET_GAME_TIMER() <= iSuppressHUDTime + 100
|
|
HIDE_HUD_COMPONENT_THIS_FRAME(NEW_HUD_STREET_NAME)
|
|
HIDE_HUD_COMPONENT_THIS_FRAME(NEW_HUD_VEHICLE_NAME)
|
|
HIDE_HUD_COMPONENT_THIS_FRAME(NEW_HUD_AREA_NAME)
|
|
HIDE_HUD_COMPONENT_THIS_FRAME(NEW_HUD_DISTRICT_NAME)
|
|
ENDIF
|
|
|
|
SWITCH hangingHotswapState
|
|
CASE HANGING_HOTSWAP_ON_FRANKLIN
|
|
HANDLE_MICHAEL_SHOOTING()
|
|
|
|
// set reinforcement ped 5 no ragdoll
|
|
IF NOT IS_PED_INJURED(reinforcementPed[5])
|
|
SET_PED_CAN_RAGDOLL(reinforcementPed[5], FALSE)
|
|
ENDIF
|
|
|
|
// switch menu
|
|
BOOL bSelectorCheck
|
|
bSelectorCheck = FALSE
|
|
IF CAN_ADVANCE_MISSION()
|
|
bSelectorCheck = UPDATE_SELECTOR_HUD(sSelectorPeds, FALSE)
|
|
ENDIF
|
|
|
|
// remote sniper
|
|
//UPDATE_REMOTE_SNIPER(remoteSniperData)
|
|
|
|
IF bSelectorCheck
|
|
//OR bForceSwapFromFranklinToMichael
|
|
IF sSelectorPeds.eNewSelectorPed = SELECTOR_PED_MICHAEL
|
|
//OR bForceSwapFromFranklinToMichael
|
|
// SET_REMOTE_SNIPER_ACTIVE(remoteSniperData, FALSE)
|
|
// RENDER_SCRIPT_CAMS(TRUE, FALSE)
|
|
// remoteSniperData.i_sniper_shot_timer = 0
|
|
STOP_SNATCH_AND_GRAB_AUDIO_SCENE(SNATCH_AND_GRAB_AUDIO_SCENE_FRANKLIN_SNIPE_ENEMIES)
|
|
START_SNATCH_AND_GRAB_AUDIO_SCENE(SNATCH_AND_GRAB_AUDIO_SCENE_MICHAEL_SHOOT_ENEMIES)
|
|
|
|
//PLAY_SOUND_FRONTEND(-1, "Hit_In", "PLAYER_SWITCH_CUSTOM_SOUNDSET")//"Hit_In", "PLAYER_SWITCH_CUSTOM_SOUNDSET")
|
|
//PLAY_SOUND_FRONTEND(iSniperSwitchSoundID, "Camera_Move_Loop", "PLAYER_SWITCH_CUSTOM_SOUNDSET")
|
|
|
|
bHitFranklinSound = FALSE
|
|
bDoneFlash = FALSE
|
|
|
|
iSwitchTime = GET_GAME_TIMER()
|
|
|
|
michaelTargetPed = NULL
|
|
bReattachedMichael = FALSE
|
|
INFORM_MISSION_STATS_OF_INCREMENT(FBI2_SWITCHES)
|
|
hangingHotswapState = HANGING_HOTSWAP_FRANKLIN_TO_MICHAEL
|
|
ENDIF
|
|
ELSE
|
|
IF IS_SELECTOR_ONSCREEN()
|
|
SET_PLAYER_FORCE_SKIP_AIM_INTRO(PLAYER_ID(),TRUE)
|
|
SET_PLAYER_FORCED_AIM(PLAYER_ID(), TRUE)
|
|
|
|
DESTROY_MISSION_STATIC_CAM(staticCam)
|
|
CREATE_MISSION_STATIC_CAM(staticCam)
|
|
|
|
// HACK: have to hardcode this as Franklin is actually floating in mid-air for the sniper rifle to be close enough to shoot.
|
|
//SET_CAM_PARAMS(staticCam, <<-136.387,-592.535,211.892>>, <<-1.573389,0.0,-96.932442>>, 35.0) // To match start of character switch (vSniperPos, vSniperRot)
|
|
SET_CAM_PARAMS(staticCam, vSniperNodePos3, vSniperNodeRot3, 35.0)
|
|
|
|
|
|
////ATTACH_CAM_TO_ENTITY(staticCam, GET_FRANKLIN_PED(), <<0.0,-3.0,0.3>>, TRUE)
|
|
////POINT_CAM_AT_ENTITY(staticCam, GET_FRANKLIN_PED(), <<0,0,0.8>>, TRUE)
|
|
|
|
RENDER_SCRIPT_CAMS(TRUE, FALSE)
|
|
////PRINTSTRING("Show Franklin here") PRINTNL()
|
|
ELSE
|
|
DESTROY_MISSION_STATIC_CAM(staticCam)
|
|
RENDER_SCRIPT_CAMS(FALSE, FALSE)
|
|
ENDIF
|
|
ENDIF
|
|
BREAK
|
|
CASE HANGING_HOTSWAP_ON_MICHAEL
|
|
// set reinforcement ped 5 can ragdoll
|
|
IF NOT IS_PED_INJURED(reinforcementPed[5])
|
|
SET_PED_CAN_RAGDOLL(reinforcementPed[5], TRUE)
|
|
ENDIF
|
|
|
|
SET_GAMEPLAY_CAM_MAX_MOTION_BLUR_STRENGTH_THIS_UPDATE(0.0)
|
|
HANDLE_FRANKLIN_SNIPING()
|
|
// do sound
|
|
IF HAS_SOUND_FINISHED(iDangleSoundID)
|
|
PLAY_SOUND_FROM_ENTITY(iDangleSoundID, "FBI_02_SNATCH_AND_GRAB_DANGLE", PLAYER_PED_ID())
|
|
SET_VARIABLE_ON_SOUND(iDangleSoundID,"PlayerSpeed",GET_ENTITY_SPEED(snatchAndGrabVehicle[SAGV_PLAYER_CHOPPER]))
|
|
ELSE
|
|
SET_VARIABLE_ON_SOUND(iDangleSoundID,"PlayerSpeed",GET_ENTITY_SPEED(snatchAndGrabVehicle[SAGV_PLAYER_CHOPPER]))
|
|
ENDIF
|
|
|
|
// switch menu
|
|
IF CAN_ADVANCE_MISSION()
|
|
IF UPDATE_SELECTOR_HUD(sSelectorPeds, FALSE)
|
|
#IF IS_DEBUG_BUILD
|
|
OR bDebugJSkip
|
|
#ENDIF
|
|
IF sSelectorPeds.eNewSelectorPed = SELECTOR_PED_FRANKLIN
|
|
INFORM_MISSION_STATS_OF_INCREMENT(FBI2_SWITCHES)
|
|
START_SNATCH_AND_GRAB_AUDIO_SCENE(SNATCH_AND_GRAB_AUDIO_SCENE_FRANKLIN_SNIPE_ENEMIES)
|
|
STOP_SNATCH_AND_GRAB_AUDIO_SCENE(SNATCH_AND_GRAB_AUDIO_SCENE_MICHAEL_SHOOT_ENEMIES)
|
|
|
|
//PLAY_SOUND_FRONTEND(-1, "Hit_In", "PLAYER_SWITCH_CUSTOM_SOUNDSET")//"Hit_In", "PLAYER_SWITCH_CUSTOM_SOUNDSET")
|
|
//PLAY_SOUND_FRONTEND(iSniperSwitchSoundID, "Camera_Move_Loop", "PLAYER_SWITCH_CUSTOM_SOUNDSET")
|
|
|
|
bDoneFlash = FALSE
|
|
bHitFranklinSound = FALSE
|
|
iSwitchTime = GET_GAME_TIMER()
|
|
|
|
hangingHotswapState = HANGING_HOTSWAP_MICHAEL_TO_FRANKLIN
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
BREAK
|
|
CASE HANGING_HOTSWAP_MICHAEL_TO_FRANKLIN
|
|
IF NOT bDoneFlash
|
|
ANIMPOSTFX_STOP_AND_FLUSH_REQUESTS("SwitchHUDMichaelOut")
|
|
ANIMPOSTFX_STOP_AND_FLUSH_REQUESTS("SwitchHUDFranklinOut")
|
|
ANIMPOSTFX_PLAY("SwitchShortMichaelIn", 0, FALSE)
|
|
bDoneFlash = TRUE
|
|
ENDIF
|
|
|
|
IF NOT bHitFranklinSound
|
|
IF NOT IS_PED_INJURED(dummyFranklinPed)
|
|
IF IS_ENTITY_AT_COORD(dummyFranklinPed, GET_FINAL_RENDERED_CAM_COORD(), <<90,90,90>>, FALSE, FALSE)
|
|
//PLAY_SOUND_FRONTEND(-1, "Hit_Out", "PLAYER_SWITCH_CUSTOM_SOUNDSET")
|
|
//STOP_SOUND(iSniperSwitchSoundID)
|
|
//ANIMPOSTFX_PLAY("SwitchShortFranklinMid", 0, FALSE)
|
|
// PLAY_SOUND_FRONTEND(-1, "Hit_Out", "PLAYER_SWITCH_CUSTOM_SOUNDSET")
|
|
bHitFranklinSound = TRUE
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF NOT bDoneHitSound
|
|
IF GET_GAME_TIMER() >= iSwitchTime + 0
|
|
PLAY_SOUND_FRONTEND(-1, "Hit_Out", "PLAYER_SWITCH_CUSTOM_SOUNDSET")
|
|
iHitTime = GET_GAME_TIMER()
|
|
bDoneHitSound = TRUE
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF NOT bWooshStarted
|
|
IF bDoneHitSound
|
|
IF GET_GAME_TIMER() >= iHitTime + 250
|
|
PLAY_SOUND_FRONTEND(-1, "Short_Transition_In", "PLAYER_SWITCH_CUSTOM_SOUNDSET")
|
|
bWooshStarted = TRUE
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
|
|
|
|
IF DO_MISSION_HOTSWAP(SELECTOR_PED_FRANKLIN, FALSE, TRUE, HOTSWAP_CAM_HANGING_TO_SNIPER)
|
|
//SET_REMOTE_SNIPER_ACTIVE(remoteSniperData, TRUE)
|
|
//UPDATE_REMOTE_SNIPER(remoteSniperData)
|
|
|
|
//MAKE_SELECTOR_PED_SELECTION(sSelectorPeds, SELECTOR_PED_FRANKLIN)
|
|
//TAKE_CONTROL_OF_SELECTOR_PED(sSelectorPeds, TRUE, TRUE)
|
|
|
|
//SET_SELECTOR_PED_HINT(sSelectorPeds, SELECTOR_PED_MICHAEL, TRUE)
|
|
//SET_SELECTOR_PED_HINT(sSelectorPeds, SELECTOR_PED_FRANKLIN, FALSE)
|
|
//SET_SELECTOR_PED_HINT(sSelectorPeds, SELECTOR_PED_TREVOR, FALSE)
|
|
SET_SELECTOR_PED_BLOCKED(sSelectorPeds, SELECTOR_PED_FRANKLIN, FALSE)
|
|
SET_SELECTOR_PED_BLOCKED(sSelectorPeds, SELECTOR_PED_MICHAEL, FALSE)
|
|
SET_SELECTOR_PED_BLOCKED(sSelectorPeds, SELECTOR_PED_TREVOR, TRUE)
|
|
//IF NOT IS_PED_INJURED(PLAYER_PED_ID())
|
|
// SET_ENTITY_COORDS(PLAYER_PED_ID(), GET_SNATCH_AND_GRAB_VECTOR(SAGVEC_BEHIND_SNIPER))
|
|
// FREEZE_ENTITY_POSITION(PLAYER_PED_ID(), TRUE)
|
|
//ENDIF
|
|
IF NOT IS_PED_INJURED(prisonerPed)
|
|
SET_ENTITY_PROOFS(prisonerPed, FALSE, FALSE, FALSE, FALSE, FALSE)
|
|
ENDIF
|
|
|
|
|
|
//CLEAR_PED_TASKS_IMMEDIATELY(PLAYER_PED_ID())
|
|
FREEZE_FRANKLIN_AT_SNIPER()
|
|
SET_CURRENT_PED_WEAPON(PLAYER_PED_ID(), GET_SNATCH_AND_GRAB_WEAPON_TYPE(SAG_WEAPON_SNIPER_RIFLE), TRUE)
|
|
PRINTSTRING("setting rifle as current from SNIPE GUARDS SWITCH!") PRINTNL()
|
|
//DISPLAY_SNIPER_SCOPE_THIS_FRAME()
|
|
//DISPLAY_HUD(TRUE)
|
|
|
|
ATTACH_MICHAEL_TO_ROPE()
|
|
|
|
IF NOT IS_PED_INJURED(reinforcementPed[0])
|
|
CLEAR_ENTITY_LAST_DAMAGE_ENTITY(reinforcementPed[0])
|
|
ENDIF
|
|
IF NOT IS_PED_INJURED(reinforcementPed[5])
|
|
CLEAR_ENTITY_LAST_DAMAGE_ENTITY(reinforcementPed[5])
|
|
ENDIF
|
|
|
|
//SCRIPT_OVERRIDES_WIND_TYPES(true,"WEATHER_TYPES_MAGDEMO_FIB2_FRANKLIN","WEATHER_TYPES_MAGDEMO_FIB2_FRANKLIN")
|
|
IF NOT IS_PLAYER_CONTROL_ON(PLAYER_ID())
|
|
SET_PLAYER_CONTROL(PLAYER_ID(), TRUE)
|
|
ENDIF
|
|
|
|
// SET_PLAYER_FORCE_SKIP_AIM_INTRO(PLAYER_ID(),TRUE)
|
|
// SET_PLAYER_FORCED_AIM(PLAYER_ID(), TRUE)
|
|
|
|
HIDE_HUD_COMPONENT_THIS_FRAME(NEW_HUD_RETICLE)
|
|
|
|
iRecheckMichaelShootTime = 0
|
|
michaelTargetPed = NULL
|
|
hotswapStage = MISSION_HOTSWAP_STAGE_SELECT_CHARACTER
|
|
hangingHotswapState = HANGING_HOTSWAP_ON_FRANKLIN
|
|
ELSE
|
|
IF GET_CURRENT_PLAYER_PED_ENUM() = CHAR_FRANKLIN
|
|
SET_PLAYER_FORCE_SKIP_AIM_INTRO(PLAYER_ID(),TRUE)
|
|
SET_PLAYER_FORCED_AIM(PLAYER_ID(), TRUE)
|
|
//DISPLAY_SNIPER_SCOPE_THIS_FRAME()
|
|
ENDIF
|
|
ENDIF
|
|
BREAK
|
|
CASE HANGING_HOTSWAP_FRANKLIN_TO_MICHAEL
|
|
IF NOT bDoneFlash
|
|
ANIMPOSTFX_STOP_AND_FLUSH_REQUESTS("SwitchHUDMichaelOut")
|
|
ANIMPOSTFX_STOP_AND_FLUSH_REQUESTS("SwitchHUDFranklinOut")
|
|
ANIMPOSTFX_PLAY("SwitchShortFranklinIn", 0, FALSE)
|
|
bDoneFlash = TRUE
|
|
ENDIF
|
|
|
|
IF NOT bHitFranklinSound
|
|
IF GET_CURRENT_PLAYER_PED_ENUM() = CHAR_MICHAEL
|
|
IF IS_ENTITY_AT_COORD(PLAYER_PED_ID(), GET_FINAL_RENDERED_CAM_COORD(), <<170,170,170>>, FALSE, FALSE)
|
|
//PLAY_SOUND_FRONTEND(-1, "Hit_Out", "PLAYER_SWITCH_CUSTOM_SOUNDSET")
|
|
STOP_SOUND(iSniperSwitchSoundID)
|
|
ANIMPOSTFX_PLAY("SwitchShortMichaelMid", 0, FALSE)
|
|
// PLAY_SOUND_FRONTEND(-1, "Hit_Out", "PLAYER_SWITCH_CUSTOM_SOUNDSET")
|
|
bHitFranklinSound = TRUE
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF NOT bDoneHitSound
|
|
IF GET_GAME_TIMER() >= iSwitchTime + 0
|
|
PLAY_SOUND_FRONTEND(-1, "Hit_Out", "PLAYER_SWITCH_CUSTOM_SOUNDSET")
|
|
iHitTime = GET_GAME_TIMER()
|
|
bDoneHitSound = TRUE
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF NOT bWooshStarted
|
|
IF bDoneHitSound
|
|
IF GET_GAME_TIMER() >= iHitTime + 300
|
|
PLAY_SOUND_FRONTEND(-1, "Short_Transition_In", "PLAYER_SWITCH_CUSTOM_SOUNDSET")
|
|
bWooshStarted = TRUE
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF DO_MISSION_HOTSWAP(SELECTOR_PED_MICHAEL, FALSE, TRUE, HOTSWAP_CAM_SNIPER_TO_HANGING, TCF_CLEAR_TASK_INTERRUPT_CHECKS)
|
|
IF NOT IS_PED_INJURED(PLAYER_PED_ID())
|
|
SET_PED_RELATIONSHIP_GROUP_HASH(PLAYER_PED_ID(), RELGROUPHASH_PLAYER)
|
|
ENDIF
|
|
IF NOT IS_PED_INJURED(prisonerPed)
|
|
SET_ENTITY_PROOFS(prisonerPed, TRUE, TRUE, TRUE, TRUE, TRUE)
|
|
ENDIF
|
|
|
|
//SET_SELECTOR_PED_HINT(sSelectorPeds, SELECTOR_PED_FRANKLIN, TRUE)
|
|
//SET_SELECTOR_PED_HINT(sSelectorPeds, SELECTOR_PED_MICHAEL, FALSE)
|
|
//SET_SELECTOR_PED_HINT(sSelectorPeds, SELECTOR_PED_TREVOR, FALSE)
|
|
SET_SELECTOR_PED_BLOCKED(sSelectorPeds, SELECTOR_PED_FRANKLIN, FALSE)
|
|
SET_SELECTOR_PED_BLOCKED(sSelectorPeds, SELECTOR_PED_MICHAEL, FALSE)
|
|
SET_SELECTOR_PED_BLOCKED(sSelectorPeds, SELECTOR_PED_TREVOR, TRUE)
|
|
//CLEAR_PED_TASKS_IMMEDIATELY(PLAYER_PED_ID())
|
|
//SET_REMOTE_SNIPER_ACTIVE(remoteSniperData, FALSE)
|
|
FREEZE_FRANKLIN_AT_SNIPER()
|
|
ATTACH_MICHAEL_TO_ROPE()
|
|
iNextFranklinSnipeTime = GET_RANDOM_INT_IN_RANGE(2000, 3000)
|
|
iRecheckFranklinShootTime = 0
|
|
iFranklinTargetPed = -1
|
|
//SCRIPT_OVERRIDES_WIND_TYPES(true,"WEATHER_TYPES_MAGDEMO_FIB2_OUTSIDE_WINDOW","WEATHER_TYPES_MAGDEMO_FIB2_OUTSIDE_WINDOW")
|
|
hotswapStage = MISSION_HOTSWAP_STAGE_SELECT_CHARACTER
|
|
hangingHotswapState = HANGING_HOTSWAP_ON_MICHAEL
|
|
ELSE
|
|
IF NOT bReattachedMichael
|
|
IF GET_CURRENT_PLAYER_PED_ENUM() = CHAR_MICHAEL
|
|
ATTACH_MICHAEL_TO_ROPE()
|
|
bReattachedMichael = TRUE
|
|
ENDIF
|
|
ENDIF
|
|
// UPDATE_REMOTE_SNIPER(remoteSniperData)
|
|
//IF remoteSniperData.b_is_sniping
|
|
// IF sCamDetails.bSplineCreated
|
|
// SET_REMOTE_SNIPER_ACTIVE(remoteSniperData, FALSE, FALSE)
|
|
// ENDIF
|
|
//ENDIF
|
|
ENDIF
|
|
|
|
|
|
BREAK
|
|
ENDSWITCH
|
|
ELSE
|
|
// UPDATE_REMOTE_SNIPER(remoteSniperData)
|
|
ENDIF
|
|
ENDIF
|
|
|
|
// handle the grab
|
|
SWITCH prisonerGrabState
|
|
CASE PRISONER_GRAB_STATE_INIT
|
|
IF bAdvancedGuardAttackTime
|
|
UPDATE_PRISONER_GRAB(PRISONER_GRAB_STATE_DUCK_INTRO)
|
|
ENDIF
|
|
BREAK
|
|
CASE PRISONER_GRAB_STATE_DUCK_INTRO
|
|
IF IS_SYNCHRONIZED_SCENE_RUNNING(iSyncScene)
|
|
IF GET_SYNCHRONIZED_SCENE_PHASE(iSyncScene) >= 0.98
|
|
UPDATE_PRISONER_GRAB(PRISONER_GRAB_STATE_DUCK_LOOPING)
|
|
ENDIF
|
|
ENDIF
|
|
BREAK
|
|
CASE PRISONER_GRAB_STATE_DUCK_LOOPING
|
|
IF bStartExtraction
|
|
UPDATE_PRISONER_GRAB(PRISONER_GRAB_STATE_EXTRACT)
|
|
ENDIF
|
|
BREAK
|
|
|
|
CASE PRISONER_GRAB_STATE_EXTRACT
|
|
|
|
BREAK
|
|
|
|
CASE PRISONER_GRAB_STATE_DANGLING
|
|
IF GET_GAME_TIMER() >= iDangleTime + 100
|
|
AND (bDebugCanWinch OR NOT bDebugSwingOutEarlier)
|
|
//SET_ROPE_PHYSICAL()
|
|
KILL_ANY_CONVERSATION()
|
|
//START_ROPE_WINDING(rappelData.rope)
|
|
prisonerGrabState = PRISONER_GRAB_STATE_WINCHING
|
|
iWinchTime = GET_GAME_TIMER() + 800
|
|
ENDIF
|
|
BREAK
|
|
ENDSWITCH
|
|
|
|
// handle extraction
|
|
SWITCH extractStage
|
|
// killing the guards in the original interrogation
|
|
CASE EXTRACT_STAGE_KILL_INITIAL_GUARDS
|
|
INT iThisSpeechLine
|
|
TEXT_LABEL tThisSpeechLabel
|
|
|
|
IF NOT bAdvancedGuardAttackTime
|
|
// advance guard attack time when shooting
|
|
IF iGuardReactionStage > -1
|
|
iGuardAttackTime = GET_GAME_TIMER() + GUARD_ATTACK_TIME_SHOOTING
|
|
iGuardSpeech = 0
|
|
iReactToFirstShotTime = GET_GAME_TIMER()
|
|
bAdvancedGuardAttackTime = TRUE
|
|
ELSE
|
|
IF bReactedToFirstShot
|
|
iGuardReactionStage = 0
|
|
ELSE
|
|
IF iGuardSpeech < 8
|
|
AND NOT bLoadedExtractSpeech
|
|
SWITCH iGuardSpeech
|
|
CASE 0
|
|
tThisSpeechLabel = "FBI2_CIA1"
|
|
iThisSpeechLine = 0
|
|
BREAK
|
|
CASE 1
|
|
tThisSpeechLabel = "FBI2_MRKSHT"
|
|
iThisSpeechLine = 0
|
|
BREAK
|
|
CASE 2
|
|
tThisSpeechLabel = "FBI2_CLEAR"
|
|
iThisSpeechLine = 0
|
|
BREAK
|
|
CASE 3
|
|
tThisSpeechLabel = "FBI2_MRKSHT"
|
|
iThisSpeechLine = 0
|
|
BREAK
|
|
CASE 4
|
|
tThisSpeechLabel = "FBI2_ASK"
|
|
iThisSpeechLine = 0
|
|
BREAK
|
|
CASE 5
|
|
tThisSpeechLabel = "FBI2_CIA2"
|
|
iThisSpeechLine = 0
|
|
BREAK
|
|
CASE 6
|
|
tThisSpeechLabel = "FBI2_MRKSHT"
|
|
iThisSpeechLine = 0
|
|
BREAK
|
|
CASE 7
|
|
tThisSpeechLabel = "FBI2_GLIGHT"
|
|
iThisSpeechLine = 0
|
|
BREAK
|
|
ENDSWITCH
|
|
|
|
IF bShownGodText
|
|
AND GET_GAME_TIMER() >= iShownGodTextTime + 2000
|
|
IF DO_MISSION_SPEECH(tThisSpeechLabel, TRUE, iThisSpeechLine, FALSE, NOT IS_MESSAGE_BEING_DISPLAYED())
|
|
iGuardSpeech++
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ELSE
|
|
// random dialogue from guards
|
|
IF iPostKilledGuardsTime = 0
|
|
IF iGuardSpeech < 16
|
|
iThisSpeechLine = 0
|
|
PED_INDEX speechPed
|
|
|
|
SWITCH iGuardSpeech
|
|
CASE 0
|
|
tThisSpeechLabel = "FBI2_SNIP"
|
|
speechPed = guardPed[0]
|
|
BREAK
|
|
CASE 1
|
|
tThisSpeechLabel = "FBI2_CHAO2"
|
|
speechPed = guardPed[1]
|
|
BREAK
|
|
CASE 2
|
|
tThisSpeechLabel = "FBI2_IAA"
|
|
speechPed = GET_MICHAEL_PED()
|
|
BREAK
|
|
CASE 3
|
|
tThisSpeechLabel = "FBI2_MRKSHT"
|
|
speechPed = prisonerPed
|
|
BREAK
|
|
CASE 4
|
|
tThisSpeechLabel = "FBI2_SHMIC"
|
|
speechPed = guardPed[2]
|
|
BREAK
|
|
CASE 5
|
|
tThisSpeechLabel = "FBI2_CHAOS"
|
|
speechPed = guardPed[0]
|
|
BREAK
|
|
CASE 6
|
|
tThisSpeechLabel = "FBI2_IAA"
|
|
speechPed = GET_MICHAEL_PED()
|
|
BREAK
|
|
CASE 7
|
|
tThisSpeechLabel = "FBI2_SNIP2"
|
|
speechPed = guardPed[1]
|
|
BREAK
|
|
CASE 8
|
|
tThisSpeechLabel = "FBI2_MRKSHT"
|
|
speechPed = prisonerPed
|
|
BREAK
|
|
CASE 9
|
|
tThisSpeechLabel = "FBI2_ESCA"
|
|
speechPed = guardPed[2]
|
|
BREAK
|
|
CASE 10
|
|
tThisSpeechLabel = "FBI2_SNIP4"
|
|
speechPed = guardPed[3]
|
|
BREAK
|
|
CASE 11
|
|
tThisSpeechLabel = "FBI2_IAA"
|
|
speechPed = GET_MICHAEL_PED()
|
|
BREAK
|
|
CASE 12
|
|
tThisSpeechLabel = "FBI2_CHAO3"
|
|
speechPed = guardPed[4]
|
|
BREAK
|
|
CASE 13
|
|
tThisSpeechLabel = "FBI2_MRKSHT"
|
|
speechPed = prisonerPed
|
|
BREAK
|
|
CASE 14
|
|
tThisSpeechLabel = "FBI2_CHAO4"
|
|
speechPed = guardPed[3]
|
|
BREAK
|
|
CASE 15
|
|
tThisSpeechLabel = "FBI2_SNIP3"
|
|
speechPed = guardPed[4]
|
|
BREAK
|
|
ENDSWITCH
|
|
|
|
IF bShownGodText
|
|
AND iReinforcementsEnterTime < 0
|
|
AND GET_GAME_TIMER() >= iShownGodTextTime + 2000
|
|
IF NOT IS_PED_INJURED(speechPed)
|
|
IF DO_MISSION_SPEECH(tThisSpeechLabel, TRUE, iThisSpeechLine, FALSE, NOT IS_MESSAGE_BEING_DISPLAYED())
|
|
iGuardSpeech++
|
|
ENDIF
|
|
ELSE
|
|
iGuardSpeech++
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
|
|
// guards shoot and kill prisoner
|
|
IF NOT bGuardsAttackPrisoner
|
|
IF GET_GAME_TIMER() >= iGuardAttackTime
|
|
IF iGuardAttackTime >= 0
|
|
IF NOT IS_MESSAGE_BEING_DISPLAYED()
|
|
// have the guards attack Michael and the prisoner
|
|
REPEAT NUMBER_GUARDS i
|
|
IF NOT IS_PED_INJURED(guardPed[i])
|
|
IF NOT IS_PED_INJURED(prisonerPed)
|
|
TASK_SHOOT_AT_ENTITY(guardPed[i], prisonerPed, -1, FIRING_TYPE_CONTINUOUS)
|
|
ENDIF
|
|
ENDIF
|
|
ENDREPEAT
|
|
SET_ENTITY_ONLY_DAMAGED_BY_PLAYER(prisonerPed, FALSE)
|
|
iGuardAttackTime = -1 // set to -1 so only do once
|
|
bGuardsAttackPrisoner = TRUE
|
|
ENDIF
|
|
ELSE
|
|
IF iGuardSpeech > 7
|
|
iGuardAttackTime = GET_GAME_TIMER() + 2000
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ELSE
|
|
IF NOT bGuardsStoppedShooting
|
|
IF IS_PED_INJURED(prisonerPed)
|
|
REPEAT NUMBER_GUARDS i
|
|
IF NOT IS_PED_INJURED(guardPed[i])
|
|
TASK_AIM_GUN_AT_COORD(guardPed[i], vCachedPrisonerPos, -1)
|
|
ENDIF
|
|
ENDREPEAT
|
|
bGuardsStoppedShooting = TRUE
|
|
ELSE
|
|
vCachedPrisonerPos = GET_ENTITY_COORDS(prisonerPed)
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
|
|
// kill the prisoner if damaged by a guard
|
|
BOOL bDoFakeKillMichael
|
|
bDoFakeKillMichael = FALSE
|
|
IF NOT IS_PED_INJURED(prisonerPed)
|
|
IF HAS_ENTITY_BEEN_DAMAGED_BY_WEAPON(prisonerPed, GET_SNATCH_AND_GRAB_WEAPON_TYPE(SAG_WEAPON_CIA_PISTOL))
|
|
APPLY_DAMAGE_TO_PED(prisonerPed, 1000, FALSE)
|
|
bDoFakeKillMichael = TRUE
|
|
ENDIF
|
|
ELSE
|
|
bDoFakeKillMichael = TRUE
|
|
ENDIF
|
|
|
|
IF bDoFakeKillMichael
|
|
IF NOT IS_PED_INJURED(sSelectorPeds.pedID[SELECTOR_PED_MICHAEL])
|
|
IF NOT IS_PED_RAGDOLL(sSelectorPeds.pedID[SELECTOR_PED_MICHAEL])
|
|
CLEAR_PED_TASKS(sSelectorPeds.pedID[SELECTOR_PED_MICHAEL])
|
|
SET_PED_TO_RAGDOLL(sSelectorPeds.pedID[SELECTOR_PED_MICHAEL], 25000, 25000, TASK_RELAX)
|
|
MISSION_FAILED(FAIL_MICHAEL_DEAD)
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
|
|
// do remote sniper checks and death count
|
|
INT iKilledGuards
|
|
iKilledGuards = 0
|
|
REPEAT NUMBER_GUARDS i
|
|
IF NOT IS_PED_INJURED(guardPed[i])
|
|
IF HAS_ENTITY_BEEN_DAMAGED_BY_WEAPON(guardPed[i], GET_SNATCH_AND_GRAB_WEAPON_TYPE(SAG_WEAPON_SNIPER_RIFLE))
|
|
APPLY_DAMAGE_TO_PED(guardPed[i], 1000, FALSE)
|
|
ENDIF
|
|
|
|
// remote sniper
|
|
//CHECK_PED_WITH_REMOTE_SNIPER(remoteSniperData, guardPed[i])
|
|
ELSE
|
|
// increment death count
|
|
IF DOES_BLIP_EXIST(guardBlip[i])
|
|
REMOVE_BLIP(guardBlip[i])
|
|
INFORM_MISSION_STATS_OF_INCREMENT(FBI2_KILLS)
|
|
ENDIF
|
|
|
|
iKilledGuards++
|
|
ENDIF
|
|
ENDREPEAT
|
|
|
|
// music for killing 3 guards
|
|
IF NOT bDoneKill3GuardsCue
|
|
bDoneKill3GuardsCue = TRIGGER_MISSION_MUSIC_EVENT("FIB2_SNIPER_SHOT_THREE")
|
|
ENDIF
|
|
|
|
// more guards enter
|
|
IF NOT bGuardsHeardSniper
|
|
IF iKilledGuards >= 1
|
|
SET_GUARDS_HEAR_SNIPER()
|
|
bGuardsHeardSniper = TRUE
|
|
ENDIF
|
|
ELSE
|
|
IF NOT bAdditionalGuardsToShoot
|
|
BOOL bDoAdditionalGuardsToShoot
|
|
bDoAdditionalGuardsToShoot = FALSE
|
|
IF IS_SYNCHRONIZED_SCENE_RUNNING(iGuardSyncScene[GSS_STANDARD])
|
|
IF GET_SYNCHRONIZED_SCENE_PHASE(iGuardSyncScene[GSS_STANDARD]) >= 0.98
|
|
bDoAdditionalGuardsToShoot = TRUE
|
|
ENDIF
|
|
ELSE
|
|
bDoAdditionalGuardsToShoot = TRUE
|
|
ENDIF
|
|
|
|
IF bDoAdditionalGuardsToShoot
|
|
REPEAT 2 i
|
|
INT iAdditionalGuard
|
|
iAdditionalGuard = i+3
|
|
guardAI[iAdditionalGuard].iRevertActionTime = 0
|
|
INIT_GUARD_ANIMATION_TIME(iAdditionalGuard)
|
|
ENDREPEAT
|
|
|
|
bAdditionalGuardsToShoot = TRUE
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF NOT bDoneLastGuardEnter
|
|
IF iKilledGuards >= 5
|
|
SET_LAST_GUARD_ENTER()
|
|
bDoneLastGuardEnter = TRUE
|
|
ENDIF
|
|
ELSE
|
|
IF NOT bLastGuardToShoot
|
|
BOOL bDoLastGuardToShoot
|
|
bDoLastGuardToShoot = FALSE
|
|
IF IS_SYNCHRONIZED_SCENE_RUNNING(iGuardSyncScene[GSS_LAST_GUARD])
|
|
IF GET_SYNCHRONIZED_SCENE_PHASE(iGuardSyncScene[GSS_LAST_GUARD]) >= 0.98
|
|
bDoLastGuardToShoot = TRUE
|
|
ENDIF
|
|
ELSE
|
|
bDoLastGuardToShoot = TRUE
|
|
ENDIF
|
|
|
|
IF bDoLastGuardToShoot
|
|
guardAI[5].iRevertActionTime = 0
|
|
INIT_GUARD_ANIMATION_TIME(5)
|
|
bLastGuardToShoot = TRUE
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
|
|
HANDLE_GUARD_ANIMATIONS(iKilledGuards)
|
|
|
|
DO_GUARD_REACTIONS(iKilledGuards)
|
|
|
|
// advance to extract when guards dead
|
|
IF iKilledGuards >= NUMBER_GUARDS
|
|
IF iReinforcementsEnterTime < 0
|
|
iReinforcementsEnterTime = GET_GAME_TIMER()
|
|
ELSE
|
|
IF NOT bLoadedExtractSpeech
|
|
IF PRELOAD_CONVERSATION(snatchAndGrabConversation, "FBI2AUD", "FBI2_PULL", CONV_PRIORITY_MEDIUM)
|
|
bLoadedExtractSpeech = TRUE
|
|
iLoadedExtractSpeechTime = GET_GAME_TIMER()
|
|
ENDIF
|
|
ELSE
|
|
//iLoadedExtractSpeechTime=iLoadedExtractSpeechTime
|
|
IF NOT bDoneExtractSpeech
|
|
IF GET_GAME_TIMER() >= iLoadedExtractSpeechTime + 200
|
|
IF GET_IS_PRELOADED_CONVERSATION_READY()
|
|
BEGIN_PRELOADED_CONVERSATION()
|
|
bDoneExtractSpeech = TRUE
|
|
ELIF GET_GAME_TIMER() >= iLoadedExtractSpeechTime + 3000
|
|
KILL_ANY_CONVERSATION()
|
|
bDoneExtractSpeech = TRUE
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF bDoneExtractSpeech
|
|
IF NOT bStartExtraction
|
|
IF GET_GAME_TIMER() >= iReinforcementsEnterTime + 300
|
|
bStartExtraction = TRUE
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF GET_GAME_TIMER() >= iReinforcementsEnterTime + 2500
|
|
// setup selector HUD
|
|
//SET_SELECTOR_PED_HINT(sSelectorPeds, SELECTOR_PED_TREVOR, FALSE)
|
|
//SET_SELECTOR_PED_HINT(sSelectorPeds, SELECTOR_PED_FRANKLIN, FALSE)
|
|
//SET_SELECTOR_PED_HINT(sSelectorPeds, SELECTOR_PED_MICHAEL, TRUE)
|
|
SET_SELECTOR_PED_BLOCKED(sSelectorPeds, SELECTOR_PED_TREVOR, TRUE)
|
|
SET_SELECTOR_PED_BLOCKED(sSelectorPeds, SELECTOR_PED_FRANKLIN, FALSE)
|
|
SET_SELECTOR_PED_BLOCKED(sSelectorPeds, SELECTOR_PED_MICHAEL, FALSE)
|
|
|
|
REMOVE_MISSION_TEXT(FALSE, TRUE, FALSE)
|
|
|
|
iGuardSpeech = 0
|
|
|
|
CREATE_REINFORCEMENTS(1)
|
|
|
|
// advance stage
|
|
extractStage = EXTRACT_STAGE_REINFORCEMENTS_ENTER
|
|
ENDIF
|
|
ELSE
|
|
iReinforcementsEnterTime = GET_GAME_TIMER()
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
BREAK
|
|
|
|
CASE EXTRACT_STAGE_REINFORCEMENTS_ENTER
|
|
// additional enemy reinforcements
|
|
INT iAlive
|
|
iAlive = HANDLE_ENEMY_FOOT_PEDS()
|
|
|
|
IF NOT bCreatedAdditionalReinforcement[1]
|
|
IF iAlive < 3
|
|
CREATE_REINFORCEMENTS(2)
|
|
bCreatedAdditionalReinforcement[1] = TRUE
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF NOT bCreatedAdditionalReinforcement[2]
|
|
IF bCreatedAdditionalReinforcement[0]
|
|
IF hangingHotswapState = HANGING_HOTSWAP_ON_MICHAEL
|
|
BOOL bCreateLastGuy
|
|
bCreateLastGuy = FALSE
|
|
IF NOT IS_PED_INJURED(reinforcementPed[5])
|
|
IF (IS_PLAYER_TARGETTING_ENTITY(PLAYER_ID(), reinforcementPed[5])
|
|
OR IS_PLAYER_FREE_AIMING_AT_ENTITY(PLAYER_ID(), reinforcementPed[5]))
|
|
AND iAlive = 1
|
|
bCreateLastGuy = TRUE
|
|
ENDIF
|
|
ELSE
|
|
bCreateLastGuy = TRUE
|
|
ENDIF
|
|
IF bCreateLastGuy
|
|
printstring("create the last guy!") printnl()
|
|
CREATE_REINFORCEMENTS(4)
|
|
bCreatedAdditionalReinforcement[2] = TRUE
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ELSE
|
|
IF NOT bCreatedAdditionalReinforcement[3]
|
|
//IF hangingHotswapState = HANGING_HOTSWAP_ON_MICHAEL
|
|
BOOL bCreateTotallyLastGuy
|
|
bCreateTotallyLastGuy = FALSE
|
|
IF NOT IS_PED_INJURED(reinforcementPed[6])
|
|
IF (IS_PLAYER_TARGETTING_ENTITY(PLAYER_ID(), reinforcementPed[6])
|
|
OR IS_PLAYER_FREE_AIMING_AT_ENTITY(PLAYER_ID(), reinforcementPed[6])
|
|
OR hangingHotswapState = HANGING_HOTSWAP_ON_FRANKLIN)
|
|
AND iAlive = 1
|
|
bCreateTotallyLastGuy = TRUE
|
|
ENDIF
|
|
ELSE
|
|
bCreateTotallyLastGuy = TRUE
|
|
ENDIF
|
|
IF bCreateTotallyLastGuy
|
|
printstring("create the TOTALLY last guy!") printnl()
|
|
CREATE_REINFORCEMENTS(5)
|
|
bCreatedAdditionalReinforcement[3] = TRUE
|
|
ENDIF
|
|
//ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF NOT bCreatedAdditionalReinforcement[0]
|
|
IF iAlive < 2
|
|
CREATE_REINFORCEMENTS(3)
|
|
bCreatedAdditionalReinforcement[0] = TRUE
|
|
iCreatedLastReinforcementTime = GET_GAME_TIMER()
|
|
ENDIF
|
|
ELSE
|
|
BOOL bLastReinforcementDangerous
|
|
bLastReinforcementDangerous = FALSE
|
|
|
|
IF NOT IS_PED_INJURED(reinforcementPed[5])
|
|
AND iAlive = 1
|
|
IF NOT IS_PED_INJURED(reinforcementPed[6])
|
|
bLastReinforcementIsLast = TRUE
|
|
ENDIF
|
|
IF hangingHotswapState = HANGING_HOTSWAP_ON_FRANKLIN
|
|
// do can't get shot speech
|
|
IF GET_GAME_TIMER() >= iCreatedLastReinforcementTime + 4000
|
|
IF NOT bDoneCantGetShotSpeech
|
|
IF DO_MISSION_SPEECH("FBI2_SHOT")
|
|
IF iGuardSpeech >= 6 AND iGuardSpeech <= 9
|
|
iGuardSpeech = 10
|
|
ENDIF
|
|
bDoneCantGetShotSpeech = TRUE
|
|
iCantGetShotSpeechTime = GET_GAME_TIMER()
|
|
ENDIF
|
|
ELSE
|
|
bLastReinforcementDangerous = TRUE
|
|
IF NOT bDoneTroubleFlashHelp
|
|
IF GET_GAME_TIMER() >= iCantGetShotSpeechTime + 2000
|
|
bDoneTroubleFlashHelp = DO_MISSION_HELP_TEXT("SG_TROHLP2", FALSE, 12500)
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF NOT IS_PED_INJURED(reinforcementPed[6])
|
|
bLastReinforcementDangerous = TRUE
|
|
ENDIF
|
|
|
|
IF bLastReinforcementDangerous
|
|
SET_SELECTOR_PED_DAMAGED(sSelectorPeds, SELECTOR_PED_MICHAEL, TRUE)
|
|
SET_SELECTOR_PED_HINT(sSelectorPeds, SELECTOR_PED_MICHAEL, FALSE)
|
|
|
|
BOOL bShooting
|
|
bShooting = FALSE
|
|
IF NOT IS_PED_INJURED(reinforcementPed[5])
|
|
IF IS_PED_SHOOTING(reinforcementPed[5])
|
|
bShooting = TRUE
|
|
ENDIF
|
|
ENDIF
|
|
IF NOT IS_PED_INJURED(reinforcementPed[6])
|
|
IF IS_PED_SHOOTING(reinforcementPed[6])
|
|
bShooting = TRUE
|
|
ENDIF
|
|
ENDIF
|
|
IF NOT IS_PED_INJURED(reinforcementPed[7])
|
|
IF IS_PED_SHOOTING(reinforcementPed[7])
|
|
bShooting = TRUE
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF bShooting
|
|
IF GET_GAME_TIMER() >= iLastFakeDamagedMichaelTime + 1000
|
|
IF NOT IS_PED_INJURED(sSelectorPeds.pedID[SELECTOR_PED_MICHAEL])
|
|
APPLY_DAMAGE_TO_PED(sSelectorPeds.pedID[SELECTOR_PED_MICHAEL], 15, TRUE)
|
|
iLastFakeDamagedMichaelTime = GET_GAME_TIMER()
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ELSE
|
|
SET_SELECTOR_PED_DAMAGED(sSelectorPeds, SELECTOR_PED_MICHAEL, FALSE)
|
|
//SET_SELECTOR_PED_HINT(sSelectorPeds, SELECTOR_PED_MICHAEL, TRUE)
|
|
IF IS_THIS_HELP_MESSAGE_BEING_DISPLAYED("SG_TROHLP2")
|
|
IF GET_GAME_TIMER() >= iClearHelpTime + 1000
|
|
CLEAR_HELP(FALSE)
|
|
iClearHelpTime = GET_GAME_TIMER()
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
|
|
// set reinforcements to shoot
|
|
REPEAT NUMBER_REINFORCEMENTS i
|
|
IF NOT IS_PED_INJURED(reinforcementPed[i])
|
|
IF NOT bReinforcementToShoot[i]
|
|
PED_INDEX targetPed
|
|
targetPed = GET_MICHAEL_PED()
|
|
FLOAT fBreakOutPhase
|
|
SWITCH i
|
|
CASE 0
|
|
fBreakOutPhase = 0.43
|
|
BREAK
|
|
DEFAULT
|
|
fBreakOutPhase = 0.98
|
|
BREAK
|
|
ENDSWITCH
|
|
|
|
IF NOT IS_PED_INJURED(targetPed)
|
|
IF GET_SYNCHRONIZED_SCENE_PHASE(iGuardSyncScene[GET_SYNCED_SCENE_FOR_REINFORCEMENT(i)]) >= fBreakOutPhase
|
|
CLEAR_SEQUENCE_TASK(sequence)
|
|
OPEN_SEQUENCE_TASK(sequence)
|
|
TASK_CLEAR_LOOK_AT(NULL)
|
|
TASK_AIM_GUN_AT_ENTITY(NULL, targetPed, GET_RANDOM_INT_IN_RANGE(100, 4000), TRUE)
|
|
TASK_SHOOT_AT_ENTITY(NULL, targetPed, -1, FIRING_TYPE_RANDOM_BURSTS)
|
|
CLOSE_SEQUENCE_TASK(sequence)
|
|
TASK_PERFORM_SEQUENCE(reinforcementPed[i], sequence)
|
|
bReinforcementToShoot[i] = TRUE
|
|
ELSE
|
|
SET_PED_RESET_FLAG(reinforcementPed[i], PRF_BlockWeaponReactionsUnlessDead, TRUE)
|
|
|
|
FLOAT fFirePhase
|
|
fFirePhase = 1.1
|
|
SWITCH i
|
|
CASE 1
|
|
SWITCH iReinforcementShootWhileMovingStage[i]
|
|
CASE 0
|
|
fFirePhase = 0.605
|
|
BREAK
|
|
CASE 1
|
|
fFirePhase = 0.693
|
|
BREAK
|
|
CASE 2
|
|
fFirePhase = 0.820
|
|
BREAK
|
|
ENDSWITCH
|
|
BREAK
|
|
CASE 2
|
|
SWITCH iReinforcementShootWhileMovingStage[i]
|
|
CASE 0
|
|
fFirePhase = 0.260
|
|
BREAK
|
|
CASE 1
|
|
fFirePhase = 0.287
|
|
BREAK
|
|
CASE 2
|
|
fFirePhase = 0.392
|
|
BREAK
|
|
CASE 3
|
|
fFirePhase = 0.420
|
|
BREAK
|
|
CASE 4
|
|
fFirePhase = 0.460
|
|
BREAK
|
|
CASE 5
|
|
fFirePhase = 0.650
|
|
BREAK
|
|
CASE 6
|
|
fFirePhase = 0.705
|
|
BREAK
|
|
CASE 7
|
|
fFirePhase = 0.852
|
|
BREAK
|
|
CASE 8
|
|
fFirePhase = 0.910
|
|
BREAK
|
|
ENDSWITCH
|
|
BREAK
|
|
CASE 3
|
|
SWITCH iReinforcementShootWhileMovingStage[i]
|
|
CASE 0
|
|
fFirePhase = 0.775
|
|
BREAK
|
|
CASE 1
|
|
fFirePhase = 0.950
|
|
BREAK
|
|
ENDSWITCH
|
|
BREAK
|
|
ENDSWITCH
|
|
|
|
IF GET_SYNCHRONIZED_SCENE_PHASE(iGuardSyncScene[GET_SYNCED_SCENE_FOR_REINFORCEMENT(i)]) >= fFirePhase
|
|
SET_PED_SHOOTS_AT_COORD(reinforcementPed[i], <<0,0,0>>)
|
|
iReinforcementShootWhileMovingStage[i]++
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
VECTOR vReinforcementPos
|
|
vReinforcementPos = GET_ENTITY_COORDS(reinforcementPed[i])
|
|
IF HAS_ENTITY_BEEN_DAMAGED_BY_WEAPON(reinforcementPed[i], GET_SNATCH_AND_GRAB_WEAPON_TYPE(SAG_WEAPON_SNIPER_RIFLE))
|
|
OR (HAS_ENTITY_BEEN_DAMAGED_BY_WEAPON(reinforcementPed[i], GET_SNATCH_AND_GRAB_WEAPON_TYPE(SAG_WEAPON_MICHAEL_PISTOL)) AND GET_SCRIPT_TASK_STATUS(reinforcementPed[i], SCRIPT_TASK_SYNCHRONIZED_SCENE) = PERFORMING_TASK)
|
|
OR (IS_PED_RAGDOLL(reinforcementPed[i]) AND (vReinforcementPos.y >= -619.2 OR vReinforcementPos.y <= -624.1 OR vReinforcementPos.x >= 124.3))
|
|
APPLY_DAMAGE_TO_PED(reinforcementPed[i], 1000, FALSE)
|
|
ENDIF
|
|
ENDIF
|
|
ENDREPEAT
|
|
|
|
// do reinforcement speech
|
|
IF prisonerGrabState >= PRISONER_GRAB_STATE_EXTRACT
|
|
IF iAlive > 0
|
|
IF iGuardSpeech < 21
|
|
AND (iGuardSpeech >=1 OR bDoneExtractSpeech)
|
|
iThisSpeechLine = 0
|
|
PED_INDEX speechPed
|
|
|
|
SWITCH iGuardSpeech
|
|
CASE 0
|
|
tThisSpeechLabel = "FBI2_ESCA2"
|
|
speechPed = reinforcementPed[1]
|
|
BREAK
|
|
CASE 1
|
|
tThisSpeechLabel = "FBI2_MIDAIR"
|
|
speechPed = prisonerPed
|
|
BREAK
|
|
CASE 2
|
|
tThisSpeechLabel = "FBI2_SNIP5"
|
|
speechPed = reinforcementPed[0]
|
|
BREAK
|
|
CASE 3
|
|
tThisSpeechLabel = "FBI2_MSHOOT1"
|
|
speechPed = reinforcementPed[0]
|
|
BREAK
|
|
CASE 4
|
|
tThisSpeechLabel = "FBI2_STK2"
|
|
speechPed = prisonerPed
|
|
BREAK
|
|
CASE 5
|
|
tThisSpeechLabel = "FBI2_NOMOV"
|
|
speechPed = GET_MICHAEL_PED()
|
|
BREAK
|
|
CASE 6
|
|
IF GET_RANDOM_INT_IN_RANGE(0,2) = 0
|
|
tThisSpeechLabel = "FBI2_YMOVE"
|
|
ELSE
|
|
tThisSpeechLabel = "FBI2_YMOVE2"
|
|
ENDIF
|
|
speechPed = GET_TREVOR_PED()
|
|
BREAK
|
|
CASE 7
|
|
tThisSpeechLabel = "FBI2_SHM2"
|
|
speechPed = reinforcementPed[1]
|
|
BREAK
|
|
CASE 8
|
|
tThisSpeechLabel = "FBI2_AHOL"
|
|
speechPed = GET_MICHAEL_PED()
|
|
BREAK
|
|
CASE 9
|
|
tThisSpeechLabel = "FBI2_HEHE"
|
|
speechPed = GET_TREVOR_PED()
|
|
BREAK
|
|
CASE 10
|
|
tThisSpeechLabel = "FBI2_CHAO5"
|
|
speechPed = reinforcementPed[0]
|
|
BREAK
|
|
CASE 11
|
|
tThisSpeechLabel = "FBI2_MIDAIR"
|
|
speechPed = prisonerPed
|
|
BREAK
|
|
CASE 12
|
|
tThisSpeechLabel = "FBI2_STK3"
|
|
speechPed = reinforcementPed[3]
|
|
BREAK
|
|
CASE 13
|
|
tThisSpeechLabel = "FBI2_MOAN"
|
|
speechPed = GET_MICHAEL_PED()
|
|
BREAK
|
|
CASE 14
|
|
tThisSpeechLabel = "FBI2_TALK"
|
|
speechPed = GET_TREVOR_PED()
|
|
BREAK
|
|
CASE 15
|
|
tThisSpeechLabel = "FBI2_MSHOOT2"
|
|
speechPed = prisonerPed
|
|
BREAK
|
|
CASE 16
|
|
tThisSpeechLabel = "FBI2_SHM3"
|
|
speechPed = reinforcementPed[3]
|
|
BREAK
|
|
CASE 17
|
|
tThisSpeechLabel = "FBI2_MIDAIR"
|
|
speechPed = prisonerPed
|
|
BREAK
|
|
CASE 18
|
|
tThisSpeechLabel = "FBI2_GETOUT"
|
|
speechPed = GET_MICHAEL_PED()
|
|
BREAK
|
|
CASE 19
|
|
tThisSpeechLabel = "FBI2_MSHOOT3"
|
|
speechPed = prisonerPed
|
|
BREAK
|
|
CASE 20
|
|
tThisSpeechLabel = "FBI2_FRANS"
|
|
speechPed = GET_FRANKLIN_PED()
|
|
BREAK
|
|
ENDSWITCH
|
|
|
|
IF NOT IS_PED_INJURED(speechPed)
|
|
IF DO_MISSION_SPEECH(tThisSpeechLabel, TRUE, iThisSpeechLine)
|
|
iGuardSpeech++
|
|
ENDIF
|
|
ELSE
|
|
iGuardSpeech++
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
|
|
INT iReinforcementsAlive
|
|
iReinforcementsAlive = 0
|
|
|
|
REPEAT COUNT_OF(reinforcementPed) i
|
|
IF NOT IS_PED_INJURED(reinforcementPed[i])
|
|
iReinforcementsAlive++
|
|
ENDIF
|
|
ENDREPEAT
|
|
|
|
IF NOT bCreatedAdditionalReinforcement[0]
|
|
OR NOT bCreatedAdditionalReinforcement[1]
|
|
OR NOT bCreatedAdditionalReinforcement[2]
|
|
OR NOT bCreatedAdditionalReinforcement[3]
|
|
iReinforcementsAlive++
|
|
ENDIF
|
|
|
|
IF iReinforcementsAlive = 0
|
|
bDebugCanWinch = TRUE
|
|
ENDIF
|
|
|
|
IF prisonerGrabState < PRISONER_GRAB_STATE_EXTRACT
|
|
IF NOT bDebugSwingOutEarlier
|
|
IF iReinforcementsAlive < 3
|
|
bStartExtraction = TRUE
|
|
ENDIF
|
|
ELSE
|
|
bStartExtraction = TRUE
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF IS_PLAYBACK_GOING_ON_FOR_VEHICLE(snatchAndGrabVehicle[SAGV_PLAYER_CHOPPER])
|
|
SET_PLAYBACK_SPEED(snatchAndGrabVehicle[SAGV_PLAYER_CHOPPER], 0.0)
|
|
ENDIF
|
|
BREAK
|
|
ENDSWITCH
|
|
|
|
// disable IK on Michael
|
|
PED_INDEX ikPed = GET_MICHAEL_PED()
|
|
IF NOT IS_PED_INJURED(ikPed)
|
|
SET_PED_CAN_TORSO_REACT_IK(ikPed, FALSE)
|
|
ENDIF
|
|
|
|
// god text
|
|
IF NOT bShownGodText
|
|
AND currentMissionStage = STAGE_SNIPE_GUARDS
|
|
IF NOT bDoneDontShootSpeech
|
|
IF iGuardSpeech < 8
|
|
bDoneDontShootSpeech = DO_MISSION_SPEECH("FBI2_SHTK")
|
|
ELSE
|
|
bDoneDontShootSpeech = TRUE
|
|
ENDIF
|
|
ELSE
|
|
//IF DO_MISSION_GOD_TEXT("SG_SNIPE")
|
|
bShownGodText = TRUE
|
|
iShownGodTextTime = GET_GAME_TIMER()
|
|
//ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF prisonerGrabState = PRISONER_GRAB_STATE_EXTRACT
|
|
fPhase = GET_SYNCHRONIZED_SCENE_PHASE(iSyncScene)
|
|
IF bPinRopeToWindow
|
|
IF fPhase >= 0.02
|
|
bPinRopeToWindow = FALSE
|
|
ENDIF
|
|
ENDIF
|
|
|
|
// go to swinging
|
|
IF NOT bActivatedRopeSwingFromSynced
|
|
IF IS_SYNCHRONIZED_SCENE_RUNNING(iSyncScene)
|
|
fPhase = GET_SYNCHRONIZED_SCENE_PHASE(iSyncScene)
|
|
IF fPhase >= 0.98
|
|
//PRINTSTRING("heading = ") PRINTFLOAT(GET_ENTITY_HEADING(GET_MICHAEL_PED())) PRINTNL()
|
|
prisonerGrabState = PRISONER_GRAB_STATE_DANGLING
|
|
SET_ROPE_DANGLING(FALSE, TRUE)
|
|
iDangleTime = GET_GAME_TIMER()
|
|
HANDLE_CHOPPER_ROPE(ROPE_TYPE_SWINGING)
|
|
//PRINT_HELP("SG_HOTHLP")
|
|
SET_SELECTOR_PED_HINT(sSelectorPeds, SELECTOR_PED_MICHAEL, TRUE)
|
|
iRecheckMichaelShootTime = GET_GAME_TIMER() + 1100
|
|
REPLAY_RECORD_BACK_FOR_TIME(3.0)
|
|
bActivatedRopeSwingFromSynced = TRUE
|
|
ENDIF
|
|
|
|
IF fPhase >= 0.18//0.24
|
|
fRopeTransitionPhase = fRopeTransitionPhase +@ 0.21
|
|
IF fRopeTransitionPhase > 1.0
|
|
fRopeTransitionPhase = 1.0
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF NOT bDoneExtractSpeech
|
|
IF fPhase >= 0.01//0.25
|
|
//bDoneExtractSpeech = DO_MISSION_SPEECH("FBI2_PULL", TRUE)
|
|
ENDIF
|
|
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF prisonerGrabState = PRISONER_GRAB_STATE_WINCHING
|
|
IF GET_GAME_TIMER() >= iWinchTime // the alt 2500
|
|
IF (hangingHotswapState = HANGING_HOTSWAP_ON_MICHAEL OR hangingHotswapState = HANGING_HOTSWAP_ON_FRANKLIN)
|
|
AND NOT IS_ANY_CONVERSATION_ONGOING_OR_QUEUED()
|
|
IF HAS_CUTSCENE_LOADED_WITH_FAILSAFE()
|
|
fRopeTransitionPhase = 1.0
|
|
bRunningCutscene = TRUE
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ELSE
|
|
DO_WINCH_CUTSCENE()
|
|
ENDIF
|
|
|
|
ENSURE_FRANKLIN_INVISIBLE()
|
|
ENDPROC
|
|
|
|
PROC RESET_CHOPPER_PED_DAMAGE_ENTITY()
|
|
INT i
|
|
REPEAT COUNT_OF(enemyChopperPed) i
|
|
IF NOT IS_PED_INJURED(enemyChopperPed[i])
|
|
CLEAR_ENTITY_LAST_DAMAGE_ENTITY(enemyChopperPed[i])
|
|
ENDIF
|
|
ENDREPEAT
|
|
ENDPROC
|
|
|
|
PROC DO_CHOPPER_ESCAPE_COMMON_FUNCTIONS()
|
|
INT i
|
|
|
|
// TEMP - BLOCK TREVOR ESCAPE
|
|
//DISABLE_CONTROL_ACTION(PLAYER_CONTROL, INPUT_VEH_EXIT)
|
|
SET_ALLOW_CUSTOM_VEHICLE_DRIVE_BY_CAM_THIS_UPDATE(TRUE)
|
|
|
|
// disable control on michael
|
|
IF GET_CURRENT_PLAYER_PED_ENUM() = CHAR_MICHAEL
|
|
DISABLE_CONTROL_ACTION(PLAYER_CONTROL, INPUT_SELECT_WEAPON)
|
|
DISABLE_CONTROL_ACTION(PLAYER_CONTROL, INPUT_VEH_EXIT)
|
|
DISABLE_CONTROL_ACTION(PLAYER_CONTROL, INPUT_ENTER)
|
|
DISABLE_CONTROL_ACTION(PLAYER_CONTROL, INPUT_VEH_SELECT_NEXT_WEAPON)
|
|
DISABLE_CONTROL_ACTION(PLAYER_CONTROL, INPUT_VEH_SELECT_PREV_WEAPON)
|
|
SET_PED_RESET_FLAG(PLAYER_PED_ID(), PRF_AllowSpecialAbilityInVehicle, TRUE)
|
|
ELIF GET_CURRENT_PLAYER_PED_ENUM() = CHAR_FRANKLIN
|
|
DISABLE_ON_FOOT_FIRST_PERSON_VIEW_THIS_UPDATE()
|
|
REPLAY_DISABLE_CAMERA_MOVEMENT_THIS_FRAME()
|
|
DISABLE_CELLPHONE_THIS_FRAME_ONLY()
|
|
DISABLE_CONTROL_ACTION(PLAYER_CONTROL, INPUT_SELECT_WEAPON)
|
|
DISABLE_CONTROL_ACTION(PLAYER_CONTROL, INPUT_JUMP)
|
|
DISABLE_CONTROL_ACTION(PLAYER_CONTROL, INPUT_ENTER)
|
|
DISABLE_CONTROL_ACTION(PLAYER_CONTROL, INPUT_SPRINT)
|
|
ENDIF
|
|
|
|
IF NOT IS_PED_INJURED(GET_MICHAEL_PED())
|
|
SET_PED_CAN_SWITCH_WEAPON(GET_MICHAEL_PED(), FALSE)
|
|
SET_PED_RESET_FLAG(GET_MICHAEL_PED(), PRF_PreventGoingIntoShuntInVehicleState, TRUE)
|
|
ENDIF
|
|
IF NOT IS_PED_INJURED(GET_FRANKLIN_PED())
|
|
SET_PED_CAN_SWITCH_WEAPON(GET_FRANKLIN_PED(), FALSE)
|
|
ENDIF
|
|
IF NOT IS_PED_INJURED(GET_TREVOR_PED())
|
|
SET_PED_CAN_SWITCH_WEAPON(GET_TREVOR_PED(), TRUE)
|
|
ENDIF
|
|
|
|
PED_INDEX fPed = GET_FRANKLIN_PED()
|
|
IF NOT IS_PED_INJURED(fPed)
|
|
IF HAS_PED_GOT_WEAPON(fPed, GET_SNATCH_AND_GRAB_WEAPON_TYPE(SAG_WEAPON_SNIPER_RIFLE))
|
|
WEAPON_TYPE weapon
|
|
GET_CURRENT_PED_WEAPON(fPed, weapon)
|
|
IF weapon <> GET_SNATCH_AND_GRAB_WEAPON_TYPE(SAG_WEAPON_SNIPER_RIFLE)
|
|
PRINTSTRING("franklin has a rifle but it is not equipped!!!") PRINTNL()
|
|
SET_CURRENT_PED_WEAPON(fPed, GET_SNATCH_AND_GRAB_WEAPON_TYPE(SAG_WEAPON_SNIPER_RIFLE), TRUE)
|
|
ENDIF
|
|
ELSE
|
|
PRINTSTRING("franklin doesn't have a rifle!!!") PRINTNL()
|
|
ENDIF
|
|
ENDIF
|
|
|
|
/*
|
|
// handle michael reload state
|
|
IF hangingHotswapState = HANGING_HOTSWAP_ON_MICHAEL
|
|
PED_INDEX reloadPed = GET_MICHAEL_PED()
|
|
IF NOT IS_PED_INJURED(reloadPed)
|
|
INT iAmmo
|
|
GET_AMMO_IN_CLIP(reloadPed, GET_SNATCH_AND_GRAB_WEAPON_TYPE(SAG_WEAPON_MICHAEL_RIFLE), iAmmo)
|
|
SWITCH michaelReloadState
|
|
CASE MICHAEL_RELOAD_HAS_AMMO
|
|
IF iAmmo = 0
|
|
PLAY_SOUND_FROM_ENTITY(-1, "FBI_02_RELOAD", reloadPed)
|
|
michaelReloadState = MICHAEL_RELOAD_IS_RELOADING
|
|
ENDIF
|
|
BREAK
|
|
CASE MICHAEL_RELOAD_IS_RELOADING
|
|
IF iAmmo > 0
|
|
michaelReloadState = MICHAEL_RELOAD_HAS_AMMO
|
|
ENDIF
|
|
BREAK
|
|
ENDSWITCH
|
|
ENDIF
|
|
ELSE
|
|
michaelReloadState = MICHAEL_RELOAD_HAS_AMMO
|
|
ENDIF
|
|
*/
|
|
|
|
// handle fbi
|
|
HANDLE_FBI()
|
|
|
|
// rotate the sniper rifle to track chopper
|
|
IF IS_VEHICLE_DRIVEABLE(enemyChopperVehicle[2])
|
|
IF hangingHotswapState <> HANGING_HOTSWAP_ON_FRANKLIN
|
|
AND hangingHotswapState <> HANGING_HOTSWAP_MICHAEL_TO_FRANKLIN
|
|
AND hangingHotswapState <> HANGING_HOTSWAP_TREVOR_TO_FRANKLIN
|
|
//VECTOR vSniperCoords = GET_ENTITY_COORDS(remoteSniperData.obj_sniper)
|
|
// VECTOR vChopperCoords = GET_ENTITY_COORDS(enemyChopperVehicle[2])
|
|
//FLOAT fSniperHeading = GET_HEADING_FROM_VECTOR_2D(vChopperCoords.x - vSniperCoords.x, vChopperCoords.y - vSniperCoords.y)
|
|
//SET_ENTITY_HEADING(remoteSniperData.obj_sniper, fSniperHeading)
|
|
ENDIF
|
|
ENDIF
|
|
|
|
// exaggerated spin out on the choppers
|
|
REPEAT NUMBER_ENEMY_CHOPPERS i
|
|
IF NOT bDoChopperSpinOut[i]
|
|
IF NOT IS_ENTITY_DEAD(enemyChopperVehicle[i])
|
|
IF IS_PED_INJURED(GET_PED_IN_VEHICLE_SEAT(enemyChopperVehicle[i]))
|
|
PLAY_SOUND_FROM_ENTITY(-1, "FBI_02_SNATCH_AND_GRAB_HELI_DOWN", enemyChopperVehicle[i])
|
|
SET_VEHICLE_OUT_OF_CONTROL(enemyChopperVehicle[i], FALSE)
|
|
bDoChopperSpinOut[i] = TRUE
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDREPEAT
|
|
|
|
// kill Franklin on chopper collision
|
|
IF NOT IS_PED_INJURED(sSelectorPeds.pedID[SELECTOR_PED_FRANKLIN])
|
|
IF currentMissionStage = STAGE_DROPOFF
|
|
IF NOT IS_PED_HEADTRACKING_ENTITY(sSelectorPeds.pedID[SELECTOR_PED_FRANKLIN], PLAYER_PED_ID())
|
|
TASK_LOOK_AT_ENTITY(sSelectorPeds.pedID[SELECTOR_PED_FRANKLIN], PLAYER_PED_ID(), -1, SLF_WHILE_NOT_IN_FOV)
|
|
ENDIF
|
|
ENDIF
|
|
|
|
SET_PED_RESET_FLAG(sSelectorPeds.pedID[SELECTOR_PED_FRANKLIN], PRF_UseKinematicPhysics, TRUE)
|
|
SET_PED_ACCURACY(sSelectorPeds.pedID[SELECTOR_PED_FRANKLIN], 0)
|
|
|
|
IF IS_ENTITY_ATTACHED(sSelectorPeds.pedID[SELECTOR_PED_FRANKLIN])
|
|
DETACH_ENTITY(sSelectorPeds.pedID[SELECTOR_PED_FRANKLIN])
|
|
ENDIF
|
|
SET_ENTITY_SHOULD_FREEZE_WAITING_ON_COLLISION(sSelectorPeds.pedID[SELECTOR_PED_FRANKLIN], TRUE)
|
|
|
|
IF NOT IS_ENTITY_DEAD(snatchAndGrabVehicle[SAGV_PLAYER_CHOPPER])
|
|
IF (IS_ENTITY_TOUCHING_ENTITY(snatchAndGrabVehicle[SAGV_PLAYER_CHOPPER], sSelectorPeds.pedID[SELECTOR_PED_FRANKLIN])
|
|
AND GET_ENTITY_SPEED(snatchAndGrabVehicle[SAGV_PLAYER_CHOPPER]) >= 2)
|
|
OR (IS_PED_RAGDOLL(sSelectorPeds.pedID[SELECTOR_PED_FRANKLIN]) AND (hangingHotswapState = HANGING_HOTSWAP_ON_MICHAEL OR hangingHotswapState = HANGING_HOTSWAP_ON_TREVOR))
|
|
DETACH_ENTITY(sSelectorPeds.pedID[SELECTOR_PED_FRANKLIN])
|
|
APPLY_DAMAGE_TO_PED(sSelectorPeds.pedID[SELECTOR_PED_FRANKLIN], 1000, TRUE)
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
|
|
|
|
// IF bDoChopperSpinOut
|
|
/*
|
|
IF IS_PED_INJURED(enemyChopperPed[0])
|
|
IF DOES_ENTITY_EXIST(enemyChopperVehicle)
|
|
IF NOT IS_ENTITY_DEAD(enemyChopperVehicle)
|
|
VECTOR vRotationVelocity = GET_ENTITY_ROTATION_VELOCITY(enemyChopperVehicle)
|
|
IF vRotationVelocity.z >= 0
|
|
iSpinModifier = -1
|
|
ELSE
|
|
iSpinModifier = 1
|
|
ENDIF
|
|
|
|
fSpinForce = fSpinForce +@ (6 * iSpinModifier) // 12
|
|
IF fSpinForce >= 50
|
|
fSpinForce = 50
|
|
ELIF fSpinForce <= -50
|
|
fSpinForce = -50
|
|
ENDIF
|
|
|
|
fUpwardsForce = fUpwardsForce -@ 1.8
|
|
IF fUpwardsForce < 0
|
|
fUpwardsForce = 0
|
|
ENDIF
|
|
|
|
IF NOT IS_HELI_PART_BROKEN(enemyChopperVehicle, TRUE, TRUE, TRUE)
|
|
APPLY_FORCE_TO_ENTITY(enemyChopperVehicle, APPLY_TYPE_FORCE, <<fSpinForce, 0, 0>>, <<0, 2.2, 0>>, 0, TRUE, TRUE, TRUE)
|
|
APPLY_FORCE_TO_ENTITY(enemyChopperVehicle, APPLY_TYPE_FORCE, <<-fSpinForce, 0, 0>>, <<0, -2.2, 0>>, 0, TRUE, TRUE, TRUE)
|
|
APPLY_FORCE_TO_ENTITY(enemyChopperVehicle, APPLY_TYPE_EXTERNAL_FORCE, <<0, 0, fUpwardsForce>>, <<0, 0, 0>>, 0, FALSE, TRUE, TRUE)
|
|
ENDIF
|
|
IF HAS_ENTITY_COLLIDED_WITH_ANYTHING(enemyChopperVehicle)
|
|
EXPLODE_VEHICLE(enemyChopperVehicle)
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
*/
|
|
// ELSE
|
|
/*
|
|
// set to spin out
|
|
IF NOT IS_VEHICLE_DRIVEABLE(enemyChopperVehicle)
|
|
OR IS_PED_INJURED(enemyChopperPed[0])
|
|
bDoChopperSpinOut = TRUE
|
|
ENDIF
|
|
*/
|
|
// ENDIF
|
|
|
|
// unpin interior
|
|
IF NOT bUnpinnedInteriorForChase
|
|
//IF GET_DISTANCE_BETWEEN_COORDS(GET_ENTITY_COORDS(PLAYER_PED_ID()), GET_SNATCH_AND_GRAB_VECTOR(SAGVEC_WINDOW_FRAME), FALSE) >= 200.0
|
|
SET_GUARDS_NO_LONGER_NEEDED()
|
|
|
|
REPEAT NUMBER_REINFORCEMENTS i
|
|
IF DOES_ENTITY_EXIST(reinforcementPed[i])
|
|
IF NOT IS_PED_INJURED(reinforcementPed[i])
|
|
CLEAR_PED_TASKS(reinforcementPed[i])
|
|
ENDIF
|
|
SET_PED_AS_NO_LONGER_NEEDED(reinforcementPed[i])
|
|
ENDIF
|
|
ENDREPEAT
|
|
|
|
IF DOES_ENTITY_EXIST(chairObject)
|
|
SET_OBJECT_AS_NO_LONGER_NEEDED(chairObject)
|
|
ENDIF
|
|
|
|
IF DOES_ENTITY_EXIST(torchObject)
|
|
SET_OBJECT_AS_NO_LONGER_NEEDED(torchObject)
|
|
ENDIF
|
|
|
|
IF DOES_ENTITY_EXIST(michellePed)
|
|
SET_PED_AS_NO_LONGER_NEEDED(michellePed)
|
|
ENDIF
|
|
|
|
PIN_OFFICE_INTERIOR(FALSE, FALSE)
|
|
bUnpinnedInteriorForChase = TRUE
|
|
//ENDIF
|
|
ENDIF
|
|
|
|
// handle winding rope
|
|
IF NOT bStartedWinding
|
|
IF GET_GAME_TIMER() >= iChopperChaseTime + CHASE_START_WINDING_TIME
|
|
OR bShortRope
|
|
OR currentMissionStage = STAGE_DROPOFF
|
|
IF DOES_ROPE_EXIST(rappelData.rope)
|
|
STOP_ROPE_UNWINDING_FRONT(rappelData.rope)
|
|
START_ROPE_WINDING(rappelData.rope)
|
|
iStartWindingTime = GET_GAME_TIMER()
|
|
bStartedWinding = TRUE
|
|
ENDIF
|
|
ENDIF
|
|
ELSE
|
|
IF NOT bStoppedWinding
|
|
IF NOT bShortRope
|
|
IF GET_GAME_TIMER() >= iStartWindingTime + WINDING_LENGTH
|
|
IF DOES_ROPE_EXIST(rappelData.rope)
|
|
STOP_ROPE_WINDING(rappelData.rope)
|
|
bStoppedWinding = TRUE
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
|
|
// create the fbi
|
|
SWITCH createFBIAtEndStage
|
|
CASE CREATE_FBI_AT_END_STAGE_NOT_STARTED
|
|
IF IS_ENTITY_AT_COORD(PLAYER_PED_ID(), <<1387.84, -2061.63, 51.00>>, <<500,500,500>>, FALSE, FALSE)
|
|
ADD_MODEL_REQUEST(ENUM_TO_INT(SAGM_FBIEND))
|
|
ADD_MODEL_REQUEST(ENUM_TO_INT(SAGM_FBI_VAN))
|
|
ADD_MODEL_REQUEST(ENUM_TO_INT(SAGM_DRIVE_AWAY_CAR))
|
|
ADD_MODEL_REQUEST(ENUM_TO_INT(SAGM_UTIL_TRUCK_1))
|
|
ADD_MODEL_REQUEST(ENUM_TO_INT(SAGM_UTIL_TRUCK_2))
|
|
createFBIAtEndStage = CREATE_FBI_AT_END_STAGE_WAITING
|
|
ENDIF
|
|
BREAK
|
|
CASE CREATE_FBI_AT_END_STAGE_WAITING
|
|
IF HAVE_ALL_MODEL_REQUESTS_SUCCEEDED()
|
|
CREATE_FBI_FOR_STAGE(STAGE_CHOPPER_CHASE)
|
|
CREATE_UTIL_TRUCKS(STAGE_CHOPPER_CHASE)
|
|
IF SHOULD_USE_MISSION_START_VEHICLE_AT_END()
|
|
driveAwayVehicle = CREATE_REPLAY_START_VEHICLE(<<1387.10, -2044.61, 51.56>>, 130.9)
|
|
ELSE
|
|
driveAwayVehicle = CREATE_VEHICLE(GET_MODEL_FOR_SNATCH_AND_GRAB_MODEL_ENUM(SAGM_DRIVE_AWAY_CAR), <<1387.10, -2044.61, 51.56>>, 130.9)
|
|
SET_VEHICLE_COLOUR_COMBINATION(driveAwayVehicle, 0)
|
|
ENDIF
|
|
IF IS_VEHICLE_DRIVEABLE(driveAwayVehicle)
|
|
SET_ENTITY_SHOULD_FREEZE_WAITING_ON_COLLISION(driveAwayVehicle, TRUE)
|
|
ENDIF
|
|
|
|
SET_VEHICLE_ON_GROUND_PROPERLY(driveAwayVehicle)
|
|
//createFBIAtEndStage = CREATE_FBI_AT_END_STAGE_MID
|
|
createFBIAtEndStage = CREATE_FBI_AT_END_STAGE_DONE
|
|
ENDIF
|
|
BREAK
|
|
CASE CREATE_FBI_AT_END_STAGE_DONE
|
|
BREAK
|
|
ENDSWITCH
|
|
|
|
// hanging swing cam
|
|
IF hangingHotswapState = HANGING_HOTSWAP_ON_TREVOR
|
|
//HANDLE_ROPE_SWING_CAM()
|
|
ENDIF
|
|
|
|
// michael shooting ai
|
|
/*
|
|
IF hangingHotswapState = HANGING_HOTSWAP_ON_TREVOR
|
|
IF NOT IS_PED_INJURED(sSelectorPeds.pedID[SELECTOR_PED_MICHAEL])
|
|
IF GET_GAME_TIMER() >= iRecheckMichaelShootTime
|
|
BOOL bCanDoShoot = FALSE
|
|
|
|
IF currentMissionStage = STAGE_CHOPPER_CHASE
|
|
IF IS_VEHICLE_DRIVEABLE(enemyChopperVehicle)
|
|
IF NOT IS_PED_INJURED(enemyChopperPed[0])
|
|
IF GET_DISTANCE_BETWEEN_ENTITIES(sSelectorPeds.pedID[SELECTOR_PED_MICHAEL], enemyChopperVehicle, FALSE) <= 110
|
|
bCanDoShoot = TRUE
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF bCanDoShoot
|
|
IF enemyChopperPed[0] <> michaelTargetPed
|
|
TASK_AIM_GUN_SCRIPTED_WITH_TARGET(sSelectorPeds.pedID[SELECTOR_PED_MICHAEL], enemyChopperPed[0], <<0,0,0>>, SCRIPTED_GUN_TASK_ON_ROPE)
|
|
michaelTargetPed = enemyChopperPed[0]
|
|
ENDIF
|
|
ELSE
|
|
IF DOES_ENTITY_EXIST(michaelTargetPed)
|
|
TASK_PLAY_ANIM(sSelectorPeds.pedID[SELECTOR_PED_MICHAEL], GET_SNATCH_AND_GRAB_ANIM_DICT_AS_STRING(SAG_ANIM_DICT_MISSION), "idle", NORMAL_BLEND_IN, NORMAL_BLEND_OUT, -1, AF_LOOPING)
|
|
michaelTargetPed = NULL
|
|
ENDIF
|
|
ENDIF
|
|
iRecheckMichaelShootTime = GET_GAME_TIMER() + 2000
|
|
ENDIF
|
|
ENDIF
|
|
|
|
ENDIF
|
|
*/
|
|
|
|
// michael
|
|
IF NOT IS_PED_INJURED(GET_MICHAEL_PED())
|
|
SET_PED_RESET_FLAG(GET_MICHAEL_PED(), PRF_ExtraLongWeaponRange, TRUE)
|
|
ENDIF
|
|
|
|
// trevor fly to dropoff
|
|
IF currentMissionStage = STAGE_DROPOFF
|
|
IF hangingHotswapState <> HANGING_HOTSWAP_ON_TREVOR
|
|
AND hangingHotswapState <> HANGING_HOTSWAP_MICHAEL_TO_TREVOR
|
|
AND hangingHotswapState <> HANGING_HOTSWAP_FRANKLIN_TO_TREVOR
|
|
AND GET_CURRENT_PLAYER_PED_ENUM() <> CHAR_TREVOR
|
|
IF NOT bDoneTrevorFly
|
|
IF bDoneGotoSpeech
|
|
IF NOT IS_PLAYBACK_GOING_ON_FOR_VEHICLE(snatchAndGrabVehicle[SAGV_PLAYER_CHOPPER])
|
|
IF GET_GAME_TIMER() >= iNextTrevorAITime
|
|
DO_TREVOR_FLY_TO_DROPOFF()
|
|
bDoneTrevorFly = TRUE
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ELSE
|
|
IF IS_VEHICLE_DRIVEABLE(snatchAndGrabVehicle[SAGV_PLAYER_CHOPPER])
|
|
IF iLeaveHighRiseAreaPoint < 0
|
|
IF iTrevorRouteStage > 0
|
|
IF IS_ENTITY_AT_COORD(snatchAndGrabVehicle[SAGV_PLAYER_CHOPPER], vTrevorRoutePoint[iTrevorRouteStage], <<40, 40, 40>>, FALSE, FALSE)
|
|
iTrevorRouteStage--
|
|
DO_TREVOR_FLY_TO_ROUTE_POINT()
|
|
ENDIF
|
|
ENDIF
|
|
ELSE
|
|
VECTOR vHeliPos
|
|
vHeliPos = GET_ENTITY_COORDS(snatchAndGrabVehicle[SAGV_PLAYER_CHOPPER])
|
|
HANDLE_LEAVE_HIGH_RISE_AREA()
|
|
IF GET_DISTANCE_BETWEEN_COORDS(vHeliPos, GET_LEAVE_HIGH_RISE_AREA_POINT(iLeaveHighRiseAreaPoint), FALSE) <= 30
|
|
OR NOT IS_COORD_IN_HIGH_RISE_AREA(vHeliPos)
|
|
DO_TREVOR_FLY_TO_DROPOFF()
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF hangingHotswapState <> HANGING_HOTSWAP_ON_TREVOR
|
|
AND hangingHotswapState <> HANGING_HOTSWAP_ON_FRANKLIN
|
|
AND hangingHotswapState <> HANGING_HOTSWAP_ON_MICHAEL
|
|
iSuppressHUDTime = GET_GAME_TIMER() + 100
|
|
ENDIF
|
|
|
|
|
|
IF GET_GAME_TIMER() <= iSuppressHUDTime + 100
|
|
HIDE_HUD_COMPONENT_THIS_FRAME(NEW_HUD_STREET_NAME)
|
|
HIDE_HUD_COMPONENT_THIS_FRAME(NEW_HUD_VEHICLE_NAME)
|
|
HIDE_HUD_COMPONENT_THIS_FRAME(NEW_HUD_AREA_NAME)
|
|
HIDE_HUD_COMPONENT_THIS_FRAME(NEW_HUD_DISTRICT_NAME)
|
|
ENDIF
|
|
|
|
// handle hotswap between michael and trevor
|
|
SWITCH hangingHotswapState
|
|
CASE HANGING_HOTSWAP_ON_TREVOR
|
|
|
|
IF NOT bClearedAutopilot
|
|
//BOOL bPressingControl
|
|
INT iLX, iLY, iRX, iRY
|
|
GET_CONTROL_VALUE_OF_ANALOGUE_STICKS(iLX, iLY, iRX, iRY)
|
|
|
|
IF GET_GAME_TIMER() >= iClearAutopilotTime
|
|
OR iLx > 20
|
|
OR iLx < -20
|
|
OR iLy > 20
|
|
OR iLy < -20
|
|
OR IS_CONTROL_PRESSED(PLAYER_CONTROL, INPUT_VEH_FLY_THROTTLE_UP)
|
|
OR IS_CONTROL_PRESSED(PLAYER_CONTROL, INPUT_VEH_FLY_THROTTLE_DOWN)
|
|
OR IS_CONTROL_PRESSED(PLAYER_CONTROL, INPUT_VEH_FLY_YAW_LEFT)
|
|
OR IS_CONTROL_PRESSED(PLAYER_CONTROL, INPUT_VEH_FLY_YAW_RIGHT)
|
|
IF IS_PLAYBACK_GOING_ON_FOR_VEHICLE(snatchAndGrabVehicle[SAGV_PLAYER_CHOPPER])
|
|
STOP_PLAYBACK_RECORDED_VEHICLE(snatchAndGrabVehicle[SAGV_PLAYER_CHOPPER])
|
|
ENDIF
|
|
CLEAR_PED_TASKS(PLAYER_PED_ID())
|
|
bClearedAutopilot = TRUE
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF currentMissionStage = STAGE_DROPOFF
|
|
IF NOT bSwitchedBackDuringDropoff
|
|
IF bShownGodText
|
|
bSwitchedBackDuringDropoff = TRUE
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
//CASCADE_SHADOWS_SET_CASCADE_BOUNDS_SCALE(CASCADE_SHADOWS_MULTIPLIER_NO_OVERRIDE)
|
|
|
|
// deal with michael driveby
|
|
HANDLE_MICHAEL_DRIVEBY()
|
|
HANDLE_FRANKLIN_SHOOT_FROM_ROOF()
|
|
|
|
IF IS_SELECTOR_UI_BUTTON_PRESSED()
|
|
DISABLE_CONTROL_ACTION(PLAYER_CONTROL, INPUT_VEH_EXIT)
|
|
iSelectorPressedTime = GET_GAME_TIMER()
|
|
ELIF GET_GAME_TIMER() <= iSelectorPressedTime + 200
|
|
DISABLE_CONTROL_ACTION(PLAYER_CONTROL, INPUT_VEH_EXIT)
|
|
ENDIF
|
|
|
|
//PRINTSTRING("ON TREVOR") PRINTNL()
|
|
IF CAN_ADVANCE_MISSION()
|
|
AND IS_PED_SITTING_IN_VEHICLE(PLAYER_PED_ID(), snatchAndGrabVehicle[SAGV_PLAYER_CHOPPER])
|
|
AND NOT bDisableSwitchDuringMagDemoEndScene
|
|
//PRINTSTRING("CAN ADVANCE MISSION") PRINTNL()
|
|
IF UPDATE_SELECTOR_HUD(sSelectorPeds, FALSE)
|
|
#IF IS_DEBUG_BUILD
|
|
OR bDebugJSkip
|
|
#ENDIF
|
|
PRINTSTRING("UPDATED SELECTOR HUD") PRINTNL()
|
|
BOOL bResetTrevor
|
|
bResetTrevor = FALSE
|
|
|
|
g_fSavedMaxMotionBlur = GET_MOTIONBLUR_MAX_VEL_SCALER()
|
|
IF sSelectorPeds.eNewSelectorPed = SELECTOR_PED_MICHAEL
|
|
bDoneReattach = FALSE
|
|
INFORM_MISSION_STATS_OF_INCREMENT(FBI2_SWITCHES)
|
|
|
|
DO_CHOPPER_TO_PED_AUDIO_SCENE(CHAR_MICHAEL)
|
|
|
|
iSwitchTime = GET_GAME_TIMER()
|
|
hangingHotswapState = HANGING_HOTSWAP_TREVOR_TO_MICHAEL
|
|
iNextTrevorAITime = GET_GAME_TIMER() + 3000
|
|
bResetTrevor = TRUE
|
|
ELIF sSelectorPeds.eNewSelectorPed = SELECTOR_PED_FRANKLIN
|
|
INFORM_MISSION_STATS_OF_INCREMENT(FBI2_SWITCHES)
|
|
iSwitchTime = GET_GAME_TIMER()
|
|
hangingHotswapState = HANGING_HOTSWAP_TREVOR_TO_FRANKLIN
|
|
SET_MOTIONBLUR_MAX_VEL_SCALER(MAX_TRANSITION_BLUR)
|
|
DO_CHOPPER_TO_PED_AUDIO_SCENE(CHAR_FRANKLIN)
|
|
bResetTrevor = TRUE
|
|
ENDIF
|
|
|
|
IF bResetTrevor
|
|
iTrevorEscapeRoutePoint = -1
|
|
iLeaveHighRiseAreaPoint = -1
|
|
bAllowStartEscapeRoute = FALSE
|
|
bDoneTrevorFly = FALSE
|
|
bDoneForceTrevorLow = FALSE
|
|
bDoneDangleHelp = TRUE
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
BREAK
|
|
CASE HANGING_HOTSWAP_ON_MICHAEL
|
|
// lockon range
|
|
SET_PLAYER_LOCKON_RANGE_OVERRIDE(PLAYER_ID(), 130)
|
|
OVERRIDE_LODSCALE_THIS_FRAME(1.0)
|
|
|
|
HANDLE_FRANKLIN_SHOOT_FROM_ROOF()
|
|
|
|
IF GET_GAME_TIMER() <= iBlockMichaelShootTime
|
|
IF NOT IS_PED_INJURED(GET_MICHAEL_PED())
|
|
SET_PED_RESET_FLAG(GET_MICHAEL_PED(), PRF_BlockWeaponFire, TRUE)
|
|
ENDIF
|
|
ENDIF
|
|
//PRINTSTRING("lodscale") PRINTNL()
|
|
//CASCADE_SHADOWS_SET_CASCADE_BOUNDS_SCALE(CASCADE_SHADOWS_MULTIPLIER_NO_OVERRIDE)
|
|
//CASCADE_SHADOWS_SET_AIRCRAFT_MODE(TRUE)]
|
|
|
|
IF GET_GAME_TIMER() >= iNextExplosionCheckTime
|
|
IF IS_EXPLOSION_IN_AREA(EXP_TAG_DONTCARE, GET_ENTITY_COORDS(PLAYER_PED_ID()) - <<6,6,6>>, GET_ENTITY_COORDS(PLAYER_PED_ID()) + <<6,6,6>>)
|
|
APPLY_DAMAGE_TO_PED(PLAYER_PED_ID(), 20, TRUE)
|
|
ENDIF
|
|
iNextExplosionCheckTime = GET_GAME_TIMER() + 5000
|
|
ENDIF
|
|
|
|
// switch menu
|
|
IF bDoneGetOutSpeech
|
|
IF CAN_ADVANCE_MISSION()
|
|
AND IS_PED_SITTING_IN_VEHICLE(PLAYER_PED_ID(), snatchAndGrabVehicle[SAGV_PLAYER_CHOPPER])
|
|
AND NOT bDisableSwitchDuringMagDemoEndScene
|
|
IF UPDATE_SELECTOR_HUD(sSelectorPeds, FALSE)
|
|
#IF IS_DEBUG_BUILD
|
|
OR bDebugJSkip
|
|
#ENDIF
|
|
//BOOL bResetTrevor
|
|
//bResetTrevor = FALSE
|
|
|
|
g_fSavedMaxMotionBlur = GET_MOTIONBLUR_MAX_VEL_SCALER()
|
|
|
|
IF sSelectorPeds.eNewSelectorPed = SELECTOR_PED_TREVOR
|
|
IF IS_THIS_HELP_MESSAGE_BEING_DISPLAYED("SG_HOTHLP2")
|
|
CLEAR_HELP(FALSE)
|
|
ENDIF
|
|
//bResetTrevor = TRUE
|
|
INFORM_MISSION_STATS_OF_INCREMENT(FBI2_SWITCHES)
|
|
DO_CHOPPER_TO_PED_AUDIO_SCENE(CHAR_TREVOR)
|
|
iSwitchTime = GET_GAME_TIMER()
|
|
hangingHotswapState = HANGING_HOTSWAP_MICHAEL_TO_TREVOR
|
|
ELIF sSelectorPeds.eNewSelectorPed = SELECTOR_PED_FRANKLIN
|
|
//bResetTrevor = TRUE
|
|
INFORM_MISSION_STATS_OF_INCREMENT(FBI2_SWITCHES)
|
|
iSwitchTime = GET_GAME_TIMER()
|
|
hangingHotswapState = HANGING_HOTSWAP_MICHAEL_TO_FRANKLIN
|
|
SET_MOTIONBLUR_MAX_VEL_SCALER(MAX_TRANSITION_BLUR)
|
|
DO_CHOPPER_TO_PED_AUDIO_SCENE(CHAR_FRANKLIN)
|
|
ENDIF
|
|
|
|
/*
|
|
IF bResetTrevor
|
|
iTrevorEscapeRoutePoint = -1
|
|
iLeaveHighRiseAreaPoint = -1
|
|
bAllowStartEscapeRoute = FALSE
|
|
bDoneTrevorFly = FALSE
|
|
bDoneForceTrevorLow = FALSE
|
|
bDoneDangleHelp = TRUE
|
|
ENDIF
|
|
*/
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
BREAK
|
|
CASE HANGING_HOTSWAP_ON_FRANKLIN
|
|
VECTOR vGameplayCamRot
|
|
vGameplayCamRot = GET_GAMEPLAY_CAM_ROT()
|
|
|
|
SET_ENTITY_ROTATION(franklinAnchorObject, <<0,0,vGameplayCamRot.z>>)
|
|
|
|
IF NOT bChangedPriorityFromSniperToTrevor
|
|
IF NOT IS_VEHICLE_DRIVEABLE(enemyChopperVehicle[0])
|
|
AND NOT IS_VEHICLE_DRIVEABLE(enemyChopperVehicle[1])
|
|
AND NOT IS_VEHICLE_DRIVEABLE(enemyChopperVehicle[3])
|
|
SET_SELECTOR_PED_PRIORITY(sSelectorPeds, SELECTOR_PED_TREVOR, SELECTOR_PED_MICHAEL, SELECTOR_PED_FRANKLIN)
|
|
bChangedPriorityFromSniperToTrevor = TRUE
|
|
ENDIF
|
|
ENDIF
|
|
|
|
// switch menu
|
|
BOOL bSelectorCheck
|
|
bSelectorCheck = FALSE
|
|
IF CAN_ADVANCE_MISSION()
|
|
bSelectorCheck = UPDATE_SELECTOR_HUD(sSelectorPeds, FALSE)
|
|
ENDIF
|
|
|
|
//CASCADE_SHADOWS_SET_CASCADE_BOUNDS_SCALE(CASCADE_SHADOWS_MULTIPLIER_EXTERIOR_OVERRIDE)
|
|
|
|
// force switch to franklin if all destroyed
|
|
IF NOT bDoneForceGetOutOfThereSpeech
|
|
IF currentMissionStage = STAGE_DROPOFF
|
|
bDoneForceGetOutOfThereSpeech = DO_MISSION_SPEECH("FBI2_LEAVE")
|
|
ENDIF
|
|
ELSE
|
|
IF NOT IS_ANY_CONVERSATION_ONGOING_OR_QUEUED()
|
|
sSelectorPeds.eNewSelectorPed = SELECTOR_PED_TREVOR
|
|
bSelectorCheck = TRUE
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF bSelectorCheck
|
|
#IF IS_DEBUG_BUILD
|
|
OR bDebugJSkip
|
|
#ENDIF
|
|
SET_ENTITY_VISIBLE(GET_FRANKLIN_PED(), TRUE)
|
|
g_fSavedMaxMotionBlur = GET_MOTIONBLUR_MAX_VEL_SCALER()
|
|
SET_MOTIONBLUR_MAX_VEL_SCALER(MAX_TRANSITION_BLUR)
|
|
IF sSelectorPeds.eNewSelectorPed = SELECTOR_PED_MICHAEL
|
|
OR sSelectorPeds.eNewSelectorPed = SELECTOR_PED_TREVOR
|
|
IF NOT IS_PED_INJURED(PLAYER_PED_ID())
|
|
SET_FACIAL_IDLE_ANIM_OVERRIDE(PLAYER_PED_ID(), "Mood_Angry_1")
|
|
ENDIF
|
|
|
|
//SET_REMOTE_SNIPER_ACTIVE(remoteSniperData, FALSE)
|
|
//RENDER_SCRIPT_CAMS(TRUE, FALSE)
|
|
// CASCADE_SHADOWS_SET_CASCADE_BOUNDS_SCALE(CASCADE_SHADOWS_MULTIPLIER_NO_OVERRIDE)
|
|
// CASCADE_SHADOWS_SET_AIRCRAFT_MODE(TRUE)
|
|
IF sSelectorPeds.eNewSelectorPed = SELECTOR_PED_MICHAEL
|
|
INFORM_MISSION_STATS_OF_INCREMENT(FBI2_SWITCHES)
|
|
DO_CHOPPER_TO_PED_AUDIO_SCENE(CHAR_MICHAEL)
|
|
iSwitchTime = GET_GAME_TIMER()
|
|
hangingHotswapState = HANGING_HOTSWAP_FRANKLIN_TO_MICHAEL
|
|
ELSE
|
|
INFORM_MISSION_STATS_OF_INCREMENT(FBI2_SWITCHES)
|
|
DO_CHOPPER_TO_PED_AUDIO_SCENE(CHAR_TREVOR)
|
|
iSwitchTime = GET_GAME_TIMER()
|
|
hangingHotswapState = HANGING_HOTSWAP_FRANKLIN_TO_TREVOR
|
|
ENDIF
|
|
ENDIF
|
|
ELSE
|
|
IF GET_FOLLOW_PED_CAM_VIEW_MODE() <> CAM_VIEW_MODE_FIRST_PERSON
|
|
SET_PLAYER_FORCE_SKIP_AIM_INTRO(PLAYER_ID(),TRUE)
|
|
SET_PLAYER_FORCED_AIM(PLAYER_ID(), TRUE)
|
|
|
|
IF IS_SELECTOR_ONSCREEN()
|
|
//IF IS_CONTROL_PRESSED(PLAYER_CONTROL, INPUT_CHARACTER_WHEEL)
|
|
iWaitToKillCam = 0
|
|
//sniper
|
|
IF NOT DOES_CAM_EXIST(staticCam)
|
|
CREATE_MISSION_STATIC_CAM(staticCam)
|
|
SET_ENTITY_VISIBLE(GET_FRANKLIN_PED(), TRUE)
|
|
SET_CAM_FOV(staticCam, 45.0)
|
|
ATTACH_CAM_TO_ENTITY(staticCam, GET_FRANKLIN_PED(), <<0.0,-2.5,0.7>>, TRUE)
|
|
POINT_CAM_AT_ENTITY(staticCam, GET_FRANKLIN_PED(), <<0,0,0.4>>, TRUE)
|
|
ENDIF
|
|
|
|
RENDER_SCRIPT_CAMS(TRUE, FALSE)
|
|
////PRINTSTRING("Show Franklin here") PRINTNL()
|
|
ELSE
|
|
IF iWaitToKillCam = 4
|
|
//SET_ENTITY_VISIBLE(GET_FRANKLIN_PED(), FALSE)
|
|
DESTROY_MISSION_STATIC_CAM(staticCam)
|
|
RENDER_SCRIPT_CAMS(FALSE, FALSE)
|
|
DISPLAY_SNIPER_SCOPE_THIS_FRAME()
|
|
ELSE
|
|
iWaitToKillCam++
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
BREAK
|
|
|
|
CASE HANGING_HOTSWAP_FRANKLIN_TO_TREVOR
|
|
CASE HANGING_HOTSWAP_MICHAEL_TO_TREVOR
|
|
//SET_GAMEPLAY_CAM_MAX_MOTION_BLUR_STRENGTH_THIS_UPDATE(0.0)
|
|
BOOL bSwitchToTrevorComplete
|
|
bSwitchToTrevorComplete = FALSE
|
|
IF hangingHotswapState = HANGING_HOTSWAP_FRANKLIN_TO_TREVOR
|
|
bSwitchToTrevorComplete = DO_MISSION_HOTSWAP(SELECTOR_PED_TREVOR, FALSE, TRUE, HOTSWAP_CAM_FRANKLIN_TO_CHOPPER)
|
|
ELSE
|
|
bSwitchToTrevorComplete = DO_MISSION_HOTSWAP(SELECTOR_PED_TREVOR, FALSE, TRUE, HOTSWAP_CAM_OUTSIDE_CHOPPER)
|
|
ENDIF
|
|
|
|
iBlockMichaelShootTime = GET_GAME_TIMER() + 500
|
|
IF NOT IS_PED_INJURED(GET_MICHAEL_PED())
|
|
IF currentMissionStage = STAGE_DROPOFF
|
|
OR NOT bSwitchToFirstPerson
|
|
SET_PED_RESET_FLAG(GET_MICHAEL_PED(), PRF_BlockWeaponFire, TRUE)
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF bSwitchToTrevorComplete
|
|
|
|
RESET_CHOPPER_PED_DAMAGE_ENTITY()
|
|
|
|
//SET_SELECTOR_PED_HINT(sSelectorPeds, SELECTOR_PED_MICHAEL, FALSE)
|
|
//SET_SELECTOR_PED_HINT(sSelectorPeds, SELECTOR_PED_FRANKLIN, FALSE)
|
|
//SET_SELECTOR_PED_HINT(sSelectorPeds, SELECTOR_PED_TREVOR, FALSE)
|
|
IF currentMissionStage = STAGE_CHOPPER_CHASE
|
|
SET_SELECTOR_PED_BLOCKED(sSelectorPeds, SELECTOR_PED_FRANKLIN, FALSE)
|
|
ENDIF
|
|
SET_SELECTOR_PED_BLOCKED(sSelectorPeds, SELECTOR_PED_MICHAEL, FALSE)
|
|
SET_SELECTOR_PED_BLOCKED(sSelectorPeds, SELECTOR_PED_TREVOR, FALSE)
|
|
|
|
IF IS_VEHICLE_DRIVEABLE(enemyChopperVehicle[2])
|
|
// selector priority
|
|
SET_SELECTOR_PED_PRIORITY(sSelectorPeds, SELECTOR_PED_FRANKLIN, SELECTOR_PED_MICHAEL, SELECTOR_PED_TREVOR)
|
|
ELSE
|
|
// selector priority
|
|
SET_SELECTOR_PED_PRIORITY(sSelectorPeds, SELECTOR_PED_MICHAEL, SELECTOR_PED_TREVOR, SELECTOR_PED_FRANKLIN)
|
|
ENDIF
|
|
//
|
|
IF NOT IS_PED_INJURED(sSelectorPeds.pedID[SELECTOR_PED_FRANKLIN])
|
|
SET_RAGDOLL_BLOCKING_FLAGS(sSelectorPeds.pedID[SELECTOR_PED_FRANKLIN], RBF_PLAYER_IMPACT)
|
|
ENDIF
|
|
|
|
SET_FAR_DRAW_VEHICLES(FALSE)
|
|
CASCADE_SHADOWS_SET_CASCADE_BOUNDS_SCALE(CASCADE_SHADOWS_MULTIPLIER_NO_OVERRIDE)
|
|
CASCADE_SHADOWS_SET_AIRCRAFT_MODE(TRUE)
|
|
|
|
michaelTargetPed = NULL
|
|
michaelTargetVehicle = NULL
|
|
|
|
DESTROY_MISSION_STATIC_CAM(staticCam)
|
|
SET_MOTIONBLUR_MAX_VEL_SCALER(g_fSavedMaxMotionBlur)
|
|
SET_TIME_SCALE(1.0)
|
|
RENDER_SCRIPT_CAMS(FALSE, FALSE)
|
|
|
|
IF IS_VEHICLE_DRIVEABLE(snatchAndGrabVehicle[SAGV_PLAYER_CHOPPER])
|
|
CLEAR_ENTITY_LAST_DAMAGE_ENTITY(snatchAndGrabVehicle[SAGV_PLAYER_CHOPPER])
|
|
ENDIF
|
|
|
|
//SCRIPT_OVERRIDES_WIND_TYPES(true,"WEATHER_TYPES_MAGDEMO_FIB2_ONBOARD_HELI_SHOOTING","WEATHER_TYPES_MAGDEMO_FIB2_ONBOARD_HELI_SHOOTING")
|
|
bClearedAutopilot = FALSE
|
|
iClearAutopilotTime = GET_GAME_TIMER() + 5000
|
|
|
|
hotswapStage = MISSION_HOTSWAP_STAGE_SELECT_CHARACTER
|
|
DISABLE_CELLPHONE(FALSE)
|
|
hangingHotswapState = HANGING_HOTSWAP_ON_TREVOR
|
|
ELSE
|
|
//[MF] Having Trevor start his heli task as soon as the switch cam starts.
|
|
IF bTrevorCachedTarget
|
|
VECTOR vChopperPos
|
|
vChopperPos = GET_ENTITY_COORDS(snatchAndGrabVehicle[SAGV_PLAYER_CHOPPER])
|
|
VECTOR vTargetPos
|
|
vTargetPos = GET_OFFSET_FROM_ENTITY_IN_WORLD_COORDS(snatchAndGrabVehicle[SAGV_PLAYER_CHOPPER], <<0,500,0>>)
|
|
vTargetPos.Z = vChopperPos.z
|
|
TASK_TREVOR_MISSION(vTargetPos, GET_ENTITY_SPEED(snatchAndGrabVehicle[SAGV_PLAYER_CHOPPER]), fTrevorDist, -1, FLOOR(vChopperPos.z), 1, TRUE)
|
|
ENDIF
|
|
bTrevorCachedTarget = FALSE
|
|
|
|
ENDIF
|
|
BREAK
|
|
CASE HANGING_HOTSWAP_FRANKLIN_TO_MICHAEL
|
|
CASE HANGING_HOTSWAP_TREVOR_TO_MICHAEL
|
|
//SET_GAMEPLAY_CAM_MAX_MOTION_BLUR_STRENGTH_THIS_UPDATE(0.0)
|
|
|
|
//SET_GAMEPLAY_CAM_RELATIVE_HEADING(45.0)
|
|
|
|
BOOL bSwitchToMichaelComplete
|
|
bSwitchToMichaelComplete = FALSE
|
|
IF hangingHotswapState = HANGING_HOTSWAP_FRANKLIN_TO_MICHAEL
|
|
bSwitchToMichaelComplete = DO_MISSION_HOTSWAP(SELECTOR_PED_MICHAEL, FALSE, TRUE, HOTSWAP_CAM_FRANKLIN_TO_CHOPPER)
|
|
ELSE
|
|
IF NOT bSwitchToFirstPerson
|
|
bSwitchToMichaelComplete = DO_MISSION_HOTSWAP(SELECTOR_PED_MICHAEL, FALSE, TRUE, HOTSWAP_CAM_INSIDE_CHOPPER)
|
|
ELSE
|
|
TAKE_CONTROL_OF_PED_FLAGS switchFlags
|
|
switchFlags = TCF_NONE
|
|
IF GET_SCRIPT_TASK_STATUS(GET_MICHAEL_PED(), SCRIPT_TASK_DRIVE_BY) <> FINISHED_TASK
|
|
switchFlags = TCF_CLEAR_TASK_INTERRUPT_CHECKS
|
|
ENDIF
|
|
|
|
bSwitchToMichaelComplete = DO_MISSION_HOTSWAP(SELECTOR_PED_MICHAEL, FALSE, TRUE, HOTSWAP_CAM_INSIDE_CHOPPER, switchFlags)
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF currentMissionStage = STAGE_CHOPPER_CHASE
|
|
iBlockMichaelShootTime = GET_GAME_TIMER() + 500
|
|
ELSE
|
|
iBlockMichaelShootTime = GET_GAME_TIMER() + 1000
|
|
ENDIF
|
|
IF NOT IS_PED_INJURED(GET_MICHAEL_PED())
|
|
IF currentMissionStage = STAGE_DROPOFF
|
|
OR NOT bSwitchToFirstPerson
|
|
SET_PED_RESET_FLAG(GET_MICHAEL_PED(), PRF_BlockWeaponFire, TRUE)
|
|
ENDIF
|
|
ENDIF
|
|
|
|
//CLEAR_PED_TASKS(GET_MICHAEL_PED())
|
|
|
|
IF NOT bTrevorToMichaelHeliSwitch_TrevorTasked
|
|
IF hangingHotswapState = HANGING_HOTSWAP_TREVOR_TO_MICHAEL
|
|
VECTOR vChopperPos
|
|
IF IS_VEHICLE_DRIVEABLE(snatchAndGrabVehicle[SAGV_PLAYER_CHOPPER])
|
|
vChopperPos = GET_ENTITY_COORDS(snatchAndGrabVehicle[SAGV_PLAYER_CHOPPER])
|
|
TASK_TREVOR_MISSION(GET_OFFSET_FROM_ENTITY_IN_WORLD_COORDS(snatchAndGrabVehicle[SAGV_PLAYER_CHOPPER], <<0,100,0>>), 40, 10, -1, FLOOR(vChopperPos.z), 10)
|
|
bTrevorToMichaelHeliSwitch_TrevorTasked = true
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
|
|
|
|
IF GET_CURRENT_PLAYER_PED_ENUM() = CHAR_MICHAEL
|
|
BOOL bSetForceAim
|
|
bSetForceAim = FALSE
|
|
IF DOES_CAM_EXIST(scsSwitch_Heli_TrevorToMichael.ciSpline)
|
|
OR DOES_CAM_EXIST(scsSwitch_FranklinToHeli_Mike.ciSpline)
|
|
IF DOES_CAM_EXIST(scsSwitch_Heli_TrevorToMichael.ciSpline)
|
|
IF GET_CAM_SPLINE_PHASE(scsSwitch_Heli_TrevorToMichael.ciSpline) >= 0.0//0.99
|
|
bSetForceAim = TRUE
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF DOES_CAM_EXIST(scsSwitch_FranklinToHeli_Mike.ciSpline)
|
|
IF GET_CAM_SPLINE_PHASE(scsSwitch_FranklinToHeli_Mike.ciSpline) >= 0.0
|
|
bSetForceAim = TRUE
|
|
ENDIF
|
|
ENDIF
|
|
ELSE
|
|
bSetForceAim = TRUE //[MF] This is needed to always be true or else Michael starts firing randomly
|
|
ENDIF
|
|
|
|
IF hangingHotswapState = HANGING_HOTSWAP_TREVOR_TO_MICHAEL
|
|
bSetForceAim = TRUE
|
|
ENDIF
|
|
|
|
IF bSetForceAim
|
|
SET_PLAYER_FORCED_AIM(PLAYER_ID(), TRUE)
|
|
SET_PLAYER_FORCE_SKIP_AIM_INTRO(PLAYER_ID(), TRUE)
|
|
ELSE
|
|
SET_PLAYER_FORCED_AIM(PLAYER_ID(), FALSE)
|
|
ENDIF
|
|
|
|
FLOAT fSetCamHeading
|
|
FLOAT fSetCamPitch
|
|
|
|
IF IS_VEHICLE_DRIVEABLE(enemyChopperVehicle[iLeadHeli])
|
|
// VECTOR vTargetVector
|
|
FLOAT fTargetHeading
|
|
FLOAT fTargetPitch
|
|
// vTargetVector = GET_ENTITY_COORDS(enemyChopperVehicle[iLeadHeli]) - GET_ENTITY_COORDS(PLAYER_PED_ID())
|
|
|
|
// fTargetHeading = GET_HEADING_FROM_VECTOR_2D(vTargetVector.x, vTargetVector.y) - GET_ENTITY_HEADING(PLAYER_PED_ID())
|
|
// IF fTargetHeading > 360.0
|
|
// fTargetHeading -= 360.0
|
|
// ELIF fTargetHeading < 0.0
|
|
// fTargetHeading += 360.0
|
|
// ENDIF
|
|
// IF fTargetHeading > 180
|
|
// IF fTargetHeading > 270
|
|
// fTargetHeading = 0
|
|
// ELSE
|
|
// fTargetHeading = 180
|
|
// ENDIF
|
|
// ENDIF
|
|
|
|
// #IF IS_DEBUG_BUILD
|
|
// IF fDEBUG_OverrideMichaelAim > -1.0
|
|
// fTargetHeading = fDEBUG_OverrideMichaelAim
|
|
// ENDIF
|
|
// #ENDIF
|
|
|
|
//[MF] forcing Michael to always be facing this heading. Otherwise there are some nasty camera issues that can occur if helis are crossing from a valid to an invalid aim point.
|
|
fTargetHeading = fSwitchToMike_AimingHeading
|
|
|
|
//fTargetPitch = GET_HEADING_FROM_VECTOR_2D(vTargetVector.y, vTargetVector.z) - 90.0 - GET_ENTITY_ROLL(PLAYER_PED_ID())
|
|
VECTOR vOffset
|
|
FLOAT fHorizontalDist
|
|
FLOAT fVerticalDist
|
|
vOffset = GET_OFFSET_FROM_ENTITY_GIVEN_WORLD_COORDS(PLAYER_PED_ID(), GET_ENTITY_COORDS(enemyChopperVehicle[iLeadHeli]))
|
|
fHorizontalDist = GET_DISTANCE_BETWEEN_ENTITIES(PLAYER_PED_ID(), enemyChopperVehicle[iLeadHeli], FALSE)
|
|
fVerticalDist = vOffset.z
|
|
|
|
fTargetPitch = ATAN(fVerticalDist/fHorizontalDist)
|
|
|
|
//PRINTSTRING("target pitch = ") PRINTFLOAT(fTargetPitch) PRINTNL()
|
|
|
|
fSetCamHeading = fTargetHeading
|
|
fSetCamPitch = fTargetPitch
|
|
|
|
//[MF] Limiting Michael's pitch as well to resolve camera issues
|
|
IF fTargetPitch > 7.0
|
|
fTargetPitch = 7.0
|
|
ELIF fTargetPitch < -7.0
|
|
fTargetPitch = -7.0
|
|
ENDIF
|
|
|
|
ELSE
|
|
fSetCamHeading = fSwitchToMike_AimingHeading
|
|
fSetCamPitch = 0.0
|
|
ENDIF
|
|
|
|
//printstring("final pitch = ") printfloat(fSetCamPitch) PRINTNL()
|
|
IF GET_SCRIPT_TASK_STATUS(PLAYER_PED_ID(), SCRIPT_TASK_DRIVE_BY) <> FINISHED_TASK
|
|
OR NOT bSwitchToFirstPerson
|
|
SET_GAMEPLAY_CAM_RELATIVE_HEADING(fSetCamHeading)
|
|
SET_GAMEPLAY_CAM_RELATIVE_PITCH(fSetCamPitch)
|
|
ELSE
|
|
SET_GAMEPLAY_CAM_RELATIVE_HEADING(30)
|
|
SET_GAMEPLAY_CAM_RELATIVE_PITCH(0)
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF bSwitchToMichaelComplete
|
|
//SET_SELECTOR_PED_HINT(sSelectorPeds, SELECTOR_PED_FRANKLIN, FALSE)
|
|
//SET_SELECTOR_PED_HINT(sSelectorPeds, SELECTOR_PED_MICHAEL, FALSE)
|
|
//SET_SELECTOR_PED_HINT(sSelectorPeds, SELECTOR_PED_TREVOR, FALSE)
|
|
IF currentMissionStage = STAGE_CHOPPER_CHASE
|
|
SET_SELECTOR_PED_BLOCKED(sSelectorPeds, SELECTOR_PED_FRANKLIN, FALSE)
|
|
ENDIF
|
|
SET_SELECTOR_PED_BLOCKED(sSelectorPeds, SELECTOR_PED_MICHAEL, FALSE)
|
|
SET_SELECTOR_PED_BLOCKED(sSelectorPeds, SELECTOR_PED_TREVOR, FALSE)
|
|
|
|
IF IS_VEHICLE_DRIVEABLE(enemyChopperVehicle[2])
|
|
// selector priority
|
|
SET_SELECTOR_PED_PRIORITY(sSelectorPeds, SELECTOR_PED_FRANKLIN, SELECTOR_PED_MICHAEL, SELECTOR_PED_TREVOR)
|
|
else
|
|
// selector priority
|
|
SET_SELECTOR_PED_PRIORITY(sSelectorPeds, SELECTOR_PED_MICHAEL, SELECTOR_PED_TREVOR, SELECTOR_PED_FRANKLIN)
|
|
endif
|
|
|
|
IF IS_VEHICLE_DRIVEABLE(snatchAndGrabVehicle[SAGV_PLAYER_CHOPPER])
|
|
CLEAR_ENTITY_LAST_DAMAGE_ENTITY(snatchAndGrabVehicle[SAGV_PLAYER_CHOPPER])
|
|
ENDIF
|
|
|
|
IF NOT IS_PED_INJURED(sSelectorPeds.pedID[SELECTOR_PED_FRANKLIN])
|
|
SET_RAGDOLL_BLOCKING_FLAGS(sSelectorPeds.pedID[SELECTOR_PED_FRANKLIN], RBF_PLAYER_IMPACT)
|
|
ENDIF
|
|
|
|
//CASCADE_SHADOWS_SET_CASCADE_BOUNDS_SCALE(2.0)
|
|
//CASCADE_SHADOWS_SET_AIRCRAFT_MODE(TRUE)
|
|
|
|
CASCADE_SHADOWS_SET_CASCADE_BOUNDS_SCALE(CASCADE_SHADOWS_MULTIPLIER_NO_OVERRIDE)
|
|
CASCADE_SHADOWS_SET_AIRCRAFT_MODE(TRUE)
|
|
SET_FAR_DRAW_VEHICLES(TRUE)
|
|
|
|
RESET_CHOPPER_PED_DAMAGE_ENTITY()
|
|
|
|
//CLEAR_PED_TASKS(PLAYER_PED_ID())
|
|
//SET_PLAYER_FORCE_SKIP_AIM_INTRO(PLAYER_ID(), TRUE)
|
|
//SET_PLAYER_FORCED_AIM(PLAYER_ID(), TRUE)
|
|
|
|
SET_CURRENT_PED_WEAPON(PLAYER_PED_ID(), GET_SNATCH_AND_GRAB_WEAPON_TYPE(SAG_WEAPON_MICHAEL_RIFLE), TRUE)
|
|
IF GET_AMMO_IN_PED_WEAPON(PLAYER_PED_ID(), GET_SNATCH_AND_GRAB_WEAPON_TYPE(SAG_WEAPON_MICHAEL_RIFLE)) = 0
|
|
SET_PED_AMMO(PLAYER_PED_ID(), GET_SNATCH_AND_GRAB_WEAPON_TYPE(SAG_WEAPON_MICHAEL_RIFLE), 1)
|
|
ENDIF
|
|
|
|
SET_PED_INFINITE_AMMO(PLAYER_PED_ID(), TRUE, GET_SNATCH_AND_GRAB_WEAPON_TYPE(SAG_WEAPON_MICHAEL_RIFLE))
|
|
SET_PED_INFINITE_AMMO_CLIP(PLAYER_PED_ID(), TRUE)
|
|
|
|
//SET_PLAYER_FORCED_AIM(PLAYER_ID(), TRUE)
|
|
//PRINTSTRING("setting rifle as current from CHOPPER CHASE SWITCH!") PRINTNL()
|
|
|
|
SET_MOTIONBLUR_MAX_VEL_SCALER(g_fSavedMaxMotionBlur)
|
|
SET_TIME_SCALE(1.0)
|
|
|
|
hotswapStage = MISSION_HOTSWAP_STAGE_SELECT_CHARACTER
|
|
//SCRIPT_OVERRIDES_WIND_TYPES(true,"WEATHER_TYPES_MAGDEMO_FIB2_ONBOARD_HELI_SHOOTING","WEATHER_TYPES_MAGDEMO_FIB2_ONBOARD_HELI_SHOOTING")
|
|
// DISABLE_CELLPHONE(TRUE)
|
|
hangingHotswapState = HANGING_HOTSWAP_ON_MICHAEL
|
|
|
|
bTrevorToMichaelHeliSwitch_TrevorTasked = FALSE
|
|
ELSE
|
|
IF NOT bDoneReattach
|
|
IF GET_CURRENT_PLAYER_PED_ENUM() = CHAR_MICHAEL
|
|
IF NOT bKnockedOff
|
|
//ATTACH_MICHAEL_TO_ROPE()
|
|
bDoneReattach = TRUE
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
BREAK
|
|
CASE HANGING_HOTSWAP_MICHAEL_TO_FRANKLIN
|
|
CASE HANGING_HOTSWAP_TREVOR_TO_FRANKLIN
|
|
BOOL bSwitchToFranklinComplete
|
|
bSwitchToFranklinComplete = FALSE
|
|
|
|
bSwitchToFranklinComplete = DO_MISSION_HOTSWAP(SELECTOR_PED_FRANKLIN, FALSE, TRUE, HOTSWAP_CAM_CHOPPER_TO_FRANKLIN, TCF_CLEAR_TASK_INTERRUPT_CHECKS)
|
|
|
|
IF bSwitchToFranklinComplete
|
|
// clear michael driveby
|
|
IF currentMissionStage >= STAGE_CHOPPER_CHASE
|
|
IF NOT IS_PED_INJURED(sSelectorPeds.pedID[SELECTOR_PED_MICHAEL])
|
|
TASK_PAUSE(sSelectorPeds.pedID[SELECTOR_PED_MICHAEL], 100)
|
|
ENDIF
|
|
ENDIF
|
|
|
|
//SET_REMOTE_SNIPER_ACTIVE(remoteSniperData, TRUE)
|
|
// UPDATE_REMOTE_SNIPER(remoteSniperData)
|
|
//SET_SELECTOR_PED_HINT(sSelectorPeds, SELECTOR_PED_MICHAEL, FALSE)
|
|
//SET_SELECTOR_PED_HINT(sSelectorPeds, SELECTOR_PED_FRANKLIN, FALSE)
|
|
//SET_SELECTOR_PED_HINT(sSelectorPeds, SELECTOR_PED_TREVOR, FALSE)
|
|
IF currentMissionStage = STAGE_CHOPPER_CHASE
|
|
SET_SELECTOR_PED_BLOCKED(sSelectorPeds, SELECTOR_PED_FRANKLIN, FALSE)
|
|
ENDIF
|
|
SET_SELECTOR_PED_BLOCKED(sSelectorPeds, SELECTOR_PED_MICHAEL, FALSE)
|
|
SET_SELECTOR_PED_BLOCKED(sSelectorPeds, SELECTOR_PED_TREVOR, FALSE)
|
|
|
|
IF IS_VEHICLE_DRIVEABLE(enemyChopperVehicle[2])
|
|
IF bChangedPriorityFromSniperToTrevor
|
|
SET_SELECTOR_PED_PRIORITY(sSelectorPeds, SELECTOR_PED_FRANKLIN, SELECTOR_PED_TREVOR, SELECTOR_PED_MICHAEL)
|
|
ELSE
|
|
// selector priority
|
|
SET_SELECTOR_PED_PRIORITY(sSelectorPeds, SELECTOR_PED_FRANKLIN, SELECTOR_PED_MICHAEL, SELECTOR_PED_TREVOR)
|
|
ENDIF
|
|
ELSE
|
|
IF bChangedPriorityFromSniperToTrevor
|
|
SET_SELECTOR_PED_PRIORITY(sSelectorPeds, SELECTOR_PED_TREVOR, SELECTOR_PED_MICHAEL, SELECTOR_PED_FRANKLIN)
|
|
ELSE
|
|
// selector priority
|
|
SET_SELECTOR_PED_PRIORITY(sSelectorPeds, SELECTOR_PED_MICHAEL, SELECTOR_PED_TREVOR, SELECTOR_PED_FRANKLIN)
|
|
ENDIF
|
|
ENDIF
|
|
//IF NOT IS_PED_INJURED(PLAYER_PED_ID())
|
|
// SET_ENTITY_COORDS(PLAYER_PED_ID(), GET_SNATCH_AND_GRAB_VECTOR(SAGVEC_BEHIND_SNIPER))
|
|
// FREEZE_ENTITY_POSITION(PLAYER_PED_ID(), TRUE)
|
|
//ENDIF
|
|
IF NOT IS_PED_INJURED(prisonerPed)
|
|
SET_ENTITY_PROOFS(prisonerPed, FALSE, FALSE, FALSE, FALSE, FALSE)
|
|
ENDIF
|
|
|
|
SET_FAR_DRAW_VEHICLES(FALSE)
|
|
CASCADE_SHADOWS_SET_AIRCRAFT_MODE(FALSE)
|
|
CASCADE_SHADOWS_SET_CASCADE_BOUNDS_SCALE(CASCADE_SHADOWS_MULTIPLIER_EXTERIOR_OVERRIDE)
|
|
RESET_CHOPPER_PED_DAMAGE_ENTITY()
|
|
CLEAR_ENTITY_LAST_DAMAGE_ENTITY(snatchAndGrabVehicle[SAGV_PLAYER_CHOPPER])
|
|
|
|
SET_MOTIONBLUR_MAX_VEL_SCALER(g_fSavedMaxMotionBlur)
|
|
|
|
//CLEAR_PED_TASKS_IMMEDIATELY(PLAYER_PED_ID())
|
|
CLEAR_RAGDOLL_BLOCKING_FLAGS(PLAYER_PED_ID(), RBF_PLAYER_IMPACT)
|
|
SET_ENTITY_SHOULD_FREEZE_WAITING_ON_COLLISION(PLAYER_PED_ID(), FALSE)
|
|
FREEZE_FRANKLIN_AT_SNIPER(FALSE)
|
|
SET_CURRENT_PED_WEAPON(PLAYER_PED_ID(), GET_SNATCH_AND_GRAB_WEAPON_TYPE(SAG_WEAPON_SNIPER_RIFLE), TRUE)
|
|
//SET_PLAYER_FORCED_AIM(PLAYER_ID(), TRUE)
|
|
PRINTSTRING("setting rifle as current from CHOPPER CHASE SWITCH!") PRINTNL()
|
|
|
|
//SCRIPT_OVERRIDES_WIND_TYPES(true,"WEATHER_TYPES_MAGDEMO_FIB2_FRANKLIN","WEATHER_TYPES_MAGDEMO_FIB2_FRANKLIN")
|
|
|
|
michaelTargetVehicle = NULL
|
|
|
|
iRecheckMichaelShootTime = 0
|
|
michaelTargetPed = NULL
|
|
bTrevorToFranklin_TrevorTasked = FALSE
|
|
hotswapStage = MISSION_HOTSWAP_STAGE_SELECT_CHARACTER
|
|
hangingHotswapState = HANGING_HOTSWAP_ON_FRANKLIN
|
|
ELSE
|
|
|
|
IF NOT bTrevorToFranklin_TrevorTasked
|
|
IF eCurrentBranchedSwitchState = BRANCHED_SWITCH_TREVOR_TO_FRANKLIN_ACTIVE
|
|
VECTOR vChopperPos
|
|
vChopperPos = GET_ENTITY_COORDS(snatchAndGrabVehicle[SAGV_PLAYER_CHOPPER])
|
|
VECTOR vTargetPos
|
|
|
|
vTargetPos = GET_OFFSET_FROM_ENTITY_IN_WORLD_COORDS(snatchAndGrabVehicle[SAGV_PLAYER_CHOPPER], <<0,500,0>>)
|
|
vTargetPos.Z = (vTargetPos.Z * 0.5)//[MF] Smoothing the heli movement a bit
|
|
|
|
CLEAR_PED_TASKS(GET_TREVOR_PED())
|
|
fTrevorDist = 1000
|
|
|
|
TASK_TREVOR_MISSION(vTargetPos, GET_ENTITY_SPEED(snatchAndGrabVehicle[SAGV_PLAYER_CHOPPER]), fTrevorDist, -1, FLOOR(vChopperPos.z), 1, TRUE)
|
|
bTrevorToFranklin_TrevorTasked = TRUE
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF GET_CURRENT_PLAYER_PED_ENUM() = CHAR_FRANKLIN
|
|
PRINTLN("TEST current ped is FRANKLIN enum current ped is FRANKLIN enum current ped is FRANKLIN enum current ped is FRANKLIN enum current ped is FRANKLIN enum current ped is FRANKLIN enum current ped is FRANKLIN")
|
|
|
|
SET_PLAYER_FORCE_SKIP_AIM_INTRO(PLAYER_ID(),TRUE)
|
|
DISPLAY_SNIPER_SCOPE_THIS_FRAME()
|
|
|
|
VECTOR vTargetVector
|
|
FLOAT fTargetHeading
|
|
|
|
IF IS_VEHICLE_DRIVEABLE(enemyChopperVehicle[2])
|
|
vTargetVector = GET_ENTITY_COORDS(enemyChopperVehicle[2]) - GET_ENTITY_COORDS(PLAYER_PED_ID())
|
|
fTargetHeading = GET_HEADING_FROM_VECTOR_2D(vTargetVector.x, vTargetVector.y) - GET_ENTITY_HEADING(PLAYER_PED_ID())
|
|
ELSE
|
|
fTargetHeading = 0.0
|
|
ENDIF
|
|
|
|
SET_GAMEPLAY_CAM_RELATIVE_HEADING(fTargetHeading)
|
|
SET_GAMEPLAY_CAM_RELATIVE_PITCH(5.0)
|
|
ENDIF
|
|
ENDIF
|
|
BREAK
|
|
ENDSWITCH
|
|
|
|
// fail for trevor bailing out
|
|
/*
|
|
PED_INDEX trevorPed = GET_TREVOR_PED()
|
|
IF NOT IS_PED_INJURED(trevorPed)
|
|
AND IS_VEHICLE_DRIVEABLE(snatchAndGrabVehicle[SAGV_PLAYER_CHOPPER])
|
|
IF NOT IS_PED_IN_VEHICLE(trevorPed, snatchAndGrabVehicle[SAGV_PLAYER_CHOPPER])
|
|
IF trevorPed = PLAYER_PED_ID()
|
|
MISSION_FAILED(FAIL_ABANDONED_CHOPPER)
|
|
ELSE
|
|
MISSION_FAILED(FAIL_TREVOR_ABANDONED_CHOPPER)
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
*/
|
|
|
|
|
|
IF GET_GAME_TIMER() <= iSuppressHUDTime
|
|
HIDE_SELECTOR_THIS_FRAME()
|
|
DISPLAY_RADAR(FALSE)
|
|
bTurnedOffRadarForSuppressHud = TRUE
|
|
ELSE
|
|
IF bTurnedOffRadarForSuppressHud
|
|
DISPLAY_RADAR(TRUE)
|
|
bTurnedOffRadarForSuppressHud = FALSE
|
|
ENDIF
|
|
ENDIF
|
|
|
|
// fail for knockoff
|
|
#IF IS_DEBUG_BUILD
|
|
IF NOT bDebugDontFailOnKnockoff
|
|
#ENDIF
|
|
IF NOT bAlternateChopper
|
|
AND NOT bShortRope
|
|
//HANDLE_KNOCKOFF_ON_COLLISION()
|
|
ENDIF
|
|
#IF IS_DEBUG_BUILD
|
|
ENDIF
|
|
#ENDIF
|
|
ENDPROC
|
|
|
|
// on rails section hanging under heli
|
|
PROC DO_STAGE_CHOPPER_CHASE()
|
|
DO_CHOPPER_ESCAPE_COMMON_FUNCTIONS()
|
|
|
|
//PRINTNL() PRINTINT(ENUM_TO_INT(GET_CAM_VIEW_MODE_FOR_CONTEXT(CAM_VIEW_MODE_CONTEXT_IN_VEHICLE))) PRINTNL()
|
|
|
|
IF hangingHotswapState = HANGING_HOTSWAP_ON_TREVOR
|
|
HANDLE_GET_TO_LOCATION(TRUE, FALSE, FALSE, FALSE)
|
|
ELSE
|
|
IF DOES_BLIP_EXIST(vehicleBlip)
|
|
REMOVE_BLIP(vehicleBlip)
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF NOT bFadedIn
|
|
IF GET_GAME_TIMER() >= iStartMissionStageTime + 100
|
|
IF IS_SCREEN_FADED_OUT()
|
|
DO_SCREEN_FADE_IN(DEFAULT_FADE_TIME)
|
|
ENDIF
|
|
bFadedIn = TRUE
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF NOT bUnproofedChoppers
|
|
IF GET_GAME_TIMER() >= iStartMissionStageTime + 6000
|
|
INT i
|
|
REPEAT COUNT_OF(enemyChopperVehicle) i
|
|
IF IS_VEHICLE_DRIVEABLE(enemyChopperVehicle[i])
|
|
SET_ENTITY_PROOFS(enemyChopperVehicle[i], FALSE, FALSE, FALSE, FALSE, FALSE)
|
|
SET_ENTITY_ONLY_DAMAGED_BY_PLAYER(enemyChopperVehicle[i], FALSE)
|
|
ENDIF
|
|
ENDREPEAT
|
|
PRINTSTRING("unproof") printnl()
|
|
bUnproofedChoppers = TRUE
|
|
ENDIF
|
|
ENDIF
|
|
|
|
// handle friendly blips
|
|
SWITCH GET_CURRENT_PLAYER_PED_ENUM()
|
|
CASE CHAR_FRANKLIN
|
|
IF DOES_BLIP_EXIST(franklinSniperBlip)
|
|
REMOVE_BLIP(franklinSniperBlip)
|
|
ENDIF
|
|
|
|
IF IS_VEHICLE_DRIVEABLE(snatchAndGrabVehicle[SAGV_PLAYER_CHOPPER])
|
|
IF NOT DOES_BLIP_EXIST(playerChopperBlip)
|
|
playerChopperBlip = CREATE_MISSION_BLIP_FOR_VEHICLE(snatchAndGrabVehicle[SAGV_PLAYER_CHOPPER], FALSE)
|
|
ENDIF
|
|
ELSE
|
|
IF DOES_BLIP_EXIST(playerChopperBlip)
|
|
REMOVE_BLIP(playerChopperBlip)
|
|
ENDIF
|
|
ENDIF
|
|
BREAK
|
|
|
|
CASE CHAR_MICHAEL
|
|
CASE CHAR_TREVOR
|
|
IF DOES_BLIP_EXIST(playerChopperBlip)
|
|
REMOVE_BLIP(playerChopperBlip)
|
|
ENDIF
|
|
IF NOT IS_PED_INJURED(sSelectorPeds.pedID[SELECTOR_PED_FRANKLIN])
|
|
IF NOT DOES_BLIP_EXIST(franklinSniperBlip)
|
|
IF IS_VEHICLE_DRIVEABLE(snatchAndGrabVehicle[SAGV_PLAYER_CHOPPER])
|
|
IF IS_PED_IN_VEHICLE(PLAYER_PED_ID(), snatchAndGrabVehicle[SAGV_PLAYER_CHOPPER])
|
|
franklinSniperBlip = CREATE_MISSION_BLIP_FOR_PED(sSelectorPeds.pedID[SELECTOR_PED_FRANKLIN], FALSE)
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ELSE
|
|
IF DOES_BLIP_EXIST(franklinSniperBlip)
|
|
REMOVE_BLIP(franklinSniperBlip)
|
|
ENDIF
|
|
ENDIF
|
|
BREAK
|
|
ENDSWITCH
|
|
|
|
IF NOT bShownSlowmoHelp
|
|
IF hangingHotswapState = HANGING_HOTSWAP_ON_MICHAEL
|
|
IF NOT bFilledMichaelMeter
|
|
SPECIAL_ABILITY_CHARGE_NORMALIZED(PLAYER_ID(), 0.5, TRUE)
|
|
bFilledMichaelMeter = TRUE
|
|
ENDIF
|
|
|
|
IF NOT IS_SPECIAL_ABILITY_ACTIVE(PLAYER_ID())
|
|
IF iSlowmoHelpTime < 0
|
|
iSlowmoHelpTime = GET_GAME_TIMER()
|
|
ELSE
|
|
IF GET_GAME_TIMER() >= iSlowmoHelpTime + 3000
|
|
IF IS_USING_KEYBOARD_AND_MOUSE(PLAYER_CONTROL)
|
|
bShownSlowmoHelp = DO_MISSION_HELP_TEXT("SG_SLOHLP_KM")
|
|
ELSE
|
|
bShownSlowmoHelp = DO_MISSION_HELP_TEXT("SG_SLOHLP")
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ELSE
|
|
bShownSlowmoHelp = TRUE
|
|
ENDIF
|
|
ELSE
|
|
iSlowmoHelpTime = -1
|
|
ENDIF
|
|
ELSE
|
|
IF hangingHotswapState <> HANGING_HOTSWAP_ON_MICHAEL
|
|
OR IS_SPECIAL_ABILITY_ACTIVE(PLAYER_ID())
|
|
IF IS_THIS_HELP_MESSAGE_BEING_DISPLAYED("SG_SLOHLP")
|
|
CLEAR_HELP()
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
|
|
BOOL bFranklinInDanger = FALSE
|
|
BOOL bMichaelTrevorInDanger = FALSE
|
|
IF hangingHotswapState <> HANGING_HOTSWAP_ON_FRANKLIN
|
|
AND hangingHotswapState <> HANGING_HOTSWAP_MICHAEL_TO_FRANKLIN
|
|
AND hangingHotswapState <> HANGING_HOTSWAP_TREVOR_TO_FRANKLIN
|
|
IF hangingHotswapState = HANGING_HOTSWAP_ON_TREVOR
|
|
OR hangingHotswapState = HANGING_HOTSWAP_ON_MICHAEL
|
|
IF DOES_BLIP_EXIST(enemyChopperBlip[2])
|
|
IF bDonePanicSpeech
|
|
bFranklinInDanger = TRUE
|
|
|
|
BOOL bApplyDeath = FALSE
|
|
IF GET_GAME_TIMER() >= iFranklinDeathTime + 10000
|
|
bApplyDeath = TRUE
|
|
ELSE
|
|
IF GET_GAME_TIMER() >= iFranklinDeathTime
|
|
IF NOT IS_PED_INJURED(sSelectorPeds.pedID[SELECTOR_PED_FRANKLIN])
|
|
IF IS_EXPLOSION_IN_AREA(EXP_TAG_DONTCARE, GET_ENTITY_COORDS(sSelectorPeds.pedID[SELECTOR_PED_FRANKLIN]) - <<8,8,8>>, GET_ENTITY_COORDS(sSelectorPeds.pedID[SELECTOR_PED_FRANKLIN]) + <<8,8,8>>)
|
|
bApplyDeath = TRUE
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
|
|
#IF IS_DEBUG_BUILD
|
|
IF NOT bSwitchCamDebugScenarioEnabled
|
|
#ENDIF
|
|
IF bApplyDeath
|
|
IF NOT IS_PED_INJURED(GET_FRANKLIN_PED())
|
|
APPLY_DAMAGE_TO_PED(GET_FRANKLIN_PED(), 1000, TRUE)
|
|
ENDIF
|
|
//MISSION_FAILED(FAIL_FRANKLIN_DEAD)
|
|
ENDIF
|
|
#IF IS_DEBUG_BUILD
|
|
ENDIF
|
|
#ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ELSE
|
|
/*
|
|
IF IS_THIS_HELP_MESSAGE_BEING_DISPLAYED("SG_TROHLP")
|
|
OR IS_THIS_HELP_MESSAGE_BEING_DISPLAYED("SG_TROHLP3")
|
|
IF GET_GAME_TIMER() >= iClearHelpTime + 1000
|
|
CLEAR_HELP(FALSE)
|
|
iClearHelpTime = GET_GAME_TIMER()
|
|
ENDIF
|
|
ENDIF
|
|
*/
|
|
IF (NOT DOES_BLIP_EXIST(enemyChopperBlip[2]) AND bDoneTrevorEncourageSpeech)
|
|
OR bDoneWeHitSpeech
|
|
bMichaelTrevorInDanger = TRUE
|
|
ENDIF
|
|
|
|
IF GET_GAME_TIMER() >= iFranklinPanicTime
|
|
iFranklinPanicTime = GET_GAME_TIMER() + 5000
|
|
ENDIF
|
|
IF bDonePanicSpeech
|
|
IF GET_GAME_TIMER() >= iFranklinDeathTime
|
|
iFranklinDeathTime = GET_GAME_TIMER() + 6000
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF bFranklinInDanger
|
|
SET_SELECTOR_PED_DAMAGED(sSelectorPeds, SELECTOR_PED_FRANKLIN, TRUE)
|
|
|
|
IF NOT bDoneTroubleFlashHelp
|
|
bDoneTroubleFlashHelp = DO_MISSION_HELP_TEXT("SG_TROHLP2", FALSE, 12500)
|
|
ENDIF
|
|
|
|
ELSE
|
|
SET_SELECTOR_PED_DAMAGED(sSelectorPeds, SELECTOR_PED_FRANKLIN, FALSE)
|
|
ENDIF
|
|
|
|
IF bMichaelTrevorInDanger
|
|
SET_SELECTOR_PED_DAMAGED(sSelectorPeds, SELECTOR_PED_TREVOR, TRUE)
|
|
SET_SELECTOR_PED_DAMAGED(sSelectorPeds, SELECTOR_PED_MICHAEL, TRUE)
|
|
IF NOT bDoneTroubleFlashHelp
|
|
bDoneTroubleFlashHelp = DO_MISSION_HELP_TEXT("SG_TROHLP2", FALSE, 12500)
|
|
ENDIF
|
|
//printstring("setting damage") printnl()
|
|
ELSE
|
|
SET_SELECTOR_PED_DAMAGED(sSelectorPeds, SELECTOR_PED_MICHAEL, FALSE)
|
|
SET_SELECTOR_PED_DAMAGED(sSelectorPeds, SELECTOR_PED_TREVOR, FALSE)
|
|
|
|
ENDIF
|
|
|
|
IF NOT bMichaelTrevorInDanger
|
|
AND NOT bFranklinInDanger
|
|
IF IS_THIS_HELP_MESSAGE_BEING_DISPLAYED("SG_TROHLP2")
|
|
IF GET_GAME_TIMER() >= iClearHelpTime + 1000
|
|
CLEAR_HELP(FALSE)
|
|
iClearHelpTime = GET_GAME_TIMER()
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
|
|
// destroy the chopper
|
|
#IF IS_DEBUG_BUILD
|
|
IF NOT bSwitchCamDebugScenarioEnabled
|
|
#ENDIF
|
|
IF hangingHotswapState = HANGING_HOTSWAP_ON_TREVOR
|
|
OR hangingHotswapState = HANGING_HOTSWAP_ON_MICHAEL
|
|
OR hangingHotswapState = HANGING_HOTSWAP_ON_FRANKLIN
|
|
IF DOES_BLIP_EXIST(enemyChopperBlip[0])
|
|
OR DOES_BLIP_EXIST(enemyChopperBlip[1])
|
|
OR DOES_BLIP_EXIST(enemyChopperBlip[3])
|
|
IF bDoneWeHitSpeech
|
|
VECTOR vPosForExplosion = GET_ENTITY_COORDS(snatchAndGrabVehicle[SAGV_PLAYER_CHOPPER])
|
|
IF (IS_EXPLOSION_IN_AREA(EXP_TAG_DONTCARE, vPosForExplosion - <<6,6,6>>, vPosForExplosion + <<6,6,6>>) AND bRocketsAccurate)
|
|
OR (bDoneWeHitSpeech AND GET_GAME_TIMER() >= iTrevorSayWeHitTime + 23000)
|
|
IF NOT IS_PED_INJURED(GET_MICHAEL_PED())
|
|
IF IS_PED_IN_VEHICLE(GET_MICHAEL_PED(), snatchAndGrabVehicle[SAGV_PLAYER_CHOPPER])
|
|
APPLY_DAMAGE_TO_PED(GET_MICHAEL_PED(), 1000, TRUE)
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF NOT IS_PED_INJURED(GET_TREVOR_PED())
|
|
IF IS_PED_IN_VEHICLE(GET_TREVOR_PED(), snatchAndGrabVehicle[SAGV_PLAYER_CHOPPER])
|
|
APPLY_DAMAGE_TO_PED(GET_TREVOR_PED(), 1000, TRUE)
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF IS_VEHICLE_DRIVEABLE(snatchAndGrabVehicle[SAGV_PLAYER_CHOPPER])
|
|
EXPLODE_VEHICLE(snatchAndGrabVehicle[SAGV_PLAYER_CHOPPER])
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
#IF IS_DEBUG_BUILD
|
|
ENDIF
|
|
#ENDIF
|
|
|
|
IF hangingHotswapState = HANGING_HOTSWAP_ON_TREVOR
|
|
IF IS_SELECTOR_ONSCREEN()
|
|
AND GET_CAM_VIEW_MODE_FOR_CONTEXT(CAM_VIEW_MODE_CONTEXT_IN_HELI) <> CAM_VIEW_MODE_FIRST_PERSON
|
|
IF NOT IS_GAMEPLAY_HINT_ACTIVE()
|
|
SET_GAMEPLAY_VEHICLE_HINT(snatchAndGrabVehicle[SAGV_PLAYER_CHOPPER], vHangOnTrevor_HintCamLookAtLoc, TRUE, iCHASE_HINT_INFINITE_DWELL_TIME, 600, 600)
|
|
SET_GAMEPLAY_HINT_FOLLOW_DISTANCE_SCALAR(fHangOnTrevor_HintCamFollowDist)
|
|
SET_GAMEPLAY_HINT_FOV(GET_GAMEPLAY_CAM_FOV())
|
|
ENDIF
|
|
ELSE
|
|
IF IS_GAMEPLAY_HINT_ACTIVE()
|
|
STOP_GAMEPLAY_HINT(FALSE)
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
|
|
// remove michael pistol
|
|
IF NOT IS_PED_INJURED(GET_MICHAEL_PED())
|
|
WEAPON_TYPE weapon
|
|
GET_CURRENT_PED_WEAPON(GET_MICHAEL_PED(), weapon)
|
|
IF weapon <> GET_SNATCH_AND_GRAB_WEAPON_TYPE(SAG_WEAPON_MICHAEL_RIFLE)
|
|
SET_CURRENT_PED_WEAPON(GET_MICHAEL_PED(), GET_SNATCH_AND_GRAB_WEAPON_TYPE(SAG_WEAPON_MICHAEL_RIFLE), TRUE)
|
|
IF GET_AMMO_IN_PED_WEAPON(GET_MICHAEL_PED(), GET_SNATCH_AND_GRAB_WEAPON_TYPE(SAG_WEAPON_MICHAEL_RIFLE)) = 0
|
|
SET_PED_AMMO(GET_MICHAEL_PED(), GET_SNATCH_AND_GRAB_WEAPON_TYPE(SAG_WEAPON_MICHAEL_RIFLE), 1)
|
|
ENDIF
|
|
SET_PED_INFINITE_AMMO(GET_MICHAEL_PED(), TRUE, GET_SNATCH_AND_GRAB_WEAPON_TYPE(SAG_WEAPON_MICHAEL_RIFLE))
|
|
SET_PED_INFINITE_AMMO_CLIP(GET_MICHAEL_PED(), TRUE)
|
|
ENDIF
|
|
ENDIF
|
|
|
|
// music for michael in chopper
|
|
IF NOT bDoneMichaelFightsChoppersCue
|
|
IF hangingHotswapState = HANGING_HOTSWAP_ON_MICHAEL
|
|
bDoneMichaelFightsChoppersCue = TRIGGER_MISSION_MUSIC_EVENT("FIB2_MICHAEL_FIGHTS_CHOPPERS")
|
|
ENDIF
|
|
ENDIF
|
|
|
|
// god text and speech stuff
|
|
IF NOT bShownGodText
|
|
OR NOT bDoneFranklinReactToChopperSpeech
|
|
IF bDoneFranklinReactToChopperSpeech
|
|
OR NOT IS_SUBTITLE_PREFERENCE_SWITCHED_ON()
|
|
IF DO_MISSION_GOD_TEXT("SG_DCHOP")
|
|
bShownGodText = TRUE
|
|
iSwitchToMichaelPromptTime = GET_GAME_TIMER() + 24000
|
|
ENDIF
|
|
ENDIF
|
|
|
|
// react to chopper attacking speech
|
|
IF NOT bDoneChopperAttackFranklinSpeech
|
|
bDoneChopperAttackFranklinSpeech = DO_MISSION_SPEECH("FBI2_RADIO")
|
|
ELSE
|
|
// react to chopper speech
|
|
IF NOT bDoneFranklinReactToChopperSpeech
|
|
bDoneFranklinReactToChopperSpeech = DO_MISSION_SPEECH("FBI2_FREACT")
|
|
ENDIF
|
|
ENDIF
|
|
ELSE
|
|
// HANDLE THE SPEECH
|
|
enumCharacterList currentChar = GET_CURRENT_PLAYER_PED_ENUM()
|
|
|
|
// speech pertaining to franklin's chopper
|
|
IF DOES_BLIP_EXIST(enemyChopperBlip[2])
|
|
// panic speech
|
|
IF hangingHotswapState <> HANGING_HOTSWAP_ON_FRANKLIN
|
|
AND hangingHotswapState <> HANGING_HOTSWAP_MICHAEL_TO_FRANKLIN
|
|
AND hangingHotswapState <> HANGING_HOTSWAP_TREVOR_TO_FRANKLIN
|
|
IF NOT bDonePanicSpeech
|
|
IF GET_GAME_TIMER() >= iFranklinPanicTime
|
|
IF DO_MISSION_SPEECH("FBI2_URGHELP")
|
|
//iDidPanicSpeechTime = GET_GAME_TIMER()
|
|
iFranklinDeathTime = GET_GAME_TIMER() + 15000
|
|
bDonePanicSpeech = TRUE
|
|
ENDIF
|
|
ENDIF
|
|
ELSE
|
|
IF NOT bDoneRealPanicSpeech
|
|
IF GET_GAME_TIMER() >= iFranklinDeathTime - 5000
|
|
bDoneRealPanicSpeech = DO_MISSION_SPEECH("FBI2_WTF")
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ELSE
|
|
// franklin congratulation speech
|
|
IF NOT bDoneDestroyedChopperSpeech[2]
|
|
bDoneDestroyedChopperSpeech[2] = DO_MISSION_SPEECH("FBI2_FSHOOT")
|
|
ELSE
|
|
IF NOT bDoneFranklinSayChopperDownSpeech
|
|
bDoneFranklinSayChopperDownSpeech = DO_MISSION_SPEECH("FBI2_FTELL")
|
|
ELSE
|
|
IF NOT bDoneTrevorCongratulateFranklinSpeech
|
|
bDoneTrevorCongratulateFranklinSpeech = DO_MISSION_SPEECH("FBI2_FGET")
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
bDoneChopperAttackFranklinSpeech = TRUE
|
|
ENDIF
|
|
|
|
// speech about almost hit
|
|
IF NOT bDoneWeHitSpeech
|
|
IF GET_GAME_TIMER() >= iTrevorSayWeHitTime
|
|
IF DOES_BLIP_EXIST(enemyChopperBlip[0])
|
|
OR DOES_BLIP_EXIST(enemyChopperBlip[1])
|
|
OR DOES_BLIP_EXIST(enemyChopperBlip[3])
|
|
IF hangingHotswapState = HANGING_HOTSWAP_ON_FRANKLIN
|
|
OR hangingHotswapState = HANGING_HOTSWAP_ON_MICHAEL
|
|
OR hangingHotswapState = HANGING_HOTSWAP_ON_TREVOR
|
|
IF DO_MISSION_SPEECH("FBI2_WEHIT")
|
|
bDoneWeHitSpeech = TRUE
|
|
iTrevorSayWeHitTime = GET_GAME_TIMER()
|
|
ENDIF
|
|
ENDIF
|
|
ELSE
|
|
bDoneWeHitSpeech = TRUE
|
|
ENDIF
|
|
ENDIF
|
|
ELSE
|
|
IF NOT bRocketsAccurate
|
|
IF GET_GAME_TIMER() >= iTrevorSayWeHitTime + 15000
|
|
bRocketsAccurate = TRUE
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF NOT bDoneTrevorEncourageSpeech
|
|
IF iAllowGoHomeTime < 0
|
|
AND NOT bFranklinInDanger
|
|
IF GET_GAME_TIMER() >= iSwitchToMichaelPromptTime AND NOT DOES_BLIP_EXIST(enemyChopperBlip[2])
|
|
//OR currentChar = CHAR_MICHAEL
|
|
//OR currentChar = CHAR_TREVOR
|
|
bDoneTrevorEncourageSpeech = DO_MISSION_SPEECH("FBI2_TAKE1")
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
|
|
// character specific stuff
|
|
IF iAllowGoHomeTime < 0
|
|
AND NOT bFranklinInDanger
|
|
IF currentChar = CHAR_MICHAEL
|
|
OR currentChar = CHAR_TREVOR
|
|
INT iMChopper
|
|
FOR iMChopper = 0 TO 1
|
|
IF NOT bDoneDestroyedChopperSpeech[iMChopper]
|
|
IF NOT DOES_BLIP_EXIST(enemyChopperBlip[iMChopper])
|
|
IF currentChar = CHAR_MICHAEL
|
|
SWITCH GET_RANDOM_INT_IN_RANGE(0,2)
|
|
CASE 0
|
|
bDoneDestroyedChopperSpeech[iMChopper] = DO_MISSION_SPEECH("FBI2_DOWN")
|
|
BREAK
|
|
CASE 1
|
|
bDoneDestroyedChopperSpeech[iMChopper] = DO_MISSION_SPEECH("FBI2_SPIN")
|
|
BREAK
|
|
ENDSWITCH
|
|
ELSE
|
|
bDoneDestroyedChopperSpeech[iMChopper] = DO_MISSION_SPEECH("FBI2_DOWN1")
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDFOR
|
|
|
|
// michael and trevor randomness
|
|
IF GET_GAME_TIMER() >= iNextMrKSpeechTime
|
|
IF iMrKSpeechStage < 5
|
|
STRING sMrKSpeech
|
|
sMrKSpeech=sMrKSpeech
|
|
SWITCH iMrKSpeechStage
|
|
CASE 0
|
|
sMrKSpeech = "FBI2_HANG1"
|
|
BREAK
|
|
CASE 1
|
|
sMrKSpeech = "FBI2_HANG2"
|
|
BREAK
|
|
CASE 2
|
|
sMrKSpeech = "FBI2_HANG3"
|
|
BREAK
|
|
CASE 3
|
|
sMrKSpeech = "FBI2_HANG4"
|
|
BREAK
|
|
CASE 4
|
|
sMrKSpeech = "FBI2_HANG5"
|
|
BREAK
|
|
ENDSWITCH
|
|
|
|
//iNextMrKSpeechTime = GET_GAME_TIMER() + GET_RANDOM_INT_IN_RANGE(10000, 12000)
|
|
IF DO_MISSION_SPEECH(sMrKSpeech)
|
|
iNextMrKSpeechTime = GET_GAME_TIMER() + GET_RANDOM_INT_IN_RANGE(14000, 18000)
|
|
iMrKSpeechStage++
|
|
ENDIF
|
|
ENDIF
|
|
ELSE
|
|
IF DOES_BLIP_EXIST(enemyChopperBlip[0])
|
|
AND DOES_BLIP_EXIST(enemyChopperBlip[1])
|
|
AND DOES_BLIP_EXIST(enemyChopperBlip[3])
|
|
IF GET_RANDOM_INT_IN_RANGE(0,2) = 0
|
|
DO_RANDOM_SPEECH("FBI2_TAKE3")
|
|
ELSE
|
|
IF NOT IS_PED_INJURED(GET_MICHAEL_PED())
|
|
IF IS_PED_SHOOTING(GET_MICHAEL_PED())
|
|
DO_RANDOM_SPEECH("FBI2_SHOTC")
|
|
ELSE
|
|
DO_RANDOM_SPEECH("FBI2_CHASE")
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ELSE
|
|
IF NOT bDoneLastOneSpeech
|
|
IF bCreatedExtraHeli
|
|
IF (DOES_BLIP_EXIST(enemyChopperBlip[0]) AND NOT DOES_BLIP_EXIST(enemyChopperBlip[1]) AND NOT DOES_BLIP_EXIST(enemyChopperBlip[3]))
|
|
OR (DOES_BLIP_EXIST(enemyChopperBlip[1]) AND NOT DOES_BLIP_EXIST(enemyChopperBlip[0]) AND NOT DOES_BLIP_EXIST(enemyChopperBlip[3]))
|
|
OR (DOES_BLIP_EXIST(enemyChopperBlip[3]) AND NOT DOES_BLIP_EXIST(enemyChopperBlip[0]) AND NOT DOES_BLIP_EXIST(enemyChopperBlip[1]))
|
|
bDoneLastOneSpeech = DO_MISSION_SPEECH("FBI2_TAKEOUT")
|
|
ENDIF
|
|
ENDIF
|
|
ELSE
|
|
IF GET_RANDOM_INT_IN_RANGE(0,2) = 0
|
|
DO_RANDOM_SPEECH("FBI2_TAKE3")
|
|
ELSE
|
|
IF NOT IS_PED_INJURED(GET_MICHAEL_PED())
|
|
IF IS_PED_SHOOTING(GET_MICHAEL_PED())
|
|
DO_RANDOM_SPEECH("FBI2_SHOTC")
|
|
ELSE
|
|
DO_RANDOM_SPEECH("FBI2_CHASE")
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ELSE
|
|
// franklin
|
|
IF DOES_BLIP_EXIST(enemyChopperBlip[2])
|
|
IF NOT bDoneRocketReactionSpeech
|
|
IF GET_GAME_TIMER() >= iLastEnemyRocketsTime + 3000
|
|
IF DO_MISSION_SPEECH("FBI2_ROCKETS")
|
|
bDoneRocketReactionSpeech = TRUE
|
|
iTrevorRemindFranklinTime = GET_GAME_TIMER() + 23000
|
|
iNextFranklinRocketReactionTime = GET_GAME_TIMER() + 8000
|
|
ENDIF
|
|
ENDIF
|
|
ELSE
|
|
IF GET_GAME_TIMER() >= iNextFranklinRocketReactionTime
|
|
IF GET_GAME_TIMER() <= iLastEnemyRocketsTime + 3500
|
|
AND GET_GAME_TIMER() >= iLastEnemyRocketsTime + 1000
|
|
IF DO_MISSION_SPEECH("FBI2_FIRED")
|
|
iNextFranklinRocketReactionTime = GET_GAME_TIMER() + GET_RANDOM_INT_IN_RANGE(13000, 16000)
|
|
ENDIF
|
|
ENDIF
|
|
ELSE
|
|
IF NOT bDoneTrevorRemindFranklinSpeech
|
|
IF bDoneRocketReactionSpeech
|
|
IF GET_GAME_TIMER() >= iTrevorRemindFranklinTime
|
|
bDoneTrevorRemindFranklinSpeech = DO_MISSION_SPEECH("FBI2_2RADIO")
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF GET_RANDOM_INT_IN_RANGE(0,2) = 0
|
|
DO_RANDOM_SPEECH("FBI2_FSHOT")
|
|
ELSE
|
|
IF NOT IS_PED_INJURED(enemyChopperPed[0])
|
|
DO_RANDOM_SPEECH("FBI2_ATTACK")
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
|
|
// friendly fire
|
|
IF IS_VEHICLE_DRIVEABLE(snatchAndGrabVehicle[SAGV_PLAYER_CHOPPER])
|
|
IF NOT bCuedFriendlyFireSpeech
|
|
IF HAS_ENTITY_BEEN_DAMAGED_BY_ENTITY(snatchAndGrabVehicle[SAGV_PLAYER_CHOPPER], PLAYER_PED_ID())
|
|
IF GET_GAME_TIMER() >= iNextFriendlyFireSpeechTime
|
|
iCueFriendlyFireSpeechTime = GET_GAME_TIMER()
|
|
bCuedFriendlyFireSpeech = TRUE
|
|
ENDIF
|
|
ENDIF
|
|
ELSE
|
|
IF DO_MISSION_SPEECH("FBI2_FRFIRE")
|
|
CLEAR_ENTITY_LAST_DAMAGE_ENTITY(snatchAndGrabVehicle[SAGV_PLAYER_CHOPPER])
|
|
bCuedFriendlyFireSpeech = FALSE
|
|
iNextFriendlyFireSpeechTime = GET_GAME_TIMER() + 18000
|
|
ELSE
|
|
IF GET_GAME_TIMER() >= iCueFriendlyFireSpeechTime + 3000
|
|
CLEAR_ENTITY_LAST_DAMAGE_ENTITY(snatchAndGrabVehicle[SAGV_PLAYER_CHOPPER])
|
|
bCuedFriendlyFireSpeech = FALSE
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF NOT bDoneChopperLandSpeech
|
|
IF NOT IS_PED_INJURED(enemyChopperPed[0])
|
|
//OR DOES_BLIP_EXIST(enemyChopperBlip[1])
|
|
//OR DOES_BLIP_EXIST(enemyChopperBlip[2])
|
|
bDoneChopperLandSpeech = DO_MISSION_SPEECH("FBI2_WARN1")
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
|
|
// franklin gameplay
|
|
PED_INDEX franklinPed = GET_FRANKLIN_PED()
|
|
IF NOT IS_PED_INJURED(franklinPed)
|
|
IF hangingHotswapState = HANGING_HOTSWAP_ON_FRANKLIN
|
|
SET_ENTITY_PROOFS(franklinPed, FALSE, FALSE, FALSE, FALSE, FALSE)
|
|
SET_ENTITY_CAN_BE_DAMAGED_BY_RELATIONSHIP_GROUP(franklinPed, TRUE, agencyRelGroup)
|
|
//SET_ENTITY_HEALTH(franklinPed, 200)
|
|
|
|
//IF GET_GAME_TIMER() >= iNextFranklinDamageCheckTime
|
|
//BOOL bWasDamaged = FALSE
|
|
//IF NOT IS_PED_INJURED(enemyChopperPed[7])
|
|
// IF HAS_ENTITY_BEEN_DAMAGED_BY_ENTITY(franklinPed, enemyChopperPed[7])
|
|
// APPLY_DAMAGE_TO_ENTITY(franklinPed, 10, TRUE)
|
|
//bWasDamaged = TRUE
|
|
// ENDIF
|
|
//ENDIF
|
|
//IF NOT IS_PED_INJURED(enemyChopperPed[8])
|
|
// IF HAS_ENTITY_BEEN_DAMAGED_BY_ENTITY(franklinPed, enemyChopperPed[8])
|
|
// APPLY_DAMAGE_TO_ENTITY(franklinPed, 10, TRUE)
|
|
//bWasDamaged = TRUE
|
|
// ENDIF
|
|
//ENDIF
|
|
|
|
|
|
IF IS_EXPLOSION_IN_AREA(EXP_TAG_DONTCARE, GET_ENTITY_COORDS(franklinPed) - <<6,6,6>>, GET_ENTITY_COORDS(franklinPed) + <<6,6,6>>)
|
|
IF DOES_BLIP_EXIST(enemyChopperBlip[2])
|
|
IF GET_GAME_TIMER() >= iNextFranklinDamageCheckTime
|
|
APPLY_DAMAGE_TO_PED(franklinPed, 40, TRUE)
|
|
PRINTSTRING("damaged franklin") printnl()
|
|
iNextFranklinDamageCheckTime = GET_GAME_TIMER() + 1000
|
|
ENDIF
|
|
//bWasDamaged = TRUE
|
|
ENDIF
|
|
ENDIF
|
|
|
|
//IF bWasDamaged
|
|
//iFranklinDamageCount++
|
|
//printstring("increment damage count = ") printint(iFranklinDamageCount) printnl()
|
|
//ENDIF
|
|
|
|
CLEAR_ENTITY_LAST_DAMAGE_ENTITY(franklinPed)
|
|
|
|
|
|
//ENDIF
|
|
ELSE
|
|
//iFranklinDamageCount = 0
|
|
SET_ENTITY_PROOFS(franklinPed, FALSE, TRUE, FALSE, FALSE, FALSE)
|
|
SET_ENTITY_CAN_BE_DAMAGED_BY_RELATIONSHIP_GROUP(franklinPed, FALSE, agencyRelGroup)
|
|
ENDIF
|
|
ENDIF
|
|
|
|
// get playback time
|
|
IF IS_VEHICLE_DRIVEABLE(snatchAndGrabVehicle[SAGV_PLAYER_CHOPPER])
|
|
IF IS_PLAYBACK_GOING_ON_FOR_VEHICLE(snatchAndGrabVehicle[SAGV_PLAYER_CHOPPER])
|
|
fPlaybackTime = GET_TIME_POSITION_IN_RECORDING(snatchAndGrabVehicle[SAGV_PLAYER_CHOPPER])
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF NOT bDoneGetOutSpeech
|
|
IF GET_GAME_TIMER() >= iStartMissionStageTime + 100
|
|
//IF DO_MISSION_SPEECH("FBI2_NOWGO", FALSE, 1)
|
|
bDoneGetOutSpeech = TRUE
|
|
//SET_SELECTOR_PED_HINT(sSelectorPeds, SELECTOR_PED_FRANKLIN, FALSE)
|
|
//SET_SELECTOR_PED_HINT(sSelectorPeds, SELECTOR_PED_MICHAEL, FALSE)
|
|
//SET_SELECTOR_PED_HINT(sSelectorPeds, SELECTOR_PED_TREVOR, FALSE)
|
|
SET_SELECTOR_PED_BLOCKED(sSelectorPeds, SELECTOR_PED_FRANKLIN, FALSE)
|
|
SET_SELECTOR_PED_BLOCKED(sSelectorPeds, SELECTOR_PED_MICHAEL, FALSE)
|
|
SET_SELECTOR_PED_BLOCKED(sSelectorPeds, SELECTOR_PED_TREVOR, FALSE)
|
|
//ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
|
|
INT i
|
|
REPEAT NUMBER_ENEMY_CHOPPERS i
|
|
IF IS_VEHICLE_DRIVEABLE(enemyChopperVehicle[i])
|
|
INT iFireHealth
|
|
SWITCH i
|
|
CASE 0
|
|
CASE 1
|
|
CASE 3
|
|
iFireHealth = 750//910//750
|
|
BREAK
|
|
CASE 2
|
|
iFireHealth = 600//880//600
|
|
BREAK
|
|
ENDSWITCH
|
|
|
|
IF GET_ENTITY_HEALTH(enemyChopperVehicle[i]) < iFireHealth
|
|
IF i <> 2
|
|
OR NOT IS_PED_INJURED(GET_PED_IN_VEHICLE_SEAT(enemyChopperVehicle[i]))
|
|
SET_VEHICLE_ENGINE_HEALTH(enemyChopperVehicle[i], -150)
|
|
SET_VEHICLE_PETROL_TANK_HEALTH(enemyChopperVehicle[i], -150)
|
|
ENDIF
|
|
IF NOT IS_PED_INJURED(GET_PED_IN_VEHICLE_SEAT(enemyChopperVehicle[i]))
|
|
APPLY_DAMAGE_TO_PED(GET_PED_IN_VEHICLE_SEAT(enemyChopperVehicle[i]), 1000, TRUE)
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDREPEAT
|
|
|
|
// window smash
|
|
IF bSkippedGlassSmash
|
|
HANDLE_WINDOW_SMASH(TRUE, TRUE)
|
|
ENDIF
|
|
|
|
IF NOT bDoneMakeMichaelMoreLethal
|
|
IF NOT IS_PED_INJURED(sSelectorPeds.pedID[SELECTOR_PED_MICHAEL])
|
|
SET_PED_ACCURACY(sSelectorPeds.pedID[SELECTOR_PED_MICHAEL], 0) // 5
|
|
ENDIF
|
|
IF GET_GAME_TIMER() >= iStartMissionStageTime + 28000
|
|
// REPEAT 3 i
|
|
// IF NOT IS_PED_INJURED(enemyChopperPed[i])
|
|
// CLEAR_ENTITY_LAST_DAMAGE_ENTITY(enemyChopperPed[i])
|
|
// ENDIF
|
|
// ENDREPEAT
|
|
bDoneMakeMichaelMoreLethal = TRUE
|
|
ENDIF
|
|
//IF NOT IS_PED_INJURED(enemyChopperPed[0])
|
|
// IF GET_CURRENT_PLAYER_PED_ENUM() = CHAR_MICHAEL
|
|
// SET_PED_SUFFERS_CRITICAL_HITS(enemyChopperPed[0], TRUE)
|
|
// ELSE
|
|
// SET_PED_SUFFERS_CRITICAL_HITS(enemyChopperPed[0], FALSE)
|
|
// ENDIF
|
|
//ENDIF
|
|
ELSE
|
|
//IF NOT IS_PED_INJURED(enemyChopperPed[0])
|
|
// SET_PED_SUFFERS_CRITICAL_HITS(enemyChopperPed[0], TRUE)
|
|
//ENDIF
|
|
IF NOT IS_PED_INJURED(sSelectorPeds.pedID[SELECTOR_PED_MICHAEL])
|
|
SET_PED_ACCURACY(sSelectorPeds.pedID[SELECTOR_PED_MICHAEL], 75) // 15
|
|
ENDIF
|
|
ENDIF
|
|
|
|
// deal with enemy chopper peds
|
|
//fChopperAccuracy = fChopperAccuracy +@ 0.6
|
|
//IF fChopperAccuracy > 100
|
|
// fChopperAccuracy = 100
|
|
//ENDIF
|
|
//PRINTSTRING("acc = ") PRINTFLOAT(fChopperAccuracy) PRINTNL()
|
|
|
|
REPEAT COUNT_OF(enemyChopperPed) i
|
|
IF NOT IS_PED_INJURED(enemyChopperPed[i])
|
|
BOOL bDoDamage = FALSE
|
|
//IF bDoneMakeMichaelMoreLethal
|
|
// IF NOT IS_PED_INJURED(sSelectorPeds.pedID[SELECTOR_PED_MICHAEL])
|
|
// IF HAS_ENTITY_BEEN_DAMAGED_BY_ENTITY(enemyChopperPed[i], sSelectorPeds.pedID[SELECTOR_PED_MICHAEL])
|
|
// bDoDamage = TRUE
|
|
// ENDIF
|
|
// ENDIF
|
|
//ENDIF
|
|
IF HAS_ENTITY_BEEN_DAMAGED_BY_WEAPON(enemyChopperPed[i], WEAPONTYPE_HEAVYSNIPER)
|
|
bDoDamage = TRUE
|
|
ENDIF
|
|
IF bDoDamage
|
|
APPLY_DAMAGE_TO_PED(enemyChopperPed[i], 1000, TRUE)
|
|
ENDIF
|
|
ELSE
|
|
IF NOT bKilledEnemyChopperPed[i]
|
|
IF DOES_ENTITY_EXIST(enemyChopperPed[i])
|
|
INFORM_MISSION_STATS_OF_INCREMENT(FBI2_KILLS)
|
|
bKilledEnemyChopperPed[i] = TRUE
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDREPEAT
|
|
|
|
IF hangingHotswapState <> HANGING_HOTSWAP_ON_TREVOR
|
|
AND hangingHotswapState <> HANGING_HOTSWAP_MICHAEL_TO_TREVOR
|
|
AND hangingHotswapState <> HANGING_HOTSWAP_FRANKLIN_TO_TREVOR
|
|
IF GET_GAME_TIMER() >= iNextTrevorAITime
|
|
DO_TREVOR_FLY_ESCAPE_ROUTE()
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF NOT bDoneChopperChoiceSpeech
|
|
IF iAllowGoHomeTime < 0
|
|
IF iEnemyChopperSpeechStage > 0
|
|
//IF DO_MISSION_SPEECH("FBI2_SEECHP")
|
|
bDoneChopperChoiceSpeech = TRUE
|
|
iChopperHelpTime = GET_GAME_TIMER() + 600
|
|
//ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ELSE
|
|
IF NOT bDoneDangleHelp
|
|
IF GET_GAME_TIMER() >= iChopperHelpTime
|
|
bDoneDangleHelp = DO_MISSION_HELP_TEXT("SG_HOTHLP2", FALSE, 12500)
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
|
|
VECTOR vChopperPos
|
|
IF IS_VEHICLE_DRIVEABLE(snatchAndGrabVehicle[SAGV_PLAYER_CHOPPER])
|
|
vChopperPos = GET_ENTITY_COORDS(snatchAndGrabVehicle[SAGV_PLAYER_CHOPPER])
|
|
ENDIF
|
|
|
|
FLOAT fHeightAboveGround
|
|
FLOAT fGroundHeight
|
|
GET_GROUND_Z_FOR_3D_COORD(vChopperPos, fGroundHeight)
|
|
IF fGroundHeight < 0
|
|
fGroundHeight = 0
|
|
ENDIF
|
|
|
|
fHeightAboveGround = vChopperPos.z - fGroundHeight
|
|
IF fHeightAboveGround < 0
|
|
fHeightAboveGround *= -1
|
|
ENDIF
|
|
|
|
VECTOR vApplyOffsetToHeliTasks
|
|
vApplyOffsetToHeliTasks = <<0,0,0>>
|
|
IF fHeightAboveGround < 20
|
|
//printstring("apply offset to heli tasks") printnl()
|
|
vApplyOffsetToHeliTasks = <<0,0,8>>
|
|
ENDIF
|
|
|
|
IF NOT bCreatedExtraHeli
|
|
IF (NOT DOES_BLIP_EXIST(enemyChopperBlip[0])
|
|
OR NOT DOES_BLIP_EXIST(enemyChopperBlip[1]))
|
|
AND GET_GAME_TIMER() >= iStartMissionStageTime + 2000
|
|
IF iCreateExtraHeliTime < 0
|
|
iCreateExtraHeliTime = GET_GAME_TIMER()
|
|
ELSE
|
|
IF GET_GAME_TIMER() >= iCreateExtraHeliTime + 3000
|
|
CREATE_ENEMY_CHOPPER(FALSE, TRUE)
|
|
enemyChopperBlip[3] = CREATE_MISSION_BLIP_FOR_VEHICLE(enemyChopperVehicle[3], TRUE)
|
|
bCreatedExtraHeli = TRUE
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
|
|
// enemy chopper AI
|
|
VECTOR vOffset
|
|
WEAPON_TYPE currentWeapon
|
|
REPEAT NUMBER_ENEMY_CHOPPERS i
|
|
IF IS_VEHICLE_DRIVEABLE(enemyChopperVehicle[i])
|
|
|
|
// bad guys to start shooting
|
|
IF NOT bEnemyChopperShootersToAttack[i]
|
|
IF GET_GAME_TIMER() >= iChopperChaseTime + 3700
|
|
SET_ENEMY_CHOPPER_SHOOTERS_TO_ATTACK(i)
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF NOT bEnemyChopperToAI[i]
|
|
BOOL bStopPlayback = FALSE
|
|
|
|
IF NOT IS_PLAYBACK_GOING_ON_FOR_VEHICLE(enemyChopperVehicle[i])
|
|
bStopPlayback = TRUE
|
|
ELSE
|
|
//IF GET_CURRENT_PLAYER_PED_ENUM() = CHAR_TREVOR
|
|
//AND GET_TIME_POSITION_IN_RECORDING(enemyChopperVehicle[i]) >= 5000
|
|
// bStopPlayback = TRUE
|
|
//ENDIF
|
|
ENDIF
|
|
|
|
IF bStopPlayback
|
|
IF IS_PLAYBACK_GOING_ON_FOR_VEHICLE(enemyChopperVehicle[i])
|
|
STOP_PLAYBACK_RECORDED_VEHICLE(enemyChopperVehicle[i])
|
|
ENDIF
|
|
iNextEnemyChopperSpeechTime = GET_GAME_TIMER() + 9000
|
|
bEnemyChopperToAI[i] = TRUE
|
|
ENDIF
|
|
ELSE
|
|
PED_INDEX pilotPed = GET_PED_IN_VEHICLE_SEAT(enemyChopperVehicle[i], VS_DRIVER)
|
|
PED_INDEX michaelPed = GET_MICHAEL_PED()
|
|
IF NOT IS_PED_INJURED(michaelPed)
|
|
AND NOT IS_PED_INJURED(pilotPed)
|
|
FLOAT fDistance = GET_DISTANCE_BETWEEN_ENTITIES(michaelPed, enemyChopperVehicle[i])
|
|
|
|
FLOAT fTaskDistance
|
|
fTaskDistance=999
|
|
IF fTaskDistance > 0
|
|
ENDIF
|
|
IF hangingHotswapState = HANGING_HOTSWAP_ON_TREVOR
|
|
fTaskDistance = 50
|
|
ELSE
|
|
IF fDistance <= 30
|
|
fTaskDistance = 40
|
|
ELSE
|
|
fTaskDistance = 20
|
|
ENDIF
|
|
ENDIF
|
|
|
|
|
|
// chopper speech
|
|
IF i=0
|
|
IF iEnemyChopperSpeechStage = 1
|
|
AND (hangingHotswapState = HANGING_HOTSWAP_ON_MICHAEL OR hangingHotswapState = HANGING_HOTSWAP_ON_TREVOR)
|
|
IF fDistance <= 130
|
|
IF GET_GAME_TIMER() >= iNextEnemyChopperSpeechTime
|
|
IF DO_MISSION_SPEECH("FBI2_DOWN3")
|
|
iNextEnemyChopperSpeechTime = GET_GAME_TIMER() + 11000
|
|
iEnemyChopperSpeechStage++
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF GET_GAME_TIMER() >= iEnemyChopperAITime[i]
|
|
IF NOT IS_PED_INJURED(michaelPed)
|
|
//VECTOR vMichaelPos = GET_ENTITY_COORDS(michaelPed)
|
|
IF IS_VEHICLE_DRIVEABLE(snatchAndGrabVehicle[SAGV_PLAYER_CHOPPER])
|
|
|
|
IF i=0 OR i=1 OR i=3
|
|
IF NOT DOES_BLIP_EXIST(enemyChopperBlip[1])
|
|
IF DOES_BLIP_EXIST(enemyChopperBlip[0])
|
|
IF iLeadHeli = 1
|
|
IF bDoLeadHeliFireRockets
|
|
bDoLeadHeliFireRockets = FALSE
|
|
iLeadHeliFireRocketsTime = GET_GAME_TIMER() + 10000
|
|
ENDIF
|
|
ENDIF
|
|
iLeadHeli = 0
|
|
ELSE
|
|
IF iLeadHeli = 1 OR iLeadHeli = 0
|
|
IF bDoLeadHeliFireRockets
|
|
bDoLeadHeliFireRockets = FALSE
|
|
iLeadHeliFireRocketsTime = GET_GAME_TIMER() + 10000
|
|
ENDIF
|
|
ENDIF
|
|
iLeadHeli = 3
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF i=iLeadHeli
|
|
/*
|
|
IF GET_GAME_TIMER() >= iLeadHeliFireRocketsTime
|
|
AND IS_ENTITY_AT_ENTITY(pilotPed, snatchAndGrabVehicle[SAGV_PLAYER_CHOPPER], <<50,50,50>>, FALSE, FALSE)
|
|
AND GET_CURRENT_PLAYER_PED_ENUM() = CHAR_MICHAEL
|
|
SET_PED_FIRING_PATTERN(pilotPed, FIRING_PATTERN_FULL_AUTO)
|
|
SET_CURRENT_PED_VEHICLE_WEAPON(pilotPed, WEAPONTYPE_VEHICLE_SPACE_ROCKET)
|
|
TASK_HELI_MISSION(pilotPed, enemyChopperVehicle[i], NULL, NULL, GET_OFFSET_FROM_ENTITY_IN_WORLD_COORDS(enemyChopperVehicle[i], <<0, 50, 0>>), MISSION_ATTACK, 30.0, 40, -1, ROUND(vChopperPos.z), 10)
|
|
//TASK_HELI_MISSION(pilotPed, enemyChopperVehicle[i], NULL, NULL, GET_ENTITY_COORDS(snatchAndGrabVehicle[SAGV_PLAYER_CHOPPER]), MISSION_ATTACK, 40.0, 40, -1, ROUND(vChopperPos.z), 10)
|
|
iEnemyChopperAITime[i] = GET_GAME_TIMER() + 5000
|
|
iLeadHeliFireRocketsTime = GET_GAME_TIMER() + 4000000
|
|
ELSE
|
|
*/
|
|
|
|
|
|
IF NOT bDoLeadHeliFireRockets
|
|
IF GET_GAME_TIMER() >= iLeadHeliFireRocketsTime
|
|
OR bRocketsAccurate
|
|
bDoLeadHeliFireRockets = TRUE
|
|
iLeadHeliFireRocketsTime = GET_GAME_TIMER() + GET_RANDOM_INT_IN_RANGE(6000, 8000)
|
|
ENDIF
|
|
TASK_HELI_MISSION(pilotPed, enemyChopperVehicle[i], NULL, NULL, GET_OFFSET_FROM_ENTITY_IN_WORLD_COORDS(snatchAndGrabVehicle[SAGV_PLAYER_CHOPPER], <<-20, -35, -3>> + vApplyOffsetToHeliTasks), MISSION_GOTO, 120.0, 0.1, GET_ENTITY_HEADING(snatchAndGrabVehicle[SAGV_PLAYER_CHOPPER]), ROUND(vChopperPos.z), 10, -1) // <<-20, 30, -1>><<-20, 40, 0>>
|
|
iEnemyChopperAITime[i] = GET_GAME_TIMER() + 10
|
|
ELSE
|
|
|
|
IF GET_GAME_TIMER() >= iNextRocketInBarrageTime
|
|
SET_CURRENT_PED_VEHICLE_WEAPON(pilotPed, WEAPONTYPE_VEHICLE_SPACE_ROCKET)
|
|
|
|
GET_CURRENT_PED_VEHICLE_WEAPON(pilotPed, currentWeapon)
|
|
IF currentWeapon = WEAPONTYPE_VEHICLE_SPACE_ROCKET
|
|
VECTOR vHeliOffset
|
|
vHeliOffset = GET_OFFSET_FROM_ENTITY_GIVEN_WORLD_COORDS(enemyChopperVehicle[i], GET_ENTITY_COORDS(snatchAndGrabVehicle[SAGV_PLAYER_CHOPPER]))
|
|
IF vHeliOffset.y >= 10
|
|
|
|
vOffset.x = GET_RANDOM_FLOAT_IN_RANGE(5, 10)
|
|
vOffset.y = GET_RANDOM_FLOAT_IN_RANGE(5, 10)
|
|
vOffset.z = GET_RANDOM_FLOAT_IN_RANGE(5, 10)
|
|
IF GET_RANDOM_INT_IN_RANGE(0,2) = 0
|
|
vOffset.x *= -1
|
|
ENDIF
|
|
IF GET_RANDOM_INT_IN_RANGE(0,2) = 0
|
|
vOffset.y *= -1
|
|
ENDIF
|
|
IF GET_RANDOM_INT_IN_RANGE(0,2) = 0
|
|
vOffset.z *= -1
|
|
ENDIF
|
|
|
|
IF bRocketsAccurate
|
|
SET_VEHICLE_SHOOT_AT_TARGET(pilotPed, snatchAndGrabVehicle[SAGV_PLAYER_CHOPPER], <<0,0,0>>)
|
|
ELSE
|
|
SET_VEHICLE_SHOOT_AT_TARGET(pilotPed, NULL, GET_ENTITY_COORDS(snatchAndGrabVehicle[SAGV_PLAYER_CHOPPER]) + vOffset)
|
|
ENDIF
|
|
ENDIF
|
|
iNextRocketInBarrageTime = GET_GAME_TIMER() + GET_RANDOM_INT_IN_RANGE(1200, 1700)
|
|
ENDIF
|
|
ENDIF
|
|
|
|
TASK_HELI_MISSION(pilotPed, enemyChopperVehicle[i], NULL, NULL, GET_OFFSET_FROM_ENTITY_IN_WORLD_COORDS(snatchAndGrabVehicle[SAGV_PLAYER_CHOPPER], <<-6, -35, -3>> + vApplyOffsetToHeliTasks), MISSION_GOTO, 120.0, 0.1, GET_ENTITY_HEADING(snatchAndGrabVehicle[SAGV_PLAYER_CHOPPER]), ROUND(vChopperPos.z), 10, -1) // <<-6, 30, -1>><<-20, 40, 0>>
|
|
iEnemyChopperAITime[i] = GET_GAME_TIMER() + 10
|
|
|
|
IF GET_GAME_TIMER() >= iLeadHeliFireRocketsTime
|
|
AND NOT bRocketsAccurate
|
|
bDoLeadHeliFireRockets = FALSE
|
|
iLeadHeliFireRocketsTime = GET_GAME_TIMER() + GET_RANDOM_INT_IN_RANGE(18000, 23000)
|
|
ENDIF
|
|
ENDIF
|
|
|
|
//ENDIF
|
|
ELSE
|
|
TASK_HELI_MISSION(pilotPed, enemyChopperVehicle[i], NULL, NULL, GET_OFFSET_FROM_ENTITY_IN_WORLD_COORDS(snatchAndGrabVehicle[SAGV_PLAYER_CHOPPER], <<-40, -5, 2>> + vApplyOffsetToHeliTasks), MISSION_GOTO, 170.0, 0.1, GET_ENTITY_HEADING(snatchAndGrabVehicle[SAGV_PLAYER_CHOPPER]), ROUND(vChopperPos.z), 10, -1) // <<-40, -2, 7>> <<-40, 15, 6>>
|
|
iEnemyChopperAITime[i] = GET_GAME_TIMER() + 10
|
|
ENDIF
|
|
ELSE
|
|
fCircleCentreMod = fCircleCentreMod -@ 0.08
|
|
IF fCircleCentreMod < 0.0
|
|
fCircleCentreMod = 0.0
|
|
ENDIF
|
|
//PRINTFLOAT(fCircleCentreMod) printnl()
|
|
|
|
SET_VEHICLE_DISABLE_HEIGHT_MAP_AVOIDANCE(enemyChopperVehicle[2], TRUE)
|
|
|
|
IF heliStrafeState = HELI_STRAFE_MOVE
|
|
VECTOR vCircleTarget = <<0,0,0>>
|
|
VECTOR vCircleCentre = GET_ENTITY_COORDS(franklinAnchorObject)
|
|
|
|
CONST_FLOAT HELI_CIRCLE_RADIUS 27.0
|
|
CONST_FLOAT HELI_CIRCLE_MOD_HEADING 0.0//-95.6
|
|
|
|
FLOAT fModHeliCircleAngle = fHeliCircleAngle + HELI_CIRCLE_MOD_HEADING
|
|
|
|
vCircleTarget.x = vCircleCentre.x + (HELI_CIRCLE_RADIUS * COS(fModHeliCircleAngle))
|
|
vCircleTarget.y = vCircleCentre.y + (HELI_CIRCLE_RADIUS * SIN(fModHeliCircleAngle))
|
|
vCircleTarget.z = vCircleCentre.z
|
|
VECTOR vChopperCoords = GET_ENTITY_COORDS(enemyChopperVehicle[2])
|
|
BOOL bNearTower = FALSE
|
|
IF GET_DISTANCE_BETWEEN_COORDS(<<-166.55, -590.77, 199.13>>, vChopperCoords, FALSE) < 18.5
|
|
bNearTower = TRUE
|
|
ENDIF
|
|
|
|
IF IS_ENTITY_AT_COORD(enemyChopperVehicle[i], vCircleTarget, <<9,9,9>>)
|
|
fHeliCircleAngle += GET_RANDOM_FLOAT_IN_RANGE(22.5, 28.0)
|
|
IF fHeliCircleAngle > 360.0
|
|
fHeliCircleAngle -= 360.0
|
|
ENDIF
|
|
|
|
IF NOT bNearTower
|
|
SET_PED_FIRING_PATTERN(pilotPed, FIRING_PATTERN_FULL_AUTO)
|
|
SET_PED_ACCURACY(pilotPed, 100)
|
|
SET_CURRENT_PED_VEHICLE_WEAPON(pilotPed, WEAPONTYPE_VEHICLE_SPACE_ROCKET)
|
|
IF fCircleCentreMod <= 0 OR bDonePanicSpeech
|
|
TASK_HELI_MISSION(pilotPed, enemyChopperVehicle[i], NULL, GET_FRANKLIN_PED(), <<0,0,0>>, MISSION_ATTACK, 10, HELI_CIRCLE_RADIUS, -1, ROUND(vCircleCentre.z), 10)
|
|
ELSE
|
|
TASK_HELI_MISSION(pilotPed, enemyChopperVehicle[i], NULL, NULL, <<-139.44576, -594.67993, 211.21364>> + <<0,0,fCircleCentreMod>>, MISSION_ATTACK, 10, HELI_CIRCLE_RADIUS, -1, ROUND(vCircleCentre.z), 10)
|
|
ENDIF
|
|
|
|
iEnemyChopperAITime[i] = GET_GAME_TIMER() + GET_RANDOM_INT_IN_RANGE(1500, 4500)
|
|
iLastEnemyRocketsTime = GET_GAME_TIMER()
|
|
heliStrafeState = HELI_STRAFE_ATTACK
|
|
ELSE
|
|
iEnemyChopperAITime[i] = GET_GAME_TIMER() + 10
|
|
ENDIF
|
|
ELSE
|
|
|
|
FLOAT fStrafeFacing = GET_HEADING_FROM_VECTOR_2D(vCircleCentre.x - vChopperCoords.x, vCircleCentre.y - vChopperCoords.y)
|
|
VECTOR vModTargetHeight = <<0,0,0>>
|
|
|
|
IF bNearTower
|
|
vModTargetHeight.z = 10
|
|
ELSE
|
|
vModTargetHeight.z = 1
|
|
ENDIF
|
|
IS_ENTITY_AT_COORD(PLAYER_PED_ID(), vCircleTarget + vModTargetHeight, <<0.2,0.2,0.2>>)
|
|
TASK_HELI_MISSION(pilotPed, enemyChopperVehicle[i], NULL, NULL, vCircleTarget + vModTargetHeight, MISSION_GOTO, 15.0, 4, fStrafeFacing, ROUND(vCircleCentre.z + vModTargetHeight.z), 10)
|
|
iEnemyChopperAITime[i] = GET_GAME_TIMER() + 10
|
|
ENDIF
|
|
ELIF heliStrafeState = HELI_STRAFE_ATTACK
|
|
heliStrafeState = HELI_STRAFE_MOVE
|
|
iEnemyChopperAITime[i] = GET_GAME_TIMER() + 10
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF IS_PED_INJURED(GET_PED_IN_VEHICLE_SEAT(enemyChopperVehicle[i]))
|
|
SET_VEHICLE_AS_NO_LONGER_NEEDED(enemyChopperVehicle[i])
|
|
ENDIF
|
|
ELSE
|
|
IF DOES_ENTITY_EXIST(enemyChopperVehicle[i])
|
|
SET_VEHICLE_AS_NO_LONGER_NEEDED(enemyChopperVehicle[i])
|
|
ENDIF
|
|
ENDIF
|
|
ENDREPEAT
|
|
|
|
REPEAT COUNT_OF(enemyChopperPed) i
|
|
IF DOES_ENTITY_EXIST(enemyChopperPed[i])
|
|
BOOL bSetNoLongerNeeded = FALSE
|
|
IF NOT IS_PED_INJURED(enemyChopperPed[i])
|
|
IF IS_PED_IN_ANY_VEHICLE(enemyChopperPed[i])
|
|
IF NOT IS_VEHICLE_DRIVEABLE(GET_VEHICLE_PED_IS_IN(enemyChopperPed[i]))
|
|
OR NOT IS_ENTITY_A_MISSION_ENTITY(GET_VEHICLE_PED_IS_IN(enemyChopperPed[i]))
|
|
bSetNoLongerNeeded = TRUE
|
|
ENDIF
|
|
ELSE
|
|
bSetNoLongerNeeded = TRUE
|
|
ENDIF
|
|
ELSE
|
|
bSetNoLongerNeeded = TRUE
|
|
ENDIF
|
|
|
|
IF bSetNoLongerNeeded
|
|
IF i=0
|
|
REMOVE_PED_FOR_DIALOGUE(snatchAndGrabConversation, 4)
|
|
ENDIF
|
|
SET_PED_AS_NO_LONGER_NEEDED(enemyChopperPed[i])
|
|
ENDIF
|
|
ENDIF
|
|
ENDREPEAT
|
|
|
|
// vs chopper gameplay
|
|
IF NOT bSpottedChopper
|
|
IF fPlaybackTime >= 0//CHASE_SPOT_CHOPPER_TIME
|
|
IF CAN_ADVANCE_MISSION()
|
|
//IF DO_MISSION_SPEECH("FBI2_CHP1")
|
|
REPEAT NUMBER_ENEMY_CHOPPERS i
|
|
IF IS_VEHICLE_DRIVEABLE(enemyChopperVehicle[i])
|
|
enemyChopperBlip[i] = CREATE_MISSION_BLIP_FOR_VEHICLE(enemyChopperVehicle[i], TRUE)
|
|
ENDIF
|
|
ENDREPEAT
|
|
|
|
iEnemyChopperSpeechStage++
|
|
iNextEnemyChopperSpeechTime = GET_GAME_TIMER() + 11000
|
|
bSpottedChopper = TRUE
|
|
// Music change when chopper is blipped
|
|
//TRIGGER_MISSION_MUSIC_EVENT("FBI2_TEST_CHOPPER_SPOTTED")
|
|
//ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ELSE
|
|
IF CAN_ADVANCE_MISSION()
|
|
IF iAllowGoHomeTime < 0
|
|
BOOL bAllowGoHome = TRUE
|
|
|
|
REPEAT NUMBER_ENEMY_CHOPPERS i
|
|
IF IS_VEHICLE_DRIVEABLE(enemyChopperVehicle[i])
|
|
IF NOT IS_PED_INJURED(GET_PED_IN_VEHICLE_SEAT(enemyChopperVehicle[i]))
|
|
bAllowGoHome = FALSE
|
|
ELSE
|
|
IF DOES_BLIP_EXIST(enemyChopperBlip[i])
|
|
REMOVE_BLIP(enemyChopperBlip[i])
|
|
ENDIF
|
|
ENDIF
|
|
//IF GET_DISTANCE_BETWEEN_ENTITIES(enemyChopperVehicle[i], snatchAndGrabVehicle[SAGV_PLAYER_CHOPPER]) < 330
|
|
// bAllowGoHome = FALSE
|
|
//ENDIF
|
|
ELSE
|
|
IF DOES_BLIP_EXIST(enemyChopperBlip[i])
|
|
REMOVE_BLIP(enemyChopperBlip[i])
|
|
ENDIF
|
|
ENDIF
|
|
ENDREPEAT
|
|
|
|
IF bAllowGoHome
|
|
AND bCreatedExtraHeli
|
|
REPEAT NUMBER_ENEMY_CHOPPERS i
|
|
IF DOES_BLIP_EXIST(enemyChopperBlip[i])
|
|
REMOVE_BLIP(enemyChopperBlip[i])
|
|
ENDIF
|
|
ENDREPEAT
|
|
// Music change
|
|
//TRIGGER_MISSION_MUSIC_EVENT("FBI2_TEST_CHOPPER_DONE")
|
|
|
|
bShownChopperPrompt = TRUE
|
|
bDoneDangleHelp = TRUE
|
|
REMOVE_MISSION_TEXT(FALSE, TRUE, FALSE)
|
|
KILL_ANY_CONVERSATION()
|
|
iAllowGoHomeTime = GET_GAME_TIMER() + 300
|
|
ENDIF
|
|
|
|
IF NOT bShownChopperPrompt
|
|
//IF DO_MISSION_GOD_TEXT("SG_DCHOP")
|
|
bShownChopperPrompt = TRUE
|
|
//ENDIF
|
|
ENDIF
|
|
ELSE
|
|
IF NOT bDoneNoMoreThreatCue
|
|
bDoneNoMoreThreatCue = TRIGGER_MISSION_MUSIC_EVENT("FIB2_HELICOPTERS_GONE")
|
|
ENDIF
|
|
|
|
IF GET_GAME_TIMER() >= iAllowGoHomeTime
|
|
AND createFBIAtEndStage <> CREATE_FBI_AT_END_STAGE_WAITING
|
|
AND NOT IS_ANY_CONVERSATION_ONGOING_OR_QUEUED()
|
|
REPEAT NUMBER_ENEMY_CHOPPERS i
|
|
SET_ENEMY_CHOPPER_AS_GAVE_UP_CHASE(i)
|
|
ENDREPEAT
|
|
SET_MISSION_STAGE(STAGE_DROPOFF, FALSE, FALSE, FALSE)
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDPROC
|
|
|
|
// dropping off prisoner cutscene
|
|
PROC DO_DROPOFF_CUTSCENE()
|
|
SET_ALL_RANDOM_PEDS_FLEE_THIS_FRAME(PLAYER_ID())
|
|
|
|
SWITCH cutsceneStage
|
|
CASE SAG_CUT_STAGE_INIT
|
|
ADD_MODEL_REQUEST(ENUM_TO_INT(SAGM_FBIEND))
|
|
|
|
SET_PLAYER_FORCED_AIM(PLAYER_ID(), FALSE)
|
|
|
|
IF NOT IS_PED_INJURED(GET_MICHAEL_PED())
|
|
SET_PED_CONFIG_FLAG(GET_MICHAEL_PED(), PCF_ForcedAim, FALSE)
|
|
ENDIF
|
|
|
|
IF NOT IS_PED_INJURED(GET_MICHAEL_PED())
|
|
REGISTER_ENTITY_FOR_CUTSCENE(GET_MICHAEL_PED(), "Michael", CU_ANIMATE_EXISTING_SCRIPT_ENTITY)
|
|
ENDIF
|
|
IF NOT IS_PED_INJURED(GET_TREVOR_PED())
|
|
REGISTER_ENTITY_FOR_CUTSCENE(GET_TREVOR_PED(), "Trevor", CU_ANIMATE_EXISTING_SCRIPT_ENTITY)
|
|
ENDIF
|
|
IF NOT IS_PED_INJURED(prisonerPed)
|
|
REGISTER_ENTITY_FOR_CUTSCENE(prisonerPed, "MR_K", CU_ANIMATE_AND_DELETE_EXISTING_SCRIPT_ENTITY)
|
|
ENDIF
|
|
IF NOT IS_PED_INJURED(fbiPed[1])
|
|
TASK_CLEAR_LOOK_AT(fbiPed[1])
|
|
REGISTER_ENTITY_FOR_CUTSCENE(fbiPed[1], "FIB_Agent_near_heli", CU_ANIMATE_AND_DELETE_EXISTING_SCRIPT_ENTITY)
|
|
ENDIF
|
|
IF NOT IS_PED_INJURED(fbiPed[0])
|
|
TASK_CLEAR_LOOK_AT(fbiPed[0])
|
|
REGISTER_ENTITY_FOR_CUTSCENE(fbiPed[0], "FIB_Agent_near_Van", CU_ANIMATE_AND_DELETE_EXISTING_SCRIPT_ENTITY)
|
|
ENDIF
|
|
IF IS_VEHICLE_DRIVEABLE(fbiVanVehicle)
|
|
REGISTER_ENTITY_FOR_CUTSCENE(fbiVanVehicle, "FBI_2_Burrito_Van", CU_ANIMATE_AND_DELETE_EXISTING_SCRIPT_ENTITY)
|
|
ENDIF
|
|
IF IS_VEHICLE_DRIVEABLE(snatchAndGrabVehicle[SAGV_PLAYER_CHOPPER])
|
|
REGISTER_ENTITY_FOR_CUTSCENE(snatchAndGrabVehicle[SAGV_PLAYER_CHOPPER], "Main_heli", CU_ANIMATE_EXISTING_SCRIPT_ENTITY)
|
|
ENDIF
|
|
|
|
CUTSCENE_OPTION_FLAGS flags
|
|
IF GET_CURRENT_PLAYER_PED_ENUM() = CHAR_MICHAEL
|
|
flags = CUTSCENE_NO_OPTIONS
|
|
ELSE
|
|
flags = CUTSCENE_PLAYER_FP_FLASH_MICHAEL
|
|
ENDIF
|
|
|
|
START_CUTSCENE(flags)
|
|
REPLAY_RECORD_BACK_FOR_TIME(6.0, 0.0, REPLAY_IMPORTANCE_HIGHEST)
|
|
REPLAY_START_EVENT(REPLAY_IMPORTANCE_HIGHEST)
|
|
|
|
SET_CUTSCENE_FADE_VALUES(FALSE, FALSE, FALSE, FALSE)
|
|
|
|
cutsceneStage = SAG_CUT_STAGE_RUNNING
|
|
BREAK
|
|
|
|
CASE SAG_CUT_STAGE_RUNNING
|
|
#IF IS_DEBUG_BUILD
|
|
DEBUG_SKIP_MOCAP()
|
|
#ENDIF
|
|
|
|
IF NOT bClearedForCutscene
|
|
IF IS_CUTSCENE_PLAYING()
|
|
SET_MISSION_MOCAP_CUTSCENE()
|
|
IF IS_SCREEN_FADED_OUT()
|
|
DO_SCREEN_FADE_IN(DEFAULT_FADE_TIME)
|
|
ENDIF
|
|
|
|
IF GET_CURRENT_PLAYER_PED_ENUM() <> CHAR_MICHAEL
|
|
bDoMichaelBoom = TRUE
|
|
MAKE_SELECTOR_PED_SELECTION(sSelectorPeds, SELECTOR_PED_MICHAEL)
|
|
TAKE_CONTROL_OF_SELECTOR_PED(sSelectorPeds, TRUE, TRUE, TCF_CLEAR_TASK_INTERRUPT_CHECKS)
|
|
REAPPLY_PLAYER_PED_ATTRIBUTES()
|
|
ENDIF
|
|
|
|
REMOVE_ALL_BLIPS()
|
|
|
|
STOP_ALL_SNATCH_AND_GRAB_AUDIO_SCENES()
|
|
//SCRIPT_OVERRIDES_WIND_TYPES(FALSE, "", "")
|
|
|
|
// temp?
|
|
//IF DOES_ENTITY_EXIST(fbiPed[0])
|
|
// DELETE_PED(fbiPed[0])
|
|
//ENDIF
|
|
|
|
CLEAR_AREA(<<1373.97437, -2070.95264, 54.18420>>, 30.0, TRUE)
|
|
STOP_FIRE_IN_RANGE(<<1373.97437, -2070.95264, 54.18420>>, 30.0)
|
|
REMOVE_PARTICLE_FX_IN_RANGE(<<1373.97437, -2070.95264, 54.18420>>, 30.0)
|
|
|
|
IF DOES_ROPE_EXIST(rappelData.rope)
|
|
DELETE_RAPPEL_ROPE(rappelData)
|
|
ENDIF
|
|
|
|
IF DOES_ENTITY_EXIST(harnessObject)
|
|
DELETE_OBJECT(harnessObject)
|
|
ENDIF
|
|
|
|
// stop the dangle sound
|
|
STOP_SOUND(iDangleSoundID)
|
|
|
|
// get rid of enemy chopper
|
|
DELETE_ENEMY_CHOPPER()
|
|
|
|
IF NOT IS_PED_INJURED(prisonerPed)
|
|
SET_PED_COMPONENT_VARIATION(prisonerPed, PED_COMP_SPECIAL, 1, 0)
|
|
ENDIF
|
|
IF IS_VEHICLE_DRIVEABLE(snatchAndGrabVehicle[SAGV_PLAYER_CHOPPER])
|
|
SET_VEHICLE_ENGINE_ON(snatchAndGrabVehicle[SAGV_PLAYER_CHOPPER], FALSE, FALSE)
|
|
//SET_HELI_BLADES_SPEED(snatchAndGrabVehicle[SAGV_PLAYER_CHOPPER], 0)
|
|
SET_VEHICLE_DOOR_CONTROL(snatchAndGrabVehicle[SAGV_PLAYER_CHOPPER], SC_DOOR_FRONT_LEFT, DT_DOOR_INTACT, 0.0)
|
|
ENDIF
|
|
STOP_VEHICLE_FIRE(snatchAndGrabVehicle[SAGV_PLAYER_CHOPPER])
|
|
|
|
IF NOT IS_PED_INJURED(GET_MICHAEL_PED())
|
|
//CLEAR_PED_PROP(GET_MICHAEL_PED(), ANCHOR_HEAD)
|
|
REMOVE_PED_HELMET(GET_MICHAEL_PED(), TRUE)
|
|
ENDIF
|
|
|
|
bClearedForCutscene = TRUE
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF NOT bChangedClothes
|
|
IF GET_CUTSCENE_TIME() >= 23397
|
|
//SET_PLAYER_PED_WITH_HEADSET(CHAR_TREVOR, FALSE)
|
|
RESTORE_PLAYER_PED_VARIATIONS(GET_MICHAEL_PED())
|
|
CLEAR_PED_WETNESS(GET_MICHAEL_PED())
|
|
CLEAR_PED_ENV_DIRT(GET_MICHAEL_PED())
|
|
CLEAR_PED_BLOOD_DAMAGE(GET_MICHAEL_PED())
|
|
RESET_PED_VISIBLE_DAMAGE(GET_MICHAEL_PED())
|
|
bChangedClothes = TRUE
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF NOT bForceStartedChopper
|
|
IF GET_CUTSCENE_TIME() >= 47617
|
|
IF IS_VEHICLE_DRIVEABLE(snatchAndGrabVehicle[SAGV_PLAYER_CHOPPER])
|
|
dummyTrevorPed = CREATE_PED_INSIDE_VEHICLE(snatchAndGrabVehicle[SAGV_PLAYER_CHOPPER], PEDTYPE_MISSION, GET_MODEL_FOR_SNATCH_AND_GRAB_MODEL_ENUM(SAGM_FBIEND))
|
|
SET_BLOCKING_OF_NON_TEMPORARY_EVENTS(dummyTrevorPed, TRUE)
|
|
STOP_PED_SPEAKING(dummyTrevorPed, TRUE)
|
|
SET_ENTITY_VISIBLE(dummyTrevorPed, FALSE)
|
|
SET_VEHICLE_ENGINE_ON(snatchAndGrabVehicle[SAGV_PLAYER_CHOPPER], TRUE, FALSE)
|
|
//SET_HELI_BLADES_FULL_SPEED(snatchAndGrabVehicle[SAGV_PLAYER_CHOPPER])
|
|
bForceStartedChopper = TRUE
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF CAN_SET_EXIT_STATE_FOR_REGISTERED_ENTITY("Trevor")
|
|
AND CAN_SET_EXIT_STATE_FOR_REGISTERED_ENTITY("Main_Heli")
|
|
IF NOT IS_PED_INJURED(sSelectorPeds.pedID[SELECTOR_PED_TREVOR])
|
|
AND IS_VEHICLE_DRIVEABLE(snatchAndGrabVehicle[SAGV_PLAYER_CHOPPER])
|
|
IF DOES_ENTITY_EXIST(dummyTrevorPed)
|
|
DELETE_PED(dummyTrevorPed)
|
|
ENDIF
|
|
SET_PED_INTO_VEHICLE(sSelectorPeds.pedID[SELECTOR_PED_TREVOR], snatchAndGrabVehicle[SAGV_PLAYER_CHOPPER])
|
|
VECTOR vChopperPos
|
|
vChopperPos=vChopperPos
|
|
vChopperPos = GET_ENTITY_COORDS(snatchAndGrabVehicle[SAGV_PLAYER_CHOPPER])
|
|
CLEAR_SEQUENCE_TASK(sequence)
|
|
OPEN_SEQUENCE_TASK(sequence)
|
|
TASK_HELI_MISSION(NULL, snatchAndGrabVehicle[SAGV_PLAYER_CHOPPER], NULL, NULL, <<vChopperPos.x, vChopperPos.y, 65>>, MISSION_GOTO, 100.0, 5.0, -1, 65, 0)
|
|
TASK_HELI_MISSION(NULL, snatchAndGrabVehicle[SAGV_PLAYER_CHOPPER], NULL, NULL, <<1450.54724, -1332.49878, 110.0>>, MISSION_GOTO, 100.0, 0.0, -1, 110, 0) //132
|
|
CLOSE_SEQUENCE_TASK(sequence)
|
|
TASK_PERFORM_SEQUENCE(sSelectorPeds.pedID[SELECTOR_PED_TREVOR], sequence)
|
|
|
|
SHUT_ALL_CHOPPER_DOORS()
|
|
SET_VEHICLE_ENGINE_ON(snatchAndGrabVehicle[SAGV_PLAYER_CHOPPER], TRUE, TRUE)
|
|
SET_HELI_BLADES_FULL_SPEED(snatchAndGrabVehicle[SAGV_PLAYER_CHOPPER])
|
|
SET_ENTITY_VELOCITY(snatchAndGrabVehicle[SAGV_PLAYER_CHOPPER], <<0.0,4,5>>)
|
|
SET_HELI_TURBULENCE_SCALAR(snatchAndGrabVehicle[SAGV_PLAYER_CHOPPER],1.0)
|
|
SET_AIRCRAFT_PILOT_SKILL_NOISE_SCALAR(snatchAndGrabVehicle[SAGV_PLAYER_CHOPPER],1.0)
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF CAN_SET_EXIT_STATE_FOR_REGISTERED_ENTITY("Michael")
|
|
|
|
REPLAY_STOP_EVENT()
|
|
|
|
SET_PED_CONFIG_FLAG(PLAYER_PED_ID(), PCF_WaitingForPlayerControlInterrupt, TRUE)
|
|
ENDIF
|
|
|
|
IF NOT IS_CUTSCENE_PLAYING()
|
|
IF WAS_CUTSCENE_SKIPPED()
|
|
WHILE NOT IS_SCREEN_FADED_OUT()
|
|
WAIT(0)
|
|
ENDWHILE
|
|
RESTORE_PLAYER_PED_VARIATIONS(GET_MICHAEL_PED())
|
|
CLEAR_PED_WETNESS(GET_MICHAEL_PED())
|
|
CLEAR_PED_ENV_DIRT(GET_MICHAEL_PED())
|
|
CLEAR_PED_BLOOD_DAMAGE(GET_MICHAEL_PED())
|
|
RESET_PED_VISIBLE_DAMAGE(GET_MICHAEL_PED())
|
|
WAIT(1500)
|
|
ENDIF
|
|
|
|
iTrevorFlyOffTime = GET_GAME_TIMER()
|
|
bTrevorGone = TRUE
|
|
|
|
SET_PED_CAN_SWITCH_WEAPON(PLAYER_PED_ID(), TRUE)
|
|
SET_MISSION_CUTSCENE(FALSE, TRUE, TRUE, TRUE, FALSE)
|
|
CLEANUP_MICHAEL_WEAPON_OVERRIDES()
|
|
|
|
IF bDoMichaelBoom
|
|
IF GET_FOLLOW_PED_CAM_VIEW_MODE() <> CAM_VIEW_MODE_FIRST_PERSON
|
|
ANIMPOSTFX_PLAY("SwitchSceneMichael", 0, FALSE)
|
|
PLAY_SOUND_FRONTEND(-1, "Hit_In", "PLAYER_SWITCH_CUSTOM_SOUNDSET")
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
|
|
|
|
|
|
|
|
/*
|
|
IF CAN_SET_EXIT_STATE_FOR_CAMERA()
|
|
|
|
IF NOT IS_PED_INJURED(PLAYER_PED_ID())
|
|
CLEAR_PED_TASKS_IMMEDIATELY(PLAYER_PED_ID())
|
|
SET_ENTITY_COORDS(PLAYER_PED_ID(), GET_SNATCH_AND_GRAB_VECTOR(SAGVEC_END))
|
|
SET_ENTITY_HEADING(PLAYER_PED_ID(), END_ROT)
|
|
ENDIF
|
|
SET_GAMEPLAY_CAM_RELATIVE_HEADING()
|
|
|
|
|
|
ENDIF
|
|
*/
|
|
BREAK
|
|
|
|
CASE SAG_CUT_STAGE_CLEANUP
|
|
|
|
BREAK
|
|
ENDSWITCH
|
|
ENDPROC
|
|
|
|
// dropoff stage
|
|
PROC DO_STAGE_DROPOFF()
|
|
IF NOT bRunningCutscene
|
|
IF NOT bTrevorGone
|
|
// remove michael pistol
|
|
IF NOT IS_PED_INJURED(GET_MICHAEL_PED())
|
|
WEAPON_TYPE weapon
|
|
GET_CURRENT_PED_WEAPON(GET_MICHAEL_PED(), weapon)
|
|
IF weapon <> GET_SNATCH_AND_GRAB_WEAPON_TYPE(SAG_WEAPON_MICHAEL_RIFLE)
|
|
SET_CURRENT_PED_WEAPON(GET_MICHAEL_PED(), GET_SNATCH_AND_GRAB_WEAPON_TYPE(SAG_WEAPON_MICHAEL_RIFLE), TRUE)
|
|
IF GET_AMMO_IN_PED_WEAPON(GET_MICHAEL_PED(), GET_SNATCH_AND_GRAB_WEAPON_TYPE(SAG_WEAPON_MICHAEL_RIFLE)) = 0
|
|
SET_PED_AMMO(GET_MICHAEL_PED(), GET_SNATCH_AND_GRAB_WEAPON_TYPE(SAG_WEAPON_MICHAEL_RIFLE), 1)
|
|
ENDIF
|
|
SET_PED_INFINITE_AMMO(GET_MICHAEL_PED(), TRUE, GET_SNATCH_AND_GRAB_WEAPON_TYPE(SAG_WEAPON_MICHAEL_RIFLE))
|
|
SET_PED_INFINITE_AMMO_CLIP(GET_MICHAEL_PED(), TRUE)
|
|
ENDIF
|
|
ENDIF
|
|
|
|
DO_CHOPPER_ESCAPE_COMMON_FUNCTIONS()
|
|
|
|
// get rid of enemy chopper
|
|
IF NOT bRemovedEnemyChopper
|
|
//IF GET_GAME_TIMER() >= iStartMissionStageTime + 10000
|
|
INT i
|
|
|
|
REPEAT NUMBER_ENEMY_CHOPPERS i
|
|
IF DOES_ENTITY_EXIST(enemyChopperVehicle[i])
|
|
SET_VEHICLE_AS_NO_LONGER_NEEDED(enemyChopperVehicle[i])
|
|
ENDIF
|
|
ENDREPEAT
|
|
|
|
REPEAT COUNT_OF(enemyChopperPed) i
|
|
IF DOES_ENTITY_EXIST(enemyChopperPed[i])
|
|
SET_PED_AS_NO_LONGER_NEEDED(enemyChopperPed[i])
|
|
ENDIF
|
|
ENDREPEAT
|
|
|
|
bRemovedEnemyChopper = TRUE
|
|
//ENDIF
|
|
ENDIF
|
|
|
|
FORCE_CHOPPER_UP()
|
|
|
|
IF CAN_ADVANCE_MISSION()
|
|
IF NOT bForcePassOnShitskip
|
|
IF hangingHotswapState = HANGING_HOTSWAP_ON_TREVOR
|
|
OR hangingHotswapState = HANGING_HOTSWAP_ON_MICHAEL
|
|
IF NOT bDoneGoHomeSpeech
|
|
bDoneGoHomeSpeech = DO_MISSION_SPEECH("FBI2_GOBACK", TRUE)
|
|
ELSE
|
|
IF NOT bDoneGotoSpeech
|
|
bDoneGotoSpeech = DO_MISSION_SPEECH("FBI2_TCONT")
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF hangingHotswapState = HANGING_HOTSWAP_ON_TREVOR
|
|
HANDLE_GET_TO_LOCATION(TRUE, FALSE)
|
|
|
|
IF IS_SELECTOR_ONSCREEN()
|
|
AND GET_CAM_VIEW_MODE_FOR_CONTEXT(CAM_VIEW_MODE_CONTEXT_IN_HELI) <> CAM_VIEW_MODE_FIRST_PERSON
|
|
IF NOT IS_GAMEPLAY_HINT_ACTIVE()
|
|
SET_GAMEPLAY_VEHICLE_HINT(snatchAndGrabVehicle[SAGV_PLAYER_CHOPPER], vHangOnTrevor_HintCamLookAtLoc, TRUE, iCHASE_HINT_INFINITE_DWELL_TIME, 600, 600)
|
|
SET_GAMEPLAY_HINT_FOLLOW_DISTANCE_SCALAR(fHangOnTrevor_HintCamFollowDist)
|
|
SET_GAMEPLAY_HINT_FOV(GET_GAMEPLAY_CAM_FOV())
|
|
ENDIF
|
|
ELSE
|
|
IF IS_GAMEPLAY_HINT_ACTIVE()
|
|
STOP_GAMEPLAY_HINT(FALSE)
|
|
ENDIF
|
|
ENDIF
|
|
|
|
ELIF hangingHotswapState = HANGING_HOTSWAP_ON_MICHAEL
|
|
// dont blip the dropoff
|
|
IF DOES_BLIP_EXIST(getToBlip)
|
|
REMOVE_BLIP(getToBlip)
|
|
// getToBlip = CREATE_MISSION_BLIP_FOR_COORD(GET_SNATCH_AND_GRAB_VECTOR(SAGVEC_DROPOFF))
|
|
ENDIF
|
|
IF DOES_BLIP_EXIST(vehicleBlip)
|
|
REMOVE_BLIP(vehicleBlip)
|
|
ENDIF
|
|
IF NOT bShownGodText
|
|
IF bDoneGotoSpeech
|
|
//bShownGodText = DO_MISSION_GOD_TEXT("SG_GOLND")
|
|
bShownGodText = TRUE
|
|
ELSE
|
|
|
|
ENDIF
|
|
ELSE
|
|
|
|
ENDIF
|
|
|
|
// force trevor to come in low
|
|
IF IS_ENTITY_AT_COORD(PLAYER_PED_ID(), GET_SNATCH_AND_GRAB_VECTOR(SAGVEC_DROPOFF), <<12,12,200>>, FALSE, FALSE)
|
|
IF NOT bDoneForceTrevorLow
|
|
TASK_HELI_MISSION(GET_TREVOR_PED(), snatchAndGrabVehicle[SAGV_PLAYER_CHOPPER], NULL, NULL, GET_SNATCH_AND_GRAB_VECTOR(SAGVEC_DROPOFF), MISSION_LAND, 10.0, 2.0, -1, 0, 0)
|
|
PRINTSTRING("force trevor low!") printnl()
|
|
bDoneForceTrevorLow = TRUE
|
|
ENDIF
|
|
ELSE
|
|
IF bDoneForceTrevorLow
|
|
bDoneForceTrevorLow = FALSE
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF NOT bForcePassOnShitskip
|
|
IF hangingHotswapState = HANGING_HOTSWAP_ON_MICHAEL
|
|
OR hangingHotswapState = HANGING_HOTSWAP_ON_TREVOR
|
|
IF bDoneForceGetOutOfThereSpeech
|
|
bDoneGetOffRoofSpeech = TRUE
|
|
ENDIF
|
|
|
|
IF NOT bDoneGetOffRoofSpeech
|
|
IF bShownGodText
|
|
bDoneGetOffRoofSpeech = DO_MISSION_SPEECH("FBI2_LEAVE")
|
|
ENDIF
|
|
ELSE
|
|
//IF NOT bDoneKeepSniperSpeech
|
|
//IF NOT g_bMagDemoActive
|
|
// bDoneKeepSniperSpeech = DO_MISSION_SPEECH("FBI2_KSNIPER")
|
|
//ELSE
|
|
// bDoneKeepSniperSpeech = TRUE
|
|
//ENDIF
|
|
//ELSE
|
|
IF NOT bDoneWayHomeSpeech
|
|
bDoneWayHomeSpeech = DO_MISSION_SPEECH("FBI2_MKTALK")
|
|
ELSE
|
|
IF NOT bDoneWayHomeSpeech2
|
|
bDoneWayHomeSpeech2 = DO_MISSION_SPEECH("FBI2_MKTALK2")
|
|
ENDIF
|
|
ENDIF
|
|
//ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF bDoneGetOffRoofSpeech
|
|
IF NOT IS_PED_INJURED(sSelectorPeds.pedID[SELECTOR_PED_FRANKLIN])
|
|
IF NOT IS_ENTITY_AT_ENTITY(PLAYER_PED_ID(), sSelectorPeds.pedID[SELECTOR_PED_FRANKLIN], <<200,200,200>>, FALSE, FALSE)
|
|
DELETE_PED(sSelectorPeds.pedID[SELECTOR_PED_FRANKLIN])
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF NOT g_bMagDemoActive
|
|
IF createFBIAtEndStage = CREATE_FBI_AT_END_STAGE_DONE
|
|
HANDLE_STREAMING_MOCAP("fbi_2_ext", GET_SNATCH_AND_GRAB_VECTOR(SAGVEC_DROPOFF), DEFAULT_CUTSCENE_LOAD_DIST, DEFAULT_CUTSCENE_UNLOAD_DIST)
|
|
|
|
IF CAN_REQUEST_ASSETS_FOR_CUTSCENE_ENTITY()
|
|
IF NOT IS_PED_INJURED(GET_MICHAEL_PED())
|
|
SET_CUTSCENE_PED_COMPONENT_VARIATION_FROM_PED("Michael", GET_MICHAEL_PED())
|
|
ENDIF
|
|
IF NOT IS_PED_INJURED(fbiPed[0])
|
|
SET_CUTSCENE_PED_COMPONENT_VARIATION_FROM_PED("FIB_Agent_near_Van", fbiPed[0])
|
|
ENDIF
|
|
IF NOT IS_PED_INJURED(fbiPed[1])
|
|
SET_CUTSCENE_PED_COMPONENT_VARIATION_FROM_PED("FIB_Agent_near_heli", fbiPed[1])
|
|
ENDIF
|
|
IF NOT IS_PED_INJURED(prisonerPed)
|
|
SET_CUTSCENE_PED_COMPONENT_VARIATION_FROM_PED("MR_K", prisonerPed)
|
|
SET_CUTSCENE_PED_COMPONENT_VARIATION("MR_K", PED_COMP_SPECIAL, 0, 0)
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF CAN_ADVANCE_MISSION()
|
|
IF GET_CURRENT_PLAYER_PED_ENUM() = CHAR_TREVOR
|
|
IF IS_PED_IN_VEHICLE(PLAYER_PED_ID(), snatchAndGrabVehicle[SAGV_PLAYER_CHOPPER])
|
|
IS_ENTITY_AT_COORD(snatchAndGrabVehicle[SAGV_PLAYER_CHOPPER], GET_SNATCH_AND_GRAB_VECTOR(SAGVEC_DROPOFF), <<7,7,LOCATE_SIZE_HEIGHT>>, TRUE)
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF IS_ENTITY_AT_COORD(PLAYER_PED_ID(), GET_SNATCH_AND_GRAB_VECTOR(SAGVEC_DROPOFF), <<100,100,60>>)
|
|
AND GET_CURRENT_PLAYER_PED_ENUM() = CHAR_TREVOR
|
|
SET_HELI_TURBULENCE_SCALAR(snatchAndGrabVehicle[SAGV_PLAYER_CHOPPER],0.0)
|
|
SET_AIRCRAFT_PILOT_SKILL_NOISE_SCALAR(snatchAndGrabVehicle[SAGV_PLAYER_CHOPPER],0.0)
|
|
ELSE
|
|
SET_HELI_TURBULENCE_SCALAR(snatchAndGrabVehicle[SAGV_PLAYER_CHOPPER],1.0)
|
|
SET_AIRCRAFT_PILOT_SKILL_NOISE_SCALAR(snatchAndGrabVehicle[SAGV_PLAYER_CHOPPER],1.0)
|
|
ENDIF
|
|
|
|
IF IS_PED_SITTING_IN_VEHICLE(PLAYER_PED_ID(), snatchAndGrabVehicle[SAGV_PLAYER_CHOPPER])
|
|
IF NOT bForcePassOnShitskip
|
|
IF NOT bDoneLandSpeech
|
|
IF NOT bKilledSpeechForLand
|
|
IF IS_ENTITY_AT_COORD(PLAYER_PED_ID(), GET_SNATCH_AND_GRAB_VECTOR(SAGVEC_DROPOFF), GET_SNATCH_AND_GRAB_VECTOR(SAGVEC_DROPOFF_DIMENSIONS))
|
|
KILL_ANY_CONVERSATION()
|
|
bDoneWayHomeSpeech = TRUE
|
|
bDoneWayHomeSpeech2 = TRUE
|
|
bDoneGetOffRoofSpeech = TRUE
|
|
bKilledSpeechForLand = TRUE
|
|
ENDIF
|
|
ELSE
|
|
bDoneLandSpeech = DO_MISSION_SPEECH("FBI2_LAN")
|
|
ENDIF
|
|
ELSE
|
|
IF NOT bDoneLandAudioScene
|
|
IF NOT IS_ANY_CONVERSATION_ONGOING_OR_QUEUED()
|
|
bDoneLandAudioScene = START_SNATCH_AND_GRAB_AUDIO_SCENE(SNATCH_AND_GRAB_AUDIO_SCENE_LAND_THE_HELI)
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
|
|
// advance mission on arrival
|
|
FLOAT fLandZ
|
|
IF GET_CURRENT_PLAYER_PED_ENUM() = CHAR_TREVOR
|
|
fLandZ = 2
|
|
ELSE
|
|
fLandZ = 2 // 20
|
|
ENDIF
|
|
|
|
//IF IS_ENTITY_AT_COORD(snatchAndGrabVehicle[SAGV_PLAYER_CHOPPER], GET_SNATCH_AND_GRAB_VECTOR(SAGVEC_DROPOFF), <<15,15,fLandZ>>)
|
|
//OR IS_ENTITY_AT_COORD(snatchAndGrabVehicle[SAGV_PLAYER_CHOPPER], <<1359.67834, -2077.29883, 50.99810>>, <<11,11,fLandZ>>)
|
|
IF IS_ENTITY_IN_ANGLED_AREA(snatchAndGrabVehicle[SAGV_PLAYER_CHOPPER], <<1376.403, -2083.443, 50.998>>, <<1360.366, -2064.322, 50.998 + fLandZ>>, 28)
|
|
OR IS_ENTITY_IN_ANGLED_AREA(snatchAndGrabVehicle[SAGV_PLAYER_CHOPPER], <<1374.360, -2059.423, 50.998>>, <<1383.849, -2050.670, 50.998 + fLandZ>>, 10)
|
|
IF NOT bDoneMissionCompleteCue
|
|
bDoneMissionCompleteCue = TRIGGER_MISSION_MUSIC_EVENT("FIB2_COMPLETE")
|
|
ENDIF
|
|
fAtDropOffTime = fAtDropOffTime +@ 1.0
|
|
ELSE
|
|
fAtDropOffTime = 0.0
|
|
bCutsceneWaitStarted = FALSE
|
|
ENDIF
|
|
|
|
IF NOT bCutsceneWaitStarted
|
|
IF fAtDropOffTime >= 2.0
|
|
AND createFBIAtEndStage = CREATE_FBI_AT_END_STAGE_DONE
|
|
KILL_ANY_CONVERSATION()
|
|
bCutsceneWaitStarted = TRUE
|
|
ENDIF
|
|
ELSE
|
|
IF NOT IS_ANY_CONVERSATION_ONGOING_OR_QUEUED()
|
|
IF HAS_CUTSCENE_LOADED_WITH_FAILSAFE()
|
|
bRunningCutscene = TRUE
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ELSE
|
|
SWITCH iHeliFlyOffState
|
|
CASE 0
|
|
IF IS_PED_SITTING_IN_VEHICLE(PLAYER_PED_ID(), snatchAndGrabVehicle[SAGV_PLAYER_CHOPPER])
|
|
OR hangingHotswapState = HANGING_HOTSWAP_ON_MICHAEL
|
|
IF GET_ENTITY_MODEL(PLAYER_PED_ID()) = GET_PLAYER_PED_MODEL(CHAR_TREVOR)
|
|
IF IS_ENTITY_AT_COORD(PLAYER_PED_ID(), <<1375.57, -2072.22, 51.00>>, <<100,100,100>>, FALSE, FALSE)
|
|
VECTOR vDest, vDestCamPointPos, vDestCamPos, vChopperPos
|
|
FLOAT fHeliHeading
|
|
INT iHeliHeight
|
|
|
|
SET_PLAYER_CONTROL(PLAYER_ID(), FALSE)
|
|
|
|
IF IS_VEHICLE_DRIVEABLE(snatchAndGrabVehicle[SAGV_PLAYER_CHOPPER])
|
|
vChopperPos = GET_ENTITY_COORDS(snatchAndGrabVehicle[SAGV_PLAYER_CHOPPER])
|
|
vDest = GET_OFFSET_FROM_ENTITY_IN_WORLD_COORDS(snatchAndGrabVehicle[SAGV_PLAYER_CHOPPER], <<20.0, 300.0, 0.0>>)
|
|
vDestCamPos = GET_OFFSET_FROM_ENTITY_IN_WORLD_COORDS(snatchAndGrabVehicle[SAGV_PLAYER_CHOPPER], <<0.0, 20.0, 0.0>>)
|
|
vDestCamPointPos = GET_OFFSET_FROM_ENTITY_IN_WORLD_COORDS(snatchAndGrabVehicle[SAGV_PLAYER_CHOPPER], <<-150.0, 100.0, 0.0>>)
|
|
fHeliHeading = GET_ENTITY_HEADING(snatchAndGrabVehicle[SAGV_PLAYER_CHOPPER])
|
|
iHeliHeight = ROUND(GET_ENTITY_HEIGHT_ABOVE_GROUND(snatchAndGrabVehicle[SAGV_PLAYER_CHOPPER]))
|
|
|
|
//Remove any Z elements (in case the chopper was in a bad orientation when working out the offsets).
|
|
vDest.z = vChopperPos.z
|
|
vDestCamPos.z = vChopperPos.z + 20.0
|
|
vDestCamPointPos.z = vChopperPos.z + 20.0
|
|
|
|
IF NOT IS_PED_INJURED(GET_TREVOR_PED())
|
|
TASK_HELI_MISSION(GET_TREVOR_PED(), snatchAndGrabVehicle[SAGV_PLAYER_CHOPPER], NULL, NULL, vDest, MISSION_GOTO, 30.0, 0.0, fHeliHeading, iHeliHeight, 20)
|
|
ELSE
|
|
TASK_HELI_MISSION(PLAYER_PED_ID(), snatchAndGrabVehicle[SAGV_PLAYER_CHOPPER], NULL, NULL, vDest, MISSION_GOTO, 30.0, 0.0, fHeliHeading, iHeliHeight, 20)
|
|
ENDIF
|
|
ENDIF
|
|
|
|
staticCam = CREATE_CAMERA_WITH_PARAMS(CAMTYPE_SCRIPTED, GET_FINAL_RENDERED_CAM_COORD(), GET_FINAL_RENDERED_CAM_ROT(), GET_FINAL_RENDERED_CAM_FOV(), TRUE)
|
|
interpCam = CREATE_CAMERA_WITH_PARAMS(CAMTYPE_SCRIPTED, vDestCamPos, GET_FINAL_RENDERED_CAM_ROT(), GET_FINAL_RENDERED_CAM_FOV())
|
|
|
|
SHAKE_CAM(staticCam, "HAND_SHAKE", 0.2)
|
|
SHAKE_CAM(interpCam, "HAND_SHAKE", 0.2)
|
|
|
|
POINT_CAM_AT_COORD(interpCam, vDestCamPointPos)
|
|
SET_CAM_ACTIVE_WITH_INTERP(interpCam, staticCam, 6500, GRAPH_TYPE_ACCEL, GRAPH_TYPE_ACCEL)
|
|
|
|
RENDER_SCRIPT_CAMS(TRUE, FALSE)
|
|
SET_SCRIPTS_SAFE_FOR_CUTSCENE(TRUE)
|
|
DISPLAY_HUD(FALSE)
|
|
DISPLAY_RADAR(FALSE)
|
|
|
|
bDisableSwitchDuringMagDemoEndScene = TRUE
|
|
|
|
SETTIMERB(0)
|
|
iHeliFlyOffState++
|
|
ENDIF
|
|
ELSE
|
|
IF IS_ENTITY_AT_COORD(PLAYER_PED_ID(), <<1375.57, -2072.22, 51.00>>, <<100,100,100>>, FALSE, FALSE)
|
|
TRIGGER_MISSION_MUSIC_EVENT("FIB2_COMPLETE")
|
|
DO_SCREEN_FADE_OUT(1000)
|
|
WHILE NOT IS_SCREEN_FADED_OUT()
|
|
WAIT(0)
|
|
ENDWHILE
|
|
DELETE_ALL_ENTITIES_IN_FADE()
|
|
MISSION_PASSED()
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
BREAK
|
|
|
|
CASE 1
|
|
IF TIMERB() > 5000
|
|
TRIGGER_MISSION_MUSIC_EVENT("FIB2_COMPLETE")
|
|
DO_SCREEN_FADE_OUT(1000)
|
|
WHILE NOT IS_SCREEN_FADED_OUT()
|
|
WAIT(0)
|
|
ENDWHILE
|
|
|
|
DESTROY_ALL_CAMS()
|
|
RENDER_SCRIPT_CAMS(FALSE, FALSE)
|
|
SET_SCRIPTS_SAFE_FOR_CUTSCENE(FALSE)
|
|
DISPLAY_HUD(TRUE)
|
|
DISPLAY_RADAR(TRUE)
|
|
|
|
DELETE_ALL_ENTITIES_IN_FADE()
|
|
MISSION_PASSED()
|
|
ENDIF
|
|
BREAK
|
|
ENDSWITCH
|
|
|
|
/*IF IS_PED_SITTING_IN_VEHICLE(PLAYER_PED_ID(), snatchAndGrabVehicle[SAGV_PLAYER_CHOPPER])
|
|
OR hangingHotswapState = HANGING_HOTSWAP_ON_MICHAEL
|
|
IF IS_ENTITY_AT_COORD(PLAYER_PED_ID(), <<1375.57, -2072.22, 51.00>>, <<100,100,100>>, FALSE, FALSE)
|
|
TRIGGER_MISSION_MUSIC_EVENT("FIB2_COMPLETE")
|
|
DO_SCREEN_FADE_OUT(1000)
|
|
WHILE NOT IS_SCREEN_FADED_OUT()
|
|
WAIT(0)
|
|
ENDWHILE
|
|
DELETE_ALL_ENTITIES_IN_FADE()
|
|
MISSION_PASSED()
|
|
ENDIF
|
|
ENDIF*/
|
|
ENDIF
|
|
ELSE
|
|
IF GET_GAME_TIMER() >= iTrevorFlyOffTime + 13000
|
|
IF DOES_ENTITY_EXIST(sSelectorPeds.pedID[SELECTOR_PED_TREVOR])
|
|
SET_PLAYER_PED_WITH_HEADSET(CHAR_TREVOR, FALSE)
|
|
STORE_PLAYER_PED_VARIATIONS(sSelectorPeds.pedID[SELECTOR_PED_TREVOR], TRUE)
|
|
printstring("store on trevor") printnl()
|
|
DELETE_PED(sSelectorPeds.pedID[SELECTOR_PED_TREVOR])
|
|
ENDIF
|
|
IF DOES_ENTITY_EXIST(sSelectorPeds.pedID[SELECTOR_PED_FRANKLIN])
|
|
DELETE_PED(sSelectorPeds.pedID[SELECTOR_PED_FRANKLIN])
|
|
ENDIF
|
|
IF DOES_ENTITY_EXIST(snatchAndGrabVehicle[SAGV_PLAYER_CHOPPER])
|
|
DELETE_VEHICLE(snatchAndGrabVehicle[SAGV_PLAYER_CHOPPER])
|
|
ENDIF
|
|
|
|
IF NOT IS_PED_IN_ANY_VEHICLE(PLAYER_PED_ID())
|
|
IF IS_VEHICLE_DRIVEABLE(driveAwayVehicle)
|
|
SET_PLAYERS_LAST_VEHICLE(driveAwayVehicle)
|
|
ENDIF
|
|
ENDIF
|
|
|
|
MISSION_PASSED()
|
|
ENDIF
|
|
ENDIF
|
|
ELSE
|
|
DO_DROPOFF_CUTSCENE()
|
|
ENDIF
|
|
ENDPROC
|
|
|
|
// debug only
|
|
#IF IS_DEBUG_BUILD
|
|
// create widgets
|
|
PROC CREATE_SNATCH_AND_GRAB_WIDGETS()
|
|
/*
|
|
snatchAndGrabWidgets = START_WIDGET_GROUP("Switch To Sniper Spline")
|
|
ADD_WIDGET_VECTOR_SLIDER("Prisoner offset", vDebugPrisonerOffset, -20, 20, 0.05)
|
|
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_BOOL("Do Dump", bRBDebugCamDoDump)
|
|
ADD_WIDGET_BOOL("Swing out earlier", bDebugSwingOutEarlier)
|
|
//ADD_WIDGET_BOOL("Use chopper searchlights", bDebugUseAlternateChopper)
|
|
ADD_WIDGET_BOOL("Use alternate rappel cam", bDebugUseAlternateRappelCam)
|
|
// ADD_WIDGET_BOOL("Use ring locate", bDebugSkipMagdemoUseRing)
|
|
// STOP_WIDGET_GROUP()
|
|
|
|
//sniperSplineWidgets = START_WIDGET_GROUP("Switch To Sniper Spline")
|
|
// ADD_WIDGET_VECTOR_SLIDER("Node Position 1", vSniperNodePos1, -1000.0, 1000.0, 1.0)
|
|
// ADD_WIDGET_VECTOR_SLIDER("Node Rotation 1", vSniperNodeRot1, -180.0, 180.0, 1.0)
|
|
ADD_WIDGET_VECTOR_SLIDER("Node Position 2", vSniperNodePos2, -1000.0, 1000.0, 1.0)
|
|
ADD_WIDGET_VECTOR_SLIDER("Node Rotation 2", vSniperNodeRot2, -180.0, 180.0, 1.0)
|
|
ADD_WIDGET_INT_SLIDER("Time from 1 to 2", iSniperNodeTime2, 0, 30000, 1000)
|
|
ADD_WIDGET_VECTOR_SLIDER("Node Position 3", vSniperNodePos3, -1000.0, 1000.0, 1.0)
|
|
ADD_WIDGET_VECTOR_SLIDER("Node Rotation 3", vSniperNodeRot3, -180.0, 180.0, 1.0)
|
|
ADD_WIDGET_INT_SLIDER("Time from 2 to 3", iSniperNodeTime3, 0, 30000, 1000)
|
|
////ADD_WIDGET_VECTOR_SLIDER("Node Position 4", vSniperNodePos4, -1000.0, 1000.0, 1.0)
|
|
//ADD_WIDGET_VECTOR_SLIDER("Node Rotation 4", vSniperNodeRot4, -180.0, 180.0, 1.0)
|
|
ADD_WIDGET_INT_SLIDER("Time from 3 to 4", iSniperNodeTime4, 0, 30000, 1000)
|
|
//ADD_WIDGET_VECTOR_SLIDER("Node Position 5", vSniperNodePos5, -1000.0, 1000.0, 1.0)
|
|
//ADD_WIDGET_VECTOR_SLIDER("Node Rotation 5", vSniperNodeRot5, -180.0, 180.0, 1.0)
|
|
ADD_WIDGET_INT_SLIDER("Time from 4 to 5", iSniperNodeTime5, 0, 30000, 1000)
|
|
//ADD_WIDGET_VECTOR_SLIDER("Node Position 6", vSniperNodePos6, -1000.0, 1000.0, 1.0)
|
|
//ADD_WIDGET_VECTOR_SLIDER("Node Rotation 6", vSniperNodeRot6, -180.0, 180.0, 1.0)
|
|
ADD_WIDGET_INT_SLIDER("Time from 5 to 6", iSniperNodeTime6, 0, 30000, 1000)
|
|
|
|
CREATE_SWITCH_CAM_SPECIFIC_WIDGETS()
|
|
|
|
STOP_WIDGET_GROUP()
|
|
|
|
|
|
SETUP_SPLINE_CAM_NODE_ARRAY_HELI_MICHAEL_TO_FRANKLIN(scsSwitch_Heli_Michael_ToFranklin, GET_MICHAEL_PED(), GET_FRANKLIN_PED())
|
|
SETUP_SPLINE_CAM_NODE_ARRAY_HELI_TREVOR_TO_FRANKLIN(scsSwitch_Heli_Trevor_ToFranklin, snatchAndGrabVehicle[SAGV_PLAYER_CHOPPER], GET_FRANKLIN_PED())
|
|
SETUP_SPLINE_CAM_NODE_ARRAY_FRANKLIN_TO_MICHAEL(scsSwitch_FranklinToHeli_Mike, GET_FRANKLIN_PED(), GET_MICHAEL_PED())
|
|
SETUP_SPLINE_CAM_NODE_ARRAY_FRANKLIN_TO_TREVOR(scsSwitch_FranklinToHeli_Trev, GET_FRANKLIN_PED(), snatchAndGrabVehicle[SAGV_PLAYER_CHOPPER])
|
|
SETUP_SPLINE_CAM_NODE_ARRAY_HANGING_TO_SNIPER(scsSwitch_HangingToSniper, GET_FRANKLIN_PED())
|
|
SETUP_SPLINE_CAM_NODE_ARRAY_HELI_TREVOR_TO_MICHAEL(scsSwitch_Heli_TrevorToMichael, GET_TREVOR_PED(), GET_MICHAEL_PED())
|
|
SETUP_SPLINE_CAM_NODE_ARRAY_HELI_MICHAEL_TO_TREVOR(scsSwitch_Heli_MichaelToTrevor, GET_MICHAEL_PED(), GET_TREVOR_PED())
|
|
|
|
CREATE_SPLINE_CAM_WIDGETS(scsSwitch_HangingToSniper, "Michael Hanging", "Franklin", snatchAndGrabWidgets)
|
|
CREATE_SPLINE_CAM_WIDGETS(scsSwitch_Heli_MichaelToTrevor, "Michael", "Trevor", snatchAndGrabWidgets)
|
|
CREATE_SPLINE_CAM_WIDGETS(scsSwitch_Heli_Michael_ToFranklin, "Michael", "Franklin", snatchAndGrabWidgets)
|
|
CREATE_SPLINE_CAM_WIDGETS(scsSwitch_FranklinToHeli_Mike, "Franklin", "Mike", snatchAndGrabWidgets)
|
|
CREATE_SPLINE_CAM_WIDGETS(scsSwitch_FranklinToHeli_Trev, "Franklin", "Trev", snatchAndGrabWidgets)
|
|
CREATE_SPLINE_CAM_WIDGETS(scsSwitch_Heli_TrevorToMichael, "Trevor", "Michael", snatchAndGrabWidgets)
|
|
CREATE_SPLINE_CAM_WIDGETS(scsSwitch_Heli_Trevor_ToFranklin, "Trevor", "Franklin", snatchAndGrabWidgets)
|
|
*/
|
|
ENDPROC
|
|
|
|
// setup the debug menu
|
|
PROC SETUP_SNATCH_AND_GRAB_DEBUG_MENU()
|
|
stageMenu[0].sTxtLabel = GET_DESCRIPTION_FOR_STAGE_AS_STRING(STAGE_FOOD_COURT)
|
|
stageMenu[1].sTxtLabel = "Cutscene FBI_2_INT"
|
|
stageMenu[1].bSelectable = FALSE
|
|
stageMenu[2].sTxtLabel = GET_DESCRIPTION_FOR_STAGE_AS_STRING(STAGE_GET_TO_CHOPPER)
|
|
stageMenu[3].sTxtLabel = "Cutscene FBI_2_MCS_1"
|
|
stageMenu[3].bSelectable = FALSE
|
|
stageMenu[4].sTxtLabel = GET_DESCRIPTION_FOR_STAGE_AS_STRING(STAGE_GET_TO_BUILDING)
|
|
stageMenu[5].sTxtLabel = "Cutscene FBI_2_MCS_2"
|
|
stageMenu[5].bSelectable = FALSE
|
|
stageMenu[6].sTxtLabel = GET_DESCRIPTION_FOR_STAGE_AS_STRING(STAGE_RAPPEL_DOWN)
|
|
stageMenu[7].sTxtLabel = "Cutscene FBI_2_MCS_3_P1A"
|
|
stageMenu[7].bSelectable = FALSE
|
|
stageMenu[8].sTxtLabel = GET_DESCRIPTION_FOR_STAGE_AS_STRING(STAGE_SNIPE_GUARDS)
|
|
stageMenu[9].sTxtLabel = "Cutscene FBI_2_MCS_3B"
|
|
stageMenu[9].bSelectable = FALSE
|
|
stageMenu[10].sTxtLabel = GET_DESCRIPTION_FOR_STAGE_AS_STRING(STAGE_CHOPPER_CHASE)
|
|
stageMenu[11].sTxtLabel = GET_DESCRIPTION_FOR_STAGE_AS_STRING(STAGE_DROPOFF)
|
|
stageMenu[12].sTxtLabel = "Cutscene FBI_2_EXT"
|
|
stageMenu[12].bSelectable = FALSE
|
|
ENDPROC
|
|
|
|
// debug skips
|
|
PROC DO_DEBUG_SKIPS()
|
|
// mission pass S
|
|
IF IS_KEYBOARD_KEY_JUST_PRESSED(KEY_S)
|
|
IF NOT IS_PED_INJURED(PLAYER_PED_ID())
|
|
RESTORE_PLAYER_PED_VARIATIONS(PLAYER_PED_ID())
|
|
ENDIF
|
|
|
|
bThoroughCleanup = TRUE
|
|
|
|
IF g_bMagDemoActive
|
|
DO_SCREEN_FADE_OUT(DEFAULT_FADE_TIME)
|
|
WHILE NOT IS_SCREEN_FADED_OUT()
|
|
WAIT(0)
|
|
ENDWHILE
|
|
DELETE_ALL_ENTITIES_IN_FADE()
|
|
ENDIF
|
|
MISSION_PASSED()
|
|
ENDIF
|
|
|
|
// mission fail F
|
|
IF IS_KEYBOARD_KEY_JUST_PRESSED(KEY_F)
|
|
MISSION_FAILED(FAIL_PRISONER_DEAD)
|
|
ENDIF
|
|
|
|
// skip stage J
|
|
IF IS_KEYBOARD_KEY_JUST_PRESSED(KEY_J)
|
|
IF NOT bRunningCutscene
|
|
AND hotswapStage <> MISSION_HOTSWAP_STAGE_DO_SPLINE_CAM
|
|
IF NOT IS_PED_INJURED(PLAYER_PED_ID())
|
|
IF currentMissionStage <> STAGE_RAPPEL_DOWN
|
|
AND currentMissionStage <> STAGE_SNIPE_GUARDS
|
|
SET_PLAYER_CONTROL(PLAYER_ID(), TRUE)
|
|
ENDIF
|
|
SWITCH currentMissionStage
|
|
CASE STAGE_FOOD_COURT
|
|
SET_ENTITY_COORDS(PLAYER_PED_ID(), <<148.61346, -679.18494, 41.02729>>)
|
|
BREAK
|
|
|
|
CASE STAGE_GET_TO_CHOPPER
|
|
IF NOT IS_PED_IN_VEHICLE(PLAYER_PED_ID(), snatchAndGrabVehicle[SAGV_MICHAEL_CAR])
|
|
SET_PLAYER_PED_INTO_SNATCH_AND_GRAB_VEHICLE(SAGV_MICHAEL_CAR, VS_DRIVER)
|
|
IF NOT IS_PED_INJURED(davePed)
|
|
IF NOT IS_PED_IN_VEHICLE(davePed, snatchAndGrabVehicle[SAGV_MICHAEL_CAR])
|
|
SET_PED_INTO_VEHICLE(davePed, snatchAndGrabVehicle[SAGV_MICHAEL_CAR], VS_FRONT_RIGHT)
|
|
ENDIF
|
|
ENDIF
|
|
ELSE
|
|
SET_ENTITY_COORDS(snatchAndGrabVehicle[SAGV_MICHAEL_CAR], GET_SNATCH_AND_GRAB_VECTOR(SAGVEC_MEETING_POINT))
|
|
ENDIF
|
|
BREAK
|
|
CASE STAGE_GET_TO_BUILDING
|
|
IF IS_VEHICLE_DRIVEABLE(snatchAndGrabVehicle[SAGV_PLAYER_CHOPPER])
|
|
IF NOT IS_PED_IN_VEHICLE(PLAYER_PED_ID(), snatchAndGrabVehicle[SAGV_PLAYER_CHOPPER])
|
|
SET_PLAYER_PED_INTO_SNATCH_AND_GRAB_VEHICLE(SAGV_PLAYER_CHOPPER, VS_DRIVER)
|
|
IF NOT IS_PED_INJURED(sSelectorPeds.pedID[SELECTOR_PED_MICHAEL])
|
|
IF NOT IS_PED_IN_VEHICLE(sSelectorPeds.pedID[SELECTOR_PED_MICHAEL], snatchAndGrabVehicle[SAGV_PLAYER_CHOPPER])
|
|
SET_PED_INTO_VEHICLE(sSelectorPeds.pedID[SELECTOR_PED_MICHAEL], snatchAndGrabVehicle[SAGV_PLAYER_CHOPPER], VS_BACK_LEFT)
|
|
ENDIF
|
|
ENDIF
|
|
IF DOES_BLIP_EXIST(getToBlip)
|
|
REMOVE_BLIP(getToBlip)
|
|
ENDIF
|
|
ELSE
|
|
KILL_FACE_TO_FACE_CONVERSATION_DO_NOT_FINISH_LAST_LINE()
|
|
SET_ENTITY_COORDS(snatchAndGrabVehicle[SAGV_PLAYER_CHOPPER], GET_SNATCH_AND_GRAB_VECTOR(SAGVEC_HOVER_TARGET))
|
|
ENDIF
|
|
ENDIF
|
|
BREAK
|
|
CASE STAGE_RAPPEL_DOWN
|
|
IF NOT bInitialisedInterrogation
|
|
rappelData.vAttachPos.z = rappelData.fLimitZ
|
|
ELSE
|
|
KILL_ANY_CONVERSATION()
|
|
IF NOT bAllowSmashIn
|
|
SET_SYNCHRONIZED_SCENE_PHASE(iSyncScene, 0.69)
|
|
STOP_SYNCHRONIZED_AUDIO_EVENT(iSyncScene)
|
|
ELSE
|
|
bDebugJSkip = TRUE
|
|
ENDIF
|
|
ENDIF
|
|
BREAK
|
|
CASE STAGE_SNIPE_GUARDS
|
|
SWITCH extractStage
|
|
CASE EXTRACT_STAGE_KILL_INITIAL_GUARDS
|
|
UPDATE_PRISONER_GRAB(PRISONER_GRAB_STATE_DUCK_LOOPING)
|
|
KILL_ALL_GUARDS()
|
|
BREAK
|
|
CASE EXTRACT_STAGE_REINFORCEMENTS_ENTER
|
|
KILL_ALL_GUARDS()
|
|
bCreatedAdditionalReinforcement[0] = TRUE
|
|
bCreatedAdditionalReinforcement[1] = TRUE
|
|
bCreatedAdditionalReinforcement[2] = TRUE
|
|
bCreatedAdditionalReinforcement[3] = TRUE
|
|
BREAK
|
|
BREAK
|
|
ENDSWITCH
|
|
|
|
IF prisonerGrabState = PRISONER_GRAB_STATE_EXTRACT
|
|
IF NOT bActivatedRopeSwingFromSynced
|
|
//fTempPhase = 0.98
|
|
SET_SYNCHRONIZED_SCENE_PHASE(iSyncScene, 0.98)
|
|
ENDIF
|
|
ENDIF
|
|
BREAK
|
|
CASE STAGE_CHOPPER_CHASE
|
|
IF NOT bSpottedChopper
|
|
IF IS_VEHICLE_DRIVEABLE(snatchAndGrabVehicle[SAGV_PLAYER_CHOPPER])
|
|
IF IS_PLAYBACK_GOING_ON_FOR_VEHICLE(snatchAndGrabVehicle[SAGV_PLAYER_CHOPPER])
|
|
REMOVE_MISSION_TEXT()
|
|
KILL_ANY_CONVERSATION()
|
|
STOP_PLAYBACK_RECORDED_VEHICLE(snatchAndGrabVehicle[SAGV_PLAYER_CHOPPER])
|
|
START_PLAYBACK_RECORDED_VEHICLE(snatchAndGrabVehicle[SAGV_PLAYER_CHOPPER], 002, GET_SNATCH_AND_GRAB_RECORDING_PREFIX())
|
|
SKIP_TIME_IN_PLAYBACK_RECORDED_VEHICLE(snatchAndGrabVehicle[SAGV_PLAYER_CHOPPER], CHASE_SPOT_CHOPPER_TIME)
|
|
fPlaybackTime = CHASE_SPOT_CHOPPER_TIME
|
|
ENDIF
|
|
ENDIF
|
|
REMOVE_ALL_BLIPS()
|
|
bShownChopperPrompt = TRUE
|
|
ELSE
|
|
//IF IS_VEHICLE_DRIVEABLE(enemyChopperVehicle)
|
|
// EXPLODE_VEHICLE(enemyChopperVehicle)
|
|
//ENDIF
|
|
INT i
|
|
REPEAT COUNT_OF(enemyChopperPed) i
|
|
IF NOT IS_PED_INJURED(enemyChopperPed[i])
|
|
APPLY_DAMAGE_TO_PED(enemyChopperPed[i], 1000, TRUE)
|
|
ENDIF
|
|
ENDREPEAT
|
|
bDoneGetOutSpeech = TRUE
|
|
bShownChopperPrompt = TRUE
|
|
ENDIF
|
|
BREAK
|
|
CASE STAGE_DROPOFF
|
|
IF GET_CURRENT_PLAYER_PED_ENUM() <> CHAR_TREVOR
|
|
sSelectorPeds.eNewSelectorPed = SELECTOR_PED_TREVOR
|
|
bDebugJSkip = TRUE
|
|
ELSE
|
|
IF IS_VEHICLE_DRIVEABLE(snatchAndGrabVehicle[SAGV_PLAYER_CHOPPER])
|
|
IF NOT IS_PED_IN_VEHICLE(PLAYER_PED_ID(), snatchAndGrabVehicle[SAGV_PLAYER_CHOPPER])
|
|
SET_PLAYER_PED_INTO_SNATCH_AND_GRAB_VEHICLE(SAGV_PLAYER_CHOPPER, VS_DRIVER)
|
|
ELSE
|
|
KILL_ANY_CONVERSATION()
|
|
bDoneWayHomeSpeech = TRUE
|
|
bDoneGetOffRoofSpeech = TRUE
|
|
bDoneLandSpeech = TRUE
|
|
SET_PED_COORDS_KEEP_VEHICLE(PLAYER_PED_ID(), GET_SNATCH_AND_GRAB_VECTOR(SAGVEC_DROPOFF))
|
|
SET_PLAYER_CONTROL(PLAYER_ID(), FALSE)
|
|
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())
|
|
AND hotswapStage <> MISSION_HOTSWAP_STAGE_DO_SPLINE_CAM
|
|
IF IS_CUTSCENE_PLAYING()
|
|
STOP_CUTSCENE()
|
|
WHILE IS_CUTSCENE_PLAYING()
|
|
WAIT(0)
|
|
ENDWHILE
|
|
ENDIF
|
|
|
|
DO_SCREEN_FADE_OUT(500)
|
|
WHILE NOT IS_SCREEN_FADED_OUT()
|
|
WAIT(0)
|
|
ENDWHILE
|
|
|
|
COMMON_MISSION_CLEAR()
|
|
TRIGGER_MUSIC_EVENT("FIB2_DEATH_FAIL")
|
|
|
|
SWITCH currentMissionStage
|
|
CASE STAGE_GET_TO_CHOPPER
|
|
//POSITION_PLAYER_AT_MISSION_INIT(TRUE)
|
|
SET_MISSION_STAGE(STAGE_GET_TO_CHOPPER, TRUE)
|
|
BREAK
|
|
CASE STAGE_GET_TO_BUILDING
|
|
//POSITION_PLAYER_AT_MISSION_INIT(TRUE)
|
|
SET_MISSION_STAGE(STAGE_GET_TO_CHOPPER, TRUE)
|
|
BREAK
|
|
CASE STAGE_RAPPEL_DOWN
|
|
SET_MISSION_STAGE(STAGE_GET_TO_BUILDING, TRUE)
|
|
BREAK
|
|
CASE STAGE_SNIPE_GUARDS
|
|
SET_MISSION_STAGE(STAGE_RAPPEL_DOWN, TRUE)
|
|
BREAK
|
|
CASE STAGE_CHOPPER_CHASE
|
|
SET_MISSION_STAGE(STAGE_SNIPE_GUARDS, TRUE)
|
|
BREAK
|
|
CASE STAGE_DROPOFF
|
|
SET_MISSION_STAGE(STAGE_CHOPPER_CHASE, TRUE)
|
|
BREAK
|
|
ENDSWITCH
|
|
|
|
DO_SCREEN_FADE_IN(500)
|
|
ENDIF
|
|
ENDIF
|
|
|
|
// stage menu
|
|
IF NOT IS_PED_INJURED(PLAYER_PED_ID())
|
|
AND hotswapStage <> MISSION_HOTSWAP_STAGE_DO_SPLINE_CAM
|
|
AND NOT bRunningCutscene
|
|
IF LAUNCH_MISSION_STAGE_MENU(stageMenu, iMenuMissionStage)
|
|
DO_SCREEN_FADE_OUT(500)
|
|
WHILE NOT IS_SCREEN_FADED_OUT()
|
|
WAIT(0)
|
|
ENDWHILE
|
|
|
|
COMMON_MISSION_CLEAR()
|
|
TRIGGER_MUSIC_EVENT("FIB2_DEATH_FAIL")
|
|
|
|
// convert debug stage to mission stage
|
|
MISSION_STAGE_ENUM setStage
|
|
SWITCH iMenuMissionStage
|
|
CASE 0
|
|
setStage = STAGE_FOOD_COURT
|
|
BREAK
|
|
CASE 2
|
|
setStage = STAGE_GET_TO_CHOPPER
|
|
BREAK
|
|
CASE 4
|
|
setStage = STAGE_GET_TO_BUILDING
|
|
BREAK
|
|
CASE 6
|
|
setStage = STAGE_RAPPEL_DOWN
|
|
BREAK
|
|
CASE 8
|
|
setStage = STAGE_SNIPE_GUARDS
|
|
BREAK
|
|
CASE 10
|
|
setStage = STAGE_CHOPPER_CHASE
|
|
BREAK
|
|
CASE 11
|
|
setStage = STAGE_DROPOFF
|
|
BREAK
|
|
ENDSWITCH
|
|
|
|
IF setStage = STAGE_GET_TO_CHOPPER
|
|
IF NOT g_bMagDemoActive
|
|
// POSITION_PLAYER_AT_MISSION_INIT(TRUE)
|
|
ELSE
|
|
bDebugSkipMagdemoStart = TRUE
|
|
ENDIF
|
|
ENDIF
|
|
IF g_bMagDemoActive
|
|
bDebugSkipMagdemoZskipped = TRUE
|
|
ENDIF
|
|
|
|
SET_MISSION_STAGE(setStage, TRUE)
|
|
|
|
DO_SCREEN_FADE_IN(500)
|
|
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)
|
|
|
|
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
|
|
|
|
//FLOAT fDof = 1.0
|
|
|
|
// main script
|
|
SCRIPT
|
|
|
|
// Keep the radio off - COMMENTED OUT 263828
|
|
//SET_FRONTEND_RADIO_ACTIVE(FALSE)
|
|
|
|
//BREAK_ON_NATIVE_COMMAND("CLEAR_AREA", FALSE)
|
|
|
|
|
|
SET_MISSION_FLAG(TRUE)
|
|
IF HAS_FORCE_CLEANUP_OCCURRED()
|
|
Mission_Flow_Mission_Force_Cleanup()
|
|
MISSION_CLEANUP()
|
|
ENDIF
|
|
|
|
#IF IS_DEBUG_BUILD
|
|
CREATE_SNATCH_AND_GRAB_WIDGETS()
|
|
SETUP_SNATCH_AND_GRAB_DEBUG_MENU()
|
|
#ENDIF
|
|
|
|
// for magdemo
|
|
IF g_bMagDemoActive
|
|
IF NOT IS_PED_INJURED(PLAYER_PED_ID())
|
|
SET_PLAYER_WANTED_LEVEL(PLAYER_ID(), 0)
|
|
SET_PLAYER_WANTED_LEVEL_NOW(PLAYER_ID())
|
|
|
|
IF IS_PED_IN_ANY_VEHICLE(PLAYER_PED_ID())
|
|
VEHICLE_INDEX pVehicle = GET_VEHICLE_PED_IS_USING(PLAYER_PED_ID())
|
|
IF IS_VEHICLE_DRIVEABLE(pVehicle)
|
|
SET_ENTITY_AS_MISSION_ENTITY(pVehicle, TRUE, TRUE)
|
|
|
|
IF IS_PLAYBACK_GOING_ON_FOR_VEHICLE(pVehicle)
|
|
// STOP_PLAYBACK_RECORDED_VEHICLE(pVehicle)
|
|
|
|
PRINTSTRING("fbi2.STOP_PLAYBACK_RECORDED_VEHICLE(scene_veh)")
|
|
PRINTNL()
|
|
|
|
ELSE
|
|
|
|
PRINTSTRING("fbi2.no need(scene_veh)")
|
|
PRINTNL()
|
|
|
|
ENDIF
|
|
|
|
PED_INDEX pPed = GET_PED_IN_VEHICLE_SEAT(pVehicle, VS_FRONT_RIGHT)
|
|
IF NOT IS_PED_INJURED(pPed)
|
|
SET_ENTITY_AS_MISSION_ENTITY(pPed, TRUE, TRUE)
|
|
ELSE
|
|
PRINTSTRING("failed to pick up dave - injured!") PRINTNL()
|
|
ENDIF
|
|
ELSE
|
|
PRINTSTRING("failed to pick up tailgater - not driveable!") PRINTNL()
|
|
ENDIF
|
|
ELSE
|
|
PRINTSTRING("failed to pick up tailgater - not in any vehicle!") PRINTNL()
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF DOES_ENTITY_EXIST(g_sMagDemoFBI2Entities.heliVehicle)
|
|
SET_ENTITY_AS_MISSION_ENTITY(g_sMagDemoFBI2Entities.heliVehicle, TRUE, TRUE)
|
|
ELSE
|
|
PRINTSTRING("failed to pick up heli - doesn't exist!") PRINTNL()
|
|
ENDIF
|
|
IF DOES_ENTITY_EXIST(g_sMagDemoFBI2Entities.bikeVehicle)
|
|
SET_ENTITY_AS_MISSION_ENTITY(g_sMagDemoFBI2Entities.bikeVehicle, TRUE, TRUE)
|
|
ELSE
|
|
PRINTSTRING("failed to pick up bike - doesn't exist!") PRINTNL()
|
|
ENDIF
|
|
IF DOES_ENTITY_EXIST(g_sMagDemoFBI2Entities.trevorPed)
|
|
SET_ENTITY_AS_MISSION_ENTITY(g_sMagDemoFBI2Entities.trevorPed, TRUE, TRUE)
|
|
ELSE
|
|
PRINTSTRING("failed to pick up trevor - doesn't exist!") PRINTNL()
|
|
ENDIF
|
|
IF DOES_ENTITY_EXIST(g_sMagDemoFBI2Entities.fibPed)
|
|
SET_ENTITY_AS_MISSION_ENTITY(g_sMagDemoFBI2Entities.fibPed, TRUE, TRUE)
|
|
ELSE
|
|
PRINTSTRING("failed to pick up agent - doesn't exist!") PRINTNL()
|
|
ENDIF
|
|
IF DOES_ENTITY_EXIST(g_sMagDemoFBI2Entities.franklinPed)
|
|
SET_ENTITY_AS_MISSION_ENTITY(g_sMagDemoFBI2Entities.franklinPed, TRUE, TRUE)
|
|
ELSE
|
|
PRINTSTRING("failed to pick up franklin - doesn't exist!") PRINTNL()
|
|
ENDIF
|
|
IF DOES_ENTITY_EXIST(g_sMagDemoFBI2Entities.truck01Vehicle)
|
|
SET_ENTITY_AS_MISSION_ENTITY(g_sMagDemoFBI2Entities.truck01Vehicle, TRUE, TRUE)
|
|
ELSE
|
|
PRINTSTRING("failed to pick up truck1 - doesn't exist!") PRINTNL()
|
|
ENDIF
|
|
IF DOES_ENTITY_EXIST(g_sMagDemoFBI2Entities.truck02Vehicle)
|
|
SET_ENTITY_AS_MISSION_ENTITY(g_sMagDemoFBI2Entities.truck02Vehicle, TRUE, TRUE)
|
|
ELSE
|
|
PRINTSTRING("failed to pick up truck2 - doesn't exist!") PRINTNL()
|
|
ENDIF
|
|
IF DOES_ENTITY_EXIST(g_sMagDemoFBI2Entities.fibVehicle)
|
|
SET_ENTITY_AS_MISSION_ENTITY(g_sMagDemoFBI2Entities.fibVehicle, TRUE, TRUE)
|
|
ELSE
|
|
PRINTSTRING("failed to pick up fibvehicle - doesn't exist!") PRINTNL()
|
|
ENDIF
|
|
ENDIF
|
|
|
|
bAlternateChopper = FALSE
|
|
bShortRope = FALSE
|
|
bShortRope=bShortRope
|
|
fUpwardsForce=fUpwardsForce
|
|
iSpinModifier=iSpinModifier
|
|
fSpinForce=fSpinForce
|
|
bReattachedMichael = bReattachedMichael
|
|
iCutsceneTriggerTime=iCutsceneTriggerTime
|
|
|
|
INIT_PC_SCRIPTED_CONTROLS("Rappelling")
|
|
|
|
WHILE TRUE
|
|
REPLAY_CHECK_FOR_EVENT_THIS_FRAME(GET_RECORD_PREFIX())
|
|
|
|
IF INIT_MISSION()
|
|
IF NOT IS_PED_INJURED(PLAYER_PED_ID())
|
|
|
|
// do streaming for next stage
|
|
DO_STREAMING_FOR_NEXT_MISSION_STAGE(FALSE)
|
|
|
|
// do fail state
|
|
#IF IS_DEBUG_BUILD
|
|
IF NOT bSwitchCamDebugScenarioEnabled
|
|
#ENDIF
|
|
HANDLE_MISSION_FAIL_STATE()
|
|
#IF IS_DEBUG_BUILD
|
|
ENDIF
|
|
#ENDIF
|
|
|
|
// head tracking
|
|
HANDLE_BUDDY_HEAD_TRACK_WHILE_ENTERING_VEHICLE()
|
|
|
|
// run appropriate stage
|
|
SWITCH currentMissionStage
|
|
CASE STAGE_FOOD_COURT
|
|
DO_STAGE_FOOD_COURT()
|
|
BREAK
|
|
|
|
CASE STAGE_GET_TO_CHOPPER
|
|
DO_STAGE_GET_TO_CHOPPER()
|
|
BREAK
|
|
|
|
CASE STAGE_GET_TO_BUILDING
|
|
DO_STAGE_GET_TO_BUILDING()
|
|
BREAK
|
|
|
|
CASE STAGE_RAPPEL_DOWN
|
|
DO_STAGE_RAPPEL_DOWN()
|
|
BREAK
|
|
|
|
CASE STAGE_SNIPE_GUARDS
|
|
DO_STAGE_SNIPE_GUARDS()
|
|
BREAK
|
|
|
|
CASE STAGE_CHOPPER_CHASE
|
|
DO_STAGE_CHOPPER_CHASE()
|
|
BREAK
|
|
|
|
CASE STAGE_DROPOFF
|
|
DO_STAGE_DROPOFF()
|
|
BREAK
|
|
ENDSWITCH
|
|
ENDIF
|
|
|
|
#IF IS_DEBUG_BUILD
|
|
IF CAN_ADVANCE_MISSION()
|
|
DO_DEBUG_SKIPS()
|
|
ENDIF
|
|
DO_RB_DEBUG_CAM_DUMP()
|
|
// UPDATE_SPLINE_CAM_WIDGETS(scsSwitch_FranklinToHeli_Mike)
|
|
// UPDATE_SPLINE_CAM_WIDGETS(scsSwitch_FranklinToHeli_Trev)
|
|
// UPDATE_SPLINE_CAM_WIDGETS(scsSwitch_HangingToSniper)
|
|
// UPDATE_SPLINE_CAM_WIDGETS(scsSwitch_Heli_Michael_ToFranklin)
|
|
// UPDATE_SPLINE_CAM_WIDGETS(scsSwitch_Heli_MichaelToTrevor)
|
|
// UPDATE_SPLINE_CAM_WIDGETS(scsSwitch_Heli_Trevor_ToFranklin)
|
|
// UPDATE_SPLINE_CAM_WIDGETS(scsSwitch_Heli_TrevorToMichael)
|
|
// HANDLE_SWITCH_CAM_SPECIFIC_WIDGETS()
|
|
#ENDIF
|
|
ENDIF
|
|
|
|
WAIT(0)
|
|
ENDWHILE
|
|
ENDSCRIPT
|