hl2_src-leak-2017/src/hammer/mappath.cpp

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

#include "stdafx.h"
#include "MapPath.h"
#include "hammer.h"
#include "EditPathDlg.h"
#include "MapEntity.h"

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


float GetFileVersion(void);


//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
CMapPath::CMapPath(void)
{
	m_iDirection = dirOneway;
	SetName("");
	SetClass("path_corner");
}


//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
CMapPath::~CMapPath(void)
{
}


//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
CMapPathNode::CMapPathNode(void)
{
	bSelected = FALSE;
	szName[0] = 0;
}

CMapPathNode::CMapPathNode(const CMapPathNode& src)
{
	*this = src;
}



//-----------------------------------------------------------------------------
// Purpose: 
// Input  : src - 
// Output : CMapPathNode
//-----------------------------------------------------------------------------
CMapPathNode &CMapPathNode::operator=(const CMapPathNode &src)
{
	// we don't care.
	Q_strncpy( szName, src.szName, sizeof(szName) );
	bSelected = src.bSelected;
	kv.RemoveAll();
	for ( int i=src.kv.GetFirst(); i != src.kv.GetInvalidIndex(); i=src.kv.GetNext( i ) )
	{
		MDkeyvalue KeyValue = src.kv.GetKeyValue(i);
		kv.SetValue(KeyValue.szKey, KeyValue.szValue);
	}
	pos = src.pos;
	dwID = src.dwID;

	return *this;
}


//-----------------------------------------------------------------------------
// Purpose: 
// Input  : dwID - 
//			piIndex - 
// Output : CMapPathNode *
//-----------------------------------------------------------------------------
CMapPathNode *CMapPath::NodeForID(DWORD dwID, int* piIndex)
{
	for(int iNode = 0; iNode < m_Nodes.Count(); iNode++)
	{
		if(m_Nodes[iNode].dwID == dwID)
		{
			if(piIndex)
				piIndex[0] = iNode;
			return &m_Nodes[iNode];
		}
	}

	return NULL;
}


//-----------------------------------------------------------------------------
// Purpose: 
// Output : DWORD
//-----------------------------------------------------------------------------
DWORD CMapPath::GetNewNodeID(void)
{
	DWORD dwNewID = 1;
	while(true)
	{
		int iNode;
		for(iNode = 0; iNode < m_Nodes.Count(); iNode++)
		{
			if(m_Nodes[iNode].dwID == dwNewID)
				break;
		}

		if(iNode == m_Nodes.Count())
			return dwNewID;

		++dwNewID;
	}
}


//-----------------------------------------------------------------------------
// Purpose: 
// Input  : dwAfterID - 
//			vecPos - 
// Output : 
//-----------------------------------------------------------------------------
DWORD CMapPath::AddNode(DWORD dwAfterID, const Vector &vecPos)
{
	int iPos;

	if(dwAfterID == ADD_START)
		iPos = 0;
	else if(dwAfterID == ADD_END)
		iPos = m_Nodes.Count();
	else if(!NodeForID(dwAfterID, &iPos))
		return 0;	// not found!

	CMapPathNode node;
	node.pos = vecPos;
	node.bSelected = FALSE;
	node.dwID = GetNewNodeID();

	if(iPos == m_Nodes.Count())
	{
		// add at tail
		m_Nodes.AddToTail(node);
	}
	else
	{
		m_Nodes.InsertBefore( iPos, node );
	}

	return node.dwID;
}


//-----------------------------------------------------------------------------
// Purpose: 
// Input  : dwID - 
//			*pt - 
//-----------------------------------------------------------------------------
void CMapPath::SetNodePosition(DWORD dwID, Vector& pt)
{
	int iIndex;
	NodeForID(dwID, &iIndex);

	m_Nodes[iIndex].pos = pt;
}


//-----------------------------------------------------------------------------
// Purpose: 
// Input  : dwID - 
//-----------------------------------------------------------------------------
void CMapPath::DeleteNode(DWORD dwID)
{
	int iIndex;
	if ( NodeForID(dwID, &iIndex) )
	{
		m_Nodes.Remove(iIndex);
	}
}


//-----------------------------------------------------------------------------
// Purpose: 
// Input  : file - 
//			fIsStoring - 
//-----------------------------------------------------------------------------
void CMapPath::SerializeRMF(std::fstream& file, BOOL fIsStoring)
{
	int iSize;

	if(fIsStoring)
	{
		// save!!
		file.write(m_szName, 128);
		file.write(m_szClass, 128);
		file.write((char*) &m_iDirection, sizeof(m_iDirection));
	
		iSize = m_Nodes.Count();
		file.write((char*) &iSize, sizeof iSize);
		for(int i = 0; i < m_Nodes.Count(); i++)
		{
			CMapPathNode& node = m_Nodes[i];
			// store each node
			file.write((char*) &node.pos[0], 3 * sizeof(float));
			file.write((char*) &node.dwID, sizeof(node.dwID));
			file.write((char*) &node.szName, sizeof(node.szName));
			
			//
			// Write keyvalue count.
			//
			WCKeyValues &kv = node.kv;
			iSize = 0;
			for ( int z=kv.GetFirst(); z != kv.GetInvalidIndex(); z=kv.GetNext( z ) )
			{
				++iSize;
			}
			file.write((char*) &iSize, sizeof(iSize));

			//
			// Write keyvalues.
			//
			for (int k = kv.GetFirst(); k != kv.GetInvalidIndex(); k=kv.GetNext( k ) )
			{
				MDkeyvalue &KeyValue = kv.GetKeyValue(k);
				if (KeyValue.szKey[0] != '\0')
				{
					KeyValue.SerializeRMF(file, TRUE);
				}
			}
		}
	}
	else
	{
		// load!!
		file.read(m_szName, 128);
		file.read(m_szClass, 128);
		file.read((char*) &m_iDirection, sizeof m_iDirection);

		file.read((char*) &iSize, sizeof iSize);
		int nNodes = iSize;
		m_Nodes.RemoveAll();

		// read nodes
		for(int i = 0; i < nNodes; i++)
		{
			CMapPathNode node;
			// store each node
			file.read((char*) &node.pos[0], 3 * sizeof(float));
			file.read((char*) &node.dwID, sizeof(node.dwID));
			if(GetFileVersion() >= 1.6f)
			{
				file.read((char*) &node.szName, sizeof(node.szName));

				// read keyvalues
				file.read((char*) &iSize, sizeof(iSize));
				WCKeyValues &kv = node.kv;
				for (int k = 0; k < iSize; k++)
				{
					MDkeyvalue KeyValue;
					KeyValue.SerializeRMF(file, FALSE);
					kv.SetValue( KeyValue.szKey, KeyValue.szValue );
				}
			}

			m_Nodes.AddToTail(node);
		}
	}
}


//-----------------------------------------------------------------------------
// Purpose: 
// Input  : iIndex - 
//			iName - 
//			str - 
//-----------------------------------------------------------------------------
void CMapPath::GetNodeName(int iIndex, int iName, CString& str)
{
	if(m_Nodes[iIndex].szName[0])
		str = m_Nodes[iIndex].szName;
	else
	{
		if(iName)
			str.Format("%s%02d", m_szName, iName);
		else
			str = m_szName;
	}
}


//-----------------------------------------------------------------------------
// Purpose: 
// Input  : file - 
//			fIsStoring - 
//			*pIntersecting - 
//-----------------------------------------------------------------------------
void CMapPath::SerializeMAP(std::fstream& file, BOOL fIsStoring, BoundBox *pIntersecting)
{
	if( m_Nodes.Count() == 0)
		return;

	// if saving WITHIN a box, check all nodes to see if they all 
	//  fit within that box. if not, don't save ANY of the path.
	if(pIntersecting)
	{
		for(int i = 0; i < m_Nodes.Count(); i++)
		{
			if (!pIntersecting->ContainsPoint(m_Nodes[i].pos))
			{
				return;	// doesn't intersect - don't save path
			}
		}
	}


	Assert(fIsStoring);

	CString strTemp;
	MDkeyvalue kvTemp;

	// initialize nodes for saving
	for(int i = 0; i < m_Nodes.Count(); i++)
	{
		m_Nodes[i].nTargets = 0;
	}

	int iDirec = 1;
	int iCurNode = 0;
	int iMax = m_Nodes.Count()-1;
	int iName = 0;

	// resolve targets 
	int iLastNodeIndex = -1;
	BOOL bFirstPass = TRUE;

ResolveNamesAgain:
	while(1)
	{
		// store targetname
		GetNodeName(iCurNode, iName, strTemp);

		// store our name in the previous node (if not -1)
		if(iLastNodeIndex != -1)
		{
			CMapPathNode &prevNode = m_Nodes[iLastNodeIndex];
			strcpy(prevNode.szTargets[prevNode.nTargets++], strTemp);
		}

		++iName;

		iLastNodeIndex = iCurNode;

		if(iCurNode == iMax)
			break;
		iCurNode += iDirec;
	}

	if(bFirstPass && m_iDirection == dirPingpong && m_Nodes.Count() > 2)
	{
		// redo loop
		bFirstPass = FALSE;
		iDirec = -1;
		iCurNode = m_Nodes.Count()-2;
		iMax = 0;
		goto ResolveNamesAgain;
	}
	else if (m_iDirection == dirCircular)
	{
		//
		// Connect the last node to the first node.
		//
		CMapPathNode &LastNode = m_Nodes[iMax];
		GetNodeName(iCurNode, 0, strTemp);
		strcpy(LastNode.szTargets[LastNode.nTargets], strTemp);
		LastNode.nTargets++;
	}

	iDirec = 1;
	iCurNode = 0;
	iMax = m_Nodes.Count()-1;
	iName = 0;

SaveAgain:
	while(1)
	{
		file << "{" << "\r\n";

		// store name
		kvTemp.Set("classname", m_szClass);
		kvTemp.SerializeMAP(file, TRUE);

		CMapPathNode &node = m_Nodes[iCurNode];

		// store location
		strTemp.Format("%.0f %.0f %.0f", node.pos[0], node.pos[1], 
			node.pos[2]);
		kvTemp.Set("origin", strTemp);
		kvTemp.SerializeMAP(file, TRUE);

		// store targetname
		GetNodeName(iCurNode, iName, strTemp);
		kvTemp.Set("targetname", strTemp);
		kvTemp.SerializeMAP(file, TRUE);

		// store target (if not last)
		BOOL bStoreTarget = TRUE;
		if(iCurNode == iMax && m_iDirection == dirOneway)
			bStoreTarget = FALSE;

		if (bStoreTarget)
		{
			kvTemp.Set("target", (iDirec == 1) ? node.szTargets[0] : node.szTargets[1]);
			kvTemp.SerializeMAP(file, TRUE);
		}

		// other keyvalues
		WCKeyValues &kv = node.kv;
		for (int k = kv.GetFirst(); k != kv.GetInvalidIndex(); k=kv.GetNext( k ) )
		{
			MDkeyvalue &KeyValue = kv.GetKeyValue(k);
			if (KeyValue.szKey[0] != '\0')
			{
				KeyValue.SerializeMAP(file, TRUE);
			}
		}

		file << "}" << "\r\n";

		++iName;
		iLastNodeIndex = iCurNode;

		if(iCurNode == iMax)
			break;
		iCurNode += iDirec;
	}

	if(iDirec == 1 && m_iDirection == dirPingpong && m_Nodes.Count() > 2)
	{
		// redo loop
		iDirec = -1;
		iCurNode = m_Nodes.Count()-2;
		iMax = 1;
		goto SaveAgain;
	}
}

// Edit

void CMapPath::EditInfo()
{
	CEditPathDlg dlg;
	dlg.m_strName = m_szName;
	dlg.m_strClass = m_szClass;
	dlg.m_iDirection = m_iDirection;
	
	if(dlg.DoModal() != IDOK)
		return;

	SetName(dlg.m_strName);
	SetClass(dlg.m_strClass);
	m_iDirection = dlg.m_iDirection;
}


//-----------------------------------------------------------------------------
// Purpose: 
// Input  : dwNodeID - 
// Output : CMapEntity *
//-----------------------------------------------------------------------------
CMapEntity *CMapPath::CreateEntityForNode(DWORD dwNodeID)
{
	int iIndex;
	CMapPathNode *pNode = NodeForID(dwNodeID, &iIndex);
	if (pNode == NULL)
	{
		return NULL;	// no node, no entity!
	}

	CMapEntity *pEntity = new CMapEntity;

	for (int k = pNode->kv.GetFirst(); k != pNode->kv.GetInvalidIndex(); k=pNode->kv.GetNext( k ) )
	{
		pEntity->SetKeyValue(pNode->kv.GetKey(k), pNode->kv.GetValue(k));
	}
	
	// store target/targetname properties:
	CString str;
	str.Format("%s%02d", m_szName, iIndex);
	pEntity->SetKeyValue("targetname", str);

	int iNext = iIndex + 1;
	if(iNext != -1)
	{
		str.Format("%s%02d", m_szName, iNext);
		pEntity->SetKeyValue("target", str);
	}

	pEntity->SetClass(m_szClass);

	return pEntity;
}


//-----------------------------------------------------------------------------
// Purpose: 
// Input  : dwNodeID - 
//			*pEntity - 
//-----------------------------------------------------------------------------
void CMapPath::CopyNodeFromEntity(DWORD dwNodeID, CMapEntity *pEntity)
{
	CMapPathNode *pNode = NodeForID(dwNodeID);
	if (!pNode)
	{
		return;	// no node, no copy!
	}

	pNode->kv.RemoveAll();

	//
	// Copy all the keys except target and targetname from the entity to the pathnode.
	//
	for ( int i=pEntity->GetFirstKeyValue(); i != pEntity->GetInvalidKeyValue(); i=pEntity->GetNextKeyValue( i ) )
	{
		if (!strcmp(pEntity->GetKey(i), "target") || !strcmp(pEntity->GetKey(i), "targetname"))
		{
			continue;
		}

		pNode->kv.SetValue(pEntity->GetKey(i), pEntity->GetKeyValue(i));
	}
}


/*
//-----------------------------------------------------------------------------
// Purpose: 
// Input  : *szKey - 
//			*szValue - 
//			*pNode - 
// Output : CChunkFileResult_t
//-----------------------------------------------------------------------------

UNDONE: Nobody uses the path tool because the user interface is so poor.
		Path support has been pulled until the tool itself can be fixed or replaced.

CChunkFileResult_t CMapPathNode::LoadKeyCallback(const char *szKey, const char *szValue, CMapPathNode *pNode)
{
	if (!stricmp(szKey, "origin"))
	{
		CChunkFile::ReadKeyValueVector3(szValue, pNode->pos);
	}
	else if (!stricmp(szKey, "id"))
	{
		CChunkFile::ReadKeyValueInt(szValue, &pNode->dwID);
	}
	else if (!stricmp(szKey, "name"))
	{
		strcpy(pNode->szName, szValue);
	}
}


//-----------------------------------------------------------------------------
// Purpose: 
// Input  : *pFile - 
// Output : ChunkFileResult_t
//-----------------------------------------------------------------------------
ChunkFileResult_t CMapPathNode::SaveVMF(CChunkFile *pFile, CSaveInfo *pSaveInfo)
{
	ChunkFileResult_t  eResult = pFile->BeginChunk("node");

	if (eResult == ChunkFile_Ok)
	{
		eResult = pFile->WriteKeyValueVector3("origin", node.pos);
	}

	if (eResult == ChunkFile_Ok)
	{
		eResult = pFile->WriteKeyValueInt("id", node.dwID);
	}

	if (eResult == ChunkFile_Ok)
	{
		eResult = pFile->WriteKeyValue("name", node.szName);
	}
	
	if (eResult == ChunkFile_Ok)
	{
		eResult = pFile->BeginChunk("keys");
	}

	//
	// Write keyvalues.
	//
	if (eResult == ChunkFile_Ok)
	{
		iSize = kv.GetCount();
		for (int k = 0; k < iSize; k++)
		{
			MDkeyvalue &KeyValue = kv.GetKeyValue(k);
			if (eResult == ChunkFile_Ok)
			{
				eResult = pFile->WriteKeyValue(KeyValue.GetKey(), KeyValue.GetValue());
			}
		}
	}

	// End the keys chunk.
	if (eResult == ChunkFile_Ok)
	{
		eResult = pFile->EndChunk();
	}

	// End the node chunk.
	if (eResult == ChunkFile_Ok)
	{
		eResult = pFile->EndChunk();
	}

	return(eResult);
}

//-----------------------------------------------------------------------------
// Purpose: 
// Input  : *szKey - 
//			*szValue - 
//			*pPath - 
// Output : CChunkFileResult_t
//-----------------------------------------------------------------------------
CChunkFileResult_t CMapPath::LoadKeyCallback(const char *szKey, const char *szValue, CMapPath *pPath)
{
	if (!stricmp(szKey, "name"))
	{
		pPath->SetName(szValue);
	}
	else if (!stricmp(szKey, "classname"))
	{
		pPath->SetClass(szValue);
	}
	else if (!stricmp(szKey, "direction"))
	{
		CChunkFile::ReadKeyValueInt(szValue, &pPath->m_iDirection);
	}
}


//-----------------------------------------------------------------------------
// Purpose: 
// Input  : *pFile - 
//-----------------------------------------------------------------------------
void CMapPath::LoadVMF(CChunkFile *pFile)
{
	file.read((char*) &iSize, sizeof iSize);
	m_nNodes = iSize;
	m_Nodes.SetSize(m_nNodes);

	// read nodes
	for (int i = 0; i < m_nNodes; i++)
	{
		CMapPathNode &node = m_Nodes[i];

			// read keyvalues
			file.read((char*) &iSize, sizeof(iSize));
			KeyValues &kv = node.kv;
			kv.SetSize(iSize);
			for (int k = 0; k < iSize; k++)
			{
				MDkeyvalue &KeyValue = kv.GetKeyValue(k);
				KeyValue.SerializeRMF(file, FALSE);
			}
		}
	}
}

//-----------------------------------------------------------------------------
// Purpose: 
// Input  : *pFile - 
//-----------------------------------------------------------------------------
void CMapPath::SaveVMF(CChunkFile *pFile, CSaveInfo *pSaveInfo)
{
	int iSize;

	ChunkFileResult_t eResult = pFile->BeginChunk("path");

	if (eResult == ChunkFile_Ok)
	{
		eResult = pFile-WriteKeyValue("name", m_szName);
	}

	if (eResult == ChunkFile_Ok)
	{
		eResult = pFile->WriteKeyValue("classname", m_szClass);
	}

	if (eResult == ChunkFile_Ok)
	{
		eResult = pFile->WriteKeyValueInt("direction", m_iDirection);
	}

	if (eResult == ChunkFile_Ok)
	{
		for (int i = 0; i < m_nNodes; i++)
		{
			CMapPathNode &node = m_Nodes[i];
			eResult = node.SaveVMF(pFile, pSaveInfo);
		}
	}

	if (eResult == ChunkFile_Ok)
	{
		eResult = pFile->EndChunk();
	}
}
*/