Results 1 to 8 of 8
  1. #1
    Faken's Avatar
    Join Date
    Jul 2010
    Gender
    male
    Posts
    3
    Reputation
    10
    Thanks
    0

    Disable Claymores from exploding?

    Hey guys,

    Not even sure if this is possible at all but any help or advice would sure be appreciated.

    I do enjoy playing quickscope mods and have previously made some of my own and used them with my friends, however I would like to be able to put claymores into the game for making nice trickshots, however I don't want the claymores being used for their real purpose which is putting on the ground and blowing people away.

    I was wondering if there was any possible way to stop the claymores from actually being tripped?

    If it's not possible then your time is certainly appreciated anyway.

    Thanks!

  2. #2
    .:MUS1CFR34K:.'s Avatar
    Join Date
    Apr 2011
    Gender
    male
    Location
    room 666
    Posts
    215
    Reputation
    12
    Thanks
    34
    My Mood
    Sneaky
    i think its not possible you would probably need mod tools for that so you could modify claymores unfortunately they dont exist sorry

  3. #3
    Jorndel's Avatar
    Join Date
    Jul 2010
    Gender
    male
    Location
    Norway
    Posts
    8,674
    Reputation
    905
    Thanks
    18,539
    My Mood
    Angelic
    Quote Originally Posted by .:MUS1CFR34K:. View Post
    i think its not possible you would probably need mod tools for that so you could modify claymores unfortunately they dont exist sorry
    Well, I think you can.

    This is the _weapon.gsc

    I have marked the line with big //LOOK HERE

    Almost at the end.....

    Code:
    #include common_scripts\utility;
    #include maps\mp\_utility;
    
    
    attachmentGroup( attachmentName )
    {
    	return tableLookup( "mp/attachmentTable.csv", 4, attachmentName, 2 );
    }
    
    getAttachmentList()
    {
    	attachmentList = [];
    	
    	index = 0;
    	attachmentName = tableLookup( "mp/attachmentTable.csv", 9, index, 4 );
    	
    	while ( attachmentName != "" )
    	{
    		attachmentList[attachmentList.size] = attachmentName;
    		
    		index++;
    		attachmentName = tableLookup( "mp/attachmentTable.csv", 9, index, 4 );
    	}
    	
    	return alphabetize( attachmentList );
    }
    
    init()
    {
    	level.scavenger_altmode = true;
    	level.scavenger_secondary = true;
    	
    	// 0 is not valid
    	level.maxPerPlayerExplosives = max( getIntProperty( "scr_maxPerPlayerExplosives", 2 ), 1 );
    	level.riotShieldXPBullets = getIntProperty( "scr_riotShieldXPBullets", 15 );
    
    	switch ( getIntProperty( "perk_scavengerMode", 0 ) )
    	{
    		case 1: // disable altmode
    			level.scavenger_altmode = false;
    			break;
    
    		case 2: // disable secondary
    			level.scavenger_secondary = false;
    			break;
    			
    		case 3: // disable altmode and secondary
    			level.scavenger_altmode = false;
    			level.scavenger_secondary = false;
    			break;		
    	}
    	
    	attachmentList = getAttachmentList();	
    	
    	// assigns weapons with stat numbers from 0-149
    	// attachments are now shown here, they are per weapon settings instead
    	
    	max_weapon_num = 149;
    
    	level.weaponList = [];
    	for( weaponId = 0; weaponId <= max_weapon_num; weaponId++ )
    	{
    		weapon_name = tablelookup( "mp/statstable.csv", 0, weaponId, 4 );
    		if( weapon_name == "" )
    			continue;
    	
    		if ( !isSubStr( tableLookup( "mp/statsTable.csv", 0, weaponId, 2 ), "weapon_" ) )
    			continue;
    			
    		level.weaponList[level.weaponList.size] = weapon_name + "_mp";
    		/#
    		if ( getDvar( "scr_dump_weapon_assets" ) != "" )
    		{
    			printLn( "" );
    			printLn( "// " + weapon_name + " real assets" );
    			printLn( "weapon,mp/" + weapon_name + "_mp" );
    		}
    		#/
    
    		// the alphabetize function is slow so we try not to do it for every weapon/attachment combo; a code solution would be better.
    		attachmentNames = [];
    		for ( innerLoopCount = 0; innerLoopCount < 10; innerLoopCount++ )
    		{
    			// generating attachment combinations
    			attachmentName = tablelookup( "mp/statStable.csv", 0, weaponId, innerLoopCount + 11 );
    			
    			if( attachmentName == "" )
    				break;
    			
    			attachmentNames[attachmentName] = true;
    		}
    
    		// generate an alphabetized attachment list
    		attachments = [];
    		foreach ( attachmentName in attachmentList )
    		{
    			if ( !isDefined( attachmentNames[attachmentName] ) )
    				continue;
    				
    			level.weaponList[level.weaponList.size] = weapon_name + "_" + attachmentName + "_mp";
    			attachments[attachments.size] = attachmentName;
    			/#
    			if ( getDvar( "scr_dump_weapon_assets" ) != "" )
    				println( "weapon,mp/" + weapon_name + "_" + attachmentName + "_mp" );
    			#/
    		}
    
    		attachmentCombos = [];
    		for ( i = 0; i < (attachments.size - 1); i++ )
    		{
    			colIndex = tableLookupRowNum( "mp/attachmentCombos.csv", 0, attachments[i] );
    			for ( j = i + 1; j < attachments.size; j++ )
    			{
    				if ( tableLookup( "mp/attachmentCombos.csv", 0, attachments[j], colIndex ) == "no" )
    					continue;
    					
    				attachmentCombos[attachmentCombos.size] = attachments[i] + "_" + attachments[j];
    			}
    		}
    
    		/#
    		if ( getDvar( "scr_dump_weapon_assets" ) != "" && attachmentCombos.size )
    			println( "// " + weapon_name + " virtual assets" );
    		#/
    		
    		foreach ( combo in attachmentCombos )
    		{
    			/#
    			if ( getDvar( "scr_dump_weapon_assets" ) != "" )
    				println( "weapon,mp/" + weapon_name + "_" + combo + "_mp" );
    			#/
    
    			level.weaponList[level.weaponList.size] = weapon_name + "_" + combo + "_mp";
    		}
    	}
    
    	foreach ( weaponName in level.weaponList )
    	{
    		precacheItem( weaponName );
    		
    		/#
    		if ( getDvar( "scr_dump_weapon_assets" ) != "" )
    		{
    			altWeapon = weaponAltWeaponName( weaponName );
    			if ( altWeapon != "none" )
    				println( "weapon,mp/" + altWeapon );				
    		}
    		#/
    	}
    
    	precacheItem( "flare_mp" );
    	precacheItem( "scavenger_bag_mp" );
    	precacheItem( "frag_grenade_short_mp" );	
    	precacheItem( "destructible_car" );
    	
    	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;
    	
    	// this should move to _stinger.gsc
    	level.stingerFXid = loadfx ("explosions/aerial_explosion_large");
    
    	// generating weapon type arrays which classifies the weapon as primary (back stow), pistol, or inventory (side pack stow)
    	// using mp/statstable.csv's weapon grouping data ( numbering 0 - 149 )
    	level.primary_weapon_array = [];
    	level.side_arm_array = [];
    	level.grenade_array = [];
    	level.inventory_array = [];
    	level.stow_priority_model_array = [];
    	level.stow_offset_array = [];
    	
    	max_weapon_num = 149;
    	for( i = 0; i < max_weapon_num; i++ )
    	{
    		weapon = tableLookup( "mp/statsTable.csv", 0, i, 4 );
    		stow_model = tableLookup( "mp/statsTable.csv", 0, i, 9 );
    		
    		if ( stow_model == "" )
    			continue;
    
    		precacheModel( stow_model );		
    
    		if ( isSubStr( stow_model, "weapon_stow_" ) )
    			level.stow_offset_array[ weapon ] = stow_model;
    		else
    			level.stow_priority_model_array[ weapon + "_mp" ] = stow_model;
    	}
    	
    	precacheModel( "weapon_claymore_bombsquad" );
    	precacheModel( "weapon_c4_bombsquad" );
    	precacheModel( "projectile_m67fraggrenade_bombsquad" );
    	precacheModel( "projectile_semtex_grenade_bombsquad" );
    	precacheModel( "weapon_light_stick_tactical_bombsquad" );
    	
    	level.killStreakSpecialCaseWeapons = [];
    	level.killStreakSpecialCaseWeapons["cobra_player_minigun_mp"] = true;
    	level.killStreakSpecialCaseWeapons["artillery_mp"] = true;
    	level.killStreakSpecialCaseWeapons["stealth_bomb_mp"] = true;
    	level.killStreakSpecialCaseWeapons["pavelow_minigun_mp"] = true;
    	level.killStreakSpecialCaseWeapons["sentry_minigun_mp"] = true;
    	level.killStreakSpecialCaseWeapons["harrier_20mm_mp"] = true;
    	level.killStreakSpecialCaseWeapons["ac130_105mm_mp"] = true;
    	level.killStreakSpecialCaseWeapons["ac130_40mm_mp"] = true;
    	level.killStreakSpecialCaseWeapons["ac130_25mm_mp"] = true;
    	level.killStreakSpecialCaseWeapons["remotemissile_projectile_mp"] = true;
    	level.killStreakSpecialCaseWeapons["cobra_20mm_mp"] = true;
    	level.killStreakSpecialCaseWeapons["sentry_minigun_mp"] = true;
    
    	
    	level thread onPlayerConnect();
    	
    	level.c4explodethisframe = false;
    
    	array_thread( getEntArray( "misc_turret", "classname" ), ::turret_monitorUse );
    	
    //	thread dumpIt();
    }
    
    
    dumpIt()
    {
    	
    	wait ( 5.0 );
    	/#
    	max_weapon_num = 149;
    
    	for( weaponId = 0; weaponId <= max_weapon_num; weaponId++ )
    	{
    		weapon_name = tablelookup( "mp/statstable.csv", 0, weaponId, 4 );
    		if( weapon_name == "" )
    			continue;
    	
    		if ( !isSubStr( tableLookup( "mp/statsTable.csv", 0, weaponId, 2 ), "weapon_" ) )
    			continue;
    			
    		if ( getDvar( "scr_dump_weapon_challenges" ) != "" )
    		{
    			/*
    			sharpshooter
    			marksman
    			veteran
    			expert
    			master
    			*/
    
    			weaponLStringName = tableLookup( "mp/statsTable.csv", 0, weaponId, 3 );
    			weaponRealName = tableLookupIString( "mp/statsTable.csv", 0, weaponId, 3 );
    
    			prefix = "WEAPON_";
    			weaponCapsName = getSubStr( weaponLStringName, prefix.size, weaponLStringName.size );
    
    			weaponGroup = tableLookup( "mp/statsTable.csv", 0, weaponId, 2 );
    			
    			weaponGroupSuffix = getSubStr( weaponGroup, prefix.size, weaponGroup.size );
    
    			/*
    			iprintln( "REFERENCE           TITLE_" + weaponCapsName + "_SHARPSHOOTER" );
    			iprintln( "LANG_ENGLISH        ", weaponRealName, ": Sharpshooter" );
    			iprintln( "" );
    			iprintln( "REFERENCE           TITLE_" + weaponCapsName + "_MARKSMAN" );
    			iprintln( "LANG_ENGLISH        ", weaponRealName, ": Marksman" );
    			iprintln( "" );
    			iprintln( "REFERENCE           TITLE_" + weaponCapsName + "_VETERAN" );
    			iprintln( "LANG_ENGLISH        ", weaponRealName, ": Veteran" );
    			iprintln( "" );
    			iprintln( "REFERENCE           TITLE_" + weaponCapsName + "_EXPERT" );
    			iprintln( "LANG_ENGLISH        ", weaponRealName, ": Expert" );
    			iprintln( "" );
    			iprintln( "REFERENCE           TITLE_" + weaponCapsName + "_Master" );
    			iprintln( "LANG_ENGLISH        ", weaponRealName, ": Master" );
    			*/
    			
    			iprintln( "cardtitle_" + weapon_name + "_sharpshooter,PLAYERCARDS_TITLE_" + weaponCapsName + "_SHARPSHOOTER,cardtitle_" + weaponGroupSuffix + "_sharpshooter,1,1,1" );
    			iprintln( "cardtitle_" + weapon_name + "_marksman,PLAYERCARDS_TITLE_" + weaponCapsName + "_MARKSMAN,cardtitle_" + weaponGroupSuffix + "_marksman,1,1,1" );
    			iprintln( "cardtitle_" + weapon_name + "_veteran,PLAYERCARDS_TITLE_" + weaponCapsName + "_VETERAN,cardtitle_" + weaponGroupSuffix + "_veteran,1,1,1" );
    			iprintln( "cardtitle_" + weapon_name + "_expert,PLAYERCARDS_TITLE_" + weaponCapsName + "_EXPERT,cardtitle_" + weaponGroupSuffix + "_expert,1,1,1" );
    			iprintln( "cardtitle_" + weapon_name + "_master,PLAYERCARDS_TITLE_" + weaponCapsName + "_MASTER,cardtitle_" + weaponGroupSuffix + "_master,1,1,1" );
    			
    			wait ( 0.05 );
    		}
    	}
    	#/
    }
    
    bombSquadWaiter()
    {
    	self endon ( "disconnect" );
    	
    	for ( ;; )
    	{
    		self waittill ( "grenade_fire", weaponEnt, weaponName );
    		
    		team = level.otherTeam[self.team];
    		
    		if ( weaponName == "c4_mp" )
    			weaponEnt thread createBombSquadModel( "weapon_c4_bombsquad", "tag_origin", team, self );
    		else if ( weaponName == "claymore_mp" )
    			weaponEnt thread createBombSquadModel( "weapon_claymore_bombsquad", "tag_origin", team, self );
    		else if ( weaponName == "frag_grenade_mp" )
    			weaponEnt thread createBombSquadModel( "projectile_m67fraggrenade_bombsquad", "tag_weapon", team, self );
    		else if ( weaponName == "frag_grenade_short_mp" )
    			weaponEnt thread createBombSquadModel( "projectile_m67fraggrenade_bombsquad", "tag_weapon", team, self );
    		else if ( weaponName == "semtex_mp" )
    			weaponEnt thread createBombSquadModel( "projectile_semtex_grenade_bombsquad", "tag_weapon", team, self );
    	}
    }
    
    
    createBombSquadModel( modelName, tagName, teamName, owner )
    {
    	bombSquadModel = spawn( "script_model", (0,0,0) );
    	bombSquadModel hide();
    	wait ( 0.05 );
    	
    	if (!isDefined( self ) ) //grenade model may not be around if picked up
    		return;
    		
    	bombSquadModel thread bombSquadVisibilityUpdater( teamName, owner );
    	bombSquadModel setModel( modelName );
    	bombSquadModel linkTo( self, tagName, (0,0,0), (0,0,0) );
    	bombSquadModel SetContents( 0 );
    	
    	self waittill ( "death" );
    	
    	bombSquadModel delete();
    }
    
    
    bombSquadVisibilityUpdater( teamName, owner )
    {
    	self endon ( "death" );
    
    	foreach ( player in level.players )
    	{
    		if ( level.teamBased )
    		{
    			if ( player.team == teamName && player _hasPerk( "specialty_detectexplosive" ) )
    				self showToPlayer( player );
    		}
    		else
    		{
    			if ( isDefined( owner ) && player == owner )
    				continue;
    			
    			if ( !player _hasPerk( "specialty_detectexplosive" ) )
    				continue;
    				
    			self showToPlayer( player );
    		}		
    	}
    	
    	for ( ;; )
    	{
    		level waittill_any( "joined_team", "player_spawned", "changed_kit" );
    		
    		self hide();
    
    		foreach ( player in level.players )
    		{
    			if ( level.teamBased )
    			{
    				if ( player.team == teamName && player _hasPerk( "specialty_detectexplosive" ) )
    					self showToPlayer( player );
    			}
    			else
    			{
    				if ( isDefined( owner ) && player == owner )
    					continue;
    				
    				if ( !player _hasPerk( "specialty_detectexplosive" ) )
    					continue;
    					
    				self showToPlayer( player );
    			}		
    		}
    	}
    }
    
    
    onPlayerConnect()
    {
    	for(;;)
    	{
    		level waittill("connected", player);
    
    		player.hits = 0;
    		player.hasDoneCombat = false;
    
    		player KC_RegWeaponForFXRemoval( "remotemissile_projectile_mp" );
    
    		player thread onPlayerSpawned();
    		player thread bombSquadWaiter();
    	}
    }
    
    
    onPlayerSpawned()
    {
    	self endon("disconnect");
    
    	for(;;)
    	{
    		self waittill("spawned_player");
    		
    		self.currentWeaponAtSpawn = self getCurrentWeapon(); // optimization so these threads we start don't have to call it.
    		
    		self.empEndTime = 0;
    		self.concussionEndTime = 0;
    		self.hasDoneCombat = false;
    		self thread watchWeaponUsage();
    		self thread watchGrenadeUsage();
    		self thread watchWeaponChange();
    		self thread watchStingerUsage();
    		self thread watchJavelinUsage();
    		self thread watchMissileUsage();
    		self thread watchSentryUsage();
    		self thread watchWeaponReload();
    		self thread maps\mp\gametypes\_class::trackRiotShield();
    
    		self.lastHitTime = [];
    		
    		self.droppedDeathWeapon = undefined;
    		self.tookWeaponFrom = [];
    		
    		self thread updateStowedWeapon();
    		
    		self thread updateSavedLastWeapon();
    		
    		if ( self hasWeapon( "semtex_mp" ) )
    			self thread monitorSemtex();
    		
    		self.currentWeaponAtSpawn = undefined;
    	}
    }
    
    WatchStingerUsage()
    {
    	self maps\mp\_stinger::StingerUsageLoop();
    }
    
    
    WatchJavelinUsage()
    {
    	self maps\mp\_javelin::JavelinUsageLoop();
    }
    
    watchWeaponChange()
    {
    	self endon("death");
    	self endon("disconnect");
    	
    	self thread watchStartWeaponChange();
    	self.lastDroppableWeapon = self.currentWeaponAtSpawn;
    	self.hitsThisMag = [];
    
    	weapon = self getCurrentWeapon();
    	
    	if ( isCACPrimaryWeapon( weapon ) && !isDefined( self.hitsThisMag[ weapon ] ) )
    		self.hitsThisMag[ weapon ] = weaponClipSize( weapon );
    
    	self.bothBarrels = undefined;
    
    	if ( isSubStr( weapon, "ranger" ) )
    		self thread watchRangerUsage( weapon );
    
    	while(1)
    	{
    		self waittill( "weapon_change", newWeapon );
    		
    		tokedNewWeapon = StrTok( newWeapon, "_" );
    
    		self.bothBarrels = undefined;
    
    		if ( isSubStr( newWeapon, "ranger" ) )
    			self thread watchRangerUsage( newWeapon );
    
    		if ( tokedNewWeapon[0] == "gl" || ( tokedNewWeapon.size > 2 && tokedNewWeapon[2] == "attach" ) )
    			newWeapon = self getCurrentPrimaryWeapon();
    
    		if ( newWeapon != "none" )
    		{
    			if ( isCACPrimaryWeapon( newWeapon ) && !isDefined( self.hitsThisMag[ newWeapon ] ) )
    				self.hitsThisMag[ newWeapon ] = weaponClipSize( newWeapon );
    		}
    		self.changingWeapon = undefined;
    		if ( mayDropWeapon( newWeapon ) )
    			self.lastDroppableWeapon = newWeapon;
    	}
    }
    
    
    watchStartWeaponChange()
    {
    	self endon("death");
    	self endon("disconnect");
    	self.changingWeapon = undefined;
    
    	while(1)
    	{
    		self waittill( "weapon_switch_started", newWeapon );
    		self.changingWeapon = newWeapon;
    	}
    }
    
    watchWeaponReload()
    {
    	self endon("death");
    	self endon("disconnect");
    
    	for ( ;; )
    	{
    		self waittill( "reload" );
    
    		weaponName = self getCurrentWeapon();
    
    		self.bothBarrels = undefined;
    		
    		if ( !isSubStr( weaponName, "ranger" ) )
    			continue;
    
    		self thread watchRangerUsage( weaponName );
    	}
    }
    
    
    watchRangerUsage( rangerName )
    {
    	rightAmmo = self getWeaponAmmoClip( rangerName, "right" );
    	leftAmmo = self getWeaponAmmoClip( rangerName, "left" );
    
    	self endon ( "reload" );
    	self endon ( "weapon_change" );
    
    	for ( ;; )
    	{
    		self waittill ( "weapon_fired", weaponName );
    		
    		if ( weaponName != rangerName )
    			continue;
    
    		self.bothBarrels = undefined;
    
    		if ( isSubStr( rangerName, "akimbo" ) )
    		{
    			newLeftAmmo = self getWeaponAmmoClip( rangerName, "left" );
    			newRightAmmo = self getWeaponAmmoClip( rangerName, "right" );
    
    			if ( leftAmmo != newLeftAmmo && rightAmmo != newRightAmmo )
    				self.bothBarrels = true;
    			
    			if ( !newLeftAmmo || !newRightAmmo )
    				return;
    				
    				
    			leftAmmo = newLeftAmmo;
    			rightAmmo = newRightAmmo;
    		}
    		else if ( rightAmmo == 2 && !self getWeaponAmmoClip( rangerName, "right" ) )
    		{
    			self.bothBarrels = true;
    			return;
    		}
    	}
    }
    
    
    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 ( isSubStr( weapon, "ac130" ) )
    		return false;
    
    	invType = WeaponInventoryType( weapon );
    	if ( invType != "primary" )
    		return false;
    	
    	return true;
    }
    
    dropWeaponForDeath( attacker )
    {
    	weapon = self.lastDroppableWeapon;
    	
    	if ( isdefined( self.droppedDeathWeapon ) )
    		return;
    
    	if ( level.inGracePeriod )
    		return;
    	
    	if ( !isdefined( weapon ) )
    	{
    		/#
    		if ( getdvar("scr_dropdebug") == "1" )
    			println( "didn't drop weapon: not defined" );
    		#/
    		return;
    	}
    	
    	if ( weapon == "none" )
    	{
    		/#
    		if ( getdvar("scr_dropdebug") == "1" )
    			println( "didn't drop weapon: weapon == none" );
    		#/
    		return;
    	}
    	
    	if ( !self hasWeapon( weapon ) )
    	{
    		/#
    		if ( getdvar("scr_dropdebug") == "1" )
    			println( "didn't drop weapon: don't have it anymore (" + weapon + ")" );
    		#/
    		return;
    	}
    	
    	if ( weapon != "riotshield_mp" )
    	{
    		if ( !(self AnyAmmoForWeaponModes( weapon )) )
    		{
    			/#
    			if ( getdvar("scr_dropdebug") == "1" )
    			  println( "didn't drop weapon: no ammo for weapon modes" );
    			#/
    			return;
    		}
    
    		clipAmmoR = self GetWeaponAmmoClip( weapon, "right" );
    		clipAmmoL = self GetWeaponAmmoClip( weapon, "left" );
    		if ( !clipAmmoR && !clipAmmoL )
    		{
    			/#
    			if ( getdvar("scr_dropdebug") == "1" )
    			  println( "didn't drop weapon: no ammo in clip" );
    			#/
    			return;
    		}
      
    		stockAmmo = self GetWeaponAmmoStock( weapon );
    		stockMax = WeaponMaxAmmo( weapon );
    		if ( stockAmmo > stockMax )
    			stockAmmo = stockMax;
    
    		item = self dropItem( weapon );
    		item ItemWeaponSetAmmo( clipAmmoR, stockAmmo, clipAmmoL );
    	}
    	else
    	{
    		item = self dropItem( weapon );	
    		if ( !isDefined( item ) )
    			return;
    		item ItemWeaponSetAmmo( 1, 1, 0 );
    	}
    
    	/#
    	if ( getdvar("scr_dropdebug") == "1" )
    		println( "dropped weapon: " + weapon );
    	#/
    
    	self.droppedDeathWeapon = true;
    
    	item.owner = self;
    	item.ownersattacker = attacker;
    
    	item thread watchPickup();
    
    	item thread deletePickupAfterAWhile();
    
    	detach_model = getWeaponModel( weapon );
    
    	if ( !isDefined( detach_model ) )
    		return;
    
    	if( isDefined( self.tag_stowed_back ) && detach_model == self.tag_stowed_back )
    		self detach_back_weapon();
    
    	if ( !isDefined( self.tag_stowed_hip ) )
    		return;
    
    	if( detach_model == self.tag_stowed_hip )
    		self detach_hip_weapon();
    }
    
    
    detachIfAttached( model, baseTag )
    {
    	attachSize = self getAttachSize();
    	
    	for ( i = 0; i < attachSize; i++ )
    	{
    		attach = self getAttachModelName( i );
    		
    		if ( attach != model )
    			continue;
    		
    		tag = self getAttachTagName( i );			
    		self detach( model, tag );
    		
    		if ( tag != baseTag )
    		{
    			attachSize = self getAttachSize();
    			
    			for ( i = 0; i < attachSize; i++ )
    			{
    				tag = self getAttachTagName( i );
    				
    				if ( tag != baseTag )
    					continue;
    					
    				model = self getAttachModelName( i );
    				self detach( model, tag );
    				
    				break;
    			}
    		}		
    		return true;
    	}
    	return false;
    }
    
    
    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;
    		// otherwise, player merely acquired ammo and didn't pick this up
    	}
    	
    	/#
    	if ( getdvar("scr_dropdebug") == "1" )
    		println( "picked up weapon: " + weapname + ", " + isdefined( self.ownersattacker ) );
    	#/
    
    	assert( isdefined( player.tookWeaponFrom ) );
    	
    	// make sure the owner information on the dropped item is preserved
    	droppedWeaponName = droppedItem getItemWeaponName();
    	if ( isdefined( player.tookWeaponFrom[ droppedWeaponName ] ) )
    	{
    		droppedItem.owner = player.tookWeaponFrom[ droppedWeaponName ];
    		droppedItem.ownersattacker = player;
    		player.tookWeaponFrom[ droppedWeaponName ] = undefined;
    	}
    	droppedItem thread watchPickup();
    	
    	// take owner information from self and put it onto player
    	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, 0, altindex );
    		curweapname = weaponAltWeaponName( curweapname );
    		altindex++;
    	}
    }
    
    
    handleScavengerBagPickup( scrPlayer )
    {
    	self endon( "death" );
    	level endon ( "game_ended" );
    
    	assert( isDefined( scrPlayer ) );
    
    	// Wait for the pickup to happen
    	self waittill( "scavenger", destPlayer );
    	assert( isDefined ( destPlayer ) );
    
    	destPlayer notify( "scavenger_pickup" );
    	destPlayer playLocalSound( "scavenger_pack_pickup" );
    	
    	offhandWeapons = destPlayer getWeaponsListOffhands();
    	
    	if ( destPlayer _hasPerk( "specialty_tacticalinsertion" ) && destPlayer getAmmoCount( "flare_mp" ) < 1 )
    		destPlayer _setPerk( "specialty_tacticalinsertion");	
    		
    	foreach ( offhand in offhandWeapons )
    	{		
    		currentClipAmmo = destPlayer GetWeaponAmmoClip( offhand );
    		destPlayer SetWeaponAmmoClip( offhand, currentClipAmmo + 1);
    	}
    
    	primaryWeapons = destPlayer getWeaponsListPrimaries();	
    	foreach ( primary in primaryWeapons )
    	{
    		if ( !isCACPrimaryWeapon( primary ) && !level.scavenger_secondary )
    			continue;
    			
    		currentStockAmmo = destPlayer GetWeaponAmmoStock( primary );
    		addStockAmmo = weaponClipSize( primary );
    		
    		destPlayer setWeaponAmmoStock( primary, currentStockAmmo + addStockAmmo );
    
    		altWeapon = weaponAltWeaponName( primary );
    
    		if ( !isDefined( altWeapon ) || (altWeapon == "none") || !level.scavenger_altmode )
    			continue;
    
    		currentStockAmmo = destPlayer GetWeaponAmmoStock( altWeapon );
    		addStockAmmo = weaponClipSize( altWeapon );
    
    		destPlayer setWeaponAmmoStock( altWeapon, currentStockAmmo + addStockAmmo );
    	}
    
    	destPlayer maps\mp\gametypes\_damagefeedback::updateDamageFeedback( "scavenger" );
    }
    
    
    dropScavengerForDeath( attacker )
    {
    	if ( level.inGracePeriod )
    		return;
    	
     	if( !isDefined( attacker ) )
     		return;
    
     	if( attacker == self )
     		return;
    
    	dropBag = self dropScavengerBag( "scavenger_bag_mp" );	
    	dropBag thread handleScavengerBagPickup( self );
    
    }
    
    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( weaponHand )
    {
    	self endon( "death" );
    	self endon( "disconnect" );
    	level endon ( "game_ended" );
    	
    	for ( ;; )
    	{	
    		self waittill ( "weapon_fired", weaponName );
    
    		self.hasDoneCombat = true;
    
    		if ( !maps\mp\gametypes\_weapons::isPrimaryWeapon( weaponName ) && !maps\mp\gametypes\_weapons::isSideArm( weaponName ) )
    			continue;
    		
    		if ( isDefined( self.hitsThisMag[ weaponName ] ) )
    			self thread updateMagShots( weaponName );
    			
    		totalShots = self maps\mp\gametypes\_persistence::statGetBuffered( "totalShots" ) + 1;
    		hits = self maps\mp\gametypes\_persistence::statGetBuffered( "hits" );
    		self maps\mp\gametypes\_persistence::statSetBuffered( "totalShots", totalShots );
    		self maps\mp\gametypes\_persistence::statSetBuffered( "accuracy", int(hits * 10000 / totalShots) );		
    		self maps\mp\gametypes\_persistence::statSetBuffered( "misses", int(totalShots - hits) );
    	}
    }
    
    
    updateMagShots( weaponName )
    {
    	self endon ( "death" );
    	self endon ( "disconnect" );
    	self endon ( "updateMagShots_" + weaponName );
    	
    	self.hitsThisMag[ weaponName ]--;
    	
    	wait ( 0.05 );
    	
    	self.hitsThisMag[ weaponName ] = weaponClipSize( weaponName );
    }
    
    
    checkHitsThisMag( weaponName )
    {
    	self endon ( "death" );
    	self endon ( "disconnect" );
    
    	self notify ( "updateMagShots_" + weaponName );
    	waittillframeend;
    	
    	if ( self.hitsThisMag[ weaponName ] == 0 )
    	{
    		weaponClass = getWeaponClass( weaponName );
    		
    		maps\mp\gametypes\_missions::genericChallenge( weaponClass );
    
    		self.hitsThisMag[ weaponName ] = weaponClipSize( weaponName );
    	}	
    }
    
    
    checkHit( weaponName, victim )
    {
    	if ( !maps\mp\gametypes\_weapons::isPrimaryWeapon( weaponName ) && !maps\mp\gametypes\_weapons::isSideArm( weaponName ) )
    		return;
    
    	// sometimes the "weapon_fired" notify happens after we hit the guy...
    	waittillframeend;
    
    	if ( isDefined( self.hitsThisMag[ weaponName ] ) )
    		self thread checkHitsThisMag( weaponName );
    
    	if ( !isDefined( self.lastHitTime[ weaponName ] ) )
    		self.lastHitTime[ weaponName ] = 0;
    		
    	// already hit with this weapon on this frame
    	if ( self.lastHitTime[ weaponName ] == getTime() )
    		return;
    
    	self.lastHitTime[ weaponName ] = getTime();
    
    	totalShots = self maps\mp\gametypes\_persistence::statGetBuffered( "totalShots" );		
    	hits = self maps\mp\gametypes\_persistence::statGetBuffered( "hits" ) + 1;
    
    	if ( hits <= totalShots )
    	{
    		self maps\mp\gametypes\_persistence::statSetBuffered( "hits", hits );
    		self maps\mp\gametypes\_persistence::statSetBuffered( "misses", int(totalShots - hits) );
    		self maps\mp\gametypes\_persistence::statSetBuffered( "accuracy", int(hits * 10000 / totalShots) );
    	}
    }
    
    
    attackerCanDamageItem( attacker, itemOwner )
    {
    	return friendlyFireCheck( itemOwner, attacker );
    }
    
    // returns true if damage should be done to the item given its owner and the attacker
    friendlyFireCheck( owner, attacker, forcedFriendlyFireRule )
    {
    	if ( !isdefined( owner ) )// owner has disconnected? allow it
    		return true;
    
    	if ( !level.teamBased )// not a team based mode? allow it
    		return true;
    
    	attackerTeam = attacker.team;
    
    	friendlyFireRule = level.friendlyfire;
    	if ( isdefined( forcedFriendlyFireRule ) )
    		friendlyFireRule = forcedFriendlyFireRule;
    
    	if ( friendlyFireRule != 0 )// friendly fire is on? allow it
    		return true;
    
    	if ( attacker == owner )// owner may attack his own items
    		return true;
    
    	if ( !isdefined( attackerTeam ) )// attacker not on a team? allow it
    		return true;
    
    	if ( attackerTeam != owner.team )// attacker not on the same team as the owner? allow it
    		return true;
    
    	return false;// disallow it
    }
    
    watchGrenadeUsage()
    {
    	self endon( "death" );
    	self endon( "disconnect" );
    
    	self.throwingGrenade = undefined;
    	self.gotPullbackNotify = false;
    
    	if ( getIntProperty( "scr_deleteexplosivesonspawn", 1 ) == 1 )
    	{
    		// delete c4 from previous spawn
    		if ( isdefined( self.c4array ) )
    		{
    			for ( i = 0; i < self.c4array.size; i++ )
    			{
    				if ( isdefined( self.c4array[ i ] ) )
    					self.c4array[ i ] delete();
    			}
    		}
    		self.c4array = [];
    		// delete claymores from previous spawn
    		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 = weaponName;
    		self.gotPullbackNotify = true;
    		
    		if ( weaponName == "c4_mp" )
    			self beginC4Tracking();
    		else
    			self beginGrenadeTracking();
    			
    		self.throwingGrenade = undefined;
    	}
    }
    
    beginGrenadeTracking()
    {
    	self endon( "death" );
    	self endon( "disconnect" );
    	self endon( "offhand_end" );
    	self endon( "weapon_change" );
    
    	startTime = getTime();
    
    	self waittill( "grenade_fire", grenade, weaponName );
    
    	if ( ( getTime() - startTime > 1000 ) && weaponName == "frag_grenade_mp" )
    		grenade.isCooked = true;
    
    	self.changingWeapon = undefined;
    
    	if ( weaponName == "frag_grenade_mp" || weaponName == "semtex_mp" )
    	{
    		grenade thread maps\mp\gametypes\_shellshock::grenade_earthQuake();
    		grenade.originalOwner = self;
    	}
    
    	if ( weaponName == "flash_grenade_mp" || weaponName == "concussion_grenade_mp" )
    	{
    		grenade.owner = self;
    		grenade thread empExplodeWaiter();
    	}
    }
    
    AddMissileToSightTraces( team )
    {
    	self.team = team;
    	level.missilesForSightTraces[ level.missilesForSightTraces.size ] = self;
    	
    	self waittill( "death" );
    	
    	newArray = [];
    	foreach( missile in level.missilesForSightTraces )
    	{
    		if ( missile != self )
    			newArray[ newArray.size ] = missile;
    	}
    	level.missilesForSightTraces = newArray;
    }
    
    watchMissileUsage()
    {
    	self endon( "death" );
    	self endon( "disconnect" );
    
    	for ( ;; )
    	{
    		self waittill( "missile_fire", missile, weaponName );
    		
    		if ( isSubStr( weaponName, "gl_" ) )
    		{
    			missile.primaryWeapon = self getCurrentPrimaryWeapon();
    			missile thread maps\mp\gametypes\_shellshock::grenade_earthQuake();
    		}
    
    		switch ( weaponName )
    		{
    			case "at4_mp":
    			case "stinger_mp":
    				level notify ( "stinger_fired", self, missile, self.stingerTarget );
    				self thread setAltSceneObj( missile, "tag_origin", 65 );
    				break;
    			case "javelin_mp":
    				level notify ( "stinger_fired", self, missile, self.javelinTarget );
    				self thread setAltSceneObj( missile, "tag_origin", 65 );
    				break;			
    			default:
    				break;
    		}
    
    		switch ( weaponName )
    		{
    			case "at4_mp":
    			case "javelin_mp":
    			case "rpg_mp":
    			case "ac130_105mm_mp":
    			case "ac130_40mm_mp":
    			case "remotemissile_projectile_mp":
    				missile thread maps\mp\gametypes\_shellshock::grenade_earthQuake();
    			default:
    				break;
    		}
    	}
    }
    
    
    watchSentryUsage()
    {
    	self endon( "death" );
    	self endon( "disconnect" );
    
    	for ( ;; )
    	{
    		self waittill( "sentry_placement_finished", sentry );
    		
    		self thread setAltSceneObj( sentry, "tag_flash", 65 );
    	}
    }
    
    
    empExplodeWaiter()
    {
    	self thread maps\mp\gametypes\_shellshock::endOnDeath();
    	self endon( "end_explode" );
    
    	self waittill( "explode", position );
    
    	ents = getEMPDamageEnts( position, 512, false );
    
    	foreach ( ent in ents )
    	{
    		if ( isDefined( ent.owner ) && !friendlyFireCheck( self.owner, ent.owner ) )
    			continue;
    
    		ent notify( "emp_damage", self.owner, 8.0 );
    	}
    }
    
    
    beginC4Tracking()
    {
    	self endon( "death" );
    	self endon( "disconnect" );
    
    	self waittill_any( "grenade_fire", "weapon_change", "offhand_end" );
    }
    
    
    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_" ) && !isSubStr( weapname, "semtex_" ) )
    			continue;
    
    		// no grenade_pullback notify! we must have picked it up off the ground.
    		grenade.threwBack = true;
    		self thread incPlayerStat( "throwbacks", 1 );
    
    		grenade thread maps\mp\gametypes\_shellshock::grenade_earthQuake();
    		grenade.originalOwner = self;
    	}
    }
    
    
    watchC4()
    {
    	self endon( "spawned_player" );
    	self endon( "disconnect" );
    
    	//maxc4 = 2;
    
    	while ( 1 )
    	{
    		self waittill( "grenade_fire", c4, weapname );
    		if ( weapname == "c4" || weapname == "c4_mp" )
    		{
    			if ( !self.c4array.size )
    				self thread watchC4AltDetonate();
    
    			if ( self.c4array.size )
    			{
    				self.c4array = array_removeUndefined( self.c4array );
    				
    				if( self.c4array.size >= level.maxPerPlayerExplosives )
    				{
    					self.c4array[0] detonate();
    				}
    			}
    
    			self.c4array[ self.c4array.size ] = c4;
    			c4.owner = self;
    			c4.team = self.team;
    			c4.activated = false;
    			c4.weaponName = weapname;
    
    			c4 thread maps\mp\gametypes\_shellshock::c4_earthQuake();
    			c4 thread c4Activate();
    			c4 thread c4Damage();
    			c4 thread c4EMPDamage();
    			c4 thread c4EMPKillstreakWait();
    			//c4 thread c4DetectionTrigger( self.pers[ "team" ] );
    		}
    	}
    }
    
    
    c4EMPDamage()
    {
    	self endon( "death" );
    
    	for ( ;; )
    	{
    		self waittill( "emp_damage", attacker, duration );
    
    		playfxOnTag( getfx( "sentry_explode_mp" ), self, "tag_origin" );
    
    		self.disabled = true;
    		self notify( "disabled" );
    
    		wait( duration );
    
    		self.disabled = undefined;
    		self notify( "enabled" );
    	}
    }
    
    
    c4EMPKillstreakWait()
    {
    	self endon( "death" );
    
    	for ( ;; )
    	{
    		level waittill( "emp_update" );
    
    		if ( (level.teamBased && level.teamEMPed[self.team]) || (!level.teamBased && isDefined( level.empPlayer ) && level.empPlayer != self.owner ) )
    		{
    			self.disabled = true;
    			self notify( "disabled" );
    		}
    		else
    		{
    			self.disabled = undefined;
    			self notify( "enabled" );
    		}
    	}
    }
    
    
    setClaymoreTeamHeadIcon( team )
    {
    	self endon( "death" );
    	wait .05;
    	if ( level.teamBased )
    		self maps\mp\_entityheadicons::setTeamHeadIcon( team, ( 0, 0, 20 ) );
    	else if ( isDefined( self.owner ) )
    		self maps\mp\_entityheadicons::setPlayerHeadIcon( self.owner, (0,0,20) );
    }
    
    
    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 = array_removeUndefined( self.claymorearray );
    			
    			if( self.claymoreArray.size >= level.maxPerPlayerExplosives )
    				self.claymoreArray[0] detonate();
    			
    			self.claymorearray[ self.claymorearray.size ] = claymore;
    			claymore.owner = self;
    			claymore.team = self.team;
    			claymore.weaponName = weapname;
    
    			claymore thread c4Damage();
    			claymore thread c4EMPDamage();
    			claymore thread c4EMPKillstreakWait();
    			claymore thread claymoreDetonation();
    			//claymore thread claymoreDetectionTrigger_wait( self.pers[ "team" ] );
    			claymore thread setClaymoreTeamHeadIcon( self.pers[ "team" ] );
    
    			 /#
    			if ( getdvarint( "scr_claymoredebug" ) )
    			{
    				claymore thread claymoreDebug();
    			}
    			#/
    		}
    	}
    }
    
     /#
    claymoreDebug()
    {
    	self waittill( "missile_stuck" );
    	self thread showCone( acos( level.claymoreDetectionDot ), level.claymoreDetonateRadius, ( 1, .85, 0 ) );
    	self thread showCone( 60, 256, ( 1, 0, 0 ) );
    }
    
    vectorcross( v1, v2 )
    {
    	return( v1[ 1 ] * v2[ 2 ] - v1[ 2 ] * v2[ 1 ], v1[ 2 ] * v2[ 0 ] - v1[ 0 ] * v2[ 2 ], v1[ 0 ] * v2[ 1 ] - v1[ 1 ] * v2[ 0 ] );
    }
    
    showCone( angle, range, color )
    {
    	self endon( "death" );
    
    	start = self.origin;
    	forward = anglestoforward( self.angles );
    	right = vectorcross( forward, ( 0, 0, 1 ) );
    	up = vectorcross( forward, right );
    
    	fullforward = forward * range * cos( angle );
    	sideamnt = range * sin( angle );
    
    	while ( 1 )
    	{
    		prevpoint = ( 0, 0, 0 );
    		for ( i = 0; i <= 20; i++ )
    		{
    			coneangle = i / 20.0 * 360;
    			point = start + fullforward + sideamnt * ( right * cos( coneangle ) + up * sin( coneangle ) );
    			if ( i > 0 )
    			{
    				line( start, point, color );
    				line( prevpoint, point, color );
    			}
    			prevpoint = point;
    		}
    		wait .05;
    	}
    }
    #/
    
    claymoreDetonation()
    {
    	self endon( "death" );
    
    	self waittill( "missile_stuck" );
    
    	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");
    	
    	
    	if ( player _hasPerk( "specialty_delaymine" ) )
    		wait 3.0;
    	else 
    		wait level.claymoreDetectionGracePeriod;
    		
    	self detonate();
    }
    
    shouldAffectClaymore( claymore )
    {
    	if ( isDefined( claymore.disabled ) )
    		return false;
    
    	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 waittill( "missile_stuck" );
    
    	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 waittillmatch( "detonate", "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 waitTillEnabled();
    
    	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;
    
    		// don't allow people to destroy C4 on their team if FF is off
    		if ( !friendlyFireCheck( self.owner, attacker ) )
    			continue;
    
    		if ( damage < 5 )// ignore concussion grenades
    			continue;
    
    		break;
    	}
    
    	if ( level.c4explodethisframe )
    		wait .1 + randomfloat( .4 );
    	else
    		wait .05;
    
    	if ( !isdefined( self ) )
    		return;
    
    	level.c4explodethisframe = true;
    
    	thread resetC4ExplodeThisFrame();
    
    	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 ( level.teamBased )
    	{
    		// "destroyed_explosive" notify, for challenges
    		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" );
    		}
    	}
    	else
    	{
    		// checking isDefined attacker is defensive but it's too late in the project to risk issues by not having it
    		if ( isDefined( self.owner ) && isDefined( attacker ) && attacker != self.owner )
    			attacker notify( "destroyed_explosive" );		
    	}
    
    	self detonate( attacker );
    	// won't get here; got death notify.
    }
    
    resetC4ExplodeThisFrame()
    {
    	wait .05;
    	level.c4explodethisframe = false;
    }
    
    saydamaged( orig, amount )
    {
    	for ( i = 0; i < 60; i++ )
    	{
    		print3d( orig, "damaged! " + amount );
    		wait .05;
    	}
    }
    
    waitTillEnabled()
    {
    	if ( !isDefined( self.disabled ) )
    		return;
    
    	self waittill( "enabled" );
    	assert( !isDefined( self.disabled ) );
    }
    
    
    c4DetectionTrigger( ownerTeam )
    {
    	self waittill( "activated" );
    
    	trigger = spawn( "trigger_radius", self.origin - ( 0, 0, 128 ), 0, 512, 256 );
    	trigger.detectId = "trigger" + getTime() + randomInt( 1000000 );
    
    	trigger.owner = self;
    	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" );
    	self waittill( "missile_stuck" );
    
    	self thread claymoreDetectionTrigger( ownerTeam );
    }
    
    claymoreDetectionTrigger( ownerTeam ) // LOOK HERE
    {
    	trigger = spawn( "trigger_radius", self.origin - ( 0, 0, 128 ), 0, 512, 256 );
    	trigger.detectId = "trigger" + getTime() + randomInt( 1000000 );
    
    	trigger.owner = self;
    	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 ( level.teamBased && player.team != detectTeam )
    			continue;
    		else if ( !level.teamBased && player == self.owner.owner )
    			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, 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;
    }
    
    
    // these functions are used with scripted weapons (like c4, claymores, artillery)
    // returns an array of objects representing damageable entities (including players) within a given sphere.
    // each object has the property damageCenter, which represents its center (the location from which it can be damaged).
    // each object also has the property entity, which contains the entity that it represents.
    // to damage it, call damageEnt() on it.
    getDamageableEnts( pos, radius, doLOS, startRadius )
    {
    	ents = [];
    
    	if ( !isdefined( doLOS ) )
    		doLOS = false;
    
    	if ( !isdefined( startRadius ) )
    		startRadius = 0;
    	
    	radiusSq = radius * radius;
    
    	// players
    	players = level.players;
    	for ( i = 0; i < players.size; i++ )
    	{
    		if ( !isalive( players[ i ] ) || players[ i ].sessionstate != "playing" )
    			continue;
    
    		playerpos = get_damageable_player_pos( players[ i ] );
    		distSq = distanceSquared( pos, playerpos );
    		if ( distSq < radiusSq && ( !doLOS || weaponDamageTracePassed( pos, playerpos, startRadius, players[ i ] ) ) )
    		{
    			ents[ ents.size ] = get_damageable_player( players[ i ], playerpos );
    		}
    	}
    
    	// grenades
    	grenades = getentarray( "grenade", "classname" );
    	for ( i = 0; i < grenades.size; i++ )
    	{
    		entpos = get_damageable_grenade_pos( grenades[ i ] );
    		distSq = distanceSquared( pos, entpos );
    		if ( distSq < radiusSq && ( !doLOS || weaponDamageTracePassed( pos, entpos, startRadius, grenades[ i ] ) ) )
    		{
    			ents[ ents.size ] = get_damageable_grenade( grenades[ i ], entpos );
    		}
    	}
    
    	destructibles = getentarray( "destructible", "targetname" );
    	for ( i = 0; i < destructibles.size; i++ )
    	{
    		entpos = destructibles[ i ].origin;
    		distSq = distanceSquared( pos, entpos );
    		if ( distSq < radiusSq && ( !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;
    		distSq = distanceSquared( pos, entpos );
    		if ( distSq < radiusSq && ( !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;
    		}
    	}
    	
    	//sentries
    	sentries = getentarray( "misc_turret", "classname" );
    	foreach ( sentry in sentries )
    	{
    		entpos = sentry.origin + (0,0,32);
    		distSq = distanceSquared( pos, entpos );
    		if ( distSq < radiusSq && ( !doLOS || weaponDamageTracePassed( pos, entpos, startRadius, sentry ) ) )
    		{
    			if ( sentry.model == "sentry_minigun" )
    				ents[ ents.size ] = get_damageable_sentry(sentry, entpos);
    		}
    	}
    
    	return ents;
    }
    
    
    getEMPDamageEnts( pos, radius, doLOS, startRadius )
    {
    	ents = [];
    
    	if ( !isDefined( doLOS ) )
    		doLOS = false;
    
    	if ( !isDefined( startRadius ) )
    		startRadius = 0;
    
    	grenades = getEntArray( "grenade", "classname" );
    	foreach ( grenade in grenades )
    	{
    		//if ( !isDefined( grenade.weaponName ) )
    		//	continue;
    
    		entpos = grenade.origin;
    		dist = distance( pos, entpos );
    		if ( dist < radius && ( !doLOS || weaponDamageTracePassed( pos, entpos, startRadius, grenade ) ) )
    			ents[ ents.size ] = grenade;
    	}
    
    	turrets = getEntArray( "misc_turret", "classname" );
    	foreach ( turret in turrets )
    	{
    		//if ( !isDefined( turret.weaponName ) )
    		//	continue;
    
    		entpos = turret.origin;
    		dist = distance( pos, entpos );
    		if ( dist < radius && ( !doLOS || weaponDamageTracePassed( pos, entpos, startRadius, turret ) ) )
    			ents[ ents.size ] = turret;
    	}
    
    	return ents;
    }
    
    
    weaponDamageTracePassed( from, to, startRadius, ent )
    {
    	midpos = undefined;
    
    	diff = to - from;
    	if ( lengthsquared( diff ) < startRadius * startRadius )
    		return true;
    	
    	dir = vectornormalize( diff );
    	midpos = from + ( dir[ 0 ] * startRadius, dir[ 1 ] * startRadius, dir[ 2 ] * startRadius );
    
    	trace = bullettrace( midpos, to, false, ent );
    
    	if ( getdvarint( "scr_damage_debug" ) != 0 )
    	{
    		thread debugprint( from, ".dmg" );
    		if ( isdefined( ent ) )
    			thread debugprint( to, "." + ent.classname );
    		else
    			thread debugprint( to, ".undefined" );
    		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 );
    }
    
    // eInflictor = the entity that causes the damage (e.g. a claymore)
    // eAttacker = the player that is attacking
    // iDamage = the amount of damage to do
    // sMeansOfDeath = string specifying the method of death (e.g. "MOD_PROJECTILE_SPLASH")
    // sWeapon = string specifying the weapon used (e.g. "claymore_mp")
    // damagepos = the position damage is coming from
    // damagedir = the direction damage is moving in
    damageEnt( eInflictor, eAttacker, iDamage, sMeansOfDeath, sWeapon, damagepos, damagedir )
    {
    	if ( self.isPlayer )
    	{
    		self.damageOrigin = damagepos;
    		self.entity thread [[ level.callbackPlayerDamage ]](
    			eInflictor,// eInflictor The entity that causes the damage.( e.g. a turret )
    			eAttacker,// eAttacker The entity that is attacking.
    			iDamage,// iDamage Integer specifying the amount of damage done
    			0,// iDFlags Integer specifying flags that are to be applied to the damage
    			sMeansOfDeath,// sMeansOfDeath Integer specifying the method of death
    			sWeapon,// sWeapon The weapon number of the weapon used to inflict the damage
    			damagepos,// vPoint The point the damage is from?
    			damagedir,// vDir The direction of the damage
    			"none",// sHitLoc The location of the hit
    			0// psOffsetTime The time offset for the damage
    		 );
    	}
    	else
    	{
    		// destructable walls and such can only be damaged in certain ways.
    		if ( self.isADestructable && ( sWeapon == "artillery_mp" || sWeapon == "claymore_mp" ) || sWeapon == "stealth_bomb_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;
    	}
    }
    
    debugprint( pt, txt )
    {
    	for ( i = 0; i < 30 * 20; i++ )
    	{
    		print3d( pt, txt );
    		wait .05;
    	}
    }
    
    
    onWeaponDamage( eInflictor, sWeapon, meansOfDeath, damage, eAttacker )
    {
    	self endon( "death" );
    	self endon( "disconnect" );
    
    	switch( sWeapon )
    	{
    		case "concussion_grenade_mp":
    			// should match weapon settings in gdt
    			radius = 512;
    			scale = 1 - ( distance( self.origin, eInflictor.origin ) / radius );
    
    			if ( scale < 0 )
    				scale = 0;
    
    			time = 2 + ( 4 * scale );
    			
    			wait( 0.05 );
    			eAttacker notify( "stun_hit" );
    			self shellShock( "concussion_grenade_mp", time );
    			self.concussionEndTime = getTime() + ( time * 1000 );
    		break;
    
    		case "weapon_cobra_mk19_mp":
    			// mk19 is too powerful with shellshock slowdown
    		break;
    
    		default:
    			// shellshock will only be done if meansofdeath is an appropriate type and if there is enough damage.
    			maps\mp\gametypes\_shellshock::shellshockOnDamage( meansOfDeath, damage );
    		break;
    	}
    
    }
    
    // weapon stowing logic ===================================================================
    
    // weapon class boolean helpers
    isPrimaryWeapon( weapName )
    {
    	if ( weapName == "none" )
    		return false;
    		
    	if ( weaponInventoryType( weapName ) != "primary" )
    		return false;
    
    	switch ( weaponClass( weapName ) )
    	{
    		case "rifle":
    		case "smg":
    		case "mg":
    		case "spread":
    		case "pistol":
    		case "rocketlauncher":
    		case "sniper":
    			return true;
    
    		default:
    			return false;
    	}	
    }
    
    
    isAltModeWeapon( weapName )
    {
    	if ( weapName == "none" )
    		return false;
    		
    	return ( weaponInventoryType( weapName ) == "altmode" );
    }
    
    isInventoryWeapon( weapName )
    {
    	if ( weapName == "none" )
    		return false;
    		
    	return ( weaponInventoryType( weapName ) == "item" );
    }
    
    isRiotShield( weapName )
    {
    	if ( weapName == "none" )
    		return false;
    		
    	return ( WeaponType( weapName ) == "riotshield" );
    }
    
    isOffhandWeapon( weapName )
    {
    	if ( weapName == "none" )
    		return false;
    		
    	return ( weaponInventoryType( weapName ) == "offhand" );
    }
    
    isSideArm( weapName )
    {
    	if ( weapName == "none" )
    		return false;
    
    	if ( weaponInventoryType( weapName ) != "primary" )
    		return false;
    
    	return ( weaponClass( weapName ) == "pistol" );
    }
    
    
    // This needs for than this.. this would qualify c4 as a grenade
    isGrenade( weapName )
    {
    	weapClass = weaponClass( weapName );
    	weapType = weaponInventoryType( weapName );
    
    	if ( weapClass != "grenade" )
    		return false;
    		
    	if ( weapType != "offhand" )
    		return false;
    }
    
    
    getStowOffsetModel( weaponName )
    {
    	assert( isDefined( level.stow_offset_array ) );
    
    	baseName = getBaseWeaponName( weaponName );
    	
    	return( level.stow_offset_array[baseName] );
    }
    
    
    stowPriorityWeapon()
    {
    	assert( isdefined( level.stow_priority_model_array ) );
    
    	// returns the first large projectil the player owns in case player owns more than one
    	foreach ( weapon_name, priority_weapon in level.stow_priority_model_array )
    	{
    		weaponName = getBaseWeaponName( weapon_name );
    		weaponList = self getWeaponsListAll();
    		
    		foreach ( weapon in weaponList )
    		{
    			if( self getCurrentWeapon() == weapon )
    				continue;
    			
    			if ( weaponName == getBaseWeaponName( weapon ) )
    				return weaponName + "_mp";
    		}
    	}
    
    	return "";
    }
    
    // thread loop life = player's life
    updateStowedWeapon()
    {
    	self endon( "spawned" );
    	self endon( "killed_player" );
    	self endon( "disconnect" );
    
    	self.tag_stowed_back = undefined;
    	self.tag_stowed_hip = undefined;
    	
    	team = self.team;
    	class = self.class;
    	
    	self thread stowedWeaponsRefresh();
    	
    	while ( true )
    	{
    		self waittill( "weapon_change", newWeapon );
    		
    		if ( newWeapon == "none" )
    			continue;
    			
    		self thread stowedWeaponsRefresh();
    	}
    }
    
    stowedWeaponsRefresh()
    {
    	self endon( "spawned" );
    	self endon( "killed_player" );
    	self endon( "disconnect" );
    	
    	detach_all_weapons();
    	stow_on_back();
    	stow_on_hip();
    }
    
    
    detach_all_weapons()
    {
    	if ( isDefined( self.tag_stowed_back ) )
    		self detach_back_weapon();
    
    	if ( isDefined( self.tag_stowed_hip ) )
    		self detach_hip_weapon();
    }
    
    
    detach_back_weapon()
    {
    	detach_success = self detachIfAttached( self.tag_stowed_back, "tag_stowed_back" );
    
    	// test for bug
    	//assertex( detach_success, "Detaching: " + self.tag_stowed_back + " from tag: tag_stowed_back failed." );
    	self.tag_stowed_back = undefined;
    }
    
    
    detach_hip_weapon()
    {
    	detach_success = self detachIfAttached( self.tag_stowed_hip, "tag_stowed_hip" );
    
    	// test for bug
    	//assertex( detach_success, "Detaching: " + detach_model + " from tag: tag_stowed_hip failed." );
    	self.tag_stowed_hip = undefined;
    }
    
    
    stow_on_back()
    {
    	prof_begin( "stow_on_back" );
    	currentWeapon = self getCurrentWeapon();
    	currentIsAlt = isAltModeWeapon( currentWeapon );
    
    	assert( !isDefined( self.tag_stowed_back ) );
    
    	stowWeapon = undefined;
    	stowCamo = 0;
    	large_projectile = self stowPriorityWeapon();
    	stowOffsetModel = undefined;
    
    	if ( large_projectile != "" )
    	{
    		stowWeapon = large_projectile;
    	}
    	else
    	{
    		weaponsList = self getWeaponsListPrimaries();
    		foreach ( weaponName in weaponsList )
    		{
    			if ( weaponName == currentWeapon )
    				continue;
    			
    			invType = weaponInventoryType( weaponName );
    			
    			if ( invType != "primary" )
    			{
    				if ( invType == "altmode" )
    					continue;
    				
    				if ( weaponClass( weaponName ) == "pistol" )
    					continue;
    			}
    			
    			if ( WeaponType( weaponName ) == "riotshield" )
    				continue;
    			
    			// Don't stow the current on our back when we're using the alt
    			if ( currentIsAlt && weaponAltWeaponName( weaponName ) == currentWeapon )
    				continue;
    				
    			stowWeapon = weaponName;
    			stowOffsetModel = getStowOffsetModel( stowWeapon );
    			
    			if ( stowWeapon == self.primaryWeapon )
    				stowCamo = self.loadoutPrimaryCamo;
    			else if ( stowWeapon == self.secondaryWeapon )
    				stowCamo = self.loadoutSecondaryCamo;
    			else
    				stowCamo = 0;
    		}		
    	}
    
    	if ( !isDefined( stowWeapon ) )
    	{
    		prof_end( "stow_on_back" );
    		return;
    	}
    
    	if ( large_projectile != "" )
    	{
    		self.tag_stowed_back = level.stow_priority_model_array[ large_projectile ];
    	}
    	else
    	{
    		self.tag_stowed_back = getWeaponModel( stowWeapon, stowCamo );	
    	}
    
    	if ( isDefined( stowOffsetModel ) )
    	{
    		self attach( stowOffsetModel, "tag_stowed_back", true );
    		attachTag = "tag_stow_back_mid_attach";
    	}
    	else
    	{
    		attachTag = "tag_stowed_back";
    	}
    
    	self attach( self.tag_stowed_back, attachTag, true );
    
    	hideTagList = GetWeaponHideTags( stowWeapon );
    
    	if ( !isDefined( hideTagList ) )
    	{
    		prof_end( "stow_on_back" );
    		return;
    	}
    
    	for ( i = 0; i < hideTagList.size; i++ )
    		self HidePart( hideTagList[ i ], self.tag_stowed_back );
    	
    	prof_end( "stow_on_back" );
    }
    
    stow_on_hip()
    {
    	currentWeapon = self getCurrentWeapon();
    
    	assert( !isDefined( self.tag_stowed_hip ) );
    
    	stowWeapon = undefined;
    
    	weaponsList = self getWeaponsListOffhands();
    	foreach ( weaponName in weaponsList )
    	{
    		if ( weaponName == currentWeapon )
    			continue;
    			
    		if ( weaponName != "c4_mp" && weaponName != "claymore_mp" )
    			continue;
    		
    		stowWeapon = weaponName;
    	}
    
    	if ( !isDefined( stowWeapon ) )
    		return;
    
    	self.tag_stowed_hip = getWeaponModel( stowWeapon );
    	self attach( self.tag_stowed_hip, "tag_stowed_hip_rear", true );
    
    	hideTagList = GetWeaponHideTags( stowWeapon );
    	
    	if ( !isDefined( hideTagList ) )
    		return;
    	
    	for ( i = 0; i < hideTagList.size; i++ )
    		self HidePart( hideTagList[ i ], self.tag_stowed_hip );
    }
    
    
    updateSavedLastWeapon()
    {
    	self endon( "death" );
    	self endon( "disconnect" );
    
    	currentWeapon = self.currentWeaponAtSpawn;
    	self.saved_lastWeapon = currentWeapon;
    
    	for ( ;; )
    	{
    		self waittill( "weapon_change", newWeapon );
    	
    		if ( newWeapon == "none" )
    		{
    			self.saved_lastWeapon = currentWeapon;
    			continue;
    		}
    
    		weaponInvType = weaponInventoryType( newWeapon );
    
    		if ( weaponInvType != "primary" && weaponInvType != "altmode" )
    		{
    			self.saved_lastWeapon = currentWeapon;
    			continue;
    		}
    		
    		if ( newWeapon == "onemanarmy_mp" )
    		{
    			self.saved_lastWeapon = currentWeapon;
    			continue;
    		}
    
    		self updateMoveSpeedScale( "primary" );
    
    		self.saved_lastWeapon = currentWeapon;
    		currentWeapon = newWeapon;
    	}
    }
    
    
    EMPPlayer( numSeconds )
    {
    	self endon( "disconnect" );
    	self endon( "death" );
    
    	self thread clearEMPOnDeath();
    
    }
    
    
    clearEMPOnDeath()
    {
    	self endon( "disconnect" );
    
    	self waittill( "death" );
    }
    
    
    updateMoveSpeedScale( weaponType )
    {
    	/*
    	if ( self _hasPerk( "specialty_lightweight" ) )
    		self.moveSpeedScaler = 1.10;
    	else
    		self.moveSpeedScaler = 1;
    	*/
    	
    	if ( !isDefined( weaponType ) || weaponType == "primary" || weaponType != "secondary" )
    		weaponType = self.primaryWeapon;
    	else
    		weaponType = self.secondaryWeapon;
    	
    	if( isDefined(self.primaryWeapon ) && self.primaryWeapon == "riotshield_mp" )
    	{
    		self setMoveSpeedScale( .8 * self.moveSpeedScaler );
    		return;
    	}
    	
    	if ( !isDefined( weaponType ) )
    		weapClass = "none";
    	else 
    		weapClass = weaponClass( weaponType );
    	
    	
    	switch ( weapClass )
    	{
    		case "rifle":
    			self setMoveSpeedScale( 0.95 * self.moveSpeedScaler );
    			break;
    		case "pistol":
    			self setMoveSpeedScale( 1.0 * self.moveSpeedScaler );
    			break;
    		case "mg":
    			self setMoveSpeedScale( 0.875 * self.moveSpeedScaler );
    			break;
    		case "smg":
    			self setMoveSpeedScale( 1.0 * self.moveSpeedScaler );
    			break;
    		case "spread":
    			self setMoveSpeedScale( .95 * self.moveSpeedScaler );
    			break;
    		case "rocketlauncher":
    			self setMoveSpeedScale( 0.80 * self.moveSpeedScaler );
    			break;
    		case "sniper":
    			self setMoveSpeedScale( 1.0 * self.moveSpeedScaler );
    			break;
    		default:
    			self setMoveSpeedScale( 1.0 * self.moveSpeedScaler );
    			break;
    	}
    }
    
    
    buildWeaponData( filterPerks )
    {
    	attachmentList = getAttachmentList();		
    	max_weapon_num = 149;
    
    	baseWeaponData = [];
    	
    	for( weaponId = 0; weaponId <= max_weapon_num; weaponId++ )
    	{
    		baseName = tablelookup( "mp/statstable.csv", 0, weaponId, 4 );
    		if( baseName == "" )
    			continue;
    
    		assetName = baseName + "_mp";
    
    		if ( !isSubStr( tableLookup( "mp/statsTable.csv", 0, weaponId, 2 ), "weapon_" ) )
    			continue;
    		
    		if ( weaponInventoryType( assetName ) != "primary" )
    			continue;
    
    		weaponInfo = spawnStruct();
    		weaponInfo.baseName = baseName;
    		weaponInfo.assetName = assetName;
    		weaponInfo.variants = [];
    
    		weaponInfo.variants[0] = assetName;
    		// the alphabetize function is slow so we try not to do it for every weapon/attachment combo; a code solution would be better.
    		attachmentNames = [];
    		for ( innerLoopCount = 0; innerLoopCount < 6; innerLoopCount++ )
    		{
    			// generating attachment combinations
    			attachmentName = tablelookup( "mp/statStable.csv", 0, weaponId, innerLoopCount + 11 );
    			
    			if ( filterPerks )
    			{
    				switch ( attachmentName )
    				{
    					case "fmj":
    					case "xmags":
    					case "rof":
    						continue;
    				}
    			}
    			
    			if( attachmentName == "" )
    				break;
    			
    			attachmentNames[attachmentName] = true;
    		}
    
    		// generate an alphabetized attachment list
    		attachments = [];
    		foreach ( attachmentName in attachmentList )
    		{
    			if ( !isDefined( attachmentNames[attachmentName] ) )
    				continue;
    			
    			weaponInfo.variants[weaponInfo.variants.size] = baseName + "_" + attachmentName + "_mp";
    			attachments[attachments.size] = attachmentName;
    		}
    
    		for ( i = 0; i < (attachments.size - 1); i++ )
    		{
    			colIndex = tableLookupRowNum( "mp/attachmentCombos.csv", 0, attachments[i] );
    			for ( j = i + 1; j < attachments.size; j++ )
    			{
    				if ( tableLookup( "mp/attachmentCombos.csv", 0, attachments[j], colIndex ) == "no" )
    					continue;
    					
    				weaponInfo.variants[weaponInfo.variants.size] = baseName + "_" + attachments[i] + "_" + attachments[j] + "_mp";
    			}
    		}
    		
    		baseWeaponData[baseName] = weaponInfo;
    	}
    	
    	return ( baseWeaponData );
    }
    
    monitorSemtex()
    {
    	self endon( "disconnect" );
    	self endon( "death" );
    	
    	for( ;; )
    	{
    		self waittill( "grenade_fire", weapon );
    
    		if ( !isSubStr(weapon.model, "semtex" ) )
    			continue;
    			
    		weapon waittill( "missile_stuck", stuckTo );
    			
    		if ( !isPlayer( stuckTo ) )
    			continue;
    			
    		if ( level.teamBased && isDefined( stuckTo.team ) && stuckTo.team == self.team )
    		{
    			weapon.isStuck = "friendly";
    			continue;
    		}
    	
    		weapon.isStuck = "enemy";
    		weapon.stuckEnemyEntity = stuckTo;
    		
    		stuckTo maps\mp\gametypes\_hud_message::playerCardSplashNotify( "semtex_stuck", self );
    		
    		self thread maps\mp\gametypes\_hud_message::SplashNotify( "stuck_semtex", 100 );
    		self notify( "process", "ch_bullseye" );
    	}	
    }
    
    
    turret_monitorUse()
    {
    	for( ;; )
    	{
    		self waittill ( "trigger", player );
    		
    		self thread turret_playerThread( player );
    	}
    }
    
    turret_playerThread( player )
    {
    	player endon ( "death" );
    	player endon ( "disconnect" );
    
    	player notify ( "weapon_change", "none" );
    	
    	self waittill ( "turret_deactivate" );
    	
    	player notify ( "weapon_change", player getCurrentWeapon() );
    }
    And change the Radius for activation......

    EDIT:

    I found another thread that may be helpfull, it is the same file ( as Above ):
    waitAndDetonate( delay )
    {
    self endon( "death" );
    wait delay;

    self waitTillEnabled();

    //self detonate(); //Deactivate this one....
    }
    Last edited by Jorndel; 04-29-2011 at 06:45 AM.

     
    Contributor 01.27.2012 - N/A
    Donator 07-17-2012 - Current
    Editor/Manager 12-16-12 - N/A
    Minion 01-10-2013 - 07.17.13
    Former Staff 09-20-2012 - 01-10-2013 / 07-17-2013 - Current
    Cocksucker 20-04-2013 - N/A

  4. #4
    YuDi21's Avatar
    Join Date
    Sep 2010
    Gender
    male
    Location
    mp_complex
    Posts
    141
    Reputation
    12
    Thanks
    35
    My Mood
    Angelic
    open a maps\mp\_minefields.gsc file and edit it

  5. #5
    Jorndel's Avatar
    Join Date
    Jul 2010
    Gender
    male
    Location
    Norway
    Posts
    8,674
    Reputation
    905
    Thanks
    18,539
    My Mood
    Angelic
    Quote Originally Posted by YuDi21 View Post
    open a maps\mp\_minefields.gsc file and edit it
    And where did you get that file from then?


     
    Contributor 01.27.2012 - N/A
    Donator 07-17-2012 - Current
    Editor/Manager 12-16-12 - N/A
    Minion 01-10-2013 - 07.17.13
    Former Staff 09-20-2012 - 01-10-2013 / 07-17-2013 - Current
    Cocksucker 20-04-2013 - N/A

  6. #6
    Yamato's Avatar
    Join Date
    Jul 2010
    Gender
    male
    Posts
    839
    Reputation
    13
    Thanks
    152
    My Mood
    Amazed
    Quote Originally Posted by jorndel View Post
    And where did you get that file from then?

    Code:
    minefields()
    {
    	minefields = getentarray("minefield", "targetname");
    	if (minefields.size > 0)
    	{
    		level._effect["mine_explosion"] = loadfx ("explosions/grenadeExp_dirt");
    	}
    	
    	for(i = 0; i < minefields.size; i++)
    	{
    		minefields[i] thread minefield_think();
    	}	
    }
    
    minefield_think()
    {
    	while (1)
    	{
    		self waittill ("trigger",other);
    		
    		if(isPlayer(other))
    			other thread minefield_kill(self);
    	}
    }
    
    minefield_kill(trigger)
    {
    	if(isDefined(self.minefield))
    		return;
    		
    	self.minefield = true;
    	self playsound ("minefield_click");
    
    	wait(.5);
    	wait(randomFloat(.5));
    
    	if(isdefined(self) && self istouching(trigger))
    	{
    		origin = self getorigin();
    		range = 300;
    		maxdamage = 2000;
    		mindamage = 50;
    
    		self playsound("explo_mine");
    		playfx(level._effect["mine_explosion"], origin);
    		radiusDamage(origin, range, maxdamage, mindamage);
    	}
    	
    	self.minefield = undefined;
    }
    This is that gsc, I dont that is the way here, jorndel is probably right, modify _weapons.gsc by adding //

  7. #7
    Jorndel's Avatar
    Join Date
    Jul 2010
    Gender
    male
    Location
    Norway
    Posts
    8,674
    Reputation
    905
    Thanks
    18,539
    My Mood
    Angelic
    Quote Originally Posted by Yamato View Post
    Code:
    minefields()
    {
    	minefields = getentarray("minefield", "targetname");
    	if (minefields.size > 0)
    	{
    		level._effect["mine_explosion"] = loadfx ("explosions/grenadeExp_dirt");
    	}
    	
    	for(i = 0; i < minefields.size; i++)
    	{
    		minefields[i] thread minefield_think();
    	}	
    }
    
    minefield_think()
    {
    	while (1)
    	{
    		self waittill ("trigger",other);
    		
    		if(isPlayer(other))
    			other thread minefield_kill(self);
    	}
    }
    
    minefield_kill(trigger)
    {
    	if(isDefined(self.minefield))
    		return;
    		
    	self.minefield = true;
    	self playsound ("minefield_click");
    
    	wait(.5);
    	wait(randomFloat(.5));
    
    	if(isdefined(self) && self istouching(trigger))
    	{
    		origin = self getorigin();
    		range = 300;
    		maxdamage = 2000;
    		mindamage = 50;
    
    		self playsound("explo_mine");
    		playfx(level._effect["mine_explosion"], origin);
    		radiusDamage(origin, range, maxdamage, mindamage);
    	}
    	
    	self.minefield = undefined;
    }
    This is that gsc, I dont that is the way here, jorndel is probably right, modify _weapons.gsc by adding //

    I would say so, cuse this is for the singel player. If you playd it. Its an mission that the Mines explod at the start....

    ( If I am not to wrong... )

     
    Contributor 01.27.2012 - N/A
    Donator 07-17-2012 - Current
    Editor/Manager 12-16-12 - N/A
    Minion 01-10-2013 - 07.17.13
    Former Staff 09-20-2012 - 01-10-2013 / 07-17-2013 - Current
    Cocksucker 20-04-2013 - N/A

  8. #8
    Yamato's Avatar
    Join Date
    Jul 2010
    Gender
    male
    Posts
    839
    Reputation
    13
    Thanks
    152
    My Mood
    Amazed
    Quote Originally Posted by jorndel View Post
    I would say so, cuse this is for the singel player. If you playd it. Its an mission that the Mines explod at the start....

    ( If I am not to wrong... )
    Yes, but this file is in mp files too, but has no use.