Monster.h

/*
 * 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_enable = true;
var bool autocvar_ai_debugLogic = false;
void
_ncMonster_Log(string className, string functionName, float edictNum, string warnMessage)
{
    if (autocvar_g_logTimestamps)
        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 ncMonsterLog(...) if (autocvar_ai_debugLogic == true) _ncMonster_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 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 ncMonster, but our current IsFriend()
 * check is currently only checking on a .takedamage basis. */
.int m_iAlliance;
 
class ncMonster:ncActor
{
public:
    void ncMonster(void);
 
#ifdef SERVER   
    /* overrides */
    virtual void DebugDraw(void);
    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(entity, entity, int, vector, vector, int);
    virtual void Death(entity, entity, int, vector, vector, int);
    virtual void Physics(void);
    virtual void Gib(int, vector);
    virtual void Sound(string);
    virtual void SpawnKey(string,string);
    virtual void HandleAnimEvent(float, int, string);
 
    virtual void OnMapFinishedLoading(void);
 
    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);
    nonvirtual void PerformAttack(string);
 
    virtual float MeleeMaxDistance(void);
 
    virtual bool MeleeCondition(void);
 
    nonvirtual bool IsValidEnemy(entity);
    virtual bool IsOnRoute(void);
    virtual void RouteClear(void);
 
    /* sequences */
    virtual void ScriptedSequenceEnded(void);
    virtual void ScriptedSequenceEnded_Moved(void);
    virtual void ScriptedSequenceEnded_Dead(void);
    virtual void RouteEnded(void);
    virtual void WalkRoute(void);
 
    /* callbacks */
    virtual void SeenPlayer(ncActor);
    virtual void SeenEnemy(ncActor);
    virtual void SeenFriend(ncActor);
    
    nonvirtual int GetSequenceState(void);
    nonvirtual bool InScriptedSequence(void);
 
    /* animation cycles */
    virtual int AnimIdle(void);
    virtual int AnimWalk(void);
    virtual int AnimRun(void);
    virtual void AnimPlay(float);
    virtual void AnimationUpdate(void);
    nonvirtual bool InForcedAnimation(void);
    nonvirtual void AnimationRewind(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);
    nonvirtual void AlertNearbyToSchedule(string scheduleType);
    nonvirtual void AlertNearbyClassWithMindset(string scheduleType);
    nonvirtual bool ShouldTurn(void);
#endif
 
    nonvirtual vector GetHeadAngles(void);
 
    virtual void DebugDraw(void);
 
#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
 
    NETWORKED_FLOAT(m_flHeadYaw)
    NETWORKED_FLOAT_N(subblendfrac)
    NETWORKED_FLOAT_N(bonecontrol1)
 
#ifdef SERVER
    entity m_eLookAt;
    entity m_ssLast;
    vector oldnet_velocity;
    float m_sentencePitch;
    int m_iFlags;
    vector base_mins;
    vector base_maxs;
    float base_health;
 
    /* I/O */
    string m_outputOnDamaged;
    string m_outputOnDeath;
    string m_outputOnHalfHealth;
    string m_outputOnHearPlayer;
    string m_outputOnFoundEnemy;
    string m_outputOnLostEnemy;
    string m_outputOnLostEnemyLOS;
    string m_outputOnFoundPlayer;
    string m_outputOnLostPlayer;
    string m_outputOnLostPlayerLOS;
    string m_outputOnDamagedByPlayer;
    string m_outputOnGreetPlayer;
    bool m_bMetPlayer;
 
    /* 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_modelEventTime;
 
    /* 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;
 
    NETWORKED_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;
    float m_flStopTime;
    float m_flyOffset;
    bool m_usesNav;
    bool m_fireFromHead;
    bool m_bCanAttack;
    bool m_freezeDuringPain;
    bool m_flinchDuringMovement;
 
    nonvirtual void _LerpTurnToPos(vector);
    nonvirtual void _LerpTurnToYaw(float);
    virtual void _Alerted(void);
    nonvirtual void _ChaseAfterSpawn(void);
#endif
};
 
#ifdef CLIENT
string Sentences_GetSamples(string);
string Sentences_ProcessSample(string);
#endif
 
#ifdef SERVER
void ncMonster_AlertEnemyAlliance(vector pos, float radius, int alliance);
entity ncMonster_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;