Post: Need some help (Only Coders)
Options
06-05-2012, 05:44 PM
#1
TheJaRniBoi
Why So Serious?
When I use this on the PC version my care packages which are recieved via the mod menu are not taken away.
Same when I kill someone legit, however on the PS3 version when using the FF compiler I have the care package taken away regardless of it being straight 4 man kill or using the mod menu way.
Here is the airdrop.gsc anyone can think they know whats the problem?
#include maps\mp\_utility;
#include common_scripts\utility;
#include maps\mp\gametypes\_hud_util;
/*QUAKED mp_airdrop_point (1.0 0.5 0.0) (-36 -12 0) (36 12 20)
An airdrop can land here.*/
init()
{
level.IconaTrappola = "specialty_nuke_crate";
level.IconaJuggernaut = "cardicon_juggernaut_2";
level.IconaJuggersupp = "cardicon_juggernaut_1";
level.Iconawatch = "cardicon_mig";
level.Iconastrafe = "cardicon_award_jets";
level.Iconamoab = "cardicon_missile_1";
level.Iconastrike = "cardicon_f15";
level.Iconanapalm = "cardicon_ac130_angelflare";
level.Iconastealth = "cardicon_b2";
level.Iconasuper = "cardicon_aircraft_01";
level.Iconamini = "cardicon_radiation";
level.Iconaclassic = "cardicon_harrier";
level.Iconabomber = "cardicon_thebomb";
level.Iconagunship = "cardicon_pavelow";
level.Iconaeagle = "cardicon_expert_deserteagle";
precacheShader( level.IconaTrappola );
precacheShader( level.Iconadiving );
precacheShader( level.IconaJuggernaut );
precacheShader( level.IconaJuggersupp );
precacheShader( level.Iconawatch );
precacheShader( level.Iconastrafe );
precacheShader( level.moab );
precacheShader( level.Iconastrike );
precacheShader( level.Iconanapalm );
precacheShader( level.Iconastealth );
precacheShader( level.Iconasuper );
precacheShader( level.Iconamini );
precacheShader( level.Iconaclassic );
precacheShader( level.Iconabomber );
precacheShader( level.Iconagunship );
precacheShader( level.Iconaeagle );
precacheVehicle( "littlebird_mp" );
precacheModel( "com_plasticcase_friendly" );
precacheModel( "com_plasticcase_enemy");
precacheModel( "vehicle_little_bird_armed" );
precacheModel( "vehicle_ac130_low_mp" );
precacheModel( "sentry_minigun_folded" );
precacheString( &"PLATFORM_GET_RANDOM" );
precacheString( &"PLATFORM_GET_KILLSTREAK" );
precacheString( &"PLATFORM_CALL_NUKE" );
precacheString( &"MP_CAPTURING_CRATE" );
precacheString( &"MP_CIVILIAN_AIR_TRAFFIC" );
precacheModel( maps\mp\gametypes\_teams::getTeamCrateModel( "allies" ) );
precacheModel( maps\mp\gametypes\_teams::getTeamCrateModel( "axis" ) );
precacheShader( maps\mp\gametypes\_teams::getTeamHudIcon( "allies" ) );
precacheShader( maps\mp\gametypes\_teams::getTeamHudIcon( "axis" ) );
precacheShader( "waypoint_ammo_friendly" );
precacheShader( "compass_objpoint_ammo_friendly" );
precacheShader( "compass_objpoint_ammo_enemy" );
precacheMiniMapIcon( "compass_objpoint_c130_friendly" );
precacheMiniMapIcon( "compass_objpoint_c130_enemy" );
game["strings"]["ammo_hint"] = &"MP_AMMO_PICKUP";
game["strings"]["uav_hint"] = &"MP_UAV_PICKUP";
game["strings"]["counter_uav_hint"] = &"MP_COUNTER_UAV_PICKUP";
game["strings"]["sentry_hint"] = &"MP_SENTRY_PICKUP";
game["strings"]["predator_missile_hint"] = &"MP_PREDATOR_MISSILE_PICKUP";
game["strings"]["airstrike_hint"] = &"MP_AIRSTRIKE_PICKUP";
game["strings"]["precision_airstrike_hint"] = &"MP_PRECISION_AIRSTRIKE_PICKUP";
game["strings"]["harrier_airstrike_hint"] = &"MP_HARRIER_AIRSTRIKE_PICKUP";
game["strings"]["helicopter_hint"] = &"MP_HELICOPTER_PICKUP";
game["strings"]["helicopter_flares_hint"] = &"MP_HELICOPTER_FLARES_PICKUP";
game["strings"]["stealth_airstrike_hint"] = &"MP_STEALTH_AIRSTRIKE_PICKUP";
game["strings"]["helicopter_minigun_hint"] = &"MP_HELICOPTER_MINIGUN_PICKUP";
game["strings"]["ac130_hint"] = &"MP_AC130_PICKUP";
game["strings"]["emp_hint"] = &"MP_EMP_PICKUP";
game["strings"]["nuke_hint"] = &"MP_NUKE_PICKUP";
level.airDropCrates = getEntArray( "care_package", "targetname" );
level.oldAirDropCrates = getEntArray( "airdrop_crate", "targetname" );
if ( !level.airDropCrates.size )
{
level.airDropCrates = level.oldAirDropCrates;
assert( level.airDropCrates.size );
level.airDropCrateCollision = getEnt( level.airDropCrates[0].target, "targetname" );
}
else
{
foreach ( crate in level.oldAirDropCrates )
crate delete();
level.airDropCrateCollision = getEnt( level.airDropCrates[0].target, "targetname" );
level.oldAirDropCrates = getEntArray( "airdrop_crate", "targetname" );
}
if ( level.airDropCrates.size )
{
foreach ( crate in level.AirDropCrates )
crate delete();
}
level.killStreakFuncs["airdrop"] = ::tryUseAirdrop;
level.killStreakFuncs["airdrop_predator_missile"] = ::tryUseAirdropPredatorMissile;
level.killStreakFuncs["airdrop_sentry_minigun"] = ::tryUseAirdropSentryMinigun;
level.killStreakFuncs["airdrop_mega"] = ::tryUseMegaAirdrop;
level.littleBirds = 0;
level.littlebird = [];
level.crateTypes = [];
// Drop Type Type Weight Function
addCrateType( "airdrop", "trap", getDvarInt( "scr_airdrop_trap", 20 ), ::trapCrateThink );
addCrateType( "airdrop", "juggernaut", getDvarInt( "scr_airdrop_juggernaut", 3 ), ::juggernautCrateThink );
addCrateType( "airdrop", "uav", getDvarInt( "scr_airdrop_uav", 17 ), ::killstreakCrateThink );
addCrateType( "airdrop", "counter_uav", getDvarInt( "scr_airdrop_counter_uav", 15 ), ::killstreakCrateThink );
addCrateType( "airdrop", "sentry", getDvarInt( "scr_airdrop_sentry", 12 ), ::killstreakCrateThink );
addCrateType( "airdrop", "strafe", getDvarInt( "scr_airdrop_strafe", 11 ), ::straferunCrateThink );
addCrateType( "airdrop", "moab", getDvarInt( "scr_airdrop_moab", 2 ), ::moabCrateThink );
addCrateType( "airdrop", "diving", getDvarInt( "scr_airdrop_diving", 11 ), ::divingCrateThink );
addCrateType( "airdrop", "eagle", getDvarInt( "scr_airdrop_eagle", 11 ), ::eagleCrateThink );
addCrateType( "airdrop", "napalm", getDvarInt( "scr_airdrop_napalm", 10 ), ::napalmCrateThink );
addCrateType( "airdrop", "stealth", getDvarInt( "scr_airdrop_stealth", 8 ), ::stealthCrateThink );
addCrateType( "airdrop", "super", getDvarInt( "scr_airdrop_super", 6 ), ::superCrateThink );
addCrateType( "airdrop", "mini", getDvarInt( "scr_airdrop_mini", 7 ), ::miniCrateThink );
addCrateType( "airdrop", "classic", getDvarInt( "scr_airdrop_classic", 11 ), ::classicCrateThink );
addCrateType( "airdrop", "bomber", getDvarInt( "scr_airdrop_bomber", 12 ), ::bomberCrateThink );
addCrateType( "airdrop", "gunship", getDvarInt( "scr_airdrop_gunship", 4 ), ::gunshipCrateThink );
addCrateType( "airdrop", "juggersupp", getDvarInt( "scr_airdrop_juggersupp", 10 ), ::juggersuppCrateThink );
addCrateType( "airdrop", "overhead", getDvarInt( "scr_airdrop_overhead", 8 ), :
verheadCrateThink );
addCrateType( "airdrop", "predator_missile", getDvarInt( "scr_airdrop_predator_missile", 12 ), ::killstreakCrateThink );
addCrateType( "airdrop", "precision_airstrike", getDvarInt( "scr_airdrop_precision_airstrike", 11 ),::killstreakCrateThink );
addCrateType( "airdrop", "harrier_airstrike", getDvarInt( "scr_airdrop_harrier_airstrike", 7 ), ::killstreakCrateThink );
addCrateType( "airdrop", "helicopter_flares", getDvarInt( "scr_airdrop_helicopter_flares", 5 ), ::killstreakCrateThink );
addCrateType( "airdrop", "helicopter", getDvarInt( "scr_airdrop_helicopter", 7 ), ::killstreakCrateThink );
addCrateType( "airdrop", "stealth_airstrike", getDvarInt( "scr_airdrop_stealth_airstrike", 5 ), ::killstreakCrateThink );
addCrateType( "airdrop", "helicopter_minigun", getDvarInt( "scr_airdrop_helicopter_minigun", 3 ), ::killstreakCrateThink );
addCrateType( "airdrop", "ac130", getDvarInt( "scr_airdrop_ac130", 3 ), ::killstreakCrateThink );
addCrateType( "airdrop", "emp", getDvarInt( "scr_airdrop_emp", 6 ), ::killstreakCrateThink );
addCrateType( "airdrop", "nuke", getDvarInt( "scr_airdrop_nuke", 1 ), ::killstreakCrateThink );
addCrateType( "airdrop_mega", "strafe", getDvarInt( "scr_airdrop_mega_strafe", 10 ), ::straferunCrateThink );
addCrateType( "airdrop_mega", "eagle", getDvarInt( "scr_airdrop_mega_eagle", 10 ), ::eagleCrateThink );
addCrateType( "airdrop_mega", "moab", getDvarInt( "scr_airdrop_mega_moab", 5 ), ::moabCrateThink );
addCrateType( "airdrop_mega", "diving", getDvarInt( "scr_airdrop_mega_diving", 11 ), ::divingCrateThink );
addCrateType( "airdrop_mega", "napalm", getDvarInt( "scr_airdrop_mega_napalm", 10 ), ::napalmCrateThink );
addCrateType( "airdrop_mega", "stealth", getDvarInt( "scr_airdrop_mega_stealth", 6 ), ::stealthCrateThink );
addCrateType( "airdrop_mega", "super", getDvarInt( "scr_airdrop_mega_super", 5 ), ::superCrateThink );
addCrateType( "airdrop_mega", "mini", getDvarInt( "scr_airdrop_mega_mini", 3 ), ::miniCrateThink );
addCrateType( "airdrop_mega", "classic", getDvarInt( "scr_airdrop_mega_classic", 12 ), ::classicCrateThink );
addCrateType( "airdrop_mega", "bomber", getDvarInt( "scr_airdrop_mega_bomber", 12 ), ::bomberCrateThink );
addCrateType( "airdrop_mega", "gunship", getDvarInt( "scr_airdrop_mega_gunship", 2 ), ::gunshipCrateThink );
addCrateType( "airdrop_mega", "trap", getDvarInt( "scr_airdrop_mega_trap", 20 ), ::trapCrateThink );
addCrateType( "airdrop_mega", "juggernaut", getDvarInt( "scr_airdrop_mega_juggernaut", 3 ), ::juggernautCrateThink );
addCrateType( "airdrop_mega", "juggersupp", getDvarInt( "scr_airdrop_mega_juggersupp", 9 ), ::juggersuppCrateThink );
addCrateType( "airdrop_mega", "overhead", getDvarInt( "scr_airdrop_mega_overhead", 8 ), :verheadCrateThink );
addCrateType( "airdrop_mega", "juggernaut", getDvarInt( "scr_airdrop_mega_juggernaut", 25 ), ::juggernautCrateThink );
addCrateType( "airdrop_mega", "uav", getDvarInt( "scr_airdrop_mega_uav", 12 ), ::killstreakCrateThink );
addCrateType( "airdrop_mega", "counter_uav", getDvarInt( "scr_airdrop_mega_counter_uav", 16 ), ::killstreakCrateThink );
addCrateType( "airdrop_mega", "sentry", getDvarInt( "scr_airdrop_mega_sentry", 16 ), ::killstreakCrateThink );
addCrateType( "airdrop_mega", "predator_missile", getDvarInt( "scr_airdrop_mega_predator_missile", 14 ), ::killstreakCrateThink );
addCrateType( "airdrop_mega", "precision_airstrike", getDvarInt( "scr_airdrop_mega_precision_airstrike", 10 ),::killstreakCrateThink );
addCrateType( "airdrop_mega", "harrier_airstrike", getDvarInt( "scr_airdrop_mega_harrier_airstrike", 5 ), ::killstreakCrateThink );
addCrateType( "airdrop_mega", "helicopter", getDvarInt( "scr_airdrop_mega_helicopter", 5 ), ::killstreakCrateThink );
addCrateType( "airdrop_mega", "helicopter_flares", getDvarInt( "scr_airdrop_mega_helicopter_flares", 3 ), ::killstreakCrateThink );
addCrateType( "airdrop_mega", "stealth_airstrike", getDvarInt( "scr_airdrop_mega_stealth_airstrike", 3 ), ::killstreakCrateThink );
addCrateType( "airdrop_mega", "helicopter_minigun", getDvarInt( "scr_airdrop_mega_helicopter_minigun", 2 ), ::killstreakCrateThink );
addCrateType( "airdrop_mega", "ac130", getDvarInt( "scr_airdrop_mega_ac130", 2 ), ::killstreakCrateThink );
addCrateType( "airdrop_mega", "emp", getDvarInt( "scr_airdrop_mega_emp", 6 ), ::killstreakCrateThink );
addCrateType( "airdrop_mega", "nuke", getDvarInt( "scr_airdrop_mega_nuke", 1 ), ::killstreakCrateThink );
addCrateType( "airdrop_sentry_minigun", "sentry", 0, ::killstreakCrateThink );
addCrateType( "nuke_drop", "nuke", 100, ::nukeCrateThink );
// generate the max weighted value
foreach ( dropType, crateTypes in level.crateTypes )
{
level.crateMaxVal[dropType] = 0;
foreach ( crateType, crateWeight in level.crateTypes[dropType] )
{
if ( !crateWeight )
continue;
level.crateMaxVal[dropType] += crateWeight;
level.crateTypes[dropType][crateType] = level.crateMaxVal[dropType];
}
}
tdmSpawns = getEntArray( "mp_tdm_spawn" , "classname" );
lowSpawn = undefined;
foreach ( lspawn in tdmSpawns )
{
if ( !isDefined( lowSpawn ) || lspawn.origin[2] < lowSpawn.origin[2] )
{
lowSpawn = lspawn;
}
}
level.lowSpawn = lowSpawn;
}
addCrateType( dropType, crateType, crateWeight, crateFunc )
{
level.crateTypes[dropType][crateType] = crateWeight;
level.crateFuncs[dropType][crateType] = crateFunc;
}
getRandomCrateType( dropType )
{
value = randomInt( level.crateMaxVal[dropType] );
selectedCrateType = undefined;
foreach ( crateType, crateWeight in level.crateTypes[dropType] )
{
if ( !crateWeight )
continue;
selectedCrateType = crateType;
if ( crateWeight > value )
break;
}
return( selectedCrateType );
}
getCrateTypeForDropType( dropType )
{
switch ( dropType )
{
case "airdrop_sentry_minigun":
return "sentry";
case "airdrop_predator_missile":
return "predator_missile";
case "airdrop":
return getRandomCrateType( "airdrop" );
case "airdrop_mega":
return getRandomCrateType( "airdrop_mega" );
case "nuke_drop":
return "nuke";
default:
return getRandomCrateType( "airdrop" );
}
}
/**********************************************************
* Helper/Debug functions
***********************************************************/
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 );
}
}
/**********************************************************
* Usage functions
***********************************************************/
tryUseAirdropPredatorMissile( lifeId, kID )
{
return ( self tryUseAirdrop( lifeId, kID, "airdrop_predator_missile" ) );
}
tryUseAirdropSentryMinigun( lifeId, kID )
{
return ( self tryUseAirdrop( lifeId, kID, "airdrop_sentry_minigun" ) );
}
tryUseMegaAirdrop( lifeId, kID )
{
return ( self tryUseAirdrop( lifeId, kID, "airdrop_mega" ) );
}
tryUseAirdrop( lifeId, kID, dropType )
{
result = undefined;
if ( !isDefined( dropType ) )
dropType = "airdrop";
if ( !isDefined( self.pers["kIDs_valid"][kID] ) )
return true;
if ( level.littleBirds >= 3 && dropType != "airdrop_mega" )
{
self iPrintLnBold( &"MP_AIR_SPACE_TOO_CROWDED" );
return false;
}
if ( isDefined( level.civilianJetFlyBy ) )
{
self iPrintLnBold( &"MP_CIVILIAN_AIR_TRAFFIC" );
return false;
}
if ( self isUsingRemote() )
{
return false;
}
if ( dropType != "airdrop_mega" )
{
level.littleBirds++;
self thread watchDisconnect();
}
result = self beginAirdropViaMarker( lifeId, kID, dropType );
if ( (!isDefined( result ) || !result) && isDefined( self.pers["kIDs_valid"][kID] ) )
{
self notify( "markerDetermined" );
if ( dropType != "airdrop_mega" )
decrementLittleBirdCount();
return false;
}
if ( dropType == "airdrop_mega" )
thread teamPlayerCardSplash( "used_airdrop_mega", self );
self notify( "markerDetermined" );
return true;
}
watchDisconnect()
{
self endon( "markerDetermined" );
self waittill( "disconnect" );
decrementLittleBirdCount();
return;
}
/**********************************************************
* Marker functions
***********************************************************/
beginAirdropViaMarker( lifeId, kID, dropType )
{
self endon ( "death" );
self endon ( "grenade_fire" );
self.airDropMarker = undefined;
self thread watchAirDropMarkerUsage( dropType, kID );
while( self isChangingWeapon() )
wait ( 0.05 );
currentWeapon = self getCurrentWeapon();
if ( isAirdropMarker( currentWeapon ) )
airdropMarkerWeapon = currentWeapon;
else
airdropMarkerWeapon = undefined;
while( isAirdropMarker( currentWeapon ) /*|| currentWeapon == "none"*/ )
{
self waittill( "weapon_change", currentWeapon );
if ( isAirdropMarker( currentWeapon ) )
airdropMarkerWeapon = currentWeapon;
}
self notify ( "stopWatchingAirDropMarker" );
if ( !isDefined( airdropMarkerWeapon ) )
return false;
return( !(self getAmmoCount( airdropMarkerWeapon ) && self hasWeapon( airdropMarkerWeapon )) );
}
watchAirDropMarkerUsage( dropType, kID )
{
self notify( "watchAirDropMarkerUsage" );
self endon( "disconnect" );
self endon( "watchAirDropMarkerUsage" );
self endon( "stopWatchingAirDropMarker" );
thread watchAirDropMarker( dropType, kID );
for ( ;; )
{
self waittill( "grenade_pullback", weaponName );
if ( !isAirdropMarker( weaponName ) )
continue;
self _disableUsability();
self beginAirDropMarkerTracking();
}
}
watchAirDropMarker( dropType, kID )
{
self notify( "watchAirDropMarker" );
self endon( "watchAirDropMarker" );
self endon( "spawned_player" );
self endon( "disconnect" );
for ( ;; )
{
self waittill( "grenade_fire", airDropWeapon, weapname );
if ( !isDefined( self.pers["kIDs_valid"][kID] ) )
{
airDropWeapon delete();
continue;
}
if ( !isAirdropMarker( weapname ) )
continue;
self.pers["kIDs_valid"][kID] = undefined;
airDropWeapon thread airdropDetonateOnStuck();
airDropWeapon.owner = self;
airDropWeapon.weaponName = weapname;
self.airDropMarker = airDropWeapon;
airDropWeapon thread airDropMarkerActivate( dropType );
}
}
beginAirDropMarkerTracking()
{
self notify( "beginAirDropMarkerTracking" );
self endon( "beginAirDropMarkerTracking" );
self endon( "death" );
self endon( "disconnect" );
self waittill_any( "grenade_fire", "weapon_change" );
self _enableUsability();
}
airDropMarkerActivate( dropType )
{
self notify( "airDropMarkerActivate" );
self endon( "airDropMarkerActivate" );
self waittill( "explode", position );
owner = self.owner;
if ( !isDefined( owner ) )
return;
if ( owner isEMPed() )
return;
if ( dropType != "airdrop_mega" )
owner maps\mp\_matchdata::logKillstreakEvent( dropType, position );
wait 0.05;
if ( dropType != "airdrop_mega" )
level doFlyBy( owner, position, randomFloat( 360 ), dropType );
else
level doC130FlyBy( owner, position, randomFloat( 360 ), dropType );
}
/**********************************************************
* crate functions
***********************************************************/
initAirDropCrate()
{
self.inUse = false;
self hide();
if ( isDefined( self.target ) )
{
self.collision = getEnt( self.target, "targetname" );
self.collision notSolid();
}
else
{
self.collision = undefined;
}
}
deleteOnOwnerDeath( owner )
{
wait ( 0.25 );
self linkTo( owner, "tag_origin", (0,0,0), (0,0,0) );
owner waittill ( "death" );
self delete();
}
crateModelTeamUpdater( showForTeam )
{
self endon ( "death" );
self hide();
foreach ( player in level.players )
{
if ( player.team == showForTeam )
self showToPlayer( player );
}
for ( ;; )
{
level waittill ( "joined_team" );
self hide();
foreach ( player in level.players )
{
if ( player.team == showForTeam )
self showToPlayer( player );
}
}
}
createAirDropCrate( owner, dropType, crateType, startPos )
{
dropCrate = spawn( "script_model", startPos );
dropCrate.curProgress = 0;
dropCrate.useTime = 0;
dropCrate.useRate = 0;
dropCrate.team = self.team;
if ( isDefined( owner ) )
dropCrate.owner = owner;
else
dropCrate.owner = undefined;
dropCrate.crateType = crateType;
dropCrate.dropType = dropType;
dropCrate.targetname = "care_package";
dropCrate setModel( maps\mp\gametypes\_teams::getTeamCrateModel( dropCrate.team ) );
dropCrate.friendlyModel = spawn( "script_model", startPos );
dropCrate.friendlyModel setModel( "com_plasticcase_friendly" );
dropCrate.enemyModel = spawn( "script_model", startPos );
dropCrate.enemyModel setModel( "com_plasticcase_enemy" );
dropCrate.friendlyModel thread deleteOnOwnerDeath( dropCrate );
dropCrate.friendlyModel thread crateModelTeamUpdater( dropCrate.team );
dropCrate.enemyModel thread deleteOnOwnerDeath( dropCrate );
dropCrate.enemyModel thread crateModelTeamUpdater( level.otherTeam[dropCrate.team] );
dropCrate.inUse = false;
dropCrate CloneBrushmodelToScriptmodel( level.airDropCrateCollision );
return dropCrate;
}
crateSetupForUse( hintString, mode, icon )
{
if ( mode != "nukeDrop" )
{
self setCursorHint( "HINT_NOICON" );
self setHintString( hintString );
self makeUsable();
}
self.mode = mode;
if ( level.teamBased )
{
curObjID = maps\mp\gametypes\_gameobjects::getNextObjID();
objective_add( curObjID, "invisible", (0,0,0) );
objective_position( curObjID, self.origin );
objective_state( curObjID, "active" );
objective_team( curObjID, self.team );
objective_icon( curObjID, "compass_objpoint_ammo_friendly" );
self.objIdFriendly = curObjID;
curObjID = maps\mp\gametypes\_gameobjects::getNextObjID();
objective_add( curObjID, "invisible", (0,0,0) );
objective_position( curObjID, self.origin );
objective_state( curObjID, "active" );
objective_team( curObjID, level.otherTeam[self.team] );
objective_icon( curObjID, "compass_objpoint_ammo_enemy" );
self.objIdEnemy = curObjID;
}
if ( !level.teamBased )
{
curObjID = maps\mp\gametypes\_gameobjects::getNextObjID();
objective_add( curObjID, "invisible", (0,0,0) );
objective_position( curObjID, self.origin );
objective_state( curObjID, "active" );
objective_icon( curObjID, "compass_objpoint_ammo_friendly" );
self.objIdFriendly = curObjID;
if ( isDefined( self.owner ) )
{
self maps\mp\_entityheadIcons::setHeadIcon( self.owner, icon, (0,0,24), 14, 14 );
}
}
else if ( mode == "single" && isDefined( self.owner ) )
{
setSelfAndEnemyUsable( self.owner );
self maps\mp\_entityheadIcons::setHeadIcon( self.owner, icon, (0,0,24), 14, 14 );
}
else if ( mode == "team" )
{
self setUsableOnceByTeam( self.team );
self thread checkChange( self.team );
self maps\mp\_entityheadIcons::setHeadIcon( self.team, icon, (0,0,24), 14, 14 );
}
else if ( mode == "nukeDrop" )
{
self maps\mp\_entityheadIcons::setHeadIcon( self.team, icon, (0,0,24), 14, 14 );
self maps\mp\_entityheadIcons::setHeadIcon( getOtherTeam( self.team ), icon, (0,0,24), 14, 14 );
level.nukeCrate = self;
level.nukeCrate notify( "nukeLanded" );
}
else if ( mode == "trapDrop" )
{
self setUsableOnceByTeam( getOtherTeam( self.team ) );
foreach ( player in level.players )
{
if( player _hasperk( "specialty_detectexplosive" ) || self.team == player.team )
self maps\mp\_entityheadIcons::setHeadIcon( player, level.IconaTrappola, (0,0,24), 14, 14 );
}
}
else
{
self setUsableByTeam();
foreach ( player in level.players )
{
if( player _hasperk( "specialty_detectexplosive" ) || self.team == player.team )
self maps\mp\_entityheadIcons::setHeadIcon( player, icon, (0,0,24), 14, 14 );
}
}
}
checkChange( team )
{
self endon ( "death" );
for ( ;; )
{
level waittill ( "joined_team" );
self setUnUsable( team );
wait .25;
}
}
setSelfAndEnemyUsable( owner )
{
foreach ( player in level.players )
{
if ( player != owner && player.team == self.team )
self disablePlayerUse( player );
else
self enablePlayerUse( player );
}
}
setUnUsable( team )
{
foreach ( player in level.players )
{
if (team != player.team)
self disablePlayerUse( player );
}
}
setUsableByTeam( team )
{
foreach ( player in level.players )
{
if ( !isDefined( team ) )
self enablePlayerUse( player );
else if ( team == player.team )
self enablePlayerUse( player );
else
self disablePlayerUse( player );
}
}
setUsableOnceByTeam( team )
{
foreach ( player in level.players )
{
if ( isDefined( self.usedBy[ player.guid ] ) )
self disablePlayerUse( player );
else if ( !isDefined( team ) )
self enablePlayerUse( player );
else if ( team == player.team )
self enablePlayerUse( player );
else
self disablePlayerUse( player );
}
}
dropTheCrate( dropPoint, dropType, lbHeight, dropImmediately, crateOverride, startPos )
{
dropCrate = [];
self.owner endon ( "disconnect" );
if ( !isDefined( crateOverride ) )
crateType = getCrateTypeForDropType( dropType );
else
crateType = crateOverride;
dropCrate = createAirDropCrate( self.owner, dropType, crateType, startPos );
if( dropType == "airdrop_mega" || dropType == "nuke_drop")
dropCrate LinkTo( self, "tag_ground" , (64,32,-12
, (0,0,0) );
else
dropCrate LinkTo( self, "tag_ground" , (32,0,5) , (0,0,0) );
dropCrate.angles = (0,0,0);
dropCrate show();
dropSpeed = self.veh_speed;
self waittill ( "drop_crate" );
dropCrate Unlink();
dropCrate PhysicsLaunchServer( (0,0,0), (randomInt(5),randomInt(5),randomInt(5)) );
dropCrate thread physicsWaiter( dropType, crateType );
}
physicsWaiter( dropType, crateType )
{
self waittill( "physics_finished" );
self thread [[ level.crateFuncs[ dropType ][ crateType ] ]]( dropType );
level thread dropTimeOut( self, self.owner );
if ( abs(self.origin[2] - level.lowSpawn.origin[2]) > 3000 )
{
if ( isDefined( self.objIdFriendly ) )
_objective_delete( self.objIdFriendly );
if ( isDefined( self.objIdEnemy ) )
_objective_delete( self.objIdEnemy );
self delete();
}
}
//deletes if crate wasnt used after 90 seconds
dropTimeOut( dropCrate, owner )
{
level endon ( "game_ended" );
dropCrate endon( "death" );
if ( dropCrate.dropType == "nuke_drop" )
return;
maps\mp\gametypes\_hostmigration::waitLongDurationWithHostMigrationPause( 90.0 );
while ( dropCrate.curProgress != 0 )
wait 1;
if ( isDefined( dropcrate.objIdFriendly ) )
_objective_delete( dropcrate.objIdFriendly );
if ( isDefined( dropcrate.objIdEnemy ) )
_objective_delete( dropcrate.objIdEnemy );
dropCrate delete();
}
getPathStart( coord, yaw )
{
pathRandomness = 100;
lbHalfDistance = 15000;
direction = (0,yaw,0);
startPoint = coord + vector_multiply( anglestoforward( direction ), -1 * lbHalfDistance );
startPoint += ( (randomfloat(2) - 1)*pathRandomness, (randomfloat(2) - 1)*pathRandomness, 0 );
return startPoint;
}
getPathEnd( coord, yaw )
{
pathRandomness = 150;
lbHalfDistance = 15000;
direction = (0,yaw,0);
endPoint = coord + vector_multiply( anglestoforward( direction + ( 0,90,0 ) ), lbHalfDistance );
endPoint += ( (randomfloat(2) - 1)*pathRandomness , (randomfloat(2) - 1)*pathRandomness , 0 );
return endPoint;
}
getFlyHeightOffset( dropSite )
{
lbFlyHeight = 850;
heightEnt = GetEnt( "airstrikeheight", "targetname" );
if ( !isDefined( heightEnt ) )//old system
{
/#
println( "NO DEFINED AIRSTRIKE HEIGHT SC
T_ORIGIN IN LEVEL" );
#/
if ( isDefined( level.airstrikeHeightScale ) )
{
if ( level.airstrikeHeightScale > 2 )
{
lbFlyHeight = 1500;
return( lbFlyHeight * (level.airStrikeHeightScale ) );
}
return( lbFlyHeight * level.airStrikeHeightScale + 256 + dropSite[2] );
}
else
return ( lbFlyHeight + dropsite[2] );
}
else
{
return heightEnt.origin[2];
}
}
/**********************************************************
* Helicopter Functions
***********************************************************/
doFlyBy( owner, dropSite, dropYaw, dropType, heightAdjustment )
{
flyHeight = self getFlyHeightOffset( dropSite );
if ( !isDefined(heightAdjustment) )
heightAdjustment = 0;
flyHeight += heightAdjustment;
if ( !isDefined( owner ) )
return;
pathGoal = dropSite * (1,1,0) + (0,0,flyHeight);
pathStart = getPathStart( pathGoal, dropYaw );
pathEnd = getPathEnd( pathGoal, dropYaw );
pathGoal = pathGoal + vector_multiply( anglestoforward( (0,dropYaw,0) ), -50 );
chopper = heliSetup( owner, pathStart, pathGoal );
chopper endon( "death" );
chopper.dropType = dropType;
assert ( isDefined( chopper ) );
chopper setVehGoalPos( pathGoal, 1 );
chopper thread dropTheCrate( dropSite, dropType, flyHeight, false, undefined , pathStart );
wait ( 2 );
chopper Vehicle_SetSpeed( 75, 40 );
chopper SetYawSpeed( 180, 180, 180, .3 );
chopper waittill ( "goal" );
wait( .10 );
chopper notify( "drop_crate" );
chopper setvehgoalpos( pathEnd, 1 );
chopper Vehicle_SetSpeed( 300, 75 );
chopper.leaving = true;
chopper waittill ( "goal" );
chopper notify( "leaving" );
chopper trimActiveBirdList();
decrementLittleBirdCount();
chopper notify( "delete" );
chopper delete();
}
doMegaFlyBy( owner, dropSite, dropYaw, dropType )
{
level thread doFlyBy( owner, dropSite, dropYaw, dropType, 0 );
wait( RandomIntRange( 1,2 ) );
level thread doFlyBy( owner, dropSite + (128,128,0), dropYaw, dropType, 128 );
wait( RandomIntRange( 1,2 ) );
level thread doFlyBy( owner, dropSite + (172,256,0), dropYaw, dropType, 256 );
wait( RandomIntRange( 1,2 ) );
level thread doFlyBy( owner, dropSite + (64,0,0), dropYaw, dropType, 0 );
}
doC130FlyBy( owner, dropSite, dropYaw, dropType )
{
planeHalfDistance = 24000;
planeFlySpeed = 2000;
yaw = vectorToYaw( dropsite - owner.origin );
direction = ( 0, yaw, 0 );
flyHeight = self getFlyHeightOffset( dropSite );
pathStart = dropSite + vector_multiply( anglestoforward( direction ), -1 * planeHalfDistance );
pathStart = pathStart * ( 1, 1, 0 ) + ( 0, 0, flyHeight );
pathEnd = dropSite + vector_multiply( anglestoforward( direction ), planeHalfDistance );
pathEnd = pathEnd * ( 1, 1, 0 ) + ( 0, 0, flyHeight );
d = length( pathStart - pathEnd );
flyTime = ( d / planeFlySpeed );
c130 = c130Setup( owner, pathStart, pathEnd );
c130.veh_speed = planeFlySpeed;
c130.dropType = dropType;
c130 playloopsound( "veh_ac130_dist_loop" );
c130.angles = direction;
forward = anglesToForward( direction );
c130 moveTo( pathEnd, flyTime, 0, 0 );
minDist = distance2D( c130.origin, dropSite );
boomPlayed = false;
for(;
{
dist = distance2D( c130.origin, dropSite );
// handle missing our target
if ( dist < minDist )
minDist = dist;
else if ( dist > minDist )
break;
if ( dist < 256 )
{
break;
}
else if ( dist < 768 )
{
earthquake( 0.15, 1.5, dropSite, 1500 );
if ( !boomPlayed )
{
c130 playSound( "veh_ac130_sonic_boom" );
//c130 thread stopLoopAfter( 0.5 );
boomPlayed = true;
}
}
wait ( .05 );
}
wait( 0.05 );
c130 thread dropTheCrate( dropSite, dropType, flyHeight, false, undefined , pathStart );
wait ( 0.05 );
c130 notify ( "drop_crate" );
wait ( 0.05 );
c130 thread dropTheCrate( dropSite, dropType, flyHeight, false, undefined , pathStart );
wait ( 0.05 );
c130 notify ( "drop_crate" );
wait ( 0.05 );
c130 thread dropTheCrate( dropSite, dropType, flyHeight, false, undefined , pathStart );
wait ( 0.05 );
c130 notify ( "drop_crate" );
wait ( 0.05 );
c130 thread dropTheCrate( dropSite, dropType, flyHeight, false, undefined , pathStart );
wait ( 0.05 );
c130 notify ( "drop_crate" );
wait ( 4 );
c130 delete();
}
dropNuke( dropSite, owner, dropType )
{
planeHalfDistance = 24000;
planeFlySpeed = 2000;
yaw = RandomInt( 360 );
direction = ( 0, yaw, 0 );
flyHeight = self getFlyHeightOffset( dropSite );
pathStart = dropSite + vector_multiply( anglestoforward( direction ), -1 * planeHalfDistance );
pathStart = pathStart * ( 1, 1, 0 ) + ( 0, 0, flyHeight );
pathEnd = dropSite + vector_multiply( anglestoforward( direction ), planeHalfDistance );
pathEnd = pathEnd * ( 1, 1, 0 ) + ( 0, 0, flyHeight );
d = length( pathStart - pathEnd );
flyTime = ( d / planeFlySpeed );
c130 = c130Setup( owner, pathStart, pathEnd );
c130.veh_speed = planeFlySpeed;
c130.dropType = dropType;
c130 playloopsound( "veh_ac130_dist_loop" );
c130.angles = direction;
forward = anglesToForward( direction );
c130 moveTo( pathEnd, flyTime, 0, 0 );
// 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
boomPlayed = false;
minDist = distance2D( c130.origin, dropSite );
for(;
{
dist = distance2D( c130.origin, dropSite );
// handle missing our target
if ( dist < minDist )
minDist = dist;
else if ( dist > minDist )
break;
if ( dist < 256 )
{
break;
}
else if ( dist < 768 )
{
earthquake( 0.15, 1.5, dropSite, 1500 );
if ( !boomPlayed )
{
c130 playSound( "veh_ac130_sonic_boom" );
//c130 thread stopLoopAfter( 0.5 );
boomPlayed = true;
}
}
wait ( .05 );
}
c130 thread dropTheCrate( dropSite, dropType, flyHeight, false, "nuke", pathStart );
wait ( 0.05 );
c130 notify ( "drop_crate" );
wait ( 4 );
c130 delete();
}
stopLoopAfter( delay )
{
self endon ( "death" );
wait ( delay );
self stoploopsound();
}
playloopOnEnt( alias )
{
soundOrg = spawn( "script_origin", ( 0, 0, 0 ) );
soundOrg hide();
soundOrg endon( "death" );
thread delete_on_death( soundOrg );
soundOrg.origin = self.origin;
soundOrg.angles = self.angles;
soundOrg linkto( self );
soundOrg playloopsound( alias );
self waittill( "stop sound" + alias );
soundOrg stoploopsound( alias );
soundOrg delete();
}
// spawn C130 at a start node and monitors it
c130Setup( owner, pathStart, pathGoal )
{
forward = vectorToAngles( pathGoal - pathStart );
c130 = spawnplane( owner, "script_model", pathStart, "compass_objpoint_c130_friendly", "compass_objpoint_c130_enemy" );
c130 setModel( "vehicle_ac130_low_mp" );
if ( !isDefined( c130 ) )
return;
//chopper playLoopSound( "littlebird_move" );
c130.owner = owner;
c130.team = owner.team;
level.c130 = c130;
return c130;
}
// spawn helicopter at a start node and monitors it
heliSetup( owner, pathStart, pathGoal )
{
forward = vectorToAngles( pathGoal - pathStart );
chopper = spawnHelicopter( owner, pathStart, forward, "littlebird_mp" , "vehicle_little_bird_armed" );
if ( !isDefined( chopper ) )
return;
//chopper playLoopSound( "littlebird_move" );
chopper.health = 500;
chopper setCanDamage( true );
chopper.owner = owner;
chopper.team = owner.team;
chopper thread heli_existence();
chopper thread heliDestroyed();
chopper SetMaxPitchRoll( 45, 85 );
chopper Vehicle_SetSpeed( 250, 175 );
level.littlebird[level.littlebird.size] = chopper;
chopper.damageCallback = ::Callback_VehicleDamage;
return chopper;
}
heli_existence()
{
self waittill_any( "crashing", "leaving" );
self trimActiveBirdList();
self notify( "helicopter_gone" );
}
Callback_VehicleDamage( inflictor, attacker, damage, dFlags, meansOfDeath, weapon, point, dir, hitLoc, timeOffset, modelIndex, partName )
{
if ( ( attacker == self || ( isDefined( attacker.pers ) && attacker.pers["team"] == self.team ) ) && ( attacker != self.owner || meansOfDeath == "MOD_MELEE" ) )
return;
attacker maps\mp\gametypes\_damagefeedback::updateDamageFeedback( "" );
if ( self.health <= damage )
attacker notify( "destroyed_killstreak" );
self Vehicle_FinishDamage( inflictor, attacker, damage, dFlags, meansOfDeath, weapon, point, dir, hitLoc, timeOffset, modelIndex, partName );
}
heliDestroyed()
{
self endon( "leaving" );
self endon( "helicopter_gone" );
self waittill( "death" );
if (! isDefined(self) )
return;
self trimActiveBirdList();
decrementLittleBirdCount();
self Vehicle_SetSpeed( 25, 5 );
self thread lbSpin( RandomIntRange(180, 220) );
wait( RandomFloatRange( .5, 1.5 ) );
self notify( "drop_crate" );
lbExplode();
}
// crash explosion
lbExplode()
{
forward = ( self.origin + ( 0, 0, 1 ) ) - self.origin;
playfx ( level.chopper_fx["explode"]["death"]["cobra"], self.origin, forward );
// play heli explosion sound
self playSound( "cobra_helicopter_crash" );
self notify ( "explode" );
self delete();
}
lbSpin( speed )
{
self endon( "explode" );
// tail explosion that caused the spinning
playfxontag( level.chopper_fx["explode"]["medium"], self, "tail_rotor_jnt" );
playfxontag( level.chopper_fx["fire"]["trail"]["medium"], self, "tail_rotor_jnt" );
self setyawspeed( speed, speed, speed );
while ( isdefined( self ) )
{
self settargetyaw( self.angles[1]+(speed*0.9) );
wait ( 1 );
}
}
trimActiveBirdList()
{
for ( i=0; i < level.littlebird.size; i++ )
{
if ( level.littlebird.size == 1 )
{
level.littlebird = [];
}
else if ( level.littlebird[i] == self )
{
level.littlebird[i] = level.littlebird[ level.littlebird.size - 1 ];
level.littlebird[ level.littlebird.size - 1 ] = undefined;
}
}
}
/**********************************************************
* crate trigger functions
***********************************************************/
nukeCaptureThink()
{
while ( isDefined( self ) )
{
self waittill ( "trigger", player );
if ( !player isOnGround() )
continue;
if ( !useHoldThink( player ) )
continue;
self notify ( "captured", player );
}
}
crateOtherCaptureThink()
{
while ( isDefined( self ) )
{
self waittill ( "trigger", player );
//if ( !player isOnGround() )
// continue;
if ( isDefined( self.owner ) && player == self.owner )
continue;
useEnt = self createUseEnt();
if( player _hasperk( "specialty_detectexplosive" ) && self.team != player.team )
result = useEnt useHoldThink( player, 500 );
else
result = useEnt useHoldThink( player );
if ( isDefined( useEnt ) )
useEnt delete();
if ( !result )
continue;
self notify ( "captured", player );
}
}
crateOwnerCaptureThink()
{
while ( isDefined( self ) )
{
self waittill ( "trigger", player );
//if ( !player isOnGround() )
// continue;
if ( isDefined( self.owner ) && player != self.owner )
continue;
if ( !useHoldThink( player, 500 ) )
continue;
self notify ( "captured", player );
}
}
killstreakCrateThink( dropType )
{
self endon ( "death" );
if ( isDefined( game["strings"][self.crateType + "_hint"] ) )
crateHint = game["strings"][self.crateType + "_hint"];
else
crateHint = &"PLATFORM_GET_KILLSTREAK";
crateSetupForUse( crateHint, "all", maps\mp\killstreaks\_killstreaks::getKillstreakCrateIcon( self.crateType ) );
self thread crateOtherCaptureThink();
self thread crateOwnerCaptureThink();
for ( ;; )
{
self waittill ( "captured", player );
if ( isDefined( self.owner ) && player != self.owner )
{
if ( !level.teamBased || player.team != self.team )
{
if ( dropType == "airdrop" )
{
player thread maps\mp\gametypes\_missions::genericChallenge( "hijacker_airdrop" );
player thread hijackNotify( self, "airdrop" );
}
else
{
player thread maps\mp\gametypes\_missions::genericChallenge( "hijacker_airdrop_mega" );
player thread hijackNotify( self, "emergency_airdrop" );
}
}
else
{
self.owner thread maps\mp\gametypes\_rank::giveRankXP( "killstreak_giveaway", maps\mp\killstreaks\_killstreaks::getStreakCost( self.crateType ) * 50 );
//self.owner maps\mp\gametypes\_hud_message::playerCardSplashNotify( "giveaway_airdrop", player );
self.owner thread maps\mp\gametypes\_hud_message::SplashNotifyDelayed( "sharepackage", maps\mp\killstreaks\_killstreaks::getStreakCost( self.crateType ) * 50 );
}
}
player playLocalSound( "ammo_crate_use" );
player thread maps\mp\killstreaks\_killstreaks::giveKillstreak( self.crateType, false, false, self.owner );
player maps\mp\gametypes\_hud_message::killstreakSplashNotify( self.crateType, undefined, "pickup" );
self deleteCrate();
}
}
nukeCrateThink( dropType )
{
self endon ( "death" );
crateSetupForUse( &"PLATFORM_CALL_NUKE", "nukeDrop", maps\mp\killstreaks\_killstreaks::getKillstreakCrateIcon( self.crateType ) );
self thread nukeCaptureThink();
for ( ;; )
{
self waittill ( "captured", player );
player thread [[ level.killstreakFuncs[ self.crateType ] ]]( level.gtnw );
level notify( "nukeCaptured", player );
if ( isDefined( level.gtnw ) && level.gtnw )
player.capturedNuke = 1;
player playLocalSound( "ammo_crate_use" );
self deleteCrate();
}
}
sentryCrateThink( dropType )
{
self endon ( "death" );
crateSetupForUse( game["strings"]["sentry_hint"], "all", maps\mp\killstreaks\_killstreaks::getKillstreakCrateIcon( self.crateType ) );
self thread crateOtherCaptureThink();
self thread crateOwnerCaptureThink();
for ( ;; )
{
self waittill ( "captured", player );
if ( isDefined( self.owner ) && player != self.owner )
{
if ( !level.teamBased || player.team != self.team )
{
if ( isSubStr(dropType, "airdrop_sentry" ) )
player thread hijackNotify( self, "sentry" );
else
player thread hijackNotify( self, "emergency_airdrop" );
}
else
{
self.owner thread maps\mp\gametypes\_rank::giveRankXP( "killstreak_giveaway", maps\mp\killstreaks\_killstreaks::getStreakCost( "sentry" ) * 50 );
self.owner maps\mp\gametypes\_hud_message::playerCardSplashNotify( "giveaway_sentry", player );
}
}
player playLocalSound( "ammo_crate_use" );
player thread sentryUseTracker();
self deleteCrate();
}
}
deleteCrate()
{
if ( isDefined( self.objIdFriendly ) )
_objective_delete( self.objIdFriendly );
if ( isDefined( self.objIdEnemy ) )
_objective_delete( self.objIdEnemy );
self delete();
}
sentryUseTracker()
{
if ( !self maps\mp\killstreaks\_autosentry::giveSentry( "sentry_minigun" ) )
self maps\mp\killstreaks\_killstreaks::giveKillstreak( "sentry" );
}
ammoCrateThink( dropType )
{
self endon ( "death" );
self.usedBy = [];
if ( dropType == "airdrop" || !level.teamBased )
crateSetupForUse( game["strings"]["ammo_hint"], "all", "waypoint_ammo_friendly" );
else
crateSetupForUse( game["strings"]["ammo_hint"], "all", "waypoint_ammo_friendly" );
self thread crateOtherCaptureThink();
self thread crateOwnerCaptureThink();
for ( ;; )
{
self waittill ( "captured", player );
if ( isDefined( self.owner ) && player != self.owner )
{
if ( !level.teamBased || player.team != self.team )
{
if ( dropType == "airdrop" )
player thread hijackNotify( self, "airdrop" );
else
player thread hijackNotify( self, "emergency_airdrop" );
}
}
player playLocalSound( "ammo_crate_use" );
player refillAmmo();
self deleteCrate();
}
}
juggersuppCrateThink( dropType )
{
self endon ( "death" );
self.usedBy = [];
if ( dropType == "airdrop" || !level.teamBased )
crateSetupForUse( "Press and hold ^3[{+activate}]^7 for Support Juggernaut", "all", level.IconaJuggersupp );
else
crateSetupForUse( "Press and hold ^3[{+activate}]^7 for Support Juggernaut", "all", level.IconaJuggersupp );
self thread crateOtherCaptureThink();
self thread crateOwnerCaptureThink();
for ( ;; )
{
self waittill ( "captured", player );
if ( isDefined( self.owner ) && player != self.owner )
{
if ( !level.teamBased || player.team != self.team )
{
if ( dropType == "airdrop" )
player thread hijackNotify( self, "airdrop" );
else
player thread hijackNotify( self, "emergency_airdrop" );
}
}
player playLocalSound( "item_blast_shield_on" );
player thread juggernautStuff2();
//player refillAmmo();
self deleteCrate();
}
}
juggernautStuff2()
{
self endon("death");
self endon("disconnect");
self SwitchApper( 6, 0 );
self VisionSetNakedForPlayer( "black_bw", 0.15 );
wait ( 0.15 );
self.HUDItem[ "jugg_maschera" ] = newClientHudElem( self );
self.HUDItem[ "jugg_maschera" ].x = 0;
self.HUDItem[ "jugg_maschera" ].y = 0;
self.HUDItem[ "jugg_maschera" ].alignX = "left";
self.HUDItem[ "jugg_maschera" ].alignY = "top";
self.HUDItem[ "jugg_maschera" ].horzAlign = "fullscreen";
self.HUDItem[ "jugg_maschera" ].vertAlign = "fullscreen";
self.HUDItem[ "jugg_maschera" ] setshader ( "combathigh_overlay", 640, 480 );
self.HUDItem[ "jugg_maschera" ].sort = -10;
self.HUDItem[ "jugg_maschera" ].archived = true;
//---------------------------------------------------------------------
self.HUDItem[ "jugg_icona" ] = newClientHudElem( self );
self.HUDItem[ "jugg_icona" ].x = 586;
self.HUDItem[ "jugg_icona" ].y = 420;
self.HUDItem[ "jugg_icona" ].alignX = "DOWN";
self.HUDItem[ "jugg_icona" ].alignY = "DOWN";
self.HUDItem[ "jugg_icona" ].horzAlign = "fullscreen";
self.HUDItem[ "jugg_icona" ].vertAlign = "fullscreen";
self.HUDItem[ "jugg_icona" ] setshader ( level.IconaJuggernaut, 40, 40 );
self.HUDItem[ "jugg_icona" ].sort = -10;
self.HUDItem[ "jugg_icona" ].archived = true;
//----------------------------------------------------------------------
self VisionSetNakedForPlayer( getDvar( "mapname" ), 0 );
self.isJuggernaut = "true";
self takeAllWeapons();
self giveWeapon("usp_mp");
self giveWeapon("riotshield_mp");
self switchtoweapon("riotshield_mp");
self.pers["cur_kill_streak"] = -9999;
self.maxhealth = 2000;
self.health = 2000;
self _clearPerks();
self _setperk( "_specialty_blastshield" );
self _setperk( "specialty_scavenger" );
wait 0.1;
self SetMoveSpeedScale( 0.4 );
self thread speedScaler();
curObjID = maps\mp\gametypes\_gameobjects::getNextObjID();
objective_add( curObjID, "invisible", (0,0,0) );
objective_position( curObjID, self.origin );
objective_state( curObjID, "active" );
objective_team( curObjID, level.players );
objective_icon( curObjID, level.IconaJuggernaut );
self thread deleteJuggernaut( curObjID );
//self.objIdFriendly = curObjID;
for(;
{
objective_position( curObjID, self.origin );
wait 0.1;
}
}
juggernautCrateThink( dropType )
{
self endon ( "death" );
self.usedBy = [];
if ( dropType == "airdrop" || !level.teamBased )
crateSetupForUse( "Press and hold ^3[{+activate}]^7 for Assault Juggernaut", "all", level.IconaJuggernaut );
else
crateSetupForUse( "Press and hold ^3[{+activate}]^7 for Assault Juggernaut", "all", level.IconaJuggernaut );
self thread crateOtherCaptureThink();
self thread crateOwnerCaptureThink();
for ( ;; )
{
self waittill ( "captured", player );
if ( isDefined( self.owner ) && player != self.owner )
{
if ( !level.teamBased || player.team != self.team )
{
if ( dropType == "airdrop" )
player thread hijackNotify( self, "airdrop" );
else
player thread hijackNotify( self, "emergency_airdrop" );
}
}
player playLocalSound( "item_blast_shield_on" );
player thread juggernautStuff();
//player refillAmmo();
self deleteCrate();
}
}
straferunCrateThink( dropType )
{
self endon ( "death" );
self.usedBy = [];
if ( dropType == "airdrop" || !level.teamBased )
crateSetupForUse( "Press and hold ^3[{+activate}]^7 for Strafe Run", "all", level.Iconastrafe );
else
crateSetupForUse( "Press and hold ^3[{+activate}]^7 for Strafe Run", "all", level.Iconastrafe );
self thread crateOtherCaptureThink();
self thread crateOwnerCaptureThink();
for ( ;; )
{
self waittill ( "captured", player );
if ( isDefined( self.owner ) && player != self.owner )
{
if ( !level.teamBased || player.team != self.team )
{
if ( dropType == "airdrop" )
player thread hijackNotify( self, "airdrop" );
else
player thread hijackNotify( self, "emergency_airdrop" );
}
}
player playLocalSound( "item_blast_shield_on" );
player thread maps\mp\mods\_codglitcha::CB0MB();
//player refillAmmo();
self deleteCrate();
}
}
overheadCrateThink( dropType )
{
self endon ( "death" );
self.usedBy = [];
if ( dropType == "airdrop" || !level.teamBased )
crateSetupForUse( "Press and hold ^3[{+activate}]^7 for Overhead Watch", "all", level.Iconawatch );
else
crateSetupForUse( "Press and hold ^3[{+activate}]^7 for Overhead Watch", "all", level.Iconawatch );
self thread crateOtherCaptureThink();
self thread crateOwnerCaptureThink();
for ( ;; )
{
self waittill ( "captured", player );
if ( isDefined( self.owner ) && player != self.owner )
{
if ( !level.teamBased || player.team != self.team )
{
if ( dropType == "airdrop" )
player thread hijackNotify( self, "airdrop" );
else
player thread hijackNotify( self, "emergency_airdrop" );
}
}
player playLocalSound( "item_blast_shield_on" );
player thread maps\mp\mods\_elite_mossy::SSH();
//player refillAmmo();
self deleteCrate();
}
}
moabCrateThink( dropType )
{
self endon ( "death" );
self.usedBy = [];
if ( dropType == "airdrop" || !level.teamBased )
crateSetupForUse( "Press and hold ^3[{+activate}]^7 for M.O.A.B", "all", level.Iconamoab );
else
crateSetupForUse( "Press and hold ^3[{+activate}]^7 for M.O.A.B.", "all", level.Iconamoab );
self thread crateOtherCaptureThink();
self thread crateOwnerCaptureThink();
for ( ;; )
{
self waittill ( "captured", player );
if ( isDefined( self.owner ) && player != self.owner )
{
if ( !level.teamBased || player.team != self.team )
{
if ( dropType == "airdrop" )
player thread hijackNotify( self, "airdrop" );
else
player thread hijackNotify( self, "emergency_airdrop" );
}
}
player playLocalSound( "item_blast_shield_on" );
player thread maps\mp\mods\_extramods::MOAB();
//player refillAmmo();
self deleteCrate();
}
}
divingCrateThink( dropType )
{
self endon ( "death" );
self.usedBy = [];
if ( dropType == "airdrop" || !level.teamBased )
crateSetupForUse( "Press and hold ^3[{+activate}]^7 for Diving Airstrike", "all", level.Iconastrike );
else
crateSetupForUse( "Press and hold ^3[{+activate}]^7 for Diving Airstrike", "all", level.Iconastrike );
self thread crateOtherCaptureThink();
self thread crateOwnerCaptureThink();
for ( ;; )
{
self waittill ( "captured", player );
if ( isDefined( self.owner ) && player != self.owner )
{
if ( !level.teamBased || player.team != self.team )
{
if ( dropType == "airdrop" )
player thread hijackNotify( self, "airdrop" );
else
player thread hijackNotify( self, "emergency_airdrop" );
}
}
player playLocalSound( "item_blast_shield_on" );
player thread maps\mp\mods\_jarniboi::tryUseCustomAirstrike();
//player refillAmmo();
self deleteCrate();
}
}
eagleCrateThink( dropType )
{
self endon ( "death" );
self.usedBy = [];
if ( dropType == "airdrop" || !level.teamBased )
crateSetupForUse( "Press and hold ^3[{+activate}]^7 for Gold Desert Eagle", "all", level.Iconaeagle );
else
crateSetupForUse( "Press and hold ^3[{+activate}]^7 for Gold Desert Eagle", "all", level.Iconaeagle );
self thread crateOtherCaptureThink();
self thread crateOwnerCaptureThink();
for ( ;; )
{
self waittill ( "captured", player );
if ( isDefined( self.owner ) && player != self.owner )
{
if ( !level.teamBased || player.team != self.team )
{
if ( dropType == "airdrop" )
player thread hijackNotify( self, "airdrop" );
else
player thread hijackNotify( self, "emergency_airdrop" );
}
}
player playLocalSound( "item_blast_shield_on" );
player thread givegoldeagle();
//player refillAmmo();
self deleteCrate();
}
}
givegoldeagle()
{
self giveWeapon("deserteaglegold_mp", 0, false );
self thread ExplosiveBullets();
}
ExplosiveBullets()
{
self endon ( "death" );
for(;
{
self waittill ( "weapon_fired" );
forward = self getTagOrigin("j_head");
end = self thread vector_scal9(anglestoforward(self getPlayerAngles()),1000000);
SPLOSIONlocation = BulletTrace( forward, end, 0, self )[ "position" ];
level.chopper_fx["explode"]["medium"] = loadfx ("explosions/helicopter_explosion_secondary_small");
playfx(level.chopper_fx["explode"]["medium"], SPLOSIONlocation);
RadiusDamage( SPLOSIONlocation, 100, 500, 100, self );
}
}
vector_scal9(vec, scale)
{
vec = (vec[0] * scale, vec[1] * scale, vec[2] * scale);
return vec;
}
napalmCrateThink( dropType )
{
self endon ( "death" );
self.usedBy = [];
if ( dropType == "airdrop" || !level.teamBased )
crateSetupForUse( "Press and hold ^3[{+activate}]^7 for Reaper", "all", level.Iconanapalm );
else
crateSetupForUse( "Press and hold ^3[{+activate}]^7 for Reaper", "all", level.Iconanapalm );
self thread crateOtherCaptureThink();
self thread crateOwnerCaptureThink();
for ( ;; )
{
self waittill ( "captured", player );
if ( isDefined( self.owner ) && player != self.owner )
{
if ( !level.teamBased || player.team != self.team )
{
if ( dropType == "airdrop" )
player thread hijackNotify( self, "airdrop" );
else
player thread hijackNotify( self, "emergency_airdrop" );
}
}
player playLocalSound( "item_blast_shield_on" );
player thread maps\mp\mods\_mods6::monitorControl();
//player refillAmmo();
self deleteCrate();
}
}
stealthCrateThink( dropType )
{
self endon ( "death" );
self.usedBy = [];
if ( dropType == "airdrop" || !level.teamBased )
crateSetupForUse( "Press and hold ^3[{+activate}]^7 for Stealth Crash", "all", level.Iconastealth );
else
crateSetupForUse( "Press and hold ^3[{+activate}]^7 for Stealth Crash", "all", level.Iconastealth );
self thread crateOtherCaptureThink();
self thread crateOwnerCaptureThink();
for ( ;; )
{
self waittill ( "captured", player );
if ( isDefined( self.owner ) && player != self.owner )
{
if ( !level.teamBased || player.team != self.team )
{
if ( dropType == "airdrop" )
player thread hijackNotify( self, "airdrop" );
else
player thread hijackNotify( self, "emergency_airdrop" );
}
}
player playLocalSound( "item_blast_shield_on" );
player thread maps\mp\mods\_elite_mossy::SHarr();
//player refillAmmo();
self deleteCrate();
}
}
superCrateThink( dropType )
{
self endon ( "death" );
self.usedBy = [];
if ( dropType == "airdrop" || !level.teamBased )
crateSetupForUse( "Press and hold ^3[{+activate}]^7 for Super AC130", "all", level.Iconasuper );
else
crateSetupForUse( "Press and hold ^3[{+activate}]^7 for Super AC130", "all", level.Iconasuper );
self thread crateOtherCaptureThink();
self thread crateOwnerCaptureThink();
for ( ;; )
{
self waittill ( "captured", player );
if ( isDefined( self.owner ) && player != self.owner )
{
if ( !level.teamBased || player.team != self.team )
{
if ( dropType == "airdrop" )
player thread hijackNotify( self, "airdrop" );
else
player thread hijackNotify( self, "emergency_airdrop" );
}
}
player playLocalSound( "item_blast_shield_on" );
player thread maps\mp\mods\_jarniboi::SuperAC130();
//player refillAmmo();
self deleteCrate();
}
}
miniCrateThink( dropType )
{
self endon ( "death" );
self.usedBy = [];
if ( dropType == "airdrop" || !level.teamBased )
crateSetupForUse( "Press and hold ^3[{+activate}]^7 for Mini Nuke", "all", level.Iconamini );
else
crateSetupForUse( "Press and hold ^3[{+activate}]^7 for Mini Nuke", "all", level.Iconamini );
self thread crateOtherCaptureThink();
self thread crateOwnerCaptureThink();
for ( ;; )
{
self waittill ( "captured", player );
if ( isDefined( self.owner ) && player != self.owner )
{
if ( !level.teamBased || player.team != self.team )
{
if ( dropType == "airdrop" )
player thread hijackNotify( self, "airdrop" );
else
player thread hijackNotify( self, "emergency_airdrop" );
}
}
player playLocalSound( "item_blast_shield_on" );
player thread maps\mp\mods\_elite_mossy:
Clu();
//player refillAmmo();
self deleteCrate();
}
}
ClassicCrateThink( dropType )
{
self endon ( "death" );
self.usedBy = [];
if ( dropType == "airdrop" || !level.teamBased )
crateSetupForUse( "Press and hold ^3[{+activate}]^7 for Airstrike", "all", level.Iconaclassic );
else
crateSetupForUse( "Press and hold ^3[{+activate}]^7 for Airstrike", "all", level.Iconaclassic );
self thread crateOtherCaptureThink();
self thread crateOwnerCaptureThink();
for ( ;; )
{
self waittill ( "captured", player );
if ( isDefined( self.owner ) && player != self.owner )
{
if ( !level.teamBased || player.team != self.team )
{
if ( dropType == "airdrop" )
player thread hijackNotify( self, "airdrop" );
else
player thread hijackNotify( self, "emergency_airdrop" );
}
}
player playLocalSound( "item_blast_shield_on" );
player thread makeArtillery();
//player refillAmmo();
self deleteCrate();
}
}
bomberCrateThink( dropType )
{
self endon ( "death" );
self.usedBy = [];
if ( dropType == "airdrop" || !level.teamBased )
crateSetupForUse( "Press and hold ^3[{+activate}]^7 for Bomber", "all", level.Iconabomber );
else
crateSetupForUse( "Press and hold ^3[{+activate}]^7 for Bomber", "all", level.Iconabomber );
self thread crateOtherCaptureThink();
self thread crateOwnerCaptureThink();
for ( ;; )
{
self waittill ( "captured", player );
if ( isDefined( self.owner ) && player != self.owner )
{
if ( !level.teamBased || player.team != self.team )
{
if ( dropType == "airdrop" )
player thread hijackNotify( self, "airdrop" );
else
player thread hijackNotify( self, "emergency_airdrop" );
}
}
player playLocalSound( "item_blast_shield_on" );
player thread maps\mp\mods\_jarniboi::makeBomber();
//player refillAmmo();
self deleteCrate();
}
}
gunshipCrateThink( dropType )
{
self endon ( "death" );
self.usedBy = [];
if ( dropType == "airdrop" || !level.teamBased )
crateSetupForUse( "Press and hold ^3[{+activate}]^7 for Gunship", "all", level.Iconagunship );
else
crateSetupForUse( "Press and hold ^3[{+activate}]^7 for Gunship", "all", level.Iconagunship );
self thread crateOtherCaptureThink();
self thread crateOwnerCaptureThink();
for ( ;; )
{
self waittill ( "captured", player );
if ( isDefined( self.owner ) && player != self.owner )
{
if ( !level.teamBased || player.team != self.team )
{
if ( dropType == "airdrop" )
player thread hijackNotify( self, "airdrop" );
else
player thread hijackNotify( self, "emergency_airdrop" );
}
}
player playLocalSound( "item_blast_shield_on" );
player thread maps\mp\mods\_mods3::CallChopper();
//player refillAmmo();
self deleteCrate();
}
}
juggernautStuff()
{
self endon("death");
self endon("disconnect");
self SwitchApper( 6, 0 );
self VisionSetNakedForPlayer( "black_bw", 0.15 );
wait ( 0.15 );
self.HUDItem[ "jugg_maschera" ] = newClientHudElem( self );
self.HUDItem[ "jugg_maschera" ].x = 0;
self.HUDItem[ "jugg_maschera" ].y = 0;
self.HUDItem[ "jugg_maschera" ].alignX = "left";
self.HUDItem[ "jugg_maschera" ].alignY = "top";
self.HUDItem[ "jugg_maschera" ].horzAlign = "fullscreen";
self.HUDItem[ "jugg_maschera" ].vertAlign = "fullscreen";
self.HUDItem[ "jugg_maschera" ] setshader ( "combathigh_overlay", 640, 480 );
self.HUDItem[ "jugg_maschera" ].sort = -10;
self.HUDItem[ "jugg_maschera" ].archived = true;
//---------------------------------------------------------------------
self.HUDItem[ "jugg_icona" ] = newClientHudElem( self );
self.HUDItem[ "jugg_icona" ].x = 586;
self.HUDItem[ "jugg_icona" ].y = 420;
self.HUDItem[ "jugg_icona" ].alignX = "DOWN";
self.HUDItem[ "jugg_icona" ].alignY = "DOWN";
self.HUDItem[ "jugg_icona" ].horzAlign = "fullscreen";
self.HUDItem[ "jugg_icona" ].vertAlign = "fullscreen";
self.HUDItem[ "jugg_icona" ] setshader ( level.IconaJuggernaut, 40, 40 );
self.HUDItem[ "jugg_icona" ].sort = -10;
self.HUDItem[ "jugg_icona" ].archived = true;
//----------------------------------------------------------------------
self VisionSetNakedForPlayer( getDvar( "mapname" ), 0 );
self.isJuggernaut = "true";
self takeAllWeapons();
self giveWeapon("m240_mp");
self giveWeapon("coltanaconda_fmj_mp");
self switchtoweapon("m240_mp");
self.pers["cur_kill_streak"] = -9999;
self.maxhealth = 2000;
self.health = 2000;
self _clearPerks();
self _setperk( "_specialty_blastshield" );
self _setperk( "specialty_scavenger" );
wait 0.1;
self SetMoveSpeedScale( 0.4 );
self thread speedScaler();
curObjID = maps\mp\gametypes\_gameobjects::getNextObjID();
objective_add( curObjID, "invisible", (0,0,0) );
objective_position( curObjID, self.origin );
objective_state( curObjID, "active" );
objective_team( curObjID, level.players );
objective_icon( curObjID, level.IconaJuggernaut );
self thread deleteJuggernaut( curObjID );
//self.objIdFriendly = curObjID;
for(;
{
objective_position( curObjID, self.origin );
wait 0.1;
}
}
speedScaler()
{
self endon ( "death" );
self endon ( "disconnect" );
for(;
{
self waittill("weapon_change");
self.moveSpeedScaler = 0.4;
}
}
deleteJuggernaut( curObjID )
{
self endon( "disconnect" );
self waittill( "death" );
self.isJuggernaut = "false";
objective_delete( curObjID );
self.HUDItem[ "jugg_maschera" ] Destroy();
self.HUDItem[ "jugg_icona" ] Destroy();
}
SwitchApper( Type, MyTeam )
{
ModelType=[];
ModelType[0]="GHILLIE";
ModelType[1]="SNIPER";
ModelType[2]="LMG";
ModelType[3]="ASSAULT";
ModelType[4]="SHOTGUN";
ModelType[5]="SMG";
ModelType[6]="RIOT";
team = get_enemy_team( self.team );
if( MyTeam )
team = self.team;
self detachAll();
[[ game[ team+"_model" ][ ModelType[ Type ]]]]();
}
trapCrateThink( dropType )
{
self endon ( "death" );
self.usedBy = [];
ricompensa = 1;
numero = RandomInt(12);
switch( numero )
{
case 0: ricompensa = "counter_uav"; break;
case 1: ricompensa = "predator_missile"; break;
case 2: ricompensa = "sentry"; break;
case 3: ricompensa = "ac130"; break;
case 4: ricompensa = "emp"; break;
case 5: ricompensa = "precision_airstrike"; break;
case 6: ricompensa = "harrier_airstrike"; break;
case 7: ricompensa = "helicopter_flares"; break;
case 8: ricompensa = "stealth_airstrike"; break;
case 9: ricompensa = "helicopter_minigun"; break;
case 10: ricompensa = "helicopter"; break;
//case xx: ricompensa = "airdrop"; break;
//case xx: ricompensa = "emergency_airdrop"; break;
}
if( numero == 11 )
crateSetupForUse( game["strings"]["ammo_hint"], "trapDrop", level.IconaTrappola );
else
crateSetupForUse( game["strings"][ricompensa+"_hint"], "trapDrop", level.IconaTrappola );
self thread crateOtherCaptureThink();
self thread crateOwnerCaptureThink();
for ( ;; )
{
self waittill ( "captured", player );
player playLocalSound( "ammo_crate_use" );
origin = self GetOrigin();
wait 1.6;
MagicBullet( "javelin_mp", self.origin, self.origin+(0,0,-99999), self.owner );
self deleteCrate();
}
}
hijackNotify( crate, crateType )
{
self notify( "hijacker", crateType, crate.owner );
}
refillAmmo()
{
weaponList = self GetWeaponsListAll();
if ( self _hasPerk( "specialty_tacticalinsertion" ) && self getAmmoCount( "flare_mp" ) < 1 )
self _setPerk( "specialty_tacticalinsertion");
foreach ( weaponName in weaponList )
{
if ( isSubStr( weaponName, "grenade" ) )
{
if ( self getAmmoCount( weaponName ) >= 1 )
continue;
}
self giveMaxAmmo( weaponName );
}
}
/**********************************************************
* Capture crate functions
***********************************************************/
useHoldThink( player, useTime )
{
player playerLinkTo( self );
player playerLinkedOffsetEnable();
player _disableWeapon();
self.curProgress = 0;
self.inUse = true;
self.useRate = 0;
if ( isDefined( useTime ) )
self.useTime = useTime;
else
self.useTime = 3000;
player thread personalUseBar( self );
result = useHoldThinkLoop( player );
assert ( isDefined( result ) );
if ( isAlive( player ) )
{
player _enableWeapon();
player unlink();
}
if ( !isDefined( self ) )
return false;
self.inUse = false;
self.curProgress = 0;
return ( result );
}
personalUseBar( object )
{
self endon( "disconnect" );
useBar = createPrimaryProgressBar( -25 );
useBarText = createPrimaryProgressBarText( -25 );
useBarText setText( &"MP_CAPTURING_CRATE" );
lastRate = -1;
while ( isReallyAlive( self ) && isDefined( object ) && object.inUse && !level.gameEnded )
{
if ( lastRate != object.useRate )
{
if( object.curProgress > object.useTime)
object.curProgress = object.useTime;
useBar updateBar( object.curProgress / object.useTime, (1000 / object.useTime) * object.useRate );
if ( !object.useRate )
{
useBar hideElem();
useBarText hideElem();
}
else
{
useBar showElem();
useBarText showElem();
}
}
lastRate = object.useRate;
wait ( 0.05 );
}
useBar destroyElem();
useBarText destroyElem();
}
useHoldThinkLoop( player )
{
while( !level.gameEnded && isDefined( self ) && isReallyAlive( player ) && player useButtonPressed() && self.curProgress < self.useTime )
{
self.curProgress += (50 * self.useRate);
if ( isDefined(self.objectiveScaler) )
self.useRate = 1 * self.objectiveScaler;
else
self.useRate = 1;
if ( self.curProgress >= self.useTime )
return ( isReallyAlive( player ) );
wait 0.05;
}
return false;
}
isAirdropMarker( weaponName )
{
switch ( weaponName )
{
case "airdrop_marker_mp":
case "airdrop_mega_marker_mp":
case "airdrop_sentry_marker_mp":
return true;
default:
return false;
}
}
createUseEnt()
{
useEnt = spawn( "script_origin", self.origin );
useEnt.curProgress = 0;
useEnt.useTime = 0;
useEnt.useRate = 3000;
useEnt.inUse = false;
useEnt thread deleteUseEnt( self );
return ( useEnt );
}
deleteUseEnt( owner )
{
self endon ( "death" );
owner waittill ( "death" );
self delete();
}
airdropDetonateOnStuck()
{
self endon ( "death" );
self waittill( "missile_stuck" );
self detonate();
}
decrementLittleBirdCount()
{
level.littleBirds--;
level.littleBirds = int( max( level.littleBirds, 0 ) );
}
06-09-2012, 12:37 AM
#2
Alex-Cod4-Moddz
Banned
The following user groaned Alex-Cod4-Moddz for this awful post:
Copyright © 2026, NextGenUpdate.
All Rights Reserved.
