API tools faq
paste
Advertisement
Guest User

Untitled

a guest
Sep 29th, 2010
469
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
text 40.46 KB | None | 0 0
raw download clone embed print report
  1. #include maps\mp\_utility;
  2. #include common_scripts\utility;
  3. #include maps\mp\gametypes\_hud_util;
  4.  
  5. /*QUAKED mp_airdrop_point (1.0 0.5 0.0) (-36 -12 0) (36 12 20)
  6. An airdrop can land here.*/
  7.  
  8. init()
  9. {
  10. precacheVehicle( "littlebird_mp" );
  11. precacheModel( "com_plasticcase_friendly" );
  12. precacheModel( "com_plasticcase_enemy");
  13. precacheModel( "vehicle_little_bird_armed" );
  14. precacheModel( "vehicle_ac130_low_mp" );
  15. precacheModel( "sentry_minigun_folded" );
  16. precacheString( &"PLATFORM_GET_RANDOM" );
  17. precacheString( &"PLATFORM_GET_KILLSTREAK" );
  18. precacheString( &"PLATFORM_CALL_NUKE" );
  19. precacheString( &"MP_CAPTURING_CRATE" );
  20. precacheString( &"MP_CIVILIAN_AIR_TRAFFIC" );
  21.  
  22. precacheModel( maps\mp\gametypes\_teams::getTeamCrateModel( "allies" ) );
  23. precacheModel( maps\mp\gametypes\_teams::getTeamCrateModel( "axis" ) );
  24.  
  25. precacheShader( maps\mp\gametypes\_teams::getTeamHudIcon( "allies" ) );
  26. precacheShader( maps\mp\gametypes\_teams::getTeamHudIcon( "axis" ) );
  27. precacheShader( "waypoint_ammo_friendly" );
  28. precacheShader( "compass_objpoint_ammo_friendly" );
  29. precacheShader( "compass_objpoint_ammo_enemy" );
  30. precacheMiniMapIcon( "compass_objpoint_c130_friendly" );
  31. precacheMiniMapIcon( "compass_objpoint_c130_enemy" );
  32.  
  33. game["strings"]["ammo_hint"] = &"MP_AMMO_PICKUP";
  34. game["strings"]["uav_hint"] = &"MP_UAV_PICKUP";
  35. game["strings"]["counter_uav_hint"] = &"MP_COUNTER_UAV_PICKUP";
  36. game["strings"]["sentry_hint"] = &"MP_SENTRY_PICKUP";
  37. game["strings"]["predator_missile_hint"] = &"MP_PREDATOR_MISSILE_PICKUP";
  38. game["strings"]["airstrike_hint"] = &"MP_AIRSTRIKE_PICKUP";
  39. game["strings"]["precision_airstrike_hint"] = &"MP_PRECISION_AIRSTRIKE_PICKUP";
  40. game["strings"]["harrier_airstrike_hint"] = &"MP_HARRIER_AIRSTRIKE_PICKUP";
  41. game["strings"]["helicopter_hint"] = &"MP_HELICOPTER_PICKUP";
  42. game["strings"]["helicopter_flares_hint"] = &"MP_HELICOPTER_FLARES_PICKUP";
  43. game["strings"]["stealth_airstrike_hint"] = &"MP_STEALTH_AIRSTRIKE_PICKUP";
  44. game["strings"]["helicopter_minigun_hint"] = &"MP_HELICOPTER_MINIGUN_PICKUP";
  45. game["strings"]["ac130_hint"] = &"MP_AC130_PICKUP";
  46. game["strings"]["emp_hint"] = &"MP_EMP_PICKUP";
  47. game["strings"]["nuke_hint"] = &"MP_NUKE_PICKUP";
  48.  
  49. level.airDropCrates = getEntArray( "care_package", "targetname" );
  50. level.oldAirDropCrates = getEntArray( "airdrop_crate", "targetname" );
  51.  
  52. if ( !level.airDropCrates.size )
  53. {
  54. level.airDropCrates = level.oldAirDropCrates;
  55.  
  56. assert( level.airDropCrates.size );
  57.  
  58. level.airDropCrateCollision = getEnt( level.airDropCrates[0].target, "targetname" );
  59. }
  60. else
  61. {
  62. foreach ( crate in level.oldAirDropCrates )
  63. crate delete();
  64.  
  65. level.airDropCrateCollision = getEnt( level.airDropCrates[0].target, "targetname" );
  66. level.oldAirDropCrates = getEntArray( "airdrop_crate", "targetname" );
  67. }
  68.  
  69. if ( level.airDropCrates.size )
  70. {
  71. foreach ( crate in level.AirDropCrates )
  72. crate delete();
  73. }
  74.  
  75.  
  76. level.killStreakFuncs["airdrop"] = ::tryUseAirdrop;
  77.  
  78. level.killStreakFuncs["airdrop_predator_missile"] = ::tryUseAirdropPredatorMissile;
  79. level.killStreakFuncs["airdrop_sentry_minigun"] = ::tryUseAirdropSentryMinigun;
  80. level.killStreakFuncs["airdrop_mega"] = ::tryUseMegaAirdrop;
  81.  
  82. level.littleBirds = 0;
  83. level.littlebird = [];
  84.  
  85. level.crateTypes = [];
  86.  
  87. // Drop Type Type Weight Function
  88. addCrateType( "airdrop", "ammo", getDvarInt( "scr_airdrop_ammo", 17 ), ::ammoCrateThink );
  89. addCrateType( "airdrop", "uav", getDvarInt( "scr_airdrop_uav", 17 ), ::killstreakCrateThink );
  90. addCrateType( "airdrop", "counter_uav", getDvarInt( "scr_airdrop_counter_uav", 15 ), ::killstreakCrateThink );
  91. addCrateType( "airdrop", "sentry", getDvarInt( "scr_airdrop_sentry", 12 ), ::killstreakCrateThink );
  92. addCrateType( "airdrop", "predator_missile", getDvarInt( "scr_airdrop_predator_missile", 12 ), ::killstreakCrateThink );
  93. addCrateType( "airdrop", "precision_airstrike", getDvarInt( "scr_airdrop_precision_airstrike", 11 ),::killstreakCrateThink );
  94. addCrateType( "airdrop", "harrier_airstrike", getDvarInt( "scr_airdrop_harrier_airstrike", 7 ), ::killstreakCrateThink );
  95. addCrateType( "airdrop", "helicopter", getDvarInt( "scr_airdrop_helicopter", 7 ), ::killstreakCrateThink );
  96. addCrateType( "airdrop", "helicopter_flares", getDvarInt( "scr_airdrop_helicopter_flares", 5 ), ::killstreakCrateThink );
  97. addCrateType( "airdrop", "stealth_airstrike", getDvarInt( "scr_airdrop_stealth_airstrike", 5 ), ::killstreakCrateThink );
  98. addCrateType( "airdrop", "helicopter_minigun", getDvarInt( "scr_airdrop_helicopter_minigun", 3 ), ::killstreakCrateThink );
  99. addCrateType( "airdrop", "ac130", getDvarInt( "scr_airdrop_ac130", 3 ), ::killstreakCrateThink );
  100. addCrateType( "airdrop", "emp", getDvarInt( "scr_airdrop_emp", 1 ), ::killstreakCrateThink );
  101. addCrateType( "airdrop", "nuke", getDvarInt( "scr_airdrop_nuke", 0 ), ::killstreakCrateThink );
  102.  
  103. addCrateType( "airdrop_mega", "ammo", getDvarInt( "scr_airdrop_mega_ammo", 12 ), ::ammoCrateThink );
  104. addCrateType( "airdrop_mega", "uav", getDvarInt( "scr_airdrop_mega_uav", 12 ), ::killstreakCrateThink );
  105. addCrateType( "airdrop_mega", "counter_uav", getDvarInt( "scr_airdrop_mega_counter_uav", 16 ), ::killstreakCrateThink );
  106. addCrateType( "airdrop_mega", "sentry", getDvarInt( "scr_airdrop_mega_sentry", 16 ), ::killstreakCrateThink );
  107. addCrateType( "airdrop_mega", "predator_missile", getDvarInt( "scr_airdrop_mega_predator_missile", 14 ), ::killstreakCrateThink );
  108. addCrateType( "airdrop_mega", "precision_airstrike", getDvarInt( "scr_airdrop_mega_precision_airstrike", 10 ),::killstreakCrateThink );
  109. addCrateType( "airdrop_mega", "harrier_airstrike", getDvarInt( "scr_airdrop_mega_harrier_airstrike", 5 ), ::killstreakCrateThink );
  110. addCrateType( "airdrop_mega", "helicopter", getDvarInt( "scr_airdrop_mega_helicopter", 5 ), ::killstreakCrateThink );
  111. addCrateType( "airdrop_mega", "helicopter_flares", getDvarInt( "scr_airdrop_mega_helicopter_flares", 3 ), ::killstreakCrateThink );
  112. addCrateType( "airdrop_mega", "stealth_airstrike", getDvarInt( "scr_airdrop_mega_stealth_airstrike", 3 ), ::killstreakCrateThink );
  113. addCrateType( "airdrop_mega", "helicopter_minigun", getDvarInt( "scr_airdrop_mega_helicopter_minigun", 2 ), ::killstreakCrateThink );
  114. addCrateType( "airdrop_mega", "ac130", getDvarInt( "scr_airdrop_mega_ac130", 2 ), ::killstreakCrateThink );
  115. addCrateType( "airdrop_mega", "emp", getDvarInt( "scr_airdrop_mega_emp", 0 ), ::killstreakCrateThink );
  116. addCrateType( "airdrop_mega", "nuke", getDvarInt( "scr_airdrop_mega_nuke", 0 ), ::killstreakCrateThink );
  117.  
  118. addCrateType( "airdrop_sentry_minigun", "sentry", 0, ::killstreakCrateThink );
  119.  
  120. addCrateType( "nuke_drop", "nuke", 100, ::nukeCrateThink );
  121.  
  122.  
  123. // generate the max weighted value
  124. foreach ( dropType, crateTypes in level.crateTypes )
  125. {
  126. level.crateMaxVal[dropType] = 0;
  127. foreach ( crateType, crateWeight in level.crateTypes[dropType] )
  128. {
  129. if ( !crateWeight )
  130. continue;
  131.  
  132. level.crateMaxVal[dropType] += crateWeight;
  133. level.crateTypes[dropType][crateType] = level.crateMaxVal[dropType];
  134. }
  135. }
  136.  
  137. tdmSpawns = getEntArray( "mp_tdm_spawn" , "classname" );
  138. lowSpawn = undefined;
  139.  
  140. foreach ( lspawn in tdmSpawns )
  141. {
  142. if ( !isDefined( lowSpawn ) || lspawn.origin[2] < lowSpawn.origin[2] )
  143. {
  144. lowSpawn = lspawn;
  145. }
  146. }
  147. level.lowSpawn = lowSpawn;
  148.  
  149. }
  150.  
  151. addCrateType( dropType, crateType, crateWeight, crateFunc )
  152. {
  153. level.crateTypes[dropType][crateType] = crateWeight;
  154. level.crateFuncs[dropType][crateType] = crateFunc;
  155. }
  156.  
  157.  
  158. getRandomCrateType( dropType )
  159. {
  160. value = randomInt( level.crateMaxVal[dropType] );
  161.  
  162. selectedCrateType = undefined;
  163. foreach ( crateType, crateWeight in level.crateTypes[dropType] )
  164. {
  165. if ( !crateWeight )
  166. continue;
  167.  
  168. selectedCrateType = crateType;
  169.  
  170. if ( crateWeight > value )
  171. break;
  172. }
  173.  
  174. return( selectedCrateType );
  175. }
  176.  
  177.  
  178. getCrateTypeForDropType( dropType )
  179. {
  180. switch ( dropType )
  181. {
  182. case "airdrop_sentry_minigun":
  183. return "sentry";
  184. case "airdrop_predator_missile":
  185. return "predator_missile";
  186. case "airdrop":
  187. return getRandomCrateType( "airdrop" );
  188. case "airdrop_mega":
  189. return getRandomCrateType( "airdrop_mega" );
  190. case "nuke_drop":
  191. return "nuke";
  192. default:
  193. return getRandomCrateType( "airdrop" );
  194.  
  195. }
  196. }
  197.  
  198.  
  199. /**********************************************************
  200. * Helper/Debug functions
  201. ***********************************************************/
  202.  
  203. drawLine( start, end, timeSlice )
  204. {
  205. drawTime = int(timeSlice * 20);
  206. for( time = 0; time < drawTime; time++ )
  207. {
  208. line( start, end, (1,0,0),false, 1 );
  209. wait ( 0.05 );
  210. }
  211. }
  212.  
  213. /**********************************************************
  214. * Usage functions
  215. ***********************************************************/
  216.  
  217. tryUseAirdropPredatorMissile( lifeId )
  218. {
  219. return ( self tryUseAirdrop( lifeId , "airdrop_predator_missile" ) );
  220. }
  221.  
  222. tryUseAirdropSentryMinigun( lifeId )
  223. {
  224. return ( self tryUseAirdrop( lifeId, "airdrop_sentry_minigun" ) );
  225. }
  226.  
  227. tryUseMegaAirdrop( lifeId )
  228. {
  229. return ( self tryUseAirdrop( lifeId, "airdrop_mega" ) );
  230. }
  231.  
  232. tryUseAirdrop( lifeId, dropType )
  233. {
  234. result = undefined;
  235.  
  236. if ( !isDefined( dropType ) )
  237. dropType = "airdrop";
  238.  
  239. if ( level.littleBirds >= 3 && dropType != "airdrop_mega" )
  240. {
  241. self iPrintLnBold( &"MP_AIR_SPACE_TOO_CROWDED" );
  242. return false;
  243. }
  244.  
  245. if ( isDefined( level.civilianJetFlyBy ) )
  246. {
  247. self iPrintLnBold( &"MP_CIVILIAN_AIR_TRAFFIC" );
  248. return false;
  249. }
  250.  
  251. if ( self isUsingRemote() )
  252. {
  253. return false;
  254. }
  255.  
  256. if ( dropType != "airdrop_mega" )
  257. {
  258. level.littleBirds++;
  259. self thread watchDisconnect();
  260. }
  261.  
  262. result = self beginAirdropViaMarker( lifeId, dropType );
  263.  
  264. if ( (!isDefined( result ) || !result) && !isDefined( self.airDropMarker ) )
  265. {
  266. self notify( "markerDetermined" );
  267.  
  268. if ( dropType != "airdrop_mega" )
  269. level.littleBirds--;
  270.  
  271. return false;
  272. }
  273.  
  274. if ( dropType == "airdrop_mega" )
  275. thread teamPlayerCardSplash( "used_airdrop_mega", self );
  276.  
  277. self notify( "markerDetermined" );
  278. return true;
  279. }
  280.  
  281. watchDisconnect()
  282. {
  283. self endon( "markerDetermined" );
  284.  
  285. self waittill( "disconnect" );
  286. level.littleBirds--;
  287. return;
  288. }
  289.  
  290.  
  291. /**********************************************************
  292. * Marker functions
  293. ***********************************************************/
  294.  
  295. beginAirdropViaMarker( lifeId, dropType )
  296. {
  297. self endon ( "death" );
  298. self endon ( "grenade_fire" );
  299. self.airDropMarker = undefined;
  300.  
  301. self thread watchAirDropMarkerUsage( dropType );
  302.  
  303. while( self isChangingWeapon() )
  304. wait ( 0.05 );
  305.  
  306. currentWeapon = self getCurrentWeapon();
  307.  
  308. if ( isAirdropMarker( currentWeapon ) )
  309. airdropMarkerWeapon = currentWeapon;
  310. else
  311. airdropMarkerWeapon = undefined;
  312.  
  313. while( isAirdropMarker( currentWeapon ) )
  314. {
  315. self waittill( "weapon_change", currentWeapon );
  316.  
  317. if ( isAirdropMarker( currentWeapon ) )
  318. airdropMarkerWeapon = currentWeapon;
  319. }
  320.  
  321. self notify ( "stopWatchingAirDropMarker" );
  322.  
  323. if ( !isDefined( airdropMarkerWeapon ) )
  324. return false;
  325.  
  326. return( !(self getAmmoCount( airdropMarkerWeapon ) && self hasWeapon( airdropMarkerWeapon )) );
  327. }
  328.  
  329.  
  330. watchAirDropMarkerUsage( dropType )
  331. {
  332. self notify( "watchAirDropMarkerUsage" );
  333.  
  334. self endon( "disconnect" );
  335. self endon( "watchAirDropMarkerUsage" );
  336. self endon( "stopWatchingAirDropMarker" );
  337.  
  338. thread watchAirDropMarker( dropType );
  339.  
  340. for ( ;; )
  341. {
  342. self waittill( "grenade_pullback", weaponName );
  343.  
  344. if ( !isAirdropMarker( weaponName ) )
  345. continue;
  346.  
  347. self _disableUsability();
  348.  
  349. self beginAirDropMarkerTracking();
  350. }
  351. }
  352.  
  353. watchAirDropMarker( dropType )
  354. {
  355. self notify( "watchAirDropMarker" );
  356.  
  357. self endon( "watchAirDropMarker" );
  358. self endon( "spawned_player" );
  359. self endon( "disconnect" );
  360.  
  361. for ( ;; )
  362. {
  363. self waittill( "grenade_fire", airDropWeapon, weapname );
  364.  
  365. if ( !isAirdropMarker( weapname ) )
  366. continue;
  367.  
  368. airDropWeapon thread airdropDetonateOnStuck();
  369.  
  370. airDropWeapon.owner = self;
  371. airDropWeapon.weaponName = weapname;
  372. self.airDropMarker = airDropWeapon;
  373.  
  374. airDropWeapon thread airDropMarkerActivate( dropType );
  375. }
  376. }
  377.  
  378. beginAirDropMarkerTracking()
  379. {
  380. self notify( "beginAirDropMarkerTracking" );
  381. self endon( "beginAirDropMarkerTracking" );
  382. self endon( "death" );
  383. self endon( "disconnect" );
  384.  
  385. self waittill_any( "grenade_fire", "weapon_change" );
  386. self _enableUsability();
  387. }
  388.  
  389. airDropMarkerActivate( dropType )
  390. {
  391. self notify( "airDropMarkerActivate" );
  392. self endon( "airDropMarkerActivate" );
  393. self waittill( "explode", position );
  394. owner = self.owner;
  395.  
  396. if ( !isDefined( owner ) )
  397. return;
  398.  
  399. if ( owner isEMPed() )
  400. return;
  401.  
  402. if ( dropType != "airdrop_mega" )
  403. owner maps\mp\_matchdata::logKillstreakEvent( dropType, position );
  404.  
  405. wait 0.05;
  406.  
  407. if ( dropType != "airdrop_mega" )
  408. level doFlyBy( owner, position, randomFloat( 360 ), dropType );
  409. else
  410. level doC130FlyBy( owner, position, randomFloat( 360 ), dropType );
  411. }
  412.  
  413. /**********************************************************
  414. * crate functions
  415. ***********************************************************/
  416. initAirDropCrate()
  417. {
  418. self.inUse = false;
  419. self hide();
  420.  
  421. if ( isDefined( self.target ) )
  422. {
  423. self.collision = getEnt( self.target, "targetname" );
  424. self.collision notSolid();
  425. }
  426. else
  427. {
  428. self.collision = undefined;
  429. }
  430. }
  431.  
  432.  
  433. deleteOnOwnerDeath( owner )
  434. {
  435. wait ( 0.25 );
  436. self linkTo( owner, "tag_origin", (0,0,0), (0,0,0) );
  437.  
  438. owner waittill ( "death" );
  439.  
  440. self delete();
  441. }
  442.  
  443.  
  444.  
  445. crateModelTeamUpdater( showForTeam )
  446. {
  447. self endon ( "death" );
  448.  
  449. self hide();
  450.  
  451. foreach ( player in level.players )
  452. {
  453. if ( player.team == showForTeam )
  454. self showToPlayer( player );
  455. }
  456.  
  457. for ( ;; )
  458. {
  459. level waittill ( "joined_team" );
  460.  
  461. self hide();
  462. foreach ( player in level.players )
  463. {
  464. if ( player.team == showForTeam )
  465. self showToPlayer( player );
  466. }
  467. }
  468. }
  469.  
  470.  
  471. createAirDropCrate( owner, dropType, crateType, startPos )
  472. {
  473. dropCrate = spawn( "script_model", startPos );
  474.  
  475. dropCrate.curProgress = 0;
  476. dropCrate.useTime = 0;
  477. dropCrate.useRate = 0;
  478. dropCrate.team = self.team;
  479.  
  480. if ( isDefined( owner ) )
  481. dropCrate.owner = owner;
  482. else
  483. dropCrate.owner = undefined;
  484.  
  485. dropCrate.crateType = crateType;
  486. dropCrate.dropType = dropType;
  487. dropCrate.targetname = "care_package";
  488.  
  489. dropCrate setModel( maps\mp\gametypes\_teams::getTeamCrateModel( dropCrate.team ) );
  490.  
  491. dropCrate.friendlyModel = spawn( "script_model", startPos );
  492. dropCrate.friendlyModel setModel( "com_plasticcase_friendly" );
  493. dropCrate.enemyModel = spawn( "script_model", startPos );
  494. dropCrate.enemyModel setModel( "com_plasticcase_enemy" );
  495.  
  496. dropCrate.friendlyModel thread deleteOnOwnerDeath( dropCrate );
  497. dropCrate.friendlyModel thread crateModelTeamUpdater( dropCrate.team );
  498.  
  499. dropCrate.enemyModel thread deleteOnOwnerDeath( dropCrate );
  500. dropCrate.enemyModel thread crateModelTeamUpdater( level.otherTeam[dropCrate.team] );
  501.  
  502. dropCrate.inUse = false;
  503.  
  504. dropCrate CloneBrushmodelToScriptmodel( level.airDropCrateCollision );
  505.  
  506. return dropCrate;
  507. }
  508.  
  509.  
  510. crateSetupForUse( hintString, mode, icon )
  511. {
  512.  
  513. if ( mode != "nukeDrop" )
  514. {
  515. self setCursorHint( "HINT_NOICON" );
  516. self setHintString( hintString );
  517. self makeUsable();
  518. }
  519.  
  520. self.mode = mode;
  521.  
  522. if ( level.teamBased )
  523. {
  524. curObjID = maps\mp\gametypes\_gameobjects::getNextObjID();
  525. objective_add( curObjID, "invisible", (0,0,0) );
  526. objective_position( curObjID, self.origin );
  527. objective_state( curObjID, "active" );
  528. objective_team( curObjID, self.team );
  529. objective_icon( curObjID, "compass_objpoint_ammo_friendly" );
  530. self.objIdFriendly = curObjID;
  531.  
  532. curObjID = maps\mp\gametypes\_gameobjects::getNextObjID();
  533. objective_add( curObjID, "invisible", (0,0,0) );
  534. objective_position( curObjID, self.origin );
  535. objective_state( curObjID, "active" );
  536. objective_team( curObjID, level.otherTeam[self.team] );
  537. objective_icon( curObjID, "compass_objpoint_ammo_enemy" );
  538. self.objIdEnemy = curObjID;
  539. }
  540.  
  541. if ( !level.teamBased )
  542. {
  543. curObjID = maps\mp\gametypes\_gameobjects::getNextObjID();
  544. objective_add( curObjID, "invisible", (0,0,0) );
  545. objective_position( curObjID, self.origin );
  546. objective_state( curObjID, "active" );
  547. objective_icon( curObjID, "compass_objpoint_ammo_friendly" );
  548. self.objIdFriendly = curObjID;
  549.  
  550. if ( isDefined( self.owner ) )
  551. self maps\mp\_entityheadIcons::setHeadIcon( self.owner, icon, (0,0,24), 14, 14 );
  552. }
  553. else if ( mode == "single" && isDefined( self.owner ) )
  554. {
  555. setSelfAndEnemyUsable( self.owner );
  556.  
  557. self maps\mp\_entityheadIcons::setHeadIcon( self.owner, icon, (0,0,24), 14, 14 );
  558. }
  559. else if ( mode == "team" )
  560. {
  561. self setUsableOnceByTeam( self.team );
  562. self thread checkChange( self.team );
  563.  
  564. self maps\mp\_entityheadIcons::setHeadIcon( self.team, icon, (0,0,24), 14, 14 );
  565. }
  566. else if ( mode == "nukeDrop" )
  567. {
  568. self maps\mp\_entityheadIcons::setHeadIcon( self.team, icon, (0,0,24), 14, 14 );
  569. self maps\mp\_entityheadIcons::setHeadIcon( getOtherTeam( self.team ), icon, (0,0,24), 14, 14 );
  570. level.nukeCrate = self;
  571. level.nukeCrate notify( "nukeLanded" );
  572. }
  573. else
  574. {
  575. self setUsableByTeam();
  576.  
  577. self maps\mp\_entityheadIcons::setHeadIcon( self.team, icon, (0,0,24), 14, 14 );
  578. }
  579. }
  580.  
  581. checkChange( team )
  582. {
  583. self endon ( "death" );
  584.  
  585. for ( ;; )
  586. {
  587. level waittill ( "joined_team" );
  588.  
  589. self setUnUsable( team );
  590. wait .25;
  591. }
  592. }
  593.  
  594.  
  595. setSelfAndEnemyUsable( owner )
  596. {
  597. foreach ( player in level.players )
  598. {
  599. if ( player != owner && player.team == self.team )
  600. self disablePlayerUse( player );
  601. else
  602. self enablePlayerUse( player );
  603. }
  604.  
  605. }
  606.  
  607. setUnUsable( team )
  608. {
  609. foreach ( player in level.players )
  610. {
  611. if (team != player.team)
  612. self disablePlayerUse( player );
  613. }
  614. }
  615.  
  616. setUsableByTeam( team )
  617. {
  618. foreach ( player in level.players )
  619. {
  620. if ( !isDefined( team ) )
  621. self enablePlayerUse( player );
  622. else if ( team == player.team )
  623. self enablePlayerUse( player );
  624. else
  625. self disablePlayerUse( player );
  626. }
  627. }
  628.  
  629.  
  630. setUsableOnceByTeam( team )
  631. {
  632. foreach ( player in level.players )
  633. {
  634. if ( isDefined( self.usedBy[ player.guid ] ) )
  635. self disablePlayerUse( player );
  636. else if ( !isDefined( team ) )
  637. self enablePlayerUse( player );
  638. else if ( team == player.team )
  639. self enablePlayerUse( player );
  640. else
  641. self disablePlayerUse( player );
  642. }
  643. }
  644.  
  645.  
  646. dropTheCrate( dropPoint, dropType, lbHeight, dropImmediately, crateOverride, startPos )
  647. {
  648. dropCrate = [];
  649. self.owner endon ( "disconnect" );
  650.  
  651. if ( !isDefined( crateOverride ) )
  652. crateType = getCrateTypeForDropType( dropType );
  653. else
  654. crateType = crateOverride;
  655.  
  656. dropCrate = createAirDropCrate( self.owner, dropType, crateType, startPos );
  657.  
  658. if( dropType == "airdrop_mega" || dropType == "nuke_drop")
  659. dropCrate LinkTo( self, "tag_ground" , (64,32,-128) , (0,0,0) );
  660. else
  661. dropCrate LinkTo( self, "tag_ground" , (32,0,5) , (0,0,0) );
  662.  
  663. dropCrate.angles = (0,0,0);
  664. dropCrate show();
  665. dropSpeed = self.veh_speed;
  666.  
  667. self waittill ( "drop_crate" );
  668.  
  669. dropCrate Unlink();
  670. dropCrate PhysicsLaunchServer( (0,0,0), (randomInt(5),randomInt(5),randomInt(5)) );
  671. dropCrate thread physicsWaiter( dropType, crateType );
  672. }
  673.  
  674.  
  675. physicsWaiter( dropType, crateType )
  676. {
  677. self waittill( "physics_finished" );
  678.  
  679. self thread [[ level.crateFuncs[ dropType ][ crateType ] ]]( dropType );
  680. level thread dropTimeOut( self, self.owner );
  681.  
  682. if ( abs(self.origin[2] - level.lowSpawn.origin[2]) > 3000 )
  683. {
  684. if ( isDefined( self.objIdFriendly ) )
  685. _objective_delete( self.objIdFriendly );
  686.  
  687. if ( isDefined( self.objIdEnemy ) )
  688. _objective_delete( self.objIdEnemy );
  689.  
  690. self delete();
  691. }
  692. }
  693.  
  694.  
  695. //deletes if crate wasnt used after 90 seconds
  696. dropTimeOut( dropCrate, owner )
  697. {
  698. level endon ( "game_ended" );
  699. dropCrate endon( "death" );
  700.  
  701. if ( dropCrate.dropType == "nuke_drop" )
  702. return;
  703.  
  704. maps\mp\gametypes\_hostmigration::waitLongDurationWithHostMigrationPause( 90.0 );
  705.  
  706. while ( dropCrate.curProgress != 0 )
  707. wait 1;
  708.  
  709. if ( isDefined( dropcrate.objIdFriendly ) )
  710. _objective_delete( dropcrate.objIdFriendly );
  711.  
  712. if ( isDefined( dropcrate.objIdEnemy ) )
  713. _objective_delete( dropcrate.objIdEnemy );
  714.  
  715. dropCrate delete();
  716. }
  717.  
  718.  
  719. getPathStart( coord, yaw )
  720. {
  721. pathRandomness = 100;
  722. lbHalfDistance = 15000;
  723.  
  724. direction = (0,yaw,0);
  725.  
  726. startPoint = coord + vector_multiply( anglestoforward( direction ), -1 * lbHalfDistance );
  727. startPoint += ( (randomfloat(2) - 1)*pathRandomness, (randomfloat(2) - 1)*pathRandomness, 0 );
  728.  
  729. return startPoint;
  730. }
  731.  
  732.  
  733. getPathEnd( coord, yaw )
  734. {
  735. pathRandomness = 150;
  736. lbHalfDistance = 15000;
  737.  
  738. direction = (0,yaw,0);
  739.  
  740. endPoint = coord + vector_multiply( anglestoforward( direction + ( 0,90,0 ) ), lbHalfDistance );
  741. endPoint += ( (randomfloat(2) - 1)*pathRandomness , (randomfloat(2) - 1)*pathRandomness , 0 );
  742.  
  743. return endPoint;
  744. }
  745.  
  746.  
  747. getFlyHeightOffset( dropSite )
  748. {
  749. lbFlyHeight = 850;
  750.  
  751. heightEnt = GetEnt( "airstrikeheight", "targetname" );
  752.  
  753. if ( !isDefined( heightEnt ) )//old system
  754. {
  755. /#
  756. println( "NO DEFINED AIRSTRIKE HEIGHT SCRIPT_ORIGIN IN LEVEL" );
  757. #/
  758. if ( isDefined( level.airstrikeHeightScale ) )
  759. {
  760. if ( level.airstrikeHeightScale > 2 )
  761. {
  762. lbFlyHeight = 1500;
  763. return( lbFlyHeight * (level.airStrikeHeightScale ) );
  764. }
  765.  
  766. return( lbFlyHeight * level.airStrikeHeightScale + 256 + dropSite[2] );
  767. }
  768. else
  769. return ( lbFlyHeight + dropsite[2] );
  770. }
  771. else
  772. {
  773. return heightEnt.origin[2];
  774. }
  775.  
  776. }
  777.  
  778.  
  779. /**********************************************************
  780. * Helicopter Functions
  781. ***********************************************************/
  782.  
  783. doFlyBy( owner, dropSite, dropYaw, dropType, heightAdjustment )
  784. {
  785. flyHeight = self getFlyHeightOffset( dropSite );
  786. if ( !isDefined(heightAdjustment) )
  787. heightAdjustment = 0;
  788.  
  789. flyHeight += heightAdjustment;
  790.  
  791. if ( !isDefined( owner ) )
  792. return;
  793.  
  794. pathGoal = dropSite * (1,1,0) + (0,0,flyHeight);
  795. pathStart = getPathStart( pathGoal, dropYaw );
  796. pathEnd = getPathEnd( pathGoal, dropYaw );
  797.  
  798. pathGoal = pathGoal + vector_multiply( anglestoforward( (0,dropYaw,0) ), -50 );
  799.  
  800. chopper = heliSetup( owner, pathStart, pathGoal );
  801.  
  802. chopper endon( "death" );
  803.  
  804. chopper.dropType = dropType;
  805. assert ( isDefined( chopper ) );
  806.  
  807. chopper setVehGoalPos( pathGoal, 1 );
  808.  
  809. chopper thread dropTheCrate( dropSite, dropType, flyHeight, false, undefined , pathStart );
  810.  
  811. wait ( 2 );
  812.  
  813. chopper Vehicle_SetSpeed( 75, 40 );
  814. chopper SetYawSpeed( 180, 180, 180, .3 );
  815.  
  816. chopper waittill ( "goal" );
  817. wait( .10 );
  818. chopper notify( "drop_crate" );
  819. chopper setvehgoalpos( pathEnd, 1 );
  820. chopper Vehicle_SetSpeed( 300, 75 );
  821. chopper.leaving = true;
  822. chopper waittill ( "goal" );
  823. chopper notify( "leaving" );
  824. chopper trimActiveBirdList();
  825. level.littleBirds--;
  826. chopper notify( "delete" );
  827. chopper delete();
  828. }
  829.  
  830. doMegaFlyBy( owner, dropSite, dropYaw, dropType )
  831. {
  832. level thread doFlyBy( owner, dropSite, dropYaw, dropType, 0 );
  833. wait( RandomIntRange( 1,2 ) );
  834. level thread doFlyBy( owner, dropSite + (128,128,0), dropYaw, dropType, 128 );
  835. wait( RandomIntRange( 1,2 ) );
  836. level thread doFlyBy( owner, dropSite + (172,256,0), dropYaw, dropType, 256 );
  837. wait( RandomIntRange( 1,2 ) );
  838. level thread doFlyBy( owner, dropSite + (64,0,0), dropYaw, dropType, 0 );
  839. }
  840.  
  841. doC130FlyBy( owner, dropSite, dropYaw, dropType )
  842. {
  843. planeHalfDistance = 24000;
  844. planeFlySpeed = 2000;
  845. yaw = vectorToYaw( dropsite - owner.origin );
  846.  
  847. direction = ( 0, yaw, 0 );
  848.  
  849. flyHeight = self getFlyHeightOffset( dropSite );
  850.  
  851. pathStart = dropSite + vector_multiply( anglestoforward( direction ), -1 * planeHalfDistance );
  852. pathStart = pathStart * ( 1, 1, 0 ) + ( 0, 0, flyHeight );
  853.  
  854. pathEnd = dropSite + vector_multiply( anglestoforward( direction ), planeHalfDistance );
  855. pathEnd = pathEnd * ( 1, 1, 0 ) + ( 0, 0, flyHeight );
  856.  
  857. d = length( pathStart - pathEnd );
  858. flyTime = ( d / planeFlySpeed );
  859.  
  860. c130 = c130Setup( owner, pathStart, pathEnd );
  861. c130.veh_speed = planeFlySpeed;
  862. c130.dropType = dropType;
  863. c130 playloopsound( "veh_ac130_dist_loop" );
  864.  
  865. c130.angles = direction;
  866. forward = anglesToForward( direction );
  867. c130 moveTo( pathEnd, flyTime, 0, 0 );
  868.  
  869. minDist = distance2D( c130.origin, dropSite );
  870. boomPlayed = false;
  871.  
  872. for(;;)
  873. {
  874. dist = distance2D( c130.origin, dropSite );
  875.  
  876. // handle missing our target
  877. if ( dist < minDist )
  878. minDist = dist;
  879. else if ( dist > minDist )
  880. break;
  881.  
  882. if ( dist < 256 )
  883. {
  884. break;
  885. }
  886. else if ( dist < 768 )
  887. {
  888. earthquake( 0.15, 1.5, dropSite, 1500 );
  889. if ( !boomPlayed )
  890. {
  891. c130 playSound( "veh_ac130_sonic_boom" );
  892. //c130 thread stopLoopAfter( 0.5 );
  893. boomPlayed = true;
  894. }
  895. }
  896.  
  897. wait ( .05 );
  898. }
  899.  
  900. wait( 0.05 );
  901. c130 thread dropTheCrate( dropSite, dropType, flyHeight, false, undefined , pathStart );
  902. wait ( 0.05 );
  903. c130 notify ( "drop_crate" );
  904. wait ( 0.05 );
  905.  
  906. c130 thread dropTheCrate( dropSite, dropType, flyHeight, false, undefined , pathStart );
  907. wait ( 0.05 );
  908. c130 notify ( "drop_crate" );
  909. wait ( 0.05 );
  910.  
  911. c130 thread dropTheCrate( dropSite, dropType, flyHeight, false, undefined , pathStart );
  912. wait ( 0.05 );
  913. c130 notify ( "drop_crate" );
  914. wait ( 0.05 );
  915.  
  916. c130 thread dropTheCrate( dropSite, dropType, flyHeight, false, undefined , pathStart );
  917. wait ( 0.05 );
  918. c130 notify ( "drop_crate" );
  919.  
  920. wait ( 4 );
  921. c130 delete();
  922. }
  923.  
  924.  
  925. dropNuke( dropSite, owner, dropType )
  926. {
  927. planeHalfDistance = 24000;
  928. planeFlySpeed = 2000;
  929. yaw = RandomInt( 360 );
  930.  
  931. direction = ( 0, yaw, 0 );
  932.  
  933. flyHeight = self getFlyHeightOffset( dropSite );
  934.  
  935. pathStart = dropSite + vector_multiply( anglestoforward( direction ), -1 * planeHalfDistance );
  936. pathStart = pathStart * ( 1, 1, 0 ) + ( 0, 0, flyHeight );
  937.  
  938. pathEnd = dropSite + vector_multiply( anglestoforward( direction ), planeHalfDistance );
  939. pathEnd = pathEnd * ( 1, 1, 0 ) + ( 0, 0, flyHeight );
  940.  
  941. d = length( pathStart - pathEnd );
  942. flyTime = ( d / planeFlySpeed );
  943.  
  944. c130 = c130Setup( owner, pathStart, pathEnd );
  945. c130.veh_speed = planeFlySpeed;
  946. c130.dropType = dropType;
  947. c130 playloopsound( "veh_ac130_dist_loop" );
  948.  
  949. c130.angles = direction;
  950. forward = anglesToForward( direction );
  951. c130 moveTo( pathEnd, flyTime, 0, 0 );
  952.  
  953. // TODO: fix this... it's bad. if we miss our distance (which could happen if plane speed is changed in the future) we stick in this thread forever
  954. boomPlayed = false;
  955. minDist = distance2D( c130.origin, dropSite );
  956. for(;;)
  957. {
  958. dist = distance2D( c130.origin, dropSite );
  959.  
  960. // handle missing our target
  961. if ( dist < minDist )
  962. minDist = dist;
  963. else if ( dist > minDist )
  964. break;
  965.  
  966. if ( dist < 256 )
  967. {
  968. break;
  969. }
  970. else if ( dist < 768 )
  971. {
  972. earthquake( 0.15, 1.5, dropSite, 1500 );
  973. if ( !boomPlayed )
  974. {
  975. c130 playSound( "veh_ac130_sonic_boom" );
  976. //c130 thread stopLoopAfter( 0.5 );
  977. boomPlayed = true;
  978. }
  979. }
  980.  
  981. wait ( .05 );
  982. }
  983.  
  984. c130 thread dropTheCrate( dropSite, dropType, flyHeight, false, "nuke", pathStart );
  985. wait ( 0.05 );
  986. c130 notify ( "drop_crate" );
  987.  
  988. wait ( 4 );
  989. c130 delete();
  990. }
  991.  
  992. stopLoopAfter( delay )
  993. {
  994. self endon ( "death" );
  995.  
  996. wait ( delay );
  997. self stoploopsound();
  998. }
  999.  
  1000.  
  1001. playloopOnEnt( alias )
  1002. {
  1003. soundOrg = spawn( "script_origin", ( 0, 0, 0 ) );
  1004. soundOrg hide();
  1005. soundOrg endon( "death" );
  1006. thread delete_on_death( soundOrg );
  1007.  
  1008. soundOrg.origin = self.origin;
  1009. soundOrg.angles = self.angles;
  1010. soundOrg linkto( self );
  1011.  
  1012. soundOrg playloopsound( alias );
  1013.  
  1014. self waittill( "stop sound" + alias );
  1015. soundOrg stoploopsound( alias );
  1016. soundOrg delete();
  1017. }
  1018.  
  1019.  
  1020. // spawn C130 at a start node and monitors it
  1021. c130Setup( owner, pathStart, pathGoal )
  1022. {
  1023. forward = vectorToAngles( pathGoal - pathStart );
  1024. c130 = spawnplane( owner, "script_model", pathStart, "compass_objpoint_c130_friendly", "compass_objpoint_c130_enemy" );
  1025. c130 setModel( "vehicle_ac130_low_mp" );
  1026.  
  1027. if ( !isDefined( c130 ) )
  1028. return;
  1029.  
  1030. //chopper playLoopSound( "littlebird_move" );
  1031. c130.owner = owner;
  1032. c130.team = owner.team;
  1033. level.c130 = c130;
  1034.  
  1035. return c130;
  1036. }
  1037.  
  1038. // spawn helicopter at a start node and monitors it
  1039. heliSetup( owner, pathStart, pathGoal )
  1040. {
  1041.  
  1042. forward = vectorToAngles( pathGoal - pathStart );
  1043. chopper = spawnHelicopter( owner, pathStart, forward, "littlebird_mp" , "vehicle_little_bird_armed" );
  1044.  
  1045. if ( !isDefined( chopper ) )
  1046. return;
  1047.  
  1048. //chopper playLoopSound( "littlebird_move" );
  1049.  
  1050. chopper.health = 500;
  1051. chopper setCanDamage( true );
  1052. chopper.owner = owner;
  1053. chopper.team = owner.team;
  1054. chopper thread heli_existence();
  1055. chopper thread heliDestroyed();
  1056. chopper SetMaxPitchRoll( 45, 85 );
  1057. chopper Vehicle_SetSpeed( 250, 175 );
  1058. level.littlebird[level.littlebird.size] = chopper;
  1059.  
  1060. chopper.damageCallback = ::Callback_VehicleDamage;
  1061.  
  1062. return chopper;
  1063. }
  1064.  
  1065. heli_existence()
  1066. {
  1067. self waittill_any( "crashing", "leaving" );
  1068. self trimActiveBirdList();
  1069.  
  1070. self notify( "helicopter_gone" );
  1071. }
  1072.  
  1073. Callback_VehicleDamage( inflictor, attacker, damage, dFlags, meansOfDeath, weapon, point, dir, hitLoc, timeOffset, modelIndex, partName )
  1074. {
  1075. if ( ( attacker == self || ( isDefined( attacker.pers ) && attacker.pers["team"] == self.team ) ) && ( attacker != self.owner || meansOfDeath == "MOD_MELEE" ) )
  1076. return;
  1077.  
  1078. attacker maps\mp\gametypes\_damagefeedback::updateDamageFeedback( "" );
  1079.  
  1080. if ( self.health <= damage )
  1081. attacker notify( "destroyed_killstreak" );
  1082.  
  1083. self Vehicle_FinishDamage( inflictor, attacker, damage, dFlags, meansOfDeath, weapon, point, dir, hitLoc, timeOffset, modelIndex, partName );
  1084. }
  1085.  
  1086. heliDestroyed()
  1087. {
  1088. self endon( "leaving" );
  1089. self endon( "helicopter_gone" );
  1090.  
  1091. self waittill( "death" );
  1092.  
  1093. if (! isDefined(self) )
  1094. return;
  1095.  
  1096. self trimActiveBirdList();
  1097. level.littleBirds--;
  1098. self Vehicle_SetSpeed( 25, 5 );
  1099. self thread lbSpin( RandomIntRange(180, 220) );
  1100.  
  1101. wait( RandomFloatRange( .5, 1.5 ) );
  1102.  
  1103. self notify( "drop_crate" );
  1104.  
  1105. lbExplode();
  1106. }
  1107.  
  1108. // crash explosion
  1109. lbExplode()
  1110. {
  1111. forward = ( self.origin + ( 0, 0, 1 ) ) - self.origin;
  1112. playfx ( level.chopper_fx["explode"]["death"]["cobra"], self.origin, forward );
  1113.  
  1114. // play heli explosion sound
  1115. self playSound( "cobra_helicopter_crash" );
  1116. self notify ( "explode" );
  1117.  
  1118. self delete();
  1119. }
  1120.  
  1121.  
  1122. lbSpin( speed )
  1123. {
  1124. self endon( "explode" );
  1125.  
  1126. // tail explosion that caused the spinning
  1127. playfxontag( level.chopper_fx["explode"]["medium"], self, "tail_rotor_jnt" );
  1128. playfxontag( level.chopper_fx["fire"]["trail"]["medium"], self, "tail_rotor_jnt" );
  1129.  
  1130. self setyawspeed( speed, speed, speed );
  1131. while ( isdefined( self ) )
  1132. {
  1133. self settargetyaw( self.angles[1]+(speed*0.9) );
  1134. wait ( 1 );
  1135. }
  1136. }
  1137.  
  1138.  
  1139. trimActiveBirdList()
  1140. {
  1141. for ( i=0; i < level.littlebird.size; i++ )
  1142. {
  1143. if ( level.littlebird.size == 1 )
  1144. {
  1145. level.littlebird = [];
  1146. }
  1147. else if ( level.littlebird[i] == self )
  1148. {
  1149. level.littlebird[i] = level.littlebird[ level.littlebird.size - 1 ];
  1150. level.littlebird[ level.littlebird.size - 1 ] = undefined;
  1151. }
  1152. }
  1153. }
  1154.  
  1155. /**********************************************************
  1156. * crate trigger functions
  1157. ***********************************************************/
  1158.  
  1159. nukeCaptureThink()
  1160. {
  1161. while ( isDefined( self ) )
  1162. {
  1163. self waittill ( "trigger", player );
  1164.  
  1165. if ( !player isOnGround() )
  1166. continue;
  1167.  
  1168. if ( !useHoldThink( player ) )
  1169. continue;
  1170.  
  1171. self notify ( "captured", player );
  1172. }
  1173. }
  1174.  
  1175.  
  1176. crateOtherCaptureThink()
  1177. {
  1178. while ( isDefined( self ) )
  1179. {
  1180. self waittill ( "trigger", player );
  1181.  
  1182. //if ( !player isOnGround() )
  1183. // continue;
  1184.  
  1185. if ( isDefined( self.owner ) && player == self.owner )
  1186. continue;
  1187.  
  1188. useEnt = self createUseEnt();
  1189. result = useEnt useHoldThink( player );
  1190.  
  1191. if ( isDefined( useEnt ) )
  1192. useEnt delete();
  1193.  
  1194. if ( !result )
  1195. continue;
  1196.  
  1197. self notify ( "captured", player );
  1198. }
  1199. }
  1200.  
  1201. crateOwnerCaptureThink()
  1202. {
  1203. while ( isDefined( self ) )
  1204. {
  1205. self waittill ( "trigger", player );
  1206.  
  1207. //if ( !player isOnGround() )
  1208. // continue;
  1209.  
  1210. if ( isDefined( self.owner ) && player != self.owner )
  1211. continue;
  1212.  
  1213. if ( !useHoldThink( player, 500 ) )
  1214. continue;
  1215.  
  1216. self notify ( "captured", player );
  1217. }
  1218. }
  1219.  
  1220.  
  1221. killstreakCrateThink( dropType )
  1222. {
  1223. self endon ( "death" );
  1224.  
  1225. if ( isDefined( game["strings"][self.crateType + "_hint"] ) )
  1226. crateHint = game["strings"][self.crateType + "_hint"];
  1227. else
  1228. crateHint = &"PLATFORM_GET_KILLSTREAK";
  1229.  
  1230. crateSetupForUse( crateHint, "all", maps\mp\killstreaks\_killstreaks::getKillstreakCrateIcon( self.crateType ) );
  1231.  
  1232. self thread crateOtherCaptureThink();
  1233. self thread crateOwnerCaptureThink();
  1234.  
  1235. for ( ;; )
  1236. {
  1237. self waittill ( "captured", player );
  1238.  
  1239. if ( isDefined( self.owner ) && player != self.owner )
  1240. {
  1241. if ( !level.teamBased || player.team != self.team )
  1242. {
  1243. if ( dropType == "airdrop" )
  1244. {
  1245. player thread maps\mp\gametypes\_missions::genericChallenge( "hijacker_airdrop" );
  1246. player thread hijackNotify( self, "airdrop" );
  1247. }
  1248. else
  1249. {
  1250. player thread maps\mp\gametypes\_missions::genericChallenge( "hijacker_airdrop_mega" );
  1251. player thread hijackNotify( self, "emergency_airdrop" );
  1252. }
  1253. }
  1254. else
  1255. {
  1256. self.owner thread maps\mp\gametypes\_rank::giveRankXP( "killstreak_giveaway", maps\mp\killstreaks\_killstreaks::getStreakCost( self.crateType ) * 50 );
  1257. //self.owner maps\mp\gametypes\_hud_message::playerCardSplashNotify( "giveaway_airdrop", player );
  1258. self.owner thread maps\mp\gametypes\_hud_message::SplashNotifyDelayed( "sharepackage", maps\mp\killstreaks\_killstreaks::getStreakCost( self.crateType ) * 50 );
  1259. }
  1260. }
  1261.  
  1262. player playLocalSound( "ammo_crate_use" );
  1263. player thread maps\mp\killstreaks\_killstreaks::giveKillstreak( self.crateType, false, false, self.owner );
  1264.  
  1265. player maps\mp\gametypes\_hud_message::killstreakSplashNotify( self.crateType, undefined, "pickup" );
  1266.  
  1267. self deleteCrate();
  1268. }
  1269. }
  1270.  
  1271.  
  1272. nukeCrateThink( dropType )
  1273. {
  1274. self endon ( "death" );
  1275.  
  1276. crateSetupForUse( &"PLATFORM_CALL_NUKE", "nukeDrop", maps\mp\killstreaks\_killstreaks::getKillstreakCrateIcon( self.crateType ) );
  1277.  
  1278. self thread nukeCaptureThink();
  1279.  
  1280. for ( ;; )
  1281. {
  1282. self waittill ( "captured", player );
  1283.  
  1284. player thread [[ level.killstreakFuncs[ self.crateType ] ]]( level.gtnw );
  1285. level notify( "nukeCaptured", player );
  1286.  
  1287. if ( isDefined( level.gtnw ) && level.gtnw )
  1288. player.capturedNuke = 1;
  1289.  
  1290. player playLocalSound( "ammo_crate_use" );
  1291. self deleteCrate();
  1292. }
  1293. }
  1294.  
  1295.  
  1296. sentryCrateThink( dropType )
  1297. {
  1298. self endon ( "death" );
  1299.  
  1300. crateSetupForUse( game["strings"]["sentry_hint"], "all", maps\mp\killstreaks\_killstreaks::getKillstreakCrateIcon( self.crateType ) );
  1301.  
  1302. self thread crateOtherCaptureThink();
  1303. self thread crateOwnerCaptureThink();
  1304.  
  1305. for ( ;; )
  1306. {
  1307. self waittill ( "captured", player );
  1308.  
  1309. if ( isDefined( self.owner ) && player != self.owner )
  1310. {
  1311. if ( !level.teamBased || player.team != self.team )
  1312. {
  1313. if ( isSubStr(dropType, "airdrop_sentry" ) )
  1314. player thread hijackNotify( self, "sentry" );
  1315. else
  1316. player thread hijackNotify( self, "emergency_airdrop" );
  1317. }
  1318. else
  1319. {
  1320. self.owner thread maps\mp\gametypes\_rank::giveRankXP( "killstreak_giveaway", maps\mp\killstreaks\_killstreaks::getStreakCost( "sentry" ) * 50 );
  1321. self.owner maps\mp\gametypes\_hud_message::playerCardSplashNotify( "giveaway_sentry", player );
  1322. }
  1323. }
  1324.  
  1325. player playLocalSound( "ammo_crate_use" );
  1326. player thread sentryUseTracker();
  1327.  
  1328. self deleteCrate();
  1329. }
  1330. }
  1331.  
  1332. deleteCrate()
  1333. {
  1334. if ( isDefined( self.objIdFriendly ) )
  1335. _objective_delete( self.objIdFriendly );
  1336.  
  1337. if ( isDefined( self.objIdEnemy ) )
  1338. _objective_delete( self.objIdEnemy );
  1339.  
  1340. self delete();
  1341. }
  1342.  
  1343. sentryUseTracker()
  1344. {
  1345. if ( !self maps\mp\killstreaks\_autosentry::giveSentry( "sentry_minigun" ) )
  1346. self maps\mp\killstreaks\_killstreaks::giveKillstreak( "sentry" );
  1347. }
  1348.  
  1349.  
  1350. ammoCrateThink( dropType )
  1351. {
  1352. self endon ( "death" );
  1353. self.usedBy = [];
  1354.  
  1355. if ( dropType == "airdrop" || !level.teamBased )
  1356. crateSetupForUse( game["strings"]["ammo_hint"], "all", "waypoint_ammo_friendly" );
  1357. else
  1358. crateSetupForUse( game["strings"]["ammo_hint"], "all", "waypoint_ammo_friendly" );
  1359.  
  1360. self thread crateOtherCaptureThink();
  1361. self thread crateOwnerCaptureThink();
  1362.  
  1363. for ( ;; )
  1364. {
  1365. self waittill ( "captured", player );
  1366.  
  1367. if ( isDefined( self.owner ) && player != self.owner )
  1368. {
  1369. if ( !level.teamBased || player.team != self.team )
  1370. {
  1371. if ( dropType == "airdrop" )
  1372. player thread hijackNotify( self, "airdrop" );
  1373. else
  1374. player thread hijackNotify( self, "emergency_airdrop" );
  1375. }
  1376. }
  1377.  
  1378. player playLocalSound( "ammo_crate_use" );
  1379. player refillAmmo();
  1380. self deleteCrate();
  1381. }
  1382. }
  1383.  
  1384.  
  1385. hijackNotify( crate, crateType )
  1386. {
  1387. self notify( "hijacker", crateType, crate.owner );
  1388. }
  1389.  
  1390.  
  1391. refillAmmo()
  1392. {
  1393. weaponList = self GetWeaponsListAll();
  1394.  
  1395. if ( self _hasPerk( "specialty_tacticalinsertion" ) && self getAmmoCount( "flare_mp" ) < 1 )
  1396. self _setPerk( "specialty_tacticalinsertion");
  1397.  
  1398. foreach ( weaponName in weaponList )
  1399. {
  1400. if ( isSubStr( weaponName, "grenade" ) )
  1401. {
  1402. if ( self getAmmoCount( weaponName ) >= 1 )
  1403. continue;
  1404. }
  1405.  
  1406. self giveMaxAmmo( weaponName );
  1407. }
  1408. }
  1409.  
  1410.  
  1411. /**********************************************************
  1412. * Capture crate functions
  1413. ***********************************************************/
  1414. useHoldThink( player, useTime )
  1415. {
  1416. player playerLinkTo( self );
  1417. player playerLinkedOffsetEnable();
  1418.  
  1419. player _disableWeapon();
  1420.  
  1421. self.curProgress = 0;
  1422. self.inUse = true;
  1423. self.useRate = 0;
  1424.  
  1425. if ( isDefined( useTime ) )
  1426. self.useTime = useTime;
  1427. else
  1428. self.useTime = 3000;
  1429.  
  1430. player thread personalUseBar( self );
  1431.  
  1432. result = useHoldThinkLoop( player );
  1433. assert ( isDefined( result ) );
  1434.  
  1435. if ( isAlive( player ) )
  1436. {
  1437. player _enableWeapon();
  1438. player unlink();
  1439. }
  1440.  
  1441. if ( !isDefined( self ) )
  1442. return false;
  1443.  
  1444. self.inUse = false;
  1445. self.curProgress = 0;
  1446.  
  1447. return ( result );
  1448. }
  1449.  
  1450.  
  1451. personalUseBar( object )
  1452. {
  1453. self endon( "disconnect" );
  1454.  
  1455. useBar = createPrimaryProgressBar( -25 );
  1456. useBarText = createPrimaryProgressBarText( -25 );
  1457. useBarText setText( &"MP_CAPTURING_CRATE" );
  1458.  
  1459. lastRate = -1;
  1460. while ( isReallyAlive( self ) && isDefined( object ) && object.inUse && !level.gameEnded )
  1461. {
  1462. if ( lastRate != object.useRate )
  1463. {
  1464. if( object.curProgress > object.useTime)
  1465. object.curProgress = object.useTime;
  1466.  
  1467. useBar updateBar( object.curProgress / object.useTime, (1000 / object.useTime) * object.useRate );
  1468.  
  1469. if ( !object.useRate )
  1470. {
  1471. useBar hideElem();
  1472. useBarText hideElem();
  1473. }
  1474. else
  1475. {
  1476. useBar showElem();
  1477. useBarText showElem();
  1478. }
  1479. }
  1480. lastRate = object.useRate;
  1481. wait ( 0.05 );
  1482. }
  1483.  
  1484. useBar destroyElem();
  1485. useBarText destroyElem();
  1486. }
  1487.  
  1488. useHoldThinkLoop( player )
  1489. {
  1490. while( !level.gameEnded && isDefined( self ) && isReallyAlive( player ) && player useButtonPressed() && self.curProgress < self.useTime )
  1491. {
  1492. self.curProgress += (50 * self.useRate);
  1493.  
  1494. if ( isDefined(self.objectiveScaler) )
  1495. self.useRate = 1 * self.objectiveScaler;
  1496. else
  1497. self.useRate = 1;
  1498.  
  1499. if ( self.curProgress >= self.useTime )
  1500. return ( isReallyAlive( player ) );
  1501.  
  1502. wait 0.05;
  1503. }
  1504.  
  1505. return false;
  1506. }
  1507.  
  1508. isAirdropMarker( weaponName )
  1509. {
  1510. switch ( weaponName )
  1511. {
  1512. case "airdrop_marker_mp":
  1513. case "airdrop_mega_marker_mp":
  1514. case "airdrop_sentry_marker_mp":
  1515. return true;
  1516. default:
  1517. return false;
  1518. }
  1519. }
  1520.  
  1521.  
  1522. createUseEnt()
  1523. {
  1524. useEnt = spawn( "script_origin", self.origin );
  1525. useEnt.curProgress = 0;
  1526. useEnt.useTime = 0;
  1527. useEnt.useRate = 3000;
  1528. useEnt.inUse = false;
  1529.  
  1530. useEnt thread deleteUseEnt( self );
  1531.  
  1532. return ( useEnt );
  1533. }
  1534.  
  1535.  
  1536. deleteUseEnt( owner )
  1537. {
  1538. self endon ( "death" );
  1539.  
  1540. owner waittill ( "death" );
  1541.  
  1542. self delete();
  1543. }
  1544.  
  1545.  
  1546. airdropDetonateOnStuck()
  1547. {
  1548. self endon ( "death" );
  1549.  
  1550. self waittill( "missile_stuck" );
  1551.  
  1552. self detonate();
  1553. }
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement
Public Pastes
Advertisement
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!