//-----------------------------------------------------------------------------
//
//  $Logfile:: /EF2/Code/DLLs/game/armor.cpp                                 $
// $Revision:: 63                                                             $
//   $Author:: Singlis                                                        $
//     $Date:: 9/26/03 2:35p                                                  $
//
// Copyright (C) 1997 by Ritual Entertainment, Inc.
// All rights reserved.
//
// This source is may not be distributed and/or modified without
// expressly written permission by Ritual Entertainment, Inc.
//
//
// DESCRIPTION:
// Standard armor that prevents a percentage of damage per hit.
//

#include "_pch_cpp.h"
#include "armor.h"
#include "player.h"
#include "mp_manager.hpp"

extern cvar_t *g_armoradaptionlimit;
extern Event EV_SetOriginEveryFrame;

//-------------------------------------------------------------------------
// Events
//-------------------------------------------------------------------------
Event EV_Armor_SetAdaptionFX
(
	"setadaptionfx",
	EV_DEFAULT,
	"s",
	"adaption_fx",
	"set the adaption fx model"
);
Event EV_Armor_SetFXLife
(
	"setFXlife",
	EV_DEFAULT,
	"ff",
	"Normal_Time Explosive_Time",
	"Sets the FX Time"
);
Event EV_Armor_SetActiveStatus
(
	"setarmoractivestatus",
	EV_DEFAULT,
	"b",
	"active",
	"sets the active status"
);
Event EV_Armor_SetMultiplier
(
	"setarmormultiplier",
	EV_DEFAULT,
	"f",
	"multiplier",
	"sets the damage multiplier for the armor"
);
Event EV_Armor_AddToNoProtectionList
(
	"noprotection",
	EV_DEFAULT,
	"s",
	"MOD",
	"Adds a MOD to the No Protection List"
);
Event EV_Armor_UseArmorDirection
(
	"usearmordirection",
	EV_DEFAULT,
	"ff",
	"directionAngleMin directionAngleMax",
	"Only allows armor to work if attack is within the specifed yaw range"
);

Event EV_Armor_LoadAdaptionDataFromGameVars
(
	"loadadaptiondata",
	EV_DEFAULT,
	NULL,
	NULL,
	"Used to control timing on adaption information loads"
);


//-------------------------------------------------------------------------
// Armor Implementation
//-------------------------------------------------------------------------
CLASS_DECLARATION( Item, Armor, NULL )
{
	{ NULL, NULL }
};


//
// Name:        Armor()
// Class:       Armor
//
// Description: Constructor
//
// Parameters:  None
//
// Returns:     None
//
Armor::Armor()
{
	// all data will be setup by the archive function
	if ( LoadingSavegame )
		return;
	
	if ( multiplayerManager.checkFlag( MP_FLAG_NO_ARMOR ) )
	{
		PostEvent( EV_Remove, EV_REMOVE );
		return;
	}
	
	setName( "UnknownArmor" );
	amount  = 0;	
	SetMax ( 200 );

	_mpItemType = MP_ITEM_TYPE_ARMOR;
}



//
// Name:        ~Armor()
// Class:        Armor
//
// Description:  Destructor
//
// Parameters:   None
//
// Returns:      None
//
Armor::~Armor()
{
	
}

//
// Name:        ResolveDamage() 
// Class:       Armor
//
// Description: Resolves the damage.
//
// Parameters:  float damage -- The initial damage.
//
// Returns:     float newDamage -- The new damage after armor factor is taken into account
//
float Armor::ResolveDamage( float damage , int meansOfDeath , const Vector &direction , const Vector &position , Entity *attacker )
{
	gi.Error( ERR_FATAL, "Armor::ResolveDamage -- Do Not Use Armor Base Class -- You MUST use a subclassed" );
	return 0.0f;
}

//--------------------------------------------------------------
// Name:		CanBeDamagedBy()
// Class:		Armor
//
// Description:	Checks if this armor will aborb 100% of the damage
//				for the specified Means Of Death
//
// Parameters:	int meansOfDeath
//
// Returns:		true or false
//--------------------------------------------------------------
bool Armor::CanBeDamagedBy( int meansOfDeath )
{
	gi.Error( ERR_FATAL, "Armor::CanBeDamagedBy -- Do Not Use Armor Base Class -- You MUST use a subclassed" );
	return true;
}

//
// Name:        ItemPickup()
// Class:       Armor
//
// Description: Handles Sentients Picking up armor... In this case, however,
//              Only Actors are allowed to actually pick up armor
//
// Parameters:  Entity *other - The entity doing the picking up
//              qboolean add_to_inventory - Here to make parameters match
//
// Returns:     NULL -- This function doesn't actually return the armor, instead
//              it has the entity picking it up process and armor event
//
Item *Armor::ItemPickup( Entity *other, qboolean add_to_inventory, qboolean )
{
	Sentient *sent;
	str      realname;
	
	// For right now, we only want players to pick up armor
	if ( !other->isSubclassOf( Player ) )
		return NULL;

	if ( !Pickupable( other ) )
		return NULL;
	
	sent = (Sentient*)other;
	
	// Check if we NEED to pick up the armor, if the armor we are about to pick up is
	// less than the armor we have, we don't want to pick it up
	if ( !_needThisArmor(sent) )
		return NULL;
	
	// Handle the actual "Picking Up"
	_pickupArmor(sent);
	
	// Give the Sentient the Armor
	Event *armorEvent;
	armorEvent = new Event(EV_Sentient_GiveArmor);
	armorEvent->AddString( item_name.c_str() );
	armorEvent->AddFloat( amount );
	armorEvent->AddInteger( true );
	
	sent->ProcessEvent(armorEvent);	
	
	return NULL; // This doesn't create any items
}



//
// Name:        _needThisArmor()
// Class:       Armor
//
// Description: Checks if the sentient needs to pick up the
//              armor or not
//
// Parameters:  Sentient *sentient -- The sentient to check
//
// Returns:     true or false
//
qboolean Armor::_needThisArmor( Sentient *sentient )
{
	int currentArmorValue = sentient->GetArmorValue();
	
	if( currentArmorValue >= amount )
		return false;
	else
		return true;
}


//
// Name:        _pickupArmor()
// Class:       Armor
//
// Description: Takes care of "Picking Up" the armor, by playing the
//              appropriate sounds, removing the model...
//
// Parameters:  None
// 
// Returns:     None
//
void Armor::_pickupArmor( Sentient *sentient)
{
	str      realname;
	
	// Play pickup sound
	realname = GetRandomAlias( "snd_pickup" );
	if ( realname.length() > 1 )
		sentient->Sound( realname, CHAN_ITEM );
	
	// Cancel some events
	CancelEventsOfType( EV_Item_DropToFloor );
	CancelEventsOfType( EV_Item_Respawn );
	CancelEventsOfType( EV_FadeOut );
	
	// Hide the model
	setSolidType( SOLID_NOT );

	if ( _missingSkin )
	{
		ChangeSkin( _missingSkin, true );
	}
	else
	{
		hideModel();
	}
	
	// Respawn?
	if ( !Respawnable() )
		PostEvent( EV_Remove, FRAMETIME );
	else
		PostEvent( EV_Item_Respawn, RespawnTime() );
	
	// fire off any pickup_thread's
	if ( pickup_thread.length() )
		ExecuteThread( pickup_thread );	
}


//-------------------------------------------------------------------------
// AdaptiveArmor Implementation
//-------------------------------------------------------------------------
CLASS_DECLARATION( Armor, AdaptiveArmor, NULL )
{
	{ &EV_Armor_SetAdaptionFX,           		&AdaptiveArmor::SetAdaptionFX 		},
	{ &EV_Armor_LoadAdaptionDataFromGameVars, 	&AdaptiveArmor::LoadDataFromGameVars},
	{ &EV_Armor_SetFXLife,				 		&AdaptiveArmor::SetFXLife			},
	{ NULL, NULL }
};


//
// Adaptive Armor is Adaption And Cannot Adapt is Global
//
Container<MODHitCounter*> AdaptiveArmor::_AdaptionList;
Container<int> AdaptiveArmor::_CannotAdaptToList;
Container<str> AdaptiveArmor::_fxList;

//
// Name:        AdaptiveArmor()
// Class:       AdaptiveArmor
//
// Description: Constructor
//
// Parameters:  None
//
// Returns:     None
//
AdaptiveArmor::AdaptiveArmor()
{
	amount  = 0;	
	SetMax ( 200 );	
	
	// Add Adaptions to list
	_fxList.AddObject( "fx/fx-borg-sheild-01.tik" );
	_fxList.AddObject( "fx/fx-borg-sheild-02.tik" );
	_fxList.AddObject( "fx/fx-borg-sheild-03.tik" );
	
	// Set our current Adaption
	_AdaptionFX = "fx/fx-borg-sheild-01.tik";
	
	// Set our index
	_currentFXIndex = 1;
	_fxTimeNormal = 0.15;
	_fxTimeExplosive = 1.0;
	
	_AddMODToCannotAdaptList( MOD_IMOD_PRIMARY);   
	_AddMODToCannotAdaptList( MOD_IMOD_SECONDARY);
	_AddMODToCannotAdaptList( MOD_SUICIDE );

	if ( !LoadingSavegame )
	{
		//Try and pull data from the gameVars
		Event *loadEvent = new Event ( EV_Armor_LoadAdaptionDataFromGameVars );

		PostEvent( loadEvent, 3.0 );
		//LoadDataFromGameVars();
	}
}

//
// Name:        ~AdaptiveArmor()
// Class:       AdaptiveArmor
//
// Description: Destructor
//
// Parameters:  None
//
// Returns:     None
//
AdaptiveArmor::~AdaptiveArmor()
{
	
	
}


//
// Name:        ResolveDamage()
// Class:       AdaptiveArmor
//
// Description: Resolves the damage
//
// Parameters:  float damage -- The initial damage.
//
// Returns:     float newDamage -- The new damage after armor factor is taken into account
//
float AdaptiveArmor::ResolveDamage( float damage , int meansOfDeath , const Vector &direction , const Vector &position , Entity *attacker )
{
	int DamageTotal;
	
	if (!_CanAdaptTo( meansOfDeath ) )
		return damage;
	
	if ( attacker->isSubclassOf( Player ) )
	{
		if ( !_AdaptionInList( meansOfDeath ) )
			_AddAdaption( meansOfDeath , damage );
		else
			_UpdateAdaption( meansOfDeath , damage );
	}
	
	DamageTotal = (int)_GetDamageTotal( meansOfDeath );
	
	_adaptionLimit = g_armoradaptionlimit->value;
	if ( DamageTotal > _adaptionLimit )
	{		
		if ( meansOfDeath == MOD_EXPLOSION || meansOfDeath == MOD_VAPORIZE_COMP )
			_fxTime = _fxTimeExplosive;
		else
			_fxTime = _fxTimeNormal;
		
		_PlayAdaptionFX( direction , position );
		return 0.0f;
	}
		
	return damage;
}


void AdaptiveArmor::SetAdaptionFX( Event *ev )
{
	SetAdaptionFX(ev->GetString( 1 ) );
}

void AdaptiveArmor::SetAdaptionFX( const str &fxName )
{
	_AdaptionFX = fxName;
}

//
// Name:        _AddAdaption()
// Class:       AdaptiveArmor
//
// Description: Adds and adaption to the adaption list
//
// Parameters:  int MOD - The Means Of Death index
//
// Returns:     None
//
void AdaptiveArmor::_AddAdaption( int MeansOfDeath , float damage)
{
	MODHitCounter *adaption = NULL;
	adaption = new MODHitCounter;
	
	//We don't want to be able to adapt to all MOD
	if ( _AdaptionList.NumObjects() > 2 )
		return;

	//Double Check we're not adding the same MOD 
	if ( _AdaptionInList( MeansOfDeath ) )
		return;

	if ( adaption )
	{
		adaption->MODIndex = MeansOfDeath;
		adaption->damage = damage + .1; // Have to add just a bit incase damage = 0
		adaption->adapted = false;

		str MODName = MOD_NumToName( MeansOfDeath );
		AddGameVar ( MODName , adaption->damage );
		_AdaptionList.AddObject( adaption );
	}		
}


//
// Name:        _AdaptionInList()
// Class:       AdaptiveArmor
//
// Description: Checks if an adaption for the MOD is in the list
//
// Parameters:  int MOD -- the Means Of Death index
//
// Returns:     true or false
//
qboolean AdaptiveArmor::_AdaptionInList( int MeansOfDeath )
{
	int i;
	MODHitCounter *adaption;
	
	for( i=_AdaptionList.NumObjects(); i>0; i-- )
	{
		adaption = _AdaptionList.ObjectAt( i );
		if ( adaption->MODIndex == MeansOfDeath )
			return true;
	}
	
	return false;
}


//
// Name:        _UpdateAdaption()
// Class:       AdaptiveArmor
//
// Description: Updates a particular adaption in the adaption list
//
// Parameters:  int MOD -- the Means Of Death index
//              int count -- the number to add
//
// Returns:     None
//
void AdaptiveArmor::_UpdateAdaption( int MeansOfDeath , float damage )
{
	int i;
	MODHitCounter *adaption;
		
	for( i=_AdaptionList.NumObjects(); i>0; i-- )
	{
		adaption = _AdaptionList.ObjectAt( i );
		if ( adaption->MODIndex == MeansOfDeath )
		{
			adaption->damage += damage;

			str MODName = MOD_NumToName( MeansOfDeath );
			UpdateGameVar ( MODName , adaption->damage );

			if ( (adaption->damage >= g_armoradaptionlimit->value) && !adaption->adapted )
			{
				adaption->adapted = true;				

				Actor *act;
				for ( int i=1; i<=ActiveList.NumObjects(); i++ )
				{
					act = ActiveList.ObjectAt(i);
					if ( !act )
						continue;
					
					act->InContext( "enemyadapted" , 0 );					
				}
				
			}
			return;
		}
	}		
}


//
// Name:         _GetDamageTotal()
// Class:        AdaptiveArmor
//
// Description:  Retrieves the number of times shot for a 
//               particular Means Of Death
//
// Parameters:   int MOD -- Means Of Death Index
//
// Returns:      int count
//
float AdaptiveArmor::_GetDamageTotal( int MeansOfDeath )
{
	int i;
	MODHitCounter *adaption;
	
	for( i=_AdaptionList.NumObjects(); i>0; i-- )
	{
		adaption = _AdaptionList.ObjectAt( i );
		if ( adaption->MODIndex == MeansOfDeath )
		{
			if ( adaption->damage > 0 )
				return adaption->damage;				
		}
		
	}		
	
	return 0.0f;
}

void AdaptiveArmor::_PlayAdaptionFX(const Vector &direction , const Vector &position )
{
	Vector dir;
	Vector newDir;
	Vector fxOrigin;
	Vector PosDelta;
	Entity *theFX;
	
	
	dir = direction;
	dir *= -1;
	dir.normalize();
	
	fxOrigin  = dir * 15;
	fxOrigin += position;
	
	dir = dir.toAngles();
	
	PosDelta = _currentFXPosition - fxOrigin;
	
	if ( PosDelta.length() > FX_CHANGE_DELTA )
	{
		_changeFX();
		_currentFXPosition = fxOrigin;
	}
		
	theFX = SpawnEffect(_AdaptionFX, fxOrigin , dir , _fxTime );	
	theFX->bind( owner );

	theFX->PostEvent( EV_SetOriginEveryFrame , FRAMETIME );	
}

qboolean AdaptiveArmor::_CanAdaptTo( int MOD )
{
	int checkMOD;
	int i;
	
	for( i=_CannotAdaptToList.NumObjects(); i>0; i-- )
	{
		checkMOD = _CannotAdaptToList.ObjectAt( i );
		if ( checkMOD == MOD )
			return false;
	}
	
	return true;
}

void AdaptiveArmor::_AddMODToCannotAdaptList( int MOD )
{
	_CannotAdaptToList.AddObject( MOD );
}

void AdaptiveArmor::_changeFX()
{
	int MaxNumber;
	MaxNumber = _fxList.NumObjects();
	
	if ( MaxNumber == 0 )
		return;

	_currentFXIndex++;
	
	if ( _currentFXIndex > MaxNumber )
		_currentFXIndex = 1;
	
	_AdaptionFX = _fxList.ObjectAt( _currentFXIndex );
	
}

void AdaptiveArmor::ClearAdaptionList()
{
	
	int i;
	MODHitCounter *adaption;
	
	for( i=_AdaptionList.NumObjects(); i>0; i-- )
	{
		adaption = _AdaptionList.ObjectAt( i );
		delete adaption;
		adaption = NULL;
	}
	
    _AdaptionList.FreeObjectList();	
	
	
}

//--------------------------------------------------------------
// Name:		CanBeDamagedBy()
// Class:		AdaptiveArmor
//
// Description:	Checks if this armor will aborb 100% of the damage
//				for the specified Means Of Death
//
// Parameters:	int meansOfDeath
//
// Returns:		true or false
//--------------------------------------------------------------
bool AdaptiveArmor::CanBeDamagedBy( int meansOfDeath )
{
	float DamageTotal;
	
	if ( !_AdaptionInList( meansOfDeath ) )
		return true;
	
	DamageTotal = _GetDamageTotal( meansOfDeath );
	if ( DamageTotal > ADAPTION_LIMIT )
		return false;
	
	return true;
}



void AdaptiveArmor::AddGameVar( const str &name , float value )
{
	ScriptVariable *script_var;
	if ( gameVars.VariableExists( name.c_str() ) )
		return;

	script_var = new ScriptVariable;
	script_var->setName( name.c_str() );
	script_var->setFloatValue( value );
	gameVars.AddVariable( script_var );	
}

void AdaptiveArmor::UpdateGameVar( const str &name , float value )
{
	ScriptVariable *script_var;
	float currentValue;

	if ( !gameVars.VariableExists( name.c_str() ) )
		return;

	script_var = gameVars.GetVariable( name.c_str() );
	currentValue = script_var->floatValue();
	currentValue = currentValue + value;
	script_var->setFloatValue( currentValue );	
}

void AdaptiveArmor::LoadAdaptionData( const str &name )
{
	ScriptVariable *script_var;
	float lastValue;
	int i;
	unsigned int theMOD;
	MODHitCounter *adaption;

	theMOD = MOD_NameToNum( name );

	if ( gameVars.VariableExists( name.c_str() ) )
		{
		script_var = gameVars.GetVariable( name.c_str() );
		lastValue = script_var->floatValue();

		_AddAdaption( theMOD , lastValue );


		if ( lastValue >= g_armoradaptionlimit->value )
			{
			for( i=_AdaptionList.NumObjects(); i>0; i-- )
			{
			adaption = _AdaptionList.ObjectAt( i );
			if ( adaption->MODIndex == theMOD )
				{
				adaption->adapted = true;
				}
			}

		}	

	}		
}

void AdaptiveArmor::LoadDataFromGameVars( Event *ev )
{
	LoadDataFromGameVars();
}

void AdaptiveArmor::LoadDataFromGameVars()
{
	//Sigh, I HATE having to do this, but since we evidently HAVE to have
	//the adaptions carry across levels, here we go... 
	LoadAdaptionData( "phaser"			);
	LoadAdaptionData( "vaporize"		);
	LoadAdaptionData( "comp_rifle"		);
	LoadAdaptionData( "vaporize_comp"	);
}

void AdaptiveArmor::SetFXLife( Event *ev )
{
	_fxTimeNormal = ev->GetFloat( 1 );
	_fxTimeExplosive = ev->GetFloat( 2 );
}

//-------------------------------------------------------------------------
// BasicArmor Implementation
//-------------------------------------------------------------------------

const float	BasicArmor::_maxAmount = 200.0f;
const float	BasicArmor::_normalMaxAmount = 100.0f;
const float	BasicArmor::_lossRate = 1.0f;

const float	BasicArmor::_highRangeCutoffSinglePlayer = 66.0f;
const float	BasicArmor::_midRangeCutoffSinglePlayer = 33.0f;

const float	BasicArmor::_highRangeCutoffMultiplayer = 100.0f;
const float	BasicArmor::_midRangeCutoffMultiplayer = 50.0f;

const float	BasicArmor::_highRangePercent = 0.75f;
const float	BasicArmor::_midRangePercent = 0.50f;
const float	BasicArmor::_lowRangePercent = 0.25f;



CLASS_DECLARATION( Armor, BasicArmor, NULL )
{
	{ NULL, NULL }
};

BasicArmor::BasicArmor()
{
	maximum_amount = _maxAmount;
	setName( "BasicArmor" );
	turnThinkOn();

	_lastAddTime = 0.0f;
}

//
// Name:        ResolveDamage() 
// Class:       BasicAmor
//
// Description: Resolves the damage.
//
// Parameters:  float damage -- The initial damage.
//
// Returns:     float newDamage -- The new damage after armor factor is taken into account
//
float BasicArmor::ResolveDamage( float damage , int meansOfDeath , const Vector &direction , const Vector &position , Entity *attacker )
{
	float tempDamage;
	float damageAbsorbed;
	float percent;
	float highRangeCutoff;
	float midRangeCutoff;


	if ( ( meansOfDeath == MOD_ARMOR_PIERCING ) || ( meansOfDeath == MOD_IMOD_PRIMARY ) || 
		 ( meansOfDeath == MOD_IMOD_SECONDARY ) || ( meansOfDeath == MOD_DEATH_QUAD ) )
		return damage;

	// Determine which cutoff values to use

	if ( multiplayerManager.inMultiplayer() )
	{
		highRangeCutoff = _highRangeCutoffMultiplayer;
		midRangeCutoff  = _midRangeCutoffMultiplayer;
	}
	else
	{
		highRangeCutoff = _highRangeCutoffSinglePlayer;
		midRangeCutoff  = _midRangeCutoffSinglePlayer;
	}

	// Figure out amount to absorb
	
	if ( amount > highRangeCutoff )
		percent = _highRangePercent;
	else if ( amount > midRangeCutoff )
		percent = _midRangePercent;
	else
		percent = _lowRangePercent;

	tempDamage = damage * percent;
	
	if ( amount > tempDamage )
		damageAbsorbed = tempDamage;
	else
		damageAbsorbed = amount;
	
	// Damage the armor
	
	amount -= damageAbsorbed;
	if ( amount < 0.0 )
		amount = 0.0;
	
	// Return damage left
	
	return damage - damageAbsorbed;
}

void BasicArmor::Think( void )
{
	if ( ( level.time > _lastAddTime + 1.0f ) && ( amount > _normalMaxAmount ) )
	{
		amount -= level.frametime * _lossRate;

		if ( amount < _normalMaxAmount )
		{
			amount = _normalMaxAmount;
		}
	}
}

void BasicArmor::Add( int num )
{
	Armor::Add( num );

	_lastAddTime = level.time;
}

//--------------------------------------------------------------
// Name:		CanBeDamagedBy()
// Class:		BasicArmor
//
// Description:	Checks if this armor will aborb 100% of the damage
//				for the specified Means Of Death
//
// Parameters:	int meansOfDeath
//
// Returns:		true or false
//--------------------------------------------------------------
bool BasicArmor::CanBeDamagedBy( int meansOfDeath )
{
	return true;
}

//--------------------------------------------------------------
// Name:		_needThisArmor
// Class:		BasicArmor
//
// Description:	Checks to see if we need more armor
//
// Parameters:	Sentient *sentient				- sentient that wants to know if it can have more armor
//
// Returns:		true or false
//--------------------------------------------------------------

qboolean BasicArmor::_needThisArmor( Sentient *sentient )
{
	int currentArmorValue = sentient->GetArmorValue();

  	if( currentArmorValue < _maxAmount )
		return true;
	else
		return false;
}

void BasicArmor::cacheStrings( void )
{
	G_FindConfigstringIndex( va( "$$PickedUp$$ %d $$Item-Armor$$", (int)amount ), CS_GENERAL_STRINGS, MAX_GENERAL_STRINGS, true );
}

//-------------------------------------------------------------------------
// ShieldArmor Implementation
//-------------------------------------------------------------------------
CLASS_DECLARATION( Armor, ShieldArmor, NULL )
{
	{ &EV_Armor_SetActiveStatus,			&ShieldArmor::SetActiveStatus 			},
	{ &EV_Armor_SetMultiplier,			 	&ShieldArmor::SetMultiplier				},
	{ &EV_Armor_AddToNoProtectionList,	  	&ShieldArmor::AddMODToNoProtectionList	},
	{ &EV_Armor_UseArmorDirection,		   	&ShieldArmor::SetShieldDirection		},

	{ NULL, NULL }
};

ShieldArmor::ShieldArmor()
{
	maximum_amount = 100.0f;
	//amount = 100.0f;
	setName( "ShieldArmor" );
	_active = true;
	_multiplier = 0.0f;
	_directionMin = -90.0;
	_directionMax = 90.0;
	_useDirection = false;

}

void ShieldArmor::SetActiveStatus( Event *ev )
{
	_active = ev->GetBoolean( 1 );
}

void ShieldArmor::SetMultiplier( Event *ev )
{
	_multiplier = ev->GetFloat( 1 );
}

bool ShieldArmor::CanBeUsed()
{
	if ( amount > 0 )
		return true;

	return false;
}

//
// Name:        ResolveDamage() 
// Class:       BasicAmor
//
// Description: Resolves the damage.
//
// Parameters:  float damage -- The initial damage.
//
// Returns:     float newDamage -- The new damage after armor factor is taken into account
//
float ShieldArmor::ResolveDamage( float damage , int meansOfDeath , const Vector &direction , const Vector &position , Entity *attacker )
{
	//Shield Armor basically acts as a "life meter" for a shield.  If the armor is actor 
	//and he have an armor value greater than 0, then we take 0 damage.  The as soon as the 
	//amount is less than 0, then we start taking full damage.
	if ( !_active ) return damage;
	
	int inNoProtectionList = 0;

	inNoProtectionList = _noProtectionList.IndexOfObject( meansOfDeath );

	if ( inNoProtectionList )
		return damage;

	if ( meansOfDeath == MOD_ARMOR_PIERCING )
		return damage;
	
	if ( amount <= 0 )
	{
		amount = 0.0f;
		return damage;
	}
	

	if ( _useDirection )
		{
		Vector directionAngle = direction.toAngles();
		float directionYaw = AngleNormalize180( directionAngle[YAW] );
		if ( (directionYaw > _directionMax) || (directionYaw < _directionMin) )
			{
			return damage;
			}
		}

	amount -= damage;
	
	if ( amount < 0 )
		amount = 0.0f;
	
	if ( amount > 0 )
	{
		// We blocked so spawn an effect
		
		str modelName;
		Vector effectAngles;
		
		effectAngles = direction;
		effectAngles.toAngles();
		
		modelName = "ReflectionModel-";
		modelName += MOD_NumToName( meansOfDeath );
		modelName += ".gdb";
		
		SpawnEffect( modelName, position, vec_zero, 1.0f );
		
		return (damage * _multiplier);
	}		
	
	return damage;	
}

//--------------------------------------------------------------
// Name:		CanBeDamagedBy()
// Class:		BasicArmor
//
// Description:	Checks if this armor will aborb 100% of the damage
//				for the specified Means Of Death
//
// Parameters:	int meansOfDeath
//
// Returns:		true or false
//--------------------------------------------------------------
bool ShieldArmor::CanBeDamagedBy( int meansOfDeath )
{
	return true;
}


void ShieldArmor::AddMODToNoProtectionList( Event *ev )
{
	str MODName = ev->GetString( 1 );
	AddMODToNoProtectionList( MODName );
}

void ShieldArmor::AddMODToNoProtectionList(const str &MODName )
{
	unsigned int theMOD = MOD_NameToNum( MODName.c_str() );

	_noProtectionList.AddUniqueObject( theMOD );	
}

void ShieldArmor::SetShieldDirection( Event *ev )
{
	SetShieldDirection( ev->GetFloat(1) , ev->GetFloat(2) );
}

void ShieldArmor::SetShieldDirection( float minAngle, float maxAngle )
{
	_useDirection = true;
	_directionMin = minAngle;
	_directionMax = maxAngle;
}