hl2sdk/game/server/team_control_point.h

//========= Copyright Valve Corporation, All rights reserved. ============//
//
// Purpose: 
//
//=============================================================================

#ifndef TEAM_CONTROL_POINT_H
#define TEAM_CONTROL_POINT_H
#ifdef _WIN32
#pragma once
#endif

#include "basemultiplayerplayer.h"

// Spawnflags
#define SF_CAP_POINT_HIDEFLAG		(1<<0)
#define SF_CAP_POINT_HIDE_MODEL		(1<<1)
#define SF_CAP_POINT_HIDE_SHADOW	(1<<2)
#define SF_CAP_POINT_NO_CAP_SOUNDS	(1<<3)
#define SF_CAP_POINT_NO_ANNOUNCER	(1<<4)

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
class CTeamControlPoint : public CBaseAnimating
{
	DECLARE_CLASS( CTeamControlPoint, CBaseAnimating );
public:
	DECLARE_DATADESC();

	CTeamControlPoint();

	// Derived, game-specific control points must override these functions
public:
	// Used to find game specific entities
	virtual const char *GetControlPointMasterName( void ) { return "team_control_point_master"; }

public:
	virtual void Spawn( void );
	virtual bool KeyValue( const char *szKeyName, const char *szValue );
	virtual void Precache( void );
	virtual int  DrawDebugTextOverlays( void );

	//Inputs
	inline void Enable( inputdata_t &input )	{ SetActive( false ); }
	inline void Disable( inputdata_t &input )	{ SetActive( true ); }
	void		InputReset( inputdata_t &input );
	void		InputSetOwner( inputdata_t &input );
	void		InputShowModel( inputdata_t &input );
	void		InputHideModel( inputdata_t &input );
	void		InputRoundActivate( inputdata_t &inputdata );
	void		InputSetLocked( inputdata_t &inputdata );
	void		InputSetUnlockTime( inputdata_t &inputdata );

	// Owner handling
	void		ForceOwner( int iTeam ); // used when selecting a specific round to play
	void		SetOwner( int iCapTeam, bool bMakeSound = true, int iNumCappers = 0, int *iCappingPlayers = NULL );
	int			GetOwner( void ) const;
	int			GetDefaultOwner( void ) const;
	bool		RandomOwnerOnRestart( void ){ return m_bRandomOwnerOnRestart; }

	void		SetActive( bool active );
	inline bool	IsActive( void ) { return m_bActive; }
	void		AnimThink( void );

	bool		PointIsVisible( void ) { return !( FBitSet( m_spawnflags, SF_CAP_POINT_HIDEFLAG ) ); }

	inline const char *GetName( void ) { return STRING(m_iszPrintName); }
	int			GetCPGroup( void );
	int			GetPointIndex( void ) { return m_iPointIndex; }
	void		SetPointIndex( int index ) { m_iPointIndex = index; }

	int			GetWarnOnCap( void ) { return m_iWarnOnCap; }
	string_t	GetWarnSound( void ) { return m_iszWarnSound; }

	int			GetTeamIcon( int iTeam );

	int			GetCurrentHudIconIndex( void );
	int			GetHudIconIndexForTeam( int iGameTeam );
	int			GetHudOverlayIndexForTeam( int iGameTeam );
	int			GetPreviousPointForTeam( int iGameTeam, int iPrevPoint );

	void		SetCappersRequiredForTeam( int iGameTeam, int iCappers );

	void		CaptureBlocked( CBaseMultiplayerPlayer *pPlayer, CBaseMultiplayerPlayer *pVictim );

	int			PointValue( void );

	bool		HasBeenContested( void ) const;				// return true if this point has ever been contested, false if the enemy has never contested this point yet
	float		LastContestedAt( void );
	void		SetLastContestedAt( float flTime );

	void		UpdateCapPercentage( void );
	float		GetTeamCapPercentage( int iTeam );

	// The specified player took part in capping this point.
	virtual void PlayerCapped( CBaseMultiplayerPlayer *pPlayer );

	// The specified player blocked the enemy team from capping this point.
	virtual void PlayerBlocked( CBaseMultiplayerPlayer *pPlayer );

	void		CaptureEnd( void );
	void		CaptureStart( int iCapTeam, int iNumCappingPlayers, int *pCappingPlayers );
	void		CaptureInterrupted( bool bBlocked );

	virtual void StopLoopingSounds( void );

	bool		IsLocked( void ){ return m_bLocked; }

	void EXPORT UnlockThink( void );

private:
	void		SendCapString( int iCapTeam, int iNumCappingPlayers, int *pCappingPlayers );
	void		InternalSetOwner( int iCapTeam, bool bMakeSound = true, int iNumCappers = 0, int *iCappingPlayers = NULL );
	void		HandleScoring( int iTeam );
	void		InternalSetLocked( bool bLocked );

	int			m_iTeam;			
	int			m_iDefaultOwner;			// Team that initially owns the cap point
	int			m_iIndex;					// The index of this point in the controlpointArray
	int			m_iWarnOnCap;				// Warn the team that owns the control point when the opposing team starts to capture it.
	string_t	m_iszPrintName;
	string_t	m_iszWarnSound;				// Sound played if the team needs to be warned about this point being captured
	bool		m_bRandomOwnerOnRestart;	// Do we want to randomize the owner after a restart?
	bool		m_bLocked;
	float		m_flUnlockTime;				// Time to unlock

	// We store a copy of this data for each team, +1 for the un-owned state.
	struct perteamdata_t
	{
		perteamdata_t()
		{
			iszCapSound = NULL_STRING;
			iszModel = NULL_STRING;
			iModelBodygroup = -1;
			iIcon = 0;
			iszIcon = NULL_STRING;
			iOverlay = 0;
			iszOverlay = NULL_STRING;
			iPlayersRequired = 0;
			iTimedPoints = 0;
			for ( int i = 0; i < MAX_PREVIOUS_POINTS; i++ )
			{
				iszPreviousPoint[i] = NULL_STRING;
			}
			iTeamPoseParam = 0;
		}

		string_t	iszCapSound;
		string_t	iszModel;
		int			iModelBodygroup;
		int			iTeamPoseParam;
		int			iIcon;
		string_t	iszIcon;
		int			iOverlay;
		string_t	iszOverlay;
		int			iPlayersRequired;
		int			iTimedPoints;
		string_t	iszPreviousPoint[MAX_PREVIOUS_POINTS];
	};
	CUtlVector<perteamdata_t>	m_TeamData;

	COutputEvent	m_OnCapReset;

	COutputEvent	m_OnCapTeam1;
	COutputEvent	m_OnCapTeam2;

	COutputEvent	m_OnOwnerChangedToTeam1;
	COutputEvent	m_OnOwnerChangedToTeam2;

	COutputEvent	m_OnRoundStartOwnedByTeam1;
	COutputEvent	m_OnRoundStartOwnedByTeam2;

	COutputEvent	m_OnUnlocked;

	int			m_bPointVisible;		//should this capture point be visible on the hud?
	int			m_iPointIndex;			//the mapper set index value of this control point

	int			m_iCPGroup;			//the group that this control point belongs to
	bool		m_bActive;			//

	string_t	m_iszName;				//Name used in cap messages

	bool		m_bStartDisabled;

	float		m_flLastContestedAt;

	CSoundPatch *m_pCaptureInProgressSound;
	string_t	m_iszCaptureStartSound;
	string_t	m_iszCaptureEndSound;
	string_t	m_iszCaptureInProgress;
	string_t	m_iszCaptureInterrupted;
};

#endif // TEAM_CONTROL_POINT_H