[csoldjb]

Here is the npc code . When playing some sequences,it always go underground.Before playing the sequences,it works perfect.

PHP Code:

LINK_ENTITY_TO_CLASS(mst_angra, CMonsterAngra);


void CMonsterAngra::Spawn(void)
{
    Precache();
    pev->classname = MAKE_STRING("monster_angra");
    pev->movetype = MOVETYPE_STEP;
    pev->solid = SOLID_SLIDEBOX;
    pev->takedamage = DAMAGE_YES;
    pev->flags |= FL_MONSTER;
    pev->deadflag = DEAD_NO;
    pev->max_health = ANGRA_MONSTER_HEALTH_BASE;
    pev->health = pev->max_health;
    pev->gravity = 1;
    pev->view_ofs = VEC_MONSTER_VIEW;
    pev->velocity = Vector(0, 0, 0);

    if (pev->spawnflags & SF_MONSTER_HITMONSTERCLIP)
        pev->flags |= FL_MONSTERCLIP;

    if (pev->skin < 0)
        pev->skin = 0;

    SET_MODEL(ENT(pev), STRING(pev->model));
    m_pTarget = NULL;

    UTIL_SetSize(pev, VEC_MONSTER_HULL_MIN, VEC_MONSTER_HULL_MAX);
    UTIL_MakeVectors(pev->v_angle);
    SetBoneController(0, UTIL_VecToYaw(gpGlobals->v_forward));

    SetThink(&CMonsterAngra::IdleThink);
    pev->nextthink = gpGlobals->time + RANDOM_FLOAT(0.1, 0.2);
    pev->modelindex = m_iModelIndex;

    DROP_TO_FLOOR(ENT(pev));

    // Set Enemy
    m_bAppeared = false;
    SetSequence(ANIM_APPEAR1);
    
    m_fChangeTarget = 0;
    
    m_pTarget = (CBaseEntity *)GET_PRIVATE(INDEXENT(1)); 


This is the code about playing sequence

PHP Code:

void CMonsterAngra::SetSequence(MONSTER_SEQUENCE iSequence,bool forcePlay)
{
    if(forcePlay || (pev->sequence != iSequence&& !forcePlay))
    {
        pev->frame = 0;
        pev->sequence = iSequence;
        ResetSequenceInfo();
        m_fAnimationTimer = gpGlobals->time;
        m_Activity = Activity::ACT_SPECIAL_ATTACK2;
    }
}
void CMonsterAngra::SetActivity(Activity activity)
{
    if (m_Activity != activity)
    {
        int animDesired = LookupActivity(activity);

        if (animDesired != -1)
        {
            if (pev->sequence != animDesired)
            {
                if ((m_Activity != ACT_WALK || m_Activity != ACT_RUN) && (activity != ACT_WALK || activity != ACT_RUN))
                    pev->frame = 0;

                pev->sequence = animDesired;
            }

            m_Activity = activity;
            ResetSequenceInfo();
            m_fAnimationTimer = gpGlobals->time;
        }
    }
} 


Here is the CPP(Metamod plugin)

PHP Code:

#include <extdll.h>
#include <meta_api.h>
#include "cbase.h"
#include "monsters.h"
#include "monster_angra.h"
#include "Extra.h"
CBaseEntity *UTIL_FindEntityByClassname(CBaseEntity *pStartEntity, const char *szName);
CBaseEntity *UTIL_FindEntityInSphere(CBaseEntity *pStartEntity, const Vector &vecCenter, float flRadius);
CBaseEntity *UTIL_PlayerByIndex(int playerIndex);

LINK_ENTITY_TO_CLASS(bte_mst_angra, CMonsterAngra);

CMonsterAngra *g_pMonsterAngra;
void CMonsterAngra::Spawn(void)
{
    Precache();
    pev->classname = MAKE_STRING("monster_angra");
    pev->movetype = MOVETYPE_FLY;
    pev->solid = SOLID_SLIDEBOX;
    pev->takedamage = DAMAGE_YES;
    pev->flags |= FL_MONSTER;
    pev->deadflag = DEAD_NO;
    pev->max_health = ANGRA_MONSTER_HEALTH_BASE;
    pev->health = pev->max_health;
    pev->gravity = 1;
    pev->view_ofs = VEC_MONSTER_VIEW;
    pev->velocity = Vector(0, 0, 0);

    if (pev->spawnflags & SF_MONSTER_HITMONSTERCLIP)
        pev->flags |= FL_MONSTERCLIP;

    if (pev->skin < 0)
        pev->skin = 0;

    SET_MODEL(ENT(pev), STRING(pev->model));
    m_pTarget = NULL;

    UTIL_SetSize(pev, VEC_MONSTER_HULL_MIN, VEC_MONSTER_HULL_MAX);
    UTIL_MakeVectors(pev->v_angle);
    SetBoneController(0, UTIL_VecToYaw(gpGlobals->v_forward));
    DROP_TO_FLOOR(ENT(pev));

    SetThink(&CMonsterAngra::IdleThink);
    pev->nextthink = gpGlobals->time + RANDOM_FLOAT(0.1, 0.2);
    pev->modelindex = m_iModelIndex;

    DROP_TO_FLOOR(ENT(pev));

    // Set Enemy
    m_bAppeared = false;
    SetSequence(ANIM_APPEAR1);
    
    m_fChangeTarget = 0;
    
    m_pTarget = (CBaseEntity *)GET_PRIVATE(INDEXENT(1));
    AtOrigin(m_pTarget->pev->origin);
    m_bDash = m_bRadiusAttack = m_bTentacle = m_bPoison = false;
    m_bInSkill =false;
    m_bDead =false;
    m_fDashSkillTimer = m_fRadiusAttackTimer = m_fTentacleSkillTimer = m_fPoisonSkillTimer = 0;
    g_pMonsterAngra = this;
} 
void CMonsterAngra::IdleThink(void)
{
    pev->nextthink = gpGlobals->time + (1.0 / 30);
    DispatchAnimEvents(StudioFrameAdvance());
    RunAI();
}
void CMonsterAngra::AtOrigin(Vector &origin)
{
    pev->angles.x = 0;
    pev->angles.y = UTIL_VecToAngles(origin - pev->origin).y;
    pev->angles.z = 0;
}
void CMonsterAngra::Touch(CBaseEntity *pOther)
{
    pev->movetype = MOVETYPE_STEP;
    if(m_bDash && m_iDashStat == DASH) // 冲刺过程中撞到东西
    {
        if( (m_vecLastTouchPos-pev->origin).Length2D() < 20.0)
        {
            m_iDashStat = DASH_END;
            SetSequence(ANIM_ROOLING3);
            m_fDashTimer = gpGlobals->time + 1.7;
        }
        m_vecLastTouchPos = pev->origin;
        // 碰到玩家或世界停止
        int iHitEntity = ENTINDEX(pOther->edict());
        if( IsPlayer(pOther) )
        {
            Vector vecDir =  (pOther->pev->origin - pev->origin).Normalize() * 800.0;
            pOther->pev->velocity = vecDir;
            pOther->pev->velocity.z = 500.0;
            MakeDamage(pOther,20.0);
            return;
        }
        
        Vector vecDir =  (pOther->pev->origin - pev->origin).Normalize() * 800.0;
        pOther->pev->velocity = vecDir;
        pOther->pev->velocity.z = 500.0;
    }
}
float CMonsterAngra::GetModifiedDamage(float flDamage)
{
    switch (m_iLastHitGroup)
    {
        case HITGROUP_GENERIC: flDamage *= 1.75; break;
        case HITGROUP_HEAD: flDamage *= 2.5; break;
        case HITGROUP_CHEST: flDamage *= 1.5; break;
        case HITGROUP_STOMACH: flDamage *= 1.75; break;
        case HITGROUP_LEFTARM:
        case HITGROUP_RIGHTARM: flDamage *= 0.75; break;
        case HITGROUP_LEFTLEG:
        case HITGROUP_RIGHTLEG: flDamage *= 0.6; break;
    }
    float iGot = (pev->max_health - pev->health) / pev->max_health + 1.0;
    flDamage *= iGot;

    return flDamage;
}
void CMonsterAngra::SpawnBlood(Vector vecSpot, int color, float flDamage)
{
    int amount = (int)flDamage;

    if ( amount == 0 )
        return;

    amount *= 2;

    if ( amount > 255 )
        amount = 255;

    MESSAGE_BEGIN( MSG_PVS, SVC_TEMPENTITY, vecSpot );
    WRITE_BYTE( TE_BLOODSPRITE );
    WRITE_COORD( vecSpot.x);                                // pos
    WRITE_COORD( vecSpot.y);
    WRITE_COORD( vecSpot.z);
    WRITE_SHORT( m_iModelIndexBloodSpray );                // initial sprite model
    WRITE_SHORT( m_iModelIndexBloodDrop);                // droplet sprite models
    WRITE_BYTE( color );                                // color index into host_basepal
    WRITE_BYTE( min( max( 3, amount / 10 ), 16 ) );        // size
    MESSAGE_END();
}
void CMonsterAngra::Killed(entvars_t *pAttacker,int iGibs)
{
    SetSequence(ANIM_EXIT2);
    m_bDead = true;
    pev->movetype = MOVETYPE_TOSS;
    pev->solid = SOLID_NOT;
    pev->takedamage = DAMAGE_NO;
    pev->deadflag = DEAD_DEAD;
    SetActivity(ACT_DIE_HEADSHOT);
    pev->nextthink = gpGlobals->time + 18.0;
    SetThink(&CMonsterAngra::Remove);
    CBaseMonster::Killed(pAttacker,GIB_NEVER); 
}
void CMonsterAngra::Remove(void)
{
    pev->nextthink = -1;
    REMOVE_ENTITY(ENT(pev));
}
int CMonsterAngra::TakeDamage(entvars_t *pevInflictor, entvars_t *pevAttacker, float flDamage, int bitsDamageType)
{
    pev->health -= flDamage;
    if(pev->health  < 1)
    {
        Killed(pevInflictor,0);
    }
    return 0;
}
void CMonsterAngra::TraceAttack(entvars_t *pevAttacker, float flDamage, Vector vecDir, TraceResult *ptr, int bitsDamageType)
{
    m_iLastHitGroup = ptr->iHitgroup;
    flDamage = GetModifiedDamage(flDamage) ;
    SpawnBlood(ptr->vecEndPos,3,flDamage);
    TakeDamage(pevAttacker,pevAttacker,flDamage,bitsDamageType);
}
float CMonsterAngra::GetTargetDistance(void)
{
    return (m_pTarget->pev->origin - pev->origin).Length2D();
}
CBaseEntity *CMonsterAngra::GetRandomTarget(void)
{
    CBaseEntity *pArray[33];
    int iCount = 0;
    for(int i=1;i<33;i++)
    {
        CBaseEntity *pPlayer = UTIL_PlayerByIndex(i);
        if(pPlayer && pPlayer->pev->health > 0)
        {
            pArray[iCount++] = pPlayer;
        }
    }
    if(!iCount) return NULL;
    return pArray[RANDOM_LONG(0,iCount-1)];
}
void CMonsterAngra::Attack(void)
{
    m_bCreatedRangeAttack = false;
    //AtOrigin(m_pTarget->pev->origin); // 先瞄准一下目标
    m_fRangeAttackAnimationTimer = gpGlobals->time + 3.5;
    SetSequence(ANIM_ZBS_BITE,true);
}
void CMonsterAngra::Shake(CBaseEntity *pTarget)
{
    MESSAGE_BEGIN( MSG_ONE, iMsgID_ScreenShake, NULL, pTarget->edict());
    WRITE_SHORT((1<<12)*6);
    WRITE_SHORT((1<<12)*3);
    WRITE_SHORT((1<<12)*13); 
    MESSAGE_END();
}
void CMonsterAngra::MakeDamage(CBaseEntity *pTarget,float fDamage)
{
    if(!IsPlayer(pTarget)) return;
    CBaseMonster *pVictim = (CBaseMonster *)pTarget;
    pVictim->m_LastHitGroup = HITGROUP_GENERIC;
    pVictim->TakeDamage(pev,pev,fDamage,DMG_BLAST);
}

void CMonsterAngra::RadiusDamage2(Vector vecStart,float fDamage,float fRange)
{
    CBaseEntity *pTarget = NULL;
    while(( pTarget = UTIL_FindEntityInSphere(pTarget, vecStart,fRange)))
    {
        MakeDamage(pTarget,fDamage);
        //Shake(pTarget);
    }
}
bool CMonsterAngra::IsPlayer(CBaseEntity *pPlayer)
{
    if(pPlayer->pev->flags & FL_CLIENT) return true;
    if(pPlayer->pev->flags & FL_FAKECLIENT) return true;
    return false;
}
bool CMonsterAngra::CheckTarget(void)
{
    if(m_pTarget && m_pTarget->pev->health < 1)
    {
        m_pTarget = NULL;
    }
    if(m_fChangeTarget < gpGlobals->time)
    {
        m_fChangeTarget = gpGlobals->time + RANDOM_FLOAT(6.0, 8.0);
        m_pTarget = GetRandomTarget();    
    }
    if(!m_pTarget)
    {
        m_pTarget = GetRandomTarget();    
        if(!m_pTarget) return false;
    }
    return true;
}

void AngraRemoveThink(edict_t *pEnt)
{
    if(!g_pMonsterAngra)
    {
        REMOVE_ENTITY(pEnt);
        return;
    }
    if(pEnt->v.iuser1 == g_pMonsterAngra->iEntID_EF_TENTACLE || pEnt->v.iuser1 == g_pMonsterAngra->iEntID_EF_TENTACLE2)
    {
        if(pEnt->v.iuser1 == g_pMonsterAngra->iEntID_EF_TENTACLE)
        {
            pEnt->v.iuser1 = g_pMonsterAngra->iEntID_EF_TENTACLE2;
            pEnt->v.nextthink = gpGlobals->time + 2.0;
        }
        else 
        {
            pEnt->v.iuser1 = g_pMonsterAngra->iEntID_EF_TENTACLE_REMOVE;
            pEnt->v.nextthink = gpGlobals->time + 3.0;
        }

        edict_t *pEnt2 = CREATE_NAMED_ENTITY(MAKE_STRING("info_target"));
        pEnt2->v.model = MAKE_STRING("models/tentacle.mdl");
        pEnt2->v.movetype = MOVETYPE_FLY;
        pEnt2->v.solid = SOLID_NOT;
        pEnt2->v.origin = pEnt->v.origin;
        pEnt2->v.animtime = gpGlobals->time;
        pEnt2->v.framerate = 1.0;
        pEnt2->v.iuser1 = g_pMonsterAngra->iEntID_TENTACLE;
        SET_MODEL(pEnt2, STRING(pEnt2->v.model));
        pEnt2->v.nextthink = gpGlobals->time + 0.2;
        SetThink2(pEnt2,&AngraRemoveThink);
    }
    else if(pEnt->v.iuser1 == g_pMonsterAngra->iEntID_TENTACLE)
    {
        pEnt->v.iuser1 = g_pMonsterAngra->iEntID_TENTACLE2;
        for(int i=1;i<33;i++)
        {
            CBaseEntity *pPlayer = UTIL_PlayerByIndex(i);
            if(pPlayer && pPlayer->pev->health > 1)
            {
                if( (pPlayer->pev->origin -pEnt->v.origin).Length2D()< 50.0 )
                {
                    pPlayer->pev->velocity.z += 600.0;
                }
            }
        }
        pEnt->v.nextthink = gpGlobals->time + 0.8;
    }
    else REMOVE_ENTITY(pEnt);
}
void CMonsterAngra::Poison(void)
{
    m_bPoison = true;
    m_bInSkill = true;
    m_iPoisonCount = 0;
    m_fPoisonLastLaunch = 0;
    m_fPoisonTimer = gpGlobals->time + 6.5;
    SetSequence(ANIM_ZBS_POISON1);
    m_bCreatedPoison = false;
}
void AngraPoisonThink(edict_t *pEnt)
{
    if(!g_pMonsterAngra)
    {
        REMOVE_ENTITY(pEnt);
        return;
    }
    pEnt->v.nextthink = gpGlobals->time + 0.1;
    Vector vecAngle = g_pMonsterAngra->GetVelocityAngle(pEnt->v.velocity);
    pEnt->v.angles = vecAngle;
}
void _fastcall AngraPoisonTouch(void *pEntData,int iFixCall,void *pEnt2Data) // thiscall -> fastcall
{
    edict_t *pEntToucher = PrivateToEdict(pEntData);
    edict_t *pEntTouched = PrivateToEdict(pEnt2Data);
    if(ENTINDEX(pEntTouched)!= 0) return;
    edict_t *pEnt = CREATE_NAMED_ENTITY(MAKE_STRING("info_target"));
    pEnt->v.model = MAKE_STRING("models/ef_poison02.mdl");
    pEnt->v.movetype = MOVETYPE_FLY;
    pEnt->v.solid = SOLID_NOT;
    pEnt->v.gravity = 1.0;
    pEnt->v.scale = 2.0;
    pEnt->v.framerate = 1.0;
    pEnt->v.animtime = gpGlobals->time;
    pEnt->v.origin = pEntToucher->v.origin;
    pEnt->v.rendermode = kRenderTransAdd;
    pEnt->v.renderamt = 255;
    SET_MODEL(pEnt, STRING(pEnt->v.model));
    pEnt->v.nextthink = gpGlobals->time + 1.0;
    SetThink2(pEnt,&AngraRemoveThink);
    REMOVE_ENTITY(pEntToucher);
}
void CMonsterAngra::PoisonEffect(void)
{
    m_bCreatedPoison = true;
    Vector vecAngle = pev->angles;
    Vector vecVelocity ;
    //vecAngle[0] += -60.0;
    vecAngle[1] -= 60.0;
    for(int i=0;i<10;i++)
    {
        edict_t *pEnt = CREATE_NAMED_ENTITY(MAKE_STRING("info_target"));
        pEnt->v.model = MAKE_STRING("models/ef_poison01.mdl");
        pEnt->v.movetype = MOVETYPE_TOSS;
        pEnt->v.solid = SOLID_BBOX;
        pEnt->v.gravity = 1.0;
        pEnt->v.scale = 2.0;
        pEnt->v.origin = pev->origin;
        pEnt->v.origin.z += 180.0;
        pEnt->v.origin.z  += 10.0 * i;
        pEnt->v.angles = pev->angles;
        SET_MODEL(pEnt, STRING(pEnt->v.model));
        UTIL_SetSize(pev, Vector(-1,-1,-1), Vector(1,1,1));
        vecAngle[1] += 10.0;
        
        g_engfuncs.pfnAngleVectors(vecAngle,vecVelocity,NULL,NULL);
        vecVelocity.x *= 600.0;
        vecVelocity.z *= 600.0;
        vecVelocity.y *= 600.0;
        pEnt->v.velocity = vecVelocity;
        pEnt->v.nextthink = gpGlobals->time + 0.1;
        pEnt->v.fuser1 = gpGlobals->time + 1.0;
        SetThink2(pEnt,&AngraPoisonThink);
        SetTouch2(pEnt,&AngraPoisonTouch);
    }
}

void CMonsterAngra::RadiusAttackEffect(void)
{
    m_bRadiusAttacked = true;
    edict_t *pEnt = CREATE_NAMED_ENTITY(MAKE_STRING("info_target"));
    pEnt->v.model = MAKE_STRING("models/ef_swing.mdl");
    pEnt->v.movetype = MOVETYPE_FLY;
    pEnt->v.solid = SOLID_NOT;
    pEnt->v.origin = pev->origin;
    pEnt->v.origin.z -= 20.0;
    pEnt->v.rendermode = kRenderTransAdd;
    pEnt->v.renderamt = 255;
    pEnt->v.scale = 2.5;
    pEnt->v.animtime = gpGlobals->time;
    pEnt->v.framerate = 1.0;
    SET_MODEL(pEnt, STRING(pEnt->v.model));
    pEnt->v.nextthink = gpGlobals->time + 0.6;
    SetThink2(pEnt,&AngraRemoveThink);
}
void CMonsterAngra::RadiusAttack(void)
{
    m_bInSkill = true;
    m_bRadiusAttack = true;
    m_fRadiusAttackTimer = gpGlobals->time + 2.0;
    SetSequence(ANIM_ZBS_SWING);
    m_bRadiusAttacked = false;
}
void CMonsterAngra::TentacleEffect(void)
{
    if(m_fTentacleLastLaunch < gpGlobals->time && m_iTentacleCount <8)
    {
        m_fTentacleLastLaunch = gpGlobals->time + 0.3;
        Vector vecAngle = pev->angles;
        vecAngle.y -= 90.0;
        vecAngle[0] = 0;

        for(int i=0;i<3;i++)
        {
            edict_t *pEnt = CREATE_NAMED_ENTITY(MAKE_STRING("info_target"));
            pEnt->v.model = MAKE_STRING("models/ef_tentacle.mdl");
            pEnt->v.movetype = MOVETYPE_FLY;
            pEnt->v.solid = SOLID_NOT;
            vecAngle.y +=45.0;
            Vector vecVelocity ;
            g_engfuncs.pfnAngleVectors(vecAngle,vecVelocity,NULL,NULL);

            pEnt->v.origin = pev->origin + vecVelocity*200.0*m_iTentacleCount;
            pEnt->v.origin.z += 10;
            pEnt->v.angles = pev->angles;
            pEnt->v.iuser1 = iEntID_EF_TENTACLE;
            //pEnt->v.rendermode = kRenderTransAdd;
            //pEnt->v.renderamt = 255;
            SET_MODEL(pEnt, STRING(pEnt->v.model));
            pEnt->v.nextthink = gpGlobals->time + 3.0;
            SetThink2(pEnt,&AngraRemoveThink);
        }
        m_iTentacleCount ++;
    }
}
void CMonsterAngra::Tentacle(void)
{
    m_bInSkill = true;
    m_bTentacle = true;
    m_iTentacleCount = 0;
    m_fTentacleLastLaunch = 0;
    m_fTentacleTimer = gpGlobals->time + 7.5;
    SetSequence(ANIM_ZBS_TENTACLE1);
}
void CMonsterAngra::RunAI(void)
{
    if(m_bDead) return;
    if(!m_bAppeared)
    {
        if(pev->sequence == ANIM_APPEAR1 && gpGlobals->time - m_fAnimationTimer > 1.1)
        {
            SetSequence(ANIM_APPEAR2);
        }
        else if(pev->sequence == ANIM_APPEAR2 && gpGlobals->time - m_fAnimationTimer > 1.1)
        {
            // GOGOGO
            Vector vecAngle = pev->angles;
            vecAngle[0] = -60.0;
            Vector vecVelocity ;
            g_engfuncs.pfnAngleVectors(vecAngle,vecVelocity,NULL,NULL);
            //vecVelocity.x *= 600.0;
            //vecVelocity.z *= 600.0;
            //vecVelocity.y *= 600.0;
            pev->velocity = vecVelocity;
            SetSequence(ANIM_APPEAR3);
        }
        else if(pev->sequence == ANIM_APPEAR3 && gpGlobals->time - m_fAnimationTimer > 6.4)
        {
            m_bAppeared = true;
        }
    }
    else
    {
        if(m_fRangeAttackAnimationTimer && m_fRangeAttackAnimationTimer > gpGlobals->time)
        {
            if(m_fRangeAttackAnimationTimer - gpGlobals->time <2.5 && !m_bCreatedRangeAttack)
            {
                RadiusDamage2(pev->origin,10.0,200.0);
                m_bCreatedRangeAttack = true;
            }
            return;
        }
        if(m_fDashSkillTimer < gpGlobals->time && !m_bInSkill)
        {
            Dash();
            m_fDashSkillTimer = gpGlobals->time + RANDOM_FLOAT(10.0,30.0);
        }
        if(m_fRadiusAttackSkillTimer < gpGlobals->time && !m_bInSkill)
        {
            RadiusAttack();
            m_fRadiusAttackSkillTimer = gpGlobals->time + 5.0;
        }
        if(m_fTentacleSkillTimer < gpGlobals->time && !m_bInSkill)
        {
            Tentacle();
            m_fTentacleSkillTimer = gpGlobals->time + 10.0;
        }
        if(m_fPoisonSkillTimer < gpGlobals->time && !m_bInSkill)
        {
            Poison();
            m_fPoisonSkillTimer = gpGlobals->time + 7.0;
        }
        
        if(m_bDash)
        {
            if(m_iDashStat == DASH_START &&m_fDashTimer < gpGlobals->time)
            {
                m_iDashStat = DASH;
            }
            if(m_iDashStat == DASH)
            {
                SetSequence(ANIM_ROOLING2);
                pev->velocity = m_vecDashVelocity;
            }
            if(m_iDashStat == DASH_END)
            {
                if(m_fDashTimer < gpGlobals->time)
                {
                    m_bDash = false;
                    m_bInSkill = false;
                }
            }
            return;
        }
        if(m_bRadiusAttack)
        {
            if(m_fRadiusAttackTimer>gpGlobals->time && m_fRadiusAttackTimer<gpGlobals->time+6.2 )
            {
                RadiusAttackEffect();
            }
            if(m_fRadiusAttackTimer < gpGlobals->time)
            {
                m_bRadiusAttack = false;
                m_bInSkill = false;
            }
            return;
        }
        if(m_bTentacle)
        {
            if(m_fTentacleTimer>gpGlobals->time)
            {
                TentacleEffect();
            }
            if(m_fTentacleTimer < gpGlobals->time)
            {
                m_bTentacle = false;
                m_bInSkill = false;
            }
            return;
        }
        if(m_bPoison)
        {
            if(m_fPoisonTimer>gpGlobals->time&&m_fPoisonTimer<gpGlobals->time+3.0 && !m_bCreatedPoison)
            {
                PoisonEffect();
            }
            if(m_fPoisonTimer < gpGlobals->time)
            {
                m_bPoison = false;
                m_bInSkill = false;
            }
            return;
        }
        float fDistance = GetTargetDistance();
        if(fDistance < 200.0) Attack();
        else MoveTowardEnemy();
    }
    return;
}
void CMonsterAngra::Dash(void)
{
    m_bInSkill = true;
    AtOrigin(m_pTarget->pev->origin);
    m_vecDashVelocity =  (m_pTarget->pev->origin - pev->origin).Normalize() * 1000.0;
    m_vecDashVelocity.z = 50.0;
    m_bDash = true;
    m_iDashStat = DASH_START;
    m_fDashTimer = gpGlobals->time + 1.0;
    SetSequence(ANIM_ROOLING1);
}
void CMonsterAngra::MoveTowardEnemy(void)
{
    Vector vecForward;
    Vector vecMove = m_pTarget->pev->origin - pev->origin;
    Vector vecAngles = UTIL_VecToAngles(vecMove);
    Vector yAngles = Vector(0, vecAngles.y, 0);
    UTIL_MakeVectorsPrivate(yAngles, vecForward, NULL, NULL);

    AtOrigin(m_pTarget->pev->origin);
    m_fSpeed = DEFAULT_ANGRA_MONSTER_SPEED;

    pev->velocity.x = vecForward.x * m_fSpeed;
    pev->velocity.y = vecForward.y * m_fSpeed;
    pev->velocity.z = 20;
    SetSequence(ANIM_ZBS_WALK);
}
void CMonsterAngra::SetSequence(MONSTER_SEQUENCE iSequence,bool forcePlay)
{
    if(forcePlay || (pev->sequence != iSequence&& !forcePlay))
    {
        pev->frame = 0;
        pev->sequence = iSequence;
        ResetSequenceInfo();
        m_fAnimationTimer = gpGlobals->time;
        m_Activity = Activity::ACT_SPECIAL_ATTACK2;
    }
}
void CMonsterAngra::SetActivity(Activity activity)
{
    if (m_Activity != activity)
    {
        int animDesired = LookupActivity(activity);

        if (animDesired != -1)
        {
            if (pev->sequence != animDesired)
            {
                if ((m_Activity != ACT_WALK || m_Activity != ACT_RUN) && (activity != ACT_WALK || activity != ACT_RUN))
                    pev->frame = 0;

                pev->sequence = animDesired;
            }

            m_Activity = activity;
            ResetSequenceInfo();
            m_fAnimationTimer = gpGlobals->time;
        }
    }
}
void CMonsterAngra::Precache(void)
{
    if (FStringNull(pev->model))
        pev->model = MAKE_STRING("models/boss3.mdl");

    m_iModelIndex = PRECACHE_MODEL((char *)STRING(pev->model));
    m_iModelIndexBloodSpray = PRECACHE_MODEL ("sprites/bloodspray.spr"); // initial blood
    m_iModelIndexBloodDrop = PRECACHE_MODEL ("sprites/blood.spr"); // splattered blood 
}
Vector CMonsterAngra::GetVelocityAngle(Vector vecVelocity)
{
    Vector vecReturn;
    VEC_TO_ANGLES(vecVelocity,vecReturn);
    if( vecReturn[0] > 90.0 ) vecReturn[0] = -(360.0 - vecReturn[0]);
    return vecReturn;
}