#ifndef CLIENT_DLL

#include "extdll.h"
#include "util.h"
#include "cbase.h"
#include "monsters.h"
#include "weapons.h"
#include "nodes.h"
#include "effects.h"
#include "baseclasses.h"
#include "player.h"
#include "gamerules.h"


#include "game.h"


#include <pakkun.h>
#include <jutsuFx.h>
#include <TsuigaJutsu.h>
#include <rotationUtils.h>
#include <pm_defs.h>

#define SPAWN_SOUND "jutsu/Poof.wav"
#define DEFAULT_DISTANCE -50


LINK_ENTITY_TO_CLASS( tsuiga_dog, Pakkun );


void Pakkun::Spawn( )
{
	Precache( );
	//pev->movetype = MOVETYPE_STEP;
	pev->solid = SOLID_SLIDEBOX;

	pev->classname = MAKE_STRING(WEAPON_NAME_JUTSU_TSUIGA);
	pev->gravity = 1.0;
	pev->friction	= 0.5;
	m_bloodColor = DONT_BLEED;

	SET_MODEL(ENT(pev), PAKKUN_MODEL);


	EMIT_SOUND(ENT(pev), CHAN_WEAPON,SPAWN_SOUND, 1, ATTN_NORM);
	UTIL_SetSize(pev, Vector(-8, -8, -18.1), Vector(8, 8, 18));
	pev->renderfx = kRenderFxCellShaded; //hack for cel shading pakkun
	pev->origin.z += 10;



	pev->flags |= FL_MONSTER;
	pev->health	= 1;
	pev->takedamage = 1;

	m_MonsterState = MONSTERSTATE_IDLE;
	//m_afCapability = bits_CAP_MELEE_ATTACK1;
	m_afCapability = bits_CAP_RANGE_ATTACK1;


	InitBoneControllers( );
	m_flFieldOfView = 0.7;
	m_timeToLive = 15;
	m_fLastTime = gpGlobals->time;
	m_pTarget = this->m_pUser->m_pTarget;
	MonsterInit();



	((CTsuigaJutsu*)m_pJutsu)->setPakkunReady(false);
}

Pakkun* Pakkun::PakkunCreate( Vector vecOrigin, Vector vecAngles, CBasePlayer* pOwner, CTsuigaJutsu* pJutsu ){
	// Create a new entity with Pakkun private data
	Pakkun *pDog = GetClassPtr( (Pakkun *)NULL );
	pDog->pev->classname = MAKE_STRING("tsuiga_dog");

	// B T
	//pDog->pev->origin = vecOrigin;
	UTIL_SetOrigin( pDog->pev, vecOrigin );
	vecAngles.x = 0;
	vecAngles.z = 0;
	// E T

	pDog->pev->angles = vecAngles;
	//pDog->pev->owner = pOwner->edict();
	pDog->m_pUser = pOwner;
	pDog->m_pJutsu = pJutsu;
	pDog->Spawn();
	sendPuffFX(vecOrigin);
	pDog->pev->playerNormal = pOwner->pev->playerNormal;


	pDog->pev->euser1 = pOwner->edict();
	pDog->pev->ownerId = pOwner->entindex();
	pDog->pev->team = pOwner->pev->team;
	pDog->pev->speed = 50;
	pDog->pev->yaw_speed = 450;


	return pDog;


}

void Pakkun::Precache(){}


Vector Pakkun::getFormationPos(){

	//UTIL_MakeVectors(m_pUser->pev->v_angle);
	//Vector dir = removeNormalComponent(gpGlobals->v_forward,m_pUser->pev->playerNormal);

	Vector angle = Vector(0,0,0);//m_pJutsu->pev->angles;
	angle.y += 200; //start at the right
	UTIL_MakeVectors(angle);

	Vector dir = gpGlobals->v_forward;
	dir = dir.Normalize();
	return m_pUser->pev->origin + dir * DEFAULT_DISTANCE;
}


void Pakkun::Killed(entvars_t *pevAttacker, int iGib ){
	if ( m_pJutsu )
		((CTsuigaJutsu*)m_pJutsu)->setPakkunReady(true);

	sendPuffFX(this->pev->origin);

	FormationMonster::Killed( pevAttacker, GIB_ALWAYS );
	UTIL_Remove(this);
}

void Pakkun::MoveExecute( CBaseEntity *pTargetEnt, const Vector &vecDir, float flInterval ){
	m_flGroundSpeed = 200; //TODO: change to constant or  variable
	FormationMonster::MoveExecute(pTargetEnt, vecDir, flInterval);
}

Task_t	tlJumpOnPlayerFace1[] =
{
	{ TASK_STOP_MOVING,			0				},
	{ TASK_FACE_ENEMY,			(float)0		},
	{ TASK_RANGE_ATTACK1,		(float)0		},
	{ TASK_SET_ACTIVITY,		(float)ACT_IDLE	},
};

Schedule_t	slJumpOnPlayerFace[] =
{
	{
		tlJumpOnPlayerFace1,
		ARRAYSIZE ( tlJumpOnPlayerFace1 ),
		bits_COND_NEW_ENEMY			|
		bits_COND_ENEMY_DEAD		|
		bits_COND_LIGHT_DAMAGE		|
		bits_COND_HEAVY_DAMAGE		|
		bits_COND_ENEMY_OCCLUDED,
		0,
		"JumpOnPlayerFace"
	},
};



#define		HC_AE_JUMPATTACK	( 2 )


DEFINE_CUSTOM_SCHEDULES( Pakkun )
{
	slJumpOnPlayerFace,
};

Schedule_t* Pakkun :: GetScheduleOfType ( int Type )
{
	switch	( Type )
	{
	case SCHED_RANGE_ATTACK1:
		{
			//ALERT ( at_console, "PAKKUN SCHED_RANGE_ATTACK1\n", Type );
			return &slJumpOnPlayerFace[ 0 ];
		}
	default:
		{
			return FormationMonster::GetScheduleOfType( Type );
		}
	}
}

IMPLEMENT_CUSTOM_SCHEDULES( Pakkun, FormationMonster );

Schedule_t *Pakkun :: GetSchedule ( void )
{
	return FormationMonster :: GetSchedule();
}

void Pakkun :: startPakkunJumpToFace()
{
			ClearBits( pev->flags, FL_ONGROUND );

			UTIL_SetOrigin (pev, pev->origin + Vector ( 0 , 0 , 1) );// take him off ground so engine doesn't instantly reset onground
			UTIL_MakeVectors ( pev->angles );

			Vector vecJumpDir;
			if (m_hEnemy != NULL)
			{
				float gravity = g_psv_gravity->value;
				if (gravity <= 1)
					gravity = 1;

				// How fast does the headcrab need to travel to reach that height given gravity?
				float height = (m_hEnemy->pev->origin.z + m_hEnemy->pev->view_ofs.z - pev->origin.z);
				if (height < 16)
					height = 16;
				float speed = sqrt( 2 * gravity * height );
				float time = speed / gravity;

				// Scale the sideways velocity to get there at the right time
				vecJumpDir = (m_hEnemy->pev->origin + m_hEnemy->pev->view_ofs - pev->origin);
				vecJumpDir = vecJumpDir * ( 1.0 / time );

				// Speed to offset gravity at the desired height
				vecJumpDir.z = speed;

				// Don't jump too far/fast
				float distance = vecJumpDir.Length();

				if (distance > 650)
				{
					vecJumpDir = vecJumpDir * ( 650.0 / distance );
				}
			}
			else
			{
				// jump hop, don't care where
				vecJumpDir = Vector( gpGlobals->v_forward.x, gpGlobals->v_forward.y, gpGlobals->v_up.z ) * 350;
			}

			pev->velocity = vecJumpDir;
			m_flNextAttack = gpGlobals->time + 2;

}

void Pakkun :: SetYawSpeed ( void )
{
	int ys;

	switch ( m_Activity )
	{
	case ACT_IDLE:
		ys = 60;
		break;
	case ACT_RUN:
	case ACT_WALK:
		ys = 60;
		break;
	case ACT_TURN_LEFT:
	case ACT_TURN_RIGHT:
		ys = 60;
		break;
	case ACT_RANGE_ATTACK1:
		//ALERT(at_console,"ACT_RANGE_ATTACK1 YS\n");
		ys = 20;
		break;
	default:
		ys = 60;
		break;
	}

	pev->yaw_speed = ys;
}

//=========================================================
// RunTask
//=========================================================
void Pakkun :: StartTask ( Task_t *pTask )
{
	m_iTaskStatus = TASKSTATUS_RUNNING;

	switch ( pTask->iTask )
	{
	case TASK_RANGE_ATTACK1:
		{
			//m_IdealActivity = ACT_RANGE_ATTACK1;
		//	ALERT(at_console,"TASK_RANGE_ATTACK1|m_IdealActivity: %i\n",m_IdealActivity);
			//SetTouch (&Pakkun::LeapTouch );
			startPakkunJumpToFace();
			break;
		}
	default:
		{
			FormationMonster :: StartTask(pTask);
		}
	}
}


void Pakkun :: RunTask ( Task_t *pTask )
{
	switch ( pTask->iTask )

	{



	case TASK_RANGE_ATTACK1:
	case TASK_RANGE_ATTACK2:
		{
			if ( m_fSequenceFinished )
			{
				ALERT(at_console,"m_fSequenceFinished\n");
				TaskComplete();
				SetTouch( NULL );
				m_IdealActivity = ACT_IDLE;
			}
			break;
	}
	default:
		{
			FormationMonster :: RunTask(pTask);
		}
	}
}

/*
void Pakkun :: StartTask ( Task_t *pTask )
{
			FormationMonster :: StartTask(pTask);
}
*/
//=========================================================
// Center - returns the real center of the headcrab.  The
// bounding box is much larger than the actual creature so
// this is needed for targeting
//=========================================================
Vector Pakkun :: Center ( void )
{
	return Vector( pev->origin.x, pev->origin.y, pev->origin.z + 6 );
}


Vector Pakkun :: BodyTarget( const Vector &posSrc )
{
	return Center( );
}

void Pakkun :: LeapTouch ( CBaseEntity *pOther )
{
	if ( !pOther->pev->takedamage )
	{
		return;
	}

	if ( pOther->Classify() == Classify() )
	{
		return;
	}

	// Don't hit if back on ground
	if ( !FBitSet( pev->flags, FL_ONGROUND ) )
	{
		pOther->TakeDamage( pev, pev, 0, DMG_SLASH );
	}

	SetTouch( NULL );
}


//=========================================================
// SetYawSpeed - allows each sequence to have a different
// turn rate associated with it.
//=========================================================

//=========================================================
// CheckRangeAttack1
//=========================================================
BOOL Pakkun :: CheckRangeAttack1 ( float flDot, float flDist )
{
	if ( FBitSet( pev->flags, FL_ONGROUND ) && flDist <= 256 && flDot >= 0.65 )
	{
		return TRUE;
	}
	return FALSE;
}

//=========================================================
// CheckRangeAttack2
//=========================================================
BOOL Pakkun :: CheckRangeAttack2 ( float flDot, float flDist )
{
	return FALSE;
}

int Pakkun :: TakeDamage( entvars_t *pevInflictor, entvars_t *pevAttacker, float flDamage, int bitsDamageType )
{
	return FormationMonster::TakeDamage( pevInflictor, pevAttacker, flDamage, bitsDamageType );
}



//==================================
//Headcrab stuff end
//==================================

#endif /*CLIENT_DLL*/