NSMonster.h

Go to the documentation of this file.

/*
 * Copyright (c) 2016-2024 Vera Visions LLC.
 *
 * Permission to use, copy, modify, and distribute this software for any
 * purpose with or without fee is hereby granted, provided that the above
 * copyright notice and this permission notice appear in all copies.
 *
 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
 * WHATSOEVER RESULTING FROM LOSS OF MIND, USE, DATA OR PROFITS, WHETHER
 * IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING
 * OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
*/
 
var bool autocvar_ai_debugLogic = false;
void
_NSMonster_Log(string className, string functionName, float edictNum, string warnMessage)
{
        if (autocvar_g_developerTimestamps)
                printf("^9%f ^5%s (%d) ^7: %s\n", time, functionName, edictNum, warnMessage);
        else
                printf("^5%s (%d) ^7: %s\n", functionName, edictNum, warnMessage);
}
#define NSMonsterLog(...) if (autocvar_ai_debugLogic == true) _NSMonster_Log(classname, __FUNC__, num_for_edict(this), sprintf(__VA_ARGS__))
 
typedef enumflags
{
        MONFL_CHANGED_ORIGIN_X,
        MONFL_CHANGED_ORIGIN_Y,
        MONFL_CHANGED_ORIGIN_Z,
        MONFL_CHANGED_ANGLES_X,
        MONFL_CHANGED_ANGLES_Y,
        MONFL_CHANGED_ANGLES_Z,
        MONFL_CHANGED_MODELINDEX,
        MONFL_CHANGED_SIZE,
        MONFL_CHANGED_FLAGS,
        MONFL_CHANGED_SOLID,
        MONFL_CHANGED_FRAME,
        MONFL_CHANGED_SKINHEALTH,
        MONFL_CHANGED_MOVETYPE,
        MONFL_CHANGED_EFFECTS,
        MONFL_CHANGED_BODY,
        MONFL_CHANGED_SCALE,
        MONFL_CHANGED_VELOCITY,
        MONFL_CHANGED_RENDERCOLOR,
        MONFL_CHANGED_RENDERAMT,
        MONFL_CHANGED_RENDERMODE,
        MONFL_CHANGED_HEADYAW
} nsmonster_changed_t;
 
typedef enum {
        ACT_RESET = 0,
        ACT_IDLE = 1i,
        ACT_GUARD,
        ACT_WALK,
        ACT_RUN,
        ACT_FLY,
        ACT_SWIM,
        ACT_HOP,
        ACT_LEAP,
        ACT_FALL,
        ACT_LAND,
        ACT_STRAFE_LEFT,
        ACT_STRAFE_RIGHT,
        ACT_ROLL_LEFT,
        ACT_ROLL_RIGHT,
        ACT_TURN_LEFT,
        ACT_TURN_RIGHT,
        ACT_CROUCH,
        ACT_CROUCHIDLE, 
        ACT_STAND,
        ACT_USE,
        ACT_SIGNAL1,
        ACT_SIGNAL2,
        ACT_SIGNAL3,
        ACT_TWITCH,
        ACT_COWER,
        ACT_SMALL_FLINCH,
        ACT_BIG_FLINCH,
        ACT_RANGE_ATTACK1,
        ACT_RANGE_ATTACK2,
        ACT_MELEE_ATTACK1,
        ACT_MELEE_ATTACK2,
        ACT_RELOAD,
        ACT_ARM,
        ACT_DISARM,
        ACT_EAT,
        ACT_DIESIMPLE,
        ACT_DIEBACKWARD,
        ACT_DIEFORWARD,
        ACT_DIEVIOLENT,
        ACT_BARNACLE_HIT,
        ACT_BARNACLE_PULL,
        ACT_BARNACLE_CHOMP,
        ACT_BARNACLE_CHEW,
        ACT_SLEEP,
        ACT_INSPECT_FLOOR,
        ACT_INSPECT_WALL,
        ACT_IDLE_ANGRY,
        ACT_WALK_HURT,
        ACT_RUN_HURT,
        ACT_HOVER,
        ACT_GLIDE,
        ACT_FLY_LEFT,
        ACT_FLY_RIGHT,
        ACT_DETECT_SCENT,
        ACT_SNIFF,
        ACT_BITE,
        ACT_THREAT_DISPLAY,
        ACT_FEAR_DISPLAY,
        ACT_EXCITED,
        ACT_SPECIAL_ATTACK1,
        ACT_SPECIAL_ATTACK2,    
        ACT_COMBAT_IDLE,
        ACT_WALK_SCARED,
        ACT_RUN_SCARED,
        ACT_VICTORY_DANCE,
        ACT_DIE_HEADSHOT,
        ACT_DIE_CHESTSHOT,
        ACT_DIE_GUTSHOT,
        ACT_DIE_BACKSHOT,
        ACT_FLINCH_HEAD,
        ACT_FLINCH_CHEST,
        ACT_FLINCH_STOMACH,
        ACT_FLINCH_LEFTARM,
        ACT_FLINCH_RIGHTARM,
        ACT_FLINCH_LEFTLEG,
        ACT_FLINCH_RIGHTLEG,
} monster_activity_t;
 
typedef enumflags
{
        MSF_WAITTILLSEEN,       
        MSF_GAG,                        
        MSF_MONSTERCLIP,        
        MSF_RESERVED1,          
        MSF_PRISONER,           
        MSF_RESERVED2,          
        MSF_IGNOREPLAYER,       
        MSF_WAITFORSCRIPT,      
        MSF_RESERVED3,          
        MSF_FADECORPSE,         
        MSF_MULTIPLAYER,        
        MSF_FALLING,            
        MSF_HORDE                       
} monsterFlag_t;
 
typedef enumflags
{
        SMSF_WAITTILLSEEN,              
        SMSF_GAG,                               
        SMSF_FALLTOGROUND,              
        SMSF_DROPHEALTHKIT,             
        SMSF_EFFICIENT,                 
        SMSF_RESERVED1,                 
        SMSF_RESERVED2,                 
        SMSF_WAITFORSCRIPT,             
        SMSF_LONGVISIBILITY,    
        SMSF_FADECORPSE,                
        SMSF_THINKOUTPVS,               
        SMSF_TEMPLATE,                  
        SMSF_ALTCOLLISION,              
        SMSF_NODROPWEAPONS,             
        SMSF_IGNOREPLAYERPUSH   
} sourceMonsterFlag_t;
 
typedef enum
{
        MONSTER_IDLE,
        MONSTER_ALERT,
        MONSTER_FOLLOWING,
        MONSTER_CHASING,
        MONSTER_AIMING,
        MONSTER_DEAD,
        MONSTER_GIBBED
} monsterState_t;
 
typedef enum
{
        SEQUENCESTATE_NONE,
        SEQUENCESTATE_IDLE,
        SEQUENCESTATE_ACTIVE,
        SEQUENCESTATE_ENDING
} sequenceState_t;
 
typedef enum
{
        MAL_FRIEND, 
        MAL_ENEMY,  
        MAL_ALIEN,  
        MAL_ROGUE,   
        MAL_NEUTRAL     
} allianceState_t;
 
typedef enum
{
        MOVESTATE_IDLE,
        MOVESTATE_WALK,
        MOVESTATE_RUN
} movementState_t;
 
typedef enum
{
        MTRIG_NONE,                                     
        MTRIG_SEEPLAYER_ANGRY,          
        MTRIG_PAIN,                                     
        MTRIG_HALFHEALTH,                       
        MTRIG_DEATH,                            
        MTRIG_SQUADMEMBERDEAD,          
        MTRIG_SQUADLEADERDEAD,          
        MTRIG_HEARNOISE,                        
        MTRIG_HEARENEMYPLAYER,          
        MTRIG_HEARWEAPONS,                      
        MTRIG_SEEPLAYER,                        
        MTRIG_SEEPLAYER_RELAXED,        
} triggerCondition_t;
 
/* FIXME: I'd like to move this into NSMonster, but our current IsFriend()
 * check is currently only checking on a .takedamage basis. */
.int m_iAlliance;
 
class NSMonster:NSNavAI
{
public:
        void NSMonster(void);
 
#ifdef SERVER   
        /* overrides */
        virtual void Save(float);
        virtual void Restore(string,string);
        virtual void EvaluateEntity(void);
        virtual float SendEntity(entity,float);
        virtual void Touch(entity);
        //virtual void Hide(void);
        virtual void Spawned(void);
        virtual void Respawn(void);
        virtual void Input(entity,string,string);
        virtual void Pain(void);
        virtual void Death(void);
        virtual void Physics(void);
        virtual void Gib(void);
        virtual void Sound(string);
        virtual void SpawnKey(string,string);
 
        virtual void RunAI(void);
        virtual void IdleNoise(void);
        virtual void FallNoise(void);
        virtual void AlertNoise(void);
 
        virtual bool IsAlive(void);
        virtual bool IsFriend(int);
        virtual void HasBeenKilled(void);
        virtual void HasBeenHit(void);
        /* Overridable: Called when the monster was gibbed. */
        virtual void HasBeenGibbed(void);
        /* Overridable: Called when the monster has been alerted to threat. */
        virtual void HasBeenAlerted(void);
 
        /* see/hear subsystem */
        virtual void SeeThink(void);
        virtual float SeeFOV(void);
 
        virtual void AlertNearby(void);
 
        /* movement */
        virtual float GetWalkSpeed(void);
        virtual float GetChaseSpeed(void);
        virtual float GetRunSpeed(void);
        virtual float GetYawSpeed(void);
 
        /* attack system */
        virtual void AttackDraw(void);
        virtual void AttackHolster(void);
        virtual void AttackThink(void);
        virtual int AttackMelee(void);
        virtual int AttackRanged(void);
 
        virtual float MeleeMaxDistance(void);
 
        virtual bool MeleeCondition(void);
 
        nonvirtual bool IsValidEnemy(entity);
        virtual bool IsOnRoute(void);
 
        /* sequences */
        virtual void FreeState(void);
        virtual void FreeStateMoved(void);
        virtual void FreeStateDead(void);
        virtual void RouteEnded(void);
        virtual void WalkRoute(void);
        
        nonvirtual int GetSequenceState(void);
        nonvirtual bool InSequence(void);
 
        /* animation cycles */
        virtual int AnimIdle(void);
        virtual int AnimWalk(void);
        virtual int AnimRun(void);
        virtual float FramegroupForAct(float);
        nonvirtual void ActPlay(float);
        virtual void AnimPlay(float);
        virtual void AnimationUpdate(void);
        nonvirtual bool InAnimation(void);
        nonvirtual void AnimReset(void);
 
        /* states */
        virtual void StateChanged(monsterState_t,monsterState_t);
        nonvirtual void SetState(monsterState_t);
        nonvirtual monsterState_t GetState(void);
 
        /* TriggerTarget/Condition */
        nonvirtual int GetTriggerCondition(void);
        virtual void TriggerTargets(void);
 
        virtual void Trigger(entity, triggermode_t);
#endif
 
#ifdef CLIENT
 
        virtual void customphysics(void);
        virtual float predraw(void);
        virtual void ReceiveEntity(float,float);
#endif
 
private:
 
        vector v_angle_net;
 
#ifdef CLIENT
        nonvirtual void _RenderDebugViewCone();
#endif
 
        PREDICTED_FLOAT(m_flHeadYaw)
        PREDICTED_FLOAT_N(subblendfrac)
        PREDICTED_FLOAT_N(bonecontrol1)
 
#ifdef SERVER
        entity m_eLookAt;
        entity m_ssLast;
        vector oldnet_velocity;
        float m_flPitch;
        int m_iFlags;
        vector base_mins;
        vector base_maxs;
        float base_health;
 
        /* sequences */
        string m_strRouteEnded;
        int m_iSequenceRemove;
        int m_iSequenceState;
        float m_flSequenceEnd;
        float m_flSequenceSpeed;
        vector m_vecSequenceAngle;
        int m_iSequenceFlags;
        movementState_t m_iMoveState;
        string m_strSequenceKillTarget;
 
        int m_iTriggerCondition;
        string m_strTriggerTarget;
 
        /* model events */
        float m_flBaseTime;
 
        /* attack/alliance system */
        entity m_eEnemy;
        float m_flAttackThink;
        monsterState_t m_iMState;
        monsterState_t m_iOldMState;
        vector m_vecLKPos; /* last-known pos */
 
        /* see/hear subsystem */
        float m_flSeeTime;
        /* animation cycles */
        float m_flAnimTime;
 
        /* timer for keeping track of the target */
        float m_flTrackingTime;
 
        PREDICTED_VECTOR_N(view_ofs)
 
        /* caching variables, don't save these */
        float m_actIdle;
        bool m_bTurning;
        float m_flIdleNext;
        float _m_flMeleeAttempts;
        float _m_flMeleeDelay;
        float _m_flBurstCount;
        bool _m_bShouldThrow;
        bool _m_bStartDead;
        float _m_flFrame;
 
        /* save these please */
        float _m_flReloadTracker;
        bool m_bWeaponDrawn;
 
        /* entityDef related */
        float m_flEyeHeight;
        string m_sndSight;
        string m_sndIdle;
        float m_flIdleMin;
        float m_flIdleMax;
        string m_sndFootstep;
        string m_sndChatter;
        string m_sndChatterCombat;
        string m_sndPain;
 
        string m_sndMeleeAttack;
        string m_sndMeleeAttackHit;
        string m_sndMeleeAttackMiss;
 
        string m_sndDeath;
        string m_sndThud;
 
        /* attack definitions, if defined will fire projectiles */
        string m_defSpecial1;
        float m_flSpecial1Range;
        string m_defSpecial2;
        float m_flSpecial2Range;
        string m_defRanged1;
        float m_flRanged1Range;
        string m_defRanged2;
        float m_flRanged2Range;
 
        /* ranged1 only */
        int m_iNumProjectiles;
        float m_flProjectileDelay;
        float m_flProjectileSpread;
 
        /* general */
        float m_flAttackCone;
        float m_flAttackAccuracy;
 
        /* melee attack */
        string m_defMelee;
        float m_flMeleeRange;
 
        string m_sndRangedAttack;
        float m_flReloadCount;
        float m_flReloadDelay;
        string m_sndReload;
        float m_flReserveAmmo;
 
        string m_sndRangedAttack2;
 
        bool m_bWeaponStartsDrawn;
        string m_strBodyOnDraw;
 
        float m_flWalkSpeed;
        float m_flRunSpeed;
 
        float m_flLeapDamage;
        bool m_bLeapAttacked;
        float m_flForceSequence;
        float m_flSkin;
        bool m_bGagged;
 
        nonvirtual void _LerpTurnToEnemy(void);
        nonvirtual void _LerpTurnToPos(vector);
        nonvirtual void _LerpTurnToYaw(vector);
        virtual void _Alerted(void);
        nonvirtual void _ChaseAfterSpawn(void);
#endif
};
 
#ifdef CLIENT
string Sentences_GetSamples(string);
string Sentences_ProcessSample(string);
#endif
 
#ifdef SERVER
void NSMonster_AlertEnemyAlliance(vector pos, float radius, int alliance);
entity NSMonster_FindClosestPlayer(entity);
#endif
 
.float baseframe2;
.float baseframe1time;
.float baseframe2time;
.float baselerpfrac;
.float bonecontrol1;
.float bonecontrol2;
.float bonecontrol3;
.float bonecontrol4;
.float bonecontrol5;
.float subblendfrac;
.float subblend2frac;
.float basesubblendfrac;
.float basesubblend2frac;