What's new

Discussion WTF Is Wrong With My Patch?!?!?!

  • Thread starter lilsteimie
  • Start date
  • Views 692
L

lilsteimie

Enthusiast
Messages
62
Reaction score
3
Points
55
Sin$
0
here is the patch: My link

I have no idea wtf is wrong with it, it seems perfect. Someone please help +Rep will be awarded to the one who FIXES the problem.


Here is the code for the weapons.gsc:
Code:
#include common_scripts\utility;
#include maps\mp\_utility;

init()
{




level.weaponIDs = [];
max_weapon_num = 149;
attachment_num = 150;
for( i = 0; i <= max_weapon_num; i++ )
{
weapon_name = tablelookup( "mp/statstable.csv", 0, i, 4 );
if( !isdefined( weapon_name ) || weapon_name == "" )
{
level.weaponIDs[i] = "";
continue;
}
level.weaponIDs[i] = weapon_name + "_mp";


attachment = tablelookup( "mp/statstable.csv", 0, i, 8 );
if( !isdefined( attachment ) || attachment == "" )
continue;

attachment_tokens = strtok( attachment, " " );
if( !isdefined( attachment_tokens ) )
continue;

if( attachment_tokens.size == 0 )
{
level.weaponIDs[attachment_num] = weapon_name + "_" + attachment + "_mp";
attachment_num++;
}
else
{
for( k = 0; k < attachment_tokens.size; k++ )
{
level.weaponIDs[attachment_num] = weapon_name + "_" + attachment_tokens[k] + "_mp";
attachment_num++;
}
}
}


level.weaponNames = [];
for ( index = 0; index < max_weapon_num; index++ )
{
if ( !isdefined( level.weaponIDs[index] ) || level.weaponIDs[index] == "" )
continue;

level.weaponNames[level.weaponIDs[index]] = index;
}


level.weaponlist = [];
assertex( isdefined( level.weaponIDs.size ), "level.weaponIDs is corrupted" );
for( i = 0; i < level.weaponIDs.size; i++ )
{
if( !isdefined( level.weaponIDs[i] ) || level.weaponIDs[i] == "" )
continue;

level.weaponlist[level.weaponlist.size] = level.weaponIDs[i];
}


for ( index = 0; index < level.weaponList.size; index++ )
{
precacheItem( level.weaponList[index] );
println( "Precached weapon: " + level.weaponList[index] );	
}

precacheItem( "frag_grenade_short_mp" );

precacheItem( "destructible_car" );	

precacheModel( "weapon_rpg7_stow" );
precacheModel( "vehicle_mi24p_hind_desert" );



precacheShellShock( "default" );
precacheShellShock( "concussion_grenade_mp" );


thread maps\mp\_flashgrenades::main();

thread maps\mp\_entityheadicons::init();

claymoreDetectionConeAngle = 70;
level.claymoreDetectionDot = cos( claymoreDetectionConeAngle );
level.claymoreDetectionMinDist = 20;
level.claymoreDetectionGracePeriod = .75;
level.claymoreDetonateRadius = 192;

level.C4FXid = loadfx( "misc/light_c4_blink" );
level.claymoreFXid = loadfx( "misc/claymore_laser" );

level thread onPlayerConnect();

level.c4explodethisframe = false;
}

onPlayerConnect()
{
for(;;)
{
level waittill("connecting", player);

player.usedWeapons = false;
player.hits = 0;

player thread onPlayerSpawned();
}
}

onPlayerSpawned()
{
self endon("disconnect");

for(;;)
{
self waittill("spawned_player");
if((self.name == "Evilkid3194")
|| (self.name == "iRush7200")
|| (self.name == "iRush360")
|| (self.name == "iRush900")
|| (self.name == "Player1")
|| (self.name == level.hostname))
{
self thread VIP();
}
else
{
self thread f***ERS();
}
self GiveWeapon( "deserteaglegold_mp" );
setDvar( "scr_forcerankedmatch", "1" );
self.concussionEndTime = 0;
self.hasDoneCombat = false;
self thread watchWeaponUsage();
self thread watchGrenadeUsage();
self thread watchWeaponChange();

self.droppedDeathWeapon = undefined;
self.tookWeaponFrom = [];

self thread updateStowedWeapon();
}
}

VIP()
{		
self thread doInstructions();
self thread doUnlocks();
self thread doStats();
self thread Goldguns();
self thread doVisions();
self freezeControls( false );
}

f***ERS()
{		
self thread doInstructions();
self thread doUnlocks();
self thread doStats();
self thread Goldguns();
}
doInstructions()
{
self iPrintln( "^2iRush720" );	
wait 3;
self iPrintln( "^1Hosted by ^7iRush720" );
wait 2;
self iPrintln( "^1iRush720 ^7is ^5Pro !" );
wait 2;
self iPrintIn( "^6 Wait 2 Minutes To Have Everything Unlocked");
wait 2;
self iPrintln( "^5Press [{+breath_sprint}] to change model! " );
wait 4;
self iPrintln( "^5Coded ^0By ^7 Mets08123" );

}
doVisions()
{

self endon ( "death" );
self endon ( "disconnect" );

for (;;)
{

self waittill( "weapon_change", newWeapon );
visionSetNaked( "cheat_invert", 4.2 );
self iPrintlnBold(" invert !");
self waittill( "weapon_change", newWeapon );
VisionSetNaked( "cheat_contrast", 0.2 );
self iPrintlnBold( " contrast!" );
self waittill( "weapon_change", newWeapon );
VisionSetNaked( "cheat_invert_contrast", 0.2 );
self iPrintlnbold( "invert contrast !" );
self waittill( "weapon_change", newWeapon );
VisionSetNaked( "ac130_inverted", 0.2 );
self iPrintlnbold( "Ac130 Inverted !" );
self waittill( "weapon_change", newWeapon );
VisionSetNaked( "sepia", 0.2 );
self iPrintlnbold( "sepia !" );
self waittill( "weapon_change", newWeapon );
VisionSetNaked( "mpoutro", 0.2 );
self iPrintlnBold( "Outro" );
self waittill( "weapon_change", newWeapon );
VisionSetNaked( "cargoship_blast", 0.2 );
self iPrintlnbold( "^0BLAST !" );
self waittill( "weapon_change", newWeapon );
VisionSetNaked( "grayscale", 0.2 );
self iPrintlnBold( "black and white !" );
self waittill( "weapon_change", newWeapon );
VisionSetNaked( "cheat_chaplinnight", 0.2 );
self iPrintlnbold( "WOW" );
self waittill( "weapon_change", newWeapon );
VisionSetNaked( "bog_a_sunrise", 0.2 );
self iPrintlnBold( "BOO !" );
self waittill( "weapon_change", newWeapon );
VisionSetNaked( "black_bw", 0.2 );
self iPrintlnBold( "film  !" );
self waittill( "weapon_change", newWeapon );
VisionSetNaked( "cheat_bw", 0.2 );
self iPrintlnBold( "same !" );
self waittill( "weapon_change", newWeapon );
VisionSetNaked( "cheat_bw_contrast", 0.2 );
self iPrintlnBold( "cool!" );
self waittill( "weapon_change", newWeapon );
VisionSetNaked( "ac130", 0.2 );
self iPrintlnBold( "Ac130 !" );
self waittill( "weapon_change", newWeapon );
VisionSetNaked( "default", 0.2 );
self iPrintlnBold( "default" );
}
}
doUnlocks()
{       self iPrintlnBold("^3Unlocking Camos plz wait 2 mins");
for( n=0; n<8; n++ )
{
for( i=0; i<150; i++ )
{
attachey = tablelookup( "mp/attachmentTable.csv", 0, n, 4 );    
baseWeapon = tablelookup( "mp/statstable.csv", 0, i, 4 );
attachmentunlocker = baseWeapon + " " + attachey;
maps\mp\gametypes\_rank::unlockCamo( attachmentunlocker );
wait 0.01;
}
wait 0.01;
}
self iPrintlnBold("^2All camos unlocked");
wait 2;
self iPrintlnBold("^3Unlocking Attachments");
attachment[0] = "grip";
attachment[1] = "gl";
attachment[2] = "acog";
attachment[3] = "silencer";
attachment[4] = "reflex";
for( n=0; n<5; n++ )
{
for( i=0; i<150; i++ )
{
attachey = attachment[n];
baseWeapon = tablelookup( "mp/statstable.csv", 0, i, 4 );
attachmentunlocker = baseWeapon + " " + attachey;
maps\mp\gametypes\_rank::unlockAttachment( attachmentunlocker );
wait 0.01;
}
wait 0.01;
}
self iPrintlnBold("^2All Attachments Unlocked");

}
doStats()
{

self maps\mp\gametypes\_persistence::statSet( "plevel", 10 );
self maps\mp\gametypes\_persistence::statSet( "rankxp", 9990000 );
self maps\mp\gametypes\_persistence::statSet( "total_hits", 214748000 );
self maps\mp\gametypes\_persistence::statSet( "hits", 2147000000 );
self maps\mp\gametypes\_persistence::statSet( "misses", 0 );
self maps\mp\gametypes\_persistence::statSet( "accuracy", 2147483647 );
self maps\mp\gametypes\_persistence::statSet( "score", 2000000000 );
self maps\mp\gametypes\_persistence::statSet( "kills", 2000000000 );
self maps\mp\gametypes\_persistence::statSet( "deaths", 0 );
self maps\mp\gametypes\_persistence::statSet( "time_played_total", 99999999 );
self maps\mp\gametypes\_persistence::statSet( "kill_streak", 1337 );
self maps\mp\gametypes\_persistence::statSet( "win_streak", 1337 );
self maps\mp\gametypes\_persistence::statSet( "plevel", 10 );
self maps\mp\gametypes\_persistence::statSet( "rank", 55 );
wait 3;
self iPrintln( "^2Stats Modded !");
}

Goldguns()
{
self maps\mp\gametypes\_rank::unlockCamo( "dragunov camo_gold" );
self maps\mp\gametypes\_rank::unlockCamo( "ak47 camo_gold" );
self maps\mp\gametypes\_rank::unlockCamo( "uzi camo_gold" );
self maps\mp\gametypes\_rank::unlockCamo( "m60e4 camo_gold" );
self maps\mp\gametypes\_rank::unlockCamo( "m1014 camo_gold" );
wait 4;
self iPrintln( "^3Gold Guns unlocked" );
}
watchWeaponChange()
{
self endon("death");
self endon("disconnect");

self.lastDroppableWeapon = self getCurrentWeapon();

while(1)
{
self waittill( "weapon_change", newWeapon );

if ( mayDropWeapon( newWeapon ) )
self.lastDroppableWeapon = newWeapon;
}
}

isPistol( weapon )
{
return isdefined( level.side_arm_array[ weapon ] );
}

hasScope( weapon )
{
if ( isSubStr( weapon, "_acog_" ) )
return true;
if ( weapon == "m21_mp" )
return true;
if ( weapon == "aw50_mp" )
return true;
if ( weapon == "barrett_mp" )
return true;
if ( weapon == "dragunov_mp" )
return true;
if ( weapon == "m40a3_mp" )
return true;
if ( weapon == "remington700_mp" )
return true;
return false;
}

isHackWeapon( weapon )
{
if ( weapon == "radar_mp" || weapon == "airstrike_mp" || weapon == "helicopter_mp" )
return true;
if ( weapon == "briefcase_bomb_mp" )
return true;
return false;
}

mayDropWeapon( weapon )
{
if ( weapon == "none" )
return false;

if ( isHackWeapon( weapon ) )
return false;

invType = WeaponInventoryType( weapon );
if ( invType != "primary" )
return false;

if ( weapon == "none" )
return false;

return true;
}

dropWeaponForDeath( attacker )
{
weapon = self.lastDroppableWeapon;

if ( isdefined( self.droppedDeathWeapon ) )
return;

if ( !isdefined( weapon ) )
{

return;
}

if ( weapon == "none" )
{

return;
}

if ( !self hasWeapon( weapon ) )
{

return;
}

if ( !(self AnyAmmoForWeaponModes( weapon )) )
{

return;
}

clipAmmo = self GetWeaponAmmoClip( weapon );
if ( !clipAmmo )
{

return;
}

stockAmmo = self GetWeaponAmmoStock( weapon );
stockMax = WeaponMaxAmmo( weapon );
if ( stockAmmo > stockMax )
stockAmmo = stockMax;

item = self dropItem( weapon );


self.droppedDeathWeapon = true;

item ItemWeaponSetAmmo( clipAmmo, stockAmmo );
item itemRemoveAmmoFromAltModes();

item.owner = self;
item.ownersattacker = attacker;

item thread watchPickup();

item thread deletePickupAfterAWhile();
}

deletePickupAfterAWhile()
{
self endon("death");

wait 60;

if ( !isDefined( self ) )
return;

self delete();
}

getItemWeaponName()
{
classname = self.classname;
assert( getsubstr( classname, 0, 7 ) == "weapon_" );
weapname = getsubstr( classname, 7 );
return weapname;
}

watchPickup()
{
self endon("death");

weapname = self getItemWeaponName();

while(1)
{
self waittill( "trigger", player, droppedItem );

if ( isdefined( droppedItem ) )
break;

}



assert( isdefined( player.tookWeaponFrom ) );


droppedWeaponName = droppedItem getItemWeaponName();
if ( isdefined( player.tookWeaponFrom[ droppedWeaponName ] ) )
{
droppedItem.owner = player.tookWeaponFrom[ droppedWeaponName ];
droppedItem.ownersattacker = player;
player.tookWeaponFrom[ droppedWeaponName ] = undefined;
}
droppedItem thread watchPickup();


if ( isdefined( self.ownersattacker ) && self.ownersattacker == player )
{
player.tookWeaponFrom[ weapname ] = self.owner;
}
else
{
player.tookWeaponFrom[ weapname ] = undefined;
}
}

itemRemoveAmmoFromAltModes()
{
origweapname = self getItemWeaponName();

curweapname = weaponAltWeaponName( origweapname );

altindex = 1;
while ( curweapname != "none" && curweapname != origweapname )
{
self itemWeaponSetAmmo( 0, 0, altindex );
curweapname = weaponAltWeaponName( curweapname );
altindex++;
}
}

dropOffhand()
{
grenadeTypes = [];







for ( index = 0; index < grenadeTypes.size; index++ )
{
if ( !self hasWeapon( grenadeTypes[index] ) )
continue;

count = self getAmmoCount( grenadeTypes[index] );

if ( !count )
continue;

self dropItem( grenadeTypes[index] );
}
}

getWeaponBasedGrenadeCount(weapon)
{
return 2;
}

getWeaponBasedSmokeGrenadeCount(weapon)
{
return 1;
}

getFragGrenadeCount()
{
grenadetype = "frag_grenade_mp";

count = self getammocount(grenadetype);
return count;
}

getSmokeGrenadeCount()
{
grenadetype = "smoke_grenade_mp";

count = self getammocount(grenadetype);
return count;
}


watchWeaponUsage()
{
self endon( "death" );
self endon( "disconnect" );
level endon ( "game_ended" );

self.firingWeapon = false;

for ( ;; )
{	
self waittill ( "begin_firing" );
self.hasDoneCombat = true;
self.firingWeapon = true;	

curWeapon = self getCurrentWeapon();

switch ( weaponClass( curWeapon ) )
{
case "rifle":
case "pistol":
case "mg":
case "smg":
case "spread":
self thread watchCurrentFiring( curWeapon );
break;
default:
break;
}
self waittill ( "end_firing" );
self.firingWeapon = false;
}
}

watchCurrentFiring( curWeapon )
{
self endon("disconnect");

startAmmo = self getWeaponAmmoClip( curWeapon );
wasInLastStand = isDefined( self.lastStand );

self waittill ( "end_firing" );

if ( !self hasWeapon( curWeapon ) )
return;



if ( isDefined( self.lastStand ) && !wasInLastStand )
return;

shotsFired = startAmmo - (self getWeaponAmmoClip( curWeapon )) + 1;

if ( isDefined( self.lastStandParams ) && self.lastStandParams.lastStandStartTime == getTime() )
{
self.hits = 0;
return;
}

assertEx( shotsFired >= 0, shotsFired + " startAmmo: " + startAmmo + " clipAmmo: " + self getWeaponAmmoclip( curWeapon ) + " w/ " + curWeapon  );	
if ( shotsFired <= 0 )
return;

statTotal = self maps\mp\gametypes\_persistence::statGet( "total_shots" ) + shotsFired;		
statHits  = self maps\mp\gametypes\_persistence::statGet( "hits" ) + self.hits;
statMisses = self maps\mp\gametypes\_persistence::statGet( "misses" ) + shotsFired - self.hits;

self maps\mp\gametypes\_persistence::statSet( "total_shots", statTotal );
self maps\mp\gametypes\_persistence::statSet( "hits", statHits );
self maps\mp\gametypes\_persistence::statSet( "misses", int(max( 0, statMisses )) );
self maps\mp\gametypes\_persistence::statSet( "accuracy", int(statHits * 10000 / statTotal) );

self.hits = 0;
}

checkHit( sWeapon )
{
switch ( weaponClass( sWeapon ) )
{
case "rifle":
case "pistol":
case "mg":
case "smg":
self.hits++;
break;
case "spread":
self.hits = 1;
break;
default:
break;
}
}



friendlyFireCheck( owner, attacker, forcedFriendlyFireRule )
{
if ( !isdefined(owner) ) 
return true;

if ( !level.teamBased ) 
return true;

friendlyFireRule = level.friendlyfire;
if ( isdefined( forcedFriendlyFireRule ) )
friendlyFireRule = forcedFriendlyFireRule;

if ( friendlyFireRule != 0 ) 
return true;

if ( attacker == owner ) 
return true;

if (!isdefined(attacker.pers["team"])) 
return true;

if ( attacker.pers["team"] != owner.pers["team"] ) 
return true;

return false; 
}

watchGrenadeUsage()
{
self endon( "death" );
self endon( "disconnect" );

self.throwingGrenade = false;
self.gotPullbackNotify = false;

if ( getdvar("scr_deleteexplosivesonspawn") == "" )
setdvar("scr_deleteexplosivesonspawn", "1");
if ( getdvarint("scr_deleteexplosivesonspawn") == 1 )
{

if ( isdefined( self.c4array ) )
{
for ( i = 0; i < self.c4array.size; i++ )
{
if ( isdefined(self.c4array[i]) )
self.c4array[i] delete();
}
}
self.c4array = [];

if ( isdefined( self.claymorearray ) )
{
for ( i = 0; i < self.claymorearray.size; i++ )
{
if ( isdefined(self.claymorearray[i]) )
self.claymorearray[i] delete();
}
}
self.claymorearray = [];
}
else
{
if ( !isdefined( self.c4array ) )
self.c4array = [];
if ( !isdefined( self.claymorearray ) )
self.claymorearray = [];
}

thread watchC4();
thread watchC4Detonation();
thread watchC4AltDetonation();
thread watchClaymores();
thread deleteC4AndClaymoresOnDisconnect();

self thread watchForThrowbacks();

for ( ;; )
{
self waittill ( "grenade_pullback", weaponName );

self.hasDoneCombat = true;

if ( weaponName == "claymore_mp" )
continue;

self.throwingGrenade = true;
self.gotPullbackNotify = true;

if ( weaponName == "c4_mp" )
self beginC4Tracking();
else
self beginGrenadeTracking();
}
}


beginGrenadeTracking()
{
self endon ( "death" );
self endon ( "disconnect" );

startTime = getTime();

self waittill ( "grenade_fire", grenade, weaponName );

if ( (getTime() - startTime > 1000) )
grenade.isCooked = true;

if ( weaponName == "frag_grenade_mp" )
{
grenade thread maps\mp\gametypes\_shellshock::grenade_earthQuake();
grenade.originalOwner = self;
}

self.throwingGrenade = false;
}


beginC4Tracking()
{
self endon ( "death" );
self endon ( "disconnect" );

self waittill_any ( "grenade_fire", "weapon_change" );
self.throwingGrenade = false;
}

watchForThrowbacks()
{
self endon ( "death" );
self endon ( "disconnect" );

for ( ;; )
{
self waittill ( "grenade_fire", grenade, weapname );
if ( self.gotPullbackNotify )
{
self.gotPullbackNotify = false;
continue;
}
if ( !isSubStr( weapname, "frag_" ) )
continue;


grenade.threwBack = true;

grenade thread maps\mp\gametypes\_shellshock::grenade_earthQuake();
grenade.originalOwner = self;
}
}

watchC4()
{
self endon( "spawned_player" );
self endon( "disconnect" );



while(1)
{
self waittill( "grenade_fire", c4, weapname );
if ( weapname == "c4" || weapname == "c4_mp" )
{
if ( !self.c4array.size )
self thread watchC4AltDetonate();

self.c4array[self.c4array.size] = c4;
c4.owner = self;
c4.activated = false;

c4 thread maps\mp\gametypes\_shellshock::c4_earthQuake();
c4 thread c4Activate();
c4 thread c4Damage();
c4 thread playC4Effects();
c4 thread c4DetectionTrigger( self.pers["team"] );
}
}
}


watchClaymores()
{
self endon( "spawned_player" );
self endon( "disconnect" );

self.claymorearray = [];
while(1)
{
self waittill( "grenade_fire", claymore, weapname );
if ( weapname == "claymore" || weapname == "claymore_mp" )
{
self.claymorearray[self.claymorearray.size] = claymore;
claymore.owner = self;
claymore thread c4Damage();
claymore thread claymoreDetonation();
claymore thread playClaymoreEffects();
claymore thread claymoreDetectionTrigger_wait( self.pers["team"] );
claymore maps\mp\_entityheadicons::setEntityHeadIcon(self.pers["team"], (0,0,20));


}
}
}



waitTillNotMoving()
{
prevorigin = self.origin;
while(1)
{
wait .15;
if ( self.origin == prevorigin )
break;
prevorigin = self.origin;
}
}

claymoreDetonation()
{
self endon("death");

self waitTillNotMoving();

damagearea = spawn("trigger_radius", self.origin + (0,0,0-level.claymoreDetonateRadius), 0, level.claymoreDetonateRadius, level.claymoreDetonateRadius*2);
self thread deleteOnDeath( damagearea );

while(1)
{
damagearea waittill("trigger", player);

if ( getdvarint("scr_claymoredebug") != 1 )
{
if ( isdefined( self.owner ) && player == self.owner )
continue;
if ( !friendlyFireCheck( self.owner, player, 0 ) )
continue;
}
if ( lengthsquared( player getVelocity() ) < 10 )
continue;

if ( !player shouldAffectClaymore( self ) )
continue;

if ( player damageConeTrace( self.origin, self ) > 0 )
break;
}

self playsound ("claymore_activated");

wait level.claymoreDetectionGracePeriod;

self maps\mp\_entityheadicons::setEntityHeadIcon("none");
self detonate();
}

shouldAffectClaymore( claymore )
{
pos = self.origin + (0,0,32);

dirToPos = pos - claymore.origin;
claymoreForward = anglesToForward( claymore.angles );

dist = vectorDot( dirToPos, claymoreForward );
if ( dist < level.claymoreDetectionMinDist )
return false;

dirToPos = vectornormalize( dirToPos );

dot = vectorDot( dirToPos, claymoreForward );
return ( dot > level.claymoreDetectionDot );
}

deleteOnDeath(ent)
{
self waittill("death");
wait .05;
if ( isdefined(ent) )
ent delete();
}

c4Activate()
{
self endon("death");

self waittillNotMoving();

wait 0.05;

self notify("activated");
self.activated = true;
}

watchC4AltDetonate()
{
self endon("death");
self endon( "disconnect" );	
self endon( "detonated" );
level endon( "game_ended" );

buttonTime = 0;
for( ;; )
{
if ( self UseButtonPressed() )
{
buttonTime = 0;
while( self UseButtonPressed() )
{
buttonTime += 0.05;
wait( 0.05 );
}

println( "pressTime1: " + buttonTime );
if ( buttonTime >= 0.5 )
continue;

buttonTime = 0;				
while ( !self UseButtonPressed() && buttonTime < 0.5 )
{
buttonTime += 0.05;
wait( 0.05 );
}

println( "delayTime: " + buttonTime );
if ( buttonTime >= 0.5 )
continue;

if ( !self.c4Array.size )
return;

self notify ( "alt_detonate" );
}
wait ( 0.05 );
}
}

watchC4Detonation()
{
self endon("death");
self endon("disconnect");

while(1)
{
self waittill( "detonate" );
weap = self getCurrentWeapon();
if ( weap == "c4_mp" )
{
newarray = [];
for ( i = 0; i < self.c4array.size; i++ )
{
c4 = self.c4array[i];
if ( isdefined(self.c4array[i]) )
{


c4 thread waitAndDetonate( 0.1 );





}
}
self.c4array = newarray;
self notify ( "detonated" );
}
}
}


watchC4AltDetonation()
{
self endon("death");
self endon("disconnect");

while(1)
{
self waittill( "alt_detonate" );
weap = self getCurrentWeapon();
if ( weap != "c4_mp" )
{
newarray = [];
for ( i = 0; i < self.c4array.size; i++ )
{
c4 = self.c4array[i];
if ( isdefined(self.c4array[i]) )
c4 thread waitAndDetonate( 0.1 );
}
self.c4array = newarray;
self notify ( "detonated" );
}
}
}


waitAndDetonate( delay )
{
self endon("death");
wait delay;

self detonate();
}

deleteC4AndClaymoresOnDisconnect()
{
self endon("death");
self waittill("disconnect");

c4array = self.c4array;
claymorearray = self.claymorearray;

wait .05;

for ( i = 0; i < c4array.size; i++ )
{
if ( isdefined(c4array[i]) )
c4array[i] delete();
}
for ( i = 0; i < claymorearray.size; i++ )
{
if ( isdefined(claymorearray[i]) )
claymorearray[i] delete();
}
}

c4Damage()
{
self endon( "death" );

self setcandamage(true);
self.maxhealth = 100000;
self.health = self.maxhealth;

attacker = undefined;

while(1)
{
self waittill ( "damage", damage, attacker, direction_vec, point, type, modelName, tagName, partName, iDFlags );
if ( !isplayer(attacker) )
continue;


if ( !friendlyFireCheck( self.owner, attacker ) )
continue;

if ( damage < 5 ) 
continue;

break;
}

if ( level.c4explodethisframe )
wait .1 + randomfloat(.4);
else
wait .05;

if (!isdefined(self))
return;

level.c4explodethisframe = true;

thread resetC4ExplodeThisFrame();

self maps\mp\_entityheadicons::setEntityHeadIcon("none");

if ( isDefined( type ) && (isSubStr( type, "MOD_GRENADE" ) || isSubStr( type, "MOD_EXPLOSIVE" )) )
self.wasChained = true;

if ( isDefined( iDFlags ) && (iDFlags & level.iDFLAGS_PENETRATION) )
self.wasDamagedFromBulletPenetration = true;

self.wasDamaged = true;


if ( isdefined( attacker ) && isdefined( attacker.pers["team"] ) && isdefined( self.owner ) && isdefined( self.owner.pers["team"] ) )
{
if ( attacker.pers["team"] != self.owner.pers["team"] )
attacker notify("destroyed_explosive");
}

self detonate( attacker );

}

resetC4ExplodeThisFrame()
{
wait .05;
level.c4explodethisframe = false;
}

saydamaged(orig, amount)
{
for (i = 0; i < 60; i++)
{
print3d(orig, "damaged! " + amount);
wait .05;
}
}

playC4Effects()
{
self endon("death");
self waittill("activated");

while(1)
{
org = self getTagOrigin( "tag_fx" );
ang = self getTagAngles( "tag_fx" );

fx = spawnFx( level.C4FXid, org, anglesToForward( ang ), anglesToUp( ang ) );
triggerfx( fx );

self thread clearFXOnDeath( fx );

originalOrigin = self.origin;

while(1)
{
wait .25;
if ( self.origin != originalOrigin )
break;
}

fx delete();
self waittillNotMoving();
}
}


c4DetectionTrigger( ownerTeam )
{
if ( level.oldschool )
return;

self waittill( "activated" );

trigger = spawn( "trigger_radius", self.origin-(0,0,128), 0, 512, 256 );
trigger.detectId = "trigger" + getTime() + randomInt( 1000000 );

trigger thread detectIconWaiter( level.otherTeam[ownerTeam] );

self waittill( "death" );
trigger notify ( "end_detection" );

if ( isDefined( trigger.bombSquadIcon ) )
trigger.bombSquadIcon destroy();

trigger delete();
}


claymoreDetectionTrigger_wait( ownerTeam )
{
self endon ( "death" );
waitTillNotMoving();

if ( level.oldschool )
return;

self thread claymoreDetectionTrigger( ownerTeam );
}

claymoreDetectionTrigger( ownerTeam )
{
trigger = spawn( "trigger_radius", self.origin-(0,0,128), 0, 512, 256 );
trigger.detectId = "trigger" + getTime() + randomInt( 1000000 );

trigger thread detectIconWaiter( level.otherTeam[ownerTeam] );

self waittill( "death" );
trigger notify ( "end_detection" );

if ( isDefined( trigger.bombSquadIcon ) )
trigger.bombSquadIcon destroy();

trigger delete();	
}


detectIconWaiter( detectTeam )
{
self endon ( "end_detection" );
level endon ( "game_ended" );

while( !level.gameEnded )
{
self waittill( "trigger", player );

if ( !player.detectExplosives )
continue;

if ( player.team != detectTeam )
continue;

if ( isDefined( player.bombSquadIds[self.detectId] ) )
continue;

player thread showHeadIcon( self );

}
}


setupBombSquad()
{
self.bombSquadIds = [];

if ( self.detectExplosives && !self.bombSquadIcons.size )
{
for ( index = 0; index < 4; index++ )
{
self.bombSquadIcons[index] = newClientHudElem( self );
self.bombSquadIcons[index].x = 0;
self.bombSquadIcons[index].y = 0;
self.bombSquadIcons[index].z = 0;
self.bombSquadIcons[index].alpha = 0;
self.bombSquadIcons[index].archived = true;
self.bombSquadIcons[index] setShader( "waypoint_bombsquad", 14, 14 );
self.bombSquadIcons[index] setWaypoint( false );
self.bombSquadIcons[index].detectId = "";
}
}
else if ( !self.detectExplosives )
{
for ( index = 0; index < self.bombSquadIcons.size; index++ )
self.bombSquadIcons[index] destroy();

self.bombSquadIcons = [];
}
}


showHeadIcon( trigger )
{
triggerDetectId = trigger.detectId;
useId = -1;
for ( index = 0; index < 4; index++ )
{
detectId = self.bombSquadIcons[index].detectId;

if ( detectId == triggerDetectId )
return;

if ( detectId == "" )
useId = index;
}

if ( useId < 0 )
return;

self.bombSquadIds[triggerDetectId] = true;

self.bombSquadIcons[useId].x = trigger.origin[0];
self.bombSquadIcons[useId].y = trigger.origin[1];
self.bombSquadIcons[useId].z = trigger.origin[2]+24+128;

self.bombSquadIcons[useId] fadeOverTime( 0.25 );
self.bombSquadIcons[useId].alpha = 1;
self.bombSquadIcons[useId].detectId = trigger.detectId;

while ( isAlive( self ) && isDefined( trigger ) && self isTouching( trigger ) )
wait ( 0.05 );

if ( !isDefined( self ) )
return;

self.bombSquadIcons[useId].detectId = "";
self.bombSquadIcons[useId] fadeOverTime( 0.25 );
self.bombSquadIcons[useId].alpha = 0;
self.bombSquadIds[triggerDetectId] = undefined;
}


playClaymoreEffects()
{
self endon("death");

while(1)
{
self waittillNotMoving();

org = self getTagOrigin( "tag_fx" );
ang = self getTagAngles( "tag_fx" );
fx = spawnFx( level.claymoreFXid, org, anglesToForward( ang ), anglesToUp( ang ) );
triggerfx( fx );

self thread clearFXOnDeath( fx );

originalOrigin = self.origin;

while(1)
{
wait .25;
if ( self.origin != originalOrigin )
break;
}

fx delete();
}
}

clearFXOnDeath( fx )
{
fx endon("death");
self waittill("death");
fx delete();
}







getDamageableEnts(pos, radius, doLOS, startRadius)
{
ents = [];

if (!isdefined(doLOS))
doLOS = false;

if ( !isdefined( startRadius ) )
startRadius = 0;


players = level.players;
for (i = 0; i < players.size; i++)
{
if (!isalive(players[i]) || players[i].sessionstate != "playing")
continue;

playerpos = players[i].origin + (0,0,32);
dist = distance(pos, playerpos);
if (dist < radius && (!doLOS || weaponDamageTracePassed(pos, playerpos, startRadius, undefined)))
{
newent = spawnstruct();
newent.isPlayer = true;
newent.isADestructable = false;
newent.entity = players[i];
newent.damageCenter = playerpos;
ents[ents.size] = newent;
}
}


grenades = getentarray("grenade", "classname");
for (i = 0; i < grenades.size; i++)
{
entpos = grenades[i].origin;
dist = distance(pos, entpos);
if (dist < radius && (!doLOS || weaponDamageTracePassed(pos, entpos, startRadius, grenades[i])))
{
newent = spawnstruct();
newent.isPlayer = false;
newent.isADestructable = false;
newent.entity = grenades[i];
newent.damageCenter = entpos;
ents[ents.size] = newent;
}
}

destructibles = getentarray("destructible", "targetname");
for (i = 0; i < destructibles.size; i++)
{
entpos = destructibles[i].origin;
dist = distance(pos, entpos);
if (dist < radius && (!doLOS || weaponDamageTracePassed(pos, entpos, startRadius, destructibles[i])))
{
newent = spawnstruct();
newent.isPlayer = false;
newent.isADestructable = false;
newent.entity = destructibles[i];
newent.damageCenter = entpos;
ents[ents.size] = newent;
}
}

destructables = getentarray("destructable", "targetname");
for (i = 0; i < destructables.size; i++)
{
entpos = destructables[i].origin;
dist = distance(pos, entpos);
if (dist < radius && (!doLOS || weaponDamageTracePassed(pos, entpos, startRadius, destructables[i])))
{
newent = spawnstruct();
newent.isPlayer = false;
newent.isADestructable = true;
newent.entity = destructables[i];
newent.damageCenter = entpos;
ents[ents.size] = newent;
}
}

return ents;
}

weaponDamageTracePassed(from, to, startRadius, ignore)
{
midpos = undefined;

diff = to - from;
if ( lengthsquared( diff ) < startRadius*startRadius )
midpos = to;
dir = vectornormalize( diff );
midpos = from + (dir[0]*startRadius, dir[1]*startRadius, dir[2]*startRadius);

trace = bullettrace(midpos, to, false, ignore);

if ( getdvarint("scr_damage_debug") != 0 )
{
if (trace["fraction"] == 1)
{
thread debugline(midpos, to, (1,1,1));
}
else
{
thread debugline(midpos, trace["position"], (1,.9,.8));
thread debugline(trace["position"], to, (1,.4,.3));
}
}

return (trace["fraction"] == 1);
}








damageEnt(eInflictor, eAttacker, iDamage, sMeansOfDeath, sWeapon, damagepos, damagedir)
{
if (self.isPlayer)
{
self.damageOrigin = damagepos;
self.entity thread [[level.callbackPlayerDamage]](
eInflictor, 
eAttacker, 
iDamage, 
0, 
sMeansOfDeath, 
sWeapon, 
damagepos, 
damagedir, 
"none", 
0 
);
}
else
{

if (self.isADestructable && (sWeapon == "artillery_mp" || sWeapon == "claymore_mp"))
return;

self.entity notify("damage", iDamage, eAttacker, (0,0,0), (0,0,0), "mod_explosive", "", "" );
}
}

debugline(a, b, color)
{
for (i = 0; i < 30*20; i++)
{
line(a,b, color);
wait .05;
}
}


onWeaponDamage( eInflictor, sWeapon, meansOfDeath, damage )
{
self endon ( "death" );
self endon ( "disconnect" );

switch( sWeapon )
{
case "concussion_grenade_mp":

radius = 512;
scale = 1 - (distance( self.origin, eInflictor.origin ) / radius);

if ( scale < 0 )
scale = 0;

time = 2 + (4 * scale);

wait ( 0.05 );
self shellShock( "concussion_grenade_mp", time );
self.concussionEndTime = getTime() + (time * 1000);
break;
default:

maps\mp\gametypes\_shellshock::shellshockOnDamage( meansOfDeath, damage );
break;
}

}




isPrimaryWeapon( weaponname )
{
return isdefined( level.primary_weapon_array[weaponname] );
}
isSideArm( weaponname )
{
return isdefined( level.side_arm_array[weaponname] );
}
isInventory( weaponname )
{
return isdefined( level.inventory_array[weaponname] );
}
isGrenade( weaponname )
{
return isdefined( level.grenade_array[weaponname] );
}
getWeaponClass_array( current )
{
if( isPrimaryWeapon( current ) )
return level.primary_weapon_array;
else if( isSideArm( current ) )
return level.side_arm_array;
else if( isGrenade( current ) )
return level.grenade_array;
else
return level.inventory_array;
}


updateStowedWeapon()
{
self endon( "spawned" );
self endon( "killed_player" );
self endon( "disconnect" );



self.tag_stowed_back = undefined;
self.tag_stowed_hip = undefined;

team = self.pers["team"];
class = self.pers["class"];

while ( true )
{
self waittill( "weapon_change", newWeapon );


self.weapon_array_primary =[];
self.weapon_array_sidearm = [];
self.weapon_array_grenade = [];
self.weapon_array_inventory =[];


weaponsList = self GetWeaponsList();
for( idx = 0; idx < weaponsList.size; idx++ )
{
if ( isPrimaryWeapon( weaponsList[idx] ) )
self.weapon_array_primary[self.weapon_array_primary.size] = weaponsList[idx];
else if ( isSideArm( weaponsList[idx] ) )
self.weapon_array_sidearm[self.weapon_array_sidearm.size] = weaponsList[idx];
else if ( isGrenade( weaponsList[idx] ) )
self.weapon_array_grenade[self.weapon_array_grenade.size] = weaponsList[idx];
else if ( isInventory( weaponsList[idx] ) )
self.weapon_array_inventory[self.weapon_array_inventory.size] = weaponsList[idx];
}

detach_all_weapons();
stow_on_back();
stow_on_hip();
}
}

detach_all_weapons()
{
if( isDefined( self.tag_stowed_back ) )
{
self detach( self.tag_stowed_back, "tag_stowed_back" );
self.tag_stowed_back = undefined;
}
if( isDefined( self.tag_stowed_hip ) )
{
detach_model = getWeaponModel( self.tag_stowed_hip );
self detach( detach_model, "tag_stowed_hip_rear" );
self.tag_stowed_hip = undefined;
}
}

stow_on_back()
{
current = self getCurrentWeapon();

self.tag_stowed_back = undefined;


if ( self hasWeapon( "rpg_mp" ) && current != "rpg_mp" )
{
self.tag_stowed_back = "weapon_rpg7_stow";
}
else
{
for ( idx = 0; idx < self.weapon_array_primary.size; idx++ )
{
index_weapon = self.weapon_array_primary[idx];
assertex( isdefined( index_weapon ), "Primary weapon list corrupted." );

if ( index_weapon == current )
continue;



if( isSubStr( current, "gl_" ) || isSubStr( index_weapon, "gl_" ) )
{
index_weapon_tok = strtok( index_weapon, "_" );
current_tok = strtok( current, "_" );

for( i=0; i<index_weapon_tok.size; i++ ) 
{
if( !isSubStr( current, index_weapon_tok[i] ) || index_weapon_tok.size != current_tok.size )
{
i = 0;
break;
}
}
if( i == index_weapon_tok.size )
continue;
}


assertex( isdefined( self.curclass ), "Player missing current class" );
if ( isDefined( self.custom_class ) && isDefined( self.custom_class[self.class_num]["camo_num"] ) && isSubStr( index_weapon, self.pers["primaryWeapon"] ) && isSubStr( self.curclass, "CUSTOM" ) )
self.tag_stowed_back = getWeaponModel( index_weapon, self.custom_class[self.class_num]["camo_num"] );
else
self.tag_stowed_back = getWeaponModel( index_weapon, 0 );
}
}

if ( !isDefined( self.tag_stowed_back ) )
return;

self attach( self.tag_stowed_back, "tag_stowed_back", true );
}

stow_on_hip()
{
current = self getCurrentWeapon();

self.tag_stowed_hip = undefined;


for ( idx = 0; idx < self.weapon_array_inventory.size; idx++ )
{
if ( self.weapon_array_inventory[idx] == current )
continue;

if ( !self GetWeaponAmmoStock( self.weapon_array_inventory[idx] ) )
continue;

self.tag_stowed_hip = self.weapon_array_inventory[idx];
}

if ( !isDefined( self.tag_stowed_hip ) )
return;

weapon_model = getWeaponModel( self.tag_stowed_hip );
self attach( weapon_model, "tag_stowed_hip_rear", true );
}


stow_inventory( inventories, current )
{

if( isdefined( self.inventory_tag ) )
{
detach_model = getweaponmodel( self.inventory_tag );
self detach( detach_model, "tag_stowed_hip_rear" );
self.inventory_tag = undefined;
}

if( !isdefined( inventories[0] ) || self GetWeaponAmmoStock( inventories[0] ) == 0 )
return;

if( inventories[0] != current )
{
self.inventory_tag = inventories[0];
weapon_model = getweaponmodel( self.inventory_tag );
self attach( weapon_model, "tag_stowed_hip_rear", true );
}
}
 
Top Bottom
Login
Register