#include common_scripts\utility;
#include maps\mp\_utility;
#include maps\mp\agents\_agent_utility;
#include maps\mp\alien\_utility;
#include maps\mp\alien\_perk_utility;

//=======================================================
//		Player persistent data script
//=======================================================

CURRENCY_START = 500;
CURRENCY_UPGRADE_START = 1500;
CURRENCY_MAX = 6000;
POINTS_MAX = 255;
MAX_PRESTIGE = 25;
FREE_SKILL_POINTS = 1; // given at start after having purchased this with tokens
CHAOS_START_SKILL_POINTS = 50; // enough skill points for player to upgrade to max skill level via bonus packages
/*

> Player XP & Rank & Prestige
> Player Unlocks ( title cards, perks, dpad abilities )
> Player Loadout setup
> Player Options/Settings
> Player Combat Stats ( career stats and scoring )
> Player Leaderboard data
> Player Permanent Items

*/

// sets game state for: join in progress rules, leaderboard rules, etc...
set_game_state( state )
{
	allowed_states 	= [ "pregame", "prehive", "progressing", "escaping", "ended" ]; // matches enums in playerdata.def
	state_allowed 	= array_contains( allowed_states, state );
	
	assertex( state_allowed, "State: " + state + " is not allowed" );
	
	self SetCoopPlayerData( "alienSession", "game_state", state );
}

//=======================================================
// 							PERKS
//=======================================================

// get player selected perks
get_selected_perk_0()
{ 
	if( is_chaos_mode() )
	{
		return "perk_none";
	}
	return self getcoopplayerdata( "alienPlayerLoadout", "perks", 0 );
}
get_selected_perk_0_secondary()
{
	//secondary class options inheret their level from selected perk 0;
	secondaryClass = "perk_none";

	if ( self is_upgrade_enabled( "multi_class" ) && !is_chaos_mode( ))
	{
		secondaryClassIndex = self GetCoopPlayerDataReservedInt( "secondary_class" );
		keys = getArrayKeys( level.alien_perks["perk_0"] );
		foreach( key in keys  )
		{
			if ( level.alien_perks["perk_0"][key].baseIdx == secondaryClassIndex )
			{
				secondaryClass = key;
			}
		}
	}
	return secondaryClass;
}
get_selected_perk_1() 	{ return self getcoopplayerdata( "alienPlayerLoadout", "perks", 1 ); }

// get current perks, upgraded perks is tracked in alienSession perks[]
get_perk_0_level() 		{ return self getcoopplayerdata( "alienSession", "perk_0_level" ); }
get_perk_1_level() 		{ return self getcoopplayerdata( "alienSession", "perk_1_level" ); }

// set current perk upgrade
set_perk_0_level( upgrade_level ) { self setcoopplayerdata( "alienSession", "perk_0_level", upgrade_level ); }
set_perk_1_level( upgrade_level ) { self setcoopplayerdata( "alienSession", "perk_1_level", upgrade_level ); }

set_perk( perk_ref )   { self [[level.alien_perk_callbacks[perk_ref].Set]](); }
unset_perk( perk_ref ) { self [[level.alien_perk_callbacks[perk_ref].unSet]](); }

// initialize the current perk upgrade level, 0
init_perk_level()
{
	self set_perk_0_level( 0 );
	self set_perk_1_level( 0 );
}

give_initial_perks()
{
	self set_perk( self get_selected_perk_0() );
	self set_perk( self get_selected_perk_1() );  //<NOTE J.C.> Delete if we decide to remove Perk 1
	
	if( self is_upgrade_enabled( "multi_class" ))
	{
		self set_perk( self get_selected_perk_0_secondary() );
	}
}

//=======================================================
// 						COMBAT RESOURCES
//=======================================================

// get player selected dpad combat resources
get_selected_dpad_up() 		{ return self getcoopplayerdata( "alienPlayerLoadout", "munition" ); }
get_selected_dpad_down()	{ return self getcoopplayerdata( "alienPlayerLoadout", "support" ); }

get_selected_dpad_left()
{
	defense = self getcoopplayerdata( "alienPlayerLoadout", "defense" );
	if ( defense == "dpad_placeholder_def_1" && maps\mp\alien\_utility::is_chaos_mode() )
		return "dpad_minigun_turret";
	else
		return defense;
}
	
get_selected_dpad_right()
{
	offense = self getcoopplayerdata( "alienPlayerLoadout", "offense" );
	if ( offense == "dpad_placeholder_off_1" && maps\mp\alien\_utility::is_chaos_mode() )
		return "dpad_ims";
	else
		return offense;
}	

// get current combat resources, upgraded resources is tracked in alienSession...
get_dpad_up_level() 	{ return self getcoopplayerdata( "alienSession", "munition_level" ); }
get_dpad_down_level()	{ return self getcoopplayerdata( "alienSession", "support_level" ); }
get_dpad_left_level()	{ return self getcoopplayerdata( "alienSession", "defense_level" ); }
get_dpad_right_level()	{ return self getcoopplayerdata( "alienSession", "offense_level" ); }

get_upgrade_level( type )					{ return self getcoopplayerdata( "alienSession", type + "_level" ); }
set_upgrade_level( type, upgrade_level )	
{ 
	self setcoopplayerdata( "alienSession", type + "_level", upgrade_level ); 
	
	// EoG tracking: update everyone's loadout upgrade level, used by in-game UI to see teammate's info
	loadout_ref = "LoadoutPlayer" + ( self GetEntityNumber() );
	setcoopplayerdata_for_everyone( loadout_ref, type + "_level", upgrade_level );
}

// set current combat resource upgrades
set_dpad_up_level( upgrade_level ) 		{ self setcoopplayerdata( "alienSession", "munition_level", upgrade_level ); }
set_dpad_down_level( upgrade_level )	{ self setcoopplayerdata( "alienSession", "support_level", upgrade_level ); }
set_dpad_left_level( upgrade_level )	{ self setcoopplayerdata( "alienSession", "defense_level", upgrade_level ); }
set_dpad_right_level( upgrade_level )	{ self setcoopplayerdata( "alienSession", "offense_level", upgrade_level ); }

// initialize the current combat resource upgrade level, 0
init_combat_resource_level()
{
	self set_dpad_up_level( 0 );
	self set_dpad_down_level( 0 );
	self set_dpad_left_level( 0 );
	self set_dpad_right_level( 0 );
}

//=======================================================
// 						CURRENCY
//=======================================================

get_player_currency()			{ return self getcoopplayerdata( "alienSession", "currency" ); }
get_player_max_currency()		{ return self.maxCurrency; }

wait_to_set_player_currency( amount )
{
	self endon( "disconnect" );
	level endon( "game_ended" );
	
	wait( 0.5 );  	// wait because level.players array may not yet be populated at this point
	if ( self is_upgrade_enabled( "more_cash_upgrade" ) )
		set_player_currency( CURRENCY_UPGRADE_START );
	else
		set_player_currency( amount );
}

set_player_currency( amount )	
{
	self setcoopplayerdata( "alienSession", "currency", int( amount ) );
	
	// EoG tracking: currency
	self eog_player_update_stat( "currency", int( amount ), true );
}

get_player_points()				{ return self getcoopplayerdata( "alienSession", "skill_points" ); }
set_player_points( amount )		{ self setcoopplayerdata( "alienSession", "skill_points", int( amount ) ); }

set_player_max_currency( amount )
{
	amount = int( amount );
	self SetClientOmnvar( "ui_alien_max_currency", amount );
	self.maxCurrency = amount;
}

give_player_currency( amount, font_size, sHitloc, skip_prestige_scalar )
{
	assert( amount >= 0 );

	if ( !is_true( skip_prestige_scalar ) )
	{
		amount = int( amount * self maps\mp\alien\_prestige::prestige_getMoneyEarnedScalar() );
		amount = maps\mp\alien\_gamescore::round_up_to_nearest( amount, 5 );
	}
	
	if ( is_chaos_mode() && is_true( self.chaosinthemoney ) )
	{
		amount = int( amount * 1.5 );
		amount = maps\mp\alien\_gamescore::round_up_to_nearest( amount, 5 );
	}
	
	current_amount = self get_player_currency();
	max_amount = self get_player_max_currency();
	new_amount = current_amount + amount;
	new_amount =  min( new_amount, max_amount );
	
	if ( !isdefined( self.total_currency_earned ) )
		self.total_currency_earned = amount;
	else
		self.total_currency_earned += ( new_amount - current_amount );
	
	// EoG tracking: currency
	self eog_player_update_stat( "currencytotal", int( self.total_currency_earned ), true );
	
	self notify( "loot_pickup" );

	self set_player_currency( new_amount );
	
	//show the player a hint if he's max'd out his cash
	MAX_CASH_COOL_DOWN_TIME = 30000;  //30 seconds
	current_time = getTime();
	
	if ( current_amount == max_amount )
		self setclientomnvar( "ui_alien_cash_overflow", true );	
	
	if ( new_amount >= max_amount )
	{
		if ( !isDefined( self.next_maxmoney_hint_time ) )
		{
			self.next_maxmoney_hint_time = current_time +  MAX_CASH_COOL_DOWN_TIME;
		}
		else if ( current_time < self.next_maxmoney_hint_time )
		{
			 return;
		}
		if ( !level.gameEnded )
		{
			self maps\mp\_utility::setLowerMessage( "maxmoney", &"ALIEN_COLLECTIBLES_MONEY_MAX", 4 );
			self.next_maxmoney_hint_time = current_time +  MAX_CASH_COOL_DOWN_TIME;
		}
	}
}

take_player_currency( amount, dont_update_challenge, spending_type, weapon_ref ) 
{
	assert( amount >= 0 );
	current_amount = self get_player_currency();
	new_amount = max( 0, current_amount - amount );
	amount_spent = int( current_amount - new_amount );

	maps\mp\alien\_chaos::update_spending_currency_event( self, spending_type, weapon_ref );
	
	self notify( "loot_removed" );
	
	self set_player_currency( new_amount );
	
	if ( isDefined ( spending_type ) )
		maps\mp\alien\_alien_matchdata::update_spending_type( amount_spent, spending_type );
	
	if ( isDefined ( dont_update_challenge ) && dont_update_challenge )
		return;
	
	self eog_player_update_stat( "currencyspent", amount_spent );
	
	//don't fail challenges if the player spends 0 dollars
	if ( amount_spent < 1 )
		return;
	
	maps\mp\alien\_challenge::update_challenge ( "spend_10k", amount );
	maps\mp\alien\_challenge::update_challenge ( "spend_20k", amount );
	maps\mp\alien\_challenge::update_challenge ( "spend_no_money" );

}

take_all_currency()
{
	self set_player_currency( 0 );
}

player_has_enough_currency( amount ) 
{
	assert( amount >= 0 );
	currency = self get_player_currency();
	return (currency >= amount);
}

try_take_player_currency( amount )
{
	if ( self player_has_enough_currency( amount ) )
	{
		self take_player_currency( amount );
		return true;
	}
	else
	{
		return false;
	}
}

give_player_points( amount )
{
	assert( amount >= 0 );
	current_amount = self get_player_points();
	new_amount = current_amount + amount;
	new_amount = min( new_amount, POINTS_MAX );
	
	self set_player_points( new_amount );
}

take_player_points( amount )
{
	assert( amount >= 0 );
	current_amount = self get_player_points();
	new_amount = max( 0, current_amount - amount );

	self notify( "points_removed" );
	
	self set_player_points( new_amount );
}

player_has_enough_points( amount ) 
{
	assert( amount >= 0 );
	points = self get_player_points();
	return (points >= amount);
}

try_take_player_points( amount )
{
	if ( self player_has_enough_points( amount ) )
	{
		self take_player_points( amount );
		return true;
	}
	else
	{
		return false;
	}
}

// check against rank for unlock
is_unlocked( item_ref )
{
	item_type 			= undefined;
	item_type 			= strtok( item_ref, "_" )[ 0 ];  	// currently only "perk" or "dpad"
	
	item_unlock_rank 	= level.combat_resource[ item_ref ].unlock;
	player_rank 		= self get_player_rank();
	
	return player_rank >= item_unlock_rank;
	// return int( self getplayerdata( "unlock", item_ref ) );
}

player_persistence_init()
{
	// enable xp
	level.alien_xp = true;
	
	// inits with playerdata
	self init_combat_resource_level();
	self init_perk_level();
	
	self init_each_perk();
	self give_initial_perks();

	// initial values for session data
	starting_currency = get_starting_currency();
	self thread wait_to_set_player_currency( starting_currency );
	self set_player_max_currency( CURRENCY_MAX * maps\mp\alien\_prestige::prestige_getWalletSizeScalar() );
	
	starting_skill_point = get_starting_skill_point();
	self set_player_points( starting_skill_point );
	self set_player_session_xp( 0 );
	self set_player_session_rankup( 0 );

	// let's tell the game to send this info to everybody else
	self SetRank( self get_player_rank(), self get_player_prestige() );
	
	self session_stats_init();
	
	num_nerf_selected = maps\mp\alien\_prestige::get_num_nerf_selected();
	self LB_player_update_stat( "prestigenerfs", num_nerf_selected, true );
	
	self thread update_loadout_for_everyone();
	
	// init HUD - XP
	//if ( isdefined( level.alien_xp ) && level.alien_xp )
	//	self maps\mp\alien\_hud::init_player_xp_display();
}

get_starting_currency()
{
/#
	if ( isDefined( level.debug_starting_currency ) )
		return level.debug_starting_currency;
#/
	return CURRENCY_START;
}

get_starting_skill_point()
{
/#
	if ( isDefined( level.debug_starting_skill_point ) )
		return level.debug_starting_skill_point;
#/
	if ( is_chaos_mode() )
		return CHAOS_START_SKILL_POINTS;
		
	if ( self is_upgrade_enabled( "free_skill_points_upgrade" ) )
		return FREE_SKILL_POINTS;	
	 else
	 	return 0;
}

update_loadout_for_everyone()
{
	// self is connecting player
	
	// if called twice within a short time (delays within this function), last call takes effect
	level notify( "updating_player_loadout_data" );
	level endon( "updating_player_loadout_data" );

	if ( !isdefined( level.players ) || level.players.size == 0 )
		wait 0.5; 
	
	wait 1; // padding for all players to be connected on start of game

	foreach ( p in level.players )
	{
		loadout_ref = "LoadoutPlayer" + ( p GetEntityNumber() );
		
		perk_0 				= p get_selected_perk_0(); 		// "perks", 0
		perk_1 				= p get_selected_perk_1(); 		// "perks", 1
		dpad_up 			= p get_selected_dpad_up(); 	// "munition"
		dpad_down 			= p get_selected_dpad_down(); 	// "support"
		dpad_left 			= p get_selected_dpad_left(); 	// "defense"
		dpad_right 			= p get_selected_dpad_right();	// "offense"
		
		// upgrade levels - initialize, will be updated later as well
		perk_0_level		= p get_perk_0_level();			// "perk_0_level"
		perk_1_level		= p get_perk_1_level();			// "perk_1_level"
		dpad_up_level		= p get_dpad_up_level(); 		// "munition_level"
		dpad_down_level		= p get_dpad_down_level(); 		// "support_level"
		dpad_left_level		= p get_dpad_left_level(); 		// "defense_level"
		dpad_right_level	= p get_dpad_right_level();		// "offense_level"
		
		// update everyone, everyone's loadout
		foreach ( player in level.players )
		{
			player setcoopplayerdata( loadout_ref, "perks", 			0, perk_0 );
			player setcoopplayerdata( loadout_ref, "perks", 			1, perk_1 );
			player setcoopplayerdata( loadout_ref, "munition", 			dpad_up );
			player setcoopplayerdata( loadout_ref, "support", 			dpad_down );	
			player setcoopplayerdata( loadout_ref, "defense", 			dpad_left );
			player setcoopplayerdata( loadout_ref, "offense", 			dpad_right );
			player setcoopplayerdata( loadout_ref, "perk_0_level", 		perk_0_level );
			player setcoopplayerdata( loadout_ref, "perk_1_level", 		perk_1_level );
			player setcoopplayerdata( loadout_ref, "munition_level", 	dpad_up_level );
			player setcoopplayerdata( loadout_ref, "support_level", 	dpad_down_level );
			player setcoopplayerdata( loadout_ref, "defense_level", 	dpad_left_level );
			player setcoopplayerdata( loadout_ref, "offense_level", 	dpad_right_level );
		}
		
		if ( !isdefined( p.bbprint_loadout ) )
		{
			p.bbprint_loadout = true; // print once
			
			// ============== BBPrint for player loadout (self) ===============
			// self is player on connect
			
			playername 		= "";
			if ( isdefined( self.name ) )
				playername 	= self.name;
			
			playerrank 		= self get_player_rank();
			playerxp 		= self get_player_xp();
			playerprestige 	= self get_player_prestige();
			playerescaped 	= self get_player_escaped();
			connecttime 	= gettime();
			
			cyclenum 		= 0;
			if ( isdefined( level.current_cycle_num ) )
				cyclenum 	= level.current_cycle_num;
			
			/#
			if ( GetDvarInt( "alien_bbprint_debug" ) > 0 )
			{
				IPrintLnBold( "^8bbprint: alienplayerloadout (1/2)\n" +
							 " playername=" + playername +
							 " playerrank=" + playerrank +
							 " playerxp=" + playerxp +
							 " playerprestige=" + playerprestige +
							 " playerescaped=" + playerescaped +
							 " connecttime=" + connecttime +
							 " cyclenum=" + cyclenum );
				
				IPrintLnBold( "^8bbprint: alienplayerloadout (2/2)\n" +
							 " perk0=" + perk_0 +
							 " perk1=" + perk_1 +
							 " dpadup=" + dpad_up +
							 " dpaddown=" + dpad_down +
							 " dpadleft=" + dpad_left +
							 " dpadright=" + dpad_right );
			}
			#/
			
			bbprint( "alienplayerloadout",
			    "playername %s playerrank %i playerxp %i playerprestige %i playerescaped %i connecttime %i cyclenum %i perk0 %s perk1 %s dpadup %s dpaddown %s dpadleft %s dpadright %s ", 
			    playername,
			    playerrank,
			    playerxp,
			    playerprestige,
			    playerescaped,
			    connecttime,
				cyclenum,
				perk_0,
				perk_1,
				dpad_up,
				dpad_down,
				dpad_left,
			    dpad_right );
		}
	}	
}


setcoopplayerdata_for_everyone( param0, param1, param2, param3, param4 )
{
	assertex( level.players.size > 0, "setting player data when level.players array is not yet populated" );
	
	foreach ( player in level.players )
	{
		if ( isdefined( param0 ) && isdefined( param1 ) && isdefined( param2 ) && isdefined( param3 ) && isdefined( param4 ) )
		{
			player setcoopplayerdata( param0, param1, param2, param3, param4 );
			continue;
		}

		if ( isdefined( param0 ) && isdefined( param1 ) && isdefined( param2 ) && isdefined( param3 ) && !isdefined( param4 ) )
		{
			player setcoopplayerdata( param0, param1, param2, param3 );
			continue;
		}
		
		if ( isdefined( param0 ) && isdefined( param1 ) && isdefined( param2 ) && !isdefined( param3 ) && !isdefined( param4 ) )
		{
			player setcoopplayerdata( param0, param1, param2 );
			continue;
		}
		
		if ( isdefined( param0 ) && isdefined( param1 ) && !isdefined( param2 ) && !isdefined( param3 ) && !isdefined( param4 ) )
		{
			player setcoopplayerdata( param0, param1 );
			continue;
		}
	}
}

//=======================================================
// 		TOKENS ( TEETH ) - Currency spent in the front end
//=======================================================

//we have space for 28 independent bonus awards, these are setup to be awarded by calling wait_then_try_give_one_shot_token_bonus
//from spawn player in ffotd.  Since a bonus is only awarded once make sure we are keeping track of which bonus we have given out so far.
//NEXT BONUS IS BONUS 0
get_token_bonus_flag( bonusNum )
{
	flagNum = 4;
	if( bonusNum < 28 )
		flagNum += bonusNum;

	return flagNum;
}

is_valid_bonus_flag( flag )
{
	//available flags are the bits of reserve data 'eggstra_award_flags' ( bits 0-3 are used elsewhere )
	return ( flag >= 4 && flag < 32 );
}

wait_then_try_give_one_shot_token_bonus( bonusFlag, numTokens )
{
	self endon( "disconnect" );
	level endon( "game_ended" );

	if( !is_valid_bonus_flag( bonusFlag ))
		return;

	//wait until the first hive is killed to give any awards.
	level waittill ( "regular_hive_destroyed" );

	try_give_one_shot_token_bonus( bonusFlag, numTokens );
}

try_give_one_shot_token_bonus( bonusFlag, numTokens )
{
	if ( !is_using_extinction_tokens( ) )
		return;

	if ( !level.onlineGame )
		return;

	if( !is_valid_bonus_flag( bonusFlag ))
		return;

	eggstra_award_flags = self GetCoopPlayerDataReservedInt( "eggstra_award_flags" );
	value = ( eggstra_award_flags >> bonusFlag ) & 1;

	//if the bit is already flagged then we have already awarded the bonus and we dont want to award it again.
	if ( value == 1 )
		return;

	//mark the flag so we know we have awarded the bonus in the future.
	eggstra_award_flags |= ( 1 << bonusFlag );
	self SetCoopPlayerDataReservedInt( "eggstra_award_flags", eggstra_award_flags );

	give_player_tokens( numTokens, true );
}

is_using_extinction_tokens()
{
	if ( GetDvarInt( "extinction_tokens_enabled" ) > 0 )
	{
		return true;
	}

	return false;
}

give_player_tokens( numTokens, showSplash )
{
	//if the feature is not enabled return false
	if ( !is_using_extinction_tokens( ) )
	{
		return;
	}

	if ( is_true( showSplash ) )
	{
		self setclientomnvar ( "ui_alien_award_token", numTokens );  // display award notification via LUA
	}
	
	currTokens = self GetCoopPlayerDataReservedInt( "extinction_tokens" );
	self SetCoopPlayerDataReservedInt( "extinction_tokens", currTokens + numTokens );
	self give_player_session_tokens( numTokens );
}


try_award_bonus_pool_token()
{
	//if the feature is not enabled we dont want to read from bonus_pool_size
	if ( !is_using_extinction_tokens( ) )
		return;

	//bonus pool rewards only apply to online games ( offline games cannot manage a reliable week timeout )
	if ( !level.onlineGame )
		return;

	//players are limited to one bonus pool tooth per game
	if( isDefined( self.pers["hasEarnedBonusToken"] ))
		return;

	self.pers["hasEarnedBonusToken"] = true;

	numInBonusPool = self GetCoopPlayerDataReservedInt( "bonus_pool_size" );
	if ( numInBonusPool > 0 )
	{
		self SetCoopPlayerDataReservedInt( "bonus_pool_size", numInBonusPool - 1 );
		give_player_tokens( 1, true );
	}
}

award_rank_up_tokens( oldRank )
{
	prestigeLevel = self get_player_prestige();
	if ( oldRank < level.alien_ranks.size && prestigeLevel == 0 )
	{
		numAwarded = level.alien_ranks[ oldRank ].tokenReward;
		if ( numAwarded > 0 )
		{
			give_player_tokens( numAwarded, true );
		}
	}
}

award_completion_tokens()
{
	if ( is_casual_mode() )
		return;
	
	//self is the player being awarded tokens

	//standard completion bonus is 3 token scaled with xp bonus weekends
	numAwarded = get_scaled_xp( 5 );

	//bonus tooth for completion in hardcore mode
	if( is_hardcore_mode( ) )
	{
		numAwarded = numAwarded + 3;
		/#
		if ( getDvar( "alien_debug_eog" ) == "1" )
			iprintln( "Hardcore Bonus Token Awarded!" );
		#/
	}

	//4 for getting completionist
	if ( level.all_challenge_completed )
	{
		numAwarded = numAwarded + 4;
	}

	//bonus token for finishing with any active relics.
	num_active_relics = self maps\mp\alien\_prestige::get_num_nerf_selected();
	if ( num_active_relics > 0 && !is_true( self.pers["hotjoined"] ))
	{
		if ( num_active_relics == 1 )
			numAwarded = numAwarded + 1;
		else if ( num_active_relics == 2 )
			numAwarded = numAwarded + 2;
		else if ( num_active_relics >= 3 )
			numAwarded = numAwarded + 3;
		/#
		if ( getDvar( "alien_debug_eog" ) == "1" )
			iprintln( "Active Relics Bonus Token Awarded!" );
		#/
	}

	//An sssist bonus is awarded when a player with previous escapes helps a new guy escape for the first time.
	if( 1 < self get_player_escaped() )
	{
		foreach ( player in level.players )
		{
			if ( player != self && 1 == player get_player_escaped() )
			{
				numAwarded++;
				/#
				if ( getDvar( "alien_debug_eog" ) == "1" )
					iprintln( "New Player Assist Bonus Token Awarded!" );
				#/
			}
		}
	}

	give_player_tokens( numAwarded );
}

is_upgrade_enabled( itemRef )
{
	if ( is_chaos_mode() )
	{
		return false;
	}
	
	//if the feature is not enabled return false
	if ( !is_using_extinction_tokens( ) )
	{
		return false;
	}

	/#
	// Forces all purchasables to enabled
	if ( GetDvarInt( "EnableExtinctionPurchasables" ) )
	{
		return true;
	}

	// Forces all purchasables to disabled
	if ( GetDvarInt( "DisableExtinctionPurchasables" ) )
	{
		return false;
	}
	#/

	if ( self alienscheckisupgradeenabled( itemRef ))
	{
		return true;
	}
	else
	{
		return false;
	}
}

is_upgrade_purchased( itemRef )
{
	//if the feature is not enabled return false
	if ( !is_using_extinction_tokens( ) )
	{
		return false;
	}

	if ( self alienscheckisitempurchased( itemRef ))
	{
		return true;
	}
	else
	{
		return false;
	}
}


//=======================================================
// 						CAREER STATS
//=======================================================

session_stats_init()
{
	// store team total stats on playerdata on each player
	self SetCoopPlayerData( "alienSession", "team_shots", 0 );
	self SetCoopPlayerData( "alienSession", "team_kills", 0 );
	self SetCoopPlayerData( "alienSession", "team_hives", 0 );
	self SetCoopPlayerData( "alienSession", "downed", 0 );
	self SetCoopPlayerData( "alienSession", "hivesDestroyed", 0 );
	self SetCoopPlayerData( "alienSession", "prestigenerfs", 0 );
	self SetCoopPlayerData( "alienSession", "repairs", 0 );
	self SetCoopPlayerData( "alienSession", "drillPlants", 0 );
	self SetCoopPlayerData( "alienSession", "deployables", 0 );
	self SetCoopPlayerData( "alienSession", "challengesCompleted", 0 );
	self SetCoopPlayerData( "alienSession", "challengesAttempted", 0 );
	self SetCoopPlayerData( "alienSession", "trapKills", 0 );
	self SetCoopPlayerData( "alienSession", "currencyTotal", 0 );
	self SetCoopPlayerData( "alienSession", "currencySpent", 0 );	
	self SetCoopPlayerData( "alienSession", "escapedRank0", 0 );
	self SetCoopPlayerData( "alienSession", "escapedRank1", 0 );
	self SetCoopPlayerData( "alienSession", "escapedRank2", 0 );
	self SetCoopPlayerData( "alienSession", "escapedRank3", 0 );
	self SetCoopPlayerData( "alienSession", "kills", 0 );
	self SetCoopPlayerData( "alienSession", "revives", 0 );
	self SetCoopPlayerData( "alienSession", "time", 0 );
	self SetCoopPlayerData( "alienSession", "score", 0 );
	self SetCoopPlayerData( "alienSession", "shots", 0 );		//Used to track tokens awarded
	self SetCoopPlayerData( "alienSession", "last_stand_count", 0 );
	
	// "deaths", "headShots", "hits" and "shots" are not used by the game mode.  Init them here so each level can use them for
	// level-specific purpose
	self SetCoopPlayerData( "alienSession", "deaths", 0 );
	self SetCoopPlayerData( "alienSession", "headShots", 0 );
	self SetCoopPlayerData( "alienSession", "hits", 0 );
	
	self thread weapons_tracking_init();
	self thread resource_tracking_init();
	
	self thread eog_player_tracking_init();
}

// ============== tracking end of game stats ================

eog_player_tracking_init()
{
	// self is connecting player
	
	// wait till level.players are populated on game start
	wait 0.5;
	
	// "available stats: eog_player_0, eog_player_1, eog_player_2, eog_player_3"
	
	// ============ write connecting player's initial values into everyone's playerdata ============
	player_ref = self get_player_ref();
	foreach ( player in level.players )
	{
		/#
			if ( getDvar( "alien_debug_eog" ) == "1" )
				iprintln( "^6[EOG STAT] " + player_ref + " updated for " + " player_" + player GetEntityNumber() );
		#/
		
		// reset data
		player reset_EoG_stats( player_ref );
		
		// init name
		player_name = "unknownPlayer";
		if ( isdefined( self.name ) )
			player_name = self.name;

		if ( !level.console )
		{
			player_name = GetSubStr( player_name, 0, 19 );
		}
		else
		{
			if ( have_clan_tag( player_name ) )
				player_name = remove_clan_tag( player_name );
		}
	
		
		player setcoopplayerdata( player_ref, "name", player_name );
	}
	
	// a barrier between script's level.players indexing and getEntityNumber() index
	players_eog_updated = [ false, false, false, false ]; // player entity numbers: 0, 1, 2, 3
	
	// connecting player grabs other in-game player's EoG stats
	foreach ( p in level.players )
	{
		players_eog_updated[ int( p GetEntityNumber() ) ] = true;
		
		// skip self
		if ( p == self )
			continue;
		
		player_ref = p get_player_ref();
		
		/#
			if ( getDvar( "alien_debug_eog" ) == "1" )
				iprintln( "^6[EOG STAT] player_" + self GetEntityNumber() + " grabbed " + player_ref );
		#/
		
		name 			= p getcoopplayerdata( player_ref, "name" );
		kills 			= p getcoopplayerdata( player_ref, "kills" );
		score 			= p getcoopplayerdata( player_ref, "score" );
		assists			= p getcoopplayerdata( player_ref, "assists" );
		revives			= p getcoopplayerdata( player_ref, "revives" );
		drillrestarts	= p getcoopplayerdata( player_ref, "drillrestarts" );
		drillplants		= p getcoopplayerdata( player_ref, "drillplants" );
		downs			= p getcoopplayerdata( player_ref, "downs" );
		deaths			= p getcoopplayerdata( player_ref, "deaths" );
		hivesdestroyed	= p getcoopplayerdata( player_ref, "hivesdestroyed" );
		currency		= p getcoopplayerdata( player_ref, "currency" );
		currencyspent	= p getcoopplayerdata( player_ref, "currencyspent" );
		currencytotal	= p getcoopplayerdata( player_ref, "currencytotal" );
		traps			= p getcoopplayerdata( player_ref, "traps" );
		deployables		= p getcoopplayerdata( player_ref, "deployables" );
		deployablesused	= p getcoopplayerdata( player_ref, "deployablesused" );
		
		self setcoopplayerdata( player_ref, "name", 			name );
		self setcoopplayerdata( player_ref, "kills", 			kills );
		self setcoopplayerdata( player_ref, "score", 			score );
		self setcoopplayerdata( player_ref, "assists", 			assists );
		self setcoopplayerdata( player_ref, "revives", 			revives );
		self setcoopplayerdata( player_ref, "drillrestarts", 	drillrestarts );
		self setcoopplayerdata( player_ref, "drillplants", 		drillplants );
		self setcoopplayerdata( player_ref, "downs", 			downs );
		self setcoopplayerdata( player_ref, "deaths", 			deaths );
		self setcoopplayerdata( player_ref, "hivesdestroyed", 	hivesdestroyed );
		self setcoopplayerdata( player_ref, "currency", 		currency );
		self setcoopplayerdata( player_ref, "currencyspent", 	currencyspent );
		self setcoopplayerdata( player_ref, "currencytotal", 	currencytotal );
		self setcoopplayerdata( player_ref, "traps",			traps );
		self setcoopplayerdata( player_ref, "deployables",		deployables );
		self setcoopplayerdata( player_ref, "deployablesused",	deployablesused );
	}
	
	// connecting player erases old EoG stats that current in-game players have not replaced
	foreach ( index, result in players_eog_updated )
	{		
		// reset
		if ( !result )
		{
			/#
				if ( getDvar( "alien_debug_eog" ) == "1" )
					iprintln( "^6[EOG STAT] player_" + self GetEntityNumber() + " reset EoGPlayer" + index );
			#/
			self reset_EoG_stats( "EoGPlayer" + index );
		}
	}
}

reset_EoG_stats( EoGPlayer_ref )
{
	self setcoopplayerdata( EoGPlayer_ref, "name", 				"" );
	self setcoopplayerdata( EoGPlayer_ref, "kills", 			0 );
	self setcoopplayerdata( EoGPlayer_ref, "score", 			0 );
	self setcoopplayerdata( EoGPlayer_ref, "assists", 			0 );
	self setcoopplayerdata( EoGPlayer_ref, "revives", 			0 );
	self setcoopplayerdata( EoGPlayer_ref, "drillrestarts", 	0 );
	self setcoopplayerdata( EoGPlayer_ref, "drillplants", 		0 );
	self setcoopplayerdata( EoGPlayer_ref, "downs", 			0 );
	self setcoopplayerdata( EoGPlayer_ref, "deaths", 			0 );
	self setcoopplayerdata( EoGPlayer_ref, "hivesdestroyed", 	0 );
	self setcoopplayerdata( EoGPlayer_ref, "currency", 			0 );
	self setcoopplayerdata( EoGPlayer_ref, "currencyspent", 	0 );
	self setcoopplayerdata( EoGPlayer_ref, "currencytotal", 	0 );
	self setcoopplayerdata( EoGPlayer_ref, "traps",				0 );
	self setcoopplayerdata( EoGPlayer_ref, "deployables",		0 );
	self setcoopplayerdata( EoGPlayer_ref, "deployablesused",	0 );
}


eog_player_update_stat( stat_ref, amount, override_value )
{
	// self is player
	player_ref = get_player_ref();
	
	new_amount = amount;
	if ( !isdefined( override_value ) || !override_value )
	{
		old_amount = self GetCoopPlayerData( player_ref, stat_ref );
		new_amount = int( old_amount ) + int( amount );
	}
	
	try_update_LB_playerdata( stat_ref, new_amount, true );
	
	setcoopplayerdata_for_everyone( player_ref, stat_ref, new_amount );
}

try_update_LB_playerdata( EoG_ref, new_amount, override_value )
{
	LB_ref = get_mapped_LB_ref_from_EoG_ref( EoG_ref );
	
	if ( !isDefined( LB_ref ) )
		return;
	
	LB_player_update_stat( LB_ref, new_amount, override_value );
}

LB_player_update_stat( alienSession_ref, amount, override_value )
{
	if( is_true( override_value ) )
	{
		new_value = amount;
	}
	else 
	{
		old_value = self GetCoopPlayerData( "alienSession", alienSession_ref );
		new_value = old_value + amount;
	}
	
	self SetCoopPlayerData( "alienSession", alienSession_ref, new_value );
}

// ============== tracking weapon career ================
weapons_tracking_init()
{
	// called after level.collectibles is setup
	assertex( isdefined( level.collectibles ), "level.collectibles not yet setup" );
	
	self.persistence_weaponstats = [];
	foreach ( weapon_ref, item in level.collectibles )
	{
		if ( StrTok( weapon_ref, "_" )[0] == "weapon" )
		{	
			base_weapon = get_base_weapon_name( weapon_ref );
			
			self.persistence_weaponstats[ base_weapon ] = true;
			
			// reset session stat values
			//self thread weaponstats_reset( "weaponStatsSession", base_weapon );
		}
	}
	
	self thread player_weaponstats_track_shots();
}

// removes "weapon_" and removes any string after "_mp"
get_base_weapon_name( weapon_ref )
{
	base_weapon = "";
	
	tokenized = StrTok( weapon_ref, "_" );

	for( i = 0; i < tokenized.size; i++ )
	{
		token = tokenized[ i ];
		
		if ( token == "weapon" && i == 0 )
			continue;
		
		if ( token == "mp" )
		{
			base_weapon += "mp";
			break;
		}
		
		if ( i < tokenized.size - 1 )
		{
			base_weapon += token + "_";
		}
		else
		{
			base_weapon += token;
			break;
		}
	}
	
	if ( base_weapon == "" )
		return "none";
	
	return base_weapon;
}

// resets tracking values to 0
weaponstats_reset( stat_type, weapon_ref )
{
	// hits
	self setcoopplayerdata( stat_type, weapon_ref, "hits", 0 );
	// shots
	self setcoopplayerdata( stat_type, weapon_ref, "shots", 0 );
	// kills
	self setcoopplayerdata( stat_type, weapon_ref, "kills", 0 );
}

// track hits
update_weaponstats_hits( weapon_ref, hits, sMeansOfDeath )
{
/#
	maps\mp\alien\_debug::debug_print_weapon_hits( weapon_ref, sMeansOfDeath );
#/		
	if ( !is_valid_weapon_hit( weapon_ref, sMeansOfDeath ) )
		return;
	
	assertex( isdefined( hits ) && hits >= 0, "value not accepted as hits for weapon stats tracking" );
	
	self update_weaponstats( "weaponStats", 		weapon_ref, "hits", hits );
	//self update_weaponstats( "weaponStatsSession", 	weapon_ref, "hits", hits );
	self maps\mp\alien\_gamescore::update_personal_encounter_performance( maps\mp\alien\_gamescore::get_personal_score_component_name(), "shots_hit", hits );
}

is_valid_weapon_hit( weapon_ref, sMeansOfDeath )
{
	if ( weapon_ref == "none" )  // things like electric fence and fire trap
		return false;
	
	if ( sMeansOfDeath == "MOD_MELEE" )
		return false;
	
	// If the weapon does not send an "weapon_fired" notify on firing, we cannot track its firing. Thus, we should not track its
	// hits either
	if ( no_weapon_fired_notify( weapon_ref ) )
		return false;
		
	return true;
}

no_weapon_fired_notify( weapon_ref )
{
	switch( weapon_ref )
	{
		case "turret_minigun_alien":        	// manned turret
		case "alien_manned_gl_turret_mp":   	// grenade turret 
		case "alien_manned_gl_turret1_mp":   	// grenade turret	
		case "alien_manned_gl_turret2_mp":   	// grenade turret	
		case "alien_manned_gl_turret3_mp":   	// grenade turret	
		case "alien_manned_gl_turret4_mp":   	// grenade turret			
		case "alien_manned_minigun_turret_mp":  // portable minigun turret
		case "alien_manned_minigun_turret1_mp": // portable minigun turret
		case "alien_manned_minigun_turret2_mp": // portable minigun turret
		case "alien_manned_minigun_turret3_mp": // portable minigun turret
		case "alien_manned_minigun_turret4_mp": // portable minigun turret
		case "switchblade_rocket_mp":       	// switchblade missile
		case "alienmortar_strike_mp":       	// mortar strike
		case "aliensemtex_mp":              	// semtex grenade
		case "alien_sentry_minigun_1_mp":   	// sentry gun
		case "alien_sentry_minigun_2_mp":   	// sentry gun
		case "alien_sentry_minigun_3_mp":   	// sentry gun
		case "alien_sentry_minigun_4_mp":   	// sentry gun			
		case "aliensoflam_missle_mp":       	// SOFLAM
		case "alienthrowingknife_mp":       	// pet bomb
		case "alienims_projectile_mp":      	// IMS
		case "alienclaymore_mp":            	// claymore
		case "alienmortar_shell_mp":        	// mortar shell
		case "alien_ball_drone_gun_mp":     	// ball drone
		case "alien_ball_drone_gun1_mp":     	// ball drone
		case "alien_ball_drone_gun2_mp":     	// ball drone
		case "alien_ball_drone_gun3_mp":     	// ball drone
		case "alien_ball_drone_gun4_mp":     	// ball drone
		case "alienvulture_mp":     			// ball drone			
		case "alienbetty_mp":               	// bouncing betty
		case "turret_minigun_alien_railgun":
		case "turret_minigun_alien_grenade":
		case "alientank_turret_mp":
		case "alientank_rigger_turret_mp":					
			return true;

		default:
			return false;
	}
}

// track shots
update_weaponstats_shots( weapon_ref, shots )
{
/#
	maps\mp\alien\_debug::debug_print_weapon_shots( weapon_ref );		
#/
	assertex( isdefined( shots ) && shots >= 0, "value not accepted as shots for weapon stats tracking" );

	if ( !self.should_track_weapon_fired )
		return;
	
	// black box data tracking
	level.alienBBData[ "bullets_shot" ] += shots;
	
	self update_weaponstats( "weaponStats", 		weapon_ref, "shots", shots );
	//self update_weaponstats( "weaponStatsSession", 	weapon_ref, "shots", shots );
	self maps\mp\alien\_gamescore::update_personal_encounter_performance( maps\mp\alien\_gamescore::get_personal_score_component_name(), "shots_fired", shots );
}

// track kills
update_weaponstats_kills( weapon_ref, kills )
{
	assertex( isdefined( kills ) && kills >= 0, "value not accepted as kills for weapon stats tracking" );
	
	self update_weaponstats( "weaponStats", 		weapon_ref, "kills", kills );
	//self update_weaponstats( "weaponStatsSession", 	weapon_ref, "kills", kills );
}

// tracks stats raw
update_weaponstats( stat_type, weapon_ref, stat, value )
{
	if ( !isplayer( self ) )
		return;
	
	// allow upgraded weapons to contribute to same base weapon stat
	base_weapon = get_base_weapon_name( weapon_ref );
	
	if ( !isdefined( base_weapon ) || !isdefined( self.persistence_weaponstats[ base_weapon ] ) )
		return;
	
	if(IsDefined(level.weapon_stats_override_name_func))
		base_weapon = [[level.weapon_stats_override_name_func]](base_weapon);
//	if(IsSubStr(base_weapon,"altalien"))
//	{
//		switch ( base_weapon )
//		{
//			case "iw6_altalienlsat_mp":
//				base_weapon = "iw6_alienDLC12_mp";
//				break;
//			case "iw6_altaliensvu_mp":
//				base_weapon = "iw6_alienDLC13_mp";
//				break;
//			case "iw6_altalienarx_mp":
//				base_weapon = "iw6_alienDLC14_mp";
//				break;
//			case "iw6_altalienmaverick_mp":
//				base_weapon = "iw6_alienDLC15_mp";
//				break;
//		
//			default:
//				break;
//		}
//	}
	
	if(IsSubStr(base_weapon,"dlc"))
	{
		//replace "dlc" with "DLC" for getting player data
		tokens		= StrTok( base_weapon, "d" );
		//tokens   = iw6_alien, lc12_mp
		base_weapon = tokens[ 0 ] + "DLC"; // + tokens[1];
		tokens		= StrTok( tokens[ 1 ], "c" );
		//tokens	   = l,12_mp
		base_weapon = base_weapon + tokens[ 1 ];
	}
	
	old_value = int( self getcoopplayerdata( stat_type, base_weapon, stat ) );
	new_value = old_value + int( value );
	self setcoopplayerdata( stat_type, base_weapon, stat, new_value );		
}

player_weaponstats_track_shots()
{
	self endon( "disconnect" );
	
	self notify( "weaponstats_track_shots" );
	self endon( "weaponstats_track_shots" );
	
	while ( 1 )
	{
		self waittill ( "weapon_fired", weapon_ref );
		if ( !isdefined( weapon_ref ) )
			continue;

		shotsFired = 1;
		self update_weaponstats_shots( weapon_ref, shotsFired );
	}
}

// ============== tracking combat resource purchases/upgrades ================

resource_tracking_init()
{
	// reset all session resource data
	foreach ( combat_resources in level.alien_combat_resources )
	{
		foreach ( resource, resource_struct in combat_resources )
		{
			self setcoopplayerdata( "resourceStatsSession", resource, "purchase", 0 );
			self setcoopplayerdata( "resourceStatsSession", resource, "upgrade", 0 );
			self setcoopplayerdata( "resourceStatsSession", resource, "used", 0 );
		}
	}
	foreach ( perk in level.alien_perks[ "perk_0" ] )
	{
		self setcoopplayerdata( "resourceStatsSession", perk.ref, "purchase", 0 );
		self setcoopplayerdata( "resourceStatsSession", perk.ref, "upgrade", 0 );
	}
	foreach ( perk in level.alien_perks[ "perk_1" ] )
	{
		self setcoopplayerdata( "resourceStatsSession", perk.ref, "purchase", 0 );
		self setcoopplayerdata( "resourceStatsSession", perk.ref, "upgrade", 0 );
	}
}

// combat resource purchases
update_resource_stats( track_type, resource, count )
{
	if ( !isplayer( self ) )
		return;
		
	assertex( isdefined( resource ), "resource reference string invalid" );

	self thread update_resource_stats_raw( "resourceStats", track_type, resource, count );
	self thread update_resource_stats_raw( "resourceStatsSession", track_type, resource, count );
}

update_resource_stats_raw( stat_type, track_type, resource, count )
{
	old_value = int( self getcoopplayerdata( stat_type, resource, track_type ) );
	new_value = old_value + int( count );
	self setcoopplayerdata( stat_type, resource, track_type, new_value );
}


//=======================================================
// 					XP/RANK/PRESTIGE
//=======================================================

// XP/Rank Table
RANK_TABLE					= "mp/alien/rankTable.csv";

TABLE_ID					= 0;	// [int] 	Rank ID
TABLE_REF					= 1;	// [string] Rank Reference
TABLE_XP_MIN				= 2;	// [int] 	Min XP
TABLE_XP_NEXT				= 3;	// [int] 	XP to Next
TABLE_RANK_SHORT			= 4;	// [string] Short rank localized
TABLE_RANK_FULL				= 5;	// [string]	Full rank localized
TABLE_ICON					= 6;	// [string] Rank icon
TABLE_XP_MAX				= 7;	// [int]	Max XP
TABLE_WEAPON_UNLOCK			= 8;	//
TABLE_PERK_UNLOCK			= 9;	//
TABLE_CHALLENGE				= 10;	//
TABLE_CAMO					= 11;	//
TABLE_ATTACHMENT			= 12;	//
TABLE_LEVEL					= 13;	// [int]	Rank number display
TABLE_DISPLAY_LEVEL			= 14;	//
TABLE_FEATURE_UNLOCK		= 15;	//
TABLE_RANK_INGAME			= 16;	// [string] In game rank localized
TABLE_UNLOCK_STRING			= 17;	//
TABLE_TOKEN_REWARD			= 18;	// [int] tokens awarded for completing the rank at prestige level 0;

// Populates data table entries into level array
rank_init()
{
	// level.alien_perks_table can be used to override default table, should be set before _alien::main()
	if ( !isdefined( level.alien_ranks_table ) )
		level.alien_ranks_table = RANK_TABLE;
	
	level.alien_ranks = [];
	
	// max rank is defined in table
	level.alien_max_rank = int( tablelookup( level.alien_ranks_table, TABLE_ID, "maxrank", TABLE_REF ) );
	assertex( isdefined( level.alien_max_rank ) && level.alien_max_rank );
	
	for ( i = 0; i <= level.alien_max_rank; i++ )
	{
		// break on end of line
		rank_ref = get_ref_by_id( i );
		if ( rank_ref == "" ) { break; }
		
		if ( !isdefined( level.alien_ranks[ i ] ) )
		{
			rank 					= spawnstruct();
			rank.id					= i;
			rank.ref				= rank_ref;
			rank.lvl				= get_level_by_id( i );
			rank.icon				= get_icon_by_id( i );
			rank.tokenReward		= get_token_reward_by_id( i );
			rank.xp					= [];
			rank.xp[ "min" ] 		= get_minxp_by_id( i );
			rank.xp[ "next" ]		= get_nextxp_by_id( i );
			rank.xp[ "max" ]		= get_maxxp_by_id( i );
			
			rank.name				= [];
			rank.name[ "short" ]	= get_shortrank_by_id( i );
			rank.name[ "full" ] 	= get_fullrank_by_id( i );
			rank.name[ "ingame" ]	= get_ingamerank_by_id( i );
			
			level.alien_ranks[ i ] = rank;
		}
	}
}

get_ref_by_id( id )
{
	return tablelookup( level.alien_ranks_table, TABLE_ID, id, TABLE_REF );
}

get_minxp_by_id( id )
{
	return int( tablelookup( level.alien_ranks_table, TABLE_ID, id, TABLE_XP_MIN ) );
}

get_maxxp_by_id( id )
{
	return int( tablelookup( level.alien_ranks_table, TABLE_ID, id, TABLE_XP_MAX ) );
}

get_nextxp_by_id( id )
{
	return int( tablelookup( level.alien_ranks_table, TABLE_ID, id, TABLE_XP_NEXT ) );
}

get_level_by_id( id )
{
	return int( tablelookup( level.alien_ranks_table, TABLE_ID, id, TABLE_LEVEL ) );
}

get_shortrank_by_id( id )
{
	return tablelookup( level.alien_ranks_table, TABLE_ID, id, TABLE_RANK_SHORT );
}

get_fullrank_by_id( id )
{
	return tablelookup( level.alien_ranks_table, TABLE_ID, id, TABLE_RANK_FULL );
}

get_ingamerank_by_id( id )
{
	return tablelookup( level.alien_ranks_table, TABLE_ID, id, TABLE_RANK_INGAME );
}

get_icon_by_id( id )
{
	return tablelookup( level.alien_ranks_table, TABLE_ID, id, TABLE_ICON );
}

get_token_reward_by_id( id )
{
	return int( tablelookup( level.alien_ranks_table, TABLE_ID, id, TABLE_TOKEN_REWARD ) );
}

// get player xp stats
get_player_rank()			{ return self getcoopplayerdata( "alienPlayerStats", "rank" ); }
get_player_xp()				{ return self getcoopplayerdata( "alienPlayerStats", "experience" ); }
get_player_prestige()		{ return self getcoopplayerdata( "alienPlayerStats", "prestige" ); }
get_player_escaped()        { return self getcoopplayerdata( "alienPlayerStats", "escaped" ); }
get_player_kills()        	{ return self getcoopplayerdata( "alienPlayerStats", "kills" ); }
get_player_revives()        { return self getcoopplayerdata( "alienPlayerStats", "revives" ); }
get_player_highest_nerf_escape_count()        { return self getcoopplayerdata( "alienPlayerStats", "headShots" ); }

// tracking session xp
get_player_session_xp()		
{ 
	return self getcoopplayerdata( "alienSession", "experience" );
}

set_player_session_xp( experience )
{ 
	self setcoopplayerdata( "alienSession", "experience", experience );
}

give_player_session_xp( amount )
{
	old_session_xp = self get_player_session_xp();
	new_session_xp = amount + old_session_xp;
	self set_player_session_xp( new_session_xp );
}

// tracking session tokens 
get_player_session_tokens()
{
	return self getcoopplayerdata( "alienSession", "shots" );
}

set_player_session_tokens( tokens )
{
	self setcoopplayerdata( "alienSession", "shots", tokens );
}

give_player_session_tokens( amount )
{
	old_session_tokens = self get_player_session_tokens();
	new_session_tokens = amount + old_session_tokens;
	self set_player_session_tokens( new_session_tokens );
}

// tracking how many times player ranked up in this session
set_player_session_rankup( ranked_up_times )
{
	self setcoopplayerdata( "alienSession", "ranked_up", int( ranked_up_times ) );
}

get_player_session_rankup()
{
	return self getcoopplayerdata( "alienSession", "ranked_up" );
}

update_player_session_rankup( ranked_up_times )
{
	if ( !isdefined( ranked_up_times ) )
		ranked_up_times = 1;
	
	old_ranked_up_times = self get_player_session_rankup();
	new_ranked_up_times = ranked_up_times + old_ranked_up_times;
	self set_player_session_rankup( new_ranked_up_times );
}

// set player xp stats
set_player_rank( rank )			
{
	self setcoopplayerdata( "alienPlayerStats", "rank", rank ); 
}

set_player_xp( xp )				
{
	self setcoopplayerdata( "alienPlayerStats", "experience", xp ); 
	
	// updates TEMP HUD
	//self maps\mp\alien\_hud::update_player_xp_display( 0.05 );
}

set_player_kills()
{
	old_kills = get_player_kills();
	new_kills = old_kills + 1;
	self setcoopplayerdata( "alienPlayerStats", "kills", new_kills );
}

set_player_revives()
{
	old_revives = get_player_revives();
	new_revives = old_revives + 1;
	self setcoopplayerdata( "alienPlayerStats", "revives", new_revives );
}

set_player_escaped()
{
	old_escaped = get_player_escaped();
	new_escaped = old_escaped + 1;
	self setcoopplayerdata( "alienPlayerStats", "escaped", new_escaped );
}

// WARNING: this should not be called in game anyways, only for testing.
set_player_prestige( prestige )	
{ 
	self setcoopplayerdata( "alienPlayerStats", "prestige", prestige );
	
	// reset rank and xp
	self setcoopplayerdata( "alienPlayerStats", "experience", 0 );
	self setcoopplayerdata( "alienPlayerStats", "rank", 0 );
}

// validates if rank meets xp requirements
get_rank_by_xp( xp )
{
	rank = 0;
	
	for ( i = 0; i < level.alien_ranks.size; i++ )
	{
		if ( xp >= level.alien_ranks[ i ].xp[ "min" ] )
		{
			if ( xp < level.alien_ranks[ i ].xp[ "max" ] )
			{
				rank = level.alien_ranks[ i ].id;
				break;
			}			
		}
	}
	
	return ( rank );
}

get_scaled_xp( xp )
{
	if( is_chaos_mode() )  //scale down xp in chaos mode only
		xp = int( 0.66 * xp );
	return int( xp * level.xpScale );
}

wait_and_give_player_xp( xp, waitTime )
{
	self endon( "disconnect" );
	level endon( "game_ended" );

	wait waitTime;
	give_player_xp( xp );
}

give_player_xp( xp )
{
	xp = get_scaled_xp( xp ); // double xp day, etc

	// JohnW: HACK to fix an xp progression blocker.  We will fix this properly after DLC1 ships.
	if ( xp > 90000 )
	{
		xp = 90000;
	}
	
	// record xp for session
	self thread give_player_session_xp( xp );
	at_max_rank = false;
	old_rank = self get_player_rank();			// get old rank for rank check later
	old_xp = self get_player_xp();				// get old xp for addition of xp
	
	old_prestige = self GetCoopPlayerData( "alienPlayerStats", "prestige" );
	
	//Fix for DLC 4 TU because we were capping at prestige 20 and rank 31
	if ( ( old_prestige == 5 || old_prestige == 10 || old_prestige == 15 || old_prestige == 20 ) && old_xp >= level.alien_ranks[ 29 ].xp[ "max" ]  )
	{
		old_xp = level.alien_ranks[ 29 ].xp[ "max" ] - 1;
		old_rank = 29;
	}
	new_xp = old_xp + xp;
	new_prestige = 0;

/#	
	if ( getDvar( "alien_debug_xp" ) == "1" )
		IPrintLn( "+" + xp + "xp [" + new_xp + "]" );
#/
		
	// set new xp
	self set_player_xp( new_xp );				// set new xp
	
	// did player level up?
	new_rank = self get_rank_by_xp( new_xp );	// get new rank
	
	if ( new_rank > old_rank )					// is new rank higher than old rank
	{
		if ( new_rank == level.alien_max_rank )
		{
			prestige = self GetCoopPlayerData( "alienPlayerStats", "prestige" );
			new_prestige = prestige;
			if ( prestige < MAX_PRESTIGE )
			{
				set_player_prestige( prestige + 1 );
				new_prestige = prestige + 1;
				give_player_tokens( 1, true );
			}
			else //player is at MAX_PRESTIGE and Max Rank (31)
			{
				at_max_rank = true;	
				self set_player_rank( new_rank );
			}
		}
		else
		{
			self set_player_rank( new_rank );		// set new rank
		}
		
		if ( at_max_rank == false )  
		{
			if ( new_rank == 30 )
				display_rank = 1;
			else
				display_rank = new_rank + 1;
			
			self setclientomnvar ( "ui_alien_rankup", display_rank );  // display rank up notification via LUA
			self notify( "ranked_up", new_rank ); 	// notify for any splash or blah
			self update_player_session_rankup(); 	// track number of times player ranked
		
			/#		if ( getDvar( "alien_debug_xp" ) == "1" )
				IPrintLnbold( "Ranked up: Lv." + new_rank + " [XP: " + new_xp + "]" );
			#/

			self award_rank_up_tokens( old_rank );
			
		}
		// let's tell the game to send this info to everybody else
		self SetRank( self get_player_rank(), self get_player_prestige() );
	}
} 

inc_stat( ref_name, stat_name, value )
{
	old_value = self getcoopplayerdata( ref_name, stat_name );
	new_value = old_value + value;

	self setcoopplayerdata( ref_name, stat_name, new_value );
}

inc_session_stat( stat_name, value )
{
	inc_stat( "alienSession", stat_name, value );
}

get_hives_destroyed_stat()
{
	return get_alienSession_stat( "hivesDestroyed" );	
}

get_alienSession_stat( field )
{
	return ( self getcoopplayerdata( "alienSession", field ) );
}

set_alienSession_stat( field, value )
{
	self setcoopplayerdata( "alienSession", field, value );
}

//=======================================================
// 					BLACK BOX DATA TRACKING
//=======================================================

BBData_init()
{
	level.alienBBData 	= [];
	
	level.alienBBData[ "times_downed" ] 		= 0; //
	level.alienBBData[ "times_died" ] 			= 0; //
	level.alienBBData[ "times_drill_stuck" ] 	= 0; //
	level.alienBBData[ "aliens_killed" ] 		= 0; //
	level.alienBBData[ "team_item_deployed" ] 	= 0; //
	level.alienBBData[ "team_item_used" ] 		= 0; //
	level.alienBBData[ "bullets_shot" ] 		= 0; //
	level.alienBBData[ "damage_taken" ] 		= 0; //
	level.alienBBData[ "damage_done" ] 			= 0; //
	level.alienBBData[ "traps_used" ] 			= 0; //
	
	level notify( "BBData_initialized" );
}

deployablebox_used_track( boxEnt )
{
	// self is user
	
	// track usage
	itemname = boxEnt.boxType;
	if ( isdefined( boxEnt.dpadName ) )
		itemname = boxEnt.dpadName;
	
	self thread maps\mp\alien\_persistence::update_resource_stats( "used", itemname, 1 );
	
	self maps\mp\alien\_gamescore::update_personal_encounter_performance( maps\mp\alien\_gamescore::get_team_score_component_name(), "team_support_deploy" );

	// black box data trcking
	level.alienBBData[ "team_item_used" ]++;
	self eog_player_update_stat( "deployablesused", 1 );

	username = "";
	if ( isdefined( self.name ) )
		username = self.name;

	/#
	if ( GetDvarInt( "alien_bbprint_debug" ) > 0 )
	{
		IPrintLnBold( "^8bbprint: aliendeployableused \n" +
					 " itemname=" + itemname +
					 " itemlevel=" + boxEnt.upgrade_rank +
					 " itemx,y,z=" + boxEnt.origin +
					 " username=" + username );
	}
	#/
	
	bbprint( "aliendeployableused",
	    "itemname %s itemlevel %i itemx %f itemy %f itemz %f username %s ", 
	    boxEnt.boxType,
	    boxEnt.upgrade_rank,
	    boxEnt.origin[0],
	    boxEnt.origin[1],
	    boxEnt.origin[2],
	    username );
}

get_player_ref()
{
	return ( "EoGPlayer" + ( self GetEntityNumber() ) );
}

update_LB_alienSession_challenge( challenge_succeed )
{
	foreach ( player in level.players )
	{
		player LB_player_update_stat( "challengesAttempted", 1 );
		
		if ( challenge_succeed )
			player LB_player_update_stat( "challengesCompleted", 1 );
	}
}

update_LB_alienSession_escape( players_escaped, escape_time_remains )
{
	LB_escape_rank = get_LB_escape_rank( escape_time_remains );
	
	foreach( player in players_escaped )
	{
		player LB_player_update_stat( "escapedRank" + LB_escape_rank, 1, true );
		player LB_player_update_stat( "hits", 1, true );  // We are using player session data "hits" to indicate that player successfully escapes from Point of Contact
	}
}

update_alien_kill_sessionStats( eInflictor, eAttacker )
{
	if ( !isDefined( eAttacker ) || !isPlayer( eAttacker ) )
		return;
	
	if ( maps\mp\alien\_utility::is_trap( eInflictor ) )
		eAttacker LB_player_update_stat( "trapKills", 1 );
}

register_LB_escape_rank( escape_rank_array )
{
	level.escape_rank_array = escape_rank_array;
}

get_LB_escape_rank( escape_time_remains )
{
	for ( i = 0; i < level.escape_rank_array.size - 1; i++ )
	{
		if ( escape_time_remains >= level.escape_rank_array[ i ] && escape_time_remains < level.escape_rank_array[ i+1 ] )
			return i;
	}	
}

have_clan_tag( player_name )
{
	return ( IsSubStr( player_name, "[" ) && IsSubStr( player_name, "]" ) );
}

remove_clan_tag( player_name )
{
	name_tokenized = StrToK( player_name, "]" );
	return name_tokenized[1];
}

register_EoG_to_LB_playerdata_mapping()
{
	// In playerdata, some fields in alienSession are tracking the same data as fields in EoGPlayer.  The mapping below 
	// allow us to update LB playerdata when EoGPlayer data is updated.
	
	alienSession_to_EoG_mapping = [];
	
	//                    EoGPlayer field name      LB field name  ( both field names need to match playerdata )
	EoG_to_LB_playerdata_mapping[ "kills" ]          = "kills";
	EoG_to_LB_playerdata_mapping[ "deployables" ]    = "deployables";
	EoG_to_LB_playerdata_mapping[ "drillplants" ]    = "drillPlants";
	EoG_to_LB_playerdata_mapping[ "revives" ]        = "revives";
	EoG_to_LB_playerdata_mapping[ "downs" ]          = "downed";
	EoG_to_LB_playerdata_mapping[ "drillrestarts" ]  = "repairs";
	EoG_to_LB_playerdata_mapping[ "score" ]          = "score";
	EoG_to_LB_playerdata_mapping[ "currencyspent" ]  = "currencySpent"; 
	EoG_to_LB_playerdata_mapping[ "currencytotal" ]  = "currencyTotal";
	EoG_to_LB_playerdata_mapping[ "hivesdestroyed" ] = "hivesDestroyed";
	
	level.EoG_to_LB_playerdata_mapping = EoG_to_LB_playerdata_mapping;
}

get_mapped_LB_ref_from_EoG_ref( EoG_ref )
{
	return level.EoG_to_LB_playerdata_mapping[ EoG_ref ];
}

play_time_monitor()
{
	self endon( "disconnect" );
	
	while ( true )
	{
		wait ( 1 );
		self LB_player_update_stat( "time", 1 );
	}
}