#include maps\mp\_utility;
#include maps\mp\gametypes\_hud_util;
#include common_scripts\utility;

init()
{	
	gameType = GetDvar( "g_gametype" );
	gameTypeRow = 0;
	
	gameTypeColumn = [];
	gameTypeColumn["dm"]		= 4;
	gameTypeColumn["war"] 		= 5;
	gameTypeColumn["sd"] 		= 6;
	gameTypeColumn["dom"] 		= 7;
	gameTypeColumn["conf"] 		= 8;
	gameTypeColumn["sr"] 		= 9;
	gameTypeColumn["infect"] 	= 10;
	gameTypeColumn["gun"] 		= 11;
	gameTypeColumn["ctf"] 		= 12;
	gameTypeColumn["horde"] 	= 13;
	gameTypeColumn["twar"] 		= 14;
	gameTypeColumn["hp"] 		= 15;
	gameTypeColumn["ball"] 		= 16;

	// register all XP events
	while( true )
	{
		if( !IsDefined(gameTypeColumn[gameType]) )
			gameType = "war";
			
		name 				= TableLookupByRow( "mp/xp_event_table.csv", gameTypeRow, 0 );
		playSplash			= TableLookupByRow( "mp/xp_event_table.csv", gameTypeRow, 1 );
		allowPlayerScore 	= TableLookupByRow( "mp/xp_event_table.csv", gameTypeRow, 2 );
		value 				= TableLookupByRow( "mp/xp_event_table.csv", gameTypeRow, gameTypeColumn[ gameType ] );
		
		if( !IsDefined( name ) || name == "" )
			break;
		
		if( name == "win" || name == "loss" || name == "tie" )
		{
			value = float( value );
		}
		else
		{
			value = int( value );
		}
		
		if( value != -1 )
		{
			allowPlayerScore = int( allowPlayerScore );
			playSplash = int( playSplash );
			maps\mp\gametypes\_rank::registerXPEventInfo( name, value, allowPlayerScore, playSplash );
		}
		
		gameTypeRow++;
	}
	
	level.numKills = 0;
	level thread onPlayerConnect();	
}

onPlayerConnect()
{
	while( true )
	{
		level waittill( "connected", player );
		
		player.killedPlayers 		= [];
		player.killedPlayersCurrent = [];
		player.damagedPlayers 		= [];	
		player.killedBy 			= [];
		player.lastKilledBy 		= undefined;
		player.recentKillCount 		= 0;
		player.lastKillTime 		= 0;
		player.bulletStreak 		= 0;
		player.lastCoopStreakTime	= 0;
	}
}

killedPlayer( killId, victim, weapon, meansOfDeath, eInflictor )
{
	level.numKills++;
	
	victimGuid 			= victim.guid;
	victimKillStreak 	= victim.pers[ "cur_kill_streak" ];
	myGuid 				= self.guid;
	curTime 			= getTime();
	
	if ( isBulletDamage( meansOfDeath ) )
	{
		if( self.lastKillTime == curTime )
		{
			self.bulletStreak++;
		}
		else
		{
			self.bulletStreak = 1;
		}
	}
	else
	{
		self.bulletStreak = 0;
	}

	self.lastKillTime 				= getTime();
	self.lastKilledPlayer 			= victim;
	self.modifiers 					= [];
	self.damagedPlayers[victimGuid] = undefined;	// a player is either damaged, or killed; never both

	// track multi kills
	self thread updateRecentKills( killId, weapon );
	
	if( !isKillstreakWeapon( weapon ) ) 
	{
		if( weapon == "none" )
			return false;

		if( isDefined( victim.throwingGrenade ) )
		{
			shortGrenade = maps\mp\_utility::strip_suffix( victim.throwingGrenade, "_lefthand" );

			if( shortGrenade == "frag_grenade_mp" )
				self.modifiers["cooking"] = true;
		}
		
		if( WeaponInventoryType(weapon) == "primary" )
		{
			self.segments["killDistanceTotal"] += Distance2D( self.origin, victim.origin );
			self.segments["killDistanceCount"]++;
		}
			
		if( meansOfDeath == "MOD_HEAD_SHOT" )
			self headShotEvent( killId, weapon, meansOfDeath );
		
		if( level.numKills == 1 )
			self firstBloodEvent( killId, weapon, meansOfDeath );
		
		if( level.teamBased && ( (curTime - victim.lastKillTime) < 3000) && (victim.lastkilledplayer != self) )
			self avengedPlayerEvent( killId, weapon, meansOfDeath );

		if( !isAlive( self ) && (self != victim) && isDefined(self.deathtime) && ( (self.deathtime + 1200) < getTime() ) )
			self postDeathKillEvent( killId );

		if( self.pers["cur_death_streak"] > 3 )
			self comeBackEvent( killId, weapon, meansOfDeath );	
		
		if ( isDefined(self.assistedSuicide) && self.assistedSuicide )
			self assistedSuicideEvent( killId, weapon, meansOfDeath );
		
		if( isLongShot( self, weapon, meansOfDeath, victim ) )
			self longShotEvent( killId, weapon, meansOfDeath );
		
		if( isResuce( victim, curTime ) )
			self defendedPlayerEvent( killId, weapon, meansOfDeath );
		
		if( (victimKillStreak > 0) && isBuzzKillEvent( victim ) )
			self buzzKillEvent( killId, victim, weapon, meansOfDeath );

		if( isOneShotKill( victim, weapon, meansOfDeath ) )
			self oneShotKillEvent(  killId, weapon, meansOfDeath );
		
		if( isDefined(self.lastKilledBy) && (self.lastKilledBy == victim) )
		{
			self revengeEvent( killId );
		}
		
		if( victim.iDFlags & level.iDFLAGS_PENETRATION )
			self bulletPenetrationEvent( killId, weapon );
		
		if( isPointBlank( victim, meansOfDeath ) )
			self pointBlankEvent( killId, weapon, meansOfDeath );
		
		if( IsDefined(weapon) && (weapon == "boost_slam_mp") )
			self boostSlamKillEvent( killId, weapon, meansOfDeath );
		
		if( self.health < 20 && self.health > 0 ) // not near death if you are dead
			self nearDeathKillEvent( weapon, meansOfDeath );
		
		if( self.isSiliding )
		{
			self sprintSlideKillEvent( weapon, meansOfDeath );
			self camoSprintSlideKillEvent( weapon, meansOfDeath );
		}
		
		if( self isFlashed() )
			self flashedKillEvent( weapon, meansOfDeath );
		
		if( isThinkFast( weapon, meansOfDeath ) )
			self thinkFastEvent();
		
		if( self.bulletStreak == 2 )
			self multiKillOneBulletEvent();
		
		if( isBackStabEvent( victim, weapon, meansOfDeath ) )
			self backStabEvent();
		
		if( isThrowBackEvent( victim, weapon, meansOfDeath ) )
			self throwBackKillEvent();
		
		if( IsDefined(self.pickedUpWeaponFrom[weapon]) && (self.pickedUpWeaponFrom[weapon] == victim) && !isMeleeMOD(meansOfDeath) )
			self takeAndKillEvent();

		if( IsDefined(weapon) && (weapon == "iw5_carrydrone_mp") )
			self killWithBallEvent();
		
		if ( IsDefined(victim) &&  victim _hasPerk("specialty_ballcarrier") )
			self killedBallCarrierEvent();
			
		if ( IsDefined( self.exoMostRecentTimeDeciSeconds["exo_dodge"] ) && ( 20 > ( getTimePassedDeciSecondsIncludingRounds() - self.exoMostRecentTimeDeciSeconds["exo_dodge"] ) ) )
		{
				self killAfterDodgeEvent(weapon);
		} 
		
		self checkHighJumpEvents( victim, killId, weapon, meansOfDeath, eInflictor );
		self checkHigherRankKillEvents( victim );
		self checkWeaponSpecificKill( victim, weapon, meansOfDeath );
	}
	
	self checkStreakingEvents( victim );

	if( !isDefined( self.killedPlayers[victimGuid] ) )
		self.killedPlayers[victimGuid] = 0;

	if( !isDefined( self.killedPlayersCurrent[victimGuid] ) )
		self.killedPlayersCurrent[victimGuid] = 0;
		
	if( !isDefined( victim.killedBy[myGuid] ) )
		victim.killedBy[myGuid] = 0;

	self.killedPlayers[victimGuid]++;
	self.killedPlayersCurrent[victimGuid]++;
	
	victim.killedBy[myGuid]++;	
	victim.lastKilledBy = self;		
}

isPointBlank( victim, meansOfDeath )
{
	if( isBulletDamage( meansOfDeath ) )
	{
		attackerPosition = self.origin;
		weapDistSq = 96 * 96;
		
		if( isDefined( victim.attackerPosition ) )
			attackerPosition = victim.attackerPosition;
		
		if( DistanceSquared(attackerPosition, victim.origin) < weapDistSq )
			return true;
	}

	return false;
}

pointBlankEvent( killId, weapon, meansOfDeath )
{
	self incPlayerStat( "pointblank", 1 );
	
	level thread maps\mp\gametypes\_rank::awardGameEvent( "pointblank", self, weapon, undefined, meansOfDeath );
	
	if(IsDefined(weapon))
	{
	baseWeapon = getBaseWeaponName( weapon );
	if( isLootWeapon( baseWeapon ) )
		baseWeapon = maps\mp\gametypes\_class::getBaseFromLootVersion( baseWeapon );
		weaponClass = self maps\mp\gametypes\_missions::get_challenge_weapon_class(weapon, baseWeapon);
		//camo challenge 
		if ( IsDefined (level.challengeInfo["ch_pointblank_" + baseWeapon ] ) )
		 	self maps\mp\gametypes\_missions::processChallenge( "ch_pointblank_" + baseWeapon );
	}
}

killedPlayerEvent( victim, weapon, sMeansOfDeath )
{
	self incPlayerStat( "kills", 1 );
	self incPersStat( "kills", 1 );
	self.kills = self getPersStat( "kills" );
	self maps\mp\gametypes\_persistence::statSetChild( "round", "kills", self.kills );
	self updatePersRatio( "kdRatio", "kills", "deaths" );
	
	event = "kill";
	
	switch( weapon )
	{
		case "killstreak_orbital_laser_mp":					// orbital laser
		case "orbital_laser_fov_mp":						// orbital laser
			event = "vulcan_kill";
			break;
		case "warbird_remote_turret_mp":					// warbird
		case "warbird_player_turret_mp":					// warbird
		case "warbird_missile_mp":							// warbird
		case "paint_missile_killstreak_mp":					// warbird
			event = "warbird_kill";
			break;
		case "orbitalsupport_105mm_mp":						// paladin
		case "orbitalsupport_40mm_mp":						// paladin
		case "orbitalsupport_40mmbuddy_mp":					// paladin
		case "orbitalsupport_big_turret_mp":				// paladin
		case "orbitalsupport_medium_turret_mp":				// paladin
		case "orbitalsupport_small_turret_mp":				// paladin
		case "orbitalsupport_missile_mp":					// paladin
			event = "paladin_kill";
			break;
		case "airdrop_trap_explosive_mp":					// care package trap
			event = "airdrop_trap_kill";
			break;
		case "orbital_carepackage_pod_mp":					// care package drop
			event = "airdrop_kill";
			break;
		case "remotemissile_projectile_mp":							// missile strike
		case "remotemissile_projectile_gas_mp":						// missile strike
		case "remotemissile_projectile_cluster_parent_mp":			// missile strike
		case "remotemissile_projectile_cluster_child_mp":			// missile strike
		case "remotemissile_projectile_cluster_child_hellfire_mp":	// missile strike
		case "remotemissile_projectile_secondary_mp":				// missile strike
		case "killstreak_strike_missile_gas_mp":					// missile strike
			event = "missile_strike_kill";
			break;
		case "remote_turret_mp":							// sentry gun
		case "remote_energy_turret_mp":						// sentry gun
		case "sentry_minigun_mp":							// sentry gun
		case "killstreakmahem_mp":							// sentry gun
		case "turretheadmg_mp":								// sentry gun
		case "turretheadenergy_mp":							// sentry gun
		case "turretheadrocket_mp":							// sentry gun
			event = "sentry_gun_kill";
			break;
		case "stealth_bomb_mp":								// strafing run
		case "airstrike_missile_mp":						// strafing run
		case "orbital_carepackage_pod_plane_mp":			// strafing run
			event = "strafing_run_kill";
			break;
		case "drone_assault_remote_turret_mp":				// assault drone
		case "ugv_missile_mp":								// assault drone
		case "assaultdrone_c4_mp":							// assault drone
			event = "assault_drone_kill";
			break;
		case "juggernaut_sentry_mg_mp":						// goliath
		case "iw5_juggernautrockets_mp":					// goliath
		case "iw5_exoxmgjugg_mp_akimbo":					// goliath
		case "iw5_juggtitan45_mp":							// goliath
		case "iw5_exominigun_mp":							// goliath
		case "iw5_mechpunch_mp":							// goliath
		case "playermech_rocket_mp":						// goliath
		case "killstreak_goliathsd_mp":						// goliath
		case "orbital_carepackage_droppod_mp":				// goliath
			event = "goliath_kill";
			break;
		case "detroit_tram_turret_mp":				// detroit turret
		case "dam_turret_mp":						// dam turret
		case "killstreak_terrace_mp":				// Terrace sniper
		case "killstreak_solar_mp":					// Solar beam
		case "refraction_turret_mp":				// Refraction turrets
		case "killstreak_comeback_mp":				// Comeback Tanks
		case "mp_laser2_core":						// Laser2 water
			event = "map_killstreak_kill";
			break;
	}
	
	if( event != "kill" )
	{
		self incPlayerStat( event, 1 );
		self maps\mp\gametypes\_missions::ch_streak_kill( event );
	}
	
	
	
	if ( level.practiceRound )
		self thread practiceRoundKillEvent( victim, event, weapon, sMeansOfDeath );
	
	level thread maps\mp\gametypes\_rank::awardGameEvent( event, self, weapon, victim, sMeansOfDeath );
}

practiceRoundDialogValid()
{
	return ( !IsDefined( self.next_pr_dialog_time ) || GetTime() > self.next_pr_dialog_time );
}

practiceRoundDialogPlayed()
{
	self.next_pr_dialog_time = GetTime() + RandomIntRange( 20000, 40000 );
}

practiceRoundKillEvent( victim, event, weapon, sMeansOfDeath )
{
	self endon( "disconnect" );
	level endon( "game_ended" );
	
	if ( IsBot( self ) )
		return;
	
	self playlocalsound( "ui_practice_round_kill" );
	
	dialog_delay = 0.5;
	
	// New personal best?
	if ( !IsDefined( self.best_pr_kills ) )
		self.best_pr_kills = self GetCommonPlayerData( "bests", "kills" );

	if ( ( self.best_pr_kills > 0 ) && ( self.kills > self.best_pr_kills ) )
	{
		self practiceRoundDialogPlayed();
		wait ( dialog_delay );
		self leaderDialogOnPlayer( "ptr_new_best" );
		self.best_pr_kills = 0; // So it never happens again this game.
	}
	else if ( event == "kill" && !isMeleeMOD( sMeansOfDeath ) )
	{
		if ( sMeansOfDeath == "MOD_HEAD_SHOT" )
		{
			self practiceRoundDialogPlayed();
			wait ( dialog_delay );
			self leaderDialogOnPlayer( "ptr_headshot" );
		}
		else
		{
			if ( !practiceRoundDialogValid() )
				return;
			
			practiceRoundDialogPlayed();
			wait ( dialog_delay );
			self leaderDialogOnPlayer( "ptr_greatshot" );
		}
	}
}

practiceRoundAssistEvent( victim )
{
	self endon( "disconnect" );
	level endon( "game_ended" );
	
	if ( IsBot( self ) )
		return;

	dialog_delay = 0.5;
	
	practiceRoundDialogPlayed();
	wait ( dialog_delay );
	self leaderDialogOnPlayer( "ptr_assist" );
}

isThinkFast( weapon, meansOfDeath )
{
	if( meansOfDeath == "MOD_IMPACT" || meansOfDeath == "MOD_HEAD_SHOT" )
	{
		if( isThinkFastWeapon(weapon) )
			return true;
	}
		
	return false;
}

isThinkFastWeapon(weapon)
{
	switch( weapon )
	{
		case "semtex_mp":
		case "frag_grenade_mp":
		case "stun_grenade__mp":
		case "stun_grenade_var_mp":
		case "emp_grenade_mp":
		case "emp_grenade_var_mp":
		case "paint_grenade_mp":
		case "paint_grenade_var_mp":
		case "smoke_grenade_mp":
		case "smoke_grenade_var_mp":
			return true;
		default:
			return false;
	}
}

thinkFastEvent()
{
	self incPlayerStat( "think_fast", 1 );

	level thread maps\mp\gametypes\_rank::awardGameEvent( "think_fast", self );
}

boostSlamKillEvent( killId, weapon, meansOfDeath )
{
	self incPlayerStat( "boostslamkill", 1 );
	
	self thread maps\mp\gametypes\_missions::processChallenge( "ch_limited_lookoutbelow", 1 );
	self thread maps\mp\gametypes\_missions::processChallenge( "ch_exomech_hot", 1 );
	level thread maps\mp\gametypes\_rank::awardGameEvent( "boostslamkill", self, weapon, undefined, meansOfDeath );
}

earnedKillStreakEvent( streakName, streakVal, modules, slotIndex )
{
	self incPlayerStat( streakName + "_earned", 1 );
	level thread maps\mp\gametypes\_rank::awardGameEvent( streakName + "_earned", self );
	
	self thread maps\mp\gametypes\_hud_message::killstreakSplashNotify( streakName, streakVal, undefined, modules, slotIndex );
	
	self maps\mp\gametypes\_missions::processChallengeDaily( 22, streakName, undefined );
	self maps\mp\gametypes\_missions::processChallengeDaily( 23, streakName, undefined );
}

bulletPenetrationEvent( killId, weapon )
{
	self incPlayerStat( "bulletpenkills", 1 );
	
	level thread maps\mp\gametypes\_rank::awardGameEvent( "bulletpen", self );
	if(IsDefined(weapon))
	{
		baseWeapon = getBaseWeaponName( weapon );
		if( isLootWeapon( baseWeapon ) )
			baseWeapon = maps\mp\gametypes\_class::getBaseFromLootVersion( baseWeapon );
		weaponClass = self maps\mp\gametypes\_missions::get_challenge_weapon_class(weapon, baseWeapon);
		if(weaponClass == "weapon_sniper")
		{
			if( IsDefined( level.challengeInfo["ch_penetrate_" + baseWeapon ] ) )
				self maps\mp\gametypes\_missions::processChallenge( "ch_penetrate_" + baseWeapon );
		}
	}
	self maps\mp\gametypes\_missions::processChallenge( "ch_boot_xray" );
}

multiKillOneBulletEvent()
{
	self incPlayerStat( "multiKillOneBullet", 1 );
	level thread maps\mp\gametypes\_rank::awardGameEvent( "multiKillOneBullet", self );
}

checkHighJumpEvents( victim, killId, weapon, meansOfDeath, eInflictor )
{
	if( IsDefined( eInflictor ) && IsDefined( eInflictor.ch_crossbow_player_jumping ) )
		attackerIsJumping = eInflictor.ch_crossbow_player_jumping;
	else
		attackerIsJumping = self IsHighJumping();
		
	if( IsDefined( eInflictor ) && IsDefined( eInflictor.ch_crossbow_victim_jumping ) )
		victimIsJumping = eInflictor.ch_crossbow_victim_jumping;
	else
		victimIsJumping = victim IsHighJumping();
	
	if( attackerIsJumping && victimIsJumping )
		self airToAirEvent( killId, weapon, meansOfDeath );
	
	if( attackerIsJumping && !victimIsJumping )
		self airToGroundEvent( killId, weapon, meansOfDeath );
	
	if( !attackerIsJumping && victimIsJumping )
		self groundToAirEvent( killId, weapon, meansOfDeath );
	
}

checkWeaponSpecificKill( victim, weapon, meansOfDeath )
{
	if( maps\mp\gametypes\_weapons::isRiotShield( weapon ) || (weapon == maps\mp\_exo_shield::get_exo_shield_weapon()) )
		riotShieldKillEvent( weapon, meansOfDeath );
	
	if( IsSubStr( weapon, "exoknife_mp" ) )
		exoKnifeKillEvent( weapon, meansOfDeath, victim );
}

exoKnifeKillEvent( weapon, meansOfDeath, victim )
{
	self incPlayerStat( "exo_knife_kill", 1 );
	
	if( IsDefined(victim.wasRecall) && victim.wasRecall )
	{
		self incPlayerStat( "exo_knife_recall_kill", 1 );
		level thread maps\mp\gametypes\_rank::awardGameEvent( "exo_knife_recall_kill", self, weapon, undefined, meansOfDeath );
		self maps\mp\gametypes\_missions::processChallenge( "ch_humiliation_boomerang" );
	}
	else
	{
		level thread maps\mp\gametypes\_rank::awardGameEvent( "exo_knife_kill", self, weapon, undefined, meansOfDeath );
	}
}

nearDeathKillEvent( weapon, meansOfDeath )
{
	self incPlayerStat( "near_death_kill", 1 );
	level thread maps\mp\gametypes\_rank::awardGameEvent( "near_death_kill", self, weapon, undefined, meansOfDeath );
}

sprintSlideKillEvent( weapon, meansOfDeath )
{
	self incPlayerStat( "slide_kill", 1 );
	level thread maps\mp\gametypes\_rank::awardGameEvent( "slide_kill", self, weapon, undefined, meansOfDeath );
}

flashedKillEvent( weapon, meansOfDeath )
{
	self incPlayerStat( "flash_kill", 1 );
	level thread maps\mp\gametypes\_rank::awardGameEvent( "flash_kill", self, weapon, undefined, meansOfDeath );
}

riotShieldKillEvent( weapon, meansOfDeath )
{
	self incPlayerStat( "riot_kill", 1 );
	level thread maps\mp\gametypes\_rank::awardGameEvent( "riot_kill", self, weapon, undefined, meansOfDeath );
}

airToAirEvent( killId, weapon, meansOfDeath )
{
	self incPlayerStat( "air_to_air_kill", 1 );
	self thread maps\mp\gametypes\_missions::processChallenge( "ch_limited_acepilot", 1 );
	self thread maps\mp\gametypes\_missions::processChallenge( "ch_exomech_redbaron", 1 );
	
	baseWeapon = getBaseWeaponName( weapon );
	if( isLootWeapon( baseWeapon ) )
		baseWeapon = maps\mp\gametypes\_class::getBaseFromLootVersion( baseWeapon );
	weaponClass = self maps\mp\gametypes\_missions::get_challenge_weapon_class(weapon, baseWeapon);
	if( isMeleeMOD(meansOfDeath) )
	{
		self incPlayerStat( "melee_air_to_air", 1 );
		level thread maps\mp\gametypes\_rank::awardGameEvent( "melee_air_to_air", self, weapon, undefined, meansOfDeath );
	}
	else
	{
		level thread maps\mp\gametypes\_rank::awardGameEvent( "air_to_air_kill", self, weapon, undefined, meansOfDeath );
		// camo check smg
		if ( WeaponClass=="weapon_smg" || WeaponClass=="weapon_shotgun")
			if(IsDefined( level.challengeInfo[ "ch_dogfight_" + baseWeapon ] ) )
				self maps\mp\gametypes\_missions::processChallenge( "ch_dogfight_" + baseWeapon);
	}
}


airToGroundEvent( killId, weapon, meansOfDeath )
{
	self incPlayerStat( "air_to_ground_kill", 1 );
	level thread maps\mp\gametypes\_rank::awardGameEvent( "air_to_ground_kill", self, weapon, undefined, meansOfDeath );
	self thread maps\mp\gametypes\_missions::processChallenge( "ch_exomech_buzz" );

	baseWeapon = getBaseWeaponName( weapon );
	if( isLootWeapon( baseWeapon ) )
		baseWeapon = maps\mp\gametypes\_class::getBaseFromLootVersion( baseWeapon );
	weaponClass = self maps\mp\gametypes\_missions::get_challenge_weapon_class(weapon, baseWeapon);
	// camo unlocks for assault and heavy
	if( WeaponClass == "weapon_assault" || WeaponClass == "weapon_heavy" || IsSubStr( weapon, "exocrossbow" ) )
	{
		if( IsSubStr( baseWeapon, "dlcgun" ) && weaponClass == "weapon_assault" )
			self maps\mp\gametypes\_missions::processChallenge( "ch_tier2_1_" + baseWeapon );
		else
			self maps\mp\gametypes\_missions::processChallenge( "ch_strafe_" + baseWeapon );
	}
}


groundToAirEvent( killId, weapon, meansOfDeath )
{
	self incPlayerStat( "ground_to_air_kill", 1 );
	level thread maps\mp\gametypes\_rank::awardGameEvent( "ground_to_air_kill", self, weapon, undefined, meansOfDeath );
	self thread maps\mp\gametypes\_missions::processChallenge( "ch_exomech_pull" );
	
	// camo
	baseWeapon = getBaseWeaponName( weapon );
	if( isLootWeapon( baseWeapon ) )
		baseWeapon = maps\mp\gametypes\_class::getBaseFromLootVersion( baseWeapon );
	weaponClass = maps\mp\gametypes\_missions::get_challenge_weapon_class( weapon, baseWeapon );
	
	if( weaponClass == "weapon_heavy" || IsSubStr( weapon, "exocrossbow" ) )
	{		
		if( isDefined( level.challengeInfo["ch_skeet_" + baseWeapon] ) )
			self maps\mp\gametypes\_missions::processChallenge( "ch_skeet_" + baseWeapon );
	}
}

isOneShotKill( victim, weapon, meansOfDeath )
{
	if( victim.attackers.size != 1 )
		return false;
	
	if( !IsDefined(victim.attackers[self.guid]) )
		return false;
	
	if( isMeleeMOD(meansOfDeath) )
		return false;
	
	if( getTime() != victim.attackerData[self.guid].firstTimeDamaged )
		return false;

	weaponClass = getWeaponClass( weapon );
		
	if( (weaponClass == "weapon_sniper") || (weaponClass == "weapon_shotgun") )
		return true;
		
	return false;
}

isLongShot( attacker, weapon, meansOfDeath, victim )
{
	if( IsDefined(victim.agentBody) )
		return false;
		
	attackerPosition = self.origin;
		
	if( isDefined( victim.attackerPosition ) )
		attackerPosition = victim.attackerPosition;
		
	if( isAlive( attacker ) &&
		!attacker isUsingRemote() && 
		( meansOfDeath == "MOD_RIFLE_BULLET" || meansOfDeath == "MOD_PISTOL_BULLET" || meansOfDeath == "MOD_HEAD_SHOT" ||  IsSubStr( weapon, "exoknife_mp" ) || IsSubStr( weapon, "exocrossbow" ) || IsSubStr( weapon, "m990" ) ) &&
		!isKillstreakWeapon( weapon ) && !isDefined( attacker.assistedSuicide ) )
	{
		thisWeaponClass = getWeaponClass( weapon );
		switch( thisWeaponClass )
		{
			case "weapon_pistol":
				weapDist = 800;
				break;
			case "weapon_smg":
				weapDist = 1200;
				break;
			case "weapon_assault":
			case "weapon_heavy":
				weapDist = 1500;
				break;
			case "weapon_sniper":
				weapDist = 2000;
				break;
			case "weapon_shotgun":
				weapDist = 500;
				break;
			case "weapon_projectile":
			default:
				weapDist = 1536;
				break;
		}

		if( IsSubStr( weapon, "exoknife_mp" ) || IsSubStr( weapon, "exocrossbow" ) ) // special case for spike drone and crossbow
			weapDist = 1200;
		
		weapDistSq = weapDist * weapDist;
		if( DistanceSquared( attackerPosition, victim.origin ) > weapDistSq )
		{
//			if( attacker IsItemUnlocked( "specialty_holdbreath" ) && attacker _hasPerk( "specialty_holdbreath" ) )
//				attacker maps\mp\gametypes\_missions::processChallenge( "ch_longdistance" );
			
			return true;
		}
	}

	return false;
}

isResuce( victim, curTime )
{
	if( !level.teamBased )
		return false;
	
	foreach( guid, damageTime in victim.damagedPlayers )
	{
		if( (guid != self.guid) && (curTime - damageTime < 500) )
			return true;
	}
	
	return false;
}


longShotEvent( killId, weapon, meansOfDeath )
{
	self.modifiers["longshot"] = true;
	
	self incPlayerStat( "longshots", 1 );

	level thread maps\mp\gametypes\_rank::awardGameEvent( "longshot", self, weapon, undefined, meansOfDeath );
	self thread maps\mp\_matchdata::logKillEvent( killId, "longshot" );
}


headShotEvent( killId, weapon, meansOfDeath )
{
	self.modifiers["headshot"] = true;
	
	self incPersStat( "headshots", 1 );
	self incPlayerStat( "headshots", 1 );
	self maps\mp\gametypes\_persistence::statSetChild( "round", "headshots", clampToShort( self.pers["headshots"] ) );
	self.headshots = self getPersStat( "headshots" );

	level thread maps\mp\gametypes\_rank::awardGameEvent( "headshot", self, weapon, undefined, meansOfDeath );	
	self thread maps\mp\_matchdata::logKillEvent( killId, "headshot" );
	self maps\mp\gametypes\_missions::processChallenge( "ch_limited_headhunter" );
}

isThrowBackEvent( victim, weapon, meansOfDeath )
{
	if( !IsExplosiveDamageMOD( meansOfDeath ) )
		return false;
	
	if( !isStrStart( weapon, "frag_" ) )
		return false;
	
	if( IsDefined( victim ) && IsDefined( victim.explosiveInfo ) && IsDefined( victim.explosiveInfo["throwbackKill"] ) && victim.explosiveInfo["throwbackKill"] )
		return true;
	
	return false;
}

throwBackKillEvent()
{
	self incPlayerStat( "throwback_kill", 1 );
	level thread maps\mp\gametypes\_rank::awardGameEvent( "throwback_kill", self );
}


fourPlayEvent()
{
	self incPlayerStat( "four_play", 1 );
	level thread maps\mp\gametypes\_rank::awardGameEvent( "four_play", self );
}


avengedPlayerEvent( killId, weapon, meansOfDeath )
{
	self.modifiers["avenger"] = true;
	
	self incPlayerStat( "avengekills", 1 );

	level thread maps\mp\gametypes\_rank::awardGameEvent( "avenger", self, weapon, undefined, meansOfDeath );
	self thread maps\mp\_matchdata::logKillEvent( killId, "avenger" );
	
	self maps\mp\gametypes\_missions::processChallenge( "ch_" + level.gametype + "_avenger" );
}


assistedSuicideEvent( killId, weapon, meansOfDeath )
{
	self.modifiers["assistedsuicide"] = true;
	
	self incPlayerStat( "assistedsuicide", 1 );

	level thread maps\mp\gametypes\_rank::awardGameEvent( "assistedsuicide", self, weapon, undefined, meansOfDeath );
	self thread maps\mp\_matchdata::logKillEvent( killId, "assistedsuicide" );
}


defendedPlayerEvent( killId, weapon, meansOfDeath )
{
	self.modifiers["defender"] = true;

	self incPlayerStat( "rescues", 1 );

	level thread maps\mp\gametypes\_rank::awardGameEvent( "defender", self, weapon, undefined, meansOfDeath );
	self thread maps\mp\_matchdata::logKillEvent( killId, "defender" );
		
	self maps\mp\gametypes\_missions::processChallenge( "ch_" + level.gametype + "_savior" );
}


defendObjectiveEvent( victim, killId )
{		
	self incPlayerStat( "defends", 1 );
	self incPersStat( "defends", 1 );
	self maps\mp\gametypes\_persistence::statSetChild( "round", "defends", self.pers["defends"] );

	level thread maps\mp\gametypes\_rank::awardGameEvent( "defend", self );
	victim thread maps\mp\_matchdata::logKillEvent( killId, "assaulting" );
}


assaultObjectiveEvent( victim, killId )
{
	self incPlayerStat( "assault", 1 );
	
	level thread maps\mp\gametypes\_rank::awardGameEvent( "assault", self );
	
	victim thread maps\mp\_matchdata::logKillEvent( killId, "defending" );
	
	self maps\mp\gametypes\_missions::processChallenge( "ch_" + level.gametype + "_attacker" );
	self maps\mp\gametypes\_missions::processChallengeDaily( 7, undefined, undefined );
}


postDeathKillEvent( killId )
{
	self.modifiers["posthumous"] = true;
	
	self incPlayerStat( "posthumous", 1 );

	level thread maps\mp\gametypes\_rank::awardGameEvent( "posthumous", self );
	self thread maps\mp\_matchdata::logKillEvent( killId, "posthumous" );
	self maps\mp\gametypes\_missions::processChallenge( "ch_humiliation_afterlife" );
	// camo
	baseWeapon = getBaseWeaponName( self GetCurrentWeapon() );
	if (baseWeapon == "iw5_microdronelauncher" || baseWeapon == "iw5_exocrossbow")
		if(IsDefined( level.challengeInfo[ "ch_afterlife_" + baseWeapon ] ) )
				self maps\mp\gametypes\_missions::processChallenge( "ch_afterlife_" + baseWeapon);
}

isBackStabEvent( victim, weapon, meansOfDeath )
{
	if( !isMeleeMOD( meansOfDeath ) )
		return false;
	
	if( maps\mp\gametypes\_weapons::isRiotShield( weapon ) || (weapon == maps\mp\_exo_shield::get_exo_shield_weapon()) )
		return false;
	
	anglesOnDeath	= victim GetPlayerAngles();
	anglesOnKill	= self GetPlayerAngles();
	angleDiff 		= AngleClamp180( anglesOnDeath[1] - anglesOnKill[1] );
	
	if( abs(angleDiff) < 75 )
		return true;
	
	return false;	
}
	
backStabEvent( killId )
{
	self incPlayerStat( "backstab", 1 );
	
	level thread maps\mp\gametypes\_rank::awardGameEvent( "backstab", self );
	self maps\mp\gametypes\_missions::processChallenge( "ch_humiliation_backstab" );
}


revengeEvent( killId )
{
	self.modifiers["revenge"] = true;

	self.lastKilledBy = undefined;
	self incPlayerStat( "revengekills", 1 );
	
	level thread maps\mp\gametypes\_rank::awardGameEvent( "revenge", self );
	self thread maps\mp\_matchdata::logKillEvent( killId, "revenge" );
	self maps\mp\gametypes\_missions::processChallenge( "ch_humiliation_revenge" );
}

multiKillEvent( killId, killCount, weapon, was_ads )
{
	assert( killCount > 1 );
	
	if( !IsDefined( was_ads ) )
		was_ads = false;
	
	weapon_class = maps\mp\gametypes\_missions::get_challenge_weapon_class( weapon );
	
	baseWeapon = getBaseWeaponName( weapon );
	if( isLootWeapon( baseWeapon ) )
		baseWeapon = maps\mp\gametypes\_class::getBaseFromLootVersion( baseWeapon );
	
	shortWeaponName = "";
	if( string_starts_with( baseWeapon, "iw5_" ) )
		shortWeaponName = GetSubStr( baseWeapon, 4 );	   	
	
	switch( killCount )
	{
		case 2:
			level thread maps\mp\gametypes\_rank::awardGameEvent( "doublekill", self );
			self incPlayerStat( "doublekill", 1 );
			self maps\mp\gametypes\_missions::processChallenge( "ch_killer_double" );
			self maps\mp\gametypes\_missions::processChallenge( "ch_" + level.gametype + "_double" );

			if( weapon_class == "weapon_smg" || weapon_class == "weapon_shotgun" || weapon_class == "weapon_sniper" || baseWeapon == "iw5_microdronelauncher" || baseWeapon == "iw5_exocrossbow" )
				if( IsDefined( level.challengeInfo[ "ch_double_" + baseWeapon ] ) )
					self maps\mp\gametypes\_missions::processChallenge( "ch_double_" + baseWeapon );			

			if( IsDefined( level.challengeInfo[ "ch_attach_unlock_double_" + shortWeaponName] ) )
				self maps\mp\gametypes\_missions::processChallenge( "ch_attach_unlock_double_" + shortWeaponName );
			
			break;
		case 3:
			level thread maps\mp\gametypes\_rank::awardGameEvent( "triplekill", self );
			level thread teamPlayerCardSplash( "callout_3xkill", self );
			self incPlayerStat( "triplekill", 1 );
			self maps\mp\gametypes\_missions::processChallenge( "ch_killer_triple" );
			self maps\mp\gametypes\_missions::processChallenge( "ch_" + level.gametype + "_triple" );
			
			if( maps\mp\gametypes\_missions::isAtBrinkOfDeath() )
				self maps\mp\gametypes\_missions::processChallenge( "ch_precision_sitcrit" );
			
			if( ( IsDefined( weapon_class ) && ( weapon_class == "weapon_smg" || weapon_class == "weapon_heavy" ) ) && was_ads == false )
				self maps\mp\gametypes\_missions::processChallenge( "ch_precision_hello" );
			break;
		case 4:
			level thread maps\mp\gametypes\_rank::awardGameEvent( "fourkill", self );
			level thread teamPlayerCardSplash( "callout_4xkill", self );
			self incPlayerStat( "fourkill", 1 );
			self maps\mp\gametypes\_missions::processChallenge( "ch_killer_feed" );
			self maps\mp\gametypes\_missions::processChallenge( "ch_killer_fury" );
			self maps\mp\gametypes\_missions::processChallenge( "ch_limited_bloodshed_fury" );
			break;
		case 5:
			level thread maps\mp\gametypes\_rank::awardGameEvent( "fivekill", self );
			level thread teamPlayerCardSplash( "callout_5xkill", self );
			self incPlayerStat( "fivekill", 1 );
			self maps\mp\gametypes\_missions::processChallenge( "ch_killer_frenzy" );
			break;
		case 6:
			level thread maps\mp\gametypes\_rank::awardGameEvent( "sixkill", self );
			level thread teamPlayerCardSplash( "callout_6xkill", self );
			self incPlayerStat( "sixkill", 1 );
			self maps\mp\gametypes\_missions::processChallenge( "ch_killer_super" );
			break;
		case 7:
			level thread maps\mp\gametypes\_rank::awardGameEvent( "sevenkill", self );
			level thread teamPlayerCardSplash( "callout_7xkill", self );
			self incPlayerStat( "sevenkill", 1 );
			self maps\mp\gametypes\_missions::processChallenge( "ch_killer_mega" );
			break;
		case 8:
			level thread maps\mp\gametypes\_rank::awardGameEvent( "eightkill", self );
			level thread teamPlayerCardSplash( "callout_8xkill", self );
			self incPlayerStat( "eightkill", 1 );
			self maps\mp\gametypes\_missions::processChallenge( "ch_killer_ultra" );
			break;
		default:
			level thread maps\mp\gametypes\_rank::awardGameEvent( "multikill", self );
			thread teamPlayerCardSplash( "callout_9xpluskill", self );
			self incPlayerStat( "multikill", 1 );
			self maps\mp\gametypes\_missions::processChallenge( "ch_killer_chain" );
			break;			
	}
	
	self thread maps\mp\_matchdata::logMultiKill( killId, killCount );
}


takeAndKillEvent()
{
	self incPlayerStat( "take_and_kill", 1 );
	level thread maps\mp\gametypes\_rank::awardGameEvent( "take_and_kill", self );
	self maps\mp\gametypes\_missions::processChallenge( "ch_humiliation_backfire" );
}

killedBallCarrierEvent()
{
	self incPlayerStat( "killedBallCarrier", 1 );
	level thread maps\mp\gametypes\_rank::awardGameEvent( "killedBallCarrier", self );
}

setUplinkStats()
{
	uplinks = getPlayerStat( "fieldgoal" ) + ( getPlayerStat( "touchdown" ) * 2 );
	self maps\mp\gametypes\_persistence::statSetChild( "round", "captures", uplinks );
	self setExtraScore0( uplinks );
}

touchDownEvent(score)
{
	self thread teamPlayerCardSplash( "callout_touchdown", self, undefined, score );
	
	self incPlayerStat( "touchdown", 1 );
	self setUplinkStats();
	
	level thread maps\mp\gametypes\_rank::awardGameEvent( "touchdown", self );
	
	self maps\mp\gametypes\_missions::processChallenge( "ch_" + level.gametype + "_touchdown" );
	self maps\mp\gametypes\_missions::processChallengeDaily( 13, score, undefined );
}


fieldGoalEvent(score)
{
	self thread teamPlayerCardSplash( "callout_fieldgoal", self, undefined, score );
	
	self incPlayerStat( "fieldgoal", 1 );
	self setUplinkStats();
	
	level thread maps\mp\gametypes\_rank::awardGameEvent( "fieldgoal", self );
	
	self maps\mp\gametypes\_missions::processChallenge( "ch_" + level.gametype + "_fieldgoal" );
	self maps\mp\gametypes\_missions::processChallengeDaily( 13, score, undefined );
}


interceptionEvent()
{
	self incPlayerStat( "interception", 1 );
	level thread maps\mp\gametypes\_rank::awardGameEvent( "interception", self );
}


killWithBallEvent()
{
	self incPlayerStat( "kill_with_ball", 1 );
	level thread maps\mp\gametypes\_rank::awardGameEvent( "kill_with_ball", self );
}


ballScoreAssistEvent()
{
	self incPlayerStat( "ball_score_assist", 1 );
	level thread maps\mp\gametypes\_rank::awardGameEvent( "ball_score_assist", self );
	self maps\mp\gametypes\_missions::processChallenge( "ch_" + level.gametype + "_assist" );
}


passKillPickupEvent()
{
	self incPlayerStat( "pass_kill_pickup", 1 );
	level thread maps\mp\gametypes\_rank::awardGameEvent( "pass_kill_pickup", self );
}


flagPickUpEvent()
{
	self thread teamPlayerCardSplash( "callout_flagpickup", self );
	self incPlayerStat( "flagscarried", 1 );
	
	level thread maps\mp\gametypes\_rank::awardGameEvent( "flag_pickup", self );
	self thread maps\mp\_matchdata::logGameEvent( "pickup", self.origin );
	
	self maps\mp\gametypes\_missions::processChallenge( "ch_" + level.gametype + "_flag_carry" );
}


flagCaptureEvent()
{
	self thread teamPlayerCardSplash( "callout_flagcapture", self );
	
	self incPlayerStat( "flagscaptured", 1 );
	self incPersStat( "captures", 1 );
	self maps\mp\gametypes\_persistence::statSetChild( "round", "captures", self.pers["captures"] );
	self setExtraScore0( self.pers[ "captures" ] );
	
	level thread maps\mp\gametypes\_rank::awardGameEvent( "flag_capture", self );
	self thread maps\mp\_matchdata::logGameEvent( "capture", self.origin );
	
	self maps\mp\gametypes\_missions::processChallenge( "ch_" + level.gametype + "_flag_capture" );
	self maps\mp\gametypes\_missions::processChallengeDaily( 16, undefined, undefined );
}

flagReturnEvent()
{
	self thread teamPlayerCardSplash( "callout_flagreturn", self );
	
	self incPlayerStat( "flagsreturned", 1 );
	self incPersStat( "returns", 1 );
	self.assists = self.pers[ "returns" ];
	self maps\mp\gametypes\_persistence::statSetChild( "round", "returns", self.pers["returns"] );
	
	level thread maps\mp\gametypes\_rank::awardGameEvent( "flag_return", self );
	self thread maps\mp\_matchdata::logGameEvent( "return", self.origin );
	
	self maps\mp\gametypes\_missions::processChallenge( "ch_" + level.gametype + "_flag_return" );
	self maps\mp\gametypes\_missions::processChallengeDaily( 17, undefined, undefined );
}


killWithFlagEvent()
{
	self incPlayerStat( "killsasflagcarrier", 1 );
	level thread maps\mp\gametypes\_rank::awardGameEvent( "kill_with_flag", self );
}


killFlagCarrierEvent( killId )
{	
	self thread teamPlayerCardSplash( "callout_killflagcarrier", self );	
	
	self incPlayerStat( "flagcarrierkills", 1 );
	self incPersStat( "defends", 1 );
	self maps\mp\gametypes\_persistence::statSetChild( "round", "defends", self.pers["defends"] );
			
	level thread maps\mp\gametypes\_rank::awardGameEvent( "kill_flag_carrier", self );
	self thread maps\mp\_matchdata::logKillEvent( killId, "carrying" );

	self maps\mp\gametypes\_missions::processChallenge( "ch_" + level.gametype + "_flag_defend" );	
}


killDeniedEvent( isTagOwner )
{
	self incPlayerStat( "killsdenied", 1 );
	self incPersStat( "denied", 1 );		
	self setExtraScore1( self.pers[ "denied" ] );
	self maps\mp\gametypes\_persistence::statSetChild( "round", "denied", self.pers["denied"] );
	
	event = "kill_denied";
	
	if( isTagOwner )
	{
		event = "kill_denied_retrieved";
		self incPlayerStat( "kill_denied_retrieved", 1 );
		self maps\mp\gametypes\_missions::processChallenge( "ch_" + level.gametype + "_save_yourself" );
	}
		
	level thread maps\mp\gametypes\_rank::awardGameEvent( event, self );
	
	self maps\mp\gametypes\_missions::processChallenge( "ch_" + level.gametype + "_denial" );
	self maps\mp\gametypes\_missions::processChallengeDaily( 21, undefined, undefined );
	
}


killConfirmedEvent()
{
	self incPlayerStat( "killsconfirmed", 1 );
	self incPersStat( "confirmed", 1 );
	self setExtraScore0( self.pers[ "confirmed" ] );
	self maps\mp\gametypes\_persistence::statSetChild( "round", "confirmed", self.pers["confirmed"] );
	
	level thread maps\mp\gametypes\_rank::awardGameEvent( "kill_confirmed", self );
	
	self maps\mp\gametypes\_missions::processChallenge( "ch_" + level.gametype + "_collector" );
	
	self maps\mp\gametypes\_missions::processChallengeDaily( 4, undefined, undefined );
}

tagCollectorEvent()
{
	self incPlayerStat( "tag_collector", 1 );
	level thread maps\mp\gametypes\_rank::awardGameEvent( "tag_collector", self );
}

monitorTagCollector( player )
{
	if( !IsPlayer(player) )
		return;
		
	player notify( "tagCollector" );
	player endon( "tagCollector" );
	
	if( !IsDefined(player.tagCollectorTotal) )
		player.tagCollectorTotal = 0;
	
	player.tagCollectorTotal++;
	
	if( player.tagCollectorTotal > 2 )
	{
		player maps\mp\_events::tagCollectorEvent();
		player.tagCollectorTotal = 0;
	}
	
	wait(2.5);
		
	player.tagCollectorTotal = 0;
}

bombPlantEvent()
{
	self incPlayerStat( "bombsplanted", 1 );
	self incPersStat( "plants", 1 );
	self maps\mp\gametypes\_persistence::statSetChild( "round", "plants", self.pers["plants"] );
	self setExtraScore0( self.pers[ "plants" ] );
	
	level thread teamPlayerCardSplash( "callout_bombplanted", self );
	level thread maps\mp\gametypes\_rank::awardGameEvent( "plant", self );
	
	self thread maps\mp\_matchdata::logGameEvent( "plant", self.origin );
}

bombDefuseEvent( defuseType )
{
	self incPlayerStat( "bombsdefused", 1 );
	self incPersStat( "defuses", 1 );
	self maps\mp\gametypes\_persistence::statSetChild( "round", "defuses", self.pers["defuses"] );
	self setExtraScore1( self.pers[ "defuses" ] );
	
	level thread teamPlayerCardSplash( "callout_bombdefused", self );
	
	if( (defuseType == "ninja_defuse") || (defuseType == "last_man_defuse") )
	{
		self incPlayerStat( defuseType, 1 );
		
		if( defuseType == "last_man_defuse" )
			self maps\mp\gametypes\_missions::processChallenge( "ch_" + level.gametype + "_ninja" );
	}
			
	level thread maps\mp\gametypes\_rank::awardGameEvent( defuseType, self );
	
	self thread maps\mp\_matchdata::logGameEvent( "defuse", self.origin );
	
	self maps\mp\gametypes\_missions::processChallenge( "ch_" + level.gametype + "_bombdefuse" );
}

eliminatePlayerEvent( isLastPlayerAlive, victim )
{
	self incPlayerStat( "elimination", 1 );
	
	level thread teamPlayerCardSplash( "callout_eliminated", victim );
	
	if( isLastPlayerAlive )
	{
		self incPlayerStat( "last_man_standing", 1 );
		level thread maps\mp\gametypes\_rank::awardGameEvent( "last_man_standing", self );
	}
	else
	{
		level thread maps\mp\gametypes\_rank::awardGameEvent( "elimination", self );
	}
}

reviveTagEvent( playerRevived )
{
	self incPlayerStat( "sr_tag_revive", 1 );
	self incPlayerStat( "killsdenied", 1 );
	self incPersStat( "denied", 1 );
	self maps\mp\gametypes\_persistence::statSetChild( "round", "denied", self.pers["denied"] );
	self.assists = ( self.pers[ "denied" ] );
	
	level thread teamPlayerCardSplash( "callout_tag_revive", playerRevived );
	
	level thread maps\mp\gametypes\_rank::awardGameEvent( "sr_tag_revive", self );
	
	self maps\mp\gametypes\_missions::processChallenge( "ch_" + level.gametype + "_medic" );
}

eliminateTagEvent()
{
	self incPlayerStat( "sr_tag_elimination", 1 );
	self incPlayerStat( "killsconfirmed", 1 );
	self incPersStat( "confirmed", 1 );
	self maps\mp\gametypes\_persistence::statSetChild( "round", "confirmed", self.pers["confirmed"] );
	
	level thread maps\mp\gametypes\_rank::awardGameEvent( "sr_tag_elimination", self );
}

bombDetonateEvent()
{
	self incPlayerStat( "targetsdestroyed", 1 );
	self incPersStat( "destructions", 1 );
	self maps\mp\gametypes\_persistence::statSetChild( "round", "destructions", self.pers["destructions"] );
									
	level thread maps\mp\gametypes\_rank::awardGameEvent( "destroy", self );	
	
	self maps\mp\gametypes\_missions::processChallenge( "ch_" + level.gametype + "_destroyer" );
}

increaseGunLevelEvent()
{
	self incPlayerStat( "levelup", 1 );
	level thread maps\mp\gametypes\_rank::awardGameEvent( "gained_gun_score", self );
}

decreaseGunLevelEvent()
{
	self incPlayerStat( "dejavu", 1 );
	level thread maps\mp\gametypes\_rank::awardGameEvent( "dropped_gun_score", self );
}

setBackEnemyGunLevelEvent()
{
	self incPlayerStat( "humiliation", 1 );
	level thread maps\mp\gametypes\_rank::awardGameEvent( "dropped_enemy_gun_rank", self );
	
	self maps\mp\gametypes\_missions::processChallenge( "ch_" + level.gametype + "_regression" );
}

quickGunLevelEvent()
{
	self incPlayerStat( "gunslinger", 1 );
	level thread maps\mp\gametypes\_rank::awardGameEvent( "quick_gun_rank", self );
}

setBackFirstPlayerGunLevelEvent()
{
	self incPlayerStat( "regicide", 1 );
	level thread maps\mp\gametypes\_rank::awardGameEvent( "dropped_first_player_gun_rank", self );
}
	
firstInfectedEvent()
{
	self incPlayerStat( "patientzero", 1 );
	
	playSoundOnPlayers( "mp_enemy_obj_captured" );
	
	level thread teamPlayerCardSplash( "callout_first_infected", self );
	level thread maps\mp\gametypes\_rank::awardGameEvent( "first_infected", self );
	
	self.patient_zero = 0;
}

finalSurvivorEvent()
{
	self incPlayerStat( "omegaman", 1 );
	
	playSoundOnPlayers( "mp_obj_captured" );
	
	level thread teamPlayerCardSplash( "callout_final_survivor", self );
	level thread maps\mp\gametypes\_rank::awardGameEvent( "final_survivor", self );
	
	self maps\mp\gametypes\_missions::processChallenge( "ch_" + level.gametype + "_survivor" );
}

gotInfectedEvent()
{
	self incPlayerStat( "careless", 1 );
	level thread maps\mp\gametypes\_rank::awardGameEvent( "got_infected", self );
}

plagueEvent()
{
	self incPlayerStat( "plague", 1 );
	level thread maps\mp\gametypes\_rank::awardGameEvent( "infected_plague", self );
}

infectedSurvivorEvent()
{
	self incPlayerStat( "contagious", 1 );
	
	level thread teamPlayerCardSplash( "callout_infected_survivor", self, "axis" );	
	level thread maps\mp\gametypes\_rank::awardGameEvent( "infected_survivor", self );
}

survivorEvent()
{
	self incPlayerStat( "survivor", 1 );
	
	level thread maps\mp\gametypes\_rank::awardGameEvent( "survivor", self );
}

domCaptureEvent( isOpeningMove )
{
	self incPlayerStat( "pointscaptured", 1 );
	self incPersStat( "captures", 1 );
	self maps\mp\gametypes\_persistence::statSetChild( "round", "captures", self.pers["captures"] );
	self setExtraScore0( self.pers[ "captures" ] );
	
	event = "capture";
	
	if( isOpeningMove )
	{
		event = "opening_move";
		self incPlayerStat( "opening_move", 1 );
	}
	
	level thread maps\mp\gametypes\_rank::awardGameEvent( event, self );
	
	self thread maps\mp\_matchdata::logGameEvent( "capture", self.origin );
	
	self maps\mp\gametypes\_missions::processChallenge( "ch_" + level.gametype + "_aggression" );
	self maps\mp\gametypes\_missions::processChallengeDaily( 6, undefined, undefined );
}

domNeutralizeEvent()
{
	level thread maps\mp\gametypes\_rank::awardGameEvent( "neutralize", self );
}

killWhileCapture( victim, killId )
{
	self incPlayerStat( "assault", 1 );
	self incPlayerStat( "kill_while_capture", 1 );
	
	level thread maps\mp\gametypes\_rank::awardGameEvent( "kill_while_capture", self );
	
	victim thread maps\mp\_matchdata::logKillEvent( killId, "defending" );
	
	self maps\mp\gametypes\_missions::processChallenge( "ch_" + level.gametype + "_defender" );
	self maps\mp\gametypes\_missions::processChallengeDaily( 22, undefined, undefined );
}

secureHardPointEvent()
{
	self incPlayerStat( "hp_secure", 1 );
	self incPersStat( "captures", 1 );
	self maps\mp\gametypes\_persistence::statSetChild( "round", "captures", self.pers["captures"] );
	self setExtraScore0( self.pers["captures"] );
	
	level thread teamPlayerCardSplash( "callout_hp_captured_by", self );
	level thread maps\mp\gametypes\_rank::awardGameEvent( "hp_secure", self );
	
	self thread maps\mp\_matchdata::logGameEvent( "capture", self.origin );
	
	self maps\mp\gametypes\_missions::processChallenge( "ch_" + level.gametype + "_aggression" );
}

firstBloodEvent( killId, weapon, meansOfDeath )
{
	self.modifiers["firstblood"] = true;
	
	self incPlayerStat( "firstblood", 1 );

	self thread teamPlayerCardSplash( "callout_firstblood", self );
	
	level thread maps\mp\gametypes\_rank::awardGameEvent( "firstblood", self, weapon, undefined, meansOfDeath );
	self thread maps\mp\_matchdata::logKillEvent( killId, "firstblood" );
}

isBuzzKillEvent( victim )
{
	foreach( streakName in victim.killstreaks )
	{
		if( maps\mp\killstreaks\_killstreaks::isSupportStreak( victim, streakName ) )
			continue;
		
		streakVal 	= maps\mp\killstreaks\_killstreaks::getStreakCost( streakName );
		adrenaline 	= victim.adrenaline;
		
		if( streakVal < adrenaline )
			continue;
		
		if( streakVal - adrenaline < 101 )
			return true;
	}
		
	return false;
}

buzzKillEvent( killId, victim, weapon, meansOfDeath )
{
	self.modifiers["buzzkill"] =  victim.pers["cur_kill_streak"];
	
	self incPlayerStat( "buzzkill", 1 );

	level thread maps\mp\gametypes\_rank::awardGameEvent( "buzzkill", self, weapon, undefined, meansOfDeath );
	self maps\mp\gametypes\_missions::processChallenge( "ch_humiliation_buzzkill" ); 
}


oneShotKillEvent(  killId, weapon, meansOfDeath )
{
	self.modifiers["oneshotkill"] = true;
	
	self incPlayerStat( "oneshotkill", 1 );
	
	level thread maps\mp\gametypes\_rank::awardGameEvent( "oneshotkill", self, weapon, undefined, meansOfDeath );
	self maps\mp\gametypes\_missions::processChallenge( "ch_limited_deadeye" );
	
	if( getWeaponClass( weapon ) == "weapon_sniper" )
		self notify( "increment_sharpshooter_kills" );
	else if( getWeaponClass( weapon ) == "weapon_shotgun" )
		self notify( "increment_oneshotgun_kills" );
}


comeBackEvent( killId, weapon, meansOfDeath )
{
	self.modifiers["comeback"] = true;

	self incPlayerStat( "comebacks", 1 );
	
	level thread maps\mp\gametypes\_rank::awardGameEvent( "comeback", self, weapon, undefined, meansOfDeath );
	self thread maps\mp\_matchdata::logKillEvent( killId, "comeback" );
}

semtexStickEvent( victim )
{
	self incPlayerStat( "semtex_stick", 1 );
	level thread maps\mp\gametypes\_rank::awardGameEvent( "semtex_stick", self );
	
	victim incPlayerStat( "stuck_with_explosive", 1 );
	level thread maps\mp\gametypes\_rank::awardGameEvent( "stuck_with_explosive", victim );
	self maps\mp\gametypes\_missions::processChallenge( "ch_humiliation_stuck" );
	self notify( "increment_stuck_kills" );
}

crossbowStickEvent( victim )
{
	self incPlayerStat( "crossbow_stick", 1 );
	level thread maps\mp\gametypes\_rank::awardGameEvent( "crossbow_stick", self );
	
	victim incPlayerStat( "stuck_with_explosive", 1 );
	level thread maps\mp\gametypes\_rank::awardGameEvent( "stuck_with_explosive", victim );
	self maps\mp\gametypes\_missions::processChallenge( "ch_humiliation_stuck" );
	self notify( "increment_stuck_kills" );
}

disconnected()
{
	myGuid = self.guid;
	
	for ( entry = 0; entry < level.players.size; entry++ )
	{
		if ( isDefined( level.players[entry].killedPlayers[myGuid] ) )
			level.players[entry].killedPlayers[myGuid] = undefined;
	
		if ( isDefined( level.players[entry].killedPlayersCurrent[myGuid] ) )
			level.players[entry].killedPlayersCurrent[myGuid] = undefined;
	
		if ( isDefined( level.players[entry].killedBy[myGuid] ) )
			level.players[entry].killedBy[myGuid] = undefined;
	}
}


updateRecentKills( killId, weapon )
{
	if( !IsDefined( weapon ) )
		weapon = "";
	
	self endon ( "disconnect" );
	level endon ( "game_ended" );
	
	self notify ( "updateRecentKills" );
	self endon ( "updateRecentKills" );
	
	self.recentKillCount++;
	
	was_ads = false;
	if( self PlayerAds() >= 0.2 )
		was_ads = true;
	
	wait ( 2.0 );
	
	if ( self.recentKillCount > 1 )
		self multiKillEvent( killId, self.recentKillCount, weapon, was_ads );
	
	self.recentKillCount = 0;
}

hijackerEvent( owner )
{	
	self incPlayerStat( "hijacker", 1 );
	
	level thread maps\mp\gametypes\_rank::awardGameEvent( "hijacker", self );
	self thread maps\mp\gametypes\_missions::genericChallenge( "hijacker_airdrop" );
	
	if( IsDefined( owner ) )
		owner maps\mp\gametypes\_hud_message::playerCardSplashNotify( "hijacked_airdrop", self );
}

sharedEvent()
{
	self incPlayerStat( "sharepackage", 1 );
	level thread maps\mp\gametypes\_rank::awardGameEvent( "sharepackage", self );
}

mapKillStreakEvent()
{
	mapStreaksReceived = getMatchData( "players", self.clientId, "numberOfMapstreaksReceived" );
	mapStreaksReceived++;
	setMatchData( "players", self.clientId, "numberOfMapstreaksReceived", clampToByte( mapStreaksReceived ) ); 

	self incPlayerStat( "map_killstreak", 1 );
	level thread maps\mp\gametypes\_rank::awardGameEvent( "map_killstreak", self );
}

killStreakTagEvent()
{
	self incPlayerStat( "killstreak_tag", 1 );
	level thread maps\mp\gametypes\_rank::awardGameEvent( "killstreak_tag", self );
}

killStreakJoinEvent()
{
	coopStreakTime 	= GetTime();
	nextAllowTime 	= self.lastCoopStreakTime + 10000;
		
	if( nextAllowTime > coopStreakTime )
		return;
	
	self.lastCoopStreakTime = coopStreakTime;
		
	self incPlayerStat( "killstreak_join", 1 );
	level thread maps\mp\gametypes\_rank::awardGameEvent( "killstreak_join", self );
}

checkVandalismMedal( killer )
{
	if( IsDefined(level.isHorde) )
		return;

	if ( !IsDefined( self.attackerList ) )
	{
		return;
	}

	if( !IsDefined(killer) )
		killer = self;
	
	owner = self.owner;
	
	if( !IsDefined(owner) )
		owner = self;
	
	foreach( previousAttacker in self.attackerList )
	{
		if( !IsDefined(previousAttacker) )
			continue;
		
		if( previousAttacker == owner )
			continue;
		
		if( previousAttacker == killer )
			continue;
		
		previousAttacker incPlayerStat( "assist_killstreak_destroyed", 1 );
		level thread maps\mp\gametypes\_rank::awardGameEvent( "assist_killstreak_destroyed", previousAttacker );
	}
}

checkStreakingEvents( victim )
{
	currentKillStreak = self.killstreakcount + 1;
	
	// track multiples of 5s and all kills after 30
	if( (currentKillStreak % 5) && (currentKillStreak < 30) )
		return;
	
	switch( currentKillStreak )
	{
		case 5:
			level thread maps\mp\gametypes\_rank::awardGameEvent( "5killstreak", self );
			self incPlayerStat( "5killstreak", 1 );
			self maps\mp\gametypes\_missions::processChallenge( "ch_killer_blood");
			if( IsDefined( self.challengeData["ch_limited_bloodshed"] ) && ( self.challengeData["ch_limited_bloodshed"] == 1 ) )
				self maps\mp\gametypes\_missions::processChallenge( "ch_limited_bloodshed", 5 );
			break;
		case 10:
			level thread maps\mp\gametypes\_rank::awardGameEvent( "10killstreak", self );
			self incPlayerStat( "10killstreak", 1 );
			self maps\mp\gametypes\_missions::processChallenge( "ch_killer_merciless");
			self maps\mp\gametypes\_missions::processChallenge( "ch_" + level.gametype +"_merciless" );
			if( IsDefined( self.challengeData["ch_limited_bloodshed"] ) && ( self.challengeData["ch_limited_bloodshed"] == 2 ) )
				self maps\mp\gametypes\_missions::processChallenge( "ch_limited_bloodshed", 5 );
			if( self.loadoutOffhand == "specialty_null" && self.loadoutEquipment == "specialty_null" )
				self maps\mp\gametypes\_missions::processChallenge( "ch_precision_wetwork" );
			break;
		case 15:
			level thread maps\mp\gametypes\_rank::awardGameEvent( "15killstreak", self );
			self incPlayerStat( "15killstreak", 1 );
			self maps\mp\gametypes\_missions::processChallenge( "ch_killer_ruthless");
			if( IsDefined( self.challengeData["ch_limited_bloodshed"] ) && ( self.challengeData["ch_limited_bloodshed"] == 3 ) )
				self maps\mp\gametypes\_missions::processChallenge( "ch_limited_bloodshed", 5 );
			break;
		case 20:
			level thread maps\mp\gametypes\_rank::awardGameEvent( "20killstreak", self );
			self incPlayerStat( "20killstreak", 1 );
			self maps\mp\gametypes\_missions::processChallenge( "ch_killer_relentless");
			if( IsDefined( self.challengeData["ch_limited_bloodshed"] ) && ( self.challengeData["ch_limited_bloodshed"] == 4 ) )
				self maps\mp\gametypes\_missions::processChallenge( "ch_limited_bloodshed", 5 );
			break;
		case 25:
			level thread maps\mp\gametypes\_rank::awardGameEvent( "25killstreak", self );
			self incPlayerStat( "25killstreak", 1 );
			self maps\mp\gametypes\_missions::processChallenge( "ch_killer_brutal");
			if( IsDefined( self.challengeData["ch_limited_bloodshed"] ) && ( self.challengeData["ch_limited_bloodshed"] == 5 ) )
				self maps\mp\gametypes\_missions::processChallenge( "ch_limited_bloodshed", 5 );
			break;
		case 30:
			level thread maps\mp\gametypes\_rank::awardGameEvent( "30killstreak", self );
			self incPlayerStat( "30killstreak", 1 );
			if( IsDefined( self.challengeData["ch_limited_bloodshed"] ) && ( self.challengeData["ch_limited_bloodshed"] == 6 ) )
				self maps\mp\gametypes\_missions::processChallenge( "ch_limited_bloodshed", 5 );
			break;
		default:
			level thread maps\mp\gametypes\_rank::awardGameEvent( "30pluskillstreak", self );
			self incPlayerStat( "30pluskillstreak", 1 );
			break;
	}
	
	self thread teamPlayerCardSplash( "callout_kill_streaking", self, undefined, currentKillStreak );
}

checkHigherRankKillEvents( victim )
{
	// only do this once the match has gone for a little while
	if( getTimePassed() < ( 60 * 1.5 ) * 1000 ) 
		return;
	
	enemyList = level.players;
	
	if( level.teamBased )
		enemyList = level.teamList[ getOtherTeam( self.team ) ];
	
	if( enemyList.size < 3 )
		return;

	enemiesSortedByRank = array_sort_with_func( enemyList, ::is_score_a_greater_than_b );
	
	if( IsDefined(enemiesSortedByRank[0]) && (victim == enemiesSortedByRank[0]) )
	{
		self incPlayerStat( "firstplacekill", 1 );
		level thread maps\mp\gametypes\_rank::awardGameEvent( "firstplacekill", self );
		self maps\mp\gametypes\_missions::processChallenge( "ch_precision_highvalue" );
	}
}
	
	
is_score_a_greater_than_b( a, b )
{
	return ( a.score > b.score );
}


processAssistEvent( killedplayer, xpEventOverride )
{
	if( IsDefined(level.assists_disabled) && level.assists_disabled )
		return;
		
	xpevent = "assist";
	
	if( IsDefined(xpEventOverride) )
		xpevent = xpEventOverride;
	
	self endon("disconnect");
	killedplayer endon("disconnect");
	
	// don't ever run on the same frame as the playerkilled callback.
	wait(0.05);
	
	if( (self.team != "axis") && (self.team != "allies") )
		return;
	
	if( self.team == killedplayer.team )
		return;
	
	level thread maps\mp\gametypes\_rank::awardGameEvent( xpevent, self, undefined, killedplayer );	
	
	killedplayer maps\mp\_matchdata::logSpecialAssists( self, xpevent );

	// only increment assist stats for normal assists
	if( (xpevent == "assist") || (xpevent == "assist_riot_shield") )
	{
		self incPlayerStat( "assists", 1 );
		self incPersStat( "assists", 1 );
		self.assists = self getPersStat( "assists" );
		
		if( xpevent == "assist_riot_shield" )
			self incPlayerStat( "assist_riot_shield", 1 );
		
		self maps\mp\gametypes\_persistence::statSetChild( "round", "assists", self.assists );
		self thread maps\mp\gametypes\_missions::playerAssist();
		
		if ( level.practiceRound )
			self thread practiceRoundAssistEvent( killedplayer );
	}
}

killAfterDodgeEvent( weapon )
{
	self maps\mp\gametypes\_missions::processChallenge( "ch_exomech_evasive" );
	
	// some more camo stuff
	if( IsDefined( weapon) )
	{
		baseWeapon = getBaseWeaponName( weapon );
		if( isLootWeapon( baseWeapon ) )
			baseWeapon = maps\mp\gametypes\_class::getBaseFromLootVersion( baseWeapon );
	
		weaponClass = self maps\mp\gametypes\_missions::get_challenge_weapon_class( weapon, baseWeapon );
		
		if( WeaponClass == "weapon_assault" || WeaponClass == "weapon_pistol" )
		{
			if( IsSubStr( baseWeapon, "dlcgun" ) && weaponClass == "weapon_assault" )
				self maps\mp\gametypes\_missions::processChallenge( "ch_tier2_3_" + baseWeapon );
			else
				self maps\mp\gametypes\_missions::processChallenge( "ch_dodge_" + baseWeapon );
		}
	}
}
camoSprintSlideKillEvent( weapon, meansOfDeath )
{
	// only smg, shotgun, pistol, 
	baseWeapon = getBaseWeaponName( weapon );
	if( isLootWeapon( baseWeapon ) )
	{
		baseWeapon = maps\mp\gametypes\_class::getBaseFromLootVersion( baseWeapon );
	}
	weaponClass = self maps\mp\gametypes\_missions::get_challenge_weapon_class(weapon, baseWeapon);
	switch( weaponClass )
	{
		case "weapon_smg":
		case "weapon_shotgun":
		case "weapon_pistol":
			if(IsDefined( level.challengeInfo[ "ch_slide_" + baseWeapon ] ))
				self maps\mp\gametypes\_missions::processChallenge( "ch_slide_" + baseWeapon );
			break;
	}
}