1HEADmaster

1 files changed, 2474 insertions, 0 deletions

diff --git a/hammer/hammer.cpp b/hammer/hammer.cpp
new file mode 100644
index 0000000..cc8ebc2
--- /dev/null
+++ b/hammer/hammer.cpp
@@ -0,0 +1,2474 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: The application object.
+//
+//===========================================================================//
+
+#include "stdafx.h"
+#include <io.h>
+#include <stdlib.h>
+#include <direct.h>
+#pragma warning(push, 1)
+#pragma warning(disable:4701 4702 4530)
+#include <fstream>
+#pragma warning(pop)
+#include "BuildNum.h"
+#include "EditGameConfigs.h"
+#include "Splash.h"
+#include "Options.h"
+#include "custommessages.h"
+#include "MainFrm.h"
+#include "MessageWnd.h"
+#include "ChildFrm.h"
+#include "MapDoc.h"
+#include "Manifest.h"
+#include "MapView3D.h"
+#include "MapView2D.h"
+#include "PakDoc.h"
+#include "PakViewDirec.h"
+#include "PakFrame.h"
+#include "Prefabs.h"
+#include "GlobalFunctions.h"
+#include "Shell.h"
+#include "ShellMessageWnd.h"
+#include "Options.h"
+#include "TextureSystem.h"
+#include "ToolManager.h"
+#include "Hammer.h"
+#include "StudioModel.h"
+#include "ibsplighting.h"
+#include "statusbarids.h"
+#include "tier0/icommandline.h"
+#include "soundsystem.h"
+#include "IHammer.h"
+#include "op_entity.h"
+#include "tier0/dbg.h"
+#include "tier0/minidump.h"
+#include "materialsystem/imaterialsystemhardwareconfig.h"
+#include "istudiorender.h"
+#include "filesystem.h"
+#include "engine_launcher_api.h"
+#include "filesystem_init.h"
+#include "utlmap.h"
+#include "progdlg.h"
+#include "MapWorld.h"
+#include "HammerVGui.h"
+#include "vgui_controls/Controls.h"
+#include "lpreview_thread.h"
+#include "inputsystem/iinputsystem.h"
+#include "datacache/idatacache.h"
+#include "steam/steam_api.h"
+#include "p4lib/ip4.h"
+
+// memdbgon must be the last include file in a .cpp file!!!
+#include <tier0/memdbgon.h>
+
+//
+//	Note!
+//
+//		If this DLL is dynamically linked against the MFC
+//		DLLs, any functions exported from this DLL which
+//		call into MFC must have the AFX_MANAGE_STATE macro
+//		added at the very beginning of the function.
+//
+//		For example:
+//
+//		extern "C" BOOL PASCAL EXPORT ExportedFunction()
+//		{
+//			AFX_MANAGE_STATE(AfxGetStaticModuleState());
+//			// normal function body here
+//		}
+//
+//		It is very important that this macro appear in each
+//		function, prior to any calls into MFC.  This means that
+//		it must appear as the first statement within the 
+//		function, even before any object variable declarations
+//		as their constructors may generate calls into the MFC
+//		DLL.
+//
+//		Please see MFC Technical Notes 33 and 58 for additional
+//		details.
+//
+
+
+// dvs: hack
+extern LPCTSTR GetErrorString(void);
+extern void MakePrefabLibrary(LPCTSTR pszName);
+void EditorUtil_ConvertPath(CString &str, bool bSave);	
+
+static bool bMakeLib = false;
+
+static float fSequenceVersion = 0.2f;
+static char *pszSequenceHdr = "Worldcraft Command Sequences\r\n\x1a";
+
+
+CHammer theApp;
+COptions Options;
+
+CShell g_Shell;
+CShellMessageWnd g_ShellMessageWnd;
+CMessageWnd *g_pwndMessage = NULL;
+
+// IPC structures for lighting preview thread
+CMessageQueue<MessageToLPreview> g_HammerToLPreviewMsgQueue;
+CMessageQueue<MessageFromLPreview> g_LPreviewToHammerMsgQueue;
+ThreadHandle_t g_LPreviewThread;
+CSteamAPIContext g_SteamAPIContext;
+CSteamAPIContext *steamapicontext = &g_SteamAPIContext;
+
+
+bool	CHammer::m_bIsNewDocumentVisible = true;
+
+
+//-----------------------------------------------------------------------------
+// Expose singleton
+//-----------------------------------------------------------------------------
+EXPOSE_SINGLE_INTERFACE_GLOBALVAR(CHammer, IHammer, INTERFACEVERSION_HAMMER, theApp);
+
+
+//-----------------------------------------------------------------------------
+// global interfaces
+//-----------------------------------------------------------------------------
+IBaseFileSystem *g_pFileSystem;
+IEngineAPI *g_pEngineAPI;
+CreateInterfaceFn g_Factory;
+
+bool g_bHDR = true;
+
+bool IsRunningInEngine()
+{
+	return g_pEngineAPI != NULL;
+}
+
+struct MinidumpWrapperHelper_t
+{
+	int (*m_pfn)(void *pParam);
+	void *m_pParam;
+	int m_iRetVal;
+};
+
+static void MinidumpWrapperHelper( void *arg )
+{
+	MinidumpWrapperHelper_t *info = (MinidumpWrapperHelper_t *)arg;
+	info->m_iRetVal = info->m_pfn( info->m_pParam );
+}
+
+static int WrapFunctionWithMinidumpHandler( int (*pfn)(void *pParam), void *pParam )
+{
+	int nRetVal;
+
+	if ( !Plat_IsInDebugSession() && !CommandLine()->FindParm( "-nominidumps") )
+	{
+		MinidumpWrapperHelper_t info;
+		info.m_pfn = pfn;
+		info.m_pParam = pParam;
+		info.m_iRetVal = 0;
+		CatchAndWriteMiniDumpForVoidPtrFn( MinidumpWrapperHelper, &info, true );
+		nRetVal = info.m_iRetVal;
+	}
+	else
+	{
+		nRetVal = pfn( pParam );
+	}
+
+	return nRetVal;
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Outputs a formatted debug string.
+// Input  : fmt - format specifier.
+//			... - arguments to format.
+//-----------------------------------------------------------------------------
+void DBG(const char *fmt, ...)
+{
+    char ach[128];
+    va_list va;
+
+    va_start(va, fmt);
+    vsprintf(ach, fmt, va);
+    va_end(va);
+    OutputDebugString(ach);
+}
+
+
+void Msg(int type, const char *fmt, ...)
+{
+	if ( !g_pwndMessage )
+		return;
+
+	va_list vl;
+	char szBuf[512];
+
+ 	va_start(vl, fmt);
+	int len = _vsnprintf(szBuf, 512, fmt, vl);
+	va_end(vl);
+
+	if ((type == mwError) || (type == mwWarning))
+	{
+		g_pwndMessage->ShowMessageWindow();
+	}
+
+	char temp = 0;
+	char *pMsg = szBuf;
+	do
+	{
+		if (len >= MESSAGE_WND_MESSAGE_LENGTH)
+		{
+			temp = pMsg[MESSAGE_WND_MESSAGE_LENGTH-1];
+			pMsg[MESSAGE_WND_MESSAGE_LENGTH-1] = '\0';
+		}
+
+		g_pwndMessage->AddMsg((MWMSGTYPE)type, pMsg);
+
+		if (len >= MESSAGE_WND_MESSAGE_LENGTH)
+		{
+			pMsg[MESSAGE_WND_MESSAGE_LENGTH-1] = temp;
+			pMsg += MESSAGE_WND_MESSAGE_LENGTH-1;
+		}
+
+		len -= MESSAGE_WND_MESSAGE_LENGTH-1;
+
+	} while (len > 0);
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: this routine calls the default doc template's OpenDocumentFile() but
+//			with the ability to override the visible flag
+// Input  : lpszPathName - the document to open
+//			bMakeVisible - ignored
+// Output : returns the opened document if successful
+//-----------------------------------------------------------------------------
+CDocument *CHammerDocTemplate::OpenDocumentFile( LPCTSTR lpszPathName, BOOL bMakeVisible )
+{
+	CDocument *pDoc = __super::OpenDocumentFile( lpszPathName, CHammer::IsNewDocumentVisible() );
+
+	return pDoc;
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: this function will attempt an orderly shutdown of all maps.  It will attempt to
+//			close only documents that have no references, hopefully freeing up additional documents
+// Input  : bEndSession - ignored
+//-----------------------------------------------------------------------------
+void CHammerDocTemplate::CloseAllDocuments( BOOL bEndSession )
+{
+	bool	bFound = true;
+
+	// rough loop to always remove the first map doc that has no references, then start over, try again.
+	// if we still have maps with references ( that's bad ), we'll exit out of this loop and just do
+	// the default shutdown to force them all to close.
+	while( bFound )
+	{
+		bFound = false;
+
+		POSITION pos = GetFirstDocPosition();
+		while( pos != NULL )
+		{
+			CDocument *pDoc = GetNextDoc( pos );
+			CMapDoc *pMapDoc = dynamic_cast< CMapDoc * >( pDoc );
+
+			if ( pMapDoc && pMapDoc->GetReferenceCount() == 0 )
+			{
+				pDoc->OnCloseDocument();
+				bFound = true;
+				break;
+			}
+		}
+	}
+
+#if 0
+	POSITION pos = GetFirstDocPosition();
+	while( pos != NULL )
+	{
+		CDocument *pDoc = GetNextDoc( pos );
+		CMapDoc *pMapDoc = dynamic_cast< CMapDoc * >( pDoc );
+
+		if ( pMapDoc )
+		{
+			pMapDoc->ForceNoReference();
+		}
+	}
+
+	__super::CloseAllDocuments( bEndSession );
+#endif
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: This function will allow hammer to control the initial visibility of an opening document
+// Input  : pFrame - the new document's frame
+//			pDoc - the new document
+//			bMakeVisible - ignored as a parameter
+//-----------------------------------------------------------------------------
+void CHammerDocTemplate::InitialUpdateFrame( CFrameWnd* pFrame, CDocument* pDoc, BOOL bMakeVisible )
+{
+	bMakeVisible = CHammer::IsNewDocumentVisible();
+
+	__super::InitialUpdateFrame( pFrame, pDoc, bMakeVisible );
+
+	if ( bMakeVisible )
+	{
+		CMapDoc *pMapDoc = dynamic_cast< CMapDoc * >( pDoc );
+
+		if ( pMapDoc )
+		{
+			pMapDoc->SetInitialUpdate();
+		}
+	}
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: this function will let all other maps know that an instanced map has been updated ( usually for volume size )
+// Input  : pInstanceMapDoc - the document that has been updated
+//-----------------------------------------------------------------------------
+void CHammerDocTemplate::UpdateInstanceMap( CMapDoc *pInstanceMapDoc )
+{
+	POSITION pos = GetFirstDocPosition();
+	while( pos != NULL )
+	{
+		CDocument *pDoc = GetNextDoc( pos );
+		CMapDoc *pMapDoc = dynamic_cast< CMapDoc * >( pDoc );
+
+		if ( pMapDoc && pMapDoc != pInstanceMapDoc )
+		{
+			pMapDoc->UpdateInstanceMap( pInstanceMapDoc );
+		}
+	}
+}
+
+
+class CHammerCmdLine : public CCommandLineInfo
+{
+	public:
+
+		CHammerCmdLine(void)
+		{
+			m_bShowLogo = true;
+			m_bGame = false;
+			m_bConfigDir = false;
+		}
+
+		void ParseParam(LPCTSTR lpszParam, BOOL bFlag, BOOL bLast)
+		{
+			if ((!m_bGame) && (bFlag && !stricmp(lpszParam, "game")))
+			{
+				m_bGame = true;	
+			}
+			else if (m_bGame)
+			{
+				if (!bFlag)
+				{
+					m_strGame = lpszParam;
+				}
+
+				m_bGame = false;
+			}
+			else if (bFlag && !strcmpi(lpszParam, "nologo"))
+			{
+				m_bShowLogo = false;
+			}
+			else if (bFlag && !strcmpi(lpszParam, "makelib"))
+			{
+				bMakeLib = TRUE;
+			}
+			else if (!bFlag && bMakeLib)
+			{
+				MakePrefabLibrary(lpszParam);
+			}
+			else if ((!m_bConfigDir) && (bFlag && !stricmp(lpszParam, "configdir")))
+			{
+				m_bConfigDir = true;	
+			}
+			else if (m_bConfigDir)
+			{
+				if ( !bFlag )
+				{
+					Options.configs.m_strConfigDir = lpszParam;
+				}
+				m_bConfigDir = false;
+			}
+			else
+			{
+				CCommandLineInfo::ParseParam(lpszParam, bFlag, bLast);
+			}
+		}
+
+	
+	bool m_bShowLogo;
+	bool m_bGame;			// Used to find and parse the "-game blah" parameter pair.
+	bool m_bConfigDir;		// Used to find and parse the "-configdir blah" parameter pair.
+	CString m_strGame;		// The name of the game to use for this session, ie "hl2" or "cstrike". This should match the mod dir, not the config name.
+};
+
+
+BEGIN_MESSAGE_MAP(CHammer, CWinApp)
+	//{{AFX_MSG_MAP(CHammer)
+	ON_COMMAND(ID_APP_ABOUT, OnAppAbout)
+	ON_COMMAND(ID_FILE_OPEN, OnFileOpen)
+	ON_COMMAND(ID_FILE_NEW, OnFileNew)
+	ON_COMMAND(ID_FILE_OPEN, CWinApp::OnFileOpen)
+	ON_COMMAND(ID_FILE_PRINT_SETUP, CWinApp::OnFilePrintSetup)
+	//}}AFX_MSG_MAP
+END_MESSAGE_MAP()
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Constructor. Initializes member variables and creates a scratch
+//			buffer for use when loading WAD files.
+//-----------------------------------------------------------------------------
+CHammer::CHammer(void)
+{
+	m_bActiveApp = true;
+	m_SuppressVideoAllocation = false;
+	m_bForceRenderNextFrame = false;
+	m_bClosing = false;
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Destructor. Frees scratch buffer used when loading WAD files.
+//			Deletes all command sequences used when compiling maps.
+//-----------------------------------------------------------------------------
+CHammer::~CHammer(void)
+{
+}
+
+
+//-----------------------------------------------------------------------------
+// Inherited from IAppSystem
+//-----------------------------------------------------------------------------
+bool CHammer::Connect( CreateInterfaceFn factory )
+{
+	if ( !BaseClass::Connect( factory ) )
+		return false;
+
+//	bool bCVarOk = ConnectStudioRenderCVars( factory );
+	g_pFileSystem = ( IBaseFileSystem * )factory( BASEFILESYSTEM_INTERFACE_VERSION, NULL );
+	g_pStudioRender = ( IStudioRender * )factory( STUDIO_RENDER_INTERFACE_VERSION, NULL );
+	g_pEngineAPI = ( IEngineAPI * )factory( VENGINE_LAUNCHER_API_VERSION, NULL );
+	g_pMDLCache = (IMDLCache*)factory( MDLCACHE_INTERFACE_VERSION, NULL );
+	p4 = ( IP4 * )factory( P4_INTERFACE_VERSION, NULL );
+    g_Factory = factory;
+
+	if ( !g_pMDLCache || !g_pFileSystem || !g_pFullFileSystem || !materials || !g_pMaterialSystemHardwareConfig || !g_pStudioRender )
+		return false;
+
+	// ensure we're in the same directory as the .EXE
+	char *p;
+	GetModuleFileName(NULL, m_szAppDir, MAX_PATH);
+	p = strrchr(m_szAppDir, '\\');
+	if(p)
+	{
+		// chop off \wc.exe
+		p[0] = 0;
+	}
+
+	if ( IsRunningInEngine() )
+	{
+		strcat( m_szAppDir, "\\bin" );
+	}
+	
+	// Create the message window object for capturing errors and warnings.
+	// This does NOT create the window itself. That happens later in CMainFrame::Create.
+	g_pwndMessage = CMessageWnd::CreateMessageWndObject();
+
+	// Default location for GameConfig.txt is the same directory as Hammer.exe but this may be overridden on the command line
+	char szGameConfigDir[MAX_PATH];
+	APP()->GetDirectory( DIR_PROGRAM, szGameConfigDir );
+	Options.configs.m_strConfigDir = szGameConfigDir;
+	CHammerCmdLine cmdInfo;
+	ParseCommandLine(cmdInfo);
+	
+	// Set up SteamApp() interface (for checking app ownership)
+	SteamAPI_InitSafe();
+	SteamAPI_SetTryCatchCallbacks( false ); // We don't use exceptions, so tell steam not to use try/catch in callback handlers
+	g_SteamAPIContext.Init();
+
+	// Load the options
+	// NOTE: Have to do this now, because we need it before Inits() are called 
+	// NOTE: SetRegistryKey will cause hammer to look into the registry for its values
+	SetRegistryKey("Valve");
+	Options.Init();
+	return true;
+}
+
+
+void CHammer::Disconnect()
+{
+	g_pStudioRender = NULL;
+	g_pFileSystem = NULL;
+	g_pEngineAPI = NULL;
+	g_pMDLCache = NULL;
+	BaseClass::Disconnect();
+}
+
+void *CHammer::QueryInterface( const char *pInterfaceName )
+{
+	// We also implement the IMatSystemSurface interface
+	if (!Q_strncmp(	pInterfaceName, INTERFACEVERSION_HAMMER, Q_strlen(INTERFACEVERSION_HAMMER) + 1))
+		return (IHammer*)this;
+
+	return NULL;
+}
+
+
+//-----------------------------------------------------------------------------
+// Methods related to message pumping
+//-----------------------------------------------------------------------------
+bool CHammer::HammerPreTranslateMessage(MSG * pMsg)
+{
+	AFX_MANAGE_STATE(AfxGetStaticModuleState());
+
+	// Copy this into the current message, needed for MFC
+#if _MSC_VER >= 1300
+	_AFX_THREAD_STATE* pState = AfxGetThreadState();
+	pState->m_msgCur = *pMsg;
+#else
+	m_msgCur = *pMsg;
+#endif
+
+	return (/*pMsg->message == WM_KICKIDLE ||*/ PreTranslateMessage(pMsg) != FALSE);
+}
+
+bool CHammer::HammerIsIdleMessage(MSG * pMsg)
+{
+	AFX_MANAGE_STATE(AfxGetStaticModuleState());
+	return IsIdleMessage(pMsg) != FALSE;
+}
+
+// return TRUE if more idle processing
+bool CHammer::HammerOnIdle(long count)
+{
+	AFX_MANAGE_STATE(AfxGetStaticModuleState());
+	return OnIdle(count) != FALSE;
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Adds a backslash to the end of a string if there isn't one already.
+// Input  : psz - String to add the backslash to.
+//-----------------------------------------------------------------------------
+static void EnsureTrailingBackslash(char *psz)
+{
+	if ((psz[0] != '\0') && (psz[strlen(psz) - 1] != '\\'))
+	{
+		strcat(psz, "\\");
+	}
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Tweaks our data members to enable us to import old Hammer settings
+//			from the registry.
+//-----------------------------------------------------------------------------
+static const char *s_pszOldAppName = NULL;
+void CHammer::BeginImportWCSettings(void)
+{
+	s_pszOldAppName = m_pszAppName;
+	m_pszAppName = "Worldcraft";
+	SetRegistryKey("Valve");
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Tweaks our data members to enable us to import old Valve Hammer Editor
+//			settings from the registry.
+//-----------------------------------------------------------------------------
+void CHammer::BeginImportVHESettings(void)
+{
+	s_pszOldAppName = m_pszAppName;
+	m_pszAppName = "Valve Hammer Editor";
+	SetRegistryKey("Valve");
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Restores our tweaked data members to their original state.
+//-----------------------------------------------------------------------------
+void CHammer::EndImportSettings(void)
+{
+	m_pszAppName = s_pszOldAppName;
+	SetRegistryKey("Valve");
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Retrieves various important directories.
+// Input  : dir - Enumerated directory to retrieve.
+//			p - Pointer to buffer that receives the full path to the directory.
+//-----------------------------------------------------------------------------
+void CHammer::GetDirectory(DirIndex_t dir, char *p)
+{
+	switch (dir)
+	{
+		case DIR_PROGRAM:
+		{
+			strcpy(p, m_szAppDir);
+			EnsureTrailingBackslash(p);
+			break;
+		}
+
+		case DIR_PREFABS:
+		{
+			strcpy(p, m_szAppDir);
+			EnsureTrailingBackslash(p);
+			strcat(p, "Prefabs");
+
+			//
+			// Make sure the prefabs directory exists.
+			//
+			if ((_access( p, 0 )) == -1)
+			{
+				CreateDirectory(p, NULL);
+			}
+			break;
+		}
+
+		//
+		// Get the game directory with a trailing backslash. This is
+		// where the base game's resources are, such as "C:\Half-Life\valve\".
+		//
+		case DIR_GAME_EXE:
+		{
+			strcpy(p, g_pGameConfig->m_szGameExeDir);
+			EnsureTrailingBackslash(p);
+			break;
+		}
+
+		//
+		// Get the mod directory with a trailing backslash. This is where
+		// the mod's resources are, such as "C:\Half-Life\tfc\".
+		//
+		case DIR_MOD:
+		{
+			strcpy(p, g_pGameConfig->m_szModDir);
+			EnsureTrailingBackslash(p);
+			break;
+		}
+
+		//
+		// Get the materials directory with a trailing backslash. This is where
+		// the mod's materials are, such as "C:\Half-Life\tfc\materials".
+		//
+		case DIR_MATERIALS:
+		{
+			strcpy(p, g_pGameConfig->m_szModDir);
+			EnsureTrailingBackslash(p);
+			Q_strcat(p, "materials\\", MAX_PATH);
+			break;
+		}
+
+		case DIR_AUTOSAVE:
+		{			
+            strcpy( p, m_szAutosaveDir );
+			EnsureTrailingBackslash(p);			
+			break;
+		}
+	}
+}
+
+void CHammer::SetDirectory(DirIndex_t dir, const char *p)
+{
+	switch(dir)
+	{
+		case DIR_AUTOSAVE:
+		{
+			strcpy( m_szAutosaveDir, p );
+			break;
+		}
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Returns a color from the application configuration storage.
+//-----------------------------------------------------------------------------
+COLORREF CHammer::GetProfileColor(const char *pszSection, const char *pszKey, int r, int g, int b)
+{
+	int newR, newG, newB;
+	
+	CString strDefault;
+	CString strReturn;
+	char szBuff[128];
+	sprintf(szBuff, "%i %i %i", r, g, b);
+
+	strDefault = szBuff;
+
+	strReturn = GetProfileString(pszSection, pszKey, strDefault);
+
+	if (strReturn.IsEmpty())
+		return 0;
+
+	// Parse out colors.
+	char *pStart;
+	char *pCurrent;
+	pStart = szBuff;
+	pCurrent = pStart;
+	
+	strcpy( szBuff, (char *)(LPCSTR)strReturn );
+
+	while (*pCurrent && *pCurrent != ' ')
+		pCurrent++;
+
+	*pCurrent++ = 0;
+	newR = atoi(pStart);
+
+	pStart = pCurrent;
+	while (*pCurrent && *pCurrent != ' ')
+		pCurrent++;
+
+	*pCurrent++ = 0;
+	newG = atoi(pStart);
+
+	pStart = pCurrent;
+	while (*pCurrent)
+		pCurrent++;
+
+	*pCurrent++ = 0;
+	newB = atoi(pStart);
+
+	return COLORREF(RGB(newR, newG, newB));
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Input  : *pszURL - 
+//-----------------------------------------------------------------------------
+void CHammer::OpenURL(const char *pszURL, HWND hwnd)
+{
+	if (HINSTANCE(32) > ::ShellExecute(hwnd, "open", pszURL, NULL, NULL, 0))
+	{
+		AfxMessageBox("The website couldn't be opened.");
+	}
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Opens a URL in the default web browser by string ID.
+//-----------------------------------------------------------------------------
+void CHammer::OpenURL(UINT nID, HWND hwnd)
+{
+	CString str;
+	str.LoadString(nID);
+	OpenURL(str, hwnd);
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Launches the help system for the specified help topic.
+// Input  : pszTopic - Topic to open.
+//-----------------------------------------------------------------------------
+void CHammer::Help(const char *pszTopic)
+{
+	//
+	// Get the directory that the help file should be in (our program directory).
+	//
+	/*char szHelpDir[MAX_PATH];
+	GetDirectory(DIR_PROGRAM, szHelpDir);
+
+	//
+	// Find the application that is associated with compiled HTML files.
+	//
+	char szHelpExe[MAX_PATH];
+	HINSTANCE hResult = FindExecutable("wc.chm", szHelpDir, szHelpExe);
+	if (hResult > (HINSTANCE)32)
+	{
+		//
+		// Build the full topic with which to launch the help application.
+		//
+		char szParam[2 * MAX_PATH];
+		strcpy(szParam, szHelpDir);
+		strcat(szParam, "wc.chm");
+		if (pszTopic != NULL)
+		{
+			strcat(szParam, "::/");
+			strcat(szParam, pszTopic);
+		}
+
+		//
+		// Launch the help application for the given topic.
+		//
+		hResult = ShellExecute(NULL, "open", szHelpExe, szParam, szHelpDir, SW_SHOW);
+	}
+
+	if (hResult <= (HINSTANCE)32)
+	{
+		char szError[MAX_PATH];
+		sprintf(szError, "The help system could not be launched. The the following error was returned:\n%s (0x%X)", GetErrorString(), hResult);
+		AfxMessageBox(szError);
+	}
+	*/
+}
+
+
+static SpewRetval_t HammerDbgOutput( SpewType_t spewType, char const *pMsg )
+{
+	// FIXME: The messages we're getting from the material system
+	// are ones that we really don't care much about.
+	// I'm disabling this for now, we need to decide about what to do with this
+
+	switch( spewType )
+	{
+	case SPEW_ERROR:
+		MessageBox( NULL, (LPCTSTR)pMsg, "Fatal Error", MB_OK | MB_ICONINFORMATION );
+#ifdef _DEBUG
+		return SPEW_DEBUGGER;
+#else
+		TerminateProcess( GetCurrentProcess(), 1 );
+		return SPEW_ABORT;
+#endif
+
+	default:
+		OutputDebugString( pMsg );
+		return (spewType == SPEW_ASSERT) ? SPEW_DEBUGGER : SPEW_CONTINUE; 
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+static HANDLE dwChangeHandle = NULL;
+void UpdatePrefabs_Init()
+{
+ 
+	// Watch the prefabs tree for file or directory creation
+	// and deletion. 
+	if (dwChangeHandle == NULL)
+	{
+		char szPrefabDir[MAX_PATH];
+		APP()->GetDirectory(DIR_PREFABS, szPrefabDir);
+
+		dwChangeHandle = FindFirstChangeNotification( 
+			szPrefabDir,													// directory to watch 
+			TRUE,															// watch the subtree 
+			FILE_NOTIFY_CHANGE_DIR_NAME | FILE_NOTIFY_CHANGE_FILE_NAME);	// watch file and dir name changes 
+ 
+		if (dwChangeHandle == INVALID_HANDLE_VALUE) 
+		{
+			ExitProcess(GetLastError()); 
+		}
+	}
+}	 
+
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void UpdatePrefabs()
+{
+ 	// Wait for notification.
+ 	DWORD dwWaitStatus = WaitForSingleObject(dwChangeHandle, 0);
+
+	if (dwWaitStatus == WAIT_OBJECT_0)
+	{
+		// A file was created or deleted in the prefabs tree. 
+		// Refresh the prefabs and restart the change notification.
+		CPrefabLibrary::FreeAllLibraries();
+		CPrefabLibrary::LoadAllLibraries();
+		GetMainWnd()->m_ObjectBar.UpdateListForTool(ToolManager()->GetActiveToolID());
+
+		if (FindNextChangeNotification(dwChangeHandle) == FALSE)
+		{
+			ExitProcess(GetLastError()); 
+		}
+	}
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void UpdatePrefabs_Shutdown()
+{
+	FindCloseChangeNotification(dwChangeHandle);
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+BOOL CHammer::InitInstance()
+{
+	return TRUE;
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Prompt the user to select a game configuration.
+//-----------------------------------------------------------------------------
+CGameConfig *CHammer::PromptForGameConfig()
+{
+	CEditGameConfigs dlg(TRUE, GetMainWnd());
+	if (dlg.DoModal() != IDOK)
+	{
+		return NULL;
+	}
+
+	return dlg.GetSelectedGame();
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Output : Returns true on success, false on failure.
+//-----------------------------------------------------------------------------
+bool CHammer::InitSessionGameConfig(const char *szGame)
+{
+	CGameConfig *pConfig = NULL;
+	bool bManualChoice = false;
+
+	if ( CommandLine()->FindParm( "-chooseconfig" ) )
+	{
+		pConfig = PromptForGameConfig();
+		bManualChoice = true;
+	}
+
+	if (!bManualChoice)
+	{
+		if (szGame && szGame[0] != '\0')
+		{
+			// They passed in -game on the command line, use that.
+			pConfig = Options.configs.FindConfigForGame(szGame);
+			if (!pConfig)
+			{
+				Msg(mwError, "Invalid game \"%s\" specified on the command-line, ignoring.", szGame);
+			}
+		}
+		else
+		{
+			// No -game on the command line, try using VPROJECT.
+			const char *pszGameDir = getenv("vproject");
+			if ( pszGameDir )
+			{
+				pConfig = Options.configs.FindConfigForGame(pszGameDir);
+				if (!pConfig)
+				{
+					Msg(mwError, "Invalid game \"%s\" found in VPROJECT environment variable, ignoring.", pszGameDir);
+				}
+			}
+		}
+	}
+
+	if (pConfig == NULL)
+	{
+		// Nothing useful was passed in or found in VPROJECT.
+
+		// If there's only one config, use that.
+		if (Options.configs.GetGameConfigCount() == 1)
+		{
+			pConfig = Options.configs.GetGameConfig(0);
+		}
+		else
+		{
+			// Otherwise, prompt for a config to use.
+			pConfig = PromptForGameConfig();
+		}
+	}
+
+	if (pConfig)
+	{
+		CGameConfig::SetActiveGame(pConfig);
+		return true;
+	}
+
+	return false;
+}
+
+
+//-----------------------------------------------------------------------------
+// Check for 16-bit color or higher.
+//-----------------------------------------------------------------------------
+bool CHammer::Check16BitColor()
+{
+	// Check for 15-bit color or higher.
+	HDC hDC = ::CreateCompatibleDC(NULL);
+	if (hDC)
+	{
+		int bpp = GetDeviceCaps(hDC, BITSPIXEL);
+		if (bpp < 15)
+		{
+			AfxMessageBox("Your screen must be in 16-bit color or higher to run Hammer.");
+			return false;
+		}
+		::DeleteDC(hDC);
+	}
+
+	return true;
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Returns true if Hammer is in the process of shutting down.
+//-----------------------------------------------------------------------------
+InitReturnVal_t CHammer::Init()
+{
+	return (InitReturnVal_t)WrapFunctionWithMinidumpHandler( &CHammer::StaticHammerInternalInit, this );
+}
+
+
+int CHammer::StaticHammerInternalInit( void *pParam )
+{
+	return (int)((CHammer*)pParam)->HammerInternalInit();
+}
+
+
+InitReturnVal_t CHammer::HammerInternalInit()
+{
+	SpewOutputFunc( HammerDbgOutput );
+	MathLib_Init( 2.2f, 2.2f, 0.0f, 2.0f, false, false, false, false );
+	InitReturnVal_t nRetVal = BaseClass::Init();
+	if ( nRetVal != INIT_OK )
+		return nRetVal;
+
+	if ( !Check16BitColor() )
+		return INIT_FAILED;
+
+
+	//
+	// Create a custom window class for this application so that engine's
+	// FindWindow will find us.
+	//
+	WNDCLASS wndcls;
+	memset(&wndcls, 0, sizeof(WNDCLASS));
+    wndcls.style         = CS_DBLCLKS | CS_HREDRAW | CS_VREDRAW;
+    wndcls.lpfnWndProc   = AfxWndProc;
+    wndcls.hInstance     = AfxGetInstanceHandle();
+    wndcls.hIcon         = LoadIcon(IDR_MAINFRAME);
+    wndcls.hCursor       = LoadCursor( IDC_ARROW );
+    wndcls.hbrBackground = (HBRUSH)0; //  (COLOR_WINDOW + 1);
+    wndcls.lpszMenuName  = "IDR_MAINFRAME";
+	wndcls.cbWndExtra    = 0;
+	 
+	// HL Shell class name
+    wndcls.lpszClassName = "VALVEWORLDCRAFT";
+
+    // Register it, exit if it fails    
+	if(!AfxRegisterClass(&wndcls))
+	{
+		AfxMessageBox("Could not register Hammer's main window class");
+		return INIT_FAILED;
+	}
+
+	srand(time(NULL));
+
+	WriteProfileString("General", "Directory", m_szAppDir);
+
+	//
+	// Create a window to receive shell commands from the engine, and attach it
+	// to our shell processor.
+	//
+	g_ShellMessageWnd.Create();
+	g_ShellMessageWnd.SetShell(&g_Shell);
+
+	if (bMakeLib)
+		return INIT_FAILED;	// made library .. don't want to enter program
+
+	CHammerCmdLine cmdInfo;
+	ParseCommandLine(cmdInfo);
+
+	//
+	// Create and optionally display the splash screen.
+	//
+	CSplashWnd::EnableSplashScreen(cmdInfo.m_bShowLogo);
+
+	LoadSequences();	// load cmd sequences - different from options because
+						//  users might want to share (darn registry)
+
+	// other init:
+	randomize();
+
+	/*
+#ifdef _AFXDLL
+	Enable3dControls();			// Call this when using MFC in a shared DLL
+#else
+	Enable3dControlsStatic();	// Call this when linking to MFC statically
+#endif
+	*/
+
+	LoadStdProfileSettings();  // Load standard INI file options (including MRU)
+
+	// Register the application's document templates.  Document templates
+	//  serve as the connection between documents, frame windows and views.
+	pMapDocTemplate = new CHammerDocTemplate(
+		IDR_MAPDOC,
+		RUNTIME_CLASS(CMapDoc),
+		RUNTIME_CLASS(CChildFrame), // custom MDI child frame
+		RUNTIME_CLASS(CMapView2D));
+	AddDocTemplate(pMapDocTemplate);
+
+	pManifestDocTemplate = new CHammerDocTemplate(
+		IDR_MANIFESTDOC,
+		RUNTIME_CLASS(CManifest),
+		RUNTIME_CLASS(CChildFrame), // custom MDI child frame
+		RUNTIME_CLASS(CMapView2D));
+	HINSTANCE hInst = AfxFindResourceHandle( MAKEINTRESOURCE( IDR_MAPDOC ), RT_MENU );
+	pManifestDocTemplate->m_hMenuShared = ::LoadMenu( hInst, MAKEINTRESOURCE( IDR_MAPDOC ) );
+	hInst = AfxFindResourceHandle( MAKEINTRESOURCE( IDR_MAPDOC ), RT_ACCELERATOR );
+	pManifestDocTemplate->m_hAccelTable = ::LoadAccelerators( hInst, MAKEINTRESOURCE( IDR_MAPDOC ) );
+	AddDocTemplate(pManifestDocTemplate);
+
+
+	// register shell file types
+	RegisterShellFileTypes();
+
+	//
+	// Initialize the rich edit control so we can use it in the entity help dialog.
+	//
+	AfxInitRichEdit();
+
+	//
+	// Create main MDI Frame window. Must be done AFTER registering the multidoc template!
+	//
+	CMainFrame *pMainFrame = new CMainFrame;
+	if (!pMainFrame->LoadFrame(IDR_MAINFRAME))
+		return INIT_FAILED;
+
+	m_pMainWnd = pMainFrame;
+
+	CSplashWnd::ShowSplashScreen(pMainFrame);
+
+
+	// try to init VGUI
+	HammerVGui()->Init( m_pMainWnd->GetSafeHwnd() );
+
+	// The main window has been initialized, so show and update it.
+	//
+	m_nCmdShow = SW_SHOWMAXIMIZED;
+	pMainFrame->ShowWindow(m_nCmdShow);
+	pMainFrame->UpdateWindow();
+
+	// Now that we've initialized the file system, we can parse this config's gameinfo.txt for the additional settings there.
+	g_pGameConfig->ParseGameInfo();
+
+	materials->ModInit();
+
+	//
+	// Initialize the texture manager and load all textures.
+	//
+	if (!g_Textures.Initialize(m_pMainWnd->m_hWnd))
+	{
+		Msg(mwError, "Failed to initialize texture system.");
+	}
+	else
+	{
+		//
+		// Initialize studio model rendering (must happen after g_Textures.Initialize since
+		// g_Textures.Initialize kickstarts the material system and sets up g_MaterialSystemClientFactory)
+		//
+		StudioModel::Initialize();
+		g_Textures.LoadAllGraphicsFiles();
+		g_Textures.SetActiveConfig(g_pGameConfig);
+	}
+	
+	// Watch for changes to models.
+	InitStudioFileChangeWatcher();
+
+	LoadFileSystemDialogModule();
+
+	// Load detail object descriptions.
+	char	szGameDir[_MAX_PATH];
+	APP()->GetDirectory(DIR_MOD, szGameDir);
+	DetailObjects::LoadEmitDetailObjectDictionary( szGameDir );
+	
+	// Initialize the sound system
+	g_Sounds.Initialize();
+
+	UpdatePrefabs_Init();
+
+	// Indicate that we are ready to use.
+	m_pMainWnd->FlashWindow(TRUE);
+
+	// Parse command line for standard shell commands, DDE, file open
+	if ( !IsRunningInEngine() )
+	{
+		if ( Q_stristr( cmdInfo.m_strFileName, ".vmf" ) )
+		{
+			// we don't want to make a new file (default behavior if no file
+			//  is specified on the commandline.)
+
+			// Dispatch commands specified on the command line
+			if (!ProcessShellCommand(cmdInfo))
+				return INIT_FAILED;
+		}
+	}
+
+	if ( Options.general.bClosedCorrectly == FALSE )
+	{
+		CString strLastGoodSave = APP()->GetProfileString("General", "Last Good Save", "");
+        
+		if ( strLastGoodSave.GetLength() != 0 )
+		{
+			char msg[1024];
+			V_snprintf( msg, sizeof( msg ), "Hammer did not shut down correctly the last time it was used.\nWould you like to load the last saved file?\n(%s)", (const char*)strLastGoodSave );
+			if ( AfxMessageBox( msg, MB_YESNO ) == IDYES )
+			{
+				LoadLastGoodSave();
+			}
+		}
+	}
+
+#ifdef VPROF_HAMMER
+	g_VProfCurrentProfile.Start();
+#endif
+	
+	CSplashWnd::HideSplashScreen();
+
+	// create the lighting preview thread
+	g_LPreviewThread = CreateSimpleThread( LightingPreviewThreadFN, 0 );
+
+	return INIT_OK;
+}
+
+int CHammer::MainLoop()
+{
+	return WrapFunctionWithMinidumpHandler( StaticInternalMainLoop, this );
+}
+
+
+int CHammer::StaticInternalMainLoop( void *pParam )
+{
+	return ((CHammer*)pParam)->InternalMainLoop();
+}
+
+
+int CHammer::InternalMainLoop()
+{	
+	MSG msg;
+
+	g_pDataCache->SetSize( 128 * 1024 * 1024 );
+
+	// For tracking the idle time state
+	bool bIdle = true;
+	long lIdleCount = 0;
+
+	// We've got our own message pump here
+	g_pInputSystem->EnableMessagePump( false );
+
+	// Acquire and dispatch messages until a WM_QUIT message is received.
+	for (;;)
+	{
+		RunFrame();
+
+		if ( bIdle && !HammerOnIdle(lIdleCount++) )
+		{
+			bIdle = false;
+		}
+
+		//
+		// Pump messages until the message queue is empty.
+		//
+		while (::PeekMessage(&msg, NULL, NULL, NULL, PM_REMOVE))
+		{
+			if ( msg.message == WM_QUIT )
+				return 1;
+
+			if ( !HammerPreTranslateMessage(&msg) )
+			{
+				::TranslateMessage(&msg);
+				::DispatchMessage(&msg);
+			}
+
+			// Reset idle state after pumping idle message.
+			if ( HammerIsIdleMessage(&msg) )
+			{
+				bIdle = true;
+				lIdleCount = 0;
+			}
+		}
+	}
+
+	Assert(0);  // not reachable
+}
+
+//-----------------------------------------------------------------------------
+// Shuts down hammer
+//-----------------------------------------------------------------------------
+void CHammer::Shutdown()
+{
+	if ( g_LPreviewThread )
+	{
+		MessageToLPreview StopMsg( LPREVIEW_MSG_EXIT );
+		g_HammerToLPreviewMsgQueue.QueueMessage( StopMsg );
+		ThreadJoin( g_LPreviewThread );
+		g_LPreviewThread = 0;
+	}
+
+#ifdef VPROF_HAMMER
+	g_VProfCurrentProfile.Stop();
+#endif
+
+	// PrintBudgetGroupTimes_Recursive( g_VProfCurrentProfile.GetRoot() );
+
+	HammerVGui()->Shutdown();
+
+	UnloadFileSystemDialogModule();
+
+	// Delete the command sequences.
+	int nSequenceCount = m_CmdSequences.GetSize();
+	for (int i = 0; i < nSequenceCount; i++)
+	{
+		CCommandSequence *pSeq = m_CmdSequences[i];
+		if ( pSeq != NULL )
+		{
+			delete pSeq;
+			m_CmdSequences[i] = NULL;
+		}
+	}
+
+	g_Textures.ShutDown();
+
+	// Shutdown the sound system
+	g_Sounds.ShutDown();
+
+	materials->ModShutdown();
+	BaseClass::Shutdown();
+}
+
+
+//-----------------------------------------------------------------------------
+// Methods used by the engine
+//-----------------------------------------------------------------------------
+const char *CHammer::GetDefaultMod()
+{
+	return g_pGameConfig->GetMod();
+}
+
+const char *CHammer::GetDefaultGame()
+{
+	return g_pGameConfig->GetGame();
+}
+
+const char *CHammer::GetDefaultModFullPath()
+{
+	return g_pGameConfig->m_szModDir;
+}
+
+	
+//-----------------------------------------------------------------------------
+// Pops up the options dialog
+//-----------------------------------------------------------------------------
+RequestRetval_t CHammer::RequestNewConfig()
+{
+	if ( !Options.RunConfigurationDialog() )
+		return REQUEST_QUIT;
+
+	return REQUEST_OK;
+}
+
+	
+//-----------------------------------------------------------------------------
+// Purpose: Returns true if Hammer is in the process of shutting down.
+//-----------------------------------------------------------------------------
+bool CHammer::IsClosing()
+{
+	return m_bClosing;
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Signals the beginning of app shutdown. Should be called before
+//			rendering views.
+//-----------------------------------------------------------------------------
+void CHammer::BeginClosing()
+{
+	m_bClosing = true;
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+int CHammer::ExitInstance()
+{
+	g_ShellMessageWnd.DestroyWindow();
+
+	UpdatePrefabs_Shutdown();
+
+	if ( GetSpewOutputFunc() == HammerDbgOutput )
+	{
+		SpewOutputFunc( NULL );
+	}
+
+	SaveStdProfileSettings();
+
+	return CWinApp::ExitInstance();
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: this function sets the global flag indicating if new documents should
+//			be visible.
+// Input  : bIsVisible - flag to indicate visibility status.
+//-----------------------------------------------------------------------------
+void CHammer::SetIsNewDocumentVisible( bool bIsVisible )
+{
+	CHammer::m_bIsNewDocumentVisible = bIsVisible;
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: this functionr eturns the global flag indicating if new documents should
+//			be visible.
+//-----------------------------------------------------------------------------
+bool CHammer::IsNewDocumentVisible( void )
+{
+	return CHammer::m_bIsNewDocumentVisible;
+}
+
+
+/////////////////////////////////////////////////////////////////////////////
+// CAboutDlg dialog used for App About
+
+class CAboutDlg : public CDialog
+{
+public:
+	CAboutDlg();
+
+// Dialog Data
+	//{{AFX_DATA(CAboutDlg)
+	enum { IDD = IDD_ABOUTBOX };
+	CStatic	m_cRedHerring;
+	CButton	m_Order;
+	//}}AFX_DATA
+
+	// ClassWizard generated virtual function overrides
+	//{{AFX_VIRTUAL(CAboutDlg)
+	protected:
+	virtual void DoDataExchange(CDataExchange* pDX);    // DDX/DDV support
+	//}}AFX_VIRTUAL
+
+// Implementation
+protected:
+	//{{AFX_MSG(CAboutDlg)
+	afx_msg void OnOrder();
+	virtual BOOL OnInitDialog();
+	//}}AFX_MSG
+	DECLARE_MESSAGE_MAP()
+};
+
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+CAboutDlg::CAboutDlg() : CDialog(CAboutDlg::IDD)
+{
+	//{{AFX_DATA_INIT(CAboutDlg)
+	//}}AFX_DATA_INIT
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Input  : pDX - 
+//-----------------------------------------------------------------------------
+void CAboutDlg::DoDataExchange(CDataExchange* pDX)
+{
+	CDialog::DoDataExchange(pDX);
+	//{{AFX_DATA_MAP(CAboutDlg)
+	DDX_Control(pDX, IDC_REDHERRING, m_cRedHerring);
+	DDX_Control(pDX, IDC_ORDER, m_Order);
+	//}}AFX_DATA_MAP
+}
+
+#include <process.h>
+
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CAboutDlg::OnOrder() 
+{
+	char szBuf[MAX_PATH];
+	GetWindowsDirectory(szBuf, MAX_PATH);
+	strcat(szBuf, "\\notepad.exe");
+	_spawnl(_P_NOWAIT, szBuf, szBuf, "order.txt", NULL);
+}
+
+
+#define DEMO_VERSION	0
+
+// 1, 4, 8, 17, 0, 0 // Encodes "Valve"
+
+#if DEMO_VERSION
+
+char gVersion[] = {                        
+#if DEMO_VERSION==1
+	7, 38, 68, 32, 4, 77, 12, 1, 0 // Encodes "PC Gamer Demo"
+#elif DEMO_VERSION==2
+	7, 38, 68, 32, 4, 77, 12, 0, 0 // Encodes "PC Games Demo"
+#elif DEMO_VERSION==3
+	20, 10, 9, 23, 16, 84, 12, 1, 0, 38, 65, 25, 6, 1, 11, 119, 50, 11, 21, 9, 68, 0 // Encodes "Computer Gaming World Demo"
+#elif DEMO_VERSION==4
+	25, 0, 28, 19, 72, 103, 12, 29, 69, 19, 65, 0, 6, 0, 2, 0		// Encodes "Next-Generation Demo"
+#elif DEMO_VERSION==5
+	20, 10, 9, 23, 16, 84, 12, 1, 0, 38, 65, 25, 10, 79, 41, 57, 17, 1, 21, 17, 65, 0, 29, 77, 4, 78, 0, 0 // Encodes "Computer Game Entertainment"
+#elif DEMO_VERSION==6
+	20, 10, 9, 23, 16, 84, 12, 1, 0, 0, 78, 16, 79, 33, 9, 35, 69, 52, 11, 4, 89, 12, 1, 0 // Encodes "Computer and Net Player"
+#elif DEMO_VERSION==7
+	50, 72, 52, 43, 36, 121, 0 // Encodes "e-PLAY"
+#elif DEMO_VERSION==8
+	4, 17, 22, 6, 17, 69, 14, 10, 0, 49, 76, 1, 28, 0 // Encodes "Strategy Plus"
+#elif DEMO_VERSION==9
+	7, 38, 68, 42, 4, 71, 8, 9, 73, 15, 69, 0 // Encodes "PC Magazine"
+#elif DEMO_VERSION==10
+	5, 10, 8, 11, 12, 78, 14, 83, 115, 21, 79, 26, 10, 0 // Encodes "Rolling Stone"
+#elif DEMO_VERSION==11
+	16, 4, 9, 2, 22, 80, 6, 7, 0 // Encodes "Gamespot"
+#endif
+};
+
+static char gKey[] = "Wedge is a tool";	// Decrypt key
+
+// XOR a string with a key
+void Encode( char *pstring, char *pkey, int strLen )
+{
+	int i, len;
+	len = strlen( pkey );
+	for ( i = 0; i < strLen; i++ )
+		pstring[i] ^= pkey[ i % len ];
+}
+#endif // DEMO_VERSION
+
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Output : Returns TRUE on success, FALSE on failure.
+//-----------------------------------------------------------------------------
+BOOL CAboutDlg::OnInitDialog(void)
+{
+	CDialog::OnInitDialog();
+
+	m_Order.SetRedraw(FALSE);
+
+#if DEMO_VERSION
+	static BOOL bFirst = TRUE;
+	if(bFirst)
+	{
+		Encode(gVersion, gKey, sizeof(gVersion)-1);
+		bFirst = FALSE;
+	}
+	CString str;
+	str.Format("%s Demo", gVersion);
+	m_cRedHerring.SetWindowText(str);
+#endif // DEMO_VERSION
+
+	//
+	// Display the build number.
+	//
+	CWnd *pWnd = GetDlgItem(IDC_BUILD_NUMBER);
+	if (pWnd != NULL)
+	{
+		char szTemp1[MAX_PATH];
+		char szTemp2[MAX_PATH];
+		int nBuild = build_number();
+		pWnd->GetWindowText(szTemp1, sizeof(szTemp1));
+		sprintf(szTemp2, szTemp1, nBuild);
+		pWnd->SetWindowText(szTemp2);
+	}
+
+	//
+	// For SDK builds, append "SDK" to the version number.
+	//
+#ifdef SDK_BUILD
+	char szTemp[MAX_PATH];
+	GetWindowText(szTemp, sizeof(szTemp));
+	strcat(szTemp, " SDK");
+	SetWindowText(szTemp);
+#endif // SDK_BUILD
+
+	return TRUE;
+}
+
+
+BEGIN_MESSAGE_MAP(CAboutDlg, CDialog)
+	//{{AFX_MSG_MAP(CAboutDlg)
+	ON_BN_CLICKED(IDC_ORDER, OnOrder)
+	//}}AFX_MSG_MAP
+END_MESSAGE_MAP()
+
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CHammer::OnAppAbout(void)
+{
+	CAboutDlg aboutDlg;
+	aboutDlg.DoModal();
+
+#ifdef VPROF_HAMMER
+	g_VProfCurrentProfile.OutputReport();
+	g_VProfCurrentProfile.Reset();
+	g_pMemAlloc->DumpStats();
+#endif
+
+}
+
+
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CHammer::OnFileNew(void)
+{
+	pMapDocTemplate->OpenDocumentFile(NULL);
+	if(Options.general.bLoadwinpos && Options.general.bIndependentwin)
+	{
+		::GetMainWnd()->LoadWindowStates();
+	}
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CHammer::OnFileOpen(void)
+{
+	static char szInitialDir[MAX_PATH] = "";
+	if (szInitialDir[0] == '\0')
+	{
+		strcpy(szInitialDir, g_pGameConfig->szMapDir);
+	}
+
+	// TODO: need to prevent (or handle) opening VMF files when using old map file formats
+	CFileDialog dlg(TRUE, NULL, NULL, OFN_LONGNAMES | OFN_HIDEREADONLY | OFN_NOCHANGEDIR, "Valve Map Files (*.vmf;*.vmm)|*.vmf;*.vmm|Valve Map Files Autosave (*.vmf_autosave)|*.vmf_autosave|Worldcraft RMFs (*.rmf)|*.rmf|Worldcraft Maps (*.map)|*.map||");
+	dlg.m_ofn.lpstrInitialDir = szInitialDir;
+	int iRvl = dlg.DoModal();
+
+	if (iRvl == IDCANCEL)
+	{
+		return;
+	}
+
+	//
+	// Get the directory they browsed to for next time.
+	//
+	CString str = dlg.GetPathName();
+	int nSlash = str.ReverseFind('\\');
+	if (nSlash != -1)
+	{
+		strcpy(szInitialDir, str.Left(nSlash));
+	}
+
+	if (str.Find('.') == -1)
+	{
+		switch (dlg.m_ofn.nFilterIndex)
+		{
+			case 1:
+			{
+				str += ".vmf";
+				break;
+			}
+			
+			case 2:
+			{
+				str += ".vmf_autosave";
+				break;
+			}
+
+			case 3:
+			{
+				str += ".rmf";
+				break;
+			}
+
+			case 4:
+			{
+				str += ".map";
+				break;
+			}
+		}
+	}
+
+	OpenDocumentFile(str);
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Input  : lpszFileName - 
+// Output : CDocument*
+//-----------------------------------------------------------------------------
+CDocument* CHammer::OpenDocumentFile(LPCTSTR lpszFileName) 
+{
+	if(GetFileAttributes(lpszFileName) == 0xFFFFFFFF)
+	{
+		CString		Message;
+
+		Message = "The file " + CString( lpszFileName ) + " does not exist.";
+		AfxMessageBox( Message );
+
+		return NULL;
+	}
+
+	CDocument	*pDoc = m_pDocManager->OpenDocumentFile( lpszFileName );
+	CMapDoc		*pMapDoc = dynamic_cast< CMapDoc * >( pDoc );
+
+	if ( pMapDoc )
+	{
+		CMapDoc::SetActiveMapDoc( pMapDoc );
+
+	}
+	if( pDoc && Options.general.bLoadwinpos && Options.general.bIndependentwin)
+	{
+		::GetMainWnd()->LoadWindowStates();
+	}
+
+	if ( pMapDoc && !CHammer::IsNewDocumentVisible() )
+	{
+		pMapDoc->ShowWindow( false );
+	}
+	else
+	{
+		pMapDoc->ShowWindow( true );
+	}
+
+	if ( pDoc && ((CMapDoc *)pDoc)->IsAutosave() )
+	{			
+		char szRenameMessage[MAX_PATH+MAX_PATH+256];
+		CString newMapPath = *((CMapDoc *)pDoc)->AutosavedFrom();
+
+		sprintf( szRenameMessage, "This map was loaded from an autosave file.\nWould you like to rename it from \"%s\" to \"%s\"?\nNOTE: This will not save the file with the new name; it will only rename it.", lpszFileName, (const char*)newMapPath );
+
+		if ( AfxMessageBox( szRenameMessage, MB_YESNO ) == IDYES )
+		{			
+			((CMapDoc *)pDoc)->SetPathName( newMapPath );		
+		}			
+	}
+
+	return pDoc;
+}
+
+
+//-----------------------------------------------------------------------------
+// Returns true if this is a key message that is not a special dialog navigation message.
+//-----------------------------------------------------------------------------
+inline bool IsKeyStrokeMessage( MSG *pMsg )
+{
+	if ( ( pMsg->message != WM_KEYDOWN ) && ( pMsg->message != WM_CHAR ) )
+		return false;
+
+	// Check for special dialog navigation characters -- they don't count
+	if ( ( pMsg->wParam == VK_ESCAPE ) || ( pMsg->wParam == VK_RETURN ) || ( pMsg->wParam == VK_TAB ) )
+		return false;
+
+	if ( ( pMsg->wParam == VK_UP ) || ( pMsg->wParam == VK_DOWN ) || ( pMsg->wParam == VK_LEFT ) || ( pMsg->wParam == VK_RIGHT ) )
+		return false;
+
+	return true;
+}
+
+
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+BOOL CHammer::PreTranslateMessage(MSG* pMsg)
+{
+	// CG: The following lines were added by the Splash Screen component.
+	if (CSplashWnd::PreTranslateAppMessage(pMsg))
+		return TRUE;
+
+	// This is for raw input, these shouldn't be translated so skip that here.
+	if ( pMsg->message == WM_INPUT )
+		return TRUE;
+
+	// Suppress the accelerator table for edit controls so that users can type
+	// uppercase characters without invoking Hammer tools.	
+	if ( IsKeyStrokeMessage( pMsg ) )
+	{
+		char className[80];
+		::GetClassNameA( pMsg->hwnd, className, sizeof( className ) );
+
+		// The classname of dialog window in the VGUI model browser and particle browser is AfxWnd100sd in Debug and AfxWnd100s in Release
+		if ( !V_stricmp( className, "edit" ) || V_stristr( className, "AfxWnd" ) )
+		{
+			// Typing in an edit control. Don't pretranslate, just translate/dispatch.
+			return FALSE;
+		}
+	}
+
+	return CWinApp::PreTranslateMessage(pMsg);
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CHammer::LoadSequences(void)
+{
+	char szRootDir[MAX_PATH];
+	char szFullPath[MAX_PATH];
+	APP()->GetDirectory(DIR_PROGRAM, szRootDir);
+	Q_MakeAbsolutePath( szFullPath, MAX_PATH, "CmdSeq.wc", szRootDir ); 
+	std::ifstream file(szFullPath, std::ios::in | std::ios::binary);
+	
+	if(!file.is_open())
+		return;	// none to load
+
+	// skip past header & version
+	float fThisVersion;
+
+	file.seekg(strlen(pszSequenceHdr));
+	file.read((char*)&fThisVersion, sizeof fThisVersion);
+
+	// read number of sequences
+	DWORD dwSize;
+	int nSeq;
+
+	file.read((char*)&dwSize, sizeof dwSize);
+	nSeq = dwSize;
+
+	for(int i = 0; i < nSeq; i++)
+	{
+		CCommandSequence *pSeq = new CCommandSequence;
+		file.read(pSeq->m_szName, 128);
+
+		// read commands in sequence
+		file.read((char*)&dwSize, sizeof dwSize);
+		int nCmd = dwSize;
+		CCOMMAND cmd;
+		for(int iCmd = 0; iCmd < nCmd; iCmd++)
+		{
+			if(fThisVersion < 0.2f)
+			{
+				file.read((char*)&cmd, sizeof(CCOMMAND)-1);
+				cmd.bNoWait = FALSE;
+			}
+			else
+			{
+				file.read((char*)&cmd, sizeof(CCOMMAND));
+			}
+			pSeq->m_Commands.Add(cmd);
+		}
+
+		m_CmdSequences.Add(pSeq);
+	}
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CHammer::SaveSequences(void)
+{
+	char szRootDir[MAX_PATH];
+	char szFullPath[MAX_PATH];
+	APP()->GetDirectory(DIR_PROGRAM, szRootDir);
+	Q_MakeAbsolutePath( szFullPath, MAX_PATH, "CmdSeq.wc", szRootDir ); 
+	std::ofstream file( szFullPath, std::ios::out | std::ios::binary );
+
+	// write header
+	file.write(pszSequenceHdr, Q_strlen(pszSequenceHdr));
+	// write out version
+	file.write((char*)&fSequenceVersion, sizeof(float));
+
+	// write out each sequence..
+	int i, nSeq = m_CmdSequences.GetSize();
+	DWORD dwSize = nSeq;
+	file.write((char*)&dwSize, sizeof dwSize);
+	for(i = 0; i < nSeq; i++)
+	{
+		CCommandSequence *pSeq = m_CmdSequences[i];
+
+		// write name of sequence
+		file.write(pSeq->m_szName, 128);
+		// write number of commands
+		int nCmd = pSeq->m_Commands.GetSize();
+		dwSize = nCmd;
+		file.write((char*)&dwSize, sizeof dwSize);
+		// write commands .. 
+		for(int iCmd = 0; iCmd < nCmd; iCmd++)
+		{
+			CCOMMAND &cmd = pSeq->m_Commands[iCmd];
+			file.write((char*)&cmd, sizeof cmd);
+		}
+	}
+}
+
+
+void CHammer::SetForceRenderNextFrame()
+{
+	m_bForceRenderNextFrame = true;
+}
+
+
+bool CHammer::GetForceRenderNextFrame()
+{
+	return m_bForceRenderNextFrame;
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Input  : *pDoc - 
+//-----------------------------------------------------------------------------
+void CHammer::UpdateLighting(CMapDoc *pDoc)
+{
+	static int lastPercent = -20000;
+	int curPercent = -10000;
+	
+	IBSPLighting *pLighting = pDoc->GetBSPLighting();
+	if ( pLighting )
+	{
+		// Update 5x / second.
+		static DWORD lastTime = 0;
+
+		DWORD curTime = GetTickCount();
+		if ( curTime - lastTime < 200 )
+		{
+			curPercent = lastPercent; // no change
+		}
+		else
+		{
+			curPercent = (int)( pLighting->GetPercentComplete() * 10000.0f );
+			lastTime = curTime;
+		}
+
+		// Redraw the views when new lightmaps are ready.
+		if ( pLighting->CheckForNewLightmaps() )
+		{
+			SetForceRenderNextFrame();
+			pDoc->UpdateAllViews( MAPVIEW_UPDATE_ONLY_3D );
+		}
+	}
+
+	// Update the status text.
+	if ( curPercent == -10000 )
+	{
+		SetStatusText( SBI_LIGHTPROGRESS, "<->" );
+	}
+	else if( curPercent != lastPercent )
+	{
+		char str[256];
+		sprintf( str, "%.2f%%", curPercent / 100.0f );
+		SetStatusText( SBI_LIGHTPROGRESS, str );
+	}
+
+	lastPercent = curPercent;	
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Performs idle processing. Runs the frame and does MFC idle processing.
+// Input  : lCount - The number of times OnIdle has been called in succession,
+//				indicating the relative length of time the app has been idle without
+//				user input.
+// Output : Returns TRUE if there is more idle processing to do, FALSE if not.
+//-----------------------------------------------------------------------------
+BOOL CHammer::OnIdle(LONG lCount)
+{
+	UpdatePrefabs();
+
+	CMapDoc *pDoc = CMapDoc::GetActiveMapDoc();
+	if (pDoc)
+	{
+		UpdateLighting(pDoc);
+	}
+
+	g_Textures.UpdateFileChangeWatchers();
+	UpdateStudioFileChangeWatcher();
+	return(CWinApp::OnIdle(lCount));
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Renders the realtime views.
+//-----------------------------------------------------------------------------
+void CHammer::RunFrame(void)
+{
+
+	// Note: since hammer may well not even have a 3D window visible
+	// at any given time, we have to call into the material system to
+	// make it deal with device lost. Usually this happens during SwapBuffers,
+	// but we may well not call SwapBuffers at any given moment.
+	materials->HandleDeviceLost();
+
+	if (!IsActiveApp())
+	{
+		Sleep(50);
+	}
+
+#ifdef VPROF_HAMMER
+	g_VProfCurrentProfile.MarkFrame();
+#endif
+
+	HammerVGui()->Simulate();
+
+	if ( CMapDoc::GetActiveMapDoc() && !IsClosing() || m_bForceRenderNextFrame )
+		HandleLightingPreview();
+
+	// never render without document or when closing down
+	// usually only render when active, but not compiling a map unless forced
+	if ( CMapDoc::GetActiveMapDoc() && !IsClosing() &&
+		 ( ( !IsRunningCommands() && IsActiveApp() ) || m_bForceRenderNextFrame ) &&
+		 CMapDoc::GetActiveMapDoc()->HasInitialUpdate() )
+		 
+	{
+		// get the time
+		CMapDoc::GetActiveMapDoc()->UpdateCurrentTime();
+
+		// run any animation
+		CMapDoc::GetActiveMapDoc()->UpdateAnimation();
+
+		// redraw the 3d views
+		CMapDoc::GetActiveMapDoc()->RenderAllViews();
+	}
+
+	// No matter what, we want to keep caching in materials...
+	if ( IsActiveApp() )
+	{
+		g_Textures.LazyLoadTextures();
+	}
+
+	m_bForceRenderNextFrame = false;
+
+
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Overloaded Run so that we can control the frameratefor realtime
+//			rendering in the 3D view.
+// Output : As MFC CWinApp::Run.
+//-----------------------------------------------------------------------------
+int CHammer::Run(void)
+{
+	Assert(0);
+	return 0;
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Returns true if the editor is the active app, false if not.
+//-----------------------------------------------------------------------------
+bool CHammer::IsActiveApp(void)
+{
+	return m_bActiveApp;
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Called from CMainFrame::OnSysCommand, this informs the app when it
+//			is minimized and unminimized. This allows us to stop rendering the
+//			3D view when we are minimized.
+// Input  : bMinimized - TRUE when minmized, FALSE otherwise.
+//-----------------------------------------------------------------------------
+void CHammer::OnActivateApp(bool bActive)
+{
+//	static int nCount = 0;
+//	if (bActive)
+//		DBG("ON %d\n", nCount);
+//	else
+//		DBG("OFF %d\n", nCount);
+//	nCount++;
+	m_bActiveApp = bActive;
+
+
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Called from the shell to relinquish our video memory in favor of the
+//			engine. This is called by the engine when it starts up.
+//-----------------------------------------------------------------------------
+void CHammer::ReleaseVideoMemory()
+{
+   POSITION pos = GetFirstDocTemplatePosition();
+
+   while (pos)
+   {
+      CDocTemplate* pTemplate = (CDocTemplate*)GetNextDocTemplate(pos);
+      POSITION pos2 = pTemplate->GetFirstDocPosition();
+      while (pos2)
+      {
+         CDocument * pDocument;
+         if ((pDocument=pTemplate->GetNextDoc(pos2)) != NULL)
+		 {
+			 static_cast<CMapDoc*>(pDocument)->ReleaseVideoMemory();
+		 }
+      }
+   }
+} 
+
+void CHammer::SuppressVideoAllocation( bool bSuppress )
+{
+	m_SuppressVideoAllocation = bSuppress;
+} 
+
+bool CHammer::CanAllocateVideo() const
+{
+	return !m_SuppressVideoAllocation;
+}
+
+//-------------------------------------------------------------------------------
+// Purpose: Runs through the autosave directory and fills the autosave map.
+//			Also sets the total amount of space used by the directory.
+// Input  : pFileMap - CUtlMap that will hold the list of files in the dir
+//			pdwTotalDirSize - pointer to the DWORD that will hold directory size
+//			pstrMapTitle - the name of the current map to be saved
+// Output : returns an int containing the next number to use for the autosave
+//-------------------------------------------------------------------------------
+int CHammer::GetNextAutosaveNumber( CUtlMap<FILETIME, WIN32_FIND_DATA, int> *pFileMap, DWORD *pdwTotalDirSize, const CString *pstrMapTitle ) const
+{
+	FILETIME oldestAutosaveTime;
+	oldestAutosaveTime.dwHighDateTime = 0;
+	oldestAutosaveTime.dwLowDateTime = 0; 
+
+	char szRootDir[MAX_PATH];
+	APP()->GetDirectory(DIR_AUTOSAVE, szRootDir);
+	CString strAutosaveDirectory( szRootDir );
+   
+	int nNumberActualAutosaves = 0;
+	int nCurrentAutosaveNumber = 1;
+	int nOldestAutosaveNumber = 1;
+	int nExpectedNextAutosaveNumber = 1;
+	int nLastHole = 0;
+	int nMaxAutosavesPerMap = Options.general.iMaxAutosavesPerMap; 
+
+	WIN32_FIND_DATA fileData;
+	HANDLE hFile;
+	DWORD dwTotalAutosaveDirectorySize = 0;
+			
+	hFile = FindFirstFile( strAutosaveDirectory + "*.vmf_autosave", &fileData );
+
+    if ( hFile != INVALID_HANDLE_VALUE )
+	{
+		//go through and for each file check to see if it is an autosave for this map; also keep track of total file size
+		//for directory.
+		while( GetLastError() != ERROR_NO_MORE_FILES && hFile != INVALID_HANDLE_VALUE )
+		{				
+			(*pFileMap).Insert( fileData.ftLastAccessTime, fileData );
+		
+			DWORD dwFileSize = fileData.nFileSizeLow;
+			dwTotalAutosaveDirectorySize += dwFileSize;
+			FILETIME fileAccessTime = fileData.ftLastAccessTime;
+
+			CString currentFilename( fileData.cFileName );
+
+			//every autosave file ends in three digits; this code separates the name from the digits
+			CString strMapName = currentFilename.Left( currentFilename.GetLength() - 17 );
+			CString strCurrentNumber = currentFilename.Mid( currentFilename.GetLength() - 16, 3 );	
+			int nMapNumber = atoi( (char *)strCurrentNumber.GetBuffer() );
+			
+			if ( strMapName.CompareNoCase( (*pstrMapTitle) ) == 0 )
+			{
+				//keep track of real number of autosaves with map name; deals with instance where older maps get deleted
+				//and create sequence holes in autosave map names.
+				nNumberActualAutosaves++; 
+
+				if ( oldestAutosaveTime.dwLowDateTime == 0 )
+				{
+					//the first file is automatically the oldest
+					oldestAutosaveTime = fileAccessTime;
+				}			
+                
+				if ( nMapNumber != nExpectedNextAutosaveNumber )
+				{					
+					//the current map number is different than what was expected
+					//there is a hole in the sequence
+					nLastHole = nMapNumber;										
+				}
+
+				nExpectedNextAutosaveNumber = nMapNumber + 1;
+				if ( nExpectedNextAutosaveNumber > 999 )
+				{
+					nExpectedNextAutosaveNumber = 1;
+				}
+				if ( CompareFileTime( &fileAccessTime, &oldestAutosaveTime ) == -1 ) 
+				{
+					//this file is older than previous oldest file
+					oldestAutosaveTime = fileAccessTime;
+					nOldestAutosaveNumber = nMapNumber;					
+				}
+			}	
+			FindNextFile(hFile, &fileData);
+		}
+		FindClose(hFile);
+	}		
+
+    if ( nNumberActualAutosaves < nMaxAutosavesPerMap ) 
+	{
+		//there are less autosaves than wanted for the map; use the larger
+		//of the next expected or the last found hole as the number.
+		nCurrentAutosaveNumber = max( nExpectedNextAutosaveNumber, nLastHole );        
+	}
+	else 
+	{
+		//there are no holes, use the oldest.
+		nCurrentAutosaveNumber = nOldestAutosaveNumber;
+	}	
+
+	*pdwTotalDirSize = dwTotalAutosaveDirectorySize;
+
+	return nCurrentAutosaveNumber;
+}
+
+
+static bool LessFunc( const FILETIME &lhs, const FILETIME &rhs )
+{ 
+	return CompareFileTime(&lhs, &rhs) < 0;	
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: This is called when the autosave timer goes off.  It checks to 
+//			make sure the document has changed and handles deletion of old
+//			files when the total directory size is too big
+//-----------------------------------------------------------------------------
+
+void CHammer::Autosave( void )
+{
+	if ( !Options.general.bEnableAutosave )
+	{
+		return;
+	}
+	
+	if ( VerifyAutosaveDirectory() != true )
+	{     
+		Options.general.bEnableAutosave = false;
+		return;		
+	}    	
+
+	CMapDoc *pDoc = CMapDoc::GetActiveMapDoc();
+
+	//value from options is in megs
+	DWORD dwMaxAutosaveSpace = Options.general.iMaxAutosaveSpace * 1024 * 1024; 
+	
+	CUtlMap<FILETIME, WIN32_FIND_DATA, int> autosaveFiles;
+
+	autosaveFiles.SetLessFunc( LessFunc );
+
+	if ( pDoc && pDoc->NeedsAutosave() )
+	{
+		char szRootDir[MAX_PATH];
+		APP()->GetDirectory(DIR_AUTOSAVE, szRootDir);
+		CString strAutosaveDirectory( szRootDir );
+
+		//expand the path if $SteamUserDir etc are used for SDK users
+		EditorUtil_ConvertPath(strAutosaveDirectory, true);
+		
+		CString strExtension  = ".vmf";
+		//this will hold the name of the map w/o leading directory info or file extension
+		CString strMapTitle; 
+		//full path of map file
+		CString strMapFilename = pDoc->GetPathName(); 
+	
+		DWORD dwTotalAutosaveDirectorySize = 0;
+		int nCurrentAutosaveNumber = 0;
+
+		// the map hasn't been saved before and doesn't have a filename; using default: 'autosave'
+		if ( strMapFilename.IsEmpty() ) 
+		{
+			strMapTitle = "autosave";
+		}
+		// the map already has a filename 
+		else 
+		{
+			int nFilenameBeginOffset = strMapFilename.ReverseFind( '\\' ) + 1;
+			int nFilenameEndOffset = strMapFilename.Find( '.' );
+			//get the filename of the map, between the leading '\' and the '.'
+			strMapTitle = strMapFilename.Mid( nFilenameBeginOffset, nFilenameEndOffset - nFilenameBeginOffset );			
+		}
+       
+		nCurrentAutosaveNumber = GetNextAutosaveNumber( &autosaveFiles, &dwTotalAutosaveDirectorySize, &strMapTitle );
+
+		//creating the proper suffix for the autosave file
+		char szNumberChars[4];
+        CString strAutosaveString = itoa( nCurrentAutosaveNumber, szNumberChars, 10 );
+		CString strAutosaveNumber = "000";
+		strAutosaveNumber += strAutosaveString;
+		strAutosaveNumber = strAutosaveNumber.Right( 3 );
+		strAutosaveNumber = "_" + strAutosaveNumber;
+   
+		CString strSaveName = strAutosaveDirectory + strMapTitle + strAutosaveNumber + strExtension + "_autosave";
+
+		pDoc->SaveVMF( (char *)strSaveName.GetBuffer(), SAVEFLAGS_AUTOSAVE );
+		//don't autosave again unless they make changes
+		pDoc->SetAutosaveFlag( FALSE ); 
+
+		//if there is too much space used for autosaves, delete the oldest file until the size is acceptable
+		while( dwTotalAutosaveDirectorySize > dwMaxAutosaveSpace ) 
+		{	
+			int nFirstElementIndex = autosaveFiles.FirstInorder();
+			if ( !autosaveFiles.IsValidIndex( nFirstElementIndex ) )
+			{
+				Assert( false );
+				break;
+			}
+
+			WIN32_FIND_DATA fileData = autosaveFiles.Element( nFirstElementIndex );
+			DWORD dwOldestFileSize =  fileData.nFileSizeLow;
+			char filename[MAX_PATH];
+			strcpy( filename, fileData.cFileName );
+			DeleteFile( strAutosaveDirectory + filename );
+			dwTotalAutosaveDirectorySize -= dwOldestFileSize;
+			autosaveFiles.RemoveAt( nFirstElementIndex );			
+		}
+		
+		autosaveFiles.RemoveAll();
+
+		
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Verifies that the autosave directory exists and attempts to create it if 
+//			it doesn't.  Also returns various failure errors.  
+//			This function is now called at two different times: immediately after a new
+//			directory is entered in the options screen and during every autosave call.
+//			If called with a directory, the input directory is checked for correctness.
+//			Otherwise, the system directory DIR_AUTOSAVE is checked
+//-----------------------------------------------------------------------------
+bool CHammer::VerifyAutosaveDirectory( char *szAutosaveDirectory ) const
+{	
+	HANDLE hDir;
+	HANDLE hTestFile;
+
+	char szRootDir[MAX_PATH];
+	if ( szAutosaveDirectory )
+	{
+		strcpy( szRootDir, szAutosaveDirectory );
+		EnsureTrailingBackslash( szRootDir );
+	}
+	else
+	{
+		APP()->GetDirectory(DIR_AUTOSAVE, szRootDir);
+	}
+
+	if ( szRootDir[0] == 0 )
+	{
+		AfxMessageBox( "No autosave directory has been selected.\nThe autosave feature will be disabled until a directory is entered.", MB_OK );
+		return false;
+	}
+	CString strAutosaveDirectory( szRootDir );	
+	{
+		EditorUtil_ConvertPath(strAutosaveDirectory, true);
+		if ( ( strAutosaveDirectory[1] != ':' ) || ( strAutosaveDirectory[2] != '\\' ) )
+		{
+			AfxMessageBox( "The current autosave directory does not have an absolute path.\nThe autosave feature will be disabled until a new directory is entered.", MB_OK );
+			return false;
+		}
+	}
+
+	hDir = CreateFile (
+		strAutosaveDirectory,
+		GENERIC_READ,
+		FILE_SHARE_READ|FILE_SHARE_WRITE|FILE_SHARE_DELETE,
+		NULL,
+		OPEN_EXISTING,
+		FILE_FLAG_BACKUP_SEMANTICS,
+		NULL
+		);
+
+	if ( hDir == INVALID_HANDLE_VALUE )
+	{
+
+		bool bDirResult = CreateDirectory( strAutosaveDirectory, NULL );
+		if ( !bDirResult )
+		{
+			AfxMessageBox( "The current autosave directory does not exist and could not be created.  \nThe autosave feature will be disabled until a new directory is entered.", MB_OK );
+			return false;
+		}
+	}    
+	else
+	{
+		CloseHandle( hDir );
+
+		hTestFile = CreateFile( strAutosaveDirectory + "test.txt", 
+			GENERIC_READ,
+			FILE_SHARE_READ|FILE_SHARE_WRITE|FILE_SHARE_DELETE,
+			NULL,
+			CREATE_NEW,
+			FILE_FLAG_BACKUP_SEMANTICS,
+			NULL
+			);
+		
+		if ( hTestFile == INVALID_HANDLE_VALUE )
+		{
+			 if ( GetLastError() == ERROR_ACCESS_DENIED )
+			 {
+				 AfxMessageBox( "The autosave directory is marked as read only.  Please remove the read only attribute or select a new directory in Tools->Options->General.\nThe autosave feature will be disabled.", MB_OK );
+				 return false;
+			 }
+			 else
+			 {
+				 AfxMessageBox( "There is a problem with the autosave directory.  Please select a new directory in Tools->Options->General.\nThe autosave feature will be disabled.", MB_OK );
+				 return false;
+			 }
+
+			 
+		}
+
+		CloseHandle( hTestFile );
+		DeleteFile( strAutosaveDirectory + "test.txt" );	
+	}
+
+	return true;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Called when Hammer starts after a crash.  It loads the newest 
+//			autosave file after Hammer has initialized.
+//-----------------------------------------------------------------------------
+void CHammer::LoadLastGoodSave( void )
+{	
+	CString strLastGoodSave = APP()->GetProfileString("General", "Last Good Save", "");
+	char szMapDir[MAX_PATH];
+	strcpy(szMapDir, g_pGameConfig->szMapDir);
+	CDocument *pCurrentDoc;
+
+	if ( !strLastGoodSave.IsEmpty() )
+	{		
+		pCurrentDoc = APP()->OpenDocumentFile( strLastGoodSave );
+
+		if ( !pCurrentDoc )
+		{
+			AfxMessageBox( "There was an error loading the last saved file.", MB_OK );
+			return;
+		}
+		
+		char szAutoSaveDir[MAX_PATH];	
+		APP()->GetDirectory(DIR_AUTOSAVE, szAutoSaveDir);	
+
+		if ( !((CMapDoc *)pCurrentDoc)->IsAutosave() && Q_stristr( pCurrentDoc->GetPathName(), szAutoSaveDir ) )
+		{
+			//This handles the case where someone recovers from a crash and tries to load an autosave file that doesn't have the new autosave chunk in it
+			//It assumes the file should go into the gameConfig map directory
+			char szRenameMessage[MAX_PATH+MAX_PATH+256];
+			char szLastSaveCopy[MAX_PATH];
+			Q_strcpy( szLastSaveCopy, strLastGoodSave );		
+			char *pszFileName = Q_strrchr( strLastGoodSave, '\\') + 1;
+			char *pszFileNameEnd = Q_strrchr( strLastGoodSave, '_');
+			if ( !pszFileNameEnd )
+			{
+				pszFileNameEnd = Q_strrchr( strLastGoodSave, '.');
+			}
+			strcpy( pszFileNameEnd, ".vmf" );
+			CString newMapPath( szMapDir );
+			newMapPath.Append( "\\" );
+			newMapPath.Append( pszFileName );
+			sprintf( szRenameMessage, "The last saved map was found in the autosave directory.\nWould you like to rename it from \"%s\" to \"%s\"?\nNOTE: This will not save the file with the new name; it will only rename it.", szLastSaveCopy, (const char*)newMapPath );
+
+			if ( AfxMessageBox( szRenameMessage, MB_YESNO ) == IDYES )
+			{			
+				pCurrentDoc->SetPathName( newMapPath );		
+			}		
+		}
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Called from the General Options dialog when the autosave timer or
+//			directory values have changed.  
+//-----------------------------------------------------------------------------
+void CHammer::ResetAutosaveTimer()
+{
+	Options.general.bEnableAutosave = true;
+
+	CMainFrame *pMainWnd = ::GetMainWnd();
+	if ( pMainWnd )
+	{
+		pMainWnd->ResetAutosaveTimer();
+	}
+}