自学教程：C++ CTakeDamageInfo函数代码示例

//-----------------------------------------------------------------------------// Purpose: //-----------------------------------------------------------------------------void CWeaponCombatLaserRifle::PrimaryAttack( void ){	CBaseTFPlayer *pPlayer = (CBaseTFPlayer*)GetOwner();	if (!pPlayer)		return;		WeaponSound(SINGLE);	// Fire the bullets	Vector vecSrc = pPlayer->Weapon_ShootPosition( );	Vector vecAiming;	pPlayer->EyeVectors( &vecAiming );	PlayAttackAnimation( GetPrimaryAttackActivity() );	// Reduce the spread if the player's ducking	Vector vecSpread = GetBulletSpread();	vecSpread *= m_flInaccuracy;	TFGameRules()->FireBullets( CTakeDamageInfo( this, pPlayer, weapon_combat_laserrifle_damage.GetFloat(), DMG_PLASMA), 1, 		vecSrc, vecAiming, vecSpread, weapon_combat_laserrifle_range.GetFloat(), m_iPrimaryAmmoType, 0, entindex(), 0 );	m_flInaccuracy += 0.3;	m_flInaccuracy = clamp(m_flInaccuracy, 0, 1);	m_flNextPrimaryAttack = gpGlobals->curtime + GetFireRate();	m_iClip1 = m_iClip1 - 1;}

//-----------------------------------------------------------------------------// Purpose: // Input  : index - //			*pEvent - //-----------------------------------------------------------------------------void CGrubNugget::VPhysicsCollision( int index, gamevcollisionevent_t *pEvent ){	int damageType;	float damage = CalculateDefaultPhysicsDamage( index, pEvent, 1.0f, true, damageType );	if ( damage > 5.0f )	{		CBaseEntity *pHitEntity = pEvent->pEntities[!index];		if ( pHitEntity == NULL )		{			// hit world			pHitEntity = GetContainingEntity( INDEXENT(0) );		}				Vector damagePos;		pEvent->pInternalData->GetContactPoint( damagePos );		Vector damageForce = pEvent->postVelocity[index] * pEvent->pObjects[index]->GetMass();		if ( damageForce == vec3_origin )		{			// This can happen if this entity is motion disabled, and can't move.			// Use the velocity of the entity that hit us instead.			damageForce = pEvent->postVelocity[!index] * pEvent->pObjects[!index]->GetMass();		}		// FIXME: this doesn't pass in who is responsible if some other entity "caused" this collision		PhysCallbackDamage( this, CTakeDamageInfo( pHitEntity, pHitEntity, damageForce, damagePos, damage, damageType ), *pEvent, index );	}	BaseClass::VPhysicsCollision( index, pEvent );}

//-----------------------------------------------------------------------------// Purpose: An entity has blocked the brush.// Input  : pOther - //-----------------------------------------------------------------------------void CFuncRotating::Blocked( CBaseEntity *pOther ){#ifdef HL1_DLL	if( m_flBlockDamage > 0 )#endif		pOther->TakeDamage( CTakeDamageInfo( this, this, m_flBlockDamage, DMG_CRUSH ) );}

void CControllerZapBall::ExplodeTouch( CBaseEntity *pOther ){	if( pOther->pev->takedamage )	{		TraceResult tr = UTIL_GetGlobalTrace();		CBaseEntity* pOwner;		if( m_hOwner != nullptr )		{			pOwner = m_hOwner;		}		else		{			pOwner = this;		}		g_MultiDamage.Clear();		pOther->TraceAttack( CTakeDamageInfo( pOwner, gSkillData.GetControllerDmgBall(), DMG_ENERGYBEAM ), pev->velocity.Normalize(), &tr );		g_MultiDamage.ApplyMultiDamage( pOwner, pOwner );		UTIL_EmitAmbientSound( this, tr.vecEndPos, "weapons/electro4.wav", 0.3, ATTN_NORM, 0, RANDOM_LONG( 90, 99 ) );	}	UTIL_Remove( this );}

void CGrenadeSpit::GrenadeSpitTouch( CBaseEntity *pOther ){	if (m_fSpitDeathTime != 0)	{		return;	}	if ( pOther->GetCollisionGroup() == HL2COLLISION_GROUP_SPIT)	{		return;	}	if ( !pOther->m_takedamage )	{		// make a splat on the wall		trace_t tr;		UTIL_TraceLine( GetAbsOrigin(), GetAbsOrigin() + GetAbsVelocity() * 10, MASK_SOLID, this, COLLISION_GROUP_NONE, &tr );		UTIL_DecalTrace(&tr, "BeerSplash" );		// make some flecks		// CPVSFilter filter( tr.endpos );		//te->SpriteSpray( filter, 0.0,		//	tr.endpos, tr.plane.normal, m_nSquidSpitSprite, 30, 0.8, 5 );	}	else	{		RadiusDamage ( CTakeDamageInfo( this, GetThrower(), m_flDamage, DMG_BLAST ), GetAbsOrigin(), m_DmgRadius, CLASS_NONE, NULL );	}	Detonate();}

//------------------------------------------------------------------------------// Purpose: Implement impact function//------------------------------------------------------------------------------void CWeaponCrowbar::Hit( void ){	//Make sound for the AI#ifndef CLIENT_DLL	CBasePlayer *pPlayer = ToBasePlayer( GetOwner() );	CSoundEnt::InsertSound( SOUND_BULLET_IMPACT, m_traceHit.endpos, 400, 0.2f, pPlayer );	CBaseEntity	*pHitEntity = m_traceHit.m_pEnt;	//Apply damage to a hit target	if ( pHitEntity != NULL )	{		Vector hitDirection;		pPlayer->EyeVectors( &hitDirection, NULL, NULL );		VectorNormalize( hitDirection );		ClearMultiDamage();		CTakeDamageInfo info( GetOwner(), GetOwner(), sk_plr_dmg_crowbar.GetFloat(), DMG_CLUB );		CalculateMeleeDamageForce( &info, hitDirection, m_traceHit.endpos );		pHitEntity->DispatchTraceAttack( info, hitDirection, &m_traceHit ); 		ApplyMultiDamage();		// Now hit all triggers along the ray that... 		TraceAttackToTriggers( CTakeDamageInfo( GetOwner(), GetOwner(), sk_plr_dmg_crowbar.GetFloat(), DMG_CLUB ), m_traceHit.startpos, m_traceHit.endpos, hitDirection );		//Play an impact sound			ImpactSound( pHitEntity );	}#endif	//Apply an impact effect	ImpactEffect();}

void CASW_Boomer_Blob::DoExplosion( ){	// scorch the ground	trace_t		tr;	UTIL_TraceLine ( GetAbsOrigin(), GetAbsOrigin() + Vector( 0, 0, -80 ), MASK_SHOT, this, COLLISION_GROUP_NONE, &tr);	if ( m_bMaster )	{		if ( ( tr.m_pEnt != GetWorldEntity() ) || ( tr.hitbox != 0 ) )		{			// non-world needs smaller decals			if( tr.m_pEnt && !tr.m_pEnt->IsNPC() )			{				UTIL_DecalTrace( &tr, "SmallScorch" );			}		}		else		{			UTIL_DecalTrace( &tr, "Scorch" );		}		UTIL_ASW_ScreenShake( GetAbsOrigin(), 7.0f, 45.0f, 0.5f, 150, SHAKE_START );	}	// explosion effects	DispatchParticleEffect( "boomer_drop_explosion", GetAbsOrigin(), Vector( m_DmgRadius, 0.0f, 0.0f ), QAngle( 0.0f, 0.0f, 0.0f ) );	EmitSound( "ASW_Boomer_Grenade.Explode" );	// damage to nearby things	ASWGameRules()->RadiusDamage( CTakeDamageInfo( this, m_hFirer.Get(), m_flDamage, DMG_BLAST ), GetAbsOrigin(), m_DmgRadius, CLASS_NONE, NULL );}

//-----------------------------------------------------------------------------// Purpose: //-----------------------------------------------------------------------------void CGrenadeRocket::MissileTouch( CBaseEntity *pOther ){	Assert( pOther );	if ( !pOther->IsSolid() )		return;	Vector vecAbsOrigin = GetAbsOrigin();	CPASFilter filter( vecAbsOrigin );	te->Explosion( filter, 0.0,	&vecAbsOrigin, g_sModelIndexFireball, 2.0, 15, TE_EXPLFLAG_NONE, 100, m_flDamage );	StopSound( "GrenadeRocket.FlyLoop" );	// Don't apply explosive damage if it hit a shield of any kind...	bool bHittingShield = false;	if (pOther->GetCollisionGroup() == TFCOLLISION_GROUP_SHIELD)	{		bHittingShield = true;	}	else if ( pOther->IsPlayer() )	{		CBaseTFPlayer *pPlayer = static_cast<CBaseTFPlayer*>(pOther);		trace_t tr;		float flDamage = m_flDamage;		bHittingShield = pPlayer->IsHittingShield( GetAbsVelocity(), &flDamage );	}	if (!bHittingShield)	{		RadiusDamage( CTakeDamageInfo( this, m_pRealOwner, m_flDamage, DMG_BLAST ), vecAbsOrigin, 100, CLASS_NONE );	}	UTIL_Remove( this );}

//-----------------------------------------------------------------------------// Purpose: // Input  : *pOther - //-----------------------------------------------------------------------------void CFlare::FlareBurnTouch( CBaseEntity *pOther ){	if ( pOther && pOther->m_takedamage && ( m_flNextDamage < gpGlobals->curtime ) )	{		pOther->TakeDamage( CTakeDamageInfo( this, m_pOwner, 1, (DMG_BULLET|DMG_BURN) ) );		m_flNextDamage = gpGlobals->curtime + 1.0f;	}}

//-----------------------------------------------------------------------------// Purpose: Called every frame when the bruch is blocked while moving// Input  : pOther - The blocking entity.//-----------------------------------------------------------------------------void CFuncMoveLinear::Blocked( CBaseEntity *pOther ){	// Hurt the blocker 	if ( m_flBlockDamage )	{		pOther->TakeDamage( CTakeDamageInfo( this, this, m_flBlockDamage, DMG_CRUSH ) );	}}

static int luasrc_CTakeDamageInfo (lua_State *L) {  if (lua_gettop(L) < 4) {    CTakeDamageInfo info = CTakeDamageInfo();    lua_pushdamageinfo(L, info);  } else if (lua_gettop(L) <= 5) {    CTakeDamageInfo info = CTakeDamageInfo(luaL_checkentity(L, 1), luaL_checkentity(L, 2), luaL_checknumber(L, 3), luaL_checkint(L, 4), luaL_optint(L, 5, 0));    lua_pushdamageinfo(L, info);  } else if (lua_gettop(L) <= 6) {    CTakeDamageInfo info = CTakeDamageInfo(luaL_checkentity(L, 1), luaL_checkentity(L, 2), luaL_checkentity(L, 3), luaL_checknumber(L, 4), luaL_checkint(L, 5), luaL_optint(L, 6, 0));    lua_pushdamageinfo(L, info);  } else if (lua_gettop(L) < 9) {    CTakeDamageInfo info = CTakeDamageInfo(luaL_checkentity(L, 1), luaL_checkentity(L, 2), luaL_checkvector(L, 3), luaL_checkvector(L, 4), luaL_checknumber(L, 5), luaL_checkint(L, 6), luaL_optint(L, 7, 0), &luaL_optvector(L, 8, NULL));    lua_pushdamageinfo(L, info);  } else {    CTakeDamageInfo info = CTakeDamageInfo(luaL_checkentity(L, 1), luaL_checkentity(L, 2), luaL_checkentity(L, 3), luaL_checkvector(L, 4), luaL_checkvector(L, 5), luaL_checknumber(L, 6), luaL_checkint(L, 7), luaL_optint(L, 8, 0), &luaL_optvector(L, 9, NULL));    lua_pushdamageinfo(L, info);  }  return 1;}

void CTripmineGrenade::BeamBreakThink( void  ){	// See if I can go solid yet (has dropper moved out of way?)	if (IsSolidFlagSet( FSOLID_NOT_SOLID ))	{		trace_t tr;		Vector	vUpBit = GetAbsOrigin();		vUpBit.z += 5.0;		UTIL_TraceEntity( this, GetAbsOrigin(), vUpBit, MASK_SHOT, &tr );		if ( !tr.startsolid && (tr.fraction == 1.0) )		{			RemoveSolidFlags( FSOLID_NOT_SOLID );		}	}	trace_t tr;	// NOT MASK_SHOT because we want only simple hit boxes	UTIL_TraceLine( GetAbsOrigin(), m_vecEnd, MASK_SOLID, this, COLLISION_GROUP_NONE, &tr );	// ALERT( at_console, "%f : %f/n", tr.flFraction, m_flBeamLength );	// respawn detect. 	if ( !m_pBeam )	{		MakeBeam( );		if ( tr.m_pEnt )			m_hOwner = tr.m_pEnt;	// reset owner too	}	CBaseEntity *pEntity = tr.m_pEnt;	CBaseCombatCharacter *pBCC  = ToBaseCombatCharacter( pEntity );	bool bAttachMoved = false;	if ( m_bAttached && m_hAttachEntity.Get() != NULL )	{		if ( m_hAttachEntity.Get()->GetAbsOrigin() != m_vAttachedPosition )			bAttachMoved = true;	}	// Also blow up if the attached entity goes away, ie: a crate	if (pBCC || fabs( m_flBeamLength - tr.fraction ) > 0.001 || ( m_bAttached && m_hAttachEntity.Get() == NULL) || bAttachMoved )	{		m_iHealth = 0;		if (m_pConstraint)			m_pConstraint->Deactivate();		Event_Killed( CTakeDamageInfo( (CBaseEntity*)m_hOwner, this, 100, GIB_NORMAL ) );		return;	}	SetNextThink( gpGlobals->curtime + 0.05f );}

//-----------------------------------------------------------------------------// Purpose: Explode and die//-----------------------------------------------------------------------------void CBasePlasmaProjectile::Detonate( void ){#if !defined( CLIENT_DLL )	// Should I explode?	if ( m_flExplosiveRadius )	{		RadiusDamage( CTakeDamageInfo( this, GetOwnerEntity(), m_flDamage, m_DamageType | DMG_BLAST ), GetAbsOrigin(), m_flExplosiveRadius, CLASS_NONE, NULL );	}#endif	Remove( );}

void CShockBeam::BallTouch( CBaseEntity* pOther ){	if( pOther->GetTakeDamageMode() != DAMAGE_NO )	{		TraceResult tr = UTIL_GetGlobalTrace();		CBaseEntity* pOwner = GetOwner();		g_MultiDamage.Clear();		int bitsDamageTypes = DMG_ALWAYSGIB | DMG_SHOCK;		if( CBaseMonster* pMonster = pOther->MyMonsterPointer() )		{			bitsDamageTypes = 64;			if( pMonster->m_flShockDuration > 1.0 )			{				bitsDamageTypes = 8192;			}			pMonster->AddShockEffect( 63, 152, 208, 16, 0.5 );		}		pOther->TraceAttack( 			CTakeDamageInfo( 				pOwner, 				bIsMultiplayer() ? gSkillData.GetPlrDmgShockRoachM() : gSkillData.GetPlrDmgShockRoachS(),				bitsDamageTypes ), 			GetAbsVelocity().Normalize(),			&tr );		g_MultiDamage.ApplyMultiDamage( this, pOwner );		SetAbsVelocity( g_vecZero );	}	SetThink( &CShockBeam::ExplodeThink );	SetNextThink( gpGlobals->time + 0.01 );	if( pOther->GetTakeDamageMode() == DAMAGE_NO )	{		TraceResult tr;		UTIL_TraceLine( GetAbsOrigin(), GetAbsOrigin() + GetAbsVelocity() * 10, dont_ignore_monsters, edict(), &tr );			UTIL_DecalTrace( &tr, DECAL_OFSCORCH1 + UTIL_RandomLong( 0, 2 ) );		MESSAGE_BEGIN( MSG_PAS, SVC_TEMPENTITY, GetAbsOrigin() );			WRITE_BYTE( TE_SPARKS );			WRITE_COORD_VECTOR( GetAbsOrigin() );		MESSAGE_END();	}}

void CGrenadeAR2::Detonate(void){	if (!m_bIsLive)	{		return;	}	m_bIsLive		= false;	m_takedamage	= DAMAGE_NO;		if(m_hSmokeTrail)	{		UTIL_Remove(m_hSmokeTrail);		m_hSmokeTrail = NULL;	}	CPASFilter filter( GetAbsOrigin() );	te->Explosion( filter, 0.0,		&GetAbsOrigin(), 		g_sModelIndexFireball,		2.0, 		15,		TE_EXPLFLAG_NONE,		m_DmgRadius,		m_flDamage );	Vector vecForward = GetAbsVelocity();	VectorNormalize(vecForward);	trace_t		tr;	UTIL_TraceLine ( GetAbsOrigin(), GetAbsOrigin() + 60*vecForward, MASK_SHOT, 		this, COLLISION_GROUP_NONE, &tr);	if ((tr.m_pEnt != GetWorldEntity()) || (tr.hitbox != 0))	{		// non-world needs smaller decals		if( tr.m_pEnt && !tr.m_pEnt->IsNPC() )		{			UTIL_DecalTrace( &tr, "SmallScorch" );		}	}	else	{		UTIL_DecalTrace( &tr, "Scorch" );	}	UTIL_ScreenShake( GetAbsOrigin(), 25.0, 150.0, 1.0, 750, SHAKE_START );	RadiusDamage ( CTakeDamageInfo( this, GetThrower(), m_flDamage, DMG_BLAST ), GetAbsOrigin(), m_DmgRadius, CLASS_NONE, NULL );	UTIL_Remove( this );}

void CGrenadeMP5::Detonate(void){	if (!m_bIsLive)	{		return;	}	m_bIsLive		= false;	m_takedamage	= DAMAGE_NO;		CPASFilter filter( GetAbsOrigin() );	te->Explosion( filter, 0.0,		&GetAbsOrigin(), 		GetWaterLevel() == 0 ? g_sModelIndexFireball : g_sModelIndexWExplosion,		(m_flDamage - 50) * .60, 		15,		TE_EXPLFLAG_NONE,		m_DmgRadius,		m_flDamage );	trace_t tr;		tr = CBaseEntity::GetTouchTrace();	if ( (tr.m_pEnt != GetWorldEntity()) || (tr.hitbox != 0) )	{		// non-world needs smaller decals		UTIL_DecalTrace( &tr, "SmallScorch");	}	else	{		UTIL_DecalTrace( &tr, "Scorch" );	}	CSoundEnt::InsertSound ( SOUND_COMBAT, GetAbsOrigin(), BASEGRENADE_EXPLOSION_VOLUME, 3.0 );	RadiusDamage ( CTakeDamageInfo( this, GetThrower(), m_flDamage, DMG_BLAST ), GetAbsOrigin(), m_flDamage * 2.5, CLASS_NONE, NULL );	CPASAttenuationFilter filter2( this );	EmitSound( filter2, entindex(), "GrenadeMP5.Detonate" );	if ( GetWaterLevel() == 0 )	{		int sparkCount = random->RandomInt( 0,3 );		QAngle angles;		VectorAngles( tr.plane.normal, angles );		for ( int i = 0; i < sparkCount; i++ )			Create( "spark_shower", GetAbsOrigin(), angles, NULL );	}	UTIL_Remove( this );}

void CShockBeam::WaterExplodeThink(){	CBaseEntity* pOwner = GetOwner();	Explode();	::RadiusDamage( 		GetAbsOrigin(), 		CTakeDamageInfo( this, pOwner, 100.0, DMG_ALWAYSGIB | DMG_BLAST ), 		150.0, 0 );	UTIL_Remove( this );}

//-----------------------------------------------------------------------------// Purpose: //-----------------------------------------------------------------------------void CWeaponGaussGun::IncreaseCharge(){	if ( m_flNextChargeTime > gpGlobals->curtime )		return;	CBasePlayer *pOwner = ToBasePlayer( GetOwner() );		if ( pOwner == NULL )		return;	//Check our charge time	if ( ( gpGlobals->curtime - m_flChargeStartTime ) > MAX_GAUSS_CHARGE_TIME )	{		//Notify the player they're at maximum charge		if ( m_bChargeIndicated == false )		{			WeaponSound( SPECIAL2 );			m_bChargeIndicated = true;		}	#ifndef CLIENT_DLL		if ( ( gpGlobals->curtime - m_flChargeStartTime ) > DANGER_GAUSS_CHARGE_TIME )		{			//Damage the player			WeaponSound( SPECIAL2 );						// Add DMG_CRUSH because we don't want any physics force			pOwner->TakeDamage( CTakeDamageInfo( this, this, 25, DMG_SHOCK | DMG_CRUSH ) );						color32 gaussDamage = {255,128,0,128};			UTIL_ScreenFade( pOwner, gaussDamage, 0.2f, 0.2f, FFADE_IN );			m_flNextChargeTime = gpGlobals->curtime + random->RandomFloat( 0.5f, 2.5f );		}	#endif		return;	}	//Decrement power	pOwner->RemoveAmmo( 1, m_iPrimaryAmmoType );	//Make sure we can draw power	if ( pOwner->GetAmmoCount( m_iPrimaryAmmoType ) <= 0 )	{		ChargedFire();		return;	}	m_flNextChargeTime = gpGlobals->curtime + GAUSS_CHARGE_TIME;}

void CSnark::Event_Killed( const CTakeDamageInfo &inputInfo ){//	pev->model = iStringNull;// make invisible	SetThink( &CSnark::SUB_Remove );	SetNextThink( gpGlobals->curtime + 0.1f );	SetTouch( NULL );	// since squeak grenades never leave a body behind, clear out their takedamage now.	// Squeaks do a bit of radius damage when they pop, and that radius damage will	// continue to call this function unless we acknowledge the Squeak's death now. (sjb)	m_takedamage = DAMAGE_NO;	// play squeek blast	CPASAttenuationFilter filter( this, 0.5 );	enginesound->EmitSound( filter, entindex(), CHAN_ITEM, "squeek/sqk_blast1.wav", 1, 0.5, 0, PITCH_NORM );	CSoundEnt::InsertSound( SOUND_COMBAT, GetAbsOrigin(), SNARK_EXPLOSION_VOLUME, 3.0 );	UTIL_BloodDrips( WorldSpaceCenter(), Vector( 0, 0, 0 ), BLOOD_COLOR_YELLOW, 80 );	if ( m_hOwner != NULL )	{		RadiusDamage( CTakeDamageInfo( this, m_hOwner, GetDamage(), DMG_BLAST ), GetAbsOrigin(), GetDamage() * 2.5, CLASS_NONE );	}	else	{		RadiusDamage( CTakeDamageInfo( this, this, GetDamage(), DMG_BLAST ), GetAbsOrigin(), GetDamage() * 2.5, CLASS_NONE );	}	// reset owner so death message happens	if ( m_hOwner != NULL )		SetOwnerEntity( m_hOwner );	CTakeDamageInfo info = inputInfo;	info.SetDamageType( DMG_GIB_CORPSE );	BaseClass::Event_Killed( info );}

//-----------------------------------------------------------------------------// Purpose: Called every frame when the bruch is blocked while moving// Input  : pOther - The blocking entity.//-----------------------------------------------------------------------------void CFuncMoveLinear::Blocked( CBaseEntity *pOther ){	// Hurt the blocker 	if ( m_flBlockDamage )	{		if ( pOther->m_takedamage == DAMAGE_EVENTS_ONLY )		{			if ( FClassnameIs( pOther, "gib" ) )				UTIL_Remove( pOther );		}		else			pOther->TakeDamage( CTakeDamageInfo( this, this, m_flBlockDamage, DMG_CRUSH ) );	}}

void CASW_Radiation_Volume::RadHurt(CBaseEntity *pEnt){	if (!pEnt)		return;	CBaseEntity *pAttacker = this;	if (m_hCreator.Get() && pEnt->Classify() != CLASS_ASW_MARINE)	// don't deal friendly fire damage from rad barrels		pAttacker = m_hCreator.Get();	float fDamage = ASW_RAD_DAMAGE;	if (pEnt->Classify() == CLASS_ASW_MARINE)		fDamage *= 0.5f;	pEnt->TakeDamage( CTakeDamageInfo( this, pAttacker, fDamage, DMG_RADIATION ) );}

//-----------------------------------------------------------------------------// Purpose: Burn targets around us//-----------------------------------------------------------------------------void CEntityFlame::FlameThink( void ){	if ( m_flLifetime < gpGlobals->curtime )	{		SetThink( &CEntityFlame::SUB_Remove );		SetNextThink( gpGlobals->curtime + 0.1f );		return;	}	RadiusDamage( CTakeDamageInfo( this, this, 4.0f, DMG_BURN ), GetAbsOrigin(), m_flSize/2, CLASS_NONE );	FireSystem_AddHeatInRadius( GetAbsOrigin(), m_flSize/2, 2.0f );	SetNextThink( gpGlobals->curtime + 0.1f );}

//-----------------------------------------------------------------------------// Purpose: Will hurt others based on how fast the brush is spinning.// Input  : pOther - //-----------------------------------------------------------------------------void CFuncRotating::HurtTouch ( CBaseEntity *pOther ){	// we can't hurt this thing, so we're not concerned with it	if ( !pOther->m_takedamage )		return;	// calculate damage based on rotation speed	m_flBlockDamage = GetLocalAngularVelocity().Length() / 10;	pOther->TakeDamage( CTakeDamageInfo( this, this, m_flBlockDamage, DMG_CRUSH ) );	Vector vecNewVelocity = pOther->GetAbsOrigin() - WorldSpaceCenter();	VectorNormalize(vecNewVelocity);	vecNewVelocity *= m_flBlockDamage;	pOther->SetAbsVelocity( vecNewVelocity );}

void CTripmineGrenade::BeamBreakThink( void  ){	// See if I can go solid yet (has dropper moved out of way?)	if (IsSolidFlagSet( FSOLID_NOT_SOLID ))	{		trace_t tr;		Vector	vUpBit = GetAbsOrigin();		vUpBit.z += 5.0;		UTIL_TraceEntity( this, GetAbsOrigin(), vUpBit, MASK_SHOT, &tr );		if ( !tr.startsolid && (tr.fraction == 1.0) )		{			RemoveSolidFlags( FSOLID_NOT_SOLID );		}	}	trace_t tr;	// NOT MASK_SHOT because we want only simple hit boxes	UTIL_TraceLine( GetAbsOrigin(), m_vecEnd, MASK_SOLID, this, COLLISION_GROUP_NONE, &tr );	// ALERT( at_console, "%f : %f/n", tr.flFraction, m_flBeamLength );	// respawn detect. 	if ( !m_pBeam )	{		MakeBeam( );		if ( tr.m_pEnt )			m_hOwner = tr.m_pEnt;	// reset owner too	}	CBaseEntity *pEntity = tr.m_pEnt;	CBaseCombatCharacter *pBCC  = ToBaseCombatCharacter( pEntity );		if (pBCC && pBCC->GetTeamNumber() != m_nTeam && pBCC->m_floatCloakFactor < 1.0f)	//if (pBCC || fabs( m_flBeamLength - tr.fraction ) > 0.001)	{		m_iHealth = 0;		Event_Killed( CTakeDamageInfo( (CBaseEntity*)m_hOwner, this, 100, GIB_NORMAL ) );				return;	}	SetNextThink( gpGlobals->curtime + 0.05f );}

//-----------------------------------------------------------------------------// Purpose: //-----------------------------------------------------------------------------void CPlayer_Missile::BlowUp(void){	// Don't take damage any more	m_takedamage	= DAMAGE_NO;	// Mark as dead so won't be attacked	m_lifeState = LIFE_DEAD;	// Stop fly and launch sounds	StopSound( "Player_Manhack.Fly" );	StopSound( "Player_Manhack.Fire" );	CPASFilter filter( GetAbsOrigin() );	te->Explosion( filter, 0.0,		&GetAbsOrigin(), 		g_sModelIndexFireball,		2.0, 		15,		TE_EXPLFLAG_NONE,		m_flDamageRadius,		m_flDamage );	Vector vecForward = GetAbsVelocity();	VectorNormalize(vecForward);	trace_t		tr;	UTIL_TraceLine ( GetAbsOrigin(), GetAbsOrigin() + 60*vecForward,  MASK_SOLID_BRUSHONLY, 		this, COLLISION_GROUP_NONE, &tr);	UTIL_DecalTrace( &tr, "Scorch" );	UTIL_ScreenShake( GetAbsOrigin(), 25.0, 150.0, 1.0, 750, SHAKE_START );	CSoundEnt::InsertSound ( SOUND_DANGER, GetAbsOrigin(), 1024, 3.0 );	RadiusDamage ( CTakeDamageInfo( this, this, m_flDamage, DMG_BLAST ), GetAbsOrigin(), m_flDamageRadius, CLASS_NONE );	SetThink(ExplodeThink);	SetTouch(NULL);	m_vBounceVel	= -0.2 * GetAbsVelocity();	AddSolidFlags( FSOLID_NOT_SOLID );	Relink();	// Stop emitting smoke	if(m_hSmokeTrail)	{		((SmokeTrail*)(CBaseEntity*)m_hSmokeTrail)->SetEmit(false);	}}

void CBMortar::Touch( CBaseEntity *pOther ){	trace_t tr;	int		iPitch;	// splat sound	iPitch = random->RandomFloat( 90, 110 );	EmitSound( "NPC_BigMomma.SpitTouch1" );	switch ( random->RandomInt( 0, 1 ) )	{	case 0:		EmitSound( "NPC_BigMomma.SpitHit1" );		break;	case 1:		EmitSound( "NPC_BigMomma.SpitHit2" );		break;	}	if ( pOther->IsBSPModel() )	{		// make a splat on the wall		UTIL_TraceLine( GetAbsOrigin(), GetAbsOrigin() + GetAbsVelocity() * 10, MASK_SOLID, this, COLLISION_GROUP_NONE, &tr );		UTIL_DecalTrace( &tr, "Splash" );	}	else	{		tr.endpos = GetAbsOrigin();		Vector vVelocity = GetAbsVelocity();		VectorNormalize( vVelocity );		tr.plane.normal = -1 * vVelocity;	}	// make some flecks	MortarSpray( tr.endpos + Vector( 0, 0, 15 ), tr.plane.normal, gSpitSprite, 24 );	CBaseEntity *pOwner = GetOwnerEntity();	RadiusDamage( CTakeDamageInfo( this, pOwner, sk_bigmomma_dmg_blast.GetFloat(), DMG_ACID ), GetAbsOrigin(), sk_bigmomma_radius_blast.GetFloat(), CLASS_NONE, NULL );			UTIL_Remove( pSprite );	UTIL_Remove( this );}

void CBreakable::BreakTouch( CBaseEntity *pOther ){	float flDamage;		// only players can break these right now	if ( !pOther->IsPlayer() || !IsBreakable() )	{        return;	}	// can I be broken when run into?	if ( HasSpawnFlags( SF_BREAK_TOUCH ) )	{		flDamage = pOther->GetSmoothedVelocity().Length() * 0.01;		if (flDamage >= m_iHealth)		{			m_takedamage = DAMAGE_YES;			SetTouch( NULL );			OnTakeDamage( CTakeDamageInfo( pOther, pOther, flDamage, DMG_CRUSH ) );			// do a little damage to player if we broke glass or computer			CTakeDamageInfo info( pOther, pOther, flDamage/4, DMG_SLASH );			CalculateMeleeDamageForce( &info, (pOther->GetAbsOrigin() - GetAbsOrigin()), GetAbsOrigin() );			pOther->TakeDamage( info );		}	}	// can I be broken when stood upon?	if ( HasSpawnFlags( SF_BREAK_PRESSURE ) && pOther->GetGroundEntity() == this )	{		// play creaking sound here.		DamageSound();		m_hBreaker = pOther;		SetThink ( &CBreakable::Die );		SetTouch( NULL );				// Add optional delay 		SetNextThink( gpGlobals->curtime + m_flPressureDelay );	}}

//-----------------------------------------------------------------------------// Purpose: Push a physics object in our wash. Return false if it's now out of our wash//-----------------------------------------------------------------------------bool CBaseHelicopter::DoWashPush( washentity_t *pWash, Vector vecWashOrigin ){	if ( !pWash || !pWash->hEntity.Get() )		return false;	// Make sure the entity is still within our wash's radius	CBaseEntity *pEntity = pWash->hEntity;	Vector vecSpot = pEntity->BodyTarget( vecWashOrigin );	Vector vecToSpot = ( vecSpot - vecWashOrigin );	vecToSpot.z = 0;	float flDist = VectorNormalize( vecToSpot );	if ( flDist > BASECHOPPER_WASH_RADIUS )		return false;	IPhysicsObject *pPhysObject = pEntity->VPhysicsGetObject();	if ( pPhysObject == NULL )		return false;	// Push it away from the center of the wash	float flMass = pPhysObject->GetMass();	float flPushTime = (gpGlobals->curtime - pWash->flWashStartTime);	float flMinPush = BASECHOPPER_WASH_PUSH_MIN * flMass;	float flMaxPush = BASECHOPPER_WASH_PUSH_MAX * flMass;	float flWashAmount = min( flMaxPush, RemapVal( flPushTime, 0, BASECHOPPER_WASH_RAMP_TIME, flMinPush, flMaxPush ) );	Vector vecForce = flWashAmount * vecToSpot * phys_pushscale.GetFloat();	pEntity->VPhysicsTakeDamage( CTakeDamageInfo( this, this, vecForce, vecWashOrigin, flWashAmount, DMG_BLAST ) );	// Debug	if ( g_debug_basehelicopter.GetInt() == BASECHOPPER_DEBUG_WASH )	{		NDebugOverlay::Cross3D( pEntity->GetAbsOrigin(), -Vector(4,4,4), Vector(4,4,4), 255, 0, 0, true, 0.1f );		NDebugOverlay::Line( pEntity->GetAbsOrigin(), pEntity->GetAbsOrigin() + vecForce, 255, 255, 0, true, 0.1f );		IPhysicsObject *pPhysObject = pEntity->VPhysicsGetObject();		Msg("Pushed %s (mass %f) with force %f (min %.2f max %.2f) at time %.2f/n", pEntity->GetClassname(), pPhysObject->GetMass(), flWashAmount, flMinPush, flMaxPush, gpGlobals->curtime );	}	// If we've pushed this thing for some time, remove it to give us a chance to find lighter things nearby	if ( flPushTime > 2.0 )		return false;	return true;}

//-----------------------------------------------------------------------------// Purpose: Make the object fall away// Input  : pOther - The entity that is touching us.//-----------------------------------------------------------------------------void CASW_Trigger_Fall::FallTouch( CBaseEntity *pOther ){	// If it's a player, just kill him for now	if ( pOther->IsNPC() )	{		if ( pOther->IsAlive() == false )			return;		pOther->TakeDamage( CTakeDamageInfo( this, this, 500, DMG_FALL ) );	}	else 	{		// Just remove the entity		//UTIL_Remove( pOther );	}	// Fire our output	m_OnFallingObject.FireOutput( pOther, this );}

void CWalkerMiniStrider::UpdateLargeGun(){	float dt = GetTimeDelta();	if ( !m_bFiringLargeGun )		return;	m_flLargeGunCountdown -= dt;	if ( m_flLargeGunCountdown <= 0 )	{		// Fire!		Vector vSrc = GetLargeGunShootOrigin();		trace_t trace;		UTIL_TraceLine( vSrc, vSrc + m_vLargeGunForward * 2000, MASK_SOLID, this, COLLISION_GROUP_NONE, &trace );		if ( trace.fraction < 1 )		{			CBasePlayer *pDriver = GetPassenger( VEHICLE_DRIVER );			if ( pDriver )			{				UTIL_ImpactTrace( &trace, DMG_ENERGYBEAM, "Strider" );				Vector vHitPos = trace.endpos;				float flDamageRadius = 100;				float flDamage = 100;				CPASFilter filter( vHitPos );				te->Explosion( filter, 0.0,					&vHitPos, 					g_sModelIndexFireball,					2.0, 					15,					TE_EXPLFLAG_NONE,					flDamageRadius,					flDamage );				UTIL_ScreenShake( vHitPos, 10.0, 150.0, 1.0, 100, SHAKE_START );				RadiusDamage( CTakeDamageInfo( this, pDriver, flDamage, DMG_BLAST ), vHitPos, flDamageRadius, CLASS_NONE );			}		}		StopFiringLargeGun();	}}