1HEADmaster

1 files changed, 1772 insertions, 0 deletions

diff --git a/hammer/mapcheckdlg.cpp b/hammer/mapcheckdlg.cpp
new file mode 100644
index 0000000..f9b839f
--- /dev/null
+++ b/hammer/mapcheckdlg.cpp
@@ -0,0 +1,1772 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+//=============================================================================//
+
+#include "stdafx.h"
+#include "GameConfig.h"
+#include "GlobalFunctions.h"
+#include "History.h"
+#include "MainFrm.h"
+#include "MapCheckDlg.h"
+#include "MapDoc.h"
+#include "MapEntity.h"
+#include "MapSolid.h"
+#include "MapWorld.h"
+#include "Options.h"
+#include "ToolManager.h"
+#include "VisGroup.h"
+#include "hammer.h"
+#include "MapOverlay.h"
+#include "Selection.h"
+
+// memdbgon must be the last include file in a .cpp file!!!
+#include <tier0/memdbgon.h>
+
+
+// ********
+// NOTE: Make sure the order matches g_MapErrorStringIDs below!
+// ********
+typedef enum
+{
+	ErrorNoPlayerStart,
+	ErrorMixedFace,
+	ErrorDuplicatePlanes,
+	ErrorMissingTarget,
+	ErrorInvalidTexture,
+	ErrorSolidStructure,
+	ErrorUnusedKeyvalues,
+	ErrorEmptyEntity,
+	ErrorDuplicateKeys,
+	ErrorSolidContents,
+	ErrorInvalidTextureAxes,
+	ErrorDuplicateFaceIDs,
+	ErrorDuplicateNodeIDs,
+	ErrorBadConnections,
+	ErrorHiddenGroupHiddenChildren,
+	ErrorHiddenGroupVisibleChildren,
+	ErrorHiddenGroupMixedChildren,
+	ErrorHiddenObjectNoVisGroup,
+	ErrorHiddenChildOfEntity,
+	ErrorIllegallyHiddenObject,
+	ErrorKillInputRaceCondition,
+	ErrorOverlayFaceList,
+} MapErrorType;
+
+// ********
+// NOTE: Make sure the order matches MapErrorType above!
+// ********
+struct
+{
+	int	m_StrResourceID;
+	int m_DescriptionResourceID;
+} g_MapErrorStrings[] =
+{
+	{IDS_NOPLAYERSTART,					IDS_NOPLAYERSTART_DESC},
+	{IDS_MIXEDFACES,					IDS_MIXEDFACES_DESC},
+	{IDS_DUPLICATEPLANES,				IDS_DUPLICATEPLANES_DESC},
+	{IDS_UNMATCHEDTARGET,				IDS_UNMATCHEDTARGET_DESC},
+	{IDS_INVALIDTEXTURE,				IDS_INVALIDTEXTURE_DESC},
+	{IDS_SOLIDSTRUCTURE,				IDS_SOLIDSTRUCTURE_DESC},
+	{IDS_UNUSEDKEYVALUES,				IDS_UNUSEDKEYVALUES_DESC},
+	{IDS_EMPTYENTITY,					IDS_EMPTYENTITY_DESC},
+	{IDS_DUPLICATEKEYS,					IDS_DUPLICATEKEYS_DESC},
+	{IDS_SOLIDCONTENT,					IDS_SOLIDCONTENT_DESC},
+	{IDS_INVALIDTEXTUREAXES,			IDS_INVALIDTEXTUREAXES_DESC},
+	{IDS_DUPLICATEFACEID,				IDS_DUPLICATEFACEID_DESC},
+	{IDS_DUPLICATE_NODE_ID,				IDS_DUPLICATE_NODE_ID_DESC},
+	{IDS_BAD_CONNECTIONS,				IDS_BAD_CONNECTIONS_DESC},
+	{IDS_HIDDEN_GROUP_HIDDEN_CHILDREN,	IDS_HIDDEN_GROUP_HIDDEN_CHILDREN_DESC},
+	{IDS_HIDDEN_GROUP_VISIBLE_CHILDREN, IDS_HIDDEN_GROUP_VISIBLE_CHILDREN_DESC},
+	{IDS_HIDDEN_GROUP_MIXED_CHILDREN,	IDS_HIDDEN_GROUP_MIXED_CHILDREN_DESC},
+	{IDS_HIDDEN_NO_VISGROUP,			IDS_HIDDEN_NO_VISGROUP_DESC},
+	{IDS_HIDDEN_CHILD_OF_ENTITY,		IDS_HIDDEN_CHILD_OF_ENTITY_DESC},
+	{IDS_HIDDEN_ILLEGALLY,				IDS_HIDDEN_ILLEGALLY_DESC},
+	{IDS_KILL_INPUT_RACE_CONDITION,		IDS_KILL_INPUT_RACE_CONDITION_DESC},
+	{IDS_BAD_OVERLAY,					IDS_DAB_OVERLAY_DESC}
+};
+
+
+
+typedef enum
+{
+	CantFix,
+	NeedsFix,
+	Fixed,
+} FIXCODE;
+
+
+struct MapError
+{
+	CMapClass *pObjects[3];
+	MapErrorType Type;
+	DWORD dwExtra;
+	FIXCODE Fix;
+};
+
+
+//
+// Fix functions.
+//
+static void FixDuplicatePlanes(MapError *pError);
+static void FixSolidStructure(MapError *pError);
+static void FixInvalidTexture(MapError *pError);
+static void FixInvalidTextureAxes(MapError *pError);
+static void FixUnusedKeyvalues(MapError *pError);
+static void FixEmptyEntity(MapError *pError);
+static void FixBadConnections(MapError *pError);
+static void FixInvalidContents(MapError *pError);
+static void FixDuplicateFaceIDs(MapError *pError);
+static void FixDuplicateNodeIDs(MapError *pError);
+static void FixMissingTarget(MapError *pError);
+void FixHiddenObject(MapError *pError);
+static void FixKillInputRaceCondition(MapError *pError);
+static void FixOverlayFaceList(MapError *pError);
+
+
+CMapCheckDlg *s_pDlg = NULL;
+
+
+BEGIN_MESSAGE_MAP(CMapCheckDlg, CDialog)
+	//{{AFX_MSG_MAP(CMapCheckDlg)
+	ON_BN_CLICKED(IDC_GO, OnGo)
+	ON_LBN_SELCHANGE(IDC_ERRORS, OnSelchangeErrors)
+	ON_LBN_DBLCLK(IDC_ERRORS, OnDblClkErrors)
+	ON_WM_PAINT()
+	ON_BN_CLICKED(IDC_FIX, OnFix)
+	ON_BN_CLICKED(IDC_FIXALL, OnFixall)
+	ON_WM_DESTROY()
+	ON_WM_CLOSE()
+	ON_BN_CLICKED(IDC_CHECK_VISIBLE_ONLY, OnCheckVisibleOnly)
+	//}}AFX_MSG_MAP
+END_MESSAGE_MAP()
+
+
+//-----------------------------------------------------------------------------
+// Visibility check
+//-----------------------------------------------------------------------------
+inline bool IsCheckVisible( CMapClass *pClass )
+{
+	return (Options.general.bCheckVisibleMapErrors == FALSE) || pClass->IsVisible();
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CMapCheckDlg::CheckForProblems(CWnd *pwndParent)
+{
+	if (!s_pDlg)
+	{
+		s_pDlg = new CMapCheckDlg;
+		s_pDlg->Create(IDD, pwndParent);
+	}
+
+	if (!s_pDlg->DoCheck())
+	{
+		// Found problems.
+		s_pDlg->ShowWindow(SW_SHOW);
+	}
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Input  : pParent - 
+//-----------------------------------------------------------------------------
+CMapCheckDlg::CMapCheckDlg(CWnd *pParent)
+	: CDialog(CMapCheckDlg::IDD, pParent)
+{
+	//{{AFX_DATA_INIT(CMapCheckDlg)
+	m_bCheckVisible = FALSE;
+	//}}AFX_DATA_INIT
+
+	m_bCheckVisible = Options.general.bCheckVisibleMapErrors;
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Input  : pDX - 
+//-----------------------------------------------------------------------------
+void CMapCheckDlg::DoDataExchange(CDataExchange* pDX)
+{
+	CDialog::DoDataExchange(pDX);
+
+	//{{AFX_DATA_MAP(CMapCheckDlg)
+	DDX_Control(pDX, IDC_FIXALL, m_cFixAll);
+	DDX_Control(pDX, IDC_FIX, m_Fix);
+	DDX_Control(pDX, IDC_GO, m_Go);
+	DDX_Control(pDX, IDC_DESCRIPTION, m_Description);
+	DDX_Control(pDX, IDC_ERRORS, m_Errors);
+	DDX_Check(pDX, IDC_CHECK_VISIBLE_ONLY, m_bCheckVisible);
+	//}}AFX_DATA_MAP
+
+	if ( pDX->m_bSaveAndValidate )
+	{
+		Options.general.bCheckVisibleMapErrors = m_bCheckVisible;
+	}
+}
+
+
+//-----------------------------------------------------------------------------
+// Checkbox indicating whether we should check visible errors
+//-----------------------------------------------------------------------------
+void CMapCheckDlg::OnCheckVisibleOnly()
+{
+	UpdateData( TRUE );
+	DoCheck();
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Selects the current error objects and centers the views on it.
+//-----------------------------------------------------------------------------
+void CMapCheckDlg::OnGo() 
+{
+	GotoSelectedErrors();
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CMapCheckDlg::GotoSelectedErrors()
+{
+	int iSel = m_Errors.GetCurSel();
+	if (iSel == LB_ERR)
+	{
+		return;
+	}
+
+	ToolManager()->SetTool(TOOL_POINTER);
+
+	CMapObjectList Objects;
+	for (int i = 0; i < m_Errors.GetCount(); i++)
+	{
+		if (m_Errors.GetSel(i) > 0)
+		{
+			MapError *pError = (MapError *)m_Errors.GetItemDataPtr(i);
+			if (pError)
+			{
+				Objects.AddToTail(pError->pObjects[0]);
+			}
+		}
+	}
+
+	CMapDoc *pDoc = CMapDoc::GetActiveMapDoc();
+
+	pDoc->SelectObjectList(&Objects);
+	pDoc->CenterViewsOnSelection();
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Fixes all the selected errors.
+//-----------------------------------------------------------------------------
+void CMapCheckDlg::OnFix() 
+{
+	int iSel = m_Errors.GetCurSel();
+	if (iSel == LB_ERR)
+	{
+		return;
+	}
+
+	UpdateBox ub;
+	CMapObjectList Objects;
+	ub.Objects = &Objects;
+
+	for (int i = 0; i < m_Errors.GetCount(); i++)
+	{
+		if (m_Errors.GetSel(i) > 0)
+		{
+			MapError *pError = (MapError *)m_Errors.GetItemDataPtr(i);
+			if (pError)
+			{
+				Fix(pError, ub);
+			}
+		}
+	}
+
+	OnSelchangeErrors();
+	CMapDoc::GetActiveMapDoc()->UpdateAllViews( MAPVIEW_UPDATE_OBJECTS );
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Input  : pError - 
+//			ub - 
+//-----------------------------------------------------------------------------
+void CMapCheckDlg::Fix(MapError *pError, UpdateBox &ub)
+{
+	CMapDoc::GetActiveMapDoc()->SetModifiedFlag();
+
+	if (pError->Fix != NeedsFix)
+	{
+		// should never get here because this button is supposed 
+		//  to be disabled if the error cannot be fixed
+		return;
+	}
+
+	//
+	// Expand the bounds of the update region to include the broken objects.
+	//
+	for (int i = 0; i < 2; i++)
+	{
+		if (!pError->pObjects[i])
+		{
+			continue;
+		}
+
+		ub.Objects->AddToTail(pError->pObjects[i]);
+
+		Vector mins;
+		Vector maxs;
+		pError->pObjects[i]->GetRender2DBox(mins, maxs);
+		ub.Box.UpdateBounds(mins, maxs);
+	}
+
+	//
+	// Perform the fix.
+	//
+	switch (pError->Type)
+	{
+		case ErrorDuplicatePlanes:
+		{
+			FixDuplicatePlanes(pError);
+			break;
+		}
+		case ErrorDuplicateFaceIDs:
+		{
+			FixDuplicatePlanes(pError);
+			break;
+		}
+		case ErrorDuplicateNodeIDs:
+		{
+			FixDuplicateNodeIDs(pError);
+			break;
+		}
+		case ErrorMissingTarget:
+		{
+			FixMissingTarget(pError);
+			break;
+		}
+		case ErrorSolidStructure:
+		{
+			FixSolidStructure(pError);
+			break;
+		}
+		case ErrorSolidContents:
+		{
+			FixInvalidContents(pError);
+			break;
+		}
+		case ErrorInvalidTexture:
+		{
+			FixInvalidTexture(pError);
+			break;
+		}
+		case ErrorInvalidTextureAxes:
+		{
+			FixInvalidTextureAxes(pError);
+			break;
+		}
+		case ErrorUnusedKeyvalues:
+		{
+			FixUnusedKeyvalues(pError);
+			break;
+		}
+		case ErrorBadConnections:
+		{
+			FixBadConnections(pError);
+			break;
+		}
+		case ErrorEmptyEntity:
+		{
+			FixEmptyEntity(pError);
+			break;
+		}
+		case ErrorHiddenGroupVisibleChildren:
+		case ErrorHiddenGroupMixedChildren:
+		case ErrorHiddenGroupHiddenChildren:
+		case ErrorHiddenObjectNoVisGroup:
+		case ErrorHiddenChildOfEntity:
+		case ErrorIllegallyHiddenObject:
+		{
+			FixHiddenObject(pError);
+			break;
+		}
+		case ErrorKillInputRaceCondition:
+		{
+			FixKillInputRaceCondition(pError);
+			break;
+		}
+		case ErrorOverlayFaceList:
+		{
+			FixOverlayFaceList( pError );
+			break;
+		}
+	}
+
+	pError->Fix = Fixed;
+
+	//
+	// Expand the bounds of the update region to include the fixed objects.
+	//
+	for (int i = 0; i < 2; i++)
+	{
+		if (!pError->pObjects[i])
+		{
+			continue;
+		}
+
+		Vector mins;
+		Vector maxs;
+		pError->pObjects[i]->GetRender2DBox(mins, maxs);
+		ub.Box.UpdateBounds(mins, maxs);
+	}
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CMapCheckDlg::OnFixall() 
+{
+	int iSel = m_Errors.GetCurSel();
+	if (iSel == LB_ERR)
+	{
+		return;
+	}
+
+	MapError *pError = (MapError *) m_Errors.GetItemDataPtr(iSel);
+
+	if (pError->Fix == CantFix)
+	{
+		// should never get here because this button is supposed 
+		//  to be disabled if the error cannot be fixed
+		return;
+	}
+
+	UpdateBox ub;
+	CMapObjectList Objects;
+	ub.Objects = &Objects;
+
+	// For every selected error...
+	for (int i = 0; i < m_Errors.GetCount(); i++)
+	{
+		if (m_Errors.GetSel(i) > 0)
+		{
+			pError = (MapError *)m_Errors.GetItemDataPtr(i);
+			if ((pError) && (pError->Fix == NeedsFix))
+			{
+				// Find and fix every error of the same type.
+				for (int j = 0; j < m_Errors.GetCount(); j++)
+				{
+					MapError *pError2 = (MapError *)m_Errors.GetItemDataPtr(j);
+					if ((pError2->Type != pError->Type) || (pError2->Fix != NeedsFix))
+					{
+						continue;
+					}
+
+					Fix(pError2, ub);
+				}
+			}
+		}
+	}
+
+	OnSelchangeErrors();
+	CMapDoc::GetActiveMapDoc()->UpdateAllViews( MAPVIEW_UPDATE_OBJECTS );
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CMapCheckDlg::OnSelchangeErrors() 
+{
+	// change description to match error
+	int iSel = m_Errors.GetCurSel();
+
+	if(iSel == LB_ERR)
+	{
+		m_Fix.EnableWindow(FALSE);
+		m_cFixAll.EnableWindow(FALSE);
+		m_Go.EnableWindow(FALSE);
+	}
+
+	CString str;
+	MapError *pError;
+	pError = (MapError*) m_Errors.GetItemDataPtr(iSel);
+
+	// Figure out which error string we're using.
+	int iErrorStr = (int)pError->Type;
+	iErrorStr = clamp( iErrorStr, 0, ARRAYSIZE( g_MapErrorStrings ) - 1 );
+	Assert( iErrorStr == (int)pError->Type );
+	
+	str.LoadString(g_MapErrorStrings[iErrorStr].m_DescriptionResourceID);
+	m_Description.SetWindowText(str);
+
+	m_Go.EnableWindow(pError->pObjects[0] != NULL);
+
+	// set state of fix button
+	m_Fix.EnableWindow(pError->Fix == NeedsFix);
+	m_cFixAll.EnableWindow(pError->Fix != CantFix);
+
+	// set text of fix button
+	switch (pError->Fix)
+	{
+		case NeedsFix:
+			m_Fix.SetWindowText("&Fix");
+			break;
+		case CantFix:
+			m_Fix.SetWindowText("Can't fix");
+			break;
+		case Fixed:
+			m_Fix.SetWindowText("(fixed)");
+			break;
+	}
+
+	CMapDoc *pDoc = CMapDoc::GetActiveMapDoc();
+
+	pDoc->GetSelection()->SetMode(selectObjects);
+	
+	if (pError->pObjects[0])
+	{
+		pDoc->SelectObject(pError->pObjects[0], scClear|scSelect|scSaveChanges );
+	}
+	else
+	{
+		pDoc->SelectObject(NULL, scClear|scSaveChanges );
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CMapCheckDlg::OnDblClkErrors() 
+{
+	GotoSelectedErrors();	
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CMapCheckDlg::OnPaint() 
+{
+	CPaintDC dc(this); // device context for painting
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CMapCheckDlg::KillErrorList()
+{
+	// delete items in list.. their data ptrs are allocated objects
+	int iSize = m_Errors.GetCount();
+	for(int i = 0; i < iSize; i++)
+	{
+		MapError *pError = (MapError*) m_Errors.GetItemDataPtr(i);
+		delete pError;
+	}
+
+	m_Errors.ResetContent();
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Builds the listbox string for the given error and adds it to the list.
+//-----------------------------------------------------------------------------
+static void AddErrorToListBox(CListBox *pList, MapError *pError)
+{
+	CString str;
+
+	// Figure out which error string we're using.
+	int iErrorStr = (int)pError->Type;
+	iErrorStr = clamp( iErrorStr, 0, ARRAYSIZE( g_MapErrorStrings ) - 1 );
+	Assert( iErrorStr == (int)pError->Type );
+	
+	str.LoadString(g_MapErrorStrings[iErrorStr].m_StrResourceID);
+
+	if (str.Find('%') != -1)
+	{
+		if (pError->Type == ErrorUnusedKeyvalues)
+		{
+			// dwExtra has the name of the string in it
+			CString str2 = str;
+			CMapEntity *pEntity = (CMapEntity *)pError->pObjects[0];
+			str.Format(str2, pEntity->GetClassName(), pError->dwExtra);
+		}
+		else
+		{
+			CString str2 = str;
+			str.Format(str2, pError->dwExtra);
+		}
+	}
+
+	int iIndex = pList->AddString(str);
+	pList->SetItemDataPtr(iIndex, (PVOID)pError);
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Input  : pList - 
+//			Type - 
+//			dwExtra - 
+//			... - 
+//-----------------------------------------------------------------------------
+static void AddError(CListBox *pList, MapErrorType Type, DWORD dwExtra, ...)
+{
+	MapError *pError = new MapError;
+	memset(pError, 0, sizeof(MapError));
+
+	pError->Type = Type;
+	pError->dwExtra = dwExtra;
+	pError->Fix = CantFix;
+
+	va_list vl;
+	va_start(vl, dwExtra);
+
+	//
+	// Get the object pointer from the variable argument list.
+	//
+	switch (Type)
+	{
+		case ErrorNoPlayerStart:
+		{
+			// no objects.
+			break;
+		}
+
+		case ErrorMixedFace:
+		case ErrorMissingTarget:
+		case ErrorDuplicatePlanes:
+		case ErrorDuplicateFaceIDs:
+		case ErrorDuplicateNodeIDs:
+		case ErrorSolidStructure:
+		case ErrorSolidContents:
+		case ErrorInvalidTexture:
+		case ErrorUnusedKeyvalues:
+		case ErrorBadConnections:
+		case ErrorEmptyEntity:
+		case ErrorDuplicateKeys:
+		case ErrorInvalidTextureAxes:
+		case ErrorHiddenGroupHiddenChildren:
+		case ErrorHiddenGroupVisibleChildren:
+		case ErrorHiddenGroupMixedChildren:
+		case ErrorHiddenObjectNoVisGroup:
+		case ErrorHiddenChildOfEntity:
+		case ErrorIllegallyHiddenObject:
+		case ErrorOverlayFaceList:
+		{
+			pError->pObjects[0] = va_arg(vl, CMapClass *);
+			break;
+		}
+
+		case ErrorKillInputRaceCondition:
+		{
+			pError->pObjects[0] = va_arg(vl, CMapClass *);
+			pError->dwExtra = (DWORD)va_arg(vl, CEntityConnection *);
+			break;
+		}
+	}
+
+	//
+	// Set the can fix flag.
+	//
+	switch (Type)
+	{
+		case ErrorSolidContents:
+		case ErrorDuplicatePlanes:
+		case ErrorDuplicateFaceIDs:
+		case ErrorDuplicateNodeIDs:
+		case ErrorSolidStructure:
+		case ErrorInvalidTexture:
+		case ErrorUnusedKeyvalues:
+		case ErrorMissingTarget:
+		case ErrorBadConnections:
+		case ErrorEmptyEntity:
+		case ErrorDuplicateKeys:
+		case ErrorInvalidTextureAxes:
+		case ErrorHiddenGroupHiddenChildren:
+		case ErrorHiddenGroupVisibleChildren:
+		case ErrorHiddenGroupMixedChildren:
+		case ErrorHiddenObjectNoVisGroup:
+		case ErrorHiddenChildOfEntity:
+		case ErrorIllegallyHiddenObject:
+		case ErrorKillInputRaceCondition:
+		case ErrorOverlayFaceList:
+		{
+			pError->Fix = NeedsFix;
+			break;
+		}
+	}
+
+	va_end(vl);
+
+	AddErrorToListBox(pList, pError);
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Input  : pObject - 
+//			DWORD - 
+// Output : 
+//-----------------------------------------------------------------------------
+static BOOL FindPlayer(CMapEntity *pObject, DWORD)
+{
+	if ( !IsCheckVisible( pObject ) )
+		return TRUE;
+
+	if (pObject->IsPlaceholder() && pObject->IsClass("info_player_start"))
+	{
+		return(FALSE);
+	}
+	return(TRUE);
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Input  : pList - 
+//			pWorld - 
+//-----------------------------------------------------------------------------
+static void CheckRequirements(CListBox *pList, CMapWorld *pWorld)
+{
+	// ensure there's a player start .. 
+	if (pWorld->EnumChildren((ENUMMAPCHILDRENPROC)FindPlayer, 0, MAPCLASS_TYPE(CMapEntity)))
+	{
+		// if rvl is !0, it was not stopped prematurely.. which means there is 
+		// NO player start.
+		AddError(pList, ErrorNoPlayerStart, 0);
+	}
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Input  : pSolid - 
+//			pList - 
+// Output : 
+//-----------------------------------------------------------------------------
+static BOOL _CheckMixedFaces(CMapSolid *pSolid, CListBox *pList)
+{
+	if ( !IsCheckVisible( pSolid ) )
+		return TRUE;
+
+	// run thru faces..
+	int iFaces = pSolid->GetFaceCount();
+	int iSolid = 2;	// start off ambivalent
+	int i;
+	for(i = 0; i < iFaces; i++)
+	{
+		CMapFace *pFace = pSolid->GetFace(i);
+
+		char ch = pFace->texture.texture[0];
+		if((ch == '*' && iSolid == 1) || (ch != '*' && iSolid == 0))
+		{
+			break;
+		}
+		else iSolid = (ch == '*') ? 0 : 1;
+	}
+
+	if(i == iFaces)	// all ok
+		return TRUE;
+
+	// NOT ok
+	AddError(pList, ErrorMixedFace, 0, pSolid);
+
+	return TRUE;
+}
+
+
+static void CheckMixedFaces(CListBox *pList, CMapWorld *pWorld)
+{
+	pWorld->EnumChildren((ENUMMAPCHILDRENPROC)_CheckMixedFaces, (DWORD)pList, MAPCLASS_TYPE(CMapSolid));
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Returns true if there is another node entity in the world with the
+//			same node ID as the given entity.
+// Input  : pNode - 
+//			pWorld - 
+//-----------------------------------------------------------------------------
+bool FindDuplicateNodeID(CMapEntity *pNode, CMapWorld *pWorld)
+{
+	if ( !IsCheckVisible( pNode ) )
+		return false;
+
+	EnumChildrenPos_t pos;
+	CMapClass *pChild = pWorld->GetFirstDescendent(pos);
+	while (pChild != NULL)
+	{
+		CMapEntity *pEntity = dynamic_cast<CMapEntity *>(pChild);
+		if (pEntity && IsCheckVisible( pEntity ) && (pEntity != pNode) && pEntity->IsNodeClass())
+		{
+			int nNodeID1 = pNode->GetNodeID();
+			int nNodeID2 = pEntity->GetNodeID();
+			if ((nNodeID1 != 0) && (nNodeID2 != 0) && (nNodeID1 == nNodeID2))
+			{
+				return true;
+			}
+		}
+		
+		pChild = pWorld->GetNextDescendent(pos);
+	}
+
+	return false;
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Checks for node entities with the same node ID.
+//-----------------------------------------------------------------------------
+static void CheckDuplicateNodeIDs(CListBox *pList, CMapWorld *pWorld)
+{
+	EnumChildrenPos_t pos;
+	CMapClass *pChild = pWorld->GetFirstDescendent(pos);
+	while (pChild != NULL)
+	{
+		CMapEntity *pEntity = dynamic_cast<CMapEntity *>(pChild);
+		if (pEntity && pEntity->IsNodeClass())
+		{
+			if (FindDuplicateNodeID(pEntity, pWorld))
+			{
+				AddError(pList, ErrorDuplicateNodeIDs, (DWORD)pWorld, pEntity);
+			}
+		}
+		
+		pChild = pWorld->GetNextDescendent(pos);
+	}
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Checks for faces with identical face normals in this solid object.
+// Input  : pSolid - Solid to check for duplicate faces.
+// Output : Returns TRUE if the face contains at least one duplicate face,
+//			FALSE if the solid contains no duplicate faces.
+//-----------------------------------------------------------------------------
+BOOL DoesContainDuplicates(CMapSolid *pSolid)
+{
+	int iFaces = pSolid->GetFaceCount();
+	for (int i = 0; i < iFaces; i++)
+	{
+		CMapFace *pFace = pSolid->GetFace(i);
+		Vector& pts1 = pFace->plane.normal;
+
+		for (int j = 0; j < iFaces; j++)
+		{
+			// Don't check self.
+			if (j == i)
+			{
+				continue;
+			}
+
+			CMapFace *pFace2 = pSolid->GetFace(j);
+			Vector& pts2 = pFace2->plane.normal;
+
+			if (pts1 == pts2)
+			{
+				return(TRUE);
+			}
+		}
+	}
+	
+	return(FALSE);
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Input  : pSolid - 
+//			pList - 
+// Output : 
+//-----------------------------------------------------------------------------
+static BOOL _CheckDuplicatePlanes(CMapSolid *pSolid, CListBox *pList)
+{
+	if ( !IsCheckVisible( pSolid ) )
+		return TRUE;
+
+	if (DoesContainDuplicates(pSolid))
+	{
+		AddError(pList, ErrorDuplicatePlanes, 0, pSolid);
+	}
+
+	return(TRUE);
+}
+
+
+static void CheckDuplicatePlanes(CListBox *pList, CMapWorld *pWorld)
+{
+	pWorld->EnumChildren((ENUMMAPCHILDRENPROC)_CheckDuplicatePlanes, (DWORD)pList, MAPCLASS_TYPE(CMapSolid));
+}
+
+
+struct FindDuplicateFaceIDs_t
+{
+	CMapFaceList All;					// Collects all the face IDs in this map.
+	CMapFaceList Duplicates;			// Collects the duplicate face IDs in this map.
+};
+
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Input  : pSolid - 
+//			pData - 
+// Output : Returns TRUE to continue enumerating.
+//-----------------------------------------------------------------------------
+static BOOL _CheckDuplicateFaceIDs(CMapSolid *pSolid, FindDuplicateFaceIDs_t *pData)
+{
+	if ( !IsCheckVisible( pSolid ) )
+		return TRUE;
+
+	int nFaceCount = pSolid->GetFaceCount();
+	for (int i = 0; i < nFaceCount; i++)
+	{
+		CMapFace *pFace = pSolid->GetFace(i);
+		if (pData->All.FindFaceID(pFace->GetFaceID()) != -1)
+		{
+			if (pData->Duplicates.FindFaceID(pFace->GetFaceID()) != -1)
+			{
+				pData->Duplicates.AddToTail(pFace);
+			}
+		}
+		else
+		{
+			pData->All.AddToTail(pFace);
+		}
+	}
+
+	return(TRUE);
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Reports errors for all faces with duplicate face IDs.
+// Input  : pList - 
+//			pWorld -  
+//-----------------------------------------------------------------------------
+static void CheckDuplicateFaceIDs(CListBox *pList, CMapWorld *pWorld)
+{
+	FindDuplicateFaceIDs_t Lists;
+	Lists.All.SetGrowSize(128);
+	Lists.Duplicates.SetGrowSize(128);
+
+	pWorld->EnumChildren((ENUMMAPCHILDRENPROC)_CheckDuplicateFaceIDs, (DWORD)&Lists, MAPCLASS_TYPE(CMapSolid));
+
+	for (int i = 0; i < Lists.Duplicates.Count(); i++)
+	{
+		CMapFace *pFace = Lists.Duplicates.Element(i);
+		AddError(pList, ErrorDuplicateFaceIDs, (DWORD)pFace, (CMapSolid *)pFace->GetParent());
+	}
+}
+
+
+//-----------------------------------------------------------------------------
+// Checks if a particular target is valid.
+//-----------------------------------------------------------------------------
+static void CheckValidTarget(CMapEntity *pEntity, const char *pFieldName, const char *pTargetName, CListBox *pList, bool bCheckClassNames)
+{
+	if (!pTargetName)
+		return;
+
+	// These procedural names are always assumed to exist.
+	if (!stricmp(pTargetName, "!activator") || !stricmp(pTargetName, "!caller") || !stricmp(pTargetName, "!player") || !stricmp(pTargetName, "!self"))
+		return;
+
+	CMapDoc *pDoc = CMapDoc::GetActiveMapDoc();
+
+	// Search by name first.
+	CMapEntityList Found;
+	bool bFound = pDoc->FindEntitiesByName(Found, pTargetName, (Options.general.bCheckVisibleMapErrors == TRUE));
+	if (!bFound && bCheckClassNames)
+	{
+		// Not found, search by classname.
+		bFound = pDoc->FindEntitiesByClassName(Found, pTargetName, (Options.general.bCheckVisibleMapErrors == TRUE));
+	}
+
+	if (!bFound)
+	{
+		// No dice, flag it as an error.
+		AddError(pList, ErrorMissingTarget, (DWORD)pFieldName, pEntity);
+	}
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Checks the given entity for references by name to nonexistent entities.
+// Input  : pEntity - 
+//			pList - 
+// Output : Returns TRUE to keep enumerating.
+//-----------------------------------------------------------------------------
+static BOOL _CheckMissingTargets(CMapEntity *pEntity, CListBox *pList)
+{
+	if ( !IsCheckVisible( pEntity ) )
+		return TRUE;
+
+	GDclass *pClass = pEntity->GetClass();
+	if (!pClass)
+	{
+		// Unknown class -- just check for target references.
+		static char *pszTarget = "target";
+		const char *pszValue = pEntity->GetKeyValue(pszTarget);
+		CheckValidTarget(pEntity, pszTarget, pszValue, pList, false);
+	}
+	else
+	{
+		// Known class -- check all target_destination and target_name_or_class keyvalues.
+		for (int i = 0; i < pClass->GetVariableCount(); i++)
+		{
+			GDinputvariable *pVar = pClass->GetVariableAt(i);
+			if ((pVar->GetType() != ivTargetDest) && (pVar->GetType() != ivTargetNameOrClass))
+				continue;
+
+			const char *pszValue = pEntity->GetKeyValue(pVar->GetName());
+			CheckValidTarget(pEntity, pVar->GetName(), pszValue, pList, (pVar->GetType() == ivTargetNameOrClass));
+		}
+	}
+
+	return TRUE;
+}
+
+
+static void CheckMissingTargets(CListBox *pList, CMapWorld *pWorld)
+{
+	pWorld->EnumChildren((ENUMMAPCHILDRENPROC)_CheckMissingTargets, (DWORD)pList, MAPCLASS_TYPE(CMapEntity));
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Determines whether a solid is good or bad.
+// Input  : pSolid - Solid to check.
+//			pList - List box into which to place errors.
+// Output : Always returns TRUE to continue enumerating.
+//-----------------------------------------------------------------------------
+static BOOL _CheckSolidIntegrity(CMapSolid *pSolid, CListBox *pList)
+{
+	if ( !IsCheckVisible( pSolid ) )
+		return TRUE;
+
+	CCheckFaceInfo cfi;
+	int nFaces = pSolid->GetFaceCount();
+	for (int i = 0; i < nFaces; i++)
+	{
+		CMapFace *pFace = pSolid->GetFace(i);
+
+		//
+		// Reset the iPoint member so results from previous faces don't carry over.
+		//
+		cfi.iPoint = -1;
+
+		//
+		// Check the face.
+		//
+		if (!pFace->CheckFace(&cfi))
+		{
+			AddError(pList, ErrorSolidStructure, 0, pSolid);
+			break;
+		}
+	}
+
+	return(TRUE);
+}
+
+
+static void CheckSolidIntegrity(CListBox *pList, CMapWorld *pWorld)
+{
+	pWorld->EnumChildren((ENUMMAPCHILDRENPROC)_CheckSolidIntegrity, (DWORD)pList, MAPCLASS_TYPE(CMapSolid));
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Input  : pSolid - 
+//			pList - 
+// Output : 
+//-----------------------------------------------------------------------------
+static BOOL _CheckSolidContents(CMapSolid *pSolid, CListBox *pList)
+{
+	if ( !IsCheckVisible( pSolid ) )
+		return TRUE;
+
+	CCheckFaceInfo cfi;
+	int nFaces = pSolid->GetFaceCount();
+	CMapFace *pFace = pSolid->GetFace(0);
+	DWORD dwContents = pFace->texture.q2contents;
+
+	for (int i = 1; i < nFaces; i++)
+	{
+		pFace = pSolid->GetFace(i);
+		if (pFace->texture.q2contents == dwContents)
+		{
+			continue;
+		}
+		AddError(pList, ErrorSolidContents, 0, pSolid);
+		break;
+	}
+
+	return TRUE;
+}
+
+
+static void CheckSolidContents(CListBox *pList, CMapWorld *pWorld)
+{
+	if (CMapDoc::GetActiveMapDoc() && CMapDoc::GetActiveMapDoc()->GetGame() && CMapDoc::GetActiveMapDoc()->GetGame()->mapformat == mfQuake2)
+	{
+		pWorld->EnumChildren((ENUMMAPCHILDRENPROC)_CheckSolidContents, (DWORD)pList, MAPCLASS_TYPE(CMapSolid));
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Determines if there are any invalid textures or texture axes on any
+//			face of this solid. Adds an error message to the list box for each
+//			error found.
+// Input  : pSolid - Solid to check.
+//			pList - Pointer to the error list box.
+// Output : Returns TRUE.
+//-----------------------------------------------------------------------------
+static BOOL _CheckInvalidTextures(CMapSolid *pSolid, CListBox *pList)
+{
+	if ( !IsCheckVisible( pSolid ) )
+		return TRUE;
+
+	int nFaces = pSolid->GetFaceCount();
+	for(int i = 0; i < nFaces; i++)
+	{
+		const CMapFace *pFace = pSolid->GetFace(i);
+
+		IEditorTexture *pTex = pFace->GetTexture();
+		if (pTex->IsDummy())
+		{
+			AddError(pList, ErrorInvalidTexture, (DWORD)pFace->texture.texture, pSolid);
+			return TRUE;
+		}
+
+		if (!pFace->IsTextureAxisValid())
+		{
+			AddError(pList, ErrorInvalidTextureAxes, i, pSolid);
+			return(TRUE);
+		}
+	}
+	
+	return(TRUE);
+}
+
+
+static void CheckInvalidTextures(CListBox *pList, CMapWorld *pWorld)
+{
+	pWorld->EnumChildren((ENUMMAPCHILDRENPROC)_CheckInvalidTextures, (DWORD)pList, MAPCLASS_TYPE(CMapSolid));
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Input  : pEntity - 
+//			pList - 
+// Output : 
+//-----------------------------------------------------------------------------
+static BOOL _CheckUnusedKeyvalues(CMapEntity *pEntity, CListBox *pList)
+{
+	if ( !IsCheckVisible( pEntity ) )
+		return TRUE;
+
+	if (!pEntity->IsClass() || pEntity->IsClass("multi_manager"))
+	{
+		return(TRUE);	// can't check if no class associated
+	}
+
+	GDclass *pClass = pEntity->GetClass();
+
+	for (int i = pEntity->GetFirstKeyValue(); i != pEntity->GetInvalidKeyValue(); i=pEntity->GetNextKeyValue( i ) )
+	{
+		if (pClass->VarForName(pEntity->GetKey(i)) == NULL)
+		{
+			AddError(pList, ErrorUnusedKeyvalues, (DWORD)pEntity->GetKey(i), pEntity);
+			return(TRUE);
+		}
+	}
+	
+	return(TRUE);
+}
+
+
+static void CheckUnusedKeyvalues(CListBox *pList, CMapWorld *pWorld)
+{
+	pWorld->EnumChildren((ENUMMAPCHILDRENPROC)_CheckUnusedKeyvalues, (DWORD)pList, MAPCLASS_TYPE(CMapEntity));
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Input  : pEntity - 
+//			pList - 
+// Output : 
+//-----------------------------------------------------------------------------
+static BOOL _CheckEmptyEntities(CMapEntity *pEntity, CListBox *pList)
+{
+	if ( !IsCheckVisible( pEntity ) )
+		return TRUE;
+
+	if(!pEntity->IsPlaceholder() && !pEntity->GetChildCount())
+	{
+		AddError(pList, ErrorEmptyEntity, (DWORD)pEntity->GetClassName(), pEntity);
+	}
+	
+	return(TRUE);
+}
+
+
+static void CheckEmptyEntities(CListBox *pList, CMapWorld *pWorld)
+{
+	pWorld->EnumChildren((ENUMMAPCHILDRENPROC)_CheckEmptyEntities, (DWORD)pList, MAPCLASS_TYPE(CMapEntity));
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Checks the entity for bad I/O connections.
+// Input  : pEntity - the entity to check
+//			pList - list box that tracks the errors
+// Output : Returns TRUE to keep enumerating.
+//-----------------------------------------------------------------------------
+static BOOL _CheckBadConnections(CMapEntity *pEntity, CListBox *pList)
+{
+	if ( !IsCheckVisible( pEntity ) )
+		return TRUE;
+
+	if (CEntityConnection::ValidateOutputConnections(pEntity, (Options.general.bCheckVisibleMapErrors == TRUE)) == CONNECTION_BAD)
+	{
+		AddError(pList, ErrorBadConnections, (DWORD)pEntity->GetClassName(), pEntity);
+	}
+
+	// TODO: Check for a "Kill" input with the same output, target, and delay as another input. This
+	//		 creates a race condition in the game where the order of arrival is not guaranteed
+	//int nConnCount = pEntity->Connections_GetCount();
+	//for (int i = 0; i < nConnCount; i++)
+	//{
+	//	CEntityConnection *pConn = pEntity->Connections_Get(i);
+	//	if (!stricmp(pConn->GetInputName(), "kill"))
+	//	{
+	//	}
+	//}
+	
+	return TRUE;
+}
+
+
+static void CheckBadConnections(CListBox *pList, CMapWorld *pWorld)
+{
+	pWorld->EnumChildren((ENUMMAPCHILDRENPROC)_CheckBadConnections, (DWORD)pList, MAPCLASS_TYPE(CMapEntity));
+}
+
+
+static bool HasVisGroupHiddenChildren(CMapClass *pObject)
+{
+	const CMapObjectList *pChildren = pObject->GetChildren();
+
+	FOR_EACH_OBJ( *pChildren, pos )
+	{
+		if (!pChildren->Element(pos)->IsVisGroupShown())
+			return true;
+	}
+
+	return false;
+}
+
+
+static bool HasVisGroupShownChildren(CMapClass *pObject)
+{
+	const CMapObjectList *pChildren = pObject->GetChildren();
+	FOR_EACH_OBJ( *pChildren, pos )
+	{
+		if (pChildren->Element(pos)->IsVisGroupShown())
+			return true;
+	}
+
+	return false;
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Makes sure that the visgroup assignments are valid.
+//-----------------------------------------------------------------------------
+static BOOL _CheckVisGroups(CMapClass *pObject, CListBox *pList)
+{
+	CMapDoc *pDoc = CMapDoc::GetActiveMapDoc();
+
+	// dvs: FIXME: not working yet, revisit
+	// Entities cannot have hidden children.
+	//CMapEntity *pEntity = dynamic_cast<CMapEntity *>(pObject);
+	//if (pEntity && HasVisGroupHiddenChildren(pEntity))
+	//{
+	//	AddError(pList, ErrorHiddenChildOfEntity, 0, pEntity);
+	//	return TRUE;
+	//}
+
+	// Check the validity of any object that claims to be hidden by visgroups.
+	if (!pObject->IsVisGroupShown())
+	{
+		// Groups cannot be hidden by visgroups.
+		if (pObject->IsGroup())
+		{
+			bool bHidden = HasVisGroupHiddenChildren(pObject);
+			bool bVisible = HasVisGroupShownChildren(pObject);
+
+			if (bHidden && !bVisible)
+			{
+				AddError(pList, ErrorHiddenGroupHiddenChildren, 0, pObject);
+			}
+			else if (!bHidden && bVisible)
+			{
+				AddError(pList, ErrorHiddenGroupVisibleChildren, 0, pObject);
+			}
+			else
+			{
+				AddError(pList, ErrorHiddenGroupMixedChildren, 0, pObject);
+			}
+
+			return TRUE;
+		}
+
+		// Check for unanticipated objects that are hidden but forbidden from visgroup membership.
+		if (!pDoc->VisGroups_ObjectCanBelongToVisGroup(pObject))
+		{
+			AddError(pList, ErrorIllegallyHiddenObject, 0, pObject);
+			return TRUE;
+		}
+		
+		// Hidden objects must belong to at least one visgroup.
+		if (pObject->GetVisGroupCount() == 0)
+		{
+			AddError(pList, ErrorHiddenObjectNoVisGroup, 0, pObject);
+			return TRUE;
+		}
+	}
+
+	return TRUE;
+}
+
+
+static void CheckVisGroups(CListBox *pList, CMapWorld *pWorld)
+{
+	pWorld->EnumChildrenRecurseGroupsOnly((ENUMMAPCHILDRENPROC)_CheckVisGroups, (DWORD)pList);
+}
+
+//-----------------------------------------------------------------------------
+// Purpose:
+//-----------------------------------------------------------------------------
+static BOOL _CheckOverlayFaceList( CMapEntity *pEntity, CListBox *pList )
+{
+	if ( !IsCheckVisible( pEntity ) )
+		return TRUE;
+
+	const CMapObjectList *pChildren = pEntity->GetChildren();
+
+	FOR_EACH_OBJ( *pChildren, pos )
+	{
+		CMapOverlay *pOverlay = dynamic_cast<CMapOverlay*>( pChildren->Element(pos) );
+		if ( pOverlay )
+		{
+			// Check to see if the overlay has assigned faces.
+			if ( pOverlay->GetFaceCount() <= 0 )
+			{
+				AddError( pList, ErrorOverlayFaceList, 0, pEntity );
+				return TRUE;
+			}
+		}
+	}
+
+	return TRUE;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose:
+//-----------------------------------------------------------------------------
+static void CheckOverlayFaceList( CListBox *pList, CMapWorld *pWorld )
+{
+	pWorld->EnumChildren( ( ENUMMAPCHILDRENPROC )_CheckOverlayFaceList, ( DWORD )pList, MAPCLASS_TYPE( CMapEntity ));
+}
+
+//
+// ** FIX FUNCTIONS
+//
+static void FixDuplicatePlanes(MapError *pError)
+{
+	// duplicate planes in pObjects[0]
+	// run thru faces..
+
+	CMapSolid *pSolid = (CMapSolid*) pError->pObjects[0];
+
+ReStart:
+	int iFaces = pSolid->GetFaceCount();
+	for(int i = 0; i < iFaces; i++)
+	{
+		CMapFace *pFace = pSolid->GetFace(i);
+		Vector& pts1 = pFace->plane.normal;
+		for (int j = 0; j < iFaces; j++)
+		{
+			// Don't check self
+			if (j == i)
+			{
+				continue;
+			}
+
+			CMapFace *pFace2 = pSolid->GetFace(j);
+			Vector& pts2 = pFace2->plane.normal;
+			if (pts1 == pts2)
+			{
+				pSolid->DeleteFace(j);
+				goto ReStart;
+			}
+		}
+	}
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Repairs an invalid solid.
+// Input  : pError - Contains information about the error.
+//-----------------------------------------------------------------------------
+static void FixSolidStructure(MapError *pError)
+{
+	CMapSolid *pSolid = (CMapSolid *)pError->pObjects[0];
+
+	//
+	// First make sure all the faces are good.
+	//
+	int nFaces = pSolid->GetFaceCount();
+	for (int i = nFaces - 1; i >= 0; i--)
+	{
+		CMapFace *pFace = pSolid->GetFace(i);
+		if (!pFace->CheckFace(NULL))
+		{
+			pFace->Fix();
+		}
+		//
+		// If the face has no points, just remove it from the solid.
+		//
+		if (pFace->GetPointCount() == 0)
+		{
+			pSolid->DeleteFace(i);
+		}
+	}
+
+	//
+	// Rebuild the solid from the planes.
+	//
+	pSolid->CreateFromPlanes();
+	pSolid->PostUpdate(Notify_Changed);
+}
+
+
+LPCTSTR GetDefaultTextureName(); // dvs: BAD!
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Replaces any missing textures with the default texture.
+// Input  : pError - 
+//-----------------------------------------------------------------------------
+static void FixInvalidTexture(MapError *pError)
+{
+	CMapSolid *pSolid = (CMapSolid *)pError->pObjects[0];
+
+	int nFaces = pSolid->GetFaceCount();
+	for (int i = 0; i < nFaces; i++)
+	{
+		CMapFace *pFace = pSolid->GetFace(i);
+		if (pFace != NULL)
+		{
+			IEditorTexture *pTex = pFace->GetTexture();
+			if (pTex != NULL)
+			{
+				if (pTex->IsDummy())
+				{
+					pFace->SetTexture(GetDefaultTextureName());
+				}
+			}
+		}
+	}
+}
+
+
+static void FixInvalidTextureAxes(MapError *pError)
+{
+	CMapSolid *pSolid = (CMapSolid *)pError->pObjects[0];
+
+	int nFaces = pSolid->GetFaceCount();
+	for (int i = 0; i < nFaces; i++)
+	{
+		CMapFace *pFace = pSolid->GetFace(i);
+		if (!pFace->IsTextureAxisValid())
+		{
+			pFace->InitializeTextureAxes(Options.GetTextureAlignment(), INIT_TEXTURE_FORCE | INIT_TEXTURE_AXES);
+		}
+	}
+}
+
+
+static void FixInvalidContents(MapError *pError)
+{
+	CMapSolid *pSolid = (CMapSolid *)pError->pObjects[0];
+
+	CMapFace *pFace = pSolid->GetFace(0);
+	DWORD dwContents = pFace->texture.q2contents;
+
+	int nFaces = pSolid->GetFaceCount();
+	for (int i = 1; i < nFaces; i++)
+	{
+		pFace = pSolid->GetFace(i);
+		pFace->texture.q2contents = dwContents;
+	}
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Fixes duplicate face IDs by assigning the face a unique ID within
+//			the world.
+// Input  : pError - Holds the world and the face that is in error.
+//-----------------------------------------------------------------------------
+static void FixDuplicateFaceIDs(MapError *pError)
+{
+	CMapWorld *pWorld = (CMapWorld *)pError->pObjects[0];
+	CMapFace *pFace = (CMapFace *)pError->dwExtra;
+
+	pFace->SetFaceID(pWorld->FaceID_GetNext());
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Input  : pError - 
+//-----------------------------------------------------------------------------
+static void FixUnusedKeyvalues(MapError *pError)
+{
+	CMapEntity *pEntity = (CMapEntity*) pError->pObjects[0];
+
+	GDclass *pClass = pEntity->GetClass();
+	if (!pClass)
+	{
+		return;
+	}
+
+	int iNext;
+	for ( int i=pEntity->GetFirstKeyValue(); i != pEntity->GetInvalidKeyValue(); i = iNext )
+	{
+		iNext = pEntity->GetNextKeyValue( i );
+		if (pClass->VarForName(pEntity->GetKey(i)) == NULL)
+		{
+			pEntity->DeleteKeyValue(pEntity->GetKey(i));
+		}
+	}
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Removes any bad connections from the entity associated with the error.
+// Input  : pError - 
+//-----------------------------------------------------------------------------
+static void FixBadConnections(MapError *pError)
+{
+	CMapEntity *pEntity = (CMapEntity *)pError->pObjects[0];
+	CEntityConnection::FixBadConnections(pEntity, (Options.general.bCheckVisibleMapErrors == TRUE));
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Fixes a race condition caused by a Kill input being triggered at the
+//			same instant as another input.
+// Input  : pError - 
+//-----------------------------------------------------------------------------
+static void FixKillInputRaceCondition(MapError *pError)
+{
+	CEntityConnection *pConn = (CEntityConnection *)pError->pObjects[1];
+
+	// Delay the Kill command so that it arrives after the other command,
+	// solving the race condition.
+	pConn->SetDelay(pConn->GetDelay() + 0.01);
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Input  : pError - 
+//-----------------------------------------------------------------------------
+static void FixOverlayFaceList( MapError *pError )
+{
+	CMapEntity *pEntity = static_cast<CMapEntity*>( pError->pObjects[0] );
+	if ( !pEntity )
+		return;
+
+	const CMapObjectList *pChildren = pEntity->GetChildren();
+
+	FOR_EACH_OBJ( *pChildren, pos )
+	{
+		CMapOverlay *pOverlay = dynamic_cast<CMapOverlay*>( pChildren->Element(pos) );
+		if ( pOverlay )
+		{
+			// Destroy itself.
+			CMapDoc *pDoc = CMapDoc::GetActiveMapDoc();
+			pDoc->RemoveObjectFromWorld( pEntity, true );
+			GetHistory()->KeepForDestruction( pEntity );
+			return;
+		}
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Input  : pError - 
+//-----------------------------------------------------------------------------
+static void FixEmptyEntity(MapError *pError)
+{
+	CMapClass *pKillMe = pError->pObjects[0];
+
+	if (pKillMe->GetParent() != NULL)
+	{
+		GetHistory()->KeepForDestruction(pKillMe);
+		pKillMe->GetParent()->RemoveChild(pKillMe);
+	}
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Fixes duplicate node IDs by assigning the entity a unique node ID.
+// Input  : pError - Holds the world and the entity that is in error.
+//-----------------------------------------------------------------------------
+static void FixDuplicateNodeIDs(MapError *pError)
+{
+	CMapEntity *pEntity = (CMapEntity *)pError->pObjects[0];
+	pEntity->AssignNodeID();
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Clears a bad target reference from the given entity.
+// Input  : pError - 
+//-----------------------------------------------------------------------------
+static void FixMissingTarget(MapError *pError)
+{
+	CMapEntity *pEntity = (CMapEntity *)pError->pObjects[0];
+	const char *pszKey = (const char *)pError->dwExtra;
+	pEntity->SetKeyValue(pszKey, NULL);
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Fix a an invalid visgroup state. This is either:
+//			1) A group that is hidden
+//			2) An object that is hidden but not in any visgroups
+//-----------------------------------------------------------------------------
+void FixHiddenObject(MapError *pError)
+{
+	CMapClass *pObject = pError->pObjects[0];
+
+	// Tweak the object's visgroup state directly to avoid changing the
+	// hidden/shown state of the object's children.
+	pObject->m_bVisGroupShown = true;
+	pObject->m_bVisGroupAutoShown = true;
+	pObject->m_VisGroups.RemoveAll();
+
+	// Create a new visgroup to out the objects in (for hiding or inspection/deletion).
+	CMapObjectList Objects;
+	Objects.AddToTail(pObject);
+	CMapDoc *pDoc = CMapDoc::GetActiveMapDoc();
+
+	if ((pError->Type == ErrorHiddenGroupHiddenChildren) ||
+		(pError->Type == ErrorHiddenObjectNoVisGroup))
+	{
+		// The objects aren't in the compile, so just hide them.
+		pDoc->VisGroups_CreateNamedVisGroup(Objects, "_hidden by Check for Problems", true, false);
+	}
+	else if (pError->Type == ErrorIllegallyHiddenObject)
+	{
+		// Do nothing, the object is now shown.
+	}
+	else
+	{
+		// ErrorHiddenGroupVisibleChildren
+		// ErrorHiddenGroupMixedChildren
+		// ErrorHiddenChildOfEntity
+
+		// The objects either ARE in the compile, or they can't be hidden in a visgroup.
+		// Don't hide them, just stick them in a visgroup for inspection
+		pDoc->VisGroups_CreateNamedVisGroup(Objects, "found by Check for Problems", false, false);
+	}
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Checks the map for problems. Returns true if the map is okay,
+//			false if problems were found.
+//-----------------------------------------------------------------------------
+bool CMapCheckDlg::DoCheck(void)
+{
+	CMapWorld *pWorld = GetActiveWorld();
+
+	// Clear error list
+	KillErrorList();
+
+	// Map validation
+	CheckRequirements(&m_Errors, pWorld);
+
+	// Solid validation
+	CheckMixedFaces(&m_Errors, pWorld);
+	//CheckDuplicatePlanes(&m_Errors, pWorld);
+	CheckDuplicateFaceIDs(&m_Errors, pWorld);
+	CheckDuplicateNodeIDs(&m_Errors, pWorld);
+	CheckSolidIntegrity(&m_Errors, pWorld);
+	CheckSolidContents(&m_Errors, pWorld);
+	CheckInvalidTextures(&m_Errors, pWorld);
+
+	// Entity validation
+	CheckUnusedKeyvalues(&m_Errors, pWorld);
+	CheckEmptyEntities(&m_Errors, pWorld);
+	CheckMissingTargets(&m_Errors, pWorld);
+	CheckBadConnections(&m_Errors, pWorld);
+
+	CheckVisGroups(&m_Errors, pWorld);
+
+	CheckOverlayFaceList(&m_Errors, pWorld);
+
+	if (!m_Errors.GetCount())
+	{
+		AfxMessageBox("No errors were found.");
+		EndDialog(IDOK);
+		return true;
+	}
+
+	return false;
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CMapCheckDlg::OnOK()
+{
+	DestroyWindow();
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CMapCheckDlg::OnClose()
+{
+	DestroyWindow();
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Called when our window is being destroyed.
+//-----------------------------------------------------------------------------
+void CMapCheckDlg::OnDestroy()
+{
+	delete this;
+	s_pDlg = NULL;
+}