From a0c29e7dd67abb15c74c85f07741784877edfdcd Mon Sep 17 00:00:00 2001 From: Joe Ludwig Date: Mon, 2 Sep 2013 11:39:10 -0700 Subject: General: * Fixed a variety of server browser issues with mods based on this SDK * Fixed many warnings on various platforms * Added source code for fgdlib and raytrace * Updated many source files with the latest shared source from TF2. OSX: * Added support for Xcode 4.6 * Switched OSX builds to use Xcode instead of makefiles * Moved libs from src/lib/osx32 to src/lib/public/osx32 or src/lib/common/osx32 to match windows better. Linux: * Moved libs from src/lib/linux32 to src/lib/public/linux32 or src/lib/common/linux32 to match windows better. --- sp/src/fgdlib/gdvar.cpp | 729 ++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 729 insertions(+) create mode 100644 sp/src/fgdlib/gdvar.cpp (limited to 'sp/src/fgdlib/gdvar.cpp') diff --git a/sp/src/fgdlib/gdvar.cpp b/sp/src/fgdlib/gdvar.cpp new file mode 100644 index 00000000..5b9a21be --- /dev/null +++ b/sp/src/fgdlib/gdvar.cpp @@ -0,0 +1,729 @@ +//========= Copyright Valve Corporation, All rights reserved. ============// +// +//============================================================================= + +#include "fgdlib/fgdlib.h" +#include "fgdlib/GameData.h" +#include "fgdlib/WCKeyValues.h" +#include "fgdlib/gdvar.h" + +// memdbgon must be the last include file in a .cpp file!!! +#include + + +typedef struct +{ + GDIV_TYPE eType; // The enumeration of this type. + char *pszName; // The name of this type. + trtoken_t eStoreAs; // How this type is stored (STRING, INTEGER, etc). +} TypeMap_t; + + +//----------------------------------------------------------------------------- +// Maps type names to type enums and parsing logic for values. +//----------------------------------------------------------------------------- +static TypeMap_t TypeMap[] = +{ + { ivAngle, "angle", STRING }, + { ivChoices, "choices", STRING }, + { ivColor1, "color1", STRING }, + { ivColor255, "color255", STRING }, + { ivDecal, "decal", STRING }, + { ivFlags, "flags", INTEGER }, + { ivInteger, "integer", INTEGER }, + { ivSound, "sound", STRING }, + { ivSprite, "sprite", STRING }, + { ivString, "string", STRING }, + { ivStudioModel, "studio", STRING }, + { ivTargetDest, "target_destination", STRING }, + { ivTargetSrc, "target_source", STRING }, + { ivTargetNameOrClass, "target_name_or_class", STRING }, // Another version of target_destination that accepts class names + { ivVector, "vector", STRING }, + { ivNPCClass, "npcclass", STRING }, + { ivFilterClass, "filterclass", STRING }, + { ivFloat, "float", STRING }, + { ivMaterial, "material", STRING }, + { ivScene, "scene", STRING }, + { ivSide, "side", STRING }, + { ivSideList, "sidelist", STRING }, + { ivOrigin, "origin", STRING }, + { ivAxis, "axis", STRING }, + { ivVecLine, "vecline", STRING }, + { ivPointEntityClass, "pointentityclass", STRING }, + { ivNodeDest, "node_dest", INTEGER }, + { ivInstanceFile, "instance_file", STRING }, + { ivAngleNegativePitch, "angle_negative_pitch", STRING }, + { ivInstanceVariable, "instance_variable", STRING }, + { ivInstanceParm, "instance_parm", STRING }, +}; + + +char *GDinputvariable::m_pszEmpty = ""; + + +//----------------------------------------------------------------------------- +//----------------------------------------------------------------------------- +GDinputvariable::GDinputvariable(void) +{ + m_szDefault[0] = 0; + m_nDefault = 0; + m_szValue[0] = 0; + m_bReportable = FALSE; + m_bReadOnly = false; + m_pszDescription = NULL; +} + + +//----------------------------------------------------------------------------- +// Purpose: construct generally used for creating a temp instance parm type +// Input : szType - the textual type of this variable +// szName - the name description of this variable +//----------------------------------------------------------------------------- +GDinputvariable::GDinputvariable( const char *szType, const char *szName ) +{ + m_szDefault[0] = 0; + m_nDefault = 0; + m_szValue[0] = 0; + m_bReportable = FALSE; + m_bReadOnly = false; + m_pszDescription = NULL; + + m_eType = GetTypeFromToken( szType ); + strcpy( m_szName, szName ); +} + + +//----------------------------------------------------------------------------- +// Purpose: Destructor. +//----------------------------------------------------------------------------- +GDinputvariable::~GDinputvariable(void) +{ + delete [] m_pszDescription; + m_Items.RemoveAll(); +} + + +//----------------------------------------------------------------------------- +// Purpose: Implements the copy operator. +//----------------------------------------------------------------------------- +GDinputvariable &GDinputvariable::operator =(GDinputvariable &Other) +{ + m_eType = Other.GetType(); + strcpy(m_szName, Other.m_szName); + strcpy(m_szLongName, Other.m_szLongName); + strcpy(m_szDefault, Other.m_szDefault); + + // + // Copy the description. + // + delete [] m_pszDescription; + if (Other.m_pszDescription != NULL) + { + m_pszDescription = new char[strlen(Other.m_pszDescription) + 1]; + strcpy(m_pszDescription, Other.m_pszDescription); + } + else + { + m_pszDescription = NULL; + } + + m_nDefault = Other.m_nDefault; + m_bReportable = Other.m_bReportable; + m_bReadOnly = Other.m_bReadOnly; + + m_Items.RemoveAll(); + + int nCount = Other.m_Items.Count(); + for (int i = 0; i < nCount; i++) + { + m_Items.AddToTail(Other.m_Items.Element(i)); + } + + return(*this); +} + + +//----------------------------------------------------------------------------- +// Purpose: Returns the storage format of a given variable type. +// Input : pszToken - Sting containing the token. +// Output : GDIV_TYPE corresponding to the token in the string, ivBadType if the +// string does not correspond to a valid type. +//----------------------------------------------------------------------------- +trtoken_t GDinputvariable::GetStoreAsFromType(GDIV_TYPE eType) +{ + for (int i = 0; i < sizeof(TypeMap) / sizeof(TypeMap[0]); i++) + { + if (TypeMap[i].eType == eType) + { + return(TypeMap[i].eStoreAs); + } + } + + Assert(FALSE); + return(STRING); +} + + +//----------------------------------------------------------------------------- +// Purpose: Returns the enumerated type of a string token. +// Input : pszToken - Sting containing the token. +// Output : GDIV_TYPE corresponding to the token in the string, ivBadType if the +// string does not correspond to a valid type. +//----------------------------------------------------------------------------- +GDIV_TYPE GDinputvariable::GetTypeFromToken(const char *pszToken) +{ + for (int i = 0; i < sizeof(TypeMap) / sizeof(TypeMap[0]); i++) + { + if (IsToken(pszToken, TypeMap[i].pszName)) + { + return(TypeMap[i].eType); + } + } + + return(ivBadType); +} + + +//----------------------------------------------------------------------------- +// Purpose: Returns a string representing the type of this variable, eg. "integer". +//----------------------------------------------------------------------------- +const char *GDinputvariable::GetTypeText(void) +{ + for (int i = 0; i < sizeof(TypeMap) / sizeof(TypeMap[0]); i++) + { + if (TypeMap[i].eType == m_eType) + { + return(TypeMap[i].pszName); + } + } + + return("unknown"); +} + + +//----------------------------------------------------------------------------- +// Purpose: +// Input : tr - +// Output : Returns TRUE on success, FALSE on failure. +//----------------------------------------------------------------------------- +BOOL GDinputvariable::InitFromTokens(TokenReader& tr) +{ + char szToken[128]; + + if (!GDGetToken(tr, m_szName, sizeof(m_szName), IDENT)) + { + return FALSE; + } + + if (!GDSkipToken(tr, OPERATOR, "(")) + { + return FALSE; + } + + // check for "reportable" marker + trtoken_t ttype = tr.NextToken(szToken, sizeof(szToken)); + if (ttype == OPERATOR) + { + if (!strcmp(szToken, "*")) + { + m_bReportable = true; + } + } + else + { + tr.Stuff(ttype, szToken); + } + + // get type + if (!GDGetToken(tr, szToken, sizeof(szToken), IDENT)) + { + return FALSE; + } + + if (!GDSkipToken(tr, OPERATOR, ")")) + { + return FALSE; + } + + // + // Check for known variable types. + // + m_eType = GetTypeFromToken(szToken); + if (m_eType == ivBadType) + { + GDError(tr, "'%s' is not a valid variable type", szToken); + return FALSE; + } + + // + // Look ahead at the next token. + // + ttype = tr.PeekTokenType(szToken,sizeof(szToken)); + + // + // Check for the "readonly" specifier. + // + if ((ttype == IDENT) && IsToken(szToken, "readonly")) + { + tr.NextToken(szToken, sizeof(szToken)); + m_bReadOnly = true; + + // + // Look ahead at the next token. + // + ttype = tr.PeekTokenType(szToken,sizeof(szToken)); + } + + // + // Check for the ':' indicating a long name. + // + if (ttype == OPERATOR && IsToken(szToken, ":")) + { + // + // Eat the ':'. + // + tr.NextToken(szToken, sizeof(szToken)); + + if (m_eType == ivFlags) + { + GDError(tr, "flag sets do not have long names"); + return FALSE; + } + + // + // Get the long name. + // + if (!GDGetToken(tr, m_szLongName, sizeof(m_szLongName), STRING)) + { + return(FALSE); + } + + // + // Look ahead at the next token. + // + ttype = tr.PeekTokenType(szToken,sizeof(szToken)); + + // + // Check for the ':' indicating a default value. + // + if (ttype == OPERATOR && IsToken(szToken, ":")) + { + // + // Eat the ':'. + // + tr.NextToken(szToken, sizeof(szToken)); + + // + // Look ahead at the next token. + // + ttype = tr.PeekTokenType(szToken,sizeof(szToken)); + if (ttype == OPERATOR && IsToken(szToken, ":")) + { + // + // No default value provided, skip to the description. + // + } + else + { + // + // Determine how to parse the default value. If this is a choices field, the + // default could either be a string or an integer, so we must look ahead and + // use whichever is there. + // + trtoken_t eStoreAs = GetStoreAsFromType(m_eType); + + if (eStoreAs == STRING) + { + if (!GDGetToken(tr, m_szDefault, sizeof(m_szDefault), STRING)) + { + return(FALSE); + } + } + else if (eStoreAs == INTEGER) + { + if (!GDGetToken(tr, szToken, sizeof(szToken), INTEGER)) + { + return(FALSE); + } + + m_nDefault = atoi(szToken); + } + + // + // Look ahead at the next token. + // + ttype = tr.PeekTokenType(szToken,sizeof(szToken)); + } + } + + // + // Check for the ':' indicating a description. + // + if (ttype == OPERATOR && IsToken(szToken, ":")) + { + // + // Eat the ':'. + // + tr.NextToken(szToken, sizeof(szToken)); + + // + // Read the description. + // + + // If we've already read a description then free it to avoid memory leaks. + if ( m_pszDescription ) + { + delete [] m_pszDescription; + m_pszDescription = NULL; + } + if (!GDGetTokenDynamic(tr, &m_pszDescription, STRING)) + { + return(FALSE); + } + + // + // Look ahead at the next token. + // + ttype = tr.PeekTokenType(szToken,sizeof(szToken)); + } + } + else + { + // + // Default long name is short name. + // + strcpy(m_szLongName, m_szName); + } + + // + // Check for the ']' indicating the end of the class definition. + // + if ((ttype == OPERATOR && IsToken(szToken, "]")) || ttype != OPERATOR) + { + if (m_eType == ivFlags || m_eType == ivChoices) + { + // + // Can't define a flags or choices variable without providing any flags or choices. + // + GDError(tr, "no %s specified", m_eType == ivFlags ? "flags" : "choices"); + return(FALSE); + } + return(TRUE); + } + + if (!GDSkipToken(tr, OPERATOR, "=")) + { + return(FALSE); + } + + if (m_eType != ivFlags && m_eType != ivChoices) + { + GDError(tr, "didn't expect '=' here"); + return(FALSE); + } + + // should be '[' to start flags/choices + if (!GDSkipToken(tr, OPERATOR, "[")) + { + return(FALSE); + } + + // get flags? + if (m_eType == ivFlags) + { + GDIVITEM ivi; + + while (1) + { + ttype = tr.PeekTokenType(); + if (ttype != INTEGER) + { + break; + } + + // store bitflag value + GDGetToken(tr, szToken, sizeof(szToken), INTEGER); + sscanf( szToken, "%lu", &ivi.iValue ); + + // colon.. + if (!GDSkipToken(tr, OPERATOR, ":")) + { + return FALSE; + } + + // get description + if (!GDGetToken(tr, szToken, sizeof(szToken), STRING)) + { + return FALSE; + } + strcpy(ivi.szCaption, szToken); + + // colon.. + if (!GDSkipToken(tr, OPERATOR, ":")) + { + return FALSE; + } + + // get default setting + if (!GDGetToken(tr, szToken, sizeof(szToken), INTEGER)) + { + return FALSE; + } + ivi.bDefault = atoi(szToken) ? TRUE : FALSE; + + // add item to array of items + m_Items.AddToTail(ivi); + } + + // Set the default value. + unsigned long nDefault = 0; + for (int i = 0; i < m_Items.Count(); i++) + { + if (m_Items[i].bDefault) + nDefault |= m_Items[i].iValue; + } + m_nDefault = (int)nDefault; + Q_snprintf( m_szDefault, sizeof( m_szDefault ), "%d", m_nDefault ); + } + else if (m_eType == ivChoices) + { + GDIVITEM ivi; + + while (1) + { + ttype = tr.PeekTokenType(); + if ((ttype != INTEGER) && (ttype != STRING)) + { + break; + } + + // store choice value + GDGetToken(tr, szToken, sizeof(szToken), ttype); + ivi.iValue = 0; + strcpy(ivi.szValue, szToken); + + // colon + if (!GDSkipToken(tr, OPERATOR, ":")) + { + return FALSE; + } + + // get description + if (!GDGetToken(tr, szToken, sizeof(szToken), STRING)) + { + return FALSE; + } + + strcpy(ivi.szCaption, szToken); + + m_Items.AddToTail(ivi); + } + } + + if (!GDSkipToken(tr, OPERATOR, "]")) + { + return FALSE; + } + + return TRUE; +} + + +//----------------------------------------------------------------------------- +// Purpose: Decodes a key value from a string. +// Input : pkv - Pointer to the key value object containing string encoded value. +//----------------------------------------------------------------------------- +void GDinputvariable::FromKeyValue(MDkeyvalue *pkv) +{ + trtoken_t eStoreAs = GetStoreAsFromType(m_eType); + + if (eStoreAs == STRING) + { + strcpy(m_szValue, pkv->szValue); + } + else if (eStoreAs == INTEGER) + { + m_nValue = atoi(pkv->szValue); + } +} + + +//----------------------------------------------------------------------------- +// Purpose: Determines whether the given flag is set (assuming this is an ivFlags). +// Input : uCheck - Flag to check. +// Output : Returns TRUE if flag is set, FALSE if not. +//----------------------------------------------------------------------------- +BOOL GDinputvariable::IsFlagSet(unsigned int uCheck) +{ + Assert(m_eType == ivFlags); + return (((unsigned int)m_nValue & uCheck) == uCheck) ? TRUE : FALSE; +} + + +//----------------------------------------------------------------------------- +// Purpose: Combines the flags or choices items from another variable into our +// list of flags or choices. Ours take priority if collisions occur. +// Input : Other - The variable whose items are being merged with ours. +//----------------------------------------------------------------------------- +void GDinputvariable::Merge(GDinputvariable &Other) +{ + // + // Only valid if we are of the same type. + // + if (Other.GetType() != GetType()) + { + return; + } + + // + // Add Other's items to this ONLY if there is no same-value entry + // for a specific item. + // + bool bFound = false; + int nOurItems = m_Items.Count(); + for (int i = 0; i < Other.m_Items.Count(); i++) + { + GDIVITEM &TheirItem = Other.m_Items[i]; + for (int j = 0; j < nOurItems; j++) + { + GDIVITEM &OurItem = m_Items[j]; + if (TheirItem.iValue == OurItem.iValue) + { + bFound = true; + break; + } + } + + if (!bFound) + { + // + // Not found in our list - add their item to our list. + // + m_Items.AddToTail(TheirItem); + } + } +} + + +//----------------------------------------------------------------------------- +// Purpose: Determines whether the given flag is set (assuming this is an ivFlags). +// Input : uFlags - Flags to set. +// bSet - TRUE to set the flags, FALSE to clear them. +//----------------------------------------------------------------------------- +void GDinputvariable::SetFlag(unsigned int uFlags, BOOL bSet) +{ + Assert(m_eType == ivFlags); + if (bSet) + { + m_nValue |= uFlags; + } + else + { + m_nValue &= ~uFlags; + } +} + + +//----------------------------------------------------------------------------- +// Purpose: Sets this keyvalue to its default value. +//----------------------------------------------------------------------------- +void GDinputvariable::ResetDefaults(void) +{ + if (m_eType == ivFlags) + { + m_nValue = 0; + + // + // Run thru flags and set any default flags. + // + int nCount = m_Items.Count(); + for (int i = 0; i < nCount; i++) + { + if (m_Items[i].bDefault) + { + m_nValue |= GetFlagMask(i); + } + } + } + else + { + m_nValue = m_nDefault; + strcpy(m_szValue, m_szDefault); + } +} + + +//----------------------------------------------------------------------------- +// Purpose: Encodes a key value as a string. +// Input : pkv - Pointer to the key value object to receive the encoded string. +//----------------------------------------------------------------------------- +void GDinputvariable::ToKeyValue(MDkeyvalue *pkv) +{ + strcpy(pkv->szKey, m_szName); + + trtoken_t eStoreAs = GetStoreAsFromType(m_eType); + + if (eStoreAs == STRING) + { + strcpy(pkv->szValue, m_szValue); + } + else if (eStoreAs == INTEGER) + { + itoa(m_nValue, pkv->szValue, 10); + } +} + + +//----------------------------------------------------------------------------- +// Purpose: Returns the description string that corresponds to a value string +// for a choices list. +// Input : pszString - The choices value string. +// Output : Returns the description string. +//----------------------------------------------------------------------------- +const char *GDinputvariable::ItemStringForValue(const char *szValue) +{ + int nCount = m_Items.Count(); + for (int i = 0; i < nCount; i++) + { + if (!stricmp(m_Items[i].szValue, szValue)) + { + return(m_Items[i].szCaption); + } + } + + return(NULL); +} + + +//----------------------------------------------------------------------------- +// Purpose: Returns the value string that corresponds to a description string +// for a choices list. +// Input : pszString - The choices description string. +// Output : Returns the value string. +//----------------------------------------------------------------------------- +const char *GDinputvariable::ItemValueForString(const char *szString) +{ + int nCount = m_Items.Count(); + for (int i = 0; i < nCount; i++) + { + if (!strcmpi(m_Items[i].szCaption, szString)) + { + return(m_Items[i].szValue); + } + } + + return(NULL); +} + + +//----------------------------------------------------------------------------- +// Purpose: this function will let you iterate through the text names of the variable types +// Input : eType - the type to get the text of +// Output : returns the textual name +//----------------------------------------------------------------------------- +const char *GDinputvariable::GetVarTypeName( GDIV_TYPE eType ) +{ + return TypeMap[ eType ].pszName; +} + + -- cgit v1.2.3