// Half-Life: Insecure Empowered Vortigaunts.
// Used Sven Co-op port of Field Intensity on modifications.
// Modified by by Nevermore2790.

namespace SVEN_VORTIGAUNT_EMPOWERED
{
	const int bits_MEMORY_ISLAVE_EMPOWERED_PROVOKED = bits_MEMORY_CUSTOM1;
	const int bits_MEMORY_ISLAVE_EMPOWERED_REVIVED = bits_MEMORY_CUSTOM2;
	const int bits_MEMORY_ISLAVE_EMPOWERED_LAST_ATTACK_WAS_COIL = bits_MEMORY_CUSTOM3;
	const int bits_MEMORY_ISLAVE_EMPOWERED_FAMILIAR_IS_ALIVE = bits_MEMORY_CUSTOM4;
	
	// Monster Spawnflags
	const int SF_MONSTER_WAIT_TILL_SEEN = 1;
	const int SF_MONSTER_GAG = 2;
	const int SF_MONSTER_HITMONSTERCLIP = 4;
	const int SF_MONSTER_PRISONER = 16;
	const int SF_SQUADMONSTER_LEADER = 32;
	const int SF_MONSTER_WAIT_UNTIL_PROVOKED = 64;
	const int SF_MONSTER_WAIT_FOR_SCRIPT = 128;
	const int SF_MONSTER_PREDISASTER = 256;
	const int SF_MONSTER_FADECORPSE = 512;
	const int SF_MONSTER_FALL_TO_GROUND = int(0x80000000);
	
	//=========================================================
	// monster-specific schedule types
	//=========================================================
	enum SCHED_ISLAVE_EMPOWERED
	{
		SCHED_ISLAVE_EMPOWERED_COVER_AND_SUMMON_FAMILIAR = LAST_COMMON_SCHEDULE + 1,
		SCHED_ISLAVE_EMPOWERED_SUMMON_FAMILIAR,
		SCHED_ISLAVE_EMPOWERED_HEAL_OR_REVIVE,
		SCHED_RETREAT_FROM_ENEMY,
		SCHED_RETREAT_FROM_ENEMY_FAILED
	};
	
	//=========================================================
	// monster-specific tasks
	//=========================================================
	enum TASK_ISLAVE_EMPOWERED
	{
		TASK_ISLAVE_EMPOWERED_SUMMON_FAMILIAR = LAST_COMMON_TASK + 1,
		TASK_ISLAVE_EMPOWERED_HEAL_OR_REVIVE_ATTACK,
	};

	//=========================================================
	// Monster's Anim Events Go Here
	//=========================================================
	const int ISLAVE_EMPOWERED_AE_CLAW = ( 1 );
	const int ISLAVE_EMPOWERED_AE_CLAWRAKE = ( 2 );
	const int ISLAVE_EMPOWERED_AE_ZAP_POWERUP = ( 3 );
	const int ISLAVE_EMPOWERED_AE_ZAP_SHOOT = ( 4 );
	const int ISLAVE_EMPOWERED_AE_ZAP_DONE = ( 5 );
	const int ISLAVE_EMPOWERED_AE_SONIC_ATTACK = ( 6 );

	const int ISLAVE_EMPOWERED_MAX_BEAMS = 8;

	const string ISLAVE_EMPOWERED_HAND_SPRITE_NAME 		= "sprites/glow02.spr";
	const string ISLAVE_EMPOWERED_LIGHTNING_SPRITE		= "sprites/lgtning.spr";
	const string ISLAVE_EMPOWERED_TRAIL_SPRITE			= "sprites/plasma.spr";
	const string ISLAVE_EMPOWERED_SHOCKWAVE_SPRITE		= "sprites/shockwave.spr";
	const string ISLAVE_EMPOWERED_SPAWNFAMILIAR_SPRITE 	= "sprites/bexplo.spr";
	
	const int ISLAVE_EMPOWERED_ZAP_RED 					= 64;
	const int ISLAVE_EMPOWERED_ZAP_GREEN 				= 160;
	const int ISLAVE_EMPOWERED_ZAP_BLUE 				= 255;

	const int ISLAVE_EMPOWERED_LEADER_ZAP_RED 			= 128;
	const int ISLAVE_EMPOWERED_LEADER_ZAP_GREEN 		= 200;
	const int ISLAVE_EMPOWERED_LEADER_ZAP_BLUE 			= 255;

	const int ISLAVE_EMPOWERED_ARMBEAM_RED 				= 48;
	const int ISLAVE_EMPOWERED_ARMBEAM_GREEN 			= 100;
	const int ISLAVE_EMPOWERED_ARMBEAM_BLUE 			= 150;

	const int ISLAVE_EMPOWERED_LEADER_ARMBEAM_RED 		= 96;
	const int ISLAVE_EMPOWERED_LEADER_ARMBEAM_GREEN 	= 128;
	const int ISLAVE_EMPOWERED_LEADER_ARMBEAM_BLUE 		= 180;

	const int ISLAVE_EMPOWERED_LIGHT_RED 				= 96;
	const int ISLAVE_EMPOWERED_LIGHT_GREEN 				= 180;
	const int ISLAVE_EMPOWERED_LIGHT_BLUE 				= 255;

	const int ISLAVE_EMPOWERED_ELECTROONLY 				= (1 << 0);
	const int ISLAVE_EMPOWERED_SNARKS 					= (1 << 1);
	const int ISLAVE_EMPOWERED_HEADCRABS 				= (1 << 2);

	const int ISLAVE_EMPOWERED_COIL_ATTACK_RADIUS 		= 196;

	// Models
	const string ISLAVE_EMPOWERED_MODEL					= "models/sc_insecure/islave_emp.mdl";
	const string ISLAVE_EMPOWERED_MODEL_CLASSIC			= "models/sc_insecure/hlclassic/islave_emp.mdl";
	
	const int ISLAVE_EMPOWERED_SPAWNFAMILIAR_DELAY 		= 6;

	enum ISLAVE_EMPOWERED_ARM
	{
		ISLAVE_EMPOWERED_LEFT_ARM = -1,
		ISLAVE_EMPOWERED_RIGHT_ARM = 1
	};

	bool IsVortEmpWounded(CBaseEntity@ pEntity)
	{
		return pEntity.pev.health <= Math.min( pEntity.pev.max_health / 2, 20 );
	}
	
	bool CanBeRevived(CBaseEntity@ pEntity)
	{
		if ( pEntity !is null && pEntity.pev.deadflag == DEAD_DEAD && ( pEntity.pev.flags & FL_KILLME ) == 0 )
		{
			CBaseMonster@ pMonster = pEntity.MyMonsterPointer();
			
			if ( pMonster is null || pMonster.HasMemory( bits_MEMORY_ISLAVE_EMPOWERED_REVIVED ) )
			{
				// Wrong target or was already revived once
				return false;
			}

			const Vector vecDest = pEntity.pev.origin + Vector( 0, 0, 38 );
			TraceResult tr;
			g_Utility.TraceHull( vecDest, vecDest - Vector( 0, 0, 2 ), dont_ignore_monsters, human_hull, pEntity.edict(), tr );
		
			return tr.fAllSolid == 0 && tr.fStartSolid == 0;
		}
		
		return false;
	}
	
	bool CanSpawnAtPosition(const Vector position, HULL_NUMBER hullType, edict_t@ pentIgnore)
	{
		TraceResult tr;
		g_Utility.TraceHull( position, position - Vector( 0, 0, 1 ), dont_ignore_monsters, hullType, pentIgnore, tr );
		
		return tr.fStartSolid == 0 && tr.fAllSolid == 0;
	}

	void PrecacheSoundArray(const array<string>& in arr)
	{
		for ( uint i = 0; i < arr.length(); i++ )
			g_SoundSystem.PrecacheSound( arr[i] );
	}

	string RandomSoundFromArray(const array<string>& in arr)
	{
		return arr[Math.RandomLong( 0, arr.length() - 1 )];
	}

	const array<string> pAttackHitSounds =
	{
		"zombie/claw_strike1.wav",
		"zombie/claw_strike2.wav",
		"zombie/claw_strike3.wav"
	};

	const array<string> pAttackMissSounds =
	{
		"zombie/claw_miss1.wav",
		"zombie/claw_miss2.wav"
	};

	const array<string> pPainSounds =
	{
		"aslave/slv_pain1.wav",
		"aslave/slv_pain2.wav"
	};

	const array<string> pDeathSounds =
	{
		"aslave/slv_die1.wav",
		"aslave/slv_die2.wav"
	};

	const array<string> pGlowArmSounds =
	{
		"debris/zap3.wav",
		"debris/zap8.wav"
	};

	const array<string> pSonicWaveSounds =
	{
		"houndeye/he_blast1.wav",
		"houndeye/he_blast2.wav",
		"houndeye/he_blast3.wav"
	};
	
	const array<string> pFollowSounds =
	{
		"aslave/slv_word1.wav",
		"aslave/slv_word2.wav",
		"aslave/slv_word5.wav",
		"aslave/slv_word7.wav"
	};
	
	const array<string> pStopFollowSounds =
	{
		"aslave/slv_word3.wav",
		"aslave/slv_word4.wav",
		"aslave/slv_word6.wav",
		"aslave/slv_word8.wav"
	};
	
	float GetVortEmpCvarValue(const string cvarName, float defaultValue)
	{
		float value = g_EngineFuncs.CVarGetFloat(cvarName);
		
		if ( value <= 0 )
			value = defaultValue;
			
		return value;
	}

	float GetVortEmpHealth()
	{
		return GetVortEmpCvarValue( "sk_islave_health", g_EngineFuncs.CVarGetFloat( "sk_islave_health" ) * 0.75 );	// Have less health than normal Vortigaunts.
	}

	float GetVortEmpClawDmg()
	{
		return GetVortEmpCvarValue( "sk_islave_dmg_claw", g_EngineFuncs.CVarGetFloat( "sk_islave_dmg_claw" ) );
	}

	float GetVortEmpClawRakeDmg()
	{
		return GetVortEmpCvarValue( "sk_islave_dmg_clawrake", g_EngineFuncs.CVarGetFloat( "sk_islave_dmg_clawrake" ) );
	}

	float GetVortEmpZapDmg()
	{
		return GetVortEmpCvarValue( "sk_islave_dmg_zap", g_EngineFuncs.CVarGetFloat( "sk_islave_dmg_zap" ) * 0.5 );	// Deals less damage, but they charge fast!
	}

	float GetVortEmpZapSpeed()
	{
		float zapSpeed = GetVortEmpCvarValue( "sk_islave_speed_zap", g_EngineFuncs.CVarGetFloat( "sk_islave_speed_zap" ) * 1.2 );
		zapSpeed *= 1.25;
		zapSpeed = Math.min(1.5, zapSpeed);
		return zapSpeed;
	}

	float GetVortEmpSonicDmg()
	{
		return GetVortEmpCvarValue( "sk_tor_sonicblast", g_EngineFuncs.CVarGetFloat( "sk_tor_sonicblast" ) );	// Fitting damage value.
	}
	
	void InitSchedules()
	{
		slSlaveEmpAttack1.AddTask(ScriptTask(TASK_STOP_MOVING, 0));
		slSlaveEmpAttack1.AddTask(ScriptTask(TASK_FACE_IDEAL, 0));
		slSlaveEmpAttack1.AddTask(ScriptTask(TASK_RANGE_ATTACK1, 0));

		slSlaveEmpHealOrReviveAttack.AddTask(ScriptTask(TASK_STOP_MOVING, 0));
		slSlaveEmpHealOrReviveAttack.AddTask(ScriptTask(TASK_MOVE_TO_TARGET_RANGE, 128));
		slSlaveEmpHealOrReviveAttack.AddTask(ScriptTask(TASK_FACE_TARGET, 0));
		slSlaveEmpHealOrReviveAttack.AddTask(ScriptTask(TASK_ISLAVE_EMPOWERED_HEAL_OR_REVIVE_ATTACK, 0));

		slSlaveEmpCoverAndSummon.AddTask(ScriptTask(TASK_STOP_MOVING, 0));
		slSlaveEmpCoverAndSummon.AddTask(ScriptTask(TASK_WAIT, 0.1));
		slSlaveEmpCoverAndSummon.AddTask(ScriptTask(TASK_FIND_COVER_FROM_ENEMY, 0));
		slSlaveEmpCoverAndSummon.AddTask(ScriptTask(TASK_RUN_PATH, 0));
		slSlaveEmpCoverAndSummon.AddTask(ScriptTask(TASK_WAIT_FOR_MOVEMENT, 0));
		slSlaveEmpCoverAndSummon.AddTask(ScriptTask(TASK_REMEMBER, bits_MEMORY_INCOVER));
		slSlaveEmpCoverAndSummon.AddTask(ScriptTask(TASK_FACE_ENEMY, 0));
		slSlaveEmpCoverAndSummon.AddTask(ScriptTask(TASK_ISLAVE_EMPOWERED_SUMMON_FAMILIAR, 0));

		slSlaveEmpSummon.AddTask(ScriptTask(TASK_STOP_MOVING, 0));
		slSlaveEmpSummon.AddTask(ScriptTask(TASK_FACE_ENEMY, 0));
		slSlaveEmpSummon.AddTask(ScriptTask(TASK_ISLAVE_EMPOWERED_SUMMON_FAMILIAR, 0));

		slRetreatFromEnemy.AddTask(ScriptTask(TASK_SET_FAIL_SCHEDULE, SCHED_RETREAT_FROM_ENEMY_FAILED));
		slRetreatFromEnemy.AddTask(ScriptTask(TASK_STOP_MOVING, 0));
		slRetreatFromEnemy.AddTask(ScriptTask(TASK_WAIT, 0.1));
		slRetreatFromEnemy.AddTask(ScriptTask(TASK_FIND_COVER_FROM_ENEMY, 0));
		slRetreatFromEnemy.AddTask(ScriptTask(TASK_RUN_PATH, 0));
		slRetreatFromEnemy.AddTask(ScriptTask(TASK_WAIT_FOR_MOVEMENT, 0));
		slRetreatFromEnemy.AddTask(ScriptTask(TASK_REMEMBER, bits_MEMORY_INCOVER));
		slRetreatFromEnemy.AddTask(ScriptTask(TASK_FACE_ENEMY, 0));
		slRetreatFromEnemy.AddTask(ScriptTask(TASK_WAIT, 0.5));

		array<ScriptSchedule@> scheds = {slSlaveEmpAttack1, slSlaveEmpHealOrReviveAttack, slSlaveEmpCoverAndSummon, slSlaveEmpSummon};
		@monster_alien_slave_empowered_schedules = @scheds;
	}

	class CISlaveEmpowered : ScriptBaseMonsterEntity
	{
		array<CBeam@> m_pBeam(ISLAVE_EMPOWERED_MAX_BEAMS);
		
		int m_iBeams, m_voicePitch, m_clawStrikeNum, m_iLightningTexture, m_iTrailTexture, m_iSpriteTexture;
		float m_flNextAttack, m_freeEnergy, m_nextHealTargetCheck, m_originalMaxHealth, m_flSpawnFamiliarTime, m_attackDistance;

		EHandle m_hDead, m_hWounded, m_hWounded2;
		CSprite@ m_handGlow1, m_handGlow2;
		CBeam@ m_handsBeam1, m_handsBeam2;
		
		CISlaveEmpowered()
		{
			@this.m_Schedules = @monster_alien_slave_empowered_schedules;
			
			for( int i = 0; i < ISLAVE_EMPOWERED_MAX_BEAMS; i++ )
			{
				@m_pBeam[i] = null;
			}
		}
		
		void Spawn()
		{
			Precache();
			
			// Added Classic Mode Support.
			if ( !self.SetupModel() )
			{
				if ( string( self.pev.model ).IsEmpty() )
				{
					if ( g_ClassicMode.IsEnabled() )
						g_EntityFuncs.SetModel( self, ISLAVE_EMPOWERED_MODEL_CLASSIC );
					else
						g_EntityFuncs.SetModel( self, ISLAVE_EMPOWERED_MODEL );
				}
			}
			
			g_EntityFuncs.SetSize( self.pev, VEC_HUMAN_HULL_MIN, VEC_HUMAN_HULL_MAX );

			pev.solid = SOLID_SLIDEBOX;
			pev.movetype = MOVETYPE_STEP;
			
			if ( self.m_bloodColor == 0 )
				self.m_bloodColor = BLOOD_COLOR_GREEN;
			
			pev.effects = 0;
			
			if ( self.pev.health == 0.0f )
				self.pev.health = g_EngineFuncs.CVarGetFloat( "sk_islave_health" ) * 0.75;	//GetVortEmpHealth();
			
			pev.view_ofs = Vector( 0, 0, 64 );// position of the eyes relative to monster's origin.
			self.m_flFieldOfView = VIEW_FIELD_WIDE; // NOTE: we need a wide field of view so npc will notice player and say hello
			self.m_MonsterState = MONSTERSTATE_NONE;
			self.m_afCapability = bits_CAP_HEAR | bits_CAP_TURN_HEAD | bits_CAP_RANGE_ATTACK2 | bits_CAP_DOORS_GROUP | bits_CAP_SQUAD;

			m_voicePitch = Math.RandomLong( 115, 125 );

			@m_handGlow1 = CreateHandGlow(1);
			@m_handGlow2 = CreateHandGlow(2);
			HandsGlowOff();

			if ( self.IsPlayerAlly() )
			{ 
				SetUse( UseFunction( this.FollowerUse ) );
				self.CanPlayerFollow();
			}
			
			self.MonsterInit();

			m_originalMaxHealth = pev.max_health;
			self.m_flDistTooFar = Math.max( m_attackDistance, self.m_flDistTooFar );

			// leader starts with some energy pool
			// TO DO: Be able to replenish energy on the fly due to their empowered status.
			if ( m_freeEnergy <= 0 && ( pev.spawnflags & SF_SQUADMONSTER_LEADER ) != 0 )
				m_freeEnergy = pev.max_health;
			else
				m_freeEnergy = pev.max_health / 2;

			if ( string( self.m_FormattedName ).IsEmpty() )
			{
				self.m_FormattedName = "Empowered Vortigaunt";
			}
		}
		
		void Precache()
		{
			BaseClass.Precache();
			
			m_iLightningTexture = g_Game.PrecacheModel( ISLAVE_EMPOWERED_LIGHTNING_SPRITE );
			m_iTrailTexture = g_Game.PrecacheModel( ISLAVE_EMPOWERED_TRAIL_SPRITE );
			m_iSpriteTexture = g_Game.PrecacheModel( ISLAVE_EMPOWERED_SHOCKWAVE_SPRITE );
			
			if ( string( self.pev.model ).IsEmpty() )
			{
				g_Game.PrecacheModel( ISLAVE_EMPOWERED_MODEL_CLASSIC );
				g_Game.PrecacheModel( ISLAVE_EMPOWERED_MODEL );
			}

			g_SoundSystem.PrecacheSound( "debris/zap1.wav" );
			g_SoundSystem.PrecacheSound( "debris/zap4.wav" );
			g_SoundSystem.PrecacheSound( "debris/beamstart1.wav" );
			g_SoundSystem.PrecacheSound( "debris/beamstart7.wav" );
			g_SoundSystem.PrecacheSound( "weapons/electro4.wav" );
			g_SoundSystem.PrecacheSound( "hassault/hw_shoot1.wav" );
			g_SoundSystem.PrecacheSound( "zombie/zo_pain2.wav" );
			g_SoundSystem.PrecacheSound( "headcrab/hc_headbite.wav" );
			g_SoundSystem.PrecacheSound( "weapons/cbar_miss1.wav" );
			g_SoundSystem.PrecacheSound( "aslave/slv_word5.wav" );
			g_SoundSystem.PrecacheSound( "aslave/slv_word7.wav" );

			PrecacheSoundArray( pAttackHitSounds );
			PrecacheSoundArray( pAttackMissSounds );
			PrecacheSoundArray( pPainSounds );
			PrecacheSoundArray( pDeathSounds );
			PrecacheSoundArray( pGlowArmSounds );
			PrecacheSoundArray( pSonicWaveSounds );
			PrecacheSoundArray( pFollowSounds );
			PrecacheSoundArray( pStopFollowSounds );
			
			g_Game.PrecacheModel( ISLAVE_EMPOWERED_HAND_SPRITE_NAME );
			g_Game.PrecacheModel( ISLAVE_EMPOWERED_SPAWNFAMILIAR_SPRITE );
			
			g_Game.PrecacheOther( "monster_snark" );
			g_Game.PrecacheOther( "monster_headcrab" );
		}
		
		void FollowerUse( CBaseEntity@ pActivator, CBaseEntity@ pCaller, USE_TYPE useType, float flValue )
		{
			self.FollowerPlayerUse( pActivator, pCaller, useType, flValue );
			
			CBaseEntity@ pTarget = self.m_hTargetEnt;
			
			if ( pTarget is pActivator )
				FollowSound();
			else
				StopFollowSound();
		}
		
		bool KeyValue( const string& in szKey, const string& in szValue )
		{
			if ( szKey == "energy" )
			{
				m_freeEnergy = atof( szValue );
				return true;
			}
			else if ( szKey == "attack_distance" )
			{
				//g_Game.AlertMessage(at_console, "Setting attack distance to %1\n", szValue);
				m_attackDistance = atof( szValue );
				
				return true;
			}
			else
				return BaseClass.KeyValue( szKey, szValue );
		}
		
		void UpdateOnRemove()
		{
			ClearBeams();
			RemoveHandGlows();

			BaseClass.UpdateOnRemove();
		}
		
		void SetYawSpeed()
		{
			int ys;
			
			switch( self.m_Activity )
			{
				case ACT_WALK:		
					ys = 100;	
					break;
				case ACT_RUN:		
					ys = 140;
					break;
				case ACT_IDLE:		
					ys = 50;
					break;
				default:
					ys = 240;
					break;
			}
			
			pev.yaw_speed = ys * 2.5; // multiply as monsters in SC tend to have higher yaw speeds than in HL
		}
		
		int ISoundMask()
		{
			return bits_SOUND_WORLD | bits_SOUND_COMBAT | bits_SOUND_DANGER | bits_SOUND_PLAYER;
		}
		
		int Classify()
		{
			// player ally override
			if ( self.IsPlayerAlly() )
				return CLASS_PLAYER_ALLY;
			
			if ( self.m_fOverrideClass )
				return self.m_iClassSelection;
			
			return CLASS_ALIEN_MILITARY;	// By default, keep it as is. For Insecure, they'll be set to a team hostile to all but themselves.
		}

		int ObjectCaps()
		{
			if ( self.IsPlayerAlly() )
				return FCAP_IMPULSE_USE;
			else
				return BaseClass.ObjectCaps();
		}
		
		CBaseEntity@ VortEmpCheckTraceHullAttack( float flDist, float iDamage, int iDmgType )
		{
			TraceResult tr;
			Math.MakeAimVectors( pev.angles );

			Vector vecStart = pev.origin;
			vecStart.z += pev.size.z * 0.5;
			Vector vecEnd = vecStart + ( g_Engine.v_forward * flDist );

			g_Utility.TraceHull( vecStart, vecEnd, dont_ignore_monsters, head_hull, self.edict(), tr );

			if ( tr.pHit !is null )
			{
				CBaseEntity@ pEntity = g_EntityFuncs.Instance( tr.pHit );

				if ( iDamage > 0 )
				{
					pEntity.TakeDamage( pev, pev, iDamage, iDmgType );
				}
				return pEntity;
			}

			return null;
		}
		
		//=========================================================
		// HandleAnimEvent - catches the monster-specific messages
		// that occur when tagged animation frames are played.
		//
		// Returns number of events handled, 0 if none.
		//=========================================================
		void HandleAnimEvent( MonsterEvent@ pEvent )
		{
			switch( pEvent.event )
			{
				case ISLAVE_EMPOWERED_AE_ZAP_POWERUP:
				{
					// speed up attack depending on difficulty level
					pev.framerate = g_EngineFuncs.CVarGetFloat( "sk_islave_speed_zap" ) * 2;	//GetVortEmpZapSpeed();

					Math.MakeAimVectors( pev.angles );

					if ( m_iBeams == 0 )
					{
						Vector vecSrc = pev.origin + g_Engine.v_forward * 2;
						MakeDynamicLight(vecSrc, 12, int(20/pev.framerate));
					}
					
					if ( CanRevive() )
					{
						WackBeam( ISLAVE_EMPOWERED_LEFT_ARM, m_hDead );
						WackBeam( ISLAVE_EMPOWERED_RIGHT_ARM, m_hDead );
					}
					else
					{
						ArmBeam( ISLAVE_EMPOWERED_LEFT_ARM );
						ArmBeam( ISLAVE_EMPOWERED_RIGHT_ARM );
						
						BeamGlow();
					}
					
					g_SoundSystem.EmitSoundDyn( self.edict(), CHAN_WEAPON, "debris/zap4.wav", 1, ATTN_NORM, 0, 100 + m_iBeams * 10 );
				}
				
				break;
				
				case ISLAVE_EMPOWERED_AE_SONIC_ATTACK:
				{
					SonicAttack();
					SonicEffect();
				}
				
				break;
				
				case ISLAVE_EMPOWERED_AE_ZAP_SHOOT:
				{
					ClearBeams();
					
					if ( ( CanRevive() ) && ( m_freeEnergy >= pev.max_health * 0.25 ) )	//Can only revive fallen comrades if energy reserves are at 25% and above.
					{
						if ( ( CanBeRevived( m_hDead ) ) && ( m_freeEnergy >= pev.max_health * 0.25 ) )
						{
							self.Forget( bits_MEMORY_ISLAVE_EMPOWERED_LAST_ATTACK_WAS_COIL );

							CBaseEntity@ revived = m_hDead.GetEntity();
							
							if ( revived !is null )
							{
								CBaseMonster@ monster = revived.MyMonsterPointer();
								
								if ( monster !is null )
								{
									ScriptBaseMonsterEntity@ scriptedMonster = cast<ScriptBaseMonsterEntity@>( CastToScriptClass( monster ) );
									CISlaveEmpowered@ revivedVort = cast<CISlaveEmpowered>(scriptedMonster);
									
									if ( revivedVort !is null )
									{
										monster.pev.health = revivedVort.m_originalMaxHealth;
										// TODO: should restore the actual values that the vort had before he died
										monster.pev.rendermode = kRenderNormal;
										monster.pev.renderamt = 255;
										@monster.pev.owner = null; // nullify owner to avoid additional DeathNotice calls
										monster.Revive();
										monster.pev.health = monster.pev.max_health;
										monster.Remember( bits_MEMORY_ISLAVE_EMPOWERED_REVIVED );

										if ( self.m_hEnemy.IsValid() )
										{
											monster.PushEnemy( self.m_hEnemy, self.m_vecEnemyLKP );
										}

										// revived vort starts with zero energy
										revivedVort.m_freeEnergy = 0;
									}
								}

								WackBeam( ISLAVE_EMPOWERED_LEFT_ARM, revived );
								WackBeam( ISLAVE_EMPOWERED_RIGHT_ARM, revived );
								m_hDead = null;
								g_SoundSystem.EmitSoundDyn( self.edict(), CHAN_WEAPON, "hassault/hw_shoot1.wav", 1, ATTN_NORM, 0, Math.RandomLong( 130, 160 ) );
								
								// Instead of waiting another 10 seconds to revive their fallen comrades.
								// They spend 25% energy to revive their fallen comrades.
								// They must now deal as much as damage to their targets to revive more if there are any available.
								SpendEnergy(pev.max_health * 0.25);
							}
							break;
						}
						else
						{
							//ALERT(at_aiconsole, "Trace failed on revive\n");
						}
					}
				
					g_WeaponFuncs.ClearMultiDamage();
					
					self.Forget(bits_MEMORY_ISLAVE_EMPOWERED_LAST_ATTACK_WAS_COIL);
					Math.MakeAimVectors( pev.angles );

					ZapBeam( ISLAVE_EMPOWERED_LEFT_ARM );
					ZapBeam( ISLAVE_EMPOWERED_RIGHT_ARM );
					
					g_SoundSystem.EmitSoundDyn( self.edict(), CHAN_WEAPON, "hassault/hw_shoot1.wav", 1, ATTN_NORM, 0, Math.RandomLong( 130, 160 ) );

					g_WeaponFuncs.ApplyMultiDamage( pev, pev );

					m_flNextAttack = g_Engine.time + 1.0; // 1 second zap
				}
				
				break;
				
				case ISLAVE_EMPOWERED_AE_ZAP_DONE:
				{
					ClearBeams();
				}
				
				break;
				
				default:
					BaseClass.HandleAnimEvent( pEvent );
				break;
			}
		}
		
		//=========================================================
		// CheckRangeAttack1 - normal beam attack
		//=========================================================
		bool CheckRangeAttack1( float flDot, float flDist )
		{
			if ( m_flNextAttack > g_Engine.time)
			{
				return false;
			}
			
			if ( flDist > 64 && flDist <= Math.max( m_attackDistance, 1536 ) && flDot >= 0.5 )
			{
				return true;
			}
			
			return false;
		}
		
		//=========================================================
		// CheckRangeAttack2 - check bravery and try to resurect dead comrades
		//=========================================================
		bool CheckRangeAttack2( float flDot, float flDist )
		{
			if ( m_flNextAttack > g_Engine.time )
			{
				return false;
			}
			
			return HasFreeEnergy() && CheckHealOrReviveTargets(flDist, true);
		}
	
		bool CheckHealOrReviveTargets( float flDist = 1536, bool mustSee = true )
		{
			if ( m_nextHealTargetCheck >= g_Engine.time )
			{
				return m_hDead.GetEntity() !is null || m_hWounded.GetEntity() !is null;
			}

			m_nextHealTargetCheck = g_Engine.time + 1;
			m_hDead = null;
			m_hWounded = null;
			m_hWounded2 = null;

			CBaseEntity@ pEntity = null;
			
			while( ( @pEntity = g_EntityFuncs.FindEntityByClassname( pEntity, self.GetClassname() ) ) != null )
			{
				if ( self.IRelationship(pEntity) >= R_DL )
					continue;
				
				TraceResult tr;

				g_Utility.TraceLine( self.EyePosition(), pEntity.EyePosition(), ignore_monsters, dont_ignore_glass, self.edict(), tr );
				
				if ( ( mustSee && ( tr.flFraction == 1.0f || tr.pHit is pEntity.edict() ) ) || ( !mustSee && ( pEntity.pev.origin - pev.origin ).Length() < flDist ) )
				{
					if ( AbleToRevive() && CanBeRevived(pEntity) )
					{
						float d = ( pev.origin - pEntity.pev.origin ).Length();
						
						if ( d < flDist )
						{
							m_hDead = pEntity;
							flDist = d;
						}
					}
					
					if ( AbleToHeal() && IsValidHealTarget(pEntity) )
					{
						float d = ( pev.origin - pEntity.pev.origin ).Length();
						
						if ( d < flDist )
						{
							m_hWounded2 = m_hWounded;
							m_hWounded = pEntity;
							flDist = d;
						}
					}
				}
			}
			
			return m_hDead.GetEntity() !is null || m_hWounded.GetEntity() !is null;
		}

		//=========================================================
		// CheckMeleeAttack2 - sonic wave attack
		//=========================================================
		bool CheckMeleeAttack1( float flDot, float flDist )
		{
			if ( !self.HasConditions( bits_COND_CAN_RANGE_ATTACK1 ) )
			{
				if ( flDist <= 192 && flDot >= 0.7 )
				{
					return true;
				}
			}
			
			return false;
		}
	
		bool IsValidHealTarget( CBaseEntity@ pEntity )
		{
			return pEntity !is null && pEntity != self && pEntity.IsAlive() && pEntity.pev.health > 0 && IsVortEmpWounded(pEntity);
		}
	
		void CallForHelp( float flDist, EHandle hEnemy, const Vector& in vecLocation )
		{
			if ( pev.netname == "" )
				return;

			CBaseEntity@ pEntity = null;

			while ( ( @pEntity = g_EntityFuncs.FindEntityByString( pEntity, "netname", pev.netname ) ) != null )
			{
				float d = ( pev.origin - pEntity.pev.origin ).Length();
				
				if ( d < flDist )
				{
					if ( pEntity.GetClassname() != self.GetClassname() )
						continue;
						
					CBaseMonster@ pMonster = pEntity.MyMonsterPointer();
					
					if ( pMonster !is null )
					{
						pMonster.m_afMemory |= bits_MEMORY_ISLAVE_EMPOWERED_PROVOKED;
						pMonster.PushEnemy( hEnemy, vecLocation );
					}
				}
			}
		}
		
		void TraceAttack( entvars_t@ pevAttacker, float flDamage, const Vector& in vecDir, TraceResult& in ptr, int bitsDamageType )
		{
			if ( ( bitsDamageType & DMG_ENERGYBEAM ) != 0 )
			{
				if ( pevAttacker is null )
					return;
					
				CBaseEntity@ pAttacker = g_EntityFuncs.Instance( pevAttacker );
				
				if ( pAttacker !is null && self.IRelationship( pAttacker ) == R_AL )
					return;
			}
			
			if ( ( bitsDamageType == DMG_BURN ) )
			{
				flDamage = flDamage / 10;
			}

			// Don't take any acid damage -- BigMomma's mortar is acid
			if ( ( bitsDamageType & DMG_ACID ) != 0 )
			{
				if ( pevAttacker is null )
					return;
					
				CBaseEntity@ pAttacker = g_EntityFuncs.Instance( pevAttacker );
				
				if ( pAttacker !is null && self.IRelationship( pAttacker ) == R_AL )
					return;
			}

			BaseClass.TraceAttack( pevAttacker, flDamage, vecDir, ptr, bitsDamageType );
		}


//// TakeDamage edited

		int TakeDamage(entvars_t@ pevInflictor, entvars_t@ pevAttacker, float flDamage, int bitsDamageType)
		{
			CBaseEntity@ pAttacker = g_EntityFuncs.Instance(pevAttacker);

			if (pAttacker !is null)
			{
				// if attacker is player
				if (pAttacker.IsPlayer())
				{
					return BaseClass.TakeDamage(pevInflictor, pevAttacker, flDamage, bitsDamageType);
				}
				else
				{
				// if attacker is other than player filter damage by 30%
				float reducedDamage = flDamage * 0.3f;
				return BaseClass.TakeDamage(pevInflictor, pevAttacker, reducedDamage, bitsDamageType);
				}
			}

			// if attacker is null
			return BaseClass.TakeDamage(pevInflictor, pevAttacker, flDamage, bitsDamageType);
		}

		float GetPointsForDamage( float flDamage )
		{
			return ( flDamage / self.pev.max_health ) * ( 2.5 );
		}
		
		void DeathSound()
		{
			g_SoundSystem.EmitSoundDyn( self.edict(), CHAN_VOICE, RandomSoundFromArray( pDeathSounds ), 1.0, ATTN_NORM, 0, m_voicePitch );
		}
		
		void PainSound()
		{
			if ( Math.RandomLong( 0, 2 ) == 0 )
			{
				g_SoundSystem.EmitSoundDyn( self.edict(), CHAN_VOICE, RandomSoundFromArray( pPainSounds ), 1.0, ATTN_NORM, 0, m_voicePitch );
			}
		}
	
		void AlertSound()
		{
			if ( self.m_hEnemy.GetEntity() !is null )
			{
				g_SoundSystem.PlaySentenceGroup( self.edict(), "SLV_ALERT", 0.85, ATTN_NORM, 0, m_voicePitch );
				CallForHelp( 512, self.m_hEnemy, self.m_vecEnemyLKP );
			}
		}
		
		void IdleSound()
		{
			if ( Math.RandomLong( 0, 2 ) == 0 )
				g_SoundSystem.PlaySentenceGroup( self.edict(), "SLV_IDLE", 0.85, ATTN_NORM, 0, m_voicePitch );
			
			if ( Math.RandomLong( 0, 20 ) == 0 )
			{
				int side = Math.RandomLong( 0, 1 ) * 2 - 1;

				ArmBeamMessage( side );

				Math.MakeAimVectors( pev.angles );
				Vector vecSrc = pev.origin + g_Engine.v_right * 2 * side;
				MakeDynamicLight(vecSrc, 8, 10);

				g_SoundSystem.EmitSoundDyn( self.edict(), CHAN_WEAPON, "debris/zap1.wav", 1, ATTN_NORM, 0, 100 );
			}
		}
		
		void FollowSound()
		{
			g_SoundSystem.EmitSoundDyn( self.edict(), CHAN_VOICE, RandomSoundFromArray( pFollowSounds ), 1.0, ATTN_NORM, 0, m_voicePitch );
		}
		
		void StopFollowSound()
		{
			g_SoundSystem.EmitSoundDyn( self.edict(), CHAN_VOICE, RandomSoundFromArray( pStopFollowSounds ), 1.0, ATTN_NORM, 0, m_voicePitch );
		}
		
		//Cannot be gibbed by any means on death. Can still be removed from a Displacer though.
		void Killed(entvars_t@ pevAttacker, int iGib)
		{
			ClearBeams();
			RemoveHandGlows();
			
			BaseClass.Killed( pevAttacker, GIB_NEVER );
		}

		void DeathNotice( entvars_t@ pevChild )
		{
			self.Forget(bits_MEMORY_ISLAVE_EMPOWERED_FAMILIAR_IS_ALIVE);
		}
	
		//=========================================================
		// StartTask
		//=========================================================
		void StartTask( Task@ pTask )
		{
			ClearBeams();
			
			switch(pTask.iTask)
			{
				case TASK_ISLAVE_EMPOWERED_SUMMON_FAMILIAR:
				{
					if ( CanSpawnAtPosition( GetFamiliarSpawnPosition(), FamiliarHull(), self.edict() ) )
					{
						self.m_IdealActivity = ACT_CROUCH;
						g_SoundSystem.EmitSound( self.edict(), CHAN_BODY, "debris/beamstart1.wav", 1, ATTN_NORM );
						Math.MakeAimVectors( pev.angles );
						Vector vecSrc = pev.origin + g_Engine.v_forward * 8;
						MakeDynamicLight(vecSrc, 10, 15);
						HandsGlowOn();
						CreateSummonBeams();
					}
					else
					{
						m_flSpawnFamiliarTime = g_Engine.time + ISLAVE_EMPOWERED_SPAWNFAMILIAR_DELAY; // still set delay to avoid constant trying
						self.TaskFail();
					}
					
					break;
				}
				
				case TASK_ISLAVE_EMPOWERED_HEAL_OR_REVIVE_ATTACK:
				{
					g_Game.AlertMessage(at_aiconsole, "start TASK_ISLAVE_EMPOWERED_HEAL_OR_REVIVE_ATTACK\n");
					self.m_IdealActivity = ACT_RANGE_ATTACK1;
					break;
				}
				
				case TASK_WAIT_FOR_MOVEMENT:
					// a hack to prevent vortigaunts running with beams caused by dangling events from the attack animation
					self.m_IdealActivity = ACT_IDLE;
					BaseClass.StartTask( pTask );
				case TASK_MELEE_ATTACK1:
					m_clawStrikeNum = 0;
					BaseClass.StartTask( pTask );
				default:
					BaseClass.StartTask( pTask );
					break;
			}
		}
		
		void RunTask( Task@ pTask )
		{
			switch( pTask.iTask )
			{
				case TASK_ISLAVE_EMPOWERED_SUMMON_FAMILIAR:
					if ( self.m_fSequenceFinished )
					{
						SpawnFamiliar(FamiliarName(), GetFamiliarSpawnPosition(), FamiliarHull());
						HandsGlowOff();
						self.TaskComplete();
						RemoveSummonBeams();
					}
					
					break;
				case TASK_ISLAVE_EMPOWERED_HEAL_OR_REVIVE_ATTACK:
					if ( self.m_fSequenceFinished )
					{
						self.m_Activity = ACT_RESET;
						self.TaskComplete();
					}
					
					break;
				default:
					BaseClass.RunTask( pTask );
					break;
			}
		}
		
		void RunAI()
		{
			if ( self.m_Activity == ACT_MELEE_ATTACK1 && m_clawStrikeNum == 0 )
			{
				if ( m_handGlow1 !is null && (m_handGlow1.pev.effects & EF_NODRAW) != 0 && CanUseGlowArms() )
				{
					StartMeleeAttackGlow(ISLAVE_EMPOWERED_RIGHT_ARM);
					g_SoundSystem.EmitSoundDyn( self.edict(), CHAN_BODY, RandomSoundFromArray(pGlowArmSounds), Math.RandomFloat(0.6, 0.8), ATTN_NORM, 0, Math.RandomLong(70, 90) );
				}
			}
			
			if ( ( self.m_MonsterState == MONSTERSTATE_IDLE ) && Math.RandomLong( 0, 25 ) == 0 )
				IdleSound();
			else if ( ( self.m_MonsterState == MONSTERSTATE_ALERT ) && Math.RandomLong( 0, 50 ) == 0 )
				IdleSound();
			
			BaseClass.RunAI();
		}
	
		void SpawnFamiliar(string entityName, const Vector& in origin, HULL_NUMBER hullType)
		{
			if ( entityName.IsEmpty() )
			{
				g_Game.AlertMessage(at_console, "Null familiar name in SpawnFamiliar!\n");
				return;
			}
			
			if ( CanSpawnAtPosition(origin, hullType, self.edict() ) )
			{
				CBaseEntity@ pNew = g_EntityFuncs.Create( entityName, origin, pev.angles, false, self.edict() );

				if ( pNew !is null )
				{
					CBaseMonster@ pNewMonster = pNew.MyMonsterPointer();

					self.Remember( bits_MEMORY_ISLAVE_EMPOWERED_FAMILIAR_IS_ALIVE );
					
					CSprite@ pSpr = g_EntityFuncs.CreateSprite( ISLAVE_EMPOWERED_SPAWNFAMILIAR_SPRITE, origin, true );
					
					if ( pSpr !is null )
					{
						pSpr.pev.spawnflags |= 4;
						pSpr.pev.framerate = 20.0f;
						
						pSpr.SetTransparency( kRenderTransAdd, ISLAVE_EMPOWERED_ARMBEAM_RED, ISLAVE_EMPOWERED_ARMBEAM_GREEN, ISLAVE_EMPOWERED_ARMBEAM_BLUE, 255, kRenderFxNoDissipation );
					}
					
					g_SoundSystem.EmitSound( pNew.edict(), CHAN_BODY, "debris/beamstart7.wav", 0.9, ATTN_NORM );

					pNew.pev.spawnflags |= SF_MONSTER_FALL_TO_GROUND;
					
					if ( pNewMonster !is null )
					{
						if ( self.m_fOverrideClass )
							pNewMonster.m_iClassSelection = self.m_iClassSelection;
							
						if ( self.m_hEnemy )
							pNewMonster.PushEnemy(self.m_hEnemy, self.m_vecEnemyLKP);
					}
				}
			}
			else
				g_Game.AlertMessage(at_aiconsole, "Not enough room to create %1\n", entityName);

			m_flSpawnFamiliarTime = g_Engine.time + ISLAVE_EMPOWERED_SPAWNFAMILIAR_DELAY;
		}

		Schedule@ GetSchedule()
		{
			if ( self.HasConditions( bits_COND_HEAR_SOUND ) )
			{
				CSound@ pSound = self.PBestSound();
				if ( pSound !is null )
				{
					if ( (pSound.m_iType & bits_SOUND_DANGER) != 0 )
						return GetScheduleOfType( SCHED_TAKE_COVER_FROM_BEST_SOUND );
					
					if ( (pSound.m_iType & bits_SOUND_COMBAT) != 0 )
						self.Remember( bits_MEMORY_ISLAVE_EMPOWERED_PROVOKED );
				}
			}

			switch( self.m_MonsterState )
			{
				case MONSTERSTATE_COMBAT:
					// dead enemy
					if ( self.HasConditions( bits_COND_ENEMY_DEAD ) )
					{
						// call base class, all code to handle dead enemies is centralized there.
						return BaseClass.GetSchedule();
					}

					if ( IsVortEmpWounded(self) )
					{
						if ( !self.HasConditions( bits_COND_CAN_MELEE_ATTACK1 ) )
						{
							const int sched = CanSpawnFamiliar() ? int( SCHED_ISLAVE_EMPOWERED_COVER_AND_SUMMON_FAMILIAR ) : int( SCHED_RETREAT_FROM_ENEMY );

							if ( self.HasConditions( bits_COND_LIGHT_DAMAGE | bits_COND_HEAVY_DAMAGE ) )
							{
								return GetScheduleOfType( sched );
							}
							
							if ( self.HasConditions( bits_COND_SEE_ENEMY ) && self.HasConditions( bits_COND_ENEMY_FACING_ME ) )
							{
								return GetScheduleOfType( sched );
							}
						}
					}
					
					break;
				case MONSTERSTATE_ALERT:
				case MONSTERSTATE_IDLE:
				case MONSTERSTATE_HUNT:
				{
					if ( !self.HasConditions( bits_COND_NEW_ENEMY | bits_COND_SEE_ENEMY ) ) // ensure there's no enemy
					{
						if ( HasFreeEnergy() && CheckHealOrReviveTargets() )
						{
							SetHealTargetAsTargetEnt();
							
							if ( CanGoToTargetEnt() )
							{
								g_Game.AlertMessage(at_aiconsole, "Vortigaunt gonna heal or revive friend when idle. State is %1\n", self.m_MonsterState == MONSTERSTATE_ALERT ? "alert" : "idle");
								
								return GetScheduleOfType( SCHED_ISLAVE_EMPOWERED_HEAL_OR_REVIVE );
							}
						}
					}
					
					break;
				}
				default:
					break;
			}
			
			return BaseClass.GetSchedule();
		}
	
		Schedule@ GetScheduleOfType( int Type )
		{
			switch( Type )
			{
				case SCHED_FAIL:
					if ( self.HasConditions( bits_COND_CAN_MELEE_ATTACK1 ) )
					{
						return BaseClass.GetScheduleOfType( SCHED_MELEE_ATTACK1 );
					}
				case SCHED_CHASE_ENEMY_FAILED:
					if ( HasFreeEnergy() && CheckHealOrReviveTargets() )
					{
						SetHealTargetAsTargetEnt();
						
						if ( CanGoToTargetEnt() )
						{
							g_Game.AlertMessage(at_aiconsole, "Vortigaunt gonna heal or revive friends after chase enemy schedule fail\n");
							return GetScheduleOfType( SCHED_ISLAVE_EMPOWERED_HEAL_OR_REVIVE );
						}
					}
					
					else if ( self.m_MonsterState == MONSTERSTATE_COMBAT && !self.HasConditions(bits_COND_ENEMY_TOOFAR) && CanSpawnFamiliar() )
						return GetScheduleOfType( SCHED_ISLAVE_EMPOWERED_SUMMON_FAMILIAR );
					
					break;
					
				case SCHED_RANGE_ATTACK1:
					return slSlaveEmpAttack1;
				case SCHED_RANGE_ATTACK2:
					return slSlaveEmpAttack1;
				case SCHED_ISLAVE_EMPOWERED_COVER_AND_SUMMON_FAMILIAR:
					return slSlaveEmpCoverAndSummon;
				case SCHED_ISLAVE_EMPOWERED_SUMMON_FAMILIAR:
					return slSlaveEmpSummon;
				case SCHED_ISLAVE_EMPOWERED_HEAL_OR_REVIVE:
					return slSlaveEmpHealOrReviveAttack;
				case SCHED_RETREAT_FROM_ENEMY:
					return slRetreatFromEnemy;
				case SCHED_RETREAT_FROM_ENEMY_FAILED:
				{
					if ( self.HasConditions( bits_COND_CAN_RANGE_ATTACK1 ) && self.HasConditions( bits_COND_SEE_ENEMY ) )
					{
						return GetScheduleOfType(SCHED_RANGE_ATTACK1);
					}
				}
				
				return BaseClass.GetScheduleOfType(SCHED_FAIL);
			}
			
			return BaseClass.GetScheduleOfType( Type );
		}
	
		void ClearBeams()
		{
			for ( int i = 0; i < ISLAVE_EMPOWERED_MAX_BEAMS; i++ )
			{
				if( m_pBeam[i] !is null )
				{
					m_pBeam[i].SUB_Remove();
					@m_pBeam[i] = null;
				}
			}
			
			m_iBeams = 0;

			HandsGlowOff();
			RemoveSummonBeams();

			g_SoundSystem.StopSound( self.edict(), CHAN_WEAPON, "debris/zap4.wav" );
		}
		
		void ArmBeam( int side )
		{
			TraceResult tr;
			float flDist = 1.0;

			if( m_iBeams >= ISLAVE_EMPOWERED_MAX_BEAMS )
				return;

			Math.MakeAimVectors( pev.angles );
			Vector vecSrc = HandPosition( side );

			for ( int i = 0; i < 3; i++ )
			{
				Vector vecAim = g_Engine.v_right * side * Math.RandomFloat( 0, 1 ) + g_Engine.v_up * Math.RandomFloat( -1, 1 );
				TraceResult tr1;
				g_Utility.TraceLine( vecSrc, vecSrc + vecAim * 512, dont_ignore_monsters, self.edict(), tr1 );
				
				if ( flDist > tr1.flFraction )
				{
					tr = tr1;
					flDist = tr.flFraction;
				}
			}

			// Couldn't find anything close enough
			if ( flDist == 1.0f )
				return;

			g_WeaponFuncs.DecalGunshot( tr, BULLET_PLAYER_CROWBAR );

			@m_pBeam[m_iBeams] = g_EntityFuncs.CreateBeam( ISLAVE_EMPOWERED_LIGHTNING_SPRITE, 30 );
			
			if ( m_pBeam[m_iBeams] is null )
				return;

			int brightness;
			
			const Vector armBeamColor = GetArmBeamColor(brightness);
			m_pBeam[m_iBeams].PointEntInit( tr.vecEndPos, self.entindex() );
			m_pBeam[m_iBeams].SetEndAttachment( AttachmentFromSide(side) );
			m_pBeam[m_iBeams].SetColor( int( armBeamColor.x ), int( armBeamColor.y ), int( armBeamColor.z ) );
			m_pBeam[m_iBeams].SetBrightness( brightness );
			m_pBeam[m_iBeams].SetNoise( 80 );
			m_iBeams++;
		}
		
		void ArmBeamMessage( int side )
		{
			TraceResult tr;
			float flDist = 1.0;

			Math.MakeAimVectors( pev.angles );
			Vector vecSrc = HandPosition(side);

			for ( int i = 0; i < 3; i++ )
			{
				Vector vecAim = g_Engine.v_right * side * Math.RandomFloat( 0, 1 ) + g_Engine.v_up * Math.RandomFloat( -1, 1 );
				TraceResult tr1;
				g_Utility.TraceLine( vecSrc, vecSrc + vecAim * 512, dont_ignore_monsters, self.edict(), tr1 );
				if( flDist > tr1.flFraction )
				{
					tr = tr1;
					flDist = tr.flFraction;
				}
			}

			// Couldn't find anything close enough
			if ( flDist == 1.0 )
				return;

			int brightness;
			const Vector armBeamColor = GetArmBeamColor(brightness);

			NetworkMessage m(MSG_PVS, NetworkMessages::SVC_TEMPENTITY, vecSrc);
			m.WriteByte( TE_BEAMENTPOINT );
			m.WriteShort( self.entindex() + 0x1000 * (AttachmentFromSide(side)) );
			m.WriteCoord( tr.vecEndPos.x );
			m.WriteCoord( tr.vecEndPos.y );
			m.WriteCoord( tr.vecEndPos.z );
			m.WriteShort( m_iLightningTexture );
			m.WriteByte( 0 ); // framestart
			m.WriteByte( 10 ); // framerate
			m.WriteByte( int( 10 * Math.RandomFloat( 0.8, 1.5 ) ) ); // life
			m.WriteByte( 30 );  // width
			m.WriteByte( 80 );   // noise
			m.WriteByte( int(armBeamColor.x) );   // r, g, b
			m.WriteByte( int(armBeamColor.y) );   // r, g, b
			m.WriteByte( int(armBeamColor.z) );   // r, g, b
			m.WriteByte( brightness );	// brightness
			m.WriteByte( 10 );		// speed
			m.End();
		}
		
		void WackBeam( int side, CBaseEntity@ pEntity )
		{
			if ( m_iBeams >= ISLAVE_EMPOWERED_MAX_BEAMS )
				return;

			if ( pEntity is null )
				return;

			@m_pBeam[m_iBeams] = g_EntityFuncs.CreateBeam( ISLAVE_EMPOWERED_LIGHTNING_SPRITE, 30 );
			
			if ( m_pBeam[m_iBeams] is null )
				return;

			Vector zapColor = GetZapColor();
			m_pBeam[m_iBeams].PointEntInit( pEntity.pev.origin, self.entindex() );
			m_pBeam[m_iBeams].SetEndAttachment( AttachmentFromSide(side) );
			m_pBeam[m_iBeams].SetColor( int( zapColor.x ), int( zapColor.y ), int( zapColor.z ) );
			m_pBeam[m_iBeams].SetBrightness( 255 );
			m_pBeam[m_iBeams].SetNoise( 80 );
			m_iBeams++;
		}
	
		CBaseEntity@ ZapBeam( int side )
		{
			Vector vecSrc, vecAim;
			TraceResult tr;

			if ( m_iBeams >= ISLAVE_EMPOWERED_MAX_BEAMS )
			{
				g_Game.AlertMessage(at_warning, "Vortigaunt didn't zap because too many beams!\n");
				return null;
			}

			vecSrc = pev.origin + g_Engine.v_up * 36;
			
			if ( IsValidHealTarget( m_hWounded ) )
			{
				vecAim = ( ( m_hWounded.GetEntity().BodyTarget( vecSrc ) ) - vecSrc ).Normalize();
				g_Game.AlertMessage(at_aiconsole, "Vortigaunt shoot friend on purpose to heal\n");
			}
			else
			{
				vecAim = self.ShootAtEnemy( vecSrc );
			}

			float deflection = 0.01;
			vecAim = vecAim + side * g_Engine.v_right * Math.RandomFloat( 0, deflection ) + g_Engine.v_up * Math.RandomFloat( -deflection, deflection );

			const float beamDistance = Math.max( 1024.0, m_attackDistance );
			g_Utility.TraceLine( vecSrc, vecSrc + vecAim * beamDistance, dont_ignore_monsters, self.edict(), tr );

			@m_pBeam[m_iBeams] = g_EntityFuncs.CreateBeam( ISLAVE_EMPOWERED_LIGHTNING_SPRITE, 50 );
			
			if ( m_pBeam[m_iBeams] is null )
				return null;

			const Vector zapColor = GetZapColor();
			m_pBeam[m_iBeams].PointEntInit( tr.vecEndPos, self.entindex() );
			m_pBeam[m_iBeams].SetEndAttachment( AttachmentFromSide(side) );
			m_pBeam[m_iBeams].SetColor( int(zapColor.x), int(zapColor.y), int(zapColor.z) );
			m_pBeam[m_iBeams].SetBrightness( 255 );
			m_pBeam[m_iBeams].SetNoise( 20 );
			m_iBeams++;

			CBaseEntity@ pResult = null;
			CBaseEntity@ pEntity = g_EntityFuncs.Instance( tr.pHit );
			
			// To do: If friendly to Player, allied Vorts can damage enemy Vorts. Enemy Vorts can damage Vorts allied to you as well.
			if ( pEntity !is null && pEntity.pev.takedamage != DAMAGE_NO )
			{
				if ( self.IRelationship( pEntity ) < R_DL && pEntity.GetClassname() == self.GetClassname() )
				{
					if ( AbleToHeal() && HealOther( pEntity ) )
					{
						g_Game.AlertMessage(at_aiconsole, "Vortigaunt healed friend with zap attack\n");
					}
				}
				else
				{
					const float zapDmg = g_EngineFuncs.CVarGetFloat( "sk_islave_dmg_zap" ) * 1.25;	//GetVortEmpZapDmg();
					
					// deal extra damage to monsters, so they don't get stuck on a long fight.
					if ( !pEntity.IsPlayer() )
					{
						pEntity.TraceAttack( pev, zapDmg * 1.25, vecAim, tr, DMG_SHOCK | DMG_NEVERGIB );
					}
					else
					{
						pEntity.TraceAttack( pev, zapDmg, vecAim, tr, DMG_SHOCK );
					}
					
					if ( ( pEntity.pev.flags & ( FL_CLIENT | FL_MONSTER ) ) != 0 )
					{
						//TODO: check that target is actually a living creature, not machine
						const float toHeal = zapDmg;
						
						bool healed = self.TakeHealth( toHeal, DMG_GENERIC );
						
						if ( healed )
						{
							g_Game.AlertMessage(at_aiconsole, "Vortigaunt gets health from enemy\n");
						}
						
						m_freeEnergy += toHeal * 3;	//Empowered Vorts replenish triple energy from damage.

						g_Game.AlertMessage( at_aiconsole, "Vortigaunt gets energy from enemy. Energy level: %1\n", int( m_freeEnergy ) );
						
						if ( m_freeEnergy > pev.max_health )
						{
							m_freeEnergy = pev.max_health;
							g_Game.AlertMessage( at_aiconsole, "Vortigaunt has too much energy. Energy level reset down to: %1\n", int( m_freeEnergy ) );
						}
					}
				}
				
				@pResult = pEntity;
			}
			
			g_SoundSystem.EmitAmbientSound( self.edict(), tr.vecEndPos, "weapons/electro4.wav", 0.5, ATTN_NORM, 0, Math.RandomLong( 140, 160 ) );
			
			return pResult;
		}
	
		void BeamGlow()
		{
			int b = m_iBeams * 32;
			
			if ( b > 255 )
				b = 255;
			
			HandsGlowOn(b);

			for ( int i = 0; i < m_iBeams; i++ )
			{
				if ( m_pBeam[i].GetBrightness() != 255 )
				{
					m_pBeam[i].SetBrightness( b );
				}
			}
		}
		
		void HandsGlowOn(int brightness = 224)
		{
			HandGlowOn(m_handGlow1, brightness);
			HandGlowOn(m_handGlow2, brightness);
		}
		
		void HandGlowOn(CSprite@ handGlow, int brightness = 224)
		{
			if ( handGlow !is null )
			{
				Vector zapColor = GetZapColor();
				handGlow.SetTransparency( kRenderTransAdd, int(zapColor.x), int(zapColor.y), int(zapColor.z), brightness, kRenderFxNoDissipation );
				handGlow.SetOrigin(pev.origin);
				handGlow.SetScale(brightness / 255.0 * 0.3);
				handGlow.pev.effects &= ~EF_NODRAW;
			}
		}
		
		void StartMeleeAttackGlow(int side)
		{
			CSprite@ handGlow = side == ISLAVE_EMPOWERED_LEFT_ARM ? m_handGlow2 : m_handGlow1;
			HandGlowOn(handGlow);
			int brightness;
			const Vector armBeamColor = GetArmBeamColor(brightness);
			NetworkMessage m(MSG_PVS, NetworkMessages::SVC_TEMPENTITY, pev.origin);
			m.WriteByte( TE_BEAMFOLLOW );
			m.WriteShort( self.entindex() + 0x1000 * (AttachmentFromSide(side)) );
			m.WriteShort( m_iTrailTexture );
			m.WriteByte( 5 ); // life
			m.WriteByte( 3 );  // width
			m.WriteByte( int(armBeamColor.x) );   // r, g, b
			m.WriteByte( int(armBeamColor.y) );   // r, g, b
			m.WriteByte( int(armBeamColor.z) );   // r, g, b
			m.WriteByte( 128 );	// brightness
			m.End();
		}
		
		bool CanUseGlowArms()
		{
			return ( pev.spawnflags & SF_SQUADMONSTER_LEADER ) != 0 || HasFreeEnergy();
		}
		
		void HandGlowOff(CSprite@ handGlow)
		{
			if (handGlow !is null)
			{
				handGlow.pev.effects |= EF_NODRAW;
			}
		}
		
		void HandsGlowOff()
		{
			HandGlowOff(m_handGlow1);
			HandGlowOff(m_handGlow2);
		}
		
		void CreateSummonBeams()
		{
			g_EngineFuncs.MakeVectors(pev.angles);
			Vector vecEnd = pev.origin + g_Engine.v_forward * 36;
			
			if (m_handGlow1 !is null)
			{
				@m_handsBeam1 = CreateSummonBeam(vecEnd, 1);
			}
			
			if (m_handGlow2 !is null)
			{
				@m_handsBeam2 = CreateSummonBeam(vecEnd, 2);
			}
		}
		
		void RemoveSummonBeams()
		{
			if (m_handsBeam1 !is null)
				m_handsBeam1.SUB_Remove();
			
			@m_handsBeam1 = null;
			
			if (m_handsBeam2 !is null)
				m_handsBeam2.SUB_Remove();
			
			@m_handsBeam2 = null;
		}
		
		void RemoveHandGlows()
		{
			if (m_handGlow1 !is null)
				m_handGlow1.SUB_Remove();
			
			@m_handGlow1 = null;
			
			if (m_handGlow2 !is null)
				m_handGlow2.SUB_Remove();
			
			@m_handGlow2 = null;
		}
	
		void SonicEffect()
		{
			Vector zapColor = GetZapColor();

			// blast circles
			NetworkMessage vortEmpSonic(MSG_PAS, NetworkMessages::SVC_TEMPENTITY, pev.origin);
			vortEmpSonic.WriteByte( TE_BEAMCYLINDER );
			vortEmpSonic.WriteCoord( pev.origin.x );
			vortEmpSonic.WriteCoord( pev.origin.y );
			vortEmpSonic.WriteCoord( pev.origin.z + 16 );
			vortEmpSonic.WriteCoord( pev.origin.x );
			vortEmpSonic.WriteCoord( pev.origin.y );
			vortEmpSonic.WriteCoord( pev.origin.z + 1500 ); 
			vortEmpSonic.WriteShort( m_iSpriteTexture );
			vortEmpSonic.WriteByte( 0 ); // startframe
			vortEmpSonic.WriteByte( 0 ); // framerate
			vortEmpSonic.WriteByte( 2 ); // life
			vortEmpSonic.WriteByte( 64 );  // width
			vortEmpSonic.WriteByte( 0 );   // noise
			vortEmpSonic.WriteByte( int(zapColor.x) );
			vortEmpSonic.WriteByte( int(zapColor.y) );
			vortEmpSonic.WriteByte( int(zapColor.z) );
			vortEmpSonic.WriteByte( 255 ); 	//brightness
			vortEmpSonic.WriteByte( 0 );	// speed
			vortEmpSonic.End();
		
			NetworkMessage vortEmpSonicB(MSG_PAS, NetworkMessages::SVC_TEMPENTITY, pev.origin);
			vortEmpSonicB.WriteByte( TE_BEAMCYLINDER );
			vortEmpSonicB.WriteCoord( pev.origin.x );
			vortEmpSonicB.WriteCoord( pev.origin.y );
			vortEmpSonicB.WriteCoord( pev.origin.z + 16 );
			vortEmpSonicB.WriteCoord( pev.origin.x );
			vortEmpSonicB.WriteCoord( pev.origin.y );
			vortEmpSonicB.WriteCoord( pev.origin.z + 1000 ); 
			vortEmpSonicB.WriteShort( m_iSpriteTexture );
			vortEmpSonicB.WriteByte( 0 ); // startframe
			vortEmpSonicB.WriteByte( 0 ); // framerate
			vortEmpSonicB.WriteByte( 2 ); // life
			vortEmpSonicB.WriteByte( 32 );  // width
			vortEmpSonicB.WriteByte( 0 );   // noise
			vortEmpSonicB.WriteByte( int(zapColor.x) );
			vortEmpSonicB.WriteByte( int(zapColor.y) );
			vortEmpSonicB.WriteByte( int(zapColor.z) );
			vortEmpSonicB.WriteByte( 255 ); 	//brightness
			vortEmpSonicB.WriteByte( 0 );	// speed
			vortEmpSonicB.End();
		}
	
		void MakeDynamicLight(const Vector& in vecSrc, int radius, int t)
		{
			Vector lightColor = GetLightColor();
			
			NetworkMessage vortEmpDynLight(MSG_PVS, NetworkMessages::SVC_TEMPENTITY, vecSrc);
			vortEmpDynLight.WriteByte( TE_DLIGHT );
			vortEmpDynLight.WriteCoord( vecSrc.x );	// X
			vortEmpDynLight.WriteCoord( vecSrc.y );	// Y
			vortEmpDynLight.WriteCoord( vecSrc.z );	// Z
			vortEmpDynLight.WriteByte( radius );		// radius * 0.1
			vortEmpDynLight.WriteByte( int( lightColor.x ) );		// r
			vortEmpDynLight.WriteByte( int( lightColor.y ) );		// g
			vortEmpDynLight.WriteByte( int( lightColor.z ) );		// b
			vortEmpDynLight.WriteByte( t );		// time * 10
			vortEmpDynLight.WriteByte( 0 );		// decay * 0.1
			vortEmpDynLight.End();
		}
	
		Vector HandPosition(int side)
		{
			Math.MakeAimVectors( pev.angles );
			return pev.origin + g_Engine.v_up * 36 + g_Engine.v_right * side * 16 + g_Engine.v_forward * 32;
		}

		CSprite@ CreateHandGlow(int attachment)
		{
			CSprite@ handSprite = g_EntityFuncs.CreateSprite( ISLAVE_EMPOWERED_HAND_SPRITE_NAME, pev.origin, false );
			handSprite.SetAttachment( self.edict(), attachment );
			handSprite.SetScale(0.25);
			return handSprite;
		}
		
		CBeam@ CreateSummonBeam(const Vector& in vecEnd, int attachment)
		{
			CBeam@ beam = g_EntityFuncs.CreateBeam( ISLAVE_EMPOWERED_LIGHTNING_SPRITE, 30 );
			
			if ( beam is null )
				return beam;

			Vector zapColor = GetZapColor();
			beam.PointEntInit(vecEnd, self.entindex());
			beam.SetEndAttachment(attachment);
			beam.SetColor( int(zapColor.x), int(zapColor.y), int(zapColor.z) );
			beam.SetBrightness( 192 );
			beam.SetNoise( 80 );
			return beam;
		}

		float HealPower()
		{
			return Math.min( g_EngineFuncs.CVarGetFloat( "sk_islave_dmg_zap" ) * 0.25, m_freeEnergy );	//GetVortEmpZapDmg()
		}
		
		void SpendEnergy(float energy)
		{
			// It's ok to be negative. Vort must restore power to positive values to proceed with healing or reviving.
			if ( ( pev.spawnflags & SF_SQUADMONSTER_LEADER) != 0 ) // leader spends less energy
				m_freeEnergy -= energy / 2;
			else
				m_freeEnergy -= energy;
		}
		
		bool HasFreeEnergy()
		{
			return m_freeEnergy > 0;
		}
		
		bool AbleToHeal()
		{
			return true;
		}
		
		bool AbleToRevive()
		{
			return true;
		}
	
		bool CanRevive()
		{
			return AbleToRevive() && m_hDead.GetEntity() !is null && HasFreeEnergy();
		}
		
		bool HealOther(CBaseEntity@ pEntity)
		{
			if ( pEntity.IsAlive() && pEntity.pev.health > 0 )
			{
				const float healthBeforeHealed = pEntity.pev.health;
				if ( pEntity.TakeHealth( HealPower(), 0 ) )
				{
					float amount = pEntity.pev.health - healthBeforeHealed;
					
					if ( amount > 0 )
					{
						SpendEnergy( amount );
						return true;
					}
				}
			}
			return false;
		}

		bool CanSpawnFamiliar()
		{
			if ( ( pev.weapons & ( ISLAVE_EMPOWERED_SNARKS | ISLAVE_EMPOWERED_HEADCRABS ) ) != 0 )
			{
				if ( !self.HasMemory( bits_MEMORY_ISLAVE_EMPOWERED_FAMILIAR_IS_ALIVE ) && m_flSpawnFamiliarTime < g_Engine.time )
				{
					return true;
				}
			}
			return false;
		}

		Vector GetZapColor()
		{
			if ( ( pev.spawnflags & SF_SQUADMONSTER_LEADER ) != 0 )
			{
				return Vector( ISLAVE_EMPOWERED_LEADER_ZAP_RED, ISLAVE_EMPOWERED_LEADER_ZAP_GREEN, ISLAVE_EMPOWERED_LEADER_ZAP_BLUE );
			}
			
			return Vector( ISLAVE_EMPOWERED_ZAP_RED, ISLAVE_EMPOWERED_ZAP_GREEN, ISLAVE_EMPOWERED_ZAP_BLUE );
		}
	
		Vector GetLightColor()
		{
			return Vector( ISLAVE_EMPOWERED_LIGHT_RED, ISLAVE_EMPOWERED_LIGHT_GREEN, ISLAVE_EMPOWERED_LIGHT_BLUE );
		}
		
		Vector GetArmBeamColor(int& out brightness)
		{
			if ( ( pev.spawnflags & SF_SQUADMONSTER_LEADER ) != 0 )
			{
				brightness = 230;
				
				return Vector( ISLAVE_EMPOWERED_LEADER_ARMBEAM_RED, ISLAVE_EMPOWERED_LEADER_ARMBEAM_GREEN, ISLAVE_EMPOWERED_LEADER_ARMBEAM_BLUE );
			}
			
			brightness = 175;
			
			return Vector( ISLAVE_EMPOWERED_ARMBEAM_RED, ISLAVE_EMPOWERED_ARMBEAM_GREEN, ISLAVE_EMPOWERED_ARMBEAM_BLUE );
		}
	
		int AttachmentFromSide(int side)
		{
			return side < 0 ? 2 : 1;
		}

		void SetHealTargetAsTargetEnt()
		{
			if ( m_hDead )
			{
				self.m_hTargetEnt = m_hDead;
			}
			else if ( m_hWounded )
			{
				self.m_hTargetEnt = m_hWounded;
			}
		}

		bool CanGoToTargetEnt()
		{
			if ( self.m_hTargetEnt.GetEntity() !is null )
				return self.FGetNodeRoute( self.m_hTargetEnt.GetEntity().pev.origin );
				
			return false;
		}

		string FamiliarName()
		{
			if ( ( pev.weapons & ISLAVE_EMPOWERED_SNARKS ) != 0 )
			{
				return "monster_snark";
			}
			else if ( ( pev.weapons & ISLAVE_EMPOWERED_HEADCRABS ) != 0 )
			{
				return "monster_headcrab";
			}
			
			return string();
		}
	
		HULL_NUMBER FamiliarHull()
		{
			return head_hull;
		}

		Vector GetFamiliarSpawnPosition()
		{
			g_EngineFuncs.MakeVectors( pev.angles );
			
			if ( ( pev.weapons & ISLAVE_EMPOWERED_SNARKS ) != 0 )
			{
				return pev.origin + g_Engine.v_forward * 36 + Vector(0, 0, 20);
			}
			else if ( ( pev.weapons & ISLAVE_EMPOWERED_HEADCRABS ) != 0 )
			{
				return pev.origin + g_Engine.v_forward * 48 + Vector(0, 0, 20);
			}
			
			return pev.origin + g_Engine.v_forward * 36 + Vector(0, 0, 20);
		}
	
		//=========================================================
		// SonicAttack
		//=========================================================
		void SonicAttack()
		{
			float flAdjustedDamage;
			float flDist;

			switch ( Math.RandomLong( 0, 2 ) )
			{
				case 0:
					g_SoundSystem.EmitSound( self.edict(), CHAN_WEAPON, pSonicWaveSounds[0], 1, ATTN_NORM );
					break;
				case 1:
					g_SoundSystem.EmitSound( self.edict(), CHAN_WEAPON, pSonicWaveSounds[1], 1, ATTN_NORM );
					break;
				case 2:
					g_SoundSystem.EmitSound( self.edict(), CHAN_WEAPON, pSonicWaveSounds[2], 1, ATTN_NORM );
					break;
			}
			
			g_PlayerFuncs.ScreenShake( pev.origin, 12.0, 100.0, 2.0, 1000 );

			CBaseEntity@ pEntity = null;
			// iterate on all entities in the vicinity.
			while ( ( @pEntity = g_EntityFuncs.FindEntityInSphere( pEntity, pev.origin, 384, "*", "classname" ) ) !is null )
			{
				if ( pEntity.pev.takedamage != DAMAGE_NO )
				{
					if ( ( pEntity.pev.classname != "monster_alien_slave_empowered" ) && ( pEntity.pev.classname != "monster_controller_exterminator" ) && ( pEntity.pev.classname != "monster_alien_slave" ) )
					{
						flAdjustedDamage = g_EngineFuncs.CVarGetFloat( "sk_tor_sonicblast" );	//GetVortEmpSonicDmg();
						flDist = ( pEntity.pev.origin - pev.origin ).Length();

						if ( !pEntity.IsPlayer() )
						{
							flAdjustedDamage *= 4;
						}

						flAdjustedDamage -= ( flDist / 384 ) * flAdjustedDamage;
						
						if ( pEntity != self && pEntity.pev.takedamage != DAMAGE_NO )
						{
							const int rel = self.IRelationship( pEntity );
							if ( rel == R_AL )
							{
								if ( pEntity.GetClassname() == self.GetClassname() )
								{
									if ( AbleToHeal() && HealOther(pEntity) )
									{
										g_Game.AlertMessage(at_aiconsole, "Vortigaunt healed friend with coil attack\n");
									}
								}
							}
							else
							{
								if ( !self.FVisible( pEntity, true ) )
								{
									if ( pEntity.IsPlayer() )
									{
										// if this entity is a client, and is not in full view, inflict half damage. We do this so that players still
										// take the residual damage if they don't totally leave the houndeye's effective radius. We restrict it to clients
										// so that monsters in other parts of the level don't take the damage and get pissed.
										flAdjustedDamage *= 0.5f;
									}
									else
									{
										flAdjustedDamage = 0;
									}
								}

								if ( flAdjustedDamage > 0 )
								{
									pEntity.TakeDamage( pev, pev, flAdjustedDamage, DMG_SONIC | DMG_ALWAYSGIB );
									
									const float toHeal = flAdjustedDamage;
									
									m_freeEnergy += toHeal * 2;	//Empowered Vorts replenish double the energy from damage.
									
									g_Game.AlertMessage( at_aiconsole, "Vortigaunt gets energy from enemy. Energy level: %1\n", int( m_freeEnergy ) );
									
									if ( m_freeEnergy > pev.max_health )
									{
										m_freeEnergy = pev.max_health;
										g_Game.AlertMessage( at_aiconsole, "Vortigaunt has too much energy. Energy level reset down to: %1\n", int( m_freeEnergy ) );
									}
								}
							}
						}
					}
				}
			}
		}
	}
	
	//=========================================================
	// AI Schedules Specific to this monster
	//=========================================================

	array<ScriptSchedule@>@ monster_alien_slave_empowered_schedules;

	ScriptSchedule slSlaveEmpAttack1
	(
			bits_COND_HEAR_SOUND |
			bits_COND_HEAVY_DAMAGE, 
			bits_SOUND_DANGER,
			"Slave Range Attack1"
	);

	ScriptSchedule slSlaveEmpHealOrReviveAttack
	(
			bits_COND_CAN_MELEE_ATTACK1 |
			bits_COND_HEAR_SOUND |
			bits_COND_NEW_ENEMY |
			bits_COND_HEAVY_DAMAGE, 

			bits_SOUND_DANGER,
			"Slave Heal or Revive Range Attack"
	);

	ScriptSchedule slSlaveEmpCoverAndSummon
	(
			bits_COND_NEW_ENEMY,
			0,
			"Slave Run Away and Summon"
	);

	ScriptSchedule slSlaveEmpSummon
	(
			bits_COND_NEW_ENEMY,
			0,
			"Slave Summon"
	);

	ScriptSchedule slRetreatFromEnemy
	(
			bits_COND_NEW_ENEMY,
			0,
			"Retreat From Enemy"
	);

	dictionary@ DictFromMonster(CBaseMonster@ pMonster)
	{
		dictionary dictMonster =
		{
			{ "displayname",        "" + pMonster.m_FormattedName },
			{ "health",             "" + pMonster.pev.health },
			{ "max_health",         "" + pMonster.pev.max_health },
			{ "body",               "" + pMonster.pev.body },
			{ "skin",               "" + pMonster.pev.skin },
			{ "weapons",            "" + pMonster.pev.weapons },
			{ "bloodcolor",         "" + pMonster.m_bloodColor },
			{ "TriggerCondition",   "" + pMonster.m_iTriggerCondition },
			{ "rendermode",         "" + pMonster.pev.rendermode },
			{ "renderamt",          "" + pMonster.pev.renderamt },
			{ "renderfx",           "" + pMonster.pev.renderfx },
			{ "rendercolor",        pMonster.pev.rendercolor.ToString().Replace( ",", "" ) }
		};
		
		if ( pMonster.GetTargetname() != "" )
			dictMonster["targetname"] = pMonster.GetTargetname();

		if ( pMonster.pev.target != "" )
			dictMonster["target"] = "" + pMonster.pev.target;

		if ( pMonster.pev.netname != "" )
			dictMonster["netname"] = "" + pMonster.pev.netname;

		if ( pMonster.m_fCustomModel )
			dictMonster["model"] = "" + pMonster.pev.model;

		if ( pMonster.m_iszTriggerTarget != "" )
			dictMonster["TriggerTarget"] = "" + pMonster.m_iszTriggerTarget;

		if ( pMonster.m_iszGuardEntName != "" )
			dictMonster["guard_ent"] = "" + pMonster.m_iszGuardEntName;

		if ( pMonster.m_fOverrideClass )
		{
			if ( pMonster.m_iClassSelection < 0 )
				dictMonster["classify"] = "-1";
			else
				dictMonster["classify"] = "" + pMonster.m_iClassSelection;
		}

		if ( pMonster.pev.spawnflags > 0 )
			dictMonster["spawnflags"] = "" + ( pMonster.pev.spawnflags & ~( 16 | 64 | 128 | 256 ) );

		CustomKeyvalues@ customKeyValues = pMonster.GetCustomKeyvalues();
		
		if ( customKeyValues !is null )
		{
			float customAttackDistance = customKeyValues.GetKeyvalue("$f_attack_distance").GetFloat();
			
			if ( customAttackDistance != 0 )
			{
				//g_Game.AlertMessage(at_console, "Got custom attack distance: %1\n", customAttackDistance);
				dictMonster["attack_distance"] = "" + customAttackDistance;
			}
		}

		return @dictMonster;
	}

	string GetMonsterName()
	{
		return "monster_alien_slave_empowered";
	}
	
	void Register()
	{
		InitSchedules();
		g_CustomEntityFuncs.RegisterCustomEntity( "SVEN_VORTIGAUNT_EMPOWERED::CISlaveEmpowered", GetMonsterName() );
		g_Game.PrecacheOther( GetMonsterName() );
	}
} // End of Namespace