Finalized actor_grenade

code/fgame/actor_grenade.cpp

@@ -27,51 +27,47 @@ Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 
 bool Actor::Grenade_Acquire(eGrenadeState eNextState, const_str csReturnAnim)
 {
+    vec3_t vDest;
     bool   bRetVal = false;
-    Vector vDest;
+
     if (m_bGrenadeBounced) {
-        bRetVal = true;
+        m_bGrenadeBounced = false;
-        vDest   = origin - m_vGrenadePos;
+        bRetVal           = true;
-        vDest   = vDest * 16 + m_vGrenadePos;
+
-        SetPath(vDest, NULL, 0, NULL, 0.0);
+        VectorSubtract(origin, m_vGrenadePos, vDest);
+        VectorNormalizeFast(vDest);
+
+        VectorMA(m_vGrenadePos, 16, vDest, vDest);
+
+        SetPath(vDest, NULL, 0, NULL, 0);
     }
-    if (PathExists()) {
-        if (PathComplete()) {
-            m_bHasDesiredLookAngles = false;
-            if (m_pGrenade->velocity.lengthXYSquared() >= 1024) {
-                Anim_Stand();
-            } else {
-                m_pGrenade->velocity = vec_zero;
 
-                m_eNextAnimMode    = ANIM_MODE_NORMAL;
+    if (!PathExists()) {
-                m_eGrenadeState    = eNextState;
-                m_bNextForceStart  = false;
-                m_csNextAnimString = csReturnAnim;
-            }
-        } else {
-            Anim_RunToCasual(3);
-
-            vec2_t delta;
-            VectorSub2D(origin, m_vGrenadePos, delta);
-
-            if (VectorLength2DSquared(delta) > 1024.0) {
-                FaceMotion();
-            } else {
-                {
-                    vec2_t facedir;
-                    facedir[0] = m_vGrenadePos[0] - origin[0];
-                    facedir[1] = m_vGrenadePos[1] - origin[1];
-                    if (facedir[0] != 0 || facedir[1] != 0) {
-                        SetDesiredYawDir(facedir);
-                    }
-                }
-            }
-        }
-    } else {
         m_bGrenadeBounced = true;
         m_eGrenadeState   = AI_GRENSTATE_FLEE;
         Grenade_Flee();
-        bRetVal = false;
+        return false;
+    }
+
+    if (PathComplete()) {
+        ForwardLook();
+
+        if (VectorLength2DSquared(m_pGrenade->velocity) >= Square(32)) {
+            Anim_Stand();
+        } else {
+            m_pGrenade->velocity = vec_zero;
+            m_eGrenadeState      = eNextState;
+            DesiredAnimation(ANIM_MODE_NORMAL, csReturnAnim);
+        }
+    } else {
+        Anim_RunToCasual(ANIM_MODE_PATH_GOAL);
+        VectorSub2D(origin, m_vGrenadePos, vDest);
+
+        if (VectorLength2DSquared(vDest) > Square(32)) {
+            FaceMotion();
+        } else {
+            SetDesiredYawDest(m_vGrenadePos);
+        }
     }
 
     return bRetVal;
@@ -91,175 +87,186 @@ void Actor::InitGrenade(GlobalFuncs_t *func)
 
 void Actor::Grenade_Flee(void)
 {
-    //float origin_ratio;
+    vec2_t    vDirPreferred;
-    float  fMinCloseDistSquared;
+    vec2_t    vDirAway;
-    float  fCosAngle;
+    float     fAngle, fSinAngle, fCosAngle;
-    float  fSinAngle;
+    float     fMinCloseDistSquared;
-    float  fAngle;
+    vec2_t    grenade_offset;
-    vec2_t vDirAway;
+    float     origin_ratio;
-    vec2_t vDirPreferred;
+    PathInfo *current_node;
 
     if (m_bGrenadeBounced) {
-        fAngle = (rand() - 0x3FFFFFFF) * -0.00000000146291807926716;
+        fAngle    = (rand() - 0x3FFFFFFF) / 683565275.f;
-
         fSinAngle = sin(fAngle);
         fCosAngle = cos(fAngle);
 
         VectorSub2D(origin, m_vGrenadePos, vDirAway);
 
-        vDirPreferred[0] = vDirAway[0] * fCosAngle - fSinAngle * vDirAway[1];
+        vDirPreferred[0] = vDirAway[0] * fCosAngle - vDirAway[1] * fSinAngle;
         vDirPreferred[1] = vDirAway[0] * fSinAngle + vDirAway[1] * fCosAngle;
 
         FindPathAway(m_vGrenadePos, vDirPreferred, 512);
 
         if (PathExists() && !PathComplete()) {
-            fMinCloseDistSquared = VectorLength2DSquared(vDirAway) * 0.63999999;
+            fMinCloseDistSquared = VectorLength2DSquared(vDirAway) * 0.64f;
 
-            if (fMinCloseDistSquared < 1024) {
+            if (fMinCloseDistSquared < Square(64)) {
                 fMinCloseDistSquared = 0;
             }
 
-            vec2_t grenade_offset;
+            for (current_node = CurrentPathNode(); current_node >= LastPathNode(); current_node--) {
-            for (auto current_node = CurrentPathNode(); current_node >= LastPathNode(); current_node--) {
                 VectorSub2D(m_vGrenadePos, current_node->point, grenade_offset);
-                if (current_node->dist > 0 && DotProduct2D(grenade_offset, current_node->dir) <= current_node->dist) {
+
-                    if (Square(CrossProduct2D(grenade_offset, current_node->dir)) < fMinCloseDistSquared) {
+                origin_ratio = DotProduct2D(grenade_offset, current_node->dir);
-                        ClearPath();
+                if (origin_ratio <= 0) {
-                        break;
+                    continue;
-                    }
+                }
+
+                if (origin_ratio > current_node->dist) {
+                    continue;
+                }
+
+                if (Square(CrossProduct2D(grenade_offset, current_node->dir)) < fMinCloseDistSquared) {
+                    ClearPath();
+                    break;
                 }
             }
         }
+
         m_bGrenadeBounced = false;
     }
 
     if (PathExists() && !PathComplete()) {
         Sentient *pOwner = NULL;
+
         if (m_pGrenade && m_pGrenade->IsSubclassOfProjectile()) {
-            pOwner = ((Projectile *)m_pGrenade.Pointer())->GetOwner();
+            pOwner = static_cast<Projectile *>(m_pGrenade.Pointer())->GetOwner();
         }
 
         if (pOwner && pOwner->m_Team == m_Team) {
-            Anim_RunTo(3);
+            Anim_RunTo(ANIM_MODE_PATH_GOAL);
         } else {
-            Anim_RunToFlee(3);
+            Anim_RunToFlee(ANIM_MODE_PATH_GOAL);
         }
+
         FaceMotion();
+    }
+    else if ((origin - m_vGrenadePos).lengthXYSquared() >= 100352
+        || !G_SightTrace(
+            centroid, vec_zero, vec_zero, m_vGrenadePos, this, m_pGrenade, MASK_CANSEE, 0, "Actor::Grenade_Flee"
+        )) {
+        m_eGrenadeState = AI_GRENSTATE_FLEE_SUCCESS;
+        Anim_Attack();
+        AimAtTargetPos();
     } else {
-        if ((origin - m_vGrenadePos).lengthXYSquared() >= 100352
+        m_eGrenadeState = AI_GRENSTATE_FLEE_FAIL;
-            || !G_SightTrace(
+        ForwardLook();
-                centroid, vec_zero, vec_zero, m_vGrenadePos, this, m_pGrenade, 33819417, 0, "Actor::Grenade_Flee"
+        Anim_Cower();
-            )) {
-            m_eGrenadeState = AI_GRENSTATE_FLEE_SUCCESS;
-            Anim_Attack();
-            AimAtTargetPos();
-        } else {
-            m_bHasDesiredLookAngles = false;
-            m_eGrenadeState         = AI_GRENSTATE_FLEE_FAIL;
-            Anim_Cower();
-        }
     }
 }
 
 void Actor::Grenade_ThrowAcquire(void)
 {
-    if (!Grenade_Acquire(AI_GRENSTATE_THROW, STRING_ANIM_GRENADERETURN_SCR)
+    if (Grenade_Acquire(AI_GRENSTATE_THROW, STRING_ANIM_GRENADERETURN_SCR)) {
-        && !CanGetGrenadeFromAToB(m_vGrenadePos, m_vLastEnemyPos, true, &m_vGrenadeVel, &m_eGrenadeMode)) {
+        return;
-        m_bGrenadeBounced = true;
-        m_eGrenadeState   = AI_GRENSTATE_FLEE;
-        Grenade_Flee();
     }
+
+    if (CanGetGrenadeFromAToB(m_vGrenadePos, m_vLastEnemyPos, true, &m_vGrenadeVel, &m_eGrenadeMode)) {
+        return;
+    }
+
+    m_eGrenadeState   = AI_GRENSTATE_FLEE;
+    m_bGrenadeBounced = true;
+    Grenade_Flee();
 }
 
 void Actor::Grenade_Throw(void)
 {
-    m_bHasDesiredLookAngles = false;
+    ForwardLook();
-
     SetDesiredYawDir(m_vGrenadeVel);
-
     ContinueAnimation();
 }
 
 void Actor::Grenade_KickAcquire(void)
 {
-    Vector vFace = vec_zero;
+    Vector vDelta;
-    if (!Grenade_Acquire(AI_GRENSTATE_KICK, STRING_ANIM_GRENADEKICK_SCR)) {
-        VectorSub2D(m_vGrenadePos, origin, vFace);
-        if (CanKickGrenade(m_vGrenadePos, m_vLastEnemyPos, vFace, &m_vGrenadeVel)) {
-            m_vKickDir = Vector(m_vGrenadeVel[0], m_vGrenadeVel[1], 0);
 
-            VectorNormalizeFast(m_vKickDir);
+    if (Grenade_Acquire(AI_GRENSTATE_KICK, STRING_ANIM_GRENADEKICK_SCR)) {
-        } else {
+        return;
-            m_bGrenadeBounced = true;
+    }
-            m_eGrenadeState   = AI_GRENSTATE_FLEE;
+
-            Grenade_Flee();
+    vDelta   = m_vGrenadePos - origin;
-        }
+    vDelta.z = 0;
+
+    if (CanKickGrenade(m_vGrenadePos, m_vLastEnemyPos, vDelta, &m_vGrenadeVel)) {
+        m_vKickDir   = m_vGrenadeVel;
+        m_vKickDir.z = 0;
+        m_vKickDir.normalizefast();
+    } else {
+        m_eGrenadeState   = AI_GRENSTATE_FLEE;
+        m_bGrenadeBounced = true;
+        Grenade_Flee();
     }
 }
 
 void Actor::Grenade_Kick(void)
 {
-    m_bHasDesiredLookAngles = false;
+    ForwardLook();
     ContinueAnimation();
 }
 
 void Actor::Grenade_MartyrAcquire(void)
 {
-    Vector vDest;
+    vec3_t vDest;
+
     if (m_bGrenadeBounced) {
         m_bGrenadeBounced = false;
 
-        vDest = origin - m_vGrenadePos;
+        VectorSubtract(origin, m_vGrenadePos, vDest);
         VectorNormalizeFast(vDest);
-
+        VectorMA(m_vGrenadePos, 88, vDest, vDest);
-        vDest = vDest * 88 + m_vGrenadePos;
 
         SetPath(vDest, NULL, 0, NULL, 0.0);
     }
 
-    if (PathExists()) {
+    if (!PathExists()) {
-        if (PathComplete()) {
-            m_bHasDesiredLookAngles = false;
-
-            vDest                = vec_zero;
-            m_pGrenade->velocity = vec_zero;
-
-            //weird ? m_pGrenade->velocity is vec_zero ???
-            if (m_pGrenade->velocity.lengthXYSquared() < 1024) {
-                m_pGrenade->velocity = vec_zero;
-
-                m_eGrenadeState = AI_GRENSTATE_MARTYR;
-                m_iStateTime    = level.inttime;
-                Grenade_Martyr();
-            }
-        } else {
-            Anim_RunToCasual(3);
-            m_csPathGoalEndAnimScript = STRING_ANIM_GRENADEMARTYR_SCR;
-            if ((origin - m_vGrenadePos).lengthXYSquared() > 16384) {
-                FaceMotion();
-            } else {
-                if (m_vGrenadePos - origin != vec_zero) {
-                    SetDesiredYawDir(m_vGrenadePos - origin);
-                }
-            }
-        }
-    } else {
         m_bGrenadeBounced = true;
         m_eGrenadeState   = AI_GRENSTATE_FLEE;
         Grenade_Flee();
+        return;
+    }
+
+    if (PathComplete()) {
+        ForwardLook();
+        m_pGrenade->velocity = vec_zero;
+
+        if (m_pGrenade->velocity.lengthXYSquared() < Square(32)) {
+            m_pGrenade->velocity = vec_zero;
+
+            m_eGrenadeState = AI_GRENSTATE_MARTYR;
+            m_iStateTime    = level.inttime;
+            Grenade_Martyr();
+        }
+    } else {
+        Anim_RunToCasual(ANIM_MODE_PATH_GOAL);
+        SetPathGoalEndAnim(STRING_ANIM_GRENADEMARTYR_SCR);
+
+        VectorSub2D(origin, m_vGrenadePos, vDest);
+        if (VectorLength2DSquared(vDest) > Square(128)) {
+            FaceMotion();
+        } else {
+            SetDesiredYawDest(m_vGrenadePos);
+        }
     }
 }
 
 void Actor::Grenade_Martyr(void)
 {
     if (m_pGrenade && level.inttime >= (m_iStateTime + 1000) - 0.5) {
-        Projectile *m_pPGrenade = (Projectile *)m_pGrenade.Pointer();
+        static_cast<Projectile *>(m_pGrenade.Pointer())->SetMartyr(entnum);
-
-        m_pPGrenade->m_bHurtOwnerOnly = true;
-        m_pPGrenade->owner            = entnum;
     }
 
-    m_bHasDesiredLookAngles = false;
+    ForwardLook();
     ContinueAnimation();
 }
 
@@ -269,55 +276,61 @@ void Actor::Grenade_Wait(void)
         Anim_Cower();
     } else {
         Anim_Stand();
-
         Grenade_NextThinkState();
     }
 }
 
 void Actor::Grenade_NextThinkState(void)
 {
-    if (m_Enemy && !(m_Enemy->IsSubclassOfActor())) {
+    if (!m_Enemy || (m_Enemy->flags & FL_NOTARGET)) {
-        SetThinkState(THINKSTATE_ATTACK, THINKLEVEL_IDLE);
-    } else {
         SetThinkState(THINKSTATE_IDLE, THINKLEVEL_IDLE);
+        return;
     }
+
+    SetThinkState(THINKSTATE_ATTACK, THINKLEVEL_IDLE);
 }
 
 void Actor::Grenade_EventAttach(Event *ev)
 {
-    if (m_pGrenade) {
+    if (!m_pGrenade) {
-        eGrenadeTossMode eMode;
+        return;
-        Vector           vVel;
-        int              tagnum = gi.Tag_NumForName(edict->tiki, "tag_weapon_right");
-        if (tagnum >= 0) {
-            vVel = vec_zero;
-            m_pGrenade->attach(entnum, tagnum, qtrue, vec3_origin);
-        }
-        m_pGrenade->avelocity = vec3_origin;
-
-        if (CanGetGrenadeFromAToB(origin, m_vLastEnemyPos, true, &vVel, &eMode)) {
-            m_vGrenadeVel  = vVel;
-            m_eGrenadeMode = eMode;
-        }
-
-        SetDesiredYawDir(m_vGrenadeVel);
     }
+
+    int              tagnum;
+    Vector           vVel;
+    eGrenadeTossMode eMode;
+
+    tagnum = gi.Tag_NumForName(edict->tiki, "tag_weapon_right");
+    if (tagnum >= 0) {
+        m_pGrenade->attach(entnum, tagnum, qtrue, vec3_origin);
+    }
+
+    m_pGrenade->avelocity = vec3_origin;
+
+    if (CanGetGrenadeFromAToB(origin, m_vLastEnemyPos, true, &vVel, &eMode)) {
+        m_vGrenadeVel  = vVel;
+        m_eGrenadeMode = eMode;
+    }
+
+    SetDesiredYawDir(m_vGrenadeVel);
 }
 
 void Actor::Grenade_EventDetach(Event *ev)
 {
-    if (m_pGrenade) {
+    if (!m_pGrenade) {
-        m_pGrenade->detach();
+        return;
-        m_pGrenade->setOrigin(GrenadeThrowPoint(
-            origin,
-            orientation[0],
-            m_eGrenadeMode == AI_GREN_KICK ? STRING_ANIM_GRENADEKICK_SCR : STRING_ANIM_GRENADERETURN_SCR
-        ));
-        m_pGrenade->velocity = m_vGrenadeVel;
-
-        m_pGrenade->edict->r.ownerNum = edict->s.number;
-        m_pGrenade->groundentity      = NULL;
     }
+
+    const_str csAnim;
+
+    m_pGrenade->detach();
+    csAnim = m_eGrenadeMode == AI_GREN_KICK ? STRING_ANIM_GRENADEKICK_SCR : STRING_ANIM_GRENADERETURN_SCR;
+
+    m_pGrenade->setOrigin(GrenadeThrowPoint(origin, orientation[0], csAnim));
+    m_pGrenade->velocity = m_vGrenadeVel;
+
+    m_pGrenade->edict->r.ownerNum = edict->s.number;
+    m_pGrenade->groundentity      = NULL;
 }
 
 void Actor::Begin_Grenade(void)
@@ -326,24 +339,33 @@ void Actor::Begin_Grenade(void)
     m_csMood     = STRING_ALERT;
     m_csIdleMood = STRING_NERVOUS;
 
-    if (m_pGrenade) {
+    if (!m_pGrenade) {
-        if (m_pGrenade->enemy) {
+        if (m_Enemy && (m_Enemy->flags & FL_NOTARGET)) {
-            m_eGrenadeState = AI_GRENSTATE_FLEE;
+            SetThinkState(THINKSTATE_ATTACK, THINKLEVEL_IDLE);
-            //LABEL_4:
+        } else if (m_Team != TEAM_GERMAN) {
-            Grenade_Flee();
+            SetThinkState(THINKSTATE_IDLE, THINKLEVEL_IDLE);
-            return;
+        } else {
+            if (!IsTeamMate(static_cast<Sentient *>(G_GetEntity(0)))) {
+                ForceAttackPlayer();
+            }
         }
 
-        if (m_pGrenade->edict->r.ownerNum == entnum) {
+        return;
-            m_eGrenadeState = AI_GRENSTATE_FLEE;
+    }
-            Grenade_Flee();
+
-            return;
+    if (m_pGrenade->enemy || m_pGrenade->edict->r.ownerNum == entnum) {
-        }
+        m_eGrenadeState = AI_GRENSTATE_FLEE;
-        bool   bHasThrowTarget = true;
+        Grenade_Flee();
+        return;
+    }
+
+    if (m_pGrenade) {
+        vec3_t vDelta;
         float  fDistSquared;
-        Vector vDelta;
+        bool   bHasThrowTarget;
+
         if (!m_Enemy) {
-            Sentient *pEnemy = (Sentient *)G_GetEntity(m_pGrenade->edict->r.ownerNum);
+            Sentient *pEnemy = static_cast<Sentient *>(G_GetEntity(m_pGrenade->edict->r.ownerNum));
 
             if (pEnemy && pEnemy->m_Team != m_Team) {
                 SetEnemyPos(pEnemy->origin);
@@ -351,15 +373,17 @@ void Actor::Begin_Grenade(void)
                 bHasThrowTarget = false;
             }
         }
+
         if (!bHasThrowTarget) {
             m_eGrenadeState = AI_GRENSTATE_FLEE;
             Grenade_Flee();
             return;
         }
-        vDelta       = m_vGrenadePos - origin;
+
-        vDelta.z     = 0;
+        VectorSub2D(m_vGrenadePos, origin, vDelta);
-        fDistSquared = vDelta.lengthXYSquared();
+        fDistSquared = VectorLength2DSquared(vDelta);
-        if (fDistSquared >= 65536) {
+
+        if (fDistSquared >= Square(256)) {
             m_eGrenadeState = AI_GRENSTATE_FLEE;
             Grenade_Flee();
             return;
@@ -379,15 +403,17 @@ void Actor::Begin_Grenade(void)
             return;
         }
 
-        if (CanKickGrenade(m_vGrenadePos, m_vLastEnemyPos, vDelta, &m_vGrenadeVel)) {
+        Vector vFace = vDelta;
+        if (CanKickGrenade(m_vGrenadePos, m_vLastEnemyPos, vFace, &m_vGrenadeVel)) {
             m_eGrenadeMode = AI_GREN_KICK;
 
-            m_vKickDir = Vector(m_vGrenadeVel[0], m_vGrenadeVel[1], 0);
+            m_vKickDir   = m_vGrenadeVel;
-            VectorNormalizeFast(m_vKickDir);
+            m_vKickDir.z = 0;
+            m_vKickDir.normalizefast();
 
             m_pGrenade->enemy = this;
+            m_eGrenadeState   = AI_GRENSTATE_KICK_ACQUIRE;
 
-            m_eGrenadeState = AI_GRENSTATE_KICK_ACQUIRE;
             PostponeEvent(EV_Projectile_Explode, 0.25);
             Grenade_KickAcquire();
             return;
@@ -403,22 +429,15 @@ void Actor::Begin_Grenade(void)
 
         m_eGrenadeState = AI_GRENSTATE_THROW_ACQUIRE;
         PostponeEvent(EV_Projectile_Explode, 0.75);
-        if (!Grenade_Acquire(AI_GRENSTATE_THROW, STRING_ANIM_GRENADERETURN_SCR)
+
-            && !Actor::CanGetGrenadeFromAToB(m_vGrenadePos, m_vLastEnemyPos, true, &m_vGrenadeVel, &m_eGrenadeMode)) {
+        Grenade_ThrowAcquire();
-            m_bGrenadeBounced = true;
+    } else if (m_Enemy && !m_Enemy->IsSubclassOfActor()) {
-            m_eGrenadeState   = AI_GRENSTATE_FLEE;
+        SetThinkState(THINKSTATE_ATTACK, THINKLEVEL_IDLE);
-            Grenade_Flee();
+    } else if (m_Team == TEAM_AMERICAN) {
-            return;
+        SetThinkState(THINKSTATE_IDLE, THINKLEVEL_IDLE);
-        }
     } else {
-        if (m_Enemy && !m_Enemy->IsSubclassOfActor()) {
+        if (!IsTeamMate((Sentient *)G_GetEntity(0))) {
-            SetThinkState(THINKSTATE_ATTACK, THINKLEVEL_IDLE);
+            ForceAttackPlayer();
-        } else if (m_Team == TEAM_AMERICAN) {
-            SetThinkState(THINKSTATE_IDLE, THINKLEVEL_IDLE);
-        } else {
-            if (!IsTeamMate((Sentient *)G_GetEntity(0))) {
-                ForceAttackPlayer();
-            }
         }
     }
 }
@@ -466,6 +485,7 @@ void Actor::Think_Grenade(void)
     if (m_bEnableEnemy) {
         UpdateEnemy(200);
     }
+
     m_pszDebugState = "";
     NoPoint();
 
@@ -476,63 +496,57 @@ void Actor::Think_Grenade(void)
         return;
     }
 
-    if (!m_pGrenade) {
+    if (m_pGrenade) {
-        if (m_eGrenadeState && m_eGrenadeState != AI_GRENSTATE_FLEE_FAIL) {
+        switch (m_eGrenadeState) {
-            // weird ? no such thing as 8 ?
+        case AI_GRENSTATE_FLEE:
-            // FIXME?
+        case AI_GRENSTATE_FLEE_SUCCESS:
-            if (m_eGrenadeMode == (eGrenadeTossMode)8) {
+        case AI_GRENSTATE_FLEE_FAIL:
-                Anim_Attack();
+            m_pszDebugState = "RunAway";
-            } else {
+            Grenade_Flee();
-                Anim_Stand();
+            break;
-            }
+        case AI_GRENSTATE_THROW_ACQUIRE:
-            Grenade_NextThinkState();
+            m_pszDebugState = "ThrowAcquire";
-        } else {
+            Grenade_ThrowAcquire();
-            m_pszDebugState = "Wait";
+            break;
-            Grenade_Wait();
+        case AI_GRENSTATE_THROW:
+            m_pszDebugState = "Throw";
+            Grenade_Throw();
+            break;
+        case AI_GRENSTATE_KICK_ACQUIRE:
+            m_pszDebugState = "KickAcquire";
+            Grenade_KickAcquire();
+            break;
+        case AI_GRENSTATE_KICK:
+            m_pszDebugState         = "Kick";
+            m_bHasDesiredLookAngles = false;
+            ContinueAnimation();
+            break;
+        case AI_GRENSTATE_MARTYR_ACQUIRE:
+            m_pszDebugState = "MartyrAcquire";
+            Grenade_MartyrAcquire();
+            break;
+        case AI_GRENSTATE_MARTYR:
+            m_pszDebugState = "Martyr";
+            Grenade_Martyr();
+            break;
+        default:
+            m_pszDebugState       = "***Invalid***";
+            char assertStr[16317] = {0};
+            strcpy(assertStr, "\"invalid grenade state\"\n\tMessage: ");
+            Q_strcat(assertStr, sizeof(assertStr), DumpCallTrace("thinkstate = %i", m_State));
+            assert(!assertStr);
+            break;
         }
-        PostThink(false);
+    } else if (m_eGrenadeState && m_eGrenadeState != AI_GRENSTATE_FLEE_FAIL) {
-        return;
+        if (m_eGrenadeMode == AI_GRENSTATE_FLEE_SUCCESS) {
-    }
+            Anim_Attack();
-
+        } else {
-    switch (m_eGrenadeState) {
+            Anim_Stand();
-    case AI_GRENSTATE_FLEE:
+        }
-    case AI_GRENSTATE_FLEE_SUCCESS:
+        Grenade_NextThinkState();
-    case AI_GRENSTATE_FLEE_FAIL:
+    } else {
-        m_pszDebugState = "RunAway";
+        m_pszDebugState = "Wait";
-        Grenade_Flee();
+        Grenade_Wait();
-        break;
-    case AI_GRENSTATE_THROW_ACQUIRE:
-        m_pszDebugState = "ThrowAcquire";
-        Grenade_ThrowAcquire();
-        break;
-    case AI_GRENSTATE_THROW:
-        m_pszDebugState = "Throw";
-        Grenade_Throw();
-        break;
-    case AI_GRENSTATE_KICK_ACQUIRE:
-        m_pszDebugState = "KickAcquire";
-        Grenade_KickAcquire();
-        break;
-    case AI_GRENSTATE_KICK:
-        m_pszDebugState         = "Kick";
-        m_bHasDesiredLookAngles = false;
-        ContinueAnimation();
-        break;
-    case AI_GRENSTATE_MARTYR_ACQUIRE:
-        m_pszDebugState = "MartyrAcquire";
-        Grenade_MartyrAcquire();
-        break;
-    case AI_GRENSTATE_MARTYR:
-        m_pszDebugState = "Martyr";
-        Grenade_Martyr();
-        break;
-    default:
-        m_pszDebugState       = "***Invalid***";
-        char assertStr[16317] = {0};
-        strcpy(assertStr, "\"invalid grenade state\"\n\tMessage: ");
-        Q_strcat(assertStr, sizeof(assertStr), DumpCallTrace("thinkstate = %i", m_State));
-        assert(!assertStr);
-        break;
     }
 
     PostThink(false);