tf_class_commando.cpp

hl2 source code. Do not use it illegal.

		float flDamage = 200;
		// Calculate the damage a player takes based on distance(time).
		//float flDamage = 1.0f - ( ( COMMANDO_BULLRUSH_TIME - m_ClassData.m_flBullRushTime ) * ( 1.0f / COMMANDO_BULLRUSH_TIME ) );
		//flDamage *= 115.0f; // max bullrush damage

		trace_t tr = m_pPlayer->GetTouchTrace();
		CTakeDamageInfo info( m_pPlayer, m_pPlayer, flDamage, DMG_CLUB, DMG_KILL_BULLRUSH );
		CalculateMeleeDamageForce( &info, (tr.endpos - tr.startpos), tr.endpos );
		pTFPlayer->TakeDamage( info );

		CPASAttenuationFilter filter( m_pPlayer, "Commando.BullRushFlesh" );
		CBaseEntity::EmitSound( filter, m_pPlayer->entindex(), "Commando.BullRushFlesh" );

		pTFPlayer->Touch( m_pPlayer ); 
	}
}

//-----------------------------------------------------------------------------
// Purpose: New technology has been gained. Recalculate any class specific technology dependencies.
//-----------------------------------------------------------------------------
void CPlayerClassCommando::GainedNewTechnology( CBaseTechnology *pTechnology )
{
	// Technology handling
	CalculateRush();

	BaseClass::GainedNewTechnology( pTechnology );
}

//-----------------------------------------------------------------------------
// Purpose: Called when we are about to bullrush.
//-----------------------------------------------------------------------------
void CPlayerClassCommando::PreBullRush( void )
{
	// Set the touch function to look for collisions!
	SetClassTouch( m_pPlayer, BullRushTouch );

	// Clear the player hit list.
	m_aHitPlayers.RemoveAll();

	// Start the bull rush sound.
	CPASAttenuationFilter filter( m_pPlayer, "Commando.BullRushScream" );
	filter.MakeReliable();
	CBaseEntity::EmitSound( filter, m_pPlayer->entindex(), "Commando.BullRushScream" );

	// Force the shield down, if it is up.
	CWeaponTwoHandedContainer *pContainer = dynamic_cast<CWeaponTwoHandedContainer*>( m_pPlayer->GetActiveWeapon() );
	if ( pContainer )
	{
		CWeaponCombatShield *pShield = dynamic_cast<CWeaponCombatShield*>( pContainer->GetRightWeapon() );
		if ( pShield )
		{
			pShield->SetShieldUsable( false );
		}
	}
}

//-----------------------------------------------------------------------------
// Purpose: Called when we finish bullrushing.
//-----------------------------------------------------------------------------
void CPlayerClassCommando::PostBullRush( void )
{
	SetClassTouch( m_pPlayer, NULL );

	// Force the shield down, if it is up.
	CWeaponTwoHandedContainer *pContainer = dynamic_cast<CWeaponTwoHandedContainer*>( m_pPlayer->GetActiveWeapon() );
	if ( pContainer )
	{
		CWeaponCombatShield *pShield = dynamic_cast<CWeaponCombatShield*>( pContainer->GetRightWeapon() );
		if ( pShield )
		{
			pShield->SetShieldUsable( true );
		}
	}
}

//-----------------------------------------------------------------------------
// Purpose: Called every frame by postthink
//-----------------------------------------------------------------------------
void CPlayerClassCommando::ClassThink( void )
{
	// Check bullrush
	m_ClassData.m_bCanBullRush = true;

	// Do the init thing here!
	if ( m_bOldBullRush != m_ClassData.m_bBullRush )
	{
		if ( m_ClassData.m_bBullRush )
		{
			PreBullRush();
		}
		else
		{
			PostBullRush();
		}

		m_bOldBullRush = (bool)m_ClassData.m_bBullRush;
	} 

	// Check for melee attack
	if ( m_bCanBoot && m_pPlayer->IsAlive() && m_flNextBootCheck < gpGlobals->curtime )
	{
		m_flNextBootCheck = gpGlobals->curtime + 0.2;

		CBaseEntity *pEntity = NULL;
		Vector vecSrc	 = m_pPlayer->Weapon_ShootPosition( );
		Vector vecDir	 = m_pPlayer->BodyDirection2D( );
		Vector vecTarget = vecSrc + (vecDir * 48);
		for ( CEntitySphereQuery sphere( vecTarget, 16 ); pEntity = sphere.GetCurrentEntity(); sphere.NextEntity() )
		{
			if ( pEntity->IsPlayer() && (pEntity != m_pPlayer) )
			{
				CBaseTFPlayer *pPlayer = (CBaseTFPlayer *)pEntity;
				// Target needs to be on the enemy team
				if ( !pPlayer->IsClass( TFCLASS_UNDECIDED ) && pPlayer->IsAlive() && pPlayer->InSameTeam( m_pPlayer ) == false )
				{
					Boot( pPlayer );
					m_flNextBootCheck = gpGlobals->curtime + 1.5;
				}
			}
		}
	}

	BaseClass::ClassThink();
}


//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CPlayerClassCommando::StartAdrenalinRush( void )
{
	// Am I actually alive?
	if ( !m_pPlayer->IsAlive() )
		return;

	// Do I have rush capability?
	if ( !m_bCanRush )
		return;

	m_bPersonalRush = true;

	// Start adrenalin rushing
	m_pPlayer->AttemptToPowerup( POWERUP_RUSH, class_commando_rush_length.GetFloat() );

	// If I have battlecry, adrenalin up all my nearby teammates
	if ( m_bHasBattlecry )
	{
		// Find nearby teammates
		for ( int i = 0; i < m_pPlayer->GetTFTeam()->GetNumPlayers(); i++ )
		{
			CBaseTFPlayer *pPlayer = (CBaseTFPlayer *)m_pPlayer->GetTFTeam()->GetPlayer(i);
			assert(pPlayer);

			// Is it within range?
			if ( pPlayer != m_pPlayer && (pPlayer->GetAbsOrigin() - m_pPlayer->GetAbsOrigin()).Length() < class_commando_battlecry_radius.GetFloat() )
			{
				// Can I see it?
				trace_t tr;
				UTIL_TraceLine( m_pPlayer->EyePosition(), pPlayer->EyePosition(), MASK_SOLID_BRUSHONLY, m_pPlayer, COLLISION_GROUP_NONE, &tr);
				CBaseEntity *pEntity = tr.m_pEnt;
				if ( (tr.fraction == 1.0) || ( pEntity == pPlayer ) )
				{
					pPlayer->AttemptToPowerup( POWERUP_RUSH, class_commando_battlecry_length.GetFloat() );
				}
			}
		}
	}
}

//-----------------------------------------------------------------------------
// Purpose: Automatic Melee Attack
//-----------------------------------------------------------------------------
void CPlayerClassCommando::Boot( CBaseTFPlayer *pTarget )
{
	CPASAttenuationFilter filter( m_pPlayer, "Commando.BootSwing" );

	CBaseEntity::EmitSound( filter, m_pPlayer->entindex(), "Commando.BootSwing" );
	CBaseEntity::EmitSound( filter, m_pPlayer->entindex(), "Commando.BootHit" );

	// Damage the target
	CTakeDamageInfo info( m_pPlayer, m_pPlayer, 25, DMG_CLUB );
	CalculateMeleeDamageForce( &info, (pTarget->GetAbsOrigin() - m_pPlayer->GetAbsOrigin()), pTarget->GetAbsOrigin() );
	pTarget->TakeDamage( info );

	Vector vecForward;
	AngleVectors( m_pPlayer->GetLocalAngles(), &vecForward );
	// Give it a lot of "in the air"
	vecForward.z = max( 0.8, vecForward.z );
	VectorNormalize( vecForward );

	// Knock the target to the ground for a few seconds (use default duration)
	pTarget->KnockDownPlayer( vecForward, 500.0f, tf_knockdowntime.GetFloat() );

}

//-----------------------------------------------------------------------------
// Purpose: Handle custom commands for this playerclass
//-----------------------------------------------------------------------------
bool CPlayerClassCommando::ClientCommand( const char *pcmd )
{
	return BaseClass::ClientCommand( pcmd );
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CPlayerClassCommando::SetPlayerHull( void )
{
	if ( m_pPlayer->GetFlags() & FL_DUCKING )
	{
		m_pPlayer->SetCollisionBounds( COMMANDOCLASS_HULL_DUCK_MIN, COMMANDOCLASS_HULL_DUCK_MAX );
	}
	else
	{
		m_pPlayer->SetCollisionBounds( COMMANDOCLASS_HULL_STAND_MIN, COMMANDOCLASS_HULL_STAND_MAX );
	}
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CPlayerClassCommando::GetPlayerHull( bool bDucking, Vector &vecMin, Vector &vecMax )
{
	if ( bDucking )
	{
		VectorCopy( COMMANDOCLASS_HULL_DUCK_MIN, vecMin );
		VectorCopy( COMMANDOCLASS_HULL_DUCK_MAX, vecMax );
	}
	else
	{
		VectorCopy( COMMANDOCLASS_HULL_STAND_MIN, vecMin );
		VectorCopy( COMMANDOCLASS_HULL_STAND_MAX, vecMax );
	}
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CPlayerClassCommando::CreatePersonalOrder( void )
{
	if ( CreateInitialOrder() )
		return;

	if ( COrderAssist::CreateOrder( this ) )
		return;

	BaseClass::CreatePersonalOrder();
}


//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CPlayerClassCommando::ResetViewOffset( void )
{
	if ( m_pPlayer )
	{
		m_pPlayer->SetViewOffset( COMMANDOCLASS_VIEWOFFSET_STAND );
	}
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CPlayerClassCommando::InitVCollision( void )
{
	CPhysCollide *pStandModel = PhysCreateBbox( COMMANDOCLASS_HULL_STAND_MIN, COMMANDOCLASS_HULL_STAND_MAX );
	CPhysCollide *pCrouchModel = PhysCreateBbox( COMMANDOCLASS_HULL_DUCK_MIN, COMMANDOCLASS_HULL_DUCK_MAX );
	m_pPlayer->SetupVPhysicsShadow( pStandModel, "tfplayer_commando_stand", pCrouchModel, "tfplayer_commando_crouch" );
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
bool CPlayerClassCommando::CanGetInVehicle( void )
{
	if ( InBullRush() )
		return false;

	return true;
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
int CPlayerClassCommando::ClassCostAdjustment( ResupplyBuyType_t nType )
{
	int nCost = 0;
	if ( nType != RESUPPLY_BUY_HEALTH )
	{
			nCost = RESUPPLY_ROCKET_COST;
	}

	return nCost;
}