//=========================================================
// monster.cpp - a new monster
//=========================================================

#include	"extdll.h"
#include	"util.h"
#include	"cbase.h"
#include	"monsters.h"
#include	"schedule.h"

#define		MELEE_ATTACK1		( 6 ) // Uses Animation Event 6, as declared in the models .qc file

//=====================
// Monsters Class Definition
//=====================
class CMonster : public CBaseMonster
{
public:
	void Spawn( void );
	void Precache( void );
	void SetYawSpeed ( void );

	BOOL CheckMeleeAttack1 ( float flDot, float flDist );
	void HandleAnimEvent( MonsterEvent_t *pEvent );
	void StartTask ( Task_t *pTask );
	Schedule_t *GetSchedule( void );
	int TakeDamage( entvars_t *pevInflictor, entvars_t *pevAttacker, float flDamage, int bitsDamageType );
	int	Save( CSave &save ); 
	int Restore( CRestore &restore );
	BOOL m_fPlayerAttacked; // This is to check if he's been attacked by the player
	static TYPEDESCRIPTION m_SaveData[]; // Storage
	CBaseEntity	*Bite( void );

	int Classify ( void );
};

LINK_ENTITY_TO_CLASS( monster_monster, CMonster );

TYPEDESCRIPTION	CMonster::m_SaveData[] = 
{
	DEFINE_FIELD( CMonster, m_fPlayerAttacked, FIELD_BOOLEAN ),
};
IMPLEMENT_SAVERESTORE( CMonster, CBaseMonster );

//=========================================================
// Classify - indicates this monster's place in the 
// relationship table.
//=========================================================
int	CMonster :: Classify ( void )
{
	if (m_fPlayerAttacked == FALSE || m_fPlayerAttacked == NULL)
		return	CLASS_PLAYER_ALLY; // This is a friendly monster
	else
		return  CLASS_ALIEN_MONSTER; // Now he's a bad guy =)
}

//=========================================================
// SetYawSpeed - allows each sequence to have a different
// turn rate associated with it.
//=========================================================
void CMonster :: SetYawSpeed ( void )
{
	pev->yaw_speed = 90; // Turning with 90
}

//=========================================================
// Spawn
//=========================================================
void CMonster :: Spawn()
{
	Precache( );

	SET_MODEL(ENT(pev), "models/bullsquid.mdl"); // We need a model anyway

   	UTIL_SetSize( pev, Vector( -32, -32, 0 ), Vector( 32, 32, 64 ) ); // For it's hitbox

	pev->solid			= SOLID_SLIDEBOX;
	pev->movetype		= MOVETYPE_STEP;
	m_bloodColor		= BLOOD_COLOR_GREEN;
	pev->effects		= 0;
	pev->health			= 100; // 100 health is enough
	pev->view_ofs		= Vector ( 0, 0, 20 );// position of the eyes relative to monster's origin.
	m_flFieldOfView		= 0.5;// indicates the width of this monster's forward view cone ( as a dotproduct result )
	m_MonsterState		= MONSTERSTATE_NONE;

	MonsterInit(); // Starts the monsters AI
}

//=========================================================
// Precache - precaches all resources this monster needs
//=========================================================
void CMonster :: Precache()
{
	PRECACHE_MODEL("models/bullsquid.mdl"); //Loads the model in the game

	PRECACHE_SOUND("bullchicken/bc_bite2.wav"); // Sounds for the attack
	PRECACHE_SOUND("bullchicken/bc_bite3.wav");

	PRECACHE_SOUND("bullchicken/bc_attackgrowl.wav");
	PRECACHE_SOUND("bullchicken/bc_attackgrowl2.wav");
	PRECACHE_SOUND("bullchicken/bc_attackgrowl3.wav");
}


BOOL CMonster :: CheckMeleeAttack1 ( float flDot, float flDist )
{
	if ( flDist <= 60 && flDot >= 0.7 )		// The player & bullsquid can be as much as their bboxes 
	{										// apart (48 * sqrt(3)) and he can still attack (85 is a little more than 48*sqrt(3))
		return TRUE;
	}
	return FALSE;
}

void CMonster :: HandleAnimEvent( MonsterEvent_t *pEvent )
{
	switch( pEvent->event )
	{
		case MELEE_ATTACK1:
			{
				CBaseEntity *pHurt = Bite();

				if ( pHurt )
				{
					// SOUND HERE!
					UTIL_MakeVectors( pev->angles );
					pHurt->pev->punchangle.x = 15;
					pHurt->pev->velocity = pHurt->pev->velocity + gpGlobals->v_forward * 100 + gpGlobals->v_up * 50;
					pHurt->TakeDamage( pev, pev, 25, DMG_CLUB );
				}
			}
		break;

		default:
			CBaseMonster::HandleAnimEvent( pEvent );
	}
}


void CMonster :: StartTask ( Task_t *pTask )
{
	m_iTaskStatus = TASKSTATUS_RUNNING;

	switch ( pTask->iTask )
	{
	case TASK_MELEE_ATTACK1:
		{
			CBaseEntity *pHurt = Bite();
			switch ( RANDOM_LONG ( 0, 2 ) )
			{
			case 0:	
				EMIT_SOUND( ENT(pev), CHAN_VOICE, "bullchicken/bc_attackgrowl.wav", 1, ATTN_NORM );		
								
				if ( pHurt )
				{
					// SOUND HERE!
					UTIL_MakeVectors( pev->angles );
					pHurt->pev->punchangle.x = 15;
					pHurt->pev->velocity = pHurt->pev->velocity + gpGlobals->v_forward * 100 + gpGlobals->v_up * 50;
					pHurt->TakeDamage( pev, pev, 25, DMG_CLUB );
				}
				break;
			case 1:	
				EMIT_SOUND( ENT(pev), CHAN_VOICE, "bullchicken/bc_attackgrowl2.wav", 1, ATTN_NORM );	
								
				if ( pHurt )
				{
					// SOUND HERE!
					UTIL_MakeVectors( pev->angles );
					pHurt->pev->punchangle.x = 15;
					pHurt->pev->velocity = pHurt->pev->velocity + gpGlobals->v_forward * 100 + gpGlobals->v_up * 50;
					pHurt->TakeDamage( pev, pev, 25, DMG_CLUB );
				}
				break;
			case 2:	
				EMIT_SOUND( ENT(pev), CHAN_VOICE, "bullchicken/bc_attackgrowl3.wav", 1, ATTN_NORM );	
								
				if ( pHurt )
				{
					// SOUND HERE!
					UTIL_MakeVectors( pev->angles );
					pHurt->pev->punchangle.x = 15;
					pHurt->pev->velocity = pHurt->pev->velocity + gpGlobals->v_forward * 100 + gpGlobals->v_up * 50;
					pHurt->TakeDamage( pev, pev, 25, DMG_CLUB );
				}
				break;
			}

			CBaseMonster :: StartTask ( pTask );
			break;
		}
	case TASK_GET_PATH_TO_ENEMY:
		{
			if ( BuildRoute ( m_hEnemy->pev->origin, bits_MF_TO_ENEMY, m_hEnemy ) )
			{
				m_iTaskStatus = TASKSTATUS_COMPLETE;
			}
			else
			{
				ALERT ( at_console, "GetPathToEnemy failed!!\n" );
				TaskFail();
			}
			break;
		}
	default:
		{
			CBaseMonster :: StartTask ( pTask );
			break;
		}
	}
}


Schedule_t *CMonster :: GetSchedule( void )
{
	switch	( m_MonsterState )
	{
	case MONSTERSTATE_COMBAT:
		{
			// dead enemy
			if ( HasConditions( bits_COND_ENEMY_DEAD ) )
			{
				// call base class, all code to handle dead enemies is centralized there.
				return CBaseMonster :: GetSchedule();
			}

			if ( HasConditions( bits_COND_CAN_MELEE_ATTACK1 ) )
			{
				return GetScheduleOfType ( SCHED_MELEE_ATTACK1 );
			}

			return GetScheduleOfType ( SCHED_CHASE_ENEMY );

			break;
		}
	}

	return CBaseMonster :: GetSchedule();
}

int CMonster :: TakeDamage( entvars_t *pevInflictor, entvars_t *pevAttacker, float flDamage, int bitsDamageType )
{
	if ( pevAttacker->flags & FL_CLIENT )
	{
		m_fPlayerAttacked = TRUE; // Yup, I am attacked by him, so now I'm pissed
	}
	else
	{
		if (m_fPlayerAttacked != TRUE)
			m_fPlayerAttacked = FALSE; // He's still my friend! (This is just to make sure it'll go right.
	}

	return CBaseMonster :: TakeDamage ( pevInflictor, pevAttacker, flDamage, bitsDamageType );
}

CBaseEntity *CMonster :: Bite( void )
{
	TraceResult tr;

	UTIL_MakeVectors( pev->angles );
	Vector vecStart = pev->origin;
	vecStart.z += pev->size.z * 0.5;
	Vector vecEnd = vecStart + (gpGlobals->v_forward * 70);

	UTIL_TraceHull( vecStart, vecEnd, dont_ignore_monsters, head_hull, ENT(pev), &tr );
	
	if ( tr.pHit )
	{
		CBaseEntity *pEntity = CBaseEntity::Instance( tr.pHit );
		return pEntity;
	}

	return NULL;
}