1185 lines
29 KiB
C++
1185 lines
29 KiB
C++
//========= Copyright © 1996-2005, Valve Corporation, All rights reserved. ============//
|
|
//
|
|
// Purpose:
|
|
//
|
|
// $NoKeywords: $
|
|
//
|
|
//=============================================================================//
|
|
// hltvdirector.cpp: implementation of the CHLTVDirector class.
|
|
//
|
|
//////////////////////////////////////////////////////////////////////
|
|
|
|
#include "cbase.h"
|
|
#include "hltvdirector.h"
|
|
#include "KeyValues.h"
|
|
|
|
// memdbgon must be the last include file in a .cpp file!!!
|
|
#include "tier0/memdbgon.h"
|
|
|
|
//////////////////////////////////////////////////////////////////////
|
|
// Construction/Destruction
|
|
//////////////////////////////////////////////////////////////////////
|
|
|
|
|
|
static ConVar tv_delay( "tv_delay", "30", 0, "SourceTV broadcast delay in seconds", true, 0, true, HLTV_MAX_DELAY );
|
|
static ConVar tv_allow_static_shots( "tv_allow_static_shots", "1", 0, "Auto director uses fixed level cameras for shots" );
|
|
static ConVar tv_allow_camera_man( "tv_allow_camera_man", "1", 0, "Auto director allows spectators to become camera man" );
|
|
|
|
static bool GameEventLessFunc( CHLTVGameEvent const &e1, CHLTVGameEvent const &e2 )
|
|
{
|
|
return e1.m_Tick < e2.m_Tick;
|
|
}
|
|
|
|
#define RANDOM_MAX_ELEMENTS 256
|
|
static int s_RndOrder[RANDOM_MAX_ELEMENTS];
|
|
static void InitRandomOrder(int nFields)
|
|
{
|
|
if ( nFields > RANDOM_MAX_ELEMENTS )
|
|
{
|
|
Assert( nFields > RANDOM_MAX_ELEMENTS );
|
|
nFields = RANDOM_MAX_ELEMENTS;
|
|
}
|
|
|
|
for ( int i=0; i<nFields; i++ )
|
|
{
|
|
s_RndOrder[i]=i;
|
|
}
|
|
|
|
for ( int i=0; i<(nFields/2); i++ )
|
|
{
|
|
int pos1 = RandomInt( 0, nFields-1 );
|
|
int pos2 = RandomInt( 0, nFields-1 );
|
|
int temp = s_RndOrder[pos1];
|
|
s_RndOrder[pos1] = s_RndOrder[pos2];
|
|
s_RndOrder[pos2] = temp;
|
|
}
|
|
};
|
|
|
|
|
|
static float WeightedAngle( Vector vec1, Vector vec2)
|
|
{
|
|
VectorNormalize( vec1 );
|
|
VectorNormalize( vec2 );
|
|
|
|
float a = DotProduct( vec1, vec2 ); // a = [-1,1]
|
|
|
|
a = (a + 1.0f) / 2.0f;
|
|
|
|
Assert ( a <= 1 && a >= 0 );
|
|
|
|
return a*a; // vectors are facing opposite direction
|
|
}
|
|
|
|
|
|
|
|
static CHLTVDirector s_HLTVDirector; // singleton
|
|
|
|
EXPOSE_SINGLE_INTERFACE_GLOBALVAR(CHLTVDirector, IHLTVDirector, INTERFACEVERSION_HLTVDIRECTOR, s_HLTVDirector );
|
|
|
|
CHLTVDirector* HLTVDirector()
|
|
{
|
|
return &s_HLTVDirector;
|
|
}
|
|
|
|
IGameSystem* HLTVDirectorSystem()
|
|
{
|
|
return &s_HLTVDirector;
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
CHLTVDirector::CHLTVDirector()
|
|
{
|
|
m_iPVSEntity = 0;
|
|
m_fDelay = 30.0;
|
|
m_iLastPlayer = 1;
|
|
m_pHLTVServer = NULL;
|
|
m_pHLTVClient = NULL;
|
|
m_iCameraMan = 0;
|
|
m_nNumFixedCameras = 0;
|
|
m_EventHistory.SetLessFunc( GameEventLessFunc );
|
|
m_nNextAnalyzeTick = 0;
|
|
m_iCameraManIndex = 0;
|
|
}
|
|
|
|
CHLTVDirector::~CHLTVDirector()
|
|
{
|
|
|
|
}
|
|
|
|
bool CHLTVDirector::Init()
|
|
{
|
|
return gameeventmanager->LoadEventsFromFile( "resource/hltvevents.res" ) > 0;
|
|
}
|
|
|
|
void CHLTVDirector::Shutdown()
|
|
{
|
|
RemoveEventsFromHistory(-1); // all
|
|
}
|
|
|
|
void CHLTVDirector::FireGameEvent( IGameEvent * event )
|
|
{
|
|
if ( !m_pHLTVServer )
|
|
return; // don't do anything
|
|
|
|
CHLTVGameEvent gameevent;
|
|
|
|
gameevent.m_Event = gameeventmanager->DuplicateEvent( event );
|
|
gameevent.m_Priority = event->GetInt( "priority", -1 ); // priorities are leveled between 0..10, -1 means ignore
|
|
gameevent.m_Tick = gpGlobals->tickcount;
|
|
|
|
m_EventHistory.Insert( gameevent );
|
|
}
|
|
|
|
IHLTVServer* CHLTVDirector::GetHLTVServer( void )
|
|
{
|
|
return m_pHLTVServer;
|
|
}
|
|
|
|
void CHLTVDirector::SetHLTVServer( IHLTVServer *hltv )
|
|
{
|
|
RemoveEventsFromHistory(-1); // all
|
|
|
|
if ( hltv )
|
|
{
|
|
m_pHLTVClient = UTIL_PlayerByIndex( hltv->GetHLTVSlot() + 1 );
|
|
|
|
if ( m_pHLTVClient && m_pHLTVClient->IsHLTV() )
|
|
{
|
|
m_pHLTVServer = hltv;
|
|
}
|
|
else
|
|
{
|
|
m_pHLTVServer = NULL;
|
|
Error( "Couldn't find HLTV client player." );
|
|
}
|
|
|
|
// register for events the director needs to know
|
|
ListenForGameEvent( "player_hurt" );
|
|
ListenForGameEvent( "player_death" );
|
|
ListenForGameEvent( "round_end" );
|
|
ListenForGameEvent( "round_start" );
|
|
ListenForGameEvent( "hltv_cameraman" );
|
|
ListenForGameEvent( "hltv_rank_entity" );
|
|
ListenForGameEvent( "hltv_rank_camera" );
|
|
}
|
|
else
|
|
{
|
|
// deactivate HLTV director
|
|
m_pHLTVServer = NULL;
|
|
}
|
|
}
|
|
|
|
bool CHLTVDirector::IsActive( void )
|
|
{
|
|
return (m_pHLTVServer != NULL );
|
|
}
|
|
|
|
float CHLTVDirector::GetDelay( void )
|
|
{
|
|
return m_fDelay;
|
|
}
|
|
|
|
int CHLTVDirector::GetDirectorTick( void )
|
|
{
|
|
// just simple delay it
|
|
return m_nBroadcastTick;
|
|
}
|
|
|
|
int CHLTVDirector::GetPVSEntity( void )
|
|
{
|
|
return m_iPVSEntity;
|
|
}
|
|
|
|
Vector CHLTVDirector::GetPVSOrigin( void )
|
|
{
|
|
return m_vPVSOrigin;
|
|
}
|
|
|
|
void CHLTVDirector::UpdateSettings()
|
|
{
|
|
// set delay
|
|
m_fDelay = tv_delay.GetFloat();
|
|
|
|
int newBroadcastTick = gpGlobals->tickcount;
|
|
|
|
if ( m_fDelay < HLTV_MIN_DIRECTOR_DELAY )
|
|
{
|
|
// instant broadcast, no delay
|
|
m_fDelay = 0.0;
|
|
}
|
|
else
|
|
{
|
|
// broadcast time is current time - delay time
|
|
newBroadcastTick -= TIME_TO_TICKS( m_fDelay );
|
|
}
|
|
|
|
if( (m_nBroadcastTick == 0) && (newBroadcastTick > 0) )
|
|
{
|
|
// we start broadcasting right now, reset NextShotTimer
|
|
m_nNextShotTick = 0;
|
|
}
|
|
|
|
// check if camera man is still valid
|
|
if ( m_iCameraManIndex > 0 )
|
|
{
|
|
CBasePlayer *pPlayer = UTIL_PlayerByIndex( m_iCameraManIndex );
|
|
if ( !pPlayer || pPlayer->GetTeamNumber() != TEAM_SPECTATOR )
|
|
{
|
|
SetCameraMan( 0 );
|
|
}
|
|
}
|
|
|
|
m_nBroadcastTick = MAX( 0, newBroadcastTick );
|
|
}
|
|
|
|
const char** CHLTVDirector::GetModEvents()
|
|
{
|
|
static const char *s_modevents[] =
|
|
{
|
|
"hltv_status",
|
|
"hltv_chat",
|
|
"player_connect",
|
|
"player_disconnect",
|
|
"player_team",
|
|
"player_info",
|
|
"server_cvar",
|
|
"player_death",
|
|
"player_chat",
|
|
"round_start",
|
|
"round_end",
|
|
NULL
|
|
};
|
|
|
|
return s_modevents;
|
|
}
|
|
|
|
|
|
void CHLTVDirector::BuildCameraList( void )
|
|
{
|
|
m_nNumFixedCameras = 0;
|
|
memset( m_pFixedCameras, 0, sizeof ( m_pFixedCameras ) );
|
|
|
|
CBaseEntity *pCamera = gEntList.FindEntityByClassname( NULL, GetFixedCameraEntityName() );
|
|
|
|
while ( pCamera && m_nNumFixedCameras < MAX_NUM_CAMERAS)
|
|
{
|
|
CBaseEntity *pTarget = gEntList.FindEntityByName( NULL, STRING(pCamera->m_target) );
|
|
|
|
if ( pTarget )
|
|
{
|
|
// look at target if any given
|
|
QAngle angles;
|
|
VectorAngles( pTarget->GetAbsOrigin() - pCamera->GetAbsOrigin(), angles );
|
|
pCamera->SetAbsAngles( angles );
|
|
}
|
|
|
|
m_pFixedCameras[m_nNumFixedCameras] = pCamera;
|
|
|
|
m_nNumFixedCameras++;
|
|
pCamera = gEntList.FindEntityByClassname( pCamera, GetFixedCameraEntityName() );
|
|
}
|
|
}
|
|
|
|
// this is called with every new map
|
|
void CHLTVDirector::LevelInitPostEntity( void )
|
|
{
|
|
BuildCameraList();
|
|
|
|
m_vPVSOrigin.Init();
|
|
m_iPVSEntity = 0;
|
|
m_nNextShotTick = 0;
|
|
m_nNextAnalyzeTick = 0;
|
|
m_iCameraManIndex = 0;
|
|
|
|
RemoveEventsFromHistory(-1); // all
|
|
|
|
// DevMsg("HLTV Director: found %i fixed cameras.\n", m_nNumFixedCameras );
|
|
}
|
|
|
|
void CHLTVDirector::FrameUpdatePostEntityThink( void )
|
|
{
|
|
if ( !m_pHLTVServer )
|
|
return; // don't do anything
|
|
|
|
// This function is called each tick
|
|
UpdateSettings(); // update settings from cvars
|
|
|
|
if ( (m_nNextAnalyzeTick < gpGlobals->tickcount) &&
|
|
(m_fDelay >= HLTV_MIN_DIRECTOR_DELAY) )
|
|
{
|
|
m_nNextAnalyzeTick = gpGlobals->tickcount + TIME_TO_TICKS( 0.5f );
|
|
|
|
AnalyzePlayers();
|
|
|
|
AnalyzeCameras();
|
|
}
|
|
|
|
if ( m_nBroadcastTick <= 0 )
|
|
{
|
|
// game start is still in delay loop
|
|
StartDelayMessage();
|
|
}
|
|
else if ( m_nNextShotTick <= m_nBroadcastTick )
|
|
{
|
|
// game is being broadcasted, generate camera shots
|
|
StartNewShot();
|
|
}
|
|
}
|
|
|
|
void CHLTVDirector::StartDelayMessage()
|
|
{
|
|
if ( m_nNextShotTick > gpGlobals->tickcount )
|
|
return;
|
|
|
|
// check the next 8 seconds for interrupts/important events
|
|
m_nNextShotTick = gpGlobals->tickcount + TIME_TO_TICKS( DEF_SHOT_LENGTH );
|
|
|
|
// game hasn't started yet, we are still in the broadcast delay hole
|
|
IGameEvent *msg = gameeventmanager->CreateEvent( "hltv_message", true );
|
|
|
|
if ( msg )
|
|
{
|
|
msg->SetString("text", "Please wait for broadcast to start ..." );
|
|
|
|
// send spectators the HLTV director command as a game event
|
|
m_pHLTVServer->BroadcastEvent( msg );
|
|
gameeventmanager->FreeEvent( msg );
|
|
}
|
|
|
|
StartBestFixedCameraShot( true );
|
|
}
|
|
|
|
void CHLTVDirector::StartBestPlayerCameraShot()
|
|
{
|
|
float flPlayerRanking[MAX_PLAYERS];
|
|
|
|
memset( flPlayerRanking, 0, sizeof(flPlayerRanking) );
|
|
|
|
int firstIndex = FindFirstEvent( m_nBroadcastTick );
|
|
|
|
int index = firstIndex;
|
|
|
|
float flBestRank = -1.0f;
|
|
int iBestCamera = -1;
|
|
int iBestTarget = -1;
|
|
|
|
// sum all ranking values for the cameras
|
|
|
|
while( index != m_EventHistory.InvalidIndex() )
|
|
{
|
|
CHLTVGameEvent &dc = m_EventHistory[index];
|
|
|
|
if ( dc.m_Tick >= m_nNextShotTick )
|
|
break;
|
|
|
|
// search for camera ranking events
|
|
if ( Q_strcmp( dc.m_Event->GetName(), "hltv_rank_entity") == 0 )
|
|
{
|
|
int index = dc.m_Event->GetInt("index");
|
|
|
|
if ( index < MAX_PLAYERS )
|
|
{
|
|
flPlayerRanking[index] += dc.m_Event->GetFloat("rank" );
|
|
|
|
// find best camera
|
|
if ( flPlayerRanking[index] > flBestRank )
|
|
{
|
|
iBestCamera = index;
|
|
flBestRank = flPlayerRanking[index];
|
|
iBestTarget = dc.m_Event->GetInt("target");
|
|
}
|
|
}
|
|
}
|
|
|
|
index = m_EventHistory.NextInorder( index );
|
|
}
|
|
|
|
if ( iBestCamera != -1 )
|
|
{
|
|
// view over shoulder, randomly left or right
|
|
StartChaseCameraShot( iBestCamera, iBestTarget, 112.0f, 20, (RandomFloat()>0.5)?20:-20, false );
|
|
}
|
|
else
|
|
{
|
|
StartBestFixedCameraShot( true );
|
|
}
|
|
}
|
|
|
|
void CHLTVDirector::StartFixedCameraShot(int iCamera, int iTarget)
|
|
{
|
|
CBaseEntity *pCamera = m_pFixedCameras[iCamera];
|
|
|
|
|
|
Vector vCamPos = pCamera->GetAbsOrigin();
|
|
QAngle aViewAngle = pCamera->GetAbsAngles();
|
|
|
|
m_iPVSEntity = 0; // don't use camera entity, since it may not been transmitted
|
|
m_vPVSOrigin = vCamPos;
|
|
|
|
IGameEvent *shot = gameeventmanager->CreateEvent( "hltv_fixed", true );
|
|
|
|
if ( shot )
|
|
{
|
|
shot->SetInt("posx", vCamPos.x );
|
|
shot->SetInt("posy", vCamPos.y );
|
|
shot->SetInt("posz", vCamPos.z );
|
|
shot->SetInt("theta", aViewAngle.x );
|
|
shot->SetInt("phi", aViewAngle.y );
|
|
shot->SetInt("target", iTarget );
|
|
shot->SetFloat("fov", RandomFloat(50,110) );
|
|
|
|
// send spectators the HLTV director command as a game event
|
|
m_pHLTVServer->BroadcastEvent( shot );
|
|
gameeventmanager->FreeEvent( shot );
|
|
}
|
|
}
|
|
|
|
void CHLTVDirector::StartChaseCameraShot(int iTarget1, int iTarget2, int distance, int phi, int theta, bool bInEye)
|
|
{
|
|
IGameEvent *shot = gameeventmanager->CreateEvent( "hltv_chase", true );
|
|
|
|
if ( !shot )
|
|
return;
|
|
|
|
shot->SetInt("target1", iTarget1 );
|
|
shot->SetInt("target2", iTarget2 );
|
|
shot->SetInt("distance", distance );
|
|
shot->SetInt("phi", phi ); // hi/low
|
|
shot->SetInt( "theta", theta ); // left/right
|
|
shot->SetInt( "ineye", bInEye?1:0 );
|
|
|
|
m_iPVSEntity = iTarget1;
|
|
|
|
// send spectators the HLTV director command as a game event
|
|
m_pHLTVServer->BroadcastEvent( shot );
|
|
gameeventmanager->FreeEvent( shot );
|
|
}
|
|
|
|
void CHLTVDirector::StartBestFixedCameraShot( bool bForce )
|
|
{
|
|
float flCameraRanking[MAX_NUM_CAMERAS];
|
|
|
|
if ( m_nNumFixedCameras <= 0 )
|
|
return;
|
|
|
|
memset( flCameraRanking, 0, sizeof(flCameraRanking) );
|
|
|
|
int firstIndex = FindFirstEvent( m_nBroadcastTick );
|
|
|
|
int index = firstIndex;
|
|
|
|
float flBestRank = -1.0f;
|
|
int iBestCamera = -1;
|
|
int iBestTarget = -1;
|
|
|
|
// sum all ranking values for the cameras
|
|
|
|
while( index != m_EventHistory.InvalidIndex() )
|
|
{
|
|
CHLTVGameEvent &dc = m_EventHistory[index];
|
|
|
|
if ( dc.m_Tick >= m_nNextShotTick )
|
|
break;
|
|
|
|
// search for camera ranking events
|
|
if ( Q_strcmp( dc.m_Event->GetName(), "hltv_rank_camera") == 0 )
|
|
{
|
|
int index = dc.m_Event->GetInt("index");
|
|
flCameraRanking[index] += dc.m_Event->GetFloat("rank" );
|
|
|
|
// find best camera
|
|
if ( flCameraRanking[index] > flBestRank )
|
|
{
|
|
iBestCamera = index;
|
|
flBestRank = flCameraRanking[index];
|
|
iBestTarget = dc.m_Event->GetInt("target");
|
|
}
|
|
}
|
|
|
|
index = m_EventHistory.NextInorder( index );
|
|
}
|
|
|
|
if ( !bForce && flBestRank == 0 )
|
|
{
|
|
// if we are not forcing a fixed camera shot, switch to player chase came
|
|
// if no camera shows any players
|
|
StartBestPlayerCameraShot();
|
|
}
|
|
else if ( iBestCamera != -1 )
|
|
{
|
|
StartFixedCameraShot( iBestCamera, iBestTarget );
|
|
}
|
|
}
|
|
|
|
void CHLTVDirector::StartRandomShot()
|
|
{
|
|
int toTick = m_nBroadcastTick + TIME_TO_TICKS ( DEF_SHOT_LENGTH );
|
|
m_nNextShotTick = MIN( m_nNextShotTick, toTick );
|
|
|
|
if ( RandomFloat(0,1) < 0.25 && tv_allow_static_shots.GetBool() )
|
|
{
|
|
// create a static shot from a level camera
|
|
StartBestFixedCameraShot( false );
|
|
}
|
|
else
|
|
{
|
|
// follow a player
|
|
StartBestPlayerCameraShot();
|
|
}
|
|
}
|
|
|
|
void CHLTVDirector::CreateShotFromEvent( CHLTVGameEvent *event )
|
|
{
|
|
// show event at least for 2 more seconds after it occured
|
|
const char *name = event->m_Event->GetName();
|
|
|
|
bool bPlayerHurt = Q_strcmp( "player_hurt", name ) == 0;
|
|
bool bPlayerKilled = Q_strcmp( "player_death", name ) == 0;
|
|
bool bRoundStart = Q_strcmp( "round_start", name ) == 0;
|
|
bool bRoundEnd = Q_strcmp( "round_end", name ) == 0;
|
|
|
|
if ( bPlayerHurt || bPlayerKilled )
|
|
{
|
|
CBaseEntity *victim = UTIL_PlayerByUserId( event->m_Event->GetInt("userid") );
|
|
CBaseEntity *attacker = UTIL_PlayerByUserId( event->m_Event->GetInt("attacker") );
|
|
|
|
if ( !victim )
|
|
return;
|
|
|
|
if ( attacker == victim || attacker == NULL )
|
|
{
|
|
// player killed self or by WORLD
|
|
StartChaseCameraShot( victim->entindex(), 0, 96, 20, 0, false );
|
|
}
|
|
else // attacker != NULL
|
|
{
|
|
// check if we would show it from ineye view
|
|
bool bInEye = (bPlayerKilled && RandomFloat(0,1) > 0.33) || (bPlayerHurt && RandomFloat(0,1) > 0.66);
|
|
|
|
// if we show ineye view, show it more likely from killer
|
|
if ( RandomFloat(0,1) > (bInEye?0.3f:0.7f) )
|
|
{
|
|
V_swap( attacker, victim );
|
|
}
|
|
|
|
// hurting a victim is shown as chase more often
|
|
// view from behind over head
|
|
// lower view point, dramatic
|
|
// view over shoulder, randomly left or right
|
|
StartChaseCameraShot( victim->entindex(), attacker->entindex(), 96, -20, (RandomFloat()>0.5)?30:-30, bInEye );
|
|
}
|
|
|
|
// shot 2 seconds after death/hurt
|
|
m_nNextShotTick = MIN( m_nNextShotTick, (event->m_Tick+TIME_TO_TICKS(2.0)) );
|
|
}
|
|
else if ( bRoundStart || bRoundEnd )
|
|
{
|
|
StartBestFixedCameraShot( false );
|
|
}
|
|
else
|
|
{
|
|
DevMsg( "No known TV shot for event %s\n", name );
|
|
}
|
|
}
|
|
|
|
void CHLTVDirector::CheckHistory()
|
|
{
|
|
int index = m_EventHistory.FirstInorder();
|
|
int lastTick = -1;
|
|
|
|
while ( index != m_EventHistory.InvalidIndex() )
|
|
{
|
|
CHLTVGameEvent &dc = m_EventHistory[index];
|
|
|
|
Assert( lastTick <= dc.m_Tick );
|
|
lastTick = dc.m_Tick;
|
|
|
|
index = m_EventHistory.NextInorder( index );
|
|
}
|
|
}
|
|
|
|
void CHLTVDirector::RemoveEventsFromHistory(int tick)
|
|
{
|
|
int index = m_EventHistory.FirstInorder();
|
|
|
|
while ( index != m_EventHistory.InvalidIndex() )
|
|
{
|
|
CHLTVGameEvent &dc = m_EventHistory[index];
|
|
|
|
if ( (dc.m_Tick < tick) || (tick == -1) )
|
|
{
|
|
gameeventmanager->FreeEvent( dc.m_Event );
|
|
dc.m_Event = NULL;
|
|
m_EventHistory.RemoveAt( index );
|
|
index = m_EventHistory.FirstInorder(); // start again
|
|
}
|
|
else
|
|
{
|
|
index = m_EventHistory.NextInorder( index );
|
|
}
|
|
}
|
|
|
|
#ifdef _DEBUG
|
|
CheckHistory();
|
|
#endif
|
|
}
|
|
|
|
int CHLTVDirector::FindFirstEvent( int tick )
|
|
{
|
|
// TODO cache last queried ticks
|
|
|
|
int index = m_EventHistory.FirstInorder();
|
|
|
|
if ( index == m_EventHistory.InvalidIndex() )
|
|
return index; // no commands in list
|
|
|
|
CHLTVGameEvent *event = &m_EventHistory[index];
|
|
|
|
while ( event->m_Tick < tick )
|
|
{
|
|
index = m_EventHistory.NextInorder( index );
|
|
|
|
if ( index == m_EventHistory.InvalidIndex() )
|
|
break;
|
|
|
|
event = &m_EventHistory[index];
|
|
}
|
|
|
|
return index;
|
|
}
|
|
|
|
bool CHLTVDirector::SetCameraMan( int iPlayerIndex )
|
|
{
|
|
if ( !tv_allow_camera_man.GetBool() )
|
|
return false;
|
|
|
|
if ( m_iCameraManIndex == iPlayerIndex )
|
|
return true;
|
|
|
|
// check if somebody else is already the camera man
|
|
if ( m_iCameraManIndex != 0 && iPlayerIndex != 0 )
|
|
return false;
|
|
|
|
CBasePlayer *pPlayer = NULL;
|
|
|
|
if ( iPlayerIndex > 0 )
|
|
{
|
|
pPlayer = UTIL_PlayerByIndex( iPlayerIndex );
|
|
if ( !pPlayer || pPlayer->GetTeamNumber() != TEAM_SPECTATOR )
|
|
return false;
|
|
}
|
|
|
|
m_iCameraManIndex = iPlayerIndex;
|
|
|
|
// create event for director event history
|
|
IGameEvent *event = gameeventmanager->CreateEvent( "hltv_cameraman" );
|
|
if ( event )
|
|
{
|
|
event->SetInt("index", iPlayerIndex );
|
|
gameeventmanager->FireEvent( event );
|
|
}
|
|
|
|
CRecipientFilter filter;
|
|
|
|
for ( int i = 1; i <= gpGlobals->maxClients; i++ )
|
|
{
|
|
CBasePlayer *pPlayer = UTIL_PlayerByIndex( i );
|
|
|
|
if ( pPlayer && pPlayer->GetTeamNumber() == TEAM_SPECTATOR && !pPlayer->IsFakeClient() )
|
|
{
|
|
filter.AddRecipient( pPlayer );
|
|
}
|
|
}
|
|
|
|
filter.MakeReliable();
|
|
|
|
if ( iPlayerIndex > 0 )
|
|
{
|
|
// tell all spectators that the camera is in use.
|
|
char szText[200];
|
|
Q_snprintf( szText, sizeof(szText), "SourceTV camera is now controlled by %s.", pPlayer->GetPlayerName() );
|
|
UTIL_ClientPrintFilter( filter, HUD_PRINTTALK, szText );
|
|
}
|
|
else
|
|
{
|
|
// tell all spectators that the camera is available again.
|
|
UTIL_ClientPrintFilter( filter, HUD_PRINTTALK, "SourceTV camera switched to auto-director mode." );
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
void CHLTVDirector::FinishCameraManShot()
|
|
{
|
|
Assert( m_iCameraMan == m_iPVSEntity );
|
|
|
|
int index = FindFirstEvent( m_nBroadcastTick );
|
|
|
|
if ( index == m_EventHistory.InvalidIndex() )
|
|
{
|
|
// check next frame again if event history is empty
|
|
m_nNextShotTick = m_nBroadcastTick+1;
|
|
return;
|
|
}
|
|
|
|
m_nNextShotTick = m_nBroadcastTick + TIME_TO_TICKS( MIN_SHOT_LENGTH );
|
|
|
|
//check if camera turns camera off within broadcast time and game time
|
|
while( index != m_EventHistory.InvalidIndex() )
|
|
{
|
|
CHLTVGameEvent &dc = m_EventHistory[index];
|
|
|
|
if ( dc.m_Tick >= m_nNextShotTick )
|
|
break;
|
|
|
|
if ( Q_strcmp( dc.m_Event->GetName(), "hltv_cameraman") == 0 )
|
|
{
|
|
int iNewCameraMan = dc.m_Event->GetInt("index");
|
|
|
|
if ( iNewCameraMan == 0 )
|
|
{
|
|
// camera man switched camera off
|
|
m_nNextShotTick = dc.m_Tick+1;
|
|
m_iCameraMan = 0;
|
|
return;
|
|
}
|
|
}
|
|
|
|
index = m_EventHistory.NextInorder( index );
|
|
}
|
|
|
|
// camera man is still recording and live, resend camera man message
|
|
IGameEvent *msg = gameeventmanager->CreateEvent( "hltv_cameraman", true );
|
|
if ( msg )
|
|
{
|
|
msg->SetInt("index", m_iCameraMan );
|
|
m_pHLTVServer->BroadcastEvent( msg );
|
|
gameeventmanager->FreeEvent( msg );
|
|
}
|
|
|
|
}
|
|
|
|
bool CHLTVDirector::StartCameraManShot()
|
|
{
|
|
Assert( m_nNextShotTick <= m_nBroadcastTick );
|
|
|
|
int index = FindFirstEvent( m_nNextShotTick );
|
|
|
|
// check for cameraman mode
|
|
while( index != m_EventHistory.InvalidIndex() )
|
|
{
|
|
CHLTVGameEvent &dc = m_EventHistory[index];
|
|
|
|
// only check if this is the current tick
|
|
if ( dc.m_Tick > m_nBroadcastTick )
|
|
break;
|
|
|
|
if ( Q_strcmp( dc.m_Event->GetName(), "hltv_cameraman") == 0 )
|
|
{
|
|
if ( dc.m_Event->GetInt("index") > 0 )
|
|
{
|
|
// ok, this guy is now the active camera man
|
|
m_iCameraMan = dc.m_Event->GetInt("index");
|
|
|
|
m_iPVSEntity = m_iCameraMan;
|
|
m_nNextShotTick = m_nBroadcastTick+1; // check setting right on next frame
|
|
|
|
// send camera man command to client
|
|
m_pHLTVServer->BroadcastEvent( dc.m_Event );
|
|
return true;
|
|
}
|
|
}
|
|
|
|
index = m_EventHistory.NextInorder( index );
|
|
}
|
|
|
|
return false; // no camera man found
|
|
}
|
|
|
|
void CHLTVDirector::StartInstantBroadcastShot()
|
|
{
|
|
m_nNextShotTick = m_nBroadcastTick + TIME_TO_TICKS( MAX_SHOT_LENGTH );
|
|
|
|
if ( m_iCameraManIndex > 0 )
|
|
{
|
|
// camera man is still recording and live, resend camera man message
|
|
IGameEvent *msg = gameeventmanager->CreateEvent( "hltv_cameraman", true );
|
|
if ( msg )
|
|
{
|
|
msg->SetInt("index", m_iCameraManIndex );
|
|
m_pHLTVServer->BroadcastEvent( msg );
|
|
gameeventmanager->FreeEvent( msg );
|
|
|
|
m_iPVSEntity = m_iCameraManIndex;
|
|
m_nNextShotTick = m_nBroadcastTick+TIME_TO_TICKS( MIN_SHOT_LENGTH );
|
|
}
|
|
}
|
|
else
|
|
{
|
|
RemoveEventsFromHistory(-1); // all
|
|
|
|
AnalyzePlayers();
|
|
|
|
AnalyzeCameras();
|
|
|
|
StartRandomShot();
|
|
}
|
|
}
|
|
|
|
void CHLTVDirector::StartNewShot()
|
|
{
|
|
// we can remove all events the
|
|
int smallestTick = MAX(0, gpGlobals->tickcount - TIME_TO_TICKS(HLTV_MAX_DELAY) );
|
|
RemoveEventsFromHistory( smallestTick );
|
|
|
|
// if the delay time is to short for autodirector, just show next best thing
|
|
if ( m_fDelay < HLTV_MIN_DIRECTOR_DELAY )
|
|
{
|
|
StartInstantBroadcastShot();
|
|
return;
|
|
}
|
|
|
|
if ( m_iCameraMan > 0 )
|
|
{
|
|
// we already have an active camera man,
|
|
// wait until he releases the "record" lock
|
|
FinishCameraManShot();
|
|
return;
|
|
}
|
|
|
|
if ( StartCameraManShot() )
|
|
{
|
|
// now we have an active camera man
|
|
return;
|
|
}
|
|
|
|
// ok, no camera man active, now check how much time
|
|
// we have for the next shot, if the time diff to the next
|
|
// important event we have to switch to is too short (<2sec)
|
|
// just extent the current shot and don't start a new one
|
|
|
|
// check the next 8 seconds for interrupts/important events
|
|
m_nNextShotTick = m_nBroadcastTick + TIME_TO_TICKS( MAX_SHOT_LENGTH );
|
|
|
|
if ( m_nBroadcastTick <= 0 )
|
|
{
|
|
// game hasn't started yet, we are still in the broadcast delay hole
|
|
IGameEvent *msg = gameeventmanager->CreateEvent( "hltv_message", true );
|
|
|
|
if ( msg )
|
|
{
|
|
msg->SetString("text", "Please wait for broadcast to start ..." );
|
|
|
|
// send spectators the HLTV director command as a game event
|
|
m_pHLTVServer->BroadcastEvent( msg );
|
|
gameeventmanager->FreeEvent( msg );
|
|
}
|
|
|
|
StartBestFixedCameraShot( true );
|
|
return;
|
|
}
|
|
|
|
int index = FindFirstEvent( m_nBroadcastTick );
|
|
|
|
while( index != m_EventHistory.InvalidIndex() )
|
|
{
|
|
CHLTVGameEvent &dc = m_EventHistory[index];
|
|
|
|
if ( dc.m_Tick >= m_nNextShotTick )
|
|
break; // we have searched enough
|
|
|
|
// a camera man is always interrupting auto director
|
|
if ( Q_strcmp( dc.m_Event->GetName(), "hltv_cameraman") == 0 )
|
|
{
|
|
if ( dc.m_Event->GetInt("index") > 0 )
|
|
{
|
|
// stop the next cut when this cameraman starts recording
|
|
m_nNextShotTick = dc.m_Tick;
|
|
break;
|
|
}
|
|
}
|
|
|
|
index = m_EventHistory.NextInorder( index );
|
|
}
|
|
|
|
float flDuration = TICKS_TO_TIME(m_nNextShotTick - m_nBroadcastTick);
|
|
|
|
if ( flDuration < MIN_SHOT_LENGTH )
|
|
return; // not enough time for a new shot
|
|
|
|
// find the most interesting game event for next shot
|
|
CHLTVGameEvent *dc = FindBestGameEvent();
|
|
|
|
if ( dc )
|
|
{
|
|
// show the game event
|
|
CreateShotFromEvent( dc );
|
|
}
|
|
else
|
|
{
|
|
// no interesting events found, start random shot
|
|
StartRandomShot();
|
|
}
|
|
}
|
|
|
|
CHLTVGameEvent *CHLTVDirector::FindBestGameEvent()
|
|
{
|
|
int bestEvent[4];
|
|
int bestEventPrio[4];
|
|
|
|
Q_memset( bestEvent, 0, sizeof(bestEvent) );
|
|
Q_memset( bestEventPrio, 0, sizeof(bestEventPrio) );
|
|
|
|
int index = FindFirstEvent( m_nBroadcastTick );
|
|
|
|
// search for next 4 best events within next 8 seconds
|
|
for (int i = 0; i<4; i ++)
|
|
{
|
|
bestEventPrio[i] = 0;
|
|
bestEvent[i] = 0;
|
|
|
|
int tillTick = m_nBroadcastTick + TIME_TO_TICKS( 2.0f*(1.0f+i) );
|
|
|
|
if ( tillTick > m_nNextShotTick )
|
|
break;
|
|
|
|
// sum all action for the next time
|
|
while ( index != m_EventHistory.InvalidIndex() )
|
|
{
|
|
CHLTVGameEvent &event = m_EventHistory[index];
|
|
|
|
if ( event.m_Tick > tillTick )
|
|
break;
|
|
|
|
int priority = event.m_Priority;
|
|
|
|
if ( priority > bestEventPrio[i] )
|
|
{
|
|
bestEvent[i] = index;
|
|
bestEventPrio[i] = priority;
|
|
}
|
|
|
|
index = m_EventHistory.NextInorder( index );
|
|
}
|
|
}
|
|
|
|
if ( !( bestEventPrio[0] || bestEventPrio[1] || bestEventPrio[2] ) )
|
|
return NULL; // no event found at all, give generic algorithm a chance
|
|
|
|
// camera cut rules :
|
|
|
|
if ( bestEventPrio[1] >= bestEventPrio[0] &&
|
|
bestEventPrio[1] >= bestEventPrio[2] &&
|
|
bestEventPrio[1] >= bestEventPrio[3] )
|
|
{
|
|
return &m_EventHistory[ bestEvent[1] ]; // best case
|
|
}
|
|
else if ( bestEventPrio[0] > bestEventPrio[1] &&
|
|
bestEventPrio[0] > bestEventPrio[2] )
|
|
{
|
|
return &m_EventHistory[ bestEvent[0] ]; // event 0 is very important
|
|
}
|
|
else if ( bestEventPrio[2] > bestEventPrio[3] )
|
|
{
|
|
return &m_EventHistory[ bestEvent[2] ];
|
|
}
|
|
else
|
|
{
|
|
// event 4 is the best but too far away, so show event 1
|
|
if ( bestEvent[0] )
|
|
return &m_EventHistory[ bestEvent[0] ];
|
|
else
|
|
return NULL;
|
|
}
|
|
}
|
|
|
|
void CHLTVDirector::AnalyzeCameras()
|
|
{
|
|
InitRandomOrder( m_nNumFixedCameras );
|
|
|
|
for ( int i = 0; i<m_nNumFixedCameras; i++ )
|
|
{
|
|
int iCameraIndex = s_RndOrder[i];
|
|
CBaseEntity *pCamera = m_pFixedCameras[ iCameraIndex ];
|
|
|
|
float flRank = 0.0f;
|
|
int iClosestPlayer = 0;
|
|
float flClosestPlayerDist = 100000.0f;
|
|
int nCount = 0; // Number of visible targets
|
|
Vector vDistribution; vDistribution.Init(); // distribution of targets
|
|
|
|
Vector vCamPos = pCamera->GetAbsOrigin();
|
|
|
|
for ( int j=0; j<m_nNumActivePlayers; j++ )
|
|
{
|
|
CBasePlayer *pPlayer = m_pActivePlayers[j];
|
|
|
|
Vector vPlayerPos = pPlayer->GetAbsOrigin();
|
|
|
|
float dist = VectorLength( vPlayerPos - vCamPos );
|
|
|
|
if ( dist > 1024.0f || dist < 4.0f )
|
|
continue; // too colse or far away
|
|
|
|
// check visibility
|
|
trace_t tr;
|
|
UTIL_TraceLine( vCamPos, pPlayer->GetAbsOrigin(), MASK_SOLID, pPlayer, COLLISION_GROUP_NONE, &tr );
|
|
|
|
if ( tr.fraction < 1.0 )
|
|
continue; // not visible for camera
|
|
|
|
nCount++;
|
|
|
|
// remember closest player
|
|
if ( dist < flClosestPlayerDist )
|
|
{
|
|
iClosestPlayer = pPlayer->entindex();
|
|
flClosestPlayerDist = dist;
|
|
}
|
|
|
|
Vector v1; AngleVectors( pPlayer->EyeAngles(), &v1 );
|
|
|
|
// check players orientation towards camera
|
|
Vector v2 = vCamPos - vPlayerPos;
|
|
VectorNormalize( v2 );
|
|
|
|
// player/camera cost function:
|
|
flRank += ( 1.0f/sqrt(dist) ) * WeightedAngle( v1, v2 );
|
|
|
|
vDistribution += v2;
|
|
}
|
|
|
|
if ( nCount > 0 )
|
|
{
|
|
// normalize distribution
|
|
flRank *= VectorLength( vDistribution ) / nCount;
|
|
}
|
|
|
|
IGameEvent *event = gameeventmanager->CreateEvent("hltv_rank_camera");
|
|
|
|
if ( event )
|
|
{
|
|
event->SetFloat("rank", flRank );
|
|
event->SetInt("index", iCameraIndex ); // index in m_pFixedCameras
|
|
event->SetInt("target", iClosestPlayer ); // ent index
|
|
gameeventmanager->FireEvent( event );
|
|
}
|
|
}
|
|
}
|
|
|
|
void CHLTVDirector::BuildActivePlayerList()
|
|
{
|
|
// first build list of all active players
|
|
|
|
m_nNumActivePlayers = 0;
|
|
|
|
for ( int i =1; i <= gpGlobals->maxClients; i++ )
|
|
{
|
|
CBasePlayer *pPlayer = UTIL_PlayerByIndex( i );
|
|
|
|
if ( !pPlayer )
|
|
continue;
|
|
|
|
if ( !pPlayer->IsAlive() )
|
|
continue;
|
|
|
|
if ( pPlayer->IsObserver() )
|
|
continue;
|
|
|
|
if ( pPlayer->GetTeamNumber() <= TEAM_SPECTATOR )
|
|
continue;
|
|
|
|
m_pActivePlayers[m_nNumActivePlayers] = pPlayer;
|
|
m_nNumActivePlayers++;
|
|
}
|
|
}
|
|
|
|
void CHLTVDirector::AnalyzePlayers()
|
|
{
|
|
// build list of current active players
|
|
BuildActivePlayerList();
|
|
|
|
// analyzes every active player
|
|
|
|
InitRandomOrder( m_nNumActivePlayers );
|
|
|
|
for ( int i = 0; i<m_nNumActivePlayers; i++ )
|
|
{
|
|
int iPlayerIndex = s_RndOrder[i];
|
|
|
|
CBasePlayer *pPlayer = m_pActivePlayers[ iPlayerIndex ];
|
|
|
|
float flRank = 0.0f;
|
|
int iBestFacingPlayer = 0;
|
|
float flBestFacingPlayer = 0.0f;
|
|
int nCount = 0; // Number of visible targets
|
|
Vector vDistribution; vDistribution.Init(); // distribution of targets
|
|
|
|
Vector vCamPos = pPlayer->GetAbsOrigin();
|
|
|
|
Vector v1; AngleVectors( pPlayer->EyeAngles(), &v1 );
|
|
|
|
v1 *= -1; // inverted
|
|
|
|
for ( int j=0; j<m_nNumActivePlayers; j++ )
|
|
{
|
|
if ( iPlayerIndex == j )
|
|
continue; // don't check against itself
|
|
|
|
CBasePlayer *pOtherPlayer = m_pActivePlayers[j];
|
|
|
|
Vector vPlayerPos = pOtherPlayer->GetAbsOrigin();
|
|
|
|
float dist = VectorLength( vPlayerPos - vCamPos );
|
|
|
|
if ( dist > 1024.0f || dist < 4.0f )
|
|
continue; // too close or far away
|
|
|
|
// check visibility
|
|
trace_t tr;
|
|
UTIL_TraceLine( vCamPos, pOtherPlayer->GetAbsOrigin(), MASK_SOLID, pOtherPlayer, COLLISION_GROUP_NONE, &tr );
|
|
|
|
if ( tr.fraction < 1.0 )
|
|
continue; // not visible for camera
|
|
|
|
nCount++;
|
|
|
|
// check players orientation towards camera
|
|
Vector v2; AngleVectors( pOtherPlayer->EyeAngles(), &v2 );
|
|
|
|
float facing = WeightedAngle( v1, v2 );
|
|
|
|
// remember closest player
|
|
if ( facing > flBestFacingPlayer )
|
|
{
|
|
iBestFacingPlayer = pOtherPlayer->entindex();
|
|
flBestFacingPlayer = facing;
|
|
}
|
|
|
|
// player/camera cost function:
|
|
flRank += ( 1.0f/sqrt(dist) ) * facing;
|
|
|
|
vDistribution += v2;
|
|
}
|
|
|
|
if ( nCount > 0 )
|
|
{
|
|
float flDistribution = VectorLength( vDistribution ) / nCount; // normalize distribution
|
|
flRank *= flDistribution;
|
|
}
|
|
|
|
IGameEvent *event = gameeventmanager->CreateEvent("hltv_rank_entity");
|
|
if ( event )
|
|
{
|
|
event->SetInt("index", pPlayer->entindex() );
|
|
event->SetFloat("rank", flRank );
|
|
event->SetInt("target", iBestFacingPlayer ); // ent index
|
|
gameeventmanager->FireEvent( event );
|
|
}
|
|
}
|
|
}
|
|
|