From 1ac69e57fdecf8e629de6f4ec75976e30b354170 Mon Sep 17 00:00:00 2001 From: cdnutter Date: Mon, 17 Jun 2024 19:46:07 -0700 Subject: [PATCH] first com --- .gitignore | 4 + bots.txt | 16 + maps/.DS_Store | Bin 0 -> 6148 bytes maps/mp/.DS_Store | Bin 0 -> 6148 bytes maps/mp/perks/_perks.gsc | 400 ++++++++++++ maps/mp/perks/_perksfunctions.gsc | 1011 +++++++++++++++++++++++++++++ 6 files changed, 1431 insertions(+) create mode 100644 .gitignore create mode 100644 bots.txt create mode 100644 maps/.DS_Store create mode 100644 maps/mp/.DS_Store create mode 100644 maps/mp/perks/_perks.gsc create mode 100644 maps/mp/perks/_perksfunctions.gsc diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..6d88cf0 --- /dev/null +++ b/.gitignore @@ -0,0 +1,4 @@ +logs +scriptdata +scripts +bots \ No newline at end of file diff --git a/bots.txt b/bots.txt new file mode 100644 index 0000000..ee3860b --- /dev/null +++ b/bots.txt @@ -0,0 +1,16 @@ +Jakob M. +Jonny R. +Kevin V. +Star M. +Cizin D. +Jared D. +Riley D. +Robert P. IV +Ralph G. +Tony B. +Jason O. +Ruben H. +Bruce J. +Chris J. +Joey M. +Xavier G. diff --git a/maps/.DS_Store b/maps/.DS_Store new file mode 100644 index 0000000000000000000000000000000000000000..ddb73bc9e11db301e61b5f4a07d6a6ee0fb33025 GIT binary patch literal 6148 zcmeHK%}N6?5Kh`^Q$#4Dptpe6g4+s;cv;ta7F^MTO6|Hu7q^?GKklIv_O1`%J9zR1 zd;}lBCvhf8{h@l5A~P`glKDwC-)@r*V~l&lu+CVOF(yC}3l(U75cH!?Nx@p?0XfbQ z#43RPbCAZ-R5Tf8kpX;n1=eM0koD8A@2@{_oL62bmgeTmqAV7~g@2o)Et>fSKO;bYUXXmJ7$(9xTTuj~Gm>ZaOJ zK3tmEyQG6s zk1Vk;z1OP07Sqt>BmcSfo(Y2Tx1P=%|semSx z+Y*DDbg)Ys=UU7Snsml(@xkrN+*T-DuMYD|9nQFGkXmAZ82HXW(G072{~y3_`Iq|t zdlHR^0b<}^F~Cbrzv;o2?ADG-PI?tt6_}sV3zb4>oCRyC}P8f<{m*m>XtOD zWe!!9y_@6KT{Q>fHVM^l}UCL;*BI7{~JVe9y+Y`e9h)@WE+$X>kcZp|g6R z?7A0yQ{#ztwhmvd`^G8^?Z+y9{|f%ScK&?c^e2z{CpYVJ*SN%L-P>rIXDYu2+j5`i zCm{xi0b*cB7_di^Xz$2=XdA=;F|a!f;Q1gy5q*obL49;Uqe}ol2h3WakF^BmNQ=J3 z+8}s9xJd;xsoa(r+@ynD+Bn~0ZP27MZi^3YSLU`t;d*tLU+QqieS_2z1H`~415GpR z;QfF6aQ(lTL?dE=7R=cdZ1y0!6{N+Tbb$I{GSxSiFkgfocJ} Y#15cuu{H=65c(0&G*CkfJShYJ0mKJo#sB~S literal 0 HcmV?d00001 diff --git a/maps/mp/perks/_perks.gsc b/maps/mp/perks/_perks.gsc new file mode 100644 index 0000000..a04dfb0 --- /dev/null +++ b/maps/mp/perks/_perks.gsc @@ -0,0 +1,400 @@ +#include common_scripts\utility; +#include maps\mp\_utility; +#include maps\mp\gametypes\_hud_util; +#include maps\mp\perks\_perkfunctions; + +init() +{ + level.perkFuncs = []; + + precacheShader( "combathigh_overlay" ); + precacheShader( "specialty_painkiller" ); + + precacheModel( "weapon_riot_shield_mp" ); + precacheModel( "viewmodel_riot_shield_mp" ); + precacheString( &"MPUI_CHANGING_KIT" ); + + //level.spawnGlowSplat = loadfx( "misc/flare_ambient_destroy" ); + + level.spawnGlowModel["enemy"] = "mil_emergency_flare_mp"; + level.spawnGlowModel["friendly"] = "mil_emergency_flare_mp"; + level.spawnGlow["enemy"] = loadfx( "misc/flare_ambient" ); + level.spawnGlow["friendly"] = loadfx( "misc/flare_ambient_green" ); + level.c4Death = loadfx( "explosions/oxygen_tank_explosion" ); + + level.spawnFire = loadfx( "props/barrelexp" ); + + precacheModel( level.spawnGlowModel["friendly"] ); + precacheModel( level.spawnGlowModel["enemy"] ); + + precacheString( &"MP_DESTROY_TI" ); + + precacheShaders(); + + level._effect["ricochet"] = loadfx( "impacts/large_metalhit_1" ); + + // perks that currently only exist in script: these will error if passed to "setPerk", etc... CASE SENSITIVE! must be lower + level.scriptPerks = []; + level.perkSetFuncs = []; + level.perkUnsetFuncs = []; + level.fauxPerks = []; + + level.scriptPerks["specialty_blastshield"] = true; + level.scriptPerks["_specialty_blastshield"] = true; + level.scriptPerks["specialty_akimbo"] = true; + level.scriptPerks["specialty_siege"] = true; + level.scriptPerks["specialty_falldamage"] = true; + level.scriptPerks["specialty_fmj"] = true; + level.scriptPerks["specialty_shield"] = true; + level.scriptPerks["specialty_feigndeath"] = true; + level.scriptPerks["specialty_shellshock"] = true; + level.scriptPerks["specialty_delaymine"] = true; + level.scriptPerks["specialty_localjammer"] = true; + level.scriptPerks["specialty_thermal"] = true; + level.scriptPerks["specialty_finalstand"] = true; + level.scriptPerks["specialty_blackbox"] = true; + level.scriptPerks["specialty_steelnerves"] = true; + level.scriptPerks["specialty_flashgrenade"] = true; + level.scriptPerks["specialty_smokegrenade"] = true; + level.scriptPerks["specialty_concussiongrenade"] = true; + level.scriptPerks["specialty_challenger"] = true; + level.scriptPerks["specialty_tacticalinsertion"] = true; + level.scriptPerks["specialty_saboteur"] = true; + level.scriptPerks["specialty_endgame"] = true; + level.scriptPerks["specialty_rearview"] = true; + level.scriptPerks["specialty_hardline"] = true; + level.scriptPerks["specialty_ac130"] = true; + level.scriptPerks["specialty_sentry_minigun"] = true; + level.scriptPerks["specialty_predator_missile"] = true; + level.scriptPerks["specialty_helicopter_minigun"] = true; + level.scriptPerks["specialty_tank"] = true; + level.scriptPerks["specialty_precision_airstrike"] = true; + level.scriptPerks["specialty_bling"] = true; + level.scriptPerks["specialty_carepackage"] = true; + level.scriptPerks["specialty_onemanarmy"] = true; + level.scriptPerks["specialty_littlebird_support"] = true; + level.scriptPerks["specialty_primarydeath"] = true; + level.scriptPerks["specialty_secondarybling"] = true; + level.scriptPerks["specialty_combathigh"] = true; + level.scriptPerks["specialty_c4death"] = true; + level.scriptPerks["specialty_explosivedamage"] = true; + level.scriptPerks["specialty_copycat"] = true; + level.scriptPerks["specialty_laststandoffhand"] = true; + level.scriptPerks["specialty_dangerclose"] = true; + + level.scriptPerks["specialty_extraspecialduration"] = true; + level.scriptPerks["specialty_rollover"] = true; + level.scriptPerks["specialty_armorpiercing"] = true; + level.scriptPerks["specialty_omaquickchange"] = true; + level.scriptPerks["specialty_fastmeleerecovery"] = true; + + level.scriptPerks["_specialty_rearview"] = true; + level.scriptPerks["_specialty_onemanarmy"] = true; + + level.fauxPerks["specialty_tacticalinsertion"] = true; + level.fauxPerks["specialty_shield"] = true; + + + /* + level.perkSetFuncs[""] = ::; + level.perkUnsetFuncs[""] = ::; + */ + + level.perkSetFuncs["specialty_blastshield"] = ::setBlastShield; + level.perkUnsetFuncs["specialty_blastshield"] = ::unsetBlastShield; + + level.perkSetFuncs["specialty_siege"] = ::setSiege; + level.perkUnsetFuncs["specialty_siege"] = ::unsetSiege; + + level.perkSetFuncs["specialty_falldamage"] = ::setFreefall; + level.perkUnsetFuncs["specialty_falldamage"] = ::unsetFreefall; + + level.perkSetFuncs["specialty_localjammer"] = ::setLocalJammer; + level.perkUnsetFuncs["specialty_localjammer"] = ::unsetLocalJammer; + + level.perkSetFuncs["specialty_thermal"] = ::setThermal; + level.perkUnsetFuncs["specialty_thermal"] = ::unsetThermal; + + level.perkSetFuncs["specialty_blackbox"] = ::setBlackBox; + level.perkUnsetFuncs["specialty_blackbox"] = ::unsetBlackBox; + + level.perkSetFuncs["specialty_lightweight"] = ::setLightWeight; + level.perkUnsetFuncs["specialty_lightweight"] = ::unsetLightWeight; + + level.perkSetFuncs["specialty_steelnerves"] = ::setSteelNerves; + level.perkUnsetFuncs["specialty_steelnerves"] = ::unsetSteelNerves; + + level.perkSetFuncs["specialty_delaymine"] = ::setDelayMine; + level.perkUnsetFuncs["specialty_delaymine"] = ::unsetDelayMine; + + level.perkSetFuncs["specialty_finalstand"] = ::setFinalStand; + level.perkUnsetFuncs["specialty_finalstand"] = ::unsetFinalStand; + + level.perkSetFuncs["specialty_combathigh"] = ::setCombatHigh; + level.perkUnsetFuncs["specialty_combathigh"] = ::unsetCombatHigh; + + level.perkSetFuncs["specialty_challenger"] = ::setChallenger; + level.perkUnsetFuncs["specialty_challenger"] = ::unsetChallenger; + + level.perkSetFuncs["specialty_saboteur"] = ::setSaboteur; + level.perkUnsetFuncs["specialty_saboteur"] = ::unsetSaboteur; + + level.perkSetFuncs["specialty_endgame"] = ::setEndGame; + level.perkUnsetFuncs["specialty_endgame"] = ::unsetEndGame; + + level.perkSetFuncs["specialty_rearview"] = ::setRearView; + level.perkUnsetFuncs["specialty_rearview"] = ::unsetRearView; + + level.perkSetFuncs["specialty_ac130"] = ::setAC130; + level.perkUnsetFuncs["specialty_ac130"] = ::unsetAC130; + + level.perkSetFuncs["specialty_sentry_minigun"] = ::setSentryMinigun; + level.perkUnsetFuncs["specialty_sentry_minigun"] = ::unsetSentryMinigun; + + level.perkSetFuncs["specialty_predator_missile"] = ::setPredatorMissile; + level.perkUnsetFuncs["specialty_predator_missile"] = ::unsetPredatorMissile; + + level.perkSetFuncs["specialty_tank"] = ::setTank; + level.perkUnsetFuncs["specialty_tank"] = ::unsetTank; + + level.perkSetFuncs["specialty_precision_airstrike"] = ::setPrecision_airstrike; + level.perkUnsetFuncs["specialty_precision_airstrike"] = ::unsetPrecision_airstrike; + + level.perkSetFuncs["specialty_helicopter_minigun"] = ::setHelicopterMinigun; + level.perkUnsetFuncs["specialty_helicopter_minigun"] = ::unsetHelicopterMinigun; + + level.perkSetFuncs["specialty_carepackage"] = ::setCarePackage; + level.perkUnsetFuncs["specialty_carepackage"] = ::unsetCarePackage; + + level.perkSetFuncs["specialty_onemanarmy"] = ::setOneManArmy; + level.perkUnsetFuncs["specialty_onemanarmy"] = ::unsetOneManArmy; + + level.perkSetFuncs["specialty_littlebird_support"] = ::setLittlebirdSupport; + level.perkUnsetFuncs["specialty_littlebird_support"] = ::unsetLittlebirdSupport; + + level.perkSetFuncs["specialty_c4death"] = ::setC4Death; + level.perkUnsetFuncs["specialty_c4death"] = ::unsetC4Death; + + level.perkSetFuncs["specialty_tacticalinsertion"] = ::setTacticalInsertion; + level.perkUnsetFuncs["specialty_tacticalinsertion"] = ::unsetTacticalInsertion; + + initPerkDvars(); + + level thread onPlayerConnect(); +} + + + +precacheShaders() +{ + precacheShader( "specialty_blastshield" ); +} + + +givePerk( perkName ) +{ + if ( IsSubStr( perkName, "_mp" ) ) + { + if ( perkName == "frag_grenade_mp" ) + self SetOffhandPrimaryClass( "frag" ); + if ( perkName == "throwingknife_mp" ) + self SetOffhandPrimaryClass( "throwingknife" ); + + self _giveWeapon( perkName, 0 ); + self giveStartAmmo( perkName ); + + self setPerk( perkName, false ); + return; + } + + if ( isSubStr( perkName, "specialty_null" ) || isSubStr( perkName, "specialty_weapon_" ) ) + { + self setPerk( perkName, false ); + return; + } + + self _setPerk( perkName ); + +} + + +validatePerk( perkIndex, perkName ) +{ + if ( getDvarInt ( "scr_game_perks" ) == 0 ) + { + if ( tableLookup( "mp/perkTable.csv", 1, perkName, 5 ) != "equipment" ) + return "specialty_null"; + } + + /* Validation disabled for now + if ( tableLookup( "mp/perkTable.csv", 1, perkName, 5 ) != ("perk"+perkIndex) ) + { + println( "^1Warning: (" + self.name + ") Perk " + perkName + " is not allowed for perk slot index " + perkIndex + "; replacing with no perk" ); + return "specialty_null"; + } + */ + + return perkName; +} + + +onPlayerConnect() +{ + for(;;) + { + level waittill( "connected", player ); + player thread onPlayerSpawned(); + } +} + + +onPlayerSpawned() +{ + self endon( "disconnect" ); + + self.perks = []; + self.weaponList = []; + self.omaClassChanged = false; + + for( ;; ) + { + self waittill( "spawned_player" ); + + self.omaClassChanged = false; + self thread gambitUseTracker(); + } +} + + +drawLine( start, end, timeSlice ) +{ + drawTime = int(timeSlice * 20); + for( time = 0; time < drawTime; time++ ) + { + line( start, end, (1,0,0),false, 1 ); + wait ( 0.05 ); + } +} + + +cac_modified_damage( victim, attacker, damage, meansofdeath, weapon, impactPoint, impactDir, hitLoc ) +{ + assert( isPlayer( victim ) ); + assert( isDefined( victim.team ) ); + + damageAdd = 0; + + if ( isPrimaryDamage( meansOfDeath ) ) + { + assert( isDefined( attacker ) ); + + if ( isPlayer( attacker ) && weaponInheritsPerks( weapon ) && attacker _hasPerk( "specialty_bulletdamage" ) && victim _hasPerk( "specialty_armorvest" ) ) + damageAdd += 0; + else if ( isPlayer( attacker ) && weaponInheritsPerks( weapon ) && attacker _hasPerk( "specialty_bulletdamage" ) ) + damageAdd += damage*level.bulletDamageMod; + else if ( victim _hasPerk( "specialty_armorvest" ) ) + damageAdd -= damage*(1-level.armorVestMod); + + if ( isPlayer( attacker ) && attacker _hasPerk( "specialty_fmj" ) && victim _hasPerk ( "specialty_armorvest" ) ) + damageAdd += damage*level.hollowPointDamageMod; + } + else if ( isExplosiveDamage( meansOfDeath ) ) + { + if ( isPlayer( attacker ) && weaponInheritsPerks( weapon ) && attacker _hasPerk( "specialty_explosivedamage" ) && victim _hasPerk( "_specialty_blastshield" ) ) + damageAdd += 0; + else if ( isPlayer( attacker ) && weaponInheritsPerks( weapon ) && attacker _hasPerk( "specialty_explosivedamage" ) ) + damageAdd += damage*level.explosiveDamageMod; + else if ( victim _hasPerk( "_specialty_blastshield" ) ) + damageAdd -= damage*(1-level.blastShieldMod); + + if ( isKillstreakWeapon( weapon ) && isPlayer( attacker ) && attacker _hasPerk("specialty_dangerclose") ) + damageAdd += damage*level.dangerCloseMod; + } + else if (meansOfDeath == "MOD_FALLING") + { + if ( victim _hasPerk( "specialty_falldamage" ) ) + { + //eventually set a msg to do a roll + damageAdd = 0; + damage = 0; + } + } + + if ( ( victim.xpScaler == 2 && isDefined( attacker ) ) && ( isPlayer( attacker ) || attacker.classname == "scrip_vehicle" ) ) + damageAdd += 200; + + if ( victim _hasperk( "specialty_combathigh" ) ) + { + if ( IsDefined( self.damageBlockedTotal ) && (!level.teamBased || (isDefined( attacker ) && isDefined( attacker.team ) && victim.team != attacker.team)) ) + { + damageTotal = damage + damageAdd; + damageBlocked = (damageTotal - ( damageTotal / 3 )); + self.damageBlockedTotal += damageBlocked; + + if ( self.damageBlockedTotal >= 101 ) + { + self notify( "combathigh_survived" ); + self.damageBlockedTotal = undefined; + } + } + + if ( weapon != "throwingknife_mp" ) + { + switch ( meansOfDeath ) + { + case "MOD_FALLING": + case "MOD_MELEE": + break; + default: + damage = damage/3; + damageAdd = damageAdd/3; + break; + } + } + } + + return int( damage + damageAdd ); +} + +initPerkDvars() +{ + level.bulletDamageMod = getIntProperty( "perk_bulletDamage", 40 )/100; // increased bullet damage by this % + level.hollowPointDamageMod = getIntProperty( "perk_hollowPointDamage", 65 )/100; // increased bullet damage by this % + level.armorVestMod = getIntProperty( "perk_armorVest", 75 )/100; // percentage of damage you take + level.explosiveDamageMod = getIntProperty( "perk_explosiveDamage", 40 )/100; // increased explosive damage by this % + level.blastShieldMod = getIntProperty( "perk_blastShield", 45 )/100; // percentage of damage you take + level.riotShieldMod = getIntProperty( "perk_riotShield", 100 )/100; + level.dangerCloseMod = getIntProperty( "perk_dangerClose", 100 )/100; + level.armorPiercingMod = getIntProperty( "perk_armorPiercingDamage", 40 )/100; // increased bullet damage by this % +} + +// CAC: Selector function, calls the individual cac features according to player's class settings +// Info: Called every time player spawns during loadout stage +cac_selector() +{ + perks = self.specialty; + + /* + self.detectExplosives = false; + + if ( self _hasPerk( "specialty_detectexplosive" ) ) + self.detectExplosives = true; + + maps\mp\gametypes\_weapons::setupBombSquad(); + */ +} + + +gambitUseTracker() +{ + self endon ( "death" ); + self endon ( "disconnect" ); + level endon ( "game_ended" ); + + if ( getDvarInt ( "scr_game_perks" ) != 1 ) + return; + + gameFlagWait( "prematch_done" ); + + self notifyOnPlayerCommand( "gambit_on", "+frag" ); +} \ No newline at end of file diff --git a/maps/mp/perks/_perksfunctions.gsc b/maps/mp/perks/_perksfunctions.gsc new file mode 100644 index 0000000..e893c1e --- /dev/null +++ b/maps/mp/perks/_perksfunctions.gsc @@ -0,0 +1,1011 @@ +/******************************************************************* +// _perkfunctions.gsc +// +// Holds all the perk set/unset and listening functions +// +// Jordan Hirsh Sept. 11th 2008 +********************************************************************/ + +#include common_scripts\utility; +#include maps\mp\_utility; +#include maps\mp\gametypes\_hud_util; +#include maps\mp\perks\_perks; + + +blastshieldUseTracker( perkName, useFunc ) +{ + self endon ( "death" ); + self endon ( "disconnect" ); + self endon ( "end_perkUseTracker" ); + level endon ( "game_ended" ); + + for ( ;; ) + { + self waittill ( "empty_offhand" ); + + if ( !isOffhandWeaponEnabled() ) + continue; + + self [[useFunc]]( self _hasPerk( "_specialty_blastshield" ) ); + } +} + +perkUseDeathTracker() +{ + self endon ( "disconnect" ); + + self waittill("death"); + self._usePerkEnabled = undefined; +} + +setRearView() +{ + //self thread perkUseTracker( "specialty_rearview", ::toggleRearView ); +} + +unsetRearView() +{ + self notify ( "end_perkUseTracker" ); +} + +toggleRearView( isEnabled ) +{ + if ( isEnabled ) + { + self _setPerk( "_specialty_rearview" ); + self SetRearViewRenderEnabled(true); + } + else + { + self _unsetPerk( "_specialty_rearview" ); + self SetRearViewRenderEnabled(false); + } +} + + +setEndGame() +{ + if ( isdefined( self.endGame ) ) + return; + + self.maxhealth = ( maps\mp\gametypes\_tweakables::getTweakableValue( "player", "maxhealth" ) * 4 ); + self.health = self.maxhealth; + self.endGame = true; + self.attackerTable[0] = ""; + self visionSetNakedForPlayer("end_game", 5 ); + self thread endGameDeath( 7 ); + self.hasDoneCombat = true; +} + + +unsetEndGame() +{ + self notify( "stopEndGame" ); + self.endGame = undefined; + revertVisionSet(); + + if (! isDefined( self.endGameTimer ) ) + return; + + self.endGameTimer destroyElem(); + self.endGameIcon destroyElem(); +} + + +revertVisionSet() +{ + self VisionSetNakedForPlayer( getDvar( "mapname" ), 1 ); +} + +endGameDeath( duration ) +{ + self endon( "death" ); + self endon( "disconnect" ); + self endon( "joined_team" ); + level endon( "game_ended" ); + self endon( "stopEndGame" ); + + wait( duration + 1 ); + //self visionSetNakedForPlayer("end_game2", 1 ); + //wait(1); + self _suicide(); +} + +setCombatHigh() +{ + self endon( "death" ); + self endon( "disconnect" ); + self endon( "unset_combathigh" ); + level endon( "end_game" ); + + self.damageBlockedTotal = 0; + //self visionSetNakedForPlayer( "end_game", 1 ); + + if ( level.splitscreen ) + { + yOffset = 56; + iconSize = 21; // 32/1.5 + } + else + { + yOffset = 112; + iconSize = 32; + } + + self.combatHighOverlay = newClientHudElem( self ); + self.combatHighOverlay.x = 0; + self.combatHighOverlay.y = 0; + self.combatHighOverlay.alignX = "left"; + self.combatHighOverlay.alignY = "top"; + self.combatHighOverlay.horzAlign = "fullscreen"; + self.combatHighOverlay.vertAlign = "fullscreen"; + self.combatHighOverlay setshader ( "combathigh_overlay", 640, 480 ); + self.combatHighOverlay.sort = -10; + self.combatHighOverlay.archived = true; + + self.combatHighTimer = createTimer( "hudsmall", 1.0 ); + self.combatHighTimer setPoint( "CENTER", "CENTER", 0, yOffset ); + self.combatHighTimer setTimer( 10.0 ); + self.combatHighTimer.color = (.8,.8,0); + self.combatHighTimer.archived = false; + self.combatHighTimer.foreground = true; + + self.combatHighIcon = self createIcon( "specialty_painkiller", iconSize, iconSize ); + self.combatHighIcon.alpha = 0; + self.combatHighIcon setParent( self.combatHighTimer ); + self.combatHighIcon setPoint( "BOTTOM", "TOP" ); + self.combatHighIcon.archived = true; + self.combatHighIcon.sort = 1; + self.combatHighIcon.foreground = true; + + self.combatHighOverlay.alpha = 0.0; + self.combatHighOverlay fadeOverTime( 1.0 ); + self.combatHighIcon fadeOverTime( 1.0 ); + self.combatHighOverlay.alpha = 1.0; + self.combatHighIcon.alpha = 0.85; + + self thread unsetCombatHighOnDeath(); + + wait( 8 ); + + self.combatHighIcon fadeOverTime( 2.0 ); + self.combatHighIcon.alpha = 0.0; + + self.combatHighOverlay fadeOverTime( 2.0 ); + self.combatHighOverlay.alpha = 0.0; + + self.combatHighTimer fadeOverTime( 2.0 ); + self.combatHighTimer.alpha = 0.0; + + wait( 2 ); + self.damageBlockedTotal = undefined; + + self _unsetPerk( "specialty_combathigh" ); +} + +unsetCombatHighOnDeath() +{ + self endon ( "disconnect" ); + self endon ( "unset_combathigh" ); + + self waittill ( "death" ); + + self thread _unsetPerk( "specialty_combathigh" ); +} + +unsetCombatHigh() +{ + self notify ( "unset_combathigh" ); + self.combatHighOverlay destroy(); + self.combatHighIcon destroy(); + self.combatHighTimer destroy(); +} + +setSiege() +{ + self thread trackSiegeEnable(); + self thread trackSiegeDissable(); +} + +trackSiegeEnable() +{ + self endon ( "death" ); + self endon ( "disconnect" ); + self endon ( "stop_trackSiege" ); + + for ( ;; ) + { + self waittill ( "gambit_on" ); + + //self setStance( "crouch" ); + //self thread stanceStateListener(); + //self thread jumpStateListener(); + self.moveSpeedScaler = 0; + self maps\mp\gametypes\_weapons::updateMoveSpeedScale( "primary" ); + class = weaponClass( self getCurrentWeapon() ); + + if ( class == "pistol" || class == "smg" ) + self setSpreadOverride( 1 ); + else + self setSpreadOverride( 2 ); + + self player_recoilScaleOn( 0 ); + self allowJump(false); + } +} + +trackSiegeDissable() +{ + self endon ( "death" ); + self endon ( "disconnect" ); + self endon ( "stop_trackSiege" ); + + for ( ;; ) + { + self waittill ( "gambit_off" ); + + unsetSiege(); + } +} + +stanceStateListener() +{ + self endon ( "death" ); + self endon ( "disconnect" ); + + self notifyOnPlayerCommand( "adjustedStance", "+stance" ); + + for ( ;; ) + { + self waittill( "adjustedStance" ); + if ( self.moveSPeedScaler != 0 ) + continue; + + unsetSiege(); + } +} + +jumpStateListener() +{ + self endon ( "death" ); + self endon ( "disconnect" ); + + self notifyOnPlayerCommand( "jumped", "+goStand" ); + + for ( ;; ) + { + self waittill( "jumped" ); + if ( self.moveSPeedScaler != 0 ) + continue; + + unsetSiege(); + } +} + +unsetSiege() +{ + self.moveSpeedScaler = 1; + //if siege is not cut add check to see if + //using lightweight and siege for movespeed scaler + self resetSpreadOverride(); + self maps\mp\gametypes\_weapons::updateMoveSpeedScale( "primary" ); + self player_recoilScaleOff(); + self allowJump(true); +} + + +setFinalStand() +{ + self _setperk( "specialty_pistoldeath"); +} + +unsetFinalStand() +{ + self _unsetperk( "specialty_pistoldeath" ); +} + + +setChallenger() +{ + if ( !level.hardcoreMode ) + { + self.maxhealth = maps\mp\gametypes\_tweakables::getTweakableValue( "player", "maxhealth" ); + + if ( isDefined( self.xpScaler ) && self.xpScaler == 1 && self.maxhealth > 30 ) + { + self.xpScaler = 2; + } + } +} + +unsetChallenger() +{ + self.xpScaler = 1; +} + + +setSaboteur() +{ + self.objectiveScaler = 1.2; +} + +unsetSaboteur() +{ + self.objectiveScaler = 1; +} + + +setLightWeight() +{ + self.moveSpeedScaler = 1.07; + self maps\mp\gametypes\_weapons::updateMoveSpeedScale( "primary" ); +} + +unsetLightWeight() +{ + self.moveSpeedScaler = 1; + self maps\mp\gametypes\_weapons::updateMoveSpeedScale( "primary" ); +} + + +setBlackBox() +{ + self.killStreakScaler = 1.5; +} + +unsetBlackBox() +{ + self.killStreakScaler = 1; +} + +setSteelNerves() +{ + self _setperk( "specialty_bulletaccuracy" ); + self _setperk( "specialty_holdbreath" ); +} + +unsetSteelNerves() +{ + self _unsetperk( "specialty_bulletaccuracy" ); + self _unsetperk( "specialty_holdbreath" ); +} + +setDelayMine() +{ +} + +unsetDelayMine() +{ +} + + +setBackShield() +{ + self AttachShieldModel( "weapon_riot_shield_mp", "tag_shield_back" ); +} + + +unsetBackShield() +{ + self DetachShieldModel( "weapon_riot_shield_mp", "tag_shield_back" ); +} + + +setLocalJammer() +{ + if ( !self isEMPed() ) + self RadarJamOn(); +} + + +unsetLocalJammer() +{ + self RadarJamOff(); +} + + +setAC130() +{ + self thread killstreakThink( "ac130", 7, "end_ac130Think" ); +} + +unsetAC130() +{ + self notify ( "end_ac130Think" ); +} + + +setSentryMinigun() +{ + self thread killstreakThink( "airdrop_sentry_minigun", 2, "end_sentry_minigunThink" ); +} + +unsetSentryMinigun() +{ + self notify ( "end_sentry_minigunThink" ); +} + +setCarePackage() +{ + self thread killstreakThink( "airdrop", 2, "endCarePackageThink" ); +} + +unsetCarePackage() +{ + self notify ( "endCarePackageThink" ); +} + +setTank() +{ + self thread killstreakThink( "tank", 6, "end_tankThink" ); +} + +unsetTank() +{ + self notify ( "end_tankThink" ); +} + +setPrecision_airstrike() +{ + println( "!precision airstrike!" ); + self thread killstreakThink( "precision_airstrike", 6, "end_precision_airstrike" ); +} + +unsetPrecision_airstrike() +{ + self notify ( "end_precision_airstrike" ); +} + +setPredatorMissile() +{ + self thread killstreakThink( "predator_missile", 4, "end_predator_missileThink" ); +} + +unsetPredatorMissile() +{ + self notify ( "end_predator_missileThink" ); +} + + +setHelicopterMinigun() +{ + self thread killstreakThink( "helicopter_minigun", 5, "end_helicopter_minigunThink" ); +} + +unsetHelicopterMinigun() +{ + self notify ( "end_helicopter_minigunThink" ); +} + + + +killstreakThink( streakName, streakVal, endonString ) +{ + self endon ( "death" ); + self endon ( "disconnect" ); + self endon ( endonString ); + + for ( ;; ) + { + self waittill ( "killed_enemy" ); + + if ( self.pers["cur_kill_streak"] != streakVal ) + continue; + + self thread maps\mp\killstreaks\_killstreaks::giveKillstreak( streakName ); + self thread maps\mp\gametypes\_hud_message::killstreakSplashNotify( streakName, streakVal ); + return; + } +} + + +setThermal() +{ + self ThermalVisionOn(); +} + + +unsetThermal() +{ + self ThermalVisionOff(); +} + + +setOneManArmy() +{ + self thread oneManArmyWeaponChangeTracker(); +} + + +unsetOneManArmy() +{ + self notify ( "stop_oneManArmyTracker" ); +} + + +oneManArmyWeaponChangeTracker() +{ + self endon ( "death" ); + self endon ( "disconnect" ); + level endon ( "game_ended" ); + self endon ( "stop_oneManArmyTracker" ); + + for ( ;; ) + { + self waittill( "weapon_change", newWeapon ); + + if ( newWeapon != "onemanarmy_mp" ) + continue; + + //if ( self isUsingRemote() ) + // continue; + + self thread selectOneManArmyClass(); + } +} + + +isOneManArmyMenu( menu ) +{ + if ( menu == game["menu_onemanarmy"] ) + return true; + + if ( isDefined( game["menu_onemanarmy_defaults_splitscreen"] ) && menu == game["menu_onemanarmy_defaults_splitscreen"] ) + return true; + + if ( isDefined( game["menu_onemanarmy_custom_splitscreen"] ) && menu == game["menu_onemanarmy_custom_splitscreen"] ) + return true; + + return false; +} + + +selectOneManArmyClass() +{ + self endon ( "death" ); + self endon ( "disconnect" ); + level endon ( "game_ended" ); + + self _disableWeaponSwitch(); + + self openPopupMenu( game["menu_onemanarmy"] ); + + self thread closeOMAMenuOnDeath(); + + self waittill ( "menuresponse", menu, className ); + + self _enableWeaponSwitch(); + + if ( className == "back" || !isOneManArmyMenu( menu ) || self isUsingRemote() ) + { + if ( self getCurrentWeapon() == "onemanarmy_mp" ) + { + self _disableWeaponSwitch(); + self switchToWeapon( self getLastWeapon() ); + self waittill ( "weapon_change" ); + self _enableWeaponSwitch(); + } + return; + } + + self thread giveOneManArmyClass( className ); +} + +closeOMAMenuOnDeath() +{ + self endon ( "menuresponse" ); + self endon ( "disconnect" ); + level endon ( "game_ended" ); + + self waittill ( "death" ); + + self _enableWeaponSwitch(); + + self closePopupMenu(); +} + +giveOneManArmyClass( className ) +{ + self endon ( "death" ); + self endon ( "disconnect" ); + level endon ( "game_ended" ); + + if ( self _hasPerk( "specialty_omaquickchange" ) ) + { + changeDuration = 3.0; + self playLocalSound( "foly_onemanarmy_bag3_plr" ); + self playSoundToTeam( "foly_onemanarmy_bag3_npc", "allies", self ); + self playSoundToTeam( "foly_onemanarmy_bag3_npc", "axis", self ); + } + else + { + changeDuration = 6.0; + self playLocalSound( "foly_onemanarmy_bag6_plr" ); + self playSoundToTeam( "foly_onemanarmy_bag6_npc", "allies", self ); + self playSoundToTeam( "foly_onemanarmy_bag6_npc", "axis", self ); + } + + self thread omaUseBar( changeDuration ); + + self _disableWeapon(); + self _disableOffhandWeapons(); + + wait ( changeDuration ); + + self _enableWeapon(); + self _enableOffhandWeapons(); + self.OMAClassChanged = true; + + self maps\mp\gametypes\_class::giveLoadout( self.pers["team"], className, false ); + + // handle the fact that detachAll in giveLoadout removed the CTF flag from our back + // it would probably be better to handle this in _detachAll itself, but this is a safety fix + if ( isDefined( self.carryFlag ) ) + self attach( self.carryFlag, "J_spine4", true ); + + self notify ( "changed_kit" ); + level notify ( "changed_kit" ); +} + + +omaUseBar( duration ) +{ + self endon( "disconnect" ); + + useBar = createPrimaryProgressBar( 25 ); + useBarText = createPrimaryProgressBarText( 25 ); + useBarText setText( &"MPUI_CHANGING_KIT" ); + + useBar updateBar( 0, 1 / duration ); + for ( waitedTime = 0; waitedTime < duration && isAlive( self ) && !level.gameEnded; waitedTime += 0.05 ) + wait ( 0.05 ); + + useBar destroyElem(); + useBarText destroyElem(); +} + + +setBlastShield() +{ + self thread blastshieldUseTracker( "specialty_blastshield", ::toggleBlastShield ); + self SetWeaponHudIconOverride( "primaryoffhand", "specialty_blastshield" ); +} + + +unsetBlastShield() +{ + self notify ( "end_perkUseTracker" ); + self SetWeaponHudIconOverride( "primaryoffhand", "none" ); +} + +toggleBlastShield( isEnabled ) +{ + if ( !isEnabled ) + { + self VisionSetNakedForPlayer( "black_bw", 0.15 ); + wait ( 0.15 ); + self _setPerk( "_specialty_blastshield" ); + self VisionSetNakedForPlayer( getDvar( "mapname" ), 0 ); + self playSoundToPlayer( "item_blast_shield_on", self ); + } + else + { + self VisionSetNakedForPlayer( "black_bw", 0.15 ); + wait ( 0.15 ); + self _unsetPerk( "_specialty_blastshield" ); + self VisionSetNakedForPlayer( getDvar( "mapname" ), 0 ); + self playSoundToPlayer( "item_blast_shield_off", self ); + } +} + + +setFreefall() +{ + //eventually set a listener to do a roll when falling damage is taken +} + +unsetFreefall() +{ +} + + +setTacticalInsertion() +{ + self _giveWeapon( "flare_mp", 0 ); + self giveStartAmmo( "flare_mp" ); + + self thread monitorTIUse(); +} + +unsetTacticalInsertion() +{ + self notify( "end_monitorTIUse" ); +} + +clearPreviousTISpawnpoint() +{ + self waittill_any ( "disconnect", "joined_team", "joined_spectators" ); + + if ( isDefined ( self.setSpawnpoint ) ) + self deleteTI( self.setSpawnpoint ); +} + +updateTISpawnPosition() +{ + self endon ( "death" ); + self endon ( "disconnect" ); + level endon ( "game_ended" ); + self endon ( "end_monitorTIUse" ); + + while ( isReallyAlive( self ) ) + { + if ( self isValidTISpawnPosition() ) + self.TISpawnPosition = self.origin; + + wait ( 0.05 ); + } +} + +isValidTISpawnPosition() +{ + if ( CanSpawn( self.origin ) && self IsOnGround() ) + return true; + else + return false; +} + +monitorTIUse() +{ + self endon ( "death" ); + self endon ( "disconnect" ); + level endon ( "game_ended" ); + self endon ( "end_monitorTIUse" ); + + self thread updateTISpawnPosition(); + self thread clearPreviousTISpawnpoint(); + + for ( ;; ) + { + self waittill( "grenade_fire", lightstick, weapName ); + + if ( weapName != "flare_mp" ) + continue; + + //lightstick delete(); + + if ( isDefined( self.setSpawnPoint ) ) + self deleteTI( self.setSpawnPoint ); + + if ( !isDefined( self.TISpawnPosition ) ) + continue; + + if ( self touchingBadTrigger() ) + continue; + + TIGroundPosition = playerPhysicsTrace( self.TISpawnPosition + (0,0,16), self.TISpawnPosition - (0,0,2048) ) + (0,0,1); + + glowStick = spawn( "script_model", TIGroundPosition ); + glowStick.angles = self.angles; + glowStick.team = self.team; + glowStick.enemyTrigger = spawn( "script_origin", TIGroundPosition ); + glowStick thread GlowStickSetupAndWaitForDeath( self ); + glowStick.playerSpawnPos = self.TISpawnPosition; + + glowStick thread maps\mp\gametypes\_weapons::createBombSquadModel( "weapon_light_stick_tactical_bombsquad", "tag_fire_fx", level.otherTeam[self.team], self ); + + self.setSpawnPoint = glowStick; + return; + } +} + + +GlowStickSetupAndWaitForDeath( owner ) +{ + self setModel( level.spawnGlowModel["enemy"] ); + if ( level.teamBased ) + self maps\mp\_entityheadIcons::setTeamHeadIcon( self.team , (0,0,20) ); + else + self maps\mp\_entityheadicons::setPlayerHeadIcon( owner, (0,0,20) ); + + self thread GlowStickDamageListener( owner ); + self thread GlowStickEnemyUseListener( owner ); + self thread GlowStickUseListener( owner ); + self thread GlowStickTeamUpdater( level.otherTeam[self.team], level.spawnGlow["enemy"], owner ); + + dummyGlowStick = spawn( "script_model", self.origin+ (0,0,0) ); + dummyGlowStick.angles = self.angles; + dummyGlowStick setModel( level.spawnGlowModel["friendly"] ); + dummyGlowStick setContents( 0 ); + dummyGlowStick thread GlowStickTeamUpdater( self.team, level.spawnGlow["friendly"], owner ); + + dummyGlowStick playLoopSound( "emt_road_flare_burn" ); + + self waittill ( "death" ); + + dummyGlowStick stopLoopSound(); + dummyGlowStick delete(); +} + + +GlowStickTeamUpdater( showForTeam, showEffect, owner ) +{ + self endon ( "death" ); + + // PlayFXOnTag fails if run on the same frame the parent entity was created + wait ( 0.05 ); + + //PlayFXOnTag( showEffect, self, "TAG_FX" ); + angles = self getTagAngles( "tag_fire_fx" ); + fxEnt = SpawnFx( showEffect, self getTagOrigin( "tag_fire_fx" ), anglesToForward( angles ), anglesToUp( angles ) ); + TriggerFx( fxEnt ); + + self thread deleteOnDeath( fxEnt ); + + for ( ;; ) + { + self hide(); + fxEnt hide(); + foreach ( player in level.players ) + { + if ( player.team == showForTeam && level.teamBased ) + { + self showToPlayer( player ); + fxEnt showToPlayer( player ); + } + else if ( !level.teamBased && player == owner && showEffect == level.spawnGlow["friendly"] ) + { + self showToPlayer( player ); + fxEnt showToPlayer( player ); + } + else if ( !level.teamBased && player != owner && showEffect == level.spawnGlow["enemy"] ) + { + self showToPlayer( player ); + fxEnt showToPlayer( player ); + } + } + + level waittill_either ( "joined_team", "player_spawned" ); + } +} + +deleteOnDeath( ent ) +{ + self waittill( "death" ); + if ( isdefined( ent ) ) + ent delete(); +} + +GlowStickDamageListener( owner ) +{ + self endon ( "death" ); + + self setCanDamage( true ); + // use large health to work around teamkilling issue + self.health = 5000; + + for ( ;; ) + { + self waittill ( "damage", amount, attacker ); + + if ( level.teambased && isDefined( owner ) && attacker != owner && ( isDefined( attacker.team ) && attacker.team == self.team ) ) + { + self.health += amount; + continue; + } + + if ( self.health < (5000-20) ) + { + if ( isDefined( owner ) && attacker != owner ) + { + attacker notify ( "destroyed_insertion", owner ); + attacker notify( "destroyed_explosive" ); // count towards SitRep Pro challenge + owner thread leaderDialogOnPlayer( "ti_destroyed" ); + } + + attacker thread deleteTI( self ); + } + } +} + +GlowStickUseListener( owner ) +{ + self endon ( "death" ); + level endon ( "game_ended" ); + owner endon ( "disconnect" ); + + self setCursorHint( "HINT_NOICON" ); + self setHintString( &"MP_PICKUP_TI" ); + + self thread updateEnemyUse( owner ); + + for ( ;; ) + { + self waittill ( "trigger", player ); + + player playSound( "chemlight_pu" ); + player thread setTacticalInsertion(); + player thread deleteTI( self ); + } +} + +updateEnemyUse( owner ) +{ + self endon ( "death" ); + + for ( ;; ) + { + self setSelfUsable( owner ); + level waittill_either ( "joined_team", "player_spawned" ); + } +} + +deleteTI( TI ) +{ + if (isDefined( TI.enemyTrigger ) ) + TI.enemyTrigger Delete(); + + spot = TI.origin; + spotAngles = TI.angles; + + TI Delete(); + + dummyGlowStick = spawn( "script_model", spot ); + dummyGlowStick.angles = spotAngles; + dummyGlowStick setModel( level.spawnGlowModel["friendly"] ); + + dummyGlowStick setContents( 0 ); + thread dummyGlowStickDelete( dummyGlowStick ); +} + +dummyGlowStickDelete( stick ) +{ + wait(2.5); + stick Delete(); +} + +GlowStickEnemyUseListener( owner ) +{ + self endon ( "death" ); + level endon ( "game_ended" ); + owner endon ( "disconnect" ); + + self.enemyTrigger setCursorHint( "HINT_NOICON" ); + self.enemyTrigger setHintString( &"MP_DESTROY_TI" ); + self.enemyTrigger makeEnemyUsable( owner ); + + for ( ;; ) + { + self.enemyTrigger waittill ( "trigger", player ); + + player notify ( "destroyed_insertion", owner ); + player notify( "destroyed_explosive" ); // count towards SitRep Pro challenge + + //playFX( level.spawnGlowSplat, self.origin); + + if ( isDefined( owner ) && player != owner ) + owner thread leaderDialogOnPlayer( "ti_destroyed" ); + + player thread deleteTI( self ); + } +} + +setLittlebirdSupport() +{ + self thread killstreakThink( "littlebird_support", 2, "end_littlebird_support_think" ); +} + +unsetLittlebirdSupport() +{ + self notify ( "end_littlebird_support_think" ); +} + +setC4Death() +{ + if ( ! self _hasperk( "specialty_pistoldeath" ) ) + self _setperk( "specialty_pistoldeath"); +} + +unsetC4Death() +{ + +} \ No newline at end of file