//========= Copyright Valve Corporation, All rights reserved. ============//
//
// Purpose: 
//
// $NoKeywords: $
//=============================================================================//

#include "stdafx.h"
#include <io.h>
#include "hammer.h"
#include "GlobalFunctions.h"
#include "MapErrorsDlg.h"
#include "Options.h"
#include "MapDoc.h"
#include "MapEntity.h"
#include "MapFace.h"
#include "MapGroup.h"
#include "MapSolid.h"
#include "MapStudioModel.h"
#include "MapWorld.h"
#include "progdlg.h"
#include "TextureSystem.h"
#include "MapDisp.h"

// memdbgon must be the last include file in a .cpp file!!!
#include <tier0/memdbgon.h>

#pragma optimize("g", off)

#pragma warning(disable: 4748)		// buffer overrung with optimizations off	 - remove if we turn "g" back on

#define TEXTURE_NAME_LEN 128

// All files are opened in binary, and we want to save CR/LF
#define ENDLINE "\r\n"


enum
{
	fileOsError = -1,	// big error!
	fileError = -2,		// problem
	fileOk = -3,		// loaded ok
	fileDone = -4		// got not-my-kind of line
};


BOOL bSaveVisiblesOnly;


static BOOL bErrors;
static int nInvalidSolids;
static CProgressDlg *pProgDlg;

static MAPFORMAT MapFormat;

static BOOL bStuffed;
static char szStuffed[255];

static UINT uMapVersion = 0;


//-----------------------------------------------------------------------------
// Purpose: 
// Input  : buf - 
//-----------------------------------------------------------------------------
static void StuffLine(char * buf)
{
	Assert(!bStuffed);
	V_strcpy_safe(szStuffed, buf);
	bStuffed = TRUE;
}


//-----------------------------------------------------------------------------
// Purpose: 
// Input  : file - 
//			buf - 
//-----------------------------------------------------------------------------
static void GetLine(std::fstream& file, char *buf)
{
	if(bStuffed)
	{
		if(buf)
			strcpy(buf, szStuffed);
		bStuffed = FALSE;
		return;
	}

	char szBuf[1024];

	while(1)
	{
		file >> std::ws;
		file.getline(szBuf, 512);
		if(file.eof())
			return;
		if(!strncmp(szBuf, "//", 2))
			continue;
		file >> std::ws;
		if(buf)
		{
//			char *p = strchr(szBuf, '\n');
//			if(p) p[0] = 0;
//			p = strchr(szBuf, '\r');
//			if(p) p[0] = 0;
			strcpy(buf, szBuf);
		}
		return;
	}
}


//-----------------------------------------------------------------------------
// Purpose: 
// Input  : pObject - 
//			file - 
//			pIntersecting - 
// Output : int
//-----------------------------------------------------------------------------
static int SaveSolidChildrenOf(CMapClass *pObject, std::fstream& file, BoundBox *pIntersecting = NULL)
{
	CMapWorld *pWorld = (CMapWorld*) CMapClass::GetWorldObject(pObject);

	//
	// If we are only saving visible objects and this object isn't visible, don't save it.
	//
	if (bSaveVisiblesOnly && (pObject != pWorld) && !pObject->IsVisible())
	{
		return fileOk;	// not an error - return ok
	}
	
	//
	// If we are only saving objects within a particular bounding box and this object isn't, don't save it.
	//
	if (pIntersecting && !pObject->IsIntersectingBox(pIntersecting->bmins, pIntersecting->bmaxs))
	{
		return fileOk;
	}

	
	const CMapObjectList *pChildren = pObject->GetChildren();
	FOR_EACH_OBJ( *pChildren, pos )
	{
		int iRvl = -1;
		CMapClass *pChild = pChildren->Element(pos);

		if (!pIntersecting || pChild->IsIntersectingBox(pIntersecting->bmins, pIntersecting->bmaxs))
		{
			if (pChild->IsMapClass(MAPCLASS_TYPE(CMapSolid)))
			{
				if (!bSaveVisiblesOnly || pChild->IsVisible())
				{
					iRvl = pChild->SerializeMAP(file, TRUE);
				}
			}
			else if (pChild->IsMapClass(MAPCLASS_TYPE(CMapGroup)))
			{
				iRvl = SaveSolidChildrenOf(pChild, file, pIntersecting);
			}

			// return error if there is an error
			if (iRvl != -1 && iRvl != fileOk)
			{
				return iRvl;
			}
		}
	}

	return fileOk;	// ok.
}


//-----------------------------------------------------------------------------
// Purpose: 
// Input  : pObject - 
//			file - 
//			pIntersecting - 
// Output : int
//-----------------------------------------------------------------------------
static int SaveEntityChildrenOf(CMapClass *pObject, std::fstream& file, BoundBox *pIntersecting)
{
	CMapWorld *pWorld = (CMapWorld *)CMapClass::GetWorldObject(pObject);

	if (bSaveVisiblesOnly && pObject != pWorld && !pObject->IsVisible())
	{
		return fileOk;	// no error
	}

	if (pIntersecting && !pObject->IsIntersectingBox(pIntersecting->bmins, pIntersecting->bmaxs))
	{
		return fileOk;
	}
	
	
	const CMapObjectList *pChildren = pObject->GetChildren();
	FOR_EACH_OBJ( *pChildren, pos )
	{
		int iRvl = -1;

		CMapClass *pChild = pChildren->Element(pos);

		if (!pIntersecting || pChild->IsIntersectingBox(pIntersecting->bmins, pIntersecting->bmaxs))
		{
			if (pChild->IsMapClass(MAPCLASS_TYPE(CMapEntity)))
			{
				if (!bSaveVisiblesOnly || pChild->IsVisible())
				{
					iRvl = pChild->SerializeMAP(file, TRUE);
				}
			}
			else if (pChild->IsMapClass(MAPCLASS_TYPE(CMapGroup)))
			{
				iRvl = SaveEntityChildrenOf(pChild, file, pIntersecting);
			}

			// return error if there is an error
			if (iRvl != -1 && iRvl != fileOk)
			{
				return iRvl;
			}
		}
	}

	return fileOk;	// ok.
}


//-----------------------------------------------------------------------------
// Purpose: 
// Input  : *pObject - 
//			file - 
// Output : int
//-----------------------------------------------------------------------------
static int ReadSolids(CMapClass *pObject, std::fstream& file)
{
	int nSolids = 0;
	char szBuf[128];

	while(1)
	{
		GetLine(file, szBuf);
		if(szBuf[0] != '{')
		{
			StuffLine(szBuf);
			break;
		}

		CMapSolid *pSolid = new CMapSolid;
		int iRvl = pSolid->SerializeMAP(file, FALSE);
		if(iRvl == fileError)
		{
			// delete the solid
			delete pSolid;
			++nInvalidSolids;
		}
		else if(iRvl == fileOsError)
		{
			// big problem
			delete pSolid;
			return fileOsError;
		}
		else
			pObject->AddChild(pSolid);

		++nSolids;
	}

	return nSolids;
}


//-----------------------------------------------------------------------------
// Purpose: 
// Input  : file - 
// Output : int
//-----------------------------------------------------------------------------
static int PeekChar(std::fstream& file)
{
	if(bStuffed)	// stuffed.. return first char
		return szStuffed[0];
	char szBuf[1024];
	szBuf[0] = 0;
	// get next line
	GetLine(file, szBuf);

	// still blank? return eof
	if(szBuf[0] == 0)
		return EOF;

	// to get it next call to getline
	StuffLine(szBuf);

	return szBuf[0];
}


//-----------------------------------------------------------------------------
// Purpose: Sets the MAP format for saving.
// Input  : mf - MAP format to use when saving.
//-----------------------------------------------------------------------------
void SetMapFormat(MAPFORMAT mf)
{
	Assert((mf == mfHalfLife) || (mf == mfHalfLife2));
	MapFormat = mf;
}


//-----------------------------------------------------------------------------
// Purpose: 
// Input  : file - 
//			fIsStoring - 
// Output : int
//-----------------------------------------------------------------------------
int CMapClass::SerializeMAP(std::fstream& file, BOOL fIsStoring)
{
	// no info stored in MAPs .. 
	return fileOk;
}


//-----------------------------------------------------------------------------
// Purpose: 
// Input  : file - 
//			fIsStoring - 
// Output : int
//-----------------------------------------------------------------------------
int CMapFace::SerializeMAP(std::fstream& file, BOOL fIsStoring)
{
	char szBuf[512];

	if (fIsStoring)
	{
		char *pszTexture;
		char szTexture[sizeof(texture.texture)+1];
		szTexture[sizeof(texture.texture)] = 0;
		memcpy(szTexture, texture.texture, sizeof texture.texture);
		strlwr(szTexture);

		if (MapFormat == mfQuake2)
		{
			pszTexture = strstr(szTexture, ".");
			if (pszTexture)
			{
				*pszTexture = 0;
			}
			pszTexture = strstr(szTexture, "textures\\");
			if (pszTexture == NULL)
			{
				pszTexture = szTexture;
			}
			else
			{
				pszTexture += strlen("textures\\");
			}
		}
		else
		{
			pszTexture = szTexture;
		}

		strupr(szTexture);


		//
		// Reverse the slashes -- thank you id.
		//
		for (int i = strlen(pszTexture) - 1; i >= 0; i--)
		{
			if (pszTexture[i] == '\\')
				pszTexture[i] = '/';
		}

		//
		// Convert the plane points to integers.
		//
		for (int nPlane = 0; nPlane < 3; nPlane++)
		{
			plane.planepts[nPlane][0] = V_rint(plane.planepts[nPlane][0]);
			plane.planepts[nPlane][1] = V_rint(plane.planepts[nPlane][1]);
			plane.planepts[nPlane][2] = V_rint(plane.planepts[nPlane][2]);
		}

		//
		// Check for duplicate plane points. All three plane points must be unique
		// or it isn't a valid plane. Try to fix it if it isn't valid.
		//
		if (!CheckFace())
		{
			Fix();
		}

		sprintf(szBuf,
			"( %.0f %.0f %.0f ) ( %.0f %.0f %.0f ) ( %.0f %.0f %.0f ) "
			"%s "
			"[ %g %g %g %g ] "
			"[ %g %g %g %g ] "
			"%g %g %g ",

			plane.planepts[0][0], plane.planepts[0][1], plane.planepts[0][2],
			plane.planepts[1][0], plane.planepts[1][1], plane.planepts[1][2],
			plane.planepts[2][0], plane.planepts[2][1], plane.planepts[2][2],
	
			pszTexture,

			(double)texture.UAxis[0], (double)texture.UAxis[1], (double)texture.UAxis[2], (double)texture.UAxis[3],
			(double)texture.VAxis[0], (double)texture.VAxis[1], (double)texture.VAxis[2], (double)texture.VAxis[3],

			(double)texture.rotate, 
			(double)texture.scale[0], 
			(double)texture.scale[1]);

		file << szBuf << ENDLINE;

		return fileOk;
	}
	else
	{
		// load the plane
		GetLine(file, szBuf);

		if(szBuf[0] != '(')
		{
			StuffLine(szBuf);
			return fileDone;
		}

		char szTexName[TEXTURE_NAME_LEN];
		DWORD q2contents;
		DWORD q2surface;
		int nLightmapScale;
		int nDummy;
		int nRead;

        if( uMapVersion >= 340 )
        {
			COMPILE_TIME_ASSERT( ARRAYSIZE(szTexName) == 128 );
			nRead = sscanf(szBuf,
				"( %f %f %f ) ( %f %f %f ) ( %f %f %f ) "
				"%127s "
				"[ %f %f %f %f ] "
				"[ %f %f %f %f ] "
				"%f %f %f "
				"%u %u %u",

				&plane.planepts[0][0], &plane.planepts[0][1], &plane.planepts[0][2],
				&plane.planepts[1][0], &plane.planepts[1][1], &plane.planepts[1][2],
				&plane.planepts[2][0], &plane.planepts[2][1], &plane.planepts[2][2],
		
				szTexName,

				&texture.UAxis[0], &texture.UAxis[1], &texture.UAxis[2], &texture.UAxis[3],
				&texture.VAxis[0], &texture.VAxis[1], &texture.VAxis[2], &texture.VAxis[3],

				&texture.rotate, 
				&texture.scale[0], 
				&texture.scale[1],
				
				&q2contents,
				&q2surface,
				&nLightmapScale);
			// Guarantee null-termination to keep /analyze happy.
			szTexName[ ARRAYSIZE(szTexName) - 1 ] = 0;

			if (nRead < 21)
			{
				bErrors = TRUE;
			}
			else if (nRead == 24)
			{
				// got q2 values - set them here
				texture.q2contents = q2contents;
				texture.q2surface = q2surface;
				texture.nLightmapScale = nLightmapScale;
				if (texture.nLightmapScale == 0)
				{
					texture.nLightmapScale = g_pGameConfig->GetDefaultLightmapScale();
				}
			}

            //
            // very cheesy HACK!!! -- this will be better when we have chunks
            //
			if( uMapVersion <= 350 )
			{
				if( ( file.peek() != '(' ) && ( file.peek() != '}' ) )
				{
					EditDispHandle_t handle = EditDispMgr()->Create();
					SetDisp( handle );

					CMapDisp *pDisp = EditDispMgr()->GetDisp( handle );
					pDisp->SerializedLoadMAP( file, this, uMapVersion );
				}
			}
        }
		else if (uMapVersion >= 220 )
		{
			COMPILE_TIME_ASSERT( ARRAYSIZE(szTexName) == 128 );
			nRead = sscanf(szBuf,
				"( %f %f %f ) ( %f %f %f ) ( %f %f %f ) "
				"%127s "
				"[ %f %f %f %f ] "
				"[ %f %f %f %f ] "
				"%f %f %f "
				"%u %u %u",

				&plane.planepts[0][0], &plane.planepts[0][1], &plane.planepts[0][2],
				&plane.planepts[1][0], &plane.planepts[1][1], &plane.planepts[1][2],
				&plane.planepts[2][0], &plane.planepts[2][1], &plane.planepts[2][2],
		
				szTexName,

				&texture.UAxis[0], &texture.UAxis[1], &texture.UAxis[2], &texture.UAxis[3],
				&texture.VAxis[0], &texture.VAxis[1], &texture.VAxis[2], &texture.VAxis[3],

				&texture.rotate, 
				&texture.scale[0], 
				&texture.scale[1],
				
				&q2contents,
				&q2surface,
				&nDummy);		// Pre-340 didn't have lightmap scale.
			// Guarantee null-termination to keep /analyze happy.
			szTexName[ ARRAYSIZE(szTexName) - 1 ] = 0;

			if (nRead < 21)
			{
				bErrors = TRUE;
			}
			else if (nRead == 24)
			{
				// got q2 values - set them here
				texture.q2contents = q2contents;
				texture.q2surface = q2surface;
			}
		}
		else
		{
			COMPILE_TIME_ASSERT( ARRAYSIZE(szTexName) == 128 );
			nRead = sscanf(szBuf,
				"( %f %f %f ) ( %f %f %f ) ( %f %f %f ) "
				"%127s "
				"%f %f %f "
				"%f %f %u %u %u",

				&plane.planepts[0][0], &plane.planepts[0][1], &plane.planepts[0][2],
				&plane.planepts[1][0], &plane.planepts[1][1], &plane.planepts[1][2],
				&plane.planepts[2][0], &plane.planepts[2][1], &plane.planepts[2][2],
		
				szTexName,

				&texture.UAxis[3],
				&texture.VAxis[3],
				&texture.rotate, 
				&texture.scale[0], 
				&texture.scale[1],
				
				&q2contents,
				&q2surface,
				&nDummy);		// Pre-340 didn't have lightmap scale.
			// Guarantee null-termination to keep /analyze happy.
			szTexName[ ARRAYSIZE(szTexName) - 1 ] = 0;

			if (nRead < 15)
			{
				bErrors = TRUE;
			}
			else if (nRead == 18)
			{
				// got q2 values - set them here
				texture.q2contents = q2contents;
				texture.q2surface = q2surface;
			}
		}

		if (g_pGameConfig->GetTextureFormat() != tfVMT)
		{
			// reverse the slashes -- thank you id
			for (int i = strlen(szTexName) - 1; i >= 0; i--)
			{
				if (szTexName[i] == '/')
					szTexName[i] = '\\';
			}
		}

		SetTexture(szTexName);
	}

	if (file.fail())
	{
		return fileOsError;
	}
	return fileOk;
}


//-----------------------------------------------------------------------------
// Purpose: 
// Input  : file - 
//			fIsStoring - 
// Output : int
//-----------------------------------------------------------------------------
int MDkeyvalue::SerializeMAP(std::fstream& file, BOOL fIsStoring)
{
	// load/save a keyvalue
	char szBuf[1024];

	if(fIsStoring)
	{
		// save a keyvalue
		sprintf( szBuf,
			"\"%s\" \"%s\"",

			Key(), Value() );

		file << szBuf << ENDLINE;
	}
	else
	{
		GetLine(file, szBuf);
		if(szBuf[0] != '\"')
		{
			StuffLine(szBuf);
			return fileDone;
		}
		char *p = strchr(szBuf, '\"');
		p = strchr(p+1, '\"');
		if(!p)
			return fileError;
		p[0] = 0;
		V_strcpy_safe(szKey, szBuf+1);

		// advance to start of value string
		p = strchr(p+1, '\"');
		if(!p)
			return fileError;
		// ocpy in value
		strcpy(szValue, p+1);
		// kill trailing "
		p = strchr(szValue, '\"');
		if(!p)
			return fileError;
		p[0] = 0;
	}

	return file.fail() ? fileOsError : fileOk;
}


//-----------------------------------------------------------------------------
// Purpose: 
// Input  : file - 
//			fIsStoring - 
// Output : int
//-----------------------------------------------------------------------------
int CMapSolid::SerializeMAP(std::fstream& file, BOOL fIsStoring)
{
	CMapClass::SerializeMAP(file, fIsStoring);

	// load/save a brush
	if (fIsStoring)
	{
		// save the brush
		file << "{" << ENDLINE;

		// serialize the Faces
		int nFaces = Faces.GetCount();
		for(int i = 0; i < nFaces; i++)
		{
			if(!Faces[i].Points)
				continue;
			if(Faces[i].SerializeMAP(file, fIsStoring) == fileError)
				return fileError;
		}

		// terminator
		file << "}" << ENDLINE;
	}
	else
	{
		// caller skipped delimiter
		Faces.SetCount(0);

		// read Faces
		for(int i = 0; ; i++)
		{
			// extract plane
			if (Faces[i].SerializeMAP(file, fIsStoring) == fileDone)
			{
				// when fileDone is returned, no face was loaded
				break;
			}

			Faces[i].CalcPlane();
		}

		GetLine(file, NULL);	// ignore line

		if (!file.fail())
		{
			//
			// Create the solid using the planes that were read from the MAP file.
			//
			if (CreateFromPlanes() == FALSE)
			{
				bErrors = TRUE;
				return(fileError);
			}

			//
			// If we are reading from an old map file, the texture axes will need to be set up.
			// Leave the rotation and shifts alone; they were read from the MAP file.
			//
			if (uMapVersion < 220)
			{
				InitializeTextureAxes(TEXTURE_ALIGN_QUAKE, INIT_TEXTURE_AXES | INIT_TEXTURE_FORCE);
			}
		}
		else
		{
			return(fileOsError);
		}

		CalcBounds();

		//
		// Set solid type based on texture name.
		//
		m_eSolidType = HL1SolidTypeFromTextureName(Faces[0].texture.texture);
	}

	return(file.fail() ? fileOsError : fileOk);
}


//-----------------------------------------------------------------------------
// Purpose: 
// Input  : file - 
//			fIsStoring - 
// Output : int
//-----------------------------------------------------------------------------
int CMapEntity::SerializeMAP(std::fstream &file, BOOL fIsStoring)
{
	CMapClass::SerializeMAP(file, fIsStoring);

	// load/save an object
	if (fIsStoring)
	{
		//
		// If it's a solidentity but it doesn't have any solids, 
		// don't save it.
		//
		if (!IsPlaceholder() && !m_Children.Count())
		{
			return(fileOk);
		}

		//
		// Save it.
		//
		file << "{" << ENDLINE;

		//
		// Save keyvalues & other data.
		//
		CEditGameClass::SerializeMAP(file, fIsStoring);

		//
		// If this is a placeholder and either has no class or is not a solid class,
		// save our origin.
		//
		if (IsPlaceholder() && (!IsClass() || !IsSolidClass()))
		{
			MDkeyvalue tmpkv;
			strcpy(tmpkv.szKey, "origin");

			Vector Origin;
			GetOrigin(Origin);
			sprintf(tmpkv.szValue, "%.0f %.0f %.0f", Origin[0], Origin[1], Origin[2]);
			tmpkv.SerializeMAP(file, fIsStoring);
		}

		if (!(IsPlaceholder()))
		{
			SaveSolidChildrenOf(this, file);
		}

		file << "}" << ENDLINE;
	}
	else
	{
		// load keyvalues
		CEditGameClass::SerializeMAP(file, fIsStoring);

		// solids
		if (!ReadSolids(this, file))
		{
			flags |= flagPlaceholder;
		}

		// skip delimiter
		GetLine(file, NULL);
	}

	return file.fail() ? fileOsError : fileOk;
}


//-----------------------------------------------------------------------------
// Purpose: 
// Input  : file - 
//			fIsStoring - 
// Output : int
//-----------------------------------------------------------------------------
int CEditGameClass::SerializeMAP(std::fstream& file, BOOL fIsStoring)
{
	int iRvl;

	if (!fIsStoring)
	{
		// loading
		if (PeekChar(file) == '\"')
		{
			// read kv pairs
			MDkeyvalue newkv;
			while (1)
			{
				if (newkv.SerializeMAP(file, fIsStoring) != fileOk)
				{
					// fileDone means the keyvalue was not loaded
					break;
				}
		
				if (!strcmp(newkv.szKey, "classname"))
				{
					m_KeyValues.SetValue(newkv.szKey, newkv.szValue);
				}
				else if (!strcmp(newkv.szKey, "angle"))
				{
					ImportAngle(atoi(newkv.szValue));
				}
				else if (strcmp(newkv.szKey, "wad"))
				{
					//
					// All other keys are simply added to the keyvalue list.
					//
					m_KeyValues.SetValue(newkv.szKey, newkv.szValue);
				}
			}	
		}
	}
	else
	{
		// save keyvalues
		MDkeyvalue tmpkv;

		if (GetKeyValue("classname") == NULL)
		{
			tmpkv.Set("classname", m_szClass);
			tmpkv.SerializeMAP(file, fIsStoring);
		}

		//
		// Determine whether we have a game data class. This will help us decide which keys
		// to write.
		//
		GDclass *pGameDataClass = NULL;
		if (pGD != NULL)
		{
			pGameDataClass = pGD->ClassForName(m_szClass);
		}

		//
		// Consider all the keyvalues in this object for serialization.
		//
		for ( int z=m_KeyValues.GetFirst(); z != m_KeyValues.GetInvalidIndex(); z=m_KeyValues.GetNext( z ) )
		{
			MDkeyvalue &KeyValue = m_KeyValues.GetKeyValue(z);

			iRvl = KeyValue.SerializeMAP(file, fIsStoring);
			if (iRvl != fileOk)
			{
				return(iRvl);
			}
		}

		//
		// If we have a base class, for each keyvalue in the class definition, write out all keys
		// that are not present in the object and whose defaults are nonzero in the class definition.
		//
		if (pGameDataClass != NULL)
		{
			//
			// For each variable from the base class...
			//
			int nVariableCount = pGameDataClass->GetVariableCount();
			for (int i = 0; i < nVariableCount; i++)
			{
				GDinputvariable *pVar = pGameDataClass->GetVariableAt(i);
				Assert(pVar != NULL);

				if (pVar != NULL)
				{
					int iIndex;
					MDkeyvalue *pKey;
					LPCTSTR p = m_KeyValues.GetValue(pVar->GetName(), &iIndex);

					//
					// If the variable is not present in this object, write out the default value.
					//
					if (p == NULL) 
					{
						pKey = &tmpkv;
						pVar->ResetDefaults();
						pVar->ToKeyValue(pKey);

						//
						// Only write the key value if it is non-zero.
						//
						if ((pKey->szKey[0] != 0) && (pKey->szValue[0] != 0) && (stricmp(pKey->szValue, "0")))
						{
							iRvl = pKey->SerializeMAP(file, fIsStoring);
							if (iRvl != fileOk)
							{
								return(iRvl);
							}
						}
					}
				}
			}
		}
	}

	return(file.fail() ? fileOsError : fileOk);
}


//-----------------------------------------------------------------------------
// Purpose: 
// Input  : file - 
//			fIsStoring - 
//			pIntersecting - 
// Output : int
//-----------------------------------------------------------------------------
int CMapWorld::SerializeMAP(std::fstream &file, BOOL fIsStoring, BoundBox *pIntersecting)
{
	int iRvl;

	bStuffed = FALSE;
	bErrors = FALSE;
	nInvalidSolids = 0;

	// load/save a world
	if (fIsStoring)	
	{
		file << "{" << ENDLINE;

		// save worldobject
		CEditGameClass::SerializeMAP(file, fIsStoring);

		if (MapFormat != mfQuake2)
		{
			MDkeyvalue tmpkv;

			strcpy(tmpkv.szKey, "mapversion");
			strcpy(tmpkv.szValue, "360");
			tmpkv.SerializeMAP(file, fIsStoring);

			// Save wad file line
			strcpy(tmpkv.szKey, "wad");

			// copy all texfiles into value
			tmpkv.szValue[0] = 0;
			BOOL bFirst = TRUE;
			int nGraphicsFiles = g_Textures.FilesGetCount();
			for (int i = 0; i < nGraphicsFiles; i++)
			{
				char szFile[MAX_PATH];
				GRAPHICSFILESTRUCT gf;

				g_Textures.FilesGetInfo(&gf, i);

				//
				// Don't save WAL files - they're never used.
				//
				if (gf.format != tfWAL)
				{
					//
					// Also make sure this is the right kind of WAD file
					// based on the game we're using.
					//
					if (gf.format == g_pGameConfig->GetTextureFormat())
					{
						//
						// Append this WAD file to the WAD list.
						//
						strcpy(szFile, gf.filename);

						// dvs: Strip off the path. This crashes VIS and QRAD!!
						/*
						char *pszSlash = strrchr(szFile, '\\');
						if (pszSlash == NULL)
						{
							pszSlash = strrchr(szFile, '/');
						}

						if (pszSlash != NULL)
						{
							pszSlash++;
						}
						else
						{
							pszSlash = szFile;
						}
						*/

						char *pszSlash = szFile;

						// Strip off any drive letter.
						if (pszSlash[1] == ':')
						{
							pszSlash += 2;
						}

						// WAD names are semicolon delimited.
						if (!bFirst)
						{
							strcat(tmpkv.szValue, ";");
						}

						strcat(tmpkv.szValue, pszSlash);
						bFirst = FALSE;
					}
				}
			}

			if ( tmpkv.szValue[0] != '\0' )
			{
				tmpkv.SerializeMAP(file, fIsStoring);
			}
		}

		//
		// Save the brushes.
		//
		if (SaveSolidChildrenOf(this, file, pIntersecting) == fileOsError)
		{
			goto FatalError;
		}

		file << "}" << ENDLINE;

		//
		// Save the entities.
		//
		if (SaveEntityChildrenOf(this, file, pIntersecting) == fileOsError)
		{
			goto FatalError;
		}

		//
		// Save paths (if paths are visible).
		//
		FOR_EACH_OBJ( m_Paths, pos )
		{
			CMapPath *pPath = m_Paths.Element(pos);
			pPath->SerializeMAP(file, TRUE, pIntersecting);
		}
	}
	else
	{
		pProgDlg = new CProgressDlg;
		pProgDlg->Create();
		pProgDlg->SetStep(1);
		
		CString caption;
		caption.LoadString(IDS_LOADINGFILE);
		pProgDlg->SetWindowText(caption);

		m_Render2DBox.ResetBounds();

		// load world
		GetLine(file, NULL);	// ignore delimiter
		CEditGameClass::SerializeMAP(file, fIsStoring);

		const char* pszMapVersion;

		pszMapVersion = m_KeyValues.GetValue("mapversion");
		if (pszMapVersion != NULL)
		{
			uMapVersion = atoi(pszMapVersion);
		}
		else
		{
			uMapVersion = 0;
		}

		// read solids
		if (ReadSolids(this, file) == fileOsError)
		{
			goto FatalError;
		}

		// skip end-of-entity marker
		GetLine(file, NULL);

		char szBuf[128];

		// read entities
		while (1)
		{
			GetLine(file, szBuf);
			if (szBuf[0] != '{')
			{
				StuffLine(szBuf);
				break;
			}

			if (PeekChar(file) == EOF)
			{
				break;
			}

			CMapEntity *pEntity;

			pEntity = new CMapEntity;
			iRvl = pEntity->SerializeMAP(file, fIsStoring);
			AddChild(pEntity);
			
			if (iRvl == fileError)
			{
				bErrors = TRUE;
			}
			else if (iRvl == fileOsError)
			{
				goto FatalError;
			}
		}

		if (bErrors)
		{
			if (nInvalidSolids)
			{
				CString str;
				str.Format("For your information, %d solids were not loaded\n"
					"due to errors in the file.", nInvalidSolids); 
				AfxMessageBox(str);
			}
			else if (AfxMessageBox("There was a problem loading the MAP file. Do you\n"
				"want to view the error report?", MB_YESNO) == IDYES)
			{
				CMapErrorsDlg dlg;
				dlg.DoModal();
			}
		}

		PostloadWorld();

		if (g_pGameConfig->GetTextureFormat() == tfVMT)
		{
			// do batch search and replace of textures from trans.txt if it exists.
			char translationFilename[MAX_PATH];
			Q_snprintf( translationFilename, sizeof( translationFilename ), "materials/trans.txt" );
			if( CMapDoc::GetActiveMapDoc() )
			{
				FileHandle_t searchReplaceFP = g_pFileSystem->Open( translationFilename, "r" );
				if( searchReplaceFP )
				{
					CMapDoc::GetActiveMapDoc()->BatchReplaceTextures( searchReplaceFP );
					g_pFileSystem->Close( searchReplaceFP );
				}
			}
		}
	}

	if (pProgDlg)
	{
		pProgDlg->DestroyWindow();
		delete pProgDlg;
		pProgDlg = NULL;
	}

	return (bErrors && fIsStoring) ? -1 : 0;

FatalError:

	// OS error.
	CString str;
	str.Format("The OS reported an error %s the file: %s", fIsStoring ? "saving" : "loading", strerror(errno));
	AfxMessageBox(str);

	if (pProgDlg != NULL)
	{
		pProgDlg->DestroyWindow();
		delete pProgDlg;
		pProgDlg = NULL;
	}

	return -1;
}