1018 lines
29 KiB
C++
1018 lines
29 KiB
C++
//========= Copyright Valve Corporation, All rights reserved. ============//
|
|
//
|
|
// Purpose:
|
|
//
|
|
// $NoKeywords: $
|
|
//=============================================================================//
|
|
#include "client_pch.h"
|
|
#include "cl_demoaction.h"
|
|
#include "cl_demoactionmanager.h"
|
|
#include "demo.h"
|
|
#include "shake.h"
|
|
#include "cdll_engine_int.h"
|
|
#include "tmessage.h"
|
|
#include "sound.h"
|
|
#include "soundflags.h"
|
|
#include "cl_demoaction_types.h"
|
|
|
|
// memdbgon must be the last include file in a .cpp file!!!
|
|
#include "tier0/memdbgon.h"
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
// Input : demoframe -
|
|
// demotime -
|
|
//-----------------------------------------------------------------------------
|
|
bool CDemoActionSkipAhead::Update( const DemoActionTimingContext& tc )
|
|
{
|
|
// Not active yet
|
|
if ( !BaseClass::Update( tc ) )
|
|
return false;
|
|
|
|
if ( GetActionFired() )
|
|
{
|
|
return true;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
// Input : *pInitData -
|
|
// Output : Returns true on success, false on failure.
|
|
//-----------------------------------------------------------------------------
|
|
bool CDemoActionSkipAhead::Init( KeyValues *pInitData )
|
|
{
|
|
if ( !BaseClass::Init( pInitData ) )
|
|
return false;
|
|
|
|
SetSkipToTick( pInitData->GetInt( "skiptotick", -1 ) );
|
|
SetSkipToTime( pInitData->GetFloat( "skiptotime", -1.0f ) );
|
|
|
|
return true;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
// Input : buf -
|
|
//-----------------------------------------------------------------------------
|
|
void CDemoActionSkipAhead::SaveKeysToBuffer( int depth, CUtlBuffer& buf )
|
|
{
|
|
BaseClass::SaveKeysToBuffer( depth, buf );
|
|
|
|
if ( m_nSkipToTick != -1 )
|
|
{
|
|
BufPrintf( depth, buf, "skiptotick \"%i\"\n",
|
|
m_nSkipToTick );
|
|
}
|
|
else
|
|
{
|
|
if ( m_flSkipToTime != -1.0f )
|
|
{
|
|
BufPrintf( depth, buf, "skiptotime \"%.3f\"\n",
|
|
m_flSkipToTime );
|
|
}
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
// Input : frame -
|
|
//-----------------------------------------------------------------------------
|
|
void CDemoActionSkipAhead::SetSkipToTick( int frame )
|
|
{
|
|
m_bUsingSkipTick = frame != -1;
|
|
m_nSkipToTick = frame;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
// Input : t -
|
|
//-----------------------------------------------------------------------------
|
|
void CDemoActionSkipAhead::SetSkipToTime( float t )
|
|
{
|
|
m_bUsingSkipTick = !( t != -1.0f );
|
|
m_flSkipToTime = t;
|
|
}
|
|
|
|
void CDemoActionSkipAhead::FireAction( void )
|
|
{
|
|
// demo->StartSkippingAhead( m_bUsingSkipFrame, m_nSkipToFrame, m_flSkipToTime );
|
|
// demo->PushDemoAction( GetActionName() );
|
|
|
|
// Don't this this, instead wait for demo to notify us that it's finished skipping
|
|
// SetFinishedAction( true );
|
|
if ( m_bUsingSkipTick )
|
|
{
|
|
demoplayer->SkipToTick( m_nSkipToTick, false, false );
|
|
}
|
|
else
|
|
{
|
|
demoplayer->SkipToTick( TIME_TO_TICKS(m_flSkipToTime), false, false );
|
|
}
|
|
|
|
SetFinishedAction( true );
|
|
}
|
|
|
|
#include "tier0/memdbgoff.h"
|
|
DECLARE_DEMOACTION( DEMO_ACTION_SKIPAHEAD, CDemoActionSkipAhead );
|
|
#include "tier0/memdbgon.h"
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
// Input : demoframe -
|
|
// demotime -
|
|
//-----------------------------------------------------------------------------
|
|
bool CDemoActionStopPlayback::Update( const DemoActionTimingContext& tc )
|
|
{
|
|
// Not active yet
|
|
if ( !BaseClass::Update( tc ) )
|
|
return false;
|
|
|
|
if ( GetActionFired() )
|
|
{
|
|
return true;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
void CDemoActionStopPlayback::FireAction( void )
|
|
{
|
|
if ( demoplayer->IsPlayingBack() )
|
|
{
|
|
Cbuf_AddText( "disconnect\n" );
|
|
}
|
|
SetActionFired( true );
|
|
}
|
|
|
|
#include "tier0/memdbgoff.h"
|
|
DECLARE_DEMOACTION( DEMO_ACTION_STOPPLAYBACK, CDemoActionStopPlayback );
|
|
#include "tier0/memdbgon.h"
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
// Input : *pInitData -
|
|
// Output : Returns true on success, false on failure.
|
|
//-----------------------------------------------------------------------------
|
|
bool CDemoActionPlayCommands::Init( KeyValues *pInitData )
|
|
{
|
|
if ( !BaseClass::Init( pInitData ) )
|
|
return false;
|
|
|
|
SetCommandStream( pInitData->GetString( "commands", "" ) );
|
|
|
|
return true;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
// Input : *stream -
|
|
//-----------------------------------------------------------------------------
|
|
void CDemoActionPlayCommands::SetCommandStream( char const *stream )
|
|
{
|
|
Q_strncpy( m_szCommandStream, stream, sizeof( m_szCommandStream ) );
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
// Output : char
|
|
//-----------------------------------------------------------------------------
|
|
char const *CDemoActionPlayCommands::GetCommandStream( void ) const
|
|
{
|
|
return m_szCommandStream;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
void CDemoActionPlayCommands::FireAction( void )
|
|
{
|
|
if( GetCommandStream()[0] )
|
|
{
|
|
Cbuf_AddText( va( "%s\n", GetCommandStream() ) );
|
|
}
|
|
SetFinishedAction( true );
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
// Input : buf -
|
|
//-----------------------------------------------------------------------------
|
|
void CDemoActionPlayCommands::SaveKeysToBuffer( int depth, CUtlBuffer& buf )
|
|
{
|
|
BaseClass::SaveKeysToBuffer( depth, buf );
|
|
|
|
BufPrintf( depth, buf, "commands \"%s\"\n",
|
|
GetCommandStream() );
|
|
}
|
|
|
|
#include "tier0/memdbgoff.h"
|
|
DECLARE_DEMOACTION( DEMO_ACTION_PLAYCOMMANDS, CDemoActionPlayCommands );
|
|
#include "tier0/memdbgon.h"
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
// Input : *pInitData -
|
|
// Output : Returns true on success, false on failure.
|
|
//-----------------------------------------------------------------------------
|
|
bool CDemoActionScreenFadeStart::Init( KeyValues *pInitData )
|
|
{
|
|
if ( !BaseClass::Init( pInitData ) )
|
|
return false;
|
|
|
|
float duration = pInitData->GetFloat( "duration", 0.0f );
|
|
float holdTime = pInitData->GetFloat( "holdtime", 0.0f );
|
|
int fadein = pInitData->GetInt( "FFADE_IN", 0 );
|
|
int fadeout = pInitData->GetInt( "FFADE_OUT", 0 );
|
|
int fademodulate = pInitData->GetInt( "FFADE_MODULATE", 0 );
|
|
int fadestayout = pInitData->GetInt( "FFADE_STAYOUT", 0 );
|
|
int fadepurge = pInitData->GetInt( "FFADE_PURGE", 0 );
|
|
int r = pInitData->GetInt( "r", 255 );
|
|
int g = pInitData->GetInt( "g", 255 );
|
|
int b = pInitData->GetInt( "b", 255 );
|
|
int a = pInitData->GetInt( "a", 255 );
|
|
|
|
fade.duration = (unsigned short)((float)(1<<SCREENFADE_FRACBITS) * duration );
|
|
fade.holdTime = (unsigned short)((float)(1<<SCREENFADE_FRACBITS) * holdTime );
|
|
|
|
fade.fadeFlags = 0;
|
|
|
|
if ( fadein )
|
|
{
|
|
fade.fadeFlags |= FFADE_IN;
|
|
}
|
|
if ( fadeout )
|
|
{
|
|
fade.fadeFlags |= FFADE_OUT;
|
|
}
|
|
if ( fademodulate )
|
|
{
|
|
fade.fadeFlags |= FFADE_MODULATE;
|
|
}
|
|
if ( fadestayout )
|
|
{
|
|
fade.fadeFlags |= FFADE_STAYOUT;
|
|
}
|
|
if ( fadepurge )
|
|
{
|
|
fade.fadeFlags |= FFADE_PURGE;
|
|
}
|
|
|
|
fade.r = r;
|
|
fade.g = g;
|
|
fade.b = b;
|
|
fade.a = a;
|
|
|
|
return true;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
// Output : ScreenFade_t const
|
|
//-----------------------------------------------------------------------------
|
|
ScreenFade_t *CDemoActionScreenFadeStart::GetScreenFade( void )
|
|
{
|
|
return &fade;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
void CDemoActionScreenFadeStart::FireAction( void )
|
|
{
|
|
g_ClientDLL->View_Fade( (ScreenFade_t *)GetScreenFade() );
|
|
SetFinishedAction( true );
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
// Input : buf -
|
|
//-----------------------------------------------------------------------------
|
|
void CDemoActionScreenFadeStart::SaveKeysToBuffer( int depth, CUtlBuffer& buf )
|
|
{
|
|
BaseClass::SaveKeysToBuffer( depth, buf );
|
|
|
|
ScreenFade_t const *f = GetScreenFade();
|
|
|
|
float duration = f->duration * (1.0f/(float)(1<<SCREENFADE_FRACBITS));
|
|
float holdTime = f->holdTime * (1.0f/(float)(1<<SCREENFADE_FRACBITS));
|
|
int fadein = f->fadeFlags & FFADE_IN;
|
|
int fadeout = f->fadeFlags & FFADE_OUT;
|
|
int fademodulate = f->fadeFlags & FFADE_MODULATE;
|
|
int fadestayout = f->fadeFlags & FFADE_STAYOUT;
|
|
int fadepurge = f->fadeFlags & FFADE_PURGE;
|
|
|
|
BufPrintf( depth, buf, "duration \"%.3f\"\n", duration );
|
|
BufPrintf( depth, buf, "holdtime \"%.3f\"\n", holdTime );
|
|
|
|
if ( fadein > 0 ) BufPrintf( depth, buf, "FFADE_IN \"1\"\n" );
|
|
if ( fadeout > 0 ) BufPrintf( depth, buf, "FFADE_OUT \"1\"\n" );
|
|
if ( fademodulate > 0 ) BufPrintf( depth, buf, "FFADE_MODULATE \"1\"\n" );
|
|
if ( fadestayout > 0 ) BufPrintf( depth, buf, "FFADE_STAYOUT \"1\"\n" );
|
|
if ( fadepurge > 0 ) BufPrintf( depth, buf, "FFADE_PURGE \"1\"\n" );
|
|
|
|
BufPrintf( depth, buf, "r \"%i\"\n", f->r );
|
|
BufPrintf( depth, buf, "g \"%i\"\n", f->g );
|
|
BufPrintf( depth, buf, "b \"%i\"\n", f->b );
|
|
BufPrintf( depth, buf, "a \"%i\"\n", f->a );
|
|
}
|
|
|
|
#include "tier0/memdbgoff.h"
|
|
DECLARE_DEMOACTION( DEMO_ACTION_SCREENFADE_START, CDemoActionScreenFadeStart );
|
|
#include "tier0/memdbgon.h"
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
// Input : *text -
|
|
//-----------------------------------------------------------------------------
|
|
void CDemoActionTextMessageStart::SetMessageText( char const *text )
|
|
{
|
|
Q_strncpy( m_szMessageText, text, sizeof( m_szMessageText ) );
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
// Output : char const
|
|
//-----------------------------------------------------------------------------
|
|
char const *CDemoActionTextMessageStart::GetMessageText( void ) const
|
|
{
|
|
return m_szMessageText;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
// Input : *font -
|
|
//-----------------------------------------------------------------------------
|
|
void CDemoActionTextMessageStart::SetFontName( char const *font )
|
|
{
|
|
Q_strncpy( m_szVguiFont, font, sizeof( m_szVguiFont ) );
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
// Output : char const
|
|
//-----------------------------------------------------------------------------
|
|
char const *CDemoActionTextMessageStart::GetFontName( void ) const
|
|
{
|
|
if ( !Q_strcasecmp( "TextMessageDefault", m_szVguiFont ) )
|
|
{
|
|
return "";
|
|
}
|
|
return m_szVguiFont;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
// Input : *pInitData -
|
|
// Output : Returns true on success, false on failure.
|
|
//-----------------------------------------------------------------------------
|
|
bool CDemoActionTextMessageStart::Init( KeyValues *pInitData )
|
|
{
|
|
if ( !BaseClass::Init( pInitData ) )
|
|
return false;
|
|
|
|
message.fadein = pInitData->GetFloat( "fadein", 0.0f );
|
|
message.fadeout = pInitData->GetFloat( "fadeout", 0.0f );
|
|
message.holdtime = pInitData->GetFloat( "holdtime", 0.0f );
|
|
message.fxtime = pInitData->GetFloat( "fxtime", 0.0f );
|
|
|
|
message.x = pInitData->GetFloat( "x", 0 );
|
|
message.y = pInitData->GetFloat( "y", 0 );
|
|
|
|
SetMessageText( pInitData->GetString( "message", "" ) );
|
|
SetFontName( pInitData->GetString( "font", "" ) );
|
|
|
|
message.r1 = pInitData->GetInt( "r1", 255 );
|
|
message.g1 = pInitData->GetInt( "g1", 255 );
|
|
message.b1 = pInitData->GetInt( "b1", 255 );
|
|
message.a1 = pInitData->GetInt( "a1", 255 );
|
|
|
|
message.r2 = pInitData->GetInt( "r2", 255 );
|
|
message.g2 = pInitData->GetInt( "g2", 255 );
|
|
message.b2 = pInitData->GetInt( "b2", 255 );
|
|
message.a2 = pInitData->GetInt( "a2", 255 );
|
|
|
|
int fadeinout = pInitData->GetInt( "FADEINOUT", 0 );
|
|
int fadeinoutflicker = pInitData->GetInt( "FLICKER", 0 );
|
|
int fadewriteout = pInitData->GetInt( "WRITEOUT", 0 );
|
|
|
|
message.effect = 0;
|
|
|
|
if ( fadeinout )
|
|
{
|
|
message.effect = 0;
|
|
}
|
|
if ( fadeinoutflicker )
|
|
{
|
|
message.effect = 1;
|
|
}
|
|
if ( fadewriteout )
|
|
{
|
|
message.effect = 2;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
// Output : ScreenFade_t const
|
|
//-----------------------------------------------------------------------------
|
|
client_textmessage_t *CDemoActionTextMessageStart::GetTextMessage( void )
|
|
{
|
|
return &message;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
void CDemoActionTextMessageStart::FireAction( void )
|
|
{
|
|
GetTextMessage()->pVGuiSchemeFontName = GetFontName();
|
|
|
|
TextMessage_DemoMessageFull( GetMessageText(), GetTextMessage() );
|
|
CL_HudMessage( (const char *)DEMO_MESSAGE );
|
|
SetFinishedAction( true );
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
// Input : buf -
|
|
//-----------------------------------------------------------------------------
|
|
void CDemoActionTextMessageStart::SaveKeysToBuffer( int depth, CUtlBuffer& buf )
|
|
{
|
|
BaseClass::SaveKeysToBuffer( depth, buf );
|
|
|
|
client_textmessage_t const *tm = GetTextMessage();
|
|
|
|
int fadeinout = tm->effect == 0 ? 1 : 0;
|
|
int fadeinoutflicker = tm->effect == 1 ? 1 : 0;
|
|
int fadewriteout = tm->effect == 2 ? 1 : 0;
|
|
|
|
BufPrintf( depth, buf, "message \"%s\"\n", GetMessageText() );
|
|
BufPrintf( depth, buf, "font \"%s\"\n", GetFontName() );
|
|
|
|
BufPrintf( depth, buf, "fadein \"%.3f\"\n", tm->fadein );
|
|
BufPrintf( depth, buf, "fadeout \"%.3f\"\n", tm->fadeout );
|
|
BufPrintf( depth, buf, "holdtime \"%.3f\"\n", tm->holdtime );
|
|
BufPrintf( depth, buf, "fxtime \"%.3f\"\n", tm->fxtime );
|
|
|
|
if ( fadeinout > 0 ) BufPrintf( depth, buf, "FADEINOUT \"1\"\n" );
|
|
if ( fadeinoutflicker > 0 ) BufPrintf( depth, buf, "FLICKER \"1\"\n" );
|
|
if ( fadewriteout > 0 ) BufPrintf( depth, buf, "WRITEOUT \"1\"\n" );
|
|
|
|
BufPrintf( depth, buf, "x \"%f\"\n", tm->x );
|
|
BufPrintf( depth, buf, "y \"%f\"\n", tm->y );
|
|
|
|
BufPrintf( depth, buf, "r1 \"%i\"\n", tm->r1 );
|
|
BufPrintf( depth, buf, "g1 \"%i\"\n", tm->g1 );
|
|
BufPrintf( depth, buf, "b1 \"%i\"\n", tm->b1 );
|
|
BufPrintf( depth, buf, "a1 \"%i\"\n", tm->a1 );
|
|
|
|
BufPrintf( depth, buf, "r2 \"%i\"\n", tm->r2 );
|
|
BufPrintf( depth, buf, "g2 \"%i\"\n", tm->g2 );
|
|
BufPrintf( depth, buf, "b2 \"%i\"\n", tm->b2 );
|
|
BufPrintf( depth, buf, "a2 \"%i\"\n", tm->a2 );
|
|
|
|
}
|
|
#include "tier0/memdbgoff.h"
|
|
DECLARE_DEMOACTION( DEMO_ACTION_TEXTMESSAGE_START, CDemoActionTextMessageStart );
|
|
#include "tier0/memdbgon.h"
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
// Input : *pInitData -
|
|
// Output : Returns true on success, false on failure.
|
|
//-----------------------------------------------------------------------------
|
|
bool CDemoActionCDTrackStart::Init( KeyValues *pInitData )
|
|
{
|
|
if ( !BaseClass::Init( pInitData ) )
|
|
return false;
|
|
|
|
SetTrack( pInitData->GetInt( "track", -1 ) );
|
|
|
|
return true;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
// Input : track -
|
|
//-----------------------------------------------------------------------------
|
|
void CDemoActionCDTrackStart::SetTrack( int track )
|
|
{
|
|
m_nCDTrack = track;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
// Output : int
|
|
//-----------------------------------------------------------------------------
|
|
int CDemoActionCDTrackStart::GetTrack( void ) const
|
|
{
|
|
return m_nCDTrack;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
void CDemoActionCDTrackStart::FireAction( void )
|
|
{
|
|
if ( GetTrack() != -1 )
|
|
{
|
|
#if 0
|
|
char szCommand[ 256 ];
|
|
Q_snprintf( szCommand, sizeof( szCommand ), "cd stop\ncd play %i\n", GetTrack() );
|
|
Cbuf_AddText( szCommand );
|
|
#endif
|
|
}
|
|
SetFinishedAction( true );
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
// Input : buf -
|
|
//-----------------------------------------------------------------------------
|
|
void CDemoActionCDTrackStart::SaveKeysToBuffer( int depth, CUtlBuffer& buf )
|
|
{
|
|
BaseClass::SaveKeysToBuffer( depth, buf );
|
|
|
|
BufPrintf( depth, buf, "track \"%i\"\n",
|
|
GetTrack() );
|
|
}
|
|
|
|
#include "tier0/memdbgoff.h"
|
|
DECLARE_DEMOACTION( DEMO_ACTION_PLAYCDTRACK_START, CDemoActionCDTrackStart );
|
|
#include "tier0/memdbgon.h"
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
void CDemoActionCDTrackStop::FireAction( void )
|
|
{
|
|
#if 0
|
|
Cbuf_AddText( "cd stop\n" );
|
|
#endif
|
|
SetFinishedAction( true );
|
|
}
|
|
|
|
#include "tier0/memdbgoff.h"
|
|
DECLARE_DEMOACTION( DEMO_ACTION_PLAYCDTRACK_STOP, CDemoActionCDTrackStop );
|
|
#include "tier0/memdbgon.h"
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
// Input : *pInitData -
|
|
// Output : Returns true on success, false on failure.
|
|
//-----------------------------------------------------------------------------
|
|
bool CDemoActionPlaySoundStart::Init( KeyValues *pInitData )
|
|
{
|
|
if ( !BaseClass::Init( pInitData ) )
|
|
return false;
|
|
|
|
SetSoundName( pInitData->GetString( "sound", "" ) );
|
|
|
|
// FIXME: Could add parsing of attenuation, other sound flags
|
|
|
|
return true;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
// Input : *stream -
|
|
//-----------------------------------------------------------------------------
|
|
void CDemoActionPlaySoundStart::SetSoundName( char const *name )
|
|
{
|
|
Q_strncpy( m_szSoundName, name, sizeof( m_szSoundName ) );
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
// Output : char
|
|
//-----------------------------------------------------------------------------
|
|
char const *CDemoActionPlaySoundStart::GetSoundName( void ) const
|
|
{
|
|
return m_szSoundName;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
void CDemoActionPlaySoundStart::FireAction( void )
|
|
{
|
|
Vector vDummyOrigin;
|
|
vDummyOrigin.Init();
|
|
|
|
CSfxTable *pSound = (CSfxTable*)S_PrecacheSound(GetSoundName());
|
|
if ( pSound )
|
|
{
|
|
StartSoundParams_t params;
|
|
params.staticsound = false;
|
|
params.soundsource = cl.m_nViewEntity;
|
|
params.entchannel = CHAN_AUTO;
|
|
params.pSfx = pSound;
|
|
params.origin = vDummyOrigin;
|
|
params.fvol = 1.0f;
|
|
params.soundlevel = SNDLVL_IDLE;
|
|
params.flags = 0;
|
|
params.pitch = PITCH_NORM;
|
|
|
|
S_StartSound( params );
|
|
}
|
|
|
|
SetFinishedAction( true );
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
// Input : buf -
|
|
//-----------------------------------------------------------------------------
|
|
void CDemoActionPlaySoundStart::SaveKeysToBuffer( int depth, CUtlBuffer& buf )
|
|
{
|
|
BaseClass::SaveKeysToBuffer( depth, buf );
|
|
|
|
BufPrintf( depth, buf, "sound \"%s\"\n", GetSoundName() );
|
|
}
|
|
|
|
#include "tier0/memdbgoff.h"
|
|
DECLARE_DEMOACTION( DEMO_ACTION_PLAYSOUND_START, CDemoActionPlaySoundStart );
|
|
#include "tier0/memdbgon.h"
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
// Input : demoframe -
|
|
// demotime -
|
|
//-----------------------------------------------------------------------------
|
|
bool CBaseDemoActionWithStopTime::Update( const DemoActionTimingContext& tc )
|
|
{
|
|
// Not active yet
|
|
if ( !BaseClass::Update( tc ) )
|
|
return false;
|
|
|
|
if ( GetActionFired() )
|
|
{
|
|
if ( m_bUsingStopTick )
|
|
{
|
|
if ( tc.curtick >= m_nStopTick )
|
|
{
|
|
SetFinishedAction( true );
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if ( tc.curtime >= m_flStopTime )
|
|
{
|
|
SetFinishedAction( true );
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
// Input : *pInitData -
|
|
// Output : Returns true on success, false on failure.
|
|
//-----------------------------------------------------------------------------
|
|
bool CBaseDemoActionWithStopTime::Init( KeyValues *pInitData )
|
|
{
|
|
if ( !BaseClass::Init( pInitData ) )
|
|
return false;
|
|
|
|
SetStopTick( pInitData->GetInt( "stoptick", -1 ) );
|
|
SetStopTime( pInitData->GetFloat( "stoptime", -1.0f ) );
|
|
|
|
return true;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
// Input : buf -
|
|
//-----------------------------------------------------------------------------
|
|
void CBaseDemoActionWithStopTime::SaveKeysToBuffer( int depth, CUtlBuffer& buf )
|
|
{
|
|
BaseClass::SaveKeysToBuffer( depth, buf );
|
|
|
|
if ( m_nStopTick != -1 )
|
|
{
|
|
BufPrintf( depth, buf, "stoptick \"%i\"\n",
|
|
m_nStopTick );
|
|
}
|
|
else
|
|
{
|
|
if ( m_flStopTime != -1.0f )
|
|
{
|
|
BufPrintf( depth, buf, "stoptime \"%.3f\"\n",
|
|
m_flStopTime );
|
|
}
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
// Input : frame -
|
|
//-----------------------------------------------------------------------------
|
|
void CBaseDemoActionWithStopTime::SetStopTick( int tick )
|
|
{
|
|
m_bUsingStopTick = tick != -1;
|
|
m_nStopTick = tick;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
// Input : t -
|
|
//-----------------------------------------------------------------------------
|
|
void CBaseDemoActionWithStopTime::SetStopTime( float t )
|
|
{
|
|
m_bUsingStopTick = !( t != -1.0f );
|
|
m_flStopTime = t;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
CDemoActionChangePlaybackRate::CDemoActionChangePlaybackRate()
|
|
{
|
|
m_flPlaybackRate = 1.0f;
|
|
m_flSavePlaybackRate = 1.0f;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
// Input : *pInitData -
|
|
// Output : Returns true on success, false on failure.
|
|
//-----------------------------------------------------------------------------
|
|
bool CDemoActionChangePlaybackRate::Init( KeyValues *pInitData )
|
|
{
|
|
if ( !BaseClass::Init( pInitData ) )
|
|
return false;
|
|
|
|
SetPlaybackRate( pInitData->GetFloat( "playbackrate", 1.0f ) );
|
|
|
|
return true;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
// Input : buf -
|
|
//-----------------------------------------------------------------------------
|
|
void CDemoActionChangePlaybackRate::SaveKeysToBuffer( int depth, CUtlBuffer& buf )
|
|
{
|
|
BaseClass::SaveKeysToBuffer( depth, buf );
|
|
|
|
BufPrintf( depth, buf, "playbackrate \"%f\"\n", GetPlaybackRate() );
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
// Input : frame -
|
|
//-----------------------------------------------------------------------------
|
|
void CDemoActionChangePlaybackRate::SetPlaybackRate( float rate )
|
|
{
|
|
m_flPlaybackRate = clamp( rate, 0.001f, 1000.0f );
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
// Input : t -
|
|
//-----------------------------------------------------------------------------
|
|
float CDemoActionChangePlaybackRate::GetPlaybackRate( void ) const
|
|
{
|
|
return m_flPlaybackRate;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
void CDemoActionChangePlaybackRate::FireAction( void )
|
|
{
|
|
// m_flSavePlaybackRate = demoplayer->Get GetPlaybackRateModifier();
|
|
demoplayer->SetPlaybackTimeScale( m_flPlaybackRate );
|
|
SetActionFired( true );
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
void CDemoActionChangePlaybackRate::OnActionFinished( void )
|
|
{
|
|
// demo->SetPlaybackRateModifier( m_flSavePlaybackRate );
|
|
}
|
|
|
|
#include "tier0/memdbgoff.h"
|
|
DECLARE_DEMOACTION( DEMO_ACTION_CHANGEPLAYBACKRATE, CDemoActionChangePlaybackRate );
|
|
#include "tier0/memdbgon.h"
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
CDemoActionPausePlayback::CDemoActionPausePlayback()
|
|
{
|
|
m_flPauseTime = 0.0f;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
// Input : *pInitData -
|
|
// Output : Returns true on success, false on failure.
|
|
//-----------------------------------------------------------------------------
|
|
bool CDemoActionPausePlayback::Init( KeyValues *pInitData )
|
|
{
|
|
if ( !BaseClass::Init( pInitData ) )
|
|
return false;
|
|
|
|
SetPauseTime( pInitData->GetFloat( "pausetime", 1.0f ) );
|
|
|
|
return true;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
// Input : buf -
|
|
//-----------------------------------------------------------------------------
|
|
void CDemoActionPausePlayback::SaveKeysToBuffer( int depth, CUtlBuffer& buf )
|
|
{
|
|
BaseClass::SaveKeysToBuffer( depth, buf );
|
|
|
|
BufPrintf( depth, buf, "pausetime \"%f\"\n", GetPauseTime() );
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
// Input : frame -
|
|
//-----------------------------------------------------------------------------
|
|
void CDemoActionPausePlayback::SetPauseTime( float t )
|
|
{
|
|
m_flPauseTime = clamp( t, 0.0f, 300.0f );
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
// Input : t -
|
|
//-----------------------------------------------------------------------------
|
|
float CDemoActionPausePlayback::GetPauseTime( void ) const
|
|
{
|
|
return m_flPauseTime;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
void CDemoActionPausePlayback::FireAction( void )
|
|
{
|
|
demoplayer->PausePlayback( GetPauseTime() );
|
|
SetActionFired( true );
|
|
}
|
|
|
|
#include "tier0/memdbgoff.h"
|
|
DECLARE_DEMOACTION( DEMO_ACTION_PAUSE, CDemoActionPausePlayback );
|
|
#include "tier0/memdbgon.h"
|
|
|
|
extern float scr_demo_override_fov;
|
|
extern float host_time;
|
|
|
|
CDemoActionZoom::CDemoActionZoom()
|
|
{
|
|
m_bSpline = false;
|
|
m_bStayout = false;
|
|
|
|
m_flFinalFOV = 0;
|
|
m_flFOVRateOut = 0; // degress per second
|
|
m_flFOVRateIn = 0; // degrees per second
|
|
m_flHoldTime = 0;
|
|
|
|
//
|
|
m_flFOVStartTime = 0;
|
|
m_flOriginalFOV = 0.0f;
|
|
}
|
|
|
|
bool CDemoActionZoom::Init( KeyValues *pInitData )
|
|
{
|
|
if ( !BaseClass::Init( pInitData ) )
|
|
return false;
|
|
|
|
m_bSpline = pInitData->GetInt( "spline", 1 ) ? true : false;
|
|
m_bStayout = pInitData->GetInt( "stayout", 1 ) ? true : false;
|
|
|
|
m_flFinalFOV = pInitData->GetFloat( "finalfov", 0.0f );
|
|
m_flFOVRateOut = pInitData->GetFloat( "fovrateout", 0.0f );
|
|
m_flFOVRateIn = pInitData->GetFloat( "fovratein", 0.0f );
|
|
m_flHoldTime = pInitData->GetFloat( "fovhold", 0.0f );
|
|
|
|
return true;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
// Input : tc -
|
|
// Output : Returns true on success, false on failure.
|
|
//-----------------------------------------------------------------------------
|
|
bool CDemoActionZoom::Update( const DemoActionTimingContext& tc )
|
|
{
|
|
// Not active yet
|
|
if ( !BaseClass::Update( tc ) )
|
|
return false;
|
|
|
|
if ( GetActionFired() )
|
|
{
|
|
// See if we're done yet
|
|
float elapsed = host_time - m_flFOVStartTime;
|
|
if ( elapsed > m_flFOVRateOut )
|
|
{
|
|
if ( m_bStayout )
|
|
{
|
|
scr_demo_override_fov = m_flFinalFOV;
|
|
SetFinishedAction( true );
|
|
return true;
|
|
}
|
|
|
|
float intime = m_flFOVRateOut + m_flHoldTime;
|
|
if ( elapsed <= intime )
|
|
{
|
|
// still going
|
|
scr_demo_override_fov = m_flFinalFOV;
|
|
return true;
|
|
}
|
|
|
|
float finishtime = intime + m_flFOVRateIn;
|
|
if ( elapsed > finishtime )
|
|
{
|
|
// Finished now
|
|
scr_demo_override_fov = 0.0f;
|
|
SetFinishedAction( true );
|
|
return true;
|
|
}
|
|
|
|
float frac = 0.0f;
|
|
if ( m_flFOVRateIn > 0.0f )
|
|
{
|
|
frac = ( elapsed - intime ) / m_flFOVRateIn;
|
|
}
|
|
if ( m_bSpline )
|
|
{
|
|
frac = 3.0f * frac * frac - 2.0f * frac * frac * frac;
|
|
}
|
|
frac = clamp( frac, 0.0f, 1.0f );
|
|
|
|
frac = 1.0f - frac;
|
|
|
|
scr_demo_override_fov = m_flOriginalFOV + frac * ( m_flFinalFOV - m_flOriginalFOV );
|
|
}
|
|
else
|
|
{
|
|
float frac = 0.0f;
|
|
if ( m_flFOVRateOut > 0.0f )
|
|
{
|
|
frac = elapsed / m_flFOVRateOut;
|
|
}
|
|
if ( m_bSpline )
|
|
{
|
|
frac = 3.0f * frac * frac - 2.0f * frac * frac * frac;
|
|
}
|
|
frac = clamp( frac, 0.0f, 1.0f );
|
|
|
|
scr_demo_override_fov = m_flOriginalFOV + frac * ( m_flFinalFOV - m_flOriginalFOV );
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
void CDemoActionZoom::FireAction( void )
|
|
{
|
|
m_flOriginalFOV = g_EngineRenderer->GetFov();
|
|
scr_demo_override_fov = m_flOriginalFOV;
|
|
m_flFOVStartTime = host_time;
|
|
}
|
|
|
|
void CDemoActionZoom::SaveKeysToBuffer( int depth, CUtlBuffer& buf )
|
|
{
|
|
BaseClass::SaveKeysToBuffer( depth, buf );
|
|
|
|
BufPrintf( depth, buf, "spline \"%i\"\n",
|
|
m_bSpline ? 1 : 0 );
|
|
BufPrintf( depth, buf, "stayout \"%i\"\n",
|
|
m_bStayout ? 1 : 0 );
|
|
|
|
BufPrintf( depth, buf, "finalfov \"%f\"\n",
|
|
m_flFinalFOV );
|
|
BufPrintf( depth, buf, "fovrateout \"%f\"\n",
|
|
m_flFOVRateOut );
|
|
BufPrintf( depth, buf, "fovratein \"%f\"\n",
|
|
m_flFOVRateIn );
|
|
BufPrintf( depth, buf, "fovhold \"%f\"\n",
|
|
m_flHoldTime );
|
|
}
|
|
|
|
#include "tier0/memdbgoff.h"
|
|
DECLARE_DEMOACTION( DEMO_ACTION_ZOOM, CDemoActionZoom );
|
|
#include "tier0/memdbgon.h"
|