// Created by Ivan_the_B
//

#include "Actor.h"
#include "Entity.h"
#include "Projectile.h"
#include "script/Script_Thread.h"
#include "gamesys/SysCvar.h"
#include "Game_local.h"
#include "Moveable.h"
#include "AI.h"
#include "AI_bot.h"


/*
===============================================================================

	idAI_Bot

===============================================================================
*/

const idEventDef AI_Bot_SelectWeapon( "selectBotWeapon", "d", 'd' );
const idEventDef AI_Bot_SelectAnotherWeapon( "selectAnotherWeapon", "dd", 'd' );
const idEventDef AI_Bot_GetCurrentWeapon( "getCurrentBotWeapon", NULL, 'd' );
const idEventDef AI_Bot_GetWeaponNumByName( "getBotWeaponNumByName", "s", 'd' );
const idEventDef AI_Bot_FireWeapon( "fireWeapon", NULL, 'e' );
const idEventDef AI_Bot_CanHitEnemyFromCurrentWeapon( "canHitEnemyFromCurrentWeapon", NULL, 'd' );
const idEventDef AI_Bot_CanFireToEnemyNoSelfDamage( "canFireToEnemyNoSelfDamage", "d", 'd' );
const idEventDef AI_Bot_CanHitEnemyFromFireAnim( "canHitEnemyFromFireAnim", "d", 'd' ); 
const idEventDef AI_Bot_GetIdleAnim( "getIdleAnim", NULL, 's' );
const idEventDef AI_Bot_GetReloadAnim( "getReloadAnim", NULL, 's' );
const idEventDef AI_Bot_GetFireAnim( "getFireAnim", NULL, 's' );
const idEventDef AI_Bot_ReloadWeapon( "reloadWeapon" );
const idEventDef AI_Bot_GetAmmoInClip( "getAmmoInClip", NULL, 'd' );
const idEventDef AI_Bot_GetClipSize( "getClipSize", NULL, 'd' );
const idEventDef AI_Bot_CheckReloadTolerance( "checkReloadTolerance", NULL, 'd' );
const idEventDef AI_Bot_GetRandomTargetTypePrefix( "getRandomTargetTypePrefix", "ss", 'e' );
const idEventDef AI_Bot_LostTimeMoreThan( "lostTimeMoreThan", "d", 'd' );
const idEventDef AI_Bot_WeaponChangedMoreThan( "weaponChangedMoreThan", "d", 'd' );
const idEventDef AI_Bot_PlayAnimOnWeapon( "playAnimOnWeapon", "s" );
const idEventDef AI_Bot_ReleaseNode( "releaseCurrentNode" );
const idEventDef AI_Bot_TryLockNode( "tryLockNode", "e", 'd' );
const idEventDef AI_Bot_FindEnemyAIorPL( "findEnemyAIorPL", "d", 'e' );

/*
//redefined:
const idEventDef AI_CanHitEnemyFromAnim( "canHitEnemyFromAnim", "s", 'd' ); 
const idEventDef AI_CreateMissile( "createMissile", "s", 'e' ); 
const idEventDef AI_LaunchMissile( "launchMissile", "vv", 'e' ); 
const idEventDef AI_CanHitEnemyFromJoint( "canHitEnemyFromJoint", "s", 'd' ); 
*/



CLASS_DECLARATION( idAI, idAI_Bot ) 
	EVENT( AI_Bot_SelectWeapon,					idAI_Bot::Event_SelectWeapon )
	EVENT( AI_Bot_SelectAnotherWeapon,			idAI_Bot::Event_SelectAnotherWeapon )
	EVENT( AI_Bot_GetCurrentWeapon,				idAI_Bot::Event_GetCurrentWeapon )
	EVENT( AI_Bot_GetWeaponNumByName,			idAI_Bot::Event_GetWeaponNumByName ) 
	EVENT( AI_Bot_FireWeapon,					idAI_Bot::Event_FireWeapon )  
	EVENT( AI_Bot_CanHitEnemyFromCurrentWeapon,	idAI_Bot::Event_CanHitEnemyFromCurrentWeapon ) 
	EVENT( AI_Bot_CanFireToEnemyNoSelfDamage,	idAI_Bot::Event_CanFireToEnemyNoSelfDamage )
	EVENT( AI_Bot_CanHitEnemyFromFireAnim,		idAI_Bot::Event_CanHitEnemyFromFireAnim )
	EVENT( AI_Bot_GetIdleAnim,					idAI_Bot::Event_GetIdleAnim )
	EVENT( AI_Bot_GetReloadAnim,				idAI_Bot::Event_GetReloadAnim )
	EVENT( AI_Bot_GetFireAnim,					idAI_Bot::Event_GetFireAnim )
	EVENT( AI_Bot_ReloadWeapon,					idAI_Bot::Event_ReloadWeapon )
	EVENT( AI_Bot_GetAmmoInClip,				idAI_Bot::Event_GetAmmoInClip )
	EVENT( AI_Bot_GetClipSize,					idAI_Bot::Event_GetClipSize )
	EVENT( AI_Bot_CheckReloadTolerance,			idAI_Bot::Event_CheckReloadTolerance ) 
	EVENT( AI_Bot_LostTimeMoreThan,				idAI_Bot::Event_LostTimeMoreThan )
	EVENT( AI_Bot_WeaponChangedMoreThan,		idAI_Bot::Event_WeaponChangedMoreThan )
	EVENT( AI_Bot_PlayAnimOnWeapon,				idAI_Bot::Event_PlayAnimOnWeapon )
	EVENT( AI_Bot_ReleaseNode,					idAI_Bot::Event_ReleaseNode )
	EVENT( AI_Bot_TryLockNode,					idAI_Bot::Event_TryLockNode )
	EVENT( AI_Bot_FindEnemyAIorPL,				idAI_Bot::Event_FindEnemyAIorPL )
	
	EVENT( AI_CanHitEnemyFromAnim,				idAI_Bot::Event_CanHitEnemyFromAnim ) //redefined
	EVENT( AI_CreateMissile,					idAI_Bot::Event_CreateMissile ) //redefined
	EVENT( AI_LaunchMissile,					idAI_Bot::Event_LaunchMissile ) //redefined
	EVENT( AI_CanHitEnemyFromJoint,				idAI_Bot::Event_CanHitEnemyFromJoint ) //redefined
	EVENT( AI_Burn,								idAI_Bot::Event_Burn )
END_CLASS


/*
===============================================================================

	Constructor and Destructor

===============================================================================
*/

/*
=====================
idAI_Bot::idAI_Bot
=====================
*/

idAI_Bot::idAI_Bot() {
	currentWeapon = -1; //nothing
	lastHitFCWCheckResult = false;
	lastHitFCWCheckTime = 0; 
	lastHitNSDCheckResult = false;
	lastHitNSDCheckTime = 0;
	lastVisibleEnemyTime = 0;
	lastWeaponChangedTime = 0;
	currentNode = NULL;
	weapons.SetGranularity( 1 );
}


/*
=====================
idAI_Bot::~idAI_Bot
=====================
*/

idAI_Bot::~idAI_Bot() {
	int i;
	idEntity *ent;

	//gameLocal.Printf("~idAI_Bot!\n");

	DeconstructScriptObject();
	scriptObject.Free();
	
	// remove any attached entities
	for( i = 0; i < weapons.Num(); i++ ) {
		//weapon entity
		ent = weapons[ i ].ent.GetEntity();
		if ( ent ) {
			ent->PostEventMS( &EV_Remove, 0 );
		}

		//projectileClipModel
		delete weapons[ i ].projectileClipModel;
	}
}

/*
=====================
idAI_Bot::Save
=====================
*/
void idAI_Bot::Save( idSaveGame *savefile ) const {
	int i;

	currentNode.Save( savefile );
	savefile->WriteInt( currentWeapon );
	savefile->WriteInt( lastVisibleEnemyTime );
	savefile->WriteBool( lastHitFCWCheckResult );
	savefile->WriteInt( lastHitFCWCheckTime );
	savefile->WriteBool( lastHitNSDCheckResult );
	savefile->WriteInt( lastHitNSDCheckTime );
	savefile->WriteInt( lastWeaponChangedTime );

	savefile->WriteInt( weapons.Num() );
	for( i = 0; i < weapons.Num(); i++ ) {
		//spawn settings
		weapons[i].ent.Save( savefile );
		savefile->WriteInt( weapons[i].channel );
		savefile->WriteJoint( weapons[i].fireJoint );
		savefile->WriteJoint( weapons[i].bindJoint );
		savefile->WriteJoint( weapons[i].flashJoint ); 
	
		//weapon
		savefile->WriteInt( weapons[i].priorityLevel );
		savefile->WriteBool( weapons[i].enabled );
		savefile->WriteString( weapons[i].weaponName );
		savefile->WriteFloat( weapons[i].minSelfDmgDistance );

		//projectile - const idDict * projectileDef
		idStr projectileName;
		idEntity *ent;
		ent = weapons[ i ].ent.GetEntity();
		ent->spawnArgs.GetString( "def_projectile", "", projectileName );
		savefile->WriteString( projectileName );


		//projectile - other stuff
		savefile->WriteFloat( weapons[i].projectileRadius );
		savefile->WriteFloat( weapons[i].projectileSpeed );
		savefile->WriteVec3( weapons[i].projectileVelocity );
		savefile->WriteVec3( weapons[i].projectileGravity );

		//mutable idClipModel *projectileClipModel; NOT SAVED

		//attack settings
		savefile->WriteFloat( weapons[i].attack_accuracy );
		savefile->WriteFloat( weapons[i].projectile_spread );
		savefile->WriteInt( weapons[i].num_projectiles );

		//clip
		savefile->WriteInt( weapons[i].clipSize );
		savefile->WriteInt( weapons[i].ammoInClip );
		savefile->WriteInt( weapons[i].reloadTolerance );

		//light
		savefile->WriteMaterial( weapons[i].shader );
		savefile->WriteVec3( weapons[i].flashColor );
		savefile->WriteFloat( weapons[i].flashRadius );
		savefile->WriteInt( weapons[i].flashTime );

	}


}

/*
=====================
idAI_Bot::Restore
=====================
*/
void idAI_Bot::Restore( idRestoreGame *savefile ) {
	int	num;
	int i;

	//gameLocal.Printf("idAI_Bot::Restore\n");
	
	currentNode.Restore( savefile );

	savefile->ReadInt( currentWeapon );
	savefile->ReadInt( lastVisibleEnemyTime );
	savefile->ReadBool( lastHitFCWCheckResult );
	savefile->ReadInt( lastHitFCWCheckTime );
	savefile->ReadBool( lastHitNSDCheckResult );
	savefile->ReadInt( lastHitNSDCheckTime );
	savefile->ReadInt( lastWeaponChangedTime );

	savefile->ReadInt( num );
	weapons.SetGranularity( 1 );
	weapons.SetNum( num );

	for( i = 0; i < num; i++ ) {
		//spawn settings
		weapons[i].ent.Restore( savefile );
		savefile->ReadInt( weapons[i].channel );
		savefile->ReadJoint( weapons[i].fireJoint );
		savefile->ReadJoint( weapons[i].bindJoint );
		savefile->ReadJoint( weapons[i].flashJoint ); 
	
		//weapon
		savefile->ReadInt( weapons[i].priorityLevel );
		savefile->ReadBool( weapons[i].enabled );
		savefile->ReadString( weapons[i].weaponName );
		savefile->ReadFloat( weapons[i].minSelfDmgDistance );

		//projectile - const idDict * projectileDef
		idStr projectileName;
		savefile->ReadString( projectileName );
		if ( projectileName.Length() ) {
			weapons[ i ].projectileDef = gameLocal.FindEntityDefDict( projectileName );
		} else {
			weapons[ i ].projectileDef = NULL;
		}


		//projectile - other stuff
		savefile->ReadFloat( weapons[i].projectileRadius );
		savefile->ReadFloat( weapons[i].projectileSpeed );
		savefile->ReadVec3( weapons[i].projectileVelocity );
		savefile->ReadVec3( weapons[i].projectileGravity );

		//mutable idClipModel *projectileClipModel; NOT SAVED
		weapons[ i ].projectileClipModel = NULL;

		//attack settings
		savefile->ReadFloat( weapons[i].attack_accuracy );
		savefile->ReadFloat( weapons[i].projectile_spread );
		savefile->ReadInt( weapons[i].num_projectiles );

		//clip
		savefile->ReadInt( weapons[i].clipSize );
		savefile->ReadInt( weapons[i].ammoInClip );
		savefile->ReadInt( weapons[i].reloadTolerance );

		//light
		savefile->ReadMaterial( weapons[i].shader );
		savefile->ReadVec3( weapons[i].flashColor );
		savefile->ReadFloat( weapons[i].flashRadius );
		savefile->ReadInt( weapons[i].flashTime );	

		// Link the script variables back to the scriptobject
		LinkScriptVariables();

		//upd muzzle light
		setWeaponMuzzleFlash();
	}
}


/*
===============================================================================

	Pain and talk stuff

===============================================================================
*/

/*
=====================
idAI::Pain
=====================

bool idAI::Pain( idEntity *inflictor, idEntity *attacker, int damage, const idVec3 &dir, int location ) {
	
	SAY_DAMAGE = true;

	return idAI::Pain( inflictor, attacker, damage, dir, location );
}
*/


/*
===============================================================================

	Spawn and remove stuff

===============================================================================
*/

/*
=====================
idAI_Bot::Spawn
=====================
*/
void idAI_Bot::Spawn( void ) {
	//gameLocal.Printf("idAI_Bot::Spawn\n");

	CreateWeapons();
	SelectInitialWeapon();
	ShowOnlyCurrentWeapon();
	LinkScriptVariables();
	/*
	//Warning: idAI_Bot::CalculateAttackOffsets is called by idAI::Spawn --> weapons are no available yet!
	//CalculateAttackOffsets(); 
	*/
}

/*
=====================
idAI_Bot::LinkScriptVariables
=====================
*/
void idAI_Bot::LinkScriptVariables( void ) {
	//idAI::LinkScriptVariables(); //useless because idAI::spawn() also calls idAI::LinkScriptVariables()
	AI_WEAPON_CHANGED.LinkTo( scriptObject, "AI_WEAPON_CHANGED" );
	AI_WEAPON_NEED_RELOAD.LinkTo( scriptObject, "AI_WEAPON_NEED_RELOAD" );
	AI_LEAVE_NODE_TO_FIGHT.LinkTo( scriptObject, "AI_LEAVE_NODE_TO_FIGHT" );
	AI_SAY_DAMAGED.LinkTo( scriptObject, "AI_SAY_DAMAGED" );
}

/*
================
idAI_Bot::CreateWeapons
================
*/
void idAI_Bot::CreateWeapons( void ) {
	idEntity *ent;
	idStr	weaponName;

	// spawn any weapons we might have
	const idKeyValue *kv = spawnArgs.MatchPrefix( "def_weapon_", NULL );
	while ( kv ) {
		idDict args;
		
		args.Set( "classname", kv->GetValue().c_str() ); //TODO: check it!?

		// make items non-touchable so the player can't take them out of the character's hands
		args.Set( "no_touch", "1" );

		// don't let them drop to the floor
		args.Set( "dropToFloor", "0" );

		gameLocal.SpawnEntityDef( args, &ent );
		if ( !ent ) {
			gameLocal.Error( "Couldn't spawn '%s' to attach to entity '%s'", kv->GetValue().c_str(), name.c_str() );
		} else {
			// get the weapon name
			weaponName = kv->GetKey();
			weaponName.Strip( "def_weapon_" );
			AttachWeapon( ent, weaponName );
		}
		kv = spawnArgs.MatchPrefix( "def_weapon_", kv );
	}
}


/*
================
idAI_Bot::AttachWeapon
================
*/
void idAI_Bot::AttachWeapon( idEntity *ent, idStr weaponName) { //TODO: spawn only the enabled ones
	idVec3			origin;
	idMat3			axis;
	jointHandle_t	bindJoint;
	//jointHandle_t	fireJoint;
	idStr			jointName;
	idBotWeapon	&attach = weapons.Alloc();
	idAngles		angleOffset;
	idVec3			originOffset;

	idStr			projectileName;
	idAnimator		*entAnimator;

	//weapon number
	currentWeapon = weapons.NumAllocated()-1; //needed to make CreateProjectile working properly

	//bindJoint
	jointName = ent->spawnArgs.GetString( "bindJoint" );
	bindJoint = animator.GetJointHandle( jointName );
	if ( bindJoint == INVALID_JOINT ) {
		gameLocal.Error( "Joint '%s' not found for attaching '%s' on '%s'", jointName.c_str(), ent->GetClassname(), name.c_str() );
	}
	attach.bindJoint = bindJoint;

	angleOffset = ent->spawnArgs.GetAngles( "angles" );
	originOffset = ent->spawnArgs.GetVector( "origin" );

	attach.channel = animator.GetChannelForJoint( bindJoint );
	GetJointWorldTransform( bindJoint, gameLocal.time, origin, axis );
	attach.ent = ent;

	ent->SetOrigin( origin + originOffset * renderEntity.axis );
	idMat3 rotate = angleOffset.ToMat3();
	idMat3 newAxis = rotate * axis;
	ent->SetAxis( newAxis );
	ent->BindToJoint( this, bindJoint, true );
	ent->cinematic = cinematic;
	
	//fire joint
	jointName = ent->spawnArgs.GetString( "fireJoint", "barrel"); //default is barrel
	entAnimator = ent->GetAnimator(); 
	if ( entAnimator && entAnimator->ModelHandle() ) { // check if the entity has an MD5 model
		attach.fireJoint = entAnimator->GetJointHandle( jointName ); //this could also be INVALID_JOINT!
		attach.flashJoint = entAnimator->GetJointHandle( "flash" ); //this could also be INVALID_JOINT!
	}else{
		attach.fireJoint = INVALID_JOINT;
		attach.flashJoint = INVALID_JOINT;
	}

	/*
	//test only
	if ( attach.fireJoint == INVALID_JOINT ) {  
		gameLocal.Printf("fireJoint == INVALID_JOINT\n");
	}else{
		gameLocal.Printf("fireJoint is valid: %d \n", attach.fireJoint);
	}*/
	
	//name 
	attach.weaponName = weaponName;

	//enabled 
	attach.enabled = spawnArgs.GetBool(attach.weaponName.c_str(),"0"); //default disabled

	//projectile
	if ( ent->spawnArgs.GetString( "def_projectile", "", projectileName ) && projectileName.Length() ) {
			//gameLocal.Printf("def_projectile found\n");
			attach.projectileDef = gameLocal.FindEntityDefDict( projectileName );
			CreateProjectile( vec3_origin, viewAxis[ 0 ] ); //this sets the variable projectile
			attach.projectileRadius	= projectile.GetEntity()->GetPhysics()->GetClipModel()->GetBounds().GetRadius();
			attach.projectileVelocity	= idProjectile::GetVelocity( attach.projectileDef );
			attach.projectileGravity	= idProjectile::GetGravity( attach.projectileDef );
			attach.projectileSpeed	= projectileVelocity.Length();
			delete projectile.GetEntity();
			projectile = NULL;

			attach.attack_accuracy = ent->spawnArgs.GetFloat( "attack_accuracy", "1" ); //was 7 
			attach.projectile_spread = ent->spawnArgs.GetFloat( "projectile_spread", "0" );
			attach.num_projectiles = ent->spawnArgs.GetInt( "num_projectiles", "1" );
			attach.clipSize = ent->spawnArgs.GetInt( "clipSize", "0" );  //0 = unlimited
			if(attach.clipSize < 0){ attach.clipSize = 0; }
			attach.ammoInClip = attach.clipSize; //start with full ammo
			attach.reloadTolerance = ent->spawnArgs.GetInt( "reloadTolerance", "0" );
			attach.minSelfDmgDistance = ent->spawnArgs.GetFloat( "minSelfDmgDistance", "0" );

			//light
			attach.flashColor = ent->spawnArgs.GetVector( "flashColor", "0 0 0" );
			attach.flashRadius = ent->spawnArgs.GetFloat( "flashRadius" );	
			attach.flashTime = SEC2MS( ent->spawnArgs.GetFloat( "flashTime", "0.25" ) );

			const char *shader;
			spawnArgs.GetString( "mtr_flashShader", "muzzleflash", &shader );
			attach.shader = declManager->FindMaterial( shader, false );

	}else{
			//gameLocal.Printf("def_projectile not found\n");
			attach.projectileDef = NULL;
			attach.projectileRadius = 0.0f;
			attach.projectileSpeed =  0.0f;
			attach.projectileVelocity = vec3_origin;
			attach.projectileGravity = vec3_origin;

			attach.attack_accuracy = 0.0f;
			attach.projectile_spread = 0.0f;
			attach.num_projectiles = 0;
			attach.clipSize = 0;
			attach.ammoInClip = 0;
			attach.reloadTolerance = 0;
			attach.minSelfDmgDistance = 0;

			attach.flashColor = vec3_origin; 
			attach.flashRadius = 0.0f;
			attach.flashTime = 0;
			attach.shader = NULL;
	}	

	attach.priorityLevel = ent->spawnArgs.GetInt( "priorityLevel", "0" );
	attach.projectileClipModel = NULL; //will be initialized later

	//gameLocal.Printf("fireJoint check: %d \n", weapons[ currentWeapon ].fireJoint);
}


/*
===================
idAI_Bot::CalculateAttackOffsets

calculate joint positions on attack frames so we can do proper "can hit" tests
===================
*/
void idAI_Bot::CalculateAttackOffsets( void ) { //Warning: this is called by idAI::Spawn --> weapons are no available yet!
	const idDeclModelDef	*modelDef;
	int						num;
	int						i;
	int						frame;
	const frameCommand_t	*command;
	idMat3					axis;
	const idAnim			*anim;
	jointHandle_t			joint;

	//gameLocal.Printf("idAI_Bot::CalculateAttackOffsets \n");

	modelDef = animator.ModelDef();
	if ( !modelDef ) {
		return;
	}
	num = modelDef->NumAnims();
	
	// needs to be off while getting the offsets so that we account for the distance the monster moves in the attack anim
	animator.RemoveOriginOffset( false );

	// anim number 0 is reserved for non-existant anims.  to avoid off by one issues, just allocate an extra spot for
	// launch offsets so that anim number can be used without subtracting 1.
	missileLaunchOffset.SetGranularity( 1 );
	missileLaunchOffset.SetNum( num + 1 );
	missileLaunchOffset[ 0 ].Zero();

	for( i = 1; i <= num; i++ ) {
		missileLaunchOffset[ i ].Zero();
		anim = modelDef->GetAnim( i );
		if ( anim ) {
			/*
			frame = anim->FindFrameForFrameCommand( FC_LAUNCHMISSILE, &command );
			if ( frame >= 0 ) {
				joint = animator.GetJointHandle( command->string->c_str() );
				if ( joint == INVALID_JOINT ) {
					gameLocal.Error( "Invalid joint '%s' on 'launch_missile' frame command on frame %d of model '%s'", command->string->c_str(), frame, modelDef->GetName() );
				}
				GetJointTransformForAnim( joint, i, FRAME2MS( frame ), missileLaunchOffset[ i ], axis );
			}*/

			//ivan - fix for new framecommand --> this allows CanHitEnemyFromAnim to work
			frame = anim->FindFrameForFrameCommand( FC_FIREWEAPON, &command );
			if ( frame >= 0 ) {
				//gameLocal.Printf("FC_FIREWEAPON trovato: '%s' \n", anim->Name());
				joint = animator.GetJointHandle( "PISTOL_ATTACHER" ); //TODO: fix this hack.
				if ( joint == INVALID_JOINT ) {
					gameLocal.Error( "Invalid joint on 'fire_weapon' frame command on frame %d of model '%s'", frame, modelDef->GetName() );
				}
				GetJointTransformForAnim( joint, i, FRAME2MS( frame ), missileLaunchOffset[ i ], axis );
			}else{
				//gameLocal.Printf("FC_FIREWEAPON non trovato: '%s' \n", anim->Name());
			}
			//ivan end
		}
	}

	animator.RemoveOriginOffset( true );
}

/*
=====================
idAI_Bot::DropWeapon
=====================
*/
void idAI_Bot::DropWeapon( int weaponNum ) {
	int ammoToAdd; 
	idVec3 velocity;
	idEntity *myweapon;
	idEntity *item;

	if(weaponNum < 0 || weaponNum >= weapons.Num() ){
		return;
	}

	myweapon = weapons[ weaponNum ].ent.GetEntity();
	item = NULL;

	const char *classname = myweapon->spawnArgs.GetString( "def_dropItem" );
	if ( !classname[0] ) {
		return;
	}

	velocity = 150.0f * idAngles( -60, current_yaw, 0 ).ToForward();

	item = idMoveableItem::DropItem( classname, myweapon->GetPhysics()->GetOrigin(), myweapon->GetPhysics()->GetAxis(), velocity , 200, AI_WEAPON_DROP_TIME );
	if ( !item ) {
		return;
	}

	if(weapons[ weaponNum ].clipSize <= 0){ //do nothing if clipSize is unlimited
		//gameLocal.Printf("clipSize <= 0\n");
		return;
	}
		
	const idKeyValue * keyval = item->spawnArgs.MatchPrefix( "inv_ammo_" );	
	if ( keyval ) {
		ammoToAdd = weapons[ weaponNum ].ammoInClip;
		if(ammoToAdd <= 0){ ammoToAdd = 1; } //at least 1
		//gameLocal.Printf("clipSize %d \n",ammoToAdd);
		item->spawnArgs.SetInt( keyval->GetKey(), ammoToAdd );
	}

}

/*
=====================
idAI_Bot::Killed
=====================
*/
void idAI_Bot::Killed( idEntity *inflictor, idEntity *attacker, int damage, const idVec3 &dir, int location ) {
	idAI::Killed( inflictor, attacker, damage, dir, location );
	
	// drop the current weapon
	DropWeapon(currentWeapon);

	//now we can remove all the weapons
	RemoveWeapons();

	//be sure...
	flashJointWorld = INVALID_JOINT; 

	//release the current node
	if ( currentNode.GetEntity() ) {
		currentNode.GetEntity()->Release();
		currentNode = NULL;
	}
}
/*
================
idAI_Bot::RemoveWeapons
================
*/
void idAI_Bot::RemoveWeapons( void ) { 
	int i;
	idEntity *ent;

	// remove any attached weapons
	for( i = 0; i < weapons.Num(); i++ ) {
		//weapon entity
		ent = weapons[ i ].ent.GetEntity();
		if ( ent ) {
			ent->PostEventMS( &EV_Remove, 0 );
		}

		//projectileClipModel
		delete weapons[ i ].projectileClipModel;
	}

	weapons.Clear();
	currentWeapon = -1;
}

/*
===============================================================================

	Weapon selection and utilities

===============================================================================
*/


/*
================
idAI_Bot::SelectInitialWeapon
================
*/
void idAI_Bot::SelectInitialWeapon( void ) { 
	int weaponNum;
	idStr initialweaponValue;

	currentWeapon = -1; //start without weapons
	weaponNum = -1; //default is none

	//get the initialweapon key
	initialweaponValue = spawnArgs.GetString( "initialweapon", "" );
	if( initialweaponValue.Length() ){
		weaponNum = GetWeaponNumByName( initialweaponValue );
		//gameLocal.Printf("The initial requested weapon is: %d \n" ,weaponNum);
		SelectWeapon(weaponNum); //could upd currentWeapon
	}	

	//still no weapon selected... try to select the higher one.
	if(currentWeapon < 0){ 
		for( weaponNum = weapons.Num()-1; weaponNum >= 0; weaponNum-- ) {
			if ( weapons[ weaponNum ].enabled) {
				SelectWeapon(weaponNum); //currentWeapon = weaponNum;
				break;
			}
		}
	}

	//gameLocal.Printf("The initial weapon is: %d \n" ,currentWeapon);
}


/*
================
idAI_Bot::GetWeaponNumByName
================
*/
int idAI_Bot::GetWeaponNumByName(idStr name) { 
	int i;
	for( i = 0; i < weapons.Num(); i++ ) {
		if ( weapons[ i ].weaponName == name) {
			return i;
		}
	}
	return -1; //no weapon
}

/*
================
idAI_Bot::SelectWeapon
================
*/
bool idAI_Bot::SelectWeapon( int weaponNum ) {
	//gameLocal.Printf("SelectWeapon requested: %d \n" ,weaponNum);
	
	if (weaponNum == currentWeapon){
		//gameLocal.Printf("The requested weapon:%d is already selected\n" ,weaponNum);
		return false;
	}
	if( weaponNum < -1 || weaponNum >= weapons.Num()){ //if 3 allocated, max allowed value is 2. Note: -1 is accepted because means 'no weapon'
		gameLocal.Warning("The requested weapon: %d is out of range" ,weaponNum);
		return false;
	}

	if( (weaponNum >= 0)  && !weapons[ weaponNum ].enabled){
		gameLocal.Warning("The requested weapon: %d is disabled" ,weaponNum);
		return false;
	}

	//hide the current one
	if(currentWeapon >= 0){
		weapons[ currentWeapon ].ent.GetEntity()->Hide();
	}

	//show the new one
	if(weaponNum >= 0){
		weapons[ weaponNum ].ent.GetEntity()->Show();
		//ammo
		if(weapons[ weaponNum ].clipSize > 0){ //only if limited clip size
			if(weapons[ weaponNum ].ammoInClip <= 0){
				AI_WEAPON_NEED_RELOAD = true;
			}else{
				AI_WEAPON_NEED_RELOAD = false;
			}
		}
	}else{ //no weapon selected
		AI_WEAPON_NEED_RELOAD = false;
	}

	//remove the current projectileClipModel so that it'll be recreated the next time GetAimDir is called
	//DeleteProjectileClipModel();

	//upd the currentWeapon
	currentWeapon = weaponNum;
	//gameLocal.Printf("SelectWeapon done: %d \n" ,currentWeapon);

	//remember this moment 
	lastWeaponChangedTime = gameLocal.time;

	//flash joint
	if(currentWeapon >= 0){
		flashJointWorld = weapons[ currentWeapon ].flashJoint;
	}else{
		flashJointWorld = INVALID_JOINT;
	}

	//upd light
	setWeaponMuzzleFlash(); //ok because currentWeapon already updated

	//upd script
	AI_WEAPON_CHANGED = true;
	return true;
}


/*
================
idAI_Bot::ShowOnlyCurrentWeapon
================
*/
void idAI_Bot::ShowOnlyCurrentWeapon( void ) {
	int i;
	idEntity *ent;

	// remove any attached entities
	for( i = 0; i < weapons.Num(); i++ ) {
		ent = weapons[ i ].ent.GetEntity();
		if (i == currentWeapon ) {
			ent->Show();
		}else{
			ent->Hide();
		}
	}
}


/*
================
idAI_Bot::TriggerWeaponEffects
================
*/
void idAI_Bot::TriggerWeaponEffects( const idVec3 &muzzle ) {
	idVec3 org;
	idMat3 axis;
	idEntity *myWeaponEnt; 

	if ( !g_muzzleFlash.GetBool() ) {
		return;
	}

	myWeaponEnt = weapons[ currentWeapon ].ent.GetEntity();	
	if(myWeaponEnt->GetRenderEntity()){
		myWeaponEnt->GetRenderEntity()->shaderParms[SHADERPARM_TIMEOFFSET] = -MS2SEC( gameLocal.time );
		myWeaponEnt->GetRenderEntity()->shaderParms[ SHADERPARM_DIVERSITY ] = gameLocal.random.CRandomFloat();
	}

	if ( flashJointWorld != INVALID_JOINT ) { //flashJointWorld has been updated on weapon selection
		//was: GetJointWorldTransform( flashJointWorld, gameLocal.time, org, axis );
	
		//get the reference to the weapon animator
		idAnimator *myWeaponAnimator;
		myWeaponAnimator = myWeaponEnt->GetAnimator(); 

		//do the equivalent of GetJointWorldTransform even without being casted to idAnimatedEntity
		myWeaponAnimator->GetJointTransform( flashJointWorld, gameLocal.time, org, axis );
		myWeaponEnt->ConvertLocalToWorldTransform( org, axis );

		if ( worldMuzzleFlash.lightRadius.x > 0.0f ) {
			worldMuzzleFlash.axis = axis;
			worldMuzzleFlash.shaderParms[SHADERPARM_TIMEOFFSET] = -MS2SEC( gameLocal.time );
			if ( worldMuzzleFlashHandle != - 1 ) {
				gameRenderWorld->UpdateLightDef( worldMuzzleFlashHandle, &worldMuzzleFlash );
			} else {
				worldMuzzleFlashHandle = gameRenderWorld->AddLightDef( &worldMuzzleFlash );
			}
			muzzleFlashEnd = gameLocal.time + flashTime;
			UpdateVisuals();
		}
	}
}


/*
================
idAI_Bot::UpdateMuzzleFlash
================
*/
void idAI_Bot::UpdateMuzzleFlash( void ) {
	if ( worldMuzzleFlashHandle != -1 ) { 
		if ( gameLocal.time >= muzzleFlashEnd ) {
			gameRenderWorld->FreeLightDef( worldMuzzleFlashHandle );
			worldMuzzleFlashHandle = -1;
		} else {
			if ( flashJointWorld != INVALID_JOINT ) { //flashJointWorld has been updated on weapon selection
				idVec3 muzzle;
				idEntity *myWeaponEnt;
				idAnimator *myWeaponAnimator;

				//get the reference to the weapon and its animator
				myWeaponEnt = weapons[ currentWeapon ].ent.GetEntity();
				myWeaponAnimator = myWeaponEnt->GetAnimator(); 

				//do the equivalent of GetJointWorldTransform even without being casted to idAnimatedEntity
				myWeaponAnimator->GetJointTransform( flashJointWorld, gameLocal.time, muzzle, worldMuzzleFlash.axis );
				myWeaponEnt->ConvertLocalToWorldTransform( muzzle, worldMuzzleFlash.axis );

				worldMuzzleFlash.origin = muzzle;
				gameRenderWorld->UpdateLightDef( worldMuzzleFlashHandle, &worldMuzzleFlash );
			}
		}
	}
}

/*
===================
idAI_Bot::InitMuzzleFlash
===================
*/
void idAI_Bot::InitMuzzleFlash( void ) { //called on spawn and on relaod. NOTE: in both cases weapons are not created yet --> just set default values.
	
	//gameLocal.Printf("idAI_Bot::InitMuzzleFlash\n");

	flashTime = 0;

	memset( &worldMuzzleFlash, 0, sizeof ( worldMuzzleFlash ) );

	worldMuzzleFlash.pointLight = true;
	worldMuzzleFlash.shader = NULL;
	worldMuzzleFlash.shaderParms[ SHADERPARM_RED ] = 0.0f;
	worldMuzzleFlash.shaderParms[ SHADERPARM_GREEN ] = 0.0f;
	worldMuzzleFlash.shaderParms[ SHADERPARM_BLUE ] = 0.0f;
	worldMuzzleFlash.shaderParms[ SHADERPARM_ALPHA ] = 1.0f;
	worldMuzzleFlash.shaderParms[ SHADERPARM_TIMESCALE ] = 1.0f;
	worldMuzzleFlash.lightRadius[0] = 0.0f;
	worldMuzzleFlash.lightRadius[1]	= 0.0f;
	worldMuzzleFlash.lightRadius[2]	= 0.0f;
	worldMuzzleFlash.noShadows = spawnArgs.GetBool( "flashNoShadows" );

	worldMuzzleFlashHandle = -1;
}


/*
================
idAI_Bot::setWeaponMuzzleFlash
================
*/
void idAI_Bot::setWeaponMuzzleFlash( void ) {
	const idMaterial *	shader;	
	idVec3				flashColor;
	float				flashRadius;

	if(currentWeapon < 0 || currentWeapon >= weapons.Num()){
		shader = NULL;
		flashColor = vec3_origin;
		flashRadius = 0.0f;
		flashTime = 0; //global
	}else{
		shader = weapons[ currentWeapon ].shader;
		flashColor = weapons[ currentWeapon ].flashColor;
		flashRadius = weapons[ currentWeapon ].flashRadius;
		flashTime = weapons[ currentWeapon ].flashTime; //global
	}
	
	worldMuzzleFlash.shader = shader;
	worldMuzzleFlash.shaderParms[ SHADERPARM_RED ] = flashColor[0];
	worldMuzzleFlash.shaderParms[ SHADERPARM_GREEN ] = flashColor[1];
	worldMuzzleFlash.shaderParms[ SHADERPARM_BLUE ] = flashColor[2];
	worldMuzzleFlash.lightRadius[0] = flashRadius;
	worldMuzzleFlash.lightRadius[1]	= flashRadius;
	worldMuzzleFlash.lightRadius[2]	= flashRadius;
}

/*
===============================================================================

	Projectiles stuff

===============================================================================
*/


/*
=====================
idAI_Bot::DeleteProjectileClipModel 
=====================

void idAI_Bot::DeleteProjectileClipModel( void ) const { 
	//remove the current projectileClipModel so that it'll be recreated the next time GetAimDir or other functions are called
	delete projectileClipModel;
	projectileClipModel = NULL;
}
*/

/*
=====================
idAI_Bot::CreateProjectileClipModel 
=====================
*/
void idAI_Bot::CreateProjectileClipModel( void ) const { //warning! a weapon needs to be selected when you call this!
	if ( weapons[ currentWeapon ].projectileClipModel == NULL ) {
		idBounds projectileBounds( vec3_origin );
		projectileBounds.ExpandSelf( weapons[ currentWeapon ].projectileRadius );
		weapons[ currentWeapon ].projectileClipModel = new idClipModel( idTraceModel( projectileBounds ) );
	}
}

/*
=====================
idAI_Bot::CreateProjectileClipModel 
=====================
*/
void idAI_Bot::CreateProjectileClipModel( int requestedWeapon ) const { //warning! make sure the requested weapon exists when you call this!
	if ( weapons[ requestedWeapon ].projectileClipModel == NULL ) {
		idBounds projectileBounds( vec3_origin );
		projectileBounds.ExpandSelf( weapons[ requestedWeapon ].projectileRadius );
		weapons[ requestedWeapon ].projectileClipModel = new idClipModel( idTraceModel( projectileBounds ) );
	}
}


/*
=====================
idAI_Bot::CreateProjectile
=====================
*/
idProjectile *idAI_Bot::CreateProjectile( const idVec3 &pos, const idVec3 &dir ) { //NOTE: make sure a weapon is selected and it has a weapon before calling this
	idEntity *ent;
	const char *clsname;
	const idDict *	currentProjectileDef;

	if ( !projectile.GetEntity() ) {
		currentProjectileDef = weapons[ currentWeapon ].projectileDef; 
		gameLocal.SpawnEntityDef( *currentProjectileDef, &ent, false );

		if ( !ent ) {
			clsname = currentProjectileDef->GetString( "classname" );
			gameLocal.Error( "Could not spawn entityDef '%s'", clsname );
		}
		
		if ( !ent->IsType( idProjectile::Type ) ) {
			clsname = ent->GetClassname();
			gameLocal.Error( "'%s' is not an idProjectile", clsname );
		}
		projectile = ( idProjectile * )ent;
	}
	projectile.GetEntity()->Create( this, pos, dir );
	return projectile.GetEntity();
}



/*
=====================
idAI_Bot::LaunchProjectile
=====================
*/
idProjectile *idAI_Bot::LaunchProjectile( const char *jointname, idEntity *target, bool clampToAttackCone ) {
	idVec3				muzzle;
	idVec3				dir;
	idVec3				start;
	trace_t				tr;
	idBounds			projBounds;
	float				distance;
	const idClipModel	*projClip;
	float				attack_accuracy;
	float				attack_cone;
	float				projectile_spread;
	float				diff;
	float				angle;
	float				spin;
	idAngles			ang;
	int					num_projectiles;
	int					i;
	idMat3				axis;
	idVec3				tmp;
	idProjectile		*lastProjectile;

	if ( currentWeapon < 0){
		gameLocal.Warning( "%s (%s) is trying to fire but doesn't have a weapon selected", name.c_str(), GetEntityDefName() );
		return NULL;
	}

	if ( !weapons[ currentWeapon ].projectileDef ) {
		gameLocal.Warning( "%s (%s) : the current weapon doesn't have a projectile specified", name.c_str(), GetEntityDefName() );
		return NULL;
	}

	attack_accuracy = weapons[ currentWeapon ].attack_accuracy;
	attack_cone = spawnArgs.GetFloat( "attack_cone", "70" );
	projectile_spread = weapons[ currentWeapon ].projectile_spread;
	num_projectiles = weapons[ currentWeapon ].num_projectiles;

	GetMuzzle( jointname, muzzle, axis );

	if ( !projectile.GetEntity() ) {
		CreateProjectile( muzzle, axis[ 0 ] );
	}

	lastProjectile = projectile.GetEntity();

	if ( target != NULL ) {
		tmp = target->GetPhysics()->GetAbsBounds().GetCenter() - muzzle;
		tmp.Normalize();
		axis = tmp.ToMat3();
	} else {
		axis = viewAxis;
	}

	// rotate it because the cone points up by default
	tmp = axis[2];
	axis[2] = axis[0];
	axis[0] = -tmp;

	// make sure the projectile starts inside the monster bounding box
	const idBounds &ownerBounds = physicsObj.GetAbsBounds();
	projClip = lastProjectile->GetPhysics()->GetClipModel();
	projBounds = projClip->GetBounds().Rotate( axis );

	// check if the owner bounds is bigger than the projectile bounds
	if ( ( ( ownerBounds[1][0] - ownerBounds[0][0] ) > ( projBounds[1][0] - projBounds[0][0] ) ) &&
		( ( ownerBounds[1][1] - ownerBounds[0][1] ) > ( projBounds[1][1] - projBounds[0][1] ) ) &&
		( ( ownerBounds[1][2] - ownerBounds[0][2] ) > ( projBounds[1][2] - projBounds[0][2] ) ) ) {
		if ( (ownerBounds - projBounds).RayIntersection( muzzle, viewAxis[ 0 ], distance ) ) {
			start = muzzle + distance * viewAxis[ 0 ];
		} else {
			start = ownerBounds.GetCenter();
		}
	} else {
		// projectile bounds bigger than the owner bounds, so just start it from the center
		start = ownerBounds.GetCenter();
	}

	gameLocal.clip.Translation( tr, start, muzzle, projClip, axis, MASK_SHOT_RENDERMODEL, this );
	muzzle = tr.endpos;

	// set aiming direction
	GetAimDirByWeapon( muzzle, target, this, dir, currentWeapon);
	ang = dir.ToAngles();

	// adjust his aim so it's not perfect.  uses sine based movement so the tracers appear less random in their spread.
	float t = MS2SEC( gameLocal.time + entityNumber * 497 );
	ang.pitch += idMath::Sin16( t * 5.1 ) * attack_accuracy;
	ang.yaw	+= idMath::Sin16( t * 6.7 ) * attack_accuracy;

	if ( clampToAttackCone ) {
		// clamp the attack direction to be within monster's attack cone so he doesn't do
		// things like throw the missile backwards if you're behind him
		diff = idMath::AngleDelta( ang.yaw, current_yaw );
		if ( diff > attack_cone ) {
			ang.yaw = current_yaw + attack_cone;
		} else if ( diff < -attack_cone ) {
			ang.yaw = current_yaw - attack_cone;
		}
	}

	axis = ang.ToMat3();

	float spreadRad = DEG2RAD( projectile_spread );
	for( i = 0; i < num_projectiles; i++ ) {
		// spread the projectiles out
		angle = idMath::Sin( spreadRad * gameLocal.random.RandomFloat() );
		spin = (float)DEG2RAD( 360.0f ) * gameLocal.random.RandomFloat();
		dir = axis[ 0 ] + axis[ 2 ] * ( angle * idMath::Sin( spin ) ) - axis[ 1 ] * ( angle * idMath::Cos( spin ) );
		dir.Normalize();

		// launch the projectile
		if ( !projectile.GetEntity() ) {
			CreateProjectile( muzzle, dir );
		}
		lastProjectile = projectile.GetEntity();
		lastProjectile->Launch( muzzle, dir, vec3_origin );
		projectile = NULL;
	}

	//weapon fxs
	TriggerWeaponEffects( muzzle );

	//ammo
	if(weapons[ currentWeapon ].clipSize > 0){ //only if limited clip size
		weapons[ currentWeapon ].ammoInClip--;
		if(weapons[ currentWeapon ].ammoInClip <= 0){
			AI_WEAPON_NEED_RELOAD = true;
		}
	}

	lastAttackTime = gameLocal.time;

	return lastProjectile;
}


/*
===============================================================================

	Misc

===============================================================================	
*/

/*
=====================
idAI_Bot::GetAimDir
=====================
*/
bool idAI_Bot::GetAimDir( const idVec3 &firePos, idEntity *aimAtEnt, const idEntity *ignore, idVec3 &aimDir ) const {
	return GetAimDirByWeapon( firePos, aimAtEnt, ignore, aimDir, currentWeapon);
}


/*
=====================
idAI_Bot::GetAimDirByWeapon
=====================
*/
bool idAI_Bot::GetAimDirByWeapon( const idVec3 &firePos, idEntity *aimAtEnt, const idEntity *ignore, idVec3 &aimDir, int weaponToTest) const {
	idVec3	targetPos1;
	idVec3	targetPos2;
	idVec3	delta;
	float	max_height;
	bool	result;

	//if no weapon is selected
	if ( weaponToTest < 0 || weaponToTest >= weapons.Num()){ 
		gameLocal.Warning( "idAI_Bot::GetAimDirByWeapon: the weapon to test is out of range" );
		return false;
	}

	// if no aimAtEnt or projectile set
	if ( !aimAtEnt || !weapons[ weaponToTest ].projectileDef ) {
		aimDir = viewAxis[ 0 ] * physicsObj.GetGravityAxis();
		return false;
	}

	if ( weapons[ weaponToTest ].projectileClipModel == NULL ) {
		CreateProjectileClipModel( weaponToTest );
	}

	if ( aimAtEnt == enemy.GetEntity() ) {
		static_cast<idActor *>( aimAtEnt )->GetAIAimTargets( lastVisibleEnemyPos, targetPos1, targetPos2 );
	} else if ( aimAtEnt->IsType( idActor::Type ) ) {
		static_cast<idActor *>( aimAtEnt )->GetAIAimTargets( aimAtEnt->GetPhysics()->GetOrigin(), targetPos1, targetPos2 );
	} else {
		targetPos1 = aimAtEnt->GetPhysics()->GetAbsBounds().GetCenter();
		targetPos2 = targetPos1;
	}

	// try aiming for chest
	delta = firePos - targetPos2;
	max_height = delta.LengthFast() * projectile_height_to_distance_ratio;
	result = PredictTrajectory( firePos, targetPos2, weapons[ weaponToTest ].projectileSpeed, weapons[ weaponToTest ].projectileGravity, weapons[ weaponToTest ].projectileClipModel, MASK_SHOT_RENDERMODEL, max_height, ignore, aimAtEnt, ai_debugTrajectory.GetBool() ? 1000 : 0, aimDir );
	if ( result || !aimAtEnt->IsType( idActor::Type ) ) {
		return result;
	}

	// try aiming for head
	delta = firePos - targetPos1;
	max_height = delta.LengthFast() * projectile_height_to_distance_ratio;
	result = PredictTrajectory( firePos, targetPos1, weapons[ weaponToTest ].projectileSpeed, weapons[ weaponToTest ].projectileGravity, weapons[ weaponToTest ].projectileClipModel, MASK_SHOT_RENDERMODEL, max_height, ignore, aimAtEnt, ai_debugTrajectory.GetBool() ? 1000 : 0, aimDir );

	return result;
}

/*
================
idAI_Bot::GetMuzzle
================
*/
void idAI_Bot::GetMuzzle( const char *jointname, idVec3 &muzzle, idMat3 &axis ) { 
	jointHandle_t joint;

	if ( !jointname || !jointname[ 0 ] ) { //new behaviour: is nothing is passed, use the current weapon settings
		if(currentWeapon >= 0){
			//WEAPON CASE 1: weapon fireJoint!
			if(weapons[ currentWeapon ].fireJoint != INVALID_JOINT){ //if fireJoint is valid, we are sure the entity has an MD5 model
				idEntity *myWeaponEnt;
				idAnimator *myWeaponAnimator;

				//get the reference to the weapon and its animator
				myWeaponEnt = weapons[ currentWeapon ].ent.GetEntity();
				myWeaponAnimator = myWeaponEnt->GetAnimator(); 

				//use the fireJoint!
				joint = weapons[ currentWeapon ].fireJoint; //myWeaponAnimator->GetJointHandle( "barrel" ); //

				//do the equivalent of GetJointWorldTransform even without being casted to idAnimatedEntity
				myWeaponAnimator->GetJointTransform( joint, gameLocal.time, muzzle, axis );
				myWeaponEnt->ConvertLocalToWorldTransform( muzzle, axis );
				
				//gameLocal.Printf("GetMuzzle che usa fireJoint\n");
			}
			//WEAPON CASE 2: my bindJoint !
			else{ 
				joint = weapons[ currentWeapon ].bindJoint; //bindJoint is always valid
				GetJointWorldTransform( joint, gameLocal.time, muzzle, axis );
				//gameLocal.Printf("GetMuzzle che usa bindJoint\n");
			}
		//NO-WEAPON CASE 1: my origin
		}else{ 
			muzzle = physicsObj.GetOrigin() + viewAxis[ 0 ] * physicsObj.GetGravityAxis() * 14;
			muzzle -= physicsObj.GetGravityNormal() * physicsObj.GetBounds()[ 1 ].z * 0.5f;
		}
	//NO-WEAPON CASE 2: my specified joint
	} else {
		joint = animator.GetJointHandle( jointname );
		if ( joint == INVALID_JOINT ) {
			gameLocal.Error( "Unknown joint '%s' on %s", jointname, GetEntityDefName() );
		}
		GetJointWorldTransform( joint, gameLocal.time, muzzle, axis );
	}
}


/*
================
idAI_Bot::Show
================
*/
void idAI_Bot::Show( void ) {
	idAI::Show();
	ShowOnlyCurrentWeapon();
}


/*
===============================================================================

	Weapon events

===============================================================================
*/


/*
================
idAI_Bot::Event_SelectWeapon
================
*/
void idAI_Bot::Event_SelectWeapon( int weaponNum ){
	//gameLocal.Printf("Event_SelectWeapon requested: %d \n" ,weaponNum);
	idThread::ReturnInt( SelectWeapon( weaponNum ) );
}

/*
================
idAI_Bot::Event_SelectAnotherWeapon
================
*/
void idAI_Bot::Event_SelectAnotherWeapon( int idealLevel, int minLevel ){ 
	int testWeapon;
	int nextWeapon;
	int wCounter;
	int wNum;

	wNum = weapons.Num();

	//ideal loop
	testWeapon = currentWeapon;
	nextWeapon = currentWeapon;

	for( wCounter = 0; wCounter < wNum; wCounter++ ) { //do exactly a complete loop (also test the current weapon so that it's ok even if we start from -1)
		
		//find the next one
		testWeapon++;
		if(testWeapon >= wNum){testWeapon = 0;}

		//test it
		if ( (weapons[ testWeapon ].enabled) && (weapons[ testWeapon ].priorityLevel >= idealLevel) ) {
			nextWeapon = testWeapon;
			break;
		}
	}

	if(nextWeapon != currentWeapon){ //found!
		idThread::ReturnInt( SelectWeapon( nextWeapon ) ); //it's enabled and on range, so no way this could be false.
		return;
	}

	//minlevel loop
	testWeapon = currentWeapon;
	nextWeapon = currentWeapon;

	for( wCounter = 0; wCounter < wNum; wCounter++ ) { //do exactly a complete loop (also test the current weapon so that it's ok even if we start from -1)
		
		//find the next one
		testWeapon++;
		if(testWeapon >= wNum){testWeapon = 0;}

		//test it
		if ( (weapons[ testWeapon ].enabled) && (weapons[ testWeapon ].priorityLevel >= minLevel) ) {
			nextWeapon = testWeapon;
			break;
		}
	}

	if(nextWeapon != currentWeapon){ //found!
		idThread::ReturnInt( SelectWeapon( nextWeapon ) ); //it's enabled and on range, so no way this can be false.
		return;
	}

	//nothing can satisfy the conditions
	idThread::ReturnInt( false );

}

/*
================
idAI_Bot::Event_ReloadWeapon
================
*/
void idAI_Bot::Event_ReloadWeapon( void ){
	AI_WEAPON_NEED_RELOAD = false;
	if( currentWeapon < 0) return;
	weapons[ currentWeapon ].ammoInClip = weapons[ currentWeapon ].clipSize;
}

/*
================
idAI_Bot::Event_CheckReloadTolerance
================
*/
void idAI_Bot::Event_CheckReloadTolerance( void ){ //returns true if we should reload
	if( currentWeapon < 0){ //no weapon selected
		idThread::ReturnInt( false );
		return;
	}

	if( weapons[ currentWeapon ].clipSize == 0){ //unlimited clip
		idThread::ReturnInt( false );
		return;
	}

	if(	weapons[ currentWeapon ].ammoInClip > weapons[ currentWeapon ].reloadTolerance ){ //still enough ammo
		idThread::ReturnInt( false );
		return;
	}
	
	//reloading is a good idea at this point...
	idThread::ReturnInt( true );
	return;
}


/*
================
idAI_Bot::Event_GetAmmoInClip
================
*/
void idAI_Bot::Event_GetAmmoInClip( void ){
	if( currentWeapon < 0){
		idThread::ReturnInt( 0 );
		return;
	}

	idThread::ReturnInt( weapons[ currentWeapon ].ammoInClip );
}

/*
================
idAI_Bot::Event_GetClipSize
================
*/
void idAI_Bot::Event_GetClipSize( void ){
	if( currentWeapon < 0){
		idThread::ReturnInt( 0 );
		return;
	}

	idThread::ReturnInt( weapons[ currentWeapon ].clipSize );
}


/*
================
idAI_Bot::Event_GetCurrentWeapon
================
*/
void idAI_Bot::Event_GetCurrentWeapon( void ){
	idThread::ReturnInt( currentWeapon );
}

/*
================
idAI_Bot::Event_GetWeaponNumByName
================
*/
void idAI_Bot::Event_GetWeaponNumByName( const char *weaponName ){
	int weaponNum;
	weaponNum = GetWeaponNumByName( idStr( weaponName ) );
	idThread::ReturnInt( weaponNum );
}

/*
===============================================================================

	Anims events

===============================================================================
*/

/*
=====================
idAI_Bot::Event_GetIdleAnim
=====================
*/

void idAI_Bot::Event_GetIdleAnim( void ) {
	const char *animname;
	if(currentWeapon < 0){
		animname = "idle";
	}else{
		animname = va( "%s_idle", weapons[ currentWeapon ].weaponName.c_str() ); 
	}
	idThread::ReturnString( animname );
}

/*
=====================
idAI_Bot::Event_GetReloadAnim
=====================
*/

void idAI_Bot::Event_GetReloadAnim( void ) {
	const char *animname;
	if(currentWeapon < 0){
		animname = "idle"; //in case someone tries to reload but no weapon is selected :)
	}else{
		animname = va( "%s_reload", weapons[ currentWeapon ].weaponName.c_str() ); 
	}
	idThread::ReturnString( animname );
}

/*
=====================
idAI_Bot::Event_GetReloadAnim
=====================
*/

void idAI_Bot::Event_GetFireAnim( void ) {
	const char *animname;
	if(currentWeapon < 0){
		animname = "idle"; //in case someone tries to fire but no weapon is selected :)
	}else{
		animname = va( "%s_fire", weapons[ currentWeapon ].weaponName.c_str() ); 
	}
	idThread::ReturnString( animname );
}

/*
===============================================================================

	Fire events

===============================================================================
*/

/*
=====================
idAI_Bot::Event_FireWeapon
=====================
*/
void idAI_Bot::Event_FireWeapon( void ) {
	idProjectile *proj;

	proj = LaunchProjectile( "", enemy.GetEntity(), true ); //"" will force the use of weapon specific settings
	idThread::ReturnEntity( proj );
}

/*
=====================
idAI_Bot::Event_CreateMissile
=====================
*/
void idAI_Bot::Event_CreateMissile( const char *jointname ) {
	idVec3 muzzle;
	idMat3 axis;

	//gameLocal.Printf("idAI_Bot::Event_CreateMissile \n");

	//ivan start
	if ( currentWeapon < 0){
		gameLocal.Warning( "idAI_Bot::Event_CreateMissile: %s (%s) is trying to fire but doesn't have a weapon selected", name.c_str(), GetEntityDefName() );
		return idThread::ReturnEntity( NULL );
	}

	if ( !weapons[ currentWeapon ].projectileDef ) {
		gameLocal.Warning( "idAI_Bot::Event_CreateMissile: %s (%s) : the current weapon doesn't have a projectile specified", name.c_str(), GetEntityDefName() );
		return idThread::ReturnEntity( NULL );
	}
	//ivan end

	GetMuzzle( jointname, muzzle, axis );
	CreateProjectile( muzzle, viewAxis[ 0 ] * physicsObj.GetGravityAxis() );
	if ( projectile.GetEntity() ) {
		if ( !jointname || !jointname[ 0 ] ) {
			projectile.GetEntity()->Bind( this, true );
		} else {
			projectile.GetEntity()->BindToJoint( this, jointname, true );
		}
	}
	idThread::ReturnEntity( projectile.GetEntity() );
}


/*
=====================
idAI_Bot::Event_LaunchMissile
=====================
*/
void idAI_Bot::Event_LaunchMissile( const idVec3 &org, const idAngles &ang ) {
	idVec3		start;
	trace_t		tr;
	idBounds	projBounds;
	const idClipModel *projClip;
	idMat3		axis;
	float		distance;

	//gameLocal.Printf("idAI_Bot::Event_LaunchMissile \n");

	//ivan start
	if ( currentWeapon < 0){
		gameLocal.Warning( "idAI_Bot::Event_LaunchMissile: %s (%s) is trying to fire but doesn't have a weapon selected", name.c_str(), GetEntityDefName() );
		idThread::ReturnEntity( NULL );
		return;
	}

	if ( !weapons[ currentWeapon ].projectileDef ) {
		gameLocal.Warning( "idAI_Bot::Event_LaunchMissile: %s (%s) : the current weapon doesn't have a projectile specified", name.c_str(), GetEntityDefName() );
		idThread::ReturnEntity( NULL );
		return;
	}
	//ivan end

	axis = ang.ToMat3();
	if ( !projectile.GetEntity() ) {
		CreateProjectile( org, axis[ 0 ] );
	}

	// make sure the projectile starts inside the monster bounding box
	const idBounds &ownerBounds = physicsObj.GetAbsBounds();
	projClip = projectile.GetEntity()->GetPhysics()->GetClipModel();
	projBounds = projClip->GetBounds().Rotate( projClip->GetAxis() );

	// check if the owner bounds is bigger than the projectile bounds
	if ( ( ( ownerBounds[1][0] - ownerBounds[0][0] ) > ( projBounds[1][0] - projBounds[0][0] ) ) &&
		( ( ownerBounds[1][1] - ownerBounds[0][1] ) > ( projBounds[1][1] - projBounds[0][1] ) ) &&
		( ( ownerBounds[1][2] - ownerBounds[0][2] ) > ( projBounds[1][2] - projBounds[0][2] ) ) ) {
		if ( (ownerBounds - projBounds).RayIntersection( org, viewAxis[ 0 ], distance ) ) {
			start = org + distance * viewAxis[ 0 ];
		} else {
			start = ownerBounds.GetCenter();
		}
	} else {
		// projectile bounds bigger than the owner bounds, so just start it from the center
		start = ownerBounds.GetCenter();
	}

	gameLocal.clip.Translation( tr, start, org, projClip, projClip->GetAxis(), MASK_SHOT_RENDERMODEL, this );

	// launch the projectile
	idThread::ReturnEntity( projectile.GetEntity() );
	projectile.GetEntity()->Launch( tr.endpos, axis[ 0 ], vec3_origin );
	projectile = NULL;

	TriggerWeaponEffects( tr.endpos );

	lastAttackTime = gameLocal.time;
}
 
/*
===============================================================================

	CanHit events

===============================================================================
*/

/*
=====================
idAI_Bot::Event_CanHitEnemyFromCurrentWeapon
=====================
*/
void idAI_Bot::Event_CanHitEnemyFromCurrentWeapon( void ) {
	trace_t	tr;
	idVec3	muzzle;
	idMat3	axis;
	idVec3	start;
	//float	distance;

	idActor *enemyEnt = enemy.GetEntity();
	if ( !AI_ENEMY_VISIBLE || !enemyEnt ) {
		idThread::ReturnInt( false );
		return;
	}

	//ivan start
	if( currentWeapon < 0 ){
		gameLocal.Warning("idAI_Bot::Event_CanHitEnemyFromCurrentWeapon: no weapon selected!");
		idThread::ReturnInt( false );
		return;
	}

	if( !weapons[ currentWeapon ].projectileDef ){
		gameLocal.Warning("idAI_Bot::Event_CanHitEnemyFromCurrentWeapon: no projectile defined!");
		idThread::ReturnInt( false );
		return;
	}
	//ivan end

	
	// don't check twice per frame - makes sense because no parameters can be passed
	if ( gameLocal.time == lastHitFCWCheckTime ) {
		idThread::ReturnInt( lastHitFCWCheckResult );
		return;
	}

	lastHitFCWCheckTime = gameLocal.time;

	//get muzzle and destination positions
	GetMuzzle( "", muzzle, axis ); //"" will force use the weapon fire position
	idVec3 toPos = enemyEnt->GetEyePosition();
	
	if ( weapons[ currentWeapon ].projectileClipModel == NULL ) {
		CreateProjectileClipModel();
	}

	gameLocal.clip.Translation( tr, muzzle, toPos, weapons[ currentWeapon ].projectileClipModel, mat3_identity, MASK_SHOT_BOUNDINGBOX, this );
	if ( tr.fraction >= 1.0f || ( gameLocal.GetTraceEntity( tr ) == enemyEnt ) ) {
		//gameLocal.Printf("OK FromCurrentWeapon!\n");
		lastHitFCWCheckResult = true;
	} else {
		//gameLocal.Printf("NO FromCurrentWeapon!\n");
		lastHitFCWCheckResult = false;
	}

	idThread::ReturnInt( lastHitFCWCheckResult );
}

/*
=====================
idAI_Bot::Event_CanFireToEnemyNoSelfDamage
=====================
*/
void idAI_Bot::Event_CanFireToEnemyNoSelfDamage( int requireVisible ) {
	trace_t	tr;
	idVec3	muzzle;
	idMat3	axis;
	idVec3	start;
	//float	distance;

	idActor *enemyEnt = enemy.GetEntity();
	if ( (!AI_ENEMY_VISIBLE && requireVisible != 0 )  || !enemyEnt ) {
		idThread::ReturnInt( false );
		return;
	}

	//ivan start
	if( currentWeapon < 0 ){
		gameLocal.Warning("idAI_Bot::Event_CanFireToEnemyNoSelfDamage: no weapon selected!");
		idThread::ReturnInt( false );
		return;
	}

	if( !weapons[ currentWeapon ].projectileDef ){
		gameLocal.Warning("idAI_Bot::Event_CanFireToEnemyNoSelfDamage: no projectile defined!");
		idThread::ReturnInt( false );
		return;
	}
	//ivan end

	
	// don't check twice per frame - makes sense because if (requireVisible = true && !AI_ENEMY_VISIBLE) the timer is not updated, so in any case if we are here we are doing the same thing again  
	if ( gameLocal.time == lastHitNSDCheckTime ) {
		idThread::ReturnInt( lastHitNSDCheckResult );
		return;
	}
	lastHitNSDCheckTime = gameLocal.time;

	//get muzzle and destination positions
	GetMuzzle( "", muzzle, axis ); //"" will force use the weapon fire position
	idVec3 toPos = enemyEnt->GetEyePosition();

	if ( weapons[ currentWeapon ].projectileClipModel == NULL ) {
		CreateProjectileClipModel();
	}

	gameLocal.clip.Translation( tr, muzzle, toPos, weapons[ currentWeapon ].projectileClipModel, mat3_identity, MASK_SHOT_BOUNDINGBOX, this );
	
	float dist = ( muzzle - tr.endpos ).LengthFast();
	
	if ( tr.fraction >= 1.0f || ( gameLocal.GetTraceEntity( tr ) == enemyEnt ) ) {
		//gameLocal.Printf("OK NoSelfDamage!\n");
		lastHitNSDCheckResult = true;
	} else if (dist > weapons[ currentWeapon ].minSelfDmgDistance ){ //60.0f
		//gameLocal.Printf("OK NoSelfDamage perche distante %f!\n", dist);
		lastHitNSDCheckResult = true;
	} else {
		//gameLocal.Printf("NO NoSelfDamage!\n");
		lastHitNSDCheckResult = false;
	}

	idThread::ReturnInt( lastHitNSDCheckResult );
}


/*
=====================
idAI_Bot::Event_CanFireNoSelfDamageFromAnim
=====================

void idAI_Bot::Event_CanFireNoSelfDamageFromAnim( const char *animname, int requireVisible ) {
	
}
*/

/*
=====================
idAI_Bot::Event_CanHitEnemyFromFireAnim
=====================
*/
void idAI_Bot::Event_CanHitEnemyFromFireAnim( int weaponToTest ) { //note: it uses the proj of the requested weapon
	int		anim;
	idVec3	dir;
	idVec3	local_dir;
	idVec3	fromPos;
	idMat3	axis;
	idVec3	start;
	trace_t	tr;
	float	distance;
	const char *animname; 

	//gameLocal.Printf("idAI_Bot::Event_CanHitEnemyFromFireAnim called! \n" );

	idActor *enemyEnt = enemy.GetEntity();
	if ( !AI_ENEMY_VISIBLE || !enemyEnt ) {
		idThread::ReturnInt( false );
		return;
	}	

	//ivan start
	if(weaponToTest < 0 || weaponToTest >= weapons.Num()){
		gameLocal.Warning("idAI_Bot::Event_CanHitEnemyFromFireAnim: requested weapon is out of range!");
		idThread::ReturnInt( false );
		return;
	}

	if( !weapons[ weaponToTest ].projectileDef ){
		gameLocal.Warning("idAI_Bot::Event_CanHitEnemyFromFireAnim: requested weapon has no projectile defined!");
		idThread::ReturnInt( false );
		return;
	}
	//ivan end

	animname = va( "%s_fire", weapons[ weaponToTest ].weaponName.c_str() ); 
	anim = GetAnim( ANIMCHANNEL_LEGS, animname );
	if ( !anim ) {
		gameLocal.Warning("idAI_Bot::Event_CanHitEnemyFromFireAnim: requested weapon has no fire anim defined!");
		idThread::ReturnInt( false );
		return;
	}

	// just do a ray test if close enough
	if ( enemyEnt->GetPhysics()->GetAbsBounds().IntersectsBounds( physicsObj.GetAbsBounds().Expand( 16.0f ) ) ) {
		Event_CanHitEnemy();
		return;
	}

	// calculate the world transform of the launch position
	
	const idVec3 &org = physicsObj.GetOrigin();
	dir = lastVisibleEnemyPos - org;
	physicsObj.GetGravityAxis().ProjectVector( dir, local_dir );
	local_dir.z = 0.0f;
	local_dir.ToVec2().Normalize();
	axis = local_dir.ToMat3();
	fromPos = physicsObj.GetOrigin() + missileLaunchOffset[ anim ] * axis;
	
	
	//ivan:
	//fromPos = physicsObj.GetOrigin() + missileLaunchOffset[ anim ] * viewAxis * physicsObj.GetGravityAxis();


	if ( weapons[ weaponToTest ].projectileClipModel == NULL ) { //TODO: use the requested one!!!
		CreateProjectileClipModel(weaponToTest);
	}

	// check if the owner bounds is bigger than the projectile bounds
	const idBounds &ownerBounds = physicsObj.GetAbsBounds();
	const idBounds &projBounds = weapons[ weaponToTest ].projectileClipModel->GetBounds();
	if ( ( ( ownerBounds[1][0] - ownerBounds[0][0] ) > ( projBounds[1][0] - projBounds[0][0] ) ) &&
		( ( ownerBounds[1][1] - ownerBounds[0][1] ) > ( projBounds[1][1] - projBounds[0][1] ) ) &&
		( ( ownerBounds[1][2] - ownerBounds[0][2] ) > ( projBounds[1][2] - projBounds[0][2] ) ) ) {
		if ( (ownerBounds - projBounds).RayIntersection( org, viewAxis[ 0 ], distance ) ) {
			start = org + distance * viewAxis[ 0 ];
		} else {
			start = ownerBounds.GetCenter();
		}
	} else {
		// projectile bounds bigger than the owner bounds, so just start it from the center
		start = ownerBounds.GetCenter();
	}	

	gameLocal.clip.Translation( tr, start, fromPos, weapons[ weaponToTest ].projectileClipModel, mat3_identity, MASK_SHOT_RENDERMODEL, this );
	fromPos = tr.endpos;

	if ( GetAimDirByWeapon( fromPos, enemy.GetEntity(), this, dir, weaponToTest) ) {
		//gameLocal.Printf("idAI_Bot::Event_CanHitEnemyFromAnim true!\n");
		idThread::ReturnInt( true );
	} else {
		//gameLocal.Printf("idAI_Bot::Event_CanHitEnemyFromAnim false!\n");
		idThread::ReturnInt( false );
	}
}


/*
=====================
idAI_Bot::Event_CanHitEnemyFromAnim
=====================
*/
void idAI_Bot::Event_CanHitEnemyFromAnim( const char *animname ) { //deprecated: it uses the current projectile!
	int		anim;
	idVec3	dir;
	idVec3	local_dir;
	idVec3	fromPos;
	idMat3	axis;
	idVec3	start;
	trace_t	tr;
	float	distance;

	gameLocal.Warning("idAI_Bot::Event_CanHitEnemyFromAnim is deprecated: it uses the current projectile!");

	idActor *enemyEnt = enemy.GetEntity();
	if ( !AI_ENEMY_VISIBLE || !enemyEnt ) {
		idThread::ReturnInt( false );
		return;
	}

	//ivan start
	if( currentWeapon < 0 ){
		gameLocal.Warning("idAI_Bot::Event_CanHitEnemyFromAnim: no weapon selected!");
		idThread::ReturnInt( false );
		return;
	}

	if( !weapons[ currentWeapon ].projectileDef ){
		gameLocal.Warning("idAI_Bot::Event_CanHitEnemyFromAnim: no projectile defined!");
		idThread::ReturnInt( false );
		return;
	}
	//ivan end

	anim = GetAnim( ANIMCHANNEL_LEGS, animname );
	if ( !anim ) {
		idThread::ReturnInt( false );
		return;
	}

	// just do a ray test if close enough
	if ( enemyEnt->GetPhysics()->GetAbsBounds().IntersectsBounds( physicsObj.GetAbsBounds().Expand( 16.0f ) ) ) {
		Event_CanHitEnemy();
		return;
	}

	// calculate the world transform of the launch position
	const idVec3 &org = physicsObj.GetOrigin();
	dir = lastVisibleEnemyPos - org;
	physicsObj.GetGravityAxis().ProjectVector( dir, local_dir );
	local_dir.z = 0.0f;
	local_dir.ToVec2().Normalize();
	axis = local_dir.ToMat3();
	fromPos = physicsObj.GetOrigin() + missileLaunchOffset[ anim ] * axis;

	if ( weapons[ currentWeapon ].projectileClipModel == NULL ) {
		CreateProjectileClipModel();
	}

	// check if the owner bounds is bigger than the projectile bounds
	const idBounds &ownerBounds = physicsObj.GetAbsBounds();
	const idBounds &projBounds = weapons[ currentWeapon ].projectileClipModel->GetBounds();
	if ( ( ( ownerBounds[1][0] - ownerBounds[0][0] ) > ( projBounds[1][0] - projBounds[0][0] ) ) &&
		( ( ownerBounds[1][1] - ownerBounds[0][1] ) > ( projBounds[1][1] - projBounds[0][1] ) ) &&
		( ( ownerBounds[1][2] - ownerBounds[0][2] ) > ( projBounds[1][2] - projBounds[0][2] ) ) ) {
		if ( (ownerBounds - projBounds).RayIntersection( org, viewAxis[ 0 ], distance ) ) {
			start = org + distance * viewAxis[ 0 ];
		} else {
			start = ownerBounds.GetCenter();
		}
	} else {
		// projectile bounds bigger than the owner bounds, so just start it from the center
		start = ownerBounds.GetCenter();
	}

	gameLocal.clip.Translation( tr, start, fromPos, weapons[ currentWeapon ].projectileClipModel, mat3_identity, MASK_SHOT_RENDERMODEL, this );
	fromPos = tr.endpos;

	if ( GetAimDirByWeapon( fromPos, enemy.GetEntity(), this, dir, currentWeapon ) ) {
		idThread::ReturnInt( true );
	} else {
		idThread::ReturnInt( false );
	}
}


/*
=====================
idAI_Bot::Event_CanHitEnemyFromJoint
=====================
*/
void idAI_Bot::Event_CanHitEnemyFromJoint( const char *jointname ) { //deprecated: it uses the current projectile!
	trace_t	tr;
	idVec3	muzzle;
	idMat3	axis;
	idVec3	start;
	float	distance;

	gameLocal.Warning("idAI_Bot::Event_CanHitEnemyFromJoint is deprecated: it uses the current projectile!");

	idActor *enemyEnt = enemy.GetEntity();
	if ( !AI_ENEMY_VISIBLE || !enemyEnt ) {
		idThread::ReturnInt( false );
		return;
	}

	//ivan start
	if( currentWeapon < 0 ){
		gameLocal.Warning("idAI_Bot::Event_CanHitEnemyFromJoint: no weapon selected!");
		idThread::ReturnInt( false );
		return;
	}

	if( !weapons[ currentWeapon ].projectileDef ){
		gameLocal.Warning("idAI_Bot::Event_CanHitEnemyFromJoint: no projectile defined!");
		idThread::ReturnInt( false );
		return;
	}
	//ivan end

	// don't check twice per frame - we cannot check more than 1 joint per frame!
	if ( gameLocal.time == lastHitCheckTime ) {
		idThread::ReturnInt( lastHitCheckResult );
		return;
	}

	lastHitCheckTime = gameLocal.time;

	const idVec3 &org = physicsObj.GetOrigin();
	idVec3 toPos = enemyEnt->GetEyePosition();
	jointHandle_t joint = animator.GetJointHandle( jointname );
	if ( joint == INVALID_JOINT ) {
		gameLocal.Error( "Unknown joint '%s' on %s", jointname, GetEntityDefName() );
	}
	animator.GetJointTransform( joint, gameLocal.time, muzzle, axis );
	muzzle = org + ( muzzle + modelOffset ) * viewAxis * physicsObj.GetGravityAxis();

	if ( weapons[ currentWeapon ].projectileClipModel == NULL ) {
		CreateProjectileClipModel();
	}

	// check if the owner bounds is bigger than the projectile bounds
	const idBounds &ownerBounds = physicsObj.GetAbsBounds();
	const idBounds &projBounds = weapons[ currentWeapon ].projectileClipModel->GetBounds();
	if ( ( ( ownerBounds[1][0] - ownerBounds[0][0] ) > ( projBounds[1][0] - projBounds[0][0] ) ) &&
		( ( ownerBounds[1][1] - ownerBounds[0][1] ) > ( projBounds[1][1] - projBounds[0][1] ) ) &&
		( ( ownerBounds[1][2] - ownerBounds[0][2] ) > ( projBounds[1][2] - projBounds[0][2] ) ) ) {
		if ( (ownerBounds - projBounds).RayIntersection( org, viewAxis[ 0 ], distance ) ) {
			start = org + distance * viewAxis[ 0 ];
		} else {
			start = ownerBounds.GetCenter();
		}
	} else {
		// projectile bounds bigger than the owner bounds, so just start it from the center
		start = ownerBounds.GetCenter();
	}

	gameLocal.clip.Translation( tr, start, muzzle, weapons[ currentWeapon ].projectileClipModel, mat3_identity, MASK_SHOT_BOUNDINGBOX, this );
	muzzle = tr.endpos;

	gameLocal.clip.Translation( tr, muzzle, toPos, weapons[ currentWeapon ].projectileClipModel, mat3_identity, MASK_SHOT_BOUNDINGBOX, this );
	if ( tr.fraction >= 1.0f || ( gameLocal.GetTraceEntity( tr ) == enemyEnt ) ) {
		lastHitCheckResult = true;
	} else {
		lastHitCheckResult = false;
	}

	idThread::ReturnInt( lastHitCheckResult );
}

/*
=====================
idAI_Bot::Event_FindEnemyAI
=====================
*/
void idAI_Bot::Event_FindEnemyAIorPL( int useFOV ) {
	idEntity	*ent;
	idActor		*actor;
	idActor		*bestEnemy;
	float		bestDist;
	float		dist;
	idVec3		delta;
	pvsHandle_t pvs;
	int			i;

	pvs = gameLocal.pvs.SetupCurrentPVS( GetPVSAreas(), GetNumPVSAreas() );

	bestDist = idMath::INFINITY;
	bestEnemy = NULL;
	for ( ent = gameLocal.activeEntities.Next(); ent != NULL; ent = ent->activeNode.Next() ) {
		if ( ent->fl.hidden || ent->fl.isDormant || !ent->IsType( idActor::Type ) ) {
			continue;
		}

		actor = static_cast<idActor *>( ent );
		if ( ( actor->health <= 0 ) || !( ReactionTo( actor ) & ATTACK_ON_SIGHT ) ) {
			continue;
		}

		if ( !gameLocal.pvs.InCurrentPVS( pvs, actor->GetPVSAreas(), actor->GetNumPVSAreas() ) ) {
			continue;
		}

		delta = physicsObj.GetOrigin() - actor->GetPhysics()->GetOrigin();
		dist = delta.LengthSqr();
		if ( ( dist < bestDist ) && CanSee( actor, useFOV != 0 ) ) {
			bestDist = dist;
			bestEnemy = actor;
		}
	}

	gameLocal.pvs.FreeCurrentPVS( pvs );

	if(bestEnemy != NULL){
		idThread::ReturnEntity( bestEnemy );
		return;
	}

	//else player!

	if ( gameLocal.InPlayerPVS( this ) ) {
		for ( i = 0; i < gameLocal.numClients ; i++ ) {
			ent = gameLocal.entities[ i ];

			if ( !ent || !ent->IsType( idActor::Type ) ) {
				continue;
			}

			actor = static_cast<idActor *>( ent );
			if ( ( actor->health <= 0 ) || !( ReactionTo( actor ) & ATTACK_ON_SIGHT ) ) {
				continue;
			}

			if ( CanSee( actor, useFOV != 0 ) ) {
				idThread::ReturnEntity( actor );
				return;
			}
		}
	}

	idThread::ReturnEntity( NULL );
}

/*
=====================
idAI::Event_Burn
=====================
*/
void idAI_Bot::Event_Burn( void ) {
	idAI::Event_Burn();
	idEntity *myWeaponEnt = weapons[ currentWeapon ].ent.GetEntity();
	if(myWeaponEnt){
		myWeaponEnt->GetRenderEntity()->shaderParms[ SHADERPARM_TIME_OF_DEATH ] = gameLocal.time * 0.001f;
	}
}

/*
===============================================================================

	Misc

===============================================================================
*/

/*
=====================
idAI_Bot::GetEnemyRange
=====================

float idAI_Bot::GetEnemyRange( void ) {
	float dist;
	idActor *enemyEnt = enemy.GetEntity();

	if ( enemyEnt ) {
		dist = ( enemyEnt->GetPhysics()->GetOrigin() - GetPhysics()->GetOrigin() ).Length();
	} else {
		// Just some really high number
		dist = idMath::INFINITY;
	}

	return dist;
}
*/

/*
=====================
idAI_Bot::SetEnemyPosition
=====================
*/
void idAI_Bot::SetEnemyPosition( void ) {
	idAI::SetEnemyPosition();
	lastVisibleEnemyTime = gameLocal.time;
}

/*
=====================
idAI_Bot::Event_LostTimeMoreThan
=====================
*/
void idAI_Bot::Event_LostTimeMoreThan( int time ) {
	if(lastVisibleEnemyTime + SEC2MS( time ) < gameLocal.time){
		//gameLocal.Printf("Event_LostTimeMoreThan true !\n" );
		idThread::ReturnInt( true ); 
	}else{
		//gameLocal.Printf("Event_LostTimeMoreThan false !\n" );
		idThread::ReturnInt( false ); 
	}
}

/*
=====================
idAI_Bot::Event_WeaponChangedMoreThan
=====================
*/
void idAI_Bot::Event_WeaponChangedMoreThan( int time ) {
	if(lastWeaponChangedTime + SEC2MS( time ) < gameLocal.time){
		//gameLocal.Printf("Event_WeaponChangedMoreThan true !\n" );
		idThread::ReturnInt( true ); 
	}else{
		//gameLocal.Printf("Event_WeaponChangedMoreThan false !\n" );
		idThread::ReturnInt( false ); 
	}
}

/*
=====================
idAI_Bot::Event_PlayAnimOnWeapon
=====================
*/
void idAI_Bot::Event_PlayAnimOnWeapon( const char *animname ) {
	if(currentWeapon < 0 ){
		return;
	}
	
	int anim;
	idEntity *myWeaponEnt;
	idAnimator *myWeaponAnimator;
	
	//get the reference to the weapon and its animator
	myWeaponEnt = weapons[ currentWeapon ].ent.GetEntity();	
	myWeaponAnimator = myWeaponEnt->GetAnimator(); 

	// only if the entity has an MD5 model
	if ( myWeaponAnimator && myWeaponAnimator->ModelHandle() ) { 
		anim = myWeaponAnimator->GetAnim( animname );
		if ( !anim ) {
			gameLocal.Warning( "missing '%s' animation on current weapon!", animname );
			myWeaponAnimator->Clear( 0, gameLocal.time, 0 );
		} else {
			myWeaponAnimator->PlayAnim( 0, anim, gameLocal.time, 0 );
		}
	}
}



/*
=====================
idAI_Bot::idAI_Bot
=====================
*/

void idAI_Bot::Event_ReleaseNode( void ) {
	if ( currentNode.GetEntity() ) {
		currentNode.GetEntity()->Release();
		currentNode = NULL;
	}
}


/*
=====================
idAI_Bot::Event_TryLockNode
=====================
*/

void idAI_Bot::Event_TryLockNode( idEntity *node ) {
	bool resultOK;

	if( !node || !node->IsType( idBotNode::Type )){
		gameLocal.Warning("trylock failed: the entity is not an idBotNode!" );
		idThread::ReturnInt( false ); return;
	}

	//cast it
	idBotNode * castedNode;
	castedNode = static_cast<idBotNode *>( node );

	//try
	resultOK = castedNode->TryLock(this);

	if(resultOK){
		//release the current node if test ok
		if( currentNode.GetEntity()){
			currentNode.GetEntity()->Release(); 
		}

		//upd the current node
		currentNode = castedNode;
	}

	idThread::ReturnInt( resultOK );

}



/***********************************************************************

idBotNode

***********************************************************************/

const idEventDef EV_BotNode_EvaluateConditions( "evaluateConditions", NULL, 'd' );
const idEventDef EV_BotNode_GetNextUsableNode( "getNextUsableNode", "e", 'e' );
const idEventDef EV_BotNode_CanBeUsedBy( "canBeUsedBy", "e", 'd' );
const idEventDef EV_BotNode_Reached( "reached" );

CLASS_DECLARATION( idEntity, idBotNode )
	EVENT( EV_BotNode_EvaluateConditions,		idBotNode::Event_EvaluateConditions )
	EVENT( EV_BotNode_GetNextUsableNode,		idBotNode::Event_GetNextUsableNode ) 
	EVENT( EV_BotNode_CanBeUsedBy,				idBotNode::Event_CanBeUsedBy ) 
	EVENT( EV_BotNode_Reached,					idBotNode::Event_Reached )
END_CLASS

/*
=====================
idBotNode::idBotNode
=====================
*/
idBotNode::idBotNode( void ) {
	fight_distance_atnode = 0.0f;
	end_distance_min = 0.0f; 
	end_distance_max = 0.0f;
	node_distance_max = 0.0f;
	end_time = 0;
	end_time_max = 0;
	end_time_min = 0;
	end_health_delta_atnode = 0;
	fight_health_delta_reaching = 0;
	intial_health = 0;
	disabled = false;
	inuse = false;
	reached = false;
	ownerBot = NULL;
}


/*
=====================
idBotNode::Save
=====================
*/
void idBotNode::Save( idSaveGame *savefile ) const {
	savefile->WriteFloat( fight_distance_atnode );
	savefile->WriteFloat( end_distance_min );
	savefile->WriteFloat( end_distance_max );
	savefile->WriteFloat( node_distance_max ); 

	savefile->WriteInt( end_time_max );
	savefile->WriteInt( end_time_min );
	savefile->WriteInt( end_time );

	savefile->WriteInt( end_health_delta_atnode );
	savefile->WriteInt( fight_health_delta_reaching ); 
	savefile->WriteInt( intial_health );

	savefile->WriteBool( disabled );
	savefile->WriteBool( inuse );
	savefile->WriteBool( reached );

	ownerBot.Save( savefile );
}

/*
=====================
idBotNode::Restore
=====================
*/
void idBotNode::Restore( idRestoreGame *savefile ) {
	savefile->ReadFloat( fight_distance_atnode );
	savefile->ReadFloat( end_distance_min );
	savefile->ReadFloat( end_distance_max );
	savefile->ReadFloat( node_distance_max ); 

	savefile->ReadInt( end_time_max );
	savefile->ReadInt( end_time_min );
	savefile->ReadInt( end_time );

	savefile->ReadInt( end_health_delta_atnode );
	savefile->ReadInt( fight_health_delta_reaching ); 
	savefile->ReadInt( intial_health );

	savefile->ReadBool( disabled );
	savefile->ReadBool( inuse );
	savefile->ReadBool( reached );

	ownerBot.Restore( savefile );
}


/*
=====================
idBotNode::Spawn
=====================
*/
void idBotNode::Spawn( void ) {
	fight_distance_atnode = spawnArgs.GetFloat( "fight_distance_atnode" ,"0");
	end_distance_min = spawnArgs.GetFloat( "end_distance_min","0" );
	end_distance_max = spawnArgs.GetFloat( "end_distance_max","0" );
	if( end_distance_min > 0 && (end_distance_min <= fight_distance_atnode)){
		gameLocal.Warning("idBotNode '%s' Spawn: end_distance_min <= fight_distance_atnode! --> end_distance_min will never be used", GetName());
		gameLocal.Warning("FIX: end_distance_min changed to fight_distance_atnode*2");
		end_distance_min = fight_distance_atnode*2; //fix
	}

	end_time_max = spawnArgs.GetInt( "end_time_max","0" );
	end_time_min = spawnArgs.GetInt( "end_time_min","0" );	
	if( end_time_min < 0){end_time_min = 0;}
	if( end_time_max < end_time_min ){end_time_max = end_time_min;}

	end_health_delta_atnode = spawnArgs.GetInt( "end_health_delta_atnode","0" );
	fight_health_delta_reaching = spawnArgs.GetInt( "fight_health_delta_reaching","0" );

	disabled = spawnArgs.GetBool( "start_off" );
	node_distance_max = spawnArgs.GetFloat( "node_distance_max","0" );
}

/*
=====================
idBotNode::TryLock
=====================
*/
bool idBotNode::TryLock( idAI_Bot *activator ) {
	if( !activator ){
		gameLocal.Warning("trylock failed on '%s' : activator not valid!", GetName() );
		return false;
	}
	
	if( disabled || inuse ){
		gameLocal.Warning("trylock failed on '%s' : disabled or inuse!", GetName() );
		return false;
	}

	//time
	if( end_time_min > 0){
		end_time = gameLocal.time + SEC2MS( end_time_min + gameLocal.random.RandomInt(end_time_max - end_time_min) );
	}

	//health
	intial_health = activator->GetHealth();

	//new owner
	ownerBot = activator;
	inuse = true;
	reached = false;
	//gameLocal.Warning("trylock ok on '%s' !", GetName() );
	return true; 
}

/*
=====================
idBotNode::Release
=====================
*/
void idBotNode::Release( void ) {
	if(inuse){
		if ( spawnArgs.GetBool( "use_once" ) ) {
			disabled = true;
		}

		inuse = false;
		reached = false;
		ownerBot = NULL;
		//gameLocal.Printf("node '%s' released!\n", GetName() );
	}
}

/*
=====================
idBotNode::Event_Reached
=====================
*/
void idBotNode::Event_Reached( void ) {
	if(inuse && !reached){
		reached = true;
		intial_health = ownerBot.GetEntity()->GetHealth();
	}
}

/*
=====================
idBotNode::Event_CanBeUsedBy
=====================
*/
void idBotNode::Event_CanBeUsedBy( idEntity *botEntity ) {
	if(disabled || inuse || !botEntity || !botEntity->IsType( idAI_Bot::Type )){
		//gameLocal.Printf("cannot use the node '%s'!\n", GetName() );
		idThread::ReturnInt( false ); return;
	}
	//gameLocal.Printf("can use the node '%s' !\n", GetName() );
	idThread::ReturnInt( true ); 

}


/*
=====================
idBotNode::Event_GetNextNode
=====================
*/
void idBotNode::Event_GetNextUsableNode( idEntity *botEntity ) {
	if( !botEntity || !botEntity->IsType( idAI_Bot::Type )){
		idThread::ReturnInt( false ); return;
	}

	idThread::ReturnEntity( GetNextUsableNode( static_cast<idAI_Bot *>( botEntity ) , 2 ) );
}

/*
=====================
idBotNode::AllNextNodesUsed
=====================
*/
bool idBotNode::AllNextNodesUsed( void ){
	int	i;
	idEntity *ent;
	idBotNode * myNode;
	bool allUsed = true;

	//gameLocal.Printf("idBotNode::AllNextNodesUsed called!\n");

	for( i = 0; i < targets.Num(); i++ ) {
		ent = targets[ i ].GetEntity();		
		if( ent ){
			if ( ent->IsType( idBotNode::Type ) ) {		
				myNode = static_cast<idBotNode *>( ent );
				if( !myNode->IsInUse() ){
					allUsed = false;
					//gameLocal.Printf("uno libero trovato: '%s'\n",myNode->GetName() );
					break;
				}
			}
		}
	}

	return allUsed ;
}


/*
=====================
idBotNode::GetNextUsableNode
=====================
*/
idEntity * idBotNode::GetNextUsableNode( idAI_Bot *botEntity, int lookAheadMaxLevel ) {
	int	i;
	int	numBotNodes;
	int	numOkEnts;
	int which;
	bool addItToList;
	idBotNode * myNode;

	//gameLocal.Printf("idBotNode::GetNextUsableNode!\n");

	idEntity *ent;
	idEntity *ents[ MAX_GENTITIES ];
	idBotNode *botNodeEnts[ MAX_GENTITIES ];

	numBotNodes = 0;
	
	//create a list containing the next idBotNodes
	for( i = 0; i < targets.Num(); i++ ) {
		ent = targets[ i ].GetEntity();		
		if( ent ){
			if ( ent->IsType( idBotNode::Type ) ) {		
				myNode = static_cast<idBotNode *>( ent );

				botNodeEnts[ numBotNodes++ ] = myNode;
				if ( numBotNodes >= MAX_GENTITIES ) {
					break;
				}
			}
		}
	}

	if ( !numBotNodes ) { //no nodes next
		//gameLocal.Printf("no nodi dopo!\n");
		return NULL;
	}

	numOkEnts = 0;

	//create a sub list containing the next VALID idBotNodes
	for( i = 0; i < numBotNodes; i++ ) {
		myNode = botNodeEnts[ i ];	
		addItToList = true;

		if( myNode->IsInUse() || ( myNode->DistanceContidionsTrue( botEntity ) < DISTANCE_COND_NOENEMY )){
			addItToList = false;
		}

		if (idStr::Cmp( myNode->GetEntityDefName(), "ai_bot_attack_path_corner" ) == 0) {
			if( myNode->AllNextNodesUsed() ){ addItToList = false; } //if it leads to used targets
		}

		if(addItToList){
			ents[ numOkEnts++ ] = myNode;
			if ( numOkEnts >= MAX_GENTITIES ) {
				break;
			}
		}

	}

	if ( numOkEnts ) {
		which = gameLocal.random.RandomInt( numOkEnts );
		//gameLocal.Printf("preso uno random dei %d nodi trovati: '%s' \n", numOkEnts, ents[ which ]->GetName() ); 
		return ents[ which ] ;
	}

	//nothing? Try looking ahead!
	lookAheadMaxLevel--;
	if(lookAheadMaxLevel > 0){
		for( i = 0; i < numBotNodes; i++ ) {
			ent = botNodeEnts[ i ]->GetNextUsableNode( botEntity, lookAheadMaxLevel );
			if(ent){ 
				//gameLocal.Printf("trovato uno con ricorsione: '%s' \n", ent->GetName() );
				return ent; 
			}
		}
	}

	//nothing
	//gameLocal.Printf("nothing found :( \n");
	return NULL;
}

/*
=====================
idBotNode::DistanceContidionsTrue
=====================
*/
int idBotNode::DistanceContidionsTrue( idAI_Bot *testEntity ) {
	idEntity * testEnemy; 
	float entityRange;
	float enemyRange;

	//entity stuff	
	if( node_distance_max > 0.0f ){ 
		entityRange = ( testEntity->GetPhysics()->GetOrigin() - GetPhysics()->GetOrigin() ).LengthFast();
		if( entityRange > node_distance_max ){
			//gameLocal.Printf("The node is too far\n" );
			return DISTANCE_COND_TOOFAR;
		}
	}
	
	//enemy stuff
	testEnemy = testEntity->GetEnemy();

	if(!testEnemy){
		//gameLocal.Printf("DistanceContidions !testEnemy...\n" );
		return DISTANCE_COND_NOENEMY; 
	}

	enemyRange = ( testEnemy->GetPhysics()->GetOrigin() - GetPhysics()->GetOrigin() ).LengthFast();

	if( fight_distance_atnode > 0.0f ){ //this is the most important one and should be the first.
		if( enemyRange < fight_distance_atnode ){
			//gameLocal.Printf("DistanceContidions fight_distance_atnode no\n" );
			return DISTANCE_COND_FIGHT_FAILED;
		}
	}

	if( end_distance_min > 0.0f){ // this check is enabled
		if( enemyRange < end_distance_min ){
			//gameLocal.Printf("DistanceContidions end_distance_min no\n" );
			return DISTANCE_COND_MIN_FAILED;
		}
	}

	if( end_distance_max > 0.0f ){ //this check is enabled
		if( enemyRange > end_distance_max ){
			//gameLocal.Printf("DistanceContidions end_distance_max no\n" );
			return DISTANCE_COND_MAX_FAILED;
		}
	}
	
	//gameLocal.Printf("DistanceContidions all ok\n" );
	return DISTANCE_COND_OK;
}

/*
=====================
idBotNode::Event_EvaluateConditions
=====================
*/
void idBotNode::Event_EvaluateConditions( void ) { //true if one of them is verified!
	idAI_Bot* currentOwner;
	int result;
	
	if ( !inuse ) {
		//gameLocal.Printf("Event_EvaluateConditions: node not in use!\n" );
		idThread::ReturnInt( true ); return;
	}

	assert( ownerBot.IsValid() );
	currentOwner = ownerBot.GetEntity();


	//time
	if( end_time_min > 0){ //not unlimited
		if(end_time < gameLocal.time){ 
			//gameLocal.Printf("time cond!\n" );
			idThread::ReturnInt( true ); return;
		}
	}

	//health
	int deltaToUse;
	if(reached){
		deltaToUse = end_health_delta_atnode;
	}else{
		deltaToUse = fight_health_delta_reaching;
	}
	if( deltaToUse > 0){
		if( deltaToUse < (intial_health - currentOwner->GetHealth())){
			//gameLocal.Printf("health cond!\n" );
			currentOwner->AI_SAY_DAMAGED = true;
			if(!reached){ currentOwner->AI_LEAVE_NODE_TO_FIGHT = true; } 
			idThread::ReturnInt( true ); return;
		}
	}
	

	//distance
	result = DistanceContidionsTrue( currentOwner );
	if( result == DISTANCE_COND_FIGHT_FAILED ){ 	
		currentOwner->AI_LEAVE_NODE_TO_FIGHT = true;
	}
	if( result != DISTANCE_COND_OK && result != DISTANCE_COND_NOENEMY ){
		//gameLocal.Printf("distance cond!\n" );
		idThread::ReturnInt( true ); return;
	}

	//else
	//gameLocal.Printf("Event_EvaluateConditions all false...go on!\n" );
	idThread::ReturnInt( false );
}