First version of the SOurce SDK 2013

1 files changed, 3442 insertions, 0 deletions

diff --git a/mp/src/game/shared/saverestore.cpp b/mp/src/game/shared/saverestore.cpp
new file mode 100644
index 00000000..708da993
--- /dev/null
+++ b/mp/src/game/shared/saverestore.cpp
@@ -0,0 +1,3442 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//

+//

+// Purpose: Helper classes and functions for the save/restore system.

+//

+// $NoKeywords: $

+//=============================================================================//

+

+#include "cbase.h"

+#include <limits.h>

+#include "isaverestore.h"

+#include "saverestore.h"

+#include <stdarg.h>

+#include "shake.h"

+#include "decals.h"

+#include "gamerules.h"

+#include "bspfile.h"

+#include "mathlib/mathlib.h"

+#include "engine/IEngineSound.h"

+#include "saverestoretypes.h"

+#include "saverestore_utlvector.h"

+#include "model_types.h"

+#include "igamesystem.h"

+#include "interval.h"

+#include "vphysics/object_hash.h"

+#include "datacache/imdlcache.h"

+#include "tier0/vprof.h"

+

+#if !defined( CLIENT_DLL )

+

+#include "globalstate.h"

+#include "entitylist.h"

+

+#else

+

+#include "gamestringpool.h"

+

+#endif

+

+// HACKHACK: Builds a global list of entities that were restored from all levels

+#if !defined( CLIENT_DLL )

+void AddRestoredEntity( CBaseEntity *pEntity );

+#else

+void AddRestoredEntity( C_BaseEntity *pEntity );

+#endif

+

+

+// memdbgon must be the last include file in a .cpp file!!!

+#include "tier0/memdbgon.h"

+

+#define MAX_ENTITYARRAY 1024

+#define ZERO_TIME ((FLT_MAX*-0.5))

+// A bit arbitrary, but unlikely to collide with any saved games...

+#define TICK_NEVER_THINK_ENCODE	( INT_MAX - 3 )

+

+ASSERT_INVARIANT( sizeof(EHandlePlaceholder_t) == sizeof(EHANDLE) );

+

+//-----------------------------------------------------------------------------

+

+static int gSizes[FIELD_TYPECOUNT] = 

+{

+	FIELD_SIZE( FIELD_VOID ),

+	FIELD_SIZE( FIELD_FLOAT ),

+	FIELD_SIZE( FIELD_STRING ),

+	FIELD_SIZE( FIELD_VECTOR ),

+	FIELD_SIZE( FIELD_QUATERNION ),

+	FIELD_SIZE( FIELD_INTEGER ),

+	FIELD_SIZE( FIELD_BOOLEAN ),

+	FIELD_SIZE( FIELD_SHORT ),

+	FIELD_SIZE( FIELD_CHARACTER ),

+	FIELD_SIZE( FIELD_COLOR32 ),

+	FIELD_SIZE( FIELD_EMBEDDED ),

+	FIELD_SIZE( FIELD_CUSTOM ),

+	

+	FIELD_SIZE( FIELD_CLASSPTR ),

+	FIELD_SIZE( FIELD_EHANDLE ),

+	FIELD_SIZE( FIELD_EDICT ),

+

+	FIELD_SIZE( FIELD_POSITION_VECTOR ),

+	FIELD_SIZE( FIELD_TIME ),

+	FIELD_SIZE( FIELD_TICK ),

+	FIELD_SIZE( FIELD_MODELNAME ),

+	FIELD_SIZE( FIELD_SOUNDNAME ),

+

+	FIELD_SIZE( FIELD_INPUT ),

+	FIELD_SIZE( FIELD_FUNCTION ),

+	FIELD_SIZE( FIELD_VMATRIX ),

+	FIELD_SIZE( FIELD_VMATRIX_WORLDSPACE ),

+	FIELD_SIZE( FIELD_MATRIX3X4_WORLDSPACE ),

+	FIELD_SIZE( FIELD_INTERVAL ),

+	FIELD_SIZE( FIELD_MODELINDEX ),

+	FIELD_SIZE( FIELD_MATERIALINDEX ),

+

+	FIELD_SIZE( FIELD_VECTOR2D ),

+};

+

+

+// helpers to offset worldspace matrices

+static void VMatrixOffset( VMatrix &dest, const VMatrix &matrixIn, const Vector &offset )

+{

+	dest = matrixIn;

+	dest.PostTranslate( offset );

+}

+

+static void Matrix3x4Offset( matrix3x4_t& dest, const matrix3x4_t& matrixIn, const Vector &offset )

+{

+	MatrixCopy( matrixIn, dest );

+	Vector out;

+	MatrixGetColumn( matrixIn, 3, out );

+	out += offset;

+	MatrixSetColumn( out, 3, dest );

+}

+

+// This does the necessary casting / extract to grab a pointer to a member function as a void *

+// UNDONE: Cast to BASEPTR or something else here?

+#define EXTRACT_INPUTFUNC_FUNCTIONPTR(x)		(*(inputfunc_t **)(&(x)))

+

+//-----------------------------------------------------------------------------

+// Purpose: Search this datamap for the name of this member function

+//			This is used to save/restore function pointers (convert pointer to text)

+// Input  : *function - pointer to member function

+// Output : const char * - function name

+//-----------------------------------------------------------------------------

+const char *UTIL_FunctionToName( datamap_t *pMap, inputfunc_t *function )

+{

+	while ( pMap )

+	{

+		for ( int i = 0; i < pMap->dataNumFields; i++ )

+		{

+			if ( pMap->dataDesc[i].flags & FTYPEDESC_FUNCTIONTABLE )

+			{

+#ifdef WIN32

+				Assert( sizeof(pMap->dataDesc[i].inputFunc) == sizeof(void *) );

+#elif defined(POSIX)

+				Assert( sizeof(pMap->dataDesc[i].inputFunc) == 8 );

+#else

+#error

+#endif

+				inputfunc_t *pTest = EXTRACT_INPUTFUNC_FUNCTIONPTR(pMap->dataDesc[i].inputFunc);

+

+				if ( pTest == function )

+					return pMap->dataDesc[i].fieldName;

+			}

+		}

+		pMap = pMap->baseMap;

+	}

+

+	return NULL;

+}

+

+//-----------------------------------------------------------------------------

+// Purpose: Search the datamap for a function named pName

+//			This is used to save/restore function pointers (convert text back to pointer)

+// Input  : *pName - name of the member function

+//-----------------------------------------------------------------------------

+inputfunc_t *UTIL_FunctionFromName( datamap_t *pMap, const char *pName )

+{

+	while ( pMap )

+	{

+		for ( int i = 0; i < pMap->dataNumFields; i++ )

+		{

+#ifdef WIN32

+			Assert( sizeof(pMap->dataDesc[i].inputFunc) == sizeof(void *) );

+#elif defined(POSIX)

+			Assert( sizeof(pMap->dataDesc[i].inputFunc) == 8 );

+#else

+#error

+#endif

+

+			if ( pMap->dataDesc[i].flags & FTYPEDESC_FUNCTIONTABLE )

+			{

+				if ( FStrEq( pName, pMap->dataDesc[i].fieldName ) )

+				{

+					return EXTRACT_INPUTFUNC_FUNCTIONPTR(pMap->dataDesc[i].inputFunc);

+				}

+			}

+		}

+		pMap = pMap->baseMap;

+	}

+

+	Msg( "Failed to find function %s\n", pName );

+

+	return NULL;

+}

+

+//-----------------------------------------------------------------------------

+//

+// CSave

+//

+//-----------------------------------------------------------------------------

+

+CSave::CSave( CSaveRestoreData *pdata )

+ :	m_pData(pdata),

+	m_pGameInfo( pdata ),

+	m_bAsync( pdata->bAsync )

+{

+	m_BlockStartStack.EnsureCapacity( 32 );

+

+	// Logging.

+	m_hLogFile = NULL;

+}

+

+//-------------------------------------

+

+inline int CSave::DataEmpty( const char *pdata, int size )

+{

+	if ( size != 4 )

+	{

+		const char *pLimit = pdata + size;

+		while ( pdata < pLimit )

+		{

+			if ( *pdata++ )

+				return 0;

+		}

+		return 1;

+	}

+

+	return ( *((int *)pdata) == 0 );

+}

+

+//-----------------------------------------------------------------------------

+// Purpose: Start logging save data.

+//-----------------------------------------------------------------------------

+void CSave::StartLogging( const char *pszLogName )

+{

+	m_hLogFile = filesystem->Open( pszLogName, "w" );

+}

+

+//-----------------------------------------------------------------------------

+// Purpose: Stop logging save data.

+//-----------------------------------------------------------------------------

+void CSave::EndLogging( void )

+{

+	if ( m_hLogFile )

+	{

+		filesystem->Close( m_hLogFile );

+	}

+	m_hLogFile = NULL;

+}

+

+//-----------------------------------------------------------------------------

+// Purpose: Check to see if we are logging data.

+//-----------------------------------------------------------------------------

+bool CSave::IsLogging( void )

+{

+	return ( m_hLogFile != NULL );

+}

+

+//-----------------------------------------------------------------------------

+// Purpose: Log data.

+//-----------------------------------------------------------------------------

+void CSave::Log( const char *pName, fieldtype_t fieldType, void *value, int count )

+{

+	// Check to see if we are logging.

+	if ( !IsLogging() )

+		return;

+

+	static char szBuf[1024];

+	static char szTempBuf[256];

+

+	// Save the name.

+	Q_snprintf( szBuf, sizeof( szBuf ), "%s ", pName );

+

+	for ( int iCount = 0; iCount < count; ++iCount )

+	{

+		switch ( fieldType )

+		{

+		case FIELD_SHORT:

+			{

+				short *pValue = ( short* )( value );

+				short nValue = pValue[iCount];

+				Q_snprintf( szTempBuf, sizeof( szTempBuf ), "%d", nValue );

+				Q_strncat( szBuf, szTempBuf, sizeof( szTempBuf ), COPY_ALL_CHARACTERS );

+				break;

+			}

+		case FIELD_FLOAT:

+			{

+				float *pValue = ( float* )( value );

+				float flValue = pValue[iCount];

+				Q_snprintf( szTempBuf, sizeof( szTempBuf ), "%f", flValue );

+				Q_strncat( szBuf, szTempBuf, sizeof( szTempBuf ), COPY_ALL_CHARACTERS );

+				break;

+			}

+		case FIELD_BOOLEAN:

+			{

+				bool *pValue = ( bool* )( value );

+				bool bValue = pValue[iCount];

+				Q_snprintf( szTempBuf, sizeof( szTempBuf ), "%d", ( int )( bValue ) );

+				Q_strncat( szBuf, szTempBuf, sizeof( szTempBuf ), COPY_ALL_CHARACTERS );

+				break;

+			}

+		case FIELD_INTEGER:

+			{

+				int *pValue = ( int* )( value );

+				int nValue = pValue[iCount];

+				Q_snprintf( szTempBuf, sizeof( szTempBuf ), "%d", nValue );

+				Q_strncat( szBuf, szTempBuf, sizeof( szTempBuf ), COPY_ALL_CHARACTERS );

+				break;

+			}

+		case FIELD_STRING:

+			{

+				string_t *pValue = ( string_t* )( value );

+				Q_snprintf( szTempBuf, sizeof( szTempBuf ), "%s", ( char* )STRING( *pValue ) );

+				Q_strncat( szBuf, szTempBuf, sizeof( szTempBuf ), COPY_ALL_CHARACTERS );

+				break;					

+			}

+		case FIELD_VECTOR:

+			{

+				Vector *pValue = ( Vector* )( value );

+				Vector vecValue = pValue[iCount];

+				Q_snprintf( szTempBuf, sizeof( szTempBuf ), "(%f %f %f)", vecValue.x, vecValue.y, vecValue.z );

+				Q_strncat( szBuf, szTempBuf, sizeof( szTempBuf ), COPY_ALL_CHARACTERS );

+				break;

+			}

+		case FIELD_QUATERNION:

+			{

+				Quaternion *pValue = ( Quaternion* )( value );

+				Quaternion q = pValue[iCount];

+				Q_snprintf( szTempBuf, sizeof( szTempBuf ), "(%f %f %f %f)", q[0], q[1], q[2], q[3] );

+				Q_strncat( szBuf, szTempBuf, sizeof( szTempBuf ), COPY_ALL_CHARACTERS );

+				break;

+			}

+		case FIELD_CHARACTER:

+			{

+				char *pValue = ( char* )( value );

+				char chValue = pValue[iCount];

+				Q_snprintf( szTempBuf, sizeof( szTempBuf ), "%c", chValue );

+				Q_strncat( szBuf, szTempBuf, sizeof( szTempBuf ), COPY_ALL_CHARACTERS );

+			}

+		case FIELD_COLOR32:

+			{

+				byte *pValue = ( byte* )( value );

+				byte *pColor = &pValue[iCount*4];

+				Q_snprintf( szTempBuf, sizeof( szTempBuf ), "(%d %d %d %d)", ( int )pColor[0], ( int )pColor[1], ( int )pColor[2], ( int )pColor[3] );

+				Q_strncat( szBuf, szTempBuf, sizeof( szTempBuf ), COPY_ALL_CHARACTERS );

+			}

+		case FIELD_EMBEDDED:

+		case FIELD_CUSTOM:

+		default:

+			{

+				break;

+			}

+		}

+

+		// Add space data.

+		if ( ( iCount + 1 ) != count )

+		{

+			Q_strncpy( szTempBuf, " ", sizeof( szTempBuf ) );

+			Q_strncat( szBuf, szTempBuf, sizeof( szTempBuf ), COPY_ALL_CHARACTERS );

+		}

+		else

+		{

+			Q_strncpy( szTempBuf, "\n", sizeof( szTempBuf ) );

+			Q_strncat( szBuf, szTempBuf, sizeof( szTempBuf ), COPY_ALL_CHARACTERS );

+		}

+	}

+

+	int nLength = strlen( szBuf ) + 1;

+	filesystem->Write( szBuf, nLength, m_hLogFile );

+}

+

+//-------------------------------------

+

+bool CSave::IsAsync()

+{

+	return m_bAsync;

+}

+

+//-------------------------------------

+

+int CSave::GetWritePos() const

+{ 

+	return m_pData->GetCurPos(); 

+}

+

+//-------------------------------------

+

+void CSave::SetWritePos(int pos)

+{

+	m_pData->Seek(pos); 

+}

+

+//-------------------------------------

+

+void CSave::WriteShort( const short *value, int count )

+{

+	BufferData( (const char *)value, sizeof(short) * count );

+}

+

+//-------------------------------------

+

+void CSave::WriteInt( const int *value, int count )

+{

+	BufferData( (const char *)value, sizeof(int) * count );

+}

+

+//-------------------------------------

+

+void CSave::WriteBool( const bool *value, int count )

+{

+	COMPILE_TIME_ASSERT( sizeof(bool) == sizeof(char) );

+	BufferData( (const char *)value, sizeof(bool) * count );

+}

+

+//-------------------------------------

+

+void CSave::WriteFloat( const float *value, int count )

+{

+	BufferData( (const char *)value, sizeof(float) * count );

+}

+

+//-------------------------------------

+

+void CSave::WriteData( const char *pdata , int size )

+{

+	BufferData( pdata, size );

+}

+

+//-------------------------------------

+

+void CSave::WriteString( const char *pstring )

+{

+	BufferData( pstring, strlen(pstring) + 1 );

+}

+

+//-------------------------------------

+

+void CSave::WriteString( const string_t *stringId, int count )

+{

+	for ( int i = 0; i < count; i++ )

+	{

+		const char *pString = STRING(stringId[i]);

+		BufferData( pString, strlen(pString)+1 );

+	}

+}

+

+//-------------------------------------

+

+void CSave::WriteVector( const Vector &value )

+{

+	BufferData( (const char *)&value, sizeof(Vector) );

+}

+

+//-------------------------------------

+

+void CSave::WriteVector( const Vector *value, int count )

+{

+	BufferData( (const char *)value, sizeof(Vector) * count );

+}

+

+void CSave::WriteQuaternion( const Quaternion &value )

+{

+	BufferData( (const char *)&value, sizeof(Quaternion) );

+}

+

+//-------------------------------------

+

+void CSave::WriteQuaternion( const Quaternion *value, int count )

+{

+	BufferData( (const char *)value, sizeof(Quaternion) * count );

+}

+

+

+//-------------------------------------

+

+void CSave::WriteData( const char *pname, int size, const char *pdata )

+{

+	BufferField( pname, size, pdata );

+}

+

+//-------------------------------------

+

+void CSave::WriteShort( const char *pname, const short *data, int count )

+{

+	BufferField( pname, sizeof(short) * count, (const char *)data );

+}

+

+//-------------------------------------

+

+void CSave::WriteInt( const char *pname, const int *data, int count )

+{

+	BufferField( pname, sizeof(int) * count, (const char *)data );

+}

+

+//-------------------------------------

+

+void CSave::WriteBool( const char *pname, const bool *data, int count )

+{

+	COMPILE_TIME_ASSERT( sizeof(bool) == sizeof(char) );

+	BufferField( pname, sizeof(bool) * count, (const char *)data );

+}

+

+//-------------------------------------

+

+void CSave::WriteFloat( const char *pname, const float *data, int count )

+{

+	BufferField( pname, sizeof(float) * count, (const char *)data );

+}

+

+//-------------------------------------

+

+void CSave::WriteString( const char *pname, const char *pdata )

+{

+	BufferField( pname, strlen(pdata) + 1, pdata );

+}

+

+//-------------------------------------

+

+void CSave::WriteString( const char *pname, const string_t *stringId, int count )

+{

+	int i, size;

+

+	size = 0;

+	for ( i = 0; i < count; i++ )

+		size += strlen( STRING( stringId[i] ) ) + 1;

+

+	WriteHeader( pname, size );

+	WriteString( stringId, count );

+}

+

+//-------------------------------------

+

+void CSave::WriteVector( const char *pname, const Vector &value )

+{

+	WriteVector( pname, &value, 1 );

+}

+

+//-------------------------------------

+

+void CSave::WriteVector( const char *pname, const Vector *value, int count )

+{

+	WriteHeader( pname, sizeof(Vector) * count );

+	BufferData( (const char *)value, sizeof(Vector) * count );

+}

+

+void CSave::WriteQuaternion( const char *pname, const Quaternion &value )

+{

+	WriteQuaternion( pname, &value, 1 );

+}

+

+//-------------------------------------

+

+void CSave::WriteQuaternion( const char *pname, const Quaternion *value, int count )

+{

+	WriteHeader( pname, sizeof(Quaternion) * count );

+	BufferData( (const char *)value, sizeof(Quaternion) * count );

+}

+

+

+//-------------------------------------

+

+void CSave::WriteVMatrix( const VMatrix *value, int count )

+{

+	BufferData( (const char *)value, sizeof(VMatrix) * count );

+}

+

+//-------------------------------------

+

+void CSave::WriteVMatrix( const char *pname, const VMatrix *value, int count )

+{

+	WriteHeader( pname, sizeof(VMatrix) * count );

+	BufferData( (const char *)value, sizeof(VMatrix) * count );

+}

+

+//-------------------------------------

+

+void CSave::WriteVMatrixWorldspace( const VMatrix *value, int count )

+{

+	for ( int i = 0; i < count; i++ )

+	{

+		VMatrix tmp;

+		VMatrixOffset( tmp, value[i], -m_pGameInfo->GetLandmark() );

+		BufferData( (const char *)&tmp, sizeof(VMatrix) );

+	}

+}

+

+//-------------------------------------

+

+void CSave::WriteVMatrixWorldspace( const char *pname, const VMatrix *value, int count )

+{

+	WriteHeader( pname, sizeof(VMatrix) * count );

+	WriteVMatrixWorldspace( value, count );

+}

+

+void CSave::WriteMatrix3x4Worldspace( const matrix3x4_t *value, int count )

+{

+	Vector offset = -m_pGameInfo->GetLandmark();

+	for ( int i = 0; i < count; i++ )

+	{

+		matrix3x4_t tmp;

+		Matrix3x4Offset( tmp, value[i], offset );

+		BufferData( (const char *)value, sizeof(matrix3x4_t) );

+	}

+}

+

+//-------------------------------------

+

+void CSave::WriteMatrix3x4Worldspace( const char *pname, const matrix3x4_t *value, int count )

+{

+	WriteHeader( pname, sizeof(matrix3x4_t) * count );

+	WriteMatrix3x4Worldspace( value, count );

+}

+

+void CSave::WriteInterval( const char *pname, const interval_t *value, int count )

+{

+	WriteHeader( pname, sizeof( interval_t ) * count );

+	WriteInterval( value, count );

+}

+

+void CSave::WriteInterval( const interval_t *value, int count )

+{

+	BufferData( (const char *)value, count * sizeof( interval_t ) );

+}

+

+//-------------------------------------

+

+bool CSave::ShouldSaveField( const void *pData, typedescription_t *pField )

+{

+	if ( !(pField->flags & FTYPEDESC_SAVE) || pField->fieldType == FIELD_VOID )

+		return false;

+

+	switch ( pField->fieldType )

+	{

+	case FIELD_EMBEDDED:

+		{

+			if ( pField->flags & FTYPEDESC_PTR )

+			{

+				AssertMsg( pField->fieldSize == 1, "Arrays of embedded pointer types presently unsupported by save/restore" );

+				if ( pField->fieldSize != 1 )

+					return false;

+			}

+

+			AssertMsg( pField->td != NULL, "Embedded type appears to have not had type description implemented" );

+			if ( pField->td == NULL )

+				return false;

+

+			if ( (pField->flags & FTYPEDESC_PTR) && !*((void **)pData) )

+				return false;

+

+			// @TODO: need real logic for handling embedded types with base classes

+			if ( pField->td->baseMap )

+			{

+				return true;

+			}

+

+			int nFieldCount = pField->fieldSize;

+			char *pTestData = (char *)( ( !(pField->flags & FTYPEDESC_PTR) ) ? pData : *((void **)pData) );

+			while ( --nFieldCount >= 0 )

+			{

+				typedescription_t *pTestField = pField->td->dataDesc;

+				typedescription_t *pLimit	  = pField->td->dataDesc + pField->td->dataNumFields;

+			

+				for ( ; pTestField < pLimit; ++pTestField )

+				{

+					if ( ShouldSaveField( pTestData + pTestField->fieldOffset[ TD_OFFSET_NORMAL ], pTestField ) )

+						return true;

+				}

+

+				pTestData += pField->fieldSizeInBytes;

+			}

+			return false;

+		}

+

+	case FIELD_CUSTOM:

+		{

+			// ask the data if it's empty

+			SaveRestoreFieldInfo_t fieldInfo =

+			{

+				const_cast<void *>(pData),

+				((char *)pData) - pField->fieldOffset[ TD_OFFSET_NORMAL ],

+				pField

+			};

+			if ( pField->pSaveRestoreOps->IsEmpty( fieldInfo ) )

+				return false;

+		}

+		return true;

+

+	case FIELD_EHANDLE:

+		{

+			if ( (pField->fieldSizeInBytes != pField->fieldSize * gSizes[pField->fieldType]) )

+			{

+				Warning("WARNING! Field %s is using the wrong FIELD_ type!\nFix this or you'll see a crash.\n", pField->fieldName );

+				Assert( 0 );

+			}

+

+			int *pEHandle = (int *)pData;

+			for ( int i = 0; i < pField->fieldSize; ++i, ++pEHandle )

+			{

+				if ( (*pEHandle) != 0xFFFFFFFF )

+					return true;

+			}

+		}

+		return false;

+

+	default:

+		{

+			if ( (pField->fieldSizeInBytes != pField->fieldSize * gSizes[pField->fieldType]) )

+			{

+				Warning("WARNING! Field %s is using the wrong FIELD_ type!\nFix this or you'll see a crash.\n", pField->fieldName );

+				Assert( 0 );

+			}

+

+			// old byte-by-byte null check

+			if ( DataEmpty( (const char *)pData, pField->fieldSize * gSizes[pField->fieldType] ) )

+				return false;

+		}

+		return true;

+	}

+}

+

+//-------------------------------------

+// Purpose:	Writes all the fields that are client neutral. In the event of 

+//			a librarization of save/restore, these would reside in the library

+//

+

+bool CSave::WriteBasicField( const char *pname, void *pData, datamap_t *pRootMap, typedescription_t *pField )

+{

+	switch( pField->fieldType )

+	{

+		case FIELD_FLOAT:

+			WriteFloat( pField->fieldName, (float *)pData, pField->fieldSize );

+			break;

+			

+		case FIELD_STRING:

+			WriteString( pField->fieldName, (string_t *)pData, pField->fieldSize );

+			break;

+			

+		case FIELD_VECTOR:

+			WriteVector( pField->fieldName, (Vector *)pData, pField->fieldSize );

+			break;

+

+		case FIELD_QUATERNION:

+			WriteQuaternion( pField->fieldName, (Quaternion *)pData, pField->fieldSize );

+			break;

+

+		case FIELD_INTEGER:

+			WriteInt( pField->fieldName, (int *)pData, pField->fieldSize );

+			break;

+

+		case FIELD_BOOLEAN:

+			WriteBool( pField->fieldName, (bool *)pData, pField->fieldSize );

+			break;

+

+		case FIELD_SHORT:

+			WriteData( pField->fieldName, 2 * pField->fieldSize, ((char *)pData) );

+			break;

+

+		case FIELD_CHARACTER:

+			WriteData( pField->fieldName, pField->fieldSize, ((char *)pData) );

+			break;

+

+		case FIELD_COLOR32:

+			WriteData( pField->fieldName, 4*pField->fieldSize, (char *)pData );	

+			break;

+

+		case FIELD_EMBEDDED:

+		{

+			AssertMsg( ( (pField->flags & FTYPEDESC_PTR) == 0 ) || (pField->fieldSize == 1), "Arrays of embedded pointer types presently unsupported by save/restore" );

+			Assert( !(pField->flags & FTYPEDESC_PTR) || *((void **)pData) );

+			int nFieldCount = pField->fieldSize;

+			char *pFieldData = (char *)( ( !(pField->flags & FTYPEDESC_PTR) ) ? pData : *((void **)pData) );

+

+			StartBlock( pField->fieldName );

+

+			while ( --nFieldCount >= 0 )

+			{

+				WriteAll( pFieldData, pField->td );

+				pFieldData += pField->fieldSizeInBytes;

+			}

+

+			EndBlock();

+			break;

+		}

+

+		case FIELD_CUSTOM:

+		{

+			// Note it is up to the custom type implementor to handle arrays

+			StartBlock( pField->fieldName );

+

+			SaveRestoreFieldInfo_t fieldInfo =

+			{

+				pData,

+				((char *)pData) - pField->fieldOffset[ TD_OFFSET_NORMAL ],

+				pField

+			};

+			pField->pSaveRestoreOps->Save( fieldInfo, this );

+			

+			EndBlock();

+			break;

+		}

+

+		default:

+			Warning( "Bad field type\n" );

+			Assert(0);

+			return false;

+	}

+

+	return true;

+}

+

+//-------------------------------------

+

+bool CSave::WriteField( const char *pname, void *pData, datamap_t *pRootMap, typedescription_t *pField )

+{

+#ifdef _DEBUG

+	Log( pname, (fieldtype_t)pField->fieldType, pData, pField->fieldSize );

+#endif

+

+	if ( pField->fieldType <= FIELD_CUSTOM )

+	{

+		return WriteBasicField( pname, pData, pRootMap, pField );

+	}

+	return WriteGameField( pname, pData, pRootMap, pField );

+}

+

+//-------------------------------------

+

+int CSave::WriteFields( const char *pname, const void *pBaseData, datamap_t *pRootMap, typedescription_t *pFields, int fieldCount )

+{

+	typedescription_t *pTest;

+	int iHeaderPos = m_pData->GetCurPos();

+	int count = -1;

+	WriteInt( pname, &count, 1 );

+

+	count = 0;

+

+#ifdef _X360

+	__dcbt( 0, pBaseData );

+	__dcbt( 128, pBaseData );

+	__dcbt( 256, pBaseData );

+	__dcbt( 512, pBaseData );

+	void *pDest = m_pData->AccessCurPos();	

+	__dcbt( 0, pDest );

+	__dcbt( 128, pDest );

+	__dcbt( 256, pDest );

+	__dcbt( 512, pDest );

+#endif

+

+	for ( int i = 0; i < fieldCount; i++ )

+	{

+		pTest = &pFields[ i ];

+		void *pOutputData = ( (char *)pBaseData + pTest->fieldOffset[ TD_OFFSET_NORMAL ] );

+			

+		if ( !ShouldSaveField( pOutputData, pTest ) )

+			continue;

+

+		if ( !WriteField( pname, pOutputData, pRootMap, pTest ) )

+			break;

+		count++;

+	}

+

+	int iCurPos = m_pData->GetCurPos();

+	int iRewind = iCurPos - iHeaderPos;

+	m_pData->Rewind( iRewind );

+	WriteInt( pname, &count, 1 );

+	iCurPos = m_pData->GetCurPos();

+	m_pData->MoveCurPos( iRewind - ( iCurPos - iHeaderPos ) );

+

+	return 1;

+}

+

+//-------------------------------------

+// Purpose: Recursively saves all the classes in an object, in reverse order (top down)

+// Output : int 0 on failure, 1 on success

+

+int CSave::DoWriteAll( const void *pLeafObject, datamap_t *pLeafMap, datamap_t *pCurMap )

+{

+	// save base classes first

+	if ( pCurMap->baseMap )

+	{

+		int status = DoWriteAll( pLeafObject, pLeafMap, pCurMap->baseMap );

+		if ( !status )

+			return status;

+	}

+

+	return WriteFields( pCurMap->dataClassName, pLeafObject, pLeafMap, pCurMap->dataDesc, pCurMap->dataNumFields );

+}

+	

+//-------------------------------------

+

+void CSave::StartBlock( const char *pszBlockName )

+{

+	WriteHeader( pszBlockName, 0 ); // placeholder

+	m_BlockStartStack.AddToTail( GetWritePos() );

+}

+

+//-------------------------------------

+

+void CSave::StartBlock()

+{

+	StartBlock( "" );

+}

+

+//-------------------------------------

+

+void CSave::EndBlock()

+{

+	int endPos = GetWritePos();

+	int startPos = m_BlockStartStack[ m_BlockStartStack.Count() - 1 ];

+	short sizeBlock = endPos - startPos;

+	

+	m_BlockStartStack.Remove( m_BlockStartStack.Count() - 1 );

+	

+	// Move to the the location where the size of the block was written & rewrite the size

+	SetWritePos( startPos - sizeof(SaveRestoreRecordHeader_t) );

+	BufferData( (const char *)&sizeBlock, sizeof(short) );

+	

+	SetWritePos( endPos );

+}

+	

+//-------------------------------------

+

+void CSave::BufferString( char *pdata, int len )

+{

+	char c = 0;

+

+	BufferData( pdata, len );		// Write the string

+	BufferData( &c, 1 );			// Write a null terminator

+}

+

+//-------------------------------------

+

+void CSave::BufferField( const char *pname, int size, const char *pdata )

+{

+	WriteHeader( pname, size );

+	BufferData( pdata, size );

+}

+

+//-------------------------------------

+

+void CSave::WriteHeader( const char *pname, int size )

+{

+	short shortSize = size;

+	short hashvalue = m_pData->FindCreateSymbol( pname );

+	if ( size > SHRT_MAX || size < 0 )

+	{

+		Warning( "CSave::WriteHeader() size parameter exceeds 'short'!\n" );

+		Assert(0);

+	}

+

+	BufferData( (const char *)&shortSize, sizeof(short) );

+	BufferData( (const char *)&hashvalue, sizeof(short) );

+}

+

+//-------------------------------------

+

+void CSave::BufferData( const char *pdata, int size )

+{

+	if ( !m_pData )

+		return;

+

+	if ( !m_pData->Write( pdata, size ) )

+	{

+		Warning( "Save/Restore overflow!\n" );

+		Assert(0);

+	}

+}

+

+//---------------------------------------------------------

+//

+// Game centric save methods.

+//

+int	CSave::EntityIndex( const edict_t *pentLookup )

+{

+#if !defined( CLIENT_DLL )

+	if ( pentLookup == NULL )

+		return -1;

+	return EntityIndex( CBaseEntity::Instance(pentLookup) );

+#else

+	Assert( !"CSave::EntityIndex( edict_t * ) not valid on client!" );

+	return -1;

+#endif

+}

+

+

+//-------------------------------------

+

+int	CSave::EntityIndex( const CBaseEntity *pEntity )

+{

+	return m_pGameInfo->GetEntityIndex( pEntity );

+}

+

+//-------------------------------------

+

+int	CSave::EntityFlagsSet( int entityIndex, int flags )

+{

+	if ( !m_pGameInfo || entityIndex < 0 )

+		return 0;

+	if ( entityIndex > m_pGameInfo->NumEntities() )

+		return 0;

+

+	m_pGameInfo->GetEntityInfo( entityIndex )->flags |= flags;

+

+	return m_pGameInfo->GetEntityInfo( entityIndex )->flags;

+}

+

+//-------------------------------------

+

+void CSave::WriteTime( const char *pname, const float *data, int count )

+{

+	int i;

+	float tmp;

+

+	WriteHeader( pname, sizeof(float) * count );

+	for ( i = 0; i < count; i++ )

+	{

+		// Always encode time as a delta from the current time so it can be re-based if loaded in a new level

+		// Times of 0 are never written to the file, so they will be restored as 0, not a relative time

+		Assert( data[i] != ZERO_TIME );

+

+		if ( data[i] == 0.0 )

+		{

+			tmp = ZERO_TIME;

+		}

+		else if ( data[i] == INVALID_TIME || data[i] == FLT_MAX )

+		{

+			tmp = data[i];

+		}

+		else

+		{			

+			tmp = data[i] - m_pGameInfo->GetBaseTime();

+			if ( fabsf( tmp ) < 0.001 ) // never allow a time to become zero due to rebasing

+				tmp = 0.001;

+		}

+

+		WriteData( (const char *)&tmp, sizeof(float) );

+	}

+}

+

+//-------------------------------------

+

+void CSave::WriteTime( const float *data, int count )

+{

+	int i;

+	float tmp;

+

+	for ( i = 0; i < count; i++ )

+	{

+		// Always encode time as a delta from the current time so it can be re-based if loaded in a new level

+		// Times of 0 are never written to the file, so they will be restored as 0, not a relative time

+		if ( data[i] == 0.0 )

+		{

+			tmp = ZERO_TIME;

+		}

+		else if ( data[i] == INVALID_TIME || data[i] == FLT_MAX )

+		{

+			tmp = data[i];

+		}

+		else

+		{			

+			tmp = data[i] - m_pGameInfo->GetBaseTime();

+			if ( fabsf( tmp ) < 0.001 ) // never allow a time to become zero due to rebasing

+				tmp = 0.001;

+		}

+

+		WriteData( (const char *)&tmp, sizeof(float) );

+	}

+}

+

+void CSave::WriteTick( const char *pname, const int *data, int count )

+{

+	WriteHeader( pname, sizeof(int) * count );

+	WriteTick( data, count );

+}

+

+//-------------------------------------

+

+void CSave::WriteTick( const int *data, int count )

+{

+	int i;

+	int tmp;

+

+	int baseTick = TIME_TO_TICKS( m_pGameInfo->GetBaseTime() );

+

+	for ( i = 0; i < count; i++ )

+	{

+		// Always encode time as a delta from the current time so it can be re-based if loaded in a new level

+		// Times of 0 are never written to the file, so they will be restored as 0, not a relative time

+		tmp = data[ i ];

+		if ( data[ i ] == TICK_NEVER_THINK )

+		{

+			tmp = TICK_NEVER_THINK_ENCODE;

+		}

+		else

+		{

+			// Rebase it...

+			tmp -= baseTick;

+		}

+		WriteData( (const char *)&tmp, sizeof(int) );

+	}

+}

+//-------------------------------------

+

+void CSave::WritePositionVector( const char *pname, const Vector &value )

+{

+	Vector tmp = value;

+

+	if ( tmp != vec3_invalid )

+		tmp -= m_pGameInfo->GetLandmark();

+

+	WriteVector( pname, tmp );

+}

+

+//-------------------------------------

+

+void CSave::WritePositionVector( const Vector &value )

+{

+	Vector tmp = value;

+

+	if ( tmp != vec3_invalid )

+		tmp -= m_pGameInfo->GetLandmark();

+

+	WriteVector( tmp );

+}

+

+//-------------------------------------

+

+void CSave::WritePositionVector( const char *pname, const Vector *value, int count )

+{

+	WriteHeader( pname, sizeof(Vector) * count );

+	WritePositionVector( value, count );

+}

+

+//-------------------------------------

+

+void CSave::WritePositionVector( const Vector *value, int count )

+{

+	int i;

+	Vector tmp;

+	for ( i = 0; i < count; i++ )

+	{

+		Vector tmp = value[i];

+

+		if ( tmp != vec3_invalid )

+			tmp -= m_pGameInfo->GetLandmark();

+

+		WriteData( (const char *)&tmp.x, sizeof(Vector) );

+	}

+}

+

+//-------------------------------------

+

+void CSave::WriteFunction( datamap_t *pRootMap, const char *pname, inputfunc_t **data, int count )

+{

+	AssertMsg( count == 1, "Arrays of functions not presently supported" );

+	const char *functionName = UTIL_FunctionToName( pRootMap, *data );

+	if ( !functionName )

+	{

+		Warning( "Invalid function pointer in entity!\n" );

+		Assert(0);

+		functionName = "BADFUNCTIONPOINTER";

+	}

+

+	BufferField( pname, strlen(functionName) + 1, functionName );

+}

+

+//-------------------------------------

+

+void CSave::WriteEntityPtr( const char *pname, CBaseEntity **ppEntity, int count )

+{

+	AssertMsg( count <= MAX_ENTITYARRAY, "Array of entities or ehandles exceeds limit supported by save/restore" );

+	int entityArray[MAX_ENTITYARRAY];

+	for ( int i = 0; i < count && i < MAX_ENTITYARRAY; i++ )

+	{

+		entityArray[i] = EntityIndex( ppEntity[i] );

+	}

+	WriteInt( pname, entityArray, count );

+}

+

+//-------------------------------------

+

+void CSave::WriteEntityPtr( CBaseEntity **ppEntity, int count )

+{

+	AssertMsg( count <= MAX_ENTITYARRAY, "Array of entities or ehandles exceeds limit supported by save/restore" );

+	int entityArray[MAX_ENTITYARRAY];

+	for ( int i = 0; i < count && i < MAX_ENTITYARRAY; i++ )

+	{

+		entityArray[i] = EntityIndex( ppEntity[i] );

+	}

+	WriteInt( entityArray, count );

+}

+

+//-------------------------------------

+

+void CSave::WriteEdictPtr( const char *pname, edict_t **ppEdict, int count )

+{

+	AssertMsg( count <= MAX_ENTITYARRAY, "Array of entities or ehandles exceeds limit supported by save/restore" );

+	int entityArray[MAX_ENTITYARRAY];

+	for ( int i = 0; i < count && i < MAX_ENTITYARRAY; i++ )

+	{

+		entityArray[i] = EntityIndex( ppEdict[i] );

+	}

+	WriteInt( pname, entityArray, count );

+}

+

+//-------------------------------------

+

+void CSave::WriteEdictPtr( edict_t **ppEdict, int count )

+{

+	AssertMsg( count <= MAX_ENTITYARRAY, "Array of entities or ehandles exceeds limit supported by save/restore" );

+	int entityArray[MAX_ENTITYARRAY];

+	for ( int i = 0; i < count && i < MAX_ENTITYARRAY; i++ )

+	{

+		entityArray[i] = EntityIndex( ppEdict[i] );

+	}

+	WriteInt( entityArray, count );

+}

+

+//-------------------------------------

+

+void CSave::WriteEHandle( const char *pname, const EHANDLE *pEHandle, int count )

+{

+	AssertMsg( count <= MAX_ENTITYARRAY, "Array of entities or ehandles exceeds limit supported by save/restore" );

+	int entityArray[MAX_ENTITYARRAY];

+	for ( int i = 0; i < count && i < MAX_ENTITYARRAY; i++ )

+	{

+		entityArray[i] = EntityIndex( (CBaseEntity *)(const_cast<EHANDLE *>(pEHandle)[i]) );

+	}

+	WriteInt( pname, entityArray, count );

+}

+

+//-------------------------------------

+

+void CSave::WriteEHandle( const EHANDLE *pEHandle, int count )

+{

+	AssertMsg( count <= MAX_ENTITYARRAY, "Array of entities or ehandles exceeds limit supported by save/restore" );

+	int entityArray[MAX_ENTITYARRAY];

+	for ( int i = 0; i < count && i < MAX_ENTITYARRAY; i++ )

+	{

+		entityArray[i] = EntityIndex( (CBaseEntity *)(const_cast<EHANDLE *>(pEHandle)[i]) );

+	}

+	WriteInt( entityArray, count );

+}

+

+//-------------------------------------

+// Purpose:	Writes all the fields that are not client neutral. In the event of 

+//			a librarization of save/restore, these would not reside in the library

+

+bool CSave::WriteGameField( const char *pname, void *pData, datamap_t *pRootMap, typedescription_t *pField )

+{

+	switch( pField->fieldType )

+	{

+		case FIELD_CLASSPTR:

+			WriteEntityPtr( pField->fieldName, (CBaseEntity **)pData, pField->fieldSize );

+			break;

+	

+		case FIELD_EDICT:

+			WriteEdictPtr( pField->fieldName, (edict_t **)pData, pField->fieldSize );

+			break;

+	

+		case FIELD_EHANDLE:

+			WriteEHandle( pField->fieldName, (EHANDLE *)pData, pField->fieldSize );

+			break;

+		

+		case FIELD_POSITION_VECTOR:

+			WritePositionVector( pField->fieldName, (Vector *)pData, pField->fieldSize );

+			break;

+			

+		case FIELD_TIME:

+			WriteTime( pField->fieldName, (float *)pData, pField->fieldSize );

+			break;

+

+		case FIELD_TICK:

+			WriteTick( pField->fieldName, (int *)pData, pField->fieldSize );

+			break;

+			

+		case FIELD_MODELINDEX:

+			{

+				int nModelIndex = *(int*)pData;

+				string_t strModelName = NULL_STRING;

+				const model_t *pModel = modelinfo->GetModel( nModelIndex );

+				if ( pModel )

+				{

+					strModelName = AllocPooledString( modelinfo->GetModelName( pModel ) );

+				}

+				WriteString( pField->fieldName, (string_t *)&strModelName, pField->fieldSize );

+			}

+			break;

+

+		case FIELD_MATERIALINDEX:

+			{

+				int nMateralIndex = *(int*)pData;

+				string_t strMaterialName = NULL_STRING;

+				const char *pMaterialName = GetMaterialNameFromIndex( nMateralIndex );

+				if ( pMaterialName )

+				{

+					strMaterialName = MAKE_STRING( pMaterialName );

+				}

+				WriteString( pField->fieldName, (string_t *)&strMaterialName, pField->fieldSize );

+			}

+			break;

+

+		case FIELD_MODELNAME:

+		case FIELD_SOUNDNAME:

+			WriteString( pField->fieldName, (string_t *)pData, pField->fieldSize );

+			break;

+

+		// For now, just write the address out, we're not going to change memory while doing this yet!

+		case FIELD_FUNCTION:

+			WriteFunction( pRootMap, pField->fieldName, (inputfunc_t **)(char *)pData, pField->fieldSize );

+			break;

+			

+		case FIELD_VMATRIX:

+			WriteVMatrix( pField->fieldName, (VMatrix *)pData, pField->fieldSize );

+			break;

+		case FIELD_VMATRIX_WORLDSPACE:

+			WriteVMatrixWorldspace( pField->fieldName, (VMatrix *)pData, pField->fieldSize );

+			break;

+

+		case FIELD_MATRIX3X4_WORLDSPACE:

+			WriteMatrix3x4Worldspace( pField->fieldName, (const matrix3x4_t *)pData, pField->fieldSize );

+			break;

+

+		case FIELD_INTERVAL:

+			WriteInterval( pField->fieldName, (interval_t *)pData, pField->fieldSize );

+			break;

+

+		default:

+			Warning( "Bad field type\n" );

+			Assert(0);

+			return false;

+	}

+

+	return true;

+}

+

+//-----------------------------------------------------------------------------

+//

+// CRestore

+//

+//-----------------------------------------------------------------------------

+

+CRestore::CRestore( CSaveRestoreData *pdata )

+ :	m_pData( pdata ),

+	m_pGameInfo( pdata ),

+	m_global( 0 ),

+	m_precache( true )

+{

+	m_BlockEndStack.EnsureCapacity( 32 );

+}

+

+//-------------------------------------

+

+int CRestore::GetReadPos() const

+{ 

+	return m_pData->GetCurPos(); 

+}

+

+//-------------------------------------

+

+void CRestore::SetReadPos( int pos ) 

+{ 

+	m_pData->Seek(pos); 

+}

+

+//-------------------------------------

+

+const char *CRestore::StringFromHeaderSymbol( int symbol )

+{

+	const char *pszResult = m_pData->StringFromSymbol( symbol );

+	return ( pszResult ) ? pszResult : "";

+}

+

+//-------------------------------------

+// Purpose:	Reads all the fields that are client neutral. In the event of 

+//			a librarization of save/restore, these would reside in the library

+

+void CRestore::ReadBasicField( const SaveRestoreRecordHeader_t &header, void *pDest, datamap_t *pRootMap, typedescription_t *pField )

+{

+	switch( pField->fieldType )

+	{

+		case FIELD_FLOAT:

+		{

+			ReadFloat( (float *)pDest, pField->fieldSize, header.size );

+			break;

+		}

+		case FIELD_STRING:

+		{

+			ReadString( (string_t *)pDest, pField->fieldSize, header.size );

+			break;

+		}

+

+		case FIELD_VECTOR:

+		{

+			ReadVector( (Vector *)pDest, pField->fieldSize, header.size );

+			break;

+		}

+		

+		case FIELD_QUATERNION:

+		{

+			ReadQuaternion( (Quaternion *)pDest, pField->fieldSize, header.size );

+			break;

+		}

+

+		case FIELD_INTEGER:

+		{

+			ReadInt( (int *)pDest, pField->fieldSize, header.size );

+			break;

+		}

+

+		case FIELD_BOOLEAN:

+		{

+			ReadBool( (bool *)pDest, pField->fieldSize, header.size );

+			break;

+		}

+

+		case FIELD_SHORT:

+		{

+			ReadShort( (short *)pDest, pField->fieldSize, header.size );

+			break;

+		}

+

+		case FIELD_CHARACTER:

+		{

+			ReadData( (char *)pDest, pField->fieldSize, header.size );

+			break;

+		}

+

+		case FIELD_COLOR32:

+		{

+			COMPILE_TIME_ASSERT( sizeof(color32) == sizeof(int) );

+			ReadInt( (int *)pDest, pField->fieldSize, header.size );

+			break;

+		}

+

+		case FIELD_EMBEDDED:

+		{

+			AssertMsg( (( pField->flags & FTYPEDESC_PTR ) == 0) || (pField->fieldSize == 1), "Arrays of embedded pointer types presently unsupported by save/restore" );

+#ifdef DBGFLAG_ASSERT

+			int startPos = GetReadPos();

+#endif

+			if ( !(pField->flags & FTYPEDESC_PTR) || *((void **)pDest) )

+			{

+				int nFieldCount = pField->fieldSize;

+				char *pFieldData = (char *)( ( !(pField->flags & FTYPEDESC_PTR) ) ? pDest : *((void **)pDest) );

+				while ( --nFieldCount >= 0 )

+				{

+					// No corresponding "block" (see write) as it was used as the header of the field

+					ReadAll( pFieldData, pField->td );

+					pFieldData += pField->fieldSizeInBytes;

+				}

+				Assert( GetReadPos() - startPos == header.size );

+			}

+			else

+			{

+				SetReadPos( GetReadPos() + header.size );

+				Warning( "Attempted to restore FIELD_EMBEDDEDBYREF %s but there is no destination memory\n", pField->fieldName );

+			}

+			break;

+			

+		}

+		case FIELD_CUSTOM:

+		{

+			// No corresponding "block" (see write) as it was used as the header of the field

+			int posNextField = GetReadPos() + header.size;

+

+			SaveRestoreFieldInfo_t fieldInfo =

+			{

+				pDest,

+				((char *)pDest) - pField->fieldOffset[ TD_OFFSET_NORMAL ],

+				pField

+			};

+			

+			pField->pSaveRestoreOps->Restore( fieldInfo, this );

+			

+			Assert( posNextField >= GetReadPos() );

+			SetReadPos( posNextField );

+			break;

+		}

+		

+		default:

+			Warning( "Bad field type\n" );

+			Assert(0);

+	}

+}

+

+//-------------------------------------

+

+void CRestore::ReadField( const SaveRestoreRecordHeader_t &header, void *pDest, datamap_t *pRootMap, typedescription_t *pField )

+{

+	if ( pField->fieldType <= FIELD_CUSTOM )

+		ReadBasicField( header, pDest, pRootMap, pField );

+	else

+		ReadGameField( header, pDest, pRootMap, pField );

+}

+

+//-------------------------------------

+

+bool CRestore::ShouldReadField( typedescription_t *pField )

+{

+	if ( (pField->flags & FTYPEDESC_SAVE) == 0 )

+		return false;

+

+	if ( m_global && (pField->flags & FTYPEDESC_GLOBAL) )

+		return false;

+

+	return true;

+}

+

+//-------------------------------------

+

+typedescription_t *CRestore::FindField( const char *pszFieldName, typedescription_t *pFields, int fieldCount, int *pCookie )

+{

+	int &fieldNumber = *pCookie;

+	if ( pszFieldName )

+	{

+		typedescription_t *pTest;

+		

+		for ( int i = 0; i < fieldCount; i++ )

+		{

+			pTest = &pFields[fieldNumber];

+			

+			++fieldNumber;

+			if ( fieldNumber == fieldCount )

+				fieldNumber = 0;

+			

+			if ( stricmp( pTest->fieldName, pszFieldName ) == 0 )

+				return pTest;

+		}

+	}

+

+	fieldNumber = 0;

+	return NULL;

+}

+

+//-------------------------------------

+

+bool CRestore::ShouldEmptyField( typedescription_t *pField )

+{

+	// don't clear out fields that don't get saved, or that are handled specially

+	if ( !( pField->flags & FTYPEDESC_SAVE ) )

+		return false;

+

+	// Don't clear global fields

+	if ( m_global && (pField->flags & FTYPEDESC_GLOBAL) )

+		return false;

+

+	return true;

+}

+

+//-------------------------------------

+

+void CRestore::EmptyFields( void *pBaseData, typedescription_t *pFields, int fieldCount )

+{

+	int i;

+	for ( i = 0; i < fieldCount; i++ )

+	{

+		typedescription_t *pField = &pFields[i];

+		if ( !ShouldEmptyField( pField ) )

+			continue;

+

+		void *pFieldData = (char *)pBaseData + pField->fieldOffset[ TD_OFFSET_NORMAL ];

+		switch( pField->fieldType )

+		{

+		case FIELD_CUSTOM:

+			{

+				SaveRestoreFieldInfo_t fieldInfo =

+				{

+					pFieldData,

+					pBaseData,

+					pField

+				};

+				pField->pSaveRestoreOps->MakeEmpty( fieldInfo );

+			}

+			break;

+

+		case FIELD_EMBEDDED:

+			{

+				if ( (pField->flags & FTYPEDESC_PTR) && !*((void **)pFieldData) )

+					break;

+

+				int nFieldCount = pField->fieldSize;

+				char *pFieldMemory = (char *)( ( !(pField->flags & FTYPEDESC_PTR) ) ? pFieldData : *((void **)pFieldData) );

+				while ( --nFieldCount >= 0 )

+				{

+					EmptyFields( pFieldMemory, pField->td->dataDesc, pField->td->dataNumFields );

+					pFieldMemory += pField->fieldSizeInBytes;

+				}

+			}

+			break;

+

+		default:

+			// NOTE: If you hit this assertion, you've got a bug where you're using 

+			// the wrong field type for your field

+			if ( pField->fieldSizeInBytes != pField->fieldSize * gSizes[pField->fieldType] )

+			{

+				Warning("WARNING! Field %s is using the wrong FIELD_ type!\nFix this or you'll see a crash.\n", pField->fieldName );

+				Assert( 0 );

+			}

+			memset( pFieldData, (pField->fieldType != FIELD_EHANDLE) ? 0 : 0xFF, pField->fieldSize * gSizes[pField->fieldType] );

+			break;

+		}

+	}

+}

+

+//-------------------------------------

+

+void CRestore::StartBlock( SaveRestoreRecordHeader_t *pHeader )

+{

+	ReadHeader( pHeader );

+	m_BlockEndStack.AddToTail( GetReadPos() + pHeader->size );	

+}

+

+//-------------------------------------

+

+void CRestore::StartBlock( char szBlockName[] )

+{

+	SaveRestoreRecordHeader_t header;

+	StartBlock( &header );

+	Q_strncpy( szBlockName, StringFromHeaderSymbol( header.symbol ), SIZE_BLOCK_NAME_BUF );

+}

+

+//-------------------------------------

+

+void CRestore::StartBlock()

+{

+	char szBlockName[SIZE_BLOCK_NAME_BUF];

+	StartBlock( szBlockName );

+}

+

+//-------------------------------------

+

+void CRestore::EndBlock()

+{

+	int endPos = m_BlockEndStack[ m_BlockEndStack.Count() - 1 ];

+	m_BlockEndStack.Remove( m_BlockEndStack.Count() - 1 );

+	SetReadPos( endPos );

+}

+	

+//-------------------------------------

+

+int CRestore::ReadFields( const char *pname, void *pBaseData, datamap_t *pRootMap, typedescription_t *pFields, int fieldCount )

+{

+	static int lastName = -1;

+	Verify( ReadShort() == sizeof(int) );			// First entry should be an int

+	int symName = m_pData->FindCreateSymbol(pname);

+

+	// Check the struct name

+	int curSym = ReadShort();

+	if ( curSym != symName )			// Field Set marker

+	{

+		const char *pLastName = m_pData->StringFromSymbol( lastName );

+		const char *pCurName = m_pData->StringFromSymbol( curSym );

+		Msg( "Expected %s found %s ( raw '%s' )! (prev: %s)\n", pname, pCurName, BufferPointer(), pLastName );

+		Msg( "Field type name may have changed or inheritance graph changed, save file is suspect\n" );

+		m_pData->Rewind( 2*sizeof(short) );

+		return 0;

+	}

+	lastName = symName;

+

+	// Clear out base data

+	EmptyFields( pBaseData, pFields, fieldCount );

+	

+	// Skip over the struct name

+	int i;

+	int nFieldsSaved = ReadInt();						// Read field count

+	int searchCookie = 0;								// Make searches faster, most data is read/written in the same order

+	SaveRestoreRecordHeader_t header;

+

+	for ( i = 0; i < nFieldsSaved; i++ )

+	{

+		ReadHeader( &header );

+

+		typedescription_t *pField = FindField( m_pData->StringFromSymbol( header.symbol ), pFields, fieldCount, &searchCookie);

+		if ( pField && ShouldReadField( pField ) )

+		{

+			ReadField( header, ((char *)pBaseData + pField->fieldOffset[ TD_OFFSET_NORMAL ]), pRootMap, pField );

+		}

+		else

+		{

+			BufferSkipBytes( header.size );			// Advance to next field

+		}

+	}

+	

+	return 1;

+}

+

+//-------------------------------------

+

+void CRestore::ReadHeader( SaveRestoreRecordHeader_t *pheader )

+{

+	if ( pheader != NULL )

+	{

+		Assert( pheader!=NULL );

+		pheader->size = ReadShort();				// Read field size

+		pheader->symbol = ReadShort();				// Read field name token

+	}

+	else

+	{

+		BufferSkipBytes( sizeof(short) * 2 );

+	}

+}

+

+//-------------------------------------

+

+short CRestore::ReadShort( void )

+{

+	short tmp = 0;

+

+	BufferReadBytes( (char *)&tmp, sizeof(short) );

+

+	return tmp;

+}

+

+//-------------------------------------

+

+int	CRestore::ReadInt( void )

+{

+	int tmp = 0;

+

+	BufferReadBytes( (char *)&tmp, sizeof(int) );

+

+	return tmp;

+}

+

+//-------------------------------------

+// Purpose: Recursively restores all the classes in an object, in reverse order (top down)

+// Output : int 0 on failure, 1 on success

+

+int CRestore::DoReadAll( void *pLeafObject, datamap_t *pLeafMap, datamap_t *pCurMap )

+{

+	// restore base classes first

+	if ( pCurMap->baseMap )

+	{

+		int status = DoReadAll( pLeafObject, pLeafMap, pCurMap->baseMap );

+		if ( !status )

+			return status;

+	}

+

+	return ReadFields( pCurMap->dataClassName, pLeafObject, pLeafMap, pCurMap->dataDesc, pCurMap->dataNumFields );

+}

+

+//-------------------------------------

+

+char *CRestore::BufferPointer( void )

+{

+	if ( !m_pData )

+		return NULL;

+

+	return m_pData->AccessCurPos();

+}

+

+//-------------------------------------

+

+void CRestore::BufferReadBytes( char *pOutput, int size )

+{

+	Assert( m_pData !=NULL );

+

+	if ( !m_pData || m_pData->BytesAvailable() == 0 )

+		return;

+

+	if ( !m_pData->Read( pOutput, size ) )

+	{

+		Warning( "Restore underflow!\n" );

+		Assert(0);

+	}

+}

+

+//-------------------------------------

+

+void CRestore::BufferSkipBytes( int bytes )

+{

+	BufferReadBytes( NULL, bytes );

+}

+

+//-------------------------------------

+

+int CRestore::ReadShort( short *pValue, int nElems, int nBytesAvailable )

+{

+	return ReadSimple( pValue, nElems, nBytesAvailable );

+}

+

+//-------------------------------------

+

+int CRestore::ReadInt( int *pValue, int nElems, int nBytesAvailable )

+{

+	return ReadSimple( pValue, nElems, nBytesAvailable );

+}

+

+//-------------------------------------

+

+int CRestore::ReadBool( bool *pValue, int nElems, int nBytesAvailable )

+{

+	COMPILE_TIME_ASSERT( sizeof(bool) == sizeof(char) );

+	return ReadSimple( pValue, nElems, nBytesAvailable );

+}

+

+//-------------------------------------

+

+int CRestore::ReadFloat( float *pValue, int nElems, int nBytesAvailable )

+{

+	return ReadSimple( pValue, nElems, nBytesAvailable );

+}

+

+//-------------------------------------

+

+int CRestore::ReadData( char *pData, int size, int nBytesAvailable )

+{

+	return ReadSimple( pData, size, nBytesAvailable );

+}

+

+//-------------------------------------

+

+void CRestore::ReadString( char *pDest, int nSizeDest, int nBytesAvailable )

+{

+	const char *pString = BufferPointer();

+	if ( !nBytesAvailable )

+		nBytesAvailable = strlen( pString ) + 1;

+	BufferSkipBytes( nBytesAvailable );

+

+	Q_strncpy(pDest, pString, nSizeDest );

+}

+	

+//-------------------------------------

+

+int CRestore::ReadString( string_t *pValue, int nElems, int nBytesAvailable )

+{

+	AssertMsg( nBytesAvailable > 0, "CRestore::ReadString() implementation does not currently support unspecified bytes available");

+	

+	int i;

+	char *pString = BufferPointer();

+	char *pLimit = pString + nBytesAvailable;

+	for ( i = 0; i < nElems && pString < pLimit; i++ )

+	{

+		if ( *((char *)pString) == 0 )

+			pValue[i] = NULL_STRING;

+		else

+			pValue[i] = AllocPooledString( (char *)pString );

+		

+		while (*pString)

+			pString++;

+		pString++;

+	}

+

+	BufferSkipBytes( nBytesAvailable );

+	

+	return i;

+}

+

+//-------------------------------------

+

+int CRestore::ReadVector( Vector *pValue)

+{

+	BufferReadBytes( (char *)pValue, sizeof(Vector) );

+	return 1;

+}

+

+//-------------------------------------

+

+int CRestore::ReadVector( Vector *pValue, int nElems, int nBytesAvailable )

+{

+	return ReadSimple( pValue, nElems, nBytesAvailable );

+}

+

+int CRestore::ReadQuaternion( Quaternion *pValue)

+{

+	BufferReadBytes( (char *)pValue, sizeof(Quaternion) );

+	return 1;

+}

+

+//-------------------------------------

+

+int CRestore::ReadQuaternion( Quaternion *pValue, int nElems, int nBytesAvailable )

+{

+	return ReadSimple( pValue, nElems, nBytesAvailable );

+}

+

+//-------------------------------------

+int CRestore::ReadVMatrix( VMatrix *pValue, int nElems, int nBytesAvailable )

+{

+	return ReadSimple( pValue, nElems, nBytesAvailable );

+}

+

+

+int CRestore::ReadVMatrixWorldspace( VMatrix *pValue, int nElems, int nBytesAvailable )

+{

+	Vector basePosition = m_pGameInfo->GetLandmark();

+	VMatrix tmp;

+

+	for ( int i = 0; i < nElems; i++ )

+	{

+		BufferReadBytes( (char *)&tmp, sizeof(float)*16 );

+

+		VMatrixOffset( pValue[i], tmp, basePosition );

+	}

+	return nElems;

+}

+

+

+int CRestore::ReadMatrix3x4Worldspace( matrix3x4_t *pValue, int nElems, int nBytesAvailable )

+{

+	Vector basePosition = m_pGameInfo->GetLandmark();

+	matrix3x4_t tmp;

+

+	for ( int i = 0; i < nElems; i++ )

+	{

+		BufferReadBytes( (char *)&tmp, sizeof(matrix3x4_t) );

+

+		Matrix3x4Offset( pValue[i], tmp, basePosition );

+	}

+	return nElems;

+}

+

+int CRestore::ReadInterval( interval_t *interval, int count, int nBytesAvailable )

+{

+	return ReadSimple( interval, count, nBytesAvailable );

+}

+

+//---------------------------------------------------------

+//

+// Game centric restore methods

+//

+

+CBaseEntity *CRestore::EntityFromIndex( int entityIndex )

+{

+	if ( !m_pGameInfo || entityIndex < 0 )

+		return NULL;

+

+	int i;

+	entitytable_t *pTable;

+

+	for ( i = 0; i < m_pGameInfo->NumEntities(); i++ )

+	{

+		pTable = m_pGameInfo->GetEntityInfo( i );

+		if ( pTable->id == entityIndex )

+			return pTable->hEnt;

+	}

+	return NULL;

+}

+

+//-------------------------------------

+

+int CRestore::ReadEntityPtr( CBaseEntity **ppEntity, int count, int nBytesAvailable )

+{

+	AssertMsg( count <= MAX_ENTITYARRAY, "Array of entities or ehandles exceeds limit supported by save/restore" );

+	int entityArray[MAX_ENTITYARRAY];

+	

+	int nRead = ReadInt( entityArray, count, nBytesAvailable );

+	

+	for ( int i = 0; i < nRead; i++ ) // nRead is never greater than count

+	{

+		ppEntity[i] = EntityFromIndex( entityArray[i] );

+	}

+	

+	if ( nRead < count)

+	{

+		memset( &ppEntity[nRead], 0, ( count - nRead ) * sizeof(ppEntity[0]) );

+	}

+	

+	return nRead;

+}

+

+//-------------------------------------

+int CRestore::ReadEdictPtr( edict_t **ppEdict, int count, int nBytesAvailable )

+{

+#if !defined( CLIENT_DLL )

+	AssertMsg( count <= MAX_ENTITYARRAY, "Array of entities or ehandles exceeds limit supported by save/restore" );

+	int entityArray[MAX_ENTITYARRAY];

+	CBaseEntity	*pEntity;

+	

+	int nRead = ReadInt( entityArray, count, nBytesAvailable );

+	

+	for ( int i = 0; i < nRead; i++ ) // nRead is never greater than count

+	{

+		pEntity = EntityFromIndex( entityArray[i] );

+		ppEdict[i] = (pEntity) ? pEntity->edict() : NULL;

+	}

+	

+	if ( nRead < count)

+	{

+		memset( &ppEdict[nRead], 0, ( count - nRead ) * sizeof(ppEdict[0]) );

+	}

+	

+	return nRead;

+#else

+	return 0;

+#endif

+}

+

+

+//-------------------------------------

+

+int CRestore::ReadEHandle( EHANDLE *pEHandle, int count, int nBytesAvailable )

+{

+	AssertMsg( count <= MAX_ENTITYARRAY, "Array of entities or ehandles exceeds limit supported by save/restore" );

+	int entityArray[MAX_ENTITYARRAY];

+	

+	int nRead = ReadInt( entityArray, count, nBytesAvailable );

+	

+	for ( int i = 0; i < nRead; i++ ) // nRead is never greater than count

+	{

+		pEHandle[i] = EntityFromIndex( entityArray[i] );

+	}

+	

+	if ( nRead < count)

+	{

+		memset( &pEHandle[nRead], 0xFF, ( count - nRead ) * sizeof(pEHandle[0]) );

+	}

+	

+	return nRead;

+}

+	

+//-------------------------------------

+// Purpose:	Reads all the fields that are not client neutral. In the event of 

+//			a librarization of save/restore, these would NOT reside in the library

+

+void CRestore::ReadGameField( const SaveRestoreRecordHeader_t &header, void *pDest, datamap_t *pRootMap, typedescription_t *pField )

+{

+	switch( pField->fieldType )

+	{

+		case FIELD_POSITION_VECTOR:

+		{

+			ReadPositionVector( (Vector *)pDest, pField->fieldSize, header.size );

+			break;

+		}

+

+		case FIELD_TIME:

+		{

+			ReadTime( (float *)pDest, pField->fieldSize, header.size );

+			break;

+		}

+

+		case FIELD_TICK:

+		{

+			ReadTick( (int *)pDest, pField->fieldSize, header.size );

+			break;

+		}

+		

+		case FIELD_FUNCTION:

+		{

+			ReadFunction( pRootMap, (inputfunc_t **)pDest, pField->fieldSize, header.size );

+			break;

+		}

+		

+		case FIELD_MODELINDEX:

+		{

+			int *pModelIndex = (int*)pDest;

+			string_t *pModelName = (string_t *)stackalloc( pField->fieldSize * sizeof(string_t) );

+			int nRead = ReadString( pModelName, pField->fieldSize, header.size );

+

+			for ( int i = 0; i < nRead; i++ )

+			{

+				if ( pModelName[i] == NULL_STRING )

+				{

+					pModelIndex[i] = -1;

+					continue;

+				}

+

+				pModelIndex[i] = modelinfo->GetModelIndex( STRING( pModelName[i] ) );

+

+#if !defined( CLIENT_DLL )	

+				if ( m_precache )

+				{

+					CBaseEntity::PrecacheModel( STRING( pModelName[i] ) );

+				}

+#endif

+			}

+			break;

+		}

+

+		case FIELD_MATERIALINDEX:

+		{

+			int *pMaterialIndex = (int*)pDest;

+			string_t *pMaterialName = (string_t *)stackalloc( pField->fieldSize * sizeof(string_t) );

+			int nRead = ReadString( pMaterialName, pField->fieldSize, header.size );

+

+			for ( int i = 0; i < nRead; i++ )

+			{

+				if ( pMaterialName[i] == NULL_STRING )

+				{

+					pMaterialIndex[i] = 0;

+					continue;

+				}

+

+				pMaterialIndex[i] = GetMaterialIndex( STRING( pMaterialName[i] ) );

+

+#if !defined( CLIENT_DLL )	

+				if ( m_precache )

+				{

+					PrecacheMaterial( STRING( pMaterialName[i] ) );

+				}

+#endif

+			}

+			break;

+		}

+		

+		case FIELD_MODELNAME:

+		case FIELD_SOUNDNAME:

+		{

+			string_t *pStringDest = (string_t *)pDest;

+			int nRead = ReadString( pStringDest, pField->fieldSize, header.size );

+			if ( m_precache )

+			{

+#if !defined( CLIENT_DLL )

+				// HACKHACK: Rewrite the .bsp models to match the map name in case the bugreporter renamed it

+				if ( pField->fieldType == FIELD_MODELNAME && Q_stristr(pStringDest->ToCStr(), ".bsp") )

+				{

+					char buf[MAX_PATH];

+					Q_strncpy( buf, "maps/", sizeof(buf) );

+					Q_strncat( buf, gpGlobals->mapname.ToCStr(), sizeof(buf) );

+					Q_strncat( buf, ".bsp", sizeof(buf) );

+					*pStringDest = AllocPooledString( buf );

+				}

+#endif

+				for ( int i = 0; i < nRead; i++ )

+				{

+					if ( pStringDest[i] != NULL_STRING )

+					{

+#if !defined( CLIENT_DLL )	

+						if ( pField->fieldType == FIELD_MODELNAME )

+						{

+							CBaseEntity::PrecacheModel( STRING( pStringDest[i] ) );

+						}

+						else if ( pField->fieldType == FIELD_SOUNDNAME )

+						{

+							CBaseEntity::PrecacheScriptSound( STRING( pStringDest[i] ) );

+						}

+#endif

+					}

+				}

+			}

+			break;

+		}

+		

+		case FIELD_CLASSPTR:

+			ReadEntityPtr( (CBaseEntity **)pDest, pField->fieldSize, header.size );

+			break;

+			

+		case FIELD_EDICT:

+#if !defined( CLIENT_DLL )

+			ReadEdictPtr( (edict_t **)pDest, pField->fieldSize, header.size );

+#else

+			Assert( !"FIELD_EDICT not valid for client .dll" );

+#endif

+			break;

+		case FIELD_EHANDLE:

+			ReadEHandle( (EHANDLE *)pDest, pField->fieldSize, header.size );

+			break;

+

+		case FIELD_VMATRIX:

+		{

+			ReadVMatrix( (VMatrix *)pDest, pField->fieldSize, header.size );

+			break;

+		}

+

+		case FIELD_VMATRIX_WORLDSPACE:

+			ReadVMatrixWorldspace( (VMatrix *)pDest, pField->fieldSize, header.size );

+			break;

+

+		case FIELD_MATRIX3X4_WORLDSPACE:

+			ReadMatrix3x4Worldspace( (matrix3x4_t *)pDest, pField->fieldSize, header.size );

+			break;

+

+		case FIELD_INTERVAL:

+			ReadInterval( (interval_t *)pDest, pField->fieldSize, header.size );

+			break;

+

+		default:

+			Warning( "Bad field type\n" );

+			Assert(0);

+	}

+}

+

+//-------------------------------------

+

+int CRestore::ReadTime( float *pValue, int count, int nBytesAvailable )

+{

+	float baseTime = m_pGameInfo->GetBaseTime();

+	int nRead = ReadFloat( pValue, count, nBytesAvailable );

+	

+	for ( int i = nRead - 1; i >= 0; i-- )

+	{

+		if ( pValue[i] == ZERO_TIME )

+			pValue[i] = 0.0;

+		else if ( pValue[i] != INVALID_TIME && pValue[i] != FLT_MAX )

+			pValue[i] += baseTime;

+	}

+	

+	return nRead;

+}

+

+int CRestore::ReadTick( int *pValue, int count, int nBytesAvailable )

+{

+	// HACK HACK:  Adding 0.1f here makes sure that all tick times read

+	//  from .sav file which are near the basetime will end up just ahead of

+	//  the base time, because we are restoring we'll have a slow frame of the

+	//  max frametime of 0.1 seconds and that could otherwise cause all of our

+	//  think times to get synchronized to each other... sigh.  ywb...

+	int baseTick = TIME_TO_TICKS( m_pGameInfo->GetBaseTime() + 0.1f );

+	int nRead = ReadInt( pValue, count, nBytesAvailable );

+	

+	for ( int i = nRead - 1; i >= 0; i-- )

+	{

+		if ( pValue[ i ] != TICK_NEVER_THINK_ENCODE )

+		{

+			// Rebase it

+			pValue[i] += baseTick;

+		}

+		else

+		{

+			// Slam to -1 value

+			pValue[ i ] = TICK_NEVER_THINK;

+		}

+	}

+	

+	return nRead;

+}

+

+//-------------------------------------

+

+int CRestore::ReadPositionVector( Vector *pValue )

+{

+	return ReadPositionVector( pValue, 1, sizeof(Vector) );

+}

+

+//-------------------------------------

+

+int CRestore::ReadPositionVector( Vector *pValue, int count, int nBytesAvailable )

+{

+	Vector basePosition = m_pGameInfo->GetLandmark();

+	int nRead = ReadVector( pValue, count, nBytesAvailable );

+	

+	for ( int i = nRead - 1; i >= 0; i-- )

+	{

+		if ( pValue[i] != vec3_invalid )

+			pValue[i] += basePosition;

+	}

+	

+	return nRead;

+}

+

+//-------------------------------------

+

+int CRestore::ReadFunction( datamap_t *pMap, inputfunc_t **pValue, int count, int nBytesAvailable )

+{

+	AssertMsg( nBytesAvailable > 0, "CRestore::ReadFunction() implementation does not currently support unspecified bytes available");

+	

+	char *pszFunctionName = BufferPointer();

+	BufferSkipBytes( nBytesAvailable );

+	

+	AssertMsg( count == 1, "Arrays of functions not presently supported" );

+	

+	if ( *pszFunctionName == 0 )

+		*pValue = NULL;

+	else

+		*pValue = UTIL_FunctionFromName( pMap, pszFunctionName );

+

+	return 0;

+}

+	

+//-----------------------------------------------------------------------------

+//

+// Entity data saving routines

+//

+//-----------------------------------------------------------------------------

+

+BEGIN_SIMPLE_DATADESC(entitytable_t)

+	DEFINE_FIELD( id, FIELD_INTEGER ),

+	DEFINE_FIELD( edictindex, FIELD_INTEGER ),

+	DEFINE_FIELD( saveentityindex, FIELD_INTEGER ),

+//	DEFINE_FIELD( restoreentityindex, FIELD_INTEGER ),

+	//				hEnt		(not saved, this is the fixup)

+	DEFINE_FIELD( location, FIELD_INTEGER ),

+	DEFINE_FIELD( size, FIELD_INTEGER ),

+	DEFINE_FIELD( flags, FIELD_INTEGER ),

+	DEFINE_FIELD( classname, FIELD_STRING ),

+	DEFINE_FIELD( globalname, FIELD_STRING ),

+	DEFINE_FIELD( landmarkModelSpace, FIELD_VECTOR ),

+	DEFINE_FIELD( modelname, FIELD_STRING ),

+END_DATADESC()

+

+

+//-----------------------------------------------------------------------------

+// Utilities entities can use when saving

+//-----------------------------------------------------------------------------

+class CEntitySaveUtils : public IEntitySaveUtils

+{

+public:

+	// Call these in pre-save + post save

+	void PreSave();

+	void PostSave();

+

+	// Methods of IEntitySaveUtils

+	virtual void AddLevelTransitionSaveDependency( CBaseEntity *pEntity1, CBaseEntity *pEntity2 );

+	virtual int GetEntityDependencyCount( CBaseEntity *pEntity );

+	virtual int GetEntityDependencies( CBaseEntity *pEntity, int nCount, CBaseEntity **ppEntList );

+

+private:

+ 	IPhysicsObjectPairHash *m_pLevelAdjacencyDependencyHash;

+};

+

+

+//-----------------------------------------------------------------------------

+// Call these in pre-save + post save

+//-----------------------------------------------------------------------------

+void CEntitySaveUtils::PreSave()

+{

+	Assert( !m_pLevelAdjacencyDependencyHash );

+	MEM_ALLOC_CREDIT();

+	m_pLevelAdjacencyDependencyHash = physics->CreateObjectPairHash();

+}

+

+void CEntitySaveUtils::PostSave()

+{

+ 	physics->DestroyObjectPairHash( m_pLevelAdjacencyDependencyHash );

+	m_pLevelAdjacencyDependencyHash = NULL;

+}

+

+

+//-----------------------------------------------------------------------------

+// Gets the # of dependencies for a particular entity

+//-----------------------------------------------------------------------------

+int CEntitySaveUtils::GetEntityDependencyCount( CBaseEntity *pEntity )

+{

+	return m_pLevelAdjacencyDependencyHash->GetPairCountForObject( pEntity );

+}

+

+

+//-----------------------------------------------------------------------------

+// Gets all dependencies for a particular entity

+//-----------------------------------------------------------------------------

+int CEntitySaveUtils::GetEntityDependencies( CBaseEntity *pEntity, int nCount, CBaseEntity **ppEntList )

+{

+	return m_pLevelAdjacencyDependencyHash->GetPairListForObject( pEntity, nCount, (void**)ppEntList );

+}

+

+

+//-----------------------------------------------------------------------------

+// Methods of IEntitySaveUtils

+//-----------------------------------------------------------------------------

+void CEntitySaveUtils::AddLevelTransitionSaveDependency( CBaseEntity *pEntity1, CBaseEntity *pEntity2 )

+{

+	if ( pEntity1 != pEntity2 )

+	{

+		m_pLevelAdjacencyDependencyHash->AddObjectPair( pEntity1, pEntity2 );

+	}

+}

+

+

+//-----------------------------------------------------------------------------

+// Block handler for save/restore of entities

+//-----------------------------------------------------------------------------

+class CEntitySaveRestoreBlockHandler : public ISaveRestoreBlockHandler

+{

+public:

+	const char *GetBlockName();

+	void PreSave( CSaveRestoreData *pSaveData );

+	void Save( ISave *pSave );

+	void WriteSaveHeaders( ISave *pSave );

+	virtual void PostSave();

+	virtual void PreRestore();

+	void ReadRestoreHeaders( IRestore *pRestore );

+

+	void Restore( IRestore *pRestore, bool createPlayers );

+	virtual void PostRestore();

+

+	inline IEntitySaveUtils * GetEntitySaveUtils() { return &m_EntitySaveUtils; }

+

+private:

+	friend int CreateEntityTransitionList( CSaveRestoreData *pSaveData, int levelMask );

+	bool SaveInitEntities( CSaveRestoreData *pSaveData );	

+	bool DoRestoreEntity( CBaseEntity *pEntity, IRestore *pRestore );

+	Vector ModelSpaceLandmark( int modelIndex );

+	int RestoreEntity( CBaseEntity *pEntity, IRestore *pRestore, entitytable_t *pEntInfo );

+

+#if !defined( CLIENT_DLL )	

+	// Find the matching global entity.  Spit out an error if the designer made entities of

+	// different classes with the same global name

+	CBaseEntity *FindGlobalEntity( string_t classname, string_t globalname );

+

+	int RestoreGlobalEntity( CBaseEntity *pEntity, CSaveRestoreData *pSaveData, entitytable_t *pEntInfo );

+#endif

+

+private:

+	CEntitySaveUtils	m_EntitySaveUtils;

+};

+

+

+//-----------------------------------------------------------------------------

+

+CEntitySaveRestoreBlockHandler g_EntitySaveRestoreBlockHandler;

+

+//-------------------------------------

+

+ISaveRestoreBlockHandler *GetEntitySaveRestoreBlockHandler()

+{

+	return &g_EntitySaveRestoreBlockHandler;

+}

+

+IEntitySaveUtils *GetEntitySaveUtils()

+{

+	return g_EntitySaveRestoreBlockHandler.GetEntitySaveUtils();

+}

+

+

+//-----------------------------------------------------------------------------

+// Implementation of the block handler for save/restore of entities

+//-----------------------------------------------------------------------------

+const char *CEntitySaveRestoreBlockHandler::GetBlockName()

+{

+	return "Entities";

+}

+

+//---------------------------------

+

+void CEntitySaveRestoreBlockHandler::PreSave( CSaveRestoreData *pSaveData )

+{

+	MDLCACHE_CRITICAL_SECTION();

+	IGameSystem::OnSaveAllSystems();

+

+	m_EntitySaveUtils.PreSave();

+

+	// Allow the entities to do some work

+	CBaseEntity *pEnt = NULL;

+#if !defined( CLIENT_DLL )

+	while ( (pEnt = gEntList.NextEnt( pEnt )) != NULL )

+	{

+		pEnt->OnSave( &m_EntitySaveUtils );

+	}

+#else

+	// Do this because it'll force entities to figure out their origins, and that requires

+	// SetupBones in the case of aiments.

+	{

+		C_BaseAnimating::AutoAllowBoneAccess boneaccess( true, true );

+

+		int last = ClientEntityList().GetHighestEntityIndex();

+		ClientEntityHandle_t iter = ClientEntityList().FirstHandle();

+

+		for ( int e = 0; e <= last; e++ )

+		{

+			pEnt = ClientEntityList().GetBaseEntity( e );

+

+			if(  !pEnt )

+				continue;

+

+			pEnt->OnSave();

+		}

+

+		while ( iter != ClientEntityList().InvalidHandle() )

+		{

+			pEnt = ClientEntityList().GetBaseEntityFromHandle( iter );

+

+			if ( pEnt && pEnt->ObjectCaps() & FCAP_SAVE_NON_NETWORKABLE ) 

+			{

+				pEnt->OnSave();

+			}

+

+			iter = ClientEntityList().NextHandle( iter );

+		}

+	}

+#endif

+	SaveInitEntities( pSaveData );

+}

+

+//---------------------------------

+

+void CEntitySaveRestoreBlockHandler::Save( ISave *pSave )

+{

+	CGameSaveRestoreInfo *pSaveData = pSave->GetGameSaveRestoreInfo();

+	

+	// write entity list that was previously built by SaveInitEntities()

+	for ( int i = 0; i < pSaveData->NumEntities(); i++ )

+	{

+		entitytable_t *pEntInfo = pSaveData->GetEntityInfo( i );

+		pEntInfo->location = pSave->GetWritePos();

+		pEntInfo->size = 0;

+

+		CBaseEntity *pEnt = pEntInfo->hEnt;

+		if ( pEnt && !( pEnt->ObjectCaps() & FCAP_DONT_SAVE ) )

+		{

+			MDLCACHE_CRITICAL_SECTION();

+#if !defined( CLIENT_DLL )

+			AssertMsg( !pEnt->edict() || ( pEnt->m_iClassname != NULL_STRING && 

+										   (STRING(pEnt->m_iClassname)[0] != 0) && 

+										   FStrEq( STRING(pEnt->m_iClassname), pEnt->GetClassname()) ), 

+					   "Saving entity with invalid classname" );

+#endif

+

+			pSaveData->SetCurrentEntityContext( pEnt );

+			pEnt->Save( *pSave );

+			pSaveData->SetCurrentEntityContext( NULL );

+

+			pEntInfo->size = pSave->GetWritePos() - pEntInfo->location;	// Size of entity block is data size written to block

+

+			pEntInfo->classname = pEnt->m_iClassname;	// Remember entity class for respawn

+

+#if !defined( CLIENT_DLL )

+			pEntInfo->globalname = pEnt->m_iGlobalname; // remember global name

+			pEntInfo->landmarkModelSpace = ModelSpaceLandmark( pEnt->GetModelIndex() );

+			int nEntIndex = pEnt->edict() ? ENTINDEX(pEnt->edict()) : -1;

+			bool bIsPlayer = ( ( nEntIndex >= 1 ) && ( nEntIndex <= gpGlobals->maxClients ) ) ? true : false;

+			if ( bIsPlayer )

+			{

+				pEntInfo->flags |= FENTTABLE_PLAYER;

+			}

+#endif

+		}

+	}

+}

+

+//---------------------------------

+

+void CEntitySaveRestoreBlockHandler::WriteSaveHeaders( ISave *pSave )

+{

+	CGameSaveRestoreInfo *pSaveData = pSave->GetGameSaveRestoreInfo();

+

+	int nEntities = pSaveData->NumEntities();

+	pSave->WriteInt( &nEntities );

+	

+	for ( int i = 0; i < pSaveData->NumEntities(); i++ )

+		pSave->WriteFields( "ETABLE", pSaveData->GetEntityInfo( i ), NULL, entitytable_t::m_DataMap.dataDesc, entitytable_t::m_DataMap.dataNumFields );

+}

+	

+//---------------------------------

+

+void CEntitySaveRestoreBlockHandler::PostSave()

+{

+	m_EntitySaveUtils.PostSave();

+}

+

+//---------------------------------

+

+void CEntitySaveRestoreBlockHandler::PreRestore()

+{

+}

+

+//---------------------------------

+

+void CEntitySaveRestoreBlockHandler::ReadRestoreHeaders( IRestore *pRestore )

+{

+	CGameSaveRestoreInfo *pSaveData = pRestore->GetGameSaveRestoreInfo();

+

+	int nEntities;

+	pRestore->ReadInt( &nEntities );

+

+	entitytable_t *pEntityTable = ( entitytable_t *)engine->SaveAllocMemory( (sizeof(entitytable_t) * nEntities), sizeof(char) );

+	if ( !pEntityTable )

+	{

+		return;

+	}

+

+	pSaveData->InitEntityTable( pEntityTable, nEntities );

+	

+	for ( int i = 0; i < pSaveData->NumEntities(); i++ )

+		pRestore->ReadFields( "ETABLE", pSaveData->GetEntityInfo( i ), NULL, entitytable_t::m_DataMap.dataDesc, entitytable_t::m_DataMap.dataNumFields );

+

+}

+

+//---------------------------------

+

+#if !defined( CLIENT_DLL )

+

+void CEntitySaveRestoreBlockHandler::Restore( IRestore *pRestore, bool createPlayers )

+{

+	entitytable_t *pEntInfo;

+	CBaseEntity *pent;

+

+	CGameSaveRestoreInfo *pSaveData = pRestore->GetGameSaveRestoreInfo();

+	

+	bool restoredWorld = false;

+

+	// Create entity list

+	int i;

+	for ( i = 0; i < pSaveData->NumEntities(); i++ )

+	{

+		pEntInfo = pSaveData->GetEntityInfo( i );

+

+		if ( pEntInfo->classname != NULL_STRING && pEntInfo->size && !(pEntInfo->flags & FENTTABLE_REMOVED) )

+		{

+			if ( pEntInfo->edictindex == 0 )	// worldspawn

+			{

+				Assert( i == 0 );

+				pent = CreateEntityByName( STRING(pEntInfo->classname) );

+				pRestore->SetReadPos( pEntInfo->location );

+				if ( RestoreEntity( pent, pRestore, pEntInfo ) < 0 )

+				{

+					pEntInfo->hEnt = NULL;

+					pEntInfo->restoreentityindex = -1;

+					UTIL_RemoveImmediate( pent );	

+				}

+				else

+				{

+					// force the entity to be relinked

+					AddRestoredEntity( pent );

+				}

+			}

+			else if ( (pEntInfo->edictindex > 0) && (pEntInfo->edictindex <= gpGlobals->maxClients) )

+			{

+				if ( !(pEntInfo->flags & FENTTABLE_PLAYER) )

+				{

+					Warning( "ENTITY IS NOT A PLAYER: %d\n" , i );

+					Assert(0);

+				}

+

+				edict_t *ed = INDEXENT( pEntInfo->edictindex );

+

+				if ( ed && createPlayers )

+				{

+					// create the player

+					pent = CBasePlayer::CreatePlayer( STRING(pEntInfo->classname), ed );

+				}

+				else

+					pent = NULL;

+			}

+			else

+			{

+				pent = CreateEntityByName( STRING(pEntInfo->classname) );

+			}

+			pEntInfo->hEnt = pent;

+			pEntInfo->restoreentityindex = pent ? pent->entindex() : - 1;

+			if ( pent && pEntInfo->restoreentityindex == 0 )

+			{

+				if ( !FClassnameIs( pent, "worldspawn" ) )

+				{

+					pEntInfo->restoreentityindex = -1;

+				}

+			}

+

+			if ( pEntInfo->restoreentityindex == 0 )

+			{

+				Assert( !restoredWorld );

+				restoredWorld = true;

+			}

+		}

+		else

+		{

+			pEntInfo->hEnt = NULL;

+			pEntInfo->restoreentityindex = -1;

+		}

+	}

+

+	// Now spawn entities

+	for ( i = 0; i < pSaveData->NumEntities(); i++ )

+	{

+		pEntInfo = pSaveData->GetEntityInfo( i );

+		if ( pEntInfo->edictindex != 0 )

+		{

+			pent = pEntInfo->hEnt;

+			pRestore->SetReadPos( pEntInfo->location );

+			if ( pent )

+			{

+				if ( RestoreEntity( pent, pRestore, pEntInfo ) < 0 )

+				{

+					pEntInfo->hEnt = NULL;

+					pEntInfo->restoreentityindex = -1;

+					UTIL_RemoveImmediate( pent );

+				}

+				else

+				{

+					AddRestoredEntity( pent );

+				}

+			}

+		}

+	}

+}

+

+#else // CLIENT DLL VERSION

+

+void CEntitySaveRestoreBlockHandler::Restore( IRestore *pRestore, bool createPlayers )

+{

+	entitytable_t *pEntInfo;

+	CBaseEntity *pent;

+

+	CGameSaveRestoreInfo *pSaveData = pRestore->GetGameSaveRestoreInfo();

+	

+	// Create entity list

+	int i;

+	bool restoredWorld = false;

+

+	for ( i = 0; i < pSaveData->NumEntities(); i++ )

+	{

+		pEntInfo = pSaveData->GetEntityInfo( i );

+		pent = ClientEntityList().GetBaseEntity( pEntInfo->restoreentityindex );

+		pEntInfo->hEnt = pent;

+	}

+

+	// Blast saved data into entities

+	for ( i = 0; i < pSaveData->NumEntities(); i++ )

+	{

+		pEntInfo = pSaveData->GetEntityInfo( i );

+

+		bool bRestoredCorrectly = false;

+		// FIXME, need to translate save spot to real index here using lookup table transmitted from server

+		//Assert( !"Need translation still" );

+		if ( pEntInfo->restoreentityindex >= 0 )

+		{

+			if ( pEntInfo->restoreentityindex == 0 )

+			{

+				Assert( !restoredWorld );

+				restoredWorld = true;

+			}

+

+			pent = ClientEntityList().GetBaseEntity( pEntInfo->restoreentityindex );

+			pRestore->SetReadPos( pEntInfo->location );

+			if ( pent )

+			{

+				if ( RestoreEntity( pent, pRestore, pEntInfo ) >= 0 )

+				{

+					// Call the OnRestore method

+					AddRestoredEntity( pent );

+					bRestoredCorrectly = true;

+				}

+			}

+		}

+		// BUGBUG: JAY: Disable ragdolls across transitions until PVS/solid check & client entity patch file are implemented

+		else if ( !pSaveData->levelInfo.fUseLandmark )

+		{

+			if ( pEntInfo->classname != NULL_STRING )

+			{

+				pent = CreateEntityByName( STRING(pEntInfo->classname) );

+				pent->InitializeAsClientEntity( NULL, RENDER_GROUP_OPAQUE_ENTITY );

+				

+				pRestore->SetReadPos( pEntInfo->location );

+

+				if ( pent )

+				{

+					if ( RestoreEntity( pent, pRestore, pEntInfo ) >= 0 )

+					{

+						pEntInfo->hEnt = pent;

+						AddRestoredEntity( pent );

+						bRestoredCorrectly = true;

+					}

+				}

+			}

+		}

+

+		if ( !bRestoredCorrectly )

+		{

+			pEntInfo->hEnt = NULL;

+			pEntInfo->restoreentityindex = -1;

+		}

+	}

+

+	// Note, server does this after local player connects fully

+	IGameSystem::OnRestoreAllSystems();

+

+	// Tell hud elements to modify behavior based on game restoration, if applicable

+	gHUD.OnRestore();

+}

+#endif

+

+void CEntitySaveRestoreBlockHandler::PostRestore()

+{

+}

+

+void SaveEntityOnTable( CBaseEntity *pEntity, CSaveRestoreData *pSaveData, int &iSlot )

+{

+	entitytable_t *pEntInfo = pSaveData->GetEntityInfo( iSlot );

+	pEntInfo->id = iSlot;

+#if !defined( CLIENT_DLL )

+	pEntInfo->edictindex = pEntity->RequiredEdictIndex();

+#else

+	pEntInfo->edictindex = -1;

+#endif

+	pEntInfo->modelname = pEntity->GetModelName();

+	pEntInfo->restoreentityindex = -1;

+	pEntInfo->saveentityindex = pEntity ? pEntity->entindex() : -1;

+	pEntInfo->hEnt = pEntity;

+	pEntInfo->flags = 0;

+	pEntInfo->location = 0;

+	pEntInfo->size = 0;

+	pEntInfo->classname = NULL_STRING;

+

+	iSlot++;

+}

+

+

+//---------------------------------

+

+bool CEntitySaveRestoreBlockHandler::SaveInitEntities( CSaveRestoreData *pSaveData )

+{

+	int number_of_entities;

+

+#if !defined( CLIENT_DLL )

+	number_of_entities = gEntList.NumberOfEntities();

+#else

+	number_of_entities = ClientEntityList().NumberOfEntities( true );

+#endif

+	entitytable_t *pEntityTable = ( entitytable_t *)engine->SaveAllocMemory( (sizeof(entitytable_t) * number_of_entities), sizeof(char) );

+	if ( !pEntityTable )

+		return false;

+

+	pSaveData->InitEntityTable( pEntityTable, number_of_entities );

+

+	// build the table of entities

+	// this is used to turn pointers into savable indices

+	// build up ID numbers for each entity, for use in pointer conversions

+	// if an entity requires a certain edict number upon restore, save that as well

+	CBaseEntity *pEnt = NULL;

+	int i = 0;

+

+#if !defined( CLIENT_DLL )

+	while ( (pEnt = gEntList.NextEnt( pEnt )) != NULL )

+	{

+#else

+	int last = ClientEntityList().GetHighestEntityIndex();

+

+	for ( int e = 0; e <= last; e++ )

+	{

+		pEnt = ClientEntityList().GetBaseEntity( e );

+		if(  !pEnt )

+			continue;

+#endif

+		SaveEntityOnTable( pEnt, pSaveData, i );

+	}

+

+#if defined( CLIENT_DLL )

+	ClientEntityHandle_t iter = ClientEntityList().FirstHandle();

+

+	while ( iter != ClientEntityList().InvalidHandle() )

+	{

+		pEnt = ClientEntityList().GetBaseEntityFromHandle( iter );

+

+		if ( pEnt && pEnt->ObjectCaps() & FCAP_SAVE_NON_NETWORKABLE  ) 

+		{

+			SaveEntityOnTable( pEnt, pSaveData, i );

+		}

+

+		iter = ClientEntityList().NextHandle( iter );

+	}

+#endif

+

+	pSaveData->BuildEntityHash();

+

+	Assert( i == pSaveData->NumEntities() );

+	return ( i == pSaveData->NumEntities() );

+}

+

+//---------------------------------

+

+#if !defined( CLIENT_DLL )

+

+// Find the matching global entity.  Spit out an error if the designer made entities of

+// different classes with the same global name

+CBaseEntity *CEntitySaveRestoreBlockHandler::FindGlobalEntity( string_t classname, string_t globalname )

+{

+	CBaseEntity *pReturn = NULL;

+

+	while ( (pReturn = gEntList.NextEnt( pReturn )) != NULL )

+	{

+		if ( FStrEq( STRING(pReturn->m_iGlobalname), STRING(globalname)) )

+			break;

+	}

+		

+	if ( pReturn )

+	{

+		if ( !FClassnameIs( pReturn, STRING(classname) ) )

+		{

+			Warning( "Global entity found %s, wrong class %s [expects class %s]\n", STRING(globalname), STRING(pReturn->m_iClassname), STRING(classname) );

+			pReturn = NULL;

+		}

+	}

+

+	return pReturn;

+}

+

+#endif	// !defined( CLIENT_DLL )

+

+//---------------------------------

+

+bool CEntitySaveRestoreBlockHandler::DoRestoreEntity( CBaseEntity *pEntity, IRestore *pRestore )

+{

+	MDLCACHE_CRITICAL_SECTION();

+

+	EHANDLE hEntity;

+	

+	hEntity = pEntity;

+

+	pRestore->GetGameSaveRestoreInfo()->SetCurrentEntityContext( pEntity );

+	pEntity->Restore( *pRestore );

+	pRestore->GetGameSaveRestoreInfo()->SetCurrentEntityContext( NULL );

+

+#if !defined( CLIENT_DLL )

+	if ( pEntity->ObjectCaps() & FCAP_MUST_SPAWN )

+	{

+		pEntity->Spawn();

+	}

+	else

+	{

+		pEntity->Precache( );

+	}

+#endif

+

+	// Above calls may have resulted in self destruction

+	return ( hEntity != NULL );

+}

+

+//---------------------------------

+// Get a reference position in model space to compute

+// changes in model space for global brush entities (designer models them in different coords!)

+Vector CEntitySaveRestoreBlockHandler::ModelSpaceLandmark( int modelIndex )

+{

+	const model_t *pModel = modelinfo->GetModel( modelIndex );

+	if ( modelinfo->GetModelType( pModel ) != mod_brush )

+		return vec3_origin;

+

+	Vector mins, maxs;

+	modelinfo->GetModelBounds( pModel, mins, maxs );

+	return mins;

+}

+

+

+int CEntitySaveRestoreBlockHandler::RestoreEntity( CBaseEntity *pEntity, IRestore *pRestore, entitytable_t *pEntInfo )

+{

+	if ( !DoRestoreEntity( pEntity, pRestore ) )

+		return 0;

+

+#if !defined( CLIENT_DLL )		

+	if ( pEntity->m_iGlobalname != NULL_STRING ) 

+	{

+		int globalIndex = GlobalEntity_GetIndex( pEntity->m_iGlobalname );

+		if ( globalIndex >= 0 )

+		{

+			// Already dead? delete

+			if ( GlobalEntity_GetState( globalIndex ) == GLOBAL_DEAD )

+				return -1;

+			else if ( !FStrEq( STRING(gpGlobals->mapname), GlobalEntity_GetMap(globalIndex) ) )

+			{

+				pEntity->MakeDormant();	// Hasn't been moved to this level yet, wait but stay alive

+			}

+			// In this level & not dead, continue on as normal

+		}

+		else

+		{

+			Warning( "Global Entity %s (%s) not in table!!!\n", STRING(pEntity->m_iGlobalname), STRING(pEntity->m_iClassname) );

+			// Spawned entities default to 'On'

+			GlobalEntity_Add( pEntity->m_iGlobalname, gpGlobals->mapname, GLOBAL_ON );

+		}

+	}

+#endif

+

+	return 0;

+}

+

+//---------------------------------

+

+#if !defined( CLIENT_DLL )

+	

+int CEntitySaveRestoreBlockHandler::RestoreGlobalEntity( CBaseEntity *pEntity, CSaveRestoreData *pSaveData, entitytable_t *pEntInfo )

+{

+	Vector oldOffset;

+	EHANDLE hEntitySafeHandle;

+	hEntitySafeHandle = pEntity;

+

+	oldOffset.Init();

+	CRestore restoreHelper( pSaveData );

+	

+	string_t globalName = pEntInfo->globalname, className = pEntInfo->classname;

+

+	// -------------------

+

+	int globalIndex = GlobalEntity_GetIndex( globalName );

+	

+	// Don't overlay any instance of the global that isn't the latest

+	// pSaveData->szCurrentMapName is the level this entity is coming from

+	// pGlobal->levelName is the last level the global entity was active in.

+	// If they aren't the same, then this global update is out of date.

+	if ( !FStrEq( pSaveData->levelInfo.szCurrentMapName, GlobalEntity_GetMap(globalIndex) ) )

+	{

+		return 0;

+	}

+

+	// Compute the new global offset

+	CBaseEntity *pNewEntity = FindGlobalEntity( className, globalName );

+	if ( pNewEntity )

+	{

+//				Msg( "Overlay %s with %s\n", pNewEntity->GetClassname(), STRING(tmpEnt->classname) );

+		// Tell the restore code we're overlaying a global entity from another level

+		restoreHelper.SetGlobalMode( 1 );	// Don't overwrite global fields

+

+		pSaveData->modelSpaceOffset = pEntInfo->landmarkModelSpace - ModelSpaceLandmark( pNewEntity->GetModelIndex() );

+

+		UTIL_Remove( pEntity );

+		pEntity = pNewEntity;// we're going to restore this data OVER the old entity

+		pEntInfo->hEnt = pEntity;

+		// HACKHACK: Do we need system-wide support for removing non-global spawn allocated resources?

+		pEntity->VPhysicsDestroyObject();

+		Assert( pEntInfo->edictindex == -1 );

+		// Update the global table to say that the global definition of this entity should come from this level

+		GlobalEntity_SetMap( globalIndex, gpGlobals->mapname );

+	}

+	else

+	{

+		// This entity will be freed automatically by the engine->  If we don't do a restore on a matching entity (below)

+		// or call EntityUpdate() to move it to this level, we haven't changed global state at all.

+		DevMsg( "Warning: No match for global entity %s found in destination level\n", STRING(globalName) );

+		return 0;

+	}

+	

+	if ( !DoRestoreEntity( pEntity, &restoreHelper ) )

+	{

+		pEntity = NULL;

+	}

+

+	// Is this an overriding global entity (coming over the transition)

+	pSaveData->modelSpaceOffset.Init();

+	if ( pEntity )

+		return 1;

+	return 0;

+}

+

+#endif	// !defined( CLIENT_DLL )

+

+

+

+//-----------------------------------------------------------------------------

+

+CSaveRestoreData *SaveInit( int size )

+{

+	CSaveRestoreData	*pSaveData;

+

+#if ( defined( CLIENT_DLL ) || defined( DISABLE_DEBUG_HISTORY ) )

+	if ( size <= 0 )

+		size = 2*1024*1024;		// Reserve 2048K for now, UNDONE: Shrink this after compressing strings

+#else

+	if ( size <= 0 )

+		size = 3*1024*1024;		// Reserve 3096K for now, UNDONE: Shrink this after compressing strings

+#endif

+

+	int numentities;

+

+#if !defined( CLIENT_DLL )

+	numentities = gEntList.NumberOfEntities();

+#else

+	numentities = ClientEntityList().NumberOfEntities();

+#endif

+

+	void *pSaveMemory = engine->SaveAllocMemory( sizeof(CSaveRestoreData) + (sizeof(entitytable_t) * numentities) + size, sizeof(char) );

+	if ( !pSaveMemory )

+	{

+		return NULL;

+	}

+

+	pSaveData = MakeSaveRestoreData( pSaveMemory );

+	pSaveData->Init( (char *)(pSaveData + 1), size );	// skip the save structure

+	

+	const int nTokens = 0xfff; // Assume a maximum of 4K-1 symbol table entries(each of some length)

+	pSaveMemory = engine->SaveAllocMemory( nTokens, sizeof( char * ) );

+	if ( !pSaveMemory )

+	{

+		engine->SaveFreeMemory( pSaveMemory );

+		return NULL;

+	}

+

+	pSaveData->InitSymbolTable( (char **)pSaveMemory, nTokens );

+

+	//---------------------------------

+	

+	pSaveData->levelInfo.time = gpGlobals->curtime;	// Use DLL time

+	pSaveData->levelInfo.vecLandmarkOffset = vec3_origin;

+	pSaveData->levelInfo.fUseLandmark = false;

+	pSaveData->levelInfo.connectionCount = 0;

+		

+	//---------------------------------

+	

+	gpGlobals->pSaveData = pSaveData;

+

+	return pSaveData;

+}

+

+

+

+//-----------------------------------------------------------------------------

+//

+// ISaveRestoreBlockSet

+//

+// Purpose:	Serves as holder for a group of sibling save sections. Takes

+//			care of iterating over them, making sure read points are

+//			queued up to the right spot (in case one section due to datadesc

+//			changes reads less than expected, or doesn't leave the

+//			read pointer at the right point), and ensuring the read pointer

+//			is at the end of the entire set when the set read is done.

+//-----------------------------------------------------------------------------

+

+struct SaveRestoreBlockHeader_t

+{

+	char szName[MAX_BLOCK_NAME_LEN + 1];

+	int locHeader;

+	int locBody;

+

+	DECLARE_SIMPLE_DATADESC();

+};

+

+

+//-------------------------------------

+

+class CSaveRestoreBlockSet : public ISaveRestoreBlockSet

+{

+public:

+	CSaveRestoreBlockSet( const char *pszName )

+	{

+		Q_strncpy( m_Name, pszName, sizeof(m_Name) );

+	}

+

+	const char *GetBlockName()

+	{

+		return m_Name;

+	}

+

+	//---------------------------------

+

+	void PreSave( CSaveRestoreData *pData )

+	{

+		m_BlockHeaders.SetCount( m_Handlers.Count() );

+		for ( int i = 0; i < m_Handlers.Count(); i++ )

+		{

+			Q_strncpy( m_BlockHeaders[i].szName, m_Handlers[i]->GetBlockName(), MAX_BLOCK_NAME_LEN + 1 );

+			m_Handlers[i]->PreSave( pData );

+		}

+	}

+	

+	void Save( ISave *pSave )

+	{

+		int base = pSave->GetWritePos();

+		for ( int i = 0; i < m_Handlers.Count(); i++ )

+		{

+			m_BlockHeaders[i].locBody = pSave->GetWritePos() - base;

+			m_Handlers[i]->Save( pSave );

+		}

+		m_SizeBodies = pSave->GetWritePos() - base;

+	}

+	

+	void WriteSaveHeaders( ISave *pSave )

+	{

+		int base = pSave->GetWritePos();

+

+		//

+		// Reserve space for a fully populated header

+		//

+		int dummyInt = -1;

+		CUtlVector<SaveRestoreBlockHeader_t> dummyArr;

+		

+		dummyArr.SetCount( m_BlockHeaders.Count() );

+		memset( &dummyArr[0], 0xff, dummyArr.Count() * sizeof(SaveRestoreBlockHeader_t) );

+		

+		pSave->WriteInt( &dummyInt ); // size all headers

+		pSave->WriteInt( &dummyInt ); // size all bodies

+		SaveUtlVector( pSave, &dummyArr, FIELD_EMBEDDED );

+		

+		//

+		// Write the data

+		//

+		for ( int i = 0; i < m_Handlers.Count(); i++ )

+		{

+			m_BlockHeaders[i].locHeader = pSave->GetWritePos() - base;

+			m_Handlers[i]->WriteSaveHeaders( pSave );

+		}

+

+		m_SizeHeaders = pSave->GetWritePos() - base;

+		

+		//

+		// Write the actual header

+		//

+		int savedPos = pSave->GetWritePos();

+		pSave->SetWritePos(base);

+		

+		pSave->WriteInt( &m_SizeHeaders );

+		pSave->WriteInt( &m_SizeBodies );

+		SaveUtlVector( pSave, &m_BlockHeaders, FIELD_EMBEDDED );

+		

+		pSave->SetWritePos(savedPos);

+	}

+	

+	void PostSave()

+	{

+		for ( int i = 0; i < m_Handlers.Count(); i++ )

+		{

+			m_Handlers[i]->PostSave();

+		}

+		m_BlockHeaders.Purge();

+	}

+	

+	//---------------------------------

+

+	void PreRestore()

+	{

+		for ( int i = 0; i < m_Handlers.Count(); i++ )

+		{

+			m_Handlers[i]->PreRestore();

+		}

+	}

+

+	void ReadRestoreHeaders( IRestore *pRestore )

+	{

+		int base = pRestore->GetReadPos();

+		

+		pRestore->ReadInt( &m_SizeHeaders );

+		pRestore->ReadInt( &m_SizeBodies );

+		RestoreUtlVector( pRestore, &m_BlockHeaders, FIELD_EMBEDDED );

+		

+		for ( int i = 0; i < m_Handlers.Count(); i++ )

+		{

+			int location = GetBlockHeaderLoc( m_Handlers[i]->GetBlockName() );

+			if ( location != -1 )

+			{

+				pRestore->SetReadPos( base + location );

+				m_Handlers[i]->ReadRestoreHeaders( pRestore );

+			}

+		}

+		

+		pRestore->SetReadPos( base + m_SizeHeaders );

+	}

+

+	void CallBlockHandlerRestore( ISaveRestoreBlockHandler *pHandler, int baseFilePos, IRestore *pRestore, bool fCreatePlayers )

+	{

+		int location = GetBlockBodyLoc( pHandler->GetBlockName() );

+		if ( location != -1 )

+		{

+			pRestore->SetReadPos( baseFilePos + location );

+			pHandler->Restore( pRestore, fCreatePlayers );

+		}

+	}

+

+	void Restore( IRestore *pRestore, bool fCreatePlayers )

+	{

+		int base = pRestore->GetReadPos();

+		

+		for ( int i = 0; i < m_Handlers.Count(); i++ )

+		{

+			CallBlockHandlerRestore( m_Handlers[i], base, pRestore, fCreatePlayers );

+		}

+		pRestore->SetReadPos( base + m_SizeBodies );

+	}

+

+	void PostRestore()

+	{

+		for ( int i = 0; i < m_Handlers.Count(); i++ )

+		{

+			m_Handlers[i]->PostRestore();

+		}

+		m_BlockHeaders.Purge();

+	}

+

+	//---------------------------------

+

+	void AddBlockHandler( ISaveRestoreBlockHandler *pHandler )

+	{

+		// Grody, but... while this class is still isolated in saverestore.cpp, this seems like a fine time to assert:

+		AssertMsg( pHandler == &g_EntitySaveRestoreBlockHandler || (m_Handlers.Count() >= 1 && m_Handlers[0] == &g_EntitySaveRestoreBlockHandler), "Expected entity save load to always be first" );

+

+		Assert( pHandler != this );

+		m_Handlers.AddToTail( pHandler );

+	}

+

+	void RemoveBlockHandler( ISaveRestoreBlockHandler *pHandler )

+	{

+		m_Handlers.FindAndRemove( pHandler );

+	}

+

+	//---------------------------------

+

+private:

+	int GetBlockBodyLoc( const char *pszName )

+	{

+		for ( int i = 0; i < m_BlockHeaders.Count(); i++ )

+		{

+			if ( strcmp( m_BlockHeaders[i].szName, pszName ) == 0 )

+				return m_BlockHeaders[i].locBody;

+		}

+		return -1;

+	}

+	

+	int GetBlockHeaderLoc( const char *pszName )

+	{

+		for ( int i = 0; i < m_BlockHeaders.Count(); i++ )

+		{

+			if ( strcmp( m_BlockHeaders[i].szName, pszName ) == 0 )

+				return m_BlockHeaders[i].locHeader;

+		}

+		return -1;

+	}

+

+	char 								   m_Name[MAX_BLOCK_NAME_LEN + 1];

+	CUtlVector<ISaveRestoreBlockHandler *> m_Handlers;

+	

+	int									   m_SizeHeaders;

+	int									   m_SizeBodies;

+	CUtlVector<SaveRestoreBlockHeader_t>   m_BlockHeaders;

+};

+

+//-------------------------------------

+

+BEGIN_SIMPLE_DATADESC( SaveRestoreBlockHeader_t )

+	DEFINE_ARRAY(szName,	FIELD_CHARACTER, MAX_BLOCK_NAME_LEN + 1), 

+	DEFINE_FIELD(locHeader,	FIELD_INTEGER), 

+	DEFINE_FIELD(locBody,	FIELD_INTEGER), 

+END_DATADESC()

+

+//-------------------------------------

+

+CSaveRestoreBlockSet g_SaveRestoreBlockSet("Game");

+ISaveRestoreBlockSet *g_pGameSaveRestoreBlockSet = &g_SaveRestoreBlockSet;

+

+//=============================================================================

+#if !defined( CLIENT_DLL )

+

+//------------------------------------------------------------------------------

+// Creates all entities that lie in the transition list

+//------------------------------------------------------------------------------

+void CreateEntitiesInTransitionList( CSaveRestoreData *pSaveData, int levelMask )

+{

+	CBaseEntity *pent;

+	int i;

+	for ( i = 0; i < pSaveData->NumEntities(); i++ )

+	{

+		entitytable_t *pEntInfo = pSaveData->GetEntityInfo( i );

+		pEntInfo->hEnt = NULL;

+

+		if ( pEntInfo->size == 0 || pEntInfo->edictindex == 0 )

+			continue;

+

+		if ( pEntInfo->classname == NULL_STRING )

+		{

+			Warning( "Entity with data saved, but with no classname\n" );

+			Assert(0);

+			continue;

+		}

+

+		bool active = (pEntInfo->flags & levelMask) ? 1 : 0;

+

+		// spawn players

+		pent = NULL;

+		if ( (pEntInfo->edictindex > 0) && (pEntInfo->edictindex <= gpGlobals->maxClients) )	

+		{

+			edict_t *ed = INDEXENT( pEntInfo->edictindex );

+

+			if ( active && ed && !ed->IsFree() )

+			{

+				if ( !(pEntInfo->flags & FENTTABLE_PLAYER) )

+				{

+					Warning( "ENTITY IS NOT A PLAYER: %d\n" , i );

+					Assert(0);

+				}

+

+				pent = CBasePlayer::CreatePlayer( STRING(pEntInfo->classname), ed );

+			}

+		}

+		else if ( active )

+		{

+			pent = CreateEntityByName( STRING(pEntInfo->classname) );

+		}

+

+		pEntInfo->hEnt = pent;

+	}

+}

+

+

+//-----------------------------------------------------------------------------

+int CreateEntityTransitionList( CSaveRestoreData *pSaveData, int levelMask )

+{

+	CBaseEntity *pent;

+	entitytable_t *pEntInfo;

+

+	// Create entity list

+	CreateEntitiesInTransitionList( pSaveData, levelMask );

+	

+	// Now spawn entities

+	CUtlVector<int> checkList;

+

+	int i;

+	int movedCount = 0;

+	for ( i = 0; i < pSaveData->NumEntities(); i++ )

+	{

+		pEntInfo = pSaveData->GetEntityInfo( i );

+		pent = pEntInfo->hEnt;

+//		pSaveData->currentIndex = i;

+		pSaveData->Seek( pEntInfo->location );

+		

+		// clear this out - it must be set on a per-entity basis

+		pSaveData->modelSpaceOffset.Init();

+

+		if ( pent && (pEntInfo->flags & levelMask) )		// Screen out the player if he's not to be spawned

+		{

+			if ( pEntInfo->flags & FENTTABLE_GLOBAL )

+			{

+				DevMsg( 2, "Merging changes for global: %s\n", STRING(pEntInfo->classname) );

+			

+				// -------------------------------------------------------------------------

+				// Pass the "global" flag to the DLL to indicate this entity should only override

+				// a matching entity, not be spawned

+				if ( g_EntitySaveRestoreBlockHandler.RestoreGlobalEntity( pent, pSaveData, pEntInfo ) > 0 )

+				{

+					movedCount++;

+					pEntInfo->restoreentityindex = pEntInfo->hEnt.Get()->entindex();

+					AddRestoredEntity( pEntInfo->hEnt.Get() );

+				}

+				else

+				{

+					UTIL_RemoveImmediate( pEntInfo->hEnt.Get() );

+				}

+				// -------------------------------------------------------------------------

+			}

+			else 

+			{

+				DevMsg( 2, "Transferring %s (%d)\n", STRING(pEntInfo->classname), pent->edict() ? ENTINDEX(pent->edict()) : -1 );

+				CRestore restoreHelper( pSaveData );

+				if ( g_EntitySaveRestoreBlockHandler.RestoreEntity( pent, &restoreHelper, pEntInfo ) < 0 )

+				{

+					UTIL_RemoveImmediate( pent );

+				}

+				else

+				{

+					// needs to be checked.  Do this in a separate pass so that pointers & hierarchy can be traversed

+					checkList.AddToTail(i);

+				}

+			}

+

+			// Remove any entities that were removed using UTIL_Remove() as a result of the above calls to UTIL_RemoveImmediate()

+			gEntList.CleanupDeleteList();

+		}

+	}

+

+	for ( i = checkList.Count()-1; i >= 0; --i )

+	{

+		pEntInfo = pSaveData->GetEntityInfo( checkList[i] );

+		pent = pEntInfo->hEnt;

+

+		// NOTE: pent can be NULL because UTIL_RemoveImmediate (called below) removes all in hierarchy

+		if ( !pent )

+			continue;

+

+		MDLCACHE_CRITICAL_SECTION();

+

+		if ( !(pEntInfo->flags & FENTTABLE_PLAYER) && UTIL_EntityInSolid( pent ) )

+		{

+			// this can happen during normal processing - PVS is just a guess, some map areas won't exist in the new map

+			DevMsg( 2, "Suppressing %s\n", STRING(pEntInfo->classname) );

+			UTIL_RemoveImmediate( pent );

+			// Remove any entities that were removed using UTIL_Remove() as a result of the above calls to UTIL_RemoveImmediate()

+			gEntList.CleanupDeleteList();

+		}

+		else

+		{

+			movedCount++;

+			pEntInfo->flags = FENTTABLE_REMOVED;

+			pEntInfo->restoreentityindex = pent->entindex();

+			AddRestoredEntity( pent );

+		}

+	}

+

+	return movedCount;

+}

+#endif