First version of the SOurce SDK 2013

2025-09-19 20:16:10 +08:00 · 2013-06-26 15:22:04 -07:00
commit e7d6f4c174
3682 changed files with 1624327 additions and 0 deletions
--- a/common/GameUI/IGameUI.h
+++ b/common/GameUI/IGameUI.h
@ -0,0 +1,121 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+// $NoKeywords: $
+//=============================================================================//
+
+#ifndef IGAMEUI_H
+#define IGAMEUI_H
+#ifdef _WIN32
+#pragma once
+#endif
+
+#include "interface.h"
+#include "vgui/IPanel.h"
+
+#if !defined( _X360 )
+#include "xbox/xboxstubs.h"
+#endif
+
+// reasons why the user can't connect to a game server
+enum ESteamLoginFailure
+{
+	STEAMLOGINFAILURE_NONE,
+	STEAMLOGINFAILURE_BADTICKET,
+	STEAMLOGINFAILURE_NOSTEAMLOGIN,
+	STEAMLOGINFAILURE_VACBANNED,
+	STEAMLOGINFAILURE_LOGGED_IN_ELSEWHERE
+};
+
+enum ESystemNotify
+{
+	SYSTEMNOTIFY_STORAGEDEVICES_CHANGED,
+	SYSTEMNOTIFY_USER_SIGNEDIN,
+	SYSTEMNOTIFY_USER_SIGNEDOUT,
+	SYSTEMNOTIFY_XUIOPENING,
+	SYSTEMNOTIFY_XUICLOSED,
+	SYSTEMNOTIFY_INVITE_SHUTDOWN,	// Cross-game invite is causing us to shutdown
+};
+
+//-----------------------------------------------------------------------------
+// Purpose: contains all the functions that the GameUI dll exports
+//-----------------------------------------------------------------------------
+abstract_class IGameUI 
+{
+public:
+	// initialization/shutdown
+	virtual void Initialize( CreateInterfaceFn appFactory ) = 0;
+	virtual void PostInit() = 0;
+
+	// connect to other interfaces at the same level (gameui.dll/server.dll/client.dll)
+	virtual void Connect( CreateInterfaceFn gameFactory ) = 0;
+
+	virtual void Start() = 0;
+	virtual void Shutdown() = 0;
+	virtual void RunFrame() = 0;
+
+	// notifications
+	virtual void OnGameUIActivated() = 0;
+	virtual void OnGameUIHidden() = 0;
+	
+	// OLD: Use OnConnectToServer2
+	virtual void OLD_OnConnectToServer(const char *game, int IP, int port) = 0; 
+	
+	virtual void OnDisconnectFromServer_OLD( uint8 eSteamLoginFailure, const char *username ) = 0;
+	virtual void OnLevelLoadingStarted(bool bShowProgressDialog) = 0;
+	virtual void OnLevelLoadingFinished(bool bError, const char *failureReason, const char *extendedReason) = 0;
+
+	// level loading progress, returns true if the screen needs updating
+	virtual bool UpdateProgressBar(float progress, const char *statusText) = 0;
+	// Shows progress desc, returns previous setting... (used with custom progress bars )
+	virtual bool SetShowProgressText( bool show ) = 0;
+
+	// !!!!!!!!!members added after "GameUI011" initial release!!!!!!!!!!!!!!!!!!!
+	virtual void ShowNewGameDialog( int chapter ) = 0;
+
+	// Xbox 360
+	virtual void SessionNotification( const int notification, const int param = 0 ) = 0;
+	virtual void SystemNotification( const int notification ) = 0;
+	virtual void ShowMessageDialog( const uint nType, vgui::Panel *pOwner ) = 0;
+	virtual void UpdatePlayerInfo( uint64 nPlayerId, const char *pName, int nTeam, byte cVoiceState, int nPlayersNeeded, bool bHost ) = 0;
+	virtual void SessionSearchResult( int searchIdx, void *pHostData, XSESSION_SEARCHRESULT *pResult, int ping ) = 0;
+	virtual void OnCreditsFinished( void ) = 0;
+
+	// inserts specified panel as background for level load dialog
+	virtual void SetLoadingBackgroundDialog( vgui::VPANEL panel ) = 0;
+
+	// Bonus maps interfaces
+	virtual void BonusMapUnlock( const char *pchFileName = NULL, const char *pchMapName = NULL ) = 0;
+	virtual void BonusMapComplete( const char *pchFileName = NULL, const char *pchMapName = NULL ) = 0;
+	virtual void BonusMapChallengeUpdate( const char *pchFileName, const char *pchMapName, const char *pchChallengeName, int iBest ) = 0;
+	virtual void BonusMapChallengeNames( char *pchFileName, char *pchMapName, char *pchChallengeName ) = 0;
+	virtual void BonusMapChallengeObjectives( int &iBronze, int &iSilver, int &iGold ) = 0;
+	virtual void BonusMapDatabaseSave( void ) = 0;
+	virtual int BonusMapNumAdvancedCompleted( void ) = 0;
+	virtual void BonusMapNumMedals( int piNumMedals[ 3 ] ) = 0;
+
+	virtual void OnConnectToServer2(const char *game, int IP, int connectionPort, int queryPort) = 0;
+
+	// X360 Storage device validation:
+	//		returns true right away if storage device has been previously selected.
+	//		otherwise returns false and will set the variable pointed by pStorageDeviceValidated to 1
+	//				  once the storage device is selected by user.
+	virtual bool ValidateStorageDevice( int *pStorageDeviceValidated ) = 0;
+
+	virtual void SetProgressOnStart() = 0;
+	virtual void OnDisconnectFromServer( uint8 eSteamLoginFailure ) = 0;
+
+	virtual void OnConfirmQuit( void ) = 0;
+
+	virtual bool IsMainMenuVisible( void ) = 0;
+
+	// Client DLL is providing us with a panel that it wants to replace the main menu with
+	virtual void SetMainMenuOverride( vgui::VPANEL panel ) = 0;
+	// Client DLL is telling us that a main menu command was issued, probably from its custom main menu panel
+	virtual void SendMainMenuCommand( const char *pszCommand ) = 0;
+};
+
+#define GAMEUI_INTERFACE_VERSION "GameUI011"
+
+#endif // IGAMEUI_H
--- a/common/compiledcaptionswap.cpp
+++ b/common/compiledcaptionswap.cpp
@ -0,0 +1,103 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: Swap a compiled caption file.
+//
+// $NoKeywords: $
+//=============================================================================//
+
+#include "utlbuffer.h"
+#include "byteswap.h"
+#include "filesystem.h"
+#include "tier2/fileutils.h"
+#include "captioncompiler.h"
+
+// memdbgon must be the last include file in a .cpp file!!!
+#include "tier0/memdbgon.h"
+
+BEGIN_BYTESWAP_DATADESC( CompiledCaptionHeader_t )
+	DEFINE_FIELD( magic, FIELD_INTEGER ),
+	DEFINE_FIELD( version, FIELD_INTEGER ),
+	DEFINE_FIELD( numblocks, FIELD_INTEGER ),
+	DEFINE_FIELD( blocksize, FIELD_INTEGER ),
+	DEFINE_FIELD( directorysize, FIELD_INTEGER ),
+	DEFINE_FIELD( dataoffset, FIELD_INTEGER ),
+END_BYTESWAP_DATADESC()
+
+BEGIN_BYTESWAP_DATADESC( CaptionLookup_t )
+	DEFINE_FIELD( hash, FIELD_INTEGER ),
+	DEFINE_FIELD( blockNum, FIELD_INTEGER ),
+	DEFINE_FIELD( offset, FIELD_SHORT ),
+	DEFINE_FIELD( length, FIELD_SHORT ),
+END_BYTESWAP_DATADESC()
+
+//-----------------------------------------------------------------------------
+// Swap a compiled closecaption file 
+//-----------------------------------------------------------------------------
+bool SwapClosecaptionFile( void *pData )
+{
+	CByteswap swap;
+	swap.ActivateByteSwapping( true );
+
+	CompiledCaptionHeader_t *pHdr = (CompiledCaptionHeader_t*)pData;
+
+	if ( IsX360() )
+	{
+		// pre-swap file header
+		swap.SwapFieldsToTargetEndian( pHdr );
+	}
+
+	if ( pHdr->magic != COMPILED_CAPTION_FILEID || pHdr->version != COMPILED_CAPTION_VERSION )
+	{
+		// bad data
+		return false;
+	}
+
+	// lookup headers
+	pData = (byte*)pData + sizeof(CompiledCaptionHeader_t);
+	swap.SwapFieldsToTargetEndian( (CaptionLookup_t*)pData, pHdr->directorysize );
+
+	// unicode data
+	pData = (byte*)pHdr + pHdr->dataoffset;
+	swap.SwapBufferToTargetEndian( (wchar_t*)pData, (wchar_t*)pData, pHdr->numblocks * pHdr->blocksize / sizeof(wchar_t) );
+
+	if ( IsPC() )
+	{
+		// post-swap file header
+		swap.SwapFieldsToTargetEndian( pHdr );
+	}
+
+	return true;
+}
+
+#if defined( CLIENT_DLL )
+//-----------------------------------------------------------------------------
+// Callback for UpdateOrCreate - generates .360 file
+//-----------------------------------------------------------------------------
+static bool CaptionCreateCallback( const char *pSourceName, const char *pTargetName, const char *pPathID, void *pExtraData )
+{
+	// Generate the file
+	CUtlBuffer buf;
+	bool bOk = g_pFullFileSystem->ReadFile( pSourceName, pPathID, buf );
+	if ( bOk )
+	{
+		bOk = SwapClosecaptionFile( buf.Base() );
+		if ( bOk )
+		{
+			bOk = g_pFullFileSystem->WriteFile( pTargetName, pPathID, buf );
+		}
+		else
+		{
+			Warning( "Failed to create %s\n", pTargetName );
+		}
+	}
+	return bOk;
+}
+
+//-----------------------------------------------------------------------------
+// Calls utility function UpdateOrCreate
+//-----------------------------------------------------------------------------
+int UpdateOrCreateCaptionFile( const char *pSourceName, char *pTargetName, int maxLen, bool bForce )
+{
+	return ::UpdateOrCreate( pSourceName, pTargetName, maxLen, "GAME", CaptionCreateCallback, bForce );
+}
+#endif
--- a/common/hl2orange.spa.h
+++ b/common/hl2orange.spa.h
@ -0,0 +1,370 @@
+////////////////////////////////////////////////////////////////////
+//
+// hl2orange.spa.h
+//
+// Auto-generated on Thursday, 13 September 2007 at 16:59:17
+// XLAST project version 1.0.402.0
+// SPA Compiler version 2.0.6274.0
+//
+////////////////////////////////////////////////////////////////////
+
+#ifndef __THE_ORANGE_BOX_SPA_H__
+#define __THE_ORANGE_BOX_SPA_H__
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+//
+// Title info
+//
+
+#define TITLEID_THE_ORANGE_BOX                      0x4541080F
+
+//
+// Context ids
+//
+// These values are passed as the dwContextId to XUserSetContext.
+//
+
+#define CONTEXT_CHAPTER_HL2                         0
+#define CONTEXT_SCENARIO                            1
+#define CONTEXT_GAME                                2
+#define CONTEXT_CHAPTER_EP1                         3
+#define CONTEXT_CHAPTER_EP2                         4
+#define CONTEXT_CHAPTER_PORTAL                      5
+
+//
+// Context values
+//
+// These values are passed as the dwContextValue to XUserSetContext.
+//
+
+// Values for CONTEXT_CHAPTER_HL2
+
+#define CONTEXT_CHAPTER_HL2_POINT_INSERTION         0
+#define CONTEXT_CHAPTER_HL2_A_RED_LETTER_DAY        1
+#define CONTEXT_CHAPTER_HL2_ROUTE_KANAL             2
+#define CONTEXT_CHAPTER_HL2_WATER_HAZARD            3
+#define CONTEXT_CHAPTER_HL2_BLACK_MESA_EAST         4
+#define CONTEXT_CHAPTER_HL2_RAVENHOLM               5
+#define CONTEXT_CHAPTER_HL2_HIGHWAY_17              6
+#define CONTEXT_CHAPTER_HL2_SANDTRAPS               7
+#define CONTEXT_CHAPTER_HL2_NOVA_PROSPEKT           8
+#define CONTEXT_CHAPTER_HL2_ENTANGLEMENT            9
+#define CONTEXT_CHAPTER_HL2_ANTICITIZEN_ONE         10
+#define CONTEXT_CHAPTER_HL2_FOLLOW_FREEMAN          11
+#define CONTEXT_CHAPTER_HL2_OUR_BENEFACTORS         12
+#define CONTEXT_CHAPTER_HL2_DARK_ENERGY             13
+
+// Values for CONTEXT_SCENARIO
+
+#define CONTEXT_SCENARIO_CTF_2FORT                  0
+#define CONTEXT_SCENARIO_CP_DUSTBOWL                1
+#define CONTEXT_SCENARIO_CP_GRANARY                 2
+#define CONTEXT_SCENARIO_CP_WELL                    3
+#define CONTEXT_SCENARIO_CP_GRAVELPIT               4
+#define CONTEXT_SCENARIO_TC_HYDRO                   5
+#define CONTEXT_SCENARIO_CTF_CLOAK                  6
+#define CONTEXT_SCENARIO_CP_CLOAK                   7
+
+// Values for CONTEXT_GAME
+
+#define CONTEXT_GAME_GAME_HALF_LIFE_2               0
+#define CONTEXT_GAME_GAME_EPISODE_ONE               1
+#define CONTEXT_GAME_GAME_EPISODE_TWO               2
+#define CONTEXT_GAME_GAME_PORTAL                    3
+#define CONTEXT_GAME_GAME_TEAM_FORTRESS             4
+
+// Values for CONTEXT_CHAPTER_EP1
+
+#define CONTEXT_CHAPTER_EP1_UNDUE_ALARM             0
+#define CONTEXT_CHAPTER_EP1_DIRECT_INTERVENTION     1
+#define CONTEXT_CHAPTER_EP1_LOWLIFE                 2
+#define CONTEXT_CHAPTER_EP1_URBAN_FLIGHT            3
+#define CONTEXT_CHAPTER_EP1_EXIT_17                 4
+
+// Values for CONTEXT_CHAPTER_EP2
+
+#define CONTEXT_CHAPTER_EP2_TO_THE_WHITE_FOREST     0
+#define CONTEXT_CHAPTER_EP2_THIS_VORTAL_COIL        1
+#define CONTEXT_CHAPTER_EP2_FREEMAN_PONTIFEX        2
+#define CONTEXT_CHAPTER_EP2_RIDING_SHOTGUN          3
+#define CONTEXT_CHAPTER_EP2_UNDER_THE_RADAR         4
+#define CONTEXT_CHAPTER_EP2_OUR_MUTUAL_FIEND        5
+#define CONTEXT_CHAPTER_EP2_T_MINUS_ONE             6
+
+// Values for CONTEXT_CHAPTER_PORTAL
+
+#define CONTEXT_CHAPTER_PORTAL_TESTCHAMBER_00       0
+#define CONTEXT_CHAPTER_PORTAL_TESTCHAMBER_04       1
+#define CONTEXT_CHAPTER_PORTAL_TESTCHAMBER_08       2
+#define CONTEXT_CHAPTER_PORTAL_TESTCHAMBER_10       3
+#define CONTEXT_CHAPTER_PORTAL_TESTCHAMBER_13       4
+#define CONTEXT_CHAPTER_PORTAL_TESTCHAMBER_14       5
+#define CONTEXT_CHAPTER_PORTAL_TESTCHAMBER_15       6
+#define CONTEXT_CHAPTER_PORTAL_TESTCHAMBER_16       7
+#define CONTEXT_CHAPTER_PORTAL_TESTCHAMBER_17       8
+#define CONTEXT_CHAPTER_PORTAL_TESTCHAMBER_18       9
+#define CONTEXT_CHAPTER_PORTAL_TESTCHAMBER_19       10
+
+// Values for X_CONTEXT_PRESENCE
+
+#define CONTEXT_PRESENCE_TF_CP                      0
+#define CONTEXT_PRESENCE_TF_CTF_LOSING              1
+#define CONTEXT_PRESENCE_TF_CTF_TIED                2
+#define CONTEXT_PRESENCE_TF_CTF_WINNING             3
+#define CONTEXT_PRESENCE_APPCHOOSER                 4
+#define CONTEXT_PRESENCE_MENU                       5
+#define CONTEXT_PRESENCE_EP1_INGAME                 6
+#define CONTEXT_PRESENCE_HL2_INGAME                 7
+#define CONTEXT_PRESENCE_EP2_INGAME                 8
+#define CONTEXT_PRESENCE_PORTAL_INGAME              9
+#define CONTEXT_PRESENCE_COMMENTARY                 10
+#define CONTEXT_PRESENCE_IDLE                       11
+
+// Values for X_CONTEXT_GAME_MODE
+
+#define CONTEXT_GAME_MODE_MULTIPLAYER               0
+#define CONTEXT_GAME_MODE_SINGLEPLAYER              1
+
+//
+// Property ids
+//
+// These values are passed as the dwPropertyId value to XUserSetProperty
+// and as the dwPropertyId value in the XUSER_PROPERTY structure.
+//
+
+#define PROPERTY_CAPS_OWNED                         0x10000000
+#define PROPERTY_CAPS_TOTAL                         0x10000001
+#define PROPERTY_PLAYER_TEAM_SCORE                  0x10000002
+#define PROPERTY_OPPONENT_TEAM_SCORE                0x10000003
+#define PROPERTY_FLAG_CAPTURE_LIMIT                 0x1000000B
+#define PROPERTY_NUMBER_OF_ROUNDS                   0x1000000C
+#define PROPERTY_GAME_SIZE                          0x1000000D
+#define PROPERTY_AUTOBALANCE                        0x1000000E
+#define PROPERTY_PRIVATE_SLOTS                      0x1000000F
+#define PROPERTY_MAX_GAME_TIME                      0x10000010
+#define PROPERTY_NUMBER_OF_KILLS                    0x10000011
+#define PROPERTY_DAMAGE_DEALT                       0x10000012
+#define PROPERTY_PLAY_TIME                          0x10000013
+#define PROPERTY_POINT_CAPTURES                     0x10000014
+#define PROPERTY_POINT_DEFENSES                     0x10000015
+#define PROPERTY_DOMINATIONS                        0x10000016
+#define PROPERTY_REVENGE                            0x10000017
+#define PROPERTY_BUILDINGS_DESTROYED                0x10000019
+#define PROPERTY_HEADSHOTS                          0x1000001A
+#define PROPERTY_HEALTH_POINTS_HEALED               0x1000001B
+#define PROPERTY_INVULNS                            0x1000001C
+#define PROPERTY_KILL_ASSISTS                       0x1000001D
+#define PROPERTY_BACKSTABS                          0x1000001E
+#define PROPERTY_HEALTH_POINTS_LEACHED              0x1000001F
+#define PROPERTY_BUILDINGS_BUILT                    0x10000020
+#define PROPERTY_SENTRY_KILLS                       0x10000021
+#define PROPERTY_TELEPORTS                          0x10000022
+#define PROPERTY_KILLS                              0x10000023
+#define PROPERTY_NUMBER_OF_TEAMS                    0x10000025
+#define PROPERTY_TEAM_RED                           0x10000026
+#define PROPERTY_TEAM_BLUE                          0x10000027
+#define PROPERTY_TEAM_SPECTATOR                     0x10000028
+#define PROPERTY_TEAM                               0x10000029
+#define PROPERTY_WIN_LIMIT                          0x1000002A
+#define PROPERTY_RANKING_TEST                       0x2000000A
+#define PROPERTY_POINTS_SCORED                      0x20000018
+
+//
+// Achievement ids
+//
+// These values are used in the dwAchievementId member of the
+// XUSER_ACHIEVEMENT structure that is used with
+// XUserWriteAchievements and XUserCreateAchievementEnumerator.
+//
+
+#define ACHIEVEMENT_HLX_KILL_ENEMIES_WITHPHYSICS    43
+#define ACHIEVEMENT_HLX_KILL_ENEMY_WITHHOPPERMINE   44
+#define ACHIEVEMENT_HLX_KILL_ENEMIES_WITHMANHACK    45
+#define ACHIEVEMENT_HLX_KILL_SOLDIER_WITHHISGRENADE 46
+#define ACHIEVEMENT_HLX_KILL_ENEMIES_WITHONEENERGYBALL 47
+#define ACHIEVEMENT_HLX_KILL_ELITESOLDIER_WITHHISENERGYBALL 48
+#define ACHIEVEMENT_EPX_GET_ZOMBINEGRENADE          50
+#define ACHIEVEMENT_EPX_KILL_ZOMBIES_WITHFLARES     51
+#define ACHIEVEMENT_HL2_HIT_CANCOP_WITHCAN          52
+#define ACHIEVEMENT_HL2_PUT_CANINTRASH              53
+#define ACHIEVEMENT_HL2_ESCAPE_APARTMENTRAID        54
+#define ACHIEVEMENT_HL2_BREAK_MINITELEPORTER        55
+#define ACHIEVEMENT_HL2_GET_CROWBAR                 56
+#define ACHIEVEMENT_HL2_KILL_BARNACLESWITHBARREL    57
+#define ACHIEVEMENT_HL2_GET_AIRBOAT                 58
+#define ACHIEVEMENT_HL2_GET_AIRBOATGUN              60
+#define ACHIEVEMENT_HL2_FIND_VORTIGAUNTCAVE         61
+#define ACHIEVEMENT_HL2_KILL_CHOPPER                62
+#define ACHIEVEMENT_HL2_FIND_HEVFACEPLATE           63
+#define ACHIEVEMENT_HL2_GET_GRAVITYGUN              64
+#define ACHIEVEMENT_HL2_MAKEABASKET                 65
+#define ACHIEVEMENT_HL2_BEAT_RAVENHOLM_NOWEAPONS    66
+#define ACHIEVEMENT_HL2_BEAT_CEMETERY               67
+#define ACHIEVEMENT_HL2_KILL_ENEMIES_WITHCRANE      68
+#define ACHIEVEMENT_HL2_PIN_SOLDIER_TOBILLBOARD     69
+#define ACHIEVEMENT_HL2_KILL_ODESSAGUNSHIP          70
+#define ACHIEVEMENT_HL2_KILL_THREEGUNSHIPS          71
+#define ACHIEVEMENT_HL2_BEAT_DONTTOUCHSAND          72
+#define ACHIEVEMENT_HL2_KILL_ENEMIES_WITHANTLIONS   74
+#define ACHIEVEMENT_HL2_KILL_ENEMY_WITHTOILET       75
+#define ACHIEVEMENT_HL2_BEAT_TURRETSTANDOFF2        76
+#define ACHIEVEMENT_HL2_BEAT_TOXICTUNNEL            78
+#define ACHIEVEMENT_HL2_BEAT_PLAZASTANDOFF          79
+#define ACHIEVEMENT_HL2_KILL_ALLC1709SNIPERS        80
+#define ACHIEVEMENT_HL2_BEAT_SUPRESSIONDEVICE       81
+#define ACHIEVEMENT_HL2_BEAT_C1713STRIDERSTANDOFF   82
+#define ACHIEVEMENT_HL2_BEAT_GAME                   84
+#define ACHIEVEMENT_HL2_FIND_ALLLAMBDAS             86
+#define ACHIEVEMENT_EP1_BEAT_MAINELEVATOR           87
+#define ACHIEVEMENT_EP1_BEAT_CITADELCORE            88
+#define ACHIEVEMENT_EP1_BEAT_CITADELCORE_NOSTALKERKILLS 89
+#define ACHIEVEMENT_EP1_KILL_ANTLIONS_WITHCARS      90
+#define ACHIEVEMENT_EP1_BEAT_GARAGEELEVATORSTANDOFF 91
+#define ACHIEVEMENT_EP1_KILL_ENEMIES_WITHSNIPERALYX 92
+#define ACHIEVEMENT_EP1_BEAT_HOSPITALATTICGUNSHIP   93
+#define ACHIEVEMENT_EP1_BEAT_CITIZENESCORT_NOCITIZENDEATHS 94
+#define ACHIEVEMENT_EP1_BEAT_GAME                   95
+#define ACHIEVEMENT_EP1_BEAT_GAME_ONEBULLET         96
+#define ACHIEVEMENT_EP2_KILL_POISONANTLION          97
+#define ACHIEVEMENT_EP2_KILL_ALLGRUBS               98
+#define ACHIEVEMENT_EP2_BREAK_ALLWEBS               99
+#define ACHIEVEMENT_EP2_BEAT_ANTLIONINVASION        100
+#define ACHIEVEMENT_EP2_BEAT_ANTLIONGUARDS          101
+#define ACHIEVEMENT_EP2_KILL_ENEMIES_WITHCAR        102
+#define ACHIEVEMENT_EP2_BEAT_HUNTERAMBUSH           103
+#define ACHIEVEMENT_EP2_KILL_CHOPPER_NOMISSES       104
+#define ACHIEVEMENT_EP2_KILL_COMBINECANNON          105
+#define ACHIEVEMENT_EP2_FIND_ALLRADARCACHES         106
+#define ACHIEVEMENT_EP2_BEAT_ROCKETCACHEPUZZLE      107
+#define ACHIEVEMENT_EP2_BEAT_RACEWITHDOG            108
+#define ACHIEVEMENT_EP2_BEAT_WHITEFORESTINN         109
+#define ACHIEVEMENT_EP2_PUT_ITEMINROCKET            110
+#define ACHIEVEMENT_EP2_BEAT_MISSILESILO2           111
+#define ACHIEVEMENT_EP2_BEAT_OUTLAND12_NOBUILDINGSDESTROYED 112
+#define ACHIEVEMENT_EP2_BEAT_GAME                   113
+#define ACHIEVEMENT_EP2_KILL_HUNTER_WITHFLECHETTES  114
+#define ACHIEVEMENT_PORTAL_GET_PORTALGUNS           115
+#define ACHIEVEMENT_PORTAL_KILL_COMPANIONCUBE       116
+#define ACHIEVEMENT_PORTAL_ESCAPE_TESTCHAMBERS      117
+#define ACHIEVEMENT_PORTAL_BEAT_GAME                118
+#define ACHIEVEMENT_PORTAL_INFINITEFALL             119
+#define ACHIEVEMENT_PORTAL_LONGJUMP                 120
+#define ACHIEVEMENT_PORTAL_BEAT_2ADVANCEDMAPS       121
+#define ACHIEVEMENT_PORTAL_BEAT_4ADVANCEDMAPS       122
+#define ACHIEVEMENT_PORTAL_BEAT_6ADVANCEDMAPS       123
+#define ACHIEVEMENT_PORTAL_GET_ALLBRONZE            124
+#define ACHIEVEMENT_PORTAL_GET_ALLSILVER            125
+#define ACHIEVEMENT_PORTAL_GET_ALLGOLD              126
+#define ACHIEVEMENT_TF_GET_TURRETKILLS              127
+#define ACHIEVEMENT_TF_KILL_NEMESIS                 128
+#define ACHIEVEMENT_TF_GET_CONSECUTIVEKILLS_NODEATHS 129
+#define ACHIEVEMENT_TF_GET_HEALED_BYENEMY           130
+#define ACHIEVEMENT_TF_PLAY_GAME_FRIENDSONLY        131
+#define ACHIEVEMENT_TF_WIN_MULTIPLEGAMES            132
+#define ACHIEVEMENT_TF_GET_MULTIPLEKILLS            133
+#define ACHIEVEMENT_TF_WIN_2FORT_NOENEMYCAPS        134
+#define ACHIEVEMENT_TF_WIN_WELL_MINIMUMTIME         135
+#define ACHIEVEMENT_TF_WIN_HYDRO_NOENEMYCAPS        136
+#define ACHIEVEMENT_TF_WIN_DUSTBOWL_NOENEMYCAPS     137
+#define ACHIEVEMENT_TF_WIN_GRAVELPIT_NOENEMYCAPS    138
+#define ACHIEVEMENT_TF_PLAY_GAME_EVERYCLASS         139
+#define ACHIEVEMENT_TF_PLAY_GAME_EVERYMAP           140
+#define ACHIEVEMENT_TF_GET_HEALPOINTS               141
+#define ACHIEVEMENT_TF_BURN_PLAYERSINMINIMIMTIME    142
+#define ACHIEVEMENT_HL2_DISINTEGRATE_SOLDIERSINFIELD 143
+#define ACHIEVEMENT_HL2_FOLLOW_FREEMAN              144
+#define ACHIEVEMENT_TF_GET_HEADSHOTS                145
+#define ACHIEVEMENT_PORTAL_DETACH_ALL_CAMERAS       146
+#define ACHIEVEMENT_PORTAL_HIT_TURRET_WITH_TURRET   148
+
+#ifndef _XBOX
+#define ACHIEVEMENT_PORTAL_TRANSMISSION_RECEIVED	149
+#define ACHIEVEMENT_TF_GENERAL_KILL_ENEMIES_AFTER_TELEPORTING	150
+#endif // _XBOX
+
+#define ACHIEVEMENT_TF_LAST_ORANGEBOX				150
+
+//
+// Stats view ids
+//
+// These are used in the dwViewId member of the XUSER_STATS_SPEC structure
+// passed to the XUserReadStats* and XUserCreateStatsEnumerator* functions.
+//
+
+// Skill leaderboards for ranked game modes
+
+#define STATS_VIEW_SKILL_RANKED_MULTIPLAYER         0xFFFF0000
+#define STATS_VIEW_SKILL_RANKED_SINGLEPLAYER        0xFFFF0001
+
+// Skill leaderboards for unranked (standard) game modes
+
+#define STATS_VIEW_SKILL_STANDARD_MULTIPLAYER       0xFFFE0000
+#define STATS_VIEW_SKILL_STANDARD_SINGLEPLAYER      0xFFFE0001
+
+// Title defined leaderboards
+
+#define STATS_VIEW_PLAYER_MAX_UNRANKED              1
+#define STATS_VIEW_PLAYER_MAX_RANKED                2
+
+//
+// Stats view column ids
+//
+// These ids are used to read columns of stats views.  They are specified in
+// the rgwColumnIds array of the XUSER_STATS_SPEC structure.  Rank, rating
+// and gamertag are not retrieved as custom columns and so are not included
+// in the following definitions.  They can be retrieved from each row's
+// header (e.g., pStatsResults->pViews[x].pRows[y].dwRank, etc.).
+//
+
+// Column ids for PLAYER_MAX_UNRANKED
+
+#define STATS_COLUMN_PLAYER_MAX_UNRANKED_POINTS_SCORED 2
+#define STATS_COLUMN_PLAYER_MAX_UNRANKED_KILLS      3
+#define STATS_COLUMN_PLAYER_MAX_UNRANKED_POINTS_CAPPED 1
+#define STATS_COLUMN_PLAYER_MAX_UNRANKED_DAMAGE_DEALT 4
+#define STATS_COLUMN_PLAYER_MAX_UNRANKED_PLAY_TIME  5
+#define STATS_COLUMN_PLAYER_MAX_UNRANKED_POINT_DEFENSES 6
+#define STATS_COLUMN_PLAYER_MAX_UNRANKED_DOMINATIONS 7
+#define STATS_COLUMN_PLAYER_MAX_UNRANKED_REVENGE    8
+#define STATS_COLUMN_PLAYER_MAX_UNRANKED_BUILDINGS_DESTROYED 9
+#define STATS_COLUMN_PLAYER_MAX_UNRANKED_HEADSHOTS  10
+#define STATS_COLUMN_PLAYER_MAX_UNRANKED_HEALTH_POINTS_HEALED 11
+#define STATS_COLUMN_PLAYER_MAX_UNRANKED_INVULNS    12
+#define STATS_COLUMN_PLAYER_MAX_UNRANKED_KILL_ASSISTS 13
+#define STATS_COLUMN_PLAYER_MAX_UNRANKED_BACKSTABS  14
+#define STATS_COLUMN_PLAYER_MAX_UNRANKED_HEALTH_POINTS_LEACHED 15
+#define STATS_COLUMN_PLAYER_MAX_UNRANKED_BUILDINGS_BUILT 16
+#define STATS_COLUMN_PLAYER_MAX_UNRANKED_SENTRY_KILLS 17
+#define STATS_COLUMN_PLAYER_MAX_UNRANKED_TELEPORTS  18
+
+// Column ids for PLAYER_MAX_RANKED
+
+#define STATS_COLUMN_PLAYER_MAX_RANKED_POINTS_SCORED 2
+
+//
+// Matchmaking queries
+//
+// These values are passed as the dwProcedureIndex parameter to
+// XSessionSearch to indicate which matchmaking query to run.
+//
+
+#define SESSION_MATCH_QUERY_PLAYER_MATCH            0
+
+//
+// Gamer pictures
+//
+// These ids are passed as the dwPictureId parameter to XUserAwardGamerTile.
+//
+
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif // __THE_ORANGE_BOX_SPA_H__
+
+
--- a/common/language.cpp
+++ b/common/language.cpp
@ -0,0 +1,217 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: languages definition
+//
+//=============================================================================
+
+#include "language.h"
+#include "tier0/dbg.h"
+#include "tier1/strtools.h"
+
+// NOTE: This has to be the last file included!
+#include "tier0/memdbgon.h"
+
+
+struct Language_t
+{	
+	const char *m_pchName;
+	const char *m_pchShortName;
+	const char *m_pchVGUILocalizationName;
+	const char *m_pchICUName;				// used by osx; ISO-639-1 + ISO-3166-1 alpha-2. http://userguide.icu-project.org/locale/examples
+	ELanguage m_ELanguage;
+	int  m_LanguageCodeID;
+};
+
+
+// REVIEW
+// es_ES - use new world spanish country code instead?
+// zh_CN - validate that SC date formats come through
+// bt_BR - assume we should use Brazilian rather than Iberian portguese
+
+static const Language_t s_LanguageNames[] = 
+{
+	{	"None",					"none",			"None",									"none",		k_Lang_None,		0 },
+	{	"English",				"english",		"#GameUI_Language_English",				"en_US",	k_Lang_English,		1033 },
+	{	"German",				"german",		"#GameUI_Language_German",				"de_DE",	k_Lang_German,		1031 } ,
+	{	"French",				"french",		"#GameUI_Language_French",				"fr_FR",	k_Lang_French,		1036 } ,
+	{	"Italian",				"italian",		"#GameUI_Language_Italian",				"it_IT",	k_Lang_Italian,		1040 } ,
+	{	"Korean",				"koreana",		"#GameUI_Language_Korean",				"ko_KR",	k_Lang_Korean,		1042 } ,
+	{	"Spanish",				"spanish",		"#GameUI_Language_Spanish",				"es_ES",	k_Lang_Spanish,		1034 },
+	{	"Simplified_Chinese",	"schinese",		"#GameUI_Language_Simplified_Chinese",	"zh_CN",	k_Lang_Simplified_Chinese, 2052 },
+	{	"Traditional_Chinese",	"tchinese",		"#GameUI_Language_Traditional_Chinese",	"zh_TW",	k_Lang_Traditional_Chinese, 1028 },
+	{	"Russian",				"russian",		"#GameUI_Language_Russian",				"ru_RU",	k_Lang_Russian,		1049 } ,
+	{	"Thai",					"thai",			"#GameUI_Language_Thai",				"th_TH",	k_Lang_Thai,		1054 } ,
+	{	"Japanese",				"japanese",		"#GameUI_Language_Japanese",			"ja_JP",	k_Lang_Japanese,	1041 } ,
+	{	"Portuguese",			"portuguese",	"#GameUI_Language_Portuguese",			"pt_PT",	k_Lang_Portuguese,	2070 } ,
+	{	"Polish",				"polish",		"#GameUI_Language_Polish",				"pl_PL",	k_Lang_Polish,		1045 } ,
+	{	"Danish",				"danish",		"#GameUI_Language_Danish",				"da_DK",	k_Lang_Danish,		1030 } ,
+	{	"Dutch",				"dutch",		"#GameUI_Language_Dutch",				"nl_NL",	k_Lang_Dutch,		1043 } ,
+	{	"Finnish",				"finnish",		"#GameUI_Language_Finnish",				"fi_FI",	k_Lang_Finnish,		1035 } ,
+	{	"Norwegian",			"norwegian",	"#GameUI_Language_Norwegian",			"no_NO",	k_Lang_Norwegian,	1044 } ,
+	{	"Swedish",				"swedish",		"#GameUI_Language_Swedish",				"sv_SE",	k_Lang_Swedish,		1053 } ,
+	{	"Romanian",				"romanian",		"#GameUI_Language_Romanian",			"ro_RO",	k_Lang_Romanian,	1048 } ,
+	{	"Turkish",				"turkish",		"#GameUI_Language_Turkish",				"tr_TR",	k_Lang_Turkish,		1055 } ,
+	{	"Hungarian",			"hungarian",	"#GameUI_Language_Hungarian",			"hu_HU",	k_Lang_Hungarian,	1038 } ,
+	{	"Czech",				"czech",		"#GameUI_Language_Czech",				"cs_CZ",	k_Lang_Czech,		1029 } ,
+	{	"Brazilian",			"brazilian",	"#GameUI_Language_Brazilian",			"pt_BR",	k_Lang_Brazilian,	1046 } ,
+	{	"Bulgarian",			"bulgarian",	"#GameUI_Language_Bulgarian",			"bg_BG",	k_Lang_Bulgarian,	1026 } ,
+	{	"Greek",				"greek",		"#GameUI_Language_Greek",				"el_GR",	k_Lang_Greek,		1032 },
+};	
+
+//-----------------------------------------------------------------------------
+// Purpose: translate language enum into closests windows language code ID
+//-----------------------------------------------------------------------------
+int GetLanguageCodeID(ELanguage eLang)
+{
+	for ( uint iLang = 0; iLang < Q_ARRAYSIZE(s_LanguageNames); ++iLang )
+	{
+		if ( s_LanguageNames[iLang].m_ELanguage == eLang )
+			return s_LanguageNames[iLang].m_LanguageCodeID;
+	}
+
+	// default to English
+	return 1033;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: find the language by name
+//-----------------------------------------------------------------------------
+ELanguage PchLanguageToELanguage( const char *pchShortName, ELanguage eDefault )
+{
+	Assert( Q_ARRAYSIZE(s_LanguageNames) == k_Lang_MAX + 1 );
+	if ( !pchShortName )
+		return eDefault;
+
+	for ( uint iLang = 0; iLang < Q_ARRAYSIZE(s_LanguageNames); ++iLang )
+	{
+		if ( !Q_stricmp( pchShortName, s_LanguageNames[iLang].m_pchShortName ) )
+		{
+			return s_LanguageNames[iLang].m_ELanguage;
+		}
+	}
+
+	// return default
+	return eDefault;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: find the language by ICU short code
+//-----------------------------------------------------------------------------
+ELanguage PchLanguageICUCodeToELanguage( const char *pchICUCode, ELanguage eDefault )
+{
+	Assert( Q_ARRAYSIZE(s_LanguageNames) == k_Lang_MAX + 1 );
+	if ( !pchICUCode )
+		return eDefault;
+
+	// Match to no more than the param length so either a short 'en' or
+	// full 'zh-Hant' can match
+	int nLen = Q_strlen( pchICUCode );
+
+	// we only have 5 character ICU codes so this should be enough room
+	char rchCleanedCode[ 6 ];
+	Q_strncpy( rchCleanedCode, pchICUCode, Q_ARRAYSIZE( rchCleanedCode ) );
+	if( nLen >= 3 && rchCleanedCode[ 2 ] == '-' )
+	{
+		rchCleanedCode[ 2 ] = '_';
+	}
+
+	for ( uint iLang = 0; iLang < Q_ARRAYSIZE(s_LanguageNames); ++iLang )
+	{
+		if ( !Q_strnicmp( rchCleanedCode, s_LanguageNames[iLang].m_pchICUName, nLen ) )
+		{
+			return s_LanguageNames[iLang].m_ELanguage;
+		}
+	}
+
+	// return default
+	return eDefault;
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: return the short string name used for this language by SteamUI
+//-----------------------------------------------------------------------------
+const char *GetLanguageShortName( ELanguage eLang )
+{
+	COMPILE_TIME_ASSERT( Q_ARRAYSIZE(s_LanguageNames) == k_Lang_MAX + 1 );
+	if ( s_LanguageNames[ eLang + 1 ].m_ELanguage == eLang )
+	{
+		Assert( eLang + 1 < ARRAYSIZE(s_LanguageNames) );
+		return s_LanguageNames[ eLang + 1 ].m_pchShortName;
+	}
+
+	Assert( !"enum ELanguage order mismatched from Language_t s_LanguageNames, fix it!" );
+	return s_LanguageNames[0].m_pchShortName;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: return the ICU code used for this language by SteamUI
+//-----------------------------------------------------------------------------
+const char *GetLanguageICUName( ELanguage eLang )
+{
+	COMPILE_TIME_ASSERT( Q_ARRAYSIZE(s_LanguageNames) == k_Lang_MAX + 1 );
+	if ( s_LanguageNames[ eLang + 1 ].m_ELanguage == eLang )
+	{
+		Assert( eLang + 1 < ARRAYSIZE(s_LanguageNames) );
+		return s_LanguageNames[ eLang + 1 ].m_pchICUName;
+	}
+
+	Assert( !"enum ELanguage order mismatched from Language_t s_LanguageNames, fix it!" );
+	return s_LanguageNames[0].m_pchICUName;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: return the CLocale name that works with setlocale()
+//-----------------------------------------------------------------------------
+const char *GetLangugeCLocaleName( ELanguage eLang )
+{
+	if ( eLang == k_Lang_None )
+		return "";
+
+#ifdef _WIN32
+	// table for Win32 is here: http://msdn.microsoft.com/en-us/library/hzz3tw78(v=VS.80).aspx
+	// shortname works except for chinese
+
+	switch ( eLang )
+	{
+	case k_Lang_Simplified_Chinese:
+		return "chs"; // or "chinese-simplified"
+	case k_Lang_Traditional_Chinese:
+		return "cht"; // or "chinese-traditional"
+	case k_Lang_Korean:
+		return "korean"; // steam likes "koreana" for the name for some reason.
+	default:
+		return GetLanguageShortName( eLang );
+	}
+
+#else
+	switch ( eLang )
+	{
+	case k_Lang_Simplified_Chinese:
+	case k_Lang_Traditional_Chinese:
+		return "zh_CN";
+	default:
+		;
+	}
+
+	// ICU codes work on linux/osx
+	return GetLanguageICUName( eLang );
+#endif
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: return the short string name used for this language by SteamUI
+//-----------------------------------------------------------------------------
+const char *GetLanguageVGUILocalization( ELanguage eLang )
+{
+	COMPILE_TIME_ASSERT( Q_ARRAYSIZE(s_LanguageNames) == k_Lang_MAX + 1 );
+	if ( s_LanguageNames[ eLang + 1 ].m_ELanguage == eLang )
+	{
+		Assert( eLang + 1 < ARRAYSIZE(s_LanguageNames) );
+		return s_LanguageNames[ eLang + 1 ].m_pchVGUILocalizationName;
+	}
+
+	Assert( !"enum ELanguage order mismatched from Language_t s_LanguageNames, fix it!" );
+	return s_LanguageNames[0].m_pchVGUILocalizationName;
+}
+
--- a/common/language.h
+++ b/common/language.h
@ -0,0 +1,55 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: represent a canonical list of the languages we support, 
+//
+//=============================================================================
+
+#ifndef LANG_H
+#define LANG_H
+#ifdef _WIN32
+#pragma once
+#endif
+
+// if you change this enum also change language.cpp:s_LanguageNames
+enum ELanguage
+{
+	k_Lang_None = -1,
+	k_Lang_First = 0,
+	k_Lang_English = 0,
+	k_Lang_German,
+	k_Lang_French,
+	k_Lang_Italian,
+	k_Lang_Korean,
+	k_Lang_Spanish,
+	k_Lang_Simplified_Chinese,
+	k_Lang_Traditional_Chinese,
+	k_Lang_Russian,
+	k_Lang_Thai,
+	k_Lang_Japanese,
+	k_Lang_Portuguese,
+	k_Lang_Polish,
+	k_Lang_Danish,
+	k_Lang_Dutch,
+	k_Lang_Finnish,
+	k_Lang_Norwegian,
+	k_Lang_Swedish,
+	k_Lang_Romanian,
+	k_Lang_Turkish,
+	k_Lang_Hungarian,
+	k_Lang_Czech,
+	k_Lang_Brazilian,
+	k_Lang_Bulgarian,
+	k_Lang_Greek,
+	k_Lang_MAX
+};
+
+#define FOR_EACH_LANGUAGE( eLang )		for ( int eLang = (int)k_Lang_First; eLang < k_Lang_MAX; ++eLang )
+
+ELanguage PchLanguageToELanguage(const char *pchShortName, ELanguage eDefault = k_Lang_English);
+ELanguage PchLanguageICUCodeToELanguage( const char *pchICUCode, ELanguage eDefault = k_Lang_English );
+const char *GetLanguageShortName( ELanguage eLang );
+const char *GetLanguageICUName( ELanguage eLang );
+const char *GetLanguageVGUILocalization( ELanguage eLang );
+const char *GetLanguageName( ELanguage eLang );
+
+#endif /* LANG_H */
--- a/common/proto_version.h
+++ b/common/proto_version.h
@ -0,0 +1,49 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+// $NoKeywords: $
+//
+//=============================================================================//
+#if !defined( PROTO_VERSION_H )
+#define PROTO_VERSION_H
+#ifdef _WIN32
+#pragma once
+#endif
+
+// The current network protocol version.  Changing this makes clients and servers incompatible
+#define PROTOCOL_VERSION    24
+
+#define DEMO_BACKWARDCOMPATABILITY
+
+// For backward compatibility of demo files (NET_MAX_PAYLOAD_BITS went away)
+#define PROTOCOL_VERSION_23		23
+
+// For backward compatibility of demo files (sound index bits used to = 13 )
+#define PROTOCOL_VERSION_22		22
+
+// For backward compatibility of demo files (before the special DSP was shipped to public)
+#define PROTOCOL_VERSION_21		21
+
+// For backward compatibility of demo files (old-style dynamic model loading)
+#define PROTOCOL_VERSION_20		20
+
+// For backward compatibility of demo files (post Halloween sound flag extra bit)
+#define PROTOCOL_VERSION_19		19
+
+// For backward compatibility of demo files (pre Halloween sound flag extra bit)
+#define PROTOCOL_VERSION_18		18
+
+// For backward compatibility of demo files (MD5 in map version)
+#define PROTOCOL_VERSION_17		17
+
+// For backward compatibility of demo files (create string tables compression flag)
+#define PROTOCOL_VERSION_14		14
+
+// For backward compatibility of demo files
+#define PROTOCOL_VERSION_12		12
+
+// The PROTOCOL_VERSION when replay shipped to public
+#define PROTOCOL_VERSION_REPLAY		16
+
+#endif
--- a/common/qlimits.h
+++ b/common/qlimits.h
@ -0,0 +1,35 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose:
+//
+// $NoKeywords: $
+//=============================================================================//
+
+#ifndef QLIMITS_H
+#define QLIMITS_H
+
+#if defined( _WIN32 )
+#pragma once
+#endif
+
+// DATA STRUCTURE INFO
+
+#define MAX_NUM_ARGVS	50
+
+// SYSTEM INFO
+#define	MAX_QPATH		96			// max length of a game pathname
+#define	MAX_OSPATH		260			// max length of a filesystem pathname
+
+#define	ON_EPSILON		0.1			// point on plane side epsilon
+
+
+// Resource counts;
+#define MAX_MODEL_INDEX_BITS	11   // sent as a short
+#define	MAX_MODELS				(1<<MAX_MODEL_INDEX_BITS)
+
+#define MAX_GENERIC_INDEX_BITS	9
+#define MAX_GENERIC				(1<<MAX_GENERIC_INDEX_BITS)
+#define MAX_DECAL_INDEX_BITS	9
+#define MAX_BASE_DECALS			(1<<MAX_DECAL_INDEX_BITS)
+
+#endif // QLIMITS_H
--- a/common/randoverride.cpp
+++ b/common/randoverride.cpp
@ -0,0 +1,27 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose:
+//
+//=============================================================================//
+#if !defined(_STATIC_LINKED) || defined(_SHARED_LIB)
+
+#include "stdlib.h"
+#include "vstdlib/random.h"
+
+// memdbgon must be the last include file in a .cpp file!!!
+#include "tier0/memdbgon.h"
+
+#ifdef GNUC
+#define __cdecl 
+#endif
+
+void __cdecl srand(unsigned int)
+{
+}
+
+int __cdecl rand()
+{
+	return RandomInt( 0, VALVE_RAND_MAX );
+}
+
+#endif // !_STATIC_LINKED || _SHARED_LIB
--- a/common/replay/basereplayserializeable.h
+++ b/common/replay/basereplayserializeable.h
@ -0,0 +1,43 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+//=======================================================================================//
+
+#ifndef REPLAYSERIALIIZEABLE_H
+#define REPLAYSERIALIIZEABLE_H
+#ifdef _WIN32
+#pragma once
+#endif
+
+//----------------------------------------------------------------------------------------
+
+#include "replay/ireplayserializeable.h"
+#include "replay/replayhandle.h"
+
+//----------------------------------------------------------------------------------------
+
+class CBaseReplaySerializeable : public IReplaySerializeable
+{
+public:
+	CBaseReplaySerializeable();
+
+	virtual void			SetHandle( ReplayHandle_t h );
+	virtual ReplayHandle_t	GetHandle() const;
+	virtual bool			Read( KeyValues *pIn );
+	virtual void			Write( KeyValues *pOut );
+	virtual const char		*GetFilename() const;
+	virtual const char		*GetFullFilename() const;
+	virtual const char		*GetDebugName() const;
+	virtual void			SetLocked( bool bLocked );
+	virtual bool			IsLocked() const;
+	virtual void			OnDelete();
+	virtual void			OnUnload();
+	virtual void			OnAddedToDirtyList();
+
+private:
+	ReplayHandle_t			m_hThis;
+	bool					m_bLocked;
+};
+
+//----------------------------------------------------------------------------------------
+
+#endif // REPLAYSERIALIIZEABLE_H
--- a/common/replay/iclientreplay.h
+++ b/common/replay/iclientreplay.h
@ -0,0 +1,64 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+//=======================================================================================//
+
+#ifndef ICLIENTREPLAY_H
+#define ICLIENTREPLAY_H
+#ifdef _WIN32
+#pragma once
+#endif
+
+//----------------------------------------------------------------------------------------
+
+#include "interface.h"
+#include "replay/replayhandle.h"
+
+//----------------------------------------------------------------------------------------
+
+#define CLIENT_REPLAY_INTERFACE_VERSION		"ClientReplay001"
+
+//----------------------------------------------------------------------------------------
+
+class IReplayFactory;
+class IReplayScreenshotSystem;
+class IReplayPerformancePlaybackHandler;
+class KeyValues;
+class IReplayCamera;
+class CReplayPerformance;
+struct RenderMovieParams_t;
+class IGameEvent;
+
+//----------------------------------------------------------------------------------------
+
+//
+// Allows the replay and engine DLL's to talk to the client.
+//
+class IClientReplay : public IBaseInterface
+{
+public:
+	virtual uint64			GetServerSessionId() = 0; 
+	virtual bool			CacheReplayRagdolls( const char* pFilename, int nStartTick ) = 0;	// Cache replay ragdolls
+	virtual IReplayScreenshotSystem *GetReplayScreenshotSystem() = 0;	// Get the client's replay screenshot system
+	virtual IReplayPerformancePlaybackHandler *GetPerformancePlaybackHandler() = 0;
+	virtual IReplayCamera	*GetReplayCamera() = 0;
+	virtual void			DisplayReplayMessage( const char *pLocalizeStr, bool bUrgent, bool bDlg, const char *pSound ) = 0;
+	virtual void			DisplayReplayMessage( const wchar_t *pText, bool bUrgent, bool bDlg, const char *pSound ) = 0;
+	virtual void			InitPerformanceEditor( ReplayHandle_t hReplay ) = 0;
+	virtual void			HidePerformanceEditor() = 0;
+	virtual bool			ShouldRender() = 0;
+	virtual void			PlaySound( const char *pSound ) = 0;
+	virtual void			UploadOgsData( KeyValues *pData, bool bIncludeTimeField ) = 0;
+	virtual bool			ShouldCompletePendingReplay( IGameEvent *pEvent ) = 0;
+
+	virtual void			OnSaveReplay( ReplayHandle_t hNewReplay, bool bShowInputDlg ) = 0;
+	virtual void			OnDeleteReplay( ReplayHandle_t hReplay ) = 0;	// Called before replay is actually removed from the replay manager
+	virtual void			OnPlaybackComplete( ReplayHandle_t hReplay, int iPerformance ) = 0;
+	virtual void			OnRenderStart() = 0;
+	virtual void			OnRenderComplete( const RenderMovieParams_t &RenderParams, bool bCancelled, bool bSuccess, bool bShowBrowser ) = 0;
+	virtual bool			OnConfirmQuit() = 0;
+	virtual bool			OnEndOfReplayReached() = 0;
+};
+
+//----------------------------------------------------------------------------------------
+
+#endif // ICLIENTREPLAY_H
--- a/common/replay/iclientreplaycontext.h
+++ b/common/replay/iclientreplaycontext.h
@ -0,0 +1,58 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+//=======================================================================================//
+
+#ifndef ICLIENTREPLAYCONTEXT_H
+#define ICLIENTREPLAYCONTEXT_H
+#ifdef _WIN32
+#pragma once
+#endif
+
+//----------------------------------------------------------------------------------------
+
+#include "replay/ireplaycontext.h"
+#include "replay/replayhandle.h"
+
+//----------------------------------------------------------------------------------------
+
+#define REPLAYHISTORYMANAGER_INTERFACE_VERSION_CLIENT		"VENGINE_CLIENT_REPLAY_HISTORY_MANAGER_001"
+
+//----------------------------------------------------------------------------------------
+
+class CReplay;
+class CReplayPerformance;
+class IReplayManager;
+class IReplayMovieManager;
+class IReplayMovieRenderer;
+class IReplayScreenshotManager;
+class IReplayPerformanceManager;
+class IReplayPerformanceController;
+class IReplayRenderQueue;
+
+//----------------------------------------------------------------------------------------
+
+class IClientReplayContext : public IReplayContext
+{
+public:
+	virtual CReplay						*GetReplay( ReplayHandle_t hReplay ) = 0;	// Shorthand to GetReplayManager()->GetReplay()
+	virtual IReplayManager				*GetReplayManager() = 0;
+	virtual IReplayMovieRenderer		*GetMovieRenderer() = 0;
+	virtual IReplayMovieManager			*GetMovieManager() = 0;
+	virtual IReplayScreenshotManager	*GetScreenshotManager() = 0;
+	virtual IReplayPerformanceManager	*GetPerformanceManager() = 0;
+	virtual IReplayPerformanceController *GetPerformanceController() = 0;
+	virtual IReplayRenderQueue			*GetRenderQueue() = 0;
+	virtual void						SetMovieRenderer( IReplayMovieRenderer *pRenderer ) = 0;	// Set to be the panel that renders replay movies, or NULL when nothing is rendering
+	virtual void						OnSignonStateFull() = 0;
+	virtual void						OnClientSideDisconnect() = 0;	// Called when client disconnects
+	virtual void						PlayReplay( ReplayHandle_t hReplay, int iPerformance, bool bPlaySound ) = 0;	// Play the given replay, from spawn tick to death tick
+	virtual bool						ReconstructReplayIfNecessary( CReplay *pReplay ) = 0;
+	virtual void						OnPlayerSpawn() = 0;	// Called on the client when player is spawned
+	virtual void						OnPlayerClassChanged() = 0;	// Called when the player's class changes - we use this instead of an event for immediacy
+	virtual void						GetPlaybackTimes( float &flOutTime, float &flOutLength, const CReplay *pReplay, const CReplayPerformance *pPerformance ) = 0;	// Calculate the current time and length of a replay or performance - takes in tick and out tick into account for performances - flCurTime should be gpGlobals->curtime. pPerformance can be NULL.
+	virtual uint64						GetServerSessionId( ReplayHandle_t hReplay ) = 0;
+};
+
+//----------------------------------------------------------------------------------------
+
+#endif // ICLIENTREPLAYCONTEXT_H
--- a/common/replay/iclientreplayhistorymanager.h
+++ b/common/replay/iclientreplayhistorymanager.h
@ -0,0 +1,104 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+//=======================================================================================//
+
+#ifndef ICLIENTREPLAYHISTORYMANAGER_H
+#define ICLIENTREPLAYHISTORYMANAGER_H
+#ifdef _WIN32
+#pragma once
+#endif
+
+//----------------------------------------------------------------------------------------
+
+#include "replay/replayhandle.h"
+#include "replay/screenshot.h"
+#include "interface.h"
+#include "qlimits.h"
+#include "convar.h"
+#include "engine/http.h"
+#include "tier1/utllinkedlist.h"
+#include "tier1/checksum_crc.h"
+#include <time.h>
+
+//----------------------------------------------------------------------------------------
+
+class IReplayDownloadGroup;
+class IReplayDownloadGroupHelper;
+class CDmxElement;
+class KeyValues;
+struct CaptureScreenshotParams_t;
+struct RenderMovieParams_t;
+class CBaseReplay;
+class CReplay;
+class IReplayMovieRenderer;
+class IReplayMovieManager;
+class IReplayMovie;
+class IReplayPerformanceManager;
+class IGameEvent;
+
+//----------------------------------------------------------------------------------------
+
+class IClientReplayHistoryManager : public IBaseInterface
+{
+public:
+	virtual bool			Init( CreateInterfaceFn fnCreateFactory ) = 0;
+	virtual void			Shutdown() = 0;
+	virtual void			Think() = 0;
+
+	virtual bool			IsInitialized() const = 0;
+	virtual bool			Commit( CBaseReplay *pNewReplay ) = 0;
+	
+	virtual void			Save() = 0;	// Write the entire index and any replays/groups/movies that are marked as dirty
+	virtual void			FlagReplayForFlush( CBaseReplay *pReplay, bool bForceImmediateWrite ) = 0;	// Mark the given replay as dirty - flush to disk at the next opportunity (see CBaseReplayHistoryManager::FlushThink())
+
+	virtual void			Nuke() = 0;
+
+	virtual void			DeleteReplay( ReplayHandle_t hReplay, bool bNotifyUI ) = 0;
+	virtual CBaseReplay		*GetReplay( ReplayHandle_t hReplay ) = 0;
+
+	virtual const char		*GetBaseDirectory() = 0;	// Returns full directory to wherever replays.dmx lives, e.g. c:\program files (x86)\steam\steamapps\someuser\team fortress 2\game\tf\replays\client\ (or server\) - NOTE: includes trailing slash
+	virtual const char		*GetReplaysSubDir() = 0;	// Returns "client" or "server"
+
+	// For loop through all replays - indices should not be cached
+	virtual int				GetReplayCount() const = 0;
+//	virtual CBaseReplay		*GetReplayAtIndex( int nIndex ) = 0;
+
+	virtual const char		*GetFullReplayPath() = 0;		// Get c:\...\game\tf\replays\<client or server>\
+
+	// Client-specific
+	virtual int				GetAdjustedDeathTick( CReplay *pReplay ) = 0;
+	virtual void			FlagDownloadGroupForFlush( IReplayDownloadGroup *pGroup, bool bForceImmediate ) = 0;
+	virtual void			FlagMovieForFlush( IReplayMovie *pMovie, bool bForceImmediate ) = 0;	// Flag the movie for flush - if pMovie is NULL, mark the index for flush
+	virtual void			SetMovieRenderer( IReplayMovieRenderer *pRenderer ) = 0;	// Set to be the panel that renders replay movies, or NULL when nothing is rendering
+	virtual bool			ShouldGameRenderView() = 0;	// Called from V_RenderView() to determine whether the game should render - used during movie rendering
+	virtual int				GetUnrenderedReplayCount() = 0;	// Get the number of unrendered replays
+	virtual void			UpdateCurrentReplayDataFromServer() = 0;	// Updates start tick, current file url, demo filename
+	virtual void			LinkReplayToDownloadGroup() = 0;
+	virtual void			CaptureScreenshot( CaptureScreenshotParams_t &params ) = 0;	// Schedules a screenshot capture at flDelay seconds in the future
+	virtual void			DoCaptureScreenshot() = 0;					// Takes the screenshot right now
+	virtual bool			ShouldCaptureScreenshot() = 0;				// Is screenshot scheduled to be taken right now?
+	virtual void			GetUnpaddedScreenshotSize( int &nWidth, int &nHeight ) = 0;	// Get the dimensions for a screenshot if we take one right now, based on replay_screenshotresolution and the current aspect ratio
+	virtual void			DeleteScreenshotsForReplay( CReplay *pReplay ) = 0;	// Deletes all screenshots associated with the given replay
+	virtual void			PlayReplay( ReplayHandle_t hReplay ) = 0;	// Play the given replay, from spawn tick to death tick
+	virtual void			RenderMovie( RenderMovieParams_t const& params ) = 0;	// Renders the given replay - or if params.hReplay is -1, render all unrendered replays
+	virtual void			CompleteRender( bool bSuccess ) = 0;
+	virtual void			OnClientSideDisconnect() = 0;	// Called when client disconnects
+	virtual void			OnSignonStateFull() = 0;
+	virtual void			OnPlayerSpawn() = 0;	// Called on the client when player is spawned
+	virtual void			OnPlayerClassChanged() = 0;	// Called when the player's class changes - we use this instead of an event for immediacy
+	virtual void			OnReplayRecordingCvarChanged() = 0;	// Called (on client only) when replay_recording is set to 1
+	virtual void			OnGroupDeleted() = 0;
+	virtual CReplay			*GetPlayingReplay() = 0;			// Get the currently playing replay, otherwise NULL if one isn't playing
+	virtual CReplay			*GetReplayForCurrentLife() = 0;	// Gets the current replay (constant from local player spawn until next spawn/disconnect/exit)
+	virtual bool			IsRendering() = 0;		// Are we currently rendering a movie?
+	virtual void			CancelRender() = 0;	// If we're currently rendering, cancel
+	virtual IReplayMovieManager		*GetMovieManager() = 0;
+	virtual IReplayMovieRenderer	*GetMovieRenderer() = 0;
+	virtual const RenderMovieParams_t	*GetRenderSettings() = 0;
+	virtual IReplayDownloadGroupHelper	*GetDownloadGroupHelper() = 0;
+	virtual IReplayPerformanceManager	*GetPerformanceManager() = 0;
+};
+
+//----------------------------------------------------------------------------------------
+
+#endif // ICLIENTREPLAYHISTORYMANAGER_H
--- a/common/replay/ienginereplay.h
+++ b/common/replay/ienginereplay.h
@ -0,0 +1,116 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+//=======================================================================================//
+
+#ifndef IENGINEREPLAY_H
+#define IENGINEREPLAY_H
+#ifdef _WIN32
+#pragma once
+#endif
+
+//----------------------------------------------------------------------------------------
+
+#include "interface.h"
+
+//----------------------------------------------------------------------------------------
+
+#define ENGINE_REPLAY_INTERFACE_VERSION				"EngineReplay001"
+
+#if !defined( DEDICATED )
+#  define ENGINE_REPLAY_CLIENT_INTERFACE_VERSION	"EngineClientReplay001"
+#endif
+
+//----------------------------------------------------------------------------------------
+
+class IServer;
+class INetChannel;
+class IReplayServer;
+class IClientEntityList;
+class IClientReplay;
+struct demoheader_t;
+class CGlobalVarsBase;
+class IDemoBuffer;
+class CBaseRecordingSessionBlock;
+
+//----------------------------------------------------------------------------------------
+
+//
+// Allows the replay, client & server DLL's to talk to the engine
+//
+class IEngineReplay : public IBaseInterface
+{
+public:
+	virtual bool			IsSupportedModAndPlatform() = 0;
+
+	virtual float			GetHostTime() = 0;
+	virtual int				GetHostTickCount() = 0;
+	virtual int				TimeToTicks( float flTime ) = 0;
+	virtual float			TicksToTime( int nTick ) = 0;
+
+	virtual bool			ReadDemoHeader( const char *pFilename, demoheader_t &header ) = 0;
+	virtual const char		*GetGameDir() = 0;
+	virtual void			Cbuf_AddText( const char *pCmd ) = 0;
+	virtual void			Cbuf_Execute() = 0;
+	virtual void			Host_Disconnect( bool bShowMainMenu ) = 0;
+	virtual void			HostState_Shutdown() = 0;
+	virtual const char		*GetModDir() = 0;
+
+	virtual bool			CopyFile( const char *pSource, const char *pDest ) = 0;
+
+	virtual bool			LZSS_Compress( char *pDest, unsigned int *pDestLen, const char *pSource, unsigned int nSourceLen ) = 0;
+	virtual bool			LZSS_Decompress( char *pDest, unsigned int *pDestLen, const char *pSource, unsigned int nSourceLen ) = 0;
+
+	virtual bool			MD5_HashBuffer( unsigned char pDigest[16], const unsigned char *pBuffer, int nSize, unsigned int pSeed[4] ) = 0;
+
+	// Server-specific
+	virtual IReplayServer	*GetReplayServer() = 0;
+	virtual IServer			*GetReplayServerAsIServer() = 0;
+	virtual IServer			*GetGameServer() = 0;
+	virtual bool			GetSessionRecordBuffer( uint8 **ppSessionBuffer, int *pSize ) = 0;
+	virtual bool			IsDedicated() = 0;
+	virtual void			ResetReplayRecordBuffer() = 0;
+	virtual demoheader_t	*GetReplayDemoHeader() = 0;
+	virtual void			RecalculateTags() = 0;
+	virtual bool			NET_GetHostnameAsIP( const char *pHostname, char *pOut, int nOutSize ) = 0;
+};
+
+//
+// Allows the replay and client DLL's to talk to the engine
+//
+#if !defined( DEDICATED )
+class IEngineClientReplay : public IBaseInterface
+{
+public:
+	virtual INetChannel		*GetNetChannel() = 0;
+	virtual bool			IsConnected() = 0;
+	virtual bool			IsListenServer() = 0;
+	virtual float			GetLastServerTickTime() = 0;
+	virtual const char		*GetLevelName() = 0;
+	virtual const char		*GetLevelNameShort() = 0;
+	virtual int				GetPlayerSlot() = 0;
+	virtual bool			IsPlayingReplayDemo() = 0;
+	virtual IClientEntityList	*GetClientEntityList() = 0;
+	virtual IClientReplay	*GetClientReplayInt() = 0;
+	virtual uint32			GetClientSteamID() = 0;
+	virtual void			Con_NPrintf( int nPos, PRINTF_FORMAT_STRING const char *pFormat, ... ) = 0;
+	virtual CGlobalVarsBase	*GetClientGlobalVars() = 0;
+	virtual void			VGui_PlaySound( const char *pSound ) = 0;
+	virtual void			EngineVGui_ConfirmQuit() = 0;
+	virtual int				GetScreenWidth() = 0;
+	virtual int				GetScreenHeight() = 0;
+	virtual bool			IsDemoPlayingBack() = 0;
+	virtual bool			IsGamePathValidAndSafeForDownload( const char *pGamePath ) = 0;
+	virtual bool			IsInGame() = 0;
+
+	virtual void			InitSoundRecord() = 0;
+
+	virtual void			Wave_CreateTmpFile( const char *pFilename ) = 0;
+	virtual void			Wave_AppendTmpFile( const char *pFilename, void *pBuffer, int nNumSamples ) = 0;
+	virtual void			Wave_FixupTmpFile( const char *pFilename ) = 0;
+
+};
+#endif	// !defined( DEDICATED )
+
+//----------------------------------------------------------------------------------------
+
+#endif // IENGINEREPLAY_H
--- a/common/replay/iqueryablereplayitem.h
+++ b/common/replay/iqueryablereplayitem.h
@ -0,0 +1,46 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+//=======================================================================================//
+
+#ifndef IQUERYABLEREPLAYITEM_H
+#define IQUERYABLEREPLAYITEM_H
+#ifdef _WIN32
+#pragma once
+#endif
+
+//----------------------------------------------------------------------------------------
+
+#include "interface.h"
+#include "iqueryablereplayitem.h"
+#include "replay/replayhandle.h"
+#include "replay/replaytime.h"
+
+//----------------------------------------------------------------------------------------
+
+class CReplay;
+
+//----------------------------------------------------------------------------------------
+
+typedef int QueryableReplayItemHandle_t;
+
+//----------------------------------------------------------------------------------------
+
+abstract_class IQueryableReplayItem : public IBaseInterface
+{
+public:
+	virtual const CReplayTime	&GetItemDate() const = 0;
+	virtual bool				IsItemRendered() const = 0;
+	virtual CReplay				*GetItemReplay() = 0;
+	virtual ReplayHandle_t		GetItemReplayHandle() const = 0;
+	virtual QueryableReplayItemHandle_t	GetItemHandle() const = 0;	// Get the handle of this item
+	virtual const wchar_t		*GetItemTitle() const = 0;
+	virtual void				SetItemTitle( const wchar_t *pTitle ) = 0;
+	virtual float				GetItemLength() const = 0;
+	virtual void				*GetUserData() = 0;
+	virtual void				SetUserData( void *pUserData ) = 0;
+	virtual bool				IsItemAMovie() const = 0;
+};
+
+//----------------------------------------------------------------------------------------
+
+#endif // IQUERYABLEREPLAYITEM_H
--- a/common/replay/irecordingsession.h
+++ b/common/replay/irecordingsession.h
@ -0,0 +1,27 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+//=======================================================================================//
+
+#ifndef IRECORDINGSESSION_H
+#define IRECORDINGSESSION_H
+#ifdef _WIN32
+#pragma once
+#endif
+
+//----------------------------------------------------------------------------------------
+
+#include "interface.h"
+
+//----------------------------------------------------------------------------------------
+
+class CBaseRecordingSessionBlock;
+
+class IRecordingSession : public IBaseInterface
+{
+public:
+	virtual void	AddBlock( CBaseRecordingSessionBlock *pBlock ) = 0;
+};
+
+//----------------------------------------------------------------------------------------
+
+#endif // IRECORDINGSESSION_H
--- a/common/replay/irecordingsessionblockmanager.h
+++ b/common/replay/irecordingsessionblockmanager.h
@ -0,0 +1,30 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+//=======================================================================================//
+
+#ifndef IRECORDINGSESSIONBLOCKMANAGER_H
+#define IRECORDINGSESSIONBLOCKMANAGER_H
+#ifdef _WIN32
+#pragma once
+#endif
+
+//----------------------------------------------------------------------------------------
+
+#include "interface.h"
+#include "replay/replayhandle.h"
+
+//----------------------------------------------------------------------------------------
+
+class IRecordingSessionBlockManager : public IBaseInterface
+{
+public:
+	virtual CBaseRecordingSessionBlock	*GetBlock( ReplayHandle_t hBlock ) = 0;
+	virtual void						DeleteBlock( CBaseRecordingSessionBlock *pBlock ) = 0;
+	virtual void						UnloadBlock( CBaseRecordingSessionBlock *pBlock ) = 0;
+	virtual const char					*GetBlockPath() const = 0;
+	virtual void						LoadBlockFromFileName( const char *pFilename, IRecordingSession *pSession ) = 0;
+};
+
+//----------------------------------------------------------------------------------------
+
+#endif // IRECORDINGSESSIONBLOCKMANAGER_H
--- a/common/replay/irecordingsessionmanager.h
+++ b/common/replay/irecordingsessionmanager.h
@ -0,0 +1,33 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+//=======================================================================================//
+
+#ifndef IRECORDINGSESSIONMANAGER_H
+#define IRECORDINGSESSIONMANAGER_H
+#ifdef _WIN32
+#pragma once
+#endif
+
+//----------------------------------------------------------------------------------------
+
+#include "interface.h"
+#include "replay/replayhandle.h"
+
+//----------------------------------------------------------------------------------------
+
+class CBaseRecordingSession;
+
+//----------------------------------------------------------------------------------------
+
+class IRecordingSessionManager : public IBaseInterface
+{
+public:
+	virtual CBaseRecordingSession	*FindSession( ReplayHandle_t hSession ) = 0;
+	virtual const CBaseRecordingSession	*FindSession( ReplayHandle_t hSession ) const = 0;
+	virtual void					FlagSessionForFlush( CBaseRecordingSession *pSession, bool bForceImmediate ) = 0;
+	virtual int						GetServerStartTickForSession( ReplayHandle_t hSession ) = 0;
+};
+
+//----------------------------------------------------------------------------------------
+
+#endif // IRECORDINGSESSIONMANAGER_H
--- a/common/replay/ireplaycamera.h
+++ b/common/replay/ireplaycamera.h
@ -0,0 +1,25 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+//----------------------------------------------------------------------------------------
+
+#ifndef IREPLAYCAMERA_H
+#define IREPLAYCAMERA_H
+#ifdef _WIN32
+#pragma once
+#endif
+
+//----------------------------------------------------------------------------------------
+
+#include "interface.h"
+
+//----------------------------------------------------------------------------------------
+
+abstract_class IReplayCamera : public IBaseInterface
+{
+public:
+	virtual void		ClearOverrideView() = 0;
+};
+
+//----------------------------------------------------------------------------------------
+
+#endif // IREPLAYCAMERA_H
--- a/common/replay/ireplaycontext.h
+++ b/common/replay/ireplaycontext.h
@ -0,0 +1,47 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+//=======================================================================================//
+
+#ifndef IREPLAYCONTEXT_H
+#define IREPLAYCONTEXT_H
+#ifdef _WIN32
+#pragma once
+#endif
+
+//----------------------------------------------------------------------------------------
+
+#include "interface.h"
+#include "replay/replayhandle.h"
+
+//----------------------------------------------------------------------------------------
+
+class IRecordingSessionManager;
+class IRecordingSessionBlockManager;
+class IRecordingSession;
+class IReplayErrorSystem;
+
+//----------------------------------------------------------------------------------------
+
+class IReplayContext : public IBaseInterface
+{
+public:
+	virtual bool			Init( CreateInterfaceFn fnCreateFactory ) = 0;
+	virtual void			Shutdown() = 0;
+
+	virtual void			Think() = 0;
+
+	virtual bool			IsInitialized() const = 0;
+	
+	virtual const char		*GetRelativeBaseDir() const = 0;	// Returns path to wherever the index .dmx lives relative to the game path, e.g. "replay\client\"
+	virtual const char		*GetBaseDir() const = 0;	// Returns full directory to wherever the index .dmx lives, e.g. c:\program files (x86)\steam\steamapps\<username>\team fortress 2\tf\replays\<client|server>\ -- NOTE: includes trailing slash
+	virtual const char		*GetReplaySubDir() const = 0;	// Returns "client" or "server"
+
+	virtual IReplayErrorSystem	*GetErrorSystem() = 0;
+	virtual IRecordingSessionManager		*GetRecordingSessionManager() = 0;
+	virtual IRecordingSessionBlockManager	*GetRecordingSessionBlockManager() = 0;
+	virtual IRecordingSession	*GetRecordingSession( ReplayHandle_t hSession ) = 0;
+};
+
+//----------------------------------------------------------------------------------------
+
+#endif // IREPLAYCONTEXT_H
--- a/common/replay/ireplaydemoplayer.h
+++ b/common/replay/ireplaydemoplayer.h
@ -0,0 +1,42 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+//=======================================================================================//
+
+#ifndef IREPLAYDEMOPLAYER_H
+#define IREPLAYDEMOPLAYER_H
+#ifdef _WIN32
+#pragma once
+#endif
+
+//----------------------------------------------------------------------------------------
+
+#include "interface.h"
+#include "replay/replay.h"
+
+//----------------------------------------------------------------------------------------
+
+#define INTERFACEVERSION_REPLAYDEMOPLAYER	"ReplayDemoPlayer001"
+
+//----------------------------------------------------------------------------------------
+
+//
+// Interface for replay demo player
+//
+class IReplayDemoPlayer : public IBaseInterface
+{
+public:
+	virtual void			PlayReplay( ReplayHandle_t hReplay, int iPerformance ) = 0;
+	virtual void			PlayNextReplay() = 0;
+	virtual void			ClearReplayList() = 0;
+	virtual void			AddReplayToList( ReplayHandle_t hReplay, int iPerformance ) = 0;
+	virtual CReplay			*GetCurrentReplay() = 0;
+	virtual CReplayPerformance *GetCurrentPerformance() = 0;	// The playing replay, or NULL if playing the original replay
+	virtual void			PauseReplay() = 0;
+	virtual bool			IsReplayPaused() = 0;
+	virtual void			ResumeReplay() = 0;
+	virtual void			OnSignonStateFull() = 0;
+};
+
+//----------------------------------------------------------------------------------------
+
+#endif // IREPLAYDEMOPLAYER_H
--- a/common/replay/ireplayerrorsystem.h
+++ b/common/replay/ireplayerrorsystem.h
@ -0,0 +1,33 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+//=======================================================================================//
+
+#ifndef IREPLAYERRORSYSYTEM_H
+#define IREPLAYERRORSYSYTEM_H
+#ifdef _WIN32
+#pragma once
+#endif
+
+//----------------------------------------------------------------------------------------
+
+#include "interface.h"
+
+//----------------------------------------------------------------------------------------
+
+class KeyValues;
+
+//----------------------------------------------------------------------------------------
+
+//
+// Replay error system
+//
+class IReplayErrorSystem : public IBaseInterface
+{
+public:
+	virtual void	AddErrorFromTokenName( const char *pToken ) = 0;
+	virtual void	AddFormattedErrorFromTokenName( const char *pFormatToken, KeyValues *pFormatArgs ) = 0;
+};
+
+//----------------------------------------------------------------------------------------
+
+#endif // IREPLAYERRORSYSYTEM_H
--- a/common/replay/ireplayfactory.h
+++ b/common/replay/ireplayfactory.h
@ -0,0 +1,31 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+//=======================================================================================//
+
+#ifndef IREPLAYFACTORY_H
+#define IREPLAYFACTORY_H
+#ifdef _WIN32
+#pragma once
+#endif
+
+//----------------------------------------------------------------------------------------
+
+#include "interface.h"
+
+//----------------------------------------------------------------------------------------
+
+class CReplay;
+
+//----------------------------------------------------------------------------------------
+
+abstract_class IReplayFactory : public IBaseInterface
+{
+public:
+	virtual CReplay		*Create() = 0;
+};
+
+#define INTERFACE_VERSION_REPLAY_FACTORY	"IReplayFactory001"
+
+//----------------------------------------------------------------------------------------
+
+#endif // IREPLAYFACTORY_H
--- a/common/replay/ireplaymanager.h
+++ b/common/replay/ireplaymanager.h
@ -0,0 +1,42 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+//=======================================================================================//
+
+#ifndef IREPLAYMANAGER_H
+#define IREPLAYMANAGER_H
+#ifdef _WIN32
+#pragma once
+#endif
+
+//----------------------------------------------------------------------------------------
+
+#include "interface.h"
+#include "replay/replayhandle.h"
+#include "utllinkedlist.h"
+
+//----------------------------------------------------------------------------------------
+
+class CReplay;
+class IQueryableReplayItem;
+
+//----------------------------------------------------------------------------------------
+
+class IReplayManager : public IBaseInterface
+{
+public:
+	virtual CReplay	*GetReplay( ReplayHandle_t hReplay ) = 0;
+	virtual CReplay	*GetPlayingReplay() = 0;
+	virtual CReplay	*GetReplayForCurrentLife() = 0;
+	virtual void	FlagReplayForFlush( CReplay *pReplay, bool bForceImmediate ) = 0;
+	virtual void	DeleteReplay( ReplayHandle_t hReplay, bool bNotifyUI ) = 0;
+	virtual int		GetReplayCount() const = 0;
+	virtual int		GetUnrenderedReplayCount() = 0;	// Get the number of unrendered replays
+	virtual void	GetReplays( CUtlLinkedList< CReplay *, int > &lstReplays ) = 0;
+	virtual void	GetReplaysAsQueryableItems( CUtlLinkedList< IQueryableReplayItem *, int > &lstReplays ) = 0;
+	virtual float	GetDownloadProgress( const CReplay *pReplay ) = 0;
+	virtual const char	*GetReplaysDir() const = 0;
+};
+
+//----------------------------------------------------------------------------------------
+
+#endif // IREPLAYMANAGER_H
--- a/common/replay/ireplaymovie.h
+++ b/common/replay/ireplaymovie.h
@ -0,0 +1,42 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+//=======================================================================================//
+
+#ifndef IREPLAYMOVIE_H
+#define IREPLAYMOVIE_H
+#ifdef _WIN32
+#pragma once
+#endif
+
+//----------------------------------------------------------------------------------------
+
+#include "iqueryablereplayitem.h"
+#include "replay/rendermovieparams.h"
+
+//----------------------------------------------------------------------------------------
+
+abstract_class IReplayMovie : public IQueryableReplayItem
+{
+public:
+	virtual ReplayHandle_t		GetMovieHandle()  const = 0;
+	virtual ReplayHandle_t		GetReplayHandle() const = 0;
+	virtual const ReplayRenderSettings_t &GetRenderSettings() = 0;
+	virtual void				GetFrameDimensions( int &nWidth, int &nHeight ) = 0;
+	virtual void				SetIsRendered( bool bIsRendered ) = 0;
+	virtual void				SetMovieFilename( const char *pFilename ) = 0;
+	virtual const char			*GetMovieFilename() const = 0;
+	virtual void				SetMovieTitle( const wchar_t *pTitle ) = 0;
+	virtual void				SetRenderTime( float flRenderTime ) = 0;
+	virtual float				GetRenderTime() const = 0;
+	virtual void				CaptureRecordTime() = 0;
+	virtual void				SetLength( float flLength ) = 0;
+
+	virtual bool				IsUploaded() const = 0;
+	virtual void				SetUploaded( bool bUploaded ) = 0;
+	virtual void				SetUploadURL( const char *pURL ) = 0;
+	virtual const char			*GetUploadURL() const = 0;
+};
+
+//----------------------------------------------------------------------------------------
+
+#endif // IREPLAYMOVIE_H
--- a/common/replay/ireplaymoviemanager.h
+++ b/common/replay/ireplaymoviemanager.h
@ -0,0 +1,56 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+//=======================================================================================//
+
+#ifndef IREPLAYMOVIEMANAGER_H
+#define IREPLAYMOVIEMANAGER_H
+#ifdef _WIN32
+#pragma once
+#endif
+
+//----------------------------------------------------------------------------------------
+
+#include "interface.h"
+#include "utlstring.h"
+#include "utllinkedlist.h"
+#include "replay/replayhandle.h"
+
+//----------------------------------------------------------------------------------------
+
+class IReplayMovie;
+class CReplay;
+struct RenderMovieParams_t;
+class IQueryableReplayItem;
+
+//----------------------------------------------------------------------------------------
+
+abstract_class IReplayMovieManager : public IBaseInterface
+{
+public:
+	virtual int				GetMovieCount() = 0;
+	virtual void			GetMovieList( CUtlLinkedList< IReplayMovie * > &list ) = 0;	// Fills the list with all movies
+	virtual IReplayMovie	*GetMovie( ReplayHandle_t hMovie ) = 0;
+	virtual IReplayMovie	*CreateAndAddMovie( ReplayHandle_t hReplay ) = 0;	// Creates and adds a movie based on the given replay
+	virtual void			DeleteMovie( ReplayHandle_t hMovie ) = 0;	// Delete a movie
+	virtual int				GetNumMoviesDependentOnReplay( const CReplay *pReplay ) = 0;	// Get the number of movies that depend on the given replay
+	virtual void			GetCachedMovieTitleAndClear( wchar_t *pOut, int nOutBufLength ) = 0;	// TODO: This is a hack - fix this
+	virtual void			SetPendingMovie( IReplayMovie *pMovie ) = 0;
+	virtual IReplayMovie	*GetPendingMovie() = 0;
+	virtual void			FlagMovieForFlush( IReplayMovie *pMovie, bool bImmediate ) = 0;
+	virtual void			GetMoviesAsQueryableItems( CUtlLinkedList< IQueryableReplayItem *, int > &lstMovies ) = 0;
+	virtual const char		*GetRenderDir() const = 0;
+	virtual const char		*GetRawExportDir() const = 0;
+
+	// TODO: Is this the best place for code that actually manages rendering?
+	virtual bool			IsRendering() const = 0;
+	virtual bool			RenderingCancelled() const = 0;
+	virtual void			RenderMovie( RenderMovieParams_t const& params ) = 0;	// Renders the given replay - or if params.hReplay is -1, render all unrendered replays
+	virtual void			RenderNextMovie() = 0;
+	virtual void			CompleteRender( bool bSuccess, bool bShowBrowser ) = 0;
+	virtual void			CancelRender() = 0;
+	virtual void			ClearRenderCancelledFlag() = 0;
+};
+
+//----------------------------------------------------------------------------------------
+
+#endif // IREPLAYMOVIEMANAGER_H
--- a/common/replay/ireplaymovierenderer.h
+++ b/common/replay/ireplaymovierenderer.h
@ -0,0 +1,33 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+//=======================================================================================//
+
+#ifndef IREPLAYMOVIERENDERER_H
+#define IREPLAYMOVIERENDERER_H
+#ifdef _WIN32
+#pragma once
+#endif
+
+//----------------------------------------------------------------------------------------
+
+class IReplayMovie;
+struct RenderMovieParams_t;
+
+//----------------------------------------------------------------------------------------
+
+abstract_class IReplayMovieRenderer : public IBaseInterface
+{
+public:
+	virtual bool			SetupRenderer( RenderMovieParams_t &params, IReplayMovie *pMovie ) = 0;
+	virtual void			ShutdownRenderer() = 0;
+	virtual void			RenderVideo() = 0;
+	virtual void			RenderAudio( unsigned char *pBuffer, int nSize, int nNumSamples ) = 0;
+	
+	virtual void			SetAudioSyncFrame( bool isSync = false ) = 0;
+	virtual bool			IsAudioSyncFrame() = 0;
+	virtual float			GetRecordingFrameDuration() = 0;
+};
+
+//----------------------------------------------------------------------------------------
+
+#endif // IREPLAYMOVIERENDERER_H
--- a/common/replay/ireplayperformancecontroller.h
+++ b/common/replay/ireplayperformancecontroller.h
@ -0,0 +1,107 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+//=======================================================================================//
+
+#ifndef IREPLAYPERFORMANCECONTROLLER_H
+#define IREPLAYPERFORMANCECONTROLLER_H
+#ifdef _WIN32
+#pragma once
+#endif
+
+//----------------------------------------------------------------------------------------
+
+#include "interface.h"
+#include "tier1/strtools.h"
+
+//----------------------------------------------------------------------------------------
+
+class IReplayPerformanceEditor;
+class CReplay;
+class Vector;
+class QAngle;
+class CReplayPerformance;
+
+//----------------------------------------------------------------------------------------
+
+// These values are what we use to represent 
+
+struct SetViewParams_t 
+{
+	SetViewParams_t() { V_memset( this, 0, sizeof( SetViewParams_t ) ); }
+	SetViewParams_t( float flTime, Vector *pOrigin, QAngle *pAngles, float flFov, float flAccel,
+					 float flSpeed, float flRotFilter )
+	:	m_flTime( flTime ),
+		m_pOrigin( pOrigin ),
+		m_pAngles( pAngles ),
+		m_flFov( flFov ),
+		m_flAccel( flAccel ),
+		m_flSpeed( flSpeed ),
+		m_flRotationFilter( flRotFilter )
+	{
+	}
+
+	float	m_flTime;
+	Vector	*m_pOrigin;
+	QAngle	*m_pAngles;
+	float	m_flFov;
+
+	// Right now only used for updating UI during playback:
+	float	m_flAccel;
+	float	m_flSpeed;
+	float	m_flRotationFilter;
+};
+
+//----------------------------------------------------------------------------------------
+
+class IReplayPerformanceController : public IBaseInterface
+{
+public:
+	virtual void		SetEditor( IReplayPerformanceEditor *pEditor ) = 0;
+
+	virtual bool		IsPlaybackDataLeft() = 0;
+
+	virtual void		StartRecording( CReplay *pReplay, bool bSnip ) = 0;
+	virtual void		NotifyRewinding() = 0;
+
+	virtual void		Stop() = 0;
+	virtual bool		SaveAsync() = 0;
+	virtual bool		SaveAsAsync( const wchar *pTitle ) = 0;
+
+	virtual bool		IsSaving() const = 0;
+
+	virtual void		SaveThink() = 0;
+
+	virtual bool		GetLastSaveStatus() const = 0;
+
+	virtual bool		IsRecording() const = 0;
+	virtual bool		IsPlaying() const = 0;
+
+	virtual bool		IsDirty() const = 0;
+	virtual void		NotifyDirty() = 0;
+
+	virtual CReplayPerformance	*GetPerformance() = 0;
+	virtual CReplayPerformance	*GetSavedPerformance() = 0;
+	virtual bool		HasSavedPerformance() = 0;
+
+	virtual void		NotifyPauseState( bool bPaused ) = 0;
+
+	virtual void		ClearRewinding() = 0;
+
+	virtual void		OnSignonStateFull() = 0;
+
+	virtual float		GetPlaybackTimeScale() const = 0;
+
+	//
+	// Recorder-specific:
+	//
+	virtual void		AddEvent_Camera_Change_FirstPerson( float flTime, int nEntityIndex ) = 0;
+	virtual void		AddEvent_Camera_Change_ThirdPerson( float flTime, int nEntityIndex ) = 0;
+	virtual void		AddEvent_Camera_Change_Free( float flTime ) = 0;
+	virtual void		AddEvent_Camera_ChangePlayer( float flTime, int nEntIndex ) = 0;
+	virtual void		AddEvent_Camera_SetView( const SetViewParams_t &params ) = 0;
+	virtual void		AddEvent_TimeScale( float flTime, float flScale ) = 0;
+};
+
+//----------------------------------------------------------------------------------------
+
+#endif // IREPLAYPERFORMANCECONTROLLER_H
--- a/common/replay/ireplayperformanceeditor.h
+++ b/common/replay/ireplayperformanceeditor.h
@ -0,0 +1,33 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+//=======================================================================================//
+
+#ifndef IREPLAYPERFORMANCEEDITOR_H
+#define IREPLAYPERFORMANCEEDITOR_H
+#ifdef _WIN32
+#pragma once
+#endif
+
+//----------------------------------------------------------------------------------------
+
+#include "interface.h"
+
+//----------------------------------------------------------------------------------------
+
+class CReplay;
+
+//----------------------------------------------------------------------------------------
+
+//
+// Interface to allow the replay DLL to talk to the actual UI.
+//
+class IReplayPerformanceEditor : public IBaseInterface
+{
+public:
+	virtual CReplay *GetReplay() = 0;
+	virtual void	OnRewindComplete() = 0;
+};
+
+//----------------------------------------------------------------------------------------
+
+#endif // IREPLAYPERFORMANCEEDITOR_H
--- a/common/replay/ireplayperformancemanager.h
+++ b/common/replay/ireplayperformancemanager.h
@ -0,0 +1,36 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+//=======================================================================================//
+
+#ifndef IREPLAYPERFORMANCEMANAGER_H
+#define IREPLAYPERFORMANCEMANAGER_H
+#ifdef _WIN32
+#pragma once
+#endif
+
+//----------------------------------------------------------------------------------------
+
+#include "interface.h"
+
+//----------------------------------------------------------------------------------------
+
+class CReplayPerformance;
+class CReplay;
+
+//----------------------------------------------------------------------------------------
+
+class IReplayPerformanceManager : public IBaseInterface
+{
+public:
+	virtual CReplayPerformance	*CreatePerformance( CReplay *pReplay ) = 0;
+	virtual void				DeletePerformance( CReplayPerformance *pPerformance ) = 0;
+
+	virtual const char			*GetRelativePath() const = 0;
+	virtual const char 			*GetFullPath() const = 0;
+
+	virtual const char			*GeneratePerformanceFilename( CReplay *pReplay ) = 0;
+};
+
+//----------------------------------------------------------------------------------------
+
+#endif // IREPLAYPERFORMANCEMANAGER_H
--- a/common/replay/ireplayperformanceplaybackhandler.h
+++ b/common/replay/ireplayperformanceplaybackhandler.h
@ -0,0 +1,36 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+//=======================================================================================//
+
+#ifndef IREPLAYPERFORMANCEPLAYBACKHANDLER_H
+#define IREPLAYPERFORMANCEPLAYBACKHANDLER_H
+#ifdef _WIN32
+#pragma once
+#endif
+
+//----------------------------------------------------------------------------------------
+
+#include "interface.h"
+#include "replay/ireplayperformancecontroller.h"
+
+//----------------------------------------------------------------------------------------
+
+class Vector;
+class QAngle;
+
+//----------------------------------------------------------------------------------------
+
+class IReplayPerformancePlaybackHandler : public IBaseInterface
+{
+public:
+	virtual void		OnEvent_Camera_Change_FirstPerson( float flTime, int nEntityIndex ) = 0;
+	virtual void		OnEvent_Camera_Change_ThirdPerson( float flTime, int nEntityIndex ) = 0;
+	virtual void		OnEvent_Camera_Change_Free( float flTime ) = 0;
+	virtual void		OnEvent_Camera_ChangePlayer( float flTime, int nEntIndex ) = 0;
+	virtual void		OnEvent_Camera_SetView( const SetViewParams_t &params ) = 0;
+	virtual void		OnEvent_TimeScale( float flTime, float flScale ) = 0;
+};
+
+//----------------------------------------------------------------------------------------
+
+#endif // IREPLAYPERFORMANCEPLAYBACKHANDLER_H
--- a/common/replay/ireplayperformanceplayer.h
+++ b/common/replay/ireplayperformanceplayer.h
@ -0,0 +1,33 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+//=======================================================================================//
+
+#ifndef IREPLAYPERFORMANCEPLAYER_H
+#define IREPLAYPERFORMANCEPLAYER_H
+#ifdef _WIN32
+#pragma once
+#endif
+
+//----------------------------------------------------------------------------------------
+
+#include "interface.h"
+
+//----------------------------------------------------------------------------------------
+
+class CReplay;
+class CReplayPerformance;
+
+//----------------------------------------------------------------------------------------
+
+class IReplayPerformancePlayer : public IBaseInterface
+{
+public:
+	virtual void		BeginPerformancePlay( CReplayPerformance *pPerformance ) = 0;
+	virtual void		EndPerformancePlay() = 0;
+
+	virtual bool		IsPlaying() const = 0;
+};
+
+//----------------------------------------------------------------------------------------
+
+#endif // IREPLAYPERFORMANCEPLAYER_H
--- a/common/replay/ireplayperformancerecorder.h
+++ b/common/replay/ireplayperformancerecorder.h
@ -0,0 +1,49 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+//=======================================================================================//
+
+#ifndef IREPLAYPERFORMANCERECORDER_H
+#define IREPLAYPERFORMANCERECORDER_H
+#ifdef _WIN32
+#pragma once
+#endif
+
+//----------------------------------------------------------------------------------------
+
+#include "interface.h"
+
+//----------------------------------------------------------------------------------------
+
+class CReplay;
+class Vector;
+class QAngle;
+class CReplayPerformance;
+
+//----------------------------------------------------------------------------------------
+
+class IReplayPerformanceRecorder : public IBaseInterface
+{
+public:
+	virtual void		BeginPerformanceRecord( CReplay *pReplay ) = 0;
+	virtual void		EndPerformanceRecord() = 0;
+
+	virtual void		NotifyPauseState( bool bPaused ) = 0;
+
+	virtual CReplayPerformance	*GetPerformance() = 0;
+	virtual bool		IsRecording() const = 0;
+
+	virtual void		SnipAtTime( float flTime ) = 0;
+	virtual void		NotifySkipping() = 0;
+	virtual void		ClearSkipping() = 0;
+
+	virtual void		AddEvent_Camera_Change_FirstPerson( float flTime, int nEntityIndex ) = 0;
+	virtual void		AddEvent_Camera_Change_ThirdPerson( float flTime, int nEntityIndex ) = 0;
+	virtual void		AddEvent_Camera_Change_Free( float flTime ) = 0;
+	virtual void		AddEvent_Camera_ChangePlayer( float flTime, int nEntIndex ) = 0;
+	virtual void		AddEvent_Camera_SetView( float flTime, const Vector& origin, const QAngle &angles, float fov ) = 0;
+	virtual void		AddEvent_Slowmo( float flTime, float flScale ) = 0;
+};
+
+//----------------------------------------------------------------------------------------
+
+#endif // IREPLAYPERFORMANCERECORDER_H
--- a/common/replay/ireplayplayercache.h
+++ b/common/replay/ireplayplayercache.h
@ -0,0 +1,41 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+//----------------------------------------------------------------------------------------
+
+#ifndef IREPLAYPLAYERCACHE_H
+#define IREPLAYPLAYERCACHE_H
+#ifdef _WIN32
+#pragma once
+#endif
+
+#include "interface.h"
+
+//----------------------------------------------------------------------------------------
+
+#define REPLAYPLAYERCACHE_INTERFACE_VERSION		"VENGINE_REPLAY_PLAYER_CACHE_001"
+
+//----------------------------------------------------------------------------------------
+
+abstract_class IReplayPlayerCache : public IBaseInterface
+{
+public:
+	virtual bool Init() = 0;
+	virtual void Shutdown() = 0;
+
+	virtual void SetupPlayer( int nEntIndex ) = 0;
+	virtual void DeletePlayerEntry( int nEntIndex ) = 0;
+
+	virtual bool PlayerHasCacheEntry( int nEntIndex ) = 0;
+
+	virtual void SetPlayerClass( int nEntIndex, const char *pPlayerClass ) = 0;
+	virtual void SetPlayerSpawnTick( int nEntIndex, int nTick ) = 0;
+	virtual void SetPlayerDeathTick( int nEntIndex, int nTick ) = 0;
+
+	virtual const char *GetPlayerClass( int nEntIndex ) = 0;
+	virtual int GetPlayerSpawnTick( int nEntIndex ) = 0;
+	virtual int GetPlayerDeathTick( int nEntIndex ) = 0;
+};
+
+//----------------------------------------------------------------------------------------
+
+#endif // IREPLAYPLAYERCACHE_H
--- a/common/replay/ireplayrenderqueue.h
+++ b/common/replay/ireplayrenderqueue.h
@ -0,0 +1,32 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+//=======================================================================================//
+
+#ifndef IREPLAYRENDERQUEUE_H
+#define IREPLAYRENDERQUEUE_H
+#ifdef _WIN32
+#pragma once
+#endif
+
+//----------------------------------------------------------------------------------------
+
+#include "interface.h"
+#include "replay/replayhandle.h"
+
+//----------------------------------------------------------------------------------------
+
+abstract_class IReplayRenderQueue : IBaseInterface
+{
+public:
+	virtual void	Add( ReplayHandle_t hReplay, int iPerformance ) = 0;
+	virtual void	Remove( ReplayHandle_t hReplay, int iPerformance ) = 0;
+	virtual void	Clear() = 0;
+
+	virtual int		GetCount() const = 0;
+	virtual bool	GetEntryData( int iIndex, ReplayHandle_t *pHandleOut, int *pPerformanceOut ) const = 0;
+	virtual bool	IsInQueue( ReplayHandle_t hReplay, int iPerformance ) const = 0;
+};
+
+//----------------------------------------------------------------------------------------
+
+#endif // IREPLAYRENDERQUEUE_H
--- a/common/replay/ireplayscreenshotmanager.h
+++ b/common/replay/ireplayscreenshotmanager.h
@ -0,0 +1,32 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+//=======================================================================================//
+
+#ifndef IREPLAYSCREENSHOTMANAGER_H
+#define IREPLAYSCREENSHOTMANAGER_H
+#ifdef _WIN32
+#pragma once
+#endif
+
+//----------------------------------------------------------------------------------------
+
+#include "interface.h"
+
+//----------------------------------------------------------------------------------------
+
+class CReplay;
+struct CaptureScreenshotParams_t;
+
+//----------------------------------------------------------------------------------------
+
+class IReplayScreenshotManager : public IBaseInterface
+{
+public:
+	virtual void		CaptureScreenshot( CaptureScreenshotParams_t& params ) = 0;
+	virtual void		GetUnpaddedScreenshotSize( int &nOutWidth, int &nOutHeight ) = 0;
+	virtual void		DeleteScreenshotsForReplay( CReplay *pReplay ) = 0;
+};
+
+//----------------------------------------------------------------------------------------
+
+#endif // IREPLAYSCREENSHOTMANAGER_H
--- a/common/replay/ireplayscreenshotsystem.h
+++ b/common/replay/ireplayscreenshotsystem.h
@ -0,0 +1,34 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+//=======================================================================================//
+
+#ifndef IREPLAYSCREENSHOTSYSTEM_H
+#define IREPLAYSCREENSHOTSYSTEM_H
+#ifdef _WIN32
+#pragma once
+#endif
+
+//----------------------------------------------------------------------------------------
+
+#include "interface.h"
+
+//----------------------------------------------------------------------------------------
+
+struct WriteReplayScreenshotParams_t;
+
+//----------------------------------------------------------------------------------------
+
+//
+// Implementation lives in the client - allows replay to tell the client to grab a
+// screenshot or update the cache.
+//
+class IReplayScreenshotSystem : public IBaseInterface
+{
+public:
+	virtual void	WriteReplayScreenshot( WriteReplayScreenshotParams_t &params ) = 0;
+	virtual void	UpdateReplayScreenshotCache() = 0;
+};
+
+//----------------------------------------------------------------------------------------
+
+#endif // IREPLAYSCREENSHOTSYSTEM_H
--- a/common/replay/ireplayserializeable.h
+++ b/common/replay/ireplayserializeable.h
@ -0,0 +1,48 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+//=======================================================================================//
+
+#ifndef IREPLAYSERIALIIZEABLE_H
+#define IREPLAYSERIALIIZEABLE_H
+#ifdef _WIN32
+#pragma once
+#endif
+
+//----------------------------------------------------------------------------------------
+
+#include "interface.h"
+#include "replay/replayhandle.h"
+
+//----------------------------------------------------------------------------------------
+
+class KeyValues;
+
+//----------------------------------------------------------------------------------------
+
+class IReplaySerializeable : public IBaseInterface
+{
+public:
+	virtual void			SetHandle( ReplayHandle_t h ) = 0;
+	virtual ReplayHandle_t	GetHandle() const = 0;
+
+	virtual bool			Read( KeyValues *pIn ) = 0;
+	virtual void			Write( KeyValues *pOut ) = 0;
+
+	virtual const char		*GetSubKeyTitle() const = 0;
+	virtual const char		*GetFilename() const = 0;
+	virtual const char		*GetPath() const = 0;
+
+	virtual const char		*GetFullFilename() const = 0;
+
+	virtual void			SetLocked( bool bLocked ) = 0;
+	virtual bool			IsLocked() const = 0;
+
+	virtual void			OnDelete() = 0;
+	virtual void			OnUnload() = 0;
+
+	virtual const char		*GetDebugName() const = 0;
+};
+
+//----------------------------------------------------------------------------------------
+
+#endif // IREPLAYSERIALIIZEABLE_H
--- a/common/replay/ireplayserver.h
+++ b/common/replay/ireplayserver.h
@ -0,0 +1,48 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+// $NoKeywords: $
+//
+//=============================================================================//
+
+#ifndef IREPLAYSERVER_H
+#define IREPLAYSERVER_H
+
+#ifdef _WIN32
+#pragma once
+#endif
+
+//-----------------------------------------------------------------------------
+
+#include "interface.h"
+
+//-----------------------------------------------------------------------------
+
+class IServer;
+class IReplayDirector;
+class IGameEvent;
+struct netadr_s;
+class CServerReplay;
+
+//-----------------------------------------------------------------------------
+// Interface the Replay module exposes to the engine
+//-----------------------------------------------------------------------------
+#define INTERFACEVERSION_REPLAYSERVER	"ReplayServer001"
+
+class IReplayServer : public IBaseInterface
+{
+public:
+	virtual	~IReplayServer() {}
+
+	virtual	IServer	*GetBaseServer() = 0; // get Replay base server interface
+	virtual	IReplayDirector *GetDirector() = 0;	// get director interface
+	virtual	int		GetReplaySlot() = 0; // return entity index-1 of Replay in game
+	virtual float	GetOnlineTime() = 0; // seconds since broadcast started
+	virtual void	BroadcastEvent(IGameEvent *event) = 0; // send a director command to all specs
+	virtual bool	IsRecording() = 0;
+	virtual void	StartRecording() = 0;
+	virtual void	StopRecording() = 0;
+};
+
+#endif
--- a/common/replay/ireplaysessionrecorder.h
+++ b/common/replay/ireplaysessionrecorder.h
@ -0,0 +1,27 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+//=======================================================================================//
+
+#ifndef IREPLAYSESSIONRECORDER_H
+#define IREPLAYSESSIONRECORDER_H
+#ifdef _WIN32
+#pragma once
+#endif
+
+//----------------------------------------------------------------------------------------
+
+#include "interface.h"
+
+//----------------------------------------------------------------------------------------
+
+class IReplaySessionRecorder : public IBaseInterface
+{
+public:
+	virtual void		StartRecording() = 0;
+	virtual void		StopRecording( bool bAborting ) = 0;
+	virtual void		SetCurrentRecordingStartTick( int nStartTick ) = 0;
+};
+
+//----------------------------------------------------------------------------------------
+
+#endif // IREPLAYSESSIONRECORDER_H
--- a/common/replay/ireplaysystem.h
+++ b/common/replay/ireplaysystem.h
@ -0,0 +1,60 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+//=======================================================================================//
+
+#ifndef IREPLAYSYSTEM_H
+#define IREPLAYSYSTEM_H
+#ifdef _WIN32
+#pragma once
+#endif
+
+//----------------------------------------------------------------------------------------
+
+#include "appframework/IAppSystem.h"
+
+//----------------------------------------------------------------------------------------
+
+class IClientReplayContext;
+class IServerReplayContext;
+class IGameEvent;
+
+//----------------------------------------------------------------------------------------
+
+abstract_class IReplaySystem : public IAppSystem
+{
+public:
+	// IAppSystem:
+	virtual bool		Connect( CreateInterfaceFn fnFactory ) = 0;
+	virtual void		Disconnect() = 0;
+	virtual InitReturnVal_t Init() = 0;
+	virtual void		Shutdown() = 0;
+
+	// To be called client- & server-side
+	virtual void		Think() = 0;
+	virtual bool		IsReplayEnabled() = 0;
+	virtual bool		IsRecording() = 0;
+
+	// To be called client-side only - on dedicated servers, only subs defined
+	virtual bool		CL_Init( CreateInterfaceFn fnClientFactory ) = 0; 
+	virtual void		CL_Shutdown() = 0;
+	virtual void		CL_Render() = 0;
+	virtual IClientReplayContext	*CL_GetContext() = 0;
+
+	// To be called server-side only
+	virtual bool		SV_Init( CreateInterfaceFn fnFactory ) = 0;
+	virtual void		SV_Shutdown() = 0;
+	virtual void		SV_EndRecordingSession( bool bForceSynchronousPublish = false ) = 0;
+	virtual void		SV_SendReplayEvent( const char *pEventName, int nClientSlot ) = 0;
+	virtual void		SV_SendReplayEvent( IGameEvent *pEvent, int nClientSlot ) = 0;
+	virtual bool		SV_ShouldBeginRecording( bool bIsInWaitingForPlayers ) = 0;
+	virtual void		SV_NotifyReplayRequested() = 0;
+	virtual IServerReplayContext	*SV_GetContext() = 0;
+};
+
+//----------------------------------------------------------------------------------------
+
+#define REPLAY_INTERFACE_VERSION "ReplaySystem001"
+
+//----------------------------------------------------------------------------------------
+
+#endif // IREPLAYSYSTEM_H
--- a/common/replay/iserverengine.h
+++ b/common/replay/iserverengine.h
@ -0,0 +1,27 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+//=======================================================================================//
+
+#ifndef ISERVERENGINE_H
+#define ISERVERENGINE_H
+#ifdef _WIN32
+#pragma once
+#endif
+
+//----------------------------------------------------------------------------------------
+
+#include "interface.h"
+
+//----------------------------------------------------------------------------------------
+
+class IReplayServerEngine : public IBaseInterface
+{
+public:
+	virtual void EndReplayRecordingSession() = 0;
+	virtual bool IsReplayRecording() = 0;
+	virtual bool IsReplay() = 0;
+};
+
+//----------------------------------------------------------------------------------------
+
+#endif // ISERVERENGINE_H
--- a/common/replay/iserverreplay.h
+++ b/common/replay/iserverreplay.h
@ -0,0 +1,37 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+//=======================================================================================//
+
+#ifndef ISERVERREPLAY_H
+#define ISERVERREPLAY_H
+#ifdef _WIN32
+#pragma once
+#endif
+
+//----------------------------------------------------------------------------------------
+
+#include "interface.h"
+
+//----------------------------------------------------------------------------------------
+
+#define SERVER_REPLAY_INTERFACE_VERSION		"ServerReplay001"
+
+//----------------------------------------------------------------------------------------
+
+class IReplayFactory;
+class KeyValues;
+
+//----------------------------------------------------------------------------------------
+
+//
+// Allows the replay DLL to talk to the server
+//
+class IServerReplay : public IBaseInterface
+{
+public:
+	virtual void				UploadOgsData( KeyValues *pData, bool bIncludeTimeField ) = 0;
+};
+
+//----------------------------------------------------------------------------------------
+
+#endif // ISERVERREPLAY_H
--- a/common/replay/iserverreplaycontext.h
+++ b/common/replay/iserverreplaycontext.h
@ -0,0 +1,38 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+//=======================================================================================//
+
+#ifndef ISERVERREPLAYCONTEXT_H
+#define ISERVERREPLAYCONTEXT_H
+#ifdef _WIN32
+#pragma once
+#endif
+
+//----------------------------------------------------------------------------------------
+
+#include "replay/ireplaycontext.h"
+
+//----------------------------------------------------------------------------------------
+
+class IGameEvent;
+class IReplaySessionRecorder;
+
+//----------------------------------------------------------------------------------------
+
+#define REPLAYHISTORYMANAGER_INTERFACE_VERSION_SERVER		"VENGINE_SERVER_REPLAY_HISTORY_MANAGER_001"
+
+//----------------------------------------------------------------------------------------
+
+class IServerReplayContext : public IReplayContext
+{
+public:
+	virtual void			FlagForConVarSanityCheck() = 0;	// Checks replay_enable / replay_local_fileserver_path / replay_downloadurlport / replay_downloadurlpath
+	virtual IGameEvent		*CreateReplaySessionInfoEvent() = 0;	// Create "replay_sessioninfo" event w/ appropriate fields filled in
+	virtual IReplaySessionRecorder	*GetSessionRecorder() = 0;
+	virtual const char		*GetLocalFileServerPath() const = 0;	// Returns the local path where session blocks and such should be published for download
+	virtual void			CreateSessionOnClient( int nClientSlot ) = 0;
+};
+
+//----------------------------------------------------------------------------------------
+
+#endif // ISERVERREPLAYCONTEXT_H
--- a/common/replay/performance.h
+++ b/common/replay/performance.h
@ -0,0 +1,63 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+//=======================================================================================//
+
+#ifndef REPLAYPERFORMANCE_H
+#define REPLAYPERFORMANCE_H
+#ifdef _WIN32
+#pragma once
+#endif
+
+//----------------------------------------------------------------------------------------
+
+#include "shared_defs.h"
+#include "qlimits.h"
+
+//----------------------------------------------------------------------------------------
+
+class CReplay;
+class KeyValues;
+
+//----------------------------------------------------------------------------------------
+
+class CReplayPerformance
+{
+public:
+	CReplayPerformance( CReplay *pReplay );
+
+	inline bool HasInTick() const { return m_nTickIn >= 0; }
+	inline bool HasOutTick() const { return m_nTickOut >= 0; }
+
+	inline int	GetTickIn() const { return m_nTickIn; }
+	inline int	GetTickOut() const { return m_nTickOut; }
+
+	void		Copy( const CReplayPerformance *pSrc );
+	void		CopyTicks( const CReplayPerformance *pSrc );
+
+	void		SetFilename( const char *pFilename );
+	const char	*GetFullPerformanceFilename();
+
+	void		AutoNameIfHasNoTitle( const char *pMapName );
+	void		SetTitle( const wchar_t *pTitle );
+	
+	// NOTE: Doesn't copy exactly - gets a valid filename for the returned performance.
+	CReplayPerformance *MakeCopy() const;
+
+	void		Read( KeyValues *pIn );
+	void		Write( KeyValues *pOut );
+
+	// NOTE: Any changes made here should be reflected in the copy constructor
+	// (which is called from MakeCopy()).
+	wchar_t		m_wszTitle[MAX_TAKE_TITLE_LENGTH];
+	char		m_szBaseFilename[ MAX_OSPATH ];
+	CReplay		*m_pReplay;
+	int			m_nTickIn;
+	int			m_nTickOut;
+
+private:
+	CReplayPerformance( const CReplayPerformance *pPerformance );
+};
+
+//----------------------------------------------------------------------------------------
+
+#endif // REPLAYPERFORMANCE_H
--- a/common/replay/rendermovieparams.h
+++ b/common/replay/rendermovieparams.h
@ -0,0 +1,62 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+//=======================================================================================//
+
+#ifndef RENDERMOVIEPARAMS_H
+#define RENDERMOVIEPARAMS_H
+#ifdef _WIN32
+#pragma once
+#endif
+
+//----------------------------------------------------------------------------------------
+
+#include "tier1/utlstring.h"
+#include "tier1/strtools.h"
+#include "replay/replayhandle.h"
+#include "replay/shared_defs.h"
+#include "video/ivideoservices.h"
+
+//----------------------------------------------------------------------------------------
+
+typedef unsigned int MovieHandle_t;
+
+struct RenderMovieParams_t
+{
+	inline RenderMovieParams_t() : m_iPerformance( -1 ) { V_memset( this, 0, sizeof( RenderMovieParams_t ) ); m_Settings.m_FPS.SetFPS( 0, false ); }
+
+	ReplayHandle_t		m_hReplay;
+	int					m_iPerformance;		// -1 for default view, otherwise this is an index into the replay's m_vecPerformances vector.
+	wchar_t				m_wszTitle[MAX_REPLAY_TITLE_LENGTH];
+	char				m_szVideoPreset[64];
+	char				m_szExtension[16];	// File extension
+	bool				m_bQuitWhenFinished;
+	bool				m_bExportRaw;		// Export movie as raw TGA frames and a .WAV
+	float				m_flEngineFps;
+
+	struct ReplayRenderSettings_t
+	{
+		uint16				m_nWidth;
+		uint16				m_nHeight;
+		int8				m_nMotionBlurQuality;	// [0,MAX_MOTION_BLUR_QUALITY]
+		VideoFrameRate_t	m_FPS;					// Actual framerate can be calculated with m_FPS.GetFps()
+		VideoEncodeCodec_t	m_Codec;
+		bool				m_bMotionBlurEnabled;	// Motion blur enabled?
+		bool				m_bAAEnabled;			// Antialiasing enabled?
+		int8				m_nEncodingQuality;		// [0,100]
+		bool				m_bRaw;					// This movie was exported as raw TGA frames and a .WAV file?
+	}
+	m_Settings;
+};
+
+typedef RenderMovieParams_t::ReplayRenderSettings_t ReplayRenderSettings_t;
+
+//----------------------------------------------------------------------------------------
+
+#define MAX_DOF_QUALITY			2
+#define MAX_MOTION_BLUR_QUALITY 3
+#define SUBPIXEL_JITTER_SAMPLES	16
+#define CHEAP_DOF_SAMPLES		4
+
+//----------------------------------------------------------------------------------------
+
+#endif // RENDERMOVIEPARAMS_H
--- a/common/replay/replay.h
+++ b/common/replay/replay.h
@ -0,0 +1,146 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+//=======================================================================================//
+
+#ifndef REPLAY_H
+#define REPLAY_H
+#ifdef _WIN32
+#pragma once
+#endif
+
+//----------------------------------------------------------------------------------------
+
+#include "replay/iqueryablereplayitem.h"
+#include "replay/replaytime.h"
+#include "replay/basereplayserializeable.h"
+#include "qlimits.h"
+#include "utlstring.h"
+#include "utlvector.h"
+#include "replay/shared_defs.h"
+
+//----------------------------------------------------------------------------------------
+
+class IReplayDownloadEventHandler;
+class CReplayScreenshot;
+class CReplayPerformance;
+
+//----------------------------------------------------------------------------------------
+
+class CReplay : public CBaseReplaySerializeable,
+				public IQueryableReplayItem
+{
+	typedef CBaseReplaySerializeable BaseClass;
+
+public:
+	enum ReplayStatus_t
+	{
+		REPLAYSTATUS_INVALID,
+		REPLAYSTATUS_ERROR,
+		REPLAYSTATUS_DOWNLOADPHASE,		// Multiple sub-states during download state
+		REPLAYSTATUS_READYTOCONVERT,	// Download is complete, ready to convert
+		REPLAYSTATUS_RENDERING,			// Currently rendering the file
+		REPLAYSTATUS_RENDERED,
+		REPLAYSTATUS_MAX
+	};
+
+	CReplay();
+	virtual ~CReplay() {}
+
+	//
+	// IReplaySerializeable
+	//
+	virtual const char	*GetSubKeyTitle() const;
+	virtual const char	*GetPath() const;
+	virtual void		OnDelete();
+	virtual bool		Read( KeyValues *pIn );
+	virtual void		Write( KeyValues *pOut );
+
+	virtual void DumpGameSpecificData() const {}
+
+	virtual void Update() {}
+
+	// Hooks to allow replays to setup event listeners, etc.
+	virtual void OnBeginRecording() {}
+	virtual void OnEndRecording() {}
+
+	// Called when a replay is "completed"
+	virtual void OnComplete();
+
+	// Should we allow this replay to be deleted?
+	virtual bool ShouldAllowDelete() const { return true; }
+
+	void AutoNameTitleIfEmpty();
+
+	void AddScreenshot( int nWidth, int nHeight, const char *pBaseFilename );
+
+	bool HasReconstructedReplay() const;
+	bool IsSignificantBlock( int iBlockReconstruction ) const;	// Does this replay care about the given block?
+
+	CReplayPerformance *AddNewPerformance( bool bGenTitle = true, bool bGenFilename = true );
+	void AddPerformance( KeyValues *pIn );
+	void AddPerformance( CReplayPerformance *pPerformance );
+
+	// Accessors:
+	inline int GetScreenshotCount() const			{ return m_vecScreenshots.Count(); }
+	inline const CReplayScreenshot *GetScreenshot( int i ) const { return m_vecScreenshots[ i ]; }
+	bool IsDownloaded() const;
+	inline int GetPerformanceCount() const			{ return m_vecPerformances.Count(); }
+	CReplayPerformance *GetPerformance( int i );
+	const CReplayPerformance *GetPerformance( int i ) const;
+	inline bool HasPerformance( CReplayPerformance *pPerformance )	{ return m_vecPerformances.Find( pPerformance ) != m_vecPerformances.InvalidIndex(); }
+	bool FindPerformance( CReplayPerformance *pPerformance, int &iResult );
+	CReplayPerformance *GetPerformanceWithTitle( const wchar_t *pTitle );
+	inline const char *GetMapName() const { return m_szMapName; }
+	inline int GetSpawnTick() const { return m_nSpawnTick; }
+	inline int GetDeathTick() const { return m_nDeathTick; }
+
+	// IQueryableReplayItem implementation:
+	virtual const CReplayTime &GetItemDate() const;
+	virtual bool IsItemRendered() const;
+	virtual CReplay *GetItemReplay();
+	virtual ReplayHandle_t	GetItemReplayHandle() const;
+	virtual QueryableReplayItemHandle_t	GetItemHandle() const;
+	virtual const wchar_t *GetItemTitle() const;
+	virtual void SetItemTitle( const wchar_t *pTitle );
+	virtual float GetItemLength() const;
+	virtual void *GetUserData();
+	virtual void SetUserData( void* pUserData );
+	virtual bool IsItemAMovie() const;
+
+	// Non-persistent data
+	mutable IReplayDownloadEventHandler *m_pDownloadEventHandler;	// Implemented by replay browser - the reason we've got one per replay rather than
+																	// one per download group is because the browser needs to receive events per-thumbnail
+	bool				m_bSaved;				// True as soon as the replay is saved to disk for the first time
+	bool				m_bRequestedByUser;		// Did the user request to save this replay?
+	bool				m_bComplete;			// Indicates whether the replay is done recording - this should be false
+												// until the player dies, the round ends, or the level changes
+	void				*m_pUserData;
+	float				m_flNextUpdateTime;
+	bool				m_bDirty;
+
+	// Persistent data
+	ReplayHandle_t		m_hSession;			// The recording session in which this replay was recorded
+	char				m_szMapName[MAX_OSPATH];
+	ReplayStatus_t		m_nStatus;
+	const char*			m_pFileURL;	// In the form <protocol>://<server address>:<port number>/path/file - points to the string in the download group
+	wchar_t				m_wszTitle[MAX_REPLAY_TITLE_LENGTH];
+	CUtlString			m_strKilledBy;	// Name of player who killed, if any
+	int					m_nDeathTime;
+	int					m_nSpawnTick;
+	int					m_nDeathTick;
+	float				m_flLength;	// The length of the entire replay, including the post-death time, in seconds
+	bool				m_bRendered;	// Has the replay been rendered yet?
+	int					m_nPlayerSlot;	// Player slot (+1), used to determine which player recorded the demo during playback
+	int					m_nPostDeathRecordTime;	// replay_postdeathrecordtime at the time of record
+	CUtlVector< CReplayScreenshot * >	m_vecScreenshots;
+	CUtlVector< CReplayPerformance * >	m_vecPerformances;
+	int					m_iMaxSessionBlockRequired;	// The maximum session block required to reconstruct a viewable .dem file from spawn tick until length
+	CReplayTime			m_RecordTime;	// Contains time/date when spawn tick was recorded
+	float				m_flStartTime;	// Start time (uses engine's host_time)
+	CUtlString			m_strReconstructedFilename;
+	bool				m_bSavedDuringThisSession;
+};
+
+//----------------------------------------------------------------------------------------
+
+#endif // REPLAY_H
--- a/common/replay/replayhandle.h
+++ b/common/replay/replayhandle.h
@ -0,0 +1,25 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+//=======================================================================================//
+
+#ifndef REPLAYHANDLE_H
+#define REPLAYHANDLE_H
+#ifdef _WIN32
+#pragma once
+#endif
+
+//----------------------------------------------------------------------------------------
+
+#include "platform.h"
+
+//----------------------------------------------------------------------------------------
+
+typedef uint32 ReplayHandle_t;
+
+//----------------------------------------------------------------------------------------
+
+#define REPLAY_HANDLE_INVALID				( (ReplayHandle_t)-1 )
+
+//----------------------------------------------------------------------------------------
+
+#endif // REPLAYHANDLE_H
--- a/common/replay/replaylib.h
+++ b/common/replay/replaylib.h
@ -0,0 +1,21 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+//=======================================================================================//
+
+#ifndef REPLAYLIB_H
+#define REPLAYLIB_H
+#ifdef _WIN32
+#pragma once
+#endif
+
+//----------------------------------------------------------------------------------------
+
+class IClientReplayContext;
+
+//----------------------------------------------------------------------------------------
+
+bool ReplayLib_Init( const char *pGameDir, IClientReplayContext *pClientReplayContext );
+
+//----------------------------------------------------------------------------------------
+
+#endif // REPLAYLIB_H
--- a/common/replay/replaytime.h
+++ b/common/replay/replaytime.h
@ -0,0 +1,57 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+//=======================================================================================//
+
+#ifndef REPLAYTIME_H
+#define REPLAYTIME_H
+#ifdef _WIN32
+#pragma once
+#endif
+
+//----------------------------------------------------------------------------------------
+
+class KeyValues;
+
+//----------------------------------------------------------------------------------------
+
+#include "vgui/ILocalize.h"
+
+//----------------------------------------------------------------------------------------
+
+class CReplayTime
+{
+public:
+	CReplayTime();
+
+	void InitDateAndTimeToNow();
+
+	void Read( KeyValues *pIn );
+	void Write( KeyValues *pOut );
+
+	// Modifiers:
+	void SetDate( int nDay, int nMonth, int nYear );
+	void SetTime( int nHour, int nMin, int nSec );
+	inline void SetRawDate( int nRawDate )	{ m_fDate = nRawDate; }
+	inline void SetRawTime( int nRawTime )	{ m_fTime = nRawTime; }
+
+	// Accessors:
+	void GetTime( int &nHour, int &nMin, int &nSec ) const;
+	void GetDate( int &nDay, int &nMonth, int &nYear ) const;
+
+	static const char *FormatTimeString( int nSecs );
+	static const char *FormatPreciseTimeString( float flSecs );
+	static const wchar_t *GetLocalizedMonth( vgui::ILocalize *pLocalize, int nMonth );
+	static const wchar_t *GetLocalizedDay( vgui::ILocalize *pLocalize, int nDay );
+	static const wchar_t *GetLocalizedYear( vgui::ILocalize *pLocalize, int nYear );
+	static const wchar_t *GetLocalizedTime( vgui::ILocalize *pLocalize, int nHour, int nMin, int nSec );
+	static const wchar_t *GetLocalizedDate( vgui::ILocalize *pLocalize, int nDay, int nMonth, int nYear,
+		int *pHour = NULL, int *pMin = NULL, int *pSec = NULL, bool bForceFullFormat = false );	// bForceFullFormat true will keep from returning "today" or "yesterday"
+	static const wchar_t *GetLocalizedDate( vgui::ILocalize *pLocalize, const CReplayTime &t, bool bForceFullFormat = false );
+
+	int				m_fDate;		// Representation of a date (bitfield)
+	int				m_fTime;		// Representation of time (bitfield)
+};
+
+//----------------------------------------------------------------------------------------
+
+#endif // REPLAYTIME_H
--- a/common/replay/replayutils.h
+++ b/common/replay/replayutils.h
@ -0,0 +1,43 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+//----------------------------------------------------------------------------------------
+
+#ifndef REPLAYUTILS_H
+#define REPLAYUTILS_H
+#ifdef _WIN32
+#pragma once
+#endif
+
+#include "utlstring.h"
+
+void Replay_GetFirstAvailableFilename( char *pDst, int nDstLen, const char *pIdealFilename, const char *pExt,
+									   const char *pFilePath, int nStartIndex );
+
+void Replay_ConstructReplayFilenameString( CUtlString &strOut, const char *pReplaySubDir, const char *pFilename, const char *pGameDir );
+
+//----------------------------------------------------------------------------------------
+// Util function, copied from src/engine/common.cpp
+//----------------------------------------------------------------------------------------
+char *Replay_va( PRINTF_FORMAT_STRING const char *format, ... );
+
+//----------------------------------------------------------------------------------------
+// Return the base dir, e.g. "c:\...\game\tf\replays\"
+//----------------------------------------------------------------------------------------
+const char *Replay_GetBaseDir();
+
+//----------------------------------------------------------------------------------------
+// Set the game directory (only to be called from ReplayLib_Init())
+//----------------------------------------------------------------------------------------
+void Replay_SetGameDir( const char *pGameDir );
+
+//----------------------------------------------------------------------------------------
+// Return the base dir, e.g. "c:\...\game\tf\replays\"
+//----------------------------------------------------------------------------------------
+const char *Replay_GetGameDir();
+
+//----------------------------------------------------------------------------------------
+// Get a name of the format "<map>: <current date & time>" - used for replays and takes.
+//----------------------------------------------------------------------------------------
+void Replay_GetAutoName( OUT_Z_BYTECAP(nDestSizeInBytes) wchar_t *pDest, int nDestSizeInBytes, const char *pMapName );
+
+#endif // REPLAY_H
--- a/common/replay/screenshot.h
+++ b/common/replay/screenshot.h
@ -0,0 +1,72 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+//=======================================================================================//
+
+#ifndef SCREENSHOT_H
+#define SCREENSHOT_H
+#ifdef _WIN32
+#pragma once
+#endif
+
+//----------------------------------------------------------------------------------------
+
+#include "replay/basereplayserializeable.h"
+#include "mathlib/vector.h"
+#include "qlimits.h"
+#include "strtools.h"
+
+//----------------------------------------------------------------------------------------
+
+#define SUBDIR_SCREENSHOTS	"screenshots"
+
+//----------------------------------------------------------------------------------------
+
+class CReplayScreenshot : public CBaseReplaySerializeable
+{
+public:
+	inline CReplayScreenshot( int nWidth = 0, int nHeight = 0, const char *pBaseFilename = NULL )
+	:	m_nWidth( nWidth ), m_nHeight( nHeight )
+	{
+		if ( pBaseFilename )
+		{
+			V_strncpy( m_szBaseFilename, pBaseFilename, sizeof( m_szBaseFilename ) );
+		}
+	}
+
+	virtual bool		Read( KeyValues *pIn );
+	virtual void		Write( KeyValues *pOut );
+	virtual const char	*GetSubKeyTitle() const;
+	virtual const char	*GetPath() const;
+
+	int		m_nWidth;				// Screenshot width (does not include power-of-2 padding)
+	int		m_nHeight;				// Screenshot height (does not include power-of-2 padding)
+	char	m_szBaseFilename[ MAX_OSPATH ];
+};
+
+//----------------------------------------------------------------------------------------
+
+struct CaptureScreenshotParams_t	// To be passed from the client into IReplayHistoryManager::CaptureScreenshot()
+{
+	float		m_flDelay;			// Delay from now (in seconds) when we will take the screenshot
+	int			m_nEntity;			// Should be 0 if no camera adjustment is needed, otherwise should be the index of the entity index from which m_posCamera will be based
+	Vector		m_posCamera;		// Local position, relative to entity's index (if m_nEntity > 0) for camera position
+	QAngle		m_angCamera;		// World angles of camera - used if m_bUseCameraAngles is true
+	bool		m_bUseCameraAngles;	// Should we use m_angCamera - m_nEntity can't be 0
+	bool		m_bIgnoreMinTimeBetweenScreenshots;	// Force screenshot, regardless of replay_mintimebetweenscreenshots?
+	bool		m_bPrimary;			// Only set to true for the primary screenshot, which is taken when the user saves their replay
+};
+
+//----------------------------------------------------------------------------------------
+
+struct WriteReplayScreenshotParams_t	// Passed from the engine into the client to take a screenshot
+{
+	const char	*m_pFilename;
+	int			m_nWidth;
+	int			m_nHeight;
+	Vector		*m_pOrigin;		// Perspective origin from which to render.  Can be NULL
+	QAngle		*m_pAngles;		// Perspective angles from which to render.  Can be NULL
+};
+
+//----------------------------------------------------------------------------------------
+
+#endif // SCREENSHOT_H
--- a/common/replay/shared_defs.h
+++ b/common/replay/shared_defs.h
@ -0,0 +1,73 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+//=======================================================================================//
+
+#ifndef SHARED_DEFS_H
+#define SHARED_DEFS_H
+#ifdef _WIN32
+#pragma once
+#endif
+
+//----------------------------------------------------------------------------------------
+
+#include "platform.h"
+
+//----------------------------------------------------------------------------------------
+
+#define SUBDIR_REPLAY				"replay"
+#define SUBDIR_REPLAYS				"replays"
+#define SUBDIR_SESSIONS				"sessions"
+#define SUBDIR_BLOCKS				"blocks"
+#define SUBDIR_CLIENT				"client"
+#define SUBDIR_MOVIES				"movies"
+#define SUBDIR_PERFORMANCES			"edits"
+#define SUBDIR_SERVER				"server"
+#define SUBDIR_RENDERED				"rendered"
+#define SUBDIR_TMP					"tmp"
+
+//----------------------------------------------------------------------------------------
+
+#define BLOCK_FILE_EXTENSION		"block"
+#define GENERIC_FILE_EXTENSION		"dmx"
+#define DEMO_FILE_EXTENSION			"dem"
+
+//----------------------------------------------------------------------------------------
+
+#define MOVIE_HANDLE_BASE			10000	// 10,000
+
+//----------------------------------------------------------------------------------------
+
+#define BUILD_CURL					( defined( WIN32 ) && !defined( _X360 ) ) || defined( POSIX )
+
+//----------------------------------------------------------------------------------------
+
+#define MIN_SERVER_DUMP_INTERVAL	10
+#define MAX_SERVER_DUMP_INTERVAL	30
+
+#define DOWNLOAD_TIMEOUT_THRESHOLD	90		// Timeout for a replay download - if no blocks
+											// are added or updated after this many seconds,
+											// the replay will be put in the error state.
+
+//----------------------------------------------------------------------------------------
+
+#define MAX_TIMES_TO_SHOW_REPLAY_WELCOME_DLG	1
+
+//----------------------------------------------------------------------------------------
+
+#define MAX_SESSIONNAME_LENGTH		260
+#define MAX_REPLAY_TITLE_LENGTH		256
+#define MAX_TAKE_TITLE_LENGTH		256
+
+//----------------------------------------------------------------------------------------
+
+#define DEFAULT_COMPRESSOR_TYPE		COMPRESSORTYPE_BZ2
+
+//----------------------------------------------------------------------------------------
+
+#define JOB_FAILED					( (JobStatus_t) -1 )
+
+#define DOWNLOAD_MAX_SIZE			( 8 * 1024 * 1024 )		// 8 MB
+
+//----------------------------------------------------------------------------------------
+
+#endif // SHARED_DEFS_H
--- a/common/studiobyteswap.cpp
+++ b/common/studiobyteswap.cpp
--- a/common/studiobyteswap.h
+++ b/common/studiobyteswap.h
@ -0,0 +1,38 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: StudioMDL byteswapping functions.
+//
+// $NoKeywords: $
+//=============================================================================
+#ifndef STUDIOBYTESWAP_H
+#define STUDIOBYTESWAP_H
+
+#if defined(_WIN32)
+#pragma once
+#endif
+
+#include "byteswap.h"
+struct studiohdr_t;
+class IPhysicsCollision;
+
+namespace StudioByteSwap
+{
+typedef bool (*CompressFunc_t)( const void *pInput, int inputSize, void **pOutput, int *pOutputSize );
+
+//void SetTargetBigEndian( bool bigEndian );
+void	ActivateByteSwapping( bool bActivate );
+void	SourceIsNative( bool bActivate );
+void	SetVerbose( bool bVerbose );
+void	SetCollisionInterface( IPhysicsCollision *pPhysicsCollision );
+
+int		ByteswapStudioFile( const char *pFilename, void *pOutBase, const void *pFileBase, int fileSize, studiohdr_t *pHdr, CompressFunc_t pCompressFunc = NULL );
+int		ByteswapPHY( void *pOutBase, const void *pFileBase, int fileSize );
+int		ByteswapANI( studiohdr_t* pHdr, void *pOutBase, const void *pFileBase, int filesize );
+int		ByteswapVVD( void *pOutBase, const void *pFileBase, int fileSize );
+int		ByteswapVTX( void *pOutBase, const void *pFileBase, int fileSize );
+int		ByteswapMDL( void *pOutBase, const void *pFileBase, int fileSize );
+
+#define BYTESWAP_ALIGNMENT_PADDING		4096
+}
+
+#endif // STUDIOBYTESWAP_H
--- a/common/xbox/xboxstubs.h
+++ b/common/xbox/xboxstubs.h
@ -0,0 +1,237 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: Win32 replacements for XBox.
+//
+//=============================================================================
+
+#if !defined( XBOXSTUBS_H ) && !defined( _X360 )
+#define XBOXSTUBS_H
+
+#ifdef _WIN32
+#pragma once
+#endif
+
+#include "tier0/platform.h"
+
+//  Content creation/open flags
+#define XCONTENTFLAG_NONE                           0x00
+#define XCONTENTFLAG_CREATENEW                      0x00
+#define XCONTENTFLAG_CREATEALWAYS                   0x00
+#define XCONTENTFLAG_OPENEXISTING                   0x00
+#define XCONTENTFLAG_OPENALWAYS                     0x00
+#define XCONTENTFLAG_TRUNCATEEXISTING               0x00
+
+//  Content attributes
+#define XCONTENTFLAG_NOPROFILE_TRANSFER             0x00
+#define XCONTENTFLAG_NODEVICE_TRANSFER              0x00
+#define XCONTENTFLAG_STRONG_SIGNED                  0x00
+#define XCONTENTFLAG_ALLOWPROFILE_TRANSFER          0x00
+#define XCONTENTFLAG_MOVEONLY_TRANSFER              0x00
+
+// Console device ports
+#define XDEVICE_PORT0               0
+#define XDEVICE_PORT1               1
+#define XDEVICE_PORT2               2
+#define XDEVICE_PORT3               3
+#define XUSER_MAX_COUNT				4
+#define XUSER_INDEX_NONE            0x000000FE
+
+#define XBX_CLR_DEFAULT				0xFF000000
+#define XBX_CLR_WARNING				0x0000FFFF
+#define XBX_CLR_ERROR				0x000000FF
+
+#define XBOX_MINBORDERSAFE			0
+#define XBOX_MAXBORDERSAFE			0
+
+typedef enum
+{
+	XK_NULL,
+	XK_BUTTON_UP,
+	XK_BUTTON_DOWN,
+	XK_BUTTON_LEFT,
+	XK_BUTTON_RIGHT,
+	XK_BUTTON_START,
+	XK_BUTTON_BACK,
+	XK_BUTTON_STICK1,
+	XK_BUTTON_STICK2,
+	XK_BUTTON_A,
+	XK_BUTTON_B,
+	XK_BUTTON_X,
+	XK_BUTTON_Y,
+	XK_BUTTON_LEFT_SHOULDER,
+	XK_BUTTON_RIGHT_SHOULDER,
+	XK_BUTTON_LTRIGGER,
+	XK_BUTTON_RTRIGGER,
+	XK_STICK1_UP,
+	XK_STICK1_DOWN,
+	XK_STICK1_LEFT,
+	XK_STICK1_RIGHT,
+	XK_STICK2_UP,
+	XK_STICK2_DOWN,
+	XK_STICK2_LEFT,
+	XK_STICK2_RIGHT,
+	XK_MAX_KEYS,
+} xKey_t;
+
+//typedef enum
+//{
+//	XVRB_NONE,		// off
+//	XVRB_ERROR,		// fatal error
+//	XVRB_ALWAYS,	// no matter what
+//	XVRB_WARNING,	// non-fatal warnings
+//	XVRB_STATUS,	// status reports
+//	XVRB_ALL,
+//} xverbose_e;
+
+typedef unsigned short WORD;
+#ifndef POSIX
+typedef unsigned long DWORD;
+typedef void* HANDLE;
+typedef unsigned __int64 ULONGLONG;
+#endif
+
+#ifdef POSIX
+typedef DWORD COLORREF;
+#endif
+
+#ifndef INVALID_HANDLE_VALUE
+#define INVALID_HANDLE_VALUE ((HANDLE)-1)
+#endif
+
+// typedef struct {
+// 	IN_ADDR     ina;                            // IP address (zero if not static/DHCP)
+// 	IN_ADDR     inaOnline;                      // Online IP address (zero if not online)
+// 	WORD        wPortOnline;                    // Online port
+// 	BYTE        abEnet[6];                      // Ethernet MAC address
+// 	BYTE        abOnline[20];                   // Online identification
+// } XNADDR;
+
+typedef int XNADDR;
+typedef uint64 XUID;
+
+typedef struct {
+	BYTE        ab[8];                          // xbox to xbox key identifier
+} XNKID;
+
+typedef struct {
+	BYTE        ab[16];                         // xbox to xbox key exchange key
+} XNKEY;
+
+typedef struct _XSESSION_INFO
+{
+	XNKID sessionID;                // 8 bytes
+	XNADDR hostAddress;             // 36 bytes
+	XNKEY keyExchangeKey;           // 16 bytes
+} XSESSION_INFO, *PXSESSION_INFO;
+
+typedef struct _XUSER_DATA
+{
+	BYTE                                type;
+
+	union
+	{
+		int                            nData;     // XUSER_DATA_TYPE_INT32
+		int64                        i64Data;   // XUSER_DATA_TYPE_INT64
+		double                          dblData;   // XUSER_DATA_TYPE_DOUBLE
+		struct                                     // XUSER_DATA_TYPE_UNICODE
+		{
+			uint                       cbData;    // Includes null-terminator
+			char *                      pwszData;
+		} string;
+		float                           fData;     // XUSER_DATA_TYPE_FLOAT
+		struct                                     // XUSER_DATA_TYPE_BINARY
+		{
+			uint                       cbData;
+			char *                       pbData;
+		} binary;
+	};
+} XUSER_DATA, *PXUSER_DATA;
+
+typedef struct _XUSER_PROPERTY
+{
+	DWORD                               dwPropertyId;
+	XUSER_DATA                          value;
+} XUSER_PROPERTY, *PXUSER_PROPERTY;
+
+typedef struct _XUSER_CONTEXT
+{
+	DWORD                               dwContextId;
+	DWORD                               dwValue;
+} XUSER_CONTEXT, *PXUSER_CONTEXT;
+
+typedef struct _XSESSION_SEARCHRESULT
+{
+	XSESSION_INFO   info;
+	DWORD           dwOpenPublicSlots;
+	DWORD           dwOpenPrivateSlots;
+	DWORD           dwFilledPublicSlots;
+	DWORD           dwFilledPrivateSlots;
+	DWORD           cProperties;
+	DWORD           cContexts;
+	PXUSER_PROPERTY pProperties;
+	PXUSER_CONTEXT  pContexts;
+} XSESSION_SEARCHRESULT, *PXSESSION_SEARCHRESULT;
+
+typedef struct _XSESSION_SEARCHRESULT_HEADER
+{
+	DWORD dwSearchResults;
+	XSESSION_SEARCHRESULT *pResults;
+} XSESSION_SEARCHRESULT_HEADER, *PXSESSION_SEARCHRESULT_HEADER;
+
+typedef struct _XSESSION_REGISTRANT
+{
+	uint64 qwMachineID;
+	DWORD bTrustworthiness;
+	DWORD bNumUsers;
+	XUID *rgUsers;
+
+} XSESSION_REGISTRANT;
+
+typedef struct _XSESSION_REGISTRATION_RESULTS
+{
+	DWORD wNumRegistrants;
+	XSESSION_REGISTRANT *rgRegistrants;
+} XSESSION_REGISTRATION_RESULTS, *PXSESSION_REGISTRATION_RESULTS;
+
+typedef struct {
+	BYTE        bFlags;                         
+	BYTE        bReserved;                    
+	WORD        cProbesXmit;                   
+	WORD        cProbesRecv;                   
+	WORD        cbData;                        
+	BYTE *      pbData;                        
+	WORD        wRttMinInMsecs;                
+	WORD        wRttMedInMsecs;                
+	DWORD       dwUpBitsPerSec;                
+	DWORD       dwDnBitsPerSec;                
+} XNQOSINFO;
+
+typedef struct {
+	uint        cxnqos;                        
+	uint        cxnqosPending;                 
+	XNQOSINFO   axnqosinfo[1];                 
+} XNQOS;
+
+#define XSESSION_CREATE_HOST				0
+#define XUSER_DATA_TYPE_INT32				0
+#define XSESSION_CREATE_USES_ARBITRATION	0
+#define XNET_QOS_LISTEN_ENABLE				0
+#define XNET_QOS_LISTEN_DISABLE				0
+#define XNET_QOS_LISTEN_SET_DATA			0
+
+FORCEINLINE void			XBX_ProcessEvents() {}
+FORCEINLINE unsigned int	XBX_GetSystemTime() { return 0; }
+FORCEINLINE	int				XBX_GetPrimaryUserId() { return 0; }
+FORCEINLINE	void			XBX_SetPrimaryUserId( DWORD idx ) {}
+FORCEINLINE	int				XBX_GetStorageDeviceId() { return 0; }
+FORCEINLINE	void			XBX_SetStorageDeviceId( DWORD idx ) {}
+FORCEINLINE const char		*XBX_GetLanguageString() { return ""; }
+FORCEINLINE bool			XBX_IsLocalized() { return false; }
+
+#define XCONTENT_MAX_DISPLAYNAME_LENGTH	128
+#define XCONTENT_MAX_FILENAME_LENGTH	42
+
+#define XBX_INVALID_STORAGE_ID ((DWORD) -1)
+#define XBX_STORAGE_DECLINED ((DWORD) -2)
+
+#endif // XBOXSTUBS_H