hl2sdk/utils/vbsp/manifest.cpp

//========= Copyright Valve Corporation, All rights reserved. ============//
#include "vbsp.h"
#include "map_shared.h"
#include "fgdlib/fgdlib.h"
#include "manifest.h"
#include "windows.h"

//-----------------------------------------------------------------------------
// Purpose: default constructor
//-----------------------------------------------------------------------------
CManifestMap::CManifestMap( void )
{
	m_RelativeMapFileName[ 0 ] = 0;
	m_bTopLevelMap = false;
}


//-----------------------------------------------------------------------------
// Purpose: default constructor
//-----------------------------------------------------------------------------
CManifest::CManifest( void ) 
{ 
	m_InstancePath[ 0 ] = 0;
	m_bIsCordoning = false;
	m_CordoningMapEnt = NULL;
}


//-----------------------------------------------------------------------------
// Purpose: this function will parse through the known keys for the manifest map entry
// Input  : szKey - the key name
//			szValue - the value
//			pManifestMap - the manifest map this belongs to
// Output : ChunkFileResult_t - result of the parsing
//-----------------------------------------------------------------------------
ChunkFileResult_t CManifest::LoadManifestMapKeyCallback( const char *szKey, const char *szValue, CManifestMap *pManifestMap )
{
	if ( !stricmp( szKey, "Name" ) )
	{
		//		pManifestMap->m_FriendlyName = szValue;
	}
	else if ( !stricmp( szKey, "File" ) )
	{
		strcpy( pManifestMap->m_RelativeMapFileName, szValue );
	}
	else if ( !stricmp( szKey, "IsPrimary" ) )
	{
		//		pManifestMap->m_bPrimaryMap = ( atoi( szValue ) == 1 );
	}
	else if ( !stricmp( szKey, "IsProtected" ) )
	{
		//		pManifestMap->m_bCanBeModified = ( atoi( szValue ) != 1 );
	}
	else if ( !stricmp( szKey, "TopLevel" ) )
	{
		pManifestMap->m_bTopLevelMap = ( atoi( szValue ) == 1 );
	}

	return ChunkFile_Ok;
}


//-----------------------------------------------------------------------------
// Purpose: this function is responsible for setting up the manifest map about to be read in
// Input  : pFile - the chunk file being read
//			pDoc - the owning manifest document
// Output : ChunkFileResult_t - result of the parsing
//-----------------------------------------------------------------------------
ChunkFileResult_t CManifest::LoadManifestVMFCallback( CChunkFile *pFile, CManifest *pManifest )
{
	CManifestMap	*pManifestMap = new CManifestMap();

	pManifest->m_Maps.AddToTail( pManifestMap );

	ChunkFileResult_t eResult = pFile->ReadChunk( ( KeyHandler_t )LoadManifestMapKeyCallback, pManifestMap );

	return( eResult );
}


//-----------------------------------------------------------------------------
// Purpose: this function will load the VMF chunk
// Input  : pFile - the chunk file being read
//			pDoc - the owning manifest document
// Output : ChunkFileResult_t - result of the parsing
//-----------------------------------------------------------------------------
ChunkFileResult_t CManifest::LoadManifestMapsCallback( CChunkFile *pFile, CManifest *pManifest )
{
	CChunkHandlerMap Handlers;
	Handlers.AddHandler( "VMF", ( ChunkHandler_t )LoadManifestVMFCallback, pManifest );
	pFile->PushHandlers(&Handlers);

	ChunkFileResult_t eResult = ChunkFile_Ok;

	eResult = pFile->ReadChunk();

	pFile->PopHandlers();

	return( eResult );
}


//-----------------------------------------------------------------------------
// Purpose: 
// Input  : 
// Output : 
//-----------------------------------------------------------------------------
ChunkFileResult_t CManifest::LoadCordonBoxCallback( CChunkFile *pFile, Cordon_t *pCordon )
{
	// Add a box to this cordon.
	pCordon->m_Boxes.AddToTail();
	BoundBox &box = pCordon->m_Boxes.Tail();

	// Fill it in with the data from the VMF.
	return pFile->ReadChunk( (KeyHandler_t)LoadCordonBoxKeyCallback, (void *)&box );
}


//-----------------------------------------------------------------------------
// Purpose: 
// Input  : 
// Output : 
//-----------------------------------------------------------------------------
ChunkFileResult_t CManifest::LoadCordonBoxKeyCallback( const char *szKey, const char *szValue, BoundBox *pBox )
{
	if (!stricmp(szKey, "mins"))
	{
		CChunkFile::ReadKeyValuePoint(szValue, pBox->bmins);
	}
	else if (!stricmp(szKey, "maxs"))
	{
		CChunkFile::ReadKeyValuePoint(szValue, pBox->bmaxs);
	}

	return ChunkFile_Ok;
}


//-----------------------------------------------------------------------------
// Purpose: 
// Input  : 
// Output : 
//-----------------------------------------------------------------------------
ChunkFileResult_t CManifest::LoadCordonKeyCallback( const char *szKey, const char *szValue, Cordon_t *pCordon )
{
	if (!stricmp(szKey, "name"))
	{
		pCordon->m_szName.Set( szValue );
	}
	// Whether this particular cordon volume is active.
	else if (!stricmp(szKey, "active"))
	{
		CChunkFile::ReadKeyValueBool(szValue, pCordon->m_bActive);
	}

	return ChunkFile_Ok;
}


//-----------------------------------------------------------------------------
// Purpose: 
// Input  : 
// Output : 
//-----------------------------------------------------------------------------
ChunkFileResult_t CManifest::LoadCordonCallback( CChunkFile *pFile, CManifest *pManifest )
{
	// Add a new cordon which will be filled in by the key callback
	pManifest->m_Cordons.AddToTail();
	Cordon_t &cordon = pManifest->m_Cordons.Tail();

	CChunkHandlerMap Handlers;
	Handlers.AddHandler( "box", (ChunkHandler_t)CManifest::LoadCordonBoxCallback, (void *)&cordon );

	pFile->PushHandlers(&Handlers);
	ChunkFileResult_t eResult = pFile->ReadChunk( (KeyHandler_t)LoadCordonKeyCallback, (void *)&cordon );
	pFile->PopHandlers();

	return(eResult);
}


//-----------------------------------------------------------------------------------------------------------
// Parses keys that are applicable to all cordons in the map.
//-----------------------------------------------------------------------------
ChunkFileResult_t CManifest::LoadCordonsKeyCallback( const char *szKey, const char *szValue, CManifest *pManifest )
{
	// Whether the cordoning system is enabled or disabled.
	if ( !stricmp( szKey, "active" ) )
	{
		CChunkFile::ReadKeyValueBool( szValue, pManifest->m_bIsCordoning );
	}

	return ChunkFile_Ok;
}


//-----------------------------------------------------------------------------
// Parses the VMF chunk that pertains to all the cordons in the map:
//
//		cordons
//		{
//			"active" "true"
//			cordon
//			{
//				"active" "true"
//				"box"
//				{
//					"mins" "-1024, -1024, -1024"
//					"maxs" "1024, 1024, 1024"
//				}
//				...may be more boxes...
//			}
//			...may be more cordons...
//		}
//
//-----------------------------------------------------------------------------
ChunkFileResult_t CManifest::LoadCordonsCallback( CChunkFile *pFile, CManifest *pManifest )
{
	CChunkHandlerMap Handlers;
	Handlers.AddHandler( "cordon", (ChunkHandler_t)CManifest::LoadCordonCallback, pManifest );

	pFile->PushHandlers(&Handlers);
	ChunkFileResult_t eResult = pFile->ReadChunk( (KeyHandler_t)LoadCordonsKeyCallback, pManifest );
	pFile->PopHandlers();

	return(eResult);
}

extern ChunkFileResult_t LoadSolidCallback(CChunkFile *pFile, LoadEntity_t *pLoadEntity);

ChunkFileResult_t CManifest::LoadManifestCordoningPrefsCallback( CChunkFile *pFile, CManifest *pDoc )
{
	pDoc->m_CordoningMapEnt = &g_MainMap->entities[g_MainMap->num_entities];
	g_MainMap->num_entities++;
	memset( pDoc->m_CordoningMapEnt, 0, sizeof( *pDoc->m_CordoningMapEnt ) );
	pDoc->m_CordoningMapEnt->firstbrush = g_MainMap->nummapbrushes;
	pDoc->m_CordoningMapEnt->numbrushes = 0;

	LoadEntity_t LoadEntity;
	LoadEntity.pEntity = pDoc->m_CordoningMapEnt;

	// No default flags/contents
	LoadEntity.nBaseFlags = 0;
	LoadEntity.nBaseContents = 0;

	//
	// Set up handlers for the subchunks that we are interested in.
	//
	CChunkHandlerMap Handlers;
	Handlers.AddHandler( "cordons", ( ChunkHandler_t )CManifest::LoadCordonsCallback, pDoc );
	Handlers.AddHandler("solid", (ChunkHandler_t)::LoadSolidCallback, &LoadEntity);
	pFile->PushHandlers(&Handlers);

	ChunkFileResult_t eResult = ChunkFile_Ok;

	eResult = pFile->ReadChunk();

	pFile->PopHandlers();

	return( eResult );
}


//-----------------------------------------------------------------------------
// Purpose: this function will create a new entity pair
// Input  : pKey - the key of the pair
//			pValue - the value of the pair
// Output : returns a newly created epair structure
//-----------------------------------------------------------------------------
epair_t *CManifest::CreateEPair( char *pKey, char *pValue )
{
	epair_t *pEPair = new epair_t;

	pEPair->key = new char[ strlen( pKey ) + 1 ];
	pEPair->value = new char[ strlen( pValue ) + 1 ];

	strcpy( pEPair->key, pKey );
	strcpy( pEPair->value, pValue );

	return pEPair;
}


//-----------------------------------------------------------------------------
// Purpose: this function will load in all of the submaps belonging to this manifest, 
//			except for the top level map, which is loaded separately.
// Input  : pMapFile - the top level map that was previously loaded
//			pszFileName - the absolute file name of the top level map file
// Output : returns true if all submaps were loaded
//-----------------------------------------------------------------------------
bool CManifest::LoadSubMaps( CMapFile *pMapFile, const char *pszFileName )
{
	entity_t	*InstanceEntity;
	epair_t		*pEPair;

	InstanceEntity = &pMapFile->entities[ pMapFile->num_entities ];
	pMapFile->num_entities++;
	memset( InstanceEntity, 0, sizeof( *InstanceEntity ) );

	InstanceEntity->origin.Init( 0.0f, 0.0f, 0.0f );
	pEPair = CreateEPair( "classname", "worldspawn" );
	pEPair->next = InstanceEntity->epairs;
	InstanceEntity->epairs = pEPair;

	for( int i = 0; i < m_Maps.Count(); i++ )
	{
		//		if ( m_Maps[ i ]->m_bTopLevelMap == false )
		{
			char		FileName[ MAX_PATH ];

			sprintf( FileName, "%s%s", m_InstancePath, m_Maps[ i ]->m_RelativeMapFileName );

			InstanceEntity = &pMapFile->entities[ pMapFile->num_entities ];
			pMapFile->num_entities++;

			memset( InstanceEntity, 0, sizeof( *InstanceEntity ) );
			InstanceEntity->origin.Init( 0.0f, 0.0f, 0.0f );

			pEPair = CreateEPair( "angles", "0 0 0" );
			pEPair->next = InstanceEntity->epairs;
			InstanceEntity->epairs = pEPair;

			char temp[ 128 ];
			sprintf( temp, "%d", GameData::NAME_FIXUP_NONE );

			pEPair = CreateEPair( "fixup_style", temp );
			pEPair->next = InstanceEntity->epairs;
			InstanceEntity->epairs = pEPair;

			pEPair = CreateEPair( "classname", "func_instance" );
			pEPair->next = InstanceEntity->epairs;
			InstanceEntity->epairs = pEPair;

			pEPair = CreateEPair( "file", m_Maps[ i ]->m_RelativeMapFileName );
			pEPair->next = InstanceEntity->epairs;
			InstanceEntity->epairs = pEPair;

			if ( m_Maps[ i ]->m_bTopLevelMap == true )
			{
				pEPair = CreateEPair( "toplevel", "1" );
				pEPair->next = InstanceEntity->epairs;
				InstanceEntity->epairs = pEPair;
			}
		}
	}

	return true;
}


//-----------------------------------------------------------------------------
// Purpose: 
// Input  : 
// Output : 
//-----------------------------------------------------------------------------
bool CManifest::LoadVMFManifestUserPrefs( const char *pszFileName )
{
	char		UserName[ MAX_PATH ], FileName[ MAX_PATH ], UserPrefsFileName[ MAX_PATH ];
	DWORD		UserNameSize;

	UserNameSize = sizeof( UserName );
	if ( GetUserName( UserName, &UserNameSize ) == 0 )
	{
		strcpy( UserPrefsFileName, "default" );
	}

	sprintf( UserPrefsFileName, "\\%s.vmm_prefs", UserName );
	V_StripExtension( pszFileName, FileName, sizeof( FileName ) );
	strcat( FileName, UserPrefsFileName );

	FILE *fp = fopen( FileName, "rb" );
	if ( !fp )
	{
		return false;
	}

	CChunkFile File;
	ChunkFileResult_t eResult = File.Open( FileName, ChunkFile_Read );

	if ( eResult == ChunkFile_Ok )
	{
		//
		// Set up handlers for the subchunks that we are interested in.
		//
		CChunkHandlerMap Handlers;
		Handlers.AddHandler( "cordoning", ( ChunkHandler_t )CManifest::LoadManifestCordoningPrefsCallback, this );

		//		Handlers.SetErrorHandler( ( ChunkErrorHandler_t )CMapDoc::HandleLoadError, this);

		File.PushHandlers(&Handlers);

		while( eResult == ChunkFile_Ok )
		{
			eResult = File.ReadChunk();
		}

		if ( eResult == ChunkFile_EOF )
		{
			eResult = ChunkFile_Ok;
		}

		File.PopHandlers();
	}

	if ( eResult == ChunkFile_Ok )
	{
	}
	else
	{
		// no pref message for now
		//		GetMainWnd()->MessageBox( File.GetErrorText( eResult ), "Error loading manifest!", MB_OK | MB_ICONEXCLAMATION );
	}

	return true;
}


//-----------------------------------------------------------------------------
// Purpose: Loads a .VMM file.
// Input  : pszFileName - Full path of the map file to load.
//-----------------------------------------------------------------------------
bool CManifest::LoadVMFManifest( const char *pszFileName )
{
	V_StripExtension( pszFileName, m_InstancePath, sizeof( m_InstancePath ) );
	strcat( m_InstancePath, "\\" );

	CChunkFile File;
	ChunkFileResult_t eResult = File.Open( pszFileName, ChunkFile_Read );
	if ( eResult != ChunkFile_Ok )
	{
		g_MapError.ReportError( File.GetErrorText( eResult ) );
		return false;
	}

	CChunkHandlerMap Handlers;
	Handlers.AddHandler( "Maps", ( ChunkHandler_t )LoadManifestMapsCallback, this );

	File.PushHandlers(&Handlers);

	while (eResult == ChunkFile_Ok)
	{
		eResult = File.ReadChunk();
	}

	if (eResult == ChunkFile_EOF)
	{
		eResult = ChunkFile_Ok;
	}

	File.PopHandlers();

	if ( eResult == ChunkFile_Ok )
	{
		int index = g_Maps.AddToTail( new CMapFile() );
		g_LoadingMap = g_Maps[ index ];
		if ( g_MainMap == NULL )
		{
			g_MainMap = g_LoadingMap;
		}

		LoadSubMaps( g_LoadingMap, pszFileName );

		LoadVMFManifestUserPrefs( pszFileName );
	}

	return ( eResult == ChunkFile_Ok );
}


//-----------------------------------------------------------------------------
// Purpose: 
// Input  : 
// Output : 
//-----------------------------------------------------------------------------
void CManifest::CordonWorld( )
{
	if ( m_bIsCordoning == false )
	{
		return;
	}

	for ( int i = 0; i < g_MainMap->num_entities; i++ )
	{
		if ( i == 0 )
		{	// for world spawn, we look at brushes
			for( int nBrushNum = 0; nBrushNum < g_MainMap->entities[ i ].numbrushes; nBrushNum++ )
			{
				int nIndex = g_MainMap->entities[ i ].firstbrush + nBrushNum;

				bool bRemove = true;

				for( int nCordon = 0; nCordon < m_Cordons.Count(); nCordon++ )
				{
					if ( m_Cordons[ nCordon ].m_bActive == false )
					{
						continue;
					}

					for( int nBox = 0; nBox < m_Cordons[ nCordon ].m_Boxes.Count(); nBox++ )
					{
						if ( m_Cordons[ nCordon ].m_Boxes[ nBox ].IsIntersectingBox( g_MainMap->mapbrushes[ nIndex ].mins, g_MainMap->mapbrushes[ nIndex ].maxs ) == true )
						{
							bRemove = false;
							break;
						}
					}

					if ( bRemove == false )
					{
						break;
					}
				}

				if ( bRemove )
				{
					int nSize = ( g_MainMap->entities[ i ].numbrushes - nBrushNum - 1 ) * sizeof( g_MainMap->mapbrushes[ 0 ] );
					memmove( &g_MainMap->mapbrushes[ nIndex ], &g_MainMap->mapbrushes[ nIndex + 1 ], nSize );
					g_MainMap->entities[ i ].numbrushes--;
					nBrushNum--;
				}
			}
		}
		else if ( &g_MainMap->entities[ i ] != m_CordoningMapEnt )
		{	// for all other entities, even if they include brushes, we look at origin
			if ( g_MainMap->entities[ i ].numbrushes == 0 && g_MainMap->entities[ i ].epairs == NULL )
			{
				continue;
			}

			bool bRemove = true;

			for( int nCordon = 0; nCordon < m_Cordons.Count(); nCordon++ )
			{
				if ( m_Cordons[ nCordon ].m_bActive == false )
				{
					continue;
				}

				for( int nBox = 0; nBox < m_Cordons[ nCordon ].m_Boxes.Count(); nBox++ )
				{
					if ( m_Cordons[ nCordon ].m_Boxes[ nBox ].ContainsPoint( g_MainMap->entities[ i ].origin ) == true )
					{
						bRemove = false;
						break;
					}
				}

				if ( bRemove == false )
				{
					break;
				}
			}

			if ( bRemove )
			{
				g_MainMap->entities[ i ].numbrushes = 0;
				g_MainMap->entities[ i ].epairs = NULL;
			}
		}
	}

	if ( m_CordoningMapEnt )
	{
		g_MainMap->MoveBrushesToWorldGeneral( m_CordoningMapEnt );
		m_CordoningMapEnt->numbrushes = 0;
		m_CordoningMapEnt->epairs = NULL;
	}
}