1HEADmaster

1 files changed, 306 insertions, 0 deletions

diff --git a/public/tier0/vcrmode.h b/public/tier0/vcrmode.h
new file mode 100644
index 0000000..2af8a60
--- /dev/null
+++ b/public/tier0/vcrmode.h
@@ -0,0 +1,306 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: VCR mode records a client's game and allows you to 
+//			play it back and reproduce it exactly. When playing it back, nothing
+//			is simulated on the server, but all server packets are recorded.
+//
+//			Most of the VCR mode functionality is accomplished through hooks
+//			called at various points in the engine.
+//
+// $NoKeywords: $
+//===========================================================================//
+#ifndef VCRMODE_H
+#define VCRMODE_H
+
+#ifdef _WIN32
+#include <process.h>
+#endif
+
+#ifdef _WIN32
+#pragma once
+#endif
+
+#include "tier0/platform.h"
+#include "tier0/vcr_shared.h"
+#include "tier0/dbg.h"
+
+#ifdef POSIX
+DBG_INTERFACE const char *BuildCmdLine( int argc, char **argv, bool fAddSteam = true );
+tchar *GetCommandLine();
+#endif
+
+#ifdef _X360
+#define NO_VCR 1
+#endif
+
+
+// Enclose lines of code in this if you don't want anything in them written to or read from the VCR file.
+#ifndef NO_VCR
+#define NOVCR(x)	\
+{\
+	VCRSetEnabled(0);\
+	x;\
+	VCRSetEnabled(1);\
+}
+#else
+#define NOVCR(x)	\
+{\
+	x;\
+}
+#endif
+
+
+//-----------------------------------------------------------------------------
+// Forward declarations
+//-----------------------------------------------------------------------------
+struct InputEvent_t;
+
+
+//-----------------------------------------------------------------------------
+// Definitions.
+//-----------------------------------------------------------------------------
+enum VCRMode_t
+{
+	VCR_Invalid=-1,
+	VCR_Disabled=0,
+	VCR_Record,
+	VCR_Playback
+};
+
+
+//-----------------------------------------------------------------------------
+// Functions.
+//-----------------------------------------------------------------------------
+abstract_class IVCRHelpers
+{
+public:
+	virtual void	ErrorMessage( const tchar *pMsg ) = 0;
+	virtual void*	GetMainWindow() = 0;
+};
+
+
+// Used by the vcrtrace program.
+abstract_class IVCRTrace
+{
+public:
+	virtual VCREvent	ReadEvent() = 0;
+	virtual void		Read( void *pDest, int size ) = 0;
+};
+
+typedef struct VCR_s
+{
+	// Start VCR record or play.
+	int			(*Start)( tchar const *pFilename, bool bRecord, IVCRHelpers *pHelpers );
+	void		(*End)();
+
+	// Used by the VCR trace app.
+	IVCRTrace*	(*GetVCRTraceInterface)();
+
+	// Get the current mode the VCR is in.
+	VCRMode_t	(*GetMode)();
+
+	// This can be used to block out areas of code that are unpredictable (like things triggered by WM_TIMER messages).
+	// Note: this enables/disables VCR mode usage on a PER-THREAD basis. The assumption is that you're marking out
+	// specific sections of code that you don't want to use VCR mode inside of, but you're not intending to 
+	// stop all the other threads from using VCR mode.
+	void		(*SetEnabled)(int bEnabled);
+
+	// This can be called any time to put in a debug check to make sure things are synchronized.
+	void		(*SyncToken)(tchar const *pToken);
+
+	// Hook for Sys_FloatTime().
+	double		(*Hook_Sys_FloatTime)(double time);
+
+	// Note: this makes no guarantees about msg.hwnd being the same on playback. If it needs to be, then we need to add
+	// an ID system for Windows and store the ID like in Goldsrc.
+	int			(*Hook_PeekMessage)(
+		struct tagMSG *msg, 
+		void *hWnd, 
+		unsigned int wMsgFilterMin, 
+		unsigned int wMsgFilterMax, 
+		unsigned int wRemoveMsg
+		);
+
+	// Call this to record game messages.
+	void		(*Hook_RecordGameMsg)( const InputEvent_t &event );
+	void		(*Hook_RecordEndGameMsg)();
+	
+	// Call this to playback game messages until it returns false.
+	bool		(*Hook_PlaybackGameMsg)( InputEvent_t *pEvent );
+
+	// Hook for recvfrom() calls. This replaces the recvfrom() call.
+	int			(*Hook_recvfrom)(int s, char *buf, int len, int flags, struct sockaddr *from, int *fromlen);
+
+	void		(*Hook_GetCursorPos)(struct tagPOINT *pt);
+	void		(*Hook_ScreenToClient)(void *hWnd, struct tagPOINT *pt);
+
+	void		(*Hook_Cmd_Exec)(tchar **f);
+
+	tchar*		(*Hook_GetCommandLine)();
+
+	// Registry hooks.
+	long		(*Hook_RegOpenKeyEx)( void *hKey, const tchar *lpSubKey, unsigned long ulOptions, unsigned long samDesired, void *pHKey );
+	long		(*Hook_RegSetValueEx)(void *hKey, tchar const *lpValueName, unsigned long Reserved, unsigned long dwType, uint8 const *lpData, unsigned long cbData);
+	long		(*Hook_RegQueryValueEx)(void *hKey, tchar const *lpValueName, unsigned long *lpReserved, unsigned long *lpType, uint8 *lpData, unsigned long *lpcbData);
+	long		(*Hook_RegCreateKeyEx)(void *hKey, tchar const *lpSubKey, unsigned long Reserved, tchar *lpClass, unsigned long dwOptions, unsigned long samDesired, void *lpSecurityAttributes, void *phkResult, unsigned long *lpdwDisposition);
+	void		(*Hook_RegCloseKey)(void *hKey);
+
+	// hInput is a HANDLE.
+	int			(*Hook_GetNumberOfConsoleInputEvents)( void *hInput, unsigned long *pNumEvents );
+
+	// hInput is a HANDLE.
+	// pRecs is an INPUT_RECORD pointer.
+	int			(*Hook_ReadConsoleInput)( void *hInput, void *pRecs, int nMaxRecs, unsigned long *pNumRead );
+
+	
+	// This calls time() then gives you localtime()'s result.
+	void		(*Hook_LocalTime)( struct tm *today );
+
+	short		(*Hook_GetKeyState)( int nVirtKey );
+
+	// TCP calls.
+	int			(*Hook_recv)( int s, char *buf, int len, int flags );
+	int			(*Hook_send)( int s, const char *buf, int len, int flags );
+
+	// These can be used to add events without having to modify VCR mode.
+	// pEventName is used for verification to make sure it's playing back correctly. 
+	// If pEventName is null, then verification is not performed.
+	void		(*GenericRecord)( const tchar *pEventName, const void *pData, int len );
+	
+
+	// Returns the number of bytes written in the generic event.
+	// If bForceLenSame is true, then it will error out unless the value in the VCR file is the same as maxLen.
+	int			(*GenericPlayback)( const tchar *pEventName, void *pOutData, int maxLen, bool bForceLenSame );
+
+	// If you just want to record and playback a value and not worry about whether or not you're
+	// recording or playing back, use this. It also will do nothing if you're not recording or playing back.
+	//
+	// NOTE: also see GenericValueVerify, which allows you to have it VERIFY that pData's contents are the same upon playback
+	// (rather than just copying whatever is in the VCR file into pData).
+	void		(*GenericValue)( const tchar *pEventName, void *pData, int maxLen );
+
+	// Get the current percent (0.0 - 1.0) that it's played back through the file (only valid in playback).
+	double		(*GetPercentCompleted)();
+
+	// If you use this, then any VCR stuff the thread does will work with VCR mode.
+	// This mirrors the Windows API CreateThread function and returns a HANDLE the same way.
+	void*		(*Hook_CreateThread)( 
+		void *lpThreadAttributes,
+		unsigned long dwStackSize,
+		void *lpStartAddress,
+		void *lpParameter,
+		unsigned long dwCreationFlags,
+		unsigned long *lpThreadID );
+	
+	unsigned long (*Hook_WaitForSingleObject)(
+		void *handle,
+		unsigned long dwMilliseconds );
+
+	void		(*Hook_EnterCriticalSection)( void *pCS );
+
+	void		(*Hook_Time)( long *pTime );
+
+	// String value. Playback just verifies that the incoming string is the same as it was when recording.
+	void		(*GenericString)( const char *pEventName, const char *pString );
+
+	// Works like GenericValue, except upon playback it will verify that pData's contents are the same as it was during recording.
+	void		(*GenericValueVerify)( const tchar *pEventName, const void *pData, int maxLen );
+
+	unsigned long (*Hook_WaitForMultipleObjects)( uint32 nHandles, const void **pHandles, int bWaitAll, uint32 timeout );
+
+} VCR_t;
+
+#ifndef NO_VCR
+
+// In the launcher, this is created by vcrmode.c. 
+// In the engine, this is set when the launcher initializes its DLL.
+PLATFORM_INTERFACE VCR_t *g_pVCR;
+
+#endif
+
+
+#ifndef NO_VCR
+#define VCRStart								g_pVCR->Start
+#define VCREnd									g_pVCR->End
+#define VCRGetVCRTraceInterface					g_pVCR->GetVCRTraceInterface
+#define VCRGetMode								g_pVCR->GetMode
+#define VCRSetEnabled							g_pVCR->SetEnabled
+#define VCRSyncToken							g_pVCR->SyncToken
+#define VCRGenericString						g_pVCR->GenericString
+#define VCRGenericValueVerify					g_pVCR->GenericValueVerify
+#define VCRHook_Sys_FloatTime					g_pVCR->Hook_Sys_FloatTime
+#define VCRHook_PeekMessage						g_pVCR->Hook_PeekMessage
+#define VCRHook_RecordGameMsg					g_pVCR->Hook_RecordGameMsg
+#define VCRHook_RecordEndGameMsg				g_pVCR->Hook_RecordEndGameMsg
+#define VCRHook_PlaybackGameMsg					g_pVCR->Hook_PlaybackGameMsg
+#define VCRHook_recvfrom						g_pVCR->Hook_recvfrom
+#define VCRHook_GetCursorPos					g_pVCR->Hook_GetCursorPos
+#define VCRHook_ScreenToClient					g_pVCR->Hook_ScreenToClient
+#define VCRHook_Cmd_Exec						g_pVCR->Hook_Cmd_Exec
+#define VCRHook_GetCommandLine					g_pVCR->Hook_GetCommandLine
+#define VCRHook_RegOpenKeyEx					g_pVCR->Hook_RegOpenKeyEx
+#define VCRHook_RegSetValueEx					g_pVCR->Hook_RegSetValueEx
+#define VCRHook_RegQueryValueEx					g_pVCR->Hook_RegQueryValueEx
+#define VCRHook_RegCreateKeyEx					g_pVCR->Hook_RegCreateKeyEx
+#define VCRHook_RegCloseKey						g_pVCR->Hook_RegCloseKey
+#define VCRHook_GetNumberOfConsoleInputEvents	g_pVCR->Hook_GetNumberOfConsoleInputEvents
+#define VCRHook_ReadConsoleInput				g_pVCR->Hook_ReadConsoleInput
+#define VCRHook_LocalTime						g_pVCR->Hook_LocalTime
+#define VCRHook_GetKeyState						g_pVCR->Hook_GetKeyState
+#define VCRHook_recv							g_pVCR->Hook_recv
+#define VCRHook_send							g_pVCR->Hook_send
+#define VCRGenericRecord						g_pVCR->GenericRecord
+#define VCRGenericPlayback						g_pVCR->GenericPlayback
+#define VCRGenericValue							g_pVCR->GenericValue
+#define VCRGetPercentCompleted					g_pVCR->GetPercentCompleted
+#define VCRHook_CreateThread					g_pVCR->Hook_CreateThread
+#define VCRHook_WaitForSingleObject				g_pVCR->Hook_WaitForSingleObject
+#define VCRHook_EnterCriticalSection			g_pVCR->Hook_EnterCriticalSection
+#define VCRHook_Time							g_pVCR->Hook_Time
+#define VCRHook_WaitForMultipleObjects( a, b, c, d) g_pVCR->Hook_WaitForMultipleObjects( a, (const void **)b, c, d)
+#else
+#define VCRStart( a, b, c )						(1)
+#define VCREnd									((void)(0))
+#define VCRGetVCRTraceInterface					(NULL)
+#define VCRGetMode()							(VCR_Disabled)
+#define VCRSetEnabled( a )						((void)(0))
+#define VCRSyncToken( a )						((void)(0))
+#define VCRGenericRecord						MUST_IFDEF_OUT_GenericRecord
+#define VCRGenericPlayback						MUST_IFDEF_OUT_GenericPlayback
+#define VCRGenericValue							MUST_IFDEF_OUT_GenericValue
+#define VCRGenericString						MUST_IFDEF_OUT_GenericString
+#define VCRGenericValueVerify					MUST_IFDEF_OUT_GenericValueVerify
+#define VCRGetPercentCompleted()				(0.0f)
+#define VCRHook_Sys_FloatTime					Sys_FloatTime
+#define VCRHook_PeekMessage						PeekMessage
+#define VCRHook_RecordGameMsg					RecordGameMsg
+#define VCRHook_RecordEndGameMsg				RecordEndGameMsg
+#define VCRHook_PlaybackGameMsg					PlaybackGameMsg
+#define VCRHook_recvfrom						recvfrom
+#define VCRHook_GetCursorPos					GetCursorPos
+#define VCRHook_ScreenToClient					ScreenToClient
+#define VCRHook_Cmd_Exec( a )					((void)(0))
+#define VCRHook_GetCommandLine					GetCommandLine
+#define VCRHook_RegOpenKeyEx					RegOpenKeyEx
+#define VCRHook_RegSetValueEx					RegSetValueEx
+#define VCRHook_RegQueryValueEx					RegQueryValueEx
+#define VCRHook_RegCreateKeyEx					RegCreateKeyEx
+#define VCRHook_RegCloseKey						RegCloseKey
+#define VCRHook_GetNumberOfConsoleInputEvents	GetNumberOfConsoleInputEvents
+#define VCRHook_ReadConsoleInput				ReadConsoleInput
+#define VCRHook_LocalTime( a )					memset(a, 0, sizeof(*a));
+#define VCRHook_GetKeyState						GetKeyState
+#define VCRHook_recv							recv
+#define VCRHook_send							send
+#if defined( _X360 )
+#define VCRHook_CreateThread					CreateThread
+#else
+#define VCRHook_CreateThread					(void*)_beginthreadex
+#endif
+#define VCRHook_WaitForSingleObject				WaitForSingleObject
+#define VCRHook_EnterCriticalSection			EnterCriticalSection
+#define VCRHook_WaitForMultipleObjects( a, b, c, d) WaitForMultipleObjects( a, (const HANDLE *)b, c, d)
+#define VCRHook_Time							Time
+#endif
+
+#endif // VCRMODE_H