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) {
+        m_bGrenadeBounced = false;
         bRetVal           = true;
-        vDest   = origin - m_vGrenadePos;
-        vDest   = vDest * 16 + m_vGrenadePos;
-        SetPath(vDest, NULL, 0, NULL, 0.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;
+        VectorSubtract(origin, m_vGrenadePos, vDest);
-                m_eGrenadeState    = eNextState;
+        VectorNormalizeFast(vDest);
-                m_bNextForceStart  = false;
-                m_csNextAnimString = csReturnAnim;
-            }
-        } else {
-            Anim_RunToCasual(3);
 
-            vec2_t delta;
+        VectorMA(m_vGrenadePos, 16, vDest, vDest);
-            VectorSub2D(origin, m_vGrenadePos, delta);
 
-            if (VectorLength2DSquared(delta) > 1024.0) {
+        SetPath(vDest, NULL, 0, NULL, 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);
     }
-                }
+
-            }
+    if (!PathExists()) {
-        }
-    } 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,141 +87,160 @@ void Actor::InitGrenade(GlobalFuncs_t *func)
 
 void Actor::Grenade_Flee(void)
 {
-    //float origin_ratio;
-    float  fMinCloseDistSquared;
-    float  fCosAngle;
-    float  fSinAngle;
-    float  fAngle;
-    vec2_t vDirAway;
     vec2_t    vDirPreferred;
+    vec2_t    vDirAway;
+    float     fAngle, fSinAngle, fCosAngle;
+    float     fMinCloseDistSquared;
+    vec2_t    grenade_offset;
+    float     origin_ratio;
+    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) {
+
+                origin_ratio = DotProduct2D(grenade_offset, current_node->dir);
+                if (origin_ratio <= 0) {
+                    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
+    else if ((origin - m_vGrenadePos).lengthXYSquared() >= 100352
         || !G_SightTrace(
-                centroid, vec_zero, vec_zero, m_vGrenadePos, this, m_pGrenade, 33819417, 0, "Actor::Grenade_Flee"
+            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 {
-            m_bHasDesiredLookAngles = false;
         m_eGrenadeState = AI_GRENSTATE_FLEE_FAIL;
+        ForwardLook();
         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_bGrenadeBounced = true;
-            m_bHasDesiredLookAngles = false;
+        m_eGrenadeState   = AI_GRENSTATE_FLEE;
+        Grenade_Flee();
+        return;
+    }
 
-            vDest                = vec_zero;
+    if (PathComplete()) {
+        ForwardLook();
         m_pGrenade->velocity = vec_zero;
 
-            //weird ? m_pGrenade->velocity is vec_zero ???
+        if (m_pGrenade->velocity.lengthXYSquared() < Square(32)) {
-            if (m_pGrenade->velocity.lengthXYSquared() < 1024) {
             m_pGrenade->velocity = vec_zero;
 
             m_eGrenadeState = AI_GRENSTATE_MARTYR;
@@ -233,33 +248,25 @@ void Actor::Grenade_MartyrAcquire(void)
             Grenade_Martyr();
         }
     } else {
-            Anim_RunToCasual(3);
+        Anim_RunToCasual(ANIM_MODE_PATH_GOAL);
-            m_csPathGoalEndAnimScript = STRING_ANIM_GRENADEMARTYR_SCR;
+        SetPathGoalEndAnim(STRING_ANIM_GRENADEMARTYR_SCR);
-            if ((origin - m_vGrenadePos).lengthXYSquared() > 16384) {
+
+        VectorSub2D(origin, m_vGrenadePos, vDest);
+        if (VectorLength2DSquared(vDest) > Square(128)) {
             FaceMotion();
         } else {
-                if (m_vGrenadePos - origin != vec_zero) {
+            SetDesiredYawDest(m_vGrenadePos);
-                    SetDesiredYawDir(m_vGrenadePos - origin);
         }
     }
 }
-    } else {
-        m_bGrenadeBounced = true;
-        m_eGrenadeState   = AI_GRENSTATE_FLEE;
-        Grenade_Flee();
-    }
-}
 
 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,30 +276,35 @@ 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;
+    }
+
+    int              tagnum;
     Vector           vVel;
-        int              tagnum = gi.Tag_NumForName(edict->tiki, "tag_weapon_right");
+    eGrenadeTossMode eMode;
+
+    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)) {
@@ -302,23 +314,24 @@ void Actor::Grenade_EventAttach(Event *ev)
 
     SetDesiredYawDir(m_vGrenadeVel);
 }
-}
 
 void Actor::Grenade_EventDetach(Event *ev)
 {
-    if (m_pGrenade) {
+    if (!m_pGrenade) {
+        return;
+    }
+
+    const_str csAnim;
+
     m_pGrenade->detach();
-        m_pGrenade->setOrigin(GrenadeThrowPoint(
+    csAnim = m_eGrenadeMode == AI_GREN_KICK ? STRING_ANIM_GRENADEKICK_SCR : STRING_ANIM_GRENADERETURN_SCR;
-            origin,
+
-            orientation[0],
+    m_pGrenade->setOrigin(GrenadeThrowPoint(origin, orientation[0], csAnim));
-            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;
 }
-}
 
 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)) {
+            SetThinkState(THINKSTATE_ATTACK, THINKLEVEL_IDLE);
+        } else if (m_Team != TEAM_GERMAN) {
+            SetThinkState(THINKSTATE_IDLE, THINKLEVEL_IDLE);
+        } else {
+            if (!IsTeamMate(static_cast<Sentient *>(G_GetEntity(0)))) {
+                ForceAttackPlayer();
+            }
+        }
+
+        return;
+    }
+
+    if (m_pGrenade->enemy || m_pGrenade->edict->r.ownerNum == entnum) {
         m_eGrenadeState = AI_GRENSTATE_FLEE;
-            //LABEL_4:
         Grenade_Flee();
         return;
     }
 
-        if (m_pGrenade->edict->r.ownerNum == entnum) {
+    if (m_pGrenade) {
-            m_eGrenadeState = AI_GRENSTATE_FLEE;
+        vec3_t vDelta;
-            Grenade_Flee();
-            return;
-        }
-        bool   bHasThrowTarget = true;
         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;
+
             PostponeEvent(EV_Projectile_Explode, 0.25);
             Grenade_KickAcquire();
             return;
@@ -403,15 +429,9 @@ 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;
-            Grenade_Flee();
-            return;
-        }
-    } else {
-        if (m_Enemy && !m_Enemy->IsSubclassOfActor()) {
         SetThinkState(THINKSTATE_ATTACK, THINKLEVEL_IDLE);
     } else if (m_Team == TEAM_AMERICAN) {
         SetThinkState(THINKSTATE_IDLE, THINKLEVEL_IDLE);
@@ -421,7 +441,6 @@ void Actor::Begin_Grenade(void)
         }
     }
 }
-}
 
 void Actor::End_Grenade(void)
 {
@@ -466,6 +485,7 @@ void Actor::Think_Grenade(void)
     if (m_bEnableEnemy) {
         UpdateEnemy(200);
     }
+
     m_pszDebugState = "";
     NoPoint();
 
@@ -476,24 +496,7 @@ void Actor::Think_Grenade(void)
         return;
     }
 
-    if (!m_pGrenade) {
+    if (m_pGrenade) {
-        if (m_eGrenadeState && m_eGrenadeState != AI_GRENSTATE_FLEE_FAIL) {
-            // weird ? no such thing as 8 ?
-            // FIXME?
-            if (m_eGrenadeMode == (eGrenadeTossMode)8) {
-                Anim_Attack();
-            } else {
-                Anim_Stand();
-            }
-            Grenade_NextThinkState();
-        } else {
-            m_pszDebugState = "Wait";
-            Grenade_Wait();
-        }
-        PostThink(false);
-        return;
-    }
-
         switch (m_eGrenadeState) {
         case AI_GRENSTATE_FLEE:
         case AI_GRENSTATE_FLEE_SUCCESS:
@@ -534,6 +537,17 @@ void Actor::Think_Grenade(void)
             assert(!assertStr);
             break;
         }
+    } else if (m_eGrenadeState && m_eGrenadeState != AI_GRENSTATE_FLEE_FAIL) {
+        if (m_eGrenadeMode == AI_GRENSTATE_FLEE_SUCCESS) {
+            Anim_Attack();
+        } else {
+            Anim_Stand();
+        }
+        Grenade_NextThinkState();
+    } else {
+        m_pszDebugState = "Wait";
+        Grenade_Wait();
+    }
 
     PostThink(false);
 }