First version of the SOurce SDK 2013

1 files changed, 369 insertions, 0 deletions

diff --git a/sp/src/game/shared/takedamageinfo.h b/sp/src/game/shared/takedamageinfo.h
new file mode 100644
index 00000000..5a50d34f
--- /dev/null
+++ b/sp/src/game/shared/takedamageinfo.h
@@ -0,0 +1,369 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//

+//

+// Purpose: 

+//

+// $NoKeywords: $

+//=============================================================================//

+

+#ifndef TAKEDAMAGEINFO_H

+#define TAKEDAMAGEINFO_H

+#ifdef _WIN32

+#pragma once

+#endif

+

+

+#include "networkvar.h" // todo: change this when DECLARE_CLASS is moved into a better location.

+

+// Used to initialize m_flBaseDamage to something that we know pretty much for sure

+// hasn't been modified by a user. 

+#define BASEDAMAGE_NOT_SPECIFIED	FLT_MAX

+

+class CBaseEntity;

+

+

+class CTakeDamageInfo

+{

+public:

+	DECLARE_CLASS_NOBASE( CTakeDamageInfo );

+

+					CTakeDamageInfo();

+					CTakeDamageInfo( CBaseEntity *pInflictor, CBaseEntity *pAttacker, float flDamage, int bitsDamageType, int iKillType = 0 );

+					CTakeDamageInfo( CBaseEntity *pInflictor, CBaseEntity *pAttacker, CBaseEntity *pWeapon, float flDamage, int bitsDamageType, int iKillType = 0 );

+					CTakeDamageInfo( CBaseEntity *pInflictor, CBaseEntity *pAttacker, const Vector &damageForce, const Vector &damagePosition, float flDamage, int bitsDamageType, int iKillType = 0, Vector *reportedPosition = NULL );

+					CTakeDamageInfo( CBaseEntity *pInflictor, CBaseEntity *pAttacker, CBaseEntity *pWeapon, const Vector &damageForce, const Vector &damagePosition, float flDamage, int bitsDamageType, int iKillType = 0, Vector *reportedPosition = NULL );

+	

+

+	// Inflictor is the weapon or rocket (or player) that is dealing the damage.

+	CBaseEntity*	GetInflictor() const;

+	void			SetInflictor( CBaseEntity *pInflictor );

+

+	// Weapon is the weapon that did the attack.

+	// For hitscan weapons, it'll be the same as the inflictor. For projectile weapons, the projectile 

+	// is the inflictor, and this contains the weapon that created the projectile.

+	CBaseEntity*	GetWeapon() const;

+	void			SetWeapon( CBaseEntity *pWeapon );

+

+	// Attacker is the character who originated the attack (like a player or an AI).

+	CBaseEntity*	GetAttacker() const;

+	void			SetAttacker( CBaseEntity *pAttacker );

+

+	float			GetDamage() const;

+	void			SetDamage( float flDamage );

+	float			GetMaxDamage() const;

+	void			SetMaxDamage( float flMaxDamage );

+	void			ScaleDamage( float flScaleAmount );

+	void			AddDamage( float flAddAmount );

+	void			SubtractDamage( float flSubtractAmount );

+	float			GetDamageBonus() const;

+	void			SetDamageBonus( float flBonus );

+

+	float			GetBaseDamage() const;

+	bool			BaseDamageIsValid() const;

+

+	Vector			GetDamageForce() const;

+	void			SetDamageForce( const Vector &damageForce );

+	void			ScaleDamageForce( float flScaleAmount );

+

+	Vector			GetDamagePosition() const;

+	void			SetDamagePosition( const Vector &damagePosition );

+

+	Vector			GetReportedPosition() const;

+	void			SetReportedPosition( const Vector &reportedPosition );

+

+	int				GetDamageType() const;

+	void			SetDamageType( int bitsDamageType );

+	void			AddDamageType( int bitsDamageType );

+	int				GetDamageCustom( void ) const;

+	void			SetDamageCustom( int iDamageCustom );

+	int				GetDamageStats( void ) const;

+	void			SetDamageStats( int iDamageStats );

+

+	int				GetAmmoType() const;

+	void			SetAmmoType( int iAmmoType );

+	const char *	GetAmmoName() const;

+

+	int				GetPlayerPenetrationCount() const { return m_iPlayerPenetrationCount; }

+	void			SetPlayerPenetrationCount( int iPlayerPenetrationCount ) { m_iPlayerPenetrationCount = iPlayerPenetrationCount; }

+	

+	int				GetDamagedOtherPlayers() const     { return m_iDamagedOtherPlayers; }

+	void			SetDamagedOtherPlayers( int iVal ) { m_iDamagedOtherPlayers = iVal; }

+

+	void			Set( CBaseEntity *pInflictor, CBaseEntity *pAttacker, float flDamage, int bitsDamageType, int iKillType = 0 );

+	void			Set( CBaseEntity *pInflictor, CBaseEntity *pAttacker, CBaseEntity *pWeapon, float flDamage, int bitsDamageType, int iKillType = 0 );

+	void			Set( CBaseEntity *pInflictor, CBaseEntity *pAttacker, const Vector &damageForce, const Vector &damagePosition, float flDamage, int bitsDamageType, int iKillType = 0, Vector *reportedPosition = NULL );

+	void			Set( CBaseEntity *pInflictor, CBaseEntity *pAttacker, CBaseEntity *pWeapon, const Vector &damageForce, const Vector &damagePosition, float flDamage, int bitsDamageType, int iKillType = 0, Vector *reportedPosition = NULL );

+

+	void			AdjustPlayerDamageInflictedForSkillLevel();

+	void			AdjustPlayerDamageTakenForSkillLevel();

+

+	// Given a damage type (composed of the #defines above), fill out a string with the appropriate text.

+	// For designer debug output.

+	static void		DebugGetDamageTypeString(unsigned int DamageType, char *outbuf, int outbuflength );

+

+

+//private:

+	void			CopyDamageToBaseDamage();

+

+protected:

+	void			Init( CBaseEntity *pInflictor, CBaseEntity *pAttacker, CBaseEntity *pWeapon, const Vector &damageForce, const Vector &damagePosition, const Vector &reportedPosition, float flDamage, int bitsDamageType, int iKillType );

+

+	Vector			m_vecDamageForce;

+	Vector			m_vecDamagePosition;

+	Vector			m_vecReportedPosition;	// Position players are told damage is coming from

+	EHANDLE			m_hInflictor;

+	EHANDLE			m_hAttacker;

+	EHANDLE			m_hWeapon;

+	float			m_flDamage;

+	float			m_flMaxDamage;

+	float			m_flBaseDamage;			// The damage amount before skill leve adjustments are made. Used to get uniform damage forces.

+	int				m_bitsDamageType;

+	int				m_iDamageCustom;

+	int				m_iDamageStats;

+	int				m_iAmmoType;			// AmmoType of the weapon used to cause this damage, if any

+	int				m_iDamagedOtherPlayers;

+	int				m_iPlayerPenetrationCount;

+	float			m_flDamageBonus;		// Anything that increases damage (crit) - store the delta

+

+	DECLARE_SIMPLE_DATADESC();

+};

+

+//-----------------------------------------------------------------------------

+// Purpose: Multi damage. Used to collect multiple damages in the same frame (i.e. shotgun pellets)

+//-----------------------------------------------------------------------------

+class CMultiDamage : public CTakeDamageInfo

+{

+	DECLARE_CLASS( CMultiDamage, CTakeDamageInfo );

+public:

+	CMultiDamage();

+

+	bool			IsClear( void ) { return (m_hTarget == NULL); }

+	CBaseEntity		*GetTarget() const;

+	void			SetTarget( CBaseEntity *pTarget );

+

+	void			Init( CBaseEntity *pTarget, CBaseEntity *pInflictor, CBaseEntity *pAttacker, CBaseEntity *pWeapon, const Vector &damageForce, const Vector &damagePosition, const Vector &reportedPosition, float flDamage, int bitsDamageType, int iKillType );

+

+protected:

+	EHANDLE			m_hTarget;

+

+	DECLARE_SIMPLE_DATADESC();

+};

+

+extern CMultiDamage g_MultiDamage;

+

+// Multidamage accessors

+void ClearMultiDamage( void );

+void ApplyMultiDamage( void );

+void AddMultiDamage( const CTakeDamageInfo &info, CBaseEntity *pEntity );

+

+//-----------------------------------------------------------------------------

+// Purpose: Utility functions for physics damage force calculation 

+//-----------------------------------------------------------------------------

+float ImpulseScale( float flTargetMass, float flDesiredSpeed );

+void CalculateExplosiveDamageForce( CTakeDamageInfo *info, const Vector &vecDir, const Vector &vecForceOrigin, float flScale = 1.0 );

+void CalculateBulletDamageForce( CTakeDamageInfo *info, int iBulletType, const Vector &vecBulletDir, const Vector &vecForceOrigin, float flScale = 1.0 );

+void CalculateMeleeDamageForce( CTakeDamageInfo *info, const Vector &vecMeleeDir, const Vector &vecForceOrigin, float flScale = 1.0 );

+void GuessDamageForce( CTakeDamageInfo *info, const Vector &vecForceDir, const Vector &vecForceOrigin, float flScale = 1.0 );

+

+

+// -------------------------------------------------------------------------------------------------- //

+// Inlines.

+// -------------------------------------------------------------------------------------------------- //

+

+inline CBaseEntity* CTakeDamageInfo::GetInflictor() const

+{

+	return m_hInflictor;

+}

+

+

+inline void CTakeDamageInfo::SetInflictor( CBaseEntity *pInflictor )

+{

+	m_hInflictor = pInflictor;

+}

+

+

+inline CBaseEntity* CTakeDamageInfo::GetAttacker() const

+{

+	return m_hAttacker;

+}

+

+

+inline void CTakeDamageInfo::SetAttacker( CBaseEntity *pAttacker )

+{

+	m_hAttacker = pAttacker;

+}

+

+inline CBaseEntity* CTakeDamageInfo::GetWeapon() const

+{

+	return m_hWeapon;

+}

+

+

+inline void CTakeDamageInfo::SetWeapon( CBaseEntity *pWeapon )

+{

+	m_hWeapon = pWeapon;

+}

+

+

+inline float CTakeDamageInfo::GetDamage() const

+{

+	return m_flDamage;

+}

+

+inline void CTakeDamageInfo::SetDamage( float flDamage )

+{

+	m_flDamage = flDamage;

+}

+

+inline float CTakeDamageInfo::GetMaxDamage() const

+{

+	return m_flMaxDamage;

+}

+

+inline void CTakeDamageInfo::SetMaxDamage( float flMaxDamage )

+{

+	m_flMaxDamage = flMaxDamage;

+}

+

+inline void CTakeDamageInfo::ScaleDamage( float flScaleAmount )

+{

+	m_flDamage *= flScaleAmount;

+}

+

+inline void CTakeDamageInfo::AddDamage( float flAddAmount )

+{

+	m_flDamage += flAddAmount;

+}

+

+inline void CTakeDamageInfo::SubtractDamage( float flSubtractAmount )

+{

+	m_flDamage -= flSubtractAmount;

+}

+

+inline float CTakeDamageInfo::GetDamageBonus() const

+{

+	return m_flDamageBonus;

+}

+

+inline void CTakeDamageInfo::SetDamageBonus( float flBonus )

+{

+	m_flDamageBonus = flBonus;

+}

+

+inline float CTakeDamageInfo::GetBaseDamage() const

+{

+	if( BaseDamageIsValid() )

+		return m_flBaseDamage;

+

+	// No one ever specified a base damage, so just return damage.

+	return m_flDamage;

+}

+

+inline bool CTakeDamageInfo::BaseDamageIsValid() const

+{

+	return (m_flBaseDamage != BASEDAMAGE_NOT_SPECIFIED);

+}

+

+inline Vector CTakeDamageInfo::GetDamageForce() const

+{

+	return m_vecDamageForce;

+}

+

+inline void CTakeDamageInfo::SetDamageForce( const Vector &damageForce )

+{

+	m_vecDamageForce = damageForce;

+}

+

+inline void	CTakeDamageInfo::ScaleDamageForce( float flScaleAmount )

+{

+	m_vecDamageForce *= flScaleAmount;

+}

+

+inline Vector CTakeDamageInfo::GetDamagePosition() const

+{

+	return m_vecDamagePosition;

+}

+

+

+inline void CTakeDamageInfo::SetDamagePosition( const Vector &damagePosition )

+{

+	m_vecDamagePosition = damagePosition;

+}

+

+inline Vector CTakeDamageInfo::GetReportedPosition() const

+{

+	return m_vecReportedPosition;

+}

+

+

+inline void CTakeDamageInfo::SetReportedPosition( const Vector &reportedPosition )

+{

+	m_vecReportedPosition = reportedPosition;

+}

+

+

+inline void CTakeDamageInfo::SetDamageType( int bitsDamageType )

+{

+	m_bitsDamageType = bitsDamageType;

+}

+

+inline int CTakeDamageInfo::GetDamageType() const

+{

+	return m_bitsDamageType;

+}

+

+inline void	CTakeDamageInfo::AddDamageType( int bitsDamageType )

+{

+	m_bitsDamageType |= bitsDamageType;

+}

+

+inline int CTakeDamageInfo::GetDamageCustom() const

+{

+	return m_iDamageCustom;

+}

+

+inline void CTakeDamageInfo::SetDamageCustom( int iDamageCustom )

+{

+	m_iDamageCustom = iDamageCustom;

+}

+

+inline int CTakeDamageInfo::GetDamageStats() const

+{

+	return m_iDamageCustom;

+}

+

+inline void CTakeDamageInfo::SetDamageStats( int iDamageCustom )

+{

+	m_iDamageCustom = iDamageCustom;

+}

+

+inline int CTakeDamageInfo::GetAmmoType() const

+{

+	return m_iAmmoType;

+}

+

+inline void CTakeDamageInfo::SetAmmoType( int iAmmoType )

+{

+	m_iAmmoType = iAmmoType;

+}

+

+inline void CTakeDamageInfo::CopyDamageToBaseDamage()

+{ 

+	m_flBaseDamage = m_flDamage;

+}

+

+

+// -------------------------------------------------------------------------------------------------- //

+// Inlines.

+// -------------------------------------------------------------------------------------------------- //

+inline CBaseEntity *CMultiDamage::GetTarget() const

+{

+	return m_hTarget;

+}

+

+inline void CMultiDamage::SetTarget( CBaseEntity *pTarget )

+{

+	m_hTarget = pTarget;

+}

+

+

+#endif // TAKEDAMAGEINFO_H