tf2/tf2_src/game/shared/SharedFunctorUtils.h

// SharedFunctorUtils.h
// Useful functors for client and server
//========= Copyright Valve Corporation, All rights reserved. ============//

//--------------------------------------------------------------------------------------------------------
/**
* NOTE: The functors in this file should ideally be game-independant, 
* and work for any Source based game
*/
//--------------------------------------------------------------------------------------------------------
#ifndef _SHARED_FUNCTOR_UTILS_H_
#define _SHARED_FUNCTOR_UTILS_H_

#include "debugoverlay_shared.h"
#include "vprof.h"

//--------------------------------------------------------------------------------------------------------
/**
 * Finds visible player on given team that we are pointing at.
 * "team" can be TEAM_ANY 
 * Use with ForEachPlayer()
 */
template < class PlayerType >
class TargetScan
{
public:
	TargetScan( PlayerType *me, int team, float aimTolerance = 0.01f, float maxRange = 2000.0f, float closestPointTestDistance = 50.0f, bool debug = false )
	{
		m_me = me;
		AngleVectors( m_me->EyeAngles(), &m_viewForward );
		m_team = team;
		m_closeDot = 1.0f - aimTolerance;
		m_bestDot = m_closeDot;
		m_maxRange = maxRange;
		m_target = NULL;
		m_closestPointTestDistance = closestPointTestDistance;
		m_debug = debug;
	}


	virtual bool operator() ( PlayerType *them )
	{
		VPROF( "TargetScan()" );
		if ( them != m_me && 
			 them->IsAlive() && 
			 (m_team == TEAM_ANY || them->GetTeamNumber() == m_team) &&
			 IsPotentialTarget( them ) )
		{
			// move the start point out for determining closestPos, to help with close-in checks (healing, etc)
			Vector closestPos;
			Vector start = m_me->EyePosition();
			Vector end = start + m_viewForward * m_closestPointTestDistance;
			Vector testPos;
			CalcClosestPointOnLineSegment( them->WorldSpaceCenter(), start, end, testPos );

			start = them->GetAbsOrigin();
			end = start;
			end.z += them->CollisionProp()->OBBMaxs().z;
			CalcClosestPointOnLineSegment( testPos, start, end, closestPos );
			if ( m_debug )
			{
				NDebugOverlay::Cross3D( closestPos, 1, 255, 255, 255, true, -1.0f );
				NDebugOverlay::Line( end, start, 255, 0, 0, true, -1.0f );
			}

			Vector to = closestPos - m_me->EyePosition();
			to.NormalizeInPlace();

			Vector meRangePoint, themRangePoint;
			m_me->CollisionProp()->CalcNearestPoint( closestPos, &meRangePoint );
			them->CollisionProp()->CalcNearestPoint( meRangePoint, &themRangePoint );
			float range = meRangePoint.DistTo( themRangePoint );

			if ( range > m_maxRange )
			{
				// too far away
				return true;
			}

			float dot = ViewDot( to );
			if ( dot > m_closeDot )
			{
				// target is within angle cone, check visibility
				if ( IsTargetVisible( them ) )
				{
					if ( dot >= m_bestDot )
					{
						m_target = them;
						m_bestDot = dot;
					}

					m_allTargets.AddToTail( them );
				}
			}
		}

		return true;
	}

	PlayerType *GetTarget( void ) const
	{
		return m_target;
	}

	const CUtlVector< PlayerType * > &GetAllTargets( void ) const
	{
		return m_allTargets;
	}

	float GetTargetDot( void ) const
	{
		return m_bestDot;
	}

protected:
	/**
	 * Is the point in our FOV?
	 */
	virtual float ViewDot( const Vector &dir ) const
	{
		return DotProduct( m_viewForward, dir );
	}

	/**
	 * Is the given actor a visible target?
	 */
	virtual bool IsTargetVisible( PlayerType *them ) const
	{
		// The default check is a straight-up IsAbleToSee
		return m_me->IsAbleToSee( them, CBaseCombatCharacter::DISREGARD_FOV ); // already have a dot product checking FOV
	}

	/**
	 * Is the given player a possible target at all?
	 */
	virtual bool IsPotentialTarget( PlayerType *them ) const
	{
		return true;
	}

	PlayerType *m_me;	
	Vector m_viewForward;
	int m_team;

	float m_closeDot;
	float m_bestDot;
	float m_maxRange;
	float m_closestPointTestDistance;
	bool m_debug;

	PlayerType *m_target;
	CUtlVector< PlayerType * > m_allTargets;
};


#endif