// ***************************************************************************************** // ***************************************************************************************** // // FILE NAME : rampageV4_include.sch // AUTHOR : Aaron Gandaa // DESCRIPTION : Shared Structs and Functions For Rampages // NOTES : Starting to split rampage stuff up - but keeping old stuff // // ***************************************************************************************** // ***************************************************************************************** //CONST_INT IS_JAPANESE_BUILD 1 /// NEVER COMMENT THIS IN - THIS IS SO I CAN TEST FIX FOR B*2163318 //---------------------- // INCLUDES //---------------------- USING "globals.sch" USING "rgeneral_include.sch" USING "RC_Helper_Functions.sch" USING "RC_Leadin_public.sch" USING "completionpercentage_public.sch" USING "randomChar_private.sch" USING "shop_public.sch" USING "mission_control_public.sch" USING "flow_public_core_override.sch" USING "stats_public.sch" USING "event_public.sch" USING "cutscene_public.sch" USING "player_ped_public.sch" USING "mission_stat_public.sch" USING "shared_hud_displays.sch" USING "finance_control_public.sch" USING "initial_scenes_rampage.sch" USING "achievement_public.sch" USING "area_checks.sch" USING "fake_cellphone_public.sch" USING "cheat_controller_public.sch" #IF IS_DEBUG_BUILD USING "select_mission_stage.sch" USING "shared_debug.sch" #ENDIF //---------------------- // ENUMS //---------------------- ENUM eRampageSpawnState ERS_SPAWNING_ON, // spawning is allowed until maxActivePeds = MAX_ACTIVE_PEDS ERS_SPAWNING_LIMIT_BREAK, // maxActivePeds = MAX_ACTIVE_PEDS. Set Timer and got into ERS_SPAWNING_WAIT ERS_SPAWNING_WAIT // spawning is paused while maxActivePeds < spawnlimit ENDENUM ENUM RAMPAGECAR_MODE RCM_RAM, RCM_DRIVEBY, RCM_DEPLOY, RCM_DEPLOY_ALL, RCM_DEPLOY_COORDS, RCM_TANK ENDENUM ENUM RAMPAGECAR_MODESTATE RCMS_STARTDRIVE, RCMS_DRIVING, RCMS_DEPLOY, RCMS_DRIVEOFF ENDENUM ENUM eRAMPAGE_CHALLENGE CHALLENGE_NONE, CHALLENGE_OVERKILL, CHALLENGE_HEADSHOT, CHALLENGE_KILLSTREAK, CHALLENGE_VEHICLES, CHALLENGE_OCCUPANT, CHALLENGE_CHOPPER, CHALLENGE_EXECUTION, CHALLENGE_LONGSHOT, CHALLENGE_TANK ENDENUM ENUM SFORMRAMPAGE_STATE SFR_LEADIN, SFR_MOCAP, SFR_INTROSTART, SFR_INTRODONE, SFR_RAMPAGEON, SFR_OUTROSTART, SFR_OUTROWAIT, SFR_OUTRODONE_FAIL, SFR_OUTRO_ANIM_OUT, SFR_OUTRODONE ENDENUM ENUM TANK_STATE TANK_INIT, TANK_DRIVE_TO_PLAYER, TANK_FIRE_MISS_SHOT, TANK_CHECK_FOR_SHOT, TANK_WAIT_BETWEEN_SHOTS, TANK_PREP_FOR_NEXT_SHOT, TANK_FIRE_HIT_SHOT, TANK_IDLE ENDENUM //---------------------- // STRUCTS //---------------------- STRUCT RAMPAGE_AREA BOOL bIsActive = FALSE VECTOR vPosition[2] FLOAT fWidth // these are calculated in setup and are used for point generation VECTOR vForward VECTOR vRight FLOAT fLength FLOAT fHeight // debug stuff so we can alter these in RAG in real time #IF IS_DEBUG_BUILD BOOL bRecalculate BOOL bShowDebug #ENDIF ENDSTRUCT STRUCT RAMPAGE_FORTRESS BOOL bIsActive = FALSE RAMPAGE_AREA spawnArea // this is the area where we pick are spawn points RAMPAGE_AREA defenseArea // this is the defensive area - generally bigger than the spawn area FLOAT fRoofHeight = 0.0 // any positions above this height are taken as roofs INT iPedCount = 0 // the number of peds who are tied to this fortress INT iSpawnedCount = 0 // the number of peds spawned from this fortress INT iMaxSpawnCount = -1 // the maximum number of peds to spawn until we shut down fortress [-1 for infinite spawning] FLOAT fRoofFactor = 0.0 // chance of allowing roof peds - [0 - none, 1 - all] FLOAT fRushFactor = 0.0 // chance of peds abandoning defensive area and using player defensive area - [0 - none, 1 - all] INT iMaxActivePeds = -1 // this override the maximum amount of peds while this fortress is active [-1 - don't override] INT iMaxActiveCars = -1 // this override the maximum amount of cars allowed while fortress is open INT iNextFortress = -1 // when this fortress closes open the next one [-1 = don't open another fortress] // debug stuff so we can alter these in RAG in real time #IF IS_DEBUG_BUILD BOOL bRecalculate VECTOR vLastSpawnPoint VECTOR vTestSpawnPoint BOOL bGenerateTestSpawnPoint BOOL bShowDebug BOOL bShowDebugTestSpawnPoint #ENDIF ENDSTRUCT STRUCT RAMPAGE_INFO STATIC_BLIP_NAME_ENUM blipNameEnum INT iRampageIndex STRING sTargetName STRING sDialogBlockName STRING sDialogRootLabel STRING sUIName STRING sScenarioGroupName VECTOR vScenarioBlockCenter FLOAT fScenarioBlockRadius STRING sIntroAnim STRING sOutroAnim STRING sOutroRunAnim FLOAT fOutroPhase FLOAT fOutroRunPhase INT iTimeLimit = 180000 WEAPON_TYPE plyrWeapon[3] WEAPON_TYPE enemyWeapon[2] WEAPONCOMPONENT_TYPE plyrWeaponComp[2] MODEL_NAMES pedModels[4] MODEL_NAMES carModels[3] MODEL_NAMES explosiveModel INT iMaxPedModels = 0 INT iMaxCarModels = 0 VECTOR vPlyrCarHidePos FLOAT fPlyrCarHideHeading = 0.0 VECTOR vPlyrStartPos FLOAT fPlyrStartHeading = 0.0 FLOAT fAmbientPedDensity = 0.0 FLOAT fAmbientCarDensity = 0.0 //Chance that a car will be tasked to ram the player before deploying its passengers FLOAT fCarRamChance = 0.0 BOOL bPassed = FALSE BOOL bAllowInnocents = FALSE BOOL bExplosiveProps = FALSE INT iTargetAmount INT iRandomSeed = 0 // so i can repeat the randomness of the rampage if necessary ENDSTRUCT STRUCT RAMPAGE_CAR VEHICLE_INDEX carID BOOL bKeepAsCover = FALSE // if this is set on cleanup if the car is okay it will add it to the list of cover cars INT iOccupantIndex[6] FLOAT fDistToPlayer FLOAT fOriginalDist RAMPAGECAR_MODE rcMode INT iTaskState = 0 INT iIndex = 0 VECTOR vDestination // if this is zero we assume we're going to player FLOAT fCruiseSpeed FLOAT fTargetReachDist INT iTimer #IF IS_DEBUG_BUILD BOOL bDebugAliveCheck = FALSE #ENDIF ENDSTRUCT STRUCT RAMPAGE_TANK PED_INDEX pedID BLIP_INDEX blipID VEHICLE_INDEX vehicleID FLOAT fPlayerDist = 0.0 FLOAT fOriginalDist = 0.0 INT iShotTimer = 0 TANK_STATE eTankState VECTOR vTargetPos ENDSTRUCT STRUCT RAMPAGE_PED PED_INDEX pedID BLIP_INDEX blipID BOOL bWasInVehicle = FALSE BOOL bIsFleePed = FALSE BOOL bMolotovThrower = FALSE FLOAT fPlayerDist = 0.0 FLOAT fOriginalDist = 0.0 INT iFortIndex = -1 INT iDeleteTime INT iIndex = 0 STRING sVoice = NULL STRING sContext = NULL INT iInsultTimer = 0 #IF IS_DEBUG_BUILD BOOL bDebugAliveCheck = FALSE #ENDIF ENDSTRUCT STRUCT RAMPAGE_EXPLOSIVE_PROP OBJECT_INDEX objID VECTOR pos VECTOR rot BOOL bCreated ENDSTRUCT STRUCT RAMPAGE_STATS INT iPedDeadCount = 0 INT iHeadShots = 0 INT iInnocentsDead = 0 INT iCrippleCount = 0 INT iCloseRange = 0 INT iLongRange = 0 INT iCarDeadCount = 0 INT iCarAbandonCount = 0 INT iCarOccupantKills = 0 INT iChopperDeadCount = 0 INT iTanksDestroyed = 0 INT iLastKillTime = 0 INT iPedsSpawned = 0 INT iStartTime INT iEndTime INT iPredictedEndTime INT iChain INT iMaxChain INT iInitialAccuracyHits INT iInitialAccuracyShots ENDSTRUCT STRUCT RAMPAGE_SPAWNPOINT BOOL bIsActive = FALSE BOOL bIsAerial = FALSE VECTOR vPosition FLOAT fHeading = 0.0 ENDSTRUCT STRUCT RAMPAGE_ALLEYSPAWNER BOOL bIsActive = FALSE INT iFrameCounter = 0 INT iMinSpawnTime = 1000 INT iMaxSpawnTime = 3000 INT iNextSpawnTime VECTOR vAlleyPoints[2] FLOAT fAlleyRadius = 0.0 FLOAT fAlleyDiffAdjust = -0.1 FLOAT fPlayerAlleyUValue = 0.0 RAMPAGE_SPAWNPOINT spawnPoint[33] INT iMaxActiveSpawnPoints = 0 #IF IS_DEBUG_BUILD BOOL bShowDebug #ENDIF ENDSTRUCT STRUCT RAMPAGE_CARSPAWNER BOOL bIsActive = FALSE INT iMinSpawnTime = 10000 INT iMaxSpawnTime = 20000 INT iNextSpawnTime INT iMinActiveCars = 0 INT iMaxActiveCars = 1 BOOL bUseSpawnPoints = FALSE RAMPAGE_SPAWNPOINT vSpawnPoints[4] INT iSpawnPointsUsed = 0 FLOAT fMinSpawnRadius = 60.0 FLOAT fMaxSpawnRadius = 120.0 INT iFrameCounter = 1 #IF IS_DEBUG_BUILD BOOL bShowSpawnPoints #ENDIF ENDSTRUCT STRUCT RAMPAGE_CLOUDSPAWNER BOOL bIsActive = FALSE INT iFrameCounter = 2 BOOL bPavementOnly = TRUE INT iMinSpawnTime = 250 INT iMaxSpawnTime = 1000 INT iNextSpawnTime FLOAT fMinSpawnRadius = 20.0 FLOAT fMaxSpawnRadius = 60.0 FLOAT fFleeChance = 0.9 #IF IS_DEBUG_BUILD BOOL bShowSpawnRadius #ENDIF ENDSTRUCT STRUCT RAMPAGE_FORTSPAWNER BOOL bIsActive = FALSE FLOAT fMinSpawnRadius = 12.5 INT iMinSpawnTime = 1000 INT iMaxSpawnTime = 3000 INT iNextSpawnTime INT iMaxActiveFortress = 0 INT iFrameCounter = 3 INT iFortressFrameCounter = 0 FLOAT fFortressAllowRange = 100.0 // if peds are more than this meters away from a fortress they won't spawn ENDSTRUCT STRUCT RAMPAGE_CHALLENGE eRAMPAGE_CHALLENGE cType INT iRequiredAmount STRING sTxtKey ENDSTRUCT //---------------------- // CONSTANTS //---------------------- CONST_INT RAMPAGE_VERSION 032 CONST_INT RAMPAGE_PED_MAXHP 120 CONST_INT RAMPAGE_PED_MONEY 0 CONST_INT CHAIN_TIMER 3500 CONST_FLOAT CLOSE_KILL_RANGE 2.0 CONST_FLOAT LONG_KILL_RANGE 50.0 CONST_FLOAT PLAYER_IN_RAGDOLL_AIM 0.01 //Accuracy of peds while player in ragdoll CONST_FLOAT TANK_ALIVE_AIM 0.05 //Accuracy of peds while tank is alive CONST_FLOAT RAMPAGE_SF_HANGTIME 1.25 // How long the rampage sf sticks about after it has started CONST_INT MAX_SKIP_MENU_LENGTH 3 CONST_INT DELAY_INITIAL_PEDS_TIME 3000 CONST_INT MAX_ACTIVE_PEDS 10 //Reducing max active peds for 1320970 CONST_INT MAX_EXPLOSIVE_PROPS 10 CONST_INT FINAL_TIME_BONUS 100 // 100 pts per tenth of a second CONST_INT FINAL_CAR_KILL_BONUS 500 CONST_INT FINAL_CHAIN_BONUS 10000 CONST_INT FINAL_HEADSHOT_BONUS 5000 // 10000 per headshot CONST_INT FINAL_KILLS_BONUS 1000 // 1000 pts per kill CONST_INT FINAL_CLOSE_RANGE_BONUS 1250 // CONST_INT FINAL_LONG_RANGE_BONUS 2500 // CONST_INT FINAL_INNOCENT_BONUS 750 // lose 500 pts for killing innocents CONST_FLOAT PED_CLEANUP_DISTANCE 100.0 CONST_FLOAT CAR_CLEANUP_DISTANCE 140.0 CONST_FLOAT NO_PED_CHECK_RADIUS 1.5 // if there is a ped within this distance the spawner will fail CONST_INT SEAT_ADD_PLUS 0 CONST_INT PEDS_TO_SCAN_PER_FRAME 2 //---------------------- // VARIABLES //---------------------- g_eRC_MissionIDs rcRampageMissionID g_structRCScriptArgs rampageScriptArgs RAMPAGE_STATS rampageStats RAMPAGE_INFO rampageInfo RAMPAGE_CHALLENGE rampageChallenge[3] INT iCompletedChallenges = 0 INT iRampagePedScannerIndex = 0 #IF USE_TU_CHANGES INT iOldCheatStateVariable = 0 #ENDIF COMBAT_PARAMETERS rampageCombatParams END_SCREEN_DATASET esd OBJECT_INDEX plyrGunObject INT iFrameCounter RAMPAGE_MEDAL iCurrentMedalIndex REL_GROUP_HASH activeGroup REL_GROUP_HASH activePassiveGroup SCENARIO_BLOCKING_INDEX scenarioBlockID SCENARIO_BLOCKING_INDEX worldScenarioBlockID RAMPAGE_EXPLOSIVE_PROP explosiveObject[MAX_EXPLOSIVE_PROPS] STAGE_PROGRESS stageProgress INT i_sound_countdown = GET_SOUND_ID() BOOL bTimerSoundStarted = FALSE BOOL bRunOutro = FALSE BOOL bBloodDamage = FALSE BOOL bDoPedSpawnBehindCheck = FALSE BOOL bUseIsAreaOccupied = FALSE BOOL bInfiniteTime = FALSE FLOAT fHPRegenMult = 1.5 FLOAT fCarDefenseAreaChance = 0.5 // chance of rampaging peds using small defense area around vehicle FLOAT fEnemySecondWeaponChance = 0.5 // chance of enemies being given second weapon FLOAT fPissTakeRocketChance = 0.1 // chance that enemies will use rockets if the player is a dick and decides to piss about in a air vehicle RAMPAGE_AREA noSpawnArea[6] INT iMaxActiveNoSpawnAreas = 0 RAMPAGE_PED rampagePed[MAX_ACTIVE_PEDS] RAMPAGE_CAR rampageCar[5] RAMPAGE_TANK rampageTank VEHICLE_INDEX coverCar[7] INT iAliveCoverCarCounter = 0 INT iCurrentRampagePedIndex = 0 INT iAlivePedCounter = 0 INT iAliveCarCounter = 0 INT iMaxActivePeds = COUNT_OF(rampagePed) INT iMolotovRespawnTimer = 0 INT iInitialSpawnDelay = 0 INT iInitialCarSpawnDelay = 0 //Tank variables FLOAT flWidgetArcOfSafety = 30.0 FLOAT flMinCannonShotDistance = 8.0 FLOAT flMaxCannonShotDistance = 10.0 FLOAT flMinimumSafeAngle FLOAT flMaximumSafeAngle FLOAT flTankShotAngle RAMPAGE_FORTRESS rampageFort[8] RAMPAGE_ALLEYSPAWNER rampageAlleySpawner RAMPAGE_CARSPAWNER rampageCarSpawner RAMPAGE_CLOUDSPAWNER rampageCloudSpawner RAMPAGE_CLOUDSPAWNER rampageBackupCloudSpawner RAMPAGE_FORTSPAWNER rampageFortressSpawner BOOL bShowNotifications = FALSE INT iTimeLineEventIndex = 0 BOOL bDisplayedSpecialHelp = FALSE VECTOR vBattleCenter FLOAT fBattleRadius = 200.0 BLIP_INDEX battleBlip BOOL bInBattleArea = TRUE INT iGameTimer = 0 INT iWaitTime = 0 STRING sAudioScene = NULL ANGLED_AREA respotVehicleArea BOOL bTankDiag = FALSE INT iNextBeepTime = 10000 // 10 seconds BOOL bRampage3WeaponBodge = FALSE //---------------------- // SCALEFORM VARIABLES //---------------------- SCALEFORM_INDEX sFormRampage = NULL SCALEFORM_INDEX sFormRampageStats = NULL SCALEFORM_INDEX sFormRampagePassMsg = NULL SFORMRAMPAGE_STATE sFormState = SFR_MOCAP STAGE_PROGRESS sFailState HUD_COLOURS medalHudColor[4] // 0 = no medal, 1 - bronze, 2 - silver, 3 - gold. INT sFormAlpha = 255 // alpha color for the scaleform video INT isFormTimer BOOL bShowZeroScores = FALSE LEADIN_HANDLER rampageLeadIn //---------------------- // MISC VARIABLES //---------------------- STRING sVoiceContext STRING sPlayerSceneHandle // for cutscene screen handles STRING sWeaponSceneHandle // for cutscene screen handles STRING sSceneHandles[8] // for cutscene screen handles STRING sMaleVoiceNames[5] STRING sFemaleVoiceNames[5] BOOL bPlayerExitStateSet = FALSE BOOL bCutsceneCanBeSkipped = FALSE INT iNextBattleRantTime INT iLastUsedMaleVoiceNameIndex = 0 INT iLastUsedFemaleVoiceNameIndex = 0 INT iLastUsedRampage2VoiceIndex = 0 BOOL bBlockRampageTempEvents = TRUE structPedsForConversation convoBattleRant eRampageSpawnState rampageSpawnState = ERS_SPAWNING_ON INT iRampageSpawnBlockLimit = MAX_ACTIVE_PEDS / 2 INT iMinRampageSpawnBlockTime = 4000 INT iMaxRampageSpawnBlockTime = 8000 INT iRampageSpawnStateTimer = 0 BOOL bBlockRampageSpawning = TRUE INT iNextRampageSpawnTime = 0 INT iMinRampagePedSpawnTime = 750 INT iMaxRampagePedSpawnTime = 1500 BOOL bUseGlobalPedSpawnTimer = TRUE //INT iNextClockTickSoundTime INT iRampageMusicStartTime // this is relative to the cutscene time BOOL bRampageMusicStarted = FALSE VECTOR vFinalCamCoord VECTOR vFinalCamRot BOOL bHackInterpolate = FALSE BOOL bCutsceneIsPlaying = FALSE BOOL bRampageShardAnimated //---------------------- // DEBUG VARIABLES //---------------------- #IF IS_DEBUG_BUILD MissionStageMenuTextStruct sSkipMenu[MAX_SKIP_MENU_LENGTH] WIDGET_GROUP_ID m_RampWidgetGroup BOOL bDebugShowMissionVersion = FALSE BOOL bDebugShowTTY = FALSE BOOL bCreateTestVehicle = FALSE BOOL bCreateTestTank = FALSE INT iTestVehicleSpawnPointIndex = 0 BOOL bPauseRampageSpawning = FALSE BOOL bDebugDeletePedsForJapan = FALSE BOOL bDeletePedsAndCars = FALSE BOOL bDeletePeds = FALSE BOOL bDeleteCars = FALSE BOOL bCleanupPedsAndCars = FALSE BOOL bCleanupPeds = FALSE BOOL bCleanupCars = FALSE BOOL bInstantPass = FALSE BOOL bInstantFail = FALSE INT iInstaPassMedal = 0 BOOL bInstaPassChallenges = FALSE BOOL bSetPlayerPosAsCheckPoint BOOL bCheckSpawnPosition VECTOR vCheckSpawnPoint BOOL bIsPointOkay BOOL bShowScenarioBlockArea INT iRampageSpawnStateDebug VECTOR vDebugDrawSpot BOOL bDebugDrawSpot #ENDIF //---------------------- // DEBUG FUNCTIONS //---------------------- #IF IS_DEBUG_BUILD /// PURPOSE: /// Setups a rampage area widget /// PARAMS: /// area - area reference /// nme - widget display name /// idx - number to append to display name PROC SETUP_RAMPAGE_AREA_WIDGETS(RAMPAGE_AREA &area, STRING nme, INT idx = -1) TEXT_LABEL sLabel = nme IF (idx >= 0) sLabel += idx ENDIF START_WIDGET_GROUP(sLabel) ADD_WIDGET_BOOL("Is Active", area.bIsActive) ADD_WIDGET_BOOL("Show Debug", area.bShowDebug) ADD_WIDGET_VECTOR_SLIDER("Point 1", area.vPosition[0], -5000.0, 5000.0, 10.0) ADD_WIDGET_VECTOR_SLIDER("Point 2", area.vPosition[1], -5000.0, 5000.0, 10.0) ADD_WIDGET_FLOAT_SLIDER("Width", area.fWidth, 0.0, 200.0, 0.1) ADD_WIDGET_BOOL("Recalculate", area.bRecalculate) STOP_WIDGET_GROUP() ENDPROC /// PURPOSE: /// Setups a rampage fortress widget /// PARAMS: /// fort - fort reference /// nme - widget display name /// idx - number to append to display name PROC SETUP_RAMPAGE_FORTRESS_WIDGETS(RAMPAGE_FORTRESS &fort, STRING nme, INT idx) TEXT_LABEL sLabel = nme sLabel += idx START_WIDGET_GROUP(sLabel) ADD_WIDGET_BOOL("Is Active", fort.bIsActive) ADD_WIDGET_BOOL("Show Debug", fort.bShowDebug) ADD_WIDGET_BOOL("Calc Debug Spawn Point", fort.bGenerateTestSpawnPoint) ADD_WIDGET_BOOL("Show Debug Spawn Point", fort.bShowDebugTestSpawnPoint) SETUP_RAMPAGE_AREA_WIDGETS(fort.spawnArea, "Spawn Area") SETUP_RAMPAGE_AREA_WIDGETS(fort.spawnArea, "Defense Area") START_WIDGET_GROUP("Ped Spawning") ADD_WIDGET_FLOAT_SLIDER("Rush Factor", fort.fRushFactor, 0.0, 100.0, 0.1) ADD_WIDGET_INT_SLIDER("Max Active Peds", fort.iMaxActivePeds, -1, COUNT_OF(rampagePed), 1) ADD_WIDGET_INT_SLIDER("Max Active Cars", fort.iMaxActiveCars, -1, COUNT_OF(rampageCar), 1) ADD_WIDGET_INT_SLIDER("Max Spawn Count", fort.iMaxSpawnCount, -1, 99, 1) STOP_WIDGET_GROUP() START_WIDGET_GROUP("Roof Values") ADD_WIDGET_FLOAT_SLIDER("Roof Height", fort.fRoofHeight, 0.0, 100.0, 0.1) ADD_WIDGET_FLOAT_SLIDER("Roof Factor", fort.fRoofFactor, 0.0, 100.0, 0.1) STOP_WIDGET_GROUP() START_WIDGET_GROUP("Read Only") ADD_WIDGET_INT_READ_ONLY("Active Peds", fort.iPedCount) ADD_WIDGET_INT_READ_ONLY("Peds Spawned", fort.iSpawnedCount) ADD_WIDGET_INT_READ_ONLY("Max Spawn Count", fort.iMaxSpawnCount) STOP_WIDGET_GROUP() ADD_WIDGET_BOOL("Recalculate", fort.bRecalculate) STOP_WIDGET_GROUP() ENDPROC /// PURPOSE: /// Creates a rampage spawnpoint widget /// PARAMS: /// sp - spawn point reference /// nme - widget display name /// idx - number to append to display name PROC SETUP_SPAWNPOINT_WIDGETS(RAMPAGE_SPAWNPOINT &sp, STRING nme, INT idx) TEXT_LABEL sLabel = nme sLabel += idx START_WIDGET_GROUP(sLabel) ADD_WIDGET_BOOL("Is Active", sp.bIsActive) ADD_WIDGET_BOOL("Is Aerial", sp.bIsAerial) ADD_WIDGET_VECTOR_SLIDER("Position", sp.vPosition, -5000.0, 5000.0, 10.0) ADD_WIDGET_FLOAT_SLIDER("Heading", sp.fHeading, 0.0, 360.0, 0.1) STOP_WIDGET_GROUP() ENDPROC /// PURPOSE: /// Creates a rampage spawnpoint widget /// PARAMS: /// sp - spawner point PROC SETUP_RAMPAGE_ALLEY_SPAWNER_DEBUG_WIDGET(RAMPAGE_ALLEYSPAWNER &csp) START_WIDGET_GROUP("Rampage Alley Spawner") ADD_WIDGET_BOOL("Is Active", csp.bIsActive) ADD_WIDGET_BOOL("Show Debug", csp.bShowDebug) ADD_WIDGET_VECTOR_SLIDER("Position 1", csp.vAlleyPoints[0], -5000.0, 5000.0, 10.0) ADD_WIDGET_VECTOR_SLIDER("Position 2", csp.vAlleyPoints[1], -5000.0, 5000.0, 10.0) ADD_WIDGET_FLOAT_SLIDER("Radius", csp.fAlleyRadius, 0.0, 150.0, 0.5) ADD_WIDGET_FLOAT_SLIDER("U Difference", csp.fAlleyDiffAdjust, -1.0, 1.0, 0.0125) ADD_WIDGET_FLOAT_READ_ONLY("Player UValue", csp.fPlayerAlleyUValue) STOP_WIDGET_GROUP() ENDPROC /// PURPOSE: /// Creates a rampage spawnpoint widget /// PARAMS: /// sp - spawn point reference /// nme - widget display name /// idx - number to append to display name PROC SETUP_RAMPAGE_CAR_SPAWNER_DEBUG_WIDGET(RAMPAGE_CARSPAWNER &csp) INT i START_WIDGET_GROUP("Rampage Car Spawner") ADD_WIDGET_BOOL("Is Active", csp.bIsActive) ADD_WIDGET_BOOL("Show Spawn Points", csp.bShowSpawnPoints) ADD_WIDGET_INT_SLIDER("Min Active Cars", csp.iMinActiveCars, 0, COUNT_OF(rampageCar), 1) ADD_WIDGET_INT_SLIDER("Max Active Cars", csp.iMaxActiveCars, 0, COUNT_OF(rampageCar), 1) START_WIDGET_GROUP("Spawning") ADD_WIDGET_BOOL("Use Spawn Points", csp.bUseSpawnPoints) ADD_WIDGET_INT_SLIDER("Spawn Points Used", csp.iSpawnPointsUsed, 0, COUNT_OF(csp.vSpawnPoints), 1) ADD_WIDGET_FLOAT_SLIDER("Min Spawn Radius", csp.fMinSpawnRadius, 0.0, 800.0, 0.5) ADD_WIDGET_FLOAT_SLIDER("Max Spawn Radius", csp.fMaxSpawnRadius, 1.0, 1000.0, 0.5) REPEAT COUNT_OF (csp.vSpawnPoints) i SETUP_SPAWNPOINT_WIDGETS(csp.vSpawnPoints[i], "Spawn Point", i) ENDREPEAT STOP_WIDGET_GROUP() START_WIDGET_GROUP("Time") ADD_WIDGET_INT_SLIDER("Min Spawn Time", csp.iMinSpawnTime, 0, 120000, 125) ADD_WIDGET_INT_SLIDER("Max Spawn Time", csp.iMaxSpawnTime, 0, 120000, 125) ADD_WIDGET_INT_READ_ONLY("Next Spawn Time", csp.iNextSpawnTime) STOP_WIDGET_GROUP() STOP_WIDGET_GROUP() ENDPROC /// PURPOSE: /// Creates a rampage spawnpoint widget /// PARAMS: /// sp - spawn point reference PROC SETUP_RAMPAGE_CLOUD_SPAWNER_DEBUG_WIDGET(RAMPAGE_CLOUDSPAWNER &csp) START_WIDGET_GROUP("Rampage Cloud Spawner") ADD_WIDGET_BOOL("Is Active", csp.bIsActive) ADD_WIDGET_BOOL("Show Spawn Radius", csp.bShowSpawnRadius) START_WIDGET_GROUP("Spawning") ADD_WIDGET_BOOL("Pavement Only", csp.bPavementOnly) ADD_WIDGET_FLOAT_SLIDER("Min Spawn Radius", csp.fMinSpawnRadius, 0.0, 800.0, 0.5) ADD_WIDGET_FLOAT_SLIDER("Max Spawn Radius", csp.fMaxSpawnRadius, 1.0, 800.0, 0.5) ADD_WIDGET_FLOAT_SLIDER("Flee Chance", csp.fFleeChance, 0.0, 1.0, 0.01) STOP_WIDGET_GROUP() START_WIDGET_GROUP("Time") ADD_WIDGET_INT_SLIDER("Min Spawn Time", csp.iMinSpawnTime, 0, 120000, 125) ADD_WIDGET_INT_SLIDER("Max Spawn Time", csp.iMaxSpawnTime, 10, 120000, 125) ADD_WIDGET_INT_READ_ONLY("Next Spawn Time", csp.iNextSpawnTime) STOP_WIDGET_GROUP() STOP_WIDGET_GROUP() ENDPROC /// PURPOSE: /// Creates a rampage spawnpoint widget /// PARAMS: /// sp - spawn point reference PROC SETUP_RAMPAGE_FORTRESS_SPAWNER_DEBUG_WIDGET(RAMPAGE_FORTSPAWNER &csp) INT i START_WIDGET_GROUP("Rampage Fortress Spawner") ADD_WIDGET_BOOL("Is Active", csp.bIsActive) ADD_WIDGET_FLOAT_SLIDER("Min Spawn Radius", csp.fMinSpawnRadius, 0.0, 800.0, 0.5) ADD_WIDGET_INT_SLIDER("Max Fortress", csp.iMaxActiveFortress, 0, COUNT_OF(rampageFort), 1) ADD_WIDGET_FLOAT_SLIDER("Player Limit", csp.fFortressAllowRange, 0.0, 800.0, 0.5) REPEAT COUNT_OF(rampageFort) i SETUP_RAMPAGE_FORTRESS_WIDGETS(rampageFort[i], "Fortress", i) ENDREPEAT START_WIDGET_GROUP("Time") ADD_WIDGET_INT_SLIDER("Min Spawn Time", csp.iMinSpawnTime, 0, 120000, 125) ADD_WIDGET_INT_SLIDER("Max Spawn Time", csp.iMaxSpawnTime, 10, 120000, 125) ADD_WIDGET_INT_READ_ONLY("Next Spawn Time", csp.iNextSpawnTime) STOP_WIDGET_GROUP() STOP_WIDGET_GROUP() ENDPROC /// PURPOSE: /// Creates a rampage ped widget /// PARAMS: /// sp - ped reference PROC SETUP_RAMPAGE_PED_DEBUG_WIDGET(RAMPAGE_PED &csp) TEXT_LABEL lbl = "Rampage Ped" lbl += csp.iIndex START_WIDGET_GROUP(lbl) ADD_WIDGET_BOOL("Is Alive", csp.bDebugAliveCheck) ADD_WIDGET_BOOL("In Vehicle", csp.bWasInVehicle) ADD_WIDGET_BOOL("Is Flee Ped", csp.bIsFleePed) ADD_WIDGET_FLOAT_READ_ONLY("Player Dist", csp.fPlayerDist) ADD_WIDGET_INT_READ_ONLY("Fort Index", csp.iFortIndex) ADD_WIDGET_INT_READ_ONLY("Index", csp.iIndex) STOP_WIDGET_GROUP() ENDPROC /// PURPOSE: /// Creates a rampage ped widget /// PARAMS: /// sp - ped reference PROC SETUP_RAMPAGE_CAR_DEBUG_WIDGET(RAMPAGE_CAR &csp) INT i TEXT_LABEL lbl = "Rampage Car" lbl += csp.iIndex START_WIDGET_GROUP(lbl) ADD_WIDGET_BOOL("Is Alive", csp.bDebugAliveCheck) ADD_WIDGET_BOOL("Keep As Cover", csp.bKeepAsCover) START_WIDGET_GROUP("Occupant Index") REPEAT COUNT_OF(csp.iOccupantIndex) i lbl = "Occupant" lbl += i ADD_WIDGET_INT_READ_ONLY(lbl, csp.iOccupantIndex[i]) ENDREPEAT STOP_WIDGET_GROUP() ADD_WIDGET_FLOAT_READ_ONLY("Player Dist", csp. fDistToPlayer) ADD_WIDGET_FLOAT_READ_ONLY("Original Dist", csp.fOriginalDist) ADD_WIDGET_INT_READ_ONLY("Task State", csp.iTaskState) ADD_WIDGET_INT_READ_ONLY("Index", csp.iIndex) STOP_WIDGET_GROUP() ENDPROC /// PURPOSE: /// Setups All The Widgets PROC START_RAMPAGE_DEBUG_WIDGET_GROUP() INT i m_RampWidgetGroup = START_WIDGET_GROUP("Rampage Configuration") START_WIDGET_GROUP("Debug Options") ADD_WIDGET_BOOL("Show Version Number", bDebugShowMissionVersion) ADD_WIDGET_BOOL("Show Debug TTY", bDebugShowTTY) ADD_WIDGET_BOOL("Infinite Time", bInfiniteTime) ADD_WIDGET_BOOL("Block Temp Events", bBlockRampageTempEvents) ADD_WIDGET_BOOL("Camera Interphack", bHackInterpolate) ADD_WIDGET_BOOL("Pause Rampage", bPauseRampageSpawning) ADD_WIDGET_BOOL("Use Behind Check", bDoPedSpawnBehindCheck) ADD_WIDGET_BOOL("Use Is Area Occupied", bUseIsAreaOccupied) ADD_WIDGET_BOOL("Japan Delete Test", bDebugDeletePedsForJapan) START_WIDGET_GROUP("Player Options") ADD_WIDGET_FLOAT_SLIDER("Player Regen Rate", fHPRegenMult, 1.0, 10.0, 0.5) ADD_WIDGET_BOOL("Show Notifications", bShowNotifications) ADD_WIDGET_INT_SLIDER("Seed", rampageInfo.iRandomSeed, 0, 100000000, 10) ADD_WIDGET_VECTOR_SLIDER("BattleCenter", vBattleCenter, -7000.0, 7000.0, 10.0) ADD_WIDGET_FLOAT_SLIDER("Battle Radius", fBattleRadius, 1.0, 1000.0, 0.5) ADD_WIDGET_FLOAT_SLIDER("PissTake Rocket Chance", fPissTakeRocketChance, 0.0, 1.0, 0.005) ADD_WIDGET_BOOL("Show Debug Draw Spot", bDebugDrawSpot) ADD_WIDGET_VECTOR_SLIDER("Debug Draw Spot Pos", vDebugDrawSpot, -7000.0, 7000.0, 10.0) STOP_WIDGET_GROUP() START_WIDGET_GROUP("Pass Fail Options") ADD_WIDGET_BOOL("Pass Rampage", bInstantPass) ADD_WIDGET_BOOL("Fail Rampage", bInstantFail) ADD_WIDGET_BOOL("Pass Challenges", bInstaPassChallenges) ADD_WIDGET_INT_SLIDER("Set Medal As", iInstaPassMedal, ENUM_TO_INT(RAMPAGE_NOMEDAL), ENUM_TO_INT(RAMPAGE_GOLD), 1) STOP_WIDGET_GROUP() STOP_WIDGET_GROUP() SETUP_COMBAT_PARAMETERS_WIDGET(rampageCombatParams, "Ped Combat Parameters") START_WIDGET_GROUP("No Spawn Areas") ADD_WIDGET_INT_READ_ONLY("Max No Spawn Areas", iMaxActiveNoSpawnAreas) i = 0 REPEAT COUNT_OF(noSpawnArea) i SETUP_RAMPAGE_AREA_WIDGETS(noSpawnArea[i], "Area", i) ENDREPEAT STOP_WIDGET_GROUP() START_WIDGET_GROUP("Spawning") ADD_WIDGET_INT_SLIDER("Active Peds", iMaxActivePeds, 0, COUNT_OF(rampagePed), 1) ADD_WIDGET_BOOL("Use Global Ped Spawn Timer", bUseGlobalPedSpawnTimer) ADD_WIDGET_INT_SLIDER("Min Ped Spawn Time", iMinRampagePedSpawnTime, 0, 30000, 1000) ADD_WIDGET_INT_SLIDER("Max Ped Spawn Time", iMaxRampagePedSpawnTime, 0, 30000, 1000) ADD_WIDGET_FLOAT_SLIDER("Second Weapon Chance", fEnemySecondWeaponChance, 0.0, 1.0, 0.05) ADD_WIDGET_INT_READ_ONLY("Game Timer", iGameTimer) START_WIDGET_GROUP("Test Vehicle") ADD_WIDGET_BOOL("Create Test Car", bCreateTestVehicle) ADD_WIDGET_BOOL("Create Test Tank", bCreateTestTank) ADD_WIDGET_INT_SLIDER("Spawn Point Index", iTestVehicleSpawnPointIndex, 0, COUNT_OF(rampageCarSpawner.vSpawnPoints) - 1, 1) STOP_WIDGET_GROUP() START_WIDGET_GROUP("Cleanup Test") ADD_WIDGET_BOOL("bDeletePedsAndCars", bDeletePedsAndCars) ADD_WIDGET_BOOL("bDeletePeds", bDeletePeds) ADD_WIDGET_BOOL("bDeleteCars", bDeleteCars) ADD_WIDGET_BOOL("bCleanupPedsAndCars", bCleanupPedsAndCars) ADD_WIDGET_BOOL("bCleanupPeds", bCleanupPeds) ADD_WIDGET_BOOL("bCleanupCars", bCleanupCars) STOP_WIDGET_GROUP() START_WIDGET_GROUP("Spawn Blocker") ADD_WIDGET_BOOL("Block Spawning", bBlockRampageSpawning) ADD_WIDGET_INT_SLIDER("Spawn Limit Block", iRampageSpawnBlockLimit, 1, COUNT_OF(rampagePed), 1) ADD_WIDGET_INT_SLIDER("Min Spawn Block Time", iMinRampageSpawnBlockTime, 0, 30000, 1000) ADD_WIDGET_INT_SLIDER("Max Spawn Block Time", iMaxRampageSpawnBlockTime, 0, 30000, 1000) ADD_WIDGET_INT_READ_ONLY("Block State", iRampageSpawnStateDebug) STOP_WIDGET_GROUP() START_WIDGET_GROUP("Spawn Pos Checker") ADD_WIDGET_BOOL("Check Position", bCheckSpawnPosition) ADD_WIDGET_BOOL("Use Player Pos", bSetPlayerPosAsCheckPoint) ADD_WIDGET_VECTOR_SLIDER("Position", vCheckSpawnPoint, -5000.0, 5000.0, 10.0) ADD_WIDGET_BOOL("Is Point Okay", bIsPointOkay ) STOP_WIDGET_GROUP() SETUP_RAMPAGE_ALLEY_SPAWNER_DEBUG_WIDGET(rampageAlleySpawner) SETUP_RAMPAGE_CAR_SPAWNER_DEBUG_WIDGET(rampageCarSpawner) SETUP_RAMPAGE_CLOUD_SPAWNER_DEBUG_WIDGET(rampageCloudSpawner) SETUP_RAMPAGE_FORTRESS_SPAWNER_DEBUG_WIDGET(rampageFortressSpawner) START_WIDGET_GROUP("Backup Spawner") SETUP_RAMPAGE_CLOUD_SPAWNER_DEBUG_WIDGET(rampageBackupCloudSpawner) STOP_WIDGET_GROUP() STOP_WIDGET_GROUP() START_WIDGET_GROUP("Scenario Area") ADD_WIDGET_BOOL("Show Area", bShowScenarioBlockArea) ADD_WIDGET_VECTOR_SLIDER("Position", rampageInfo.vScenarioBlockCenter, -8000.0, 8000.0, 10.0) ADD_WIDGET_FLOAT_SLIDER("Radius", rampageInfo.fScenarioBlockRadius, 0.0, 800.0, 10.0) STOP_WIDGET_GROUP() START_WIDGET_GROUP("Ped Debug") i = 0 REPEAT COUNT_OF(rampagePed) i SETUP_RAMPAGE_PED_DEBUG_WIDGET(rampagePed[i]) ENDREPEAT STOP_WIDGET_GROUP() START_WIDGET_GROUP("Car Debug") i = 0 REPEAT COUNT_OF(rampageCar) i SETUP_RAMPAGE_CAR_DEBUG_WIDGET(rampageCar[i]) ENDREPEAT STOP_WIDGET_GROUP() START_WIDGET_GROUP("Stats") START_WIDGET_GROUP("Ped Stats") ADD_WIDGET_INT_READ_ONLY("Max Active Peds", iMaxActivePeds) ADD_WIDGET_INT_READ_ONLY("Alive Peds", iAlivePedCounter) ADD_WIDGET_INT_READ_ONLY("Peds Dead", rampageStats.iPedDeadCount) ADD_WIDGET_INT_READ_ONLY("Head Shots", rampageStats.iHeadShots) ADD_WIDGET_INT_READ_ONLY("Cripple Shots", rampageStats.iCrippleCount) ADD_WIDGET_INT_READ_ONLY("Close Ranges", rampageStats.iCloseRange) STOP_WIDGET_GROUP() START_WIDGET_GROUP("Car Stats") ADD_WIDGET_INT_READ_ONLY("Alive Cars", iAliveCarCounter) ADD_WIDGET_INT_READ_ONLY("Alive Cover Cars", iAliveCoverCarCounter) ADD_WIDGET_INT_READ_ONLY("Cars Destroyed", rampageStats.iCarDeadCount) ADD_WIDGET_INT_READ_ONLY("Cars Abandoned", rampageStats.iCarAbandonCount) ADD_WIDGET_INT_READ_ONLY("Car Occupants Kills", rampageStats.iCarOccupantKills) STOP_WIDGET_GROUP() STOP_WIDGET_GROUP() STOP_WIDGET_GROUP() ENDPROC /// PURPOSE: /// Cleans up All The Widgets PROC CLEANUP_RAMPAGE_DEBUG_WIDGETS() IF DOES_WIDGET_GROUP_EXIST(m_RampWidgetGroup) DELETE_WIDGET_GROUP(m_RampWidgetGroup) ENDIF ENDPROC /// PURPOSE: /// Draw a Ramage Fortress Area in Debug /// PARAMS: /// fort - fortress reference PROC DRAW_DEBUG_RAMPAGE_FORTRESS(RAMPAGE_FORTRESS &fort) INT iAlpha = 128 VECTOR v1, v2 IF (fort.bIsActive) iAlpha = 255 ENDIF DRAW_DEBUG_SPHERE(fort.vLastSpawnPoint, 0.5) DRAW_DEBUG_AREA(fort.defenseArea.vPosition[0], fort.defenseArea.vPosition[1], fort.defenseArea.fWidth, 0, 255, 0, iAlpha) DRAW_DEBUG_AREA(fort.spawnArea.vPosition[0], fort.spawnArea.vPosition[1], fort.spawnArea.fWidth, 0, 255, 0, 255) // draw roof IF (fort.fRoofHeight > 0.0) v1 = fort.spawnArea.vPosition[0] v1.z = fort.fRoofHeight v2 = fort.spawnArea.vPosition[1] v2.z = fort.fRoofHeight DRAW_DEBUG_AREA(v1, v2, fort.defenseArea.fWidth, 0, 255, 255, 255) ENDIF ENDPROC #ENDIF //---------------------- // AREA FUNCTIONS //---------------------- /// PURPOSE: /// Resolve cars for mission PROC RESOLVE_MISSION_VEHICLES_FOR_CUTSCENE() CPRINTLN(DEBUG_RAMPAGE, "Resolve vehicles Resolved For Intro") VEHICLE_INDEX playerVeh VECTOR vRespotPos FLOAT fRespotHeading playerVeh = GET_MISSION_START_VEHICLE_INDEX() SWITCH (rampageInfo.blipNameEnum) CASE STATIC_BLIP_MINIGAME_RAMPAGE1 SET_ANGLED_AREA(respotVehicleArea, <<896.120422,3640.058105,36.088860>>, <<922.222107,3639.568359,31.159431>>, 13.500000) IF IS_REPLAY_START_VEHICLE_UNDER_SIZE_LIMIT(GET_DEFAULT_ALLOWABLE_VEHICLE_SIZE_VECTOR(), TRUE) vRespotPos = <<899.9673, 3653.0491, 31.7576>> fRespotHeading = 268.2063 ELSE vRespotPos = <<891.0971, 3653.3279, 31.8184>> fRespotHeading = 268.1944 ENDIF BREAK CASE STATIC_BLIP_MINIGAME_RAMPAGE2 SET_ANGLED_AREA(respotVehicleArea, <<1179.185303,-421.631012,74.338844>>, <<1185.704590,-388.575287,66.900261>>, 21.500000) IF IS_REPLAY_START_VEHICLE_UNDER_SIZE_LIMIT(GET_DEFAULT_ALLOWABLE_VEHICLE_SIZE_VECTOR(), TRUE) vRespotPos = <<1231.5063, -442.6294, 66.5811>> fRespotHeading = 191.4606 ELSE vRespotPos = <<1226.6814, -436.0827, 66.5804>> fRespotHeading = 76.5787 ENDIF BREAK CASE STATIC_BLIP_MINIGAME_RAMPAGE3 SET_ANGLED_AREA(respotVehicleArea, <<449.730560,-1858.224121,28.845421>>, <<472.455170,-1843.895630,25.801113>>, 37.250000) IF IS_REPLAY_START_VEHICLE_UNDER_SIZE_LIMIT(GET_DEFAULT_ALLOWABLE_VEHICLE_SIZE_VECTOR(), TRUE) vRespotPos = <<506.3633, -1842.3701, 26.6440>> fRespotHeading = 308.8210 ELSE vRespotPos = <<505.1393, -1845.2905, 26.3862>> fRespotHeading = 308.6425 ENDIF BREAK CASE STATIC_BLIP_MINIGAME_RAMPAGE4 SET_ANGLED_AREA(respotVehicleArea, <<-143.971466,-1646.401001,39.634609>>, <<-172.522293,-1680.794800,31.561562>>, 18.750000) IF IS_REPLAY_START_VEHICLE_UNDER_SIZE_LIMIT(GET_DEFAULT_ALLOWABLE_VEHICLE_SIZE_VECTOR(), TRUE) vRespotPos = <<-163.3928, -1698.3533, 30.6384>> fRespotHeading = 63.0698 ELSE vRespotPos = <<-225.3203, -1699.5354, 33.0015>> fRespotHeading = 107.6143 ENDIF BREAK CASE STATIC_BLIP_MINIGAME_RAMPAGE5 SET_ANGLED_AREA(respotVehicleArea, <<-1303.807495,2499.506104,29.048244>>, <<-1228.827271,2569.846191,14.731240>>, 29.500000) vRespotPos = <<-1323.6338, 2474.4177, 23.6185>> fRespotHeading = 318.5112 BREAK ENDSWITCH IF IS_REPLAY_IN_PROGRESS() CREATE_VEHICLE_FOR_REPLAY( playerVeh, vRespotPos, fRespotHeading, FALSE, FALSE, TRUE, TRUE, FALSE ) ENDIF RESOLVE_VEHICLES_INSIDE_ANGLED_AREA_WITH_SIZE_LIMIT(respotVehicleArea.vPosition[0], respotVehicleArea.vPosition[1], respotVehicleArea.fWidth, vRespotPos, fRespotHeading, GET_DEFAULT_ALLOWABLE_VEHICLE_SIZE_VECTOR()) IF DOES_ENTITY_EXIST( playerVeh ) SET_ENTITY_AS_MISSION_ENTITY( playerVeh, TRUE, TRUE ) ENDIF SET_MISSION_VEHICLE_GEN_VEHICLE( playerVeh, <<0,0,0>>, 0 ) ENDPROC FUNC BOOL IS_PLAYER_IN_UNDERGROUND_TUNNEL() RETURN IS_ENTITY_IN_ANGLED_AREA(PLAYER_PED_ID(), << -2080.115, 3292.193, -11.667 >>, << -2112.049, 3224.331, 11.667 >>, 115.000, FALSE, FALSE) ENDFUNC FUNC BOOL IS_PLAYER_JUMPING_GATES() IF NOT IS_PED_INJURED(PLAYER_PED_ID()) IF IS_ENTITY_IN_ANGLED_AREA(PLAYER_PED_ID(), << -1599.593, 2818.150, -17.645 >>, << -1612.423, 2806.997, 17.645 >>, 51.000, TRUE, FALSE) OR IS_ENTITY_IN_ANGLED_AREA(PLAYER_PED_ID(), << -2301.089, 3385.031, -31.086 >>, << -2305.302, 3379.441, 31.086 >>, 16.000, TRUE, FALSE) OR IS_ENTITY_IN_ANGLED_AREA(PLAYER_PED_ID(), << -2287.138, 3385.616, 31.124 >>, << -2292.554, 3378.428, 31.124 >>, 19.8, TRUE, FALSE) RETURN TRUE ENDIF ENDIF RETURN FALSE ENDFUNC /// PURPOSE: /// Setups a rampage area /// PARAMS: /// area - area reference /// p1 - area point 1 /// p2 - area point 2 /// width - area width PROC SETUP_RAMPAGE_AREA(RAMPAGE_AREA &area, VECTOR p1, VECTOR p2, FLOAT width) area.bIsActive = TRUE area.vPosition[0] = p1 area.vPosition[1] = p2 area.fWidth = width area.fHeight = p2.z - p1.z // calculate flat forward p2.z = p1.z area.vForward = NORMALISE_VECTOR(p2 - p1) area.fLength = GET_LINE_MAGNITUDE(p1, p2) area.vRight = <> ENDPROC /// PURPOSE: /// Expands an angled area by an amount and returns the expanded version /// PARAMS: /// a - area to expand /// exp - expand amount FUNC RAMPAGE_AREA EXPAND_RAMPAGE_AREA(RAMPAGE_AREA a, FLOAT exp = 1.0) RAMPAGE_AREA aOut VECTOR vNormal = NORMALISE_VECTOR(a.vPosition[1] - a.vPosition[0]) * exp VECTOR v0 = a.vPosition[0] - vNormal VECTOR v1 = a.vPosition[1] + vNormal FLOAT fWidth = a.fWidth + (exp * 2.0) SETUP_RAMPAGE_AREA(aOut, v0, v1, fWidth) RETURN aOut ENDFUNC /// PURPOSE: /// Generates a random point within an area /// PARAMS: /// area - area reference /// RETURNS: /// a generated position FUNC VECTOR GET_RANDOM_POINT_IN_RAMPAGE_AREA(RAMPAGE_AREA area) VECTOR v v = area.vPosition[0] + (area.vForward * GET_RANDOM_FLOAT_IN_RANGE(0, area.fLength)) v += (area.vRight * GET_RANDOM_FLOAT_IN_RANGE(-0.5, 0.5) * area.fWidth) v.z = area.vPosition[0].z + ((area.vPosition[1].z - area.vPosition[0].z) * GET_RANDOM_FLOAT_IN_RANGE(0, 1.5)) IF (v.z > area.vPosition[1].z) v.z = area.vPosition[1].z ENDIF RETURN v ENDFUNC /// PURPOSE: /// Setups a rampage spawn point /// PARAMS: /// sp - spawn point reference /// pos - spawn point location /// head - spawn point heading /// aerial - set this to be true if they are on a roof (so people don't fall off) PROC SET_RAMPAGE_SPAWN_POINT(RAMPAGE_SPAWNPOINT &sp, VECTOR pos, FLOAT head, BOOL aerial = FALSE) sp.vPosition = pos sp.fHeading = head sp.bIsAerial = aerial ENDPROC /// PURPOSE: /// Adds a no spawn area to our current lise /// PARAMS: /// p1 - area point 1 /// p2 - area point 2 /// width - area width /// RETURNS: /// True if we can - or this will assert if we've overstepped the area FUNC BOOL ADD_NO_SPAWN_AREA(VECTOR p1, VECTOR p2, FLOAT width) // if we out of allocated no spawn areas - bail IF (iMaxActiveNoSpawnAreas >= COUNT_OF(noSpawnArea)) SCRIPT_ASSERT("INCREASE THE ARRAY SIZE OF NO SPAWN AREA") RETURN FALSE ENDIF SETUP_RAMPAGE_AREA(noSpawnArea[iMaxActiveNoSpawnAreas], p1, p2, width) iMaxActiveNoSpawnAreas ++ RETURN TRUE ENDFUNC //---------------------- // AUDIO FUNCTIONS //---------------------- /// PURPOSE: /// SETS UP TIMERS AND CONVERSATIONS FOR RAMPAGE RANTING PROC PREPARE_RAMPAGE_ONE_SHOT() SWITCH (rampageInfo.blipNameEnum) CASE STATIC_BLIP_MINIGAME_RAMPAGE1 PREPARE_MUSIC_EVENT("RAMPAGE_1_OS") BREAK CASE STATIC_BLIP_MINIGAME_RAMPAGE2 PREPARE_MUSIC_EVENT("RAMPAGE_2_OS") BREAK CASE STATIC_BLIP_MINIGAME_RAMPAGE3 PREPARE_MUSIC_EVENT("RAMPAGE_3_OS") BREAK CASE STATIC_BLIP_MINIGAME_RAMPAGE4 PREPARE_MUSIC_EVENT("RAMPAGE_4_OS") BREAK CASE STATIC_BLIP_MINIGAME_RAMPAGE5 PREPARE_MUSIC_EVENT("RAMPAGE_5_OS") BREAK ENDSWITCH CPRINTLN(DEBUG_RAMPAGE, "PREPARING RAMPAGE ONE SHOT") ENDPROC /// PURPOSE: /// SETS UP TIMERS AND CONVERSATIONS FOR RAMPAGE RANTING PROC TRIGGER_RAMPAGE_ONE_SHOT() SWITCH (rampageInfo.blipNameEnum) CASE STATIC_BLIP_MINIGAME_RAMPAGE1 TRIGGER_MUSIC_EVENT("RAMPAGE_1_OS") BREAK CASE STATIC_BLIP_MINIGAME_RAMPAGE2 TRIGGER_MUSIC_EVENT("RAMPAGE_2_OS") BREAK CASE STATIC_BLIP_MINIGAME_RAMPAGE3 TRIGGER_MUSIC_EVENT("RAMPAGE_3_OS") BREAK CASE STATIC_BLIP_MINIGAME_RAMPAGE4 TRIGGER_MUSIC_EVENT("RAMPAGE_4_OS") BREAK CASE STATIC_BLIP_MINIGAME_RAMPAGE5 TRIGGER_MUSIC_EVENT("RAMPAGE_5_OS") BREAK ENDSWITCH CPRINTLN(DEBUG_RAMPAGE, "TRIGGERING RAMPAGE ONE SHOT") ENDPROC PROC TRIGGER_RAMPAGE_FX() IF NOT ANIMPOSTFX_IS_RUNNING("Rampage") ANIMPOSTFX_PLAY("Rampage", 0, TRUE) ENDIF ENDPROC PROC STOP_RAMPAGE_FX() IF ANIMPOSTFX_IS_RUNNING("Rampage") ANIMPOSTFX_STOP("Rampage") ANIMPOSTFX_PLAY("RampageOut", 0, FALSE) ENDIF ENDPROC /// PURPOSE: /// SETS MUSIC FOR RAMPAGE PROC TRIGGER_RAMPAGE_MUSIC() IF (bRampageMusicStarted = TRUE) EXIT ENDIF SWITCH (rampageInfo.blipNameEnum) CASE STATIC_BLIP_MINIGAME_RAMPAGE1 TRIGGER_MUSIC_EVENT("RAMPAGE_1_START") BREAK CASE STATIC_BLIP_MINIGAME_RAMPAGE2 TRIGGER_MUSIC_EVENT("RAMPAGE_2_START") BREAK CASE STATIC_BLIP_MINIGAME_RAMPAGE3 TRIGGER_MUSIC_EVENT("RAMPAGE_3_START") BREAK CASE STATIC_BLIP_MINIGAME_RAMPAGE4 TRIGGER_MUSIC_EVENT("RAMPAGE_4_START") BREAK CASE STATIC_BLIP_MINIGAME_RAMPAGE5 TRIGGER_MUSIC_EVENT("RAMPAGE_5_START") BREAK ENDSWITCH CPRINTLN(DEBUG_RAMPAGE, "TRIGGERING RAMPAGE MUSIC") bRampageMusicStarted = TRUE ENDPROC /// PURPOSE: /// SETS UP TIMERS AND CONVERSATIONS FOR RAMPAGE RANTING PROC SETUP_RAMPAGE_BATTLE_RANT() ADD_PED_FOR_DIALOGUE(convoBattleRant, ENUM_TO_INT(CHAR_TREVOR), PLAYER_PED_ID(), "TREVOR") iNextBattleRantTime = GET_GAME_TIMER() + GET_RANDOM_INT_IN_RANGE(20000, 40000) ENDPROC /// PURPOSE: /// Selects lines for Trevor to shout out during battle PROC UPDATE_RAMPAGE_BATTLE_RANT() IF IS_SCRIPTED_CONVERSATION_ONGOING() EXIT ENDIF IF (GET_GAME_TIMER() < iNextBattleRantTime) EXIT ENDIF // don't shout out words until rampage is actually active IF (sFormState <> SFR_RAMPAGEON) EXIT ENDIF iNextBattleRantTime = GET_GAME_TIMER() + GET_RANDOM_INT_IN_RANGE(10000, 20000) #IF IS_DEBUG_BUILD IF bDebugShowTTY CPRINTLN(DEBUG_RAMPAGE, "RAMPAGE RANT - PED DEAD - BATTLE TIME:", GET_GAME_TIMER() - rampageStats.iStartTime) ENDIF #ENDIF CREATE_CONVERSATION(convoBattleRant, rampageInfo.sDialogBlockName, rampageInfo.sDialogRootLabel, CONV_PRIORITY_MEDIUM) ENDPROC //---------------------- // EVENT FUNCTIONS //---------------------- FUNC INT GET_RAMPAGE_REMAINING_TIME_IN_MILLISECONDS() INT time = rampageInfo.iTimeLimit - (GET_GAME_TIMER() - rampageStats.iStartTime ) IF (time <= 0) time = 0 ENDIF RETURN time ENDFUNC /// PURPOSE: /// Disables attack, weapon select and certain movement controls when about to trigger a cutscene PROC RAMPAGE_DISABLE_CONTROL_ACTIONS() DISABLE_CONTROL_ACTION(PLAYER_CONTROL, INPUT_SELECT_WEAPON) DISABLE_CONTROL_ACTION(PLAYER_CONTROL, INPUT_AIM) DISABLE_CONTROL_ACTION(PLAYER_CONTROL, INPUT_MELEE_ATTACK_HEAVY) DISABLE_CONTROL_ACTION(PLAYER_CONTROL, INPUT_MELEE_ATTACK_LIGHT) DISABLE_CONTROL_ACTION(PLAYER_CONTROL, INPUT_ATTACK) DISABLE_CONTROL_ACTION(PLAYER_CONTROL, INPUT_ATTACK2) DISABLE_CONTROL_ACTION(PLAYER_CONTROL, INPUT_ENTER) DISABLE_CONTROL_ACTION(PLAYER_CONTROL, INPUT_VEH_ATTACK) DISABLE_CONTROL_ACTION(PLAYER_CONTROL, INPUT_VEH_ATTACK2) DISABLE_CONTROL_ACTION(PLAYER_CONTROL, INPUT_VEH_SPECIAL) DISABLE_CONTROL_ACTION(PLAYER_CONTROL, INPUT_VEH_AIM) ENDPROC /// PURPOSE: /// If we are repeating a rampage down to repeat play or replay or rampages all clear /// RETURNS: /// FUNC BOOL IS_REPEAT_RAMPAGE_IN_PROGRESS() RETURN IS_REPLAY_IN_PROGRESS() OR GET_MISSION_FLOW_FLAG_STATE(FLOWFLAG_ALL_RAMPAGES_UNLOCKED) ENDFUNC /// PURPOSE: /// Checks to if a ped model is one of the rampage ped models /// PARAMS: /// pedID - ped index /// RETURNS: /// True if it is FUNC BOOL IS_PED_ENEMY_PED_MODEL(PED_INDEX pedID) INT i MODEL_NAMES mdl = GET_ENTITY_MODEL(pedID) REPEAT COUNT_OF(rampageInfo.pedModels) i IF (rampageInfo.pedModels[i] = mdl) RETURN TRUE ENDIF ENDREPEAT RETURN FALSE ENDFUNC /// PURPOSE: /// Checks to if a ped model is one of the rampage ped models /// PARAMS: /// pedID - ped index /// RETURNS: /// True if it is FUNC BOOL IS_VEHICLE_ENEMY_VEHICLE_MODEL(VEHICLE_INDEX pedID) INT i MODEL_NAMES mdl = GET_ENTITY_MODEL(pedID) IF (rampageInfo.iMaxCarModels <= 0) RETURN FALSE ENDIF REPEAT COUNT_OF(rampageInfo.carModels) i IF (rampageInfo.carModels[i] = mdl) RETURN TRUE ENDIF ENDREPEAT RETURN FALSE ENDFUNC /// PURPOSE: /// Handles Scoring and Stats when a ped dies /// PARAMS: /// pedID - pedIndex PROC RESET_RAMPAGE_STATS(RAMPAGE_STATS &st) st.iPedDeadCount = 0 st.iHeadShots = 0 st.iInnocentsDead = 0 st.iCrippleCount = 0 st.iCloseRange = 0 st.iLongRange = 0 st.iCarDeadCount = 0 st.iCarAbandonCount = 0 st.iCarOccupantKills = 0 st.iLastKillTime = 0 st.iPedsSpawned = 0 st.iChain = 0 st.iMaxChain = 0 STAT_GET_INT(SP2_SHOTS, st.iInitialAccuracyShots) STAT_GET_INT(SP2_HITS, st.iInitialAccuracyHits) ENDPROC /// PURPOSE: /// Handles Scoring and Stats when a ped dies /// PARAMS: /// pedID - pedIndex PROC REGISTER_PED_DEATH(PED_INDEX pedID) FLOAT dist IS_ENTITY_ALIVE(pedID) // this is done to stop the check entity is alive assert //CPRINTLN(DEBUG_RAMPAGE, "Ped Killed Report ") IF NOT IS_PED_ENEMY_PED_MODEL(pedID) rampageStats.iInnocentsDead ++ //CPRINTLN(DEBUG_RAMPAGE, " Innocent Killed") //CPRINTLN(DEBUG_RAMPAGE, "") EXIT ENDIF SET_BLOCKING_OF_NON_TEMPORARY_EVENTS(pedID, FALSE) SET_ENTITY_IS_TARGET_PRIORITY(pedID, FALSE) SET_PED_CAN_BE_TARGETTED(pedID, FALSE) UPDATE_RAMPAGE_BATTLE_RANT() rampageStats.iPedDeadCount ++ CPRINTLN(DEBUG_RAMPAGE, "Peds Dead:", rampageStats.iPedDeadCount) IF (CHECK_HEADSHOT(pedID)) rampageStats.iHeadShots ++ CPRINTLN(DEBUG_RAMPAGE, "Headshots:", rampageStats.iHeadShots) IF (bShowNotifications) BEGIN_TEXT_COMMAND_THEFEED_POST("NOT_HEAD") // Headshot END_TEXT_COMMAND_THEFEED_POST_TICKER(FALSE) ENDIF IF (rampageStats.iPedDeadCount % 5 = 0) PLAY_SOUND_FRONTEND(-1, "RAMPAGE_ROAR_MASTER") CPRINTLN(DEBUG_RAMPAGE, " SOUND PLAYED - RAMPAGE_ROAR_MASTER") ELSE PLAY_SOUND_FRONTEND(-1, "RAMPAGE_KILLED_HEAD_SHOT_MASTER") CPRINTLN(DEBUG_RAMPAGE, " SOUND PLAYED - RAMPAGE_KILLED_HEAD_SHOT_MASTER") ENDIF ELSE IF (rampageStats.iPedDeadCount % 5 = 0) PLAY_SOUND_FRONTEND(-1, "RAMPAGE_ROAR_MASTER") CPRINTLN(DEBUG_RAMPAGE, " SOUND PLAYED - RAMPAGE_ROAR_MASTER") ELSE IF ((GET_GAME_TIMER() - rampageStats.iLastKillTime) > 64) PLAY_SOUND_FRONTEND(-1, "RAMPAGE_KILLED_COUNTER_MASTER") CPRINTLN(DEBUG_RAMPAGE, " SOUND PLAYED - RAMPAGE_KILLED_COUNTER_MASTER") ENDIF ENDIF ENDIF rampageStats.iLastKillTime = GET_GAME_TIMER() rampageStats.iChain ++ dist = GET_DISTANCE_BETWEEN_ENTITIES(PLAYER_PED_ID(), pedID) //CPRINTLN(DEBUG_RAMPAGE, " Kill Distance:", dist) // get square magnitude of distance - point blank range is 2 meters (2*2 = 4) IF (dist <= CLOSE_KILL_RANGE) rampageStats.iCloseRange ++ //CPRINTLN(DEBUG_RAMPAGE, " Close Range Kill") /* IF (bShowNotifications) BEGIN_TEXT_COMMAND_THEFEED_POST("NOT_PBLK") // Point Blank END_TEXT_COMMAND_THEFEED_POST_TICKER(FALSE) ENDIF */ ENDIF // get square magnitude of distance - point blank range is 2 meters (2*2 = 4) IF (dist >= LONG_KILL_RANGE) rampageStats.iLongRange ++ //CPRINTLN(DEBUG_RAMPAGE, " Long Range Kill") /* IF (bShowNotifications) BEGIN_TEXT_COMMAND_THEFEED_POST("NOT_LSHT") // Long shot END_TEXT_COMMAND_THEFEED_POST_TICKER(FALSE) ENDIF */ ENDIF IF IS_PED_IN_ANY_VEHICLE(pedID) rampageStats.iCarOccupantKills ++ CPRINTLN(DEBUG_RAMPAGE, "Peds In Cars Killed:", rampageStats.iCarOccupantKills) //CPRINTLN(DEBUG_RAMPAGE, " Vehicle Occupant Kill") ENDIF IF (CHECK_CRIPPLED(pedID)) rampageStats.iCrippleCount ++ CPRINTLN(DEBUG_RAMPAGE, "Peds Crippled:", rampageStats.iCrippleCount) //CPRINTLN(DEBUG_RAMPAGE, " Cripple Kill") ENDIF //CPRINTLN(DEBUG_RAMPAGE, "") ENDPROC /// PURPOSE: /// Handles scoring and stats when a car is abandoned /// PARAMS: /// carID - vehicle index PROC REGISTER_CAR_ABANDON(VEHICLE_INDEX carID) IS_ENTITY_ALIVE(carID) // this is done to stop the check entity is alive assert rampageStats.iCarAbandonCount ++ CPRINTLN(DEBUG_RAMPAGE, "CARS ABANDONED:", rampageStats.iCarAbandonCount) ENDPROC /// PURPOSE: /// Handles scoring and stats when a car is destroyed /// PARAMS: /// carID - vehicle index PROC REGISTER_CAR_DEATH(VEHICLE_INDEX car, BOOL bFromEvent = TRUE) IS_ENTITY_ALIVE(car) // this is done to stop the check entity is alive assert IF IS_VEHICLE_ENEMY_VEHICLE_MODEL(car) IF NOT DECOR_EXIST_ON(car, "RampageCarExploded") IF DECOR_SET_BOOL(car, "RampageCarExploded", TRUE) IF (bShowNotifications) BEGIN_TEXT_COMMAND_THEFEED_POST("NOT_VDED") // Vehicle Destroyed END_TEXT_COMMAND_THEFEED_POST_TICKER(FALSE) ENDIF rampageStats.iCarDeadCount ++ IF (bFromEvent = TRUE) ENDIF CPRINTLN(DEBUG_RAMPAGE, "VEHICLES DESTROYED:", rampageStats.iCarDeadCount, " REGISTERED BY EVENT:", bFromEvent) ENDIF ENDIF ENDIF ENDPROC /// PURPOSE: /// This checks the event queue so we can tell if people or cars have died PROC PROCESS_RAMPAGE_DAMAGE_EVENT_QUEUE() EVENT_NAMES eEventType STRUCT_ENTITY_ID sEntityID INT iCount = 0 PED_INDEX ped VEHICLE_INDEX car // to stop things crying about unreference variable REPEAT GET_NUMBER_OF_EVENTS(SCRIPT_EVENT_QUEUE_AI) iCount eEventType = GET_EVENT_AT_INDEX(SCRIPT_EVENT_QUEUE_AI, iCount) SWITCH (eEventType) CASE EVENT_ENTITY_DAMAGED // Grab the event data and process also kill the ped on injury GET_EVENT_DATA(SCRIPT_EVENT_QUEUE_AI, iCount, sEntityID, SIZE_OF(STRUCT_ENTITY_ID)) IF DOES_ENTITY_EXIST(sEntityID.EntityId) IF IS_ENTITY_A_PED(sEntityID.EntityId) ped = GET_PED_INDEX_FROM_ENTITY_INDEX(sEntityID.EntityId) IF IS_ENTITY_DEAD(ped) REGISTER_PED_DEATH(ped) ELIF IS_PED_INJURED(ped) SET_ENTITY_HEALTH(ped, 0) // insta kill the ped REGISTER_PED_DEATH(ped) ENDIF ENDIF IF IS_ENTITY_A_VEHICLE(sEntityID.EntityId) car = GET_VEHICLE_INDEX_FROM_ENTITY_INDEX(sEntityID.EntityId) IF IS_ENTITY_DEAD(car) IF HAS_ENTITY_BEEN_DAMAGED_BY_ENTITY( car, PLAYER_PED_ID() ) REGISTER_CAR_DEATH(car) ENDIF ENDIF ENDIF ENDIF BREAK ENDSWITCH ENDREPEAT ENDPROC PROC PROCESS_PED_SCANNER_VEHICLE_EXPLOSION_CHECKS(PED_INDEX ped) INT i, iCnt VEHICLE_INDEX array[20] IF IS_ENTITY_ALIVE(ped) iCnt = GET_PED_NEARBY_VEHICLES(ped, array) REPEAT iCnt i IF IS_ENTITY_DEAD(array[i]) IF HAS_ENTITY_BEEN_DAMAGED_BY_ENTITY(array[i], PLAYER_PED_ID() ) REGISTER_CAR_DEATH(array[i], FALSE) ENDIF ENDIF ENDREPEAT ENDIF ENDPROC PROC PROCESS_ALL_PED_SCANNER_VEHICLE_EXPLOSION_CHECKS() INT i INT iScanCheck = 0 PROCESS_PED_SCANNER_VEHICLE_EXPLOSION_CHECKS(PLAYER_PED_ID()) REPEAT MAX_ACTIVE_PEDS i IF IS_ENTITY_ALIVE(rampagePed[iRampagePedScannerIndex].pedID) PROCESS_PED_SCANNER_VEHICLE_EXPLOSION_CHECKS(rampagePed[iRampagePedScannerIndex].pedID) iScanCheck ++ ENDIF iRampagePedScannerIndex ++ IF (iRampagePedScannerIndex >= MAX_ACTIVE_PEDS) iRampagePedScannerIndex = 0 ENDIF IF (iScanCheck >= PEDS_TO_SCAN_PER_FRAME) EXIT ENDIF ENDREPEAT ENDPROC //---------------------- // ASSET FUNCTIONS //---------------------- /// PURPOSE: /// Loads Relevant Text Assets and Dialog PROC LOAD_TEXT_ASSETS() SWITCH (rampageInfo.blipNameEnum) CASE STATIC_BLIP_MINIGAME_RAMPAGE1 rampageInfo.sDialogBlockName = "RAMP1AU" rampageInfo.sDialogRootLabel = "RAMP1_FIGHT" BREAK CASE STATIC_BLIP_MINIGAME_RAMPAGE2 rampageInfo.sDialogBlockName = "RAMP2AU" rampageInfo.sDialogRootLabel = "RAMP2_FIGHT" BREAK CASE STATIC_BLIP_MINIGAME_RAMPAGE3 rampageInfo.sDialogBlockName = "RAMP3AU" rampageInfo.sDialogRootLabel = "RAMP3_FIGHT" BREAK CASE STATIC_BLIP_MINIGAME_RAMPAGE4 rampageInfo.sDialogBlockName = "RAMP4AU" rampageInfo.sDialogRootLabel = "RAMP4_FIGHT" BREAK CASE STATIC_BLIP_MINIGAME_RAMPAGE5 rampageInfo.sDialogBlockName = "RAMP5AU" rampageInfo.sDialogRootLabel = "RAMP5_FIGHT" BREAK DEFAULT SCRIPT_ASSERT("rampageInfo.sDialogRootLabel not set") EXIT ENDSWITCH SECURE_REQUEST_AND_LOAD_ADDITIONAL_TEXT(rampageInfo.sDialogBlockName, MISSION_DIALOGUE_TEXT_SLOT, FALSE) ENDPROC /// PURPOSE: /// Loads Relevant Mission Assets and Dialog /// PARAMS: /// forceWait - if set we pause until this is completed PROC LOAD_RAMPAGE_ASSETS(BOOL forceWait = TRUE) INT i #IF IS_DEBUG_BUILD IF (bDebugShowTTY) CPRINTLN(DEBUG_RAMPAGE, "LOADING RAMPAGE ASSETS") ENDIF #ENDIF // load text and scaleform LOAD_TEXT_ASSETS() SECURE_REQUEST_AND_LOAD_ADDITIONAL_TEXT("TRVRAMP", MISSION_TEXT_SLOT, forceWait) SECURE_REQUEST_AND_LOAD_SCALEFORM("MP_BIG_MESSAGE_FREEMODE", sFormRampage, forceWait) SECURE_REQUEST_AND_LOAD_AUDIO_BANK("SCRIPT\\RAMPAGE_01", forceWait) SECURE_REQUEST_AND_LOAD_AUDIO_BANK("SCRIPT\\RAMPAGE_02", forceWait) BOOL bFinishedLoad = FALSE if forceWait WHILE NOT bFinishedLoad IF LOAD_STREAM( "RAMPAGE_STREAMING_BED_MASTER" ) CPRINTLN(DEBUG_RAMPAGE, "FINISHED LOADING RAMPAGE_STREAMING_BED_MASTER") bFinishedLoad = TRUE ELIF iWaitTime > 50 CPRINTLN(DEBUG_RAMPAGE, "GIVING UP LOADING RAMPAGE_STREAMING_BED_MASTER") bFinishedLoad = TRUE ELSE iWaitTime++ CPRINTLN(DEBUG_RAMPAGE, "WAITING FOR STREAM: RAMPAGE_STREAMING_BED_MASTER TO LOAD, ", iWaitTime) ENDIF WAIT(0) ENDWHILE else LOAD_STREAM( "RAMPAGE_STREAMING_BED_MASTER" ) endif SECURE_REQUEST_AND_LOAD_ANIM_DICT( "missrampageintrooutro", forceWait) i = 0 REPEAT COUNT_OF(rampageInfo.plyrWeapon) i IF (rampageInfo.plyrWeapon[i] <> WEAPONTYPE_INVALID) AND (rampageInfo.plyrWeapon[i] <> WEAPONTYPE_UNARMED) SECURE_REQUEST_AND_LOAD_WEAPON_ASSET(rampageInfo.plyrWeapon[i], FALSE) ENDIF ENDREPEAT i = 0 REPEAT COUNT_OF(rampageInfo.pedModels) i IF (rampageInfo.pedModels[i] <> DUMMY_MODEL_FOR_SCRIPT) SECURE_REQUEST_AND_LOAD_MODEL(rampageInfo.pedModels[i], forceWait) SET_PED_MODEL_IS_SUPPRESSED(rampageInfo.pedModels[i], TRUE) ENDIF ENDREPEAT IF (rampageInfo.explosiveModel <> DUMMY_MODEL_FOR_SCRIPT) SECURE_REQUEST_AND_LOAD_MODEL(rampageInfo.explosiveModel, forceWait) ENDIF // load cars i = 0 REPEAT COUNT_OF(rampageInfo.carModels) i IF (rampageInfo.carModels[i] <> DUMMY_MODEL_FOR_SCRIPT) SECURE_REQUEST_AND_LOAD_MODEL(rampageInfo.carModels[i], forceWait) ENDIF ENDREPEAT #IF IS_DEBUG_BUILD IF (bDebugShowTTY) CPRINTLN(DEBUG_RAMPAGE, "LOADING RAMPAGE ASSETS FINISHED") ENDIF #ENDIF ENDPROC /// PURPOSE: /// Checks if all assets are loaded /// RETURNS: /// True if they all are FUNC BOOL ARE_RAMPAGE_ASSETS_LOADED() INT i INT cnt IF NOT HAS_ADDITIONAL_TEXT_LOADED(MISSION_TEXT_SLOT) RETURN FALSE ENDIF // check ped models loaded cnt = COUNT_OF(rampageInfo.pedModels) IF (rampageInfo.iMaxPedModels < cnt) cnt = rampageInfo.iMaxPedModels ENDIF IF (cnt > 0) i = 0 REPEAT cnt i IF NOT HAS_MODEL_LOADED(rampageInfo.pedModels[i]) RETURN FALSE ENDIF ENDREPEAT ENDIF // check car models loaded cnt = COUNT_OF(rampageInfo.carModels) IF (rampageInfo.iMaxCarModels < cnt) cnt = rampageInfo.iMaxCarModels ENDIF IF (cnt > 0) i = 0 REPEAT cnt i IF NOT HAS_MODEL_LOADED(rampageInfo.carModels[i]) RETURN FALSE ENDIF ENDREPEAT ENDIF //@RJP Check explosive model loaded IF rampageInfo.bExplosiveProps IF (rampageInfo.explosiveModel <> DUMMY_MODEL_FOR_SCRIPT) IF NOT HAS_MODEL_LOADED( rampageInfo.explosiveModel ) RETURN FALSE ENDIF ENDIF ENDIF IF NOT REQUEST_SCRIPT_AUDIO_BANK("SCRIPT\\RAMPAGE_01") RETURN FALSE ENDIF IF NOT REQUEST_SCRIPT_AUDIO_BANK("SCRIPT\\RAMPAGE_02") RETURN FALSE ENDIF IF NOT LOAD_STREAM("RAMPAGE_STREAMING_BED_MASTER") RETURN FALSE ENDIF RETURN TRUE ENDFUNC //---------------------- // VOICE FUNCTIONS //---------------------- /// PURPOSE: /// Check if a index into the rampage voice list is okay /// PARAMS: /// ind - index # FUNC BOOL IS_RAMPAGE_MALE_VOICE_OK(INT &ind) IF (ind >= COUNT_OF(sMaleVoiceNames)) ind = 0 ENDIF IF IS_STRING_NULL_OR_EMPTY(sMaleVoiceNames[ind]) ind = 0 RETURN FALSE ENDIF RETURN TRUE ENDFUNC /// PURPOSE: /// Check if a index into the rampage voice list is okay /// PARAMS: /// ind - index # FUNC BOOL IS_RAMPAGE_FEMALE_VOICE_OK(INT &ind) IF (ind >= COUNT_OF(sFemaleVoiceNames)) ind = 0 ENDIF IF IS_STRING_NULL_OR_EMPTY(sFemaleVoiceNames[ind]) ind = 0 RETURN FALSE ENDIF RETURN TRUE ENDFUNC /// PURPOSE: /// Sets up ped voices for a ped /// PARAMS: /// pedID - ped reference PROC SETUP_SPECIFIC_PED_VOICE_CONTEXT(PED_INDEX &pedID) #IF IS_DEBUG_BUILD MODEL_NAMES pedModel = GET_ENTITY_MODEL(pedID) #ENDIF IF IS_PED_MALE(pedID) IF IS_RAMPAGE_MALE_VOICE_OK(iLastUsedMaleVoiceNameIndex) SET_AMBIENT_VOICE_NAME(pedID, sMaleVoiceNames[iLastUsedMaleVoiceNameIndex]) #IF IS_DEBUG_BUILD CPRINTLN(DEBUG_RAMPAGE, "Ambient Voice Applied:", GET_MODEL_NAME_FOR_DEBUG(pedModel), " ", sMaleVoiceNames[iLastUsedMaleVoiceNameIndex], " ", sVoiceContext) #ENDIF iLastUsedMaleVoiceNameIndex ++ ELSE iLastUsedMaleVoiceNameIndex = 0 ENDIF ELIF IS_RAMPAGE_FEMALE_VOICE_OK(iLastUsedFemaleVoiceNameIndex) SET_AMBIENT_VOICE_NAME(pedID, sFemaleVoiceNames[iLastUsedFemaleVoiceNameIndex]) #IF IS_DEBUG_BUILD CPRINTLN(DEBUG_RAMPAGE, "Ambient Voice Applied:", GET_MODEL_NAME_FOR_DEBUG(pedModel), " ", sFemaleVoiceNames[iLastUsedFemaleVoiceNameIndex], " ", sVoiceContext) #ENDIF iLastUsedFemaleVoiceNameIndex ++ ELSE iLastUsedFemaleVoiceNameIndex = 0 ENDIF IF NOT (rampageInfo.blipNameEnum = STATIC_BLIP_MINIGAME_RAMPAGE2) IF NOT IS_STRING_NULL_OR_EMPTY(sVoiceContext) PLAY_PED_AMBIENT_SPEECH_NATIVE(pedID, sVoiceContext, "SPEECH_PARAMS_FORCE") ENDIF ENDIF ENDPROC PROC SETUP_SPECIFIC_HIPSTER_VOICE( RAMPAGE_PED &ped ) IF iLastUsedRampage2VoiceIndex > 8 iLastUsedRampage2VoiceIndex = 0 ENDIF SWITCH iLastUsedRampage2VoiceIndex CASE 0 ped.sContext = "RAMP2_HIP9" ped.sVoice = "RAMPAGEHIPSTER9" BREAK CASE 1 ped.sContext = "RAMP2_HIP1" ped.sVoice = "RAMPAGEHIPSTER" BREAK CASE 2 ped.sContext = "RAMP2_HIP2" ped.sVoice = "RAMPAGEHIPSTER2" BREAK CASE 3 ped.sContext = "RAMP2_HIP3" ped.sVoice = "RAMPAGEHIPSTER3" BREAK CASE 4 ped.sContext = "RAMP2_HIP4" ped.sVoice = "RAMPAGEHIPSTER4" BREAK CASE 5 ped.sContext = "RAMP2_HIP5" ped.sVoice = "RAMPAGEHIPSTER5" BREAK CASE 6 ped.sContext = "RAMP2_HIP6" ped.sVoice = "RAMPAGEHIPSTER6" BREAK CASE 7 ped.sContext = "RAMP2_HIP7" ped.sVoice = "RAMPAGEHIPSTER7" BREAK CASE 8 ped.sContext = "RAMP2_HIP8" ped.sVoice = "RAMPAGEHIPSTER8" BREAK ENDSWITCH ADD_PED_FOR_DIALOGUE( convoBattleRant, (iLastUsedRampage2VoiceIndex), ped.pedID, ped.sVoice ) iLastUsedRampage2VoiceIndex++ IF iLastUsedRampage2VoiceIndex = 2 iLastUsedRampage2VoiceIndex++ ENDIF ENDPROC PROC RAMPAGE2_HIPSTER_INSULTS( RAMPAGE_PED &ped ) IF NOT (rampageInfo.blipNameEnum = STATIC_BLIP_MINIGAME_RAMPAGE2) EXIT ENDIF IF IS_STRING_NULL_OR_EMPTY( ped.sContext ) OR IS_STRING_NULL_OR_EMPTY( ped.sVoice ) SETUP_SPECIFIC_HIPSTER_VOICE( ped ) ENDIF IF ped.iInsultTimer = 0 ped.iInsultTimer = GET_GAME_TIMER()+GET_RANDOM_INT_IN_RANGE(5000,15000) ENDIF IF GET_GAME_TIMER() > ped.iInsultTimer CREATE_CONVERSATION( convoBattleRant, rampageInfo.sDialogBlockName, ped.sContext, CONV_PRIORITY_LOW, DO_NOT_DISPLAY_SUBTITLES ) ped.iInsultTimer = GET_GAME_TIMER()+GET_RANDOM_INT_IN_RANGE(10000,20000) ENDIF ENDPROC //---------------------- // ENTITY FUNCTIONS //---------------------- /// PURPOSE: /// Returns a random ped model from the current rampage info struct /// RETURNS: /// Model Name or null it can't pick one FUNC MODEL_NAMES GET_RANDOM_RAMPAGE_PED_MODEL() IF (rampageInfo.iMaxPedModels = 0) SCRIPT_ASSERT("NO RAMPAGE PED MODELS DEFINED!!") RETURN DUMMY_MODEL_FOR_SCRIPT ENDIF RETURN rampageInfo.pedModels[GET_RANDOM_INT_IN_RANGE(0, rampageInfo.iMaxPedModels)] ENDFUNC /// PURPOSE: /// Assigns the Players Rampage Weapons and Weapon Components PROC GIVE_PLAYER_RAMPAGE_WEAPONS() INT i // give weapons i = 0 SET_PED_CAN_SWITCH_WEAPON(PLAYER_PED_ID(), TRUE) GIVE_WEAPON_TO_PED(PLAYER_PED_ID(), WEAPONTYPE_GRENADE, 15, FALSE, FALSE) REPEAT COUNT_OF(rampageInfo.plyrWeapon) i IF (rampageInfo.plyrWeapon[i] <> WEAPONTYPE_INVALID) CPRINTLN(DEBUG_RAMPAGE, "GIVING PLAYER WEAPON") GIVE_WEAPON_TO_PED(PLAYER_PED_ID(), rampageInfo.plyrWeapon[i], INFINITE_AMMO , TRUE, TRUE) // INFINITE_AMMO ADD_AMMO_TO_PED(PLAYER_PED_ID(), rampageInfo.plyrWeapon[i], INFINITE_AMMO) // just in case someone turns up to the rampage with weapons with no ammo SET_PED_INFINITE_AMMO(PLAYER_PED_ID(), TRUE, rampageInfo.plyrWeapon[i]) ENDIF ENDREPEAT // NOTE: The weapon components are only for plyrWeapon[0] as this is the primary weapon IF (rampageInfo.plyrWeapon[0] <> WEAPONTYPE_INVALID) AND (rampageInfo.plyrWeapon[0] <> WEAPONTYPE_UNARMED) i = 0 REPEAT COUNT_OF(rampageInfo.plyrWeaponComp) i IF (rampageInfo.plyrWeaponComp[i] <> WEAPONCOMPONENT_INVALID) GIVE_WEAPON_COMPONENT_TO_PED(PLAYER_PED_ID(), rampageInfo.plyrWeapon[0], rampageInfo.plyrWeaponComp[i]) ENDIF ENDREPEAT ENDIF // force weapon in player hand CPRINTLN(DEBUG_RAMPAGE, "ARMS INSTALLATION IS COMPLETE - GOOD LUCK!") IF (rampageInfo.plyrWeapon[0] <> WEAPONTYPE_INVALID) CPRINTLN(DEBUG_RAMPAGE, "EQUIPING PLAYER FIRST WEAPON") SET_CURRENT_PED_WEAPON(PLAYER_PED_ID(), rampageInfo.plyrWeapon[0], TRUE) SET_PED_CURRENT_WEAPON_VISIBLE(PLAYER_PED_ID(), TRUE) REFILL_AMMO_INSTANTLY(PLAYER_PED_ID()) ENDIF CPRINTLN(DEBUG_RAMPAGE, "ACTION MODE INITIALIZED") SET_PED_USING_ACTION_MODE(PLAYER_PED_ID(), TRUE, -1,"TREVOR_ACTION") //FORCE_PED_MOTION_STATE(PLAYER_PED_ID(), MS_ACTIONMODE_IDLE, TRUE) ENDPROC /// PURPOSE: /// Assigns the Players Rampage Weapons and Weapon Components PROC RESET_PLAYER_RAMPAGE_INFINITE_AMMO() INT i = 0 REPEAT COUNT_OF(rampageInfo.plyrWeapon) i IF (rampageInfo.plyrWeapon[i] <> WEAPONTYPE_INVALID) IF HAS_PED_GOT_WEAPON(PLAYER_PED_ID(), rampageInfo.plyrWeapon[i]) SET_PED_INFINITE_AMMO(PLAYER_PED_ID(), FALSE, rampageInfo.plyrWeapon[i]) ENDIF ENDIF ENDREPEAT ENDPROC //---------------------- // PED FUNCTIONS //---------------------- /// PURPOSE: /// Hacky function to fix B*1035547 /// PARAMS: /// pedID - ped to do the running /// pos - position to get to /// bForceNavMesh - force nav mesh use - (don't use this by the military base) PROC RAMPAGE_SMART_FLEE_HACKERY(PED_INDEX pedID, VECTOR pos, BOOL bForceNavMesh = TRUE) SEQUENCE_INDEX seqTask SET_BLOCKING_OF_NON_TEMPORARY_EVENTS(pedID, bBlockRampageTempEvents) SET_PED_COMBAT_ATTRIBUTES(pedID, CA_ALWAYS_FLEE, TRUE) OPEN_SEQUENCE_TASK(seqTask) IF (bForceNavMesh) TASK_FOLLOW_NAV_MESH_TO_COORD(NULL, pos, PEDMOVE_RUN, DEFAULT_TIME_NEVER_WARP, DEFAULT_NAVMESH_RADIUS, ENAV_NO_STOPPING ) ELSE TASK_GO_TO_COORD_ANY_MEANS(NULL, pos, PEDMOVE_RUN, NULL) ENDIF TASK_SMART_FLEE_PED(NULL, PLAYER_PED_ID(), 600.0, -1) CLOSE_SEQUENCE_TASK(seqTask) TASK_PERFORM_SEQUENCE(pedID, seqTask) CLEAR_SEQUENCE_TASK(seqTask) FORCE_PED_MOTION_STATE(pedID, MS_ON_FOOT_RUN) ENDPROC /// PURPOSE: /// Hacky function to fix B*1035547 /// PARAMS: /// pedID - ped to do the running /// pos - position to get to PROC RAMPAGE_SMART_FLEE_ATTACK_HACKERY(PED_INDEX pedID, VECTOR pos, FLOAT spd = PEDMOVE_RUN) SET_BLOCKING_OF_NON_TEMPORARY_EVENTS(pedID, bBlockRampageTempEvents) FORCE_PED_MOTION_STATE(pedID, MS_ON_FOOT_RUN) TASK_GO_STRAIGHT_TO_COORD(pedID, pos, spd) ENDPROC /// PURPOSE: /// Assigns a rampage ped his weapons and components /// PARAMS: /// ped - rampage ped reference PROC ASSIGN_RAMPAGE_PED_WEAPON(RAMPAGE_PED &ped) IF IS_PED_IN_ANY_VEHICLE(ped.pedID) GIVE_WEAPON_TO_PED(ped.pedID, WEAPONTYPE_PISTOL, INFINITE_AMMO) SET_PED_INFINITE_AMMO(ped.pedID, TRUE, WEAPONTYPE_PISTOL) ENDIF IF (GET_RANDOM_FLOAT_IN_RANGE() < fEnemySecondWeaponChance) AND (rampageInfo.enemyWeapon[1] <> WEAPONTYPE_INVALID) GIVE_WEAPON_TO_PED(ped.pedID, rampageInfo.enemyWeapon[1], INFINITE_AMMO ) // INFINITE_AMMO SET_PED_INFINITE_AMMO(ped.pedID, TRUE, rampageInfo.enemyWeapon[1]) APPLY_COMBAT_PARAMETERS_TO_PED(ped.pedID, rampageCombatParams, TRUE) ELIF (rampageInfo.enemyWeapon[0] <> WEAPONTYPE_INVALID) GIVE_WEAPON_TO_PED(ped.pedID, rampageInfo.enemyWeapon[0], INFINITE_AMMO ) // INFINITE_AMMO SET_PED_INFINITE_AMMO(ped.pedID, TRUE, rampageInfo.enemyWeapon[0]) APPLY_COMBAT_PARAMETERS_TO_PED(ped.pedID, rampageCombatParams) ENDIF ENDPROC /// PURPOSE: /// Sets up hp, relationship groups and other things for ped /// PARAMS: /// ped - reference to rampage ped PROC SET_RAMAGER_PED_BATTLE_ATTRIBUTES(RAMPAGE_PED &ped, BOOL bAssignWeapon = TRUE) // INT rnd IF NOT IS_PED_UNINJURED(ped.pedID) EXIT ENDIF IF (bAssignWeapon) ASSIGN_RAMPAGE_PED_WEAPON(ped) ENDIF // health and damage ped.fOriginalDist = GET_DISTANCE_BETWEEN_ENTITIES(ped.pedID, PLAYER_PED_ID(), FALSE) SET_PED_RELATIONSHIP_GROUP_HASH(ped.pedID, activeGroup) SET_PED_CAN_BE_TARGETTED(ped.pedID, TRUE) SET_ENTITY_HEALTH(ped.pedID, RAMPAGE_PED_MAXHP) SET_PED_MAX_HEALTH(ped.pedID, RAMPAGE_PED_MAXHP) SET_ENTITY_ONLY_DAMAGED_BY_RELATIONSHIP_GROUP(ped.pedID, TRUE, RELGROUPHASH_PLAYER) SET_PED_PATH_AVOID_FIRE(ped.pedID, TRUE) SET_PED_SUFFERS_CRITICAL_HITS(ped.pedID, TRUE) SET_PED_CAN_BE_TARGETED_WHEN_INJURED(ped.pedID, FALSE) SET_ENTITY_IS_TARGET_PRIORITY(ped.pedID, TRUE) SET_PED_DIES_WHEN_INJURED(ped.pedID, TRUE) SET_PED_PATH_MAY_ENTER_WATER(ped.pedID, FALSE) SET_PED_PATH_PREFER_TO_AVOID_WATER(ped.pedID, TRUE) // SET_PED_DROPS_WEAPONS_WHEN_DEAD(ped.pedID, FALSE) SET_PED_MONEY(ped.pedID, RAMPAGE_PED_MONEY) // flee and combat attributes SET_PED_FLEE_ATTRIBUTES(ped.pedID, FA_USE_COVER, TRUE) SET_PED_COMBAT_ATTRIBUTES(ped.pedID, CA_USE_COVER, TRUE) SET_PED_COMBAT_ATTRIBUTES(ped.pedID, CA_REQUIRES_LOS_TO_SHOOT, TRUE) SET_PED_TARGET_LOSS_RESPONSE(ped.pedID, TLR_NEVER_LOSE_TARGET) SET_PED_COMBAT_ATTRIBUTES(ped.pedID, CA_ENABLE_TACTICAL_POINTS_WHEN_DEFENSIVE, TRUE) //@RJP all rampages should have aggressive enemies SET_PED_COMBAT_ATTRIBUTES(ped.pedID, CA_CAN_CHARGE, TRUE) SET_PED_COMBAT_MOVEMENT(ped.pedID, CM_WILLADVANCE) //@RJP old version, random chance of different combat movements // setup combat movement // rnd = GET_RANDOM_INT_IN_RANGE(0, 4) // SWITCH (rnd) // CASE 0 // SET_PED_COMBAT_MOVEMENT(ped.pedID, CM_DEFENSIVE) // Seeks a defensive position. // BREAK // CASE 1 // SET_PED_COMBAT_MOVEMENT(ped.pedID, CM_WILLADVANCE) // Will advance forward in combat // SET_PED_COMBAT_ATTRIBUTES(ped.pedID, CA_SWITCH_TO_ADVANCE_IF_CANT_FIND_COVER, TRUE) // BREAK // CASE 2 // SET_PED_COMBAT_MOVEMENT(ped.pedID, CM_WILLRETREAT) // Will retreat if the enemy gets too close // SET_PED_COMBAT_ATTRIBUTES(ped.pedID, CA_SWITCH_TO_DEFENSIVE_IF_IN_COVER, TRUE) // BREAK // DEFAULT // SET_PED_COMBAT_ATTRIBUTES(ped.pedID, CA_SWITCH_TO_DEFENSIVE_IF_IN_COVER, TRUE) // BREAK // ENDSWITCH // misc stuff SETUP_SPECIFIC_PED_VOICE_CONTEXT(ped.pedID) REGISTER_HATED_TARGETS_AROUND_PED(ped.pedID, 200.0) SET_PED_MONEY(ped.pedID, RAMPAGE_PED_MONEY) ENDPROC /// PURPOSE: /// Deletes ampage ped - deletes reference and removes blip /// PARAMS: /// ped - reference to rampage ped PROC SHARED_CLEAN_AND_DELETE_RAMPAGE_PED(RAMPAGE_PED &ped) SAFE_REMOVE_BLIP(ped.blipID) ped.blipID = NULL ped.iDeleteTime = 0 ped.fPlayerDist = 0.0 ped.bWasInVehicle = FALSE ped.bIsFleePed = FALSE ped.bMolotovThrower = FALSE ped.sVoice = NULL ped.sContext = NULL ped.iInsultTimer = 0 #IF IS_DEBUG_BUILD ped.bDebugAliveCheck = FALSE #ENDIF // drop the counter that tells us how many people are active IF (ped.iFortIndex <> -1) rampageFort[ped.iFortIndex].iPedCount -- IF (rampageFort[ped.iFortIndex].iPedCount < 0) rampageFort[ped.iFortIndex].iPedCount = 0 ENDIF ped.iFortIndex = -1 ENDIF ENDPROC /// PURPOSE: /// Deletes ampage ped - deletes reference and removes blip /// PARAMS: /// ped - reference to rampage ped PROC DELETE_RAMPAGE_PED(RAMPAGE_PED &ped) IF NOT DOES_ENTITY_EXIST(ped.pedID) EXIT ENDIF SHARED_CLEAN_AND_DELETE_RAMPAGE_PED(ped) SAFE_DELETE_PED(ped.pedID) ped.pedID = NULL ENDPROC /// PURPOSE: /// Cleans up rampage ped - release reference and removes blip /// PARAMS: /// ped - reference to rampage ped /// keepTask - if this is true ped will retain his task after cleanup PROC CLEANUP_RAMPAGE_PED(RAMPAGE_PED &ped, BOOL keepTask = FALSE) IF NOT DOES_ENTITY_EXIST(ped.pedID) EXIT ENDIF // B*650069 - Allows peds who are on roofs to leave once rampage is finished IF IS_ENTITY_ALIVE(ped.pedID) SET_PED_PATH_CAN_USE_CLIMBOVERS(ped.pedID, TRUE) SET_PED_PATH_CAN_USE_LADDERS(ped.pedID, TRUE) SET_PED_PATH_CAN_DROP_FROM_HEIGHT(ped.pedID, TRUE) ENDIF // stop targeting as soon as people are cleaned up SET_BLOCKING_OF_NON_TEMPORARY_EVENTS(ped.pedID, keepTask) // so that they follow orders SET_ENTITY_IS_TARGET_PRIORITY(ped.pedID, FALSE) SET_PED_CAN_BE_TARGETTED(ped.pedID, FALSE) SET_PED_CAN_BE_TARGETED_WITHOUT_LOS(ped.pedID, FALSE) SHARED_CLEAN_AND_DELETE_RAMPAGE_PED(ped) SAFE_RELEASE_PED(ped.pedID, keepTask) ped.pedID = NULL ENDPROC /// PURPOSE: /// Cleans up an entire array of rampage peds /// PARAMS: /// array - reference to ped array /// keepTask - if this is true peds will retain tasks after cleanup PROC CLEANUP_RAMPAGE_PED_ARRAY(RAMPAGE_PED& array[], BOOL keepTask = FALSE) INT i REPEAT COUNT_OF(array) i CLEANUP_RAMPAGE_PED(array[i], keepTask) ENDREPEAT ENDPROC /// PURPOSE: /// Deletes an entire array of rampage peds /// PARAMS: /// array - reference to ped array PROC DELETE_RAMPAGE_PED_ARRAY(RAMPAGE_PED& array[]) INT i REPEAT COUNT_OF(array) i DELETE_RAMPAGE_PED(array[i]) ENDREPEAT ENDPROC PROC FORCE_DELETE_RAMPAGE_PED_ARRAY(RAMPAGE_PED &array[]) // loop through all peds and delete them INT i DELETE_RAMPAGE_PED_ARRAY(array) // then run through the ped scanner and wipe everything within x meters of player INT cnt PED_INDEX pedIndex[32] cnt = GET_PED_NEARBY_PEDS(PLAYER_PED_ID(), pedIndex) IF (cnt = 0) EXIT ENDIF CPRINTLN(DEBUG_MINIGAME, "PEDS SCANNED:", cnt) REPEAT cnt i IF DOES_ENTITY_EXIST(pedIndex[i]) IS_ENTITY_ALIVE(pedIndex[i]) // we need to call this so we don't get an assert we still want to delete dead peds IF IS_PED_ENEMY_PED_MODEL(pedIndex[i]) SAFE_DELETE_PED(pedIndex[i]) ENDIF ENDIF ENDREPEAT ENDPROC /// PURPOSE: /// Cleans up an entire array of rampage peds while making them flee /// PARAMS: /// array - reference to ped array /// keepTask - if this is true peds will retain tasks after cleanup PROC FLEE_RAMPAGE_PED(RAMPAGE_PED &ped) IF NOT DOES_ENTITY_EXIST(ped.pedID) EXIT ENDIF IF IS_PED_UNINJURED(ped.pedID) SET_PED_PATH_CAN_USE_CLIMBOVERS(ped.pedID, TRUE) SET_PED_PATH_CAN_USE_LADDERS(ped.pedID, TRUE) SET_PED_PATH_CAN_DROP_FROM_HEIGHT(ped.pedID, TRUE) CLEAR_PED_TASKS(ped.pedID) SET_BLOCKING_OF_NON_TEMPORARY_EVENTS(ped.pedID, bBlockRampageTempEvents) TASK_SMART_FLEE_PED(ped.pedID, PLAYER_PED_ID(), 400.0, -1) // SET_PED_DROPS_WEAPONS_WHEN_DEAD(ped.pedID, FALSE) SET_PED_MONEY(ped.pedID, RAMPAGE_PED_MONEY) ELSE #IF IS_JAPANESE_BUILD DELETE_RAMPAGE_PED(ped) #ENDIF ENDIF CLEANUP_RAMPAGE_PED(ped, TRUE) ENDPROC /// PURPOSE: /// Cleans up an entire array of rampage peds while making them flee /// PARAMS: /// array - reference to ped array /// keepTask - if this is true peds will retain tasks after cleanup PROC FLEE_RAMPAGE_PED_ARRAY(RAMPAGE_PED& array[]) INT i REPEAT COUNT_OF(array) i FLEE_RAMPAGE_PED(array[i]) ENDREPEAT ENDPROC /// PURPOSE: /// Sets an entire array of rampage peds to go into combat mode /// PARAMS: /// array - reference to ped array PROC FORCE_RAMPAGE_PED_ARRAY_COMBAT(RAMPAGE_PED& array[]) INT i CPRINTLN(DEBUG_RAMPAGE, "RAMPAGE ARRAY IS FORCED INTO COMBAT") REPEAT COUNT_OF(array) i IF IS_PED_UNINJURED(array[i].pedID) IF NOT array[i].bIsFleePed IF NOT IS_PED_IN_ANY_VEHICLE(array[i].pedID) AND (array[i].bIsFleePed = FALSE) TASK_COMBAT_PED(array[i].pedID, PLAYER_PED_ID()) // SET_PED_DROPS_WEAPONS_WHEN_DEAD(array[i].pedID, FALSE) SET_PED_MONEY(array[i].pedID, RAMPAGE_PED_MONEY) ENDIF ENDIF ENDIF ENDREPEAT ENDPROC /// PURPOSE: /// Searches Rampage Ped Array for a free index /// PARAMS: /// ind - this index is written to /// RETURNS: /// true if there is an index free FUNC BOOL GET_FREE_RAMPAGE_PED_INDEX(RAMPAGE_PED& array[], INT &ind) INT i REPEAT COUNT_OF(array) i IF NOT DOES_ENTITY_EXIST(array[i].pedID) ind = i RETURN TRUE ENDIF ENDREPEAT RETURN FALSE ENDFUNC /// PURPOSE: /// Returns number of rampage peds who are alive FUNC INT GET_ALIVE_RAMPAGE_PED_COUNT(RAMPAGE_PED& array[]) INT i INT cnt = 0 REPEAT COUNT_OF(array) i IF IS_PED_UNINJURED(array[i].pedID) #IF IS_DEBUG_BUILD array[i].bDebugAliveCheck = TRUE #ENDIF cnt ++ ELSE #IF IS_DEBUG_BUILD array[i].bDebugAliveCheck = FALSE #ENDIF ENDIF ENDREPEAT RETURN cnt ENDFUNC PROC SET_PED_DEBUG_NAME( PED_INDEX &ped, STRING sName, INT pedIndex ) text_label tdebugname = sName tdebugname += pedIndex SET_PED_NAME_DEBUG(ped, tdebugname) ENDPROC /// PURPOSE: /// Creates a rampage ped at a given position /// PARAMS: /// ped - rampage ped reference /// pos - spawn position /// head - spawn heading /// newvariation - set this to try to force random ped components /// RETURNS: /// true - if successful FUNC BOOL CREATE_RAMPAGER_PED_AT_POSITION(RAMPAGE_PED &ped, VECTOR pos, FLOAT head = 0.0, BOOL newvariation = TRUE) MODEL_NAMES pedModel = GET_RANDOM_RAMPAGE_PED_MODEL() #IF IS_JAPANESE_BUILD IF (GET_RAMPAGE_REMAINING_TIME_IN_MILLISECONDS() < 2000) RETURN FALSE ENDIF #ENDIF ped.pedID = CREATE_PED(PEDTYPE_MISSION, pedModel, pos, head) IF IS_ENTITY_IN_WATER(ped.pedID) CPRINTLN(DEBUG_RAMPAGE, "TRYING TO CREATE PED WHO IS IN WATER") DELETE_RAMPAGE_PED(ped) RETURN FALSE ENDIF SAFE_REMOVE_BLIP(ped.blipID) ped.blipID = CREATE_PED_BLIP(ped.pedID) SET_PED_RELATIONSHIP_GROUP_HASH(ped.pedID, activeGroup) IF (newvariation = TRUE) SET_PED_RANDOM_COMPONENT_VARIATION(ped.pedID) ENDIF SET_ENTITY_COORDS_GROUNDED(ped.pedID, pos) SET_RAMAGER_PED_BATTLE_ATTRIBUTES(ped) IF (head = 0.0) SET_ENTITY_HEADING_FACE_PLAYER(ped.pedID) ENDIF CPRINTLN(DEBUG_RAMPAGE, "Ped ", ped.iIndex ," was created") TASK_COMBAT_PED(ped.pedID, PLAYER_PED_ID()) #IF IS_DEBUG_BUILD SET_PED_DEBUG_NAME( ped.pedID, "RampPed", ped.iIndex ) #ENDIF // SET_PED_DROPS_WEAPONS_WHEN_DEAD(ped.pedID, FALSE) rampageStats.iPedsSpawned ++ iAlivePedCounter ++ ped.bIsFleePed = FALSE ped.bMolotovThrower = FALSE RETURN TRUE ENDFUNC /// PURPOSE: /// Creates a rampage ped from a supplied index (useful for turning ambient peds into rampage peds) /// PARAMS: /// ped - rampage ped reference /// nped - ped index /// flee - should we make this a flee type ped /// newvariation - set this to try to force random ped components /// RETURNS: /// true - if successful FUNC BOOL CREATE_RAMPAGER_PED_FROM_PED_INDEX(RAMPAGE_PED &ped, PED_INDEX &nped, BOOL flee = FALSE, BOOL newvariation = TRUE, BOOL newTask = TRUE) IF IS_ENTITY_IN_WATER(nped) CPRINTLN(DEBUG_RAMPAGE, "TRYING TO GRAB PED WHO IS IN WATER") RETURN FALSE ENDIF ped.pedID = nped SAFE_REMOVE_BLIP(ped.blipID) ped.blipID = CREATE_PED_BLIP(ped.pedID) FREEZE_ENTITY_POSITION(ped.pedID, FALSE) SET_ENTITY_COLLISION(ped.pedID, TRUE) SET_PED_RELATIONSHIP_GROUP_HASH(ped.pedID, activeGroup) IF (newvariation = TRUE) SET_PED_RANDOM_COMPONENT_VARIATION(ped.pedID) ENDIF SET_PED_CAN_BE_TARGETTED(ped.pedID, TRUE) SET_RAMAGER_PED_BATTLE_ATTRIBUTES(ped) SET_BLOCKING_OF_NON_TEMPORARY_EVENTS(ped.pedID, TRUE) IF (newTask = TRUE) IF (flee = FALSE) #IF IS_DEBUG_BUILD SET_PED_DEBUG_NAME( ped.pedID, "RampPed", ped.iIndex ) #ENDIF TASK_COMBAT_PED(ped.pedID, PLAYER_PED_ID()) ELSE #IF IS_DEBUG_BUILD SET_PED_DEBUG_NAME( ped.pedID, "RampFlee", ped.iIndex ) #ENDIF ped.bIsFleePed = TRUE SET_PED_COMBAT_ATTRIBUTES(ped.pedID, CA_ALWAYS_FLEE, TRUE) TASK_SMART_FLEE_PED(ped.pedID, PLAYER_PED_ID(), 600.0, -1) ENDIF ELSE IF (flee = TRUE) #IF IS_DEBUG_BUILD SET_PED_DEBUG_NAME( ped.pedID, "RampFlee", ped.iIndex ) #ENDIF ped.bIsFleePed = TRUE ENDIF ENDIF rampageStats.iPedsSpawned ++ iAlivePedCounter ++ ped.bIsFleePed = flee RETURN TRUE ENDFUNC /// PURPOSE: /// Creates a rampage flee ped at a given position /// PARAMS: /// ped - rampage ped reference /// pos - spawn position /// head - spawn heading /// newvariation - set this to try to force random ped components /// RETURNS: /// true - if successful FUNC BOOL CREATE_RAMPAGER_FLEE_PED_AT_POSITION(RAMPAGE_PED &ped, VECTOR pos, FLOAT head = 0.0, BOOL newvariation = TRUE) BOOL boolok MODEL_NAMES pedModel = GET_RANDOM_RAMPAGE_PED_MODEL() #IF IS_JAPANESE_BUILD IF (GET_RAMPAGE_REMAINING_TIME_IN_MILLISECONDS() < 2000) RETURN FALSE ENDIF #ENDIF ped.pedID = CREATE_PED(PEDTYPE_MISSION, pedModel, pos, head) IF IS_ENTITY_IN_WATER(ped.pedID) CPRINTLN(DEBUG_RAMPAGE, "TRYING TO CREATED PED IN WATER - NAH MATE") DELETE_RAMPAGE_PED(ped) RETURN FALSE ENDIF SAFE_REMOVE_BLIP(ped.blipID) ped.blipID = CREATE_PED_BLIP(ped.pedID) SET_PED_RELATIONSHIP_GROUP_HASH(ped.pedID, activeGroup) IF (newvariation = TRUE) SET_PED_RANDOM_COMPONENT_VARIATION(ped.pedID) ENDIF REMOVE_ALL_PED_WEAPONS(ped.pedID) SET_ENTITY_COORDS_GROUNDED(ped.pedID, pos) SET_PED_MONEY(ped.pedID, RAMPAGE_PED_MONEY) // SET_PED_DROPS_WEAPONS_WHEN_DEAD(ped.pedID, FALSE) SET_ENTITY_HEALTH(ped.pedID, RAMPAGE_PED_MAXHP) SET_PED_MAX_HEALTH(ped.pedID, RAMPAGE_PED_MAXHP) SET_PED_CAN_BE_TARGETED_WHEN_INJURED(ped.pedID, FALSE) SET_ENTITY_IS_TARGET_PRIORITY(ped.pedID, TRUE) SET_ENTITY_ONLY_DAMAGED_BY_RELATIONSHIP_GROUP(ped.pedID, TRUE, RELGROUPHASH_PLAYER) SET_BLOCKING_OF_NON_TEMPORARY_EVENTS(ped.pedID, FALSE) SET_PED_FLEE_ATTRIBUTES(ped.pedID, FA_USE_COVER, TRUE) SET_PED_FLEE_ATTRIBUTES(ped.pedID, FA_WANDER_AT_END, TRUE) SET_PED_FLEE_ATTRIBUTES(ped.pedID, FA_CAN_SCREAM, TRUE) SET_PED_COMBAT_ATTRIBUTES(ped.pedID, CA_USE_COVER, TRUE) boolok = TRUE SET_PED_COMBAT_ATTRIBUTES(ped.pedID, CA_JUST_SEEK_COVER, boolok) SET_PED_COMBAT_ATTRIBUTES(ped.pedID, CA_ALWAYS_FLEE, boolok) //TASK_WANDER_STANDARD(ped.pedID) TASK_SMART_FLEE_PED(ped.pedID, PLAYER_PED_ID(), 600.0, -1) rampageStats.iPedsSpawned ++ iAlivePedCounter ++ #IF IS_DEBUG_BUILD SET_PED_DEBUG_NAME( ped.pedID, "RampFlee", ped.iIndex ) #ENDIF SETUP_SPECIFIC_PED_VOICE_CONTEXT(ped.pedID) SET_PED_ACCURACY(ped.pedID, 2) SET_PED_COMBAT_ABILITY(ped.pedID, CAL_POOR) ped.bIsFleePed = TRUE RETURN TRUE ENDFUNC /// PURPOSE: /// Creates a rampage ped at a rampage spawn point /// PARAMS: /// ped - rampage ped reference /// sp - spawn point variable /// newvariation - set this to try to force random ped components /// RETURNS: /// true - if successful FUNC BOOL CREATE_RAMPAGER_PED_AT_SPAWN_POINT(RAMPAGE_PED &ped, RAMPAGE_SPAWNPOINT sp, BOOL newvariation = TRUE, BOOL occuldeCheck = FALSE) // check if entity would be visible - just check against pedmodel 0 as most peds are about the same size IF (occuldeCheck = TRUE) IF NOT WOULD_ENTITY_BE_OCCLUDED(rampageInfo.pedModels[0], sp.vPosition) RETURN FALSE ENDIF ENDIF // create the ped IF NOT CREATE_RAMPAGER_PED_AT_POSITION(ped, sp.vPosition, sp.fHeading, newvariation) RETURN FALSE ENDIF // stop people from using climbovers and ladders if spawn point is aerial IF (sp.bIsAerial = TRUE) SET_PED_PATH_CAN_USE_CLIMBOVERS(ped.pedID, FALSE) SET_PED_PATH_CAN_USE_LADDERS(ped.pedID, FALSE) SET_PED_PATH_CAN_DROP_FROM_HEIGHT(ped.pedID, FALSE) SET_PED_COMBAT_ATTRIBUTES(ped.pedID, CA_CAN_CHARGE, FALSE) SET_PED_SPHERE_DEFENSIVE_AREA(ped.pedID, sp.vPosition, 2.0) SET_PED_COMBAT_MOVEMENT(ped.pedID, CM_STATIONARY) ELSE SET_PED_PATH_CAN_USE_CLIMBOVERS(ped.pedID, TRUE) SET_PED_PATH_CAN_USE_LADDERS(ped.pedID, TRUE) SET_PED_PATH_CAN_DROP_FROM_HEIGHT(ped.pedID, TRUE) SET_PED_DEFENSIVE_SPHERE_ATTACHED_TO_PED(ped.pedID, PLAYER_PED_ID(), <<0, 0, 0>>, GET_RANDOM_FLOAT_IN_RANGE(10.0, 25.0), FALSE) ENDIF TASK_COMBAT_PED(ped.pedID, PLAYER_PED_ID()) SET_PED_MONEY(ped.pedID, RAMPAGE_PED_MONEY) // SET_PED_DROPS_WEAPONS_WHEN_DEAD(ped.pedID, FALSE) RETURN TRUE ENDFUNC /// PURPOSE: /// Creates a rampage ped in a vehicle and assigns him a seat /// PARAMS: /// ped - rampage ped reference /// veh - vehicle index /// RETURNS: /// true on success FUNC BOOL CREATE_RAMPAGE_PED_IN_VEHICLE(RAMPAGE_PED &ped, VEHICLE_INDEX veh) MODEL_NAMES pedModel = GET_RANDOM_RAMPAGE_PED_MODEL() ped.pedID = CREATE_PED_INSIDE_VEHICLE_AUTO_SEAT(pedModel, veh, WEAPONTYPE_PISTOL, TRUE, bBlockRampageTempEvents) IF NOT IS_ENTITY_ALIVE(ped.pedID) RETURN FALSE ENDIF ped.bIsFleePed = FALSE ped.bMolotovThrower = FALSE SET_RAMAGER_PED_BATTLE_ATTRIBUTES(ped, NOT IS_PED_IN_ANY_HELI(ped.pedID)) SET_BLOCKING_OF_NON_TEMPORARY_EVENTS(ped.pedID, bBlockRampageTempEvents) REGISTER_HATED_TARGETS_AROUND_PED(ped.pedID, 200.0) SET_PED_MONEY(ped.pedID, RAMPAGE_PED_MONEY) // SET_PED_DROPS_WEAPONS_WHEN_DEAD(ped.pedID, FALSE) rampageStats.iPedsSpawned ++ iAlivePedCounter ++ ped.bWasInVehicle = FALSE // we set this to false initially as the update handles blipping now CPRINTLN(DEBUG_RAMPAGE, "Ped ", ped.iIndex ," is created in vehicle") #IF IS_DEBUG_BUILD SET_PED_DEBUG_NAME( ped.pedID, "RampCar", ped.iIndex ) #ENDIF RETURN TRUE ENDFUNC /// PURPOSE: /// Creates a rampage ped and ties him to rampage fortress /// PARAMS: /// fort - rampage fortress reference /// pos - spawn position /// iFortIndex - index of the fortress /// newvariation - set this to try to force random ped components /// RETURNS: /// true - if successful FUNC BOOL CREATE_RAMPAGER_PED_IN_FORTRESS_AT_POSITION(RAMPAGE_FORTRESS &fort, VECTOR pos, INT iFortIndex = -1, BOOL newvariation = TRUE) INT ind IF NOT GET_FREE_RAMPAGE_PED_INDEX(rampagePed, ind) RETURN FALSE ENDIF IF NOT CREATE_RAMPAGER_PED_AT_POSITION(rampagePed[ind], pos, GET_RANDOM_FLOAT_IN_RANGE() * 360.0, newvariation) RETURN FALSE ENDIF //@RJP all peds should advance on player from fortresses, NO HANGING BACK! Commenting out old system SET_PED_DEFENSIVE_SPHERE_ATTACHED_TO_PED(rampagePed[ind].pedID, PLAYER_PED_ID(), <>, GET_RANDOM_FLOAT_IN_RANGE(10.0, 25.0)) // IF (GET_RANDOM_FLOAT_IN_RANGE() < fort.fRushFactor) // SET_PED_DEFENSIVE_SPHERE_ATTACHED_TO_PED(rampagePed[ind].pedID, PLAYER_PED_ID(), <>, GET_RANDOM_FLOAT_IN_RANGE(15.0, 40.0)) // ELSE // SET_PED_ANGLED_DEFENSIVE_AREA(rampagePed[ind].pedID, fort.defenseArea.vPosition[0], fort.defenseArea.vPosition[1], fort.defenseArea.fWidth * 1.5) // ENDIF IF (fort.fRoofHeight > 0.0) IF (pos.z >= fort.fRoofHeight) SET_PED_PATH_CAN_USE_CLIMBOVERS(rampagePed[ind].pedID, FALSE) SET_PED_PATH_CAN_USE_LADDERS(rampagePed[ind].pedID, FALSE) SET_PED_PATH_CAN_DROP_FROM_HEIGHT(rampagePed[ind].pedID, FALSE) ENDIF ELSE // let some people have a secondary defense area IF (GET_RANDOM_FLOAT_IN_RANGE() < 0.5) SET_PED_DEFENSIVE_SPHERE_ATTACHED_TO_PED(rampagePed[ind].pedID, PLAYER_PED_ID(), <<0, 0, 0>>, GET_RANDOM_FLOAT_IN_RANGE(5.0, 20.0), TRUE) ENDIF ENDIF // mark the rampage ped as belonging to a fortress rampagePed[ind].iFortIndex = iFortIndex fort.iPedCount ++ fort.iSpawnedCount ++ // handle increased spawn count and auto shutdown of fortress when enough peds have been spawned IF (fort.iSpawnedCount >= fort.iMaxSpawnCount) fort.iSpawnedCount = 0 fort.bIsActive = FALSE IF (fort.iNextFortress <> -1) rampageFort[fort.iNextFortress].bIsActive = TRUE rampageFort[fort.iNextFortress].iSpawnedCount = 0 IF (rampageFort[fort.iNextFortress].iMaxActivePeds <> -1) iMaxActivePeds = rampageFort[fort.iNextFortress].iMaxActivePeds ENDIF ENDIF ENDIF SET_PED_MONEY(rampagePed[ind].pedID, RAMPAGE_PED_MONEY) // SET_PED_DROPS_WEAPONS_WHEN_DEAD(rampagePed[ind].pedID, FALSE) RETURN TRUE ENDFUNC /// PURPOSE: /// Updates rampage ped - handles auto cleanup and blip switching /// PARAMS: /// ped - reference to rampage ped PROC UPDATE_RAMPAGE_PED(RAMPAGE_PED &ped) VECTOR pos BOOL inCar IF NOT DOES_ENTITY_EXIST(ped.pedID) EXIT ENDIF IF IS_PED_INJURED(ped.pedID) OR IS_ENTITY_DEAD(ped.pedID) CPRINTLN(DEBUG_RAMPAGE, "Ped ", ped.iIndex ," is dead or injured") #IF IS_JAPANESE_BUILD IF GET_GAME_TIMER() > (GET_PED_TIME_OF_DEATH(ped.pedID)+2000) DELETE_RAMPAGE_PED( ped ) ENDIF #ENDIF #IF NOT IS_JAPANESE_BUILD CLEANUP_RAMPAGE_PED(ped) #ENDIF EXIT ENDIF // just incase we fall through the world pos = GET_ENTITY_COORDS(ped.pedID) IF (pos.z < -10.0) CPRINTLN(DEBUG_RAMPAGE, "Ped ", ped.iIndex ," feel through the world") CLEANUP_RAMPAGE_PED(ped) EXIT ENDIF //Run hipster insults RAMPAGE2_HIPSTER_INSULTS( ped ) //@RJP check if player is in ragdoll (most likely from being hit by car) and set accuracy low when player in ragdoll //also lower accuracy if the tank is alive IF rampageInfo.blipNameEnum = STATIC_BLIP_MINIGAME_RAMPAGE5 AND IS_ENTITY_ALIVE(rampageTank.vehicleID) IF GET_COMBAT_FLOAT( ped.pedID, CCF_WEAPON_ACCURACY ) != TANK_ALIVE_AIM SET_COMBAT_FLOAT( ped.pedID, CCF_WEAPON_ACCURACY, TANK_ALIVE_AIM ) ENDIF ELIF IS_PED_RAGDOLL( PLAYER_PED_ID() ) IF GET_COMBAT_FLOAT( ped.pedID, CCF_WEAPON_ACCURACY ) != PLAYER_IN_RAGDOLL_AIM SET_COMBAT_FLOAT( ped.pedID, CCF_WEAPON_ACCURACY, PLAYER_IN_RAGDOLL_AIM ) ENDIF ELSE IF GET_COMBAT_FLOAT( ped.pedID, CCF_WEAPON_ACCURACY ) = PLAYER_IN_RAGDOLL_AIM WEAPON_TYPE wtCurrentWeapon IF GET_CURRENT_PED_WEAPON( ped.pedID, wtCurrentWeapon ) IF wtCurrentWeapon = rampageInfo.enemyWeapon[1] SET_COMBAT_FLOAT( ped.pedID, CCF_WEAPON_ACCURACY, rampageCombatParams.fWeaponAccuracy2 ) ELSE SET_COMBAT_FLOAT( ped.pedID, CCF_WEAPON_ACCURACY, rampageCombatParams.fWeaponAccuracy1 ) ENDIF ENDIF ENDIF ENDIF IF IS_PED_IN_ANY_VEHICLE(ped.pedID) ped.fPlayerDist = GET_DISTANCE_BETWEEN_ENTITIES(GET_VEHICLE_PED_IS_IN(ped.pedID), PLAYER_PED_ID(), FALSE) ELSE ped.fPlayerDist = GET_DISTANCE_BETWEEN_ENTITIES(ped.pedID, PLAYER_PED_ID(), FALSE) ENDIF IF ped.bMolotovThrower IF ped.fPlayerDist < 25 AND IS_ENTITY_ON_SCREEN( ped.pedID ) SEQUENCE_INDEX seq GIVE_WEAPON_TO_PED( ped.pedID, WEAPONTYPE_MOLOTOV, 4, TRUE, TRUE ) SET_BLOCKING_OF_NON_TEMPORARY_EVENTS( ped.pedID, TRUE ) PLAY_PED_AMBIENT_SPEECH_NATIVE(ped.pedID, sVoiceContext, "SPEECH_PARAMS_FORCE") CLEAR_PED_TASKS( ped.pedID ) OPEN_SEQUENCE_TASK( seq ) TASK_THROW_PROJECTILE( NULL, GET_ENTITY_COORDS(PLAYER_PED_ID())) TASK_SWAP_WEAPON( NULL, TRUE ) TASK_SET_BLOCKING_OF_NON_TEMPORARY_EVENTS( NULL, FALSE ) TASK_COMBAT_PED( NULL, PLAYER_PED_ID() ) CLOSE_SEQUENCE_TASK( seq ) TASK_PERFORM_SEQUENCE( ped.pedID, seq ) CLEAR_SEQUENCE_TASK( seq ) ped.bMolotovThrower = FALSE ENDIF ENDIF IF (ped.bWasInVehicle = FALSE) IF IS_PED_IN_ANY_VEHICLE(ped.pedID) SAFE_REMOVE_BLIP(ped.blipID) IF IS_PED_SITTING_IN_VEHICLE_SEAT( ped.pedID, GET_VEHICLE_PED_IS_IN(ped.pedID), VS_DRIVER ) ped.blipID = CREATE_VEHICLE_BLIP(GET_VEHICLE_PED_IS_IN(ped.pedID), FALSE) ENDIF ped.bWasInVehicle = TRUE EXIT ENDIF ENDIF IF (ped.bWasInVehicle = TRUE) IF NOT IS_PED_IN_ANY_VEHICLE(ped.pedID) SAFE_REMOVE_BLIP(ped.blipID) ped.blipID = CREATE_PED_BLIP(ped.pedID) ped.bWasInVehicle = FALSE ped.fOriginalDist = ped.fPlayerDist CPRINTLN(DEBUG_RAMPAGE, "Ped ", ped.iIndex ," left is vehicle - Resetting Original Distance:", ped.fOriginalDist) TASK_COMBAT_PED(ped.pedID, PLAYER_PED_ID()) EXIT ENDIF ENDIF IF (ped.bIsFleePed) inCar = IS_PED_IN_ANY_VEHICLE(PLAYER_PED_ID()) IF (NOT inCar AND (ped.fPlayerDist > ped.fOriginalDist + 40.0)) OR (inCar AND (ped.fPlayerDist > (PED_CLEANUP_DISTANCE * 2.0))) IF NOT IS_ENTITY_ON_SCREEN(ped.pedID) CPRINTLN(DEBUG_RAMPAGE, "Flee Ped ", ped.iIndex ," is being deleted for being too far away") DELETE_RAMPAGE_PED(ped) ELSE #IF IS_JAPANESE_BUILD DELETE_RAMPAGE_PED(ped) #ENDIF #IF NOT IS_JAPANESE_BUILD CLEANUP_RAMPAGE_PED(ped,TRUE) #ENDIF ENDIF ENDIF ELSE // handle deleting fleeing peds IF (ped.bWasInVehicle = FALSE) AND (ped.fPlayerDist > ped.fOriginalDist + PED_CLEANUP_DISTANCE) IF NOT IS_ENTITY_ON_SCREEN(ped.pedID) CPRINTLN(DEBUG_RAMPAGE, "Ped ", ped.iIndex ," is being deleted for being too far away") DELETE_RAMPAGE_PED(ped) ENDIF ENDIF ENDIF ENDPROC /// PURPOSE: /// Updates rampage ped array PROC UPDATE_RAMPAGE_PEDS(RAMPAGE_PED& array[]) INT i REPEAT 5 i UPDATE_RAMPAGE_PED(array[iCurrentRampagePedIndex]) iCurrentRampagePedIndex ++ IF (iCurrentRampagePedIndex >= COUNT_OF(array)) iCurrentRampagePedIndex = 0 ENDIF ENDREPEAT ENDPROC //---------------------- // CAR FUNCTIONS //---------------------- /// PURPOSE: /// Sets a ped to optionally hold a defense perimeter around a vehicle /// PARAMS: /// pass - ped index /// veh - car to defend PROC SET_RAMPAGE_PED_CAR_DEFENDER(PED_INDEX pass, VEHICLE_INDEX veh=NULL) FLOAT x, y SET_PED_COMBAT_ATTRIBUTES(pass, CA_LEAVE_VEHICLES, TRUE) SET_PED_COMBAT_ATTRIBUTES(pass, CA_USE_VEHICLE, FALSE) SET_PED_COMBAT_ATTRIBUTES(pass, CA_USE_COVER, TRUE) x = GET_RANDOM_FLOAT_IN_RANGE(-30.0, 30.0) y = GET_RANDOM_FLOAT_IN_RANGE(-30.0, 30.0) SET_PED_DEFENSIVE_SPHERE_ATTACHED_TO_PED(pass, PLAYER_PED_ID(), <<0, 0, 0>>, GET_RANDOM_FLOAT_IN_RANGE(20.0, 30.0), TRUE) IF (GET_RANDOM_FLOAT_IN_RANGE() < fCarDefenseAreaChance) AND IS_ENTITY_ALIVE(veh) SET_PED_SPHERE_DEFENSIVE_AREA(pass, GET_ENTITY_COORDS(veh), GET_RANDOM_FLOAT_IN_RANGE(10.0, 25.0)) SET_PED_COMBAT_ATTRIBUTES(pass, CA_OPEN_COMBAT_WHEN_DEFENSIVE_AREA_IS_REACHED, TRUE) ELSE SET_PED_DEFENSIVE_SPHERE_ATTACHED_TO_PED(pass, PLAYER_PED_ID(), <>, GET_RANDOM_FLOAT_IN_RANGE(30.0, 80.0)) ENDIF IF (rampageInfo.blipNameEnum <> STATIC_BLIP_MINIGAME_RAMPAGE2) AND (IS_PED_IN_ANY_HELI(PLAYER_PED_ID()) OR IS_PED_IN_ANY_PLANE(PLAYER_PED_ID())) IF (GET_RANDOM_FLOAT_IN_RANGE() <= fPissTakeRocketChance) GIVE_WEAPON_TO_PED(pass, WEAPONTYPE_RPG, 60) ENDIF ENDIF SEQUENCE_INDEX seq OPEN_SEQUENCE_TASK(seq) TASK_LEAVE_ANY_VEHICLE(NULL, 0, ECF_DONT_CLOSE_DOOR) TASK_COMBAT_PED(NULL, PLAYER_PED_ID()) CLOSE_SEQUENCE_TASK(seq) TASK_PERFORM_SEQUENCE(pass,seq) CLEAR_SEQUENCE_TASK(seq) ENDPROC /// PURPOSE: /// Gets a random car model from the ones we are allowed to use /// RETURNS: /// Car Model FUNC MODEL_NAMES GET_RANDOM_RAMPAGE_CAR_MODEL() IF (rampageInfo.iMaxCarModels = 0) SCRIPT_ASSERT("NO RAMPAGE CAR MODELS DEFINED!!") RETURN DUMMY_MODEL_FOR_SCRIPT ENDIF RETURN rampageInfo.carModels[GET_RANDOM_INT_IN_RANGE(0, rampageInfo.iMaxCarModels)] ENDFUNC /// PURPOSE: /// Gets free cover car index /// PARAMS: /// ind - new index reference (this is overwritten) /// RETURNS: /// true on success FUNC BOOL GET_FREE_COVER_CAR_INDEX(INT &ind) INT i REPEAT COUNT_OF(coverCar) i IF NOT DOES_ENTITY_EXIST(coverCar[i]) ind = i RETURN TRUE ENDIF ENDREPEAT RETURN FALSE ENDFUNC /// PURPOSE: /// Creates a cover vehicle /// PARAMS: /// mdl - model name /// pos - position /// head - heading PROC CREATE_COVER_CAR(MODEL_NAMES mdl, VECTOR pos, FLOAT head) INT ind IF NOT GET_FREE_COVER_CAR_INDEX(ind) EXIT ENDIF coverCar[ind] = CREATE_VEHICLE(mdl, pos, head) SET_ENTITY_ONLY_DAMAGED_BY_PLAYER(coverCar[ind], TRUE) //SET_VEHICLE_DOORS_LOCKED(coverCar[ind], VEHICLELOCK_LOCKED) ENDPROC /// PURPOSE: /// Sets a supplied vehicle index as a cover vehicle /// PARAMS: /// veh - vehicle index /// RETURNS: /// true on success FUNC BOOL SET_AS_COVER_CAR(VEHICLE_INDEX veh) INT ind INT i IF NOT IS_ENTITY_ALIVE(veh) RETURN FALSE ENDIF IF NOT GET_FREE_COVER_CAR_INDEX(ind) RETURN FALSE ENDIF i = 0 REPEAT COUNT_OF(coverCar) i IF IS_ENTITY_ALIVE(coverCar[i]) AND (coverCar[i] = veh) RETURN TRUE ENDIF ENDREPEAT coverCar[ind] = veh SET_ENTITY_ONLY_DAMAGED_BY_PLAYER(coverCar[ind], TRUE) CPRINTLN(DEBUG_RAMPAGE, "VEHICLE SET AS COVER VEHICLE") SET_VEHICLE_DOORS_LOCKED(coverCar[ind], VEHICLELOCK_UNLOCKED) RETURN TRUE ENDFUNC /// PURPOSE: /// Releases all cover cars PROC CLEANUP_COVER_CARS() INT i REPEAT COUNT_OF(coverCar) i IF DOES_ENTITY_EXIST(coverCar[i]) IF IS_ENTITY_ALIVE(coverCar[i]) SET_VEHICLE_DOORS_LOCKED(coverCar[i], VEHICLELOCK_UNLOCKED) SET_ENTITY_ONLY_DAMAGED_BY_PLAYER(coverCar[i], FALSE) ENDIF SAFE_RELEASE_VEHICLE(coverCar[i]) coverCar[i] = NULL ENDIF ENDREPEAT ENDPROC /// PURPOSE: /// Updates all cover cars PROC UPDATE_COVER_CARS() INT i = 0 iAliveCoverCarCounter = 0 DUMMY_REFERENCE_INT(iAliveCoverCarCounter) REPEAT COUNT_OF(coverCar) i IF DOES_ENTITY_EXIST(coverCar[i]) IF IS_ENTITY_DEAD(coverCar[i]) REGISTER_CAR_DEATH(coverCar[i], FALSE) SAFE_RELEASE_VEHICLE(coverCar[i]) CPRINTLN(DEBUG_RAMPAGE, "COVER VEHICLE ", i, " RELEASED") coverCar[i] = NULL ELSE iAliveCoverCarCounter ++ ENDIF ENDIF ENDREPEAT ENDPROC /// PURPOSE: /// Returns number of rampage cars who are alive FUNC INT GET_ALIVE_RAMPAGE_CAR_COUNT() INT i = 0 INT cnt = 0 REPEAT COUNT_OF(rampageCar) i IF IS_ENTITY_ALIVE(rampageCar[i].carID) #IF IS_DEBUG_BUILD rampageCar[i].bDebugAliveCheck = TRUE #ENDIF cnt ++ ELSE #IF IS_DEBUG_BUILD rampageCar[i].bDebugAliveCheck = FALSE #ENDIF ENDIF ENDREPEAT RETURN cnt ENDFUNC /// PURPOSE: /// Searches Rampage Car Array for a free index /// PARAMS: /// ind - this index is written to /// RETURNS: /// true if there is an index free FUNC BOOL GET_FREE_RAMPAGE_CAR_INDEX(INT &out) INT i = 0 REPEAT COUNT_OF(rampageCar) i IF NOT DOES_ENTITY_EXIST(rampageCar[i].carID) out = i RETURN TRUE ENDIF ENDREPEAT RETURN FALSE ENDFUNC /// PURPOSE: /// Cleans up rampage car - release reference and kick everyone out vehicle /// PARAMS: /// car - reference to rampage car PROC CLEANUP_RAMPAGE_CAR(RAMPAGE_CAR &car) INT i IF NOT DOES_ENTITY_EXIST(car.carID) EXIT ENDIF // at this point we release any people that happen to be in the car and set them into combat state IF (sFormState = SFR_RAMPAGEON) REPEAT COUNT_OF (car.iOccupantIndex) i IF (car.iOccupantIndex[i] <> -1) IF IS_ENTITY_ALIVE(rampagePed[car.iOccupantIndex[i]].pedID) SET_PED_COMBAT_ATTRIBUTES(rampagePed[car.iOccupantIndex[i]].pedID, CA_LEAVE_VEHICLES, TRUE) SET_PED_COMBAT_ATTRIBUTES(rampagePed[car.iOccupantIndex[i]].pedID, CA_USE_VEHICLE, FALSE) IF (rampagePed[car.iOccupantIndex[i]].fPlayerDist > 120.0) CLEANUP_RAMPAGE_PED(rampagePed[car.iOccupantIndex[i]]) car.iOccupantIndex[i] = -1 ELSE // TASK_COMBAT_PED(rampagePed[car.iOccupantIndex[i]].pedID, PLAYER_PED_ID()) SET_RAMPAGE_PED_CAR_DEFENDER(rampagePed[car.iOccupantIndex[i]].pedID, car.carID) CPRINTLN(DEBUG_RAMPAGE, "Ped ", rampagePed[car.iOccupantIndex[i]].iIndex ," was in a car that has been cleanup - enter combat") car.iOccupantIndex[i] = -1 ENDIF ELSE IF (i = 0) CPRINTLN(DEBUG_RAMPAGE, "Car ", car.iIndex ," appears to have a dead driver") car.iOccupantIndex[i] = -1 ENDIF ENDIF ENDIF ENDREPEAT i = 0 REPEAT COUNT_OF (car.iOccupantIndex) i car.iOccupantIndex[i] = -1 ENDREPEAT // try and keep car as cover or release it IF IS_ENTITY_ALIVE(car.carID) //Turn off leaking petrol SET_VEHICLE_CAN_LEAK_PETROL( car.carID, FALSE ) IF (car.bKeepAsCover = TRUE) IF SET_AS_COVER_CAR(car.carID) CPRINTLN(DEBUG_RAMPAGE, "Car ", car.iIndex ," has been set as cover car") car.carID = NULL EXIT ENDIF ENDIF ENDIF ELSE CPRINTLN(DEBUG_RAMPAGE, "Post Rampage Car ", car.iIndex ," has been cleaned up") REPEAT COUNT_OF (car.iOccupantIndex) i IF (car.iOccupantIndex[i] <> -1) IF IS_ENTITY_ALIVE(rampagePed[car.iOccupantIndex[i]].pedID) TASK_SMART_FLEE_COORD(rampagePed[car.iOccupantIndex[i]].pedID, GET_ENTITY_COORDS(car.carID), 200.0, -1) CPRINTLN(DEBUG_RAMPAGE, "Rampage Ped ", car.iOccupantIndex[i], "is Fleeing Car ", car.iIndex) CLEANUP_RAMPAGE_PED(rampagePed[car.iOccupantIndex[i]], TRUE) ENDIF car.iOccupantIndex[i] = -1 ENDIF ENDREPEAT ENDIF CPRINTLN(DEBUG_RAMPAGE, "Car ", car.iIndex ," has been cleaned up") SAFE_RELEASE_VEHICLE(car.carID) car.carID = NULL ENDPROC /// PURPOSE: /// Deleter up rampage car - release reference and kick everyone out vehicle /// PARAMS: /// car - reference to rampage car PROC DELETE_RAMPAGE_CAR(RAMPAGE_CAR &car) IF NOT DOES_ENTITY_EXIST(car.carID) EXIT ENDIF INT i REPEAT COUNT_OF (car.iOccupantIndex) i car.iOccupantIndex[i] = -1 ENDREPEAT CPRINTLN(DEBUG_RAMPAGE, "Car ", car.iIndex ," has been cleaned up") SAFE_DELETE_VEHICLE(car.carID) car.carID = NULL ENDPROC /// PURPOSE: /// Creates a rampage car /// PARAMS: /// car - Rampage Car Reference /// mdl - Model Name /// pos - Position /// head - Heading /// keepcov - Set this as cover car on cleanup /// nPass - force the # of passengers set this to -1 if you don't care /// RETURNS: /// true on success FUNC BOOL CREATE_RAMPAGE_CAR(RAMPAGE_CAR &car, MODEL_NAMES mdl, VECTOR pos, FLOAT head = 0.0, BOOL keepcov = TRUE, INT nPass = -1) INT i INT cnt INT dridx IF (mdl = DUMMY_MODEL_FOR_SCRIPT) RETURN FALSE ENDIF IF (iAlivePedCounter >= iMaxActivePeds) #IF IS_DEBUG_BUILD IF (bDebugShowTTY) CPRINTLN(DEBUG_RAMPAGE, "CREATE RAMPAGE CAR - NO DRIVERS FREE") ENDIF #ENDIF RETURN FALSE ENDIF #IF IS_JAPANESE_BUILD IF (GET_RAMPAGE_REMAINING_TIME_IN_MILLISECONDS() < 2000) RETURN FALSE ENDIF #ENDIF // check we at least have a driver available IF NOT GET_FREE_RAMPAGE_PED_INDEX(rampagePed, dridx) #IF IS_DEBUG_BUILD IF (bDebugShowTTY) CPRINTLN(DEBUG_RAMPAGE, "CREATE RAMPAGE CAR - NO DRIVERS FREE") ENDIF #ENDIF RETURN FALSE ENDIF // B*1032585 - Don't create vehicle if there is one within 10m of it. IF IS_SPHERE_OCCUPIED(pos, 8.0, FALSE, TRUE, FALSE, FALSE, FALSE) #IF IS_DEBUG_BUILD IF (bDebugShowTTY) CPRINTLN(DEBUG_RAMPAGE, "CREATE RAMPAGE CAR - FAILED THERE IS A VEHICLE HERE") ENDIF #ENDIF RETURN FALSE ENDIF // create car car.carID = CREATE_VEHICLE(mdl, pos, head) IF NOT DOES_ENTITY_EXIST(car.carID) #IF IS_DEBUG_BUILD IF (bDebugShowTTY) CPRINTLN(DEBUG_RAMPAGE, "CREATE RAMPAGE CAR - VEHICLE NOT CREATED") ENDIF #ENDIF RETURN FALSE ENDIF SET_ENTITY_HEALTH( car.carID, 600 ) SET_VEHICLE_PETROL_TANK_HEALTH( car.carID, 600 ) SET_VEHICLE_ENGINE_HEALTH( car.carID, 600 ) SET_ENTITY_ONLY_DAMAGED_BY_PLAYER(car.carID, TRUE) // B*2012758 - Init occupant indicies i = 0 REPEAT COUNT_OF (car.iOccupantIndex) i car.iOccupantIndex[i] = -1 ENDREPEAT // rampage specific vehicle creation SWITCH rampageInfo.blipNameEnum CASE STATIC_BLIP_MINIGAME_RAMPAGE1 nPass = GET_RANDOM_INT_IN_RANGE(1, 2) SET_VEHICLE_DIRT_LEVEL(car.carID, GET_RANDOM_FLOAT_IN_RANGE(10.0, 14.9)) IF mdl = rampageInfo.carModels[0] SET_ENTITY_HEALTH( car.carID, 200 ) SET_VEHICLE_PETROL_TANK_HEALTH( car.carID, 300 ) SET_VEHICLE_ENGINE_HEALTH( car.carID, 300 ) ENDIF IF GET_RANDOM_FLOAT_IN_RANGE() < 0.3 SET_VEHICLE_CAN_LEAK_PETROL( car.carID, TRUE ) SET_VEHICLE_PETROL_TANK_HEALTH( car.carID, 100 ) ENDIF BREAK CASE STATIC_BLIP_MINIGAME_RAMPAGE2 IF mdl = rampageInfo.carModels[2] nPass = 1 LOWER_CONVERTIBLE_ROOF( car.carID, TRUE ) ELSE nPass = 0 SET_ENTITY_HEALTH( car.carID, 150 ) ENDIF BREAK CASE STATIC_BLIP_MINIGAME_RAMPAGE3 nPass = GET_RANDOM_INT_IN_RANGE(1, 2) IF mdl = rampageInfo.carModels[0] SET_ENTITY_HEALTH( car.carID, 300 ) SET_VEHICLE_PETROL_TANK_HEALTH( car.carID, 300 ) SET_VEHICLE_ENGINE_HEALTH( car.carID, 300 ) ENDIF BREAK CASE STATIC_BLIP_MINIGAME_RAMPAGE4 nPass = GET_RANDOM_INT_IN_RANGE(1, 2) BREAK CASE STATIC_BLIP_MINIGAME_RAMPAGE5 nPass = GET_RANDOM_INT_IN_RANGE(3, 6) SET_ENTITY_PROOFS(car.carID, FALSE, TRUE, FALSE, FALSE, TRUE) BREAK ENDSWITCH // create driver IF NOT CREATE_RAMPAGE_PED_IN_VEHICLE(rampagePed[dridx], car.carID) CLEANUP_RAMPAGE_CAR(car) RETURN FALSE ENDIF car.bKeepAsCover = keepcov car.iOccupantIndex[0] = dridx car.fDistToPlayer = GET_DISTANCE_BETWEEN_ENTITIES(car.carID, PLAYER_PED_ID(), FALSE) car.fOriginalDist = car.fDistToPlayer CPRINTLN(DEBUG_RAMPAGE, "Car ", car.iIndex ," has been created") IF (nPass <= 0) RETURN TRUE ENDIF i = 0 REPEAT nPass i cnt = i + 1 IF (cnt >= COUNT_OF(car.iOccupantIndex)) RETURN TRUE ENDIF IF (iAlivePedCounter >= iMaxActivePeds) RETURN TRUE ENDIF IF NOT GET_FREE_RAMPAGE_PED_INDEX(rampagePed, dridx) RETURN TRUE ENDIF IF NOT CREATE_RAMPAGE_PED_IN_VEHICLE(rampagePed[dridx], car.carID) RETURN TRUE ENDIF car.iOccupantIndex[cnt] = dridx ENDREPEAT RETURN TRUE ENDFUNC /// PURPOSE: /// Sets a rampage car to drive to a set of coords and then kick everyone out /// PARAMS: /// rc - rampage car reference /// pos - desired position /// bDeployAll - if this is set all occupants will get out, else only passengers will and driver will drive off PROC SET_RAMPAGE_CAR_DEPLOY_TO_COORDINATES(RAMPAGE_CAR &rc, VECTOR pos, FLOAT spd = 35.0, FLOAT targetDistance = 5.0 ) INT i PED_INDEX pass PED_INDEX driver INT iTotalSeats // don't do this if the car is dead or driver is dead IF (rc.iOccupantIndex[0] = -1) EXIT ENDIF driver = rampagePed[rc.iOccupantIndex[0]].pedID IF IS_PED_INJURED(driver) OR NOT IS_ENTITY_ALIVE(rc.carID) EXIT ENDIF rc.vDestination = pos // if this is zero we assume we're going to player rc.fCruiseSpeed = spd rc.fTargetReachDist = targetDistance // give a task to the driver IF IS_PED_UNINJURED(driver) SET_PED_COMBAT_ATTRIBUTES(driver, CA_DO_DRIVEBYS, TRUE) SET_BLOCKING_OF_NON_TEMPORARY_EVENTS(driver, bBlockRampageTempEvents) TASK_VEHICLE_MISSION_COORS_TARGET(driver, rc.carID, rc.vDestination, MISSION_GOTO, rc.fCruiseSpeed , DF_SwerveAroundAllCars|DF_UseShortCutLinks|DF_ChangeLanesAroundObstructions, rc.fTargetReachDist, 15.0, TRUE) ENDIF // set everyone in the car to be drive-by capable iTotalSeats = GET_VEHICLE_MAX_NUMBER_OF_PASSENGERS(rc.carID) + SEAT_ADD_PLUS REPEAT iTotalSeats i pass = GET_PED_IN_VEHICLE_SEAT(rc.carID, INT_TO_ENUM(VEHICLE_SEAT, i)) IF IS_PED_UNINJURED(pass) and (pass <> driver) SET_PED_COMBAT_ATTRIBUTES(pass, CA_LEAVE_VEHICLES, FALSE) SET_PED_COMBAT_ATTRIBUTES(pass, CA_DO_DRIVEBYS, TRUE) TASK_COMBAT_PED(pass, PLAYER_PED_ID()) ENDIF ENDREPEAT // reset the task enum (andy i'm using numbers for the time being once i lock this down i'll enum it all) rc.iTaskState = 0 rc.rcMode = RCM_DEPLOY_ALL ENDPROC /// PURPOSE: /// Sets a rampage car to driveby the player /// PARAMS: /// rc - /// spd - PROC SET_RAMPAGE_CAR_DRIVEBY( RAMPAGE_CAR &rc, FLOAT spd = 35.0 ) INT i PED_INDEX pass PED_INDEX driver INT iTotalSeats // don't do this if the car is dead or driver is dead IF (rc.iOccupantIndex[0] = -1) EXIT ENDIF driver = rampagePed[rc.iOccupantIndex[0]].pedID IF IS_PED_INJURED(driver) OR NOT IS_ENTITY_ALIVE(rc.carID) EXIT ENDIF rc.vDestination = <<0, 0, 0>> // if this is zero we assume we're going to player rc.fCruiseSpeed = spd TASK_VEHICLE_MISSION_PED_TARGET(driver, rc.carID, PLAYER_PED_ID(), MISSION_CRUISE, rc.fCruiseSpeed, DF_SwerveAroundAllCars|DF_UseShortCutLinks|DF_ChangeLanesAroundObstructions, -1, -1, TRUE) // set everyone in the car to be drive-by capable iTotalSeats = GET_VEHICLE_MAX_NUMBER_OF_PASSENGERS(rc.carID) + SEAT_ADD_PLUS REPEAT iTotalSeats i pass = GET_PED_IN_VEHICLE_SEAT(rc.carID, INT_TO_ENUM(VEHICLE_SEAT, i)) IF IS_PED_UNINJURED(pass) and (pass <> driver) SET_PED_COMBAT_ATTRIBUTES(pass, CA_LEAVE_VEHICLES, FALSE) SET_PED_COMBAT_ATTRIBUTES(pass, CA_DO_DRIVEBYS, TRUE) TASK_COMBAT_PED(pass, PLAYER_PED_ID()) ELIF IS_PED_UNINJURED(pass) SET_PED_COMBAT_ATTRIBUTES(pass, CA_DO_DRIVEBYS, TRUE) ENDIF ENDREPEAT // reset the task enum (andy i'm using numbers for the time being once i lock this down i'll enum it all) rc.iTaskState = 0 rc.rcMode = RCM_DRIVEBY ENDPROC /// PURPOSE: /// @RJP sets a rampage car to try to ram the player /// PARAMS: /// rc - /// bDeployAll - /// spd - PROC SET_RAMPAGE_CAR_RAM( RAMPAGE_CAR &rc, FLOAT spd = 35.0 ) INT i PED_INDEX pass PED_INDEX driver INT iTotalSeats // don't do this if the car is dead or driver is dead IF (rc.iOccupantIndex[0] = -1) EXIT ENDIF driver = rampagePed[rc.iOccupantIndex[0]].pedID IF IS_PED_INJURED(driver) OR NOT IS_ENTITY_ALIVE(rc.carID) EXIT ENDIF rc.vDestination = <<0, 0, 0>> // if this is zero we assume we're going to player rc.fCruiseSpeed = spd TASK_VEHICLE_MISSION_PED_TARGET(driver, rc.carID, PLAYER_PED_ID(), MISSION_ATTACK, rc.fCruiseSpeed, DF_SwerveAroundAllCars|DF_UseShortCutLinks|DF_ChangeLanesAroundObstructions, -1, -1, TRUE) // set everyone in the car to be drive-by capable iTotalSeats = GET_VEHICLE_MAX_NUMBER_OF_PASSENGERS(rc.carID) + SEAT_ADD_PLUS REPEAT iTotalSeats i pass = GET_PED_IN_VEHICLE_SEAT(rc.carID, INT_TO_ENUM(VEHICLE_SEAT, i)) IF IS_PED_UNINJURED(pass) and (pass <> driver) SET_PED_COMBAT_ATTRIBUTES(pass, CA_LEAVE_VEHICLES, FALSE) SET_PED_COMBAT_ATTRIBUTES(pass, CA_DO_DRIVEBYS, TRUE) TASK_COMBAT_PED(pass, PLAYER_PED_ID()) ENDIF ENDREPEAT // reset the task enum (andy i'm using numbers for the time being once i lock this down i'll enum it all) rc.iTaskState = 0 rc.rcMode = RCM_RAM IF (GET_ENTITY_MODEL(rc.carID) = RHINO) rc.rcMode = RCM_TANK ENDIF ENDPROC /// PURPOSE: /// Sets a rampage car to drive towards the player and then kick everyone out /// PARAMS: /// rc - rampage car reference /// bDeployAll - if this is set all occupants will get out, else only passengers will and driver will drive off PROC SET_RAMPAGE_CAR_DEPLOY(RAMPAGE_CAR &rc, BOOL bDeployAll = TRUE, FLOAT spd = 35.0) INT i PED_INDEX pass PED_INDEX driver INT iTotalSeats // don't do this if the car is dead or driver is dead IF (rc.iOccupantIndex[0] = -1) EXIT ENDIF driver = rampagePed[rc.iOccupantIndex[0]].pedID IF IS_PED_INJURED(driver) OR NOT IS_ENTITY_ALIVE(rc.carID) EXIT ENDIF rc.vDestination = <<0, 0, 0>> // if this is zero we assume we're going to player rc.fCruiseSpeed = spd //@RJP cars should come much closer to player, everything more aggressive rc.fTargetReachDist = GET_RANDOM_FLOAT_IN_RANGE(15.0, 25.0) //@RJP old values // rc.fTargetReachDist = GET_RANDOM_FLOAT_IN_RANGE(30.0, 50.0) // give a task to the driver IF IS_PED_UNINJURED(driver) SET_PED_COMBAT_ATTRIBUTES(driver, CA_DO_DRIVEBYS, TRUE) SET_ENTITY_IS_TARGET_PRIORITY(driver, TRUE) SET_BLOCKING_OF_NON_TEMPORARY_EVENTS(driver, bBlockRampageTempEvents) IF rampageInfo.blipNameEnum = STATIC_BLIP_MINIGAME_RAMPAGE5 TASK_VEHICLE_MISSION_PED_TARGET(driver, rc.carID, PLAYER_PED_ID(), MISSION_GOTO, rc.fCruiseSpeed, DRIVINGMODE_AVOIDCARS_RECKLESS, rc.fTargetReachDist, 15.0, TRUE) ELSE TASK_VEHICLE_MISSION_PED_TARGET(driver, rc.carID, PLAYER_PED_ID(), MISSION_GOTO, rc.fCruiseSpeed, DF_SwerveAroundAllCars|DF_UseShortCutLinks|DF_ChangeLanesAroundObstructions, rc.fTargetReachDist, 15.0, TRUE) ENDIF ENDIF // set everyone in the car to be drive-by capable iTotalSeats = GET_VEHICLE_MAX_NUMBER_OF_PASSENGERS(rc.carID) + SEAT_ADD_PLUS REPEAT iTotalSeats i pass = GET_PED_IN_VEHICLE_SEAT(rc.carID, INT_TO_ENUM(VEHICLE_SEAT, i)) IF IS_PED_UNINJURED(pass) and (pass <> driver) SET_PED_COMBAT_ATTRIBUTES(pass, CA_LEAVE_VEHICLES, FALSE) SET_PED_COMBAT_ATTRIBUTES(pass, CA_DO_DRIVEBYS, TRUE) TASK_COMBAT_PED(pass, PLAYER_PED_ID()) ENDIF ENDREPEAT // reset the task enum (andy i'm using numbers for the time being once i lock this down i'll enum it all) rc.iTaskState = 0 IF (bDeployAll = TRUE) rc.rcMode = RCM_DEPLOY_ALL ELSE rc.rcMode = RCM_DEPLOY ENDIF IF (GET_ENTITY_MODEL(rc.carID) = RHINO) rc.rcMode = RCM_TANK ENDIF ENDPROC PROC SET_RAMPAGE_CAR_RAISED_COLLISION(RAMPAGE_CAR &rc) PED_INDEX driver IF NOT IS_ENTITY_ALIVE(rc.carID) EXIT ENDIF driver = GET_PED_IN_VEHICLE_SEAT(rc.carID) IF NOT IS_ENTITY_ALIVE(driver) EXIT ENDIF SET_CAN_ADJUST_GROUND_CLEARANCE(rc.carID, TRUE) ENDPROC PROC UPDATE_RAMPAGE_CAR_DRIVEBY(RAMPAGE_CAR &rc) PED_INDEX driver // don't do this if the car is dead or driver is dead IF (rc.iOccupantIndex[0] = -1) EXIT ENDIF driver = rampagePed[rc.iOccupantIndex[0]].pedID IF NOT IS_ENTITY_ALIVE(rc.carID) EXIT ENDIF IF NOT IS_ENTITY_ALIVE(driver) CPRINTLN(DEBUG_RAMPAGE, "Car ", rc.iIndex ," has driver is dead - Emergency cleanup - Dist to Player:", rc.fDistToPlayer) CLEANUP_RAMPAGE_CAR(rc) ELIF (GET_SCRIPT_TASK_STATUS(driver, SCRIPT_TASK_VEHICLE_MISSION) > PERFORMING_TASK) CPRINTLN(DEBUG_RAMPAGE, "Car ", rc.iIndex ," has abandoned ram task - redeploy - Dist to Player:", rc.fDistToPlayer) IF IS_VECTOR_ZERO(rc.vDestination) TASK_VEHICLE_MISSION_PED_TARGET(driver, rc.carID, PLAYER_PED_ID(), MISSION_CRUISE, rc.fCruiseSpeed, DF_SwerveAroundAllCars|DF_UseShortCutLinks|DF_ChangeLanesAroundObstructions, -1, -1, TRUE) ELSE TASK_VEHICLE_MISSION_COORS_TARGET(driver, rc.carID, rc.vDestination, MISSION_CRUISE, rc.fCruiseSpeed , DF_SwerveAroundAllCars|DF_UseShortCutLinks|DF_ChangeLanesAroundObstructions, -1, -1, TRUE) ENDIF ENDIF ENDPROC /// PURPOSE: /// @RJP makes sure a car set to ram keeps trying to ram until the driver is dead /// PARAMS: /// rc - rampage car reference PROC UPDATE_RAMPAGE_CAR_RAM(RAMPAGE_CAR &rc) PED_INDEX driver // don't do this if the car is dead or driver is dead IF (rc.iOccupantIndex[0] = -1) EXIT ENDIF driver = rampagePed[rc.iOccupantIndex[0]].pedID IF NOT IS_ENTITY_ALIVE(rc.carID) EXIT ENDIF //If the player has been damaged by the car, change the car to deploy instead of attack so the car doesn't keep running the player over // IF HAS_ENTITY_BEEN_DAMAGED_BY_ENTITY( PLAYER_PED_ID(), rc.carID, TRUE ) IF IS_ENTITY_TOUCHING_ENTITY( PLAYER_PED_ID(), rc.carID ) OR IS_PED_RAGDOLL( PLAYER_PED_ID() ) IF IS_ENTITY_ALIVE(driver) CPRINTLN(DEBUG_RAMPAGE, "Car ", rc.iIndex ," has rammed the player, setting car to deploy.") CLEAR_PED_TASKS( driver ) TASK_VEHICLE_MISSION_PED_TARGET(driver, rc.carID, PLAYER_PED_ID(), MISSION_GOTO, rc.fCruiseSpeed, DF_SwerveAroundAllCars|DF_UseShortCutLinks|DF_ChangeLanesAroundObstructions, rc.fTargetReachDist, 15.0, TRUE) rc.rcMode = RCM_DEPLOY_ALL ENDIF ENDIF IF NOT IS_ENTITY_ALIVE(driver) CPRINTLN(DEBUG_RAMPAGE, "Car ", rc.iIndex ," has driver is dead - Emergency cleanup - Dist to Player:", rc.fDistToPlayer) CLEANUP_RAMPAGE_CAR(rc) ELIF (GET_SCRIPT_TASK_STATUS(driver, SCRIPT_TASK_VEHICLE_MISSION) > PERFORMING_TASK) CPRINTLN(DEBUG_RAMPAGE, "Car ", rc.iIndex ," has abandoned ram task - redeploy - Dist to Player:", rc.fDistToPlayer) IF IS_VECTOR_ZERO(rc.vDestination) TASK_VEHICLE_MISSION_PED_TARGET(driver, rc.carID, PLAYER_PED_ID(), MISSION_ATTACK, rc.fCruiseSpeed, DF_SwerveAroundAllCars|DF_UseShortCutLinks|DF_ChangeLanesAroundObstructions, -1, -1, TRUE) ELSE TASK_VEHICLE_MISSION_COORS_TARGET(driver, rc.carID, rc.vDestination, MISSION_ATTACK, rc.fCruiseSpeed , DF_SwerveAroundAllCars|DF_UseShortCutLinks|DF_ChangeLanesAroundObstructions, -1, -1, TRUE) ENDIF ENDIF ENDPROC /// PURPOSE: /// Handles the state machine for vehicle deployment /// PARAMS: /// rc - rampage car reference /// bGetawayDriver - if this is set the driver doesn't get out PROC UPDATE_RAMPAGE_CAR_DEPLOY(RAMPAGE_CAR &rc, BOOL bGetawayDriver = TRUE) INT i PED_INDEX driver // don't do this if the car is dead or driver is dead IF (rc.iOccupantIndex[0] = -1) EXIT ENDIF driver = rampagePed[rc.iOccupantIndex[0]].pedID IF NOT IS_ENTITY_ALIVE(rc.carID) EXIT ENDIF SWITCH (rc.iTaskState) CASE 0 // driving to a destination //CPRINTLN(DEBUG_RAMPAGE, "Car ", rc.iIndex ," is driving") IF NOT IS_ENTITY_ALIVE(driver) CPRINTLN(DEBUG_RAMPAGE, "Car ", rc.iIndex ," has driver is dead - Emergency cleanup - Dist to Player:", rc.fDistToPlayer) CLEANUP_RAMPAGE_CAR(rc) rc.iTaskState = 1 ELIF (GET_SCRIPT_TASK_STATUS(driver, SCRIPT_TASK_VEHICLE_MISSION) = FINISHED_TASK) IF IS_VECTOR_ZERO(rc.vDestination) IF (rc.fDistToPlayer > (rc.fTargetReachDist + 20.0)) CPRINTLN(DEBUG_RAMPAGE, "Car ", rc.iIndex ," claims it has finished deploy to ped task - lies - Dist to Player:", rc.fDistToPlayer) TASK_VEHICLE_MISSION_PED_TARGET(driver, rc.carID, PLAYER_PED_ID(), MISSION_GOTO, rc.fCruiseSpeed, DF_SwerveAroundAllCars|DF_UseShortCutLinks|DF_ChangeLanesAroundObstructions, rc.fTargetReachDist, 15.0, TRUE) EXIT ENDIF ELSE IF GET_DISTANCE_BETWEEN_ENTITY_AND_COORD(rc.carID, rc.vDestination) > (rc.fTargetReachDist + 20.0) CPRINTLN(DEBUG_RAMPAGE, "Car ", rc.iIndex ," claims it has finished deploy to point task - lies - Dist to Player:", rc.fDistToPlayer) TASK_VEHICLE_MISSION_COORS_TARGET(driver, rc.carID, rc.vDestination, MISSION_GOTO, rc.fCruiseSpeed , DF_SwerveAroundAllCars|DF_UseShortCutLinks|DF_ChangeLanesAroundObstructions, rc.fTargetReachDist, 15.0, TRUE) EXIT ENDIF ENDIF rc.iTaskState = 1 ELIF (GET_SCRIPT_TASK_STATUS(driver, SCRIPT_TASK_VEHICLE_MISSION) <> PERFORMING_TASK) CPRINTLN(DEBUG_RAMPAGE, "Car ", rc.iIndex ," has abandoned task - redeploy - Dist to Player:", rc.fDistToPlayer) IF IS_VECTOR_ZERO(rc.vDestination) IF rampageInfo.blipNameEnum = STATIC_BLIP_MINIGAME_RAMPAGE5 TASK_VEHICLE_MISSION_PED_TARGET(driver, rc.carID, PLAYER_PED_ID(), MISSION_GOTO, rc.fCruiseSpeed, DRIVINGMODE_AVOIDCARS_RECKLESS, rc.fTargetReachDist, 15.0, TRUE) ELSE TASK_VEHICLE_MISSION_PED_TARGET(driver, rc.carID, PLAYER_PED_ID(), MISSION_GOTO, rc.fCruiseSpeed, DF_SwerveAroundAllCars|DF_UseShortCutLinks|DF_ChangeLanesAroundObstructions, rc.fTargetReachDist, 15.0, TRUE) ENDIF ELSE TASK_VEHICLE_MISSION_COORS_TARGET(driver, rc.carID, rc.vDestination, MISSION_GOTO, rc.fCruiseSpeed , DF_SwerveAroundAllCars|DF_UseShortCutLinks|DF_ChangeLanesAroundObstructions, rc.fTargetReachDist, 15.0, TRUE) ENDIF ENDIF BREAK CASE 1 // tell everyone to leave and attack IF (bGetawayDriver = FALSE) i = 0 REPEAT COUNT_OF(rc.iOccupantIndex) i IF (rc.iOccupantIndex[i] <> -1) CPRINTLN(DEBUG_RAMPAGE, "Car ", rc.iIndex ," Ped ", rc.iOccupantIndex[i], " is getting out") IF IS_PED_UNINJURED(rampagePed[rc.iOccupantIndex[i]].pedID) SET_RAMPAGE_PED_CAR_DEFENDER(rampagePed[rc.iOccupantIndex[i]].pedID, rc.carID) ENDIF ENDIF rc.iOccupantIndex[i] = -1 ENDREPEAT rc.iTaskState = 3 CLEANUP_RAMPAGE_CAR(rc) ELSE i = 0 REPEAT COUNT_OF(rc.iOccupantIndex) i IF (rc.iOccupantIndex[i] <> -1) IF (rampagePed[rc.iOccupantIndex[i]].pedID <> driver) IF IS_PED_UNINJURED(rampagePed[rc.iOccupantIndex[i]].pedID) SET_RAMPAGE_PED_CAR_DEFENDER(rampagePed[rc.iOccupantIndex[i]].pedID, rc.carID) ENDIF rc.iOccupantIndex[i] = -1 ENDIF ENDIF ENDREPEAT rc.iTaskState = 2 // this is a null state - we don't care what happens after this ENDIF BREAK CASE 2 // wait for everyone to get out IF ((GET_VEHICLE_NUMBER_OF_PASSENGERS(rc.carID) = 0) AND (bGetawayDriver)) IF IS_PED_UNINJURED(driver) TASK_VEHICLE_MISSION_PED_TARGET(driver, rc.carID, PLAYER_PED_ID(), MISSION_FLEE, 80.0, DF_SwerveAroundAllCars|DF_UseShortCutLinks|DF_ChangeLanesAroundObstructions, 500.0, -1.0) rc.iTaskState = 3 // this is a null state - we don't care what happens after this ELSE EXIT ENDIF ENDIF BREAK ENDSWITCH ENDPROC /// PURPOSE: /// Handles the state machine for the tank attacking the player /// PARAMS: /// rc - rampage car reference /// bGetawayDriver - if this is set the driver doesn't get out PROC UPDATE_RAMPAGE_CAR_DEPLOY_TANK(RAMPAGE_CAR &rc) PED_INDEX driver // don't do this if the car is dead or driver is dead IF (rc.iOccupantIndex[0] = -1) EXIT ENDIF driver = rampagePed[rc.iOccupantIndex[0]].pedID IF NOT IS_ENTITY_ALIVE(rc.carID) EXIT ENDIF SWITCH (rc.iTaskState) CASE 0 // driving to a destination //CPRINTLN(DEBUG_RAMPAGE, "Car ", rc.iIndex ," is driving") IF NOT IS_ENTITY_ALIVE(driver) CPRINTLN(DEBUG_RAMPAGE, "Car ", rc.iIndex ," has driver is dead - Emergency cleanup - Dist to Player:", rc.fDistToPlayer) CLEANUP_RAMPAGE_CAR(rc) rc.iTaskState = 1 ELIF (GET_SCRIPT_TASK_STATUS(driver, SCRIPT_TASK_VEHICLE_MISSION) = FINISHED_TASK) CPRINTLN(DEBUG_RAMPAGE, "Car ", rc.iIndex ," has finished task - deploy - Dist to Player:", rc.fDistToPlayer) GIVE_WEAPON_TO_PED(driver, WEAPONTYPE_VEHICLE_WEAPON_TANK, INFINITE_AMMO, TRUE, TRUE) SET_PED_COMBAT_ATTRIBUTES(driver, CA_USE_VEHICLE, TRUE) SET_PED_COMBAT_ATTRIBUTES(driver, CA_LEAVE_VEHICLES, FALSE) rc.iTaskState = 1 ELIF (GET_SCRIPT_TASK_STATUS(driver, SCRIPT_TASK_VEHICLE_MISSION) <> PERFORMING_TASK) CPRINTLN(DEBUG_RAMPAGE, "Car ", rc.iIndex ," has abandoned task - redeploy - Dist to Player:", rc.fDistToPlayer) IF IS_VECTOR_ZERO(rc.vDestination) TASK_VEHICLE_MISSION_PED_TARGET(driver, rc.carID, PLAYER_PED_ID(), MISSION_GOTO, rc.fCruiseSpeed, DF_SwerveAroundAllCars|DF_UseShortCutLinks|DF_ChangeLanesAroundObstructions, rc.fTargetReachDist, 15.0, TRUE) ELSE TASK_VEHICLE_MISSION_COORS_TARGET(driver, rc.carID, rc.vDestination, MISSION_GOTO, rc.fCruiseSpeed , DF_SwerveAroundAllCars|DF_UseShortCutLinks|DF_ChangeLanesAroundObstructions, rc.fTargetReachDist, 15.0, TRUE) ENDIF SCRIPT_ASSERT("DRIVER'S TASK HAS BEEN ABANDONED!!!") ENDIF BREAK CASE 1 // start tank firing IF GET_DISTANCE_BETWEEN_ENTITIES(rc.carID, PLAYER_PED_ID()) > 5.0 TASK_VEHICLE_SHOOT_AT_PED(driver, PLAYER_PED_ID()) CPRINTLN(DEBUG_RAMPAGE, "TANK IS FIRING") rc.iTaskState = 2 ENDIF BREAK CASE 2 // wait for everyone to get out IF (GET_SCRIPT_TASK_STATUS(driver, SCRIPT_TASK_VEHICLE_SHOOT_AT_ENTITY) = FINISHED_TASK) rc.iTimer = GET_GAME_TIMER() + 9000 CPRINTLN(DEBUG_RAMPAGE, "TANK IS FIRING") rc.iTaskState = 3 // this is a null state - we don't care what happens after this ELIF (GET_SCRIPT_TASK_STATUS(driver, SCRIPT_TASK_VEHICLE_SHOOT_AT_ENTITY) <> PERFORMING_TASK) CPRINTLN(DEBUG_RAMPAGE, "TANK FIRE FAILED") rc.iTaskState = 1 ENDIF BREAK CASE 3 // wait for everyone to get out IF GET_GAME_TIMER() > rc.iTimer rc.iTaskState = 1 ENDIF BREAK ENDSWITCH ENDPROC /// PURPOSE: /// Cleans up an entire array of rampage cars /// PARAMS: /// array - reference to car array PROC FLEE_RAMPAGE_CAR(RAMPAGE_CAR &rc, BOOL faroff = TRUE) SEQUENCE_INDEX seqTask PED_INDEX driver VECTOR v, dest // don't do this if the car is dead or driver is dead IF (rc.iOccupantIndex[0] = -1) EXIT ENDIF driver = rampagePed[rc.iOccupantIndex[0]].pedID IF NOT IS_ENTITY_ALIVE(rc.carID) EXIT ENDIF IF IS_ENTITY_ALIVE(driver) AND NOT IS_PED_INJURED(driver) IF (faroff) v = GET_ENTITY_COORDS(rc.carID) + (NORMALISE_VECTOR(GET_ENTITY_COORDS(rc.carID) - GET_ENTITY_COORDS(PLAYER_PED_ID())) * 500.0) IF NOT GET_NTH_CLOSEST_VEHICLE_NODE(v, 0, dest) dest = v ENDIF IF IS_PED_IN_VEHICLE(driver, rc.carID) IF GET_SEAT_PED_IS_IN(driver) = VS_DRIVER OPEN_SEQUENCE_TASK(seqTask) TASK_VEHICLE_MISSION_COORS_TARGET(NULL, rc.carID, dest, MISSION_GOTO, 60.0, DF_SwerveAroundAllCars|DF_UseShortCutLinks|DF_ChangeLanesAroundObstructions, rc.fTargetReachDist, 15.0, TRUE) TASK_VEHICLE_DRIVE_WANDER(NULL, rc.carID, 60.0, DRIVINGMODE_AVOIDCARS) CLOSE_SEQUENCE_TASK(seqTask) TASK_PERFORM_SEQUENCE(driver, seqTask) CLEAR_SEQUENCE_TASK(seqTask) ENDIF ENDIF ELSE TASK_SMART_FLEE_PED( driver, PLAYER_PED_ID(), 1000, -1 ) ENDIF ENDIF CLEANUP_RAMPAGE_PED(rampagePed[rc.iOccupantIndex[0]], TRUE) CLEANUP_RAMPAGE_CAR(rc) ENDPROC /// PURPOSE: /// Cleans up an entire array of rampage cars /// PARAMS: /// array - reference to car array PROC FLEE_RAMPAGE_CAR_ARRAY(RAMPAGE_CAR& array[]) INT i REPEAT COUNT_OF(array) i FLEE_RAMPAGE_CAR(array[i]) ENDREPEAT ENDPROC /// PURPOSE: /// Cleans up an entire array of rampage cars /// PARAMS: /// array - reference to car array PROC CLEANUP_RAMPAGE_CAR_ARRAY(RAMPAGE_CAR& array[]) INT i REPEAT COUNT_OF(array) i CLEANUP_RAMPAGE_CAR(array[i]) ENDREPEAT ENDPROC /// PURPOSE: /// Cleans up an entire array of rampage cars /// PARAMS: /// array - reference to car array PROC DELETE_RAMPAGE_CAR_ARRAY(RAMPAGE_CAR& array[]) INT i REPEAT COUNT_OF(array) i DELETE_RAMPAGE_CAR(array[i]) ENDREPEAT ENDPROC /// PURPOSE: /// Updates a rampage car and deploy state machine /// PARAMS: /// car - rampage car reference PROC UPDATE_RAMPAGE_CAR(RAMPAGE_CAR &car) IF NOT DOES_ENTITY_EXIST(car.carID) EXIT ENDIF IF IS_ENTITY_DEAD(car.carID) REGISTER_CAR_DEATH(car.carID, FALSE) CPRINTLN(DEBUG_RAMPAGE, "Car ", car.iIndex ," is dead - clean it up") CLEANUP_RAMPAGE_CAR(car) EXIT ENDIF IF IS_VEHICLE_EMPTY(car.carID, TRUE) REGISTER_CAR_ABANDON(car.carID) CPRINTLN(DEBUG_RAMPAGE, "Car ", car.iIndex ," has been abandonded - clean it up") CLEANUP_RAMPAGE_CAR(car) EXIT ENDIF // if the driver is dead abandon the car IF (car.iOccupantIndex[0] <> -1) IF NOT IS_ENTITY_ALIVE(rampagePed[car.iOccupantIndex[0]].pedID) CPRINTLN(DEBUG_RAMPAGE, "Car ", car.iIndex ," has no driver - clean it up") CLEANUP_RAMPAGE_CAR(car) EXIT ENDIF ENDIF // clean up the car if gets too far away from the player car.fDistToPlayer = GET_DISTANCE_BETWEEN_ENTITIES(car.carID, PLAYER_PED_ID(), FALSE) IF (car.fDistToPlayer >= (car.fOriginalDist + 120.0)) CPRINTLN(DEBUG_RAMPAGE, "Car ", car.iIndex ," is more than ", car.fOriginalDist + 120.0, " away clean it up") CLEANUP_RAMPAGE_CAR(car) EXIT ENDIF SWITCH (car.rcMode) CASE RCM_RAM UPDATE_RAMPAGE_CAR_RAM(car) BREAK CASE RCM_DRIVEBY UPDATE_RAMPAGE_CAR_DRIVEBY(car) BREAK CASE RCM_DEPLOY UPDATE_RAMPAGE_CAR_DEPLOY(car, TRUE) BREAK CASE RCM_DEPLOY_ALL UPDATE_RAMPAGE_CAR_DEPLOY(car, FALSE) BREAK CASE RCM_TANK UPDATE_RAMPAGE_CAR_DEPLOY_TANK(car) BREAK ENDSWITCH ENDPROC /// PURPOSE: /// Updates rampage car array PROC UPDATE_RAMPAGE_CARS() INT i REPEAT COUNT_OF(rampageCar) i UPDATE_RAMPAGE_CAR(rampageCar[i]) ENDREPEAT ENDPROC //---------------------- // TANK FUNCTIONS //---------------------- FUNC BOOL CREATE_RAMPAGE_TANK(RAMPAGE_TANK &rt, VECTOR pos, FLOAT head = 0.0) INT hp rt.vehicleID = CREATE_VEHICLE(RHINO, pos, head) IF NOT IS_ENTITY_ALIVE(rt.vehicleID) RETURN FALSE ENDIF rt.pedID = CREATE_PED_INSIDE_VEHICLE_AUTO_SEAT(rampageInfo.pedModels[0], rt.vehicleID, WEAPONTYPE_VEHICLE_WEAPON_TANK, TRUE, TRUE) rt.blipID = CREATE_VEHICLE_BLIP(rt.vehicleID, FALSE) SET_PED_CAN_BE_DRAGGED_OUT(rt.pedID, FALSE) SET_ENTITY_PROOFS(rt.vehicleID, TRUE, TRUE, FALSE, FALSE, TRUE) SET_VEHICLE_DOORS_LOCKED(rt.vehicleID, VEHICLELOCK_CANNOT_ENTER) SET_VEHICLE_IS_CONSIDERED_BY_PLAYER(rt.vehicleID, FALSE) hp = GET_ENTITY_MAX_HEALTH(rt.vehicleID) * 2 SET_ENTITY_MAX_HEALTH(rt.vehicleID, hp) SET_ENTITY_HEALTH(rt.vehicleID, hp) rt.fPlayerDist = GET_DISTANCE_BETWEEN_ENTITIES(rt.vehicleID, PLAYER_PED_ID()) rt.fOriginalDist = rt.fPlayerDist SET_PED_SEEING_RANGE(rt.pedID, 100.0) SET_PED_COMBAT_ATTRIBUTES(rt.pedID, CA_LEAVE_VEHICLES, FALSE) SET_PED_COMBAT_ATTRIBUTES(rt.pedID, CA_CAN_SHOOT_WITHOUT_LOS, TRUE) //SET_PED_FIRING_PATTERN(rt.pedID, FIRING_PATTERN_DELAY_FIRE_BY_ONE_SEC) // SET_PED_SHOOT_RATE(rt.pedID, iTankShootRate) SET_PED_COMBAT_ATTRIBUTES(rt.pedID, CA_PERFECT_ACCURACY, TRUE) SET_PED_COMBAT_ATTRIBUTES(rt.pedID, CA_USE_VEHICLE, TRUE) // TASK_COMBAT_PED(rt.pedID, PLAYER_PED_ID()) rt.iShotTimer = 0 rt.eTankState = TANK_INIT rt.vTargetPos = <<0.0,0.0,0.0>> RETURN TRUE ENDFUNC /// PURPOSE: /// Cleans up an entire array of rampage cars /// PARAMS: /// array - reference to car array PROC DELETE_RAMPAGE_TANK(RAMPAGE_TANK &rt) IF NOT DOES_ENTITY_EXIST(rt.vehicleID) EXIT ENDIF SAFE_REMOVE_BLIP(rt.blipID) SAFE_DELETE_PED(rt.pedID) SAFE_DELETE_VEHICLE(rt.vehicleID) rt.blipID = NULL rt.pedID = NULL rt.vehicleID = NULL rt.iShotTimer = 0 rt.eTankState = TANK_INIT rt.vTargetPos = <<0.0,0.0,0.0>> ENDPROC /// PURPOSE: /// Cleans up an entire array of rampage cars /// PARAMS: /// array - reference to car array PROC CLEANUP_RAMPAGE_TANK(RAMPAGE_TANK &rt, BOOL faroff = TRUE) SEQUENCE_INDEX seqTask VECTOR v, dest IF NOT DOES_ENTITY_EXIST(rt.vehicleID) EXIT ENDIF SAFE_REMOVE_BLIP(rt.blipID) IF NOT IS_ENTITY_ALIVE(rt.vehicleID) SAFE_RELEASE_PED(rt.pedID) ELSE IF IS_ENTITY_ALIVE(rt.pedID) IF (faroff) v = GET_ENTITY_COORDS(rt.vehicleID) + (NORMALISE_VECTOR(GET_ENTITY_COORDS(rt.vehicleID) - GET_ENTITY_COORDS(PLAYER_PED_ID())) * 500.0) IF NOT GET_NTH_CLOSEST_VEHICLE_NODE(v, 0, dest) dest = v ENDIF OPEN_SEQUENCE_TASK(seqTask) TASK_VEHICLE_MISSION_COORS_TARGET(NULL, rt.vehicleID, dest, MISSION_GOTO, 60.0, DF_SwerveAroundAllCars|DF_UseShortCutLinks|DF_ChangeLanesAroundObstructions, -1, -1, TRUE) TASK_VEHICLE_DRIVE_WANDER(NULL, rt.vehicleID, 60.0, DRIVINGMODE_AVOIDCARS) CLOSE_SEQUENCE_TASK(seqTask) TASK_PERFORM_SEQUENCE(rt.pedID, seqTask) CLEAR_SEQUENCE_TASK(seqTask) ELSE TASK_VEHICLE_MISSION_PED_TARGET(rt.pedID, rt.vehicleID, PLAYER_PED_ID(), MISSION_FLEE, 60.0, DF_SwerveAroundAllCars|DF_UseShortCutLinks|DF_ChangeLanesAroundObstructions, -1, -1) ENDIF ENDIF SAFE_RELEASE_PED(rt.pedID, TRUE) ENDIF SAFE_RELEASE_VEHICLE(rt.vehicleID) rt.blipID = NULL rt.pedID = NULL rt.vehicleID = NULL rt.iShotTimer = 0 rt.eTankState = TANK_INIT rt.vTargetPos = <<0.0,0.0,0.0>> ENDPROC /// PURPOSE: /// Generates a vector for the tank to fire that will miss the player /// PARAMS: /// rt - /// RETURNS: /// a VECTOR in a safe area for a tank shot close to and around the player FUNC VECTOR GENERATE_SHOT(RAMPAGE_TANK &rt) VECTOR vRetVal, vPlayerPos, vEnemyPos, vDirectionalVector, vShotVectorFromPlayer, vShotOffset FLOAT flSafetyAngle, flScalarOfShotFromPlayer, flZCoord // Get Bulldozer's position IF IS_ENTITY_OK(PLAYER_PED_ID()) vPlayerPos = GET_ENTITY_COORDS(PLAYER_PED_ID()) ENDIF // Get Tank's position IF IS_ENTITY_OK(rt.vehicleID) vEnemyPos = GET_ENTITY_COORDS(rt.vehicleID) ENDIF // Get the direction vector between them vDirectionalVector = vPlayerPos - vEnemyPos // Get the angle between tank and direction vector flTankShotAngle = ATAN2(vDirectionalVector.y, vDirectionalVector.x) // Determine the safety arc that won't shoot through the bulldozer // flTankShotAngle = RAD_TO_DEG(flTankShotAngle) // The minimum "safe" angle is the angle from tank to bulldozer plus our ArcOfSafety flMinimumSafeAngle = flTankShotAngle + flWidgetArcOfSafety // The maximum "safe" angle is the angle from tank to bulldozer minus our ArcOfSafety PLUS 2 PI flMaximumSafeAngle = flTankShotAngle - flWidgetArcOfSafety + 360 flSafetyAngle = GET_RANDOM_FLOAT_IN_RANGE(flMinimumSafeAngle, flMaximumSafeAngle) // Determine the distance from the bulldozer to the shot flScalarOfShotFromPlayer = GET_RANDOM_FLOAT_IN_RANGE(flMinCannonShotDistance, flMaxCannonShotDistance) vShotVectorFromPlayer.x = COS(flSafetyAngle) vShotVectorFromPlayer.y = SIN(flSafetyAngle) vShotVectorFromPlayer.z = 0 vShotOffset = flScalarOfShotFromPlayer * vShotVectorFromPlayer vRetVal = vPlayerPos + vShotOffset IF GET_GROUND_Z_FOR_3D_COORD(vRetVal, flZCoord) CPRINTLN(DEBUG_MISSION, "GET_GROUND_Z_FOR_3D_COORD was able to find a valid ground intersection") vRetVal.z = flZCoord ELSE CPRINTLN(DEBUG_MISSION, "GET_GROUND_Z_FOR_3D_COORD was unable to find a valid ground intersection") ENDIF CPRINTLN(DEBUG_MISSION, "vRetVal = ", vRetVal) RETURN vRetVal ENDFUNC /// PURPOSE: /// Updates the rampage tank telling it when to fire /// PARAMS: /// rt - PROC UPDATE_RAMPAGE_TANK(RAMPAGE_TANK &rt) IF NOT DOES_ENTITY_EXIST(rt.vehicleID) EXIT ENDIF IF IS_ENTITY_DEAD(rt.vehicleID) rampageStats.iTanksDestroyed ++ CPRINTLN(DEBUG_RAMPAGE, "TANKS DESTROYED:", rampageStats.iTanksDestroyed) EXPLODE_VEHICLE(rt.vehicleID) CLEANUP_RAMPAGE_TANK(rt) EXIT ENDIF rt.fPlayerDist = GET_DISTANCE_BETWEEN_ENTITIES(rt.vehicleID, PLAYER_PED_ID()) IF (rt.fPlayerDist > (rt.fOriginalDist + 100.0)) CPRINTLN(DEBUG_RAMPAGE, "TANK TOO FAR AWAY CLEAN IT UP") CLEANUP_RAMPAGE_TANK(rt) EXIT ENDIF IF NOT IS_ENTITY_ALIVE(rt.pedID) CPRINTLN(DEBUG_RAMPAGE, "TANK PILOT SOMEHOW DIED, CLEAN UP TANK") CLEANUP_RAMPAGE_TANK(rt) EXIT ENDIF VECTOR vMissShot SET_VEHICLE_TURRET_SPEED_THIS_FRAME( rt.vehicleID, 0.7 ) SWITCH rt.eTankState CASE TANK_INIT SET_PED_ACCURACY( rt.pedID, 100 ) TASK_VEHICLE_MISSION_PED_TARGET( rt.pedId, rt.vehicleID, PLAYER_PED_ID(), MISSION_GOTO, 40, DF_SwerveAroundAllCars|DF_UseShortCutLinks|DF_ChangeLanesAroundObstructions, -1, -1 ) rt.eTankState = TANK_DRIVE_TO_PLAYER BREAK CASE TANK_DRIVE_TO_PLAYER IF rt.fPlayerDist < 35.0 CLEAR_PED_TASKS( rt.pedID ) TASK_VEHICLE_TEMP_ACTION( rt.pedId, rt.vehicleID, TEMPACT_BRAKE, 100 ) CPRINTLN(DEBUG_RAMPAGE, "TANK_DRIVE_TO_PLAYER: SETTING eTankState TO TANK_FIRE_MISS_SHOT") rt.eTankState = TANK_FIRE_MISS_SHOT ELIF (GET_SCRIPT_TASK_STATUS(rt.pedID, SCRIPT_TASK_VEHICLE_MISSION) > PERFORMING_TASK) TASK_VEHICLE_MISSION_PED_TARGET( rt.pedId, rt.vehicleID, PLAYER_PED_ID(), MISSION_GOTO, 50, DF_SwerveAroundAllCars|DF_UseShortCutLinks|DF_ChangeLanesAroundObstructions, 30, -1 ) ENDIF BREAK CASE TANK_FIRE_MISS_SHOT IF NOT bTankDiag IF CREATE_CONVERSATION( convoBattleRant, rampageInfo.sDialogBlockName, "RAMP5_TANK", CONV_PRIORITY_MEDIUM ) bTankDiag = TRUE ENDIF ENDIF CLEAR_PED_TASKS( rt.pedID ) rt.vTargetPos = GET_ENTITY_COORDS( PLAYER_PED_ID() ) vMissShot = GENERATE_SHOT(rt) CPRINTLN(DEBUG_RAMPAGE, "UPDATE_RAMPAGE_TANK: TANK_FIRE_MISS_SHOT: TANK FIRING, SETTING eTankState TO TANK_CHECK_FOR_SHOT") TASK_VEHICLE_SHOOT_AT_COORD( rt.pedID, vMissShot ) rt.iShotTimer = GET_GAME_TIMER() + 6000 rt.eTankState = TANK_CHECK_FOR_SHOT BREAK CASE TANK_CHECK_FOR_SHOT IF IS_EXPLOSION_IN_SPHERE( EXP_TAG_TANKSHELL, GET_ENTITY_COORDS( PLAYER_PED_ID() ), 60 ) OR ( GET_GAME_TIMER() >= rt.iShotTimer ) CPRINTLN(DEBUG_RAMPAGE, "TANK_CHECK_FOR_SHOT: TANK FIRED, SETTING eTankState TO TANK_WAIT_BETWEEN_SHOTS") rt.iShotTimer = GET_GAME_TIMER() + GET_RANDOM_INT_IN_RANGE( 3000, 4000 ) rt.eTankState = TANK_WAIT_BETWEEN_SHOTS ENDIF BREAK CASE TANK_WAIT_BETWEEN_SHOTS IF ( GET_GAME_TIMER() >= rt.iShotTimer ) CLEAR_PED_TASKS( rt.pedID ) CPRINTLN(DEBUG_RAMPAGE, "TANK_WAIT_BETWEEN_SHOTS: TIMER COMPLETE, SETTING eTankState TO TANK_FIRE_HIT_SHOT") rt.eTankState = TANK_FIRE_HIT_SHOT ELIF rt.fPlayerDist < 10.0 IF (GET_SCRIPT_TASK_STATUS(rt.pedID, SCRIPT_TASK_VEHICLE_MISSION) > PERFORMING_TASK) TASK_VEHICLE_MISSION_PED_TARGET( rt.pedId, rt.vehicleID, PLAYER_PED_ID(), MISSION_FLEE, 30, DF_SwerveAroundAllCars|DF_UseShortCutLinks|DF_ChangeLanesAroundObstructions, -1, -1 ) ENDIF ELIF rt.fPlayerDist < 35.0 IF (GET_SCRIPT_TASK_STATUS(rt.pedID, SCRIPT_TASK_VEHICLE_MISSION) = PERFORMING_TASK) TASK_VEHICLE_TEMP_ACTION( rt.pedId, rt.vehicleID, TEMPACT_BRAKE, 100 ) CLEAR_PED_TASKS( rt.pedID ) ELIF (GET_SCRIPT_TASK_STATUS(rt.pedID, SCRIPT_TASK_VEHICLE_AIM_AT_COORD) > PERFORMING_TASK) CLEAR_PED_TASKS( rt.pedID ) TASK_VEHICLE_AIM_AT_COORD( rt.pedID, rt.vTargetPos ) ENDIF ELIF (GET_SCRIPT_TASK_STATUS(rt.pedID, SCRIPT_TASK_VEHICLE_MISSION) > PERFORMING_TASK) TASK_VEHICLE_MISSION_PED_TARGET( rt.pedId, rt.vehicleID, PLAYER_PED_ID(), MISSION_GOTO, 50, DF_SwerveAroundAllCars|DF_UseShortCutLinks|DF_ChangeLanesAroundObstructions, 30, -1 ) ENDIF BREAK // CASE TANK_PREP_FOR_NEXT_SHOT // CLEAR_PED_TASKS( rt.pedId ) // IF IS_ENTITY_AT_COORD( PLAYER_PED_ID(), rt.vTargetPos, <<6,6,6>>, FALSE, FALSE ) // CPRINTLN(DEBUG_RAMPAGE, "TANK_PREP_FOR_NEXT_SHOT: PLAYER HAS NOT MOVED, eTankState TO TANK_FIRE_HIT_SHOT HIT! HIT! HIT!") // rt.eTankState = TANK_FIRE_HIT_SHOT // ELSE // CPRINTLN(DEBUG_RAMPAGE, "TANK_PREP_FOR_NEXT_SHOT: PLAYER HAS MOVED, eTankState TO TANK_FIRE_MISS_SHOT") // rt.eTankState = TANK_FIRE_MISS_SHOT // ENDIF // BREAK CASE TANK_FIRE_HIT_SHOT CLEAR_PED_TASKS( rt.pedID ) CPRINTLN(DEBUG_RAMPAGE, "TANK_FIRE_HIT_SHOT: TANK FIRING, SETTING eTankState TO TANK_CHECK_FOR_SHOT") TASK_VEHICLE_SHOOT_AT_COORD( rt.pedID, rt.vTargetPos ) rt.vTargetPos = GET_ENTITY_COORDS( PLAYER_PED_ID() ) // CPRINTLN(DEBUG_RAMPAGE, "TANK_FIRE_HIT_SHOT: TANK FIRING, SETTING eTankState TO TANK_CHECK_FOR_SHOT") // TASK_VEHICLE_SHOOT_AT_PED( rt.pedID, PLAYER_PED_ID() ) rt.iShotTimer = GET_GAME_TIMER() + 6000 rt.eTankState = TANK_CHECK_FOR_SHOT BREAK ENDSWITCH ENDPROC /// PURPOSE: /// Removes All Rampage Blips PROC FORCE_REMOVE_ALL_BLIPS() INT i SAFE_REMOVE_BLIP(battleBlip) battleBlip = NULL i = 0 REPEAT COUNT_OF(rampagePed) i SAFE_REMOVE_BLIP(rampagePed[i].blipID) rampagePed[i].blipID = NULL ENDREPEAT ENDPROC //---------------------- // SPAWNER FUNCTIONS //---------------------- /// PURPOSE: /// Resets a rampage fortress struct (sets everything to zero) /// PARAMS: /// fort - rampage fortress reference PROC ZERO_RAMPAGE_FORTRESS(RAMPAGE_FORTRESS &fort) fort.bIsActive = FALSE fort.spawnArea.fWidth = 0 fort.defenseArea.fWidth = 0 fort.fRoofHeight = 0.0 fort.iPedCount = 0 fort.iSpawnedCount = 0 fort.iMaxSpawnCount = 0 fort.fRoofFactor = 0.0 fort.fRushFactor = 0.0 fort.iMaxActivePeds = -1 fort.iNextFortress = -1 ENDPROC ///------------------------------------------------------------------------------ /// FUNCTION: /// SETUP_RAMPAGE_FORTRESS() /// PURPOSE: /// SETS UP AREA FOR SPAWN AREA OF RAMPAGE FORTRESS ///------------------------------------------------------------------------------ /// PURPOSE: /// Setup an area to use as a rampage fortress /// PARAMS: /// fort - area reference /// p1 - area point 1 /// p2 - area point 2 /// width - area width /// active - set this to force the area active on start /// nextfort - this is the index for the next fortress to turn on once this fortress has stopped spawning PROC SETUP_RAMPAGE_FORTRESS(RAMPAGE_FORTRESS &fort, VECTOR p1, VECTOR p2, FLOAT width, BOOL active = FALSE, INT nextfort = -1) fort.bIsActive = active SETUP_RAMPAGE_AREA(fort.spawnArea, p1, p2, width) //SETUP_RAMPAGE_AREA(fort.defenseArea, p1, p2, width) fort.defenseArea = EXPAND_RAMPAGE_AREA(fort.spawnArea, 2.5) fort.iNextFortress = nextfort ENDPROC /// PURPOSE: /// Setup rampage fortress roof parameters /// PARAMS: /// fort - fortress reference /// roofz - any z coord higher than this is counted as roof by the fortress /// roofactor - chance of peds spawning on roof (0 - none, 1 - all) PROC SETUP_RAMPAGE_FORTRESS_ROOF(RAMPAGE_FORTRESS &fort, FLOAT roofz, FLOAT roofactor = 0.25) fort.fRoofFactor = roofactor fort.fRoofHeight = roofz ENDPROC /// PURPOSE: /// Setup rampage fortress spawning overrides /// PARAMS: /// fort - fortress reference /// ratio - how many of the total # of peds to come from the fortress (0.0 for infinite) /// rushFactor - chance of a spawned ped rushing you or staying in the fortress /// maxAPeds - maximum of active peds while fortress is operational (set to -1 to not override) /// maxACars - maximum of active cars while fortress is operational (set to -1 to not override) PROC SETUP_RAMPAGE_FORTRESS_SPAWNING(RAMPAGE_FORTRESS &fort, FLOAT ratio, FLOAT rushFactor = 0.0, INT maxAPeds = -1) IF (ratio > 0.0) fort.iMaxSpawnCount = CEIL(TO_FLOAT(rampageInfo.iTargetAmount * 2) * ratio) ELSE fort.iMaxSpawnCount = 99 // this will ensure the fortress never shuts down ENDIF IF (maxAPeds > iMaxActivePeds) maxAPeds = iMaxActivePeds ENDIF IF (maxAPeds > MAX_ACTIVE_PEDS) maxAPeds = MAX_ACTIVE_PEDS ENDIF fort.iMaxActivePeds = maxAPeds fort.fRushFactor = rushFactor ENDPROC /// PURPOSE: /// Generates a spawn position within a fortress /// PARAMS: /// fort - fortress reference /// out - the resultant point /// RETURNS: /// true if we could generate one FUNC BOOL GENERATE_FORTRESS_SPAWN_POINT(RAMPAGE_FORTRESS &fort, VECTOR &out) VECTOR v = GET_RANDOM_POINT_IN_RAMPAGE_AREA(fort.spawnArea) BOOL pvemnt = FALSE // (rampageInfo.blipNameEnum = STATIC_BLIP_MINIGAME_RAMPAGE2) FLOAT z INT i // check if point is safe #IF IS_DEBUG_BUILD VECTOR ppos = GET_ENTITY_COORDS(PLAYER_PED_ID()) CPRINTLN(DEBUG_RAMPAGE, " POINT GRABBED FROM RAMPAGE SPAWN AREA:", v ," PLAYER POS:", ppos) #ENDIF IF NOT GET_SAFE_COORD_FOR_PED(v, pvemnt, out, GSC_FLAG_NOT_INTERIOR | GSC_FLAG_NOT_WATER) CPRINTLN(DEBUG_RAMPAGE, " FAILED - CAN'T GET SAFE SPAWN POINT - POS:", v) RETURN FALSE ENDIF // do roof factor check - we check possiblity of people in roof // roof factor of 1 means if it can find a roof point it will put someone on it IF (fort.fRoofHeight > 0.0) IF (out.z > fort.fRoofHeight) AND (GET_RANDOM_FLOAT_IN_RANGE() > fort.fRoofFactor) CPRINTLN(DEBUG_RAMPAGE, " FAILED - SPAWN POINT IS TOO HIGH - INPOS:", v, " OUTPOS:", out) RETURN FALSE ENDIF ENDIF out.z += 0.25 IF GET_GROUND_Z_FOR_3D_COORD(out, z) out.z = z ENDIF // this stops peds from popping in from behind at very close range IF VDIST2(out, GET_ENTITY_COORDS(PLAYER_PED_ID())) < (rampageFortressSpawner.fMinSpawnRadius * rampageFortressSpawner.fMinSpawnRadius) IF (bDoPedSpawnBehindCheck) v = NORMALISE_VECTOR(GET_ENTITY_COORDS(PLAYER_PED_ID()) - GET_GAMEPLAY_CAM_COORD()) IF GET_PLANE_SIDE(v, GET_GAMEPLAY_CAM_COORD(), out) <= ON_PLANE CPRINTLN(DEBUG_RAMPAGE, " FAILED - SPAWN POINT IS WITHIN MIN SPAWN DISTANCE:", rampageFortressSpawner.fMinSpawnRadius, " - INPOS:", v, " OUTPOS:", out) RETURN FALSE ENDIF ELSE CPRINTLN(DEBUG_RAMPAGE, " FAILED - SPAWN POINT IS WITHIN MIN SPAWN DISTANCE:", rampageFortressSpawner.fMinSpawnRadius, " - INPOS:", v, " OUTPOS:", out) RETURN FALSE ENDIF ENDIF // check the point is actually in the fortress IF NOT IS_POINT_IN_ANGLED_AREA(out, fort.defenseArea.vPosition[0], fort.defenseArea.vPosition[1], fort.defenseArea.fWidth) CPRINTLN(DEBUG_RAMPAGE, " SPAWN POINT ISN'T IN FORTRESS - OUTPOS:", out) RETURN FALSE ENDIF IF IS_ANY_PED_NEAR_POINT(out, NO_PED_CHECK_RADIUS) CPRINTLN(DEBUG_RAMPAGE, " FAILED - SPAWN POINT IS WITHIN ", NO_PED_CHECK_RADIUS, " OF SOMEONE - OUTPOS:", out) RETURN FALSE ENDIF // check point isnt in any used no spawn zone REPEAT iMaxActiveNoSpawnAreas i IF IS_POINT_IN_ANGLED_AREA(out, noSpawnArea[i].vPosition[0], noSpawnArea[i].vPosition[1], noSpawnArea[i].fWidth) CPRINTLN(DEBUG_RAMPAGE, " FAILED - SPAWN POINT IS NO SPAWN AREA ", i, " OUTPOS:", out) RETURN FALSE ENDIF ENDREPEAT // check that we aren't spawning on top of a ped //IF IS_ANY_PED_IN_SPHERE(out, NO_PED_CHECK_RADIUS) // if the point is invisible it's okay but if we are at no spawn dist abandon IF IS_SPHERE_VISIBLE(out, 0.25) IF WOULD_ENTITY_BE_OCCLUDED(rampageInfo.pedModels[0], out) RETURN TRUE ENDIF CPRINTLN(DEBUG_RAMPAGE, " FAILED - AT LEAST 0.25 METERS AROUND SPAWN POINT IS VISIBLE - OUTPOS:", out) RETURN FALSE ENDIF RETURN TRUE ENDFUNC /// PURPOSE: /// Updates the blocking of rampage spawning /// RETURNS: /// Return false if we aren't allowed to spawn FUNC BOOL UPDATE_RAMPAGE_SPAWN_BLOCKER() IF (bBlockRampageSpawning = FALSE) RETURN TRUE ENDIF #IF IS_DEBUG_BUILD IF (bPauseRampageSpawning) RETURN FALSE ENDIF #ENDIF iRampageSpawnBlockLimit = iMaxActivePeds / 2 SWITCH (rampageSpawnState) CASE ERS_SPAWNING_ON REPLAY_DISABLE_CAMERA_MOVEMENT_THIS_FRAME() //Spawning is on, block camera movement - fix for bug 2201576 IF (iAlivePedCounter >= iMaxActivePeds) rampageSpawnState = ERS_SPAWNING_LIMIT_BREAK RETURN FALSE ENDIF BREAK CASE ERS_SPAWNING_LIMIT_BREAK IF (iAlivePedCounter < iRampageSpawnBlockLimit) rampageSpawnState = ERS_SPAWNING_WAIT iRampageSpawnStateTimer = GET_GAME_TIMER() + GET_RANDOM_INT_IN_RANGE(iMinRampageSpawnBlockTime, iMaxRampageSpawnBlockTime) ENDIF RETURN FALSE BREAK CASE ERS_SPAWNING_WAIT IF (GET_GAME_TIMER() > iRampageSpawnStateTimer) OR (iAlivePedCounter < 4) rampageSpawnState = ERS_SPAWNING_ON RETURN TRUE ENDIF RETURN FALSE BREAK ENDSWITCH RETURN TRUE ENDFUNC /// PURPOSE: /// Check if a spawner is ready to spawn /// PARAMS: /// sptime - after this time spawner is ready /// RETURNS: /// TRUE or FALSE FUNC BOOL IS_SPAWNER_READY_TO_SPAWN(INT &sptime) IF (bUseGlobalPedSpawnTimer) RETURN (GET_GAME_TIMER() > iNextRampageSpawnTime) ENDIF RETURN (GET_GAME_TIMER() > sptime) ENDFUNC /// PURPOSE: /// Updates the fortress spawning system PROC UPDATE_RAMPAGE_ALLEY_SPAWNER(RAMPAGE_ALLEYSPAWNER &rs) INT i INT pedInd, spawnInd VECTOR defPoint FLOAT spawnU rs.iFrameCounter ++ IF (rs.bIsActive = FALSE) EXIT ENDIF IF (iAlivePedCounter >= iMaxActivePeds) EXIT ENDIF IF (rs.iFrameCounter % 4 <> 0) EXIT ENDIF IF (bInBattleArea = FALSE) EXIT ENDIF IF NOT IS_SPAWNER_READY_TO_SPAWN(rs.iNextSpawnTime) EXIT ENDIF // look for free ped IF NOT GET_FREE_RAMPAGE_PED_INDEX(rampagePed, pedInd) EXIT ENDIF // update player u position - works out how far along the alley the player is rs.fPlayerAlleyUValue = GET_RATIO_OF_CLOSEST_POINT_ON_LINE(GET_ENTITY_COORDS(PLAYER_PED_ID()), rs.vAlleyPoints[0], rs.vAlleyPoints[1]) //GET_CLOSEST_POINT_ON_LINE_WITH_U_DEPRECIATED(GET_ENTITY_COORDS(PLAYER_PED_ID()), rs.vAlleyPoints[0], rs.vAlleyPoints[1], rs.fPlayerAlleyUValue) // get a spawn point check to see that further up the alley than the player is spawnInd = GET_RANDOM_INT_IN_RANGE(0, rs.iMaxActiveSpawnPoints) spawnU = GET_RATIO_OF_CLOSEST_POINT_ON_LINE(rs.spawnPoint[spawnInd].vPosition, rs.vAlleyPoints[0], rs.vAlleyPoints[1]) defPoint = rs.vAlleyPoints[0] + (spawnU * (rs.vAlleyPoints[1] - rs.vAlleyPoints[0])) //defPoint = GET_CLOSEST_POINT_ON_LINE_WITH_U_DEPRECIATED(rs.spawnPoint[spawnInd].vPosition, rs.vAlleyPoints[0], rs.vAlleyPoints[1], spawnU) IF (spawnU < (rs.fPlayerAlleyUValue + rs.fAlleyDiffAdjust)) EXIT ENDIF //@RJP Check spawn point is not too close to player IF VDIST2( GET_ENTITY_COORDS(PLAYER_PED_ID()), rs.spawnPoint[spawnInd].vPosition ) < 100 EXIT ENDIF // check there isn't a ped right next to me IF (bUseIsAreaOccupied) IF IS_ANY_PED_IN_SPHERE(rs.spawnPoint[spawnInd].vPosition, 0.25) EXIT ENDIF ELSE IF IS_ANY_PED_NEAR_POINT(rs.spawnPoint[spawnInd].vPosition, 0.25) EXIT ENDIF ENDIF // check point isnt in any used no spawn zone REPEAT iMaxActiveNoSpawnAreas i IF IS_POINT_IN_ANGLED_AREA(rs.spawnPoint[spawnInd].vPosition, noSpawnArea[i].vPosition[0], noSpawnArea[i].vPosition[1], noSpawnArea[i].fWidth) EXIT ENDIF ENDREPEAT IF NOT CREATE_RAMPAGER_PED_AT_SPAWN_POINT(rampagePed[pedInd], rs.spawnPoint[spawnInd], TRUE, TRUE) EXIT ENDIF IF (bUseGlobalPedSpawnTimer) rs.iNextSpawnTime = GET_GAME_TIMER() + GET_RANDOM_INT_IN_RANGE(iMinRampagePedSpawnTime, iMaxRampagePedSpawnTime) iNextRampageSpawnTime = rs.iNextSpawnTime ELSE rs.iNextSpawnTime = GET_GAME_TIMER() + GET_RANDOM_INT_IN_RANGE(rs.iMinSpawnTime, rs.iMaxSpawnTime) ENDIF //@RJP only doing this in rampage 4 for now IF rampageInfo.blipNameEnum = STATIC_BLIP_MINIGAME_RAMPAGE4 defPoint = GET_ENTITY_COORDS(rampagePed[pedInd].pedID) IF (defPoint.z > 35.0) SET_PED_COMBAT_MOVEMENT(rampagePed[pedInd].pedID, CM_STATIONARY) ENDIF ENDIF TASK_COMBAT_PED(rampagePed[pedInd].pedID, PLAYER_PED_ID()) ENDPROC /// PURPOSE: /// Updates the car spawner /// PARAMS: /// rs - PROC UPDATE_RAMPAGE_CAR_SPAWNER(RAMPAGE_CARSPAWNER &rs) INT i FLOAT head INT iCarInd VECTOR carpos, tmp MODEL_NAMES mdl rs.iFrameCounter ++ IF (rs.bIsActive = FALSE) EXIT ENDIF IF (iAliveCarCounter >= rs.iMinActiveCars) IF (GET_GAME_TIMER() < rs.iNextSpawnTime) EXIT ENDIF ENDIF IF (iAliveCarCounter >= rs.iMaxActiveCars) rs.iNextSpawnTime = GET_GAME_TIMER() + GET_RANDOM_INT_IN_RANGE(rs.iMinSpawnTime, rs.iMaxSpawnTime) EXIT ENDIF IF (iAliveCarCounter >= COUNT_OF(rampageCar)) EXIT ENDIF IF (iAlivePedCounter >= COUNT_OF(rampagePed)) EXIT ENDIF IF (rs.iFrameCounter % 4 <> 0) EXIT ENDIF // pick a car model mdl = GET_RANDOM_RAMPAGE_CAR_MODEL() IF (mdl = DUMMY_MODEL_FOR_SCRIPT) EXIT ENDIF IF NOT GET_FREE_RAMPAGE_CAR_INDEX(iCarInd) EXIT ENDIF // don't use spawn points IF (rs.bUseSpawnPoints = FALSE) OR (bInBattleArea = FALSE) VECTOR ResultLinkDir tmp = GET_OFFSET_FROM_COORD_AND_HEADING_IN_WORLD_COORDS(GET_ENTITY_COORDS(PLAYER_PED_ID()), GET_RANDOM_FLOAT_IN_RANGE(0, 360), <<0, GET_RANDOM_FLOAT_IN_RANGE(rs.fMinSpawnRadius, rs.fMaxSpawnRadius), 0>>) IF NOT GENERATE_VEHICLE_CREATION_POS_FROM_PATHS(tmp, carpos, ResultLinkDir) EXIT ENDIF head = GET_HEADING_FROM_COORDS(carpos, GET_ENTITY_COORDS(PLAYER_PED_ID())) ELSE i = GET_RANDOM_INT_IN_RANGE(0, rs.iSpawnPointsUsed) carPos = rs.vSpawnPoints[i].vPosition head = rs.vSpawnPoints[i].fHeading ENDIF IF NOT CREATE_RAMPAGE_CAR(rampageCar[iCarInd], mdl, carpos, head) EXIT ENDIF //@RJP Check random chance that car should try to run over player IF GET_RANDOM_FLOAT_IN_RANGE() < rampageInfo.fCarRamChance SET_RAMPAGE_CAR_RAM(rampageCar[iCarInd], GET_RANDOM_FLOAT_IN_RANGE(35.0, 42.0)) ELIF rampageInfo.blipNameEnum = STATIC_BLIP_MINIGAME_RAMPAGE2 IF mdl = rampageInfo.carModels[0] IF GET_RANDOM_FLOAT_IN_RANGE() < 0.5 SET_RAMPAGE_CAR_DRIVEBY( rampageCar[iCarInd], 20 ) ELSE SET_RAMPAGE_CAR_DEPLOY(rampageCar[iCarInd], TRUE, 25) ENDIF ELSE SET_RAMPAGE_CAR_DEPLOY(rampageCar[iCarInd], TRUE, GET_RANDOM_FLOAT_IN_RANGE(35.0, 42.0)) ENDIF ELSE SET_RAMPAGE_CAR_DEPLOY(rampageCar[iCarInd], TRUE, GET_RANDOM_FLOAT_IN_RANGE(35.0, 42.0)) ENDIF rs.iNextSpawnTime = GET_GAME_TIMER() + GET_RANDOM_INT_IN_RANGE(rs.iMinSpawnTime, rs.iMaxSpawnTime) ENDPROC /// PURPOSE: /// Updates the cloud spawner /// PARAMS: /// rs - PROC UPDATE_RAMPAGE_CLOUD_SPAWNER(RAMPAGE_CLOUDSPAWNER &rs) //FLOAT zrot INT ind, i VECTOR pos, out rs.iFrameCounter ++ IF (rs.bIsActive = FALSE) EXIT ENDIF IF NOT IS_SPAWNER_READY_TO_SPAWN(rs.iNextSpawnTime) EXIT ENDIF IF (iAlivePedCounter >= iMaxActivePeds) EXIT ENDIF IF (iAlivePedCounter >= COUNT_OF(rampagePed)) EXIT ENDIF IF (rs.iFrameCounter % 4 <> 0) EXIT ENDIF #IF IS_JAPANESE_BUILD IF (GET_RAMPAGE_REMAINING_TIME_IN_MILLISECONDS() < 2000) EXIT ENDIF #ENDIF IF NOT GET_FREE_RAMPAGE_PED_INDEX(rampagePed, ind) EXIT ENDIF pos = GET_OFFSET_FROM_COORD_AND_HEADING_IN_WORLD_COORDS(GET_ENTITY_COORDS(PLAYER_PED_ID()), GET_RANDOM_FLOAT_IN_RANGE(0.0, 360.0), <<0, GET_RANDOM_FLOAT_IN_RANGE(rs.fMinSpawnRadius, rs.fMaxSpawnRadius), 0>>) IF NOT GET_SAFE_COORD_FOR_PED(pos, rs.bPavementOnly, out, GSC_FLAG_NOT_ISOLATED | GSC_FLAG_NOT_INTERIOR | GSC_FLAG_NOT_WATER) EXIT ENDIF /* IF GET_GROUND_Z_FOR_3D_COORD(out, zrot) out.z = zrot ENDIF */ IF VDIST2(out, GET_ENTITY_COORDS(PLAYER_PED_ID())) < (rs.fMinSpawnRadius * rs.fMinSpawnRadius) EXIT ENDIF // check point isnt in any used no spawn zone REPEAT iMaxActiveNoSpawnAreas i IF IS_POINT_IN_ANGLED_AREA(out, noSpawnArea[i].vPosition[0], noSpawnArea[i].vPosition[1], noSpawnArea[i].fWidth) EXIT ENDIF ENDREPEAT // check that we aren't spawning on top of a ped IF (bUseIsAreaOccupied) IF IS_ANY_PED_IN_SPHERE(out, NO_PED_CHECK_RADIUS) EXIT ENDIF ELSE IF IS_ANY_PED_NEAR_POINT(out, NO_PED_CHECK_RADIUS) EXIT ENDIF ENDIF // if the point is invisible it's okay but if we are at no spawn dist abandon IF IS_SPHERE_VISIBLE(out, 0.25) IF NOT WOULD_ENTITY_BE_OCCLUDED(rampageInfo.pedModels[0], out) EXIT ENDIF ENDIF // create IF (GET_RANDOM_FLOAT_IN_RANGE() <= rs.fFleeChance) IF NOT CREATE_RAMPAGER_FLEE_PED_AT_POSITION(rampagePed[ind], out) EXIT ENDIF ELIF NOT CREATE_RAMPAGER_PED_AT_POSITION(rampagePed[ind], out) EXIT ENDIF IF (bUseGlobalPedSpawnTimer) rs.iNextSpawnTime = GET_GAME_TIMER() + GET_RANDOM_INT_IN_RANGE(iMinRampagePedSpawnTime, iMaxRampagePedSpawnTime) iNextRampageSpawnTime = rs.iNextSpawnTime ELSE rs.iNextSpawnTime = GET_GAME_TIMER() + GET_RANDOM_INT_IN_RANGE(rs.iMinSpawnTime, rs.iMaxSpawnTime) ENDIF ENDPROC /// PURPOSE: /// Updates the fortress spawning system PROC UPDATE_RAMPAGE_FORTRESS_SPAWNER(RAMPAGE_FORTSPAWNER &rs) // INT i VECTOR tmp rs.iFrameCounter ++ IF (rs.bIsActive = FALSE) EXIT ENDIF IF NOT IS_SPAWNER_READY_TO_SPAWN(rs.iNextSpawnTime) EXIT ENDIF IF (bInBattleArea = FALSE) EXIT ENDIF IF (rampageFort[rs.iFortressFrameCounter].bIsActive) AND (iAlivePedCounter < iMaxActivePeds) CPRINTLN(DEBUG_RAMPAGE, " ") CPRINTLN(DEBUG_RAMPAGE, "FORTRESS ", rs.iFortressFrameCounter, " IS TRYING TO SPAWN") IF GENERATE_FORTRESS_SPAWN_POINT(rampageFort[rs.iFortressFrameCounter], tmp) IF IS_ENTITY_IN_RANGE_COORDS(PLAYER_PED_ID(), tmp, rs.fFortressAllowRange) IF CREATE_RAMPAGER_PED_IN_FORTRESS_AT_POSITION(rampageFort[rs.iFortressFrameCounter], tmp, rs.iFortressFrameCounter) IF (bUseGlobalPedSpawnTimer) rs.iNextSpawnTime = GET_GAME_TIMER() + GET_RANDOM_INT_IN_RANGE(iMinRampagePedSpawnTime, iMaxRampagePedSpawnTime) iNextRampageSpawnTime = rs.iNextSpawnTime ELSE rs.iNextSpawnTime = GET_GAME_TIMER() + GET_RANDOM_INT_IN_RANGE(rs.iMinSpawnTime, rs.iMaxSpawnTime) ENDIF ENDIF ELSE CPRINTLN(DEBUG_RAMPAGE, "FORTRESS ", rs.iFortressFrameCounter, " PLAYER IS TOO FAR AWAY") ENDIF ELSE CPRINTLN(DEBUG_RAMPAGE, "FORTRESS ", rs.iFortressFrameCounter, " COULDN'T GENERATE POINT") ENDIF ENDIF rs.iFortressFrameCounter ++ IF rs.iFortressFrameCounter >= rs.iMaxActiveFortress rs.iFortressFrameCounter = 0 ENDIF ENDPROC //---------------------- // CHALLENGE FUNCTIONS //---------------------- /// PURPOSE: /// Resets the Challenge Array /// PARAMS: /// array - PROC RESET_CHALLENGE_ARRAY(RAMPAGE_CHALLENGE& array[]) INT i REPEAT COUNT_OF(array) i array[i].cType = CHALLENGE_NONE array[i].iRequiredAmount = 0 array[i].sTxtKey = "" ENDREPEAT ENDPROC /// PURPOSE: /// Checks to see if a challenge has been furfilled /// PARAMS: /// cg - Challenge Reference /// RETURNS: /// Success FUNC BOOL CHECK_CHALLENGE(RAMPAGE_CHALLENGE &cg) SWITCH (cg.cType) CASE CHALLENGE_OVERKILL RETURN (rampageStats.iPedDeadCount >= cg.iRequiredAmount) CASE CHALLENGE_HEADSHOT RETURN (rampageStats.iHeadShots >= cg.iRequiredAmount) CASE CHALLENGE_KILLSTREAK RETURN (rampageStats.iMaxChain >= cg.iRequiredAmount) CASE CHALLENGE_VEHICLES RETURN (rampageStats.iCarDeadCount >= cg.iRequiredAmount) CASE CHALLENGE_OCCUPANT RETURN (rampageStats.iCarOccupantKills >= cg.iRequiredAmount) CASE CHALLENGE_CHOPPER RETURN (rampageStats.iChopperDeadCount >= cg.iRequiredAmount) CASE CHALLENGE_EXECUTION RETURN (rampageStats.iCloseRange >= cg.iRequiredAmount) CASE CHALLENGE_LONGSHOT RETURN (rampageStats.iLongRange >= cg.iRequiredAmount) CASE CHALLENGE_TANK RETURN (rampageStats.iTanksDestroyed >= cg.iRequiredAmount) ENDSWITCH RETURN FALSE ENDFUNC /// PURPOSE: /// Count The Number Of Challenges /// PARAMS: /// array - FUNC INT COUNT_ACTIVE_CHALLENGES(RAMPAGE_CHALLENGE& array[]) INT i INT cnt = 0 REPEAT COUNT_OF(array) i IF array[i].cType <> CHALLENGE_NONE cnt ++ ENDIF ENDREPEAT RETURN cnt ENDFUNC /// PURPOSE: /// Count The Number Of Completed Challenges /// PARAMS: /// array - FUNC INT COUNT_COMPLETED_CHALLENGES(RAMPAGE_CHALLENGE& array[]) INT i INT cnt = 0 REPEAT COUNT_OF(array) i IF CHECK_CHALLENGE(array[i]) cnt ++ ENDIF ENDREPEAT RETURN cnt ENDFUNC /// PURPOSE: /// /// PARAMS: /// cg - Challenge Reference /// type - Challenge Type /// cnt - Number of things to do to complete challenge PROC SET_CHALLENGE(RAMPAGE_CHALLENGE &cg, eRAMPAGE_CHALLENGE type, INT cnt) cg.cType = type cg.iRequiredAmount = cnt SWITCH (cg.cType) CASE CHALLENGE_OVERKILL cg.sTxtKey = "CH_000" BREAK CASE CHALLENGE_HEADSHOT cg.sTxtKey = "CH_001" BREAK CASE CHALLENGE_KILLSTREAK cg.sTxtKey = "CH_002" BREAK CASE CHALLENGE_VEHICLES cg.sTxtKey = "CH_003" BREAK CASE CHALLENGE_OCCUPANT cg.sTxtKey = "CH_004" BREAK CASE CHALLENGE_CHOPPER cg.sTxtKey = "CH_005" BREAK CASE CHALLENGE_EXECUTION cg.sTxtKey = "CH_006" BREAK CASE CHALLENGE_LONGSHOT cg.sTxtKey = "CH_007" BREAK CASE CHALLENGE_TANK cg.sTxtKey = "CH_008" BREAK ENDSWITCH ENDPROC /// PURPOSE: /// Checks to see if a challenge has been furfilled /// PARAMS: /// cg - Challenge Reference /// RETURNS: /// Success FUNC FLOAT GET_CHALLENGE_PERCENTAGE(RAMPAGE_CHALLENGE &cg) IF (cg.iRequiredAmount = 0) RETURN 0.0 ENDIF SWITCH (cg.cType) CASE CHALLENGE_HEADSHOT RETURN TO_FLOAT(rampageStats.iHeadShots) / TO_FLOAT(cg.iRequiredAmount) CASE CHALLENGE_KILLSTREAK RETURN TO_FLOAT(rampageStats.iMaxChain) / TO_FLOAT(cg.iRequiredAmount) CASE CHALLENGE_VEHICLES RETURN TO_FLOAT(rampageStats.iCarDeadCount) / TO_FLOAT(cg.iRequiredAmount) CASE CHALLENGE_OCCUPANT RETURN TO_FLOAT(rampageStats.iCarOccupantKills) / TO_FLOAT(cg.iRequiredAmount) CASE CHALLENGE_CHOPPER RETURN TO_FLOAT(rampageStats.iChopperDeadCount) / TO_FLOAT(cg.iRequiredAmount) CASE CHALLENGE_EXECUTION RETURN TO_FLOAT(rampageStats.iCloseRange) / TO_FLOAT(cg.iRequiredAmount) CASE CHALLENGE_LONGSHOT RETURN TO_FLOAT(rampageStats.iLongRange) / TO_FLOAT(cg.iRequiredAmount) CASE CHALLENGE_TANK RETURN TO_FLOAT(rampageStats.iTanksDestroyed) / TO_FLOAT(cg.iRequiredAmount) ENDSWITCH RETURN 0.0 ENDFUNC /// PURPOSE: /// Gets combined challenge percentage /// PARAMS: /// array - FUNC FLOAT GET_TOTAL_CHALLENGE_PERCENTAGE(RAMPAGE_CHALLENGE& array[]) INT cnt = COUNT_ACTIVE_CHALLENGES(array) IF (cnt = 0) RETURN 0.0 ENDIF RETURN TO_FLOAT(COUNT_COMPLETED_CHALLENGES(array)) / TO_FLOAT(cnt) ENDFUNC //---------------------- // SETUP FUNCTIONS //---------------------- /// PURPOSE: /// Gets the position of a rampage blip from the rampage info struct /// RETURNS: /// Blip Coords FUNC VECTOR GET_RAMPAGE_POSITION() INT iIndex = ENUM_TO_INT(rampageInfo.blipNameEnum) RETURN g_GameBlips[iIndex].vCoords[0] ENDFUNC /// PURPOSE: /// Sets a rampage as failed used by the scaleform FUNC BOOL IS_RAMPAGE_IN_FAIL_UPDATE_STATE() RETURN sFailState <> SP_LOADING ENDFUNC /// PURPOSE: /// Sets a rampage as failed used by the scaleform PROC SET_RAMPAGE_TO_FAIL_UPDATE_STATE() sFailState = SP_SETUP ENDPROC /// PURPOSE: /// Zeros out the rampage info struct PROC RESET_RAMPAGE_INFO() INT i // reset misc data RESET_COMBAT_PARAMETERS(rampageCombatParams) rampageInfo.iTargetAmount = 30 rampageInfo.iTimeLimit = 3 * ONE_MINUTE rampageInfo.vPlyrStartPos = <<0, 0, 0>> rampageInfo.fPlyrStartHeading = 0.0 rampageInfo.vPlyrCarHidePos = <<0, 0, 0>> rampageInfo.fPlyrCarHideHeading = 0.0 rampageInfo.bPassed = FALSE rampageInfo.fAmbientCarDensity = 0.0 rampageInfo.fAmbientPedDensity = 0.0 rampageInfo.iRandomSeed = 0 rampageInfo.bExplosiveProps = FALSE rampageInfo.fCarRamChance = 0.0 rampageInfo.sScenarioGroupName = "" rampageInfo.vScenarioBlockCenter = <<0, 0, 0>> rampageInfo.fScenarioBlockRadius = 0.0 // reset model data rampageInfo.explosiveModel = DUMMY_MODEL_FOR_SCRIPT i = 0 REPEAT COUNT_OF(rampageInfo.pedModels) i rampageInfo.pedModels[i] = DUMMY_MODEL_FOR_SCRIPT ENDREPEAT rampageInfo.iMaxPedModels = 0 i = 0 REPEAT COUNT_OF(rampageInfo.carModels) i rampageInfo.carModels[i] = DUMMY_MODEL_FOR_SCRIPT ENDREPEAT rampageInfo.iMaxCarModels = 0 // reset weapon data i = 0 REPEAT COUNT_OF(rampageInfo.plyrWeapon) i rampageInfo.plyrWeapon[i] = WEAPONTYPE_INVALID ENDREPEAT i = 0 REPEAT COUNT_OF(rampageInfo.plyrWeaponComp) i rampageInfo.plyrWeaponComp[i] = WEAPONCOMPONENT_INVALID ENDREPEAT i = 0 REPEAT COUNT_OF(rampageInfo.enemyWeapon) i rampageInfo.enemyWeapon[i] = WEAPONTYPE_INVALID ENDREPEAT // reset voice names sVoiceContext = "" i = 0 REPEAT COUNT_OF(sMaleVoiceNames) i sMaleVoiceNames[i] = "" ENDREPEAT i = 0 REPEAT COUNT_OF(sFemaleVoiceNames) i sFemaleVoiceNames[i] = "" ENDREPEAT ENDPROC /// PURPOSE: /// Release models and other things held by the rampage info struct PROC RELEASE_RAMPAGE_INFO() INT i i = 0 IF (rampageInfo.explosiveModel <> DUMMY_MODEL_FOR_SCRIPT) SET_MODEL_AS_NO_LONGER_NEEDED(rampageInfo.explosiveModel) ENDIF REPEAT COUNT_OF(rampageInfo.pedModels) i IF (rampageInfo.pedModels[i] <> DUMMY_MODEL_FOR_SCRIPT) SET_MODEL_AS_NO_LONGER_NEEDED(rampageInfo.pedModels[i]) ENDIF ENDREPEAT i = 0 REPEAT COUNT_OF(rampageInfo.carModels) i IF (rampageInfo.carModels[i] <> DUMMY_MODEL_FOR_SCRIPT) SET_MODEL_AS_NO_LONGER_NEEDED(rampageInfo.carModels[i]) ENDIF ENDREPEAT ENDPROC /// PURPOSE: /// Populates the rampage info struct based on blip enum /// PARAMS: /// bp - rampage blip enum PROC SET_RAMPAGE_INFO_FROM_STATIC_BLIP(STATIC_BLIP_NAME_ENUM bp) VECTOR vmin, vmax // write default values in RESET_RAMPAGE_INFO() rampageInfo.blipNameEnum = bp vBattleCenter = GET_RAMPAGE_POSITION() // then fill them in on a case by case basis SWITCH (bp) CASE STATIC_BLIP_MINIGAME_RAMPAGE1 rcRampageMissionID = RC_RAMPAGE_1 rampageInfo.iRampageIndex = 0 rampageInfo.iTimeLimit = CEIL(2.0 * ONE_MINUTE) rampageInfo.sIntroAnim = "trvram_6_2h_intro" rampageInfo.sOutroAnim = "trvram_6_2h_outro" rampageInfo.sOutroRunAnim = "trvram_6_2h_run_outro" rampageInfo.fOutroPhase = 0.15 rampageInfo.fOutroRunPhase = 0.37 rampageInfo.plyrWeapon[0] = WEAPONTYPE_ASSAULTRIFLE rampageInfo.plyrWeaponComp[0] = WEAPONCOMPONENT_ASSAULTRIFLE_CLIP_01 rampageInfo.plyrWeaponComp[1] = WEAPONCOMPONENT_ASSAULTRIFLE_CLIP_02 rampageInfo.enemyWeapon[0] = WEAPONTYPE_PISTOL rampageInfo.pedModels[0] = A_M_M_HILLBILLY_01 rampageInfo.pedModels[1] = A_M_Y_SALTON_01 rampageInfo.pedModels[2] = IG_RAMP_HIC rampageInfo.iMaxPedModels = 2 rampageInfo.carModels[0] = BFINJECTION //REBEL rampageInfo.carModels[1] = BISON // rampageInfo.carModels[2] = BFINJECTION rampageInfo.iMaxCarModels = 2 rampageInfo.sTargetName = "TR_RTGT1" // Rednecks rampageInfo.sUIName = "TR_RAMP1" rampageInfo.fCarRamChance = 0.33 //Cars have a 1/3 chance to ram the player rampageInfo.bExplosiveProps = TRUE rampageInfo.explosiveModel = PROP_GASCYL_01A rampageInfo.sScenarioGroupName = "Rampage1" //rampageInfo.vScenarioBlockCenter = <<928, 3607, 33>> //rampageInfo.fScenarioBlockRadius = 140 rampageInfo.vPlyrStartPos = <<908.7723, 3641.4531, 31.4889>> rampageInfo.fPlyrStartHeading = 270.3831 rampageInfo.vPlyrCarHidePos = << 899.2652, 3649.5786, 31.7623 >> rampageInfo.fPlyrCarHideHeading = 269.0209 rampageInfo.iTargetAmount = 25 sMaleVoiceNames[0] = "A_M_M_SALTON_02_WHITE_FULL_01" sMaleVoiceNames[1] = "A_M_O_SALTON_01_WHITE_FULL_01 " sMaleVoiceNames[2] = "A_M_M_HILLBILLY_01_WHITE_MINI_01" sMaleVoiceNames[3] = "A_M_M_HILLBILLY_02_WHITE_MINI_01" sMaleVoiceNames[4] = "A_M_Y_SALTON_01_WHITE_MINI_01" sVoiceContext = "GENERIC_INSULT_HIGH" sAudioScene = "RAMPAGE_REDNECKS_SCENE" iRampageMusicStartTime = 28000 // 38 seconds in BREAK CASE STATIC_BLIP_MINIGAME_RAMPAGE2 rcRampageMissionID = RC_RAMPAGE_2 rampageInfo.iRampageIndex = 1 rampageInfo.plyrWeapon[0] = WEAPONTYPE_SAWNOFFSHOTGUN rampageInfo.enemyWeapon[0] = WEAPONTYPE_PISTOL rampageInfo.enemyWeapon[1] = WEAPONTYPE_BAT rampageInfo.iTimeLimit = 2 * ONE_MINUTE rampageInfo.sIntroAnim = "trvram_6_2h_intro" rampageInfo.sOutroAnim = "trvram_6_2h_outro" rampageInfo.sOutroRunAnim = "trvram_6_2h_run_outro" rampageInfo.fOutroPhase = 0.15 rampageInfo.fOutroRunPhase = 0.37 rampageInfo.pedModels[0] = A_M_Y_HIPSTER_03 rampageInfo.pedModels[1] = A_M_Y_HIPSTER_02 //A_F_Y_HIPSTER_01 rampageInfo.pedModels[2] = A_M_Y_HIPSTER_01 rampageInfo.pedModels[3] = IG_RAMP_HIPSTER rampageInfo.iMaxPedModels = 3 rampageInfo.carModels[0] = FAGGIO2 rampageInfo.carModels[1] = FIXTER rampageInfo.carModels[2] = ISSI2 rampageInfo.iMaxCarModels = 3 rampageInfo.vPlyrStartPos = <<1181.1375, -400.7188, 66.9130>> rampageInfo.fPlyrStartHeading = 218.4670 rampageInfo.vPlyrCarHidePos = << 1193.6074, -392.7852, 67.0623 >> rampageInfo.fPlyrCarHideHeading = 164.6903 rampageInfo.sTargetName = "TR_RTGT2" // Hipsters rampageInfo.sUIName = "TR_RAMP5" rampageInfo.fAmbientCarDensity = 1.0 rampageInfo.fAmbientPedDensity = 0.2 sMaleVoiceNames[0] = "A_M_Y_Hipster_03_White_Mini_01" sMaleVoiceNames[1] = "A_M_Y_Vinewood_02_White_Mini_01" sMaleVoiceNames[2] = "A_M_Y_Vinewood_03_White_Mini_01" sMaleVoiceNames[3] = "A_M_Y_Vinewood_04_White_Mini_01" sFemaleVoiceNames[0] = "A_F_Y_Hipster_01_White_Mini_01" sFemaleVoiceNames[1] = "A_F_Y_Vinewood_01_White_Mini_01" sFemaleVoiceNames[2] = "A_F_Y_Vinewood_02_White_Mini_01" sFemaleVoiceNames[3] = "A_F_Y_Vinewood_03_Chinese_Mini_01" sFemaleVoiceNames[4] = "A_F_Y_Vinewood_04_White_Mini_01" sVoiceContext = "RAMPAGEHIPSTER" sAudioScene = "RAMPAGE_HIPSTERS_SCENE" rampageInfo.iTargetAmount = 20 fEnemySecondWeaponChance = 0.0 fPissTakeRocketChance = 0.0 iRampageMusicStartTime = 17000 // 19 seconds in fBattleRadius = 600.0 sFormState = SFR_LEADIN BREAK CASE STATIC_BLIP_MINIGAME_RAMPAGE3 rcRampageMissionID = RC_RAMPAGE_3 rampageInfo.iRampageIndex = 2 rampageInfo.iTimeLimit = 2 * ONE_MINUTE rampageInfo.sIntroAnim = "trvram_6_1h_intro" rampageInfo.sOutroAnim = "trvram_6_1h_outro" rampageInfo.sOutroRunAnim = "trvram_6_1h_run_outro" rampageInfo.fOutroPhase = 0.19 rampageInfo.fOutroRunPhase = 0.24 rampageInfo.plyrWeapon[0] = WEAPONTYPE_MICROSMG rampageInfo.plyrWeaponComp[0] = WEAPONCOMPONENT_AT_SCOPE_MACRO rampageInfo.plyrWeaponComp[1] = WEAPONCOMPONENT_MICROSMG_CLIP_02 rampageInfo.enemyWeapon[0] = WEAPONTYPE_PISTOL rampageInfo.enemyWeapon[1] = WEAPONTYPE_ASSAULTRIFLE rampageInfo.pedModels[0] = A_M_M_MEXLABOR_01 rampageInfo.pedModels[1] = G_M_Y_MEXGOON_03 rampageInfo.pedModels[2] = A_M_Y_MEXTHUG_01 rampageInfo.pedModels[3] = IG_RAMP_MEX rampageInfo.iMaxPedModels = 3 rampageInfo.carModels[0] = CAVALCADE2 rampageInfo.carModels[1] = VIGERO rampageInfo.iMaxCarModels = 2 rampageInfo.vPlyrStartPos = <<463.9719, -1848.9276, 26.8640>> rampageInfo.fPlyrStartHeading = 135.7623 rampageInfo.vPlyrCarHidePos = << 444.0720, -1861.6890, 26.5592 >> rampageInfo.fPlyrCarHideHeading = 131.0001 rampageInfo.sTargetName = "TR_RTGT3" // Gang Members rampageInfo.sUIName = "TR_RAMP2" rampageInfo.iTargetAmount = 30 iRampageMusicStartTime = 15500 // 15.5 seconds in sVoiceContext = "GENERIC_INSULT_HIGH" sAudioScene = "RAMPAGE_VAGOS_SCENE" BREAK CASE STATIC_BLIP_MINIGAME_RAMPAGE4 rcRampageMissionID = RC_RAMPAGE_4 rampageInfo.iRampageIndex = 3 rampageInfo.iTimeLimit = 2 * ONE_MINUTE rampageInfo.plyrWeapon[0] = WEAPONTYPE_ASSAULTRIFLE rampageInfo.enemyWeapon[0] = WEAPONTYPE_PISTOL rampageInfo.pedModels[0] = G_M_Y_BALLAEAST_01 rampageInfo.pedModels[1] = G_M_Y_BALLAORIG_01 rampageInfo.pedModels[2] = G_M_Y_BALLASOUT_01 rampageInfo.pedModels[3] = IG_RAMP_GANG rampageInfo.iMaxPedModels = 3 rampageInfo.sIntroAnim = "trvram_6_2h_intro" rampageInfo.sOutroAnim = "trvram_6_2h_outro" rampageInfo.sOutroRunAnim = "trvram_6_2h_run_outro" rampageInfo.fOutroPhase = 0.15 rampageInfo.fOutroRunPhase = 0.37 rampageInfo.carModels[0] = ORACLE //TAILGATER rampageInfo.carModels[1] = FELON //DOMINATOR rampageInfo.iMaxCarModels = 2 rampageInfo.vPlyrStartPos = <<-162.3577, -1668.2686, 32.1239>> rampageInfo.fPlyrStartHeading = 327.5840 rampageInfo.vPlyrCarHidePos = << -168.0764, -1633.8662, 32.6486 >> rampageInfo.fPlyrCarHideHeading = 262.9751 rampageInfo.sTargetName = "TR_RTGT4" // Gang Members rampageInfo.sUIName = "TR_RAMP3" rampageInfo.iTargetAmount = 30 vBattleCenter = <<-129.0, -1622.7, 32.1>> iRampageMusicStartTime = 14100 // 14.1 seconds in sAudioScene = "RAMPAGE_BALLAS_SCENE" BREAK CASE STATIC_BLIP_MINIGAME_RAMPAGE5 rcRampageMissionID = RC_RAMPAGE_5 rampageInfo.iRampageIndex = 4 rampageInfo.sIntroAnim = "trvram_6_2h_intro" rampageInfo.sOutroAnim = "trvram_6_2h_outro" rampageInfo.sOutroRunAnim = "trvram_6_2h_run_outro" rampageInfo.fOutroPhase = 0.15 rampageInfo.fOutroRunPhase = 0.37 rampageInfo.plyrWeapon[0] = WEAPONTYPE_GRENADELAUNCHER rampageInfo.plyrWeapon[1] = WEAPONTYPE_ASSAULTRIFLE rampageInfo.enemyWeapon[0] = WEAPONTYPE_PISTOL rampageInfo.enemyWeapon[1] = WEAPONTYPE_ASSAULTRIFLE rampageInfo.pedModels[0] = S_M_Y_MARINE_01 rampageInfo.pedModels[1] = S_M_Y_MARINE_03 // rampageInfo.pedModels[2] = S_M_Y_MARINE_02 rampageInfo.iMaxPedModels = 2 rampageInfo.carModels[0] = CRUSADER rampageInfo.carModels[1] = BARRACKS rampageInfo.carModels[2] = RHINO rampageInfo.iMaxCarModels = 2 rampageInfo.vPlyrStartPos = <<-1295.7534, 2507.1167, 20.2824>> rampageInfo.fPlyrStartHeading = 336.2132 rampageInfo.vPlyrCarHidePos = <<-1317.2107, 2482.0774, 22.8051>> rampageInfo.fPlyrCarHideHeading = 311.7142 rampageInfo.sTargetName = "TR_RTGT5" // Soldiers rampageInfo.sUIName = "TR_RAMP4" rampageInfo.iTargetAmount = 35 rampageInfo.iRandomSeed = 19780921 fPissTakeRocketChance = 0.8 iRampageMusicStartTime = 16000 // 19 seconds in sAudioScene = "RAMPAGE_MILITARY_SCENE" BREAK DEFAULT SCRIPT_ASSERT("THIS BLIP IS NOT A RAMPAGE BLIP") BREAK ENDSWITCH //rampageInfo.iTimeLimit = CEIL(0.5 * ONE_MINUTE) PREPARE_RAMPAGE_ONE_SHOT() // scenario blocking IF NOT IS_VECTOR_ZERO(rampageInfo.vScenarioBlockCenter) AND (rampageInfo.fScenarioBlockRadius > 0.0) CALCULATE_MIN_MAX_FROM_POSITION_AND_RADIUS(rampageInfo.vScenarioBlockCenter, rampageInfo.fScenarioBlockRadius, vmin, vmax) scenarioBlockID = ADD_SCENARIO_BLOCKING_AREA(vmin, vmax) CPRINTLN(DEBUG_RAMPAGE, "BLOCKING SCENARIO AREA ", vmin, " TO ", vmax) ENDIF IF NOT IS_STRING_NULL_OR_EMPTY(rampageInfo.sScenarioGroupName) SET_SCENARIO_GROUP_ENABLED(rampageInfo.sScenarioGroupName, FALSE) CPRINTLN(DEBUG_RAMPAGE, "BLOCKING SCENARIO GROUP", rampageInfo.sScenarioGroupName) ENDIF CALCULATE_MIN_MAX_FROM_POSITION_AND_RADIUS(vBattleCenter, fBattleRadius, vmin, vmax) CPRINTLN(DEBUG_RAMPAGE, "RESETTING PED PATHS AND NAVMESH AROUND ", vmin, " TO ", vmax) DISABLE_NAVMESH_IN_AREA(vmin, vmax, FALSE) SET_PED_PATHS_BACK_TO_ORIGINAL(vmin, vmax) // BLOCK_SCENARIOS_AND_AMBIENT(worldScenarioBlockID, FALSE) ENDPROC /// PURPOSE: /// Populates the rampage spawnsystem struct based on blip enum /// PARAMS: /// bp - rampage blip enum PROC SET_RAMPAGE_COMBAT_PARAMS_FROM_STATIC_BLIP(STATIC_BLIP_NAME_ENUM bp) RESET_COMBAT_PARAMETERS(rampageCombatParams) // then fill them in on a case by case basis SWITCH (bp) CASE STATIC_BLIP_MINIGAME_RAMPAGE1 rampageCombatParams.fWeaponAccuracy1 = 0.12 // 0.06 rampageCombatParams.fWeaponAccuracy2 = 0.12 // 0.06 rampageCombatParams.fNearBlankChance = 0.1 // 0.2 rampageCombatParams.fFarBlankChance = 0.5 // 0.6 rampageCombatParams.iMinShootRate = 30 // 20 rampageCombatParams.iMaxShootRate = 55 // 45 rampageCombatParams.fPlayerWeaponDefenseModifier = 0.25 // 0.2 //@RJP make peds always aggressive and more likely to flank rampageCombatParams.fAgressionChance = 1 rampageCombatParams.fFlankChance = 0.5 BREAK CASE STATIC_BLIP_MINIGAME_RAMPAGE2 rampageCombatParams.fWeaponAccuracy1 = 0.032 rampageCombatParams.fWeaponAccuracy2 = 0.015 rampageCombatParams.fNearBlankChance = 0.4 rampageCombatParams.fFarBlankChance = 0.6 rampageCombatParams.iMinShootRate = 20 rampageCombatParams.iMaxShootRate = 40 rampageCombatParams.fPlayerWeaponDefenseModifier = 0.25 //@RJP making enemies in all rampages more aggressive rampageCombatParams.fAgressionChance = 1 rampageCombatParams.fFlankChance = 0.5 BREAK CASE STATIC_BLIP_MINIGAME_RAMPAGE5 rampageCombatParams.fWeaponAccuracy1 = 0.12 // 0.06 rampageCombatParams.fWeaponAccuracy2 = 0.09 // 0.06 rampageCombatParams.fNearBlankChance = 0.2 // 0.2 rampageCombatParams.fFarBlankChance = 0.6 // 0.6 rampageCombatParams.iMinShootRate = 20 // 20 rampageCombatParams.iMaxShootRate = 50 // 45 rampageCombatParams.fPlayerWeaponDefenseModifier = 0.11 // 0.2 // rampageCombatParams.fAgressionChance = 0.45 //@RJP making enemies in all rampages more aggressive rampageCombatParams.fAgressionChance = 1 rampageCombatParams.fFlankChance = 0.5 BREAK DEFAULT rampageCombatParams.fWeaponAccuracy1 = 0.032 rampageCombatParams.fWeaponAccuracy2 = 0.015 rampageCombatParams.fNearBlankChance = 0.4 rampageCombatParams.fFarBlankChance = 0.6 rampageCombatParams.iMinShootRate = 20 rampageCombatParams.iMaxShootRate = 40 rampageCombatParams.fPlayerWeaponDefenseModifier = 0.2 //@RJP making enemies in all rampages more aggressive rampageCombatParams.fAgressionChance = 1 rampageCombatParams.fFlankChance = 0.5 BREAK ENDSWITCH ENDPROC /// PURPOSE: /// Populates no spawn areas based on blip enum /// PARAMS: /// bp - rampage blip enum PROC SET_RAMPAGE_NO_SPAWN_AREAS_FROM_STATIC_BLIP(STATIC_BLIP_NAME_ENUM bp) iMaxActiveNoSpawnAreas = 0 // then fill them in on a case by case basis SWITCH (bp) CASE STATIC_BLIP_MINIGAME_RAMPAGE1 ADD_NO_SPAWN_AREA(<<899.080017,3616.289307,30.824312>>, <<889.898193,3616.469971,33.862087>>, 6.300000) ADD_NO_SPAWN_AREA(<<900.753662,3579.707275,30.141163>>, <<916.025208,3579.704102,37.618240>>, 13.000000) ADD_NO_SPAWN_AREA(<<908.902710,3571.474121,30.782627>>, <<908.867249,3554.104004,37.818115>>, 12.000000) ADD_NO_SPAWN_AREA(<<985.621765,3578.334961,30.448856>>, <<997.556702,3569.890137,41.186794>>, 9.750000) ADD_NO_SPAWN_AREA(<<954.739319,3617.572510,30.717031>>, <<960.034668,3617.539063,34.758904>>, 8.000000) BREAK CASE STATIC_BLIP_MINIGAME_RAMPAGE2 ADD_NO_SPAWN_AREA(<<1145.495972,-368.676819,66.048904>>, <<1133.037842,-417.905365,77.887863>>, 16.500000) ADD_NO_SPAWN_AREA(<<1186.173950,-386.635620,66.453995>>, <<1156.464722,-379.281464,72.744225>>, 8.750000) BREAK CASE STATIC_BLIP_MINIGAME_RAMPAGE3 ADD_NO_SPAWN_AREA(<<413.366638,-1746.958740,27.106783>>, <<405.916229,-1742.053589,33.078545>>, 7.500000) ADD_NO_SPAWN_AREA(<<444.245178,-1745.233398,26.727312>>, <<435.744415,-1741.421143,32.967648>>, 8.750000) ADD_NO_SPAWN_AREA(<<468.188049,-1802.802124,26.342609>>, <<449.523804,-1787.471436,33.342533>>, 13.000000) ADD_NO_SPAWN_AREA(<<531.593262,-1806.028564,26.562597>>, <<521.041504,-1806.093140,31.505949>>, 10.000000) ADD_NO_SPAWN_AREA(<<419.392212,-1845.889404,25.887005>>, <<425.954987,-1850.847412,28.781279>>, 7.000000) ADD_NO_SPAWN_AREA(<<481.791687,-1735.011353,30.859770>>, <<488.150574,-1737.297607,26.943594>>, 11.200000) BREAK CASE STATIC_BLIP_MINIGAME_RAMPAGE4 ADD_NO_SPAWN_AREA(<<-139.409958,-1648.285156,31.543270>>, <<-133.891083,-1653.293701,34.950226>>, 3.500000) BREAK CASE STATIC_BLIP_MINIGAME_RAMPAGE5 ADD_NO_SPAWN_AREA(<<-1277.212524,2569.290527,22.069016>>, <<-1284.096802,2548.221680,28.853512>>, 19.250000) BREAK DEFAULT SCRIPT_ASSERT("THIS BLIP IS NOT A RAMPAGE BLIP") BREAK ENDSWITCH ENDPROC /// PURPOSE: /// Populates no spawn areas based on blip enum /// PARAMS: /// bp - rampage blip enum PROC SET_RAMPAGE_SPAWNSYSTEM_FROM_STATIC_BLIP(STATIC_BLIP_NAME_ENUM bp) // setup backup spawner rampageBackupCloudSpawner.bIsActive = FALSE rampageBackupCloudSpawner.bPavementOnly = FALSE rampageBackupCloudSpawner.iMinSpawnTime = 250 rampageBackupCloudSpawner.iMaxSpawnTime = 1000 rampageBackupCloudSpawner.fMinSpawnRadius = 30.0 rampageBackupCloudSpawner.fMaxSpawnRadius = 80.0 rampageBackupCloudSpawner.fFleeChance = 0.0 // then fill them in on a case by case basis SWITCH (bp) CASE STATIC_BLIP_MINIGAME_RAMPAGE1 iInitialSpawnDelay = 8000 iInitialCarSpawnDelay = 8000 // setup car spawner rampageCarSpawner.bIsActive = TRUE rampageCarSpawner.bUseSpawnPoints = TRUE rampageCarSpawner.iMaxActiveCars = 1 rampageCarSpawner.iMinSpawnTime = 20000 rampageCarSpawner.iMaxSpawnTime = 40000 SET_RAMPAGE_SPAWN_POINT(rampageCarSpawner.vSpawnPoints[0], <<638.8113, 3575.6160, 31.8078>>, 280.4006) SET_RAMPAGE_SPAWN_POINT(rampageCarSpawner.vSpawnPoints[1], <<677.1325, 3520.3567, 33.1989>>, 276.7284) SET_RAMPAGE_SPAWN_POINT(rampageCarSpawner.vSpawnPoints[2], <<1256.5873, 3540.4756, 34.2046>>, 90.8648) rampageCarSpawner.iSpawnPointsUsed = 3 // setup fortress spawner rampageFortressSpawner.bIsActive = TRUE rampageFortressSpawner.iMaxActiveFortress = 7 rampageFortressSpawner.iMinSpawnTime = 1000 rampageFortressSpawner.iMaxSpawnTime = 3000 SETUP_RAMPAGE_FORTRESS(rampageFort[0], <<898.879761,3595.323242,31.918310>>, <<899.167908,3626.273682,32.514000>>, 30.750000, TRUE, 1) SETUP_RAMPAGE_FORTRESS_SPAWNING(rampageFort[0], 0.0) SETUP_RAMPAGE_FORTRESS(rampageFort[1], <<887.112671,3583.712158,32.403027>>, <<922.399719,3584.079346,34.894115>>, 25.750000, TRUE, 2) SETUP_RAMPAGE_FORTRESS_SPAWNING(rampageFort[1], 0.0) SETUP_RAMPAGE_FORTRESS(rampageFort[2], <<921.673157,3558.021973,32.785378>>, <<878.298828,3557.901611,34.441288>>, 30.750000, TRUE, 3) SETUP_RAMPAGE_FORTRESS_SPAWNING(rampageFort[2], 0.0) SETUP_RAMPAGE_FORTRESS(rampageFort[3], <<1020.117737,3577.570557,31.758381>>, <<968.554504,3573.576172,32.805687>>, 35.250000, TRUE, 4) SETUP_RAMPAGE_FORTRESS_SPAWNING(rampageFort[3], 0.0) SETUP_RAMPAGE_FORTRESS(rampageFort[4], <<977.714905,3614.298828,31.531330>>, <<936.611206,3614.114014,32.604645>>, 29.500000, TRUE, 5) SETUP_RAMPAGE_FORTRESS_SPAWNING(rampageFort[4], 0.0) SETUP_RAMPAGE_FORTRESS(rampageFort[5], <<928.147705,3650.682861,31.363585>>, <<887.448364,3651.773682,32.843071>>, 32.000000, TRUE, 6) SETUP_RAMPAGE_FORTRESS_SPAWNING(rampageFort[5], 0.0) SETUP_RAMPAGE_FORTRESS(rampageFort[6], <<851.545593,3676.695313,31.115583>>, <<871.752380,3671.204346,32.785095>>, 13.500000, TRUE, 0) SETUP_RAMPAGE_FORTRESS_SPAWNING(rampageFort[6], 0.0) BREAK CASE STATIC_BLIP_MINIGAME_RAMPAGE2 iInitialSpawnDelay = 2000 iInitialCarSpawnDelay = 6000 // setup car spawner rampageCarSpawner.bIsActive = TRUE rampageCarSpawner.bUseSpawnPoints = TRUE rampageCarSpawner.iMinActiveCars = 2 rampageCarSpawner.iMaxActiveCars = 4 rampageCarSpawner.iMinSpawnTime = 8000 rampageCarSpawner.iMaxSpawnTime = 12000 SET_RAMPAGE_SPAWN_POINT(rampageCarSpawner.vSpawnPoints[0], <<1261.5217, -392.1491, 68.0716>>, 45.8832) SET_RAMPAGE_SPAWN_POINT(rampageCarSpawner.vSpawnPoints[1], <<1160.7268, -363.8029, 66.4686>>, 249.5359) SET_RAMPAGE_SPAWN_POINT(rampageCarSpawner.vSpawnPoints[2], <<1112.8073, -516.7747, 62.7259>>, 259.5641) SET_RAMPAGE_SPAWN_POINT(rampageCarSpawner.vSpawnPoints[3], <<1222.8971, -524.8954, 65.7801>>, 50.4901) rampageCarSpawner.iSpawnPointsUsed = 4 // spawning rampageAlleySpawner.bIsActive = TRUE rampageAlleySpawner.vAlleyPoints[0] = <<1208.0143, -386.7501, 67.5128>> rampageAlleySpawner.vAlleyPoints[1] = <<1179.5604, -503.5638, 64.3207>> rampageAlleySpawner.fAlleyDiffAdjust = -1 // ground based SET_RAMPAGE_SPAWN_POINT(rampageAlleySpawner.spawnPoint[0], <<1171.7067, -395.8017, 70.5896>>, 179.2177) SET_RAMPAGE_SPAWN_POINT(rampageAlleySpawner.spawnPoint[1], <<1174.9569, -405.9748, 66.7132>>, 237.7915) SET_RAMPAGE_SPAWN_POINT(rampageAlleySpawner.spawnPoint[2], <<1177.9843, -415.0459, 66.4166>>, 263.1743) SET_RAMPAGE_SPAWN_POINT(rampageAlleySpawner.spawnPoint[3], <<1172.0057, -422.1147, 66.0902>>, 248.2870) SET_RAMPAGE_SPAWN_POINT(rampageAlleySpawner.spawnPoint[4], <<1173.9624, -430.9555, 66.0785>>, 215.4900) SET_RAMPAGE_SPAWN_POINT(rampageAlleySpawner.spawnPoint[5], <<1217.7241, -418.0172, 66.7731>>, 104.3705) SET_RAMPAGE_SPAWN_POINT(rampageAlleySpawner.spawnPoint[6], <<1228.4182, -390.4437, 68.0662>>, 67.1844) SET_RAMPAGE_SPAWN_POINT(rampageAlleySpawner.spawnPoint[7], <<1219.3175, -424.2363, 66.6526>>, 85.3891) SET_RAMPAGE_SPAWN_POINT(rampageAlleySpawner.spawnPoint[8], <<1215.1510, -438.7675, 66.1798>>, 64.3428) SET_RAMPAGE_SPAWN_POINT(rampageAlleySpawner.spawnPoint[9], <<1168.2654, -457.0743, 65.6949>>, 274.1016) SET_RAMPAGE_SPAWN_POINT(rampageAlleySpawner.spawnPoint[10], <<1158.5686, -454.4118, 65.9844>>, 248.8965) SET_RAMPAGE_SPAWN_POINT(rampageAlleySpawner.spawnPoint[11], <<1140.5071, -461.1952, 65.9288>>, 269.3017) SET_RAMPAGE_SPAWN_POINT(rampageAlleySpawner.spawnPoint[12], <<1133.4406, -480.2752, 65.0497>>, 246.3703) SET_RAMPAGE_SPAWN_POINT(rampageAlleySpawner.spawnPoint[13], <<1131.1036, -481.0168, 64.9569>>, 242.0116) SET_RAMPAGE_SPAWN_POINT(rampageAlleySpawner.spawnPoint[14], <<1123.4287, -502.5286, 63.0634>>, 290.4138) SET_RAMPAGE_SPAWN_POINT(rampageAlleySpawner.spawnPoint[15], <<1130.8507, -501.8386, 63.2847>>, 278.3421) SET_RAMPAGE_SPAWN_POINT(rampageAlleySpawner.spawnPoint[16], <<1202.5520, -505.4180, 64.1416>>, 55.5955) SET_RAMPAGE_SPAWN_POINT(rampageAlleySpawner.spawnPoint[17], <<1203.6964, -507.7457, 64.3037>>, 45.4403) SET_RAMPAGE_SPAWN_POINT(rampageAlleySpawner.spawnPoint[18], <<1207.2788, -470.6629, 65.1517>>, 81.1791) SET_RAMPAGE_SPAWN_POINT(rampageAlleySpawner.spawnPoint[19], <<1205.9600, -469.2520, 65.2501>>, 124.0248) SET_RAMPAGE_SPAWN_POINT(rampageAlleySpawner.spawnPoint[20], <<1207.1526, -463.4705, 65.4440>>, 110.4368) SET_RAMPAGE_SPAWN_POINT(rampageAlleySpawner.spawnPoint[21], <<1212.2612, -445.3408, 65.9532>>, 94.8838) rampageAlleySpawner.iMaxActiveSpawnPoints = 22 BREAK CASE STATIC_BLIP_MINIGAME_RAMPAGE3 iInitialSpawnDelay = 5000 iInitialCarSpawnDelay = 10000 // setup fortress spawner rampageFortressSpawner.bIsActive = TRUE rampageFortressSpawner.iMaxActiveFortress = 8 rampageFortressSpawner.iMinSpawnTime = 1000 rampageFortressSpawner.iMaxSpawnTime = 3000 SETUP_RAMPAGE_FORTRESS(rampageFort[0], <<491.036011,-1816.695068,26.366055>>, <<508.153839,-1831.315796,29.419441>>, 25.000000, TRUE, 1) SETUP_RAMPAGE_FORTRESS_SPAWNING(rampageFort[0], 0.0) SETUP_RAMPAGE_FORTRESS(rampageFort[1], <<433.541656,-1774.958252,29.387346>>, <<471.039612,-1807.620605,26.340366>>, 20.000000, TRUE, 2) SETUP_RAMPAGE_FORTRESS_SPAWNING(rampageFort[1], 0.0) SETUP_RAMPAGE_FORTRESS(rampageFort[2], <<507.713135,-1790.534058,26.500551>>, <<533.069275,-1790.829346,30.167883>>, 39.000000, TRUE, 3) SETUP_RAMPAGE_FORTRESS_SPAWNING(rampageFort[2], 0.0) SETUP_RAMPAGE_FORTRESS(rampageFort[3], <<484.440094,-1755.382446,29.064936>>, <<451.243195,-1742.952759,27.251459>>, 22.250000, TRUE, 4) SETUP_RAMPAGE_FORTRESS_SPAWNING(rampageFort[3], 0.0) SETUP_RAMPAGE_FORTRESS(rampageFort[4], <<458.570557,-1721.835205,29.504240>>, <<491.081787,-1734.426636,27.306875>>, 25.000000, TRUE, 5) SETUP_RAMPAGE_FORTRESS_SPAWNING(rampageFort[4], 0.0) SETUP_RAMPAGE_FORTRESS(rampageFort[5], <<519.821716,-1763.702393,26.695234>>, <<538.813416,-1722.355957,31.265846>>, 32.000000, TRUE, 6) SETUP_RAMPAGE_FORTRESS_SPAWNING(rampageFort[5], 0.0) SETUP_RAMPAGE_FORTRESS(rampageFort[6], <<480.949249,-1717.530273,29.864294>>, <<503.944916,-1684.640991,27.394945>>, 25.000000, TRUE, 7) SETUP_RAMPAGE_FORTRESS_SPAWNING(rampageFort[6], 0.0) SETUP_RAMPAGE_FORTRESS(rampageFort[7], <<436.893097,-1841.786865,25.842968>>, <<413.346313,-1817.801025,29.323025>>, 40.000000, TRUE, 0) SETUP_RAMPAGE_FORTRESS_SPAWNING(rampageFort[7], 0.0) // spawning rampageAlleySpawner.bIsActive = FALSE // roof top molotov throwers SET_RAMPAGE_SPAWN_POINT(rampageAlleySpawner.spawnPoint[0], <<467.5966, -1853.2515, 32.0385>>, 15.2180, TRUE) SET_RAMPAGE_SPAWN_POINT(rampageAlleySpawner.spawnPoint[1], <<441.4879, -1827.1527, 30.6772>>, 269.2424, TRUE) SET_RAMPAGE_SPAWN_POINT(rampageAlleySpawner.spawnPoint[2], <<425.6849, -1850.3021, 29.6723>>, 232.5502, TRUE) SET_RAMPAGE_SPAWN_POINT(rampageAlleySpawner.spawnPoint[3], <<474.1450, -1861.8615, 32.0385>>, 304.1951, TRUE) SET_RAMPAGE_SPAWN_POINT(rampageAlleySpawner.spawnPoint[4], <<488.6247, -1827.9253, 31.0552>>, 44.0614, TRUE) SET_RAMPAGE_SPAWN_POINT(rampageAlleySpawner.spawnPoint[5], <<502.1079, -1814.2856, 32.7449>>, 43.2727, TRUE) SET_RAMPAGE_SPAWN_POINT(rampageAlleySpawner.spawnPoint[6], <<507.4474, -1797.3165, 30.3208>>, 65.9409, TRUE) SET_RAMPAGE_SPAWN_POINT(rampageAlleySpawner.spawnPoint[7], <<512.1399, -1788.1361, 31.2764>>, 106.2277, TRUE) SET_RAMPAGE_SPAWN_POINT(rampageAlleySpawner.spawnPoint[8], <<487.3958, -1730.4272, 31.0703>>, 211.2030, TRUE) SET_RAMPAGE_SPAWN_POINT(rampageAlleySpawner.spawnPoint[9], <<478.1194, -1740.2147, 31.7743>>, 232.2849, TRUE) SET_RAMPAGE_SPAWN_POINT(rampageAlleySpawner.spawnPoint[10], <<474.0694, -1760.0837, 31.5086>>, 250.7436, TRUE) SET_RAMPAGE_SPAWN_POINT(rampageAlleySpawner.spawnPoint[11], <<475.3656, -1772.2528, 31.1009>>, 267.3608, TRUE) SET_RAMPAGE_SPAWN_POINT(rampageAlleySpawner.spawnPoint[12], <<477.9729, -1792.3981, 31.2899>>, 235.5816, TRUE) SET_RAMPAGE_SPAWN_POINT(rampageAlleySpawner.spawnPoint[13], <<470.5758, -1797.9939, 31.4238>>, 264.4785, TRUE) SET_RAMPAGE_SPAWN_POINT(rampageAlleySpawner.spawnPoint[14], <<463.8697, -1805.9473, 31.4137>>, 177.1468, TRUE) SET_RAMPAGE_SPAWN_POINT(rampageAlleySpawner.spawnPoint[15], <<447.8933, -1792.6598, 31.3978>>, 141.8946, TRUE) SET_RAMPAGE_SPAWN_POINT(rampageAlleySpawner.spawnPoint[16], <<428.7633, -1813.7426, 30.6083>>, 297.5291, TRUE) // SET_RAMPAGE_SPAWN_POINT(rampageAlleySpawner.spawnPoint[3], <<444.2840, -1867.4685, 30.3466>>, 53.9152, TRUE) rampageAlleySpawner.iMaxActiveSpawnPoints = 17 // setup car spawner rampageCarSpawner.bIsActive = TRUE rampageCarSpawner.bUseSpawnPoints = TRUE rampageCarSpawner.iMaxActiveCars = 1 rampageCarSpawner.iMinSpawnTime = 20000 rampageCarSpawner.iMaxSpawnTime = 30000 SET_RAMPAGE_SPAWN_POINT(rampageCarSpawner.vSpawnPoints[0], <<406.0836, -1916.9851, 24.0788>>, 44.7007) SET_RAMPAGE_SPAWN_POINT(rampageCarSpawner.vSpawnPoints[1], <<533.4858, -1889.4647, 24.4219>>, 102.9549) SET_RAMPAGE_SPAWN_POINT(rampageCarSpawner.vSpawnPoints[2], <<543.5394, -1713.4049, 28.2633>>, 59.5502) SET_RAMPAGE_SPAWN_POINT(rampageCarSpawner.vSpawnPoints[3], <<413.8781, -1810.7837, 27.7617>>, 303.4869) rampageCarSpawner.iSpawnPointsUsed = 4 BREAK CASE STATIC_BLIP_MINIGAME_RAMPAGE4 iInitialSpawnDelay = 5000 iInitialCarSpawnDelay = 8000 // spawning rampageAlleySpawner.bIsActive = TRUE rampageAlleySpawner.vAlleyPoints[0] = <<-162.145447,-1663.402344,32.8>> rampageAlleySpawner.vAlleyPoints[1] = <<-91.898834,-1579.666504,31.5>> rampageAlleySpawner.fAlleyRadius = 10.0 // ground based SET_RAMPAGE_SPAWN_POINT(rampageAlleySpawner.spawnPoint[0], <<-148.5, -1668.9, 32.3>>, 0.0) SET_RAMPAGE_SPAWN_POINT(rampageAlleySpawner.spawnPoint[1], <<-135.4, -1651.9, 32.3>>, 0.0) SET_RAMPAGE_SPAWN_POINT(rampageAlleySpawner.spawnPoint[2], <<-149.8, -1630.2, 33.1>>, 0.0) SET_RAMPAGE_SPAWN_POINT(rampageAlleySpawner.spawnPoint[3], <<-119.9, -1637.4, 32.2>>, 0.0) SET_RAMPAGE_SPAWN_POINT(rampageAlleySpawner.spawnPoint[4], <<-140.5, -1612.6, 33.3>>, 0.0) SET_RAMPAGE_SPAWN_POINT(rampageAlleySpawner.spawnPoint[5], <<-98.7, -1607.7, 31.9>>, 0.0) SET_RAMPAGE_SPAWN_POINT(rampageAlleySpawner.spawnPoint[6], <<-117.7, -1591.1, 33.3>>, 0.0) SET_RAMPAGE_SPAWN_POINT(rampageAlleySpawner.spawnPoint[7], <<-104.0, -1567.6, 32.7>>, 0.0) SET_RAMPAGE_SPAWN_POINT(rampageAlleySpawner.spawnPoint[8], <<-77.9, -1588.7, 30.4>>, 0.0) //roof top points SET_RAMPAGE_SPAWN_POINT(rampageAlleySpawner.spawnPoint[9], <<-95.6932, -1595.2693, 37.5381>>, 119.5596, TRUE) SET_RAMPAGE_SPAWN_POINT(rampageAlleySpawner.spawnPoint[10], <<-106.9553, -1586.2290, 39.4618>>, 231.9059, TRUE) SET_RAMPAGE_SPAWN_POINT(rampageAlleySpawner.spawnPoint[11], <<-125.7233, -1608.6276, 40.5382>>, 211.3573, TRUE) SET_RAMPAGE_SPAWN_POINT(rampageAlleySpawner.spawnPoint[12], <<-116.0610, -1620.4855, 38.8444>>, 48.9904, TRUE) SET_RAMPAGE_SPAWN_POINT(rampageAlleySpawner.spawnPoint[13], <<-144.6918, -1631.8112, 39.7488>>, 210.9559, TRUE) SET_RAMPAGE_SPAWN_POINT(rampageAlleySpawner.spawnPoint[14], <<-138.2615, -1645.8605, 39.0303>>, 14.7954, TRUE) SET_RAMPAGE_SPAWN_POINT(rampageAlleySpawner.spawnPoint[15], <<-172.5470, -1649.6149, 32.4385>>, 173.3268) SET_RAMPAGE_SPAWN_POINT(rampageAlleySpawner.spawnPoint[16], <<-175.8211, -1646.3540, 32.3339>>, 178.1288) SET_RAMPAGE_SPAWN_POINT(rampageAlleySpawner.spawnPoint[17], <<-165.5250, -1690.7644, 31.2333>>, 20.2723) // air based // SET_RAMPAGE_SPAWN_POINT(rampageAlleySpawner.spawnPoint[9], <<-150.9, -1662.3, 36.5>>, 0.0, TRUE) // SET_RAMPAGE_SPAWN_POINT(rampageAlleySpawner.spawnPoint[10], <<-149.9, -1659.4, 36.5>>, 0.0, TRUE) // // SET_RAMPAGE_SPAWN_POINT(rampageAlleySpawner.spawnPoint[11], <<-159.3, -1649.0, 37.7>>, 0.0, TRUE) // SET_RAMPAGE_SPAWN_POINT(rampageAlleySpawner.spawnPoint[12], <<-161.1, -1652.2, 37.7>>, 0.0, TRUE) // // SET_RAMPAGE_SPAWN_POINT(rampageAlleySpawner.spawnPoint[13], <<-155.2, -1645.0, 37.7>>, 0.0, TRUE) // // SET_RAMPAGE_SPAWN_POINT(rampageAlleySpawner.spawnPoint[14], <<-143.8, -1653.6, 36.5>>, 0.0, TRUE) // SET_RAMPAGE_SPAWN_POINT(rampageAlleySpawner.spawnPoint[15], <<-142.2, -1650.6, 36.5>>, 0.0, TRUE) // // SET_RAMPAGE_SPAWN_POINT(rampageAlleySpawner.spawnPoint[16], <<-137.0, -1644.8, 36.5>>, 0.0, TRUE) // SET_RAMPAGE_SPAWN_POINT(rampageAlleySpawner.spawnPoint[17], <<-136.1, -1642.7, 36.5>>, 0.0, TRUE) // // SET_RAMPAGE_SPAWN_POINT(rampageAlleySpawner.spawnPoint[18], <<-131.1, -1636.8, 36.5>>, 0.0, TRUE) // // SET_RAMPAGE_SPAWN_POINT(rampageAlleySpawner.spawnPoint[19], <<-124.0, -1628.9, 35.9>>, 0.0, TRUE) // // SET_RAMPAGE_SPAWN_POINT(rampageAlleySpawner.spawnPoint[20], <<-119.4, -1623.3, 35.9>>, 0.0, TRUE) // SET_RAMPAGE_SPAWN_POINT(rampageAlleySpawner.spawnPoint[21], <<-117.5, -1620.5, 35.9>>, 0.0, TRUE) // // SET_RAMPAGE_SPAWN_POINT(rampageAlleySpawner.spawnPoint[22], <<-127.7, -1611.2, 37.8>>, 0.0, TRUE) // SET_RAMPAGE_SPAWN_POINT(rampageAlleySpawner.spawnPoint[23], <<-129.5, -1613.6, 37.8>>, 0.0, TRUE) //roof top points // SET_RAMPAGE_SPAWN_POINT(rampageAlleySpawner.spawnPoint[24], <<-95.6932, -1595.2693, 37.5381>>, 119.5596, TRUE) // SET_RAMPAGE_SPAWN_POINT(rampageAlleySpawner.spawnPoint[25], <<-106.9553, -1586.2290, 39.4618>>, 231.9059, TRUE) // SET_RAMPAGE_SPAWN_POINT(rampageAlleySpawner.spawnPoint[26], <<-125.7233, -1608.6276, 40.5382>>, 211.3573, TRUE) // SET_RAMPAGE_SPAWN_POINT(rampageAlleySpawner.spawnPoint[27], <<-116.0610, -1620.4855, 38.8444>>, 48.9904, TRUE) // SET_RAMPAGE_SPAWN_POINT(rampageAlleySpawner.spawnPoint[28], <<-144.6918, -1631.8112, 39.7488>>, 210.9559, TRUE) // SET_RAMPAGE_SPAWN_POINT(rampageAlleySpawner.spawnPoint[29], <<-138.2615, -1645.8605, 39.0303>>, 14.7954, TRUE) // // SET_RAMPAGE_SPAWN_POINT(rampageAlleySpawner.spawnPoint[30], <<-172.5470, -1649.6149, 32.4385>>, 173.3268) // SET_RAMPAGE_SPAWN_POINT(rampageAlleySpawner.spawnPoint[31], <<-175.8211, -1646.3540, 32.3339>>, 178.1288) // SET_RAMPAGE_SPAWN_POINT(rampageAlleySpawner.spawnPoint[32], <<-165.5250, -1690.7644, 31.2333>>, 20.2723) rampageAlleySpawner.iMaxActiveSpawnPoints = 18 // setup car spawner rampageCarSpawner.bIsActive = TRUE rampageCarSpawner.bUseSpawnPoints = TRUE rampageCarSpawner.iMaxActiveCars = 1 rampageCarSpawner.iMinSpawnTime = 20000 rampageCarSpawner.iMaxSpawnTime = 30000 SET_RAMPAGE_SPAWN_POINT(rampageCarSpawner.vSpawnPoints[0], <<-102.4641, -1560.3872, 32.0852>>, 228.8770) SET_RAMPAGE_SPAWN_POINT(rampageCarSpawner.vSpawnPoints[1], <<-62.2571, -1593.2477, 28.5327>>, 43.1166) rampageCarSpawner.iSpawnPointsUsed = 2 BREAK CASE STATIC_BLIP_MINIGAME_RAMPAGE5 iInitialSpawnDelay = 8000 iInitialCarSpawnDelay = 5000 iMaxActivePeds = MAX_ACTIVE_PEDS rampageCarSpawner.bIsActive = TRUE rampageCarSpawner.bUseSpawnPoints = TRUE rampageCarSpawner.iMinActiveCars = 2 rampageCarSpawner.iMaxActiveCars = 4 rampageCarSpawner.iMinSpawnTime = 4000 rampageCarSpawner.iMaxSpawnTime = 10000 rampageCloudSpawner.fMinSpawnRadius = 20.0 rampageCloudSpawner.fMaxSpawnRadius = 60.0 SET_RAMPAGE_SPAWN_POINT(rampageCarSpawner.vSpawnPoints[0], <<-1111.0688, 2673.1702, 17.5640>>, 134.8095) SET_RAMPAGE_SPAWN_POINT(rampageCarSpawner.vSpawnPoints[1], <<-1504.7275, 2397.6868, 25.2559>>, 269.3951) SET_RAMPAGE_SPAWN_POINT(rampageCarSpawner.vSpawnPoints[2], <<-1536.2335, 2740.8357, 16.6437>>, 233.2830) rampageCarSpawner.iSpawnPointsUsed = 3 BREAK DEFAULT SCRIPT_ASSERT("THIS BLIP IS NOT A RAMPAGE BLIP") BREAK ENDSWITCH ENDPROC PROC CLEANUP_EXPLOSIVE_PROPS() INT i REPEAT MAX_EXPLOSIVE_PROPS i IF DOES_ENTITY_EXIST( explosiveObject[i].objID ) SET_OBJECT_AS_NO_LONGER_NEEDED( explosiveObject[i].objID ) explosiveObject[i].bCreated = FALSE ENDIF ENDREPEAT ENDPROC PROC CREATE_EXLOSIVE_PROPS() IF NOT rampageInfo.bExplosiveProps EXIT ENDIF INT i REPEAT MAX_EXPLOSIVE_PROPS i IF NOT explosiveObject[i].bCreated IF NOT DOES_ENTITY_EXIST( explosiveObject[i].objID ) explosiveObject[i].objID = CREATE_OBJECT( rampageInfo.explosiveModel, explosiveObject[i].pos ) SET_ENTITY_ROTATION( explosiveObject[i].objID, explosiveObject[i].rot ) explosiveObject[i].bCreated = TRUE ENDIF ENDIF ENDREPEAT ENDPROC PROC SETUP_EXPLOSIVE_PROP( RAMPAGE_EXPLOSIVE_PROP &expProp, VECTOR pos, VECTOR rot ) expProp.pos = pos expProp.rot = rot ENDPROC PROC SETUP_RAMPAGE_EXPLOSIVE_PROPS( STATIC_BLIP_NAME_ENUM bp ) SWITCH bp CASE STATIC_BLIP_MINIGAME_RAMPAGE1 SETUP_EXPLOSIVE_PROP( explosiveObject[0], <<917.5861, 3593.5764, 32.1551>>, <<0,0,0>> ) SETUP_EXPLOSIVE_PROP( explosiveObject[1], <<899.7161, 3607.4707, 31.8142>>, <<0,0,0>> ) SETUP_EXPLOSIVE_PROP( explosiveObject[2], <<889.1971, 3618.6641, 31.8218>>, <<0,0,0>> ) SETUP_EXPLOSIVE_PROP( explosiveObject[3], <<901.7499, 3586.1833, 32.4256>>, <<0,0,0>> ) SETUP_EXPLOSIVE_PROP( explosiveObject[4], <<915.1172, 3569.6101, 32.7876>>, <<0,0,0>> ) SETUP_EXPLOSIVE_PROP( explosiveObject[5], <<979.5751, 3584.9543, 32.4930>>, <<0,0,0>> ) SETUP_EXPLOSIVE_PROP( explosiveObject[6], <<999.9662, 3583.3921, 32.6675>>, <<0,0,0>> ) SETUP_EXPLOSIVE_PROP( explosiveObject[7], <<956.1263, 3620.4758, 31.6291>>, <<0,0,0>> ) SETUP_EXPLOSIVE_PROP( explosiveObject[8], <<864.4873, 3671.1313, 31.8982>>, <<0,0,0>> ) SETUP_EXPLOSIVE_PROP( explosiveObject[9], <<921.76, 3644.44, 31.5245>>, <<0,0,0>> ) BREAK ENDSWITCH ENDPROC /// PURPOSE: /// Populates the rampage info struct based on blip enum /// PARAMS: /// bp - rampage blip enum PROC SET_RAMPAGE_CHALLENGE_FROM_STATIC_BLIP(STATIC_BLIP_NAME_ENUM bp) RESET_CHALLENGE_ARRAY(rampageChallenge) // then fill them in on a case by case basis SWITCH (bp) CASE STATIC_BLIP_MINIGAME_RAMPAGE1 SET_CHALLENGE(rampageChallenge[0], CHALLENGE_OVERKILL, 45) SET_CHALLENGE(rampageChallenge[1], CHALLENGE_HEADSHOT, 3) SET_CHALLENGE(rampageChallenge[2], CHALLENGE_VEHICLES, 2) //SET_CHALLENGE(rampageChallenge[3], CHALLENGE_KILLSTREAK, 4) BREAK CASE STATIC_BLIP_MINIGAME_RAMPAGE2 SET_CHALLENGE(rampageChallenge[0], CHALLENGE_OVERKILL, 30) SET_CHALLENGE(rampageChallenge[1], CHALLENGE_HEADSHOT, 10) SET_CHALLENGE(rampageChallenge[2], CHALLENGE_VEHICLES, 2) //SET_CHALLENGE(rampageChallenge[2], CHALLENGE_EXECUTION, 5) //SET_CHALLENGE(rampageChallenge[3], CHALLENGE_KILLSTREAK, 5) BREAK CASE STATIC_BLIP_MINIGAME_RAMPAGE3 SET_CHALLENGE(rampageChallenge[0], CHALLENGE_OVERKILL, 45) SET_CHALLENGE(rampageChallenge[1], CHALLENGE_HEADSHOT, 6) SET_CHALLENGE(rampageChallenge[2], CHALLENGE_VEHICLES, 2) //SET_CHALLENGE(rampageChallenge[3], CHALLENGE_KILLSTREAK, 6) BREAK CASE STATIC_BLIP_MINIGAME_RAMPAGE4 SET_CHALLENGE(rampageChallenge[0], CHALLENGE_OVERKILL, 50) SET_CHALLENGE(rampageChallenge[1], CHALLENGE_HEADSHOT, 6) SET_CHALLENGE(rampageChallenge[2], CHALLENGE_VEHICLES, 2) //SET_CHALLENGE(rampageChallenge[3], CHALLENGE_KILLSTREAK, 7) BREAK CASE STATIC_BLIP_MINIGAME_RAMPAGE5 SET_CHALLENGE(rampageChallenge[0], CHALLENGE_OVERKILL, 45) SET_CHALLENGE(rampageChallenge[1], CHALLENGE_HEADSHOT, 6) SET_CHALLENGE(rampageChallenge[2], CHALLENGE_TANK, 2) //SET_CHALLENGE(rampageChallenge[3], CHALLENGE_KILLSTREAK, 8) BREAK ENDSWITCH ENDPROC /// PURPOSE: /// Setups the rampage systems based on blip enum /// PARAMS: /// bp - rampage blip enum PROC SET_RAMPAGE_FROM_STATIC_BLIP(STATIC_BLIP_NAME_ENUM bp) RC_PLAYER_TRIGGER_SCENE_LOCK_IN() SET_RAMPAGE_INFO_FROM_STATIC_BLIP(bp) SET_RAMPAGE_NO_SPAWN_AREAS_FROM_STATIC_BLIP(bp) SET_RAMPAGE_SPAWNSYSTEM_FROM_STATIC_BLIP(bp) SET_RAMPAGE_COMBAT_PARAMS_FROM_STATIC_BLIP(bp) SET_RAMPAGE_CHALLENGE_FROM_STATIC_BLIP(bp) IF rampageInfo.bExplosiveProps SETUP_RAMPAGE_EXPLOSIVE_PROPS(bp) ENDIF SET_PED_DENSITY_MULTIPLIER_THIS_FRAME(rampageInfo.fAmbientPedDensity) SET_VEHICLE_DENSITY_MULTIPLIER_THIS_FRAME(rampageInfo.fAmbientCarDensity) // do check to see if we have beaten rampage score and write medal to CPRINTLN(DEBUG_RAMPAGE, "-PRE RAMPAGE SAVE DATA CHECK----------------------") CPRINTLN(DEBUG_RAMPAGE, " RAMPAGE #:", rampageInfo.iRampageIndex) CPRINTLN(DEBUG_RAMPAGE, "") CPRINTLN(DEBUG_RAMPAGE, " SAVED MEDAL INDEX :", g_savedGlobals.sRampageData.playerData[rampageInfo.iRampageIndex].iMedalIndex) CPRINTLN(DEBUG_RAMPAGE, " SAVED HIGH SCORE :", g_savedGlobals.sRampageData.playerData[rampageInfo.iRampageIndex].iHighScore) CPRINTLN(DEBUG_RAMPAGE, "--------------------------------------------------") ENDPROC /// PURPOSE: /// Initializes the rampage /// PARAMS: /// sData - script arg data (this passed in from the launcher) PROC RAMPAGE_SETUP(g_structRCScriptArgs& sData) INT i // fill in text for z skip menu #IF IS_DEBUG_BUILD sSkipMenu[0].sTxtLabel = "INTRO" sSkipMenu[1].sTxtLabel = "BATTLE" sSkipMenu[2].sTxtLabel = "STAGE CLEAR" #ENDIF // fill in array for medal colors medalHudColor[0] = HUD_COLOUR_RED medalHudColor[1] = HUD_COLOUR_BRONZE medalHudColor[2] = HUD_COLOUR_SILVER medalHudColor[3] = HUD_COLOUR_GOLD // setup groups and script arguments g_bIsOnRampage = TRUE g_RestoreStoredWeaponsOnDeath = TRUE rampageScriptArgs = sData CPRINTLN(DEBUG_RAMPAGE, "RAMPAGE VERSION", RAMPAGE_VERSION) #IF USE_TU_CHANGES CPRINTLN(DEBUG_RAMPAGE, "TU CHANGES ARE IN EFFECT") CPRINTLN(DEBUG_RAMPAGE, "Disabling all Cheats - Current Cheat Variable:", g_iBitsetCheatsUsedThisSession) DISABLE_CHEAT(CHEAT_TYPE_ALL, TRUE) iOldCheatStateVariable = g_iBitsetCheatsUsedThisSession g_iBitsetCheatsUsedThisSession = 0 #ENDIF // SPECIAL_ABILITY_LOCK(GET_PLAYER_PED_MODEL(CHAR_TREVOR)) // SPECIAL_ABILITY_RESET(PLAYER_ID()) ADD_RELATIONSHIP_GROUP("RamageGrp", activeGroup) ADD_RELATIONSHIP_GROUP("PassiveGrp", activePassiveGroup) SET_RELATIONSHIP_BETWEEN_GROUPS(ACQUAINTANCE_TYPE_PED_HATE, RELGROUPHASH_PLAYER, activeGroup) SET_RELATIONSHIP_BETWEEN_GROUPS(ACQUAINTANCE_TYPE_PED_HATE, activeGroup, RELGROUPHASH_PLAYER) SET_RELATIONSHIP_BETWEEN_GROUPS(ACQUAINTANCE_TYPE_PED_IGNORE, RELGROUPHASH_PLAYER, activePassiveGroup) SET_RELATIONSHIP_BETWEEN_GROUPS(ACQUAINTANCE_TYPE_PED_IGNORE, activePassiveGroup, RELGROUPHASH_PLAYER) SET_RELATIONSHIP_BETWEEN_GROUPS(ACQUAINTANCE_TYPE_PED_LIKE, activePassiveGroup, activeGroup) SET_RELATIONSHIP_BETWEEN_GROUPS(ACQUAINTANCE_TYPE_PED_LIKE, activeGroup, activePassiveGroup) SET_RELATIONSHIP_BETWEEN_GROUPS(ACQUAINTANCE_TYPE_PED_IGNORE, RELGROUPHASH_PLAYER, RELGROUPHASH_AMBIENT_GANG_FAMILY) SET_RELATIONSHIP_BETWEEN_GROUPS(ACQUAINTANCE_TYPE_PED_IGNORE, RELGROUPHASH_PLAYER, RELGROUPHASH_AMBIENT_GANG_MEXICAN) SET_RELATIONSHIP_BETWEEN_GROUPS(ACQUAINTANCE_TYPE_PED_IGNORE, RELGROUPHASH_PLAYER, RELGROUPHASH_AMBIENT_GANG_LOST) SET_RELATIONSHIP_BETWEEN_GROUPS(ACQUAINTANCE_TYPE_PED_IGNORE, RELGROUPHASH_AMBIENT_GANG_FAMILY, RELGROUPHASH_PLAYER) SET_RELATIONSHIP_BETWEEN_GROUPS(ACQUAINTANCE_TYPE_PED_IGNORE, RELGROUPHASH_AMBIENT_GANG_MEXICAN, RELGROUPHASH_PLAYER) SET_RELATIONSHIP_BETWEEN_GROUPS(ACQUAINTANCE_TYPE_PED_IGNORE, RELGROUPHASH_AMBIENT_GANG_LOST, RELGROUPHASH_PLAYER) SET_PLAYER_CAN_BE_HASSLED_BY_GANGS(PLAYER_ID(), FALSE) // turn off ambient things and cellphones DISABLE_CELLPHONE(TRUE) ENABLE_ALL_DISPATCH_SERVICES(FALSE) SUPPRESS_PICKUP_REWARD_TYPE(PICKUP_REWARD_TYPE_ALL, TRUE) STOP_ANY_PED_MODEL_BEING_SUPPRESSED() SET_ALL_SHOPS_TEMPORARILY_UNAVAILABLE(TRUE) SET_PLAYER_HEALTH_RECHARGE_MULTIPLIER(PLAYER_ID(), fHPRegenMult) // turn off debug lines - just incase i forget SET_DEBUG_LINES_AND_SPHERES_DRAWING_ACTIVE(FALSE) // clear wanted levels and cars and vehicles and stop scenario peds from messing about IF IS_ENTITY_OK(PLAYER_PED_ID()) SET_MAX_WANTED_LEVEL(0) SET_PLAYER_WANTED_LEVEL(PLAYER_ID(), 0) SET_PLAYER_WANTED_LEVEL_NOW(PLAYER_ID()) SET_DISPATCH_COPS_FOR_PLAYER(PLAYER_ID(), FALSE) ENDIF RELEASE_SCRIPT_AUDIO_BANK() // fill index values i = 0 REPEAT COUNT_OF(rampagePed) i rampagePed[i].iIndex = i ENDREPEAT i = 0 REPEAT COUNT_OF(rampageCar) i rampageCar[i].iIndex = i ENDREPEAT #IF IS_DEBUG_BUILD START_RAMPAGE_DEBUG_WIDGET_GROUP() #ENDIF ENDPROC /// PURPOSE: /// Cleanups the rampage and shuts down everything /// PARAMS: /// bPlayerDied - Call this if the player died PROC RAMPAGE_CLEANUP(BOOL bPlayerDead = FALSE) INT i WEAPON_TYPE currentWeapon // mark us as not being on rampage STOP_STREAM() IF (bPlayerDead) TRIGGER_MUSIC_EVENT("RAMPAGE_FAIL") ENDIF CPRINTLN(DEBUG_RAMPAGE, "RAMPAGE_CLEANUP() - START") IF NOT IS_STRING_NULL_OR_EMPTY(sAudioScene) IF IS_AUDIO_SCENE_ACTIVE(sAudioScene) STOP_AUDIO_SCENE(sAudioScene) CPRINTLN(DEBUG_RAMPAGE, "RAMPAGE_CLEANUP() - AUDIO SCENE STOPED") ENDIF ENDIF #IF USE_TU_CHANGES CPRINTLN(DEBUG_RAMPAGE, "RAMPAGE_CLEANUP() - RE ENABLING ANY CHEATS WHICH WERE ACTIVE BEFORE") CPRINTLN(DEBUG_RAMPAGE, " RESTORING CHEAT VARIABLE:", iOldCheatStateVariable) DISABLE_CHEAT(CHEAT_TYPE_ALL, FALSE) g_iBitsetCheatsUsedThisSession = iOldCheatStateVariable #ENDIF STOP_RAMPAGE_FX() // CLEAR_TIMECYCLE_MODIFIER() STOP_SOUND(i_sound_countdown) IF IS_GAMEPLAY_HINT_ACTIVE() STOP_GAMEPLAY_HINT() ENDIF IF rampageInfo.blipNameEnum = STATIC_BLIP_MINIGAME_RAMPAGE2 RELEASE_FAKE_CELLPHONE_MOVIE(sFakeCellphoneData) ENDIF FORCE_REMOVE_ALL_BLIPS() RESET_PLAYER_RAMPAGE_INFINITE_AMMO() SET_ALL_SHOPS_TEMPORARILY_UNAVAILABLE(FALSE) #IF IS_DEBUG_BUILD CLEANUP_RAMPAGE_DEBUG_WIDGETS() #ENDIF SAFE_REMOVE_BLIP(battleBlip) SAFE_RELEASE_OBJECT(plyrGunObject) plyrGunObject = NULL // restore weapons - make him drop weapon when he dies IF NOT IS_ENTITY_OK(PLAYER_PED_ID()) IF GET_CURRENT_PED_WEAPON(PLAYER_PED_ID(), currentWeapon) plyrGunObject = CREATE_FAKE_WEAPON_FOR_PLAYER(currentWeapon) SAFE_RELEASE_OBJECT(plyrGunObject) plyrGunObject = NULL ENDIF ENDIF IF IS_PED_USING_ACTION_MODE(PLAYER_PED_ID()) SET_PED_USING_ACTION_MODE(PLAYER_PED_ID(), FALSE) ENDIF SET_PED_CAN_SWITCH_WEAPON(PLAYER_PED_ID(), TRUE) // SPECIAL_ABILITY_UNLOCK(GET_PLAYER_PED_MODEL(CHAR_TREVOR)) Restore_Game_State_Snapshot_Weapons(g_startSnapshot) IF (NOT bPlayerDead) RESTORE_PLAYER_PED_WEAPONS(PLAYER_PED_ID()) ENDIF IF (rampageInfo.bPassed = TRUE) REPEAT COUNT_OF(rampageInfo.plyrWeapon) i IF (rampageInfo.plyrWeapon[i] <> WEAPONTYPE_INVALID) AND (rampageInfo.plyrWeapon[i] <> WEAPONTYPE_UNARMED) GIVE_WEAPON_TO_PED(PLAYER_PED_ID(), rampageInfo.plyrWeapon[i], GET_WEAPON_CLIP_SIZE(rampageInfo.plyrWeapon[i]) * 3, TRUE, TRUE) ENDIF ENDREPEAT ENDIF SET_CURRENT_PED_WEAPON( PLAYER_PED_ID(), WEAPONTYPE_UNARMED, TRUE ) SET_PLAYER_HEALTH_RECHARGE_MULTIPLIER(PLAYER_ID(), 1.0) SET_ALL_SHOPS_TEMPORARILY_UNAVAILABLE(FALSE) SET_PLAYER_WEAPON_DAMAGE_MODIFIER(PLAYER_ID(), 1.0) SET_PLAYER_WEAPON_DEFENSE_MODIFIER(PLAYER_ID(), 1.0) // unload scaleform IF (sFormRampage <> NULL) CALL_SCALEFORM_MOVIE_METHOD(sFormRampage, "RESET_MOVIE") // DRAW_SCALEFORM_MOVIE(sFormRampage, 0.5, 0.5, 1.0, 1.0, 255, 255, 255, 0) SET_SCALEFORM_MOVIE_AS_NO_LONGER_NEEDED(sFormRampage) sFormRampage = NULL ENDIF // unload scaleform IF (sFormRampageStats <> NULL) SET_SCALEFORM_MOVIE_AS_NO_LONGER_NEEDED(sFormRampageStats) sFormRampageStats = NULL ENDIF // unload scaleform IF (sFormRampagePassMsg <> NULL) CALL_SCALEFORM_MOVIE_METHOD(sFormRampagePassMsg, "RESET_MOVIE") SET_SCALEFORM_MOVIE_AS_NO_LONGER_NEEDED(sFormRampagePassMsg) sFormRampagePassMsg = NULL ENDIF //UNLOAD_LEADIN_ANIMDICT(rampageLeadIn) //cleanup entities CLEANUP_RAMPAGE_CAR_ARRAY(rampageCar) FLEE_RAMPAGE_PED_ARRAY(rampagePed) CLEANUP_RAMPAGE_TANK(rampageTank) CLEANUP_COVER_CARS() CLEANUP_EXPLOSIVE_PROPS() // restore sceanrios UNBLOCK_SCENARIOS_AND_AMBIENT(worldScenarioBlockID) IF (scenarioBlockID <> NULL) REMOVE_SCENARIO_BLOCKING_AREA(scenarioBlockID) ENDIF RESET_SCENARIO_GROUPS_ENABLED() // restore ambient stuff REMOVE_RELATIONSHIP_GROUP(activeGroup) REMOVE_RELATIONSHIP_GROUP(activePassiveGroup) CLEAR_ALL_PICKUP_REWARD_TYPE_SUPPRESSION() SET_WANTED_LEVEL_MULTIPLIER(1.0) SET_DISPATCH_COPS_FOR_PLAYER(GET_PLAYER_INDEX(), TRUE) CLEAR_ADDITIONAL_TEXT(MISSION_TEXT_SLOT, TRUE) ENABLE_AMBIENT_PEDS_AND_VEHICLES() ENABLE_ALL_DISPATCH_SERVICES(TRUE) DISABLE_CELLPHONE(FALSE) SET_PLAYER_CAN_BE_HASSLED_BY_GANGS(PLAYER_ID(), TRUE) // handle passing completion percentage IF (rampageInfo.bPassed) SWITCH (rampageInfo.blipNameEnum) // Rednecks CASE STATIC_BLIP_MINIGAME_RAMPAGE1 Random_Character_Passed(CP_OJ_RAM1) BREAK // Ballers CASE STATIC_BLIP_MINIGAME_RAMPAGE3 Random_Character_Passed(CP_OJ_RAM3) BREAK // Vagos CASE STATIC_BLIP_MINIGAME_RAMPAGE4 Random_Character_Passed(CP_OJ_RAM4) BREAK // Army CASE STATIC_BLIP_MINIGAME_RAMPAGE5 Random_Character_Passed(CP_OJ_RAM5) BREAK // Hipsters CASE STATIC_BLIP_MINIGAME_RAMPAGE2 //IF NOT GET_MISSION_FLOW_FLAG_STATE(FLOWFLAG_ALL_RAMPAGES_UNLOCKED) CPRINTLN(DEBUG_RAMPAGE, "RAMPAGE_CLEANUP() - ALL RAMPAGES CLEAR") SET_MISSION_FLOW_FLAG_STATE(FLOWFLAG_ALL_RAMPAGES_UNLOCKED, TRUE) AWARD_ACHIEVEMENT(ACH18) // Award achievement - Blast from the Past //ENDIF Random_Character_Passed(CP_OJ_RAM2) BREAK DEFAULT SCRIPT_ASSERT("UNDEFINED RAMPAGE - CAN'T REGISTER 100%") BREAK ENDSWITCH IF GET_MISSION_FLOW_FLAG_STATE(FLOWFLAG_ALL_RAMPAGES_UNLOCKED) CPRINTLN(DEBUG_RAMPAGE, "RAMPAGE_CLEANUP() - ALL RAMPAGES UNLOCKED, REACTIVATING WORLD BRAIN") AWARD_ACHIEVEMENT(ACH18) // Award achievement - Blast from the Past REACTIVATE_NAMED_WORLD_BRAINS_WAITING_TILL_OUT_OF_RANGE("launcher_rampage") ENDIF ENDIF IF (Random_Character_Cleanup_If_Triggered()) #IF IS_DEBUG_BUILD CPRINTLN(DEBUG_RAMPAGE, "Random Character Script was triggered so additional cleanup required") #ENDIF ENDIF // Clean up entities and release models g_bIsOnRampage = FALSE g_bCheckSolidGoldBabyAchievement = TRUE RC_CleanupSceneEntities(rampageScriptArgs, FALSE, FALSE) RELEASE_RAMPAGE_INFO() BAWSAQ_INCREMENT_MODIFIER(BSMF_SM_RAMCOM ) //#1514495 stockmarket TERMINATE_THIS_THREAD() ENDPROC //---------------------- // CUTSCENE FUNCTIONS //---------------------- /// PURPOSE: /// Tells us the name of the intro cutscene /// We need this just in case people try to use the z menu in a replay PROC GET_NAME_OF_RAMPAGE_INTRO_CUTSCENE() SWITCH (rampageInfo.blipNameEnum) CASE STATIC_BLIP_MINIGAME_RAMPAGE1 rampageScriptArgs.sIntroCutscene = "TRVRAM_1" BREAK CASE STATIC_BLIP_MINIGAME_RAMPAGE2 rampageScriptArgs.sIntroCutscene = "TRVRAM_2_CONCAT" BREAK CASE STATIC_BLIP_MINIGAME_RAMPAGE3 rampageScriptArgs.sIntroCutscene = "TRVRAM_3" BREAK CASE STATIC_BLIP_MINIGAME_RAMPAGE4 rampageScriptArgs.sIntroCutscene = "TRVRAM_4" BREAK CASE STATIC_BLIP_MINIGAME_RAMPAGE5 rampageScriptArgs.sIntroCutscene = "TRVRAM_5_CON" BREAK DEFAULT SCRIPT_ASSERT("Rampage does not have an intial cutscene") BREAK ENDSWITCH ENDPROC /// PURPOSE: /// Registers entities we got from the script args with the mocaps PROC REGISTER_INTRO_CUTSCENE_ENTITIES() MODEL_NAMES weaponModel IF IS_ENTITY_ALIVE(PLAYER_PED_ID()) sPlayerSceneHandle = "Trevor" CPRINTLN(DEBUG_RAMPAGE, "REGISTER_INTRO_CUTSCENE_ENTITIES - PLAYER REGISTERED") REGISTER_ENTITY_FOR_CUTSCENE(PLAYER_PED_ID(), sPlayerSceneHandle, CU_ANIMATE_EXISTING_SCRIPT_ENTITY, GET_ENTITY_MODEL(PLAYER_PED_ID()),CEO_PRESERVE_FACE_BLOOD_DAMAGE|CEO_PRESERVE_BODY_BLOOD_DAMAGE) ENDIF SWITCH (rampageInfo.blipNameEnum) CASE STATIC_BLIP_MINIGAME_RAMPAGE1 IF IS_ENTITY_ALIVE(rampageScriptArgs.pedID[0]) sSceneHandles[0] = "TriggerHappy_WhiteTrash" CPRINTLN(DEBUG_RAMPAGE, "REGISTER ", sSceneHandles[0], " - PED: 0") REGISTER_ENTITY_FOR_CUTSCENE(rampageScriptArgs.pedID[0], sSceneHandles[0], CU_ANIMATE_EXISTING_SCRIPT_ENTITY)//, GET_ENTITY_MODEL(rampageScriptArgs.pedID[0])) ENDIF IF IS_ENTITY_ALIVE(rampageScriptArgs.pedID[1]) sSceneHandles[1] = "Nervous_WhiteTrash" CPRINTLN(DEBUG_RAMPAGE, "REGISTER ", sSceneHandles[1], " - PED: 1") REGISTER_ENTITY_FOR_CUTSCENE(rampageScriptArgs.pedID[1], sSceneHandles[1], CU_ANIMATE_EXISTING_SCRIPT_ENTITY) //, GET_ENTITY_MODEL(rampageScriptArgs.pedID[1])) ENDIF sWeaponSceneHandle = "Trevors_weapon" weaponModel = GET_WEAPONTYPE_MODEL(WEAPONTYPE_ASSAULTRIFLE) IF IS_ENTITY_ALIVE(rampageScriptArgs.objID[3]) FREEZE_ENTITY_POSITION( rampageScriptArgs.objID[3], FALSE ) ENDIF IF IS_ENTITY_ALIVE(rampageScriptArgs.objID[4]) FREEZE_ENTITY_POSITION( rampageScriptArgs.objID[4], FALSE ) ENDIF BREAK CASE STATIC_BLIP_MINIGAME_RAMPAGE2 IF IS_ENTITY_ALIVE(rampageScriptArgs.pedID[0]) sSceneHandles[0] = "Rampage_Hipster" CPRINTLN(DEBUG_RAMPAGE, "REGISTER ", sSceneHandles[0], " - PED: 0") REGISTER_ENTITY_FOR_CUTSCENE(rampageScriptArgs.pedID[0], sSceneHandles[0], CU_ANIMATE_EXISTING_SCRIPT_ENTITY, GET_ENTITY_MODEL(rampageScriptArgs.pedID[0])) ENDIF IF IS_ENTITY_ALIVE(rampageScriptArgs.objID[1]) SAFE_DELETE_OBJECT(rampageScriptArgs.objID[1]) ENDIF IF IS_ENTITY_ALIVE(rampageScriptArgs.objID[2]) FREEZE_ENTITY_POSITION( rampageScriptArgs.objID[2], FALSE ) ENDIF IF IS_ENTITY_ALIVE(rampageScriptArgs.objID[3]) FREEZE_ENTITY_POSITION( rampageScriptArgs.objID[3], FALSE ) ENDIF sWeaponSceneHandle = "Trevors_weapon" weaponModel = GET_WEAPONTYPE_MODEL(WEAPONTYPE_SAWNOFFSHOTGUN) BREAK CASE STATIC_BLIP_MINIGAME_RAMPAGE3 IF IS_ENTITY_ALIVE(rampageScriptArgs.pedID[0]) sSceneHandles[0] = "Armed_Mexican_Goon" CPRINTLN(DEBUG_RAMPAGE, "REGISTER ", sSceneHandles[0], " - PED: 0") SET_PED_COMPONENT_VARIATION(rampageScriptArgs.pedID[0], PED_COMP_SPECIAL2, 0, 0) //To fix dupe gun from B*2015853 - remove gun before registering for the cutsene REGISTER_ENTITY_FOR_CUTSCENE(rampageScriptArgs.pedID[0], sSceneHandles[0], CU_ANIMATE_EXISTING_SCRIPT_ENTITY, GET_ENTITY_MODEL(rampageScriptArgs.pedID[0])) ENDIF IF IS_ENTITY_ALIVE(rampageScriptArgs.pedID[1]) sSceneHandles[1] = "Mexican_Goon" CPRINTLN(DEBUG_RAMPAGE, "REGISTER ", sSceneHandles[1], " - PED: 1") REGISTER_ENTITY_FOR_CUTSCENE(rampageScriptArgs.pedID[1], sSceneHandles[1], CU_ANIMATE_EXISTING_SCRIPT_ENTITY, GET_ENTITY_MODEL(rampageScriptArgs.pedID[1])) ENDIF sWeaponSceneHandle = "Trevors_weapon" weaponModel = GET_WEAPONTYPE_MODEL(WEAPONTYPE_MICROSMG) BREAK CASE STATIC_BLIP_MINIGAME_RAMPAGE4 IF IS_ENTITY_ALIVE(rampageScriptArgs.pedID[0]) sSceneHandles[0] = "Thug" CPRINTLN(DEBUG_RAMPAGE, "REGISTER ", sSceneHandles[0], " - PED: 0") REGISTER_ENTITY_FOR_CUTSCENE(rampageScriptArgs.pedID[0], sSceneHandles[0], CU_ANIMATE_EXISTING_SCRIPT_ENTITY, GET_ENTITY_MODEL(rampageScriptArgs.pedID[0])) ENDIF IF IS_ENTITY_ALIVE(rampageScriptArgs.pedID[1]) sSceneHandles[1] = "Armed_Thug" CPRINTLN(DEBUG_RAMPAGE, "REGISTER ", sSceneHandles[1], " - PED: 1") REGISTER_ENTITY_FOR_CUTSCENE(rampageScriptArgs.pedID[1], sSceneHandles[1], CU_ANIMATE_EXISTING_SCRIPT_ENTITY, GET_ENTITY_MODEL(rampageScriptArgs.pedID[1]), CEO_PRESERVE_FACE_BLOOD_DAMAGE|CEO_PRESERVE_BODY_BLOOD_DAMAGE|CEO_CLONE_DAMAGE_TO_CS_MODEL) ENDIF sWeaponSceneHandle = "Trevors_weapon" weaponModel = GET_WEAPONTYPE_MODEL(WEAPONTYPE_ASSAULTRIFLE) // we're now creating a weapon in the lead-in // was cleaner to just delete it and recreate here // @bsw 13/7/2013 IF IS_ENTITY_ALIVE(rampageScriptArgs.objID[0]) DELETE_OBJECT(rampageScriptArgs.objID[0]) ENDIF IF NOT IS_ENTITY_ALIVE(rampageScriptArgs.objID[0]) CPRINTLN(DEBUG_RAMPAGE, "REGISTER_INTRO_CUTSCENE_ENTITIES - PLAYER WEAPON REGISTERED - RAMPAGE 4 - CREATING NEW WEAPON") rampageScriptArgs.objID[0] = CREATE_WEAPON_OBJECT(WEAPONTYPE_ASSAULTRIFLE, 100, GET_ENTITY_COORDS(rampageScriptArgs.pedID[0]), TRUE) IF IS_ENTITY_ALIVE(rampageScriptArgs.objID[0]) CPRINTLN(DEBUG_RAMPAGE, "REGISTER_INTRO_CUTSCENE_ENTITIES - PLAYER WEAPON CREATED - RAMPAGE 4 - CREATING NEW WEAPON") ENDIF ENDIF BREAK CASE STATIC_BLIP_MINIGAME_RAMPAGE5 IF IS_ENTITY_ALIVE(rampageScriptArgs.pedID[0]) sSceneHandles[0] = "Army_Guy_Right" CPRINTLN(DEBUG_RAMPAGE, "REGISTER ", sSceneHandles[0], " - PED: 0") REGISTER_ENTITY_FOR_CUTSCENE(rampageScriptArgs.pedID[0], sSceneHandles[0], CU_ANIMATE_EXISTING_SCRIPT_ENTITY)//, GET_ENTITY_MODEL(rampageScriptArgs.pedID[0])) ENDIF IF IS_ENTITY_ALIVE(rampageScriptArgs.pedID[1]) sSceneHandles[1] = "Army_Guy_Left" CPRINTLN(DEBUG_RAMPAGE, "REGISTER ", sSceneHandles[1], " - PED: 1") REGISTER_ENTITY_FOR_CUTSCENE(rampageScriptArgs.pedID[1], sSceneHandles[1], CU_ANIMATE_EXISTING_SCRIPT_ENTITY)//, GET_ENTITY_MODEL(rampageScriptArgs.pedID[1])) ENDIF IF IS_ENTITY_ALIVE(rampageScriptArgs.vehID[0]) sSceneHandles[2] = "Army_Truck" CPRINTLN(DEBUG_RAMPAGE, "REGISTER ", sSceneHandles[2], " - VEHICLE") SET_VEHICLE_EXTRA(rampageScriptArgs.vehID[0], 1, TRUE) REGISTER_ENTITY_FOR_CUTSCENE(rampageScriptArgs.vehID[0], sSceneHandles[2], CU_ANIMATE_EXISTING_SCRIPT_ENTITY)//, GET_ENTITY_MODEL(rampageScriptArgs.vehID[0])) ENDIF sWeaponSceneHandle = "Trevors_weapon" weaponModel = GET_WEAPONTYPE_MODEL(WEAPONTYPE_GRENADELAUNCHER) BREAK ENDSWITCH IF NOT IS_STRING_NULL_OR_EMPTY(sWeaponSceneHandle) IF IS_ENTITY_ALIVE(rampageScriptArgs.objID[0]) CPRINTLN(DEBUG_RAMPAGE, "REGISTER_INTRO_CUTSCENE_ENTITIES - PLAYER WEAPON REGISTERED - USING EXISTING OBJECT") REGISTER_ENTITY_FOR_CUTSCENE(rampageScriptArgs.objID[0], sWeaponSceneHandle, CU_ANIMATE_EXISTING_SCRIPT_ENTITY) ELSE CPRINTLN(DEBUG_RAMPAGE, "REGISTER_INTRO_CUTSCENE_ENTITIES - PLAYER WEAPON REGISTERED - USING NEW OBJECT") REGISTER_ENTITY_FOR_CUTSCENE(NULL, sWeaponSceneHandle, CU_CREATE_AND_ANIMATE_NEW_SCRIPT_ENTITY, weaponModel) ENDIF ENDIF ENDPROC /// PURPOSE: /// Updates registered entities we got from the script args with the mocaps PROC UPDATE_REGISTERED_INTRO_CUTSCENE_EXIT_STATE() IF IS_ENTITY_ALIVE(PLAYER_PED_ID()) IF CAN_SET_EXIT_STATE_FOR_REGISTERED_ENTITY(sPlayerSceneHandle) CPRINTLN(DEBUG_RAMPAGE, "PLAYER EXIT STATE SET") set_ped_using_action_mode(PLAYER_PED_ID(),true,-1,"TREVOR_ACTION") FORCE_PED_MOTION_STATE(PLAYER_PED_ID(),MS_ACTIONMODE_IDLE,FALSE,FAUS_CUTSCENE_EXIT) SET_PLAYER_CONTROL(PLAYER_ID(), FALSE, SPC_LEAVE_CAMERA_CONTROL_ON) TASK_PLAY_ANIM( PLAYER_PED_ID(), "missrampageintrooutro", rampageInfo.sIntroAnim, SLOW_BLEND_IN, SLOW_BLEND_OUT ) TRIGGER_RAMPAGE_FX() bPlayerExitStateSet = TRUE ENDIF ENDIF SWITCH (rampageInfo.blipNameEnum) CASE STATIC_BLIP_MINIGAME_RAMPAGE1 IF IS_ENTITY_ALIVE(rampageScriptArgs.pedID[0]) sSceneHandles[0] = "TriggerHappy_WhiteTrash" IF CAN_SET_EXIT_STATE_FOR_REGISTERED_ENTITY(sSceneHandles[0]) //, GET_ENTITY_MODEL(rampageScriptArgs.pedID[0])) RAMPAGE_SMART_FLEE_HACKERY(rampageScriptArgs.pedID[0], <<930.2522, 3681.3391, 30.6506>>) // GET_OFFSET_FROM_ENTITY_IN_WORLD_COORDS(rampagePed[ind].pedID, <<0.0, 100.0, 0.0>>)) FORCE_PED_MOTION_STATE(rampageScriptArgs.pedID[0], MS_ON_FOOT_RUN, FALSE, FAUS_CUTSCENE_EXIT) SET_PED_MIN_MOVE_BLEND_RATIO(rampageScriptArgs.pedID[0], PEDMOVE_SPRINT) ENDIF ENDIF IF IS_ENTITY_ALIVE(rampageScriptArgs.pedID[1]) sSceneHandles[1] = "Nervous_WhiteTrash" IF CAN_SET_EXIT_STATE_FOR_REGISTERED_ENTITY(sSceneHandles[1]) //, GET_ENTITY_MODEL(rampageScriptArgs.pedID[1])) RAMPAGE_SMART_FLEE_HACKERY(rampageScriptArgs.pedID[1],<<920.2722, 3546.1018, 32.9231>>)// <<1049.8945, 3575.0146, 32.9901>>) FORCE_PED_MOTION_STATE(rampageScriptArgs.pedID[1], MS_ON_FOOT_RUN, FALSE, FAUS_CUTSCENE_EXIT) SET_PED_MIN_MOVE_BLEND_RATIO(rampageScriptArgs.pedID[1], PEDMOVE_RUN) ENDIF ENDIF BREAK CASE STATIC_BLIP_MINIGAME_RAMPAGE2 IF IS_ENTITY_ALIVE(rampageScriptArgs.pedID[0]) sSceneHandles[0] = "Rampage_Hipster" IF CAN_SET_EXIT_STATE_FOR_REGISTERED_ENTITY(sSceneHandles[0]) //, GET_ENTITY_MODEL(rampageScriptArgs.pedID[0])) RAMPAGE_SMART_FLEE_HACKERY(rampageScriptArgs.pedID[0], <<1212.5776, -421.3977, 66.5951>>, TRUE) FORCE_PED_MOTION_STATE(rampageScriptArgs.pedID[0], MS_ON_FOOT_SPRINT, FALSE, FAUS_CUTSCENE_EXIT) SET_PED_MIN_MOVE_BLEND_RATIO(rampageScriptArgs.pedID[0], PEDMOVE_SPRINT) ENDIF ENDIF BREAK CASE STATIC_BLIP_MINIGAME_RAMPAGE3 IF IS_ENTITY_ALIVE(rampageScriptArgs.pedID[0]) sSceneHandles[0] = "Armed_Mexican_Goon" IF CAN_SET_EXIT_STATE_FOR_REGISTERED_ENTITY(sSceneHandles[0])//, GET_ENTITY_MODEL(rampageScriptArgs.pedID[0])) SET_PED_COMPONENT_VARIATION(rampageScriptArgs.pedID[0], PED_COMP_SPECIAL, 0, 0) RAMPAGE_SMART_FLEE_HACKERY(rampageScriptArgs.pedID[0], <<335.7316, -1887.2788, 24.8253>>) FORCE_PED_MOTION_STATE(rampageScriptArgs.pedID[0], MS_ON_FOOT_SPRINT, FALSE, FAUS_CUTSCENE_EXIT) SET_PED_MIN_MOVE_BLEND_RATIO(rampageScriptArgs.pedID[0], PEDMOVE_SPRINT) ENDIF ENDIF IF IS_ENTITY_ALIVE(rampageScriptArgs.pedID[1]) sSceneHandles[1] = "Mexican_Goon" IF CAN_SET_EXIT_STATE_FOR_REGISTERED_ENTITY(sSceneHandles[1]) //, GET_ENTITY_MODEL(rampageScriptArgs.pedID[1])) RAMPAGE_SMART_FLEE_HACKERY(rampageScriptArgs.pedID[1], <<408.9685, -1923.8516, 24.0339>>) FORCE_PED_MOTION_STATE(rampageScriptArgs.pedID[1], MS_ON_FOOT_SPRINT, FALSE, FAUS_CUTSCENE_EXIT) SET_PED_MIN_MOVE_BLEND_RATIO(rampageScriptArgs.pedID[1], PEDMOVE_SPRINT) ENDIF ENDIF BREAK CASE STATIC_BLIP_MINIGAME_RAMPAGE4 IF IS_ENTITY_ALIVE(rampageScriptArgs.pedID[0]) sSceneHandles[0] = "Thug" IF CAN_SET_EXIT_STATE_FOR_REGISTERED_ENTITY(sSceneHandles[0]) //, GET_ENTITY_MODEL(rampageScriptArgs.pedID[0])) RAMPAGE_SMART_FLEE_HACKERY(rampageScriptArgs.pedID[0], <<-110.74, -1601.2, 31.7>>, FALSE) FORCE_PED_MOTION_STATE(rampageScriptArgs.pedID[0], MS_ON_FOOT_RUN, FALSE, FAUS_CUTSCENE_EXIT) SET_PED_MIN_MOVE_BLEND_RATIO(rampageScriptArgs.pedID[0], PEDMOVE_SPRINT) ENDIF ENDIF IF IS_ENTITY_ALIVE(rampageScriptArgs.pedID[1]) sSceneHandles[1] = "Armed_Thug" IF CAN_SET_EXIT_STATE_FOR_REGISTERED_ENTITY(sSceneHandles[1]) //, GET_ENTITY_MODEL(rampageScriptArgs.pedID[1])) RAMPAGE_SMART_FLEE_HACKERY(rampageScriptArgs.pedID[1], <<-142.6, -1713.4, 30.1>>, TRUE)//, TRUE) // FORCE_PED_MOTION_STATE(rampageScriptArgs.pedID[1], MS_ON_FOOT_RUN, FALSE, FAUS_CUTSCENE_EXIT) // SET_PED_MIN_MOVE_BLEND_RATIO(rampageScriptArgs.pedID[1], PEDMOVE_SPRINT) ENDIF ENDIF BREAK CASE STATIC_BLIP_MINIGAME_RAMPAGE5 IF IS_ENTITY_ALIVE(rampageScriptArgs.pedID[0]) sSceneHandles[0] = "Army_Guy_Left" IF CAN_SET_EXIT_STATE_FOR_REGISTERED_ENTITY(sSceneHandles[0]) //, GET_ENTITY_MODEL(rampageScriptArgs.pedID[0])) RAMPAGE_SMART_FLEE_HACKERY(rampageScriptArgs.pedID[0], <<-1209.9448, 2598.6895, 14.3906>>) FORCE_PED_MOTION_STATE(rampageScriptArgs.pedID[0], MS_ON_FOOT_RUN, FALSE, FAUS_CUTSCENE_EXIT) SET_PED_MIN_MOVE_BLEND_RATIO(rampageScriptArgs.pedID[0], PEDMOVE_RUN) ENDIF ENDIF IF IS_ENTITY_ALIVE(rampageScriptArgs.pedID[1]) sSceneHandles[1] = "Army_Guy_Right" IF CAN_SET_EXIT_STATE_FOR_REGISTERED_ENTITY(sSceneHandles[1]) //, GET_ENTITY_MODEL(rampageScriptArgs.pedID[1])) RAMPAGE_SMART_FLEE_HACKERY(rampageScriptArgs.pedID[1], <<-1222.5686, 2587.6506, 15.1474>>) FORCE_PED_MOTION_STATE(rampageScriptArgs.pedID[1], MS_ON_FOOT_SPRINT, FALSE, FAUS_CUTSCENE_EXIT) SET_PED_MIN_MOVE_BLEND_RATIO(rampageScriptArgs.pedID[1], PEDMOVE_SPRINT) ENDIF ENDIF IF IS_ENTITY_ALIVE(rampageScriptArgs.vehID[0]) IF CAN_SET_ENTER_STATE_FOR_REGISTERED_ENTITY(sSceneHandles[2]) SET_VEHICLE_EXTRA(rampageScriptArgs.vehID[0], 1, FALSE) CPRINTLN(DEBUG_RAMPAGE, "VEHICLE ENTER STATE SET") ENDIF ENDIF BREAK ENDSWITCH IF NOT IS_ENTITY_ALIVE(rampageScriptArgs.objID[0]) IF DOES_ENTITY_EXIST(GET_ENTITY_INDEX_OF_REGISTERED_ENTITY(sWeaponSceneHandle)) rampageScriptArgs.objID[0] = GET_OBJECT_INDEX_FROM_ENTITY_INDEX(GET_ENTITY_INDEX_OF_REGISTERED_ENTITY(sWeaponSceneHandle)) IF IS_ENTITY_ALIVE(rampageScriptArgs.objID[0]) CPRINTLN(DEBUG_RAMPAGE, "PLAYER WEAPON CREATED") ENDIF ENDIF ELIF CAN_SET_EXIT_STATE_FOR_REGISTERED_ENTITY(sWeaponSceneHandle) //, GET_ENTITY_MODEL(rampageScriptArgs.objID[0])) // @SBA - fix an issue with rampageScriptArgs.objID[0] not working when the corresponding // player weapon had no ammo (rampage 4 only) IF rampageScriptArgs.eMissionID = RC_RAMPAGE_4 CPRINTLN(DEBUG_RAMPAGE, "PLAYER WEAPON EXIT STATE SET: Rampage 4") SAFE_DELETE_OBJECT(rampageScriptArgs.objID[0]) GIVE_PLAYER_RAMPAGE_WEAPONS() ELSE CPRINTLN(DEBUG_RAMPAGE, "PLAYER WEAPON EXIT STATE SET") GIVE_WEAPON_OBJECT_TO_PED(rampageScriptArgs.objID[0], PLAYER_PED_ID()) ENDIF ENDIF // To fix B*2015853, yeah it's a bit of a bodge. IF rampageScriptArgs.eMissionID = RC_RAMPAGE_3 IF GET_CUTSCENE_TIME() >= 23000 IF NOT bRampage3WeaponBodge GIVE_WEAPON_TO_PED(PLAYER_PED_ID(), rampageInfo.plyrWeapon[0], INFINITE_AMMO , TRUE, TRUE) INT i = 0 REPEAT COUNT_OF(rampageInfo.plyrWeaponComp) i IF (rampageInfo.plyrWeaponComp[i] <> WEAPONCOMPONENT_INVALID) GIVE_WEAPON_COMPONENT_TO_PED(PLAYER_PED_ID(), rampageInfo.plyrWeapon[0], rampageInfo.plyrWeaponComp[i]) ENDIF ENDREPEAT bRampage3WeaponBodge = TRUE ENDIF SET_PED_CURRENT_WEAPON_VISIBLE(PLAYER_PED_ID(), TRUE) ENDIF ENDIF ENDPROC /// PURPOSE: /// This places the player and any cars or peds we want there immediately after the mocap PROC SETUP_INITIAL_PEDS() INT ind SWITCH (rampageInfo.blipNameEnum) CASE STATIC_BLIP_MINIGAME_RAMPAGE1 //@RJP set up cars to move in to attack player IF GET_FREE_RAMPAGE_CAR_INDEX( ind ) IF CREATE_RAMPAGE_CAR( rampageCar[ind], rampageInfo.carModels[0], <<930.9605, 3555.5437, 32.9354>>, 354.1474, TRUE, 1) SET_RAMPAGE_CAR_DEPLOY_TO_COORDINATES( rampageCar[ind], <<911.7063, 3625.5491, 31.3674>>, 40 ) // SET_RAMPAGE_CAR_DEPLOY(rampageCar[ind], TRUE, 40) ENDIF ENDIF BREAK CASE STATIC_BLIP_MINIGAME_RAMPAGE2 /* setup some peds in combat positions */ IF GET_FREE_RAMPAGE_PED_INDEX(rampagePed, ind) CREATE_RAMPAGER_PED_AT_POSITION(rampagePed[ind], <<1175.0933, -417.2925, 66.3285>>, 265.3943) ENDIF IF GET_FREE_RAMPAGE_PED_INDEX(rampagePed, ind) CREATE_RAMPAGER_PED_AT_POSITION(rampagePed[ind], <<1170.4524, -425.4240, 66.0957>>, 300.0205) ENDIF IF GET_FREE_RAMPAGE_PED_INDEX(rampagePed, ind) CREATE_RAMPAGER_PED_AT_POSITION(rampagePed[ind], <<1171.6316, -423.4090, 66.0957>>, 300.2360) ENDIF IF GET_FREE_RAMPAGE_CAR_INDEX( ind ) IF CREATE_RAMPAGE_CAR( rampageCar[ind], rampageInfo.carModels[2], <<1169.7002, -366.0976, 66.9855>>, 256.6603, TRUE, 1) SET_RAMPAGE_CAR_DEPLOY_TO_COORDINATES( rampageCar[ind], <<1188.0450, -407.0416, 66.8409>>, 30 ) // SET_RAMPAGE_CAR_DEPLOY(rampageCar[ind], TRUE, 30) ENDIF ENDIF IF GET_FREE_RAMPAGE_CAR_INDEX( ind ) IF CREATE_RAMPAGE_CAR( rampageCar[ind], rampageInfo.carModels[2], <<1154.9923, -474.4909, 65.5083>>, 245.5358, TRUE, 1) SET_RAMPAGE_CAR_DEPLOY_TO_COORDINATES( rampageCar[ind], <<1192.1339, -400.4286, 66.8566>>, 30 ) // SET_RAMPAGE_CAR_DEPLOY(rampageCar[ind], TRUE, 30) ENDIF ENDIF BREAK CASE STATIC_BLIP_MINIGAME_RAMPAGE3 //@RJP set up cars to move in to attack player IF GET_FREE_RAMPAGE_CAR_INDEX( ind ) IF CREATE_RAMPAGE_CAR( rampageCar[ind], rampageInfo.carModels[0], <<405.9012, -1916.1853, 24.1725>>, 48.5025, TRUE, 1) SET_RAMPAGE_CAR_DEPLOY(rampageCar[ind], TRUE, 40) SET_RAMPAGE_CAR_RAISED_COLLISION(rampageCar[ind]) ENDIF ENDIF IF GET_FREE_RAMPAGE_CAR_INDEX( ind ) IF CREATE_RAMPAGE_CAR( rampageCar[ind], rampageInfo.carModels[1], <<351.6271, -1906.6952, 23.7255>>, 221.0698, TRUE, 1) SET_RAMPAGE_CAR_DEPLOY(rampageCar[ind], TRUE, 40) SET_RAMPAGE_CAR_RAISED_COLLISION(rampageCar[ind]) ENDIF ENDIF BREAK CASE STATIC_BLIP_MINIGAME_RAMPAGE4 // setup some peds in combat positions IF GET_FREE_RAMPAGE_PED_INDEX(rampagePed, ind) IF CREATE_RAMPAGER_PED_AT_POSITION(rampagePed[ind], <<-148.0109, -1632.1240, 32.0708>>, 230.0827) SET_PED_DEFENSIVE_SPHERE_ATTACHED_TO_PED(rampagePed[ind].pedID, PLAYER_PED_ID(), <<0, 0, 0>>, 30.0) ENDIF ENDIF IF GET_FREE_RAMPAGE_PED_INDEX(rampagePed, ind) IF CREATE_RAMPAGER_PED_AT_POSITION(rampagePed[ind], <<-122.8691, -1634.9785, 31.1487>>, 42.2112) SET_PED_DEFENSIVE_SPHERE_ATTACHED_TO_PED(rampagePed[ind].pedID, PLAYER_PED_ID(), <<0, 0, 0>>, 30.0) ENDIF ENDIF IF GET_FREE_RAMPAGE_PED_INDEX(rampagePed, ind) IF CREATE_RAMPAGER_PED_AT_POSITION(rampagePed[ind], <<-134.9283, -1614.3149, 31.6326>>, 243.3803) SET_PED_DEFENSIVE_SPHERE_ATTACHED_TO_PED(rampagePed[ind].pedID, PLAYER_PED_ID(), <<0, 0, 0>>, 30.0) TASK_SEEK_COVER_FROM_PED(rampagePed[ind].pedID, PLAYER_PED_ID(), -1, TRUE) ENDIF ENDIF BREAK DEFAULT BREAK ENDSWITCH ENDPROC PROC REPLAY_PLAYER_POSITION() SWITCH (rampageInfo.blipNameEnum) CASE STATIC_BLIP_MINIGAME_RAMPAGE1 SET_ENTITY_COORDS_GROUNDED(PLAYER_PED_ID(), <<908.7723, 3641.4531, 31.4889>>) SET_ENTITY_HEADING(PLAYER_PED_ID(), 270.3831) BREAK CASE STATIC_BLIP_MINIGAME_RAMPAGE2 SET_ENTITY_COORDS_GROUNDED(PLAYER_PED_ID(), <<1185.7426, -400.5164, 66.9606>>) SET_ENTITY_HEADING(PLAYER_PED_ID(), 159.1354) BREAK CASE STATIC_BLIP_MINIGAME_RAMPAGE3 SET_ENTITY_COORDS_GROUNDED(PLAYER_PED_ID(), <<463.9719, -1848.9276, 26.8640>>) SET_ENTITY_HEADING(PLAYER_PED_ID(), 135.7623) BREAK CASE STATIC_BLIP_MINIGAME_RAMPAGE4 SET_ENTITY_COORDS_GROUNDED(PLAYER_PED_ID(), <<-162.40, -1668.70, 33.14>>) SET_ENTITY_HEADING(PLAYER_PED_ID(), -45.22) BREAK CASE STATIC_BLIP_MINIGAME_RAMPAGE5 SET_ENTITY_COORDS_GROUNDED(PLAYER_PED_ID(), <<-1295.7534, 2507.1167, 20.2824>>) SET_ENTITY_HEADING(PLAYER_PED_ID(), 336.2132) BREAK ENDSWITCH ENDPROC /// PURPOSE: /// This places the player and any cars or peds we want there immediately after the mocap PROC POST_INTRO_CUTSCENE_SETUP(BOOL bSkipped = FALSE) INT n PED_INDEX ped INT ind0, ind1, ind BOOL bCreateInSwitch = FALSE ENABLE_AMBIENT_PEDS_AND_VEHICLES(FALSE, FALSE, TRUE, TRUE) SET_VEHICLE_DENSITY_MULTIPLIER_THIS_FRAME(rampageInfo.fAmbientCarDensity) SET_PED_DENSITY_MULTIPLIER_THIS_FRAME(rampageInfo.fAmbientPedDensity) CPRINTLN(DEBUG_RAMPAGE, "POST_INTRO_CUTSCENE_SETUP - SKIPPED:", bSkipped) SWITCH (rampageInfo.blipNameEnum) CASE STATIC_BLIP_MINIGAME_RAMPAGE1 // setup fleeing peds if they haven't been setup IF GET_FREE_RAMPAGE_PED_INDEX(rampagePed, ind0) IF IS_ENTITY_ALIVE(rampageScriptArgs.pedID[0]) CREATE_RAMPAGER_PED_FROM_PED_INDEX(rampagePed[ind0], rampageScriptArgs.pedID[0], TRUE, FALSE, FALSE) //SET_ENTITY_HEADING(rampageScriptArgs.pedID[0], -68.55) CPRINTLN(DEBUG_RAMPAGE, "GRABBED SCRIPT ARGS PED 0 - NEW INDEX:", ind0) ELSE ped = CREATE_PED(PEDTYPE_MISSION, IG_RAMP_HIC, <<914.678894,3638.753174,31.896519>>, -68.557541) SET_PED_COMPONENT_VARIATION(ped, PED_COMP_HEAD, 0, 0) SET_PED_COMPONENT_VARIATION(ped, PED_COMP_BERD, 0, 0) SET_PED_COMPONENT_VARIATION(ped, PED_COMP_HAIR, 0, 0) SET_PED_COMPONENT_VARIATION(ped, PED_COMP_TORSO, 0, 0) SET_PED_COMPONENT_VARIATION(ped, PED_COMP_LEG, 0, 0) SET_PED_COMPONENT_VARIATION(ped, PED_COMP_HAND, 0, 0) SET_PED_COMPONENT_VARIATION(ped, PED_COMP_FEET, 0, 0) SET_PED_COMPONENT_VARIATION(ped, PED_COMP_TEETH, 0, 0) SET_PED_COMPONENT_VARIATION(ped, PED_COMP_SPECIAL, 0, 0) SET_PED_COMPONENT_VARIATION(ped, PED_COMP_SPECIAL2, 0, 0) SET_PED_COMPONENT_VARIATION(ped, PED_COMP_DECL, 0, 0) SET_PED_COMPONENT_VARIATION(ped, PED_COMP_JBIB, 0, 0) SET_ENTITY_COORDS_GROUNDED(ped, <<914.678894,3638.753174,31.896519>>) CREATE_RAMPAGER_PED_FROM_PED_INDEX(rampagePed[ind0], ped, TRUE, FALSE, FALSE) CPRINTLN(DEBUG_RAMPAGE, "CREATED FAKED ARGS PED 0 - NEW INDEX:", ind0) ENDIF ENDIF IF GET_FREE_RAMPAGE_PED_INDEX(rampagePed, ind1) IF IS_ENTITY_ALIVE(rampageScriptArgs.pedID[1]) CREATE_RAMPAGER_PED_FROM_PED_INDEX(rampagePed[ind1], rampageScriptArgs.pedID[1], TRUE, FALSE, FALSE) //SET_ENTITY_HEADING(rampageScriptArgs.pedID[1], -143.115036) CPRINTLN(DEBUG_RAMPAGE, "GRABBED SCRIPT ARGS PED 1 - NEW INDEX:", ind1) ELSE ped = CREATE_PED(PEDTYPE_MISSION, IG_RAMP_HIC, <<915.581360,3637.608154,31.912495>>, -143.115036) SET_PED_COMPONENT_VARIATION(ped, PED_COMP_HEAD, 1, 0) SET_PED_COMPONENT_VARIATION(ped, PED_COMP_BERD, 0, 0) SET_PED_COMPONENT_VARIATION(ped, PED_COMP_HAIR, 1, 0) SET_PED_COMPONENT_VARIATION(ped, PED_COMP_TORSO, 1, 0) SET_PED_COMPONENT_VARIATION(ped, PED_COMP_LEG, 1, 0) SET_PED_COMPONENT_VARIATION(ped, PED_COMP_HAND, 0, 0) SET_PED_COMPONENT_VARIATION(ped, PED_COMP_FEET, 0, 0) SET_PED_COMPONENT_VARIATION(ped, PED_COMP_TEETH, 0, 0) SET_PED_COMPONENT_VARIATION(ped, PED_COMP_SPECIAL, 0, 0) SET_PED_COMPONENT_VARIATION(ped, PED_COMP_SPECIAL2, 0, 0) SET_PED_COMPONENT_VARIATION(ped, PED_COMP_DECL, 0, 0) SET_PED_COMPONENT_VARIATION(ped, PED_COMP_JBIB, 0, 0) SET_ENTITY_COORDS_GROUNDED(ped, <<915.581360,3637.608154,31.912495>>) CREATE_RAMPAGER_PED_FROM_PED_INDEX(rampagePed[ind1], ped, TRUE, FALSE, FALSE) CPRINTLN(DEBUG_RAMPAGE, "CREATED FAKED ARGS PED 1 - NEW INDEX:", ind1) ENDIF ENDIF IF (bSkipped = TRUE) CPRINTLN(DEBUG_RAMPAGE, "CUTSCENE SKIPPED") IF NOT IS_REPLAY_BEING_SET_UP() SET_ENTITY_COORDS_GROUNDED(PLAYER_PED_ID(), rampageInfo.vPlyrStartPos) SET_ENTITY_HEADING(PLAYER_PED_ID(), rampageInfo.fPlyrStartHeading) ENDIF SET_ENTITY_COORDS_GROUNDED(rampagePed[ind0].pedID, <<926.0913, 3639.4471,32.4406>>) SET_ENTITY_HEADING(rampagePed[ind0].pedID, RAD_TO_DEG(-1.38)) SET_ENTITY_COORDS_GROUNDED(rampagePed[ind1].pedID, <<923.4156, 3632.4092,32.4944>>) SET_ENTITY_HEADING(rampagePed[ind1].pedID, -143.115036) RAMPAGE_SMART_FLEE_HACKERY(rampagePed[ind0].pedID, <<1007.1674, 3634.4473, 31.5345>>) RAMPAGE_SMART_FLEE_HACKERY(rampagePed[ind1].pedID, <<1049.8945, 3575.0146, 32.9901>>) ENDIF bCreateInSwitch = TRUE BREAK CASE STATIC_BLIP_MINIGAME_RAMPAGE2 IF GET_FREE_RAMPAGE_PED_INDEX(rampagePed, ind0) IF IS_ENTITY_ALIVE(rampageScriptArgs.pedID[0]) CREATE_RAMPAGER_PED_FROM_PED_INDEX(rampagePed[ind0], rampageScriptArgs.pedID[0], TRUE, FALSE, FALSE) ELSE ped = CREATE_PED(PEDTYPE_MISSION, IG_RAMP_HIPSTER, <<1186.44, -407.79, 67.72>>, RAD_TO_DEG(-2.04)) SET_PED_DEFAULT_COMPONENT_VARIATION(ped) SET_PED_COMPONENT_VARIATION(ped, PED_COMP_HAIR, 0, 0) SET_ENTITY_COORDS_GROUNDED(ped, <<1186.44, -407.79, 67.72>>) CREATE_RAMPAGER_PED_FROM_PED_INDEX(rampagePed[ind0], ped, TRUE, FALSE, FALSE) ENDIF ENDIF IF (bSkipped = TRUE) IF NOT IS_REPLAY_BEING_SET_UP() SET_ENTITY_COORDS_GROUNDED(PLAYER_PED_ID(), rampageInfo.vPlyrStartPos) SET_ENTITY_HEADING(PLAYER_PED_ID(), rampageInfo.fPlyrStartHeading) ENDIF SET_ENTITY_COORDS_GROUNDED(rampagePed[ind0].pedID, <<1186.44, -407.79, 67.72>>) SET_ENTITY_HEADING(rampagePed[ind0].pedID, RAD_TO_DEG(-2.04)) RAMPAGE_SMART_FLEE_HACKERY(rampagePed[ind0].pedID, <<1212.0, -421.3, 67.6>>) ENDIF bCreateInSwitch = TRUE BREAK CASE STATIC_BLIP_MINIGAME_RAMPAGE3 // setup peds if they haven't been setup IF GET_FREE_RAMPAGE_PED_INDEX(rampagePed, ind0) IF IS_ENTITY_ALIVE(rampageScriptArgs.pedID[0]) CREATE_RAMPAGER_PED_FROM_PED_INDEX(rampagePed[ind0], rampageScriptArgs.pedID[0], TRUE, FALSE, FALSE) ELSE ped = CREATE_PED(PEDTYPE_MISSION, IG_RAMP_MEX, <<454.1726, -1851.3158, 26.9211>>, 131.2600) SET_PED_COMPONENT_VARIATION(ped, PED_COMP_HEAD, 0, 0) SET_PED_COMPONENT_VARIATION(ped, PED_COMP_BERD, 0, 0) SET_PED_COMPONENT_VARIATION(ped, PED_COMP_HAIR, 0, 0) SET_PED_COMPONENT_VARIATION(ped, PED_COMP_TORSO, 0, 0) SET_PED_COMPONENT_VARIATION(ped, PED_COMP_LEG, 0, 0) SET_PED_COMPONENT_VARIATION(ped, PED_COMP_HAND, 0, 0) SET_PED_COMPONENT_VARIATION(ped, PED_COMP_FEET, 0, 0) SET_PED_COMPONENT_VARIATION(ped, PED_COMP_TEETH, 0, 0) SET_PED_COMPONENT_VARIATION(ped, PED_COMP_SPECIAL, 0, 0) SET_PED_COMPONENT_VARIATION(ped, PED_COMP_SPECIAL2, 0, 0) SET_PED_COMPONENT_VARIATION(ped, PED_COMP_DECL, 0, 0) SET_PED_COMPONENT_VARIATION(ped, PED_COMP_JBIB, 0, 0) SET_ENTITY_COORDS_GROUNDED(ped, <<454.1726, -1851.3158, 26.9211>>) CREATE_RAMPAGER_PED_FROM_PED_INDEX(rampagePed[ind0], ped, TRUE, FALSE, FALSE) ENDIF ENDIF IF GET_FREE_RAMPAGE_PED_INDEX(rampagePed, ind1) IF IS_ENTITY_ALIVE(rampageScriptArgs.pedID[1]) CREATE_RAMPAGER_PED_FROM_PED_INDEX(rampagePed[ind1], rampageScriptArgs.pedID[1], TRUE, FALSE, FALSE) ELSE ped = CREATE_PED(PEDTYPE_MISSION, IG_RAMP_MEX, <<457.3105, -1854.0668, 26.8747>>, 128.3050) SET_PED_COMPONENT_VARIATION(ped, PED_COMP_HEAD, 1, 0) SET_PED_COMPONENT_VARIATION(ped, PED_COMP_BERD, 0, 0) SET_PED_COMPONENT_VARIATION(ped, PED_COMP_HAIR, 0, 0) SET_PED_COMPONENT_VARIATION(ped, PED_COMP_TORSO, 1, 0) SET_PED_COMPONENT_VARIATION(ped, PED_COMP_LEG, 0, 1) SET_PED_COMPONENT_VARIATION(ped, PED_COMP_HAND, 0, 0) SET_PED_COMPONENT_VARIATION(ped, PED_COMP_FEET, 0, 0) SET_PED_COMPONENT_VARIATION(ped, PED_COMP_TEETH, 0, 0) SET_PED_COMPONENT_VARIATION(ped, PED_COMP_SPECIAL, 1, 0) SET_PED_COMPONENT_VARIATION(ped, PED_COMP_SPECIAL2, 0, 0) SET_PED_COMPONENT_VARIATION(ped, PED_COMP_DECL, 0, 0) SET_PED_COMPONENT_VARIATION(ped, PED_COMP_JBIB, 0, 0) SET_ENTITY_COORDS_GROUNDED(ped, <<457.3105, -1854.0668, 26.8747>>) CREATE_RAMPAGER_PED_FROM_PED_INDEX(rampagePed[ind1], ped, TRUE, FALSE, FALSE) ENDIF ENDIF IF (bSkipped = TRUE) IF NOT IS_REPLAY_BEING_SET_UP() SET_ENTITY_COORDS_GROUNDED(PLAYER_PED_ID(), rampageInfo.vPlyrStartPos) SET_ENTITY_HEADING(PLAYER_PED_ID(), rampageInfo.fPlyrStartHeading) ENDIF SET_ENTITY_COORDS_GROUNDED(rampagePed[ind0].pedID, <<454.1726, -1851.3158, 26.9211>>) SET_ENTITY_HEADING(rampagePed[ind0].pedID, 131.2600) SET_ENTITY_COORDS_GROUNDED(rampagePed[ind1].pedID, <<457.3105, -1854.0668, 26.8747>>) SET_ENTITY_HEADING(rampagePed[ind1].pedID, 128.3050) RAMPAGE_SMART_FLEE_HACKERY(rampagePed[ind1].pedID, <<408.9685, -1923.8516, 24.0339>>) RAMPAGE_SMART_FLEE_HACKERY(rampagePed[ind0].pedID, <<335.7316, -1887.2788, 24.8253>>) ENDIF bCreateInSwitch = TRUE BREAK CASE STATIC_BLIP_MINIGAME_RAMPAGE4 CLEAR_AREA_OF_OBJECTS(<<-152.6, -1665.1, 32.9>>, 1.0) CLEAR_AREA_OF_OBJECTS(<<-132.7, -1615.8, 32.6>>, 1.0) // this guy does not have the gun IF GET_FREE_RAMPAGE_PED_INDEX(rampagePed, ind0) IF IS_ENTITY_ALIVE(rampageScriptArgs.pedID[0]) CREATE_RAMPAGER_PED_FROM_PED_INDEX(rampagePed[ind0], rampageScriptArgs.pedID[0], TRUE, FALSE, FALSE) ELSE ped = CREATE_PED(PEDTYPE_MISSION, IG_RAMP_GANG, <<-156.00, -1660.82, 32.88>>, -14.52) SET_PED_COMPONENT_VARIATION(ped, PED_COMP_HEAD, 0, 0) SET_PED_COMPONENT_VARIATION(ped, PED_COMP_BERD, 0, 0) SET_PED_COMPONENT_VARIATION(ped, PED_COMP_HAIR, 0, 0) SET_PED_COMPONENT_VARIATION(ped, PED_COMP_TORSO, 0, 1) SET_PED_COMPONENT_VARIATION(ped, PED_COMP_LEG, 0, 0) SET_PED_COMPONENT_VARIATION(ped, PED_COMP_HAND, 0, 0) SET_PED_COMPONENT_VARIATION(ped, PED_COMP_FEET, 0, 0) SET_PED_COMPONENT_VARIATION(ped, PED_COMP_TEETH, 0, 0) SET_PED_COMPONENT_VARIATION(ped, PED_COMP_SPECIAL, 0, 0) SET_PED_COMPONENT_VARIATION(ped, PED_COMP_SPECIAL2, 0, 0) SET_PED_COMPONENT_VARIATION(ped, PED_COMP_DECL, 0, 1) SET_PED_COMPONENT_VARIATION(ped, PED_COMP_JBIB, 0, 0) SET_ENTITY_COORDS_GROUNDED(ped, <<-156.90, -1662.03, 32.84>>) CREATE_RAMPAGER_PED_FROM_PED_INDEX(rampagePed[ind0], ped, TRUE, FALSE, FALSE) ENDIF ENDIF // setup peds if they haven't been setup - he ends up on the floor IF GET_FREE_RAMPAGE_PED_INDEX(rampagePed, ind1) IF IS_ENTITY_ALIVE(rampageScriptArgs.pedID[1]) //SET_ENTITY_COORDS_GROUNDED(rampageScriptArgs.pedID[1], <<-164.50, -1672.90, 32.22>>) CREATE_RAMPAGER_PED_FROM_PED_INDEX(rampagePed[ind1], rampageScriptArgs.pedID[1], TRUE, FALSE, FALSE) ELSE ped = CREATE_PED(PEDTYPE_MISSION, IG_RAMP_GANG, <<-163.45, -1671.12, 32.38>>, -20.36) SET_PED_COMPONENT_VARIATION(ped, PED_COMP_HEAD, 1, 0) SET_PED_COMPONENT_VARIATION(ped, PED_COMP_BERD, 0, 0) SET_PED_COMPONENT_VARIATION(ped, PED_COMP_HAIR, 0, 0) SET_PED_COMPONENT_VARIATION(ped, PED_COMP_TORSO, 1, 1) SET_PED_COMPONENT_VARIATION(ped, PED_COMP_LEG, 0, 0) SET_PED_COMPONENT_VARIATION(ped, PED_COMP_HAND, 0, 0) SET_PED_COMPONENT_VARIATION(ped, PED_COMP_FEET, 0, 0) SET_PED_COMPONENT_VARIATION(ped, PED_COMP_TEETH, 0, 0) SET_PED_COMPONENT_VARIATION(ped, PED_COMP_SPECIAL, 0, 0) SET_PED_COMPONENT_VARIATION(ped, PED_COMP_SPECIAL2, 0, 0) SET_PED_COMPONENT_VARIATION(ped, PED_COMP_DECL, 1, 0) SET_PED_COMPONENT_VARIATION(ped, PED_COMP_JBIB, 0, 0) SET_ENTITY_COORDS_GROUNDED(ped, <<-163.45, -1671.12, 32.38>>) CREATE_RAMPAGER_PED_FROM_PED_INDEX(rampagePed[ind1], ped, TRUE, FALSE, FALSE) ENDIF ENDIF IF (bSkipped = TRUE) IF NOT IS_REPLAY_BEING_SET_UP() SET_ENTITY_COORDS_GROUNDED(PLAYER_PED_ID(), rampageInfo.vPlyrStartPos) SET_ENTITY_HEADING(PLAYER_PED_ID(), rampageInfo.fPlyrStartHeading) ENDIF SET_ENTITY_COORDS_GROUNDED(rampagePed[ind0].pedID, <<-156.90, -1662.03, 32.84>>) SET_ENTITY_HEADING(rampagePed[ind0].pedID, -14.52) // B*1034387 RAMPAGE_SMART_FLEE_HACKERY(rampagePed[ind0].pedID, <<-110.74, -1601.2, 31.7>>, FALSE) SET_ENTITY_COORDS_GROUNDED(rampagePed[ind1].pedID, <<-164.50, -1672.90, 32.22>>) SET_ENTITY_HEADING(rampagePed[ind1].pedID, -20.36) RAMPAGE_SMART_FLEE_HACKERY(rampagePed[ind1].pedID, <<-142.6, -1713.4, 30.1>>, TRUE)//, TRUE) ENDIF bCreateInSwitch = TRUE BREAK CASE STATIC_BLIP_MINIGAME_RAMPAGE5 IF IS_ENTITY_ALIVE(rampageScriptArgs.vehID[0]) FREEZE_ENTITY_POSITION(rampageScriptArgs.vehID[0], FALSE) ENDIF // setup fleeing peds if they haven't been setup IF GET_FREE_RAMPAGE_PED_INDEX(rampagePed, ind0) IF IS_ENTITY_ALIVE(rampageScriptArgs.pedID[0]) CREATE_RAMPAGER_PED_FROM_PED_INDEX(rampagePed[ind0], rampageScriptArgs.pedID[0], TRUE, FALSE, FALSE) //SET_ENTITY_HEADING(rampageScriptArgs.pedID[0], RAD_TO_DEG(-1.35)) ELSE ped = CREATE_PED(PEDTYPE_MISSION, S_M_Y_MARINE_01, <<-1299.23, 2510.35, 21.26>>, RAD_TO_DEG(-1.31)) SET_PED_COMPONENT_VARIATION(ped, PED_COMP_HEAD, 0, 0) SET_PED_COMPONENT_VARIATION(ped, PED_COMP_BERD, 0, 0) SET_PED_COMPONENT_VARIATION(ped, PED_COMP_HAIR, 0, 0) SET_PED_COMPONENT_VARIATION(ped, PED_COMP_TORSO, 0, 0) SET_PED_COMPONENT_VARIATION(ped, PED_COMP_LEG, 0, 0) SET_PED_COMPONENT_VARIATION(ped, PED_COMP_HAND, 0, 0) SET_PED_COMPONENT_VARIATION(ped, PED_COMP_FEET, 0, 0) SET_PED_COMPONENT_VARIATION(ped, PED_COMP_TEETH, 0, 0) SET_PED_COMPONENT_VARIATION(ped, PED_COMP_SPECIAL, 0, 0) SET_PED_COMPONENT_VARIATION(ped, PED_COMP_SPECIAL2, 0, 0) SET_PED_COMPONENT_VARIATION(ped, PED_COMP_DECL, 0, 0) SET_PED_COMPONENT_VARIATION(ped, PED_COMP_JBIB, 0, 0) CLEAR_PED_PROP(ped, ANCHOR_HEAD) CLEAR_PED_PROP(ped, ANCHOR_EYES) CLEAR_PED_PROP(ped, ANCHOR_EARS) CLEAR_PED_PROP(ped, ANCHOR_MOUTH) CLEAR_PED_PROP(ped, ANCHOR_LEFT_HAND) CLEAR_PED_PROP(ped, ANCHOR_RIGHT_HAND) CLEAR_PED_PROP(ped, ANCHOR_LEFT_WRIST) CLEAR_PED_PROP(ped, ANCHOR_RIGHT_WRIST) CLEAR_PED_PROP(ped, ANCHOR_HIP) CREATE_RAMPAGER_PED_FROM_PED_INDEX(rampagePed[ind0], ped, TRUE, FALSE, FALSE) ENDIF ENDIF IF GET_FREE_RAMPAGE_PED_INDEX(rampagePed, ind1) IF IS_ENTITY_ALIVE(rampageScriptArgs.pedID[1]) CREATE_RAMPAGER_PED_FROM_PED_INDEX(rampagePed[ind1], rampageScriptArgs.pedID[1], TRUE, FALSE, FALSE) SET_ENTITY_HEADING(rampagePed[ind1].pedID, 8.44) ELSE ped = CREATE_PED(PEDTYPE_MISSION, S_M_Y_MARINE_03, <<-1298.69, 2511.35, 21.17>>, RAD_TO_DEG(-1.42)) SET_PED_COMPONENT_VARIATION(ped, PED_COMP_HEAD, 1, 0) SET_PED_COMPONENT_VARIATION(ped, PED_COMP_BERD, 0, 0) SET_PED_COMPONENT_VARIATION(ped, PED_COMP_HAIR, 0, 0) SET_PED_COMPONENT_VARIATION(ped, PED_COMP_TORSO, 1, 0) SET_PED_COMPONENT_VARIATION(ped, PED_COMP_LEG, 0, 0) SET_PED_COMPONENT_VARIATION(ped, PED_COMP_HAND, 0, 0) SET_PED_COMPONENT_VARIATION(ped, PED_COMP_FEET, 0, 0) SET_PED_COMPONENT_VARIATION(ped, PED_COMP_TEETH, 0, 0) SET_PED_COMPONENT_VARIATION(ped, PED_COMP_SPECIAL, 0, 0) SET_PED_COMPONENT_VARIATION(ped, PED_COMP_SPECIAL2, 0, 0) SET_PED_COMPONENT_VARIATION(ped, PED_COMP_DECL, 0, 0) SET_PED_COMPONENT_VARIATION(ped, PED_COMP_JBIB, 0, 0) CLEAR_PED_PROP(ped, ANCHOR_HEAD) CLEAR_PED_PROP(ped, ANCHOR_EYES) CLEAR_PED_PROP(ped, ANCHOR_EARS) CLEAR_PED_PROP(ped, ANCHOR_MOUTH) CLEAR_PED_PROP(ped, ANCHOR_LEFT_HAND) CLEAR_PED_PROP(ped, ANCHOR_RIGHT_HAND) CLEAR_PED_PROP(ped, ANCHOR_LEFT_WRIST) CLEAR_PED_PROP(ped, ANCHOR_RIGHT_WRIST) CLEAR_PED_PROP(ped, ANCHOR_HIP) CREATE_RAMPAGER_PED_FROM_PED_INDEX(rampagePed[ind1], ped, TRUE, FALSE, FALSE) ENDIF ENDIF IF (bSkipped = TRUE) IF NOT IS_REPLAY_BEING_SET_UP() SET_ENTITY_COORDS_GROUNDED(PLAYER_PED_ID(), rampageInfo.vPlyrStartPos) SET_ENTITY_HEADING(PLAYER_PED_ID(), rampageInfo.fPlyrStartHeading) ENDIF IF IS_ENTITY_ALIVE(rampagePed[ind0].pedID) CPRINTLN(DEBUG_RAMPAGE, "ENTITIES 0 REPOSITION") SET_ENTITY_COORDS_GROUNDED(rampagePed[ind0].pedID, <<-1288.9551, 2529.9951, 19.52>>) SET_ENTITY_HEADING(rampagePed[ind0].pedID, RAD_TO_DEG(-0.83)) RAMPAGE_SMART_FLEE_HACKERY(rampagePed[ind0].pedID, <<-1222.5686, 2587.6506, 15.1474>>) ENDIF IF IS_ENTITY_ALIVE(rampagePed[ind1].pedID) CPRINTLN(DEBUG_RAMPAGE, "ENTITIES 1 REPOSITION") SET_ENTITY_COORDS_GROUNDED(rampagePed[ind1].pedID, <<-1284.7990, 2535.8208, 18.7709>>) SET_ENTITY_HEADING(rampagePed[ind1].pedID, RAD_TO_DEG(-0.15)) RAMPAGE_SMART_FLEE_HACKERY(rampagePed[ind1].pedID, <<-1222.5686, 2587.6506, 15.1474>>) ENDIF ENDIF // setup some cars ready IF GET_FREE_RAMPAGE_CAR_INDEX(ind) IF CREATE_RAMPAGE_CAR(rampageCar[ind], rampageInfo.carModels[0], <<-1433.5477, 2650.1660, 16.6436>>, 228.0205, TRUE, 2) SET_RAMPAGE_CAR_DEPLOY(rampageCar[ind], TRUE, 40.0) CPRINTLN(DEBUG_RAMPAGE, "AFTER CUTSCENE CAR 0 CREATED") ENDIF ENDIF IF GET_FREE_RAMPAGE_CAR_INDEX(ind) IF CREATE_RAMPAGE_CAR(rampageCar[ind], rampageInfo.carModels[0], <<-1478.0034, 2688.8289, 16.6436>>, 227.7704, TRUE, 2) SET_RAMPAGE_CAR_DEPLOY(rampageCar[ind], TRUE, 40.0) CPRINTLN(DEBUG_RAMPAGE, "AFTER CUTSCENE CAR 1 CREATED") ENDIF ENDIF bCreateInSwitch = TRUE BREAK ENDSWITCH GIVE_PLAYER_RAMPAGE_WEAPONS() //SIMULATE_PLAYER_INPUT_GAIT(PLAYER_ID(), PEDMOVE_SPRINT, 500) IF (bCreateInSwitch = TRUE) EXIT ENDIF // grab any peds in the cutscene tell them to flee // so the player has a first target and so they don't go into attack mode straight off // as it isn't fair if people are clearly behind the player on startup REPEAT COUNT_OF(rampageScriptArgs.pedID) n IF IS_ENTITY_ALIVE(rampageScriptArgs.pedID[n]) IF GET_FREE_RAMPAGE_PED_INDEX(rampagePed, ind) CREATE_RAMPAGER_PED_FROM_PED_INDEX(rampagePed[ind], rampageScriptArgs.pedID[n], TRUE, FALSE, FALSE) ENDIF ENDIF ENDREPEAT ENDPROC PROC SET_GAMEPLAY_INTERPOLATE_FROM_INTRO() CAMERA_INDEX cam SWITCH (rampageInfo.blipNameEnum) CASE STATIC_BLIP_MINIGAME_RAMPAGE1 cam = CREATE_CAM_WITH_PARAMS("DEFAULT_SCRIPTED_CAMERA", <<907.5499, 3641.5085, 33.1808>>, <<-11.3754, 0.0004, -105.7755>>, 50.0000, TRUE) BREAK DEFAULT cam = CREATE_CAM_WITH_PARAMS("DEFAULT_SCRIPTED_CAMERA", vFinalCamCoord, vFinalCamRot, 50.0000, TRUE) BREAK ENDSWITCH IF DOES_CAM_EXIST(cam) SET_CAM_ACTIVE(cam, TRUE) RENDER_SCRIPT_CAMS(TRUE, FALSE) WAIT(0) STOP_RENDERING_SCRIPT_CAMS_USING_CATCH_UP() //RENDER_SCRIPT_CAMS(FALSE, TRUE) ENDIF ENDPROC /// PURPOSE: /// Updates the intro /// RETURNS: /// Returns true when intro is finished FUNC BOOL UPDATE_INTRO_CUTSCENE() VECTOR plyrPos SWITCH (stageProgress) CASE SP_LOADING #IF IS_DEBUG_BUILD IF (bDebugShowTTY) CPRINTLN(DEBUG_RAMPAGE, "Requesting Cutscene ", rampageScriptArgs.sIntroCutscene) ENDIF #ENDIF CPRINTLN(DEBUG_RAMPAGE, "Loading Cutscene:", rampageScriptArgs.sIntroCutscene, " Game Time:", GET_GAME_TIMER()) RC_TakeEntityOwnership(rampageScriptArgs) CPRINTLN(DEBUG_RAMPAGE, "Owner Ship Passed Across") IF NOT HAS_CUTSCENE_LOADED() RC_REQUEST_CUTSCENE(rampageScriptArgs.sIntroCutscene) PRESTREAM_RAMPAGE_INTRO_CUTSCENE_PED_VARIATIONS(rampageScriptArgs, sSceneHandles) // gun and holster IF rampageInfo.blipNameEnum = STATIC_BLIP_MINIGAME_RAMPAGE3 IF IS_ENTITY_ALIVE(rampageScriptArgs.pedID[0]) SET_PED_COMPONENT_VARIATION(rampageScriptArgs.pedID[0], PED_COMP_SPECIAL, 0, 0) SET_PED_COMPONENT_VARIATION(rampageScriptArgs.pedID[0], PED_COMP_SPECIAL2, 1, 0) ENDIF ENDIF ENDIF stageProgress = SP_SETUP BREAK CASE SP_SETUP PRESTREAM_RAMPAGE_INTRO_CUTSCENE_PED_VARIATIONS(rampageScriptArgs, sSceneHandles) IF rampageInfo.blipNameEnum = STATIC_BLIP_MINIGAME_RAMPAGE3 IF IS_ENTITY_ALIVE(rampageScriptArgs.pedID[0]) SET_PED_COMPONENT_VARIATION(rampageScriptArgs.pedID[0], PED_COMP_SPECIAL, 0, 0) SET_PED_COMPONENT_VARIATION(rampageScriptArgs.pedID[0], PED_COMP_SPECIAL2, 1, 0) ENDIF ENDIF bPlayerExitStateSet = FALSE IF RC_IS_CUTSCENE_OK_TO_START() #IF IS_DEBUG_BUILD IF (bDebugShowTTY) CPRINTLN(DEBUG_RAMPAGE, "Playing Cutscene ", rampageScriptArgs.sIntroCutscene) ENDIF #ENDIF /*In rampage2, request fake cell phone movie IF rampageInfo.blipNameEnum = STATIC_BLIP_MINIGAME_RAMPAGE2 REQUEST_FAKE_CELLPHONE_MOVIE(sFakeCellphoneData) WHILE NOT HAS_FAKE_CELLPHONE_MOVIE_LOADED( sFakeCellphoneData ) WAIT(0) ENDWHILE ENDIF */ TASK_CLEAR_LOOK_AT( PLAYER_PED_ID() ) CPRINTLN(DEBUG_RAMPAGE, "Starting Cutscene:", rampageScriptArgs.sIntroCutscene, " Game Time:", GET_GAME_TIMER()) plyrPos = GET_ENTITY_COORDS(PLAYER_PED_ID()) REQUEST_ACTION_MODE_ASSET("TREVOR_ACTION") REGISTER_INTRO_CUTSCENE_ENTITIES() SET_CUTSCENE_CAN_BE_SKIPPED(FALSE) RC_CLEANUP_LAUNCHER() START_CUTSCENE() //WAIT(0) UNLOAD_LEADIN_ANIMDICT(rampageLeadIn) CPRINTLN(DEBUG_RAMPAGE, "Cleared Vehicle For :", rampageScriptArgs.sIntroCutscene, " Game Time:", GET_GAME_TIMER()) RC_START_CUTSCENE_MODE(plyrPos, TRUE, FALSE, TRUE, TRUE, FALSE, TRUE, TRUE) //BLOCK_SCENARIOS_AND_AMBIENT(scenarioBlock) SAFE_FADE_SCREEN_IN_FROM_BLACK(500, FALSE) bCutsceneIsPlaying = FALSE LOAD_RAMPAGE_ASSETS(FALSE) stageProgress = SP_RUNNING ENDIF BREAK CASE SP_RUNNING IF ARE_RAMPAGE_ASSETS_LOADED() IF NOT bCutsceneCanBeSkipped bCutsceneCanBeSkipped = TRUE SET_CUTSCENE_CAN_BE_SKIPPED(TRUE) ENDIF // IF IS_CUTSCENE_SKIP_BUTTON_JUST_PRESSED_WITH_DELAY() //@RJP IS_CUTSCENE_SKIP_BUTTON_JUST_PRESSED_WITH_DELAY doesn't seem to work, WAS_CUTSCENE_SKIPPED seems to work though IF WAS_CUTSCENE_SKIPPED() stageProgress = SP_CSKIPPED RETURN FALSE ENDIF ENDIF IF IS_CUTSCENE_PLAYING() AND (bCutsceneIsPlaying = FALSE) BLOCK_SCENARIOS_AND_AMBIENT(worldScenarioBlockID, FALSE) SET_PLAYER_WEAPON_DAMAGE_MODIFIER(PLAYER_ID(), rampageCombatParams.fPlayerWeaponDamageModifier) SET_PLAYER_WEAPON_DEFENSE_MODIFIER(PLAYER_ID(), rampageCombatParams.fPlayerWeaponDefenseModifier) CPRINTLN(DEBUG_RAMPAGE, "*** REMOVING PLAYER WEAPONS, RESOLVING VEHICLES ***") REMOVE_ALL_PED_WEAPONS(PLAYER_PED_ID()) RESOLVE_MISSION_VEHICLES_FOR_CUTSCENE() //If rampage2, move hipster's chair back into place IF rampageInfo.blipNameEnum = STATIC_BLIP_MINIGAME_RAMPAGE2 IF IS_ENTITY_ALIVE(rampageScriptArgs.objID[2]) SET_ENTITY_COORDS( rampageScriptArgs.objID[2], <<1179.778, -401.7374, 66.8697>> ) ENDIF //DRAW_FAKE_CELLPHONE_SCREEN(sFakeCellphoneData, FALSE, FAKE_CELLPHONE_SCREEN_GENERIC_CALL) ENDIF // ENABLE_AMBIENT_PEDS_AND_VEHICLES(FALSE, FALSE, TRUE, TRUE) IF rampageInfo.blipNameEnum = STATIC_BLIP_MINIGAME_RAMPAGE1 // hide and move beer bottles IF IS_ENTITY_ALIVE(rampageScriptArgs.objID[1]) DETACH_ENTITY(rampageScriptArgs.objID[1]) SET_ENTITY_COORDS( rampageScriptArgs.objID[1], <<909.8177, 3643.2930, 31.7073>> ) SET_ENTITY_ROTATION( rampageScriptArgs.objID[1], <<0,0,140.60>> ) FREEZE_ENTITY_POSITION(rampageScriptArgs.objID[1],TRUE) SET_ENTITY_VISIBLE(rampageScriptArgs.objID[1],FALSE) ENDIF IF IS_ENTITY_ALIVE(rampageScriptArgs.objID[2]) DETACH_ENTITY(rampageScriptArgs.objID[2]) SET_ENTITY_COORDS( rampageScriptArgs.objID[2], <<907.6703, 3643.4170, 31.7073>> ) SET_ENTITY_ROTATION( rampageScriptArgs.objID[2], <<0,0,-62.47>> ) FREEZE_ENTITY_POSITION(rampageScriptArgs.objID[2],TRUE) SET_ENTITY_VISIBLE(rampageScriptArgs.objID[2],FALSE) ENDIF ENDIF bCutsceneIsPlaying = TRUE ENDIF IF (GET_CUTSCENE_TIME() > iRampageMusicStartTime) TRIGGER_RAMPAGE_MUSIC() ENDIF IF rampageInfo.blipNameEnum = STATIC_BLIP_MINIGAME_RAMPAGE4 IF NOT bBloodDamage IF IS_ENTITY_ALIVE( rampageScriptArgs.pedID[1] ) IF (GET_CUTSCENE_TIME() > 20100) CPRINTLN( DEBUG_RAMPAGE, "APPLYING BLOOD DAMAGE TO PED1" ) APPLY_PED_BLOOD_SPECIFIC(rampageScriptArgs.pedID[1], ENUM_TO_INT(PDZ_HEAD), 0.500, 0.650, 307.546, 1.000, 3, 0.00, "BulletLarge") bBloodDamage = TRUE ENDIF ENDIF ENDIF ENDIF IF HAS_CUTSCENE_FINISHED() RC_END_CUTSCENE_MODE(TRUE, FALSE) POST_INTRO_CUTSCENE_SETUP() SETUP_INITIAL_PEDS() IF rampageInfo.blipNameEnum = STATIC_BLIP_MINIGAME_RAMPAGE2 RELEASE_FAKE_CELLPHONE_MOVIE(sFakeCellphoneData) ENDIF IF rampageInfo.blipNameEnum = STATIC_BLIP_MINIGAME_RAMPAGE1 // unhide beer bottles IF IS_ENTITY_ALIVE(rampageScriptArgs.objID[1]) FREEZE_ENTITY_POSITION(rampageScriptArgs.objID[1],FALSE) SET_ENTITY_VISIBLE(rampageScriptArgs.objID[1],TRUE) ENDIF IF IS_ENTITY_ALIVE(rampageScriptArgs.objID[2]) FREEZE_ENTITY_POSITION(rampageScriptArgs.objID[2],FALSE) SET_ENTITY_VISIBLE(rampageScriptArgs.objID[2],TRUE) ENDIF ENDIF IF (bHackInterpolate) SET_GAMEPLAY_INTERPOLATE_FROM_INTRO() ENDIF RETURN TRUE ELSE //vFinalCamCoord = GET_FINAL_RENDERED_CAM_COORD() //FinalCamRot = GET_FINAL_RENDERED_CAM_ROT() UPDATE_REGISTERED_INTRO_CUTSCENE_EXIT_STATE() IF NOT bPlayerExitStateSet //CPRINTLN(DEBUG_RAMPAGE, "UPDATING PLAYER CAMERA") SET_GAMEPLAY_CAM_RELATIVE_HEADING() SET_GAMEPLAY_CAM_RELATIVE_PITCH() ENDIF ENDIF BREAK CASE SP_CSKIPPED SET_CUTSCENE_FADE_VALUES(false, false, false, false) SAFE_FADE_SCREEN_OUT_TO_BLACK(250, FALSE) WAIT_FOR_CUTSCENE_TO_STOP() RC_END_CUTSCENE_MODE() SAFE_DELETE_OBJECT(rampageScriptArgs.objID[0]) IF rampageInfo.blipNameEnum = STATIC_BLIP_MINIGAME_RAMPAGE1 // unhide beer bottles IF IS_ENTITY_ALIVE(rampageScriptArgs.objID[1]) FREEZE_ENTITY_POSITION(rampageScriptArgs.objID[1],FALSE) SET_ENTITY_VISIBLE(rampageScriptArgs.objID[1],TRUE) ENDIF IF IS_ENTITY_ALIVE(rampageScriptArgs.objID[2]) FREEZE_ENTITY_POSITION(rampageScriptArgs.objID[2],FALSE) SET_ENTITY_VISIBLE(rampageScriptArgs.objID[2],TRUE) ENDIF ENDIF POST_INTRO_CUTSCENE_SETUP(TRUE) SETUP_INITIAL_PEDS() SET_GAMEPLAY_CAM_RELATIVE_HEADING() SET_GAMEPLAY_CAM_RELATIVE_PITCH() WAIT(250) RETURN TRUE CASE SP_CLEANUP RC_END_CUTSCENE_MODE(TRUE, FALSE) RETURN TRUE ENDSWITCH RETURN FALSE ENDFUNC //---------------------- // SFORM FUNCTIONS //---------------------- /// PURPOSE: /// Tells us if the intro scaleform is active /// RETURNS: /// True or False FUNC BOOL IS_RAMPAGE_SCALEFORM_INTRO_RUNNING() RETURN ENUM_TO_INT(sFormState) < ENUM_TO_INT(SFR_INTRODONE) ENDFUNC /// PURPOSE: /// Tells us if the outro (results) scaleform is active /// RETURNS: /// True or False FUNC BOOL IS_RAMPAGE_SCALEFORM_OUTRO_RUNNING() RETURN ENUM_TO_INT(sFormState) >= ENUM_TO_INT(SFR_OUTROSTART) ENDFUNC /// PURPOSE: /// Tells us if any rampage scaleform is active /// RETURNS: /// True or False FUNC BOOL IS_RAMPAGE_SCALEFORM_RUNNING() RETURN IS_RAMPAGE_SCALEFORM_INTRO_RUNNING() OR IS_RAMPAGE_SCALEFORM_INTRO_RUNNING() ENDFUNC /// PURPOSE: /// Fills in data for the rampage complete endscreen /// PARAMS: /// cp - PROC ADD_CHALLENGE_TO_PASSED_ENDSCREEN_DATASET( RAMPAGE_CHALLENGE &cp ) IF (cp.iRequiredAmount = 0) EXIT ENDIF END_SCREEN_CHECK_MARK_STATUS check = ESCM_UNCHECKED IF (CHECK_CHALLENGE(cp)) check = ESCM_CHECKED iCompletedChallenges ++ ENDIF /* BOOL bInvalidated = TRUE IF (rampageInfo.bPassed) bInvalidated = FALSE ENDIF */ ADD_ENDSCREEN_DATASET_CONTENT_ELEMENT( esd, ESEF_LEFT_SIDE_INT_SUBSTRING, cp.sTxtKey, "", cp.iRequiredAmount, 0, check) ENDPROC /// PURPOSE: /// Fills in a line of the rampage complete score with an in /// PARAMS /// txtkey - the string we want on the left /// val - the number we want on the right PROC ADD_CHALLENGE_TO_PASSED_SCALEFORM(RAMPAGE_CHALLENGE &cp, INT &slot) IF (cp.iRequiredAmount = 0) EXIT ENDIF INT chk = 0 IF (CHECK_CHALLENGE(cp)) chk = 1 ENDIF // headshots BEGIN_SCALEFORM_MOVIE_METHOD(sFormRampageStats, "SET_DATA_SLOT") SCALEFORM_MOVIE_METHOD_ADD_PARAM_INT(slot) SCALEFORM_MOVIE_METHOD_ADD_PARAM_INT(chk) //SCALEFORM_MOVIE_METHOD_ADD_PARAM_INT(0) //SCALEFORM_MOVIE_METHOD_ADD_PARAM_INT(0) // headshots BEGIN_TEXT_COMMAND_SCALEFORM_STRING(cp.sTxtKey) ADD_TEXT_COMPONENT_INTEGER(cp.iRequiredAmount) END_TEXT_COMMAND_SCALEFORM_STRING() END_SCALEFORM_MOVIE_METHOD() slot ++ ENDPROC /// PURPOSE: /// Fills in a line of the rampage complete score with an time /// PARAMS /// txtkey - the string we want on the left /// val - the number we want on the right (in ms) /// slot - the data slot we want to add it to PROC ADD_INT_TO_PASSED_SCALEFORM(STRING txtkey, INT val, INT &slot) IF (val <= 0) AND (bShowZeroScores = FALSE) EXIT ENDIF // headshots BEGIN_SCALEFORM_MOVIE_METHOD(sFormRampageStats, "SET_DATA_SLOT") SCALEFORM_MOVIE_METHOD_ADD_PARAM_INT(slot) SCALEFORM_MOVIE_METHOD_ADD_PARAM_INT(-1) SCALEFORM_MOVIE_METHOD_ADD_PARAM_INT(1) SCALEFORM_MOVIE_METHOD_ADD_PARAM_INT(val) // headshots SCALEFORM_MOVIE_METHOD_ADD_PARAM_STRING(txtkey) END_SCALEFORM_MOVIE_METHOD() slot ++ ENDPROC /// PURPOSE: /// Fills in a line of the rampage complete score with an time /// PARAMS /// txtkey - the string we want on the left /// val - the number we want on the right (in ms) /// slot - the data slot we want to add it to PROC ADD_PERCENT_TO_PASSED_SCALEFORM(STRING txtkey, INT val, INT &slot) IF (val <= 0) AND (bShowZeroScores = FALSE) EXIT ENDIF // headshots BEGIN_SCALEFORM_MOVIE_METHOD(sFormRampageStats, "SET_DATA_SLOT") SCALEFORM_MOVIE_METHOD_ADD_PARAM_INT(slot) SCALEFORM_MOVIE_METHOD_ADD_PARAM_INT(-1) SCALEFORM_MOVIE_METHOD_ADD_PARAM_INT(3) SCALEFORM_MOVIE_METHOD_ADD_PARAM_INT(val) // headshots SCALEFORM_MOVIE_METHOD_ADD_PARAM_STRING(txtkey) END_SCALEFORM_MOVIE_METHOD() slot ++ ENDPROC /// PURPOSE: /// Works out the final score /// RETURNS: /// Score FUNC INT CALCULATE_RAMPAGE_FINAL_SCORE() INT i INT sc INT val INT m, s, t INT iTimeLeft = rampageInfo.iTimeLimit - (rampageStats.iEndTime - rampageStats.iStartTime) FLOAT cPercent CPRINTLN(DEBUG_RAMPAGE, "") CPRINTLN(DEBUG_RAMPAGE, "-SCORE BREAKDOWN-----------------------------------") CONVERT_INT_TO_TIME(iTimeLeft, m, s, t) /* B*970451 IF (iTimeLeft > 0) val = (iTimeLeft / 100) * FINAL_TIME_BONUS CPRINTLN(DEBUG_RAMPAGE, " TIME LEFT:", m, ":", s, ".", t, " = ", val) sc += val ENDIF */ val = rampageStats.iCarDeadCount * FINAL_CAR_KILL_BONUS CPRINTLN(DEBUG_RAMPAGE, " CARS KILLS:", rampageStats.iCarDeadCount, " = ", val) sc += val val = rampageStats.iMaxChain * FINAL_CHAIN_BONUS CPRINTLN(DEBUG_RAMPAGE, " MAX CHAIN:", rampageStats.iMaxChain, " = ", val) sc += val val = rampageStats.iHeadShots * FINAL_HEADSHOT_BONUS CPRINTLN(DEBUG_RAMPAGE, " HEADSHOTS:", rampageStats.iHeadShots, " = ", val) sc += val val = rampageStats.iPedDeadCount * FINAL_KILLS_BONUS CPRINTLN(DEBUG_RAMPAGE, " KILLS:", rampageStats.iPedDeadCount, " = ", val) sc += val /* val = rampageStats.iCloseRange * FINAL_CLOSE_RANGE_BONUS CPRINTLN(DEBUG_RAMPAGE, " CLOSE RANGE:", rampageStats.iCloseRange, " = ", val) sc += val val = rampageStats.iLongRange * FINAL_LONG_RANGE_BONUS CPRINTLN(DEBUG_RAMPAGE, " LONG SHOT:", rampageStats.iLongRange, " = ", val) sc += val val = rampageStats.iInnocentsDead * FINAL_INNOCENT_BONUS CPRINTLN(DEBUG_RAMPAGE, " INNOCENTS KILLS:", rampageStats.iInnocentsDead, " = -", val) sc -= val */ CPRINTLN(DEBUG_RAMPAGE, "") CPRINTLN(DEBUG_RAMPAGE, " FINAL SCORE:", sc) CPRINTLN(DEBUG_RAMPAGE, "---------------------------------------------------") CPRINTLN(DEBUG_RAMPAGE, "") // do check to see if we have beaten rampage score and write medal to CPRINTLN(DEBUG_RAMPAGE, "-CHALLENGE CHECK-----------------------------------") cPercent = GET_TOTAL_CHALLENGE_PERCENTAGE(rampageChallenge) * 50.0 REPEAT COUNT_OF(rampageChallenge) i IF (CHECK_CHALLENGE(rampageChallenge[i])) CPRINTLN(DEBUG_RAMPAGE, " CHALLENGE ", i, " COMPLETED") ENDIF ENDREPEAT CPRINTLN(DEBUG_RAMPAGE, "") CPRINTLN(DEBUG_RAMPAGE, " COMPLETED CHALLENGE PERCENTAGE: ", cPercent * 2.0, "%") CPRINTLN(DEBUG_RAMPAGE, "") CPRINTLN(DEBUG_RAMPAGE, "---------------------------------------------------") CPRINTLN(DEBUG_RAMPAGE, "") // medal percents IF (rampageStats.iPedDeadCount >= rampageInfo.iTargetAmount) cPercent += 50.0 ENDIF IF HAS_CHEAT_BEEN_USED_THIS_SESSION(CHEAT_TYPE_SUPER_JUMP) OR HAS_CHEAT_BEEN_USED_THIS_SESSION(CHEAT_TYPE_SLIDEY_CARS) OR HAS_CHEAT_BEEN_USED_THIS_SESSION(CHEAT_TYPE_FAST_RUN) OR HAS_CHEAT_BEEN_USED_THIS_SESSION(CHEAT_TYPE_FAST_SWIM) OR HAS_CHEAT_BEEN_USED_THIS_SESSION(CHEAT_TYPE_GIVE_WEAPONS) OR HAS_CHEAT_BEEN_USED_THIS_SESSION(CHEAT_TYPE_GIVE_HEALTH_ARMOR) OR HAS_CHEAT_BEEN_USED_THIS_SESSION(CHEAT_TYPE_SPECIAL_ABILITY_RECHARGE) OR HAS_CHEAT_BEEN_USED_THIS_SESSION(CHEAT_TYPE_SPAWN_VEHICLE) OR HAS_CHEAT_BEEN_USED_THIS_SESSION(CHEAT_TYPE_GIVE_PARACHUTE) iCurrentMedalIndex = RAMPAGE_BRONZE ELIF (cPercent >= 100.0) iCurrentMedalIndex = RAMPAGE_GOLD ELIF (cPercent >= 75.0) iCurrentMedalIndex = RAMPAGE_SILVER ELIF (cPercent >= 50.0) iCurrentMedalIndex = RAMPAGE_BRONZE ELSE iCurrentMedalIndex = RAMPAGE_NOMEDAL ENDIF CPRINTLN(DEBUG_RAMPAGE, "") CPRINTLN(DEBUG_RAMPAGE, " MEDAL PERCENT:", cPercent, "%") CPRINTLN(DEBUG_RAMPAGE, "") // do check to see if we have beaten rampage score and write medal to CPRINTLN(DEBUG_RAMPAGE, "-SAVE DATA CHECK-----------------------------------") CPRINTLN(DEBUG_RAMPAGE, " RAMPAGE #:", rampageInfo.iRampageIndex) CPRINTLN(DEBUG_RAMPAGE, "") CPRINTLN(DEBUG_RAMPAGE, " SAVED MEDAL INDEX :", g_savedGlobals.sRampageData.playerData[rampageInfo.iRampageIndex].iMedalIndex) CPRINTLN(DEBUG_RAMPAGE, " MEDAL THIS SESSION:", ENUM_TO_INT(iCurrentMedalIndex)) CPRINTLN(DEBUG_RAMPAGE, " SAVED HIGH SCORE :", g_savedGlobals.sRampageData.playerData[rampageInfo.iRampageIndex].iHighScore) CPRINTLN(DEBUG_RAMPAGE, " SCORE THIS SESSION:", sc) IF IS_REPEAT_PLAY_ACTIVE() IF (ENUM_TO_INT(iCurrentMedalIndex) > g_savedGlobals.sRampageData.playerData[rampageInfo.iRampageIndex].iMedalIndex) OR (sc > g_savedGlobals.sRampageData.playerData[rampageInfo.iRampageIndex].iHighScore) CPRINTLN(DEBUG_MISSION_STATS, " Repeat play is active, logging medal and/or high score for rampage ", rampageInfo.iRampageIndex, ".") CLEAR_REPLAY_STATS() BEGIN_REPLAY_STATS(13, 37) ADD_REPLAY_STAT_VALUE(rampageInfo.iRampageIndex) IF (ENUM_TO_INT(iCurrentMedalIndex) > g_savedGlobals.sRampageData.playerData[rampageInfo.iRampageIndex].iMedalIndex) CPRINTLN(DEBUG_MISSION_STATS, " Medal rank beaten. Passing new rank ", ENUM_TO_INT(iCurrentMedalIndex), ".") ADD_REPLAY_STAT_VALUE(ENUM_TO_INT(iCurrentMedalIndex)) ELSE CPRINTLN(DEBUG_MISSION_STATS, " Medal rank not beaten. Passing old rank ", g_savedGlobals.sRampageData.playerData[rampageInfo.iRampageIndex].iMedalIndex, ".") ADD_REPLAY_STAT_VALUE(g_savedGlobals.sRampageData.playerData[rampageInfo.iRampageIndex].iMedalIndex) ENDIF IF (sc > g_savedGlobals.sRampageData.playerData[rampageInfo.iRampageIndex].iHighScore) CPRINTLN(DEBUG_MISSION_STATS, " High score beaten. Passing new score ", sc, ".") ADD_REPLAY_STAT_VALUE(sc) ELSE CPRINTLN(DEBUG_MISSION_STATS, " High score not beaten. Passing old score ", g_savedGlobals.sRampageData.playerData[rampageInfo.iRampageIndex].iHighScore, ".") ADD_REPLAY_STAT_VALUE(g_savedGlobals.sRampageData.playerData[rampageInfo.iRampageIndex].iHighScore) ENDIF END_REPLAY_STATS() ENDIF ENDIF IF (ENUM_TO_INT(iCurrentMedalIndex) > g_savedGlobals.sRampageData.playerData[rampageInfo.iRampageIndex].iMedalIndex) CPRINTLN(DEBUG_RAMPAGE, "") CPRINTLN(DEBUG_RAMPAGE, " MEDAL RECORD BEATEN!") g_savedGlobals.sRampageData.playerData[rampageInfo.iRampageIndex].iMedalIndex = ENUM_TO_INT(iCurrentMedalIndex) ENDIF IF (sc > g_savedGlobals.sRampageData.playerData[rampageInfo.iRampageIndex].iHighScore) CPRINTLN(DEBUG_RAMPAGE, "") CPRINTLN(DEBUG_RAMPAGE, " HIGH SCORE BEATEN!") g_savedGlobals.sRampageData.playerData[rampageInfo.iRampageIndex].iHighScore = sc ENDIF CPRINTLN(DEBUG_RAMPAGE, "---------------------------------------------------") CPRINTLN(DEBUG_RAMPAGE, "") RETURN sc ENDFUNC PROC LODGE_PERCENTAGE_FOR_CURRENT_RAMPAGE(FLOAT fperc) FLOAT fLastPerc = GET_RC_MS_PERCENTAGE(rcRampageMissionID) CPRINTLN(DEBUG_ACHIEVEMENT, "ACH10 - Lodging Percentage For RC Mission - Old %:", fLastPerc, " Current %:", fperc) IF (fLastPerc < 100.0) CPRINTLN(DEBUG_ACHIEVEMENT, "ACH10 - Previous Percentage is less than 100%") IF fperc >= 100.0 ++g_savedGlobals.sFlowCustom.iMissionGolds ENDIF ENDIF IF (fperc >= fLastPerc) SET_RC_MS_PERCENTAGE(rcRampageMissionID, fperc) ENDIF ENDPROC /// PURPOSE: /// This starts up the rampage complete screen PROC SETUP_RAMPAGE_COMPLETE_SCALEFORM() INT iTimeLeft = rampageInfo.iTimeLimit - (rampageStats.iEndTime - rampageStats.iStartTime) // INT iDataSlot = 0 INT i //INT iTimeBonus IF (iTimeLeft < 0) iTimeLeft = 0 ENDIF CALCULATE_RAMPAGE_FINAL_SCORE() //Update Rampages Completed stat and achievement INT iNumRampagesCompleted = 0 REPEAT NUM_OF_RAMPAGES i IF g_savedGlobals.sRampageData.playerData[i].iHighScore>0 iNumRampagesCompleted++ ENDIF ENDREPEAT //Check achievement and stat progress, update if necessary STAT_GET_INT(NUM_RAMPAGES_COMPLETED,i) IF I 0) SET_RANDOM_SEED(rampageInfo.iRandomSeed) ENDIF BREAK CASE SFR_INTRODONE RESET_RAMPAGE_STATS(rampageStats) IF IS_REPEAT_RAMPAGE_IN_PROGRESS() IF IS_SCREEN_FADED_OUT() CPRINTLN(DEBUG_RAMPAGE, "SCREEN SHOULD BE FADED OUT") ELSE CPRINTLN(DEBUG_RAMPAGE, "SCREEN ISN'T FADED OUT") ENDIF IF IS_SCREEN_FADING_IN() CPRINTLN(DEBUG_RAMPAGE, "SCREEN IS FADING IN AND IT SHOULDN'T BE") ENDIF CPRINTLN(DEBUG_RAMPAGE, "*** REMOVING PLAYER WEAPONS, REPEAT IN PROGRESS***") REMOVE_ALL_PED_WEAPONS(PLAYER_PED_ID()) POST_INTRO_CUTSCENE_SETUP(TRUE) SETUP_INITIAL_PEDS() ENDIF sFormState = SFR_RAMPAGEON iCurrentMedalIndex = RAMPAGE_NOMEDAL iTimeLineEventIndex = 0 rampageStats.iStartTime = GET_GAME_TIMER() rampageStats.iPredictedEndTime = rampageStats.iStartTime + rampageInfo.iTimeLimit END_REPLAY_SETUP() PRINTLN(DEBUG_RAMPAGE, "FADING IN SCREEN") SAFE_FADE_SCREEN_IN_FROM_BLACK(500, FALSE) // give weapons SETUP_RAMPAGE_BATTLE_RANT() FORCE_RAMPAGE_PED_ARRAY_COMBAT(rampagePed) TRIGGER_RAMPAGE_MUSIC() TRIGGER_RAMPAGE_ONE_SHOT() TRIGGER_RAMPAGE_FX() // force 0 wanted level IF IS_ENTITY_OK(PLAYER_PED_ID()) GIVE_PLAYER_RAMPAGE_WEAPONS() SET_MAX_WANTED_LEVEL(0) SET_PLAYER_WANTED_LEVEL(PLAYER_ID(), 0) SET_WANTED_LEVEL_MULTIPLIER(0.0) SET_PLAYER_WANTED_LEVEL_NOW(PLAYER_ID()) SET_DISPATCH_COPS_FOR_PLAYER(PLAYER_ID(), FALSE) SET_PLAYER_WEAPON_DAMAGE_MODIFIER(PLAYER_ID(), rampageCombatParams.fPlayerWeaponDamageModifier) SET_PLAYER_WEAPON_DEFENSE_MODIFIER(PLAYER_ID(), rampageCombatParams.fPlayerWeaponDefenseModifier) IF NOT bPlayerExitStateSet SET_PLAYER_CONTROL(PLAYER_ID(), FALSE, SPC_LEAVE_CAMERA_CONTROL_ON) TASK_PLAY_ANIM( PLAYER_PED_ID(), "missrampageintrooutro", rampageInfo.sIntroAnim, SLOW_BLEND_IN, SLOW_BLEND_OUT ) ENDIF ENDIF IF NOT IS_STRING_NULL_OR_EMPTY(sAudioScene) IF NOT IS_AUDIO_SCENE_ACTIVE(sAudioScene) START_AUDIO_SCENE(sAudioScene) CPRINTLN(DEBUG_RAMPAGE, "RAMPAGE_CLEANUP() - AUDIO SCENE STARTED") ENDIF ENDIF BEGIN_TEXT_COMMAND_PRINT("TR_ROBJ1") ADD_TEXT_COMPONENT_INTEGER(rampageInfo.iTargetAmount) ADD_TEXT_COMPONENT_SUBSTRING_TEXT_LABEL(rampageInfo.sTargetName) END_TEXT_COMMAND_PRINT(DEFAULT_GOD_TEXT_TIME, TRUE) // iNextClockTickSoundTime = GET_GAME_TIMER() + 1000 IF LOAD_STREAM( "RAMPAGE_STREAMING_BED_MASTER" ) PLAY_STREAM_FRONTEND() ENDIF BREAK CASE SFR_RAMPAGEON IF NOT IS_ENTITY_PLAYING_ANIM( PLAYER_PED_ID(), "missrampageintrooutro", rampageInfo.sIntroAnim ) SET_PLAYER_CONTROL(PLAYER_ID(), TRUE) ENDIF // this is to make sure that the movie has to time to go away IF NOT bRampageShardAnimated IF (GET_GAME_TIMER() > (rampageStats.iStartTime + 2500)) BEGIN_SCALEFORM_MOVIE_METHOD(sFormRampage, "SHARD_ANIM_OUT") SCALEFORM_MOVIE_METHOD_ADD_PARAM_INT(ENUM_TO_INT(HUD_COLOUR_BLACK))//WHITE)) SCALEFORM_MOVIE_METHOD_ADD_PARAM_FLOAT(0.33) SCALEFORM_MOVIE_METHOD_ADD_PARAM_INT(ENUM_TO_INT(HUD_COLOUR_RED)) END_SCALEFORM_MOVIE_METHOD() bRampageShardAnimated = TRUE ENDIF ELIF (GET_GAME_TIMER() > (rampageStats.iStartTime + 3000)) IF (bDisplayedSpecialHelp = FALSE) IF (rampageInfo.blipNameEnum = STATIC_BLIP_MINIGAME_RAMPAGE1) PRINT_HELP("RAMP_WPN_CHNGE") bDisplayedSpecialHelp = TRUE ENDIF ENDIF IF (sFormRampage <> NULL) SET_SCALEFORM_MOVIE_AS_NO_LONGER_NEEDED(sFormRampage) sFormRampage = NULL ENDIF EXIT ENDIF BREAK CASE SFR_OUTROSTART sFormAlpha = 255 rampageStats.iEndTime = GET_GAME_TIMER() TRIGGER_MUSIC_EVENT("RAMPAGE_STOP") STOP_SOUND( i_sound_countdown ) SAFE_REMOVE_BLIP(battleBlip) CLEANUP_RAMPAGE_TANK(rampageTank) RAMPAGE_DISABLE_CONTROL_ACTIONS() STOP_FIRE_IN_RANGE(GET_ENTITY_COORDS(PLAYER_PED_ID()), 30.0) RC_START_CUTSCENE_MODE(<<0.0,0.0,0.0>>, TRUE, FALSE, TRUE, FALSE, FALSE) #IF IS_JAPANESE_BUILD FORCE_DELETE_RAMPAGE_PED_ARRAY(rampagePed) #ENDIF FORCE_VEHICLE_OCCUPANTS_NEAR_PED_FLEE(PLAYER_PED_ID(), 10.0) FLEE_RAMPAGE_CAR_ARRAY(rampageCar) FLEE_RAMPAGE_PED_ARRAY(rampagePed) SET_PLAYER_CONTROL(PLAYER_ID(), TRUE) IF IS_PED_RAGDOLL( PLAYER_PED_ID() ) GIVE_PLAYER_RAGDOLL_CONTROL(PLAYER_ID(), TRUE) ENDIF IF (rampageInfo.bPassed) DRAW_FROZEN_RAMPAGE_HUD() STOP_STREAM() PLAY_SOUND_FRONTEND(-1, "RAMPAGE_PASSED_MASTER") //MISSION_FLOW_PLAY_END_OF_MISSION_MUSIC(TRUE) ELSE DISABLE_ON_FOOT_FIRST_PERSON_VIEW_THIS_UPDATE() ENDIF IF NOT IS_STRING_NULL_OR_EMPTY(sAudioScene) IF IS_AUDIO_SCENE_ACTIVE(sAudioScene) STOP_AUDIO_SCENE(sAudioScene) CPRINTLN(DEBUG_RAMPAGE, "RAMPAGE_CLEANUP() - AUDIO SCENE STOPPED") sAudioScene = NULL ENDIF ENDIF IF IS_ENTITY_ALIVE( PLAYER_PED_ID() ) IF GET_CURRENT_PED_WEAPON(PLAYER_PED_ID(), currentWeapon) IF currentWeapon = rampageInfo.plyrWeapon[0] OR currentWeapon = rampageInfo.plyrWeapon[1] AND NOT IS_PED_RAGDOLL( PLAYER_PED_ID() ) AND NOT IS_PED_IN_ANY_VEHICLE( PLAYER_PED_ID() ) IF IS_PED_RUNNING( PLAYER_PED_ID() ) OR IS_PED_SPRINTING( PLAYER_PED_ID() ) bRunOutro = TRUE TASK_PLAY_ANIM( PLAYER_PED_ID(), "missrampageintrooutro", rampageInfo.sOutroRunAnim, SLOW_BLEND_IN, NORMAL_BLEND_OUT ) ELSE bRunOutro = FALSE TASK_PLAY_ANIM( PLAYER_PED_ID(), "missrampageintrooutro", rampageInfo.sOutroAnim, SLOW_BLEND_IN, NORMAL_BLEND_OUT ) ENDIF IF IS_PED_USING_ACTION_MODE(PLAYER_PED_ID()) SET_PED_USING_ACTION_MODE(PLAYER_PED_ID(), FALSE) ENDIF SET_PLAYER_CONTROL( PLAYER_ID(), FALSE, SPC_LEAVE_CAMERA_CONTROL_ON ) ELSE plyrGunObject = CREATE_FAKE_WEAPON_FOR_PLAYER(currentWeapon) IF IS_ENTITY_OK(plyrGunObject) IF IS_ENTITY_ATTACHED(plyrGunObject) DETACH_ENTITY(plyrGunObject) ENDIF ENDIF IF IS_PED_USING_ACTION_MODE(PLAYER_PED_ID()) SET_PED_USING_ACTION_MODE(PLAYER_PED_ID(), FALSE) ENDIF ENDIF ENDIF ENDIF SETUP_RAMPAGE_COMPLETE_SCALEFORM() isFormTimer = GET_GAME_TIMER() sFormState = SFR_OUTROWAIT BREAK CASE SFR_OUTROWAIT RAMPAGE_DISABLE_CONTROL_ACTIONS() IF IS_ENTITY_ALIVE( PLAYER_PED_ID() ) IF bRunOutro IF NOT IS_ENTITY_PLAYING_ANIM( PLAYER_PED_ID(), "missrampageintrooutro", rampageInfo.sOutroRunAnim ) SET_PLAYER_CONTROL( PLAYER_ID(), TRUE ) ELIF GET_ENTITY_ANIM_CURRENT_TIME( PLAYER_PED_ID(), "missrampageintrooutro", rampageInfo.sOutroRunAnim ) > rampageInfo.fOutroRunPhase IF GET_CURRENT_PED_WEAPON(PLAYER_PED_ID(), currentWeapon) plyrGunObject = CREATE_FAKE_WEAPON_FOR_PLAYER(currentWeapon) ENDIF IF IS_ENTITY_OK(plyrGunObject) IF IS_ENTITY_ATTACHED(plyrGunObject) DETACH_ENTITY(plyrGunObject) ENDIF ENDIF ENDIF ELSE IF NOT IS_ENTITY_PLAYING_ANIM( PLAYER_PED_ID(), "missrampageintrooutro", rampageInfo.sOutroAnim ) SET_PLAYER_CONTROL( PLAYER_ID(), TRUE ) ELIF GET_ENTITY_ANIM_CURRENT_TIME( PLAYER_PED_ID(), "missrampageintrooutro", rampageInfo.sOutroAnim ) > rampageInfo.fOutroPhase IF GET_CURRENT_PED_WEAPON(PLAYER_PED_ID(), currentWeapon) plyrGunObject = CREATE_FAKE_WEAPON_FOR_PLAYER(currentWeapon) ENDIF IF IS_ENTITY_OK(plyrGunObject) IF IS_ENTITY_ATTACHED(plyrGunObject) DETACH_ENTITY(plyrGunObject) ENDIF ENDIF ENDIF ENDIF ENDIF HIDE_HELP_TEXT_THIS_FRAME() IF (rampageInfo.bPassed = FALSE) sFormState = SFR_OUTRODONE_FAIL //DO_SCREEN_FADE_OUT(1000) isFormTimer = GET_GAME_TIMER() + 1500 ELIF (GET_GAME_TIMER() > (isFormTimer + DEFAULT_GOD_TEXT_TIME)) OR (IS_CUTSCENE_SKIP_BUTTON_PRESSED() AND (GET_GAME_TIMER() > isFormTimer + 2000)) //Set end screen to animate out ENDSCREEN_START_TRANSITION_OUT(esd) sFormState = SFR_OUTRO_ANIM_OUT isFormTimer = GET_GAME_TIMER() + 1500 ENDIF BREAK CASE SFR_OUTRODONE_FAIL RAMPAGE_DISABLE_CONTROL_ACTIONS() HIDE_HELP_TEXT_THIS_FRAME() DRAW_RECT(0.5, 0.5, 1.0, 1.0, 0, 0, 0, 0) IF (GET_GAME_TIMER() > isFormTimer) SAFE_DELETE_OBJECT(plyrGunObject) plyrGunObject = NULL //RC_END_CUTSCENE_MODE(TRUE, FALSE) SET_RAMPAGE_TO_FAIL_UPDATE_STATE() EXIT ENDIF BREAK //Wait for the pass screen to animate out CASE SFR_OUTRO_ANIM_OUT IF RENDER_ENDSCREEN( esd ) sFormState = SFR_OUTRODONE ENDIF BREAK CASE SFR_OUTRODONE RAMPAGE_DISABLE_CONTROL_ACTIONS() CPRINTLN(DEBUG_RAMPAGE, "*** REMOVING PLAYER WEAPONS, OUTRO DONE***") REMOVE_ALL_PED_WEAPONS(PLAYER_PED_ID()) HIDE_HELP_TEXT_THIS_FRAME() SAFE_RELEASE_OBJECT(plyrGunObject) // SAFE_DELETE_OBJECT(plyrGunObject) // plyrGunObject = NULL //RC_END_CUTSCENE_MODE(TRUE, FALSE) ENDSCREEN_SHUTDOWN( esd ) RAMPAGE_CLEANUP() EXIT ENDSWITCH IF (ENUM_TO_INT(sFormState) >= ENUM_TO_INT(SFR_OUTROSTART)) IF (rampageInfo.bPassed = FALSE) DISABLE_ON_FOOT_FIRST_PERSON_VIEW_THIS_UPDATE() ENDIF ENDIF // don't draw the scaleform if we're in fail state IF NOT IS_RAMPAGE_IN_FAIL_UPDATE_STATE() IF (ENUM_TO_INT(sFormState) >= ENUM_TO_INT(SFR_OUTROSTART)) IF (rampageInfo.bPassed) // DISABLE_FRONTEND_THIS_FRAME() RENDER_ENDSCREEN( esd ) // DRAW_SCALEFORM_MOVIE(sFormRampageStats, MISSION_PASSED_CENTER_X,MISSION_PASSED_CENTER_Y,MISSION_PASSED_SIZE_X,MISSION_PASSED_SIZE_Y,255,255,255,255) // DRAW_SCALEFORM_MOVIE(sFormRampagePassMsg, 0.5, 0.5, 1.0, 1.0, 100, 100, 100, 255 ) ENDIF ELIF (ENUM_TO_INT(sFormState) >= ENUM_TO_INT(SFR_INTROSTART)) IF (sFormRampage <> NULL) // DISABLE_FRONTEND_THIS_FRAME() //SET_SCRIPT_GFX_ALIGN(UI_ALIGN_LEFT, UI_ALIGN_TOP) DRAW_SCALEFORM_MOVIE_FULLSCREEN(sFormRampage, 255, 255, 255, sFormAlpha) //DRAW_SCALEFORM_MOVIE(sFormRampage, 0.5, 0.44, 1.0, 1.0, 255, 255, 255, sFormAlpha) //RESET_SCRIPT_GFX_ALIGN() ENDIF ENDIF ENDIF ENDPROC //---------------------- // UPDATE FUNCTIONS //---------------------- /// PURPOSE: /// This handle Z Skips /// PARAMS: /// iTargetStage - index of what stage we want to go to PROC DO_Z_SKIP(INT iTargetStage) BOOL bFadeIn = FALSE RC_START_Z_SKIP() DELETE_RAMPAGE_PED_ARRAY(rampagePed) DELETE_RAMPAGE_CAR_ARRAY(rampageCar) SET_RAMPAGE_FROM_STATIC_BLIP(rampageInfo.blipNameEnum) WAIT_FOR_CUTSCENE_TO_STOP() STOP_STREAM() SWITCH iTargetStage CASE 0 // intro sFormState = SFR_MOCAP stageProgress = SP_LOADING STOP_RAMPAGE_FX() // CLEAR_TIMECYCLE_MODIFIER() GET_NAME_OF_RAMPAGE_INTRO_CUTSCENE() IF IS_ENTITY_OK(PLAYER_PED_ID()) CLEAR_PED_TASKS(PLAYER_PED_ID()) SET_ENTITY_COORDS_GROUNDED(PLAYER_PED_ID(), GET_RAMPAGE_POSITION()) ENDIF BREAK CASE 1 sFormState = SFR_INTROSTART IF IS_ENTITY_OK(PLAYER_PED_ID()) CLEAR_PED_TASKS(PLAYER_PED_ID()) SET_ENTITY_COORDS_GROUNDED(PLAYER_PED_ID(), GET_RAMPAGE_POSITION()) ENDIF POST_INTRO_CUTSCENE_SETUP(TRUE) SETUP_INITIAL_PEDS() BREAK CASE 2 sFormState = SFR_OUTRODONE rampageInfo.bPassed = TRUE bFadeIn = TRUE BREAK ENDSWITCH RC_END_Z_SKIP(TRUE, bFadeIn) ENDPROC /// PURPOSE: /// This handles the forced deletion of objects we don't want /// Will be able to get rid of this once i can convince art to remove some stuff PROC UPDATE_FORCED_OBJECT_DELETE() OBJECT_INDEX obj SWITCH (rampageInfo.blipNameEnum) // CASE STATIC_BLIP_MINIGAME_RAMPAGE2 // // // this removes the fences so we can get in // obj = GET_CLOSEST_OBJECT_OF_TYPE(<<1214.3939,-431.5607,66.3090>>, 4.0, PROP_FNCLINK_02GATE4) // IF DOES_ENTITY_EXIST(obj) // SET_ENTITY_COORDS(obj, <<0, 0, -20>>) // SET_OBJECT_AS_NO_LONGER_NEEDED(obj) // obj = NULL // ENDIF // BREAK CASE STATIC_BLIP_MINIGAME_RAMPAGE3 // this removes the fences so we can get in obj = GET_CLOSEST_OBJECT_OF_TYPE(<<500.9570,-1805.2900,27.5551>>, 4.0, PROP_FNCLINK_02GATE4) IF DOES_ENTITY_EXIST(obj) SET_ENTITY_COORDS(obj, <<0, 0, -20>>) SET_OBJECT_AS_NO_LONGER_NEEDED(obj) obj = NULL ENDIF obj = GET_CLOSEST_OBJECT_OF_TYPE(<<511.2028,-1798.3715,27.4122>>, 4.0, PROP_FNCRES_06GATER) IF DOES_ENTITY_EXIST(obj) SET_ENTITY_COORDS(obj, <<0, 0, -20>>) SET_OBJECT_AS_NO_LONGER_NEEDED(obj) obj = NULL ENDIF obj = GET_CLOSEST_OBJECT_OF_TYPE(<<469.1499,-1805.6255,28.4358>>, 4.0, PROP_FNCLINK_06GATE2) IF DOES_ENTITY_EXIST(obj) SET_ENTITY_COORDS(obj, <<0, 0, -20>>) SET_OBJECT_AS_NO_LONGER_NEEDED(obj) obj = NULL ENDIF BREAK CASE STATIC_BLIP_MINIGAME_RAMPAGE4 // this removes the fences so we can get in obj = GET_CLOSEST_OBJECT_OF_TYPE(<<-155.46, -1665.80, 32.17>>, 4.0, prop_fncsec_03c) IF DOES_ENTITY_EXIST(obj) SET_ENTITY_COORDS(obj, <<0, 0, -20>>) SET_OBJECT_AS_NO_LONGER_NEEDED(obj) obj = NULL ENDIF obj = GET_CLOSEST_OBJECT_OF_TYPE(<<-133.76, -1617.43, 32.00>>, 4.0, prop_fncsec_03c) IF DOES_ENTITY_EXIST(obj) SET_ENTITY_COORDS(obj, <<0, 0, -20>>) SET_OBJECT_AS_NO_LONGER_NEEDED(obj) obj = NULL ENDIF BREAK ENDSWITCH ENDPROC /// PURPOSE: /// This handles S, F, J and Z skips PROC UPDATE_RAMPAGE_FLOW_DEBUG_KEYS() #IF IS_DEBUG_BUILD INT iDbgStageJump IF (bDebugShowMissionVersion) SET_TEXT_SCALE(0.25, 0.25) DISPLAY_TEXT_WITH_NUMBER(0, 0, "NUMBER", RAMPAGE_VERSION) ENDIF //IF NOT IS_RAMPAGE_SCALEFORM_RUNNING() IF IS_KEYBOARD_KEY_JUST_PRESSED(KEY_S) OR IS_KEYBOARD_KEY_JUST_PRESSED(KEY_J) FORCE_VEHICLE_OCCUPANTS_NEAR_PED_FLEE(PLAYER_PED_ID(), 15.0) WAIT_FOR_CUTSCENE_TO_STOP() sFormState = SFR_OUTROSTART //CLEAR_TIMECYCLE_MODIFIER() rampageInfo.bPassed = TRUE ELIF IS_KEYBOARD_KEY_JUST_PRESSED(KEY_F) FORCE_VEHICLE_OCCUPANTS_NEAR_PED_FLEE(PLAYER_PED_ID(), 15.0) WAIT_FOR_CUTSCENE_TO_STOP() sFormState = SFR_OUTROSTART rampageInfo.bPassed = FALSE ENDIF //ENDIF IF LAUNCH_MISSION_STAGE_MENU(sSkipMenu, iDbgStageJump) DO_Z_SKIP(iDbgStageJump) ENDIF #ENDIF ENDPROC /// PURPOSE: /// This updates the rampage hud and shuts down the rampage if time runs out PROC UPDATE_RAMPAGE_HUD() INT iValue = rampageStats.iPedDeadCount INT time = rampageInfo.iTimeLimit - (GET_GAME_TIMER() - rampageStats.iStartTime ) IF (bInfiniteTime = FALSE) IF (time <= 0) time = 0 sFormState = SFR_OUTROSTART IF (iValue >= rampageInfo.iTargetAmount) rampageInfo.bPassed = TRUE ENDIF ENDIF ENDIF //@RJP B*1267626 - stop ticking when time less than 10 seconds // IF time > 10000 // IF (GET_GAME_TIMER() > iNextClockTickSoundTime) // iNextClockTickSoundTime = GET_GAME_TIMER() + 1000 // PLAY_SOUND_FRONTEND(-1, "RAMPAGE_TIMER_COUNTDOWN_MASTER") // //CPRINTLN(DEBUG_RAMPAGE, " SOUND PLAYED - RAMPAGE_TIMER_COUNTDOWN_MASTER") // ENDIF // ENDIF IF NOT bTimerSoundStarted bTimerSoundStarted = TRUE IF (rampageInfo.blipNameEnum = STATIC_BLIP_MINIGAME_RAMPAGE5) // B*1843735 - Swap sound for military rampage PLAY_SOUND_FRONTEND(i_sound_countdown, "RAMPAGE_TIMER_COUNTDOWN_LOOP_3_MIN_MASTER") ELSE PLAY_SOUND_FRONTEND(i_sound_countdown, "RAMPAGE_TIMER_COUNTDOWN_LOOP_MASTER") ENDIF ENDIF IF (time <= 0) CPRINTLN(DEBUG_RAMPAGE, "SOUND PLAYED - TIMER STOP") PLAY_SOUND_FRONTEND(-1, "TIMER_STOP", "HUD_MINI_GAME_SOUNDSET") ELIF (time < iNextBeepTime) CPRINTLN(DEBUG_RAMPAGE, "SOUND PLAYED - 10_SEC_WARNING - ", TO_FLOAT(iNextBeepTime) / 1000.0, " SECONDS") iNextBeepTime -= 1000 PLAY_SOUND_FRONTEND(-1, "10_SEC_WARNING", "HUD_MINI_GAME_SOUNDSET") ENDIF DRAW_RAMPAGE_HUD(iValue, "TR_HKILL", time, "TR_HTIME", 0, FALSE, -1, medalHudColor[iCurrentMedalIndex]) ENDPROC PROC UPDATE_RAMPAGE1_TIMELINE() INT ind SWITCH (iTimeLineEventIndex) CASE 0 IF GET_GAME_TIMER() > rampageStats.iStartTime + 2000 iTimeLineEventIndex ++ ENDIF BREAK CASE 1 IF GET_FREE_RAMPAGE_CAR_INDEX( ind ) IF CREATE_RAMPAGE_CAR( rampageCar[ind], rampageInfo.carModels[1], <<978.3540, 3616.1819, 31.6477>>, 356.7491, TRUE, 1) SET_RAMPAGE_CAR_DEPLOY(rampageCar[ind], TRUE, 60) iTimeLineEventIndex ++ ENDIF ENDIF BREAK ENDSWITCH ENDPROC PROC UPDATE_RAMPAGE2_TIMELINE() INT ind SWITCH (iTimeLineEventIndex) CASE 0 IF IS_ENTITY_ALIVE(rampageScriptArgs.pedID[0]) IF VDIST2( GET_ENTITY_COORDS(PLAYER_PED_ID()), GET_ENTITY_COORDS(rampageScriptArgs.pedID[0]) ) > 144 GIVE_WEAPON_TO_PED( rampageScriptArgs.pedID[0], rampageInfo.enemyWeapon[0], INFINITE_AMMO, TRUE ) SET_PED_COMBAT_ATTRIBUTES(rampageScriptArgs.pedID[0], CA_ALWAYS_FLEE, FALSE) SET_PED_COMBAT_ATTRIBUTES(rampageScriptArgs.pedID[0], CA_AGGRESSIVE, TRUE) SET_PED_COMBAT_ATTRIBUTES(rampageScriptArgs.pedID[0], CA_CAN_CHARGE, TRUE) SET_PED_COMBAT_MOVEMENT(rampageScriptArgs.pedID[0], CM_WILLADVANCE ) TASK_COMBAT_PED( rampageScriptArgs.pedID[0], PLAYER_PED_ID() ) ENDIF ELSE iTimeLineEventIndex ++ ENDIF BREAK CASE 1 IF rampageStats.iPedDeadCount > 15 iTimeLineEventIndex ++ ENDIF BREAK CASE 2 IF GET_FREE_RAMPAGE_CAR_INDEX( ind ) IF CREATE_RAMPAGE_CAR( rampageCar[ind], rampageInfo.carModels[0], <<1223.0145, -527.4169, 65.9266>>, 53.7151, TRUE, 1) SET_RAMPAGE_CAR_RAM( rampageCar[ind], 25 ) iTimeLineEventIndex ++ ENDIF ENDIF BREAK CASE 3 IF rampageStats.iPedDeadCount > 25 iTimeLineEventIndex ++ ENDIF BREAK CASE 4 IF GET_FREE_RAMPAGE_CAR_INDEX( ind ) IF CREATE_RAMPAGE_CAR( rampageCar[ind], rampageInfo.carModels[0], <<1171.5835, -365.4520, 67.1268>>, 252.1326, TRUE, 1) SET_RAMPAGE_CAR_RAM( rampageCar[ind], 25 ) iTimeLineEventIndex ++ ENDIF ENDIF BREAK ENDSWITCH ENDPROC FUNC BOOL GET_RAMPAGE_MOLOTOV_THROWER_SPAWN_POINT(RAMPAGE_ALLEYSPAWNER &rs, INT &spawnInd) IF (iAlivePedCounter >= iMaxActivePeds) RETURN FALSE ENDIF IF (rs.iFrameCounter % 4 <> 0) RETURN FALSE ENDIF spawnInd = GET_RANDOM_INT_IN_RANGE(0, rs.iMaxActiveSpawnPoints) IF VDIST2(GET_ENTITY_COORDS(PLAYER_PED_ID()), rs.spawnPoint[spawnInd].vPosition) > 3600 RETURN FALSE ENDIF // check that we aren't spawning on top of a ped IF (bUseIsAreaOccupied) IF IS_ANY_PED_IN_SPHERE(rs.spawnPoint[spawnInd].vPosition, 1.0) RETURN FALSE ENDIF ELSE IF IS_ANY_PED_NEAR_POINT(rs.spawnPoint[spawnInd].vPosition, 1.0) RETURN FALSE ENDIF ENDIF RETURN TRUE ENDFUNC PROC UPDATE_RAMPAGE3_TIMELINE() INT molotovPedInd, spawnInd SWITCH (iTimeLineEventIndex) CASE 0 iMolotovRespawnTimer = GET_GAME_TIMER() + GET_RANDOM_INT_IN_RANGE( 6000, 12000) iTimeLineEventIndex ++ BREAK CASE 1 IF GET_GAME_TIMER() > iMolotovRespawnTimer iTimeLineEventIndex ++ ENDIF BREAK CASE 2 IF GET_FREE_RAMPAGE_PED_INDEX( rampagePed, molotovPedInd ) IF GET_RAMPAGE_MOLOTOV_THROWER_SPAWN_POINT( rampageAlleySpawner, spawnInd ) IF CREATE_RAMPAGER_PED_AT_SPAWN_POINT( rampagePed[molotovPedInd], rampageAlleySpawner.spawnPoint[spawnInd], TRUE, TRUE ) rampagePed[molotovPedInd].bMolotovThrower = TRUE #IF IS_DEBUG_BUILD SET_PED_DEBUG_NAME( rampagePed[molotovPedInd].pedID, "RampMolotov", rampagePed[molotovPedInd].iIndex ) #ENDIF iTimeLineEventIndex = 0 ENDIF ENDIF ENDIF BREAK ENDSWITCH ENDPROC PROC UPDATE_RAMPAGE4_TIMELINE() INT rocketPedInd // events based on numbers of people killed SWITCH (iTimeLineEventIndex) CASE 0 IF IS_ENTITY_IN_RANGE_COORDS(PLAYER_PED_ID(), <<-155.1995, -1655.9540, 31.8369>>, 7.0) iTimeLineEventIndex ++ ENDIF BREAK CASE 1 IF GET_FREE_RAMPAGE_PED_INDEX( rampagePed, rocketPedInd ) IF CREATE_RAMPAGER_PED_AT_POSITION( rampagePed[rocketPedInd], <<-148.6551, -1631.6625, 32.0646>>, 237.4733 ) iTimeLineEventIndex ++ CPRINTLN( DEBUG_RAMPAGE, "UPDATE_RAMPAGE4_TIMELINE: CREATE ROCKET ENEMY" ) GIVE_WEAPON_TO_PED( rampagePed[rocketPedInd].pedID, WEAPONTYPE_RPG, 1, TRUE ) SET_PED_ACCURACY( rampagePed[rocketPedInd].pedID, 5 ) SET_PED_DROPS_WEAPONS_WHEN_DEAD( rampagePed[rocketPedInd].pedID, TRUE ) SET_PED_SPHERE_DEFENSIVE_AREA( rampagePed[rocketPedInd].pedID, <<-140.7438, -1637.3519, 31.3864>>, 5, TRUE ) ENDIF ENDIF BREAK CASE 2 IF IS_ENTITY_IN_RANGE_COORDS(PLAYER_PED_ID(), <<-132.3154, -1626.2484, 31.1810>>, 7.0) iTimeLineEventIndex ++ ENDIF BREAK CASE 3 IF GET_FREE_RAMPAGE_PED_INDEX( rampagePed, rocketPedInd ) IF CREATE_RAMPAGER_PED_AT_POSITION( rampagePed[rocketPedInd], <<-98.7502, -1607.0056, 30.8521>>, 45.6334 ) iTimeLineEventIndex ++ CPRINTLN( DEBUG_RAMPAGE, "UPDATE_RAMPAGE4_TIMELINE: CREATE ROCKET ENEMY" ) GIVE_WEAPON_TO_PED( rampagePed[rocketPedInd].pedID, WEAPONTYPE_RPG, 1, TRUE ) SET_PED_ACCURACY( rampagePed[rocketPedInd].pedID, 5 ) SET_PED_DROPS_WEAPONS_WHEN_DEAD( rampagePed[rocketPedInd].pedID, TRUE ) SET_PED_SPHERE_DEFENSIVE_AREA( rampagePed[rocketPedInd].pedID, <<-109.1352, -1599.4410, 30.6352>>, 5, TRUE ) ENDIF ENDIF BREAK CASE 4 IF IS_ENTITY_IN_RANGE_COORDS(PLAYER_PED_ID(), <<-110.1830, -1600.6589, 30.6615>>, 9.0) iTimeLineEventIndex ++ ENDIF BREAK CASE 5 IF GET_FREE_RAMPAGE_PED_INDEX( rampagePed, rocketPedInd ) IF CREATE_RAMPAGER_PED_AT_POSITION( rampagePed[rocketPedInd], <<-98.9138, -1571.4451, 31.2628>>, 228.6146 ) iTimeLineEventIndex ++ CPRINTLN( DEBUG_RAMPAGE, "UPDATE_RAMPAGE4_TIMELINE: CREATE ROCKET ENEMY" ) GIVE_WEAPON_TO_PED( rampagePed[rocketPedInd].pedID, WEAPONTYPE_RPG, 1, TRUE ) SET_PED_ACCURACY( rampagePed[rocketPedInd].pedID, 5 ) SET_PED_DROPS_WEAPONS_WHEN_DEAD( rampagePed[rocketPedInd].pedID, TRUE ) SET_PED_SPHERE_DEFENSIVE_AREA( rampagePed[rocketPedInd].pedID, <<-91.4304, -1578.0559, 30.5151>>, 5, TRUE ) ENDIF ENDIF BREAK CASE 6 IF (rampageStats.iPedDeadCount > 20) OR IS_ENTITY_IN_RANGE_COORDS(PLAYER_PED_ID(), <<-97.324738,-1585.606201,30.352205>>, 13.500000) iTimeLineEventIndex ++ rampageCarSpawner.bIsActive = TRUE rampageCarSpawner.bUseSpawnPoints = TRUE rampageCarSpawner.iMaxActiveCars = 2 rampageCarSpawner.iMinSpawnTime = 8000 rampageCarSpawner.iMaxSpawnTime = 15000 SET_RAMPAGE_SPAWN_POINT(rampageCarSpawner.vSpawnPoints[0], <<-168.9869, -1697.6454, 30.9580>>, 38.6579) SET_RAMPAGE_SPAWN_POINT(rampageCarSpawner.vSpawnPoints[1], <<-186.1806, -1634.2001, 32.3377>>, 179.0611) rampageAlleySpawner.fAlleyDiffAdjust = -0.5 CPRINTLN(DEBUG_RAMPAGE, "NEXT RAMPAGE EVENT", iTimeLineEventIndex) ENDIF BREAK ENDSWITCH ENDPROC PROC UPDATE_RAMPAGE5_TIMELINE() INT ind VECTOR tmp, pos, ResultLinkDir IF IS_ENTITY_ALIVE(rampageTank.vehicleID) rampageCarSpawner.iSpawnPointsUsed = 2 ELSE rampageCarSpawner.iSpawnPointsUsed = 3 ENDIF // generate tank in miltary base if player tries to run in there IF IS_COORD_IN_SPECIFIED_AREA(GET_ENTITY_COORDS(PLAYER_PED_ID()), AC_MILITARY_BASE) OR IS_PLAYER_JUMPING_GATES() OR IS_PLAYER_IN_UNDERGROUND_TUNNEL() OR IS_ENTITY_IN_RANGE_COORDS(PLAYER_PED_ID(), <<-1577.24854, 2779.56274, 16.07899>>, 60.0) rampageCloudSpawner.bIsActive = TRUE iMaxActivePeds = MAX_ACTIVE_PEDS IF NOT IS_ENTITY_ALIVE(rampageTank.vehicleID) tmp = GET_OFFSET_FROM_COORD_AND_HEADING_IN_WORLD_COORDS(GET_ENTITY_COORDS(PLAYER_PED_ID()), GET_RANDOM_FLOAT_IN_RANGE(0, 360), <<0, GET_RANDOM_FLOAT_IN_RANGE(30.0, 100.0), 0>>) IF GENERATE_VEHICLE_CREATION_POS_FROM_PATHS(tmp, pos, ResultLinkDir) CREATE_RAMPAGE_TANK(rampageTank, pos) CPRINTLN(DEBUG_RAMPAGE, "TANK! TANK! TANK!") EXIT ENDIF ENDIF ELSE rampageCloudSpawner.bIsActive = FALSE ENDIF // events based on numbers of people killed SWITCH (iTimeLineEventIndex) CASE 0 IF (rampageStats.iPedDeadCount > 3) IF GET_FREE_RAMPAGE_CAR_INDEX(ind) IF CREATE_RAMPAGE_CAR(rampageCar[ind], rampageInfo.carModels[0], <<-1111.0688, 2673.1702, 17.5640>>, 134.8095, TRUE) SET_RAMPAGE_CAR_DEPLOY(rampageCar[ind]) iTimeLineEventIndex ++ CPRINTLN(DEBUG_RAMPAGE, "NEXT RAMPAGE EVENT", iTimeLineEventIndex) ENDIF ENDIF ENDIF BREAK CASE 1 IF (rampageStats.iPedDeadCount > 10) IF GET_FREE_RAMPAGE_CAR_INDEX(ind) IF CREATE_RAMPAGE_CAR(rampageCar[ind], rampageInfo.carModels[0], <<-1536.2335, 2740.8357, 16.6437>>, 233.2830, TRUE) SET_RAMPAGE_CAR_DEPLOY(rampageCar[ind]) iTimeLineEventIndex ++ CPRINTLN(DEBUG_RAMPAGE, "NEXT RAMPAGE EVENT", iTimeLineEventIndex) ENDIF ENDIF ENDIF BREAK CASE 2 IF (rampageStats.iPedDeadCount >= 15) IF CREATE_RAMPAGE_TANK(rampageTank, <<-1079.6121, 2690.5684, 19.3431>>, 132.9435) //<<-1544.3688, 2750.1809, 16.7780>>, 233.2830) CPRINTLN(DEBUG_RAMPAGE, "TANK! TANK! TANK!") //SET_RAMPAGE_CAR_DEPLOY_TO_COORDINATES(rampageTank, <<-1335.2, 2565.4, 17.7>>) iTimeLineEventIndex ++ CPRINTLN(DEBUG_RAMPAGE, "NEXT RAMPAGE EVENT", iTimeLineEventIndex) iMaxActivePeds = MAX_ACTIVE_PEDS / 2 ENDIF ENDIF BREAK CASE 3 IF IS_ENTITY_ALIVE(rampageTank.vehicleID) iMaxActivePeds = MAX_ACTIVE_PEDS / 2 ELSE iMaxActivePeds = MAX_ACTIVE_PEDS //@RJP don't create a new rampage tank if one exists IF (rampageStats.iPedDeadCount >= 35) IF CREATE_RAMPAGE_TANK(rampageTank, <<-1353.2513, 2319.6099, 38.6243>>, 1.1871) //<<-1544.3688, 2750.1809, 16.7780>>, 233.2830) CPRINTLN(DEBUG_RAMPAGE, "TANK! TANK! TANK!") iTimeLineEventIndex ++ CPRINTLN(DEBUG_RAMPAGE, "NEXT RAMPAGE EVENT", iTimeLineEventIndex) iMaxActivePeds = MAX_ACTIVE_PEDS / 2 ENDIF ENDIF ENDIF BREAK CASE 4 IF IS_ENTITY_ALIVE(rampageTank.vehicleID) iMaxActivePeds = MAX_ACTIVE_PEDS / 2 ELSE iMaxActivePeds = MAX_ACTIVE_PEDS ENDIF BREAK ENDSWITCH ENDPROC PROC UPDATE_RAMPAGE_TIMELINE() #IF IS_DEBUG_BUILD IF (bPauseRampageSpawning) EXIT ENDIF #ENDIF SWITCH (rampageInfo.blipNameEnum) CASE STATIC_BLIP_MINIGAME_RAMPAGE1 UPDATE_RAMPAGE1_TIMELINE() BREAK CASE STATIC_BLIP_MINIGAME_RAMPAGE2 UPDATE_RAMPAGE2_TIMELINE() BREAK CASE STATIC_BLIP_MINIGAME_RAMPAGE3 UPDATE_RAMPAGE3_TIMELINE() BREAK CASE STATIC_BLIP_MINIGAME_RAMPAGE4 UPDATE_RAMPAGE4_TIMELINE() BREAK CASE STATIC_BLIP_MINIGAME_RAMPAGE5 UPDATE_RAMPAGE5_TIMELINE() BREAK ENDSWITCH ENDPROC #IF IS_DEBUG_BUILD /// PURPOSE: /// This updates our RAG widgets PROC UPDATE_RAMPAGE_DEBUG_WIDGETS() INT i FLOAT sx, sy VECTOR tmp SET_PLAYER_WEAPON_DAMAGE_MODIFIER(PLAYER_ID(), rampageCombatParams.fPlayerWeaponDamageModifier) SET_PLAYER_WEAPON_DEFENSE_MODIFIER(PLAYER_ID(), rampageCombatParams.fPlayerWeaponDefenseModifier) if (bDebugDrawSpot) DRAW_DEBUG_CIRCLE(vDebugDrawSpot, 1.0) DRAW_DEBUG_SPHERE(vDebugDrawSpot, 0.125) ENDIF i = 0 REPEAT COUNT_OF (coverCar) i IF IS_ENTITY_ALIVE(coverCar[i]) tmp = GET_ENTITY_COORDS(coverCar[i]) DRAW_DEBUG_LINE(tmp, tmp + <<0, 0, 10>>, 255, 128, 0, 255) ENDIF ENDREPEAT IF (bInstaPassChallenges) i = 0 REPEAT COUNT_OF(rampageChallenge) i rampageChallenge[i].iRequiredAmount = 0 ENDREPEAT bInstaPassChallenges = FALSE ENDIF iRampageSpawnStateDebug = ENUM_TO_INT(rampageSpawnState) IF (bDeletePedsAndCars) or (bDeletePeds) DELETE_RAMPAGE_PED_ARRAY(rampagePed) bDeletePeds = FALSE ENDIF IF (bDebugDeletePedsForJapan) FORCE_DELETE_RAMPAGE_PED_ARRAY(rampagePed) bDebugDeletePedsForJapan = FALSE ENDIF IF (bDeletePedsAndCars) or (bDeleteCars) DELETE_RAMPAGE_CAR_ARRAY(rampageCar) DELETE_RAMPAGE_TANK(rampageTank) bDeleteCars = FALSE ENDIF bDeletePedsAndCars = FALSE IF (bCleanupPedsAndCars) or (bCleanupPeds) CLEANUP_RAMPAGE_PED_ARRAY(rampagePed) bCleanupPeds = FALSE ENDIF IF (bCleanupPedsAndCars) or (bCleanupCars) CLEANUP_RAMPAGE_CAR_ARRAY(rampageCar) CLEANUP_RAMPAGE_TANK(rampageTank) bCleanupCars = FALSE ENDIF bCleanupPedsAndCars = FALSE IF (bCreateTestVehicle) IF GET_FREE_RAMPAGE_CAR_INDEX(i) IF CREATE_RAMPAGE_CAR(rampageCar[i], GET_RANDOM_RAMPAGE_CAR_MODEL(), rampageCarSpawner.vSpawnPoints[iTestVehicleSpawnPointIndex].vPosition, rampageCarSpawner.vSpawnPoints[iTestVehicleSpawnPointIndex].fHeading) SET_RAMPAGE_CAR_DEPLOY(rampageCar[i], TRUE) bCreateTestVehicle = FALSE ENDIF ENDIF ENDIF IF (bCreateTestTank) DELETE_RAMPAGE_TANK(rampageTank) IF CREATE_RAMPAGE_TANK(rampageTank, rampageCarSpawner.vSpawnPoints[iTestVehicleSpawnPointIndex].vPosition, rampageCarSpawner.vSpawnPoints[iTestVehicleSpawnPointIndex].fHeading) bCreateTestTank = FALSE ENDIF ENDIF IF (bInstantPass) rampageStats.iPedDeadCount = rampageInfo.iTargetAmount bInstantPass = FALSE ENDIF IF (bInstantFail) rampageStats.iStartTime = (GET_GAME_TIMER() - rampageInfo.iTimeLimit) bInstantFail = FALSE ENDIF IF NOT IS_VECTOR_ZERO(vBattleCenter) DRAW_DEBUG_CIRCLE(vBattleCenter, fBattleRadius) DRAW_DEBUG_SPHERE(vBattleCenter, 0.5) ENDIF // handle spawn point checker IF (bCheckSpawnPosition) bIsPointOkay = TRUE IF (bSetPlayerPosAsCheckPoint) vCheckSpawnPoint = GET_ENTITY_COORDS(PLAYER_PED_ID()) ENDIF i = 0 REPEAT iMaxActiveNoSpawnAreas i IF IS_POINT_IN_ANGLED_AREA(vCheckSpawnPoint, noSpawnArea[i].vPosition[0], noSpawnArea[i].vPosition[1], noSpawnArea[i].fWidth) bIsPointOkay = FALSE i = 99999 ENDIF ENDREPEAT bCheckSpawnPosition = FALSE ENDIF // no spawn debug i = 0 REPEAT COUNT_OF(noSpawnArea) i IF (noSpawnArea[i].bRecalculate) SETUP_RAMPAGE_AREA(noSpawnArea[i], noSpawnArea[i].vPosition[0], noSpawnArea[i].vPosition[1], noSpawnArea[i].fWidth) ENDIF IF (bDebugShowTTY) IF (noSpawnArea[i].bShowDebug) DRAW_DEBUG_AREA(noSpawnArea[i].vPosition[0], noSpawnArea[i].vPosition[1], noSpawnArea[i].fWidth, 255, 0, 0, 255) ENDIF ENDIF ENDREPEAT // fortress debug i = 0 REPEAT COUNT_OF(rampageFort) i IF (rampageFort[i].bRecalculate) SETUP_RAMPAGE_FORTRESS(rampageFort[i], rampageFort[i].defenseArea.vPosition[0], rampageFort[i].defenseArea.vPosition[1], rampageFort[i].defenseArea.fWidth, rampageFort[i].bIsActive) SETUP_RAMPAGE_AREA(rampageFort[i].spawnArea, rampageFort[i].spawnArea.vPosition[0], rampageFort[i].spawnArea.vPosition[1], rampageFort[i].spawnArea.fWidth) rampageFort[i].bRecalculate = FALSE ENDIF tmp = INTERPOLATE_VECTOR(rampageFort[i].spawnArea.vPosition[0], rampageFort[i].spawnArea.vPosition[1], 0.5) IF (rampageFort[i].bGenerateTestSpawnPoint) IF GENERATE_FORTRESS_SPAWN_POINT(rampageFort[i], rampageFort[i].vTestSpawnPoint) rampageFort[i].bGenerateTestSpawnPoint = FALSE ENDIF ENDIF IF (rampageFort[i].bShowDebugTestSpawnPoint) DRAW_DEBUG_LINE(rampageFort[i].vTestSpawnPoint, GET_ENTITY_COORDS(PLAYER_PED_ID())) DRAW_DEBUG_SPHERE(rampageFort[i].vTestSpawnPoint, 0.5) ENDIF IF (rampageFort[i].bIsActive) DRAW_DEBUG_LINE(tmp - <<0, 0, 20>>, tmp + <<0, 0, 40>>) DRAW_DEBUG_RAMPAGE_FORTRESS(rampageFort[i]) ENDIF IF (bDebugShowTTY) IF GET_SCREEN_COORD_FROM_WORLD_COORD(tmp, sx, sy) SET_TEXT_SCALE(2.0, 2.0) DISPLAY_TEXT_WITH_NUMBER(sx, sy, "NUMBER", i) ENDIF IF (rampageFort[i].bIsActive) OR (rampageFort[i].bShowDebug) DRAW_DEBUG_RAMPAGE_FORTRESS(rampageFort[i]) ENDIF ENDIF ENDREPEAT IF (bShowScenarioBlockArea) IF NOT IS_VECTOR_ZERO(rampageInfo.vScenarioBlockCenter) DRAW_DEBUG_CIRCLE(rampageInfo.vScenarioBlockCenter, rampageInfo.fScenarioBlockRadius) ENDIF ENDIF ENDPROC #ENDIF /// PURPOSE: /// This updates the entire rampage PROC UPDATE_RAMPAGE_FAIL_STATE() RAMPAGE_DISABLE_CONTROL_ACTIONS() SWITCH (sFailState) CASE SP_LOADING // not actually a loading state this does nothing BREAK CASE SP_SETUP CPRINTLN(DEBUG_RAMPAGE, "Entering Failure State") CLEAR_PRINTS() CLEAR_HELP() STOP_RAMPAGE_FX() // CLEAR_TIMECYCLE_MODIFIER() // Remove all blips here IF (rampageStats.iPedDeadCount < rampageInfo.iTargetAmount) CPRINTLN(DEBUG_RAMPAGE, "Supposed to be setting failure reason here...") Random_Character_Failed_With_Reason("TR_FAIL", TRUE) ELSE CPRINTLN(DEBUG_RAMPAGE, "No Fail Reason...") Random_Character_Failed() ENDIF sFailState = SP_RUNNING BREAK CASE SP_RUNNING CPRINTLN(DEBUG_RAMPAGE, "Running Failure State") IF GET_MISSION_FLOW_SAFE_TO_CLEANUP() REMOVE_DECALS_IN_RANGE(GET_RAMPAGE_POSITION(), 500.0) CPRINTLN(DEBUG_RAMPAGE, "*** REMOVING PLAYER WEAPONS, CLEAN UP***") REMOVE_ALL_PED_WEAPONS(PLAYER_PED_ID()) CPRINTLN(DEBUG_RAMPAGE, "Rampage Cleanup") RAMPAGE_CLEANUP() ENDIF BREAK ENDSWITCH ENDPROC /// PURPOSE: /// This updates the entire rampage PROC UPDATE_RAMPAGE() iFrameCounter ++ iGameTimer = GET_GAME_TIMER() //CPRINTLN(DEBUG_RAMPAGE, "---- RAMPAGE START FRAME: ", iFrameCounter, " ---- GAME TIMER:", iGameTimer, " ----") IF (iFrameCounter % 10 = 0) UPDATE_FORCED_OBJECT_DELETE() ENDIF // we now need to do this every frame NO_AMBIENT_MALARKY_THIS_FRAME() SET_ALL_NEUTRAL_RANDOM_PEDS_FLEE_THIS_FRAME(PLAYER_ID()) SET_ALL_RANDOM_PEDS_FLEE_THIS_FRAME(PLAYER_ID()) IF IS_RAMPAGE_IN_FAIL_UPDATE_STATE() UPDATE_RAMPAGE_FAIL_STATE() ELSE #IF IS_DEBUG_BUILD UPDATE_RAMPAGE_FLOW_DEBUG_KEYS() UPDATE_RAMPAGE_DEBUG_WIDGETS() #ENDIF UPDATE_RAMPAGE_SCALEFORM() ENDIF // reset wanted rating IF (GET_PLAYER_WANTED_LEVEL(PLAYER_ID()) > 0) SET_PLAYER_WANTED_LEVEL(PLAYER_ID(), 0) SET_PLAYER_WANTED_LEVEL_NOW(PLAYER_ID()) ENDIF IF (sFormState = SFR_RAMPAGEON) PROCESS_RAMPAGE_DAMAGE_EVENT_QUEUE() PROCESS_ALL_PED_SCANNER_VEHICLE_EXPLOSION_CHECKS() CREATE_EXLOSIVE_PROPS() UPDATE_RAMPAGE_HUD() UPDATE_RAMPAGE_PEDS(rampagePed) UPDATE_RAMPAGE_CARS() UPDATE_RAMPAGE_TANK(rampageTank) UPDATE_COVER_CARS() UPDATE_RAMPAGE_TIMELINE() iAlivePedCounter = GET_ALIVE_RAMPAGE_PED_COUNT(rampagePed) iAliveCarCounter = GET_ALIVE_RAMPAGE_CAR_COUNT() IF UPDATE_RAMPAGE_SPAWN_BLOCKER() IF iGameTimer > (rampageStats.iStartTime + iInitialCarSpawnDelay) UPDATE_RAMPAGE_CAR_SPAWNER(rampageCarSpawner) ENDIF IF iGameTimer > (rampageStats.iStartTime + iInitialSpawnDelay) UPDATE_RAMPAGE_CLOUD_SPAWNER(rampageCloudSpawner) UPDATE_RAMPAGE_CLOUD_SPAWNER(rampageBackupCloudSpawner) UPDATE_RAMPAGE_FORTRESS_SPAWNER(rampageFortressSpawner) UPDATE_RAMPAGE_ALLEY_SPAWNER(rampageAlleySpawner) ENDIF ENDIF // here we blip the rampage point incase the player fucks off from the area - also turn on emergency spawner IF NOT DOES_BLIP_EXIST(battleBlip) IF (GET_DISTANCE_BETWEEN_ENTITY_AND_COORD(PLAYER_PED_ID(), vBattleCenter, FALSE) > fBattleRadius) bInBattleArea = FALSE rampageBackupCloudSpawner.bIsActive = TRUE battleBlip = ADD_BLIP_FOR_COORD(vBattleCenter) IF DOES_BLIP_EXIST(battleBlip) SET_BLIP_AS_FRIENDLY(battleBlip, FALSE) ENDIF ENDIF ELSE IF (GET_DISTANCE_BETWEEN_ENTITY_AND_COORD(PLAYER_PED_ID(), vBattleCenter, FALSE) < fBattleRadius - 10) rampageBackupCloudSpawner.bIsActive = FALSE bInBattleArea = TRUE SAFE_REMOVE_BLIP(battleBlip) battleBlip = NULL ENDIF ENDIF IF (rampageStats.iLastKillTime > 0) IF (iGameTimer > (rampageStats.iLastKillTime + CHAIN_TIMER)) IF (rampageStats.iChain > 1) CPRINTLN(DEBUG_RAMPAGE, "Chain Ended - Chain:", rampageStats.iChain) IF (rampageStats.iChain > rampageStats.iMaxChain) rampageStats.iMaxChain = rampageStats.iChain CPRINTLN(DEBUG_RAMPAGE, "New Max Kill Chain:", rampageStats.iMaxChain) //PLAY_SOUND_FRONTEND(GET_SOUND_ID(), "MULTIPLIER_AWARD_MASTER") IF (bShowNotifications) /* BEGIN_TEXT_COMMAND_THEFEED_POST("NOT_MCHN") // New Max Chain ADD_TEXT_COMPONENT_INTEGER(rampageStats.iMaxChain) END_TEXT_COMMAND_THEFEED_POST_TICKER(FALSE) */ ENDIF ELSE CPRINTLN(DEBUG_RAMPAGE, "Kill Chain:", rampageStats.iChain) //PLAY_SOUND_FRONTEND(GET_SOUND_ID(), "MULTIPLIER_AWARD_MASTER") IF (bShowNotifications) /* BEGIN_TEXT_COMMAND_THEFEED_POST("NOT_CHN") // Kill Streak ADD_TEXT_COMPONENT_INTEGER(rampageStats.iChain) END_TEXT_COMMAND_THEFEED_POST_TICKER(FALSE) */ ENDIF ENDIF ENDIF rampageStats.iChain = 0 ENDIF ENDIF ENDIF //CPRINTLN(DEBUG_RAMPAGE, "---- RAMPAGE END FRAME ----") //CPRINTLN(DEBUG_RAMPAGE, " ") ENDPROC