比較文本

尋找兩個文字檔案之間的差異

即時編輯器

隱藏空白變更

摺疊未變更行

關閉換行

檢視

比對精度

文字樣式

語法突出顯示

Diffchecker Desktop 執行Diffchecker最安全的方式。取得Diffchecker桌面應用程式：您的差異永遠不會離開您的電腦！取得桌面版

Untitled diff

建立於 9 年前差異永不過期

48 刪除

行
總計
刪除

字符
總計
刪除

要繼續使用此功能，請升級到 Diffchecker Pro 查看價格

550 行

58 新增

行
總計
新增

字符
總計
新增

要繼續使用此功能，請升級到 Diffchecker Pro 查看價格

561 行

// Purpose: Base combat character with no AI

// $NoKeywords: $

//=============================================================================//

#ifndef BASECOMBATCHARACTER_H

#define BASECOMBATCHARACTER_H

#include <limits.h>

#include "weapon_proficiency.h"

#ifdef _WIN32

#pragma once

#endif

#ifdef INVASION_DLL

#include "tf_shareddefs.h"

#define POWERUP_THINK_CONTEXT "PowerupThink"

#endif

#include "cbase.h"

#include "baseentity.h"

#include "baseflex.h"

#include "damagemodifier.h"

#include "utllinkedlist.h"

#include "ai_hull.h"

#include "ai_utils.h"

#include "physics_impact_damage.h"

// Bots

#include "soundent.h"

class CNavArea;

class CScriptedTarget;

typedef CHandle<CBaseCombatWeapon> CBaseCombatWeaponHandle;

// -------------------------------------

// Capability Bits

// -------------------------------------

enum Capability_t

{

bits_CAP_MOVE_GROUND = 0x00000001, // walk/run

bits_CAP_MOVE_JUMP = 0x00000002, // jump/leap

bits_CAP_MOVE_FLY = 0x00000004, // can fly, move all around

bits_CAP_MOVE_CLIMB = 0x00000008, // climb ladders

bits_CAP_MOVE_SWIM = 0x00000010, // navigate in water // UNDONE - not yet implemented

bits_CAP_MOVE_CRAWL = 0x00000020, // crawl // UNDONE - not yet implemented

bits_CAP_MOVE_SHOOT = 0x00000040, // tries to shoot weapon while moving

bits_CAP_SKIP_NAV_GROUND_CHECK = 0x00000080, // optimization - skips ground tests while computing navigation

bits_CAP_USE = 0x00000100, // open doors/push buttons/pull levers

//bits_CAP_HEAR = 0x00000200, // can hear forced sounds

bits_CAP_AUTO_DOORS = 0x00000400, // can trigger auto doors

bits_CAP_OPEN_DOORS = 0x00000800, // can open manual doors

bits_CAP_TURN_HEAD = 0x00001000, // can turn head, always bone controller 0

bits_CAP_WEAPON_RANGE_ATTACK1 = 0x00002000, // can do a weapon range attack 1

bits_CAP_WEAPON_RANGE_ATTACK2 = 0x00004000, // can do a weapon range attack 2

bits_CAP_WEAPON_MELEE_ATTACK1 = 0x00008000, // can do a weapon melee attack 1

bits_CAP_WEAPON_MELEE_ATTACK2 = 0x00010000, // can do a weapon melee attack 2

bits_CAP_INNATE_RANGE_ATTACK1 = 0x00020000, // can do a innate range attack 1

bits_CAP_INNATE_RANGE_ATTACK2 = 0x00040000, // can do a innate range attack 1

bits_CAP_INNATE_MELEE_ATTACK1 = 0x00080000, // can do a innate melee attack 1

bits_CAP_INNATE_MELEE_ATTACK2 = 0x00100000, // can do a innate melee attack 1

bits_CAP_USE_WEAPONS = 0x00200000, // can use weapons (non-innate attacks)

//bits_CAP_STRAFE = 0x00400000, // strafe ( walk/run sideways)

bits_CAP_ANIMATEDFACE = 0x00800000, // has animated eyes/face

bits_CAP_USE_SHOT_REGULATOR = 0x01000000, // Uses the shot regulator for range attack1

bits_CAP_FRIENDLY_DMG_IMMUNE = 0x02000000, // don't take damage from npc's that are D_LI

bits_CAP_SQUAD = 0x04000000, // can form squads

bits_CAP_DUCK = 0x08000000, // cover and reload ducking

bits_CAP_NO_HIT_PLAYER = 0x10000000, // don't hit players

bits_CAP_AIM_GUN = 0x20000000, // Use arms to aim gun, not just body

bits_CAP_NO_HIT_SQUADMATES = 0x40000000, // none

bits_CAP_SIMPLE_RADIUS_DAMAGE = 0x80000000, // Do not use robust radius damage model on this character.

};

#define bits_CAP_DOORS_GROUP (bits_CAP_AUTO_DOORS | bits_CAP_OPEN_DOORS)

#define bits_CAP_RANGE_ATTACK_GROUP (bits_CAP_WEAPON_RANGE_ATTACK1 | bits_CAP_WEAPON_RANGE_ATTACK2)

#define bits_CAP_MELEE_ATTACK_GROUP (bits_CAP_WEAPON_MELEE_ATTACK1 | bits_CAP_WEAPON_MELEE_ATTACK2)

class CBaseCombatWeapon;

#define BCC_DEFAULT_LOOK_TOWARDS_TOLERANCE 0.9f

enum Disposition_t

{

D_ER, // Undefined - error

D_HT, // Hate

D_FR, // Fear

D_LI, // Like

D_NU // Neutral

};

const int DEF_RELATIONSHIP_PRIORITY = INT_MIN;

struct Relationship_t

{

EHANDLE entity; // Relationship to a particular entity

Class_T classType; // Relationship to a class CLASS_NONE = not class based (Def. in baseentity.h)

Disposition_t disposition; // D_HT (Hate), D_FR (Fear), D_LI (Like), D_NT (Neutral)

int priority; // Relative importance of this relationship (higher numbers mean more important)

DECLARE_SIMPLE_DATADESC();

};

//-----------------------------------------------------------------------------

// Purpose: This should contain all of the combat entry points / functionality

// that are common between NPCs and players

//-----------------------------------------------------------------------------

class CBaseCombatCharacter : public CBaseFlex

{

DECLARE_CLASS( CBaseCombatCharacter, CBaseFlex );

public:

CBaseCombatCharacter(void);

~CBaseCombatCharacter(void);

DECLARE_SERVERCLASS();

DECLARE_DATADESC();

DECLARE_PREDICTABLE();

public:

//-----------------------------------------------------

// Senses

//-----------------------------------------------------

virtual void SetDistLook( float flDistLook ) { }

virtual bool QueryHearSound( CSound *pSound ) {

return true;

}

virtual bool QuerySeeEntity( CBaseEntity *pEntity, bool bOnlyHateOrFearIfNPC = false ) {

return true;

}

virtual void OnLooked( int iDistance ) { }

virtual void OnListened() { }

virtual void OnSeeEntity( CBaseEntity *pEntity ) { }

// If true, AI will try to see this entity regardless of distance.

virtual bool ShouldNotDistanceCull() {

return false;

}

virtual int GetSoundInterests( void ) {

return ALL_SOUNDS;

}

virtual int GetSoundPriority( CSound *pSound ) {

return 1;

}

CSound * GetLoudestSoundOfType( int iType ) {

return NULL;

}

virtual CSound * GetBestSound( int validTypes = ALL_SOUNDS ) {

return NULL;

}

virtual CSound * GetBestScent( void ) {

return NULL;

}

virtual float HearingSensitivity( void ) {

return 1.0;

}

virtual bool ShouldIgnoreSound( CSound * ) {

return false;

}

virtual bool SoundIsVisible( CSound *pSound ) {

return false;

}

virtual bool OnlySeeAliveEntities( void ) {

return true;

}

virtual void Spawn( void );

virtual void Precache();

virtual int Restore( IRestore &restore );

virtual const impactdamagetable_t &GetPhysicsImpactDamageTable( void );

int TakeHealth( float flHealth, int bitsDamageType );

void CauseDeath( const CTakeDamageInfo &info );

virtual bool FVisible ( CBaseEntity *pEntity, int traceMask = MASK_BLOCKLOS, CBaseEntity **ppBlocker = NULL ); // true iff the parameter can be seen by me.

virtual bool FVisible( const Vector &vecTarget, int traceMask = MASK_BLOCKLOS, CBaseEntity **ppBlocker = NULL ) { return BaseClass::FVisible( vecTarget, traceMask, ppBlocker ); }

static void ResetVisibilityCache( CBaseCombatCharacter *pBCC = NULL );

#ifdef PORTAL

virtual bool FVisibleThroughPortal( const CProp_Portal *pPortal, CBaseEntity *pEntity, int traceMask = MASK_BLOCKLOS, CBaseEntity **ppBlocker = NULL );

#endif

virtual bool FInViewCone( CBaseEntity *pEntity );

virtual bool FInViewCone( const Vector &vecSpot );

#ifdef PORTAL

virtual CProp_Portal* FInViewConeThroughPortal( CBaseEntity *pEntity );

virtual CProp_Portal* FInViewConeThroughPortal( const Vector &vecSpot );

#endif

virtual bool FInAimCone( CBaseEntity *pEntity );

virtual bool FInAimCone( const Vector &vecSpot );

virtual bool ShouldShootMissTarget( CBaseCombatCharacter *pAttacker );

virtual CBaseEntity *FindMissTarget( void );

// Do not call HandleInteraction directly, use DispatchInteraction

bool DispatchInteraction( int interactionType, void *data, CBaseCombatCharacter* sourceEnt ) { return ( interactionType > 0 ) ? HandleInteraction( interactionType, data, sourceEnt ) : false; }

virtual bool HandleInteraction( int interactionType, void *data, CBaseCombatCharacter* sourceEnt );

virtual QAngle BodyAngles();

virtual Vector BodyDirection2D( void );

virtual Vector BodyDirection3D( void );

virtual Vector HeadDirection2D( void ) { return BodyDirection2D( ); }; // No head motion so just return body dir

virtual Vector HeadDirection3D( void ) { return BodyDirection2D( ); }; // No head motion so just return body dir

virtual Vector EyeDirection2D( void ) { return HeadDirection2D( ); }; // No eye motion so just return head dir

virtual Vector EyeDirection3D( void ) { return HeadDirection3D( ); }; // No eye motion so just return head dir

virtual void SetTransmit( CCheckTransmitInfo *pInfo, bool bAlways );

// -----------------------

// Fog

// -----------------------

virtual bool IsHiddenByFog( const Vector &target ) const; ///< return true if given target cant be seen because of fog

virtual bool IsHiddenByFog( CBaseEntity *target ) const; ///< return true if given target cant be seen because of fog

virtual bool IsHiddenByFog( float range ) const; ///< return true if given distance is too far to see through the fog

virtual float GetFogObscuredRatio( const Vector &target ) const;///< return 0-1 ratio where zero is not obscured, and 1 is completely obscured

virtual float GetFogObscuredRatio( CBaseEntity *target ) const; ///< return 0-1 ratio where zero is not obscured, and 1 is completely obscured

virtual float GetFogObscuredRatio( float range ) const; ///< return 0-1 ratio where zero is not obscured, and 1 is completely obscured

// -----------------------

// Vision

// -----------------------

enum FieldOfViewCheckType { USE_FOV, DISREGARD_FOV };

// Visible starts with line of sight, and adds all the extra game checks like fog, smoke, camo...

bool IsAbleToSee( const CBaseEntity *entity, FieldOfViewCheckType checkFOV );

bool IsAbleToSee( CBaseCombatCharacter *pBCC, FieldOfViewCheckType checkFOV );

virtual bool IsLookingTowards( const Vector &target, float cosTolerance = BCC_DEFAULT_LOOK_TOWARDS_TOLERANCE ) const; // return true if our view direction is pointing at the given target, within the cosine of the angular tolerance. LINE OF SIGHT IS NOT CHECKED.

virtual bool IsInFieldOfView( CBaseEntity *entity ) const; // Calls IsLookingTowards with the current field of view.

virtual bool IsInFieldOfView( const Vector &pos ) const;

enum LineOfSightCheckType

{

IGNORE_NOTHING,

IGNORE_ACTORS

};

virtual bool IsLineOfSightClear( CBaseEntity *entity, LineOfSightCheckType checkType = IGNORE_NOTHING ) const;// strictly LOS check with no other considerations

virtual bool IsLineOfSightClear( const Vector &pos, LineOfSightCheckType checkType = IGNORE_NOTHING, CBaseEntity *entityToIgnore = NULL ) const;

// -----------------------

// Ammo

// -----------------------

virtual int GiveAmmo( int iCount, int iAmmoIndex, bool bSuppressSound = false );

int GiveAmmo( int iCount, const char *szName, bool bSuppressSound = false );

virtual void RemoveAmmo( int iCount, int iAmmoIndex );

virtual void RemoveAmmo( int iCount, const char *szName );

void RemoveAllAmmo( );

virtual int GetAmmoCount( int iAmmoIndex ) const;

int GetAmmoCount( char *szName ) const;

virtual Activity NPC_TranslateActivity( Activity baseAct );

// -----------------------

// Weapons

// -----------------------

CBaseCombatWeapon* Weapon_Create( const char *pWeaponName );

virtual Activity Weapon_TranslateActivity( Activity baseAct, bool *pRequired = NULL );

void Weapon_SetActivity( Activity newActivity, float duration );

virtual void Weapon_FrameUpdate( void );

virtual void Weapon_HandleAnimEvent( animevent_t *pEvent );

CBaseCombatWeapon* Weapon_OwnsThisType( const char *pszWeapon, int iSubType = 0 ) const; // True if already owns a weapon of this class

virtual bool Weapon_CanUse( CBaseCombatWeapon *pWeapon ); // True is allowed to use this class of weapon

virtual void Weapon_Equip( CBaseCombatWeapon *pWeapon ); // Adds weapon to player

virtual bool Weapon_EquipAmmoOnly( CBaseCombatWeapon *pWeapon ); // Adds weapon ammo to player, leaves weapon

bool Weapon_Detach( CBaseCombatWeapon *pWeapon ); // Clear any pointers to the weapon.

virtual void Weapon_Drop( CBaseCombatWeapon *pWeapon, const Vector *pvecTarget = NULL, const Vector *pVelocity = NULL );

virtual bool Weapon_Switch( CBaseCombatWeapon *pWeapon, int viewmodelindex = 0 ); // Switch to given weapon if has ammo (false if failed)

virtual Vector Weapon_ShootPosition( ); // gun position at current position/orientation

bool Weapon_IsOnGround( CBaseCombatWeapon *pWeapon );

CBaseEntity* Weapon_FindUsable( const Vector &range ); // search for a usable weapon in this range

virtual bool Weapon_CanSwitchTo(CBaseCombatWeapon *pWeapon);

virtual bool Weapon_SlotOccupied( CBaseCombatWeapon *pWeapon );

virtual CBaseCombatWeapon *Weapon_GetSlot( int slot ) const;

CBaseCombatWeapon *Weapon_GetWpnForAmmo( int iAmmoIndex );

// For weapon strip

void Weapon_DropAll( bool bDisallowWeaponPickup = false );

virtual bool AddPlayerItem( CBaseCombatWeapon *pItem ) { return false; }

virtual bool RemovePlayerItem( CBaseCombatWeapon *pItem ) { return false; }

virtual bool CanBecomeServerRagdoll( void ) { return true; }

// -----------------------

// Damage

// -----------------------

// Don't override this for characters, override the per-life-state versions below

virtual int OnTakeDamage( const CTakeDamageInfo &info );

// Override these to control how your character takes damage in different states

virtual int OnTakeDamage_Alive( const CTakeDamageInfo &info );

virtual int OnTakeDamage_Dying( const CTakeDamageInfo &info );

virtual int OnTakeDamage_Dead( const CTakeDamageInfo &info );

virtual float GetAliveDuration( void ) const; // return time we have been alive (only valid when alive)

virtual void OnFriendDamaged( CBaseCombatCharacter *pSquadmate, CBaseEntity *pAttacker ) {}

virtual void NotifyFriendsOfDamage( CBaseEntity *pAttackerEntity ) {}

virtual bool HasEverBeenInjured( int team = TEAM_ANY ) const; // return true if we have ever been injured by a member of the given team

virtual float GetTimeSinceLastInjury( int team = TEAM_ANY ) const; // return time since we were hurt by a member of the given team

virtual void OnPlayerKilledOther( CBaseEntity *pVictim, const CTakeDamageInfo &info ) {}

// utility function to calc damage force

Vector CalcDamageForceVector( const CTakeDamageInfo &info );

virtual int BloodColor();

virtual Activity GetDeathActivity( void );

virtual bool CorpseGib( const CTakeDamageInfo &info );

virtual void CorpseFade( void ); // Called instead of GibNPC() when gibs are disabled

virtual bool HasHumanGibs( void );

virtual bool HasAlienGibs( void );

virtual bool ShouldGib( const CTakeDamageInfo &info ) { return false; } // Always ragdoll, unless specified by the leaf class

float GetDamageAccumulator() { return m_flDamageAccumulator; }

int GetDamageCount( void ) { return m_iDamageCount; } // # of times NPC has been damaged. used for tracking 1-shot kills.

// Character killed (only fired once)

virtual void Event_Killed( const CTakeDamageInfo &info );

// Killed a character

void InputKilledNPC( inputdata_t &inputdata );

virtual void OnKilledNPC( CBaseCombatCharacter *pKilled ) {};

// Exactly one of these happens immediately after killed (gibbed may happen later when the corpse gibs)

// Character gibbed or faded out (violence controls) (only fired once)

// returns true if gibs were spawned

virtual bool Event_Gibbed( const CTakeDamageInfo &info );

// Character entered the dying state without being gibbed (only fired once)

virtual void Event_Dying( const CTakeDamageInfo &info );

virtual void Event_Dying();

// character died and should become a ragdoll now

// return true if converted to a ragdoll, false to use AI death

virtual bool BecomeRagdoll( const CTakeDamageInfo &info, const Vector &forceVector );

virtual void FixupBurningServerRagdoll( CBaseEntity *pRagdoll );

virtual bool BecomeRagdollBoogie( CBaseEntity *pKiller, const Vector &forceVector, float duration, int flags );

CBaseEntity *FindHealthItem( const Vector &vecPosition, const Vector &range );

virtual CBaseEntity *CheckTraceHullAttack( float flDist, const Vector &mins, const Vector &maxs, int iDamage, int iDmgType, float forceScale = 1.0f, bool bDamageAnyNPC = false );

virtual CBaseEntity *CheckTraceHullAttack( const Vector &vStart, const Vector &vEnd, const Vector &mins, const Vector &maxs, int iDamage, int iDmgType, float flForceScale = 1.0f, bool bDamageAnyNPC = false );

virtual CBaseCombatCharacter *MyCombatCharacterPointer( void ) { return this; }

// VPHYSICS

virtual void VPhysicsShadowCollision( int index, gamevcollisionevent_t *pEvent );

virtual void VPhysicsUpdate( IPhysicsObject *pPhysics );

float CalculatePhysicsStressDamage( vphysics_objectstress_t *pStressOut, IPhysicsObject *pPhysics );

void ApplyStressDamage( IPhysicsObject *pPhysics, bool bRequireLargeObject );

virtual void PushawayTouch( CBaseEntity *pOther ) {}

void SetImpactEnergyScale( float fScale ) { m_impactEnergyScale = fScale; }

virtual void UpdateOnRemove( void );

virtual Disposition_t IRelationType( CBaseEntity *pTarget );

virtual int IRelationPriority( CBaseEntity *pTarget );

virtual void SetLightingOriginRelative( CBaseEntity *pLightingOrigin );

protected:

Relationship_t *FindEntityRelationship( CBaseEntity *pTarget );

public:

// Vehicle queries

virtual bool IsInAVehicle( void ) const { return false; }

virtual IServerVehicle *GetVehicle( void ) { return NULL; }

virtual CBaseEntity *GetVehicleEntity( void ) { return NULL; }

virtual bool ExitVehicle( void ) { return false; }

// Blood color (see BLOOD_COLOR_* macros in baseentity.h)

void SetBloodColor( int nBloodColor );

// Weapons..

CBaseCombatWeapon* GetActiveWeapon() const;

int WeaponCount() const;

CBaseCombatWeapon* GetWeapon( int i ) const;

bool RemoveWeapon( CBaseCombatWeapon *pWeapon );

virtual void RemoveAllWeapons();

WeaponProficiency_t GetCurrentWeaponProficiency() { return m_CurrentWeaponProficiency; }

void SetCurrentWeaponProficiency( WeaponProficiency_t iProficiency ) { m_CurrentWeaponProficiency = iProficiency; }

virtual WeaponProficiency_t CalcWeaponProficiency( CBaseCombatWeapon *pWeapon );

virtual Vector GetAttackSpread( CBaseCombatWeapon *pWeapon, CBaseEntity *pTarget = NULL );

virtual float GetSpreadBias( CBaseCombatWeapon *pWeapon, CBaseEntity *pTarget );

virtual void DoMuzzleFlash();

// Interactions

static void InitInteractionSystem();

// Relationships

static void AllocateDefaultRelationships( );

static void SetDefaultRelationship( Class_T nClass, Class_T nClassTarget, Disposition_t nDisposition, int nPriority );

Disposition_t GetDefaultRelationshipDisposition( Class_T nClassTarget );

virtual void AddEntityRelationship( CBaseEntity *pEntity, Disposition_t nDisposition, int nPriority );

virtual bool RemoveEntityRelationship( CBaseEntity *pEntity );

virtual void AddClassRelationship( Class_T nClass, Disposition_t nDisposition, int nPriority );

virtual void ChangeTeam( int iTeamNum );

// Nav hull type

Hull_t GetHullType() const { return m_eHull; }

void SetHullType( Hull_t hullType ) { m_eHull = hullType; }

// FIXME: The following 3 methods are backdoor hack methods

// This is a sort of hack back-door only used by physgun!

void SetAmmoCount( int iCount, int iAmmoIndex );

// This is a hack to blat out the current active weapon...

// Used by weapon_slam + game_ui

void SetActiveWeapon( CBaseCombatWeapon *pNewWeapon );

void ClearActiveWeapon() { SetActiveWeapon( NULL ); }

virtual void OnChangeActiveWeapon( CBaseCombatWeapon *pOldWeapon, CBaseCombatWeapon *pNewWeapon ) {}

// I can't use my current weapon anymore. Switch me to the next best weapon.

bool SwitchToNextBestWeapon(CBaseCombatWeapon *pCurrent);

// This is a hack to copy the relationship strings used by monstermaker

void SetRelationshipString( string_t theString ) { m_RelationshipString = theString; }

float GetNextAttack() const { return m_flNextAttack; }

void SetNextAttack( float flWait ) { m_flNextAttack = flWait; }

bool m_bForceServerRagdoll;

// Pickup prevention

bool IsAllowedToPickupWeapons( void ) { return !m_bPreventWeaponPickup; }

void SetPreventWeaponPickup( bool bPrevent ) { m_bPreventWeaponPickup = bPrevent; }

bool m_bPreventWeaponPickup;

virtual CNavArea *GetLastKnownArea( void ) const { return m_lastNavArea; } // return the last nav area the player occupied - NULL if unknown

virtual bool IsAreaTraversable( const CNavArea *area ) const; // return true if we can use the given area

virtual void ClearLastKnownArea( void );

virtual void UpdateLastKnownArea( void ); // invoke this to update our last known nav area (since there is no think method chained to CBaseCombatCharacter)

virtual void OnNavAreaChanged( CNavArea *enteredArea, CNavArea *leftArea ) { } // invoked (by UpdateLastKnownArea) when we enter a new nav area (or it is reset to NULL)

virtual void OnNavAreaRemoved( CNavArea *removedArea );

// -----------------------

// Notification from INextBots.

// -----------------------

virtual void OnPursuedBy( INextBot * RESTRICT pPursuer ){} // called every frame while pursued by a bot in DirectChase.

#ifdef GLOWS_ENABLE

// Glows

void AddGlowEffect( void );

void RemoveGlowEffect( void );

bool IsGlowEffectActive( void );

#endif // GLOWS_ENABLE

#ifdef INVASION_DLL

public:

// TF2 Powerups

virtual bool CanBePoweredUp( void );

bool HasPowerup( int iPowerup );

virtual bool CanPowerupNow( int iPowerup ); // Return true if I can be powered by this powerup right now

virtual bool CanPowerupEver( int iPowerup ); // Return true if I ever accept this powerup type

void SetPowerup( int iPowerup, bool bState, float flTime = 0, float flAmount = 0, CBaseEntity *pAttacker = NULL, CDamageModifier *pDamageModifier = NULL );

virtual bool AttemptToPowerup( int iPowerup, float flTime, float flAmount = 0, CBaseEntity *pAttacker = NULL, CDamageModifier *pDamageModifier = NULL );

virtual float PowerupDuration( int iPowerup, float flTime );

virtual void PowerupStart( int iPowerup, float flAmount = 0, CBaseEntity *pAttacker = NULL, CDamageModifier *pDamageModifier = NULL );

virtual void PowerupEnd( int iPowerup );

void PowerupThink( void );

virtual void PowerupThink( int iPowerup );

public:

CNetworkVar( int, m_iPowerups );

float m_flPowerupAttemptTimes[ MAX_POWERUPS ];

float m_flPowerupEndTimes[ MAX_POWERUPS ];

float m_flFractionalBoost; // POWERUP_BOOST health fraction - specific powerup data

#endif

public:

// returns the last body region that took damage

int LastHitGroup() const { return m_LastHitGroup; }

protected:

void SetLastHitGroup( int nHitGroup ) { m_LastHitGroup = nHitGroup; }

public:

CNetworkVar( float, m_flNextAttack ); // cannot attack again until this time

#ifdef GLOWS_ENABLE

protected:

CNetworkVar( bool, m_bGlowEnabled );

#endif // GLOWS_ENABLE

private:

Hull_t m_eHull;

void UpdateGlowEffect( void );

void DestroyGlowEffect( void );

protected:

int m_bloodColor; // color of blood particless

// -------------------

// combat ability data

// -------------------

float m_flFieldOfView; // cosine of field of view for this character

Vector m_HackedGunPos; // HACK until we can query end of gun

string_t m_RelationshipString; // Used to load up relationship keyvalues

float m_impactEnergyScale;// scale the amount of energy used to calculate damage this ent takes due to physics

public:

static int GetInteractionID(); // Returns the next interaction #

protected:

// Visibility-related stuff

bool ComputeLOS( const Vector &vecEyePosition, const Vector &vecTarget ) const;

private:

// For weapon strip

void ThrowDirForWeaponStrip( CBaseCombatWeapon *pWeapon, const Vector &vecForward, Vector *pVecThrowDir );

void DropWeaponForWeaponStrip( CBaseCombatWeapon *pWeapon, const Vector &vecForward, const QAngle &vecAngles, float flDiameter );

friend class CScriptedTarget; // needs to access GetInteractionID()

static int m_lastInteraction; // Last registered interaction #

static Relationship_t** m_DefaultRelationship;

// attack/damage

int m_LastHitGroup; // the last body region that took damage

float m_flDamageAccumulator; // so very small amounts of damage do not get lost.

int m_iDamageCount; // # of times NPC has been damaged. used for tracking 1-shot kills.

// Weapon proficiency gets calculated each time an NPC changes his weapon, and then

// cached off as the CurrentWeaponProficiency.

// cached off as the CurrentWeaponPr

WeaponProficiency_t m_CurrentWeaponProficiency;

// ---------------

// Relationships

// ---------------

CUtlVector<Relationship_t> m_Relationship; // Array of relationships

protected:

// shared ammo slots

CNetworkArrayForDerived( int, m_iAmmo, MAX_AMMO_SLOTS );

// Usable character items

CNetworkArray( CBaseCombatWeaponHandle, m_hMyWeapons, MAX_WEAPONS );

CNetworkHandle( CBaseCombatWeapon, m_hActiveWeapon );

friend class CCleanupDefaultRelationShips;

IntervalTimer m_aliveTimer;

unsigned int m_hasBeenInjured; // bitfield corresponding to team ID that did the injury

// we do this because MAX_TEAMS is 32, which is wasteful for most games

enum { MAX_DAMAGE_TEAMS = 4 };

struct DamageHistory

{

int team; // which team hurt us (TEAM_INVALID means slot unused)

IntervalTimer interval; // how long has it been

};

DamageHistory m_damageHistory[ MAX_DAMAGE_TEAMS ];

// last known navigation area of player - NULL if unknown

CNavArea *m_lastNavArea;

CAI_MoveMonitor m_NavAreaUpdateMonitor;

int m_registeredNavTeam; // ugly, but needed to clean up player team counts in nav mesh

};

inline float CBaseCombatCharacter::GetAliveDuration( void ) const

{

return m_aliveTimer.GetElapsedTime();

}

//-----------------------------------------------------------------------------

// Purpose:

//-----------------------------------------------------------------------------

inline in

已保存差異

原始文本

開啟檔案

//========= Copyright Valve Corporation, All rights reserved. ============//
//
// Purpose: Base combat character with no AI
//
// $NoKeywords: $
//=============================================================================//

#ifndef BASECOMBATCHARACTER_H
#define BASECOMBATCHARACTER_H

#include <limits.h>
#include "weapon_proficiency.h"

#ifdef _WIN32
#pragma once
#endif

#ifdef INVASION_DLL
#include "tf_shareddefs.h"

#define POWERUP_THINK_CONTEXT	"PowerupThink"
#endif

#include "cbase.h"
#include "baseentity.h"
#include "baseflex.h"
#include "damagemodifier.h"
#include "utllinkedlist.h"
#include "ai_hull.h"
#include "ai_utils.h"
#include "physics_impact_damage.h"

class CNavArea;
class CScriptedTarget;
typedef CHandle<CBaseCombatWeapon> CBaseCombatWeaponHandle;

// -------------------------------------
//  Capability Bits
// -------------------------------------

enum Capability_t 
{
	bits_CAP_MOVE_GROUND			= 0x00000001, // walk/run
	bits_CAP_MOVE_JUMP				= 0x00000002, // jump/leap
	bits_CAP_MOVE_FLY				= 0x00000004, // can fly, move all around
	bits_CAP_MOVE_CLIMB				= 0x00000008, // climb ladders
	bits_CAP_MOVE_SWIM				= 0x00000010, // navigate in water			// UNDONE - not yet implemented
	bits_CAP_MOVE_CRAWL				= 0x00000020, // crawl						// UNDONE - not yet implemented
	bits_CAP_MOVE_SHOOT				= 0x00000040, // tries to shoot weapon while moving
	bits_CAP_SKIP_NAV_GROUND_CHECK	= 0x00000080, // optimization - skips ground tests while computing navigation
	bits_CAP_USE					= 0x00000100, // open doors/push buttons/pull levers
	//bits_CAP_HEAR					= 0x00000200, // can hear forced sounds
	bits_CAP_AUTO_DOORS				= 0x00000400, // can trigger auto doors
	bits_CAP_OPEN_DOORS				= 0x00000800, // can open manual doors
	bits_CAP_TURN_HEAD				= 0x00001000, // can turn head, always bone controller 0
	bits_CAP_WEAPON_RANGE_ATTACK1	= 0x00002000, // can do a weapon range attack 1
	bits_CAP_WEAPON_RANGE_ATTACK2	= 0x00004000, // can do a weapon range attack 2
	bits_CAP_WEAPON_MELEE_ATTACK1	= 0x00008000, // can do a weapon melee attack 1
	bits_CAP_WEAPON_MELEE_ATTACK2	= 0x00010000, // can do a weapon melee attack 2
	bits_CAP_INNATE_RANGE_ATTACK1	= 0x00020000, // can do a innate range attack 1
	bits_CAP_INNATE_RANGE_ATTACK2	= 0x00040000, // can do a innate range attack 1
	bits_CAP_INNATE_MELEE_ATTACK1	= 0x00080000, // can do a innate melee attack 1
	bits_CAP_INNATE_MELEE_ATTACK2	= 0x00100000, // can do a innate melee attack 1
	bits_CAP_USE_WEAPONS			= 0x00200000, // can use weapons (non-innate attacks)
	//bits_CAP_STRAFE					= 0x00400000, // strafe ( walk/run sideways)
	bits_CAP_ANIMATEDFACE			= 0x00800000, // has animated eyes/face
	bits_CAP_USE_SHOT_REGULATOR		= 0x01000000, // Uses the shot regulator for range attack1
	bits_CAP_FRIENDLY_DMG_IMMUNE	= 0x02000000, // don't take damage from npc's that are D_LI
	bits_CAP_SQUAD					= 0x04000000, // can form squads
	bits_CAP_DUCK					= 0x08000000, // cover and reload ducking
	bits_CAP_NO_HIT_PLAYER			= 0x10000000, // don't hit players
	bits_CAP_AIM_GUN				= 0x20000000, // Use arms to aim gun, not just body
	bits_CAP_NO_HIT_SQUADMATES		= 0x40000000, // none
	bits_CAP_SIMPLE_RADIUS_DAMAGE	= 0x80000000, // Do not use robust radius damage model on this character.
};

#define bits_CAP_DOORS_GROUP    (bits_CAP_AUTO_DOORS | bits_CAP_OPEN_DOORS)
#define bits_CAP_RANGE_ATTACK_GROUP	(bits_CAP_WEAPON_RANGE_ATTACK1 | bits_CAP_WEAPON_RANGE_ATTACK2)
#define bits_CAP_MELEE_ATTACK_GROUP	(bits_CAP_WEAPON_MELEE_ATTACK1 | bits_CAP_WEAPON_MELEE_ATTACK2)

class CBaseCombatWeapon;

#define BCC_DEFAULT_LOOK_TOWARDS_TOLERANCE 0.9f

enum Disposition_t 
{
	D_ER,		// Undefined - error
	D_HT,		// Hate
	D_FR,		// Fear
	D_LI,		// Like
	D_NU		// Neutral
};

const int DEF_RELATIONSHIP_PRIORITY = INT_MIN;

struct Relationship_t
{
	EHANDLE			entity;			// Relationship to a particular entity
	Class_T			classType;		// Relationship to a class  CLASS_NONE = not class based (Def. in baseentity.h)
	Disposition_t	disposition;	// D_HT (Hate), D_FR (Fear), D_LI (Like), D_NT (Neutral)
	int				priority;		// Relative importance of this relationship (higher numbers mean more important)

DECLARE_SIMPLE_DATADESC();
};

//-----------------------------------------------------------------------------
// Purpose: This should contain all of the combat entry points / functionality 
// that are common between NPCs and players
//-----------------------------------------------------------------------------
class CBaseCombatCharacter : public CBaseFlex
{
	DECLARE_CLASS( CBaseCombatCharacter, CBaseFlex );

public:
	CBaseCombatCharacter(void);
	~CBaseCombatCharacter(void);

DECLARE_SERVERCLASS();
	DECLARE_DATADESC();
	DECLARE_PREDICTABLE();

public:

virtual void		Spawn( void );
	virtual void		Precache();

virtual int			Restore( IRestore &restore );

virtual const impactdamagetable_t	&GetPhysicsImpactDamageTable( void );

int					TakeHealth( float flHealth, int bitsDamageType );
	void				CauseDeath( const CTakeDamageInfo &info );

virtual	bool		FVisible ( CBaseEntity *pEntity, int traceMask = MASK_BLOCKLOS, CBaseEntity **ppBlocker = NULL ); // true iff the parameter can be seen by me.
	virtual bool		FVisible( const Vector &vecTarget, int traceMask = MASK_BLOCKLOS, CBaseEntity **ppBlocker = NULL )	{ return BaseClass::FVisible( vecTarget, traceMask, ppBlocker ); }
	static void			ResetVisibilityCache( CBaseCombatCharacter *pBCC = NULL );

#ifdef PORTAL
	virtual	bool		FVisibleThroughPortal( const CProp_Portal *pPortal, CBaseEntity *pEntity, int traceMask = MASK_BLOCKLOS, CBaseEntity **ppBlocker = NULL );
#endif

virtual bool		FInViewCone( CBaseEntity *pEntity );
	virtual bool		FInViewCone( const Vector &vecSpot );

#ifdef PORTAL
	virtual CProp_Portal*	FInViewConeThroughPortal( CBaseEntity *pEntity );
	virtual CProp_Portal*	FInViewConeThroughPortal( const Vector &vecSpot );
#endif

virtual bool		FInAimCone( CBaseEntity *pEntity );
	virtual bool		FInAimCone( const Vector &vecSpot );
	
	virtual bool		ShouldShootMissTarget( CBaseCombatCharacter *pAttacker );
	virtual CBaseEntity *FindMissTarget( void );

// Do not call HandleInteraction directly, use DispatchInteraction
	bool				DispatchInteraction( int interactionType, void *data, CBaseCombatCharacter* sourceEnt )	{ return ( interactionType > 0 ) ? HandleInteraction( interactionType, data, sourceEnt ) : false; }
	virtual bool		HandleInteraction( int interactionType, void *data, CBaseCombatCharacter* sourceEnt );

virtual QAngle		BodyAngles();
	virtual Vector		BodyDirection2D( void );
	virtual Vector		BodyDirection3D( void );
	virtual Vector		HeadDirection2D( void )	{ return BodyDirection2D( ); }; // No head motion so just return body dir
	virtual Vector		HeadDirection3D( void )	{ return BodyDirection2D( ); }; // No head motion so just return body dir
	virtual Vector		EyeDirection2D( void ) 	{ return HeadDirection2D( );  }; // No eye motion so just return head dir
	virtual Vector		EyeDirection3D( void ) 	{ return HeadDirection3D( );  }; // No eye motion so just return head dir

virtual void SetTransmit( CCheckTransmitInfo *pInfo, bool bAlways );

// -----------------------
	// Fog
	// -----------------------
	virtual bool		IsHiddenByFog( const Vector &target ) const;	///< return true if given target cant be seen because of fog
	virtual bool		IsHiddenByFog( CBaseEntity *target ) const;		///< return true if given target cant be seen because of fog
	virtual bool		IsHiddenByFog( float range ) const;				///< return true if given distance is too far to see through the fog
	virtual float		GetFogObscuredRatio( const Vector &target ) const;///< return 0-1 ratio where zero is not obscured, and 1 is completely obscured
	virtual float		GetFogObscuredRatio( CBaseEntity *target ) const;	///< return 0-1 ratio where zero is not obscured, and 1 is completely obscured
	virtual float		GetFogObscuredRatio( float range ) const;		///< return 0-1 ratio where zero is not obscured, and 1 is completely obscured

// -----------------------
	// Vision
	// -----------------------
	enum FieldOfViewCheckType { USE_FOV, DISREGARD_FOV };

// Visible starts with line of sight, and adds all the extra game checks like fog, smoke, camo...
	bool IsAbleToSee( const CBaseEntity *entity, FieldOfViewCheckType checkFOV );
	bool IsAbleToSee( CBaseCombatCharacter *pBCC, FieldOfViewCheckType checkFOV );

virtual bool IsLookingTowards( const CBaseEntity *target, float cosTolerance = BCC_DEFAULT_LOOK_TOWARDS_TOLERANCE ) const;	// return true if our view direction is pointing at the given target, within the cosine of the angular tolerance. LINE OF SIGHT IS NOT CHECKED.
	virtual bool IsLookingTowards( const Vector &target, float cosTolerance = BCC_DEFAULT_LOOK_TOWARDS_TOLERANCE ) const;	// return true if our view direction is pointing at the given target, within the cosine of the angular tolerance. LINE OF SIGHT IS NOT CHECKED.

virtual bool IsInFieldOfView( CBaseEntity *entity ) const;	// Calls IsLookingTowards with the current field of view.  
	virtual bool IsInFieldOfView( const Vector &pos ) const;

enum LineOfSightCheckType
	{
		IGNORE_NOTHING,
		IGNORE_ACTORS
	};
	virtual bool IsLineOfSightClear( CBaseEntity *entity, LineOfSightCheckType checkType = IGNORE_NOTHING ) const;// strictly LOS check with no other considerations
	virtual bool IsLineOfSightClear( const Vector &pos, LineOfSightCheckType checkType = IGNORE_NOTHING, CBaseEntity *entityToIgnore = NULL ) const;

// -----------------------
	// Ammo
	// -----------------------
	virtual int			GiveAmmo( int iCount, int iAmmoIndex, bool bSuppressSound = false );
	int					GiveAmmo( int iCount, const char *szName, bool bSuppressSound = false );
	virtual void		RemoveAmmo( int iCount, int iAmmoIndex );
	virtual void		RemoveAmmo( int iCount, const char *szName );
	void				RemoveAllAmmo( );
	virtual int			GetAmmoCount( int iAmmoIndex ) const;
	int					GetAmmoCount( char *szName ) const;

virtual Activity	NPC_TranslateActivity( Activity baseAct );

// -----------------------
	// Weapons
	// -----------------------
	CBaseCombatWeapon*	Weapon_Create( const char *pWeaponName );
	virtual Activity	Weapon_TranslateActivity( Activity baseAct, bool *pRequired = NULL );
	void				Weapon_SetActivity( Activity newActivity, float duration );
	virtual void		Weapon_FrameUpdate( void );
	virtual void		Weapon_HandleAnimEvent( animevent_t *pEvent );
	CBaseCombatWeapon*	Weapon_OwnsThisType( const char *pszWeapon, int iSubType = 0 ) const;  // True if already owns a weapon of this class
	virtual bool		Weapon_CanUse( CBaseCombatWeapon *pWeapon );		// True is allowed to use this class of weapon
	virtual void		Weapon_Equip( CBaseCombatWeapon *pWeapon );			// Adds weapon to player
	virtual bool		Weapon_EquipAmmoOnly( CBaseCombatWeapon *pWeapon );	// Adds weapon ammo to player, leaves weapon
	bool				Weapon_Detach( CBaseCombatWeapon *pWeapon );		// Clear any pointers to the weapon.
	virtual void		Weapon_Drop( CBaseCombatWeapon *pWeapon, const Vector *pvecTarget = NULL, const Vector *pVelocity = NULL );
	virtual	bool		Weapon_Switch( CBaseCombatWeapon *pWeapon, int viewmodelindex = 0 );		// Switch to given weapon if has ammo (false if failed)
	virtual	Vector		Weapon_ShootPosition( );		// gun position at current position/orientation
	bool				Weapon_IsOnGround( CBaseCombatWeapon *pWeapon );
	CBaseEntity*		Weapon_FindUsable( const Vector &range );			// search for a usable weapon in this range
	virtual	bool		Weapon_CanSwitchTo(CBaseCombatWeapon *pWeapon);
	virtual bool		Weapon_SlotOccupied( CBaseCombatWeapon *pWeapon );
	virtual CBaseCombatWeapon *Weapon_GetSlot( int slot ) const;
	CBaseCombatWeapon	*Weapon_GetWpnForAmmo( int iAmmoIndex );

// For weapon strip
	void				Weapon_DropAll( bool bDisallowWeaponPickup = false );

virtual bool			AddPlayerItem( CBaseCombatWeapon *pItem ) { return false; }
	virtual bool			RemovePlayerItem( CBaseCombatWeapon *pItem ) { return false; }

virtual bool			CanBecomeServerRagdoll( void ) { return true; }

// -----------------------
	// Damage
	// -----------------------
	// Don't override this for characters, override the per-life-state versions below
	virtual int				OnTakeDamage( const CTakeDamageInfo &info );

// Override these to control how your character takes damage in different states
	virtual int				OnTakeDamage_Alive( const CTakeDamageInfo &info );
	virtual int				OnTakeDamage_Dying( const CTakeDamageInfo &info );
	virtual int				OnTakeDamage_Dead( const CTakeDamageInfo &info );

virtual float			GetAliveDuration( void ) const;			// return time we have been alive (only valid when alive)

virtual void 			OnFriendDamaged( CBaseCombatCharacter *pSquadmate, CBaseEntity *pAttacker ) {}
	virtual void 			NotifyFriendsOfDamage( CBaseEntity *pAttackerEntity ) {}
	virtual bool			HasEverBeenInjured( int team = TEAM_ANY ) const;			// return true if we have ever been injured by a member of the given team
	virtual float			GetTimeSinceLastInjury( int team = TEAM_ANY ) const;		// return time since we were hurt by a member of the given team

virtual void			OnPlayerKilledOther( CBaseEntity *pVictim, const CTakeDamageInfo &info ) {}

// utility function to calc damage force
	Vector					CalcDamageForceVector( const CTakeDamageInfo &info );

virtual int				BloodColor();
	virtual Activity		GetDeathActivity( void );

virtual bool			CorpseGib( const CTakeDamageInfo &info );
	virtual void			CorpseFade( void );	// Called instead of GibNPC() when gibs are disabled
	virtual bool			HasHumanGibs( void );
	virtual bool			HasAlienGibs( void );
	virtual bool			ShouldGib( const CTakeDamageInfo &info ) { return false; }	// Always ragdoll, unless specified by the leaf class

float GetDamageAccumulator() { return m_flDamageAccumulator; }
	int	  GetDamageCount( void ) { return m_iDamageCount; }	// # of times NPC has been damaged.  used for tracking 1-shot kills.

// Character killed (only fired once)
	virtual void			Event_Killed( const CTakeDamageInfo &info );

// Killed a character
	void InputKilledNPC( inputdata_t &inputdata );
	virtual void OnKilledNPC( CBaseCombatCharacter *pKilled ) {};

// Exactly one of these happens immediately after killed (gibbed may happen later when the corpse gibs)
	// Character gibbed or faded out (violence controls) (only fired once)
	// returns true if gibs were spawned
	virtual bool			Event_Gibbed( const CTakeDamageInfo &info );
	// Character entered the dying state without being gibbed (only fired once)
	virtual void			Event_Dying( const CTakeDamageInfo &info );
	virtual void			Event_Dying();
	// character died and should become a ragdoll now
	// return true if converted to a ragdoll, false to use AI death
	virtual bool			BecomeRagdoll( const CTakeDamageInfo &info, const Vector &forceVector );
	virtual void			FixupBurningServerRagdoll( CBaseEntity *pRagdoll );

virtual bool			BecomeRagdollBoogie( CBaseEntity *pKiller, const Vector &forceVector, float duration, int flags );

CBaseEntity				*FindHealthItem( const Vector &vecPosition, const Vector &range );

virtual CBaseEntity		*CheckTraceHullAttack( float flDist, const Vector &mins, const Vector &maxs, int iDamage, int iDmgType, float forceScale = 1.0f, bool bDamageAnyNPC = false );
	virtual CBaseEntity		*CheckTraceHullAttack( const Vector &vStart, const Vector &vEnd, const Vector &mins, const Vector &maxs, int iDamage, int iDmgType, float flForceScale = 1.0f, bool bDamageAnyNPC = false );

virtual CBaseCombatCharacter *MyCombatCharacterPointer( void ) { return this; }

// VPHYSICS
	virtual void			VPhysicsShadowCollision( int index, gamevcollisionevent_t *pEvent );
	virtual void			VPhysicsUpdate( IPhysicsObject *pPhysics );
	float					CalculatePhysicsStressDamage( vphysics_objectstress_t *pStressOut, IPhysicsObject *pPhysics );
	void					ApplyStressDamage( IPhysicsObject *pPhysics, bool bRequireLargeObject );

virtual void			PushawayTouch( CBaseEntity *pOther ) {}

void SetImpactEnergyScale( float fScale ) { m_impactEnergyScale = fScale; }

virtual void			UpdateOnRemove( void );

virtual Disposition_t	IRelationType( CBaseEntity *pTarget );
	virtual int				IRelationPriority( CBaseEntity *pTarget );

virtual void			SetLightingOriginRelative( CBaseEntity *pLightingOrigin );

protected:
	Relationship_t			*FindEntityRelationship( CBaseEntity *pTarget );

public:
	
	// Vehicle queries
	virtual bool IsInAVehicle( void ) const { return false; }
	virtual IServerVehicle *GetVehicle( void ) { return NULL; }
	virtual CBaseEntity *GetVehicleEntity( void ) { return NULL; }
	virtual bool ExitVehicle( void ) { return false; }

// Blood color (see BLOOD_COLOR_* macros in baseentity.h)
	void SetBloodColor( int nBloodColor );

// Weapons..
	CBaseCombatWeapon*	GetActiveWeapon() const;
	int					WeaponCount() const;
	CBaseCombatWeapon*	GetWeapon( int i ) const;
	bool				RemoveWeapon( CBaseCombatWeapon *pWeapon );
	virtual void		RemoveAllWeapons();
	WeaponProficiency_t GetCurrentWeaponProficiency() { return m_CurrentWeaponProficiency; }
	void				SetCurrentWeaponProficiency( WeaponProficiency_t iProficiency ) { m_CurrentWeaponProficiency = iProficiency; }
	virtual WeaponProficiency_t CalcWeaponProficiency( CBaseCombatWeapon *pWeapon );
	virtual	Vector		GetAttackSpread( CBaseCombatWeapon *pWeapon, CBaseEntity *pTarget = NULL );
	virtual	float		GetSpreadBias(  CBaseCombatWeapon *pWeapon, CBaseEntity *pTarget );
	virtual void		DoMuzzleFlash();

// Interactions
	static void			InitInteractionSystem();

// Relationships
	static void			AllocateDefaultRelationships( );
	static void			SetDefaultRelationship( Class_T nClass, Class_T nClassTarget,  Disposition_t nDisposition, int nPriority );
	Disposition_t		GetDefaultRelationshipDisposition( Class_T nClassTarget );
	virtual void		AddEntityRelationship( CBaseEntity *pEntity, Disposition_t nDisposition, int nPriority );
	virtual bool		RemoveEntityRelationship( CBaseEntity *pEntity );
	virtual void		AddClassRelationship( Class_T nClass, Disposition_t nDisposition, int nPriority );

virtual void		ChangeTeam( int iTeamNum );

// Nav hull type
	Hull_t	GetHullType() const				{ return m_eHull; }
	void	SetHullType( Hull_t hullType )	{ m_eHull = hullType; }

// FIXME: The following 3 methods are backdoor hack methods
	
	// This is a sort of hack back-door only used by physgun!
	void SetAmmoCount( int iCount, int iAmmoIndex );

// This is a hack to blat out the current active weapon...
	// Used by weapon_slam + game_ui
	void SetActiveWeapon( CBaseCombatWeapon *pNewWeapon );
	void ClearActiveWeapon() { SetActiveWeapon( NULL ); }
	virtual void OnChangeActiveWeapon( CBaseCombatWeapon *pOldWeapon, CBaseCombatWeapon *pNewWeapon ) {}

// I can't use my current weapon anymore. Switch me to the next best weapon.
	bool SwitchToNextBestWeapon(CBaseCombatWeapon *pCurrent);

// This is a hack to copy the relationship strings used by monstermaker
	void SetRelationshipString( string_t theString ) { m_RelationshipString = theString; }

float				GetNextAttack() const { return m_flNextAttack; }
	void				SetNextAttack( float flWait ) { m_flNextAttack = flWait; }

bool				m_bForceServerRagdoll;

// Pickup prevention
	bool				IsAllowedToPickupWeapons( void ) { return !m_bPreventWeaponPickup; }
	void				SetPreventWeaponPickup( bool bPrevent ) { m_bPreventWeaponPickup = bPrevent; }
	bool				m_bPreventWeaponPickup;

virtual CNavArea *GetLastKnownArea( void ) const		{ return m_lastNavArea; }		// return the last nav area the player occupied - NULL if unknown
	virtual bool IsAreaTraversable( const CNavArea *area ) const;							// return true if we can use the given area 
	virtual void ClearLastKnownArea( void );
	virtual void UpdateLastKnownArea( void );										// invoke this to update our last known nav area (since there is no think method chained to CBaseCombatCharacter)
	virtual void OnNavAreaChanged( CNavArea *enteredArea, CNavArea *leftArea ) { }	// invoked (by UpdateLastKnownArea) when we enter a new nav area (or it is reset to NULL)
	virtual void OnNavAreaRemoved( CNavArea *removedArea );

// -----------------------
	// Notification from INextBots.
	// -----------------------
	virtual void		OnPursuedBy( INextBot * RESTRICT pPursuer ){} // called every frame while pursued by a bot in DirectChase.

#ifdef GLOWS_ENABLE
	// Glows
	void				AddGlowEffect( void );
	void				RemoveGlowEffect( void );
	bool				IsGlowEffectActive( void );
#endif // GLOWS_ENABLE

#ifdef INVASION_DLL
public:

// TF2 Powerups
	virtual bool		CanBePoweredUp( void );
	bool				HasPowerup( int iPowerup );
	virtual	bool		CanPowerupNow( int iPowerup );		// Return true if I can be powered by this powerup right now
	virtual	bool		CanPowerupEver( int iPowerup );		// Return true if I ever accept this powerup type

void				SetPowerup( int iPowerup, bool bState, float flTime = 0, float flAmount = 0, CBaseEntity *pAttacker = NULL, CDamageModifier *pDamageModifier = NULL );
	virtual	bool		AttemptToPowerup( int iPowerup, float flTime, float flAmount = 0, CBaseEntity *pAttacker = NULL, CDamageModifier *pDamageModifier = NULL );
	virtual	float		PowerupDuration( int iPowerup, float flTime );
	virtual	void		PowerupStart( int iPowerup, float flAmount = 0, CBaseEntity *pAttacker = NULL, CDamageModifier *pDamageModifier = NULL );
	virtual	void		PowerupEnd( int iPowerup );

void				PowerupThink( void );
	virtual	void		PowerupThink( int iPowerup );

public:

CNetworkVar( int, m_iPowerups );
	float				m_flPowerupAttemptTimes[ MAX_POWERUPS ];
	float				m_flPowerupEndTimes[ MAX_POWERUPS ];
	float				m_flFractionalBoost;	// POWERUP_BOOST health fraction - specific powerup data

#endif

public:
	// returns the last body region that took damage
	int	LastHitGroup() const				{ return m_LastHitGroup; }
protected:
	void SetLastHitGroup( int nHitGroup )	{ m_LastHitGroup = nHitGroup; }

public:
	CNetworkVar( float, m_flNextAttack );			// cannot attack again until this time

#ifdef GLOWS_ENABLE
protected:
	CNetworkVar( bool, m_bGlowEnabled );
#endif // GLOWS_ENABLE

private:
	Hull_t		m_eHull;

void				UpdateGlowEffect( void );
	void				DestroyGlowEffect( void );

protected:
	int			m_bloodColor;			// color of blood particless

// -------------------
	// combat ability data
	// -------------------
	float		m_flFieldOfView;		// cosine of field of view for this character
	Vector		m_HackedGunPos;			// HACK until we can query end of gun
	string_t	m_RelationshipString;	// Used to load up relationship keyvalues
	float		m_impactEnergyScale;// scale the amount of energy used to calculate damage this ent takes due to physics

public:
	static int					GetInteractionID();	// Returns the next interaction #

protected:
	// Visibility-related stuff
	bool ComputeLOS( const Vector &vecEyePosition, const Vector &vecTarget ) const;
private:
	// For weapon strip
	void ThrowDirForWeaponStrip( CBaseCombatWeapon *pWeapon, const Vector &vecForward, Vector *pVecThrowDir );
	void DropWeaponForWeaponStrip( CBaseCombatWeapon *pWeapon, const Vector &vecForward, const QAngle &vecAngles, float flDiameter );

friend class CScriptedTarget; // needs to access GetInteractionID()
	
	static int					m_lastInteraction;	// Last registered interaction #
	static Relationship_t**		m_DefaultRelationship;

// attack/damage
	int					m_LastHitGroup;			// the last body region that took damage
	float				m_flDamageAccumulator;	// so very small amounts of damage do not get lost.
	int					m_iDamageCount;			// # of times NPC has been damaged.  used for tracking 1-shot kills.
	
	// Weapon proficiency gets calculated each time an NPC changes his weapon, and then
	// cached off as the CurrentWeaponProficiency.
	WeaponProficiency_t m_CurrentWeaponProficiency;

// ---------------
	//  Relationships
	// ---------------
	CUtlVector<Relationship_t>		m_Relationship;						// Array of relationships

protected:
	// shared ammo slots
	CNetworkArrayForDerived( int, m_iAmmo, MAX_AMMO_SLOTS );

// Usable character items 
	CNetworkArray( CBaseCombatWeaponHandle, m_hMyWeapons, MAX_WEAPONS );

CNetworkHandle( CBaseCombatWeapon, m_hActiveWeapon );

friend class CCleanupDefaultRelationShips;
	
	IntervalTimer m_aliveTimer;

unsigned int m_hasBeenInjured;							// bitfield corresponding to team ID that did the injury

// we do this because MAX_TEAMS is 32, which is wasteful for most games
	enum { MAX_DAMAGE_TEAMS = 4 };
	struct DamageHistory
	{
		int team;					// which team hurt us (TEAM_INVALID means slot unused)
		IntervalTimer interval;		// how long has it been
	};
	DamageHistory m_damageHistory[ MAX_DAMAGE_TEAMS ];

// last known navigation area of player - NULL if unknown
	CNavArea *m_lastNavArea;
	CAI_MoveMonitor m_NavAreaUpdateMonitor;
	int m_registeredNavTeam;	// ugly, but needed to clean up player team counts in nav mesh
};

inline float CBaseCombatCharacter::GetAliveDuration( void ) const
{
	return m_aliveTimer.GetElapsedTime();
}

//-----------------------------------------------------------------------------
// Purpose: 
// Input  : i - 
//-----------------------------------------------------------------------------
inline CBaseCombatWeapon *CBaseCombatCharacter::GetWeapon( int i ) const
{
	Assert( (i >= 0) && (i < MAX_WEAPONS) );
	return m_hMyWeapons[i].Get();
}

#ifdef INVASION_DLL
// Powerup Inlines
inline bool CBaseCombatCharacter::CanBePoweredUp( void )							{ return true; }
inline float CBaseCombatCharacter::PowerupDuration( int iPowerup, float flTime )	{ return flTime; }
inline void	CBaseCombatCharacter::PowerupEnd( int iPowerup )						{ return; }
inline void	CBaseCombatCharacter::PowerupThink( int iPowerup )						{ return; }
#endif

EXTERN_SEND_TABLE(DT_BaseCombatCharacter);

void RadiusDamage( const CTakeDamageInfo &info, const Vector &vecSrc, float flRadius, int iClassIgnore, CBaseEntity *pEntityIgnore );

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
class CTraceFilterMelee : public CTraceFilterEntitiesOnly
{
public:
	// It does have a base, but we'll never network anything below here..
	DECLARE_CLASS_NOBASE( CTraceFilterMelee );
	
	CTraceFilterMelee( const IHandleEntity *passentity, int collisionGroup, CTakeDamageInfo *dmgInfo, float flForceScale, bool bDamageAnyNPC )
		: m_pPassEnt(passentity), m_collisionGroup(collisionGroup), m_dmgInfo(dmgInfo), m_pHit(NULL), m_flForceScale(flForceScale), m_bDamageAnyNPC(bDamageAnyNPC)
	{
	}
	
	virtual bool ShouldHitEntity( IHandleEntity *pHandleEntity, int contentsMask );

public:
	const IHandleEntity *m_pPassEnt;
	int					m_collisionGroup;
	CTakeDamageInfo		*m_dmgInfo;
	CBaseEntity			*m_pHit;
	float				m_flForceScale;
	bool				m_bDamageAnyNPC;
};

#endif // BASECOMBATCHARACTER_H

更改後文本

開啟檔案

#ifndef BASECOMBATCHARACTER_H
#define BASECOMBATCHARACTER_H

#include <limits.h>
#include "weapon_proficiency.h"

#ifdef _WIN32
#pragma once
#endif

#ifdef INVASION_DLL
#include "tf_shareddefs.h"

#define POWERUP_THINK_CONTEXT	"PowerupThink"
#endif

#include "cbase.h"
#include "baseentity.h"
#include "baseflex.h"
#include "damagemodifier.h"
#include "utllinkedlist.h"
#include "ai_hull.h"
#include "ai_utils.h"
#include "physics_impact_damage.h"

// Bots
#include "soundent.h"

class CNavArea;
class CScriptedTarget;
typedef CHandle<CBaseCombatWeapon> CBaseCombatWeaponHandle;

// -------------------------------------
//  Capability Bits
// -------------------------------------

class CBaseCombatWeapon;

#define BCC_DEFAULT_LOOK_TOWARDS_TOLERANCE 0.9f

enum Disposition_t 
{
	D_ER,		// Undefined - error
	D_HT,		// Hate
	D_FR,		// Fear
	D_LI,		// Like
	D_NU		// Neutral
};

const int DEF_RELATIONSHIP_PRIORITY = INT_MIN;

DECLARE_SIMPLE_DATADESC();
};

public:
	CBaseCombatCharacter(void);
	~CBaseCombatCharacter(void);

DECLARE_SERVERCLASS();
	DECLARE_DATADESC();
	DECLARE_PREDICTABLE();

public:
    //-----------------------------------------------------
    //
    // Senses
    //
    //-----------------------------------------------------

virtual void		SetDistLook( float flDistLook ) { }

virtual bool		QueryHearSound( CSound *pSound ) {
        return true;
    }

virtual bool		QuerySeeEntity( CBaseEntity *pEntity, bool bOnlyHateOrFearIfNPC = false ) {
        return true;
    }

virtual void		OnLooked( int iDistance ) { }
    virtual void		OnListened() { }

virtual void		OnSeeEntity( CBaseEntity *pEntity ) { }

// If true, AI will try to see this entity regardless of distance.
    virtual bool		ShouldNotDistanceCull() {
        return false;
    }

virtual int			GetSoundInterests( void ) {
        return ALL_SOUNDS;
    }
    virtual int			GetSoundPriority( CSound *pSound ) {
        return 1;
    }

CSound *			GetLoudestSoundOfType( int iType ) {
        return NULL;
    }
    virtual CSound *	GetBestSound( int validTypes = ALL_SOUNDS ) {
        return NULL;
    }
    virtual CSound *	GetBestScent( void ) {
        return NULL;
    }
    virtual float		HearingSensitivity( void ) {
        return 1.0;
    }
    virtual bool		ShouldIgnoreSound( CSound * ) {
        return false;
    }
    virtual bool		SoundIsVisible( CSound *pSound ) {
        return false;
    }
    virtual	bool		OnlySeeAliveEntities( void ) {
        return true;
    }