gdclass.cpp

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

#include "fgdlib/GameData.h" // FGDLIB: eliminate dependency
#include "fgdlib/GDClass.h"

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


//-----------------------------------------------------------------------------
// Purpose: Constructor.
//-----------------------------------------------------------------------------
GDclass::GDclass(void)
{
	m_nVariables = 0;
	m_bBase = false;
	m_bSolid = false;
	m_bBase = false;
	m_bSolid = false;
	m_bModel = false;
	m_bMove = false;
	m_bKeyFrame = false;
	m_bPoint = false;
	m_bNPC = false;
	m_bFilter = false;

	m_bHalfGridSnap = false;

	m_bGotSize = false;
	m_bGotColor = false;

	m_rgbColor.r = 220;
	m_rgbColor.g = 30;
	m_rgbColor.b = 220;
	m_rgbColor.a = 0;

	m_pszDescription = NULL;

	for (int i = 0; i < 3; i++)
	{
		m_bmins[i] = -8;
		m_bmaxs[i] = 8;
	}
}


//-----------------------------------------------------------------------------
// Purpose: Destructor. Frees variable and helper lists.
//-----------------------------------------------------------------------------
GDclass::~GDclass(void)
{
	//
	// Free variables.
	//
	int nCount = m_Variables.Count();
	for (int i = 0; i < nCount; i++)
	{
		GDinputvariable *pvi = m_Variables.Element(i);
		delete pvi;
	}
	m_Variables.RemoveAll();

	//
	// Free helpers.
	//
	nCount = m_Helpers.Count();
	for (int i = 0; i < nCount; i++)
	{
		CHelperInfo *pHelper = m_Helpers.Element(i);
		delete pHelper;
	}
	m_Helpers.RemoveAll();

	//
	// Free inputs.
	//
	nCount = m_Inputs.Count();
	for (int i = 0; i < nCount; i++)
	{
		CClassInput *pInput = m_Inputs.Element(i);
		delete pInput;
	}
	m_Inputs.RemoveAll();

	//
	// Free outputs.
	//
	nCount = m_Outputs.Count();
	for (int i = 0; i < nCount; i++)
	{
		CClassOutput *pOutput = m_Outputs.Element(i);
		delete pOutput;
	}
	m_Outputs.RemoveAll();

	delete m_pszDescription;
}


//-----------------------------------------------------------------------------
// Purpose: Adds the base class's variables to our variable list. Acquires the
//			base class's bounding box and color, if any.
// Input  : pszBase - Name of base class to add.
//-----------------------------------------------------------------------------
void GDclass::AddBase(GDclass *pBase)
{
	int iBaseIndex;
	Parent->ClassForName(pBase->GetName(), &iBaseIndex);

	//
	// Add variables from base - update variable table
	//
	for (int i = 0; i < pBase->GetVariableCount(); i++)
	{
		GDinputvariable *pVar = pBase->GetVariableAt(i);
		AddVariable(pVar, pBase, iBaseIndex, i);
	}

	//
	// Add inputs from the base.
	// UNDONE: need to use references to inputs & outputs to conserve memory
	//
	int nCount = pBase->GetInputCount();
	for (int i = 0; i < nCount; i++)
	{
		CClassInput *pInput = pBase->GetInput(i);

		CClassInput *pNew = new CClassInput;
		*pNew = *pInput;
		AddInput(pNew);
	}

	//
	// Add outputs from the base.
	//
	nCount = pBase->GetOutputCount();
	for (int i = 0; i < nCount; i++)
	{
		CClassOutput *pOutput = pBase->GetOutput(i);

		CClassOutput *pNew = new CClassOutput;
		*pNew = *pOutput;
		AddOutput(pNew);
	}

	//
	// If we don't have a bounding box, try to get the base's box.
	//
	if (!m_bGotSize)
	{
		if (pBase->GetBoundBox(m_bmins, m_bmaxs))
		{
			m_bGotSize = true;
		}
	}

	//
	// If we don't have a color, use the base's color.
	//
	if (!m_bGotColor)
	{
		m_rgbColor = pBase->GetColor();
		m_bGotColor = true;
	}	
}


//-----------------------------------------------------------------------------
// Purpose: Adds the given GDInputVariable to this GDClass's list of variables.
// Input  : pVar - 
//			pBase - 
//			iBaseIndex - 
//			iVarIndex - 
// Output : Returns TRUE if the pVar pointer was copied directly into this GDClass,
//			FALSE if not. If this function returns TRUE, pVar should not be
//			deleted by the caller.
//-----------------------------------------------------------------------------
BOOL GDclass::AddVariable(GDinputvariable *pVar, GDclass *pBase, int iBaseIndex, int iVarIndex)
{
	int iThisIndex;
	GDinputvariable *pThisVar = VarForName(pVar->GetName(), &iThisIndex);
	
	//
	// Check to see if we are overriding an existing variable definition.
	//
	if (pThisVar != NULL)
	{
		//
		// Same name, different type. Flag this as an error.
		//
		if (pThisVar->GetType() != pVar->GetType())
		{
			return(false);
		}

		GDinputvariable *pAddVar;
		bool bReturn;

		//
		// Check to see if we need to combine a choices/flags array.
		//
		if (pVar->GetType() == ivFlags || pVar->GetType() == ivChoices)
		{
			//
			// Combine two variables' flags into a new variable. Add the new
			// variable to the local variable list and modify the old variable's
			// position in our variable map to reflect the new local variable.
			// This way, we can have multiple inheritance.
			//
			GDinputvariable *pNewVar = new GDinputvariable;

			*pNewVar = *pVar;
			pNewVar->Merge(*pThisVar);

			pAddVar = pNewVar;
			bReturn = false;
		}
		else
		{
			pAddVar = pVar;
			bReturn = true;
		}

		if (m_VariableMap[iThisIndex][0] == -1)
		{
			//
			// "pThisVar" is a leaf variable - we can remove since it is overridden.
			//
			int nIndex = m_Variables.Find(pThisVar);
			Assert(nIndex != -1);
			delete pThisVar;

			m_Variables.Element(nIndex) = pAddVar;

			//
			// No need to modify variable map - we just replaced
			// the pointer in the local variable list.
			//
		}
		else
		{
			//
			// "pThisVar" was declared in a base class - we can replace the reference in
			// our variable map with the new variable.
			//
			m_VariableMap[iThisIndex][0] = iBaseIndex;

			if (iBaseIndex == -1)
			{
				m_Variables.AddToTail(pAddVar);
				m_VariableMap[iThisIndex][1] = m_Variables.Count() - 1;
			}
			else
			{
				m_VariableMap[iThisIndex][1] = iVarIndex;
			}
		}

		return(bReturn);
	}
	
	//
	// New variable.
	//
	if (iBaseIndex == -1)
	{
		//
		// Variable declared in the leaf class definition - add it to the list.
		//
		m_Variables.AddToTail(pVar);
	}

	//
	// Too many variables already declared in this class definition - abort.
	//
	if (m_nVariables == GD_MAX_VARIABLES)
	{
		//CUtlString str;
		//str.Format("Too many gamedata variables for class \"%s\"", m_szName);
		//AfxMessageBox(str);

		return(false);
	}

	//
	// Add the variable to our list.
	//
	m_VariableMap[m_nVariables][0] = iBaseIndex;
	m_VariableMap[m_nVariables][1] = iVarIndex;
	++m_nVariables;
	
	//
	// We added the pointer to our list of items (see Variables.AddToTail, above) so
	// we must return true here.
	//
	return(true);
}


//-----------------------------------------------------------------------------
// Finds an input by name.
//-----------------------------------------------------------------------------
CClassInput *GDclass::FindInput(const char *szName)
{
	int nCount = GetInputCount();
	for (int i = 0; i < nCount; i++)
	{
		CClassInput *pInput = GetInput(i);
		if (!stricmp(pInput->GetName(), szName))
		{
			return(pInput);
		}
	}

	return(NULL);
}


//-----------------------------------------------------------------------------
// Finds an output by name.
//-----------------------------------------------------------------------------
CClassOutput *GDclass::FindOutput(const char *szName)
{
	int nCount = GetOutputCount();
	for (int i = 0; i < nCount; i++)
	{
		CClassOutput *pOutput = GetOutput(i);
		if (!stricmp(pOutput->GetName(), szName))
		{
			return(pOutput);
		}
	}

	return(NULL);
}


//-----------------------------------------------------------------------------
// Purpose: Gets the mins and maxs of the class's bounding box as read from the
//			FGD file. This controls the onscreen representation of any entities
//			derived from this class.
// Input  : pfMins - Receives minimum X, Y, and Z coordinates for the class.
//			pfMaxs - Receives maximum X, Y, and Z coordinates for the class.
// Output : Returns TRUE if this class has a specified bounding box, FALSE if not.
//-----------------------------------------------------------------------------
BOOL GDclass::GetBoundBox(Vector& pfMins, Vector& pfMaxs)
{
	if (m_bGotSize)
	{
		pfMins[0] = m_bmins[0];
		pfMins[1] = m_bmins[1];
		pfMins[2] = m_bmins[2];

		pfMaxs[0] = m_bmaxs[0];
		pfMaxs[1] = m_bmaxs[1];
		pfMaxs[2] = m_bmaxs[2];
	}

	return(m_bGotSize);
}


//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
CHelperInfo *GDclass::GetHelper(int nIndex)
{
	return m_Helpers.Element(nIndex);
}


//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
CClassInput *GDclass::GetInput(int nIndex)
{
	return m_Inputs.Element(nIndex);
}


//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
CClassOutput *GDclass::GetOutput(int nIndex)
{
	return m_Outputs.Element(nIndex);
}


//-----------------------------------------------------------------------------
// Purpose: 
// Input  : tr - 
//			pGD - 
// Output : Returns TRUE if worth continuing, FALSE otherwise.	
//-----------------------------------------------------------------------------
BOOL GDclass::InitFromTokens(TokenReader& tr, GameData *pGD)
{
	Parent = pGD;

	//
	// Initialize VariableMap
	//
	for (int i = 0; i < GD_MAX_VARIABLES; i++)
	{
		m_VariableMap[i][0] = -1;
		m_VariableMap[i][1] = -1;
	}

	//
	// Parse all specifiers (base, size, color, etc.)
	//
	if (!ParseSpecifiers(tr))
	{
		return(FALSE);
	}

	//
	// Specifiers should be followed by an "="
	//
	if (!GDSkipToken(tr, OPERATOR, "="))
	{
		return(FALSE);
	}

	//
	// Parse the class name.
	//
	if (!GDGetToken(tr, m_szName, sizeof(m_szName), IDENT))
	{
		return(FALSE);
	}

	//
	// Check next operator - if ":", we have a description - if "[",
	// we have no description.
	//
	char szToken[MAX_TOKEN];
	if ((tr.PeekTokenType(szToken,sizeof(szToken)) == OPERATOR) && IsToken(szToken, ":"))
	{
		// Skip ":"
		tr.NextToken(szToken, sizeof(szToken));

		//
		// Free any existing description and set the pointer to NULL so that GDGetToken
		// allocates memory for us.
		//
		delete m_pszDescription;
		m_pszDescription = NULL;

		// Load description
		if (!GDGetTokenDynamic(tr, &m_pszDescription, STRING))
		{
			return(FALSE);
		}
	}

	//
	// Opening square brace.
	//
	if (!GDSkipToken(tr, OPERATOR, "["))
	{
		return(FALSE);
	}

	//
	// Get class variables.
	//
	if (!ParseVariables(tr))
	{
		return(FALSE);
	}

	//
	// Closing square brace.
	//
	if (!GDSkipToken(tr, OPERATOR, "]"))
	{
		return(FALSE);
	}

	return(TRUE);
}


//-----------------------------------------------------------------------------
// Purpose: 
// Input  : &tr - 
// Output : Returns true on success, false on failure.
//-----------------------------------------------------------------------------
bool GDclass::ParseBase(TokenReader &tr)
{
	char szToken[MAX_TOKEN];

	while (1)
	{
		if (!GDGetToken(tr, szToken, sizeof(szToken), IDENT))
		{
			return(false);
		}

		//
		// Find base class in list of classes.
		//
		GDclass *pBase = Parent->ClassForName(szToken);
		if (pBase == NULL)
		{
			GDError(tr, "undefined base class '%s", szToken);
			return(false);
		}

		AddBase(pBase);

		if (!GDGetToken(tr, szToken, sizeof(szToken), OPERATOR))
		{
			return(false);
		}

		if (IsToken(szToken, ")"))
		{
			break;
		}
		else if (!IsToken(szToken, ","))
		{
			GDError(tr, "expecting ',' or ')', but found %s", szToken);
			return(false);
		}
	}

	return(true);
}


//-----------------------------------------------------------------------------
// Purpose: 
// Input  : &tr - 
// Output : Returns true on success, false on failure.
//-----------------------------------------------------------------------------
bool GDclass::ParseColor(TokenReader &tr)
{
	char szToken[MAX_TOKEN];

	//
	// Red.
	//
	if (!GDGetToken(tr, szToken, sizeof(szToken), INTEGER))
	{
		return(false);
	}
	BYTE r = atoi(szToken);

	//
	// Green.
	//
	if (!GDGetToken(tr, szToken, sizeof(szToken), INTEGER))
	{
		return(false);
	}
	BYTE g = atoi(szToken);

	//
	// Blue.
	//
	if (!GDGetToken(tr, szToken, sizeof(szToken), INTEGER))
	{
		return(false);
	}
	BYTE b = atoi(szToken);

	m_rgbColor.r = r;
	m_rgbColor.g = g;
	m_rgbColor.b = b;
	m_rgbColor.a = 0;

	m_bGotColor = true;

	if (!GDGetToken(tr, szToken, sizeof(szToken), OPERATOR, ")"))
	{
		return(false);
	}
	
	return(true);
}


//-----------------------------------------------------------------------------
// Purpose: Parses a helper from the FGD file. Helpers are of the following format:
//
//			<helpername>(<parameter 0> <parameter 1> ... <parameter n>)
//
//			When this function is called, the helper name has already been parsed.
// Input  : tr - Tokenreader to use for parsing.
//			pszHelperName - Name of the helper being declared.
// Output : Returns true on success, false on failure.
//-----------------------------------------------------------------------------
bool GDclass::ParseHelper(TokenReader &tr, char *pszHelperName)
{
	char szToken[MAX_TOKEN];

	CHelperInfo *pHelper = new CHelperInfo;
	pHelper->SetName(pszHelperName);

	bool bCloseParen = false;
	while (!bCloseParen)
	{
		trtoken_t eType = tr.PeekTokenType(szToken,sizeof(szToken));

		if (eType == OPERATOR)
		{
			if (!GDGetToken(tr, szToken, sizeof(szToken), OPERATOR))
			{
				delete pHelper;
				return(false);
			}

			if (IsToken(szToken, ")"))
			{
				bCloseParen = true;
			}
			else if (IsToken(szToken, "="))
			{
				delete pHelper;
				return(false);
			}
		}
		else
		{
			if (!GDGetToken(tr, szToken, sizeof(szToken), eType))
			{
				delete pHelper;
				return(false);
			}
			else
			{
				pHelper->AddParameter(szToken);
			}
		}
	}

	m_Helpers.AddToTail(pHelper);

	return(true);
}


//-----------------------------------------------------------------------------
// Purpose: 
// Input  : &tr - 
// Output : Returns true on success, false on failure.
//-----------------------------------------------------------------------------
bool GDclass::ParseSize(TokenReader &tr)
{
	char szToken[MAX_TOKEN];

	//
	// Mins.
	//
	for (int i = 0; i < 3; i++)
	{
		if (!GDGetToken(tr, szToken, sizeof(szToken), INTEGER))
		{
			return(false);
		}

		m_bmins[i] = (float)atof(szToken);
	}

	if (tr.PeekTokenType(szToken,sizeof(szToken)) == OPERATOR && IsToken(szToken, ","))
	{
		//
		// Skip ","
		//
		tr.NextToken(szToken, sizeof(szToken));

		//
		// Get maxes.
		//
		for (int i = 0; i < 3; i++)
		{
			if (!GDGetToken(tr, szToken, sizeof(szToken), INTEGER))
			{
				return(false);
			}
			m_bmaxs[i] = (float)atof(szToken);
		}
	}
	else
	{
		//
		// Split mins across origin.
		//
		for (int i = 0; i < 3; i++)
		{
			float div2 = m_bmins[i] / 2;
			m_bmaxs[i] = div2;
			m_bmins[i] = -div2;
		}
	}

	m_bGotSize = true;

	if (!GDGetToken(tr, szToken, sizeof(szToken), OPERATOR, ")"))
	{
		return(false);
	}

	return(true);
}


//-----------------------------------------------------------------------------
// Purpose: 
// Input  : &tr - 
// Output : Returns true on success, false on failure.
//-----------------------------------------------------------------------------
bool GDclass::ParseSpecifiers(TokenReader &tr)
{
	char szToken[MAX_TOKEN];

	while (tr.PeekTokenType() == IDENT)
	{
		tr.NextToken(szToken, sizeof(szToken));

		//
		// Handle specifiers that don't have any parens after them.
		//
		if (IsToken(szToken, "halfgridsnap"))
		{
			m_bHalfGridSnap = true;
		}
		else
		{
			//
			// Handle specifiers require parens after them.
			//
			if (!GDSkipToken(tr, OPERATOR, "("))
			{
				return(false);
			}

			if (IsToken(szToken, "base"))
			{
				if (!ParseBase(tr))
				{
					return(false);
				}
			}
			else if (IsToken(szToken, "size"))
			{
				if (!ParseSize(tr))
				{
					return(false);
				}
			}
			else if (IsToken(szToken, "color"))
			{
				if (!ParseColor(tr))
				{
					return(false);
				}
			}
			else if (!ParseHelper(tr, szToken))
			{
				return(false);
			}
		}
	}

	return(true);
}


//-----------------------------------------------------------------------------
// Purpose: Reads an input using a given token reader. If the input is
//			read successfully, the input is added to this class. If not, a
//			parsing failure is returned.
// Input  : tr - Token reader to use for parsing.
// Output : Returns true on success, false on failure.
//-----------------------------------------------------------------------------
bool GDclass::ParseInput(TokenReader &tr)
{
	char szToken[MAX_TOKEN];

	if (!GDGetToken(tr, szToken, sizeof(szToken), IDENT, "input"))
	{
		return(false);
	}

	CClassInput *pInput = new CClassInput;

	bool bReturn = ParseInputOutput(tr, pInput);
	if (bReturn)
	{
		AddInput(pInput);
	}
	else
	{
		delete pInput;
	}

	return(bReturn);
}


//-----------------------------------------------------------------------------
// Purpose: Reads an input or output using a given token reader.
// Input  : tr - Token reader to use for parsing.
//			pInputOutput - Input or output to fill out.
// Output : Returns true on success, false on failure.
//-----------------------------------------------------------------------------
bool GDclass::ParseInputOutput(TokenReader &tr, CClassInputOutputBase *pInputOutput)
{
	char szToken[MAX_TOKEN];

	//
	// Read the name.
	//
	if (!GDGetToken(tr, szToken, sizeof(szToken), IDENT))
	{
		return(false);
	}

	pInputOutput->SetName(szToken);

	//
	// Read the type.
	//
	if (!GDGetToken(tr, szToken, sizeof(szToken), OPERATOR, "("))
	{
		return(false);
	}

	if (!GDGetToken(tr, szToken, sizeof(szToken), IDENT))
	{
		return(false);
	}

	InputOutputType_t eType = pInputOutput->SetType(szToken);
	if (eType == iotInvalid)
	{
		GDError(tr, "bad input/output type '%s'", szToken);
		return(false);
	}

	if (!GDGetToken(tr, szToken, sizeof(szToken), OPERATOR, ")"))
	{
		return(false);
	}

	//
	// Check the next operator - if ':', we have a description.
	//
	if ((tr.PeekTokenType(szToken,sizeof(szToken)) == OPERATOR) && (IsToken(szToken, ":")))
	{
		//
		// Skip the ":".
		//
		tr.NextToken(szToken, sizeof(szToken));

		//
		// Read the description.
		//
		char *pszDescription;
		if (!GDGetTokenDynamic(tr, &pszDescription, STRING))
		{
			return(false);
		}

		pInputOutput->SetDescription(pszDescription);
	}

	return(true);
}


//-----------------------------------------------------------------------------
// Purpose: Reads an output using a given token reader. If the output is
//			read successfully, the output is added to this class. If not, a
//			parsing failure is returned.
// Input  : tr - Token reader to use for parsing.
// Output : Returns true on success, false on failure.
//-----------------------------------------------------------------------------
bool GDclass::ParseOutput(TokenReader &tr)
{
	char szToken[MAX_TOKEN];

	if (!GDGetToken(tr, szToken, sizeof(szToken), IDENT, "output"))
	{
		return(false);
	}

	CClassOutput *pOutput = new CClassOutput;

	bool bReturn = ParseInputOutput(tr, pOutput);
	if (bReturn)
	{
		AddOutput(pOutput);
	}
	else
	{
		delete pOutput;
	}

	return(bReturn);
}


//-----------------------------------------------------------------------------
// Purpose: 
// Input  : &tr - 
// Output : Returns true on success, false on failure.
//-----------------------------------------------------------------------------
bool GDclass::ParseVariables(TokenReader &tr)
{
	while (1)
	{
		char szToken[MAX_TOKEN];

		if (tr.PeekTokenType(szToken,sizeof(szToken)) == OPERATOR)
		{
			break;
		}

		if (!stricmp(szToken, "input"))
		{
			if (!ParseInput(tr))
			{
				return(false);
			}

			continue;
		}

		if (!stricmp(szToken, "output"))
		{
			if (!ParseOutput(tr))
			{
				return(false);
			}

			continue;
		}

		if (!stricmp(szToken, "key"))
		{
			GDGetToken(tr, szToken, sizeof(szToken));
		}

		GDinputvariable * var = new GDinputvariable;
		if (!var->InitFromTokens(tr))
		{
			delete var;
			return(false);
		}

		int nDupIndex;
		GDinputvariable *pDupVar = VarForName(var->GetName(), &nDupIndex);
		
		// check for duplicate variable definitions
		if (pDupVar)
		{
			// Same name, different type.
			if (pDupVar->GetType() != var->GetType())
			{
				char szError[_MAX_PATH];

				sprintf(szError, "%s: Variable '%s' is multiply defined with different types.", GetName(), var->GetName());
				GDError(tr, szError);
			}
		}

		if (!AddVariable(var, this, -1, m_Variables.Count()))
		{
			delete var;
		}
	}

	return(true);
}


//-----------------------------------------------------------------------------
// Purpose: 
// Input  : iIndex - 
// Output : GDinputvariable *
//-----------------------------------------------------------------------------
GDinputvariable *GDclass::GetVariableAt(int iIndex)
{
	if ( iIndex < 0 || iIndex >= m_nVariables )
		return NULL;

	if (m_VariableMap[iIndex][0] == -1)
	{
		return m_Variables.Element(m_VariableMap[iIndex][1]);
	}

	// find var's owner
	GDclass *pVarClass = Parent->GetClass(m_VariableMap[iIndex][0]);

	// find var in pVarClass
	return pVarClass->GetVariableAt(m_VariableMap[iIndex][1]);
}


//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
GDinputvariable *GDclass::VarForName(const char *pszName, int *piIndex)
{
	for(int i = 0; i < GetVariableCount(); i++)
	{
		GDinputvariable *pVar = GetVariableAt(i);
		if(!strcmpi(pVar->GetName(), pszName))
		{
			if(piIndex)
				piIndex[0] = i;
			return pVar;
		}
	}

	return NULL;
}

void GDclass::GetHelperForGDVar( GDinputvariable *pVar, CUtlVector<const char *> *pszHelperName )
{
	const char *pszName = pVar->GetName();
	for( int i = 0; i < GetHelperCount(); i++ )
	{
		CHelperInfo *pHelper = GetHelper( i );
		int nParamCount = pHelper->GetParameterCount();
		for ( int j = 0; j < nParamCount; j++ )
		{
			if ( !strcmpi( pszName, pHelper->GetParameter( j ) ) )
			{
				pszHelperName->AddToTail(pHelper->GetName());
			}
		}
	}
}