#include common_scripts\utility;

main()
{
	flag_init( "give_player_abilities" );
	if( maps\mp\alien\_utility::is_chaos_mode() )
		thread maps\mp\alien\_chaos::chaos_setup_op_weapons();
	else	
		thread setup_op_weapons();

	level._effect[ "smoke_green_signal" ] 			= loadfx( "vfx/gameplay/alien/vfx_alien_cskill_medic_smk_01" ) ;
}

setup_op_weapons()
{
	level.opWeaponsArray = [];
	level.opWeaponsArray[0] = "iw5_alienriotshield_mp";
	level.opWeaponsArray[1] = "iw5_alienriotshield1_mp";
	level.opWeaponsArray[2] = "iw5_alienriotshield2_mp";
	level.opWeaponsArray[3] = "iw5_alienriotshield3_mp";
	level.opWeaponsArray[4] = "iw5_alienriotshield4_mp";
	level.opWeaponsArray[5] = "iw6_alienminigun_mp";
	level.opWeaponsArray[6] = "iw6_alienminigun1_mp";
	level.opWeaponsArray[7] = "iw6_alienminigun2_mp";
	level.opWeaponsArray[8] = "iw6_alienminigun3_mp";
	level.opWeaponsArray[9] = "iw6_alienminigun4_mp";
	level.opWeaponsArray[10] = "iw6_alienmk32_mp";
	level.opWeaponsArray[11] = "iw6_alienmk321_mp";
	level.opWeaponsArray[12] = "iw6_alienmk322_mp";
	level.opWeaponsArray[13] = "iw6_alienmk323_mp";
	level.opWeaponsArray[14] = "iw6_alienmk324_mp";
	level.opWeaponsArray[15] = "iw6_alienpanzerfaust3_mp";
	level.opWeaponsArray[16] = "iw6_alienrgm_mp";
	level.opWeaponsArray[17] = "mp/iw6_alienrgm_mp";
	level.opWeaponsArray[18] = "weapon_iw6_alienrgm_mp";
	level.opWeaponsArray[19] = "iw6_alienmaaws_mp";
	level.opWeaponsArray[20] = "venomxgun_mp";
	level.opWeaponsArray[21] = "venomxproj_mp";
	level.opWeaponsArray[22] = "iw6_aliendlc11_mp";
	level.opWeaponsArray[23] = "alienbomb_mp";
	level.opWeaponsArray[24] = "iw6_aliendlc11sp_mp";
	level.opWeaponsArray[25] = "iw6_aliendlc11li_mp";
	level.opWeaponsArray[26] = "iw6_aliendlc11fi_mp";
	level.opWeaponsArray[27] = "iw6_aliendlc11_mp";
	level.opWeaponsArray[28] = "aliensoflam_mp";
	level.opWeaponsArray[29] = "aliencortex_mp";
	level.opWeaponsArray[30] = "iw6_aliendlc41_mp";	
	
}

assign_skills()
{
	self endon( "death" );
	self endon( "disconnect" );
	
	self.ability_scalar_bullet = 1;
	self.ability_scalar_melee = 1;
	
	player = self;
	flag_wait( "give_player_abilities" );
	primaryClass = player maps\mp\alien\_persistence::get_selected_perk_0();
	secondaryClass = maps\mp\alien\_persistence::get_selected_perk_0_secondary();
	self thread death_check();
	
	if( primaryClass == "perk_bullet_damage" )
	{
		if ( self maps\mp\alien\_persistence::is_upgrade_enabled( "weapon_specialist_upgrade" ) )
		{
			player thread specialist_skill_icon_waiter( );
		}
	}
	
	if( secondaryClass == "perk_bullet_damage" )
	{
		if ( self maps\mp\alien\_persistence::is_upgrade_enabled( "weapon_specialist_upgrade" ) )
		{
			player thread specialist_skill_icon_waiter( "secondary" );
		}
	}
	
	if( primaryClass == "perk_health" )
	{
		if ( self maps\mp\alien\_persistence::is_upgrade_enabled( "tank_upgrade" ) )
		{
			player thread tank_skill_icon_waiter();
		}
	}
	
	if( secondaryClass == "perk_health"  )
	{
		if ( self maps\mp\alien\_persistence::is_upgrade_enabled( "tank_upgrade" ) )
		{
			player thread tank_skill_icon_waiter( "secondary" );
		}
	}
	
	if( primaryClass == "perk_medic" )
	{
		if ( self maps\mp\alien\_persistence::is_upgrade_enabled( "medic_upgrade" ) )
		{
			player thread medic_skill_icon_waiter();
		}
	}
	
	if( secondaryClass == "perk_medic" )
	{
		if ( self maps\mp\alien\_persistence::is_upgrade_enabled( "medic_upgrade" ) )
		{
			player thread medic_skill_icon_waiter( "secondary" );
		}
	}
	
	if( primaryClass == "perk_rigger" )
	{
		if ( self maps\mp\alien\_persistence::is_upgrade_enabled( "engineer_upgrade" ) )
		{
			player thread engineer_skill_icon_waiter();
		}
	}
	
	if( secondaryClass == "perk_rigger" )
	{
		if ( self maps\mp\alien\_persistence::is_upgrade_enabled( "engineer_upgrade" ) )
		{
			player thread engineer_skill_icon_waiter( "secondary" );
		}
	}
	
}

///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//																												 			TANK SKILL
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//The tank pulls out two flares and gets all of the aggro
tank_skill_icon_waiter( secondary )
{
	self endon( "death" );
	self endon( "disconnect" );
	self notify( "clear_skills" );
	self endon( "clear_skills" );

	level.meleeStunRadius = 128;
	level.meleeStunMaxDamage = 1;
	level.meleeStunMinDamage = 1;

	tank_skill = [];
	tank_skill[ "rank_0_cost" ] = 200;
	tank_skill[ "rank_1_cost" ] = 350;
	tank_skill[ "rank_2_cost" ] = 380;
	tank_skill[ "rank_3_cost" ] = 415;
	tank_skill[ "rank_4_cost" ] = 475;

	tank_skill[ "rank_0_duration" ] = 5.00;
	tank_skill[ "rank_1_duration" ] = 5.625;
	tank_skill[ "rank_2_duration" ] = 6.25;
	tank_skill[ "rank_3_duration" ] = 7.5;
	tank_skill[ "rank_4_duration" ] = 10.0;

	tank_skill[ "rank_0_cooldown" ] = 180;
	tank_skill[ "rank_1_cooldown" ] = 180;
	tank_skill[ "rank_2_cooldown" ] = 180;
	tank_skill[ "rank_3_cooldown" ] = 180;
	tank_skill[ "rank_4_cooldown" ] = 180;

	tank_skill[ "perk" ] = "perk_health";

	self thread tank_skill_setup( tank_skill, secondary );
	
	self thread generic_skill_waiter( tank_skill , 2, secondary );
}

tank_skill_setup( tank_skill, secondary )
{
	self endon( "death" );
	self endon( "disconnect" );
	while(1)
	{
		if( IsDefined( self.has_died_primary ) || IsDefined( self.has_died_secondary ) ) 
		{
			if( isDefined( secondary ) )
			{
				self.has_died_secondary = undefined;
				skill_cooldown_secondary( tank_skill );
			}
			else
			{
				self.has_died_primary = undefined;
				skill_cooldown_primary( tank_skill );
			}
		}
		//Wait for the player to press the skill button
		
		if( isDefined( secondary ) )
			self wait_for_secondary_skill_button();
		else
			self wait_for_primary_skill_button();
		
		variables = generic_variable_setup( tank_skill );
		
		self thread sound_audio_weapon_activate();

		if( ability_cost( variables[ "cost" ], secondary ) )
		{
			self VisionSetNakedForPlayer( "mp_alien_thermal_trinity", .5 );

			self maps\mp\alien\_music_and_dialog::playTankClassSkillVO(self);
			//Attach flares
			self thread create_tank_ring( variables );
			self tank_skill_flare( variables );

			self VisionSetNakedForPlayer( "", .5 );

			//Wait for power to be ready
			if( isDefined( secondary ) )
				skill_cooldown_secondary( tank_skill );
			else
				skill_cooldown_primary( tank_skill );	
		}
		wait .05;
	}
}

tank_skill_flare( variables )
{
	self endon( "death" );
	self endon( "disconnect" );
	//increase the threat of our tank
	current_bias 	= self.threatbias;

	self.threatbias = 3000;
//	self.moveSpeedScaler = 1.4;
	self.ability_scalar_melee = 1.25;
	self.tank_skill_active = true;
	self thread tank_death_watcher();
	self.ability_invulnerable = true;
//	self thread tank_health_watch();

	self thread super_punch();
	level notify( "aggro_grab" );
	self thread aggro_grab();
	
	self thread sound_audio_tank(variables);

	wait variables["duration"];
//	self proto_hack_flare_update();

	//reset threat bias and speed
	self.threatbias = current_bias;
	self.ability_scalar_melee = 1;

	aliens = [];
	aliens = maps\mp\alien\_spawnlogic::get_alive_agents();
	self.tank_skill_active = undefined;
	self notify( "super_expired" );

	foreach ( alien in aliens)
	{
		alien.favoriteenemy = undefined;
	}
}

sound_audio_tank(variables)
{
	audio_tank = spawn( "script_origin", self.origin );
	self thread sound_position_update( audio_tank );
	audio_tank PlayLoopSound( "alien_skill_tank_lp" );
	waittill_any_timeout(variables["duration"], variables["death"]);
	audio_tank StopLoopSound();
	audio_tank notify( "kill_node" );
	wait 1;
	audio_tank delete();
}

sound_position_update(node)
{
	self endon( "death" );
	self endon( "disconnect" );
	node endon( "kill_node" );
	while(1)
	{
		node.origin = self.origin;
		wait 0.1;		
	}
}

tank_death_watcher()
{
	self waittill_any( "disconnect" , "death" , "super_expired" );
	self.ability_invulnerable = undefined;
	
}

tank_health_watch()
{
	self endon( "death" );
	self endon( "disconnect" );
	self endon( "super_expired" );

	iHealth = self.health;
	while(1)
	{
		if( iHealth <= self.health )
		{
			iHealth = self.health;
		}
		else
		{
			self.health = iHealth;	
		}
	 	wait .05;
	}
}

super_punch()
{
	self endon( "death" );
	self endon( "disconnect" );
	self endon( "super_expired" );

	while(1)
	{
		if( self MeleeButtonPressed() && self IsMeleeing()  )
		{
			wait 0.05;  
			Earthquake( 0.30,0.2,self.origin, 10 );  //make it feel good
            RadiusDamage( self.origin, level.meleeStunRadius, level.meleeStunMaxDamage, level.meleeStunMinDamage, self, "MOD_MELEE", "meleestun_mp"  ); // pass in a bogus weapon we are not using so the damage isn't caught in an infinate MOD_MELEE loop
            self PlaySoundToPlayer( "bodyfall_asphault_large", self );
            self wait_for_melee_end();

		}
		wait 0.05;  
	}
}

wait_for_melee_end()
{
	while(1)
	{
		if( self IsMeleeing() ==  false )
		{
			return;	
		}
		wait .1;
	}
}

aggro_grab()
{
	self endon( "death" );
	self endon( "disconnect" );
	level endon( "aggro_grab" );
	self endon( "super_expired" );

	while(1)
	{
		aliens = [];
		aliens = maps\mp\alien\_spawnlogic::get_alive_agents();

		foreach ( alien in aliens)
		{
			alien.favoriteenemy = self;
		}	
		wait .5;
	}
}


//TODO: HACKHACK BAD BAD  -- This stuff is for proto only, need better way of rendering flare
proto_hack_flare_update()
{
	self endon( "death" );
	self endon( "disconnect" );
	counter = 0;	

	while(1)
	{
		glowStick = spawn( "script_model", self GetTagOrigin( "tag_weapon_right" ) );
		glowstick setmodel("mil_emergency_flare_mp");
		glowstick.angles = self GetTagAngles( "tag_weapon_right" );
		glowStick LinkTo( self , "tag_weapon_right" );

		wait .05;

		angles = glowStick getTagAngles( "tag_fire_fx" );
		fxEnt = SpawnFx( loadfx( "fx/misc/flare_ambient_green" ), glowStick getTagOrigin( "tag_fire_fx" ), anglesToForward( angles ), anglesToUp( angles ) );
		TriggerFx( fxEnt );

		glowStick playLoopSound( "emt_road_flare_burn" );
	//	self thread deleteOnDeath( fxEnt );
	//	self.flareType = true;

		wait .05;	
		glowStick delete();
		fxEnt delete();

		counter = counter + 1;

		if( counter == 50 )
		{
			return;
		}
	}
}

create_tank_ring( variables )
{
	if( IsDefined( self ) )
		PlayFXOnTag( loadfx( "vfx/gameplay/alien/vfx_alien_cskill_tank_01" ) , self , "tag_origin" );

	waittill_any_timeout( variables[ "duration" ] , "last_stand" );
	if( IsDefined( self ) )
		StopFXOnTag( loadfx( "vfx/gameplay/alien/vfx_alien_cskill_tank_01" ) , self , "tag_origin" );
}
   
 
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//																												 			MEDIC SKILL
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//The medic tosses a medkit that heals a hurt player or pciks up a downed player

HEAL_TICK = .1;

medic_skill_icon_waiter( secondary )
{
	self endon( "death" );
	self endon( "disconnect" );
	self notify( "clear_skills" );
	self endon( "clear_skills" );

	medic_skill = [];
	medic_skill[ "rank_0_cost" ] = 225;
	medic_skill[ "rank_1_cost" ] = 350;
	medic_skill[ "rank_2_cost" ] = 390;
	medic_skill[ "rank_3_cost" ] = 430;
	medic_skill[ "rank_4_cost" ] = 515;

	medic_skill[ "rank_0_duration" ] = 5;
	medic_skill[ "rank_1_duration" ] = 5.625;
	medic_skill[ "rank_2_duration" ] = 6.25;
	medic_skill[ "rank_3_duration" ] = 7.5;
	medic_skill[ "rank_4_duration" ] = 10;

	medic_skill[ "rank_0_cooldown" ]= 180;
	medic_skill[ "rank_1_cooldown" ]= 180;
	medic_skill[ "rank_2_cooldown" ]= 180;
	medic_skill[ "rank_3_cooldown" ]= 180;
	medic_skill[ "rank_4_cooldown" ]= 180;

	medic_skill[ "perk" ] = "perk_medic";
	self thread medic_skill_setup( medic_skill, secondary );

	self thread generic_skill_waiter( medic_skill , 4, secondary );	
}

medic_skill_setup( medic_skill, secondary )
{
	self endon( "death" );
	self endon( "disconnect" );
	while(1)
	{
		if( IsDefined( self.has_died_primary ) || IsDefined( self.has_died_secondary ) ) 
		{
			if( isDefined( secondary ) )
			{
				self.has_died_secondary = undefined;
				skill_cooldown_secondary( medic_skill );
			}
			else
			{
				self.has_died_primary = undefined;
				skill_cooldown_primary( medic_skill );
			}
		}
		
		//Wait for the player to press the skill button
		if( isDefined( secondary ) )
			self wait_for_secondary_skill_button();
		else
			self wait_for_primary_skill_button();

		variables = generic_variable_setup( medic_skill );

		self thread sound_audio_weapon_activate();
		
		if( ability_cost( variables[ "cost" ], secondary ) )
		{
			self  maps\mp\alien\_music_and_dialog::playMedicClassSkillVO(self);
			self create_heal_ring( variables );
			if( isDefined( secondary ) )
				skill_cooldown_secondary( medic_skill );
			else
				skill_cooldown_primary( medic_skill );	
		}

		wait .05;	
	}
}
create_heal_ring( variables )
{
	carriedObj = SpawnTurret( "misc_turret", self.origin + ( 0, 0, 20 ), "sentry_minigun_mp" );
	carriedObj.owner = self;
	carriedObj.angles = AnglesToUp( ( 0 , 0 , 90 )  );

	carriedObj SetModel( "tag_origin_vehicle" );

	carriedObj MakeTurretInoperable();
	carriedObj SetTurretModeChangeWait( true );
	carriedObj SetMode( "sentry_offline" );
	carriedObj MakeUnusable();
	carriedObj SetSentryOwner( self );
	carriedObj SetSentryCarrier( self );

	carriedObj SetCanDamage( false );
	carriedObj SetContents( 0 );
	
	wait .1;
	PlayFXOnTag(level._effect[ "smoke_green_signal" ] , carriedObj , "tag_origin" );
	sound_heal = spawn( "script_model", self.origin );
	sound_heal LinkTo( carriedObj );
	sound_heal PlayLoopSound( "alien_skill_medic_lp" );
	self thread heal_logic();
	self thread death_deletes_heal_ring(carriedObj);
	self waittill_any_timeout( variables[ "duration" ] , "last_stand" , "death" , "disconnect" );

	if( IsDefined( self ) )
		self notify( "heal_over" );

	sound_heal StopLoopSound();
	sound_heal unlink();
	if( IsDefined( carriedObj ) )
		carriedObj delete();	
	wait 0.1;
	if( IsDefined( sound_heal ) )
		sound_heal delete();
}

death_deletes_heal_ring(carriedObj)
{
	self endon( "heal_over" );
	self waittill_any( "death","disconnect", "vanguard_used" );
	if( IsDefined( carriedObj ))
	{
		carriedObj delete();
	}
}
save_grenade()
{
	self endon( "missile_stuck" );
	wait 5;
	self.failthrow = true;
	self notify( "missile_stuck" );
}

medic_heal_skill( position ,  grenade , variables )
{
	self endon( "death" );
	self endon( "disconnect" );
	wait 1.5;

	//THE REAL ONE
//	 fxEnt = SpawnFx( loadfx( "vfx/gameplay/alien/vfx_alien_cskill_medic_smk_01" ) , position , anglesToForward( self.angles + ( -90 , 0 , 0 ) ), anglesToUp( self.angles + ( 0 , 0 , 0 ) ) );
//     TriggerFx( fxEnt );
	self thread heal_logic( position );

	//HACK HACK BAD
	fxEnt = SpawnFx( level._effect[ "smoke_green_signal" ] , position , anglesToForward( self.angles ), anglesToUp( self.angles + ( 0 , 0 , 0 ) ) );
	TriggerFx( fxEnt );
//
//	fxEnt3 = SpawnFx( level._effect[ "smoke_green_signal" ] , position + ( -100 , 100 , 0 ) , anglesToForward( self.angles ), anglesToUp( self.angles + ( 0 , 0 , -180 ) ) );
//	TriggerFx( fxEnt3 );

	wait variables["duration"];
	self notify( "heal_over" );
	fxEnt Delete();
//	fxEnt2 Delete();
//	fxEnt3 Delete();
}

heal_logic( )
{
	self endon( "death" );
	self endon( "disconnect" );
	self endon( "heal_over" );

	while(1)
	{
		foreach ( player in level.players)
		{
			healAmount = int(floor( player.maxhealth * HEAL_TICK ));
						
			if( Distance( player.origin , self.origin) <= 128 )
			{
				if( IsDefined( player.laststand ) && player.laststand )
				{
					player notify( "revive_success" );
					player setClientOmnvar ( "ui_laststand_end_milliseconds", 0 );
					maps\mp\alien\_laststand::record_revive_success( self , player );
				}
				else
				{
					if( ( player.health + healAmount ) >= player.maxhealth	)
					{
						player.health = player.maxhealth;	
					}
					else
					{
						player.health = player.health + healAmount ;
					}
				}
			}
		}
		wait .5;
	}
}

///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//																												 		 ENGINEER SKILL
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//Slow field traps enemies//
engineer_skill_icon_waiter( secondary )
{
	self endon( "death" );
	self endon( "disconnect" );
	self notify( "clear_skills" );
	self endon( "clear_skills" );

	engineer_skill = [];
	engineer_skill[ "rank_0_cost" ] = 200;
	engineer_skill[ "rank_1_cost" ] = 350;
	engineer_skill[ "rank_2_cost" ] = 380;
	engineer_skill[ "rank_3_cost" ] = 415;
	engineer_skill[ "rank_4_cost" ] = 475;

	engineer_skill[ "rank_0_duration" ] = 5.00;
	engineer_skill[ "rank_1_duration" ] = 5.625;
	engineer_skill[ "rank_2_duration" ] = 6.25;
	engineer_skill[ "rank_3_duration" ] = 7.5;
	engineer_skill[ "rank_4_duration" ] = 10.0;

	engineer_skill[ "rank_0_cooldown" ] =  180;
	engineer_skill[ "rank_1_cooldown" ] =  180;
	engineer_skill[ "rank_2_cooldown" ] =  180;
	engineer_skill[ "rank_3_cooldown" ] =  180;
	engineer_skill[ "rank_4_cooldown" ] =  180;

	engineer_skill[ "perk" ] = "perk_rigger";
	self thread engineer_skill_setup(engineer_skill, secondary);

	self thread generic_skill_waiter( engineer_skill , 3, secondary );
}

engineer_skill_setup(engineer_skill, secondary)
{
	self endon( "death" );
	self endon( "disconnect" );

	while(1)
	{
		if( IsDefined( self.has_died_primary ) || IsDefined( self.has_died_secondary ) ) 
		{
			if( isDefined( secondary ) )
			{
				self.has_died_secondary = undefined;
				skill_cooldown_secondary( engineer_skill );
			}
			else
			{
				self.has_died_primary = undefined;
				skill_cooldown_primary( engineer_skill );
			}
		}
		//Wait for the player to press the skill button
		if( isDefined( secondary ) )
			self wait_for_secondary_skill_button();
		else
			self wait_for_primary_skill_button();

		variables = generic_variable_setup( engineer_skill );
		
		self thread sound_audio_weapon_activate();
		
		if( ability_cost( variables[ "cost" ], secondary ) )
		{
			//Spawn the slowfield
			self maps\mp\alien\_music_and_dialog::playEngineerClassSkillVO(self);
			self engineer_slow_field( variables );

			//Wait for power to be ready
			if( isDefined( secondary ) )
				skill_cooldown_secondary( engineer_skill );
			else
				skill_cooldown_primary( engineer_skill );	
		}

		wait .05;
	}
}

engineer_slow_field( variables )
{
	self endon( "death" );
	self endon( "disconnect" );

	//Place the effect at the location of the engineer
	generator = spawn( "script_model", self.origin );
	newOrigin = GetGroundPosition( self.origin + ( 0,0,20 )  , 2 );
	generator.ammo = 1000;  //used for trophy upgrade and players should not run out of ammo, as this field is based off time.
	
	if( IsDefined( newOrigin ) )
	{
		generator.origin = newOrigin ;	
	}

	generator SetModel( "mp_weapon_alien_crate" );
	//HACK TEMP
//	fxEnt = SpawnFx( loadfx( "vfx/gameplay/alien/vfx_alien_chopper_escape_ring" ), generator.origin , anglesToForward( generator.angles ), anglesToUp( generator.angles ) );

	//THE REAL ONE
	fxEnt = SpawnFx( loadfx( "vfx/gameplay/alien/vfx_alien_cskill_engnr_ff_01" ), generator.origin , anglesToForward( self.angles + ( -90 , 0 , 0 ) ), anglesToUp( generator.angles ) );
	sound_engineer = Spawn( "script_origin", generator.origin );
	sound_engineer PlayLoopSound( "alien_skill_engineer_lp" );
	TriggerFx( fxEnt );
	self thread disconnect_delete( fxEnt , "skill_done" );

	//Deal a slight amount of pain to enemies in the field
	level.slow_field_active = true;
	self thread handle_ally_threat( generator , variables );
	
//	if ( self maps\mp\alien\_persistence::is_upgrade_enabled( "engineer_class_trophy_upgrade" ) )
	generator thread maps\mp\gametypes\_trophy_system::trophyActive( self );
	
	self alien_blocker_field( generator , variables );
	
	level.slow_field_active = false;
	sound_engineer StopLoopSound();
	wait 0.1;
	fxEnt delete();
	generator delete();
	sound_engineer delete();

	foreach ( player in level.players )
	{
		player.ignoreme = false;
	}
}

alien_blocker_field( generator , variables )
{
	self endon( "death" );
	self endon( "disconnect" );

	radius  = 245;
//	origins = [];
//	origins[0] 	= Spawn( "script_origin" , generator.origin + ( radius + 50 , 0 , 32 ) );
//	origins[1] 	= Spawn( "script_origin" , generator.origin - ( radius + 50 , 0 , 32 ) );
//	origins[2] 	= Spawn( "script_origin" , generator.origin + ( 0 , radius + 50 , 32 ) );
//	origins["rightOrg"]	= Spawn( "script_origin" , generator.origin - ( 0 , radius + 50 , 32 ) );
	
	self thread damage_enemies_in_range( generator);

//	linker = Spawn( "script_origin" , generator.origin );

//	foreach ( origin in origins)
//	{
//		origin MakeEntitySentient( "allies" );
//		origin.threatbias = self.threatbias;
//		origin.health = 10000;  
//		origin SetCanDamage( true );
//		origin LinkTo( linker );
//		self thread melee_attackers( origin );
//	}
//	linker RotateYaw( 180 , 10 , 0 , 10 );
	BadPlace_Cylinder( "cray_dome" , variables[ "duration" ] , generator.origin , radius , radius , "axis" );
	//Duration
	wait variables["duration"];	
	self notify( "stop_eng_damage" );
//	foreach ( origin in origins)
//	{
//		origin delete();
//	}
	BadPlace_Delete( "cray_dome" );
}

damage_enemies_in_range( generator )
{
	self endon( "stop_eng_damage" );
	self endon( "death" );
	self endon( "disconnect" );

	while(1)
	{
		aliens = maps\mp\alien\_spawnlogic::get_alive_agents();
		foreach ( alien in aliens )
		{
			if( Distance2D( generator.origin , alien.origin ) <= 256 )
			{
				alien DoDamage( 1 , generator.origin , self , self , "MOD_MELEE" );
				
				wait .5;
			}
			else
			{
//				alien.favoriteenemy = undefined;
			}
			wait .05;
		}
		wait .05;
	}
}

//melee_attackers( origin )
//{
//	self endon( "disconnect" );
//	self endon( "death" );
//	
//	while(1)
//	{
//		attacker DoDamage( 1 , origin.origin , self , self , "MOD_MELEE" );	
//	}
//}

handle_ally_threat( generator , variables )
{
	self endon( "death" );
	self endon( "disconnect" );
	self endon( "stop_eng_damage" );

	IGNORE_DISTANCE_SQ = 30625; // 175 * 175
	
	while(1)
	{
		foreach ( player in level.players )
		{
			if( Distance2DSquared( generator.origin , player.origin ) <= IGNORE_DISTANCE_SQ )
			{
				player.ignoreme = true;
				player thread safe_threat_restore( variables );
			}	
			else
			{
				player.ignoreme = false;
			}
		}
		wait .5;	
	}
}

safe_threat_restore( array )
{
	self endon( "death" );
	self endon( "disconnect" );
	wait array[ "duration" ];
	
	self.ignoreme = false;
	
}
 
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//																												WEAPON SPECIALIST SKILL
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//Crazy damage awesome mode pew pew pew
specialist_skill_icon_waiter( secondary )
{
	self endon( "death" );
	self endon( "disconnect" );
	self notify( "clear_skills" );
	self endon( "clear_skills" );

	specialist_skill = [];
	specialist_skill[ "rank_0_cost" ] = 250;
	specialist_skill[ "rank_1_cost" ] = 350;
	specialist_skill[ "rank_2_cost" ] = 400;
	specialist_skill[ "rank_3_cost" ] = 450;
	specialist_skill[ "rank_4_cost" ] = 500;

	specialist_skill[ "rank_0_duration" ] = 5.00;
	specialist_skill[ "rank_1_duration" ] = 5.625;
	specialist_skill[ "rank_2_duration" ] = 6.25;
	specialist_skill[ "rank_3_duration" ] = 7.5;
	specialist_skill[ "rank_4_duration" ] = 10.0;

	specialist_skill[ "rank_0_cooldown" ] = 180;
	specialist_skill[ "rank_1_cooldown" ] = 180;
	specialist_skill[ "rank_2_cooldown" ] = 180; 
	specialist_skill[ "rank_3_cooldown" ] = 180;
	specialist_skill[ "rank_4_cooldown" ] = 180; 

	specialist_skill[ "perk" ] = "perk_bullet_damage";
	self thread specialist_skill_setup( specialist_skill, secondary );

	self thread generic_skill_waiter( specialist_skill , 1, secondary );
}

specialist_skill_setup( specialist_skill, secondary )
{
	self endon( "death" );
	self endon( "disconnect" );
	self.damage_increased = true;
	
	while(1)
	{
		if( IsDefined( self.has_died_primary ) || IsDefined( self.has_died_secondary ) ) 
		{
			if( isDefined( secondary ) )
			{
				self.has_died_secondary = undefined;
				skill_cooldown_secondary( specialist_skill );
			}
			else
			{
				self.has_died_primary = undefined;
				skill_cooldown_primary( specialist_skill );
			}
		}
		
		//Wait for the player to press the skill button
		if( isDefined( secondary ) )
			self wait_for_secondary_skill_button();
		else
			self wait_for_primary_skill_button();

		variables = generic_variable_setup( specialist_skill );
		
		self thread sound_audio_weapon_activate();
		
		if( ability_cost( variables[ "cost" ], secondary ) )
		{
			//Sends the weapon specialist into awesome kill mode
                        self maps\mp\alien\_music_and_dialog::playWeaponClassSkillVO(self);
			self.skill_in_use = true;
			self thread effect_on_fire( variables );
			self.camFX = SpawnFXForClient( LoadFX( "vfx/gameplay/alien/vfx_alien_cskill_wspecial_01" ), self.origin , self );
			TriggerFX( self.camFX );
			self specialist_boost( variables );

			self.skill_in_use = undefined;
			if( IsDefined( self.camFX ) )
				self.camFX delete();
			//Wait for power to be ready
			if( isDefined( secondary ) )
				skill_cooldown_secondary( specialist_skill );
			else
				skill_cooldown_primary( specialist_skill );	
		}

		wait .05;
	}
}

sound_audio_weapon_activate()
{
	audio_weapon = spawn_tag_origin();
	audio_weapon.origin = self.origin;
	audio_weapon.angles = self.angles;
	audio_weapon LinkTo( self );
	audio_weapon PlaySound( "alien_skill_activate" );
	wait 2;
	audio_weapon delete();
}

effect_on_fire(variables)
{
	self endon( "death" );
	self endon( "disconnect" );	
	PlayFXOnTag(LoadFX( "vfx/gameplay/alien/vfx_alien_cskill_wspecial_02" ) , self , "tag_origin" );

	self thread sound_audio_weapon(variables);
	
	waittill_any_timeout( variables[ "duration" ] , "last_stand" );
	StopFXOnTag(LoadFX( "vfx/gameplay/alien/vfx_alien_cskill_wspecial_02" ) , self , "tag_origin" );

}

sound_audio_weapon(variables)
{
	wait 0.3;
	audio_weapon = spawn( "script_origin", self.origin );
	self thread sound_position_update( audio_weapon );
	audio_weapon PlayLoopSound( "alien_skill_weapon_lp" );
	waittill_any_timeout(variables["duration"], variables["death"]);
	audio_weapon StopLoopSound();
	audio_weapon notify( "kill_node" );
	wait 1;
	audio_weapon delete();
}


//
specialist_boost( variables )
{
	self endon( "death" );
	self endon( "disconnect" );

	//store current damage multiplier, speed, and ammo
	ammo 			= self specialist_ammo_round_up();
//	initial_speed	= self.moveSpeedScaler;

	//Boost that damage!
	self thread specialist_death_watcher();
	self.ability_scalar_bullet = .9;
	foreach ( player in level.players)
	{
		if( player != self )
		{
			player thread temp_damage_increase( variables );
		}
	}

	//Unlimited Ammo!
	self thread unlimited_ammo( ammo );
//	self VisionSetNakedForPlayer( "aftermath_post", .5 );
	self maps\mp\alien\_utility::restore_client_fog( 0 );
	self thread maps\mp\alien\_outline_proto::set_alien_outline();

	wait variables["duration"];

	//Reset everything
	self SetClientOmnvar ( "ui_alien_unlimited_ammo", 0);
	level notify( "stop_specialist_power" );
	self.ability_scalar_bullet = 1;
//	self VisionSetNakedForPlayer( "", .5 );

	self remove_the_outline();
}

specialist_death_watcher()
{
	self waittill_any( "death" , "disconnect" , "stop_specialist_power" );
	if( IsDefined( self ) )
	{
		self.ability_scalar_bullet = 1;
		self SetClientOmnvar ( "ui_alien_unlimited_ammo", 0);
		StopFXOnTag(LoadFX( "vfx/gameplay/alien/vfx_alien_cskill_wspecial_02" ) , self , "tag_origin" );
	}
	if( IsDefined( self.camFX ) )
		self.camFX delete();
}

temp_damage_increase( variables )
{
	self endon( "death" );
	self endon( "disconnect" );

	if( !IsDefined( self.damage_increased ) )
	{
	   	self.damage_increased = true;
		self.ability_scalar_bullet = 1.1;
		wait variables["duration"];
		self.ability_scalar_bullet = 1;
		self.damage_increased = undefined;
	}
}

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

	if( IsDefined( self.isFeral ) && self.isFeral )
		return;
	
	self notify( "switchblade_over" );

	aliens = maps\mp\alien\_spawnlogic::get_alive_agents();
	foreach ( alien in aliens )
	{
		if ( isDefined( alien.damaged_by_players ) ) // this is set by a challenge that uses outlines, so don't mess with the outlines for these guys
			continue;
			
		if ( isDefined( alien.marked_for_challenge ) ) // this is set by a challenge that uses outlines, so don't mess with the outlines for these guys
			continue;
		
		if ( !isDefined( alien.pet) )
			maps\mp\alien\_outline_proto::disable_outline_for_player( alien, self );
	}
	if( !IsDefined( level.seeder_active_turrets ) )
		return;

	foreach ( turret in level.seeder_active_turrets)
	{
		if ( isDefined( turret ) && !isdefined(turret.pet))
		{
			maps\mp\alien\_outline_proto::disable_outline_for_player( turret, self );
		}
	}
	
}

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

	ammo = [];
	foreach ( weapon in self.weaponlist)
	{
		ammo[ weapon ] = self GetAmmoCount( weapon );
	}
	return ammo;
}

unlimited_ammo( ammo )
{
	self endon( "death" );
	self endon( "disconnect" );
	level endon( "stop_specialist_power" );

	if( self.weaponlist.size == 0 ) 
	{
		self.weaponlist[0] = self GetCurrentWeapon();
	}

	while(1)
	{
		bCheck = false;
		foreach ( index in self.weaponlist)
		{
			if( weapon_no_unlimited_check( self GetCurrentWeapon() ) )
			{
				self SetClientOmnvar ( "ui_alien_unlimited_ammo", 1);
			}
			else
			{
				self SetClientOmnvar ( "ui_alien_unlimited_ammo", 0);				
			}

			if( index == self GetCurrentWeapon() && weapon_no_unlimited_check( index )  )
			{
				bCheck = true;	
				self SetWeaponAmmoClip(	index , WeaponClipSize( index ) , "left" );
			}

			if( index == self GetCurrentWeapon() && weapon_no_unlimited_check( index ) )
			{
				bCheck = true;	
				self SetWeaponAmmoClip(	index , WeaponClipSize( index ) , "right" );
			}

			if( bCheck == false )
			{
				self specialist_ammo_round_up();
			}
		}
		wait .05;
	}
}

weapon_no_unlimited_check( weapon )
{
	bCheck = true;

	foreach( opWeapon in level.opWeaponsArray)
	{
		if( weapon == opWeapon )
		{
			bCheck = false;	
		}
	}
	return bCheck;	
}

///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//																															  UTILITIES
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//Waits for the power to the be ready
skill_cooldown_primary( array )
{
	self endon( "death" );
	self endon( "disconnect" );

	bPause = false;
	cooldown_duration = get_wait_seconds( array );
	self.is_cooling_primary = true;
	self SetClientOmnvar( "ui_alien_class_skill_active" , false );
	timer = gettime() + int(1000 * cooldown_duration );
	self SetClientOmnvar( "ui_alien_class_skill_timer" , timer );
	self thread pause_cooldown_watcher();
	checker = timer;
	while( timer >= Gettime() )
	{
		if( IsDefined( self.laststand ) )
		{
			timer = timer + 1000;
			bPause = true;
		}
		else
		{
			checker = checker - 1000;
			if( bPause == true )
			{
				self SetClientOmnvar( "ui_alien_class_skill_timer" , checker );
				bPause = false;
			}			
		}
		wait 1;
	}
	self SetClientOmnvar( "ui_alien_class_skill_timer" , 0 );
	self.is_cooling_primary = undefined;
}

skill_cooldown_secondary( array )
{
	self endon( "death" );
	self endon( "disconnect" );

	bPause = false;
	cooldown_duration = get_wait_seconds( array );
	self.is_cooling_secondary = true;
	self SetClientOmnvar( "ui_alien_class_skill_active_secondary" , false );
	timer = gettime() + int(1000 * cooldown_duration );
	self SetClientOmnvar( "ui_alien_class_skill_timer_secondary" , timer );
	self thread pause_cooldown_watcher();
	checker = timer;
	while( timer >= Gettime() )
	{
		if( IsDefined( self.laststand ) )
		{
			timer = timer + 1000;
			bPause = true;
		}
		else
		{
			checker = checker - 1000;
			if( bPause == true )
			{
				self SetClientOmnvar( "ui_alien_class_skill_timer_secondary" , checker );
				bPause = false;
			}			
		}
		wait 1;
	}
	self SetClientOmnvar( "ui_alien_class_skill_timer_secondary" , 0 );
	self.is_cooling_secondary = undefined;
}
pause_cooldown_watcher()
{	
	self endon( "death" );
	self endon( "disconnect" );
	self endon( "death" );
	
	while(IsDefined( self.is_cooling_secondary ) || IsDefined( self.is_cooling_primary ) )
	{
		if( IsDefined( self.laststand ) )
		{
			self SetClientOmnvar( "ui_alien_class_skill_blocked" , 1 );			
		}
		else
		{
			self SetClientOmnvar( "ui_alien_class_skill_blocked" , 0 );	
		}
		wait .1;
	}
}

get_wait_seconds( skill_array )
{
	cooldown=skill_array[ "rank_0_cooldown" ];
	
	primaryClass = self maps\mp\alien\_persistence::get_selected_perk_0();
	class_level = self maps\mp\alien\_persistence::get_perk_0_level();

	if( primaryClass == skill_array["perk"] && class_level == 0 )
	{
		cooldown = skill_array[ "rank_0_cooldown" ];
	}
	else if( primaryClass == skill_array["perk"] && class_level == 1 )
	{
		cooldown = skill_array[ "rank_1_cooldown" ];
	}
	else if( primaryClass == skill_array["perk"] && class_level == 2 )
	{
		cooldown = skill_array[ "rank_2_cooldown" ];
	}
	else if( primaryClass == skill_array["perk"] && class_level == 3 )
	{
		cooldown = skill_array[ "rank_3_cooldown" ];
	}
	else if( primaryClass == skill_array["perk"] && class_level == 4 )
	{
		cooldown = skill_array[ "rank_4_cooldown" ];
	}
	
	if ( self maps\mp\alien\_persistence::is_upgrade_enabled( "cooldown_skills_upgrade" ) )
		cooldown = cooldown * 0.5;	

	return cooldown;
}

//Waits for the player to push the primary skill button
wait_for_primary_skill_button()
{
	self endon( "death" );
	self endon( "disconnect" );

	self.double_tapped_primary = undefined;
	while( !IsDefined( self.double_tapped_primary ) )
	{
		if( !IsDefined( self ) )
		{
			wait 1;
			break;			
		}

		self waittill( "action_slot_1" );
		if(IsDefined(self.turn_off_class_skill_activation))
			continue;
		if( !IsDefined( self.laststand ) )
		{
			self check_for_double_tap_primary();
		}
	}
}
check_for_double_tap_primary()
{
	self endon( "d_tap_limit_primary" );

	self thread timer_for_double_tap_primary();
	waittill_any( "action_slot_1" );
	self notify( "double_tapped_primary" );
	self.double_tapped_primary = true;
}

timer_for_double_tap_primary()
{
	self endon( "double_tapped_primary" );
	
	counter = 10;

	while( counter > 0 )
	{
		wait .05;
		counter = counter - 1;
	}
	self notify( "d_tap_limit_primary" );
}

//Waits for the player to push the secondary skill button
wait_for_secondary_skill_button()
{
	self endon( "death" );
	self endon( "disconnect" );

	self.double_tapped_secondary = undefined;
	while( !IsDefined( self.double_tapped_secondary ) )
	{
		if( !IsDefined( self ) )
		{
			wait 1;
			break;			
		}

		self waittill( "action_slot_3" );
		if(IsDefined(self.turn_off_class_skill_activation))
			continue;
		if( !IsDefined( self.laststand ) )
		{
			self check_for_double_tap_secondary();
		}
	}
}
check_for_double_tap_secondary()
{
	self endon( "d_tap_limit_secondary" );

	self thread timer_for_double_tap_secondary();
	waittill_any( "action_slot_3" );
	self notify( "double_tapped_secondary" );
	self.double_tapped_secondary = true;
}

timer_for_double_tap_secondary()
{
	self endon( "double_tapped_secondary" );
	
	counter = 10;

	while( counter > 0 )
	{
		wait .05;
		counter = counter - 1;
	}
	self notify( "d_tap_limit_secondary" );
}


//Remove money when the ability gets used
ability_cost( amount, secondary )
{
	self endon( "death" );
	self endon( "disconnect" );
//	amount = 0;

//	cash_money = self maps\mp\alien\_persistence::get_player_currency();

//	if( cash_money >= amount && self offhand_check() == true )
//	if( self offhand_check() == true )
//	{
//		self maps\mp\alien\_persistence::set_player_currency( cash_money - amount );
//		self thread maps\mp\alien\_persistence::take_player_currency( amount , false , "ability" );
		
	if( isDefined ( secondary ) )
		self SetClientOmnvar( "ui_alien_class_skill_active_secondary" , true );
	else
		self SetClientOmnvar( "ui_alien_class_skill_active" , true );
	self notify( "class_skill_used" );
	return true;
//	}
//	else
//	{
//		return false;
//	}
}

deleteOnDeath( ent )
{
	self endon( "death" );
	self endon( "disconnect" );

	self waittill( "death" );

	if ( IsDefined( ent ) )
		ent delete();
}

//Makes sure the player doesn't have anything equipped in the offhand before allowing them to use their skills
offhand_check()
{
	self endon( "death" );
	self endon( "disconnect" );
	weapons = self GetWeaponsListOffhands();
	foreach ( weapon in weapons)
	{
		if( self GetAmmoCount( weapon ) )
		{
			return false;
		}
	}
	return true;
}

generic_skill_waiter( skill_array , omnvarNum, secondary )
{
	self endon( "death" );
	self endon( "disconnect" );
	
	if( isDefined( secondary ) )
		self SetClientOmnvar ( "ui_alien_class_skill_secondary", omnvarNum );
	else
		self SetClientOmnvar ( "ui_alien_class_skill", omnvarNum );
}

generic_variable_setup( skill_array )
{
	self endon( "death" );
	self endon( "disconnect" );
	variables = [];

	secondaryClass = maps\mp\alien\_persistence::get_selected_perk_0_secondary();
	primaryClass = self maps\mp\alien\_persistence::get_selected_perk_0();
	class_level = self maps\mp\alien\_persistence::get_perk_0_level();

	if( ( primaryClass == skill_array["perk"] || secondaryClass == skill_array[ "perk" ] ) && class_level == 0 )
	{
		variables[ "cooldown" ] = skill_array[ "rank_0_cooldown" ];
		variables[ "cost" ]		= skill_array[ "rank_0_cost" ];
		variables[ "duration" ]	= skill_array[ "rank_0_duration" ];
	}
	else if( ( primaryClass == skill_array["perk"] || secondaryClass == skill_array[ "perk" ] ) && class_level == 1 )
	{
		variables[ "cooldown" ] = skill_array[ "rank_1_cooldown" ];	
		variables[ "cost" ]		= skill_array[ "rank_1_cost" ];	
		variables[ "duration" ]	= skill_array[ "rank_1_duration" ];
	}
	else if( ( primaryClass == skill_array["perk"] || secondaryClass == skill_array[ "perk" ] ) && class_level == 2 )
	{
		variables[ "cooldown" ] = skill_array[ "rank_2_cooldown" ];	
		variables[ "cost" ]		= skill_array[ "rank_2_cost" ];
		variables[ "duration" ]	= skill_array[ "rank_2_duration" ];
	}
	else if( ( primaryClass == skill_array["perk"] || secondaryClass == skill_array[ "perk" ] ) && class_level == 3 )
	{
		variables[ "cooldown" ] = skill_array[ "rank_3_cooldown" ];	
		variables[ "cost" ]		= skill_array[ "rank_3_cost" ];
		variables[ "duration" ]	= skill_array[ "rank_3_duration" ];
	}
	else if( ( primaryClass == skill_array["perk"] || secondaryClass == skill_array[ "perk" ] ) && class_level == 4 )
	{
		variables[ "cooldown" ] = skill_array[ "rank_4_cooldown" ];	
		variables[ "cost" ]		= skill_array[ "rank_4_cost" ];
		variables[ "duration" ]	= skill_array[ "rank_4_duration" ];
	}

	return variables;
}

death_check()
{
	self waittill( "death" );
	self.has_died_primary = true;
	self.has_died_secondary = true;
}

disconnect_delete( entity , notifyString )
{
	self endon( notifyString );

	self waittill_any( "disconnect" , "death" );
	if( IsDefined( entity) )
		entity delete();
}