1HEADmaster

1 files changed, 1010 insertions, 0 deletions

diff --git a/engine/MapReslistGenerator.cpp b/engine/MapReslistGenerator.cpp
new file mode 100644
index 0000000..cc729a6
--- /dev/null
+++ b/engine/MapReslistGenerator.cpp
@@ -0,0 +1,1010 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+//===========================================================================//
+
+
+#include "MapReslistGenerator.h"
+#include "filesystem.h"
+#include "filesystem_engine.h"
+#include "sys.h"
+#include "cmd.h"
+#include "common.h"
+#include "quakedef.h"
+#include "vengineserver_impl.h"
+#include "tier1/strtools.h"
+#include "tier0/icommandline.h"
+#include <ctype.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <tier0/dbg.h>
+#include "host.h"
+#include "host_state.h"
+#include "utlbuffer.h"
+#include "characterset.h"
+#include "tier1/fmtstr.h"
+
+// memdbgon must be the last include file in a .cpp file!!!
+#include "tier0/memdbgon.h"
+
+#define PAUSE_FRAMES_BETWEEN_MAPS	300
+#define PAUSE_TIME_BETWEEN_MAPS		2.0f
+
+extern engineparms_t host_parms;
+
+#define ENGINE_RESLIST_FILE "engine.lst"
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void MapReslistGenerator_Usage()
+{ 
+	Msg( "-makereslists usage:\n" );
+	Msg( "  [ -makereslists <optionalscriptfile> ] -- script file to control more complex makereslists operations (multiple passes, etc.)\n" );
+	Msg( "  [ -usereslistfile filename ] -- get map list from specified file, default is to build for maps/*.bsp\n" );
+	Msg( "  [ -startmap mapname ] -- restart generation at specified map (after crash, implies resume)\n" );
+	Msg( "  [ -condebug ] -- prepend console.log entries with mapname or engine if not in a map\n" );
+	Msg( "  [ +map mapname ] -- generate reslists for specified map and exit after that map\n" );
+	Msg( "  [ -rebuildaudio ] -- force rebuild of _other_rebuild.cache (metacache) file at exit\n" );
+	Msg( "  [ -forever ] -- when you get to the end of the maplist, start over from the top\n" );
+	Msg( "  [ -reslistdir ] -- default is 'reslists', use this to override\n" );
+	Msg( "  [ -startstage nnn ] -- when running from script file, this starts at specified stage\n" );
+	Msg( "  [ -collate ] -- skip everything, just merge the reslist from temp folders to the final folder again\n" );
+}
+
+void MapReslistGenerator_Init()
+{
+	// check for reslist generation
+	if ( CommandLine()->FindParm("-makereslists") )
+	{
+		bool usemaplistfile = false;
+		if ( CommandLine()->FindParm("-usereslistfile") )
+		{
+			usemaplistfile = true;
+		}
+		MapReslistGenerator().EnableReslistGeneration( usemaplistfile );
+	}
+	else if ( CommandLine()->FindParm( "-rebuildaudio" ) )
+	{
+		MapReslistGenerator().SetAutoQuit( true );
+	}
+
+	if ( CommandLine()->FindParm( "-trackdeletions" ) )
+	{
+		MapReslistGenerator().EnableDeletionsTracking();
+	}
+}
+
+void MapReslistGenerator_Shutdown()
+{
+	MapReslistGenerator().Shutdown();
+}
+
+void MapReslistGenerator_BuildMapList()
+{
+	MapReslistGenerator().BuildMapList();
+}
+
+CMapReslistGenerator g_MapReslistGenerator;
+CMapReslistGenerator &MapReslistGenerator()
+{
+	return g_MapReslistGenerator;
+}
+
+static bool ReslistLogLessFunc( CUtlString const &pLHS, CUtlString const &pRHS )
+{
+	return CaselessStringLessThan( pLHS.Get(), pRHS.Get() );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Constructor
+//-----------------------------------------------------------------------------
+CMapReslistGenerator::CMapReslistGenerator() : 
+	m_AlreadyWrittenFileNames( 0, 0, true ),
+	m_DeletionListWarnings( 0, 0, DefLessFunc( CUtlSymbol ) ),
+	m_EngineLog( 0, 0, ReslistLogLessFunc ),
+	m_MapLog( 0, 0, ReslistLogLessFunc ),
+	m_bAutoQuit( false )
+{
+	MEM_ALLOC_CREDIT_CLASS();
+
+	m_bUsingMapList = false;
+	m_bTrackingDeletions = false;
+	m_bLoggingEnabled = false;
+	m_iCurrentMap = 0;
+	m_flNextMapRunTime = 0.0f;
+	m_iFrameCountdownToRunningNextMap = 0;
+	m_szPrefix[0] = '\0';
+	m_szLevelName[0] = '\0';
+	m_iPauseTimeBetweenMaps = PAUSE_TIME_BETWEEN_MAPS;
+	m_iPauseFramesBetweenMaps = PAUSE_FRAMES_BETWEEN_MAPS;
+	m_bRestartOnTransition = false;
+	m_bLogToEngineList = true;
+	m_sResListDir = "reslists";
+}
+
+void CMapReslistGenerator::SetAutoQuit( bool bState )
+{
+	m_bAutoQuit = bState;
+}
+
+void CMapReslistGenerator::BuildMapList()
+{
+	if ( !IsEnabled() )
+		return;
+
+	MapReslistGenerator_Usage();
+
+	// Get the maplist file, if any
+	const char *pMapFile = NULL;
+	CommandLine()->CheckParm( "-usereslistfile", &pMapFile );
+
+	// +map argument precludes using a maplist file
+	bool bUseMap = CommandLine()->FindParm("+map") != 0;
+	bool bUseMapListFile = bUseMap ? false : CommandLine()->FindParm("-usereslistfile") != 0;
+
+	// Build the map list
+	if ( !BuildGeneralMapList( &m_Maps, bUseMapListFile, pMapFile, "reslists", &m_iCurrentMap ) )
+	{
+		m_bLoggingEnabled = false;
+	}
+}
+
+bool BuildGeneralMapList( CUtlVector<maplist_map_t> *aMaps, bool bUseMapListFile, const char *pMapFile, char *pSystemMsg, int *iCurrentMap )
+{
+	if ( !bUseMapListFile )
+	{
+		// If the user passed in a +map parameter, just use that single map
+		char const *pMapName = NULL;
+		if ( CommandLine()->CheckParm( "+map", &pMapName ) && pMapName )
+		{
+			// ensure validity
+			char szMapFile[64] = { 0 };
+			V_snprintf( szMapFile, sizeof( szMapFile ), "maps/%s.bsp", pMapName );
+			if (g_pVEngineServer->IsMapValid( szMapFile ))
+			{
+				// add to list
+				maplist_map_t newMap;
+				Q_strncpy(newMap.name, pMapName, sizeof(newMap.name));
+				aMaps->AddToTail( newMap );
+			}
+
+			CommandLine()->RemoveParm( "+map" );
+		}
+		else
+		{
+			// build the list of all the levels to scan
+			// Search the directory structure.
+			const char *mapwild = "maps/*.bsp";
+			char const *findfn = Sys_FindFirst( mapwild, NULL, 0 );
+			while ( findfn )
+			{
+				// make sure that it's in the mod filesystem
+				if ( !g_pFileSystem->FileExists( va("maps/%s", findfn), "MOD" ) )
+				{
+					findfn = Sys_FindNext( NULL, 0 );
+					continue;
+				}
+
+				// strip extension
+				char sz[ MAX_PATH ];
+				Q_strncpy( sz, findfn, sizeof( sz ) );
+				char *ext = strchr( sz, '.' );
+				if (ext)
+				{
+					ext[0] = 0;
+				}
+
+				// move to next item
+				findfn = Sys_FindNext( NULL, 0  );
+
+				// ensure validity
+				char szMapFile[64] = { 0 };
+				V_snprintf( szMapFile, sizeof( szMapFile ), "maps/%s.bsp", sz );
+				if (!g_pVEngineServer->IsMapValid( szMapFile ))
+					continue;
+
+				// add to list
+				maplist_map_t newMap;
+				Q_strncpy(newMap.name, sz, sizeof(newMap.name));
+				aMaps->AddToTail( newMap );
+			}
+
+			Sys_FindClose();
+		}
+	}
+	else
+	{
+		// Read from file
+		if ( pMapFile )
+		{
+			// Load them in
+			FileHandle_t resfilehandle;
+			resfilehandle = g_pFileSystem->Open( pMapFile, "rb" );
+			if ( FILESYSTEM_INVALID_HANDLE != resfilehandle )
+			{
+				// Read in and parse mapcycle.txt
+				int length = g_pFileSystem->Size(resfilehandle);
+				if ( length > 0 )
+				{
+					char *pStart = (char *)new char[ length + 1 ];
+					if ( pStart && ( length == g_pFileSystem->Read(pStart, length, resfilehandle) ) )
+					{
+						pStart[ length ] = 0;
+						const char *pFileList = pStart;
+
+						while ( 1 )
+						{
+							char szMap[ MAX_OSPATH ];
+
+							pFileList = COM_Parse( pFileList );
+							if ( strlen( com_token ) <= 0 )
+								break;
+
+							Q_strncpy(szMap, com_token, sizeof(szMap));
+
+							// ensure validity
+							char szMapFile[64] = { 0 };
+							V_snprintf( szMapFile, sizeof( szMapFile ), "maps/%s.bsp", szMap );
+							if (!g_pVEngineServer->IsMapValid( szMapFile ))
+								continue;
+
+							// Any more tokens on this line?
+							while ( COM_TokenWaiting( pFileList ) )
+							{
+								pFileList = COM_Parse( pFileList );
+							}
+
+							maplist_map_t newMap;
+							Q_strncpy(newMap.name, szMap, sizeof(newMap.name));
+							aMaps->AddToTail( newMap );
+						}
+					}
+					delete[] pStart;
+				}
+
+				g_pFileSystem->Close(resfilehandle);
+			}
+			else
+			{
+				Error( "Unable to load %s maplist file: %s\n", pSystemMsg, pMapFile );
+				return false;
+			}
+
+		}
+		else
+		{
+			Error( "Unable to find %s maplist filename\n", pSystemMsg );
+			return false;
+		}
+	}
+
+	int c = aMaps->Count();
+	if ( c == 0 )
+	{
+		Msg( "%s: No maps found\n", pSystemMsg );
+		return false;
+	}
+
+	Msg( "%s: Creating for:\n", pSystemMsg );
+
+	// Determine the current map (-startmap allows starts mid-maplist)
+	*iCurrentMap = 0;
+	char const *startmap = NULL;
+	if ( CommandLine()->CheckParm( "-startmap", &startmap ) && startmap )
+	{
+		for ( int i = 0 ; i < c; ++i )
+		{
+			if ( !Q_stricmp( aMaps->Element(i).name, startmap ) )
+			{
+				*iCurrentMap = i;
+			}
+		}
+	}
+
+	for ( int i = 0 ; i < c; ++i )
+	{
+		if ( i < *iCurrentMap )
+		{
+			Msg( "-  %s\n", aMaps->Element(i).name );
+		}
+		else
+		{
+			Msg( "+  %s\n", aMaps->Element(i).name );
+		}
+	}
+
+	return true;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Reconstructs engine log dictionary from existing engine reslist.
+// This is used to restore state after a restart, otherwise the engine log
+// would aggregate duplicate files.
+//-----------------------------------------------------------------------------
+void CMapReslistGenerator::BuildEngineLogFromReslist()
+{
+	m_EngineLog.RemoveAll();
+
+	CUtlBuffer buffer( 0, 0, CUtlBuffer::TEXT_BUFFER );
+	if ( !g_pFileSystem->ReadFile( CFmtStr( "%s\\%s", m_sResListDir.String(), ENGINE_RESLIST_FILE ), "DEFAULT_WRITE_PATH", buffer ) )
+	{
+		// does not exist
+		return;
+	}
+
+	characterset_t breakSet;
+	CharacterSetBuild( &breakSet, "" );
+
+	// parse reslist
+	char szToken[MAX_PATH];
+	for ( ;; )
+	{
+		int nTokenSize = buffer.ParseToken( &breakSet, szToken, sizeof( szToken ) );
+		if ( nTokenSize <= 0 )
+		{
+			break;
+		}
+
+		int idx = m_EngineLog.Find( szToken );
+		if ( idx == m_EngineLog.InvalidIndex() )
+		{
+			m_EngineLog.Insert( szToken );
+		}
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Appends specified line to the engine reslist.
+//-----------------------------------------------------------------------------
+void CMapReslistGenerator::LogToEngineReslist( char const *pLine )
+{
+	// prevent unecessary duplication due to file appending
+	int idx = m_EngineLog.Find( pLine );
+	if ( idx != m_EngineLog.InvalidIndex() )
+	{
+		// already logged
+		return;
+	}
+
+	m_EngineLog.Insert( pLine );
+
+	// Open for append, write data, close.
+	FileHandle_t fh = g_pFileSystem->Open( CFmtStr( "%s\\%s", m_sResListDir.String(), ENGINE_RESLIST_FILE ), "at", "DEFAULT_WRITE_PATH" );
+	if ( fh != FILESYSTEM_INVALID_HANDLE )
+	{
+		g_pFileSystem->Write( "\"", 1, fh );
+		g_pFileSystem->Write( pLine, Q_strlen( pLine  ), fh );
+		g_pFileSystem->Write( "\"\n", 2, fh );
+		g_pFileSystem->Close( fh );
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: initializes the object to enable reslist generation
+//-----------------------------------------------------------------------------
+void CMapReslistGenerator::EnableReslistGeneration( bool usemaplistfile )
+{
+	//hackhack !!!! This is a work-around until CS precaches things on level start, not player spawn
+	if ( !Q_stricmp( "cstrike", GetCurrentMod() ))
+	{
+		m_iPauseTimeBetweenMaps = PAUSE_TIME_BETWEEN_MAPS * 3;
+		m_iPauseFramesBetweenMaps = PAUSE_FRAMES_BETWEEN_MAPS * 3;
+	}
+
+	m_bUsingMapList = usemaplistfile;
+
+	m_bLoggingEnabled = true;
+
+	char const *pszDir = NULL;
+	if ( CommandLine()->CheckParm( "-reslistdir", &pszDir ) && pszDir )
+	{
+		char szDir[ MAX_PATH ];
+		Q_strncpy( szDir, pszDir, sizeof( szDir ) );
+		Q_StripTrailingSlash( szDir );
+		Q_strlower( szDir );
+		Q_FixSlashes( szDir );
+
+		if ( Q_strlen( szDir ) > 0 )
+		{
+			m_sResListDir = szDir;
+		}
+	}
+
+	// create file to dump out to
+	g_pFileSystem->CreateDirHierarchy( m_sResListDir.String() , "DEFAULT_WRITE_PATH" );
+
+	// Leave the existing one if resuming from a specific map, otherwise, blow it away
+	if ( !CommandLine()->FindParm( "-startmap" ) )
+	{
+		g_pFileSystem->RemoveFile( CFmtStr( "%s\\%s", m_sResListDir.String(), ENGINE_RESLIST_FILE ), "DEFAULT_WRITE_PATH" );
+		m_EngineLog.RemoveAll();
+	}
+	else
+	{
+		BuildEngineLogFromReslist();
+	}
+
+	// add logging function
+	g_pFileSystem->AddLoggingFunc(&FileSystemLoggingFunc);
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: starts the first map
+//-----------------------------------------------------------------------------
+void CMapReslistGenerator::StartReslistGeneration()
+{
+	m_iCurrentMap = 0;
+	m_iFrameCountdownToRunningNextMap = m_iPauseFramesBetweenMaps;
+	m_flNextMapRunTime = Sys_FloatTime() + m_iPauseTimeBetweenMaps;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Input  : *mapname - 
+//-----------------------------------------------------------------------------
+void CMapReslistGenerator::SetPrefix( char const *mapname )
+{
+	Q_snprintf( m_szPrefix, sizeof( m_szPrefix ), "%s:  ", mapname );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Output : char const
+//-----------------------------------------------------------------------------
+char const *CMapReslistGenerator::LogPrefix()
+{
+	// If not recording stuff to file, then use the "default" prefix.
+	if ( m_bLogToEngineList )
+	{
+		return "engine:  ";
+	}
+
+	return m_szPrefix;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: call to mark level load/end
+//-----------------------------------------------------------------------------
+void CMapReslistGenerator::OnLevelLoadStart(const char *levelName)
+{
+	if ( !IsEnabled() )
+		return;
+
+	// reset the duplication list
+	m_AlreadyWrittenFileNames.RemoveAll();
+
+	// prepare for map logging
+	m_bLogToEngineList = false;
+	m_MapLog.RemoveAll();
+	V_strncpy( m_szLevelName, levelName, sizeof( m_szLevelName ) );
+
+	// add in the bsp file to the list, and its node graph
+	char path[MAX_PATH];
+	Q_snprintf( path, sizeof( path ), "maps\\%s.bsp", levelName );
+	OnResourcePrecached( path );
+
+	bool useNodeGraph = true;
+	KeyValues *modinfo = new KeyValues("ModInfo");
+	if ( modinfo->LoadFromFile( g_pFileSystem, "gameinfo.txt" ) )
+	{
+		useNodeGraph = modinfo->GetInt( "nodegraph", 1 ) != 0;
+	}
+	modinfo->deleteThis();
+
+	if ( useNodeGraph )
+	{
+		Q_snprintf(path, sizeof(path), "maps\\graphs\\%s.ain", levelName);
+		OnResourcePrecached(path);
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: call to mark level load/end
+//-----------------------------------------------------------------------------
+void CMapReslistGenerator::OnLevelLoadEnd()
+{
+}
+
+void CMapReslistGenerator::OnPlayerSpawn()
+{
+	if ( !IsEnabled() )
+		return;
+
+	// initiate the next level
+	m_iFrameCountdownToRunningNextMap = m_iPauseFramesBetweenMaps;
+	m_flNextMapRunTime = Sys_FloatTime() + m_iPauseTimeBetweenMaps;
+}
+
+bool CMapReslistGenerator::ShouldRebuildCaches()
+{
+	if ( !IsEnabled() )
+	{
+		return CommandLine()->FindParm( "-rebuildaudio" ) != 0;
+	}
+
+	if ( !CommandLine()->FindParm( "-norebuildaudio" ) )
+		return true;
+	return false;
+}
+
+char const *CMapReslistGenerator::GetResListDirectory() const
+{
+	return m_sResListDir.String();
+}
+
+void CMapReslistGenerator::DoQuit()
+{
+	Cbuf_AddText( "quit\n" );
+	// remove the logging
+	g_pFileSystem->RemoveLoggingFunc(&FileSystemLoggingFunc);
+	m_bLogToEngineList = true;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: call every frame if we're enabled, just so that the next map can be triggered at the right time
+//-----------------------------------------------------------------------------
+void CMapReslistGenerator::RunFrame()
+{
+	if ( !IsEnabled() )
+	{
+		if ( m_bAutoQuit )
+		{
+			m_bAutoQuit = false;
+			DoQuit();
+		}
+		return;
+	}
+
+	if ( --m_iFrameCountdownToRunningNextMap > 0 )
+		return;
+
+	if ( m_flNextMapRunTime && m_flNextMapRunTime < Sys_FloatTime() )
+	{
+		// about to transition or terminate, emit the current map log
+		WriteMapLog();
+
+		if ( m_Maps.IsValidIndex( m_iCurrentMap ) )
+		{
+			m_flNextMapRunTime = 0.0f;
+			m_iFrameCountdownToRunningNextMap = 0;
+
+			if ( !m_bRestartOnTransition )
+			{
+				Cbuf_AddText( va( "map %s\n", m_Maps[m_iCurrentMap].name ) );
+
+				SetPrefix( m_Maps[m_iCurrentMap].name );
+
+				++m_iCurrentMap;
+				if ( m_Maps.IsValidIndex( m_iCurrentMap ) )
+				{
+					// cause a full engine restart on the transition to the next map
+					// ensure that one-time init code logs correctly to each map reslist
+					m_bRestartOnTransition = true;
+				}
+			}
+			else
+			{
+				// restart at specified map
+				CommandLine()->RemoveParm( "-startmap" );
+				CommandLine()->AppendParm( "-startmap", m_Maps[m_iCurrentMap].name );	
+				HostState_Restart();
+			}
+		}
+		else
+		{
+			// no more levels, just quit
+			if ( !CommandLine()->FindParm( "-forever" ) )
+			{
+				DoQuit();
+			}
+			else
+			{
+				StartReslistGeneration();
+				m_bRestartOnTransition = true;
+			}
+		}
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: logs and handles mdl files being precaches
+//-----------------------------------------------------------------------------
+void CMapReslistGenerator::OnModelPrecached(const char *relativePathFileName)
+{
+	if ( !IsEnabled() )
+		return;
+
+	if (strstr(relativePathFileName, ".vmt"))
+	{
+		// it's a materials file, make sure that it starts in the materials directory, and we get the .vtf
+		char file[_MAX_PATH];
+
+		if (!Q_strnicmp(relativePathFileName, "materials", strlen("materials")))
+		{
+			Q_strncpy(file, relativePathFileName, sizeof(file));
+		}
+		else
+		{
+			// prepend the materials directory
+			Q_snprintf(file, sizeof(file), "materials\\%s", relativePathFileName);
+		}
+		OnResourcePrecached(file);
+
+		// get the matching vtf file
+		char *ext = strstr(file, ".vmt");
+		if (ext)
+		{
+			Q_strncpy(ext, ".vtf", 5);
+			OnResourcePrecached(file);
+		}
+	}
+	else
+	{
+		OnResourcePrecached(relativePathFileName);
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: logs sound file access
+//-----------------------------------------------------------------------------
+void CMapReslistGenerator::OnSoundPrecached(const char *relativePathFileName)
+{
+	// skip any special characters
+	if (!V_isalnum(relativePathFileName[0]))
+	{
+		++relativePathFileName;
+	}
+
+	// prepend the sound/ directory if necessary
+	char file[_MAX_PATH];
+	if (!Q_strnicmp(relativePathFileName, "sound", strlen("sound")))
+	{
+		Q_strncpy(file, relativePathFileName, sizeof(file));
+	}
+	else
+	{
+		// prepend the sound directory
+		Q_snprintf(file, sizeof(file), "sound\\%s", relativePathFileName);
+	}
+
+	OnResourcePrecached(file);
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: logs the precache as a file access
+//-----------------------------------------------------------------------------
+void CMapReslistGenerator::OnResourcePrecached(const char *relativePathFileName)
+{
+	if ( !IsEnabled() )
+		return;
+
+	// ignore empty string
+	if (relativePathFileName[0] == 0)
+		return;
+
+	// ignore files that start with '*' since they signify special models
+	if (relativePathFileName[0] == '*')
+		return;
+
+	char fullPath[_MAX_PATH];
+	if (g_pFileSystem->GetLocalPath(relativePathFileName, fullPath, sizeof(fullPath)))
+	{
+		OnResourcePrecachedFullPath(fullPath);
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Logs out file access to a file
+//-----------------------------------------------------------------------------
+void CMapReslistGenerator::OnResourcePrecachedFullPath(const char *fullPathFileName)
+{
+	char fixed[ MAX_PATH ];
+	Q_strncpy( fixed, fullPathFileName, sizeof( fixed ) );
+	Q_strlower( fixed );
+	Q_FixSlashes( fixed );
+
+	// make sure the filename hasn't already been written
+	UtlSymId_t filename = m_AlreadyWrittenFileNames.Find( fixed );
+	if ( filename != UTL_INVAL_SYMBOL )
+		return;
+
+	// record in list, so we don't write it again
+	m_AlreadyWrittenFileNames.AddString( fixed );
+
+	// add extras for mdl's
+	if (strstr(fixed, ".mdl"))
+	{
+		// it's a model, get it's other files as well
+		char file[_MAX_PATH];
+		Q_strncpy(file, fixed, sizeof(file) - 10);
+		char *ext = strstr(file, ".mdl");
+
+		Q_strncpy(ext, ".vvd", 10);
+		OnResourcePrecachedFullPath(file);
+		Q_strncpy(ext, ".ani", 10);
+		OnResourcePrecachedFullPath(file);
+		Q_strncpy(ext, ".dx80.vtx", 10);
+		OnResourcePrecachedFullPath(file);
+		Q_strncpy(ext, ".dx90.vtx", 10);
+		OnResourcePrecachedFullPath(file);
+		Q_strncpy(ext, ".sw.vtx", 10);
+		OnResourcePrecachedFullPath(file);
+		Q_strncpy(ext, ".phy", 10);
+		OnResourcePrecachedFullPath(file);
+		Q_strncpy(ext, ".jpg", 10);
+		OnResourcePrecachedFullPath(file);
+	}
+
+	// strip it down relative to the root directory of the game (for steam)
+	char const *relativeFileName = Q_stristr( fixed, GetBaseDirectory() );
+	if ( relativeFileName )
+	{
+		// Skip the basedir and slash
+		relativeFileName += ( Q_strlen( GetBaseDirectory() ) + 1 );
+	}
+
+	if ( !relativeFileName )
+	{
+		return;
+	}
+
+	if ( m_bLogToEngineList )
+	{
+		LogToEngineReslist( relativeFileName );
+	}
+	else
+	{
+		// find or add to sorted tree
+		int idx = m_MapLog.Find( relativeFileName );
+		if ( idx == m_MapLog.InvalidIndex() )
+		{
+			m_MapLog.Insert( relativeFileName );
+		}
+	}
+}
+
+void CMapReslistGenerator::WriteMapLog()
+{
+	if ( !m_szLevelName[0] )
+	{
+		// log has not been established yet
+		return;
+	}
+
+	// write the sorted map log, allows for easier diffs between revisions
+	char path[_MAX_PATH];
+	Q_snprintf( path, sizeof( path ), "%s\\%s.lst", m_sResListDir.String(), m_szLevelName );
+	FileHandle_t fh = g_pFileSystem->Open( path, "wt", "DEFAULT_WRITE_PATH" );
+	for ( int i = m_MapLog.FirstInorder(); i != m_MapLog.InvalidIndex(); i = m_MapLog.NextInorder( i ) )
+	{
+		const char *pLine = m_MapLog[i].String();
+		g_pFileSystem->Write( "\"", 1, fh );
+		g_pFileSystem->Write( pLine, Q_strlen( pLine ), fh );
+		g_pFileSystem->Write( "\"\n", 2, fh );
+	}
+	g_pFileSystem->Close( fh );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: callback function from filesystem
+//-----------------------------------------------------------------------------
+void CMapReslistGenerator::FileSystemLoggingFunc(const char *fullPathFileName, const char *options)
+{
+	g_MapReslistGenerator.OnResourcePrecachedFullPath(fullPathFileName);
+}
+
+#define DELETIONS_BATCH_FILE		"deletions.bat"
+#define DELETIONS_WARNINGS_FILE		"undelete.lst"
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CMapReslistGenerator::EnableDeletionsTracking()
+{
+	unsigned int deletions = 0;
+	unsigned int warnings = 0;
+
+	// Load deletions file and build dictionary
+	m_bTrackingDeletions =  true;;
+
+	// Open up deletions.bat and parse out all filenames
+	// Load them in
+	FileHandle_t deletionsfile;
+	deletionsfile = g_pFileSystem->Open( DELETIONS_BATCH_FILE, "rb" );
+	if ( FILESYSTEM_INVALID_HANDLE != deletionsfile )
+	{
+		// Read in and parse mapcycle.txt
+		int length = g_pFileSystem->Size(deletionsfile);
+		if ( length > 0 )
+		{
+			char *pStart = (char *)new char[ length + 1 ];
+			if ( pStart && ( length == g_pFileSystem->Read(pStart, length, deletionsfile) ) )
+			{
+				pStart[ length ] = 0;
+				const char *pFileList = pStart;
+
+				while ( 1 )
+				{
+					char filename[ MAX_OSPATH ];
+
+					pFileList = COM_Parse( pFileList );
+					if ( strlen( com_token ) <= 0 )
+						break;
+
+					if ( !Q_stricmp( com_token, "del" ) )
+						continue;
+
+					Q_snprintf(filename, sizeof( filename ), "%s/%s", com_gamedir, com_token );
+
+					// Any more tokens on this line?
+					while ( COM_TokenWaiting( pFileList ) )
+					{
+						pFileList = COM_Parse( pFileList );
+					}
+
+					Q_FixSlashes( filename );
+					Q_strlower( filename );
+	
+					m_DeletionList.AddString( filename );
+
+					++deletions;
+				}
+			}
+			delete[] pStart;
+		}
+
+		g_pFileSystem->Close(deletionsfile);
+	}
+	else
+	{
+		Warning( "Unable to load deletions.bat file %s\n", DELETIONS_BATCH_FILE );
+		m_bTrackingDeletions = false;
+		return;
+	}
+
+	FileHandle_t warningsfile = g_pFileSystem->Open( DELETIONS_WARNINGS_FILE, "rb" );
+	if ( FILESYSTEM_INVALID_HANDLE != warningsfile )
+	{
+		// Read in and parse mapcycle.txt
+		int length = g_pFileSystem->Size(warningsfile);
+		if ( length > 0 )
+		{
+			char *pStart = (char *)new char[ length + 1 ];
+			if ( pStart && ( length == g_pFileSystem->Read(pStart, length, warningsfile) ) )
+			{
+				pStart[ length ] = 0;
+				const char *pFileList = pStart;
+
+				while ( 1 )
+				{
+					pFileList = COM_Parse( pFileList );
+					if ( strlen( com_token ) <= 0 )
+						break;
+
+					Q_FixSlashes( com_token );
+					Q_strlower( com_token );
+	
+					CUtlSymbol sym = m_DeletionListWarningsSymbols.AddString( com_token );
+					int idx = m_DeletionListWarnings.Find( sym );
+					if ( idx == m_DeletionListWarnings.InvalidIndex() )
+					{
+						m_DeletionListWarnings.Insert( sym );
+						++warnings;
+					}
+				}
+			}
+			delete[] pStart;
+		}
+
+		g_pFileSystem->Close(warningsfile);
+	}
+	
+	// Hook up logging function
+	g_pFileSystem->AddLoggingFunc( &TrackDeletionsLoggingFunc );
+
+	Msg( "Tracking deletions (%u files in deletion list in '%s', %u previous warnings loaded from '%s'\n",
+		deletions, DELETIONS_BATCH_FILE, warnings, DELETIONS_WARNINGS_FILE );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Input  : *fullPathFileName - 
+//-----------------------------------------------------------------------------
+void CMapReslistGenerator::TrackDeletions( const char *fullPathFileName )
+{
+	Assert( m_bTrackingDeletions );
+
+	char test[ _MAX_PATH ];
+	Q_strncpy( test, fullPathFileName, sizeof( test ) );
+	Q_FixSlashes( test );
+	Q_strlower( test );
+
+	CUtlSymbol sym = m_DeletionList.Find( test );
+	if ( UTL_INVAL_SYMBOL != sym )
+	{
+		CUtlSymbol warningSymbol = m_DeletionListWarningsSymbols.AddString( test );
+
+		uint idx = m_DeletionListWarnings.Find( warningSymbol );
+		if ( idx == m_DeletionListWarnings.InvalidIndex() )
+		{
+			Msg( "--> Referenced file marked for deletion \"%s\"\n", test );
+			m_DeletionListWarnings.Insert( warningSymbol );
+		}
+	}
+
+	// add extras for mdl's
+	if (strstr(test, ".mdl"))
+	{
+		// it's a model, get it's other files as well
+		char file[_MAX_PATH];
+		Q_strncpy(file, test, sizeof(file) - 10);
+		char *ext = strstr(file, ".mdl");
+
+		Q_strncpy(ext, ".vvd", 10);
+		TrackDeletions(file);
+		Q_strncpy(ext, ".ani", 10);
+		TrackDeletions(file);
+		Q_strncpy(ext, ".dx80.vtx", 10);
+		TrackDeletions(file);
+		Q_strncpy(ext, ".dx90.vtx", 10);
+		TrackDeletions(file);
+		Q_strncpy(ext, ".sw.vtx", 10);
+		TrackDeletions(file);
+		Q_strncpy(ext, ".phy", 10);
+		TrackDeletions(file);
+		Q_strncpy(ext, ".jpg", 10);
+		TrackDeletions(file);
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: callback function from filesystem
+//-----------------------------------------------------------------------------
+void CMapReslistGenerator::TrackDeletionsLoggingFunc(const char *fullPathFileName, const char *options)
+{
+	g_MapReslistGenerator.TrackDeletions(fullPathFileName);
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CMapReslistGenerator::Shutdown()
+{
+	if ( m_bTrackingDeletions )
+	{
+		SpewTrackedDeletionsLog();
+
+		g_pFileSystem->RemoveLoggingFunc( &TrackDeletionsLoggingFunc );
+		m_DeletionList.RemoveAll();
+		m_DeletionListWarnings.RemoveAll();
+		m_DeletionListWarningsSymbols.RemoveAll();
+		m_bTrackingDeletions = NULL;
+	}
+}
+
+void CMapReslistGenerator::SpewTrackedDeletionsLog()
+{
+	if ( !m_bTrackingDeletions )
+		return;
+
+	FileHandle_t hUndeleteFile = g_pFileSystem->Open( DELETIONS_WARNINGS_FILE, "wt", "DEFAULT_WRITE_PATH" );
+	if ( FILESYSTEM_INVALID_HANDLE == hUndeleteFile )
+	{
+		return;
+	}
+
+	for ( int i = m_DeletionListWarnings.FirstInorder(); i != m_DeletionListWarnings.InvalidIndex() ; i = m_DeletionListWarnings.NextInorder( i ) )
+	{
+		char const *filename = m_DeletionListWarningsSymbols.String( m_DeletionListWarnings[ i ] );
+
+		g_pFileSystem->Write("\"", 1, hUndeleteFile);
+		g_pFileSystem->Write(filename, Q_strlen(filename), hUndeleteFile);
+		g_pFileSystem->Write("\"\n", 2, hUndeleteFile);
+	}
+
+	g_pFileSystem->Close( hUndeleteFile );
+}
+
+