16173 lines
516 KiB
Python
Executable File
16173 lines
516 KiB
Python
Executable File
//+-----------------------------------------------------------------------------+
|
|
//¦ Author: Rob Bray Date: 12/01/11 ¦
|
|
//¦-----------------------------------------------------------------------------¦
|
|
//¦ ¦
|
|
//¦ ¦
|
|
//¦ Exile 1 - Cargo Plane ¦
|
|
//¦ ¦
|
|
//¦ ¦
|
|
//+-----------------------------------------------------------------------------+
|
|
|
|
//Compile out Title Update changes to header functions.
|
|
//Must be before includes.
|
|
//CONST_INT USE_TU_CHANGES 0 // Removed by Kenneth R.
|
|
|
|
// REMOVE REQUEST IPL CALLS!!
|
|
|
|
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_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 "cutscene_public.sch"
|
|
USING "chase_hint_cam.sch" CHASE_HINT_CAM_STRUCT localChaseHintCamStruct
|
|
USING "script_ped.sch"
|
|
USING "script_blips.sch"
|
|
USING "script_buttons.sch"
|
|
USING "select_mission_stage.sch"
|
|
USING "replay_public.sch"
|
|
USING "mission_stat_public.sch"
|
|
USING "taxi_functions.sch"
|
|
USING "clearMissionArea.sch"
|
|
USING "area_checks.sch"
|
|
USING "CompletionPercentage_public.sch"
|
|
USING "vehicle_gen_public.sch"
|
|
USING "locates_public.sch"
|
|
USING "respawn_location_private.sch"
|
|
USING "buddy_head_track_public.sch"
|
|
USING "properties_public.sch"
|
|
USING "emergency_call.sch"
|
|
USING "spline_cam_edit.sch"
|
|
USING "fake_cellphone_public.sch"
|
|
USING "commands_recording.sch"
|
|
|
|
// Enums
|
|
ENUM MISSION_INIT_STAGE_ENUM
|
|
MISSION_INIT_PRE_INTRO = 0,
|
|
MISSION_INIT_REQUEST_INTRO_ASSETS,
|
|
MISSION_INIT_WAIT_FOR_INTRO_ASSETS,
|
|
MISSION_INIT_WAIT_TRAILER_INTERIOR,
|
|
MISSION_INIT_CREATE_INTRO_ASSETS,
|
|
MISSION_INIT_PLAY_INTRO,
|
|
MISSION_INIT_DONE
|
|
ENDENUM
|
|
|
|
ENUM MISSION_STAGE_ENUM
|
|
STAGE_GET_TO_AIRSTRIP = 0,
|
|
STAGE_FOLLOW_PLANE_1,
|
|
STAGE_FOLLOW_PLANE_2,
|
|
STAGE_FOLLOW_PLANE_3,
|
|
STAGE_ENTER_PLANE,
|
|
STAGE_PLANE_FIGHT,
|
|
STAGE_FLY_PLANE,
|
|
STAGE_ESCAPE_PLANE
|
|
ENDENUM
|
|
|
|
ENUM FAIL_REASON_ENUM
|
|
FAIL_RON_DEAD = 0,
|
|
FAIL_TREVOR_PLANE_DESTROYED,
|
|
FAIL_CARGO_PLANE_DESTROYED,
|
|
FAIL_MISSED_CARGO_PLANE,
|
|
FAIL_LOST_CARGO_PLANE,
|
|
FAIL_FELL_FROM_CARGO_PLANE,
|
|
FAIL_ABANDONED_PLANE,
|
|
FAIL_ABANDONED_RON,
|
|
FAIL_TREVOR_DEAD,
|
|
FAIL_TOO_HIGH,
|
|
FAIL_OVER_BASE,
|
|
FAIL_PLANE_STUCK,
|
|
FAIL_MICHAEL_DEAD,
|
|
FAIL_PATRICIA_DEAD,
|
|
FAIL_PLANE_FORCED_GLIDE,
|
|
FAIL_LEFT_WORLD
|
|
ENDENUM
|
|
|
|
ENUM MISSION_FAIL_STATE_ENUM
|
|
MISSION_FAIL_STATE_NOT_FAILED = 0,
|
|
MISSION_FAIL_STATE_WAIT_FOR_FADE
|
|
ENDENUM
|
|
|
|
ENUM MISSION_HOTSWAP_STAGE_ENUM
|
|
MISSION_HOTSWAP_STAGE_SELECT_CHARACTER = 0,
|
|
MISSION_HOTSWAP_STAGE_DO_SPLINE_CAM
|
|
ENDENUM
|
|
|
|
ENUM MISSION_STREAMING_STAGE_ENUM
|
|
MISSION_STREAMING_STAGE_REQUEST = 0,
|
|
MISSION_STREAMING_STAGE_WAIT,
|
|
MISSION_STREAMING_STAGE_COMPLETE
|
|
ENDENUM
|
|
|
|
ENUM MOCAP_STREAMING_STAGE_ENUM
|
|
MOCAP_STREAMING_STAGE_REQUEST = 0,
|
|
MOCAP_STREAMING_STAGE_WAIT,
|
|
MOCAP_STREAMING_STAGE_COMPLETE
|
|
ENDENUM
|
|
|
|
ENUM PLANE_FIGHT_MODEL_ENUM
|
|
PFM_TREVOR = 0,
|
|
PFM_FRANKLIN,
|
|
PFM_RON,
|
|
PFM_MICHAEL,
|
|
PFM_PATRICIA,
|
|
PFM_SOLDIER,
|
|
PFM_PILOT,
|
|
PFM_ENEMY,
|
|
PFM_TREVOR_4WD,
|
|
PFM_TREVOR_PLANE,
|
|
PFM_CARGO_PLANE,
|
|
PFM_JET,
|
|
PFM_4WD,
|
|
//PFM_VAN,
|
|
PFM_COVER1,
|
|
PFM_COVER2,
|
|
PFM_PLANE_ROOT,
|
|
PFM_FRANKLIN_PHONE,
|
|
PFM_MICHAEL_PHONE,
|
|
PFM_LIGHT_RIG,
|
|
//PFM_REFLECT_RIG,
|
|
PFM_CHAIR,
|
|
PFM_RADIO,
|
|
PFM_LAST_VEHICLE
|
|
ENDENUM
|
|
|
|
ENUM PLANE_FIGHT_VECTOR_ENUM
|
|
PFVEC_TREVOR_4WD_INIT = 0,
|
|
PFVEC_PLAYER_INIT,
|
|
PFVEC_TREVOR_PLANE_INIT,
|
|
PFVEC_TREVOR_PLANE_MID_POINT,
|
|
PFVEC_TREVOR_PLANE_CLIMB_POINT,
|
|
PFVEC_TREVOR_PLANE_ENTER_POINT,
|
|
PFVEC_CARGO_PLANE_INIT,
|
|
PFVEC_CARGO_PLANE_FLY,
|
|
PFVEC_CARGO_PLANE_DESCEND,
|
|
PFVEC_TREVOR_INSIDE_PLANE_INIT,
|
|
PFVEC_AIRSTRIP,
|
|
PFVEC_RON_INIT,
|
|
PFVEC_RON_STAND,
|
|
PFVEC_ATTACH_TREVOR_PLANE,
|
|
PFVEC_CRASH_SMOKE_OFFSET,
|
|
PFVEC_ENGINE_OFFSET,
|
|
PFVEC_CLOUD_OFFSET,
|
|
PFVEC_SMOKE_FLIGHT_OFFSET,
|
|
PFVEC_PASSED,
|
|
PFVEC_RUNWAY,
|
|
PFVEC_BASE_LAUNCH,
|
|
PFVEC_MOVE_LAST_PLAYER_VEHICLE
|
|
ENDENUM
|
|
|
|
ENUM PLANE_FIGHT_VEHICLE_ENUM
|
|
PFV_TREVOR_4WD = 0,
|
|
PFV_TREVOR_PLANE,
|
|
PFV_CARGO_PLANE
|
|
ENDENUM
|
|
|
|
ENUM PLANE_FIGHT_SHOT_DETAILS_ENUM
|
|
PF_SHOT_CARGO_DOOR_OPEN = 0,
|
|
PF_SHOT_CRASH_IN_INT,
|
|
PF_SHOT_CRASH_IN_EXT,
|
|
PF_SHOT_CRASH_IN_JUMP_OUT,
|
|
PF_SHOT_WAVE_DOWN,
|
|
PF_SHOT_WAVE_DOWNB,
|
|
PF_SHOT_CRASH_INTO_SEA,
|
|
PF_SHOT_CRASH_INTO_SEAB,
|
|
PF_SHOT_ENTER_SEAT,
|
|
PF_SHOT_ENTER_SEATB
|
|
ENDENUM
|
|
|
|
ENUM PLANE_FIGHT_ANIM_DICT_ENUM
|
|
PF_ANIM_DICT_MISSION = 0,
|
|
PF_ANIM_DICT_LADDERS_BASE,
|
|
PF_ANIM_DICT_LADDERS_MAIN,
|
|
PF_ANIM_DICT_TO_PARACHUTE,
|
|
PF_ANIM_DICT_CELLPHONE,
|
|
PF_ANIM_DICT_LEADOUT,
|
|
PF_ANIM_DICT_LEADIN
|
|
ENDENUM
|
|
|
|
ENUM PLANE_FIGHT_WEAPON_ENUM
|
|
PF_WEAPON_MERC_PISTOL = 0,
|
|
PF_WEAPON_MERC_SHOTGUN,
|
|
PF_WEAPON_MERC_LMG,
|
|
PF_WEAPON_MERC_RPG,
|
|
PF_WEAPON_PILOT_PISTOL,
|
|
PF_WEAPON_PLAYER_BACKUP
|
|
ENDENUM
|
|
|
|
ENUM PLANE_FIGHT_PTFX_ENUM
|
|
PF_PTFX_MISSION = 0
|
|
ENDENUM
|
|
|
|
ENUM PLANE_FIGHT_SFX_ENUM
|
|
PF_SFX_ALARM = 0,
|
|
PF_SFX_CAR1,
|
|
PF_SFX_CAR2,
|
|
PF_SFX_CAR3,
|
|
PF_SFX_FAIL,
|
|
PF_SFX_TRANSITION
|
|
ENDENUM
|
|
|
|
ENUM PLANE_FIGHT_MISC_ASSET_ENUM
|
|
PF_MISC_ASSET_TEMP = 0
|
|
ENDENUM
|
|
|
|
ENUM PLANE_FIGHT_CUTSCENE_STAGE_ENUM
|
|
PF_CUT_STAGE_INIT = 0,
|
|
PF_CUT_STAGE_RUNNING,
|
|
PF_CUT_STAGE_CLEANUP
|
|
ENDENUM
|
|
|
|
ENUM PLANE_ROLL_DIR_ENUM
|
|
PLANE_ROLL_DIR_CLOCKWISE = 0,
|
|
PLANE_ROLL_DIR_ANTICLOCKWISE
|
|
ENDENUM
|
|
|
|
ENUM PLANE_ROLL_SPEED_ENUM
|
|
PLANE_ROLL_SPEED_VERY_SLOW = 0,
|
|
PLANE_ROLL_SPEED_SLOW,
|
|
PLANE_ROLL_SPEED_MED,
|
|
PLANE_ROLL_SPEED_FAST
|
|
ENDENUM
|
|
|
|
ENUM PLANE_PITCH_DIR_ENUM
|
|
PLANE_PITCH_DIR_DIVE = 0,
|
|
PLANE_PITCH_DIR_CLIMB
|
|
ENDENUM
|
|
|
|
ENUM PLANE_PITCH_SPEED_ENUM
|
|
PLANE_PITCH_SPEED_SLOW = 0,
|
|
PLANE_PITCH_SPEED_MED,
|
|
PLANE_PITCH_SPEED_FAST
|
|
ENDENUM
|
|
|
|
ENUM TRANSPORTED_VEHICLE_TYPE_ENUM
|
|
TRANSPORTED_VEHICLE_TYPE_VAN = 0,
|
|
TRANSPORTED_VEHICLE_TYPE_4WD
|
|
ENDENUM
|
|
|
|
ENUM TRANSPORTED_VEHICLE_INDEX_ENUM
|
|
TRANSPORTED_VEHICLE_INDEX_4WD_DRIVE = 0,
|
|
TRANSPORTED_VEHICLE_INDEX_4WD_SLIDE_OUT,
|
|
TRANSPORTED_VEHICLE_INDEX_4WD_L_1,
|
|
TRANSPORTED_VEHICLE_INDEX_4WD_L_2,
|
|
TRANSPORTED_VEHICLE_INDEX_4WD_L_3,
|
|
TRANSPORTED_VEHICLE_INDEX_4WD_L_4,
|
|
TRANSPORTED_VEHICLE_INDEX_4WD_R_1,
|
|
TRANSPORTED_VEHICLE_INDEX_4WD_R_2
|
|
ENDENUM
|
|
|
|
ENUM NAMED_ENEMY_PED_ENUM
|
|
ENEMY_PILOT = 0,
|
|
//ENEMY_COPILOT,
|
|
ENEMY_RAMP_MACHINE_GUN,
|
|
ENEMY_RAMP_RPG
|
|
ENDENUM
|
|
|
|
ENUM COVER_OBJECT_TYPE_ENUM
|
|
COVER_OBJECT_TYPE_SHORT = 0,
|
|
COVER_OBJECT_TYPE_LONG
|
|
ENDENUM
|
|
|
|
ENUM COVER_OBJECT_INDEX_ENUM
|
|
COVER_OBJECT_INDEX_BATCH1_1_L1 = 0,
|
|
COVER_OBJECT_INDEX_BATCH1_2_S1,
|
|
//COVER_OBJECT_INDEX_BATCH1_2_S2,
|
|
COVER_OBJECT_INDEX_BATCH1_3_S1,
|
|
COVER_OBJECT_INDEX_BATCH1_3_S2,
|
|
COVER_OBJECT_INDEX_BATCH2_2_L1,
|
|
COVER_OBJECT_INDEX_BATCH2_1_S1,
|
|
COVER_OBJECT_INDEX_BATCH2_1_S2,
|
|
COVER_OBJECT_INDEX_BATCH2_3_L1,
|
|
|
|
COVER_OBJECT_INDEX_BATCHD_1,
|
|
COVER_OBJECT_INDEX_BATCHD_2,
|
|
COVER_OBJECT_INDEX_BATCHD_3,
|
|
COVER_OBJECT_INDEX_BATCHD_4,
|
|
COVER_OBJECT_INDEX_BATCHD_5
|
|
ENDENUM
|
|
|
|
ENUM PLANE_SMOKE_ENUM
|
|
PLANE_SMOKE_CLOUDS = 0,
|
|
PLANE_SMOKE_ENGINE_FIRE,
|
|
PLANE_SMOKE_ENGINE_EXPLOSION,
|
|
PLANE_SMOKE_CRASH_SMOKE_R1,
|
|
PLANE_SMOKE_CRASH_SMOKE_FLIGHT,
|
|
PLANE_SMOKE_SPEW_DEBRIS,
|
|
PLANE_SMOKE_GROUND_EXPLOSION,
|
|
PLANE_SMOKE_GROUND_DUST_IMPACT,
|
|
PLANE_SMOKE_GROUND_DUST_SETTLE,
|
|
PLANE_SMOKE_HOLD_FIRE_1,
|
|
PLANE_SMOKE_HOLD_FIRE_2,
|
|
PLANE_SMOKE_HOLD_FIRE_3,
|
|
PLANE_SMOKE_HOLD_FIRE_4,
|
|
PLANE_SMOKE_HOLD_FIRE_5,
|
|
PLANE_SMOKE_HOLD_WIRES_1,
|
|
PLANE_SMOKE_HOLD_WIRES_2
|
|
ENDENUM
|
|
|
|
ENUM FLY_PLANE_STATE_ENUM
|
|
FLY_PLANE_FINE = 0,
|
|
FLY_PLANE_POST_ENGINE,
|
|
FLY_PLANE_POST_FIREBALL
|
|
ENDENUM
|
|
|
|
ENUM JET_ATTACK_STATE_ENUM
|
|
JET_ATTACK_NOT_CREATED = 0,
|
|
JET_ATTACK_FLY_TO_PLANE,
|
|
JET_ATTACK_TO_REAR,
|
|
JET_ATTACK_ESCORT,
|
|
JET_ATTACK_FALL_BACK_TO_SHOOT,
|
|
JET_ATTACK_MISSILES,
|
|
JET_ATTACK_OVERTAKE,
|
|
JET_ATTACK_FLY_HOME
|
|
ENDENUM
|
|
|
|
ENUM PLANE_FALLING_STATE_ENUM
|
|
PLANE_FALLING_ON_RECORDING = 0,
|
|
PLANE_FALLING_FORCE_TO_DIVE,
|
|
PLANE_FALLING_DONE
|
|
ENDENUM
|
|
|
|
ENUM JET_MISSILE_STATE_ENUM
|
|
JET_MISSILE_STATE_NOT_LAUNCHED = 0,
|
|
JET_MISSILE_STATE_LAUNCH_READY,
|
|
JET_MISSILE_STATE_IN_FLIGHT,
|
|
JET_MISSILE_STATE_EXPLODED
|
|
ENDENUM
|
|
|
|
ENUM PLANE_INTERIOR_STREAMING_STAGE_ENUM
|
|
PLANE_INTERIOR_STREAMING_NOT_STARTED = 0,
|
|
PLANE_INTERIOR_STREAMING_WAIT,
|
|
PLANE_INTERIOR_STREAMING_DONE
|
|
ENDENUM
|
|
|
|
ENUM LADDER_STATE_ENUM
|
|
LADDER_STATE_NOT_ON = 0,
|
|
LADDER_STATE_GETTING_ON,
|
|
LADDER_STATE_GETTING_OFF_BOTTOM,
|
|
LADDER_STATE_GETTING_OFF_TOP,
|
|
LADDER_STATE_GOING_UP,
|
|
LADDER_STATE_GOING_DOWN,
|
|
LADDER_STATE_IDLE
|
|
ENDENUM
|
|
|
|
ENUM ENEMY_AI_STATE_ENUM
|
|
ENEMY_AI_NOT_TASKED = 0,
|
|
ENEMY_AI_COMBAT,
|
|
ENEMY_AI_MOVING
|
|
ENDENUM
|
|
|
|
ENUM CREATE_PLANE_STAGE_ENUM
|
|
CREATE_PLANE_STAGE_NOT_STARTED = 0,
|
|
CREATE_PLANE_STAGE_WAITING,
|
|
CREATE_PLANE_STAGE_DONE
|
|
ENDENUM
|
|
|
|
ENUM PLANE_FIGHT_AUDIO_SCENE_ENUM
|
|
PLANE_FIGHT_AUDIO_SCENE_DRIVE_TO_PLANE = 0,
|
|
PLANE_FIGHT_AUDIO_SCENE_FLIGHT_MAIN,
|
|
PLANE_FIGHT_AUDIO_SCENE_CARGO_PLANE_APPEARS,
|
|
PLANE_FIGHT_AUDIO_SCENE_FOCUS_ON_CARGO_PLANE,
|
|
PLANE_FIGHT_AUDIO_SCENE_FLIGHT_START_CLIMB,
|
|
PLANE_FIGHT_AUDIO_SCENE_TREVOR_GETS_WARNING,
|
|
PLANE_FIGHT_AUDIO_SCENE_ENEMY_OPENS_FIRE,
|
|
PLANE_FIGHT_AUDIO_SCENE_SHOOTOUT_CARGO_HOLD,
|
|
PLANE_FIGHT_AUDIO_SCENE_HIJACK_THE_PLANE,
|
|
PLANE_FIGHT_AUDIO_SCENE_FLY_CARGO_PLANE,
|
|
PLANE_FIGHT_AUDIO_SCENE_FIGHTER_JETS_ARRIVE,
|
|
PLANE_FIGHT_AUDIO_SCENE_FIGHTER_JET_CAMERA,
|
|
PLANE_FIGHT_AUDIO_SCENE_COCKPIT_CUTSCENE,
|
|
PLANE_FIGHT_AUDIO_SCENE_ROCKETS_FIRED,
|
|
PLANE_FIGHT_AUDIO_SCENE_PLANE_GOING_DOWN,
|
|
PLANE_FIGHT_AUDIO_SCENE_ESCAPE_ON_FOOT,
|
|
PLANE_FIGHT_AUDIO_SCENE_ESCAPE_IN_CAR,
|
|
PLANE_FIGHT_AUDIO_SCENE_SKYDIVE,
|
|
PLANE_FIGHT_AUDIO_SCENE_DEPLOY_PARACHUTE,
|
|
PLANE_FIGHT_AUDIO_SCENE_FOCUS_ON_CRASHING_PLANE
|
|
ENDENUM
|
|
|
|
ENUM JET_FLY_ALONGSIDE_STATE_ENUM
|
|
JET_FLY_ALONGSIDE_POSITION_BEHIND = 0,
|
|
JET_FLY_ALONGSIDE_POSITION_ABOVE_CABIN,
|
|
JET_FLY_ALONGSIDE_GO_TO_CABIN,
|
|
JET_FLY_ALONGSIDE_POSITION_FOR_FALLBACK,
|
|
JET_FLY_ALONGSIDE_DONE
|
|
ENDENUM
|
|
|
|
ENUM SHAPE_TEST_STATE_ENUM
|
|
SHAPE_TEST_STATE_NOT_STARTED = 0,
|
|
SHAPE_TEST_STATE_WAITING
|
|
ENDENUM
|
|
|
|
|
|
/*
|
|
ENUM CUTSCENE_STREAMING_STATE
|
|
CSS_TRAILER_EXT,
|
|
CSS_TRAILER_INT,
|
|
CSS_EXT,
|
|
CSS_END
|
|
ENDENUM
|
|
CUTSCENE_STREAMING_STATE eCutStreamState = CSS_TRAILER_EXT
|
|
*/
|
|
|
|
// Consts
|
|
CONST_INT NUMBER_MODEL_REQUEST_SLOTS COUNT_OF(PLANE_FIGHT_MODEL_ENUM)
|
|
CONST_INT NUMBER_RECORDING_REQUEST_SLOTS 6
|
|
CONST_INT NUMBER_ENEMY_PEDS 8
|
|
CONST_INT NUMBER_JETS 2
|
|
CONST_INT NUMBER_MISSILES 4
|
|
CONST_INT NUMBER_DEBRIS_OBJECTS 4
|
|
CONST_INT STICK_MOVEMENT_CLIMB_ROPE -100
|
|
CONST_INT MAX_SKIP_MENU_LENGTH 8
|
|
CONST_INT SKIP_FADE_WAIT_TIME 200
|
|
CONST_INT SKIP_FADE_LONG_WAIT_TIME 2500
|
|
CONST_INT PLAYER_VEHICLE_SEARCH_FLAGS VEHICLE_SEARCH_FLAG_RETURN_MISSION_VEHICLES | VEHICLE_SEARCH_FLAG_RETURN_RANDOM_VEHICLES | VEHICLE_SEARCH_FLAG_RETURN_VEHICLES_CONTAINING_GROUP_MEMBERS | VEHICLE_SEARCH_FLAG_RETURN_VEHICLES_CONTAINING_A_PLAYER | VEHICLE_SEARCH_FLAG_RETURN_VEHICLES_CONTAINING_A_DEAD_OR_DYING_PED | VEHICLE_SEARCH_FLAG_RETURN_VEHICLES_WITH_PEDS_ENTERING_OR_EXITING | VEHICLE_SEARCH_FLAG_ALLOW_VEHICLE_OCCUPANTS_TO_BE_PERFORMING_A_SCRIPTED_TASK
|
|
|
|
CONST_INT NUMBER_FLIGHT_SUBSTAGES 10
|
|
CONST_INT FWD_DETACH_HEALTH 850
|
|
CONST_INT VAN_DETACH_HEALTH 800
|
|
CONST_INT ALLOW_DESTRUCTION_TIME 5000
|
|
CONST_INT DUSTER_BEHIND_TIME 4500
|
|
//CONST_INT PLANE_SKIP_TIME_INIT
|
|
//CONST_INT PLANE_SKIP_TIME_AT
|
|
|
|
CONST_INT MIN_RANDOM_SPEECH_TIME 7000
|
|
CONST_INT MAX_RANDOM_SPEECH_TIME 12000
|
|
|
|
CONST_INT PAD_SHAKE_AMPLITUDE 128
|
|
|
|
CONST_FLOAT CLEAR_POS_RADIUS 3.2
|
|
/*
|
|
CONST_FLOAT FWD_ATTACH_Z -3.49
|
|
CONST_FLOAT VAN_ATTACH_Z -3.17
|
|
CONST_FLOAT BIKE_ATTACH_Z -3.50
|
|
*/
|
|
CONST_FLOAT FWD_ATTACH_Z -3.20 // -3.49
|
|
CONST_FLOAT VAN_ATTACH_Z -3.37
|
|
|
|
CONST_FLOAT PED_ATTACH_Z -4.0
|
|
CONST_FLOAT LONG_COVER_ATTACH_Z -3.45
|
|
CONST_FLOAT SHORT_COVER_ATTACH_Z -3.45
|
|
|
|
CONST_FLOAT PLANE_ROLL_ACCELERATION 3.5
|
|
CONST_FLOAT PLANE_ROLL_DECELERATION 6.3
|
|
CONST_FLOAT PLANE_PITCH_ACCELERATION 1.0
|
|
CONST_FLOAT PLANE_PITCH_DECELERATION 1.8
|
|
|
|
CONST_FLOAT CARGO_PLANE_SPEED 0.70
|
|
CONST_FLOAT RON_CHAT_AT_PLANE_DISTANCE 20.0
|
|
|
|
CONST_FLOAT ATTACH_PLANE_X 0.4
|
|
CONST_FLOAT ATTACH_PLANE_INIT_Z -3.2
|
|
CONST_FLOAT ATTACH_PLANE_END_Z -2.1
|
|
CONST_FLOAT ATTACH_PLANE_INIT_Y -47.0
|
|
CONST_FLOAT ATTACH_PLANE_END_Y -33.0
|
|
CONST_FLOAT ATTACH_PLANE_INIT_SPEED 15.0
|
|
CONST_FLOAT ATTACH_PLANE_ASCEND_SPEED 1.0
|
|
CONST_FLOAT ATTACH_PLANE_DECELERATION 12.0
|
|
|
|
CONST_FLOAT RAMP_MACHINE_GUN_ATTACH_X 1.08245
|
|
CONST_FLOAT RAMP_MACHINE_GUN_ATTACH_INIT_Y -18.0
|
|
CONST_FLOAT RAMP_MACHINE_GUN_ATTACH_INIT_Z -3.0
|
|
CONST_FLOAT RAMP_MACHINE_GUN_ATTACH_END_Y -37.7809
|
|
CONST_FLOAT RAMP_MACHINE_GUN_ATTACH_END_Z -5.74982
|
|
|
|
//[Script] RPG OFFSET = <<, -32.7518, >>
|
|
//[Script] MG OFFSET = << , -39.1809, -5.04982 >>
|
|
|
|
CONST_FLOAT RAMP_RPG_ATTACH_X -1.28529
|
|
CONST_FLOAT RAMP_RPG_ATTACH_INIT_Y -13.0
|
|
CONST_FLOAT RAMP_RPG_ATTACH_INIT_Z -3.0
|
|
CONST_FLOAT RAMP_RPG_ATTACH_END_Y -32.7518
|
|
CONST_FLOAT RAMP_RPG_ATTACH_END_Z -4.75798
|
|
|
|
CONST_FLOAT FLIP_OVER_Y 18.6
|
|
CONST_FLOAT JUMP_OFF_Y -25.0
|
|
CONST_FLOAT JUMP_OFF_Z 7.0
|
|
CONST_FLOAT FALL_FROM_Z 6.0
|
|
CONST_FLOAT ALLOW_DESTRUCTION_ROLL 1.0
|
|
CONST_FLOAT INIT_VAN_2_Y_OFFSET 12.0
|
|
|
|
CONST_FLOAT DODGE_CHECK_DISTANCE 8.0
|
|
CONST_FLOAT CAM_SHAKE_AMPLITUDE 0.07
|
|
|
|
CONST_FLOAT ALLOW_FLY_HIGH_TIME 183000.0
|
|
CONST_FLOAT STREAM_CARGO_PLANE_INTERIOR_TIME 170000.0
|
|
|
|
CONST_FLOAT PLAYER_INIT_ROT 48.0//-79.12
|
|
CONST_FLOAT TREVOR_4WD_INIT_ROT -60.09
|
|
CONST_FLOAT TREVOR_PLANE_INIT_ROT 27.5
|
|
CONST_FLOAT TREVOR_PLANE_MID_POINT_ROT -42.49
|
|
CONST_FLOAT TREVOR_PLANE_CLIMB_POINT_ROT -169.9
|
|
CONST_FLOAT TREVOR_PLANE_ENTER_POINT_ROT -171.8
|
|
CONST_FLOAT TREVOR_INSIDE_PLANE_INIT_ROT 0.0
|
|
CONST_FLOAT CARGO_PLANE_FLY_ROT 121.0
|
|
CONST_FLOAT RON_INIT_ROT -5.8
|
|
CONST_FLOAT RON_STAND_ROT -179.12
|
|
CONST_FLOAT PASSED_ROT 21.38
|
|
CONST_FLOAT MOVE_LAST_PLAYER_VEHICLE_ROT -22.3
|
|
|
|
// Structs
|
|
STRUCT TRANSPORTED_VEHICLE
|
|
VEHICLE_INDEX veh
|
|
BOOL bDetached
|
|
TRANSPORTED_VEHICLE_TYPE_ENUM type
|
|
ENDSTRUCT
|
|
|
|
STRUCT COVER_OBJECT
|
|
OBJECT_INDEX obj
|
|
BOOL bDetached
|
|
COVER_OBJECT_TYPE_ENUM type
|
|
ENDSTRUCT
|
|
|
|
STRUCT FLIGHT_TARGET_DATA
|
|
// roll
|
|
PLANE_ROLL_DIR_ENUM rollDir
|
|
PLANE_ROLL_SPEED_ENUM rollSpeed
|
|
FLOAT fRollTarget
|
|
|
|
// pitch
|
|
PLANE_PITCH_DIR_ENUM pitchDir
|
|
PLANE_PITCH_SPEED_ENUM pitchSpeed
|
|
FLOAT fPitchTarget
|
|
ENDSTRUCT
|
|
|
|
STRUCT PLANE_MOVEMENT_DATA
|
|
VECTOR vRot
|
|
FLOAT fRollSpeed
|
|
FLOAT fPitchSpeed
|
|
ENDSTRUCT
|
|
|
|
STRUCT JET_DATA
|
|
VEHICLE_INDEX veh
|
|
PED_INDEX ped
|
|
INT iTaskTime
|
|
INT iBobTime
|
|
BLIP_INDEX blip
|
|
BOOL bInvertOffset
|
|
ENDSTRUCT
|
|
|
|
STRUCT JET_MISSILE
|
|
JET_MISSILE_STATE_ENUM state
|
|
OBJECT_INDEX obj
|
|
PTFX_ID ptfx
|
|
VECTOR vPos
|
|
VECTOR vRot
|
|
VECTOR vCurrentDirection
|
|
INT iSoundID
|
|
FLOAT fTurnSpeed
|
|
ENDSTRUCT
|
|
|
|
STRUCT DEBRIS_OBJECT
|
|
OBJECT_INDEX obj
|
|
BOOL bStopForce
|
|
BOOL bDonePassSFX
|
|
ENDSTRUCT
|
|
|
|
STRUCT ENEMY_DATA
|
|
PED_INDEX ped
|
|
AI_BLIP_STRUCT blip
|
|
ENEMY_AI_STATE_ENUM aiState
|
|
FLOAT fReadyMoveTime
|
|
VECTOR vMoveTarget
|
|
BOOL bRegisteredDead
|
|
INT iRunOverTime
|
|
BOOL bRunover
|
|
ENDSTRUCT
|
|
|
|
// Script-specific variables
|
|
MISSION_INIT_STAGE_ENUM missionInitStage = MISSION_INIT_PRE_INTRO
|
|
MISSION_FAIL_STATE_ENUM missionFailState = MISSION_FAIL_STATE_NOT_FAILED
|
|
MISSION_STAGE_ENUM currentMissionStage
|
|
FAIL_REASON_ENUM savedFailReason
|
|
MISSION_HOTSWAP_STAGE_ENUM hotswapStage
|
|
MISSION_STREAMING_STAGE_ENUM streamingStage
|
|
MOCAP_STREAMING_STAGE_ENUM mocapStreamingStage
|
|
PLANE_FIGHT_CUTSCENE_STAGE_ENUM cutsceneStage
|
|
TRANSPORTED_VEHICLE transportedVehicle[COUNT_OF(TRANSPORTED_VEHICLE_INDEX_ENUM)]
|
|
TRANSPORTED_VEHICLE fakeTransportedVehicle[COUNT_OF(TRANSPORTED_VEHICLE_INDEX_ENUM)]
|
|
COVER_OBJECT coverObject[COUNT_OF(COVER_OBJECT_INDEX_ENUM)]
|
|
COVER_OBJECT fakeCoverObject[COUNT_OF(COVER_OBJECT_INDEX_ENUM)]
|
|
DEBRIS_OBJECT debrisObject[NUMBER_DEBRIS_OBJECTS]
|
|
JET_DATA jetData[NUMBER_JETS]
|
|
JET_MISSILE jetMissile[NUMBER_MISSILES]
|
|
ENEMY_DATA enemyData[NUMBER_ENEMY_PEDS]
|
|
FLIGHT_TARGET_DATA flightTargetData
|
|
PLANE_MOVEMENT_DATA planeMovementData
|
|
FLY_PLANE_STATE_ENUM flyPlaneState
|
|
JET_ATTACK_STATE_ENUM jetAttackState
|
|
PLANE_FALLING_STATE_ENUM planeFallingState
|
|
SELECTOR_PED_STRUCT sSelectorPeds
|
|
SELECTOR_CAM_STRUCT sCamDetails
|
|
PLANE_INTERIOR_STREAMING_STAGE_ENUM planeInteriorStreamingStage
|
|
LADDER_STATE_ENUM ladderState
|
|
CREATE_PLANE_STAGE_ENUM createPlaneStage
|
|
JET_FLY_ALONGSIDE_STATE_ENUM jetFlyAlongsideState
|
|
SHAPE_TEST_STATE_ENUM shapeTestState
|
|
FAKE_CELLPHONE_DATA fakeCellphoneData
|
|
|
|
// Peds
|
|
PED_INDEX ronPed
|
|
PED_INDEX michaelPed
|
|
PED_INDEX patriciaPed
|
|
PED_INDEX dummyJetPed
|
|
PED_INDEX namedEnemyPed[COUNT_OF(NAMED_ENEMY_PED_ENUM)]
|
|
|
|
// Vehicles
|
|
VEHICLE_INDEX planeFightVehicle[COUNT_OF(PLANE_FIGHT_VEHICLE_ENUM)]
|
|
VEHICLE_INDEX checkpointVehicle
|
|
VEHICLE_INDEX fakePlaneVehicle
|
|
|
|
// Objects
|
|
OBJECT_INDEX planeRootObject
|
|
OBJECT_INDEX franklinPhoneObject
|
|
OBJECT_INDEX lightRigObject
|
|
//OBJECT_INDEX reflectRigObject
|
|
OBJECT_INDEX fakeLightRigObject
|
|
//OBJECT_INDEX fakeReflectRigObject
|
|
OBJECT_INDEX chairObject
|
|
OBJECT_INDEX radioObject
|
|
|
|
// Blips
|
|
BLIP_INDEX trevorPlaneBlip
|
|
BLIP_INDEX getToBlip
|
|
BLIP_INDEX ronBlip
|
|
BLIP_INDEX controlsBlip
|
|
BLIP_INDEX crewBlip[2]
|
|
|
|
// Cameras
|
|
CAMERA_INDEX staticCam
|
|
CAMERA_INDEX interpCam
|
|
CAMERA_INDEX animCam
|
|
CAMERA_INDEX jetCam
|
|
|
|
// Other variables
|
|
COVERPOINT_INDEX planeCover
|
|
COVERPOINT_INDEX cockpitLeftCover
|
|
COVERPOINT_INDEX cockpitRightCover
|
|
|
|
// Bools
|
|
BOOL bModelRequestTracker[COUNT_OF(PLANE_FIGHT_MODEL_ENUM)]
|
|
BOOL bVehicleRecordingRequestTracker[NUMBER_RECORDING_REQUEST_SLOTS]
|
|
BOOL bAnimDictRequestTracker[COUNT_OF(PLANE_FIGHT_ANIM_DICT_ENUM)]
|
|
BOOL bWeaponRequestTracker[COUNT_OF(PLANE_FIGHT_WEAPON_ENUM)]
|
|
BOOL bPTFXRequestTracker[COUNT_OF(PLANE_FIGHT_PTFX_ENUM)]
|
|
BOOL bSFXRequestTracker[COUNT_OF(PLANE_FIGHT_SFX_ENUM)]
|
|
BOOL bMiscAssetRequestTracker[COUNT_OF(PLANE_FIGHT_MISC_ASSET_ENUM)]
|
|
BOOL bThoroughCleanup
|
|
BOOL bForcePassOnShitskip
|
|
BOOL bRunningCutscene
|
|
BOOL bSkippedCutscene
|
|
BOOL bClearedForCutscene
|
|
BOOL bSkipInProgress
|
|
BOOL bShownGodText
|
|
BOOL bShouldDoGetInText
|
|
BOOL bDoneGotoSpeech
|
|
BOOL bDoneBanter
|
|
BOOL bSavedBanter
|
|
BOOL bRemovedBlipsForWanted
|
|
//BOOL bKilledConversationOnWanted
|
|
BOOL bShownLoseWantedPrompt
|
|
//BOOL bDoneIntroPlayerHotswap
|
|
//BOOL bDoneIntroStreamingVolume
|
|
//BOOL bDeletedIntroStreamingVolume
|
|
BOOL bDoneIntroCreateEntities
|
|
BOOL bDoneIntroClearStart
|
|
BOOL bWaitForRonPrompt
|
|
BOOL bGetRonPrompt
|
|
BOOL bSetRonAsGroupMember
|
|
BOOL bResetDirectEntryFlag
|
|
BOOL bForceIntoCar
|
|
//BOOL bRestoredControlOnStart
|
|
BOOL bAtAirstrip
|
|
BOOL bDoneBriefSpeech
|
|
BOOL bRonOutOfGroup
|
|
BOOL bDoneRonWalkToTrailer
|
|
BOOL bRemovedRon
|
|
BOOL bActivatedCargoPlaneSpeed
|
|
BOOL bAllowFlyHigh
|
|
BOOL bEnforceFlyLow
|
|
BOOL bShownFlyLowHelp
|
|
BOOL bDoneComeInSpeech
|
|
BOOL bDoneFlyLowSpeech
|
|
//BOOL bDoneFlyLowSpeech2
|
|
BOOL bShownTooHighHelp
|
|
BOOL bDoneTooHighSpeech
|
|
BOOL bDoneTooHighUrgentSpeech
|
|
BOOL bDoOnItSpeech
|
|
BOOL bIncrementedTooHigh
|
|
BOOL bKilledSpeechForJets
|
|
BOOL bKilledSpeechForTooHigh
|
|
BOOL bKilledSpeechForBase
|
|
BOOL bDoneFlyHighSpeech
|
|
BOOL bShownFlyHighHelp
|
|
BOOL bDoneHereWeGoSpeech
|
|
BOOL bShownBaseHelp
|
|
BOOL bDoneBaseSpeech
|
|
BOOL bDoneOverBaseSpeech
|
|
BOOL bDoneIgnoreRonSpeech
|
|
//BOOL bShownCropHelp
|
|
//BOOL bCropDustingOn
|
|
BOOL bDoneSeePlane
|
|
BOOL bStoppedPlayback
|
|
BOOL bDoneCrashSpeech
|
|
BOOL bDoneTrevorReactToShootSpeech
|
|
BOOL bShownCrashHelp
|
|
BOOL bMachineGunEnemyShooting
|
|
BOOL bBeenInEnterVicinity
|
|
BOOL bDoneTryAgainSpeech
|
|
BOOL bDoneCollisionSpeech
|
|
//BOOL bDoneEnemyPlaneReactSpeech
|
|
BOOL bSetAccuracy
|
|
BOOL bKlaxonOn
|
|
BOOL bStoppedForceSpeed
|
|
//BOOL bShownLadderHelp
|
|
BOOl bDoneTannoyAnnouncement
|
|
//BOOL bForcedDuck
|
|
BOOL bBlippedCrew
|
|
BOOL bDoneCrewSpeech
|
|
//BOOL bShownKillCrewPrompt
|
|
BOOL bOffLadder
|
|
BOOL bAddedCockpitCover
|
|
BOOL bCrewShoot
|
|
BOOL bDoneClouds
|
|
BOOL bDoneFlashlightHelp
|
|
BOOL bSetTransportedVehiclesPhysical
|
|
//BOOL bDetachedCropDuster
|
|
BOOL bDoneGotoCockpitPrompt
|
|
BOOL bCanUseControls
|
|
BOOL bDoneUseControlsPrompt
|
|
BOOL bDonePilotDeadSpeech
|
|
BOOL bDoneTurbulenceSpeech
|
|
//BOOL bAttachedVehiclesInCut
|
|
BOOL bDoneTurnOffAlarmSpeech
|
|
BOOL bTurnedOffAlarm
|
|
BOOL bDoneHailRonSpeech
|
|
BOOL bDoneRonHailedSpeech
|
|
BOOL bDoneChangeFreqSpeech
|
|
BOOL bDoneInPlaneSpeech
|
|
BOOL bDoneBearingSpeech
|
|
BOOL bShownTurnHelp
|
|
BOOL bCutOutControl
|
|
BOOL bRestoredControl
|
|
BOOL bDoneSeeJetSpeech
|
|
BOOL bDoneJetWarning1Speech
|
|
BOOL bShownJetCamHelp
|
|
BOOL bUsingJetCam
|
|
BOOL bDoneWaveDownCutscene
|
|
BOOL bDoneWaveDownSpeech
|
|
BOOL bDoneTrevorGestureSpeech
|
|
//BOOL bShownLadderPrompt
|
|
BOOL bDoneRudderFallOff
|
|
//BOOL bShownObeyJetHelp
|
|
BOOL bDoneSplashSpeech
|
|
BOOL bDoneSplashSpeech2
|
|
BOOL bCancelledSplashSpeech
|
|
BOOL bDoneFireMissileSpeech
|
|
BOOL bDoneFireMissileSpeech2
|
|
BOOL bDoneEngineBlowSpeech
|
|
BOOL bDoneRearExplosionSpeech
|
|
BOOL bDoneJetReactSpeech
|
|
BOOL bDoneRonShakeJetsSpeech
|
|
BOOL bDoneTrevorShakeJetsSpeech
|
|
BOOL bDoneShootDownReactSpeech
|
|
BOOL bDoneRonResponseToShootdownSpeech
|
|
BOOL bDoneFindParachuteSpeech
|
|
BOOL bDoneGotParachuteSpeech
|
|
BOOL bShownClimbText
|
|
BOOL bForceClimb
|
|
//BOOL bAllowDestruction
|
|
BOOL bAllowBike
|
|
//BOOl bDoneLeaveBikePrompt
|
|
//BOOL bDoneForceOffBike
|
|
BOOL bDoneEscapeSpeech
|
|
BOOL bDoneOutOfPlane
|
|
BOOL bDoneParachutePrompt
|
|
BOOL bShownFreeFallHelp
|
|
BOOL bShownParachuteHelp
|
|
BOOL bShownParachuteHelp2
|
|
BOOL bShownParachuteHelp3
|
|
BOOL bShownParachuteFocusHelp
|
|
BOOL bUsedParachute
|
|
//BOOL bRemovedParachuteBackpack
|
|
BOOL bDonePhoneCall
|
|
BOOL bAtSafety
|
|
BOOL bCheckedPerfectLanding
|
|
BOOL bTriggeredJumpToParachute
|
|
BOOL bClearedParachuteAnim
|
|
BOOL bShownInWaterPrompt
|
|
BOOL bDoingGotoSubstage
|
|
//BOOL bResetDeathProofs
|
|
BOOL bDodgeIsVehicle
|
|
//BOOL bDoneExplodePlaneVFX
|
|
BOOL bStartedFreefallTimer
|
|
BOOL bStoppedFreefallTimer
|
|
BOOL bJetsScrambled
|
|
BOOL bDoneJetsScrambledSpeech
|
|
BOOL bLoadedFlybyStream
|
|
BOOL bPlayedFlybyStream
|
|
BOOL bClearedLightRig
|
|
BOOL bDoneSpewSmokeOnEscape
|
|
//BOOL bStoppedDustCloud
|
|
BOOL bEnemiesAttachedToRamp
|
|
BOOL bLoadedCrashStream
|
|
BOOL bPlayingCrashStream
|
|
BOOL bLoadedWindStream
|
|
BOOL bPlayingWindStream
|
|
BOOL bStoppedWindStream
|
|
BOOL bDoneCloseToCitySpeech
|
|
BOOL bJetAlongsideCabin
|
|
BOOL bDoneExplodePlaneVFX
|
|
BOOL bCreatedLightRig
|
|
BOOL bCleanedUpMichaelAndPatricia
|
|
BOOL bTakePlaneDamage
|
|
BOOL bResetPlaneBreak
|
|
BOOL bRonActionModeTrack
|
|
BOOL bDoneTrevorGoBackSpeech
|
|
BOOL bKilledBanterForHangarSpeech
|
|
BOOL bDoneOwnHangarSpeech
|
|
BOOL bFinishedBanterSpeech
|
|
BOOL bDonePitchDown
|
|
BOOL bSetDampingOn4wd
|
|
BOOL bClearedEnemiesFromHold
|
|
BOOL bDamagedPlaneToGlideDown
|
|
BOOL bClearedForGlideDownChecks
|
|
BOOL bShownGlideHelp
|
|
BOOL bStartedHillsStreaming
|
|
BOOL bKilledHillsStreaming
|
|
BOOL bDonePlaneCrashWithTrevor
|
|
BOOL bSuppressFutureReplaySetups
|
|
BOOL bBeenCloseToPlane
|
|
//BOOL bOnLadderForCam
|
|
BOOL bStartExplodeCounter
|
|
BOOL bSetPilotAttack
|
|
BOOL bSetPack
|
|
BOOL bAllowUseControls
|
|
BOOL bForceUseControls
|
|
BOOL bSetMerryweatherSpeaker1
|
|
BOOL bSetMerryweatherSpeaker2
|
|
BOOL bDoneMerryweatherCombatSpeech1
|
|
BOOL bDoneMerryweatherCombatSpeech2
|
|
BOOL bDoneMerryweatherCombatSpeech3
|
|
//BOOL bDoneSwearOnWayDownSpeech
|
|
BOOL bMovedPed
|
|
BOOL bMovedPlayer
|
|
BOOL bStoppedDebrisAtBack
|
|
BOOL bSetupInsidePlaneDuringCutscene
|
|
BOOL bPopulatedInteriorDuringCutscene
|
|
BOOL bResetSpeechFlag
|
|
BOOL bSetNoTurbulence
|
|
BOOL bDoneCarFallSound
|
|
BOOL bStoppedCarFallSound
|
|
BOOL bSentText
|
|
BOOL bForceIntoPlaneWhenCutsceneLoaded
|
|
BOOL bChangedPilotSpeaker
|
|
BOOL bInCarCollisionProof
|
|
|
|
BOOL bDoneTakeoffCue
|
|
BOOL bDoneSpotPlaneCue
|
|
BOOL bDoneSenseOfStyleCue
|
|
BOOL bDoneOnToesCue
|
|
BOOL bDoneStartClimbingCue
|
|
BOOL bDoneIdentifyYourselfCue
|
|
BOOL bPreparedCargoDoorsOpenCue
|
|
BOOL bPreparedLandInPlaneCue
|
|
BOOL bDoneLandInPlaneCue
|
|
BOOL bDoneGotoCockpitCue
|
|
BOOL bDoneUseControlsCue
|
|
BOOL bDoneSeeJetCue
|
|
BOOL bDoneJetAlongsideCue
|
|
BOOL bDoneMissileExplodeCue
|
|
BOOL bPreparedJumpCue
|
|
BOOL bDoneJumpCue
|
|
BOOL bDoneLandedCue
|
|
BOOL bShownControlsHelp
|
|
BOOL bStoppedRocketsScene
|
|
BOOL bFlyAbove
|
|
BOOL bPausedConvo
|
|
BOOL bDoneFlash
|
|
|
|
BOOL bDoneInTruckAudioScene
|
|
BOOL bStoppedInTruckAudioScene
|
|
BOOL bDoneCargoPlaneAppearsAudioScene
|
|
BOOL bDoneFocusAudioScene
|
|
BOOL bDoneWarningAudioScene
|
|
BOOL bStoppedWarningAudioScene
|
|
BOOL bDoneSeeJetAudioScene
|
|
BOOL bDoneCarEscapeAudioScene
|
|
BOOL bDoneFocusOnCrashingPlaneAudioScene
|
|
BOOL bStoppedDeployParachuteAudioScene
|
|
|
|
// Vectors
|
|
VECTOR vPlayerOffsetFromPlane
|
|
VECTOR vAttachLadder
|
|
VECTOR vLadderRot
|
|
VECTOR vRampMachineGunAttach
|
|
VECTOR vRampRPGAttach
|
|
VECTOR vJetAttach
|
|
VECTOR vCachedOffsetFromPlane
|
|
VECTOR vJetCamAttach
|
|
VECTOR vAttachCamPos
|
|
VECTOR vAttachCamRot
|
|
VECTOR vPlaneRotForCutscene
|
|
|
|
// Floats
|
|
FLOAT fPlaneSpeed
|
|
FLOAT fPlaneDistance
|
|
FLOAT fPlaybackTime
|
|
FLOAT fAboveHeightTime
|
|
FLOAT fOverBaseTime
|
|
FLOAT fDoorOpen
|
|
FLOAT fSafetyTimer
|
|
FLOAT fPlaneInteriorSpeed
|
|
FLOAT fCachedHeightAboveGround
|
|
FLOAT fProportionUpPlane
|
|
FLOAT fTurbulence
|
|
FLOAT fJetFlyAlongsideTimer
|
|
FLOAT fInTrailerTime
|
|
FLOAT fVehicleDamping
|
|
FLOAT fExplodeCounter
|
|
FLOAT fTimeAtHatch
|
|
|
|
// Ints
|
|
INT iReplayAttempt
|
|
INT iAllowSkipCutsceneTime
|
|
INT iPlaneFightCutsceneTime
|
|
INT iGetInTextStage
|
|
INT iNextRandomSpeechTime
|
|
INT iApproachSpeechStage
|
|
INT iRPGShot
|
|
//INT iCropHelpTime
|
|
INT iAlarmIntensitySetting
|
|
INT iEnforceFlyLowTime
|
|
INT iCancelOnItSpeechTime
|
|
INT iFlyLowSpeechTime
|
|
INT iFlyHighSpeechTime
|
|
INT iBaseSpeechTime
|
|
INT iTooHighHelpTime
|
|
INT iKlaxonTime
|
|
INT iBaseCheckTime
|
|
INT iNextOverBaseSpeechTime
|
|
INT iOpenDoorTime
|
|
INT iStartFightTime
|
|
INT iStartEscapeTime
|
|
INT iOutOfPlaneTime
|
|
INT iCutOutControlTime
|
|
INT iDodgeReactCount
|
|
INT iNextDodgeReactTime
|
|
INT iDodgeEntity
|
|
INT iDodgeTime
|
|
INT iNextShakeTime
|
|
INT iFlightIntensityStage
|
|
INT iFlightSubstage
|
|
INT iNextSubstageUpdateTime
|
|
INT iKilledEnemies
|
|
INT iCrewShootTime
|
|
INT iTurnOffAlarmSpeechTime
|
|
INT iJetWarningSpeech
|
|
INT iJetSetStateTime
|
|
//INT iJetSpeechTime
|
|
INT iJetTurnTime
|
|
INT iFlightTime
|
|
INT iBlowEngineTime
|
|
//INT iJetSpeechTime
|
|
INT iStopForceSpeedTime
|
|
INT iNextCheckCrashTime
|
|
INT iClimbPromptTime
|
|
//INT iStartDestructionTime
|
|
INT iClearHelpTime
|
|
//INT iPlaneCrashTime
|
|
INT iStoredPlayerHealth
|
|
INT iSyncScene
|
|
INT iMichaelSyncScene
|
|
INT iPatriciaSyncScene
|
|
INT iDoCutscene
|
|
INT iGotSafetyTime
|
|
INT iJumpToParachuteTime
|
|
INT iShownTooHighHelpTimes
|
|
INT iTooHighCount
|
|
INT iStageStartTime
|
|
INT iCrewShootSpeechTime
|
|
INT iFlyTooLowSpeechTime
|
|
INT iScrambleJetsTime
|
|
INT iEnemyShootingTime
|
|
INT iRonActionModeDelay
|
|
INT iRPGTime
|
|
INT iCanUseControlsTime
|
|
INT iDamagedPlaneToGlideDownTime
|
|
INT iOpenedParachuteTime
|
|
INT iMerryweatherSpeaker1
|
|
INT iMerryweatherSpeaker2
|
|
INT iMerryweatherCombatSpeechTime
|
|
//INT iOnLadderForCamTime
|
|
//INT iTruckCheck
|
|
INT iCacheParachuteTint = -1
|
|
INT iFakeCellphoneState
|
|
INT iKlaxonSoundID = GET_SOUND_ID()
|
|
INT iEngineSoundID = GET_SOUND_ID()
|
|
INT iTransitionSoundID = GET_SOUND_ID()
|
|
INT iCarFallSoundID = GET_SOUND_ID()
|
|
INT iForceSkipToNextStageTime
|
|
INT iOutOfVehicleTime
|
|
INT iSwitchConvoTime
|
|
INT iDoorStartOpenTime
|
|
INT iHitTime
|
|
|
|
// Other variables
|
|
SEQUENCE_INDEX sequence
|
|
WEAPON_TYPE ladderWeapon
|
|
//PTFX_ID dustPTFX
|
|
//BOOL bDustPTFXActive
|
|
PTFX_ID smokePTFX[COUNT_OF(PLANE_SMOKE_ENUM)]
|
|
BOOL bSmokePTFXActive[COUNT_OF(PLANE_SMOKE_ENUM)]
|
|
REL_GROUP_HASH enemyRelGroup
|
|
//SCENARIO_BLOCKING_INDEX airfieldScenarioBlocking
|
|
//SCENARIO_BLOCKING_INDEX crashSiteAirScenarioBlocking
|
|
//SCENARIO_BLOCKING_INDEX crashSiteGroundScenarioBlocking
|
|
//STREAMVOL_ID trailerVolume
|
|
structPedsForConversation planeFightConversation
|
|
SHAPETEST_INDEX planeShapeTest
|
|
STREAMVOL_ID hillsStreamingVolume
|
|
STREAMVOL_ID trailerStreamingVolume
|
|
TEXT_LABEL_23 tSavedBanterRoot
|
|
TEXT_LABEL_23 tResumeBanterLabel
|
|
INTERIOR_INSTANCE_INDEX iiiTrailer
|
|
|
|
// Debug
|
|
#IF IS_DEBUG_BUILD
|
|
WIDGET_GROUP_ID planeFightWidgets
|
|
TEXT_WIDGET_ID RBCamPosWidget, RBCamRotWidget
|
|
BOOL bRBDebugCamDoDump
|
|
VECTOR vRBDebugCamPos
|
|
VECTOR vRBDebugCamRot
|
|
FLOAT fRBDebugCamFOV
|
|
|
|
VECTOR vDebugAttachCamOffset = <<0.9, 29.0, 2.1>>
|
|
VECTOR vDebugAttachCamPoint = <<-3.2, 27.6, 2.45>>
|
|
FLOAT fDebugAttachCamFOV = 35.8
|
|
|
|
MissionStageMenuTextStruct stageMenu[MAX_SKIP_MENU_LENGTH]
|
|
INT iMenuMissionStage
|
|
|
|
BOOL bDebugForceIntoHold = FALSE
|
|
BOOL bDebugForceUseControls = FALSE
|
|
|
|
BOOL bDebugForceJetIntoPlane = FALSE
|
|
|
|
INT iDebugStage = -1
|
|
#ENDIF
|
|
|
|
// get intro name
|
|
FUNC STRING GET_EXILE1_INTRO_CUTSCENE_NAME()
|
|
RETURN "exile_1_intp1_a"
|
|
ENDFUNC
|
|
|
|
// get recording prefix
|
|
FUNC STRING GET_PLANE_FIGHT_RECORDING_PREFIX()
|
|
RETURN "planeFight"
|
|
ENDFUNC
|
|
|
|
// get alarm bank name
|
|
FUNC STRING GET_ALARM_AUDIO_BANK_NAME()
|
|
RETURN "Alarms"
|
|
ENDFUNC
|
|
|
|
FUNC STRING GET_DESCRIPTION_FOR_STAGE_AS_STRING(MISSION_STAGE_ENUM thisStage)
|
|
SWITCH thisStage
|
|
CASE STAGE_GET_TO_AIRSTRIP
|
|
RETURN "Get to airstrip"
|
|
BREAK
|
|
CASE STAGE_FOLLOW_PLANE_1
|
|
RETURN "Follow cargo plane - out to sea"
|
|
BREAK
|
|
CASE STAGE_FOLLOW_PLANE_2
|
|
RETURN "Follow cargo plane - around coast"
|
|
BREAK
|
|
CASE STAGE_FOLLOW_PLANE_3
|
|
RETURN "Follow cargo plane - allow climb"
|
|
BREAK
|
|
CASE STAGE_ENTER_PLANE
|
|
RETURN "Enter cargo plane"
|
|
BREAK
|
|
CASE STAGE_PLANE_FIGHT
|
|
RETURN "Fight on plane"
|
|
BREAK
|
|
CASE STAGE_FLY_PLANE
|
|
RETURN "Fly the plane"
|
|
BREAK
|
|
CASE STAGE_ESCAPE_PLANE
|
|
RETURN "Escape the plane"
|
|
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, BOOL bSupercedeHelp = FALSE)
|
|
IF bSupercedeHelp OR NOT IS_HELP_MESSAGE_BEING_DISPLAYED()
|
|
IF CAN_ADVANCE_MISSION()
|
|
IF NOT bForever
|
|
PRINT_HELP(sHelpText)
|
|
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 bFromSpecifiedLine = FALSE, enumSubtitlesState ShouldDisplaySubtitles = DISPLAY_SUBTITLES)
|
|
IF bSupercedeText OR NOT IS_MESSAGE_BEING_DISPLAYED() OR NOT IS_SUBTITLE_PREFERENCE_SWITCHED_ON()
|
|
IF NOT IS_ANY_CONVERSATION_ONGOING_OR_QUEUED()
|
|
AND CAN_ADVANCE_MISSION()
|
|
IF iLine = 0
|
|
RETURN CREATE_CONVERSATION(planeFightConversation, "EXL1AUD", sSpeech, CONV_PRIORITY_HIGH, ShouldDisplaySubtitles)
|
|
ELSE
|
|
TEXT_LABEL tLine
|
|
tLine = sSpeech
|
|
tLine+="_"
|
|
tLine+=iLine
|
|
IF NOT bFromSpecifiedLine
|
|
RETURN PLAY_SINGLE_LINE_FROM_CONVERSATION(planeFightConversation, "EXL1AUD", sSpeech, tLine, CONV_PRIORITY_HIGH, ShouldDisplaySubtitles)
|
|
ELSE
|
|
RETURN CREATE_CONVERSATION_FROM_SPECIFIC_LINE(planeFightConversation, "EXL1AUD", sSpeech, tLine, CONV_PRIORITY_HIGH, ShouldDisplaySubtitles)
|
|
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()
|
|
printstring("conversation kill!") printnl()
|
|
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
|
|
|
|
// get model for a plane fight model enum
|
|
FUNC MODEL_NAMES GET_MODEL_FOR_PLANE_FIGHT_MODEL_ENUM(PLANE_FIGHT_MODEL_ENUM pfModel)
|
|
SWITCH pfModel
|
|
CASE PFM_TREVOR
|
|
RETURN GET_PLAYER_PED_MODEL(CHAR_TREVOR)
|
|
BREAK
|
|
CASE PFM_FRANKLIN
|
|
RETURN GET_PLAYER_PED_MODEL(CHAR_FRANKLIN)
|
|
BREAK
|
|
CASE PFM_MICHAEL
|
|
RETURN GET_PLAYER_PED_MODEL(CHAR_MICHAEL)
|
|
BREAK
|
|
CASE PFM_PATRICIA
|
|
RETURN GET_NPC_PED_MODEL(CHAR_PATRICIA)
|
|
BREAK
|
|
CASE PFM_RON
|
|
RETURN GET_NPC_PED_MODEL(CHAR_RON)
|
|
BREAK
|
|
CASE PFM_ENEMY
|
|
RETURN S_M_Y_BLACKOPS_01
|
|
BREAK
|
|
CASE PFM_PILOT
|
|
RETURN S_M_M_PILOT_01
|
|
BREAK
|
|
CASE PFM_SOLDIER
|
|
RETURN S_M_M_PILOT_02
|
|
BREAK
|
|
CASE PFM_TREVOR_4WD
|
|
RETURN GET_PLAYER_VEH_MODEL(CHAR_TREVOR)
|
|
BREAK
|
|
CASE PFM_TREVOR_PLANE
|
|
RETURN DUSTER
|
|
BREAK
|
|
CASE PFM_CARGO_PLANE
|
|
RETURN CARGOPLANE
|
|
BREAK
|
|
CASE PFM_4WD
|
|
RETURN MESA3
|
|
BREAK
|
|
//CASE PFM_VAN
|
|
// RETURN BURRITO3
|
|
//BREAK
|
|
CASE PFM_JET
|
|
RETURN LAZER
|
|
BREAK
|
|
CASE PFM_COVER1
|
|
RETURN PROP_MIL_CRATE_01
|
|
BREAK
|
|
CASE PFM_COVER2
|
|
RETURN PROP_MIL_CRATE_02
|
|
BREAK
|
|
CASE PFM_PLANE_ROOT
|
|
RETURN Prop_LD_Test_01
|
|
BREAK
|
|
CASE PFM_FRANKLIN_PHONE
|
|
RETURN Prop_Phone_ING_03
|
|
BREAK
|
|
CASE PFM_MICHAEL_PHONE
|
|
RETURN PROP_PHONE_ING
|
|
BREAK
|
|
CASE PFM_LIGHT_RIG
|
|
RETURN EXILE1_LIGHTRIG
|
|
BREAK
|
|
//CASE PFM_REFLECT_RIG
|
|
// RETURN Exile1_reflecttrig
|
|
//BREAK
|
|
CASE PFM_CHAIR
|
|
RETURN PROP_CHAIR_06
|
|
BREAK
|
|
CASE PFM_RADIO
|
|
RETURN P_POLICE_RADIO_HSET_S
|
|
BREAK
|
|
CASE PFM_LAST_VEHICLE
|
|
RETURN GET_REPLAY_CHECKPOINT_VEHICLE_MODEL()
|
|
BREAK
|
|
ENDSWITCH
|
|
|
|
RETURN DUMMY_MODEL_FOR_SCRIPT
|
|
ENDFUNC
|
|
|
|
// get a sfx enum as string
|
|
FUNC STRING GET_PLANE_FIGHT_SFX_AS_STRING(PLANE_FIGHT_SFX_ENUM sfx)
|
|
SWITCH sfx
|
|
CASE PF_SFX_ALARM
|
|
RETURN GET_ALARM_AUDIO_BANK_NAME()
|
|
BREAK
|
|
CASE PF_SFX_CAR1
|
|
RETURN "EXILE_1_CAR_01"
|
|
BREAK
|
|
CASE PF_SFX_CAR2
|
|
RETURN "EXILE_1_CAR_02"
|
|
BREAK
|
|
CASE PF_SFX_CAR3
|
|
RETURN "EXILE_1_CAR_03"
|
|
BREAK
|
|
CASE PF_SFX_FAIL
|
|
RETURN "EXILE_1_PT2_FAIL"
|
|
BREAK
|
|
CASE PF_SFX_TRANSITION
|
|
RETURN "EXILE_1_TRANSITION_WIND"
|
|
BREAK
|
|
ENDSWITCH
|
|
|
|
RETURN "invalid!"
|
|
ENDFUNC
|
|
|
|
// suppress vehicles
|
|
PROC SUPPRESS_MISSION_VEHICLES(BOOL bSuppress)
|
|
SET_VEHICLE_MODEL_IS_SUPPRESSED(GET_MODEL_FOR_PLANE_FIGHT_MODEL_ENUM(PFM_TREVOR_4WD), bSuppress)
|
|
SET_VEHICLE_MODEL_IS_SUPPRESSED(GET_MODEL_FOR_PLANE_FIGHT_MODEL_ENUM(PFM_4WD), bSuppress)
|
|
SET_VEHICLE_MODEL_IS_SUPPRESSED(GET_MODEL_FOR_PLANE_FIGHT_MODEL_ENUM(PFM_CARGO_PLANE), bSuppress)
|
|
SET_VEHICLE_MODEL_IS_SUPPRESSED(GET_MODEL_FOR_PLANE_FIGHT_MODEL_ENUM(PFM_TREVOR_PLANE), bSuppress)
|
|
SET_VEHICLE_MODEL_IS_SUPPRESSED(GET_MODEL_FOR_PLANE_FIGHT_MODEL_ENUM(PFM_JET), bSuppress)
|
|
SET_PED_MODEL_IS_SUPPRESSED(GET_MODEL_FOR_PLANE_FIGHT_MODEL_ENUM(PFM_ENEMY), bSuppress)
|
|
SET_PED_MODEL_IS_SUPPRESSED(GET_MODEL_FOR_PLANE_FIGHT_MODEL_ENUM(PFM_SOLDIER), bSuppress)
|
|
SET_PED_MODEL_IS_SUPPRESSED(GET_MODEL_FOR_PLANE_FIGHT_MODEL_ENUM(PFM_RON), bSuppress)
|
|
|
|
SET_VEHICLE_MODEL_IS_SUPPRESSED(CUBAN800, bSuppress)
|
|
SET_VEHICLE_MODEL_IS_SUPPRESSED(STUNT, bSuppress)
|
|
SET_VEHICLE_MODEL_IS_SUPPRESSED(TITAN, bSuppress)
|
|
SET_VEHICLE_MODEL_IS_SUPPRESSED(JET, bSuppress)
|
|
SET_VEHICLE_MODEL_IS_SUPPRESSED(SHAMAL, bSuppress)
|
|
SET_VEHICLE_MODEL_IS_SUPPRESSED(LUXOR, bSuppress)
|
|
SET_VEHICLE_MODEL_IS_SUPPRESSED(MAMMATUS, bSuppress)
|
|
SET_VEHICLE_MODEL_IS_SUPPRESSED(VELUM, 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
|
|
|
|
// disable/reenable cargens
|
|
PROC ENABLE_CARGENS_FOR_MISSION(BOOL bEnable)
|
|
SET_ALL_VEHICLE_GENERATORS_ACTIVE_IN_AREA(<<1902.74243, 4689.52734, 0>>, <<2188.94653, 4834.07861, 100.69606>>, bEnable)
|
|
SET_ALL_VEHICLE_GENERATORS_ACTIVE_IN_AREA(<<1003.4, 2968.3, -10.0>>, <<1778.0, 3357.1, 150.0>>, bEnable)
|
|
ENDPROC
|
|
|
|
|
|
FUNC STRING GET_PLANE_FIGHT_AUDIO_SCENE_AS_STRING(PLANE_FIGHT_AUDIO_SCENE_ENUM thisScene)
|
|
SWITCH thisScene
|
|
CASE PLANE_FIGHT_AUDIO_SCENE_DRIVE_TO_PLANE
|
|
RETURN "EXILE_1_DRIVE_TO_PLANE"
|
|
BREAK
|
|
CASE PLANE_FIGHT_AUDIO_SCENE_FLIGHT_MAIN
|
|
RETURN "EXILE_1_FLIGHT_MAIN"
|
|
BREAK
|
|
CASE PLANE_FIGHT_AUDIO_SCENE_CARGO_PLANE_APPEARS
|
|
RETURN "EXILE_1_CARGO_PLANE_APPEARS"
|
|
BREAK
|
|
CASE PLANE_FIGHT_AUDIO_SCENE_FOCUS_ON_CARGO_PLANE
|
|
RETURN "EXILE_1_FOCUS_ON_CARGO_PLANE"
|
|
BREAK
|
|
CASE PLANE_FIGHT_AUDIO_SCENE_FLIGHT_START_CLIMB
|
|
RETURN "EXILE_1_FLIGHT_START_CLIMB"
|
|
BREAK
|
|
CASE PLANE_FIGHT_AUDIO_SCENE_TREVOR_GETS_WARNING
|
|
RETURN "EXILE_1_TREVOR_GETS_WARNING"
|
|
BREAK
|
|
CASE PLANE_FIGHT_AUDIO_SCENE_ENEMY_OPENS_FIRE
|
|
RETURN "EXILE_1_ENEMY_OPENS_FIRE"
|
|
BREAK
|
|
CASE PLANE_FIGHT_AUDIO_SCENE_SHOOTOUT_CARGO_HOLD
|
|
RETURN "EXILE_1_SHOOTOUT_CARGO_HOLD"
|
|
BREAK
|
|
CASE PLANE_FIGHT_AUDIO_SCENE_HIJACK_THE_PLANE
|
|
RETURN "EXILE_1_HIJACK_THE_PLANE"
|
|
BREAK
|
|
CASE PLANE_FIGHT_AUDIO_SCENE_FLY_CARGO_PLANE
|
|
RETURN "EXILE_1_FLY_CARGO_PLANE"
|
|
BREAK
|
|
CASE PLANE_FIGHT_AUDIO_SCENE_FIGHTER_JETS_ARRIVE
|
|
RETURN "EXILE_1_FIGHTER_JETS_ARRIVE"
|
|
BREAK
|
|
CASE PLANE_FIGHT_AUDIO_SCENE_FIGHTER_JET_CAMERA
|
|
RETURN "EXILE_1_FIGHTER_JET_CAMERA"
|
|
BREAK
|
|
CASE PLANE_FIGHT_AUDIO_SCENE_COCKPIT_CUTSCENE
|
|
RETURN "EXILE_1_COCKPIT_CUTSCENE"
|
|
BREAK
|
|
CASE PLANE_FIGHT_AUDIO_SCENE_ROCKETS_FIRED
|
|
RETURN "EXILE_1_ROCKETS_FIRED"
|
|
BREAK
|
|
CASE PLANE_FIGHT_AUDIO_SCENE_PLANE_GOING_DOWN
|
|
RETURN "EXILE_1_PLANE_GOING_DOWN"
|
|
BREAK
|
|
CASE PLANE_FIGHT_AUDIO_SCENE_ESCAPE_ON_FOOT
|
|
RETURN "EXILE_1_ESCAPE_ON_FOOT"
|
|
BREAK
|
|
CASE PLANE_FIGHT_AUDIO_SCENE_ESCAPE_IN_CAR
|
|
RETURN "EXILE_1_ESCAPE_IN_CAR"
|
|
BREAK
|
|
CASE PLANE_FIGHT_AUDIO_SCENE_SKYDIVE
|
|
RETURN "EXILE_1_SKYDIVE"
|
|
BREAK
|
|
CASE PLANE_FIGHT_AUDIO_SCENE_DEPLOY_PARACHUTE
|
|
RETURN "EXILE_1_DEPLOY_PARACHUTE"
|
|
BREAK
|
|
CASE PLANE_FIGHT_AUDIO_SCENE_FOCUS_ON_CRASHING_PLANE
|
|
RETURN "EXILE_1_FOCUS_ON_CRASHING_PLANE"
|
|
BREAK
|
|
ENDSWITCH
|
|
|
|
RETURN ""
|
|
ENDFUNC
|
|
|
|
// start train crash audio scene
|
|
FUNC BOOL START_PLANE_FIGHT_AUDIO_SCENE(PLANE_FIGHT_AUDIO_SCENE_ENUM thisScene)
|
|
RETURN START_AUDIO_SCENE(GET_PLANE_FIGHT_AUDIO_SCENE_AS_STRING(thisScene))
|
|
ENDFUNC
|
|
|
|
// stop train crash audio scene
|
|
PROC STOP_PLANE_FIGHT_AUDIO_SCENE(PLANE_FIGHT_AUDIO_SCENE_ENUM thisScene)
|
|
STOP_AUDIO_SCENE(GET_PLANE_FIGHT_AUDIO_SCENE_AS_STRING(thisScene))
|
|
ENDPROC
|
|
|
|
// stop all train crash audio scenes
|
|
PROC STOP_ALL_PLANE_FIGHT_AUDIO_SCENES()
|
|
INT i
|
|
REPEAT COUNT_OF(PLANE_FIGHT_AUDIO_SCENE_ENUM) i
|
|
STOP_PLANE_FIGHT_AUDIO_SCENE(INT_TO_ENUM(PLANE_FIGHT_AUDIO_SCENE_ENUM, i))
|
|
ENDREPEAT
|
|
ENDPROC
|
|
|
|
|
|
|
|
// remove blips
|
|
PROC REMOVE_ALL_BLIPS()
|
|
INT i
|
|
|
|
IF DOES_BLIP_EXIST(trevorPlaneBlip)
|
|
REMOVE_BLIP(trevorPlaneBlip)
|
|
ENDIF
|
|
|
|
IF DOES_BLIP_EXIST(ronBlip)
|
|
REMOVE_BLIP(ronBlip)
|
|
ENDIF
|
|
|
|
IF DOES_BLIP_EXIST(getToBlip)
|
|
REMOVE_BLIP(getToBlip)
|
|
ENDIF
|
|
|
|
IF DOES_BLIP_EXIST(controlsBlip)
|
|
REMOVE_BLIP(controlsBlip)
|
|
ENDIF
|
|
|
|
REPEAT NUMBER_ENEMY_PEDS i
|
|
CLEANUP_AI_PED_BLIP(enemyData[i].blip)
|
|
ENDREPEAT
|
|
|
|
REPEAT COUNT_OF(crewBlip) i
|
|
IF DOES_BLIP_EXIST(crewBlip[i])
|
|
REMOVE_BLIP(crewBlip[i])
|
|
ENDIF
|
|
ENDREPEAT
|
|
|
|
REPEAT COUNT_OF(jetData) i
|
|
IF DOES_BLIP_EXIST(jetData[i].blip)
|
|
REMOVE_BLIP(jetData[i].blip)
|
|
ENDIF
|
|
ENDREPEAT
|
|
ENDPROC
|
|
|
|
// reset back to franklin
|
|
PROC RESET_BACK_TO_FRANKLIN()
|
|
SET_PLAYER_PED_AVAILABLE(CHAR_TREVOR, FALSE)
|
|
MISSION_FLOW_SET_FAIL_WARP_LOCATION(<<-822.25739, 177.27713, 70.32091>>, 107.4)
|
|
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)
|
|
DISABLE_CELLPHONE(FALSE)
|
|
KILL_CHASE_HINT_CAM(localChaseHintCamStruct)
|
|
STOP_PLANE_FIGHT_AUDIO_SCENE(PLANE_FIGHT_AUDIO_SCENE_FOCUS_ON_CARGO_PLANE)
|
|
STOP_PLANE_FIGHT_AUDIO_SCENE(PLANE_FIGHT_AUDIO_SCENE_FIGHTER_JET_CAMERA)
|
|
STOP_PLANE_FIGHT_AUDIO_SCENE(PLANE_FIGHT_AUDIO_SCENE_FOCUS_ON_CRASHING_PLANE)
|
|
bDoneFocusAudioScene = FALSE
|
|
bDoneFocusOnCrashingPlaneAudioScene = FALSE
|
|
ENDPROC
|
|
|
|
// cleanup the mission
|
|
PROC MISSION_CLEANUP()
|
|
TRIGGER_MUSIC_EVENT("EXL1_MISSION_FAILED")
|
|
STOP_ALL_PLANE_FIGHT_AUDIO_SCENES()
|
|
|
|
SET_PARTICLE_FX_CAM_INSIDE_VEHICLE(FALSE)
|
|
CLEAR_WEATHER_TYPE_PERSIST()
|
|
|
|
REMOVE_MISSION_TEXT()
|
|
|
|
CLEAR_TIMECYCLE_MODIFIER()
|
|
CASCADE_SHADOWS_SET_CASCADE_BOUNDS_SCALE(1.0)
|
|
CASCADE_SHADOWS_INIT_SESSION()
|
|
|
|
SET_RADAR_ZOOM_PRECISE(0.0)
|
|
|
|
SET_VEHICLE_CONVERSATIONS_PERSIST(FALSE, FALSE)
|
|
|
|
PAUSE_FACE_TO_FACE_CONVERSATION(FALSE)
|
|
|
|
SET_FAKE_MINIMAP_MAX_ALTIMETER_HEIGHT(0)
|
|
|
|
IF DOES_ENTITY_EXIST(transportedVehicle[TRANSPORTED_VEHICLE_INDEX_4WD_DRIVE].veh)
|
|
IF NOT IS_ENTITY_DEAD(transportedVehicle[TRANSPORTED_VEHICLE_INDEX_4WD_DRIVE].veh)
|
|
SET_ENTITY_LOAD_COLLISION_FLAG(transportedVehicle[TRANSPORTED_VEHICLE_INDEX_4WD_DRIVE].veh, FALSE)
|
|
ENDIF
|
|
ENDIF
|
|
|
|
DISABLE_SCUFF_DECALS(FALSE)
|
|
|
|
KILL_FACE_TO_FACE_CONVERSATION_DO_NOT_FINISH_LAST_LINE()
|
|
|
|
REMOVE_COVER_POINT(planeCover)
|
|
REMOVE_COVER_POINT(cockpitLeftCover)
|
|
REMOVE_COVER_POINT(cockpitRightCover)
|
|
//REMOVE_SCENARIO_BLOCKING_AREA(airfieldScenarioBlocking)
|
|
//REMOVE_SCENARIO_BLOCKING_AREA(crashSiteAirScenarioBlocking)
|
|
//REMOVE_SCENARIO_BLOCKING_AREA(crashSiteGroundScenarioBlocking)
|
|
|
|
SET_STREAMING(TRUE)
|
|
|
|
SET_INSTANCE_PRIORITY_HINT(INSTANCE_HINT_NONE)
|
|
|
|
IF STREAMVOL_IS_VALID(hillsStreamingVolume)
|
|
STREAMVOL_DELETE(hillsStreamingVolume)
|
|
ENDIF
|
|
|
|
IF STREAMVOL_IS_VALID(trailerStreamingVolume)
|
|
STREAMVOL_DELETE(trailerStreamingVolume)
|
|
ENDIF
|
|
|
|
CLEAR_GPS_FLAGS()
|
|
|
|
SET_WIND(-1)
|
|
SET_WIND_DIRECTION(-1)
|
|
|
|
RESET_AI_WEAPON_DAMAGE_MODIFIER()
|
|
|
|
SET_AUDIO_FLAG("DisableAbortConversationForRagdoll", FALSE)
|
|
|
|
IF IS_VALID_INTERIOR(iiiTrailer)
|
|
IF IS_INTERIOR_READY(iiiTrailer)
|
|
UNPIN_INTERIOR(iiiTrailer)
|
|
ENDIF
|
|
ENDIF
|
|
|
|
// enable emergency services
|
|
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)
|
|
|
|
IF iCacheParachuteTint >= 0
|
|
SET_PLAYER_PARACHUTE_TINT_INDEX(PLAYER_ID(), iCacheParachuteTint)
|
|
ENDIF
|
|
|
|
SET_CONTROL_SHAKE(PLAYER_CONTROL, 0, 0)
|
|
|
|
SET_PTFX_FORCE_VEHICLE_INTERIOR_FLAG(FALSE) //url:bugstar:7108561 Clean up the vehicle interior PTFX mode
|
|
CPRINTLN(DEBUG_DAN, "Cleanup-cleaning ptfx interior")
|
|
|
|
//STREAMVOL_DELETE(trailerVolume)
|
|
|
|
IF IS_VEHICLE_DRIVEABLE(planeFightVehicle[PFV_TREVOR_PLANE])
|
|
//SET_ENTITY_PROOFS(planeFightVehicle[PFV_TREVOR_PLANE], FALSE, FALSE, FALSE, FALSE, FALSE)
|
|
SET_VEHICLE_IS_CONSIDERED_BY_PLAYER(planeFightVehicle[PFV_TREVOR_PLANE], TRUE)
|
|
SET_ENTITY_ONLY_DAMAGED_BY_PLAYER(planeFightVehicle[PFV_TREVOR_PLANE], FALSE)
|
|
ENDIF
|
|
|
|
IF NOT IS_ENTITY_DEAD(planeFightVehicle[PFV_CARGO_PLANE])
|
|
ENABLE_VEHICLE_DYNAMIC_AMBIENT_SCALES(planeFightVehicle[PFV_CARGO_PLANE])
|
|
//SET_ENTITY_LOAD_COLLISION_FLAG(planeFightVehicle[PFV_CARGO_PLANE], FALSE)
|
|
IF currentMissionStage = STAGE_PLANE_FIGHT
|
|
OR (currentMissionStage = STAGE_ESCAPE_PLANE AND NOT bDoneOutOfPlane)
|
|
IF bDonePlaneCrashWithTrevor
|
|
DELETE_VEHICLE(planeFightVehicle[PFV_CARGO_PLANE])
|
|
ELSE
|
|
IF IS_PLAYBACK_GOING_ON_FOR_VEHICLE(planeFightVehicle[PFV_CARGO_PLANE])
|
|
STOP_PLAYBACK_RECORDED_VEHICLE(planeFightVehicle[PFV_CARGO_PLANE])
|
|
FREEZE_ENTITY_POSITION(planeFightVehicle[PFV_CARGO_PLANE], TRUE)
|
|
SET_VEHICLE_STAYS_FROZEN_WHEN_CLEANED_UP(planeFightVehicle[PFV_CARGO_PLANE], TRUE)
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
|
|
INT i
|
|
|
|
//STOP_CROP_DUST_PTFX()
|
|
REPEAT COUNT_OF(PLANE_SMOKE_ENUM) i
|
|
IF bSmokePTFXActive[i]
|
|
IF DOES_PARTICLE_FX_LOOPED_EXIST(smokePTFX[i])
|
|
STOP_PARTICLE_FX_LOOPED(smokePTFX[i])
|
|
ENDIF
|
|
ENDIF
|
|
ENDREPEAT
|
|
|
|
// detach if needed
|
|
IF NOT IS_PED_INJURED(PLAYER_PED_ID())
|
|
SET_PED_CAPSULE(PLAYER_PED_ID(), 0.0)
|
|
SET_ENTITY_PROOFS(PLAYER_PED_ID(), FALSE, FALSE, FALSE, FALSE, FALSE)
|
|
|
|
// temp config flags
|
|
SET_PED_CONFIG_FLAG(PLAYER_PED_ID(), PCF_WaitForDirectEntryPointToBeFreeWhenExiting, TRUE)
|
|
SET_PED_CONFIG_FLAG(PLAYER_PED_ID(), PCF_OnlyRequireOnePressToExitVehicle, FALSE)
|
|
SET_PED_CONFIG_FLAG(PLAYER_PED_ID(), PCF_ForceExitToSkyDive, FALSE)
|
|
SET_PED_CONFIG_FLAG(PLAYER_PED_ID(), PCF_DisableExitToSkyDive, FALSE)
|
|
|
|
IF IS_ENTITY_ATTACHED(PLAYER_PED_ID())
|
|
IF GET_PED_PARACHUTE_STATE(PLAYER_PED_ID()) = PPS_INVALID
|
|
IF GET_VEHICLE_PED_IS_USING(PLAYER_PED_ID()) = NULL
|
|
CLEAR_PED_TASKS(PLAYER_PED_ID())
|
|
DETACH_ENTITY(PLAYER_PED_ID())
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
//SET_PED_CAN_RAGDOLL(PLAYER_PED_ID(), TRUE)
|
|
//SET_ENTITY_PROOFS(PLAYER_PED_ID(), FALSE, FALSE, FALSE, FALSE, FALSE)
|
|
ENDIF
|
|
|
|
DO_COMMON_PLAYER_AND_CAM_CLEANUP()
|
|
|
|
//IF mocapStreamingStage >= MOCAP_STREAMING_STAGE_WAIT
|
|
REMOVE_CUTSCENE()
|
|
//ENDIF
|
|
|
|
ENABLE_CARGENS_FOR_MISSION(TRUE)
|
|
DISABLE_VEHICLE_GEN_ON_MISSION(FALSE)
|
|
SUPPRESS_MISSION_VEHICLES(FALSE)
|
|
|
|
// remove ron
|
|
IF NOT IS_PED_INJURED(ronPed)
|
|
REMOVE_PED_FROM_GROUP(ronPed)
|
|
ENDIF
|
|
|
|
IF bThoroughCleanup
|
|
IF DOES_ENTITY_EXIST(ronPed)
|
|
DELETE_PED(ronPed)
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF NOT HAS_SOUND_FINISHED(iKlaxonSoundID)
|
|
STOP_SOUND(iKlaxonSoundID)
|
|
ENDIF
|
|
IF NOT HAS_SOUND_FINISHED(iEngineSoundID)
|
|
STOP_SOUND(iEngineSoundID)
|
|
ENDIF
|
|
IF NOT HAS_SOUND_FINISHED(iTransitionSoundID)
|
|
STOP_SOUND(iTransitionSoundID)
|
|
ENDIF
|
|
IF NOT HAS_SOUND_FINISHED(iCarFallSoundID)
|
|
STOP_SOUND(iCarFallSoundID)
|
|
ENDIF
|
|
|
|
|
|
RELEASE_SOUND_ID(iKlaxonSoundID)
|
|
RELEASE_SOUND_ID(iEngineSoundID)
|
|
RELEASE_SOUND_ID(iTransitionSoundID)
|
|
RELEASE_SOUND_ID(iCarFallSoundID)
|
|
|
|
|
|
REPEAT COUNT_OF(jetMissile) i
|
|
IF NOT HAS_SOUND_FINISHED(jetMissile[i].iSoundID)
|
|
STOP_SOUND(jetMissile[i].iSoundID)
|
|
ENDIF
|
|
RELEASE_SOUND_ID(jetMissile[i].iSoundID)
|
|
ENDREPEAT
|
|
|
|
REPEAT COUNT_OF(PLANE_FIGHT_SFX_ENUM) i
|
|
RELEASE_NAMED_SCRIPT_AUDIO_BANK(GET_PLANE_FIGHT_SFX_AS_STRING(INT_TO_ENUM(PLANE_FIGHT_SFX_ENUM, i)))
|
|
ENDREPEAT
|
|
|
|
STOP_STREAM()
|
|
|
|
#IF IS_DEBUG_BUILD
|
|
IF DOES_WIDGET_GROUP_EXIST(planeFightWidgets)
|
|
DELETE_WIDGET_GROUP(planeFightWidgets)
|
|
ENDIF
|
|
#ENDIF
|
|
|
|
TERMINATE_THIS_THREAD()
|
|
ENDPROC
|
|
|
|
// mission passed
|
|
PROC MISSION_PASSED()
|
|
SET_BUILDING_STATE(BUILDINGNAME_IPL_CARGOPLANE, BUILDINGSTATE_DESTROYED)
|
|
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("EXL1_MISSION_FAILED")
|
|
|
|
missionFailState = MISSION_FAIL_STATE_WAIT_FOR_FADE
|
|
savedFailReason = reasonForFail
|
|
|
|
STRING failText
|
|
SWITCH savedFailReason
|
|
CASE FAIL_TREVOR_PLANE_DESTROYED
|
|
failText = "PF_FAIL1"
|
|
BREAK
|
|
CASE FAIL_CARGO_PLANE_DESTROYED
|
|
failText = "PF_FAIL2"
|
|
BREAK
|
|
CASE FAIL_MISSED_CARGO_PLANE
|
|
failText = "PF_FAIL3"
|
|
BREAK
|
|
CASE FAIL_RON_DEAD
|
|
failText = "PF_FAIL4"
|
|
BREAK
|
|
CASE FAIL_FELL_FROM_CARGO_PLANE
|
|
failText = "PF_FAIL5"
|
|
BREAK
|
|
CASE FAIL_ABANDONED_PLANE
|
|
failText = "PF_FAIL6"
|
|
BREAK
|
|
CASE FAIL_ABANDONED_RON
|
|
failText = "PF_FAIL7"
|
|
BREAK
|
|
CASE FAIL_LOST_CARGO_PLANE
|
|
failText = "PF_FAIL10"
|
|
BREAK
|
|
CASE FAIL_TOO_HIGH
|
|
failText = "PF_FAIL8"
|
|
BREAK
|
|
CASE FAIL_OVER_BASE
|
|
failText = "PF_FAIL9"
|
|
BREAK
|
|
CASE FAIL_TREVOR_DEAD
|
|
failText = "CMN_TDIED"
|
|
BREAK
|
|
CASE FAIL_PLANE_STUCK
|
|
failText = "PF_FAIL11"
|
|
BREAK
|
|
CASE FAIL_MICHAEL_DEAD
|
|
failText = "CMN_MDIED"
|
|
BREAK
|
|
CASE FAIL_PATRICIA_DEAD
|
|
failText = "PF_FAIL12"
|
|
BREAK
|
|
CASE FAIL_PLANE_FORCED_GLIDE
|
|
failText = "PF_FAIL13"
|
|
BREAK
|
|
CASE FAIL_LEFT_WORLD
|
|
failText = "PF_FAIL14"
|
|
BREAK
|
|
ENDSWITCH
|
|
|
|
MISSION_FLOW_MISSION_FAILED_WITH_REASON(failText)
|
|
ENDIF
|
|
ENDPROC
|
|
|
|
// remove smoke
|
|
PROC STOP_SMOKE_ON_PLANE(PLANE_SMOKE_ENUM planeSmoke, BOOL bForceNow = FALSE)
|
|
IF bSmokePTFXActive[planeSmoke]
|
|
IF DOES_PARTICLE_FX_LOOPED_EXIST(smokePTFX[planeSmoke])
|
|
IF NOT bForceNow
|
|
STOP_PARTICLE_FX_LOOPED(smokePTFX[planeSmoke])
|
|
ELSE
|
|
REMOVE_PARTICLE_FX(smokePTFX[planeSmoke])
|
|
ENDIF
|
|
ENDIF
|
|
bSmokePTFXActive[planeSmoke] = FALSE
|
|
ENDIF
|
|
ENDPROC
|
|
|
|
// get mission vector
|
|
FUNC VECTOR GET_PLANE_FIGHT_VECTOR(PLANE_FIGHT_VECTOR_ENUM pfVec)
|
|
SWITCH pfVec
|
|
CASE PFVEC_TREVOR_4WD_INIT
|
|
RETURN <<1982.1, 3829.6, 32.3>>
|
|
BREAK
|
|
CASE PFVEC_PLAYER_INIT
|
|
RETURN <<1983.95691, 3823.33374, 31.34886>>
|
|
BREAK
|
|
CASE PFVEC_TREVOR_PLANE_INIT
|
|
RETURN <<2134.84, 4784.11, 39.97>>
|
|
BREAK
|
|
CASE PFVEC_TREVOR_PLANE_MID_POINT
|
|
RETURN <<-2834.33, 3858.68, 35.0>>
|
|
BREAK
|
|
CASE PFVEC_TREVOR_PLANE_CLIMB_POINT
|
|
RETURN <<2411.72, 5802.24, 100.29>>
|
|
BREAK
|
|
CASE PFVEC_TREVOR_PLANE_ENTER_POINT
|
|
RETURN <<2758.59, 4188.90, 371.89>>//<<2758.59, 4148.90, 381.89>>
|
|
BREAK
|
|
CASE PFVEC_CARGO_PLANE_INIT
|
|
RETURN <<510, -3833, 412>>
|
|
BREAK
|
|
CASE PFVEC_CARGO_PLANE_FLY
|
|
RETURN <<1362, -3890, 750>>
|
|
BREAK
|
|
CASE PFVEC_CARGO_PLANE_DESCEND
|
|
RETURN <<1989, 4108, 1456>>
|
|
BREAK
|
|
CASE PFVEC_TREVOR_INSIDE_PLANE_INIT
|
|
RETURN <<-1.5, -20.6, -4.0>> //<<-1.5, -21.0, -4.0>>//-4.5>>
|
|
BREAK
|
|
CASE PFVEC_AIRSTRIP
|
|
RETURN <<2155.72, 4808.02, 40.19>>
|
|
BREAK
|
|
CASE PFVEC_RON_INIT
|
|
RETURN <<1982.63, 3827.46, 31.42>>
|
|
BREAK
|
|
CASE PFVEC_RON_STAND
|
|
RETURN <<2134.09424, 4797.40674, 40.12542>>
|
|
BREAK
|
|
CASE PFVEC_ATTACH_TREVOR_PLANE
|
|
RETURN << 0, -23.8936, -2.1 >>
|
|
BREAK
|
|
CASE PFVEC_CRASH_SMOKE_OFFSET
|
|
RETURN <<0.0, -24.0, -3.55734 >>
|
|
BREAK
|
|
CASE PFVEC_ENGINE_OFFSET
|
|
RETURN<< 27.4893, -12.1439, -1.92886 >>
|
|
//RETURN << 27.3, -9.1, -2.6 >>
|
|
BREAK
|
|
CASE PFVEC_CLOUD_OFFSET
|
|
//RETURN <<0,-38,-13>>
|
|
RETURN <<0,-125,-13>>
|
|
BREAK
|
|
CASE PFVEC_SMOKE_FLIGHT_OFFSET
|
|
RETURN <<0.0, -24.0, -3.55734 >>
|
|
BREAK
|
|
CASE PFVEC_PASSED
|
|
RETURN <<1953.29785, 3961.83008, 31.55935>>
|
|
BREAK
|
|
CASE PFVEC_RUNWAY
|
|
RETURN <<2047.90, 4768.06, 40.06>>
|
|
BREAK
|
|
CASE PFVEC_BASE_LAUNCH
|
|
RETURN <<-3172.56665, 3162.30884, 5.71102>>
|
|
BREAK
|
|
CASE PFVEC_MOVE_LAST_PLAYER_VEHICLE
|
|
RETURN <<-830.42603, 168.64005, 68.80289>>
|
|
BREAK
|
|
ENDSWITCH
|
|
|
|
RETURN <<0,0,0>>
|
|
ENDFUNC
|
|
|
|
// get rid of everything
|
|
PROC CLEAR_MISSION_FOR_SKIP()
|
|
INT i
|
|
|
|
SET_PARTICLE_FX_CAM_INSIDE_VEHICLE(FALSE)
|
|
|
|
SET_PLAYER_OUT_OF_ANY_VEHICLE()
|
|
REMOVE_COVER_POINT(planeCover)
|
|
REMOVE_COVER_POINT(cockpitLeftCover)
|
|
REMOVE_COVER_POINT(cockpitRightCover)
|
|
CLEAR_TIMECYCLE_MODIFIER()
|
|
CASCADE_SHADOWS_SET_CASCADE_BOUNDS_SCALE(1.0)
|
|
CASCADE_SHADOWS_INIT_SESSION()
|
|
SET_RADAR_ZOOM_PRECISE(0.0)
|
|
/*
|
|
IF bDustPTFXActive
|
|
STOP_PARTICLE_FX_LOOPED(dustPTFX)
|
|
bDustPTFXActive = FALSE
|
|
ENDIF
|
|
*/
|
|
|
|
REPEAT COUNT_OF(jetMissile) i
|
|
IF NOT HAS_SOUND_FINISHED(jetMissile[i].iSoundID)
|
|
STOP_SOUND(jetMissile[i].iSoundID)
|
|
ENDIF
|
|
ENDREPEAT
|
|
|
|
SET_FAKE_MINIMAP_MAX_ALTIMETER_HEIGHT(0)
|
|
|
|
STOP_STREAM()
|
|
|
|
IF STREAMVOL_IS_VALID(hillsStreamingVolume)
|
|
STREAMVOL_DELETE(hillsStreamingVolume)
|
|
ENDIF
|
|
|
|
STOP_ALL_PLANE_FIGHT_AUDIO_SCENES()
|
|
|
|
REPEAT COUNT_OF(PLANE_SMOKE_ENUM) i
|
|
STOP_SMOKE_ON_PLANE(INT_TO_ENUM(PLANE_SMOKE_ENUM, i))
|
|
ENDREPEAT
|
|
|
|
// delete entities
|
|
REPEAT 3 i
|
|
IF DOES_ENTITY_EXIST(sSelectorPeds.pedID[i])
|
|
DELETE_PED(sSelectorPeds.pedID[i])
|
|
ENDIF
|
|
ENDREPEAT
|
|
|
|
REPEAT COUNT_OF(enemyData) i
|
|
IF DOES_ENTITY_EXIST(enemyData[i].ped)
|
|
DELETE_PED(enemyData[i].ped)
|
|
ENDIF
|
|
ENDREPEAT
|
|
|
|
IF DOES_ENTITY_EXIST(ronPed)
|
|
DELETE_PED(ronPed)
|
|
ENDIF
|
|
IF DOES_ENTITY_EXIST(michaelPed)
|
|
DELETE_PED(michaelPed)
|
|
ENDIF
|
|
IF DOES_ENTITY_EXIST(patriciaPed)
|
|
DELETE_PED(patriciaPed)
|
|
ENDIF
|
|
IF DOES_ENTITY_EXIST(dummyJetPed)
|
|
DELETE_PED(dummyJetPed)
|
|
ENDIF
|
|
|
|
REPEAT COUNT_OF(NAMED_ENEMY_PED_ENUM) i
|
|
IF DOES_ENTITY_EXIST(namedEnemyPed[i])
|
|
DELETE_PED(namedEnemyPed[i])
|
|
ENDIF
|
|
ENDREPEAT
|
|
|
|
REPEAT NUMBER_JETS i
|
|
IF DOES_ENTITY_EXIST(jetData[i].ped)
|
|
DELETE_PED(jetData[i].ped)
|
|
ENDIF
|
|
IF DOES_ENTITY_EXIST(jetData[i].veh)
|
|
DELETE_VEHICLE(jetData[i].veh)
|
|
ENDIF
|
|
ENDREPEAT
|
|
|
|
REPEAT COUNT_OF(planeFightVehicle) i
|
|
IF DOES_ENTITY_EXIST(planeFightVehicle[i])
|
|
DELETE_VEHICLE(planeFightVehicle[i])
|
|
ENDIF
|
|
ENDREPEAT
|
|
|
|
IF DOES_ENTITY_EXIST(checkpointVehicle)
|
|
DELETE_VEHICLE(checkpointVehicle)
|
|
ENDIF
|
|
|
|
IF DOES_ENTITY_EXIST(fakePlaneVehicle)
|
|
DELETE_VEHICLE(fakePlaneVehicle)
|
|
ENDIF
|
|
|
|
REPEAT COUNT_OF(transportedVehicle) i
|
|
IF DOES_ENTITY_EXIST(transportedVehicle[i].veh)
|
|
DELETE_VEHICLE(transportedVehicle[i].veh)
|
|
transportedVehicle[i].bDetached = FALSE
|
|
ENDIF
|
|
ENDREPEAT
|
|
|
|
REPEAT COUNT_OF(fakeTransportedVehicle) i
|
|
IF DOES_ENTITY_EXIST(fakeTransportedVehicle[i].veh)
|
|
DELETE_VEHICLE(fakeTransportedVehicle[i].veh)
|
|
fakeTransportedVehicle[i].bDetached = FALSE
|
|
ENDIF
|
|
ENDREPEAT
|
|
|
|
REPEAT COUNT_OF(coverObject) i
|
|
IF DOES_ENTITY_EXIST(coverObject[i].obj)
|
|
DELETE_OBJECT(coverObject[i].obj)
|
|
coverObject[i].bDetached = FALSE
|
|
ENDIF
|
|
ENDREPEAT
|
|
|
|
REPEAT COUNT_OF(fakeCoverObject) i
|
|
IF DOES_ENTITY_EXIST(fakeCoverObject[i].obj)
|
|
DELETE_OBJECT(fakeCoverObject[i].obj)
|
|
fakeCoverObject[i].bDetached = FALSE
|
|
ENDIF
|
|
ENDREPEAT
|
|
|
|
REPEAT COUNT_OF(debrisObject) i
|
|
IF DOES_ENTITY_EXIST(debrisObject[i].obj)
|
|
DELETE_OBJECT(debrisObject[i].obj)
|
|
ENDIF
|
|
ENDREPEAT
|
|
|
|
REPEAT COUNT_OF(jetMissile) i
|
|
IF DOES_ENTITY_EXIST(jetMissile[i].obj)
|
|
DELETE_OBJECT(jetMissile[i].obj)
|
|
ENDIF
|
|
ENDREPEAT
|
|
|
|
IF DOES_ENTITY_EXIST(planeRootObject)
|
|
DELETE_OBJECT(planeRootObject)
|
|
ENDIF
|
|
|
|
IF DOES_ENTITY_EXIST(franklinPhoneObject)
|
|
DELETE_OBJECT(franklinPhoneObject)
|
|
ENDIF
|
|
|
|
IF DOES_ENTITY_EXIST(lightRigObject)
|
|
DELETE_OBJECT(lightRigObject)
|
|
ENDIF
|
|
|
|
//IF DOES_ENTITY_EXIST(reflectRigObject)
|
|
// DELETE_OBJECT(reflectRigObject)
|
|
//ENDIF
|
|
|
|
IF DOES_ENTITY_EXIST(fakElightRigObject)
|
|
DELETE_OBJECT(fakElightRigObject)
|
|
ENDIF
|
|
|
|
//IF DOES_ENTITY_EXIST(fakereflectRigObject)
|
|
// DELETE_OBJECT(fakereflectRigObject)
|
|
//ENDIF
|
|
|
|
IF DOES_ENTITY_EXIST(chairObject)
|
|
DELETE_OBJECT(chairObject)
|
|
ENDIF
|
|
|
|
IF DOES_ENTITY_EXIST(radioObject)
|
|
DELETE_OBJECT(radioObject)
|
|
ENDIF
|
|
|
|
IF DOES_CAM_EXIST(staticCam)
|
|
DESTROY_CAM(staticCam)
|
|
ENDIF
|
|
|
|
IF DOES_CAM_EXIST(animCam)
|
|
DESTROY_CAM(animCam)
|
|
ENDIF
|
|
|
|
IF DOES_CAM_EXIST(jetCam)
|
|
DESTROY_CAM(jetCam)
|
|
ENDIF
|
|
|
|
REPEAT COUNT_OF(jetMissile) i
|
|
IF DOES_PARTICLE_FX_LOOPED_EXIST(jetMissile[i].ptfx)
|
|
REMOVE_PARTICLE_FX(jetMissile[i].ptfx)
|
|
ENDIF
|
|
ENDREPEAT
|
|
|
|
CLEAR_AREA(GET_PLANE_FIGHT_VECTOR(PFVEC_PLAYER_INIT), 10000, TRUE)
|
|
ENDPROC
|
|
|
|
// remove plane blip and text
|
|
PROC REMOVE_PLANE_BLIP_AND_TEXT()
|
|
IF DOES_BLIP_EXIST(trevorPlaneBlip)
|
|
REMOVE_BLIP(trevorPlaneBlip)
|
|
ENDIF
|
|
IF IS_THIS_PRINT_BEING_DISPLAYED("PF_PLANE")
|
|
OR IS_THIS_PRINT_BEING_DISPLAYED("PF_PLANE2")
|
|
REMOVE_MISSION_TEXT(TRUE, TRUE, FALSE)
|
|
ENDIF
|
|
ENDPROC
|
|
|
|
// remove ron blip and text
|
|
PROC REMOVE_RON_BLIP_AND_TEXT()
|
|
IF DOES_BLIP_EXIST(ronBlip)
|
|
REMOVE_BLIP(ronBlip)
|
|
ENDIF
|
|
IF IS_THIS_PRINT_BEING_DISPLAYED("PF_WAIT")
|
|
OR IS_THIS_PRINT_BEING_DISPLAYED("PF_LEAVE")
|
|
REMOVE_MISSION_TEXT(TRUE, TRUE, FALSE)
|
|
ENDIF
|
|
ENDPROC
|
|
|
|
// check all peds and vehicles for fail
|
|
PROC HANDLE_MISSION_FAIL_CHECKS()
|
|
IF NOT bRunningCutscene
|
|
IF currentMissionStage <= STAGE_ENTER_PLANE
|
|
IF DOES_ENTITY_EXIST(planeFightVehicle[PFV_TREVOR_PLANE])
|
|
IF NOT IS_VEHICLE_DRIVEABLE(planeFightVehicle[PFV_TREVOR_PLANE])
|
|
BOOL bFail = FALSE
|
|
BOOL bExplode = FALSE
|
|
|
|
IF bDamagedPlaneToGlideDown
|
|
IF IS_ENTITY_DEAD(planeFightVehicle[PFV_TREVOR_PLANE])
|
|
OR IS_ENTITY_IN_WATER(planeFightVehicle[PFV_TREVOR_PLANE])
|
|
bFail = TRUE
|
|
ELIF GET_GAME_TIMER() >= iDamagedPlaneToGlideDownTime + 32000
|
|
REMOVE_PLANE_BLIP_AND_TEXT()
|
|
MISSION_FAILED(FAIL_PLANE_FORCED_GLIDE)
|
|
ENDIF
|
|
ELSE
|
|
bExplode = TRUE
|
|
bFail = TRUE
|
|
ENDIF
|
|
|
|
IF bExplode
|
|
IF currentMissionStage <> STAGE_ENTER_PLANE
|
|
IF NOT IS_ENTITY_DEAD(planeFightVehicle[PFV_TREVOR_PLANE])
|
|
IF GET_VEHICLE_ENGINE_HEALTH(planeFightVehicle[PFV_TREVOR_PLANE]) < 300
|
|
EXPLODE_VEHICLE(planeFightVehicle[PFV_TREVOR_PLANE])
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF bFail
|
|
REMOVE_PLANE_BLIP_AND_TEXT()
|
|
IF NOT HAS_PLAYER_LEFT_THE_WORLD(PLAYER_ID())
|
|
MISSION_FAILED(FAIL_TREVOR_PLANE_DESTROYED)
|
|
ELSE
|
|
MISSION_FAILED(FAIL_LOST_CARGO_PLANE)
|
|
ENDIF
|
|
ENDIF
|
|
ELSE
|
|
IF GET_DISTANCE_BETWEEN_ENTITIES(PLAYER_PED_ID(), planeFightVehicle[PFV_TREVOR_PLANE], FALSE) > STUCK_FAIL_RANGE_m
|
|
IF currentMissionStage = STAGE_FOLLOW_PLANE_1
|
|
OR currentMissionStage = STAGE_FOLLOW_PLANE_2
|
|
OR currentMissionStage = STAGE_FOLLOW_PLANE_3
|
|
OR currentMissionStage = STAGE_ENTER_PLANE
|
|
//OR bAtAirstrip
|
|
MISSION_FAILED(FAIL_ABANDONED_PLANE)
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF currentMissionStage = STAGE_FOLLOW_PLANE_1
|
|
OR currentMissionStage = STAGE_FOLLOW_PLANE_2
|
|
OR currentMissionStage = STAGE_FOLLOW_PLANE_3
|
|
OR currentMissionStage = STAGE_ENTER_PLANE
|
|
IF IS_VEHICLE_STUCK_TIMER_UP(planeFightVehicle[PFV_TREVOR_PLANE], VEH_STUCK_JAMMED, JAMMED_TIME)
|
|
OR IS_VEHICLE_STUCK_TIMER_UP(planeFightVehicle[PFV_TREVOR_PLANE], VEH_STUCK_ON_SIDE, SIDE_TIME)
|
|
OR IS_VEHICLE_STUCK_TIMER_UP(planeFightVehicle[PFV_TREVOR_PLANE], VEH_STUCK_ON_ROOF, ROOF_TIME)
|
|
OR IS_VEHICLE_STUCK_TIMER_UP(planeFightVehicle[PFV_TREVOR_PLANE], VEH_STUCK_HUNG_UP, HUNG_UP_TIME)
|
|
REMOVE_PLANE_BLIP_AND_TEXT()
|
|
MISSION_FAILED(FAIL_PLANE_STUCK)
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF currentMissionStage <= STAGE_FOLLOW_PLANE_1
|
|
IF NOT bRemovedRon
|
|
IF IS_PED_INJURED(ronPed)
|
|
REMOVE_RON_BLIP_AND_TEXT()
|
|
MISSION_FAILED(FAIL_RON_DEAD)
|
|
ELSE
|
|
IF currentMissionStage = STAGE_GET_TO_AIRSTRIP
|
|
//AND NOT bAtAirstrip
|
|
IF GET_DISTANCE_BETWEEN_ENTITIES(PLAYER_PED_ID(), ronPed, FALSE) > ABANDON_BUDDY_FAIL_RANGE
|
|
MISSION_FAILED(FAIL_ABANDONED_RON)
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF NOT IS_VEHICLE_DRIVEABLE(planeFightVehicle[PFV_CARGO_PLANE])
|
|
IF currentMissionStage = STAGE_FOLLOW_PLANE_1
|
|
OR currentMissionStage = STAGE_FOLLOW_PLANE_2
|
|
OR currentMissionStage = STAGE_FOLLOW_PLANE_3
|
|
OR currentMissionStage = STAGE_ENTER_PLANE
|
|
OR currentMissionStage = STAGE_FLY_PLANE
|
|
OR currentMissionStage = STAGE_PLANE_FIGHT
|
|
IF DOES_BLIP_EXIST(getToBlip)
|
|
REMOVE_BLIP(getToBlip)
|
|
ENDIF
|
|
IF IS_THIS_PRINT_BEING_DISPLAYED("PF_FLY")
|
|
OR IS_THIS_PRINT_BEING_DISPLAYED("PF_FCLOSE")
|
|
OR IS_THIS_PRINT_BEING_DISPLAYED("PF_CRASH")
|
|
REMOVE_MISSION_TEXT(TRUE, TRUE, FALSE)
|
|
ENDIF
|
|
|
|
IF currentMissionStage <> STAGE_FLY_PLANE
|
|
OR NOT HAS_PLAYER_LEFT_THE_WORLD(PLAYER_ID())
|
|
MISSION_FAILED(FAIL_CARGO_PLANE_DESTROYED)
|
|
ELSE
|
|
MISSION_FAILED(FAIL_LEFT_WORLD)
|
|
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 now
|
|
|
|
// Call RemovePlayerFromRestrictedVehicle() here if you need to
|
|
//RemovePlayerFromRestrictedVehicle(planeFightVehicle[PFV_CARGO_PLANE])
|
|
|
|
// 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
|
|
|
|
|
|
RESET_BACK_TO_FRANKLIN()
|
|
|
|
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_PLANE_FIGHT_SHOT(PLANE_FIGHT_SHOT_DETAILS_ENUM cutsceneShot, VECTOR &vCamPos, VECTOR &vCamRot, FLOAT &fCamFOV)
|
|
SWITCH cutsceneShot
|
|
CASE PF_SHOT_CRASH_INTO_SEA
|
|
vCamPos = <<315.7, 3782.6, 30.1>>
|
|
vCamRot = <<8.3, 0.4, -22.0>>
|
|
fCamFOV = 27.60
|
|
BREAK
|
|
CASE PF_SHOT_CRASH_INTO_SEAB
|
|
vCamPos = <<316.5, 3791.2, 30.7>>
|
|
vCamRot = <<10.3, 0.4, -16.1>>
|
|
fCamFOV = 27.60
|
|
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 attached to plane
|
|
PROC CREATE_CAM_ATTACHED_TO_CARGO_PLANE(PLANE_FIGHT_SHOT_DETAILS_ENUM planeShot)
|
|
IF IS_VEHICLE_DRIVEABLE(planeFightVehicle[PFV_CARGO_PLANE])
|
|
VECTOR vCamOffset, vCamPoint
|
|
FLOAT fCamFOV
|
|
FLOAT fShakeAmplitude = 1.0
|
|
STRING sShakeType = "road_vibration_shake"
|
|
|
|
SWITCH planeShot
|
|
CASE PF_SHOT_CARGO_DOOR_OPEN
|
|
vCamOffset = <<0,-18.5,-3>>
|
|
vCamPoint = <<0,-50,-3>>
|
|
fCamFOV = 28.98
|
|
BREAK
|
|
CASE PF_SHOT_CRASH_IN_INT
|
|
vCamOffset = <<0,-18.5,-3>>
|
|
vCamPoint = <<0,-50,-3>>
|
|
fCamFOV = 26.75
|
|
BREAK
|
|
CASE PF_SHOT_CRASH_IN_EXT
|
|
vCamOffset = <<-3,-45,-2>>
|
|
vCamPoint = <<0,-20,-2>>
|
|
fCamFOV = 24.92
|
|
BREAK
|
|
CASE PF_SHOT_CRASH_IN_JUMP_OUT
|
|
vCamOffset = <<-1.8,-16,-1>>
|
|
vCamPoint = <<1.5,-30,-2.3>>
|
|
fCamFOV = 28.43
|
|
BREAK
|
|
CASE PF_SHOT_WAVE_DOWN
|
|
vCamOffset = <<6.600, 31.500, 2.300>>
|
|
vCamPoint = <<0.000, 28.300, 2.600>>
|
|
fCamFOV = 45.0
|
|
fShakeAmplitude = 1.0
|
|
BREAK
|
|
CASE PF_SHOT_WAVE_DOWNB
|
|
vCamOffset = <<6.600, 34.900, 2.300>>
|
|
vCamPoint = <<0.000, 32.000, 2.500>>
|
|
fCamFOV = 45.0
|
|
BREAK
|
|
CASE PF_SHOT_ENTER_SEAT
|
|
vCamOffset = <<0.9, 29.0, 2.1>>
|
|
vCamPoint = <<-3.2, 27.6, 2.45>>
|
|
fCamFOV = 35.8
|
|
fShakeAmplitude = 1.5
|
|
BREAK
|
|
CASE PF_SHOT_ENTER_SEATB
|
|
vCamOffset = <<0.75, 29.0, 2.1>>
|
|
vCamPoint = <<-3.2, 27.9, 1.82>>
|
|
fCamFOV = 35.8
|
|
BREAK
|
|
ENDSWITCH
|
|
|
|
vAttachCamPos = vCamOffset
|
|
vAttachCamRot = vCamPoint
|
|
|
|
CREATE_MISSION_STATIC_CAM(staticCam)
|
|
|
|
ATTACH_CAM_TO_ENTITY(staticCam, planeFightVehicle[PFV_CARGO_PLANE], vCamOffset)
|
|
POINT_CAM_AT_ENTITY(staticCam, planeFightVehicle[PFV_CARGO_PLANE], vCamPoint)
|
|
SET_CAM_FOV(staticCam, fCamFOV)
|
|
|
|
SET_CAM_INHERIT_ROLL_VEHICLE(staticCam, planeFightVehicle[PFV_CARGO_PLANE])
|
|
SHAKE_CAM(staticCam, sShakeType, fShakeAmplitude)
|
|
|
|
RENDER_SCRIPT_CAMS(TRUE, FALSE)
|
|
ENDIF
|
|
ENDPROC
|
|
|
|
// cam for a cutscene shot
|
|
PROC CREATE_CAM_FOR_PLANE_FIGHT_SHOT(PLANE_FIGHT_SHOT_DETAILS_ENUM cutsceneShot, BOOL bIsInterp = FALSE, INT iInterpTime = 10000)
|
|
VECTOR vCamPos, vCamRot
|
|
FLOAT fCamFOV
|
|
FILL_CAMERA_PROPERTIES_FOR_PLANE_FIGHT_SHOT(cutsceneShot, vCamPos, vCamRot, fCamFOV)
|
|
CREATE_MISSION_STATIC_CAM(staticCam)
|
|
DETACH_CAM(staticCam)
|
|
STOP_CAM_POINTING(staticCam)
|
|
|
|
SET_CAM_COORD(staticCam, vCamPos)
|
|
SET_CAM_ROT(staticCam, vCamRot)
|
|
SET_CAM_FOV(staticCam, fCamFOV)
|
|
|
|
// setup for interpolation
|
|
IF bIsInterp
|
|
FILL_CAMERA_PROPERTIES_FOR_PLANE_FIGHT_SHOT(INT_TO_ENUM(PLANE_FIGHT_SHOT_DETAILS_ENUM, ENUM_TO_INT(cutsceneShot)+1), vCamPos, vCamRot, fCamFOV)
|
|
CREATE_MISSION_STATIC_CAM(interpCam)
|
|
SET_CAM_COORD(interpCam, vCamPos)
|
|
SET_CAM_ROT(interpCam, vCamRot)
|
|
SET_CAM_FOV(interpCam, fCamFOV)
|
|
SET_CAM_ACTIVE_WITH_INTERP(interpCam, staticCam, iInterpTime)
|
|
ENDIF
|
|
|
|
RENDER_SCRIPT_CAMS(TRUE, FALSE)
|
|
ENDPROC
|
|
|
|
// create an anim cam for sync scenes
|
|
PROC CREATE_MISSION_ANIM_CAM()
|
|
IF DOES_CAM_EXIST(animCam)
|
|
DESTROY_CAM(animCam)
|
|
ENDIF
|
|
animCam = CREATE_CAM("DEFAULT_ANIMATED_CAMERA", TRUE)
|
|
RENDER_SCRIPT_CAMS(TRUE, FALSE)
|
|
ENDPROC
|
|
|
|
//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_SCRIPTS_SAFE_FOR_CUTSCENE(TRUE)
|
|
SET_CUTSCENE_HUD_ELEMENTS()
|
|
ENDPROC
|
|
|
|
// setup stuff for plane fight cutscene
|
|
PROC SET_MISSION_CUTSCENE(BOOL bStart, BOOL bResetControlAndCameras = TRUE, BOOL bDoFade = TRUE, BOOL bSetRelativeHeading = TRUE)
|
|
REMOVE_MISSION_TEXT()
|
|
SET_SCRIPTS_SAFE_FOR_CUTSCENE(bStart)
|
|
|
|
IF bStart
|
|
SET_CUTSCENE_HUD_ELEMENTS()
|
|
DISPLAY_RADAR(FALSE)
|
|
DISPLAY_HUD(FALSE)
|
|
iAllowSkipCutsceneTime = GET_GAME_TIMER()
|
|
ELSE
|
|
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
|
|
bSkippedCutscene = FALSE
|
|
bClearedForCutscene = FALSE
|
|
bSkipInProgress = FALSE
|
|
cutsceneStage = PF_CUT_STAGE_INIT
|
|
|
|
IF bDoFade
|
|
IF IS_SCREEN_FADED_OUT()
|
|
DO_SCREEN_FADE_IN(DEFAULT_FADE_TIME)
|
|
ENDIF
|
|
ENDIF
|
|
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
|
|
|
|
// get correct model for mission vehicle
|
|
FUNC PLANE_FIGHT_MODEL_ENUM GET_MODEL_ENUM_FOR_PLANE_FIGHT_VEHICLE(PLANE_FIGHT_VEHICLE_ENUM pfVehicle)
|
|
SWITCH pfVehicle
|
|
CASE PFV_TREVOR_4WD
|
|
RETURN PFM_TREVOR_4WD
|
|
BREAK
|
|
CASE PFV_TREVOR_PLANE
|
|
RETURN PFM_TREVOR_PLANE
|
|
BREAK
|
|
CASE PFV_CARGO_PLANE
|
|
RETURN PFM_CARGO_PLANE
|
|
BREAK
|
|
ENDSWITCH
|
|
|
|
RETURN PFM_4WD
|
|
ENDFUNC
|
|
|
|
// is this model required on this stage?
|
|
FUNC BOOL IS_MODEL_REQUIRED_FOR_MISSION_STAGE(PLANE_FIGHT_MODEL_ENUM pfModel, MISSION_STAGE_ENUM reqStage)
|
|
SWITCH pfModel
|
|
CASE PFM_TREVOR
|
|
RETURN TRUE
|
|
BREAK
|
|
CASE PFM_RON
|
|
IF reqStage <= STAGE_FOLLOW_PLANE_1
|
|
RETURN TRUE
|
|
ENDIF
|
|
BREAK
|
|
CASE PFM_MICHAEL
|
|
CASE PFM_PATRICIA
|
|
IF reqStage = STAGE_GET_TO_AIRSTRIP
|
|
RETURN TRUE
|
|
ENDIF
|
|
BREAK
|
|
CASE PFM_TREVOR_4WD
|
|
IF reqStage = STAGE_GET_TO_AIRSTRIP
|
|
RETURN TRUE
|
|
ENDIF
|
|
BREAK
|
|
CASE PFM_TREVOR_PLANE
|
|
IF reqStage >= STAGE_FOLLOW_PLANE_1
|
|
AND reqStage <= STAGE_ENTER_PLANE
|
|
RETURN TRUE
|
|
ENDIF
|
|
BREAK
|
|
CASE PFM_CARGO_PLANE
|
|
CASE PFM_LIGHT_RIG
|
|
//CASE PFM_REFLECT_RIG
|
|
IF reqStage >= STAGE_FOLLOW_PLANE_1
|
|
RETURN TRUE
|
|
ENDIF
|
|
BREAK
|
|
CASE PFM_PILOT
|
|
IF reqStage >= STAGE_FOLLOW_PLANE_1
|
|
AND reqStage <= STAGE_PLANE_FIGHT
|
|
RETURN TRUE
|
|
ENDIF
|
|
BREAK
|
|
CASE PFM_ENEMY
|
|
IF reqStage = STAGE_PLANE_FIGHT
|
|
OR reqStage = STAGE_ENTER_PLANE
|
|
RETURN TRUE
|
|
ENDIF
|
|
BREAK
|
|
CASE PFM_SOLDIER
|
|
CASE PFM_JET
|
|
IF reqStage = STAGE_FLY_PLANE
|
|
//OR reqStage = STAGE_FOLLOW_PLANE_1
|
|
//OR reqStage = STAGE_FOLLOW_PLANE_2
|
|
//OR reqStage = STAGE_FOLLOW_PLANE_3
|
|
RETURN TRUE
|
|
ENDIF
|
|
BREAK
|
|
CASE PFM_4WD
|
|
// CASE PFM_VAN
|
|
IF reqStage >= STAGE_ENTER_PLANE
|
|
RETURN TRUE
|
|
ENDIF
|
|
BREAK
|
|
CASE PFM_COVER1
|
|
CASE PFM_COVER2
|
|
IF reqStage = STAGE_ENTER_PLANE
|
|
OR reqStage = STAGE_PLANE_FIGHT
|
|
OR reqStage = STAGE_ESCAPE_PLANE
|
|
RETURN TRUE
|
|
ENDIF
|
|
BREAK
|
|
CASE PFM_PLANE_ROOT
|
|
IF reqStage = STAGE_FLY_PLANE
|
|
OR reqStage = STAGE_FOLLOW_PLANE_1
|
|
OR reqStage = STAGE_FOLLOW_PLANE_2
|
|
OR reqStage = STAGE_FOLLOW_PLANE_3
|
|
RETURN TRUE
|
|
ENDIF
|
|
BREAK
|
|
CASE PFM_CHAIR
|
|
IF reqStage = STAGE_GET_TO_AIRSTRIP
|
|
RETURN TRUE
|
|
ENDIF
|
|
BREAK
|
|
CASE PFM_RADIO
|
|
IF reqStage = STAGE_FLY_PLANE
|
|
RETURN TRUE
|
|
ENDIF
|
|
BREAK
|
|
CASE PFM_LAST_VEHICLE
|
|
IF reqStage = STAGE_FOLLOW_PLANE_1
|
|
IF Is_Replay_In_Progress()
|
|
IF IS_REPLAY_CHECKPOINT_VEHICLE_AVAILABLE()
|
|
IF IS_REPLAY_VEHICLE_MODEL_UNDER_SIZE_LIMIT(GET_REPLAY_CHECKPOINT_VEHICLE_MODEL(), <<0,0,0>>)
|
|
printstring("request checkpoint vehicle") printnl()
|
|
RETURN TRUE
|
|
ENDIF
|
|
ELSE
|
|
printstring("DON'T request checkpoint vehicle") printnl()
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
BREAK
|
|
|
|
ENDSWITCH
|
|
|
|
RETURN FALSE
|
|
ENDFUNC
|
|
|
|
// add a request for a model
|
|
PROC ADD_MODEL_REQUEST(INT i)
|
|
MODEL_NAMES mModelToRequest = GET_MODEL_FOR_PLANE_FIGHT_MODEL_ENUM(INT_TO_ENUM(PLANE_FIGHT_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_PLANE_FIGHT_MODEL_ENUM(INT_TO_ENUM(PLANE_FIGHT_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_PLANE_FIGHT_MODEL_ENUM(INT_TO_ENUM(PLANE_FIGHT_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(PLANE_FIGHT_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(PLANE_FIGHT_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 // main cargo plane recording
|
|
IF reqStage = STAGE_FOLLOW_PLANE_1
|
|
OR reqStage = STAGE_FOLLOW_PLANE_2
|
|
OR reqStage = STAGE_FOLLOW_PLANE_3
|
|
OR reqStage = STAGE_ENTER_PLANE
|
|
RETURN TRUE
|
|
ENDIF
|
|
BREAK
|
|
//CASE 002 // player plane recording
|
|
// IF reqStage = STAGE_FOLLOW_PLANE_3
|
|
// OR reqStage = STAGE_ENTER_PLANE
|
|
// RETURN TRUE
|
|
// ENDIF
|
|
//BREAK
|
|
//CASE 003 // crash recording
|
|
// IF reqStage = STAGE_ESCAPE_PLANE
|
|
// RETURN TRUE
|
|
// ENDIF
|
|
//BREAK
|
|
//CASE 004 // jack recording
|
|
// IF reqStage = STAGE_PLANE_FIGHT
|
|
// RETURN TRUE
|
|
// ENDIF
|
|
//BREAK
|
|
CASE 005 // fight recording
|
|
IF reqStage = STAGE_PLANE_FIGHT
|
|
OR reqStage = STAGE_ENTER_PLANE
|
|
RETURN TRUE
|
|
ENDIF
|
|
BREAK
|
|
CASE 006 //descending recording
|
|
IF reqStage >= STAGE_ESCAPE_PLANE
|
|
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_PLANE_FIGHT_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_PLANE_FIGHT_RECORDING_PREFIX())
|
|
REMOVE_VEHICLE_RECORDING(iRec, GET_PLANE_FIGHT_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_PLANE_FIGHT_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
|
|
|
|
// get an anim dict enum as string
|
|
FUNC STRING GET_PLANE_FIGHT_ANIM_DICT_AS_STRING(PLANE_FIGHT_ANIM_DICT_ENUM animDict)
|
|
SWITCH animDict
|
|
CASE PF_ANIM_DICT_MISSION
|
|
RETURN "MISSEXILE1_CargoPlane"
|
|
BREAK
|
|
CASE PF_ANIM_DICT_LADDERS_BASE
|
|
RETURN "LADDERSBASE"
|
|
BREAK
|
|
CASE PF_ANIM_DICT_LADDERS_MAIN
|
|
RETURN "LADDERS"
|
|
BREAK
|
|
CASE PF_ANIM_DICT_TO_PARACHUTE
|
|
RETURN "MISSEXILE1_Cargoplanejumpout"
|
|
BREAK
|
|
CASE PF_ANIM_DICT_CELLPHONE
|
|
RETURN "CELLPHONE@"
|
|
BREAK
|
|
CASE PF_ANIM_DICT_LEADOUT
|
|
RETURN "MISSEXILE1_CargoPlaneLeadInOutEXILE_1_INT"
|
|
BREAK
|
|
CASE PF_ANIM_DICT_LEADIN
|
|
RETURN "missexile1_cargoplaneleadinoutexile_1_intleadin"
|
|
BREAK
|
|
ENDSWITCH
|
|
|
|
RETURN "invalid!"
|
|
ENDFUNC
|
|
|
|
// is this anim dict required on this stage?
|
|
FUNC BOOL IS_ANIM_DICT_REQUIRED_FOR_MISSION_STAGE(PLANE_FIGHT_ANIM_DICT_ENUM animDict, MISSION_STAGE_ENUM reqStage)
|
|
SWITCH animDict
|
|
CASE PF_ANIM_DICT_MISSION
|
|
IF reqStage = STAGE_PLANE_FIGHT
|
|
OR reqStage = STAGE_FLY_PLANE
|
|
OR reqStage = STAGE_ENTER_PLANE
|
|
RETURN TRUE
|
|
ENDIF
|
|
BREAK
|
|
CASE PF_ANIM_DICT_LADDERS_BASE
|
|
CASE PF_ANIM_DICT_LADDERS_MAIN
|
|
IF reqStage = STAGE_PLANE_FIGHT
|
|
RETURN TRUE
|
|
ENDIF
|
|
BREAK
|
|
CASE PF_ANIM_DICT_TO_PARACHUTE
|
|
IF reqStage = STAGE_ESCAPE_PLANE
|
|
RETURN TRUE
|
|
ENDIF
|
|
BREAK
|
|
CASE PF_ANIM_DICT_LEADOUT
|
|
IF reqStage = STAGE_GET_TO_AIRSTRIP
|
|
RETURN TRUE
|
|
ENDIF
|
|
BREAK
|
|
ENDSWITCH
|
|
|
|
RETURN FALSE
|
|
ENDFUNC
|
|
|
|
// add a request for an anim
|
|
PROC ADD_ANIM_DICT_REQUEST(PLANE_FIGHT_ANIM_DICT_ENUM animDict)
|
|
bAnimDictRequestTracker[animDict] = TRUE
|
|
STRING sAnimDict = GET_PLANE_FIGHT_ANIM_DICT_AS_STRING(animDict)
|
|
REQUEST_ANIM_DICT(sAnimDict)
|
|
ENDPROC
|
|
|
|
// clear an anim request slot
|
|
PROC CLEAR_ANIM_DICT_REQUEST(PLANE_FIGHT_ANIM_DICT_ENUM animDict)
|
|
IF bAnimDictRequestTracker[animDict]
|
|
bAnimDictRequestTracker[animDict] = FALSE
|
|
STRING sAnimDict = GET_PLANE_FIGHT_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(PLANE_FIGHT_ANIM_DICT_ENUM) i
|
|
IF bAnimDictRequestTracker[i]
|
|
IF NOT HAS_ANIM_DICT_LOADED(GET_PLANE_FIGHT_ANIM_DICT_AS_STRING(INT_TO_ENUM(PLANE_FIGHT_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(PLANE_FIGHT_ANIM_DICT_ENUM) i
|
|
PLANE_FIGHT_ANIM_DICT_ENUM thisAnimDict = INT_TO_ENUM(PLANE_FIGHT_ANIM_DICT_ENUM, i)
|
|
|
|
IF IS_ANIM_DICT_REQUIRED_FOR_MISSION_STAGE(thisAnimDict, requestStage)
|
|
// if we need this recording, request it
|
|
ADD_ANIM_DICT_REQUEST(thisAnimDict)
|
|
ELSE
|
|
// otherwise try and get rid of it
|
|
IF NOT IS_ANIM_DICT_REQUIRED_FOR_MISSION_STAGE(thisAnimDict, currentMissionStage)
|
|
OR NOT bKeepAnimsForCurrentStage
|
|
CLEAR_ANIM_DICT_REQUEST(thisAnimDict)
|
|
ENDIF
|
|
ENDIF
|
|
ENDREPEAT
|
|
|
|
// if wait for load, don't quit out 'til all the recordings are in
|
|
IF bWaitForLoad
|
|
IF NOT HAVE_ALL_ANIM_DICT_REQUESTS_SUCCEEDED()
|
|
LOAD_ALL_OBJECTS_IF_SCREEN_FADED_OUT()
|
|
WHILE NOT HAVE_ALL_ANIM_DICT_REQUESTS_SUCCEEDED()
|
|
WAIT(0)
|
|
ENDWHILE
|
|
ENDIF
|
|
ENDIF
|
|
ENDPROC
|
|
|
|
// get a weapon enum as a weapontype
|
|
FUNC WEAPON_TYPE GET_PLANE_FIGHT_WEAPON_TYPE(PLANE_FIGHT_WEAPON_ENUM weapon)
|
|
SWITCH weapon
|
|
CASE PF_WEAPON_MERC_PISTOL
|
|
RETURN WEAPONTYPE_APPISTOL
|
|
BREAK
|
|
CASE PF_WEAPON_MERC_LMG
|
|
RETURN WEAPONTYPE_COMBATMG
|
|
BREAK
|
|
CASE PF_WEAPON_MERC_SHOTGUN
|
|
RETURN WEAPONTYPE_PUMPSHOTGUN
|
|
BREAK
|
|
CASE PF_WEAPON_MERC_RPG
|
|
RETURN WEAPONTYPE_RPG
|
|
BREAK
|
|
CASE PF_WEAPON_PILOT_PISTOL
|
|
RETURN WEAPONTYPE_PISTOL
|
|
BREAK
|
|
CASE PF_WEAPON_PLAYER_BACKUP
|
|
RETURN WEAPONTYPE_ASSAULTRIFLE
|
|
BREAK
|
|
ENDSWITCH
|
|
|
|
RETURN WEAPONTYPE_UNARMED
|
|
ENDFUNC
|
|
|
|
// is this weapon required on this stage?
|
|
FUNC BOOL IS_WEAPON_REQUIRED_FOR_MISSION_STAGE(PLANE_FIGHT_WEAPON_ENUM weapon, MISSION_STAGE_ENUM reqStage)
|
|
SWITCH weapon
|
|
CASE PF_WEAPON_MERC_PISTOL
|
|
CASE PF_WEAPON_MERC_SHOTGUN
|
|
IF reqStage = STAGE_PLANE_FIGHT
|
|
RETURN TRUE
|
|
ENDIF
|
|
BREAK
|
|
CASE PF_WEAPON_MERC_RPG
|
|
IF reqStage = STAGE_FOLLOW_PLANE_3
|
|
OR reqStage = STAGE_ENTER_PLANE
|
|
RETURN TRUE
|
|
ENDIF
|
|
BREAK
|
|
CASE PF_WEAPON_PILOT_PISTOL
|
|
CASE PF_WEAPON_PLAYER_BACKUP
|
|
IF reqStage = STAGE_PLANE_FIGHT
|
|
RETURN TRUE
|
|
ENDIF
|
|
BREAK
|
|
CASE PF_WEAPON_MERC_LMG
|
|
IF reqStage = STAGE_FOLLOW_PLANE_3
|
|
OR reqStage = STAGE_ENTER_PLANE
|
|
OR reqStage = STAGE_PLANE_FIGHT
|
|
RETURN TRUE
|
|
ENDIF
|
|
BREAK
|
|
ENDSWITCH
|
|
|
|
RETURN FALSE
|
|
ENDFUNC
|
|
|
|
// add a request for a weapon
|
|
PROC ADD_WEAPON_REQUEST(PLANE_FIGHT_WEAPON_ENUM weapon)
|
|
bWeaponRequestTracker[weapon] = TRUE
|
|
WEAPON_TYPE weaponType = GET_PLANE_FIGHT_WEAPON_TYPE(weapon)
|
|
REQUEST_WEAPON_ASSET(weaponType)
|
|
PRINTSTRING("requesting weapon ") PRINTINT(ENUM_TO_INT(weapon)) PRINTNL()
|
|
ENDPROC
|
|
|
|
// clear a weapon request slot
|
|
PROC CLEAR_WEAPON_REQUEST(PLANE_FIGHT_WEAPON_ENUM weapon)
|
|
IF bWeaponRequestTracker[weapon]
|
|
bWeaponRequestTracker[weapon] = FALSE
|
|
WEAPON_TYPE weaponType = GET_PLANE_FIGHT_WEAPON_TYPE(weapon)
|
|
IF HAS_WEAPON_ASSET_LOADED(weaponType)
|
|
REMOVE_WEAPON_ASSET(weaponType)
|
|
PRINTSTRING("removing weapon ") PRINTINT(ENUM_TO_INT(weapon)) PRINTNL()
|
|
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(PLANE_FIGHT_WEAPON_ENUM) i
|
|
IF bWeaponRequestTracker[i]
|
|
IF NOT HAS_WEAPON_ASSET_LOADED(GET_PLANE_FIGHT_WEAPON_TYPE(INT_TO_ENUM(PLANE_FIGHT_WEAPON_ENUM, i)))
|
|
printstring("not loaded weapon ") printint(i) printnl()
|
|
|
|
// 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(PLANE_FIGHT_WEAPON_ENUM) i
|
|
PLANE_FIGHT_WEAPON_ENUM thisWeapon = INT_TO_ENUM(PLANE_FIGHT_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_PLANE_FIGHT_PTFX_AS_STRING(PLANE_FIGHT_PTFX_ENUM ptfx)
|
|
SWITCH ptfx
|
|
//CASE PF_PTFX_SCRIPT
|
|
// RETURN "script"
|
|
///BREAK
|
|
CASE PF_PTFX_MISSION
|
|
RETURN "scr_exile1"
|
|
BREAK
|
|
ENDSWITCH
|
|
|
|
RETURN "invalid!"
|
|
ENDFUNC
|
|
*/
|
|
|
|
// is this ptfx required on this stage?
|
|
FUNC BOOL IS_PTFX_REQUIRED_FOR_MISSION_STAGE(PLANE_FIGHT_PTFX_ENUM ptfx, MISSION_STAGE_ENUM reqStage)
|
|
SWITCH ptfx
|
|
//CASE PF_PTFX_SCRIPT
|
|
// IF reqStage = STAGE_FOLLOW_PLANE
|
|
// RETURN TRUE
|
|
// ENDIF
|
|
//BREAK
|
|
CASE PF_PTFX_MISSION
|
|
IF reqStage >= STAGE_FOLLOW_PLANE_1
|
|
RETURN TRUE
|
|
ENDIF
|
|
BREAK
|
|
ENDSWITCH
|
|
|
|
RETURN FALSE
|
|
ENDFUNC
|
|
|
|
// add a request for a ptfx
|
|
PROC ADD_PTFX_REQUEST(PLANE_FIGHT_PTFX_ENUM ptfx)
|
|
bPTFXRequestTracker[ptfx] = TRUE
|
|
// STRING sPTFX = GET_PLANE_FIGHT_PTFX_AS_STRING(ptfx)
|
|
REQUEST_PTFX_ASSET()
|
|
ENDPROC
|
|
|
|
// clear a ptfx request slot
|
|
PROC CLEAR_PTFX_REQUEST(PLANE_FIGHT_PTFX_ENUM ptfx)
|
|
IF bPTFXRequestTracker[ptfx]
|
|
bPTFXRequestTracker[ptfx] = FALSE
|
|
// STRING sPTFX = GET_PLANE_FIGHT_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(PLANE_FIGHT_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(PLANE_FIGHT_PTFX_ENUM) i
|
|
PLANE_FIGHT_PTFX_ENUM thisPTFX = INT_TO_ENUM(PLANE_FIGHT_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 requestStage = STAGE_PLANE_FIGHT OR requestStage = STAGE_FLY_PLANE
|
|
SET_PTFX_FORCE_VEHICLE_INTERIOR_FLAG(TRUE) //url:bugstar:7108561 Set this stage as having vehicle interior PTFX
|
|
CPRINTLN(DEBUG_DAN, "SETTING ptfx interior")
|
|
ELSE
|
|
SET_PTFX_FORCE_VEHICLE_INTERIOR_FLAG(FALSE)
|
|
CPRINTLN(DEBUG_DAN, "clearing ptfx interior")
|
|
ENDIF
|
|
|
|
// 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
|
|
|
|
// is this sfx required on this stage?
|
|
FUNC BOOL IS_SFX_REQUIRED_FOR_MISSION_STAGE(PLANE_FIGHT_SFX_ENUM sfx, MISSION_STAGE_ENUM reqStage)
|
|
SWITCH sfx
|
|
CASE PF_SFX_ALARM
|
|
IF reqStage >= STAGE_FLY_PLANE
|
|
RETURN TRUE
|
|
ENDIF
|
|
BREAK
|
|
CASE PF_SFX_CAR1
|
|
CASE PF_SFX_CAR2
|
|
CASE PF_SFX_CAR3
|
|
IF reqStage = STAGE_PLANE_FIGHT
|
|
RETURN TRUE
|
|
ENDIF
|
|
BREAK
|
|
CASE PF_SFX_FAIL
|
|
CASE PF_SFX_TRANSITION
|
|
IF reqStage = STAGE_ESCAPE_PLANE
|
|
RETURN TRUE
|
|
ENDIF
|
|
BREAK
|
|
|
|
ENDSWITCH
|
|
|
|
RETURN FALSE
|
|
ENDFUNC
|
|
|
|
// add a request for a sfx
|
|
PROC ADD_SFX_REQUEST(PLANE_FIGHT_SFX_ENUM sfx)
|
|
bSFXRequestTracker[sfx] = TRUE
|
|
STRING sSFX = GET_PLANE_FIGHT_SFX_AS_STRING(sfx)
|
|
REQUEST_SCRIPT_AUDIO_BANK(sSFX)
|
|
ENDPROC
|
|
|
|
// clear a sfx request slot
|
|
PROC CLEAR_SFX_REQUEST(PLANE_FIGHT_SFX_ENUM sfx)
|
|
IF bSFXRequestTracker[sfx]
|
|
bSFXRequestTracker[sfx] = FALSE
|
|
STRING sSFX = GET_PLANE_FIGHT_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(PLANE_FIGHT_SFX_ENUM) i
|
|
IF bSFXRequestTracker[i]
|
|
IF NOT REQUEST_SCRIPT_AUDIO_BANK(GET_PLANE_FIGHT_SFX_AS_STRING(INT_TO_ENUM(PLANE_FIGHT_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(PLANE_FIGHT_SFX_ENUM) i
|
|
PLANE_FIGHT_SFX_ENUM thisSFX = INT_TO_ENUM(PLANE_FIGHT_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(PLANE_FIGHT_MISC_ASSET_ENUM miscAsset, MISSION_STAGE_ENUM reqStage)
|
|
reqStage=reqStage
|
|
SWITCH miscAsset
|
|
CASE PF_MISC_ASSET_TEMP
|
|
BREAK
|
|
ENDSWITCH
|
|
|
|
RETURN FALSE
|
|
ENDFUNC
|
|
|
|
// add a request for a misc asset
|
|
PROC ADD_MISC_ASSET_REQUEST(PLANE_FIGHT_MISC_ASSET_ENUM miscAsset)
|
|
bMiscAssetRequestTracker[miscAsset] = TRUE
|
|
|
|
SWITCH miscAsset
|
|
CASE PF_MISC_ASSET_TEMP
|
|
BREAK
|
|
ENDSWITCH
|
|
ENDPROC
|
|
|
|
// clear a misc asset slot
|
|
PROC CLEAR_MISC_ASSET_REQUEST(PLANE_FIGHT_MISC_ASSET_ENUM miscAsset)
|
|
IF bMiscAssetRequestTracker[miscAsset]
|
|
bMiscAssetRequestTracker[miscAsset] = FALSE
|
|
SWITCH miscAsset
|
|
CASE PF_MISC_ASSET_TEMP
|
|
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(PLANE_FIGHT_MISC_ASSET_ENUM) i
|
|
IF bMiscAssetRequestTracker[i]
|
|
SWITCH INT_TO_ENUM(PLANE_FIGHT_MISC_ASSET_ENUM, i)
|
|
CASE PF_MISC_ASSET_TEMP
|
|
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(PLANE_FIGHT_MISC_ASSET_ENUM) i
|
|
PLANE_FIGHT_MISC_ASSET_ENUM thisMiscAsset = INT_TO_ENUM(PLANE_FIGHT_MISC_ASSET_ENUM, i)
|
|
|
|
IF IS_MISC_ASSET_REQUIRED_FOR_MISSION_STAGE(thisMiscAsset, requestStage)
|
|
// if we need this asset, request it
|
|
ADD_MISC_ASSET_REQUEST(thisMiscAsset)
|
|
ELSE
|
|
// otherwise try and get rid of it
|
|
IF NOT IS_MISC_ASSET_REQUIRED_FOR_MISSION_STAGE(thisMiscAsset, currentMissionStage)
|
|
OR NOT bKeepMiscAssetsForCurrentStage
|
|
CLEAR_MISC_ASSET_REQUEST(thisMiscAsset)
|
|
ENDIF
|
|
ENDIF
|
|
ENDREPEAT
|
|
|
|
// if wait for load, don't quit out 'til all the recordings are in
|
|
IF bWaitForLoad
|
|
IF NOT HAVE_ALL_MISC_ASSET_REQUESTS_SUCCEEDED()
|
|
LOAD_ALL_OBJECTS_IF_SCREEN_FADED_OUT()
|
|
WHILE NOT HAVE_ALL_MISC_ASSET_REQUESTS_SUCCEEDED()
|
|
WAIT(0)
|
|
ENDWHILE
|
|
ENDIF
|
|
ENDIF
|
|
ENDPROC
|
|
|
|
// request the text for the mission
|
|
PROC REQUEST_TEXT(BOOL bWaitForLoad)
|
|
REQUEST_ADDITIONAL_TEXT("PFIGHT", 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()
|
|
hotswapStage = MISSION_HOTSWAP_STAGE_SELECT_CHARACTER
|
|
streamingStage = MISSION_STREAMING_STAGE_REQUEST
|
|
cutsceneStage = PF_CUT_STAGE_INIT
|
|
bRunningCutscene = FALSE
|
|
bSkippedCutscene = FALSE
|
|
bClearedForCutscene = FALSE
|
|
bShownGodText = FALSE
|
|
bDoneGotoSpeech = FALSE
|
|
bShouldDoGetInText = FALSE
|
|
bWaitForRonPrompt = FALSE
|
|
bGetRonPrompt = FALSE
|
|
bDoneBanter = FALSE
|
|
bSavedBanter = FALSE
|
|
bRemovedBlipsForWanted = FALSE
|
|
//bKilledConversationOnWanted = FALSE
|
|
bShownLoseWantedPrompt = FALSE
|
|
iNextRandomSpeechTime = -1
|
|
iClearHelpTime = 0
|
|
ENDPROC
|
|
|
|
// get all variables in the correct state for this stage
|
|
PROC RESET_VARIABLES_FOR_STAGE(MISSION_STAGE_ENUM resetStage, BOOL bResetCommonVariables = TRUE)
|
|
IF bResetCommonVariables
|
|
RESET_ALL_COMMON_VARIABLES()
|
|
ENDIF
|
|
|
|
INT i
|
|
SWITCH resetStage
|
|
CASE STAGE_GET_TO_AIRSTRIP
|
|
createPlaneStage = CREATE_PLANE_STAGE_NOT_STARTED
|
|
bForceIntoCar = FALSE
|
|
// bRestoredControlOnStart = FALSE
|
|
bAtAirstrip = FALSE
|
|
bDoneBriefSpeech = FALSE
|
|
bRonOutOfGroup = FALSE
|
|
bSetRonAsGroupMember = FALSE
|
|
bRemovedRon = FALSE
|
|
bResetDirectEntryFlag = FALSE
|
|
bDoneInTruckAudioScene = FALSE
|
|
bStoppedInTruckAudioScene = FALSE
|
|
bDoneOwnHangarSpeech = FALSE
|
|
bCleanedUpMichaelAndPatricia = FALSE
|
|
bRonActionModeTrack = FALSE
|
|
bDoneTrevorGoBackSpeech = FALSE
|
|
bKilledBanterForHangarSpeech = FALSE
|
|
bDoneOwnHangarSpeech = FALSE
|
|
bFinishedBanterSpeech = FALSE
|
|
bKilledHillsStreaming = FALSE
|
|
iGetInTextStage = 3
|
|
iRonActionModeDelay = 0
|
|
fInTrailerTime = 0.0
|
|
BREAK
|
|
|
|
CASE STAGE_FOLLOW_PLANE_1
|
|
jetAttackState = JET_ATTACK_NOT_CREATED
|
|
iGetInTextStage = 2
|
|
fOverBaseTime = 0.0
|
|
iAlarmIntensitySetting = 0
|
|
iApproachSpeechStage = 0
|
|
iShownTooHighHelpTimes = 0
|
|
iTooHighCount = 0
|
|
fPlaneSpeed = 0.0
|
|
fAboveHeightTime = 0.0
|
|
iScrambleJetsTime = -1
|
|
bRemovedRon = FALSE
|
|
bDoneRonWalkToTrailer = FALSE
|
|
bDoneSeePlane = FALSE
|
|
bActivatedCargoPlaneSpeed = FALSE
|
|
bAllowFlyHigh = FALSE
|
|
bEnforceFlyLow = FALSE
|
|
bShownFlyLowHelp = FALSE
|
|
bDoneComeInSpeech = FALSE
|
|
bDoneFlyLowSpeech = FALSE
|
|
//bDoneFlyLowSpeech2 = FALSE
|
|
bShownTooHighHelp = FALSE
|
|
bDoneTooHighSpeech = FALSE
|
|
bDoneTooHighUrgentSpeech = FALSE
|
|
bDoOnItSpeech = FALSE
|
|
bIncrementedTooHigh = FALSE
|
|
bKilledSpeechForJets = FALSE
|
|
bKilledSpeechForTooHigh = FALSE
|
|
bKilledSpeechForBase = FALSE
|
|
bShownBaseHelp = FALSE
|
|
bDoneBaseSpeech = FALSE
|
|
bDoneOverBaseSpeech = FALSE
|
|
bDoneIgnoreRonSpeech = FALSE
|
|
bKlaxonOn = FALSE
|
|
bStoppedForceSpeed = TRUE
|
|
bDoneTakeoffCue = FALSE
|
|
bDoneSpotPlaneCue = FALSE
|
|
bDoneSenseOfStyleCue = FALSE
|
|
bDoneOnToesCue = FALSE
|
|
bDoneStartClimbingCue = FALSE
|
|
bDoneIdentifyYourselfCue = FALSE
|
|
bPreparedCargoDoorsOpenCue = FALSE
|
|
bJetsScrambled = FALSE
|
|
bDoneJetsScrambledSpeech = FALSE
|
|
bDoneCargoPlaneAppearsAudioScene = FALSE
|
|
bDoneFocusAudioScene = FALSE
|
|
bBeenCloseToPlane = FALSE
|
|
bSentText = FALSE
|
|
BREAK
|
|
|
|
CASE STAGE_FOLLOW_PLANE_2
|
|
//planeInteriorStreamingStage = PLANE_INTERIOR_STREAMING_NOT_STARTED
|
|
//bShownFlyHighHelp = FALSE
|
|
//bDoneFlyHighSpeech = FALSE
|
|
//fDoorOpen = 0.0
|
|
//vRampMachineGunAttach = <<RAMP_MACHINE_GUN_ATTACH_X, RAMP_MACHINE_GUN_ATTACH_INIT_Y, RAMP_MACHINE_GUN_ATTACH_INIT_Z>>
|
|
//vRampRPGAttach = <<RAMP_RPG_ATTACH_X, RAMP_RPG_ATTACH_INIT_Y, RAMP_RPG_ATTACH_INIT_Z>>
|
|
//bDoneTannoyAnnouncement = FALSE
|
|
streamingStage = MISSION_STREAMING_STAGE_REQUEST
|
|
BREAK
|
|
|
|
CASE STAGE_FOLLOW_PLANE_3
|
|
streamingStage = MISSION_STREAMING_STAGE_REQUEST
|
|
planeInteriorStreamingStage = PLANE_INTERIOR_STREAMING_NOT_STARTED
|
|
bShownFlyHighHelp = FALSE
|
|
bDoneFlyHighSpeech = FALSE
|
|
bDoneHereWeGoSpeech = FALSE
|
|
vRampMachineGunAttach = <<RAMP_MACHINE_GUN_ATTACH_X, RAMP_MACHINE_GUN_ATTACH_INIT_Y, RAMP_MACHINE_GUN_ATTACH_INIT_Z>>
|
|
vRampRPGAttach = <<RAMP_RPG_ATTACH_X, RAMP_RPG_ATTACH_INIT_Y, RAMP_RPG_ATTACH_INIT_Z>>
|
|
BREAK
|
|
|
|
CASE STAGE_ENTER_PLANE
|
|
streamingStage = MISSION_STREAMING_STAGE_REQUEST
|
|
//fPlaneSpeed = CARGO_PLANE_SPEED
|
|
iRPGShot = 0
|
|
fDoorOpen = 0.0
|
|
fTurbulence = 1.0
|
|
vRampMachineGunAttach = <<RAMP_MACHINE_GUN_ATTACH_X, RAMP_MACHINE_GUN_ATTACH_END_Y, RAMP_MACHINE_GUN_ATTACH_END_Z>>
|
|
vRampRPGAttach = <<RAMP_RPG_ATTACH_X, RAMP_RPG_ATTACH_END_Y, RAMP_RPG_ATTACH_END_Z>>
|
|
vCachedOffsetFromPlane = <<0,0,0>>
|
|
bShownCrashHelp = FALSE
|
|
bDoneCrashSpeech = FALSE
|
|
bDoneTrevorReactToShootSpeech = FALSE
|
|
bMachineGunEnemyShooting = FALSE
|
|
bBeenInEnterVicinity = FALSE
|
|
bDoneTryAgainSpeech = FALSE
|
|
bDoneCollisionSpeech = FALSE
|
|
// bDoneEnemyPlaneReactSpeech = FALSE
|
|
bStoppedPlayback = FALSE
|
|
bPreparedLandInPlaneCue = FALSE
|
|
bDoneLandInPlaneCue = FALSE
|
|
bEnemiesAttachedToRamp = FALSE
|
|
bDoneTannoyAnnouncement = FALSE
|
|
bDoneWarningAudioScene = FALSE
|
|
bStoppedWarningAudioScene = FALSE
|
|
bDoneCloseToCitySpeech = FALSE
|
|
bCreatedLightRig = FALSE
|
|
bTakePlaneDamage = FALSE
|
|
bLoadedWindStream = FALSE
|
|
bPlayingWindStream = FALSE
|
|
bDamagedPlaneToGlideDown = FALSE
|
|
bClearedForGlideDownChecks = FALSE
|
|
bShownGlideHelp = FALSE
|
|
bSetupInsidePlaneDuringCutscene = FALSE
|
|
bPopulatedInteriorDuringCutscene = FALSE
|
|
bSetNoTurbulence = FALSE
|
|
bForceIntoPlaneWhenCutsceneLoaded = FALSE
|
|
iEnemyShootingTime = -1
|
|
iForceSkipToNextStageTime = -1
|
|
iDoorStartOpenTime = -1
|
|
|
|
#IF IS_DEBUG_BUILD
|
|
bDebugForceIntoHold = FALSE
|
|
#ENDIF
|
|
BREAK
|
|
|
|
CASE STAGE_PLANE_FIGHT
|
|
ladderState = LADDER_STATE_NOT_ON
|
|
iFlightIntensityStage = 0
|
|
iNextSubstageUpdateTime = 0
|
|
iFlightSubstage = 0
|
|
iKilledEnemies = 0
|
|
iDodgeReactCount = 0
|
|
iDodgeEntity = -1
|
|
bRestoredControl = FALSE
|
|
bDoingGotoSubstage = FALSE
|
|
bDoneOutOfPlane = FALSE
|
|
bDoneTannoyAnnouncement = FALSE
|
|
//bForcedDuck = FALSE
|
|
bDoneClouds = FALSE
|
|
bSetTransportedVehiclesPhysical = FALSE
|
|
//bDetachedCropDuster = FALSE
|
|
bKlaxonOn = FALSE
|
|
bSetAccuracy = FALSE
|
|
//bShownLadderPrompt = FALSE
|
|
// bResetDeathProofs = FALSE
|
|
bDoneGotoCockpitPrompt = FALSE
|
|
bDoneFlashlightHelp = FALSE
|
|
// bAttachedVehiclesInCut = FALSE
|
|
bBlippedCrew = FALSE
|
|
bCrewShoot = FALSE
|
|
bDoneCrewSpeech = FALSE
|
|
//bShownKillCrewPrompt = FALSE
|
|
bOffLadder = FALSE
|
|
bAddedCockpitCover = FALSE
|
|
bCanUseControls = FALSE
|
|
bDoneUseControlsPrompt = FALSE
|
|
bDonePilotDeadSpeech = FALSE
|
|
bDoneTurbulenceSpeech = FALSE
|
|
bDoneGotoCockpitCue = FALSE
|
|
bDoneUseControlsCue = FALSE
|
|
bLoadedWindStream = FALSE
|
|
bPlayingWindStream = FALSE
|
|
bDonePitchDown = FALSE
|
|
bClearedEnemiesFromHold = FALSE
|
|
bSetPilotAttack = FALSE
|
|
bAllowUseControls = FALSE
|
|
bForceUseControls = FALSE
|
|
bMovedPlayer = FALSE
|
|
bShownControlsHelp = FALSE
|
|
bChangedPilotSpeaker = FALSE
|
|
|
|
bSetMerryweatherSpeaker1 = FALSE
|
|
bSetMerryweatherSpeaker2 = FALSE
|
|
bDoneMerryweatherCombatSpeech1 = FALSE
|
|
bDoneMerryweatherCombatSpeech2 = FALSE
|
|
bDoneMerryweatherCombatSpeech3 = FALSE
|
|
iMerryweatherSpeaker1 = -1
|
|
iMerryweatherSpeaker2 = -1
|
|
|
|
//bOnLadderForCam = FALSE
|
|
fProportionUpPlane = 1.0
|
|
//iTruckCheck = 0
|
|
//bShownLadderHelp = FALSE
|
|
#IF IS_DEBUG_BUILD
|
|
bDebugForceUseControls = FALSE
|
|
#ENDIF
|
|
BREAK
|
|
|
|
CASE STAGE_FLY_PLANE
|
|
|
|
REPEAT NUMBER_MISSILES i
|
|
jetMissile[i].state = JET_MISSILE_STATE_NOT_LAUNCHED
|
|
ENDREPEAT
|
|
flyPlaneState = FLY_PLANE_FINE
|
|
jetFlyAlongsideState = JET_FLY_ALONGSIDE_POSITION_BEHIND
|
|
jetAttackState = JET_ATTACK_NOT_CREATED
|
|
shapeTestState = SHAPE_TEST_STATE_NOT_STARTED
|
|
bDoneTurnOffAlarmSpeech = FALSE
|
|
bTurnedOffAlarm = FALSE
|
|
bDoneHailRonSpeech = FALSE
|
|
bDoneRonHailedSpeech = FALSE
|
|
bDoneChangeFreqSpeech = FALSE
|
|
bDoneInPlaneSpeech = FALSE
|
|
bDoneBearingSpeech = FALSE
|
|
bDoneWaveDownCutscene = FALSE
|
|
bDoneWaveDownSpeech = FALSE
|
|
bDoneTrevorGestureSpeech = FALSE
|
|
bCutOutControl = FALSE
|
|
bShownTurnHelp = FALSE
|
|
bDoneSeeJetSpeech = FALSE
|
|
bDoneJetWarning1Speech = FALSE
|
|
bDoneSplashSpeech = FALSE
|
|
bDoneFireMissileSpeech = FALSE
|
|
bDoneSplashSpeech2 = FALSE
|
|
bCancelledSplashSpeech = FALSE
|
|
bDoneFireMissileSpeech2 = FALSE
|
|
bDoneEngineBlowSpeech = FALSE
|
|
bDoneRearExplosionSpeech = FALSE
|
|
bDoneJetReactSpeech = FALSE
|
|
bDoneRonShakeJetsSpeech = FALSE
|
|
bDoneTrevorShakeJetsSpeech = FALSE
|
|
bDoneShootDownReactSpeech = FALSE
|
|
bDoneRonResponseToShootdownSpeech = FALSE
|
|
bDoneFindParachuteSpeech = FALSE
|
|
bDoneGotParachuteSpeech = FALSE
|
|
bForceClimb = FALSE
|
|
bShownClimbText = FALSE
|
|
bShownJetCamHelp = FALSE
|
|
bUsingJetCam = FALSE
|
|
bStoppedForceSpeed = FALSE
|
|
bDoneRudderFallOff = FALSE
|
|
bDoneSeeJetCue = FALSE
|
|
bDoneJetAlongsideCue = FALSE
|
|
bDoneMissileExplodeCue = FALSE
|
|
bLoadedFlybyStream = FALSE
|
|
bPlayedFlybyStream = FALSE
|
|
bDoneSeeJetAudioScene = FALSE
|
|
bJetAlongsideCabin = FALSE
|
|
bResetPlaneBreak = FALSE
|
|
bStartExplodeCounter = FALSE
|
|
//bDoneSwearOnWayDownSpeech = FALSE
|
|
bStoppedDebrisAtBack = FALSE
|
|
bResetSpeechFlag = FALSE
|
|
bStoppedRocketsScene = FALSE
|
|
|
|
fExplodeCounter = 0
|
|
|
|
//bShownObeyJetHelp = FALSE
|
|
fJetFlyAlongsideTimer = 0.0
|
|
iJetWarningSpeech = 0
|
|
iStopForceSpeedTime = GET_GAME_TIMER() + 400
|
|
vJetAttach = <<-19, 20.7, 3.0>>//<<-19, 25.7, 1.4>>//<<-11, 25.7, 1.4>>
|
|
BREAK
|
|
|
|
CASE STAGE_ESCAPE_PLANE
|
|
planeFallingState = PLANE_FALLING_ON_RECORDING
|
|
iDodgeEntity = -1
|
|
fSafetyTimer = 0.0
|
|
bKlaxonOn = FALSE
|
|
bRestoredControl = FALSE
|
|
//bAllowDestruction = FALSE
|
|
bAllowBike = FALSE
|
|
bSetTransportedVehiclesPhysical = FALSE
|
|
//bDoneLeaveBikePrompt = FALSE
|
|
//bDoneForceOffBike = FALSE
|
|
bDoneOutOfPlane = FALSE
|
|
bDoneEscapeSpeech = FALSE
|
|
bDoneParachutePrompt = FALSE
|
|
bShownFreeFallHelp = FALSE
|
|
bShownParachuteHelp = FALSE
|
|
bShownParachuteHelp2 = FALSE
|
|
bShownParachuteHelp3 = FALSE
|
|
bShownParachuteFocusHelp = FALSE
|
|
bAtSafety = FALSE
|
|
bCheckedPerfectLanding = FALSE
|
|
bShownInWaterPrompt = FALSE
|
|
bDonePhoneCall = FALSE
|
|
bUsedParachute = FALSE
|
|
bTriggeredJumpToParachute = FALSE
|
|
bClearedParachuteAnim = FALSE
|
|
//bRemovedParachuteBackpack = FALSE
|
|
bDoneExplodePlaneVFX = FALSE
|
|
bPreparedJumpCue = FALSE
|
|
bDoneJumpCue = FALSE
|
|
bDoneLandedCue = FALSE
|
|
bStartedFreefallTimer = FALSE
|
|
bStoppedFreefallTimer = FALSE
|
|
bClearedLightRig = FALSE
|
|
bDoneSpewSmokeOnEscape = FALSE
|
|
//bStoppedDustCloud = FALSE
|
|
bLoadedCrashStream = FALSE
|
|
bPlayingCrashStream = FALSE
|
|
bLoadedWindStream = FALSE
|
|
bPlayingWindStream = FALSE
|
|
bStoppedWindStream = FALSE
|
|
bDoneCarEscapeAudioScene = FALSE
|
|
bDoneFocusOnCrashingPlaneAudioScene = FALSE
|
|
bStoppedDeployParachuteAudioScene = FALSE
|
|
bOffLadder = FALSE
|
|
bSetDampingOn4wd = FALSE
|
|
bSetPack = FALSE
|
|
bDoneCarFallSound = FALSE
|
|
bStoppedCarFallSound = FALSE
|
|
bInCarCollisionProof = FALSE
|
|
fProportionUpPlane = 0.0
|
|
fVehicleDamping = 0.0027//0.00072
|
|
fTimeAtHatch = -1.0
|
|
iOpenedParachuteTime = -1
|
|
BREAK
|
|
ENDSWITCH
|
|
ENDPROC
|
|
|
|
// reset the flight target data
|
|
PROC RESET_FLIGHT_TARGET_DATA_FOR_STAGE(MISSION_STAGE_ENUM resetStage)
|
|
SWITCH resetStage
|
|
CASE STAGE_PLANE_FIGHT
|
|
flightTargetData.fRollTarget = 0.0
|
|
flightTargetData.fPitchTarget = 11.5
|
|
BREAK
|
|
CASE STAGE_ESCAPE_PLANE
|
|
flightTargetData.fRollTarget = 0.0
|
|
flightTargetData.fPitchTarget = 0.0//-20.0
|
|
BREAK
|
|
ENDSWITCH
|
|
ENDPROC
|
|
|
|
// reset the movement data
|
|
PROC RESET_PLANE_MOVEMENT_DATA_FROM_TARGET_DATA()
|
|
planeMovementData.vRot = <<flightTargetData.fPitchTarget, flightTargetData.fRollTarget, 0>>
|
|
planeMovementData.fRollSpeed = 0.0
|
|
planeMovementData.fPitchSpeed = 0.0
|
|
ENDPROC
|
|
|
|
// get plane offset for cargo positioning
|
|
FUNC VECTOR GET_PLANE_OFFSET_IN_WORLD_COORDS(VECTOR vOffset)
|
|
IF IS_VEHICLE_DRIVEABLE(planeFightVehicle[PFV_CARGO_PLANE])
|
|
RETURN GET_OFFSET_FROM_ENTITY_IN_WORLD_COORDS(planeFightVehicle[PFV_CARGO_PLANE], vOffset)
|
|
ENDIF
|
|
|
|
#IF IS_DEBUG_BUILD
|
|
SCRIPT_ASSERT("trying to get a plane offset but the plane does not exist")
|
|
#ENDIF
|
|
RETURN <<0,0,0>>
|
|
ENDFUNC
|
|
|
|
// return the correct character to start a particular stage on
|
|
FUNC enumCharacterList GET_CHARACTER_FOR_MISSION_STAGE(MISSION_STAGE_ENUM getStage)
|
|
getStage = getStage
|
|
|
|
RETURN CHAR_TREVOR
|
|
ENDFUNC
|
|
|
|
// set light rig
|
|
PROC SET_LIGHT_RIG_ON_CARGO_PLANE(BOOL bSet)
|
|
|
|
IF IS_VEHICLE_DRIVEABLE(planeFightVehicle[PFV_CARGO_PLANE])
|
|
IF bSet
|
|
DISABLE_VEHCILE_DYNAMIC_AMBIENT_SCALES(planeFightVehicle[PFV_CARGO_PLANE], 0, 255)
|
|
IF NOT DOES_ENTITY_EXIST(lightRigObject)
|
|
lightRigObject = CREATE_OBJECT(GET_MODEL_FOR_PLANE_FIGHT_MODEL_ENUM(PFM_LIGHT_RIG), GET_ENTITY_COORDS(planeFightVehicle[PFV_CARGO_PLANE]))
|
|
SET_ENTITY_COORDS(lightRigObject, GET_ENTITY_COORDS(planeFightVehicle[PFV_CARGO_PLANE]))
|
|
SET_ENTITY_ROTATION(lightRigObject, GET_ENTITY_ROTATION(planeFightVehicle[PFV_CARGO_PLANE]))
|
|
FREEZE_ENTITY_POSITION(lightRigObject, TRUE)
|
|
SET_ENTITY_COLLISION(lightRigObject, FALSE)
|
|
ENDIF
|
|
|
|
/*
|
|
IF NOT DOES_ENTITY_EXIST(reflectRigObject)
|
|
reflectRigObject = CREATE_OBJECT(GET_MODEL_FOR_PLANE_FIGHT_MODEL_ENUM(PFM_REFLECT_RIG), GET_ENTITY_COORDS(planeFightVehicle[PFV_CARGO_PLANE]))
|
|
SET_ENTITY_COORDS(reflectRigObject, GET_ENTITY_COORDS(planeFightVehicle[PFV_CARGO_PLANE]))
|
|
SET_ENTITY_ROTATION(reflectRigObject, GET_ENTITY_ROTATION(planeFightVehicle[PFV_CARGO_PLANE]))
|
|
FREEZE_ENTITY_POSITION(reflectRigObject, TRUE)
|
|
SET_ENTITY_COLLISION(reflectRigObject, FALSE)
|
|
ENDIF
|
|
*/
|
|
ELSE
|
|
ENABLE_VEHICLE_DYNAMIC_AMBIENT_SCALES(planeFightVehicle[PFV_CARGO_PLANE])
|
|
IF DOES_ENTITY_EXIST(lightRigObject)
|
|
DELETE_OBJECT(lightRigObject)
|
|
ENDIF
|
|
//IF DOES_ENTITY_EXIST(reflectRigObject)
|
|
// DELETE_OBJECT(reflectRigObject)
|
|
// ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDPROC
|
|
|
|
// set fake light rig
|
|
PROC SET_FAKE_LIGHT_RIG_ON_CARGO_PLANE()
|
|
IF IS_VEHICLE_DRIVEABLE(fakePlaneVehicle)
|
|
DISABLE_VEHCILE_DYNAMIC_AMBIENT_SCALES(fakePlaneVehicle, 0, 255)
|
|
IF NOT DOES_ENTITY_EXIST(fakeLightRigObject)
|
|
fakeLightRigObject = CREATE_OBJECT(GET_MODEL_FOR_PLANE_FIGHT_MODEL_ENUM(PFM_LIGHT_RIG), GET_ENTITY_COORDS(fakePlaneVehicle))
|
|
SET_ENTITY_COORDS(fakeLightRigObject, GET_ENTITY_COORDS(fakePlaneVehicle))
|
|
SET_ENTITY_ROTATION(fakeLightRigObject, GET_ENTITY_ROTATION(fakePlaneVehicle))
|
|
FREEZE_ENTITY_POSITION(fakeLightRigObject, TRUE)
|
|
SET_ENTITY_COLLISION(fakeLightRigObject, FALSE)
|
|
ENDIF
|
|
|
|
/*
|
|
IF NOT DOES_ENTITY_EXIST(fakeReflectRigObject)
|
|
fakeReflectRigObject = CREATE_OBJECT(GET_MODEL_FOR_PLANE_FIGHT_MODEL_ENUM(PFM_REFLECT_RIG), GET_ENTITY_COORDS(fakePlaneVehicle))
|
|
SET_ENTITY_COORDS(fakeReflectRigObject, GET_ENTITY_COORDS(fakePlaneVehicle))
|
|
SET_ENTITY_ROTATION(fakeReflectRigObject, GET_ENTITY_ROTATION(fakePlaneVehicle))
|
|
FREEZE_ENTITY_POSITION(fakeReflectRigObject, TRUE)
|
|
SET_ENTITY_COLLISION(fakeReflectRigObject, FALSE)
|
|
ENDIF
|
|
*/
|
|
ENDIF
|
|
ENDPROC
|
|
|
|
// update cargo plane light rig
|
|
PROC UPDATE_CARGO_PLANE_LIGHT_RIG()
|
|
IF DOES_ENTITY_EXIST(lightRigObject)
|
|
//AND DOES_ENTITY_EXIST(reflectRigObject)
|
|
AND IS_VEHICLE_DRIVEABLE(planeFightVehicle[PFV_CARGO_PLANE])
|
|
|
|
SET_ENTITY_COORDS(lightRigObject, GET_ENTITY_COORDS(planeFightVehicle[PFV_CARGO_PLANE]))
|
|
SET_ENTITY_ROTATION(lightRigObject, GET_ENTITY_ROTATION(planeFightVehicle[PFV_CARGO_PLANE]))
|
|
FREEZE_ENTITY_POSITION(lightRigObject, TRUE)
|
|
|
|
//SET_ENTITY_COORDS(reflectRigObject, GET_ENTITY_COORDS(planeFightVehicle[PFV_CARGO_PLANE]))
|
|
//SET_ENTITY_ROTATION(reflectRigObject, GET_ENTITY_ROTATION(planeFightVehicle[PFV_CARGO_PLANE]))
|
|
//FREEZE_ENTITY_POSITION(reflectRigObject, TRUE)
|
|
|
|
//printstring("updating") printnl()
|
|
ENDIF
|
|
ENDPROC
|
|
|
|
// setup the variations on an enemy ped
|
|
PROC SET_ENEMY_VARIATIONS(INT iPed, BOOL bIsNamed)
|
|
PED_INDEX ped
|
|
IF bIsNamed
|
|
ped = namedEnemyPed[iPed]
|
|
ELSE
|
|
ped = enemyData[iPed].ped
|
|
ENDIF
|
|
|
|
IF NOT IS_PED_INJURED(ped)
|
|
INT iHairVar
|
|
INT iHeadVar
|
|
INT iHeadTex
|
|
INT iTorsoVar
|
|
INT iTorsoTex
|
|
INT iLegTex
|
|
INT iAccVar
|
|
INT iAccTex
|
|
INT iShadesVar = -1
|
|
INT iShadesTex = -1
|
|
INT iHatVar = -1
|
|
INT iHatTex = -1
|
|
|
|
IF bIsNamed
|
|
SWITCH INT_TO_ENUM(NAMED_ENEMY_PED_ENUM, iPed)
|
|
CASE ENEMY_PILOT
|
|
iHairVar = 0
|
|
iHeadVar = 1
|
|
iHeadTex = 1
|
|
iTorsoVar = 0
|
|
iTorsoTex = 1
|
|
iLegTex = 0
|
|
iAccVar = 0
|
|
iAccTex = 0
|
|
iShadesVar = 0
|
|
iShadesTex = 0
|
|
BREAK
|
|
/*
|
|
CASE ENEMY_COPILOT
|
|
iHairVar = 1
|
|
iHeadVar = 1
|
|
iHeadTex = 2
|
|
iTorsoVar = 1
|
|
iTorsoTex = 3
|
|
iLegTex = 0
|
|
iAccVar = 1
|
|
iAccTex = 0
|
|
iShadesVar = 0
|
|
iShadesTex = 0
|
|
BREAK
|
|
*/
|
|
CASE ENEMY_RAMP_RPG
|
|
iHairVar = 0
|
|
iHeadVar = 1
|
|
iHeadTex = 2
|
|
iTorsoVar = 0
|
|
iTorsoTex = 4
|
|
iLegTex = 0
|
|
iAccVar = 0
|
|
iAccTex = 0
|
|
iShadesVar = 0
|
|
iShadesTex = 1
|
|
BREAK
|
|
CASE ENEMY_RAMP_MACHINE_GUN
|
|
iHairVar = 1
|
|
iHeadVar = 0
|
|
iHeadTex = 1
|
|
iTorsoVar = 1
|
|
iTorsoTex = 2
|
|
iLegTex = 2
|
|
iAccVar = 1
|
|
iAccTex = 0
|
|
iHatVar = 0
|
|
iHatTex = 0
|
|
BREAK
|
|
ENDSWITCH
|
|
ELSE
|
|
SWITCH iPed
|
|
// remember to change these vars if the cutscene var does
|
|
CASE 0
|
|
iHairVar = 1
|
|
iHeadVar = 0
|
|
iHeadTex = 0
|
|
iTorsoVar = 1
|
|
iTorsoTex = 0
|
|
iLegTex = 0
|
|
iAccVar = 0
|
|
iAccTex = 2
|
|
iHatVar = 0
|
|
iHatTex = 1
|
|
BREAK
|
|
CASE 1
|
|
iHairVar = 0
|
|
iHeadVar = 1
|
|
iHeadTex = 0
|
|
iTorsoVar = 0
|
|
iTorsoTex = 5
|
|
iLegTex = 2
|
|
iAccVar = 0
|
|
iAccTex = 1
|
|
BREAK
|
|
CASE 2
|
|
iHairVar = 0
|
|
iHeadVar = 0
|
|
iHeadTex = 2
|
|
iTorsoVar = 0
|
|
iTorsoTex = 1
|
|
iLegTex = 1
|
|
iAccVar = 1
|
|
iAccTex = 0
|
|
iShadesVar = 0
|
|
iShadesTex = 0
|
|
iHatVar = 1
|
|
iHatTex = 0
|
|
BREAK
|
|
CASE 3
|
|
iHairVar = 1
|
|
iHeadVar = 1
|
|
iHeadTex = 0
|
|
iTorsoVar = 0
|
|
iTorsoTex = 4
|
|
iLegTex = 0
|
|
iAccVar = 0
|
|
iAccTex = 0
|
|
BREAK
|
|
CASE 4
|
|
iHairVar = 1
|
|
iHeadVar = 1
|
|
iHeadTex = 1
|
|
iTorsoVar = 1
|
|
iTorsoTex = 4
|
|
iLegTex = 1
|
|
iAccVar = 0
|
|
iAccTex = 2
|
|
iHatVar = 0
|
|
iHatTex = 0
|
|
BREAK
|
|
CASE 5
|
|
iHairVar = 0
|
|
iHeadVar = 0
|
|
iHeadTex = 0
|
|
iTorsoVar = 1
|
|
iTorsoTex = 2
|
|
iLegTex = 2
|
|
iAccVar = 0
|
|
iAccTex = 0
|
|
iHatVar = 0
|
|
iHatTex = 2
|
|
BREAK
|
|
CASE 6
|
|
iHairVar = 1
|
|
iHeadVar = 0
|
|
iHeadTex = 1
|
|
iTorsoVar = 1
|
|
iTorsoTex = 1
|
|
iLegTex = 2
|
|
iAccVar = 0
|
|
iAccTex = 2
|
|
BREAK
|
|
CASE 7
|
|
iHairVar = 1
|
|
iHeadVar = 1
|
|
iHeadTex = 2
|
|
iTorsoVar = 1
|
|
iTorsoTex = 3
|
|
iLegTex = 0
|
|
iAccVar = 1
|
|
iAccTex = 0
|
|
iShadesVar = 0
|
|
iShadesTex = 0
|
|
BREAK
|
|
ENDSWITCH
|
|
ENDIF
|
|
|
|
SET_PED_COMPONENT_VARIATION(ped, PED_COMP_HAIR, iHairVar, 0)
|
|
SET_PED_COMPONENT_VARIATION(ped, PED_COMP_HEAD, iHeadVar, iHeadTex)
|
|
SET_PED_COMPONENT_VARIATION(ped, PED_COMP_TORSO, iTorsoVar, iTorsoTex)
|
|
SET_PED_COMPONENT_VARIATION(ped, PED_COMP_LEG, 0, iLegTex)
|
|
SET_PED_COMPONENT_VARIATION(ped, PED_COMP_SPECIAL, iAccVar, iAccTex)
|
|
SET_PED_COMPONENT_VARIATION(ped, PED_COMP_SPECIAL2, 0, 0)
|
|
|
|
CLEAR_PED_PROP(ped, ANCHOR_EYES)
|
|
CLEAR_PED_PROP(ped, ANCHOR_HEAD)
|
|
IF iShadesVar >= 0
|
|
SET_PED_PROP_INDEX(ped, ANCHOR_EYES, iShadesVar, iShadesTex)
|
|
ENDIF
|
|
IF iHatVar >= 0
|
|
SET_PED_PROP_INDEX(ped, ANCHOR_HEAD, iHatVar, iHatTex)
|
|
ENDIF
|
|
ENDIF
|
|
|
|
ENDPROC
|
|
|
|
// create cargo plane crew
|
|
PROC CREATE_CARGO_PLANE_CREW()
|
|
INT i
|
|
IF IS_VEHICLE_DRIVEABLE(planeFightVehicle[PFV_CARGO_PLANE])
|
|
FOR i=ENEMY_PILOT TO ENEMY_PILOT//ENEMY_COPILOT
|
|
IF NOT DOES_ENTITY_EXIST(namedEnemyPed[i])
|
|
VEHICLE_SEAT seat
|
|
IF i=0
|
|
seat = VS_DRIVER
|
|
ELSE
|
|
seat = VS_FRONT_RIGHT
|
|
ENDIF
|
|
namedEnemyPed[i] = CREATE_PED_INSIDE_VEHICLE(planeFightVehicle[PFV_CARGO_PLANE], PEDTYPE_MISSION, GET_MODEL_FOR_PLANE_FIGHT_MODEL_ENUM(PFM_PILOT), seat)
|
|
SET_BLOCKING_OF_NON_TEMPORARY_EVENTS(namedEnemyPed[i], TRUE)
|
|
SET_PED_GET_OUT_UPSIDE_DOWN_VEHICLE(namedEnemyPed[i], FALSE)
|
|
SET_PED_DIES_WHEN_INJURED(namedEnemyPed[i], TRUE)
|
|
SET_ENTITY_ONLY_DAMAGED_BY_PLAYER(namedEnemyPed[i], TRUE)
|
|
SET_ENTITY_PROOFS(namedEnemyPed[i], TRUE, TRUE, TRUE, TRUE, TRUE)
|
|
SET_PED_KEEP_TASK(namedEnemyPed[i], TRUE)
|
|
SET_PED_CONFIG_FLAG(namedEnemyPed[i], PCF_DisableExplosionReactions, TRUE)
|
|
SET_PED_CONFIG_FLAG(namedEnemyPed[i], PCF_RunFromFiresAndExplosions, FALSE)
|
|
SET_PED_CONFIG_FLAG(namedEnemyPed[i], PCF_CanAttackNonWantedPlayerAsLaw, TRUE)
|
|
SET_PED_CONFIG_FLAG(namedEnemyPed[i], PCF_DisableHurt, TRUE)
|
|
SET_RAGDOLL_BLOCKING_FLAGS(namedEnemyPed[i], RBF_PLAYER_IMPACT)
|
|
SET_PED_PATH_CAN_USE_CLIMBOVERS(namedEnemyPed[i], FALSE)
|
|
INFORM_MISSION_STATS_OF_HEADSHOT_WATCH_ENTITY(namedEnemyPed[i])
|
|
SET_PED_RELATIONSHIP_GROUP_HASH(namedEnemyPed[i], enemyRelGroup)
|
|
SET_ENEMY_VARIATIONS(i, TRUE)
|
|
SET_PED_COMPONENT_VARIATION(namedEnemyPed[i], PED_COMP_DECL, 1, 0)
|
|
ENDIF
|
|
ENDFOR
|
|
ENDIF
|
|
ENDPROC
|
|
|
|
// set crew
|
|
PROC SET_CARGO_PLANE_CREW_OUT_OF_SEATS()
|
|
INT i
|
|
IF IS_VEHICLE_DRIVEABLE(planeFightVehicle[PFV_CARGO_PLANE])
|
|
FOR i=ENEMY_PILOT TO ENEMY_PILOT//ENEMY_COPILOT
|
|
IF NOT IS_PED_INJURED(namedEnemyPed[i])
|
|
VECTOR vOffset
|
|
SWITCH i
|
|
CASE 0
|
|
vOffset = <<0, 26.8826, 2.077 >>//<< -0.659288, 26.8826, 2.077 >>//<<0.526855, 27.3215, 1.99817>>
|
|
BREAK
|
|
CASE 1
|
|
vOffset = <<-0.710986, 27.1286, 1.99338>>
|
|
BREAK
|
|
ENDSWITCH
|
|
|
|
SET_ENTITY_PROOFS(namedEnemyPed[i], FALSE, FALSE, FALSE, FALSE, FALSE)
|
|
SET_ENTITY_COORDS_NO_OFFSET(namedEnemyPed[i], GET_PLANE_OFFSET_IN_WORLD_COORDS(vOffset))
|
|
SET_ENTITY_HEADING(namedEnemyPed[i], 0)
|
|
GIVE_WEAPON_TO_PED(namedEnemyPed[i], GET_PLANE_FIGHT_WEAPON_TYPE(PF_WEAPON_MERC_PISTOL), INFINITE_AMMO, TRUE)
|
|
TASK_AIM_GUN_AT_ENTITY(namedEnemyPed[i], PLAYER_PED_ID(), -1, TRUE)
|
|
ENDIF
|
|
ENDFOR
|
|
ENDIF
|
|
ENDPROC
|
|
|
|
// create ramp peds
|
|
PROC CREATE_RAMP_PEDS(BOOL bDoSyncScene)
|
|
INT i
|
|
// create the bad guys on ramp
|
|
IF bDoSyncScene
|
|
iSyncScene = CREATE_SYNCHRONIZED_SCENE(<<0,0,0>>, <<0,0,0>>)
|
|
ATTACH_SYNCHRONIZED_SCENE_TO_ENTITY(iSyncScene, planeFightVehicle[PFV_CARGO_PLANE], 0)
|
|
ENDIF
|
|
|
|
FOR i=ENEMY_RAMP_MACHINE_GUN TO ENEMY_RAMP_RPG
|
|
NAMED_ENEMY_PED_ENUM thisEnemy = INT_TO_ENUM(NAMED_ENEMY_PED_ENUM, i)
|
|
|
|
namedEnemyPed[i] = CREATE_PED(PEDTYPE_MISSION, GET_MODEL_FOR_PLANE_FIGHT_MODEL_ENUM(PFM_ENEMY), <<0,1,0>>)
|
|
SET_BLOCKING_OF_NON_TEMPORARY_EVENTS(namedEnemyPed[i], TRUE)
|
|
SET_PED_RELATIONSHIP_GROUP_HASH(namedEnemyPed[i], enemyRelGroup)
|
|
INFORM_MISSION_STATS_OF_HEADSHOT_WATCH_ENTITY(namedEnemyPed[i])
|
|
SET_PED_KEEP_TASK(namedEnemyPed[i], TRUE)
|
|
SET_PED_CONFIG_FLAG(namedEnemyPed[i], PCF_DisableExplosionReactions, TRUE)
|
|
SET_PED_CONFIG_FLAG(namedEnemyPed[i], PCF_RunFromFiresAndExplosions, FALSE)
|
|
SET_PED_CONFIG_FLAG(namedEnemyPed[i], PCF_CanAttackNonWantedPlayerAsLaw, TRUE)
|
|
SET_PED_CONFIG_FLAG(namedEnemyPed[i], PCF_DisableHurt, TRUE)
|
|
SET_PED_COMBAT_MOVEMENT(namedEnemyPed[i], CM_STATIONARY)
|
|
|
|
SET_ENEMY_VARIATIONS(i, TRUE)
|
|
SET_ENTITY_PROOFS(namedEnemyPed[i], TRUE, TRUE, TRUE, TRUE, TRUE)
|
|
SET_ENTITY_INVINCIBLE(namedEnemyPed[i], TRUE)
|
|
SET_ENTITY_CAN_BE_DAMAGED(namedEnemyPed[i], FALSE)
|
|
SET_PED_CAN_RAGDOLL(namedEnemyPed[i], FALSE)
|
|
WEAPON_TYPE weapon
|
|
STRING sAnim
|
|
SWITCH thisEnemy
|
|
CASE ENEMY_RAMP_MACHINE_GUN
|
|
weapon = GET_PLANE_FIGHT_WEAPON_TYPE(PF_WEAPON_MERC_LMG)
|
|
sAnim = "RampShooting_GUY2"
|
|
SET_PED_ACCURACY(namedEnemyPed[i], 7)
|
|
BREAK
|
|
CASE ENEMY_RAMP_RPG
|
|
weapon = GET_PLANE_FIGHT_WEAPON_TYPE(PF_WEAPON_MERC_RPG)
|
|
sAnim = "RampShooting_GUY1"
|
|
SET_PED_ACCURACY(namedEnemyPed[i], 100)
|
|
BREAK
|
|
ENDSWITCH
|
|
GIVE_WEAPON_TO_PED(namedEnemyPed[i], weapon, INFINITE_AMMO, TRUE)
|
|
IF bDoSyncScene
|
|
TASK_SYNCHRONIZED_SCENE(namedEnemyPed[i], iSyncScene, GET_PLANE_FIGHT_ANIM_DICT_AS_STRING(PF_ANIM_DICT_MISSION), sAnim, INSTANT_BLEND_IN, INSTANT_BLEND_OUT)
|
|
FORCE_PED_AI_AND_ANIMATION_UPDATE(namedEnemyPed[i])
|
|
ENDIF
|
|
|
|
IF thisEnemy=ENEMY_RAMP_MACHINE_GUN
|
|
ADD_PED_FOR_DIALOGUE(planeFightConversation, 6, NULL, "MERC1")
|
|
ENDIF
|
|
ENDFOR
|
|
ENDPROC
|
|
|
|
// attach peds to ramp
|
|
PROC ATTACH_RAMP_PEDS()
|
|
INT i
|
|
VECTOR vAttach
|
|
|
|
IF IS_VEHICLE_DRIVEABLE(planeFightVehicle[PFV_CARGO_PLANE])
|
|
FOR i=ENEMY_RAMP_MACHINE_GUN TO ENEMY_RAMP_RPG
|
|
IF NOT IS_PED_INJURED(namedEnemyPed[i])
|
|
SWITCH INT_TO_ENUM(NAMED_ENEMY_PED_ENUM, i)
|
|
CASE ENEMY_RAMP_MACHINE_GUN
|
|
vAttach = vRampMachineGunAttach
|
|
BREAK
|
|
CASE ENEMY_RAMP_RPG
|
|
vAttach = vRampRPGAttach
|
|
BREAK
|
|
ENDSWITCH
|
|
|
|
ATTACH_ENTITY_TO_ENTITY(namedEnemyPed[i], planeFightVehicle[PFV_CARGO_PLANE], 0, vAttach, <<0,0,180>>)
|
|
TASK_AIM_GUN_AT_ENTITY(namedEnemyPed[i], planeFightVehicle[PFV_TREVOR_PLANE], -1)
|
|
ENDIF
|
|
ENDFOR
|
|
ENDIF
|
|
ENDPROC
|
|
|
|
// plane engine
|
|
PROC SET_PLANE_ENGINE_ON(BOOL bOn)
|
|
IF bOn
|
|
IF IS_VEHICLE_DRIVEABLE(planeFightVehicle[PFV_CARGO_PLANE])
|
|
//PLAY_SOUND_FROM_ENTITY(iEngineSoundID, "PLANE", planeFightVehicle[PFV_CARGO_PLANE], "CARGO_PLANE")
|
|
ENDIF
|
|
ELSE
|
|
IF NOT HAS_SOUND_FINISHED(iEngineSoundID)
|
|
STOP_SOUND(iEngineSoundID)
|
|
ENDIF
|
|
ENDIF
|
|
ENDPROC
|
|
|
|
// plane damage
|
|
PROC APPLY_PLANE_DAMAGE()
|
|
IF IS_VEHICLE_DRIVEABLE(planeFightVehicle[PFV_CARGO_PLANE])
|
|
SET_VEHICLE_EXTRA(planeFightVehicle[PFV_CARGO_PLANE], 7, FALSE)
|
|
SET_VEHICLE_EXTRA(planeFightVehicle[PFV_CARGO_PLANE], 8, TRUE)
|
|
ENDIF
|
|
ENDPROC
|
|
|
|
// create plane root
|
|
PROC CREATE_PLANE_ROOT()
|
|
planeRootObject = CREATE_OBJECT(GET_MODEL_FOR_PLANE_FIGHT_MODEL_ENUM(PFM_PLANE_ROOT), <<0,2,4>>)
|
|
SET_ENTITY_COLLISION(planeRootObject, FALSE)
|
|
SET_ENTITY_VISIBLE(planeRootObject, FALSE)
|
|
ENDPROC
|
|
|
|
// update plane root
|
|
PROC UPDATE_PLANE_ROOT(VEHICLE_INDEX planeVehicle, FLOAT fHeightAboveGround)
|
|
SET_ENTITY_COORDS(planeRootObject, GET_ENTITY_COORDS(planeVehicle))
|
|
VECTOR vPlaneRotation = GET_ENTITY_ROTATION(planeVehicle)
|
|
IF jetAttackState > JET_ATTACK_NOT_CREATED
|
|
IF vPlaneRotation.y > 360
|
|
vPlaneRotation.y -= 360
|
|
ELIF vPlaneRotation.y < 0
|
|
vPlaneRotation.y += 360
|
|
ENDIF
|
|
|
|
// set the rotation ignoring roll, if roll is too extreme
|
|
IF (vPlaneRotation.y > 70
|
|
AND vPlaneRotation.y < 290)
|
|
OR jetAttackState < JET_ATTACK_ESCORT
|
|
vPlaneRotation.y = 0
|
|
ENDIF
|
|
|
|
// set the rotation ignoring pitch, if going to crash
|
|
IF (vPlaneRotation.x <= -10 AND fHeightAboveGround < 80)
|
|
OR fHeightAboveGround < 40
|
|
vPlaneRotation.x = 0
|
|
ENDIF
|
|
|
|
SET_ENTITY_ROTATION(planeRootObject, vPlaneRotation)
|
|
ELSE
|
|
SET_ENTITY_ROTATION(planeRootObject, <<0,0,vPlaneRotation.z>>)
|
|
ENDIF
|
|
ENDPROC
|
|
|
|
// get the plane height above ground
|
|
FUNC FLOAT GET_HEIGHT_ABOVE_GROUND(VEHICLE_INDEX planeVehicle, FLOAT &fGroundHeight)
|
|
FLOAT fHeightAboveGround
|
|
VECTOR vPlayerCoords = GET_ENTITY_COORDS(planeVehicle)
|
|
GET_GROUND_Z_FOR_3D_COORD(vPlayerCoords, fGroundHeight)
|
|
IF fGroundHeight < 0
|
|
fGroundHeight = 0
|
|
ENDIF
|
|
|
|
IF IS_ENTITY_IN_AREA(planeVehicle, <<-181.68785, 3545.77539, 62.87735>>, <<2463.76489, 4640.36670, 31.42104>>, FALSE, FALSE)
|
|
IF fGroundHeight < 30
|
|
fGroundHeight = 30
|
|
ENDIF
|
|
ENDIF
|
|
|
|
fHeightAboveGround = vPlayerCoords.z - fGroundHeight
|
|
IF fHeightAboveGround < 0
|
|
fHeightAboveGround *= -1
|
|
ENDIF
|
|
|
|
RETURN fHeightAboveGround
|
|
ENDFUNC
|
|
|
|
|
|
// create a player vehicle for the mission
|
|
PROC PLANE_FIGHT_CREATE_VEHICLE(PLANE_FIGHT_VEHICLE_ENUM pfVehicle, VECTOR vCreatePos, FLOAT fCreateRot, BOOL bKeepModel = TRUE, BOOL bKeepVehicle = TRUE, BOOL bMakeInvincible = FALSE)
|
|
IF NOT IS_VEHICLE_DRIVEABLE(planeFightVehicle[pfVehicle])
|
|
PLANE_FIGHT_MODEL_ENUM vehicleModelEnum = GET_MODEL_ENUM_FOR_PLANE_FIGHT_VEHICLE(pfVehicle)
|
|
|
|
// if using a specific player vehicle
|
|
IF pfVehicle = PFV_TREVOR_4WD
|
|
CREATE_PLAYER_VEHICLE(planeFightVehicle[pfVehicle], CHAR_TREVOR, vCreatePos, fCreateRot, FALSE)
|
|
ELSE
|
|
planeFightVehicle[pfVehicle] = CREATE_VEHICLE(GET_MODEL_FOR_PLANE_FIGHT_MODEL_ENUM(vehicleModelEnum), vCreatePos, fCreateRot)
|
|
ENDIF
|
|
|
|
SET_VEHICLE_ON_GROUND_PROPERLY(planeFightVehicle[pfVehicle])
|
|
|
|
IF NOT bKeepModel
|
|
CLEAR_MODEL_REQUEST(ENUM_TO_INT(vehicleModelEnum))
|
|
ENDIF
|
|
|
|
IF bMakeInvincible
|
|
SET_VEHICLE_CAN_BE_VISIBLY_DAMAGED(planeFightVehicle[pfVehicle], FALSE)
|
|
SET_VEHICLE_CAN_BREAK(planeFightVehicle[pfVehicle], FALSE)
|
|
SET_ENTITY_PROOFS(planeFightVehicle[pfVehicle], TRUE, TRUE, TRUE, TRUE, TRUE)
|
|
ENDIF
|
|
|
|
IF NOT bKeepVehicle
|
|
SET_VEHICLE_AS_NO_LONGER_NEEDED(planeFightVehicle[pfVehicle])
|
|
ENDIF
|
|
|
|
SET_VEHICLE_CAN_LEAK_OIL(planeFightVehicle[pfVehicle], FALSE)
|
|
SET_VEHICLE_CAN_LEAK_PETROL(planeFightVehicle[pfVehicle], FALSE)
|
|
SET_DISABLE_VEHICLE_PETROL_TANK_FIRES(planeFightVehicle[pfVehicle], TRUE)
|
|
|
|
SWITCH pfVehicle
|
|
CASE PFV_CARGO_PLANE
|
|
//SET_VEHICLE_DOOR_BROKEN(planeFightVehicle[pfVehicle], SC_DOOR_REAR_LEFT, TRUE)
|
|
SET_VEHICLE_IS_CONSIDERED_BY_PLAYER(planeFightVehicle[pfVehicle], FALSE)
|
|
SET_ENTITY_ONLY_DAMAGED_BY_PLAYER(planeFightVehicle[pfVehicle], TRUE)
|
|
SET_VEHICLE_PROVIDES_COVER(planeFightVehicle[pfVehicle], FALSE)
|
|
SET_ENTITY_PROOFS(planeFightVehicle[pfVehicle], TRUE, TRUE, TRUE, TRUE, TRUE)
|
|
SET_VEHICLE_DOORS_LOCKED(planeFightVehicle[pfVehicle], VEHICLELOCK_LOCKED)
|
|
SET_VEHICLE_CAN_BREAK(planeFightVehicle[pfVehicle], FALSE)
|
|
SET_VEHICLE_CAN_BE_VISIBLY_DAMAGED(planeFightVehicle[pfVehicle], FALSE)
|
|
SET_VEHICLE_ENGINE_CAN_DEGRADE(planeFightVehicle[pfVehicle], FALSE)
|
|
SET_ENTITY_SHOULD_FREEZE_WAITING_ON_COLLISION(planeFightVehicle[pfVehicle], FALSE)
|
|
SET_VEHICLE_EXPLODES_ON_HIGH_EXPLOSION_DAMAGE(planeFightVehicle[pfVehicle], FALSE)
|
|
SET_ENTITY_LOD_DIST(planeFightVehicle[pfVehicle], 6000)
|
|
SET_VEHICLE_KEEP_ENGINE_ON_WHEN_ABANDONED(planeFightVehicle[pfVehicle], TRUE)
|
|
SET_VEHICLE_ENGINE_ON(planeFightVehicle[pfVehicle], TRUE, TRUE)
|
|
//SET_VEHICLE_USES_LARGE_REAR_RAMP(planeFightVehicle[pfVehicle], TRUE)
|
|
SET_PLANE_ENGINE_ON(TRUE)
|
|
INT i
|
|
FOR i=2 TO 8
|
|
SET_VEHICLE_EXTRA(planeFightVehicle[pfVehicle], i, FALSE)
|
|
ENDFOR
|
|
SET_VEHICLE_EXTRA(planeFightVehicle[PFV_CARGO_PLANE], 7, TRUE)
|
|
|
|
CONTROL_LANDING_GEAR(planeFightVehicle[pfVehicle], LGC_RETRACT_INSTANT)
|
|
SET_VEHICLE_AS_RESTRICTED(planeFightVehicle[pfVehicle], 0)
|
|
BREAK
|
|
CASE PFV_TREVOR_PLANE
|
|
SET_VEHICLE_COLOUR_COMBINATION(planeFightVehicle[pfVehicle], 0)
|
|
SET_VEHICLE_ENGINE_CAN_DEGRADE(planeFightVehicle[pfVehicle], FALSE)
|
|
SET_ENTITY_HEALTH(planeFightVehicle[pfVehicle], 2000)
|
|
//SET_ENTITY_CAN_BE_DAMAGED_BY_RELATIONSHIP_GROUP(planeFightVehicle[pfVehicle], FALSE, enemyRelGroup)
|
|
//SET_ENTITY_ONLY_DAMAGED_BY_PLAYER(planeFightVehicle[pfVehicle], TRUE)
|
|
// temp
|
|
//SET_ENTITY_PROOFS(planeFightVehicle[pfVehicle], FALSE, TRUE, TRUE, FALSE, FALSE)
|
|
BREAK
|
|
ENDSWITCH
|
|
ENDIF
|
|
ENDPROC
|
|
|
|
// setup player character with their correct variations
|
|
PROC SETUP_PLAYER_CHARACTER_WITH_MISSION_VARIATIONS(PED_INDEX ped, enumCharacterList createChar, MISSION_STAGE_ENUM setStage)
|
|
setStage=setStage
|
|
IF NOT IS_PED_INJURED(ped)
|
|
SWITCH createChar
|
|
CASE CHAR_MICHAEL
|
|
BREAK
|
|
ENDSWITCH
|
|
ENDIF
|
|
ENDPROC
|
|
|
|
// create player character
|
|
PROC PLANE_FIGHT_CREATE_PLAYER_CHARACTER(enumCharacterList createChar, MISSION_STAGE_ENUM setStage, VECTOR vPos, FLOAT fRot, VEHICLE_INDEX veh = NULL, VEHICLE_SEAT seat = VS_DRIVER)
|
|
SELECTOR_SLOTS_ENUM selectorSlot = GET_SELECTOR_SLOT_FROM_PLAYER_PED_ENUM(createChar)
|
|
|
|
IF NOT DOES_ENTITY_EXIST(sSelectorPeds.pedID[selectorSlot])
|
|
IF NOT IS_ENTITY_DEAD(veh)
|
|
// create in vehicle
|
|
WHILE NOT(CREATE_PLAYER_PED_INSIDE_VEHICLE(sSelectorPeds.pedID[selectorSlot], createChar, veh, seat, FALSE))
|
|
WAIT(0)
|
|
ENDWHILE
|
|
ELSE
|
|
// create on foot
|
|
WHILE NOT(CREATE_PLAYER_PED_ON_FOOT(sSelectorPeds.pedID[selectorSlot], createChar, vPos, fRot, FALSE))
|
|
WAIT(0)
|
|
ENDWHILE
|
|
ENDIF
|
|
|
|
SWITCH createChar
|
|
CASE CHAR_MICHAEL
|
|
BREAK
|
|
CASE CHAR_FRANKLIN
|
|
BREAK
|
|
ENDSWITCH
|
|
|
|
SETUP_PLAYER_CHARACTER_WITH_MISSION_VARIATIONS(sSelectorPeds.pedID[selectorSlot], createChar, setStage)
|
|
SET_PED_RELATIONSHIP_GROUP_HASH(sSelectorPeds.pedID[selectorSlot], RELGROUPHASH_PLAYER)
|
|
SET_BLOCKING_OF_NON_TEMPORARY_EVENTS(sSelectorPeds.pedID[selectorSlot], TRUE)
|
|
ENDIF
|
|
ENDPROC
|
|
|
|
PROC ADD_CARGO_PLANE_TO_AUDIO_MIX_GROUP()
|
|
ADD_ENTITY_TO_AUDIO_MIX_GROUP(planeFightVehicle[PFV_CARGO_PLANE], "EXILE_1_CARGO_PLANE")
|
|
ENDPROC
|
|
|
|
// create the player characters, and transport if appropriate, for a mission stage
|
|
PROC CREATE_PLAYER_CHARACTERS_WITH_TRANSPORT_IN_MISSION_STAGE(MISSION_STAGE_ENUM setStage)
|
|
// create transport
|
|
SWITCH setStage
|
|
CASE STAGE_GET_TO_AIRSTRIP
|
|
PLANE_FIGHT_CREATE_VEHICLE(PFV_TREVOR_4WD, GET_PLANE_FIGHT_VECTOR(PFVEC_TREVOR_4WD_INIT), TREVOR_4WD_INIT_ROT)
|
|
//PLANE_FIGHT_CREATE_VEHICLE(PFV_TREVOR_PLANE, GET_PLANE_FIGHT_VECTOR(PFVEC_TREVOR_PLANE_INIT), TREVOR_PLANE_INIT_ROT)
|
|
BREAK
|
|
CASE STAGE_FOLLOW_PLANE_1
|
|
PLANE_FIGHT_CREATE_VEHICLE(PFV_CARGO_PLANE, GET_PLANE_FIGHT_VECTOR(PFVEC_CARGO_PLANE_INIT), 0.0)
|
|
ADD_CARGO_PLANE_TO_AUDIO_MIX_GROUP()
|
|
PLANE_FIGHT_CREATE_VEHICLE(PFV_TREVOR_PLANE, GET_PLANE_FIGHT_VECTOR(PFVEC_TREVOR_PLANE_INIT), TREVOR_PLANE_INIT_ROT)
|
|
BREAK
|
|
CASE STAGE_FOLLOW_PLANE_2
|
|
PLANE_FIGHT_CREATE_VEHICLE(PFV_CARGO_PLANE, GET_PLANE_FIGHT_VECTOR(PFVEC_CARGO_PLANE_INIT), 0.0)
|
|
ADD_CARGO_PLANE_TO_AUDIO_MIX_GROUP()
|
|
PLANE_FIGHT_CREATE_VEHICLE(PFV_TREVOR_PLANE, GET_PLANE_FIGHT_VECTOR(PFVEC_TREVOR_PLANE_MID_POINT), TREVOR_PLANE_MID_POINT_ROT)
|
|
BREAK
|
|
CASE STAGE_FOLLOW_PLANE_3
|
|
PLANE_FIGHT_CREATE_VEHICLE(PFV_CARGO_PLANE, GET_PLANE_FIGHT_VECTOR(PFVEC_CARGO_PLANE_INIT), 0.0)
|
|
ADD_CARGO_PLANE_TO_AUDIO_MIX_GROUP()
|
|
PLANE_FIGHT_CREATE_VEHICLE(PFV_TREVOR_PLANE, GET_PLANE_FIGHT_VECTOR(PFVEC_TREVOR_PLANE_CLIMB_POINT), TREVOR_PLANE_CLIMB_POINT_ROT)
|
|
BREAK
|
|
CASE STAGE_ENTER_PLANE
|
|
PLANE_FIGHT_CREATE_VEHICLE(PFV_CARGO_PLANE, GET_PLANE_FIGHT_VECTOR(PFVEC_CARGO_PLANE_INIT), 0.0)
|
|
ADD_CARGO_PLANE_TO_AUDIO_MIX_GROUP()
|
|
CREATE_CARGO_PLANE_CREW()
|
|
PLANE_FIGHT_CREATE_VEHICLE(PFV_TREVOR_PLANE, GET_PLANE_FIGHT_VECTOR(PFVEC_TREVOR_PLANE_ENTER_POINT), TREVOR_PLANE_ENTER_POINT_ROT)
|
|
BREAK
|
|
CASE STAGE_PLANE_FIGHT
|
|
PLANE_FIGHT_CREATE_VEHICLE(PFV_CARGO_PLANE, GET_PLANE_FIGHT_VECTOR(PFVEC_CARGO_PLANE_INIT), 0.0)
|
|
APPLY_PLANE_DAMAGE()
|
|
CREATE_CARGO_PLANE_CREW()
|
|
BREAK
|
|
CASE STAGE_FLY_PLANE
|
|
PLANE_FIGHT_CREATE_VEHICLE(PFV_CARGO_PLANE, GET_PLANE_FIGHT_VECTOR(PFVEC_CARGO_PLANE_FLY), CARGO_PLANE_FLY_ROT)
|
|
APPLY_PLANE_DAMAGE()
|
|
BREAK
|
|
CASE STAGE_ESCAPE_PLANE
|
|
PLANE_FIGHT_CREATE_VEHICLE(PFV_CARGO_PLANE, GET_PLANE_FIGHT_VECTOR(PFVEC_CARGO_PLANE_DESCEND), 0.0)
|
|
APPLY_PLANE_DAMAGE()
|
|
BREAK
|
|
ENDSWITCH
|
|
ENDPROC
|
|
|
|
// set ron at the car
|
|
PROC SET_RON_AT_CAR()
|
|
IF NOT IS_PED_INJURED(ronPed)
|
|
CLEAR_PED_TASKS_IMMEDIATELY(ronPed)
|
|
SET_ENTITY_COORDS(ronPed, GET_PLANE_FIGHT_VECTOR(PFVEC_RON_INIT))
|
|
SET_ENTITY_HEADING(ronPed, RON_INIT_ROT)
|
|
//FORCE_PED_MOTION_STATE(ronPed,MS_ON_FOOT_WALK,TRUE,FAUS_CUTSCENE_EXIT)
|
|
//SET_PED_MIN_MOVE_BLEND_RATIO(ronPed, PEDMOVE_WALK)
|
|
ENDIF
|
|
ENDPROC
|
|
|
|
// create Ron
|
|
PROC CREATE_RON_FOR_STAGE(MISSION_STAGE_ENUM createStage, BOOL bWaitForStreaming)
|
|
IF IS_PED_INJURED(ronPed)
|
|
VECTOR vPos
|
|
FLOAT fRot
|
|
|
|
SWITCH createStage
|
|
CASE STAGE_GET_TO_AIRSTRIP
|
|
vPos = GET_PLANE_FIGHT_VECTOR(PFVEC_RON_INIT)
|
|
fRot = RON_INIT_ROT
|
|
BREAK
|
|
CASE STAGE_FOLLOW_PLANE_1
|
|
vPos = GET_PLANE_FIGHT_VECTOR(PFVEC_RON_STAND)
|
|
fRot = RON_STAND_ROT
|
|
BREAK
|
|
ENDSWITCH
|
|
|
|
CREATE_NPC_PED_ON_FOOT(ronPed, CHAR_RON, vPos, fRot, FALSE)
|
|
|
|
IF bWaitForStreaming
|
|
LOAD_ALL_OBJECTS_IF_SCREEN_FADED_OUT()
|
|
|
|
BOOL bRonStreamingCompleted = FALSE
|
|
WHILE NOT bRonStreamingCompleted
|
|
IF NOT IS_PED_INJURED(ronPed)
|
|
IF HAVE_ALL_STREAMING_REQUESTS_COMPLETED(ronPed)
|
|
bRonStreamingCompleted = TRUE
|
|
ENDIF
|
|
ELSE
|
|
bRonStreamingCompleted = TRUE
|
|
ENDIF
|
|
WAIT(0)
|
|
ENDWHILE
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF NOT IS_PED_INJURED(ronPed)
|
|
SET_PED_PROP_INDEX(ronPed, ANCHOR_HEAD, 0)
|
|
SET_PED_PROP_INDEX(ronPed, ANCHOR_EYES, 0)
|
|
|
|
//SET_BLOCKING_OF_NON_TEMPORARY_EVENTS(ronPed, TRUE)
|
|
SET_PED_KEEP_TASK(ronPed, TRUE)
|
|
SET_PED_GROUP_MEMBER_PASSENGER_INDEX(ronPed, VS_FRONT_RIGHT)
|
|
SET_PED_CONFIG_FLAG(ronPed, PCF_ForcedToUseSpecificGroupSeatIndex, TRUE)
|
|
ADD_PED_FOR_DIALOGUE(planeFightConversation, 3, ronPed, "NervousRon")
|
|
SET_PED_RELATIONSHIP_GROUP_HASH(ronPed, RELGROUPHASH_PLAYER)
|
|
SET_PED_CAN_BE_TARGETTED(ronPed, FALSE)
|
|
SET_PED_DIES_WHEN_INJURED(ronPed, TRUE)
|
|
SET_PED_CONFIG_FLAG(ronPed, PCF_WillFlyThroughWindscreen, FALSE)
|
|
SET_PED_CONFIG_FLAG(ronPed, PCF_LawWillOnlyAttackIfPlayerIsWanted, TRUE)
|
|
SET_PED_CONFIG_FLAG(ronPed, PCF_OnlyAttackLawIfPlayerIsWanted, TRUE)
|
|
SET_ENTITY_ONLY_DAMAGED_BY_PLAYER(ronPed, TRUE)
|
|
|
|
SWITCH createStage
|
|
CASE STAGE_GET_TO_AIRSTRIP
|
|
// SET_PED_AS_GROUP_MEMBER(ronPed, PLAYER_GROUP_ID())
|
|
BREAK
|
|
CASE STAGE_FOLLOW_PLANE_1
|
|
//SET_BLOCKING_OF_NON_TEMPORARY_EVENTS(ronPed, TRUE)
|
|
BREAK
|
|
ENDSWITCH
|
|
ENDIF
|
|
ENDPROC
|
|
|
|
// cleanup ron
|
|
PROC CLEANUP_RON(BOOL bDelete = FALSE)
|
|
IF DOES_ENTITY_EXIST(ronPed)
|
|
IF bDelete
|
|
DELETE_PED(ronPed)
|
|
ELSE
|
|
SET_PED_AS_NO_LONGER_NEEDED(ronPed)
|
|
ENDIF
|
|
ENDIF
|
|
REMOVE_PED_FOR_DIALOGUE(planeFightConversation, 3)
|
|
CLEAR_MODEL_REQUEST(ENUM_TO_INT(PFM_RON))
|
|
ENDPROC
|
|
|
|
// create michael and patricia
|
|
PROC CREATE_MICHAEL_AND_PATRICIA(BOOL bWaitForStreaming)
|
|
IF DOES_ENTITY_EXIST(sSelectorPeds.pedID[SELECTOR_PED_MICHAEL])
|
|
DELETE_PED(sSelectorPeds.pedID[SELECTOR_PED_MICHAEL])
|
|
ENDIF
|
|
|
|
IF NOT DOES_ENTITY_EXIST(chairObject)
|
|
chairObject = CREATE_OBJECT_NO_OFFSET(GET_MODEL_FOR_PLANE_FIGHT_MODEL_ENUM(PFM_CHAIR), <<1976.806, 3819.159, 32.419>>)
|
|
SET_ENTITY_HEADING(chairObject, 124.33)
|
|
FREEZE_ENTITY_POSITION(chairObject, TRUE)
|
|
|
|
INTERIOR_INSTANCE_INDEX trailerInterior = GET_INTERIOR_AT_COORDS(<<1974, 3819, 34>>)
|
|
IF IS_VALID_INTERIOR(trailerInterior)
|
|
RETAIN_ENTITY_IN_INTERIOR(chairObject, trailerInterior)
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF NOT DOES_ENTITY_EXIST(michaelPed)
|
|
CREATE_PLAYER_PED_ON_FOOT(michaelPed, CHAR_MICHAEL, <<1974.07629, 3818.74487, 32.43633>>, 0, FALSE)
|
|
SET_PED_RELATIONSHIP_GROUP_HASH(michaelPed, RELGROUPHASH_PLAYER)
|
|
TASK_LOOK_AT_ENTITY(michaelPed, PLAYER_PED_ID(), -1, SLF_WHILE_NOT_IN_FOV)
|
|
iMichaelSyncScene = CREATE_SYNCHRONIZED_SCENE(<<1975.008,3821.327,33.426>>, <<0,0,-150.11>>)
|
|
TASK_SYNCHRONIZED_SCENE(michaelPed, iMichaelSyncScene, GET_PLANE_FIGHT_ANIM_DICT_AS_STRING(PF_ANIM_DICT_LEADOUT), "_LeadOut_Michael", INSTANT_BLEND_IN, NORMAL_BLEND_OUT, SYNCED_SCENE_USE_PHYSICS, RBF_PLAYER_IMPACT | RBF_MELEE)
|
|
FORCE_PED_AI_AND_ANIMATION_UPDATE(michaelPed)
|
|
SET_SYNCHRONIZED_SCENE_LOOPED(iMichaelSyncScene, TRUE)
|
|
SET_PED_COMP_ITEM_CURRENT_SP(michaelPed, COMP_TYPE_OUTFIT, OUTFIT_P0_DEFAULT, FALSE)
|
|
SET_PED_CONFIG_FLAG(michaelPed, PCF_RunFromFiresAndExplosions, FALSE)
|
|
SET_PED_CONFIG_FLAG(michaelPed, PCF_DisableExplosionReactions, TRUE)
|
|
|
|
CREATE_NPC_PED_ON_FOOT(patriciaPed, CHAR_PATRICIA, <<1974.07629, 3818.74487, 32.43633>>, 0, FALSE)
|
|
SET_PED_RELATIONSHIP_GROUP_HASH(patriciaPed, RELGROUPHASH_PLAYER)
|
|
TASK_LOOK_AT_ENTITY(patriciaPed, PLAYER_PED_ID(), -1, SLF_WHILE_NOT_IN_FOV)
|
|
iPatriciaSyncScene = CREATE_SYNCHRONIZED_SCENE(<<1976.700, 3819.085, 33.4576>>, <<0,0,-58.44>>)
|
|
TASK_SYNCHRONIZED_SCENE(patriciaPed, iPatriciaSyncScene, GET_PLANE_FIGHT_ANIM_DICT_AS_STRING(PF_ANIM_DICT_LEADOUT), "_LeadOut_Patricia", INSTANT_BLEND_IN, NORMAL_BLEND_OUT, SYNCED_SCENE_USE_PHYSICS, RBF_PLAYER_IMPACT | RBF_MELEE)
|
|
FORCE_PED_AI_AND_ANIMATION_UPDATE(patriciaPed)
|
|
SET_SYNCHRONIZED_SCENE_LOOPED(iPatriciaSyncScene, TRUE)
|
|
SET_PED_CONFIG_FLAG(patriciaPed, PCF_RunFromFiresAndExplosions, FALSE)
|
|
SET_PED_CONFIG_FLAG(patriciaPed, PCF_DisableExplosionReactions, TRUE)
|
|
|
|
IF bWaitForStreaming
|
|
LOAD_ALL_OBJECTS_IF_SCREEN_FADED_OUT()
|
|
|
|
BOOL bMichaelStreamingCompleted = FALSE
|
|
WHILE NOT bMichaelStreamingCompleted
|
|
IF NOT IS_PED_INJURED(michaelPed)
|
|
IF HAVE_ALL_STREAMING_REQUESTS_COMPLETED(michaelPed)
|
|
bMichaelStreamingCompleted = TRUE
|
|
ENDIF
|
|
ELSE
|
|
bMichaelStreamingCompleted = TRUE
|
|
ENDIF
|
|
WAIT(0)
|
|
ENDWHILE
|
|
ENDIF
|
|
ENDIF
|
|
IF NOT DOES_ENTITY_EXIST(patriciaPed)
|
|
CREATE_NPC_PED_ON_FOOT(patriciaPed, CHAR_PATRICIA, <<1975.19690, 3820.66187, 32.44597>>, 0, FALSE)
|
|
SET_PED_RELATIONSHIP_GROUP_HASH(patriciaPed, RELGROUPHASH_PLAYER)
|
|
|
|
IF bWaitForStreaming
|
|
LOAD_ALL_OBJECTS_IF_SCREEN_FADED_OUT()
|
|
|
|
BOOL bPatriciaStreamingCompleted = FALSE
|
|
WHILE NOT bPatriciaStreamingCompleted
|
|
IF NOT IS_PED_INJURED(patriciaPed)
|
|
IF HAVE_ALL_STREAMING_REQUESTS_COMPLETED(patriciaPed)
|
|
bPatriciaStreamingCompleted = TRUE
|
|
ENDIF
|
|
ELSE
|
|
bPatriciaStreamingCompleted = TRUE
|
|
ENDIF
|
|
WAIT(0)
|
|
ENDWHILE
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF NOT IS_PED_INJURED(michaelPed)
|
|
SET_PED_KEEP_TASK(michaelPed, TRUE)
|
|
SET_BLOCKING_OF_NON_TEMPORARY_EVENTS(michaelPed, TRUE)
|
|
SET_ENTITY_ONLY_DAMAGED_BY_PLAYER(michaelPed, TRUE)
|
|
ENDIF
|
|
|
|
IF NOT IS_PED_INJURED(patriciaPed)
|
|
SET_PED_KEEP_TASK(patriciaPed, TRUE)
|
|
SET_BLOCKING_OF_NON_TEMPORARY_EVENTS(patriciaPed, TRUE)
|
|
SET_ENTITY_ONLY_DAMAGED_BY_PLAYER(patriciaPed, TRUE)
|
|
ENDIF
|
|
ENDPROC
|
|
|
|
// cleanup michael and patricia
|
|
PROC CLEANUP_MICHAEL_AND_PATRICIA()
|
|
IF DOES_ENTITY_EXIST(chairObject)
|
|
DELETE_OBJECT(chairObject)
|
|
ENDIF
|
|
|
|
IF DOES_ENTITY_EXIST(michaelPed)
|
|
DELETE_PED(michaelPed)
|
|
ENDIF
|
|
|
|
IF DOES_ENTITY_EXIST(patriciaPed)
|
|
DELETE_PED(patriciaPed)
|
|
ENDIF
|
|
|
|
CLEAR_MODEL_REQUEST(ENUM_TO_INT(PFM_MICHAEL))
|
|
CLEAR_MODEL_REQUEST(ENUM_TO_INT(PFM_PATRICIA))
|
|
CLEAR_MODEL_REQUEST(ENUM_TO_INT(PFM_CHAIR))
|
|
|
|
CLEAR_ANIM_DICT_REQUEST(PF_ANIM_DICT_LEADOUT)
|
|
|
|
bCleanedUpMichaelAndPatricia = TRUE
|
|
ENDPROC
|
|
|
|
// get type of transported vehicle
|
|
FUNC TRANSPORTED_VEHICLE_TYPE_ENUM GET_TRANSPORTED_VEHICLE_TYPE(TRANSPORTED_VEHICLE_INDEX_ENUM vehicleIndex)
|
|
SWITCH vehicleIndex
|
|
CASE TRANSPORTED_VEHICLE_INDEX_4WD_SLIDE_OUT
|
|
CASE TRANSPORTED_VEHICLE_INDEX_4WD_L_1
|
|
CASE TRANSPORTED_VEHICLE_INDEX_4WD_L_2
|
|
CASE TRANSPORTED_VEHICLE_INDEX_4WD_L_3
|
|
CASE TRANSPORTED_VEHICLE_INDEX_4WD_L_4
|
|
CASE TRANSPORTED_VEHICLE_INDEX_4WD_DRIVE
|
|
RETURN TRANSPORTED_VEHICLE_TYPE_4WD
|
|
BREAK
|
|
CASE TRANSPORTED_VEHICLE_INDEX_4WD_R_1
|
|
CASE TRANSPORTED_VEHICLE_INDEX_4WD_R_2
|
|
//RETURN TRANSPORTED_VEHICLE_TYPE_VAN
|
|
RETURN TRANSPORTED_VEHICLE_TYPE_4WD
|
|
BREAK
|
|
ENDSWITCH
|
|
|
|
RETURN TRANSPORTED_VEHICLE_TYPE_4WD
|
|
ENDFUNC
|
|
|
|
// is this vehicle facing the door
|
|
FUNC BOOL IS_TRANSPORTED_VEHICLE_FACING_TOWARDS_DOOR(TRANSPORTED_VEHICLE_INDEX_ENUM vehicleIndex)
|
|
SWITCH vehicleIndex
|
|
CASE TRANSPORTED_VEHICLE_INDEX_4WD_L_1
|
|
CASE TRANSPORTED_VEHICLE_INDEX_4WD_L_2
|
|
CASE TRANSPORTED_VEHICLE_INDEX_4WD_R_1
|
|
CASE TRANSPORTED_VEHICLE_INDEX_4WD_DRIVE
|
|
RETURN TRUE
|
|
BREAK
|
|
CASE TRANSPORTED_VEHICLE_INDEX_4WD_SLIDE_OUT
|
|
CASE TRANSPORTED_VEHICLE_INDEX_4WD_L_3
|
|
CASE TRANSPORTED_VEHICLE_INDEX_4WD_L_4
|
|
CASE TRANSPORTED_VEHICLE_INDEX_4WD_R_2
|
|
RETURN FALSE
|
|
BREAK
|
|
ENDSWITCH
|
|
|
|
RETURN FALSE
|
|
ENDFUNC
|
|
|
|
// get init coords for transported vehicle
|
|
FUNC VECTOR GET_TRANSPORTED_VEHICLE_COORDS(TRANSPORTED_VEHICLE_INDEX_ENUM vehicleIndex, BOOL bReturnWorldCoords = TRUE)
|
|
FLOAT fXOffset
|
|
FLOAT fYOffset
|
|
|
|
SWITCH vehicleIndex
|
|
CASE TRANSPORTED_VEHICLE_INDEX_4WD_DRIVE
|
|
fXOffset = 1.6
|
|
fYOffset = 17.0
|
|
BREAK
|
|
CASE TRANSPORTED_VEHICLE_INDEX_4WD_SLIDE_OUT
|
|
fXOffset = 1.6
|
|
fYOffset = -14.5
|
|
BREAK
|
|
CASE TRANSPORTED_VEHICLE_INDEX_4WD_L_1
|
|
fXOffset = -1.6
|
|
fYOffset = -11.5
|
|
BREAK
|
|
CASE TRANSPORTED_VEHICLE_INDEX_4WD_L_2
|
|
fXOffset = -1.6
|
|
fYOffset = -6.0
|
|
BREAK
|
|
CASE TRANSPORTED_VEHICLE_INDEX_4WD_L_3
|
|
fXOffset = -1.6
|
|
fYOffset = 10.2
|
|
BREAK
|
|
CASE TRANSPORTED_VEHICLE_INDEX_4WD_L_4
|
|
fXOffset = -1.6
|
|
fYOffset = 15.6
|
|
BREAK
|
|
CASE TRANSPORTED_VEHICLE_INDEX_4WD_R_1
|
|
fXOffset = 1.6
|
|
fYOffset = 0.0
|
|
BREAK
|
|
CASE TRANSPORTED_VEHICLE_INDEX_4WD_R_2
|
|
fXOffset = 1.6
|
|
fYOffset = 12.0
|
|
BREAK
|
|
ENDSWITCH
|
|
|
|
FLOAT fZOffset
|
|
IF transportedVehicle[vehicleIndex].type = TRANSPORTED_VEHICLE_TYPE_VAN
|
|
fZOffset = VAN_ATTACH_Z
|
|
ELSE
|
|
fZOffset = FWD_ATTACH_Z
|
|
ENDIF
|
|
|
|
IF bReturnWorldCoords
|
|
RETURN GET_PLANE_OFFSET_IN_WORLD_COORDS(<<fXOffset, fYOffset, fZOffset>>)
|
|
ELSE
|
|
RETURN <<fXOffset, fYOffset, fZOffset>>
|
|
ENDIF
|
|
ENDFUNC
|
|
|
|
// attach transported vehicles to the plane
|
|
PROC ATTACH_TRANSPORTED_VEHICLES(BOOL bPhysicalAttach, BOOL bFake = FALSE)
|
|
INT i
|
|
|
|
IF NOT IS_ENTITY_DEAD(planeFightVehicle[PFV_CARGO_PLANE])
|
|
IF NOT bFake
|
|
REPEAT COUNT_OF(transportedVehicle) i
|
|
IF NOT transportedVehicle[i].bDetached
|
|
IF NOT IS_ENTITY_DEAD(transportedVehicle[i].veh)
|
|
TRANSPORTED_VEHICLE_INDEX_ENUM vehicleIndex = INT_TO_ENUM(TRANSPORTED_VEHICLE_INDEX_ENUM, i)
|
|
DETACH_ENTITY(transportedVehicle[i].veh)
|
|
|
|
IF vehicleIndex <> TRANSPORTED_VEHICLE_INDEX_4WD_DRIVE
|
|
SET_VEHICLE_REDUCE_GRIP(transportedVehicle[i].veh, FALSE)
|
|
ENDIF
|
|
|
|
FLOAT fRot
|
|
IF IS_TRANSPORTED_VEHICLE_FACING_TOWARDS_DOOR(vehicleIndex)
|
|
fRot = 180.0
|
|
ELSE
|
|
fRot = 0.0
|
|
ENDIF
|
|
|
|
IF bPhysicalAttach
|
|
//ATTACH_ENTITY_TO_ENTITY_PHYSICALLY(transportedVehicle[i].veh, planeFightVehicle[PFV_CARGO_PLANE], 0, 0, GET_TRANSPORTED_VEHICLE_COORDS(vehicleIndex, FALSE) + <<0,0,-1.15>>, <<0,0,0>> + <<0,0,-1.15>>, <<0,0,fRot>>, 1000000, FALSE, TRUE, TRUE)
|
|
//IF i=0
|
|
ATTACH_ENTITY_TO_ENTITY_PHYSICALLY(transportedVehicle[i].veh, planeFightVehicle[PFV_CARGO_PLANE], 0, 0, GET_TRANSPORTED_VEHICLE_COORDS(vehicleIndex, FALSE), <<0,0,0>>, <<0,0,fRot>>, 100000, TRUE, TRUE, TRUE)
|
|
//ELSE
|
|
// DELETE_VEHICLE(transportedVehicle[i].veh)
|
|
//ENDIF
|
|
ELSE
|
|
ATTACH_ENTITY_TO_ENTITY(transportedVehicle[i].veh, planeFightVehicle[PFV_CARGO_PLANE], 0, GET_TRANSPORTED_VEHICLE_COORDS(vehicleIndex, FALSE), <<0,0,fRot>>, FALSE, FALSE, TRUE)
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDREPEAT
|
|
ELSE
|
|
IF IS_VEHICLE_DRIVEABLE(fakePlaneVehicle)
|
|
REPEAT COUNT_OF(fakeTransportedVehicle) i
|
|
IF NOT fakeTransportedVehicle[i].bDetached
|
|
IF NOT IS_ENTITY_DEAD(fakeTransportedVehicle[i].veh)
|
|
TRANSPORTED_VEHICLE_INDEX_ENUM vehicleIndex = INT_TO_ENUM(TRANSPORTED_VEHICLE_INDEX_ENUM, i)
|
|
DETACH_ENTITY(fakeTransportedVehicle[i].veh)
|
|
|
|
FLOAT fRot
|
|
IF IS_TRANSPORTED_VEHICLE_FACING_TOWARDS_DOOR(vehicleIndex)
|
|
fRot = 180.0
|
|
ELSE
|
|
fRot = 0.0
|
|
ENDIF
|
|
|
|
ATTACH_ENTITY_TO_ENTITY(fakeTransportedVehicle[i].veh, fakePlaneVehicle, 0, GET_TRANSPORTED_VEHICLE_COORDS(vehicleIndex, FALSE), <<0,0,fRot>>, FALSE, FALSE, TRUE)
|
|
ENDIF
|
|
ENDIF
|
|
ENDREPEAT
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDPROC
|
|
|
|
// set proofs on transported vehicles
|
|
PROC PROOF_TRANSPORTED_VEHICLES(BOOL bPhysicalAttach)
|
|
INT i
|
|
|
|
REPEAT COUNT_OF(transportedVehicle) i
|
|
IF NOT transportedVehicle[i].bDetached
|
|
IF NOT IS_ENTITY_DEAD(transportedVehicle[i].veh)
|
|
SET_ENTITY_PROOFS(transportedVehicle[i].veh, bPhysicalAttach, bPhysicalAttach, bPhysicalAttach, bPhysicalAttach, bPhysicalAttach)
|
|
ENDIF
|
|
ENDIF
|
|
ENDREPEAT
|
|
ENDPROC
|
|
|
|
// create vehicles transported in plane
|
|
PROC CREATE_TRANSPORTED_VEHICLES(BOOL bAttach = FALSE, BOOL bFake = FALSE)
|
|
INT i
|
|
|
|
IF NOT bFake
|
|
REPEAT COUNT_OF(transportedVehicle) i
|
|
TRANSPORTED_VEHICLE_INDEX_ENUM vehicleIndex = INT_TO_ENUM(TRANSPORTED_VEHICLE_INDEX_ENUM, i)
|
|
|
|
IF NOT g_bExile1DestroyedEscapeVehicle
|
|
OR vehicleIndex <> TRANSPORTED_VEHICLE_INDEX_4WD_DRIVE
|
|
MODEL_NAMES createModel
|
|
|
|
TRANSPORTED_VEHICLE_TYPE_ENUM vehicleType = GET_TRANSPORTED_VEHICLE_TYPE(vehicleIndex)
|
|
IF vehicleType = TRANSPORTED_VEHICLE_TYPE_4WD
|
|
createModel = GET_MODEL_FOR_PLANE_FIGHT_MODEL_ENUM(PFM_4WD)
|
|
ELSE
|
|
// createModel = GET_MODEL_FOR_PLANE_FIGHT_MODEL_ENUM(PFM_VAN)
|
|
ENDIF
|
|
|
|
transportedVehicle[i].type = vehicleType
|
|
transportedVehicle[i].veh = CREATE_VEHICLE(createModel, GET_TRANSPORTED_VEHICLE_COORDS(vehicleIndex))
|
|
SET_VEHICLE_DOORS_LOCKED(transportedVehicle[i].veh, VEHICLELOCK_LOCKED)
|
|
SET_VEHICLE_IS_CONSIDERED_BY_PLAYER(transportedVehicle[i].veh, FALSE)
|
|
transportedVehicle[i].bDetached = FALSE
|
|
|
|
|
|
INT iColour
|
|
SWITCH vehicleIndex
|
|
CASE TRANSPORTED_VEHICLE_INDEX_4WD_DRIVE
|
|
CASE TRANSPORTED_VEHICLE_INDEX_4WD_L_1
|
|
CASE TRANSPORTED_VEHICLE_INDEX_4WD_L_4
|
|
CASE TRANSPORTED_VEHICLE_INDEX_4WD_R_1
|
|
iColour = 0
|
|
BREAK
|
|
CASE TRANSPORTED_VEHICLE_INDEX_4WD_SLIDE_OUT
|
|
CASE TRANSPORTED_VEHICLE_INDEX_4WD_L_2
|
|
CASE TRANSPORTED_VEHICLE_INDEX_4WD_L_3
|
|
CASE TRANSPORTED_VEHICLE_INDEX_4WD_R_2
|
|
iColour = 1
|
|
BREAK
|
|
ENDSWITCH
|
|
SET_VEHICLE_COLOUR_COMBINATION(transportedVehicle[i].veh, iColour)
|
|
|
|
SET_VEHICLE_WHEELS_CAN_BREAK_OFF_WHEN_BLOW_UP(transportedVehicle[i].veh, FALSE)
|
|
SET_VEHICLE_TYRES_CAN_BURST(transportedVehicle[i].veh, FALSE)
|
|
|
|
IF vehicleIndex = TRANSPORTED_VEHICLE_INDEX_4WD_DRIVE
|
|
SET_ENTITY_ONLY_DAMAGED_BY_PLAYER(transportedVehicle[i].veh, TRUE)
|
|
ENDIF
|
|
ENDIF
|
|
ENDREPEAT
|
|
ELSE
|
|
REPEAT COUNT_OF(fakeTransportedVehicle) i
|
|
TRANSPORTED_VEHICLE_INDEX_ENUM vehicleIndex = INT_TO_ENUM(TRANSPORTED_VEHICLE_INDEX_ENUM, i)
|
|
|
|
MODEL_NAMES createModel
|
|
|
|
TRANSPORTED_VEHICLE_TYPE_ENUM vehicleType = GET_TRANSPORTED_VEHICLE_TYPE(vehicleIndex)
|
|
IF vehicleType = TRANSPORTED_VEHICLE_TYPE_4WD
|
|
createModel = GET_MODEL_FOR_PLANE_FIGHT_MODEL_ENUM(PFM_4WD)
|
|
ELSE
|
|
// createModel = GET_MODEL_FOR_PLANE_FIGHT_MODEL_ENUM(PFM_VAN)
|
|
ENDIF
|
|
|
|
fakeTransportedVehicle[i].type = vehicleType
|
|
fakeTransportedVehicle[i].veh = CREATE_VEHICLE(createModel, GET_TRANSPORTED_VEHICLE_COORDS(vehicleIndex))
|
|
fakeTransportedVehicle[i].bDetached = FALSE
|
|
|
|
INT iColour
|
|
SWITCH vehicleIndex
|
|
CASE TRANSPORTED_VEHICLE_INDEX_4WD_DRIVE
|
|
CASE TRANSPORTED_VEHICLE_INDEX_4WD_L_1
|
|
CASE TRANSPORTED_VEHICLE_INDEX_4WD_L_4
|
|
CASE TRANSPORTED_VEHICLE_INDEX_4WD_R_1
|
|
iColour = 0
|
|
BREAK
|
|
CASE TRANSPORTED_VEHICLE_INDEX_4WD_SLIDE_OUT
|
|
CASE TRANSPORTED_VEHICLE_INDEX_4WD_L_2
|
|
CASE TRANSPORTED_VEHICLE_INDEX_4WD_L_3
|
|
CASE TRANSPORTED_VEHICLE_INDEX_4WD_R_2
|
|
iColour = 1
|
|
BREAK
|
|
ENDSWITCH
|
|
SET_VEHICLE_COLOUR_COMBINATION(fakeTransportedVehicle[i].veh, iColour)
|
|
ENDREPEAT
|
|
ENDIF
|
|
|
|
IF bAttach
|
|
ATTACH_TRANSPORTED_VEHICLES(FALSE, bFake)
|
|
ENDIF
|
|
ENDPROC
|
|
|
|
// detach vehicle from its clamps
|
|
PROC DETACH_TRANSPORTED_VEHICLE(TRANSPORTED_VEHICLE_INDEX_ENUM vehicleIndex, BOOL bDoSpeech = FALSE)
|
|
IF DOES_ENTITY_EXIST(transportedVehicle[vehicleIndex].veh)
|
|
IF NOT IS_ENTITY_DEAD(transportedVehicle[vehicleIndex].veh)
|
|
OR IS_ENTITY_DEAD(transportedVehicle[vehicleIndex].veh)
|
|
IF bDoSpeech
|
|
IF iDodgeEntity < 0
|
|
IF IS_ENTITY_AT_ENTITY(PLAYER_PED_ID(), transportedVehicle[vehicleIndex].veh, <<DODGE_CHECK_DISTANCE,DODGE_CHECK_DISTANCE,DODGE_CHECK_DISTANCE>>)
|
|
iDodgeEntity = ENUM_TO_INT(vehicleIndex)
|
|
iDodgeTime = GET_GAME_TIMER() + GET_RANDOM_INT_IN_RANGE(600, 1000)
|
|
bDodgeIsVehicle = TRUE
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
|
|
STRING sRollSFX
|
|
SWITCH vehicleIndex
|
|
CASE TRANSPORTED_VEHICLE_INDEX_4WD_DRIVE
|
|
sRollSFX = "Car_01"
|
|
BREAK
|
|
CASE TRANSPORTED_VEHICLE_INDEX_4WD_SLIDE_OUT
|
|
sRollSFX = "Car_01"
|
|
BREAK
|
|
CASE TRANSPORTED_VEHICLE_INDEX_4WD_L_1
|
|
sRollSFX = "Car_02"
|
|
BREAK
|
|
CASE TRANSPORTED_VEHICLE_INDEX_4WD_L_2
|
|
sRollSFX = "Car_03"
|
|
BREAK
|
|
CASE TRANSPORTED_VEHICLE_INDEX_4WD_L_3
|
|
sRollSFX = "Car_03"
|
|
BREAK
|
|
CASE TRANSPORTED_VEHICLE_INDEX_4WD_L_4
|
|
sRollSFX = "Car_01"
|
|
BREAK
|
|
CASE TRANSPORTED_VEHICLE_INDEX_4WD_R_1
|
|
sRollSFX = "Car_01"
|
|
BREAK
|
|
CASE TRANSPORTED_VEHICLE_INDEX_4WD_R_2
|
|
sRollSFX = "Car_02"
|
|
BREAK
|
|
ENDSWITCH
|
|
|
|
PLAY_SOUND_FROM_ENTITY(-1, sRollSFX, transportedVehicle[vehicleIndex].veh, "EXILE_1")
|
|
//PLAY_SOUND_FRONTEND(-1, sRollSFX, "EXILE_1")
|
|
|
|
//FREEZE_ENTITY_POSITION(transportedVehicle[vehicleIndex].veh, FALSE)
|
|
DETACH_ENTITY(transportedVehicle[vehicleIndex].veh)
|
|
IF vehicleIndex <> TRANSPORTED_VEHICLE_INDEX_4WD_DRIVE
|
|
SET_ENTITY_ONLY_DAMAGED_BY_PLAYER(transportedVehicle[vehicleIndex].veh, TRUE)
|
|
SET_VEHICLE_REDUCE_GRIP(transportedVehicle[vehicleIndex].veh, TRUE)
|
|
SET_VEHICLE_PROVIDES_COVER(transportedVehicle[vehicleIndex].veh, FALSE)
|
|
//APPLY_FORCE_TO_ENTITY(transportedVehicle[vehicleIndex].veh, APPLY_TYPE_EXTERNAL_IMPULSE, <<0,0,0.1>>, <<0,0,0>>, 0, TRUE, TRUE, TRUE)
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
transportedVehicle[vehicleIndex].bDetached = TRUE
|
|
ENDPROC
|
|
|
|
/*
|
|
// handle fake damage on transported vehicle
|
|
PROC HANDLE_FAKE_TRANSPORTED_VEHICLE_DAMAGE(TRANSPORTED_VEHICLE_INDEX_ENUM vehicleIndex)
|
|
IF NOT transportedVehicle[vehicleIndex].bFakeDamaged
|
|
IF NOT IS_ENTITY_DEAD(transportedVehicle[vehicleIndex].veh)
|
|
INT iDamageOnHealth = 1000
|
|
|
|
SWITCH vehicleIndex
|
|
CASE TRANSPORTED_VEHICLE_INDEX_4WD_L_1
|
|
iDamageOnHealth = 930
|
|
BREAK
|
|
CASE TRANSPORTED_VEHICLE_INDEX_4WD_L_2
|
|
iDamageOnHealth = 920
|
|
BREAK
|
|
CASE TRANSPORTED_VEHICLE_INDEX_4WD_L_3
|
|
iDamageOnHealth = 890
|
|
BREAK
|
|
CASE TRANSPORTED_VEHICLE_INDEX_4WD_L_4
|
|
iDamageOnHealth = 910
|
|
BREAK
|
|
CASE TRANSPORTED_VEHICLE_INDEX_4WD_R_1
|
|
iDamageOnHealth = 880
|
|
BREAK
|
|
CASE TRANSPORTED_VEHICLE_INDEX_4WD_R_2
|
|
iDamageOnHealth = 920
|
|
BREAK
|
|
ENDSWITCH
|
|
|
|
IF GET_ENTITY_HEALTH(transportedVehicle[vehicleIndex].veh) < iDamageOnHealth
|
|
// apply the damage
|
|
SWITCH vehicleIndex
|
|
CASE TRANSPORTED_VEHICLE_INDEX_4WD_L_1
|
|
SET_VEHICLE_TYRE_BURST(transportedVehicle[vehicleIndex].veh, SC_WHEEL_CAR_FRONT_LEFT)
|
|
SET_VEHICLE_TYRE_BURST(transportedVehicle[vehicleIndex].veh, SC_WHEEL_CAR_REAR_LEFT)
|
|
SMASH_VEHICLE_WINDOW(transportedVehicle[vehicleIndex].veh, SC_WINDOW_FRONT_LEFT)
|
|
SET_VEHICLE_DAMAGE(transportedVehicle[vehicleIndex].veh, <<-0.5, 0.75, 0.05>>, 260.0, 90.0, TRUE)
|
|
BREAK
|
|
CASE TRANSPORTED_VEHICLE_INDEX_4WD_R_1
|
|
SET_VEHICLE_TYRE_BURST(transportedVehicle[vehicleIndex].veh, SC_WHEEL_CAR_FRONT_RIGHT)
|
|
SET_VEHICLE_TYRE_BURST(transportedVehicle[vehicleIndex].veh, SC_WHEEL_CAR_REAR_RIGHT)
|
|
SMASH_VEHICLE_WINDOW(transportedVehicle[vehicleIndex].veh, SC_WINDOW_FRONT_RIGHT)
|
|
SMASH_VEHICLE_WINDOW(transportedVehicle[vehicleIndex].veh, SC_WINDOW_REAR_RIGHT)
|
|
SET_VEHICLE_DAMAGE(transportedVehicle[vehicleIndex].veh, <<0.1, 0.75, 0.05>>, 270.0, 90.0, TRUE)
|
|
BREAK
|
|
CASE TRANSPORTED_VEHICLE_INDEX_4WD_L_2
|
|
SET_VEHICLE_TYRE_BURST(transportedVehicle[vehicleIndex].veh, SC_WHEEL_CAR_FRONT_LEFT)
|
|
SMASH_VEHICLE_WINDOW(transportedVehicle[vehicleIndex].veh, SC_WINDOW_REAR_LEFT)
|
|
SET_VEHICLE_DAMAGE(transportedVehicle[vehicleIndex].veh, <<-0.6, 1.0, 0.9>>, 290.0, 80.0, TRUE)
|
|
BREAK
|
|
CASE TRANSPORTED_VEHICLE_INDEX_4WD_L_3
|
|
SET_VEHICLE_TYRE_BURST(transportedVehicle[vehicleIndex].veh, SC_WHEEL_CAR_FRONT_RIGHT)
|
|
SET_VEHICLE_DAMAGE(transportedVehicle[vehicleIndex].veh, <<-0.6, -1.4, 0.8>>, 290.0, 80.0, TRUE)
|
|
BREAK
|
|
CASE TRANSPORTED_VEHICLE_INDEX_4WD_L_4
|
|
SET_VEHICLE_TYRE_BURST(transportedVehicle[vehicleIndex].veh, SC_WHEEL_CAR_REAR_LEFT)
|
|
SMASH_VEHICLE_WINDOW(transportedVehicle[vehicleIndex].veh, SC_WINDOW_FRONT_LEFT)
|
|
SMASH_VEHICLE_WINDOW(transportedVehicle[vehicleIndex].veh, SC_WINDOW_FRONT_RIGHT)
|
|
SET_VEHICLE_DAMAGE(transportedVehicle[vehicleIndex].veh, <<-0.2, 0.6, 0.02>>, 310.0, 105.0, TRUE)
|
|
BREAK
|
|
CASE TRANSPORTED_VEHICLE_INDEX_4WD_R_2
|
|
SET_VEHICLE_DOOR_BROKEN(transportedVehicle[vehicleIndex].veh, SC_DOOR_REAR_RIGHT, FALSE)
|
|
//SET_VEHICLE_DOOR_OPEN(transportedVehicle[vehicleIndex].veh, SC_DOOR_REAR_LEFT)
|
|
//SET_VEHICLE_DOOR_OPEN(transportedVehicle[vehicleIndex].veh, SC_DOOR_REAR_RIGHT)
|
|
SMASH_VEHICLE_WINDOW(transportedVehicle[vehicleIndex].veh, SC_WINDOW_FRONT_LEFT)
|
|
BREAK
|
|
ENDSWITCH
|
|
|
|
transportedVehicle[vehicleIndex].bFakeDamaged = TRUE
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDPROC
|
|
*/
|
|
|
|
// updated vehicles in plane
|
|
PROC UPDATE_TRANSPORTED_VEHICLES()
|
|
INT i
|
|
|
|
//VECTOR vRotTowardsCockpit = planeMovementData.vRot
|
|
//VECTOR vRotTowardsDoor = (planeMovementData.vRot + <<0,0,180>>) * <<-1,-1,1>>
|
|
//VECTOR v4wdForceOnDetached = <<-2,-10,0>> // needs looked at
|
|
//VECTOR vVanForceOnDetached = <<-2,-12,0>> // needs looked at
|
|
//VECTOR vApplyForce
|
|
|
|
REPEAT COUNT_OF(transportedVehicle) i
|
|
TRANSPORTED_VEHICLE_INDEX_ENUM vehicleIndex = INT_TO_ENUM(TRANSPORTED_VEHICLE_INDEX_ENUM, i)
|
|
|
|
IF NOT transportedVehicle[vehicleIndex].bDetached
|
|
BOOL bDoDetach = FALSE
|
|
IF NOT IS_VEHICLE_DRIVEABLE(transportedVehicle[vehicleIndex].veh)
|
|
bDoDetach = TRUE
|
|
ELSE
|
|
IF vehicleIndex = TRANSPORTED_VEHICLE_INDEX_4WD_R_1
|
|
IF GET_ENTITY_HEALTH(transportedVehicle[vehicleIndex].veh) < 880
|
|
bDoDetach = TRUE
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF bDoDetach
|
|
DETACH_TRANSPORTED_VEHICLE(vehicleIndex, TRUE)
|
|
ELSE
|
|
IF IS_VEHICLE_DRIVEABLE(transportedVehicle[i].veh)
|
|
RESET_VEHICLE_WHEELS(transportedVehicle[i].veh, FALSE)
|
|
ENDIF
|
|
//HANDLE_FAKE_TRANSPORTED_VEHICLE_DAMAGE(vehicleIndex)
|
|
ENDIF
|
|
ELSE
|
|
IF NOT IS_ENTITY_DEAD(transportedVehicle[vehicleIndex].veh)
|
|
IF currentMissionStage = STAGE_PLANE_FIGHT
|
|
IF vehicleIndex <> TRANSPORTED_VEHICLE_INDEX_4WD_DRIVE
|
|
// apply force out
|
|
APPLY_FORCE_TO_ENTITY(transportedVehicle[vehicleIndex].veh, APPLY_TYPE_EXTERNAL_FORCE, <<0,6,0>>, <<0,0,0>>, 0, FALSE, TRUE, TRUE) // 4.5
|
|
|
|
// apply side force
|
|
FLOAT fSideForce = 0.0
|
|
|
|
IF vehicleIndex = TRANSPORTED_VEHICLE_INDEX_4WD_SLIDE_OUT
|
|
OR vehicleIndex = TRANSPORTED_VEHICLE_INDEX_4WD_R_1
|
|
OR vehicleIndex = TRANSPORTED_VEHICLE_INDEX_4WD_R_2
|
|
IF planeMovementData.vRot.y <= -1.0
|
|
fSideForce = -1.3
|
|
ELSE
|
|
fSideForce = -0.2
|
|
ENDIF
|
|
ELSE
|
|
IF planeMovementData.vRot.y >= 1.0
|
|
fSideForce = 1.0
|
|
ENDIF
|
|
ENDIF
|
|
|
|
APPLY_FORCE_TO_ENTITY(transportedVehicle[vehicleIndex].veh, APPLY_TYPE_EXTERNAL_FORCE, <<fSideForce,0,0>>, <<0,0,0>>, 0, FALSE, TRUE, TRUE)
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDREPEAT
|
|
ENDPROC
|
|
|
|
// get type of cover object
|
|
FUNC COVER_OBJECT_TYPE_ENUM GET_COVER_OBJECT_TYPE(COVER_OBJECT_INDEX_ENUM coverEnum)
|
|
SWITCH coverEnum
|
|
CASE COVER_OBJECT_INDEX_BATCH1_1_L1
|
|
CASE COVER_OBJECT_INDEX_BATCH2_2_L1
|
|
CASE COVER_OBJECT_INDEX_BATCH2_3_L1
|
|
RETURN COVER_OBJECT_TYPE_LONG
|
|
BREAK
|
|
ENDSWITCH
|
|
|
|
RETURN COVER_OBJECT_TYPE_SHORT
|
|
ENDFUNC
|
|
|
|
// get init coords for cover object
|
|
FUNC VECTOR GET_COVER_OBJECT_COORDS(COVER_OBJECT_INDEX_ENUM coverEnum, BOOL bReturnWorldCoords = TRUE)
|
|
FLOAT fXOffset
|
|
FLOAT fYOffset
|
|
FLOAT fZOffset
|
|
|
|
SWITCH coverEnum
|
|
CASE COVER_OBJECT_INDEX_BATCH1_1_L1
|
|
fXOffset = -1.81
|
|
fYOffset = -19.6
|
|
BREAK
|
|
CASE COVER_OBJECT_INDEX_BATCH1_2_S1
|
|
fXOffset = -2.0
|
|
fYOffset = -18.2
|
|
BREAK
|
|
//CASE COVER_OBJECT_INDEX_BATCH1_2_S2
|
|
// fXOffset = -0.9
|
|
// fYOffset = -17.9
|
|
//BREAK
|
|
CASE COVER_OBJECT_INDEX_BATCH1_3_S1
|
|
fXOffset = -2.0
|
|
fYOffset = -14.9
|
|
BREAK
|
|
CASE COVER_OBJECT_INDEX_BATCH1_3_S2
|
|
fXOffset = -0.7
|
|
fYOffset = -15.5
|
|
BREAK
|
|
CASE COVER_OBJECT_INDEX_BATCH2_1_S1
|
|
fXOffset = -1.9
|
|
fYOffset = -0.2
|
|
BREAK
|
|
CASE COVER_OBJECT_INDEX_BATCH2_1_S2
|
|
fXOffset = -0.7
|
|
fYOffset = 0.3
|
|
BREAK
|
|
CASE COVER_OBJECT_INDEX_BATCH2_2_L1
|
|
fXOffset = -1.9
|
|
fYOffset = 2.0
|
|
BREAK
|
|
CASE COVER_OBJECT_INDEX_BATCH2_3_L1
|
|
fXOffset = -1.6
|
|
fYOffset = 4.7
|
|
BREAK
|
|
CASE COVER_OBJECT_INDEX_BATCHD_1
|
|
fXOffset = 0
|
|
fYOffset = 0
|
|
fZOffset = SHORT_COVER_ATTACH_Z
|
|
BREAK
|
|
CASE COVER_OBJECT_INDEX_BATCHD_2
|
|
fXOffset = 1.3
|
|
fYOffset = -0.4
|
|
fZOffset = SHORT_COVER_ATTACH_Z
|
|
BREAK
|
|
CASE COVER_OBJECT_INDEX_BATCHD_3
|
|
fXOffset = 2.0
|
|
fYOffset = 0.9
|
|
fZOffset = SHORT_COVER_ATTACH_Z
|
|
BREAK
|
|
CASE COVER_OBJECT_INDEX_BATCHD_4
|
|
fXOffset = 0.4
|
|
fYOffset = 0.3
|
|
fZOffset = SHORT_COVER_ATTACH_Z + 1.15
|
|
BREAK
|
|
CASE COVER_OBJECT_INDEX_BATCHD_5
|
|
fXOffset = 1.7
|
|
fYOffset = 0.6
|
|
fZOffset = SHORT_COVER_ATTACH_Z + 1.15
|
|
BREAK
|
|
ENDSWITCH
|
|
|
|
IF coverEnum < COVER_OBJECT_INDEX_BATCHD_1
|
|
IF coverObject[coverEnum].type = COVER_OBJECT_TYPE_LONG
|
|
fZOffset = LONG_COVER_ATTACH_Z
|
|
ELSE
|
|
fZOffset = SHORT_COVER_ATTACH_Z
|
|
ENDIF
|
|
ELSE
|
|
fXOffset += 0.3
|
|
fYOffset += 26.92
|
|
ENDIF
|
|
|
|
IF bReturnWorldCoords
|
|
RETURN GET_PLANE_OFFSET_IN_WORLD_COORDS(<<fXOffset, fYOffset, fZOffset>>)
|
|
ELSE
|
|
RETURN <<fXOffset, fYOffset, fZOffset>>
|
|
ENDIF
|
|
ENDFUNC
|
|
|
|
// get init coords for debris object
|
|
FUNC VECTOR GET_DEBRIS_OBJECT_COORDS(INT iDebris, BOOL bReturnWorldCoords = TRUE)
|
|
FLOAT fXOffset
|
|
FLOAT fYOffset
|
|
FLOAT fZOffset
|
|
|
|
SWITCH iDebris
|
|
CASE 0
|
|
fXOffset = 1.8
|
|
fYOffset = 25.0
|
|
fZOffset = -0.3
|
|
BREAK
|
|
CASE 1
|
|
fXOffset = -1.6
|
|
fYOffset = 24.1
|
|
fZOffset = -0.5
|
|
BREAK
|
|
CASE 2
|
|
fXOffset = -1.9
|
|
fYOffset = 23.5
|
|
fZOffset = -2.2
|
|
BREAK
|
|
CASE 3
|
|
fXOffset = -0.1
|
|
fYOffset = 23.2
|
|
fZOffset = -0.4
|
|
BREAK
|
|
CASE 4
|
|
fXOffset = -2.0
|
|
fYOffset = -15.6
|
|
fZOffset = -1.1
|
|
BREAK
|
|
ENDSWITCH
|
|
|
|
IF bReturnWorldCoords
|
|
RETURN GET_PLANE_OFFSET_IN_WORLD_COORDS(<<fXOffset, fYOffset, fZOffset>>)
|
|
ELSE
|
|
RETURN <<fXOffset, fYOffset, fZOffset>>
|
|
ENDIF
|
|
ENDFUNC
|
|
|
|
// detach cover object
|
|
PROC DETACH_COVER_OBJECT(INT iCover, BOOL bDoSpeech = FALSE)
|
|
IF DOES_ENTITY_EXIST(coverObject[iCover].obj)
|
|
IF bDoSpeech
|
|
IF iDodgeEntity < 0
|
|
IF IS_ENTITY_AT_ENTITY(PLAYER_PED_ID(), coverObject[iCover].obj, <<DODGE_CHECK_DISTANCE,DODGE_CHECK_DISTANCE,DODGE_CHECK_DISTANCE>>)
|
|
iDodgeEntity = iCover
|
|
iDodgeTime = GET_GAME_TIMER() + GET_RANDOM_INT_IN_RANGE(500, 800)
|
|
bDodgeIsVehicle = FALSE
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
FREEZE_ENTITY_POSITION(coverObject[iCover].obj, FALSE)
|
|
DETACH_ENTITY(coverObject[iCover].obj, TRUE, FALSE)
|
|
|
|
APPLY_FORCE_TO_ENTITY(coverObject[iCover].obj, APPLY_TYPE_EXTERNAL_IMPULSE, <<0,0,0.1>>, <<0,0,0>>, 0, TRUE, TRUE, TRUE)
|
|
ENDIF
|
|
coverObject[iCover].bDetached = TRUE
|
|
ENDPROC
|
|
|
|
// create cover objects
|
|
PROC CREATE_COVER_OBJECTS(BOOL bAttach, BOOL bFake = FALSE)
|
|
INT i
|
|
|
|
IF NOT bFake
|
|
REPEAT COUNT_OF(coverObject) i
|
|
MODEL_NAMES createModel
|
|
COVER_OBJECT_INDEX_ENUM objectEnum = INT_TO_ENUM(COVER_OBJECT_INDEX_ENUM, i)
|
|
COVER_OBJECT_TYPE_ENUM objectType = GET_COVER_OBJECT_TYPE(objectEnum)
|
|
IF objectType = COVER_OBJECT_TYPE_LONG
|
|
createModel = GET_MODEL_FOR_PLANE_FIGHT_MODEL_ENUM(PFM_COVER1)
|
|
ELSE
|
|
createModel = GET_MODEL_FOR_PLANE_FIGHT_MODEL_ENUM(PFM_COVER2)
|
|
ENDIF
|
|
|
|
coverObject[i].obj = CREATE_OBJECT(createModel, GET_COVER_OBJECT_COORDS(objectEnum))
|
|
coverObject[i].type = objectType
|
|
coverObject[i].bDetached = FALSE
|
|
SET_ENTITY_SHOULD_FREEZE_WAITING_ON_COLLISION(coverObject[i].obj, FALSE)
|
|
|
|
IF bAttach
|
|
ATTACH_ENTITY_TO_ENTITY(coverObject[i].obj, planeFightVehicle[PFV_CARGO_PLANE], 0, GET_COVER_OBJECT_COORDS(objectEnum, FALSE), <<0,0,0>>, FALSE, FALSE, TRUE)
|
|
ENDIF
|
|
ENDREPEAT
|
|
ELSE
|
|
IF IS_VEHICLE_DRIVEABLE(fakePlaneVehicle)
|
|
REPEAT COUNT_OF(fakeCoverObject) i
|
|
MODEL_NAMES createModel
|
|
COVER_OBJECT_INDEX_ENUM objectEnum = INT_TO_ENUM(COVER_OBJECT_INDEX_ENUM, i)
|
|
COVER_OBJECT_TYPE_ENUM objectType = GET_COVER_OBJECT_TYPE(objectEnum)
|
|
IF objectType = COVER_OBJECT_TYPE_LONG
|
|
createModel = GET_MODEL_FOR_PLANE_FIGHT_MODEL_ENUM(PFM_COVER1)
|
|
ELSE
|
|
createModel = GET_MODEL_FOR_PLANE_FIGHT_MODEL_ENUM(PFM_COVER2)
|
|
ENDIF
|
|
|
|
fakeCoverObject[i].obj = CREATE_OBJECT(createModel, GET_COVER_OBJECT_COORDS(objectEnum))
|
|
fakeCoverObject[i].type = objectType
|
|
fakeCoverObject[i].bDetached = FALSE
|
|
SET_ENTITY_SHOULD_FREEZE_WAITING_ON_COLLISION(fakeCoverObject[i].obj, FALSE)
|
|
|
|
IF bAttach
|
|
ATTACH_ENTITY_TO_ENTITY(fakeCoverObject[i].obj, fakePlaneVehicle, 0, GET_COVER_OBJECT_COORDS(objectEnum, FALSE), <<0,0,0>>, FALSE, FALSE, TRUE)
|
|
ENDIF
|
|
ENDREPEAT
|
|
ENDIF
|
|
ENDIF
|
|
ENDPROC
|
|
|
|
// update cover objects
|
|
PROC UPDATE_COVER_OBJECTS()
|
|
INT i
|
|
//VECTOR vForceOnDetached = <<0,-6,-3>> // needs looked at
|
|
|
|
REPEAT COUNT_OF(coverObject) i
|
|
IF DOES_ENTITY_EXIST(coverObject[i].obj)
|
|
IF coverObject[i].bDetached
|
|
APPLY_FORCE_TO_ENTITY(coverObject[i].obj, APPLY_TYPE_EXTERNAL_FORCE, <<0,3.5,10.0>>, <<0,0,0>>, 0, FALSE, TRUE, TRUE)
|
|
ENDIF
|
|
ENDIF
|
|
ENDREPEAT
|
|
ENDPROC
|
|
|
|
// create debris objects
|
|
PROC CREATE_DEBRIS_OBJECTS()
|
|
INT i
|
|
|
|
VECTOR vForce1
|
|
VECTOR vForce2
|
|
VECTOR vOffset1
|
|
VECTOR vOffset2
|
|
|
|
vForce1=vForce1
|
|
vForce2=vForce2
|
|
vOffset1=vOffset1
|
|
vOffset2=vOffset2
|
|
|
|
REPEAT COUNT_OF(debrisObject) i
|
|
debrisObject[i].obj = CREATE_OBJECT(GET_MODEL_FOR_PLANE_FIGHT_MODEL_ENUM(PFM_COVER2), GET_DEBRIS_OBJECT_COORDS(i))
|
|
|
|
SWITCH i
|
|
CASE 0
|
|
CASE 2
|
|
CASE 3
|
|
vForce1 = <<1.0,0.0,0.0>>
|
|
vForce2 = <<-1.0,0.0,0.0>>
|
|
vOffset1 = <<0,1,0>>
|
|
vOffset2 = <<0,-1,0>>
|
|
BREAK
|
|
CASE 1
|
|
CASE 4
|
|
vForce1 = <<-1.0,0.0,0.0>>
|
|
vForce2 = <<1.0,0.0,0.0>>
|
|
vOffset1 = <<0,-1,0>>
|
|
vOffset2 = <<0,1,0>>
|
|
BREAK
|
|
ENDSWITCH
|
|
|
|
//APPLY_FORCE_TO_ENTITY(debrisObject[i].obj, APPLY_TYPE_EXTERNAL_IMPULSE, vForce1, vOffset1, 0, FALSE, TRUE, TRUE)
|
|
//APPLY_FORCE_TO_ENTITY(debrisObject[i].obj, APPLY_TYPE_EXTERNAL_IMPULSE, vForce2, vOffset2, 0, FALSE, TRUE, TRUE)
|
|
debrisObject[i].bStopForce = FALSE
|
|
debrisObject[i].bDonePassSFX = FALSE
|
|
FREEZE_ENTITY_POSITION(debrisObject[i].obj, TRUE)
|
|
SET_ENTITY_SHOULD_FREEZE_WAITING_ON_COLLISION(debrisObject[i].obj, FALSE)
|
|
SET_ENTITY_LOD_DIST(debrisObject[i].obj, 1000)
|
|
ENDREPEAT
|
|
ENDPROC
|
|
|
|
// update debris objects
|
|
PROC UPDATE_DEBRIS_OBJECTS()
|
|
INT i
|
|
|
|
VECTOR vPlayerPos = GET_ENTITY_COORDS(PLAYER_PED_ID())
|
|
|
|
IF IS_VEHICLE_DRIVEABLE(planeFightVehicle[PFV_CARGO_PLANE])
|
|
REPEAT COUNT_OF(debrisObject) i
|
|
IF DOES_ENTITY_EXIST(debrisObject[i].obj)
|
|
IF NOT debrisObject[i].bStopForce
|
|
IF GET_GAME_TIMER() >= iStageStartTime + 800
|
|
FREEZE_ENTITY_POSITION(debrisObject[i].obj, FALSE)
|
|
APPLY_FORCE_TO_ENTITY(debrisObject[i].obj, APPLY_TYPE_EXTERNAL_FORCE, <<-8.0,-30.0,23.0>>, <<0,0,0>>, 0, FALSE, TRUE, TRUE)
|
|
IF GET_DISTANCE_BETWEEN_ENTITIES(planeFightVehicle[PFV_CARGO_PLANE], debrisObject[i].obj, FALSE) >= 40
|
|
//SET_OBJECT_AS_NO_LONGER_NEEDED(debrisObject[i].obj)
|
|
//SET_ENTITY_NO_COLLISION_ENTITY(debrisObject[i].obj, PLAYER_PED_ID(), FALSE)
|
|
//SET_ENTITY_COLLISION(DEBRISOBJECT[I].OBJ, FALSE)
|
|
|
|
debrisObject[i].bStopForce = TRUE
|
|
ENDIF
|
|
ENDIF
|
|
ELSE
|
|
IF bDoneOutOfPlane
|
|
IF (GET_GAME_TIMER() <= iOpenedParachuteTime + 10000 OR (iOpenedParachuteTime < 0))
|
|
IF IS_ENTITY_AT_ENTITY(PLAYER_PED_ID(), debrisObject[i].obj, <<30,30,100>>)
|
|
IF IS_ENTITY_IN_AIR(debrisObject[i].obj)
|
|
VECTOR vDebrisPos = GET_ENTITY_COORDS(debrisObject[i].obj)
|
|
|
|
VECTOR vPush = NORMALISE_VECTOR(GET_ENTITY_COORDS(debrisObject[i].obj) - GET_ENTITY_COORDS(PLAYER_PED_ID()))
|
|
|
|
IF vPlayerPos.z < vDebrisPos.z - 5
|
|
vPush *= <<90,90,90>>
|
|
ELSE
|
|
vPush *= <<70,70,70>>
|
|
ENDIF
|
|
APPLY_FORCE_TO_ENTITY(debrisObject[i].obj, APPLY_TYPE_EXTERNAL_FORCE, vPush, <<0,0,0>>, 0, FALSE, TRUE, TRUE)
|
|
|
|
IF vPlayerPos.z < vDebrisPos.z - 100
|
|
OR vPlayerPos.z > vDebrisPos.z + 300
|
|
SET_OBJECT_AS_NO_LONGER_NEEDED(debrisObject[i].obj)
|
|
PRINTSTRING("ditched object") PRINTNL()
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
|
|
ENDIF
|
|
ENDREPEAT
|
|
ENDIF
|
|
ENDPROC
|
|
|
|
// detach all transported vehicles and cover
|
|
PROC DETACH_ALL_TRANSPORTED_VEHICLES_AND_COVER()
|
|
INT i
|
|
|
|
REPEAT COUNT_OF(transportedVehicle) i
|
|
IF IS_VEHICLE_DRIVEABLE(transportedVehicle[i].veh)
|
|
DETACH_ENTITY(transportedVehicle[i].veh)
|
|
ENDIF
|
|
ENDREPEAT
|
|
|
|
REPEAT COUNT_OF(coverObject) i
|
|
IF DOES_ENTITY_EXIST(coverObject[i].obj)
|
|
DETACH_ENTITY(coverObject[i].obj)
|
|
ENDIF
|
|
ENDREPEAT
|
|
ENDPROC
|
|
|
|
// delete all transported vehicles
|
|
PROC DELETE_ALL_TRANSPORTED_VEHICLES()
|
|
INT i
|
|
REPEAT COUNT_OF(transportedVehicle) i
|
|
IF DOES_ENTITY_EXIST(transportedVehicle[i].veh)
|
|
IF INT_TO_ENUM(TRANSPORTED_VEHICLE_INDEX_ENUM, i) <> TRANSPORTED_VEHICLE_INDEX_4WD_DRIVE
|
|
DELETE_VEHICLE(transportedVehicle[i].veh)
|
|
ELSE
|
|
IF NOT IS_VEHICLE_DRIVEABLE(transportedVehicle[i].veh)
|
|
DELETE_VEHICLE(transportedVehicle[i].veh)
|
|
g_bExile1DestroyedEscapeVehicle = TRUE
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDREPEAT
|
|
ENDPROC
|
|
|
|
// delete all cover objects
|
|
PROC DELETE_ALL_COVER_OBJECTS(BOOL bDeleteDebris)
|
|
INT i
|
|
REPEAT COUNT_OF(coverObject) i
|
|
COVER_OBJECT_INDEX_ENUM thisCover = INT_TO_ENUM(COVER_OBJECT_INDEX_ENUM, i)
|
|
IF thisCover < COVER_OBJECT_INDEX_BATCHD_1
|
|
OR bDeleteDebris
|
|
IF DOES_ENTITY_EXIST(coverObject[i].obj)
|
|
DELETE_OBJECT(coverObject[i].obj)
|
|
ENDIF
|
|
ENDIF
|
|
ENDREPEAT
|
|
ENDPROC
|
|
|
|
CONST_FLOAT SMOKE_X_1 2.9
|
|
CONST_FLOAT SMOKE_X_2 3.1
|
|
CONST_FLOAT SMOKE_Y_1 -29.5
|
|
CONST_FLOAT SMOKE_Y_2 -33.0
|
|
CONST_FLOAT SMOKE_Z_1 -3.15734
|
|
CONST_FLOAT SMOKE_Z_2 -1.65734
|
|
|
|
// smoke
|
|
PROC DO_SMOKE_ON_PLANE(PLANE_SMOKE_ENUM planeSmoke, FLOAT fOverrideScale = 1.0)
|
|
IF NOT bSmokePTFXActive[planeSmoke]
|
|
IF IS_VEHICLE_DRIVEABLE(planeFightVehicle[PFV_CARGO_PLANE])
|
|
STRING sPTFX
|
|
VECTOR vOffset
|
|
VECTOR vRot = <<0,0,0>>
|
|
FLOAT fScale = fOverrideScale
|
|
BOOL bLooped = TRUE
|
|
BOOL bRelative = TRUE
|
|
SWITCH planeSmoke
|
|
CASE PLANE_SMOKE_CLOUDS
|
|
sPTFX = "scr_ex1_moving_cloud"
|
|
vOffset = GET_PLANE_FIGHT_VECTOR(PFVEC_CLOUD_OFFSET)
|
|
vRot = <<0,0,180>>
|
|
bRelative = FALSE
|
|
BREAK
|
|
CASE PLANE_SMOKE_ENGINE_FIRE
|
|
sPTFX = "scr_ex1_cargo_engine_trail"
|
|
vOffset = GET_PLANE_FIGHT_VECTOR(PFVEC_ENGINE_OFFSET)
|
|
bLooped = TRUE
|
|
BREAK
|
|
CASE PLANE_SMOKE_ENGINE_EXPLOSION
|
|
sPTFX = "scr_ex1_cargo_engine_burst"
|
|
vOffset = GET_PLANE_FIGHT_VECTOR(PFVEC_ENGINE_OFFSET)
|
|
bLooped = FALSE
|
|
BREAK
|
|
/*
|
|
CASE PLANE_SMOKE_CRASH_SMOKE_L1
|
|
sPTFX = "scr_ex1_cargo_smoke"
|
|
vOffset = <<-SMOKE_X_1, SMOKE_Y_1, SMOKE_Z_1>>
|
|
vRot = <<0,0,270>>
|
|
bLooped = TRUE
|
|
BREAK
|
|
CASE PLANE_SMOKE_CRASH_SMOKE_L2
|
|
sPTFX = "scr_ex1_cargo_smoke"
|
|
vOffset = <<-SMOKE_X_2, SMOKE_Y_2, SMOKE_Z_2>>
|
|
vRot = <<0,0,270>>
|
|
bLooped = TRUE
|
|
BREAK
|
|
*/
|
|
CASE PLANE_SMOKE_CRASH_SMOKE_R1
|
|
sPTFX = "scr_ex1_cargo_smoke"
|
|
vOffset = <<SMOKE_X_1, SMOKE_Y_1, SMOKE_Z_1>>
|
|
vRot = <<0,0,90>>
|
|
bLooped = TRUE
|
|
BREAK
|
|
/*
|
|
CASE PLANE_SMOKE_CRASH_SMOKE_R2
|
|
sPTFX = "scr_ex1_cargo_smoke"
|
|
vOffset = <<SMOKE_X_2, SMOKE_Y_2, SMOKE_Z_2>>
|
|
vRot = <<0,0,90>>
|
|
bLooped = TRUE
|
|
BREAK
|
|
*/
|
|
CASE PLANE_SMOKE_CRASH_SMOKE_FLIGHT
|
|
sPTFX = "scr_ex1_cargo_debris"
|
|
vOffset = GET_PLANE_FIGHT_VECTOR(PFVEC_SMOKE_FLIGHT_OFFSET)
|
|
vRot = <<0,0,0>>
|
|
bLooped = TRUE
|
|
BREAK
|
|
CASE PLANE_SMOKE_SPEW_DEBRIS
|
|
sPTFX = "scr_ex1_cargo_debris"
|
|
vOffset = GET_PLANE_FIGHT_VECTOR(PFVEC_SMOKE_FLIGHT_OFFSET)//<<0.0, -48.0, 5.05734 >>
|
|
vRot = <<0,0,0>>
|
|
bLooped = TRUE
|
|
BREAK
|
|
CASE PLANE_SMOKE_GROUND_EXPLOSION
|
|
sPTFX = "scr_ex1_plane_exp"
|
|
vOffset = <<0,31,-3>>
|
|
bLooped = FALSE
|
|
BREAK
|
|
CASE PLANE_SMOKE_GROUND_DUST_IMPACT
|
|
sPTFX = "scr_ex1_dust_impact"
|
|
vOffset = <<0,31,-3>>
|
|
bLooped = FALSE
|
|
BREAK
|
|
CASE PLANE_SMOKE_GROUND_DUST_SETTLE
|
|
sPTFX = "scr_ex1_dust_settle"
|
|
vOffset = <<0,31,-3>>
|
|
bLooped = TRUE
|
|
BREAK
|
|
CASE PLANE_SMOKE_HOLD_FIRE_1
|
|
sPTFX = "cs_ex1_cargo_fire"
|
|
vOffset = <<-2.7864, -23.3082, -2.3844>>
|
|
bLooped = TRUE
|
|
BREAK
|
|
CASE PLANE_SMOKE_HOLD_FIRE_2
|
|
sPTFX = "cs_ex1_cargo_fire"
|
|
vOffset = <<-3.3518, -21.8452, -1.3641>>
|
|
bLooped = TRUE
|
|
BREAK
|
|
CASE PLANE_SMOKE_HOLD_FIRE_3
|
|
sPTFX = "cs_ex1_cargo_fire"
|
|
vOffset = <<-2.9242, -19.1240, -0.3526>>
|
|
bLooped = TRUE
|
|
BREAK
|
|
CASE PLANE_SMOKE_HOLD_FIRE_4
|
|
sPTFX = "cs_ex1_cargo_fire"
|
|
vOffset = <<3.0550, -21.4325, -3.6115>>
|
|
bLooped = TRUE
|
|
BREAK
|
|
CASE PLANE_SMOKE_HOLD_FIRE_5
|
|
sPTFX = "cs_ex1_cargo_fire"
|
|
vOffset = <<2.9188, -15.3878, -3.0399>>
|
|
bLooped = TRUE
|
|
BREAK
|
|
CASE PLANE_SMOKE_HOLD_WIRES_1
|
|
sPTFX = "cs_ex1_sparking_wires_sm"
|
|
vOffset = <<-3.2248, -19.7849, -1.1471>>
|
|
bLooped = TRUE
|
|
BREAK
|
|
CASE PLANE_SMOKE_HOLD_WIRES_2
|
|
sPTFX = "cs_ex1_sparking_wires_sm"
|
|
vOffset = <<0.6253, -14.5067, -0.3474>>
|
|
bLooped = TRUE
|
|
BREAK
|
|
ENDSWITCH
|
|
IF bLooped
|
|
IF bRelative
|
|
smokePTFX[planeSmoke] = START_PARTICLE_FX_LOOPED_ON_ENTITY(sPTFX, planeFightVehicle[PFV_CARGO_PLANE], vOffset, vRot, fScale)
|
|
ELSE
|
|
smokePTFX[planeSmoke] = START_PARTICLE_FX_LOOPED_AT_COORD(sPTFX, GET_OFFSET_FROM_ENTITY_IN_WORLD_COORDS(planeFightVehicle[PFV_CARGO_PLANE], vOffset), vRot, fScale)
|
|
ENDIF
|
|
bSmokePTFXActive[planeSmoke] = TRUE
|
|
ELSE
|
|
START_PARTICLE_FX_NON_LOOPED_ON_ENTITY(sPTFX, planeFightVehicle[PFV_CARGO_PLANE], vOffset, vRot, fScale)
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDPROC
|
|
|
|
PROC SET_DAMAGE_FX_ON_CARGO_PLANE(BOOL bSet)
|
|
IF bSet
|
|
//DO_SMOKE_ON_PLANE(PLANE_SMOKE_HOLD_FIRE_1)
|
|
DO_SMOKE_ON_PLANE(PLANE_SMOKE_HOLD_FIRE_2)
|
|
DO_SMOKE_ON_PLANE(PLANE_SMOKE_HOLD_FIRE_3)
|
|
DO_SMOKE_ON_PLANE(PLANE_SMOKE_HOLD_FIRE_4)
|
|
//DO_SMOKE_ON_PLANE(PLANE_SMOKE_HOLD_FIRE_5)
|
|
DO_SMOKE_ON_PLANE(PLANE_SMOKE_HOLD_WIRES_1)
|
|
DO_SMOKE_ON_PLANE(PLANE_SMOKE_HOLD_WIRES_2)
|
|
ELSE
|
|
STOP_SMOKE_ON_PLANE(PLANE_SMOKE_HOLD_FIRE_1, TRUE)
|
|
STOP_SMOKE_ON_PLANE(PLANE_SMOKE_HOLD_FIRE_2, TRUE)
|
|
STOP_SMOKE_ON_PLANE(PLANE_SMOKE_HOLD_FIRE_3, TRUE)
|
|
STOP_SMOKE_ON_PLANE(PLANE_SMOKE_HOLD_FIRE_4, TRUE)
|
|
STOP_SMOKE_ON_PLANE(PLANE_SMOKE_HOLD_FIRE_5, TRUE)
|
|
STOP_SMOKE_ON_PLANE(PLANE_SMOKE_HOLD_WIRES_1, TRUE)
|
|
STOP_SMOKE_ON_PLANE(PLANE_SMOKE_HOLD_WIRES_2, TRUE)
|
|
ENDIF
|
|
ENDPROC
|
|
|
|
// get init ped coords for enemy
|
|
FUNC VECTOR GET_ENEMY_PED_COORDS(INT iEnemy)
|
|
FLOAT fXOffset
|
|
FLOAT fYOffset
|
|
|
|
SWITCH iEnemy
|
|
CASE 0
|
|
fXOffset = -2.1
|
|
fYOffset = -16.7
|
|
BREAK
|
|
CASE 1
|
|
fXOffset = 0.2
|
|
fYOffset = -10.1
|
|
BREAK
|
|
CASE 2
|
|
fXOffset = 1.9
|
|
fYOffset = -4.9
|
|
BREAK
|
|
CASE 3
|
|
fXOffset = -0.4
|
|
fYOffset = 1.2
|
|
BREAK
|
|
CASE 4
|
|
fXOffset = -2.2
|
|
fYOffset = 5.8
|
|
BREAK
|
|
CASE 6
|
|
fXOffset = 1.1
|
|
fYOffset = 8.5
|
|
BREAK
|
|
CASE 7
|
|
fXOffset = 0.1
|
|
fYOffset = 18.9
|
|
BREAK
|
|
CASE 5
|
|
fXOffset = -2.0
|
|
fYOffset = 20.0
|
|
BREAK
|
|
ENDSWITCH
|
|
|
|
RETURN GET_PLANE_OFFSET_IN_WORLD_COORDS(<<fXOffset, fYOffset, PED_ATTACH_Z>>)
|
|
ENDFUNC
|
|
|
|
// create plane enemies
|
|
PROC CREATE_ENEMY_PEDS()
|
|
INT i
|
|
WEAPON_TYPE enemyWeapon
|
|
|
|
printstring("create enemy peds") printnl()
|
|
|
|
REPEAT COUNT_OF(enemyData) i
|
|
enemyData[i].ped = CREATE_PED(PEDTYPE_MISSION, GET_MODEL_FOR_PLANE_FIGHT_MODEL_ENUM(PFM_ENEMY), GET_ENEMY_PED_COORDS(i), 0)
|
|
SWITCH i
|
|
CASE 1
|
|
CASE 5
|
|
CASE 6
|
|
enemyWeapon = GET_PLANE_FIGHT_WEAPON_TYPE(PF_WEAPON_MERC_SHOTGUN)
|
|
BREAK
|
|
DEFAULT
|
|
enemyWeapon = GET_PLANE_FIGHT_WEAPON_TYPE(PF_WEAPON_MERC_PISTOL)
|
|
BREAK
|
|
ENDSWITCH
|
|
GIVE_WEAPON_TO_PED(enemyData[i].ped, enemyWeapon, INFINITE_AMMO, TRUE)
|
|
SET_BLOCKING_OF_NON_TEMPORARY_EVENTS(enemyData[i].ped, TRUE)
|
|
SET_PED_KEEP_TASK(enemyData[i].ped, TRUE)
|
|
SET_PED_DIES_WHEN_INJURED(enemyData[i].ped, TRUE)
|
|
SET_PED_RELATIONSHIP_GROUP_HASH(enemyData[i].ped, enemyRelGroup)
|
|
SET_ENTITY_CAN_BE_DAMAGED_BY_RELATIONSHIP_GROUP(enemyData[i].ped, FALSE, enemyRelGroup)
|
|
SET_PED_ACCURACY(enemyData[i].ped, 0)
|
|
//SET_CORPSE_RAGDOLL_FRICTION(enemyData[i].ped, 0.16)
|
|
SET_CORPSE_RAGDOLL_FRICTION(enemyData[i].ped, 1.0)
|
|
INFORM_MISSION_STATS_OF_HEADSHOT_WATCH_ENTITY(enemyData[i].ped)
|
|
SET_PED_CONFIG_FLAG(enemyData[i].ped, PCF_DisableExplosionReactions, TRUE)
|
|
SET_PED_CONFIG_FLAG(enemyData[i].ped, PCF_RunFromFiresAndExplosions, FALSE)
|
|
SET_PED_CONFIG_FLAG(enemyData[i].ped, PCF_CanAttackNonWantedPlayerAsLaw, TRUE)
|
|
SET_PED_CONFIG_FLAG(enemyData[i].ped, PCF_DisableHurt, TRUE)
|
|
SET_RAGDOLL_BLOCKING_FLAGS(enemyData[i].ped, RBF_PLAYER_IMPACT)
|
|
|
|
SET_PED_PATH_CAN_USE_CLIMBOVERS(enemyData[i].ped, FALSE)
|
|
SET_PED_CONFIG_FLAG(enemyData[i].ped, PCF_KeepRelationshipGroupAfterCleanUp, TRUE)
|
|
SET_COMBAT_FLOAT(enemyData[i].ped, CCF_BURST_DURATION_IN_COVER, 3.0) // default 2.0
|
|
SET_COMBAT_FLOAT(enemyData[i].ped, CCF_TIME_BETWEEN_BURSTS_IN_COVER, 1.0) // default 1.25
|
|
SET_PED_CAN_RAGDOLL(enemyData[i].ped, FALSE)
|
|
//FREEZE_ENTITY_POSITION(enemyData[i].ped, TRUE)
|
|
|
|
SET_ENEMY_VARIATIONS(i, FALSE)
|
|
|
|
TASK_AIM_GUN_AT_ENTITY(enemyData[i].ped, PLAYER_PED_ID(), -1, TRUE)
|
|
FORCE_PED_AI_AND_ANIMATION_UPDATE(enemyData[i].ped)
|
|
|
|
enemyData[i].fReadyMoveTime = 0.0
|
|
enemyData[i].aiState = ENEMY_AI_NOT_TASKED
|
|
enemyData[i].bRegisteredDead = FALSE
|
|
enemyData[i].bRunOver = FALSE
|
|
ENDREPEAT
|
|
ENDPROC
|
|
|
|
// blip all enemies
|
|
//PROC BLIP_ENEMY_PEDS()
|
|
// INT i
|
|
// REPEAT COUNT_OF(enemyData) i
|
|
// IF NOT IS_PED_INJURED(enemyData[i].ped)
|
|
// enemyData[i].blip = CREATE_MISSION_BLIP_FOR_PED(enemyData[i].ped, TRUE)
|
|
// ENDIF
|
|
// ENDREPEAT
|
|
//ENDPROC
|
|
|
|
// kill all enemy peds
|
|
PROC KILL_ALL_ENEMY_PEDS()
|
|
INT i
|
|
REPEAT COUNT_OF(enemyData) i
|
|
IF NOT IS_PED_INJURED(enemyData[i].ped)
|
|
APPLY_DAMAGE_TO_PED(enemyData[i].ped, 1000, TRUE)
|
|
ENDIF
|
|
ENDREPEAT
|
|
ENDPROC
|
|
|
|
// task enemy to combat
|
|
PROC SET_ENEMY_TO_COMBAT(INT iEnemy)
|
|
IF NOT IS_PED_INJURED(enemyData[iEnemy].ped)
|
|
TASK_COMBAT_PED(enemyData[iEnemy].ped, PLAYER_PED_ID())
|
|
enemyData[iEnemy].aiState = ENEMY_AI_COMBAT
|
|
ENDIF
|
|
ENDPROC
|
|
|
|
// add enemy move point
|
|
PROC ADD_ENEMY_MOVE_POINT(INT iEnemy, VECTOR vPos, FLOAT fMoveBlend, BOOL bSetTarget = FALSE)
|
|
TASK_GO_TO_COORD_WHILE_AIMING_AT_ENTITY(NULL, vPos, PLAYER_PED_ID(), fMoveBlend, TRUE, 0.5, 4, FALSE, ENAV_DONT_AVOID_OBJECTS)
|
|
|
|
IF bSetTarget
|
|
enemyData[iEnemy].vMoveTarget = vPos
|
|
ENDIF
|
|
ENDPROC
|
|
|
|
// task enemy to move
|
|
PROC SET_ENEMY_TO_MOVE(INT iEnemy)
|
|
IF NOT IS_PED_INJURED(enemyData[iEnemy].ped)
|
|
FLOAT fMoveBlend = PEDMOVE_RUN
|
|
VECTOR vEnemyPos = GET_ENTITY_COORDS(enemyData[iEnemy].ped)
|
|
|
|
CLEAR_SEQUENCE_TASK(sequence)
|
|
OPEN_SEQUENCE_TASK(sequence)
|
|
|
|
SWITCH iEnemy
|
|
CASE 0
|
|
fMoveBlend = PEDMOVE_WALK
|
|
IF vEnemyPos.x >= 2929.46
|
|
ADD_ENEMY_MOVE_POINT(iEnemy, <<2927.64, 807.39, 449.09>>, fMoveBlend)
|
|
ENDIF
|
|
ADD_ENEMY_MOVE_POINT(iEnemy, <<2927.39, 811.11, 448.28>>, fMoveBlend, TRUE)
|
|
BREAK
|
|
|
|
CASE 1
|
|
fMoveBlend = PEDMOVE_WALK
|
|
ADD_ENEMY_MOVE_POINT(iEnemy, <<2927.36, 811.42, 448.22>>, fMoveBlend, TRUE)
|
|
BREAK
|
|
|
|
CASE 3
|
|
IF vEnemyPos.x >= 2928.53
|
|
ADD_ENEMY_MOVE_POINT(iEnemy, <<2928.40, 787.77, 453.03>>, fMoveBlend)
|
|
ENDIF
|
|
ADD_ENEMY_MOVE_POINT(iEnemy, <<2928.20, 811.43, 448.22>>, fMoveBlend, TRUE)
|
|
BREAK
|
|
|
|
CASE 4
|
|
IF vEnemyPos.x >= 2928.53
|
|
ADD_ENEMY_MOVE_POINT(iEnemy, <<2927.3, 784.1, 454.8>>, fMoveBlend)
|
|
ENDIF
|
|
ADD_ENEMY_MOVE_POINT(iEnemy, <<2928.3, 812.7, 448.6>>, fMoveBlend, TRUE)
|
|
BREAK
|
|
|
|
CASE 5
|
|
fMoveBlend = PEDMOVE_WALK
|
|
IF vEnemyPos.x >= 2928.53
|
|
ADD_ENEMY_MOVE_POINT(iEnemy, <<2928.7, 772.1, 454.8>>, fMoveBlend)
|
|
ENDIF
|
|
ADD_ENEMY_MOVE_POINT(iEnemy, <<2927.39, 811.11, 448.28>>, fMoveBlend, TRUE)
|
|
BREAK
|
|
|
|
CASE 6
|
|
fMoveBlend = PEDMOVE_WALK
|
|
ADD_ENEMY_MOVE_POINT(iEnemy, <<2927.35, 810.30, 448.14>>, fMoveBlend, TRUE)
|
|
BREAK
|
|
|
|
CASE 7
|
|
fMoveBlend = PEDMOVE_WALK
|
|
ADD_ENEMY_MOVE_POINT(iEnemy, <<2928.7, 772.9, 448.14>>, fMoveBlend, TRUE)
|
|
ADD_ENEMY_MOVE_POINT(iEnemy, <<2929.2, 813.0, 448.1>>, fMoveBlend, TRUE)
|
|
BREAK
|
|
ENDSWITCH
|
|
|
|
CLOSE_SEQUENCE_TASK(sequence)
|
|
TASK_PERFORM_SEQUENCE(enemyData[iEnemy].ped, sequence)
|
|
|
|
//SET_PED_COMBAT_ATTRIBUTES(enemyData[iEnemy].ped, CA_REQUIRES_LOS_TO_SHOOT, FALSE)
|
|
|
|
enemyData[iEnemy].aiState = ENEMY_AI_MOVING
|
|
ENDIF
|
|
ENDPROC
|
|
|
|
// should enemy move
|
|
FUNC BOOL SHOULD_ENEMY_MOVE(INT iEnemy, FLOAT fYDiff)
|
|
IF fYDiff > 0
|
|
AND IS_PED_IN_COVER(PLAYER_PED_ID())
|
|
SWITCH iEnemy
|
|
CASE 0
|
|
IF IS_PED_INJURED(enemyData[1].ped)
|
|
RETURN TRUE
|
|
ENDIF
|
|
BREAK
|
|
CASE 1
|
|
//IF IS_PED_INJURED(enemyData[0].ped)
|
|
RETURN TRUE
|
|
//ENDIF
|
|
BREAK
|
|
CASE 3
|
|
IF IS_PED_INJURED(enemyData[0].ped)
|
|
AND IS_PED_INJURED(enemyData[1].ped)
|
|
//AND IS_PED_INJURED(enemyData[4].ped)
|
|
//AND transportedVehicle[TRANSPORTED_VEHICLE_INDEX_4WD_R_1].bDetached
|
|
RETURN TRUE
|
|
ENDIF
|
|
BREAK
|
|
CASE 4
|
|
IF IS_PED_INJURED(enemyData[0].ped)
|
|
AND IS_PED_INJURED(enemyData[1].ped)
|
|
AND IS_PED_INJURED(enemyData[3].ped)
|
|
AND IS_PED_INJURED(enemyData[6].ped)
|
|
AND IS_PED_INJURED(enemyData[7].ped)
|
|
//AND IS_PED_INJURED(enemyData[4].ped)
|
|
//AND transportedVehicle[TRANSPORTED_VEHICLE_INDEX_4WD_R_1].bDetached
|
|
RETURN TRUE
|
|
ENDIF
|
|
BREAK
|
|
CASE 5
|
|
IF IS_PED_INJURED(enemyData[7].ped)
|
|
RETURN TRUE
|
|
ENDIF
|
|
BREAK
|
|
CASE 6
|
|
IF IS_PED_INJURED(enemyData[0].ped)
|
|
AND IS_PED_INJURED(enemyData[1].ped)
|
|
AND IS_PED_INJURED(enemyData[3].ped)
|
|
//AND transportedVehicle[TRANSPORTED_VEHICLE_INDEX_4WD_R_1].bDetached
|
|
RETURN TRUE
|
|
ENDIF
|
|
BREAK
|
|
CASE 7
|
|
IF IS_PED_INJURED(enemyData[0].ped)
|
|
AND IS_PED_INJURED(enemyData[1].ped)
|
|
AND IS_PED_INJURED(enemyData[3].ped)
|
|
//AND transportedVehicle[TRANSPORTED_VEHICLE_INDEX_4WD_R_1].bDetached
|
|
RETURN TRUE
|
|
ENDIF
|
|
BREAK
|
|
ENDSWITCH
|
|
ENDIF
|
|
|
|
RETURN FALSE
|
|
ENDFUNC
|
|
|
|
// should enemy return to combat
|
|
FUNC BOOL SHOULD_MOVING_ENEMY_RETURN_TO_COMBAT(FLOAT fYDiff, FLOAT fYDistance)
|
|
IF IS_PED_IN_COVER(PLAYER_PED_ID())
|
|
IF fYDiff <= -0.8
|
|
RETURN TRUE
|
|
ENDIF
|
|
ELSE
|
|
IF fYDistance <= 5
|
|
RETURN TRUE
|
|
ENDIF
|
|
ENDIF
|
|
|
|
RETURN FALSE
|
|
ENDFUNC
|
|
|
|
// time for enemy to move
|
|
FUNC FLOAT GET_ENEMY_MOVE_TIME(INT iEnemy)
|
|
SWITCH iEnemy
|
|
CASE 0
|
|
RETURN 3.0
|
|
BREAK
|
|
CASE 1
|
|
RETURN 2.0
|
|
BREAK
|
|
CASE 3
|
|
RETURN 4.0
|
|
BREAK
|
|
CASE 4
|
|
RETURN 2.0
|
|
BREAK
|
|
CASE 5
|
|
RETURN 4.0
|
|
BREAK
|
|
CASE 6
|
|
RETURN 7.0
|
|
BREAK
|
|
CASE 7
|
|
RETURN 8.0
|
|
BREAK
|
|
ENDSWITCH
|
|
|
|
RETURN 99999999999.0
|
|
ENDFUNC
|
|
|
|
// update enemies in the plane
|
|
PROC UPDATE_ENEMY_PEDS()
|
|
INT i
|
|
VECTOR vPlayerCoords = GET_ENTITY_COORDS(PLAYER_PED_ID())
|
|
|
|
iKilledEnemies = 0
|
|
REPEAT COUNT_OF(enemyData) i
|
|
IF missionFailState = MISSION_FAIL_STATE_NOT_FAILED
|
|
UPDATE_AI_PED_BLIP(enemyData[i].ped, enemyData[i].blip)
|
|
ENDIF
|
|
|
|
IF IS_PED_INJURED(enemyData[i].ped)
|
|
IF NOT enemyData[i].bRegisteredDead
|
|
IF DOES_ENTITY_EXIST(enemyData[i].ped)
|
|
IF IS_PED_DEAD_OR_DYING(enemyData[i].ped)
|
|
INFORM_MISSION_STATS_OF_INCREMENT(EXL1_KILLS)
|
|
//SET_CORPSE_SLEEP_TOLERANCES(enemyData[i].ped, 1, 2)
|
|
//SET_CORPSE_SLEEPS_ALONE(enemyData[i].ped, TRUE)
|
|
enemyData[i].bRegisteredDead = TRUE
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
|
|
iKilledEnemies++
|
|
ELSE
|
|
VECTOR vEnemyOffsetFromPlane = GET_OFFSET_FROM_ENTITY_GIVEN_WORLD_COORDS(planeFightVehicle[PFV_CARGO_PLANE], GET_ENTITY_COORDS(enemyData[i].ped))
|
|
FLOAT fYDiff = vEnemyOffsetFromPlane.y - vPlayerOffsetFromPlane.y
|
|
FLOAT fYDistance = fYDiff
|
|
IF fYDistance < 0
|
|
fYDistance *= -1
|
|
ENDIF
|
|
|
|
// shooting
|
|
IF i=0
|
|
IF IS_PED_IN_COVER(PLAYER_PED_ID())
|
|
IF fyDiff > 1
|
|
AND NOT IS_PLAYER_FREE_AIMING(PLAYER_ID())
|
|
AND NOT IS_PLAYER_TARGETTING_ANYTHING(PLAYER_ID())
|
|
AND enemyData[i].aiState <> ENEMY_AI_MOVING
|
|
SET_PED_RESET_FLAG(enemyData[i].ped, PRF_BlockWeaponFire, TRUE)
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
|
|
// handle ai
|
|
SWITCH enemyData[i].aiState
|
|
CASE ENEMY_AI_NOT_TASKED
|
|
SET_ENEMY_TO_COMBAT(i)
|
|
BREAK
|
|
|
|
CASE ENEMY_AI_COMBAT
|
|
IF NOT IS_PED_IN_COMBAT(enemyData[i].ped)
|
|
SET_ENEMY_TO_COMBAT(i)
|
|
ELSE
|
|
IF SHOULD_ENEMY_MOVE(i, fYDiff)
|
|
enemyData[i].fReadyMoveTime = enemyData[i].fReadyMoveTime +@ 1.0
|
|
IF enemyData[i].fReadyMoveTime >= GET_ENEMY_MOVE_TIME(i)
|
|
SET_ENEMY_TO_MOVE(i)
|
|
ENDIF
|
|
ELSE
|
|
enemyData[i].fReadyMoveTime = enemyData[i].fReadyMoveTime -@ 1.0
|
|
IF enemyData[i].fReadyMoveTime < 0.0
|
|
enemyData[i].fReadyMoveTime = 0.0
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
BREAK
|
|
|
|
CASE ENEMY_AI_MOVING
|
|
IF IS_ENTITY_AT_COORD(enemyData[i].ped, enemyData[i].vMoveTarget, <<0.5,0.5,1>>, FALSE, FALSE)
|
|
OR SHOULD_MOVING_ENEMY_RETURN_TO_COMBAT(fYDiff, fYDistance)
|
|
OR GET_SCRIPT_TASK_STATUS(enemyData[i].ped, SCRIPT_TASK_PERFORM_SEQUENCE) = FINISHED_TASK
|
|
SET_ENEMY_TO_COMBAT(i)
|
|
ENDIF
|
|
BREAK
|
|
ENDSWITCH
|
|
|
|
// kill the ped if they managed to fall out
|
|
VECTOR vPedCoords = GET_ENTITY_COORDS(enemyData[i].ped)
|
|
IF vPedCoords.z <= vPlayerCoords.z - 10.0
|
|
SET_PED_AS_NO_LONGER_NEEDED(enemyData[i].ped)
|
|
ENDIF
|
|
|
|
// kill the ped if fell under a truck
|
|
//IF iTruckCheck = i
|
|
IF NOT IS_PED_INJURED(enemyData[i].ped)
|
|
IF NOT enemyData[i].bRunover
|
|
IF IS_PED_RAGDOLL(enemyData[i].ped)
|
|
INT j
|
|
REPEAT COUNT_OF(TRANSPORTED_VEHICLE_INDEX_ENUM) j
|
|
IF transportedVehicle[j].bDetached
|
|
IF NOT IS_ENTITY_DEAD(transportedVehicle[j].veh)
|
|
IF IS_ENTITY_TOUCHING_ENTITY(transportedVehicle[j].veh, enemyData[i].ped)
|
|
enemyData[i].iRunOverTIme = GET_GAME_TIMER()
|
|
enemyData[i].bRunover = true
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDREPEAT
|
|
ENDIF
|
|
ELSE
|
|
IF IS_PED_RAGDOLL(enemyData[i].ped)
|
|
IF GET_GAME_TIMER() >= enemyData[i].iRunOverTIme + 2000
|
|
APPLY_DAMAGE_TO_PED(enemyData[i].ped, 1000, TRUE)
|
|
ENDIF
|
|
ELSE
|
|
enemyData[i].bRunover = FALSE
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDREPEAT
|
|
|
|
//iTruckCheck++
|
|
//IF iTruckCheck = NUMBER_ENEMY_PEDS
|
|
// iTruckCheck = 0
|
|
//ENDIF
|
|
ENDPROC
|
|
|
|
PROC POPULATE_PLANE_INTERIOR(BOOL bCreateVehiclesAndCover, BOOL bCreatePeds, BOOL bAttach = FALSE, BOOL bBlipPeds = FALSE, BOOL bCreateCover = TRUE)
|
|
IF bCreateVehiclesAndCover
|
|
CREATE_TRANSPORTED_VEHICLES(bAttach)
|
|
IF bCreateCover
|
|
CREATE_COVER_OBJECTS(bAttach)
|
|
ENDIF
|
|
ENDIF
|
|
printstring("pop interior") printnl()
|
|
IF bCreatePeds
|
|
printstring("benemy peds") printnl()
|
|
CREATE_ENEMY_PEDS()
|
|
IF bBlipPeds
|
|
// BLIP_ENEMY_PEDS()
|
|
ENDIF
|
|
ENDIF
|
|
ENDPROC
|
|
|
|
// start playback for cargo plane
|
|
PROC SET_CARGO_PLANE_TO_FLY(MISSION_STAGE_ENUM flyStage)
|
|
IF IS_VEHICLE_DRIVEABLE(planeFightVehicle[PFV_CARGO_PLANE])
|
|
CONTROL_LANDING_GEAR(planeFightVehicle[PFV_CARGO_PLANE], LGC_RETRACT_INSTANT)
|
|
|
|
IF IS_PLAYBACK_GOING_ON_FOR_VEHICLE(planeFightVehicle[PFV_CARGO_PLANE])
|
|
STOP_PLAYBACK_RECORDED_VEHICLE(planeFightVehicle[PFV_CARGO_PLANE])
|
|
ENDIF
|
|
START_PLAYBACK_RECORDED_VEHICLE(planeFightVehicle[PFV_CARGO_PLANE], 001, GET_PLANE_FIGHT_RECORDING_PREFIX())
|
|
FLOAT fSkip
|
|
IF flyStage = STAGE_FOLLOW_PLANE_1
|
|
fSkip = 7500
|
|
ELIF flyStage = STAGE_FOLLOW_PLANE_2
|
|
fSkip = 101000//98000
|
|
ELIF flyStage = STAGE_FOLLOW_PLANE_3
|
|
fSkip = 189100//98000
|
|
ELSE
|
|
fSkip = ALLOW_FLY_HIGH_TIME + 20000
|
|
ENDIF
|
|
|
|
SKIP_TIME_IN_PLAYBACK_RECORDED_VEHICLE(planeFightVehicle[PFV_CARGO_PLANE], fSkip)
|
|
ENDIF
|
|
ENDPROC
|
|
|
|
// setup the cargo plane so can do rumble inside
|
|
PROC SET_CARGO_PLANE_FOR_INTERIOR_ACTION(MISSION_STAGE_ENUM setStage)
|
|
IF IS_VEHICLE_DRIVEABLE(planeFightVehicle[PFV_CARGO_PLANE])
|
|
|
|
|
|
IF IS_PLAYBACK_GOING_ON_FOR_VEHICLE(planeFightVehicle[PFV_CARGO_PLANE])
|
|
STOP_PLAYBACK_RECORDED_VEHICLE(planeFightVehicle[PFV_CARGO_PLANE])
|
|
ENDIF
|
|
//FLOAT fHeading = GET_ENTITY_HEADING(planeFightVehicle[PFV_CARGO_PLANE])
|
|
//VECTOR vPos = GET_ENTITY_COORDS(planeFightVehicle[PFV_CARGO_PLANE])
|
|
//SET_ENTITY_COORDS(planeFightVehicle[PFV_CARGO_PLANE], <<vPos.x, vPos.y, 1485>>)
|
|
//SET_ENTITY_HEADING(planeFightVehicle[PFV_CARGO_PLANE], fHeading)
|
|
//FREEZE_ENTITY_POSITION(planeFightVehicle[PFV_CARGO_PLANE], TRUE)
|
|
|
|
INT iRec
|
|
IF setStage = STAGE_PLANE_FIGHT
|
|
iRec = 005
|
|
ELSE
|
|
iRec = 006
|
|
ENDIF
|
|
|
|
FREEZE_ENTITY_POSITION(planeFightVehicle[PFV_CARGO_PLANE], FALSE)
|
|
START_PLAYBACK_RECORDED_VEHICLE(planeFightVehicle[PFV_CARGO_PLANE], iRec, GET_PLANE_FIGHT_RECORDING_PREFIX())
|
|
fPlaneInteriorSpeed = 0.000000000001
|
|
SET_PLAYBACK_SPEED(planeFightVehicle[PFV_CARGO_PLANE], fPlaneInteriorSpeed)
|
|
|
|
SET_ENTITY_PROOFS(planeFightVehicle[PFV_CARGO_PLANE], TRUE, TRUE, TRUE, TRUE, TRUE)
|
|
SET_VEHICLE_CAN_BREAK(planeFightVehicle[PFV_CARGO_PLANE], FALSE)
|
|
SET_VEHICLE_CAN_BE_VISIBLY_DAMAGED(planeFightVehicle[PFV_CARGO_PLANE], FALSE)
|
|
CONTROL_LANDING_GEAR(planeFightVehicle[PFV_CARGO_PLANE], LGC_RETRACT_INSTANT)
|
|
SET_VEHICLE_ENGINE_ON(planeFightVehicle[PFV_CARGO_PLANE], TRUE, TRUE)
|
|
ENDIF
|
|
ENDPROC
|
|
|
|
// open door cutscene
|
|
PROC DO_POPULATE_PLANE_AND_OPEN_DOOR()
|
|
g_bExile1DestroyedEscapeVehicle = FALSE
|
|
POPULATE_PLANE_INTERIOR(TRUE, FALSE, TRUE)
|
|
|
|
IF bPreparedCargoDoorsOpenCue
|
|
TRIGGER_MISSION_MUSIC_EVENT("EXL1_CARGO_DOORS_OPEN")
|
|
ENDIF
|
|
ENDPROC
|
|
|
|
// jump to escape
|
|
PROC SETUP_JUMP_TO_ESCAPE()
|
|
INT i
|
|
REPEAT COUNT_OF(transportedVehicle) i
|
|
IF INT_TO_ENUM(TRANSPORTED_VEHICLE_INDEX_ENUM, i) <> TRANSPORTED_VEHICLE_INDEX_4WD_DRIVE
|
|
IF DOES_ENTITY_EXIST(transportedVehicle[i].veh)
|
|
DELETE_VEHICLE(transportedVehicle[i].veh)
|
|
ENDIF
|
|
ENDIF
|
|
ENDREPEAT
|
|
IF IS_VEHICLE_DRIVEABLE(planeFightVehicle[PFV_CARGO_PLANE])
|
|
SET_VEHICLE_DOOR_BROKEN(planeFightVehicle[PFV_CARGO_PLANE], SC_DOOR_REAR_LEFT, TRUE)
|
|
ENDIF
|
|
IF IS_VEHICLE_DRIVEABLE(transportedVehicle[TRANSPORTED_VEHICLE_INDEX_4WD_DRIVE].veh)
|
|
SET_VEHICLE_ENGINE_ON(transportedVehicle[TRANSPORTED_VEHICLE_INDEX_4WD_DRIVE].veh, TRUE, TRUE)
|
|
ENDIF
|
|
ENDPROC
|
|
|
|
// get roll speed
|
|
FUNC FLOAT GET_PLANE_TARGET_ROLL_SPEED()
|
|
SWITCH flightTargetData.rollSpeed
|
|
CASE PLANE_ROLL_SPEED_VERY_SLOW
|
|
RETURN 1.0
|
|
BREAK
|
|
CASE PLANE_ROLL_SPEED_SLOW
|
|
RETURN 2.0
|
|
BREAK
|
|
CASE PLANE_ROLL_SPEED_MED
|
|
RETURN 8.0
|
|
BREAK
|
|
CASE PLANE_ROLL_SPEED_FAST
|
|
RETURN 11.0
|
|
BREAK
|
|
ENDSWITCH
|
|
|
|
RETURN 0.0
|
|
ENDFUNC
|
|
|
|
// get pitch speed
|
|
FUNC FLOAT GET_PLANE_TARGET_PITCH_SPEED()
|
|
SWITCH flightTargetData.pitchSpeed
|
|
CASE PLANE_PITCH_SPEED_SLOW
|
|
RETURN 1.0
|
|
BREAK
|
|
CASE PLANE_PITCH_SPEED_MED
|
|
RETURN 1.8
|
|
BREAK
|
|
CASE PLANE_PITCH_SPEED_FAST
|
|
RETURN 4.0
|
|
BREAK
|
|
ENDSWITCH
|
|
|
|
RETURN 0.0
|
|
ENDFUNC
|
|
|
|
// get cockpit coords
|
|
FUNC VECTOR GET_LADDER_COORDS()
|
|
RETURN GET_PLANE_OFFSET_IN_WORLD_COORDS(<<-0.8, 22.7, -3.0>>)
|
|
ENDFUNC
|
|
|
|
// get cockpit coords
|
|
FUNC VECTOR GET_COCKPIT_COORDS()
|
|
RETURN GET_PLANE_OFFSET_IN_WORLD_COORDS(<<-0.8, 30, 2.0>>)
|
|
ENDFUNC
|
|
|
|
// get controls coords
|
|
FUNC VECTOR GET_CONTROLS_COORDS()
|
|
RETURN GET_PLANE_OFFSET_IN_WORLD_COORDS(<<0.0, 29.32, 2.0>>)
|
|
ENDFUNC
|
|
|
|
// get cockpit coords
|
|
FUNC VECTOR GET_EXIT_COCKPIT_COORDS()
|
|
//RETURN GET_PLANE_OFFSET_IN_WORLD_COORDS(<<-0.1, 22.4, -3.8>>)
|
|
RETURN GET_PLANE_OFFSET_IN_WORLD_COORDS(<<-0.8, 22.4, -3.8>>)
|
|
ENDFUNC
|
|
|
|
// get klaxon coords
|
|
FUNC VECTOR GET_KLAXON_COORDS()
|
|
RETURN GET_PLANE_OFFSET_IN_WORLD_COORDS(<<0, 0, -0.6>>)
|
|
ENDFUNC
|
|
|
|
// klaxon sound
|
|
PROC HANDLE_KLAXON_SOUND(BOOL bFrontEnd)
|
|
// handle klaxon sound on/off
|
|
IF NOT bDoneOutOfPlane
|
|
IF NOT bKlaxonOn
|
|
IF HAS_SOUND_FINISHED(iKlaxonSoundID)
|
|
IF NOT bFrontEnd
|
|
PLAY_SOUND_FROM_COORD(iKlaxonSoundID, "Generic_Alarm_Fire_Electronic", GET_KLAXON_COORDS())
|
|
ELSE
|
|
PLAY_SOUND_FRONTEND(iKlaxonSoundID, "Generic_Alarm_Fire_Electronic")
|
|
ENDIF
|
|
bKlaxonOn = TRUE
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDPROC
|
|
|
|
// turn off klaxon
|
|
PROC TURN_OFF_KLAXON()
|
|
IF NOT HAS_SOUND_FINISHED(iKlaxonSoundID)
|
|
STOP_SOUND(iKlaxonSoundID)
|
|
ENDIF
|
|
bKlaxonOn = FALSE
|
|
ENDPROC
|
|
|
|
// update the plane movement
|
|
PROC UPDATE_PLANE_PHYSICAL_MOVEMENT()
|
|
IF IS_VEHICLE_DRIVEABLE(planeFightVehicle[PFV_CARGO_PLANE])
|
|
SET_VEHICLE_ENGINE_ON(planeFightVehicle[PFV_CARGO_PLANE], TRUE, TRUE)
|
|
|
|
// roll
|
|
IF planeMovementData.vRot.y <> flightTargetData.fRollTarget
|
|
// increase roll speed
|
|
FLOAT fTargetRollSpeed = GET_PLANE_TARGET_ROLL_SPEED()
|
|
IF flightTargetData.rollDir = PLANE_ROLL_DIR_CLOCKWISE
|
|
planeMovementData.fRollSpeed = planeMovementData.fRollSpeed +@ PLANE_ROLL_ACCELERATION
|
|
IF planeMovementData.fRollSpeed > fTargetRollSpeed
|
|
planeMovementData.fRollSpeed = fTargetRollSpeed
|
|
ENDIF
|
|
ELSE
|
|
fTargetRollSpeed *= -1
|
|
planeMovementData.fRollSpeed = planeMovementData.fRollSpeed -@ PLANE_ROLL_ACCELERATION
|
|
IF planeMovementData.fRollSpeed < fTargetRollSpeed
|
|
planeMovementData.fRollSpeed = fTargetRollSpeed
|
|
ENDIF
|
|
ENDIF
|
|
|
|
planeMovementData.vRot.y = planeMovementData.vRot.y +@ planeMovementData.fRollSpeed
|
|
IF flightTargetData.rollDir = PLANE_ROLL_DIR_CLOCKWISE
|
|
IF planeMovementData.vRot.y >= flightTargetData.fRollTarget
|
|
planeMovementData.vRot.y = flightTargetData.fRollTarget
|
|
ENDIF
|
|
ELSE
|
|
IF planeMovementData.vRot.y <= flightTargetData.fRollTarget
|
|
planeMovementData.vRot.y = flightTargetData.fRollTarget
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF planeMovementData.vRot.y > 180.0
|
|
planeMovementData.vRot.y -= 360.0
|
|
ELIF planeMovementData.vRot.y < -180.0
|
|
planeMovementData.vRot.y += 360.0
|
|
ENDIF
|
|
ENDIF
|
|
|
|
|
|
|
|
// pitch
|
|
IF planeMovementData.vRot.x <> flightTargetData.fPitchTarget
|
|
//PRINTSTRING("adjusting") printnl()
|
|
|
|
// increase pitch speed
|
|
FLOAT fTargetPitchSpeed = GET_PLANE_TARGET_PITCH_SPEED()
|
|
IF flightTargetData.pitchDir = PLANE_PITCH_DIR_CLIMB
|
|
planeMovementData.fPitchSpeed = planeMovementData.fPitchSpeed +@ PLANE_PITCH_ACCELERATION
|
|
IF planeMovementData.fPitchSpeed > fTargetPitchSpeed
|
|
planeMovementData.fPitchSpeed = fTargetPitchSpeed
|
|
ENDIF
|
|
ELSE
|
|
//PRINTSTRING("diving") printnl()
|
|
fTargetPitchSpeed *= -1
|
|
planeMovementData.fPitchSpeed = planeMovementData.fPitchSpeed -@ PLANE_PITCH_ACCELERATION
|
|
IF planeMovementData.fPitchSpeed < fTargetPitchSpeed
|
|
planeMovementData.fPitchSpeed = fTargetPitchSpeed
|
|
ENDIF
|
|
ENDIF
|
|
|
|
planeMovementData.vRot.x = planeMovementData.vRot.x +@ planeMovementData.fPitchSpeed
|
|
IF flightTargetData.pitchDir = PLANE_PITCH_DIR_CLIMB
|
|
IF planeMovementData.vRot.x >= flightTargetData.fPitchTarget
|
|
planeMovementData.vRot.x = flightTargetData.fPitchTarget
|
|
ENDIF
|
|
ELSE
|
|
IF planeMovementData.vRot.x <= flightTargetData.fPitchTarget
|
|
planeMovementData.vRot.x = flightTargetData.fPitchTarget
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF planeMovementData.vRot.x > 180.0
|
|
planeMovementData.vRot.x -= 360.0
|
|
ELIF planeMovementData.vRot.x < -180.0
|
|
planeMovementData.vRot.x += 360.0
|
|
ENDIF
|
|
ENDIF
|
|
|
|
// set doors
|
|
//SET_VEHICLE_DOOR_CONTROL(planeFightVehicle[PFV_CARGO_PLANE], SC_DOOR_REAR_LEFT, DT_DOOR_INTACT, 1.0)
|
|
//SET_VEHICLE_DOOR_CONTROL(planeFightVehicle[PFV_CARGO_PLANE], SC_DOOR_FRONT_LEFT, DT_DOOR_INTACT, 0.0)
|
|
//SET_VEHICLE_DOOR_CONTROL(planeFightVehicle[PFV_CARGO_PLANE], SC_DOOR_FRONT_RIGHT, DT_DOOR_INTACT, 0.0)
|
|
|
|
// set anchor rotation and cache
|
|
//PRINTSTRING("rot = ") PRINTVECTOR(planeMovementData.vRot) PRINTNL()
|
|
//SET_ENTITY_ROTATION(planeFightVehicle[PFV_CARGO_PLANE], planeMovementData.vRot)
|
|
IF IS_PLAYBACK_GOING_ON_FOR_VEHICLE(planeFightVehicle[PFV_CARGO_PLANE])
|
|
//planeMovementData.vRot.y = 0
|
|
SET_ADDITIONAL_ROTATION_FOR_RECORDED_VEHICLE_PLAYBACK(planeFightVehicle[PFV_CARGO_PLANE], planeMovementData.vRot)
|
|
ENDIF
|
|
ENDIF
|
|
ENDPROC
|
|
|
|
// shake gameplay cam
|
|
PROC DO_MISSION_GAMEPLAY_CAM_SHAKE()
|
|
SHAKE_GAMEPLAY_CAM("SMALL_EXPLOSION_SHAKE", CAM_SHAKE_AMPLITUDE)
|
|
ENDPROC
|
|
|
|
// equip best player weapon
|
|
PROC EQUIP_BEST_PLAYER_WEAPON(BOOL bForceIntoHand)
|
|
IF NOT IS_PED_INJURED(PLAYER_PED_ID())
|
|
WEAPON_TYPE bestWeapon = GET_BEST_PED_WEAPON(PLAYER_PED_ID())
|
|
WEAPON_GROUP weaponGroup = GET_WEAPONTYPE_GROUP(bestWeapon)
|
|
INT iWeaponAmmo = GET_AMMO_IN_PED_WEAPON(PLAYER_PED_ID(), bestWeapon)
|
|
INT iGiveAmmo = -1
|
|
|
|
BOOL bWeaponIsSuitable = TRUE
|
|
|
|
IF weaponGroup <> WEAPONGROUP_PISTOL
|
|
AND weaponGroup <> WEAPONGROUP_SMG
|
|
AND weaponGroup <> WEAPONGROUP_RIFLE
|
|
AND weaponGroup <> WEAPONGROUP_MG
|
|
//AND weaponGroup <> WEAPONGROUP_SHOTGUN
|
|
bWeaponIsSuitable = FALSE
|
|
ELSE
|
|
INT iReasonableAmmo
|
|
SWITCH weaponGroup
|
|
CASE WEAPONGROUP_PISTOL
|
|
iReasonableAmmo = 30
|
|
BREAK
|
|
CASE WEAPONGROUP_SMG
|
|
iReasonableAmmo = 90
|
|
BREAK
|
|
CASE WEAPONGROUP_RIFLE
|
|
iReasonableAmmo = 90
|
|
BREAK
|
|
CASE WEAPONGROUP_MG
|
|
iReasonableAmmo = 100
|
|
BREAK
|
|
CASE WEAPONGROUP_SHOTGUN
|
|
iReasonableAmmo = 12
|
|
BREAK
|
|
ENDSWITCH
|
|
|
|
IF iWeaponAmmo < iReasonableAmmo
|
|
iGiveAmmo = iReasonableAmmo
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF bWeaponIsSuitable
|
|
SET_CURRENT_PED_WEAPON(PLAYER_PED_ID(), bestWeapon, bForceIntoHand)
|
|
IF iGiveAmmo >= 0
|
|
SET_AMMO_IN_CLIP(PLAYER_PED_ID(), bestWeapon, GET_MAX_AMMO_IN_CLIP(PLAYER_PED_ID(), bestWeapon))
|
|
SET_PED_AMMO(PLAYER_PED_ID(), bestWeapon, iGiveAmmo)
|
|
ENDIF
|
|
ELSE
|
|
GIVE_WEAPON_TO_PED(PLAYER_PED_ID(), GET_PLANE_FIGHT_WEAPON_TYPE(PF_WEAPON_PLAYER_BACKUP), 90, TRUE)
|
|
ENDIF
|
|
ENDIF
|
|
ENDPROC
|
|
|
|
// preload parachute
|
|
PROC PRELOAD_PARACHUTE(BOOL bWait = FALSE)
|
|
SET_PED_PRELOAD_VARIATION_DATA(PLAYER_PED_ID(), PED_COMP_SPECIAL, 3, 0)
|
|
|
|
IF bWait
|
|
WHILE NOT HAS_PED_PRELOAD_VARIATION_DATA_FINISHED(PLAYER_PED_ID())
|
|
WAIT(0)
|
|
ENDWHILE
|
|
ENDIF
|
|
ENDPROC
|
|
|
|
// give trevor a parachute backpack
|
|
PROC GIVE_TREVOR_PARACHUTE_BACKPACK()
|
|
IF NOT IS_PED_INJURED(PLAYER_PED_ID())
|
|
SET_PED_COMPONENT_VARIATION(PLAYER_PED_ID(), PED_COMP_SPECIAL, 3, 0)
|
|
RELEASE_PED_PRELOAD_VARIATION_DATA(PLAYER_PED_ID())
|
|
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)
|
|
// 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()
|
|
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
|
|
|
|
// position player at init pos for mission
|
|
PROC POSITION_PLAYER_AT_MISSION_INIT()
|
|
IF NOT IS_PED_INJURED(PLAYER_PED_ID())
|
|
SET_ENTITY_COORDS(PLAYER_PED_ID(), GET_PLANE_FIGHT_VECTOR(PFVEC_PLAYER_INIT))
|
|
SET_ENTITY_HEADING(PLAYER_PED_ID(), PLAYER_INIT_ROT)
|
|
SET_GAMEPLAY_CAM_RELATIVE_HEADING()
|
|
ENDIF
|
|
ENDPROC
|
|
|
|
// create blip for airstrip
|
|
PROC CREATE_MISSION_BLIP_FOR_AIRSTRIP()
|
|
getToBlip = CREATE_MISSION_BLIP_FOR_COORD(GET_PLANE_FIGHT_VECTOR(PFVEC_AIRSTRIP), TRUE)
|
|
SET_TAXI_DROPOFF_LOCATION_FOR_BLIP(getToBlip, <<1792.95, 3316.93, 40.72>>, -160.93)
|
|
ENDPROC
|
|
|
|
// trevor in cover
|
|
PROC PUT_TREVOR_INTO_COVER()
|
|
planeCover = ADD_COVER_POINT(<<2930.45, 810.2, 448.4>>, 180, COVUSE_WALLTOBOTH, COVHEIGHT_LOW, COVARC_180) // <<2930.45, 810.39, 448.57>>
|
|
CLEAR_PED_TASKS_IMMEDIATELY(PLAYER_PED_ID())
|
|
TASK_PUT_PED_DIRECTLY_INTO_COVER(PLAYER_PED_ID(), <<2930.5, 810.2, 448.4>>, -1, FALSE, 0, TRUE, FALSE, planeCover)
|
|
//SET_PED_CAN_RAGDOLL(PLAYER_PED_ID(), FALSE)
|
|
FORCE_PED_AI_AND_ANIMATION_UPDATE(PLAYER_PED_ID(), TRUE)
|
|
//bForcedDuck = TRUE
|
|
ENDPROC
|
|
|
|
// trevor into car
|
|
PROC SET_TREVOR_INTO_CAR()
|
|
IF NOT bForceIntoCar
|
|
IF IS_VEHICLE_DRIVEABLE(planeFightVehicle[PFV_TREVOR_4WD])
|
|
AND NOT IS_PED_INJURED(PLAYER_PED_ID())
|
|
// TASK_ENTER_VEHICLE(PLAYER_PED_ID(), planeFightVehicle[PFV_TREVOR_4WD], DEFAULT_TIME_BEFORE_WARP, VS_DRIVER, PEDMOVEBLENDRATIO_WALK)
|
|
//TASK_GO_STRAIGHT_TO_COORD(player_ped_id(),<< 1980.7129, 3830.8232, 31.3860 >>,PEDMOVE_WALK,DEFAULT_TIME_NEVER_WARP)
|
|
bForceIntoCar = TRUE
|
|
ENDIF
|
|
ENDIF
|
|
ENDPROC
|
|
|
|
|
|
PROC SETUP_TREVOR_WITH_MISSION_OUTFIT(PED_INDEX trevorPed)
|
|
SET_PED_COMP_ITEM_CURRENT_SP(trevorPed, COMP_TYPE_OUTFIT, OUTFIT_P2_TSHIRT_JEANS_1, FALSE)
|
|
ENDPROC
|
|
|
|
// should we set the checkpoint for replay on this stage init?
|
|
FUNC BOOL SHOULD_SET_CHECKPOINT_FOR_THIS_STAGE(MISSION_STAGE_ENUM setStage)
|
|
SWITCH setStage
|
|
CASE STAGE_GET_TO_AIRSTRIP
|
|
CASE STAGE_FOLLOW_PLANE_1
|
|
CASE STAGE_FOLLOW_PLANE_2
|
|
CASE STAGE_FOLLOW_PLANE_3
|
|
CASE STAGE_ENTER_PLANE
|
|
CASE STAGE_PLANE_FIGHT
|
|
CASE STAGE_FLY_PLANE
|
|
CASE STAGE_ESCAPE_PLANE
|
|
RETURN TRUE
|
|
BREAK
|
|
ENDSWITCH
|
|
|
|
RETURN FALSE
|
|
ENDFUNC
|
|
|
|
// clear the start area
|
|
PROC CLEAR_START_AREA()
|
|
// move last player vehicle and clear init areas
|
|
CLEAR_INIT_POS(GET_PLANE_FIGHT_VECTOR(PFVEC_PLAYER_INIT))
|
|
CLEAR_INIT_POS(GET_PLANE_FIGHT_VECTOR(PFVEC_TREVOR_4WD_INIT))
|
|
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 CREATE_HILLS_STREAMING_VOLUME()
|
|
hillsStreamingVolume = STREAMVOL_CREATE_FRUSTUM(<<1983.29309, 3823.83691, 31.43800>>, CONVERT_ROTATION_TO_DIRECTION_VECTOR(<<0,0,34.6>>), 3500, FLAG_MAPDATA)
|
|
ENDPROC
|
|
|
|
PROC SETUP_SHOOTOUT()
|
|
RESET_FLIGHT_TARGET_DATA_FOR_STAGE(STAGE_PLANE_FIGHT)
|
|
RESET_PLANE_MOVEMENT_DATA_FROM_TARGET_DATA()
|
|
UPDATE_PLANE_PHYSICAL_MOVEMENT()
|
|
SET_PARTICLE_FX_CAM_INSIDE_NONPLAYER_VEHICLE(planeFightVehicle[PFV_CARGO_PLANE], TRUE)
|
|
|
|
FORCE_PLAYBACK_RECORDED_VEHICLE_UPDATE(planeFightVehicle[PFV_CARGO_PLANE])
|
|
SET_VEHICLE_INACTIVE_DURING_PLAYBACK(planeFightVehicle[PFV_CARGO_PLANE], TRUE)
|
|
IF IS_VEHICLE_DRIVEABLE(planeFightVehicle[PFV_CARGO_PLANE])
|
|
SET_VEHICLE_DOOR_BROKEN(planeFightVehicle[PFV_CARGO_PLANE], SC_DOOR_REAR_LEFT, TRUE)
|
|
ENDIF
|
|
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 bRemoveBlips = TRUE, BOOL bKillHintCam = TRUE, BOOL bResetCommonVariables = TRUE, BOOL bRemoveCutscene = TRUE)
|
|
IF bJumpingToStage
|
|
// clear area and load scene around start pos
|
|
VECTOR vStartPos
|
|
FLOAT fStartRot
|
|
|
|
SWITCH setStage
|
|
CASE STAGE_GET_TO_AIRSTRIP
|
|
vStartPos = GET_PLANE_FIGHT_VECTOR(PFVEC_PLAYER_INIT)
|
|
fStartRot = PLAYER_INIT_ROT
|
|
BREAK
|
|
CASE STAGE_FOLLOW_PLANE_1
|
|
vStartPos = GET_PLANE_FIGHT_VECTOR(PFVEC_TREVOR_PLANE_INIT) + <<0,0,6>>
|
|
fStartRot = TREVOR_PLANE_INIT_ROT
|
|
BREAK
|
|
CASE STAGE_FOLLOW_PLANE_2
|
|
vStartPos = GET_PLANE_FIGHT_VECTOR(PFVEC_TREVOR_PLANE_MID_POINT) + <<0,0,6>>
|
|
fStartRot = TREVOR_PLANE_MID_POINT_ROT
|
|
BREAK
|
|
CASE STAGE_FOLLOW_PLANE_3
|
|
vStartPos = GET_PLANE_FIGHT_VECTOR(PFVEC_TREVOR_PLANE_CLIMB_POINT) + <<0,0,6>>
|
|
fStartRot = TREVOR_PLANE_CLIMB_POINT_ROT
|
|
BREAK
|
|
CASE STAGE_ENTER_PLANE
|
|
vStartPos = GET_PLANE_FIGHT_VECTOR(PFVEC_TREVOR_PLANE_ENTER_POINT) + <<0,0,6>>
|
|
fStartRot = TREVOR_PLANE_ENTER_POINT_ROT
|
|
BREAK
|
|
CASE STAGE_PLANE_FIGHT
|
|
vStartPos = <<2930.5, 810.389, 448.3599>>
|
|
fStartRot = 180
|
|
BREAK
|
|
CASE STAGE_FLY_PLANE
|
|
vStartPos = GET_PLANE_FIGHT_VECTOR(PFVEC_CARGO_PLANE_FLY) + <<0,0,10>>
|
|
fStartRot = CARGO_PLANE_FLY_ROT
|
|
BREAK
|
|
CASE STAGE_ESCAPE_PLANE
|
|
IF NOT bForcePassOnShitskip
|
|
vStartPos = <<1904.1, 4091.2, 1458.9>>
|
|
fStartRot = 160
|
|
ELSE
|
|
vStartPos = GET_PLANE_FIGHT_VECTOR(PFVEC_PASSED)
|
|
fStartRot = PASSED_ROT
|
|
ENDIF
|
|
BREAK
|
|
ENDSWITCH
|
|
|
|
// clear area for replay
|
|
SET_PLAYER_OUT_OF_ANY_VEHICLE()
|
|
IF bClearMap
|
|
CLEAR_AREA(vStartPos, 10000, TRUE)
|
|
ENDIF
|
|
WAIT(0)
|
|
|
|
// set weather
|
|
SET_WEATHER_TYPE_NOW_PERSIST("extrasunny")
|
|
|
|
// set to coords and wait for streaming
|
|
IF IS_REPLAY_IN_PROGRESS()
|
|
AND NOT bSuppressFutureReplaySetups
|
|
START_REPLAY_SETUP(vStartPos, fStartRot)
|
|
ELSE
|
|
SET_ENTITY_COORDS(PLAYER_PED_ID(), vStartPos)
|
|
SET_ENTITY_HEADING(PLAYER_PED_ID(), fStartRot)
|
|
ENDIF
|
|
|
|
//IF NOT bForcePassOnShitskip
|
|
//WAIT(0)
|
|
//LOAD_SCENE(vStartPos)
|
|
//WAIT(0)
|
|
//ENDIF
|
|
ENDIF
|
|
|
|
// get the models and force their load
|
|
REQUEST_MODELS_FOR_STAGE(setStage, TRUE, FALSE)
|
|
|
|
// get the recordings and force their load
|
|
REQUEST_VEHICLE_RECORDINGS_FOR_STAGE(setStage, TRUE, FALSE)
|
|
|
|
// get the anims and force their load
|
|
REQUEST_ANIM_DICTS_FOR_STAGE(setStage, TRUE, FALSE)
|
|
|
|
// get the weapons and force their load
|
|
REQUEST_WEAPONS_FOR_STAGE(setStage, TRUE, FALSE)
|
|
|
|
// get the ptfx and force their load
|
|
REQUEST_PTFX_FOR_STAGE(setStage, TRUE, FALSE)
|
|
|
|
// get the sfx and force their load
|
|
REQUEST_SFX_FOR_STAGE(setStage, TRUE, FALSE)
|
|
|
|
// get the misc assets and force their load
|
|
REQUEST_MISC_ASSETS_FOR_STAGE(setStage, TRUE, FALSE)
|
|
|
|
// get the text and force its load
|
|
REQUEST_TEXT(TRUE)
|
|
|
|
// reset mocap streaming
|
|
//IF mocapStreamingStage >= MOCAP_STREAMING_STAGE_WAIT
|
|
IF bRemoveCutscene
|
|
REMOVE_CUTSCENE()
|
|
ENDIF
|
|
mocapStreamingStage = MOCAP_STREAMING_STAGE_REQUEST
|
|
//ENDIF
|
|
|
|
// reset vars
|
|
RESET_VARIABLES_FOR_STAGE(setStage, bResetCommonVariables)
|
|
|
|
// get rid of blips and text
|
|
IF bRemoveBlips
|
|
REMOVE_ALL_BLIPS()
|
|
ENDIF
|
|
REMOVE_MISSION_TEXT(bClearTextAndSpeech OR bJumpingToStage, bClearTextAndSpeech OR bJumpingToStage)
|
|
|
|
// kill chase cam
|
|
IF bKillHintCam
|
|
KILL_CHASE_HINT_CAM(localChaseHintCamStruct)
|
|
STOP_PLANE_FIGHT_AUDIO_SCENE(PLANE_FIGHT_AUDIO_SCENE_FOCUS_ON_CARGO_PLANE)
|
|
STOP_PLANE_FIGHT_AUDIO_SCENE(PLANE_FIGHT_AUDIO_SCENE_FIGHTER_JET_CAMERA)
|
|
STOP_PLANE_FIGHT_AUDIO_SCENE(PLANE_FIGHT_AUDIO_SCENE_FOCUS_ON_CRASHING_PLANE)
|
|
bDoneFocusAudioScene = FALSE
|
|
bDoneFocusOnCrashingPlaneAudioScene = 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
|
|
|
|
INT i
|
|
REPEAT 3 i
|
|
IF DOES_ENTITY_EXIST(sSelectorPeds.pedID[i])
|
|
DELETE_PED(sSelectorPeds.pedID[i])
|
|
ENDIF
|
|
ENDREPEAT
|
|
ENDIF
|
|
|
|
//SETUP_TREVOR_WITH_MISSION_OUTFIT(PLAYER_PED_ID())
|
|
ENDIF
|
|
|
|
IF bJumpingToStage
|
|
OR bInitialisingAfterIntro
|
|
// remove all dialogue
|
|
IF bJumpingToStage
|
|
INT i
|
|
FOR i=0 TO 9
|
|
REMOVE_PED_FOR_DIALOGUE(planeFightConversation, i)
|
|
ENDFOR
|
|
ENDIF
|
|
|
|
// setup with speech
|
|
ADD_PED_FOR_DIALOGUE(planeFightConversation, 1, PLAYER_PED_ID(), "TREVOR")
|
|
|
|
sSelectorPeds.eCurrentSelectorPed = GET_SELECTOR_SLOT_FROM_PLAYER_PED_ENUM(GET_CHARACTER_FOR_MISSION_STAGE(setStage))
|
|
// create the player characters for the stage
|
|
CREATE_PLAYER_CHARACTERS_WITH_TRANSPORT_IN_MISSION_STAGE(setStage)
|
|
SETUP_PLAYER_CHARACTER_WITH_MISSION_VARIATIONS(PLAYER_PED_ID(), GET_CHARACTER_FOR_MISSION_STAGE(setStage), setStage)
|
|
|
|
IF bJumpingToStage
|
|
LOAD_ALL_OBJECTS_IF_SCREEN_FADED_OUT()
|
|
WHILE NOT HAVE_ALL_STREAMING_REQUESTS_COMPLETED(PLAYER_PED_ID())
|
|
WAIT(0)
|
|
ENDWHILE
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF setStage = STAGE_FOLLOW_PLANE_1
|
|
DISABLE_VEHICLE_GEN_ON_MISSION(FALSE)
|
|
ENDIF
|
|
|
|
// setup player control/cameras
|
|
IF bRenderScriptCamsFalse
|
|
RENDER_SCRIPT_CAMS(FALSE, FALSE)
|
|
ENDIF
|
|
|
|
// do any other necessary setup for the stage
|
|
SWITCH setStage
|
|
CASE STAGE_GET_TO_AIRSTRIP
|
|
IF bJumpingToStage
|
|
IF STREAMVOL_IS_VALID(trailerStreamingVolume)
|
|
AND NOT IS_NEW_LOAD_SCENE_ACTIVE()
|
|
STREAMVOL_DELETE(trailerStreamingVolume)
|
|
ENDIF
|
|
|
|
IF NOT IS_REPLAY_IN_PROGRESS()
|
|
INT iStreamVolTimeOut
|
|
iStreamVolTimeOut = GET_GAME_TIMER() + 5000
|
|
IF NOT STREAMVOL_IS_VALID(hillsStreamingVolume)
|
|
CREATE_HILLS_STREAMING_VOLUME()
|
|
ENDIF
|
|
|
|
WHILE GET_GAME_TIMER() <= iStreamVolTimeOut
|
|
AND NOT STREAMVOL_HAS_LOADED(hillsStreamingVolume)
|
|
printstring("Wait for streaming") PRINTNL()
|
|
WAIT(0)
|
|
ENDWHILE
|
|
ENDIF
|
|
ENDIF
|
|
|
|
|
|
IF IS_VEHICLE_DRIVEABLE(planeFightVehicle[PFV_TREVOR_PLANE])
|
|
SET_VEHICLE_IS_CONSIDERED_BY_PLAYER(planeFightVehicle[PFV_TREVOR_PLANE], FALSE)
|
|
ENDIF
|
|
|
|
CREATE_RON_FOR_STAGE(STAGE_GET_TO_AIRSTRIP, bJumpingToStage)
|
|
// temp comment out jump check
|
|
IF bJumpingToStage
|
|
SET_RON_AT_CAR()
|
|
IF IS_VEHICLE_DRIVEABLE(planeFightVehicle[PFV_TREVOR_4WD])
|
|
AND NOT IS_PED_INJURED(ronPed)
|
|
TASK_ENTER_VEHICLE(ronPed, planeFightVehicle[PFV_TREVOR_4WD], DEFAULT_TIME_BEFORE_WARP, VS_FRONT_RIGHT, PEDMOVEBLENDRATIO_WALK)
|
|
ENDIF
|
|
ENDIF
|
|
|
|
CREATE_MICHAEL_AND_PATRICIA(bJumpingToStage)
|
|
|
|
//SET_CURRENT_PED_WEAPON(PLAYER_PED_ID(), WEAPONTYPE_UNARMED, FALSE)
|
|
|
|
// ron into 4wd
|
|
IF NOT IS_PED_INJURED(ronPed)
|
|
AND IS_VEHICLE_DRIVEABLE(planeFightVehicle[PFV_TREVOR_4WD])
|
|
AND NOT IS_PED_INJURED(PLAYER_PED_ID())
|
|
|
|
SET_PED_CONFIG_FLAG(PLAYER_PED_ID(), PCF_ForceDirectEntry, TRUE)
|
|
ENDIF
|
|
//RESET_ADAPTATION(1)
|
|
//SET_PED_AS_GROUP_MEMBER(ronPed, PLAYER_GROUP_ID())
|
|
|
|
//getToBlip = CREATE_MISSION_BLIP_FOR_COORD(GET_PLANE_FIGHT_VECTOR(PFVEC_AIRSTRIP), TRUE)
|
|
//SET_TAXI_DROPOFF_LOCATION_FOR_BLIP(getToBlip, <<1792.95, 3316.93, 40.72>>, -160.93)
|
|
//CREATE_MISSION_BLIP_FOR_AIRSTRIP()
|
|
//SET_PLAYER_CONTROL(PLAYER_ID(), FALSE, SPC_LEAVE_CAMERA_CONTROL_ON)
|
|
BREAK
|
|
CASE STAGE_FOLLOW_PLANE_1
|
|
CLEANUP_MICHAEL_AND_PATRICIA()
|
|
|
|
IF bJumpingToStage
|
|
IF Is_Replay_In_Progress()
|
|
IF IS_REPLAY_CHECKPOINT_VEHICLE_AVAILABLE()
|
|
IF IS_REPLAY_VEHICLE_MODEL_UNDER_SIZE_LIMIT(GET_REPLAY_CHECKPOINT_VEHICLE_MODEL(), <<0,0,0>>)
|
|
checkpointVehicle = CREATE_REPLAY_CHECKPOINT_VEHICLE(<<2134.08, 4808.97, 40.79>>, 154.6)
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
bModelRequestTracker[PFM_LAST_VEHICLE] = FALSE
|
|
|
|
CREATE_RON_FOR_STAGE(STAGE_FOLLOW_PLANE_1, TRUE)
|
|
IF IS_VEHICLE_DRIVEABLE(planeFightVehicle[PFV_TREVOR_PLANE])
|
|
IF NOT IS_PED_IN_VEHICLE(PLAYER_PED_ID(), planeFightVehicle[PFV_TREVOR_PLANE])
|
|
SET_PED_INTO_VEHICLE(PLAYER_PED_ID(), planeFightVehicle[PFV_TREVOR_PLANE])
|
|
ENDIF
|
|
SET_VEHICLE_ENGINE_ON(planeFightVehicle[PFV_TREVOR_PLANE], TRUE, TRUE)
|
|
SET_HELI_BLADES_FULL_SPEED (planeFightVehicle[PFV_TREVOR_PLANE])
|
|
ENDIF
|
|
ELSE
|
|
PLANE_FIGHT_CREATE_VEHICLE(PFV_CARGO_PLANE, GET_PLANE_FIGHT_VECTOR(PFVEC_CARGO_PLANE_INIT), 0.0)
|
|
ADD_CARGO_PLANE_TO_AUDIO_MIX_GROUP()
|
|
ENDIF
|
|
IF DOES_ENTITY_EXIST(planeFightVehicle[PFV_TREVOR_4WD])
|
|
SET_VEHICLE_AS_NO_LONGER_NEEDED(planeFightVehicle[PFV_TREVOR_4WD])
|
|
ENDIF
|
|
IF IS_VEHICLE_DRIVEABLE(planeFightVehicle[PFV_TREVOR_PLANE])
|
|
SET_VEHICLE_IS_CONSIDERED_BY_PLAYER(planeFightVehicle[PFV_TREVOR_PLANE], TRUE)
|
|
ENDIF
|
|
|
|
IF IS_VEHICLE_DRIVEABLE(planeFightVehicle[PFV_CARGO_PLANE])
|
|
SET_VEHICLE_INTERIORLIGHT(planeFightVehicle[PFV_CARGO_PLANE], FALSE)
|
|
ENDIF
|
|
|
|
ADD_PED_FOR_DIALOGUE(planeFightConversation, 4, NULL, "MERCPLANE")
|
|
CREATE_PLANE_ROOT()
|
|
|
|
START_PLANE_FIGHT_AUDIO_SCENE(PLANE_FIGHT_AUDIO_SCENE_FLIGHT_MAIN)
|
|
|
|
SET_CARGO_PLANE_TO_FLY(STAGE_FOLLOW_PLANE_1)
|
|
BREAK
|
|
CASE STAGE_FOLLOW_PLANE_2
|
|
IF bJumpingToStage
|
|
jetAttackState = JET_ATTACK_NOT_CREATED
|
|
bDoneTakeoffCue = TRUE
|
|
bDoneSpotPlaneCue = TRUE
|
|
bDoneSenseOfStyleCue = TRUE
|
|
bDoneOnToesCue = FALSE
|
|
bDoneStartClimbingCue = FALSE
|
|
bDoneIdentifyYourselfCue = FALSE
|
|
bPreparedCargoDoorsOpenCue = FALSE
|
|
bDoneCargoPlaneAppearsAudioScene = TRUE
|
|
|
|
iGetInTextStage = 2
|
|
iAlarmIntensitySetting = 0
|
|
iShownTooHighHelpTimes = 0
|
|
iTooHighCount = 0
|
|
fOverBaseTime = 0.0
|
|
iApproachSpeechStage = 4
|
|
fPlaneSpeed = 0.9
|
|
fAboveHeightTime = 0.0
|
|
iScrambleJetsTime = -1
|
|
bDoneSeePlane = TRUE
|
|
bActivatedCargoPlaneSpeed = TRUE
|
|
bAllowFlyHigh = FALSE
|
|
bEnforceFlyLow = TRUE
|
|
bShownFlyLowHelp = TRUE
|
|
bDoneFlyLowSpeech = TRUE
|
|
//bDoneFlyLowSpeech2 = TRUE
|
|
bDoneComeInSpeech = TRUE
|
|
bShownTooHighHelp = FALSE
|
|
bDoneTooHighSpeech = FALSE
|
|
bDoneTooHighUrgentSpeech = FALSE
|
|
bDoOnItSpeech = FALSE
|
|
bIncrementedTooHigh = FALSE
|
|
bKilledSpeechForJets = FALSE
|
|
bKilledSpeechForTooHigh = FALSE
|
|
bKilledSpeechForBase = FALSE
|
|
bShownBaseHelp = TRUE
|
|
bDoneBaseSpeech = TRUE
|
|
bDoneIgnoreRonSpeech = TRUE
|
|
bDoneOverBaseSpeech = FALSE
|
|
bKlaxonOn = FALSE
|
|
bStoppedForceSpeed = FALSE
|
|
bJetsScrambled = FALSE
|
|
bDoneJetsScrambledSpeech = FALSE
|
|
bDoneFocusAudioScene = FALSE
|
|
bBeenCloseToPlane = FALSE
|
|
bSentText = FALSE
|
|
|
|
iStopForceSpeedTime = GET_GAME_TIMER() + 400
|
|
iEnforceFlyLowTime = GET_GAME_TIMER() - 7000
|
|
|
|
CREATE_PLANE_ROOT()
|
|
|
|
IF IS_VEHICLE_DRIVEABLE(planeFightVehicle[PFV_CARGO_PLANE])
|
|
SET_VEHICLE_INTERIORLIGHT(planeFightVehicle[PFV_CARGO_PLANE], FALSE)
|
|
ENDIF
|
|
|
|
FREEZE_ENTITY_POSITION(PLAYER_PED_ID(), FALSE)
|
|
IF IS_VEHICLE_DRIVEABLE(planeFightVehicle[PFV_TREVOR_PLANE])
|
|
IF NOT IS_PED_IN_VEHICLE(PLAYER_PED_ID(), planeFightVehicle[PFV_TREVOR_PLANE])
|
|
SET_PED_INTO_VEHICLE(PLAYER_PED_ID(), planeFightVehicle[PFV_TREVOR_PLANE])
|
|
ENDIF
|
|
SET_VEHICLE_ENGINE_ON(planeFightVehicle[PFV_TREVOR_PLANE], TRUE, TRUE)
|
|
SET_HELI_BLADES_FULL_SPEED(planeFightVehicle[PFV_TREVOR_PLANE])
|
|
SET_VEHICLE_FORWARD_SPEED(planeFightVehicle[PFV_TREVOR_PLANE], 55.0)
|
|
ENDIF
|
|
SET_CARGO_PLANE_TO_FLY(STAGE_FOLLOW_PLANE_2)
|
|
|
|
IF IS_VEHICLE_DRIVEABLE(planeFightVehicle[PFV_TREVOR_PLANE])
|
|
SET_VEHICLE_IS_CONSIDERED_BY_PLAYER(planeFightVehicle[PFV_TREVOR_PLANE], TRUE)
|
|
ENDIF
|
|
ADD_PED_FOR_DIALOGUE(planeFightConversation, 4, NULL, "MERCPLANE")
|
|
ADD_PED_FOR_DIALOGUE(planeFightConversation, 3, NULL, "NervousRon")
|
|
|
|
START_PLANE_FIGHT_AUDIO_SCENE(PLANE_FIGHT_AUDIO_SCENE_CARGO_PLANE_APPEARS)
|
|
|
|
TRIGGER_MISSION_MUSIC_EVENT("EXL1_RELOAD_AROUND_THE_COAST")
|
|
ENDIF
|
|
BREAK
|
|
CASE STAGE_FOLLOW_PLANE_3
|
|
STOP_PLANE_FIGHT_AUDIO_SCENE(PLANE_FIGHT_AUDIO_SCENE_CARGO_PLANE_APPEARS)
|
|
START_PLANE_FIGHT_AUDIO_SCENE(PLANE_FIGHT_AUDIO_SCENE_FLIGHT_START_CLIMB)
|
|
|
|
IF bJumpingToStage
|
|
jetAttackState = JET_ATTACK_NOT_CREATED
|
|
bDoneTakeoffCue = TRUE
|
|
bDoneSpotPlaneCue = TRUE
|
|
bDoneSenseOfStyleCue = TRUE
|
|
bDoneOnToesCue = TRUE
|
|
bDoneStartClimbingCue = TRUE
|
|
bDoneIdentifyYourselfCue = FALSE
|
|
bPreparedCargoDoorsOpenCue = FALSE
|
|
bDoneCargoPlaneAppearsAudioScene = TRUE
|
|
|
|
iGetInTextStage = 2
|
|
fOverBaseTime = 0.0
|
|
iApproachSpeechStage = 6
|
|
iAlarmIntensitySetting = 0
|
|
fPlaneSpeed = 0.75
|
|
fAboveHeightTime = 0.0
|
|
iScrambleJetsTime = -1
|
|
bDoneSeePlane = TRUE
|
|
bActivatedCargoPlaneSpeed = TRUE
|
|
bAllowFlyHigh = TRUE
|
|
bEnforceFlyLow = TRUE
|
|
bShownFlyLowHelp = TRUE
|
|
bDoneFlyLowSpeech = TRUE
|
|
//bDoneFlyLowSpeech2 = TRUE
|
|
bDoneComeInSpeech = TRUE
|
|
bShownTooHighHelp = FALSE
|
|
bDoneTooHighSpeech = FALSE
|
|
bDoneTooHighUrgentSpeech = FALSE
|
|
bDoOnItSpeech = FALSE
|
|
bIncrementedTooHigh = FALSE
|
|
bKilledSpeechForJets = FALSE
|
|
bKilledSpeechForTooHigh = FALSE
|
|
bKilledSpeechForBase = FALSE
|
|
bShownBaseHelp = TRUE
|
|
bDoneBaseSpeech = TRUE
|
|
bDoneOverBaseSpeech = FALSE
|
|
bDoneIgnoreRonSpeech = TRUE
|
|
bKlaxonOn = FALSE
|
|
bStoppedForceSpeed = FALSE
|
|
bJetsScrambled = FALSE
|
|
bDoneJetsScrambledSpeech = FALSE
|
|
bDoneFocusAudioScene = FALSE
|
|
bBeenCloseToPlane = FALSE
|
|
iStopForceSpeedTime = GET_GAME_TIMER() + 400
|
|
|
|
CREATE_PLANE_ROOT()
|
|
|
|
FREEZE_ENTITY_POSITION(PLAYER_PED_ID(), FALSE)
|
|
IF IS_VEHICLE_DRIVEABLE(planeFightVehicle[PFV_TREVOR_PLANE])
|
|
IF NOT IS_PED_IN_VEHICLE(PLAYER_PED_ID(), planeFightVehicle[PFV_TREVOR_PLANE])
|
|
SET_PED_INTO_VEHICLE(PLAYER_PED_ID(), planeFightVehicle[PFV_TREVOR_PLANE])
|
|
ENDIF
|
|
SET_VEHICLE_ENGINE_ON(planeFightVehicle[PFV_TREVOR_PLANE], TRUE, TRUE)
|
|
SET_HELI_BLADES_FULL_SPEED(planeFightVehicle[PFV_TREVOR_PLANE])
|
|
SET_VEHICLE_FORWARD_SPEED(planeFightVehicle[PFV_TREVOR_PLANE], 55.0)
|
|
ENDIF
|
|
IF IS_VEHICLE_DRIVEABLE(planeFightVehicle[PFV_CARGO_PLANE])
|
|
SET_VEHICLE_INTERIORLIGHT(planeFightVehicle[PFV_CARGO_PLANE], FALSE)
|
|
ENDIF
|
|
|
|
SET_CARGO_PLANE_TO_FLY(STAGE_FOLLOW_PLANE_3)
|
|
|
|
IF IS_VEHICLE_DRIVEABLE(planeFightVehicle[PFV_TREVOR_PLANE])
|
|
SET_VEHICLE_IS_CONSIDERED_BY_PLAYER(planeFightVehicle[PFV_TREVOR_PLANE], TRUE)
|
|
ENDIF
|
|
ADD_PED_FOR_DIALOGUE(planeFightConversation, 4, NULL, "MERCPLANE")
|
|
ADD_PED_FOR_DIALOGUE(planeFightConversation, 3, NULL, "NervousRon")
|
|
|
|
TRIGGER_MISSION_MUSIC_EVENT("EXL1_START_CLIMB_RT")
|
|
ENDIF
|
|
BREAK
|
|
CASE STAGE_ENTER_PLANE
|
|
IF bJumpingToStage
|
|
//PLANE_FIGHT_CREATE_VEHICLE(PFV_CARGO_PLANE, GET_PLANE_FIGHT_VECTOR(PFVEC_CARGO_PLANE_INIT), 0.0)
|
|
g_bExile1DestroyedEscapeVehicle = FALSE
|
|
POPULATE_PLANE_INTERIOR(TRUE, FALSE, TRUE)
|
|
fPlaneSpeed = CARGO_PLANE_SPEED
|
|
bDoneFocusAudioScene = FALSE
|
|
bDoneSeePlane = TRUE
|
|
bBeenCloseToPlane = FALSE
|
|
|
|
FREEZE_ENTITY_POSITION(PLAYER_PED_ID(), FALSE)
|
|
//ATTACH_RAMP_PEDS()
|
|
//bCropDustingOn = FALSE
|
|
ADD_PED_FOR_DIALOGUE(planeFightConversation, 4, NULL, "MERCPLANE")
|
|
SET_CARGO_PLANE_TO_FLY(STAGE_ENTER_PLANE)
|
|
|
|
IF IS_VEHICLE_DRIVEABLE(planeFightVehicle[PFV_CARGO_PLANE])
|
|
SET_VEHICLE_INTERIORLIGHT(planeFightVehicle[PFV_CARGO_PLANE], FALSE)
|
|
ENDIF
|
|
|
|
IF IS_VEHICLE_DRIVEABLE(planeFightVehicle[PFV_TREVOR_PLANE])
|
|
IF NOT IS_PED_IN_VEHICLE(PLAYER_PED_ID(), planeFightVehicle[PFV_TREVOR_PLANE])
|
|
SET_PED_INTO_VEHICLE(PLAYER_PED_ID(), planeFightVehicle[PFV_TREVOR_PLANE])
|
|
ENDIF
|
|
SET_VEHICLE_ENGINE_ON(planeFightVehicle[PFV_TREVOR_PLANE], TRUE, TRUE)
|
|
SET_HELI_BLADES_FULL_SPEED (planeFightVehicle[PFV_TREVOR_PLANE])
|
|
SET_VEHICLE_FORWARD_SPEED(planeFightVehicle[PFV_TREVOR_PLANE], 55.0)
|
|
//START_PLAYBACK_RECORDED_VEHICLE(planeFightVehicle[PFV_TREVOR_PLANE], 002, GET_PLANE_FIGHT_RECORDING_PREFIX())
|
|
//SKIP_TIME_IN_PLAYBACK_RECORDED_VEHICLE(planeFightVehicle[PFV_TREVOR_PLANE], GET_TIME_POSITION_IN_RECORDING(planeFightVehicle[PFV_CARGO_PLANE]) - DUSTER_BEHIND_TIME)
|
|
//FORCE_PLAYBACK_RECORDED_VEHICLE_UPDATE(planeFightVehicle[PFV_TREVOR_PLANE])
|
|
ENDIF
|
|
iGetInTextStage = 2
|
|
|
|
ADD_PED_FOR_DIALOGUE(planeFightConversation, 3, NULL, "NervousRon")
|
|
TRIGGER_MISSION_MUSIC_EVENT("EXL1_RELOAD_ENTER_CARGO")
|
|
ELSE
|
|
DO_POPULATE_PLANE_AND_OPEN_DOOR()
|
|
//bShownGodText = TRUE
|
|
ENDIF
|
|
|
|
IF IS_VEHICLE_DRIVEABLE(planeFightVehicle[PFV_TREVOR_PLANE])
|
|
CLEAR_ENTITY_LAST_WEAPON_DAMAGE(planeFightVehicle[PFV_TREVOR_PLANE])
|
|
ENDIF
|
|
|
|
CREATE_RAMP_PEDS(TRUE)
|
|
iOpenDoorTime = GET_GAME_TIMER()
|
|
BREAK
|
|
CASE STAGE_PLANE_FIGHT
|
|
IF DOES_ENTITY_EXIST(planeRootObject)
|
|
DELETE_OBJECT(planeRootObject)
|
|
ENDIF
|
|
|
|
DISABLE_SCUFF_DECALS(TRUE)
|
|
|
|
STOP_STREAM()
|
|
SET_PLAYER_WANTED_LEVEL(PLAYER_ID(), 0)
|
|
SET_PLAYER_WANTED_LEVEL_NOW(PLAYER_ID())
|
|
CLEANUP_RON(TRUE)
|
|
IF bJumpingToStage
|
|
SET_CARGO_PLANE_FOR_INTERIOR_ACTION(STAGE_PLANE_FIGHT)
|
|
ENDIF
|
|
|
|
IF bJumpingToStage
|
|
WAIT(500)
|
|
ENDIF
|
|
|
|
IF NOT bJumpingToStage
|
|
DO_SMOKE_ON_PLANE(PLANE_SMOKE_CRASH_SMOKE_R1)
|
|
ENDIF
|
|
|
|
IF IS_VEHICLE_DRIVEABLE(planeFightVehicle[PFV_CARGO_PLANE])
|
|
SET_ENTITY_VISIBLE(planeFightVehicle[PFV_CARGO_PLANE], TRUE)
|
|
SET_VEHICLE_INTERIORLIGHT(planeFightVehicle[PFV_CARGO_PLANE], TRUE)
|
|
SET_ENTITY_NOWEAPONDECALS(planeFightVehicle[PFV_CARGO_PLANE], TRUE)
|
|
ENDIF
|
|
|
|
IF bJumpingToStage
|
|
SETUP_SHOOTOUT()
|
|
ENDIF
|
|
|
|
IF bJumpingToStage
|
|
g_bExile1DestroyedEscapeVehicle = FALSE
|
|
POPULATE_PLANE_INTERIOR(TRUE, TRUE, TRUE, TRUE)
|
|
SET_LIGHT_RIG_ON_CARGO_PLANE(TRUE)
|
|
SET_DAMAGE_FX_ON_CARGO_PLANE(TRUE)
|
|
ADD_PED_FOR_DIALOGUE(planeFightConversation, 4, NULL, "MERCPLANE")
|
|
ELSE
|
|
|
|
//DETACH_ALL_TRANSPORTED_VEHICLES_AND_COVER()
|
|
g_bExile1DestroyedEscapeVehicle = FALSE
|
|
//POPULATE_PLANE_INTERIOR(FALSE, TRUE, TRUE, TRUE)
|
|
ENDIF
|
|
// INFORM_MISSION_STATS_OF_FINANCIAL_DAMAGE(500000) // temp - move this?
|
|
|
|
IF bJumpingToStage
|
|
IF NOT IS_PED_INJURED(PLAYER_PED_ID())
|
|
SET_ENTITY_COORDS(PLAYER_PED_ID(), GET_PLANE_OFFSET_IN_WORLD_COORDS(GET_PLANE_FIGHT_VECTOR(PFVEC_TREVOR_INSIDE_PLANE_INIT)), TRUE, NOT bJumpingToStage)
|
|
SET_ENTITY_HEADING(PLAYER_PED_ID(), GET_ENTITY_HEADING(planeFightVehicle[PFV_CARGO_PLANE]) - 90)
|
|
//SET_PED_CAN_RAGDOLL(PLAYER_PED_ID(), FALSE) // temp
|
|
//SET_GAMEPLAY_CAM_RELATIVE_HEADING()
|
|
ENDIF
|
|
ENDIF
|
|
|
|
//PRINT_NOW("PF_KILL", DEFAULT_GOD_TEXT_TIME, 1)
|
|
EQUIP_BEST_PLAYER_WEAPON(TRUE)
|
|
SET_CARGO_PLANE_CREW_OUT_OF_SEATS()
|
|
|
|
SET_NEXT_RANDOM_SPEECH_TIME(14000)
|
|
//SET_PLAYER_CONTROL(PLAYER_ID(), FALSE, SPC_LEAVE_CAMERA_CONTROL_ON)
|
|
|
|
SPECIAL_ABILITY_FILL_METER(PLAYER_ID(), TRUE)
|
|
//IF bJumpingToStage
|
|
//WAIT(1200)
|
|
//PUT_TREVOR_INTO_COVER()
|
|
//bForcedDuck = TRUE
|
|
//ELSE
|
|
IF bJumpingToStage
|
|
PUT_TREVOR_INTO_COVER()
|
|
SET_GAMEPLAY_CAM_RELATIVE_HEADING(90.0)
|
|
SET_GAMEPLAY_CAM_RELATIVE_PITCH(0.0)
|
|
ENDIF
|
|
//ENDIF
|
|
|
|
IF bJumpingToStage
|
|
WAIT(500)
|
|
ENDIF
|
|
|
|
IF bJumpingToStage
|
|
TRIGGER_MISSION_MUSIC_EVENT("EXL1_RELOAD_FIGHT_BEGINS")
|
|
ELSE
|
|
TRIGGER_MISSION_MUSIC_EVENT("EXL1_FIGHT_BEGINS")
|
|
ENDIF
|
|
START_PLANE_FIGHT_AUDIO_SCENE(PLANE_FIGHT_AUDIO_SCENE_SHOOTOUT_CARGO_HOLD)
|
|
|
|
iStartFightTime = GET_GAME_TIMER()
|
|
BREAK
|
|
CASE STAGE_FLY_PLANE
|
|
STOP_STREAM()
|
|
CREATE_PLANE_ROOT()
|
|
SET_LIGHT_RIG_ON_CARGO_PLANE(FALSE)
|
|
SET_RADAR_ZOOM_PRECISE(0.0)
|
|
|
|
SET_WAYPOINT_OFF()
|
|
|
|
DISABLE_SCUFF_DECALS(TRUE)
|
|
|
|
IF IS_VEHICLE_DRIVEABLE(planeFightVehicle[PFV_CARGO_PLANE])
|
|
IF NOT IS_PED_IN_VEHICLE(PLAYER_PED_ID(), planeFightVehicle[PFV_CARGO_PLANE])
|
|
SET_PED_INTO_VEHICLE(PLAYER_PED_ID(), planeFightVehicle[PFV_CARGO_PLANE])
|
|
ENDIF
|
|
SET_VEHICLE_PROVIDES_COVER(planeFightVehicle[PFV_CARGO_PLANE], FALSE)
|
|
SET_VEHICLE_INACTIVE_DURING_PLAYBACK(planeFightVehicle[PFV_CARGO_PLANE], FALSE)
|
|
SET_VEHICLE_FIXED(planeFightVehicle[PFV_CARGO_PLANE])
|
|
SET_VEHICLE_DOOR_BROKEN(planeFightVehicle[PFV_CARGO_PLANE], SC_DOOR_REAR_LEFT, TRUE)
|
|
SET_PARTICLE_FX_CAM_INSIDE_NONPLAYER_VEHICLE(planeFightVehicle[PFV_CARGO_PLANE], FALSE)
|
|
|
|
SET_VEHICLE_INTERIORLIGHT(planeFightVehicle[PFV_CARGO_PLANE], FALSE)
|
|
SET_ENTITY_NOWEAPONDECALS(planeFightVehicle[PFV_CARGO_PLANE], TRUE)
|
|
ENDIF
|
|
|
|
IF bJumpingToStage
|
|
POPULATE_PLANE_INTERIOR(TRUE, FALSE, TRUE, FALSE, TRUE)
|
|
DELETE_ALL_COVER_OBJECTS(FALSE)
|
|
ENDIF
|
|
|
|
PROOF_TRANSPORTED_VEHICLES(TRUE)
|
|
|
|
SET_VEHICLE_CONVERSATIONS_PERSIST(FALSE, TRUE)
|
|
|
|
SETUP_JUMP_TO_ESCAPE()
|
|
ADD_PED_FOR_DIALOGUE(planeFightConversation, 3, NULL, "NervousRon")
|
|
SET_PLANE_ENGINE_ON(FALSE)
|
|
|
|
IF IS_VEHICLE_DRIVEABLE(planeFightVehicle[PFV_CARGO_PLANE])
|
|
SET_VEHICLE_DOORS_LOCKED(planeFightVehicle[PFV_CARGO_PLANE], VEHICLELOCK_LOCKED_PLAYER_INSIDE)
|
|
SET_VEHICLE_FORWARD_SPEED(planeFightVehicle[PFV_CARGO_PLANE], 55)
|
|
CONTROL_LANDING_GEAR(planeFightVehicle[PFV_CARGO_PLANE], LGC_RETRACT_INSTANT)
|
|
ENDIF
|
|
CLEAR_AREA(GET_PLANE_FIGHT_VECTOR(PFVEC_CARGO_PLANE_FLY), 100, TRUE)
|
|
//SET_CONTROL_SHAKE(PLAYER_CONTROL, 1000, PAD_SHAKE_AMPLITUDE)
|
|
//DO_MISSION_GAMEPLAY_CAM_SHAKE()
|
|
|
|
IF bJumpingToStage
|
|
TRIGGER_MISSION_MUSIC_EVENT("EXL1_RELOAD_FLY_CARGO")
|
|
ENDIF
|
|
STOP_PLANE_FIGHT_AUDIO_SCENE(PLANE_FIGHT_AUDIO_SCENE_HIJACK_THE_PLANE)
|
|
START_PLANE_FIGHT_AUDIO_SCENE(PLANE_FIGHT_AUDIO_SCENE_FLY_CARGO_PLANE)
|
|
|
|
iNextRandomSpeechTime = GET_GAME_TIMER() + 8000
|
|
iFlightTime = GET_GAME_TIMER()
|
|
getToBlip = CREATE_MISSION_BLIP_FOR_COORD(GET_PLANE_FIGHT_VECTOR(PFVEC_RUNWAY))
|
|
SET_GAMEPLAY_CAM_RELATIVE_HEADING(0.0)
|
|
BREAK
|
|
CASE STAGE_ESCAPE_PLANE
|
|
INFORM_MISSION_STATS_SYSTEM_OF_ACTION_CAM_END()
|
|
|
|
STOP_PLANE_FIGHT_AUDIO_SCENE(PLANE_FIGHT_AUDIO_SCENE_FLY_CARGO_PLANE)
|
|
STOP_PLANE_FIGHT_AUDIO_SCENE(PLANE_FIGHT_AUDIO_SCENE_FIGHTER_JETS_ARRIVE)
|
|
|
|
IF bJumpingToStage
|
|
PRELOAD_PARACHUTE(TRUE)
|
|
ENDIF
|
|
|
|
DISABLE_SCUFF_DECALS(TRUE)
|
|
|
|
// delete jets
|
|
INT i
|
|
REPEAT NUMBER_JETS i
|
|
IF DOES_ENTITY_EXIST(jetData[i].ped)
|
|
DELETE_PED(jetData[i].ped)
|
|
ENDIF
|
|
IF DOES_ENTITY_EXIST(jetData[i].veh)
|
|
DELETE_VEHICLE(jetData[i].veh)
|
|
ENDIF
|
|
ENDREPEAT
|
|
REPEAT NUMBER_MISSILES i
|
|
IF DOES_ENTITY_EXIST(jetMissile[i].obj)
|
|
DELETE_OBJECT(jetMissile[i].obj)
|
|
ENDIF
|
|
IF DOES_PARTICLE_FX_LOOPED_EXIST(jetMissile[i].ptfx)
|
|
REMOVE_PARTICLE_FX(jetMissile[i].ptfx)
|
|
ENDIF
|
|
ENDREPEAT
|
|
|
|
SET_VEHICLE_CONVERSATIONS_PERSIST(FALSE, FALSE)
|
|
|
|
IF IS_VEHICLE_DRIVEABLE(planeFightVehicle[PFV_CARGO_PLANE])
|
|
SET_PARTICLE_FX_CAM_INSIDE_NONPLAYER_VEHICLE(planeFightVehicle[PFV_CARGO_PLANE], TRUE)
|
|
SET_VEHICLE_DOORS_LOCKED(planeFightVehicle[PFV_CARGO_PLANE], VEHICLELOCK_LOCKED)
|
|
SET_VEHICLE_INTERIORLIGHT(planeFightVehicle[PFV_CARGO_PLANE], TRUE)
|
|
SET_ENTITY_NOWEAPONDECALS(planeFightVehicle[PFV_CARGO_PLANE], TRUE)
|
|
ENDIF
|
|
|
|
IF NOT bForcePassOnShitskip
|
|
//DETACH_ALL_TRANSPORTED_VEHICLES_AND_COVER()
|
|
|
|
SET_CARGO_PLANE_FOR_INTERIOR_ACTION(STAGE_ESCAPE_PLANE)
|
|
|
|
IF bJumpingToStage
|
|
WAIT(500)
|
|
ENDIF
|
|
|
|
IF IS_VEHICLE_DRIVEABLE(planeFightVehicle[PFV_CARGO_PLANE])
|
|
SET_VEHICLE_INACTIVE_DURING_PLAYBACK(planeFightVehicle[PFV_CARGO_PLANE], TRUE)
|
|
ENDIF
|
|
|
|
RESET_FLIGHT_TARGET_DATA_FOR_STAGE(STAGE_ESCAPE_PLANE)
|
|
RESET_PLANE_MOVEMENT_DATA_FROM_TARGET_DATA()
|
|
|
|
//DO_SMOKE_ON_PLANE(PLANE_SMOKE_CLOUDS)
|
|
//STOP_SMOKE_ON_PLANE(PLANE_SMOKE_FIRE_REAR_MOVING)
|
|
|
|
STOP_SMOKE_ON_PLANE(PLANE_SMOKE_CRASH_SMOKE_FLIGHT)
|
|
STOP_SMOKE_ON_PLANE(PLANE_SMOKE_ENGINE_FIRE)
|
|
|
|
UPDATE_PLANE_PHYSICAL_MOVEMENT()
|
|
WAIT(0)
|
|
IF bJumpingToStage
|
|
POPULATE_PLANE_INTERIOR(TRUE, FALSE, TRUE, FALSE, FALSE)
|
|
//KILL_ALL_ENEMY_PEDS()
|
|
ENDIF
|
|
|
|
IF NOT bJumpingToStage
|
|
DO_SMOKE_ON_PLANE(PLANE_SMOKE_CRASH_SMOKE_R1)
|
|
DO_SMOKE_ON_PLANE(PLANE_SMOKE_ENGINE_FIRE)
|
|
ENDIF
|
|
|
|
DELETE_ALL_COVER_OBJECTS(TRUE)
|
|
SETUP_JUMP_TO_ESCAPE()
|
|
PROOF_TRANSPORTED_VEHICLES(FALSE)
|
|
|
|
iFlightIntensityStage = 3
|
|
iFlightSubstage = 1
|
|
|
|
IF NOT bJumpingToStage
|
|
SET_PLANE_ENGINE_ON(TRUE)
|
|
ENDIF
|
|
|
|
ATTACH_TRANSPORTED_VEHICLES(FALSE)
|
|
CREATE_DEBRIS_OBJECTS()
|
|
SET_LIGHT_RIG_ON_CARGO_PLANE(TRUE)
|
|
|
|
HANG_UP_AND_PUT_AWAY_PHONE()
|
|
TURN_OFF_KLAXON()
|
|
|
|
//DO_SMOKE_ON_PLANE(PLANE_SMOKE_HOLD_WIRES_1)
|
|
//DO_SMOKE_ON_PLANE(PLANE_SMOKE_HOLD_WIRES_2)
|
|
|
|
//GIVE_PED_A_PARACHUTE(PLAYER_PED_ID())
|
|
//DISABLE_OPEN_PARACHUTE(TRUE)
|
|
//DISABLE_PARACHUTE_PED_UPDATES(PLAYER_PED_ID(), TRUE)
|
|
ELSE
|
|
CLEAR_MISSION_FOR_SKIP()
|
|
REMOVE_MISSION_TEXT()
|
|
bDoneOutOfPlane = TRUE
|
|
bAtSafety = TRUE
|
|
iGotSafetyTime = GET_GAME_TIMER() - 1500
|
|
ENDIF
|
|
|
|
|
|
// setup Ron for phone call
|
|
ADD_PED_FOR_DIALOGUE(planeFightConversation, 3, NULL, "NervousRon")
|
|
|
|
SET_CURRENT_PED_WEAPON(PLAYER_PED_ID(), WEAPONTYPE_UNARMED, TRUE)
|
|
|
|
IF NOT bForcePassOnShitskip
|
|
SET_GAMEPLAY_CAM_RELATIVE_HEADING(0.0)
|
|
SET_GAMEPLAY_CAM_RELATIVE_PITCH(20.0)
|
|
ENDIF
|
|
|
|
IF bJumpingToStage
|
|
// WAIT(500)
|
|
ENDIF
|
|
|
|
IF NOT bForcePassOnShitskip
|
|
IF bJumpingToStage
|
|
TRIGGER_MISSION_MUSIC_EVENT("EXL1_RELOAD_ESCAPE_CARGO")
|
|
ELSE
|
|
TRIGGER_MISSION_MUSIC_EVENT("EXL1_READY_TO_JUMP")
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF NOT bForcePassOnShitSkip
|
|
STOP_PLANE_FIGHT_AUDIO_SCENE(PLANE_FIGHT_AUDIO_SCENE_ROCKETS_FIRED)
|
|
STOP_PLANE_FIGHT_AUDIO_SCENE(PLANE_FIGHT_AUDIO_SCENE_PLANE_GOING_DOWN)
|
|
START_PLANE_FIGHT_AUDIO_SCENE(PLANE_FIGHT_AUDIO_SCENE_ESCAPE_ON_FOOT)
|
|
ENDIF
|
|
|
|
PLAY_SOUND_FROM_COORD(iTransitionSoundID, "Transition_Sound", <<1903.29, 4085.20, 1462.66>>, "EXILE_1")
|
|
|
|
SET_NEXT_RANDOM_SPEECH_TIME(8000)
|
|
iStartEscapeTime = GET_GAME_TIMER()
|
|
BREAK
|
|
ENDSWITCH
|
|
|
|
SET_VEHICLE_POPULATION_BUDGET(3)
|
|
SET_PED_POPULATION_BUDGET(3)
|
|
|
|
// instance priority
|
|
IF setStage = STAGE_PLANE_FIGHT
|
|
SET_INSTANCE_PRIORITY_HINT(INSTANCE_HINT_SHOOTING)
|
|
ELSE
|
|
SET_INSTANCE_PRIORITY_HINT(INSTANCE_HINT_NONE)
|
|
ENDIF
|
|
|
|
// set wanted level
|
|
IF setStage <= STAGE_ENTER_PLANE
|
|
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
|
|
|
|
// taxi
|
|
IF setStage > STAGE_GET_TO_AIRSTRIP
|
|
DISABLE_TAXI_HAILING(TRUE)
|
|
ELSE
|
|
DISABLE_TAXI_HAILING(FALSE)
|
|
ENDIF
|
|
|
|
// should we disable the military base
|
|
IF setStage = STAGE_GET_TO_AIRSTRIP
|
|
RELEASE_SUPPRESSED_RESTRICTED_AREA_WANTED_LEVEL(AC_MILITARY_BASE)
|
|
ELSE
|
|
SUPPRESS_RESTRICTED_AREA_WANTED_LEVEL(AC_MILITARY_BASE)
|
|
ENDIF
|
|
|
|
// damage stat
|
|
IF NOT IS_PED_INJURED(PLAYER_PED_ID())
|
|
INFORM_MISSION_STATS_OF_DAMAGE_WATCH_ENTITY(PLAYER_PED_ID())
|
|
ENDIF
|
|
|
|
SET_PED_CAPSULE(PLAYER_PED_ID(), 0.0)
|
|
CLEAR_GPS_FLAGS()
|
|
|
|
IF bJumpingToStage
|
|
IF ENUM_TO_INT(setStage) > 0
|
|
IF setStage <> STAGE_PLANE_FIGHT
|
|
SET_GAMEPLAY_CAM_RELATIVE_HEADING(0.0)
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
|
|
// weapon damage mod
|
|
RESET_AI_WEAPON_DAMAGE_MODIFIER()
|
|
|
|
// set value for replay
|
|
BOOL bFinalCheckpoint = FALSE
|
|
IF ENUM_TO_INT(setStage) >= ENUM_TO_INT(STAGE_ESCAPE_PLANE)
|
|
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, FALSE, NULL, setStage <> STAGE_FOLLOW_PLANE_1)
|
|
IF ENUM_TO_INT(setStage) <> 0
|
|
AND NOT bJumpingToStage
|
|
iReplayAttempt = 0
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF bJumpingToStage
|
|
WHILE IS_SCREEN_FADING_OUT()
|
|
WAIT(0)
|
|
ENDWHILE
|
|
|
|
IF NOT bSuppressFutureReplaySetups
|
|
IF IS_REPLAY_IN_PROGRESS()
|
|
IF IS_REPLAY_BEING_SET_UP()
|
|
|
|
VEHICLE_INDEX endReplayVehicle
|
|
SWITCH setStage
|
|
CASE STAGE_FOLLOW_PLANE_1
|
|
CASE STAGE_FOLLOW_PLANE_2
|
|
CASE STAGE_FOLLOW_PLANE_3
|
|
CASE STAGE_ENTER_PLANE
|
|
endReplayVehicle = planeFightVehicle[PFV_TREVOR_PLANE]
|
|
BREAK
|
|
CASE STAGE_FLY_PLANE
|
|
endReplayVehicle = planeFightVehicle[PFV_CARGO_PLANE]
|
|
BREAK
|
|
ENDSWITCH
|
|
|
|
BOOL bReturnControl = TRUE
|
|
IF setStage = STAGE_PLANE_FIGHT
|
|
OR setStage = STAGE_ESCAPE_PLANE
|
|
IF NOT bForcePassOnShitskip
|
|
bReturnControl = FALSE
|
|
ENDIF
|
|
ENDIF
|
|
|
|
END_REPLAY_SETUP(endReplayVehicle, VS_DRIVER, bReturnControl)
|
|
|
|
bSuppressFutureReplaySetups = TRUE
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
|
|
// post replay setup specific skip stuff
|
|
SWITCH setStage
|
|
CASE STAGE_FOLLOW_PLANE_1
|
|
SET_GAMEPLAY_CAM_RELATIVE_HEADING(0)
|
|
SET_GAMEPLAY_CAM_RELATIVE_PITCH(0)
|
|
BREAK
|
|
CASE STAGE_PLANE_FIGHT
|
|
WAIT(0)
|
|
DO_SMOKE_ON_PLANE(PLANE_SMOKE_CRASH_SMOKE_R1)
|
|
IF GET_FOLLOW_PED_CAM_VIEW_MODE() <> CAM_VIEW_MODE_FIRST_PERSON
|
|
OR GET_IS_USING_FPS_THIRD_PERSON_COVER()
|
|
SET_GAMEPLAY_CAM_RELATIVE_HEADING(90.0)
|
|
SET_GAMEPLAY_CAM_RELATIVE_PITCH(0.0)
|
|
ELSE
|
|
SET_GAMEPLAY_CAM_RELATIVE_HEADING(30.0)
|
|
SET_GAMEPLAY_CAM_RELATIVE_PITCH(8.4)
|
|
ENDIF
|
|
|
|
BREAK
|
|
CASE STAGE_FLY_PLANE
|
|
WAIT(0)
|
|
DO_SMOKE_ON_PLANE(PLANE_SMOKE_CRASH_SMOKE_FLIGHT)
|
|
INT iSmokeTimeOut
|
|
iSmokeTimeOut = GET_GAME_TIMER() + 1000
|
|
WHILE GET_GAME_TIMER() < iSmokeTimeOut
|
|
WAIT(0)
|
|
ENDWHILE
|
|
BREAK
|
|
CASE STAGE_ESCAPE_PLANE
|
|
WAIT(0)
|
|
DO_SMOKE_ON_PLANE(PLANE_SMOKE_CRASH_SMOKE_R1)
|
|
DO_SMOKE_ON_PLANE(PLANE_SMOKE_ENGINE_FIRE)
|
|
BREAK
|
|
ENDSWITCH
|
|
ENDIF
|
|
|
|
// after rest of setup common stuff
|
|
SWITCH setStage
|
|
CASE STAGE_GET_TO_AIRSTRIP
|
|
|
|
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, 1000)
|
|
ENDIF
|
|
BREAK
|
|
CASE STAGE_PLANE_FIGHT
|
|
IF NOT bJumpingToStage
|
|
IF GET_FOLLOW_PED_CAM_VIEW_MODE() = CAM_VIEW_MODE_FIRST_PERSON
|
|
AND NOT GET_IS_USING_FPS_THIRD_PERSON_COVER()
|
|
SET_PLAYER_CONTROL(PLAYER_ID(), TRUE)
|
|
SET_GAMEPLAY_CAM_RELATIVE_HEADING(30.0)
|
|
SET_GAMEPLAY_CAM_RELATIVE_PITCH(8.4)
|
|
ENDIF
|
|
ENDIF
|
|
BREAK
|
|
CASE STAGE_ESCAPE_PLANE
|
|
IF NOT bForcePassOnShitskip
|
|
FREEZE_ENTITY_POSITION(PLAYER_PED_ID(), FALSE)
|
|
|
|
CLEAR_PED_TASKS_IMMEDIATELY(PLAYER_PED_ID())
|
|
SET_PED_CAN_RAGDOLL(PLAYER_PED_ID(), FALSE)
|
|
SET_ENTITY_COORDS(PLAYER_PED_ID(), GET_EXIT_COCKPIT_COORDS())
|
|
SET_ENTITY_HEADING(PLAYER_PED_ID(), GET_ENTITY_HEADING(planeFightVehicle[PFV_CARGO_PLANE]) - 180)
|
|
SET_PLAYER_CONTROL(PLAYER_ID(), FALSE)
|
|
|
|
GET_PLAYER_PARACHUTE_TINT_INDEX(PLAYER_ID(), iCacheParachuteTint)
|
|
SET_PLAYER_PARACHUTE_TINT_INDEX(PLAYER_ID(), 6)
|
|
GIVE_WEAPON_TO_PED(PLAYER_PED_ID(), GADGETTYPE_PARACHUTE, 1, TRUE, FALSE)
|
|
|
|
GIVE_TREVOR_PARACHUTE_BACKPACK()
|
|
SET_PED_RESET_FLAG(PLAYER_PED_ID(), PRF_DisableTakeOffParachutePack, TRUE)
|
|
IF GET_FOLLOW_PED_CAM_VIEW_MODE() <> CAM_VIEW_MODE_FIRST_PERSON
|
|
SET_PED_MIN_MOVE_BLEND_RATIO(PLAYER_PED_ID(), PEDMOVE_RUN)
|
|
FORCE_PED_MOTION_STATE(PLAYER_PED_ID(),MS_ON_FOOT_RUN,TRUE,FAUS_CUTSCENE_EXIT)
|
|
ELSE
|
|
FORCE_PED_MOTION_STATE(PLAYER_PED_ID(),MS_AIMING,TRUE,FAUS_CUTSCENE_EXIT)
|
|
SIMULATE_PLAYER_INPUT_GAIT(PLAYER_ID(), PEDMOVE_RUN, 500)
|
|
ENDIF
|
|
|
|
ENDIF
|
|
|
|
SET_GAMEPLAY_CAM_RELATIVE_HEADING(0)
|
|
BREAK
|
|
ENDSWITCH
|
|
|
|
IF bJumpingToStage
|
|
IF bHandleFadeIn
|
|
IF NOT bForcePassOnShitskip
|
|
IF IS_SCREEN_FADED_OUT()
|
|
PRINTSTRING("DO FADE IN!") PRINTNL()
|
|
DO_SCREEN_FADE_IN(DEFAULT_FADE_TIME)
|
|
ENDIF
|
|
ENDIF
|
|
ELSE
|
|
IF bForcePassOnShitskip
|
|
IF setStage = STAGE_ESCAPE_PLANE
|
|
DO_SCREEN_FADE_IN(DEFAULT_FADE_TIME)
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
|
|
iStageStartTime = GET_GAME_TIMER()
|
|
currentMissionStage = setStage
|
|
ENDPROC
|
|
|
|
// handle streaming mocap
|
|
PROC HANDLE_STREAMING_MOCAP(STRING sMocap, VECTOR vStreamPos, FLOAT fStreamInDistance, FLOAT fStreamOutDistance)
|
|
SWITCH mocapStreamingStage
|
|
CASE MOCAP_STREAMING_STAGE_REQUEST
|
|
IF IS_ENTITY_AT_COORD(PLAYER_PED_ID(), vStreamPos, <<fStreamInDistance, fStreamInDistance, fStreamInDistance>>)
|
|
REQUEST_CUTSCENE(sMocap)
|
|
mocapStreamingStage = MOCAP_STREAMING_STAGE_WAIT
|
|
ENDIF
|
|
BREAK
|
|
CASE MOCAP_STREAMING_STAGE_WAIT
|
|
IF HAS_CUTSCENE_LOADED()
|
|
mocapStreamingStage = MOCAP_STREAMING_STAGE_COMPLETE
|
|
ENDIF
|
|
BREAK
|
|
CASE MOCAP_STREAMING_STAGE_COMPLETE
|
|
IF NOT IS_ENTITY_AT_COORD(PLAYER_PED_ID(), vStreamPos, <<fStreamOutDistance, fStreamOutDistance, fStreamOutDistance>>)
|
|
REMOVE_CUTSCENE()
|
|
mocapStreamingStage = MOCAP_STREAMING_STAGE_REQUEST
|
|
ENDIF
|
|
BREAK
|
|
ENDSWITCH
|
|
ENDPROC
|
|
|
|
// should we start streaming for next mission stage?
|
|
FUNC BOOL SHOULD_START_STREAMING_FOR_NEXT_MISSION_STAGE()
|
|
SWITCH currentMissionStage
|
|
CASE STAGE_GET_TO_AIRSTRIP
|
|
IF bAtAirstrip
|
|
RETURN TRUE
|
|
ENDIF
|
|
BREAK
|
|
CASE STAGE_FOLLOW_PLANE_1
|
|
RETURN TRUE
|
|
BREAK
|
|
CASE STAGE_FOLLOW_PLANE_2
|
|
RETURN TRUE
|
|
BREAK
|
|
CASE STAGE_FOLLOW_PLANE_3
|
|
RETURN TRUE
|
|
BREAK
|
|
CASE STAGE_ENTER_PLANE
|
|
RETURN TRUE
|
|
BREAK
|
|
CASE STAGE_PLANE_FIGHT
|
|
IF iFlightIntensityStage >= 2
|
|
RETURN TRUE
|
|
ENDIF
|
|
BREAK
|
|
CASE STAGE_FLY_PLANE
|
|
RETURN TRUE
|
|
BREAK
|
|
CASE STAGE_ESCAPE_PLANE
|
|
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)
|
|
STOP_CUTSCENE()
|
|
WHILE NOT IS_SCREEN_FADED_OUT()
|
|
WAIT(0)
|
|
ENDWHILE
|
|
ENDIF
|
|
ENDPROC
|
|
#ENDIF
|
|
|
|
// common stuff to clear mission
|
|
PROC COMMON_MISSION_CLEAR()
|
|
IF IS_ENTITY_ATTACHED(PLAYER_PED_ID())
|
|
IF GET_PED_PARACHUTE_STATE(PLAYER_PED_ID()) = PPS_INVALID
|
|
IF GET_VEHICLE_PED_IS_USING(PLAYER_PED_ID()) = NULL
|
|
CLEAR_PED_TASKS(PLAYER_PED_ID())
|
|
DETACH_ENTITY(PLAYER_PED_ID())
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
//FORCE_RESET_PARACHUTE_PED(PLAYER_PED_ID())
|
|
KILL_CHASE_HINT_CAM(localChaseHintCamStruct)
|
|
|
|
TURN_OFF_KLAXON()
|
|
SET_PLANE_ENGINE_ON(FALSE)
|
|
DISPLAY_RADAR(TRUE)
|
|
DISPLAY_HUD(TRUE)
|
|
//SET_PED_CAN_RAGDOLL(PLAYER_PED_ID(), TRUE)
|
|
SET_PLAYER_CONTROL(PLAYER_ID(), TRUE)
|
|
SET_SCRIPTS_SAFE_FOR_CUTSCENE(FALSE)
|
|
RESET_MISSION_STATS_ENTITY_WATCH()
|
|
CLEAR_MISSION_FOR_SKIP()
|
|
ENDPROC
|
|
|
|
/// PURPOSE:
|
|
/// Handles the shitskip for this mission
|
|
/// RETURNS:
|
|
/// TRUE if the mission has just used a shitskip, false otherwise
|
|
FUNC BOOL HANDLE_MISSION_SHITSKIP()
|
|
// new shitskip system
|
|
IF IS_REPLAY_IN_PROGRESS()
|
|
IF g_bShitskipAccepted = TRUE
|
|
CPRINTLN(DEBUG_REPLAY, "Exile 1: starting shitskip")
|
|
// get next replay stage
|
|
MISSION_STAGE_ENUM nextReplayStage
|
|
//BOOL bPassMission = FALSE
|
|
SWITCH INT_TO_ENUM(MISSION_STAGE_ENUM, Get_Replay_Mid_Mission_Stage())
|
|
CASE STAGE_GET_TO_AIRSTRIP
|
|
nextReplayStage = STAGE_FOLLOW_PLANE_1
|
|
BREAK
|
|
CASE STAGE_FOLLOW_PLANE_1
|
|
nextReplayStage = STAGE_FOLLOW_PLANE_2
|
|
BREAK
|
|
CASE STAGE_FOLLOW_PLANE_2
|
|
nextReplayStage = STAGE_FOLLOW_PLANE_3
|
|
BREAK
|
|
CASE STAGE_FOLLOW_PLANE_3
|
|
nextReplayStage = STAGE_ENTER_PLANE
|
|
BREAK
|
|
CASE STAGE_ENTER_PLANE
|
|
nextReplayStage = STAGE_ENTER_PLANE
|
|
bForcePassOnShitskip = TRUE
|
|
BREAK
|
|
CASE STAGE_PLANE_FIGHT
|
|
nextReplayStage = STAGE_FLY_PLANE
|
|
BREAK
|
|
CASE STAGE_FLY_PLANE
|
|
nextReplayStage = STAGE_ESCAPE_PLANE
|
|
BREAK
|
|
CASE STAGE_ESCAPE_PLANE
|
|
nextReplayStage = STAGE_ESCAPE_PLANE
|
|
bForcePassOnShitskip = TRUE
|
|
BREAK
|
|
ENDSWITCH
|
|
|
|
// set the next mission stage nicely
|
|
COMMON_MISSION_CLEAR()
|
|
SET_MISSION_STAGE(nextReplayStage, TRUE, TRUE, TRUE, FALSE, TRUE, FALSE)
|
|
//IF nextReplayStage <> STAGE_ESCAPE_PLANE
|
|
// WAIT(SKIP_FADE_WAIT_TIME)
|
|
//ELSE
|
|
// iWaitTime = GET_GAME_TIMER()
|
|
// WHILE GET_GAME_TIMER() < iWaitTime + SKIP_FADE_WAIT_TIME
|
|
// WAIT(0)
|
|
// SET_PED_RESET_FLAG(PLAYER_PED_ID(), PRF_DisableTakeOffParachutePack, TRUE)
|
|
// ENDWHILE
|
|
//ENDIF
|
|
IF NOT bForcePassOnShitskip
|
|
DO_SCREEN_FADE_IN(DEFAULT_FADE_TIME)
|
|
ENDIF
|
|
|
|
RETURN TRUE // we did do a shitskip
|
|
ELSE
|
|
CPRINTLN(DEBUG_REPLAY, "Exile 1: no shitskip")
|
|
ENDIF
|
|
ENDIF
|
|
RETURN FALSE // did not do a shitskip
|
|
ENDFUNC
|
|
|
|
// do mission init start mission
|
|
PROC DO_MISSION_INIT_START_MISSION()
|
|
// remove franklin and model
|
|
IF DOES_ENTITY_EXIST(sSelectorPeds.pedID[SELECTOR_PED_FRANKLIN])
|
|
DELETE_PED(sSelectorPeds.pedID[SELECTOR_PED_FRANKLIN])
|
|
ENDIF
|
|
SET_MODEL_AS_NO_LONGER_NEEDED(GET_MODEL_FOR_PLANE_FIGHT_MODEL_ENUM(PFM_FRANKLIN))
|
|
|
|
//SET_PLAYER_OUT_OF_ANY_VEHICLE()
|
|
|
|
// relationships
|
|
ADD_RELATIONSHIP_GROUP("Enemy Group", enemyRelGroup)
|
|
SET_RELATIONSHIP_BETWEEN_GROUPS(ACQUAINTANCE_TYPE_PED_HATE, RELGROUPHASH_PLAYER, enemyRelGroup)
|
|
SET_RELATIONSHIP_BETWEEN_GROUPS(ACQUAINTANCE_TYPE_PED_HATE, enemyRelGroup, RELGROUPHASH_PLAYER)
|
|
|
|
// stats
|
|
//INFORM_MISSION_STATS_OF_MISSION_START_EXILE_ONE()
|
|
|
|
// get rid of streaming vol created in intro
|
|
//STREAMVOL_DELETE(trailerVolume)
|
|
SET_STREAMING(TRUE)
|
|
|
|
SET_PLAYER_CONTROL(PLAYER_ID(), TRUE)
|
|
|
|
IF NOT IS_PED_INJURED(PLAYER_PED_ID())
|
|
IF NOT Is_Replay_In_Progress()
|
|
// no replay - kick mission off normally
|
|
IF NOT WAS_CUTSCENE_SKIPPED()
|
|
AND NOT bSkippedCutscene
|
|
#IF IS_DEBUG_BUILD
|
|
IF iDebugStage >= 0
|
|
SET_MISSION_STAGE(INT_TO_ENUM(MISSION_STAGE_ENUM, iDebugStage), TRUE)
|
|
ELSE
|
|
#ENDIF
|
|
SET_MISSION_STAGE(STAGE_GET_TO_AIRSTRIP, FALSE, TRUE, FALSE, TRUE)
|
|
#IF IS_DEBUG_BUILD
|
|
ENDIF
|
|
#ENDIF
|
|
ELSE
|
|
CLEAR_START_AREA()
|
|
WAIT(0)
|
|
SET_MISSION_STAGE(STAGE_GET_TO_AIRSTRIP, TRUE, TRUE, TRUE, FALSE, TRUE, FALSE)
|
|
ENDIF
|
|
ELSE
|
|
IF HANDLE_MISSION_SHITSKIP()
|
|
CPRINTLN(DEBUG_REPLAY, "Exile 1: shitskip done")
|
|
ELSE
|
|
INT iReplayStage
|
|
iReplayStage = Get_Replay_Mid_Mission_Stage()
|
|
IF iReplayStage = 0
|
|
//POSITION_PLAYER_AT_MISSION_INIT()
|
|
SET_MISSION_STAGE(STAGE_GET_TO_AIRSTRIP, TRUE, TRUE, TRUE, FALSE, TRUE, FALSE)
|
|
ELSE
|
|
SET_MISSION_STAGE(INT_TO_ENUM(MISSION_STAGE_ENUM, iReplayStage), TRUE)
|
|
//IF INT_TO_ENUM(MISSION_STAGE_ENUM, iReplayStage) <> STAGE_ESCAPE_PLANE
|
|
//WAIT(SKIP_FADE_WAIT_TIME)
|
|
//ELSE
|
|
//iWaitTime = GET_GAME_TIMER()
|
|
//WHILE GET_GAME_TIMER() < iWaitTime + SKIP_FADE_WAIT_TIME
|
|
// WAIT(0)
|
|
// SET_PED_RESET_FLAG(PLAYER_PED_ID(), PRF_DisableTakeOffParachutePack, TRUE)
|
|
//ENDWHILE
|
|
//ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF NOT bForcePassOnShitskip
|
|
IF IS_SCREEN_FADED_OUT()
|
|
OR IS_SCREEN_FADING_OUT()
|
|
DO_SCREEN_FADE_IN(DEFAULT_FADE_TIME)
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
|
|
//UNPIN_INTERIOR(iTrailer)
|
|
//NEW_LOAD_SCENE_STOP()
|
|
|
|
missionInitStage = MISSION_INIT_DONE
|
|
ENDPROC
|
|
|
|
|
|
/*
|
|
///PURPOSE: Requests the interior at coords, then waits until it loads
|
|
PROC SAFE_REQUEST_INTERIOR_AT_COORDS(INTERIOR_INSTANCE_INDEX &storeInteriorIndex, VECTOR theseCoords, BOOL bWait)
|
|
storeInteriorIndex = GET_INTERIOR_AT_COORDS(theseCoords)
|
|
|
|
//IF NOT IS_INTERIOR_READY(storeInteriorIndex)
|
|
PIN_INTERIOR_IN_MEMORY(storeInteriorIndex)
|
|
IF bWait
|
|
WHILE NOT IS_INTERIOR_READY(storeInteriorIndex)
|
|
WAIT(0)
|
|
ENDWHILE
|
|
ENDIF
|
|
//ENDIF
|
|
ENDPROC
|
|
|
|
/// PURPOSE:
|
|
/// Loads a scene around a point used to the player
|
|
/// seeing the map stream in when starting a replay or debug skipping
|
|
/// PARAMS:
|
|
/// pos - the position to stream the scene around at
|
|
/// rad - the radius of the scene to load
|
|
//PROC LOAD_SCENE_CUT(VECTOR pos, FLOAT rad)
|
|
// NEW_LOAD_SCENE_START_SPHERE(pos, rad)
|
|
// INT i_load_scene_timer = GET_GAME_TIMER()
|
|
// WHILE (NOT IS_NEW_LOAD_SCENE_LOADED())
|
|
// AND (GET_GAME_TIMER() - i_load_scene_timer < 12000)
|
|
// WAIT(0)
|
|
// ENDWHILE
|
|
// NEW_LOAD_SCENE_STOP()
|
|
//ENDPROC
|
|
|
|
PROC CREATE_SCENE_LOAD_CUT(VECTOR pos, FLOAT rad, CUTSCENE_STREAMING_STATE state)
|
|
NEW_LOAD_SCENE_STOP()
|
|
NEW_LOAD_SCENE_START_SPHERE(pos, rad)
|
|
eCutStreamState = state
|
|
ENDPROC
|
|
|
|
PROC MANAGE_STREAMING_CUTSCENE(INT iTime)
|
|
SWITCH eCutStreamState
|
|
CASE CSS_TRAILER_EXT
|
|
CREATE_SCENE_LOAD_CUT(<< 1980.2294, 3803.2119, 31.7705 >>, 50, CSS_TRAILER_INT)
|
|
BREAK
|
|
CASE CSS_TRAILER_INT
|
|
IF iTime > 10000
|
|
SAFE_REQUEST_INTERIOR_AT_COORDS(iTrailer, << 1972.1216, 3817.7249, 32.4287 >>, FALSE)
|
|
eCutStreamState = CSS_EXT
|
|
ENDIF
|
|
BREAK
|
|
CASE CSS_EXT
|
|
IF iTime > 120000
|
|
CREATE_SCENE_LOAD_CUT(<< 1983.1040, 3824.7510, 31.4501 >>, 20, CSS_END)
|
|
ENDIF
|
|
BREAK
|
|
ENDSWITCH
|
|
ENDPROC
|
|
*/
|
|
|
|
|
|
PROC SET_VARIATIONS_FOR_INTRO_CUTSCENE()
|
|
CDEBUG3LN(DEBUG_MISSION, "SET_VARIATIONS_FOR_INTRO_CUTSCENE")
|
|
|
|
IF CAN_REQUEST_ASSETS_FOR_CUTSCENE_ENTITY()
|
|
SET_CUTSCENE_PED_OUTFIT("Michael", PLAYER_ZERO, OUTFIT_P0_DEFAULT)
|
|
SET_CUTSCENE_PED_OUTFIT("Trevor", PLAYER_TWO, OUTFIT_P2_TSHIRT_JEANS_1)
|
|
SET_CUTSCENE_PED_COMPONENT_VARIATION("Ron", PED_COMP_TORSO, 0,0)
|
|
SET_CUTSCENE_PED_PROP_VARIATION("Ron", ANCHOR_HEAD, 0, 0)
|
|
SET_CUTSCENE_PED_PROP_VARIATION("Ron", ANCHOR_EYES, 0, 0)
|
|
ENDIF
|
|
ENDPROC
|
|
|
|
ENUM EXILE1_SWITCH_CAM_STATE
|
|
SWITCH_CAM_IDLE,
|
|
SWITCH_CAM_START_SPLINE1,
|
|
SWITCH_CAM_PLAYING_SPLINE1,
|
|
SWITCH_CAM_START_CUTSCENE,
|
|
SWITCH_CAM_PLAYING_CUTSCENE_FIRST_FRAME,
|
|
SWITCH_CAM_PLAYING_CUTSCENE,
|
|
SWITCH_CAM_RETURN_TO_GAMEPLAY
|
|
ENDENUM
|
|
EXILE1_SWITCH_CAM_STATE eSwitchCamState = SWITCH_CAM_IDLE
|
|
|
|
SWITCH_CAM_STRUCT scsSwitchCam
|
|
|
|
STRING strSyncSceneAnimDict = "missexile1_cargoplaneleadinoutexile_1_intleadin"
|
|
STRING strAnimDictCamShake = "shake_cam_all@"
|
|
|
|
OBJECT_INDEX oiFranklinsCellPhone
|
|
OBJECT_INDEX oiMichaelsCellPhone
|
|
|
|
INT iSyncSceneFranklin = -1
|
|
INT iSyncSceneMichael = -1
|
|
|
|
VECTOR vFranklinSyncScenePos = <<-818.494, 178.903, 71.232>>
|
|
VECTOR vFranklinSyncSceneRot = <<0.0, 0.0, -4.680>>
|
|
|
|
VECTOR vMichaelSyncScenePos = <<1973.871, 3820.796, 33.042>>
|
|
VECTOR vMichaelSyncSceneRot = <<-0.000, 0.000, 43.560>>
|
|
|
|
FLOAT fFranklinCellShownPhase = 0.200
|
|
FLOAT fMichaelAnimStartedPhase = 0.1
|
|
FLOAT fSwitchConvo2StartPhase = 0.7
|
|
FLOAT fSwitchFX1StartPhase = 0.676
|
|
FLOAT fSwitchFX2StartPhase = 0.697
|
|
FLOAT fHitStartPhase = 0.676
|
|
|
|
BOOL bFranklinCellShown = FALSE
|
|
BOOL bMichaelAnimStarted = FALSE
|
|
BOOL bMichaelAnimUnpaused = FALSE
|
|
BOOL bSwitchConvo1Started = FALSE
|
|
BOOL bSwitchConvo2Started = FALSE
|
|
BOOL bWooshStarted = FALSE
|
|
BOOL bSwitchFX1Started = FALSE
|
|
BOOL bSwitchFX2Started = FALSE
|
|
BOOL bHitSound = FALSE
|
|
|
|
BOOL bCustomSwitchSRLRequested = FALSE
|
|
STRING strCustomSwitchSRL = "exile1_customswitch"
|
|
FLOAT fCustomSwitchSRLTime = -9999.0
|
|
|
|
PROC PIN_TRAILER_INTERIOR()
|
|
CDEBUG3LN(DEBUG_MISSION, "PIN_TRAILER_INTERIOR")
|
|
|
|
VECTOR vRoomPos = <<1974.7, 3819.7, 33.4>>
|
|
iiiTrailer = GET_INTERIOR_AT_COORDS_WITH_TYPE(vRoomPos, "v_trailer") //Int = "v_trailer", Room = "V_TrailerRm", Room = "V_TrailerBedRm"...
|
|
IF IS_VALID_INTERIOR(iiiTrailer)
|
|
CDEBUG3LN(DEBUG_MISSION, "Trailer Interior: ", NATIVE_TO_INT(iiiTrailer), " is valid.")
|
|
PIN_INTERIOR_IN_MEMORY(iiiTrailer)
|
|
IF IS_INTERIOR_READY(iiiTrailer)
|
|
CDEBUG3LN(DEBUG_MISSION, "Trailer Interior is ready...")
|
|
ENDIF
|
|
ELSE
|
|
CDEBUG3LN(DEBUG_MISSION, "Trailer Interior is NOT valid!!!")
|
|
ENDIF
|
|
|
|
ENDPROC
|
|
|
|
FUNC BOOL IS_TRAILER_INTERIOR_READY()
|
|
//CDEBUG3LN(DEBUG_MISSION, "IS_TRAILER_INTERIOR_READY")
|
|
|
|
IF IS_VALID_INTERIOR(iiiTrailer)
|
|
CDEBUG3LN(DEBUG_MISSION, "Trailer Interior: ", NATIVE_TO_INT(iiiTrailer), " is valid.")
|
|
IF IS_INTERIOR_READY(iiiTrailer)
|
|
CDEBUG3LN(DEBUG_MISSION, "Trailer Interior is ready...")
|
|
RETURN TRUE
|
|
ENDIF
|
|
ELSE
|
|
CDEBUG3LN(DEBUG_MISSION, "Trailer Interior is NOT valid!!!")
|
|
ENDIF
|
|
RETURN FALSE
|
|
ENDFUNC
|
|
|
|
PROC SETUP_MICHAEL(BOOL bWithAttachedPhone)
|
|
CDEBUG3LN(DEBUG_MISSION, "SETUP_MICHAEL")
|
|
|
|
VECTOR vPlayerPos = <<1975.3, 3820.5, 32.4>>
|
|
FLOAT fPlayerHeading = -150.0
|
|
|
|
CREATE_PLAYER_PED_ON_FOOT(sSelectorPeds.pedID[SELECTOR_PED_MICHAEL], CHAR_MICHAEL, vPlayerPos, fPlayerHeading)
|
|
IF NOT IS_PED_INJURED(sSelectorPeds.pedID[SELECTOR_PED_MICHAEL])
|
|
|
|
FREEZE_ENTITY_POSITION(sSelectorPeds.pedID[SELECTOR_PED_MICHAEL], TRUE)
|
|
SET_ENTITY_COLLISION(sSelectorPeds.pedID[SELECTOR_PED_MICHAEL], FALSE)
|
|
|
|
SET_BLOCKING_OF_NON_TEMPORARY_EVENTS(sSelectorPeds.pedID[SELECTOR_PED_MICHAEL], TRUE)
|
|
SET_PED_RELATIONSHIP_GROUP_HASH(sSelectorPeds.pedID[SELECTOR_PED_MICHAEL], RELGROUPHASH_PLAYER)
|
|
SET_ENTITY_LOAD_COLLISION_FLAG(sSelectorPeds.pedID[SELECTOR_PED_MICHAEL], TRUE)
|
|
|
|
SET_PED_COMP_ITEM_CURRENT_SP(sSelectorPeds.pedID[SELECTOR_PED_MICHAEL], COMP_TYPE_OUTFIT, OUTFIT_P0_DEFAULT, FALSE)
|
|
|
|
IF bWithAttachedPhone
|
|
|
|
VECTOR vCellphonePos = <<1975.3, 3820.5, 22.4>>
|
|
VECTOR vCellphoneAttachPos = <<0.0, 0.0, 0.0>>
|
|
VECTOR vCellphoneAttachRot = <<0.0, 0.0, 0.0>>
|
|
|
|
oiMichaelsCellPhone = CREATE_OBJECT_NO_OFFSET(PROP_PHONE_ING, vCellphonePos)
|
|
IF DOES_ENTITY_EXIST(oiMichaelsCellPhone)
|
|
IF NOT IS_ENTITY_DEAD(oiMichaelsCellPhone)
|
|
ATTACH_ENTITY_TO_ENTITY(oiMichaelsCellPhone, sSelectorPeds.pedID[SELECTOR_PED_MICHAEL], GET_PED_BONE_INDEX(sSelectorPeds.pedID[SELECTOR_PED_MICHAEL], BONETAG_PH_L_HAND), vCellphoneAttachPos, vCellphoneAttachRot)
|
|
ENDIF
|
|
ENDIF
|
|
|
|
ENDIF
|
|
ENDIF
|
|
|
|
ENDPROC
|
|
|
|
PROC SETUP_TREVOR()
|
|
CDEBUG3LN(DEBUG_MISSION, "SETUP_TREVOR")
|
|
|
|
VECTOR vTrevorPos = <<1969.8, 3818.4, 33.0>>
|
|
FLOAT fTrevorHeading = -60.0
|
|
|
|
CREATE_PLAYER_PED_ON_FOOT(sSelectorPeds.pedID[SELECTOR_PED_TREVOR], CHAR_TREVOR, vTrevorPos, fTrevorHeading)
|
|
IF NOT IS_PED_INJURED(sSelectorPeds.pedID[SELECTOR_PED_TREVOR])
|
|
SETUP_TREVOR_WITH_MISSION_OUTFIT(sSelectorPeds.pedID[SELECTOR_PED_TREVOR])
|
|
STORE_PLAYER_PED_VARIATIONS(sSelectorPeds.pedID[SELECTOR_PED_TREVOR], TRUE)
|
|
//FREEZE_ENTITY_POSITION(sSelectorPeds.pedID[SELECTOR_PED_TREVOR], TRUE)
|
|
//SET_ENTITY_VISIBLE(sSelectorPeds.pedID[SELECTOR_PED_TREVOR], FALSE)
|
|
ENDIF
|
|
ENDPROC
|
|
|
|
PROC START_FRANKLIN_ANIM()
|
|
CDEBUG3LN(DEBUG_MISSION, "START_FRANKLIN_ANIM")
|
|
|
|
IF DOES_ENTITY_EXIST(oiFranklinsCellPhone)
|
|
IF NOT IS_ENTITY_DEAD(oiFranklinsCellPhone)
|
|
DELETE_OBJECT(oiFranklinsCellPhone)
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF DOES_ENTITY_EXIST(PLAYER_PED_ID())
|
|
IF NOT IS_ENTITY_DEAD(PLAYER_PED_ID())
|
|
IF NOT IS_PED_INJURED(PLAYER_PED_ID())
|
|
|
|
iSyncSceneFranklin = CREATE_SYNCHRONIZED_SCENE(vFranklinSyncScenePos, vFranklinSyncSceneRot)
|
|
|
|
SET_CURRENT_PED_WEAPON(PLAYER_PED_ID(), WEAPONTYPE_UNARMED, TRUE)
|
|
CLEAR_PED_TASKS_IMMEDIATELY(PLAYER_PED_ID())
|
|
TASK_SYNCHRONIZED_SCENE(PLAYER_PED_ID(), iSyncSceneFranklin, strSyncSceneAnimDict, "Franklin_atHouse", INSTANT_BLEND_IN, INSTANT_BLEND_OUT, SYNCED_SCENE_DONT_INTERRUPT)
|
|
FORCE_PED_AI_AND_ANIMATION_UPDATE(PLAYER_PED_ID())
|
|
|
|
VECTOR vCellphonePos = <<-818.394, 178.903, 60.0>>
|
|
VECTOR vCellphoneAttachPos = <<0.0, 0.0, 0.0>>
|
|
VECTOR vCellphoneAttachRot = <<0.0, 0.0, 0.0>>
|
|
|
|
oiFranklinsCellPhone = CREATE_OBJECT(Prop_Phone_ING_03, vCellphonePos)
|
|
IF DOES_ENTITY_EXIST(oiFranklinsCellPhone)
|
|
ATTACH_ENTITY_TO_ENTITY(oiFranklinsCellPhone, PLAYER_PED_ID(), GET_PED_BONE_INDEX(PLAYER_PED_ID(), BONETAG_PH_R_HAND), vCellphoneAttachPos, vCellphoneAttachRot)
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
|
|
ENDPROC
|
|
|
|
PROC START_MICHAEL_ANIM()
|
|
CDEBUG3LN(DEBUG_MISSION, "START_MICHAEL_ANIM")
|
|
|
|
PED_INDEX piMichael
|
|
IF GET_CURRENT_PLAYER_PED_ENUM() = CHAR_MICHAEL
|
|
piMichael = PLAYER_PED_ID()
|
|
ELSE
|
|
piMichael = sSelectorPeds.pedID[SELECTOR_PED_MICHAEL]
|
|
ENDIF
|
|
|
|
IF DOES_ENTITY_EXIST(piMichael)
|
|
IF NOT IS_ENTITY_DEAD(piMichael)
|
|
IF NOT IS_PED_INJURED(piMichael)
|
|
|
|
iSyncSceneMichael = CREATE_SYNCHRONIZED_SCENE(vMichaelSyncScenePos, vMichaelSyncSceneRot)
|
|
|
|
FREEZE_ENTITY_POSITION(piMichael, FALSE)
|
|
SET_ENTITY_COLLISION(piMichael, FALSE)
|
|
SET_BLOCKING_OF_NON_TEMPORARY_EVENTS(piMichael, TRUE)
|
|
|
|
CLEAR_PED_TASKS(piMichael)
|
|
TASK_SYNCHRONIZED_SCENE(piMichael, iSyncSceneMichael, strSyncSceneAnimDict, "Michael_inTrailer", INSTANT_BLEND_IN, INSTANT_BLEND_OUT, SYNCED_SCENE_DONT_INTERRUPT, DEFAULT, DEFAULT, AIK_DISABLE_LEG_IK)
|
|
FORCE_PED_AI_AND_ANIMATION_UPDATE(piMichael)
|
|
SET_SYNCHRONIZED_SCENE_RATE(iSyncSceneMichael, 1.0)
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
|
|
ENDPROC
|
|
|
|
PROC SETUP_SPLINE_CAM_NODE_ARRAY(SWITCH_CAM_STRUCT &thisSwitchCam, PED_INDEX pi1, PED_INDEX pi2)
|
|
CDEBUG3LN(DEBUG_MISSION, "SETUP_SPLINE_CAM_NODE_ARRAY")
|
|
|
|
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 = <<-818.1516, 176.7675, 72.7135>>
|
|
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 = <<-4.2602, -0.0064, -48.9658>>
|
|
thisSwitchCam.nodes[0].bPointAtEntity = FALSE
|
|
thisSwitchCam.nodes[0].bPointAtOffsetIsRelative = FALSE
|
|
thisSwitchCam.nodes[0].bAttachOffsetIsRelative = FALSE
|
|
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_MEDIUM
|
|
thisSwitchCam.nodes[0].fNodeCamShake = 0.2000
|
|
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 = 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 = 2000
|
|
thisSwitchCam.nodes[1].vNodePos = <<-818.3190, 176.7892, 72.7218>>
|
|
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 = <<-3.6262, -0.0064, -51.0333>>
|
|
thisSwitchCam.nodes[1].bPointAtEntity = FALSE
|
|
thisSwitchCam.nodes[1].bPointAtOffsetIsRelative = FALSE
|
|
thisSwitchCam.nodes[1].bAttachOffsetIsRelative = FALSE
|
|
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.2000
|
|
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.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_WORLD_POS
|
|
thisSwitchCam.nodes[2].iForceCamPointAtEntityIndex = -1
|
|
thisSwitchCam.nodes[2].bIsGameplayCamCopy = FALSE
|
|
thisSwitchCam.nodes[2].iNodeTime = 6500
|
|
thisSwitchCam.nodes[2].vNodePos = <<-819.9017, 177.3299, 72.4137>>
|
|
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 = <<2.4320, -0.0064, -59.8801>>
|
|
thisSwitchCam.nodes[2].bPointAtEntity = FALSE
|
|
thisSwitchCam.nodes[2].bPointAtOffsetIsRelative = FALSE
|
|
thisSwitchCam.nodes[2].bAttachOffsetIsRelative = FALSE
|
|
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 = 0.0000
|
|
thisSwitchCam.nodes[2].NodeCamShakeType = CAM_SHAKE_MEDIUM
|
|
thisSwitchCam.nodes[2].fNodeCamShake = 0.2000
|
|
thisSwitchCam.nodes[2].iCamEaseType = 3
|
|
thisSwitchCam.nodes[2].fCamEaseScaler = 1.0
|
|
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_CAM_WORLD_POS
|
|
thisSwitchCam.nodes[3].iForceCamPointAtEntityIndex = -1
|
|
thisSwitchCam.nodes[3].bIsGameplayCamCopy = FALSE
|
|
thisSwitchCam.nodes[3].iNodeTime = 2200
|
|
thisSwitchCam.nodes[3].vNodePos = <<-820.1751, 177.1052, 71.8574>>
|
|
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 = <<-1.7255, -0.0064, -60.1440>>
|
|
thisSwitchCam.nodes[3].bPointAtEntity = FALSE
|
|
thisSwitchCam.nodes[3].bPointAtOffsetIsRelative = FALSE
|
|
thisSwitchCam.nodes[3].bAttachOffsetIsRelative = FALSE
|
|
thisSwitchCam.nodes[3].fNodeFOV = 45.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.2000
|
|
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 = 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.nodes[4].SwitchCamType = SWITCH_CAM_WORLD_POS
|
|
thisSwitchCam.nodes[4].iForceCamPointAtEntityIndex = -1
|
|
thisSwitchCam.nodes[4].bIsGameplayCamCopy = FALSE
|
|
thisSwitchCam.nodes[4].iNodeTime = 3700
|
|
thisSwitchCam.nodes[4].vNodePos = <<-820.1777, 177.1036, 71.7557>>
|
|
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 = <<-1.7255, -0.0064, -60.1440>>
|
|
thisSwitchCam.nodes[4].bPointAtEntity = FALSE
|
|
thisSwitchCam.nodes[4].bPointAtOffsetIsRelative = FALSE
|
|
thisSwitchCam.nodes[4].bAttachOffsetIsRelative = FALSE
|
|
thisSwitchCam.nodes[4].fNodeFOV = 45.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 = 0.0000
|
|
thisSwitchCam.nodes[4].NodeCamShakeType = CAM_SHAKE_MEDIUM
|
|
thisSwitchCam.nodes[4].fNodeCamShake = 0.2000
|
|
thisSwitchCam.nodes[4].iCamEaseType = 2
|
|
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 = 1.0000
|
|
thisSwitchCam.nodes[4].iTimeScaleEaseType = 2
|
|
thisSwitchCam.nodes[4].fTimeScaleEaseScaler = 1.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_WORLD_POS
|
|
thisSwitchCam.nodes[5].iForceCamPointAtEntityIndex = -1
|
|
thisSwitchCam.nodes[5].bIsGameplayCamCopy = FALSE
|
|
thisSwitchCam.nodes[5].iNodeTime = 600
|
|
thisSwitchCam.nodes[5].vNodePos = <<-820.1507, 177.1195, 72.8050>>
|
|
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.6181, 0.1296, -59.9780>>
|
|
thisSwitchCam.nodes[5].bPointAtEntity = FALSE
|
|
thisSwitchCam.nodes[5].bPointAtOffsetIsRelative = FALSE
|
|
thisSwitchCam.nodes[5].bAttachOffsetIsRelative = FALSE
|
|
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 = 0.3000
|
|
thisSwitchCam.nodes[5].NodeCamShakeType = CAM_SHAKE_MEDIUM
|
|
thisSwitchCam.nodes[5].fNodeCamShake = 0.2000
|
|
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 = 1.0000
|
|
thisSwitchCam.nodes[5].iTimeScaleEaseType = 0
|
|
thisSwitchCam.nodes[5].fTimeScaleEaseScaler = 0.0000
|
|
thisSwitchCam.nodes[5].bFlashEnabled = TRUE
|
|
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].bIsCamCutNode = TRUE
|
|
|
|
thisSwitchCam.nodes[7].SwitchCamType = SWITCH_CAM_WORLD_POS
|
|
thisSwitchCam.nodes[7].iForceCamPointAtEntityIndex = -1
|
|
thisSwitchCam.nodes[7].bIsGameplayCamCopy = FALSE
|
|
thisSwitchCam.nodes[7].iNodeTime = 0
|
|
thisSwitchCam.nodes[7].vNodePos = <<1976.2390, 3820.6760, 32.5522>>
|
|
thisSwitchCam.nodes[7].vWorldPosLookAt = <<0.0000, 0.0000, 0.0000>>
|
|
thisSwitchCam.nodes[7].fNodeOffsetDist = 0.0000
|
|
thisSwitchCam.nodes[7].fNodeVerticleOffset = 0.0000
|
|
thisSwitchCam.nodes[7].bAttachToOriginPed = FALSE
|
|
thisSwitchCam.nodes[7].vNodeDir = <<-5.6554, 0.0838, 87.4010>>
|
|
thisSwitchCam.nodes[7].bPointAtEntity = FALSE
|
|
thisSwitchCam.nodes[7].bPointAtOffsetIsRelative = FALSE
|
|
thisSwitchCam.nodes[7].bAttachOffsetIsRelative = FALSE
|
|
thisSwitchCam.nodes[7].fNodeFOV = 45.0000
|
|
thisSwitchCam.nodes[7].vClonedNodeOffset = <<0.0000, 0.0000, 0.0000>>
|
|
thisSwitchCam.nodes[7].iNodeToClone = 0
|
|
thisSwitchCam.nodes[7].NodeTimePostFX_Type = NO_EFFECT
|
|
thisSwitchCam.nodes[7].fNodeTimePostFXBlendTime = 0.0000
|
|
thisSwitchCam.nodes[7].fNodeTimePostFXTimeOffset = 0.0000
|
|
thisSwitchCam.nodes[7].fNodeMotionBlur = 0.5000
|
|
thisSwitchCam.nodes[7].NodeCamShakeType = CAM_SHAKE_MEDIUM
|
|
thisSwitchCam.nodes[7].fNodeCamShake = 0.2000
|
|
thisSwitchCam.nodes[7].iCamEaseType = 1
|
|
thisSwitchCam.nodes[7].fCamEaseScaler = 1.0000
|
|
thisSwitchCam.nodes[7].fCamNodeVelocityScale = 0.0000
|
|
thisSwitchCam.nodes[7].bCamEaseForceLinear = FALSE
|
|
thisSwitchCam.nodes[7].bCamEaseForceLevel = FALSE
|
|
thisSwitchCam.nodes[7].fTimeScale = 1.0000
|
|
thisSwitchCam.nodes[7].iTimeScaleEaseType = 0
|
|
thisSwitchCam.nodes[7].fTimeScaleEaseScaler = 0.0000
|
|
thisSwitchCam.nodes[7].bFlashEnabled = FALSE
|
|
thisSwitchCam.nodes[7].SCFE_FlashEffectUsed = SCFE_CODE_FLASH
|
|
thisSwitchCam.nodes[7].fMinExposure = 0.0000
|
|
thisSwitchCam.nodes[7].fMaxExposure = 0.0000
|
|
thisSwitchCam.nodes[7].iRampUpDuration = 0
|
|
thisSwitchCam.nodes[7].iRampDownDuration = 0
|
|
thisSwitchCam.nodes[7].iHoldDuration = 0
|
|
thisSwitchCam.nodes[7].fFlashNodePhaseOffset = 0.0000
|
|
thisSwitchCam.nodes[7].bIsLowDetailNode = FALSE
|
|
thisSwitchCam.nodes[7].bUseCustomDOF = FALSE
|
|
thisSwitchCam.nodes[7].NodeDOF_Info.fDOF_NearDOF = 0.0000
|
|
thisSwitchCam.nodes[7].NodeDOF_Info.fDOF_FarDOF = 0.0000
|
|
thisSwitchCam.nodes[7].NodeDOF_Info.fDOF_EffectStrength = 0.0000
|
|
|
|
thisSwitchCam.nodes[8].SwitchCamType = SWITCH_CAM_WORLD_POS
|
|
thisSwitchCam.nodes[8].iForceCamPointAtEntityIndex = -1
|
|
thisSwitchCam.nodes[8].bIsGameplayCamCopy = FALSE
|
|
thisSwitchCam.nodes[8].iNodeTime = 600
|
|
thisSwitchCam.nodes[8].vNodePos = <<1976.1722, 3820.6797, 33.2294>>
|
|
thisSwitchCam.nodes[8].vWorldPosLookAt = <<0.0000, 0.0000, 0.0000>>
|
|
thisSwitchCam.nodes[8].fNodeOffsetDist = 0.0000
|
|
thisSwitchCam.nodes[8].fNodeVerticleOffset = 0.0000
|
|
thisSwitchCam.nodes[8].bAttachToOriginPed = FALSE
|
|
thisSwitchCam.nodes[8].vNodeDir = <<-5.6609, 0.0878, 87.4019>>
|
|
thisSwitchCam.nodes[8].bPointAtEntity = FALSE
|
|
thisSwitchCam.nodes[8].bPointAtOffsetIsRelative = FALSE
|
|
thisSwitchCam.nodes[8].bAttachOffsetIsRelative = FALSE
|
|
thisSwitchCam.nodes[8].fNodeFOV = 45.0000
|
|
thisSwitchCam.nodes[8].vClonedNodeOffset = <<0.0000, 0.0000, 0.0000>>
|
|
thisSwitchCam.nodes[8].iNodeToClone = 0
|
|
thisSwitchCam.nodes[8].NodeTimePostFX_Type = NO_EFFECT
|
|
thisSwitchCam.nodes[8].fNodeTimePostFXBlendTime = 0.0000
|
|
thisSwitchCam.nodes[8].fNodeTimePostFXTimeOffset = 0.0000
|
|
thisSwitchCam.nodes[8].fNodeMotionBlur = 0.5000
|
|
thisSwitchCam.nodes[8].NodeCamShakeType = CAM_SHAKE_MEDIUM
|
|
thisSwitchCam.nodes[8].fNodeCamShake = 0.2000
|
|
thisSwitchCam.nodes[8].iCamEaseType = 0
|
|
thisSwitchCam.nodes[8].fCamEaseScaler = 0.0000
|
|
thisSwitchCam.nodes[8].fCamNodeVelocityScale = 0.670
|
|
thisSwitchCam.nodes[8].bCamEaseForceLinear = FALSE
|
|
thisSwitchCam.nodes[8].bCamEaseForceLevel = FALSE
|
|
thisSwitchCam.nodes[8].fTimeScale = 1.0000
|
|
thisSwitchCam.nodes[8].iTimeScaleEaseType = 0
|
|
thisSwitchCam.nodes[8].fTimeScaleEaseScaler = 0.0000
|
|
thisSwitchCam.nodes[8].bFlashEnabled = FALSE
|
|
thisSwitchCam.nodes[8].SCFE_FlashEffectUsed = SCFE_CODE_FLASH
|
|
thisSwitchCam.nodes[8].fMinExposure = 0.0000
|
|
thisSwitchCam.nodes[8].fMaxExposure = 0.0000
|
|
thisSwitchCam.nodes[8].iRampUpDuration = 0
|
|
thisSwitchCam.nodes[8].iRampDownDuration = 0
|
|
thisSwitchCam.nodes[8].iHoldDuration = 0
|
|
thisSwitchCam.nodes[8].fFlashNodePhaseOffset = 0.0000
|
|
thisSwitchCam.nodes[8].bIsLowDetailNode = FALSE
|
|
thisSwitchCam.nodes[8].bUseCustomDOF = FALSE
|
|
thisSwitchCam.nodes[8].NodeDOF_Info.fDOF_NearDOF = 0.0000
|
|
thisSwitchCam.nodes[8].NodeDOF_Info.fDOF_FarDOF = 0.0000
|
|
thisSwitchCam.nodes[8].NodeDOF_Info.fDOF_EffectStrength = 0.0000
|
|
|
|
thisSwitchCam.nodes[9].SwitchCamType = SWITCH_CAM_WORLD_POS
|
|
thisSwitchCam.nodes[9].iForceCamPointAtEntityIndex = -1
|
|
thisSwitchCam.nodes[9].bIsGameplayCamCopy = FALSE
|
|
thisSwitchCam.nodes[9].iNodeTime = 3700
|
|
thisSwitchCam.nodes[9].vNodePos = <<1976.1354, 3820.5784, 33.5507>>
|
|
thisSwitchCam.nodes[9].vWorldPosLookAt = <<0.0000, 0.0000, 0.0000>>
|
|
thisSwitchCam.nodes[9].fNodeOffsetDist = 0.0000
|
|
thisSwitchCam.nodes[9].fNodeVerticleOffset = 0.0000
|
|
thisSwitchCam.nodes[9].bAttachToOriginPed = FALSE
|
|
thisSwitchCam.nodes[9].vNodeDir = <<-5.6609, 0.0878, 87.4019>>
|
|
thisSwitchCam.nodes[9].bPointAtEntity = FALSE
|
|
thisSwitchCam.nodes[9].bPointAtOffsetIsRelative = FALSE
|
|
thisSwitchCam.nodes[9].bAttachOffsetIsRelative = FALSE
|
|
thisSwitchCam.nodes[9].fNodeFOV = 45.0000
|
|
thisSwitchCam.nodes[9].vClonedNodeOffset = <<0.0000, 0.0000, 0.0000>>
|
|
thisSwitchCam.nodes[9].iNodeToClone = 0
|
|
thisSwitchCam.nodes[9].NodeTimePostFX_Type = NO_EFFECT
|
|
thisSwitchCam.nodes[9].fNodeTimePostFXBlendTime = 0.0000
|
|
thisSwitchCam.nodes[9].fNodeTimePostFXTimeOffset = 0.0000
|
|
thisSwitchCam.nodes[9].fNodeMotionBlur = 0.3000
|
|
thisSwitchCam.nodes[9].NodeCamShakeType = CAM_SHAKE_MEDIUM
|
|
thisSwitchCam.nodes[9].fNodeCamShake = 0.2000
|
|
thisSwitchCam.nodes[9].iCamEaseType = 0
|
|
thisSwitchCam.nodes[9].fCamEaseScaler = 0.0000
|
|
thisSwitchCam.nodes[9].fCamNodeVelocityScale = 0.0000
|
|
thisSwitchCam.nodes[9].bCamEaseForceLinear = FALSE
|
|
thisSwitchCam.nodes[9].bCamEaseForceLevel = FALSE
|
|
thisSwitchCam.nodes[9].fTimeScale = 1.0000
|
|
thisSwitchCam.nodes[9].iTimeScaleEaseType = 0
|
|
thisSwitchCam.nodes[9].fTimeScaleEaseScaler = 0.0000
|
|
thisSwitchCam.nodes[9].bFlashEnabled = FALSE
|
|
thisSwitchCam.nodes[9].SCFE_FlashEffectUsed = SCFE_CODE_FLASH
|
|
thisSwitchCam.nodes[9].fMinExposure = 0.0000
|
|
thisSwitchCam.nodes[9].fMaxExposure = 0.0000
|
|
thisSwitchCam.nodes[9].iRampUpDuration = 0
|
|
thisSwitchCam.nodes[9].iRampDownDuration = 0
|
|
thisSwitchCam.nodes[9].iHoldDuration = 0
|
|
thisSwitchCam.nodes[9].fFlashNodePhaseOffset = 0.0000
|
|
thisSwitchCam.nodes[9].bIsLowDetailNode = FALSE
|
|
thisSwitchCam.nodes[9].bUseCustomDOF = FALSE
|
|
thisSwitchCam.nodes[9].NodeDOF_Info.fDOF_NearDOF = 0.0000
|
|
thisSwitchCam.nodes[9].NodeDOF_Info.fDOF_FarDOF = 0.0000
|
|
thisSwitchCam.nodes[9].NodeDOF_Info.fDOF_EffectStrength = 0.0000
|
|
|
|
thisSwitchCam.nodes[10].SwitchCamType = SWITCH_CAM_WORLD_POS
|
|
thisSwitchCam.nodes[10].iForceCamPointAtEntityIndex = -1
|
|
thisSwitchCam.nodes[10].bIsGameplayCamCopy = FALSE
|
|
thisSwitchCam.nodes[10].iNodeTime = 2000
|
|
thisSwitchCam.nodes[10].vNodePos = <<1976.0815, 3820.4841, 34.0510>>
|
|
thisSwitchCam.nodes[10].vWorldPosLookAt = <<0.0000, 0.0000, 0.0000>>
|
|
thisSwitchCam.nodes[10].fNodeOffsetDist = 0.0000
|
|
thisSwitchCam.nodes[10].fNodeVerticleOffset = 0.0000
|
|
thisSwitchCam.nodes[10].bAttachToOriginPed = FALSE
|
|
thisSwitchCam.nodes[10].vNodeDir = <<-4.9828, 0.0878, 87.4019>>
|
|
thisSwitchCam.nodes[10].bPointAtEntity = FALSE
|
|
thisSwitchCam.nodes[10].bPointAtOffsetIsRelative = FALSE
|
|
thisSwitchCam.nodes[10].bAttachOffsetIsRelative = FALSE
|
|
thisSwitchCam.nodes[10].fNodeFOV = 45.0000
|
|
thisSwitchCam.nodes[10].vClonedNodeOffset = <<0.0000, 0.0000, 0.0000>>
|
|
thisSwitchCam.nodes[10].iNodeToClone = 0
|
|
thisSwitchCam.nodes[10].NodeTimePostFX_Type = NO_EFFECT
|
|
thisSwitchCam.nodes[10].fNodeTimePostFXBlendTime = 0.0000
|
|
thisSwitchCam.nodes[10].fNodeTimePostFXTimeOffset = 0.0000
|
|
thisSwitchCam.nodes[10].fNodeMotionBlur = 0.0000
|
|
thisSwitchCam.nodes[10].NodeCamShakeType = CAM_SHAKE_MEDIUM
|
|
thisSwitchCam.nodes[10].fNodeCamShake = 0.2000
|
|
thisSwitchCam.nodes[10].iCamEaseType = 0
|
|
thisSwitchCam.nodes[10].fCamEaseScaler = 0.0000
|
|
thisSwitchCam.nodes[10].fCamNodeVelocityScale = 0.0000
|
|
thisSwitchCam.nodes[10].bCamEaseForceLinear = FALSE
|
|
thisSwitchCam.nodes[10].bCamEaseForceLevel = FALSE
|
|
thisSwitchCam.nodes[10].fTimeScale = 1.0000
|
|
thisSwitchCam.nodes[10].iTimeScaleEaseType = 0
|
|
thisSwitchCam.nodes[10].fTimeScaleEaseScaler = 0.0000
|
|
thisSwitchCam.nodes[10].bFlashEnabled = FALSE
|
|
thisSwitchCam.nodes[10].SCFE_FlashEffectUsed = SCFE_CODE_FLASH
|
|
thisSwitchCam.nodes[10].fMinExposure = 0.0000
|
|
thisSwitchCam.nodes[10].fMaxExposure = 0.0000
|
|
thisSwitchCam.nodes[10].iRampUpDuration = 0
|
|
thisSwitchCam.nodes[10].iRampDownDuration = 0
|
|
thisSwitchCam.nodes[10].iHoldDuration = 0
|
|
thisSwitchCam.nodes[10].fFlashNodePhaseOffset = 0.0000
|
|
thisSwitchCam.nodes[10].bIsLowDetailNode = FALSE
|
|
thisSwitchCam.nodes[10].bUseCustomDOF = FALSE
|
|
thisSwitchCam.nodes[10].NodeDOF_Info.fDOF_NearDOF = 0.0000
|
|
thisSwitchCam.nodes[10].NodeDOF_Info.fDOF_FarDOF = 0.0000
|
|
thisSwitchCam.nodes[10].NodeDOF_Info.fDOF_EffectStrength = 0.0000
|
|
|
|
|
|
|
|
thisSwitchCam.iNumNodes = 11
|
|
thisSwitchCam.iCamSwitchFocusNode = 6
|
|
thisSwitchCam.fSwitchSoundAudioStartPhase = -1.0000
|
|
thisSwitchCam.fSwitchSoundAudioEndPhase = -1.0000
|
|
thisSwitchCam.bSplineNoSmoothing = TRUE
|
|
thisSwitchCam.bAddGameplayCamAsLastNode = FALSE
|
|
thisSwitchCam.iGameplayNodeBlendDuration = 0
|
|
|
|
|
|
//--- End of Cam Data ---
|
|
|
|
|
|
|
|
|
|
thisSwitchCam.strOutputStructName = "thisSwitchCam"
|
|
thisSwitchCam.strOutputFileName = "CameraInfo_Exile1_FranklinToMichael.txt"
|
|
thisSwitchCam.strXMLFileName = "CameraInfo_Exile1_FranklinToMichael.xml"
|
|
|
|
thisSwitchCam.bInitialized = TRUE
|
|
ENDIF
|
|
|
|
thisSwitchCam.piPeds[0] = pi1
|
|
thisSwitchCam.piPeds[1] = pi2
|
|
|
|
ENDPROC
|
|
|
|
FUNC BOOL HANDLE_SWITCH_CAM(SWITCH_CAM_STRUCT &thisSwitchCam)
|
|
|
|
INT iCurrentNode
|
|
FLOAT fCamPhase
|
|
|
|
SET_VEHICLE_DENSITY_MULTIPLIER_THIS_FRAME(0)
|
|
SET_PED_DENSITY_MULTIPLIER_THIS_FRAME(0)
|
|
|
|
SWITCH iFakeCellphoneState
|
|
CASE 0
|
|
DRAW_FAKE_CELLPHONE_SCREEN(fakeCellphoneData, TRUE, FAKE_CELLPHONE_SCREEN_BADGER_MENU)
|
|
BREAK
|
|
CASE 1
|
|
DRAW_FAKE_CELLPHONE_SCREEN(fakeCellphoneData, TRUE, FAKE_CELLPHONE_SCREEN_BADGER_CALL)
|
|
BREAK
|
|
CASE 2
|
|
DRAW_FAKE_CELLPHONE_SCREEN(fakeCellphoneData, TRUE, FAKE_CELLPHONE_SCREEN_GENERIC_CALL)
|
|
BREAK
|
|
ENDSWITCH
|
|
|
|
SWITCH eSwitchCamState
|
|
|
|
CASE SWITCH_CAM_IDLE
|
|
//CDEBUG3LN(DEBUG_MISSION, "eSwitchCamState = SWITCH_CAM_IDLE")
|
|
BREAK
|
|
|
|
CASE SWITCH_CAM_START_SPLINE1
|
|
CDEBUG3LN(DEBUG_MISSION, "eSwitchCamState = SWITCH_CAM_START_SPLINE1")
|
|
|
|
SET_SCRIPTS_SAFE_FOR_CUTSCENE(TRUE)
|
|
|
|
DESTROY_ALL_CAMS()
|
|
|
|
SETUP_SPLINE_CAM_NODE_ARRAY(thisSwitchCam, PLAYER_PED_ID(), sSelectorPeds.pedID[SELECTOR_PED_MICHAEL])
|
|
CREATE_SPLINE_CAM(thisSwitchCam)
|
|
|
|
SET_CAM_ACTIVE(thisSwitchCam.ciSpline, TRUE)
|
|
RENDER_SCRIPT_CAMS(TRUE, FALSE)
|
|
|
|
DISPLAY_RADAR(FALSE)
|
|
DISPLAY_HUD(FALSE)
|
|
|
|
RESOLVE_VEHICLES_INSIDE_ANGLED_AREA_WITH_SIZE_LIMIT(<<-816.459, 178.285, 76.232>>, <<-823.844, 175.655, 64.887>>, 8, <<-821.73596, 182.88571, 70.90462>>, -57.6, GET_DEFAULT_ALLOWABLE_VEHICLE_SIZE_VECTOR(), TRUE, FALSE, TRUE)
|
|
CLEAR_AREA_OF_PROJECTILES(<<-817.66711, 177.79582, 71.22737>>, 18)
|
|
STOP_FIRE_IN_RANGE(<<-817.66711, 177.79582, 71.22737>>, 18)
|
|
REMOVE_PARTICLE_FX_IN_RANGE(<<-817.66711, 177.79582, 71.22737>>, 18)
|
|
|
|
SET_VEHICLE_POPULATION_BUDGET(0)
|
|
SET_PED_POPULATION_BUDGET(0)
|
|
SET_ALL_VEHICLE_GENERATORS_ACTIVE_IN_AREA(<<-5000, -5000.0, -1000.0>>, <<5000, 5000.0, 1000.0>>, FALSE)
|
|
|
|
SET_GAME_PAUSES_FOR_STREAMING(FALSE)
|
|
|
|
SETUP_TREVOR()
|
|
SETUP_MICHAEL(TRUE)
|
|
|
|
PIN_TRAILER_INTERIOR()
|
|
|
|
//[SP] Replaced with an SRL
|
|
//trailerStreamingVolume = STREAMVOL_CREATE_SPHERE(<<1973.61511, 3820.31543, 32.42871>>, 10, FLAG_MAPDATA | FLAG_COLLISIONS_MOVER)
|
|
|
|
|
|
START_FRANKLIN_ANIM()
|
|
|
|
ADD_PED_FOR_DIALOGUE(planeFightConversation, 0, sSelectorPeds.pedID[SELECTOR_PED_MICHAEL], "MICHAEL")
|
|
ADD_PED_FOR_DIALOGUE(planeFightConversation, 1, PLAYER_PED_ID(), "FRANKLIN")
|
|
|
|
BEGIN_SRL()
|
|
fCustomSwitchSRLTime = -9999.0
|
|
|
|
DO_SCREEN_FADE_IN(DEFAULT_FADE_TIME)
|
|
|
|
iAllowSkipCutsceneTime = GET_GAME_TIMER()
|
|
|
|
//iSyncSceneFranklin = -1
|
|
//iSyncSceneMichael = -1
|
|
|
|
bFranklinCellShown = FALSE
|
|
bMichaelAnimStarted = FALSE
|
|
bMichaelAnimUnpaused = FALSE
|
|
bSwitchConvo1Started = FALSE
|
|
bSwitchConvo2Started = FALSE
|
|
bWooshStarted = FALSE
|
|
bSwitchFX1Started = FALSE
|
|
bSwitchFX2Started = FALSE
|
|
|
|
eSwitchCamState = SWITCH_CAM_PLAYING_SPLINE1
|
|
CDEBUG3LN(DEBUG_MISSION, "eSwitchCamState = SWITCH_CAM_PLAYING_SPLINE1")
|
|
FALLTHRU
|
|
|
|
CASE SWITCH_CAM_PLAYING_SPLINE1
|
|
//CDEBUG3LN(DEBUG_MISSION, "eSwitchCamState = SWITCH_CAM_PLAYING_SPLINE1")
|
|
|
|
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
|
|
|
|
END_SRL()
|
|
|
|
REMOVE_ANIM_DICT(strAnimDictCamShake)
|
|
|
|
SET_GAME_PAUSES_FOR_STREAMING(TRUE)
|
|
|
|
bSkippedCutscene = TRUE
|
|
STOP_CUTSCENE()
|
|
IF STREAMVOL_IS_VALID(hillsStreamingVolume)
|
|
STREAMVOL_DELETE(hillsStreamingVolume)
|
|
ENDIF
|
|
|
|
IF STREAMVOL_IS_VALID(trailerStreamingVolume)
|
|
STREAMVOL_DELETE(trailerStreamingVolume)
|
|
ENDIF
|
|
|
|
SET_WEATHER_TYPE_NOW_PERSIST("extrasunny")
|
|
|
|
DISPLAY_RADAR(TRUE)
|
|
DISPLAY_HUD(TRUE)
|
|
|
|
SET_SCRIPTS_SAFE_FOR_CUTSCENE(FALSE)
|
|
|
|
DO_MISSION_INIT_START_MISSION()
|
|
|
|
IF GET_FOLLOW_PED_CAM_VIEW_MODE() <> CAM_VIEW_MODE_FIRST_PERSON
|
|
ANIMPOSTFX_PLAY("SwitchSceneTrevor", 0, FALSE)
|
|
ENDIF
|
|
|
|
RETURN FALSE
|
|
ELSE
|
|
SET_VARIATIONS_FOR_INTRO_CUTSCENE()
|
|
|
|
OVERRIDE_LODSCALE_THIS_FRAME(1.0)
|
|
|
|
fCustomSwitchSRLTime += (GET_FRAME_TIME() * 1000.0)
|
|
IF fCustomSwitchSRLTime < 0.0
|
|
fCustomSwitchSRLTime = 0.0
|
|
ENDIF
|
|
CDEBUG3LN(DEBUG_MISSION, "SRL Time = ", fCustomSwitchSRLTime)
|
|
SET_SRL_TIME(fCustomSwitchSRLTime)
|
|
|
|
IF IS_CAM_ACTIVE(thisSwitchCam.ciSpline)
|
|
|
|
iCurrentNode = iCurrentNode
|
|
iCurrentNode = UPDATE_SPLINE_CAM(thisSwitchCam)
|
|
fCamPhase = fCamPhase
|
|
fCamPhase = GET_CAM_SPLINE_PHASE(thisSwitchCam.ciSpline)
|
|
|
|
//PRINTFLOAT(fCamPhase) PRINTNL()
|
|
|
|
IF NOT bFranklinCellShown
|
|
IF IS_SYNCHRONIZED_SCENE_RUNNING(iSyncSceneFranklin)
|
|
IF GET_SYNCHRONIZED_SCENE_PHASE(iSyncSceneFranklin) >= fFranklinCellShownPhase
|
|
CDEBUG3LN(DEBUG_MISSION, "Showing Franklin's cellphone...")
|
|
bFranklinCellShown = TRUE
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
|
|
/*
|
|
IF NOT bPreloadedSpeech
|
|
IF IS_SYNCHRONIZED_SCENE_RUNNING(iSyncSceneFranklin)
|
|
IF GET_SYNCHRONIZED_SCENE_PHASE(iSyncSceneFranklin) >= 0.05
|
|
PRELOAD_CONVERSATION(planeFightConversation, "EXL1AUD", "EXL1_INT_LI", CONV_PRIORITY_MEDIUM)
|
|
bPreloadedSpeech = TRUE
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
*/
|
|
|
|
IF iFakeCellphoneState = 0
|
|
IF IS_SYNCHRONIZED_SCENE_RUNNING(iSyncSceneFranklin)
|
|
IF GET_SYNCHRONIZED_SCENE_PHASE(iSyncSceneFranklin) >= 0.548
|
|
iFakeCellphoneState = 1
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF NOT bMichaelAnimStarted
|
|
IF fCamPhase >= fMichaelAnimStartedPhase
|
|
CDEBUG3LN(DEBUG_MISSION, "Starting Michaels anim 1...")
|
|
START_MICHAEL_ANIM()
|
|
bMichaelAnimStarted = TRUE
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF NOT bSwitchFX1Started
|
|
IF fCamPhase >= fSwitchFX1StartPhase
|
|
ANIMPOSTFX_PLAY("SwitchShortFranklinIn", 0, FALSE)
|
|
// PLAY_SOUND_FRONTEND(-1, "Hit_1", "LONG_PLAYER_SWITCH_SOUNDS")
|
|
// PLAY_SOUND_FRONTEND(-1, "FranklinToMichael", "PLAYER_SWITCH_EXILE_1_SOUNDSET")
|
|
bSwitchFX1Started = TRUE
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF NOT bSwitchFX2Started
|
|
IF fCamPhase >= fSwitchFX2StartPhase
|
|
ANIMPOSTFX_PLAY("SwitchShortMichaelMid", 0, FALSE)
|
|
bSwitchFX2Started = TRUE
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF NOT bHitSound
|
|
IF fCamPhase >= fHitStartPhase
|
|
PLAY_SOUND_FRONTEND(-1, "Hit_Out", "PLAYER_SWITCH_CUSTOM_SOUNDSET")
|
|
iHitTime = GET_GAME_TIMER()
|
|
bHitSound = TRUE
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF NOT bWooshStarted
|
|
IF bHitSound
|
|
IF GET_GAME_TIMER() >= iHitTime + 200
|
|
PLAY_SOUND_FRONTEND(-1, "Short_Transition_In", "PLAYER_SWITCH_CUSTOM_SOUNDSET")
|
|
bWooshStarted = TRUE
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
|
|
|
|
|
|
//printfloat(fcamphase) printnl()
|
|
|
|
//Pause the sync scenen until we are looking at Michael
|
|
IF bMichaelAnimStarted
|
|
AND NOT bMichaelAnimUnpaused
|
|
IF IS_SYNCHRONIZED_SCENE_RUNNING(iSyncSceneMichael)
|
|
SET_SYNCHRONIZED_SCENE_RATE(iSyncSceneMichael, 0.0)
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF iCurrentNode > thisSwitchCam.iCamSwitchFocusNode
|
|
SET_ROOM_FOR_GAME_VIEWPORT_BY_NAME("v_trailerrm")
|
|
ENDIF
|
|
|
|
IF NOT bMichaelAnimUnpaused
|
|
IF iCurrentNode > thisSwitchCam.iCamSwitchFocusNode
|
|
|
|
CDEBUG3LN(DEBUG_MISSION, "Starting Michaels anim 2...")
|
|
|
|
IF IS_SYNCHRONIZED_SCENE_RUNNING(iSyncSceneMichael)
|
|
SET_SYNCHRONIZED_SCENE_RATE(iSyncSceneMichael, 1.0)
|
|
ENDIF
|
|
|
|
IF DOES_ENTITY_EXIST(sSelectorPeds.pedID[SELECTOR_PED_FRANKLIN])
|
|
DELETE_PED(sSelectorPeds.pedID[SELECTOR_PED_FRANKLIN])
|
|
ENDIF
|
|
|
|
iFakeCellphoneState = 2
|
|
bMichaelAnimUnpaused = TRUE
|
|
ENDIF
|
|
ENDIF
|
|
IF NOT bSwitchConvo1Started
|
|
IF IS_SYNCHRONIZED_SCENE_RUNNING(iSyncSceneFranklin)
|
|
IF GET_SYNCHRONIZED_SCENE_PHASE(iSyncSceneFranklin) >= 0.849
|
|
CDEBUG3LN(DEBUG_MISSION, "Starting Conversation 1...")
|
|
//IF PLAY_SINGLE_LINE_FROM_CONVERSATION(planeFightConversation, "EXL1AUD", "EXL1_INT_LI", "EXL1_INT_LI_2", CONV_PRIORITY_HIGH)
|
|
IF CREATE_CONVERSATION_FROM_SPECIFIC_LINE(planeFightConversation, "EXL1AUD", "EXL1_INT_LI", "EXL1_INT_LI_2", CONV_PRIORITY_HIGH)
|
|
//CREATE_CONVERSATION(structConversationPeds, "EXL1AUD", "EXL1_INT_LI", CONV_PRIORITY_HIGH)
|
|
//PLAY_SINGLE_LINE_FROM_CONVERSATION(planeFightConversation, "EXL1AUD", "EXL1_INT_LI", "EXL1_INT_LI_1", CONV_PRIORITY_HIGH)
|
|
// BEGIN_PRELOADED_CONVERSATION()
|
|
iSwitchConvoTime = GET_GAME_TIMEr()
|
|
bSwitchConvo1Started = TRUE
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ELSE
|
|
IF NOT bPausedConvo
|
|
TEXT_LABEL_23 tCurrentLabel
|
|
tCurrentLabel = GET_CURRENTLY_PLAYING_STANDARD_CONVERSATION_LABEL()
|
|
IF ARE_STRINGS_EQUAL(tCurrentLabel, "EXL1_INT_LI_2")
|
|
AND GET_GAME_TIMER() >= iSwitchConvoTime + 1000
|
|
PAUSE_FACE_TO_FACE_CONVERSATION(TRUE)
|
|
bPausedConvo = TRUE
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF NOT bSwitchConvo2Started
|
|
IF fCamPhase >= fSwitchConvo2StartPhase
|
|
CDEBUG3LN(DEBUG_MISSION, "Starting Conversation 2...")
|
|
//CREATE_CONVERSATION(structConversationPeds, "EXL1AUD", "EXL1_INT_LI", CONV_PRIORITY_HIGH)
|
|
//IF PLAY_SINGLE_LINE_FROM_CONVERSATION(planeFightConversation, "EXL1AUD", "EXL1_INT_LI", "EXL1_INT_LI_3", CONV_PRIORITY_HIGH)
|
|
PAUSE_FACE_TO_FACE_CONVERSATION(FALSE)
|
|
bSwitchConvo2Started = TRUE
|
|
//ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
|
|
|
|
IF NOT bMovedPed
|
|
REQUEST_ADDITIONAL_COLLISION_AT_COORD(<<1969.67188, 3818.38330, 33.59213>>)
|
|
IF fCamPhase >= 0.7
|
|
REQUEST_CUTSCENE("exile_1_int")
|
|
SET_ENTITY_COORDS(PLAYER_PED_ID(), <<1969.67188, 3818.38330, 33.59213>>)
|
|
FREEZE_ENTITY_POSITION(PLAYER_PED_ID(), TRUE)
|
|
bMovedPed = TRUE
|
|
ENDIF
|
|
ENDIF
|
|
|
|
/*IF bMovedPed //[SP] Replaced with an SRL
|
|
IF NOT STREAMVOL_IS_VALID(trailerStreamingVolume)
|
|
trailerStreamingVolume = STREAMVOL_CREATE_FRUSTUM( <<1969.4, 3815.2, 34>>, CONVERT_ROTATION_TO_DIRECTION_VECTOR(<<-0.4, 1.3, -47.6>>), 50, FLAG_MAPDATA)
|
|
ENDIF
|
|
ENDIF*/
|
|
|
|
|
|
IF GET_CAM_SPLINE_PHASE(thisSwitchCam.ciSpline) >= 1.0
|
|
|
|
SET_GAME_PAUSES_FOR_STREAMING(TRUE)
|
|
|
|
END_SRL()
|
|
|
|
REMOVE_ANIM_DICT(strAnimDictCamShake)
|
|
|
|
RELEASE_FAKE_CELLPHONE_MOVIE(fakeCellphoneData)
|
|
|
|
eSwitchCamState = SWITCH_CAM_START_CUTSCENE
|
|
CDEBUG3LN(DEBUG_MISSION, "eSwitchCamState = SWITCH_CAM_START_CUTSCENE")
|
|
ELSE
|
|
RETURN FALSE
|
|
ENDIF
|
|
ELSE
|
|
RETURN FALSE
|
|
ENDIF
|
|
ENDIF
|
|
|
|
FALLTHRU
|
|
|
|
CASE SWITCH_CAM_START_CUTSCENE
|
|
//CDEBUG3LN(DEBUG_MISSION, "eSwitchCamState = SWITCH_CAM_START_CUTSCENE")
|
|
|
|
IF HAS_CUTSCENE_LOADED_WITH_FAILSAFE()
|
|
|
|
//[SP] Replaced with an SRL
|
|
/*IF STREAMVOL_IS_VALID(trailerStreamingVolume)
|
|
STREAMVOL_DELETE(trailerStreamingVolume)
|
|
ENDIF*/
|
|
|
|
SET_VARIATIONS_FOR_INTRO_CUTSCENE()
|
|
|
|
IF DOES_ENTITY_EXIST(sSelectorPeds.pedID[SELECTOR_PED_MICHAEL])
|
|
IF NOT IS_ENTITY_DEAD(sSelectorPeds.pedID[SELECTOR_PED_MICHAEL])
|
|
REGISTER_ENTITY_FOR_CUTSCENE(sSelectorPeds.pedID[SELECTOR_PED_MICHAEL], "Michael", CU_ANIMATE_EXISTING_SCRIPT_ENTITY)
|
|
ENDIF
|
|
ENDIF
|
|
IF DOES_ENTITY_EXIST(sSelectorPeds.pedID[SELECTOR_PED_TREVOR])
|
|
IF NOT IS_ENTITY_DEAD(sSelectorPeds.pedID[SELECTOR_PED_TREVOR])
|
|
REGISTER_ENTITY_FOR_CUTSCENE(sSelectorPeds.pedID[SELECTOR_PED_TREVOR], "Trevor", CU_ANIMATE_EXISTING_SCRIPT_ENTITY)
|
|
ENDIF
|
|
ENDIF
|
|
|
|
CLEAR_ANIM_DICT_REQUEST(PF_ANIM_DICT_LEADIN)
|
|
|
|
REGISTER_ENTITY_FOR_CUTSCENE(ronPed, "Ron", CU_CREATE_AND_ANIMATE_NEW_SCRIPT_ENTITY, GET_MODEL_FOR_PLANE_FIGHT_MODEL_ENUM(PFM_RON))
|
|
|
|
IF IS_REPLAY_START_VEHICLE_UNDER_SIZE_LIMIT(<<0,0,0>>, TRUE)
|
|
SET_MISSION_START_VEHICLE_AS_VEHICLE_GEN(<<0.0,0.0,0.0>>, 0.0, TRUE, CHAR_FRANKLIN)
|
|
ENDIF
|
|
|
|
IF NOT IS_ENTITY_AT_COORD(PLAYER_PED_ID(), <<1969.67188, 3818.38330, 33.59213>>, <<10,10,10>>, FALSE, FALSE)
|
|
SET_ENTITY_COORDS(PLAYER_PED_ID(), <<1969.67188, 3818.38330, 33.59213>>)
|
|
ENDIF
|
|
|
|
MISSION_FLOW_RELEASE_TRIGGER_SCENE_ASSETS(SP_MISSION_EXILE_1)
|
|
|
|
SET_CUTSCENE_FADE_VALUES(FALSE, FALSE, FALSE, FALSE)
|
|
START_CUTSCENE(CUTSCENE_PLAYER_FP_FLASH_TREVOR)
|
|
|
|
REPLAY_START_EVENT(REPLAY_IMPORTANCE_HIGHEST)
|
|
|
|
bClearedForCutscene = FALSE
|
|
bSkippedCutscene = FALSE
|
|
|
|
eSwitchCamState = SWITCH_CAM_PLAYING_CUTSCENE_FIRST_FRAME
|
|
ELSE
|
|
RETURN FALSE
|
|
ENDIF
|
|
BREAK
|
|
|
|
CASE SWITCH_CAM_PLAYING_CUTSCENE_FIRST_FRAME
|
|
CDEBUG3LN(DEBUG_MISSION, "eSwitchCamState = SWITCH_CAM_PLAYING_CUTSCENE_FIRST_FRAME")
|
|
|
|
|
|
CDEBUG3LN(DEBUG_MISSION, "Switching to Trevor...")
|
|
|
|
SET_STREAMING(TRUE)
|
|
|
|
SET_SELECTOR_PED_FAKE_STATE(sSelectorPeds, SELECTOR_PED_TREVOR, SELECTOR_STATE_AVAILABLE)
|
|
MAKE_SELECTOR_PED_SELECTION(sSelectorPeds, SELECTOR_PED_TREVOR)
|
|
TAKE_CONTROL_OF_SELECTOR_PED(sSelectorPeds, FALSE, TRUE, TCF_CLEAR_TASK_INTERRUPT_CHECKS)
|
|
SET_PLAYER_CONTROL(PLAYER_ID(), FALSE)
|
|
|
|
IF DOES_ENTITY_EXIST(oiMichaelsCellPhone)
|
|
IF NOT IS_ENTITY_DEAD(oiMichaelsCellPhone)
|
|
DELETE_OBJECT(oiMichaelsCellPhone)
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF DOES_ENTITY_EXIST(oiFranklinsCellPhone)
|
|
IF NOT IS_ENTITY_DEAD(oiFranklinsCellPhone)
|
|
DELETE_OBJECT(oiFranklinsCellPhone)
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF DOES_ENTITY_EXIST(sSelectorPeds.pedID[SELECTOR_PED_TREVOR])
|
|
IF NOT IS_ENTITY_DEAD(sSelectorPeds.pedID[SELECTOR_PED_TREVOR])
|
|
IF NOT IS_PED_INJURED(sSelectorPeds.pedID[SELECTOR_PED_TREVOR])
|
|
FREEZE_ENTITY_POSITION(sSelectorPeds.pedID[SELECTOR_PED_TREVOR], FALSE)
|
|
SET_ENTITY_VISIBLE(sSelectorPeds.pedID[SELECTOR_PED_TREVOR], TRUE)
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
|
|
SET_TIME_SCALE(1.0)
|
|
IF DOES_CAM_EXIST(thisSwitchCam.ciSpline)
|
|
DESTROY_CAM(thisSwitchCam.ciSpline)
|
|
DESTROY_ALL_CAMS()
|
|
ENDIF
|
|
RENDER_SCRIPT_CAMS(FALSE, FALSE)
|
|
|
|
UNPIN_INTERIOR(iiiTrailer)
|
|
|
|
IF IS_SCREEN_FADED_OUT()
|
|
DO_SCREEN_FADE_IN(DEFAULT_FADE_TIME)
|
|
ENDIF
|
|
|
|
eSwitchCamState = SWITCH_CAM_PLAYING_CUTSCENE
|
|
CDEBUG3LN(DEBUG_MISSION, "eSwitchCamState = SWITCH_CAM_PLAYING_CUTSCENE")
|
|
FALLTHRU
|
|
|
|
CASE SWITCH_CAM_PLAYING_CUTSCENE
|
|
//CDEBUG3LN(DEBUG_MISSION, "eSwitchCamState = SWITCH_CAM_PLAYING_CUTSCENE")
|
|
|
|
// get cutscene-created peds
|
|
IF NOT DOES_ENTITY_EXIST(ronPed)
|
|
IF DOES_ENTITY_EXIST(GET_ENTITY_INDEX_OF_REGISTERED_ENTITY("Ron"))
|
|
ronPed = GET_PED_INDEX_FROM_ENTITY_INDEX(GET_ENTITY_INDEX_OF_REGISTERED_ENTITY("Ron"))
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF NOT bStartedHillsStreaming
|
|
IF GET_CUTSCENE_TIME() >= 120167
|
|
CREATE_HILLS_STREAMING_VOLUME()
|
|
bStartedHillsStreaming = TRUE
|
|
ENDIF
|
|
ENDIF
|
|
|
|
// preload assets
|
|
IF GET_CUTSCENE_TIME() >= 120000
|
|
DO_STREAMING_FOR_NEXT_MISSION_STAGE(TRUE)
|
|
ENDIF
|
|
|
|
// pre-create mission entities not involved in cut
|
|
IF NOT bDoneIntroCreateEntities
|
|
IF streamingStage = MISSION_STREAMING_STAGE_COMPLETE
|
|
IF NOT bDoneIntroClearStart
|
|
CLEAR_START_AREA()
|
|
bDoneIntroClearStart = TRUE
|
|
ELSE
|
|
CREATE_PLAYER_CHARACTERS_WITH_TRANSPORT_IN_MISSION_STAGE(STAGE_GET_TO_AIRSTRIP)
|
|
bDoneIntroCreateEntities = TRUE
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
|
|
// ron exit state
|
|
IF CAN_SET_EXIT_STATE_FOR_REGISTERED_ENTITY("Ron")
|
|
SET_RON_AT_CAR()
|
|
IF IS_VEHICLE_DRIVEABLE(planeFightVehicle[PFV_TREVOR_4WD])
|
|
AND NOT IS_PED_INJURED(ronPed)
|
|
TASK_ENTER_VEHICLE(ronPed, planeFightVehicle[PFV_TREVOR_4WD], DEFAULT_TIME_BEFORE_WARP, VS_FRONT_RIGHT, PEDMOVEBLENDRATIO_WALK)
|
|
ENDIF
|
|
ENDIF
|
|
|
|
// trevor exit state
|
|
IF CAN_SET_EXIT_STATE_FOR_REGISTERED_ENTITY("Trevor")
|
|
POSITION_PLAYER_AT_MISSION_INIT()
|
|
ENDIF
|
|
|
|
// camera exit state
|
|
IF CAN_SET_EXIT_STATE_FOR_CAMERA()
|
|
|
|
REPLAY_STOP_EVENT()
|
|
|
|
SET_MISSION_CUTSCENE(FALSE, TRUE, FALSE)
|
|
DO_MISSION_INIT_START_MISSION()
|
|
RESET_ADAPTATION()
|
|
IF GET_FOLLOW_PED_CAM_VIEW_MODE() <> CAM_VIEW_MODE_FIRST_PERSON
|
|
ANIMPOSTFX_PLAY("SwitchSceneTrevor", 0, FALSE)
|
|
PLAY_SOUND_FRONTEND(-1, "Hit_1", "LONG_PLAYER_SWITCH_SOUNDS")
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF NOT IS_CUTSCENE_PLAYING()
|
|
SET_PED_CONFIG_FLAG(PLAYER_PED_ID(), PCF_WaitingForPlayerControlInterrupt, TRUE)
|
|
SET_PLAYER_CONTROL(PLAYER_ID(), TRUE)
|
|
|
|
DISPLAY_RADAR(TRUE)
|
|
DISPLAY_HUD(TRUE)
|
|
|
|
SET_SCRIPTS_SAFE_FOR_CUTSCENE(FALSE)
|
|
|
|
eSwitchCamState = SWITCH_CAM_IDLE
|
|
CDEBUG3LN(DEBUG_MISSION, "eSwitchCamState = SWITCH_CAM_IDLE")
|
|
|
|
RETURN TRUE
|
|
ENDIF
|
|
|
|
BREAK
|
|
|
|
ENDSWITCH
|
|
|
|
RETURN FALSE
|
|
ENDFUNC
|
|
|
|
|
|
|
|
// initialise mission
|
|
FUNC BOOL INIT_MISSION()
|
|
|
|
SWITCH missionInitStage
|
|
|
|
CASE MISSION_INIT_PRE_INTRO
|
|
|
|
REMOVE_MISSION_TEXT()
|
|
DISABLE_VEHICLE_GEN_ON_MISSION(TRUE)
|
|
ENABLE_CARGENS_FOR_MISSION(FALSE)
|
|
IF GET_FOLLOW_PED_CAM_VIEW_MODE() <> CAM_VIEW_MODE_FIRST_PERSON
|
|
SET_PLAYER_CONTROL(PLAYER_ID(), FALSE, SPC_LEAVE_CAMERA_CONTROL_ON)
|
|
ENDIF
|
|
SET_PLAYER_PED_AVAILABLE(CHAR_TREVOR, TRUE)
|
|
SET_WEATHER_TYPE_OVERTIME_PERSIST("extrasunny", 12.0)
|
|
|
|
INT i
|
|
REPEAT COUNT_OF(jetMissile) i
|
|
jetMissile[i].iSoundID = GET_SOUND_ID()
|
|
ENDREPEAT
|
|
|
|
g_savedGlobals.sAmbient.iChaseHelpTextDisplayed_mission = iCHASE_HINT_HELP_DISPLAY_MAX
|
|
|
|
//airfieldScenarioBlocking = ADD_SCENARIO_BLOCKING_AREA(<<1602.74243, 4571.52734, 47>>, <<2288.94653, 5200.07861, 150>>)
|
|
//crashSiteAirScenarioBlocking = ADD_SCENARIO_BLOCKING_AREA(<<576.7, 2890.8, 54.0>>, <<2050.6, 3512.8, 400.0>>)
|
|
//crashSiteGroundScenarioBlocking = ADD_SCENARIO_BLOCKING_AREA(<<1003.4, 2968.3, -10.0>>, <<1778.0, 3357.1, 150.0>>)
|
|
|
|
IF NOT Is_Replay_In_Progress()
|
|
iReplayAttempt = 0
|
|
ELSE
|
|
iReplayAttempt = g_savedGlobals.sFlow.missionSavedData[SP_MISSION_EXILE_1].missionFailsNoProgress + 1
|
|
ENDIF
|
|
|
|
bCustomSwitchSRLRequested = FALSE
|
|
|
|
SUPPRESS_MISSION_VEHICLES(TRUE)
|
|
missionInitStage = MISSION_INIT_REQUEST_INTRO_ASSETS
|
|
BREAK
|
|
|
|
CASE MISSION_INIT_REQUEST_INTRO_ASSETS
|
|
|
|
IF NOT Is_Replay_In_Progress()
|
|
#IF IS_DEBUG_BUILD
|
|
AND iDebugStage < 0
|
|
#ENDIF
|
|
//SET_MISSION_MOCAP_CUTSCENE()
|
|
|
|
IF NOT bCustomSwitchSRLRequested
|
|
PREFETCH_SRL(strCustomSwitchSRL)
|
|
SET_SRL_READAHEAD_TIMES(7, 7, 7, 7)
|
|
bCustomSwitchSRLRequested = TRUE
|
|
ENDIF
|
|
|
|
ADD_MODEL_REQUEST(ENUM_TO_INT(PFM_TREVOR))
|
|
ADD_MODEL_REQUEST(ENUM_TO_INT(PFM_MICHAEL))
|
|
ADD_MODEL_REQUEST(ENUM_TO_INT(PFM_FRANKLIN_PHONE))
|
|
ADD_MODEL_REQUEST(ENUM_TO_INT(PFM_MICHAEL_PHONE))
|
|
ADD_ANIM_DICT_REQUEST(PF_ANIM_DICT_LEADIN)
|
|
REQUEST_ANIM_DICT(strAnimDictCamShake)
|
|
REQUEST_FAKE_CELLPHONE_MOVIE(fakeCellphoneData)
|
|
|
|
|
|
WHILE NOT HAVE_ALL_MODEL_REQUESTS_SUCCEEDED()
|
|
OR NOT HAVE_ALL_ANIM_DICT_REQUESTS_SUCCEEDED()
|
|
OR NOT HAS_ANIM_DICT_LOADED(strAnimDictCamShake)
|
|
OR NOT HAS_FAKE_CELLPHONE_MOVIE_LOADED(fakeCellphoneData)
|
|
OR NOT IS_SRL_LOADED()
|
|
IF IS_ENTITY_IN_ANGLED_AREA(PLAYER_PED_ID(), <<-817.28430, 178.94594, 71.22786>>, << -816.60114, 177.17238, 73.22786>>, 1)
|
|
SET_PLAYER_CONTROL(PLAYER_ID(), FALSE, SPC_LEAVE_CAMERA_CONTROL_ON)
|
|
ENDIF
|
|
WAIT(0)
|
|
ENDWHILE
|
|
|
|
INT iCloseToDoorTime
|
|
iCloseToDoorTime = GET_GAME_TIMER()
|
|
WHILE GET_GAME_TIMER() < iCloseToDoorTime + 2000
|
|
AND GET_FOLLOW_PED_CAM_VIEW_MODE() = CAM_VIEW_MODE_FIRST_PERSON
|
|
AND NOT IS_ENTITY_IN_ANGLED_AREA(PLAYER_PED_ID(), <<-817.28430, 178.94594, 71.22786>>, << -816.60114, 177.17238, 73.22786>>, 1)
|
|
WAIT(0)
|
|
ENDWHILE
|
|
|
|
SET_PLAYER_CONTROL(PLAYER_ID(), FALSE, SPC_LEAVE_CAMERA_CONTROL_ON)
|
|
eSwitchCamState = SWITCH_CAM_START_SPLINE1
|
|
missionInitStage = MISSION_INIT_PLAY_INTRO
|
|
ELSE
|
|
STOP_CUTSCENE()
|
|
DO_MISSION_INIT_START_MISSION()
|
|
ENDIF
|
|
BREAK
|
|
|
|
CASE MISSION_INIT_PLAY_INTRO
|
|
SET_ALL_RANDOM_PEDS_FLEE_THIS_FRAME(PLAYER_ID())
|
|
|
|
IF HANDLE_SWITCH_CAM(scsSwitchCam)
|
|
PAUSE_FACE_TO_FACE_CONVERSATION(FALSE)
|
|
missionInitStage = MISSION_INIT_DONE
|
|
ELSE
|
|
RETURN FALSE
|
|
ENDIF
|
|
|
|
FALLTHRU
|
|
|
|
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()
|
|
INT i
|
|
REPEAT COUNT_OF(sSelectorPeds.pedID) i
|
|
IF NOT IS_PED_INJURED(sSelectorPeds.pedID[i])
|
|
SET_BLOCKING_OF_NON_TEMPORARY_EVENTS(sSelectorPeds.pedID[i], TRUE)
|
|
SET_PED_RELATIONSHIP_GROUP_HASH(sSelectorPeds.pedID[i], RELGROUPHASH_PLAYER)
|
|
ENDIF
|
|
ENDREPEAT
|
|
ENDPROC
|
|
|
|
// constantly run the hotswap selector/spline cam, and return true when selected the target ped
|
|
FUNC BOOL DO_MISSION_HOTSWAP(SELECTOR_SLOTS_ENUM targetCharacter, BOOL bInstantSwap = FALSE)
|
|
SWITCH hotswapStage
|
|
CASE MISSION_HOTSWAP_STAGE_SELECT_CHARACTER
|
|
REMOVE_MISSION_TEXT()
|
|
sSelectorPeds.eNewSelectorPed = targetCharacter
|
|
sCamDetails.pedTo = sSelectorPeds.pedID[targetCharacter]
|
|
sCamDetails.bPedSwitched = FALSE
|
|
hotswapStage = MISSION_HOTSWAP_STAGE_DO_SPLINE_CAM
|
|
BREAK
|
|
|
|
CASE MISSION_HOTSWAP_STAGE_DO_SPLINE_CAM
|
|
SELECTOR_CAM_INTERP_TYPE camInterpType
|
|
|
|
IF NOT bInstantSwap
|
|
IF RUN_CAM_SPLINE_FROM_PLAYER_TO_PED(sCamDetails, 0.0, 0.0, camInterpType)
|
|
IF sCamDetails.bOKToSwitchPed
|
|
IF NOT sCamDetails.bPedSwitched
|
|
IF TAKE_CONTROL_OF_SELECTOR_PED(sSelectorPeds)
|
|
sCamDetails.bPedSwitched = TRUE
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ELSE
|
|
REAPPLY_PLAYER_PED_ATTRIBUTES()
|
|
RETURN TRUE
|
|
ENDIF
|
|
ELSE
|
|
IF TAKE_CONTROL_OF_SELECTOR_PED(sSelectorPeds)
|
|
sCamDetails.bPedSwitched = TRUE
|
|
REAPPLY_PLAYER_PED_ATTRIBUTES()
|
|
RETURN TRUE
|
|
ENDIF
|
|
ENDIF
|
|
BREAK
|
|
ENDSWITCH
|
|
|
|
RETURN FALSE
|
|
ENDFUNC
|
|
|
|
// common stuff for cutscene skip
|
|
PROC HANDLE_SKIP_CUTSCENE()
|
|
IF IS_CUTSCENE_SKIP_BUTTON_JUST_PRESSED()
|
|
AND GET_GAME_TIMER() >= iAllowSkipCutsceneTime + 1000
|
|
DO_SCREEN_FADE_OUT(DEFAULT_FADE_TIME)
|
|
WHILE NOT IS_SCREEN_FADED_OUT()
|
|
WAIT(0)
|
|
ENDWHILE
|
|
|
|
HANG_UP_AND_PUT_AWAY_PHONE()
|
|
KILL_ANY_CONVERSATION()
|
|
bSkippedCutscene = TRUE
|
|
cutsceneStage = PF_CUT_STAGE_CLEANUP
|
|
ENDIF
|
|
ENDPROC
|
|
|
|
CONST_FLOAT PLANE_BOTTOM_Y -20.4
|
|
CONST_FLOAT PLANE_LENGTH_Y 40.4
|
|
|
|
// update the player while on plane
|
|
PROC UPDATE_PLAYER_ON_PLANE()
|
|
IF NOT IS_PED_INJURED(PLAYER_PED_ID())
|
|
AND IS_VEHICLE_DRIVEABLE(planeFightVehicle[PFV_CARGO_PLANE])
|
|
SET_PED_RESET_FLAG(PLAYER_PED_ID(), PRF_DisableCrouchWhileInCover, TRUE)
|
|
//PRINTSTRING("setting reset flag") PRINTNL()
|
|
vPlayerOffsetFromPlane = GET_OFFSET_FROM_ENTITY_GIVEN_WORLD_COORDS(planeFightVehicle[PFV_CARGO_PLANE], GET_ENTITY_COORDS(PLAYER_PED_ID()))
|
|
|
|
//PRINTSTRING("offset = ") PRINTVECTOR(vPlayerOffsetFromPlane) PRINTNL()
|
|
|
|
// calculate distance up plane
|
|
FLOAT fDistanceUpPlane = vPlayerOffsetFromPlane.y - PLANE_BOTTOM_Y
|
|
IF fDistanceUpPlane < 0
|
|
fDistanceUpPlane *= -1
|
|
ENDIF
|
|
|
|
fProportionUpPlane = fDistanceUpPlane / PLANE_LENGTH_Y
|
|
|
|
IF fProportionUpPlane < 0
|
|
fProportionUpPlane = 0
|
|
ELIF fProportionUpPlane > 1
|
|
fProportionUpPlane = 1
|
|
ENDIF
|
|
|
|
//PRINTSTRING("distance = ") PRINTFLOAT(fDistanceUpPlane) PRINTNL()
|
|
//PRINTSTRING("proportion = ") PRINTFLOAT(fProportionUpPlane) PRINTNL()
|
|
ENDIF
|
|
ENDPROC
|
|
|
|
// update roll data for a flight update
|
|
PROC FILL_PLANE_ROLL_DATA(PLANE_ROLL_DIR_ENUM pRD, PLANE_ROLL_SPEED_ENUM pRS, FLOAT fRollTarget)
|
|
IF flightTargetData.fRollTarget <> fRollTarget
|
|
flightTargetData.rollDir = pRD
|
|
flightTargetData.rollSpeed = pRS
|
|
flightTargetData.fRollTarget = fRollTarget
|
|
// minimise roll if in plane cockpit
|
|
IF bOffLadder
|
|
flightTargetData.fRollTarget /= 2
|
|
flightTargetData.rollSpeed = PLANE_ROLL_SPEED_VERY_SLOW
|
|
ENDIF
|
|
ENDIF
|
|
ENDPROC
|
|
|
|
// fill pitch data for a flight update
|
|
PROC FILL_PLANE_PITCH_DATA(PLANE_PITCH_DIR_ENUM pPD, PLANE_PITCH_SPEED_ENUM pPS, FLOAT fPitchTarget)
|
|
IF flightTargetData.fPitchTarget <> fPitchTarget
|
|
flightTargetData.pitchDir = pPD
|
|
flightTargetData.pitchSpeed = pPS
|
|
flightTargetData.fPitchTarget = fPitchTarget
|
|
ENDIF
|
|
ENDPROC
|
|
|
|
// add a wait in ms till next flight update
|
|
PROC DO_FLIGHT_WAIT(INT iWait)
|
|
iNextSubstageUpdateTime = GET_GAME_TIMER() + iWait
|
|
ENDPROC
|
|
|
|
// goto to flight substage
|
|
PROC GOTO_FLIGHT_SUBSTAGE(INT iGotoSubstage)
|
|
iFlightSubstage = iGotoSubstage
|
|
bDoingGotoSubstage = TRUE
|
|
ENDPROC
|
|
|
|
// should we increase the flight intensity?
|
|
FUNC BOOL SHOULD_INCREASE_FLIGHT_INTENSITY()
|
|
//PRINTSTRING("offset = ") PRINTFLOAT(vPlayerOffsetFromPlane.y) PRINTNL()
|
|
|
|
SWITCH iFlightIntensityStage
|
|
CASE 0
|
|
CASE 1
|
|
FLOAT fIncreaseY
|
|
SWITCH iFlightIntensityStage
|
|
CASE 0
|
|
fIncreaseY = -12.4
|
|
BREAK
|
|
CASE 1
|
|
//fIncreaseY = 7.8
|
|
fIncreaseY = 15.2
|
|
BREAK
|
|
ENDSWITCH
|
|
|
|
IF vPlayerOffsetFromPlane.y >= fIncreaseY
|
|
RETURN TRUE
|
|
ENDIF
|
|
BREAK
|
|
|
|
CASE 2
|
|
/*
|
|
IF currentMissionStage = STAGE_ESCAPE_PLANE
|
|
IF NOT IS_PED_IN_ANY_VEHICLE(PLAYER_PED_ID())
|
|
IF vPlayerOffsetFromPlane.y <= FLIP_OVER_Y
|
|
RETURN TRUE
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
*/
|
|
BREAK
|
|
ENDSWITCH
|
|
|
|
RETURN FALSE
|
|
ENDFUNC
|
|
|
|
// update the plane movement
|
|
PROC UPDATE_FLIGHT()
|
|
BOOL bForceNewSubstage = FALSE
|
|
|
|
// increase flight intensity if progressed along hold far enough
|
|
IF SHOULD_INCREASE_FLIGHT_INTENSITY()
|
|
iFlightIntensityStage++
|
|
iFlightSubstage = 0
|
|
bForceNewSubstage = TRUE
|
|
ENDIF
|
|
|
|
// update the substage
|
|
IF GET_GAME_TIMER() >= iNextSubstageUpdateTime
|
|
IF (planeMovementData.vRot.y = flightTargetData.fRollTarget AND planeMovementData.vRot.x = flightTargetData.fPitchTarget)
|
|
OR bDoingGotoSubstage
|
|
OR bForceNewSubstage
|
|
bDoingGotoSubstage = FALSE
|
|
SWITCH iFlightIntensityStage
|
|
// 0: nice and gentle, slow tipping to shallow angles
|
|
CASE 0
|
|
SWITCH iFlightSubstage
|
|
CASE 0
|
|
DO_FLIGHT_WAIT(600)
|
|
BREAK
|
|
CASE 1
|
|
FILL_PLANE_ROLL_DATA(PLANE_ROLL_DIR_ANTICLOCKWISE, PLANE_ROLL_SPEED_SLOW, -2)
|
|
BREAK
|
|
CASE 2
|
|
FILL_PLANE_ROLL_DATA(PLANE_ROLL_DIR_CLOCKWISE, PLANE_ROLL_SPEED_SLOW, 3)
|
|
BREAK
|
|
CASE 3
|
|
FILL_PLANE_ROLL_DATA(PLANE_ROLL_DIR_ANTICLOCKWISE, PLANE_ROLL_SPEED_SLOW, -3)
|
|
BREAK
|
|
CASE 4
|
|
FILL_PLANE_ROLL_DATA(PLANE_ROLL_DIR_CLOCKWISE, PLANE_ROLL_SPEED_SLOW, 2)
|
|
BREAK
|
|
CASE 5
|
|
GOTO_FLIGHT_SUBSTAGE(1)
|
|
BREAK
|
|
ENDSWITCH
|
|
BREAK
|
|
|
|
// 1: pitch up
|
|
CASE 1
|
|
SWITCH iFlightSubstage
|
|
CASE 0
|
|
// FILL_PLANE_PITCH_DATA(PLANE_PITCH_DIR_DIVE, PLANE_PITCH_SPEED_SLOW, 12.0)
|
|
FILL_PLANE_ROLL_DATA(PLANE_ROLL_DIR_CLOCKWISE, PLANE_ROLL_SPEED_SLOW, 4)
|
|
BREAK
|
|
CASE 1
|
|
FILL_PLANE_ROLL_DATA(PLANE_ROLL_DIR_ANTICLOCKWISE, PLANE_ROLL_SPEED_SLOW, -4)
|
|
BREAK
|
|
CASE 2
|
|
FILL_PLANE_ROLL_DATA(PLANE_ROLL_DIR_CLOCKWISE, PLANE_ROLL_SPEED_SLOW, 3)
|
|
BREAK
|
|
CASE 3
|
|
FILL_PLANE_ROLL_DATA(PLANE_ROLL_DIR_ANTICLOCKWISE, PLANE_ROLL_SPEED_SLOW, -4)
|
|
BREAK
|
|
CASE 4
|
|
FILL_PLANE_ROLL_DATA(PLANE_ROLL_DIR_CLOCKWISE, PLANE_ROLL_SPEED_SLOW, 4)
|
|
BREAK
|
|
CASE 5
|
|
GOTO_FLIGHT_SUBSTAGE(1)
|
|
BREAK
|
|
ENDSWITCH
|
|
BREAK
|
|
|
|
// 2: pitch to 0
|
|
CASE 2
|
|
SWITCH iFlightSubstage
|
|
CASE 0
|
|
// FILL_PLANE_PITCH_DATA(PLANE_PITCH_DIR_DIVE, PLANE_PITCH_SPEED_SLOW, 0.0)
|
|
FILL_PLANE_ROLL_DATA(PLANE_ROLL_DIR_ANTICLOCKWISE, PLANE_ROLL_SPEED_SLOW, -4)
|
|
BREAK
|
|
CASE 1
|
|
FILL_PLANE_ROLL_DATA(PLANE_ROLL_DIR_CLOCKWISE, PLANE_ROLL_SPEED_SLOW, 5)
|
|
BREAK
|
|
CASE 2
|
|
FILL_PLANE_ROLL_DATA(PLANE_ROLL_DIR_ANTICLOCKWISE, PLANE_ROLL_SPEED_SLOW, -3)
|
|
BREAK
|
|
CASE 3
|
|
FILL_PLANE_ROLL_DATA(PLANE_ROLL_DIR_CLOCKWISE, PLANE_ROLL_SPEED_SLOW, 4)
|
|
BREAK
|
|
CASE 4
|
|
FILL_PLANE_ROLL_DATA(PLANE_ROLL_DIR_ANTICLOCKWISE, PLANE_ROLL_SPEED_SLOW, -3)
|
|
BREAK
|
|
CASE 5
|
|
GOTO_FLIGHT_SUBSTAGE(1)
|
|
BREAK
|
|
ENDSWITCH
|
|
BREAK
|
|
|
|
// 3: diving for escape
|
|
CASE 3
|
|
SWITCH iFlightSubstage
|
|
CASE 0
|
|
FILL_PLANE_ROLL_DATA(PLANE_ROLL_DIR_ANTICLOCKWISE, PLANE_ROLL_SPEED_MED, -4)
|
|
BREAK
|
|
CASE 1
|
|
FILL_PLANE_ROLL_DATA(PLANE_ROLL_DIR_CLOCKWISE, PLANE_ROLL_SPEED_MED, 5)
|
|
BREAK
|
|
CASE 2
|
|
FILL_PLANE_ROLL_DATA(PLANE_ROLL_DIR_ANTICLOCKWISE, PLANE_ROLL_SPEED_MED, -3)
|
|
BREAK
|
|
CASE 3
|
|
FILL_PLANE_ROLL_DATA(PLANE_ROLL_DIR_CLOCKWISE, PLANE_ROLL_SPEED_MED, 4)
|
|
BREAK
|
|
CASE 4
|
|
FILL_PLANE_ROLL_DATA(PLANE_ROLL_DIR_ANTICLOCKWISE, PLANE_ROLL_SPEED_MED, -3)
|
|
BREAK
|
|
CASE 5
|
|
GOTO_FLIGHT_SUBSTAGE(1)
|
|
BREAK
|
|
ENDSWITCH
|
|
BREAK
|
|
ENDSWITCH
|
|
|
|
IF iFlightSubstage < NUMBER_FLIGHT_SUBSTAGES
|
|
IF NOT bDoingGotoSubstage
|
|
iFlightSubstage++
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDPROC
|
|
|
|
// common functions to update plane
|
|
PROC DO_COMMON_PLANE_FUNCTIONS()
|
|
UPDATE_PLAYER_ON_PLANE()
|
|
UPDATE_FLIGHT()
|
|
UPDATE_PLANE_PHYSICAL_MOVEMENT()
|
|
UPDATE_TRANSPORTED_VEHICLES()
|
|
UPDATE_COVER_OBJECTS()
|
|
UPDATE_DEBRIS_OBJECTS()
|
|
UPDATE_ENEMY_PEDS()
|
|
|
|
IF currentMissionStage = STAGE_ESCAPE_PLANE
|
|
HANDLE_KLAXON_SOUND(FALSE)
|
|
ENDIF
|
|
ENDPROC
|
|
|
|
// is a transported vehicle touching a cover object?
|
|
FUNC BOOL IS_TRANSPORTED_VEHICLE_TOUCHING_COVER_OBJECT(TRANSPORTED_VEHICLE_INDEX_ENUM vehicleIndex, INT iObject)
|
|
IF DOES_ENTITY_EXIST(transportedVehicle[vehicleIndex].veh)
|
|
AND DOES_ENTITY_EXIST(coverObject[iObject].obj)
|
|
IF IS_ENTITY_TOUCHING_ENTITY(transportedVehicle[vehicleIndex].veh, coverObject[iObject].obj)
|
|
RETURN TRUE
|
|
ENDIF
|
|
ENDIF
|
|
|
|
RETURN FALSE
|
|
ENDFUNC
|
|
|
|
// get y offset from anchor to do vehicle destruction
|
|
FUNC FLOAT GET_TRANSPORTED_VEHICLE_DESTRUCTION_Y_OFFSET(TRANSPORTED_VEHICLE_INDEX_ENUM vehicleIndex)
|
|
SWITCH vehicleIndex
|
|
CASE TRANSPORTED_VEHICLE_INDEX_4WD_DRIVE
|
|
RETURN 500.0//22.1
|
|
BREAK
|
|
CASE TRANSPORTED_VEHICLE_INDEX_4WD_SLIDE_OUT
|
|
RETURN -21.8
|
|
BREAK
|
|
CASE TRANSPORTED_VEHICLE_INDEX_4WD_L_1
|
|
RETURN -12.9
|
|
//RETURN -2.44
|
|
BREAK
|
|
CASE TRANSPORTED_VEHICLE_INDEX_4WD_L_2
|
|
RETURN -12.82
|
|
//RETURN -2.31
|
|
BREAK
|
|
CASE TRANSPORTED_VEHICLE_INDEX_4WD_L_3
|
|
RETURN 9.98
|
|
BREAK
|
|
CASE TRANSPORTED_VEHICLE_INDEX_4WD_L_4
|
|
RETURN 15.45
|
|
BREAK
|
|
CASE TRANSPORTED_VEHICLE_INDEX_4WD_R_1
|
|
RETURN -20.4
|
|
BREAK
|
|
CASE TRANSPORTED_VEHICLE_INDEX_4WD_R_2
|
|
RETURN -6.12
|
|
BREAK
|
|
ENDSWITCH
|
|
|
|
RETURN -999999.0
|
|
ENDFUNC
|
|
|
|
// get time from start destruction to do vehicle destruction
|
|
FUNC INT GET_TRANSPORTED_VEHICLE_DESTRUCTION_TIME(TRANSPORTED_VEHICLE_INDEX_ENUM vehicleIndex)
|
|
SWITCH vehicleIndex
|
|
CASE TRANSPORTED_VEHICLE_INDEX_4WD_DRIVE
|
|
RETURN 5500
|
|
BREAK
|
|
CASE TRANSPORTED_VEHICLE_INDEX_4WD_SLIDE_OUT
|
|
RETURN 7200
|
|
BREAK
|
|
CASE TRANSPORTED_VEHICLE_INDEX_4WD_L_1
|
|
RETURN 5000
|
|
BREAK
|
|
CASE TRANSPORTED_VEHICLE_INDEX_4WD_L_2
|
|
RETURN 4000
|
|
BREAK
|
|
CASE TRANSPORTED_VEHICLE_INDEX_4WD_L_3
|
|
RETURN 3600
|
|
BREAK
|
|
CASE TRANSPORTED_VEHICLE_INDEX_4WD_L_4
|
|
RETURN 3200
|
|
BREAK
|
|
CASE TRANSPORTED_VEHICLE_INDEX_4WD_R_1
|
|
RETURN 3000
|
|
BREAK
|
|
CASE TRANSPORTED_VEHICLE_INDEX_4WD_R_2
|
|
RETURN 2000
|
|
BREAK
|
|
ENDSWITCH
|
|
|
|
RETURN 99999999
|
|
ENDFUNC
|
|
|
|
// get time from start destruction to do cover destruction
|
|
FUNC INT GET_COVER_OBJECT_DESTRUCTION_TIME(INT iCover)
|
|
COVER_OBJECT_INDEX_ENUM thisCoverObject = INT_TO_ENUM(COVER_OBJECT_INDEX_ENUM, iCover)
|
|
//RETURN 99999999
|
|
SWITCH thisCoverObject
|
|
CASE COVER_OBJECT_INDEX_BATCH1_1_L1
|
|
RETURN 5000
|
|
BREAK
|
|
CASE COVER_OBJECT_INDEX_BATCH1_2_S1
|
|
RETURN 4500
|
|
BREAK
|
|
//CASE COVER_OBJECT_INDEX_BATCH1_2_S2
|
|
// RETURN 4400
|
|
//BREAK
|
|
CASE COVER_OBJECT_INDEX_BATCH1_3_S1
|
|
RETURN 1000
|
|
BREAK
|
|
CASE COVER_OBJECT_INDEX_BATCH1_3_S2
|
|
RETURN 1400
|
|
BREAK
|
|
CASE COVER_OBJECT_INDEX_BATCH2_1_S1
|
|
RETURN 2400
|
|
BREAK
|
|
CASE COVER_OBJECT_INDEX_BATCH2_1_S2
|
|
RETURN 2200
|
|
BREAK
|
|
CASE COVER_OBJECT_INDEX_BATCH2_2_L1
|
|
RETURN 1800
|
|
BREAK
|
|
CASE COVER_OBJECT_INDEX_BATCH2_3_L1
|
|
RETURN 1700
|
|
BREAK
|
|
ENDSWITCH
|
|
|
|
RETURN 99999999
|
|
ENDFUNC
|
|
|
|
// get y offset from anchor to do cover destruction
|
|
FUNC FLOAT GET_COVER_OBJECT_DESTRUCTION_Y_OFFSET(INT iCover)
|
|
COVER_OBJECT_INDEX_ENUM thisCoverObject = INT_TO_ENUM(COVER_OBJECT_INDEX_ENUM, iCover)
|
|
|
|
SWITCH thisCoverObject
|
|
CASE COVER_OBJECT_INDEX_BATCH1_1_L1
|
|
RETURN -19.16
|
|
BREAK
|
|
CASE COVER_OBJECT_INDEX_BATCH1_2_S1
|
|
RETURN -19.16
|
|
BREAK
|
|
//CASE COVER_OBJECT_INDEX_BATCH1_2_S2
|
|
// RETURN 4400
|
|
//BREAK
|
|
CASE COVER_OBJECT_INDEX_BATCH1_3_S1
|
|
RETURN -15.44
|
|
BREAK
|
|
CASE COVER_OBJECT_INDEX_BATCH1_3_S2
|
|
RETURN -15.34
|
|
BREAK
|
|
CASE COVER_OBJECT_INDEX_BATCH2_1_S1
|
|
RETURN 0.41
|
|
BREAK
|
|
CASE COVER_OBJECT_INDEX_BATCH2_1_S2
|
|
RETURN 0.42
|
|
BREAK
|
|
CASE COVER_OBJECT_INDEX_BATCH2_2_L1
|
|
RETURN 2.54
|
|
BREAK
|
|
CASE COVER_OBJECT_INDEX_BATCH2_3_L1
|
|
RETURN 3.90
|
|
BREAK
|
|
ENDSWITCH
|
|
|
|
RETURN 99999999.0
|
|
ENDFUNC
|
|
|
|
// setpieces as progress through plane
|
|
PROC DO_PLANE_SETPIECES(MISSION_STAGE_ENUM setpieceStage)
|
|
INT i
|
|
TRANSPORTED_VEHICLE_INDEX_ENUM vehicleIndex
|
|
|
|
SWITCH setpieceStage
|
|
CASE STAGE_PLANE_FIGHT
|
|
// release vehicles as player approaches
|
|
REPEAT COUNT_OF(transportedVehicle) i
|
|
vehicleIndex = INT_TO_ENUM(TRANSPORTED_VEHICLE_INDEX_ENUM, i)
|
|
IF vehicleIndex <> TRANSPORTED_VEHICLE_INDEX_4WD_DRIVE
|
|
IF NOT transportedVehicle[vehicleIndex].bDetached
|
|
IF vPlayerOffsetFromPlane.y >= GET_TRANSPORTED_VEHICLE_DESTRUCTION_Y_OFFSET(vehicleIndex)
|
|
OR ((enemyData[3].aiState = ENEMY_AI_MOVING OR IS_PED_INJURED(enemyData[3].ped)) AND vehicleIndex = TRANSPORTED_VEHICLE_INDEX_4WD_R_1)
|
|
DETACH_TRANSPORTED_VEHICLE(vehicleIndex, TRUE)
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDREPEAT
|
|
|
|
// release cover objects as player approaches
|
|
REPEAT COUNT_OF(coverObject) i
|
|
IF NOT coverObject[i].bDetached
|
|
//IF GET_GAME_TIMER() >= iStartDestructionTime + GET_COVER_OBJECT_DESTRUCTION_TIME(i)
|
|
IF vPlayerOffsetFromPlane.y >= GET_COVER_OBJECT_DESTRUCTION_Y_OFFSET(i)
|
|
DETACH_COVER_OBJECT(i, TRUE)
|
|
ENDIF
|
|
ENDIF
|
|
ENDREPEAT
|
|
BREAK
|
|
|
|
/*
|
|
CASE STAGE_ESCAPE_PLANE
|
|
// handle stuff falling from the ceiling during destruction
|
|
IF NOT bAllowDestruction
|
|
IF IS_PED_IN_ANY_VEHICLE(PLAYER_PED_ID())
|
|
OR vPlayerOffsetFromPlane.y <= 16.0
|
|
iStartDestructionTime = GET_GAME_TIMER()
|
|
bAllowDestruction = TRUE
|
|
ENDIF
|
|
ELSE
|
|
REPEAT COUNT_OF(transportedVehicle) i
|
|
vehicleIndex = INT_TO_ENUM(TRANSPORTED_VEHICLE_INDEX_ENUM, i)
|
|
IF NOT transportedVehicle[vehicleIndex].bDetached
|
|
IF vPlayerOffsetFromPlane.y <= GET_TRANSPORTED_VEHICLE_DESTRUCTION_Y_OFFSET(vehicleIndex)
|
|
OR GET_GAME_TIMER() >= iStartDestructionTime + GET_TRANSPORTED_VEHICLE_DESTRUCTION_TIME(vehicleIndex)
|
|
DETACH_TRANSPORTED_VEHICLE(vehicleIndex, TRUE)
|
|
ENDIF
|
|
ENDIF
|
|
ENDREPEAT
|
|
REPEAT COUNT_OF(coverObject) i
|
|
IF NOT coverObject[i].bDetached
|
|
IF GET_GAME_TIMER() >= iStartDestructionTime + GET_COVER_OBJECT_DESTRUCTION_TIME(i)
|
|
DETACH_COVER_OBJECT(i, TRUE)
|
|
ENDIF
|
|
ENDIF
|
|
ENDREPEAT
|
|
ENDIF
|
|
BREAK
|
|
*/
|
|
ENDSWITCH
|
|
|
|
// dodge speech
|
|
IF currentMissionStage = STAGE_ESCAPE_PLANE
|
|
OR bShownGodText
|
|
IF iDodgeReactCount < 3
|
|
AND GET_GAME_TIMER() >= iNextDodgeReactTime
|
|
IF iDodgeEntity >= 0
|
|
IF GET_GAME_TIMER() >= iDodgeTime
|
|
IF bDodgeIsVehicle
|
|
IF DOES_ENTITY_EXIST(transportedVehicle[iDodgeEntity].veh)
|
|
IF IS_ENTITY_DEAD(transportedVehicle[iDodgeEntity].veh)
|
|
OR NOT IS_ENTITY_DEAD(transportedVehicle[iDodgeEntity].veh)
|
|
IF NOT IS_ENTITY_AT_ENTITY(PLAYER_PED_ID(), transportedVehicle[iDodgeEntity].veh, <<DODGE_CHECK_DISTANCE, DODGE_CHECK_DISTANCE, DODGE_CHECK_DISTANCE>>)
|
|
iDodgeEntity = -1
|
|
ENDIF
|
|
ENDIF
|
|
ELSE
|
|
iDodgeEntity = -1
|
|
ENDIF
|
|
ELSE
|
|
IF DOES_ENTITY_EXIST(coverObject[iDodgeEntity].obj)
|
|
IF NOT IS_ENTITY_AT_ENTITY(PLAYER_PED_ID(), coverObject[iDodgeEntity].obj, <<DODGE_CHECK_DISTANCE, DODGE_CHECK_DISTANCE, DODGE_CHECK_DISTANCE>>)
|
|
iDodgeEntity = -1
|
|
ENDIF
|
|
ELSE
|
|
iDodgeEntity = -1
|
|
ENDIF
|
|
ENDIF
|
|
IF iDodgeEntity >= 0
|
|
STRING sSpeech
|
|
IF currentMissionStage = STAGE_PLANE_FIGHT
|
|
IF GET_RANDOM_INT_IN_RANGE(0,2) = 0
|
|
sSpeech = "EXL1_DODGE1"
|
|
ELSE
|
|
sSpeech = "EXL1_CAR"
|
|
ENDIF
|
|
|
|
IF DO_MISSION_SPEECH(sSpeech)
|
|
iDodgeEntity = -1
|
|
iNextDodgeReactTime = GET_GAME_TIMER() + 8000
|
|
iNextRandomSpeechTime += 3000
|
|
iDodgeReactCount++
|
|
ENDIF
|
|
ENDIF
|
|
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDPROC
|
|
|
|
// handle plane falling
|
|
PROC HANDLE_PLANE_FALLING()
|
|
SWITCH planeFallingState
|
|
CASE PLANE_FALLING_ON_RECORDING
|
|
IF IS_VEHICLE_DRIVEABLE(planeFightVehicle[PFV_CARGO_PLANE])
|
|
//SET_ENTITY_LOAD_COLLISION_FLAG(planeFightVehicle[PFV_CARGO_PLANE], TRUE)
|
|
//PRINTSTRING("HERE1") PRINTNL()
|
|
|
|
//PRINTSTRING("HERE3") PRINTNL()
|
|
planeFallingState = PLANE_FALLING_FORCE_TO_DIVE
|
|
ENDIF
|
|
BREAK
|
|
|
|
CASE PLANE_FALLING_FORCE_TO_DIVE
|
|
IF NOT bStoppedWindStream
|
|
STOP_STREAM()
|
|
//PLAY_SOUND_FROM_COORD(iTransitionSoundID, "Transition_Sound", <<1903.29, 4085.20, 1462.66>>, "EXILE_1")
|
|
//printstring("stop stream") printnl()
|
|
bStoppedWindStream = TRUE
|
|
ELSE
|
|
//printstring("here1") printnl()
|
|
IF NOT bLoadedCrashStream
|
|
bLoadedCrashStream = LOAD_STREAM("Pt2_Succeed", "EXILE_1")
|
|
//printstring("here2") printnl()
|
|
ELSE
|
|
IF NOT bPlayingCrashStream
|
|
PLAY_STREAM_FROM_VEHICLE(planeFightVehicle[PFV_CARGO_PLANE])
|
|
//PLAY_STREAM_FRONTEND()
|
|
//printstring("here3") printnl()
|
|
bPlayingCrashStream = TRUE
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
|
|
BOOL bCleanupVehicle
|
|
IF IS_VEHICLE_DRIVEABLE(planeFightVehicle[PFV_CARGO_PLANE])
|
|
IF IS_PLAYBACK_GOING_ON_FOR_VEHICLE(planeFightVehicle[PFV_CARGO_PLANE])
|
|
fPlaneInteriorSpeed = fPlaneInteriorSpeed +@ 0.8
|
|
IF fPlaneInteriorSpeed >= 1.4
|
|
fPlaneInteriorSpeed = 1.4
|
|
ENDIF
|
|
|
|
IF NOT bDoneExplodePlaneVFX
|
|
IF GET_TIME_POSITION_IN_RECORDING(planeFightVehicle[PFV_CARGO_PLANE]) >= 39600
|
|
SET_ENTITY_COLLISION(planeFightVehicle[PFV_CARGO_PLANE], FALSE)
|
|
DO_SMOKE_ON_PLANE(PLANE_SMOKE_GROUND_EXPLOSION)
|
|
DO_SMOKE_ON_PLANE(PLANE_SMOKE_GROUND_DUST_IMPACT)
|
|
DO_SMOKE_ON_PLANE(PLANE_SMOKE_GROUND_DUST_SETTLE)
|
|
bDoneExplodePlaneVFX = TRUE
|
|
ENDIF
|
|
ENDIF
|
|
|
|
SET_PLAYBACK_SPEED(planeFightVehicle[PFV_CARGO_PLANE], fPlaneInteriorSpeed)
|
|
|
|
IF GET_TIME_POSITION_IN_RECORDING(planeFightVehicle[PFV_CARGO_PLANE]) >= 43000
|
|
bCleanupVehicle = TRUE
|
|
ENDIF
|
|
ELSE
|
|
bCleanupVehicle = TRUE
|
|
ENDIF
|
|
ELSE
|
|
bCleanupVehicle = TRUE
|
|
ENDIF
|
|
|
|
IF bCleanupVehicle
|
|
KILL_CHASE_HINT_CAM(localChaseHintCamStruct)
|
|
|
|
IF NOT IS_ENTITY_DEAD(transportedVehicle[TRANSPORTED_VEHICLE_INDEX_4WD_DRIVE].veh)
|
|
IF IS_ENTITY_ATTACHED(transportedVehicle[TRANSPORTED_VEHICLE_INDEX_4WD_DRIVE].veh)
|
|
DELETE_VEHICLE(transportedVehicle[TRANSPORTED_VEHICLE_INDEX_4WD_DRIVE].veh)
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF DOES_ENTITY_EXIST(planeFightVehicle[PFV_CARGO_PLANE])
|
|
DELETE_VEHICLE(planeFightVehicle[PFV_CARGO_PLANE])
|
|
ENDIF
|
|
|
|
SET_BUILDING_STATE(BUILDINGNAME_IPL_CARGOPLANE, BUILDINGSTATE_DESTROYED)
|
|
|
|
planeFallingState = PLANE_FALLING_DONE
|
|
|
|
ENDIF
|
|
BREAK
|
|
|
|
CASE PLANE_FALLING_DONE
|
|
/*
|
|
IF NOT bStoppedDustCloud
|
|
IF GET_GAME_TIMER() >= iPlaneCrashTime + 3500
|
|
IF IS_VEHICLE_DRIVEABLE(planeFightVehicle[PFV_CARGO_PLANE])
|
|
STOP_SMOKE_ON_PLANE(PLANE_SMOKE_GROUND_DUST_SETTLE)
|
|
bStoppedDustCloud = TRUE
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
*/
|
|
BREAK
|
|
ENDSWITCH
|
|
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
|
|
|
|
// get heading near to heading
|
|
PROC GET_HEADING_NEAR_TO_HEADING(FLOAT &fHeading, FLOAT fTargetHeading)
|
|
FLOAT fDiff = fHeading - fTargetHeading
|
|
IF fDiff < -90
|
|
fHeading += 360
|
|
ELIF fDiff > 90
|
|
fHeading -= 360
|
|
ENDIF
|
|
ENDPROC
|
|
|
|
// check heading
|
|
FUNC BOOL IS_PED_AT_SAME_HEADING_AS_VEHICLE(PED_INDEX ped, VEHICLE_INDEX veh, FLOAT allowAngleFrom0 = 25.0)
|
|
FLOAT fPedHeading = NORMALISE_HEADING(GET_ENTITY_HEADING(ped))
|
|
FLOAT fAnimHeading = NORMALISE_HEADING(GET_ENTITY_HEADING(veh))
|
|
FLOAT fHeadingDiff = fPedHeading - fAnimHeading
|
|
IF fHeadingDiff < 0
|
|
fHeadingDiff *= -1
|
|
ENDIF
|
|
IF fHeadingDiff <= allowAngleFrom0
|
|
OR fHeadingDiff >= 360 - allowAngleFrom0
|
|
RETURN TRUE
|
|
ENDIF
|
|
|
|
RETURN FALSE
|
|
ENDFUNC
|
|
|
|
// shift float to an ideal
|
|
PROC SHIFT_FLOAT_TO_IDEAL_FLOAT(FLOAT &fCurrent, FLOAT fIdeal, FLOAT fSpeed)
|
|
IF fCurrent < fIdeal
|
|
fCurrent = fCurrent +@ fSpeed
|
|
IF fCurrent > fIdeal
|
|
fCurrent = fIdeal
|
|
ENDIF
|
|
ELIF fCurrent > fIdeal
|
|
fCurrent = fCurrent -@ fSpeed
|
|
IF fCurrent < fIdeal
|
|
fCurrent = fIdeal
|
|
ENDIF
|
|
ENDIF
|
|
ENDPROC
|
|
|
|
// shift vector to an ideal
|
|
PROC SHIFT_VECTOR_TO_IDEAL_VECTOR(VECTOR &vCurrent, VECTOR vIdeal, FLOAT fSpeed)
|
|
SHIFT_FLOAT_TO_IDEAL_FLOAT(vCurrent.x, vIdeal.x, fSpeed)
|
|
SHIFT_FLOAT_TO_IDEAL_FLOAT(vCurrent.y, vIdeal.y, fSpeed)
|
|
SHIFT_FLOAT_TO_IDEAL_FLOAT(vCurrent.z, vIdeal.z, fSpeed)
|
|
ENDPROC
|
|
|
|
// set a new ladder state
|
|
PROC SET_LADDER_STATE(LADDER_STATE_ENUM newState)
|
|
SWITCH newState
|
|
CASE LADDER_STATE_NOT_ON
|
|
IF ladderWeapon <> WEAPONTYPE_UNARMED
|
|
SET_CURRENT_PED_WEAPON(PLAYER_PED_ID(), ladderWeapon, ladderState = LADDER_STATE_GETTING_OFF_TOP)
|
|
ENDIF
|
|
//REMOVE_MISSION_TEXT(FALSE)
|
|
SET_PLAYER_CONTROL(PLAYER_ID(), TRUE)
|
|
BREAK
|
|
|
|
CASE LADDER_STATE_IDLE
|
|
TASK_PLAY_ANIM(PLAYER_PED_ID(), GET_PLANE_FIGHT_ANIM_DICT_AS_STRING(PF_ANIM_DICT_LADDERS_BASE), "base_left_hand_up", NORMAL_BLEND_IN, NORMAL_BLEND_OUT, -1, AF_LOOPING | AF_FORCE_START)
|
|
BREAK
|
|
|
|
CASE LADDER_STATE_GOING_UP
|
|
TASK_PLAY_ANIM(PLAYER_PED_ID(), GET_PLANE_FIGHT_ANIM_DICT_AS_STRING(PF_ANIM_DICT_LADDERS_BASE), "climb_up", NORMAL_BLEND_IN, NORMAL_BLEND_OUT, -1, AF_LOOPING | AF_FORCE_START)
|
|
BREAK
|
|
|
|
CASE LADDER_STATE_GOING_DOWN
|
|
TASK_PLAY_ANIM(PLAYER_PED_ID(), GET_PLANE_FIGHT_ANIM_DICT_AS_STRING(PF_ANIM_DICT_LADDERS_BASE), "climb_down", NORMAL_BLEND_IN, NORMAL_BLEND_OUT, -1, AF_LOOPING | AF_FORCE_START)
|
|
BREAK
|
|
|
|
CASE LADDER_STATE_GETTING_ON
|
|
IF NOT bChangedPilotSpeaker
|
|
REMOVE_PED_FOR_DIALOGUE(planeFightConversation, 4)
|
|
IF NOT IS_PED_INJURED(namedEnemyPed[ENEMY_PILOT])
|
|
ADD_PED_FOR_DIALOGUE(planeFightConversation, 4, namedEnemyPed[ENEMY_PILOT], "MERCPLANE")
|
|
ENDIF
|
|
bChangedPilotSpeaker = TRUE
|
|
ENDIF
|
|
|
|
GET_CURRENT_PED_WEAPON(PLAYER_PED_ID(), ladderWeapon)
|
|
SET_CURRENT_PED_WEAPON(PLAYER_PED_ID(), WEAPONTYPE_UNARMED, TRUE)
|
|
|
|
vAttachLadder = GET_OFFSET_FROM_ENTITY_GIVEN_WORLD_COORDS(planeFightVehicle[PFV_CARGO_PLANE], GET_ENTITY_COORDS(PLAYER_PED_ID()))
|
|
vLadderRot = GET_ENTITY_ROTATION(PLAYER_PED_ID()) - GET_ENTITY_ROTATION(planeFightVehicle[PFV_CARGO_PLANE])
|
|
vLadderRot.x = NORMALISE_HEADING(vLadderRot.x)
|
|
vLadderRot.y = NORMALISE_HEADING(vLadderRot.y)
|
|
vLadderRot.z = NORMALISE_HEADING(vLadderRot.z)
|
|
GET_HEADING_NEAR_TO_HEADING(vLadderRot.x, 0)
|
|
GET_HEADING_NEAR_TO_HEADING(vLadderRot.y, 0)
|
|
GET_HEADING_NEAR_TO_HEADING(vLadderRot.z, 0)
|
|
|
|
//REMOVE_ALL_BLIPS()
|
|
REMOVE_MISSION_TEXT(FALSE)
|
|
|
|
TASK_PLAY_ANIM(PLAYER_PED_ID(), GET_PLANE_FIGHT_ANIM_DICT_AS_STRING(PF_ANIM_DICT_LADDERS_BASE), "get_on_bottom_front_stand_high", SLOW_BLEND_IN, NORMAL_BLEND_OUT, -1, AF_HOLD_LAST_FRAME | AF_FORCE_START, 0.2)
|
|
SET_PLAYER_CONTROL(PLAYER_ID(), FALSE, SPC_LEAVE_CAMERA_CONTROL_ON)
|
|
BREAK
|
|
|
|
CASE LADDER_STATE_GETTING_OFF_BOTTOM
|
|
DETACH_ENTITY(PLAYER_PED_ID(), FALSE, FALSE)
|
|
TASK_PLAY_ANIM(PLAYER_PED_ID(), GET_PLANE_FIGHT_ANIM_DICT_AS_STRING(PF_ANIM_DICT_LADDERS_BASE), "get_off_bottom_front_stand", NORMAL_BLEND_IN, NORMAL_BLEND_OUT, -1, AF_FORCE_START)
|
|
BREAK
|
|
|
|
CASE LADDER_STATE_GETTING_OFF_TOP
|
|
IF NOT bOffLadder
|
|
IF DOES_BLIP_EXIST(getToBlip)
|
|
REMOVE_BLIP(getToBlip)
|
|
REMOVE_MISSION_TEXT(FALSE, TRUE, FALSE)
|
|
ENDIF
|
|
SET_PED_CAPSULE(PLAYER_PED_ID(), 0.3)
|
|
iCrewShootTime = GET_GAME_TIMER() + 800
|
|
bOffLadder = TRUE
|
|
ENDIF
|
|
|
|
TASK_PLAY_ANIM(PLAYER_PED_ID(), GET_PLANE_FIGHT_ANIM_DICT_AS_STRING(PF_ANIM_DICT_LADDERS_MAIN), "get_off_top_back_stand_right_hand", NORMAL_BLEND_IN, NORMAL_BLEND_OUT, -1, AF_FORCE_START)
|
|
BREAK
|
|
ENDSWITCH
|
|
|
|
ladderState = newState
|
|
ENDPROC
|
|
|
|
// handle ladder
|
|
CONST_INT LADDER_INPUT_Y 100
|
|
CONST_FLOAT LADDER_X -0.75
|
|
CONST_FLOAT LADDER_Y 22.64
|
|
CONST_FLOAT INTERP_TO_LADDER_POS_SPEED 0.4
|
|
CONST_FLOAT INTERP_TO_LADDER_ROT_SPEED 30.0
|
|
CONST_FLOAT LADDER_OFF_HEIGHT -2.0
|
|
CONST_FLOAT LADDER_TOP_HEIGHT -0.2
|
|
|
|
PROC HANDLE_LADDER()
|
|
INT iLX, iLY, iRX, iRY
|
|
FLOAT fPhase = 0.0
|
|
VECTOR vDisplace = GET_PED_EXTRACTED_DISPLACEMENT(PLAYER_PED_ID(), FALSE)
|
|
GET_CONTROL_VALUE_OF_ANALOGUE_STICKS(iLX, iLY, iRX, iRY)
|
|
|
|
// handle blip
|
|
VECTOR vLadderCoords = GET_LADDER_COORDS()
|
|
VECTOR vCockpitCoords = GET_COCKPIT_COORDS()
|
|
VECTOR vUseCoords
|
|
|
|
IF ladderState = LADDER_STATE_NOT_ON
|
|
vUseCoords = vLadderCoords
|
|
//IS_ENTITY_AT_COORD(PLAYER_PED_ID(), vUseCoords, <<2, 2, LOCATE_SIZE_HEIGHT>>, TRUE)
|
|
ELSE
|
|
vUseCoords = vCockpitCoords
|
|
ENDIF
|
|
|
|
IF NOT bOffLadder
|
|
IF DOES_BLIP_EXIST(getToBlip)
|
|
SET_BLIP_COORDS(getToBlip, vUseCoords)
|
|
ELSE
|
|
getToBlip = CREATE_MISSION_BLIP_FOR_COORD(vUseCoords)
|
|
ENDIF
|
|
ENDIF
|
|
|
|
SWITCH ladderState
|
|
CASE LADDER_STATE_NOT_ON
|
|
IF IS_ENTITY_AT_COORD(PLAYER_PED_ID(), vLadderCoords, <<0.5, 0.4, 1.3>>, FALSE, TRUE, TM_ON_FOOT)
|
|
AND IS_PED_AT_SAME_HEADING_AS_VEHICLE(PLAYER_PED_ID(), planeFightVehicle[PFV_CARGO_PLANE], 40)
|
|
AND NOT IS_PED_RAGDOLL(PLAYER_PED_ID())
|
|
AND (IS_PED_WALKING(PLAYER_PED_ID()) OR IS_PED_RUNNING(PLAYER_PED_ID()) OR IS_PED_SPRINTING(PLAYER_PED_ID()))
|
|
SET_LADDER_STATE(LADDER_STATE_GETTING_ON)
|
|
ENDIF
|
|
BREAK
|
|
|
|
CASE LADDER_STATE_GETTING_ON
|
|
|
|
IF IS_ENTITY_PLAYING_ANIM(PLAYER_PED_ID(), GET_PLANE_FIGHT_ANIM_DICT_AS_STRING(PF_ANIM_DICT_LADDERS_BASE), "get_on_bottom_front_stand_high")
|
|
fPhase = GET_ENTITY_ANIM_CURRENT_TIME(PLAYER_PED_ID(), GET_PLANE_FIGHT_ANIM_DICT_AS_STRING(PF_ANIM_DICT_LADDERS_BASE), "get_on_bottom_front_stand_high")
|
|
ENDIF
|
|
|
|
IF fPhase >= 0.98
|
|
SET_LADDER_STATE(LADDER_STATE_IDLE)
|
|
ENDIF
|
|
BREAK
|
|
|
|
CASE LADDER_STATE_GETTING_OFF_BOTTOM
|
|
IF IS_ENTITY_PLAYING_ANIM(PLAYER_PED_ID(), GET_PLANE_FIGHT_ANIM_DICT_AS_STRING(PF_ANIM_DICT_LADDERS_BASE), "get_off_bottom_front_stand")
|
|
fPhase = GET_ENTITY_ANIM_CURRENT_TIME(PLAYER_PED_ID(), GET_PLANE_FIGHT_ANIM_DICT_AS_STRING(PF_ANIM_DICT_LADDERS_BASE), "get_off_bottom_front_stand")
|
|
ELSE
|
|
SET_LADDER_STATE(LADDER_STATE_NOT_ON)
|
|
ENDIF
|
|
|
|
IF fPhase >= 0.98
|
|
SET_LADDER_STATE(LADDER_STATE_NOT_ON)
|
|
ENDIF
|
|
BREAK
|
|
|
|
CASE LADDER_STATE_GETTING_OFF_TOP
|
|
IF IS_ENTITY_PLAYING_ANIM(PLAYER_PED_ID(), GET_PLANE_FIGHT_ANIM_DICT_AS_STRING(PF_ANIM_DICT_LADDERS_MAIN), "get_off_top_back_stand_right_hand")
|
|
fPhase = GET_ENTITY_ANIM_CURRENT_TIME(PLAYER_PED_ID(), GET_PLANE_FIGHT_ANIM_DICT_AS_STRING(PF_ANIM_DICT_LADDERS_MAIN), "get_off_top_back_stand_right_hand")
|
|
ELSE
|
|
DETACH_ENTITY(PLAYER_PED_ID(), FALSE, FALSE)
|
|
SET_LADDER_STATE(LADDER_STATE_NOT_ON)
|
|
ENDIF
|
|
|
|
IF fPhase >= 0.98
|
|
DETACH_ENTITY(PLAYER_PED_ID(), FALSE, FALSE)
|
|
SET_LADDER_STATE(LADDER_STATE_NOT_ON)
|
|
ENDIF
|
|
BREAK
|
|
|
|
CASE LADDER_STATE_IDLE
|
|
IF iLY < -LADDER_INPUT_Y
|
|
IF vAttachLadder.z < LADDER_TOP_HEIGHT
|
|
SET_LADDER_STATE(LADDER_STATE_GOING_UP)
|
|
ENDIF
|
|
ELIF iLY > LADDER_INPUT_Y
|
|
IF vAttachLadder.z > LADDER_OFF_HEIGHT
|
|
SET_LADDER_STATE(LADDER_STATE_GOING_DOWN)
|
|
ELSE
|
|
SET_LADDER_STATE(LADDER_STATE_GETTING_OFF_BOTTOM)
|
|
ENDIF
|
|
ENDIF
|
|
BREAK
|
|
|
|
CASE LADDER_STATE_GOING_UP
|
|
IF IS_ENTITY_PLAYING_ANIM(PLAYER_PED_ID(), GET_PLANE_FIGHT_ANIM_DICT_AS_STRING(PF_ANIM_DICT_LADDERS_BASE), "climb_up")
|
|
fPhase = GET_ENTITY_ANIM_CURRENT_TIME(PLAYER_PED_ID(), GET_PLANE_FIGHT_ANIM_DICT_AS_STRING(PF_ANIM_DICT_LADDERS_BASE), "climb_up")
|
|
ENDIF
|
|
|
|
IF vAttachLadder.z >= LADDER_TOP_HEIGHT
|
|
SET_LADDER_STATE(LADDER_STATE_GETTING_OFF_TOP)
|
|
ELIF iLY >= -LADDER_INPUT_Y
|
|
IF fPhase >= 0.90
|
|
SET_LADDER_STATE(LADDER_STATE_IDLE)
|
|
ENDIF
|
|
ENDIF
|
|
BREAK
|
|
|
|
CASE LADDER_STATE_GOING_DOWN
|
|
IF IS_ENTITY_PLAYING_ANIM(PLAYER_PED_ID(), GET_PLANE_FIGHT_ANIM_DICT_AS_STRING(PF_ANIM_DICT_LADDERS_BASE), "climb_down")
|
|
fPhase = GET_ENTITY_ANIM_CURRENT_TIME(PLAYER_PED_ID(), GET_PLANE_FIGHT_ANIM_DICT_AS_STRING(PF_ANIM_DICT_LADDERS_BASE), "climb_down")
|
|
ENDIF
|
|
|
|
IF fPhase >= 0.90
|
|
IF iLY <= LADDER_INPUT_Y
|
|
OR vAttachLadder.z <= LADDER_OFF_HEIGHT
|
|
SET_LADDER_STATE(LADDER_STATE_IDLE)
|
|
ENDIF
|
|
ENDIF
|
|
BREAK
|
|
ENDSWITCH
|
|
|
|
IF ladderState > LADDER_STATE_NOT_ON
|
|
//IF NOT bOnLadderForCam
|
|
// iOnLadderForCamTime = GET_GAME_TIMER()
|
|
// bOnLadderForCam = TRUE
|
|
//ENDIF
|
|
ALLOW_ALTERNATIVE_SCRIPT_CONTROLS_LAYOUT(PLAYER_CONTROL)
|
|
SET_FOLLOW_PED_CAM_LADDER_ALIGN_THIS_UPDATE()
|
|
//iOnLadderForCamTime=iOnLadderForCamTime
|
|
//IF GET_GAME_TIMER() >= iOnLadderForCamTime + 1000
|
|
SET_FOLLOW_PED_CAM_THIS_UPDATE("FOLLOW_PED_ON_EXILE1_LADDER_CAMERA", 1500)
|
|
//ENDIF
|
|
//ELSE
|
|
// bOnLadderForCam = FALSE
|
|
ENDIF
|
|
|
|
IF ladderState <> LADDER_STATE_NOT_ON
|
|
AND ladderState <> LADDER_STATE_GETTING_OFF_BOTTOM
|
|
|
|
SHIFT_FLOAT_TO_IDEAL_FLOAT(vAttachLadder.x, LADDER_X, INTERP_TO_LADDER_POS_SPEED)
|
|
|
|
IF vAttachLadder.z >= -1.27
|
|
SHIFT_FLOAT_TO_IDEAL_FLOAT(vAttachLadder.y, LADDER_Y + 0.07, INTERP_TO_LADDER_POS_SPEED) // 0.08
|
|
ELIF vAttachLadder.z >= -1.56
|
|
SHIFT_FLOAT_TO_IDEAL_FLOAT(vAttachLadder.y, LADDER_Y + 0.02, INTERP_TO_LADDER_POS_SPEED) // 0.03
|
|
ELSE
|
|
SHIFT_FLOAT_TO_IDEAL_FLOAT(vAttachLadder.y, LADDER_Y, INTERP_TO_LADDER_POS_SPEED)
|
|
ENDIF
|
|
|
|
FLOAT fIdealLadderZ = -5
|
|
FLOAT fShiftSpeed
|
|
FLOAT fAllowDiff
|
|
IF ladderState = LADDER_STATE_IDLE
|
|
IF vAttachLadder.z < -2
|
|
fIdealLadderZ = -2.4987//-2.5287
|
|
ELIF vAttachLadder.z < -1
|
|
fIdealLadderZ = -1.4952//-1.5252
|
|
ELSE
|
|
fIdealLadderZ = -0.500924//-0.530924
|
|
ENDIF
|
|
fShiftSpeed = 0.4//0.2
|
|
fAllowDiff = 1
|
|
ELIF ladderState = LADDER_STATE_GOING_UP
|
|
OR ladderState = LADDER_STATE_GETTING_ON
|
|
IF fPhase >= 0.8
|
|
IF vAttachLadder.z >= -0.500924
|
|
fIdealLadderZ = -0.500924
|
|
fShiftSpeed = 100.0
|
|
fAllowDiff = 0.2
|
|
ELIF vAttachLadder.z >= -0.700924
|
|
fIdealLadderZ = -0.500924
|
|
fShiftSpeed = 0.2
|
|
fAllowDiff = 0.2
|
|
ELIF vAttachLadder.z >= -1.4952
|
|
fIdealLadderZ = -1.4952
|
|
fShiftSpeed = 100.0
|
|
fAllowDiff = 0.2
|
|
ELIF vAttachLadder.z >= -1.6952
|
|
fIdealLadderZ = -1.4952
|
|
fShiftSpeed = 0.2
|
|
fAllowDiff = 0.2
|
|
ELIF vAttachLadder.z >= -2.4987
|
|
fIdealLadderZ = -2.4987
|
|
fShiftSpeed = 100.0
|
|
fAllowDiff = 0.2
|
|
ELIF vAttachLadder.z >= -2.6987
|
|
fIdealLadderZ = -2.4987
|
|
fShiftSpeed = 0.2
|
|
fAllowDiff = 0.2
|
|
ENDIF
|
|
ENDIF
|
|
|
|
ELIF ladderState = LADDER_STATE_GOING_DOWN
|
|
IF fPhase >= 0.8
|
|
IF vAttachLadder.z <= -0.300924
|
|
fIdealLadderZ = -0.500924
|
|
fShiftSpeed = 0.2
|
|
fAllowDiff = 0.2
|
|
ELIF vAttachLadder.z <= -0.500924
|
|
fIdealLadderZ = -0.500924
|
|
fShiftSpeed = 100
|
|
fAllowDiff = 0.2
|
|
ELIF vAttachLadder.z <= -1.0952
|
|
fIdealLadderZ = -1.4952
|
|
fShiftSpeed = 0.2
|
|
fAllowDiff = 0.2
|
|
ELIF vAttachLadder.z <= -1.4952
|
|
fIdealLadderZ = -1.4952
|
|
fShiftSpeed = 100
|
|
fAllowDiff = 0.2
|
|
ELIF vAttachLadder.z <= -2.0987
|
|
fIdealLadderZ = -2.4987
|
|
fShiftSpeed = 0.2
|
|
fAllowDiff = 0.2
|
|
ELIF vAttachLadder.z <= -2.4987
|
|
fIdealLadderZ = -2.4987
|
|
fShiftSpeed = 100
|
|
fAllowDiff = 0.2
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
|
|
//OR ladderState = LADDER_STATE_GOING_DOWN
|
|
|
|
IF fIdealLadderZ > -5
|
|
FLOAT fDiff
|
|
fDiff = fIdealLadderZ - vAttachLadder.z
|
|
IF fDiff < 0
|
|
fDiff *= -1
|
|
ENDIF
|
|
IF fDiff < fAllowDiff
|
|
SHIFT_FLOAT_TO_IDEAL_FLOAT(vAttachLadder.z, fIdealLadderZ, fShiftSpeed)
|
|
ENDIF
|
|
ENDIF
|
|
|
|
SHIFT_VECTOR_TO_IDEAL_VECTOR(vLadderRot, <<0,0,0>>, INTERP_TO_LADDER_ROT_SPEED)
|
|
|
|
printvector(vAttachLadder) printnl()
|
|
vAttachLadder.z += vDisplace.z
|
|
|
|
IF ladderState <> LADDER_STATE_GETTING_ON
|
|
vAttachLadder.x += vDisplace.x
|
|
vAttachLadder.y += vDisplace.y
|
|
ENDIF
|
|
|
|
IF ladderState <> LADDER_STATE_GETTING_OFF_TOP
|
|
IF vAttachLadder.z > LADDER_TOP_HEIGHT
|
|
vAttachLadder.z = LADDER_TOP_HEIGHT
|
|
ENDIF
|
|
|
|
IF vAttachLadder.z < -1.56
|
|
IF vAttachLadder.y > LADDER_Y
|
|
vAttachLadder.y = LADDER_Y
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
|
|
ATTACH_ENTITY_TO_ENTITY(PLAYER_PED_ID(), planeFightVehicle[PFV_CARGO_PLANE], 0, vAttachLadder, vLadderRot, FALSE, FALSE, FALSE, TRUE)
|
|
ENDIF
|
|
ENDPROC
|
|
|
|
// request plane interior assets
|
|
PROC REQUEST_PLANE_INTERIOR_ASSETS()
|
|
ADD_MODEL_REQUEST(ENUM_TO_INT(PFM_ENEMY))
|
|
//ADD_MODEL_REQUEST(ENUM_TO_INT(PFM_VAN))
|
|
ADD_MODEL_REQUEST(ENUM_TO_INT(PFM_4WD))
|
|
ADD_MODEL_REQUEST(ENUM_TO_INT(PFM_COVER1))
|
|
ADD_MODEL_REQUEST(ENUM_TO_INT(PFM_COVER2))
|
|
ADD_ANIM_DICT_REQUEST(PF_ANIM_DICT_MISSION)
|
|
ENDPROC
|
|
|
|
// is ped at correct heading
|
|
FUNC BOOL IS_PED_AT_CORRECT_HEADING(PED_INDEX ped, FLOAT fTargetHeading, FLOAT allowAngleFrom0 = 25.0)
|
|
FLOAT fPedHeading = NORMALISE_HEADING(GET_ENTITY_HEADING(ped))
|
|
FLOAT fHeadingDiff = fPedHeading - fTargetHeading
|
|
IF fHeadingDiff < 0
|
|
fHeadingDiff *= -1
|
|
ENDIF
|
|
IF fHeadingDiff <= allowAngleFrom0
|
|
OR fHeadingDiff >= 360 - allowAngleFrom0
|
|
RETURN TRUE
|
|
ENDIF
|
|
|
|
RETURN FALSE
|
|
ENDFUNC
|
|
|
|
// do the plane headings match?
|
|
FUNC BOOL DO_PLANE_HEADINGS_MATCH(VEHICLE_INDEX plane1Veh, VEHICLE_INDEX plane2Veh, FLOAT allowAngleFrom0 = 30.0)
|
|
IF IS_VEHICLE_DRIVEABLE(plane1Veh)
|
|
AND IS_VEHICLE_DRIVEABLE(plane2Veh)
|
|
// must have a similar heading
|
|
FLOAT fPlane1Heading = NORMALISE_HEADING(GET_ENTITY_HEADING(plane1Veh))
|
|
FLOAT fPlane2Heading = NORMALISE_HEADING(GET_ENTITY_HEADING(plane2Veh))
|
|
FLOAT fHeadingDiff = fPlane1Heading - fPlane2Heading
|
|
IF fHeadingDiff < 0
|
|
fHeadingDiff *= -1
|
|
ENDIF
|
|
IF fHeadingDiff <= allowAngleFrom0
|
|
OR fHeadingDiff >= 360 - allowAngleFrom0
|
|
RETURN TRUE
|
|
ENDIF
|
|
ENDIF
|
|
|
|
RETURN FALSE
|
|
ENDFUNC
|
|
|
|
// do the plane pitches match?
|
|
FUNC BOOL DO_PLANE_PITCHES_MATCH(VEHICLE_INDEX plane1Veh, VEHICLE_INDEX plane2Veh, FLOAT allowAngleFrom0 = 30.0)
|
|
IF IS_VEHICLE_DRIVEABLE(plane1Veh)
|
|
AND IS_VEHICLE_DRIVEABLE(plane2Veh)
|
|
// must have a similar heading
|
|
VECTOR vPlane1Rot = GET_ENTITY_ROTATION(plane1Veh)
|
|
VECTOR vPlane2Rot = GET_ENTITY_ROTATION(plane2Veh)
|
|
FLOAT fPlane1Heading = NORMALISE_HEADING(vPlane1Rot.x)
|
|
FLOAT fPlane2Heading = NORMALISE_HEADING(vPlane2Rot.x)
|
|
FLOAT fHeadingDiff = fPlane1Heading - fPlane2Heading
|
|
IF fHeadingDiff < 0
|
|
fHeadingDiff *= -1
|
|
ENDIF
|
|
IF fHeadingDiff <= allowAngleFrom0
|
|
OR fHeadingDiff >= 360 - allowAngleFrom0
|
|
RETURN TRUE
|
|
ENDIF
|
|
ENDIF
|
|
|
|
RETURN FALSE
|
|
ENDFUNC
|
|
|
|
// crop dusting
|
|
/*
|
|
CONST_FLOAT ALLOW_DUSTING_Z 12.5
|
|
CONST_FLOAT CANCEL_DUSTING_Z 10.0
|
|
|
|
PROC HANDLE_CROP_DUSTING()
|
|
BOOL bClearHelp = FALSE
|
|
IF IS_VEHICLE_DRIVEABLE(planeFightVehicle[PFV_TREVOR_PLANE])
|
|
IF IS_PED_SITTING_IN_VEHICLE(PLAYER_PED_ID(), planeFightVehicle[PFV_TREVOR_PLANE])
|
|
// get distance above ground
|
|
VECTOR vPlanePos = GET_ENTITY_COORDS(planeFightVehicle[PFV_TREVOR_PLANE])
|
|
FLOAT fGroundHeight
|
|
FLOAT fDistanceAboveGround
|
|
GET_GROUND_Z_FOR_3D_COORD(vPlanePos, fGroundHeight)
|
|
fDistanceAboveGround = vPlanePos.z - fGroundHeight
|
|
|
|
// help
|
|
IF NOT bShownCropHelp
|
|
IF bCropDustingOn
|
|
bShownCropHelp = TRUE
|
|
ELSE
|
|
IF iCropHelpTime < 0
|
|
IF bShownGodText
|
|
iCropHelpTime = GET_GAME_TIMER()
|
|
ENDIF
|
|
ELSE
|
|
VECTOR vPos = GET_ENTITY_COORDS(planeFightVehicle[PFV_TREVOR_PLANE])
|
|
IF vPos.x < 820
|
|
IF fDistanceAboveGround >= ALLOW_DUSTING_Z
|
|
bShownCropHelp = DO_MISSION_HELP_TEXT("PF_CRPHLP")
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
|
|
// implementation
|
|
IF NOT bCropDustingOn
|
|
IF IS_CONTROL_JUST_PRESSED(PLAYER_CONTROL, INPUT_DUCK)
|
|
IF fDistanceAboveGround >= ALLOW_DUSTING_Z
|
|
bClearHelp = TRUE
|
|
dustPTFX = START_PARTICLE_FX_LOOPED_ON_ENTITY("scr_crop_spreading_spray", planeFightVehicle[PFV_TREVOR_PLANE], <<0.0, 0.0, 0.0>>, <<0.0, 0.0, 0.0>>)
|
|
ENABLE_CROP_DUSTING_SOUNDS(planeFightVehicle[PFV_TREVOR_PLANE], TRUE)
|
|
bDustPTFXActive = TRUE
|
|
bCropDustingOn = TRUE
|
|
ENDIF
|
|
ENDIF
|
|
ELSE
|
|
IF IS_CONTROL_JUST_PRESSED(PLAYER_CONTROL, INPUT_DUCK)
|
|
OR fDistanceAboveGround < CANCEL_DUSTING_Z
|
|
STOP_CROP_DUST_PTFX()
|
|
bCropDustingOn = FALSE
|
|
ENDIF
|
|
ENDIF
|
|
ELSE
|
|
STOP_CROP_DUST_PTFX()
|
|
bClearHelp = TRUE
|
|
bCropDustingOn = FALSE
|
|
ENDIF
|
|
ELSE
|
|
STOP_CROP_DUST_PTFX()
|
|
bClearHelp = TRUE
|
|
ENDIF
|
|
|
|
IF bClearHelp
|
|
IF GET_GAME_TIMER() >= iClearHelpTime
|
|
IF IS_THIS_HELP_MESSAGE_BEING_DISPLAYED("PF_CRPHLP")
|
|
CLEAR_HELP(FALSE)
|
|
iClearHelpTime = GET_GAME_TIMER() + 1000
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDPROC
|
|
*/
|
|
|
|
// handle cargo plane speed
|
|
PROC HANDLE_CARGO_PLANE_SPEED()
|
|
IF IS_VEHICLE_DRIVEABLE(planeFightVehicle[PFV_CARGO_PLANE])
|
|
SET_VEHICLE_ENGINE_ON(planeFightVehicle[PFV_CARGO_PLANE], TRUE, TRUE)
|
|
|
|
IF IS_PLAYBACK_GOING_ON_FOR_VEHICLE(planeFightVehicle[PFV_CARGO_PLANE])
|
|
FLOAT fTargetSpeed
|
|
fPlaneDistance = GET_DISTANCE_BETWEEN_ENTITIES(PLAYER_PED_ID(), planeFightVehicle[PFV_CARGO_PLANE], FALSE)
|
|
fPlaybackTime = GET_TIME_POSITION_IN_RECORDING(planeFightVehicle[PFV_CARGO_PLANE])
|
|
|
|
FLOAT fAccelerate = 0.1
|
|
FLOAT fDecelerate = 0.1
|
|
BOOL bInstantAcceleration = FALSE
|
|
|
|
VECTOR vPlayerPos = GET_ENTITY_COORDS(PLAYER_PED_ID())
|
|
|
|
IF currentMissionStage = STAGE_ENTER_PLANE
|
|
IF fPlaneDistance <= 310
|
|
fTargetSpeed = CARGO_PLANE_SPEED
|
|
ELSE
|
|
fTargetSpeed = 0.60
|
|
ENDIF
|
|
ELSE
|
|
IF NOT bActivatedCargoPlaneSpeed
|
|
IF fPlaneDistance <= 3000
|
|
OR vPlayerPos.x < -381
|
|
OR vPlayerPos.x > 3356
|
|
OR vPlayerPos.y > 5915
|
|
OR vPlayerPos.y < 2005
|
|
IF fPlaneDistance > 3000
|
|
bBeenCloseToPlane = TRUE
|
|
ENDIF
|
|
bActivatedCargoPlaneSpeed = TRUE
|
|
bInstantAcceleration = TRUE
|
|
fTargetSpeed = 1.1
|
|
ELSE
|
|
fTargetSpeed = 0.0
|
|
ENDIF
|
|
ELSE
|
|
IF fPlaybackTime >= ALLOW_FLY_HIGH_TIME
|
|
fTargetSpeed = 0.55
|
|
fDecelerate = 0.04
|
|
ELSE
|
|
FLOAT fSpeedUpDistance
|
|
FLOAT fSlowDownDistance
|
|
FLOAT fFastSpeed = 0.81//1.11
|
|
FLOAT fMediumSpeed = 0.57//0.87
|
|
FLOAT fSlowSpeed = 0.41//0.71
|
|
|
|
// start slowing down before open door
|
|
IF fPlaybackTime >= 160000
|
|
// catch up some more
|
|
fSpeedUpDistance = 900
|
|
fSlowDownDistance = 1300
|
|
ELIF fPlaybackTime >= 120000
|
|
// catch up a bit
|
|
fSpeedUpDistance = 1100
|
|
fSlowDownDistance = 1600
|
|
ELIF fPlaybackTime >= 90600
|
|
// after corner
|
|
fSpeedUpDistance = 1200
|
|
fSlowDownDistance = 1700
|
|
ELIF fPlaybackTime >= 51400
|
|
// speed up round corner
|
|
fSpeedUpDistance = 1800
|
|
fSlowDownDistance = 2000
|
|
fFastSpeed = 1.8
|
|
ELIF fPlaybackTime >= 33900
|
|
// go towards corner
|
|
fSpeedUpDistance = 1600
|
|
fSlowDownDistance = 2000
|
|
ELSE
|
|
// start
|
|
fSpeedUpDistance = 1500
|
|
fSlowDownDistance = 3200
|
|
fMediumSpeed = 1.10
|
|
fFastSpeed = 1.10
|
|
ENDIF
|
|
|
|
IF fPlaneDistance < fSpeedUpDistance
|
|
fTargetSpeed = fFastSpeed
|
|
ELIF fPlaneDistance > fSlowDownDistance
|
|
fTargetSpeed = fSlowSpeed
|
|
ELSE
|
|
fTargetSpeed = fMediumSpeed
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF fPlaneSpeed < fTargetSpeed
|
|
IF bInstantAcceleration
|
|
fPlaneSpeed = fTargetSpeed
|
|
ELSE
|
|
fPlaneSpeed = fPlaneSpeed +@ fAccelerate
|
|
IF fPlaneSpeed > fTargetSpeed
|
|
fPlaneSpeed = fTargetSpeed
|
|
ENDIF
|
|
ENDIF
|
|
ELIF fPlaneSpeed > fTargetSpeed
|
|
fPlaneSpeed = fPlaneSpeed -@ fDecelerate
|
|
IF fPlaneSpeed < fTargetSpeed
|
|
fPlaneSpeed = fTargetSpeed
|
|
ENDIF
|
|
ENDIF
|
|
|
|
//PRINTSTRING("distance = ") PRINTFLOAT(fPlaneDistance) PRINTNL()
|
|
//PRINTSTRING("speed = ") PRINTFLOAT(fPlaneSpeed) PRINTNL()
|
|
//PRINTSTRING("time = ") PRINTFLOAT(fPlaybackTime) PRINTNL()
|
|
|
|
SET_PLAYBACK_SPEED(planeFightVehicle[PFV_CARGO_PLANE], fPlaneSpeed)
|
|
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, "EXL1_BANTERb")
|
|
OR ARE_STRINGS_EQUAL(tBanter, "EXL1_BANTERc")
|
|
//OR ARE_STRINGS_EQUAL(tBanter, "EXL1_BANT2")
|
|
OR ARE_STRINGS_EQUAL(tBanter, "EXL1_PBAN1")
|
|
OR ARE_STRINGS_EQUAL(tBanter, "EXL1_PBAN2")
|
|
OR ARE_STRINGS_EQUAL(tBanter, "EXL1_PBAN3")
|
|
OR ARE_STRINGS_EQUAL(tBanter, "EXL1_PBAN4")
|
|
OR ARE_STRINGS_EQUAL(tBanter, "EXL1_PBAN5")
|
|
OR ARE_STRINGS_EQUAL(tBanter, "EXL1_PBAN6")
|
|
OR ARE_STRINGS_EQUAL(tBanter, "EXL1_PBAN7")
|
|
OR ARE_STRINGS_EQUAL(tBanter, "EXL1_HAVEHGR")
|
|
OR ARE_STRINGS_EQUAL(tBanter, "EXL1_NOHGR")
|
|
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(planeFightConversation, "EXL1AUD", tSavedBanterRoot, tResumeBanterLabel, CONV_PRIORITY_HIGH)
|
|
RETURN TRUE
|
|
ENDIF
|
|
ENDIF
|
|
ELSE
|
|
RETURN TRUE
|
|
ENDIF
|
|
|
|
RETURN FALSE
|
|
ENDFUNC
|
|
|
|
// handle get to location
|
|
PROC HANDLE_GET_TO_LOCATION(BOOL bWithPlane, BOOL bWithRon, BOOL bEnforceWantedLevel = FALSE)
|
|
BOOL bPlayerPlaneOK = TRUE
|
|
BOOL bRonPlaneOK = TRUE
|
|
BOOL bRonGroupOK = TRUE
|
|
BOOL bWantedLevelOK = TRUE
|
|
BOOL bAllOK = FALSE
|
|
|
|
IF bWithRon
|
|
IF NOT IS_PED_INJURED(ronPed)
|
|
IF NOT IS_PED_GROUP_MEMBER(ronPed, PLAYER_GROUP_ID())
|
|
AND (currentMissionStage <> STAGE_GET_TO_AIRSTRIP OR bSetRonAsGroupMember)
|
|
bRonGroupOK = FALSE
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF bWithPlane
|
|
IF IS_VEHICLE_DRIVEABLE(planeFightVehicle[PFV_TREVOR_PLANE])
|
|
IF bWithRon
|
|
IF NOT IS_PED_INJURED(ronPed)
|
|
IF NOT IS_PED_IN_VEHICLE(ronPed, planeFightVehicle[PFV_TREVOR_PLANE])
|
|
bRonPlaneOK = FALSE
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
IF NOT IS_PED_IN_VEHICLE(PLAYER_PED_ID(), planeFightVehicle[PFV_TREVOR_PLANE])
|
|
bPlayerPlaneOK = FALSE
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF bEnforceWantedLevel
|
|
IF GET_PLAYER_WANTED_LEVEL(PLAYER_ID()) > 0
|
|
bWantedLevelOK = FALSE
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF bRonGroupOK
|
|
// ron is group member / not required to be in group
|
|
IF bPlayerPlaneOK
|
|
bShouldDoGetInText = FALSE
|
|
|
|
IF bWithPlane
|
|
IF iGetInTextStage < 2
|
|
iGetInTextStage = 2
|
|
ENDIF
|
|
ENDIF
|
|
|
|
// player is in plane / not required to be in plane
|
|
IF bRonPlaneOK
|
|
IF bWantedLevelOK
|
|
bAllOK = TRUE
|
|
bRemovedBlipsForWanted = FALSE
|
|
//bKilledConversationOnWanted = FALSE
|
|
bShownLoseWantedPrompt = FALSE
|
|
|
|
IF currentMissionStage > STAGE_GET_TO_AIRSTRIP
|
|
//blip the destination
|
|
IF NOT DOES_BLIP_EXIST(getToBlip)
|
|
REMOVE_MISSION_TEXT(FALSE, TRUE, FALSE)
|
|
REMOVE_ALL_BLIPS()
|
|
|
|
IF IS_VEHICLE_DRIVEABLE(planeFightVehicle[PFV_CARGO_PLANE])
|
|
getToBlip = CREATE_MISSION_BLIP_FOR_VEHICLE(planeFightVehicle[PFV_CARGO_PLANE])
|
|
ENDIF
|
|
ENDIF
|
|
ELSE
|
|
IF NOT DOES_BLIP_EXIST(trevorPlaneBlip)
|
|
REMOVE_MISSION_TEXT(FALSE, TRUE, FALSE)
|
|
REMOVE_ALL_BLIPS()
|
|
|
|
trevorPlaneBlip = CREATE_MISSION_BLIP_FOR_VEHICLE(planeFightVehicle[PFV_TREVOR_PLANE])
|
|
IF DOES_BLIP_EXIST(trevorPlaneBlip)
|
|
SET_BLIP_ROUTE(trevorPlaneBlip, TRUE)
|
|
SET_GPS_FLAGS(GPS_FLAG_CUSTOM_PROXIMITY, 10)
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
|
|
// god text
|
|
IF NOT bShownGodText
|
|
IF currentMissionStage > STAGE_GET_TO_AIRSTRIP
|
|
IF currentMissionStage = STAGE_FOLLOW_PLANE_1
|
|
OR currentMissionStage = STAGE_FOLLOW_PLANE_2
|
|
OR currentMissionStage = STAGE_FOLLOW_PLANE_3
|
|
IF bDoneGotoSpeech
|
|
IF NOT bDoneSeePlane
|
|
bShownGodText = DO_MISSION_GOD_TEXT("PF_FLY")
|
|
IF bShownGodText
|
|
REPLAY_RECORD_BACK_FOR_TIME(3.0, 20.0, REPLAY_IMPORTANCE_HIGHEST)
|
|
ENDIF
|
|
ELIF NOT bAllowFlyHigh
|
|
bShownGodText = DO_MISSION_GOD_TEXT("PF_FLYLOW")
|
|
ELSE
|
|
//IF bDoneFlyHighSpeech
|
|
IF bDoneHereWeGoSpeech
|
|
bShownGodText = DO_MISSION_GOD_TEXT("PF_FCLOSE")
|
|
//bShownGodText = DO_MISSION_GOD_TEXT("PF_CRASH")
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ELSE
|
|
//IF bDoneCrashSpeech
|
|
IF bDoneTannoyAnnouncement
|
|
bShownGodText = DO_MISSION_GOD_TEXT("PF_CRASH")
|
|
ENDIF
|
|
//ENDIF
|
|
ENDIF
|
|
ELSE
|
|
//bShownGodText = TRUE
|
|
IF bDoneGotoSpeech
|
|
IF NOT IS_ANY_CONVERSATION_ONGOING_OR_QUEUED()
|
|
bShownGodText = DO_MISSION_GOD_TEXT("PF_GOAIR", TRUE, TRUE)
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ELSE
|
|
IF NOT bRemovedBlipsForWanted
|
|
REMOVE_ALL_BLIPS()
|
|
bRemovedBlipsForWanted = TRUE
|
|
ELSE
|
|
REMOVE_PLANE_BLIP_AND_TEXT()
|
|
ENDIF
|
|
|
|
//IF NOT bKilledConversationOnWanted
|
|
// REMOVE_MISSION_TEXT(FALSE, TRUE, FALSE)
|
|
// bKilledConversationOnWanted = TRUE
|
|
//ELSE
|
|
IF NOT bShownLoseWantedPrompt
|
|
bShownLoseWantedPrompt = DO_MISSION_GOD_TEXT("LOSE_WANTED")
|
|
ENDIF
|
|
//ENDIF
|
|
ENDIF
|
|
ELSE
|
|
// ron is not in the vehicle - blip him
|
|
IF NOT DOES_BLIP_EXIST(ronBlip)
|
|
REMOVE_MISSION_TEXT(FALSE, TRUE, FALSE)
|
|
REMOVE_ALL_BLIPS()
|
|
ronBlip = CREATE_MISSION_BLIP_FOR_PED(ronPed)
|
|
ENDIF
|
|
|
|
IF NOT bWaitForRonPrompt
|
|
bWaitForRonPrompt = DO_MISSION_GOD_TEXT("PF_WAIT")
|
|
ENDIF
|
|
ENDIF
|
|
ELSE
|
|
// player is not in the vehicle - blip it
|
|
IF NOT DOES_BLIP_EXIST(trevorPlaneBlip)
|
|
REMOVE_MISSION_TEXT(FALSE, TRUE, FALSE)
|
|
REMOVE_ALL_BLIPS()
|
|
IF iGetInTextStage = 0
|
|
OR iGetInTextStage = 2
|
|
bShouldDoGetInText = TRUE
|
|
ENDIF
|
|
trevorPlaneBlip = CREATE_MISSION_BLIP_FOR_VEHICLE(planeFightVehicle[PFV_TREVOR_PLANE])
|
|
ENDIF
|
|
|
|
IF bShouldDoGetInText
|
|
STRING sGetInString
|
|
SWITCH iGetInTextStage
|
|
CASE 0
|
|
sGetInString = "PF_PLANE"
|
|
BREAK
|
|
CASE 2
|
|
sGetInString = "PF_PLANE2"
|
|
BREAK
|
|
ENDSWITCH
|
|
|
|
IF currentMissionStage > STAGE_GET_TO_AIRSTRIP
|
|
OR bDoneBanter
|
|
IF DO_MISSION_GOD_TEXT(sGetInString)
|
|
bShouldDoGetInText = FALSE
|
|
iGetInTextStage++
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ELSE
|
|
// ron is not group member
|
|
IF IS_ENTITY_AT_ENTITY(PLAYER_PED_ID(), ronPed, <<12, 12, 6>>)
|
|
// re-add to group
|
|
IF bSetRonAsGroupMember
|
|
OR currentMissionStage <> STAGE_GET_TO_AIRSTRIP
|
|
SET_PED_AS_GROUP_MEMBER(ronPed, PLAYER_GROUP_ID())
|
|
ENDIF
|
|
ELSE
|
|
// do blip and god text
|
|
IF NOT DOES_BLIP_EXIST(ronBlip)
|
|
REMOVE_MISSION_TEXT(FALSE, TRUE, FALSE)
|
|
REMOVE_ALL_BLIPS()
|
|
ronBlip = CREATE_MISSION_BLIP_FOR_PED(ronPed)
|
|
ENDIF
|
|
IF NOT bGetRonPrompt
|
|
bGetRonPrompt = DO_MISSION_GOD_TEXT("PF_LEAVE")
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
|
|
// for banter
|
|
IF bWithRon
|
|
BOOL bInSameVehicle = FALSE
|
|
IF IS_PED_IN_ANY_VEHICLE(PLAYER_PED_ID())
|
|
IF NOT IS_PED_INJURED(ronPed)
|
|
IF IS_PED_IN_ANY_VEHICLE(ronPed)
|
|
IF GET_VEHICLE_PED_IS_IN(PLAYER_PED_ID()) = GET_VEHICLE_PED_IS_IN(ronPed)
|
|
bInSameVehicle = TRUE
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
IF bAllOK
|
|
bAllOK = bInSameVehicle
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF bAllOK
|
|
IF IS_PLAYER_BROWSING_ITEMS_IN_ANY_SHOP()
|
|
bAllOK = FALSE
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF NOT bAllOK
|
|
IF NOT bSavedBanter
|
|
IF STORE_BANTER()
|
|
KILL_ANY_CONVERSATION()
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDPROC
|
|
|
|
CONST_FLOAT PLANE_ESCORT_X 45.0
|
|
CONST_FLOAT PLANE_ESCORT_Y 100.0
|
|
CONST_FLOAT PLANE_ESCORT_Z 16.0
|
|
|
|
// set jet attack state
|
|
PROC SET_JET_ATTACK_STATE(JET_ATTACK_STATE_ENUM newState)
|
|
INT i
|
|
|
|
REPEAT NUMBER_JETS i
|
|
IF IS_VEHICLE_DRIVEABLE(jetData[i].veh)
|
|
AND NOT IS_PED_INJURED(jetData[i].ped)
|
|
VECTOR vTargetOffset
|
|
vTargetOffset = <<0,0,0>>
|
|
vTargetOffset=vTargetOffset
|
|
SWITCH newState
|
|
CASE JET_ATTACK_FLY_HOME
|
|
TASK_VEHICLE_DRIVE_TO_COORD(jetData[i].ped, jetData[i].veh, <<2335, 3397, 500>>, 40, DRIVINGSTYLE_NORMAL, GET_MODEL_FOR_PLANE_FIGHT_MODEL_ENUM(PFM_JET), DRIVINGMODE_PLOUGHTHROUGH, 50, 10000)
|
|
BREAK
|
|
CASE JET_ATTACK_ESCORT
|
|
bDoneJetWarning1Speech = TRUE
|
|
BREAK
|
|
CASE JET_ATTACK_TO_REAR
|
|
iJetTurnTime = GET_GAME_TIMER()
|
|
BREAK
|
|
ENDSWITCH
|
|
ENDIF
|
|
|
|
jetData[i].iTaskTime = GET_GAME_TIMER()
|
|
ENDREPEAT
|
|
|
|
IF newState = JET_ATTACK_MISSILES
|
|
START_PLANE_FIGHT_AUDIO_SCENE(PLANE_FIGHT_AUDIO_SCENE_ROCKETS_FIRED)
|
|
STOP_PLANE_FIGHT_AUDIO_SCENE(PLANE_FIGHT_AUDIO_SCENE_FLY_CARGO_PLANE)
|
|
STOP_PLANE_FIGHT_AUDIO_SCENE(PLANE_FIGHT_AUDIO_SCENE_FIGHTER_JETS_ARRIVE)
|
|
ENDIF
|
|
|
|
iJetSetStateTime = GET_GAME_TIMER()
|
|
jetAttackState = newState
|
|
ENDPROC
|
|
|
|
// get target vector from target offset
|
|
FUNC VECTOR GET_JET_TARGET_FROM_TARGET_OFFSET(VECTOR vTargetOffset)
|
|
VECTOR vReturn = GET_OFFSET_FROM_ENTITY_IN_WORLD_COORDS(planeRootObject, vTargetOffset)
|
|
|
|
FLOAT fGroundHeight
|
|
FLOAT fHeightAboveGround
|
|
GET_GROUND_Z_FOR_3D_COORD(vReturn, fGroundHeight)
|
|
IF fGroundHeight < 0
|
|
fGroundHeight = 0
|
|
ENDIF
|
|
fHeightAboveGround = vReturn.z - fGroundHeight
|
|
|
|
IF fHeightAboveGround <= 40
|
|
vReturn.z = fGroundHeight + 40
|
|
ENDIF
|
|
|
|
RETURN vReturn
|
|
ENDFUNC
|
|
|
|
// handle jets
|
|
PROC HANDLE_JET_ATTACK()
|
|
//PRINTSTRING("dist = ") PRINTFLOAT(GET_DISTANCE_BETWEEN_COORDS(GET_PLANE_FIGHT_VECTOR(PFVEC_MAP_CENTRE), GET_ENTITY_COORDS(planeFightVehicle[PFV_CARGO_PLANE]), FALSE)) PRINTNL()
|
|
FLOAT fDistanceFromAirstrip
|
|
VEHICLE_INDEX playerPlane
|
|
|
|
IF currentMissionStage = STAGE_FLY_PLANE
|
|
playerPlane = planeFightVehicle[PFV_CARGO_PLANE]
|
|
IF IS_VEHICLE_DRIVEABLE(playerPlane)
|
|
fDistanceFromAirstrip = GET_DISTANCE_BETWEEN_COORDS(GET_PLANE_FIGHT_VECTOR(PFVEC_RUNWAY), GET_ENTITY_COORDS(playerPlane), FALSE)
|
|
ENDIF
|
|
ELSE
|
|
playerPlane = planeFightVehicle[PFV_TREVOR_PLANE]
|
|
ENDIF
|
|
|
|
INT i
|
|
IF jetAttackState = JET_ATTACK_NOT_CREATED
|
|
BOOL bCreateJets = FALSE
|
|
IF currentMissionStage = STAGE_FLY_PLANE
|
|
IF fDistanceFromAirstrip < 7700
|
|
bCreateJets = TRUE
|
|
ENDIF
|
|
ELSE
|
|
IF bJetsScrambled
|
|
ADD_MODEL_REQUEST(ENUM_TO_INT(PFM_SOLDIER))
|
|
ADD_MODEL_REQUEST(ENUM_TO_INT(PFM_JET))
|
|
|
|
IF HAVE_ALL_MODEL_REQUESTS_SUCCEEDED()
|
|
IF iScrambleJetsTime < 0
|
|
FLOAT fDistanceFromBase = GET_DISTANCE_BETWEEN_COORDS(GET_ENTITY_COORDS(PLAYER_PED_ID()),GET_PLANE_FIGHT_VECTOR(PFVEC_BASE_LAUNCH), FALSE)
|
|
|
|
iScrambleJetsTime = FLOOR(fDistanceFromBase * 2)
|
|
IF iScrambleJetsTime >= 10000
|
|
iScrambleJetsTime = 10000
|
|
ENDIF
|
|
iScrambleJetsTime += GET_GAME_TIMER()
|
|
ELSE
|
|
IF GET_GAME_TIMER() >= iScrambleJetsTime
|
|
bCreateJets = TRUE
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
|
|
#IF IS_DEBUG_BUILD
|
|
IF IS_KEYBOARD_KEY_JUST_PRESSED(KEY_NUMPAD2)
|
|
bCreateJets = TRUE
|
|
ENDIF
|
|
#ENDIF
|
|
|
|
// create the jets
|
|
IF bCreateJets
|
|
// create the jets
|
|
REPEAT NUMBER_JETS i
|
|
VECTOR vInitOffset
|
|
VECTOR vInitPos
|
|
FLOAT fInitRot
|
|
FLOAT fGroundAtInit
|
|
fGroundAtInit = 0.0
|
|
FLOAT fMinGround
|
|
|
|
SWITCH i
|
|
CASE 0
|
|
vInitOffset = <<20, 1000, 45>>
|
|
BREAK
|
|
CASE 1
|
|
vInitOffset = <<-20, 1000, 45>>
|
|
BREAK
|
|
ENDSWITCH
|
|
|
|
VECTOR vPlayerPos = GET_ENTITY_COORDS(PLAYER_PED_ID())
|
|
VECTOR vBaseOffset = GET_OFFSET_FROM_ENTITY_GIVEN_WORLD_COORDS(planeRootObject, GET_PLANE_FIGHT_VECTOR(PFVEC_BASE_LAUNCH))
|
|
|
|
IF currentMissionStage = STAGE_FLY_PLANE
|
|
vInitPos = GET_OFFSET_FROM_ENTITY_IN_WORLD_COORDS(planeRootObject, vInitOffset)
|
|
fInitRot = GET_ENTITY_HEADING(planeRootObject)-180
|
|
ELIF GET_DISTANCE_BETWEEN_COORDS(vPlayerPos, GET_PLANE_FIGHT_VECTOR(PFVEC_BASE_LAUNCH), FALSE) < 2000
|
|
|
|
fInitRot = GET_ENTITY_HEADING(planeRootObject)-180
|
|
IF vBaseOffset.y < 0
|
|
vInitOffset *= <<-1,-1,1>>
|
|
fInitRot -= 180
|
|
ENDIF
|
|
vInitPos = GET_OFFSET_FROM_ENTITY_IN_WORLD_COORDS(planeRootObject, vInitOffset)
|
|
|
|
printstring("creating from base!") printnl()
|
|
|
|
ELSE
|
|
VECTOR vBaseVector = vPlayerPos - GET_PLANE_FIGHT_VECTOR(PFVEC_BASE_LAUNCH)
|
|
FLOAT fTargetHeading = GET_HEADING_FROM_VECTOR_2D(vBaseVector.x, vBaseVector.y)
|
|
|
|
printstring("creating from vector!") printnl()
|
|
|
|
IF fTargetHeading > 360.0
|
|
fTargetHeading -= 360.0
|
|
ELIF fTargetHeading < 0.0
|
|
fTargetHeading += 360.0
|
|
ENDIF
|
|
|
|
// distance along vector
|
|
vInitPos = GET_PLANE_FIGHT_VECTOR(PFVEC_BASE_LAUNCH) + (vBaseVector * <<0.4, 0.4, 0.4>>)
|
|
VECTOR vOffsetFromInit = <<20,0,0>>
|
|
|
|
IF i=0
|
|
vOffsetFromInit.x *= -1
|
|
ENDIF
|
|
|
|
vInitPos = GET_OFFSET_FROM_COORD_AND_HEADING_IN_WORLD_COORDS(vInitPos, fTargetHeading, vOffsetFromInit)
|
|
vInitPos.z = vPlayerPos.z + 50
|
|
fInitRot = fTargetHeading
|
|
ENDIF
|
|
|
|
GET_GROUND_Z_FOR_3D_COORD(vInitPos, fGroundAtInit)
|
|
IF fGroundAtInit < 0
|
|
fGroundAtInit = 0
|
|
ENDIF
|
|
|
|
fMinGround = fGroundAtInit + 70
|
|
|
|
IF vInitPos.z < fMinGround
|
|
vInitPos.z = fMinGround
|
|
ENDIF
|
|
|
|
VECTOR vOffsetFromPlane = GET_OFFSET_FROM_ENTITY_GIVEN_WORLD_COORDS(planeRootObject, vInitPos)
|
|
IF vOffsetFromPlane.y > 0
|
|
IF i = 0
|
|
jetData[i].bInvertOffset = FALSE
|
|
ELSE
|
|
jetData[i].bInvertOffset = TRUE
|
|
ENDIF
|
|
ELSE
|
|
IF i = 0
|
|
jetData[i].bInvertOffset = TRUE
|
|
ELSE
|
|
jetData[i].bInvertOffset = FALSE
|
|
ENDIF
|
|
ENDIF
|
|
|
|
jetData[i].veh = CREATE_VEHICLE(GET_MODEL_FOR_PLANE_FIGHT_MODEL_ENUM(PFM_JET), vInitPos, fInitRot)
|
|
SET_VEHICLE_ENGINE_ON(jetData[i].veh, TRUE, TRUE)
|
|
SET_VEHICLE_FORWARD_SPEED(jetData[i].veh, 100)
|
|
SET_ENTITY_LOD_DIST(jetData[i].veh, 900)
|
|
SET_ENTITY_SHOULD_FREEZE_WAITING_ON_COLLISION(jetData[i].veh, FALSE)
|
|
CONTROL_LANDING_GEAR(jetData[i].veh, LGC_RETRACT_INSTANT)
|
|
SET_VEHICLE_FORCE_AFTERBURNER(jetData[i].veh, TRUE)
|
|
SET_ENTITY_INVINCIBLE(jetData[i].veh, TRUE)
|
|
SET_ENTITY_PROOFS(jetData[i].veh, TRUE, TRUE, TRUE, TRUE, TRUE)
|
|
SET_VEHICLE_CAN_BREAK(jetData[i].veh, FALSE)
|
|
SET_VEHICLE_CAN_BE_VISIBLY_DAMAGED(jetData[i].veh, FALSE)
|
|
SET_VEHICLE_COLOUR_COMBINATION(jetData[i].veh, 0)
|
|
ADD_ENTITY_TO_AUDIO_MIX_GROUP(jetData[i].veh, "EXILE_1_FIGHTER_JETS")
|
|
|
|
jetData[i].ped = CREATE_PED_INSIDE_VEHICLE(jetData[i].veh, PEDTYPE_MISSION, GET_MODEL_FOR_PLANE_FIGHT_MODEL_ENUM(PFM_SOLDIER))
|
|
CLEAR_ALL_PED_PROPS(jetData[i].ped)
|
|
SET_PED_PROP_INDEX(jetData[i].ped, ANCHOR_HEAD, 2, 0)
|
|
SET_PED_COMPONENT_VARIATION(jetData[i].ped, PED_COMP_SPECIAL, 0, 0)
|
|
|
|
IF i=1
|
|
SET_PED_COMPONENT_VARIATION(jetData[i].ped, PED_COMP_HEAD, 1, 0)
|
|
ELSE
|
|
SET_PED_COMPONENT_VARIATION(jetData[i].ped, PED_COMP_HEAD, 0, 0)
|
|
ENDIF
|
|
|
|
SET_BLOCKING_OF_NON_TEMPORARY_EVENTS(jetData[i].ped, TRUE)
|
|
ENDREPEAT
|
|
|
|
// jet cam
|
|
CREATE_MISSION_STATIC_CAM(jetCam)
|
|
POINT_CAM_AT_ENTITY(jetCam, playerPlane, <<0.0, 10.0, 0.0>>)
|
|
vJetCamAttach = <<0,0,6.5>>
|
|
ATTACH_CAM_TO_ENTITY(jetCam, jetData[1].veh, vJetCamAttach, FALSE)
|
|
SET_CAM_FOV(jetCam, 60.00)
|
|
|
|
ADD_PED_FOR_DIALOGUE(planeFightConversation, 8, NULL, "MILITARYJET")
|
|
ADD_PED_FOR_DIALOGUE(planeFightConversation, 5, NULL, "MILITARYJET2")
|
|
SET_JET_ATTACK_STATE(JET_ATTACK_FLY_TO_PLANE)
|
|
ENDIF
|
|
ELSE
|
|
REPEAT NUMBER_JETS i
|
|
IF IS_VEHICLE_DRIVEABLE(jetData[i].veh)
|
|
AND NOT IS_PED_INJURED(jetData[i].ped)
|
|
|
|
|
|
FLOAT fApplyXForce = 0
|
|
FLOAT fApplyYForce = 0
|
|
FLOAT fApplyZForce = 0
|
|
//VECTOR vOffsetFromPlane = GET_OFFSET_FROM_ENTITY_GIVEN_WORLD_COORDS(planeRootObject, GET_ENTITY_COORDS(jetData[i].veh))
|
|
VECTOR vTargetOffset
|
|
VECTOR vTarget
|
|
|
|
VECTOR vPosForForce
|
|
VECTOR vPlayerPlanePos
|
|
vPosForForce = GET_ENTITY_COORDS(jetData[i].veh)
|
|
vPlayerPlanePos = GET_ENTITY_COORDS(PLAYER_PED_ID())
|
|
|
|
SWITCH jetAttackState
|
|
CASE JET_ATTACK_FLY_TO_PLANE
|
|
fApplyYForce = 140
|
|
|
|
IF currentMissionStage = STAGE_FLY_PLANE
|
|
|
|
//137
|
|
|
|
FLOAT fHeightDiff
|
|
fHeightDiff = (vPosForForce.z + 40) - vPlayerPlanePos.z
|
|
// if fdiff greater > 0 jet is higher
|
|
|
|
IF fHeightDiff > 0
|
|
fApplyZForce = fHeightDiff * -15
|
|
IF fApplyZForce < -140
|
|
fApplyZForce = -140
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF vPosForForce.z < 100
|
|
fApplyZForce = 0
|
|
ENDIF
|
|
|
|
//printstring("APPLY Z FORCE = ") PRINTFLOAT(fApplyZForce) PRINTNL()
|
|
ENDIF
|
|
|
|
IF GET_GAME_TIMER() >= jetData[i].iTaskTime
|
|
IF currentMissionStage = STAGE_FLY_PLANE
|
|
vTargetOffset = <<15,30,0>>//<<15, -30, 0>>
|
|
ELSE
|
|
vTargetOffset = <<15,30,20>>//<<15, -30, 0>>
|
|
ENDIF
|
|
|
|
IF jetData[i].bInvertOffset
|
|
vTargetOffset.x *= -1
|
|
ENDIF
|
|
|
|
vTarget = GET_JET_TARGET_FROM_TARGET_OFFSET(vTargetOffset)
|
|
|
|
IF vTarget.z > 1260
|
|
vTarget.z = 1260
|
|
ENDIF
|
|
|
|
IF vTarget.z < 100.0
|
|
vTarget.z = 100
|
|
ENDIF
|
|
|
|
TASK_VEHICLE_DRIVE_TO_COORD(jetData[i].ped, jetData[i].veh, vTarget, 10000, DRIVINGSTYLE_NORMAL, GET_MODEL_FOR_PLANE_FIGHT_MODEL_ENUM(PFM_JET), DRIVINGMODE_PLOUGHTHROUGH, 50, -1)
|
|
//PRINTSTRING("target = ") printvector(vTarget) printnl()
|
|
jetData[i].iTaskTime = GET_GAME_TIMER() + 1000
|
|
ENDIF
|
|
|
|
FLOAT fDistanceBetween
|
|
fDistanceBetween = GET_DISTANCE_BETWEEN_ENTITIES(playerPlane, jetData[i].veh, FALSE)
|
|
|
|
IF currentMissionStage = STAGE_FLY_PLANE
|
|
|
|
IF fDistanceBetween < 400
|
|
IF NOT bPlayedFlybyStream
|
|
IF bLoadedFlybyStream
|
|
PLAY_STREAM_FRONTEND()
|
|
bPlayedFlybyStream = TRUE
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF fDistanceBetween < 320//230//200//230//210.0
|
|
SET_JET_ATTACK_STATE(JET_ATTACK_TO_REAR)
|
|
ELSE
|
|
IF NOT bDoneSeeJetSpeech
|
|
IF fDistanceBetween < 380.0
|
|
STRING sSeeJetString
|
|
IF iReplayAttempt % 2 = 0
|
|
sSeeJetString = "EXL1_JETS"
|
|
ELSE
|
|
sSeeJetString = "EXL1_SEEJET"
|
|
ENDIF
|
|
IF DO_MISSION_SPEECH(sSeeJetString)
|
|
bDoneHailRonSpeech = TRUE
|
|
bDoneRonHailedSpeech = TRUE
|
|
bDoneSeeJetSpeech = TRUE
|
|
bDoneChangeFreqSpeech = TRUE
|
|
ENDIF
|
|
ELSE
|
|
IF NOT bDoneSeeJetAudioScene
|
|
IF fDistanceBetween < 650.0
|
|
bDoneSeeJetAudioScene = START_PLANE_FIGHT_AUDIO_SCENE(PLANE_FIGHT_AUDIO_SCENE_FIGHTER_JETS_ARRIVE)
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ELSE
|
|
IF fDistanceBetween < 800.0
|
|
SET_JET_ATTACK_STATE(JET_ATTACK_MISSILES)
|
|
ENDIF
|
|
ENDIF
|
|
BREAK
|
|
|
|
CASE JET_ATTACK_TO_REAR
|
|
fApplyYForce = 140
|
|
fApplyXForce = 25
|
|
|
|
IF NOT bDoneJetWarning1Speech
|
|
bDoneJetWarning1Speech = DO_MISSION_SPEECH("EXL1_PLCALL1")
|
|
ENDIF
|
|
|
|
|
|
IF GET_GAME_TIMER() >= jetData[i].iTaskTime
|
|
vTargetOffset = <<400.0, 1000.0, 0.0>>
|
|
IF jetData[i].bInvertOffset
|
|
vTargetOffset.x *= -1
|
|
ENDIF
|
|
|
|
VECTOR vAttackTarget
|
|
vAttackTarget = GET_OFFSET_FROM_ENTITY_IN_WORLD_COORDS(planeRootObject, vTargetOffset)
|
|
IF vAttackTarget.z > 1260
|
|
vAttackTarget.z = 1260
|
|
ENDIF
|
|
IF vAttackTarget.z < 100.0
|
|
vAttackTarget.z = 100
|
|
ENDIF
|
|
|
|
TASK_VEHICLE_DRIVE_TO_COORD(jetData[i].ped, jetData[i].veh, vAttackTarget, 40, DRIVINGSTYLE_NORMAL, GET_MODEL_FOR_PLANE_FIGHT_MODEL_ENUM(PFM_JET), DRIVINGMODE_PLOUGHTHROUGH, 50, -1)
|
|
SET_ENTITY_LOD_DIST(jetData[i].veh, 2000)
|
|
jetData[i].iTaskTime = GET_GAME_TIMER() + 1000
|
|
ENDIF
|
|
|
|
IF DO_PLANE_HEADINGS_MATCH(jetData[0].veh, playerPlane, 55)
|
|
OR DO_PLANE_HEADINGS_MATCH(jetData[1].veh, playerPlane, 55)
|
|
SET_JET_ATTACK_STATE(JET_ATTACK_ESCORT)
|
|
ENDIF
|
|
|
|
BREAK
|
|
CASE JET_ATTACK_ESCORT
|
|
// escort speech
|
|
IF iJetWarningSpeech < 5
|
|
FLOAT fSpeechDistance
|
|
INT iSpeechTime
|
|
TEXT_LABEL tSpeech
|
|
SWITCH iJetWarningSpeech
|
|
CASE 0
|
|
fSpeechDistance = 999999
|
|
iSpeechTime = 21000
|
|
IF GET_RANDOM_INT_IN_RANGE(0,2) = 0
|
|
tSpeech = "EXL1_PLCALL5"
|
|
ELSE
|
|
tSpeech = "EXL1_PLCALL4"
|
|
ENDIF
|
|
BREAK
|
|
CASE 1
|
|
fSpeechDistance = 999999
|
|
iSpeechTime = 0
|
|
IF GET_RANDOM_INT_IN_RANGE(0,2) = 0
|
|
tSpeech = "EXL1_REASON1"
|
|
ELSE
|
|
tSpeech = "EXL1_REASON2"
|
|
ENDIF
|
|
BREAK
|
|
CASE 2
|
|
fSpeechDistance = 4400
|
|
iSpeechTime = 44000
|
|
tSpeech = "EXL1_PLCALL2"
|
|
BREAK
|
|
CASE 3
|
|
fSpeechDistance = 3300
|
|
iSpeechTime = 64000
|
|
tSpeech = "EXL1_PLCALL3"
|
|
BREAK
|
|
CASE 4
|
|
fSpeechDistance = 999999
|
|
iSpeechTime = 0
|
|
tSpeech = "EXL1_REASON3"
|
|
BREAK
|
|
ENDSWITCH
|
|
|
|
//printstring("distance = ") printfloat(fDistanceFromAirstrip) printnl()
|
|
//printstring("time = ") printint(GET_GAME_TIMER()-iJetSetStateTime) printnl()
|
|
|
|
IF fDistanceFromAirstrip < fSpeechDistance
|
|
OR GET_GAME_TIMER() >= iJetSetStateTime + iSpeechTime
|
|
IF DO_MISSION_SPEECH(tSpeech)
|
|
iJetWarningSpeech++
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
|
|
// handle jet fly alongside
|
|
IF i=1
|
|
bJetAlongsideCabin = FALSE
|
|
IF IS_VEHICLE_DRIVEABLE(jetData[1].veh)
|
|
VECTOR vOffset
|
|
vOffset = GET_OFFSET_FROM_ENTITY_GIVEN_WORLD_COORDS(planeFightVehicle[PFV_CARGO_PLANE], GET_ENTITY_COORDS(jetData[1].veh))
|
|
|
|
SWITCH jetFlyAlongsideState
|
|
CASE JET_FLY_ALONGSIDE_POSITION_BEHIND
|
|
IF IS_ENTITY_TOUCHING_ENTITY(jetData[1].veh, planeFightVehicle[PFV_CARGO_PLANE])
|
|
fJetFlyAlongsideTimer = 0.0
|
|
ELSE
|
|
IF IS_ENTITY_AT_COORD(jetData[1].veh, GET_OFFSET_FROM_ENTITY_IN_WORLD_COORDS(planeFightVehicle[PFV_CARGO_PLANE], <<0,-95,12>>), <<90,90,60>>)
|
|
fJetFlyAlongsideTimer = fJetFlyAlongsideTimer +@ 1.0
|
|
IF fJetFlyAlongsideTimer >= 3.0
|
|
jetData[1].iTaskTime = GET_GAME_TIMER()
|
|
fJetFlyAlongsideTimer = 0.0
|
|
jetFlyAlongsideState = JET_FLY_ALONGSIDE_POSITION_ABOVE_CABIN
|
|
ENDIF
|
|
ELSE
|
|
fJetFlyAlongsideTimer = 0.0
|
|
ENDIF
|
|
ENDIF
|
|
BREAK
|
|
CASE JET_FLY_ALONGSIDE_POSITION_ABOVE_CABIN
|
|
fApplyYForce = 15//10
|
|
IF IS_ENTITY_TOUCHING_ENTITY(jetData[1].veh, planeFightVehicle[PFV_CARGO_PLANE])
|
|
OR vOffset.y <= -80
|
|
OR vOffset.z >= 40
|
|
OR vOffset.y >= 50
|
|
OR vOffset.z <= -40
|
|
OR vOffset.x <= -75
|
|
OR vOffset.x >= 75
|
|
jetData[1].iTaskTime = GET_GAME_TIMER()
|
|
fJetFlyAlongsideTimer = 0.0
|
|
jetFlyAlongsideState = JET_FLY_ALONGSIDE_POSITION_BEHIND
|
|
ELIF (vPosForForce.z > vPlayerPlanePos.z AND NOT bFlyAbove)
|
|
OR (vPosForForce.z < vPlayerPlanePos.z AND bFlyAbove)
|
|
jetData[1].iTaskTime = GET_GAME_TIMER()
|
|
fJetFlyAlongsideTimer = 0.0
|
|
ELSE
|
|
IF IS_ENTITY_AT_COORD(jetData[1].veh, GET_OFFSET_FROM_ENTITY_IN_WORLD_COORDS(planeFightVehicle[PFV_CARGO_PLANE], <<-25, 35, 0>>), <<35,35,60>>)
|
|
OR GET_GAME_TIMER() >= jetData[1].iTaskTime + 8000
|
|
fJetFlyAlongsideTimer = fJetFlyAlongsideTimer +@ 1.0
|
|
IF fJetFlyAlongsideTimer >= 3.0
|
|
jetData[1].iTaskTime = GET_GAME_TIMER()
|
|
fJetFlyAlongsideTimer = 0.0
|
|
jetFlyAlongsideState = JET_FLY_ALONGSIDE_GO_TO_CABIN
|
|
ENDIF
|
|
ELSE
|
|
fJetFlyAlongsideTimer = 0.0
|
|
ENDIF
|
|
ENDIF
|
|
BREAK
|
|
CASE JET_FLY_ALONGSIDE_GO_TO_CABIN
|
|
fApplyYForce = 15//10
|
|
IF IS_ENTITY_TOUCHING_ENTITY(jetData[1].veh, planeFightVehicle[PFV_CARGO_PLANE])
|
|
OR vOffset.y <= -60
|
|
OR vOffset.z >= 40
|
|
OR vOffset.y >= 50
|
|
OR vOffset.z <= -40
|
|
OR vOffset.x <= -75
|
|
OR vOffset.x >= 75
|
|
jetData[1].iTaskTime = GET_GAME_TIMER()
|
|
fJetFlyAlongsideTimer = 0.0
|
|
jetFlyAlongsideState = JET_FLY_ALONGSIDE_POSITION_BEHIND
|
|
ELIF (vPosForForce.z > vPlayerPlanePos.z - 8 AND NOT bFlyAbove)
|
|
OR (vPosForForce.z < vPlayerPlanePos.z - 8 AND bFlyAbove)
|
|
jetData[1].iTaskTime = GET_GAME_TIMER()
|
|
fJetFlyAlongsideTimer = 0.0
|
|
ELSE
|
|
IF IS_ENTITY_AT_COORD(jetData[1].veh, GET_OFFSET_FROM_ENTITY_IN_WORLD_COORDS(planeFightVehicle[PFV_CARGO_PLANE], <<-25,28,0>>), <<30,30,25>>)
|
|
fJetFlyAlongsideTimer = fJetFlyAlongsideTimer +@ 1.0
|
|
IF fJetFlyAlongsideTimer >= 1.5
|
|
bJetAlongsideCabin = TRUE
|
|
ENDIF
|
|
ELSE
|
|
fJetFlyAlongsideTimer = 0.0
|
|
ENDIF
|
|
ENDIF
|
|
BREAK
|
|
CASE JET_FLY_ALONGSIDE_POSITION_FOR_FALLBACK
|
|
fJetFlyAlongsideTimer = fJetFlyAlongsideTimer +@ 1.0
|
|
IF fJetFlyAlongsideTimer >= 3.0
|
|
jetData[1].iTaskTime = 0
|
|
fJetFlyAlongsideTimer = 0.0
|
|
jetFlyAlongsideState = JET_FLY_ALONGSIDE_DONE
|
|
ENDIF
|
|
BREAK
|
|
CASE JET_FLY_ALONGSIDE_DONE
|
|
|
|
BREAK
|
|
ENDSWITCH
|
|
ENDIF
|
|
ENDIF
|
|
|
|
//PRINTSTRING("fly timer = ") printfloat(fJetFlyAlongsideTimer) printnl()
|
|
|
|
//BOOL bRetask
|
|
//bRetask = FALSE
|
|
IF GET_GAME_TIMER() >= jetData[i].iTaskTime
|
|
IF jetFlyAlongsideState = JET_FLY_ALONGSIDE_POSITION_BEHIND
|
|
OR jetFlyAlongsideState = JET_FLY_ALONGSIDE_DONE
|
|
OR i=0
|
|
vTargetOffset = <<35, -50, -6>>//<<37, 100, 12>>
|
|
ELIF jetFlyAlongsideState = JET_FLY_ALONGSIDE_GO_TO_CABIN
|
|
IF vPosForForce.z >= vPlayerPlanePos.z - 8
|
|
vTargetOffset = <<25, 50, 7>> // 40
|
|
bFlyAbove = TRUE
|
|
ELSE
|
|
vTargetOffset = <<25, 50, -5>> // 40
|
|
bFlyAbove = FALSE
|
|
ENDIF
|
|
//bRetask = TRUE
|
|
ELIF jetFlyAlongsideState = JET_FLY_ALONGSIDE_POSITION_ABOVE_CABIN
|
|
IF vPosForForce.z >= vPlayerPlanePos.z - 8
|
|
vTargetOffset = <<25, 50, 25>> // 40
|
|
bFlyAbove = TRUE
|
|
ELSE
|
|
vTargetOffset = <<25, 50, -25>> // 40
|
|
bFlyAbove = FALSE
|
|
ENDIF
|
|
//bRetask = TRUE
|
|
ELIF jetFlyAlongsideState = JET_FLY_ALONGSIDE_POSITION_FOR_FALLBACK
|
|
vTargetOffset = <<55, 80, 35>>
|
|
ENDIF
|
|
IF jetData[i].bInvertOffset
|
|
vTargetOffset.x *= -1
|
|
//PRINTSTRING("vTargetOffset = ") PRINTVECTOR(vTargetOffset) PRINTNL()
|
|
ENDIF
|
|
vTarget = GET_JET_TARGET_FROM_TARGET_OFFSET(vTargetOffset)
|
|
//TASK_VEHICLE_DRIVE_TO_COORD(jetData[i].ped, jetData[i].veh, vTarget, 50, DRIVINGSTYLE_NORMAL, GET_MODEL_FOR_PLANE_FIGHT_MODEL_ENUM(PFM_JET), DRIVINGMODE_PLOUGHTHROUGH, 50, 10000)
|
|
TASK_PLANE_CHASE(jetData[i].ped, playerPlane, vTargetOffset)
|
|
|
|
jetData[i].iTaskTime = GET_GAME_TIMER() + 1000000
|
|
|
|
ENDIF
|
|
|
|
IF fDistanceFromAirstrip < 2400//4500
|
|
OR GET_GAME_TIMER() >= iJetSetStateTime + 85000
|
|
#IF IS_DEBUG_BUILD
|
|
OR IS_KEYBOARD_KEY_JUST_PRESSED(KEY_NUMPAD1)
|
|
#ENDIF
|
|
IF fDistanceFromAirstrip < 2400
|
|
printstring("distance from strip") printnl()
|
|
ELSE
|
|
printstring("timed out") printnl()
|
|
ENDIF
|
|
SET_JET_ATTACK_STATE(JET_ATTACK_FALL_BACK_TO_SHOOT)
|
|
jetData[1].iTaskTime += 1200
|
|
ENDIF
|
|
BREAK
|
|
CASE JET_ATTACK_FALL_BACK_TO_SHOOT
|
|
IF NOT bDoneSplashSpeech
|
|
IF IS_ENTITY_IN_AREA(PLAYER_PED_ID(), <<-1176.02515, 2000.56641, 19.16425>>, <<3427.56763, 6152.39453, -0.12149>>, FALSE, FALSE)
|
|
bDoneSplashSpeech = DO_MISSION_SPEECH("EXL1_WFREE")
|
|
ELSE
|
|
bDoneSplashSpeech = DO_MISSION_SPEECH("EXL1_PLCALL6")
|
|
bCancelledSplashSpeech = TRUE
|
|
ENDIF
|
|
ELSE
|
|
IF NOT bCancelledSplashSpeech
|
|
IF NOT bDoneSplashSpeech2
|
|
bDoneSplashSpeech2 = DO_MISSION_SPEECH("EXL1_WFREE2")
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF GET_GAME_TIMER() >= jetData[i].iTaskTime
|
|
vTargetOffset = <<37, -60, 5>>//<<37, 100, 12>>
|
|
IF jetData[i].bInvertOffset
|
|
vTargetOffset.x *= -1
|
|
// PRINTSTRING("vTargetOffset = ") PRINTVECTOR(vTargetOffset) PRINTNL()
|
|
ENDIF
|
|
vTarget = GET_JET_TARGET_FROM_TARGET_OFFSET(vTargetOffset)
|
|
//TASK_VEHICLE_DRIVE_TO_COORD(jetData[i].ped, jetData[i].veh, vTarget, 50, DRIVINGSTYLE_NORMAL, GET_MODEL_FOR_PLANE_FIGHT_MODEL_ENUM(PFM_JET), DRIVINGMODE_PLOUGHTHROUGH, 50, 10000)
|
|
TASK_PLANE_CHASE(jetData[i].ped, playerPlane, vTargetOffset)
|
|
ENDIF
|
|
|
|
//IF vOffsetFromPlane.y < -60
|
|
//OR vOffsetFromPlane.y > 60
|
|
IF GET_GAME_TIMER() >= jetData[i].iTaskTime + 5500
|
|
SET_JET_ATTACK_STATE(JET_ATTACK_MISSILES)
|
|
ENDIF
|
|
//ENDIF
|
|
|
|
BREAK
|
|
CASE JET_ATTACK_MISSILES
|
|
INT j
|
|
INT iMissileTime
|
|
iMissileTime=0
|
|
|
|
BOOL bMissilesRemaining
|
|
bMissilesRemaining = FALSE
|
|
REPEAT NUMBER_MISSILES j
|
|
IF jetMissile[j].state = JET_MISSILE_STATE_NOT_LAUNCHED
|
|
bMissilesRemaining = TRUE
|
|
SWITCH j
|
|
CASE 0
|
|
iMissileTime = 2500
|
|
BREAK
|
|
CASE 1
|
|
iMissileTime = 3000
|
|
BREAK
|
|
CASE 2
|
|
iMissileTime = 2800
|
|
BREAK
|
|
CASE 3
|
|
iMissileTime = 3600
|
|
BREAK
|
|
ENDSWITCH
|
|
IF GET_GAME_TIMER() >= jetData[i].iTaskTime + iMissileTime
|
|
jetMissile[j].state = JET_MISSILE_STATE_LAUNCH_READY
|
|
ENDIF
|
|
ENDIF
|
|
ENDREPEAT
|
|
|
|
IF NOT bMissilesRemaining
|
|
IF currentMissionStage <> STAGE_FLY_PLANE
|
|
SET_JET_ATTACK_STATE(JET_ATTACK_FLY_HOME)
|
|
ELSE
|
|
SET_JET_ATTACK_STATE(JET_ATTACK_OVERTAKE)
|
|
ENDIF
|
|
ENDIF
|
|
BREAK
|
|
|
|
CASE JET_ATTACK_OVERTAKE
|
|
IF GET_GAME_TIMER() >= jetData[i].iTaskTime
|
|
|
|
IF vPosForForce.z >= vPlayerPlanePos.z - 6
|
|
vTargetOffset = <<80, 200, 40>>//<<37, 100, 12>>
|
|
ELSE
|
|
vTargetOffset = <<80, 200, -20>>//<<37, 100, 12>>
|
|
ENDIF
|
|
IF jetData[i].bInvertOffset
|
|
vTargetOffset.x *= -1
|
|
ENDIF
|
|
vTarget = GET_JET_TARGET_FROM_TARGET_OFFSET(vTargetOffset)
|
|
|
|
TASK_PLANE_CHASE(jetData[i].ped, playerPlane, vTargetOffset)
|
|
jetData[i].iTaskTime = GET_GAME_TIMER() + 100000
|
|
ENDIF
|
|
|
|
//IF vOffsetFromPlane.y < -60
|
|
//OR vOffsetFromPlane.y > 60
|
|
IF GET_GAME_TIMER() >= iJetSetStateTime + 4000
|
|
SET_JET_ATTACK_STATE(JET_ATTACK_FLY_HOME)
|
|
ENDIF
|
|
BREAK
|
|
|
|
CASE JET_ATTACK_FLY_HOME
|
|
|
|
//VECTOR vPosForForce
|
|
//VECTOR vPlayerPlanePos
|
|
//vPosForForce = GET_ENTITY_COORDS(jetData[i].veh)
|
|
//vPlayerPlanePos = GET_ENTITY_COORDS(PLAYER_PED_ID())
|
|
|
|
IF currentMissionStage = STAGE_FLY_PLANE
|
|
IF GET_GAME_TIMER() >= jetData[i].iTaskTime
|
|
vTargetOffset = <<50.0, 1000.0, 5.0>>
|
|
|
|
fApplyYForce = 40
|
|
fApplyZForce = 80
|
|
|
|
IF jetData[i].bInvertOffset
|
|
vTargetOffset.x *= -1
|
|
ENDIF
|
|
|
|
VECTOR vAttackTarget
|
|
vAttackTarget = GET_OFFSET_FROM_ENTITY_IN_WORLD_COORDS(planeRootObject, vTargetOffset)
|
|
IF vAttackTarget.z > 1260
|
|
vAttackTarget.z = 1260
|
|
ENDIF
|
|
IF vAttackTarget.z < 100.0
|
|
vAttackTarget.z = 100
|
|
ENDIF
|
|
|
|
TASK_VEHICLE_DRIVE_TO_COORD(jetData[i].ped, jetData[i].veh, vAttackTarget, 1000, DRIVINGSTYLE_NORMAL, GET_MODEL_FOR_PLANE_FIGHT_MODEL_ENUM(PFM_JET), DRIVINGMODE_PLOUGHTHROUGH, 50, -1)
|
|
jetData[i].iTaskTime = GET_GAME_TIMER() + 1000
|
|
ENDIF
|
|
|
|
/*
|
|
IF GET_GAME_TIMER() >= jetData[i].iTaskTime
|
|
vTargetOffset = <<250, 1000, 40>>//<<37, 100, 12>>
|
|
IF jetData[i].bInvertOffset
|
|
vTargetOffset.x *= -1
|
|
// PRINTSTRING("vTargetOffset = ") PRINTVECTOR(vTargetOffset) PRINTNL()
|
|
ENDIF
|
|
|
|
vTarget = GET_JET_TARGET_FROM_TARGET_OFFSET(vTargetOffset)
|
|
TASK_PLANE_CHASE(jetData[i].ped, playerPlane, vTargetOffset)
|
|
ENDIF
|
|
*/
|
|
ENDIF
|
|
BREAK
|
|
ENDSWITCH
|
|
|
|
// missile launch
|
|
IF NOT bDoneShootDownReactSpeech
|
|
IF NOT bDoneFireMissileSpeech
|
|
IF jetAttackState >= JET_ATTACK_MISSILES
|
|
bDoneFireMissileSpeech = DO_MISSION_SPEECH("EXL1_SHOOT")
|
|
ENDIF
|
|
ELSE
|
|
// bDoneFireMissileSpeech2 = TRUE
|
|
IF NOT bDoneFireMissileSpeech2
|
|
IF bDoneEngineBlowSpeech
|
|
bDoneFireMissileSpeech2 = TRUE
|
|
ELSE
|
|
bDoneFireMissileSpeech2 = DO_MISSION_SPEECH("EXL1_MISSILE")
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF i=0
|
|
IF fApplyXForce <> 0
|
|
fApplyXForce *= -1
|
|
ENDIF
|
|
ENDIF
|
|
|
|
//fApplyXForce=fApplyXForce
|
|
//fApplyYForce=fApplyYForce
|
|
APPLY_FORCE_TO_ENTITY(jetData[i].veh, APPLY_TYPE_FORCE, <<fApplyXForce,0,0>>, <<0,10,0>>, 0, TRUE, TRUE, TRUE)
|
|
APPLY_FORCE_TO_ENTITY(jetData[i].veh, APPLY_TYPE_FORCE, <<0,fApplyYForce,0>>, <<0,0,0>>, 0, TRUE, TRUE, TRUE)
|
|
APPLY_FORCE_TO_ENTITY(jetData[i].veh, APPLY_TYPE_FORCE, <<0,0,fApplyZForce>>, <<0,0,0>>, 0, FALSE, TRUE, TRUE)
|
|
|
|
IF bDoneSeeJetSpeech
|
|
OR bJetsScrambled
|
|
OR jetAttackState >= JET_ATTACK_TO_REAR
|
|
IF NOT DOES_BLIP_EXIST(jetData[i].blip)
|
|
jetData[i].blip = CREATE_MISSION_BLIP_FOR_VEHICLE(jetData[i].veh, TRUE)
|
|
ENDIF
|
|
ENDIF
|
|
ELSE
|
|
IF DOES_BLIP_EXIST(jetData[i].blip)
|
|
REMOVE_BLIP(jetData[i].blip)
|
|
ENDIF
|
|
ENDIF
|
|
ENDREPEAT
|
|
ENDIF
|
|
|
|
#IF IS_DEBUG_BUILD
|
|
IF bDebugForceJetIntoPlane
|
|
IF IS_VEHICLE_DRIVEABLE(jetData[0].veh)
|
|
AND IS_VEHICLE_DRIVEABLE(planeFightVehicle[PFV_CARGO_PLANE])
|
|
SET_ENTITY_COORDS(jetData[0].veh, GET_ENTITY_COORDS(planeFightVehicle[PFV_CARGO_PLANE]))
|
|
ENDIF
|
|
ENDIF
|
|
#ENDIF
|
|
ENDPROC
|
|
|
|
// PURPOSE: caps heading to between 0.0 and 360.0
|
|
FUNC FLOAT CAP_HEADING(FLOAT heading)
|
|
|
|
float mod = heading
|
|
|
|
IF heading < 0.0
|
|
heading += ((FLOOR(mod / -360.0) + 1) * 360)
|
|
ELIF heading >= 360.0
|
|
heading = mod % 360.0
|
|
ENDIF
|
|
|
|
RETURN heading
|
|
ENDFUNC
|
|
|
|
// explode a missile
|
|
PROC EXPLODE_MISSILE(INT i)
|
|
ADD_EXPLOSION(jetMissile[i].vPos, EXP_TAG_ROCKET, 1.0)
|
|
PLAY_SOUND_FROM_COORD(-1, "Jet_Explosions", jetMissile[i].vPos, "exile_1")
|
|
|
|
STOP_PARTICLE_FX_LOOPED(jetMissile[i].ptfx)
|
|
DELETE_OBJECT(jetMissile[i].obj)
|
|
iNextCheckCrashTime = GET_GAME_TIMER() + 2000
|
|
jetMissile[i].state = JET_MISSILE_STATE_EXPLODED
|
|
|
|
IF NOT HAS_SOUND_FINISHED(jetMissile[i].iSoundID)
|
|
STOP_SOUND(jetMissile[i].iSoundID)
|
|
ENDIF
|
|
|
|
IF NOT bDoneMissileExplodeCue
|
|
bDoneMissileExplodeCue = TRIGGER_MISSION_MUSIC_EVENT("EXL1_MISSLE_HITS")
|
|
ENDIF
|
|
ENDPROC
|
|
|
|
// handle missiles from jet
|
|
PROC HANDLE_MISSILES()
|
|
//CONST_FLOAT MISSILE_TURN_SPEED 0.01//8.0
|
|
CONST_FLOAT MISSILE_FORWARD_SPEED 100.0
|
|
CONST_FLOAT MISSILE_INIT_X 3.0
|
|
|
|
VEHICLE_INDEX playerPlane
|
|
|
|
IF currentMissionStage = STAGE_FLY_PLANE
|
|
playerPlane = planeFightVehicle[PFV_CARGO_PLANE]
|
|
ELSE
|
|
playerPlane = planeFightVehicle[PFV_TREVOR_PLANE]
|
|
ENDIF
|
|
|
|
INT i
|
|
REPEAT COUNT_OF(jetMissile) i
|
|
INT iMissileOwner
|
|
IF i < 2
|
|
iMissileOwner = 1
|
|
ELSE
|
|
iMissileOwner = 0
|
|
ENDIF
|
|
|
|
SWITCH jetMissile[i].state
|
|
CASE JET_MISSILE_STATE_LAUNCH_READY
|
|
IF IS_VEHICLE_DRIVEABLE(jetData[iMissileOwner].veh)
|
|
FLOAT fXInit
|
|
fXInit = MISSILE_INIT_X
|
|
IF i%2 <> 0
|
|
fXInit *= -1
|
|
ENDIF
|
|
|
|
jetMissile[i].vPos = GET_OFFSET_FROM_ENTITY_IN_WORLD_COORDS(jetData[iMissileOwner].veh, <<fXInit, 8.0, 0.0>>)
|
|
jetMissile[i].vRot = GET_ENTITY_ROTATION(jetData[iMissileOwner].veh)
|
|
jetMissile[i].vCurrentDirection = NORMALISE_VECTOR(GET_OFFSET_FROM_ENTITY_IN_WORLD_COORDS(jetData[iMissileOwner].veh, <<fXInit, 200.0, 0.0>>) - jetMissile[i].vPos)
|
|
|
|
jetMissile[i].obj = CREATE_OBJECT(GET_WEAPONTYPE_MODEL(WEAPONTYPE_AMMO_SPACE_ROCKET), jetMissile[i].vPos)
|
|
SET_ENTITY_ROTATION(jetMissile[i].obj, jetMissile[i].vRot)
|
|
SET_ENTITY_SHOULD_FREEZE_WAITING_ON_COLLISION(jetMissile[i].obj, FALSE)
|
|
|
|
PLAY_SOUND_FROM_ENTITY(jetMissile[i].iSoundID, "SPL_RPG_DIST_FLIGHT_MASTER", jetMissile[i].obj)
|
|
|
|
//jetMissile[i].ptfx = START_PARTICLE_FX_LOOPED_ON_ENTITY("scr_ex1_heatseeker", jetMissile[i].obj, <<0.0, -0.2, 0.0>>, <<0.0, 0.0, 0.0>>)
|
|
IF DO_PLANE_HEADINGS_MATCH(jetData[iMissileOwner].veh, playerPlane, 60)
|
|
jetMissile[i].fTurnSpeed = 8.0
|
|
ELSE
|
|
jetMissile[i].fTurnSpeed = 0.0
|
|
ENDIF
|
|
jetMissile[i].ptfx = START_PARTICLE_FX_LOOPED_AT_COORD("scr_ex1_heatseeker", GET_ENTITY_COORDS(jetMissile[i].obj), GET_ENTITY_ROTATION(jetMissile[i].obj))
|
|
jetMissile[i].state = JET_MISSILE_STATE_IN_FLIGHT
|
|
ENDIF
|
|
BREAK
|
|
|
|
CASE JET_MISSILE_STATE_IN_FLIGHT
|
|
jetMissile[i].fTurnSpeed = jetMissile[i].fTurnSpeed +@ 1.0
|
|
IF jetMissile[i].fTurnSpeed >= 8.0
|
|
jetMissile[i].fTurnSpeed = 8.0
|
|
ENDIF
|
|
|
|
IF NOT IS_ENTITY_DEAD(playerPlane)
|
|
VECTOR vTargetPos
|
|
VECTOR vTargetOffset
|
|
IF currentMissionStage = STAGE_FLY_PLANE
|
|
SWITCH i
|
|
CASE 0
|
|
vTargetOffset = <<-4, -30, 0>>
|
|
BREAK
|
|
CASE 1
|
|
vTargetOffset = <<0.0122964, -48.1696, 6.5634 >>
|
|
BREAK
|
|
CASE 2
|
|
vTargetOffset = <<5, -4, -0.5>>
|
|
BREAK
|
|
CASE 3
|
|
vTargetOffset = << 27.4893, -12.1439, -1.92886 >>
|
|
BREAK
|
|
ENDSWITCH
|
|
ELSE
|
|
vTargetOffset = <<0,0,0>>
|
|
ENDIF
|
|
|
|
vTargetPos = GET_OFFSET_FROM_ENTITY_IN_WORLD_COORDS(playerPlane, vTargetOffset)
|
|
VECTOR vDesiredDirection
|
|
vDesiredDirection = <<0,0,0>>
|
|
|
|
vDesiredDirection = NORMALISE_VECTOR(vTargetPos - jetMissile[i].vPos)
|
|
|
|
jetMissile[i].vCurrentDirection.x = jetMissile[i].vCurrentDirection.x + ((vDesiredDirection.x - jetMissile[i].vCurrentDirection.x) * jetMissile[i].fTurnSpeed * GET_FRAME_TIME())
|
|
jetMissile[i].vCurrentDirection.y = jetMissile[i].vCurrentDirection.y + ((vDesiredDirection.y - jetMissile[i].vCurrentDirection.y) * jetMissile[i].fTurnSpeed * GET_FRAME_TIME())
|
|
jetMissile[i].vCurrentDirection.z = jetMissile[i].vCurrentDirection.z + ((vDesiredDirection.z - jetMissile[i].vCurrentDirection.z) * jetMissile[i].fTurnSpeed * GET_FRAME_TIME())
|
|
|
|
jetMissile[i].vRot.x = ATAN2(jetMissile[i].vCurrentDirection.z, VMAG(<<jetMissile[i].vCurrentDirection.x, jetMissile[i].vCurrentDirection.y, 0.0>>))
|
|
jetMissile[i].vRot.z = CAP_HEADING(ATAN2(jetMissile[i].vCurrentDirection.y, jetMissile[i].vCurrentDirection.x) - 90.0)
|
|
jetMissile[i].vPos += (jetMissile[i].vCurrentDirection * GET_FRAME_TIME() * MISSILE_FORWARD_SPEED)
|
|
|
|
SET_ENTITY_COORDS_NO_OFFSET(jetMissile[i].obj, jetMissile[i].vPos)
|
|
SET_ENTITY_ROTATION(jetMissile[i].obj, jetMissile[i].vRot)
|
|
|
|
// setup ptfx
|
|
SET_PARTICLE_FX_LOOPED_OFFSETS(jetMissile[i].ptfx, GET_OFFSET_FROM_ENTITY_IN_WORLD_COORDS(jetMissile[i].obj, <<0.0, -0.2, 0.0>>), GET_ENTITY_ROTATION(jetMissile[i].obj))
|
|
|
|
IF GET_DISTANCE_BETWEEN_COORDS(jetMissile[i].vPos, vTargetPos) <= 2.0
|
|
EXPLODE_MISSILE(i)
|
|
SET_CONTROL_SHAKE(PLAYER_CONTROL, 1000, 200)
|
|
DO_MISSION_GAMEPLAY_CAM_SHAKE()
|
|
// ELSE
|
|
/// FLOAT fGround
|
|
// fGround = 0
|
|
// GET_GROUND_Z_FOR_3D_COORD(jetMissile[i].vPos, fGround)
|
|
// IF jetMissile[i].vPos.z - fGround <= 1.3
|
|
// EXPLODE_MISSILE(i)
|
|
// ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
BREAK
|
|
ENDSWITCH
|
|
ENDREPEAT
|
|
ENDPROC
|
|
|
|
// jet cam
|
|
PROC HANDLE_JET_CAM()
|
|
IF jetAttackState >= JET_ATTACK_TO_REAR
|
|
AND GET_GAME_TIMER() >= iJetTurnTime + 2500
|
|
IF NOT bShownJetCamHelp
|
|
DO_MISSION_HELP_TEXT("PF_JETHLP")
|
|
bShownJetCamHelp = TRUE
|
|
ENDIF
|
|
|
|
//set pos
|
|
IF IS_VEHICLE_DRIVEABLE(jetData[1].veh)
|
|
AND IS_VEHICLE_DRIVEABLE(planeFightVehicle[PFV_CARGO_PLANE])
|
|
VECTOR vTargetAttach
|
|
VECTOR vOffset = GET_ENTITY_COORDS(jetData[1].veh) - GET_ENTITY_COORDS(planeFightVehicle[PFV_CARGO_PLANE])
|
|
|
|
vTargetAttach.x = vOffset.x / 4
|
|
IF vTargetAttach.x > 20
|
|
vTargetAttach.x = 20
|
|
ELIF vTargetAttach.x < -20
|
|
vTargetAttach.x = -20
|
|
ENDIF
|
|
|
|
vTargetAttach.y = vOffset.y / 4
|
|
IF vTargetAttach.y > 20
|
|
vTargetAttach.y = 20
|
|
ELIF vTargetAttach.y < -20
|
|
vTargetAttach.y = -20
|
|
ENDIF
|
|
|
|
vTargetAttach.z = 6.5
|
|
|
|
CONST_FLOAT JET_CAM_INTERP_SPEED 3.0
|
|
|
|
IF vJetCamAttach.x < vTargetAttach.x
|
|
vJetCamAttach.x = vJetCamAttach.x +@ JET_CAM_INTERP_SPEED
|
|
IF vJetCamAttach.x > vTargetAttach.x
|
|
vJetCamAttach.x = vTargetAttach.x
|
|
ENDIF
|
|
ELIF vJetCamAttach.x > vTargetAttach.x
|
|
vJetCamAttach.x = vJetCamAttach.x -@ JET_CAM_INTERP_SPEED
|
|
IF vJetCamAttach.x < vTargetAttach.x
|
|
vJetCamAttach.x = vTargetAttach.x
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF vJetCamAttach.y < vTargetAttach.y
|
|
vJetCamAttach.y = vJetCamAttach.y +@ JET_CAM_INTERP_SPEED
|
|
IF vJetCamAttach.y > vTargetAttach.y
|
|
vJetCamAttach.y = vTargetAttach.y
|
|
ENDIF
|
|
ELIF vJetCamAttach.y > vTargetAttach.y
|
|
vJetCamAttach.y = vJetCamAttach.y -@ JET_CAM_INTERP_SPEED
|
|
IF vJetCamAttach.y < vTargetAttach.y
|
|
vJetCamAttach.y = vTargetAttach.y
|
|
ENDIF
|
|
ENDIF
|
|
|
|
//PRINTSTRING("offset = ") PRINTVECTOR(vOffset) printnl()
|
|
//PRINTSTRING("target attach = ") PRINTVECTOR(vTargetAttach) printnl()
|
|
|
|
ATTACH_CAM_TO_ENTITY(jetCam, jetData[1].veh, vJetCamAttach, FALSE)
|
|
ENDIF
|
|
|
|
//IF IS_CONTROL_PRESSED(PLAYER_CONTROL, INPUT_VEH_CIN_CAM)
|
|
IF SHOULD_CONTROL_CHASE_HINT_CAM(localChaseHintCamStruct, TRUE, FALSE)
|
|
AND flyPlaneState < FLY_PLANE_POST_ENGINE
|
|
//AND NOT IS_PHONE_ONSCREEN()
|
|
IF NOT bUsingJetCam
|
|
RENDER_SCRIPT_CAMS(TRUE, FALSE)
|
|
DISPLAY_HUD(FALSE)
|
|
DISPLAY_RADAR(FALSE)
|
|
bShownJetCamHelp = TRUE
|
|
IF GET_GAME_TIMER() >= iClearHelpTime
|
|
IF IS_THIS_HELP_MESSAGE_BEING_DISPLAYED("PF_JETHLP")
|
|
CLEAR_HELP(FALSE)
|
|
iClearHelpTime = GET_GAME_TIMER() + 1000
|
|
ENDIF
|
|
ENDIF
|
|
INFORM_MISSION_STATS_SYSTEM_OF_ACTION_CAM_START()
|
|
START_PLANE_FIGHT_AUDIO_SCENE(PLANE_FIGHT_AUDIO_SCENE_FIGHTER_JET_CAMERA)
|
|
bUsingJetCam = TRUE
|
|
ENDIF
|
|
ELSE
|
|
IF bUsingJetCam
|
|
INFORM_MISSION_STATS_SYSTEM_OF_ACTION_CAM_END()
|
|
RENDER_SCRIPT_CAMS(FALSE, FALSE)
|
|
DISPLAY_HUD(TRUE)
|
|
DISPLAY_RADAR(TRUE)
|
|
STOP_PLANE_FIGHT_AUDIO_SCENE(PLANE_FIGHT_AUDIO_SCENE_FIGHTER_JET_CAMERA)
|
|
bUsingJetCam = FALSE
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDPROC
|
|
|
|
// handle the wind stream played inside the jet
|
|
PROC HANDLE_PLANE_FIGHT_WIND_STREAM(BOOL bPlayOnLoaded, BOOL bForceAtDoor)
|
|
IF NOT bLoadedWindStream
|
|
bLoadedWindStream = LOAD_STREAM("Plane_Wind_Pt1", "EXILE_1")
|
|
ELSE
|
|
//printstring("loaded wind stream!") printnl()
|
|
IF bPlayOnLoaded
|
|
IF NOT bPlayingWindStream
|
|
//printstring("play wind stream!") printnl()
|
|
IF bForceAtDoor
|
|
PLAY_STREAM_FROM_POSITION(<<2930.0, 849.7, 454.5>>)
|
|
//printstring("pos1") printnl()
|
|
ELSE
|
|
PLAY_STREAM_FROM_POSITION(<<2929.93, 815.88, 449.35>>)
|
|
//printstring("pos2") printnl()
|
|
ENDIF
|
|
bPlayingWindStream = TRUE
|
|
ELSE
|
|
IF bForceAtDoor
|
|
//printstring("force at door!") printnl()
|
|
SET_VARIABLE_ON_STREAM("INOUT", 0)
|
|
ELSE
|
|
//printstring("use proportion!") printnl()
|
|
SET_VARIABLE_ON_STREAM("INOUT", (fProportionUpPlane - 1) * -1)
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDPROC
|
|
|
|
// get to the airstrip
|
|
PROC DO_STAGE_GET_TO_AIRSTRIP()
|
|
INT iWanted = GET_PLAYER_WANTED_LEVEL(PLAYER_ID())
|
|
|
|
SET_DOOR_STATE(DOORNAME_T_TRAILER_CS, DOORSTATE_FORCE_LOCKED_THIS_FRAME)
|
|
DOOR_SYSTEM_SET_DOOR_STATE(GET_HASH_KEY("DOORHASH_T_TRAILER_CS"), DOORSTATE_FORCE_LOCKED_THIS_FRAME, TRUE)
|
|
DOOR_SYSTEM_SET_OPEN_RATIO(GET_HASH_KEY("DOORHASH_T_TRAILER_CS"), -1.0)
|
|
|
|
HANDLE_BUDDY_ACTION_MODE_WHILE_WANTED(ronPed, bRonActionModeTrack, iRonActionModeDelay)
|
|
|
|
// create everything at the meeting
|
|
SWITCH createPlaneStage
|
|
CASE CREATE_PLANE_STAGE_NOT_STARTED
|
|
ADD_MODEL_REQUEST(ENUM_TO_INT(PFM_TREVOR_PLANE))
|
|
createPlaneStage = CREATE_PLANE_STAGE_WAITING
|
|
BREAK
|
|
CASE CREATE_PLANE_STAGE_WAITING
|
|
IF HAVE_ALL_MODEL_REQUESTS_SUCCEEDED()
|
|
CLEAR_AREA(GET_PLANE_FIGHT_VECTOR(PFVEC_TREVOR_PLANE_INIT), 10, TRUE)
|
|
PLANE_FIGHT_CREATE_VEHICLE(PFV_TREVOR_PLANE, GET_PLANE_FIGHT_VECTOR(PFVEC_TREVOR_PLANE_INIT), TREVOR_PLANE_INIT_ROT)
|
|
createPlaneStage = CREATE_PLANE_STAGE_DONE
|
|
ENDIF
|
|
BREAK
|
|
CASE CREATE_PLANE_STAGE_DONE
|
|
//SET_PLAYER_CONTROL(PLAYER_ID(), TRUE)
|
|
BREAK
|
|
ENDSWITCH
|
|
|
|
IF NOT bKilledHillsStreaming
|
|
IF GET_GAME_TIMER() >= iStageStartTime + 1000
|
|
IF STREAMVOL_IS_VALID(hillsStreamingVolume)
|
|
STREAMVOL_DELETE(hillsStreamingVolume)
|
|
ENDIF
|
|
bKilledHillsStreaming = TRUE
|
|
ENDIF
|
|
ENDIF
|
|
|
|
HANDLE_BUDDY_HEAD_TRACK_WHILE_ENTERING_VEHICLE()
|
|
|
|
IF NOT bCleanedUpMichaelAndPatricia
|
|
IF NOT IS_ENTITY_AT_COORD(PLAYER_PED_ID(), <<1973.55457, 3818.52441, 32.43631>>, <<400,400,400>>, FALSE, FALSE)
|
|
CLEANUP_MICHAEL_AND_PATRICIA()
|
|
ELSE
|
|
IF NOT bDoneTrevorGoBackSpeech
|
|
IF GET_INTERIOR_FROM_ENTITY(PLAYER_PED_ID()) <> NULL AND IS_ENTITY_AT_COORD(PLAYER_PED_ID(), <<1972.01514, 3817.51611, 35.51379>>, <<16,16,LOCATE_SIZE_HEIGHT>>, FALSE, FALSE)
|
|
fInTrailerTime = fInTrailerTime +@ 1.0
|
|
IF fInTrailerTime >= 1.8
|
|
IF NOT IS_PED_INJURED(michaelPed)
|
|
bDoneTrevorGoBackSpeech = DO_MISSION_SPEECH("EXL1_TRGOBAK")
|
|
ENDIF
|
|
ENDIF
|
|
ELSE
|
|
fInTrailerTime = 0.0
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF IS_PED_INJURED(michaelPed)
|
|
MISSION_FAILED(FAIL_MICHAEL_DEAD)
|
|
ELSE
|
|
SET_PED_RESET_FLAG(michaelPed, PRF_DisablePlayerMeleeFriendlyAttacks, TRUE)
|
|
IF NOT IS_PED_HEADTRACKING_ENTITY(michaelPed, PLAYER_PED_ID())
|
|
TASK_LOOK_AT_ENTITY(michaelPed, PLAYER_PED_ID(), -1, SLF_WHILE_NOT_IN_FOV)
|
|
ENDIF
|
|
IF HAS_ENTITY_BEEN_DAMAGED_BY_ENTITY(michaelPed, PLAYER_PED_ID())
|
|
APPLY_DAMAGE_TO_PED(michaelPed, 1000, TRUE)
|
|
ENDIF
|
|
ENDIF
|
|
IF IS_PED_INJURED(patriciaPed)
|
|
MISSION_FAILED(FAIL_PATRICIA_DEAD)
|
|
ELSE
|
|
SET_PED_RESET_FLAG(patriciaPed, PRF_DisablePlayerMeleeFriendlyAttacks, TRUE)
|
|
IF NOT IS_PED_HEADTRACKING_ENTITY(patriciaPed, PLAYER_PED_ID())
|
|
TASK_LOOK_AT_ENTITY(patriciaPed, PLAYER_PED_ID(), -1, SLF_WHILE_NOT_IN_FOV)
|
|
ENDIF
|
|
IF HAS_ENTITY_BEEN_DAMAGED_BY_ENTITY(patriciaPed, PLAYER_PED_ID())
|
|
APPLY_DAMAGE_TO_PED(patriciaPed, 1000, TRUE)
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
|
|
// reset direct entry flag
|
|
IF NOT bResetDirectEntryFlag
|
|
IF IS_PED_IN_ANY_VEHICLE(ronPed)
|
|
SET_PED_CONFIG_FLAG(PLAYER_PED_ID(), PCF_ForceDirectEntry, FALSE)
|
|
bResetDirectEntryFlag = TRUE
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF GET_FOLLOW_PED_CAM_VIEW_MODE() <> CAM_VIEW_MODE_FIRST_PERSON
|
|
IF GET_GAME_TIMER() <= iStageStartTime + 1000
|
|
SET_PED_MIN_MOVE_BLEND_RATIO(PLAYER_PED_ID(), PEDMOVE_WALK)
|
|
ENDIF
|
|
ENDIF
|
|
|
|
// set ron as group member
|
|
IF NOT bSetRonAsGroupMember
|
|
BOOL bDoSet = FALSE
|
|
IF IS_PED_IN_ANY_VEHICLE(ronPed)
|
|
AND IS_PED_IN_ANY_VEHICLE(PLAYER_PED_ID())
|
|
IF GET_VEHICLE_PED_IS_USING(ronPed) = GET_VEHICLE_PED_IS_USING(PLAYER_PED_ID())
|
|
bDoSet = TRUE
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF NOT IS_ENTITY_AT_ENTITY(PLAYER_PED_ID(), ronPed, <<BUDDY_WILL_GET_IN_SPECIFIC_VEHICLE_DIST, BUDDY_WILL_GET_IN_SPECIFIC_VEHICLE_DIST, BUDDY_WILL_GET_IN_SPECIFIC_VEHICLE_DIST>>, FALSE, FALSE)
|
|
bDoSet = TRUE
|
|
ENDIF
|
|
|
|
IF IS_PLAYER_USING_A_TAXI()
|
|
OR IS_THERE_A_TAXI_WAITING_FOR_THE_PLAYER()
|
|
bDoSet = TRUE
|
|
ENDIF
|
|
|
|
IF bDoSet
|
|
SET_PED_AS_GROUP_MEMBER(ronPed, PLAYER_GROUP_ID())
|
|
bSetRonAsGroupMember = TRUE
|
|
ENDIF
|
|
ENDIF
|
|
|
|
SET_TREVOR_INTO_CAR()
|
|
|
|
IF NOT bDoneInTruckAudioScene
|
|
IF IS_VEHICLE_DRIVEABLE(planeFightVehicle[PFV_TREVOR_4WD])
|
|
IF IS_PED_IN_VEHICLE(PLAYER_PED_ID(), planeFightVehicle[PFV_TREVOR_4WD])
|
|
bDoneInTruckAudioScene = START_PLANE_FIGHT_AUDIO_SCENE(PLANE_FIGHT_AUDIO_SCENE_DRIVE_TO_PLANE)
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF IS_VEHICLE_DRIVEABLE(planeFightVehicle[PFV_TREVOR_PLANE])
|
|
AND NOT IS_PED_INJURED(ronPed)
|
|
IF NOT bAtAirstrip
|
|
HANDLE_GET_TO_LOCATION(FALSE, TRUE, TRUE)
|
|
|
|
SET_VEHICLE_IS_CONSIDERED_BY_PLAYER(planeFightVehicle[PFV_TREVOR_PLANE], FALSE)
|
|
|
|
IF IS_PED_GROUP_MEMBER(ronPed, PLAYER_GROUP_ID())
|
|
OR NOT bSetRonAsGroupMember
|
|
// banter
|
|
IF bShownGodText
|
|
IF IS_PED_IN_ANY_VEHICLE(PLAYER_PED_ID())
|
|
AND IS_PED_IN_ANY_VEHICLE(ronPed)
|
|
IF GET_VEHICLE_PED_IS_IN(ronPed) = GET_VEHICLE_PED_IS_IN(PLAYER_PED_ID())
|
|
IF iWanted = 0
|
|
IF NOT bDoneBanter
|
|
IF iReplayAttempt % 2 = 0
|
|
bDoneBanter = DO_MISSION_SPEECH("EXL1_BANTERB")
|
|
ELSE
|
|
bDoneBanter = DO_MISSION_SPEECH("EXL1_BANTERC")
|
|
ENDIF
|
|
IF bDoneBanter
|
|
REPLAY_RECORD_BACK_FOR_TIME(3.0, 10.0, REPLAY_IMPORTANCE_HIGHEST)
|
|
ENDIF
|
|
ELSE
|
|
IF NOT bKilledBanterForHangarSpeech
|
|
TEXT_LABEL_23 tCurrentLabel = GET_CURRENTLY_PLAYING_STANDARD_CONVERSATION_LABEL()
|
|
IF ARE_STRINGS_EQUAL(tCurrentLabel, "EXL1_BANTERb_33")
|
|
KILL_ANY_CONVERSATION()
|
|
bKilledBanterForHangarSpeech = TRUE
|
|
ENDIF
|
|
ELSE
|
|
IF NOT bDoneOwnHangarSpeech
|
|
IF GET_CURRENT_PROPERTY_OWNER(PROPERTY_ARMS_TRAFFICKING) = CHAR_TREVOR
|
|
bDoneOwnHangarSpeech = DO_MISSION_SPEECH("EXL1_HAVEHGR")
|
|
ELSE
|
|
bDoneOwnHangarSpeech = DO_MISSION_SPEECH("EXL1_NOHGR")
|
|
ENDIF
|
|
ELSE
|
|
IF NOT bFinishedBanterSpeech
|
|
bFinishedBanterSpeech = DO_MISSION_SPEECH("EXL1_BANTERB", FALSE, 35, TRUE)
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF bSavedBanter
|
|
IF RESTORE_BANTER()
|
|
bSavedBanter = FALSE
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF (IS_ENTITY_AT_ENTITY(PLAYER_PED_ID(), planeFightVehicle[PFV_TREVOR_PLANE], <<10,10,4>>)
|
|
OR IS_ENTITY_AT_COORD(PLAYER_PED_ID(), <<2124.43433, 4802.56543, 40.07504>>, <<16.5, 16.5, 4>>))
|
|
AND IS_PED_GROUP_MEMBER(ronPed, PLAYER_GROUP_ID())
|
|
AND iWanted = 0
|
|
KILL_ANY_CONVERSATION()
|
|
bDoneBanter = FALSE
|
|
SET_VEHICLE_IS_CONSIDERED_BY_PLAYER(planeFightVehicle[PFV_TREVOR_PLANE], TRUE)
|
|
printstring("set considered true!") printnl()
|
|
Store_Vehicle_Snapshot_For_Last_Player_Vehicle(g_stageSnapshot.mVehicleStruct, g_stageSnapshot)
|
|
bAtAirstrip = TRUE
|
|
ENDIF
|
|
ENDIF
|
|
|
|
//IF iWanted = 0
|
|
// SET_VEHICLE_IS_CONSIDERED_BY_PLAYER(planeFightVehicle[PFV_TREVOR_PLANE], TRUE)
|
|
//ELSE
|
|
// SET_VEHICLE_IS_CONSIDERED_BY_PLAYER(planeFightVehicle[PFV_TREVOR_PLANE], FALSE)
|
|
//ENDIF
|
|
ELSE
|
|
IF NOT bStoppedInTruckAudioScene
|
|
IF NOT IS_PED_IN_ANY_VEHICLE(PLAYER_PED_ID())
|
|
STOP_PLANE_FIGHT_AUDIO_SCENE(PLANE_FIGHT_AUDIO_SCENE_DRIVE_TO_PLANE)
|
|
bStoppedInTruckAudioScene = TRUE
|
|
ENDIF
|
|
ENDIF
|
|
|
|
// banter
|
|
IF IS_ENTITY_AT_ENTITY(PLAYER_PED_ID(), ronPed, <<RON_CHAT_AT_PLANE_DISTANCE, RON_CHAT_AT_PLANE_DISTANCE, 4>>)
|
|
IF iWanted = 0
|
|
IF NOT bDoneBanter
|
|
IF NOT IS_ENTITY_OCCLUDED(planeFightVehicle[PFV_TREVOR_PLANE])
|
|
AND IS_ENTITY_IN_ANGLED_AREA(PLAYER_PED_ID(), <<2137.27075, 4794.18506, 40.00207>>, <<2122.55469, 4787.16504, 43.99516>>, 42)
|
|
OR IS_ENTITY_IN_ANGLED_AREA(PLAYER_PED_ID(), <<2133.57080, 4809.39404, 40.00207>>, <<2112.32910, 4799.40869, 43.99516>>, 8)
|
|
OR IS_ENTITY_IN_ANGLED_AREA(PLAYER_PED_ID(), <<2135.30176, 4818.37256, 40.00207>>, <<2105.44434, 4804.13623, 43.99516>>, 8)
|
|
bDoneBanter = DO_MISSION_SPEECH("EXL1_SEEPLNb")
|
|
IF bDoneBanter
|
|
REPLAY_RECORD_BACK_FOR_TIME(3.0, 4.0, REPLAY_IMPORTANCE_HIGHEST)
|
|
ENDIF
|
|
ENDIF
|
|
ELSE
|
|
IF NOT bDoneBriefSpeech
|
|
IF GET_VEHICLE_PED_IS_USING(PLAYER_PED_ID()) = planeFightVehicle[PFV_TREVOR_PLANE]
|
|
bDoneBriefSpeech = DO_MISSION_SPEECH("EXL1_SHOUT")
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ELSE
|
|
bDoneBanter = TRUE
|
|
ENDIF
|
|
|
|
HANDLE_GET_TO_LOCATION(TRUE, FALSE, FALSE)//GET_VEHICLE_PED_IS_USING(PLAYER_PED_ID()) <> planeFightVehicle[PFV_TREVOR_PLANE])
|
|
|
|
IF NOT bRonOutOfGroup
|
|
IF NOT IS_PED_IN_ANY_VEHICLE(PLAYER_PED_ID())
|
|
AND (IS_ENTITY_AT_COORD(ronPed, <<2124.43433, 4802.56543, 40.07504>>, <<16.5, 16.5, 4>>) OR IS_ENTITY_AT_ENTITY(ronPed, planeFightVehicle[PFV_TREVOR_PLANE], <<14,14,4>>))
|
|
|
|
//AND NOT IS_PED_IN_ANY_VEHICLE(ronPed)
|
|
//IF IS_ENTITY_AT_ENTITY(PLAYER_PED_ID(), planeFightVehicle[PFV_TREVOR_PLANE], <<20,20,LOCATE_SIZE_HEIGHT>>)
|
|
//AND iWanted = 0
|
|
SET_BLOCKING_OF_NON_TEMPORARY_EVENTS(ronPed, FALSE)
|
|
|
|
REMOVE_PED_FROM_GROUP(ronPed)
|
|
//SET_BLOCKING_OF_NON_TEMPORARY_EVENTS(ronPed, TRUE)
|
|
|
|
CLEAR_SEQUENCE_TASK(sequence)
|
|
OPEN_SEQUENCE_TASK(sequence)
|
|
TASK_LOOK_AT_ENTITY(NULL, PLAYER_PED_ID(), -1, SLF_WHILE_NOT_IN_FOV)
|
|
TASK_LEAVE_ANY_VEHICLE(NULL)
|
|
TASK_FOLLOW_NAV_MESH_TO_COORD(NULL, GET_PLANE_FIGHT_VECTOR(PFVEC_RON_STAND), PEDMOVE_WALK, 40000, DEFAULT_NAVMESH_RADIUS, ENAV_DEFAULT, RON_STAND_ROT)
|
|
CLOSE_SEQUENCE_TASK(sequence)
|
|
TASK_PERFORM_SEQUENCE(ronPed, sequence)
|
|
|
|
bRonOutOfGroup = TRUE
|
|
//ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF IS_PED_IN_VEHICLE(PLAYER_PED_ID(), planeFightVehicle[PFV_TREVOR_PLANE])
|
|
IF NOT IS_ENTITY_AT_ENTITY(PLAYER_PED_ID(), ronPed, <<RON_CHAT_AT_PLANE_DISTANCE, RON_CHAT_AT_PLANE_DISTANCE, 4>>)
|
|
KILL_ANY_CONVERSATION()
|
|
ENDIF
|
|
SET_MISSION_STAGE(STAGE_FOLLOW_PLANE_1, FALSE, FALSE)
|
|
ENDIF
|
|
ENDIF
|
|
|
|
// goto speech
|
|
IF currentMissionStage = STAGE_GET_TO_AIRSTRIP
|
|
IF NOT bDoneGotoSpeech
|
|
//bDoneGotoSpeech = DO_MISSION_SPEECH("EXL1_GOAIR")
|
|
IF iReplayAttempt % 2 = 0
|
|
bDoneGotoSpeech = DO_MISSION_SPEECH("EXL1_RONPLAS", FALSE, 0, FALSE, DO_NOT_DISPLAY_SUBTITLES)
|
|
ELSE
|
|
bDoneGotoSpeech = DO_MISSION_SPEECH("EXL1_GOAIR2", FALSE, 0, FALSE, DO_NOT_DISPLAY_SUBTITLES)
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDPROC
|
|
|
|
// common fly functions
|
|
PROC DO_COMMON_FLY_FUNCTIONS()
|
|
HANDLE_GET_TO_LOCATION(TRUE, FALSE)
|
|
//HANDLE_CROP_DUSTING()
|
|
HANDLE_CARGO_PLANE_SPEED()
|
|
|
|
IF IS_PED_IN_VEHICLE(PLAYER_PED_ID(), planeFightVehicle[PFV_TREVOR_PLANE])
|
|
IF bDoneSeePlane
|
|
OR iApproachSpeechStage > 0
|
|
CONTROL_VEHICLE_CHASE_HINT_CAM_IN_VEHICLE(localChaseHintCamStruct, planeFightVehicle[PFV_CARGO_PLANE])
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF NOT bDoneFocusAudioScene
|
|
IF IS_GAMEPLAY_HINT_ACTIVE()
|
|
bDoneFocusAudioScene = START_PLANE_FIGHT_AUDIO_SCENE(PLANE_FIGHT_AUDIO_SCENE_FOCUS_ON_CARGO_PLANE)
|
|
ENDIF
|
|
ELSE
|
|
IF NOT IS_GAMEPLAY_HINT_ACTIVE()
|
|
STOP_PLANE_FIGHT_AUDIO_SCENE(PLANE_FIGHT_AUDIO_SCENE_FOCUS_ON_CARGO_PLANE)
|
|
bDoneFocusAudioScene = FALSE
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF NOT IS_PLAYBACK_GOING_ON_FOR_VEHICLE(planeFightVehicle[PFV_CARGO_PLANE])
|
|
OR fPlaybackTime >= 300000
|
|
MISSION_FAILED(FAIL_MISSED_CARGO_PLANE)
|
|
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
|
|
|
|
// follow the plane
|
|
PROC DO_STAGE_FOLLOW_PLANE()
|
|
IF NOT bRunningCutscene
|
|
FLOAT fHeightAboveGround
|
|
FLOAT fGroundHeight
|
|
IF IS_VEHICLE_DRIVEABLE(planeFightVehicle[PFV_TREVOR_PLANE])
|
|
fHeightAboveGround = GET_HEIGHT_ABOVE_GROUND(planeFightVehicle[PFV_TREVOR_PLANE], fGroundHeight)
|
|
UPDATE_PLANE_ROOT(planeFightVehicle[PFV_TREVOR_PLANE], fHeightAboveGround)
|
|
ENDIF
|
|
|
|
IF NOT bDoneTakeoffCue
|
|
bDoneTakeoffCue = TRIGGER_MISSION_MUSIC_EVENT("EXL1_TAKE_OFF")
|
|
ENDIF
|
|
|
|
HANDLE_JET_ATTACK()
|
|
HANDLE_MISSILES()
|
|
|
|
IF NOT bSentText
|
|
VECTOR vPosForText = GET_ENTITY_COORDS(PLAYER_PED_ID())
|
|
IF vPosForText.y > 3791
|
|
AND vPosForText.x < -2064
|
|
IF NOT CHECK_FOR_MESSAGE_PRESENCE_IN_CHARACTER_MESSAGE_LIST("EXIL2_U", CHAR_TREVOR)
|
|
bSentText = SEND_TEXT_MESSAGE_TO_CURRENT_PLAYER(CHAR_FRANKLIN, "EXIL2_U", TXTMSG_UNLOCKED)
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
|
|
|
|
IF bJetsScrambled
|
|
IF NOT bKilledSpeechForJets
|
|
REMOVE_MISSION_TEXT(TRUE, FALSE, FALSE)
|
|
bKilledSpeechForJets = TRUE
|
|
ELSE
|
|
IF NOT bDoneJetsScrambledSpeech
|
|
bDoneJetsScrambledSpeech = DO_MISSION_SPEECH("EXL1_JETSUP")
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
|
|
// get rid of ron
|
|
IF NOT bRemovedRon
|
|
IF NOT IS_PED_INJURED(ronPed)
|
|
IF NOT bDoneRonWalkToTrailer
|
|
SET_BLOCKING_OF_NON_TEMPORARY_EVENTS(ronPed, FALSE)
|
|
|
|
CLEAR_SEQUENCE_TASK(sequence)
|
|
OPEN_SEQUENCE_TASK(sequence)
|
|
TASK_LOOK_AT_ENTITY(NULL, PLAYER_PED_ID(), -1, SLF_WHILE_NOT_IN_FOV)
|
|
TASK_FOLLOW_NAV_MESH_TO_COORD(NULL, <<2158.33569, 4790.00098, 40.12202>>, PEDMOVE_WALK, 40000)
|
|
TASK_ACHIEVE_HEADING(NULL, 80.7)
|
|
CLOSE_SEQUENCE_TASK(sequence)
|
|
TASK_PERFORM_SEQUENCE(ronPed, sequence)
|
|
bDoneRonWalkToTrailer = TRUE
|
|
ENDIF
|
|
IF NOT IS_ENTITY_AT_ENTITY(PLAYER_PED_ID(), ronPed, <<360,360,360>>, FALSE, FALSE)
|
|
IF NOT IS_ANY_CONVERSATION_ONGOING_OR_QUEUED()
|
|
CLEANUP_RON()
|
|
ADD_PED_FOR_DIALOGUE(planeFightConversation, 3, NULL, "NervousRon")
|
|
bRemovedRon = TRUE
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF DOES_ENTITY_EXIST(checkpointVehicle)
|
|
IF IS_ENTITY_DEAD(checkpointVehicle)
|
|
SET_VEHICLE_AS_NO_LONGER_NEEDED(checkpointVehicle)
|
|
ELSE
|
|
IF NOT IS_ENTITY_AT_ENTITY(PLAYER_PED_ID(), checkpointVehicle, <<300,300,300>>, FALSE, FALSE)
|
|
SET_VEHICLE_AS_NO_LONGER_NEEDED(checkpointVehicle)
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF IS_VEHICLE_DRIVEABLE(planeFightVehicle[PFV_TREVOR_PLANE])
|
|
AND IS_VEHICLE_DRIVEABLE(planeFightVehicle[PFV_CARGO_PLANE])
|
|
VECTOR vPlayerCoords = GET_ENTITY_COORDS(PLAYER_PED_ID())
|
|
VECTOR vPlaneCoords = GET_ENTITY_COORDS(planeFightVehicle[PFV_CARGO_PLANE])
|
|
|
|
DO_COMMON_FLY_FUNCTIONS()
|
|
|
|
IF NOT bBeenCloseToPlane
|
|
//PRINTfloat(GET_DISTANCE_BETWEEN_COORDS(vPlayerCoords, vPlaneCoords)) PRINTNL()
|
|
IF GET_DISTANCE_BETWEEN_COORDS(vPlayerCoords, vPlaneCoords) < 2400
|
|
bBeenCloseToPlane = TRUE
|
|
ENDIF
|
|
ENDIF
|
|
|
|
FLOAT fFailDistance
|
|
FLOAT fFlashPercentage
|
|
IF bBeenCloseToPlane
|
|
fFailDistance = 3000
|
|
fFlashPercentage = 0.90
|
|
ELSE
|
|
fFailDistance = 5000
|
|
fFlashPercentage = 0.95
|
|
ENDIF
|
|
|
|
UPDATE_CHASE_BLIP(getToBlip, planeFightVehicle[PFV_CARGO_PLANE], fFailDistance, fFlashPercentage)
|
|
|
|
IF fPlaneDistance >= fFailDistance
|
|
MISSION_FAILED(FAIL_LOST_CARGO_PLANE)
|
|
ENDIF
|
|
|
|
FLOAT fAllowableHeight
|
|
IF NOT bAllowFlyHigh
|
|
IF IS_ENTITY_IN_AREA(PLAYER_PED_ID(), <<-909, 5426, -10>>, <<-310,6078,200>>, FALSE, FALSE)
|
|
fAllowableHeight = 130.0
|
|
ELSE
|
|
fAllowableHeight = 46//48.5//50.0//55.0
|
|
ENDIF
|
|
|
|
SET_FAKE_MINIMAP_MAX_ALTIMETER_HEIGHT(fGroundHeight + fAllowableHeight)
|
|
ENDIF
|
|
|
|
|
|
IF IS_PED_SITTING_IN_VEHICLE(PLAYER_PED_ID(), planeFightVehicle[PFV_TREVOR_PLANE])
|
|
|
|
IF bRemovedRon
|
|
IF NOT bDoneComeInSpeech
|
|
bDoneComeInSpeech = DO_MISSION_SPEECH("EXL1_COME")
|
|
ELSE
|
|
IF NOT bDoneFlyLowSpeech
|
|
IF DO_MISSION_SPEECH("EXL1_RADAR")
|
|
bDoneFlyLowSpeech = TRUE
|
|
iEnforceFlyLowTime = GET_GAME_TIMER()
|
|
iFlyLowSpeechTime = GET_GAME_TIMER()
|
|
ENDIF
|
|
ELSE
|
|
//IF NOT bDoneFlyLowSpeech2
|
|
// bDoneFlyLowSpeech2 = DO_MISSION_SPEECH("EXL1_RADAR2")
|
|
//ENDIF
|
|
IF GET_GAME_TIMER() >= iFlyLowSpeechTime + 2000
|
|
IF NOT bShownFlyLowHelp
|
|
iEnforceFlyLowTime = GET_GAME_TIMER()
|
|
bEnforceFlyLow = TRUE
|
|
bShownFlyLowHelp = DO_MISSION_HELP_TEXT("PF_LOWHLP")
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF bEnforceFlyLow
|
|
IF NOT bAllowFlyHigh
|
|
|
|
IF GET_GAME_TIMER() >= iEnforceFlyLowTime + 8000
|
|
// check plane height
|
|
|
|
BOOL bClimbing
|
|
|
|
IF fHeightAboveGround > fCachedHeightAboveGround
|
|
bClimbing = TRUE
|
|
ELSE
|
|
bClimbing = FALSE
|
|
ENDIF
|
|
|
|
IF fHeightAboveGround >= fAllowableHeight
|
|
BOOL bDelayGoDownSpeech = FALSE
|
|
|
|
IF fPlaybackTime < ALLOW_FLY_HIGH_TIME - 10000 // allow some leeway at the end
|
|
OR fPlaybackTime > ALLOW_FLY_HIGH_TIME + 5000
|
|
OR fAboveHeightTime >= 3.0
|
|
fAboveHeightTime = fAboveHeightTime +@ 1.0
|
|
ELSE
|
|
fAboveHeightTime = fAboveHeightTime +@ 0.20
|
|
bDelayGoDownSpeech = TRUE
|
|
ENDIF
|
|
|
|
IF NOT bDelayGoDownSpeech
|
|
IF NOT bKilledSpeechForTooHigh
|
|
IF NOT bJetsScrambled
|
|
REMOVE_MISSION_TEXT(TRUE, FALSE, FALSE)
|
|
bKilledSpeechForTooHigh = TRUE
|
|
ENDIF
|
|
ELSE
|
|
IF iTooHighCount < 4
|
|
IF NOT bJetsScrambled
|
|
IF NOT bDoneTooHighSpeech
|
|
IF DO_MISSION_SPEECH("EXL1_THIGH")
|
|
INFORM_MISSION_STATS_OF_INCREMENT(EXL1_FLYING_HIGH)
|
|
bDoneTooHighSpeech = TRUE
|
|
ENDIF
|
|
ELSE
|
|
IF NOT bDoneTooHighUrgentSpeech
|
|
IF fAboveHeightTime > 9.0
|
|
bDoneTooHighUrgentSpeech = DO_MISSION_SPEECH("EXL1_TUHIGH")
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF NOT bKlaxonOn
|
|
IF HAS_SOUND_FINISHED(iKlaxonSoundID)
|
|
IF GET_GAME_TIMER() >= iKlaxonTime + 1000
|
|
//AND fAboveHeightTime > 3.5//2.5
|
|
//printstring("play altitude warning") printnl()
|
|
PLAY_SOUND_FRONTEND(iKlaxonSoundID, "Altitude_Warning", "EXILE_1")
|
|
iKlaxonTime = GET_GAME_TIMER()
|
|
bKlaxonOn = TRUE
|
|
ENDIF
|
|
ENDIF
|
|
ELSE
|
|
IF NOT bIncrementedTooHigh
|
|
IF fAboveHeightTime >= 3.0
|
|
iTooHighCount++
|
|
IF iTooHighCount >= 5
|
|
bJetsScrambled = TRUE
|
|
ENDIF
|
|
bIncrementedTooHigh = TRUE
|
|
printstring("itoohigh = ") printint(iTooHighCount) PRINTNL()
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF NOT HAS_SOUND_FINISHED(iKlaxonSoundID)
|
|
FLOAT fIntensity
|
|
FLOAT fHeightAboveAllowable = fHeightAboveGround - fAllowableHeight
|
|
|
|
IF bClimbing
|
|
SWITCH iAlarmIntensitySetting
|
|
CASE 0
|
|
IF fHeightAboveAllowable >= 50
|
|
OR fAboveHeightTime >= 7.0
|
|
iAlarmIntensitySetting++
|
|
ENDIF
|
|
BREAK
|
|
CASE 1
|
|
IF fHeightAboveAllowable >= 100
|
|
OR fAboveHeightTime >= 12.0
|
|
iAlarmIntensitySetting++
|
|
ENDIF
|
|
BREAK
|
|
ENDSWITCH
|
|
ENDIF
|
|
|
|
SWITCH iAlarmIntensitySetting
|
|
CASE 0
|
|
fIntensity = 0.0
|
|
BREAK
|
|
CASE 1
|
|
fIntensity = 0.5
|
|
BREAK
|
|
CASE 2
|
|
fIntensity = 1.0
|
|
BREAK
|
|
ENDSWITCH
|
|
|
|
SET_VARIABLE_ON_SOUND(iKlaxonSoundID, "Intensity", fIntensity)
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF NOT bShownTooHighHelp
|
|
IF iShownTooHighHelpTimes < 2
|
|
IF fAboveHeightTime > 2.8
|
|
IF DO_MISSION_HELP_TEXT("PF_DWNHLP")
|
|
iTooHighHelpTime = GET_GAME_TIMER()
|
|
iShownTooHighHelpTimes++
|
|
bShownTooHighHelp = TRUE
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF fAboveHeightTime > 15.0
|
|
bJetsScrambled = TRUE
|
|
//MISSION_FAILED(FAIL_TOO_HIGH)
|
|
ENDIF
|
|
ELSE
|
|
// test to see if Trev should say he is already on the case getting low
|
|
IF bDoneTooHighSpeech
|
|
IF IS_ANY_CONVERSATION_ONGOING_OR_QUEUED()
|
|
TEXT_LABEL_23 tCurrentRoot = GET_CURRENTLY_PLAYING_STANDARD_CONVERSATION_ROOT()
|
|
IF ARE_STRINGS_EQUAL(tCurrentRoot, "EXL1_THIGH")
|
|
iCancelOnItSpeechTime = GET_GAME_TIMER() + 1000
|
|
bDoOnItSpeech = TRUE
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
|
|
fAboveHeightTime = fAboveHeightTime -@ 5.0
|
|
IF fAboveHeightTime <= 0.0
|
|
iAlarmIntensitySetting = 0
|
|
fAboveHeightTime = 0.0
|
|
bIncrementedTooHigh = FALSE
|
|
bKilledSpeechForTooHigh = FALSE
|
|
bDoneTooHighSpeech = FALSE
|
|
bDoneTooHighUrgentSpeech = FALSE
|
|
bShownTooHighHelp = FALSE
|
|
bKlaxonOn = FALSE
|
|
ENDIF
|
|
|
|
IF bDoOnItSpeech
|
|
IF GET_GAME_TIMER() >= iCancelOnItSpeechTime
|
|
bDoOnItSpeech = FALSE
|
|
ELSE
|
|
IF IS_ANY_CONVERSATION_ONGOING_OR_QUEUED()
|
|
iCancelOnItSpeechTime = GET_GAME_TIMER() + 1000
|
|
ELSE
|
|
IF DO_MISSION_SPEECH("EXL1_ONIT")
|
|
bDoOnItSpeech = FALSE
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF IS_THIS_HELP_MESSAGE_BEING_DISPLAYED("PF_DWNHLP")
|
|
IF GET_GAME_TIMER() >= iTooHighHelpTime + 2500
|
|
AND GET_GAME_TIMER() >= iClearHelpTime + 1000
|
|
iClearHelpTime = GET_GAME_TIMER()
|
|
CLEAR_HELP(FALSE)
|
|
ENDIF
|
|
ENDIF
|
|
|
|
|
|
IF NOT HAS_SOUND_FINISHED(iKlaxonSoundID)
|
|
IF savedFailReason <> FAIL_TOO_HIGH
|
|
IF GET_GAME_TIMER() >= iKlaxonTime + 1000
|
|
AND NOT bJetsScrambled
|
|
STOP_SOUND(iKlaxonSoundID)
|
|
iKlaxonTime = GET_GAME_TIMER()
|
|
bKlaxonOn = FALSE
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
|
|
ENDIF
|
|
|
|
fCachedHeightAboveGround = fHeightAboveGround
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
|
|
// handle entering the plane
|
|
IF IS_PED_SITTING_IN_VEHICLE(PLAYER_PED_ID(), planeFightVehicle[PFV_TREVOR_PLANE])
|
|
// music
|
|
|
|
//ELSE
|
|
IF NOT bDoneSpotPlaneCue
|
|
IF iApproachSpeechStage > 0
|
|
bDoneSpotPlaneCue = TRIGGER_MISSION_MUSIC_EVENT("EXL1_CARGO_PLANE_SPOTTED")
|
|
ENDIF
|
|
ELSE
|
|
IF NOT bDoneSenseOfStyleCue
|
|
IF iApproachSpeechStage > 3
|
|
bDoneSenseOfStyleCue = TRIGGER_MISSION_MUSIC_EVENT("EXL1_SENSE_OF_STYLE")
|
|
ENDIF
|
|
ELSE
|
|
IF NOT bDoneOnToesCue
|
|
IF iApproachSpeechStage > 5
|
|
bDoneOnToesCue = TRIGGER_MISSION_MUSIC_EVENT("EXL1_ON_YOUR_TOES")
|
|
ENDIF
|
|
ELSE
|
|
IF NOT bDoneStartClimbingCue
|
|
IF bDoneFlyHighSpeech
|
|
bDoneStartClimbingCue = TRIGGER_MISSION_MUSIC_EVENT("EXL1_START_CLIMBING")
|
|
ENDIF
|
|
ELSE
|
|
IF NOT bDoneIdentifyYourselfCue
|
|
IF iApproachSpeechStage > 8
|
|
bDoneIdentifyYourselfCue = TRIGGER_MISSION_MUSIC_EVENT("EXL1_IDENTIFY_YOURSELF")
|
|
ENDIF
|
|
ELSE
|
|
IF NOT bPreparedCargoDoorsOpenCue
|
|
bPreparedCargoDoorsOpenCue = PREPARE_MUSIC_EVENT("EXL1_CARGO_DOORS_OPEN")
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
|
|
ENDIF
|
|
//ENDIF
|
|
|
|
// audio scenes
|
|
IF NOT bDoneCargoPlaneAppearsAudioScene
|
|
IF iApproachSpeechStage > 0
|
|
IF START_PLANE_FIGHT_AUDIO_SCENE(PLANE_FIGHT_AUDIO_SCENE_CARGO_PLANE_APPEARS)
|
|
bDoneCargoPlaneAppearsAudioScene = TRUE
|
|
STOP_PLANE_FIGHT_AUDIO_SCENE(PLANE_FIGHT_AUDIO_SCENE_FLIGHT_MAIN)
|
|
ENDIF
|
|
ENDIF
|
|
ELSE
|
|
IF NOT bDoneWarningAudioScene
|
|
IF iApproachSpeechStage > 6
|
|
bDoneWarningAudioScene = START_PLANE_FIGHT_AUDIO_SCENE(PLANE_FIGHT_AUDIO_SCENE_TREVOR_GETS_WARNING)
|
|
ENDIF
|
|
ELSE
|
|
IF NOT bStoppedWarningAudioScene
|
|
IF iApproachSpeechStage > 11
|
|
IF NOT IS_ANY_CONVERSATION_ONGOING_OR_QUEUED()
|
|
STOP_PLANE_FIGHT_AUDIO_SCENE(PLANE_FIGHT_AUDIO_SCENE_TREVOR_GETS_WARNING)
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
|
|
// set speed
|
|
IF NOT bStoppedForceSpeed
|
|
SET_VEHICLE_FORWARD_SPEED(planeFightVehicle[PFV_TREVOR_PLANE], 55.0)
|
|
IF GET_GAME_TIMER() >= iStopForceSpeedTime
|
|
bStoppedForceSpeed = TRUE
|
|
ENDIF
|
|
ENDIF
|
|
|
|
// goto speech
|
|
IF NOT bDoneGotoSpeech
|
|
IF NOT IS_PED_INJURED(ronPed)
|
|
IF IS_ENTITY_AT_COORD(ronPed, GET_PLANE_FIGHT_VECTOR(PFVEC_RON_STAND), <<20.0, 20.0, 20.0>>, FALSE, FALSE)
|
|
bDoneGotoSpeech = DO_MISSION_SPEECH("EXL1_RADIO")
|
|
ELSE
|
|
bDoneGotoSpeech = TRUE
|
|
ENDIF
|
|
ELSE
|
|
bDoneGotoSpeech = TRUE
|
|
ENDIF
|
|
ELSE
|
|
IF iApproachSpeechStage <= 11
|
|
AND bShownGodText
|
|
// approach speech
|
|
FLOAT fSpeechDistance
|
|
FLOAT fSpeechDistanceZ
|
|
FLOAT fSpeechTime
|
|
BOOL bRequireLOS = TRUE
|
|
STRING sSpeech
|
|
|
|
SWITCH iApproachSpeechStage
|
|
CASE 0 // see plane
|
|
//IF GET_RANDOM_INT_IN_RANGE(0,10) = 0 // temp - do check to see if it's actually "On his 12"
|
|
BOOL bIsFacing
|
|
bIsFacing = FALSE
|
|
|
|
VECTOR vPlayerPos
|
|
VECTOR vPlanePos
|
|
vPlayerPos = GET_ENTITY_COORDS(PLAYER_PED_ID())
|
|
vPlanePos = GET_ENTITY_COORDS(planeFightVehicle[PFV_CARGO_PLANE])
|
|
FLOAT fHeadingToPlane
|
|
fHeadingToPlane = GET_HEADING_BETWEEN_VECTORS_2D(vPlayerPos, vPlanePos)
|
|
fHeadingToPlane = NORMALISE_HEADING(fHeadingToPlane)
|
|
|
|
//PRINTSTRING("heading to plane = ") PRINTFLOAT(fHeadingToPlane) PRINTNL()
|
|
|
|
bIsFacing = IS_VEHICLE_AT_HEADING(planeFightVehicle[PFV_TREVOR_PLANE], fHeadingToPlane, 30)
|
|
|
|
|
|
|
|
IF NOT bIsFacing
|
|
sSpeech = "EXL1_SEECG"
|
|
ELSE
|
|
sSpeech = "EXL1_HORIZ"
|
|
ENDIF
|
|
fSpeechDistance = 2750
|
|
fSpeechDistanceZ = 2750
|
|
fSpeechTime = 0
|
|
BREAK
|
|
CASE 1 // see plane
|
|
sSpeech = "EXL1_RONENC"
|
|
fSpeechDistance = 3000
|
|
fSpeechDistanceZ = 3000
|
|
fSpeechTime = 0
|
|
bRequireLOS = FALSE
|
|
BREAK
|
|
CASE 2 // banter 1
|
|
IF GET_RANDOM_INT_IN_RANGE(0,2) = 0
|
|
sSpeech = "EXL1_PBAN1"
|
|
ELSE
|
|
sSpeech = "EXL1_PBAN2"
|
|
ENDIF
|
|
fSpeechDistance = 3000
|
|
fSpeechDistanceZ = 3000
|
|
fSpeechTime = 27000
|
|
bRequireLOS = FALSE
|
|
BREAK
|
|
CASE 3 // banter 2
|
|
sSpeech = "EXL1_PBAN3"
|
|
fSpeechDistance = 3000
|
|
fSpeechDistanceZ = 3000
|
|
fSpeechTime = 76000
|
|
bRequireLOS = FALSE
|
|
BREAK
|
|
CASE 4 // banter 3
|
|
IF GET_RANDOM_INT_IN_RANGE(0,2) = 0
|
|
sSpeech = "EXL1_PBAN4"
|
|
ELSE
|
|
sSpeech = "EXL1_PBAN5"
|
|
ENDIF
|
|
fSpeechDistance = 3000
|
|
fSpeechDistanceZ = 3000
|
|
fSpeechTime = 116000
|
|
bRequireLOS = FALSE
|
|
BREAK
|
|
CASE 5 // banter 4
|
|
IF GET_RANDOM_INT_IN_RANGE(0,2) = 0
|
|
sSpeech = "EXL1_PBAN6"
|
|
ELSE
|
|
sSpeech = "EXL1_PBAN7"
|
|
ENDIF
|
|
fSpeechDistance = 3000
|
|
fSpeechDistanceZ = 3000
|
|
fSpeechTime = 154000
|
|
bRequireLOS = FALSE
|
|
BREAK
|
|
CASE 6 // threat 1
|
|
sSpeech = "EXL1_WARN1"
|
|
fSpeechDistance = 950
|
|
fSpeechDistanceZ = 600
|
|
fSpeechTime = 55000
|
|
BREAK
|
|
CASE 7 // response 1
|
|
sSpeech = "EXL1_RESP1"
|
|
fSpeechDistance = 3000
|
|
fSpeechDistanceZ = 3000
|
|
fSpeechTime = 55000
|
|
bRequireLOS = FALSE
|
|
BREAK
|
|
CASE 8 // threat 2
|
|
sSpeech = "EXL1_WARN2"
|
|
fSpeechDistance = 720
|
|
fSpeechDistanceZ = 250
|
|
fSpeechTime = 93000
|
|
BREAK
|
|
CASE 9 // response 2
|
|
sSpeech = "EXL1_RESP2"
|
|
fSpeechDistance = 3000
|
|
fSpeechDistanceZ = 3000
|
|
fSpeechTime = 93000
|
|
bRequireLOS = FALSE
|
|
BREAK
|
|
CASE 10 // threat 3
|
|
sSpeech = "EXL1_WARN3"
|
|
fSpeechDistance = 480
|
|
fSpeechDistanceZ = 150
|
|
fSpeechTime = 135000
|
|
BREAK
|
|
CASE 11 // response 3
|
|
sSpeech = "EXL1_RESP3"
|
|
fSpeechDistance = 3000
|
|
fSpeechDistanceZ = 3000
|
|
fSpeechTime = 135000
|
|
bRequireLOS = FALSE
|
|
BREAK
|
|
ENDSWITCH
|
|
|
|
IF fPlaybackTime >= fSpeechTime
|
|
FLOAT fZDiff = vPlayerCoords.z - vPlaneCoords.z
|
|
IF fZDiff < 0
|
|
fZDiff *= -1
|
|
ENDIF
|
|
|
|
IF fPlaneDistance <= fSpeechDistance
|
|
AND fZDiff <= fSpeechDistanceZ
|
|
AND NOT bKlaxonOn
|
|
AND NOT bKilledSpeechForTooHigh
|
|
AND NOT bDoneTooHighSpeech
|
|
AND NOT bDoOnItSpeech
|
|
AND NOT bJetsScrambled
|
|
AND fOverBaseTime = 0.0
|
|
IF ((IS_ENTITY_ON_SCREEN(planeFightVehicle[PFV_CARGO_PLANE]) AND NOT IS_ENTITY_OCCLUDED(planeFightVehicle[PFV_CARGO_PLANE])) OR NOT bRequireLOS)
|
|
AND (iApproachSpeechStage<=5 OR bAllowFlyHigh)
|
|
IF DO_MISSION_SPEECH(sSpeech)
|
|
|
|
REPLAY_RECORD_BACK_FOR_TIME(3.0, 5.0)
|
|
|
|
iApproachSpeechStage++
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
|
|
// detect whether close enough to prompt to follow
|
|
IF NOT bDoneSeePlane
|
|
IF iApproachSpeechStage > 1
|
|
bShownGodText = FALSE
|
|
bDoneSeePlane = TRUE
|
|
ENDIF
|
|
ELSE
|
|
|
|
// test to see if should change stage
|
|
IF NOT bJetsScrambled
|
|
IF currentMissionStage = STAGE_FOLLOW_PLANE_1
|
|
IF CAN_ADVANCE_MISSION()
|
|
IF fPlaybackTime >= 88000
|
|
AND fPlaneDistance < 1500
|
|
SET_MISSION_STAGE(STAGE_FOLLOW_PLANE_2, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE)
|
|
ENDIF
|
|
ENDIF
|
|
ELIF currentMissionStage = STAGE_FOLLOW_PLANE_2
|
|
IF CAN_ADVANCE_MISSION()
|
|
IF bAllowFlyHigh
|
|
SET_MISSION_STAGE(STAGE_FOLLOW_PLANE_3, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE)
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF NOT bAllowFlyHigh
|
|
IF currentMissionStage = STAGE_FOLLOW_PLANE_2
|
|
IF fPlaybackTime >= ALLOW_FLY_HIGH_TIME
|
|
AND (fPlaneDistance < 900 OR (vPlayerCoords.x >= 1791 AND vPlayerCoords.y <= 5915))
|
|
AND NOT bJetsScrambled
|
|
IF NOT HAS_SOUND_FINISHED(iKlaxonSoundID)
|
|
STOP_SOUND(iKlaxonSoundID)
|
|
ENDIF
|
|
bDoOnItSpeech = FALSE
|
|
bKlaxonOn = FALSE
|
|
IF IS_THIS_HELP_MESSAGE_BEING_DISPLAYED("PF_DWNHLP")
|
|
CLEAR_HELP(FALSE)
|
|
ENDIF
|
|
bShownGodText = FALSE
|
|
iEnforceFlyLowTime = GET_GAME_TIMER()
|
|
iApproachSpeechStage = 6
|
|
SET_FAKE_MINIMAP_MAX_ALTIMETER_HEIGHT(0)
|
|
bAllowFlyHigh = TRUE
|
|
ENDIF
|
|
ENDIF
|
|
ELSE
|
|
IF NOT bDoneFlyHighSpeech
|
|
IF DO_MISSION_SPEECH("EXL1_CANGO")
|
|
bDoneFlyHighSpeech = TRUE
|
|
iFlyHighSpeechTime = GET_GAME_TIMER()
|
|
ENDIF
|
|
ELSE
|
|
IF NOT bDoneHereWeGoSpeech
|
|
bDoneHereWeGoSpeech = DO_MISSION_SPEECH("EXL1_HEREGO")
|
|
ENDIF
|
|
IF NOT bShownFlyHighHelp
|
|
IF GET_GAME_TIMER() >= iFlyHighSpeechTime + 2000
|
|
bShownFlyHighHelp = DO_MISSION_HELP_TEXT("PF_UPHLP")
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF currentMissionStage = STAGE_FOLLOW_PLANE_3
|
|
// if close enough, start streaming in plane stuff
|
|
SWITCH planeInteriorStreamingStage
|
|
CASE PLANE_INTERIOR_STREAMING_NOT_STARTED
|
|
REQUEST_PLANE_INTERIOR_ASSETS()
|
|
planeInteriorStreamingStage = PLANE_INTERIOR_STREAMING_WAIT
|
|
BREAK
|
|
CASE PLANE_INTERIOR_STREAMING_WAIT
|
|
IF HAVE_ALL_MODEL_REQUESTS_SUCCEEDED()
|
|
AND HAVE_ALL_ANIM_DICT_REQUESTS_SUCCEEDED()
|
|
CREATE_CARGO_PLANE_CREW()
|
|
planeInteriorStreamingStage = PLANE_INTERIOR_STREAMING_DONE
|
|
ENDIF
|
|
BREAK
|
|
CASE PLANE_INTERIOR_STREAMING_DONE
|
|
BREAK
|
|
ENDSWITCH
|
|
ENDIF
|
|
ENDIF
|
|
|
|
// detect whether over military base
|
|
BOOL bResetOverBase = FALSE
|
|
IF IS_ENTITY_AT_COORD(PLAYER_PED_ID(), <<-2179.34, 3098.39, 31.81>>, <<950,950,2000>>, FALSE, FALSE)
|
|
IF NOT bDoneBaseSpeech
|
|
IF DO_MISSION_SPEECH("EXL1_MBASE")
|
|
bDoneBaseSpeech = TRUE
|
|
iBaseSpeechTime = GET_GAME_TIMER()
|
|
ENDIF
|
|
ELSE
|
|
IF NOT bDoneIgnoreRonSpeech
|
|
bDoneIgnoreRonSpeech = DO_MISSION_SPEECH("EXL1_REACT")
|
|
ENDIF
|
|
IF GET_GAME_TIMER() >= iBaseSpeechTime + 2000
|
|
IF NOT bShownBaseHelp
|
|
bShownBaseHelp = DO_MISSION_HELP_TEXT("PF_BASHLP")
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF GET_GAME_TIMER() >= iBaseCheckTime + 250
|
|
IF IS_COORD_IN_SPECIFIED_AREA(vPlayerCoords, AC_MILITARY_BASE, 2000)
|
|
bDoOnItSpeech = FALSE
|
|
|
|
IF NOT bKilledSpeechForBase
|
|
IF NOT bJetsScrambled
|
|
REMOVE_MISSION_TEXT(TRUE, FALSE, FALSE)
|
|
bKilledSpeechForBase = TRUE
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF NOT bDoneOverBaseSpeech
|
|
IF GET_GAME_TIMER() >= iNextOverBaseSpeechTime
|
|
bDoneOverBaseSpeech = DO_MISSION_SPEECH("EXL1_FORT")
|
|
ENDIF
|
|
ENDIF
|
|
fOverBaseTime += 0.25
|
|
IF fOverBaseTime >= 6.0
|
|
bJetsScrambled = TRUE
|
|
//MISSION_FAILED(FAIL_OVER_BASE)
|
|
ENDIF
|
|
ELSE
|
|
bResetOverBase = TRUE
|
|
ENDIF
|
|
iBaseCheckTime = GET_GAME_TIMER()
|
|
ENDIF
|
|
ELSE
|
|
bResetOverBase = TRUE
|
|
ENDIF
|
|
|
|
IF bResetOverBase
|
|
fOverBaseTime = fOverBaseTime -@ 2.0
|
|
IF fOverBaseTime < 0
|
|
fOverBaseTime = 0.0
|
|
ENDIF
|
|
IF bDoneOverBaseSpeech
|
|
iNextOverBaseSpeechTime = GET_GAME_TIMER() + 3000
|
|
bDoneOverBaseSpeech = FALSE
|
|
ENDIF
|
|
bKilledSpeechForBase = FALSE
|
|
ENDIF
|
|
|
|
// trigger open door cut
|
|
IF bAllowFlyHigh
|
|
IF IS_ENTITY_AT_ENTITY(PLAYER_PED_ID(), planeFightVehicle[PFV_CARGO_PLANE], <<275, 275, 100>>)
|
|
AND planeInteriorStreamingStage = PLANE_INTERIOR_STREAMING_DONE
|
|
IF DO_PLANE_HEADINGS_MATCH(planeFightVehicle[PFV_TREVOR_PLANE], planeFightVehicle[PFV_CARGO_PLANE], 60.0)
|
|
IF CAN_ADVANCE_MISSION()
|
|
SET_MISSION_STAGE(STAGE_ENTER_PLANE, FALSE, FALSE)
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ELSE
|
|
IF IS_THIS_HELP_MESSAGE_BEING_DISPLAYED("PF_LOWHLP")
|
|
OR IS_THIS_HELP_MESSAGE_BEING_DISPLAYED("PF_DWNHLP")
|
|
OR IS_THIS_HELP_MESSAGE_BEING_DISPLAYED("PF_BASHLP")
|
|
OR IS_THIS_HELP_MESSAGE_BEING_DISPLAYED("PF_CRSHLP")
|
|
IF GET_GAME_TIMER() >= iClearHelpTime
|
|
CLEAR_HELP(FALSE)
|
|
iClearHelpTime = GET_GAME_TIMER() + 1000
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ELSE
|
|
//DO_OPEN_DOOR_CUTSCENE()
|
|
ENDIF
|
|
ENDPROC
|
|
|
|
PROC DO_CUTSCENE_WARP_ONTO_PLANE()
|
|
SET_ENTITY_COORDS(PLAYER_PED_ID(), GET_PLANE_OFFSET_IN_WORLD_COORDS(GET_PLANE_FIGHT_VECTOR(PFVEC_TREVOR_INSIDE_PLANE_INIT)), TRUE, TRUE)
|
|
SET_ENTITY_HEADING(PLAYER_PED_ID(), GET_ENTITY_HEADING(planeFightVehicle[PFV_CARGO_PLANE]) - 90)
|
|
EQUIP_BEST_PLAYER_WEAPON(TRUE)
|
|
PUT_TREVOR_INTO_COVER()
|
|
IF GET_FOLLOW_PED_CAM_VIEW_MODE() <> CAM_VIEW_MODE_FIRST_PERSON
|
|
OR GET_IS_USING_FPS_THIRD_PERSON_COVER()
|
|
SET_GAMEPLAY_CAM_RELATIVE_HEADING(90.0)
|
|
SET_GAMEPLAY_CAM_RELATIVE_PITCH(0.0)
|
|
ELSE
|
|
SET_GAMEPLAY_CAM_RELATIVE_HEADING(30.0)
|
|
SET_GAMEPLAY_CAM_RELATIVE_PITCH(8.4)
|
|
ENDIF
|
|
ENDPROC
|
|
|
|
PROC SETUP_INSIDE_PLANE_DURING_CUTSCENE()
|
|
IF IS_VEHICLE_DRIVEABLE(planeFightVehicle[PFV_CARGO_PLANE])
|
|
SET_VEHICLE_DOOR_BROKEN(planeFightVehicle[PFV_CARGO_PLANE], SC_DOOR_REAR_LEFT, TRUE)
|
|
ENDIF
|
|
|
|
//SET_LIGHT_RIG_ON_CARGO_PLANE(TRUE)
|
|
SET_CARGO_PLANE_FOR_INTERIOR_ACTION(STAGE_PLANE_FIGHT)
|
|
APPLY_PLANE_DAMAGE()
|
|
ATTACH_TRANSPORTED_VEHICLES(FALSE)
|
|
SETUP_SHOOTOUT()
|
|
|
|
INT i
|
|
REPEAT COUNT_OF(enemyData) i
|
|
IF NOT IS_PED_INJURED(enemyData[i].ped)
|
|
TASK_AIM_GUN_AT_COORD(enemyData[i].ped, <<2930.5, 810.5, 449.1>>, -1, TRUE)
|
|
ENDIF
|
|
ENDREPEAT
|
|
|
|
bSetupInsidePlaneDuringCutscene = TRUE
|
|
ENDPROC
|
|
|
|
// crash plane cutscene procedure
|
|
PROC DO_CRASH_IN_CUTSCENE()
|
|
UPDATE_TRANSPORTED_VEHICLES()
|
|
|
|
IF IS_VEHICLE_DRIVEABLE(planeFightVehicle[PFV_CARGO_PLANE])
|
|
SET_FORCE_HD_VEHICLE(planeFightVehicle[PFV_CARGO_PLANE], TRUE)
|
|
ENDIF
|
|
|
|
SWITCH cutsceneStage
|
|
CASE PF_CUT_STAGE_INIT
|
|
|
|
REGISTER_ENTITY_FOR_CUTSCENE(fakePlaneVehicle, "EXL_Plane", CU_CREATE_AND_ANIMATE_NEW_SCRIPT_ENTITY, GET_MODEL_FOR_PLANE_FIGHT_MODEL_ENUM(PFM_CARGO_PLANE))
|
|
|
|
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(transportedVehicle[TRANSPORTED_VEHICLE_INDEX_4WD_SLIDE_OUT].veh)
|
|
/// DETACH_ENTITY(transportedVehicle[TRANSPORTED_VEHICLE_INDEX_4WD_SLIDE_OUT].veh)
|
|
// REGISTER_ENTITY_FOR_CUTSCENE(transportedVehicle[TRANSPORTED_VEHICLE_INDEX_4WD_SLIDE_OUT].veh, "EXL_mesa3", CU_ANIMATE_EXISTING_SCRIPT_ENTITY)
|
|
// ENDIF
|
|
|
|
IF NOT IS_PED_INJURED(namedEnemyPed[ENEMY_RAMP_MACHINE_GUN])
|
|
DETACH_ENTITY(namedEnemyPed[ENEMY_RAMP_MACHINE_GUN])
|
|
REGISTER_ENTITY_FOR_CUTSCENE(namedEnemyPed[ENEMY_RAMP_MACHINE_GUN], "Ramp_Guard_L", CU_ANIMATE_EXISTING_SCRIPT_ENTITY)
|
|
ENDIF
|
|
|
|
IF NOT IS_PED_INJURED(namedEnemyPed[ENEMY_RAMP_RPG])
|
|
DETACH_ENTITY(namedEnemyPed[ENEMY_RAMP_RPG])
|
|
REGISTER_ENTITY_FOR_CUTSCENE(namedEnemyPed[ENEMY_RAMP_RPG], "Ramp_Guard_R", CU_ANIMATE_EXISTING_SCRIPT_ENTITY)
|
|
ENDIF
|
|
|
|
IF NOT IS_ENTITY_DEAD(planeFightVehicle[PFV_TREVOR_PLANE])
|
|
SET_ENTITY_PROOFS(planeFightVehicle[PFV_TREVOR_PLANE], TRUE, TRUE, TRUE, TRUE, TRUE)
|
|
SET_ENTITY_ONLY_DAMAGED_BY_PLAYER(planeFightVehicle[PFV_TREVOR_PLANE], TRUE)
|
|
ENDIF
|
|
|
|
// REGISTER_ENTITY_FOR_CUTSCENE(enemyData[0].ped, "Hold_Guard_Front", CU_CREATE_AND_ANIMATE_NEW_SCRIPT_ENTITY, GET_MODEL_FOR_PLANE_FIGHT_MODEL_ENUM(PFM_ENEMY))
|
|
// REGISTER_ENTITY_FOR_CUTSCENE(enemyData[1].ped, "Hold_Guard_Middle", CU_CREATE_AND_ANIMATE_NEW_SCRIPT_ENTITY, GET_MODEL_FOR_PLANE_FIGHT_MODEL_ENUM(PFM_ENEMY))
|
|
// REGISTER_ENTITY_FOR_CUTSCENE(enemyData[2].ped, "Hold_Guard_Rear", CU_CREATE_AND_ANIMATE_NEW_SCRIPT_ENTITY, GET_MODEL_FOR_PLANE_FIGHT_MODEL_ENUM(PFM_ENEMY))
|
|
|
|
REPLAY_START_EVENT(REPLAY_IMPORTANCE_HIGHEST)
|
|
|
|
CUTSCENE_OPTION_FLAGS flags
|
|
flags = CUTSCENE_NO_OPTIONS
|
|
IF GET_IS_USING_FPS_THIRD_PERSON_COVER()
|
|
AND GET_FOLLOW_PED_CAM_VIEW_MODE() = CAM_VIEW_MODE_FIRST_PERSON
|
|
flags = CUTSCENE_SUPPRESS_FP_TRANSITION_FLASH
|
|
ENDIF
|
|
|
|
//SET_CUTSCENE_TRIGGER_AREA(<<0,0,0>>, 0.0, 180, 180)
|
|
START_CUTSCENE(flags)//GET_ENTITY_COORDS(planeFightVehicle[PFV_CARGO_PLANE]))
|
|
//SET_CUTSCENE_ORIGIN(<<0,0,0>>, 180, -1)
|
|
SET_CUTSCENE_ORIGIN(<<2929, 844, 467>>, 180, -1)
|
|
//SET_CUTSCENE_ORIGIN(<<100, 100, 100>>, 180, -1)
|
|
SET_CUTSCENE_FADE_VALUES(FALSE, FALSE, FALSE, FALSE)
|
|
|
|
//SET_TIMECYCLE_MODIFIER_STRENGTH(1.0)
|
|
|
|
iPlaneFightCutsceneTime = GET_GAME_TIMER()
|
|
cutsceneStage = PF_CUT_STAGE_RUNNING
|
|
BREAK
|
|
|
|
CASE PF_CUT_STAGE_RUNNING
|
|
HANDLE_PLANE_FIGHT_WIND_STREAM(TRUE, TRUE)
|
|
|
|
IF NOT bClearedForCutscene
|
|
IF IS_CUTSCENE_PLAYING()
|
|
SET_MISSION_MOCAP_CUTSCENE()
|
|
|
|
KILL_CHASE_HINT_CAM(localChaseHintCamStruct)
|
|
|
|
|
|
|
|
IF IS_VEHICLE_DRIVEABLE(planeFightVehicle[PFV_CARGO_PLANE])
|
|
SET_VEHICLE_INTERIORLIGHT(planeFightVehicle[PFV_CARGO_PLANE], TRUE)
|
|
CLEAR_AREA(GET_ENTITY_COORDS(planeFightVehicle[PFV_CARGO_PLANE]), 1000, TRUE)
|
|
|
|
REMOVE_ENTITY_FROM_AUDIO_MIX_GROUP(planeFightVehicle[PFV_CARGO_PLANE])
|
|
STOP_PLANE_FIGHT_AUDIO_SCENE(PLANE_FIGHT_AUDIO_SCENE_ENEMY_OPENS_FIRE)
|
|
STOP_PLANE_FIGHT_AUDIO_SCENE(PLANE_FIGHT_AUDIO_SCENE_FLIGHT_START_CLIMB)
|
|
|
|
SET_ENTITY_VISIBLE(planeFightVehicle[PFV_CARGO_PLANE], FALSE)
|
|
ENDIF
|
|
|
|
INT i
|
|
REPEAT NUMBER_JETS i
|
|
IF DOES_ENTITY_EXIST(jetData[i].ped)
|
|
DELETE_PED(jetData[i].ped)
|
|
ENDIF
|
|
IF DOES_ENTITY_EXIST(jetData[i].veh)
|
|
DELETE_VEHICLE(jetData[i].veh)
|
|
ENDIF
|
|
ENDREPEAT
|
|
|
|
IF DOES_ENTITY_EXIST(planeFightVehicle[PFV_TREVOR_PLANE])
|
|
DELETE_VEHICLE(planeFightVehicle[PFV_TREVOR_PLANE])
|
|
ENDIF
|
|
|
|
IF bForcePassOnShitskip
|
|
wait(0)
|
|
DO_SCREEN_FADE_IN(DEFAULT_FADE_TIME)
|
|
bForcePassOnShitskip = FALSE
|
|
ELSE
|
|
IF IS_SCREEN_FADED_OUT()
|
|
DO_SCREEN_FADE_IN(DEFAULT_FADE_TIME)
|
|
ENDIF
|
|
ENDIF
|
|
|
|
bClearedForCutscene = TRUE
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF NOT IS_PED_INJURED(namedEnemyPed[ENEMY_RAMP_MACHINE_GUN])
|
|
SET_ENTITY_VISIBLE(namedEnemyPed[ENEMY_RAMP_MACHINE_GUN], TRUE)
|
|
ENDIF
|
|
|
|
IF NOT IS_PED_INJURED(namedEnemyPed[ENEMY_RAMP_RPG])
|
|
SET_ENTITY_VISIBLE(namedEnemyPed[ENEMY_RAMP_RPG], TRUE)
|
|
ENDIF
|
|
|
|
IF NOT bCreatedLightRig
|
|
IF GET_CUTSCENE_TIME() >= 1500
|
|
AND HAS_CUTSCENE_CUT_THIS_FRAME()
|
|
SET_TIMECYCLE_MODIFIER("exile1_plane")
|
|
SET_TIMECYCLE_MODIFIER_STRENGTH(1.0)
|
|
SET_FAKE_LIGHT_RIG_ON_CARGO_PLANE()
|
|
bCreatedLightRig = TRUE
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF NOT bDoneLandInPlaneCue
|
|
bDoneLandInPlaneCue = TRIGGER_MISSION_MUSIC_EVENT("EXL1_LAND_IN_CARGO_PLANE")
|
|
ENDIF
|
|
|
|
IF NOT DOES_ENTITY_EXIST(fakePlaneVehicle)
|
|
IF DOES_ENTITY_EXIST(GET_ENTITY_INDEX_OF_REGISTERED_ENTITY("EXL_Plane"))
|
|
PRINTSTRING("grabbed plane!") PRINTNL()
|
|
fakePlaneVehicle = GET_VEHICLE_INDEX_FROM_ENTITY_INDEX(GET_ENTITY_INDEX_OF_REGISTERED_ENTITY("EXL_Plane"))
|
|
|
|
DISABLE_VEHCILE_DYNAMIC_AMBIENT_SCALES(fakePlaneVehicle, 255, 0)
|
|
|
|
SET_ENTITY_PROOFS(fakePlaneVehicle, TRUE, TRUE, TRUE, TRUE, TRUE)
|
|
SET_VEHICLE_CAN_BREAK(fakePlaneVehicle, FALSE)
|
|
SET_VEHICLE_CAN_BE_VISIBLY_DAMAGED(fakePlaneVehicle, FALSE)
|
|
SET_VEHICLE_ENGINE_CAN_DEGRADE(fakePlaneVehicle, FALSE)
|
|
SET_ENTITY_SHOULD_FREEZE_WAITING_ON_COLLISION(fakePlaneVehicle, FALSE)
|
|
SET_VEHICLE_EXPLODES_ON_HIGH_EXPLOSION_DAMAGE(fakePlaneVehicle, FALSE)
|
|
SET_ENTITY_LOD_DIST(fakePlaneVehicle, 3000)
|
|
SET_VEHICLE_KEEP_ENGINE_ON_WHEN_ABANDONED(fakePlaneVehicle, TRUE)
|
|
SET_VEHICLE_ENGINE_ON(fakePlaneVehicle, TRUE, TRUE)
|
|
SET_PLANE_ENGINE_ON(TRUE)
|
|
SET_VEHICLE_INTERIORLIGHT(fakePlaneVehicle, TRUE)
|
|
SET_VEHICLE_DOOR_CONTROL(fakePlaneVehicle, SC_DOOR_REAR_LEFT, DT_DOOR_INTACT, 1)
|
|
INT i
|
|
FOR i=2 TO 8
|
|
SET_VEHICLE_EXTRA(fakePlaneVehicle, i, FALSE)
|
|
ENDFOR
|
|
SET_VEHICLE_EXTRA(fakePlaneVehicle, 7, TRUE)
|
|
CONTROL_LANDING_GEAR(fakePlaneVehicle, LGC_RETRACT_INSTANT)
|
|
|
|
CREATE_COVER_OBJECTS(TRUE, TRUE)
|
|
CREATE_TRANSPORTED_VEHICLES(TRUE, TRUE)
|
|
FORCE_ENTITY_AI_AND_ANIMATION_UPDATE(fakePlaneVehicle)
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF GET_CUTSCENE_TIME() >= 2287
|
|
IF NOT bSetupInsidePlaneDuringCutscene
|
|
SETUP_INSIDE_PLANE_DURING_CUTSCENE()
|
|
ELSE
|
|
IF NOT bPopulatedInteriorDuringCutscene
|
|
POPULATE_PLANE_INTERIOR(FALSE, TRUE, TRUE, TRUE, FALSE)
|
|
bPopulatedInteriorDuringCutscene = TRUE
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
|
|
|
|
/*
|
|
IF NOT DOES_ENTITY_EXIST(enemyData[0].ped)
|
|
IF DOES_ENTITY_EXIST(GET_ENTITY_INDEX_OF_REGISTERED_ENTITY("Hold_Guard_Front"))
|
|
enemyData[0].ped = GET_PED_INDEX_FROM_ENTITY_INDEX(GET_ENTITY_INDEX_OF_REGISTERED_ENTITY("Hold_Guard_Front"))
|
|
ENDIF
|
|
ENDIF
|
|
IF NOT DOES_ENTITY_EXIST(enemyData[1].ped)
|
|
IF DOES_ENTITY_EXIST(GET_ENTITY_INDEX_OF_REGISTERED_ENTITY("Hold_Guard_Middle"))
|
|
enemyData[1].ped = GET_PED_INDEX_FROM_ENTITY_INDEX(GET_ENTITY_INDEX_OF_REGISTERED_ENTITY("Hold_Guard_Middle"))
|
|
ENDIF
|
|
ENDIF
|
|
IF NOT DOES_ENTITY_EXIST(enemyData[2].ped)
|
|
IF DOES_ENTITY_EXIST(GET_ENTITY_INDEX_OF_REGISTERED_ENTITY("Hold_Guard_Rear"))
|
|
enemyData[2].ped = GET_PED_INDEX_FROM_ENTITY_INDEX(GET_ENTITY_INDEX_OF_REGISTERED_ENTITY("Hold_Guard_Rear"))
|
|
ENDIF
|
|
ENDIF
|
|
*/
|
|
|
|
IF CAN_SET_EXIT_STATE_FOR_REGISTERED_ENTITY("Ramp_Guard_L")
|
|
AND CAN_SET_EXIT_STATE_FOR_REGISTERED_ENTITY("Ramp_Guard_R")
|
|
INT i
|
|
FOR i=ENEMY_RAMP_MACHINE_GUN TO ENEMY_RAMP_RPG
|
|
IF DOES_ENTITY_EXIST(namedEnemyPed[i])
|
|
DELETE_PED(namedEnemyPed[i])
|
|
ENDIF
|
|
ENDFOR
|
|
ENDIF
|
|
|
|
IF CAN_SET_EXIT_STATE_FOR_REGISTERED_ENTITY("EXL_Plane")
|
|
//AND CAN_SET_EXIT_STATE_FOR_REGISTERED_ENTITY("EXL_mesa3")
|
|
INT i
|
|
REPEAT COUNT_OF(fakeTransportedVehicle) i
|
|
IF DOES_ENTITY_EXIST(fakeTransportedVehicle[i].veh)
|
|
DELETE_VEHICLE(fakeTransportedVehicle[i].veh)
|
|
fakeTransportedVehicle[i].bDetached = FALSE
|
|
ENDIF
|
|
ENDREPEAT
|
|
|
|
REPEAT COUNT_OF(fakeCoverObject) i
|
|
IF DOES_ENTITY_EXIST(fakeCoverObject[i].obj)
|
|
DELETE_OBJECT(fakeCoverObject[i].obj)
|
|
fakeCoverObject[i].bDetached = FALSE
|
|
ENDIF
|
|
ENDREPEAT
|
|
|
|
IF DOES_ENTITY_EXIST(fakElightRigObject)
|
|
DELETE_OBJECT(fakElightRigObject)
|
|
ENDIF
|
|
|
|
//IF DOES_ENTITY_EXIST(fakereflectRigObject)
|
|
// DELETE_OBJECT(fakereflectRigObject)
|
|
//ENDIF
|
|
|
|
IF DOES_ENTITY_EXIST(fakePlaneVehicle)
|
|
DELETE_VEHICLE(fakePlaneVehicle)
|
|
ENDIF
|
|
ENDIF
|
|
|
|
// CAN_SET_EXIT_STATE_FOR_REGISTERED_ENTITY("Trevor")
|
|
//ENDIF
|
|
|
|
/*
|
|
IF CAN_SET_EXIT_STATE_FOR_REGISTERED_ENTITY("Hold_Guard_Front")
|
|
IF DOES_ENTITY_EXIST(enemyData[0].ped)
|
|
DELETE_PED(enemyData[0].ped)
|
|
ENDIF
|
|
ENDIF
|
|
IF CAN_SET_EXIT_STATE_FOR_REGISTERED_ENTITY("Hold_Guard_Middle")
|
|
IF DOES_ENTITY_EXIST(enemyData[1].ped)
|
|
DELETE_PED(enemyData[1].ped)
|
|
ENDIF
|
|
ENDIF
|
|
IF CAN_SET_EXIT_STATE_FOR_REGISTERED_ENTITY("Hold_Guard_Rear")
|
|
IF DOES_ENTITY_EXIST(enemyData[2].ped)
|
|
DELETE_PED(enemyData[2].ped)
|
|
ENDIF
|
|
ENDIF
|
|
*/
|
|
|
|
IF WAS_CUTSCENE_SKIPPED()
|
|
bSkippedCutscene = TRUE
|
|
ENDIF
|
|
|
|
IF NOT bSkippedCutscene
|
|
IF NOT bMovedPlayer
|
|
IF CAN_SET_EXIT_STATE_FOR_REGISTERED_ENTITY("Trevor")
|
|
DO_CUTScENE_WARP_ONTO_PLANE()
|
|
PRINTSTRING("move player1") PRINTNL()
|
|
SET_DAMAGE_FX_ON_CARGO_PLANE(TRUE)
|
|
SET_PED_CAN_RAGDOLL(PLAYER_PED_ID(), TRUE)
|
|
FORCE_INSTANT_LEG_IK_SETUP(PLAYER_PED_ID())
|
|
bMovedPlayer = TRUE
|
|
ENDIF
|
|
ELSE
|
|
SET_LIGHT_RIG_ON_CARGO_PLANE(TRUE)
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF CAN_SET_EXIT_STATE_FOR_CAMERA()
|
|
IF NOT bSetupInsidePlaneDuringCutscene
|
|
SETUP_INSIDE_PLANE_DURING_CUTSCENE()
|
|
WAIT(500)
|
|
ENDIF
|
|
IF NOT bPopulatedInteriorDuringCutscene
|
|
POPULATE_PLANE_INTERIOR(FALSE, TRUE, TRUE, TRUE, FALSE)
|
|
WAIT(500)
|
|
ENDIF
|
|
|
|
IF bSkippedCutscene
|
|
IF NOT bMovedPlayer
|
|
WAIT(0)
|
|
PRINTSTRING("move player2") PRINTNL()
|
|
DO_CUTSCENE_WARP_ONTO_PLANE()
|
|
SET_LIGHT_RIG_ON_CARGO_PLANE(FALSE)
|
|
SET_LIGHT_RIG_ON_CARGO_PLANE(TRUE)
|
|
SET_DAMAGE_FX_ON_CARGO_PLANE(TRUE)
|
|
FORCE_INSTANT_LEG_IK_SETUP(PLAYER_PED_ID())
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF DOES_ENTITY_EXIST(planeFightVehicle[PFV_TREVOR_PLANE])
|
|
DELETE_VEHICLE(planeFightVehicle[PFV_TREVOR_PLANE])
|
|
ENDIF
|
|
|
|
REPLAY_STOP_EVENT()
|
|
|
|
REMOVE_PED_FOR_DIALOGUE(planeFightConversation, 6)
|
|
|
|
// back to gameplay
|
|
SET_MISSION_CUTSCENE(FALSE, TRUE, TRUE, FALSE)
|
|
|
|
CLEAR_TIMECYCLE_MODIFIER()
|
|
|
|
REPLAY_STOP_EVENT()
|
|
|
|
// advance mission
|
|
SET_MISSION_STAGE(STAGE_PLANE_FIGHT)
|
|
ENDIF
|
|
|
|
#IF IS_DEBUG_BUILD
|
|
DEBUG_SKIP_MOCAP()
|
|
#ENDIF
|
|
BREAK
|
|
|
|
CASE PF_CUT_STAGE_CLEANUP
|
|
|
|
BREAK
|
|
ENDSWITCH
|
|
ENDPROC
|
|
|
|
// enter plane
|
|
PROC DO_STAGE_ENTER_PLANE()
|
|
IF NOT bRunningCutscene
|
|
HANDLE_PLANE_FIGHT_WIND_STREAM(FALSE, FALSE)
|
|
|
|
IF NOT bForcePassOnShitskip
|
|
IF NOT IS_ENTITY_DEAD(planeFightVehicle[PFV_TREVOR_PLANE])
|
|
|
|
IF GET_VEHICLE_ENGINE_HEALTH(planeFightVehicle[PFV_TREVOR_PLANE]) <= 700
|
|
SET_AI_WEAPON_DAMAGE_MODIFIER(0.01)
|
|
|
|
IF NOT bDamagedPlaneToGlideDown
|
|
IF bTakePlaneDamage
|
|
SET_ENTITY_CAN_BE_DAMAGED_BY_RELATIONSHIP_GROUP(planeFightVehicle[PFV_TREVOR_PLANE], FALSE, enemyRelGroup)
|
|
bTakePlaneDamage = FALSE
|
|
ELSE
|
|
IF GET_VEHICLE_ENGINE_HEALTH(planeFightVehicle[PFV_TREVOR_PLANE]) > 300
|
|
AND GET_ENTITY_HEALTH(planeFightVehicle[PFV_TREVOR_PLANE]) > 300
|
|
SET_ENTITY_CAN_BE_DAMAGED_BY_RELATIONSHIP_GROUP(planeFightVehicle[PFV_TREVOR_PLANE], TRUE, enemyRelGroup)
|
|
bTakePlaneDamage = TRUE
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF HAS_ENTITY_BEEN_DAMAGED_BY_WEAPON(planeFightVehicle[PFV_TREVOR_PLANE], WEAPONTYPE_RPG)
|
|
EXPLODE_VEHICLE(planeFightVehicle[PFV_TREVOR_PLANE])
|
|
ENDIF
|
|
|
|
IF NOT bDamagedPlaneToGlideDown
|
|
IF fPlaybackTime >= 274000
|
|
IF missionFailState = MISSION_FAIL_STATE_NOT_FAILED
|
|
IF NOT bClearedForGlideDownChecks
|
|
SET_ENTITY_CAN_BE_DAMAGED_BY_RELATIONSHIP_GROUP(planeFightVehicle[PFV_TREVOR_PLANE], TRUE, enemyRelGroup)
|
|
IF NOT IS_PED_INJURED(namedEnemyPed[ENEMY_RAMP_MACHINE_GUN])
|
|
SET_PED_ACCURACY(namedEnemyPed[ENEMY_RAMP_MACHINE_GUN], 100)
|
|
ENDIF
|
|
CLEAR_ENTITY_LAST_WEAPON_DAMAGE(planeFightVehicle[PFV_TREVOR_PLANE])
|
|
bClearedForGlideDownChecks = TRUE
|
|
ENDIF
|
|
|
|
IF HAS_ENTITY_BEEN_DAMAGED_BY_WEAPON(planeFightVehicle[PFV_TREVOR_PLANE], GET_PLANE_FIGHT_WEAPON_TYPE(PF_WEAPON_MERC_LMG))
|
|
IF GET_VEHICLE_ENGINE_HEALTH(planeFightVehicle[PFV_TREVOR_PLANE]) > -400
|
|
SET_ENTITY_CAN_BE_DAMAGED_BY_RELATIONSHIP_GROUP(planeFightVehicle[PFV_TREVOR_PLANE], FALSE, enemyRelGroup)
|
|
SET_VEHICLE_ENGINE_HEALTH(planeFightVehicle[PFV_TREVOR_PLANE], -400)
|
|
SET_VEHICLE_ENGINE_ON(planeFightVehicle[PFV_TREVOR_PLANE], FALSE, FALSE)
|
|
iDamagedPlaneToGlideDownTime = GET_GAME_TIMER()
|
|
bDamagedPlaneToGlideDown = TRUE
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ELSE
|
|
IF NOT bShownGlideHelp
|
|
IF missionFailState = MISSION_FAIL_STATE_NOT_FAILED
|
|
IF GET_GAME_TIMER() >= iDamagedPlaneToGlideDownTime + 9500
|
|
bShownGlideHelp = DO_MISSION_HELP_TEXT("PF_GLDHLP")
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF IS_VEHICLE_DRIVEABLE(planeFightVehicle[PFV_CARGO_PLANE])
|
|
// door control
|
|
//SET_VEHICLE_DOOR_CONTROL(planeFightVehicle[PFV_CARGO_PLANE], SC_DOOR_REAR_LEFT, DT_DOOR_INTACT, 1.0)
|
|
IF IS_VEHICLE_DRIVEABLE(planeFightVehicle[PFV_CARGO_PLANE])
|
|
CONST_FLOAT DOOR_OPEN_PHASE 1.0
|
|
|
|
//printstring("FDOOROPEN") PRINTFLOAT(fDoorOpen) printnl()
|
|
|
|
|
|
|
|
IF fDoorOpen < 1
|
|
//printstring("here1") printnl()
|
|
fDoorOpen = GET_VEHICLE_DOOR_ANGLE_RATIO(planeFightVehicle[PFV_CARGO_PLANE], SC_DOOR_REAR_LEFT)
|
|
IF fDoorOpen < 0.92
|
|
printstring("door open time = ") printint(get_game_timer() - iDoorStartOpenTime) PRINTNL()
|
|
IF iDoorStartOpenTime < 0
|
|
OR GET_GAME_TIMER() < iDoorStartOpenTime + 2000
|
|
SET_VEHICLE_USES_LARGE_REAR_RAMP(planeFightVehicle[PFV_CARGO_PLANE], TRUE)
|
|
ELSE
|
|
SET_VEHICLE_USES_LARGE_REAR_RAMP(planeFightVehicle[PFV_CARGO_PLANE], FALSE)
|
|
ENDIF
|
|
SET_VEHICLE_INACTIVE_DURING_PLAYBACK(planeFightVehicle[PFV_CARGO_PLANE], FALSE)
|
|
ELSE
|
|
//printstring("here2") printnl()
|
|
REPLAY_RECORD_BACK_FOR_TIME(3.0)
|
|
SET_VEHICLE_USES_LARGE_REAR_RAMP(planeFightVehicle[PFV_CARGO_PLANE], FALSE)
|
|
SET_VEHICLE_INACTIVE_DURING_PLAYBACK(planeFightVehicle[PFV_CARGO_PLANE], TRUE)
|
|
fDoorOpen = 1
|
|
ENDIF
|
|
ELSE
|
|
//printstring("here3") printnl()
|
|
//printstring("door is open!") printnl()
|
|
SET_VEHICLE_USES_LARGE_REAR_RAMP(planeFightVehicle[PFV_CARGO_PLANE], FALSE)
|
|
SET_VEHICLE_INACTIVE_DURING_PLAYBACK(planeFightVehicle[PFV_CARGO_PLANE], TRUE)
|
|
ENDIF
|
|
|
|
SET_VEHICLE_DOOR_CONTROL(planeFightVehicle[PFV_CARGO_PLANE], SC_DOOR_REAR_LEFT, DT_DOOR_INTACT, 1)
|
|
|
|
IF iDoorStartOpenTime < 0
|
|
iDoorStartOpenTime = GET_GAME_TIMER()
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF IS_VEHICLE_DRIVEABLE(planeFightVehicle[PFV_TREVOR_PLANE])
|
|
AND IS_VEHICLE_DRIVEABLE(planeFightVehicle[PFV_CARGO_PLANE])
|
|
VECTOR vOffsetFromPlane = GET_OFFSET_FROM_ENTITY_GIVEN_WORLD_COORDS(planeFightVehicle[PFV_CARGO_PLANE], GET_ENTITY_COORDS(planeFightVehicle[PFV_TREVOR_PLANE]))
|
|
|
|
IF NOT bForcePassOnShitSkip
|
|
#IF IS_DEBUG_BUILD
|
|
AND NOT bDebugForceIntoHold
|
|
#ENDIF
|
|
IF NOT bForceIntoPlaneWhenCutsceneLoaded
|
|
HANDLE_STREAMING_MOCAP("EXL_1_MCS_1_P3_B", GET_ENTITY_COORDS(planeFightVehicle[PFV_CARGO_PLANE]), 400, 500)
|
|
ELSE
|
|
HANDLE_STREAMING_MOCAP("EXL_1_MCS_1_P3_B", GET_ENTITY_COORDS(planeFightVehicle[PFV_CARGO_PLANE]), 2000, 4000)
|
|
ENDIF
|
|
ELSE
|
|
HANDLE_STREAMING_MOCAP("EXL_1_MCS_1_P3_B", GET_ENTITY_COORDS(planeFightVehicle[PFV_CARGO_PLANE]), 2000, 4000)
|
|
ENDIF
|
|
|
|
IF NOT bForcePassOnShitskip
|
|
IF NOT bSetNoTurbulence
|
|
CONST_FLOAT ENTER_PLANE_TURBULENCE 0.06//0.12
|
|
IF fTurbulence >= ENTER_PLANE_TURBULENCE
|
|
fTurbulence = fTurbulence -@ 0.08
|
|
IF fTurbulence < ENTER_PLANE_TURBULENCE
|
|
fTurbulence = ENTER_PLANE_TURBULENCE
|
|
ENDIF
|
|
ENDIF
|
|
//printFLOAT(fTurbulence) PRINTNL()
|
|
SET_PLANE_TURBULENCE_MULTIPLIER(planeFightVehicle[PFV_TREVOR_PLANE], fTurbulence)
|
|
|
|
IF IS_ENTITY_AT_ENTITY(planeFightVehicle[PFV_TREVOR_PLANE], planeFightVehicle[PFV_CARGO_PLANE], <<250,250,250>>, FALSE, FALSE)
|
|
bSetNoTurbulence = TRUE
|
|
ENDIF
|
|
ELSE
|
|
SET_PLANE_TURBULENCE_MULTIPLIER(planeFightVehicle[PFV_TREVOR_PLANE], 0.0)
|
|
ENDIF
|
|
|
|
IF CAN_REQUEST_ASSETS_FOR_CUTSCENE_ENTITY()
|
|
IF NOT IS_PED_INJURED(namedEnemyPed[ENEMY_RAMP_MACHINE_GUN])
|
|
SET_CUTSCENE_PED_COMPONENT_VARIATION_FROM_PED("Ramp_Guard_L", namedEnemyPed[ENEMY_RAMP_MACHINE_GUN])
|
|
ENDIF
|
|
IF NOT IS_PED_INJURED(namedEnemyPed[ENEMY_RAMP_RPG])
|
|
SET_CUTSCENE_PED_COMPONENT_VARIATION_FROM_PED("Ramp_Guard_R", namedEnemyPed[ENEMY_RAMP_RPG])
|
|
ENDIF
|
|
|
|
// hold dudes - remember to change these vars if the ingame var does
|
|
MODEL_NAMES enemyModel = GET_MODEL_FOR_PLANE_FIGHT_MODEL_ENUM(PFM_ENEMY)
|
|
SET_CUTSCENE_PED_COMPONENT_VARIATION("Hold_Guard_Front", PED_COMP_HAIR, 1, 0, enemyModel)
|
|
SET_CUTSCENE_PED_COMPONENT_VARIATION("Hold_Guard_Front", PED_COMP_HEAD, 0, 0, enemyModel)
|
|
SET_CUTSCENE_PED_COMPONENT_VARIATION("Hold_Guard_Front", PED_COMP_TORSO, 1, 0, enemyModel)
|
|
SET_CUTSCENE_PED_COMPONENT_VARIATION("Hold_Guard_Front", PED_COMP_LEG, 0, 0, enemyModel)
|
|
SET_CUTSCENE_PED_COMPONENT_VARIATION("Hold_Guard_Front", PED_COMP_SPECIAL, 0, 2, enemyModel)
|
|
SET_CUTSCENE_PED_COMPONENT_VARIATION("Hold_Guard_Front", PED_COMP_SPECIAL2, 0, 0, enemyModel)
|
|
SET_CUTSCENE_PED_PROP_VARIATION("Hold_Guard_Front", ANCHOR_HEAD, 0, 1, enemyModel)
|
|
|
|
SET_CUTSCENE_PED_COMPONENT_VARIATION("Hold_Guard_Middle", PED_COMP_HAIR, 0, 0, enemyModel)
|
|
SET_CUTSCENE_PED_COMPONENT_VARIATION("Hold_Guard_Middle", PED_COMP_HEAD, 1, 0, enemyModel)
|
|
SET_CUTSCENE_PED_COMPONENT_VARIATION("Hold_Guard_Middle", PED_COMP_TORSO, 0, 5, enemyModel)
|
|
SET_CUTSCENE_PED_COMPONENT_VARIATION("Hold_Guard_Middle", PED_COMP_LEG, 0, 2, enemyModel)
|
|
SET_CUTSCENE_PED_COMPONENT_VARIATION("Hold_Guard_Middle", PED_COMP_SPECIAL, 0, 1, enemyModel)
|
|
SET_CUTSCENE_PED_COMPONENT_VARIATION("Hold_Guard_Middle", PED_COMP_SPECIAL2, 0, 0, enemyModel)
|
|
|
|
SET_CUTSCENE_PED_COMPONENT_VARIATION("Hold_Guard_Rear", PED_COMP_HAIR, 0, 0, enemyModel)
|
|
SET_CUTSCENE_PED_COMPONENT_VARIATION("Hold_Guard_Rear", PED_COMP_HEAD, 0, 2, enemyModel)
|
|
SET_CUTSCENE_PED_COMPONENT_VARIATION("Hold_Guard_Rear", PED_COMP_TORSO, 0, 1, enemyModel)
|
|
SET_CUTSCENE_PED_COMPONENT_VARIATION("Hold_Guard_Rear", PED_COMP_LEG, 0, 1, enemyModel)
|
|
SET_CUTSCENE_PED_COMPONENT_VARIATION("Hold_Guard_Rear", PED_COMP_SPECIAL, 1, 0, enemyModel)
|
|
SET_CUTSCENE_PED_COMPONENT_VARIATION("Hold_Guard_Rear", PED_COMP_SPECIAL2, 0, 0, enemyModel)
|
|
SET_CUTSCENE_PED_PROP_VARIATION("Hold_Guard_Rear", ANCHOR_HEAD, 1, 0, enemyModel)
|
|
SET_CUTSCENE_PED_PROP_VARIATION("Hold_Guard_Rear", ANCHOR_EYES, 0, 0, enemyModel)
|
|
ENDIF
|
|
|
|
IF NOT bPreparedLandInPlaneCue
|
|
IF GET_GAME_TIMER() >= iOpenDoorTime + 10000
|
|
bPreparedLandInPlaneCue = PREPARE_MUSIC_EVENT("EXL1_LAND_IN_CARGO_PLANE")
|
|
ENDIF
|
|
ENDIF
|
|
|
|
DO_COMMON_FLY_FUNCTIONS()
|
|
|
|
UPDATE_CHASE_BLIP(getToBlip, planeFightVehicle[PFV_CARGO_PLANE], 3000, 0.90)
|
|
IF fPlaneDistance >= 3100
|
|
IF NOT bForceIntoPlaneWhenCutsceneLoaded
|
|
MISSION_FAILED(FAIL_LOST_CARGO_PLANE)
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF NOT bStoppedPlayback
|
|
IF GET_GAME_TIMER() >= iOpenDoorTime + 500
|
|
IF IS_PLAYBACK_GOING_ON_FOR_VEHICLE(planeFightVehicle[PFV_TREVOR_PLANE])
|
|
STOP_PLAYBACK_RECORDED_VEHICLE(planeFightVehicle[PFV_TREVOR_PLANE])
|
|
ENDIF
|
|
bStoppedPlayback = TRUE
|
|
ENDIF
|
|
ENDIF
|
|
|
|
// speech
|
|
IF IS_PED_SITTING_IN_VEHICLE(PLAYER_PED_ID(), planeFightVehicle[PFV_TREVOR_PLANE])
|
|
IF NOT bDoneTannoyAnnouncement
|
|
IF DO_MISSION_SPEECH("EXL1_WARN4")
|
|
bDoneTannoyAnnouncement = TRUE
|
|
STOP_PLANE_FIGHT_AUDIO_SCENE(PLANE_FIGHT_AUDIO_SCENE_FLIGHT_START_CLIMB)
|
|
START_PLANE_FIGHT_AUDIO_SCENE(PLANE_FIGHT_AUDIO_SCENE_ENEMY_OPENS_FIRE)
|
|
ENDIF
|
|
ELSE
|
|
IF NOT bDoneCloseToCitySpeech
|
|
IF fPlaybackTime >= 253000
|
|
bDoneCloseToCitySpeech = DO_MISSION_SPEECH("EXL1_NEARLS")
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF NOT bShownCrashHelp
|
|
IF GET_GAME_TIMER() >= iOpenDoorTime + 4000
|
|
bShownCrashHelp = DO_MISSION_HELP_TEXT("PF_CRSHLP")
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
|
|
|
|
|
|
IF NOT bEnemiesAttachedToRamp
|
|
BOOL bDoAttach
|
|
|
|
IF IS_SYNCHRONIZED_SCENE_RUNNING(iSyncScene)
|
|
IF GET_SYNCHRONIZED_SCENE_PHASE(iSyncScene) >= 0.98
|
|
bDoAttach = TRUE
|
|
ENDIF
|
|
ELSE
|
|
bDoAttach = TRUE
|
|
ENDIF
|
|
|
|
IF bDoAttach
|
|
ATTACH_RAMP_PEDS()
|
|
bEnemiesAttachedToRamp = TRUE
|
|
//ELSE
|
|
//PRINTSTRING("RPG OFFSET = ") PRINTVECTOR(GET_OFFSET_FROM_ENTITY_GIVEN_WORLD_COORDS(planeFightVehicle[PFV_CARGO_PLANE], GET_ENTITY_COORDS(namedEnemyPed[ENEMY_RAMP_RPG]))) PRINTNL()
|
|
//PRINTSTRING("MG OFFSET = ") PRINTVECTOR(GET_OFFSET_FROM_ENTITY_GIVEN_WORLD_COORDS(planeFightVehicle[PFV_CARGO_PLANE], GET_ENTITY_COORDS(namedEnemyPed[ENEMY_RAMP_MACHINE_GUN]))) PRINTNL()
|
|
ENDIF
|
|
ELSE
|
|
BOOL bInEnemyShootRange = IS_ENTITY_AT_COORD(PLAYER_PED_ID(), GET_OFFSET_FROM_ENTITY_IN_WORLD_COORDS(planeFightVehicle[PFV_CARGO_PLANE], <<0,-133,0>>), <<90,90,60>>) //<<0,-103,-34>>), <<38,38,38>>
|
|
|
|
IF bDoneTannoyAnnouncement
|
|
IF bShownGodText
|
|
IF IS_PED_SITTING_IN_VEHICLE(PLAYER_PED_ID(), planeFightVehicle[PFV_TREVOR_PLANE])
|
|
IF NOT bDoneTrevorReactToShootSpeech
|
|
BOOL bIsShooting = FALSE
|
|
IF NOT IS_PED_INJURED(namedEnemyPed[ENEMY_RAMP_MACHINE_GUN])
|
|
IF IS_PED_SHOOTING(namedEnemyPed[ENEMY_RAMP_MACHINE_GUN])
|
|
bIsShooting = TRUE
|
|
ENDIF
|
|
ENDIF
|
|
IF NOT IS_PED_INJURED(namedEnemyPed[ENEMY_RAMP_RPG])
|
|
IF IS_PED_SHOOTING(namedEnemyPed[ENEMY_RAMP_RPG])
|
|
bIsShooting = TRUE
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF bIsShooting
|
|
IF iEnemyShootingTime < 0
|
|
iEnemyShootingTime = GET_GAME_TIMER()
|
|
ELSE
|
|
IF GET_GAME_TIMER() >= iEnemyShootingTime + 800
|
|
bDoneTrevorReactToShootSpeech = DO_MISSION_SPEECH("EXL1_SHOOTD")
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ELSE
|
|
IF NOT bDoneCrashSpeech
|
|
IF GET_DISTANCE_BETWEEN_ENTITIES(PLAYER_PED_ID(), planeFightVehicle[PFV_CARGO_PLANE]) < 80
|
|
AND DO_PLANE_HEADINGS_MATCH(planeFightVehicle[PFV_TREVOR_PLANE], planeFightVehicle[PFV_CARGO_PLANE], 30.0)
|
|
bDoneCrashSpeech = DO_MISSION_SPEECH("EXL1_RAM")
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
|
|
// machine gun shooting
|
|
IF NOT IS_PED_INJURED(namedEnemyPed[ENEMY_RAMP_MACHINE_GUN])
|
|
IF bMachineGunEnemyShooting
|
|
IF NOT bInEnemyShootRange
|
|
TASK_AIM_GUN_AT_ENTITY(namedEnemyPed[ENEMY_RAMP_MACHINE_GUN], planeFightVehicle[PFV_TREVOR_PLANE], -1)
|
|
//CLEAR_PED_TASKS(namedEnemyPed[ENEMY_RAMP_MACHINE_GUN])
|
|
bMachineGunEnemyShooting = FALSE
|
|
ENDIF
|
|
ELSE
|
|
IF bInEnemyShootRange
|
|
SET_PED_SHOOT_RATE(namedEnemyPed[ENEMY_RAMP_MACHINE_GUN], 100)
|
|
TASK_SHOOT_AT_ENTITY(namedEnemyPed[ENEMY_RAMP_MACHINE_GUN], planeFightVehicle[PFV_TREVOR_PLANE], 99999999, FIRING_TYPE_CONTINUOUS)
|
|
bMachineGunEnemyShooting = TRUE
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
|
|
// rpg shooting
|
|
IF NOT IS_PED_INJURED(namedEnemyPed[ENEMY_RAMP_RPG])
|
|
|
|
IF iRPGShot < 3
|
|
IF bInEnemyShootRange
|
|
AND NOT IS_ENTITY_AT_ENTITY(planeFightVehicle[PFV_TREVOR_PLANE], namedEnemyPed[ENEMY_RAMP_RPG], <<30,30,30>>, FALSE, FALSE)
|
|
AND GET_GAME_TIMER() >= iRPGTime + 5000
|
|
VECTOR vOffset
|
|
VECTOR vOffsetDiff = vOffsetFromPlane - vCachedOffsetFromPlane
|
|
//PRINTSTRING("diff = ") PRINTVECTOR(vOffsetDiff) PRINTNL()
|
|
|
|
IF vOffsetDiff.x >= 0
|
|
vOffset.x = 38
|
|
ELSE
|
|
vOffset.x = -38
|
|
ENDIF
|
|
|
|
IF vOffsetDiff.z >= 0
|
|
vOffset.z = -30
|
|
ELSE
|
|
vOffset.z = 30
|
|
ENDIF
|
|
|
|
//PRINTSTRING("shot offset = ") PRINTVECTOR(vOffset) PRINTNL()
|
|
|
|
/*
|
|
SWITCH iRPGShot
|
|
CASE 0
|
|
vOffset = <<-14, 0, 15>>
|
|
BREAK
|
|
CASE 1
|
|
vOffset = <<20, 0, 16>>
|
|
BREAK
|
|
CASE 2
|
|
vOffset = <<-14, 0, 15>>
|
|
BREAK
|
|
ENDSWITCH
|
|
*/
|
|
|
|
CLEAR_SEQUENCE_TASK(sequence)
|
|
OPEN_SEQUENCE_TASK(sequence)
|
|
TASK_SHOOT_AT_COORD(NULL, GET_ENTITY_COORDS(planeFightVehicle[PFV_TREVOR_PLANE]) + vOffset, 2000, FIRING_TYPE_CONTINUOUS)
|
|
TASK_AIM_GUN_AT_ENTITY(NULL, planeFightVehicle[PFV_TREVOR_PLANE], -1)
|
|
CLOSE_SEQUENCE_TASK(sequence)
|
|
TASK_PERFORM_SEQUENCE(namedEnemyPed[ENEMY_RAMP_RPG], sequence)
|
|
|
|
// temp? make plane invincible
|
|
// IF IS_VEHICLE_DRIVEABLE(planeFightVehicle[PFV_TREVOR_PLANE])
|
|
// SET_ENTITY_ONLY_DAMAGED_BY_PLAYER(planeFightVehicle[PFV_TREVOR_PLANE], TRUE)
|
|
// ENDIF
|
|
iRPGTime = GET_GAME_TIMER()
|
|
iRPGShot++
|
|
ENDIF
|
|
ENDIF
|
|
|
|
/*
|
|
IF NOT bRestoredPlaneProofs
|
|
IF iRPGShot >= 1
|
|
IF GET_GAME_TIMER() >= iRPGTime + 5000
|
|
IF IS_VEHICLE_DRIVEABLE(planeFightVehicle[PFV_TREVOR_PLANE])
|
|
SET_ENTITY_ONLY_DAMAGED_BY_PLAYER(planeFightVehicle[PFV_TREVOR_PLANE], FALSE)
|
|
ENDIF
|
|
bRestoredPlaneProofs = TRUE
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
*/
|
|
ENDIF
|
|
|
|
ENDIF
|
|
ENDIF
|
|
|
|
// in vicinity?
|
|
IF IS_ENTITY_AT_COORD(PLAYER_PED_ID(), GET_OFFSET_FROM_ENTITY_IN_WORLD_COORDS(planeFightVehicle[PFV_CARGO_PLANE], <<0,-47.0,-3>>) , <<12.0, 12.0, 12.0>>)
|
|
OR bForcePassOnShitskip
|
|
OR bForceIntoPlaneWhenCutsceneLoaded
|
|
IF NOT bForcePassOnShitskip
|
|
// IF NOT bDoneEnemyPlaneReactSpeech
|
|
// bDoneEnemyPlaneReactSpeech = DO_MISSION_SPEECH("EXL1_MERC1")
|
|
// ENDIF
|
|
bBeenInEnterVicinity = TRUE
|
|
ENDIF
|
|
|
|
// next stage
|
|
VECTOR vPlaneRot = GET_ENTITY_ROTATION(planeFightVehicle[PFV_TREVOR_PLANE])
|
|
PRINTVECTOR(vPlaneRot) PRINTNL()
|
|
//IF IS_ENTITY_AT_COORD(PLAYER_PED_ID(), GET_OFFSET_FROM_ENTITY_IN_WORLD_COORDS(planeFightVehicle[PFV_CARGO_PLANE], <<0,-40.0,-3>>) , <<4.0, 4.0, 4.0>>)
|
|
IF IS_ENTITY_AT_COORD(PLAYER_PED_ID(), GET_OFFSET_FROM_ENTITY_IN_WORLD_COORDS(planeFightVehicle[PFV_CARGO_PLANE], <<0,-42.0,-3>>) , <<5.0, 5.0, 5.0>>)
|
|
OR bForcePassOnShitskip
|
|
OR bForceIntoPlaneWhenCutsceneLoaded
|
|
IF IS_PED_SITTING_IN_VEHICLE(PLAYER_PED_ID(), planeFightVehicle[PFV_TREVOR_PLANE])
|
|
OR bForcePassOnShitskip
|
|
OR bForceIntoPlaneWhenCutsceneLoaded
|
|
IF (DO_PLANE_HEADINGS_MATCH(planeFightVehicle[PFV_TREVOR_PLANE], planeFightVehicle[PFV_CARGO_PLANE], 30.0)
|
|
AND (vPlaneRot.y <= 70.0 AND vPlaneRot.y >= -70.0))
|
|
OR bForcePassOnShitskip
|
|
OR bForceIntoPlaneWhenCutsceneLoaded
|
|
IF CAN_ADVANCE_MISSION()
|
|
IF HAS_CUTSCENE_LOADED_WITH_FAILSAFE()
|
|
bRunningCutscene = TRUE
|
|
ELSE
|
|
SET_PLAYER_CONTROL(PLAYER_ID(), FALSE)
|
|
SET_ENTITY_PROOFS(planeFightVehicle[PFV_TREVOR_PLANE], TRUE, TRUE, TRUE, TRUE, TRUE)
|
|
SET_ENTITY_INVINCIBLE(planeFightVehicle[PFV_TREVOR_PLANE], TRUE)
|
|
SET_VEHICLE_CAN_BREAK(planeFightVehicle[PFV_TREVOR_PLANE], FALSE)
|
|
SET_VEHICLE_CAN_BE_VISIBLY_DAMAGED(planeFightVehicle[PFV_TREVOR_PLANE], FALSE)
|
|
bForceIntoPlaneWhenCutsceneLoaded = TRUE
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ELSE
|
|
IF NOT bForcePassOnShitskip
|
|
IF IS_PED_SITTING_IN_VEHICLE(PLAYER_PED_ID(), planeFightVehicle[PFV_TREVOR_PLANE])
|
|
IF NOT bDoneTryAgainSpeech
|
|
IF bBeenInEnterVicinity
|
|
bDoneTryAgainSpeech = DO_MISSION_SPEECH("EXL1_AGAIN")
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF NOT bDoneCollisionSpeech
|
|
IF IS_ENTITY_TOUCHING_ENTITY(planeFightVehicle[PFV_TREVOR_PLANE], planeFightVehicle[PFV_CARGO_PLANE])
|
|
bDoneCollisionSpeech = DO_MISSION_SPEECH("EXL1_CRASH")
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
|
|
vCachedOffsetFromPlane = vOffsetFromPlane
|
|
|
|
#IF IS_DEBUG_BUILD
|
|
IF bDebugForceIntoHold
|
|
AND HAS_CUTSCENE_LOADED()
|
|
bRunningCutscene = TRUE
|
|
ENDIF
|
|
#ENDIF
|
|
ENDIF
|
|
|
|
IF NOT bRunningCutscene
|
|
IF bForceIntoPlaneWhenCutsceneLoaded
|
|
IF IS_SCREEN_FADED_OUT()
|
|
FREEZE_ENTITY_POSITION(planeFightVehicle[PFV_TREVOR_PLANE], TRUE)
|
|
SET_PLAYER_CONTROL(PLAYER_ID(), FALSE)
|
|
|
|
IF iForceSkipToNextStageTime < 0
|
|
iForceSkipToNextStageTime = GET_GAME_TIMER()
|
|
ELSE
|
|
IF GET_GAME_TIMER() >= iForceSkipToNextStageTime + 30000
|
|
TRIGGER_MUSIC_EVENT("EXL1_MISSION_FAILED")
|
|
COMMON_MISSION_CLEAR()
|
|
|
|
SET_MISSION_STAGE(STAGE_PLANE_FIGHT, TRUE, TRUE, TRUE, FALSE, TRUE, TRUE, TRUE, TRUE, TRUE, FALSE)
|
|
REMOVE_CUTSCENE()
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ELSE
|
|
DO_CRASH_IN_CUTSCENE()
|
|
ENDIF
|
|
ENDPROC
|
|
|
|
PROC INTERP_FLOAT_TO_FLOAT_OVER_TIME(FLOAT f1, FLOAT f2, FLOAT &fChangeVar, FLOAT fTime)
|
|
FLOAT fTimeSinceLastFrame = GET_FRAME_TIME()
|
|
|
|
FLOAT fDiff = f2 - f1
|
|
FLOAT fTimePerMS = (fDiff / fTime)
|
|
fChangeVar += (fTimePerMS * fTimeSinceLastFrame)
|
|
ENDPROC
|
|
|
|
PROC INTERP_VECTOR_TO_VECTOR_OVER_TIME(VECTOR v1, VECTOR v2, VECTOR &vChangeVar, FLOAT fTime)
|
|
INTERP_FLOAT_TO_FLOAT_OVER_TIME(v1.x, v2.x, vChangeVar.x, fTime)
|
|
INTERP_FLOAT_TO_FLOAT_OVER_TIME(v1.y, v2.y, vChangeVar.y, fTime)
|
|
INTERP_FLOAT_TO_FLOAT_OVER_TIME(v1.z, v2.z, vChangeVar.z, fTime)
|
|
ENDPROC
|
|
|
|
// jack attempt cutscene procedure
|
|
PROC DO_JACK_ATTEMPT_CUTSCENE()
|
|
INT i
|
|
|
|
//HANDLE_KLAXON_SOUND(TRUE)
|
|
|
|
SWITCH cutsceneStage
|
|
CASE PF_CUT_STAGE_INIT
|
|
SET_MISSION_CUTSCENE(TRUE)
|
|
CASCADE_SHADOWS_ENABLE_ENTITY_TRACKER(FALSE)
|
|
|
|
DELETE_ALL_TRANSPORTED_VEHICLES()
|
|
DELETE_ALL_COVER_OBJECTS(FALSE)
|
|
|
|
ATTACH_TRANSPORTED_VEHICLES(FALSE)
|
|
|
|
STOP_SMOKE_ON_PLANE(PLANE_SMOKE_CLOUDS)
|
|
SET_DAMAGE_FX_ON_CARGO_PLANE(FALSE)
|
|
|
|
CLEAR_AREA_OF_PROJECTILES(GET_ENTITY_COORDS(PLAYER_PED_ID()), 10)
|
|
|
|
REPEAT COUNT_OF(enemyData) i
|
|
IF DOES_ENTITY_EXIST(enemyData[i].ped)
|
|
DELETE_PED(enemyData[i].ped)
|
|
ENDIF
|
|
ENDREPEAT
|
|
REPEAT COUNT_OF(namedEnemyPed) i
|
|
IF DOES_ENTITY_EXIST(namedEnemyPed[i])
|
|
DELETE_PED(namedEnemyPed[i])
|
|
ENDIF
|
|
ENDREPEAT
|
|
|
|
IF IS_PLAYBACK_GOING_ON_FOR_VEHICLE(planeFightVehicle[PFV_CARGO_PLANE])
|
|
STOP_PLAYBACK_RECORDED_VEHICLE(planeFightVehicle[PFV_CARGO_PLANE])
|
|
ENDIF
|
|
|
|
STOP_PLANE_FIGHT_AUDIO_SCENE(PLANE_FIGHT_AUDIO_SCENE_SHOOTOUT_CARGO_HOLD)
|
|
START_PLANE_FIGHT_AUDIO_SCENE(PLANE_FIGHT_AUDIO_SCENE_HIJACK_THE_PLANE)
|
|
|
|
iSyncScene = CREATE_SYNCHRONIZED_SCENE(<<0,0,0>>, <<0,0,0>>)
|
|
IF IS_VEHICLE_DRIVEABLE(planeFightVehicle[PFV_CARGO_PLANE])
|
|
ATTACH_SYNCHRONIZED_SCENE_TO_ENTITY(iSyncScene, planeFightVehicle[PFV_CARGO_PLANE], GET_ENTITY_BONE_INDEX_BY_NAME(planeFightVehicle[PFV_CARGO_PLANE], "seat_dside_f"))
|
|
ENDIF
|
|
CLEAR_PED_TASKS_IMMEDIATELY(PLAYER_PED_ID())
|
|
TASK_SYNCHRONIZED_SCENE(PLAYER_PED_ID(), iSyncScene, GET_PLANE_FIGHT_ANIM_DICT_AS_STRING(PF_ANIM_DICT_MISSION), "Sit_Pilot_Seat", INSTANT_BLEND_IN, NORMAL_BLEND_OUT, SYNCED_SCENE_TAG_SYNC_OUT, RBF_NONE, INSTANT_BLEND_IN, AIK_DISABLE_ARM_IK)
|
|
SET_SYNCHRONIZED_SCENE_PHASE(iSyncScene, 0.04)
|
|
FORCE_PED_AI_AND_ANIMATION_UPDATE(PLAYER_PED_ID())
|
|
|
|
SET_CURRENT_PED_WEAPON(PLAYER_PED_ID(), WEAPONTYPE_UNARMED, TRUE)
|
|
|
|
STOP_SMOKE_ON_PLANE(PLANE_SMOKE_CRASH_SMOKE_R1, TRUE)
|
|
DO_SMOKE_ON_PLANE(PLANE_SMOKE_CRASH_SMOKE_FLIGHT)
|
|
|
|
VECTOR vCargoPlaneFly
|
|
vCargoPlaneFly = GET_PLANE_FIGHT_VECTOR(PFVEC_CARGO_PLANE_FLY)
|
|
IF IS_VEHICLE_DRIVEABLE(planeFightVehicle[PFV_CARGO_PLANE])
|
|
SET_LIGHT_RIG_ON_CARGO_PLANE(FALSE)
|
|
SET_ENTITY_COORDS(planeFightVehicle[PFV_CARGO_PLANE], <<1592.9, -3738.5, vCargoPlaneFly.z>>)
|
|
SET_ENTITY_HEADING(planeFightVehicle[PFV_CARGO_PLANE], CARGO_PLANE_FLY_ROT)
|
|
ENDIF
|
|
|
|
CREATE_CAM_ATTACHED_TO_CARGO_PLANE(PF_SHOT_ENTER_SEAT)
|
|
bDoneFlash = FALSE
|
|
iPlaneFightCutsceneTime = GET_GAME_TIMER()
|
|
cutsceneStage = PF_CUT_STAGE_RUNNING
|
|
BREAK
|
|
|
|
CASE PF_CUT_STAGE_RUNNING
|
|
IF IS_VEHICLE_DRIVEABLE(planeFightVehicle[PFV_CARGO_PLANE])
|
|
SET_ENTITY_ROTATION(planeFightVehicle[PFV_CARGO_PLANE], <<0,0,CARGO_PLANE_FLY_ROT>>)
|
|
SET_VEHICLE_FORWARD_SPEED(planeFightVehicle[PFV_CARGO_PLANE], 40.0)
|
|
ENDIF
|
|
|
|
INTERP_VECTOR_TO_VECTOR_OVER_TIME(<<0.9, 29.0, 2.1>>, <<0.75, 29.0, 2.1>>, vAttachCamPos, 3)
|
|
INTERP_VECTOR_TO_VECTOR_OVER_TIME(<<-3.2, 27.6, 2.45>>, <<-3.2, 27.9, 1.82>>, vAttachCamRot, 3)
|
|
|
|
ATTACH_CAM_TO_ENTITY(staticCam, planeFightVehicle[PFV_CARGO_PLANE], vAttachCamPos)
|
|
POINT_CAM_AT_ENTITY(staticCam, planeFightVehicle[PFV_CARGO_PLANE], vAttachCamRot)
|
|
|
|
//#IF IS_DEBUG_BUILD
|
|
// ATTACH_CAM_TO_ENTITY(staticCam, planeFightVehicle[PFV_CARGO_PLANE], vDebugAttachCamOffset)
|
|
// POINT_CAM_AT_ENTITY(staticCam, planeFightVehicle[PFV_CARGO_PLANE], vDebugAttachCamPoint)
|
|
// SET_CAM_FOV(staticCam, fDebugAttachCamFOV)
|
|
//#ENDIF
|
|
|
|
IF NOT bDoneFlash
|
|
IF GET_CAM_VIEW_MODE_FOR_CONTEXT(CAM_VIEW_MODE_CONTEXT_IN_AIRCRAFT) = CAM_VIEW_MODE_FIRST_PERSON
|
|
IF GET_GAME_TIMER() >= iPlaneFightCutsceneTime + 2700
|
|
ANIMPOSTFX_PLAY("CamPushInNeutral", 0, FALSE)
|
|
PLAY_SOUND_FRONTEND(-1, "1st_Person_Transition", "PLAYER_SWITCH_CUSTOM_SOUNDSET")
|
|
bDoneFlash = TRUE
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF GET_GAME_TIMER() >= iPlaneFightCutsceneTime + 3000
|
|
cutsceneStage = PF_CUT_STAGE_CLEANUP
|
|
ENDIF
|
|
BREAK
|
|
|
|
CASE PF_CUT_STAGE_CLEANUP
|
|
CASCADE_SHADOWS_INIT_SESSION()
|
|
SET_MISSION_CUTSCENE(FALSE)
|
|
SET_MISSION_STAGE(STAGE_FLY_PLANE)
|
|
BREAK
|
|
ENDSWITCH
|
|
ENDPROC
|
|
|
|
FUNC INT GET_CLOSEST_MERRYWEATHER_PED()
|
|
INT i
|
|
INT iClosest = -1
|
|
FLOAT fClosestDistance = 9999999
|
|
|
|
REPEAT NUMBER_ENEMY_PEDS i
|
|
IF i <> 1
|
|
AND i <> iMerryweatherSpeaker1
|
|
AND i <> iMerryweatherSpeaker2
|
|
IF NOT IS_PED_INJURED(enemyData[i].ped)
|
|
FLOAT fThisDistance = GET_DISTANCE_BETWEEN_COORDS(GET_ENTITY_COORDS(PLAYER_PED_ID()), GET_ENTITY_COORDS(enemyData[i].ped), FALSE)
|
|
IF fThisDistance < fClosestDistance
|
|
fClosestDistance = fThisDistance
|
|
iClosest = i
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDREPEAT
|
|
|
|
RETURN iClosest
|
|
ENDFUNC
|
|
|
|
// fight enemies on the plane as it flips over
|
|
PROC DO_STAGE_PLANE_FIGHT()
|
|
DISABLE_GAMEPLAY_CAM_ALTITUDE_FOV_SCALING_THIS_UPDATE()
|
|
REPLAY_DISABLE_CAMERA_MOVEMENT_THIS_FRAME()
|
|
|
|
IF IS_VEHICLE_DRIVEABLE(planeFightVehicle[PFV_CARGO_PLANE])
|
|
SET_FORCE_HD_VEHICLE(planeFightVehicle[PFV_CARGO_PLANE], TRUE)
|
|
ENDIF
|
|
|
|
IF IS_PED_JUMPING(PLAYER_PED_ID())
|
|
DISABLE_CONTROL_ACTION(PLAYER_CONTROL, INPUT_MELEE_ATTACK_LIGHT)
|
|
DISABLE_CONTROL_ACTION(PLAYER_CONTROL, INPUT_MELEE_ATTACK_HEAVY)
|
|
DISABLE_CONTROL_ACTION(PLAYER_CONTROL, INPUT_MELEE_ATTACK_ALTERNATE)
|
|
DISABLE_CONTROL_ACTION(PLAYER_CONTROL, INPUT_MELEE_BLOCK)
|
|
DISABLE_CONTROL_ACTION(PLAYER_CONTROL, INPUT_ATTACK)
|
|
DISABLE_CONTROL_ACTION(PLAYER_CONTROL, INPUT_ATTACK2)
|
|
ENDIF
|
|
|
|
IF NOT bRunningCutscene
|
|
|
|
HANDLE_PLANE_FIGHT_WIND_STREAM(TRUE, FALSE)
|
|
|
|
DO_COMMON_PLANE_FUNCTIONS()
|
|
IF NOT bDoneGotoCockpitPrompt
|
|
IF bShownGodText
|
|
IF GET_RANDOM_INT_IN_RANGE(0,2) = 0
|
|
//DO_RANDOM_SPEECH("EXL1_MERCR")
|
|
DO_RANDOM_SPEECH("EXL1_UPPLAN")
|
|
ELSE
|
|
DO_RANDOM_SPEECH("EXL1_TBANT")
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF NOT bDoneClouds
|
|
DO_SMOKE_ON_PLANE(PLANE_SMOKE_CLOUDS)
|
|
bDoneClouds = TRUE
|
|
ENDIF
|
|
|
|
IF GET_GAME_TIMER() >= iStartFightTime + 100
|
|
IF NOT bSetTransportedVehiclesPhysical
|
|
//ATTACH_TRANSPORTED_VEHICLES(TRUE)
|
|
bSetTransportedVehiclesPhysical = TRUE
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF NOT bRestoredControl
|
|
IF GET_GAME_TIMER() >= iStartFightTime + 500
|
|
//SET_PED_CAN_RAGDOLL(PLAYER_PED_ID(), TRUE)
|
|
SET_PLAYER_CONTROL(PLAYER_ID(), TRUE)
|
|
|
|
INT i
|
|
REPEAT COUNT_OF(enemyData) i
|
|
IF NOT IS_PED_INJURED(enemyData[i].ped)
|
|
SET_PED_CAN_RAGDOLL(enemyData[i].ped, TRUE)
|
|
FREEZE_ENTITY_POSITION(enemyData[i].ped, FALSE)
|
|
ENDIF
|
|
ENDREPEAT
|
|
|
|
bRestoredControl = TRUE
|
|
ENDIF
|
|
ENDIF
|
|
|
|
WEAPON_TYPE currentWeapon
|
|
BOOL bWeaponHasFlashlight = FALSE
|
|
BOOL bFlashlightInUse = FALSE
|
|
|
|
GET_CURRENT_PED_WEAPON(PLAYER_PED_ID(), currentWeapon)
|
|
IF HAS_PED_GOT_WEAPON_COMPONENT(PLAYER_PED_ID(), currentWeapon, WEAPONCOMPONENT_AT_AR_FLSH)
|
|
bWeaponHasFlashlight = TRUE
|
|
IF IS_PED_WEAPON_COMPONENT_ACTIVE(PLAYER_PED_ID(), currentWeapon, WEAPONCOMPONENT_AT_AR_FLSH)
|
|
bFlashlightInUse = TRUE
|
|
ENDIF
|
|
ELIF HAS_PED_GOT_WEAPON_COMPONENT(PLAYER_PED_ID(), currentWeapon, WEAPONCOMPONENT_AT_PI_FLSH)
|
|
bWeaponHasFlashlight = TRUE
|
|
IF IS_PED_WEAPON_COMPONENT_ACTIVE(PLAYER_PED_ID(), currentWeapon, WEAPONCOMPONENT_AT_PI_FLSH)
|
|
bFlashlightInUse = TRUE
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF NOT bDoneFlashlightHelp
|
|
IF bFlashlightInUse
|
|
bDoneFlashlightHelp = TRUE
|
|
ELSE
|
|
IF GET_GAME_TIMER() >= iStartFightTime + 800
|
|
IF bWeaponHasFlashlight AND NOT bFlashlightInUse
|
|
bDoneFlashlightHelp = DO_MISSION_HELP_TEXT("PF_FLSHLP")
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ELSE
|
|
IF bFlashlightInUse
|
|
IF IS_THIS_HELP_MESSAGE_BEING_DISPLAYED("PF_FLSHLP")
|
|
IF GET_GAME_TIMER() >= iClearHelpTime + 500
|
|
CLEAR_HELP(FALSE)
|
|
iClearHelpTime = GET_GAME_TIMER()
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF vPlayerOffsetFromPlane.z <= -FALL_FROM_Z
|
|
REMOVE_ALL_BLIPS()
|
|
STOP_SMOKE_ON_PLANE(PLANE_SMOKE_CLOUDS)
|
|
MISSION_FAILED(FAIL_FELL_FROM_CARGO_PLANE)
|
|
ELSE
|
|
IF IS_VEHICLE_DRIVEABLE(planeFightVehicle[PFV_CARGO_PLANE])
|
|
VECTOR vPlanePos = GET_ENTITY_COORDS(planeFightVehicle[PFV_CARGO_PLANE])
|
|
SET_RADAR_AS_INTERIOR_THIS_FRAME(GET_HASH_KEY("V_FakeCargoPlaneClimb"), vPlanePos.x, vPlanePos.y, FLOOR(GET_ENTITY_HEADING(planeFightVehicle[PFV_CARGO_PLANE])), 0)
|
|
SET_RADAR_ZOOM_PRECISE(1)
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF GET_GAME_TIMER() >= iStartFightTime + 200
|
|
DO_PLANE_SETPIECES(STAGE_PLANE_FIGHT)
|
|
ENDIF
|
|
|
|
// tannoy announcement
|
|
IF NOT bSetMerryweatherSpeaker1
|
|
IF NOT IS_MESSAGE_BEING_DISPLAYED()
|
|
AND NOT IS_ANY_CONVERSATION_ONGOING_OR_QUEUED()
|
|
iMerryweatherSpeaker1 = GET_CLOSEST_MERRYWEATHER_PED()
|
|
IF iMerryweatherSpeaker1 >= 0
|
|
ADD_PED_FOR_DIALOGUE(planeFightConversation, 6, enemyData[iMerryweatherSpeaker1].ped, "MERRYPLANE1")
|
|
bSetMerryweatherSpeaker1 = TRUE
|
|
ENDIF
|
|
ENDIF
|
|
ELSE
|
|
IF NOT bDoneMerryweatherCombatSpeech1
|
|
bDoneMerryweatherCombatSpeech1 = DO_MISSION_SPEECH("EXL1_MW1")
|
|
iMerryweatherCombatSpeechTime = GET_GAME_TIMER()
|
|
ELSE
|
|
IF NOT bDoneMerryweatherCombatSpeech2
|
|
IF GET_GAME_TIMER() >= iMerryweatherCombatSpeechTime + 12000
|
|
bDoneMerryweatherCombatSpeech2 = DO_MISSION_SPEECH("EXL1_MW2")
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF NOT bShownGodText
|
|
IF bDoneTannoyAnnouncement
|
|
bShownGodText = DO_MISSION_GOD_TEXT("PF_KILL")
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF bShownGodText
|
|
IF NOT bSetMerryweatherSpeaker2
|
|
IF vPlayerOffsetFromPlane.y >= -4.0
|
|
IF NOT IS_MESSAGE_BEING_DISPLAYED()
|
|
AND NOT IS_ANY_CONVERSATION_ONGOING_OR_QUEUED()
|
|
iMerryweatherSpeaker2 = GET_CLOSEST_MERRYWEATHER_PED()
|
|
IF iMerryweatherSpeaker2 >= 0
|
|
ADD_PED_FOR_DIALOGUE(planeFightConversation, 7, enemyData[iMerryweatherSpeaker2].ped, "MERRYPLANE2")
|
|
bSetMerryweatherSpeaker2 = TRUE
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ELSE
|
|
IF NOT bDoneMerryweatherCombatSpeech3
|
|
bDoneMerryweatherCombatSpeech3 = DO_MISSION_SPEECH("EXL1_MWCOM")
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF NOT bDoneTannoyAnnouncement
|
|
IF bSetMerryweatherSpeaker1
|
|
IF bDoneMerryweatherCombatSpeech1
|
|
OR IS_PED_INJURED(enemyData[iMerryweatherSpeaker1].ped)
|
|
bDoneTannoyAnnouncement = DO_MISSION_SPEECH("EXL1_MERCR")
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
|
|
// handle set ped accuracy
|
|
INT i
|
|
IF NOT bSetAccuracy
|
|
IF GET_GAME_TIMER() >= iStartFightTime + 3000
|
|
REPEAT COUNT_OF(enemyData) i
|
|
IF NOT IS_PED_INJURED(enemyData[i].ped)
|
|
SET_PED_ACCURACY(enemyData[i].ped, 25)
|
|
ENDIF
|
|
ENDREPEAT
|
|
bSetAccuracy = TRUE
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF NOT bDoneGotoCockpitPrompt
|
|
// blip cockpit when al-l guards killed
|
|
IF iKilledEnemies = NUMBER_ENEMY_PEDS
|
|
//IF DO_MISSION_GOD_TEXT("PF_CPIT")
|
|
// bDoneGotoCockpitPrompt = TRUE
|
|
// REMOVE_ALL_BLIPS()
|
|
//ENDIF
|
|
bDoneGotoCockpitPrompt = TRUE
|
|
ENDIF
|
|
ELSE
|
|
HANDLE_LADDER()
|
|
|
|
IF bCrewShoot
|
|
IF GET_DISTANCE_BETWEEN_COORDS(GET_GAMEPLAY_CAM_COORD(), GET_PED_BONE_COORDS(PLAYER_PED_ID(), BONETAG_HEAD, <<0,0,0>>)) < 0.6
|
|
SET_PED_CAN_TORSO_REACT_IK(PLAYER_PED_ID(), FALSE)
|
|
ENDIF
|
|
ENDIF
|
|
|
|
// cover
|
|
IF vPlayerOffsetFromPlane.z >= -0.6
|
|
IF NOT bAddedCockpitCover
|
|
SET_VEHICLE_PROVIDES_COVER(planeFightVehicle[PFV_CARGO_PLANE], TRUE)
|
|
bAddedCockpitCover = TRUE
|
|
ENDIF
|
|
ELSE
|
|
IF bAddedCockpitCover
|
|
SET_VEHICLE_PROVIDES_COVER(planeFightVehicle[PFV_CARGO_PLANE], FALSE)
|
|
bAddedCockpitCover = FALSE
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF NOT bDoneGoToCockpitCue
|
|
bDoneGoToCockpitCue = TRIGGER_MISSION_MUSIC_EVENT("EXL1_HEAD_TO_COCKPIT")
|
|
ENDIF
|
|
|
|
VECTOR vPlayerCoords = GET_ENTITY_COORDS(PLAYER_PED_ID())
|
|
IF NOT bCanUseControls
|
|
// crew shoot at player
|
|
IF NOT bCrewShoot
|
|
IF bOffLadder
|
|
IF NOT bClearedEnemiesFromHold
|
|
REPEAT COUNT_OF(enemyData) i
|
|
IF DOES_ENTITY_EXIST(enemyData[i].ped)
|
|
IF IS_ENTITY_ON_SCREEN(enemyData[i].ped)
|
|
SET_PED_AS_NO_LONGER_NEEDED(enemyData[i].ped)
|
|
ELSE
|
|
DELETE_PED(enemyData[i].ped)
|
|
ENDIF
|
|
ENDIF
|
|
ENDREPEAT
|
|
bClearedEnemiesFromHold = TRUE
|
|
ENDIF
|
|
|
|
IF GET_GAME_TIMER() >= iCrewShootTime
|
|
FOR i=ENEMY_PILOT TO ENEMY_PILOT//ENEMY_COPILOT
|
|
IF NOT IS_PED_INJURED(namedEnemyPed[i])
|
|
//SET_PED_CAN_LEG_IK(namedEnemyPed[i], TRUE)
|
|
//SET_PED_LEG_IK_MODE(namedEnemyPed[i], LEG_IK_FULL)
|
|
|
|
SET_PED_ACCURACY(namedEnemyPed[i], 20)
|
|
CLEAR_SEQUENCE_TASK(sequence)
|
|
OPEN_SEQUENCE_TASK(sequence)
|
|
//TASK_GO_TO_COORD_WHILE_AIMING_AT_ENTITY(NULL, <<2928.93, 764.77, 463.21>>, PLAYER_PED_ID(), PEDMOVE_WALK, FALSE, 0.5, 4.0, FALSE, ENAV_DONT_AVOID_OBJECTS)
|
|
TASK_AIM_GUN_AT_ENTITY(NULL, PLAYER_PED_ID(), 3600)
|
|
TASK_COMBAT_PED(NULL, PLAYER_PED_ID())
|
|
CLOSE_SEQUENCE_TASK(sequence)
|
|
TASK_PERFORM_SEQUENCE(namedEnemyPed[i], sequence)
|
|
iCrewShootSpeechTime = GET_GAME_TIMER()
|
|
bCrewShoot = TRUE
|
|
ENDIF
|
|
ENDFOR
|
|
ENDIF
|
|
ENDIF
|
|
ELSE
|
|
IF NOT bSetPilotAttack
|
|
IF NOT IS_PED_INJURED(namedEnemyPed[ENEMY_PILOT])
|
|
IF GET_GAME_TIMER() >= iCrewShootSpeechTime + 8000
|
|
OPEN_SEQUENCE_TASK(sequence)
|
|
TASK_GO_TO_COORD_WHILE_AIMING_AT_ENTITY(NULL, <<2928.93, 767.2, 462.4>>, PLAYER_PED_ID(), PEDMOVE_WALK, FALSE, 0.5, 4.0, FALSE, ENAV_DONT_AVOID_OBJECTS)
|
|
//TASK_AIM_GUN_AT_ENTITY(NULL, PLAYER_PED_ID(), 3600)
|
|
TASK_COMBAT_PED(NULL, PLAYER_PED_ID())
|
|
CLOSE_SEQUENCE_TASK(sequence)
|
|
TASK_PERFORM_SEQUENCE(namedEnemyPed[i], sequence)
|
|
bSetPilotAttack = TRUE
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF NOT bDoneCrewSpeech
|
|
IF GET_GAME_TIMER() >= iCrewShootSpeechTime + 1000
|
|
bDoneCrewSpeech = DO_MISSION_SPEECH("EXL1_PILOTA")
|
|
ENDIF
|
|
ELSE
|
|
IF NOT bDoneTurbulenceSpeech
|
|
bDoneTurbulenceSpeech = DO_MISSION_SPEECH("EXL1_PFIGHT")
|
|
ENDIF
|
|
//IF NOT bShownKillCrewPrompt
|
|
// bShownKillCrewPrompt = DO_MISSION_GOD_TEXT("PF_KILL2")
|
|
//ENDIF
|
|
ENDIF
|
|
|
|
// blip the crew
|
|
IF NOT bBlippedCrew
|
|
FOR i=ENEMY_PILOT TO ENEMY_PILOT//ENEMY_COPILOT
|
|
IF NOT IS_PED_INJURED(namedEnemyPed[i])
|
|
crewBlip[i] = CREATE_MISSION_BLIP_FOR_PED(namedEnemyPed[i], TRUE)
|
|
ENDIF
|
|
ENDFOR
|
|
bBlippedCrew = TRUE
|
|
ENDIF
|
|
ENDIF
|
|
|
|
// check to see if crew dead
|
|
IF bOffLadder
|
|
INT iKilledPeds = 0
|
|
FOR i=ENEMY_PILOT TO ENEMY_PILOT//ENEMY_COPILOT
|
|
IF IS_PED_INJURED(namedEnemyPed[i])
|
|
IF DOES_BLIP_EXIST(crewBlip[i])
|
|
IF DOES_ENTITY_EXIST(namedEnemyPed[i])
|
|
INFORM_MISSION_STATS_OF_INCREMENT(EXL1_KILLS)
|
|
ENDIF
|
|
REMOVE_BLIP(crewBlip[i])
|
|
ENDIF
|
|
iKilledPeds++
|
|
ELSE
|
|
VECTOR vPedCoords = GET_ENTITY_COORDS(namedEnemyPed[i])
|
|
IF vPedCoords.z <= vPlayerCoords.z - 10.0
|
|
SET_PED_AS_NO_LONGER_NEEDED(namedEnemyPed[i])
|
|
// APPLY_DAMAGE_TO_PED(namedEnemyPed[i], 1000, TRUE)
|
|
ENDIF
|
|
ENDIF
|
|
ENDFOR
|
|
|
|
IF iKilledPeds = 1
|
|
//PRINTSTRING("do pitch") printnl()
|
|
iCanUseControlsTime = GET_GAME_TIMER()
|
|
bCanUseControls = TRUE
|
|
ENDIF
|
|
ENDIF
|
|
ELSE
|
|
IF NOT bDonePitchDown
|
|
IF GET_GAME_TIMER() >= iCanUseControlsTime + 10000
|
|
FILL_PLANE_PITCH_DATA(PLANE_PITCH_DIR_DIVE, PLANE_PITCH_SPEED_SLOW, -10.0)
|
|
bDonePitchDown = TRUE
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF NOT bDoneUseControlsCue
|
|
bDoneUseControlsCue = TRIGGER_MISSION_MUSIC_EVENT("EXL1_COCKPIT_ENTERED")
|
|
ENDIF
|
|
|
|
IF NOT DOES_BLIP_EXIST(controlsBlip)
|
|
controlsBlip = CREATE_MISSION_BLIP_FOR_COORD(GET_CONTROLS_COORDS())
|
|
IF DOES_BLIP_EXIST(controlsBlip)
|
|
SET_BLIP_COLOUR(controlsBlip, BLIP_COLOUR_GREEN)
|
|
SET_BLIP_SCALE(controlsBlip, BLIP_SIZE_OBJECT)
|
|
SET_BLIP_NAME_FROM_TEXT_FILE(controlsBlip, "PF_CONTROLS")
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF NOT bDonePilotDeadSpeech
|
|
bDonePilotDeadSpeech = DO_MISSION_SPEECH("EXL1_PKILL")
|
|
ELSE
|
|
IF NOT bDoneUseControlsPrompt
|
|
bDoneUseControlsPrompt = DO_MISSION_GOD_TEXT("PF_CONT")
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF GET_GAME_TIMER() >= iCanUseControlsTime + 30000
|
|
bForceUseControls = TRUE
|
|
ENDIF
|
|
|
|
IF NOT bAllowUseControls
|
|
IF vPlayerOffsetFromPlane.y >= 27.2
|
|
bAllowUseControls = TRUE
|
|
ENDIF
|
|
ELSE
|
|
IF vPlayerOffsetFromPlane.y <= 26.9
|
|
bAllowUseControls = FALSE
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF bAllowUseControls
|
|
OR bForceUseControls
|
|
#IF IS_DEBUG_BUILD
|
|
OR bDebugForceUseControls
|
|
#ENDIF
|
|
IF NOT bForceUseControls
|
|
IF NOT bShownControlsHelp
|
|
PRINT_HELP_FOREVER("PF_CONHLP")
|
|
bShownControlsHelp = TRUE
|
|
ENDIF
|
|
//DISPLAY_HELP_TEXT_THIS_FRAME("PF_CONHLP", FALSE)
|
|
ENDIF
|
|
IF IS_CONTROL_JUST_PRESSED(PLAYER_CONTROL, INPUT_ENTER)
|
|
OR bForceUseControls
|
|
#IF IS_DEBUG_BUILD
|
|
OR bDebugForceUseControls
|
|
#ENDIF
|
|
bRunningCutscene = TRUE
|
|
ENDIF
|
|
ELSE
|
|
IF GET_GAME_TIMER() >= iClearHelpTime
|
|
IF IS_THIS_HELP_MESSAGE_BEING_DISPLAYED("PF_CONHLP")
|
|
CLEAR_HELP(FALSE)
|
|
bShownControlsHelp = FALSE
|
|
iClearHelpTime = GET_GAME_TIMER() + 100
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ELSE
|
|
DO_JACK_ATTEMPT_CUTSCENE()
|
|
ENDIF
|
|
ENDPROC
|
|
//VECTOR vCachePlanePos
|
|
|
|
// wave down cutscene procedure
|
|
PROC DO_WAVE_DOWN_CUTSCENE()
|
|
SWITCH cutsceneStage
|
|
CASE PF_CUT_STAGE_INIT
|
|
SET_MISSION_CUTSCENE(TRUE)
|
|
|
|
IF IS_VEHICLE_DRIVEABLE(planeFightVehicle[PFV_CARGO_PLANE])
|
|
AND IS_VEHICLE_DRIVEABLE(jetData[1].veh)
|
|
AND NOT IS_PED_INJURED(jetData[1].ped)
|
|
AND NOT IS_PED_INJURED(PLAYER_PED_ID())
|
|
|
|
SET_ENTITY_COORDS(planeFightVehicle[PFV_CARGO_PLANE], GET_ENTITY_COORDS(planeFightVehicle[PFV_CARGO_PLANE]))
|
|
vPlaneRotForCutscene = GET_ENTITY_ROTATION(planeFightVehicle[PFV_CARGO_PLANE])
|
|
SET_ENTITY_ROTATION(planeFightVehicle[PFV_CARGO_PLANE], <<0,0,vPlaneRotForCutscene.z>>)
|
|
|
|
//vCachePlanePos = GET_ENTITY_COORDS(planeFightVehicle[PFV_CARGO_PLANE])
|
|
|
|
ATTACH_ENTITY_TO_ENTITY(jetData[1].veh, planeFightVehicle[PFV_CARGO_PLANE], 0, vJetAttach, <<0,0,0>>)
|
|
IF IS_VEHICLE_DRIVEABLE(jetData[0].veh)
|
|
ATTACH_ENTITY_TO_ENTITY(jetData[0].veh, planeFightVehicle[PFV_CARGO_PLANE], 0, <<30, -40, -6>>, <<0,0,0>>)
|
|
ENDIF
|
|
|
|
IF NOT bStoppedDebrisAtBack
|
|
STOP_SMOKE_ON_PLANE(PLANE_SMOKE_CRASH_SMOKE_FLIGHT)
|
|
ENDIF
|
|
|
|
bUsingJetCam = FALSE
|
|
localChaseHintCamStruct.iInputCheckTimer = get_game_timer()
|
|
localChaseHintCamStruct.eHintCamMethod = hint_OFF
|
|
localChaseHintCamStruct.bHint_toggleOn = FALSE
|
|
|
|
// setup player
|
|
iSyncScene = CREATE_SYNCHRONIZED_SCENE(<<0,0,0>>, <<0,0,0>>)
|
|
|
|
SET_ENTITY_COORDS(PLAYER_PED_ID(), GET_ENTITY_COORDS(PLAYER_PED_ID()) + <<0,0,1>>)
|
|
ATTACH_SYNCHRONIZED_SCENE_TO_ENTITY(iSyncScene, planeFightVehicle[PFV_CARGO_PLANE], GET_ENTITY_BONE_INDEX_BY_NAME(planeFightVehicle[PFV_CARGO_PLANE], "seat_dside_f"))
|
|
TASK_SYNCHRONIZED_SCENE(PLAYER_PED_ID(), iSyncScene, GET_PLANE_FIGHT_ANIM_DICT_AS_STRING(PF_ANIM_DICT_MISSION), "CALL_RADIO_PLAYER2", INSTANT_BLEND_IN, NORMAL_BLEND_OUT)
|
|
|
|
FORCE_PED_AI_AND_ANIMATION_UPDATE(PLAYER_PED_ID())
|
|
SET_CURRENT_PED_WEAPON(PLAYER_PED_ID(), WEAPONTYPE_UNARMED, TRUE)
|
|
SET_VEHICLE_ENGINE_ON(planeFightVehicle[PFV_CARGO_PLANE], TRUE, TRUE)
|
|
|
|
dummyJetPed = CREATE_PED_INSIDE_VEHICLE(planeFightVehicle[PFV_CARGO_PLANE], PEDTYPE_MISSION, GET_MODEL_FOR_PLANE_FIGHT_MODEL_ENUM(PFM_SOLDIER))
|
|
SET_ENTITY_VISIBLE(dummyJetPed, FALSE)
|
|
|
|
// setup radio
|
|
radioObject = CREATE_OBJECT(GET_MODEL_FOR_PLANE_FIGHT_MODEL_ENUM(PFM_RADIO), <<0,1,2>>)
|
|
PLAY_SYNCHRONIZED_ENTITY_ANIM(radioObject, iSyncScene, "call_radio_radio", GET_PLANE_FIGHT_ANIM_DICT_AS_STRING(PF_ANIM_DICT_MISSION), INSTANT_BLEND_IN)
|
|
FORCE_ENTITY_AI_AND_ANIMATION_UPDATE(radioObject)
|
|
|
|
|
|
// setup jet chap
|
|
TASK_PLAY_ANIM(jetData[1].ped, GET_PLANE_FIGHT_ANIM_DICT_AS_STRING(PF_ANIM_DICT_MISSION), "CALL_RADIO_SECURITY", INSTANT_BLEND_IN, NORMAL_BLEND_OUT, -1, AF_HOLD_LAST_FRAME, 0.15)
|
|
FORCE_PED_AI_AND_ANIMATION_UPDATE(jetData[1].ped)
|
|
ENDIF
|
|
|
|
CREATE_CAM_ATTACHED_TO_CARGO_PLANE(PF_SHOT_WAVE_DOWN)
|
|
|
|
CASCADE_SHADOWS_SET_CASCADE_BOUNDS_SCALE(0.06)
|
|
|
|
START_PLANE_FIGHT_AUDIO_SCENE(PLANE_FIGHT_AUDIO_SCENE_COCKPIT_CUTSCENE)
|
|
|
|
bDoneFlash = FALSE
|
|
|
|
iPlaneFightCutsceneTime = GET_GAME_TIMER()
|
|
cutsceneStage = PF_CUT_STAGE_RUNNING
|
|
BREAK
|
|
|
|
CASE PF_CUT_STAGE_RUNNING
|
|
IF IS_VEHICLE_DRIVEABLE(planeFightVehicle[PFV_CARGO_PLANE])
|
|
AND IS_VEHICLE_DRIVEABLE(jetData[1].veh)
|
|
|
|
//#IF IS_DEBUG_BUILD
|
|
/// ATTACH_CAM_TO_ENTITY(staticCam, planeFightVehicle[PFV_CARGO_PLANE], vDebugAttachCamOffset)
|
|
// POINT_CAM_AT_ENTITY(staticCam, planeFightVehicle[PFV_CARGO_PLANE], vDebugAttachCamPoint)
|
|
// SET_CAM_FOV(staticCam, fDebugAttachCamFOV)
|
|
//#ENDIF
|
|
|
|
INTERP_VECTOR_TO_VECTOR_OVER_TIME(<<6.600, 31.500, 2.300>>, <<6.600, 34.900, 2.300>>, vAttachCamPos, 9)
|
|
INTERP_VECTOR_TO_VECTOR_OVER_TIME(<<0.000, 28.300, 2.600>>, <<0.000, 32.000, 2.500>>, vAttachCamRot, 9)
|
|
|
|
ATTACH_CAM_TO_ENTITY(staticCam, planeFightVehicle[PFV_CARGO_PLANE], vAttachCamPos)
|
|
POINT_CAM_AT_ENTITY(staticCam, planeFightVehicle[PFV_CARGO_PLANE], vAttachCamRot)
|
|
|
|
// move cargo plane
|
|
SET_ENTITY_ROTATION(planeFightVehicle[PFV_CARGO_PLANE], <<0,0,vPlaneRotForCutscene.z>>)
|
|
SET_VEHICLE_FORWARD_SPEED(planeFightVehicle[PFV_CARGO_PLANE], 40.0)
|
|
SET_VEHICLE_ENGINE_ON(planeFightVehicle[PFV_CARGO_PLANE], TRUE, TRUE)
|
|
|
|
// move jet
|
|
vJetAttach.y = vJetAttach.y +@ 0.9//0.27//0.64
|
|
vJetAttach.z = vJetAttach.z -@ 0.3//0.12//0.36
|
|
|
|
ATTACH_ENTITY_TO_ENTITY(jetData[1].veh, planeFightVehicle[PFV_CARGO_PLANE], 0, vJetAttach, <<0,0,0>>)
|
|
ENDIF
|
|
|
|
IF NOT bDoneJetAlongSideCue
|
|
IF bDoneSeeJetCue
|
|
bDoneJetAlongSideCue = TRIGGER_MISSION_MUSIC_EVENT("EXL1_DEADLY_FORCE")
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF NOT bDoneWaveDownSpeech
|
|
IF GET_GAME_TIMER() >= iPlaneFightCutsceneTime + 100
|
|
bDoneWaveDownSpeech = DO_MISSION_SPEECH("EXL1_PLWAVE")
|
|
IF bDoneWaveDownSpeech
|
|
REPLAY_RECORD_BACK_FOR_TIME(3.0, 8.0, REPLAY_IMPORTANCE_HIGHEST)
|
|
ENDIF
|
|
ENDIF
|
|
ELSE
|
|
IF NOT bDoneTrevorGestureSpeech
|
|
bDoneTrevorGestureSpeech = DO_MISSION_SPEECH("EXL1_FLIPOFF")
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF NOT bSkipInProgress
|
|
IF IS_CUTSCENE_SKIP_BUTTON_JUST_PRESSED()
|
|
AND GET_GAME_TIMER() >= iAllowSkipCutsceneTime + 1000
|
|
DO_SCREEN_FADE_OUT(DEFAULT_FADE_TIME)
|
|
bSkipInProgress = TRUE
|
|
ENDIF
|
|
ELSE
|
|
IF IS_SCREEN_FADED_OUT()
|
|
bSkippedCutscene = TRUE
|
|
cutsceneStage = PF_CUT_STAGE_CLEANUP
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF NOT bDoneFlash
|
|
IF GET_CAM_VIEW_MODE_FOR_CONTEXT(CAM_VIEW_MODE_CONTEXT_IN_AIRCRAFT) = CAM_VIEW_MODE_FIRST_PERSON
|
|
IF GET_GAME_TIMER() >= iPlaneFightCutsceneTime + 8700
|
|
ANIMPOSTFX_PLAY("CamPushInNeutral", 0, FALSE)
|
|
PLAY_SOUND_FRONTEND(-1, "1st_Person_Transition", "PLAYER_SWITCH_CUSTOM_SOUNDSET")
|
|
bDoneFlash = TRUE
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF GET_GAME_TIMER() >= iPlaneFightCutsceneTime + 9000
|
|
AND NOT bSkipInProgress
|
|
cutsceneStage = PF_CUT_STAGE_CLEANUP
|
|
ENDIF
|
|
BREAK
|
|
|
|
CASE PF_CUT_STAGE_CLEANUP
|
|
IF bSkippedCutscene
|
|
KILL_FACE_TO_FACE_CONVERSATION_DO_NOT_FINISH_LAST_LINE()
|
|
WAIT(800)
|
|
ENDIF
|
|
|
|
IF IS_VEHICLE_DRIVEABLE(planeFightVehicle[PFV_CARGO_PLANE])
|
|
AND IS_VEHICLE_DRIVEABLE(jetData[1].veh)
|
|
AND NOT IS_PED_INJURED(jetData[1].ped)
|
|
AND NOT IS_PED_INJURED(PLAYER_PED_ID())
|
|
FREEZE_ENTITY_POSITION(planeFightVehicle[PFV_CARGO_PLANE], FALSE)
|
|
SET_VEHICLE_FORWARD_SPEED(planeFightVehicle[PFV_CARGO_PLANE], 55)
|
|
|
|
IF DOES_ENTITY_EXIST(radioObject)
|
|
DELETE_OBJECT(radioObject)
|
|
ENDIF
|
|
CLEAR_MODEL_REQUEST(ENUM_TO_INT(PFM_RADIO))
|
|
|
|
DETACH_ENTITY(jetData[1].veh)
|
|
SET_VEHICLE_FORWARD_SPEED(jetData[1].veh, 55)
|
|
IF IS_VEHICLE_DRIVEABLE(jetData[0].veh)
|
|
DETACH_ENTITY(jetData[0].veh)
|
|
SET_VEHICLE_FORWARD_SPEED(jetData[0].veh, 55)
|
|
ENDIF
|
|
|
|
TASK_CLEAR_LOOK_AT(jetData[1].ped)
|
|
TASK_CLEAR_LOOK_AT(PLAYER_PED_ID())
|
|
|
|
IF DOES_ENTITY_EXIST(dummyJetPed)
|
|
DELETE_PED(dummyJetPed)
|
|
ENDIF
|
|
|
|
//STOP_ANIM_TASK(PLAYER_PED_ID(), GET_PLANE_FIGHT_ANIM_DICT_AS_STRING(PF_ANIM_DICT_MISSION), "CALL_RADIO_PLAYER2")
|
|
STOP_ANIM_TASK(jetData[1].ped, GET_PLANE_FIGHT_ANIM_DICT_AS_STRING(PF_ANIM_DICT_MISSION), "CALL_RADIO_SECURITY")
|
|
|
|
SET_PED_INTO_VEHICLE(PLAYER_PED_ID(), planeFightVehicle[PFV_CARGO_PLANE])
|
|
ENDIF
|
|
|
|
jetData[1].iTaskTime = 0
|
|
fJetFlyAlongsideTimer = 0.0
|
|
jetFlyAlongsideState = JET_FLY_ALONGSIDE_POSITION_FOR_FALLBACK
|
|
SET_JET_ATTACK_STATE(JET_ATTACK_ESCORT)
|
|
|
|
STOP_PLANE_FIGHT_AUDIO_SCENE(PLANE_FIGHT_AUDIO_SCENE_COCKPIT_CUTSCENE)
|
|
|
|
// back to gameplay
|
|
SET_MISSION_CUTSCENE(FALSE)
|
|
CASCADE_SHADOWS_SET_CASCADE_BOUNDS_SCALE(1.0)
|
|
|
|
bDoneWaveDownCutscene = TRUE
|
|
BREAK
|
|
ENDSWITCH
|
|
ENDPROC
|
|
|
|
|
|
// cleanup jack attempt cutscene
|
|
PROC CLEANUP_ESCAPE_CUTSCENE()
|
|
IF bSkippedCutscene
|
|
ENDIF
|
|
|
|
IF bSkippedCutscene
|
|
WAIT(500)
|
|
ENDIF
|
|
|
|
SET_MISSION_CUTSCENE(FALSE)
|
|
SET_MISSION_STAGE(STAGE_ESCAPE_PLANE)
|
|
ENDPROC
|
|
|
|
/*
|
|
// jack attempt cutscene procedure
|
|
PROC DO_ESCAPE_CUTSCENE()
|
|
HANDLE_KLAXON_SOUND(TRUE)
|
|
|
|
SWITCH cutsceneStage
|
|
CASE PF_CUT_STAGE_INIT
|
|
SET_MISSION_CUTSCENE(TRUE)
|
|
|
|
TURN_OFF_KLAXON()
|
|
|
|
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(planeFightVehicle[PFV_CARGO_PLANE])
|
|
REGISTER_ENTITY_FOR_CUTSCENE(planeFightVehicle[PFV_CARGO_PLANE], "cargoplane", CU_ANIMATE_EXISTING_SCRIPT_ENTITY)
|
|
ENDIF
|
|
|
|
START_CUTSCENE_AT_COORDS(GET_PLANE_FIGHT_VECTOR(PFVEC_CARGO_PLANE_DESCEND))
|
|
SET_CUTSCENE_FADE_VALUES(FALSE, FALSE, FALSE, FALSE)
|
|
|
|
cutsceneStage = PF_CUT_STAGE_RUNNING
|
|
BREAK
|
|
|
|
CASE PF_CUT_STAGE_RUNNING
|
|
|
|
IF CAN_SET_EXIT_STATE_FOR_REGISTERED_ENTITY("Trevor")
|
|
IF WAS_CUTSCENE_SKIPPED()
|
|
bSkippedCutscene = TRUE
|
|
ENDIF
|
|
CLEANUP_ESCAPE_CUTSCENE()
|
|
ENDIF
|
|
|
|
#IF IS_DEBUG_BUILD
|
|
DEBUG_SKIP_MOCAP()
|
|
#ENDIF
|
|
BREAK
|
|
|
|
CASE PF_CUT_STAGE_CLEANUP
|
|
BREAK
|
|
ENDSWITCH
|
|
ENDPROC
|
|
*/
|
|
|
|
CONST_FLOAT PLANE_CLIMB_HEIGHT_HIGH 550.0
|
|
CONST_FLOAT PLANE_CLIMB_HEIGHT_LOW 250.0
|
|
// fly the plane briefly
|
|
PROC DO_STAGE_FLY_PLANE()
|
|
|
|
DISABLE_CONTROL_ACTION(PLAYER_CONTROL, INPUT_VEH_SELECT_NEXT_WEAPON)
|
|
DISABLE_CONTROL_ACTION(PLAYER_CONTROL, INPUT_VEH_SELECT_PREV_WEAPON)
|
|
|
|
IF NOT bRunningCutscene
|
|
// load jet flyby sound
|
|
IF NOT bLoadedFlybyStream
|
|
bLoadedFlybyStream = LOAD_STREAM("FLYBY", "EXILE_1")
|
|
ENDIF
|
|
|
|
IF IS_VEHICLE_DRIVEABLE(planeFightVehicle[PFV_CARGO_PLANE])
|
|
IF NOT bDoneTurnOffAlarmSpeech
|
|
/*
|
|
HANDLE_KLAXON_SOUND(TRUE)
|
|
IF DO_MISSION_SPEECH("EXL1_SALARM")
|
|
iTurnOffAlarmSpeechTime = GET_GAME_TIMER()
|
|
bDoneTurnOffAlarmSpeech = TRUE
|
|
ENDIF
|
|
*/
|
|
bDoneTurnOffAlarmSpeech = TRUE
|
|
ELSE
|
|
IF NOT bTurnedOffAlarm
|
|
IF GET_GAME_TIMER() >= iTurnOffAlarmSpeechTime + 2000
|
|
TURN_OFF_KLAXON()
|
|
bTurnedOffAlarm = TRUE
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF NOT bDoneInPlaneSpeech
|
|
bDoneInPlaneSpeech = DO_MISSION_SPEECH("EXL1_PILOT")
|
|
IF bDoneInPlaneSpeech
|
|
REPLAY_RECORD_BACK_FOR_TIME(4.0, 8.0, REPLAY_IMPORTANCE_HIGHEST)
|
|
ENDIF
|
|
ELSE
|
|
IF NOT bDoneBearingSpeech
|
|
bDoneBearingSpeech = DO_MISSION_SPEECH("EXL1_BEARING")
|
|
ELSE
|
|
IF NOT bShownGodText
|
|
bShownGodText = DO_MISSION_GOD_TEXT("PF_FLYCG")
|
|
ELSE
|
|
IF NOT bDoneChangeFreqSpeech
|
|
bDoneChangeFreqSpeech = DO_MISSION_SPEECH("EXL1_PILOT2")
|
|
ELSE
|
|
IF NOT bDoneHailRonSpeech
|
|
bDoneHailRonSpeech = DO_MISSION_SPEECH("EXL1_HAILRON")
|
|
ELSE
|
|
IF NOT bDoneRonHailedSpeech
|
|
bDoneRonHailedSpeech = DO_MISSION_SPEECH("EXL1_RESP")
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
|
|
// music
|
|
IF NOT bDoneSeeJetCue
|
|
IF bDoneSeeJetSpeech
|
|
bDoneSeeJetCue = TRIGGER_MISSION_MUSIC_EVENT("EXL1_FIGHTER_JETS_APPEAR")
|
|
ENDIF
|
|
ENDIF
|
|
|
|
// set speed
|
|
IF NOT bStoppedForceSpeed
|
|
SET_VEHICLE_FORWARD_SPEED(planeFightVehicle[PFV_CARGO_PLANE], 55.0)
|
|
IF GET_GAME_TIMER() >= iStopForceSpeedTime
|
|
bStoppedForceSpeed = TRUE
|
|
ENDIF
|
|
ENDIF
|
|
|
|
// turn help
|
|
IF NOT bShownTurnHelp
|
|
IF GET_GAME_TIMER() >= iFlightTime + 3000
|
|
bShownTurnHelp = DO_MISSION_HELP_TEXT("PF_TRNHLP")
|
|
ENDIF
|
|
ENDIF
|
|
|
|
// height above ground
|
|
FLOAT fHeightAboveGround
|
|
FLOAT fGroundHeight
|
|
VECTOR vPlanePos
|
|
fHeightAboveGround = GET_HEIGHT_ABOVE_GROUND(planeFightVehicle[PFV_CARGO_PLANE], fGroundHeight)
|
|
UPDATE_PLANE_ROOT(planeFightVehicle[PFV_CARGO_PLANE], fHeightAboveGround)
|
|
vPlanePos = GET_ENTITY_COORDS(planeFightVehicle[PFV_CARGO_PLANE])
|
|
|
|
IF bDoneRonHailedSpeech
|
|
AND jetAttackState <> JET_ATTACK_FLY_TO_PLANE
|
|
IF fHeightAboveGround < 135
|
|
AND vPlanePos.z < PLANE_CLIMB_HEIGHT_HIGH
|
|
IF GET_GAME_TIMER() >= iFlyTooLowSpeechTime
|
|
AND jetAttackState < JET_ATTACK_FALL_BACK_TO_SHOOT
|
|
IF DO_MISSION_SPEECH("EXL1_TOOLOW")
|
|
iFlyTooLowSpeechTime = GET_GAME_TIMER() + GET_RANDOM_INT_IN_RANGE(20000, 25000)
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
|
|
// jet cam
|
|
IF jetAttackState >= JET_ATTACK_TO_REAR
|
|
HANDLE_JET_CAM()
|
|
ENDIF
|
|
|
|
// obey help
|
|
/*
|
|
IF NOT bShownObeyJetHelp
|
|
IF iJetWarningSpeech >= 1
|
|
IF GET_GAME_TIMER() >= iJetSpeechTime + 2500
|
|
bShownObeyJetHelp = DO_MISSION_HELP_TEXT("PF_OBYHLP")
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
*/
|
|
|
|
// trevor react to jet on radio to ron
|
|
IF NOT bDoneJetReactSpeech
|
|
IF bDoneJetWarning1Speech
|
|
bDoneJetReactSpeech = DO_MISSION_SPEECH("EXL1_RONJET2", FALSE, 1)
|
|
ENDIF
|
|
ELSE
|
|
IF NOT bDoneRonShakeJetsSpeech
|
|
bDoneRonShakeJetsSpeech = DO_MISSION_SPEECH("EXL1_SHAKE2")
|
|
ELSE
|
|
IF NOT bDoneTrevorShakeJetsSpeech
|
|
bDoneTrevorShakeJetsSpeech = DO_MISSION_SPEECH("EXL1_TABOVE")
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF NOT bStoppedDebrisAtBack
|
|
IF iJetWarningSpeech > 2
|
|
STOP_SMOKE_ON_PLANE(PLANE_SMOKE_CRASH_SMOKE_FLIGHT)
|
|
bStoppedDebrisAtBack = TRUE
|
|
ENDIF
|
|
ENDIF
|
|
|
|
// trevor react to shot down on radio to ron
|
|
IF flyPlaneState < FLY_PLANE_POST_FIREBALL
|
|
IF NOT bDoneShootDownReactSpeech
|
|
IF bDoneEngineBlowSpeech
|
|
//bDoneShootDownReactSpeech = DO_MISSION_SPEECH("EXL1_RONSHO2")
|
|
bDoneShootDownReactSpeech = DO_MISSION_SPEECH("EXL1_GOTME")
|
|
ENDIF
|
|
ELSE
|
|
IF NOT bDoneRonResponseToShootDownSpeech
|
|
IF vPlanePos.z >= PLANE_CLIMB_HEIGHT_LOW
|
|
IF DO_MISSION_SPEECH("EXL1_SAVE")
|
|
bDoneRonResponseToShootDownSpeech = TRUE
|
|
IF vPlanePos.z >= PLANE_CLIMB_HEIGHT_HIGH
|
|
bForceClimb = FALSE
|
|
ELSE
|
|
iClimbPromptTime = GET_GAME_TIMER()
|
|
bForceClimb = TRUE
|
|
ENDIF
|
|
ENDIF
|
|
ELSE
|
|
IF DO_MISSION_SPEECH("EXL1_CLIMB")
|
|
bDoneRonResponseToShootDownSpeech = TRUE
|
|
iClimbPromptTime = GET_GAME_TIMER()
|
|
bForceClimb = TRUE
|
|
ENDIF
|
|
ENDIF
|
|
ELSE
|
|
IF NOT bShownClimbText
|
|
IF bForceClimb
|
|
bShownClimbText = DO_MISSION_GOD_TEXT("PF_CLIMB")
|
|
iNextRandomSpeechTime = GET_GAME_TIMER() + 8000
|
|
ENDIF
|
|
ELSE
|
|
DO_RANDOM_SPEECH("EXL1_CURSE")
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
|
|
BOOL bForceExplode = FALSE
|
|
IF bForceClimb
|
|
IF vPlanePos.z < PLANE_CLIMB_HEIGHT_HIGH
|
|
IF flyPlaneState < FLY_PLANE_POST_FIREBALL
|
|
IF GET_GAME_TIMER() >= iClimbPromptTime + 38000//17000
|
|
bForceExplode = TRUE
|
|
ENDIF
|
|
ENDIF
|
|
ELSE
|
|
IF IS_THIS_PRINT_BEING_DISPLAYED("PF_CLIMB")
|
|
REMOVE_MISSION_TEXT(FALSE, TRUE, FALSE)
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
|
|
// cut out control intermittently
|
|
IF flyPlaneState >= FLY_PLANE_POST_ENGINE
|
|
//HANDLE_STREAMING_MOCAP("EXL_1_MCS_3", GET_ENTITY_COORDS(planeFightVehicle[PFV_CARGO_PLANE]), 500, 600)
|
|
|
|
IF bCutOutControl
|
|
DISABLE_CONTROL_ACTION(PLAYER_CONTROL, INPUT_VEH_FLY_THROTTLE_UP)
|
|
DISABLE_CONTROL_ACTION(PLAYER_CONTROL, INPUT_VEH_FLY_THROTTLE_DOWN)
|
|
DISABLE_CONTROL_ACTION(PLAYER_CONTROL, INPUT_VEH_FLY_YAW_LEFT)
|
|
DISABLE_CONTROL_ACTION(PLAYER_CONTROL, INPUT_VEH_FLY_YAW_RIGHT)
|
|
DISABLE_CONTROL_ACTION(PLAYER_CONTROL, INPUT_VEH_FLY_ROLL_LR)
|
|
DISABLE_CONTROL_ACTION(PLAYER_CONTROL, INPUT_VEH_FLY_PITCH_UD)
|
|
ENDIF
|
|
|
|
IF GET_GAME_TIMER() >= iCutOutControlTime
|
|
INT iAddControlTime
|
|
|
|
IF NOT bCutOutControl
|
|
// cutting out control
|
|
IF flyPlaneState = FLY_PLANE_POST_ENGINE
|
|
iAddControlTime = GET_RANDOM_INT_IN_RANGE(700, 1200) //GET_RANDOM_INT_IN_RANGE(400, 900)
|
|
ELSE
|
|
iAddControlTime = GET_RANDOM_INT_IN_RANGE(1200, 1600)
|
|
ENDIF
|
|
//SET_PLAYER_CONTROL(PLAYER_ID(), FALSE, SPC_LEAVE_CAMERA_CONTROL_ON)
|
|
bCutOutControl = TRUE
|
|
ELSE
|
|
// restore control
|
|
IF flyPlaneState = FLY_PLANE_POST_ENGINE
|
|
iAddControlTime = GET_RANDOM_INT_IN_RANGE(1000, 1600)//iAddControlTime = GET_RANDOM_INT_IN_RANGE(1000, 1800)
|
|
// SET_PLAYER_CONTROL(PLAYER_ID(), TRUE)
|
|
bCutOutControl = FALSE
|
|
ELSE
|
|
iAddControlTime = GET_RANDOM_INT_IN_RANGE(800, 1100)
|
|
ENDIF
|
|
ENDIF
|
|
|
|
SET_CONTROL_SHAKE(PLAYER_CONTROL, 1000, PAD_SHAKE_AMPLITUDE)
|
|
DO_MISSION_GAMEPLAY_CAM_SHAKE()
|
|
iCutOutControlTime = GET_GAME_TIMER() + iAddControlTime
|
|
ENDIF
|
|
ENDIF
|
|
|
|
// handle jet attack
|
|
HANDLE_JET_ATTACK()
|
|
|
|
// handle missiles
|
|
HANDLE_MISSILES()
|
|
|
|
IF flyPlaneState >= FLY_PLANE_POST_ENGINE
|
|
HANDLE_KLAXON_SOUND(TRUE)
|
|
ENDIF
|
|
|
|
// handle mishaps on plane
|
|
// rudder off
|
|
IF NOT bDoneRudderFallOff
|
|
IF jetMissile[1].state = JET_MISSILE_STATE_EXPLODED
|
|
SET_VEHICLE_CAN_BREAK(planeFightVehicle[PFV_CARGO_PLANE], TRUE)
|
|
SET_VEHICLE_RUDDER_BROKEN(planeFightVehicle[PFV_CARGO_PLANE], FALSE)
|
|
iNextCheckCrashTime = GET_GAME_TIMER() + 5000
|
|
bDoneRudderFallOff = TRUE
|
|
ENDIF
|
|
ELSE
|
|
IF NOT bResetPlaneBreak
|
|
SET_VEHICLE_CAN_BREAK(planeFightVehicle[PFV_CARGO_PLANE], FALSE)
|
|
bResetPlaneBreak = TRUE
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF jetMissile[0].state = JET_MISSILE_STATE_EXPLODED
|
|
OR jetMissile[1].state = JET_MISSILE_STATE_EXPLODED
|
|
OR jetMissile[2].state = JET_MISSILE_STATE_EXPLODED
|
|
OR jetMissile[3].state = JET_MISSILE_STATE_EXPLODED
|
|
IF NOT bDoneEngineBlowSpeech
|
|
//bDoneEngineBlowSpeech = DO_MISSION_SPEECH("EXL1_DAMAGE")
|
|
bDoneEngineBlowSpeech = DO_MISSION_SPEECH("EXL1_IMHIT")
|
|
ENDIF
|
|
ENDIF
|
|
|
|
SWITCH flyPlaneState
|
|
CASE FLY_PLANE_FINE
|
|
IF jetMissile[3].state = JET_MISSILE_STATE_EXPLODED
|
|
//ADD_EXPLOSION(GET_OFFSET_FROM_ENTITY_IN_WORLD_COORDS(planeFightVehicle[PFV_CARGO_PLANE], GET_PLANE_FIGHT_VECTOR(PFVEC_ENGINE_OFFSET)), EXP_TAG_GRENADE, 1.0)
|
|
APPLY_FORCE_TO_ENTITY(planeFightVehicle[PFV_CARGO_PLANE], APPLY_TYPE_IMPULSE, <<0,0,5>>, <<10, 0, 0>>, 0, TRUE, TRUE, TRUE)
|
|
SET_CONTROL_SHAKE(PLAYER_CONTROL, 1000, 200)
|
|
DO_MISSION_GAMEPLAY_CAM_SHAKE()
|
|
DO_SMOKE_ON_PLANE(PLANE_SMOKE_ENGINE_EXPLOSION)
|
|
DO_SMOKE_ON_PLANE(PLANE_SMOKE_ENGINE_FIRE)
|
|
//DO_SMOKE_ON_PLANE(PLANE_SMOKE_FIRE_REAR_MOVING)
|
|
|
|
START_PLANE_FIGHT_AUDIO_SCENE(PLANE_FIGHT_AUDIO_SCENE_PLANE_GOING_DOWN)
|
|
|
|
iBlowEngineTime = GET_GAME_TIMER()
|
|
iCutOutControlTime = GET_GAME_TIMER() + 1200
|
|
REPLAY_RECORD_BACK_FOR_TIME(3.0)
|
|
flyPlaneState = FLY_PLANE_POST_ENGINE
|
|
ENDIF
|
|
BREAK
|
|
CASE FLY_PLANE_POST_ENGINE
|
|
IF NOT bStoppedRocketsScene
|
|
IF GET_GAME_TIMER() >= iBlowEngineTime + 2000
|
|
STOP_PLANE_FIGHT_AUDIO_SCENE(PLANE_FIGHT_AUDIO_SCENE_ROCKETS_FIRED)
|
|
ENDIF
|
|
ENDIF
|
|
|
|
BOOL bAdvanceStage
|
|
bAdvanceStage = FALSE
|
|
IF GET_GAME_TIMER() >= iBlowEngineTime + 13000 AND vPlanePos.z >= PLANE_CLIMB_HEIGHT_HIGH
|
|
SET_CONTROL_SHAKE(PLAYER_CONTROL, 1000, 200)
|
|
DO_MISSION_GAMEPLAY_CAM_SHAKE()
|
|
bAdvanceStage = TRUE
|
|
ELIF IS_CONTROL_JUST_PRESSED(PLAYER_CONTROL, INPUT_VEH_EXIT) AND vPlanePos.z >= PLANE_CLIMB_HEIGHT_LOW
|
|
bDoneRearExplosionSpeech = TRUE
|
|
bAdvanceStage = TRUE
|
|
ENDIF
|
|
|
|
IF bAdvanceStage
|
|
STOP_PLANE_FIGHT_AUDIO_SCENE(PLANE_FIGHT_AUDIO_SCENE_ROCKETS_FIRED)
|
|
PRELOAD_PARACHUTE()
|
|
REMOVE_MISSION_TEXT(FALSE, TRUE, FALSE)
|
|
iBlowEngineTime = GET_GAME_TIMER()
|
|
iCutOutControlTime = 0
|
|
bCutOutControl = FALSE
|
|
flyPlaneState = FLY_PLANE_POST_FIREBALL
|
|
ENDIF
|
|
BREAK
|
|
CASE FLY_PLANE_POST_FIREBALL
|
|
IF NOT bDoneRearExplosionSpeech
|
|
// bDoneRearExplosionSpeech = DO_MISSION_SPEECH("EXL1_EXP1")
|
|
bDoneRearExplosionSpeech = DO_MISSION_SPEECH("EXL1_BRKPLAN")
|
|
ELSE
|
|
IF NOT bDoneFindParachuteSpeech
|
|
//bDoneFindParachuteSpeech = DO_MISSION_SPEECH("EXL1_LPARA")
|
|
bDoneFindParachuteSpeech = DO_MISSION_SPEECH("EXL1_ANGPAR")
|
|
IF bDoneFindParachuteSpeech
|
|
REPLAY_RECORD_BACK_FOR_TIME(8.0, 10.0, REPLAY_IMPORTANCE_HIGHEST)
|
|
ENDIF
|
|
ELSE
|
|
IF NOT bDoneGotParachuteSpeech
|
|
//bDoneGotParachuteSpeech = DO_MISSION_SPEECH("EXL1_LPARA2")
|
|
bDoneGotParachuteSpeech = DO_MISSION_SPEECH("EXL1_ANGPAR2")
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF bCutOutControl
|
|
VECTOR vPlaneRot
|
|
vPlaneRot = GET_ENTITY_ROTATION(planeFightVehicle[PFV_CARGO_PLANE])
|
|
IF vPlaneRot.x >= -20
|
|
AND fHeightAboveGround >= 65.0
|
|
APPLY_FORCE_TO_ENTITY(planeFightVehicle[PFV_CARGO_PLANE], APPLY_TYPE_FORCE, <<0,0,18>>, <<0, -18, 0>>, 0, TRUE, TRUE, TRUE) //28
|
|
APPLY_FORCE_TO_ENTITY(planeFightVehicle[PFV_CARGO_PLANE], APPLY_TYPE_FORCE, <<0,0,-18>>, <<0, 18, 0>>, 0, TRUE, TRUE, TRUE) //28
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF GET_GAME_TIMER() >= iBlowEngineTime + 4800//3500//4200//5000
|
|
//OR (fHeightAboveGround < PLANE_CLIMB_HEIGHT AND GET_GAME_TIMER() >= iBlowEngineTime + 1300)
|
|
//IF HAS_CUTSCENE_LOADED()
|
|
IF NOT IS_ANY_CONVERSATION_ONGOING_OR_QUEUED()
|
|
IF NOT bSetPack
|
|
GIVE_TREVOR_PARACHUTE_BACKPACK()
|
|
SET_PED_RESET_FLAG(PLAYER_PED_ID(), PRF_DisableTakeOffParachutePack, TRUE)
|
|
REMOVE_PED_HELMET(PLAYER_PED_ID(), TRUE)
|
|
//CLEAR_PED_PROP(PLAYER_PED_ID(), ANCHOR_HEAD)
|
|
bSetPack = TRUE
|
|
ELSE
|
|
GIVE_TREVOR_PARACHUTE_BACKPACK()
|
|
SET_CONTROL_SHAKE(PLAYER_CONTROL, 10, PAD_SHAKE_AMPLITUDE)
|
|
iDoCutscene = 1
|
|
REMOVE_PED_HELMET(PLAYER_PED_ID(), TRUE)
|
|
SET_PED_RESET_FLAG(PLAYER_PED_ID(), PRF_DisableTakeOffParachutePack, TRUE)
|
|
SET_MISSION_STAGE(STAGE_ESCAPE_PLANE)
|
|
ENDIF
|
|
|
|
ENDIF
|
|
//ENDIF
|
|
ENDIF
|
|
BREAK
|
|
ENDSWITCH
|
|
|
|
// mega temp
|
|
//IF IS_ENTITY_AT_COORD(planeFightVehicle[PFV_CARGO_PLANE], GET_PLANE_FIGHT_VECTOR(PFVEC_RUNWAY), <<600,600,600>>, FALSE, FALSE)
|
|
// SET_MISSION_STAGE(STAGE_ESCAPE_PLANE)
|
|
//ENDIF
|
|
|
|
// wave down cutscene
|
|
IF NOT bDoneWaveDownCutscene
|
|
#IF IS_DEBUG_BUILD
|
|
IF IS_KEYBOARD_KEY_JUST_PRESSED(KEY_NUMPAD1)
|
|
IF jetAttackState >= JET_ATTACK_FLY_TO_PLANE
|
|
iDoCutscene = 0
|
|
bRunningCutscene = TRUE
|
|
ENDIF
|
|
ENDIF
|
|
#ENDIF
|
|
IF jetAttackState = JET_ATTACK_ESCORT
|
|
IF IS_VEHICLE_DRIVEABLE(jetData[1].veh)
|
|
BOOL bCanRunWaveDownCutscene = FALSE
|
|
SWITCH shapeTestState
|
|
CASE SHAPE_TEST_STATE_NOT_STARTED
|
|
//PRINTSTRING("start shape test") printnl()
|
|
VECTOR vTestFrom
|
|
vTestFrom = GET_ENTITY_COORDS(planeRootObject)
|
|
VECTOR vTestTo
|
|
vTestTo = GET_OFFSET_FROM_ENTITY_IN_WORLD_COORDS(planeRootObject, <<0,500,0>>)
|
|
vTestTo.z = vTestFrom.z
|
|
planeShapeTest = START_SHAPE_TEST_CAPSULE(vTestFrom, vTestTo, 50, SCRIPT_INCLUDE_MOVER, planeFightVehicle[PFV_CARGO_PLANE])
|
|
shapeTestState = SHAPE_TEST_STATE_WAITING
|
|
BREAK
|
|
CASE SHAPE_TEST_STATE_WAITING
|
|
//PRINTSTRING("waiting on shape test") printnl()
|
|
SHAPETEST_STATUS shapeTestResult
|
|
INT iHitSomething
|
|
VECTOR vPos
|
|
VECTOR vNormal
|
|
ENTITY_INDEX hitEntity
|
|
shapeTestResult = GET_SHAPE_TEST_RESULT(planeShapeTest, iHitSomething, vPos, vNormal, hitEntity)
|
|
IF shapeTestResult = SHAPETEST_STATUS_RESULTS_READY
|
|
//PRINTSTRING("shape test results ready") printnl()
|
|
IF iHitSomething = 0
|
|
//PRINTSTRING("didn't hit!") printnl()
|
|
bCanRunWaveDownCutscene = TRUE
|
|
shapeTestState = SHAPE_TEST_STATE_NOT_STARTED
|
|
ELSE
|
|
//PRINTSTRING("hit something!") printnl()
|
|
shapeTestState = SHAPE_TEST_STATE_NOT_STARTED
|
|
ENDIF
|
|
ELIF shapeTestResult = SHAPETEST_STATUS_NONEXISTENT
|
|
//PRINTSTRING("reset shape test") printnl()
|
|
shapeTestState = SHAPE_TEST_STATE_NOT_STARTED
|
|
ENDIF
|
|
BREAK
|
|
ENDSWITCH
|
|
|
|
//IF IS_ENTITY_AT_COORD(jetData[1].veh, GET_OFFSET_FROM_ENTITY_IN_WORLD_COORDS(planeFightVehicle[PFV_CARGO_PLANE], <<0,20,0>>), <<40,40,40>>)
|
|
|
|
//PRINTVECTOR( GET_ENTITY_ROTATION(planeFightVehicle[PFV_CARGO_PLANE])) PRINTNL()
|
|
IF bJetAlongsideCabin
|
|
AND bCanRunWaveDownCutscene
|
|
VECTOR vPlaneRotForCut
|
|
vPlaneRotForCut = GET_ENTITY_ROTATION(planeFightVehicle[PFV_CARGO_PLANE])
|
|
IF DO_PLANE_HEADINGS_MATCH(jetData[1].veh, planeFightVehicle[PFV_CARGO_PLANE], 45)
|
|
AND (vPlaneRotForCut.x < 25 AND vPlaneRotForCut.x > -25 AND vPlaneRotForCut.y < 30 AND vPlaneRotForCut.y > -30)
|
|
IF bDoneJetReactSpeech
|
|
AND bDoneRonShakeJetsSpeech
|
|
IF NOT IS_ANY_CONVERSATION_ONGOING_OR_QUEUED()
|
|
IF CAN_ADVANCE_MISSION()
|
|
iDoCutscene = 0
|
|
bRunningCutscene = TRUE
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
|
|
// temp!
|
|
/*
|
|
IF GET_GAME_TIMER() >= iJetSetStateTime + 15000
|
|
IF bDoneJetReactSpeech
|
|
AND bDoneRonShakeJetsSpeech
|
|
IF NOT IS_ANY_CONVERSATION_ONGOING_OR_QUEUED()
|
|
IF CAN_ADVANCE_MISSION()
|
|
iDoCutscene = 0
|
|
bRunningCutscene = TRUE
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
*/
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF (GET_GAME_TIMER() >= iNextCheckCrashTime
|
|
AND GET_GAME_TIMER() >= iFlightTime + 3000)
|
|
OR bForceExplode
|
|
IF NOT IS_ENTITY_IN_AIR(planeFightVehicle[PFV_CARGO_PLANE])
|
|
AND HAS_ENTITY_COLLIDED_WITH_ANYTHING(planeFightVehicle[PFV_CARGO_PLANE])
|
|
OR bForceExplode
|
|
//INT i
|
|
|
|
/*
|
|
BOOL bTouchingObject = FALSE
|
|
REPEAT COUNT_OF(jetData) i
|
|
IF IS_VEHICLE_DRIVEABLE(jetData[i].veh)
|
|
IF IS_ENTITY_TOUCHING_ENTITY(planeFightVehicle[PFV_CARGO_PLANE], jetData[i].veh)
|
|
bTouchingObject = TRUE
|
|
ENDIF
|
|
ENDIF
|
|
ENDREPEAT
|
|
|
|
REPEAT COUNT_OF(jetMissile) i
|
|
IF DOES_ENTITY_EXIST(jetMissile[i].obj)
|
|
IF IS_ENTITY_TOUCHING_ENTITY(planeFightVehicle[PFV_CARGO_PLANE], jetMissile[i].obj)
|
|
bTouchingObject = TRUE
|
|
ENDIF
|
|
ENDIF
|
|
ENDREPEAT
|
|
*/
|
|
|
|
//IF NOT bTouchingObject
|
|
//OR bForceExplode
|
|
// EXPLODE_VEHICLE(planeFightVehicle[PFV_CARGO_PLANE])
|
|
//ELSE
|
|
// iNextCheckCrashTime = GET_GAME_TIMER() + 1000
|
|
//ENDIF
|
|
|
|
SET_ENTITY_ONLY_DAMAGED_BY_PLAYER(planeFightVehicle[PFV_CARGO_PLANE], FALSE)
|
|
SET_ENTITY_PROOFS(planeFightVehicle[PFV_CARGO_PLANE], FALSE, FALSE, FALSE, FALSE, FALSE)
|
|
SET_VEHICLE_CAN_BREAK(planeFightVehicle[PFV_CARGO_PLANE], TRUE)
|
|
SET_VEHICLE_CAN_BE_VISIBLY_DAMAGED(planeFightVehicle[PFV_CARGO_PLANE], TRUE)
|
|
SET_VEHICLE_ENGINE_CAN_DEGRADE(planeFightVehicle[PFV_CARGO_PLANE], TRUE)
|
|
SET_VEHICLE_EXPLODES_ON_HIGH_EXPLOSION_DAMAGE(planeFightVehicle[PFV_CARGO_PLANE], TRUE)
|
|
bStartExplodeCounter = TRUE
|
|
IF bForceExplode
|
|
EXPLODE_VEHICLE(planeFightVehicle[PFV_CARGO_PLANE])
|
|
ENDIF
|
|
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF bStartExplodeCounter
|
|
fExplodeCounter = fExplodeCounter +@ 1.0
|
|
IF fExplodeCounter >= 2.0
|
|
EXPLODE_VEHICLE(planeFightVehicle[PFV_CARGO_PLANE])
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ELSE
|
|
IF iDoCutscene = 0
|
|
DO_WAVE_DOWN_CUTSCENE()
|
|
ELSE
|
|
//DO_ESCAPE_CUTSCENE()
|
|
ENDIF
|
|
ENDIF
|
|
ENDPROC
|
|
|
|
// crash cutscene
|
|
PROC DO_CRASH_INTO_SEA_CUTSCENE()
|
|
SWITCH cutsceneStage
|
|
CASE PF_CUT_STAGE_INIT
|
|
SET_MISSION_CUTSCENE(TRUE)
|
|
STOP_SMOKE_ON_PLANE(PLANE_SMOKE_HOLD_WIRES_1)
|
|
STOP_SMOKE_ON_PLANE(PLANE_SMOKE_HOLD_WIRES_2)
|
|
STOP_SMOKE_ON_PLANE(PLANE_SMOKE_CRASH_SMOKE_R1, TRUE)
|
|
STOP_SMOKE_ON_PLANE(PLANE_SMOKE_ENGINE_FIRE, TRUE)
|
|
|
|
SET_PLAYER_OUT_OF_ANY_VEHICLE()
|
|
|
|
INT i
|
|
REPEAT COUNT_OF(transportedVehicle) i
|
|
IF DOES_ENTITY_EXIST(transportedVehicle[i].veh)
|
|
DELETE_VEHICLE(transportedVehicle[i].veh)
|
|
ENDIF
|
|
ENDREPEAT
|
|
|
|
REPEAT COUNT_OF(coverObject) i
|
|
IF DOES_ENTITY_EXIST(coverObject[i].obj)
|
|
DELETE_OBJECT(coverObject[i].obj)
|
|
ENDIF
|
|
ENDREPEAT
|
|
|
|
REPEAT COUNT_OF(enemyData) i
|
|
IF DOES_ENTITY_EXIST(enemyData[i].ped)
|
|
DELETE_PED(enemyData[i].ped)
|
|
ENDIF
|
|
ENDREPEAT
|
|
|
|
SET_LIGHT_RIG_ON_CARGO_PLANE(FALSE)
|
|
|
|
IF IS_VEHICLE_DRIVEABLE(planeFightVehicle[PFV_CARGO_PLANE])
|
|
FREEZE_ENTITY_POSITION(planeFightVehicle[PFV_CARGO_PLANE], FALSE)
|
|
IF IS_PLAYBACK_GOING_ON_FOR_VEHICLE(planeFightVehicle[PFV_CARGO_PLANE])
|
|
STOP_PLAYBACK_RECORDED_VEHICLE(planeFightVehicle[PFV_CARGO_PLANE])
|
|
ENDIF
|
|
|
|
START_PLAYBACK_RECORDED_VEHICLE(planeFightVehicle[PFV_CARGO_PLANE], 006, GET_PLANE_FIGHT_RECORDING_PREFIX())
|
|
SKIP_TIME_IN_PLAYBACK_RECORDED_VEHICLE(planeFightVehicle[PFV_CARGO_PLANE], 37600)
|
|
FORCE_PLAYBACK_RECORDED_VEHICLE_UPDATE(planeFightVehicle[PFV_CARGO_PLANE])
|
|
SET_PLAYBACK_SPEED(planeFightVehicle[PFV_CARGO_PLANE], 1.0)
|
|
STOP_STREAM()
|
|
|
|
PLAY_SOUND_FROM_ENTITY(-1, "Pt2_Fail", planeFightVehicle[PFV_CARGO_PLANE], "exile_1")
|
|
|
|
DO_SMOKE_ON_PLANE(PLANE_SMOKE_SPEW_DEBRIS)
|
|
DO_SMOKE_ON_PLANE(PLANE_SMOKE_ENGINE_FIRE)
|
|
ENDIF
|
|
|
|
IF NOT IS_PED_INJURED(PLAYER_PED_ID())
|
|
SET_ENTITY_COORDS(PLAYER_PED_ID(), <<38.74771, 3802.38574, 30.71010>>)
|
|
SET_ENTITY_HEADING(PLAYER_PED_ID(), -25.7)
|
|
SET_GAMEPLAY_CAM_RELATIVE_HEADING()
|
|
ENDIF
|
|
|
|
CREATE_CAM_FOR_PLANE_FIGHT_SHOT(PF_SHOT_CRASH_INTO_SEA, TRUE, 2100)
|
|
SHAKE_CAM(staticCam, "HAND_SHAKE", 0.6)
|
|
iPlaneFightCutsceneTime = GET_GAME_TIMER()
|
|
|
|
cutsceneStage = PF_CUT_STAGE_RUNNING
|
|
BREAK
|
|
|
|
CASE PF_CUT_STAGE_RUNNING
|
|
//IF GET_GAME_TIMER() >= iPlaneFightCutsceneTime + 15
|
|
//
|
|
//ENDIF
|
|
|
|
IF NOT bDoneExplodePlaneVFX
|
|
IF IS_VEHICLE_DRIVEABLE(planeFightVehicle[PFV_CARGO_PLANE])
|
|
IF GET_TIME_POSITION_IN_RECORDING(planeFightVehicle[PFV_CARGO_PLANE]) >= 39600
|
|
SHAKE_CAM(interpCam, "LARGE_EXPLOSION_SHAKE", 0.25)
|
|
DO_SMOKE_ON_PLANE(PLANE_SMOKE_GROUND_EXPLOSION)
|
|
DO_SMOKE_ON_PLANE(PLANE_SMOKE_GROUND_DUST_IMPACT)
|
|
DO_SMOKE_ON_PLANE(PLANE_SMOKE_GROUND_DUST_SETTLE)
|
|
bDoneExplodePlaneVFX = TRUE
|
|
cutsceneStage = PF_CUT_STAGE_CLEANUP
|
|
MISSION_FAILED(FAIL_TREVOR_DEAD)
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
BREAK
|
|
|
|
CASE PF_CUT_STAGE_CLEANUP
|
|
IF bSkippedCutscene
|
|
ENDIF
|
|
|
|
IF IS_SCREEN_FADED_OUT()
|
|
IF DOES_ENTITY_EXIST(planeFightVehicle[PFV_CARGO_PLANE])
|
|
DELETE_VEHICLE(planeFightVehicle[PFV_CARGO_PLANE])
|
|
ENDIF
|
|
ENDIF
|
|
|
|
bDonePlaneCrashWithTrevor = TRUE
|
|
|
|
BREAK
|
|
ENDSWITCH
|
|
ENDPROC
|
|
|
|
// freefall to grab parachute and get to safety
|
|
PROC DO_STAGE_ESCAPE_PLANE()
|
|
IF NOT bRunningCutscene
|
|
//VECTOR vPlayerPos = GET_ENTITY_COORDS(PLAYER_PED_ID())
|
|
PED_PARACHUTE_STATE parachuteState = GET_PED_PARACHUTE_STATE(PLAYER_PED_ID())
|
|
|
|
IF NOT bForcePassOnShitskip
|
|
|
|
IF NOT bLoadedWindStream
|
|
bLoadedWindStream = LOAD_STREAM("Plane_Wind_Pt2", "EXILE_1")
|
|
ELSE
|
|
IF NOT bPlayingWindStream
|
|
PLAY_STREAM_FROM_POSITION(<<1903.29, 4085.20, 1462.66>>)
|
|
bPlayingWindStream = TRUE
|
|
ELSE
|
|
IF NOT bStoppedWindStream
|
|
SET_VARIABLE_ON_STREAM("INOUT", (fProportionUpPlane - 1) * -1)
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF NOT bPreparedJumpCue
|
|
bPreparedJumpCue = PREPARE_MUSIC_EVENT("EXL1_JUMPED")
|
|
ENDIF
|
|
|
|
// windy
|
|
SET_WIND(1.0)
|
|
SET_WIND_SPEED(11.99)
|
|
SET_WIND_DIRECTION(2.92)
|
|
|
|
IF NOT bSetTransportedVehiclesPhysical
|
|
//IF GET_GAME_TIMER() >= iStartEscapeTime + 1000
|
|
//ATTACH_TRANSPORTED_VEHICLES(TRUE)
|
|
bSetTransportedVehiclesPhysical = TRUE
|
|
//ENDIF
|
|
ENDIF
|
|
|
|
IF NOT bRestoredControl
|
|
IF GET_GAME_TIMER() >= iStartEscapeTime + 300
|
|
SET_PED_CAN_RAGDOLL(PLAYER_PED_ID(), TRUE)
|
|
SET_PLAYER_CONTROL(PLAYER_ID(), TRUE)
|
|
SET_ENTITY_PROOFS(PLAYER_PED_ID(), FALSE, FALSE, FALSE, TRUE, FALSE) // temp?
|
|
bRestoredControl = TRUE
|
|
ENDIF
|
|
|
|
IF GET_FOLLOW_PED_CAM_VIEW_MODE() <> CAM_VIEW_MODE_FIRST_PERSON
|
|
SET_PED_MIN_MOVE_BLEND_RATIO(PLAYER_PED_ID(), PEDMOVE_RUN)
|
|
ENDIF
|
|
ELSE
|
|
|
|
ENDIF
|
|
|
|
//PRINTSTRING("para state = ") PRINTINT(ENUM_TO_INT(parachuteState)) PRINTNL()
|
|
IF NOT bUsedParachute
|
|
IF parachuteState >= PPS_DEPLOYING
|
|
STOP_PLANE_FIGHT_AUDIO_SCENE(PLANE_FIGHT_AUDIO_SCENE_SKYDIVE)
|
|
START_PLANE_FIGHT_AUDIO_SCENE(PLANE_FIGHT_AUDIO_SCENE_DEPLOY_PARACHUTE)
|
|
iOpenedParachuteTime = GET_GAME_TIMER()
|
|
bUsedParachute = TRUE
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF NOT bStartedFreefallTimer
|
|
IF parachuteState = PPS_SKYDIVING
|
|
INFORM_MISSION_STATS_SYSTEM_OF_TIME_WINDOW_OPEN(EXL1_FREEFALL_TIME)
|
|
bStartedFreefallTimer = TRUE
|
|
ENDIF
|
|
ELSE
|
|
IF NOT bStoppedFreefallTimer
|
|
IF parachuteState <> PPS_SKYDIVING
|
|
INFORM_MISSION_STATS_SYSTEM_OF_TIME_WINDOW_CLOSED()
|
|
bStoppedFreefallTimer = TRUE
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
|
|
// music
|
|
IF bTriggeredJumpToParachute
|
|
OR bDoneOutOfPlane
|
|
IF NOT bDoneJumpCue
|
|
IF bPreparedJumpCue
|
|
bDoneJumpCue = TRIGGER_MISSION_MUSIC_EVENT("EXL1_JUMPED")
|
|
ELSE
|
|
bDoneJumpCue = TRUE
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF IS_VEHICLE_DRIVEABLE(transportedVehicle[TRANSPORTED_VEHICLE_INDEX_4WD_DRIVE].veh)
|
|
IF IS_PED_IN_VEHICLE(PLAYER_PED_ID(), transportedVehicle[TRANSPORTED_VEHICLE_INDEX_4WD_DRIVE].veh)
|
|
IF NOT bDoneCarEscapeAudioScene
|
|
bDoneCarEscapeAudioScene = START_PLANE_FIGHT_AUDIO_SCENE(PLANE_FIGHT_AUDIO_SCENE_ESCAPE_IN_CAR)
|
|
ENDIF
|
|
|
|
IF NOT bInCarCollisionProof
|
|
SET_ENTITY_PROOFS(PLAYER_PED_ID(), FALSE, FALSE, FALSE, TRUE, FALSE)
|
|
bInCarCollisionProof = TRUE
|
|
ENDIF
|
|
|
|
iOutOfVehicleTime = GET_GAME_TIMER() + 2000
|
|
ELSE
|
|
IF bInCarCollisionProof
|
|
IF GET_GAME_TIMER() >= iOutOfVehicleTime
|
|
OR GET_ENTITY_HEIGHT_ABOVE_GROUND(PLAYER_PED_ID()) < 20
|
|
SET_ENTITY_PROOFS(PLAYER_PED_ID(), FALSE, FALSE, FALSE, FALSE, FALSE)
|
|
bInCarCollisionProof = FALSE
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF bDoneCarEscapeAudioScene
|
|
STOP_PLANE_FIGHT_AUDIO_SCENE(PLANE_FIGHT_AUDIO_SCENE_ESCAPE_IN_CAR)
|
|
bDoneCarEscapeAudioScene = FALSE
|
|
ENDIF
|
|
ENDIF
|
|
|
|
VECTOR v4wdPos = GET_ENTITY_COORDS(transportedVehicle[TRANSPORTED_VEHICLE_INDEX_4WD_DRIVE].veh)
|
|
IF v4wdPos.z <= 1400
|
|
FLOAT fDummy
|
|
IF HAS_ENTITY_COLLIDED_WITH_ANYTHING(transportedVehicle[TRANSPORTED_VEHICLE_INDEX_4WD_DRIVE].veh)
|
|
AND NOT IS_ENTITY_IN_AIR(transportedVehicle[TRANSPORTED_VEHICLE_INDEX_4WD_DRIVE].veh)
|
|
AND NOT IS_ENTITY_ATTACHED(transportedVehicle[TRANSPORTED_VEHICLE_INDEX_4WD_DRIVE].veh)
|
|
AND (GET_HEIGHT_ABOVE_GROUND(transportedVehicle[TRANSPORTED_VEHICLE_INDEX_4WD_DRIVE].veh, fDummy) < 3 OR IS_ENTITY_IN_WATER(transportedVehicle[TRANSPORTED_VEHICLE_INDEX_4WD_DRIVE].veh))
|
|
STOP_SOUND(iCarFallSoundID)
|
|
EXPLODE_VEHICLE(transportedVehicle[TRANSPORTED_VEHICLE_INDEX_4WD_DRIVE].veh)
|
|
ENDIF
|
|
ENDIF
|
|
ELSE
|
|
IF bInCarCollisionProof
|
|
SET_ENTITY_PROOFS(PLAYER_PED_ID(), FALSE, FALSE, FALSE, FALSE, FALSE)
|
|
bInCarCollisionProof = FALSE
|
|
ENDIF
|
|
|
|
IF DOES_ENTITY_EXIST(transportedVehicle[TRANSPORTED_VEHICLE_INDEX_4WD_DRIVE].veh)
|
|
IF IS_ENTITY_DEAD(transportedVehicle[TRANSPORTED_VEHICLE_INDEX_4WD_DRIVE].veh)
|
|
IF IS_PED_IN_ANY_VEHICLE(PLAYER_PED_ID())
|
|
IF GET_VEHICLE_PED_IS_IN(PLAYER_PED_ID()) = transportedVehicle[TRANSPORTED_VEHICLE_INDEX_4WD_DRIVE].veh
|
|
APPLY_DAMAGE_TO_PED(PLAYER_PED_ID(), 1000, TRUE)
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF bDoneCarEscapeAudioScene
|
|
STOP_PLANE_FIGHT_AUDIO_SCENE(PLANE_FIGHT_AUDIO_SCENE_ESCAPE_IN_CAR)
|
|
bDoneCarEscapeAudioScene = FALSE
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF NOT bDoneOutOfPlane
|
|
DISABLE_GAMEPLAY_CAM_ALTITUDE_FOV_SCALING_THIS_UPDATE()
|
|
SET_PED_RESET_FLAG(PLAYER_PED_ID(), PRF_DisableTakeOffParachutePack, TRUE)
|
|
REPLAY_DISABLE_CAMERA_MOVEMENT_THIS_FRAME()
|
|
|
|
IF IS_VEHICLE_DRIVEABLE(planeFightVehicle[PFV_CARGO_PLANE])
|
|
SET_FORCE_HD_VEHICLE(planeFightVehicle[PFV_CARGO_PLANE], TRUE)
|
|
ENDIF
|
|
|
|
IF GET_GAME_TIMER() >= iNextShakeTime
|
|
SET_CONTROL_SHAKE(PLAYER_CONTROL, GET_RANDOM_INT_IN_RANGE(500, 1200), PAD_SHAKE_AMPLITUDE)
|
|
DO_MISSION_GAMEPLAY_CAM_SHAKE()
|
|
iNextShakeTime = GET_GAME_TIMER() + GET_RANDOM_INT_IN_RANGE(1500, 3000)
|
|
ENDIF
|
|
|
|
IF IS_VEHICLE_DRIVEABLE(planeFightVehicle[PFV_CARGO_PLANE])
|
|
VECTOR vPlanePos = GET_ENTITY_COORDS(planeFightVehicle[PFV_CARGO_PLANE])
|
|
SET_RADAR_AS_INTERIOR_THIS_FRAME(GET_HASH_KEY("V_FakeCargoPlaneDive"), vPlanePos.x, vPlanePos.y, FLOOR(GET_ENTITY_HEADING(planeFightVehicle[PFV_CARGO_PLANE])), 0)
|
|
SET_RADAR_ZOOM_PRECISE(1)
|
|
ENDIF
|
|
|
|
//IF NOT bForcePassOnShitskip
|
|
// DO_RANDOM_SPEECH("EXL1_FIGHT")
|
|
//ENDIF
|
|
|
|
DO_COMMON_PLANE_FUNCTIONS()
|
|
DO_PLANE_SETPIECES(STAGE_ESCAPE_PLANE)
|
|
|
|
IF NOT bDoneGotoSpeech
|
|
//bDoneGotoSpeech = DO_MISSION_SPEECH("EXL1_ABAN")
|
|
bDoneGotoSpeech = TRUE
|
|
ELSE
|
|
IF NOT bShownGodText
|
|
IF NOT bForcePassOnShitskip
|
|
bShownGodText = DO_MISSION_GOD_TEXT("PF_JUMP")
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF NOT bTriggeredJumpToParachute
|
|
IF vPlayerOffsetFromPlane.y <= -23.0
|
|
IF NOT IS_PED_IN_ANY_VEHICLE(PLAYER_PED_ID())
|
|
IF IS_PED_AT_CORRECT_HEADING(PLAYER_PED_ID(), GET_ENTITY_HEADING(planeFightVehicle[PFV_CARGO_PLANE]) - 180)
|
|
IF GET_ENTITY_SPEED(PLAYER_PED_ID()) >= 3.2
|
|
|
|
TASK_PLAY_ANIM(PLAYER_PED_ID(), GET_PLANE_FIGHT_ANIM_DICT_AS_STRING(PF_ANIM_DICT_TO_PARACHUTE), "jump_launch_l_to_skydive", NORMAL_BLEND_IN, NORMAL_BLEND_OUT, -1, AF_FORCE_START | AF_NOT_INTERRUPTABLE | AF_HOLD_LAST_FRAME | AF_TAG_SYNC_IN | AF_TAG_SYNC_OUT)
|
|
iJumpToParachuteTime = GET_GAME_TIMER()
|
|
bTriggeredJumpToParachute = TRUE
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
|
|
// handle plane
|
|
IF fTimeAtHatch < 0
|
|
IF vPlayerOffsetFromPlane.y <= -20.0
|
|
fTimeAtHatch = 0.0
|
|
ENDIF
|
|
ELSE
|
|
IF NOT bTriggeredJumpToParachute
|
|
fTimeAtHatch = fTimeAtHatch +@ 1.0
|
|
printstring("time at hatch = ") printfloat(fTimeAtHatch) PRINTNL()
|
|
IF fTimeAtHatch >= 1.2
|
|
HANDLE_PLANE_FALLING()
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF vPlayerOffsetFromPlane.y <= JUMP_OFF_Y
|
|
OR vPlayerOffsetFromPlane.z <= -JUMP_OFF_Z
|
|
OR vPlayerOffsetFromPlane.z >= JUMP_OFF_Z
|
|
OR bTriggeredJumpToParachute
|
|
// handle jump off
|
|
IF IS_VEHICLE_DRIVEABLE(transportedVehicle[TRANSPORTED_VEHICLE_INDEX_4WD_DRIVE].veh)
|
|
IF NOT transportedVehicle[TRANSPORTED_VEHICLE_INDEX_4WD_DRIVE].bDetached
|
|
SET_VEHICLE_IS_CONSIDERED_BY_PLAYER(transportedVehicle[TRANSPORTED_VEHICLE_INDEX_4WD_DRIVE].veh, FALSE)
|
|
ATTACH_TRANSPORTED_VEHICLES(FALSE)
|
|
ENDIF
|
|
ENDIF
|
|
SET_CONTROL_SHAKE(PLAYER_CONTROL, 10, PAD_SHAKE_AMPLITUDE)
|
|
iStoredPlayerHealth = GET_ENTITY_HEALTH(PLAYER_PED_ID())
|
|
|
|
|
|
IF IS_PED_IN_ANY_VEHICLE(PLAYER_PED_ID())
|
|
SET_ENTITY_PROOFS(PLAYER_PED_ID(), FALSE, FALSE, FALSE, TRUE, FALSE) // temp?
|
|
INFORM_STAT_SYSTEM_OF_BOOL_STAT_HAPPENED(EXL1_BAIL_IN_CAR)
|
|
ELSE
|
|
SET_ENTITY_PROOFS(PLAYER_PED_ID(), FALSE, FALSE, FALSE, FALSE, FALSE) // temp?
|
|
ENDIF
|
|
|
|
IF STREAMVOL_IS_VALID(hillsStreamingVolume)
|
|
STREAMVOL_DELETE(hillsStreamingVolume)
|
|
ENDIF
|
|
|
|
SET_VEHICLE_INTERIORLIGHT(planeFightVehicle[PFV_CARGO_PLANE], FALSE)
|
|
SET_ENTITY_NOWEAPONDECALS(planeFightVehicle[PFV_CARGO_PLANE], FALSE)
|
|
|
|
STOP_SMOKE_ON_PLANE(PLANE_SMOKE_HOLD_WIRES_1)
|
|
STOP_SMOKE_ON_PLANE(PLANE_SMOKE_HOLD_WIRES_2)
|
|
|
|
STOP_PLANE_FIGHT_AUDIO_SCENE(PLANE_FIGHT_AUDIO_SCENE_ESCAPE_ON_FOOT)
|
|
START_PLANE_FIGHT_AUDIO_SCENE(PLANE_FIGHT_AUDIO_SCENE_SKYDIVE)
|
|
|
|
DISABLE_SCUFF_DECALS(FALSE)
|
|
SET_RADAR_ZOOM_PRECISE(0.0)
|
|
iOutOfPlaneTime = GET_GAME_TIMER()
|
|
SET_WAYPOINT_OFF()
|
|
REPLAY_RECORD_BACK_FOR_TIME(3.0)
|
|
bDoneOutOfPlane = TRUE
|
|
ELSE
|
|
// handle bike
|
|
IF IS_VEHICLE_DRIVEABLE(transportedVehicle[TRANSPORTED_VEHICLE_INDEX_4WD_DRIVE].veh)
|
|
IF NOT bAllowBike
|
|
IF IS_ENTITY_AT_ENTITY(PLAYER_PED_ID(), transportedVehicle[TRANSPORTED_VEHICLE_INDEX_4WD_DRIVE].veh, <<3.5, 3.5, 3.5>>)
|
|
SET_VEHICLE_DOORS_LOCKED(transportedVehicle[TRANSPORTED_VEHICLE_INDEX_4WD_DRIVE].veh, VEHICLELOCK_UNLOCKED)
|
|
SET_VEHICLE_IS_CONSIDERED_BY_PLAYER(transportedVehicle[TRANSPORTED_VEHICLE_INDEX_4WD_DRIVE].veh, TRUE)
|
|
bAllowBike = TRUE
|
|
ENDIF
|
|
ELSE
|
|
IF NOT transportedVehicle[TRANSPORTED_VEHICLE_INDEX_4WD_DRIVE].bDetached
|
|
//IF IS_PED_IN_VEHICLE(PLAYER_PED_ID(), transportedVehicle[TRANSPORTED_VEHICLE_INDEX_4WD_DRIVE].veh)
|
|
IF GET_VEHICLE_PED_IS_USING(PLAYER_PED_ID()) = transportedVehicle[TRANSPORTED_VEHICLE_INDEX_4WD_DRIVE].veh
|
|
DETACH_TRANSPORTED_VEHICLE(TRANSPORTED_VEHICLE_INDEX_4WD_DRIVE)
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF NOT bDoneOutOfPlane
|
|
IF NOT STREAMVOL_IS_VALID(hillsStreamingVolume)
|
|
IF GET_GAME_TIMER() >= iStartEscapeTime + 52000
|
|
hillsStreamingVolume = STREAMVOL_CREATE_FRUSTUM( <<315.7, 3782.6, 30.1>>, CONVERT_ROTATION_TO_DIRECTION_VECTOR(<<8.3, 0.4, -22.0>> ), 1500, FLAG_MAPDATA)
|
|
ENDIF
|
|
ELSE
|
|
REQUEST_ADDITIONAL_COLLISION_AT_COORD(<<38.74771, 3802.38574, 30.71010>>)
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF GET_GAME_TIMER() >= iStartEscapeTime + 60000
|
|
#if is_debug_build
|
|
OR IS_KEYBOARD_KEY_JUST_PRESSED(KEY_NUMPAD1)
|
|
#ENDIF
|
|
IF CAN_ADVANCE_MISSION()
|
|
bRunningCutscene = TRUE
|
|
ENDIF
|
|
ENDIF
|
|
ELSE
|
|
UPDATE_DEBRIS_OBJECTS()
|
|
|
|
IF NOT bClearedLightRig
|
|
IF GET_GAME_TIMER() >= iOutOfPlaneTime + 1000
|
|
SET_LIGHT_RIG_ON_CARGO_PLANE(FALSE)
|
|
bClearedLightRig = TRUE
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF NOT bDoneSpewSmokeOnEscape
|
|
IF GET_GAME_TIMER() >= iOutOfPlaneTime + 800
|
|
DO_SMOKE_ON_PLANE(PLANE_SMOKE_SPEW_DEBRIS)
|
|
bDoneSpewSmokeOnEscape = TRUE
|
|
ENDIF
|
|
ENDIF
|
|
|
|
/*
|
|
IF NOT bForcePassOnShitskip
|
|
IF NOT bDoneSwearOnWayDownSpeech
|
|
IF GET_GAME_TIMER() >= iOutOfPlaneTime + 13000
|
|
bDoneSwearOnWayDownSpeech = DO_MISSION_SPEECH("EXL1_JUMP2")
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
*/
|
|
|
|
IF GET_GAME_TIMER() <= iOutOfPlaneTime + 1500
|
|
OR IS_PED_IN_ANY_VEHICLE(PLAYER_PED_ID())
|
|
SET_PED_RESET_FLAG(PLAYER_PED_ID(), PRF_DisableTakeOffParachutePack, TRUE)
|
|
ENDIF
|
|
|
|
INT i
|
|
REPEAT NUMBER_DEBRIS_OBJECTS i
|
|
IF NOT debrisObject[i].bDonePassSFX
|
|
IF DOES_ENTITY_EXIST(debrisObject[i].obj)
|
|
IF IS_ENTITY_AT_ENTITY(PLAYER_PED_ID(), debrisObject[i].obj, <<50,50,8>>)
|
|
PLAY_SOUND_FRONTEND(-1, "Falling_Crates", "EXILE_1")
|
|
PRINTSTRING("done pass crate ") PRINTINT(i) PRINTNL()
|
|
debrisObject[i].bDonePassSFX = TRUE
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDREPEAT
|
|
|
|
IF IS_VEHICLE_DRIVEABLE(transportedVehicle[TRANSPORTED_VEHICLE_INDEX_4WD_DRIVE].veh)
|
|
IF NOT bSetDampingOn4wd
|
|
SET_AIR_DRAG_MULTIPLIER_FOR_PLAYERS_VEHICLE(PLAYER_ID(), 5)
|
|
|
|
IF NOT IS_ENTITY_ATTACHED(transportedVehicle[TRANSPORTED_VEHICLE_INDEX_4WD_DRIVE].veh)
|
|
IF NOT IS_PED_SITTING_IN_VEHICLE(PLAYER_PED_ID(), transportedVehicle[TRANSPORTED_VEHICLE_INDEX_4WD_DRIVE].veh)
|
|
SET_ENTITY_LOAD_COLLISION_FLAG(transportedVehicle[TRANSPORTED_VEHICLE_INDEX_4WD_DRIVE].veh, TRUE)
|
|
//PRINTSTRING("done set damping 100") PRINTINT(i) PRINTNL()
|
|
bSetDampingOn4wd = TRUE
|
|
ENDIF
|
|
ENDIF
|
|
ELSE
|
|
SET_AIR_DRAG_MULTIPLIER_FOR_PLAYERS_VEHICLE(PLAYER_ID(), 2)
|
|
fVehicleDamping = fVehicleDamping +@ 0.001//0.0020
|
|
IF fVehicleDamping >= 0.0080
|
|
fVehicleDamping = 0.0080
|
|
ENDIF
|
|
//SET_DAMPING(transportedVehicle[TRANSPORTED_VEHICLE_INDEX_4WD_DRIVE].veh, PHYSICS_DAMPING_LINEAR_C, fVehicleDamping)//0.03)
|
|
//SET_DAMPING(transportedVehicle[TRANSPORTED_VEHICLE_INDEX_4WD_DRIVE].veh, PHYSICS_DAMPING_LINEAR_V, fVehicleDamping)//0.03)
|
|
//SET_DAMPING(transportedVehicle[TRANSPORTED_VEHICLE_INDEX_4WD_DRIVE].veh, PHYSICS_DAMPING_LINEAR_V2, fVehicleDamping)//0.05)
|
|
//PRINTVECTOR(GET_DAMPING(transportedVehicle[TRANSPORTED_VEHICLE_INDEX_4WD_DRIVE].veh, PHYSICS_DAMPING_LINEAR_V2)) printnl()
|
|
//PRINTSTRING("fvehicledamping = ") PRINTFLOAT(fVehicleDamping) PRINTNL()
|
|
ENDIF
|
|
|
|
IF NOT bDoneCarFallSound
|
|
IF IS_PED_IN_VEHICLE(PLAYER_PED_ID(), transportedVehicle[TRANSPORTED_VEHICLE_INDEX_4WD_DRIVE].veh)
|
|
PLAY_SOUND_FROM_ENTITY(iCarFallSoundID, "Transition_Sound", transportedVehicle[TRANSPORTED_VEHICLE_INDEX_4WD_DRIVE].veh, "EXILE_1")
|
|
bDoneCarFallSound = TRUE
|
|
ENDIF
|
|
ELSE
|
|
IF NOT bStoppedCarFallSound
|
|
IF NOT IS_PED_IN_VEHICLE(PLAYER_PED_ID(), transportedVehicle[TRANSPORTED_VEHICLE_INDEX_4WD_DRIVE].veh)
|
|
//STOP_SOUND(iCarFallSoundID)
|
|
bStoppedCarFallSound = TRUE
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
|
|
|
|
ENDIF
|
|
|
|
IF NOT bForcePassOnShitskip
|
|
IF NOT bClearedParachuteAnim
|
|
IF bTriggeredJumpToParachute
|
|
IF GET_GAME_TIMER() >= iJumpToParachuteTime + 1000
|
|
FORCE_PED_MOTION_STATE(PLAYER_PED_ID(), MS_PARACHUTING, FALSE, FAUS_CUTSCENE_EXIT)
|
|
TASK_SKY_DIVE(PLAYER_PED_ID())
|
|
bClearedParachuteAnim = TRUE
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
|
|
// temp disable parachute
|
|
IF bTriggeredJumpToParachute
|
|
IF GET_GAME_TIMER() <= iJumpToParachuteTime + 2500
|
|
DISABLE_CONTROL_ACTION(PLAYER_CONTROL, INPUT_PARACHUTE_DEPLOY)
|
|
ENDIF
|
|
ENDIF
|
|
|
|
VECTOR vPlayerPos = GET_ENTITY_COORDS(PLAYER_PED_ID())
|
|
|
|
IF NOT bDoneEscapeSpeech
|
|
|
|
IF GET_GAME_TIMER() >= iOutOfPlaneTime + 600
|
|
IF GET_RANDOM_INT_IN_RANGE(0,6) = 0
|
|
bDoneEscapeSpeech = DO_MISSION_SPEECH("EXL1_JUMP", TRUE)
|
|
ELSE
|
|
bDoneEscapeSpeech = DO_MISSION_SPEECH("EXL1_JUMP2", TRUE)
|
|
ENDIF
|
|
|
|
IF bDoneEscapeSpeech
|
|
SET_AUDIO_FLAG("DisableAbortConversationForRagdoll", TRUE)
|
|
ENDIF
|
|
ENDIF
|
|
ELSE
|
|
IF NOT bDoneParachutePrompt
|
|
IF NOT IS_PED_IN_ANY_VEHICLE(PLAYER_PED_ID())
|
|
IF vPlayerPos.z > 40
|
|
AND IS_ENTITY_IN_AIR(PLAYER_PED_ID())
|
|
IF DO_MISSION_GOD_TEXT("PF_PARA")
|
|
REPLAY_RECORD_BACK_FOR_TIME(4.0, 12.0, REPLAY_IMPORTANCE_HIGHEST)
|
|
bDoneParachutePrompt = TRUE
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ELSE
|
|
IF NOT bShownFreefallHelp
|
|
IF NOT bUsedParachute
|
|
bShownFreefallHelp = DO_MISSION_HELP_TEXT("PF_FALLHLP")
|
|
ELSE
|
|
bShownFreefallHelp = TRUE
|
|
ENDIF
|
|
ELSE
|
|
IF NOT bShownParachuteHelp
|
|
IF bUsedParachute
|
|
bShownParachuteHelp = TRUE
|
|
IF GET_GAME_TIMER() >= iClearHelpTime
|
|
IF IS_THIS_HELP_MESSAGE_BEING_DISPLAYED("PF_FALLHLP")
|
|
CLEAR_HELP(FALSE)
|
|
iClearHelpTime = GET_GAME_TIMER() + 1000
|
|
ENDIF
|
|
ENDIF
|
|
ELSE
|
|
bShownParachuteHelp = DO_MISSION_HELP_TEXT("PF_PARHLP")
|
|
ENDIF
|
|
ELSE
|
|
// clear open parachute help
|
|
IF bUsedParachute
|
|
AND parachuteState < PPS_LANDING
|
|
AND parachuteState <> PPS_INVALID
|
|
AND NOT IS_ENTITY_IN_WATER(PLAYER_PED_ID())
|
|
AND NOT IS_PED_RAGDOLL(PLAYER_PED_ID())
|
|
AND fSafetyTimer = 0.0
|
|
AND NOT bAtSafety
|
|
IF GET_GAME_TIMER() >= iClearHelpTime
|
|
IF IS_THIS_HELP_MESSAGE_BEING_DISPLAYED("PF_PARHLP")
|
|
CLEAR_HELP(FALSE)
|
|
iClearHelpTime = GET_GAME_TIMER() + 1000
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF bShownParachuteFocusHelp
|
|
IF NOT bShownParachuteHelp2
|
|
bShownParachuteHelp2 = DO_MISSION_HELP_TEXT("PF_PARHLP2")
|
|
ELSE
|
|
IF NOT bShownParachuteHelp3
|
|
|
|
IF IS_USING_KEYBOARD_AND_MOUSE(PLAYER_CONTROL)
|
|
bShownParachuteHelp3 = DO_MISSION_HELP_TEXT("PF_PARHLP3_KM")
|
|
ELSE
|
|
bShownParachuteHelp3 = DO_MISSION_HELP_TEXT("PF_PARHLP3")
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ELSE
|
|
IF (IS_THIS_HELP_MESSAGE_BEING_DISPLAYED("PF_PARHLP") AND IS_ENTITY_IN_WATER(PLAYER_PED_ID()))
|
|
OR IS_THIS_HELP_MESSAGE_BEING_DISPLAYED("PF_PARHLP2")
|
|
OR IS_THIS_HELP_MESSAGE_BEING_DISPLAYED("PF_PARHLP3")
|
|
OR IS_THIS_HELP_MESSAGE_BEING_DISPLAYED("PF_FALLHLP")
|
|
IF GET_GAME_TIMER() >= iClearHelpTime
|
|
CLEAR_HELP(FALSE)
|
|
iClearHelpTime = GET_GAME_TIMER() + 1000
|
|
ENDIF
|
|
ENDIF
|
|
|
|
// PC keyboard and mouse help treated separately, as the PC text isn't included in console builds.
|
|
IF IS_USING_KEYBOARD_AND_MOUSE(PLAYER_CONTROL)
|
|
IF IS_THIS_HELP_MESSAGE_BEING_DISPLAYED("PF_PARHLP3")
|
|
|
|
IF GET_GAME_TIMER() >= iClearHelpTime
|
|
CLEAR_HELP(FALSE)
|
|
iClearHelpTime = GET_GAME_TIMER() + 1000
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
|
|
// handle plane
|
|
HANDLE_PLANE_FALLING()
|
|
|
|
// focus on plane
|
|
BOOL bCanDoHintCam = FALSE
|
|
IF DOES_ENTITY_EXIST(planeFightVehicle[PFV_CARGO_PLANE])
|
|
IF IS_ENTITY_DEAD(planeFightVehicle[PFV_CARGO_PLANE])
|
|
OR NOT IS_ENTITY_DEAD(planeFightVehicle[PFV_CARGO_PLANE])
|
|
IF NOT bAtSafety
|
|
AND NOT bShownInWaterPrompt
|
|
AND NOT IS_ENTITY_IN_WATER(PLAYER_PED_ID())
|
|
AND NOT (GET_FOLLOW_PED_CAM_VIEW_MODE() = CAM_VIEW_MODE_FIRST_PERSON)
|
|
CONTROL_VEHICLE_CHASE_HINT_CAM_ANY_MEANS(localChaseHintCamStruct, planeFightVehicle[PFV_CARGO_PLANE])
|
|
bCanDoHintCam = TRUE
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
IF NOT bCanDoHintCam
|
|
KILL_CHASE_HINT_CAM(localChaseHintCamStruct)
|
|
IF bDoneFocusOnCrashingPlaneAudioScene
|
|
STOP_PLANE_FIGHT_AUDIO_SCENE(PLANE_FIGHT_AUDIO_SCENE_FOCUS_ON_CRASHING_PLANE)
|
|
bDoneFocusOnCrashingPlaneAudioScene = FALSE
|
|
ENDIF
|
|
ELSE
|
|
IF NOT bDoneFocusOnCrashingPlaneAudioScene
|
|
IF IS_GAMEPLAY_HINT_ACTIVE()
|
|
bDoneFocusOnCrashingPlaneAudioScene = START_PLANE_FIGHT_AUDIO_SCENE(PLANE_FIGHT_AUDIO_SCENE_FOCUS_ON_CRASHING_PLANE)
|
|
ENDIF
|
|
ELSE
|
|
IF NOT IS_GAMEPLAY_HINT_ACTIVE()
|
|
STOP_PLANE_FIGHT_AUDIO_SCENE(PLANE_FIGHT_AUDIO_SCENE_FOCUS_ON_CRASHING_PLANE)
|
|
bDoneFocusOnCrashingPlaneAudioScene = FALSE
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
|
|
// help
|
|
IF NOT bShownParachuteFocusHelp
|
|
IF IS_GAMEPLAY_HINT_ACTIVE()
|
|
OR GET_FOLLOW_PED_CAM_VIEW_MODE() = CAM_VIEW_MODE_FIRST_PERSON
|
|
bShownParachuteFocusHelp = TRUE
|
|
ELSE
|
|
IF bCanDoHintCam
|
|
AND NOT IS_PHONE_ONSCREEN()
|
|
AND SAFE_TO_PRINT_CHASE_HINT_CAM_HELP()
|
|
IF IS_PED_IN_ANY_VEHICLE(PLAYER_PED_ID())
|
|
OR bShownParachuteHelp
|
|
bShownParachuteFocusHelp = DO_MISSION_HELP_TEXT("PF_FALHLP")
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ELSE
|
|
IF IS_GAMEPLAY_HINT_ACTIVE()
|
|
OR IS_PHONE_ONSCREEN()
|
|
OR NOT bCanDoHintCam
|
|
IF IS_THIS_HELP_MESSAGE_BEING_DISPLAYED("PF_FALHLP")
|
|
IF GET_GAME_TIMER() >= iClearHelpTime
|
|
CLEAR_HELP(FALSE)
|
|
iClearHelpTime = GET_GAME_TIMER() + 1000
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF bDonePhoneCall
|
|
IF planeFallingState = PLANE_FALLING_DONE
|
|
OR bForcePassOnShitskip
|
|
IF NOT IS_ANY_CONVERSATION_ONGOING_OR_QUEUED()
|
|
MISSION_PASSED()
|
|
ENDIF
|
|
ENDIF
|
|
ELSE
|
|
// mission passed call
|
|
IF bAtSafety
|
|
|
|
IF NOT bResetSpeechFlag
|
|
IF NOT IS_ANY_CONVERSATION_ONGOING_OR_QUEUED()
|
|
SET_AUDIO_FLAG("DisableAbortConversationForRagdoll", FALSE)
|
|
bResetSpeechFlag = TRUE
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF NOT bDoneLandedCue
|
|
bDoneLandedCue = TRIGGER_MISSION_MUSIC_EVENT("EXL1_LANDED")
|
|
ENDIF
|
|
|
|
IF IS_THIS_PRINT_BEING_DISPLAYED("PF_LAND")
|
|
REMOVE_MISSION_TEXT(FALSE, TRUE, FALSE)
|
|
ENDIF
|
|
|
|
IF GET_GAME_TIMER() >= iGotSafetyTime + 3000
|
|
|
|
REPLAY_RECORD_BACK_FOR_TIME(10.0, 5.0, REPLAY_IMPORTANCE_HIGHEST)
|
|
|
|
bDonePhoneCall = TRUE
|
|
//IF NOT IS_ANY_CONVERSATION_ONGOING_OR_QUEUED()
|
|
// bDonePhoneCall = PLAYER_CALL_CHAR_CELLPHONE(planeFightConversation, CHAR_RON, "EXL1AUD", "EXL1_CALLM", CONV_PRIORITY_HIGH)
|
|
//ENDIF
|
|
ENDIF
|
|
ELSE
|
|
IF NOT IS_ENTITY_IN_WATER(PLAYER_PED_ID())
|
|
IF GET_PED_PARACHUTE_STATE(PLAYER_PED_ID()) = PPS_INVALID
|
|
AND GET_ENTITY_HEIGHT_ABOVE_GROUND(PLAYER_PED_ID()) < 10.0
|
|
AND NOT IS_PED_RAGDOLL(PLAYER_PED_ID())
|
|
fSafetyTimer = fSafetyTimer +@ 1.0
|
|
|
|
IF NOT bStoppedDeployParachuteAudioScene
|
|
STOP_PLANE_FIGHT_AUDIO_SCENE(PLANE_FIGHT_AUDIO_SCENE_DEPLOY_PARACHUTE)
|
|
bStoppedDeployParachuteAudioScene = TRUE
|
|
ENDIF
|
|
|
|
IF fSafetyTimer >= 1.5
|
|
IF NOT bCheckedPerfectLanding
|
|
IF GET_ENTITY_HEALTH(PLAYER_PED_ID()) = iStoredPlayerHealth
|
|
//INFORM_STAT_EXILE_ONE_PERFECT_LANDING()
|
|
ENDIF
|
|
bCheckedPerfectLanding = TRUE
|
|
ENDIF
|
|
|
|
iGotSafetyTime = GET_GAME_TIMER()
|
|
|
|
bAtSafety = TRUE
|
|
ENDIF
|
|
ELSE
|
|
fSafetyTimer = 0.0
|
|
ENDIF
|
|
ELSE
|
|
IF NOT bDoneLandedCue
|
|
bDoneLandedCue = TRIGGER_MISSION_MUSIC_EVENT("EXL1_LANDED")
|
|
ENDIF
|
|
|
|
IF NOT bStoppedDeployParachuteAudioScene
|
|
STOP_PLANE_FIGHT_AUDIO_SCENE(PLANE_FIGHT_AUDIO_SCENE_DEPLOY_PARACHUTE)
|
|
bStoppedDeployParachuteAudioScene = TRUE
|
|
ENDIF
|
|
|
|
IF NOT bShownInWaterPrompt
|
|
bShownInWaterPrompt = DO_MISSION_GOD_TEXT("PF_LAND")
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ELSE
|
|
DO_CRASH_INTO_SEA_CUTSCENE()
|
|
ENDIF
|
|
ENDPROC
|
|
|
|
// debug only
|
|
#IF IS_DEBUG_BUILD
|
|
// create widgets
|
|
PROC CREATE_PLANE_FIGHT_WIDGETS()
|
|
planeFightWidgets = START_WIDGET_GROUP("Plane Fight")
|
|
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_VECTOR_SLIDER("Attach Cam Offset", vDebugAttachCamOffset, -50.0, 50.0, 0.1)
|
|
ADD_WIDGET_VECTOR_SLIDER("Attach Cam point", vDebugAttachCamPoint, -50.0, 50.0, 0.1)
|
|
ADD_WIDGET_FLOAT_SLIDER("Attach Cam FOV", fDebugAttachCamFOV, 0, 80, 0.5)
|
|
|
|
ADD_WIDGET_BOOL("Force jet into plane", bDebugForceJetIntoPlane)
|
|
STOP_WIDGET_GROUP()
|
|
ENDPROC
|
|
|
|
// setup the debug menu
|
|
PROC SETUP_PLANE_FIGHT_DEBUG_MENU()
|
|
INT i
|
|
|
|
REPEAT MAX_SKIP_MENU_LENGTH i
|
|
stageMenu[i].sTxtLabel = GET_DESCRIPTION_FOR_STAGE_AS_STRING(INT_TO_ENUM(MISSION_STAGE_ENUM, i))
|
|
ENDREPEAT
|
|
ENDPROC
|
|
|
|
// debug skips
|
|
PROC DO_DEBUG_SKIPS()
|
|
// mission pass S
|
|
IF IS_KEYBOARD_KEY_JUST_PRESSED(KEY_S)
|
|
bThoroughCleanup = TRUE
|
|
MISSION_PASSED()
|
|
ENDIF
|
|
|
|
// mission fail F
|
|
IF IS_KEYBOARD_KEY_JUST_PRESSED(KEY_F)
|
|
MISSION_FAILED(FAIL_MISSED_CARGO_PLANE)
|
|
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())
|
|
INT i
|
|
|
|
SET_PLAYER_CONTROL(PLAYER_ID(), TRUE)
|
|
|
|
SWITCH currentMissionStage
|
|
CASE STAGE_GET_TO_AIRSTRIP
|
|
IF createPlaneStage = CREATE_PLANE_STAGE_DONE
|
|
|
|
IF IS_VEHICLE_DRIVEABLE(planefightVehicle[PFV_TREVOR_4WD])
|
|
SET_ENTITY_COORDS(planefightVehicle[PFV_TREVOR_4WD], <<2141.23242, 4806.81445, 40.22812>>)
|
|
endif
|
|
|
|
IF NOT IS_PED_INJURED(ronPed)
|
|
CLEAR_PED_TASKS_IMMEDIATELY(ronPed)
|
|
REMOVE_PED_FROM_GROUP(ronPed)
|
|
SET_ENTITY_COORDS(ronPed, <<2136.11523, 4795.18652, 40.11475>>)
|
|
ENDIF
|
|
|
|
WAIT(0)
|
|
IF IS_VEHICLE_DRIVEABLE(planeFightVehicle[PFV_TREVOR_PLANE])
|
|
bAtAirstrip = TRUE
|
|
SET_VEHICLE_IS_CONSIDERED_BY_PLAYER(planeFightVehicle[PFV_TREVOR_PLANE], TRUE)
|
|
SET_PED_INTO_VEHICLE(PLAYER_PED_ID(), planeFightVehicle[PFV_TREVOR_PLANE])
|
|
SET_VEHICLE_ENGINE_ON(planeFightVehicle[PFV_TREVOR_PLANE], TRUE, TRUE)
|
|
ENDIF
|
|
ENDIF
|
|
BREAK
|
|
CASE STAGE_FOLLOW_PLANE_1
|
|
IF IS_VEHICLE_DRIVEABLE(planeFightVehicle[PFV_TREVOR_PLANE])
|
|
IF NOT IS_PED_IN_VEHICLE(PLAYER_PED_ID(), planeFightVehicle[PFV_TREVOR_PLANE])
|
|
SET_PED_INTO_VEHICLE(PLAYER_PED_ID(), planeFightVehicle[PFV_TREVOR_PLANE])
|
|
SET_VEHICLE_ENGINE_ON(planeFightVehicle[PFV_TREVOR_PLANE], TRUE, TRUE)
|
|
ELSE
|
|
DO_SCREEN_FADE_OUT(500)
|
|
WHILE NOT IS_SCREEN_FADED_OUT()
|
|
WAIT(0)
|
|
ENDWHILE
|
|
|
|
COMMON_MISSION_CLEAR()
|
|
SET_MISSION_STAGE(STAGE_FOLLOW_PLANE_2, TRUE)
|
|
|
|
DO_SCREEN_FADE_IN(500)
|
|
ENDIF
|
|
ENDIF
|
|
BREAK
|
|
CASE STAGE_FOLLOW_PLANE_2
|
|
CASE STAGE_FOLLOW_PLANE_3
|
|
IF IS_VEHICLE_DRIVEABLE(planeFightVehicle[PFV_TREVOR_PLANE])
|
|
IF NOT IS_PED_IN_VEHICLE(PLAYER_PED_ID(), planeFightVehicle[PFV_TREVOR_PLANE])
|
|
SET_PED_INTO_VEHICLE(PLAYER_PED_ID(), planeFightVehicle[PFV_TREVOR_PLANE])
|
|
SET_VEHICLE_ENGINE_ON(planeFightVehicle[PFV_TREVOR_PLANE], TRUE, TRUE)
|
|
ELSE
|
|
IF IS_VEHICLE_DRIVEABLE(planeFightVehicle[PFV_CARGO_PLANE])
|
|
AND IS_VEHICLE_DRIVEABLE(planeFightVehicle[PFV_TREVOR_PLANE])
|
|
REQUEST_PLANE_INTERIOR_ASSETS()
|
|
LOAD_ALL_OBJECTS_IF_SCREEN_FADED_OUT()
|
|
WHILE NOT HAVE_ALL_MODEL_REQUESTS_SUCCEEDED()
|
|
OR NOT HAVE_ALL_ANIM_DICT_REQUESTS_SUCCEEDED()
|
|
WAIT(0)
|
|
ENDWHILE
|
|
planeInteriorStreamingStage = PLANE_INTERIOR_STREAMING_DONE
|
|
SET_FAKE_MINIMAP_MAX_ALTIMETER_HEIGHT(0)
|
|
bAllowFlyHigh = TRUE
|
|
CREATE_CARGO_PLANE_CREW()
|
|
STOP_PLAYBACK_RECORDED_VEHICLE(planeFightVehicle[PFV_CARGO_PLANE])
|
|
START_PLAYBACK_RECORDED_VEHICLE(planeFightVehicle[PFV_CARGO_PLANE], 001, GET_PLANE_FIGHT_RECORDING_PREFIX())
|
|
SKIP_TIME_IN_PLAYBACK_RECORDED_VEHICLE(planeFightVehicle[PFV_CARGO_PLANE], ALLOW_FLY_HIGH_TIME)
|
|
WAIT(0)
|
|
IF IS_VEHICLE_DRIVEABLE(planeFightVehicle[PFV_CARGO_PLANE])
|
|
AND IS_VEHICLE_DRIVEABLE(planeFightVehicle[PFV_TREVOR_PLANE])
|
|
SET_ENTITY_COORDS(planeFightVehicle[PFV_TREVOR_PLANE], GET_OFFSET_FROM_ENTITY_IN_WORLD_COORDS(planeFightVehicle[PFV_CARGO_PLANE], <<0,-43,-6>>))
|
|
SET_ENTITY_ROTATION(planeFightVehicle[PFV_TREVOR_PLANE], GET_ENTITY_ROTATION(planeFightVehicle[PFV_CARGO_PLANE]))
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
BREAK
|
|
CASE STAGE_ENTER_PLANE
|
|
IF IS_VEHICLE_DRIVEABLE(planeFightVehicle[PFV_TREVOR_PLANE])
|
|
IF NOT IS_PED_IN_VEHICLE(PLAYER_PED_ID(), planeFightVehicle[PFV_TREVOR_PLANE])
|
|
SET_PED_INTO_VEHICLE(PLAYER_PED_ID(), planeFightVehicle[PFV_TREVOR_PLANE])
|
|
SET_VEHICLE_ENGINE_ON(planeFightVehicle[PFV_TREVOR_PLANE], TRUE, TRUE)
|
|
ELSE
|
|
IF IS_VEHICLE_DRIVEABLE(planeFightVehicle[PFV_CARGO_PLANE])
|
|
AND IS_VEHICLE_DRIVEABLE(planeFightVehicle[PFV_TREVOR_PLANE])
|
|
REQUEST_PLANE_INTERIOR_ASSETS()
|
|
WHILE NOT HAVE_ALL_MODEL_REQUESTS_SUCCEEDED()
|
|
OR NOT HAVE_ALL_ANIM_DICT_REQUESTS_SUCCEEDED()
|
|
WAIT(0)
|
|
ENDWHILE
|
|
|
|
bDebugForceIntoHold = TRUE
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
BREAK
|
|
CASE STAGE_PLANE_FIGHT
|
|
IF ladderState = LADDER_STATE_NOT_ON
|
|
AND NOT bCanUseControls
|
|
KILL_ALL_ENEMY_PEDS()
|
|
bDoneGotoCockpitPrompt = TRUE
|
|
REMOVE_ALL_BLIPS()
|
|
CLEAR_PED_TASKS_IMMEDIATELY(PLAYER_PED_ID())
|
|
IF NOT IS_PED_INJURED(PLAYER_PED_ID())
|
|
SET_ENTITY_COORDS(PLAYER_PED_ID(), <<2929.79, 768.65, 458.23>>)
|
|
SET_ENTITY_HEADING(PLAYER_PED_ID(), 180)
|
|
FREEZE_ENTITY_POSITION(PLAYER_PED_ID(), TRUE)
|
|
WAIT(500)
|
|
IF IS_VEHICLE_DRIVEABLE(planeFightVehicle[PFV_CARGO_PLANE])
|
|
FREEZE_ENTITY_POSITION(PLAYER_PED_ID(), FALSE)
|
|
SET_LADDER_STATE(LADDER_STATE_GETTING_ON)
|
|
ENDIF
|
|
ENDIF
|
|
ELSE
|
|
IF NOT bCanUseControls
|
|
REPEAT COUNT_OF(namedEnemyPed) i
|
|
IF NOT IS_PED_INJURED(namedEnemyPed[i])
|
|
APPLY_DAMAGE_TO_PED(namedEnemyPed[i], 1000, TRUE)
|
|
ENDIF
|
|
ENDREPEAT
|
|
DETACH_ENTITY(PLAYER_PED_ID(), FALSE, FALSE)
|
|
SET_LADDER_STATE(LADDER_STATE_NOT_ON)
|
|
SET_ENTITY_COORDS_NO_OFFSET(PLAYER_PED_ID(), GET_PLANE_OFFSET_IN_WORLD_COORDS(<<0.0, 26.32, 1.92>>))
|
|
iCanUseControlsTime = GET_GAME_TIMER()
|
|
bCanUseControls = TRUE
|
|
ELSE
|
|
bDebugForceUseControls = TRUE
|
|
ENDIF
|
|
ENDIF
|
|
BREAK
|
|
CASE STAGE_FLY_PLANE
|
|
flyPlaneState = FLY_PLANE_POST_FIREBALL
|
|
iBlowEngineTime = 0
|
|
BREAK
|
|
CASE STAGE_ESCAPE_PLANE
|
|
IF NOT bDoneOutOfPlane
|
|
// FORCE_RESET_PARACHUTE_PED(PLAYER_PED_ID())
|
|
CLEAR_PED_TASKS_IMMEDIATELY(PLAYER_PED_ID())
|
|
// SET_ENTITY_COORDS(PLAYER_PED_ID(), <<-858, 5731, 6.0>>)
|
|
// WAIT(0)
|
|
// GIVE_WEAPON_TO_PED(PLAYER_PED_ID(), GADGETTYPE_PARACHUTE, 1)
|
|
// GIVE_PED_A_PARACHUTE(PLAYER_PED_ID())
|
|
SET_ENTITY_COORDS(PLAYER_PED_ID(), GET_PLANE_OFFSET_IN_WORLD_COORDS(<<0, JUMP_OFF_Y -26.0, -1.0>>))
|
|
ELSE
|
|
// FORCE_RESET_PARACHUTE_PED(PLAYER_PED_ID())
|
|
CLEAR_PED_TASKS_IMMEDIATELY(PLAYER_PED_ID())
|
|
SET_ENTITY_COORDS(PLAYER_PED_ID(), GET_PLANE_FIGHT_VECTOR(PFVEC_PASSED))
|
|
MISSION_PASSED()
|
|
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
|
|
AND NOT bRunningCutscene
|
|
TRIGGER_MUSIC_EVENT("EXL1_MISSION_FAILED")
|
|
|
|
DO_SCREEN_FADE_OUT(500)
|
|
WHILE NOT IS_SCREEN_FADED_OUT()
|
|
WAIT(0)
|
|
ENDWHILE
|
|
|
|
COMMON_MISSION_CLEAR()
|
|
|
|
SWITCH currentMissionStage
|
|
CASE STAGE_GET_TO_AIRSTRIP
|
|
//POSITION_PLAYER_AT_MISSION_INIT()
|
|
SET_MISSION_STAGE(STAGE_GET_TO_AIRSTRIP, TRUE)
|
|
BREAK
|
|
CASE STAGE_FOLLOW_PLANE_1
|
|
//POSITION_PLAYER_AT_MISSION_INIT()
|
|
SET_MISSION_STAGE(STAGE_GET_TO_AIRSTRIP, TRUE)
|
|
BREAK
|
|
CASE STAGE_FOLLOW_PLANE_2
|
|
SET_MISSION_STAGE(STAGE_FOLLOW_PLANE_1, TRUE)
|
|
BREAK
|
|
CASE STAGE_FOLLOW_PLANE_3
|
|
SET_MISSION_STAGE(STAGE_FOLLOW_PLANE_2, TRUE)
|
|
BREAK
|
|
CASE STAGE_ENTER_PLANE
|
|
SET_MISSION_STAGE(STAGE_FOLLOW_PLANE_3, TRUE)
|
|
BREAK
|
|
CASE STAGE_PLANE_FIGHT
|
|
SET_MISSION_STAGE(STAGE_ENTER_PLANE, TRUE)
|
|
BREAK
|
|
CASE STAGE_FLY_PLANE
|
|
SET_MISSION_STAGE(STAGE_PLANE_FIGHT, TRUE)
|
|
BREAK
|
|
CASE STAGE_ESCAPE_PLANE
|
|
SET_MISSION_STAGE(STAGE_FLY_PLANE, TRUE)
|
|
BREAK
|
|
|
|
DO_SCREEN_FADE_IN(500)
|
|
ENDSWITCH
|
|
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)
|
|
TRIGGER_MUSIC_EVENT("EXL1_MISSION_FAILED")
|
|
COMMON_MISSION_CLEAR()
|
|
|
|
DO_SCREEN_FADE_OUT(500)
|
|
WHILE NOT IS_SCREEN_FADED_OUT()
|
|
WAIT(0)
|
|
ENDWHILE
|
|
|
|
IF iMenuMissionStage = 0
|
|
//POSITION_PLAYER_AT_MISSION_INIT()
|
|
ENDIF
|
|
SET_MISSION_STAGE(INT_TO_ENUM(MISSION_STAGE_ENUM, iMenuMissionStage), 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)
|
|
fRBDebugCamFOV = GET_CAM_FOV(tempCam)
|
|
|
|
//PRINTSTRING("offset = ") PRINTVECTOR(GET_OFFSET_FROM_ENTITY_GIVEN_WORLD_COORDS(planeFightVehicle[PFV_CARGO_PLANE], vRBDebugCamPos)) PRINTNL()
|
|
|
|
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
|
|
|
|
// main script
|
|
SCRIPT
|
|
SET_MISSION_FLAG(TRUE)
|
|
IF HAS_FORCE_CLEANUP_OCCURRED()
|
|
RESET_BACK_TO_FRANKLIN()
|
|
Mission_Flow_Mission_Force_Cleanup()
|
|
MISSION_CLEANUP()
|
|
ENDIF
|
|
|
|
#IF IS_DEBUG_BUILD
|
|
CREATE_PLANE_FIGHT_WIDGETS()
|
|
SETUP_PLANE_FIGHT_DEBUG_MENU()
|
|
#ENDIF
|
|
|
|
WHILE TRUE
|
|
REPLAY_CHECK_FOR_EVENT_THIS_FRAME("M_EX1")
|
|
|
|
#IF IS_DEBUG_BUILD
|
|
IF IS_KEYBOARD_KEY_JUST_PRESSED(KEY_NUMPAD4)
|
|
SET_LIGHT_RIG_ON_CARGO_PLANE(TRUE)
|
|
ENDIF
|
|
#ENDIF
|
|
|
|
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 checks
|
|
HANDLE_MISSION_FAIL_STATE()
|
|
|
|
// plane light rig
|
|
UPDATE_CARGO_PLANE_LIGHT_RIG()
|
|
|
|
// run appropriate stage
|
|
SWITCH currentMissionStage
|
|
CASE STAGE_GET_TO_AIRSTRIP
|
|
DO_STAGE_GET_TO_AIRSTRIP()
|
|
BREAK
|
|
CASE STAGE_FOLLOW_PLANE_1
|
|
CASE STAGE_FOLLOW_PLANE_2
|
|
CASE STAGE_FOLLOW_PLANE_3
|
|
DO_STAGE_FOLLOW_PLANE()
|
|
BREAK
|
|
CASE STAGE_ENTER_PLANE
|
|
DO_STAGE_ENTER_PLANE()
|
|
BREAK
|
|
CASE STAGE_PLANE_FIGHT
|
|
DO_STAGE_PLANE_FIGHT()
|
|
BREAK
|
|
CASE STAGE_FLY_PLANE
|
|
DO_STAGE_FLY_PLANE()
|
|
BREAK
|
|
CASE STAGE_ESCAPE_PLANE
|
|
DO_STAGE_ESCAPE_PLANE()
|
|
BREAK
|
|
ENDSWITCH
|
|
ENDIF
|
|
|
|
#IF IS_DEBUG_BUILD
|
|
IF CAN_ADVANCE_MISSION()
|
|
DO_DEBUG_SKIPS()
|
|
ENDIF
|
|
DO_RB_DEBUG_CAM_DUMP()
|
|
#ENDIF
|
|
ENDIF
|
|
|
|
WAIT(0)
|
|
ENDWHILE
|
|
ENDSCRIPT
|