11222 lines
353 KiB
Python
Executable File
11222 lines
353 KiB
Python
Executable File
|
|
// _________________________________________________________________________________________
|
|
// ___
|
|
// ___ Author: Rob Bray/Ben Wilson
|
|
// ___ Date: 09/01/2012
|
|
// _________________________________________________________________________________________
|
|
// ___
|
|
// ___ Finale 1A - Save Michael and Trevor
|
|
// ___
|
|
// ___ Survive waves of enemies from various factions at the foundry
|
|
// ___
|
|
// _________________________________________________________________________________________
|
|
|
|
//Compile out Title Update changes to header functions.
|
|
//Must be before includes.
|
|
//CONST_INT USE_TU_CHANGES 0 // Removed by Kenneth R.
|
|
|
|
// ____________________________________ INCLUDES ___________________________________________
|
|
|
|
USING "rage_builtins.sch"
|
|
USING "globals.sch"
|
|
USING "commands_misc.sch"
|
|
USING "commands_pad.sch"
|
|
USING "commands_script.sch"
|
|
USING "commands_player.sch"
|
|
USING "commands_streaming.sch"
|
|
USING "commands_vehicle.sch"
|
|
USING "commands_camera.sch"
|
|
USING "commands_path.sch"
|
|
USING "commands_fire.sch"
|
|
USING "commands_object.sch"
|
|
USING "commands_graphics.sch"
|
|
USING "commands_cutscene.sch"
|
|
USING "commands_physics.sch"
|
|
USING "script_maths.sch"
|
|
USING "script_player.sch"
|
|
USING "streamed_scripts.sch"
|
|
USING "model_enums.sch"
|
|
USING "selector_public.sch"
|
|
USING "dialogue_public.sch"
|
|
USING "flow_public_core_override.sch"
|
|
USING "script_blips.sch"
|
|
USING "script_buttons.sch"
|
|
USING "script_ped.sch"
|
|
USING "select_mission_stage.sch"
|
|
USING "replay_public.sch"
|
|
USING "cutscene_public.sch"
|
|
USING "mission_stat_public.sch"
|
|
USING "area_checks.sch"
|
|
USING "rappel_public.sch"
|
|
USING "clearMissionArea.sch"
|
|
USING "CompletionPercentage_public.sch"
|
|
USING "locates_public.sch"
|
|
USING "trigger_box.sch"
|
|
USING "commands_recording.sch"
|
|
|
|
// Enums
|
|
ENUM MISSION_INIT_STAGE_ENUM
|
|
MISSION_INIT_PRE_INTRO = 0,
|
|
MISSION_INIT_REQUEST_INTRO,
|
|
MISSION_INIT_WAIT_FOR_INTRO,
|
|
MISSION_INIT_PLAY_INTRO,
|
|
MISSION_INIT_DONE
|
|
ENDENUM
|
|
|
|
ENUM MISSION_STAGE_ENUM
|
|
STAGE_GET_TO_FOUNDRY = 0,
|
|
STAGE_MEET_GANG,
|
|
STAGE_SHOOTOUT_STAGE_1,
|
|
STAGE_SHOOTOUT_STAGE_2,
|
|
STAGE_SHOOTOUT_STAGE_3,
|
|
STAGE_SHOOTOUT_STAGE_4,
|
|
STAGE_OUTRO_CUTSCENE
|
|
ENDENUM
|
|
|
|
ENUM TRAVEL_GOAL
|
|
TRAVEL_INIT,
|
|
TRAVEL_GO_TO_LAMARS,
|
|
TRAVEL_LAMAR_GETS_IN,
|
|
TRAVEL_GO_TO_FOUNDRY,
|
|
TRAVEL_ARRIVED_AT_FOUNDRY,
|
|
TRAVEL_COMPLETE
|
|
ENDENUM
|
|
|
|
ENUM TRAVEL_TEXT
|
|
TRAVEL_TEXT_CALL_LAMAR,
|
|
TRAVEL_TEXT_GO_TO_LAMARS,
|
|
TRAVEL_TEXT_APPROACH_LAMAR,
|
|
TRAVEL_TEXT_GET_IN_LAMAR,
|
|
TRAVEL_TEXT_GO_TO_FOUNDRY,
|
|
TRAVEL_TEXT_BANTER_1,
|
|
TRAVEL_TEXT_BANTER_2,
|
|
TRAVEL_TEXT_BANTER_3,
|
|
TRAVEL_TEXT_IDLE
|
|
ENDENUM
|
|
|
|
ENUM ARGUMENT_TEXT
|
|
ARG_TEXT_LI1,
|
|
ARG_TEXT_LI2,
|
|
ARG_TEXT_LI3,
|
|
ARG_TEXT_LI4,
|
|
ARG_TEXT_LI5,
|
|
ARG_TEXT_IDLE
|
|
ENDENUM
|
|
|
|
ENUM KICKOFF_TEXT
|
|
KICKOFF_SEARCHERS_REACT,
|
|
KICKOFF_FRIENDLY_SHOUT,
|
|
KICKOFF_RESPONSE,
|
|
KICKOFF_IDLE
|
|
ENDENUM
|
|
|
|
ENUM SHOOTOUT_2_GOAL
|
|
SHOOTOUT_2_INIT,
|
|
SHOOTOUT_2_SWITCH_TO_FRANK,
|
|
SHOOTOUT_2_GO_TO_EXIT,
|
|
SHOOTOUT_2_CHECK_FOR_EXIT,
|
|
SHOOTOUT_2_OUTSIDE_1,
|
|
SHOOTOUT_2_OUTSIDE_2,
|
|
SHOOTOUT_2_SWITCH,
|
|
SHOOTOUT_2_FINISH_SWITCH,
|
|
SHOOTOUT_2_COMPLETE
|
|
ENDENUM
|
|
|
|
ENUM SHOOTOUT_2_TEXT
|
|
SHOOTOUT_2_TEXT_LAMAR_CALLS,
|
|
SHOOTOUT_2_TEXT_SWITCH_TO_FRANK,
|
|
SHOOTOUT_2_TEXT_MICHAEL_ENCOURAGEMENT,
|
|
SHOOTOUT_2_TEXT_GO_TO_EXIT,
|
|
SHOOTOUT_2_TEXT_LAMAR_PANIC,
|
|
SHOOTOUT_2_TEXT_FRANKLIN_RESPONSE_URGENT,
|
|
SHOOTOUT_2_TEXT_FRANKLIN_RESPONSE,
|
|
SHOOTOUT_2_TEXT_FRANK_REACHES_LAMAR,
|
|
SHOOTOUT_2_TEXT_LAMAR_GRATEFUL,
|
|
SHOOTOUT_2_TEXT_FIGHT_WITH_LAMAR,
|
|
SHOOTOUT_2_TEXT_MICHAEL_UNDER_ATTACK,
|
|
SHOOTOUT_2_TEXT_SWITCH_TO_MIKE,
|
|
SHOOTOUT_2_TEXT_SWITCH_URGENT,
|
|
SHOOTOUT_2_TEXT_IDLE
|
|
ENDENUM
|
|
|
|
ENUM SHOOTOUT_3_GOAL
|
|
SHOOTOUT_3_INIT,
|
|
SHOOTOUT_3_ATTACK_1,
|
|
SHOOTOUT_3_ATTACK_2,
|
|
SHOOTOUT_3_ATTACK_3,
|
|
SHOOTOUT_3_ATTACK_4,
|
|
SHOOTOUT_3_EXIT,
|
|
SHOOTOUT_3_COMPLETE
|
|
ENDENUM
|
|
|
|
ENUM SHOOTOUT_3_TEXT
|
|
SHOOTOUT_3_TEXT_MICHAEL_SAYS_IM_GOING,
|
|
SHOOTOUT_3_TEXT_GO_TO_TREV,
|
|
SHOOTOUT_3_TEXT_MICHAEL_REACHES_TREVOR,
|
|
SHOOTOUT_3_TEXT_TREVOR_EXPLAINS_HIMSELF,
|
|
SHOOTOUT_3_TEXT_U_MAD_MICHAEL,
|
|
SHOOTOUT_3_MORE_FIB_ENTER,
|
|
SHOOTOUT_3_TEXT_DEFEND,
|
|
SHOOTOUT_3_TEXT_EXIT_FOUNDRY,
|
|
SHOOTOUT_3_TEXT_GO_TO_DOOR,
|
|
SHOOTOUT_3_TEXT_IDLE
|
|
ENDENUM
|
|
|
|
ENUM ALL_AUDIO_SCENES
|
|
AUDIO_IDLE,
|
|
AUDIO_GO_TO_FOUNDRY,
|
|
AUDIO_ENTER_FOUNDRY,
|
|
AUDIO_WAIT_FOR_AMBUSH,
|
|
AUDIO_AMBUSH_STARTS,
|
|
AUDIO_GET_TO_LAMAR,
|
|
AUDIO_SHOOT_OUT_WITH_LAMAR,
|
|
AUDIO_SAVE_TREVOR,
|
|
AUDIO_GO_TO_EXIT,
|
|
AUDIO_SHOOTOUT_OUTSIDE,
|
|
AUDIO_HELICOPTER_ARRIVES,
|
|
AUDIO_FINISH_OUTSIDE_SHOOTOUT
|
|
ENDENUM
|
|
|
|
ENUM SCRIPTED_CAM_CONTROLLER
|
|
SCRIPTCAM_INIT,
|
|
SCRIPTCAM_SHOT_1,
|
|
SCRIPTCAM_SHOT_2,
|
|
SCRIPTCAM_RETURN_TO_GAMEPLAY,
|
|
SCRIPTCAM_COMPLETE
|
|
ENDENUM
|
|
|
|
ENUM FAIL_REASON_ENUM
|
|
FAIL_MICHAEL_DEAD = 0,
|
|
FAIL_FRANKLIN_DEAD,
|
|
FAIL_TREVOR_DEAD,
|
|
FAIL_LAMAR_DEAD,
|
|
FAIL_ABANDONED_LAMAR,
|
|
FAIL_ABANDONED_FIGHT,
|
|
FAIL_ABANDONED_MEETING,
|
|
FAIL_ATTRACTED_COPS
|
|
ENDENUM
|
|
|
|
ENUM MISSION_FAIL_STATE_ENUM
|
|
MISSION_FAIL_STATE_NOT_FAILED = 0,
|
|
MISSION_FAIL_STATE_WAIT_FOR_FADE,
|
|
MISSION_FAIL_STATE_DONE
|
|
ENDENUM
|
|
|
|
ENUM MOCAP_STREAMING_STAGE_ENUM
|
|
MOCAP_STREAMING_STAGE_REQUEST = 0,
|
|
MOCAP_STREAMING_STAGE_WAIT,
|
|
MOCAP_STREAMING_STAGE_COMPLETE
|
|
ENDENUM
|
|
|
|
ENUM MISSION_HOTSWAP_STAGE_ENUM
|
|
MISSION_HOTSWAP_STAGE_SELECT_CHARACTER = 0,
|
|
MISSION_HOTSWAP_STAGE_DO_SPLINE_CAM,
|
|
MISSION_HOTSWAP_STAGE_DONE
|
|
ENDENUM
|
|
|
|
ENUM MISSION_STREAMING_STAGE_ENUM
|
|
MISSION_STREAMING_STAGE_REQUEST = 0,
|
|
MISSION_STREAMING_STAGE_WAIT,
|
|
MISSION_STREAMING_STAGE_COMPLETE
|
|
ENDENUM
|
|
|
|
ENUM FINALE_MODEL_ENUM
|
|
FM_MICHAEL = 0,
|
|
FM_FRANKLIN,
|
|
FM_TREVOR,
|
|
FM_LAMAR,
|
|
FM_FIB,
|
|
FM_MERC,
|
|
FM_FIB_VAN,
|
|
FM_MERC_4WD,
|
|
FM_MERC_CHOPPER,
|
|
FM_ANCHOR,
|
|
FM_BARREL,
|
|
FM_PHONE,
|
|
FM_CRATE
|
|
ENDENUM
|
|
|
|
ENUM FINALE_VECTOR_ENUM
|
|
FINVEC_PLAYER_INIT = 0,
|
|
FINVEC_TREVOR_INIT,
|
|
FINVEC_MICHAEL_INIT,
|
|
FINVEC_LAMAR_INIT,
|
|
FINVEC_LAMAR_SHOOTOUT,
|
|
FINVEC_LESTERS_CAR_INIT,
|
|
FINVEC_PARK,
|
|
FINVEC_FOUNDRY_DOOR,
|
|
FINVEC_TOP_DOOR,
|
|
FINVEC_FOUNDRY_CENTER,
|
|
FINVEC_SEE_FRANKLIN,
|
|
FINVEC_GAS_TANK,
|
|
FINVEC_MEETING_GANTRY,
|
|
FINVEC_MEETING_FRANKLIN,
|
|
FINVEC_MEETING_MICHAEL,
|
|
FINVEC_MEETING_TREVOR,
|
|
FINVEC_AFTER_MEETING_FRANKLIN,
|
|
FINVEC_AFTER_MEETING_MICHAEL,
|
|
FINVEC_AFTER_MEETING_TREVOR,
|
|
FINVEC_FRANKLIN_READY,
|
|
FINVEC_MICHAEL_READY,
|
|
FINVEC_TREVOR_READY,
|
|
FINVEC_TREVOR_SAVETREVOR,
|
|
FINVEC_MICHAEL_SAVETREVOR,
|
|
FINVEC_IN_POSITION,
|
|
FINVEC_FRANKLIN_OUTSIDE_READY,
|
|
FINVEC_MICHAEL_GROUND_READY,
|
|
FINVEC_TREVOR_OUTSIDE_READY,
|
|
FINVEC_TOP_INNER_COVER,
|
|
FINVEC_BOTTOM_INNER_COVER,
|
|
FINVEC_TOP_OUTER_COVER,
|
|
FINVEC_BOTTOM_OUTER_COVER,
|
|
FINVEC_OUTSIDE_BATTLE_CENTER,
|
|
FINVEC_REGROUP
|
|
ENDENUM
|
|
|
|
ENUM FINALE_VEHICLE_ENUM
|
|
FV_MISSION_START_CAR = 0,
|
|
FV_FRANKLIN_CAR,
|
|
FV_MICHAEL_CAR,
|
|
FV_TREVOR_CAR
|
|
ENDENUM
|
|
|
|
ENUM FINALE_ANIM_DICT_ENUM
|
|
F_ANIM_DICT_MCS_1_LEADIN=0,
|
|
F_ANIM_DICT_LAMAR_WAIT,
|
|
F_ANIM_DICT_LAMAR_LOOKOUT
|
|
ENDENUM
|
|
|
|
ENUM FINALE_WEAPON_ENUM
|
|
F_WEAPON_LMG = 0,
|
|
F_WEAPON_FIB_RIFLE,
|
|
F_WEAPON_MERC_RIFLE,
|
|
F_WEAPON_SNIPER,
|
|
F_WEAPON_PISTOL
|
|
ENDENUM
|
|
|
|
ENUM FINALE_SFX_ENUM
|
|
F_SFX_FOUNDRY_01 = 0,
|
|
F_SFX_FOUNDRY_02
|
|
ENDENUM
|
|
|
|
ENUM FINALE_MISC_ASSET_ENUM
|
|
F_MISC_ASSET_TEMP = 0
|
|
ENDENUM
|
|
|
|
ENUM FINALE_CUTSCENE_STAGE_ENUM
|
|
F_CUT_STAGE_INIT = 0,
|
|
F_CUT_STAGE_RUNNING,
|
|
F_CUT_STAGE_CLEANUP
|
|
ENDENUM
|
|
|
|
ENUM LAMAR_WAITS_FOR_CAR
|
|
LAMAR_WAIT_PHONE_LOOP = 0,
|
|
LAMAR_WAIT_PLAYER_ARRIVES,
|
|
LAMAR_WAIT_STOP_PLAYER,
|
|
LAMAR_WAIT_PHONE_OUTRO,
|
|
LAMAR_WAIT_CONVERSATION,
|
|
LAMAR_WAIT_GO_TO_CAR
|
|
ENDENUM
|
|
|
|
ENUM LAMAR_WALK_STAGE_ENUM
|
|
LAMAR_LEAVE_CAR = 0,
|
|
LAMAR_WALK_IN_CAR,
|
|
LAMAR_WALK_LOOK_AT_FRANKLIN,
|
|
LAMAR_WALK_TO_PATH_START,
|
|
LAMAR_WALK_ON_PATH,
|
|
LAMAR_WALK_PLAYING_ANIM,
|
|
LAMAR_WALK_DONE
|
|
ENDENUM
|
|
|
|
ENUM TREVOR_INJURED_STATE
|
|
TREV_INJURED_SETUP,
|
|
TREV_INJURED_WAITING,
|
|
TREV_INJURED_VULNERABLE,
|
|
TREV_INJURED_RESCUED,
|
|
TREV_INJURED_IDLE
|
|
ENDENUM
|
|
|
|
ENUM ALLY_FIGHT_STATE
|
|
ALLY_STATE_INVALID,
|
|
ALLY_STATE_AMBUSH,
|
|
ALLY_STATE_REINITIALIZE,
|
|
ALLY_STATE_INJURED,
|
|
ALLY_STATE_COMBAT_INIT,
|
|
ALLY_STATE_COMBAT,
|
|
ALLY_STATE_GOING_TO_FOUNDRY_INNER_EXIT,
|
|
ALLY_STATE_GOING_TO_FOUNDRY_OUTER_EXIT,
|
|
ALLY_STATE_LOCKED_IN_COVER,
|
|
ALLY_STATE_GOING_TO_FINISH
|
|
ENDENUM
|
|
|
|
ENUM ENEMY_FACTION_ENUM
|
|
ENEMY_FACTION_FIB = 0,
|
|
ENEMY_FACTION_MERC
|
|
ENDENUM
|
|
|
|
ENUM ENEMY_WAVE_ENUM
|
|
// STAGE 1
|
|
EW_FIB_SEARCH = 0,
|
|
EW_MERC_CATWALK,
|
|
EW_MERC_TREVORCORNER,
|
|
EW_FIB_REINFORCEMENTS,
|
|
EW_FIB_ATTACK_TREVOR_GROUND,
|
|
EW_FIB_ATTACK_TREVOR_GROUND_REINF,
|
|
EW_FIB_ATTACK_TREVOR_CATWALK,
|
|
EW_FIB_ATTACK_TREVOR_CLIMAX_1,
|
|
EW_FIB_ATTACK_TREVOR_CLIMAX_2,
|
|
EW_FIB_BATTLE_OUTSIDE,
|
|
EW_MERC_INSIDE,
|
|
EW_FIB_STAGE2_INSIDE,
|
|
EW_FIB_STAGE2_INSIDE_REINF,
|
|
EW_FIB_LAMAR,
|
|
EW_FIB_MID_FIGHTERS_FRONT,
|
|
EW_MERC_MID_FIGHTERS_BACK,
|
|
EW_FIB_REINF_LAMAR,
|
|
EW_FIB_INFINITE_LAMAR,
|
|
EW_MERC_HELI_GROUP,
|
|
EW_MERC_BATTLE_OUTSIDE,
|
|
EW_FIB_GROUND_FLOOR,
|
|
EW_FIB_ON_ROAD,
|
|
EW_MERC_TRAIN_REINF1,
|
|
EW_MERC_TRAIN_REINF2,
|
|
EW_FIB_ROAD_REINF,
|
|
EW_MERC_UP_ROAD
|
|
ENDENUM
|
|
|
|
ENUM ENEMY_PED_ENUM
|
|
// STAGE 1
|
|
// FIB enter wave inside
|
|
EP_FIB_SEARCH_FOOT_1 = 0,
|
|
EP_FIB_SEARCH_FOOT_2,
|
|
EP_FIB_SEARCH_FOOT_3,
|
|
EP_FIB_SEARCH_FOOT_4,
|
|
EP_FIB_SEARCH_FOOT_5,
|
|
EP_FIB_SEARCH_FOOT_6,
|
|
EP_FIB_SEARCH_FOOT_7,
|
|
|
|
EP_FIB_REINFORCEMENT_FOOT_1,
|
|
EP_FIB_REINFORCEMENT_FOOT_2,
|
|
EP_FIB_REINFORCEMENT_FOOT_3,
|
|
|
|
EP_MERC_TREVORCORNER_FOOT_1,
|
|
EP_MERC_TREVORCORNER_FOOT_2,
|
|
EP_MERC_TREVORCORNER_FOOT_3,
|
|
|
|
// FIB catwalk wave
|
|
EP_MERC_CATWALK_FOOT_1,
|
|
EP_MERC_CATWALK_FOOT_2,
|
|
|
|
EP_FIB_ATTACK_TREVOR_GROUND_1,
|
|
EP_FIB_ATTACK_TREVOR_GROUND_2,
|
|
EP_FIB_ATTACK_TREVOR_GROUND_3,
|
|
EP_FIB_ATTACK_TREVOR_GROUND_4,
|
|
EP_FIB_ATTACK_TREVOR_GROUND_5,
|
|
EP_FIB_ATTACK_TREVOR_GROUND_6,
|
|
EP_FIB_ATTACK_TREVOR_GROUND_7,
|
|
|
|
EP_FIB_ATTACK_TREVOR_CATWALK_1,
|
|
EP_FIB_ATTACK_TREVOR_CATWALK_2,
|
|
|
|
EP_FIB_ATTACK_TREVOR_CLIMAX_1,
|
|
EP_FIB_ATTACK_TREVOR_CLIMAX_2,
|
|
EP_FIB_ATTACK_TREVOR_CLIMAX_3,
|
|
EP_FIB_ATTACK_TREVOR_CLIMAX_4,
|
|
EP_FIB_ATTACK_TREVOR_CLIMAX_5,
|
|
EP_FIB_ATTACK_TREVOR_CLIMAX_6,
|
|
EP_FIB_ATTACK_TREVOR_CLIMAX_7,
|
|
|
|
// FIB enter wave outside
|
|
EP_FIB_BATTLE_OUTSIDE_FOOT_1,
|
|
EP_FIB_BATTLE_OUTSIDE_FOOT_2,
|
|
EP_FIB_BATTLE_OUTSIDE_FOOT_3,
|
|
|
|
// MERC INSIDE WAVE
|
|
EP_MERC_INSIDE_FOOT_1,
|
|
EP_MERC_INSIDE_FOOT_2,
|
|
EP_MERC_INSIDE_FOOT_3,
|
|
|
|
EP_FIB_LAMAR_INSIDE_1,
|
|
EP_FIB_LAMAR_INSIDE_2,
|
|
|
|
EP_FIB_LAMAR_INSIDE_REINF_1,
|
|
EP_FIB_LAMAR_INSIDE_REINF_2,
|
|
|
|
EP_FIB_LAMAR_BATTLE_1,
|
|
EP_FIB_LAMAR_BATTLE_2,
|
|
EP_FIB_LAMAR_BATTLE_3,
|
|
EP_FIB_LAMAR_BATTLE_4,
|
|
EP_FIB_LAMAR_BATTLE_5,
|
|
|
|
EP_FIB_LAMAR_BATTLE_REINF_1,
|
|
EP_FIB_LAMAR_BATTLE_REINF_2,
|
|
EP_FIB_LAMAR_BATTLE_REINF_3,
|
|
EP_FIB_LAMAR_BATTLE_REINF_4,
|
|
EP_FIB_LAMAR_BATTLE_REINF_5,
|
|
|
|
EP_FIB_LAMAR_BATTLE_INFINITE_1,
|
|
EP_FIB_LAMAR_BATTLE_INFINITE_2,
|
|
|
|
// Helicopter group
|
|
EP_MERC_BATTLE_OUTSIDE_CHOPPER_1_PILOT,
|
|
EP_MERC_BATTLE_OUTSIDE_CHOPPER_1_PASSBR,
|
|
// merc outside
|
|
EP_MERC_BATTLE_OUTSIDE_4WD_1_DRIVER,
|
|
EP_MERC_BATTLE_OUTSIDE_4WD_1_PASSFR,
|
|
EP_MERC_BATTLE_OUTSIDE_4WD_2_DRIVER,
|
|
|
|
// FIB ground floor
|
|
EP_FIB_GROUND_FLOOR_FOOT_1,
|
|
EP_FIB_GROUND_FLOOR_FOOT_2,
|
|
EP_FIB_GROUND_FLOOR_FOOT_3,
|
|
EP_FIB_GROUND_FLOOR_FOOT_4,
|
|
|
|
// FIB on road
|
|
EP_FIB_ON_ROAD_FOOT_1,
|
|
EP_FIB_ON_ROAD_FOOT_2,
|
|
EP_FIB_ON_ROAD_FOOT_3,
|
|
EP_FIB_ON_ROAD_FOOT_4,
|
|
|
|
// Mercs up road
|
|
EP_MERC_TRAIN_4WD_1_DRIVER,
|
|
EP_MERC_TRAIN_4WD_1_PASSFR,
|
|
EP_MERC_TRAIN_4WD_2_DRIVER,
|
|
EP_MERC_TRAIN_4WD_2_PASSFR,
|
|
|
|
EP_FIB_ROAD_REINF_1_DRIVER,
|
|
EP_FIB_ROAD_REINF_1_PASSFR,
|
|
|
|
EP_FIB_MID_FIGHTERS_FRONT_1,
|
|
EP_FIB_MID_FIGHTERS_FRONT_2,
|
|
EP_FIB_MID_FIGHTERS_FRONT_3,
|
|
EP_FIB_MID_FIGHTERS_BACK_1,
|
|
EP_FIB_MID_FIGHTERS_BACK_2,
|
|
EP_FIB_MID_FIGHTERS_BACK_3,
|
|
|
|
// Mercs up road
|
|
EP_MERC_UP_ROAD_4WD_1_DRIVER,
|
|
EP_MERC_UP_ROAD_4WD_2_DRIVER
|
|
ENDENUM
|
|
|
|
ENUM ENEMY_VEHICLE_ENUM
|
|
EV_MERC_BATTLE_OUTSIDE_CHOPPER_1 = 0,
|
|
EV_MERC_BATTLE_OUTSIDE_4WD_1,
|
|
EV_MERC_BATTLE_OUTSIDE_4WD_2,
|
|
EV_MERC_UP_ROAD_4WD_1,
|
|
EV_MERC_UP_ROAD_4WD_2,
|
|
EV_MERC_TRAIN_4WD_1,
|
|
EV_MERC_TRAIN_4WD_2,
|
|
EV_FIB_ROAD_REINF_1,
|
|
EV_FIB_FIGHTING_LAMAR
|
|
ENDENUM
|
|
|
|
ENUM FREE_HOTSWAP_STATE_ENUM
|
|
FREE_HOTSWAP_STATE_SELECTING = 0,
|
|
FREE_HOTSWAP_STATE_IN_PROGRESS
|
|
ENDENUM
|
|
|
|
ENUM ENEMY_TASK_TYPE
|
|
TASK_TYPE_FLY_HELI = 0,
|
|
TASK_TYPE_SHOOT_FROM_HELI,
|
|
TASK_TYPE_FOOT_COMBAT
|
|
ENDENUM
|
|
|
|
ENUM ENEMY_TASK_STATUS
|
|
ENEMY_TASK_STATUS_NO_TASK = 0,
|
|
ENEMY_TASK_STATUS_FOLLOW_ROUTE,
|
|
ENEMY_TASK_STATUS_ENTERING_FOUNDRY,
|
|
ENEMY_TASK_LEAVING_FORBIDDEN_ZONE,
|
|
ENEMY_TASK_STATUS_COMBAT,
|
|
ENEMY_TASK_STATUS_CHARGING
|
|
ENDENUM
|
|
|
|
ENUM MEETING_SHOT_ENUM
|
|
MEETING_SHOT_GANTRY = 0,
|
|
MEETING_SHOT_LAMAR,
|
|
MEETING_SHOT_FIB_ARRIVE
|
|
ENDENUM
|
|
|
|
|
|
// Consts
|
|
CONST_INT NUMBER_MODEL_REQUEST_SLOTS COUNT_OF(FINALE_MODEL_ENUM)
|
|
CONST_INT NUMBER_RECORDING_REQUEST_SLOTS 10
|
|
CONST_INT NUMBER_WAYPOINT_REQUEST_SLOTS 9
|
|
|
|
CONST_INT NUMBER_BARRELS 4
|
|
CONST_INT NUMBER_EXITS 3
|
|
CONST_INT NUMBER_PLAYER_COVER_POINTS 3
|
|
|
|
CONST_INT iEXIT_CATWALK 0
|
|
CONST_INT iEXIT_OFFICE 1
|
|
CONST_INT iEXIT_BACK 2
|
|
|
|
CONST_INT MIN_RANDOM_SPEECH_TIME 7000
|
|
CONST_INT MAX_RANDOM_SPEECH_TIME 12000
|
|
|
|
CONST_INT BIG_EVENT_TIME_SPACING 10000
|
|
|
|
CONST_INT MAX_SKIP_MENU_LENGTH 8
|
|
CONST_INT SKIP_FADE_WAIT_TIME 200
|
|
|
|
CONST_INT kiTrevorUninjuredTime 2000
|
|
|
|
CONST_INT iDefaultAccuracy 14
|
|
CONST_INT iLowAccuracy 5
|
|
|
|
CONST_FLOAT PLAYER_INIT_ROT 204.87
|
|
CONST_FLOAT TREVOR_INIT_ROT 57.04
|
|
CONST_FLOAT MICHAEL_INIT_ROT 14.7
|
|
CONST_FLOAT LAMAR_INIT_ROT 210.0
|
|
CONST_FLOAT LAMAR_SHOOTOUT_ROT 85.0
|
|
CONST_FLOAT LAMAR_IN_TOWER_ROT -94.5
|
|
CONST_FLOAT LESTERS_CAR_INIT_ROT 116.20
|
|
CONST_FLOAT PARK_CAR_ROT -127.01
|
|
CONST_FLOAT FRANKLIN_MEETING_ROT 114.12
|
|
CONST_FLOAT MICHAEL_MEETING_ROT -87.12
|
|
CONST_FLOAT TREVOR_MEETING_ROT -62.48
|
|
CONST_FLOAT FRANKLIN_AFTER_MEETING_ROT -107.12
|
|
CONST_FLOAT MICHAEL_AFTER_MEETING_ROT -126.34
|
|
CONST_FLOAT TREVOR_AFTER_MEETING_ROT -17.7
|
|
CONST_FLOAT FRANKLIN_READY_ROT 323.6474
|
|
CONST_FLOAT MICHAEL_READY_ROT 52.1
|
|
CONST_FLOAT TREVOR_READY_ROT 173.77
|
|
CONST_FLOAT MICHAEL_SAVETREVOR_ROT 76.0
|
|
CONST_FLOAT TREVOR_SAVETREVOR_ROT 221.1
|
|
CONST_FLOAT FRANKLIN_OUTSIDE_READY_ROT 56.5751
|
|
CONST_FLOAT MICHAEL_GROUND_READY_ROT 83.8774
|
|
CONST_FLOAT TREVOR_GROUND_READY_ROT 237.0881
|
|
CONST_FLOAT FOUNDRY_HEADING 35.0
|
|
CONST_FLOAT FRANKLIN_INIT_ROT2 121.14
|
|
CONST_FLOAT TREVOR_INIT_ROT2 57.04
|
|
CONST_FLOAT MICHAEL_INIT_ROT2 63.41
|
|
|
|
CONST_FLOAT CLEAR_POS_RADIUS 3.2
|
|
|
|
CONST_FLOAT LAMAR_DEATH_TIME 75.0
|
|
CONST_FLOAT LAMAR_DESPARATE_TIME 50.0
|
|
|
|
// Structs
|
|
STRUCT ENEMY_PED
|
|
PED_INDEX ped
|
|
BOOL bBlockTask
|
|
BOOL bAlive
|
|
AI_BLIP_STRUCT blipStruct
|
|
ENEMY_TASK_STATUS enemyTaskStatus
|
|
BOOL bRegisteredDead
|
|
INT iTaskTime
|
|
ENDSTRUCT
|
|
|
|
STRUCT ENEMY_VEHICLE
|
|
VEHICLE_INDEX veh
|
|
//BLIP_INDEX blip
|
|
ENDSTRUCT
|
|
|
|
STRUCT FREE_HOTSWAP_DATA
|
|
SELECTOR_SLOTS_ENUM swapTarget
|
|
FREE_HOTSWAP_STATE_ENUM state
|
|
ENDSTRUCT
|
|
|
|
STRUCT ALLY_STATE_DATA
|
|
ALLY_FIGHT_STATE currentState
|
|
INT iCurrentTaskTime
|
|
INT iLastShotTime
|
|
ENDSTRUCT
|
|
|
|
STRUCT FINALE_PICKUP
|
|
PICKUP_INDEX puIndex
|
|
VECTOR vPickupLoc
|
|
VECTOR vPickupRot
|
|
ENDSTRUCT
|
|
FINALE_PICKUP eFinalePickups[3]
|
|
|
|
TRAVEL_GOAL eTravelCurrentGoal = TRAVEL_INIT
|
|
TRAVEL_TEXT eTravelCurrentText = TRAVEL_TEXT_IDLE
|
|
ARGUMENT_TEXT eArgumentCurrentText = ARG_TEXT_IDLE
|
|
KICKOFF_TEXT eKickOffDialogue = KICKOFF_IDLE
|
|
|
|
SHOOTOUT_2_GOAL eShootout2CurrentGoal = SHOOTOUT_2_INIT
|
|
SHOOTOUT_2_TEXT eShootout2CurrentText = SHOOTOUT_2_TEXT_IDLE
|
|
|
|
SHOOTOUT_3_GOAL eShootout3CurrentGoal = SHOOTOUT_3_INIT
|
|
SHOOTOUT_3_TEXT eShootout3CurrentText = SHOOTOUT_3_TEXT_IDLE
|
|
|
|
LOCATES_HEADER_DATA locates_data
|
|
|
|
ALL_AUDIO_SCENES eAudioSceneState = AUDIO_IDLE
|
|
|
|
// 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
|
|
MOCAP_STREAMING_STAGE_ENUM endcutStreamingStage
|
|
FINALE_CUTSCENE_STAGE_ENUM cutsceneStage
|
|
SELECTOR_PED_STRUCT sSelectorPeds
|
|
SELECTOR_CAM_STRUCT sCamDetails
|
|
LAMAR_WAITS_FOR_CAR eLamarWaitCarState = LAMAR_WAIT_PHONE_LOOP
|
|
LAMAR_WALK_STAGE_ENUM lamarWalkStage
|
|
WEAPON_TYPE wepFranklinWepGoingIntoMeetup
|
|
|
|
ALLY_STATE_DATA eAllyStates[COUNT_OF(SELECTOR_SLOTS_ENUM)]
|
|
|
|
TREVOR_INJURED_STATE eTrevorInjuredState = TREV_INJURED_IDLE
|
|
FREE_HOTSWAP_DATA freeHotswapData
|
|
ENEMY_PED enemyPed[COUNT_OF(ENEMY_PED_ENUM)]
|
|
ENEMY_VEHICLE enemyVehicle[COUNT_OF(ENEMY_VEHICLE_ENUM)]
|
|
|
|
MODEL_NAMES mapPlacedGasTank = PROP_GAS_TANK_02A
|
|
|
|
TRIGGER_BOX tbFoundryExcess
|
|
|
|
TRIGGER_BOX tbForceWalkAroundStairs
|
|
TRIGGER_BOX tbTriggerMeetCrewScene
|
|
TRIGGER_BOX tbBackupMeetCrewSceneTrigger
|
|
|
|
TRIGGER_BOX tbBottomExit2Buffer
|
|
|
|
TRIGGER_BOX tbForbiddenZone
|
|
|
|
TRIGGER_BOX tbCloserToCatwalkExit
|
|
|
|
// door checks
|
|
TRIGGER_BOX tbTopExitInner
|
|
TRIGGER_BOX tbTopExitOuter
|
|
TRIGGER_BOX tbBottomExit1Inner
|
|
TRIGGER_BOX tbBottomExit1Outer
|
|
TRIGGER_BOX tbBottomExit2Inner
|
|
TRIGGER_BOX tbBottomExit2Outer
|
|
|
|
TRIGGER_BOX tbBottomApproachBackFight
|
|
TRIGGER_BOX tbBottomApproachFrontFight
|
|
|
|
TRIGGER_BOX tbSaveLamarFailsafe1
|
|
TRIGGER_BOX tbSaveLamarFailsafe2
|
|
TRIGGER_BOX tbSaveLamar
|
|
|
|
TRIGGER_BOX tbBottomOfStairs
|
|
|
|
structTimer tmrMichaelIncidental
|
|
structTimer tmrTrevorIncidental
|
|
structTimer tmrFranklinIncidental
|
|
structTimer tmrLamarIncidental
|
|
structTimer tmrLamarDies
|
|
structTimer tmrSearchReactionDelay
|
|
structTimer tmrTrevorGetUpDelay
|
|
structTimer tmrStage3SecondWaveBackup
|
|
structTimer tmrTrevorInjuredFailTime
|
|
structTimer tmrTopOuterBuddyAppear
|
|
structTimer tmrHelicopterDialogue
|
|
structTimer tmrHeliExplode
|
|
structTimer tmrKickoffDialogue
|
|
|
|
structTimer tmrSwitchToMikeFailTime
|
|
|
|
INT iMichaelIncidentalTime
|
|
INT iFranklinIncidentalTime
|
|
INT iTrevorIncidentalTime
|
|
INT iLamarIncidentalTime
|
|
INT iMichaelCallsShotCount
|
|
INT iTrevorCallsShotCount
|
|
INT iSquibID = 0
|
|
INT iHeliCombatState = 0
|
|
INT iHeliAttackPause = 0
|
|
|
|
TRIGGER_BOX tbInjuredTrevor
|
|
|
|
TRIGGER_BOX tbNearingBottomExit1
|
|
|
|
REL_GROUP_HASH relgroupIgnore
|
|
|
|
// Peds
|
|
PED_INDEX pedLester
|
|
PED_INDEX lamarPed
|
|
SELECTOR_SLOTS_ENUM selectorPedToTopExit
|
|
|
|
// Vehicles
|
|
VEHICLE_INDEX finaleVehicle[COUNT_OF(FINALE_VEHICLE_ENUM)]
|
|
VEHICLE_INDEX ambientVehicles[4]
|
|
|
|
// Objects
|
|
OBJECT_INDEX objWheelchair
|
|
OBJECT_INDEX foundryRootObject
|
|
OBJECT_INDEX interiorBarrelObject[NUMBER_BARRELS]
|
|
OBJECT_INDEX exteriorBarrelObject[1]
|
|
OBJECT_INDEX coverCrate
|
|
OBJECT_INDEX lamarsPhone
|
|
OBJECT_INDEX backFightCoverCrates[2]
|
|
|
|
// Blips
|
|
BLIP_INDEX gotoBlip
|
|
BLIP_INDEX vehicleBlip
|
|
BLIP_INDEX lamarBlip
|
|
BLIP_INDEX buddyBlip[3]
|
|
BLIP_INDEX exitBlip[NUMBER_EXITS]
|
|
BLIP_INDEX fakeEnemyBlips[5]
|
|
|
|
// Bools
|
|
BOOL bModelRequestTracker[COUNT_OF(FINALE_MODEL_ENUM)]
|
|
BOOL bVehicleRecordingRequestTracker[NUMBER_RECORDING_REQUEST_SLOTS]
|
|
BOOL bWaypointRequestTracker[NUMBER_WAYPOINT_REQUEST_SLOTS]
|
|
BOOL bAnimDictRequestTracker[COUNT_OF(FINALE_ANIM_DICT_ENUM)]
|
|
BOOL bWeaponRequestTracker[COUNT_OF(FINALE_WEAPON_ENUM)]
|
|
BOOL bSFXRequestTracker[COUNT_OF(FINALE_SFX_ENUM)]
|
|
BOOL bThoroughCleanup
|
|
BOOL bForcePassOnShitskip = FALSE
|
|
BOOL bRequestedLamarCarModel
|
|
BOOL bRunningCutscene
|
|
BOOL bClearedForCutscene
|
|
BOOL bCutsceneWaitStarted
|
|
BOOL bStartedArgument
|
|
BOOL bShownGodText
|
|
BOOL bShownReturnText
|
|
BOOL bInteriorPinned
|
|
BOOL bDoneIntroCreateEntities
|
|
BOOL bDoneIntroClearStart
|
|
BOOL bLamarApproached
|
|
BOOL bTrevorIsInjured
|
|
BOOL bDoneArrivalSpeech
|
|
BOOL bKilledAll
|
|
BOOL bCreatedCatwalkWave
|
|
BOOL bCreatedTrevorCornerWave
|
|
BOOL bSwitchedToMichaelForCatwalkKill
|
|
BOOL bReinforcementWarning
|
|
BOOL bEnemyInfightingDialogue
|
|
BOOL bSwitchedToTrevorForCornerKill
|
|
BOOL bTrevorAnnouncesMerryweather
|
|
BOOL bCatwalkWaveDialogue
|
|
BOOL bCreatedInsideMercWave
|
|
BOOL bCreatedFIBReinforcements
|
|
BOOL bShootoutStarted
|
|
BOOL bShownAmbushText
|
|
BOOL bLockSelector
|
|
BOOL bForceSwitch
|
|
BOOL bShownKillAllText
|
|
BOOL bShownRegroupText
|
|
BOOL bRegroupDialogue
|
|
BOOL bCreatedRoadMercs
|
|
BOOL bGoneOutsideDialogue
|
|
BOOL bShootout4ObjectiveDialogue
|
|
BOOL bCreatedAmbientCopCars
|
|
BOOL bTaskedTopPlayerOut
|
|
BOOL bCreatedTrainMercs1
|
|
BOOL bCreatedTrainMercs2
|
|
BOOL bCreatedFIBRoadReinf
|
|
BOOL bCreatedLamarFight
|
|
BOOL bCreatedMidChargers
|
|
BOOL bRingToneStarted
|
|
BOOL bRingToneStopped
|
|
BOOL bAddedInteriorBlip
|
|
BOOL bCreatedMichaelAndTrevor
|
|
BOOL bAddedGantryBlip
|
|
BOOL bPreparedMichaelShoutCue
|
|
BOOL bDoneMichaelShoutCue
|
|
BOOL bPreparedSWATCue
|
|
BOOL bDoneSWATCue
|
|
BOOL bDoneFightCue
|
|
BOOL bDoneRegroupCue
|
|
BOOL bDoneAtVehiclesCue
|
|
BOOL bLamarWasSaved
|
|
BOOL bToggledBackFightInvuln = FALSE
|
|
BOOL bSpawnedHelicopter = FALSE
|
|
BOOL bTopInPositionPlayed = FALSE
|
|
BOOL bTopIsOutOfPosition = FALSE
|
|
BOOL bLamarCalmedDown
|
|
BOOL bPlayedChat9
|
|
BOOL bPlayedChat10
|
|
BOOL bPlayedChat11
|
|
BOOL bForceEndCutsceneToRunWhenLoaded = FALSE
|
|
BOOL bSuppressGreeting
|
|
BOOL bDoneLamarAskForHelp
|
|
BOOL bResetViewOnSkip
|
|
|
|
// audio scene bools
|
|
BOOL bAudioStartShootout1 = FALSE
|
|
BOOL bAudioPlayNewWaveOneShot = FALSE
|
|
BOOL bAudioGetToLamar = FALSE
|
|
BOOL bAudioStartShootout4 = FALSE
|
|
BOOL bAudioStopShootout4 = FALSE
|
|
BOOL bAudioHelicopterArrives = FALSE
|
|
|
|
|
|
// Vectors
|
|
VECTOR vDefensiveAreaCenter = <<1095.2019, -1999.4622, 28.6039>>
|
|
|
|
// Floats
|
|
//FLOAT fGondolaRadius = 10
|
|
|
|
// Ints
|
|
INT iFIBReactionCount
|
|
INT iFIBReactionStartTime
|
|
|
|
INT iAllowSkipCutsceneTime
|
|
INT iNextRandomSpeechTime
|
|
INT iClearHelpTime
|
|
|
|
INT iNextTurnBuddyTime[3]
|
|
|
|
INT sceneIdStandoff = -1
|
|
|
|
INT iBottom1Blocker
|
|
INT iBottom2Blocker
|
|
INT iTopBlocker
|
|
|
|
INT iGroundFloorBlocker1
|
|
|
|
INT iOutsideFrontFightRearBlocker
|
|
|
|
// Other variables
|
|
SEQUENCE_INDEX sequence
|
|
INTERIOR_INSTANCE_INDEX foundryInterior
|
|
SCRIPTTASKSTATUS taskStatus
|
|
structPedsForConversation finaleConversation
|
|
REL_GROUP_HASH fibRelGroup
|
|
REL_GROUP_HASH mercRelGroup
|
|
SCENARIO_BLOCKING_INDEX foundryScenarioBlocking
|
|
COVERPOINT_INDEX initialCover[NUMBER_PLAYER_COVER_POINTS]
|
|
COVERPOINT_INDEX franklinExitOuterCover
|
|
COVERPOINT_INDEX bottomExit2InnerCover
|
|
COVERPOINT_INDEX bottomExit2OuterCover
|
|
COVERPOINT_INDEX topExitInnerCover
|
|
COVERPOINT_INDEX michaelCatwalkCover
|
|
COVERPOINT_INDEX trevorInjuredCover
|
|
COVERPOINT_INDEX topExitOuterCover
|
|
COVERPOINT_INDEX outsideShackCornerCover
|
|
|
|
// Debug
|
|
#IF IS_DEBUG_BUILD
|
|
WIDGET_GROUP_ID finaleWidgets
|
|
TEXT_WIDGET_ID RBCamPosWidget, RBCamRotWidget
|
|
BOOL bRBDebugCamDoDump
|
|
VECTOR vRBDebugCamPos
|
|
VECTOR vRBDebugCamRot
|
|
FLOAT fRBDebugCamFOV
|
|
|
|
MissionStageMenuTextStruct stageMenu[MAX_SKIP_MENU_LENGTH]
|
|
INT iMenuMissionStage
|
|
|
|
INT iDebugStage = -1
|
|
|
|
BOOL bDebugJSkip
|
|
#ENDIF
|
|
|
|
FUNC STRING GET_FINALE_INTRO_CUTSCENE_NAME()
|
|
RETURN "fin_c_int"
|
|
ENDFUNC
|
|
|
|
// get recording prefix
|
|
FUNC STRING GET_FINALE_RECORDING_PREFIX()
|
|
RETURN "finalec"
|
|
ENDFUNC
|
|
|
|
FUNC STRING GET_DESCRIPTION_FOR_STAGE_AS_STRING(MISSION_STAGE_ENUM thisStage)
|
|
SWITCH thisStage
|
|
CASE STAGE_GET_TO_FOUNDRY
|
|
RETURN "Get to the foundry"
|
|
BREAK
|
|
CASE STAGE_MEET_GANG
|
|
RETURN "Meet Michael and Trevor"
|
|
BREAK
|
|
CASE STAGE_SHOOTOUT_STAGE_1
|
|
RETURN "Shootout 1 - FIB Arrives"
|
|
BREAK
|
|
CASE STAGE_SHOOTOUT_STAGE_2
|
|
RETURN "Shootout 2 - Franklin helps Lamar"
|
|
BREAK
|
|
CASE STAGE_SHOOTOUT_STAGE_3
|
|
RETURN "Shootout 3 - Protect Trevor"
|
|
BREAK
|
|
CASE STAGE_SHOOTOUT_STAGE_4
|
|
RETURN "Shootout 4 - Outside"
|
|
BREAK
|
|
CASE STAGE_OUTRO_CUTSCENE
|
|
RETURN "Outro cutscene"
|
|
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)
|
|
IF NOT IS_HELP_MESSAGE_BEING_DISPLAYED()
|
|
IF CAN_ADVANCE_MISSION()
|
|
PRINT_HELP(sHelpText)
|
|
RETURN TRUE
|
|
ENDIF
|
|
ENDIF
|
|
|
|
RETURN FALSE
|
|
ENDFUNC
|
|
|
|
// do mission speech
|
|
FUNC BOOL DO_MISSION_SPEECH(STRING sSpeech, BOOL bSupercedeText = FALSE, INT iLine = 0)
|
|
IF bSupercedeText OR NOT IS_MESSAGE_BEING_DISPLAYED() OR NOT IS_SUBTITLE_PREFERENCE_SWITCHED_ON()
|
|
IF NOT IS_ANY_CONVERSATION_ONGOING_OR_QUEUED()
|
|
IF CAN_ADVANCE_MISSION()
|
|
IF iLine = 0
|
|
RETURN CREATE_CONVERSATION(finaleConversation, "FINC1AU", sSpeech, CONV_PRIORITY_HIGH)
|
|
ELSE
|
|
TEXT_LABEL tLine
|
|
tLine = sSpeech
|
|
tLine+="_"
|
|
tLine+=iLine
|
|
RETURN PLAY_SINGLE_LINE_FROM_CONVERSATION(finaleConversation, "FINC1AU", sSpeech, tLine, CONV_PRIORITY_HIGH)
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
|
|
RETURN FALSE
|
|
ENDFUNC
|
|
|
|
// remove mission text
|
|
PROC REMOVE_MISSION_TEXT(BOOL bClearSpeech = TRUE, BOOL bClearGodText = TRUE, BOOL bClearHelpText = TRUE, BOOL bKeepSubs = FALSE)
|
|
IF bClearSpeech
|
|
KILL_ANY_CONVERSATION()
|
|
ENDIF
|
|
|
|
IF bClearGodText
|
|
IF NOT IS_ANY_CONVERSATION_ONGOING_OR_QUEUED()
|
|
OR (bClearSpeech AND NOT bKeepSubs)
|
|
CLEAR_PRINTS()
|
|
ENDIF
|
|
CLEAR_REMINDER_MESSAGE()
|
|
ENDIF
|
|
|
|
IF bClearHelpText
|
|
IF GET_GAME_TIMER() >= iClearHelpTime + 1000
|
|
CLEAR_HELP()
|
|
iClearHelpTime = GET_GAME_TIMER()
|
|
ENDIF
|
|
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
|
|
|
|
PROC CREATE_FAKE_ENEMY_BLIPS()
|
|
fakeEnemyBlips[0] = ADD_BLIP_FOR_COORD(<<1081.48, -2047.89, 29.99>>)
|
|
fakeEnemyBlips[1] = ADD_BLIP_FOR_COORD(<<1078.59, -2042.40, 31.31>>)
|
|
fakeEnemyBlips[2] = ADD_BLIP_FOR_COORD(<<1076.49, -2041.62, 30.01>>)
|
|
fakeEnemyBlips[3] = ADD_BLIP_FOR_COORD(<<1045.9607, -1957.5865, 34.1391>>)
|
|
fakeEnemyBlips[4] = ADD_BLIP_FOR_COORD(<<1054.7507, -1964.7998, 30.0444>>)
|
|
|
|
INT i
|
|
REPEAT COUNT_OF(fakeEnemyBlips) i
|
|
IF DOES_BLIP_EXIST(fakeEnemyBlips[i])
|
|
SET_BLIP_COLOUR(fakeEnemyBlips[i], BLIP_COLOUR_RED)
|
|
SET_BLIP_SCALE(fakeEnemyBlips[i], BLIP_SIZE_PED)
|
|
ENDIF
|
|
ENDREPEAT
|
|
ENDPROC
|
|
|
|
PROC DELETE_FAKE_ENEMY_BLIPS()
|
|
INT i
|
|
REPEAT COUNT_OF(fakeEnemyBlips) i
|
|
IF DOES_BLIP_EXIST(fakeEnemyBlips[i])
|
|
REMOVE_BLIP(fakeEnemyBlips[i])
|
|
ENDIF
|
|
ENDREPEAT
|
|
ENDPROC
|
|
|
|
PROC INITIALIZE_FINALE_PICKUP_DATA()
|
|
// main entrance, first aid station
|
|
eFinalePickups[0].vPickupLoc = <<1077.09424, -1976.670, 32.132>>
|
|
eFinalePickups[0].vPickupRot = <<0.0, 0.0, -44.9>>
|
|
// other downstairs entry
|
|
eFinalePickups[1].vPickupLoc = <<1074.820, -2008.030, 32.162>>
|
|
eFinalePickups[1].vPickupRot = <<0.0, 0.0, 73.1>>
|
|
// upstairs entry
|
|
eFinalePickups[2].vPickupLoc = <<1081.710, -2018.570, 41.035>>
|
|
eFinalePickups[2].vPickupRot = <<0.0, 0.0, 154.5>>
|
|
ENDPROC
|
|
|
|
PROC CREATE_FINALE_PICKUPS()
|
|
INITIALIZE_FINALE_PICKUP_DATA()
|
|
INT idx
|
|
REPEAT COUNT_OF(eFinalePickups) idx
|
|
IF NOT DOES_PICKUP_EXIST(eFinalePickups[idx].puIndex)
|
|
eFinalePickups[idx].puIndex = CREATE_PICKUP_ROTATE(PICKUP_HEALTH_STANDARD, eFinalePickups[idx].vPickupLoc, eFinalePickups[idx].vPickupRot)
|
|
ENDIF
|
|
ENDREPEAT
|
|
ENDPROC
|
|
|
|
PROC DELETE_FINALE_PICKUPS()
|
|
INT idx
|
|
REPEAT COUNT_OF(eFinalePickups) idx
|
|
IF DOES_PICKUP_EXIST(eFinalePickups[idx].puIndex)
|
|
REMOVE_PICKUP(eFinalePickups[idx].puIndex)
|
|
ENDIF
|
|
ENDREPEAT
|
|
ENDPROC
|
|
|
|
FUNC BOOL TRIGGER_MISSION_MUSIC_EVENT(STRING sEvent)
|
|
RETURN TRIGGER_MUSIC_EVENT(sEvent)
|
|
ENDFUNC
|
|
|
|
FUNC BOOL SHOULD_USE_REPLAY_VEHICLE(MISSION_STAGE_ENUM checkStage)
|
|
IF IS_REPLAY_CHECKPOINT_VEHICLE_AVAILABLE()
|
|
IF IS_REPLAY_CHECKPOINT_VEHICLE_UNDER_SIZE_LIMIT(GET_DEFAULT_ALLOWABLE_VEHICLE_SIZE_VECTOR())
|
|
AND ((GET_REPLAY_CHECKPOINT_VEHICLE_MODEL() <> SOVEREIGN AND GET_VEHICLE_MODEL_NUMBER_OF_SEATS(GET_REPLAY_CHECKPOINT_VEHICLE_MODEL()) >= 2) OR checkStage = STAGE_GET_TO_FOUNDRY)
|
|
RETURN TRUE
|
|
ELSE
|
|
CPRINTLN(DEBUG_MISSION, "SHOULD_USE_REPLAY_VEHICLE vehicle size is over limit")
|
|
ENDIF
|
|
ELSE
|
|
CPRINTLN(DEBUG_MISSION, "SHOULD_USE_REPLAY_VEHICLE no replay start vehicle available")
|
|
ENDIF
|
|
|
|
RETURN FALSE
|
|
ENDFUNC
|
|
|
|
FUNC STRING GET_RECORD_PREFIX()
|
|
RETURN "SaveMichaelAndTrevorP1"
|
|
ENDFUNC
|
|
|
|
PROC WAIT_WITH_RECORD()
|
|
WAIT(0)
|
|
REPLAY_CHECK_FOR_EVENT_THIS_FRAME(GET_RECORD_PREFIX())
|
|
ENDPROC
|
|
|
|
// get model for a train crash model enum
|
|
FUNC MODEL_NAMES GET_MODEL_FOR_FINALE_MODEL_ENUM(FINALE_MODEL_ENUM FModel)
|
|
SWITCH FModel
|
|
CASE FM_MICHAEL
|
|
RETURN GET_PLAYER_PED_MODEL(CHAR_MICHAEL)
|
|
BREAK
|
|
CASE FM_FRANKLIN
|
|
RETURN GET_PLAYER_PED_MODEL(CHAR_FRANKLIN)
|
|
BREAK
|
|
CASE FM_TREVOR
|
|
RETURN GET_PLAYER_PED_MODEL(CHAR_TREVOR)
|
|
BREAK
|
|
CASE FM_LAMAR
|
|
RETURN GET_NPC_PED_MODEL(CHAR_LAMAR)
|
|
BREAK
|
|
CASE FM_FIB
|
|
RETURN S_M_Y_SWAT_01
|
|
BREAK
|
|
CASE FM_FIB_VAN
|
|
RETURN FBI2
|
|
BREAK
|
|
CASE FM_MERC
|
|
RETURN S_M_Y_BLACKOPS_01
|
|
BREAK
|
|
CASE FM_MERC_4WD
|
|
RETURN MESA3
|
|
BREAK
|
|
CASE FM_MERC_CHOPPER
|
|
RETURN BUZZARD
|
|
BREAK
|
|
CASE FM_ANCHOR
|
|
RETURN GET_RAPPEL_ANCHOR_MODEL_NAME()
|
|
BREAK
|
|
CASE FM_BARREL
|
|
RETURN prop_barrel_exp_01a
|
|
BREAK
|
|
CASE FM_PHONE
|
|
RETURN PROP_NPC_PHONE
|
|
BREAK
|
|
CASE FM_CRATE
|
|
RETURN PROP_BOX_WOOD03A
|
|
BREAK
|
|
ENDSWITCH
|
|
|
|
RETURN DUMMY_MODEL_FOR_SCRIPT
|
|
ENDFUNC
|
|
|
|
// suppress vehicles
|
|
PROC SUPPRESS_MISSION_VEHICLES(BOOL bSuppress)
|
|
SET_VEHICLE_MODEL_IS_SUPPRESSED(GET_MODEL_FOR_FINALE_MODEL_ENUM(FM_MERC_4WD), bSuppress)
|
|
|
|
SET_PED_MODEL_IS_SUPPRESSED(GET_MODEL_FOR_FINALE_MODEL_ENUM(FM_LAMAR), bSuppress)
|
|
SET_PED_MODEL_IS_SUPPRESSED(GET_MODEL_FOR_FINALE_MODEL_ENUM(FM_FIB), bSuppress)
|
|
SET_PED_MODEL_IS_SUPPRESSED(GET_MODEL_FOR_FINALE_MODEL_ENUM(FM_MERC), 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)
|
|
bEnable=bEnable
|
|
ENDPROC
|
|
|
|
|
|
// which ped is michael?
|
|
FUNC PED_INDEX GET_MICHAEL_PED()
|
|
IF GET_CURRENT_PLAYER_PED_ENUM() = CHAR_MICHAEL
|
|
RETURN PLAYER_PED_ID()
|
|
ELSE
|
|
RETURN sSelectorPeds.pedID[SELECTOR_PED_MICHAEL]
|
|
ENDIF
|
|
ENDFUNC
|
|
|
|
// which ped is trevor?
|
|
FUNC PED_INDEX GET_TREVOR_PED()
|
|
IF GET_CURRENT_PLAYER_PED_ENUM() = CHAR_TREVOR
|
|
RETURN PLAYER_PED_ID()
|
|
ELSE
|
|
RETURN sSelectorPeds.pedID[SELECTOR_PED_TREVOR]
|
|
ENDIF
|
|
ENDFUNC
|
|
|
|
// which ped is franklin?
|
|
FUNC PED_INDEX GET_FRANKLIN_PED()
|
|
IF GET_CURRENT_PLAYER_PED_ENUM() = CHAR_FRANKLIN
|
|
RETURN PLAYER_PED_ID()
|
|
ELSE
|
|
RETURN sSelectorPeds.pedID[SELECTOR_PED_FRANKLIN]
|
|
ENDIF
|
|
ENDFUNC
|
|
|
|
|
|
FUNC SELECTOR_SLOTS_ENUM GET_NON_PLAYER_PED_FOR_FOUNDRY_EXIT()
|
|
IF GET_CURRENT_PLAYER_PED_ENUM() = CHAR_TREVOR
|
|
RETURN SELECTOR_PED_MICHAEL
|
|
ELSE
|
|
RETURN SELECTOR_PED_TREVOR
|
|
ENDIF
|
|
ENDFUNC
|
|
|
|
PROC CREATE_BLOCKING_OBJECTS()
|
|
IF NOT DOES_NAVMESH_BLOCKING_OBJECT_EXIST(iBottom1Blocker)
|
|
iBottom1Blocker = ADD_NAVMESH_BLOCKING_OBJECT(<<1083.1099, -1975.2751, 30.4723>>, <<1.0, 1.0, 1.0>>, 0.0)
|
|
ENDIF
|
|
IF NOT DOES_NAVMESH_BLOCKING_OBJECT_EXIST(iBottom2Blocker)
|
|
iBottom2Blocker = ADD_NAVMESH_BLOCKING_OBJECT(<<1065.0365, -2005.4205, 31.0325>>, <<1.0, 1.0, 1.0>>, 0.0)
|
|
ENDIF
|
|
IF NOT DOES_NAVMESH_BLOCKING_OBJECT_EXIST(iTopBlocker)
|
|
iTopBlocker = ADD_NAVMESH_BLOCKING_OBJECT(<<1084.8204, -2018.7639, 40.4804>>, <<1.0, 1.0, 1.0>>, 0.0)
|
|
ENDIF
|
|
|
|
IF NOT DOES_NAVMESH_BLOCKING_OBJECT_EXIST(iGroundFloorBlocker1)
|
|
iGroundFloorBlocker1 = ADD_NAVMESH_BLOCKING_OBJECT(<<1086.2224, -2008.2258, 29.9929>>, <<17.0, 10.0, 2.0>>, 100.0, FALSE, BLOCKING_OBJECT_WANDERPATH | BLOCKING_OBJECT_SHORTESTPATH)
|
|
ENDIF
|
|
|
|
IF NOT DOES_NAVMESH_BLOCKING_OBJECT_EXIST(iOutsideFrontFightRearBlocker)
|
|
iOutsideFrontFightRearBlocker = ADD_NAVMESH_BLOCKING_OBJECT(<<1124.8148, -1963.1213, 30.6623>>, <<45.0, 28.0, 8.0>>, 55.0)
|
|
ENDIF
|
|
ENDPROC
|
|
|
|
// remove blips
|
|
PROC REMOVE_ALL_BLIPS()
|
|
CLEAR_MISSION_LOCATION_TEXT_AND_BLIPS(Locates_Data)
|
|
CLEAR_MISSION_LOCATE_STUFF(locates_data, TRUE)
|
|
|
|
IF DOES_BLIP_EXIST(gotoBlip)
|
|
REMOVE_BLIP(gotoBlip)
|
|
ENDIF
|
|
IF DOES_BLIP_EXIST(vehicleBlip)
|
|
REMOVE_BLIP(vehicleBlip)
|
|
ENDIF
|
|
IF DOES_BLIP_EXIST(lamarBlip)
|
|
REMOVE_BLIP(lamarBlip)
|
|
ENDIF
|
|
|
|
INT i
|
|
REPEAT 3 i
|
|
IF DOES_BLIP_EXIST(buddyBlip[i])
|
|
REMOVE_BLIP(buddyBlip[i])
|
|
ENDIF
|
|
ENDREPEAT
|
|
|
|
REPEAT NUMBER_EXITS i
|
|
IF DOES_BLIP_EXIST(exitBlip[i])
|
|
REMOVE_BLIP(exitBlip[i])
|
|
ENDIF
|
|
ENDREPEAT
|
|
|
|
REPEAT COUNT_OF(enemyPed) i
|
|
CLEANUP_AI_PED_BLIP(enemyPed[i].blipStruct)
|
|
ENDREPEAT
|
|
ENDPROC
|
|
|
|
// common player and cam cleanup stuff
|
|
PROC DO_COMMON_PLAYER_AND_CAM_CLEANUP()
|
|
IF IS_PLAYER_PLAYING(PLAYER_ID())
|
|
SET_PLAYER_CONTROL(PLAYER_ID(), TRUE)
|
|
SET_PLAYER_INVINCIBLE(PLAYER_ID(), FALSE)
|
|
ENDIF
|
|
DISPLAY_HUD(TRUE)
|
|
DISPLAY_RADAR(TRUE)
|
|
RENDER_SCRIPT_CAMS(FALSE, FALSE)
|
|
SET_SCRIPTS_SAFE_FOR_CUTSCENE(FALSE)
|
|
DISABLE_CELLPHONE(FALSE)
|
|
ENDPROC
|
|
|
|
PROC CLEANUP_BLOCKING_OBJECTS()
|
|
IF DOES_NAVMESH_BLOCKING_OBJECT_EXIST(iBottom1Blocker)
|
|
REMOVE_NAVMESH_BLOCKING_OBJECT(iBottom1Blocker)
|
|
ENDIF
|
|
IF DOES_NAVMESH_BLOCKING_OBJECT_EXIST(iBottom2Blocker)
|
|
REMOVE_NAVMESH_BLOCKING_OBJECT(iBottom2Blocker)
|
|
ENDIF
|
|
IF DOES_NAVMESH_BLOCKING_OBJECT_EXIST(iTopBlocker)
|
|
REMOVE_NAVMESH_BLOCKING_OBJECT(iTopBlocker)
|
|
ENDIF
|
|
IF DOES_NAVMESH_BLOCKING_OBJECT_EXIST(iGroundFloorBlocker1)
|
|
REMOVE_NAVMESH_BLOCKING_OBJECT(iGroundFloorBlocker1)
|
|
ENDIF
|
|
IF DOES_NAVMESH_BLOCKING_OBJECT_EXIST(iOutsideFrontFightRearBlocker)
|
|
REMOVE_NAVMESH_BLOCKING_OBJECT(iOutsideFrontFightRearBlocker)
|
|
ENDIF
|
|
ENDPROC
|
|
|
|
|
|
// get mission vector
|
|
FUNC VECTOR GET_FINALE_VECTOR(FINALE_VECTOR_ENUM fVec)
|
|
SWITCH fVec
|
|
CASE FINVEC_PLAYER_INIT
|
|
RETURN <<1276.4896, -1724.1554, 53.6551>>
|
|
BREAK
|
|
CASE FINVEC_TREVOR_INIT
|
|
RETURN <<1112.35, -2003.90, 34.44>>
|
|
BREAK
|
|
CASE FINVEC_MICHAEL_INIT
|
|
RETURN <<1114.10, -2003.12, 34.44>>
|
|
BREAK
|
|
CASE FINVEC_LAMAR_INIT
|
|
RETURN <<-61.39580, -1460.5424, 31.08074>>
|
|
BREAK
|
|
CASE FINVEC_LAMAR_SHOOTOUT
|
|
RETURN <<1087.2225, -1969.0425, 30.0446>>
|
|
BREAK
|
|
CASE FINVEC_LESTERS_CAR_INIT
|
|
RETURN <<1279.8389, -1735.9131, 51.2107>>
|
|
BREAK
|
|
CASE FINVEC_PARK
|
|
RETURN <<1079.1, -1967.5193, 30.0447>>
|
|
BREAK
|
|
CASE FINVEC_FOUNDRY_DOOR
|
|
RETURN <<1082.29, -1975.94, 30.47>>
|
|
BREAK
|
|
CASE FINVEC_TOP_DOOR
|
|
RETURN <<1084.98, -2019.18, 40.50>>
|
|
BREAK
|
|
CASE FINVEC_SEE_FRANKLIN
|
|
RETURN <<1079.2052, -1980.2927, 30.4713>>
|
|
BREAK
|
|
CASE FINVEC_GAS_TANK
|
|
RETURN <<1044.21, -1957.92, 30.01>>
|
|
BREAK
|
|
CASE FINVEC_MEETING_GANTRY
|
|
RETURN <<1115.08, -2003.47, 34.44>>
|
|
BREAK
|
|
CASE FINVEC_MEETING_FRANKLIN
|
|
RETURN <<1115.47, -2003.97, 34.44>>
|
|
BREAK
|
|
CASE FINVEC_MEETING_MICHAEL
|
|
RETURN <<1114.21, -2003.08, 34.44>>
|
|
BREAK
|
|
CASE FINVEC_MEETING_TREVOR
|
|
RETURN <<1113.67, -2004.58, 34.44>>
|
|
BREAK
|
|
CASE FINVEC_FOUNDRY_CENTER
|
|
RETURN <<1084.7487, -1995.7273, 29.9727>>
|
|
BREAK
|
|
CASE FINVEC_AFTER_MEETING_FRANKLIN
|
|
RETURN <<1115.47, -2003.97, 34.44>>
|
|
BREAK
|
|
CASE FINVEC_AFTER_MEETING_MICHAEL
|
|
RETURN <<1118.36, -2005.42, 34.44>>
|
|
BREAK
|
|
CASE FINVEC_AFTER_MEETING_TREVOR
|
|
RETURN <<1117.30, -2003.63, 34.44>>
|
|
BREAK
|
|
CASE FINVEC_FRANKLIN_READY
|
|
RETURN <<1107.22742, -2011.23474, 34.44438>>
|
|
BREAK
|
|
CASE FINVEC_MICHAEL_READY
|
|
RETURN <<1112.3929, -2003.7122, 34.4444>>
|
|
BREAK
|
|
CASE FINVEC_TREVOR_READY
|
|
RETURN <<1078.77, -1981.03, 33.61>>
|
|
BREAK
|
|
CASE FINVEC_IN_POSITION
|
|
RETURN <<1087.91, -2028.81, 35.84>>
|
|
BREAK
|
|
CASE FINVEC_TREVOR_SAVETREVOR
|
|
RETURN <<1076.0895, -1982.7013, 29.9498>>
|
|
BREAK
|
|
CASE FINVEC_MICHAEL_SAVETREVOR
|
|
RETURN <<1106.2898, -1996.5974, 29.9111>>
|
|
BREAK
|
|
CASE FINVEC_FRANKLIN_OUTSIDE_READY
|
|
RETURN <<1077.6639, -1970.0713, 30.0447>>
|
|
BREAK
|
|
CASE FINVEC_MICHAEL_GROUND_READY
|
|
RETURN <<1073.4308, -2007.4316, 31.0848>>
|
|
BREAK
|
|
CASE FINVEC_TREVOR_OUTSIDE_READY
|
|
RETURN <<1084.5775, -2011.2036, 42.8439>>
|
|
BREAK
|
|
CASE FINVEC_TOP_INNER_COVER
|
|
RETURN <<1081.6725, -2011.1798, 42.8438>>
|
|
BREAK
|
|
CASE FINVEC_BOTTOM_INNER_COVER
|
|
RETURN <<1073.4563, -2005.4015, 31.0396>>
|
|
BREAK
|
|
CASE FINVEC_TOP_OUTER_COVER
|
|
RETURN <<1088.6592, -2029.7809, 35.8701>>
|
|
BREAK
|
|
CASE FINVEC_BOTTOM_OUTER_COVER
|
|
RETURN <<1057.0808, -2014.3490, 30.0447>>
|
|
BREAK
|
|
CASE FINVEC_OUTSIDE_BATTLE_CENTER
|
|
RETURN <<1047.2074, -1996.9257, 30.0390>>
|
|
BREAK
|
|
CASE FINVEC_REGROUP
|
|
RETURN <<1052.00635, -1989.34998, 30.04471>>
|
|
BREAK
|
|
ENDSWITCH
|
|
|
|
RETURN <<0,0,0>>
|
|
ENDFUNC
|
|
|
|
|
|
// get player cover coord
|
|
FUNC VECTOR GET_PLAYER_COVER_COORD(INT iCover)
|
|
SWITCH iCover
|
|
CASE 0
|
|
RETURN <<1112.3929, -2003.7122, 34.4444>>
|
|
BREAK
|
|
CASE 1
|
|
RETURN GET_FINALE_VECTOR(FINVEC_FRANKLIN_READY)
|
|
BREAK
|
|
CASE 2
|
|
RETURN <<1080.78, -1980.85, 33.63>>
|
|
BREAK
|
|
ENDSWITCH
|
|
|
|
RETURN <<0,0,0>>
|
|
ENDFUNC
|
|
|
|
FUNC BOOL IS_ENEMY_ALIVE(ENEMY_PED_ENUM eEnemyIndex)
|
|
IF enemyPed[eEnemyIndex].bAlive
|
|
IF IS_ENTITY_OK(enemyPed[eEnemyIndex].ped)
|
|
RETURN TRUE
|
|
ELSE
|
|
enemyPed[eEnemyIndex].bAlive = FALSE
|
|
ENDIF
|
|
ENDIF
|
|
|
|
RETURN FALSE
|
|
ENDFUNC
|
|
|
|
FUNC BOOL TASK_PLAYER_PED_TO_FOUNDRY_EXIT_COVER(SELECTOR_SLOTS_ENUM thisPed, BOOL bInnerExit)
|
|
IF NOT IS_ENTITY_OK(sSelectorPeds.pedID[thisPed])
|
|
RETURN FALSE
|
|
ENDIF
|
|
|
|
COVERPOINT_INDEX coverPoint
|
|
|
|
IF selectorPedToTopExit = thisPed
|
|
IF bInnerExit
|
|
coverPoint = topExitInnerCover
|
|
ELSE
|
|
coverPoint = topExitOuterCover
|
|
ENDIF
|
|
ELSE
|
|
IF bInnerExit
|
|
coverPoint = bottomExit2InnerCover
|
|
ELSE
|
|
coverPoint = bottomExit2OuterCover
|
|
ENDIF
|
|
ENDIF
|
|
|
|
VECTOR vCoverLocation = GET_SCRIPTED_COVER_POINT_COORDS(coverPoint)
|
|
|
|
IF sSelectorPeds.pedID[thisPed] != PLAYER_PED_ID()
|
|
IF NOT IS_PED_IN_COVER(sSelectorPeds.pedID[thisPed]) OR NOT IS_ENTITY_AT_COORD(sSelectorPeds.pedID[thisPed], vCoverLocation, (<< 2, 2, 2>>))
|
|
IF GET_SCRIPT_TASK_STATUS(sSelectorPeds.pedID[thisPed], SCRIPT_TASK_PERFORM_SEQUENCE) = FINISHED_TASK
|
|
CPRINTLN(DEBUG_MISSION, "BSWtest tasking ped to cover at: ", vCoverLocation.x, ", ", vCoverLocation.y, ", ", vCoverLocation.z)
|
|
SEQUENCE_INDEX iSeq
|
|
OPEN_SEQUENCE_TASK(iSeq)
|
|
TASK_FOLLOW_NAV_MESH_TO_COORD(NULL, vCoverLocation, PEDMOVE_RUN, -1)
|
|
TASK_PUT_PED_DIRECTLY_INTO_COVER(NULL, vCoverLocation, INFINITE_TASK_TIME, NOT bInnerExit, DEFAULT, DEFAULT, DEFAULT, coverPoint, TRUE)
|
|
CLOSE_SEQUENCE_TASK(iSeq)
|
|
TASK_PERFORM_SEQUENCE(sSelectorPeds.pedID[thisPed], iSeq)
|
|
CLEAR_SEQUENCE_TASK(iSeq)
|
|
eAllyStates[thisPed].iCurrentTaskTime = GET_GAME_TIMER()
|
|
ENDIF
|
|
ELSE
|
|
RETURN TRUE
|
|
ENDIF
|
|
ENDIF
|
|
|
|
RETURN FALSE
|
|
ENDFUNC
|
|
|
|
PROC ADVANCE_PLAYER_PED_TO_OUTSIDE_EXIT(SELECTOR_SLOTS_ENUM thisPed)
|
|
IF IS_ENTITY_OK(sSelectorPeds.pedID[thisPed])
|
|
CLEAR_PED_TASKS(sSelectorPeds.pedID[thisPed])
|
|
ENDIF
|
|
eAllyStates[thisPed].currentState = ALLY_STATE_GOING_TO_FOUNDRY_OUTER_EXIT
|
|
ENDPROC
|
|
|
|
FUNC BOOL IS_PED_IN_FOUNDRY_INTERIOR(PED_INDEX thisPed)
|
|
IF NOT IS_ENTITY_OK(thisPed)
|
|
RETURN FALSE
|
|
ENDIF
|
|
|
|
IF GET_INTERIOR_FROM_ENTITY(thisPed) = foundryInterior
|
|
RETURN TRUE
|
|
ENDIF
|
|
|
|
RETURN FALSE
|
|
ENDFUNC
|
|
|
|
FUNC BOOL IS_ANY_PED_IN_FOUNDRY_INTERIOR()
|
|
IF NOT bTaskedTopPlayerOut AND currentMissionStage = STAGE_SHOOTOUT_STAGE_4
|
|
RETURN TRUE
|
|
ENDIF
|
|
|
|
INT i
|
|
REPEAT 3 i
|
|
IF IS_PED_IN_FOUNDRY_INTERIOR(sSelectorPeds.pedID[i])
|
|
RETURN TRUE
|
|
ENDIF
|
|
ENDREPEAT
|
|
|
|
i = 0
|
|
REPEAT COUNT_OF(ENEMY_PED_ENUM) i
|
|
IF IS_PED_IN_FOUNDRY_INTERIOR(enemyPed[i].ped)
|
|
RETURN TRUE
|
|
ENDIF
|
|
ENDREPEAT
|
|
|
|
RETURN FALSE
|
|
ENDFUNC
|
|
|
|
FUNC FLOAT GET_CLOSEST_ENEMY_TO_ALLY(PED_INDEX allyPed, ENEMY_PED_ENUM &outEnemyIndex)
|
|
FLOAT fDistance = 999
|
|
|
|
INT iter
|
|
REPEAT COUNT_OF(ENEMY_PED_ENUM) iter
|
|
IF IS_ENEMY_ALIVE(INT_TO_ENUM(ENEMY_PED_ENUM, iter)) AND IS_ENTITY_OK(allyPed)
|
|
FLOAT fTempDistance = GET_DISTANCE_BETWEEN_ENTITIES(enemyPed[iter].ped, allyPed)
|
|
IF fTempDistance < fDistance
|
|
outEnemyIndex = INT_TO_ENUM(ENEMY_PED_ENUM, iter)
|
|
fDistance = fTempDistance
|
|
ENDIF
|
|
ENDIF
|
|
ENDREPEAT
|
|
|
|
RETURN fDistance
|
|
ENDFUNC
|
|
|
|
FUNC INT GET_NUM_ENEMIES_IN_TRIGGER_BOX(TRIGGER_BOX tbTestBox)
|
|
INT iEnemyCount = 0
|
|
|
|
INT iter
|
|
REPEAT COUNT_OF(ENEMY_PED_ENUM) iter
|
|
IF IS_ENTITY_IN_TRIGGER_BOX(tbTestBox, enemyPed[iter].ped)
|
|
iEnemyCount++
|
|
ENDIF
|
|
ENDREPEAT
|
|
|
|
RETURN iEnemyCount
|
|
ENDFUNC
|
|
|
|
FUNC INT GET_NUM_LIVING_ENEMIES()
|
|
INT iEnemyCount = 0
|
|
|
|
INT iter
|
|
REPEAT COUNT_OF(ENEMY_PED_ENUM) iter
|
|
IF IS_ENEMY_ALIVE(INT_TO_ENUM(ENEMY_PED_ENUM, iter))
|
|
iEnemyCount++
|
|
ENDIF
|
|
ENDREPEAT
|
|
|
|
RETURN iEnemyCount
|
|
ENDFUNC
|
|
|
|
FUNC INT GET_NUM_CHARGERS()
|
|
INT iChargerCount = 0
|
|
|
|
INT iter
|
|
REPEAT COUNT_OF(ENEMY_PED_ENUM) iter
|
|
IF enemyPed[iter].enemyTaskStatus = ENEMY_TASK_STATUS_CHARGING
|
|
IF IS_ENEMY_ALIVE(INT_TO_ENUM(ENEMY_PED_ENUM, iter))
|
|
iChargerCount++
|
|
ELSE
|
|
enemyPed[iter].enemyTaskStatus = ENEMY_TASK_STATUS_NO_TASK
|
|
ENDIF
|
|
ENDIF
|
|
ENDREPEAT
|
|
|
|
RETURN iChargerCount
|
|
ENDFUNC
|
|
|
|
FUNC BOOL CAN_ALLY_SEE_ANY_ENEMIES(PED_INDEX allyPed)
|
|
IF NOT IS_ENTITY_OK(allyPed)
|
|
RETURN FALSE
|
|
ENDIF
|
|
|
|
INT iter
|
|
REPEAT COUNT_OF(ENEMY_PED_ENUM) iter
|
|
IF IS_ENEMY_ALIVE(INT_TO_ENUM(ENEMY_PED_ENUM, iter))
|
|
IF CAN_PED_SEE_HATED_PED(allyPed, enemyPed[iter].ped)
|
|
RETURN TRUE
|
|
ENDIF
|
|
ENDIF
|
|
ENDREPEAT
|
|
|
|
RETURN FALSE
|
|
|
|
ENDFUNC
|
|
PROC REGISTER_ENEMIES_FOR_PED(PED_INDEX aimPed)
|
|
INT iter
|
|
REPEAT COUNT_OF(ENEMY_PED_ENUM) iter
|
|
IF IS_ENEMY_ALIVE(INT_TO_ENUM(ENEMY_PED_ENUM, iter))
|
|
REGISTER_TARGET(aimPed, enemyPed[iter].ped)
|
|
ENDIF
|
|
ENDREPEAT
|
|
ENDPROC
|
|
|
|
FUNC BOOL SHOULD_ALLY_FOLLOW_PLAYER(SELECTOR_SLOTS_ENUM thisPed)
|
|
IF eAllyStates[thisPed].iCurrentTaskTime + 2000 > GET_GAME_TIMER()
|
|
//CPRINTLN(DEBUG_MISSION, "SHOULD_ALLY_FOLLOW_PLAYER - ally #", thisPed, " was just recently tasked, dont follow")
|
|
RETURN FALSE
|
|
ENDIF
|
|
|
|
IF GET_SCRIPT_TASK_STATUS(sSelectorPeds.pedID[thisPed], SCRIPT_TASK_PERFORM_SEQUENCE) = PERFORMING_TASK
|
|
IF GET_SEQUENCE_PROGRESS(sSelectorPeds.pedID[thisPed]) < 1
|
|
IF eAllyStates[thisPed].iCurrentTaskTime + 10000 > GET_GAME_TIMER()
|
|
//CPRINTLN(DEBUG_MISSION, "SHOULD_ALLY_FOLLOW_PLAYER - ally #", thisPed, " is doing his follow use sequence for less than 10s, dont follow")
|
|
RETURN FALSE
|
|
ELSE
|
|
CPRINTLN(DEBUG_MISSION, "SHOULD_ALLY_FOLLOW_PLAYER - ally #", thisPed, " is doing his follow use sequence for more than 10s, maybe we should re-task!?")
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF IS_PED_SHOOTING(sSelectorPeds.pedID[thisPed])
|
|
//CPRINTLN(DEBUG_MISSION, "SHOULD_ALLY_FOLLOW_PLAYER - ally #", thisPed, " is shooting, dont follow")
|
|
eAllyStates[thisPed].iLastShotTime = GET_GAME_TIMER()
|
|
RETURN FALSE
|
|
ENDIF
|
|
|
|
IF eAllyStates[thisPed].iLastShotTime + 1000 > GET_GAME_TIMER()
|
|
//CPRINTLN(DEBUG_MISSION, "SHOULD_ALLY_FOLLOW_PLAYER - ally #", thisPed, " shot recently, dont follow")
|
|
RETURN FALSE
|
|
ENDIF
|
|
|
|
IF IS_PED_RUNNING(sSelectorPeds.pedID[thisPed]) OR IS_PED_SPRINTING(sSelectorPeds.pedID[thisPed]) OR IS_PED_CLIMBING(sSelectorPeds.pedID[thisPed])
|
|
//CPRINTLN(DEBUG_MISSION, "SHOULD_ALLY_FOLLOW_PLAYER - ally #", thisPed, " is moving, dont follow")
|
|
RETURN FALSE
|
|
ENDIF
|
|
|
|
//eAllyStates[thisPed].currentState = ALLY_STATE_LOCKED_IN_COVER AND GET_SEQUENCE_PROGRESS(sSelectorPeds.pedID[thisPed]) > 0
|
|
|
|
IF IS_PED_IN_COMBAT(sSelectorPeds.pedID[thisPed])
|
|
IF eAllyStates[thisPed].iLastShotTime + 20000 > GET_GAME_TIMER()
|
|
//CPRINTLN(DEBUG_MISSION, "SHOULD_ALLY_FOLLOW_PLAYER - ally #", thisPed, " is in combat and shot recently, dont follow")
|
|
RETURN FALSE
|
|
ENDIF
|
|
ENDIF
|
|
|
|
ENEMY_PED_ENUM outPed
|
|
IF GET_CLOSEST_ENEMY_TO_ALLY(sSelectorPeds.pedID[thisPed], outPed) < 30
|
|
//CPRINTLN(DEBUG_MISSION, "SHOULD_ALLY_FOLLOW_PLAYER - ally #", thisPed, " is close to enemies, dont follow")
|
|
RETURN FALSE
|
|
ENDIF
|
|
|
|
RETURN TRUE
|
|
ENDFUNC
|
|
|
|
FUNC INT GET_ALLY_LOCKED_IN_COVER()
|
|
INT i
|
|
REPEAT 3 i
|
|
IF eAllyStates[i].currentState = ALLY_STATE_LOCKED_IN_COVER
|
|
CPRINTLN(DEBUG_MISSION, "GET_ALLY_LOCKED_IN_COVER found ally locked in cover #", i)
|
|
RETURN i
|
|
ENDIF
|
|
ENDREPEAT
|
|
|
|
RETURN -1
|
|
ENDFUNC
|
|
|
|
PROC UPDATE_ALLY_FOR_SHOOTOUT(SELECTOR_SLOTS_ENUM thisPed)
|
|
IF GET_SELECTOR_SLOT_FROM_PLAYER_PED_ENUM(GET_CURRENT_PLAYER_PED_ENUM()) = thisPed
|
|
eAllyStates[thisPed].currentState = ALLY_STATE_REINITIALIZE
|
|
EXIT
|
|
ENDIF
|
|
|
|
IF NOT IS_ENTITY_OK(sSelectorPeds.pedID[thisPed])
|
|
EXIT
|
|
ENDIF
|
|
|
|
IF NOT IS_ENTITY_OK(PLAYER_PED_ID())
|
|
EXIT
|
|
ENDIF
|
|
|
|
SWITCH eAllyStates[thisPed].currentState
|
|
CASE ALLY_STATE_REINITIALIZE
|
|
CPRINTLN(DEBUG_MISSION, "UPDATE_ALLY_FOR_SHOOTOUT reinitializing ally #", thisPed)
|
|
SWITCH currentMissionStage
|
|
CASE STAGE_SHOOTOUT_STAGE_1
|
|
IF bShootoutStarted
|
|
eAllyStates[thisPed].currentState = ALLY_STATE_COMBAT_INIT
|
|
ELSE
|
|
eAllyStates[thisPed].iCurrentTaskTime = GET_GAME_TIMER()
|
|
eAllyStates[thisPed].currentState = ALLY_STATE_AMBUSH
|
|
ENDIF
|
|
BREAK
|
|
CASE STAGE_SHOOTOUT_STAGE_2
|
|
IF bKilledAll
|
|
SEQUENCE_INDEX iSeq
|
|
OPEN_SEQUENCE_TASK(iSeq)
|
|
TASK_FOLLOW_NAV_MESH_TO_COORD(NULL, GET_PLAYER_COVER_COORD(ENUM_TO_INT(thisPed)), PEDMOVE_RUN, -1)
|
|
TASK_PUT_PED_DIRECTLY_INTO_COVER(NULL, GET_PLAYER_COVER_COORD(ENUM_TO_INT(thisPed)), INFINITE_TASK_TIME, FALSE, 0.0, FALSE, FALSE, initialCover[ENUM_TO_INT(thisPed)], TRUE)
|
|
CLOSE_SEQUENCE_TASK(iSeq)
|
|
TASK_PERFORM_SEQUENCE(sSelectorPeds.pedID[thisPed], iSeq)
|
|
CLEAR_SEQUENCE_TASK(iSeq)
|
|
eAllyStates[thisPed].iCurrentTaskTime = GET_GAME_TIMER()
|
|
eAllyStates[thisPed].currentState = ALLY_STATE_LOCKED_IN_COVER
|
|
ELSE
|
|
eAllyStates[thisPed].currentState = ALLY_STATE_COMBAT_INIT
|
|
ENDIF
|
|
BREAK
|
|
CASE STAGE_SHOOTOUT_STAGE_3
|
|
IF bKilledAll
|
|
eAllyStates[thisPed].iCurrentTaskTime = GET_GAME_TIMER()
|
|
eAllyStates[thisPed].currentState = ALLY_STATE_GOING_TO_FOUNDRY_INNER_EXIT
|
|
ELSE
|
|
IF bTrevorIsInjured AND thisPed = SELECTOR_PED_TREVOR
|
|
eAllyStates[thisPed].iCurrentTaskTime = GET_GAME_TIMER()
|
|
eAllyStates[thisPed].currentState = ALLY_STATE_INJURED
|
|
ELSE
|
|
eAllyStates[thisPed].currentState = ALLY_STATE_COMBAT_INIT
|
|
ENDIF
|
|
ENDIF
|
|
BREAK
|
|
CASE STAGE_SHOOTOUT_STAGE_4
|
|
IF bKilledAll
|
|
TASK_LOOK_AT_ENTITY(sSelectorPeds.pedID[thisPed], PLAYER_PED_ID(), -1, SLF_WHILE_NOT_IN_FOV)
|
|
TASK_FOLLOW_NAV_MESH_TO_COORD(sSelectorPeds.pedID[thisPed], GET_FINALE_VECTOR(FINVEC_REGROUP), PEDMOVE_RUN, 60000, 5.0)
|
|
eAllyStates[thisPed].iCurrentTaskTime = GET_GAME_TIMER()
|
|
eAllyStates[thisPed].currentState = ALLY_STATE_GOING_TO_FINISH
|
|
ELSE
|
|
eAllyStates[thisPed].currentState = ALLY_STATE_COMBAT_INIT
|
|
ENDIF
|
|
BREAK
|
|
ENDSWITCH
|
|
BREAK
|
|
|
|
CASE ALLY_STATE_COMBAT_INIT
|
|
REGISTER_ENEMIES_FOR_PED(sSelectorPeds.pedID[thisPed])
|
|
|
|
IF currentMissionStage <= STAGE_SHOOTOUT_STAGE_3
|
|
VECTOR vDefensiveCenter
|
|
vDefensiveCenter = GET_ENTITY_COORDS(sSelectorPeds.pedID[thisPed])
|
|
FLOAT fRadius
|
|
fRadius = 5.0
|
|
|
|
// special hacky case to handle players getting left in the exits
|
|
// mostly for stage2 force switch case
|
|
IF IS_ENTITY_IN_TRIGGER_BOX(tbBottomExit1Inner, sSelectorPeds.pedID[thisPed])
|
|
OR IS_ENTITY_IN_TRIGGER_BOX(tbBottomExit2Inner, sSelectorPeds.pedID[thisPed])
|
|
OR IS_ENTITY_IN_TRIGGER_BOX(tbTopExitInner, sSelectorPeds.pedID[thisPed])
|
|
vDefensiveCenter = GET_FINALE_VECTOR(FINVEC_FOUNDRY_CENTER)
|
|
fRadius = 15.0
|
|
ENDIF
|
|
|
|
SET_PED_SPHERE_DEFENSIVE_AREA(sSelectorPeds.pedID[thisPed], vDefensiveCenter, fRadius)
|
|
TASK_COMBAT_HATED_TARGETS_AROUND_PED(sSelectorPeds.pedID[thisPed], 200)
|
|
ELSE
|
|
SET_PED_COMBAT_MOVEMENT(sSelectorPeds.pedID[thisPed], CM_WILLADVANCE)
|
|
IF SHOULD_ALLY_FOLLOW_PLAYER(thisPed)
|
|
CPRINTLN(DEBUG_MISSION, "UPDATE_ALLY_FOR_SHOOTOUT - combat init for ally #", thisPed, " is giving him a move-your-ass sequence")
|
|
SET_PED_DEFENSIVE_AREA_ATTACHED_TO_PED(sSelectorPeds.pedID[thisPed], PLAYER_PED_ID(), <<7, 7, 7>>, <<-7, -7, -7>>, 8, FALSE)
|
|
|
|
// this is checked in SHOULD_ALLY_FOLLOW_PLAYER as well, so if you add tasks to this sequence, bump the number in SHOULD_ALLY_FOLLOW_PLAYER
|
|
SEQUENCE_INDEX iSeq
|
|
OPEN_SEQUENCE_TASK(iSeq)
|
|
TASK_GO_TO_COORD_AND_AIM_AT_HATED_ENTITIES_NEAR_COORD(NULL, GET_FINALE_VECTOR(FINVEC_OUTSIDE_BATTLE_CENTER), GET_FINALE_VECTOR(FINVEC_OUTSIDE_BATTLE_CENTER), PEDMOVE_RUN, TRUE, 5, 6, TRUE, DEFAULT, GO_TO_AIM_AT_GOTO_COORD_IF_TARGET_LOS_BLOCKED)
|
|
TASK_COMBAT_HATED_TARGETS_AROUND_PED(NULL, 200)
|
|
CLOSE_SEQUENCE_TASK(iSeq)
|
|
TASK_PERFORM_SEQUENCE(sSelectorPeds.pedID[thisPed], iSeq)
|
|
CLEAR_SEQUENCE_TASK(iSeq)
|
|
ELSE
|
|
REMOVE_PED_DEFENSIVE_AREA(sSelectorPeds.pedID[thisPed])
|
|
TASK_COMBAT_HATED_TARGETS_AROUND_PED(sSelectorPeds.pedID[thisPed], 200)
|
|
ENDIF
|
|
ENDIF
|
|
|
|
eAllyStates[thisPed].currentState = ALLY_STATE_COMBAT
|
|
eAllyStates[thisPed].iCurrentTaskTime = GET_GAME_TIMER()
|
|
BREAK
|
|
|
|
CASE ALLY_STATE_AMBUSH
|
|
STOP_PED_SPEAKING(sSelectorPeds.pedID[thisPed], TRUE)
|
|
BREAK
|
|
|
|
CASE ALLY_STATE_GOING_TO_FOUNDRY_INNER_EXIT
|
|
TASK_PLAYER_PED_TO_FOUNDRY_EXIT_COVER(thisPed, TRUE)
|
|
BREAK
|
|
|
|
CASE ALLY_STATE_GOING_TO_FOUNDRY_OUTER_EXIT
|
|
IF TASK_PLAYER_PED_TO_FOUNDRY_EXIT_COVER(thisPed, FALSE)
|
|
eAllyStates[thisPed].currentState = ALLY_STATE_LOCKED_IN_COVER
|
|
ENDIF
|
|
BREAK
|
|
|
|
CASE ALLY_STATE_GOING_TO_FINISH
|
|
IF GET_SCRIPT_TASK_STATUS(sSelectorPeds.pedID[thisPed], SCRIPT_TASK_FOLLOW_NAV_MESH_TO_COORD) <> PERFORMING_TASK
|
|
AND GET_SCRIPT_TASK_STATUS(sSelectorPeds.pedID[thisPed], SCRIPT_TASK_FOLLOW_NAV_MESH_TO_COORD) <> FINISHED_TASK
|
|
CPRINTLN(DEBUG_MISSION, "UPDATE_ALLY_FOR_SHOOTOUT - retasking ally #", thisPed, " to ALLY_STATE_GOING_TO_FINISH")
|
|
eAllyStates[thisPed].currentState = ALLY_STATE_REINITIALIZE
|
|
ENDIF
|
|
BREAK
|
|
|
|
CASE ALLY_STATE_LOCKED_IN_COVER
|
|
IF currentMissionStage = STAGE_SHOOTOUT_STAGE_4
|
|
IF bCreatedMidChargers
|
|
IF SHOULD_ALLY_FOLLOW_PLAYER(thisPed)
|
|
CPRINTLN(DEBUG_MISSION, "UPDATE_ALLY_FOR_SHOOTOUT - time to unlock ally #", thisPed, " from cover")
|
|
eAllyStates[thisPed].currentState = ALLY_STATE_REINITIALIZE
|
|
|
|
IF NOT IS_ANY_CONVERSATION_ONGOING_OR_QUEUED() AND NOT IS_MESSAGE_BEING_DISPLAYED()
|
|
// this is sort of backwards
|
|
// if trevor is getting up, probably franklin will be the one speaking
|
|
INT iAllyThatNeedsHelp
|
|
iAllyThatNeedsHelp = GET_ALLY_LOCKED_IN_COVER()
|
|
IF iAllyThatNeedsHelp > -1
|
|
STRING sHelpConvo
|
|
IF INT_TO_ENUM(SELECTOR_SLOTS_ENUM, iAllyThatNeedsHelp) = SELECTOR_PED_FRANKLIN
|
|
sHelpConvo = "FINC1_DONEF"
|
|
ELIF INT_TO_ENUM(SELECTOR_SLOTS_ENUM, iAllyThatNeedsHelp) = SELECTOR_PED_TREVOR
|
|
sHelpConvo = "FINC1_DONET"
|
|
ELSE
|
|
sHelpConvo = "FINC1_DONEM"
|
|
ENDIF
|
|
|
|
CREATE_CONVERSATION(finaleConversation, "FINC1AU", sHelpConvo, CONV_PRIORITY_LOW)
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF NOT IS_ANY_CONVERSATION_ONGOING_OR_QUEUED() AND NOT IS_MESSAGE_BEING_DISPLAYED()
|
|
IF thisPed = SELECTOR_PED_FRANKLIN
|
|
IF GET_TIMER_IN_SECONDS_SAFE(tmrFranklinIncidental) > iFranklinIncidentalTime
|
|
IF GET_DISTANCE_BETWEEN_ENTITIES(PLAYER_PED_ID(), sSelectorPeds.pedID[thisPed]) > 30
|
|
ENEMY_PED_ENUM closeEnemy
|
|
IF GET_CLOSEST_ENEMY_TO_ALLY(sSelectorPeds.pedID[thisPed], closeEnemy) < 30
|
|
IF CREATE_CONVERSATION(finaleConversation, "FINC1AU", "FINC1_HELPF", CONV_PRIORITY_LOW)
|
|
iFranklinIncidentalTime = GET_RANDOM_INT_IN_RANGE(20, 30)
|
|
RESTART_TIMER_NOW(tmrFranklinIncidental)
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ELIF thisPed = SELECTOR_PED_MICHAEL
|
|
IF GET_TIMER_IN_SECONDS_SAFE(tmrMichaelIncidental) > iMichaelIncidentalTime
|
|
ENEMY_PED_ENUM closeEnemy
|
|
IF GET_CLOSEST_ENEMY_TO_ALLY(sSelectorPeds.pedID[thisPed], closeEnemy) < 30
|
|
IF GET_DISTANCE_BETWEEN_ENTITIES(PLAYER_PED_ID(), sSelectorPeds.pedID[thisPed]) > 30
|
|
IF CREATE_CONVERSATION(finaleConversation, "FINC1AU", "FINC1_HELPM", CONV_PRIORITY_LOW)
|
|
iMichaelIncidentalTime = GET_RANDOM_INT_IN_RANGE(20, 30)
|
|
RESTART_TIMER_NOW(tmrMichaelIncidental)
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ELIF thisPed = SELECTOR_PED_TREVOR
|
|
IF GET_TIMER_IN_SECONDS_SAFE(tmrTrevorIncidental) > iTrevorIncidentalTime
|
|
IF GET_DISTANCE_BETWEEN_ENTITIES(PLAYER_PED_ID(), sSelectorPeds.pedID[thisPed]) > 30
|
|
ENEMY_PED_ENUM closeEnemy
|
|
IF GET_CLOSEST_ENEMY_TO_ALLY(sSelectorPeds.pedID[thisPed], closeEnemy) < 30
|
|
IF CREATE_CONVERSATION(finaleConversation, "FINC1AU", "FINC1_HELPT", CONV_PRIORITY_LOW)
|
|
iTrevorIncidentalTime = GET_RANDOM_INT_IN_RANGE(20, 30)
|
|
RESTART_TIMER_NOW(tmrTrevorIncidental)
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
BREAK
|
|
|
|
CASE ALLY_STATE_COMBAT
|
|
IF bKilledAll AND NOT IS_PED_IN_COMBAT(sSelectorPeds.pedID[thisPed])
|
|
eAllyStates[thisPed].currentState = ALLY_STATE_REINITIALIZE
|
|
ENDIF
|
|
|
|
IF currentMissionStage = STAGE_SHOOTOUT_STAGE_4
|
|
IF SHOULD_ALLY_FOLLOW_PLAYER(thisPed)
|
|
eAllyStates[thisPed].currentState = ALLY_STATE_REINITIALIZE
|
|
ENDIF
|
|
IF IS_PED_IN_FOUNDRY_INTERIOR(sSelectorPeds.pedID[thisPed])
|
|
eAllyStates[thisPed].currentState = ALLY_STATE_GOING_TO_FOUNDRY_OUTER_EXIT
|
|
CPRINTLN(DEBUG_MISSION, "UPDATE_ALLY_FOR_SHOOTOUT ally is in foundry interior, tasking him out...")
|
|
ENDIF
|
|
ENDIF
|
|
BREAK
|
|
ENDSWITCH
|
|
ENDPROC
|
|
|
|
INT iAllyUpdateThrottle
|
|
PROC UPDATE_ALLIES_FOR_SHOOTOUT()
|
|
iAllyUpdateThrottle++
|
|
|
|
INT i
|
|
REPEAT 3 i
|
|
IF iAllyUpdateThrottle > ENUM_TO_INT(SELECTOR_PED_TREVOR)
|
|
iAllyUpdateThrottle = ENUM_TO_INT(SELECTOR_PED_MICHAEL)
|
|
ENDIF
|
|
|
|
IF i = iAllyUpdateThrottle
|
|
UPDATE_ALLY_FOR_SHOOTOUT(INT_TO_ENUM(SELECTOR_SLOTS_ENUM, i))
|
|
ENDIF
|
|
ENDREPEAT
|
|
ENDPROC
|
|
|
|
FUNC BOOL CAN_UNBLOCK_TREVOR_SELECTOR()
|
|
PED_INDEX piTrevor = GET_TREVOR_PED()
|
|
|
|
IF IS_PED_INJURED(piTrevor)
|
|
RETURN FALSE
|
|
ENDIF
|
|
|
|
RETURN TRUE
|
|
ENDFUNC
|
|
|
|
PROC CLEAR_TREVOR_INJURED()
|
|
IF IS_ENTITY_OK(GET_TREVOR_PED())
|
|
STOP_PED_SPEAKING(GET_TREVOR_PED(), FALSE)
|
|
SET_ENTITY_ONLY_DAMAGED_BY_PLAYER(GET_TREVOR_PED(), TRUE)
|
|
SET_PED_RELATIONSHIP_GROUP_HASH(GET_TREVOR_PED(), RELGROUPHASH_PLAYER)
|
|
ENDIF
|
|
|
|
CANCEL_TIMER(tmrMichaelIncidental)
|
|
|
|
// Only do this if we aren't doing ragdoll, otherwise his selector won't be unblocked
|
|
// If Trevor is ragdolling, check this again separately
|
|
IF CAN_UNBLOCK_TREVOR_SELECTOR()
|
|
SET_SELECTOR_PED_BLOCKED(sSelectorPeds, SELECTOR_PED_TREVOR, FALSE)
|
|
sSelectorPeds.pedID[SELECTOR_PED_TREVOR] = GET_TREVOR_PED() //@BSW is this doing anything?
|
|
|
|
IF GET_CURRENT_PLAYER_PED_ENUM() = CHAR_TREVOR
|
|
SET_PLAYER_CONTROL(PLAYER_ID(), TRUE)
|
|
ENDIF
|
|
|
|
eAllyStates[SELECTOR_PED_TREVOR].currentState = ALLY_STATE_COMBAT_INIT
|
|
ENDIF
|
|
|
|
ENDPROC
|
|
|
|
// bullets around Michael at start of shootout 3
|
|
PROC HANDLE_SHOOTOUT3_SQUIBS()
|
|
|
|
VECTOR vOrigin = <<1093.8, -1995.2, 31.5>>
|
|
VECTOR vHit[5]
|
|
|
|
IF iSquibID >= COUNT_OF(vHit)
|
|
EXIT
|
|
ENDIF
|
|
|
|
vHit[0] = <<1111.41992, -2004.57898, 34.72998>>
|
|
vHit[1] = <<1111.58667, -2004.34070, 34.91570>>
|
|
vHit[2] = <<1111.76587, -2004.08484, 35.07050>>
|
|
vHit[3] = <<1111.93188, -2003.84766, 35.16402>>
|
|
vHit[4] = <<1112.14697, -2003.54053, 35.28234>>
|
|
|
|
IF GET_FRAME_COUNT() % 2 = 0
|
|
CPRINTLN(DEBUG_MISSION, "HANDLE_SHOOTOUT3_SQUIBS: squib fired: ", iSquibID)
|
|
SHOOT_SINGLE_BULLET_BETWEEN_COORDS(vOrigin, vHit[iSquibID], 1, FALSE, WEAPONTYPE_ASSAULTRIFLE)
|
|
iSquibID ++
|
|
ENDIF
|
|
|
|
ENDPROC
|
|
|
|
PROC HANDLE_NEW_LOAD_SCENE_FOR_SHOOTOUT3()
|
|
IF eShootout2CurrentGoal < SHOOTOUT_2_SWITCH
|
|
EXIT
|
|
ENDIF
|
|
IF NOT IS_NEW_LOAD_SCENE_ACTIVE()
|
|
IF NOT IS_PLAYER_SWITCH_IN_PROGRESS()
|
|
IF NEW_LOAD_SCENE_START((<<1115.65, -2005.17, 35.71>>), NORMALISE_VECTOR(<<-0.93, 0.31, -0.19>>), 50.0)
|
|
CPRINTLN(DEBUG_MISSION, "HANDLE_NEW_LOAD_SCENE_FOR_SHOOTOUT3: calling NEW_LOAD_SCENE_START().")
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDPROC
|
|
|
|
PROC HANDLE_CLEAR_NEW_LOAD_SCENE()
|
|
IF IS_NEW_LOAD_SCENE_ACTIVE()
|
|
IF IS_NEW_LOAD_SCENE_LOADED()
|
|
NEW_LOAD_SCENE_STOP()
|
|
ENDIF
|
|
ENDIF
|
|
ENDPROC
|
|
|
|
OBJECT_INDEX oiCS_Weapon[3]
|
|
OBJECT_INDEX swatWeapons[4]
|
|
|
|
PROC DELETE_THIS_OBJECT(OBJECT_INDEX oiObj)
|
|
IF DOES_ENTITY_EXIST(oiObj)
|
|
DELETE_OBJECT(oiObj)
|
|
ENDIF
|
|
ENDPROC
|
|
|
|
PROC CLEAR_TEMP_WEAPON_ARRAY()
|
|
INT idx
|
|
// clear out array
|
|
REPEAT COUNT_OF(oiCS_Weapon) idx
|
|
DELETE_THIS_OBJECT(oiCS_Weapon[idx])
|
|
ENDREPEAT
|
|
ENDPROC
|
|
|
|
// cleanup the mission
|
|
PROC MISSION_CLEANUP()
|
|
|
|
TRIGGER_MUSIC_EVENT("FIN1_FAIL")
|
|
|
|
RELEASE_SCRIPT_AUDIO_BANK()
|
|
|
|
REMOVE_RELATIONSHIP_GROUP(relgroupIgnore)
|
|
|
|
STOP_AUDIO_SCENES()
|
|
|
|
STOP_GAMEPLAY_HINT()
|
|
|
|
REMOVE_MISSION_TEXT()
|
|
|
|
STORE_FAIL_WEAPON(GET_MICHAEL_PED(), ENUM_TO_INT(CHAR_MICHAEL))
|
|
STORE_FAIL_WEAPON(GET_TREVOR_PED(), ENUM_TO_INT(CHAR_TREVOR))
|
|
STORE_FAIL_WEAPON(GET_FRANKLIN_PED(), ENUM_TO_INT(CHAR_FRANKLIN))
|
|
|
|
CLEAR_MISSION_LOCATION_TEXT_AND_BLIPS(Locates_Data)
|
|
CLEAR_MISSION_LOCATE_STUFF(locates_data, TRUE)
|
|
|
|
DELETE_FAKE_ENEMY_BLIPS()
|
|
|
|
REMOVE_FORCED_OBJECT(GET_FINALE_VECTOR(FINVEC_GAS_TANK), 10, mapPlacedGasTank)
|
|
|
|
SET_SELECTOR_PED_BLOCKED(sSelectorPeds, SELECTOR_PED_FRANKLIN, FALSE)
|
|
|
|
//RESTORE_PLAYER_PED_VARIATIONS(PLAYER_PED_ID())
|
|
|
|
IF NOT IS_PED_INJURED(PLAYER_PED_ID())
|
|
SET_PED_USING_ACTION_MODE(PLAYER_PED_ID(), FALSE)
|
|
SET_PED_CAN_SWITCH_WEAPON(PLAYER_PED_ID(), TRUE)
|
|
//RESTORE_PLAYER_PED_VARIATIONS(PLAYER_PED_ID())
|
|
|
|
IF IS_ENTITY_ATTACHED(PLAYER_PED_ID())
|
|
IF NOT GET_IS_PED_GADGET_EQUIPPED(PLAYER_PED_ID(), GADGETTYPE_PARACHUTE)
|
|
IF GET_VEHICLE_PED_IS_USING(PLAYER_PED_ID()) = NULL
|
|
CLEAR_PED_TASKS(PLAYER_PED_ID())
|
|
DETACH_ENTITY(PLAYER_PED_ID())
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
|
|
// reset proofs
|
|
SET_ENTITY_PROOFS(PLAYER_PED_ID(), FALSE, FALSE, FALSE, FALSE, FALSE)
|
|
SET_ENTITY_ONLY_DAMAGED_BY_PLAYER(PLAYER_PED_ID(), FALSE)
|
|
SET_PED_CAN_BE_KNOCKED_OFF_VEHICLE(PLAYER_PED_ID(), KNOCKOFFVEHICLE_DEFAULT)
|
|
REMOVE_ENTITY_FROM_AUDIO_MIX_GROUP(PLAYER_PED_ID())
|
|
ENDIF
|
|
|
|
// remove lamar
|
|
IF NOT IS_PED_INJURED(lamarPed)
|
|
REMOVE_PED_FROM_GROUP(lamarPed)
|
|
ENDIF
|
|
|
|
IF DOES_ENTITY_EXIST(pedLester)
|
|
DELETE_PED(pedLester)
|
|
ENDIF
|
|
|
|
CLEAR_TEMP_WEAPON_ARRAY()
|
|
|
|
CLEANUP_BLOCKING_OBJECTS()
|
|
CLEAR_TREVOR_INJURED()
|
|
|
|
IF NOT IS_PED_INJURED(GET_MICHAEL_PED())
|
|
STOP_PED_SPEAKING(GET_MICHAEL_PED(), FALSE)
|
|
ENDIF
|
|
IF NOT IS_PED_INJURED(GET_FRANKLIN_PED())
|
|
STOP_PED_SPEAKING(GET_FRANKLIN_PED(), FALSE)
|
|
ENDIF
|
|
IF NOT IS_PED_INJURED(GET_TREVOR_PED())
|
|
STOP_PED_SPEAKING(GET_TREVOR_PED(), FALSE)
|
|
ENDIF
|
|
|
|
IF NOT IS_PED_INJURED(GET_FRANKLIN_PED())
|
|
SET_PED_HELMET(GET_FRANKLIN_PED(), TRUE)
|
|
ENDIF
|
|
|
|
DOOR_SYSTEM_SET_OPEN_RATIO(ENUM_TO_INT(DOORHASH_FOUNDRY_B_01), 0.0, FALSE, FALSE)
|
|
DOOR_SYSTEM_SET_DOOR_STATE(ENUM_TO_INT(DOORHASH_FOUNDRY_B_01), DOORSTATE_FORCE_LOCKED_THIS_FRAME, FALSE, TRUE)
|
|
SET_DOOR_STATE(DOORNAME_FOUNDRY_B_01, DOORSTATE_LOCKED)
|
|
SET_DOOR_STATE(DOORNAME_FOUNDRY_B_02, DOORSTATE_LOCKED)
|
|
SET_DOOR_STATE(DOORNAME_FOUNDRY_T_01, DOORSTATE_LOCKED)
|
|
|
|
IF bThoroughCleanup
|
|
IF DOES_ENTITY_EXIST(lamarPed)
|
|
REMOVE_ENTITY_FROM_AUDIO_MIX_GROUP(lamarPed)
|
|
CPRINTLN(DEBUG_MISSION, "BSWclean deleting Lamar")
|
|
DELETE_PED(lamarPed)
|
|
ENDIF
|
|
IF DOES_ENTITY_EXIST(sSelectorPeds.pedID[SELECTOR_PED_FRANKLIN]) AND GET_CURRENT_PLAYER_PED_ENUM() <> CHAR_FRANKLIN
|
|
REMOVE_ENTITY_FROM_AUDIO_MIX_GROUP(sSelectorPeds.pedID[SELECTOR_PED_FRANKLIN])
|
|
CPRINTLN(DEBUG_MISSION, "BSWclean deleting Franklin")
|
|
DELETE_PED(sSelectorPeds.pedID[SELECTOR_PED_FRANKLIN])
|
|
ENDIF
|
|
IF DOES_ENTITY_EXIST(sSelectorPeds.pedID[SELECTOR_PED_MICHAEL]) AND GET_CURRENT_PLAYER_PED_ENUM() <> CHAR_MICHAEL
|
|
REMOVE_ENTITY_FROM_AUDIO_MIX_GROUP(sSelectorPeds.pedID[SELECTOR_PED_MICHAEL])
|
|
CPRINTLN(DEBUG_MISSION, "BSWclean deleting Michael")
|
|
DELETE_PED(sSelectorPeds.pedID[SELECTOR_PED_MICHAEL])
|
|
ENDIF
|
|
IF DOES_ENTITY_EXIST(sSelectorPeds.pedID[SELECTOR_PED_TREVOR]) AND GET_CURRENT_PLAYER_PED_ENUM() <> CHAR_TREVOR
|
|
REMOVE_ENTITY_FROM_AUDIO_MIX_GROUP(sSelectorPeds.pedID[SELECTOR_PED_TREVOR])
|
|
CPRINTLN(DEBUG_MISSION, "BSWclean deleting Trevor")
|
|
DELETE_PED(sSelectorPeds.pedID[SELECTOR_PED_TREVOR])
|
|
ENDIF
|
|
ENDIF
|
|
|
|
INT i
|
|
REPEAT 3 i
|
|
REMOVE_COVER_POINT(initialCover[i])
|
|
ENDREPEAT
|
|
|
|
REMOVE_COVER_POINT(bottomExit2InnerCover)
|
|
REMOVE_COVER_POINT(bottomExit2OuterCover)
|
|
REMOVE_COVER_POINT(franklinExitOuterCover)
|
|
REMOVE_COVER_POINT(topExitInnerCover)
|
|
REMOVE_COVER_POINT(michaelCatwalkCover)
|
|
REMOVE_COVER_POINT(trevorInjuredCover)
|
|
REMOVE_COVER_POINT(topExitOuterCover)
|
|
REMOVE_COVER_POINT(outsideShackCornerCover)
|
|
|
|
SET_INTERIOR_CAPPED_ON_EXIT(INTERIOR_V_FOUNDRY, TRUE)
|
|
// unpin interior
|
|
IF bInteriorPinned
|
|
IF IS_INTERIOR_READY(foundryInterior)
|
|
UNPIN_INTERIOR(foundryInterior)
|
|
ENDIF
|
|
ENDIF
|
|
|
|
HANDLE_CLEAR_NEW_LOAD_SCENE()
|
|
|
|
INT iter
|
|
REPEAT COUNT_OF(ambientVehicles) iter
|
|
IF DOES_ENTITY_EXIST(ambientVehicles[iter])
|
|
DELETE_VEHICLE(ambientVehicles[iter])
|
|
ENDIF
|
|
ENDREPEAT
|
|
|
|
DELETE_FINALE_PICKUPS()
|
|
|
|
DO_COMMON_PLAYER_AND_CAM_CLEANUP()
|
|
|
|
//IF mocapStreamingStage >= MOCAP_STREAMING_STAGE_WAIT
|
|
REMOVE_CUTSCENE()
|
|
//ENDIF
|
|
|
|
// enable emergency services
|
|
SET_WANTED_LEVEL_MULTIPLIER(1.0)
|
|
SET_MAX_WANTED_LEVEL(5)
|
|
ENABLE_ALL_DISPATCH_SERVICES(TRUE)
|
|
|
|
// enable other ambient stuff
|
|
SUPPRESS_MISSION_VEHICLES(FALSE)
|
|
ENABLE_CARGENS_FOR_MISSION(TRUE)
|
|
REMOVE_SCENARIO_BLOCKING_AREA(foundryScenarioBlocking)
|
|
|
|
DISABLE_CELLPHONE(FALSE)
|
|
|
|
#IF IS_DEBUG_BUILD
|
|
IF DOES_WIDGET_GROUP_EXIST(finaleWidgets)
|
|
DELETE_WIDGET_GROUP(finaleWidgets)
|
|
ENDIF
|
|
#ENDIF
|
|
|
|
TERMINATE_THIS_THREAD()
|
|
ENDPROC
|
|
|
|
// mission passed
|
|
PROC MISSION_PASSED()
|
|
INFORM_MISSION_STATS_OF_INCREMENT(FIN_KILLS) // one for devin
|
|
|
|
//TODO 1009388. Force an autosave between the two parts of the mission.
|
|
SET_AUTOSAVE_IGNORES_ON_MISSION_FLAG(TRUE, TRUE)
|
|
MAKE_AUTOSAVE_REQUEST()
|
|
|
|
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("FIN1_FAIL")
|
|
missionFailState = MISSION_FAIL_STATE_WAIT_FOR_FADE
|
|
savedFailReason = reasonForFail
|
|
|
|
STRING failText
|
|
SWITCH savedFailReason
|
|
CASE FAIL_MICHAEL_DEAD
|
|
failText = "CMN_MDIED"
|
|
BREAK
|
|
CASE FAIL_FRANKLIN_DEAD
|
|
failText = "CMN_FDIED"
|
|
BREAK
|
|
CASE FAIL_TREVOR_DEAD
|
|
failText = "CMN_TDIED"
|
|
BREAK
|
|
CASE FAIL_LAMAR_DEAD
|
|
failText = "FC1_FAIL1"
|
|
BREAK
|
|
CASE FAIL_ABANDONED_FIGHT
|
|
failText = "FC1_FAIL3"
|
|
BREAK
|
|
CASE FAIL_ABANDONED_LAMAR
|
|
failText = "FC1_FAIL4"
|
|
BREAK
|
|
CASE FAIL_ABANDONED_MEETING
|
|
failText = "FC1_FAIL6"
|
|
BREAK
|
|
CASE FAIL_ATTRACTED_COPS
|
|
failText = "FC1_FAIL7"
|
|
BREAK
|
|
ENDSWITCH
|
|
|
|
MISSION_FLOW_MISSION_FAILED_WITH_REASON(failText)
|
|
ENDIF
|
|
ENDPROC
|
|
|
|
// headsets
|
|
PROC SET_PLAYER_PED_WITH_HEADSET(enumCharacterList headSetCharacter, BOOL bHasHeadset)
|
|
PED_INDEX headsetPed
|
|
PED_COMP_NAME_ENUM componentEnum
|
|
SWITCH headSetCharacter
|
|
CASE CHAR_MICHAEL
|
|
componentEnum = PROPS_P0_HEADSET
|
|
BREAK
|
|
CASE CHAR_FRANKLIN
|
|
componentEnum = PROPS_P1_HEADSET
|
|
BREAK
|
|
CASE CHAR_TREVOR
|
|
componentEnum = PROPS_P2_HEADSET
|
|
BREAK
|
|
ENDSWITCH
|
|
|
|
IF GET_CURRENT_PLAYER_PED_ENUM() = headSetCharacter
|
|
headsetPed = PLAYER_PED_ID()
|
|
ELSE
|
|
headsetPed = sSelectorPeds.pedID[GET_SELECTOR_SLOT_FROM_PLAYER_PED_ENUM(headSetCharacter)]
|
|
ENDIF
|
|
|
|
IF NOT IS_PED_INJURED(headsetPed)
|
|
IF bHasHeadset
|
|
SET_PED_COMP_ITEM_CURRENT_SP(headsetPed, COMP_TYPE_PROPS, componentEnum)
|
|
ELSE
|
|
REMOVE_PED_COMP_ITEM_SP(headsetPed, COMP_TYPE_PROPS, componentEnum)
|
|
ENDIF
|
|
ENDIF
|
|
ENDPROC
|
|
|
|
PROC HANDLE_SHOOTOUT_3_ABANDON_CHECK()
|
|
IF IS_PLAYER_IN_TRIGGER_BOX(tbBottomExit1Inner)
|
|
OR IS_PLAYER_IN_TRIGGER_BOX(tbBottomExit2Outer)
|
|
OR IS_PLAYER_IN_TRIGGER_BOX(tbTopExitOuter)
|
|
FAIL_REASON_ENUM thisFail
|
|
IF GET_CURRENT_PLAYER_PED_ENUM() = CHAR_MICHAEL
|
|
thisFail = FAIL_TREVOR_DEAD
|
|
ELSE
|
|
thisFail = FAIL_MICHAEL_DEAD
|
|
ENDIF
|
|
MISSION_FAILED(thisFail)
|
|
ENDIF
|
|
ENDPROC
|
|
|
|
// check all peds and vehicles for fail
|
|
PROC HANDLE_MISSION_FAIL_CHECKS()
|
|
INT i
|
|
|
|
IF NOT bRunningCutscene
|
|
// character peds
|
|
REPEAT COUNT_OF(sSelectorPeds.pedID) i
|
|
IF DOES_ENTITY_EXIST(sSelectorPeds.pedID[i])
|
|
IF IS_PED_INJURED(sSelectorPeds.pedID[i])
|
|
enumCharacterList injuredChar = INT_TO_ENUM(enumCharacterList, i)
|
|
IF injuredChar <> GET_CURRENT_PLAYER_PED_ENUM()
|
|
IF DOES_BLIP_EXIST(buddyBlip[i])
|
|
REMOVE_BLIP(buddyBlip[i])
|
|
ENDIF
|
|
|
|
SWITCH injuredChar
|
|
CASE CHAR_MICHAEL
|
|
// michael
|
|
MISSION_FAILED(FAIL_MICHAEL_DEAD)
|
|
BREAK
|
|
CASE CHAR_TREVOR
|
|
// trevor
|
|
MISSION_FAILED(FAIL_TREVOR_DEAD)
|
|
BREAK
|
|
CASE CHAR_FRANKLIN
|
|
// franklin
|
|
IF currentMissionStage <> STAGE_SHOOTOUT_STAGE_3
|
|
MISSION_FAILED(FAIL_FRANKLIN_DEAD)
|
|
ENDIF
|
|
BREAK
|
|
ENDSWITCH
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDREPEAT
|
|
|
|
// Lamar
|
|
//IF currentMissionStage <= STAGE_MEET_GANG
|
|
//OR currentMissionStage = STAGE_SHOOTOUT_STAGE_2
|
|
IF DOES_ENTITY_EXIST(lamarPed)
|
|
IF IS_PED_INJURED(lamarPed)
|
|
IF DOES_BLIP_EXIST(lamarBlip)
|
|
REMOVE_BLIP(lamarBlip)
|
|
ENDIF
|
|
REMOVE_ENTITY_FROM_AUDIO_MIX_GROUP(lamarPed)
|
|
|
|
IF IS_THIS_PRINT_BEING_DISPLAYED("FC1_GOLAM")
|
|
OR IS_THIS_PRINT_BEING_DISPLAYED("FC1_WAITLAM")
|
|
OR IS_THIS_PRINT_BEING_DISPLAYED("FC1_LELAM")
|
|
REMOVE_MISSION_TEXT(TRUE, TRUE, FALSE)
|
|
ENDIF
|
|
MISSION_FAILED(FAIL_LAMAR_DEAD)
|
|
ENDIF
|
|
ENDIF
|
|
//ENDIF
|
|
|
|
// abandon the foundry complex
|
|
IF currentMissionStage >= STAGE_MEET_GANG
|
|
AND currentMissionStage < STAGE_OUTRO_CUTSCENE
|
|
IF NOT IS_ENTITY_IN_AREA(PLAYER_PED_ID(), <<927, -2080, -10>>, <<1141, -1858, 50>>, FALSE)
|
|
AND NOT IS_ENTITY_IN_AREA(PLAYER_PED_ID(), <<1135, -2080, -10>>, <<1202, -1960, 50>>, FALSE)
|
|
AND NOT IS_ENTITY_IN_AREA(PLAYER_PED_ID(), <<1135, -1963, -10>>, <<1162, -1931, 50>>, FALSE)
|
|
IF currentMissionStage = STAGE_MEET_GANG
|
|
MISSION_FAILED(FAIL_ABANDONED_MEETING)
|
|
ELSE
|
|
MISSION_FAILED(FAIL_ABANDONED_FIGHT)
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDPROC
|
|
|
|
// mission failed
|
|
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()
|
|
IF NOT IS_PED_INJURED(PLAYER_PED_ID())
|
|
SET_PLAYER_PED_WITH_HEADSET(GET_CURRENT_PLAYER_PED_ENUM(), FALSE)
|
|
ENDIF
|
|
|
|
BOOL bReposition
|
|
bReposition = FALSE
|
|
IF IS_PED_IN_FOUNDRY_INTERIOR(PLAYER_PED_ID())
|
|
bReposition = TRUE
|
|
ELSE
|
|
IF NOT IS_PED_INJURED(PLAYER_PED_ID())
|
|
IF IS_ENTITY_AT_COORD(PLAYER_PED_ID(), <<1082.46082, -1975.35742, 30.83251>>, <<4,4,4>>)
|
|
OR IS_ENTITY_AT_COORD(PLAYER_PED_ID(), <<1065.48242, -2005.48071, 31.13397>>, <<4,4,4>>)
|
|
OR IS_ENTITY_AT_COORD(PLAYER_PED_ID(), <<1085.01379, -2019.12378, 40.52797>>, <<4,4,4>>)
|
|
bReposition = TRUE
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF IS_ANY_VEHICLE_NEAR_POINT(<<1082.46082, -1975.35742, 30.83251>>, 3)
|
|
OR IS_ANY_VEHICLE_NEAR_POINT(<<1065.48242, -2005.48071, 31.13397>>, 3)
|
|
OR IS_ANY_VEHICLE_NEAR_POINT(<<1085.01379, -2019.12378, 40.52797>>, 3)
|
|
SET_REPLAY_DECLINED_VEHICLE_WARP_LOCATION(GET_FINALE_VECTOR(FINVEC_PARK), PARK_CAR_ROT)
|
|
ENDIF
|
|
|
|
IF bReposition
|
|
MISSION_FLOW_SET_FAIL_WARP_LOCATION(<<1084.6444, -1972.2926, 30.0447>>, 65)
|
|
SET_REPLAY_DECLINED_VEHICLE_WARP_LOCATION(GET_FINALE_VECTOR(FINVEC_PARK), PARK_CAR_ROT)
|
|
ENDIF
|
|
|
|
bThoroughCleanup = TRUE
|
|
|
|
MISSION_CLEANUP() // must only take 1 frame and terminate the thread
|
|
ELSE
|
|
//Maintain anything that could look weird during fade out (e.g. enemies walking off).
|
|
ENDIF
|
|
BREAK
|
|
ENDSWITCH
|
|
ENDPROC
|
|
|
|
//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 finale cutscene
|
|
PROC SET_MISSION_CUTSCENE(BOOL bStart, BOOL bResetControlAndCameras = TRUE, BOOL bKillSpeech = TRUE, BOOL bInterpBackToGame = FALSE, BOOL bDoFade = TRUE, BOOL bResetHUDWhenNotReturningCams = FALSE, INT iInterpTime = DEFAULT_PED_CAM_INTERP_TIME, BOOL bSetRelativeHeading = TRUE)
|
|
REMOVE_MISSION_TEXT(bKillSpeech)
|
|
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, bInterpBackToGame, iInterpTime)
|
|
|
|
IF bSetRelativeHeading
|
|
SET_GAMEPLAY_CAM_RELATIVE_HEADING(0.0)
|
|
ENDIF
|
|
ELSE
|
|
IF bResetHUDWhenNotReturningCams
|
|
DISPLAY_RADAR(TRUE)
|
|
DISPLAY_HUD(TRUE)
|
|
ENDIF
|
|
ENDIF
|
|
bRunningCutscene = FALSE
|
|
bClearedForCutscene = FALSE
|
|
bCutsceneWaitStarted = FALSE
|
|
cutsceneStage = F_CUT_STAGE_INIT
|
|
|
|
IF bDoFade
|
|
IF IS_SCREEN_FADED_OUT()
|
|
DO_SCREEN_FADE_IN(DEFAULT_FADE_TIME)
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDPROC
|
|
|
|
// prevent wanted level for cut
|
|
PROC PREVENT_WANTED_LEVEL_FOR_CUTSCENE()
|
|
SET_WANTED_LEVEL_MULTIPLIER(0.0)
|
|
SET_PLAYER_WANTED_LEVEL(PLAYER_ID(), 0)
|
|
SET_PLAYER_WANTED_LEVEL_NOW(PLAYER_ID())
|
|
ENDPROC
|
|
|
|
// pin the office in memory
|
|
PROC PIN_FOUNDRY_INTERIOR(BOOL bDoPin)
|
|
IF bDoPin
|
|
IF NOT bInteriorPinned
|
|
IF IS_VALID_INTERIOR(foundryInterior)
|
|
PIN_INTERIOR_IN_MEMORY(foundryInterior)
|
|
WHILE NOT IS_INTERIOR_READY(foundryInterior)
|
|
WAIT(0)
|
|
ENDWHILE
|
|
IF NOT DOES_ENTITY_EXIST(foundryRootObject)
|
|
foundryRootObject = CREATE_OBJECT(GET_MODEL_FOR_FINALE_MODEL_ENUM(FM_ANCHOR), GET_OFFSET_FROM_INTERIOR_IN_WORLD_COORDS(foundryInterior, <<0,0,0>>))
|
|
SET_ENTITY_HEADING(foundryRootObject, -FOUNDRY_HEADING)//GET_INTERIOR_HEADING(foundryInterior))
|
|
SET_ENTITY_COLLISION(foundryRootObject, FALSE)
|
|
SET_ENTITY_VISIBLE(foundryRootObject, FALSE)
|
|
FREEZE_ENTITY_POSITION(foundryRootObject, TRUE)
|
|
ENDIF
|
|
bInteriorPinned = TRUE
|
|
ENDIF
|
|
ENDIF
|
|
ELSE
|
|
IF bInteriorPinned
|
|
IF DOES_ENTITY_EXIST(foundryRootObject)
|
|
DELETE_OBJECT(foundryRootObject)
|
|
ENDIF
|
|
UNPIN_INTERIOR(foundryInterior)
|
|
bInteriorPinned = FALSE
|
|
ENDIF
|
|
ENDIF
|
|
ENDPROC
|
|
|
|
// unblock all selectors
|
|
PROC UNBLOCK_ALL_SELECTOR_PEDS()
|
|
sSelectorPeds.bBlockSelectorPed[SELECTOR_PED_MICHAEL] = FALSE
|
|
sSelectorPeds.bBlockSelectorPed[SELECTOR_PED_FRANKLIN] = FALSE
|
|
sSelectorPeds.bBlockSelectorPed[SELECTOR_PED_TREVOR] = FALSE
|
|
ENDPROC
|
|
|
|
// get number of blocked peds
|
|
FUNC INT GET_NUMBER_BLOCKED_PEDS()
|
|
INT iReturn = 0
|
|
INT i
|
|
REPEAT 3 i
|
|
IF sSelectorPeds.bBlockSelectorPed[i]
|
|
iReturn++
|
|
ENDIF
|
|
ENDREPEAT
|
|
RETURN iReturn
|
|
ENDFUNC
|
|
|
|
// is this model required on this stage?
|
|
FUNC BOOL IS_MODEL_REQUIRED_FOR_MISSION_STAGE(FINALE_MODEL_ENUM sagModel, MISSION_STAGE_ENUM reqStage)
|
|
SWITCH sagModel
|
|
CASE FM_MICHAEL
|
|
CASE FM_TREVOR
|
|
IF reqStage >= STAGE_MEET_GANG
|
|
RETURN TRUE
|
|
ENDIF
|
|
BREAK
|
|
CASE FM_FRANKLIN
|
|
RETURN TRUE
|
|
BREAK
|
|
CASE FM_LAMAR
|
|
IF reqStage <= STAGE_MEET_GANG
|
|
OR reqStage = STAGE_SHOOTOUT_STAGE_2
|
|
OR reqStage = STAGE_SHOOTOUT_STAGE_4
|
|
RETURN TRUE
|
|
ENDIF
|
|
BREAK
|
|
CASE FM_FIB
|
|
IF reqStage >= STAGE_MEET_GANG
|
|
AND reqStage < STAGE_OUTRO_CUTSCENE
|
|
RETURN TRUE
|
|
ENDIF
|
|
BREAK
|
|
CASE FM_FIB_VAN
|
|
IF reqStage >= STAGE_SHOOTOUT_STAGE_2
|
|
AND reqStage < STAGE_OUTRO_CUTSCENE
|
|
RETURN TRUE
|
|
ENDIF
|
|
BREAK
|
|
CASE FM_MERC
|
|
IF reqStage >= STAGE_SHOOTOUT_STAGE_1
|
|
AND reqStage < STAGE_OUTRO_CUTSCENE
|
|
RETURN TRUE
|
|
ENDIF
|
|
BREAK
|
|
CASE FM_MERC_4WD
|
|
IF reqStage >= STAGE_SHOOTOUT_STAGE_4
|
|
AND reqStage < STAGE_OUTRO_CUTSCENE
|
|
RETURN TRUE
|
|
ENDIF
|
|
BREAK
|
|
CASE FM_MERC_CHOPPER
|
|
IF reqStage >= STAGE_SHOOTOUT_STAGE_4
|
|
AND reqStage < STAGE_OUTRO_CUTSCENE
|
|
RETURN TRUE
|
|
ENDIF
|
|
BREAK
|
|
CASE FM_ANCHOR
|
|
RETURN TRUE
|
|
BREAK
|
|
CASE FM_BARREL
|
|
RETURN TRUE
|
|
BREAK
|
|
CASE FM_PHONE
|
|
IF reqStage = STAGE_GET_TO_FOUNDRY
|
|
RETURN TRUE
|
|
ENDIF
|
|
BREAK
|
|
CASE FM_CRATE
|
|
RETURN TRUE
|
|
BREAK
|
|
ENDSWITCH
|
|
|
|
RETURN FALSE
|
|
ENDFUNC
|
|
|
|
// add a request for a model
|
|
PROC ADD_MODEL_REQUEST(INT i)
|
|
MODEL_NAMES mModelToRequest = GET_MODEL_FOR_FINALE_MODEL_ENUM(INT_TO_ENUM(FINALE_MODEL_ENUM, i))
|
|
REQUEST_MODEL(mModelToRequest)
|
|
// request vehicle assets for the following models
|
|
IF mModelToRequest = GET_MODEL_FOR_FINALE_MODEL_ENUM(FM_MERC_4WD)
|
|
REQUEST_VEHICLE_ASSET(mModelToRequest, ENUM_TO_INT(VRF_REQUEST_ALL_ANIMS))
|
|
ENDIF
|
|
bModelRequestTracker[i] = TRUE
|
|
ENDPROC
|
|
|
|
// remove request
|
|
PROC CLEAR_MODEL_REQUEST(INT i)
|
|
IF bModelRequestTracker[i]
|
|
MODEL_NAMES mModelToRequest = GET_MODEL_FOR_FINALE_MODEL_ENUM(INT_TO_ENUM(FINALE_MODEL_ENUM, i))
|
|
IF HAS_MODEL_LOADED(mModelToRequest)
|
|
SET_MODEL_AS_NO_LONGER_NEEDED(mModelToRequest)
|
|
ENDIF
|
|
// remove vehicle assets for the following vehicles
|
|
IF mModelToRequest = GET_MODEL_FOR_FINALE_MODEL_ENUM(FM_MERC_4WD)
|
|
IF HAS_VEHICLE_ASSET_LOADED(mModelToRequest)
|
|
REMOVE_VEHICLE_ASSET(mModelToRequest)
|
|
ENDIF
|
|
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
|
|
MODEL_NAMES mModelToRequest = GET_MODEL_FOR_FINALE_MODEL_ENUM(INT_TO_ENUM(FINALE_MODEL_ENUM, i))
|
|
IF NOT HAS_MODEL_LOADED(mModelToRequest)
|
|
// a full slot is not loaded, return false
|
|
RETURN FALSE
|
|
ENDIF
|
|
// check for vehicle assets for the following models
|
|
IF mModelToRequest = GET_MODEL_FOR_FINALE_MODEL_ENUM(FM_MERC_4WD)
|
|
IF NOT HAS_VEHICLE_ASSET_LOADED(mModelToRequest)
|
|
RETURN FALSE
|
|
ENDIF
|
|
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(FINALE_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(FINALE_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()
|
|
IF IS_SCREEN_FADED_OUT()
|
|
LOAD_ALL_OBJECTS_NOW()
|
|
ENDIF
|
|
|
|
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 // init merc jeeps
|
|
CASE 002
|
|
//CASE 003 // init merc choppers
|
|
CASE 004
|
|
CASE 005 // merc jeeps up road
|
|
CASE 006
|
|
CASE 007
|
|
CASE 008
|
|
CASE 009
|
|
IF reqStage = STAGE_SHOOTOUT_STAGE_4
|
|
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_FINALE_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_FINALE_RECORDING_PREFIX())
|
|
REMOVE_VEHICLE_RECORDING(iRec, GET_FINALE_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_FINALE_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()
|
|
IF IS_SCREEN_FADED_OUT()
|
|
LOAD_ALL_OBJECTS_NOW()
|
|
ENDIF
|
|
|
|
WHILE NOT HAVE_ALL_RECORDING_REQUESTS_SUCCEEDED()
|
|
WAIT(0)
|
|
ENDWHILE
|
|
ENDIF
|
|
ENDIF
|
|
ENDPROC
|
|
|
|
// is this waypoint required on this stage?
|
|
FUNC BOOL IS_WAYPOINT_REQUIRED_FOR_MISSION_STAGE(INT iWaypoint, MISSION_STAGE_ENUM reqStage)
|
|
SWITCH iWaypoint + 1
|
|
CASE 1 // lamar into foundry
|
|
CASE 2 // lamar to vantage
|
|
IF reqStage = STAGE_MEET_GANG
|
|
RETURN TRUE
|
|
ENDIF
|
|
BREAK
|
|
CASE 3
|
|
CASE 4
|
|
CASE 5
|
|
CASE 6
|
|
CASE 7
|
|
CASE 8
|
|
CASE 9
|
|
IF reqStage = STAGE_SHOOTOUT_STAGE_1
|
|
RETURN TRUE
|
|
ENDIF
|
|
BREAK
|
|
ENDSWITCH
|
|
|
|
RETURN FALSE
|
|
ENDFUNC
|
|
|
|
FUNC TEXT_LABEL GET_WAYPOINT_LABEL_FROM_INT(INT iWaypoint)
|
|
TEXT_LABEL tWaypoint = "finc1"
|
|
tWaypoint += (iWaypoint+1)
|
|
RETURN tWaypoint
|
|
ENDFUNC
|
|
|
|
// add a request for a waypoint
|
|
PROC ADD_WAYPOINT_REQUEST(INT iWaypoint)
|
|
bWaypointRequestTracker[iWaypoint] = TRUE
|
|
TEXT_LABEL tWaypoint = GET_WAYPOINT_LABEL_FROM_INT(iWaypoint)
|
|
REQUEST_WAYPOINT_RECORDING(tWaypoint)
|
|
ENDPROC
|
|
|
|
// clear a waypoint request slot
|
|
PROC CLEAR_WAYPOINT_REQUEST(INT iWaypoint)
|
|
IF bWaypointRequestTracker[iWaypoint]
|
|
bWaypointRequestTracker[iWaypoint] = FALSE
|
|
TEXT_LABEL tWaypoint = GET_WAYPOINT_LABEL_FROM_INT(iWaypoint)
|
|
IF GET_IS_WAYPOINT_RECORDING_LOADED(tWaypoint) = FALSE
|
|
REMOVE_WAYPOINT_RECORDING(tWaypoint)
|
|
ENDIF
|
|
ENDIF
|
|
ENDPROC
|
|
|
|
// have all requests for waypoints succeeded?
|
|
FUNC BOOL HAVE_ALL_WAYPOINT_REQUESTS_SUCCEEDED()
|
|
INT i
|
|
|
|
// loop through and check for empty
|
|
REPEAT NUMBER_WAYPOINT_REQUEST_SLOTS i
|
|
IF bWaypointRequestTracker[i]
|
|
TEXT_LABEL tWaypoint = GET_WAYPOINT_LABEL_FROM_INT(i)
|
|
IF NOT GET_IS_WAYPOINT_RECORDING_LOADED(tWaypoint)
|
|
// a full slot is not loaded, return false
|
|
RETURN FALSE
|
|
ENDIF
|
|
ENDIF
|
|
ENDREPEAT
|
|
|
|
RETURN TRUE
|
|
ENDFUNC
|
|
|
|
// get recordings for particular stage
|
|
PROC REQUEST_WAYPOINT_RECORDINGS_FOR_STAGE(MISSION_STAGE_ENUM requestStage, BOOL bWaitForLoad, BOOL bKeepWaypointsForCurrentStage)
|
|
INT i
|
|
REPEAT NUMBER_WAYPOINT_REQUEST_SLOTS i
|
|
IF IS_WAYPOINT_REQUIRED_FOR_MISSION_STAGE(i, requestStage)
|
|
// if we need this waypoint, request it
|
|
ADD_WAYPOINT_REQUEST(i)
|
|
ELSE
|
|
// otherwise try and get rid of it
|
|
IF NOT IS_WAYPOINT_REQUIRED_FOR_MISSION_STAGE(i, currentMissionStage)
|
|
OR NOT bKeepWaypointsForCurrentStage
|
|
CLEAR_WAYPOINT_REQUEST(i)
|
|
ENDIF
|
|
ENDIF
|
|
ENDREPEAT
|
|
|
|
// if wait for load, don't quit out 'til all the waypoints are in
|
|
IF bWaitForLoad
|
|
IF NOT HAVE_ALL_WAYPOINT_REQUESTS_SUCCEEDED()
|
|
IF IS_SCREEN_FADED_OUT()
|
|
LOAD_ALL_OBJECTS_NOW()
|
|
ENDIF
|
|
|
|
WHILE NOT HAVE_ALL_WAYPOINT_REQUESTS_SUCCEEDED()
|
|
WAIT(0)
|
|
ENDWHILE
|
|
ENDIF
|
|
ENDIF
|
|
ENDPROC
|
|
|
|
// get an anim dict enum as string
|
|
FUNC STRING GET_FINALE_ANIM_DICT_AS_STRING(FINALE_ANIM_DICT_ENUM animDict)
|
|
SWITCH animDict
|
|
CASE F_ANIM_DICT_MCS_1_LEADIN
|
|
RETURN "missfinale_c1@leadin@fin_mcs_1"
|
|
BREAK
|
|
CASE F_ANIM_DICT_LAMAR_WAIT
|
|
RETURN "MISSFINALE_C1@LAMAR_WAIT"
|
|
BREAK
|
|
CASE F_ANIM_DICT_LAMAR_LOOKOUT
|
|
RETURN "missprologuewait_impatient"
|
|
BREAK
|
|
ENDSWITCH
|
|
|
|
RETURN "invalid!"
|
|
ENDFUNC
|
|
|
|
// is this anim dict required on this stage?
|
|
FUNC BOOL IS_ANIM_DICT_REQUIRED_FOR_MISSION_STAGE(FINALE_ANIM_DICT_ENUM animDict, MISSION_STAGE_ENUM reqStage)
|
|
SWITCH animDict
|
|
CASE F_ANIM_DICT_MCS_1_LEADIN
|
|
IF reqStage = STAGE_MEET_GANG
|
|
RETURN TRUE
|
|
ENDIF
|
|
BREAK
|
|
CASE F_ANIM_DICT_LAMAR_WAIT
|
|
IF reqStage = STAGE_GET_TO_FOUNDRY
|
|
RETURN TRUE
|
|
ENDIF
|
|
BREAK
|
|
CASE F_ANIM_DICT_LAMAR_LOOKOUT
|
|
IF reqStage = STAGE_MEET_GANG
|
|
RETURN TRUE
|
|
ENDIF
|
|
BREAK
|
|
ENDSWITCH
|
|
|
|
RETURN FALSE
|
|
ENDFUNC
|
|
|
|
// add a request for an anim
|
|
PROC ADD_ANIM_DICT_REQUEST(FINALE_ANIM_DICT_ENUM animDict)
|
|
bAnimDictRequestTracker[animDict] = TRUE
|
|
STRING sAnimDict = GET_FINALE_ANIM_DICT_AS_STRING(animDict)
|
|
REQUEST_ANIM_DICT(sAnimDict)
|
|
ENDPROC
|
|
|
|
// clear an anim request slot
|
|
PROC CLEAR_ANIM_DICT_REQUEST(FINALE_ANIM_DICT_ENUM animDict)
|
|
IF bAnimDictRequestTracker[animDict]
|
|
bAnimDictRequestTracker[animDict] = FALSE
|
|
STRING sAnimDict = GET_FINALE_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(FINALE_ANIM_DICT_ENUM) i
|
|
IF bAnimDictRequestTracker[i]
|
|
IF NOT HAS_ANIM_DICT_LOADED(GET_FINALE_ANIM_DICT_AS_STRING(INT_TO_ENUM(FINALE_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(FINALE_ANIM_DICT_ENUM) i
|
|
FINALE_ANIM_DICT_ENUM thisAnimDict = INT_TO_ENUM(FINALE_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()
|
|
IF IS_SCREEN_FADED_OUT()
|
|
LOAD_ALL_OBJECTS_NOW()
|
|
ENDIF
|
|
|
|
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_FINALE_WEAPON_TYPE(FINALE_WEAPON_ENUM weapon)
|
|
SWITCH weapon
|
|
CASE F_WEAPON_LMG
|
|
RETURN WEAPONTYPE_COMBATMG
|
|
BREAK
|
|
CASE F_WEAPON_FIB_RIFLE
|
|
RETURN WEAPONTYPE_CARBINERIFLE
|
|
BREAK
|
|
CASE F_WEAPON_MERC_RIFLE
|
|
RETURN WEAPONTYPE_ASSAULTRIFLE
|
|
BREAK
|
|
CASE F_WEAPON_SNIPER
|
|
RETURN WEAPONTYPE_HEAVYSNIPER
|
|
BREAK
|
|
CASE F_WEAPON_PISTOL
|
|
RETURN WEAPONTYPE_PISTOL
|
|
BREAK
|
|
ENDSWITCH
|
|
|
|
RETURN WEAPONTYPE_UNARMED
|
|
ENDFUNC
|
|
|
|
// is this weapon required on this stage?
|
|
FUNC BOOL IS_WEAPON_REQUIRED_FOR_MISSION_STAGE(FINALE_WEAPON_ENUM weapon, MISSION_STAGE_ENUM reqStage)
|
|
SWITCH weapon
|
|
CASE F_WEAPON_LMG
|
|
IF reqStage >= STAGE_MEET_GANG
|
|
AND reqStage < STAGE_OUTRO_CUTSCENE
|
|
RETURN TRUE
|
|
ENDIF
|
|
BREAK
|
|
CASE F_WEAPON_FIB_RIFLE
|
|
IF reqStage >= STAGE_MEET_GANG
|
|
AND reqStage < STAGE_OUTRO_CUTSCENE
|
|
RETURN TRUE
|
|
ENDIF
|
|
BREAK
|
|
CASE F_WEAPON_MERC_RIFLE
|
|
IF reqStage >= STAGE_SHOOTOUT_STAGE_1
|
|
AND reqStage < STAGE_OUTRO_CUTSCENE
|
|
RETURN TRUE
|
|
ENDIF
|
|
BREAK
|
|
CASE F_WEAPON_SNIPER
|
|
IF reqStage >= STAGE_MEET_GANG
|
|
AND reqStage < STAGE_OUTRO_CUTSCENE
|
|
RETURN TRUE
|
|
ENDIF
|
|
BREAK
|
|
CASE F_WEAPON_PISTOL
|
|
IF reqStage >= STAGE_MEET_GANG
|
|
AND reqStage < STAGE_OUTRO_CUTSCENE
|
|
RETURN TRUE
|
|
ENDIF
|
|
BREAK
|
|
ENDSWITCH
|
|
|
|
RETURN FALSE
|
|
ENDFUNC
|
|
|
|
// add a request for a weapon
|
|
PROC ADD_WEAPON_REQUEST(FINALE_WEAPON_ENUM weapon)
|
|
bWeaponRequestTracker[weapon] = TRUE
|
|
WEAPON_TYPE weaponType = GET_FINALE_WEAPON_TYPE(weapon)
|
|
REQUEST_WEAPON_ASSET(weaponType)
|
|
ENDPROC
|
|
|
|
// clear a weapon request slot
|
|
PROC CLEAR_WEAPON_REQUEST(FINALE_WEAPON_ENUM weapon)
|
|
IF bWeaponRequestTracker[weapon]
|
|
bWeaponRequestTracker[weapon] = FALSE
|
|
WEAPON_TYPE weaponType = GET_FINALE_WEAPON_TYPE(weapon)
|
|
IF HAS_WEAPON_ASSET_LOADED(weaponType)
|
|
REMOVE_WEAPON_ASSET(weaponType)
|
|
ENDIF
|
|
ENDIF
|
|
ENDPROC
|
|
|
|
// have all requests for weapons succeeded?
|
|
FUNC BOOL HAVE_ALL_WEAPON_REQUESTS_SUCCEEDED()
|
|
INT i
|
|
|
|
// loop through and check for empty
|
|
REPEAT COUNT_OF(FINALE_WEAPON_ENUM) i
|
|
IF bWeaponRequestTracker[i]
|
|
IF NOT HAS_WEAPON_ASSET_LOADED(GET_FINALE_WEAPON_TYPE(INT_TO_ENUM(FINALE_WEAPON_ENUM, i)))
|
|
// a full slot is not loaded, return false
|
|
RETURN FALSE
|
|
ENDIF
|
|
ENDIF
|
|
ENDREPEAT
|
|
|
|
RETURN TRUE
|
|
ENDFUNC
|
|
|
|
// get weapons for particular stage
|
|
PROC REQUEST_WEAPONS_FOR_STAGE(MISSION_STAGE_ENUM requestStage, BOOL bWaitForLoad, BOOL bKeepWeaponsForCurrentStage)
|
|
|
|
INT i
|
|
REPEAT COUNT_OF(FINALE_WEAPON_ENUM) i
|
|
FINALE_WEAPON_ENUM thisWeapon = INT_TO_ENUM(FINALE_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()
|
|
IF IS_SCREEN_FADED_OUT()
|
|
LOAD_ALL_OBJECTS_NOW()
|
|
ENDIF
|
|
|
|
WHILE NOT HAVE_ALL_WEAPON_REQUESTS_SUCCEEDED()
|
|
WAIT(0)
|
|
ENDWHILE
|
|
ENDIF
|
|
ENDIF
|
|
ENDPROC
|
|
|
|
// get a sfx enum as string
|
|
FUNC STRING GET_FINALE_SFX_AS_STRING(FINALE_SFX_ENUM sfx)
|
|
SWITCH sfx
|
|
CASE F_SFX_FOUNDRY_01
|
|
RETURN "FINALE_C1_FOUNDRY_01"
|
|
BREAK
|
|
CASE F_SFX_FOUNDRY_02
|
|
RETURN "FINALE_C1_FOUNDRY_02"
|
|
BREAK
|
|
ENDSWITCH
|
|
|
|
RETURN "invalid!"
|
|
ENDFUNC
|
|
|
|
// is this sfx required on this stage?
|
|
FUNC BOOL IS_SFX_REQUIRED_FOR_MISSION_STAGE(FINALE_SFX_ENUM sfx, MISSION_STAGE_ENUM reqStage)
|
|
SWITCH sfx
|
|
CASE F_SFX_FOUNDRY_01
|
|
CASE F_SFX_FOUNDRY_02
|
|
IF reqStage >= STAGE_MEET_GANG
|
|
AND reqStage < STAGE_OUTRO_CUTSCENE
|
|
RETURN TRUE
|
|
ENDIF
|
|
BREAK
|
|
ENDSWITCH
|
|
|
|
RETURN FALSE
|
|
ENDFUNC
|
|
|
|
// add a request for a sfx
|
|
PROC ADD_SFX_REQUEST(FINALE_SFX_ENUM sfx)
|
|
bSFXRequestTracker[sfx] = TRUE
|
|
STRING sSFX = GET_FINALE_SFX_AS_STRING(sfx)
|
|
REQUEST_SCRIPT_AUDIO_BANK(sSFX)
|
|
ENDPROC
|
|
|
|
// clear a sfx request slot
|
|
PROC CLEAR_SFX_REQUEST(FINALE_SFX_ENUM sfx)
|
|
IF bSFXRequestTracker[sfx]
|
|
bSFXRequestTracker[sfx] = FALSE
|
|
STRING sSFX = GET_FINALE_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(FINALE_SFX_ENUM) i
|
|
IF bSFXRequestTracker[i]
|
|
IF NOT REQUEST_SCRIPT_AUDIO_BANK(GET_FINALE_SFX_AS_STRING(INT_TO_ENUM(FINALE_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(FINALE_SFX_ENUM) i
|
|
FINALE_SFX_ENUM thisSFX = INT_TO_ENUM(FINALE_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()
|
|
IF IS_SCREEN_FADED_OUT()
|
|
LOAD_ALL_OBJECTS_NOW()
|
|
ENDIF
|
|
|
|
WHILE NOT HAVE_ALL_SFX_REQUESTS_SUCCEEDED()
|
|
WAIT(0)
|
|
ENDWHILE
|
|
ENDIF
|
|
ENDIF
|
|
ENDPROC
|
|
|
|
// request the text for the mission
|
|
PROC REQUEST_TEXT(BOOL bWaitForLoad)
|
|
REQUEST_ADDITIONAL_TEXT("FINC", 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 = F_CUT_STAGE_INIT
|
|
bRunningCutscene = FALSE
|
|
bClearedForCutscene = FALSE
|
|
bCutsceneWaitStarted = FALSE
|
|
bTrevorIsInjured = FALSE
|
|
bShownGodText = FALSE
|
|
bShownReturnText = FALSE
|
|
bLamarWasSaved = FALSE
|
|
bLamarApproached = FALSE
|
|
bSuppressGreeting = FALSE
|
|
bDoneLamarAskForHelp = FALSE
|
|
|
|
bForceSwitch = FALSE
|
|
|
|
bAudioStartShootout1 = FALSE
|
|
bAudioPlayNewWaveOneShot = FALSE
|
|
bAudioGetToLamar = FALSE
|
|
bAudioStartShootout4 = FALSE
|
|
bAudioStopShootout4 = FALSE
|
|
bAudioHelicopterArrives = FALSE
|
|
bToggledBackFightInvuln = FALSE
|
|
bSpawnedHelicopter = FALSE
|
|
bTopInPositionPlayed = FALSE
|
|
bTopIsOutOfPosition = FALSE
|
|
|
|
iNextRandomSpeechTime = -1
|
|
freeHotswapData.swapTarget = GET_SELECTOR_SLOT_FROM_PLAYER_PED_ENUM(GET_CURRENT_PLAYER_PED_ENUM())
|
|
freeHotswapData.state = FREE_HOTSWAP_STATE_SELECTING
|
|
|
|
iFIBReactionCount = ENUM_TO_INT(EP_FIB_SEARCH_FOOT_1)
|
|
iFIBReactionStartTime = 0
|
|
|
|
tbFoundryExcess = CREATE_TRIGGER_BOX(<<1066.821533,-1985.848999,25.047035>>, <<1117.886963,-2023.860840,50.013065>>, 38)
|
|
tbForceWalkAroundStairs = CREATE_TRIGGER_BOX(<<1103.112915,-1988.406982,30.014751>>, <<1113.823364,-1996.484131,34.030678>>, 18.500000)
|
|
tbTriggerMeetCrewScene = CREATE_TRIGGER_BOX(<<1107.679565,-1993.302490,29.960894>>, <<1112.671875,-1997.906982,33.996750>>, 6.000000)
|
|
tbBackupMeetCrewSceneTrigger = CREATE_TRIGGER_BOX(<<1124.434448,-1997.750610,34.444378>>, <<1119.596558,-2018.719482,37.604424>>, 32.0)
|
|
|
|
tbForbiddenZone = CREATE_TRIGGER_BOX(<<1078.290283,-2003.627930,30.008945>>, <<1089.224121,-2013.857178,31.902382>>, 11)
|
|
|
|
tbCloserToCatwalkExit = CREATE_TRIGGER_BOX(<<1114.424194,-2028.897339,37.032864>>, <<1093.471924,-2015.221069,46.054119>>, 10)
|
|
|
|
tbBottomExit2Buffer = CREATE_TRIGGER_BOX(<<1070.319580,-1995.860229,29.894566>>, <<1081.312988,-2005.465454,34.002991>>, 15)
|
|
|
|
tbTopExitInner = CREATE_TRIGGER_BOX(<<1086.849976,-2010.593750,46.217575>>, <<1084.042358,-2013.152466,41.845615>>, 2.0)
|
|
tbTopExitOuter = CREATE_TRIGGER_BOX(<<1095.147827,-2028.568237,33.219734>>, <<1084.148926,-2021.099731,44.370483>> , 11.0)
|
|
tbBottomExit1Inner = CREATE_TRIGGER_BOX(<<1078.577148,-1972.393188,30.470356>>, <<1077.366333,-1974.158447,33.471329>>, 3.0)
|
|
tbBottomExit1Outer = CREATE_TRIGGER_BOX(<<1083.849487,-1973.886230,30.044798>>, <<1083.058228,-1974.975830,33.499069>>, 2.0)
|
|
tbBottomExit2Inner = CREATE_TRIGGER_BOX(<<1072.154175,-2004.475952,31.039562>>, <<1075.589233,-2006.794556,34.039562>>, 1.0)
|
|
tbBottomExit2Outer = CREATE_TRIGGER_BOX(<<1065.833618,-2004.828247,31.134092>>, <<1065.023193,-2006.008423,34.062546>>, 2.0)
|
|
tbBottomApproachBackFight = CREATE_TRIGGER_BOX(<<1065.593506,-2010.446045,29.039293>>, <<1054.999390,-2014.945679,35.408455>>, 7.0)
|
|
tbBottomApproachFrontFight = CREATE_TRIGGER_BOX(<<1057.713623,-1993.924316,30.044798>>, <<1003.887451,-2011.271729,33.289299>>, 3.0)
|
|
|
|
tbNearingBottomExit1 = CREATE_TRIGGER_BOX(<<1092.536499,-1980.295532,28.284578>>, <<1072.599121,-2013.819214,45.574467>>, 53.0)
|
|
tbInjuredTrevor = CREATE_TRIGGER_BOX(<<1070.007080,-1981.345703,30.079538>>, <<1076.193970,-1986.311890,33.030476>>, 8.0)
|
|
|
|
tbBottomOfStairs = CREATE_TRIGGER_BOX(<<1110.410278,-1993.184082,30.002172>>, <<1113.265381,-1995.274536,33.033745>>, 3.5)
|
|
|
|
// Outside bottom exit 2
|
|
tbSaveLamarFailsafe1 = CREATE_TRIGGER_BOX(<<1064.089966,-2005.697754,31.143833>>, <<1066.833862,-2001.615479,34.062500>>, 2.500000)
|
|
// Outside top exit
|
|
tbSaveLamarFailsafe2 = CREATE_TRIGGER_BOX(<<1086.121582,-2018.981567,40.093056>>, <<1084.681396,-2020.961182,42.810280>>, 2.500000)
|
|
// save lamar
|
|
tbSaveLamar = CREATE_TRIGGER_BOX(<<1072.721436,-1959.989136,30.044275>>, <<1100.012817,-1979.646973,34.044643>>, 13.000000)
|
|
|
|
ENDPROC
|
|
|
|
// get all variables in the correct state for this stage
|
|
PROC RESET_VARIABLES_FOR_STAGE(MISSION_STAGE_ENUM resetStage)
|
|
RESET_ALL_COMMON_VARIABLES()
|
|
|
|
SWITCH resetStage
|
|
CASE STAGE_GET_TO_FOUNDRY
|
|
BREAK
|
|
CASE STAGE_MEET_GANG
|
|
lamarWalkStage = LAMAR_LEAVE_CAR
|
|
bDoneArrivalSpeech = FALSE
|
|
bRingToneStarted = FALSE
|
|
bRingToneStopped = FALSE
|
|
bAddedInteriorBlip = FALSE
|
|
bCreatedMichaelAndTrevor = FALSE
|
|
bAddedGantryBlip = FALSE
|
|
bPreparedMichaelShoutCue = FALSE
|
|
bDoneMichaelShoutCue = FALSE
|
|
bPreparedSWATCue = FALSE
|
|
bDoneSWATCue = FALSE
|
|
bStartedArgument = FALSE
|
|
BREAK
|
|
CASE STAGE_SHOOTOUT_STAGE_1
|
|
bKilledAll = FALSE
|
|
bCreatedCatwalkWave = FALSE
|
|
bCreatedTrevorCornerWave = FALSE
|
|
bSwitchedToMichaelForCatwalkKill = FALSE
|
|
bSwitchedToTrevorForCornerKill = FALSE
|
|
bReinforcementWarning = FALSE
|
|
bEnemyInfightingDialogue = FALSE
|
|
bTrevorAnnouncesMerryweather = FALSE
|
|
bCreatedInsideMercWave = FALSE
|
|
bCreatedFIBReinforcements = FALSE
|
|
bShootoutStarted = FALSE
|
|
bShownAmbushText = FALSE
|
|
bCatwalkWaveDialogue = FALSE
|
|
bLockSelector = FALSE
|
|
bDoneFightCue = FALSE
|
|
iMichaelCallsShotCount = 0
|
|
iTrevorCallsShotCount = 0
|
|
BREAK
|
|
CASE STAGE_SHOOTOUT_STAGE_2
|
|
bShootoutStarted = TRUE
|
|
bKilledAll = FALSE
|
|
bDoneFightCue = FALSE
|
|
bTrevorIsInjured = TRUE
|
|
bLamarCalmedDown = FALSE
|
|
bPlayedChat9 = FALSE
|
|
bPlayedChat10 = FALSE
|
|
bPlayedChat11 = FALSE
|
|
BREAK
|
|
CASE STAGE_SHOOTOUT_STAGE_3
|
|
bShootoutStarted = TRUE
|
|
bKilledAll = FALSE
|
|
bLockSelector = FALSE
|
|
bDoneFightCue = FALSE
|
|
bTrevorIsInjured = TRUE
|
|
iSquibID = 0
|
|
BREAK
|
|
CASE STAGE_SHOOTOUT_STAGE_4
|
|
bShootoutStarted = TRUE
|
|
bKilledAll = FALSE
|
|
bLockSelector = FALSE
|
|
bShownKillAllText = FALSE
|
|
bShownRegroupText = FALSE
|
|
bRegroupDialogue = FALSE
|
|
bCreatedRoadMercs = FALSE
|
|
bGoneOutsideDialogue = FALSE
|
|
bShootout4ObjectiveDialogue = FALSE
|
|
bCreatedAmbientCopCars = FALSE
|
|
bTaskedTopPlayerOut = FALSE
|
|
bCreatedTrainMercs1 = FALSE
|
|
bCreatedTrainMercs2 = FALSE
|
|
bCreatedFIBRoadReinf = FALSE
|
|
bCreatedLamarFight = FALSE
|
|
bCreatedMidChargers = FALSE
|
|
bDoneRegroupCue = FALSE
|
|
bDoneAtVehiclesCue = FALSE
|
|
iHeliCombatState = 0
|
|
iHeliAttackPause = 0
|
|
BREAK
|
|
ENDSWITCH
|
|
ENDPROC
|
|
|
|
// return the correct character to start a particular stage on
|
|
FUNC enumCharacterList GET_CHARACTER_FOR_MISSION_STAGE(MISSION_STAGE_ENUM getStage)
|
|
SWITCH getStage
|
|
CASE STAGE_GET_TO_FOUNDRY
|
|
RETURN CHAR_FRANKLIN
|
|
BREAK
|
|
CASE STAGE_MEET_GANG
|
|
RETURN CHAR_FRANKLIN
|
|
BREAK
|
|
CASE STAGE_SHOOTOUT_STAGE_1
|
|
RETURN CHAR_FRANKLIN
|
|
BREAK
|
|
CASE STAGE_SHOOTOUT_STAGE_2
|
|
RETURN CHAR_FRANKLIN
|
|
BREAK
|
|
CASE STAGE_SHOOTOUT_STAGE_3
|
|
RETURN CHAR_MICHAEL
|
|
BREAK
|
|
CASE STAGE_SHOOTOUT_STAGE_4
|
|
RETURN CHAR_MICHAEL
|
|
BREAK
|
|
CASE STAGE_OUTRO_CUTSCENE
|
|
RETURN CHAR_MICHAEL
|
|
BREAK
|
|
ENDSWITCH
|
|
|
|
RETURN CHAR_MICHAEL
|
|
ENDFUNC
|
|
|
|
// set vehicle properties
|
|
PROC SET_FINALE_VEHICLE_PROPERTIES(FINALE_VEHICLE_ENUM fVehicle)
|
|
IF IS_VEHICLE_DRIVEABLE(finaleVehicle[fVehicle])
|
|
SET_VEHICLE_CAN_LEAK_OIL(finaleVehicle[fVehicle], FALSE)
|
|
SET_VEHICLE_CAN_LEAK_PETROL(finaleVehicle[fVehicle], FALSE)
|
|
SET_DISABLE_VEHICLE_PETROL_TANK_FIRES(finaleVehicle[fVehicle], TRUE)
|
|
ENDIF
|
|
ENDPROC
|
|
|
|
PROC CREATE_PLAYER_FINALE_VEHICLE(MISSION_STAGE_ENUM createStage)
|
|
IF IS_VEHICLE_DRIVEABLE(finaleVehicle[FV_MISSION_START_CAR])
|
|
CPRINTLN(DEBUG_MISSION, "CREATE_PLAYER_FINALE_VEHICLE start car already exists")
|
|
|
|
EXIT
|
|
ENDIF
|
|
|
|
VECTOR vCreatePos
|
|
FLOAT fCreateRot
|
|
IF createStage <= STAGE_GET_TO_FOUNDRY
|
|
vCreatePos = GET_FINALE_VECTOR(FINVEC_LESTERS_CAR_INIT)
|
|
fCreateRot = LESTERS_CAR_INIT_ROT
|
|
ELSE
|
|
vCreatePos = GET_FINALE_VECTOR(FINVEC_PARK)
|
|
fCreateRot = PARK_CAR_ROT
|
|
ENDIF
|
|
|
|
IF SHOULD_USE_REPLAY_VEHICLE(createStage)
|
|
CPRINTLN(DEBUG_MISSION, "CREATE_PLAYER_FINALE_VEHICLE using a replay vehicle")
|
|
CREATE_VEHICLE_FOR_REPLAY(finaleVehicle[FV_MISSION_START_CAR], vCreatePos, fCreateRot)
|
|
ELSE
|
|
VEHICLE_INDEX storedVehicle = GET_MISSION_START_VEHICLE_INDEX()
|
|
IF IS_ENTITY_OK(storedVehicle)
|
|
CPRINTLN(DEBUG_MISSION, "CREATE_PLAYER_FINALE_VEHICLE using stored mission start vehicle")
|
|
finaleVehicle[FV_MISSION_START_CAR] = storedVehicle
|
|
ELSE
|
|
CPRINTLN(DEBUG_MISSION, "CREATE_PLAYER_FINALE_VEHICLE got an invalid mission_start_vehicle_index")
|
|
|
|
WHILE NOT CREATE_PLAYER_VEHICLE(finaleVehicle[FV_MISSION_START_CAR], CHAR_FRANKLIN, vCreatePos, fCreateRot, TRUE, VEHICLE_TYPE_BIKE)
|
|
WAIT(0)
|
|
ENDWHILE
|
|
//CREATE_VEHICLE_FOR_REPLAY(finaleVehicle[FV_MISSION_START_CAR], vCreatePos, fCreateRot, FALSE, FALSE, FALSE, FALSE, TRUE, DEFAULT, DEFAULT, CHAR_FRANKLIN)
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF IS_ENTITY_OK(finaleVehicle[FV_MISSION_START_CAR])
|
|
SET_VEHICLE_ON_GROUND_PROPERLY(finaleVehicle[FV_MISSION_START_CAR])
|
|
SET_VEHICLE_ENGINE_ON(finaleVehicle[FV_MISSION_START_CAR], TRUE, TRUE)
|
|
|
|
SET_FINALE_VEHICLE_PROPERTIES(FV_MISSION_START_CAR)
|
|
ENDIF
|
|
ENDPROC
|
|
|
|
// setup player character with their correct variations
|
|
PROC SETUP_PLAYER_CHARACTER_WITH_MISSION_VARIATIONS(PED_INDEX ped, enumCharacterList createChar)
|
|
IF NOT IS_PED_INJURED(ped)
|
|
SWITCH createChar
|
|
CASE CHAR_MICHAEL
|
|
SET_PED_COMP_ITEM_CURRENT_SP(ped, COMP_TYPE_OUTFIT, OUTFIT_P0_LEATHER_AND_JEANS, FALSE)
|
|
BREAK
|
|
CASE CHAR_TREVOR
|
|
SET_PED_COMP_ITEM_CURRENT_SP(ped, COMP_TYPE_OUTFIT, OUTFIT_P2_TSHIRT_JEANS_2, FALSE)
|
|
BREAK
|
|
ENDSWITCH
|
|
ENDIF
|
|
ENDPROC
|
|
|
|
// apply attributes
|
|
PROC APPLY_PLAYER_ATTRIBUTES(PED_INDEX ped)
|
|
SET_BLOCKING_OF_NON_TEMPORARY_EVENTS(ped, TRUE)
|
|
SET_PED_RELATIONSHIP_GROUP_HASH(ped, RELGROUPHASH_PLAYER)
|
|
SET_PED_CAN_BE_TARGETTED(ped, FALSE)
|
|
SET_PED_KEEP_TASK(ped, TRUE)
|
|
SET_ENTITY_ONLY_DAMAGED_BY_PLAYER(ped, TRUE)
|
|
SET_ENTITY_AS_MISSION_ENTITY(ped, TRUE, TRUE)
|
|
SET_PED_SUFFERS_CRITICAL_HITS(ped, FALSE)
|
|
SET_PED_CONFIG_FLAG(ped, PCF_DisableHurt, TRUE)
|
|
SET_PED_CONFIG_FLAG(ped, PCF_DisableExplosionReactions, TRUE)
|
|
SET_PED_CAN_BE_KNOCKED_OFF_VEHICLE(ped, KNOCKOFFVEHICLE_HARD)
|
|
SET_PED_CAN_SWITCH_WEAPON(ped, FALSE)
|
|
SET_RAGDOLL_BLOCKING_FLAGS(ped, RBF_BULLET_IMPACT)
|
|
ENDPROC
|
|
|
|
// all player peds block non-temporary events and reset relationships
|
|
PROC REAPPLY_PLAYER_PED_ATTRIBUTES(MISSION_STAGE_ENUM stageToSet, BOOL bSetPlayerProofsOff = TRUE)
|
|
|
|
INT i
|
|
REPEAT COUNT_OF(sSelectorPeds.pedID) i
|
|
IF NOT IS_PED_INJURED(sSelectorPeds.pedID[i])
|
|
APPLY_PLAYER_ATTRIBUTES(sSelectorPeds.pedID[i])
|
|
|
|
IF stageToSet >= STAGE_SHOOTOUT_STAGE_1
|
|
AND stageToSet <= STAGE_SHOOTOUT_STAGE_4
|
|
SET_PED_USING_ACTION_MODE(sSelectorPeds.pedID[i], TRUE)
|
|
ENDIF
|
|
ENDIF
|
|
ENDREPEAT
|
|
IF NOT IS_PED_INJURED(PLAYER_PED_ID())
|
|
IF bSetPlayerProofsOff
|
|
SET_ENTITY_ONLY_DAMAGED_BY_PLAYER(PLAYER_PED_ID(), FALSE)
|
|
SET_ENTITY_PROOFS(PLAYER_PED_ID(), FALSE, FALSE, FALSE, FALSE, FALSE)
|
|
CLEAR_RAGDOLL_BLOCKING_FLAGS(PLAYER_PED_ID(), RBF_BULLET_IMPACT)
|
|
ENDIF
|
|
|
|
SET_PED_CAN_SWITCH_WEAPON(PLAYER_PED_ID(), TRUE)
|
|
SET_PED_CAN_BE_KNOCKED_OFF_VEHICLE(PLAYER_PED_ID(), KNOCKOFFVEHICLE_DEFAULT)
|
|
SET_PED_CONFIG_FLAG(PLAYER_PED_ID(), PCF_ForcedToStayInCover, FALSE)
|
|
|
|
SET_PED_MAX_HEALTH(PLAYER_PED_ID(), 200)
|
|
SET_ENTITY_HEALTH(PLAYER_PED_ID(), 200)
|
|
|
|
IF stageToSet >= STAGE_SHOOTOUT_STAGE_1 AND stageToSet <= STAGE_SHOOTOUT_STAGE_4
|
|
SET_PED_USING_ACTION_MODE(PLAYER_PED_ID(), TRUE)
|
|
ENDIF
|
|
ENDIF
|
|
ENDPROC
|
|
|
|
// create player character
|
|
PROC FINALE_CREATE_PLAYER_CHARACTER(enumCharacterList createChar, VECTOR vPos, FLOAT fRot, VEHICLE_INDEX veh = NULL, VEHICLE_SEAT seat = VS_DRIVER, BOOL bWaitForStreaming = FALSE)
|
|
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
|
|
|
|
IF bWaitForStreaming
|
|
BOOL bFullyStreamed = FALSE
|
|
WHILE NOT bFullyStreamed
|
|
WAIT(0)
|
|
IF NOT IS_PED_DEAD_OR_DYING(sSelectorPeds.pedID[selectorSlot])
|
|
AND NOT IS_PED_INJURED(sSelectorPeds.pedID[selectorSlot])
|
|
IF HAVE_ALL_STREAMING_REQUESTS_COMPLETED(sSelectorPeds.pedID[selectorSlot])
|
|
bFullyStreamed = TRUE
|
|
ENDIF
|
|
ELSE
|
|
bFullyStreamed = TRUE
|
|
ENDIF
|
|
ENDWHILE
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF NOT IS_PED_INJURED(sSelectorPeds.pedID[selectorSlot])
|
|
APPLY_PLAYER_ATTRIBUTES(sSelectorPeds.pedID[selectorSlot])
|
|
|
|
SWITCH createChar
|
|
CASE CHAR_MICHAEL
|
|
ADD_PED_FOR_DIALOGUE(finaleConversation, 0, sSelectorPeds.pedID[selectorSlot], "MICHAEL")
|
|
BREAK
|
|
CASE CHAR_TREVOR
|
|
ADD_PED_FOR_DIALOGUE(finaleConversation, 1, sSelectorPeds.pedID[selectorSlot], "TREVOR")
|
|
BREAK
|
|
CASE CHAR_FRANKLIN
|
|
ADD_PED_FOR_DIALOGUE(finaleConversation, 2, sSelectorPeds.pedID[selectorSlot], "FRANKLIN")
|
|
BREAK
|
|
ENDSWITCH
|
|
|
|
SETUP_PLAYER_CHARACTER_WITH_MISSION_VARIATIONS(sSelectorPeds.pedID[selectorSlot], createChar)
|
|
ENDIF
|
|
ENDPROC
|
|
|
|
FUNC ENEMY_PED_ENUM GET_EXECUTIONER_FOR_TREVOR()
|
|
ENEMY_PED_ENUM eEnemyIndex, eReturnIndex
|
|
|
|
IF GET_CLOSEST_ENEMY_TO_ALLY(GET_TREVOR_PED(), eEnemyIndex) < 30
|
|
IF enemyPed[eEnemyIndex].enemyTaskStatus <> ENEMY_TASK_STATUS_CHARGING
|
|
eReturnIndex = eEnemyIndex
|
|
ENDIF
|
|
ENDIF
|
|
|
|
RETURN eReturnIndex
|
|
ENDFUNC
|
|
|
|
// 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
|
|
CREATE_PLAYER_FINALE_VEHICLE(setStage)
|
|
|
|
// create the player characters
|
|
SWITCH setStage
|
|
CASE STAGE_GET_TO_FOUNDRY
|
|
// franklin
|
|
//SET_ENTITY_COORDS(PLAYER_PED_ID(), GET_FINALE_VECTOR(FINVEC_PLAYER_INIT))
|
|
//SET_ENTITY_HEADING(PLAYER_PED_ID(), PLAYER_INIT_ROT)
|
|
BREAK
|
|
CASE STAGE_MEET_GANG
|
|
// franklin
|
|
SET_PED_INTO_VEHICLE(PLAYER_PED_ID(), finaleVehicle[FV_MISSION_START_CAR])
|
|
IF IS_PED_IN_VEHICLE(PLAYER_PED_ID(), finaleVehicle[FV_MISSION_START_CAR])
|
|
IF IS_THIS_MODEL_A_BIKE(GET_ENTITY_MODEL(finaleVehicle[FV_MISSION_START_CAR]))
|
|
SET_PED_HELMET(PLAYER_PED_ID(), FALSE)
|
|
ENDIF
|
|
ENDIF
|
|
BREAK
|
|
CASE STAGE_SHOOTOUT_STAGE_1
|
|
CASE STAGE_SHOOTOUT_STAGE_2
|
|
// franklin
|
|
SET_ENTITY_COORDS(PLAYER_PED_ID(), GET_FINALE_VECTOR(FINVEC_FRANKLIN_READY))
|
|
SET_ENTITY_HEADING(PLAYER_PED_ID(), FRANKLIN_READY_ROT)
|
|
// trevor
|
|
FINALE_CREATE_PLAYER_CHARACTER(CHAR_TREVOR, GET_FINALE_VECTOR(FINVEC_TREVOR_READY), TREVOR_READY_ROT, NULL, VS_DRIVER, TRUE)
|
|
|
|
// michael
|
|
FINALE_CREATE_PLAYER_CHARACTER(CHAR_MICHAEL, GET_FINALE_VECTOR(FINVEC_MICHAEL_READY), MICHAEL_READY_ROT, NULL, VS_DRIVER, TRUE)
|
|
BREAK
|
|
CASE STAGE_SHOOTOUT_STAGE_3
|
|
FINALE_CREATE_PLAYER_CHARACTER(CHAR_TREVOR, GET_FINALE_VECTOR(FINVEC_TREVOR_SAVETREVOR), TREVOR_SAVETREVOR_ROT, NULL, VS_DRIVER, TRUE)
|
|
BREAK
|
|
CASE STAGE_SHOOTOUT_STAGE_4
|
|
CASE STAGE_OUTRO_CUTSCENE
|
|
// michael
|
|
SET_ENTITY_COORDS(PLAYER_PED_ID(), GET_FINALE_VECTOR(FINVEC_MICHAEL_GROUND_READY))
|
|
SET_ENTITY_HEADING(PLAYER_PED_ID(), MICHAEL_GROUND_READY_ROT)
|
|
|
|
// trevor
|
|
FINALE_CREATE_PLAYER_CHARACTER(CHAR_TREVOR, GET_SCRIPTED_COVER_POINT_COORDS(topExitInnerCover), TREVOR_GROUND_READY_ROT, NULL, VS_DRIVER, TRUE)
|
|
|
|
// franklin
|
|
FINALE_CREATE_PLAYER_CHARACTER(CHAR_FRANKLIN, GET_FINALE_VECTOR(FINVEC_FRANKLIN_OUTSIDE_READY),FRANKLIN_OUTSIDE_READY_ROT, NULL, VS_DRIVER, TRUE)
|
|
BREAK
|
|
ENDSWITCH
|
|
ENDPROC
|
|
|
|
// close all vehicle doors
|
|
PROC CLOSE_ALL_VEHICLE_DOORS(VEHICLE_INDEX veh)
|
|
IF IS_VEHICLE_DRIVEABLE(veh)
|
|
SET_VEHICLE_DOOR_CONTROL(veh, SC_DOOR_FRONT_RIGHT, DT_DOOR_SWINGING_FREE, 0.0)
|
|
SET_VEHICLE_DOOR_CONTROL(veh, SC_DOOR_FRONT_LEFT, DT_DOOR_SWINGING_FREE, 0.0)
|
|
SET_VEHICLE_DOOR_CONTROL(veh, SC_DOOR_REAR_LEFT, DT_DOOR_SWINGING_FREE, 0.0)
|
|
SET_VEHICLE_DOOR_CONTROL(veh, SC_DOOR_REAR_RIGHT, DT_DOOR_SWINGING_FREE, 0.0)
|
|
ENDIF
|
|
ENDPROC
|
|
|
|
// close all vehicle doors
|
|
PROC SHUT_ALL_VEHICLE_DOORS(VEHICLE_INDEX veh)
|
|
IF IS_VEHICLE_DRIVEABLE(veh)
|
|
SET_VEHICLE_DOOR_SHUT(veh, SC_DOOR_FRONT_RIGHT)
|
|
SET_VEHICLE_DOOR_SHUT(veh, SC_DOOR_FRONT_LEFT)
|
|
SET_VEHICLE_DOOR_SHUT(veh, SC_DOOR_REAR_LEFT)
|
|
SET_VEHICLE_DOOR_SHUT(veh, SC_DOOR_REAR_RIGHT)
|
|
ENDIF
|
|
ENDPROC
|
|
|
|
// give michael AR
|
|
CONST_INT AR_AMMO 180
|
|
PROC GIVE_MICHAEL_ASSAULT_RIFLE(BOOL bForceIntoHand = FALSE)
|
|
CPRINTLN(DEBUG_MISSION, "BSW GIVE_MICHAEL_ASSAULT_RIFLE start")
|
|
PED_INDEX michaelPed = GET_MICHAEL_PED()
|
|
|
|
IF NOT IS_PED_INJURED(michaelPed)
|
|
IF NOT HAS_PED_GOT_WEAPON(michaelPed, GET_FINALE_WEAPON_TYPE(F_WEAPON_MERC_RIFLE))
|
|
GIVE_WEAPON_TO_PED(michaelPed, GET_FINALE_WEAPON_TYPE(F_WEAPON_MERC_RIFLE), AR_AMMO)
|
|
ELSE
|
|
IF GET_AMMO_IN_PED_WEAPON(michaelPed, GET_FINALE_WEAPON_TYPE(F_WEAPON_MERC_RIFLE)) < AR_AMMO
|
|
SET_PED_AMMO(michaelPed,GET_FINALE_WEAPON_TYPE(F_WEAPON_MERC_RIFLE), AR_AMMO)
|
|
ENDIF
|
|
ENDIF
|
|
IF michaelPed <> PLAYER_PED_ID() OR bForceIntoHand
|
|
SET_CURRENT_PED_WEAPON(michaelPed, GET_FINALE_WEAPON_TYPE(F_WEAPON_MERC_RIFLE), TRUE)
|
|
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
|
|
|
|
// 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
|
|
FUNC BOOL DO_RANDOM_SPEECH(STRING sSpeech, INT iNextMinTime = -1, INT iNextMaxTime = -1)
|
|
// initialise next speech time if not yet done so
|
|
IF iNextRandomSpeechTime < 0
|
|
SET_NEXT_RANDOM_SPEECH_TIME()
|
|
ENDIF
|
|
|
|
IF GET_GAME_TIMER() >= iNextRandomSpeechTime
|
|
IF DO_MISSION_SPEECH(sSpeech)
|
|
INT iSetNextSpeechTime = -1
|
|
IF iNextMinTime > 0
|
|
iSetNextSpeechTime = GET_RANDOM_INT_IN_RANGE(iNextMinTime, iNextMaxTime)
|
|
ENDIF
|
|
SET_NEXT_RANDOM_SPEECH_TIME(iSetNextSpeechTime)
|
|
RETURN TRUE
|
|
ENDIF
|
|
ENDIF
|
|
|
|
RETURN FALSE
|
|
ENDFUNC
|
|
|
|
// create lamar
|
|
//
|
|
|
|
/// PURPOSE:
|
|
/// Create Lamars ped with the correct setup for the indicated stage
|
|
/// PARAMS:
|
|
/// createStage - Mission stage to setup Lamar for
|
|
/// DoCollisionCheck - Only return TRUE if collision for Lamar has loaded
|
|
/// RETURNS:
|
|
/// TRUE if Lamar has been successfully created and collision is loaded (if DoCollisionCheck is set to TRUE).
|
|
/// FALSE Otherwise
|
|
FUNC BOOL CREATE_LAMAR_FOR_STAGE(MISSION_STAGE_ENUM createStage, BOOL DoCollisionCheck = FALSE)
|
|
CPRINTLN(DEBUG_MISSION, "BSW creating Lamar...")
|
|
|
|
WEAPON_TYPE lamarsWeapon = WEAPONTYPE_INVALID
|
|
BOOL bLamarBool = TRUE
|
|
|
|
IF NOT DOES_ENTITY_EXIST(lamarPed)
|
|
CPRINTLN(DEBUG_MISSION, "Lamar doesn't exist, making him.")
|
|
SWITCH createStage
|
|
CASE STAGE_GET_TO_FOUNDRY
|
|
CREATE_NPC_PED_ON_FOOT(lamarPed, CHAR_LAMAR, GET_FINALE_VECTOR(FINVEC_LAMAR_INIT), LAMAR_INIT_ROT, FALSE)
|
|
lamarsWeapon = WEAPONTYPE_ASSAULTRIFLE
|
|
bLamarBool = FALSE
|
|
|
|
lamarsPhone = CREATE_OBJECT(GET_MODEL_FOR_FINALE_MODEL_ENUM(FM_PHONE), GET_OFFSET_FROM_ENTITY_IN_WORLD_COORDS(lamarPed, <<0.0, 0.0, 1.0>>))
|
|
ATTACH_ENTITY_TO_ENTITY(lamarsPhone, lamarPed, GET_PED_BONE_INDEX(lamarPed, BONETAG_PH_R_HAND), <<0,0,0>>, <<0,0,0>>)
|
|
BREAK
|
|
CASE STAGE_SHOOTOUT_STAGE_2
|
|
CREATE_NPC_PED_ON_FOOT(lamarPed, CHAR_LAMAR, GET_FINALE_VECTOR(FINVEC_LAMAR_SHOOTOUT), LAMAR_SHOOTOUT_ROT, FALSE)
|
|
lamarsWeapon = WEAPONTYPE_ASSAULTRIFLE
|
|
BREAK
|
|
CASE STAGE_SHOOTOUT_STAGE_4
|
|
CPRINTLN(DEBUG_MISSION, "Lamar stage 4")
|
|
CREATE_NPC_PED_ON_FOOT(lamarPed, CHAR_LAMAR, GET_FINALE_VECTOR(FINVEC_LAMAR_SHOOTOUT), LAMAR_SHOOTOUT_ROT, FALSE)
|
|
lamarsWeapon = WEAPONTYPE_ASSAULTRIFLE
|
|
BREAK
|
|
DEFAULT
|
|
CREATE_NPC_PED_INSIDE_VEHICLE(lamarPed, CHAR_LAMAR, finaleVehicle[FV_MISSION_START_CAR], VS_FRONT_RIGHT, FALSE)
|
|
IF IS_PED_IN_VEHICLE(lamarPed, finaleVehicle[FV_MISSION_START_CAR])
|
|
IF IS_THIS_MODEL_A_BIKE(GET_ENTITY_MODEL(finaleVehicle[FV_MISSION_START_CAR]))
|
|
SET_PED_HELMET(lamarPed, FALSE)
|
|
ENDIF
|
|
ENDIF
|
|
BREAK
|
|
ENDSWITCH
|
|
ENDIF
|
|
|
|
IF NOT IS_PED_INJURED(lamarPed)
|
|
CPRINTLN(DEBUG_MISSION, "Set Lamar stuff")
|
|
SET_PED_GROUP_MEMBER_PASSENGER_INDEX(lamarPed, VS_FRONT_RIGHT)
|
|
SET_PED_RELATIONSHIP_GROUP_HASH(lamarPed, RELGROUPHASH_PLAYER)
|
|
SET_PED_CAN_BE_TARGETTED(lamarPed, FALSE)
|
|
SET_BLOCKING_OF_NON_TEMPORARY_EVENTS(lamarPed, TRUE)
|
|
SET_ENTITY_ONLY_DAMAGED_BY_PLAYER(lamarPed, bLamarBool)
|
|
SET_PED_CONFIG_FLAG(lamarPed, PCF_WillFlyThroughWindscreen, FALSE)
|
|
SET_PED_KEEP_TASK(lamarPed, TRUE)
|
|
SET_PED_DIES_WHEN_INJURED(lamarPed, TRUE)
|
|
ADD_PED_FOR_DIALOGUE(finaleConversation, 3, lamarPed, "LAMAR")
|
|
IF IS_WEAPON_VALID(lamarsWeapon)
|
|
IF NOT HAS_PED_GOT_WEAPON(lamarPed, lamarsWeapon)
|
|
GIVE_WEAPON_TO_PED(lamarPed, lamarsWeapon, 1000)
|
|
ELSE
|
|
SET_PED_AMMO(lamarPed, lamarsWeapon, 1000)
|
|
ENDIF
|
|
ENDIF
|
|
ADD_ENTITY_TO_AUDIO_MIX_GROUP(lamarPed, "FINALE_BUDDY_Group")
|
|
ENDIF
|
|
|
|
IF IS_ENTITY_OK(lamarPed)
|
|
IF DoCollisionCheck
|
|
IF HAVE_ALL_STREAMING_REQUESTS_COMPLETED(lamarPed)
|
|
//[MF] Lamar has spawned succesfully AND all geo has loaded
|
|
RETURN TRUE
|
|
ENDIF
|
|
ELSE
|
|
//[MF] Lamar has spawned successfully
|
|
RETURN TRUE
|
|
ENDIF
|
|
ENDIF
|
|
|
|
//[MF] Either Lamar hasn't completed spawning or we're still waiting for geo to load...
|
|
RETURN FALSE
|
|
|
|
ENDFUNC
|
|
|
|
/// PURPOSE:
|
|
/// Handles Lamar's animations as he waits to be picked up by Franklin
|
|
/// RETURNS:
|
|
/// TRUE when done and ready to get into the car
|
|
FUNC BOOL HANDLE_LAMAR_WAITING_TO_BE_PICKED_UP()
|
|
IF NOT IS_ENTITY_OK(lamarPed)
|
|
RETURN FALSE
|
|
ENDIF
|
|
|
|
SEQUENCE_INDEX iSeq
|
|
|
|
SWITCH eLamarWaitCarState
|
|
CASE LAMAR_WAIT_PHONE_LOOP
|
|
OPEN_SEQUENCE_TASK(iSeq)
|
|
TASK_PLAY_ANIM(NULL, GET_FINALE_ANIM_DICT_AS_STRING(F_ANIM_DICT_LAMAR_WAIT), "PHONE_LOOP", NORMAL_BLEND_IN, NORMAL_BLEND_OUT, -1, AF_LOOPING)
|
|
CLOSE_SEQUENCE_TASK(iSeq)
|
|
TASK_PERFORM_SEQUENCE(lamarPed, iSeq)
|
|
CLEAR_SEQUENCE_TASK(iSeq)
|
|
eLamarWaitCarState = LAMAR_WAIT_PLAYER_ARRIVES
|
|
BREAK
|
|
CASE LAMAR_WAIT_PLAYER_ARRIVES
|
|
IF IS_PLAYER_AT_LOCATION_ANY_MEANS(Locates_Data, <<-60.4284, -1463.9620, 31.0828>>, (<<7, 4, LOCATE_SIZE_HEIGHT>>), TRUE, "", FALSE)
|
|
IF NOT bSuppressGreeting
|
|
OPEN_SEQUENCE_TASK(iSeq)
|
|
TASK_PLAY_ANIM(NULL, GET_FINALE_ANIM_DICT_AS_STRING(F_ANIM_DICT_LAMAR_WAIT), "PHONE_OUTRO")
|
|
TASK_TURN_PED_TO_FACE_ENTITY(NULL, PLAYER_PED_ID())
|
|
CLOSE_SEQUENCE_TASK(iSeq)
|
|
TASK_PERFORM_SEQUENCE(lamarPed, iSeq)
|
|
CLEAR_SEQUENCE_TASK(iSeq)
|
|
ENDIF
|
|
TASK_LOOK_AT_ENTITY(lamarPed, PLAYER_PED_ID(), INFINITE_TASK_TIME, SLF_WHILE_NOT_IN_FOV | SLF_EXTEND_YAW_LIMIT, SLF_LOOKAT_HIGH)
|
|
REPLAY_RECORD_BACK_FOR_TIME(5.0, 7.0, REPLAY_IMPORTANCE_HIGHEST)
|
|
eLamarWaitCarState = LAMAR_WAIT_STOP_PLAYER
|
|
ELIF IS_PED_RAGDOLL(lamarPed)
|
|
IF GET_SCRIPT_TASK_STATUS(lamarPed, SCRIPT_TASK_PERFORM_SEQUENCE) <> FINISHED_TASK
|
|
CLEAR_PED_TASKS(lamarPed)
|
|
TASK_LOOK_AT_ENTITY(lamarPed, PLAYER_PED_ID(), INFINITE_TASK_TIME, SLF_WHILE_NOT_IN_FOV | SLF_EXTEND_YAW_LIMIT, SLF_LOOKAT_HIGH)
|
|
bSuppressGreeting = TRUE
|
|
ENDIF
|
|
ENDIF
|
|
BREAK
|
|
CASE LAMAR_WAIT_STOP_PLAYER
|
|
IF IS_PED_IN_ANY_VEHICLE(PLAYER_PED_ID())
|
|
IF BRING_VEHICLE_TO_HALT_AND_DISABLE_VEH_CONTROLS(GET_VEHICLE_PED_IS_IN(PLAYER_PED_ID()), 5, 4)
|
|
eLamarWaitCarState = LAMAR_WAIT_PHONE_OUTRO
|
|
ENDIF
|
|
ELSE
|
|
eLamarWaitCarState = LAMAR_WAIT_PHONE_OUTRO
|
|
ENDIF
|
|
BREAK
|
|
CASE LAMAR_WAIT_PHONE_OUTRO
|
|
IF NOT IS_ENTITY_PLAYING_ANIM(lamarPed, GET_FINALE_ANIM_DICT_AS_STRING(F_ANIM_DICT_LAMAR_WAIT), "PHONE_OUTRO")
|
|
OR IS_PED_RAGDOLL(lamarPed)
|
|
IF DOES_ENTITY_EXIST(lamarsPhone)
|
|
DELETE_OBJECT(lamarsPhone)
|
|
ENDIF
|
|
|
|
eTravelCurrentText = TRAVEL_TEXT_GET_IN_LAMAR
|
|
|
|
IF IS_PED_RAGDOLL(lamarPed)
|
|
CLEAR_PED_TASKS(lamarPed)
|
|
ENDIF
|
|
|
|
IF IS_ENTITY_OK(PLAYER_PED_ID())
|
|
TASK_LOOK_AT_ENTITY(PLAYER_PED_ID(), lamarPed, -1, SLF_WHILE_NOT_IN_FOV, SLF_LOOKAT_VERY_HIGH)
|
|
eLamarWaitCarState = LAMAR_WAIT_GO_TO_CAR
|
|
ENDIF
|
|
ELSE
|
|
IF IS_ENTITY_OK(lamarPed) AND NOT bLamarApproached
|
|
IF GET_ENTITY_ANIM_CURRENT_TIME(lamarPed, GET_FINALE_ANIM_DICT_AS_STRING(F_ANIM_DICT_LAMAR_WAIT), "PHONE_OUTRO") > 0.2
|
|
bLamarApproached = TRUE
|
|
eTravelCurrentText = TRAVEL_TEXT_APPROACH_LAMAR
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
BREAK
|
|
CASE LAMAR_WAIT_GO_TO_CAR
|
|
TASK_CLEAR_LOOK_AT(lamarPed)
|
|
TASK_CLEAR_LOOK_AT(PLAYER_PED_ID())
|
|
|
|
RETURN TRUE
|
|
BREAK
|
|
CASE LAMAR_WAIT_CONVERSATION
|
|
IF NOT IS_ANY_CONVERSATION_ONGOING_OR_QUEUED()
|
|
TASK_CLEAR_LOOK_AT(lamarPed)
|
|
|
|
RETURN TRUE
|
|
ENDIF
|
|
BREAK
|
|
ENDSWITCH
|
|
RETURN FALSE
|
|
ENDFUNC
|
|
|
|
PROC POSITION_LAMAR_IN_COVER_FOR_SHOOTOUT()
|
|
CPRINTLN(DEBUG_MISSION, "POSITION_LAMAR_IN_COVER_FOR_SHOOTOUT")
|
|
IF IS_ENTITY_OK(lamarPed)
|
|
SEQUENCE_INDEX seqLamar
|
|
FLOAT fCombatRange = 75.0
|
|
|
|
CPRINTLN(DEBUG_MISSION, "Tasking Lamar to combat.")
|
|
OPEN_SEQUENCE_TASK(seqLamar)
|
|
TASK_SET_SPHERE_DEFENSIVE_AREA(NULL, GET_FINALE_VECTOR(FINVEC_LAMAR_SHOOTOUT), 2.75)
|
|
TASK_COMBAT_HATED_TARGETS_AROUND_PED(NULL, fCombatRange)
|
|
CLOSE_SEQUENCE_TASK(seqLamar)
|
|
TASK_PERFORM_SEQUENCE(lamarPed, seqLamar)
|
|
CLEAR_SEQUENCE_TASK(seqLamar)
|
|
|
|
SET_PED_COMBAT_MOVEMENT(lamarPed, CM_DEFENSIVE)
|
|
SET_PED_SEEING_RANGE(lamarPed, fCombatRange)
|
|
SET_PED_HEARING_RANGE(lamarPed, fCombatRange)
|
|
SET_PED_ID_RANGE(lamarPed, fCombatRange)
|
|
SET_PED_ACCURACY(lamarPed, 5)
|
|
ENDIF
|
|
ENDPROC
|
|
|
|
PROC HANDLE_LAMAR_IN_COMBAT()
|
|
IF IS_ENTITY_OK(lamarPed)
|
|
IF GET_SCRIPT_TASK_STATUS(lamarPed, SCRIPT_TASK_PERFORM_SEQUENCE) > PERFORMING_TASK
|
|
POSITION_LAMAR_IN_COVER_FOR_SHOOTOUT()
|
|
ENDIF
|
|
ENDIF
|
|
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_FINALE_VECTOR(FINVEC_PLAYER_INIT))
|
|
SET_ENTITY_HEADING(PLAYER_PED_ID(), PLAYER_INIT_ROT)
|
|
SET_GAMEPLAY_CAM_RELATIVE_HEADING()
|
|
|
|
FORCE_PED_MOTION_STATE(PLAYER_PED_ID(), MS_ON_FOOT_WALK, FALSE, FAUS_CUTSCENE_EXIT)
|
|
SIMULATE_PLAYER_INPUT_GAIT(PLAYER_ID(), PEDMOVE_WALK, 5000)
|
|
ENDIF
|
|
ENDPROC
|
|
|
|
// create barrels
|
|
PROC CREATE_INTERIOR_PROPS()
|
|
INT i
|
|
VECTOR vPos
|
|
FLOAT fRot
|
|
REPEAT NUMBER_BARRELS i
|
|
SWITCH i
|
|
// mid foundry floor
|
|
CASE 0
|
|
vPos = <<1089.32, -1998.79, 29.93>>
|
|
fRot = 124
|
|
BREAK
|
|
// back foundry near plow
|
|
CASE 1
|
|
vPos = <<1068.32, -1990.78, 29.95>>
|
|
fRot = 6
|
|
BREAK
|
|
// foundry floor near cauldron
|
|
CASE 2
|
|
vPos = <<1101.26, -2004.10, 28.43>>
|
|
fRot = 272
|
|
BREAK
|
|
// catwalk
|
|
CASE 3
|
|
vPos = <<1107.4098, -2025.9827, 42.8439>>
|
|
fRot = 242
|
|
BREAK
|
|
ENDSWITCH
|
|
|
|
IF NOT DOES_ENTITY_EXIST(interiorBarrelObject[i])
|
|
interiorBarrelObject[i] = CREATE_OBJECT(GET_MODEL_FOR_FINALE_MODEL_ENUM(FM_BARREL), vPos)
|
|
SET_ENTITY_HEADING(interiorBarrelObject[i], fRot)
|
|
SET_OBJECT_TARGETTABLE(interiorBarrelObject[i], TRUE)
|
|
ENDIF
|
|
ENDREPEAT
|
|
ENDPROC
|
|
|
|
PROC CREATE_EXTERIOR_PROPS()
|
|
|
|
IF NOT DOES_ENTITY_EXIST(exteriorBarrelObject[0])
|
|
exteriorBarrelObject[0] = CREATE_OBJECT(GET_MODEL_FOR_FINALE_MODEL_ENUM(FM_BARREL), <<1078.86, -2043.43, 31.31>>)
|
|
SET_ENTITY_HEADING(exteriorBarrelObject[0], 89)
|
|
SET_OBJECT_TARGETTABLE(exteriorBarrelObject[0], TRUE)
|
|
ENDIF
|
|
|
|
IF NOT DOES_ENTITY_EXIST(coverCrate)
|
|
coverCrate = CREATE_OBJECT(GET_MODEL_FOR_FINALE_MODEL_ENUM(FM_CRATE), <<1077.1471, -1969.3192, 30.0447>>)
|
|
SET_ENTITY_HEADING(coverCrate, 47)
|
|
FREEZE_ENTITY_POSITION(coverCrate, TRUE)
|
|
ENDIF
|
|
|
|
// near back wall
|
|
IF NOT DOES_ENTITY_EXIST(backFightCoverCrates[0])
|
|
backFightCoverCrates[0] = CREATE_OBJECT(GET_MODEL_FOR_FINALE_MODEL_ENUM(FM_CRATE), <<1083.1292, -2056.5994, 30.0244>>)
|
|
SET_ENTITY_HEADING(backFightCoverCrates[0], 12)
|
|
FREEZE_ENTITY_POSITION(backFightCoverCrates[0], TRUE)
|
|
ENDIF
|
|
|
|
// near railcar(?)
|
|
IF NOT DOES_ENTITY_EXIST(backFightCoverCrates[1])
|
|
backFightCoverCrates[1] = CREATE_OBJECT(GET_MODEL_FOR_FINALE_MODEL_ENUM(FM_CRATE), <<1084.6306, -2058.2605, 30.0244>>)
|
|
SET_ENTITY_HEADING(backFightCoverCrates[1], 319)
|
|
FREEZE_ENTITY_POSITION(backFightCoverCrates[1], TRUE)
|
|
ENDIF
|
|
ENDPROC
|
|
|
|
|
|
// give weapons - temp
|
|
PROC GIVE_CHARACTERS_WEAPONS(BOOL bForceFranklinWep = TRUE)
|
|
WEAPON_TYPE wepMichael = GET_FINALE_WEAPON_TYPE(F_WEAPON_SNIPER)
|
|
WEAPON_TYPE wepTrevor = GET_FINALE_WEAPON_TYPE(F_WEAPON_LMG)
|
|
WEAPON_TYPE wepFranklin = GET_FINALE_WEAPON_TYPE(F_WEAPON_PISTOL)
|
|
|
|
// get franklin's best pistol and use that instead
|
|
IF NOT IS_PED_INJURED(GET_FRANKLIN_PED())
|
|
WEAPON_TYPE newPistol = GET_PED_WEAPONTYPE_IN_SLOT(GET_FRANKLIN_PED(), WEAPONSLOT_PISTOL)
|
|
IF IS_WEAPON_VALID(newPistol)
|
|
wepFranklin = newPistol
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF IS_REPLAY_IN_PROGRESS()
|
|
CPRINTLN(DEBUG_MISSION, "BSW setting up player replay weapons")
|
|
WEAPON_TYPE retryWep
|
|
retryWep = GET_FAIL_WEAPON(ENUM_TO_INT(CHAR_MICHAEL))
|
|
IF IS_WEAPON_VALID(retryWep)
|
|
wepMichael = GET_FAIL_WEAPON(ENUM_TO_INT(CHAR_MICHAEL))
|
|
ENDIF
|
|
retryWep = GET_FAIL_WEAPON(ENUM_TO_INT(CHAR_TREVOR))
|
|
IF IS_WEAPON_VALID(retryWep)
|
|
wepTrevor = GET_FAIL_WEAPON(ENUM_TO_INT(CHAR_TREVOR))
|
|
ENDIF
|
|
retryWep = GET_FAIL_WEAPON(ENUM_TO_INT(CHAR_FRANKLIN))
|
|
IF IS_WEAPON_VALID(retryWep)
|
|
wepFranklin = GET_FAIL_WEAPON(ENUM_TO_INT(CHAR_FRANKLIN))
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF NOT IS_PED_INJURED(GET_MICHAEL_PED())
|
|
GIVE_WEAPON_TO_PED(GET_MICHAEL_PED(), wepMichael, 100, TRUE)
|
|
ENDIF
|
|
|
|
IF NOT IS_PED_INJURED(GET_TREVOR_PED())
|
|
GIVE_WEAPON_TO_PED(GET_TREVOR_PED(), wepTrevor, 800, TRUE)
|
|
ENDIF
|
|
|
|
IF bForceFranklinWep
|
|
IF NOT IS_PED_INJURED(GET_FRANKLIN_PED())
|
|
GIVE_WEAPON_TO_PED(GET_FRANKLIN_PED(), wepFranklin, 200, TRUE)
|
|
ENDIF
|
|
ENDIF
|
|
|
|
ENDPROC
|
|
|
|
PROC CREATE_AMBIENT_VEHICLES()
|
|
IF NOT DOES_ENTITY_eXIST(ambientVehicles[0])
|
|
ambientVehicles[0] = CREATE_VEHICLE(GET_MODEL_FOR_FINALE_MODEL_ENUM(FM_FIB_VAN), <<1050.2419, -2108.3958, 31.3739>>, 82.8)
|
|
SET_VEHICLE_SIREN(ambientVehicles[0], TRUE)
|
|
ENDIF
|
|
IF NOT DOES_ENTITY_eXIST(ambientVehicles[1])
|
|
ambientVehicles[1] = CREATE_VEHICLE(GET_MODEL_FOR_FINALE_MODEL_ENUM(FM_FIB_VAN), <<1075.1447, -2087.6377, 33.3449>>, 292.0)
|
|
SET_VEHICLE_SIREN(ambientVehicles[1], TRUE)
|
|
ENDIF
|
|
IF NOT DOES_ENTITY_eXIST(ambientVehicles[2])
|
|
ambientVehicles[2] = CREATE_VEHICLE(GET_MODEL_FOR_FINALE_MODEL_ENUM(FM_FIB_VAN), <<1110.5468, -2091.8208, 37.3995>>, 282.6)
|
|
SET_VEHICLE_SIREN(ambientVehicles[2], TRUE)
|
|
ENDIF
|
|
IF NOT DOES_ENTITY_eXIST(ambientVehicles[3])
|
|
ambientVehicles[3] = CREATE_VEHICLE(GET_MODEL_FOR_FINALE_MODEL_ENUM(FM_FIB_VAN), <<1099.1996, -2094.6226, 35.9406>>, 101.9)
|
|
SET_VEHICLE_SIREN(ambientVehicles[3], TRUE)
|
|
ENDIF
|
|
ENDPROC
|
|
|
|
// create enemy vehicle
|
|
PROC CREATE_ENEMY_VEHICLE(ENEMY_VEHICLE_ENUM vehicleEnum)
|
|
// vehicle
|
|
MODEL_NAMES model
|
|
INT iRec = 000
|
|
VECTOR vPos = <<ENUM_TO_INT(vehicleEnum) * 10, 0, 0>>
|
|
FLOAT fRot = 0.0
|
|
FLOAT fSkip = 0.0
|
|
FLOAT fSpeed = 1.0
|
|
BOOL bOnlyDamagedByPlayer = FALSE
|
|
BOOL bEngineOn = TRUE
|
|
BOOL bSirenOn = FALSE
|
|
|
|
// model
|
|
SWITCH vehicleEnum
|
|
CASE EV_MERC_BATTLE_OUTSIDE_CHOPPER_1
|
|
model = GET_MODEL_FOR_FINALE_MODEL_ENUM(FM_MERC_CHOPPER)
|
|
BREAK
|
|
CASE EV_MERC_BATTLE_OUTSIDE_4WD_1
|
|
CASE EV_MERC_BATTLE_OUTSIDE_4WD_2
|
|
CASE EV_MERC_UP_ROAD_4WD_1
|
|
CASE EV_MERC_UP_ROAD_4WD_2
|
|
CASE EV_MERC_TRAIN_4WD_1
|
|
CASE EV_MERC_TRAIN_4WD_2
|
|
model = GET_MODEL_FOR_FINALE_MODEL_ENUM(FM_MERC_4WD)
|
|
BREAK
|
|
CASE EV_FIB_FIGHTING_LAMAR
|
|
CASE EV_FIB_ROAD_REINF_1
|
|
model = GET_MODEL_FOR_FINALE_MODEL_ENUM(FM_FIB_VAN)
|
|
BREAK
|
|
ENDSWITCH
|
|
|
|
// details
|
|
SWITCH vehicleEnum
|
|
CASE EV_MERC_BATTLE_OUTSIDE_CHOPPER_1
|
|
iRec = 004
|
|
fSkip = 3700
|
|
bOnlyDamagedByPlayer = TRUE
|
|
BREAK
|
|
CASE EV_MERC_BATTLE_OUTSIDE_4WD_1
|
|
iRec = 001
|
|
fSkip = 3000
|
|
BREAK
|
|
CASE EV_MERC_BATTLE_OUTSIDE_4WD_2
|
|
iRec = 002
|
|
fSkip = 1000
|
|
BREAK
|
|
CASE EV_MERC_UP_ROAD_4WD_1
|
|
iRec = 005
|
|
fSkip = 7000
|
|
BREAK
|
|
CASE EV_MERC_UP_ROAD_4WD_2
|
|
iRec = 006
|
|
fSkip = 7000
|
|
BREAK
|
|
CASE EV_FIB_FIGHTING_LAMAR
|
|
vPos = <<1071.4458, -1961.9401, 30.0444>>
|
|
fRot = 176.6
|
|
BREAK
|
|
CASE EV_MERC_TRAIN_4WD_1
|
|
vPos = <<1115.3898, -2130.7334, 29.9867>>
|
|
fRot = 322.6
|
|
iRec = 007
|
|
BREAK
|
|
CASE EV_MERC_TRAIN_4WD_2
|
|
vPos = <<1106.1942, -2137.9800, 30.1233>>
|
|
fRot = 344.0
|
|
iRec = 008
|
|
BREAK
|
|
CASE EV_FIB_ROAD_REINF_1
|
|
iRec = 009
|
|
bSirenOn = TRUE
|
|
BREAK
|
|
ENDSWITCH
|
|
|
|
enemyVehicle[vehicleEnum].veh = CREATE_VEHICLE(model, vPos, fRot)
|
|
SET_VEHICLE_ON_GROUND_PROPERLY(enemyVehicle[vehicleEnum].veh)
|
|
IF bEngineOn
|
|
SET_VEHICLE_ENGINE_ON(enemyVehicle[vehicleEnum].veh, TRUE, TRUE)
|
|
ENDIF
|
|
|
|
IF bSirenOn
|
|
SET_VEHICLE_SIREN(enemyVehicle[vehicleEnum].veh, TRUE)
|
|
ENDIF
|
|
|
|
SET_ENTITY_ONLY_DAMAGED_BY_PLAYER(enemyVehicle[vehicleEnum].veh, bOnlyDamagedByPlayer)
|
|
SET_VEHICLE_CAN_BE_TARGETTED(enemyVehicle[vehicleEnum].veh, TRUE)
|
|
|
|
IF IS_THIS_MODEL_A_HELI(model)
|
|
SET_HELI_BLADES_FULL_SPEED(enemyVehicle[vehicleEnum].veh)
|
|
ENDIF
|
|
IF iRec > 000
|
|
START_PLAYBACK_RECORDED_VEHICLE(enemyVehicle[vehicleEnum].veh, iRec, GET_FINALE_RECORDING_PREFIX())
|
|
SET_PLAYBACK_SPEED(enemyVehicle[vehicleEnum].veh, fSpeed)
|
|
SKIP_TIME_IN_PLAYBACK_RECORDED_VEHICLE(enemyVehicle[vehicleEnum].veh, fSkip)
|
|
// changed from crusaders to mesas, need an offset or a re-record
|
|
IF model = GET_MODEL_FOR_FINALE_MODEL_ENUM(FM_MERC_4WD)
|
|
SET_POSITION_OFFSET_FOR_RECORDED_VEHICLE_PLAYBACK(enemyVehicle[vehicleEnum].veh, <<0, 0, 0.278>>)
|
|
ENDIF
|
|
ENDIF
|
|
|
|
ENDPROC
|
|
|
|
// setup the variations on an enemy ped
|
|
PROC SET_ENEMY_VARIATIONS(ENEMY_PED_ENUM enemyEnum)
|
|
PED_INDEX ped = enemyPed[enemyEnum].ped
|
|
|
|
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
|
|
BOOL bHasVariation = TRUE
|
|
|
|
SWITCH enemyEnum
|
|
CASE EP_FIB_SEARCH_FOOT_1
|
|
bHasVariation = FALSE
|
|
BREAK
|
|
DEFAULT
|
|
bHasVariation = FALSE
|
|
BREAK
|
|
ENDSWITCH
|
|
|
|
IF bHasVariation
|
|
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
|
|
ENDIF
|
|
ENDPROC
|
|
|
|
// does enemy ped have ballistic armour
|
|
FUNC BOOL IS_ENEMY_PED_BALLISTIC_ARMOUR(ENEMY_PED_ENUM pedEnum)
|
|
SWITCH pedEnum
|
|
CASE EP_FIB_GROUND_FLOOR_FOOT_1
|
|
CASE EP_FIB_GROUND_FLOOR_FOOT_2
|
|
CASE EP_FIB_GROUND_FLOOR_FOOT_3
|
|
CASE EP_FIB_GROUND_FLOOR_FOOT_4
|
|
RETURN TRUE
|
|
BREAK
|
|
ENDSWITCH
|
|
|
|
RETURN FALSE
|
|
ENDFUNC
|
|
|
|
// get defensive area for enemy
|
|
FUNC VECTOR GET_ENEMY_PED_DEFENSIVE_AREA(ENEMY_PED_ENUM pedEnum)
|
|
SWITCH pedEnum
|
|
CASE EP_MERC_TREVORCORNER_FOOT_1
|
|
RETURN <<1080.6461, -1998.7513, 30.2223>>
|
|
BREAK
|
|
CASE EP_MERC_TREVORCORNER_FOOT_2
|
|
RETURN <<1084.7458, -1991.1451, 28.5265>>
|
|
BREAK
|
|
CASE EP_MERC_TREVORCORNER_FOOT_3
|
|
RETURN <<1075.1682, -1987.3263, 30.0410>>
|
|
BREAK
|
|
CASE EP_FIB_ATTACK_TREVOR_GROUND_1
|
|
CASE EP_FIB_ATTACK_TREVOR_GROUND_2
|
|
CASE EP_FIB_ATTACK_TREVOR_GROUND_3
|
|
CASE EP_FIB_ATTACK_TREVOR_GROUND_4
|
|
CASE EP_FIB_ATTACK_TREVOR_GROUND_5
|
|
CASE EP_FIB_ATTACK_TREVOR_GROUND_6
|
|
CASE EP_FIB_ATTACK_TREVOR_GROUND_7
|
|
CASE EP_FIB_ATTACK_TREVOR_CATWALK_1
|
|
CASE EP_FIB_ATTACK_TREVOR_CATWALK_2
|
|
CASE EP_FIB_ATTACK_TREVOR_CLIMAX_1
|
|
CASE EP_FIB_ATTACK_TREVOR_CLIMAX_2
|
|
CASE EP_FIB_ATTACK_TREVOR_CLIMAX_3
|
|
CASE EP_FIB_ATTACK_TREVOR_CLIMAX_4
|
|
CASE EP_FIB_ATTACK_TREVOR_CLIMAX_5
|
|
CASE EP_FIB_ATTACK_TREVOR_CLIMAX_6
|
|
CASE EP_FIB_ATTACK_TREVOR_CLIMAX_7
|
|
RETURN <<1090.4739, -1994.4098, 28.0966>>
|
|
BREAK
|
|
CASE EP_FIB_LAMAR_BATTLE_1
|
|
CASE EP_FIB_LAMAR_BATTLE_2
|
|
CASE EP_FIB_LAMAR_BATTLE_3
|
|
CASE EP_FIB_LAMAR_BATTLE_REINF_1
|
|
CASE EP_FIB_LAMAR_BATTLE_REINF_2
|
|
CASE EP_FIB_LAMAR_BATTLE_INFINITE_1
|
|
CASE EP_FIB_LAMAR_BATTLE_INFINITE_2
|
|
CASE EP_FIB_ON_ROAD_FOOT_1
|
|
CASE EP_FIB_ON_ROAD_FOOT_2
|
|
CASE EP_FIB_ON_ROAD_FOOT_3
|
|
CASE EP_FIB_ON_ROAD_FOOT_4
|
|
RETURN <<1066.5557, -1958.2693, 30.0444>>
|
|
BREAK
|
|
CASE EP_FIB_LAMAR_BATTLE_REINF_3
|
|
CASE EP_FIB_LAMAR_BATTLE_REINF_4
|
|
CASE EP_FIB_LAMAR_BATTLE_REINF_5
|
|
CASE EP_FIB_ROAD_REINF_1_DRIVER
|
|
CASE EP_FIB_ROAD_REINF_1_PASSFR
|
|
RETURN <<1065.5397, -1950.3646, 30.0444>>
|
|
BREAK
|
|
CASE EP_FIB_LAMAR_BATTLE_4
|
|
RETURN <<1056.2513, -1964.2822, 30.0444>>
|
|
BREAK
|
|
CASE EP_FIB_LAMAR_BATTLE_5
|
|
RETURN <<1045.9607, -1957.5865, 34.1391>>
|
|
BREAK
|
|
|
|
// FIB OUTSIDE WAVE
|
|
CASE EP_FIB_BATTLE_OUTSIDE_FOOT_1
|
|
RETURN <<1078.3196, -2053.4507, 30.0390>>
|
|
BREAK
|
|
CASE EP_FIB_BATTLE_OUTSIDE_FOOT_2
|
|
RETURN <<1082.5980, -2058.6497, 30.0261>>
|
|
BREAK
|
|
CASE EP_FIB_BATTLE_OUTSIDE_FOOT_3
|
|
RETURN <<1076.8340, -2043.0873, 30.0390>>
|
|
BREAK
|
|
CASE EP_MERC_BATTLE_OUTSIDE_4WD_1_DRIVER
|
|
RETURN <<1092.93, -2042.29, 31.78>>
|
|
BREAK
|
|
CASE EP_MERC_BATTLE_OUTSIDE_4WD_1_PASSFR
|
|
RETURN <<1089.50, -2036.61, 29.99>>
|
|
BREAK
|
|
CASE EP_MERC_BATTLE_OUTSIDE_4WD_2_DRIVER
|
|
RETURN <<1097.0999, -2052.7310, 30.0244>>
|
|
BREAK
|
|
|
|
CASE EP_MERC_UP_ROAD_4WD_1_DRIVER
|
|
RETURN <<1071.46, -2029.40, 30.01>>
|
|
BREAK
|
|
CASE EP_MERC_UP_ROAD_4WD_2_DRIVER
|
|
RETURN <<1063.04, -2003.85, 30.01>>
|
|
BREAK
|
|
|
|
CASE EP_MERC_TRAIN_4WD_1_DRIVER
|
|
CASE EP_MERC_TRAIN_4WD_1_PASSFR
|
|
CASE EP_MERC_TRAIN_4WD_2_DRIVER
|
|
CASE EP_MERC_TRAIN_4WD_2_PASSFR
|
|
RETURN <<1108.4097, -2047.6672, 30.0244>>
|
|
BREAK
|
|
|
|
CASE EP_FIB_GROUND_FLOOR_FOOT_1
|
|
RETURN <<1079.65, -1989.83, 30.35>>
|
|
BREAK
|
|
CASE EP_FIB_GROUND_FLOOR_FOOT_2
|
|
RETURN <<1081.76, -1986.55, 29.89>>
|
|
BREAK
|
|
CASE EP_FIB_GROUND_FLOOR_FOOT_3
|
|
RETURN <<1076.95, -1978.37, 30.47>>
|
|
BREAK
|
|
CASE EP_FIB_GROUND_FLOOR_FOOT_4
|
|
RETURN <<1088.65, -1970.16, 30.01>>
|
|
BREAK
|
|
CASE EP_FIB_MID_FIGHTERS_BACK_1
|
|
CASE EP_FIB_MID_FIGHTERS_BACK_2
|
|
CASE EP_FIB_MID_FIGHTERS_BACK_3
|
|
CASE EP_FIB_MID_FIGHTERS_FRONT_1
|
|
CASE EP_FIB_MID_FIGHTERS_FRONT_2
|
|
CASE EP_FIB_MID_FIGHTERS_FRONT_3
|
|
RETURN <<1051.5612, -2006.8407, 30.0448>>
|
|
BREAK
|
|
DEFAULT
|
|
RETURN vDefensiveAreaCenter
|
|
BREAK
|
|
ENDSWITCH
|
|
|
|
RETURN <<0,0,0>>
|
|
ENDFUNC
|
|
|
|
// get secondary defensive area for enemy
|
|
FUNC VECTOR GET_ENEMY_PED_SECONDARY_DEFENSIVE_AREA(ENEMY_PED_ENUM pedEnum)
|
|
SWITCH pedEnum
|
|
// FIB CATWALK WAVE
|
|
CASE EP_MERC_CATWALK_FOOT_1
|
|
RETURN <<1086.04871, -2012.50891, 42.84379>>
|
|
BREAK
|
|
CASE EP_MERC_CATWALK_FOOT_2
|
|
RETURN <<1089.43311, -2014.86670, 42.84379>>
|
|
BREAK
|
|
ENDSWITCH
|
|
|
|
RETURN <<0,0,0>>
|
|
ENDFUNC
|
|
|
|
// get defensive radius for enemy
|
|
FUNC FLOAT GET_ENEMY_PED_DEFENSIVE_RADIUS(ENEMY_PED_ENUM pedEnum)
|
|
SWITCH pedEnum
|
|
CASE EP_MERC_CATWALK_FOOT_1
|
|
CASE EP_MERC_CATWALK_FOOT_2
|
|
RETURN 4.0
|
|
BREAK
|
|
|
|
CASE EP_MERC_TREVORCORNER_FOOT_1
|
|
CASE EP_MERC_TREVORCORNER_FOOT_2
|
|
CASE EP_MERC_TREVORCORNER_FOOT_3
|
|
RETURN 5.0
|
|
BREAK
|
|
|
|
CASE EP_FIB_LAMAR_BATTLE_1
|
|
CASE EP_FIB_LAMAR_BATTLE_2
|
|
CASE EP_FIB_LAMAR_BATTLE_3
|
|
CASE EP_FIB_LAMAR_BATTLE_4
|
|
CASE EP_FIB_LAMAR_BATTLE_5
|
|
CASE EP_FIB_LAMAR_BATTLE_REINF_1
|
|
CASE EP_FIB_LAMAR_BATTLE_REINF_2
|
|
CASE EP_FIB_LAMAR_BATTLE_REINF_3
|
|
CASE EP_FIB_LAMAR_BATTLE_REINF_4
|
|
CASE EP_FIB_LAMAR_BATTLE_REINF_5
|
|
CASE EP_FIB_LAMAR_BATTLE_INFINITE_1
|
|
CASE EP_FIB_LAMAR_BATTLE_INFINITE_2
|
|
CASE EP_FIB_ROAD_REINF_1_DRIVER
|
|
CASE EP_FIB_ROAD_REINF_1_PASSFR
|
|
CASE EP_FIB_ON_ROAD_FOOT_1
|
|
CASE EP_FIB_ON_ROAD_FOOT_2
|
|
CASE EP_FIB_ON_ROAD_FOOT_3
|
|
CASE EP_FIB_ON_ROAD_FOOT_4
|
|
RETURN 12.0
|
|
BREAK
|
|
|
|
CASE EP_FIB_ATTACK_TREVOR_GROUND_1
|
|
CASE EP_FIB_ATTACK_TREVOR_GROUND_2
|
|
CASE EP_FIB_ATTACK_TREVOR_GROUND_3
|
|
CASE EP_FIB_ATTACK_TREVOR_GROUND_4
|
|
CASE EP_FIB_ATTACK_TREVOR_GROUND_5
|
|
CASE EP_FIB_ATTACK_TREVOR_GROUND_6
|
|
CASE EP_FIB_ATTACK_TREVOR_GROUND_7
|
|
CASE EP_FIB_ATTACK_TREVOR_CATWALK_1
|
|
CASE EP_FIB_ATTACK_TREVOR_CATWALK_2
|
|
CASE EP_FIB_ATTACK_TREVOR_CLIMAX_1
|
|
CASE EP_FIB_ATTACK_TREVOR_CLIMAX_2
|
|
CASE EP_FIB_ATTACK_TREVOR_CLIMAX_3
|
|
CASE EP_FIB_ATTACK_TREVOR_CLIMAX_4
|
|
CASE EP_FIB_ATTACK_TREVOR_CLIMAX_5
|
|
CASE EP_FIB_ATTACK_TREVOR_CLIMAX_6
|
|
CASE EP_FIB_ATTACK_TREVOR_CLIMAX_7
|
|
RETURN 12.0
|
|
BREAK
|
|
|
|
CASE EP_FIB_BATTLE_OUTSIDE_FOOT_1
|
|
RETURN 5.0
|
|
BREAK
|
|
CASE EP_FIB_BATTLE_OUTSIDE_FOOT_2
|
|
RETURN 5.0
|
|
BREAK
|
|
CASE EP_FIB_BATTLE_OUTSIDE_FOOT_3
|
|
RETURN 3.0
|
|
BREAK
|
|
|
|
CASE EP_MERC_BATTLE_OUTSIDE_4WD_1_DRIVER
|
|
RETURN 8.0
|
|
BREAK
|
|
CASE EP_MERC_BATTLE_OUTSIDE_4WD_1_PASSFR
|
|
RETURN 8.0
|
|
BREAK
|
|
CASE EP_MERC_BATTLE_OUTSIDE_4WD_2_DRIVER
|
|
RETURN 8.0
|
|
BREAK
|
|
|
|
CASE EP_MERC_UP_ROAD_4WD_1_DRIVER
|
|
RETURN 4.0
|
|
BREAK
|
|
CASE EP_MERC_UP_ROAD_4WD_2_DRIVER
|
|
RETURN 2.9
|
|
BREAK
|
|
|
|
CASE EP_MERC_TRAIN_4WD_1_DRIVER
|
|
CASE EP_MERC_TRAIN_4WD_1_PASSFR
|
|
CASE EP_MERC_TRAIN_4WD_2_DRIVER
|
|
CASE EP_MERC_TRAIN_4WD_2_PASSFR
|
|
RETURN 20.0
|
|
BREAK
|
|
|
|
CASE EP_FIB_GROUND_FLOOR_FOOT_1
|
|
RETURN 2.0
|
|
BREAK
|
|
CASE EP_FIB_GROUND_FLOOR_FOOT_2
|
|
RETURN 2.0
|
|
BREAK
|
|
CASE EP_FIB_GROUND_FLOOR_FOOT_3
|
|
RETURN 1.6
|
|
BREAK
|
|
CASE EP_FIB_GROUND_FLOOR_FOOT_4
|
|
RETURN 1.0
|
|
BREAK
|
|
|
|
CASE EP_FIB_MID_FIGHTERS_BACK_1
|
|
CASE EP_FIB_MID_FIGHTERS_BACK_2
|
|
CASE EP_FIB_MID_FIGHTERS_BACK_3
|
|
CASE EP_FIB_MID_FIGHTERS_FRONT_1
|
|
CASE EP_FIB_MID_FIGHTERS_FRONT_2
|
|
CASE EP_FIB_MID_FIGHTERS_FRONT_3
|
|
RETURN 35.0
|
|
BREAK
|
|
DEFAULT
|
|
RETURN 15.0
|
|
BREAK
|
|
ENDSWITCH
|
|
|
|
RETURN 1.0
|
|
ENDFUNC
|
|
|
|
// get secondary defensive radius for enemy
|
|
FUNC FLOAT GET_ENEMY_PED_SECONDARY_DEFENSIVE_RADIUS(ENEMY_PED_ENUM pedEnum)
|
|
SWITCH pedEnum
|
|
CASE EP_MERC_CATWALK_FOOT_1
|
|
CASE EP_MERC_CATWALK_FOOT_2
|
|
BREAK
|
|
ENDSWITCH
|
|
|
|
RETURN 0.0
|
|
ENDFUNC
|
|
|
|
// create enemy ped
|
|
PROC CREATE_ENEMY_PED(ENEMY_PED_ENUM pedEnum, BOOL bBlip, ENEMY_FACTION_ENUM enemy_faction)
|
|
VECTOR vPos = <<0,0,0>>
|
|
FLOAT fRot = 0.0
|
|
ENEMY_VEHICLE_ENUM vehicleEnum
|
|
VEHICLE_SEAT seat = VS_ANY_PASSENGER
|
|
BOOL bOnlyDamagedByPlayer = FALSE
|
|
BOOL bForceWeapon = TRUE
|
|
BOOL bForceStationary = FALSE
|
|
BOOL bAggressive = FALSE
|
|
BOOL bDisableSecondaryTargets = FALSE
|
|
TEXT_LABEL_15 sName
|
|
|
|
INT iAccuracy = iDefaultAccuracy
|
|
|
|
WEAPON_TYPE weapon
|
|
MODEL_NAMES model
|
|
|
|
SWITCH pedEnum
|
|
// FIB ENTER WAVE INSIDE
|
|
CASE EP_FIB_SEARCH_FOOT_1
|
|
sName = "FIBSEARCH1"
|
|
vPos = <<1086.3148, -1994.9814, 29.9393>>
|
|
fRot = 319.5
|
|
bDisableSecondaryTargets = TRUE
|
|
BREAK
|
|
CASE EP_FIB_SEARCH_FOOT_2
|
|
sName = "FIBSEARCH2"
|
|
vPos = <<1084.5778, -1996.1300, 29.8739>>
|
|
fRot = 305.3
|
|
bDisableSecondaryTargets = TRUE
|
|
BREAK
|
|
CASE EP_FIB_SEARCH_FOOT_3
|
|
sName = "FIBSEARCH3"
|
|
vPos = <<1085.8164, -1997.0804, 29.8740>>
|
|
fRot = 238.0
|
|
bDisableSecondaryTargets = TRUE
|
|
BREAK
|
|
CASE EP_FIB_SEARCH_FOOT_4
|
|
sName = "FIBSEARCH4"
|
|
vPos = <<1084.4714, -1998.5194, 29.8787>>
|
|
fRot = 234.7
|
|
bDisableSecondaryTargets = TRUE
|
|
BREAK
|
|
CASE EP_FIB_SEARCH_FOOT_5
|
|
sName = "FIBSEARCH5"
|
|
vPos = <<1069.4227, -2006.4746, 31.0831>>
|
|
fRot = 267.4
|
|
bDisableSecondaryTargets = TRUE
|
|
BREAK
|
|
CASE EP_FIB_SEARCH_FOOT_6
|
|
sName = "FIBSEARCH6"
|
|
vPos = <<1068.1992, -2006.3955, 31.0826>>
|
|
fRot = 267.4
|
|
bDisableSecondaryTargets = TRUE
|
|
BREAK
|
|
CASE EP_FIB_SEARCH_FOOT_7
|
|
sName = "FIBSEARCH7"
|
|
vPos = <<1066.9611, -2006.0806, 31.0821>>
|
|
fRot = 267.4
|
|
bDisableSecondaryTargets = TRUE
|
|
BREAK
|
|
|
|
// FIB CATWALK WAVE
|
|
CASE EP_MERC_CATWALK_FOOT_1
|
|
sName = "FIBCWALK1"
|
|
vPos = <<1078.9418, -2012.5966, 42.9080>>
|
|
fRot = -25.2
|
|
bAggressive = TRUE
|
|
iAccuracy = iLowAccuracy
|
|
BREAK
|
|
CASE EP_MERC_CATWALK_FOOT_2
|
|
sName = "FIBCWALK2"
|
|
vPos = <<1078.1412, -2014.3105, 42.9080>>
|
|
fRot = -25.2
|
|
bAggressive = TRUE
|
|
iAccuracy = iLowAccuracy
|
|
BREAK
|
|
|
|
// FIB TREVORCORNER WAVE
|
|
CASE EP_MERC_TREVORCORNER_FOOT_1
|
|
sName = "FIBTCORN1"
|
|
vPos = <<1068.0996, -2004.3345, 31.0820>>
|
|
fRot = 154
|
|
bAggressive = TRUE
|
|
bDisableSecondaryTargets = TRUE
|
|
BREAK
|
|
|
|
CASE EP_MERC_TREVORCORNER_FOOT_2
|
|
sName = "FIBTCORN2"
|
|
vPos = <<1067.8547, -2004.9292, 31.0821>>
|
|
fRot = 167
|
|
bAggressive = TRUE
|
|
bDisableSecondaryTargets = TRUE
|
|
BREAK
|
|
|
|
CASE EP_MERC_TREVORCORNER_FOOT_3
|
|
sName = "FIBTCORN3"
|
|
vPos = <<1067.9473, -2005.7913, 31.0824>>
|
|
fRot = 223
|
|
bAggressive = TRUE
|
|
bDisableSecondaryTargets = TRUE
|
|
BREAK
|
|
|
|
CASE EP_FIB_ATTACK_TREVOR_GROUND_1
|
|
sName = "ATTTREVGRND1"
|
|
vPos = <<1103.0809, -1994.9175, 29.9095>>
|
|
fRot = 177
|
|
bAggressive = TRUE
|
|
iAccuracy = iLowAccuracy
|
|
bDisableSecondaryTargets = TRUE
|
|
BREAK
|
|
|
|
CASE EP_FIB_ATTACK_TREVOR_GROUND_2
|
|
sName = "ATTTREVGRND2"
|
|
vPos = <<1092.3278, -2002.9709, 30.0713>>
|
|
fRot = 275
|
|
bAggressive = TRUE
|
|
iAccuracy = iLowAccuracy
|
|
bDisableSecondaryTargets = TRUE
|
|
BREAK
|
|
|
|
CASE EP_FIB_ATTACK_TREVOR_GROUND_3
|
|
sName = "ATTTREVGRND3"
|
|
vPos = <<1085.3970, -1992.8695, 28.3932>>
|
|
fRot = 295
|
|
bAggressive = TRUE
|
|
iAccuracy = iLowAccuracy
|
|
bDisableSecondaryTargets = TRUE
|
|
BREAK
|
|
|
|
CASE EP_FIB_ATTACK_TREVOR_GROUND_4
|
|
sName = "ATTTREVGRND4"
|
|
vPos = <<1079.1241, -1994.1174, 29.9986>>
|
|
fRot = 229
|
|
bAggressive = TRUE
|
|
iAccuracy = iLowAccuracy
|
|
bDisableSecondaryTargets = TRUE
|
|
BREAK
|
|
|
|
CASE EP_FIB_ATTACK_TREVOR_GROUND_5
|
|
sName = "ATTTREVGRND5"
|
|
vPos = <<1067.0514, -2006.1910, 31.0820>>
|
|
fRot = 250
|
|
bAggressive = TRUE
|
|
iAccuracy = iLowAccuracy
|
|
bDisableSecondaryTargets = TRUE
|
|
BREAK
|
|
|
|
CASE EP_FIB_ATTACK_TREVOR_GROUND_6
|
|
sName = "ATTTREVGRND6"
|
|
vPos = <<1068.0511, -2006.2424, 31.0825>>
|
|
fRot = 254
|
|
bAggressive = TRUE
|
|
iAccuracy = iLowAccuracy
|
|
bDisableSecondaryTargets = TRUE
|
|
BREAK
|
|
|
|
CASE EP_FIB_ATTACK_TREVOR_GROUND_7
|
|
sName = "ATTTREVGRND7"
|
|
vPos = <<1070.1852, -2006.2993, 31.0835>>
|
|
fRot = 255
|
|
bAggressive = TRUE
|
|
iAccuracy = iLowAccuracy
|
|
bDisableSecondaryTargets = TRUE
|
|
BREAK
|
|
|
|
CASE EP_FIB_ATTACK_TREVOR_CATWALK_1
|
|
sName = "ATTTREVCAT1"
|
|
vPos = <<1085.7471, -2013.8279, 42.8439>>
|
|
fRot = 261
|
|
bAggressive = TRUE
|
|
iAccuracy = iLowAccuracy
|
|
BREAK
|
|
|
|
CASE EP_FIB_ATTACK_TREVOR_CATWALK_2
|
|
sName = "ATTTREVCAT2"
|
|
vPos = <<1088.2765, -2014.0953, 42.8439>>
|
|
fRot = 241
|
|
bAggressive = TRUE
|
|
iAccuracy = iLowAccuracy
|
|
BREAK
|
|
|
|
CASE EP_FIB_ATTACK_TREVOR_CLIMAX_1
|
|
sName = "ATTTREVFIN1"
|
|
vPos = <<1072.7076, -2007.1271, 31.0845>>
|
|
fRot = 178
|
|
bAggressive = TRUE
|
|
iAccuracy = iLowAccuracy
|
|
BREAK
|
|
CASE EP_FIB_ATTACK_TREVOR_CLIMAX_2
|
|
sName = "ATTTREVFIN2"
|
|
vPos = <<1071.8170, -2006.7574, 31.0841>>
|
|
fRot = 227
|
|
bAggressive = TRUE
|
|
iAccuracy = iLowAccuracy
|
|
BREAK
|
|
CASE EP_FIB_ATTACK_TREVOR_CLIMAX_3
|
|
sName = "ATTTREVFIN3"
|
|
vPos = <<1070.6676, -2006.4200, 31.0837>>
|
|
fRot = 276
|
|
bAggressive = TRUE
|
|
iAccuracy = iLowAccuracy
|
|
BREAK
|
|
CASE EP_FIB_ATTACK_TREVOR_CLIMAX_4
|
|
sName = "ATTTREVFIN4"
|
|
vPos = <<1069.4238, -2006.0084, 31.0831>>
|
|
fRot = 255
|
|
bAggressive = TRUE
|
|
iAccuracy = iLowAccuracy
|
|
BREAK
|
|
CASE EP_FIB_ATTACK_TREVOR_CLIMAX_5
|
|
sName = "ATTTREVFIN5"
|
|
vPos = <<1072.7076, -2007.1271, 31.0845>>
|
|
fRot = 11
|
|
bAggressive = TRUE
|
|
iAccuracy = iLowAccuracy
|
|
BREAK
|
|
CASE EP_FIB_ATTACK_TREVOR_CLIMAX_6
|
|
sName = "ATTTREVFIN6"
|
|
vPos = <<1071.8170, -2006.7574, 31.0841>>
|
|
fRot = 328
|
|
bAggressive = TRUE
|
|
iAccuracy = iLowAccuracy
|
|
BREAK
|
|
CASE EP_FIB_ATTACK_TREVOR_CLIMAX_7
|
|
sName = "ATTTREVFIN7"
|
|
vPos = <<1070.6676, -2006.4200, 31.0837>>
|
|
fRot = 290
|
|
bAggressive = TRUE
|
|
iAccuracy = iLowAccuracy
|
|
BREAK
|
|
|
|
// FIB REINFORCEMENT WAVE
|
|
CASE EP_FIB_REINFORCEMENT_FOOT_1
|
|
sName = "FIBREINF1"
|
|
vPos = <<1078.5896, -1973.5990, 30.4713>>
|
|
fRot = 66
|
|
bAggressive = TRUE
|
|
BREAK
|
|
|
|
CASE EP_FIB_REINFORCEMENT_FOOT_2
|
|
sName = "FIBREINF2"
|
|
vPos = <<1079.7064, -1973.8478, 30.4709>>
|
|
fRot = 16
|
|
bAggressive = TRUE
|
|
BREAK
|
|
|
|
CASE EP_FIB_REINFORCEMENT_FOOT_3
|
|
sName = "FIBREINF3"
|
|
vPos = <<1080.5520, -1974.3707, 30.4714>>
|
|
fRot = 60
|
|
bAggressive = TRUE
|
|
BREAK
|
|
|
|
// FIB ENTER WAVE OUTSIDE
|
|
// open left of railcars
|
|
CASE EP_FIB_BATTLE_OUTSIDE_FOOT_1
|
|
sName = "FIBOUTSIDE1"
|
|
vPos = <<1078.3196, -2053.4507, 30.0390>>
|
|
fRot = 283
|
|
bOnlyDamagedByPlayer = TRUE
|
|
BREAK
|
|
// in railcar
|
|
CASE EP_FIB_BATTLE_OUTSIDE_FOOT_2
|
|
sName = "FIBOUTSIDE2"
|
|
vPos = <<1082.5980, -2058.6497, 30.0261>>
|
|
fRot = 61
|
|
bOnlyDamagedByPlayer = TRUE
|
|
BREAK
|
|
// open on railcars
|
|
CASE EP_FIB_BATTLE_OUTSIDE_FOOT_3
|
|
sName = "FIBOUTSIDE3"
|
|
vPos = <<1076.8340, -2043.0873, 30.0390>>
|
|
fRot = -117.1
|
|
bOnlyDamagedByPlayer = TRUE
|
|
BREAK
|
|
|
|
// MERC INSIDE WAVE
|
|
CASE EP_MERC_INSIDE_FOOT_1
|
|
sName = "MERCINSIDE1"
|
|
bForceWeapon = FALSE
|
|
vPos = <<1071.6923, -2006.6581, 31.0841>>
|
|
fRot = 341.0
|
|
BREAK
|
|
CASE EP_MERC_INSIDE_FOOT_2
|
|
sName = "MERCINSIDE2"
|
|
bForceWeapon = FALSE
|
|
vPos = <<1070.9485, -2006.0835, 31.0837>>
|
|
fRot = 153.0
|
|
BREAK
|
|
CASE EP_MERC_INSIDE_FOOT_3
|
|
sName = "MERCINSIDE3"
|
|
bForceWeapon = FALSE
|
|
vPos = <<1069.9236, -2005.7213, 31.0832>>
|
|
fRot = 246.0
|
|
BREAK
|
|
|
|
CASE EP_FIB_LAMAR_INSIDE_1
|
|
sName = "FIBLAMIN1"
|
|
bForceWeapon = FALSE
|
|
vPos = <<1071.8170, -2006.7574, 31.0841>>
|
|
fRot = 285
|
|
BREAK
|
|
CASE EP_FIB_LAMAR_INSIDE_2
|
|
sName = "FIBLAMIN2"
|
|
bForceWeapon = FALSE
|
|
vPos = <<1070.6676, -2006.4200, 31.0837>>
|
|
fRot = 285
|
|
BREAK
|
|
|
|
CASE EP_FIB_LAMAR_INSIDE_REINF_1
|
|
sName = "FIBLAMINRE1"
|
|
bForceWeapon = FALSE
|
|
vPos = <<1068.5797, -2005.0900, 31.0825>>
|
|
fRot = 285
|
|
BREAK
|
|
CASE EP_FIB_LAMAR_INSIDE_REINF_2
|
|
sName = "FIBLAMINRE2"
|
|
bForceWeapon = FALSE
|
|
vPos = <<1069.0621, -2005.9562, 31.0829>>
|
|
fRot = 243
|
|
BREAK
|
|
|
|
CASE EP_FIB_LAMAR_BATTLE_1
|
|
sName = "FIBLAM1"
|
|
vPos = <<1057.4979, -1948.5887, 35.3253>>
|
|
fRot = 176.0
|
|
bOnlyDamagedByPlayer = TRUE
|
|
iAccuracy = iLowAccuracy
|
|
bForceStationary = TRUE
|
|
BREAK
|
|
|
|
CASE EP_FIB_LAMAR_BATTLE_2
|
|
sName = "FIBLAM2"
|
|
vPos = <<1069.2128, -1964.6361, 30.0444>>
|
|
fRot = 163.6
|
|
bOnlyDamagedByPlayer = TRUE
|
|
iAccuracy = iLowAccuracy
|
|
BREAK
|
|
|
|
CASE EP_FIB_LAMAR_BATTLE_3
|
|
sName = "FIBLAM3"
|
|
vPos = <<1069.8390, -1960.5525, 30.0444>>
|
|
fRot = 200.5
|
|
bOnlyDamagedByPlayer = TRUE
|
|
iAccuracy = iLowAccuracy
|
|
BREAK
|
|
|
|
CASE EP_FIB_LAMAR_BATTLE_4
|
|
sName = "FIBLAM4"
|
|
vPos = <<1054.7507, -1964.7998, 30.0444>>
|
|
fRot = 230.5
|
|
bOnlyDamagedByPlayer = TRUE
|
|
iAccuracy = iLowAccuracy
|
|
BREAK
|
|
|
|
CASE EP_FIB_LAMAR_BATTLE_5
|
|
sName = "FIBLAM5"
|
|
vPos = <<1045.9607, -1957.5865, 34.1391>>
|
|
fRot = 280.0
|
|
bOnlyDamagedByPlayer = TRUE
|
|
iAccuracy = iLowAccuracy
|
|
bForceStationary = TRUE
|
|
BREAK
|
|
|
|
// next wave
|
|
CASE EP_FIB_LAMAR_BATTLE_REINF_1
|
|
sName = "FIBLAMRE1"
|
|
vPos = <<1032.4911, -1942.9932, 30.0443>>
|
|
fRot = 248
|
|
bOnlyDamagedByPlayer = TRUE
|
|
iAccuracy = iLowAccuracy
|
|
BREAK
|
|
|
|
CASE EP_FIB_LAMAR_BATTLE_REINF_2
|
|
sName = "FIBLAMRE2"
|
|
vPos = <<1033.4302, -1944.8301, 30.0443>>
|
|
fRot = 248
|
|
bOnlyDamagedByPlayer = TRUE
|
|
iAccuracy = iLowAccuracy
|
|
BREAK
|
|
|
|
CASE EP_FIB_LAMAR_BATTLE_REINF_3
|
|
sName = "FIBLAMRE3"
|
|
vPos = <<1031.8977, -1946.8385, 30.0443>>
|
|
fRot = 248
|
|
bOnlyDamagedByPlayer = TRUE
|
|
iAccuracy = iLowAccuracy
|
|
BREAK
|
|
|
|
CASE EP_FIB_LAMAR_BATTLE_REINF_4
|
|
sName = "FIBLAMRE4"
|
|
vPos = <<1054.2367, -1902.3300, 30.0443>>
|
|
fRot = 170
|
|
bOnlyDamagedByPlayer = TRUE
|
|
iAccuracy = iLowAccuracy
|
|
BREAK
|
|
|
|
CASE EP_FIB_LAMAR_BATTLE_REINF_5
|
|
sName = "FIBLAMRE5"
|
|
vPos = <<1055.9896, -1902.0062, 30.0443>>
|
|
fRot = 270
|
|
bOnlyDamagedByPlayer = TRUE
|
|
iAccuracy = iLowAccuracy
|
|
BREAK
|
|
|
|
CASE EP_FIB_LAMAR_BATTLE_INFINITE_1
|
|
sName = "FIBLAMINF1"
|
|
vPos = <<1025.4098, -1950.7577, 30.0492>>
|
|
fRot = 290
|
|
bOnlyDamagedByPlayer = TRUE
|
|
iAccuracy = iLowAccuracy
|
|
BREAK
|
|
|
|
CASE EP_FIB_LAMAR_BATTLE_INFINITE_2
|
|
sName = "FIBLAMINF2"
|
|
vPos = <<1027.3417, -1951.7936, 30.0401>>
|
|
fRot = 255
|
|
bOnlyDamagedByPlayer = TRUE
|
|
iAccuracy = iLowAccuracy
|
|
BREAK
|
|
|
|
// HELICOPTER GROUP
|
|
CASE EP_MERC_BATTLE_OUTSIDE_CHOPPER_1_PILOT
|
|
sName = "CHOPPER1A"
|
|
vehicleEnum = EV_MERC_BATTLE_OUTSIDE_CHOPPER_1
|
|
seat = VS_DRIVER
|
|
BREAK
|
|
CASE EP_MERC_BATTLE_OUTSIDE_CHOPPER_1_PASSBR
|
|
sName = "CHOPPER1C"
|
|
vehicleEnum = EV_MERC_BATTLE_OUTSIDE_CHOPPER_1
|
|
seat = VS_BACK_RIGHT
|
|
BREAK
|
|
|
|
// MERC OUTSIDE
|
|
CASE EP_MERC_BATTLE_OUTSIDE_4WD_1_DRIVER
|
|
sName = "MERC4WD1DRV"
|
|
vehicleEnum = EV_MERC_BATTLE_OUTSIDE_4WD_1
|
|
seat = VS_DRIVER
|
|
bOnlyDamagedByPlayer = TRUE
|
|
iAccuracy = iLowAccuracy
|
|
BREAK
|
|
CASE EP_MERC_BATTLE_OUTSIDE_4WD_1_PASSFR
|
|
sName = "MERC4WD1PFR"
|
|
vehicleEnum = EV_MERC_BATTLE_OUTSIDE_4WD_1
|
|
seat = VS_FRONT_RIGHT
|
|
bOnlyDamagedByPlayer = TRUE
|
|
iAccuracy = iLowAccuracy
|
|
BREAK
|
|
|
|
CASE EP_MERC_BATTLE_OUTSIDE_4WD_2_DRIVER
|
|
sName = "MERC4WD2DRV"
|
|
vehicleEnum = EV_MERC_BATTLE_OUTSIDE_4WD_2
|
|
seat = VS_DRIVER
|
|
bOnlyDamagedByPlayer = TRUE
|
|
iAccuracy = iLowAccuracy
|
|
BREAK
|
|
|
|
// FIB GROUND FLOOR
|
|
CASE EP_FIB_GROUND_FLOOR_FOOT_1
|
|
sName = "FIBGROUND1"
|
|
vPos = <<1079.72, -1989.04, 30.30>>
|
|
fRot = -121.5
|
|
bOnlyDamagedByPlayer = TRUE
|
|
iAccuracy = iLowAccuracy
|
|
BREAK
|
|
CASE EP_FIB_GROUND_FLOOR_FOOT_2
|
|
sName = "FIBGROUND2"
|
|
vPos = <<1081.65, -1986.19, 29.96>>
|
|
fRot = -133.1
|
|
bOnlyDamagedByPlayer = TRUE
|
|
iAccuracy = iLowAccuracy
|
|
BREAK
|
|
CASE EP_FIB_GROUND_FLOOR_FOOT_3
|
|
sName = "FIBGROUND3"
|
|
vPos = <<1076.30, -1975.96, 30.47>>
|
|
fRot = -145.1
|
|
bOnlyDamagedByPlayer = TRUE
|
|
iAccuracy = iLowAccuracy
|
|
BREAK
|
|
CASE EP_FIB_GROUND_FLOOR_FOOT_4
|
|
sName = "FIBGROUND4"
|
|
vPos = <<1088.65, -1970.16, 30.01>>
|
|
fRot = 57.7
|
|
bOnlyDamagedByPlayer = TRUE
|
|
iAccuracy = iLowAccuracy
|
|
BREAK
|
|
|
|
// FIB ON ROAD
|
|
CASE EP_FIB_ON_ROAD_FOOT_1
|
|
sName = "FIBROAD1"
|
|
vPos = <<1069.2128, -1964.6361, 30.0444>>
|
|
fRot = 160
|
|
bOnlyDamagedByPlayer = TRUE
|
|
iAccuracy = iLowAccuracy
|
|
BREAK
|
|
CASE EP_FIB_ON_ROAD_FOOT_2
|
|
sName = "FIBROAD2"
|
|
vPos = <<1069.8390, -1960.5525, 30.0444>>
|
|
fRot = 200
|
|
bOnlyDamagedByPlayer = TRUE
|
|
iAccuracy = iLowAccuracy
|
|
BREAK
|
|
CASE EP_FIB_ON_ROAD_FOOT_3
|
|
sName = "FIBROAD3"
|
|
vPos = <<1054.7507, -1964.7998, 30.0444>>
|
|
fRot = 230
|
|
bOnlyDamagedByPlayer = TRUE
|
|
iAccuracy = iLowAccuracy
|
|
BREAK
|
|
CASE EP_FIB_ON_ROAD_FOOT_4
|
|
sName = "FIBROAD4"
|
|
vPos = <<1057.3029, -1940.4484, 35.3253>>
|
|
fRot = 180
|
|
bOnlyDamagedByPlayer = TRUE
|
|
iAccuracy = iLowAccuracy
|
|
BREAK
|
|
|
|
// MERCS UP ROAD
|
|
CASE EP_MERC_UP_ROAD_4WD_1_DRIVER
|
|
sName = "MERC4UR1DRV"
|
|
vehicleEnum = EV_MERC_UP_ROAD_4WD_1
|
|
seat = VS_DRIVER
|
|
bOnlyDamagedByPlayer = TRUE
|
|
iAccuracy = iLowAccuracy
|
|
BREAK
|
|
CASE EP_MERC_UP_ROAD_4WD_2_DRIVER
|
|
sName = "MERC4UR2DRV"
|
|
vehicleEnum = EV_MERC_UP_ROAD_4WD_2
|
|
seat = VS_DRIVER
|
|
bOnlyDamagedByPlayer = TRUE
|
|
iAccuracy = iLowAccuracy
|
|
BREAK
|
|
|
|
CASE EP_MERC_TRAIN_4WD_1_DRIVER
|
|
sName = "MERC4TR1DRV"
|
|
vehicleEnum = EV_MERC_TRAIN_4WD_1
|
|
seat = VS_DRIVER
|
|
iAccuracy = iLowAccuracy
|
|
BREAK
|
|
CASE EP_MERC_TRAIN_4WD_1_PASSFR
|
|
sName = "MERC4TR1PFR"
|
|
vehicleEnum = EV_MERC_TRAIN_4WD_1
|
|
seat = VS_FRONT_RIGHT
|
|
iAccuracy = iLowAccuracy
|
|
BREAK
|
|
CASE EP_MERC_TRAIN_4WD_2_DRIVER
|
|
sName = "MERC4TR2DRV"
|
|
vehicleEnum = EV_MERC_TRAIN_4WD_2
|
|
seat = VS_DRIVER
|
|
iAccuracy = iLowAccuracy
|
|
BREAK
|
|
CASE EP_MERC_TRAIN_4WD_2_PASSFR
|
|
sName = "MERC4TR2PFR"
|
|
vehicleEnum = EV_MERC_TRAIN_4WD_2
|
|
seat = VS_FRONT_RIGHT
|
|
iAccuracy = iLowAccuracy
|
|
BREAK
|
|
|
|
CASE EP_FIB_ROAD_REINF_1_DRIVER
|
|
sName = "FIBRRE1DRV"
|
|
vehicleEnum = EV_FIB_ROAD_REINF_1
|
|
seat = VS_DRIVER
|
|
iAccuracy = iLowAccuracy
|
|
BREAK
|
|
CASE EP_FIB_ROAD_REINF_1_PASSFR
|
|
sName = "FIBRRE1PFR"
|
|
vehicleEnum = EV_FIB_ROAD_REINF_1
|
|
seat = VS_FRONT_RIGHT
|
|
iAccuracy = iLowAccuracy
|
|
BREAK
|
|
|
|
CASE EP_FIB_MID_FIGHTERS_BACK_1
|
|
sName = "MERCMIDB1"
|
|
vPos = <<1086.5555, -2024.4998, 30.0393>>
|
|
fRot = 58
|
|
iAccuracy = iLowAccuracy
|
|
BREAK
|
|
CASE EP_FIB_MID_FIGHTERS_BACK_2
|
|
sName = "MERCMIDB2"
|
|
vPos = <<1081.7366, -2021.6091, 30.0393>>
|
|
fRot = 58
|
|
iAccuracy = iLowAccuracy
|
|
BREAK
|
|
CASE EP_FIB_MID_FIGHTERS_BACK_3
|
|
sName = "MERCMIDB3"
|
|
vPos = <<1075.8063, -2017.9146, 30.0393>>
|
|
fRot = 58
|
|
iAccuracy = iLowAccuracy
|
|
BREAK
|
|
CASE EP_FIB_MID_FIGHTERS_FRONT_1
|
|
sName = "FIBMIDF1"
|
|
vPos = <<1031.8342, -1939.3159, 30.0443>>
|
|
fRot = 90
|
|
iAccuracy = iLowAccuracy
|
|
BREAK
|
|
CASE EP_FIB_MID_FIGHTERS_FRONT_2
|
|
sName = "FIBMIDF2"
|
|
vPos = <<1031.4766, -1940.9905, 30.0443>>
|
|
fRot = 90
|
|
iAccuracy = iLowAccuracy
|
|
BREAK
|
|
CASE EP_FIB_MID_FIGHTERS_FRONT_3
|
|
sName = "FIBMIDF3"
|
|
vPos = <<1030.9567, -1943.4086, 30.0443>>
|
|
fRot = 90
|
|
iAccuracy = iLowAccuracy
|
|
BREAK
|
|
ENDSWITCH
|
|
|
|
SWITCH enemy_faction
|
|
CASE ENEMY_FACTION_FIB
|
|
model = GET_MODEL_FOR_FINALE_MODEL_ENUM(FM_FIB)
|
|
weapon = GET_FINALE_WEAPON_TYPE(F_WEAPON_FIB_RIFLE)
|
|
BREAK
|
|
CASE ENEMY_FACTION_MERC
|
|
//IF NOT bIsBallistic
|
|
model = GET_MODEL_FOR_FINALE_MODEL_ENUM(FM_MERC)
|
|
weapon = GET_FINALE_WEAPON_TYPE(F_WEAPON_MERC_RIFLE)
|
|
//ELSE
|
|
// model = GET_MODEL_FOR_FINALE_MODEL_ENUM(FM_BALLISTIC)
|
|
// weapon = GET_FINALE_WEAPON_TYPE(F_WEAPON_LMG)
|
|
//ENDIF
|
|
BREAK
|
|
ENDSWITCH
|
|
|
|
enemyPed[pedEnum].bBlockTask = FALSE
|
|
|
|
IF seat <> VS_ANY_PASSENGER
|
|
IF IS_ENTITY_OK(enemyVehicle[vehicleEnum].veh)
|
|
enemyPed[pedEnum].ped = CREATE_PED_INSIDE_VEHICLE(enemyVehicle[vehicleEnum].veh, PEDTYPE_MISSION, model, seat)
|
|
ENDIF
|
|
ELSE
|
|
enemyPed[pedEnum].ped = CREATE_PED(PEDTYPE_MISSION, model, vPos, fRot)
|
|
IF bBlip
|
|
//enemyPed[pedEnum].blip = CREATE_MISSION_BLIP_FOR_PED(enemyPed[pedEnum].ped, TRUE)
|
|
ENDIF
|
|
ENDIF
|
|
|
|
enemyPed[pedEnum].bAlive = TRUE
|
|
|
|
GIVE_WEAPON_TO_PED(enemyPed[pedEnum].ped, weapon, INFINITE_AMMO)
|
|
|
|
IF enemy_faction = ENEMY_FACTION_FIB
|
|
INT iNewArmor = FLOOR(GET_PED_ARMOUR(enemyPed[pedEnum].ped)*0.4)
|
|
CPRINTLN(DEBUG_MISSION, "Reducing a peds armor. Old value: ", GET_PED_ARMOUR(enemyPed[pedEnum].ped), ". New value: ", iNewArmor)
|
|
SET_PED_ARMOUR(enemyPed[pedEnum].ped, iNewArmor)
|
|
ENDIF
|
|
|
|
IF bForceWeapon
|
|
SET_CURRENT_PED_WEAPON(enemyPed[pedEnum].ped, weapon, TRUE)
|
|
ENDIF
|
|
|
|
IF bAggressive
|
|
SET_PED_COMBAT_ATTRIBUTES(enemyPed[pedEnum].ped, CA_MAINTAIN_MIN_DISTANCE_TO_TARGET, TRUE)
|
|
ENDIF
|
|
|
|
SET_PED_COMBAT_ATTRIBUTES(enemyPed[pedEnum].ped, CA_USE_VEHICLE, FALSE)
|
|
|
|
IF bDisableSecondaryTargets
|
|
SET_PED_COMBAT_ATTRIBUTES(enemyPed[pedEnum].ped, CA_DISABLE_SECONDARY_TARGET, TRUE)
|
|
ENDIF
|
|
|
|
sName += "_"
|
|
sName += ENUM_TO_INT(pedEnum)
|
|
|
|
SET_PED_NAME_DEBUG(enemyPed[pedEnum].ped, sName)
|
|
|
|
IF bForceStationary
|
|
SET_PED_COMBAT_MOVEMENT(enemyPed[pedEnum].ped, CM_STATIONARY)
|
|
ENDIF
|
|
|
|
|
|
SET_PED_ACCURACY(enemyPed[pedEnum].ped, iAccuracy)
|
|
SET_BLOCKING_OF_NON_TEMPORARY_EVENTS(enemyPed[pedEnum].ped, TRUE)
|
|
SET_ENTITY_ONLY_DAMAGED_BY_PLAYER(enemyPed[pedEnum].ped, bOnlyDamagedByPlayer)
|
|
SET_PED_KEEP_TASK(enemyPed[pedEnum].ped, TRUE)
|
|
SET_PED_DIES_WHEN_INJURED(enemyPed[pedEnum].ped, TRUE)
|
|
SET_PED_CONFIG_FLAG(enemyPed[pedEnum].ped, PCF_DisableHurt, TRUE)
|
|
SET_PED_CONFIG_FLAG(enemyPed[pedEnum].ped, PCF_CanAttackNonWantedPlayerAsLaw, TRUE)
|
|
|
|
SET_PED_HAS_AI_BLIP(enemyPed[pedEnum].ped, TRUE)
|
|
SET_PED_AI_BLIP_FORCED_ON(enemyPed[pedEnum].ped, TRUE)
|
|
SET_PED_AI_BLIP_HAS_CONE(enemyPed[pedEnum].ped, FALSE)
|
|
|
|
SET_ENTITY_IS_TARGET_PRIORITY(enemyPed[pedEnum].ped, TRUE)
|
|
INFORM_MISSION_STATS_OF_HEADSHOT_WATCH_ENTITY(enemyPed[pedEnum].ped)
|
|
|
|
enemyPed[pedEnum].enemyTaskStatus = ENEMY_TASK_STATUS_NO_TASK
|
|
enemyPed[pedEnum].bRegisteredDead = FALSE
|
|
|
|
|
|
SWITCH enemy_faction
|
|
CASE ENEMY_FACTION_FIB
|
|
SET_PED_RELATIONSHIP_GROUP_HASH(enemyPed[pedEnum].ped, fibRelGroup)
|
|
SET_ENTITY_CAN_BE_DAMAGED_BY_RELATIONSHIP_GROUP(enemyPed[pedEnum].ped, FALSE, fibRelGroup)
|
|
BREAK
|
|
CASE ENEMY_FACTION_MERC
|
|
SET_PED_RELATIONSHIP_GROUP_HASH(enemyPed[pedEnum].ped, mercRelGroup)
|
|
SET_ENTITY_CAN_BE_DAMAGED_BY_RELATIONSHIP_GROUP(enemyPed[pedEnum].ped, FALSE, mercRelGroup)
|
|
BREAK
|
|
ENDSWITCH
|
|
|
|
|
|
SET_ENEMY_VARIATIONS(pedEnum)
|
|
ENDPROC
|
|
|
|
// fill wave properties
|
|
PROC FILL_ENEMY_WAVE_PROPERTIES(ENEMY_WAVE_ENUM waveEnum, ENEMY_VEHICLE_ENUM &firstVehicle, ENEMY_VEHICLE_ENUM &lastVehicle, ENEMY_PED_ENUM &firstPed, ENEMY_PED_ENUM &lastPed, BOOL &bHasVehicles, ENEMY_FACTION_ENUM &enemy_faction)
|
|
SWITCH waveEnum
|
|
// STAGE 1
|
|
CASE EW_FIB_SEARCH
|
|
firstPed = EP_FIB_SEARCH_FOOT_1
|
|
lastPed = EP_FIB_SEARCH_FOOT_7
|
|
bHasVehicles = FALSE
|
|
enemy_faction = ENEMY_FACTION_FIB
|
|
BREAK
|
|
CASE EW_MERC_CATWALK
|
|
firstPed = EP_MERC_CATWALK_FOOT_1
|
|
lastPed = EP_MERC_CATWALK_FOOT_2
|
|
bHasVehicles = FALSE
|
|
enemy_faction = ENEMY_FACTION_MERC
|
|
BREAK
|
|
CASE EW_MERC_TREVORCORNER
|
|
firstPed = EP_MERC_TREVORCORNER_FOOT_1
|
|
lastPed = EP_MERC_TREVORCORNER_FOOT_3
|
|
bHasVehicles = FALSE
|
|
enemy_faction = ENEMY_FACTION_MERC
|
|
BREAK
|
|
CASE EW_FIB_REINFORCEMENTS
|
|
firstPed = EP_FIB_REINFORCEMENT_FOOT_1
|
|
lastPed = EP_FIB_REINFORCEMENT_FOOT_3
|
|
bHasVehicles = FALSE
|
|
enemy_faction = ENEMY_FACTION_FIB
|
|
BREAK
|
|
CASE EW_MERC_INSIDE
|
|
firstPed = EP_MERC_INSIDE_FOOT_1
|
|
lastPed = EP_MERC_INSIDE_FOOT_3
|
|
bHasVehicles = FALSE
|
|
enemy_faction = ENEMY_FACTION_MERC
|
|
BREAK
|
|
CASE EW_FIB_ATTACK_TREVOR_GROUND
|
|
firstPed = EP_FIB_ATTACK_TREVOR_GROUND_1
|
|
lastPed = EP_FIB_ATTACK_TREVOR_GROUND_4
|
|
bHasVehicles = FALSE
|
|
enemy_faction = ENEMY_FACTION_FIB
|
|
BREAK
|
|
CASE EW_FIB_ATTACK_TREVOR_GROUND_REINF
|
|
firstPed = EP_FIB_ATTACK_TREVOR_GROUND_5
|
|
lastPed = EP_FIB_ATTACK_TREVOR_GROUND_7
|
|
bHasVehicles = FALSE
|
|
enemy_faction = ENEMY_FACTION_FIB
|
|
BREAK
|
|
CASE EW_FIB_ATTACK_TREVOR_CATWALK
|
|
firstPed = EP_FIB_ATTACK_TREVOR_CATWALK_1
|
|
lastPed = EP_FIB_ATTACK_TREVOR_CATWALK_2
|
|
bHasVehicles = FALSE
|
|
enemy_faction = ENEMY_FACTION_FIB
|
|
BREAK
|
|
CASE EW_FIB_ATTACK_TREVOR_CLIMAX_1
|
|
firstPed = EP_FIB_ATTACK_TREVOR_CLIMAX_1
|
|
lastPed = EP_FIB_ATTACK_TREVOR_CLIMAX_3
|
|
bHasVehicles = FALSE
|
|
enemy_faction = ENEMY_FACTION_FIB
|
|
BREAK
|
|
CASE EW_FIB_ATTACK_TREVOR_CLIMAX_2
|
|
firstPed = EP_FIB_ATTACK_TREVOR_CLIMAX_4
|
|
lastPed = EP_FIB_ATTACK_TREVOR_CLIMAX_7
|
|
bHasVehicles = FALSE
|
|
enemy_faction = ENEMY_FACTION_FIB
|
|
BREAK
|
|
CASE EW_FIB_BATTLE_OUTSIDE
|
|
bHasVehicles = FALSE
|
|
firstPed = EP_FIB_BATTLE_OUTSIDE_FOOT_1
|
|
lastPed = EP_FIB_BATTLE_OUTSIDE_FOOT_3
|
|
enemy_faction = ENEMY_FACTION_FIB
|
|
BREAK
|
|
CASE EW_FIB_ON_ROAD
|
|
firstPed = EP_FIB_ON_ROAD_FOOT_1
|
|
lastPed = EP_FIB_ON_ROAD_FOOT_4
|
|
bHasVehicles = FALSE
|
|
enemy_faction = ENEMY_FACTION_FIB
|
|
BREAK
|
|
CASE EW_FIB_GROUND_FLOOR
|
|
firstPed = EP_FIB_GROUND_FLOOR_FOOT_1
|
|
lastPed = EP_FIB_GROUND_FLOOR_FOOT_4
|
|
bHasVehicles = FALSE
|
|
enemy_faction = ENEMY_FACTION_FIB
|
|
BREAK
|
|
CASE EW_FIB_STAGE2_INSIDE
|
|
firstPed = EP_FIB_LAMAR_INSIDE_1
|
|
lastPed = EP_FIB_LAMAR_INSIDE_2
|
|
bHasVehicles = FALSE
|
|
enemy_faction = ENEMY_FACTION_FIB
|
|
BREAK
|
|
CASE EW_FIB_STAGE2_INSIDE_REINF
|
|
firstPed = EP_FIB_LAMAR_INSIDE_REINF_1
|
|
lastPed = EP_FIB_LAMAR_INSIDE_REINF_2
|
|
bHasVehicles = FALSE
|
|
enemy_faction = ENEMY_FACTION_FIB
|
|
BREAK
|
|
CASE EW_FIB_LAMAR
|
|
firstPed = EP_FIB_LAMAR_BATTLE_1
|
|
lastPed = EP_FIB_LAMAR_BATTLE_5
|
|
enemy_faction = ENEMY_FACTION_FIB
|
|
bHasVehicles = FALSE
|
|
BREAK
|
|
CASE EW_FIB_REINF_LAMAR
|
|
firstPed = EP_FIB_LAMAR_BATTLE_REINF_1
|
|
lastPed = EP_FIB_LAMAR_BATTLE_REINF_5
|
|
bHasVehicles = FALSE
|
|
enemy_faction = ENEMY_FACTION_FIB
|
|
BREAK
|
|
CASE EW_FIB_INFINITE_LAMAR
|
|
firstPed = EP_FIB_LAMAR_BATTLE_INFINITE_1
|
|
lastPed = EP_FIB_LAMAR_BATTLE_INFINITE_2
|
|
bHasVehicles = FALSE
|
|
enemy_faction = ENEMY_FACTION_FIB
|
|
BREAK
|
|
CASE EW_MERC_HELI_GROUP
|
|
firstVehicle = EV_MERC_BATTLE_OUTSIDE_CHOPPER_1
|
|
lastVehicle = EV_MERC_BATTLE_OUTSIDE_CHOPPER_1
|
|
firstPed = EP_MERC_BATTLE_OUTSIDE_CHOPPER_1_PILOT
|
|
lastPed = EP_MERC_BATTLE_OUTSIDE_CHOPPER_1_PASSBR
|
|
enemy_faction = ENEMY_FACTION_MERC
|
|
BREAK
|
|
CASE EW_MERC_BATTLE_OUTSIDE
|
|
firstVehicle = EV_MERC_BATTLE_OUTSIDE_4WD_1
|
|
lastVehicle = EV_MERC_BATTLE_OUTSIDE_4WD_2
|
|
firstPed = EP_MERC_BATTLE_OUTSIDE_4WD_1_DRIVER
|
|
lastPed = EP_MERC_BATTLE_OUTSIDE_4WD_2_DRIVER
|
|
enemy_faction = ENEMY_FACTION_MERC
|
|
BREAK
|
|
CASE EW_MERC_UP_ROAD
|
|
firstVehicle = EV_MERC_UP_ROAD_4WD_1
|
|
lastVehicle = EV_MERC_UP_ROAD_4WD_2
|
|
firstPed = EP_MERC_UP_ROAD_4WD_1_DRIVER
|
|
lastPed = EP_MERC_UP_ROAD_4WD_2_DRIVER
|
|
enemy_faction = ENEMY_FACTION_MERC
|
|
BREAK
|
|
CASE EW_MERC_TRAIN_REINF1
|
|
firstVehicle = EV_MERC_TRAIN_4WD_1
|
|
lastVehicle = EV_MERC_TRAIN_4WD_1
|
|
firstPed = EP_MERC_TRAIN_4WD_1_DRIVER
|
|
lastPed = EP_MERC_TRAIN_4WD_1_PASSFR
|
|
enemy_faction = ENEMY_FACTION_MERC
|
|
BREAK
|
|
CASE EW_MERC_TRAIN_REINF2
|
|
firstVehicle = EV_MERC_TRAIN_4WD_2
|
|
lastVehicle = EV_MERC_TRAIN_4WD_2
|
|
firstPed = EP_MERC_TRAIN_4WD_2_DRIVER
|
|
lastPed = EP_MERC_TRAIN_4WD_2_PASSFR
|
|
enemy_faction = ENEMY_FACTION_MERC
|
|
BREAK
|
|
CASE EW_FIB_ROAD_REINF
|
|
firstVehicle = EV_FIB_ROAD_REINF_1
|
|
lastVehicle = EV_FIB_ROAD_REINF_1
|
|
firstPed = EP_FIB_ROAD_REINF_1_DRIVER
|
|
lastPed = EP_FIB_ROAD_REINF_1_PASSFR
|
|
enemy_faction = ENEMY_FACTION_FIB
|
|
BREAK
|
|
CASE EW_FIB_MID_FIGHTERS_FRONT
|
|
firstPed = EP_FIB_MID_FIGHTERS_FRONT_1
|
|
lastPed = EP_FIB_MID_FIGHTERS_FRONT_3
|
|
enemy_faction = ENEMY_FACTION_FIB
|
|
bHasVehicles = FALSE
|
|
BREAK
|
|
CASE EW_MERC_MID_FIGHTERS_BACK
|
|
firstPed = EP_FIB_MID_FIGHTERS_BACK_1
|
|
lastPed = EP_FIB_MID_FIGHTERS_BACK_3
|
|
enemy_faction = ENEMY_FACTION_MERC
|
|
bHasVehicles = FALSE
|
|
BREAK
|
|
ENDSWITCH
|
|
ENDPROC
|
|
|
|
// put enemies in the given wave into the mix group
|
|
PROC ADD_ENEMY_WAVE_TO_MIX_GROUP(ENEMY_WAVE_ENUM waveEnum)
|
|
INT i
|
|
ENEMY_VEHICLE_ENUM firstVehicle
|
|
ENEMY_VEHICLE_ENUM lastVehicle
|
|
ENEMY_PED_ENUM firstPed
|
|
ENEMY_PED_ENUM lastPed
|
|
BOOL bHasVehicles = TRUE
|
|
ENEMY_FACTION_ENUM enemy_faction
|
|
|
|
FILL_ENEMY_WAVE_PROPERTIES(waveEnum, firstVehicle, lastVehicle, firstPed, lastPed, bHasVehicles, enemy_faction)
|
|
|
|
FOR i=firstPed TO lastPed
|
|
ADD_ENTITY_TO_AUDIO_MIX_GROUP(enemyPed[i].ped, "FINALE_ENEMIES_ARRIVE_Group")
|
|
ENDFOR
|
|
|
|
ENDPROC
|
|
|
|
// remove all enemy blips
|
|
PROC REMOVE_ALL_ENEMY_BLIPS()
|
|
INT i
|
|
REPEAT COUNT_OF(enemyPed) i
|
|
CLEANUP_AI_PED_BLIP(enemyPed[i].blipStruct)
|
|
//IF DOES_BLIP_EXIST(enemyPed[i].blip)
|
|
// REMOVE_BLIP(enemyPed[i].blip)
|
|
//ENDIF
|
|
ENDREPEAT
|
|
//REPEAT COUNT_OF(enemyVehicle) i
|
|
// IF DOES_BLIP_EXIST(enemyVehicle[i].blip)
|
|
// REMOVE_BLIP(enemyVehicle[i].blip)
|
|
// ENDIF
|
|
//ENDREPEAT
|
|
ENDPROC
|
|
|
|
// sets the AI blips of the given enemy wave on or off
|
|
PROC TOGGLE_ENEMY_WAVE_BLIPS(ENEMY_WAVE_ENUM waveEnum, BOOL bBlipsOn)
|
|
INT i
|
|
ENEMY_VEHICLE_ENUM firstVehicle
|
|
ENEMY_VEHICLE_ENUM lastVehicle
|
|
ENEMY_PED_ENUM firstPed
|
|
ENEMY_PED_ENUM lastPed
|
|
BOOL bHasVehicles = TRUE
|
|
ENEMY_FACTION_ENUM enemy_faction
|
|
|
|
FILL_ENEMY_WAVE_PROPERTIES(waveEnum, firstVehicle, lastVehicle, firstPed, lastPed, bHasVehicles, enemy_faction)
|
|
|
|
FOR i = firstPed TO lastPed
|
|
IF IS_ENEMY_ALIVE(INT_TO_ENUM(ENEMY_PED_ENUM, i))
|
|
IF bBlipsOn
|
|
IF NOT DOES_PED_HAVE_AI_BLIP(enemyPed[i].ped)
|
|
CPRINTLN(DEBUG_MISSION, "TOGGLE_ENEMY_WAVE_BLIPS: Toggle blip on")
|
|
SET_PED_HAS_AI_BLIP(enemyPed[i].ped, TRUE)
|
|
ENDIF
|
|
ELSE
|
|
IF DOES_PED_HAVE_AI_BLIP(enemyPed[i].ped)
|
|
CPRINTLN(DEBUG_MISSION, "TOGGLE_ENEMY_WAVE_BLIPS: Toggle blip off")
|
|
SET_PED_HAS_AI_BLIP(enemyPed[i].ped, FALSE)
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDFOR
|
|
ENDPROC
|
|
|
|
// handles turning on/off the inside enemy blips during the save Lamar stage
|
|
PROC HANDLE_INSIDE_BLIPS_DURING_SAVE_LAMAR()
|
|
IF IS_PED_IN_FOUNDRY_INTERIOR(PLAYER_PED_ID())
|
|
// put blips on
|
|
TOGGLE_ENEMY_WAVE_BLIPS(EW_FIB_STAGE2_INSIDE, TRUE)
|
|
TOGGLE_ENEMY_WAVE_BLIPS(EW_FIB_STAGE2_INSIDE_REINF, TRUE)
|
|
ELSE
|
|
// remove blips for inside enemies
|
|
TOGGLE_ENEMY_WAVE_BLIPS(EW_FIB_STAGE2_INSIDE, FALSE)
|
|
TOGGLE_ENEMY_WAVE_BLIPS(EW_FIB_STAGE2_INSIDE_REINF, FALSE)
|
|
ENDIF
|
|
|
|
ENDPROC
|
|
|
|
// create enemy wave
|
|
PROC CREATE_ENEMY_WAVE(ENEMY_WAVE_ENUM waveEnum, BOOL bBlip, BOOL bForceWait = FALSE)
|
|
CPRINTLN(DEBUG_MISSION, "CREATE_ENEMY_WAVE creating wave #", waveEnum)
|
|
INT i
|
|
ENEMY_VEHICLE_ENUM firstVehicle
|
|
ENEMY_VEHICLE_ENUM lastVehicle
|
|
ENEMY_PED_ENUM firstPed
|
|
ENEMY_PED_ENUM lastPed
|
|
BOOL bHasVehicles = TRUE
|
|
ENEMY_FACTION_ENUM enemy_faction
|
|
|
|
FILL_ENEMY_WAVE_PROPERTIES(waveEnum, firstVehicle, lastVehicle, firstPed, lastPed, bHasVehicles, enemy_faction)
|
|
|
|
IF bHasVehicles
|
|
FOR i=firstVehicle TO lastVehicle
|
|
CREATE_ENEMY_VEHICLE(INT_TO_ENUM(ENEMY_VEHICLE_ENUM, i))
|
|
IF bForceWait
|
|
WAIT_WITH_RECORD()
|
|
ENDIF
|
|
ENDFOR
|
|
ENDIF
|
|
FOR i=firstPed TO lastPed
|
|
CREATE_ENEMY_PED(INT_TO_ENUM(ENEMY_PED_ENUM, i), bBlip, enemy_faction)
|
|
IF bForceWait
|
|
WAIT_WITH_RECORD()
|
|
ENDIF
|
|
ENDFOR
|
|
|
|
IF bShootoutStarted
|
|
bAudioPlayNewWaveOneShot = TRUE
|
|
ENDIF
|
|
|
|
ADD_ENEMY_WAVE_TO_MIX_GROUP(waveEnum)
|
|
|
|
ENDPROC
|
|
|
|
// delete enemy wave
|
|
PROC DELETE_ENEMY_WAVE(ENEMY_WAVE_ENUM waveEnum, BOOL bLazy)
|
|
INT i
|
|
|
|
ENEMY_VEHICLE_ENUM firstVehicle
|
|
ENEMY_VEHICLE_ENUM lastVehicle
|
|
ENEMY_PED_ENUM firstPed
|
|
ENEMY_PED_ENUM lastPed
|
|
BOOL bHasVehicles = TRUE
|
|
ENEMY_FACTION_ENUM enemy_faction
|
|
|
|
FILL_ENEMY_WAVE_PROPERTIES(waveEnum, firstVehicle, lastVehicle, firstPed, lastPed, bHasVehicles, enemy_faction)
|
|
|
|
IF bHasVehicles
|
|
FOR i=firstVehicle TO lastVehicle
|
|
//IF DOES_BLIP_EXIST(enemyVehicle[i].blip)
|
|
// REMOVE_BLIP(enemyVehicle[i].blip)
|
|
//ENDIF
|
|
IF DOES_ENTITY_EXIST(enemyVehicle[i].veh)
|
|
IF NOT bLazy
|
|
DELETE_VEHICLE(enemyVehicle[i].veh)
|
|
ELSE
|
|
SET_VEHICLE_AS_NO_LONGER_NEEDED(enemyVehicle[i].veh)
|
|
ENDIF
|
|
ENDIF
|
|
ENDFOR
|
|
ENDIF
|
|
FOR i=firstPed TO lastPed
|
|
IF DOES_ENTITY_EXIST(enemyPed[i].ped)
|
|
IF NOT bLazy
|
|
DELETE_PED(enemyPed[i].ped)
|
|
ELSE
|
|
SET_PED_AS_NO_LONGER_NEEDED(enemyPed[i].ped)
|
|
ENDIF
|
|
ENDIF
|
|
ENDFOR
|
|
ENDPROC
|
|
|
|
// kill enemy wave
|
|
PROC KILL_ENEMY_WAVE(ENEMY_WAVE_ENUM waveEnum)
|
|
INT i
|
|
|
|
ENEMY_VEHICLE_ENUM firstVehicle
|
|
ENEMY_VEHICLE_ENUM lastVehicle
|
|
ENEMY_PED_ENUM firstPed
|
|
ENEMY_PED_ENUM lastPed
|
|
BOOL bHasVehicles = TRUE
|
|
ENEMY_FACTION_ENUM enemy_faction
|
|
|
|
FILL_ENEMY_WAVE_PROPERTIES(waveEnum, firstVehicle, lastVehicle, firstPed, lastPed, bHasVehicles, enemy_faction)
|
|
|
|
IF bHasVehicles
|
|
FOR i=firstVehicle TO lastVehicle
|
|
IF IS_VEHICLE_DRIVEABLE(enemyVehicle[i].veh)
|
|
SET_VEHICLE_ENGINE_HEALTH(enemyVehicle[i].veh, 50)
|
|
ENDIF
|
|
ENDFOR
|
|
ENDIF
|
|
FOR i=firstPed TO lastPed
|
|
IF NOT IS_PED_INJURED(enemyPed[i].ped)
|
|
APPLY_DAMAGE_TO_PED(enemyPed[i].ped, 1000, TRUE)
|
|
ENDIF
|
|
ENDFOR
|
|
ENDPROC
|
|
|
|
// kill all enemies
|
|
PROC KILL_ALL_ENEMIES()
|
|
INT i
|
|
|
|
REPEAT COUNT_OF(enemyVehicle) i
|
|
IF IS_VEHICLE_DRIVEABLE(enemyVehicle[i].veh)
|
|
SET_VEHICLE_ENGINE_HEALTH(enemyVehicle[i].veh, 50)
|
|
ENDIF
|
|
ENDREPEAT
|
|
REPEAT COUNT_OF(enemyPed) i
|
|
IF NOT IS_PED_INJURED(enemyPed[i].ped)
|
|
APPLY_DAMAGE_TO_PED(enemyPed[i].ped, 1000, TRUE)
|
|
ENDIF
|
|
ENDREPEAT
|
|
ENDPROC
|
|
|
|
// mark dead enemy peds no longer needed
|
|
PROC SET_DEAD_ENEMY_PEDS_NO_LONGER_NEEDED()
|
|
INT i
|
|
|
|
REPEAT COUNT_OF(enemyPed) i
|
|
IF DOES_ENTITY_EXIST(enemyPed[i].ped)
|
|
IF IS_PED_INJURED(enemyPed[i].ped)
|
|
SET_PED_AS_NO_LONGER_NEEDED(enemyPed[i].ped)
|
|
ENDIF
|
|
ENDIF
|
|
ENDREPEAT
|
|
ENDPROC
|
|
|
|
|
|
// enemy explode health
|
|
FUNC INT GET_ENEMY_VEHICLE_EXPLODE_HEALTH(ENEMY_VEHICLE_ENUM thisVehicle)
|
|
SWITCH thisVehicle
|
|
//CASE EV_FIB_BATTLE_OUTSIDE_VAN_1
|
|
//CASE EV_FIB_BATTLE_OUTSIDE_VAN_2
|
|
// RETURN 300
|
|
//BREAK
|
|
CASE EV_MERC_BATTLE_OUTSIDE_CHOPPER_1
|
|
//CASE EV_MERC_BATTLE_OUTSIDE_CHOPPER_2
|
|
RETURN 700
|
|
BREAK
|
|
ENDSWITCH
|
|
|
|
RETURN -100
|
|
ENDFUNC
|
|
|
|
// put enemy ped in combat
|
|
PROC PUT_ENEMY_PED_IN_COMBAT(ENEMY_PED_ENUM thisPed)
|
|
IF NOT IS_PED_INJURED(enemyPed[thisPed].ped)
|
|
|
|
TASK_COMBAT_HATED_TARGETS_AROUND_PED(enemyPed[thisPed].ped, 200.0)
|
|
REGISTER_TARGET(enemyPed[thisPed].ped, PLAYER_PED_ID())
|
|
SET_BLOCKING_OF_NON_TEMPORARY_EVENTS(enemyPed[thisPed].ped, FALSE)
|
|
|
|
FLOAT fDefensiveAreaRadius = GET_ENEMY_PED_DEFENSIVE_RADIUS(thisPed)
|
|
IF fDefensiveAreaRadius > 0
|
|
SET_PED_SPHERE_DEFENSIVE_AREA(enemyPed[thisPed].ped, GET_ENEMY_PED_DEFENSIVE_AREA(thisPed), fDefensiveAreaRadius)
|
|
ENDIF
|
|
|
|
FLOAT fSecondaryDefensiveAreaRadius = GET_ENEMY_PED_SECONDARY_DEFENSIVE_RADIUS(thisPed)
|
|
IF fSecondaryDefensiveAreaRadius > 0
|
|
SET_PED_SPHERE_DEFENSIVE_AREA(enemyPed[thisPed].ped, GET_ENEMY_PED_SECONDARY_DEFENSIVE_AREA(thisPed), fSecondaryDefensiveAreaRadius, FALSE, TRUE)
|
|
ENDIF
|
|
|
|
enemyPed[thisPed].enemyTaskStatus = ENEMY_TASK_STATUS_COMBAT
|
|
ENDIF
|
|
ENDPROC
|
|
|
|
|
|
// exits from foundry
|
|
FUNC VECTOR GET_EXIT_COORD(INT iExit)
|
|
SWITCH iExit
|
|
CASE iEXIT_CATWALK
|
|
RETURN <<1079.58582, -2012.59290, 42.90799>>
|
|
BREAK
|
|
CASE iEXIT_OFFICE
|
|
RETURN <<1078.10754, -1973.13184, 30.47120>>
|
|
BREAK
|
|
CASE iEXIT_BACK
|
|
RETURN <<1073.58057, -2007.23340, 31.05574>>
|
|
BREAK
|
|
ENDSWITCH
|
|
|
|
RETURN <<0,0,0>>
|
|
ENDFUNC
|
|
|
|
// exits dimensions
|
|
FUNC VECTOR GET_EXIT_DIMENSIONS(INT iExit)
|
|
SWITCH iExit
|
|
CASE iEXIT_CATWALK
|
|
RETURN <<2, 2, 2.5>>
|
|
BREAK
|
|
CASE iEXIT_OFFICE
|
|
RETURN <<1.3 ,1.3 ,2.5>>
|
|
BREAK
|
|
CASE iEXIT_BACK
|
|
RETURN <<1.5, 1.5, 2.5>>
|
|
BREAK
|
|
ENDSWITCH
|
|
|
|
RETURN <<0,0,0>>
|
|
ENDFUNC
|
|
|
|
PROC MAKE_FIB_SEARCHERS_REACT()
|
|
IF iFIBReactionCount > ENUM_TO_INT(EP_FIB_SEARCH_FOOT_7)
|
|
EXIT
|
|
ENDIF
|
|
|
|
ENEMY_PED_ENUM thisReactor = INT_TO_ENUM(ENEMY_PED_ENUM, iFIBReactionCount)
|
|
|
|
INT iReactionTime
|
|
SWITCH thisReactor
|
|
CASE EP_FIB_SEARCH_FOOT_1
|
|
iReactionTime = 250
|
|
BREAK
|
|
CASE EP_FIB_SEARCH_FOOT_2
|
|
CASE EP_FIB_SEARCH_FOOT_3
|
|
iReactionTime = 500
|
|
BREAK
|
|
CASE EP_FIB_SEARCH_FOOT_4
|
|
iReactionTime = 400
|
|
BREAK
|
|
CASE EP_FIB_SEARCH_FOOT_5
|
|
CASE EP_FIB_SEARCH_FOOT_6
|
|
iReactionTime = 700
|
|
BREAK
|
|
DEFAULT
|
|
iReactionTime = 300
|
|
BREAK
|
|
ENDSWITCH
|
|
|
|
IF GET_GAME_TIMER() > iFIBReactionStartTime + iReactionTime
|
|
CPRINTLN(DEBUG_MISSION, "BSW making searcher #", iFIBReactionCount, " react")
|
|
PUT_ENEMY_PED_IN_COMBAT(thisReactor)
|
|
iFIBReactionCount++
|
|
ENDIF
|
|
|
|
ENDPROC
|
|
|
|
FUNC BOOL HANDLE_FIB_SEARCH()
|
|
PED_INDEX michaelPed = GET_MICHAEL_PED()
|
|
PED_INDEX franklinPed = GET_FRANKLIN_PED()
|
|
PED_INDEX trevorPed = GET_TREVOR_PED()
|
|
|
|
IF NOT IS_ENTITY_OK(michaelPed)
|
|
OR NOT IS_ENTITY_OK(franklinPed)
|
|
OR NOT IS_ENTITY_OK(trevorPed)
|
|
RETURN FALSE
|
|
ENDIF
|
|
|
|
IF GET_TIMER_IN_SECONDS_SAFE(tmrSearchReactionDelay) > 2
|
|
CPRINTLN(DEBUG_MISSION, "HANDLE_FIB_SEARCH - player was aiming or out of cover for long enough")
|
|
RETURN TRUE
|
|
ENDIF
|
|
|
|
IF IS_PED_SHOOTING(michaelPed)
|
|
OR IS_PED_SHOOTING(franklinPed)
|
|
OR IS_PED_SHOOTING(trevorPed)
|
|
CPRINTLN(DEBUG_MISSION, "HANDLE_FIB_SEARCH - one of the player peds is shooting")
|
|
RETURN TRUE
|
|
ENDIF
|
|
|
|
IF NOT IS_TIMER_STARTED(tmrSearchReactionDelay)
|
|
IF IS_PLAYER_FREE_AIMING(PLAYER_ID()) OR NOT IS_PED_IN_COVER(PLAYER_PED_ID())
|
|
START_TIMER_NOW_SAFE(tmrSearchReactionDelay)
|
|
ENDIF
|
|
ELSE
|
|
IF NOT IS_PLAYER_FREE_AIMING(PLAYER_ID()) AND IS_PED_IN_COVER(PLAYER_PED_ID())
|
|
CANCEL_TIMER(tmrSearchReactionDelay)
|
|
ENDIF
|
|
ENDIF
|
|
|
|
INT i
|
|
REPEAT COUNT_OF(enemyPed) i
|
|
IF IS_ENEMY_ALIVE(INT_TO_ENUM(ENEMY_PED_ENUM, i))
|
|
|
|
IF IS_WAYPOINT_PLAYBACK_GOING_ON_FOR_PED(enemyPed[i].ped)
|
|
INT iProgress = GET_PED_WAYPOINT_PROGRESS(enemyPed[i].ped)
|
|
INT iTotalPoints = 0
|
|
TEXT_LABEL waypointName = GET_WAYPOINT_LABEL_FROM_INT(i+2)
|
|
WAYPOINT_RECORDING_GET_NUM_POINTS(waypointName, iTotalPoints)
|
|
|
|
IF i = ENUM_TO_INT(EP_FIB_SEARCH_FOOT_2)
|
|
IF iProgress / iTotalPoints > 0.9
|
|
CPRINTLN(DEBUG_MISSION, "HANDLE_FIB_SEARCH - EP_FIB_SEARCH_FOOT_2 finished his route")
|
|
RETURN TRUE
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF IS_ENTITY_AT_ENTITY(michaelPed, enemyPed[i].ped, <<7, 7, 2>>)
|
|
OR IS_ENTITY_AT_ENTITY(franklinPed, enemyPed[i].ped, <<7, 7, 2>>)
|
|
OR IS_ENTITY_AT_ENTITY(trevorPed, enemyPed[i].ped, <<7, 7, 2>>)
|
|
CPRINTLN(DEBUG_MISSION, "HANDLE_FIB_SEARCH - a searcher got close to a player ped")
|
|
|
|
// special case stuff to help michael target the guy that just walked up behind him
|
|
IF IS_ENTITY_AT_COORD(GET_MICHAEL_PED(), GET_FINALE_VECTOR(FINVEC_MICHAEL_READY), (<<2, 2, 2>>))
|
|
CPRINTLN(DEBUG_MISSION, "HANDLE_FIB_SEARCH - telling Michael to stand up")
|
|
CLEAR_PED_TASKS(GET_MICHAEL_PED())
|
|
ENDIF
|
|
|
|
RETURN TRUE
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF DOES_ENTITY_EXIST(enemyPed[i].ped)
|
|
IF IS_PED_INJURED(enemyPed[i].ped)
|
|
OR HAS_ENTITY_BEEN_DAMAGED_BY_ANY_PED(enemyPed[i].ped)
|
|
RETURN TRUE
|
|
ENDIF
|
|
IF IS_EXPLOSION_IN_SPHERE(EXP_TAG_DONTCARE, GET_ENTITY_COORDS(enemyPed[i].ped), 50)
|
|
RETURN TRUE
|
|
ENDIF
|
|
ENDIF
|
|
ENDREPEAT
|
|
|
|
RETURN FALSE
|
|
ENDFUNC
|
|
|
|
FUNC VECTOR GET_AIM_TARGET_FOR_SEARCHER(ENEMY_PED_ENUM thisPed)
|
|
INT iWaypointInt
|
|
VECTOR vAimTarget
|
|
|
|
SWITCH thisPed
|
|
CASE EP_FIB_SEARCH_FOOT_1
|
|
vAimTarget = <<1110.9869, -2003.3766, 30.7560>>
|
|
iWaypointInt = 2
|
|
BREAK
|
|
CASE EP_FIB_SEARCH_FOOT_2
|
|
vAimTarget = <<1107.3804, -2014.5999, 34.6895>>
|
|
iWaypointInt = 3
|
|
BREAK
|
|
CASE EP_FIB_SEARCH_FOOT_3
|
|
vAimTarget = <<1113.0319, -1997.1774, 29.3790>>
|
|
iWaypointInt = 4
|
|
BREAK
|
|
CASE EP_FIB_SEARCH_FOOT_4
|
|
vAimTarget = <<1102.4016, -2023.9705, 30.1532>>
|
|
iWaypointInt = 5
|
|
BREAK
|
|
CASE EP_FIB_SEARCH_FOOT_5
|
|
vAimTarget = <<1081.8768, -1984.0442, 30.5513>>
|
|
iWaypointInt = 6
|
|
BREAK
|
|
CASE EP_FIB_SEARCH_FOOT_6
|
|
vAimTarget = <<1073.9987, -1983.5785, 30.0500>>
|
|
iWaypointInt = 7
|
|
BREAK
|
|
CASE EP_FIB_SEARCH_FOOT_7
|
|
vAimTarget = <<1070.7472, -1994.2069, 30.5689>>
|
|
iWaypointInt = 8
|
|
BREAK
|
|
ENDSWITCH
|
|
|
|
TEXT_LABEL waypointName = GET_WAYPOINT_LABEL_FROM_INT(iWaypointInt)
|
|
|
|
IF IS_WAYPOINT_PLAYBACK_GOING_ON_FOR_PED(enemyPed[thisPed].ped)
|
|
INT iTotalPoints
|
|
IF NOT WAYPOINT_RECORDING_GET_NUM_POINTS(waypointName, iTotalPoints)
|
|
CPRINTLN(DEBUG_MISSION, "BSWwp WAYPOINT_RECORDING_GET_NUM_POINTS failed")
|
|
ENDIF
|
|
IF NOT WAYPOINT_RECORDING_GET_COORD(waypointName, iTotalPoints-1, vAimTarget)
|
|
CPRINTLN(DEBUG_MISSION, "BSWwp WAYPOINT_RECORDING_GET_COORD failed")
|
|
ENDIF
|
|
|
|
INT iProgress = GET_PED_WAYPOINT_PROGRESS(enemyPed[thisPed].ped)
|
|
// get a point a couple ahead of where we are now
|
|
iProgress = iProgress+2
|
|
|
|
WAYPOINT_RECORDING_GET_NUM_POINTS(waypointName, iTotalPoints)
|
|
|
|
IF iProgress >= iTotalPoints
|
|
iProgress = iTotalPoints-1
|
|
ENDIF
|
|
|
|
WAYPOINT_RECORDING_GET_COORD(waypointName, iProgress, vAimTarget)
|
|
//DRAW_DEBUG_SPHERE(vAimTarget, 1)
|
|
ELSE
|
|
//CPRINTLN(DEBUG_MISSION, "BSWwp searcher #", thisPed, " aim-only aim target:", vAimTarget.x, ", ", vAimTarget.y, ", ", vAimTarget.z)
|
|
ENDIF
|
|
|
|
// adjust our Z because waypoint positions default to the ground
|
|
vAimTarget.z = vAimTarget.z + 1.5
|
|
|
|
RETURN vAimTarget
|
|
ENDFUNC
|
|
|
|
// set the fib to search
|
|
PROC SET_FIB_TO_SEARCH()
|
|
INT i
|
|
|
|
INT iFirstSearchWaypoint = 2 // (its actually 3 but GET_WAYPOINT_LABEL_FROM_INT adds 1 so...)
|
|
|
|
FOR i=EP_FIB_SEARCH_FOOT_1 TO EP_FIB_SEARCH_FOOT_7
|
|
ENEMY_PED_ENUM thisPed = INT_TO_ENUM(ENEMY_PED_ENUM, i)
|
|
TEXT_LABEL waypointName = GET_WAYPOINT_LABEL_FROM_INT(iFirstSearchWaypoint)
|
|
|
|
INT iPauseTime = iFirstSearchWaypoint * 20
|
|
|
|
IF NOT IS_PED_INJURED(enemyPed[thisPed].ped)
|
|
SET_CURRENT_PED_WEAPON(enemyPed[thisPed].ped, GET_FINALE_WEAPON_TYPE(F_WEAPON_FIB_RIFLE), TRUE)
|
|
CLEAR_SEQUENCE_TASK(sequence)
|
|
OPEN_SEQUENCE_TASK(sequence)
|
|
TASK_PAUSE(NULL, iPauseTime)
|
|
TASK_FOLLOW_WAYPOINT_RECORDING(NULL, waypointName, 0, EWAYPOINT_START_FROM_CLOSEST_POINT | EWAYPOINT_START_TASK_INITIALLY_AIMING | EWAYPOINT_TURN_TO_FACE_WAYPOINT_HEADING_AT_END | EWAYPOINT_USE_TIGHTER_TURN_SETTINGS)
|
|
TASK_AIM_GUN_AT_COORD(NULL, GET_AIM_TARGET_FOR_SEARCHER(thisPed), INFINITE_TASK_TIME, TRUE, FALSE)
|
|
CLOSE_SEQUENCE_TASK(sequence)
|
|
TASK_PERFORM_SEQUENCE(enemyPed[thisPed].ped, sequence)
|
|
enemyPed[thisPed].enemyTaskStatus = ENEMY_TASK_STATUS_FOLLOW_ROUTE
|
|
iFirstSearchWaypoint++
|
|
ENDIF
|
|
ENDFOR
|
|
ENDPROC
|
|
|
|
PROC TOGGLE_ENEMY_WAVE_ONLY_DAMAGED_BY_PLAYER(ENEMY_WAVE_ENUM waveEnum, BOOL bOnlyDamagedByPlayer)
|
|
INT i
|
|
|
|
ENEMY_VEHICLE_ENUM firstVehicle
|
|
ENEMY_VEHICLE_ENUM lastVehicle
|
|
ENEMY_PED_ENUM firstPed
|
|
ENEMY_PED_ENUM lastPed
|
|
BOOL bHasVehicles = FALSE
|
|
ENEMY_FACTION_ENUM enemy_faction
|
|
FILL_ENEMY_WAVE_PROPERTIES(waveEnum, firstVehicle, lastVehicle, firstPed, lastPed, bHasVehicles, enemy_faction)
|
|
|
|
FOR i=firstPed TO lastPed
|
|
IF IS_ENEMY_ALIVE(INT_TO_ENUM(ENEMY_PED_ENUM, i))
|
|
SET_ENTITY_ONLY_DAMAGED_BY_PLAYER(enemyPed[i].ped, bOnlyDamagedByPlayer)
|
|
ENDIF
|
|
ENDFOR
|
|
ENDPROC
|
|
|
|
PROC TASK_ENEMY_WAVE_SHOOT_AT_LAMAR(ENEMY_WAVE_ENUM waveEnum)
|
|
INT i
|
|
|
|
ENEMY_VEHICLE_ENUM firstVehicle
|
|
ENEMY_VEHICLE_ENUM lastVehicle
|
|
ENEMY_PED_ENUM firstPed
|
|
ENEMY_PED_ENUM lastPed
|
|
BOOL bHasVehicles = FALSE
|
|
ENEMY_FACTION_ENUM enemy_faction
|
|
FILL_ENEMY_WAVE_PROPERTIES(waveEnum, firstVehicle, lastVehicle, firstPed, lastPed, bHasVehicles, enemy_faction)
|
|
|
|
FOR i=firstPed TO lastPed
|
|
ENEMY_PED_ENUM thisEnemyPed = INT_TO_ENUM(ENEMY_PED_ENUM, i)
|
|
|
|
IF IS_ENEMY_ALIVE(INT_TO_ENUM(ENEMY_PED_ENUM, i))
|
|
IF IS_ENTITY_OK(lamarPed)
|
|
TASK_COMBAT_PED(enemyPed[i].ped, lamarPed)
|
|
FLOAT fDefensiveAreaRadius = GET_ENEMY_PED_DEFENSIVE_RADIUS(thisEnemyPed)
|
|
IF fDefensiveAreaRadius > 0
|
|
SET_PED_SPHERE_DEFENSIVE_AREA(enemyPed[i].ped, GET_ENEMY_PED_DEFENSIVE_AREA(thisEnemyPed), fDefensiveAreaRadius)
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDFOR
|
|
ENDPROC
|
|
|
|
PROC TASK_ENEMY_PED_GO_AGGRESSIVE(ENEMY_PED_ENUM thisEnemy)
|
|
IF IS_ENTITY_OK(enemyPed[thisEnemy].ped)
|
|
SET_PED_COMBAT_ATTRIBUTES(enemyPed[thisEnemy].ped, CA_CAN_CHARGE, TRUE)
|
|
SET_PED_COMBAT_MOVEMENT(enemyPed[thisEnemy].ped, CM_WILLADVANCE)
|
|
REMOVE_PED_DEFENSIVE_AREA(enemyPed[thisEnemy].ped)
|
|
SET_PED_SPHERE_DEFENSIVE_AREA(enemyPed[thisEnemy].ped, GET_ENEMY_PED_DEFENSIVE_AREA(thisEnemy), 20.0)
|
|
SET_PED_DEFENSIVE_AREA_ATTACHED_TO_PED(enemyPed[thisEnemy].ped, PLAYER_PED_ID(), (<<10, 0, 10>>), (<<-10, 0, -10>>), 10, FALSE, TRUE)
|
|
ENDIF
|
|
ENDPROC
|
|
|
|
PROC TASK_ENEMY_PED_CHARGE_PED(ENEMY_PED_ENUM thisEnemy, PED_INDEX chargeTarget)
|
|
IF NOT IS_ENTITY_OK(enemyPed[thisEnemy].ped)
|
|
EXIT
|
|
ENDIF
|
|
IF NOT IS_ENTITY_OK(chargeTarget)
|
|
EXIT
|
|
ENDIF
|
|
|
|
TASK_ENEMY_PED_GO_AGGRESSIVE(thisEnemy)
|
|
REMOVE_PED_DEFENSIVE_AREA(enemyPed[thisEnemy].ped)
|
|
REMOVE_PED_DEFENSIVE_AREA(enemyPed[thisEnemy].ped, TRUE)
|
|
SET_PED_DEFENSIVE_AREA_ATTACHED_TO_PED(enemyPed[thisEnemy].ped, chargeTarget, (<<10, 0, 10>>), (<<-10, 0, -10>>), 10, FALSE)
|
|
|
|
SEQUENCE_INDEX iSeq
|
|
OPEN_SEQUENCE_TASK(iSeq)
|
|
TASK_SET_BLOCKING_OF_NON_TEMPORARY_EVENTS(NULL, TRUE)
|
|
TASK_GO_TO_ENTITY_WHILE_AIMING_AT_ENTITY(NULL, chargeTarget, chargeTarget, PEDMOVE_RUN, TRUE, 5, 8, DEFAULT, DEFAULT, FIRING_TYPE_RANDOM_BURSTS)
|
|
TASK_SET_BLOCKING_OF_NON_TEMPORARY_EVENTS(NULL, FALSE)
|
|
TASK_COMBAT_HATED_TARGETS_AROUND_PED(NULL, 100)
|
|
CLOSE_SEQUENCE_TASK(iSeq)
|
|
TASK_PERFORM_SEQUENCE(enemyPed[thisEnemy].ped, iSeq)
|
|
CLEAR_SEQUENCE_TASK(iSeq)
|
|
|
|
SET_PED_ACCURACY(enemyPed[thisEnemy].ped, iLowAccuracy)
|
|
|
|
enemyPed[thisEnemy].enemyTaskStatus = ENEMY_TASK_STATUS_CHARGING
|
|
ENDPROC
|
|
|
|
PROC TASK_ENEMY_WAVE_GO_AGGRESSIVE(ENEMY_WAVE_ENUM waveEnum)
|
|
INT i
|
|
|
|
ENEMY_VEHICLE_ENUM firstVehicle
|
|
ENEMY_VEHICLE_ENUM lastVehicle
|
|
ENEMY_PED_ENUM firstPed
|
|
ENEMY_PED_ENUM lastPed
|
|
BOOL bHasVehicles = FALSE
|
|
ENEMY_FACTION_ENUM enemy_faction
|
|
FILL_ENEMY_WAVE_PROPERTIES(waveEnum, firstVehicle, lastVehicle, firstPed, lastPed, bHasVehicles, enemy_faction)
|
|
|
|
FOR i=firstPed TO lastPed
|
|
ENEMY_PED_ENUM thisEnemyPed = INT_TO_ENUM(ENEMY_PED_ENUM, i)
|
|
TASK_ENEMY_PED_GO_AGGRESSIVE(thisEnemyPed)
|
|
ENDFOR
|
|
ENDPROC
|
|
|
|
PROC TASK_ENEMY_WAVE_CHARGE_PLAYER(ENEMY_WAVE_ENUM waveEnum)
|
|
INT i
|
|
|
|
ENEMY_VEHICLE_ENUM firstVehicle
|
|
ENEMY_VEHICLE_ENUM lastVehicle
|
|
ENEMY_PED_ENUM firstPed
|
|
ENEMY_PED_ENUM lastPed
|
|
BOOL bHasVehicles = FALSE
|
|
ENEMY_FACTION_ENUM enemy_faction
|
|
FILL_ENEMY_WAVE_PROPERTIES(waveEnum, firstVehicle, lastVehicle, firstPed, lastPed, bHasVehicles, enemy_faction)
|
|
|
|
FOR i=firstPed TO lastPed
|
|
ENEMY_PED_ENUM thisEnemyPed = INT_TO_ENUM(ENEMY_PED_ENUM, i)
|
|
TASK_ENEMY_PED_CHARGE_PED(thisEnemyPed, PLAYER_PED_ID())
|
|
ENDFOR
|
|
ENDPROC
|
|
|
|
PROC TASK_ENEMY_WAVE_MOVE_ONTO_CATWALK(ENEMY_WAVE_ENUM waveEnum, BOOL bFightUpTopForABit = FALSE)
|
|
INT i
|
|
SEQUENCE_INDEX iSeq
|
|
|
|
ENEMY_VEHICLE_ENUM firstVehicle
|
|
ENEMY_VEHICLE_ENUM lastVehicle
|
|
ENEMY_PED_ENUM firstPed
|
|
ENEMY_PED_ENUM lastPed
|
|
BOOL bHasVehicles = FALSE
|
|
ENEMY_FACTION_ENUM enemy_faction
|
|
FILL_ENEMY_WAVE_PROPERTIES(waveEnum, firstVehicle, lastVehicle, firstPed, lastPed, bHasVehicles, enemy_faction)
|
|
|
|
INT iCount = 0
|
|
FOR i=firstPed TO lastPed
|
|
IF IS_ENEMY_ALIVE(INT_TO_ENUM(ENEMY_PED_ENUM, i))
|
|
|
|
// check ENEMY_TASK_STATUS_ENTERING_FOUNDRY before adding more stages to this sequence
|
|
OPEN_SEQUENCE_TASK(iSeq)
|
|
TASK_PAUSE(NULL, GET_RANDOM_INT_IN_RANGE(iCount*500, iCount*501))
|
|
TASK_GO_TO_COORD_AND_AIM_AT_HATED_ENTITIES_NEAR_COORD(NULL, (<<1088.6072, -2014.4706, 42.8439>>), (<<1088.6072, -2014.4706, 42.8439>>), PEDMOVE_RUN, TRUE, 2.0, 0, TRUE, ENAV_NO_STOPPING)
|
|
TASK_GO_TO_COORD_AND_AIM_AT_HATED_ENTITIES_NEAR_COORD(NULL, (<<1105.9193, -2026.2938, 42.8439>>), (<<1105.9193, -2026.2938, 42.8439>>), PEDMOVE_RUN, TRUE, 4.0, 0, TRUE, ENAV_NO_STOPPING)
|
|
IF bFightUpTopForABit
|
|
IF IS_ENTITY_OK(GET_MICHAEL_PED())
|
|
TASK_COMBAT_HATED_TARGETS_AROUND_PED_TIMED(NULL, 50, GET_RANDOM_INT_IN_RANGE(12000, 14000))
|
|
ENDIF
|
|
ENDIF
|
|
TASK_GO_TO_COORD_AND_AIM_AT_HATED_ENTITIES_NEAR_COORD(NULL, (<<1114.1713, -2022.2714, 39.2828>>), (<<1114.1713, -2022.2714, 39.2828>>), PEDMOVE_RUN, TRUE, 2.0, 0, TRUE, ENAV_NO_STOPPING)
|
|
TASK_GO_TO_COORD_AND_AIM_AT_HATED_ENTITIES_NEAR_COORD(NULL, (<<1111.4017, -2019.7240, 34.4867>>), (<<1111.4017, -2019.7240, 34.4867>>), PEDMOVE_RUN, TRUE, 2.0, 0, TRUE, ENAV_NO_STOPPING)
|
|
CLOSE_SEQUENCE_TASK(iSeq)
|
|
TASK_PERFORM_SEQUENCE(enemyPed[i].ped, iSeq)
|
|
CLEAR_SEQUENCE_TASK(iSeq)
|
|
enemyPed[i].enemyTaskStatus = ENEMY_TASK_STATUS_ENTERING_FOUNDRY
|
|
iCount++
|
|
ENDIF
|
|
ENDFOR
|
|
|
|
ENDPROC
|
|
|
|
PROC TASK_ENEMY_WAVE_INTO_FOUNDRY(ENEMY_WAVE_ENUM waveEnum, INT iDoorToEnter)
|
|
INT i
|
|
SEQUENCE_INDEX iSeq
|
|
|
|
ENEMY_VEHICLE_ENUM firstVehicle
|
|
ENEMY_VEHICLE_ENUM lastVehicle
|
|
ENEMY_PED_ENUM firstPed
|
|
ENEMY_PED_ENUM lastPed
|
|
BOOL bHasVehicles = FALSE
|
|
ENEMY_FACTION_ENUM enemy_faction
|
|
FILL_ENEMY_WAVE_PROPERTIES(waveEnum, firstVehicle, lastVehicle, firstPed, lastPed, bHasVehicles, enemy_faction)
|
|
|
|
VECTOR vGoToPos
|
|
INT iCount = 0
|
|
FOR i=firstPed TO lastPed
|
|
IF IS_ENEMY_ALIVE(INT_TO_ENUM(ENEMY_PED_ENUM, i))
|
|
|
|
IF iDoorToEnter = 1
|
|
IF iCount = 0
|
|
vGoToPos = <<1086.2845, -1983.9818, 29.9637>> //near in front of door
|
|
ELIF iCount = 1
|
|
vGoToPos = <<1076.4740, -1992.1276, 29.8789>> //near slabs
|
|
ELIF iCount = 2
|
|
vGoToPos = <<1080.2450, -1989.4192, 29.8747>> //near low cover in front of exit 1
|
|
ELSE
|
|
vGoToPos = <<1073.6465, -1984.9788, 29.9472>> //near trevor injured position
|
|
ENDIF
|
|
ELSE
|
|
IF iCount = 0
|
|
vGoToPos = <<1077.5128, -1996.5780, 29.8843>> //near slabs RIGHT
|
|
ELIF iCount = 1
|
|
vGoToPos = <<1071.3622, -1992.7021, 29.9255>> //near slabs LEFT
|
|
ELIF iCount = 2
|
|
vGoToPos = <<1078.6055, -1999.4377, 29.9102>> //middle, open
|
|
ELSE
|
|
vGoToPos = <<1076.4086, -1993.9581, 29.8816>> //near slabs front
|
|
ENDIF
|
|
ENDIF
|
|
|
|
OPEN_SEQUENCE_TASK(iSeq)
|
|
TASK_SET_BLOCKING_OF_NON_TEMPORARY_EVENTS(NULL, TRUE)
|
|
TASK_PAUSE(NULL, GET_RANDOM_INT_IN_RANGE(iCount*500, iCount*501))
|
|
IF IS_ENTITY_OK(PLAYER_PED_ID())
|
|
IF IS_PLAYER_IN_TRIGGER_BOX(tbBottomExit2Buffer)
|
|
TASK_COMBAT_PED_TIMED(NULL, PLAYER_PED_ID(), 2000)
|
|
TASK_COMBAT_HATED_TARGETS_AROUND_PED(NULL, 100)
|
|
CPRINTLN(DEBUG_MISSION, "BSW don't enter, just combat")
|
|
ELSE
|
|
TASK_GO_TO_COORD_WHILE_AIMING_AT_ENTITY(NULL, vGoToPos, PLAYER_PED_ID(), PEDMOVE_RUN, TRUE, 2, DEFAULT, DEFAULT, DEFAULT, DEFAULT, FIRING_TYPE_RANDOM_BURSTS)
|
|
TASK_SEEK_COVER_FROM_PED(NULL, PLAYER_PED_ID(), 3000, TRUE)
|
|
ENDIF
|
|
ENDIF
|
|
TASK_SET_BLOCKING_OF_NON_TEMPORARY_EVENTS(NULL, FALSE)
|
|
TASK_COMBAT_HATED_TARGETS_AROUND_PED(NULL, 100)
|
|
CLOSE_SEQUENCE_TASK(iSeq)
|
|
TASK_PERFORM_SEQUENCE(enemyPed[i].ped, iSeq)
|
|
CLEAR_SEQUENCE_TASK(iSeq)
|
|
enemyPed[i].enemyTaskStatus = ENEMY_TASK_STATUS_ENTERING_FOUNDRY
|
|
enemyPed[i].iTaskTime = GET_GAME_TIMER()
|
|
iCount++
|
|
ENDIF
|
|
ENDFOR
|
|
ENDPROC
|
|
|
|
FUNC BOOL SHOULD_ENEMY_CHARGE(ENEMY_PED_ENUM thisEnemy, INT iRemainingPedsInWave)
|
|
IF NOT IS_ENEMY_ALIVE(thisEnemy)
|
|
RETURN FALSE
|
|
ENDIF
|
|
IF enemyPed[thisEnemy].enemyTaskStatus <> ENEMY_TASK_STATUS_COMBAT
|
|
RETURN FALSE
|
|
ENDIF
|
|
|
|
// special case for end of stage3
|
|
IF currentMissionStage = STAGE_SHOOTOUT_STAGE_3 AND NOT bTrevorIsInjured
|
|
IF GET_NUM_CHARGERS() = 0 AND GET_GAME_TIMER() > enemyPed[thisEnemy].iTaskTime + 12000
|
|
RETURN TRUE
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF GET_NUM_CHARGERS() > 0
|
|
RETURN FALSE
|
|
ENDIF
|
|
|
|
// don't let the infinite guys charge
|
|
IF thisEnemy = EP_FIB_LAMAR_BATTLE_INFINITE_1
|
|
OR thisEnemy = EP_FIB_LAMAR_BATTLE_INFINITE_2
|
|
RETURN FALSE
|
|
ENDIF
|
|
|
|
INT iNumLivingEnemies = GET_NUM_LIVING_ENEMIES()
|
|
|
|
IF iNumLivingEnemies < 3 AND GET_GAME_TIMER() > enemyPed[thisEnemy].iTaskTime + 22000
|
|
RETURN TRUE
|
|
ENDIF
|
|
IF iNumLivingEnemies < 2
|
|
RETURN TRUE
|
|
ENDIF
|
|
// @BSW this is kinda arbitrary. tweak it or remove it?
|
|
IF currentMissionStage = STAGE_SHOOTOUT_STAGE_4 AND iNumLivingEnemies < 8 AND iRemainingPedsInWave < 2
|
|
RETURN TRUE
|
|
ENDIF
|
|
|
|
RETURN FALSE
|
|
ENDFUNC
|
|
|
|
VEHICLE_INDEX viEarlyVehicle
|
|
|
|
// handle enemy wave
|
|
FUNC INT HANDLE_ENEMY_WAVE(ENEMY_WAVE_ENUM waveEnum)
|
|
INT i, j
|
|
INT iPedsAlive = 0
|
|
|
|
ENEMY_VEHICLE_ENUM firstVehicle
|
|
ENEMY_VEHICLE_ENUM lastVehicle
|
|
ENEMY_PED_ENUM firstPed
|
|
ENEMY_PED_ENUM lastPed
|
|
BOOL bHasVehicles = TRUE
|
|
ENEMY_FACTION_ENUM enemy_faction
|
|
|
|
FILL_ENEMY_WAVE_PROPERTIES(waveEnum, firstVehicle, lastVehicle, firstPed, lastPed, bHasVehicles, enemy_faction)
|
|
|
|
// vehicle stuff
|
|
IF bHasVehicles
|
|
FOR i=firstVehicle TO lastVehicle
|
|
ENEMY_VEHICLE_ENUM thisVehicle = INT_TO_ENUM(ENEMY_VEHICLE_ENUM, i)
|
|
BOOL bDoExplode = FALSE
|
|
IF IS_VEHICLE_DRIVEABLE(enemyVehicle[i].veh)
|
|
// @SBA - save specific vehicle for special handling
|
|
IF thisVehicle = EV_MERC_UP_ROAD_4WD_2
|
|
viEarlyVehicle = enemyVehicle[i].veh
|
|
ENDIF
|
|
|
|
// check to stop playback
|
|
IF DOES_ENTITY_EXIST(GET_PED_IN_VEHICLE_SEAT(enemyVehicle[i].veh, VS_DRIVER))
|
|
IF IS_PED_INJURED(GET_PED_IN_VEHICLE_SEAT(enemyVehicle[i].veh, VS_DRIVER))
|
|
IF IS_PLAYBACK_GOING_ON_FOR_VEHICLE(enemyVehicle[i].veh)
|
|
STOP_PLAYBACK_RECORDED_VEHICLE(enemyVehicle[i].veh)
|
|
CPRINTLN(DEBUG_MISSION, "BSW stopping playback 1 ")
|
|
ENDIF
|
|
|
|
IF IS_THIS_MODEL_A_HELI(GET_ENTITY_MODEL(enemyVehicle[i].veh))
|
|
IF NOT IS_TIMER_STARTED(tmrHeliExplode)
|
|
CPRINTLN(DEBUG_MISSION, "ENEMY_HELI - Starting heli out of control backup timer")
|
|
START_TIMER_NOW_SAFE(tmrHeliExplode)
|
|
ENDIF
|
|
SET_VEHICLE_OUT_OF_CONTROL(enemyVehicle[i].veh, FALSE)
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
|
|
BOOL bVehiclePed = FALSE
|
|
FOR j=-1 TO 2
|
|
PED_INDEX pedInVehicle = GET_PED_IN_VEHICLE_SEAT(enemyVehicle[i].veh, INT_TO_ENUM(VEHICLE_SEAT, j))
|
|
IF NOT IS_PED_INJURED(pedInVehicle)
|
|
bVehiclePed = TRUE
|
|
ENDIF
|
|
ENDFOR
|
|
|
|
IF NOT bVehiclePed
|
|
//IF DOES_BLIP_EXIST(enemyVehicle[i].blip)
|
|
// REMOVE_BLIP(enemyVehicle[i].blip)
|
|
SET_VEHICLE_CAN_BE_TARGETTED(enemyVehicle[i].veh, FALSE)
|
|
//ENDIF
|
|
ENDIF
|
|
|
|
// exploding
|
|
IF IS_THIS_MODEL_A_HELI(GET_ENTITY_MODEL(enemyVehicle[i].veh))
|
|
IF GET_TIMER_IN_SECONDS_SAFE(tmrHeliExplode) > 4
|
|
CPRINTLN(DEBUG_MISSION, "ENEMY_HELI - out of control backup timer got hit")
|
|
bDoExplode = TRUE
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF GET_ENTITY_HEALTH(enemyVehicle[i].veh) <= GET_ENEMY_VEHICLE_EXPLODE_HEALTH(thisVehicle)
|
|
OR IS_ENTITY_ON_FIRE(enemyVehicle[i].veh)
|
|
bDoExplode = TRUE
|
|
ENDIF
|
|
ELSE
|
|
// exploding
|
|
IF NOT IS_ENTITY_DEAD(enemyVehicle[i].veh)
|
|
IF NOT IS_THIS_MODEL_A_HELI(GET_ENTITY_MODEL(enemyVehicle[i].veh))
|
|
bDoExplode = TRUE
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
|
|
// handle explosions
|
|
IF bDoExplode
|
|
IF IS_PLAYBACK_GOING_ON_FOR_VEHICLE(enemyVehicle[i].veh)
|
|
SET_VEHICLE_CAN_BE_TARGETTED(enemyVehicle[i].veh, FALSE)
|
|
STOP_PLAYBACK_RECORDED_VEHICLE(enemyVehicle[i].veh)
|
|
CPRINTLN(DEBUG_MISSION, "BSW stopping playback 2")
|
|
ENDIF
|
|
|
|
IF NOT IS_THIS_MODEL_A_HELI(GET_ENTITY_MODEL(enemyVehicle[i].veh))
|
|
EXPLODE_VEHICLE(enemyVehicle[i].veh)
|
|
FOR j=-1 TO 2
|
|
PED_INDEX pedInVehicle = GET_PED_IN_VEHICLE_SEAT(enemyVehicle[i].veh, INT_TO_ENUM(VEHICLE_SEAT, j))
|
|
IF NOT IS_PED_INJURED(pedInVehicle)
|
|
APPLY_DAMAGE_TO_PED(pedInVehicle, 1000, TRUE)
|
|
ENDIF
|
|
ENDFOR
|
|
ELSE
|
|
SET_VEHICLE_ENGINE_HEALTH(enemyVehicle[i].veh, -150)
|
|
SET_VEHICLE_PETROL_TANK_HEALTH(enemyVehicle[i].veh, -150)
|
|
SET_VEHICLE_OUT_OF_CONTROL(enemyVehicle[i].veh, FALSE)
|
|
ENDIF
|
|
ENDIF
|
|
ENDFOR
|
|
ENDIF
|
|
|
|
FOR i=firstPed TO lastPed
|
|
IF NOT IS_PED_INJURED(enemyPed[i].ped)
|
|
iPedsAlive++
|
|
ENDIF
|
|
ENDFOR
|
|
|
|
FOR i=firstPed TO lastPed
|
|
ENEMY_PED_ENUM thisEnemyPed = INT_TO_ENUM(ENEMY_PED_ENUM, i)
|
|
|
|
IF NOT IS_PED_INJURED(enemyPed[i].ped)
|
|
// BLOCK WEAPON REACTIONS ON BALLISTIC ARMOUR - TEMP?
|
|
IF IS_ENEMY_PED_BALLISTIC_ARMOUR(thisEnemyPed)
|
|
SET_PED_RESET_FLAG(enemyPed[i].ped, PRF_BlockWeaponReactionsUnlessDead, TRUE)
|
|
ENDIF
|
|
|
|
ENEMY_TASK_TYPE thisTaskType
|
|
SWITCH thisEnemyPed
|
|
CASE EP_MERC_BATTLE_OUTSIDE_CHOPPER_1_PILOT
|
|
thisTaskType = TASK_TYPE_FLY_HELI
|
|
BREAK
|
|
CASE EP_MERC_BATTLE_OUTSIDE_CHOPPER_1_PASSBR
|
|
thisTaskType = TASK_TYPE_SHOOT_FROM_HELI
|
|
BREAK
|
|
DEFAULT
|
|
thisTaskType = TASK_TYPE_FOOT_COMBAT
|
|
BREAK
|
|
ENDSWITCH
|
|
|
|
SWITCH enemyPed[i].enemyTaskStatus
|
|
CASE ENEMY_TASK_STATUS_NO_TASK
|
|
BOOL bDoTask
|
|
bDoTask = FALSE
|
|
|
|
SWITCH thisTaskType
|
|
CASE TASK_TYPE_FOOT_COMBAT
|
|
CASE TASK_TYPE_FLY_HELI
|
|
IF IS_PED_IN_ANY_VEHICLE(enemyPed[i].ped)
|
|
VEHICLE_INDEX pedVehicle
|
|
pedVehicle = GET_VEHICLE_PED_IS_IN(enemyPed[i].ped)
|
|
IF IS_VEHICLE_DRIVEABLE(pedVehicle)
|
|
IF NOT IS_PLAYBACK_GOING_ON_FOR_VEHICLE(pedVehicle)
|
|
bDoTask = TRUE
|
|
ELIF pedVehicle = viEarlyVehicle
|
|
// we need this enemy to exit his vehicle quicker
|
|
IF GET_TIME_POSITION_IN_RECORDING(pedVehicle) + 4000 > GET_TOTAL_DURATION_OF_VEHICLE_RECORDING(006, GET_FINALE_RECORDING_PREFIX())
|
|
STOP_PLAYBACK_RECORDED_VEHICLE(pedVehicle)
|
|
//SET_VEHICLE_DOOR_OPEN(pedVehicle, SC_DOOR_FRONT_LEFT) //@SBA - hack so his arm doesn't clip door
|
|
CPRINTLN(DEBUG_MISSION,"Handling EV_MERC_UP_ROAD_4WD_2: Ending Car Recording")
|
|
bDoTask = TRUE
|
|
ENDIF
|
|
ENDIF
|
|
ELSE
|
|
bDoTask = TRUE
|
|
ENDIF
|
|
ELSE
|
|
IF NOT IS_ENTITY_ATTACHED(enemyPed[i].ped)
|
|
AND NOT enemyPed[i].bBlockTask
|
|
bDoTask = TRUE
|
|
ENDIF
|
|
ENDIF
|
|
BREAK
|
|
CASE TASK_TYPE_SHOOT_FROM_HELI
|
|
bDoTask = TRUE
|
|
BREAK
|
|
ENDSWITCH
|
|
|
|
IF bDoTask
|
|
SWITCH thisTaskType
|
|
CASE TASK_TYPE_FOOT_COMBAT
|
|
enemyPed[i].iTaskTime = GET_GAME_TIMER()
|
|
enemyPed[i].enemyTaskStatus = ENEMY_TASK_STATUS_COMBAT
|
|
BREAK
|
|
|
|
CASE TASK_TYPE_SHOOT_FROM_HELI
|
|
CPRINTLN(DEBUG_MISSION, "TASKING ped #", i, " shoot from heli")
|
|
SET_BLOCKING_OF_NON_TEMPORARY_EVENTS(enemyPed[i].ped, TRUE)
|
|
TASK_VEHICLE_SHOOT_AT_PED(enemyPed[i].ped, PLAYER_PED_ID())
|
|
enemyPed[i].enemyTaskStatus = ENEMY_TASK_STATUS_COMBAT
|
|
BREAK
|
|
|
|
CASE TASK_TYPE_FLY_HELI
|
|
enemyPed[i].enemyTaskStatus = ENEMY_TASK_STATUS_COMBAT
|
|
BREAK
|
|
ENDSWITCH
|
|
IF thisTaskType <> TASK_TYPE_SHOOT_FROM_HELI
|
|
SET_BLOCKING_OF_NON_TEMPORARY_EVENTS(enemyPed[i].ped, FALSE)
|
|
ENDIF
|
|
ENDIF
|
|
BREAK
|
|
|
|
CASE ENEMY_TASK_STATUS_FOLLOW_ROUTE
|
|
IF IS_WAYPOINT_PLAYBACK_GOING_ON_FOR_PED(enemyPed[i].ped)
|
|
WAYPOINT_PLAYBACK_START_AIMING_AT_COORD(enemyPed[thisEnemyPed].ped, GET_AIM_TARGET_FOR_SEARCHER(thisEnemyPed), TRUE)
|
|
ENDIF
|
|
BREAK
|
|
|
|
CASE ENEMY_TASK_STATUS_ENTERING_FOUNDRY
|
|
INT iNumSequenceSteps
|
|
IF waveEnum = EW_MERC_CATWALK
|
|
iNumSequenceSteps = 4
|
|
ELSE
|
|
iNumSequenceSteps = 3
|
|
ENDIF
|
|
|
|
IF enemyPed[i].iTaskTime + 1500 < GET_GAME_TIMER()
|
|
AND (GET_SEQUENCE_PROGRESS(enemyPed[thisEnemyPed].ped) > iNumSequenceSteps
|
|
OR ((waveEnum = EW_FIB_ATTACK_TREVOR_CLIMAX_1 OR waveEnum = EW_FIB_ATTACK_TREVOR_CLIMAX_2) AND IS_PLAYER_IN_TRIGGER_BOX(tbBottomExit2Buffer)))
|
|
CPRINTLN(DEBUG_MISSION, "BSW releasing entering ped #", i," to task combat")
|
|
enemyPed[i].iTaskTime = GET_GAME_TIMER()
|
|
CLEAR_PED_TASKS(enemyPed[thisEnemyPed].ped)
|
|
PUT_ENEMY_PED_IN_COMBAT(thisEnemyPed)
|
|
enemyPed[i].enemyTaskStatus = ENEMY_TASK_STATUS_COMBAT
|
|
ENDIF
|
|
BREAK
|
|
|
|
// this is getting hacky and complicated. simplify @BSW
|
|
CASE ENEMY_TASK_LEAVING_FORBIDDEN_ZONE
|
|
// if we're out of the forbidden zone OR it's been 5+ seconds since we tried to leave, go back to combat
|
|
// (if we change because of timer then TASK_STATUS_COMBAT will probably tell us to re-flee and come back here,
|
|
// which is good, we could use a re-tasking)
|
|
IF NOT IS_ENTITY_IN_TRIGGER_BOX(tbForbiddenZone, enemyPed[i].ped) OR GET_GAME_TIMER() > enemyPed[i].iTaskTime + 5000
|
|
CPRINTLN(DEBUG_MISSION, "BSW enemy #", i, " got out of the forbidden zone")
|
|
|
|
PUT_ENEMY_PED_IN_COMBAT(thisEnemyPed)
|
|
enemyPed[i].enemyTaskStatus = ENEMY_TASK_STATUS_COMBAT
|
|
ENDIF
|
|
BREAK
|
|
CASE ENEMY_TASK_STATUS_COMBAT
|
|
CASE ENEMY_TASK_STATUS_CHARGING
|
|
IF currentMissionStage < STAGE_SHOOTOUT_STAGE_4
|
|
IF IS_ENTITY_IN_TRIGGER_BOX(tbForbiddenZone, enemyPed[i].ped)
|
|
CPRINTLN(DEBUG_MISSION, "BSW tasking enemy #", i, " out of the forbidden zone")
|
|
TASK_SMART_FLEE_COORD(enemyPed[i].ped, <<1082.4788, -2007.3793, 29.8989>>, 15, INFINITE_TASK_TIME)
|
|
enemyPed[i].iTaskTime = GET_GAME_TIMER()
|
|
enemyPed[i].enemyTaskStatus = ENEMY_TASK_LEAVING_FORBIDDEN_ZONE
|
|
ENDIF
|
|
ENDIF
|
|
|
|
SWITCH thisTaskType
|
|
CASE TASK_TYPE_FOOT_COMBAT
|
|
IF enemyPed[i].enemyTaskStatus = ENEMY_TASK_STATUS_COMBAT
|
|
IF NOT IS_PED_IN_COMBAT(enemyPed[i].ped)
|
|
PUT_ENEMY_PED_IN_COMBAT(thisEnemyPed)
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF SHOULD_ENEMY_CHARGE(thisEnemyPed, iPedsAlive)
|
|
CPRINTLN(DEBUG_MISSION, "BSW setting enemy ped #", i, " to charge!")
|
|
TASK_ENEMY_PED_CHARGE_PED(thisEnemyPed, PLAYER_PED_ID())
|
|
SET_PED_CONFIG_FLAG(enemyPed[i].ped, PCF_ShouldChargeNow, TRUE)
|
|
ENDIF
|
|
BREAK
|
|
CASE TASK_TYPE_FLY_HELI
|
|
//TASK_HELI_MISSION(enemyPed[i].ped, GET_VEHICLE_PED_IS_IN(enemyPed[i].ped), NULL, NULL, GET_ENTITY_COORDS(enemyPed[i].ped), MISSION_GOTO, 5.0, 10.0, GET_ENTITY_HEADING(enemyPed[i].ped), 6, 6)
|
|
VEHICLE_INDEX viHeli
|
|
viHeli = GET_VEHICLE_PED_IS_IN(enemyPed[i].ped)
|
|
VECTOR vHeliWaypoint
|
|
vHeliWaypoint = <<1094.49023, -2045.41223, 42.0>>
|
|
SWITCH iHeliCombatState
|
|
CASE 0
|
|
SET_PED_SHOOT_RATE(enemyPed[i].ped, 100)
|
|
SET_PED_FIRING_PATTERN(enemyPed[i].ped, FIRING_PATTERN_BURST_FIRE_HELI)
|
|
SET_BLOCKING_OF_NON_TEMPORARY_EVENTS(enemyPed[i].ped, TRUE)
|
|
IF SET_CURRENT_PED_VEHICLE_WEAPON(enemyPed[i].ped, WEAPONTYPE_VEHICLE_PLAYER_BUZZARD)
|
|
CPRINTLN(DEBUG_MISSION, "Pilot weapon assigned! Going to start attack 1!")
|
|
ENDIF
|
|
iHeliCombatState++
|
|
BREAK
|
|
CASE 1
|
|
IF NOT IS_SCRIPT_TASK_RUNNING_OR_STARTING(enemyPed[i].ped, SCRIPT_TASK_VEHICLE_MISSION)
|
|
OR GET_GAME_TIMER() - iHeliAttackPause > 1000
|
|
//CPRINTLN(DEBUG_MISSION, "Pilot flying to coords!")
|
|
TASK_HELI_MISSION(enemyPed[i].ped, viHeli, NULL, NULL, vHeliWaypoint,
|
|
MISSION_GOTO, 5.0, 0.1, GET_HEADING_FROM_ENTITIES(viHeli, PLAYER_PED_ID()), 42, 5)
|
|
iHeliCombatState++
|
|
ENDIF
|
|
BREAK
|
|
CASE 2
|
|
IF IS_SCRIPT_TASK_RUNNING_OR_STARTING(enemyPed[i].ped, SCRIPT_TASK_VEHICLE_MISSION)
|
|
TASK_DRIVE_BY(enemyPed[i].ped, PLAYER_PED_ID(), null, <<0,0,0>>, 5000, 100, TRUE, FIRING_PATTERN_BURST_FIRE_HELI)
|
|
//CPRINTLN(DEBUG_MISSION, "Pilot attacking player!")
|
|
iHeliAttackPause = GET_GAME_TIMER()
|
|
iHeliCombatState--
|
|
ENDIF
|
|
BREAK
|
|
ENDSWITCH
|
|
BREAK
|
|
|
|
ENDSWITCH
|
|
BREAK
|
|
ENDSWITCH
|
|
ELSE
|
|
IF DOES_ENTITY_EXIST(enemyPed[i].ped)
|
|
IF NOT enemyPed[i].bRegisteredDead
|
|
IF HAS_ENTITY_BEEN_DAMAGED_BY_ENTITY(enemyPed[i].ped, PLAYER_PED_ID())
|
|
INFORM_MISSION_STATS_OF_INCREMENT(FIN_KILLS)
|
|
ENDIF
|
|
enemyPed[i].bRegisteredDead = TRUE
|
|
REMOVE_ENTITY_FROM_AUDIO_MIX_GROUP(enemyPed[i].ped)
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDFOR
|
|
|
|
RETURN iPedsAlive
|
|
ENDFUNC
|
|
|
|
// General stuff to clean up after Lamar is saved
|
|
PROC LAMAR_SAVED_CLEANUP()
|
|
CANCEL_TIMER(tmrLamarDies)
|
|
|
|
DELETE_ENEMY_WAVE(EW_FIB_STAGE2_INSIDE, TRUE)
|
|
DELETE_ENEMY_WAVE(EW_FIB_STAGE2_INSIDE_REINF, TRUE)
|
|
|
|
IF DOES_BLIP_EXIST(gotoBlip)
|
|
REMOVE_BLIP(gotoBlip)
|
|
ENDIF
|
|
|
|
IF NOT DOES_BLIP_EXIST(lamarBlip)
|
|
lamarBlip = CREATE_MISSION_BLIP_FOR_PED(lamarPed)
|
|
ENDIF
|
|
ENDPROC
|
|
|
|
// When Lamar's time is up, he dies
|
|
PROC HANDLE_KILLING_LAMAR()
|
|
IF IS_ENTITY_DEAD(lamarPed)
|
|
EXIT
|
|
ENDIF
|
|
|
|
IF TIMER_DO_WHEN_READY(tmrLamarDies, LAMAR_DEATH_TIME)
|
|
CPRINTLN(DEBUG_MISSION, "Lamar must die")
|
|
EXPLODE_PED_HEAD(lamarPed)
|
|
APPLY_DAMAGE_TO_PED(lamarPed, 1000, TRUE)
|
|
CANCEL_TIMER(tmrLamarDies)
|
|
REMOVE_ENTITY_FROM_AUDIO_MIX_GROUP(lamarPed)
|
|
ENDIF
|
|
ENDPROC
|
|
|
|
// check if player reached Lamar, do stuff if so
|
|
PROC HANDLE_GET_TO_LAMAR_SUCCESS()
|
|
IF bLamarWasSaved
|
|
EXIT
|
|
ENDIF
|
|
|
|
IF IS_PLAYER_IN_TRIGGER_BOX(tbBottomExit1Outer)
|
|
OR IS_PLAYER_IN_TRIGGER_BOX(tbSaveLamar)
|
|
CPRINTLN(DEBUG_MISSION, "Lamar Is Safe")
|
|
bLamarWasSaved = TRUE
|
|
|
|
LAMAR_SAVED_CLEANUP()
|
|
|
|
eShootout2CurrentText = SHOOTOUT_2_TEXT_FRANK_REACHES_LAMAR
|
|
ELSE
|
|
HANDLE_KILLING_LAMAR()
|
|
ENDIF
|
|
ENDPROC
|
|
|
|
// set characters hiding in cover
|
|
PROC SET_CHARACTERS_HIDING_IN_COVER(BOOL bClear = FALSE)
|
|
IF bClear
|
|
IF NOT IS_PED_INJURED(PLAYER_PED_ID())
|
|
AND NOT IS_PED_INJURED(sSelectorPeds.pedID[SELECTOR_PED_TREVOR])
|
|
AND NOT IS_PED_INJURED(sSelectorPeds.pedID[SELECTOR_PED_MICHAEL])
|
|
CLEAR_PED_TASKS_IMMEDIATELY(PLAYER_PED_ID())
|
|
SET_ENTITY_COORDS(PLAYER_PED_ID(), GET_FINALE_VECTOR(FINVEC_FRANKLIN_READY))
|
|
SET_ENTITY_HEADING(PLAYER_PED_ID(), FRANKLIN_READY_ROT)
|
|
TASK_CLEAR_LOOK_AT(PLAYER_PED_ID())
|
|
|
|
CLEAR_PED_TASKS_IMMEDIATELY(sSelectorPeds.pedID[SELECTOR_PED_TREVOR])
|
|
SET_ENTITY_COORDS(sSelectorPeds.pedID[SELECTOR_PED_TREVOR], GET_FINALE_VECTOR(FINVEC_TREVOR_READY))
|
|
SET_ENTITY_HEADING(sSelectorPeds.pedID[SELECTOR_PED_TREVOR], TREVOR_READY_ROT)
|
|
TASK_CLEAR_LOOK_AT(sSelectorPeds.pedID[SELECTOR_PED_TREVOR])
|
|
|
|
CLEAR_PED_TASKS_IMMEDIATELY(sSelectorPeds.pedID[SELECTOR_PED_MICHAEL])
|
|
SET_ENTITY_COORDS(sSelectorPeds.pedID[SELECTOR_PED_MICHAEL], GET_FINALE_VECTOR(FINVEC_MICHAEL_READY))
|
|
SET_ENTITY_HEADING(sSelectorPeds.pedID[SELECTOR_PED_MICHAEL], MICHAEL_READY_ROT)
|
|
TASK_CLEAR_LOOK_AT(sSelectorPeds.pedID[SELECTOR_PED_MICHAEL])
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF IS_ENTITY_OK(PLAYER_PED_ID())
|
|
TASK_PUT_PED_DIRECTLY_INTO_COVER(PLAYER_PED_ID(), GET_PLAYER_COVER_COORD(ENUM_TO_INT(SELECTOR_PED_FRANKLIN)), -1, FALSE, 0.0, TRUE, FALSE, initialCover[ENUM_TO_INT(SELECTOR_PED_FRANKLIN)])
|
|
SET_PED_USING_ACTION_MODE(PLAYER_PED_ID(), TRUE)
|
|
FORCE_PED_AI_AND_ANIMATION_UPDATE(PLAYER_PED_ID())
|
|
ENDIF
|
|
|
|
IF NOT IS_PED_INJURED(GET_MICHAEL_PED())
|
|
SET_PED_USING_ACTION_MODE(sSelectorPeds.pedID[SELECTOR_PED_MICHAEL], TRUE)
|
|
TASK_PUT_PED_DIRECTLY_INTO_COVER(GET_MICHAEL_PED(), GET_PLAYER_COVER_COORD(ENUM_TO_INT(SELECTOR_PED_MICHAEL)), -1, FALSE, 0.0, FALSE, FALSE, initialCover[ENUM_TO_INT(SELECTOR_PED_MICHAEL)])
|
|
FORCE_PED_AI_AND_ANIMATION_UPDATE(GET_MICHAEL_PED())
|
|
ENDIF
|
|
IF IS_ENTITY_OK(GET_TREVOR_PED())
|
|
SET_PED_USING_ACTION_MODE(GET_TREVOR_PED(), TRUE)
|
|
TASK_PUT_PED_DIRECTLY_INTO_COVER(GET_TREVOR_PED(), GET_PLAYER_COVER_COORD(ENUM_TO_INT(SELECTOR_PED_TREVOR)), -1, FALSE, 0.0, FALSE, FALSE, initialCover[ENUM_TO_INT(SELECTOR_PED_TREVOR)])
|
|
FORCE_PED_AI_AND_ANIMATION_UPDATE(GET_TREVOR_PED())
|
|
ENDIF
|
|
ENDPROC
|
|
|
|
// set player to combat
|
|
PROC SET_PLAYER_TO_COMBAT(MISSION_STAGE_ENUM thisStage)
|
|
IF bShootoutStarted
|
|
IF NOT IS_PED_INJURED(PLAYER_PED_ID())
|
|
IF NOT IS_PED_IN_COMBAT(PLAYER_PED_ID())
|
|
TASK_COMBAT_HATED_TARGETS_AROUND_PED(PLAYER_PED_ID(), 200)
|
|
ENDIF
|
|
FLOAT fRadius = 2.0
|
|
IF thisStage = STAGE_SHOOTOUT_STAGE_4
|
|
fRadius = 10
|
|
ENDIF
|
|
SET_PED_SPHERE_DEFENSIVE_AREA(PLAYER_PED_ID(), GET_ENTITY_COORDS(PLAYER_PED_ID()), fRadius)
|
|
ENDIF
|
|
ENDIF
|
|
ENDPROC
|
|
|
|
// blip all buddies
|
|
PROC BLIP_BUDDIES()
|
|
INT i
|
|
REPEAT 3 i
|
|
// remove blip if is the player's character
|
|
IF GET_PLAYER_PED_ENUM_FROM_SELECTOR_SLOT(INT_TO_ENUM(SELECTOR_SLOTS_ENUM, i)) = GET_CURRENT_PLAYER_PED_ENUM()
|
|
IF DOES_BLIP_EXIST(buddyBlip[i])
|
|
REMOVE_BLIP(buddyBlip[i])
|
|
ENDIF
|
|
ELSE
|
|
IF NOT DOES_BLIP_EXIST(buddyBlip[i])
|
|
buddyBlip[i] = CREATE_MISSION_BLIP_FOR_PED(sSelectorPeds.pedID[i])
|
|
ENDIF
|
|
ENDIF
|
|
ENDREPEAT
|
|
ENDPROC
|
|
|
|
PROC MAKE_COORD_BLIP_FRIENDLY(BLIP_INDEX &blipID)
|
|
IF DOES_BLIP_EXIST(blipID)
|
|
SET_BLIP_COLOUR(blipID, BLIP_COLOUR_BLUE)
|
|
SET_BLIP_PRIORITY(blipID, BLIPPRIORITY_HIGHEST)
|
|
ENDIF
|
|
ENDPROC
|
|
|
|
// room
|
|
CONST_FLOAT ROOM_LEFT -8.804
|
|
CONST_FLOAT ROOM_RIGHT 29.539
|
|
CONST_FLOAT ROOM_TOP 1.410
|
|
CONST_FLOAT ROOM_BOTTOM -18.237
|
|
|
|
CONST_FLOAT OBSTACLE_SAFE_ZONE 0.3
|
|
|
|
// bottom left walkway
|
|
CONST_FLOAT WALKWAY_1_TOP -9.302
|
|
CONST_FLOAT WALKWAY_1_LEFT 1.533
|
|
CONST_FLOAT WALKWAY_1_RIGHT 7.371
|
|
|
|
// bottom right walkway (includes tubes in bottom right
|
|
CONST_FLOAT WALKWAY_2_TOP -11.042
|
|
CONST_FLOAT WALKWAY_2_LEFT 11.316
|
|
CONST_FLOAT WALKWAY_2_RIGHT 30.0//19.449 not including tubes
|
|
|
|
// control hut
|
|
CONST_FLOAT CONTROL_HUT_RIGHT -4.769
|
|
CONST_FLOAT CONTROL_HUT_BOTTOM -3.121
|
|
|
|
// ground bucket
|
|
//CONST_FLOAT GROUND_BUCKET_LEFT 21.205
|
|
//CONST_FLOAT GROUND_BUCKET_RIGHT 26.175
|
|
//CONST_FLOAT GROUND_BUCKET_BOTTOM -4.169
|
|
|
|
// top corner
|
|
//CONST_FLOAT TOP_CORNER_LEFT 21.205
|
|
//CONST_FLOAT TOP_CORNER_BOTTOM 0.182
|
|
|
|
// top pipes
|
|
CONST_FLOAT TOP_PIPES_RIGHT 0.319
|
|
CONST_FLOAT TOP_PIPES_BOTTOM -0.068
|
|
|
|
// handle inside foundry
|
|
PROC HANDLE_INSIDE_FOUNDRY()
|
|
// set zoom level only once player is at foundry
|
|
IF currentMissionStage >= STAGE_SHOOTOUT_STAGE_1
|
|
AND currentMissionStage < STAGE_SHOOTOUT_STAGE_4
|
|
// pin interior
|
|
IF NOT bInteriorPinned
|
|
PIN_FOUNDRY_INTERIOR(TRUE)
|
|
ELSE
|
|
INT i
|
|
FOR i=0 TO 2
|
|
IF DOES_ENTITY_EXIST(interiorBarrelObject[i])
|
|
FORCE_ROOM_FOR_ENTITY(interiorBarrelObject[i], foundryInterior, GET_HASH_KEY("foundrymainrm"))
|
|
ENDIF
|
|
ENDFOR
|
|
ENDIF
|
|
|
|
SET_RADAR_AS_EXTERIOR_THIS_FRAME()
|
|
SET_RADAR_ZOOM_PRECISE(50)
|
|
ENDIF
|
|
|
|
ENDPROC
|
|
|
|
PROC ADD_MAIN_CHARACTERS_TO_BUDDY_AUDIO_MIX_GROUP()
|
|
|
|
IF IS_ENTITY_OK(sSelectorPeds.pedID[SELECTOR_PED_FRANKLIN])
|
|
ADD_ENTITY_TO_AUDIO_MIX_GROUP(sSelectorPeds.pedID[SELECTOR_PED_FRANKLIN], "FINALE_BUDDY_Group")
|
|
ENDIF
|
|
IF IS_ENTITY_OK(sSelectorPeds.pedID[SELECTOR_PED_MICHAEL])
|
|
ADD_ENTITY_TO_AUDIO_MIX_GROUP(sSelectorPeds.pedID[SELECTOR_PED_MICHAEL], "FINALE_BUDDY_Group")
|
|
ENDIF
|
|
IF IS_ENTITY_OK(sSelectorPeds.pedID[SELECTOR_PED_TREVOR])
|
|
ADD_ENTITY_TO_AUDIO_MIX_GROUP(sSelectorPeds.pedID[SELECTOR_PED_TREVOR], "FINALE_BUDDY_Group")
|
|
ENDIF
|
|
|
|
IF IS_ENTITY_OK(PLAYER_PED_ID())
|
|
REMOVE_ENTITY_FROM_AUDIO_MIX_GROUP(PLAYER_PED_ID())
|
|
ENDIF
|
|
|
|
ENDPROC
|
|
|
|
PROC STOP_THIS_AUDIO_SCENE(STRING sAudioScene)
|
|
IF IS_AUDIO_SCENE_ACTIVE(sAudioScene)
|
|
STOP_AUDIO_SCENE(sAudioScene)
|
|
ENDIF
|
|
ENDPROC
|
|
|
|
// handle the starting and stopping of audio scenes in the mission
|
|
PROC HANDLE_AUDIO_SCENES()
|
|
|
|
IF bAudioPlayNewWaveOneShot
|
|
// this is a one shot that stops itself
|
|
CPRINTLN(DEBUG_MISSION, "HANDLE_AUDIO_SCENES: firing off FINALE_ENEMIES_ARRIVE_ONESHOT.")
|
|
START_AUDIO_SCENE("FINALE_ENEMIES_ARRIVE_ONESHOT")
|
|
bAudioPlayNewWaveOneShot = FALSE
|
|
ENDIF
|
|
|
|
SWITCH eAudioSceneState
|
|
CASE AUDIO_IDLE
|
|
BREAK
|
|
|
|
CASE AUDIO_GO_TO_FOUNDRY
|
|
IF NOT IS_PED_INJURED(PLAYER_PED_ID())
|
|
IF IS_PED_SITTING_IN_ANY_VEHICLE(PLAYER_PED_ID())
|
|
IF NOT IS_AUDIO_SCENE_ACTIVE("FINALE_GET_TO_FOUNDRY")
|
|
START_AUDIO_SCENE("FINALE_GET_TO_FOUNDRY")
|
|
ENDIF
|
|
ELSE
|
|
STOP_THIS_AUDIO_SCENE("FINALE_GET_TO_FOUNDRY")
|
|
ENDIF
|
|
ENDIF
|
|
IF currentMissionStage = STAGE_MEET_GANG
|
|
CPRINTLN(DEBUG_MISSION, "HANDLE_AUDIO_SCENES: AUDIO_GO_TO_FOUNDRY --> AUDIO_ENTER_FOUNDRY")
|
|
eAudioSceneState = AUDIO_ENTER_FOUNDRY
|
|
ENDIF
|
|
BREAK
|
|
|
|
CASE AUDIO_ENTER_FOUNDRY
|
|
IF currentMissionStage = STAGE_MEET_GANG
|
|
IF lamarWalkStage >= LAMAR_WALK_IN_CAR
|
|
STOP_THIS_AUDIO_SCENE("FINALE_GET_TO_FOUNDRY")
|
|
ENDIF
|
|
ENDIF
|
|
IF NOT IS_PED_INJURED(PLAYER_PED_ID())
|
|
IF GET_INTERIOR_FROM_ENTITY(PLAYER_PED_ID()) <> NULL
|
|
STOP_THIS_AUDIO_SCENE("FINALE_GET_TO_FOUNDRY")
|
|
START_AUDIO_SCENE("FINALE_ENTER_FOUNDRY")
|
|
CPRINTLN(DEBUG_MISSION, "HANDLE_AUDIO_SCENES: AUDIO_ENTER_FOUNDRY --> AUDIO_WAIT_FOR_AMBUSH")
|
|
eAudioSceneState = AUDIO_WAIT_FOR_AMBUSH
|
|
ENDIF
|
|
ENDIF
|
|
BREAK
|
|
|
|
CASE AUDIO_WAIT_FOR_AMBUSH
|
|
IF currentMissionStage = STAGE_MEET_GANG
|
|
IF cutsceneStage = F_CUT_STAGE_RUNNING
|
|
STOP_THIS_AUDIO_SCENE("FINALE_ENTER_FOUNDRY")
|
|
ENDIF
|
|
ENDIF
|
|
IF currentMissionStage = STAGE_SHOOTOUT_STAGE_1
|
|
STOP_THIS_AUDIO_SCENE("FINALE_ENTER_FOUNDRY")
|
|
START_AUDIO_SCENE("FINALE_WAIT_FOR_AMBUSH")
|
|
CPRINTLN(DEBUG_MISSION, "HANDLE_AUDIO_SCENES: AUDIO_WAIT_FOR_AMBUSH --> AUDIO_AMBUSH_STARTS")
|
|
eAudioSceneState = AUDIO_AMBUSH_STARTS
|
|
ENDIF
|
|
BREAK
|
|
|
|
CASE AUDIO_AMBUSH_STARTS
|
|
IF bAudioStartShootout1
|
|
STOP_THIS_AUDIO_SCENE("FINALE_WAIT_FOR_AMBUSH")
|
|
START_AUDIO_SCENE("FINALE_SHOOTOUT_FIRST_WAVE")
|
|
bAudioStartShootout1 = FALSE
|
|
ENDIF
|
|
IF currentMissionStage = STAGE_SHOOTOUT_STAGE_2
|
|
CPRINTLN(DEBUG_MISSION, "HANDLE_AUDIO_SCENES: AUDIO_AMBUSH_STARTS --> AUDIO_GET_TO_LAMAR")
|
|
eAudioSceneState = AUDIO_GET_TO_LAMAR
|
|
ENDIF
|
|
BREAK
|
|
|
|
CASE AUDIO_GET_TO_LAMAR
|
|
IF bAudioGetToLamar
|
|
STOP_THIS_AUDIO_SCENE("FINALE_SHOOTOUT_FIRST_WAVE")
|
|
START_AUDIO_SCENE("FINALE_GET_TO_LAMAR")
|
|
bAudioGetToLamar = FALSE
|
|
CPRINTLN(DEBUG_MISSION, "HANDLE_AUDIO_SCENES: AUDIO_GET_TO_LAMAR --> AUDIO_SHOOT_OUT_WITH_LAMAR")
|
|
eAudioSceneState = AUDIO_SHOOT_OUT_WITH_LAMAR
|
|
ENDIF
|
|
BREAK
|
|
|
|
CASE AUDIO_SHOOT_OUT_WITH_LAMAR
|
|
IF eShootout2CurrentGoal = SHOOTOUT_2_OUTSIDE_1
|
|
STOP_THIS_AUDIO_SCENE("FINALE_GET_TO_LAMAR")
|
|
START_AUDIO_SCENE("FINALE_SHOOTOUT_WITH_LAMAR")
|
|
CPRINTLN(DEBUG_MISSION, "HANDLE_AUDIO_SCENES: AUDIO_SHOOT_OUT_WITH_LAMAR --> AUDIO_SAVE_TREVOR")
|
|
eAudioSceneState = AUDIO_SAVE_TREVOR
|
|
ENDIF
|
|
BREAK
|
|
|
|
CASE AUDIO_SAVE_TREVOR
|
|
IF currentMissionStage = STAGE_SHOOTOUT_STAGE_3
|
|
STOP_THIS_AUDIO_SCENE("FINALE_SHOOTOUT_WITH_LAMAR")
|
|
START_AUDIO_SCENE("FINALE_SAVE_TREVOR")
|
|
CPRINTLN(DEBUG_MISSION, "HANDLE_AUDIO_SCENES: AUDIO_SAVE_TREVOR --> AUDIO_GO_TO_EXIT")
|
|
eAudioSceneState = AUDIO_GO_TO_EXIT
|
|
ENDIF
|
|
BREAK
|
|
|
|
CASE AUDIO_GO_TO_EXIT
|
|
IF eShootout3CurrentGoal = SHOOTOUT_3_EXIT
|
|
STOP_THIS_AUDIO_SCENE("FINALE_SAVE_TREVOR")
|
|
START_AUDIO_SCENE("FINALE_GET_TO_EXIT")
|
|
CPRINTLN(DEBUG_MISSION, "HANDLE_AUDIO_SCENES: AUDIO_GO_TO_EXIT --> AUDIO_SHOOTOUT_OUTSIDE")
|
|
eAudioSceneState = AUDIO_SHOOTOUT_OUTSIDE
|
|
ENDIF
|
|
BREAK
|
|
|
|
CASE AUDIO_SHOOTOUT_OUTSIDE
|
|
IF bAudioStartShootout4
|
|
STOP_THIS_AUDIO_SCENE("FINALE_GET_TO_EXIT")
|
|
START_AUDIO_SCENE("FINALE_SHOOTOUT_OUTSIDE")
|
|
bAudioStartShootout4 = FALSE
|
|
ENDIF
|
|
IF bAudioHelicopterArrives
|
|
START_AUDIO_SCENE("FINALE_HELICOPTER_ARRIVES")
|
|
bAudioHelicopterArrives = FALSE
|
|
CPRINTLN(DEBUG_MISSION, "HANDLE_AUDIO_SCENES: AUDIO_HELICOPTER_ARRIVES --> AUDIO_FINISH_OUTSIDE_SHOOTOUT")
|
|
eAudioSceneState = AUDIO_FINISH_OUTSIDE_SHOOTOUT
|
|
ENDIF
|
|
BREAK
|
|
|
|
CASE AUDIO_FINISH_OUTSIDE_SHOOTOUT
|
|
IF DOES_ENTITY_EXIST(enemyVehicle[EV_MERC_BATTLE_OUTSIDE_CHOPPER_1].veh)
|
|
IF IS_ENTITY_DEAD(enemyVehicle[EV_MERC_BATTLE_OUTSIDE_CHOPPER_1].veh)
|
|
STOP_THIS_AUDIO_SCENE("FINALE_HELICOPTER_ARRIVES")
|
|
ENDIF
|
|
ENDIF
|
|
IF bAudioStopShootout4
|
|
STOP_THIS_AUDIO_SCENE("FINALE_SHOOTOUT_OUTSIDE")
|
|
bAudioStopShootout4 = FALSE
|
|
CPRINTLN(DEBUG_MISSION, "HANDLE_AUDIO_SCENES: AUDIO_FINISH_OUTSIDE_SHOOTOUT --> AUDIO_IDLE")
|
|
eAudioSceneState = AUDIO_IDLE
|
|
ENDIF
|
|
BREAK
|
|
|
|
ENDSWITCH
|
|
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_FOUNDRY
|
|
CASE STAGE_MEET_GANG
|
|
CASE STAGE_SHOOTOUT_STAGE_1
|
|
CASE STAGE_SHOOTOUT_STAGE_2
|
|
CASE STAGE_SHOOTOUT_STAGE_3
|
|
CASE STAGE_SHOOTOUT_STAGE_4
|
|
RETURN TRUE
|
|
BREAK
|
|
ENDSWITCH
|
|
|
|
RETURN FALSE
|
|
ENDFUNC
|
|
|
|
// clear the start area
|
|
PROC CLEAR_START_AREA()
|
|
// clear init areas
|
|
CLEAR_INIT_POS(GET_FINALE_VECTOR(FINVEC_PLAYER_INIT))
|
|
CLEAR_INIT_POS(GET_FINALE_VECTOR(FINVEC_LAMAR_INIT))
|
|
CLEAR_INIT_POS(GET_FINALE_VECTOR(FINVEC_LESTERS_CAR_INIT))
|
|
//WAIT(0)
|
|
ENDPROC
|
|
|
|
// do a hint on hud
|
|
PROC DO_MISSION_HINT(SELECTOR_SLOTS_ENUM thisPed)
|
|
INT i
|
|
FOR i=0 TO 2
|
|
SELECTOR_SLOTS_ENUM sPed = INT_TO_ENUM(SELECTOR_SLOTS_ENUM, i)
|
|
IF sPed = thisPed
|
|
SET_SELECTOR_PED_HINT(sSelectorPeds, sPed, TRUE)
|
|
ELSE
|
|
SET_SELECTOR_PED_HINT(sSelectorPeds, sPed, FALSE)
|
|
ENDIF
|
|
ENDFOR
|
|
ENDPROC
|
|
|
|
// clear hud hint
|
|
PROC CLEAR_ALL_MISSION_HINTS()
|
|
INT i
|
|
FOR i=0 TO 2
|
|
SELECTOR_SLOTS_ENUM sPed = INT_TO_ENUM(SELECTOR_SLOTS_ENUM, i)
|
|
SET_SELECTOR_PED_HINT(sSelectorPeds, sPed, FALSE)
|
|
ENDFOR
|
|
ENDPROC
|
|
|
|
PROC CLEAR_PED_MISSION_HINT(SELECTOR_SLOTS_ENUM thisPed)
|
|
SET_SELECTOR_PED_HINT(sSelectorPeds, thisPed, FALSE)
|
|
ENDPROC
|
|
|
|
PROC SET_UP_RELATIONSHIP_GROUPS()
|
|
REMOVE_RELATIONSHIP_GROUP(relgroupIgnore)
|
|
ADD_RELATIONSHIP_GROUP("IgnoreGroup", relgroupIgnore)
|
|
|
|
SET_RELATIONSHIP_BETWEEN_GROUPS(ACQUAINTANCE_TYPE_PED_LIKE, relgroupIgnore, RELGROUPHASH_PLAYER)
|
|
SET_RELATIONSHIP_BETWEEN_GROUPS(ACQUAINTANCE_TYPE_PED_LIKE, RELGROUPHASH_PLAYER, relgroupIgnore)
|
|
|
|
SET_RELATIONSHIP_BETWEEN_GROUPS(ACQUAINTANCE_TYPE_PED_IGNORE, RELGROUPHASH_HATES_PLAYER, relgroupIgnore)
|
|
SET_RELATIONSHIP_BETWEEN_GROUPS(ACQUAINTANCE_TYPE_PED_HATE, relgroupIgnore, RELGROUPHASH_HATES_PLAYER)
|
|
ENDPROC
|
|
|
|
PROC HANDLE_TREVOR_INJURED()
|
|
|
|
SWITCH eTrevorInjuredState
|
|
|
|
CASE TREV_INJURED_SETUP
|
|
IF IS_ENTITY_OK(sSelectorPeds.pedID[SELECTOR_PED_TREVOR])
|
|
CPRINTLN(DEBUG_MISSION, "HANDLE_TREVOR_INJURED: Setting up Trevor injured state")
|
|
|
|
SET_ENTITY_ONLY_DAMAGED_BY_PLAYER(GET_TREVOR_PED(), TRUE)
|
|
|
|
STOP_PED_SPEAKING(sSelectorPeds.pedID[SELECTOR_PED_TREVOR], TRUE)
|
|
|
|
SET_SELECTOR_PED_BLOCKED(sSelectorPeds, SELECTOR_PED_TREVOR, TRUE)
|
|
|
|
SET_PED_RELATIONSHIP_GROUP_HASH(sSelectorPeds.pedID[SELECTOR_PED_TREVOR], relgroupIgnore)
|
|
|
|
TASK_PUT_PED_DIRECTLY_INTO_COVER(sSelectorPeds.pedID[SELECTOR_PED_TREVOR], GET_SCRIPTED_COVER_POINT_COORDS(trevorInjuredCover), INFINITE_TASK_TIME, FALSE, DEFAULT, TRUE, FALSE, trevorInjuredCover)
|
|
|
|
bTrevorIsInjured = TRUE
|
|
|
|
eAllyStates[SELECTOR_PED_TREVOR].currentState = ALLY_STATE_INJURED
|
|
|
|
START_TIMER_NOW_SAFE(tmrTrevorInjuredFailTime)
|
|
|
|
eTrevorInjuredState = TREV_INJURED_WAITING
|
|
ENDIF
|
|
BREAK
|
|
|
|
CASE TREV_INJURED_WAITING
|
|
CASE TREV_INJURED_VULNERABLE
|
|
IF GET_TIMER_IN_SECONDS_SAFE(tmrTrevorInjuredFailTime) > 50
|
|
CPRINTLN(DEBUG_MISSION, "BSW time to kill Trevor")
|
|
ENEMY_PED_ENUM eExecutionerIndex
|
|
eExecutionerIndex = GET_EXECUTIONER_FOR_TREVOR()
|
|
IF IS_ENTITY_OK(enemyPed[eExecutionerIndex].ped)
|
|
RESTART_TIMER_NOW(tmrTrevorInjuredFailTime)
|
|
TASK_ENEMY_PED_CHARGE_PED(eExecutionerIndex, GET_TREVOR_PED())
|
|
ENDIF
|
|
|
|
SET_ENTITY_ONLY_DAMAGED_BY_PLAYER(GET_TREVOR_PED(), FALSE)
|
|
SET_PED_MAX_HEALTH(GET_TREVOR_PED(), GET_ENTITY_MAX_HEALTH(GET_TREVOR_PED()))
|
|
SET_ENTITY_HEALTH(GET_TREVOR_PED(), GET_ENTITY_MAX_HEALTH(GET_TREVOR_PED()))
|
|
|
|
SET_PED_RELATIONSHIP_GROUP_HASH(sSelectorPeds.pedID[SELECTOR_PED_TREVOR], RELGROUPHASH_PLAYER)
|
|
|
|
eTrevorInjuredState = TREV_INJURED_VULNERABLE
|
|
ENDIF
|
|
|
|
IF (GET_ENTITY_HEALTH(GET_TREVOR_PED()) < GET_ENTITY_MAX_HEALTH(GET_TREVOR_PED()) AND eTrevorInjuredState = TREV_INJURED_VULNERABLE)
|
|
OR IS_PLAYER_IN_TRIGGER_BOX(tbBottomExit1Inner)
|
|
OR IS_PLAYER_IN_TRIGGER_BOX(tbBottomExit2Outer)
|
|
OR IS_PLAYER_IN_TRIGGER_BOX(tbTopExitOuter)
|
|
CPRINTLN(DEBUG_MISSION, "BSW failing because trevor died")
|
|
MISSION_FAILED(FAIL_TREVOR_DEAD)
|
|
ENDIF
|
|
|
|
IF eShootout3CurrentGoal >= SHOOTOUT_3_ATTACK_3
|
|
START_TIMER_NOW(tmrTrevorGetUpDelay)
|
|
// Pause for dialog timing
|
|
IF TIMER_DO_ONCE_WHEN_READY(tmrTrevorGetUpDelay, 3.500)
|
|
CPRINTLN(DEBUG_MISSION, "HANDLE_TREVOR_INJURED: Getting Trevor up")
|
|
CLEAR_TREVOR_INJURED()
|
|
|
|
eTrevorInjuredState = TREV_INJURED_RESCUED
|
|
ENDIF
|
|
ENDIF
|
|
BREAK
|
|
|
|
CASE TREV_INJURED_RESCUED
|
|
IF CAN_UNBLOCK_TREVOR_SELECTOR()
|
|
CPRINTLN(DEBUG_MISSION, "HANDLE_TREVOR_INJURED: bTrevorIsInjured = FALSE")
|
|
SET_SELECTOR_PED_BLOCKED(sSelectorPeds, SELECTOR_PED_TREVOR, FALSE)
|
|
sSelectorPeds.pedID[SELECTOR_PED_TREVOR] = GET_TREVOR_PED()
|
|
|
|
IF GET_CURRENT_PLAYER_PED_ENUM() = CHAR_TREVOR
|
|
SET_PLAYER_CONTROL(PLAYER_ID(), TRUE)
|
|
ENDIF
|
|
|
|
eAllyStates[SELECTOR_PED_TREVOR].currentState = ALLY_STATE_COMBAT_INIT
|
|
|
|
bTrevorIsInjured = FALSE
|
|
eTrevorInjuredState = TREV_INJURED_IDLE
|
|
ENDIF
|
|
BREAK
|
|
|
|
CASE TREV_INJURED_IDLE
|
|
BREAK
|
|
|
|
ENDSWITCH
|
|
ENDPROC
|
|
|
|
PROC SETUP_PLAYERS_FOR_SHOOTOUT_3(BOOL bTrevorInjured = TRUE)
|
|
// michael
|
|
IF IS_ENTITY_OK(GET_MICHAEL_PED())
|
|
CPRINTLN(DEBUG_MISSION, "Putting Michael in position")
|
|
CLEAR_PED_TASKS_IMMEDIATELY(GET_MICHAEL_PED())
|
|
SET_ENTITY_COORDS(GET_MICHAEL_PED(), GET_FINALE_VECTOR(FINVEC_MICHAEL_READY))
|
|
SET_ENTITY_HEADING(GET_MICHAEL_PED(), 323.6475) //MICHAEL_READY_ROT)
|
|
|
|
IF NOT IS_PED_USING_ACTION_MODE(GET_MICHAEL_PED())
|
|
CPRINTLN(DEBUG_MISSION, "Putting Michael in action mode")
|
|
SET_PED_USING_ACTION_MODE(GET_MICHAEL_PED(), TRUE)
|
|
ENDIF
|
|
|
|
TASK_PUT_PED_DIRECTLY_INTO_COVER(GET_MICHAEL_PED(), GET_PLAYER_COVER_COORD(ENUM_TO_INT(SELECTOR_PED_MICHAEL)), -1, FALSE, 0.0, FALSE, FALSE, initialCover[ENUM_TO_INT(SELECTOR_PED_MICHAEL)])
|
|
FORCE_PED_AI_AND_ANIMATION_UPDATE(GET_MICHAEL_PED())
|
|
|
|
FORCE_ROOM_FOR_ENTITY(GET_MICHAEL_PED(), foundryInterior, GET_HASH_KEY("foundrymainrm"))
|
|
ENDIF
|
|
|
|
// trevor
|
|
IF IS_ENTITY_OK(sSelectorPeds.pedID[SELECTOR_PED_TREVOR])
|
|
CPRINTLN(DEBUG_MISSION, "Puting Trevor in posiiton")
|
|
CLEAR_PED_TASKS_IMMEDIATELY(sSelectorPeds.pedID[SELECTOR_PED_TREVOR])
|
|
SET_ENTITY_COORDS(sSelectorPeds.pedID[SELECTOR_PED_TREVOR], GET_FINALE_VECTOR(FINVEC_TREVOR_SAVETREVOR))
|
|
SET_ENTITY_HEADING(sSelectorPeds.pedID[SELECTOR_PED_TREVOR], TREVOR_SAVETREVOR_ROT)
|
|
|
|
FORCE_ROOM_FOR_ENTITY(GET_TREVOR_PED(), foundryInterior, GET_HASH_KEY("foundrymainrm"))
|
|
|
|
IF bTrevorInjured
|
|
eTrevorInjuredState = TREV_INJURED_SETUP
|
|
// update state machine
|
|
HANDLE_TREVOR_INJURED()
|
|
ENDIF
|
|
ENDIF
|
|
ENDPROC
|
|
|
|
enumCharacterList endcutStreamedChar
|
|
PROC HANDLE_END_CUTSCENE()
|
|
SWITCH endcutStreamingStage
|
|
CASE MOCAP_STREAMING_STAGE_REQUEST
|
|
endcutStreamedChar = GET_CURRENT_PLAYER_PED_ENUM()
|
|
IF IS_ENTITY_AT_COORD(PLAYER_PED_ID(), GET_FINALE_VECTOR(FINVEC_REGROUP), <<120, 120, 120>>)
|
|
CUTSCENE_SECTION thisSection
|
|
IF endcutStreamedChar = CHAR_FRANKLIN
|
|
thisSection = cs_section_1 | cs_section_4 | cs_section_5 | cs_section_6 | cs_section_7
|
|
ELIF endcutStreamedChar = CHAR_MICHAEL
|
|
thisSection = cs_section_3 | cs_section_4 | cs_section_5 | cs_section_6 | cs_section_7
|
|
ELSE
|
|
thisSection = cs_section_2 | cs_section_4 | cs_section_5 | cs_section_6 | cs_section_7
|
|
ENDIF
|
|
REQUEST_CUTSCENE_WITH_PLAYBACK_LIST("fin_c_ext", thisSection)
|
|
//thisSection=thisSection
|
|
//REQUEST_CUTSCENE("fin_c_ext")
|
|
endcutStreamingStage = MOCAP_STREAMING_STAGE_WAIT
|
|
ENDIF
|
|
BREAK
|
|
CASE MOCAP_STREAMING_STAGE_WAIT
|
|
IF HAS_CUTSCENE_LOADED()
|
|
endcutStreamingStage = MOCAP_STREAMING_STAGE_COMPLETE
|
|
ENDIF
|
|
BREAK
|
|
CASE MOCAP_STREAMING_STAGE_COMPLETE
|
|
IF NOT IS_ENTITY_AT_COORD(PLAYER_PED_ID(), GET_FINALE_VECTOR(FINVEC_REGROUP), <<150, 150, 150>>)
|
|
REMOVE_CUTSCENE()
|
|
endcutStreamingStage = MOCAP_STREAMING_STAGE_REQUEST
|
|
ENDIF
|
|
BREAK
|
|
ENDSWITCH
|
|
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 bUseAutomaticStreaming = TRUE, BOOL bHandleFadeIn = TRUE)
|
|
IF bJumpingToStage
|
|
VECTOR vStartPos
|
|
INT i
|
|
|
|
// clear area to load scene around start pos
|
|
SET_PLAYER_OUT_OF_ANY_VEHICLE()
|
|
|
|
// set the correct player character if not already
|
|
enumCharacterList stageCharacter = GET_CHARACTER_FOR_MISSION_STAGE(setStage)
|
|
SELECTOR_SLOTS_ENUM selectorSlot = GET_SELECTOR_SLOT_FROM_PLAYER_PED_ENUM(stageCharacter)
|
|
|
|
IF GET_CURRENT_PLAYER_PED_ENUM() <> stageCharacter
|
|
WHILE NOT CREATE_PLAYER_PED_ON_FOOT(sSelectorPeds.pedID[selectorSlot], stageCharacter, GET_ENTITY_COORDS(PLAYER_PED_ID()), GET_ENTITY_HEADING(PLAYER_PED_ID()), FALSE)
|
|
WAIT(0)
|
|
ENDWHILE
|
|
WHILE NOT MAKE_SELECTOR_PED_SELECTION(sSelectorPeds, selectorSlot)
|
|
WAIT(0)
|
|
ENDWHILE
|
|
WHILE NOT TAKE_CONTROL_OF_SELECTOR_PED(sSelectorPeds, TRUE)
|
|
WAIT(0)
|
|
ENDWHILE
|
|
REPEAT 3 i
|
|
IF DOES_ENTITY_EXIST(sSelectorPeds.pedID[i])
|
|
DELETE_PED(sSelectorPeds.pedID[i])
|
|
ENDIF
|
|
ENDREPEAT
|
|
|
|
ENDIF
|
|
|
|
// Replay setup
|
|
SWITCH setStage
|
|
CASE STAGE_GET_TO_FOUNDRY
|
|
vStartPos = GET_FINALE_VECTOR(FINVEC_PLAYER_INIT)
|
|
IF IS_REPLAY_IN_PROGRESS()
|
|
START_REPLAY_SETUP(vStartPos, PLAYER_INIT_ROT)
|
|
ENDIF
|
|
BREAK
|
|
CASE STAGE_MEET_GANG
|
|
vStartPos = GET_FINALE_VECTOR(FINVEC_PARK)
|
|
IF IS_REPLAY_IN_PROGRESS()
|
|
START_REPLAY_SETUP(vStartPos, PLAYER_INIT_ROT)
|
|
ENDIF
|
|
BREAK
|
|
CASE STAGE_SHOOTOUT_STAGE_1
|
|
vStartPos = GET_PLAYER_COVER_COORD(ENUM_TO_INT(SELECTOR_PED_FRANKLIN))
|
|
IF IS_REPLAY_IN_PROGRESS()
|
|
START_REPLAY_SETUP(vStartPos, FRANKLIN_READY_ROT)
|
|
ENDIF
|
|
BREAK
|
|
CASE STAGE_SHOOTOUT_STAGE_2
|
|
vStartPos = <<1105.36, -2004.70, 28.44>>
|
|
IF IS_REPLAY_IN_PROGRESS()
|
|
START_REPLAY_SETUP(vStartPos, FRANKLIN_READY_ROT)
|
|
ENDIF
|
|
BREAK
|
|
CASE STAGE_SHOOTOUT_STAGE_3
|
|
vStartPos = <<1105.36, -2004.70, 28.44>>
|
|
IF IS_REPLAY_IN_PROGRESS()
|
|
START_REPLAY_SETUP(vStartPos, MICHAEL_READY_ROT)
|
|
ENDIF
|
|
BREAK
|
|
CASE STAGE_SHOOTOUT_STAGE_4
|
|
vStartPos = GET_FINALE_VECTOR(FINVEC_MICHAEL_GROUND_READY)
|
|
IF IS_REPLAY_IN_PROGRESS()
|
|
START_REPLAY_SETUP(vStartPos, MICHAEL_GROUND_READY_ROT)
|
|
ENDIF
|
|
BREAK
|
|
ENDSWITCH
|
|
|
|
// clear area for replay
|
|
IF bClearMap
|
|
CLEAR_AREA(vStartPos, 10000, TRUE)
|
|
ENDIF
|
|
WAIT(0)
|
|
|
|
// set to coords and wait for streaming
|
|
IF NOT IS_REPLAY_BEING_SET_UP()
|
|
SET_ENTITY_COORDS(PLAYER_PED_ID(), vStartPos)
|
|
IF NOT bForcePassOnShitskip
|
|
WHILE IS_NETWORK_LOADING_SCENE()
|
|
WAIT(0)
|
|
ENDWHILE
|
|
LOAD_SCENE(vStartPos)
|
|
WAIT(0)
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF bJumpingToStage
|
|
CPRINTLN(DEBUG_MISSION, "SET_MISSION_STAGE identifying foundryInterior")
|
|
|
|
IF setStage >= STAGE_MEET_GANG
|
|
AND setStage < STAGE_OUTRO_CUTSCENE
|
|
SET_INTERIOR_CAPPED(INTERIOR_V_FOUNDRY, FALSE)
|
|
ENDIF
|
|
|
|
// doors
|
|
IF setStage >= STAGE_SHOOTOUT_STAGE_1
|
|
AND setStage < STAGE_OUTRO_CUTSCENE
|
|
SET_DOOR_STATE(DOORNAME_FOUNDRY_B_01, DOORSTATE_UNLOCKED)
|
|
SET_DOOR_STATE(DOORNAME_FOUNDRY_B_02, DOORSTATE_UNLOCKED)
|
|
SET_DOOR_STATE(DOORNAME_FOUNDRY_T_01, DOORSTATE_UNLOCKED)
|
|
ENDIF
|
|
ENDIF
|
|
|
|
SET_DOOR_STATE(DOORNAME_LESTER_F, DOORSTATE_LOCKED)
|
|
|
|
IF setStage >= STAGE_SHOOTOUT_STAGE_1 AND setStage <= STAGE_SHOOTOUT_STAGE_3
|
|
// ensure foundry interior is in memory
|
|
PIN_FOUNDRY_INTERIOR(TRUE)
|
|
// "lock" the doors!
|
|
CREATE_BLOCKING_OBJECTS()
|
|
ELSE
|
|
PIN_FOUNDRY_INTERIOR(FALSE)
|
|
ENDIF
|
|
|
|
|
|
IF bUseAutomaticStreaming
|
|
// 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 waypoints and force their load
|
|
REQUEST_WAYPOINT_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 sfx and force their load
|
|
REQUEST_SFX_FOR_STAGE(setStage, TRUE, FALSE)
|
|
ENDIF
|
|
|
|
// request all the vehicle models for replays etc
|
|
IF bJumpingToStage
|
|
// do we need a replay vehicle
|
|
BOOL bRequestReplayCheckpointVehicle = FALSE
|
|
BOOL bRequestReplayStartVehicle = FALSE
|
|
|
|
IF setStage = STAGE_GET_TO_FOUNDRY
|
|
IF IS_REPLAY_BEING_SET_UP()
|
|
IF SHOULD_USE_REPLAY_VEHICLE(setStage)
|
|
bRequestReplayStartVehicle = TRUE
|
|
REQUEST_REPLAY_CHECKPOINT_VEHICLE_MODEL()
|
|
ENDIF
|
|
ENDIF
|
|
ELIF setStage <= STAGE_SHOOTOUT_STAGE_4
|
|
IF IS_REPLAY_BEING_SET_UP()
|
|
IF IS_REPLAY_CHECKPOINT_VEHICLE_AVAILABLE()
|
|
bRequestReplayCheckpointVehicle = TRUE
|
|
REQUEST_REPLAY_CHECKPOINT_VEHICLE_MODEL()
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
|
|
// wait for them all to load in
|
|
IF IS_SCREEN_FADED_OUT()
|
|
LOAD_ALL_OBJECTS_NOW()
|
|
ENDIF
|
|
|
|
WHILE NOT HAVE_ALL_MODEL_REQUESTS_SUCCEEDED()
|
|
WAIT(0)
|
|
ENDWHILE
|
|
IF bRequestReplayCheckpointVehicle
|
|
WHILE NOT HAS_REPLAY_CHECKPOINT_VEHICLE_LOADED()
|
|
WAIT(0)
|
|
ENDWHILE
|
|
ENDIF
|
|
IF bRequestReplayStartVehicle
|
|
WHILE NOT HAS_REPLAY_CHECKPOINT_VEHICLE_LOADED()
|
|
WAIT(0)
|
|
ENDWHILE
|
|
ENDIF
|
|
ENDIF
|
|
|
|
// get the text and force its load
|
|
REQUEST_TEXT(TRUE)
|
|
|
|
// reset mocap streaming
|
|
IF setStage < STAGE_OUTRO_CUTSCENE
|
|
REMOVE_CUTSCENE()
|
|
mocapStreamingStage = MOCAP_STREAMING_STAGE_REQUEST
|
|
ENDIF
|
|
|
|
// reset vars
|
|
RESET_VARIABLES_FOR_STAGE(setStage)
|
|
|
|
#IF IS_DEBUG_BUILD
|
|
bDebugJSkip = FALSE
|
|
#ENDIF
|
|
|
|
// get rid of blips and text
|
|
IF bJumpingToStage
|
|
OR setStage <> STAGE_SHOOTOUT_STAGE_4
|
|
REMOVE_ALL_BLIPS()
|
|
ENDIF
|
|
|
|
IF setStage >= STAGE_SHOOTOUT_STAGE_1 AND setStage <= STAGE_SHOOTOUT_STAGE_4
|
|
SET_PED_DENSITY_MULTIPLIER_THIS_FRAME(0.0)
|
|
SET_VEHICLE_DENSITY_MULTIPLIER_THIS_FRAME(0.0)
|
|
ENDIF
|
|
|
|
REMOVE_MISSION_TEXT(bClearTextAndSpeech OR bJumpingToStage, bClearTextAndSpeech OR bJumpingToStage)
|
|
|
|
|
|
IF bJumpingToStage
|
|
OR bInitialisingAfterIntro
|
|
// remove all dialogue
|
|
INT k
|
|
IF bJumpingToStage
|
|
FOR k=0 TO 9
|
|
REMOVE_PED_FOR_DIALOGUE(finaleConversation, k)
|
|
ENDFOR
|
|
ENDIF
|
|
|
|
SET_UP_RELATIONSHIP_GROUPS()
|
|
|
|
// setup player with dialogue
|
|
SWITCH GET_CURRENT_PLAYER_PED_ENUM()
|
|
CASE CHAR_MICHAEL
|
|
ADD_PED_FOR_DIALOGUE(finaleConversation, 0, PLAYER_PED_ID(), "MICHAEL")
|
|
BREAK
|
|
CASE CHAR_TREVOR
|
|
ADD_PED_FOR_DIALOGUE(finaleConversation, 1, PLAYER_PED_ID(), "TREVOR")
|
|
BREAK
|
|
CASE CHAR_FRANKLIN
|
|
ADD_PED_FOR_DIALOGUE(finaleConversation, 2, PLAYER_PED_ID(), "FRANKLIN")
|
|
BREAK
|
|
ENDSWITCH
|
|
|
|
// @SBA - Best spot for this?
|
|
END_REPLAY_SETUP(NULL, VS_DRIVER, FALSE)
|
|
|
|
CREATE_EXTERIOR_PROPS()
|
|
|
|
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))
|
|
|
|
IF bJumpingToStage
|
|
IF IS_SCREEN_FADED_OUT()
|
|
LOAD_ALL_OBJECTS_NOW()
|
|
ENDIF
|
|
|
|
IF IS_ENTITY_OK(PLAYER_PED_ID())
|
|
WHILE NOT HAVE_ALL_STREAMING_REQUESTS_COMPLETED(PLAYER_PED_ID())
|
|
WAIT(0)
|
|
ENDWHILE
|
|
ENDIF
|
|
ENDIF
|
|
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_FOUNDRY
|
|
IF bJumpingToStage
|
|
POSITION_PLAYER_AT_MISSION_INIT()
|
|
ENDIF
|
|
CREATE_LAMAR_FOR_STAGE(STAGE_GET_TO_FOUNDRY)
|
|
BREAK
|
|
|
|
CASE STAGE_MEET_GANG
|
|
IF bJumpingToStage
|
|
IF CREATE_LAMAR_FOR_STAGE(STAGE_MEET_GANG, TRUE)
|
|
|
|
eAudioSceneState = AUDIO_ENTER_FOUNDRY
|
|
|
|
DOOR_SYSTEM_SET_OPEN_RATIO(ENUM_TO_INT(DOORHASH_FOUNDRY_B_01), 0.2, FALSE, FALSE)
|
|
|
|
ENDIF
|
|
ENDIF
|
|
BREAK
|
|
|
|
CASE STAGE_SHOOTOUT_STAGE_1
|
|
SET_INSTANCE_PRIORITY_HINT(INSTANCE_HINT_SHOOTING)
|
|
|
|
ADD_PED_FOR_DIALOGUE(finaleConversation, 8, NULL, "LAMAR")
|
|
|
|
eAllyStates[SELECTOR_PED_MICHAEL].currentState = ALLY_STATE_AMBUSH
|
|
eAllyStates[SELECTOR_PED_TREVOR].currentState = ALLY_STATE_AMBUSH
|
|
eAllyStates[SELECTOR_PED_FRANKLIN].currentState = ALLY_STATE_AMBUSH
|
|
|
|
IF bJumpingToStage
|
|
CREATE_ENEMY_WAVE(EW_FIB_SEARCH, TRUE)
|
|
CREATE_INTERIOR_PROPS()
|
|
SET_FIB_TO_SEARCH()
|
|
eAudioSceneState = AUDIO_WAIT_FOR_AMBUSH
|
|
ENDIF
|
|
BLIP_BUDDIES()
|
|
|
|
IF bJumpingToStage
|
|
SET_CHARACTERS_HIDING_IN_COVER()
|
|
ENDIF
|
|
|
|
IF NOT bJumpingToStage
|
|
REAPPLY_PLAYER_PED_ATTRIBUTES(setStage)
|
|
ENDIF
|
|
|
|
// buddy mix group
|
|
ADD_MAIN_CHARACTERS_TO_BUDDY_AUDIO_MIX_GROUP()
|
|
|
|
IF bJumpingToStage
|
|
TRIGGER_MUSIC_EVENT("FIN1_SO_1_RT")
|
|
ELSE
|
|
TRIGGER_MUSIC_EVENT("FIN1_BEFORE_GUNS")
|
|
ENDIF
|
|
BREAK
|
|
CASE STAGE_SHOOTOUT_STAGE_2
|
|
IF bJumpingToStage
|
|
SET_CHARACTERS_HIDING_IN_COVER()
|
|
CREATE_INTERIOR_PROPS()
|
|
ENDIF
|
|
|
|
IF NOT bJumpingToStage
|
|
REAPPLY_PLAYER_PED_ATTRIBUTES(setStage)
|
|
ENDIF
|
|
|
|
eAllyStates[SELECTOR_PED_MICHAEL].currentState = ALLY_STATE_COMBAT_INIT
|
|
eAllyStates[SELECTOR_PED_TREVOR].currentState = ALLY_STATE_COMBAT_INIT
|
|
eAllyStates[SELECTOR_PED_FRANKLIN].currentState = ALLY_STATE_COMBAT_INIT
|
|
|
|
SET_INSTANCE_PRIORITY_HINT(INSTANCE_HINT_SHOOTING)
|
|
CREATE_LAMAR_FOR_STAGE(STAGE_SHOOTOUT_STAGE_2)
|
|
|
|
// buddy mix group
|
|
ADD_MAIN_CHARACTERS_TO_BUDDY_AUDIO_MIX_GROUP()
|
|
|
|
IF bJumpingToStage
|
|
TRIGGER_MUSIC_EVENT("FIN1_SO_2_RT")
|
|
START_AUDIO_SCENE("FINALE_SHOOTOUT_FIRST_WAVE")
|
|
eAudioSceneState = AUDIO_GET_TO_LAMAR
|
|
ENDIF
|
|
BREAK
|
|
CASE STAGE_SHOOTOUT_STAGE_3
|
|
eAllyStates[SELECTOR_PED_MICHAEL].currentState = ALLY_STATE_COMBAT_INIT
|
|
eAllyStates[SELECTOR_PED_TREVOR].currentState = ALLY_STATE_INJURED
|
|
eAllyStates[SELECTOR_PED_FRANKLIN].currentState = ALLY_STATE_LOCKED_IN_COVER
|
|
|
|
SET_INSTANCE_PRIORITY_HINT(INSTANCE_HINT_SHOOTING)
|
|
|
|
BLIP_BUDDIES()
|
|
|
|
IF NOT bJumpingToStage
|
|
REAPPLY_PLAYER_PED_ATTRIBUTES(setStage)
|
|
ELSE
|
|
CREATE_INTERIOR_PROPS()
|
|
SETUP_PLAYERS_FOR_SHOOTOUT_3()
|
|
CREATE_ENEMY_WAVE(EW_FIB_ATTACK_TREVOR_GROUND, TRUE)
|
|
ENDIF
|
|
|
|
// buddy mix group
|
|
ADD_MAIN_CHARACTERS_TO_BUDDY_AUDIO_MIX_GROUP()
|
|
|
|
IF bJumpingToStage
|
|
TRIGGER_MUSIC_EVENT("FIN1_SO_3_RT")
|
|
eAudioSceneState = AUDIO_SAVE_TREVOR
|
|
CPRINTLN(DEBUG_MISSION,"Why yes, I AM setting the proper audio state (AUDIO_SAVE_TREVOR)")
|
|
ENDIF
|
|
BREAK
|
|
|
|
CASE STAGE_SHOOTOUT_STAGE_4
|
|
IF bJumpingToStage
|
|
CREATE_INTERIOR_PROPS()
|
|
eAllyStates[SELECTOR_PED_MICHAEL].currentState = ALLY_STATE_GOING_TO_FOUNDRY_INNER_EXIT
|
|
eAllyStates[SELECTOR_PED_TREVOR].currentState = ALLY_STATE_GOING_TO_FOUNDRY_INNER_EXIT
|
|
ENDIF
|
|
eAllyStates[SELECTOR_PED_FRANKLIN].currentState = ALLY_STATE_LOCKED_IN_COVER
|
|
|
|
IF NOT bJumpingToStage
|
|
REAPPLY_PLAYER_PED_ATTRIBUTES(setStage)
|
|
ENDIF
|
|
|
|
SET_INSTANCE_PRIORITY_HINT(INSTANCE_HINT_SHOOTING)
|
|
IF bJumpingToStage
|
|
// is this happening twice now, because it also happens in CREATE_PLAYER_CHARACTERS_WITH_TRANSPORT_IN_MISSION_STAGE? @BSW
|
|
FINALE_CREATE_PLAYER_CHARACTER(CHAR_FRANKLIN, GET_FINALE_VECTOR(FINVEC_FRANKLIN_OUTSIDE_READY), FRANKLIN_OUTSIDE_READY_ROT)
|
|
TASK_PUT_PED_DIRECTLY_INTO_COVER(GET_FRANKLIN_PED(), GET_FINALE_VECTOR(FINVEC_FRANKLIN_OUTSIDE_READY), INFINITE_TASK_TIME, TRUE, 0.0, FALSE, FALSE, franklinExitOuterCover, TRUE)
|
|
|
|
BLIP_BUDDIES()
|
|
|
|
START_TIMER_NOW_SAFE(tmrTopOuterBuddyAppear)
|
|
selectorPedToTopExit = SELECTOR_PED_TREVOR
|
|
ENDIF
|
|
|
|
CREATE_LAMAR_FOR_STAGE(STAGE_SHOOTOUT_STAGE_4)
|
|
POSITION_LAMAR_IN_COVER_FOR_SHOOTOUT()
|
|
|
|
RESTART_TIMER_NOW(tmrFranklinIncidental)
|
|
RESTART_TIMER_NOW(tmrMichaelIncidental)
|
|
RESTART_TIMER_NOW(tmrTrevorIncidental)
|
|
|
|
iFranklinIncidentalTime = 2
|
|
iMichaelIncidentalTime = 8
|
|
iTrevorIncidentalTime = 8
|
|
|
|
iNextRandomSpeechTime = GET_GAME_TIMER() + 11000
|
|
|
|
DELETE_ENEMY_WAVE(EW_FIB_SEARCH, TRUE)
|
|
DELETE_ENEMY_WAVE(EW_MERC_CATWALK, TRUE)
|
|
DELETE_ENEMY_WAVE(EW_FIB_REINFORCEMENTS, TRUE)
|
|
DELETE_ENEMY_WAVE(EW_FIB_ATTACK_TREVOR_GROUND, TRUE)
|
|
DELETE_ENEMY_WAVE(EW_FIB_ATTACK_TREVOR_CATWALK, TRUE)
|
|
DELETE_ENEMY_WAVE(EW_FIB_ATTACK_TREVOR_CLIMAX_1, TRUE)
|
|
DELETE_ENEMY_WAVE(EW_FIB_ATTACK_TREVOR_CLIMAX_2, TRUE)
|
|
DELETE_ENEMY_WAVE(EW_FIB_ATTACK_TREVOR_GROUND_REINF, TRUE)
|
|
DELETE_ENEMY_WAVE(EW_MERC_INSIDE, TRUE)
|
|
DELETE_ENEMY_WAVE(EW_FIB_LAMAR, TRUE)
|
|
DELETE_ENEMY_WAVE(EW_FIB_REINF_LAMAR, TRUE)
|
|
DELETE_ENEMY_WAVE(EW_FIB_INFINITE_LAMAR, TRUE)
|
|
DELETE_ENEMY_WAVE(EW_MERC_TREVORCORNER, TRUE)
|
|
|
|
CREATE_ENEMY_WAVE(EW_FIB_BATTLE_OUTSIDE, TRUE, TRUE)
|
|
CREATE_ENEMY_WAVE(EW_MERC_BATTLE_OUTSIDE, TRUE, TRUE)
|
|
|
|
IF bJumpingToStage
|
|
TRIGGER_MUSIC_EVENT("FIN1_SO_4_RT")
|
|
eAudioSceneState = AUDIO_SHOOTOUT_OUTSIDE
|
|
ENDIF
|
|
|
|
// buddy mix group
|
|
ADD_MAIN_CHARACTERS_TO_BUDDY_AUDIO_MIX_GROUP()
|
|
|
|
IF bJumpingToStage
|
|
GIVE_MICHAEL_ASSAULT_RIFLE(TRUE)
|
|
ENDIF
|
|
|
|
BREAK
|
|
CASE STAGE_OUTRO_CUTSCENE
|
|
// hacky to make sure we get the cutscene streamed in on jump
|
|
IF bJumpingToStage
|
|
WHILE endcutStreamingStage < MOCAP_STREAMING_STAGE_COMPLETE
|
|
HANDLE_END_CUTSCENE()
|
|
WAIT(0)
|
|
ENDWHILE
|
|
ENDIF
|
|
BREAK
|
|
ENDSWITCH
|
|
|
|
// give weapons - temp?
|
|
IF bJumpingToStage
|
|
IF setStage >= STAGE_SHOOTOUT_STAGE_1 AND setStage <= STAGE_SHOOTOUT_STAGE_4
|
|
GIVE_CHARACTERS_WEAPONS()
|
|
ENDIF
|
|
ENDIF
|
|
|
|
// headsets
|
|
IF bJumpingToStage
|
|
IF setStage >= STAGE_SHOOTOUT_STAGE_1
|
|
SET_PLAYER_PED_WITH_HEADSET(CHAR_MICHAEL, TRUE)
|
|
SET_PLAYER_PED_WITH_HEADSET(CHAR_TREVOR, TRUE)
|
|
SET_PLAYER_PED_WITH_HEADSET(CHAR_FRANKLIN, TRUE)
|
|
ENDIF
|
|
ENDIF
|
|
|
|
// clear selector hint
|
|
CLEAR_ALL_MISSION_HINTS()
|
|
|
|
// wanted level, emergency services
|
|
IF setStage >= STAGE_MEET_GANG
|
|
SET_MAX_WANTED_LEVEL(0)
|
|
SET_WANTED_LEVEL_MULTIPLIER(0.0)
|
|
ENABLE_ALL_DISPATCH_SERVICES(FALSE)
|
|
ELSE
|
|
SET_MAX_WANTED_LEVEL(5)
|
|
SET_WANTED_LEVEL_MULTIPLIER(1.0)
|
|
ENABLE_ALL_DISPATCH_SERVICES(TRUE)
|
|
SET_DISPATCH_COPS_FOR_PLAYER(PLAYER_ID(), TRUE)
|
|
ENDIF
|
|
|
|
IF bJumpingToStage
|
|
IF setStage = STAGE_SHOOTOUT_STAGE_1
|
|
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(-15.0)
|
|
ELSE
|
|
SET_GAMEPLAY_CAM_RELATIVE_HEADING(87.0)
|
|
SET_GAMEPLAY_CAM_RELATIVE_PITCH(-2.5)
|
|
ENDIF
|
|
ELIF setStage = STAGE_SHOOTOUT_STAGE_2
|
|
SET_GAMEPLAY_CAM_RELATIVE_HEADING(90)
|
|
SET_GAMEPLAY_CAM_RELATIVE_PITCH(-15.0)
|
|
ELIF setStage = STAGE_SHOOTOUT_STAGE_3
|
|
SET_GAMEPLAY_CAM_RELATIVE_HEADING(90)
|
|
SET_GAMEPLAY_CAM_RELATIVE_PITCH(0.0)
|
|
ELSE
|
|
SET_GAMEPLAY_CAM_RELATIVE_HEADING(0.0)
|
|
ENDIF
|
|
ENDIF
|
|
|
|
// set value for replay
|
|
BOOL bFinalCheckpoint = FALSE
|
|
BOOL bCanLowerCheckpoint = FALSE
|
|
BOOL bStoreVehicle = TRUE
|
|
IF ENUM_TO_INT(setStage) >= ENUM_TO_INT(STAGE_SHOOTOUT_STAGE_4)
|
|
bFinalCheckpoint = TRUE // skipping from this point would end the mission
|
|
ENDIF
|
|
IF setStage >= STAGE_SHOOTOUT_STAGE_1 AND setStage <= STAGE_SHOOTOUT_STAGE_4
|
|
bStoreVehicle = FALSE
|
|
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, bCanLowerCheckpoint, NULL, bStoreVehicle)
|
|
ENDIF
|
|
|
|
IF setStage = STAGE_MEET_GANG
|
|
IF g_stageSnapshot.mVehicleStruct.mVehicle.eModel <> DUMMY_MODEL_FOR_SCRIPT
|
|
IF GET_VEHICLE_MODEL_NUMBER_OF_SEATS(g_stageSnapshot.mVehicleStruct.mVehicle.eModel) < 2
|
|
OR g_stageSnapshot.mVehicleStruct.mVehicle.eModel = SOVEREIGN
|
|
printstring("cancel store snapshot") PRINTNL()
|
|
g_stageSnapshot.mVehicleStruct.mVehicle.eModel = DUMMY_MODEL_FOR_SCRIPT
|
|
bStoreVehicle = FALSE
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
|
|
// creath health pickups
|
|
IF setStage >= STAGE_MEET_GANG
|
|
CREATE_FINALE_PICKUPS()
|
|
ENDIF
|
|
|
|
SET_PLAYER_CONTROL(PLAYER_ID(), TRUE)
|
|
|
|
IF bJumpingToStage
|
|
WHILE IS_SCREEN_FADING_OUT()
|
|
WAIT(0)
|
|
ENDWHILE
|
|
IF bHandleFadeIn
|
|
IF IS_SCREEN_FADED_OUT()
|
|
DO_SCREEN_FADE_IN(DEFAULT_FADE_TIME)
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
|
|
currentMissionStage = setStage
|
|
ENDPROC
|
|
|
|
// should we start streaming for next mission stage?
|
|
FUNC BOOL SHOULD_START_STREAMING_FOR_NEXT_MISSION_STAGE()
|
|
SWITCH currentMissionStage
|
|
CASE STAGE_GET_TO_FOUNDRY
|
|
IF IS_ENTITY_AT_COORD(PLAYER_PED_ID(), GET_FINALE_VECTOR(FINVEC_PARK), <<120,120,120>>, FALSE, FALSE)
|
|
RETURN TRUE
|
|
ENDIF
|
|
BREAK
|
|
CASE STAGE_MEET_GANG
|
|
IF bRunningCutscene
|
|
RETURN TRUE
|
|
ENDIF
|
|
BREAK
|
|
CASE STAGE_SHOOTOUT_STAGE_1
|
|
IF bKilledAll
|
|
RETURN TRUE
|
|
ENDIF
|
|
BREAK
|
|
CASE STAGE_SHOOTOUT_STAGE_2
|
|
IF bKilledAll
|
|
RETURN TRUE
|
|
ENDIF
|
|
BREAK
|
|
CASE STAGE_SHOOTOUT_STAGE_3
|
|
IF bKilledAll
|
|
RETURN TRUE
|
|
ENDIF
|
|
BREAK
|
|
CASE STAGE_SHOOTOUT_STAGE_4
|
|
IF bKilledAll
|
|
RETURN TRUE
|
|
ENDIF
|
|
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_WAYPOINT_RECORDINGS_FOR_STAGE(nextStageEnum, FALSE, TRUE)
|
|
REQUEST_ANIM_DICTS_FOR_STAGE(nextStageEnum, FALSE, TRUE)
|
|
REQUEST_WEAPONS_FOR_STAGE(nextStageEnum, FALSE, TRUE)
|
|
REQUEST_SFX_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_WAYPOINT_REQUESTS_SUCCEEDED()
|
|
AND HAVE_ALL_ANIM_DICT_REQUESTS_SUCCEEDED()
|
|
AND HAVE_ALL_WEAPON_REQUESTS_SUCCEEDED()
|
|
AND HAVE_ALL_SFX_REQUESTS_SUCCEEDED()
|
|
AND HAS_ADDITIONAL_TEXT_LOADED(MISSION_TEXT_SLOT)
|
|
streamingStage = MISSION_STREAMING_STAGE_COMPLETE
|
|
ENDIF
|
|
BREAK
|
|
ENDSWITCH
|
|
ENDPROC
|
|
|
|
// debug skip mocap
|
|
#IF IS_DEBUG_BUILD
|
|
PROC DEBUG_SKIP_MOCAP()
|
|
IF IS_KEYBOARD_KEY_JUST_PRESSED(KEY_J)
|
|
STOP_CUTSCENE()
|
|
WHILE NOT IS_SCREEN_FADED_OUT()
|
|
WAIT(0)
|
|
ENDWHILE
|
|
ENDIF
|
|
ENDPROC
|
|
#ENDIF
|
|
|
|
// get rid of everything
|
|
PROC CLEAR_MISSION_FOR_SKIP()
|
|
INT i
|
|
|
|
RESET_MISSION_STATS_ENTITY_WATCH()
|
|
SET_PLAYER_OUT_OF_ANY_VEHICLE()
|
|
|
|
sSelectorPeds.bBlockSelectorPed[SELECTOR_PED_MICHAEL] = FALSE
|
|
sSelectorPeds.bBlockSelectorPed[SELECTOR_PED_FRANKLIN] = FALSE
|
|
sSelectorPeds.bBlockSelectorPed[SELECTOR_PED_TREVOR] = FALSE
|
|
|
|
WAIT(100)
|
|
|
|
// delete entities
|
|
REPEAT 3 i
|
|
IF DOES_ENTITY_EXIST(sSelectorPeds.pedID[i])
|
|
DELETE_PED(sSelectorPeds.pedID[i])
|
|
ENDIF
|
|
ENDREPEAT
|
|
|
|
IF DOES_ENTITY_EXIST(lamarPed)
|
|
DELETE_PED(lamarPed)
|
|
ENDIF
|
|
|
|
REPEAT COUNT_OF(enemyPed) i
|
|
IF DOES_ENTITY_EXIST(enemyPed[i].ped)
|
|
DELETE_PED(enemyPed[i].ped)
|
|
ENDIF
|
|
ENDREPEAT
|
|
|
|
REPEAT COUNT_OF(finaleVehicle) i
|
|
IF DOES_ENTITY_EXIST(finaleVehicle[i])
|
|
IF IS_ENTITY_A_MISSION_ENTITY(finaleVehicle[i])
|
|
DELETE_VEHICLE(finaleVehicle[i])
|
|
ENDIF
|
|
ENDIF
|
|
ENDREPEAT
|
|
|
|
REPEAT COUNT_OF(enemyVehicle) i
|
|
IF DOES_ENTITY_EXIST(enemyVehicle[i].veh)
|
|
IF IS_ENTITY_A_MISSION_ENTITY(enemyVehicle[i].veh)
|
|
DELETE_VEHICLE(enemyVehicle[i].veh)
|
|
ENDIF
|
|
ENDIF
|
|
ENDREPEAT
|
|
|
|
REPEAT NUMBER_BARRELS i
|
|
IF DOES_ENTITY_EXIST(interiorBarrelObject[i])
|
|
DELETE_OBJECT(interiorBarrelObject[i])
|
|
ENDIF
|
|
ENDREPEAT
|
|
|
|
IF DOES_ENTITY_EXIST(exteriorBarrelObject[0])
|
|
DELETE_OBJECT(exteriorBarrelObject[0])
|
|
ENDIF
|
|
|
|
REPEAT COUNT_OF(backFightCoverCrates) i
|
|
IF DOES_ENTITY_EXIST(backFightCoverCrates[i])
|
|
DELETE_OBJECT(backFightCoverCrates[i])
|
|
ENDIF
|
|
ENDREPEAT
|
|
|
|
IF DOES_ENTITY_EXIST(coverCrate)
|
|
DELETE_OBJECT(coverCrate)
|
|
ENDIF
|
|
|
|
IF DOES_ENTITY_EXIST(lamarsPhone)
|
|
DELETE_OBJECT(lamarsPhone)
|
|
ENDIF
|
|
|
|
PIN_FOUNDRY_INTERIOR(FALSE)
|
|
|
|
CLEAR_AREA(GET_FINALE_VECTOR(FINVEC_PLAYER_INIT), 10000, TRUE)
|
|
ENDPROC
|
|
|
|
// common stuff to clear mission
|
|
PROC COMMON_MISSION_CLEAR(BOOL bDoingReplay = FALSE)
|
|
REMOVE_ALL_BLIPS()
|
|
IF IS_ENTITY_ATTACHED(PLAYER_PED_ID())
|
|
IF NOT GET_IS_PED_GADGET_EQUIPPED(PLAYER_PED_ID(), GADGETTYPE_PARACHUTE)
|
|
IF GET_VEHICLE_PED_IS_USING(PLAYER_PED_ID()) = NULL
|
|
CLEAR_PED_TASKS(PLAYER_PED_ID())
|
|
DETACH_ENTITY(PLAYER_PED_ID())
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
|
|
STOP_AUDIO_SCENES()
|
|
UNBLOCK_ALL_SELECTOR_PEDS()
|
|
CLEAR_SELECTOR_PED_PRIORITY(sSelectorPeds)
|
|
IF NOT bDoingReplay
|
|
SET_PLAYER_CONTROL(PLAYER_ID(), TRUE)
|
|
ENDIF
|
|
SET_PED_USING_ACTION_MODE(PLAYER_PED_ID(), FALSE)
|
|
SET_SCRIPTS_SAFE_FOR_CUTSCENE(FALSE)
|
|
DISABLE_CELLPHONE(FALSE)
|
|
CLEAR_MISSION_FOR_SKIP()
|
|
ENDPROC
|
|
|
|
// handle shitskip
|
|
FUNC BOOL HANDLE_MISSION_SHITSKIP()
|
|
// new shitskip system
|
|
IF IS_REPLAY_IN_PROGRESS()
|
|
IF g_bShitskipAccepted = TRUE
|
|
CPRINTLN(DEBUG_REPLAY, "Finale 3: 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_FOUNDRY
|
|
nextReplayStage = STAGE_MEET_GANG
|
|
BREAK
|
|
CASE STAGE_MEET_GANG
|
|
nextReplayStage = STAGE_SHOOTOUT_STAGE_1
|
|
BREAK
|
|
CASE STAGE_SHOOTOUT_STAGE_1
|
|
nextReplayStage = STAGE_SHOOTOUT_STAGE_2
|
|
BREAK
|
|
CASE STAGE_SHOOTOUT_STAGE_2
|
|
nextReplayStage = STAGE_SHOOTOUT_STAGE_3
|
|
BREAK
|
|
CASE STAGE_SHOOTOUT_STAGE_3
|
|
nextReplayStage = STAGE_SHOOTOUT_STAGE_4
|
|
BREAK
|
|
CASE STAGE_SHOOTOUT_STAGE_4
|
|
nextReplayStage = STAGE_OUTRO_CUTSCENE
|
|
bForcePassOnShitskip = TRUE
|
|
BREAK
|
|
CASE STAGE_OUTRO_CUTSCENE
|
|
bForcePassOnShitskip = TRUE
|
|
bPassMission = TRUE
|
|
BREAK
|
|
ENDSWITCH
|
|
|
|
// set the next mission stage nicely
|
|
COMMON_MISSION_CLEAR(IS_REPLAY_BEING_SET_UP())
|
|
SET_MISSION_STAGE(nextReplayStage, TRUE, TRUE, TRUE, FALSE, TRUE, TRUE, FALSE)
|
|
WAIT(SKIP_FADE_WAIT_TIME)
|
|
IF NOT bForcePassOnShitskip
|
|
IF nextReplayStage <> STAGE_OUTRO_CUTSCENE
|
|
DO_SCREEN_FADE_IN(DEFAULT_FADE_TIME)
|
|
ENDIF
|
|
ELSE
|
|
IF bPassMission
|
|
DO_SCREEN_FADE_IN(DEFAULT_FADE_TIME)
|
|
MISSION_PASSED()
|
|
ENDIF
|
|
ENDIF
|
|
|
|
RETURN TRUE
|
|
ELSE
|
|
CPRINTLN(DEBUG_REPLAY, "Finale 3: no shitskip")
|
|
ENDIF
|
|
ENDIF
|
|
RETURN FALSE // did not do a shitskip
|
|
ENDFUNC
|
|
|
|
// do mission init start mission
|
|
PROC DO_MISSION_INIT_START_MISSION()
|
|
CPRINTLN(DEBUG_MISSION, "DO_MISSION_INIT_START_MISSION start")
|
|
ADD_RELATIONSHIP_GROUP("FIB group", fibRelGroup)
|
|
ADD_RELATIONSHIP_GROUP("Merc group", mercRelGroup)
|
|
|
|
SET_RELATIONSHIP_BETWEEN_GROUPS(ACQUAINTANCE_TYPE_PED_HATE, RELGROUPHASH_PLAYER, fibRelGroup)
|
|
SET_RELATIONSHIP_BETWEEN_GROUPS(ACQUAINTANCE_TYPE_PED_HATE, RELGROUPHASH_PLAYER, mercRelGroup)
|
|
|
|
SET_RELATIONSHIP_BETWEEN_GROUPS(ACQUAINTANCE_TYPE_PED_HATE, fibRelGroup, RELGROUPHASH_PLAYER)
|
|
SET_RELATIONSHIP_BETWEEN_GROUPS(ACQUAINTANCE_TYPE_PED_HATE, fibRelGroup, mercRelGroup)
|
|
|
|
SET_RELATIONSHIP_BETWEEN_GROUPS(ACQUAINTANCE_TYPE_PED_HATE, mercRelGroup, fibRelGroup)
|
|
SET_RELATIONSHIP_BETWEEN_GROUPS(ACQUAINTANCE_TYPE_PED_HATE, mercRelGroup, RELGROUPHASH_PLAYER)
|
|
|
|
|
|
IF NOT IS_PED_INJURED(PLAYER_PED_ID())
|
|
IF NOT IS_REPLAY_IN_PROGRESS()
|
|
|
|
// no replay - kick mission off normally
|
|
IF NOT WAS_CUTSCENE_SKIPPED()
|
|
#IF IS_DEBUG_BUILD
|
|
IF iDebugStage >= 0
|
|
SET_MISSION_STAGE(INT_TO_ENUM(MISSION_STAGE_ENUM, iDebugStage), TRUE)
|
|
ELSE
|
|
#ENDIF
|
|
SET_MISSION_STAGE(STAGE_GET_TO_FOUNDRY, FALSE, TRUE, TRUE, TRUE)
|
|
#IF IS_DEBUG_BUILD
|
|
ENDIF
|
|
#ENDIF
|
|
ELSE
|
|
CLEAR_START_AREA()
|
|
SET_MISSION_STAGE(STAGE_GET_TO_FOUNDRY, TRUE, TRUE, TRUE, FALSE, FALSE)
|
|
WAIT(SKIP_FADE_WAIT_TIME)
|
|
ENDIF
|
|
ELSE
|
|
IF HANDLE_MISSION_SHITSKIP()
|
|
CPRINTLN(DEBUG_REPLAY, "Finale 3: shitskip done")
|
|
ELSE
|
|
INT iReplayStage
|
|
iReplayStage = Get_Replay_Mid_Mission_Stage()
|
|
SET_MISSION_STAGE(INT_TO_ENUM(MISSION_STAGE_ENUM, iReplayStage), TRUE)
|
|
WAIT(SKIP_FADE_WAIT_TIME)
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF NOT bForcePassOnShitskip
|
|
IF IS_SCREEN_FADED_OUT()
|
|
OR IS_SCREEN_FADING_OUT()
|
|
CPRINTLN(DEBUG_MISSION, "DO_MISSION_INIT_START_MISSION fading in")
|
|
DO_SCREEN_FADE_IN(DEFAULT_FADE_TIME)
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
|
|
missionInitStage = MISSION_INIT_DONE
|
|
ENDPROC
|
|
|
|
// initialise mission
|
|
FUNC BOOL INIT_MISSION()
|
|
SWITCH missionInitStage
|
|
CASE MISSION_INIT_PRE_INTRO
|
|
REMOVE_MISSION_TEXT()
|
|
SUPPRESS_MISSION_VEHICLES(TRUE)
|
|
ENABLE_CARGENS_FOR_MISSION(FALSE)
|
|
foundryScenarioBlocking = ADD_SCENARIO_BLOCKING_AREA(<<928, -2095, -10>>, <<1181, -1830, 100>>)
|
|
SET_PLAYER_CONTROL(PLAYER_ID(), FALSE, SPC_LEAVE_CAMERA_CONTROL_ON)
|
|
|
|
SET_INTERIOR_CAPPED(INTERIOR_V_LESTERS, FALSE)
|
|
|
|
// cover
|
|
initialCover[ENUM_TO_INT(SELECTOR_PED_FRANKLIN)] = ADD_COVER_POINT(GET_PLAYER_COVER_COORD(ENUM_TO_INT(SELECTOR_PED_FRANKLIN)), 58.24, COVUSE_WALLTOBOTH, COVHEIGHT_LOW, COVARC_180)
|
|
initialCover[ENUM_TO_INT(SELECTOR_PED_MICHAEL)] = ADD_COVER_POINT(GET_PLAYER_COVER_COORD(ENUM_TO_INT(SELECTOR_PED_MICHAEL)), 54.2, COVUSE_WALLTOBOTH, COVHEIGHT_LOW, COVARC_180)
|
|
initialCover[ENUM_TO_INT(SELECTOR_PED_TREVOR)] = ADD_COVER_POINT(GET_PLAYER_COVER_COORD(ENUM_TO_INT(SELECTOR_PED_TREVOR)), 234.83, COVUSE_WALLTOBOTH, COVHEIGHT_LOW, COVARC_180)
|
|
|
|
michaelCatwalkCover = ADD_COVER_POINT(<<1112.5048, -2005.4424, 34.4444>>, 148.0, COVUSE_WALLTOBOTH, COVHEIGHT_LOW, COVARC_180)
|
|
|
|
trevorInjuredCover = ADD_COVER_POINT(GET_FINALE_VECTOR(FINVEC_TREVOR_SAVETREVOR), 227.5, COVUSE_WALLTOBOTH, COVHEIGHT_LOW, COVARC_180)
|
|
|
|
topExitInnerCover = ADD_COVER_POINT(GET_FINALE_VECTOR(FINVEC_TOP_INNER_COVER), 160.0, COVUSE_WALLTOLEFT, COVHEIGHT_TOOHIGH, COVARC_0TO60)
|
|
topExitOuterCover = ADD_COVER_POINT(GET_FINALE_VECTOR(FINVEC_TOP_OUTER_COVER), 140.0, COVUSE_WALLTORIGHT, COVHEIGHT_TOOHIGH, COVARC_300TO0)
|
|
|
|
bottomExit2InnerCover = ADD_COVER_POINT(GET_FINALE_VECTOR(FINVEC_BOTTOM_INNER_COVER), 160.0, COVUSE_WALLTORIGHT, COVHEIGHT_TOOHIGH, COVARC_300TO0)
|
|
bottomExit2OuterCover = ADD_COVER_POINT(GET_FINALE_VECTOR(FINVEC_BOTTOM_OUTER_COVER), 280, COVUSE_WALLTOBOTH, COVHEIGHT_LOW, COVARC_180)
|
|
|
|
franklinExitOuterCover = ADD_COVER_POINT(GET_FINALE_VECTOR(FINVEC_FRANKLIN_OUTSIDE_READY), 45, COVUSE_WALLTOBOTH, COVHEIGHT_LOW, COVARC_180)
|
|
|
|
outsideShackCornerCover = ADD_COVER_POINT((<<1066.6490, -2053.6365, 30.0447>>), 330.0, COVUSE_WALLTOLEFT, COVHEIGHT_TOOHIGH, COVARC_0TO60)
|
|
|
|
CREATE_FORCED_OBJECT(GET_FINALE_VECTOR(FINVEC_GAS_TANK), 10, mapPlacedGasTank, TRUE)
|
|
|
|
CPRINTLN(DEBUG_MISSION, "SET_MISSION_STAGE identifying foundryInterior")
|
|
foundryInterior = GET_INTERIOR_AT_COORDS(<<1100, -2004, 37>>)
|
|
|
|
missionInitStage = MISSION_INIT_REQUEST_INTRO
|
|
BREAK
|
|
|
|
CASE MISSION_INIT_REQUEST_INTRO
|
|
IF NOT IS_REPLAY_IN_PROGRESS()
|
|
#IF IS_DEBUG_BUILD
|
|
AND iDebugStage < 0
|
|
#ENDIF
|
|
REQUEST_CUTSCENE(GET_FINALE_INTRO_CUTSCENE_NAME())
|
|
missionInitStage = MISSION_INIT_WAIT_FOR_INTRO
|
|
ELSE
|
|
DO_MISSION_INIT_START_MISSION()
|
|
ENDIF
|
|
BREAK
|
|
|
|
CASE MISSION_INIT_WAIT_FOR_INTRO
|
|
IF HAS_CUTSCENE_LOADED_WITH_FAILSAFE()
|
|
IF DOES_ENTITY_EXIST(g_sTriggerSceneAssets.ped[0])
|
|
IF NOT IS_PED_INJURED(g_sTriggerSceneAssets.ped[0])
|
|
//Transfer the global index to a local index and grab ownership of the entity.
|
|
pedLester = g_sTriggerSceneAssets.ped[0]
|
|
SET_ENTITY_AS_MISSION_ENTITY(pedLester, TRUE, TRUE)
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF DOES_ENTITY_EXIST(g_sTriggerSceneAssets.object[0])
|
|
//Transfer the global index to a local index and grab ownership of the entity.
|
|
objWheelchair = g_sTriggerSceneAssets.object[0]
|
|
SET_ENTITY_AS_MISSION_ENTITY(objWheelchair, TRUE, TRUE)
|
|
ENDIF
|
|
|
|
// register entities and start cutscene
|
|
REGISTER_ENTITY_FOR_CUTSCENE(PLAYER_PED_ID(), "Franklin", CU_ANIMATE_EXISTING_SCRIPT_ENTITY, GET_MODEL_FOR_FINALE_MODEL_ENUM(FM_FRANKLIN))
|
|
IF DOES_ENTITY_EXIST(pedLester)
|
|
REGISTER_ENTITY_FOR_CUTSCENE(pedLester, "Lester", CU_ANIMATE_AND_DELETE_EXISTING_SCRIPT_ENTITY, GET_NPC_PED_MODEL(CHAR_LESTER))
|
|
ENDIF
|
|
IF DOES_ENTITY_EXIST(objWheelchair)
|
|
REGISTER_ENTITY_FOR_CUTSCENE(objWheelchair, "Wheelchair_Lester", CU_ANIMATE_AND_DELETE_EXISTING_SCRIPT_ENTITY, Prop_WheelChair_01_S)
|
|
ENDIF
|
|
START_CUTSCENE()
|
|
|
|
REPLAY_START_EVENT(REPLAY_IMPORTANCE_HIGHEST)
|
|
|
|
SET_CUTSCENE_FADE_VALUES(FALSE, FALSE, FALSE, FALSE)
|
|
|
|
MISSION_FLOW_RELEASE_TRIGGER_SCENE_ASSETS(SP_MISSION_FINALE_C1)
|
|
|
|
missionInitStage = MISSION_INIT_PLAY_INTRO
|
|
ELSE
|
|
IF CAN_REQUEST_ASSETS_FOR_CUTSCENE_ENTITY()
|
|
IF IS_ENTITY_OK(PLAYER_PED_ID())
|
|
SET_CUTSCENE_PED_COMPONENT_VARIATION_FROM_PED("Franklin", PLAYER_PED_ID(), GET_ENTITY_MODEL(PLAYER_PED_ID()))
|
|
CPRINTLN(DEBUG_MISSION, "FRANKLIN CUTSCENE VARIATION SET")
|
|
ENDIF
|
|
IF IS_ENTITY_OK(g_sTriggerSceneAssets.ped[0])
|
|
SET_CUTSCENE_PED_COMPONENT_VARIATION_FROM_PED("Lester", g_sTriggerSceneAssets.ped[0], GET_NPC_PED_MODEL(CHAR_LESTER))
|
|
SET_CUTSCENE_PED_PROP_VARIATION("Lester", ANCHOR_EYES, 0)
|
|
CPRINTLN(DEBUG_MISSION, "LESTER CUTSCENE VARIATION SET")
|
|
ENDIF
|
|
|
|
ENDIF
|
|
ENDIF
|
|
BREAK
|
|
|
|
CASE MISSION_INIT_PLAY_INTRO
|
|
IF NOT bClearedForCutscene
|
|
IF IS_CUTSCENE_PLAYING()
|
|
SET_MISSION_MOCAP_CUTSCENE()
|
|
RESOLVE_VEHICLES_INSIDE_ANGLED_AREA_WITH_SIZE_LIMIT(<<1272.815, -1725.651, 47.095>>, <<1265.771, -1710.435, 58.837>>, 22.000, <<1283.36218, -1729.55811, 52.88403>>, 114.1, GET_DEFAULT_ALLOWABLE_VEHICLE_SIZE_VECTOR(), TRUE, FALSE, TRUE)
|
|
|
|
finaleVehicle[FV_MISSION_START_CAR] = GET_MISSION_START_VEHICLE_INDEX()
|
|
IF IS_VEHICLE_DRIVEABLE(finaleVehicle[FV_MISSION_START_CAR])
|
|
IF IS_REPLAY_START_VEHICLE_UNDER_SIZE_LIMIT(GET_DEFAULT_ALLOWABLE_VEHICLE_SIZE_VECTOR())
|
|
SET_ENTITY_AS_MISSION_ENTITY(finaleVehicle[FV_MISSION_START_CAR], TRUE, TRUE)
|
|
SET_POSITION_OF_MISSION_START_VEHICLE(GET_FINALE_VECTOR(FINVEC_LESTERS_CAR_INIT), LESTERS_CAR_INIT_ROT)
|
|
ENDIF
|
|
ELSE
|
|
finaleVehicle[FV_MISSION_START_CAR] = NULL
|
|
#IF IS_DEBUG_BUILD
|
|
CREATE_VEHICLE_FOR_REPLAY(finaleVehicle[FV_MISSION_START_CAR], GET_FINALE_VECTOR(FINVEC_LESTERS_CAR_INIT), LESTERS_CAR_INIT_ROT, FALSE, FALSE, FALSE, FALSE, TRUE, DEFAULT, DEFAULT, CHAR_FRANKLIN)
|
|
#ENDIF
|
|
ENDIF
|
|
|
|
CLEAR_AREA(GET_FINALE_VECTOR(FINVEC_LESTERS_CAR_INIT), 10000, TRUE)
|
|
|
|
// rein in the hounds
|
|
SET_AMBIENT_ZONE_LIST_STATE_PERSISTENT("AZL_LESTERS_DOGS", FALSE, TRUE)
|
|
|
|
IF IS_SCREEN_FADED_OUT()
|
|
DO_SCREEN_FADE_IN(DEFAULT_FADE_TIME)
|
|
ENDIF
|
|
|
|
bClearedForCutscene = TRUE
|
|
ENDIF
|
|
ENDIF
|
|
|
|
SET_VEHICLE_DENSITY_MULTIPLIER_THIS_FRAME(0.0)
|
|
|
|
// preload assets
|
|
IF GET_CUTSCENE_TIME() >= 5000
|
|
DO_STREAMING_FOR_NEXT_MISSION_STAGE(TRUE)
|
|
IF NOT bRequestedLamarCarModel
|
|
IF NOT IS_VEHICLE_DRIVEABLE(finaleVehicle[FV_MISSION_START_CAR])
|
|
bRequestedLamarCarModel = TRUE
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
|
|
// pre-create mission entities not involved in cut
|
|
IF NOT bDoneIntroCreateEntities
|
|
SET_CUTSCENE_CAN_BE_SKIPPED(FALSE)
|
|
IF streamingStage = MISSION_STREAMING_STAGE_COMPLETE
|
|
AND HAVE_ALL_MODEL_REQUESTS_SUCCEEDED()
|
|
IF NOT bDoneIntroClearStart
|
|
CLEAR_START_AREA()
|
|
bDoneIntroClearStart = TRUE
|
|
ELSE
|
|
CREATE_PLAYER_CHARACTERS_WITH_TRANSPORT_IN_MISSION_STAGE(STAGE_GET_TO_FOUNDRY)
|
|
bDoneIntroCreateEntities = TRUE
|
|
SET_CUTSCENE_CAN_BE_SKIPPED(TRUE)
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
|
|
// set exit state
|
|
IF CAN_SET_EXIT_STATE_FOR_REGISTERED_ENTITY("Franklin")
|
|
|
|
REPLAY_STOP_EVENT()
|
|
|
|
POSITION_PLAYER_AT_MISSION_INIT() // temp
|
|
ENDIF
|
|
|
|
IF CAN_SET_EXIT_STATE_FOR_CAMERA() OR (WAS_CUTSCENE_SKIPPED() AND NOT IS_CUTSCENE_PLAYING())
|
|
CPRINTLN(DEBUG_MISSION, "Init cutscene was skipped or can set exit state for camera, time to advance")
|
|
SET_MISSION_CUTSCENE(FALSE, TRUE, TRUE, FALSE, FALSE)
|
|
SET_INTERIOR_CAPPED_ON_EXIT(INTERIOR_V_LESTERS, TRUE)
|
|
DO_MISSION_INIT_START_MISSION()
|
|
ENDIF
|
|
|
|
#IF IS_DEBUG_BUILD
|
|
DEBUG_SKIP_MOCAP()
|
|
#ENDIF
|
|
BREAK
|
|
|
|
CASE MISSION_INIT_DONE
|
|
RETURN TRUE
|
|
BREAK
|
|
ENDSWITCH
|
|
|
|
RETURN FALSE
|
|
ENDFUNC
|
|
|
|
// constantly run the hotswap selector/spline cam, and return true when selected the target ped
|
|
FUNC BOOL DO_MISSION_HOTSWAP(SELECTOR_SLOTS_ENUM targetCharacter)
|
|
SWITCH hotswapStage
|
|
CASE MISSION_HOTSWAP_STAGE_SELECT_CHARACTER
|
|
REMOVE_MISSION_TEXT()
|
|
sSelectorPeds.eNewSelectorPed = targetCharacter
|
|
sCamDetails.pedTo = sSelectorPeds.pedID[targetCharacter]
|
|
sCamDetails.bRun = TRUE
|
|
sCamDetails.bOKToSwitchPed = FALSE
|
|
sCamDetails.bPedSwitched = FALSE
|
|
hotswapStage = MISSION_HOTSWAP_STAGE_DO_SPLINE_CAM
|
|
BREAK
|
|
|
|
CASE MISSION_HOTSWAP_STAGE_DO_SPLINE_CAM
|
|
IF RUN_SWITCH_CAM_FROM_PLAYER_TO_PED(sCamDetails)
|
|
IF sCamDetails.bOKToSwitchPed
|
|
IF NOT sCamDetails.bPedSwitched
|
|
IF TAKE_CONTROL_OF_SELECTOR_PED(sSelectorPeds, TRUE, TRUE)
|
|
REAPPLY_PLAYER_PED_ATTRIBUTES(currentMissionStage, FALSE)
|
|
sCamDetails.bPedSwitched = TRUE
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ELSE
|
|
IF GET_CURRENT_PLAYER_PED_ENUM() = GET_PLAYER_PED_ENUM_FROM_SELECTOR_SLOT(targetCharacter)
|
|
INT i
|
|
|
|
REPEAT COUNT_OF(sCamDetails.camInterpIDs) i
|
|
IF DOES_CAM_EXIST(sCamDetails.camInterpIDs[i])
|
|
DESTROY_CAM(sCamDetails.camInterpIDs[i])
|
|
ENDIF
|
|
ENDREPEAT
|
|
|
|
IF DOES_CAM_EXIST(sCamDetails.camID)
|
|
DESTROY_CAM(sCamDetails.camID)
|
|
ENDIF
|
|
|
|
REAPPLY_PLAYER_PED_ATTRIBUTES(currentMissionStage)
|
|
|
|
hotswapStage = MISSION_HOTSWAP_STAGE_DONE
|
|
RETURN TRUE
|
|
ENDIF
|
|
ENDIF
|
|
BREAK
|
|
ENDSWITCH
|
|
|
|
RETURN FALSE
|
|
ENDFUNC
|
|
|
|
// can we do a free hotswap
|
|
FUNC BOOL CAN_DO_FREE_HOTSWAP()
|
|
IF GET_NUMBER_BLOCKED_PEDS() < 2
|
|
OR sSelectorPeds.bBlockSelectorPed[GET_SELECTOR_SLOT_FROM_PLAYER_PED_ENUM(GET_CURRENT_PLAYER_PED_ENUM())]
|
|
OR freeHotswapData.state = FREE_HOTSWAP_STATE_IN_PROGRESS
|
|
RETURN TRUE
|
|
ENDIF
|
|
|
|
RETURN FALSE
|
|
ENDFUNC
|
|
|
|
// free hotswapping between peds
|
|
PROC HANDLE_FREE_HOTSWAP()
|
|
SWITCH freeHotswapData.state
|
|
CASE FREE_HOTSWAP_STATE_SELECTING
|
|
IF NOT bLockSelector
|
|
IF UPDATE_SELECTOR_HUD(sSelectorPeds, FALSE)
|
|
OR bForceSwitch
|
|
#IF IS_DEBUG_BUILD
|
|
OR bDebugJSkip
|
|
#ENDIF
|
|
bForceSwitch = FALSE
|
|
|
|
hotswapStage = MISSION_HOTSWAP_STAGE_SELECT_CHARACTER
|
|
freeHotswapData.swapTarget = sSelectorPeds.eNewSelectorPed
|
|
freeHotswapData.state = FREE_HOTSWAP_STATE_IN_PROGRESS
|
|
|
|
INFORM_MISSION_STATS_OF_INCREMENT(FIN_SWITCHES)
|
|
|
|
IF mocapStreamingStage >= MOCAP_STREAMING_STAGE_WAIT
|
|
REMOVE_CUTSCENE()
|
|
mocapStreamingStage = MOCAP_STREAMING_STAGE_REQUEST
|
|
ENDIF
|
|
|
|
sCamDetails.bPedSwitched = FALSE
|
|
|
|
freeHotswapData.state = FREE_HOTSWAP_STATE_IN_PROGRESS
|
|
|
|
// set ped switching from into combat
|
|
IF NOT IS_PED_IN_COVER(PLAYER_PED_ID())
|
|
SET_PLAYER_TO_COMBAT(currentMissionStage)
|
|
ENDIF
|
|
|
|
// set ped switching to into combat
|
|
IF NOT (bKilledAll AND currentMissionStage = STAGE_SHOOTOUT_STAGE_4)
|
|
AND NOT (bTrevorIsInjured AND sSelectorPeds.eNewSelectorPed = SELECTOR_PED_TREVOR)
|
|
IF NOT IS_PED_INJURED(sSelectorPeds.pedID[sSelectorPeds.eNewSelectorPed])
|
|
IF GET_SCRIPT_TASK_STATUS(sSelectorPeds.pedID[sSelectorPeds.eNewSelectorPed], SCRIPT_TASK_FOLLOW_NAV_MESH_TO_COORD) = FINISHED_TASK
|
|
IF NOT IS_PED_IN_COVER(sSelectorPeds.pedID[sSelectorPeds.eNewSelectorPed])
|
|
// get into cover
|
|
INT iFoundCover
|
|
iFoundCover = -1
|
|
INT i
|
|
REPEAT NUMBER_PLAYER_COVER_POINTS i
|
|
IF IS_ENTITY_AT_COORD(sSelectorPeds.pedID[sSelectorPeds.eNewSelectorPed], GET_PLAYER_COVER_COORD(i), <<5,5,2>>)
|
|
iFoundCover = i
|
|
ENDIF
|
|
ENDREPEAT
|
|
|
|
IF iFoundCover < 0
|
|
IF currentMissionStage = STAGE_SHOOTOUT_STAGE_4
|
|
IF NOT (selectorPedToTopExit = sSelectorPeds.eNewSelectorPed AND NOT bTaskedTopPlayerOut)
|
|
TASK_COMBAT_HATED_TARGETS_AROUND_PED(sSelectorPeds.pedID[sSelectorPeds.eNewSelectorPed], 100)
|
|
ENDIF
|
|
ELSE
|
|
TASK_SEEK_COVER_TO_COORDS(sSelectorPeds.pedID[sSelectorPeds.eNewSelectorPed], GET_ENTITY_COORDS(sSelectorPeds.pedID[sSelectorPeds.eNewSelectorPed]), <<1092.61, -1998.99, 31.37>>, -1, TRUE)
|
|
ENDIF
|
|
ELSE
|
|
TASK_SEEK_COVER_TO_COVER_POINT(sSelectorPeds.pedID[sSelectorPeds.eNewSelectorPed], initialCover[iFoundCover], <<1092.61, -1998.99, 31.37>>, -1, TRUE)
|
|
ENDIF
|
|
ELSE
|
|
SET_PED_CONFIG_FLAG(sSelectorPeds.pedID[sSelectorPeds.eNewSelectorPed], PCF_ForcedToStayInCover, TRUE)
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
BREAK
|
|
|
|
CASE FREE_HOTSWAP_STATE_IN_PROGRESS
|
|
IF DO_MISSION_HOTSWAP(freeHotswapData.swapTarget)
|
|
BLIP_BUDDIES()
|
|
|
|
DISPLAY_HUD(TRUE)
|
|
DISPLAY_RADAR(TRUE)
|
|
freeHotswapData.state = FREE_HOTSWAP_STATE_SELECTING
|
|
|
|
BOOL bClearTasks
|
|
bClearTasks = TRUE
|
|
|
|
|
|
IF currentMissionStage >= STAGE_SHOOTOUT_STAGE_1 AND currentMissionStage <= STAGE_SHOOTOUT_STAGE_4
|
|
bClearTasks = FALSE
|
|
|
|
IF GET_SCRIPT_TASK_STATUS(PLAYER_PED_ID(), SCRIPT_TASK_FOLLOW_NAV_MESH_TO_COORD) <> FINISHED_TASK
|
|
OR GET_SCRIPT_TASK_STATUS(PLAYER_PED_ID(), SCRIPT_TASK_TURN_PED_TO_FACE_ENTITY) <> FINISHED_TASK
|
|
bClearTasks = TRUE
|
|
ENDIF
|
|
ENDIF
|
|
|
|
// buddy mix group
|
|
ADD_MAIN_CHARACTERS_TO_BUDDY_AUDIO_MIX_GROUP()
|
|
|
|
IF bClearTasks
|
|
CLEAR_PED_TASKS(PLAYER_PED_ID())
|
|
ENDIF
|
|
|
|
// set the AIs back to regular weapons so they dont spam rockets or some shit
|
|
INT i
|
|
REPEAT 3 i
|
|
IF IS_ENTITY_OK(sSelectorPeds.pedID[i])
|
|
WEAPON_TYPE currentWeapon
|
|
currentWeapon = WEAPONTYPE_PISTOL
|
|
IF GET_CURRENT_PED_WEAPON(sSelectorPeds.pedID[i], currentWeapon)
|
|
IF currentWeapon = WEAPONTYPE_RPG
|
|
OR currentWeapon = WEAPONTYPE_GRENADELAUNCHER
|
|
OR currentWeapon = WEAPONTYPE_DLC_HOMINGLAUNCHER
|
|
WEAPON_TYPE newWeapon
|
|
IF i = ENUM_TO_INT(SELECTOR_PED_MICHAEL)
|
|
newWeapon = GET_FINALE_WEAPON_TYPE(F_WEAPON_SNIPER)
|
|
ELIF i = ENUM_TO_INT(SELECTOR_PED_TREVOR)
|
|
newWeapon = GET_FINALE_WEAPON_TYPE(F_WEAPON_LMG)
|
|
ELSE
|
|
newWeapon = GET_PED_WEAPONTYPE_IN_SLOT(GET_FRANKLIN_PED(), WEAPONSLOT_PISTOL)
|
|
ENDIF
|
|
SET_CURRENT_PED_WEAPON(sSelectorPeds.pedID[i], newWeapon)
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDREPEAT
|
|
|
|
SET_PED_CAN_SWITCH_WEAPON(PLAYER_PED_ID(), TRUE)
|
|
ENDIF
|
|
BREAK
|
|
ENDSWITCH
|
|
ENDPROC
|
|
|
|
// have all hits succeeded
|
|
FUNC BOOL HAVE_ALL_HITS_SUCCEEDED()
|
|
BOOL bAllDone = TRUE
|
|
INT i
|
|
REPEAT 3 i
|
|
IF NOT g_bFinale3BHitSuccessful[i]
|
|
bAllDone = FALSE
|
|
ENDIF
|
|
ENDREPEAT
|
|
|
|
RETURN bAllDone
|
|
ENDFUNC
|
|
|
|
// get correct string for switch text
|
|
FUNC STRING GET_STRING_FOR_SWITCH_PROMPT()
|
|
SWITCH GET_CURRENT_PLAYER_PED_ENUM()
|
|
// michael
|
|
CASE CHAR_MICHAEL
|
|
IF NOT sSelectorPeds.bBlockSelectorPed[SELECTOR_PED_TREVOR]
|
|
IF NOT sSelectorPeds.bBlockSelectorPed[SELECTOR_PED_FRANKLIN]
|
|
RETURN "FC2_SWTF"
|
|
ELSE
|
|
RETURN "FC2_SWT"
|
|
ENDIF
|
|
ELSE
|
|
IF NOT sSelectorPeds.bBlockSelectorPed[SELECTOR_PED_FRANKLIN]
|
|
RETURN "FC2_SWF"
|
|
ENDIF
|
|
ENDIF
|
|
BREAK
|
|
|
|
// franklin
|
|
CASE CHAR_FRANKLIN
|
|
IF NOT sSelectorPeds.bBlockSelectorPed[SELECTOR_PED_TREVOR]
|
|
IF NOT sSelectorPeds.bBlockSelectorPed[SELECTOR_PED_MICHAEL]
|
|
RETURN "FC2_SWMT"
|
|
ELSE
|
|
RETURN "FC2_SWT"
|
|
ENDIF
|
|
ELSE
|
|
IF NOT sSelectorPeds.bBlockSelectorPed[SELECTOR_PED_MICHAEL]
|
|
RETURN "FC2_SWM"
|
|
ENDIF
|
|
ENDIF
|
|
BREAK
|
|
|
|
// trevor
|
|
CASE CHAR_TREVOR
|
|
IF NOT sSelectorPeds.bBlockSelectorPed[SELECTOR_PED_MICHAEL]
|
|
IF NOT sSelectorPeds.bBlockSelectorPed[SELECTOR_PED_FRANKLIN]
|
|
RETURN "FC2_SWMF"
|
|
ELSE
|
|
RETURN "FC2_SWM"
|
|
ENDIF
|
|
ELSE
|
|
IF NOT sSelectorPeds.bBlockSelectorPed[SELECTOR_PED_FRANKLIN]
|
|
RETURN "FC2_SWF"
|
|
ENDIF
|
|
ENDIF
|
|
BREAK
|
|
ENDSWITCH
|
|
|
|
RETURN "BADSTRING"
|
|
ENDFUNC
|
|
|
|
// ask who to assassinate next
|
|
FUNC BOOL DO_WHO_NEXT_QUESTION_SPEECH()
|
|
STRING sString
|
|
SWITCH GET_RANDOM_INT_IN_RANGE(0,3)
|
|
CASE 0
|
|
sString = "FINC1_WM"
|
|
BREAK
|
|
CASE 1
|
|
sString = "FINC1_WT"
|
|
BREAK
|
|
CASE 2
|
|
sString = "FINC1_WF"
|
|
BREAK
|
|
ENDSWITCH
|
|
RETURN DO_MISSION_SPEECH(sString)
|
|
ENDFUNC
|
|
|
|
// answer who to assassinate next
|
|
FUNC BOOL DO_WHO_NEXT_ANSWER_SPEECH()
|
|
STRING sString
|
|
|
|
IF NOT HAVE_ALL_HITS_SUCCEEDED()
|
|
SWITCH GET_CURRENT_PLAYER_PED_ENUM()
|
|
// michael
|
|
CASE CHAR_MICHAEL
|
|
IF NOT sSelectorPeds.bBlockSelectorPed[SELECTOR_PED_TREVOR]
|
|
IF NOT sSelectorPeds.bBlockSelectorPed[SELECTOR_PED_FRANKLIN]
|
|
sString = "FINC1_NFT"
|
|
ELSE
|
|
sString = "FINC1_NT"
|
|
ENDIF
|
|
ELSE
|
|
IF NOT sSelectorPeds.bBlockSelectorPed[SELECTOR_PED_FRANKLIN]
|
|
sString = "FINC1_NF"
|
|
ENDIF
|
|
ENDIF
|
|
BREAK
|
|
|
|
// franklin
|
|
CASE CHAR_FRANKLIN
|
|
IF NOT sSelectorPeds.bBlockSelectorPed[SELECTOR_PED_TREVOR]
|
|
IF NOT sSelectorPeds.bBlockSelectorPed[SELECTOR_PED_MICHAEL]
|
|
sString = "FINC1_NTM"
|
|
ELSE
|
|
sString = "FINC1_NT"
|
|
ENDIF
|
|
ELSE
|
|
IF NOT sSelectorPeds.bBlockSelectorPed[SELECTOR_PED_MICHAEL]
|
|
sString = "FINC1_NM"
|
|
ENDIF
|
|
ENDIF
|
|
BREAK
|
|
|
|
// trevor
|
|
CASE CHAR_TREVOR
|
|
IF NOT sSelectorPeds.bBlockSelectorPed[SELECTOR_PED_MICHAEL]
|
|
IF NOT sSelectorPeds.bBlockSelectorPed[SELECTOR_PED_FRANKLIN]
|
|
sString = "FINC1_NFM"
|
|
ELSE
|
|
sString = "FINC1_NM"
|
|
ENDIF
|
|
ELSE
|
|
IF NOT sSelectorPeds.bBlockSelectorPed[SELECTOR_PED_FRANKLIN]
|
|
sString = "FINC1_NF"
|
|
ENDIF
|
|
ENDIF
|
|
BREAK
|
|
ENDSWITCH
|
|
ELSE
|
|
sString = "FINC1_ND"
|
|
ENDIF
|
|
|
|
RETURN DO_MISSION_SPEECH(sString)
|
|
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()
|
|
cutsceneStage = F_CUT_STAGE_CLEANUP
|
|
ENDIF
|
|
ENDPROC
|
|
|
|
FUNC BOOL SHOULD_PAUSE_TRAVEL_STAGE_CONVERSATION()
|
|
IF NOT IS_ENTITY_OK(PLAYER_PED_ID())
|
|
RETURN TRUE
|
|
ENDIF
|
|
|
|
IF NOT IS_ENTITY_OK(lamarPed)
|
|
RETURN TRUE
|
|
ENDIF
|
|
|
|
IF GET_PLAYER_WANTED_LEVEL(PLAYER_ID()) > 0
|
|
RETURN TRUE
|
|
ENDIF
|
|
|
|
IF IS_PED_RAGDOLL(lamarPed)
|
|
RETURN TRUE
|
|
ENDIF
|
|
IF IS_PED_RAGDOLL(PLAYER_PED_ID())
|
|
RETURN TRUE
|
|
ENDIF
|
|
|
|
IF GET_DISTANCE_BETWEEN_PEDS(PLAYER_PED_ID(), lamarPed) > 9
|
|
RETURN TRUE
|
|
ENDIF
|
|
|
|
RETURN FALSE
|
|
ENDFUNC
|
|
|
|
PROC HANDLE_TRAVEL_STAGE_CONVERSATION_PAUSES()
|
|
IF NOT IS_FACE_TO_FACE_CONVERSATION_PAUSED()
|
|
IF SHOULD_PAUSE_TRAVEL_STAGE_CONVERSATION()
|
|
PAUSE_FACE_TO_FACE_CONVERSATION(TRUE)
|
|
ENDIF
|
|
ELSE
|
|
IF NOT SHOULD_PAUSE_TRAVEL_STAGE_CONVERSATION()
|
|
PAUSE_FACE_TO_FACE_CONVERSATION(FALSE)
|
|
ENDIF
|
|
ENDIF
|
|
ENDPROC
|
|
|
|
PROC HANDLE_TRAVEL_TEXT()
|
|
SWITCH eTravelCurrentText
|
|
CASE TRAVEL_TEXT_CALL_LAMAR
|
|
IF PLAYER_CALL_CHAR_CELLPHONE(finaleConversation, CHAR_LAMAR, "FINC1AU", "FINC1_LCALL4", CONV_PRIORITY_HIGH)
|
|
|
|
REPLAY_RECORD_BACK_FOR_TIME(5.0, 15.0, REPLAY_IMPORTANCE_HIGHEST)
|
|
|
|
eTravelCurrentText = TRAVEL_TEXT_GO_TO_LAMARS
|
|
ENDIF
|
|
BREAK
|
|
CASE TRAVEL_TEXT_GO_TO_LAMARS
|
|
IF NOT IS_ANY_CONVERSATION_ONGOING_OR_QUEUED()
|
|
IF DO_MISSION_GOD_TEXT("FC1_GOL1")
|
|
eTravelCurrentText = TRAVEL_TEXT_IDLE
|
|
ENDIF
|
|
ENDIF
|
|
BREAK
|
|
CASE TRAVEL_TEXT_APPROACH_LAMAR
|
|
IF NOT IS_PED_INJURED(lamarPed)
|
|
IF NOT IS_PED_RAGDOLL(lamarPed)
|
|
IF NOT IS_ANY_CONVERSATION_ONGOING_OR_QUEUED() AND NOT IS_MESSAGE_BEING_DISPLAYED()
|
|
IF CREATE_CONVERSATION(finaleConversation, "FINC1AU", "FINC1_CALLTO", CONV_PRIORITY_HIGH)
|
|
eTravelCurrentText = TRAVEL_TEXT_IDLE
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
BREAK
|
|
CASE TRAVEL_TEXT_GET_IN_LAMAR
|
|
IF NOT IS_PED_INJURED(lamarPed)
|
|
IF NOT IS_PED_RAGDOLL(lamarPed)
|
|
IF NOT IS_ANY_CONVERSATION_ONGOING_OR_QUEUED() AND NOT IS_MESSAGE_BEING_DISPLAYED()
|
|
IF CREATE_CONVERSATION(finaleConversation, "FINC1AU", "FINC1_GETIN", CONV_PRIORITY_HIGH)
|
|
eTravelCurrentText = TRAVEL_TEXT_IDLE
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
BREAK
|
|
CASE TRAVEL_TEXT_GO_TO_FOUNDRY
|
|
IF NOT IS_ANY_CONVERSATION_ONGOING_OR_QUEUED()
|
|
IF DO_MISSION_GOD_TEXT("FC1_GOF1")
|
|
eTravelCurrentText = TRAVEL_TEXT_BANTER_1
|
|
ENDIF
|
|
ENDIF
|
|
BREAK
|
|
CASE TRAVEL_TEXT_BANTER_1
|
|
HANDLE_TRAVEL_STAGE_CONVERSATION_PAUSES()
|
|
|
|
IF NOT IS_ANY_CONVERSATION_ONGOING_OR_QUEUED() AND NOT IS_MESSAGE_BEING_DISPLAYED()
|
|
IF CREATE_CONVERSATION(finaleConversation, "FINC1AU", "FINC1_VIBE", CONV_PRIORITY_HIGH)
|
|
|
|
REPLAY_RECORD_BACK_FOR_TIME(3.0, 7.0, REPLAY_IMPORTANCE_HIGHEST)
|
|
|
|
eTravelCurrentText = TRAVEL_TEXT_BANTER_2
|
|
ENDIF
|
|
ENDIF
|
|
BREAK
|
|
CASE TRAVEL_TEXT_BANTER_2
|
|
HANDLE_TRAVEL_STAGE_CONVERSATION_PAUSES()
|
|
|
|
IF NOT IS_ANY_CONVERSATION_ONGOING_OR_QUEUED()
|
|
IF CREATE_CONVERSATION(finaleConversation, "FINC1AU", "FINC1_BAN1A1", CONV_PRIORITY_HIGH)
|
|
eTravelCurrentText = TRAVEL_TEXT_BANTER_3
|
|
ENDIF
|
|
ENDIF
|
|
BREAK
|
|
CASE TRAVEL_TEXT_BANTER_3
|
|
HANDLE_TRAVEL_STAGE_CONVERSATION_PAUSES()
|
|
|
|
IF NOT IS_ANY_CONVERSATION_ONGOING_OR_QUEUED()
|
|
IF CREATE_CONVERSATION(finaleConversation, "FINC1AU", "FINC1_BAN1A2", CONV_PRIORITY_HIGH)
|
|
eTravelCurrentText = TRAVEL_TEXT_IDLE
|
|
ENDIF
|
|
ENDIF
|
|
BREAK
|
|
CASE TRAVEL_TEXT_IDLE
|
|
HANDLE_TRAVEL_STAGE_CONVERSATION_PAUSES()
|
|
BREAK
|
|
ENDSWITCH
|
|
ENDPROC
|
|
|
|
PROC DO_STAGE_TRAVEL()
|
|
IF NOT IS_ENTITY_OK(PLAYER_PED_ID())
|
|
EXIT
|
|
ENDIF
|
|
|
|
SET_ALL_RANDOM_PEDS_FLEE_THIS_FRAME(PLAYER_ID())
|
|
|
|
HANDLE_TRAVEL_TEXT()
|
|
|
|
SWITCH eTravelCurrentGoal
|
|
CASE TRAVEL_INIT
|
|
eAudioSceneState = AUDIO_GO_TO_FOUNDRY
|
|
eLamarWaitCarState = LAMAR_WAIT_PHONE_LOOP
|
|
eTravelCurrentText = TRAVEL_TEXT_CALL_LAMAR
|
|
eTravelCurrentGoal = TRAVEL_GO_TO_LAMARS
|
|
// woof
|
|
SET_AMBIENT_ZONE_LIST_STATE_PERSISTENT("AZL_LESTERS_DOGS", TRUE, TRUE)
|
|
BREAK
|
|
CASE TRAVEL_GO_TO_LAMARS
|
|
IF HANDLE_LAMAR_WAITING_TO_BE_PICKED_UP()
|
|
eTravelCurrentText = TRAVEL_TEXT_GO_TO_FOUNDRY
|
|
// in case they see combat en route to foundry
|
|
SET_BLOCKING_OF_NON_TEMPORARY_EVENTS(lamarPed, FALSE)
|
|
|
|
SET_INTERIOR_CAPPED(INTERIOR_V_FOUNDRY, FALSE)
|
|
DOOR_SYSTEM_SET_OPEN_RATIO(ENUM_TO_INT(DOORHASH_FOUNDRY_B_01), 0.2, FALSE, FALSE)
|
|
|
|
eTravelCurrentGoal = TRAVEL_GO_TO_FOUNDRY
|
|
ENDIF
|
|
BREAK
|
|
CASE TRAVEL_GO_TO_FOUNDRY
|
|
IF GET_DISTANCE_BETWEEN_ENTITIES(PLAYER_PED_ID(), lamarPed, FALSE) > ABANDON_BUDDY_FAIL_RANGE
|
|
MISSION_FAILED(FAIL_ABANDONED_LAMAR)
|
|
ENDIF
|
|
IF IS_PLAYER_AT_LOCATION_WITH_BUDDY_ANY_MEANS(Locates_Data, GET_FINALE_VECTOR(FINVEC_PARK), (<<LOCATE_SIZE_ANY_MEANS, LOCATE_SIZE_ANY_MEANS, LOCATE_SIZE_HEIGHT>>), TRUE, lamarPed, "FC1_GOF1", "FC1_GOLAM", DEFAULT, TRUE)
|
|
eTravelCurrentGoal = TRAVEL_ARRIVED_AT_FOUNDRY
|
|
ENDIF
|
|
BREAK
|
|
CASE TRAVEL_ARRIVED_AT_FOUNDRY
|
|
IF IS_PED_IN_ANY_VEHICLE(PLAYER_PED_ID())
|
|
IF BRING_VEHICLE_TO_HALT_AND_DISABLE_VEH_CONTROLS(GET_VEHICLE_PED_IS_IN(PLAYER_PED_ID()), 4.0, 8)
|
|
SET_MISSION_VEHICLE_GEN_VEHICLE(GET_VEHICLE_PED_IS_IN(PLAYER_PED_ID()), GET_FINALE_VECTOR(FINVEC_PARK), PARK_CAR_ROT)
|
|
REPLAY_RECORD_BACK_FOR_TIME(10.0, 3.0, REPLAY_IMPORTANCE_HIGHEST)
|
|
eTravelCurrentGoal = TRAVEL_COMPLETE
|
|
ENDIF
|
|
ELSE
|
|
REPLAY_RECORD_BACK_FOR_TIME(10.0, 3.0, REPLAY_IMPORTANCE_HIGHEST)
|
|
eTravelCurrentGoal = TRAVEL_COMPLETE
|
|
ENDIF
|
|
BREAK
|
|
CASE TRAVEL_COMPLETE
|
|
SET_MISSION_STAGE(STAGE_MEET_GANG, DEFAULT, FALSE)
|
|
BREAK
|
|
ENDSWITCH
|
|
ENDPROC
|
|
|
|
// meeting cutscene proc
|
|
PROC DO_MEETING_CUTSCENE()
|
|
|
|
SWITCH cutsceneStage
|
|
CASE F_CUT_STAGE_INIT
|
|
CLEAR_TEMP_WEAPON_ARRAY()
|
|
|
|
IF NOT IS_PED_INJURED(PLAYER_PED_ID())
|
|
REGISTER_ENTITY_FOR_CUTSCENE(PLAYER_PED_ID(), "Franklin", CU_ANIMATE_EXISTING_SCRIPT_ENTITY)
|
|
GET_CURRENT_PED_WEAPON(PLAYER_PED_ID(), wepFranklinWepGoingIntoMeetup)
|
|
CPRINTLN(DEBUG_MISSION, "Registering Franklin")
|
|
// get Franklin's weapon from pistol slot
|
|
IF GET_PED_WEAPONTYPE_IN_SLOT(GET_FRANKLIN_PED(), WEAPONSLOT_PISTOL) = WEAPONTYPE_INVALID
|
|
oiCS_Weapon[0] = CREATE_WEAPON_OBJECT_FROM_PED_WEAPON_WITH_COMPONENTS(GET_FRANKLIN_PED(), WEAPONTYPE_PISTOL, TRUE, TRUE, 1123.2,-2011.0,36.0)
|
|
ELSE
|
|
oiCS_Weapon[0] = CREATE_WEAPON_OBJECT_FROM_PED_WEAPON_WITH_COMPONENTS(GET_FRANKLIN_PED(), GET_PED_WEAPONTYPE_IN_SLOT(GET_FRANKLIN_PED(), WEAPONSLOT_PISTOL), TRUE, TRUE, 1123.2,-2011.0,36.0)
|
|
ENDIF
|
|
ENDIF
|
|
IF DOES_ENTITY_EXIST(oiCS_Weapon[0])
|
|
REGISTER_ENTITY_FOR_CUTSCENE(oiCS_Weapon[0], "Franklins_weapon", CU_ANIMATE_EXISTING_SCRIPT_ENTITY)
|
|
CPRINTLN(DEBUG_MISSION, "Registering Franklin's weapon")
|
|
ENDIF
|
|
|
|
IF NOT IS_PED_INJURED(sSelectorPeds.pedID[SELECTOR_PED_MICHAEL])
|
|
REGISTER_ENTITY_FOR_CUTSCENE(sSelectorPeds.pedID[SELECTOR_PED_MICHAEL], "Michael", CU_ANIMATE_EXISTING_SCRIPT_ENTITY)
|
|
CPRINTLN(DEBUG_MISSION, "Registering Michael")
|
|
ENDIF
|
|
oiCS_Weapon[1] = CREATE_WEAPON_OBJECT_FROM_CURRENT_PED_WEAPON_WITH_COMPONENTS(GET_MICHAEL_PED(), TRUE, TRUE, 1123.2,-2011.0,36.0)
|
|
IF DOES_ENTITY_EXIST(oiCS_Weapon[1])
|
|
REGISTER_ENTITY_FOR_CUTSCENE(oiCS_Weapon[1], "Michaels_weapon", CU_ANIMATE_EXISTING_SCRIPT_ENTITY)
|
|
CPRINTLN(DEBUG_MISSION, "Registering Michael's weapon")
|
|
ENDIF
|
|
|
|
IF NOT IS_PED_INJURED(sSelectorPeds.pedID[SELECTOR_PED_TREVOR])
|
|
REGISTER_ENTITY_FOR_CUTSCENE(sSelectorPeds.pedID[SELECTOR_PED_TREVOR], "Trevor", CU_ANIMATE_EXISTING_SCRIPT_ENTITY)
|
|
CPRINTLN(DEBUG_MISSION, "Registering Trevor")
|
|
ENDIF
|
|
oiCS_Weapon[2] = CREATE_WEAPON_OBJECT_FROM_CURRENT_PED_WEAPON_WITH_COMPONENTS(GET_TREVOR_PED(), TRUE, TRUE, 1123.2,-2011.0,36.0)
|
|
IF DOES_ENTITY_EXIST(oiCS_Weapon[2])
|
|
REGISTER_ENTITY_FOR_CUTSCENE(oiCS_Weapon[2], "Trevors_weapon", CU_ANIMATE_EXISTING_SCRIPT_ENTITY)
|
|
CPRINTLN(DEBUG_MISSION, "Registering Trevor's weapon")
|
|
ENDIF
|
|
|
|
CREATE_ENEMY_WAVE(EW_FIB_SEARCH, TRUE)
|
|
|
|
IF IS_ENTITY_OK(enemyPed[EP_FIB_SEARCH_FOOT_1].ped)
|
|
//CREATE_WEAPON_OBJECT_FROM_CURRENT_PED_WEAPON_WITH_COMPONENTS()
|
|
REGISTER_ENTITY_FOR_CUTSCENE(enemyPed[EP_FIB_SEARCH_FOOT_1].ped, "Swat_4", CU_ANIMATE_EXISTING_SCRIPT_ENTITY)
|
|
swatWeapons[0] = CREATE_WEAPON_OBJECT_FROM_CURRENT_PED_WEAPON_WITH_COMPONENTS(enemyPed[EP_FIB_SEARCH_FOOT_1].ped)
|
|
REGISTER_ENTITY_FOR_CUTSCENE(swatWeapons[0], "Swat_wpn_4", CU_ANIMATE_EXISTING_SCRIPT_ENTITY)
|
|
ENDIF
|
|
IF IS_ENTITY_OK(enemyPed[EP_FIB_SEARCH_FOOT_2].ped)
|
|
REGISTER_ENTITY_FOR_CUTSCENE(enemyPed[EP_FIB_SEARCH_FOOT_2].ped, "Swat_1", CU_ANIMATE_EXISTING_SCRIPT_ENTITY)
|
|
swatWeapons[1] = CREATE_WEAPON_OBJECT_FROM_CURRENT_PED_WEAPON_WITH_COMPONENTS(enemyPed[EP_FIB_SEARCH_FOOT_2].ped)
|
|
REGISTER_ENTITY_FOR_CUTSCENE(swatWeapons[1], "Swat_wpn_1", CU_ANIMATE_EXISTING_SCRIPT_ENTITY)
|
|
ENDIF
|
|
IF IS_ENTITY_OK(enemyPed[EP_FIB_SEARCH_FOOT_3].ped)
|
|
REGISTER_ENTITY_FOR_CUTSCENE(enemyPed[EP_FIB_SEARCH_FOOT_3].ped, "Swat_2", CU_ANIMATE_EXISTING_SCRIPT_ENTITY)
|
|
swatWeapons[2] = CREATE_WEAPON_OBJECT_FROM_CURRENT_PED_WEAPON_WITH_COMPONENTS(enemyPed[EP_FIB_SEARCH_FOOT_3].ped)
|
|
REGISTER_ENTITY_FOR_CUTSCENE(swatWeapons[2], "Swat_wpn_2", CU_ANIMATE_EXISTING_SCRIPT_ENTITY)
|
|
ENDIF
|
|
IF IS_ENTITY_OK(enemyPed[EP_FIB_SEARCH_FOOT_4].ped)
|
|
REGISTER_ENTITY_FOR_CUTSCENE(enemyPed[EP_FIB_SEARCH_FOOT_4].ped, "Swat_3", CU_ANIMATE_EXISTING_SCRIPT_ENTITY)
|
|
swatWeapons[3] = CREATE_WEAPON_OBJECT_FROM_CURRENT_PED_WEAPON_WITH_COMPONENTS(enemyPed[EP_FIB_SEARCH_FOOT_4].ped)
|
|
REGISTER_ENTITY_FOR_CUTSCENE(swatWeapons[3], "Swat_wpn_3", CU_ANIMATE_EXISTING_SCRIPT_ENTITY)
|
|
ENDIF
|
|
|
|
REPLAY_RECORD_BACK_FOR_TIME(15.0, 0.0, REPLAY_IMPORTANCE_HIGHEST)
|
|
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
|
|
|
|
START_CUTSCENE(flags)
|
|
|
|
SET_CUTSCENE_FADE_VALUES(FALSE, FALSE, FALSE, FALSE)
|
|
cutsceneStage = F_CUT_STAGE_RUNNING
|
|
BREAK
|
|
|
|
CASE F_CUT_STAGE_RUNNING
|
|
IF NOT bClearedForCutscene
|
|
IF IS_CUTSCENE_PLAYING()
|
|
STOP_GAMEPLAY_HINT()
|
|
|
|
SET_MISSION_MOCAP_CUTSCENE()
|
|
// Clear porjectiles only in smaller volume, so sticky bombs are left in place elsewhere
|
|
CLEAR_AREA(<<1114.48999, -2004.87671, 34.44437>>, 120, FALSE)
|
|
CLEAR_AREA(<<1116.57056, -2004.61499, 34.44438>>, 12, TRUE)
|
|
|
|
RESOLVE_VEHICLES_INSIDE_ANGLED_AREA(tbFoundryExcess.vMin, tbFoundryExcess.vMax, tbFoundryExcess.flWidth, GET_FINALE_VECTOR(FINVEC_PARK), PARK_CAR_ROT)
|
|
|
|
TRIGGER_MUSIC_EVENT("FIN1_PREP")
|
|
|
|
SET_PLAYER_PED_WITH_HEADSET(CHAR_MICHAEL, TRUE)
|
|
SET_PLAYER_PED_WITH_HEADSET(CHAR_TREVOR, TRUE)
|
|
SET_PLAYER_PED_WITH_HEADSET(CHAR_FRANKLIN, TRUE)
|
|
|
|
IF DOES_ENTITY_EXIST(lamarPed)
|
|
REMOVE_ENTITY_FROM_AUDIO_MIX_GROUP(lamarPed)
|
|
DELETE_PED(lamarPed)
|
|
ENDIF
|
|
bClearedForCutscene = TRUE
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF NOT bDoneMichaelShoutCue
|
|
IF bPreparedMichaelShoutCue
|
|
bDoneMichaelShoutCue = TRIGGER_MUSIC_EVENT("FIN1_START")
|
|
ELSE
|
|
bPreparedMichaelShoutCue = PREPARE_MUSIC_EVENT("FIN1_START")
|
|
ENDIF
|
|
ENDIF
|
|
|
|
//Start the ringtone for the phone
|
|
IF bRingToneStarted = FALSE
|
|
IF GET_CUTSCENE_TIME() > 20550
|
|
PLAY_PED_RINGTONE(g_savedGlobals.sCellphoneSettingsData.This_Cellphone_Owner_Settings[g_Cellphone.PhoneOwner].RingtoneForThisPlayer, PLAYER_PED_ID(), false)
|
|
CPRINTLN(DEBUG_MISSION, "PLAY_PED_RINGTONE NOW")
|
|
bRingToneStarted = TRUE
|
|
ENDIF
|
|
ENDIF
|
|
//Stop the ringtone for the phone
|
|
IF bRingToneStopped = FALSE
|
|
IF IS_PED_RINGTONE_PLAYING(PLAYER_PED_ID())
|
|
AND GET_CUTSCENE_TIME() > 22400
|
|
STOP_PED_RINGTONE(PLAYER_PED_ID())
|
|
CPRINTLN(DEBUG_MISSION, "STOP_PED_RINGTONE NOW")
|
|
bRingToneStopped = TRUE
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF NOT bPreparedSWATCue AND bDoneMichaelShoutCue
|
|
bPreparedSWATCue = PREPARE_MUSIC_EVENT("FIN1_SWAT_ARRIVE")
|
|
ELSE
|
|
IF NOT bDoneSWATCue
|
|
IF GET_CUTSCENE_TIME() >= 66500
|
|
bDoneSWATCue = TRIGGER_MUSIC_EVENT("FIN1_SWAT_ARRIVE")
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF CAN_SET_EXIT_STATE_FOR_REGISTERED_ENTITY("Michael")
|
|
IF IS_ENTITY_OK(GET_MICHAEL_PED())
|
|
TASK_PUT_PED_DIRECTLY_INTO_COVER(GET_MICHAEL_PED(), GET_PLAYER_COVER_COORD(ENUM_TO_INT(SELECTOR_PED_TREVOR)), -1, FALSE, 0.0, FALSE, FALSE, initialCover[ENUM_TO_INT(SELECTOR_PED_MICHAEL)])
|
|
FORCE_PED_AI_AND_ANIMATION_UPDATE(GET_MICHAEL_PED())
|
|
ENDIF
|
|
ENDIF
|
|
IF CAN_SET_EXIT_STATE_FOR_REGISTERED_ENTITY("Michaels_weapon")
|
|
DELETE_THIS_OBJECT(oiCS_Weapon[1])
|
|
ENDIF
|
|
|
|
IF CAN_SET_EXIT_STATE_FOR_REGISTERED_ENTITY("Swat_wpn_4")
|
|
DELETE_THIS_OBJECT(swatWeapons[0])
|
|
ENDIF
|
|
IF CAN_SET_EXIT_STATE_FOR_REGISTERED_ENTITY("Swat_wpn_1")
|
|
DELETE_THIS_OBJECT(swatWeapons[1])
|
|
ENDIF
|
|
IF CAN_SET_EXIT_STATE_FOR_REGISTERED_ENTITY("Swat_wpn_2")
|
|
DELETE_THIS_OBJECT(swatWeapons[2])
|
|
ENDIF
|
|
IF CAN_SET_EXIT_STATE_FOR_REGISTERED_ENTITY("Swat_wpn_3")
|
|
DELETE_THIS_OBJECT(swatWeapons[3])
|
|
ENDIF
|
|
|
|
IF CAN_SET_EXIT_STATE_FOR_REGISTERED_ENTITY("Trevor")
|
|
IF IS_ENTITY_OK(GET_TREVOR_PED())
|
|
TASK_PUT_PED_DIRECTLY_INTO_COVER(GET_TREVOR_PED(), GET_PLAYER_COVER_COORD(ENUM_TO_INT(SELECTOR_PED_MICHAEL)), -1, FALSE, 0.0, FALSE, FALSE, initialCover[ENUM_TO_INT(SELECTOR_PED_TREVOR)])
|
|
FORCE_PED_AI_AND_ANIMATION_UPDATE(GET_TREVOR_PED())
|
|
ENDIF
|
|
ENDIF
|
|
IF CAN_SET_EXIT_STATE_FOR_REGISTERED_ENTITY("Trevors_weapon")
|
|
DELETE_THIS_OBJECT(oiCS_Weapon[2])
|
|
ENDIF
|
|
IF CAN_SET_EXIT_STATE_FOR_REGISTERED_ENTITY("Franklin")
|
|
IF IS_ENTITY_OK(GET_FRANKLIN_PED())
|
|
TASK_PUT_PED_DIRECTLY_INTO_COVER(GET_FRANKLIN_PED(), GET_PLAYER_COVER_COORD(ENUM_TO_INT(SELECTOR_PED_FRANKLIN)), -1, FALSE, 0.5, TRUE, FALSE, initialCover[ENUM_TO_INT(SELECTOR_PED_FRANKLIN)])
|
|
FORCE_PED_AI_AND_ANIMATION_UPDATE(GET_FRANKLIN_PED())
|
|
ENDIF
|
|
ENDIF
|
|
// Give weapons here as Franklin is the only one on screen
|
|
IF CAN_SET_EXIT_STATE_FOR_REGISTERED_ENTITY("Franklins_weapon")
|
|
DELETE_THIS_OBJECT(oiCS_Weapon[0])
|
|
IF WAS_CUTSCENE_SKIPPED() AND IS_WEAPON_VALID(wepFranklinWepGoingIntoMeetup) AND wepFranklinWepGoingIntoMeetup <> WEAPONTYPE_UNARMED
|
|
GIVE_CHARACTERS_WEAPONS(FALSE)
|
|
SET_CURRENT_PED_WEAPON(GET_FRANKLIN_PED(), wepFranklinWepGoingIntoMeetup, TRUE)
|
|
ELSE
|
|
GIVE_CHARACTERS_WEAPONS()
|
|
ENDIF
|
|
ENDIF
|
|
|
|
// this may not be good
|
|
// @BSW OMGHAX
|
|
IF CAN_SET_EXIT_STATE_FOR_REGISTERED_ENTITY("Swat_4")
|
|
OR CAN_SET_EXIT_STATE_FOR_REGISTERED_ENTITY("Swat_1")
|
|
OR CAN_SET_EXIT_STATE_FOR_REGISTERED_ENTITY("Swat_2")
|
|
OR CAN_SET_EXIT_STATE_FOR_REGISTERED_ENTITY("Swat_3")
|
|
SET_FIB_TO_SEARCH()
|
|
ENDIF
|
|
|
|
IF CAN_SET_EXIT_STATE_FOR_CAMERA()
|
|
|
|
REPLAY_STOP_EVENT()
|
|
|
|
bResetViewOnSkip = FALSE
|
|
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(-15.0)
|
|
ELSE
|
|
IF WAS_CUTSCENE_SKIPPED()
|
|
SET_GAMEPLAY_CAM_RELATIVE_HEADING(-3.0)
|
|
SET_GAMEPLAY_CAM_RELATIVE_PITCH(-2.5)
|
|
bResetViewOnSkip = TRUE
|
|
ELSE
|
|
SET_GAMEPLAY_CAM_RELATIVE_HEADING(87.0)
|
|
SET_GAMEPLAY_CAM_RELATIVE_PITCH(-2.5)
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF NOT IS_CUTSCENE_PLAYING()
|
|
SET_MISSION_CUTSCENE(FALSE, DEFAULT, DEFAULT, DEFAULT, DEFAULT, DEFAULT, DEFAULT, FALSE)
|
|
SET_MISSION_STAGE(STAGE_SHOOTOUT_STAGE_1)
|
|
IF bResetViewOnSkip
|
|
SET_GAMEPLAY_CAM_RELATIVE_HEADING(87)
|
|
SET_GAMEPLAY_CAM_RELATIVE_PITCH(-2.5)
|
|
ENDIF
|
|
IF IS_PED_RINGTONE_PLAYING(PLAYER_PED_ID())
|
|
STOP_PED_RINGTONE(PLAYER_PED_ID())
|
|
CPRINTLN(DEBUG_MISSION, "CUTSCENE SKIPPED: STOP_PED_RINGTONE NOW")
|
|
ENDIF
|
|
ENDIF
|
|
|
|
#IF IS_DEBUG_BUILD
|
|
DEBUG_SKIP_MOCAP()
|
|
#ENDIF
|
|
BREAK
|
|
|
|
CASE F_CUT_STAGE_CLEANUP
|
|
|
|
BREAK
|
|
ENDSWITCH
|
|
ENDPROC
|
|
|
|
VEHICLE_INDEX fakeFranklinBike
|
|
PROC DO_REGROUP_CUTSCENE()
|
|
IF IS_VEHICLE_DRIVEABLE(finaleVehicle[FV_FRANKLIN_CAR])
|
|
SET_FORCE_HD_VEHICLE(finaleVehicle[FV_FRANKLIN_CAR], TRUE)
|
|
ENDIF
|
|
|
|
IF IS_VEHICLE_DRIVEABLE(fakeFranklinBike)
|
|
SET_FORCE_HD_VEHICLE(fakeFranklinBike, TRUE)
|
|
ENDIF
|
|
|
|
SWITCH cutsceneStage
|
|
CASE F_CUT_STAGE_INIT
|
|
//SET_MISSION_CUTSCENE(TRUE)
|
|
|
|
PED_INDEX michaelPed
|
|
michaelPed = GET_MICHAEL_PED()
|
|
PED_INDEX franklinPed
|
|
franklinPed = GET_FRANKLIN_PED()
|
|
PED_INDEX trevorPed
|
|
trevorPed = GET_TREVOR_PED()
|
|
|
|
IF NOT IS_PED_INJURED(michaelPed)
|
|
TASK_CLEAR_LOOK_AT(michaelPed)
|
|
DETACH_ENTITY(michaelPed)
|
|
REGISTER_ENTITY_FOR_CUTSCENE(michaelPed, "Michael", CU_ANIMATE_EXISTING_SCRIPT_ENTITY)
|
|
ENDIF
|
|
IF NOT IS_PED_INJURED(franklinPed)
|
|
TASK_CLEAR_LOOK_AT(franklinPed)
|
|
DETACH_ENTITY(franklinPed)
|
|
REGISTER_ENTITY_FOR_CUTSCENE(franklinPed, "Franklin", CU_ANIMATE_EXISTING_SCRIPT_ENTITY)
|
|
ENDIF
|
|
IF NOT IS_PED_INJURED(trevorPed)
|
|
TASK_CLEAR_LOOK_AT(trevorPed)
|
|
DETACH_ENTITY(trevorPed)
|
|
REGISTER_ENTITY_FOR_CUTSCENE(trevorPed, "Trevor", CU_ANIMATE_EXISTING_SCRIPT_ENTITY)
|
|
ENDIF
|
|
REGISTER_ENTITY_FOR_CUTSCENE(finaleVehicle[FV_FRANKLIN_CAR], "Franklin_Bike", CU_CREATE_AND_ANIMATE_NEW_SCRIPT_ENTITY, BAGGER)
|
|
REGISTER_ENTITY_FOR_CUTSCENE(finaleVehicle[FV_MICHAEL_CAR], "Michaels_car", CU_CREATE_AND_ANIMATE_NEW_SCRIPT_ENTITY, TAILGATER)
|
|
REGISTER_ENTITY_FOR_CUTSCENE(finaleVehicle[FV_TREVOR_CAR], "Trevors_car", CU_CREATE_AND_ANIMATE_NEW_SCRIPT_ENTITY, BODHI2)
|
|
|
|
REPLAY_RECORD_BACK_FOR_TIME(15.0, 0.0)
|
|
|
|
REPLAY_START_EVENT(REPLAY_IMPORTANCE_HIGHEST)
|
|
|
|
CUTSCENE_OPTION_FLAGS flags
|
|
IF GET_CURRENT_PLAYER_PED_ENUM() = CHAR_FRANKLIN
|
|
flags = CUTSCENE_NO_OPTIONS
|
|
ELSE
|
|
flags = CUTSCENE_PLAYER_FP_FLASH_FRANKLIN
|
|
ENDIF
|
|
|
|
SET_VEHICLE_MODEL_PLAYER_WILL_EXIT_SCENE(BAGGER)
|
|
START_CUTSCENE(flags)
|
|
|
|
SET_CUTSCENE_FADE_VALUES(FALSE, FALSE, FALSE, FALSE)
|
|
cutsceneStage = F_CUT_STAGE_RUNNING
|
|
BREAK
|
|
|
|
CASE F_CUT_STAGE_RUNNING
|
|
IF NOT bClearedForCutscene
|
|
IF IS_CUTSCENE_PLAYING()
|
|
PIN_FOUNDRY_INTERIOR(FALSE)
|
|
|
|
INT i
|
|
REPEAT COUNT_OF(enemyPed) i
|
|
IF DOES_ENTITY_EXIST(enemyPed[i].ped)
|
|
DELETE_PED(enemyPed[i].ped)
|
|
ENDIF
|
|
ENDREPEAT
|
|
REPEAT COUNT_OF(enemyVehicle) i
|
|
IF DOES_ENTITY_EXIST(enemyVehicle[i].veh)
|
|
DELETE_VEHICLE(enemyVehicle[i].veh)
|
|
ENDIF
|
|
ENDREPEAT
|
|
REPEAT NUMBER_BARRELS i
|
|
IF DOES_ENTITY_EXIST(interiorBarrelObject[i])
|
|
DELETE_OBJECT(interiorBarrelObject[i])
|
|
ENDIF
|
|
ENDREPEAT
|
|
IF NOT IS_PED_INJURED(lamarPed)
|
|
REMOVE_ENTITY_FROM_AUDIO_MIX_GROUP(lamarPed)
|
|
DELETE_PED(lamarPed)
|
|
ENDIF
|
|
IF DOES_ENTITY_EXIST(exteriorBarrelObject[0])
|
|
DELETE_OBJECT(exteriorBarrelObject[0])
|
|
ENDIF
|
|
// reposition lamar car as a cargen at franklin's for after pass
|
|
IF IS_VEHICLE_DRIVEABLE(finaleVehicle[FV_MISSION_START_CAR])
|
|
IF IS_REPLAY_VEHICLE_MODEL_UNDER_SIZE_LIMIT(GET_ENTITY_MODEL(finaleVehicle[FV_MISSION_START_CAR]), GET_DEFAULT_ALLOWABLE_VEHICLE_SIZE_VECTOR())
|
|
IF NOT IS_VEHICLE_A_PLAYER_PERSONAL_VEHICLE(finaleVehicle[FV_MISSION_START_CAR], CHAR_FRANKLIN, VEHICLE_TYPE_CAR)
|
|
AND NOT IS_VEHICLE_A_PLAYER_PERSONAL_VEHICLE(finaleVehicle[FV_MISSION_START_CAR], CHAR_FRANKLIN, VEHICLE_TYPE_BIKE)
|
|
SET_MISSION_VEHICLE_GEN_VEHICLE(finaleVehicle[FV_MISSION_START_CAR], <<1.5947, 543.4017, 173.46439>>, 310.7556)
|
|
ENDIF
|
|
ENDIF
|
|
ELSE
|
|
IF DOES_ENTITY_EXIST(finaleVehicle[FV_MISSION_START_CAR])
|
|
AND DOES_ENTITY_BELONG_TO_THIS_SCRIPT(finaleVehicle[FV_MISSION_START_CAR], FALSE)
|
|
DELETE_VEHICLE(finaleVehicle[FV_MISSION_START_CAR])
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF GET_CURRENT_PLAYER_PED_ENUM() <> CHAR_FRANKLIN
|
|
MAKE_SELECTOR_PED_SELECTION(sSelectorPeds, SELECTOR_PED_FRANKLIN)
|
|
TAKE_CONTROL_OF_SELECTOR_PED(sSelectorPeds, TRUE, TRUE, TCF_CLEAR_TASK_INTERRUPT_CHECKS)
|
|
|
|
REAPPLY_PLAYER_PED_ATTRIBUTES(currentMissionStage)
|
|
ENDIF
|
|
|
|
REQUEST_VEHICLE_ASSET(BAGGER)
|
|
REQUEST_ANIM_DICT("veh@bike@police@front@base")
|
|
|
|
REMOVE_ALL_BLIPS()
|
|
|
|
RESET_MISSION_STATS_ENTITY_WATCH()
|
|
|
|
SET_MISSION_MOCAP_CUTSCENE()
|
|
|
|
// clear the area
|
|
CLEAR_AREA(GET_FINALE_VECTOR(FINVEC_REGROUP), 7.0, TRUE)
|
|
|
|
IF NOT IS_SCREEN_FADED_IN()
|
|
DO_SCREEN_FADE_IN(DEFAULT_FADE_TIME)
|
|
ENDIF
|
|
|
|
bClearedForCutscene = TRUE
|
|
|
|
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF NOT DOES_ENTITY_EXIST(finaleVehicle[FV_FRANKLIN_CAR])
|
|
PRINTSTRING("look for franklin bike!") PRINTNL()
|
|
IF DOES_ENTITY_EXIST(GET_ENTITY_INDEX_OF_REGISTERED_ENTITY("Franklin_Bike"))
|
|
PRINTSTRING("franklin bike in cutscene") PRINTNL()
|
|
finaleVehicle[FV_FRANKLIN_CAR] = GET_VEHICLE_INDEX_FROM_ENTITY_INDEX(GET_ENTITY_INDEX_OF_REGISTERED_ENTITY("Franklin_Bike"))
|
|
ENDIF
|
|
ELSE
|
|
PRINTSTRING("got franklin bike!") PRINTNL()
|
|
ENDIF
|
|
|
|
IF NOT DOES_ENTITY_EXIST(finaleVehicle[FV_MICHAEL_CAR])
|
|
IF DOES_ENTITY_EXIST(GET_ENTITY_INDEX_OF_REGISTERED_ENTITY("Michaels_car"))
|
|
finaleVehicle[FV_MICHAEL_CAR] = GET_VEHICLE_INDEX_FROM_ENTITY_INDEX(GET_ENTITY_INDEX_OF_REGISTERED_ENTITY("Michaels_car"))
|
|
ENDIF
|
|
ELSE
|
|
PRINTSTRING("got michael car!") PRINTNL()
|
|
ENDIF
|
|
|
|
IF NOT DOES_ENTITY_EXIST(finaleVehicle[FV_TREVOR_CAR])
|
|
IF DOES_ENTITY_EXIST(GET_ENTITY_INDEX_OF_REGISTERED_ENTITY("Trevors_car"))
|
|
finaleVehicle[FV_TREVOR_CAR] = GET_VEHICLE_INDEX_FROM_ENTITY_INDEX(GET_ENTITY_INDEX_OF_REGISTERED_ENTITY("Trevors_car"))
|
|
ENDIF
|
|
ELSE
|
|
PRINTSTRING("got trevor car!") PRINTNL()
|
|
ENDIF
|
|
|
|
IF NOT DOES_ENTITY_EXIST(fakeFranklinBike)
|
|
CREATE_PLAYER_VEHICLE(fakeFranklinBike, CHAR_FRANKLIN, <<1023.7, -2042.1, 30.02007>>, 147.5, FALSE, VEHICLE_TYPE_BIKE)
|
|
IF IS_VEHICLE_DRIVEABLE(fakeFranklinBike)
|
|
SET_VEHICLE_ON_GROUND_PROPERLY(fakeFranklinBike)
|
|
SET_ENTITY_VISIBLE(fakeFranklinBike, FALSE)
|
|
ENDIF
|
|
ENDIF
|
|
|
|
|
|
IF NOT bDoneAtVehiclesCue
|
|
IF GET_CUTSCENE_TIME() >= 94350
|
|
bDoneAtVehiclesCue = TRIGGER_MUSIC_EVENT("FIN1_AT_VEHICLES")
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF CAN_SET_EXIT_STATE_FOR_REGISTERED_ENTITY("Trevors_car")
|
|
IF DOES_ENTITY_EXIST(finaleVehicle[FV_TREVOR_CAR])
|
|
DELETE_VEHICLE(finaleVehicle[FV_TREVOR_CAR])
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF CAN_SET_EXIT_STATE_FOR_REGISTERED_ENTITY("Michaels_car")
|
|
IF IS_VEHICLE_DRIVEABLE(finaleVehicle[FV_MICHAEL_CAR])
|
|
DELETE_VEHICLE(finaleVehicle[FV_MICHAEL_CAR])
|
|
//g_sTriggerSceneAssets.veh[1] = finaleVehicle[FV_MICHAEL_CAR]
|
|
//SET_FINALE_VEHICLE_PROPERTIES(FV_MICHAEL_CAR)
|
|
//IF WAS_CUTSCENE_SKIPPED()
|
|
// SET_ENTITY_COORDS(finaleVehicle[FV_MICHAEL_CAR], <<989.67328, -2076.10498, 30.06461>>)
|
|
// SET_ENTITY_HEADING(finaleVehicle[FV_MICHAEL_CAR], 88.6)
|
|
// SET_VEHICLE_ON_GROUND_PROPERLY(finaleVehicle[FV_MICHAEL_CAR])
|
|
//ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF CAN_SET_EXIT_STATE_FOR_REGISTERED_ENTITY("Franklin_Bike")
|
|
IF IS_VEHICLE_DRIVEABLE(finaleVehicle[FV_FRANKLIN_CAR])
|
|
DELETE_VEHICLE(finaleVehicle[FV_FRANKLIN_CAR])
|
|
finaleVehicle[FV_FRANKLIN_CAR] = fakeFranklinBike
|
|
g_sTriggerSceneAssets.veh[2] = finaleVehicle[FV_FRANKLIN_CAR]
|
|
SET_FINALE_VEHICLE_PROPERTIES(FV_FRANKLIN_CAR)
|
|
IF WAS_CUTSCENE_SKIPPED()
|
|
SET_ENTITY_COORDS(finaleVehicle[FV_FRANKLIN_CAR], <<1022.91, -2041.58, 30.01>>)
|
|
SET_ENTITY_HEADING(finaleVehicle[FV_FRANKLIN_CAR], 144.89)
|
|
SET_VEHICLE_ON_GROUND_PROPERLY(finaleVehicle[FV_FRANKLIN_CAR])
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF CAN_SET_EXIT_STATE_FOR_REGISTERED_ENTITY("Franklin")
|
|
SET_PED_CONFIG_FLAG(PLAYER_PED_ID(), PCF_WaitingForPlayerControlInterrupt, TRUE)
|
|
SET_PED_USING_ACTION_MODE(PLAYER_PED_ID(), FALSE)
|
|
|
|
IF IS_VEHICLE_DRIVEABLE(fakeFranklinBike)
|
|
SET_PED_INTO_VEHICLE(PLAYER_PED_ID(), fakeFranklinBike)
|
|
SET_ENTITY_VISIBLE(fakeFranklinBike, TRUE)
|
|
TASK_PLAY_ANIM(PLAYER_PED_ID(), "veh@bike@police@front@base", "still", INSTANT_BLEND_IN, REALLY_SLOW_BLEND_OUT, 500)
|
|
FORCE_PED_AI_AND_ANIMATION_UPDATE(PLAYER_PED_ID())
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF CAN_SET_EXIT_STATE_FOR_REGISTERED_ENTITY("Trevor")
|
|
IF NOT IS_PED_INJURED(sSelectorPeds.pedID[SELECTOR_PED_TREVOR])
|
|
g_sTriggerSceneAssets.ped[0] = sSelectorPeds.pedID[SELECTOR_PED_TREVOR]
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF CAN_SET_EXIT_STATE_FOR_REGISTERED_ENTITY("Michael")
|
|
IF NOT IS_PED_INJURED(sSelectorPeds.pedID[SELECTOR_PED_MICHAEL])
|
|
g_sTriggerSceneAssets.ped[1] = sSelectorPeds.pedID[SELECTOR_PED_MICHAEL]
|
|
//IF IS_VEHICLE_DRIVEABLE(finaleVehicle[FV_MICHAEL_CAR])
|
|
// TASK_CLEAR_LOOK_AT(sSelectorPeds.pedID[SELECTOR_PED_MICHAEL])
|
|
// SET_PED_INTO_VEHICLE(sSelectorPeds.pedID[SELECTOR_PED_MICHAEL], finaleVehicle[FV_MICHAEL_CAR])
|
|
// TASK_VEHICLE_DRIVE_TO_COORD_LONGRANGE(sSelectorPeds.pedID[SELECTOR_PED_MICHAEL], finaleVehicle[FV_MICHAEL_CAR], <<957.74481, -2076.55249, 29.75380>>, 20.0, DRIVINGMODE_AVOIDCARS, 4.0)
|
|
//ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF CAN_SET_EXIT_STATE_FOR_CAMERA()
|
|
SET_GAMEPLAY_CAM_RELATIVE_HEADING(0.0)
|
|
|
|
IF WAS_CUTSCENE_SKIPPED()
|
|
TRIGGER_MUSIC_EVENT("FIN1_CS_SKIP")
|
|
ENDIF
|
|
|
|
IF DOES_ENTITY_EXIST(finaleVehicle[FV_MICHAEL_CAR])
|
|
DELETE_VEHICLE(finaleVehicle[FV_MICHAEL_CAR])
|
|
ENDIF
|
|
|
|
SET_MISSION_CUTSCENE(FALSE, TRUE, TRUE, FALSE, TRUE, FALSE, DEFAULT_PED_CAM_INTERP_TIME, FALSE)
|
|
IF IS_VEHICLE_DRIVEABLE(finaleVehicle[FV_FRANKLIN_CAR])
|
|
SET_FORCE_HD_VEHICLE(finaleVehicle[FV_FRANKLIN_CAR], TRUE)
|
|
ENDIF
|
|
WAIT_WITH_RECORD()
|
|
IF IS_VEHICLE_DRIVEABLE(finaleVehicle[FV_FRANKLIN_CAR])
|
|
SET_FORCE_HD_VEHICLE(finaleVehicle[FV_FRANKLIN_CAR], TRUE)
|
|
ENDIF
|
|
|
|
REPLAY_STOP_EVENT()
|
|
|
|
MISSION_PASSED()
|
|
ENDIF
|
|
|
|
#IF IS_DEBUG_BUILD
|
|
DEBUG_SKIP_MOCAP()
|
|
#ENDIF
|
|
BREAK
|
|
|
|
CASE F_CUT_STAGE_CLEANUP
|
|
|
|
BREAK
|
|
ENDSWITCH
|
|
ENDPROC
|
|
|
|
FUNC BOOL HANDLE_INTERFERING_WITH_TREVOR_AND_MICHAEL(PED_INDEX piChar)
|
|
IF NOT IS_PED_INJURED(piChar)
|
|
IF IS_PED_RAGDOLL(piChar)
|
|
OR HAS_ENTITY_BEEN_DAMAGED_BY_ANY_PED(piChar)
|
|
EXPLODE_PED_HEAD(piChar)
|
|
APPLY_DAMAGE_TO_PED(piChar, 10000, TRUE)
|
|
RETURN TRUE
|
|
ENDIF
|
|
ENDIF
|
|
RETURN FALSE
|
|
ENDFUNC
|
|
|
|
PROC HANDLE_LAMAR_ARRIVES_AT_FOUNDRY()
|
|
// handle lamar walk
|
|
IF NOT IS_PED_INJURED(lamarPed)
|
|
SWITCH lamarWalkStage
|
|
CASE LAMAR_LEAVE_CAR
|
|
SET_BLOCKING_OF_NON_TEMPORARY_EVENTS(lamarPed, TRUE)
|
|
SET_ENTITY_ONLY_DAMAGED_BY_PLAYER(lamarPed, TRUE)
|
|
CLEAR_SEQUENCE_TASK(sequence)
|
|
OPEN_SEQUENCE_TASK(sequence)
|
|
TASK_LEAVE_ANY_VEHICLE(NULL)
|
|
CLOSE_SEQUENCE_TASK(sequence)
|
|
TASK_PERFORM_SEQUENCE(lamarPed, sequence)
|
|
TASK_LOOK_AT_ENTITY(lamarPed, PLAYER_PED_ID(), -1, SLF_WHILE_NOT_IN_FOV)
|
|
|
|
lamarWalkStage = LAMAR_WALK_IN_CAR
|
|
BREAK
|
|
CASE LAMAR_WALK_IN_CAR
|
|
IF GET_SCRIPT_TASK_STATUS(lamarPed, SCRIPT_TASK_PERFORM_SEQUENCE) = FINISHED_TASK
|
|
CLEAR_SEQUENCE_TASK(sequence)
|
|
OPEN_SEQUENCE_TASK(sequence)
|
|
TASK_TURN_PED_TO_FACE_ENTITY(NULL, PLAYER_PED_ID(), -1)
|
|
CLOSE_SEQUENCE_TASK(sequence)
|
|
TASK_PERFORM_SEQUENCE(lamarPed, sequence)
|
|
|
|
lamarWalkStage = LAMAR_WALK_LOOK_AT_FRANKLIN
|
|
ENDIF
|
|
BREAK
|
|
CASE LAMAR_WALK_LOOK_AT_FRANKLIN
|
|
TASK_FOLLOW_NAV_MESH_TO_COORD(lamarPed, GET_FINALE_VECTOR(FINVEC_LAMAR_SHOOTOUT), PEDMOVE_WALK)
|
|
lamarWalkStage = LAMAR_WALK_TO_PATH_START
|
|
BREAK
|
|
CASE LAMAR_WALK_TO_PATH_START
|
|
IF IS_ENTITY_AT_COORD(lamarPed, GET_FINALE_VECTOR(FINVEC_LAMAR_SHOOTOUT), <<1.5,1.5,2>>)
|
|
GIVE_WEAPON_TO_PED(lamarPed, WEAPONTYPE_ASSAULTRIFLE, 1000)
|
|
lamarWalkStage = LAMAR_WALK_ON_PATH
|
|
ENDIF
|
|
BREAK
|
|
// now having Lamar on lookout
|
|
CASE LAMAR_WALK_ON_PATH
|
|
CLEAR_SEQUENCE_TASK(sequence)
|
|
OPEN_SEQUENCE_TASK(sequence)
|
|
TASK_ACHIEVE_HEADING(NULL, 100.0)
|
|
TASK_SWAP_WEAPON(NULL, TRUE)
|
|
TASK_PLAY_ANIM(NULL, GET_FINALE_ANIM_DICT_AS_STRING(F_ANIM_DICT_LAMAR_LOOKOUT), "trevor_waiting_impatient_a", SLOW_BLEND_IN, NORMAL_BLEND_OUT, -1, AF_LOOPING | AF_NOT_INTERRUPTABLE)
|
|
CLOSE_SEQUENCE_TASK(sequence)
|
|
TASK_PERFORM_SEQUENCE(lamarPed, sequence)
|
|
CLEAR_SEQUENCE_TASK(sequence)
|
|
|
|
lamarWalkStage = LAMAR_WALK_PLAYING_ANIM
|
|
BREAK
|
|
CASE LAMAR_WALK_PLAYING_ANIM
|
|
IF IS_ENTITY_PLAYING_ANIM(lamarPed, GET_FINALE_ANIM_DICT_AS_STRING(F_ANIM_DICT_LAMAR_LOOKOUT), "trevor_waiting_impatient_a")
|
|
CPRINTLN(DEBUG_MISSION, "Lowering Lamar's anim speed")
|
|
SET_ENTITY_ANIM_SPEED(lamarPed, GET_FINALE_ANIM_DICT_AS_STRING(F_ANIM_DICT_LAMAR_LOOKOUT), "trevor_waiting_impatient_a", 0.8)
|
|
SET_PED_USING_ACTION_MODE(lamarPed, TRUE)
|
|
TASK_LOOK_AT_ENTITY(lamarPed, PLAYER_PED_ID(), -1, SLF_WHILE_NOT_IN_FOV, SLF_LOOKAT_VERY_HIGH)
|
|
lamarWalkStage = LAMAR_WALK_DONE
|
|
ENDIF
|
|
BREAK
|
|
CASE LAMAR_WALK_DONE
|
|
// since he's playing his uninterruptible anim
|
|
// molotovs wont kill him, so handle that specifically
|
|
IF IS_ENTITY_ON_FIRE(lamarPed)
|
|
MISSION_FAILED(FAIL_LAMAR_DEAD)
|
|
CLEAR_PED_TASKS(lamarPed)
|
|
ENDIF
|
|
BREAK
|
|
ENDSWITCH
|
|
ENDIF
|
|
ENDPROC
|
|
|
|
PROC HANDLE_ARGUMENT()
|
|
IF bCutsceneWaitStarted
|
|
EXIT
|
|
ENDIF
|
|
|
|
SWITCH eArgumentCurrentText
|
|
CASE ARG_TEXT_LI1
|
|
IF NOT IS_ANY_CONVERSATION_ONGOING_OR_QUEUED()
|
|
IF CREATE_CONVERSATION(finaleConversation, "FINC1AU", "FINC1_LI1", CONV_PRIORITY_VERY_HIGH)
|
|
eArgumentCurrentText = ARG_TEXT_LI2
|
|
ENDIF
|
|
ENDIF
|
|
BREAK
|
|
CASE ARG_TEXT_LI2
|
|
IF NOT IS_ANY_CONVERSATION_ONGOING_OR_QUEUED()
|
|
IF CREATE_CONVERSATION(finaleConversation, "FINC1AU", "FINC1_LI2", CONV_PRIORITY_VERY_HIGH)
|
|
eArgumentCurrentText = ARG_TEXT_LI3
|
|
ENDIF
|
|
ENDIF
|
|
BREAK
|
|
CASE ARG_TEXT_LI3
|
|
IF NOT IS_ANY_CONVERSATION_ONGOING_OR_QUEUED()
|
|
IF CREATE_CONVERSATION(finaleConversation, "FINC1AU", "FINC1_LI3", CONV_PRIORITY_VERY_HIGH)
|
|
eArgumentCurrentText = ARG_TEXT_LI4
|
|
ENDIF
|
|
ENDIF
|
|
BREAK
|
|
CASE ARG_TEXT_LI4
|
|
IF NOT IS_ANY_CONVERSATION_ONGOING_OR_QUEUED()
|
|
IF CREATE_CONVERSATION(finaleConversation, "FINC1AU", "FINC1_LI4", CONV_PRIORITY_VERY_HIGH)
|
|
eArgumentCurrentText = ARG_TEXT_LI5
|
|
ENDIF
|
|
ENDIF
|
|
BREAK
|
|
CASE ARG_TEXT_LI5
|
|
IF NOT IS_ANY_CONVERSATION_ONGOING_OR_QUEUED()
|
|
IF CREATE_CONVERSATION(finaleConversation, "FINC1AU", "FINC1_LI5", CONV_PRIORITY_VERY_HIGH)
|
|
eArgumentCurrentText = ARG_TEXT_IDLE
|
|
SET_NEXT_RANDOM_SPEECH_TIME(20000)
|
|
ENDIF
|
|
ENDIF
|
|
BREAK
|
|
ENDSWITCH
|
|
ENDPROC
|
|
|
|
// meet up with michael and trevor
|
|
PROC DO_STAGE_MEET_GANG()
|
|
IF NOT bRunningCutscene
|
|
// @SBA - if player explodes or otherwise ragdolls either Trevor or Michael, kill them
|
|
IF HANDLE_INTERFERING_WITH_TREVOR_AND_MICHAEL(sSelectorPeds.pedID[SELECTOR_PED_TREVOR])
|
|
CPRINTLN(DEBUG_MISSION, "HANDLE_INTERFERING_WITH_TREVOR_AND_MICHAEL: Killing Trevor")
|
|
ENDIF
|
|
IF HANDLE_INTERFERING_WITH_TREVOR_AND_MICHAEL(sSelectorPeds.pedID[SELECTOR_PED_MICHAEL])
|
|
CPRINTLN(DEBUG_MISSION, "HANDLE_INTERFERING_WITH_TREVOR_AND_MICHAEL: Killing Michael")
|
|
ENDIF
|
|
|
|
HANDLE_LAMAR_ARRIVES_AT_FOUNDRY()
|
|
|
|
// handle abandon blips
|
|
IF NOT IS_PED_IN_FOUNDRY_INTERIOR(PLAYER_PED_ID())
|
|
IF IS_ENTITY_OK(lamarPed) AND IS_ENTITY_OK(PLAYER_PED_ID())
|
|
IF GET_DISTANCE_BETWEEN_ENTITIES(PLAYER_PED_ID(), lamarPed, FALSE) < ABANDON_BUDDY_FAIL_RANGE - 20
|
|
IF DOES_BLIP_EXIST(lamarBlip)
|
|
REMOVE_BLIP(lamarBlip)
|
|
ENDIF
|
|
IF NOT DOES_BLIP_EXIST(gotoBlip)
|
|
bAddedInteriorBlip = FALSE
|
|
bAddedGantryBlip = FALSE
|
|
|
|
SET_DOOR_STATE(DOORNAME_FOUNDRY_B_01, DOORSTATE_UNLOCKED)
|
|
CPRINTLN(DEBUG_MISSION, "BSW unlocking foundry door for entry in Meet Gang")
|
|
gotoBlip = CREATE_MISSION_BLIP_FOR_COORD(GET_FINALE_VECTOR(FINVEC_FOUNDRY_DOOR))
|
|
ENDIF
|
|
|
|
ELIF GET_DISTANCE_BETWEEN_ENTITIES(PLAYER_PED_ID(), lamarPed, FALSE) < ABANDON_BUDDY_FAIL_RANGE
|
|
IF NOT bShownReturnText
|
|
bShownReturnText = DO_MISSION_GOD_TEXT("FC1_GOFOUND")
|
|
ENDIF
|
|
ELSE
|
|
MISSION_FAILED(FAIL_ABANDONED_LAMAR)
|
|
ENDIF
|
|
ENDIF
|
|
ELSE
|
|
IF NOT bCreatedMichaelAndTrevor
|
|
FINALE_CREATE_PLAYER_CHARACTER(CHAR_TREVOR, GET_FINALE_VECTOR(FINVEC_TREVOR_INIT), TREVOR_INIT_ROT)
|
|
FINALE_CREATE_PLAYER_CHARACTER(CHAR_MICHAEL, GET_FINALE_VECTOR(FINVEC_MICHAEL_INIT), MICHAEL_INIT_ROT)
|
|
|
|
GIVE_CHARACTERS_WEAPONS(FALSE)
|
|
|
|
sceneIdStandoff = CREATE_SYNCHRONIZED_SCENE(<< 1113.944, -2002.070, 34.431 >>, << -0.000, 0.000, 55.800 >>)
|
|
SET_SYNCHRONIZED_SCENE_LOOPED(sceneIdStandoff, TRUE)
|
|
|
|
TASK_SYNCHRONIZED_SCENE(GET_TREVOR_PED(), sceneIdStandoff, GET_FINALE_ANIM_DICT_AS_STRING(F_ANIM_DICT_MCS_1_LEADIN), "_leadin_idle_trevor", INSTANT_BLEND_IN, INSTANT_BLEND_OUT)
|
|
TASK_SYNCHRONIZED_SCENE(GET_MICHAEL_PED(), sceneIdStandoff, GET_FINALE_ANIM_DICT_AS_STRING(F_ANIM_DICT_MCS_1_LEADIN), "_leadin_idle_michael", INSTANT_BLEND_IN, INSTANT_BLEND_OUT)
|
|
|
|
FORCE_PED_AI_AND_ANIMATION_UPDATE(GET_TREVOR_PED())
|
|
FORCE_PED_AI_AND_ANIMATION_UPDATE(GET_MICHAEL_PED())
|
|
|
|
bCreatedMichaelAndTrevor = TRUE
|
|
ENDIF
|
|
|
|
IF NOT bAddedInteriorBlip
|
|
IF DOES_BLIP_EXIST(gotoBlip)
|
|
REMOVE_BLIP(gotoBlip)
|
|
ENDIF
|
|
|
|
CREATE_INTERIOR_PROPS()
|
|
|
|
gotoBlip = CREATE_MISSION_BLIP_FOR_COORD(GET_FINALE_VECTOR(FINVEC_SEE_FRANKLIN))
|
|
bAddedGantryBlip = FALSE
|
|
|
|
bAddedInteriorBlip = TRUE
|
|
ELSE
|
|
IF NOT bAddedGantryBlip
|
|
IF IS_ENTITY_AT_COORD(PLAYER_PED_ID(), GET_FINALE_VECTOR(FINVEC_SEE_FRANKLIN), <<LOCATE_SIZE_ON_FOOT_ONLY, LOCATE_SIZE_ON_FOOT_ONLY, LOCATE_SIZE_HEIGHT>>, TRUE)
|
|
IF DOES_BLIP_EXIST(gotoBlip)
|
|
REMOVE_BLIP(gotoBlip)
|
|
ENDIF
|
|
gotoBlip = CREATE_MISSION_BLIP_FOR_COORD(GET_FINALE_VECTOR(FINVEC_MEETING_GANTRY))
|
|
bAddedGantryBlip = TRUE
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF NOT bPreparedMichaelShoutCue
|
|
IF NOT IS_MUSIC_ONESHOT_PLAYING()
|
|
bPreparedMichaelShoutCue = PREPARE_MUSIC_EVENT("FIN1_START")
|
|
ENDIF
|
|
ENDIF
|
|
|
|
// god text
|
|
IF NOT bDoneArrivalSpeech
|
|
KILL_ANY_CONVERSATION()
|
|
bDoneArrivalSpeech = DO_MISSION_SPEECH("FINC1_GINSID")
|
|
ELSE
|
|
IF NOT bShownGodText
|
|
bShownGodText = DO_MISSION_GOD_TEXT("FC1_GOF2")
|
|
ENDIF
|
|
ENDIF
|
|
|
|
|
|
IF IS_ENTITY_OK(GET_MICHAEL_PED()) AND IS_ENTITY_OK(GET_TREVOR_PED())
|
|
IF IS_ENTITY_ON_SCREEN(GET_MICHAEL_PED()) OR IS_ENTITY_ON_SCREEN(GET_TREVOR_PED())
|
|
DISABLE_CONTROL_ACTION(PLAYER_CONTROL, INPUT_ATTACK)
|
|
DISABLE_CONTROL_ACTION(PLAYER_CONTROL, INPUT_ATTACK2)
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF NOT bStartedArgument
|
|
IF IS_ENTITY_OK(PLAYER_PED_ID()) AND IS_ENTITY_OK(GET_MICHAEL_PED())
|
|
IF GET_DISTANCE_BETWEEN_ENTITIES(PLAYER_PED_ID(), GET_MICHAEL_PED()) < 35
|
|
REQUEST_CUTSCENE_WITH_PLAYBACK_LIST("FIN_C_MCS_1", cs_section_1 | cs_section_3
|
|
| cs_section_4 | cs_section_5 | cs_section_6 | cs_section_7 | cs_section_8 | cs_section_9
|
|
| cs_section_10 | cs_section_11 | cs_section_12 | cs_section_13 | cs_section_14 | cs_section_15)
|
|
|
|
eArgumentCurrentText = ARG_TEXT_LI1
|
|
bStartedArgument = TRUE
|
|
ENDIF
|
|
ENDIF
|
|
ELSE
|
|
HANDLE_ARGUMENT()
|
|
IF NOT bDoneMichaelShoutCue
|
|
IF bPreparedMichaelShoutCue
|
|
bDoneMichaelShoutCue = TRIGGER_MUSIC_EVENT("FIN1_START")
|
|
ELSE
|
|
bPreparedMichaelShoutCue = PREPARE_MUSIC_EVENT("FIN1_START")
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF NOT bCutsceneWaitStarted
|
|
IF GET_INTERIOR_FROM_ENTITY(PLAYER_PED_ID()) <> NULL
|
|
STRING randomConv
|
|
IF GET_RANDOM_INT_IN_RANGE(0, 1) = 0
|
|
randomConv = "FINC1_GREET2"
|
|
ELSE
|
|
randomConv = "FINC1_GREET3"
|
|
ENDIF
|
|
IF DO_RANDOM_SPEECH(randomConv, 10000, 15000)
|
|
//DO_TREVOR_WAVE()
|
|
ENDIF
|
|
ELSE
|
|
iNextRandomSpeechTime = GET_GAME_TIMER() + 2000
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF NOT bCutsceneWaitStarted
|
|
IF IS_PLAYER_IN_TRIGGER_BOX(tbForceWalkAroundStairs)
|
|
SET_PED_MAX_MOVE_BLEND_RATIO(PLAYER_PED_ID(), PEDMOVE_WALK)
|
|
|
|
IF NOT IS_GAMEPLAY_HINT_ACTIVE()
|
|
IF IS_ENTITY_OK(GET_MICHAEL_PED())
|
|
SET_GAMEPLAY_ENTITY_HINT(GET_MICHAEL_PED(), <<0,0,0>>, TRUE, DEFAULT, 4000)
|
|
SET_GAMEPLAY_HINT_FOV(50.0)
|
|
SET_GAMEPLAY_HINT_FOLLOW_DISTANCE_SCALAR(0.25)
|
|
SET_GAMEPLAY_HINT_CAMERA_RELATIVE_SIDE_OFFSET(-0.02)
|
|
SET_GAMEPLAY_HINT_CAMERA_BLEND_TO_FOLLOW_PED_MEDIUM_VIEW_MODE(TRUE)
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF IS_PLAYER_IN_TRIGGER_BOX(tbTriggerMeetCrewScene)
|
|
OR IS_PLAYER_IN_TRIGGER_BOX(tbBackupMeetCrewSceneTrigger) // backup in case the player takes a different route
|
|
IF NOT IS_PED_IN_ANY_VEHICLE(PLAYER_PED_ID())
|
|
IF CAN_PLAYER_START_CUTSCENE()
|
|
bCutsceneWaitStarted = TRUE
|
|
REMOVE_ALL_BLIPS()
|
|
IF IS_PLAYER_IN_TRIGGER_BOX(tbTriggerMeetCrewScene)
|
|
SET_PLAYER_CONTROL(PLAYER_ID(), FALSE, SPC_LEAVE_CAMERA_CONTROL_ON|SPC_REMOVE_PROJECTILES|SPC_REMOVE_EXPLOSIONS|SPC_REMOVE_FIRES|SPC_ALLOW_PLAYER_DAMAGE|SPC_REENABLE_CONTROL_ON_DEATH)
|
|
IF IS_ENTITY_OK(GET_FRANKLIN_PED())
|
|
TASK_FOLLOW_NAV_MESH_TO_COORD(GET_FRANKLIN_PED(), (<<1114.5931, -1996.3708, 32.1953>>), PEDMOVE_WALK)
|
|
|
|
IF IS_ENTITY_OK(GET_MICHAEL_PED())
|
|
TASK_LOOK_AT_ENTITY(PLAYER_PED_ID(), GET_MICHAEL_PED(), -1, SLF_WHILE_NOT_IN_FOV, SLF_LOOKAT_VERY_HIGH)
|
|
ENDIF
|
|
ENDIF
|
|
ELSE
|
|
REMOVE_CUTSCENE()
|
|
REQUEST_CUTSCENE_WITH_PLAYBACK_LIST("FIN_C_MCS_1", cs_section_2 | cs_section_3
|
|
| cs_section_4 | cs_section_5 | cs_section_6 | cs_section_7 | cs_section_8 | cs_section_9
|
|
| cs_section_10 | cs_section_11 | cs_section_12 | cs_section_13 | cs_section_14 | cs_section_15)
|
|
ENDIF
|
|
ENDIF
|
|
ELSE
|
|
IF BRING_VEHICLE_TO_HALT_AND_DISABLE_VEH_CONTROLS(GET_VEHICLE_PED_IS_USING(PLAYER_PED_ID()), 2)
|
|
IF IS_ENTITY_OK(PLAYER_PED_ID()) AND IS_ENTITY_OK(GET_VEHICLE_PED_IS_USING(PLAYER_PED_ID()))
|
|
TASK_LEAVE_VEHICLE(PLAYER_PED_ID(), GET_VEHICLE_PED_IS_USING(PLAYER_PED_ID()))
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ELSE
|
|
IF IS_PLAYER_IN_TRIGGER_BOX(tbBottomOfStairs)
|
|
OR IS_PLAYER_IN_TRIGGER_BOX(tbBackupMeetCrewSceneTrigger)
|
|
IF CAN_ADVANCE_MISSION()
|
|
IF HAS_CUTSCENE_LOADED_WITH_FAILSAFE()
|
|
STOP_SCRIPTED_CONVERSATION(FALSE)
|
|
TASK_CLEAR_LOOK_AT(PLAYER_PED_ID())
|
|
bRunningCutscene = TRUE
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ELSE
|
|
DO_MEETING_CUTSCENE()
|
|
ENDIF
|
|
ENDPROC
|
|
|
|
// common shootout functions
|
|
PROC DO_COMMON_SHOOTOUT_FUNCTIONS()
|
|
SET_PED_DENSITY_MULTIPLIER_THIS_FRAME(0.0)
|
|
|
|
UPDATE_ALLIES_FOR_SHOOTOUT()
|
|
|
|
HANDLE_FREE_HOTSWAP()
|
|
|
|
// handle on fire
|
|
INT i
|
|
REPEAT 3 i
|
|
IF NOT IS_PED_INJURED(sSelectorPeds.pedID[i])
|
|
IF IS_ENTITY_ON_FIRE(sSelectorPeds.pedID[i])
|
|
IF GET_ENTITY_HEALTH(sSelectorPeds.pedID[i]) > 200
|
|
SET_PED_SUFFERS_CRITICAL_HITS(sSelectorPeds.pedID[i], TRUE)
|
|
SET_PED_MAX_HEALTH(sSelectorPeds.pedID[i], 200)
|
|
SET_ENTITY_HEALTH(sSelectorPeds.pedID[i], 200)
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDREPEAT
|
|
ENDPROC
|
|
|
|
FUNC INT GET_LIVING_ENEMY()
|
|
INT i
|
|
REPEAT COUNT_OF(enemyPed) i
|
|
IF IS_ENEMY_ALIVE(INT_TO_ENUM(ENEMY_PED_ENUM, i))
|
|
RETURN i
|
|
ENDIF
|
|
ENDREPEAT
|
|
|
|
RETURN -1
|
|
ENDFUNC
|
|
|
|
PROC HANDLE_KICKOFF_DIALOGUE()
|
|
STRING sKickOff, sResponse
|
|
IF GET_CURRENT_PLAYER_PED_ENUM() = CHAR_FRANKLIN
|
|
IF GET_RANDOM_BOOL()
|
|
sKickOff = "FINC1_KICKM"
|
|
sResponse = "FINC1_RESPT"
|
|
ELSE
|
|
sKickOff = "FINC1_KICKT"
|
|
sResponse = "FINC1_RESPM"
|
|
ENDIF
|
|
ELIF GET_CURRENT_PLAYER_PED_ENUM() = CHAR_MICHAEL
|
|
IF GET_RANDOM_BOOL()
|
|
sKickOff = "FINC1_KICKF"
|
|
sResponse = "FINC1_RESPT"
|
|
ELSE
|
|
sKickOff = "FINC1_KICKT"
|
|
sResponse = "FINC1_RESPF"
|
|
ENDIF
|
|
ELSE
|
|
IF GET_RANDOM_BOOL()
|
|
sKickOff = "FINC1_KICKM"
|
|
sResponse = "FINC1_RESPF"
|
|
ELSE
|
|
sKickOff = "FINC1_KICKF"
|
|
sResponse = "FINC1_RESPM"
|
|
ENDIF
|
|
ENDIF
|
|
|
|
SWITCH eKickOffDialogue
|
|
CASE KICKOFF_SEARCHERS_REACT
|
|
IF NOT IS_ANY_CONVERSATION_ONGOING_OR_QUEUED() AND NOT IS_MESSAGE_BEING_DISPLAYED()
|
|
CPRINTLN(DEBUG_MISSION, "Starting kickoff dialogue")
|
|
INT iLivingEnemy
|
|
iLivingEnemy = GET_LIVING_ENEMY()
|
|
IF iLivingEnemy > -1
|
|
PLAY_PED_AMBIENT_SPEECH(enemyPed[iLivingEnemy].ped, "SUSPECT_SPOTTED", SPEECH_PARAMS_FORCE_SHOUTED_CLEAR)
|
|
ENDIF
|
|
|
|
START_TIMER_NOW_SAFE(tmrKickoffDialogue)
|
|
|
|
eKickOffDialogue = KICKOFF_FRIENDLY_SHOUT
|
|
ENDIF
|
|
BREAK
|
|
CASE KICKOFF_FRIENDLY_SHOUT
|
|
IF NOT IS_ANY_CONVERSATION_ONGOING_OR_QUEUED() AND NOT IS_MESSAGE_BEING_DISPLAYED()
|
|
IF GET_TIMER_IN_SECONDS_SAFE(tmrKickoffDialogue) > 2
|
|
IF CREATE_CONVERSATION(finaleConversation, "FINC1AU", sKickOff, CONV_PRIORITY_LOW)
|
|
eKickOffDialogue = KICKOFF_RESPONSE
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
BREAK
|
|
CASE KICKOFF_RESPONSE
|
|
IF NOT IS_ANY_CONVERSATION_ONGOING_OR_QUEUED() AND NOT IS_MESSAGE_BEING_DISPLAYED()
|
|
IF CREATE_CONVERSATION(finaleConversation, "FINC1AU", sResponse, CONV_PRIORITY_LOW)
|
|
iFranklinIncidentalTime = GET_RANDOM_INT_IN_RANGE(5, 7)
|
|
RESTART_TIMER_NOW(tmrFranklinIncidental)
|
|
iMichaelIncidentalTime = GET_RANDOM_INT_IN_RANGE(8, 10)
|
|
RESTART_TIMER_NOW(tmrMichaelIncidental)
|
|
iTrevorIncidentalTime = GET_RANDOM_INT_IN_RANGE(10, 12)
|
|
RESTART_TIMER_NOW(tmrTrevorIncidental)
|
|
|
|
eKickOffDialogue = KICKOFF_IDLE
|
|
ENDIF
|
|
ENDIF
|
|
BREAK
|
|
ENDSWITCH
|
|
|
|
ENDPROC
|
|
|
|
// shootout - vs the FIB
|
|
PROC DO_STAGE_SHOOTOUT_STAGE_1()
|
|
INT iRemainingCatwalkEnemies
|
|
|
|
IF NOT bKilledAll
|
|
|
|
IF IS_PLAYER_IN_TRIGGER_BOX(tbBottomExit1Outer)
|
|
OR IS_PLAYER_IN_TRIGGER_BOX(tbBottomExit2Outer)
|
|
OR IS_PLAYER_IN_TRIGGER_BOX(tbTopExitOuter)
|
|
MISSION_FAILED(FAIL_ABANDONED_FIGHT)
|
|
ENDIF
|
|
|
|
// common shootout functions
|
|
DO_COMMON_SHOOTOUT_FUNCTIONS()
|
|
|
|
IF NOT bShootoutStarted
|
|
IF NOT bShownAmbushText
|
|
bShownAmbushText = DO_MISSION_GOD_TEXT("FC1_AMBUSH")
|
|
IF bShownAmbushText
|
|
REPLAY_RECORD_BACK_FOR_TIME(0.0, 8.0, REPLAY_IMPORTANCE_HIGHEST)
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF HANDLE_FIB_SEARCH()
|
|
bShootoutStarted = TRUE
|
|
bAudioStartShootout1 = TRUE
|
|
IF IS_THIS_PRINT_BEING_DISPLAYED("FC1_AMBUSH")
|
|
REMOVE_MISSION_TEXT(FALSE, TRUE, FALSE)
|
|
ENDIF
|
|
|
|
eAllyStates[SELECTOR_PED_MICHAEL].currentState = ALLY_STATE_COMBAT_INIT
|
|
eAllyStates[SELECTOR_PED_TREVOR].currentState = ALLY_STATE_COMBAT_INIT
|
|
eAllyStates[SELECTOR_PED_FRANKLIN].currentState = ALLY_STATE_COMBAT_INIT
|
|
|
|
STOP_PED_SPEAKING(GET_MICHAEL_PED(), FALSE)
|
|
STOP_PED_SPEAKING(GET_TREVOR_PED(), FALSE)
|
|
STOP_PED_SPEAKING(GET_FRANKLIN_PED(), FALSE)
|
|
|
|
REPLAY_RECORD_BACK_FOR_TIME(0.0, 8.0, REPLAY_IMPORTANCE_HIGHEST)
|
|
|
|
eKickOffDialogue = KICKOFF_SEARCHERS_REACT
|
|
|
|
SET_DOOR_STATE(DOORNAME_FOUNDRY_B_02, DOORSTATE_UNLOCKED)
|
|
SET_DOOR_STATE(DOORNAME_FOUNDRY_T_01, DOORSTATE_UNLOCKED)
|
|
|
|
iFIBReactionStartTime = GET_GAME_TIMER()
|
|
ENDIF
|
|
ELSE
|
|
MAKE_FIB_SEARCHERS_REACT()
|
|
|
|
HANDLE_KICKOFF_DIALOGUE()
|
|
|
|
IF NOT bDoneFightCue
|
|
bDoneFightCue = TRIGGER_MUSIC_EVENT("FIN1_SHOOTOUT_1")
|
|
ENDIF
|
|
ENDIF
|
|
|
|
INT iTotalEnemiesAlive = 0
|
|
INT iEnemiesFIBInsideWave = HANDLE_ENEMY_WAVE(EW_FIB_SEARCH)
|
|
|
|
iTotalEnemiesAlive += iEnemiesFIBInsideWave
|
|
|
|
IF NOT bCreatedCatwalkWave
|
|
IF freeHotswapData.state = FREE_HOTSWAP_STATE_SELECTING
|
|
IF iTotalEnemiesAlive < 2
|
|
OR IS_ANY_BUDDY_IN_TRIGGER_BOX(tbTopExitInner, GET_MICHAEL_PED(), GET_TREVOR_PED(), GET_FRANKLIN_PED())
|
|
CREATE_ENEMY_WAVE(EW_MERC_CATWALK, TRUE)
|
|
TASK_ENEMY_WAVE_MOVE_ONTO_CATWALK(EW_MERC_CATWALK, TRUE)
|
|
bCreatedCatwalkWave = TRUE
|
|
iTotalEnemiesAlive = 100
|
|
ENDIF
|
|
ENDIF
|
|
ELSE
|
|
IF NOT bCatwalkWaveDialogue
|
|
IF IS_ENTITY_IN_TRIGGER_BOX(tbTopExitInner, enemyPed[EP_MERC_CATWALK_FOOT_1].ped)
|
|
IF GET_CURRENT_PLAYER_PED_ENUM() = CHAR_FRANKLIN
|
|
bCatwalkWaveDialogue = CREATE_CONVERSATION(finaleConversation, "FINC1AU", "FINC1_CATFAR", CONV_PRIORITY_HIGH)
|
|
ELSE
|
|
bCatwalkWaveDialogue = CREATE_CONVERSATION(finaleConversation, "FINC1AU", "FINC1_CTWLK", CONV_PRIORITY_HIGH)
|
|
ENDIF
|
|
IF bCatwalkWaveDialogue
|
|
START_TIMER_NOW_SAFE(tmrMichaelIncidental)
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
|
|
iRemainingCatwalkEnemies = HANDLE_ENEMY_WAVE(EW_MERC_CATWALK)
|
|
IF bCatwalkWaveDialogue
|
|
IF iRemainingCatwalkEnemies > 0
|
|
IF NOT bTrevorAnnouncesMerryweather
|
|
IF GET_CURRENT_PLAYER_PED_ENUM() <> CHAR_MICHAEL
|
|
IF iMichaelCallsShotCount < 3
|
|
IF GET_TIMER_IN_SECONDS_SAFE(tmrMichaelIncidental) > iMichaelIncidentalTime
|
|
IF CREATE_CONVERSATION(finaleConversation, "FINC1AU", "FINC1_MSHOT", CONV_PRIORITY_HIGH)
|
|
IF iMichaelCallsShotCount = 0
|
|
IF IS_ENTITY_OK(sSelectorPeds.pedID[SELECTOR_PED_MICHAEL])
|
|
IF GET_DISTANCE_BETWEEN_ENTITY_AND_COORD(sSelectorPeds.pedID[SELECTOR_PED_MICHAEL], GET_SCRIPTED_COVER_POINT_COORDS(michaelCatwalkCover)) < 3
|
|
SEQUENCE_INDEX iMikeSeq
|
|
OPEN_SEQUENCE_TASK(iMikeSeq)
|
|
TASK_PUT_PED_DIRECTLY_INTO_COVER(NULL, GET_SCRIPTED_COVER_POINT_COORDS(michaelCatwalkCover), 3000, TRUE, DEFAULT, DEFAULT, DEFAULT, michaelCatwalkCover, TRUE)
|
|
TASK_COMBAT_HATED_TARGETS_AROUND_PED(NULL, 200)
|
|
CLOSE_SEQUENCE_TASK(iMikeSeq)
|
|
TASK_PERFORM_SEQUENCE(sSelectorPeds.pedID[SELECTOR_PED_MICHAEL], iMikeSeq)
|
|
CLEAR_SEQUENCE_TASK(iMikeSeq)
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
iMichaelCallsShotCount++
|
|
iMichaelIncidentalTime = GET_RANDOM_INT_IN_RANGE(4, 8)
|
|
RESTART_TIMER_NOW(tmrMichaelIncidental)
|
|
SET_SELECTOR_PED_HINT(sSelectorPeds, SELECTOR_PED_MICHAEL, TRUE)
|
|
SET_SELECTOR_PED_PRIORITY(sSelectorPeds, SELECTOR_PED_MICHAEL, SELECTOR_PED_FRANKLIN, SELECTOR_PED_TREVOR)
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ELSE
|
|
// if michael has announced the catwalk guys and the player has switched then he plays some dialogue
|
|
IF iMichaelCallsShotCount > 0 AND NOT bSwitchedToMichaelForCatwalkKill
|
|
bSwitchedToMichaelForCatwalkKill = CREATE_CONVERSATION(finaleConversation, "FINC1AU", "FINC1_SWITM", CONV_PRIORITY_MEDIUM)
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ELSE
|
|
SET_SELECTOR_PED_HINT(sSelectorPeds, SELECTOR_PED_MICHAEL, FALSE)
|
|
ENDIF
|
|
ENDIF
|
|
|
|
iTotalEnemiesAlive += iRemainingCatwalkEnemies
|
|
ENDIF
|
|
|
|
IF NOT bCreatedTrevorCornerWave
|
|
IF freeHotswapData.state = FREE_HOTSWAP_STATE_SELECTING
|
|
IF (iTotalEnemiesAlive < 2 AND bCreatedCatwalkWave)
|
|
OR IS_ANY_BUDDY_IN_TRIGGER_BOX(tbTopExitInner, GET_MICHAEL_PED(), GET_TREVOR_PED(), GET_FRANKLIN_PED())
|
|
CREATE_ENEMY_WAVE(EW_MERC_TREVORCORNER, TRUE)
|
|
TASK_ENEMY_WAVE_INTO_FOUNDRY(EW_MERC_TREVORCORNER, 2)
|
|
bCreatedTrevorCornerWave = TRUE
|
|
START_TIMER_NOW_SAFE(tmrTrevorIncidental)
|
|
iTrevorIncidentalTime = 1
|
|
|
|
iTotalEnemiesAlive = 100
|
|
ENDIF
|
|
ENDIF
|
|
ELSE
|
|
INT iRemainingTrevCornerEnemies = HANDLE_ENEMY_WAVE(EW_MERC_TREVORCORNER)
|
|
|
|
IF NOT bTrevorAnnouncesMerryweather
|
|
IF NOT IS_ANY_CONVERSATION_ONGOING_OR_QUEUED() AND NOT IS_MESSAGE_BEING_DISPLAYED()
|
|
bTrevorAnnouncesMerryweather = CREATE_CONVERSATION(finaleConversation, "FINC1AU", "FINC1_MOREMT", CONV_PRIORITY_HIGH)
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF iRemainingTrevCornerEnemies > 1
|
|
IF bTrevorAnnouncesMerryweather
|
|
IF GET_CURRENT_PLAYER_PED_ENUM() <> CHAR_TREVOR
|
|
IF iTrevorCallsShotCount < 4
|
|
IF GET_TIMER_IN_SECONDS_SAFE(tmrTrevorIncidental) > iTrevorIncidentalTime
|
|
IF NOT IS_ANY_CONVERSATION_ONGOING_OR_QUEUED() AND NOT IS_MESSAGE_BEING_DISPLAYED()
|
|
IF CREATE_CONVERSATION(finaleConversation, "FINC1AU", "FINC1_TSHOT", CONV_PRIORITY_HIGH)
|
|
iTrevorCallsShotCount++
|
|
iTrevorIncidentalTime = GET_RANDOM_INT_IN_RANGE(3, 8)
|
|
RESTART_TIMER_NOW(tmrTrevorIncidental)
|
|
|
|
IF iMichaelCallsShotCount > 3 OR iRemainingCatwalkEnemies < 3
|
|
SET_SELECTOR_PED_HINT(sSelectorPeds, SELECTOR_PED_TREVOR, TRUE)
|
|
SET_SELECTOR_PED_PRIORITY(sSelectorPeds, SELECTOR_PED_TREVOR, SELECTOR_PED_FRANKLIN, SELECTOR_PED_MICHAEL)
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ELSE
|
|
// if trevor has announced the corner guys and the player has switched then he plays some dialogue
|
|
IF iTrevorCallsShotCount > 0 AND NOT bSwitchedToTrevorForCornerKill
|
|
bSwitchedToTrevorForCornerKill = CREATE_CONVERSATION(finaleConversation, "FINC1AU", "FINC1_SWITT", CONV_PRIORITY_MEDIUM)
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ELSE
|
|
SET_SELECTOR_PED_HINT(sSelectorPeds, SELECTOR_PED_TREVOR, FALSE)
|
|
ENDIF
|
|
|
|
iTotalEnemiesAlive += iRemainingTrevCornerEnemies
|
|
ENDIF
|
|
|
|
IF NOT bCreatedFIBReinforcements
|
|
IF freeHotswapData.state = FREE_HOTSWAP_STATE_SELECTING
|
|
IF (iTotalEnemiesAlive < 2 AND bCreatedTrevorCornerWave)
|
|
OR IS_ANY_BUDDY_IN_TRIGGER_BOX(tbBottomExit2Inner, GET_MICHAEL_PED(), GET_TREVOR_PED(), GET_FRANKLIN_PED())
|
|
CREATE_ENEMY_WAVE(EW_FIB_REINFORCEMENTS, TRUE)
|
|
TASK_ENEMY_WAVE_INTO_FOUNDRY(EW_FIB_REINFORCEMENTS, 1)
|
|
bCreatedFIBReinforcements = TRUE
|
|
iTotalEnemiesAlive = 100
|
|
ENDIF
|
|
ENDIF
|
|
ELSE
|
|
iTotalEnemiesAlive += HANDLE_ENEMY_WAVE(EW_FIB_REINFORCEMENTS)
|
|
ENDIF
|
|
|
|
IF NOT bCreatedInsideMercWave AND bCreatedFIBReinforcements
|
|
IF freeHotswapData.state = FREE_HOTSWAP_STATE_SELECTING
|
|
CREATE_ENEMY_WAVE(EW_MERC_INSIDE, TRUE)
|
|
TASK_ENEMY_WAVE_INTO_FOUNDRY(EW_MERC_INSIDE, 2)
|
|
iTotalEnemiesAlive = 100
|
|
bCreatedInsideMercWave = TRUE
|
|
ENDIF
|
|
ELSE
|
|
iTotalEnemiesAlive += HANDLE_ENEMY_WAVE(EW_MERC_INSIDE)
|
|
|
|
IF bCreatedInsideMercWave
|
|
IF NOT bReinforcementWarning
|
|
IF NOT IS_ANY_CONVERSATION_ONGOING_OR_QUEUED() AND NOT IS_MESSAGE_BEING_DISPLAYED()
|
|
STRING sWarningDialogue
|
|
SWITCH GET_RANDOM_INT_IN_RANGE(0, 2)
|
|
CASE 0
|
|
sWarningDialogue = "FINC1_MORET"
|
|
BREAK
|
|
CASE 1
|
|
sWarningDialogue = "FINC1_MOREF"
|
|
BREAK
|
|
// CASE 2
|
|
// sWarningDialogue = "FINC1_MOREM"
|
|
// BREAK
|
|
ENDSWITCH
|
|
|
|
bReinforcementWarning = CREATE_CONVERSATION(finaleConversation, "FINC1AU", sWarningDialogue, CONV_PRIORITY_MEDIUM)
|
|
ENDIF
|
|
ELSE
|
|
IF NOT bEnemyInfightingDialogue
|
|
IF NOT IS_ANY_CONVERSATION_ONGOING_OR_QUEUED() AND NOT IS_MESSAGE_BEING_DISPLAYED()
|
|
bEnemyInfightingDialogue= CREATE_CONVERSATION(finaleConversation, "FINC1AU", "FINC1_KILL_M", CONV_PRIORITY_MEDIUM)
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
|
|
// is this going to stomp the "switch to me" stuff above? will adding "+1" to the time avoid that?
|
|
// should they be different timers?
|
|
// OMGHAX
|
|
IF GET_TIMER_IN_SECONDS_SAFE(tmrTrevorIncidental) > iTrevorIncidentalTime + 1
|
|
IF IS_ENTITY_OK(GET_TREVOR_PED())
|
|
IF IS_PED_SHOOTING(GET_TREVOR_PED())
|
|
CREATE_CONVERSATION(finaleConversation, "FINC1AU", "FINC1_ATT_T", CONV_PRIORITY_LOW, DO_NOT_DISPLAY_SUBTITLES)
|
|
RESTART_TIMER_NOW(tmrTrevorIncidental)
|
|
iTrevorIncidentalTime = GET_RANDOM_INT_IN_RANGE(10, 15)
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
IF GET_TIMER_IN_SECONDS_SAFE(tmrMichaelIncidental) > iMichaelIncidentalTime + 1
|
|
IF IS_ENTITY_OK(GET_MICHAEL_PED())
|
|
IF IS_PED_SHOOTING(GET_MICHAEL_PED())
|
|
CREATE_CONVERSATION(finaleConversation, "FINC1AU", "FINC1_ATT_M", CONV_PRIORITY_LOW, DO_NOT_DISPLAY_SUBTITLES)
|
|
RESTART_TIMER_NOW(tmrMichaelIncidental)
|
|
iMichaelIncidentalTime = GET_RANDOM_INT_IN_RANGE(10, 15)
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
IF GET_TIMER_IN_SECONDS_SAFE(tmrFranklinIncidental) > iFranklinIncidentalTime + 1
|
|
IF IS_ENTITY_OK(GET_FRANKLIN_PED())
|
|
IF IS_PED_SHOOTING(GET_FRANKLIN_PED())
|
|
CREATE_CONVERSATION(finaleConversation, "FINC1AU", "FINC1_FBANT", CONV_PRIORITY_LOW, DO_NOT_DISPLAY_SUBTITLES)
|
|
RESTART_TIMER_NOW(tmrFranklinIncidental)
|
|
iFranklinIncidentalTime = GET_RANDOM_INT_IN_RANGE(10, 15)
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF iTotalEnemiesAlive = 0 AND freeHotswapData.state = FREE_HOTSWAP_STATE_SELECTING
|
|
bKilledAll = TRUE
|
|
ENDIF
|
|
ELSE
|
|
SET_MISSION_STAGE(STAGE_SHOOTOUT_STAGE_2)
|
|
ENDIF
|
|
|
|
ENDPROC
|
|
|
|
PROC HANDLE_SHOOTOUT_STAGE_2_TEXT()
|
|
SWITCH eShootout2CurrentText
|
|
CASE SHOOTOUT_2_TEXT_LAMAR_CALLS
|
|
IF CREATE_CONVERSATION(finaleConversation, "FINC1AU", "FINC1_LHELP", CONV_PRIORITY_HIGH)
|
|
bDoneLamarAskForHelp = TRUE
|
|
eShootout2CurrentText = SHOOTOUT_2_TEXT_IDLE
|
|
ENDIF
|
|
BREAK
|
|
CASE SHOOTOUT_2_TEXT_SWITCH_TO_FRANK
|
|
IF NOT IS_ANY_CONVERSATION_ONGOING_OR_QUEUED()
|
|
IF DO_MISSION_GOD_TEXT("FC1_SWF")
|
|
SET_SELECTOR_PED_PRIORITY(sSelectorPeds, SELECTOR_PED_FRANKLIN, SELECTOR_PED_MICHAEL, SELECTOR_PED_TREVOR)
|
|
DO_MISSION_HINT(SELECTOR_PED_FRANKLIN)
|
|
|
|
eShootout2CurrentText = SHOOTOUT_2_TEXT_MICHAEL_ENCOURAGEMENT
|
|
ENDIF
|
|
ENDIF
|
|
BREAK
|
|
CASE SHOOTOUT_2_TEXT_MICHAEL_ENCOURAGEMENT
|
|
IF NOT IS_ANY_CONVERSATION_ONGOING_OR_QUEUED() AND NOT IS_MESSAGE_BEING_DISPLAYED()
|
|
IF GET_TIMER_IN_SECONDS_SAFE(tmrMichaelIncidental) > iMichaelIncidentalTime
|
|
IF CREATE_CONVERSATION(finaleConversation, "FINC1AU", "FINC1_FSW2", CONV_PRIORITY_MEDIUM)
|
|
iMichaelIncidentalTime = GET_RANDOM_INT_IN_RANGE(8, 12)
|
|
RESTART_TIMER_NOW(tmrMichaelIncidental)
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
BREAK
|
|
CASE SHOOTOUT_2_TEXT_GO_TO_EXIT
|
|
IF GET_CURRENT_PLAYER_PED_ENUM() = CHAR_FRANKLIN AND freeHotswapData.state = FREE_HOTSWAP_STATE_SELECTING
|
|
IF NOT IS_ANY_CONVERSATION_ONGOING_OR_QUEUED()
|
|
IF bDoneLamarAskForHelp
|
|
IF DO_MISSION_GOD_TEXT("FC1_GOL")
|
|
REMOVE_ALL_BLIPS()
|
|
|
|
gotoBlip = CREATE_BLIP_FOR_COORD(<<1082.8473, -1975.1332, 30.4723>>)
|
|
MAKE_COORD_BLIP_FRIENDLY(gotoBlip)
|
|
|
|
bAudioGetToLamar = TRUE
|
|
|
|
REPLAY_RECORD_BACK_FOR_TIME(4.0, 8.0, REPLAY_IMPORTANCE_HIGHEST)
|
|
|
|
eShootout2CurrentText = SHOOTOUT_2_TEXT_LAMAR_PANIC
|
|
ENDIF
|
|
ELSE
|
|
bDoneLamarAskForHelp = CREATE_CONVERSATION(finaleConversation, "FINC1AU", "FINC1_LHELP", CONV_PRIORITY_HIGH)
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
BREAK
|
|
CASE SHOOTOUT_2_TEXT_LAMAR_PANIC
|
|
IF NOT IS_ANY_CONVERSATION_ONGOING_OR_QUEUED() AND NOT IS_MESSAGE_BEING_DISPLAYED()
|
|
IF GET_TIMER_IN_SECONDS_SAFE(tmrLamarIncidental) > iLamarIncidentalTime
|
|
IF CREATE_CONVERSATION(finaleConversation, "FINC1AU", "FINC1_LHELP2", CONV_PRIORITY_MEDIUM)
|
|
// Increase the frequency if Lamar has been waiting awhile
|
|
IF GET_TIMER_IN_SECONDS_SAFE(tmrLamarDies) < LAMAR_DESPARATE_TIME
|
|
iLamarIncidentalTime = GET_RANDOM_INT_IN_RANGE(9, 15)
|
|
IF GET_RANDOM_INT_IN_RANGE(0, 4) < 3
|
|
eShootout2CurrentText = SHOOTOUT_2_TEXT_FRANKLIN_RESPONSE
|
|
ENDIF
|
|
ELSE
|
|
CPRINTLN(DEBUG_MISSION, "Lamar is desparate")
|
|
iLamarIncidentalTime = GET_RANDOM_INT_IN_RANGE(7, 10)
|
|
eShootout2CurrentText = SHOOTOUT_2_TEXT_FRANKLIN_RESPONSE_URGENT
|
|
ENDIF
|
|
RESTART_TIMER_NOW(tmrLamarIncidental)
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
BREAK
|
|
CASE SHOOTOUT_2_TEXT_FRANKLIN_RESPONSE
|
|
IF NOT IS_ANY_CONVERSATION_ONGOING_OR_QUEUED() AND NOT IS_MESSAGE_BEING_DISPLAYED()
|
|
IF CREATE_CONVERSATION(finaleConversation, "FINC1AU", "FINC1_GOLAM", CONV_PRIORITY_HIGH)
|
|
eShootout2CurrentText = SHOOTOUT_2_TEXT_LAMAR_PANIC
|
|
ENDIF
|
|
ENDIF
|
|
BREAK
|
|
CASE SHOOTOUT_2_TEXT_FRANKLIN_RESPONSE_URGENT
|
|
IF NOT IS_ANY_CONVERSATION_ONGOING_OR_QUEUED() AND NOT IS_MESSAGE_BEING_DISPLAYED()
|
|
IF CREATE_CONVERSATION(finaleConversation, "FINC1AU", "FINC1_LONG", CONV_PRIORITY_MEDIUM)
|
|
eShootout2CurrentText = SHOOTOUT_2_TEXT_LAMAR_PANIC
|
|
ENDIF
|
|
ENDIF
|
|
BREAK
|
|
CASE SHOOTOUT_2_TEXT_FRANK_REACHES_LAMAR
|
|
IF NOT IS_ANY_CONVERSATION_ONGOING_OR_QUEUED() AND NOT IS_MESSAGE_BEING_DISPLAYED()
|
|
IF CREATE_CONVERSATION(finaleConversation, "FINC1AU", "FINC1_SEELAM", CONV_PRIORITY_HIGH)
|
|
IF DOES_BLIP_EXIST(gotoBlip)
|
|
REMOVE_BLIP(gotoBlip)
|
|
ENDIF
|
|
|
|
IF NOT DOES_BLIP_EXIST(lamarBlip)
|
|
lamarBlip = CREATE_MISSION_BLIP_FOR_PED(lamarPed)
|
|
ENDIF
|
|
REPLAY_RECORD_BACK_FOR_TIME(4.0, 8.0, REPLAY_IMPORTANCE_HIGHEST)
|
|
eShootout2CurrentText = SHOOTOUT_2_TEXT_LAMAR_GRATEFUL
|
|
ENDIF
|
|
ENDIF
|
|
BREAK
|
|
CASE SHOOTOUT_2_TEXT_LAMAR_GRATEFUL
|
|
IF NOT IS_ANY_CONVERSATION_ONGOING_OR_QUEUED() AND NOT IS_MESSAGE_BEING_DISPLAYED()
|
|
IF CREATE_CONVERSATION(finaleConversation, "FINC1AU", "FINC1_LJOIN", CONV_PRIORITY_HIGH)
|
|
eShootout2CurrentText = SHOOTOUT_2_TEXT_FIGHT_WITH_LAMAR
|
|
ENDIF
|
|
ENDIF
|
|
BREAK
|
|
CASE SHOOTOUT_2_TEXT_FIGHT_WITH_LAMAR
|
|
IF NOT IS_ANY_CONVERSATION_ONGOING_OR_QUEUED()
|
|
IF DO_MISSION_GOD_TEXT("FC1_PROLAM")
|
|
eShootout2CurrentText = SHOOTOUT_2_TEXT_IDLE
|
|
ENDIF
|
|
ENDIF
|
|
BREAK
|
|
CASE SHOOTOUT_2_TEXT_MICHAEL_UNDER_ATTACK
|
|
IF CREATE_CONVERSATION(finaleConversation, "FINC1AU", "FINC1_MOREIN", CONV_PRIORITY_HIGH)
|
|
eShootout2CurrentText = SHOOTOUT_2_TEXT_SWITCH_TO_MIKE
|
|
ENDIF
|
|
BREAK
|
|
CASE SHOOTOUT_2_TEXT_SWITCH_TO_MIKE
|
|
IF NOT IS_ANY_CONVERSATION_ONGOING_OR_QUEUED()
|
|
IF DO_MISSION_GOD_TEXT("FC1_SWMT")
|
|
bLockSelector = FALSE
|
|
SET_SELECTOR_PED_BLOCKED(sSelectorPeds, SELECTOR_PED_TREVOR, TRUE)
|
|
SET_SELECTOR_PED_PRIORITY(sSelectorPeds, SELECTOR_PED_MICHAEL, SELECTOR_PED_TREVOR, SELECTOR_PED_FRANKLIN)
|
|
DO_MISSION_HINT(SELECTOR_PED_MICHAEL)
|
|
|
|
START_TIMER_NOW_SAFE(tmrSwitchToMikeFailTime)
|
|
START_TIMER_NOW_SAFE(tmrMichaelIncidental)
|
|
|
|
eShootout2CurrentText = SHOOTOUT_2_TEXT_SWITCH_URGENT
|
|
ENDIF
|
|
ENDIF
|
|
BREAK
|
|
CASE SHOOTOUT_2_TEXT_SWITCH_URGENT
|
|
IF GET_TIMER_IN_SECONDS_SAFE(tmrMichaelIncidental) > iMichaelIncidentalTime
|
|
IF CREATE_CONVERSATION(finaleConversation, "FINC1AU", "FINC1_NOSWM", CONV_PRIORITY_MEDIUM)
|
|
iMichaelIncidentalTime = GET_RANDOM_INT_IN_RANGE(8, 14)
|
|
RESTART_TIMER_NOW(tmrMichaelIncidental)
|
|
ENDIF
|
|
ENDIF
|
|
BREAK
|
|
CASE SHOOTOUT_2_TEXT_IDLE
|
|
IF NOT IS_ANY_CONVERSATION_ONGOING_OR_QUEUED() AND NOT IS_MESSAGE_BEING_DISPLAYED()
|
|
IF GET_TIMER_IN_SECONDS_SAFE(tmrLamarIncidental) > iLamarIncidentalTime
|
|
STRING sShootout2IncidentalDialogue
|
|
IF bLamarCalmedDown OR bLamarWasSaved
|
|
INT iRandomDialogue
|
|
iRandomDialogue = GET_RANDOM_INT_IN_RANGE(0, 7)
|
|
SWITCH iRandomDialogue
|
|
CASE 0
|
|
CASE 1
|
|
sShootout2IncidentalDialogue = "FINC1_SHT_F"
|
|
BREAK
|
|
CASE 2
|
|
CASE 3
|
|
sShootout2IncidentalDialogue = "FINC1_LSHOOT"
|
|
BREAK
|
|
CASE 4
|
|
IF NOT bPlayedChat9
|
|
sShootout2IncidentalDialogue = "FINC1_CHAT9"
|
|
ENDIF
|
|
BREAK
|
|
CASE 5
|
|
IF NOT bPlayedChat10
|
|
sShootout2IncidentalDialogue = "FINC1_CHAT10"
|
|
ENDIF
|
|
BREAK
|
|
CASE 6
|
|
IF NOT bPlayedChat11
|
|
sShootout2IncidentalDialogue = "FINC1_CHAT11"
|
|
ENDIF
|
|
BREAK
|
|
ENDSWITCH
|
|
IF IS_ENTITY_OK(PLAYER_PED_ID()) AND IS_ENTITY_OK(lamarPed)
|
|
// if it's 0-1 it's franklin, so we can just play the dialogue
|
|
// if it's greater than that, it involves lamar, so don't play it unless we're close to him
|
|
IF GET_DISTANCE_BETWEEN_ENTITIES(PLAYER_PED_ID(), lamarPed) < 10 OR iRandomDialogue <= 1
|
|
IF CREATE_CONVERSATION(finaleConversation, "FINC1AU", sShootout2IncidentalDialogue, CONV_PRIORITY_MEDIUM)
|
|
iLamarIncidentalTime = GET_RANDOM_INT_IN_RANGE(8, 14)
|
|
RESTART_TIMER_NOW(tmrLamarIncidental)
|
|
|
|
// ugh dont play the chats more than once
|
|
// OMGHAX
|
|
IF iRandomDialogue = 4
|
|
bPlayedChat9 = TRUE
|
|
ELIF iRandomDialogue = 5
|
|
bPlayedChat10 = TRUE
|
|
ELIF iRandomDialogue = 6
|
|
bPlayedChat11 = TRUE
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
|
|
ENDIF
|
|
ENDIF
|
|
BREAK
|
|
ENDSWITCH
|
|
ENDPROC
|
|
|
|
PROC DO_STAGE_SHOOTOUT_STAGE_2()
|
|
DO_COMMON_SHOOTOUT_FUNCTIONS()
|
|
|
|
HANDLE_SHOOTOUT_STAGE_2_TEXT()
|
|
HANDLE_NEW_LOAD_SCENE_FOR_SHOOTOUT3()
|
|
HANDLE_INSIDE_BLIPS_DURING_SAVE_LAMAR()
|
|
|
|
IF eShootout2CurrentGoal >= SHOOTOUT_2_OUTSIDE_1
|
|
AND eShootout2CurrentGoal < SHOOTOUT_2_FINISH_SWITCH
|
|
HANDLE_LAMAR_IN_COMBAT()
|
|
|
|
IF bLamarWasSaved
|
|
IF GET_CURRENT_PLAYER_PED_ENUM() = CHAR_FRANKLIN
|
|
AND (IS_PED_IN_FOUNDRY_INTERIOR(PLAYER_PED_ID()) OR GET_DISTANCE_BETWEEN_ENTITIES(PLAYER_PED_ID(), lamarPed) > 45)
|
|
HANDLE_KILLING_LAMAR()
|
|
IF NOT IS_TIMER_STARTED(tmrLamarDies)
|
|
CREATE_CONVERSATION(finaleConversation, "FINC1AU", "FINC1_LHELP2", CONV_PRIORITY_MEDIUM)
|
|
START_TIMER_AT(tmrLamarDies, LAMAR_DEATH_TIME - 4)
|
|
ENDIF
|
|
ELSE
|
|
IF IS_TIMER_STARTED(tmrLamarDies)
|
|
CANCEL_TIMER(tmrLamarDies)
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
|
|
SWITCH eShootout2CurrentGoal
|
|
CASE SHOOTOUT_2_INIT
|
|
IF freeHotswapData.state = FREE_HOTSWAP_STATE_SELECTING
|
|
IF GET_CURRENT_PLAYER_PED_ENUM() <> CHAR_FRANKLIN
|
|
eShootout2CurrentGoal = SHOOTOUT_2_SWITCH_TO_FRANK
|
|
RESTART_TIMER_NOW(tmrMichaelIncidental)
|
|
ELSE
|
|
eShootout2CurrentGoal = SHOOTOUT_2_GO_TO_EXIT
|
|
ENDIF
|
|
|
|
TRIGGER_MUSIC_EVENT("FIN1_SHOOTOUT_2")
|
|
|
|
// start this timer
|
|
START_TIMER_NOW_SAFE(tmrLamarDies)
|
|
|
|
CREATE_ENEMY_WAVE(EW_FIB_STAGE2_INSIDE, TRUE)
|
|
eShootout2CurrentText = SHOOTOUT_2_TEXT_LAMAR_CALLS
|
|
ENDIF
|
|
BREAK
|
|
CASE SHOOTOUT_2_SWITCH_TO_FRANK
|
|
// hacky, reset this when the next wave is spawned
|
|
// we're just doing this to get our friends to go to cover
|
|
// @BSW OMGHAX
|
|
IF HANDLE_ENEMY_WAVE(EW_FIB_STAGE2_INSIDE) = 0
|
|
bKilledAll = TRUE
|
|
ENDIF
|
|
HANDLE_KILLING_LAMAR()
|
|
|
|
// is this safe? hacky? @BSW
|
|
IF eShootout2CurrentText = SHOOTOUT_2_TEXT_IDLE
|
|
eShootout2CurrentText = SHOOTOUT_2_TEXT_SWITCH_TO_FRANK
|
|
ENDIF
|
|
|
|
// force a switch to franklin if the player leaves the doors
|
|
// as somebody else
|
|
IF GET_CURRENT_PLAYER_PED_ENUM() <> CHAR_FRANKLIN
|
|
AND freeHotswapData.state = FREE_HOTSWAP_STATE_SELECTING
|
|
IF IS_PLAYER_IN_TRIGGER_BOX(tbBottomExit1Inner)
|
|
OR IS_PLAYER_IN_TRIGGER_BOX(tbBottomExit2Inner)
|
|
OR IS_PLAYER_IN_TRIGGER_BOX(tbTopExitInner)
|
|
sSelectorPeds.eNewSelectorPed = SELECTOR_PED_FRANKLIN
|
|
bForceSwitch = TRUE
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF GET_CURRENT_PLAYER_PED_ENUM() = CHAR_FRANKLIN AND freeHotswapData.state = FREE_HOTSWAP_STATE_SELECTING
|
|
CLEAR_ALL_MISSION_HINTS()
|
|
eShootout2CurrentGoal = SHOOTOUT_2_GO_TO_EXIT
|
|
ENDIF
|
|
BREAK
|
|
CASE SHOOTOUT_2_GO_TO_EXIT
|
|
// hacky, reset this when the next wave is spawned
|
|
// we're just doing this to get our friends to go to cover
|
|
// @BSW OMGHAX
|
|
IF HANDLE_ENEMY_WAVE(EW_FIB_STAGE2_INSIDE) = 0
|
|
bKilledAll = TRUE
|
|
ENDIF
|
|
|
|
SET_ENTITY_ONLY_DAMAGED_BY_PLAYER(GET_TREVOR_PED(), TRUE)
|
|
SET_ENTITY_ONLY_DAMAGED_BY_PLAYER(GET_MICHAEL_PED(), TRUE)
|
|
|
|
eShootout2CurrentText = SHOOTOUT_2_TEXT_GO_TO_EXIT
|
|
|
|
bLockSelector = TRUE
|
|
|
|
// Lamar dialogue
|
|
START_TIMER_NOW_SAFE(tmrLamarIncidental)
|
|
iLamarIncidentalTime = 15
|
|
|
|
eShootout2CurrentGoal = SHOOTOUT_2_CHECK_FOR_EXIT
|
|
BREAK
|
|
CASE SHOOTOUT_2_CHECK_FOR_EXIT
|
|
HANDLE_ENEMY_WAVE(EW_FIB_LAMAR)
|
|
|
|
// @BSW OMGHAX this isn't actually true, it just means all THE INSIDE guys are killed
|
|
// we might want a new checkpoint here anyway, so i'm going to let this exist for the time being
|
|
IF HANDLE_ENEMY_WAVE(EW_FIB_STAGE2_INSIDE) + HANDLE_ENEMY_WAVE(EW_FIB_STAGE2_INSIDE_REINF) = 0
|
|
bKilledAll = TRUE
|
|
ENDIF
|
|
|
|
HANDLE_KILLING_LAMAR()
|
|
|
|
IF NOT HAS_TRIGGER_BOX_BEEN_TRIGGERED(tbNearingBottomExit1)
|
|
IF IS_PLAYER_IN_TRIGGER_BOX(tbNearingBottomExit1)
|
|
// RESET killedAll, and kick trevor and michael back into combat
|
|
bKilledAll = FALSE
|
|
eAllyStates[SELECTOR_PED_MICHAEL].currentState = ALLY_STATE_REINITIALIZE
|
|
eAllyStates[SELECTOR_PED_TREVOR].currentState = ALLY_STATE_REINITIALIZE
|
|
CREATE_ENEMY_WAVE(EW_FIB_STAGE2_INSIDE_REINF, TRUE)
|
|
ENDIF
|
|
ENDIF
|
|
|
|
// is player at any exit
|
|
IF IS_PLAYER_IN_TRIGGER_BOX(tbBottomExit1Inner)
|
|
OR IS_PLAYER_IN_TRIGGER_BOX(tbSaveLamarFailsafe1)
|
|
OR IS_PLAYER_IN_TRIGGER_BOX(tbSaveLamarFailsafe2)
|
|
CPRINTLN(DEBUG_MISSION, "Triggered Lamar Setup")
|
|
POSITION_LAMAR_IN_COVER_FOR_SHOOTOUT()
|
|
CREATE_ENEMY_WAVE(EW_FIB_LAMAR, FALSE)
|
|
CREATE_ENEMY_VEHICLE(EV_FIB_FIGHTING_LAMAR)
|
|
TASK_ENEMY_WAVE_SHOOT_AT_LAMAR(EW_FIB_LAMAR)
|
|
|
|
TOGGLE_ENEMY_WAVE_ONLY_DAMAGED_BY_PLAYER(EW_FIB_LAMAR, FALSE)
|
|
|
|
eShootout2CurrentGoal = SHOOTOUT_2_OUTSIDE_1
|
|
ENDIF
|
|
BREAK
|
|
CASE SHOOTOUT_2_OUTSIDE_1
|
|
INT iWaveEnemiesAlive
|
|
iWaveEnemiesAlive = HANDLE_ENEMY_WAVE(EW_FIB_LAMAR)
|
|
|
|
HANDLE_GET_TO_LAMAR_SUCCESS()
|
|
|
|
// stop Lamar help dialogue if an enemy died
|
|
IF NOT bLamarCalmedDown
|
|
IF iWaveEnemiesAlive < 5
|
|
bLamarCalmedDown = TRUE
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF iWaveEnemiesAlive <= 3
|
|
CREATE_ENEMY_WAVE(EW_FIB_REINF_LAMAR, TRUE)
|
|
TASK_ENEMY_WAVE_GO_AGGRESSIVE(EW_FIB_REINF_LAMAR)
|
|
TOGGLE_ENEMY_WAVE_ONLY_DAMAGED_BY_PLAYER(EW_FIB_REINF_LAMAR, FALSE)
|
|
eShootout2CurrentGoal = SHOOTOUT_2_OUTSIDE_2
|
|
ENDIF
|
|
BREAK
|
|
CASE SHOOTOUT_2_OUTSIDE_2
|
|
HANDLE_GET_TO_LAMAR_SUCCESS()
|
|
|
|
IF HANDLE_ENEMY_WAVE(EW_FIB_LAMAR) + HANDLE_ENEMY_WAVE(EW_FIB_REINF_LAMAR) <= 5
|
|
CPRINTLN(DEBUG_MISSION, "Lamar Is Safe: enough enemies killed")
|
|
bLamarWasSaved = TRUE
|
|
|
|
LAMAR_SAVED_CLEANUP()
|
|
|
|
SETUP_PLAYERS_FOR_SHOOTOUT_3(FALSE)
|
|
|
|
TASK_ENEMY_WAVE_GO_AGGRESSIVE(EW_FIB_LAMAR)
|
|
TASK_ENEMY_WAVE_GO_AGGRESSIVE(EW_FIB_REINF_LAMAR)
|
|
|
|
eShootout2CurrentText = SHOOTOUT_2_TEXT_MICHAEL_UNDER_ATTACK
|
|
eShootout2CurrentGoal = SHOOTOUT_2_SWITCH
|
|
ENDIF
|
|
BREAK
|
|
CASE SHOOTOUT_2_SWITCH
|
|
HANDLE_ENEMY_WAVE(EW_FIB_LAMAR)
|
|
HANDLE_ENEMY_WAVE(EW_FIB_REINF_LAMAR)
|
|
HANDLE_ENEMY_WAVE(EW_FIB_INFINITE_LAMAR)
|
|
|
|
IF GET_TIMER_IN_SECONDS_SAFE(tmrSwitchToMikeFailTime) > 25
|
|
MISSION_FAILED(FAIL_TREVOR_DEAD)
|
|
ELSE
|
|
IF HANDLE_ENEMY_WAVE(EW_FIB_LAMAR) + HANDLE_ENEMY_WAVE(EW_FIB_REINF_LAMAR) + HANDLE_ENEMY_WAVE(EW_FIB_INFINITE_LAMAR) = 0
|
|
CREATE_ENEMY_WAVE(EW_FIB_INFINITE_LAMAR, TRUE)
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF GET_CURRENT_PLAYER_PED_ENUM() <> CHAR_FRANKLIN AND freeHotswapData.state = FREE_HOTSWAP_STATE_IN_PROGRESS
|
|
CLEAR_ALL_MISSION_HINTS()
|
|
|
|
SETUP_PLAYERS_FOR_SHOOTOUT_3()
|
|
CREATE_ENEMY_WAVE(EW_FIB_ATTACK_TREVOR_GROUND, TRUE)
|
|
|
|
DELETE_ENEMY_WAVE(EW_FIB_LAMAR, TRUE)
|
|
DELETE_ENEMY_WAVE(EW_FIB_REINF_LAMAR, TRUE)
|
|
DELETE_ENEMY_WAVE(EW_FIB_INFINITE_LAMAR, TRUE)
|
|
|
|
eShootout2CurrentGoal = SHOOTOUT_2_FINISH_SWITCH
|
|
ENDIF
|
|
BREAK
|
|
|
|
CASE SHOOTOUT_2_FINISH_SWITCH
|
|
IF GET_CURRENT_PLAYER_PED_ENUM() <> CHAR_FRANKLIN AND freeHotswapData.state = FREE_HOTSWAP_STATE_SELECTING
|
|
HANDLE_ENEMY_WAVE(EW_FIB_ATTACK_TREVOR_GROUND)
|
|
SET_MISSION_STAGE(STAGE_SHOOTOUT_STAGE_3)
|
|
ENDIF
|
|
BREAK
|
|
ENDSWITCH
|
|
ENDPROC
|
|
|
|
PROC HANDLE_SHOOTOUT_STAGE_3_TEXT()
|
|
SWITCH eShootout3CurrentText
|
|
CASE SHOOTOUT_3_TEXT_MICHAEL_SAYS_IM_GOING
|
|
IF NOT IS_ANY_CONVERSATION_ONGOING_OR_QUEUED()
|
|
IF CREATE_CONVERSATION(finaleConversation, "FINC1AU", "FINC1_SWM", CONV_PRIORITY_VERY_HIGH)
|
|
eShootout3CurrentText = SHOOTOUT_3_TEXT_GO_TO_TREV
|
|
ENDIF
|
|
ENDIF
|
|
BREAK
|
|
CASE SHOOTOUT_3_TEXT_GO_TO_TREV
|
|
IF DO_MISSION_GOD_TEXT("FC1_GOTR")
|
|
IF DOES_BLIP_EXIST(gotoBlip)
|
|
REMOVE_BLIP(gotoBlip)
|
|
ENDIF
|
|
gotoBlip = CREATE_BLIP_FOR_COORD(GET_FINALE_VECTOR(FINVEC_TREVOR_SAVETREVOR))
|
|
MAKE_COORD_BLIP_FRIENDLY(gotoBlip)
|
|
|
|
RESTART_TIMER_NOW(tmrFranklinIncidental)
|
|
|
|
REPLAY_RECORD_BACK_FOR_TIME(5.0, 10.0, REPLAY_IMPORTANCE_HIGHEST)
|
|
|
|
eShootout3CurrentText = SHOOTOUT_3_TEXT_IDLE
|
|
ENDIF
|
|
BREAK
|
|
CASE SHOOTOUT_3_TEXT_MICHAEL_REACHES_TREVOR
|
|
IF CREATE_CONVERSATION(finaleConversation, "FINC1AU", "FINC1_SEET", CONV_PRIORITY_VERY_HIGH)
|
|
IF DOES_BLIP_EXIST(gotoBlip)
|
|
REMOVE_BLIP(gotoBlip)
|
|
ENDIF
|
|
REPLAY_RECORD_BACK_FOR_TIME(5.0, 10.0, REPLAY_IMPORTANCE_HIGHEST)
|
|
eShootout3CurrentText = SHOOTOUT_3_TEXT_TREVOR_EXPLAINS_HIMSELF
|
|
ENDIF
|
|
BREAK
|
|
CASE SHOOTOUT_3_TEXT_TREVOR_EXPLAINS_HIMSELF
|
|
IF NOT IS_ANY_CONVERSATION_ONGOING_OR_QUEUED()
|
|
IF CREATE_CONVERSATION(finaleConversation, "FINC1AU", "FINC1_MHELPT", CONV_PRIORITY_VERY_HIGH)
|
|
eShootout3CurrentText = SHOOTOUT_3_TEXT_U_MAD_MICHAEL
|
|
ENDIF
|
|
ENDIF
|
|
BREAK
|
|
CASE SHOOTOUT_3_TEXT_U_MAD_MICHAEL
|
|
IF NOT IS_ANY_CONVERSATION_ONGOING_OR_QUEUED()
|
|
IF CREATE_CONVERSATION(finaleConversation, "FINC1AU", "FINC1_ASST", CONV_PRIORITY_VERY_HIGH)
|
|
eShootout3CurrentText = SHOOTOUT_3_MORE_FIB_ENTER
|
|
ENDIF
|
|
ENDIF
|
|
BREAK
|
|
CASE SHOOTOUT_3_MORE_FIB_ENTER
|
|
IF NOT IS_ANY_CONVERSATION_ONGOING_OR_QUEUED()
|
|
IF CREATE_CONVERSATION(finaleConversation, "FINC1AU", "FINC1_LOOK", CONV_PRIORITY_VERY_HIGH)
|
|
eShootout3CurrentText = SHOOTOUT_3_TEXT_DEFEND
|
|
ENDIF
|
|
ENDIF
|
|
BREAK
|
|
CASE SHOOTOUT_3_TEXT_DEFEND
|
|
IF NOT IS_ANY_CONVERSATION_ONGOING_OR_QUEUED()
|
|
IF DO_MISSION_GOD_TEXT("FC1_KILL")
|
|
|
|
eShootout3CurrentText = SHOOTOUT_3_TEXT_IDLE
|
|
ENDIF
|
|
ENDIF
|
|
BREAK
|
|
CASE SHOOTOUT_3_TEXT_EXIT_FOUNDRY
|
|
STRING sConvName
|
|
IF GET_CURRENT_PLAYER_PED_ENUM() = CHAR_MICHAEL
|
|
sConvName = "FINC1_EXIT"
|
|
ELSE
|
|
sConvName = "FINC1_EXIT2"
|
|
ENDIF
|
|
|
|
IF CREATE_CONVERSATION(finaleConversation, "FINC1AU", sConvName, CONV_PRIORITY_HIGH)
|
|
|
|
REPLAY_RECORD_BACK_FOR_TIME(5.0, 10.0, REPLAY_IMPORTANCE_HIGHEST)
|
|
|
|
eShootout3CurrentText = SHOOTOUT_3_TEXT_GO_TO_DOOR
|
|
ENDIF
|
|
BREAK
|
|
CASE SHOOTOUT_3_TEXT_GO_TO_DOOR
|
|
IF NOT IS_ANY_CONVERSATION_ONGOING_OR_QUEUED()
|
|
IF DO_MISSION_GOD_TEXT("FC1_GODOOR")
|
|
RESTART_TIMER_NOW(tmrFranklinIncidental)
|
|
eShootout3CurrentText = SHOOTOUT_3_TEXT_IDLE
|
|
ENDIF
|
|
ENDIF
|
|
BREAK
|
|
CASE SHOOTOUT_3_TEXT_IDLE
|
|
IF NOT IS_ANY_CONVERSATION_ONGOING_OR_QUEUED() AND NOT IS_MESSAGE_BEING_DISPLAYED()
|
|
IF bTrevorIsInjured
|
|
IF GET_TIMER_IN_SECONDS_SAFE(tmrMichaelIncidental) > iMichaelIncidentalTime
|
|
IF CREATE_CONVERSATION(finaleConversation, "FINC1AU", "FINC1_LOOKT", CONV_PRIORITY_MEDIUM)
|
|
iMichaelIncidentalTime = GET_RANDOM_INT_IN_RANGE(11, 17)
|
|
RESTART_TIMER_NOW(tmrMichaelIncidental)
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
IF GET_TIMER_IN_SECONDS_SAFE(tmrFranklinIncidental) > iFranklinIncidentalTime AND eShootout3CurrentGoal > SHOOTOUT_3_INIT
|
|
STRING sFranklinConv
|
|
IF bKilledAll
|
|
sFranklinConv = "FINC1_HELPF"
|
|
ELSE
|
|
sFranklinConv = "FINC1_FOUT"
|
|
ENDIF
|
|
add_ped_for_dialogue(finaleConversation, 2, null, "FRANKLIN")
|
|
IF CREATE_CONVERSATION(finaleConversation, "FINC1AU", sFranklinConv, CONV_PRIORITY_MEDIUM)
|
|
iFranklinIncidentalTime = GET_RANDOM_INT_IN_RANGE(15, 22)
|
|
RESTART_TIMER_NOW(tmrFranklinIncidental)
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
BREAK
|
|
ENDSWITCH
|
|
ENDPROC
|
|
|
|
FUNC BOOL DO_STAGE_SHOOTOUT_STAGE_3()
|
|
BOOL bRetVal = FALSE
|
|
|
|
HANDLE_TREVOR_INJURED()
|
|
DO_COMMON_SHOOTOUT_FUNCTIONS()
|
|
HANDLE_SHOOTOUT_STAGE_3_TEXT()
|
|
|
|
HANDLE_CLEAR_NEW_LOAD_SCENE()
|
|
|
|
SWITCH eShootout3CurrentGoal
|
|
CASE SHOOTOUT_3_INIT
|
|
|
|
SET_SELECTOR_PED_BLOCKED(sSelectorPeds, SELECTOR_PED_FRANKLIN, TRUE)
|
|
IF DOES_ENTITY_EXIST(sSelectorPeds.pedID[SELECTOR_PED_FRANKLIN])
|
|
CPRINTLN(DEBUG_MISSION, "BSW deleting Franklin for stage 3")
|
|
REMOVE_ENTITY_FROM_AUDIO_MIX_GROUP(sSelectorPeds.pedID[SELECTOR_PED_FRANKLIN])
|
|
IF DOES_BLIP_EXIST(buddyBlip[SELECTOR_PED_FRANKLIN])
|
|
REMOVE_BLIP(buddyBlip[SELECTOR_PED_FRANKLIN])
|
|
ENDIF
|
|
DELETE_PED(sSelectorPeds.pedID[SELECTOR_PED_FRANKLIN])
|
|
ENDIF
|
|
|
|
TRIGGER_MUSIC_EVENT("FIN1_SHOOTOUT_3")
|
|
|
|
RESTART_TIMER_NOW(tmrMichaelIncidental)
|
|
RESTART_TIMER_NOW(tmrStage3SecondWaveBackup)
|
|
iMichaelIncidentalTime = 10
|
|
|
|
HANDLE_ENEMY_WAVE(EW_FIB_ATTACK_TREVOR_GROUND)
|
|
|
|
IF DOES_BLIP_EXIST(gotoBlip)
|
|
REMOVE_BLIP(gotoBlip)
|
|
ENDIF
|
|
IF DOES_BLIP_EXIST(lamarBlip)
|
|
REMOVE_BLIP(lamarBlip)
|
|
ENDIF
|
|
|
|
|
|
eShootout3CurrentText = SHOOTOUT_3_TEXT_MICHAEL_SAYS_IM_GOING
|
|
eShootout3CurrentGoal = SHOOTOUT_3_ATTACK_1
|
|
BREAK
|
|
CASE SHOOTOUT_3_ATTACK_1
|
|
HANDLE_ENEMY_WAVE(EW_FIB_ATTACK_TREVOR_GROUND)
|
|
HANDLE_SHOOTOUT3_SQUIBS()
|
|
|
|
IF GET_NUM_LIVING_ENEMIES() < 2 OR IS_PLAYER_IN_TRIGGER_BOX(tbBottomExit2Inner)
|
|
IF IS_PLAYER_IN_TRIGGER_BOX(tbNearingBottomExit1) OR GET_TIMER_IN_SECONDS_SAFE(tmrStage3SecondWaveBackup) > 60
|
|
CREATE_ENEMY_WAVE(EW_FIB_ATTACK_TREVOR_GROUND_REINF, TRUE)
|
|
|
|
eShootout3CurrentGoal = SHOOTOUT_3_ATTACK_2
|
|
ENDIF
|
|
ENDIF
|
|
BREAK
|
|
CASE SHOOTOUT_3_ATTACK_2
|
|
HANDLE_ENEMY_WAVE(EW_FIB_ATTACK_TREVOR_GROUND)
|
|
HANDLE_ENEMY_WAVE(EW_FIB_ATTACK_TREVOR_GROUND_REINF)
|
|
|
|
// Michael rescues Trevor
|
|
IF IS_PLAYER_IN_TRIGGER_BOX(tbInjuredTrevor) AND GET_NUM_ENEMIES_IN_TRIGGER_BOX(tbInjuredTrevor) = 0
|
|
CREATE_ENEMY_WAVE(EW_FIB_ATTACK_TREVOR_CLIMAX_1, TRUE)
|
|
CREATE_ENEMY_WAVE(EW_FIB_ATTACK_TREVOR_CATWALK, TRUE)
|
|
|
|
TASK_ENEMY_WAVE_MOVE_ONTO_CATWALK(EW_FIB_ATTACK_TREVOR_CATWALK)
|
|
TASK_ENEMY_WAVE_INTO_FOUNDRY(EW_FIB_ATTACK_TREVOR_CLIMAX_1, 2)
|
|
|
|
TRIGGER_MUSIC_EVENT("FIN1_TREV_HELPED")
|
|
|
|
eShootout3CurrentText = SHOOTOUT_3_TEXT_MICHAEL_REACHES_TREVOR
|
|
|
|
eShootout3CurrentGoal = SHOOTOUT_3_ATTACK_3
|
|
ENDIF
|
|
BREAK
|
|
CASE SHOOTOUT_3_ATTACK_3
|
|
HANDLE_SHOOTOUT_3_ABANDON_CHECK()
|
|
IF HANDLE_ENEMY_WAVE(EW_FIB_ATTACK_TREVOR_GROUND)
|
|
+ HANDLE_ENEMY_WAVE(EW_FIB_ATTACK_TREVOR_GROUND_REINF)
|
|
+ HANDLE_ENEMY_WAVE(EW_FIB_ATTACK_TREVOR_CATWALK)
|
|
+ HANDLE_ENEMY_WAVE(EW_FIB_ATTACK_TREVOR_CLIMAX_1) < 4
|
|
|
|
CREATE_ENEMY_WAVE(EW_FIB_ATTACK_TREVOR_CLIMAX_2, TRUE)
|
|
|
|
TASK_ENEMY_WAVE_INTO_FOUNDRY(EW_FIB_ATTACK_TREVOR_CLIMAX_2, 2)
|
|
|
|
eShootout3CurrentGoal = SHOOTOUT_3_ATTACK_4
|
|
ENDIF
|
|
BREAK
|
|
CASE SHOOTOUT_3_ATTACK_4
|
|
HANDLE_SHOOTOUT_3_ABANDON_CHECK()
|
|
IF HANDLE_ENEMY_WAVE(EW_FIB_ATTACK_TREVOR_GROUND)
|
|
+ HANDLE_ENEMY_WAVE(EW_FIB_ATTACK_TREVOR_GROUND_REINF)
|
|
+ HANDLE_ENEMY_WAVE(EW_FIB_ATTACK_TREVOR_CATWALK)
|
|
+ HANDLE_ENEMY_WAVE(EW_FIB_ATTACK_TREVOR_CLIMAX_1)
|
|
+ HANDLE_ENEMY_WAVE(EW_FIB_ATTACK_TREVOR_CLIMAX_2) = 0
|
|
bKilledAll = TRUE
|
|
|
|
eAllyStates[SELECTOR_PED_MICHAEL].currentState = ALLY_STATE_GOING_TO_FOUNDRY_INNER_EXIT
|
|
eAllyStates[SELECTOR_PED_TREVOR].currentState = ALLY_STATE_GOING_TO_FOUNDRY_INNER_EXIT
|
|
|
|
CREATE_FAKE_ENEMY_BLIPS()
|
|
|
|
eShootout3CurrentText = SHOOTOUT_3_TEXT_EXIT_FOUNDRY
|
|
|
|
IF IS_PLAYER_IN_TRIGGER_BOX(tbCloserToCatwalkExit)
|
|
selectorPedToTopExit = GET_SELECTOR_SLOT_FROM_PLAYER_PED_ENUM(GET_CURRENT_PLAYER_PED_ENUM())
|
|
ELSE
|
|
selectorPedToTopExit = GET_NON_PLAYER_PED_FOR_FOUNDRY_EXIT()
|
|
ENDIF
|
|
|
|
eShootout3CurrentGoal = SHOOTOUT_3_EXIT
|
|
ENDIF
|
|
BREAK
|
|
CASE SHOOTOUT_3_EXIT
|
|
IF HAVE_ALL_MODEL_REQUESTS_SUCCEEDED() AND HAVE_ALL_RECORDING_REQUESTS_SUCCEEDED() //@BSW why?
|
|
INT i
|
|
REPEAT NUMBER_EXITS i
|
|
IF IS_ENTITY_AT_COORD(PLAYER_PED_ID(), GET_EXIT_COORD(i), GET_EXIT_DIMENSIONS(i))
|
|
|
|
CLEANUP_BLOCKING_OBJECTS()
|
|
|
|
INT exitIter
|
|
REPEAT NUMBER_EXITS exitIter
|
|
IF DOES_BLIP_EXIST(exitBlip[exitIter])
|
|
REMOVE_BLIP(exitBlip[exitIter])
|
|
ENDIF
|
|
ENDREPEAT
|
|
// recreate frank
|
|
FINALE_CREATE_PLAYER_CHARACTER(CHAR_FRANKLIN, GET_FINALE_VECTOR(FINVEC_FRANKLIN_OUTSIDE_READY), FRANKLIN_OUTSIDE_READY_ROT, NULL, VS_DRIVER, TRUE)
|
|
TASK_PUT_PED_DIRECTLY_INTO_COVER(GET_FRANKLIN_PED(), GET_FINALE_VECTOR(FINVEC_FRANKLIN_OUTSIDE_READY), INFINITE_TASK_TIME, TRUE, 0.0, FALSE, FALSE, franklinExitOuterCover, TRUE)
|
|
SET_SELECTOR_PED_BLOCKED(sSelectorPeds, SELECTOR_PED_FRANKLIN, FALSE)
|
|
BLIP_BUDDIES()
|
|
|
|
WEAPON_TYPE newRifle
|
|
newRifle = GET_PED_WEAPONTYPE_IN_SLOT(GET_FRANKLIN_PED(), WEAPONSLOT_ASSAULTRIFLE)
|
|
IF IS_WEAPON_VALID(newRifle)
|
|
SET_CURRENT_PED_WEAPON(GET_FRANKLIN_PED(), newRifle, TRUE)
|
|
ELSE
|
|
GIVE_WEAPON_TO_PED(GET_FRANKLIN_PED(), WEAPONTYPE_ASSAULTRIFLE, 200, TRUE)
|
|
ENDIF
|
|
|
|
IF GET_DISTANCE_BETWEEN_ENTITIES(GET_MICHAEL_PED(), GET_TREVOR_PED()) < 20
|
|
CPRINTLN(DEBUG_MISSION, "BSW we're close together, just task out")
|
|
ADVANCE_PLAYER_PED_TO_OUTSIDE_EXIT(GET_NON_PLAYER_PED_FOR_FOUNDRY_EXIT())
|
|
ELSE
|
|
IF i = iEXIT_CATWALK
|
|
CPRINTLN(DEBUG_MISSION, "BSW we're far from the other player and on the catwalk")
|
|
ADVANCE_PLAYER_PED_TO_OUTSIDE_EXIT(GET_NON_PLAYER_PED_FOR_FOUNDRY_EXIT())
|
|
ELSE
|
|
CPRINTLN(DEBUG_MISSION, "BSW we're far from the other player and at the back exit")
|
|
START_TIMER_NOW_SAFE(tmrTopOuterBuddyAppear)
|
|
ENDIF
|
|
ENDIF
|
|
|
|
|
|
bRetVal = TRUE
|
|
|
|
SET_MISSION_STAGE(STAGE_SHOOTOUT_STAGE_4)
|
|
ENDIF
|
|
ENDREPEAT
|
|
ENDIF
|
|
BREAK
|
|
ENDSWITCH
|
|
|
|
RETURN bRetVal
|
|
ENDFUNC
|
|
|
|
PROC DO_STAGE_SHOOTOUT_STAGE_4()
|
|
IF NOT bRunningCutscene
|
|
|
|
DO_COMMON_SHOOTOUT_FUNCTIONS()
|
|
|
|
IF bGoneOutsideDialogue
|
|
IF NOT bShootout4ObjectiveDialogue
|
|
STRING sObjectiveDialogue
|
|
IF GET_CURRENT_PLAYER_PED_ENUM() = CHAR_MICHAEL
|
|
sObjectiveDialogue = "FINC1_OBJ_T"
|
|
ELSE
|
|
sObjectiveDialogue = "FINC1_OBJ_M"
|
|
ENDIF
|
|
bShootout4ObjectiveDialogue = CREATE_CONVERSATION(finaleConversation, "FINC1AU", sObjectiveDialogue, CONV_PRIORITY_MEDIUM)
|
|
ELSE
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF freeHotswapData.state = FREE_HOTSWAP_STATE_SELECTING
|
|
IF NOT bShownKillAllText AND bShootout4ObjectiveDialogue
|
|
bShownKillAllText = DO_MISSION_GOD_TEXT("FC1_TAKE2")
|
|
IF bShownKillAllText
|
|
REPLAY_RECORD_BACK_FOR_TIME(5.0, 10.0, REPLAY_IMPORTANCE_HIGHEST)
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF NOT bKilledAll
|
|
INT iBackFighersAlive = 0
|
|
INT iFrontFightersAlive = 0
|
|
INT iMidFightersAlive = 0
|
|
|
|
// do this here to break up the spawning of objects
|
|
// (specifically ABOVE created lamar fight, but waiting on it to be done)
|
|
IF NOT bCreatedAmbientCopCars AND bCreatedLamarFight
|
|
bCreatedAmbientCopCars = TRUE
|
|
CREATE_AMBIENT_VEHICLES()
|
|
ENDIF
|
|
|
|
iBackFighersAlive += HANDLE_ENEMY_WAVE(EW_FIB_BATTLE_OUTSIDE)
|
|
iBackFighersAlive += HANDLE_ENEMY_WAVE(EW_MERC_BATTLE_OUTSIDE)
|
|
iBackFighersAlive += HANDLE_ENEMY_WAVE(EW_MERC_HELI_GROUP)
|
|
iBackFighersAlive += HANDLE_ENEMY_WAVE(EW_MERC_UP_ROAD)
|
|
iBackFighersAlive += HANDLE_ENEMY_WAVE(EW_MERC_TRAIN_REINF1)
|
|
iBackFighersAlive += HANDLE_ENEMY_WAVE(EW_MERC_TRAIN_REINF2)
|
|
|
|
iFrontFightersAlive += HANDLE_ENEMY_WAVE(EW_FIB_ON_ROAD)
|
|
iFrontFightersAlive += HANDLE_ENEMY_WAVE(EW_FIB_ROAD_REINF)
|
|
|
|
iMidFightersAlive += HANDLE_ENEMY_WAVE(EW_FIB_MID_FIGHTERS_FRONT)
|
|
iMidFightersAlive += HANDLE_ENEMY_WAVE(EW_MERC_MID_FIGHTERS_BACK)
|
|
|
|
IF IS_ANY_PED_IN_FOUNDRY_INTERIOR()
|
|
SET_DOOR_STATE(DOORNAME_FOUNDRY_B_01, DOORSTATE_UNLOCKED)
|
|
SET_DOOR_STATE(DOORNAME_FOUNDRY_B_02, DOORSTATE_UNLOCKED)
|
|
SET_DOOR_STATE(DOORNAME_FOUNDRY_T_01, DOORSTATE_UNLOCKED)
|
|
ELSE
|
|
SET_DOOR_STATE(DOORNAME_FOUNDRY_B_01, DOORSTATE_LOCKED)
|
|
SET_DOOR_STATE(DOORNAME_FOUNDRY_B_02, DOORSTATE_LOCKED)
|
|
SET_DOOR_STATE(DOORNAME_FOUNDRY_T_01, DOORSTATE_LOCKED)
|
|
ENDIF
|
|
|
|
// task Lamar
|
|
HANDLE_LAMAR_IN_COMBAT()
|
|
|
|
// player specific stuff
|
|
IF freeHotswapData.state = FREE_HOTSWAP_STATE_SELECTING
|
|
IF IS_ENTITY_OK(PLAYER_PED_ID())
|
|
IF IS_PED_SHOOTING(PLAYER_PED_ID())
|
|
IF NOT IS_ANY_CONVERSATION_ONGOING_OR_QUEUED() AND NOT IS_MESSAGE_BEING_DISPLAYED()
|
|
IF GET_CURRENT_PLAYER_PED_ENUM() = CHAR_FRANKLIN
|
|
DO_RANDOM_SPEECH("FINC1_FBANT")
|
|
ELIF GET_CURRENT_PLAYER_PED_ENUM() = CHAR_TREVOR
|
|
DO_RANDOM_SPEECH("FINC1_ATT_T")
|
|
ELIF GET_CURRENT_PLAYER_PED_ENUM() = CHAR_MICHAEL
|
|
DO_RANDOM_SPEECH("FINC1_ATT_M")
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF NOT bTaskedTopPlayerOut
|
|
// if the player has switched to this ped, dont worry about the tasking anymore
|
|
IF GET_SELECTOR_SLOT_FROM_PLAYER_PED_ENUM(GET_CURRENT_PLAYER_PED_ENUM()) = selectorPedToTopExit
|
|
bTaskedTopPlayerOut = TRUE
|
|
ENDIF
|
|
|
|
IF GET_TIMER_IN_SECONDS_SAFE(tmrTopOuterBuddyAppear) > 5 AND freeHotswapData.state = FREE_HOTSWAP_STATE_SELECTING
|
|
IF IS_ENTITY_OK(sSelectorPeds.pedID[selectorPedToTopExit])
|
|
SET_ENTITY_COORDS(sSelectorPeds.pedID[selectorPedToTopExit], GET_SCRIPTED_COVER_POINT_COORDS(topExitInnerCover))
|
|
FORCE_ROOM_FOR_ENTITY(sSelectorPeds.pedID[selectorPedToTopExit], foundryInterior, GET_HASH_KEY("foundrymainrm"))
|
|
ADVANCE_PLAYER_PED_TO_OUTSIDE_EXIT(GET_NON_PLAYER_PED_FOR_FOUNDRY_EXIT())
|
|
|
|
CPRINTLN(DEBUG_MISSION, "BSW tasking top player out of foundry")
|
|
|
|
bTaskedTopPlayerOut = TRUE
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF NOT bCreatedRoadMercs
|
|
IF NOT IS_PED_IN_FOUNDRY_INTERIOR(PLAYER_PED_ID())
|
|
OR bCreatedFIBRoadReinf OR iBackFighersAlive < 4 // SUPER SAFETY
|
|
CREATE_ENEMY_WAVE(EW_MERC_UP_ROAD, TRUE, TRUE)
|
|
iBackFighersAlive += HANDLE_ENEMY_WAVE(EW_MERC_UP_ROAD)
|
|
|
|
DELETE_FAKE_ENEMY_BLIPS()
|
|
|
|
bCreatedRoadMercs = TRUE
|
|
ENDIF
|
|
ELSE
|
|
IF NOT bGoneOutsideDialogue
|
|
IF GET_CURRENT_PLAYER_PED_ENUM() = CHAR_FRANKLIN
|
|
bGoneOutsideDialogue = TRUE
|
|
ELSE
|
|
STRING sOutsideDialogue
|
|
IF GET_CURRENT_PLAYER_PED_ENUM() = CHAR_MICHAEL
|
|
sOutsideDialogue = "FINC1_OUT_M"
|
|
ELSE
|
|
sOutsideDialogue = "FINC1_OUT_T"
|
|
ENDIF
|
|
bGoneOutsideDialogue = CREATE_CONVERSATION(finaleConversation, "FINC1AU", sOutsideDialogue, CONV_PRIORITY_MEDIUM)
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF NOT bCreatedLamarFight
|
|
IF NOT DOES_ENTITY_EXIST(enemyVehicle[EV_FIB_FIGHTING_LAMAR].veh)
|
|
CREATE_ENEMY_VEHICLE(EV_FIB_FIGHTING_LAMAR)
|
|
ENDIF
|
|
CREATE_ENEMY_WAVE(EW_FIB_ON_ROAD, TRUE, TRUE)
|
|
iFrontFightersAlive += HANDLE_ENEMY_WAVE(EW_FIB_ON_ROAD)
|
|
bCreatedLamarFight = TRUE
|
|
|
|
// JUST PIGGYBACKING HERE
|
|
bDoneRegroupCue = TRIGGER_MUSIC_EVENT("FIN1_SHOOTOUT_4")
|
|
bAudioStartShootout4 = TRUE
|
|
ENDIF
|
|
|
|
IF bCreatedRoadMercs AND bSpawnedHelicopter
|
|
IF NOT bCreatedTrainMercs1
|
|
IF iBackFighersAlive < 3
|
|
CPRINTLN(DEBUG_MISSION, "BSW creating merc train reinf1")
|
|
CREATE_ENEMY_WAVE(EW_MERC_TRAIN_REINF1, TRUE, TRUE)
|
|
iBackFighersAlive += HANDLE_ENEMY_WAVE(EW_MERC_TRAIN_REINF1)
|
|
|
|
bCreatedTrainMercs1 = TRUE
|
|
ENDIF
|
|
ELSE
|
|
IF NOT bCreatedTrainMercs2
|
|
CPRINTLN(DEBUG_MISSION, "BSW creating merc train reinf2")
|
|
CREATE_ENEMY_WAVE(EW_MERC_TRAIN_REINF2, TRUE, TRUE)
|
|
iBackFighersAlive += HANDLE_ENEMY_WAVE(EW_MERC_TRAIN_REINF2)
|
|
|
|
bCreatedTrainMercs2 = TRUE
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF NOT bCreatedFIBRoadReinf
|
|
IF bCreatedLamarFight AND iFrontFightersAlive + iMidFightersAlive < 4
|
|
CREATE_ENEMY_WAVE(EW_FIB_ROAD_REINF, TRUE, TRUE)
|
|
iFrontFightersAlive += HANDLE_ENEMY_WAVE(EW_FIB_ROAD_REINF)
|
|
|
|
bCreatedFIBRoadReinf = TRUE
|
|
ENDIF
|
|
ENDIF
|
|
|
|
|
|
// crappy implementation. implementing late night feedback...
|
|
// if you're near the back fight and kill (most) everybody, spawn some guys
|
|
// at the front fight and send them to the middle to draw you towards front.
|
|
// if you're near the front, do vice versa
|
|
IF NOT bCreatedMidChargers
|
|
IF (iBackFighersAlive < 2 AND bCreatedTrainMercs2) OR (iFrontFightersAlive < 2 AND bCreatedFIBRoadReinf)
|
|
FLOAT fDistanceFromBack = GET_DISTANCE_BETWEEN_ENTITY_AND_COORD(PLAYER_PED_ID(), <<1084.2373, -2035.6226, 30.0245>>)
|
|
FLOAT fDistanceFromFront = GET_DISTANCE_BETWEEN_ENTITY_AND_COORD(PLAYER_PED_ID(), <<1065.7296, -1962.3138, 30.0444>>)
|
|
|
|
IF fDistanceFromBack < 35
|
|
OR fDistanceFromFront < 40
|
|
ENEMY_WAVE_ENUM eMidFighters
|
|
IF fDistanceFromBack < 35
|
|
eMidFighters = EW_FIB_MID_FIGHTERS_FRONT
|
|
ELSE
|
|
eMidFighters = EW_MERC_MID_FIGHTERS_BACK
|
|
ENDIF
|
|
|
|
CPRINTLN(DEBUG_MISSION, "BSW spawning the midfighters")
|
|
|
|
CREATE_ENEMY_WAVE(eMidFighters, TRUE, TRUE)
|
|
|
|
iMidFightersAlive += HANDLE_ENEMY_WAVE(eMidFighters)
|
|
|
|
bCreatedMidChargers = TRUE
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF iBackFighersAlive + iFrontFightersAlive + iMidFightersAlive = 0
|
|
TRIGGER_MUSIC_EVENT("FIN1_GUNS_DONE")
|
|
|
|
bLockSelector = TRUE
|
|
|
|
// start the cutscene loading as early as possible
|
|
HANDLE_END_CUTSCENE()
|
|
|
|
REMOVE_ALL_BLIPS()
|
|
bKilledAll = TRUE
|
|
bAudioStopSHootout4 = TRUE
|
|
// this will (after a tick) bump us to ALLY_STATE_GOING_TO_FINISH
|
|
eAllyStates[SELECTOR_PED_MICHAEL].currentState = ALLY_STATE_REINITIALIZE
|
|
eAllyStates[SELECTOR_PED_TREVOR].currentState = ALLY_STATE_REINITIALIZE
|
|
eAllyStates[SELECTOR_PED_FRANKLIN].currentState = ALLY_STATE_REINITIALIZE
|
|
ENDIF
|
|
|
|
IF NOT bToggledBackFightInvuln AND bCreatedRoadMercs
|
|
//optimize
|
|
IF IS_ANY_BUDDY_IN_TRIGGER_BOX(tbTopExitOuter, GET_MICHAEL_PED(), GET_TREVOR_PED(), GET_FRANKLIN_PED())
|
|
OR IS_ANY_BUDDY_IN_TRIGGER_BOX(tbBottomApproachBackFight, GET_MICHAEL_PED(), GET_TREVOR_PED(), GET_FRANKLIN_PED())
|
|
TOGGLE_ENEMY_WAVE_ONLY_DAMAGED_BY_PLAYER(EW_MERC_BATTLE_OUTSIDE, FALSE)
|
|
TOGGLE_ENEMY_WAVE_ONLY_DAMAGED_BY_PLAYER(EW_FIB_BATTLE_OUTSIDE, FALSE)
|
|
TOGGLE_ENEMY_WAVE_ONLY_DAMAGED_BY_PLAYER(EW_MERC_UP_ROAD, FALSE)
|
|
|
|
bToggledBackFightInvuln = TRUE
|
|
ENDIF
|
|
ENDIF
|
|
|
|
// OK to spawn helicopter?
|
|
IF NOT bSpawnedHelicopter
|
|
IF iBackFighersAlive + iMidFightersAlive < 4
|
|
IF WOULD_ENTITY_BE_OCCLUDED(GET_MODEL_FOR_FINALE_MODEL_ENUM(FM_MERC_CHOPPER), (<<1154.35510, -1995.90137, 48.00383>>))
|
|
CPRINTLN(DEBUG_MISSION, "Spawning helicopter")
|
|
|
|
CREATE_ENEMY_WAVE(EW_MERC_HELI_GROUP, TRUE, TRUE)
|
|
|
|
REPLAY_RECORD_BACK_FOR_TIME(0.0, 10.0, REPLAY_IMPORTANCE_HIGHEST)
|
|
|
|
bAudioHelicopterArrives = TRUE
|
|
bSpawnedHelicopter = TRUE
|
|
ENDIF
|
|
ENDIF
|
|
ELSE
|
|
// if the heli is alive and the player hasnt switched to the top player
|
|
// then the bottom player should ask for help IF they are near the heli
|
|
// this got ridiculously complex
|
|
IF NOT IS_ANY_CONVERSATION_ONGOING_OR_QUEUED() AND NOT IS_MESSAGE_BEING_DISPLAYED()
|
|
IF IS_ENTITY_OK(enemyVehicle[EV_MERC_BATTLE_OUTSIDE_CHOPPER_1].veh) AND NOT IS_PED_INJURED(GET_PED_IN_VEHICLE_SEAT(enemyVehicle[EV_MERC_BATTLE_OUTSIDE_CHOPPER_1].veh, VS_DRIVER))
|
|
STRING sInPositionDialogue
|
|
IF selectorPedToTopExit = SELECTOR_PED_TREVOR
|
|
sInPositionDialogue = "FINC1_TO_POS"
|
|
ELSE
|
|
sInPositionDialogue = "FINC1_MO_POS"
|
|
ENDIF
|
|
|
|
// only play the "i'm up top" if he's actually up top
|
|
IF NOT bTopInPositionPlayed AND NOT bTopIsOutOfPosition
|
|
IF IS_ENTITY_OK(sSelectorPeds.pedID[selectorPedToTopExit])
|
|
IF GET_DISTANCE_BETWEEN_ENTITY_AND_COORD(enemyVehicle[EV_MERC_BATTLE_OUTSIDE_CHOPPER_1].veh, <<1094.49023, -2045.41223, 42.0>>, FALSE) < 15
|
|
IF GET_DISTANCE_BETWEEN_ENTITIES(enemyVehicle[EV_MERC_BATTLE_OUTSIDE_CHOPPER_1].veh, sSelectorPeds.pedID[selectorPedToTopExit]) < 50
|
|
bTopInPositionPlayed = CREATE_CONVERSATION(finaleConversation, "FINC1AU", sInPositionDialogue, CONV_PRIORITY_MEDIUM)
|
|
ELSE
|
|
bTopIsOutOfPosition = TRUE
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF GET_SELECTOR_SLOT_FROM_PLAYER_PED_ENUM(GET_CURRENT_PLAYER_PED_ENUM()) <> selectorPedToTopExit
|
|
IF bTopInPositionPlayed
|
|
IF GET_TIMER_IN_SECONDS_SAFE(tmrHelicopterDialogue) > 5 OR NOT IS_TIMER_STARTED(tmrHelicopterDialogue)
|
|
IF NOT IS_ANY_CONVERSATION_ONGOING_OR_QUEUED() AND NOT IS_MESSAGE_BEING_DISPLAYED()
|
|
IF IS_ENTITY_ON_SCREEN(enemyVehicle[EV_MERC_BATTLE_OUTSIDE_CHOPPER_1].veh)
|
|
IF GET_DISTANCE_BETWEEN_ENTITIES(PLAYER_PED_ID(), enemyVehicle[EV_MERC_BATTLE_OUTSIDE_CHOPPER_1].veh) < 50
|
|
OR IS_PLAYER_FREE_AIMING_AT_ENTITY(PLAYER_ID(), enemyVehicle[EV_MERC_BATTLE_OUTSIDE_CHOPPER_1].veh)
|
|
STRING sConvoName
|
|
IF GET_CURRENT_PLAYER_PED_ENUM() = CHAR_MICHAEL
|
|
sConvoName = "FINC1_MHELPI"
|
|
ELIF GET_CURRENT_PLAYER_PED_ENUM() = CHAR_TREVOR
|
|
sConvoName = "FINC1_THELPI"
|
|
ELSE
|
|
sConvoName = "FINC1_FHELPI"
|
|
ENDIF
|
|
START_TIMER_NOW_SAFE(tmrHelicopterDialogue)
|
|
CREATE_CONVERSATION(finaleConversation, "FINC1AU", sConvoName, CONV_PRIORITY_MEDIUM)
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
|
|
// toggle front fight invuln if the player is close //optimize
|
|
IF NOT HAS_TRIGGER_BOX_BEEN_TRIGGERED(tbBottomApproachFrontFight) AND bCreatedRoadMercs
|
|
IF IS_PLAYER_IN_TRIGGER_BOX(tbBottomApproachFrontFight) OR GET_CURRENT_PLAYER_PED_ENUM() = CHAR_FRANKLIN
|
|
TOGGLE_ENEMY_WAVE_ONLY_DAMAGED_BY_PLAYER(EW_FIB_ON_ROAD, FALSE)
|
|
TOGGLE_ENEMY_WAVE_ONLY_DAMAGED_BY_PLAYER(EW_FIB_REINF_LAMAR, FALSE)
|
|
ENDIF
|
|
ENDIF
|
|
ELSE
|
|
HANDLE_END_CUTSCENE()
|
|
|
|
IF NOT bDoneRegroupCue
|
|
bDoneRegroupCue = TRIGGER_MUSIC_EVENT("FIN1_SHOOTOUT_3")
|
|
ENDIF
|
|
|
|
IF freeHotswapData.state = FREE_HOTSWAP_STATE_SELECTING
|
|
// turn peds to face player
|
|
INT i
|
|
REPEAT 3 i
|
|
IF NOT IS_PED_INJURED(sSelectorPeds.pedID[i])
|
|
IF IS_ENTITY_AT_COORD(sSelectorPeds.pedID[i], GET_FINALE_VECTOR(FINVEC_REGROUP), <<5.5, 5.5, 2.5>>)
|
|
AND GET_SCRIPT_TASK_STATUS(sSelectorPeds.pedID[i], SCRIPT_TASK_FOLLOW_NAV_MESH_TO_COORD) = FINISHED_TASK
|
|
IF GET_GAME_TIMER() >= iNextTurnBuddyTime[i]
|
|
TASK_TURN_PED_TO_FACE_ENTITY(sSelectorPeds.pedID[i], PLAYER_PED_ID(), 3000)
|
|
iNextTurnBuddyTime[i] = GET_GAME_TIMER() + GET_RANDOM_INT_IN_RANGE(4000, 6000)
|
|
ENDIF
|
|
ELSE
|
|
iNextTurnBuddyTime[i] = GET_GAME_TIMER() + GET_RANDOM_INT_IN_RANGE(300, 1000)
|
|
ENDIF
|
|
ENDIF
|
|
ENDREPEAT
|
|
|
|
IF CAN_ADVANCE_MISSION()
|
|
IF IS_ENTITY_AT_COORD(PLAYER_PED_ID(), GET_FINALE_VECTOR(FINVEC_REGROUP), <<LOCATE_SIZE_ON_FOOT_ONLY,LOCATE_SIZE_ON_FOOT_ONLY,LOCATE_SIZE_HEIGHT>>, TRUE)
|
|
OR bForceEndCutsceneToRunWhenLoaded
|
|
IF bForceEndCutsceneToRunWhenLoaded
|
|
OR (NOT IS_PED_IN_ANY_VEHICLE(PLAYER_PED_ID()) AND GET_SCRIPT_TASK_STATUS(PLAYER_PED_ID(), SCRIPT_TASK_LEAVE_ANY_VEHICLE) <> PERFORMING_TASK)
|
|
bForceEndCutsceneToRunWhenLoaded = TRUE
|
|
IF HAS_CUTSCENE_LOADED_WITH_FAILSAFE()
|
|
bRunningCutscene = TRUE
|
|
ENDIF
|
|
ELSE
|
|
IF IS_PED_IN_ANY_VEHICLE(PLAYER_PED_ID())
|
|
IF BRING_VEHICLE_TO_HALT_AND_DISABLE_VEH_CONTROLS(GET_VEHICLE_PED_IS_IN(PLAYER_PED_ID()), 5.0, 4)
|
|
IF IS_ENTITY_OK(PLAYER_PED_ID()) AND GET_SCRIPT_TASK_STATUS(PLAYER_PED_ID(), SCRIPT_TASK_LEAVE_ANY_VEHICLE) <> PERFORMING_TASK
|
|
CPRINTLN(DEBUG_MISSION, "BSW forcing player out of vehicle")
|
|
TASK_LEAVE_ANY_VEHICLE(PLAYER_PED_ID())
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ELSE
|
|
IF NOT bRegroupDialogue
|
|
STRING sRegroupDialogue
|
|
IF GET_CURRENT_PLAYER_PED_ENUM() = CHAR_MICHAEL
|
|
sRegroupDialogue = "FINC1_GROUPF"
|
|
ELIF GET_CURRENT_PLAYER_PED_ENUM() = CHAR_TREVOR
|
|
sRegroupDialogue = "FINC1_GROUPM"
|
|
ELSE
|
|
sRegroupDialogue = "FINC1_GROUPT"
|
|
ENDIF
|
|
bRegroupDialogue = CREATE_CONVERSATION(finaleConversation, "FINC1AU", sRegroupDialogue, CONV_PRIORITY_MEDIUM)
|
|
ELSE
|
|
IF NOT bShownRegroupText AND NOT IS_ANY_CONVERSATION_ONGOING_OR_QUEUED()
|
|
bShownRegroupText = DO_MISSION_GOD_TEXT("FC1_GOOUT")
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF NOT DOES_BLIP_EXIST(gotoBlip)
|
|
gotoBlip = CREATE_MISSION_BLIP_FOR_COORD(GET_FINALE_VECTOR(FINVEC_REGROUP))
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ELSE
|
|
SET_MISSION_STAGE(STAGE_OUTRO_CUTSCENE)
|
|
ENDIF
|
|
ENDPROC
|
|
|
|
PROC DO_STAGE_OUTRO_CUTSCENE()
|
|
DO_REGROUP_CUTSCENE()
|
|
ENDPROC
|
|
|
|
PROC HANDLE_STATS()
|
|
// handle vehicle stats
|
|
BOOL bSetVehicleStatsNull = FALSE
|
|
IF IS_PED_IN_ANY_VEHICLE(PLAYER_PED_ID())
|
|
VEHICLE_INDEX currentVehicle = GET_VEHICLE_PED_IS_USING(PLAYER_PED_ID())
|
|
|
|
IF DOES_ENTITY_EXIST(currentVehicle)
|
|
INFORM_MISSION_STATS_OF_DAMAGE_WATCH_ENTITY(currentVehicle, FIN_CAR_DAMAGE)
|
|
INFORM_MISSION_STATS_OF_SPEED_WATCH_ENTITY(currentVehicle, FIN_MAX_SPEED)
|
|
ELSE
|
|
bSetVehicleStatsNull = TRUE
|
|
ENDIF
|
|
ELSE
|
|
bSetVehicleStatsNull = TRUE
|
|
ENDIF
|
|
|
|
IF bSetVehicleStatsNull
|
|
INFORM_MISSION_STATS_OF_DAMAGE_WATCH_ENTITY(NULL, FIN_CAR_DAMAGE)
|
|
INFORM_MISSION_STATS_OF_SPEED_WATCH_ENTITY(NULL, FIN_MAX_SPEED)
|
|
ENDIF
|
|
|
|
// damage stat
|
|
IF NOT IS_PED_INJURED(PLAYER_PED_ID())
|
|
INFORM_MISSION_STATS_OF_DAMAGE_WATCH_ENTITY(PLAYER_PED_ID(), FIN_DAMAGE)
|
|
ENDIF
|
|
ENDPROC
|
|
|
|
// debug only
|
|
#IF IS_DEBUG_BUILD
|
|
// create widgets
|
|
PROC CREATE_FINALE_WIDGETS()
|
|
finaleWidgets = START_WIDGET_GROUP("Finale 3")
|
|
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_FLOAT_SLIDER("Wheel rot", fWheelRotation, 0, 360, 1.0)
|
|
//ADD_WIDGET_FLOAT_SLIDER("Gondola Radius", fGondolaRadius, 0, 50, 1.0)
|
|
//ADD_WIDGET_VECTOR_SLIDER("Wheel pos", vWheelPos, -6000, 6000, 0.1)
|
|
STOP_WIDGET_GROUP()
|
|
ENDPROC
|
|
|
|
// setup the debug menu
|
|
PROC SETUP_FINALE_DEBUG_MENU()
|
|
stageMenu[0].sTxtLabel = "Cutscene FIN_C_INT"
|
|
stageMenu[0].bSelectable = FALSE
|
|
stageMenu[1].sTxtLabel = GET_DESCRIPTION_FOR_STAGE_AS_STRING(STAGE_GET_TO_FOUNDRY)
|
|
stageMenu[2].sTxtLabel = GET_DESCRIPTION_FOR_STAGE_AS_STRING(STAGE_MEET_GANG)
|
|
stageMenu[3].sTxtLabel = GET_DESCRIPTION_FOR_STAGE_AS_STRING(STAGE_SHOOTOUT_STAGE_1)
|
|
stageMenu[4].sTxtLabel = GET_DESCRIPTION_FOR_STAGE_AS_STRING(STAGE_SHOOTOUT_STAGE_2)
|
|
stageMenu[5].sTxtLabel = GET_DESCRIPTION_FOR_STAGE_AS_STRING(STAGE_SHOOTOUT_STAGE_3)
|
|
stageMenu[6].sTxtLabel = GET_DESCRIPTION_FOR_STAGE_AS_STRING(STAGE_SHOOTOUT_STAGE_4)
|
|
stageMenu[7].sTxtLabel = GET_DESCRIPTION_FOR_STAGE_AS_STRING(STAGE_OUTRO_CUTSCENE)
|
|
ENDPROC
|
|
|
|
// debug skips
|
|
PROC DO_DEBUG_SKIPS()
|
|
// mission pass S
|
|
IF IS_KEYBOARD_KEY_JUST_PRESSED(KEY_S)
|
|
bThoroughCleanup = TRUE
|
|
MISSION_PASSED()
|
|
ENDIF
|
|
|
|
// mission failed F
|
|
IF IS_KEYBOARD_KEY_JUST_PRESSED(KEY_F)
|
|
MISSION_FAILED(FAIL_LAMAR_DEAD)
|
|
ENDIF
|
|
|
|
// skip stage J
|
|
IF IS_KEYBOARD_KEY_JUST_PRESSED(KEY_J)
|
|
IF NOT bRunningCutscene
|
|
AND hotswapStage <> MISSION_HOTSWAP_STAGE_DO_SPLINE_CAM
|
|
IF NOT IS_PED_INJURED(PLAYER_PED_ID())
|
|
SET_PLAYER_CONTROL(PLAYER_ID(), TRUE)
|
|
|
|
SWITCH currentMissionStage
|
|
CASE STAGE_GET_TO_FOUNDRY
|
|
IF NOT IS_PED_IN_VEHICLE(PLAYER_PED_ID(), finaleVehicle[FV_MISSION_START_CAR])
|
|
SET_PED_INTO_VEHICLE(PLAYER_PED_ID(), finaleVehicle[FV_MISSION_START_CAR])
|
|
ELSE
|
|
IF NOT IS_PED_IN_VEHICLE(lamarPed, finaleVehicle[FV_MISSION_START_CAR])
|
|
SET_PED_INTO_VEHICLE(lamarPed, finaleVehicle[FV_MISSION_START_CAR], VS_FRONT_RIGHT)
|
|
ENDIF
|
|
|
|
SET_ENTITY_COORDS(finaleVehicle[FV_MISSION_START_CAR], <<1074.39, -1964.12, 30.01>>)
|
|
SET_ENTITY_HEADING(finaleVehicle[FV_MISSION_START_CAR], -127.01)
|
|
SET_VEHICLE_ON_GROUND_PROPERLY(finaleVehicle[FV_MISSION_START_CAR])
|
|
ENDIF
|
|
BREAK
|
|
CASE STAGE_MEET_GANG
|
|
SET_ENTITY_COORDS(PLAYER_PED_ID(), <<1115.47, -2003.97, 34.44>>)
|
|
BREAK
|
|
CASE STAGE_SHOOTOUT_STAGE_1
|
|
CASE STAGE_SHOOTOUT_STAGE_2
|
|
bShootoutStarted = TRUE
|
|
REMOVE_MISSION_TEXT()
|
|
IF NOT bKilledAll
|
|
bShootoutStarted = TRUE
|
|
KILL_ALL_ENEMIES()
|
|
ELSE
|
|
IF GET_CURRENT_PLAYER_PED_ENUM() <> CHAR_FRANKLIN
|
|
sSelectorPeds.eNewSelectorPed = SELECTOR_PED_FRANKLIN
|
|
bDebugJSkip = TRUE
|
|
ELSE
|
|
SET_ENTITY_COORDS(PLAYER_PED_ID(), GET_FINALE_VECTOR(FINVEC_FRANKLIN_READY))
|
|
SET_ENTITY_HEADING(PLAYER_PED_ID(), FRANKLIN_READY_ROT)
|
|
ENDIF
|
|
ENDIF
|
|
//ENDIF
|
|
BREAK
|
|
CASE STAGE_SHOOTOUT_STAGE_3
|
|
SET_ENTITY_COORDS(PLAYER_PED_ID(), <<1079.7, -2012.6, 43.48>>)
|
|
SET_ENTITY_HEADING(PLAYER_PED_ID(), -124.1)
|
|
BREAK
|
|
CASE STAGE_SHOOTOUT_STAGE_4
|
|
IF NOT bShownRegroupText
|
|
REMOVE_MISSION_TEXT()
|
|
KILL_ALL_ENEMIES()
|
|
ELSE
|
|
SET_ENTITY_COORDS(PLAYER_PED_ID(), GET_FINALE_VECTOR(FINVEC_REGROUP))
|
|
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
|
|
DO_SCREEN_FADE_OUT(500)
|
|
WHILE NOT IS_SCREEN_FADED_OUT()
|
|
WAIT(0)
|
|
ENDWHILE
|
|
|
|
COMMON_MISSION_CLEAR()
|
|
TRIGGER_MUSIC_EVENT("FIN1_FAIL")
|
|
|
|
SWITCH currentMissionStage
|
|
CASE STAGE_GET_TO_FOUNDRY
|
|
SET_MISSION_STAGE(STAGE_GET_TO_FOUNDRY, TRUE)
|
|
BREAK
|
|
CASE STAGE_MEET_GANG
|
|
SET_MISSION_STAGE(STAGE_GET_TO_FOUNDRY, TRUE)
|
|
BREAK
|
|
CASE STAGE_SHOOTOUT_STAGE_1
|
|
SET_MISSION_STAGE(STAGE_MEET_GANG, TRUE)
|
|
BREAK
|
|
CASE STAGE_SHOOTOUT_STAGE_2
|
|
SET_MISSION_STAGE(STAGE_SHOOTOUT_STAGE_1, TRUE)
|
|
BREAK
|
|
CASE STAGE_SHOOTOUT_STAGE_3
|
|
SET_MISSION_STAGE(STAGE_SHOOTOUT_STAGE_2, TRUE)
|
|
BREAK
|
|
CASE STAGE_SHOOTOUT_STAGE_4
|
|
SET_MISSION_STAGE(STAGE_SHOOTOUT_STAGE_3, TRUE)
|
|
BREAK
|
|
ENDSWITCH
|
|
|
|
IF NOT IS_PED_INJURED(PLAYER_PED_ID())
|
|
SET_ENTITY_PROOFS(PLAYER_PED_ID(), FALSE, FALSE, FALSE, FALSE, FALSE)
|
|
ENDIF
|
|
|
|
DO_SCREEN_FADE_IN(500)
|
|
ENDIF
|
|
ENDIF
|
|
|
|
// stage menu
|
|
IF NOT IS_PED_INJURED(PLAYER_PED_ID())
|
|
AND hotswapStage <> MISSION_HOTSWAP_STAGE_DO_SPLINE_CAM
|
|
AND NOT bRunningCutscene
|
|
IF LAUNCH_MISSION_STAGE_MENU(stageMenu, iMenuMissionStage)
|
|
DO_SCREEN_FADE_OUT(500)
|
|
WHILE NOT IS_SCREEN_FADED_OUT()
|
|
WAIT(0)
|
|
ENDWHILE
|
|
|
|
COMMON_MISSION_CLEAR()
|
|
|
|
TRIGGER_MUSIC_EVENT("FIN1_FAIL")
|
|
|
|
// convert debug stage to mission stage
|
|
MISSION_STAGE_ENUM setStage
|
|
SWITCH iMenuMissionStage
|
|
CASE 1
|
|
setStage = STAGE_GET_TO_FOUNDRY
|
|
BREAK
|
|
CASE 2
|
|
setStage = STAGE_MEET_GANG
|
|
BREAK
|
|
CASE 3
|
|
setStage = STAGE_SHOOTOUT_STAGE_1
|
|
BREAK
|
|
CASE 4
|
|
setStage = STAGE_SHOOTOUT_STAGE_2
|
|
BREAK
|
|
CASE 5
|
|
setStage = STAGE_SHOOTOUT_STAGE_3
|
|
BREAK
|
|
CASE 6
|
|
setStage = STAGE_SHOOTOUT_STAGE_4
|
|
BREAK
|
|
CASE 7
|
|
setStage = STAGE_OUTRO_CUTSCENE
|
|
BREAK
|
|
ENDSWITCH
|
|
|
|
SET_MISSION_STAGE(setStage, TRUE)
|
|
|
|
IF NOT IS_PED_INJURED(PLAYER_PED_ID())
|
|
SET_ENTITY_PROOFS(PLAYER_PED_ID(), FALSE, FALSE, FALSE, FALSE, FALSE)
|
|
ENDIF
|
|
|
|
// special case because don't fade in before the cutscene starts!
|
|
IF setStage <> STAGE_OUTRO_CUTSCENE
|
|
DO_SCREEN_FADE_IN(500)
|
|
ENDIF
|
|
ENDIF
|
|
ENDIF
|
|
ENDPROC
|
|
|
|
// there must be an easier way to do this
|
|
PROC FORMAT_FLOAT_FOR_RB_CAM_DUMP(FLOAT fInputFloat, INT &iBeforeDec, INT &iAfterDec)
|
|
IF fInputFloat >= 0
|
|
iBeforeDec = FLOOR(fInputFloat)
|
|
ELSE
|
|
iBeforeDec = CEIL(fInputFloat)
|
|
ENDIF
|
|
|
|
fInputFloat -= iBeforeDec
|
|
fInputFloat *= 100
|
|
IF fInputFloat < 0
|
|
fInputFloat *= (-1)
|
|
ENDIF
|
|
IF fInputFloat < 10
|
|
fInputFloat *= 10
|
|
ENDIF
|
|
|
|
iAfterDec = FLOOR(fInputFloat)
|
|
ENDPROC
|
|
|
|
// dump the cam coords to a widget
|
|
PROC DO_RB_DEBUG_CAM_DUMP()
|
|
IF bRBDebugCamDoDump
|
|
CAMERA_INDEX tempCam = GET_DEBUG_CAM()
|
|
|
|
vRBDebugCamPos = GET_CAM_COORD(tempCam)
|
|
vRBDebugCamRot = GET_CAM_ROT(tempCam)
|
|
fRBDebugCamFOV = GET_CAM_FOV(tempCam)
|
|
|
|
TEXT_LABEL_63 tPos
|
|
TEXT_LABEL_63 tRot
|
|
INT iBefore, iAfter
|
|
|
|
// fill position
|
|
tPos = "<<"
|
|
FORMAT_FLOAT_FOR_RB_CAM_DUMP(vRBDebugCamPos.x, iBefore, iAfter)
|
|
tPos += iBefore
|
|
tPos += "."
|
|
tPos += iAfter
|
|
tPos += ", "
|
|
FORMAT_FLOAT_FOR_RB_CAM_DUMP(vRBDebugCamPos.y, iBefore, iAfter)
|
|
tPos += iBefore
|
|
tPos += "."
|
|
tPos += iAfter
|
|
tPos += ", "
|
|
FORMAT_FLOAT_FOR_RB_CAM_DUMP(vRBDebugCamPos.z, iBefore, iAfter)
|
|
tPos += iBefore
|
|
tPos += "."
|
|
tPos += iAfter
|
|
tPos += ">>"
|
|
|
|
// fill rotation
|
|
tRot = "<<"
|
|
FORMAT_FLOAT_FOR_RB_CAM_DUMP(vRBDebugCamRot.x, iBefore, iAfter)
|
|
tRot += iBefore
|
|
tRot += "."
|
|
tRot += iAfter
|
|
tRot += ", "
|
|
FORMAT_FLOAT_FOR_RB_CAM_DUMP(vRBDebugCamRot.y, iBefore, iAfter)
|
|
tRot += iBefore
|
|
tRot += "."
|
|
tRot += iAfter
|
|
tRot += ", "
|
|
FORMAT_FLOAT_FOR_RB_CAM_DUMP(vRBDebugCamRot.z, iBefore, iAfter)
|
|
tRot += iBefore
|
|
tRot += "."
|
|
tRot += iAfter
|
|
tRot += ">>"
|
|
|
|
// set widgets
|
|
SET_CONTENTS_OF_TEXT_WIDGET(RBCamPosWidget, tPos)
|
|
SET_CONTENTS_OF_TEXT_WIDGET(RBCamRotWidget, tRot)
|
|
|
|
bRBDebugCamDoDump = FALSE
|
|
ENDIF
|
|
ENDPROC
|
|
#ENDIF
|
|
|
|
// main script
|
|
SCRIPT
|
|
SET_MISSION_FLAG(TRUE)
|
|
IF HAS_FORCE_CLEANUP_OCCURRED()
|
|
Mission_Flow_Mission_Force_Cleanup()
|
|
MISSION_CLEANUP()
|
|
ENDIF
|
|
|
|
#IF IS_DEBUG_BUILD
|
|
CREATE_FINALE_WIDGETS()
|
|
SETUP_FINALE_DEBUG_MENU()
|
|
#ENDIF
|
|
|
|
taskStatus = taskStatus
|
|
|
|
//INFORM_MISSION_STATS_OF_MISSION_START_FINALE_3()
|
|
|
|
CPRINTLN(DEBUG_MISSION, "BSW Finale C1 script launch")
|
|
|
|
WHILE TRUE
|
|
REPLAY_CHECK_FOR_EVENT_THIS_FRAME(GET_RECORD_PREFIX())
|
|
|
|
IF INIT_MISSION()
|
|
IF NOT IS_PED_INJURED(PLAYER_PED_ID())
|
|
// do streaming for next stage
|
|
DO_STREAMING_FOR_NEXT_MISSION_STAGE(FALSE)
|
|
|
|
// do fail checks
|
|
HANDLE_MISSION_FAIL_STATE()
|
|
|
|
// handle inside foundry stuff
|
|
HANDLE_INSIDE_FOUNDRY()
|
|
|
|
HANDLE_STATS()
|
|
|
|
HANDLE_AUDIO_SCENES()
|
|
|
|
// run appropriate stage
|
|
SWITCH currentMissionStage
|
|
CASE STAGE_GET_TO_FOUNDRY
|
|
DO_STAGE_TRAVEL()
|
|
BREAK
|
|
CASE STAGE_MEET_GANG
|
|
DO_STAGE_MEET_GANG()
|
|
BREAK
|
|
CASE STAGE_SHOOTOUT_STAGE_1
|
|
DO_STAGE_SHOOTOUT_STAGE_1()
|
|
BREAK
|
|
CASE STAGE_SHOOTOUT_STAGE_2
|
|
DO_STAGE_SHOOTOUT_STAGE_2()
|
|
BREAK
|
|
CASE STAGE_SHOOTOUT_STAGE_3
|
|
DO_STAGE_SHOOTOUT_STAGE_3()
|
|
BREAK
|
|
CASE STAGE_SHOOTOUT_STAGE_4
|
|
DO_STAGE_SHOOTOUT_STAGE_4()
|
|
BREAK
|
|
CASE STAGE_OUTRO_CUTSCENE
|
|
DO_STAGE_OUTRO_CUTSCENE()
|
|
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
|