コード例 #1
0
ファイル: BanIPMgr.cpp プロジェクト: Arc0re/lithtech
bool BanIPMgr_Impl::ReadBans( )
{
	CButeMgr banBute;
	banBute.Parse( "BanList.txt" );

	char szBanKey[128] = "";
	char szClientIP[16] = "";
	int nBanIndex = 0;

	// Read in the current set of bans.
	while( 1 )
	{
		// Read the next banned IP.
		sprintf( szBanKey, "Ban%d", nBanIndex );
		banBute.GetString( "Bans", szBanKey, "", szClientIP, ARRAY_LEN( szClientIP ));

		// If we didn't find one, the stop looking.
		if( !banBute.Success( ))
			break;

		// Add the ban.
		AddBan( szClientIP );
		nBanIndex++;
	}	

	return true;
}
コード例 #2
0
ファイル: BanIPMgr.cpp プロジェクト: Arc0re/lithtech
bool BanIPMgr_Impl::WriteBans( )
{
	// If not initialized, we can't write out the bans yet.
	if( !m_bInitialized )
		  

		return false;

	CButeMgr banBute;
	char szBanKey[128] = "";
	char szClientIP[16] = "";
	int nBanIndex = 0;

	// Look through list of banned ip's.
	for( BanList::iterator iter = m_BanList.begin( ); iter != m_BanList.end( ); iter++ )
	{
		ClientIP const& bannedIP = *iter;

		// Convert it to a string.
		if( !ConvertClientIPToString( bannedIP, szClientIP, ARRAY_LEN( szClientIP )))
			return false;

		// Write the banned IP.
		sprintf( szBanKey, "Ban%d", nBanIndex );
		banBute.SetString( "Bans", szBanKey, szClientIP );

		nBanIndex++;
	}

	// Save the list.
	banBute.Save( "BanList.txt" );

	return true;
}
コード例 #3
0
ファイル: NetDefs.cpp プロジェクト: Arc0re/lithtech
LTBOOL ServerOption::InitializeFromBute(CButeMgr & buteMgr, const char* aTagName)
{
    if (!aTagName) return LTFALSE;


	CString str = buteMgr.GetString(aTagName, SO_VARIABLE);
	if (!str.IsEmpty())
	{
		strncpy(szVariable, (char*)(LPCSTR)str, sizeof(szVariable));
	}
	else
        szVariable[0] = LTNULL;

	str = buteMgr.GetString(aTagName, SO_SERV_VARIABLE);
	if (!str.IsEmpty())
	{
		strncpy(szServVariable, (char*)(LPCSTR)str, sizeof(szServVariable));
	}
	else
        strncpy(szServVariable, szVariable, sizeof(szServVariable));

	nNameId = buteMgr.GetInt(aTagName, SO_NAME,0);
	nHelpId = buteMgr.GetInt(aTagName, SO_HELP,0);
	eType = (eOptionType) buteMgr.GetInt(aTagName, SO_TYPE,(int)SO_UNKNOWN);
	eGameType = (GameType) buteMgr.GetInt(aTagName, SO_GAME_TYPE,(int)SINGLE);

	nNumStrings = 0;
	str = buteMgr.GetString(aTagName, SO_STRINGS);
	if (!str.IsEmpty())
	{
		char szTemp[128];
		char *pNum;
		strncpy(szTemp, (char*)(LPCSTR)str, sizeof(szTemp));

		pNum = strtok(szTemp,",");
		while (pNum && nNumStrings < SO_MAX_STRINGS)
		{
			nStringId[nNumStrings] = atoi(pNum);
			nNumStrings++;
			pNum = strtok(NULL,",");
		}
	}


	for (int i = nNumStrings; i < SO_MAX_STRINGS; i++)
		nStringId[i] = 0;

    CPoint zero(0, 0);
    CPoint tmp = buteMgr.GetPoint(aTagName, SO_RANGE, zero);
	nSliderMin = tmp.x;
	nSliderMax = tmp.y;

	nSliderInc = buteMgr.GetInt(aTagName, SO_INCREMENT,0);
    fSliderScale = (LTFLOAT)buteMgr.GetDouble(aTagName, SO_SCALE,1.0f);

    fDefault = fSliderScale * (LTFLOAT)buteMgr.GetDouble(aTagName, SO_DEFAULT,0.0f);

    return LTTRUE;
}
コード例 #4
0
ファイル: PerformanceMgr.cpp プロジェクト: rickyharis39/nolf2
void CPerformanceMgr::SavePerformanceOptions(CButeMgr &buteMgr,sPerformCfg *pCfg)
{

	for (int i = 0; i < kNumDetailSettings; i++)
	{
		buteMgr.SetInt("Settings",sSettings[i].szName, pCfg->nSettings[i]);
	}

	for (int grp = 0; grp < kNumTextureGroups; grp++)
	{
		buteMgr.SetInt("Details",sTextureGroups[grp].szName, pCfg->nDetails[grp]);
	}
}
コード例 #5
0
ファイル: FXStructs.cpp プロジェクト: Arc0re/lithtech
LTBOOL BuildPolyDebrisFXList(PolyDebrisFXList & list, CButeMgr & buteMgr,
							char* pTagBase)
{
    if (!pTagBase) return LTFALSE;

	int nNum = 0;
	sprintf(s_aTagName, "%s%d", pTagBase, nNum);

	// Read in the properties for each scale fx...

	while (buteMgr.Exist(s_aTagName))
	{
		CPolyDebrisFX* pFX = debug_new(CPolyDebrisFX);

		if (pFX && pFX->Init(buteMgr, s_aTagName))
		{
			pFX->nId = nNum;
			list.AddTail(pFX);
		}
		else
		{
			debug_delete(pFX);
            return LTFALSE;
		}

		nNum++;
		sprintf(s_aTagName, "%s%d", pTagBase, nNum);
	}

    return LTTRUE;
}
コード例 #6
0
ファイル: RadarTypeMgr.cpp プロジェクト: rickyharis39/nolf2
bool RADARTYPE::Init( CButeMgr &ButeMgr, char *aTagName )
{
	if( !aTagName ) return false;

	szName		= GetString( ButeMgr, aTagName, RTMGR_NAME, RTMGR_MAX_NAME_LENGTH );
	szIcon		= GetString( ButeMgr, aTagName, RTMGR_ICON, RTMGR_MAX_FILE_PATH );
	nDrawOrder	= ButeMgr.GetInt(aTagName, RTMGR_DRAWORDER,0);

	return true;
}
コード例 #7
0
ファイル: PropHelpGen.cpp プロジェクト: Joincheng/lithtech
// Add the class properties to the bute file
void AddClassProperties(ClassDef *pClass, CString sTagName, BOOL &bClassAdded, CButeMgr &buteMgr)
{
	if (!pClass)
	{
		ASSERT(FALSE);
		return;
	}

	// Go through each property
	int i;
	for (i=0; i < pClass->m_nProps; i++)
	{
		// Get the property
		PropDef *pProperty=&pClass->m_Props[i];

		// Skip hidden properties
		if (pProperty->m_PropFlags & PF_HIDDEN)
		{
			continue;
		}

		// Get the property name
		char *lpszPropName=pProperty->m_PropName;
		
		// Check to see if the property help already exists
		if (!buteMgr.Exist(sTagName, lpszPropName))
		{
			// Add the property
			buteMgr.SetString(sTagName, lpszPropName, "");

			// Display that this was added
			if (!bClassAdded)
			{
				printf("\r\n[%s]\r\n", sTagName);
				bClassAdded=TRUE;
			}
			printf("%s\r\n", lpszPropName);
		}
	}
}
コード例 #8
0
ファイル: PerformanceMgr.cpp プロジェクト: rickyharis39/nolf2
void CPerformanceMgr::LoadPerformanceOptions(CButeMgr &buteMgr,sPerformCfg *pCfg)
{
	for (int i = 0; i < kNumDetailSettings; i++)
	{
		pCfg->nSettings[i] = buteMgr.GetInt("Settings",sSettings[i].szName, 0);
	}

	int nDetail = pCfg->nSettings[kPerform_DetailLevel];
	if ( nDetail >= 0 && nDetail < kNumDetailLevels)
	{
		for (int grp = 0; grp < kNumTextureGroups; grp++)
		{
			pCfg->nDetails[grp] = (int8)sTextureGroups[grp].nSetting[nDetail];
		}

	}
	else
	{
		for (int grp = 0; grp < kNumTextureGroups; grp++)
		{
			pCfg->nDetails[grp] = buteMgr.GetInt("Details",sTextureGroups[grp].szName, 0);
		}
	}
}
コード例 #9
0
ファイル: EditProjectMgr.cpp プロジェクト: Joincheng/lithtech
void CEditProjectMgr::UpdateBUTFile()
{
	//get the resource directory for the currently open project, and add on
	//our filename to get the BUT file
	CString sBUTFile = m_BaseProjectDir + "\\ClassHlp.but";

	//now create a but manager to load this
	CButeMgr* pNewMgr = new CButeMgr;

	//bail if memory failed
	if(pNewMgr == NULL)
		return;

	if (!pNewMgr->Parse(sBUTFile))
	{
		//failed to find a new but file, no worries, just bail
		delete pNewMgr;
		return;
	}

	//this worked, we want to override the old but file with this one
	GetApp()->SetClassHelpButeAgg(pNewMgr);
	
}
コード例 #10
0
LTBOOL SOUNDFILTER::Init(CButeMgr & buteMgr, char* aTagName)
{
    if (!aTagName) return LTFALSE;

    CString str = buteMgr.GetString(aTagName, SFM_NAME);
    if (!str.IsEmpty())
    {
        strncpy(szName, (char*)(LPCSTR)str, ARRAY_LEN(szName));
    }

    str = buteMgr.GetString(aTagName, SFM_FILTERNAME);
    if (!str.IsEmpty())
    {
        strncpy(szFilterName, (char*)(LPCSTR)str, ARRAY_LEN(szFilterName));
    }

    int i;
    for (i=0; i < SFM_MAX_VARIABLES; i++)
    {
        sprintf(s_aAttName, "%s%d", SFM_VARIABLE, i);

        if (buteMgr.Exist(aTagName, s_aAttName))
        {
            str = buteMgr.GetString(aTagName, s_aAttName);
            if (!str.IsEmpty())
            {
                strncpy(szVars[i], (char*)(LPCSTR)str, ARRAY_LEN(szVars[i]));
            }
            nNumVars++;
        }
    }

    int nNumValues = 0;
    for (i=0; i < SFM_MAX_VARIABLES; i++)
    {
        sprintf(s_aAttName, "%s%d", SFM_VALUE, i);

        if (buteMgr.Exist(aTagName, s_aAttName))
        {
            fValues[i] = (LTFLOAT) buteMgr.GetDouble(aTagName, s_aAttName);
            nNumValues++;
        }
    }

    if (nNumVars != nNumValues)
    {
        _ASSERT(LTFALSE);
        return LTFALSE;
    }

    return LTTRUE;
}
コード例 #11
0
ファイル: IntelMgr.cpp プロジェクト: jordandavidson/lithtech
LTBOOL INTEL::Init(CButeMgr & buteMgr, char* aTagName)
{
    if (!aTagName) return LTFALSE;

    nDefaultTextId	= buteMgr.GetInt(aTagName, INTELMGR_DEFAULTTEXTID);
    bChrome		    = (LTBOOL) buteMgr.GetInt(aTagName, INTELMGR_CHROME);
    bChromakey      = (LTBOOL) buteMgr.GetInt(aTagName, INTELMGR_CHROMAKEY);

    CString str = buteMgr.GetString(aTagName, INTELMGR_NAME);
    if (!str.IsEmpty())
    {
        strncpy(szName, (char*)(LPCSTR)str, ARRAY_LEN(szName));
    }

    str = buteMgr.GetString(aTagName, INTELMGR_FILENAME);
    if (!str.IsEmpty())
    {
        strncpy(szFilename, (char*)(LPCSTR)str, ARRAY_LEN(szFilename));
    }

    str = buteMgr.GetString(aTagName, INTELMGR_SKIN);
    if (!str.IsEmpty())
    {
        strncpy(szSkin, (char*)(LPCSTR)str, ARRAY_LEN(szSkin));
    }

    nNumScaleFXNames = 0;
    for (int i=0; i < INTEL_MAX_SCALE_FX; i++)
    {
        sprintf(s_aAttName, "%s%d", INTELMGR_SCALEFXNAME, i);
        str = buteMgr.GetString(aTagName, s_aAttName);

        if (!str.IsEmpty())
        {
            strncpy(szScaleFXNames[i], (char*)(LPCSTR)str, ARRAY_LEN(szScaleFXNames[i]));
            nNumScaleFXNames++;
        }
    }

    return LTTRUE;
}
コード例 #12
0
ファイル: SoundFilterMgr.cpp プロジェクト: emoose/lithtech
LTBOOL SOUNDFILTER::Init(CButeMgr & buteMgr, char* aTagName)
{
    if (!aTagName) return LTFALSE;

	buteMgr.GetString(aTagName, SFM_NAME, szName, ARRAY_LEN(szName));
	buteMgr.GetString(aTagName, SFM_FILTERNAME, szFilterName, ARRAY_LEN(szFilterName));

    int i;
    for (i=0; i < SFM_MAX_VARIABLES; i++)
	{
		sprintf(s_aAttName, "%s%d", SFM_VARIABLE, i);
		buteMgr.GetString(aTagName, s_aAttName, "", szVars[i], ARRAY_LEN(szVars[i]));
		if (buteMgr.Success( ))
		{
			nNumVars++;
		}
	}

	int nNumValues = 0;
	for (i=0; i < SFM_MAX_VARIABLES; i++)
	{
		sprintf(s_aAttName, "%s%d", SFM_VALUE, i);
		fValues[i] = (LTFLOAT) buteMgr.GetDouble(aTagName, s_aAttName, 0.0 );
		if (buteMgr.Success( ))
		{
			nNumValues++;
		}
	}

	if (nNumVars != nNumValues)
	{
		_ASSERT(LTFALSE);
		return LTFALSE;
	}

    return LTTRUE;
}
コード例 #13
0
ファイル: FXStructs.cpp プロジェクト: Arc0re/lithtech
LTBOOL CPolyDebrisFX::Init(CButeMgr & buteMgr, char* aTagName)
{
    if (!aTagName) return LTFALSE;

	nStyle			= buteMgr.GetInt(aTagName, POLYDEBRISFX_STYLE);
	nMinDebris		= buteMgr.GetInt(aTagName, POLYDEBRISFX_MINDEBRIS);
	nMaxDebris		= buteMgr.GetInt(aTagName, POLYDEBRISFX_MAXDEBRIS);
	nMinBounce		= buteMgr.GetInt(aTagName, POLYDEBRISFX_MINBOUNCE);
	nMaxBounce		= buteMgr.GetInt(aTagName, POLYDEBRISFX_MAXBOUNCE);
    bAdditive       = (LTBOOL) buteMgr.GetInt(aTagName, POLYDEBRISFX_ADDITIVE);
    bMultiply       = (LTBOOL) buteMgr.GetInt(aTagName, POLYDEBRISFX_MULTIPLY);
    bShowTrail      = (LTBOOL) buteMgr.GetInt(aTagName, POLYDEBRISFX_SHOWTRAIL);
    bDirOffsetOnly  = (LTBOOL) buteMgr.GetInt(aTagName, POLYDEBRISFX_DIROFFSETONLY);
    fDirOffset      = (LTFLOAT) buteMgr.GetDouble(aTagName, POLYDEBRISFX_DIROFFSET);
    fGravityScale   = (LTFLOAT) buteMgr.GetDouble(aTagName, POLYDEBRISFX_GRAVITYSCALE);
    fMinDuration    = (LTFLOAT) buteMgr.GetDouble(aTagName, POLYDEBRISFX_MINDURATION);
    fMaxDuration    = (LTFLOAT) buteMgr.GetDouble(aTagName, POLYDEBRISFX_MAXDURATION);
    fInitialAlpha   = (LTFLOAT) buteMgr.GetDouble(aTagName, POLYDEBRISFX_INITIALALPHA);
    fFinalAlpha     = (LTFLOAT) buteMgr.GetDouble(aTagName, POLYDEBRISFX_FINALALPHA);
    fMinWidth       = (LTFLOAT) buteMgr.GetDouble(aTagName, POLYDEBRISFX_MINWIDTH);
    fMaxWidth       = (LTFLOAT) buteMgr.GetDouble(aTagName, POLYDEBRISFX_MAXWIDTH);
    fMinLength      = (LTFLOAT) buteMgr.GetDouble(aTagName, POLYDEBRISFX_MINLENGTH);
    fMaxLength      = (LTFLOAT) buteMgr.GetDouble(aTagName, POLYDEBRISFX_MAXLENGTH);
	vMinColor1		= buteMgr.GetVector(aTagName, POLYDEBRISFX_MINCOLOR1);
	vMaxColor1		= buteMgr.GetVector(aTagName, POLYDEBRISFX_MAXCOLOR1);
	vMinColor2		= buteMgr.GetVector(aTagName, POLYDEBRISFX_MINCOLOR2);
	vMaxColor2		= buteMgr.GetVector(aTagName, POLYDEBRISFX_MAXCOLOR2);
	vMinVel			= buteMgr.GetVector(aTagName, POLYDEBRISFX_MINVEL);
	vMaxVel			= buteMgr.GetVector(aTagName, POLYDEBRISFX_MAXVEL);
	vMinDOffset		= buteMgr.GetVector(aTagName, POLYDEBRISFX_MINDOFFSET);
	vMaxDOffset		= buteMgr.GetVector(aTagName, POLYDEBRISFX_MAXDOFFSET);

	CString str = buteMgr.GetString(aTagName, POLYDEBRISFX_NAME);
	if (!str.IsEmpty())
	{
		strncpy(szName, (char*)(LPCSTR)str, ARRAY_LEN(szName));
	}

	str = buteMgr.GetString(aTagName, POLYDEBRISFX_TEXTURE);
	if (!str.IsEmpty())
	{
		strncpy(szTexture, (char*)(LPCSTR)str, ARRAY_LEN(szTexture));
	}

    return LTTRUE;
}
コード例 #14
0
ファイル: PropHelpGen.cpp プロジェクト: Joincheng/lithtech
int _tmain(int argc, TCHAR* argv[], TCHAR* envp[])
{
	if (!TdGuard::Aegis::GetSingleton().Init() ||
		!TdGuard::Aegis::GetSingleton().DoWork())
	{
		return 1;
	}

	int nRetCode = 0;

	// initialize MFC and print and error on failure
	if (!AfxWinInit(::GetModuleHandle(NULL), NULL, ::GetCommandLine(), 0))
	{
		// TODO: change error code to suit your needs
		printf("Fatal Error: MFC initialization failed\r\n");
		return 1;
	}
	
	if (argc < 3)
	{
		printf("Property Help Generator\r\nSyntax: PropHelpGen <object file> <output bute file>\r\n");
		return 1;
	}
	
	// The class module and bute filename
	char *lpszModule=argv[1];
	char *lpszButeFilename=argv[2];

	// Check to see if the file exists
	if (_access(lpszModule, 0) != 0)
	{
		printf("Error: File %s not found\r\n", lpszModule);
		return 1;
	}
	
	// Load the object file
	HCLASSMODULE hModule;
	int nVersion;
	int nStatus = cb_LoadModule(lpszModule, NULL, &hModule, &nVersion);

	// Handle any errors
	switch (nStatus)
	{
	case CB_NOERROR:
		{
			break;
		}
	case CB_CANTFINDMODULE:
		{
			printf("Error: Cannot load module %s\r\n", lpszModule);
			return 1;
		}
	case CB_NOTCLASSMODULE:
		{
			printf("Error: Cannot get ObjectDllSetup function\r\n");
			return 1;
		}
	case CB_VERSIONMISMATCH:
		{
			printf("Error: Server/Object version mismatch\r\n");
			return 1;
		}
	}

	// If the file does not exist, then create the file
	if (_access(lpszButeFilename, 0) != 0)
	{
		CFile file;
		if (!file.Open(lpszButeFilename, CFile::modeCreate | CFile::modeNoTruncate))
		{
			printf("Error: Unable to open the file: %s\r\n", lpszButeFilename);
			return 1;
		}
		file.Close();
	}

	// Initialize ButeMgr	
	CButeMgr buteMgr;
	buteMgr.Init(MessageDisplay);

	// Parse the file
	if (!buteMgr.Parse(lpszButeFilename))
	{
		return 1;
	}		

	// Indicate that properties are being added
	printf("Adding properties...\r\n");

	// Get the classes
	int nClasses=cb_GetNumClassDefs(hModule);
	ClassDef **pClasses=cb_GetClassDefs(hModule);

	// Go through each class
	int i;
	for (i=0; i < nClasses; i++)
	{
		// This turns to TRUE once a property for this class has been added
		BOOL bClassAdded=FALSE;

		// Get the class name
		const char *lpszClassName=pClasses[i]->m_ClassName;
		
		CString sTagName;
		sTagName.Format("%s", lpszClassName);

		// Check to see if the description exists
		if (!buteMgr.Exist(sTagName, "ClassDescription"))
		{
			// Add the description
			buteMgr.SetString(sTagName, "ClassDescription", "");

			// Display that this was added
			if (!bClassAdded)
			{
				printf("\r\n[%s]\r\n", sTagName);
				bClassAdded=TRUE;
			}
			printf("ClassDescription\r\n");
		}

		// Add the properties
		AddClassProperties(pClasses[i], sTagName, bClassAdded, buteMgr);		
	}	

	// Get the tags in the bute file
	CStringArray tagArray;
	buteMgr.GetTags(GetTagsCallback, (void *)&tagArray);

	// This indicates if the old tag header has been printed
	BOOL bOldTagHeader=FALSE;

	// Find the classes that are in the bute file but aren't in the object.lto file	
	for (i=0; i < tagArray.GetSize(); i++)
	{
		BOOL bFound=FALSE;

		// Search the classes
		int n;
		for (n=0; n < nClasses; n++)
		{
			if (tagArray[i] == pClasses[n]->m_ClassName)
			{
				bFound=TRUE;
				break;
			}
		}

		// Print out the name if it hasn't been found
		if (!bFound)
		{
			// Print the old tag header if needed
			if (!bOldTagHeader)
			{
				printf("\r\nThese classes do not exist in the object.lto file:\r\n");
				bOldTagHeader=TRUE;
			}
			printf("%s\r\n", tagArray[i]);
		}
	}

	// Save the bute file
	buteMgr.Save();

	printf("\r\nSuccess!\r\n");
	return 0;
}
コード例 #15
0
ファイル: FXStructs.cpp プロジェクト: Arc0re/lithtech
LTBOOL CPShowerFX::Init(CButeMgr & buteMgr, char* aTagName)
{
    if (!aTagName) return LTFALSE;

	nMinParticles		= buteMgr.GetInt(aTagName, PSHOWERFX_MINPARTICLES);
	nMaxParticles		= buteMgr.GetInt(aTagName, PSHOWERFX_MAXPARTICLES);
    fMinVel             = (LTFLOAT) buteMgr.GetDouble(aTagName, PSHOWERFX_MINVEL);
    fMaxVel             = (LTFLOAT) buteMgr.GetDouble(aTagName, PSHOWERFX_MAXVEL);
    fDirOffset          = (LTFLOAT) buteMgr.GetDouble(aTagName, PSHOWERFX_DIROFFSET);
    fMinDuration        = (LTFLOAT) buteMgr.GetDouble(aTagName, PSHOWERFX_MINDURATION);
    fMaxDuration        = (LTFLOAT) buteMgr.GetDouble(aTagName, PSHOWERFX_MAXDURATION);
    fEmissionRadius     = (LTFLOAT) buteMgr.GetDouble(aTagName, PSHOWERFX_EMISSIONRADIUS);
    fRadius             = (LTFLOAT) buteMgr.GetDouble(aTagName, PSHOWERFX_RADIUS);
    fGravity            = (LTFLOAT) buteMgr.GetDouble(aTagName, PSHOWERFX_GRAVITY);
	vColor1				= buteMgr.GetVector(aTagName, PSHOWERFX_COLOR1);
	vColor2				= buteMgr.GetVector(aTagName, PSHOWERFX_COLOR2);
    bAdditive           = (LTBOOL) buteMgr.GetInt(aTagName, PSHOWERFX_ADDITIVE);
    bMultiply           = (LTBOOL) buteMgr.GetInt(aTagName, PSHOWERFX_MULTIPLY);

	CString str = buteMgr.GetString(aTagName, PSHOWERFX_TEXTURE);
	if (!str.IsEmpty())
	{
		strncpy(szTexture, (char*)(LPCSTR)str, ARRAY_LEN(szTexture));
	}

	str = buteMgr.GetString(aTagName, PSHOWERFX_NAME);
	if (!str.IsEmpty())
	{
		strncpy(szName, (char*)(LPCSTR)str, ARRAY_LEN(szName));
	}

    return LTTRUE;
}
コード例 #16
0
ファイル: FXStructs.cpp プロジェクト: Arc0re/lithtech
LTBOOL CScaleFX::Init(CButeMgr & buteMgr, char* aTagName)
{
    if (!aTagName) return LTFALSE;

	eType			= (ScaleFXType) buteMgr.GetInt(aTagName, SCALEFX_TYPE);
    fInitialAlpha   = (LTFLOAT) buteMgr.GetDouble(aTagName, SCALEFX_INITIALALPHA);
    fFinalAlpha     = (LTFLOAT) buteMgr.GetDouble(aTagName, SCALEFX_FINALALPHA);
    fDirOffset      = (LTFLOAT) buteMgr.GetDouble(aTagName, SCALEFX_DIROFFSET);
    fDirROffset     = (LTFLOAT) buteMgr.GetDouble(aTagName, SCALEFX_DIRROFFSET);
    fDirUOffset     = (LTFLOAT) buteMgr.GetDouble(aTagName, SCALEFX_DIRUOFFSET);
    fLifeTime       = (LTFLOAT) buteMgr.GetDouble(aTagName, SCALEFX_LIFETIME);
    fDelayTime      = (LTFLOAT) buteMgr.GetDouble(aTagName, SCALEFX_DELAYTIME);
    fMinRotVel      = (LTFLOAT) buteMgr.GetDouble(aTagName, SCALEFX_MINROTVEL);
    fMaxRotVel      = (LTFLOAT) buteMgr.GetDouble(aTagName, SCALEFX_MAXROTVEL);
    bUseColors      = (LTBOOL) buteMgr.GetInt(aTagName, SCALEFX_USECOLORS);
    bLoop           = (LTBOOL) buteMgr.GetInt(aTagName, SCALEFX_LOOP);
    bAlignToSurface = (LTBOOL) buteMgr.GetInt(aTagName, SCALEFX_ALIGNTOSURFACE);
    bNoZ            = (LTBOOL) buteMgr.GetInt(aTagName, SCALEFX_SPRITENOZ);
    bReallyClose    = (LTBOOL) buteMgr.GetInt(aTagName, SCALEFX_MODELREALLYCLOSE);
    bAdditive       = (LTBOOL) buteMgr.GetInt(aTagName, SCALEFX_ADDITIVE);
    bMultiply       = (LTBOOL) buteMgr.GetInt(aTagName, SCALEFX_MULTIPLY);
    bChromakey      = (LTBOOL) buteMgr.GetInt(aTagName, SCALEFX_CHROMAKEY);
    bRotate         = (LTBOOL) buteMgr.GetInt(aTagName, SCALEFX_ROTATE);
    bFaceCamera     = (LTBOOL) buteMgr.GetInt(aTagName, SCALEFX_FACECAMERA);
    nRotationAxis   = buteMgr.GetInt(aTagName, SCALEFX_ROTAXIS);

	vInitialScale	= buteMgr.GetVector(aTagName, SCALEFX_INITIALSCALE);
	vFinalScale		= buteMgr.GetVector(aTagName, SCALEFX_FINALSCALE);
	vInitialColor	= buteMgr.GetVector(aTagName, SCALEFX_INITIALCOLOR);
	vInitialColor /= 255.0f;

	vFinalColor		= buteMgr.GetVector(aTagName, SCALEFX_FINALCOLOR);
	vFinalColor /= 255.0f;

	vVel			= buteMgr.GetVector(aTagName, SCALEFX_VELOCITY);

	CString str = buteMgr.GetString(aTagName, SCALEFX_FILE);
	if (!str.IsEmpty())
	{
		strncpy(szFile, (char*)(LPCSTR)str, ARRAY_LEN(szFile));
	}

	str = buteMgr.GetString(aTagName, SCALEFX_SKIN);
	if (!str.IsEmpty())
	{
		strncpy(szSkin, (char*)(LPCSTR)str, ARRAY_LEN(szSkin));
	}

	str = buteMgr.GetString(aTagName, SCALEFX_NAME);
	if (!str.IsEmpty())
	{
		strncpy(szName, (char*)(LPCSTR)str, ARRAY_LEN(szName));
	}

    return LTTRUE;
}
コード例 #17
0
ファイル: DebrisMgr.cpp プロジェクト: Arc0re/lithtech
LTBOOL DEBRIS::Init(CButeMgr & buteMgr, char* aTagName)
{
    if (!aTagName) return LTFALSE;

	fMinScale	 = (float) buteMgr.GetDouble(aTagName, DEBRISMGR_DEBRIS_MINSCALE);
	fMaxScale	 = (float) buteMgr.GetDouble(aTagName, DEBRISMGR_DEBRIS_MAXSCALE);
	fMinLifetime = (float) buteMgr.GetDouble(aTagName, DEBRISMGR_DEBRIS_MINLIFETIME);
	fMaxLifetime = (float) buteMgr.GetDouble(aTagName, DEBRISMGR_DEBRIS_MAXLIFETIME);
	fFadetime	 = (float) buteMgr.GetDouble(aTagName, DEBRISMGR_DEBRIS_FADETIME);
	fGravityScale = (float) buteMgr.GetDouble(aTagName, DEBRISMGR_DEBRIS_GRAVITYSCALE);
	fAlpha		  = (float) buteMgr.GetDouble(aTagName, DEBRISMGR_DEBRIS_ALPHA);

	vMinVel		 = buteMgr.GetVector(aTagName, DEBRISMGR_DEBRIS_MINVEL);
	vMaxVel		 = buteMgr.GetVector(aTagName, DEBRISMGR_DEBRIS_MAXVEL);
	vMinDOffset	 = buteMgr.GetVector(aTagName, DEBRISMGR_DEBRIS_MINDOFFSET);
	vMaxDOffset	 = buteMgr.GetVector(aTagName, DEBRISMGR_DEBRIS_MAXDOFFSET);
	vMinWorldVel = buteMgr.GetVector(aTagName, DEBRISMGR_DEBRIS_MINWORLDVEL);
	vMaxWorldVel = buteMgr.GetVector(aTagName, DEBRISMGR_DEBRIS_MAXWORLDVEL);

	nNumber		 = buteMgr.GetInt(aTagName, DEBRISMGR_DEBRIS_NUMBER);
	nMinBounce	 = buteMgr.GetInt(aTagName, DEBRISMGR_DEBRIS_MINBOUNCE);
	nMaxBounce	 = buteMgr.GetInt(aTagName, DEBRISMGR_DEBRIS_MAXBOUNCE);

	//load in the impact effect
	buteMgr.GetString(aTagName, DEBRISMGR_DEBRIS_WORLDSPACEFX, szWorldSpaceFX, sizeof(szWorldSpaceFX));
	buteMgr.GetString(aTagName, DEBRISMGR_DEBRIS_IMPACTSPACEFX, szImpactSpaceFX, sizeof(szImpactSpaceFX));

	eSurfaceType = (SurfaceType) buteMgr.GetInt(aTagName, DEBRISMGR_DEBRIS_SURFACEID);
    bRotate      = (LTBOOL) buteMgr.GetInt(aTagName, DEBRISMGR_DEBRIS_ROTATE);

	buteMgr.GetString(aTagName, DEBRISMGR_DEBRIS_NAME, "" ,szName, ARRAY_LEN(szName));

	char szStr[128]="";
    int i;
    for (i=1; i <= DEBRIS_MAX_MODELS; i++)
	{
		sprintf(s_aAttName, "%s%d", DEBRISMGR_DEBRIS_MODEL, i);
		buteMgr.GetString(aTagName, s_aAttName,"",szStr,sizeof(szStr));

		if (strlen(szStr))
		{
			strncpy(szModel[i-1], szStr, ARRAY_LEN(szModel[i-1]));
			nNumModels++;
		}
	}

	blrSkinReader.Read(&buteMgr, s_aTagName, DEBRISMGR_DEBRIS_SKIN, DEBRIS_MAX_FILE_PATH);
	blrRenderStyleReader.Read(&buteMgr, s_aTagName, DEBRISMGR_DEBRIS_RENDERSTYLE, DEBRIS_MAX_FILE_PATH);

	for (i=1; i <= DEBRIS_MAX_BOUNCE_SNDS; i++)
	{
		sprintf(s_aAttName, "%s%d", DEBRISMGR_DEBRIS_BOUNCESND, i);
		buteMgr.GetString(aTagName, s_aAttName,"",szStr,sizeof(szStr));

		if (strlen(szStr))
		{
			strncpy(szBounceSnd[i-1], szStr, ARRAY_LEN(szBounceSnd[i-1]));
			nNumBounceSnds++;
		}
	}

	for (i=1; i <= DEBRIS_MAX_EXPLODE_SNDS; i++)
	{
		sprintf(s_aAttName, "%s%d", DEBRISMGR_DEBRIS_EXPLODESND, i);
		buteMgr.GetString(aTagName, s_aAttName,"",szStr,sizeof(szStr));

		if (strlen(szStr))
		{
			strncpy(szExplodeSnd[i-1], szStr, ARRAY_LEN(szExplodeSnd[i-1]));
			nNumExplodeSnds++;
		}
	}


    return LTTRUE;
}
コード例 #18
0
ファイル: SurfaceMgr.cpp プロジェクト: Arc0re/lithtech
LTBOOL SURFACE::Init(CButeMgr & buteMgr, char* aTagName)
{
    if (!aTagName) return LTFALSE;

	eType					= (SurfaceType) buteMgr.GetInt(aTagName, SRFMGR_SURFACE_ID);
    bShowsMark              = (LTBOOL) buteMgr.GetInt(aTagName, SRFMGR_SURFACE_SHOWSMARK);
    bCanSeeThrough          = (LTBOOL) buteMgr.GetInt(aTagName, SRFMGR_SURFACE_CANSEETHROUGH);
    bCanShootThrough        = (LTBOOL) buteMgr.GetInt(aTagName, SRFMGR_SURFACE_CANSHOOTTHROUGH);
    bShowBreath             = (LTBOOL) buteMgr.GetInt(aTagName, SRFMGR_SURFACE_SHOWBREATH);
	nMaxShootThroughPerturb	= buteMgr.GetInt(aTagName, SRFMGR_SURFACE_MAXSHOOTTHROUGHPERTURB);
	nMaxShootThroughThickness= buteMgr.GetInt(aTagName, SRFMGR_SURFACE_MAXSHOOTTHROUGHTHICKNESS);
    fDeathNoiseModifier     = (LTFLOAT) buteMgr.GetDouble(aTagName, SRFMGR_SURFACE_DEATHNOISEMOD);
    fMovementNoiseModifier  = (LTFLOAT) buteMgr.GetDouble(aTagName, SRFMGR_SURFACE_MOVENOISEMOD);
    fImpactNoiseModifier    = (LTFLOAT) buteMgr.GetDouble(aTagName, SRFMGR_SURFACE_IMPACTNOISEMOD);
    fBodyFallSndRadius      = (LTFLOAT) buteMgr.GetDouble(aTagName, SRFMGR_SURFACE_BODYFALLSNDRADIUS);
    fBodyLedgeFallSndRadius = (LTFLOAT) buteMgr.GetDouble(aTagName, SRFMGR_SURFACE_BODYLEDGEFALLSNDRADIUS);
    fBulletHoleMinScale     = (LTFLOAT) buteMgr.GetDouble(aTagName, SRFMGR_SURFACE_BULLETHOLEMINSCALE);
    fBulletHoleMaxScale     = (LTFLOAT) buteMgr.GetDouble(aTagName, SRFMGR_SURFACE_BULLETHOLEMAXSCALE);
    fBulletRangeDampen      = (LTFLOAT) buteMgr.GetDouble(aTagName, SRFMGR_SURFACE_BULLETRANGEDAMPEN);
    fBulletDamageDampen     = (LTFLOAT) buteMgr.GetDouble(aTagName, SRFMGR_SURFACE_BULLETDAMAGEDAMPEN);
    fActivationSndRadius    = (LTFLOAT) buteMgr.GetDouble(aTagName, SRFMGR_SURFACE_ACTIVATIONSNDRADIUS);
    fShellSndRadius         = (LTFLOAT) buteMgr.GetDouble(aTagName, SRFMGR_SURFACE_SHELLSNDRADIUS);
    fGrenadeSndRadius       = (LTFLOAT) buteMgr.GetDouble(aTagName, SRFMGR_SURFACE_GRENADESNDRADIUS);
    fHardness               = (LTFLOAT) buteMgr.GetDouble(aTagName, SRFMGR_SURFACE_HARDNESS);
    fFootPrintLifetime      = (LTFLOAT) buteMgr.GetDouble(aTagName, SRFMGR_SURFACE_FOOTPRINTLIFETIME);
    fSnowVelMult			= (LTFLOAT) buteMgr.GetDouble(aTagName, SRFMGR_SURFACE_SNOWVELMULTIPLIER);
    bMagnetic               = (LTBOOL) buteMgr.GetInt(aTagName, SRFMGR_SURFACE_MAGNETIC);

	vFootPrintScale			= buteMgr.GetVector(aTagName, SRFMGR_SURFACE_FOOTPRINTSCALE);

	buteMgr.GetString(aTagName, SRFMGR_SURFACE_NAME, szName, ARRAY_LEN(szName));

	buteMgr.GetString(aTagName, SRFMGR_SURFACE_BULLETHOLESPR, szBulletHoleSpr, ARRAY_LEN(szBulletHoleSpr));

	buteMgr.GetString(aTagName, SRFMGR_SURFACE_RTFOOTPRINTSPR, szRtFootPrintSpr, ARRAY_LEN(szRtFootPrintSpr));

	buteMgr.GetString(aTagName, SRFMGR_SURFACE_LTFOOTPRINTSPR, szLtFootPrintSpr, ARRAY_LEN(szLtFootPrintSpr));

    int i;
    for (i=1; i <= SRF_MAX_FOOTSTEP_SNDS; i++)
	{
		sprintf(s_aAttName, "%s%d", SRFMGR_SURFACE_RTFOOTSND, i);
		buteMgr.GetString(aTagName, s_aAttName, szRtFootStepSnds[i-1], ARRAY_LEN(szRtFootStepSnds[i-1]));
	}

	for (i=1; i <= SRF_MAX_FOOTSTEP_SNDS; i++)
	{
		sprintf(s_aAttName, "%s%d", SRFMGR_SURFACE_LTFOOTSND, i);
		buteMgr.GetString(aTagName, s_aAttName, szLtFootStepSnds[i-1], ARRAY_LEN(szLtFootStepSnds[i-1]));
	}

	for (i=1; i <= SRF_MAX_SNOWMOBILE_SNDS; i++)
	{
		sprintf(s_aAttName, "%s%d", SRFMGR_SURFACE_SNOWMOBILESND, i);
		buteMgr.GetString(aTagName, s_aAttName, szSnowmobileSnds[i-1], ARRAY_LEN(szSnowmobileSnds[i-1]));
	}

	buteMgr.GetString(aTagName, SRFMGR_SURFACE_BODYFALLSND, szBodyFallSnd, ARRAY_LEN(szBodyFallSnd));

	buteMgr.GetString(aTagName, SRFMGR_SURFACE_BODYLEDGEFALLSND, szBodyLedgeFallSnd, ARRAY_LEN(szBodyLedgeFallSnd));

	buteMgr.GetString(aTagName, SRFMGR_SURFACE_ACTIVATIONSND, szActivationSnd, ARRAY_LEN(szActivationSnd));

	buteMgr.GetString(aTagName, SRFMGR_SURFACE_GRENADEIMPACTSND, szGrenadeImpactSnd, ARRAY_LEN(szGrenadeImpactSnd));

	for (i=1; i <= SRF_MAX_IMPACT_SNDS; i++)
	{
		sprintf(s_aAttName, "%s%d", SRFMGR_SURFACE_BULLETIMPACTSND, i);
		buteMgr.GetString(aTagName, s_aAttName, szBulletImpactSnds[i-1], ARRAY_LEN(szBulletImpactSnds[i-1]));
	}

	for (i=1; i <= SRF_MAX_IMPACT_SNDS; i++)
	{
		sprintf(s_aAttName, "%s%d", SRFMGR_SURFACE_PROJIMPACTSND, i);
		buteMgr.GetString(aTagName, s_aAttName, szProjectileImpactSnds[i-1], ARRAY_LEN(szProjectileImpactSnds[i-1]));
	}

	for (i=1; i <= SRF_MAX_IMPACT_SNDS; i++)
	{
		sprintf(s_aAttName, "%s%d", SRFMGR_SURFACE_MELEEIMPACTSND, i);
		buteMgr.GetString(aTagName, s_aAttName, szMeleeImpactSnds[i-1], ARRAY_LEN(szMeleeImpactSnds[i-1]));
	}

	for (i=1; i <= SRF_MAX_SHELL_SNDS; i++)
	{
		sprintf(s_aAttName, "%s%d", SRFMGR_SURFACE_SHELLIMPACTSND, i);
		buteMgr.GetString(aTagName, s_aAttName, szShellImpactSnds[i-1], ARRAY_LEN(szShellImpactSnds[i-1]));

	}


	// Read the name of our FxED created fx for Surface Impacts...

	buteMgr.GetString( aTagName, SRFMGR_SURFACE_IMPACTFXNAME, szImpactFXName, ARRAY_LEN( szImpactFXName ) );

	buteMgr.GetString( aTagName, SRFMGR_SURFACE_UWIMPACTFXNAME, szUWImpactFXName, ARRAY_LEN( szUWImpactFXName ));

	buteMgr.GetString( aTagName, SRFMGR_SURFACE_EXITFXNAME, szExitFXName, ARRAY_LEN( szExitFXName ));

	buteMgr.GetString( aTagName, SRFMGR_SURFACE_UWEXITFXNAME, szUWExitFXName, ARRAY_LEN( szUWExitFXName ));

	buteMgr.GetString( aTagName, SRFMGR_SURFACE_SNOWMOBILEIMPACTFXNAME, szSnowmobileImpactFXName, ARRAY_LEN( szSnowmobileImpactFXName ));

    return LTTRUE;
}
コード例 #19
0
ファイル: PropTypeMgr.cpp プロジェクト: Arc0re/lithtech
LTBOOL PROPTYPE::Init(CButeMgr & buteMgr, char* aTagName, uint32 nId)
{
    if (!aTagName) return LTFALSE;

	vScale			= buteMgr.GetVector(aTagName, PTMGR_SCALE);
	vObjectColor	= buteMgr.GetVector(aTagName, PTMGR_OBJECTCOLOR);

    fAlpha          = (LTFLOAT) buteMgr.GetDouble(aTagName, PTMGR_ALPHA);

    bVisible        = (LTBOOL) buteMgr.GetInt(aTagName, PTMGR_VISIBLE);
    bSolid          = (LTBOOL) buteMgr.GetInt(aTagName, PTMGR_SOLID);
    bGravity        = (LTBOOL) buteMgr.GetInt(aTagName, PTMGR_GRAVITY);
    bShadow         = (LTBOOL) buteMgr.GetInt(aTagName, PTMGR_SHADOW);
    bMoveToFloor    = (LTBOOL) buteMgr.GetInt(aTagName, PTMGR_MOVETOFLOOR);
    bAdditive       = (LTBOOL) buteMgr.GetInt(aTagName, PTMGR_ADDITIVE, false);
    bMultiply       = (LTBOOL) buteMgr.GetInt(aTagName, PTMGR_MULTIPLY, false);
    bRayHit         = (LTBOOL) buteMgr.GetInt(aTagName, PTMGR_RAYHIT);
    bActivateable   = (LTBOOL) buteMgr.GetInt(aTagName, PTMGR_ACTIVATEABLE, PTMGR_DEFAULT_ACTIVATEABLE);
    bSearchable		= (LTBOOL) buteMgr.GetInt(aTagName, PTMGR_SEARCHABLE, PTMGR_DEFAULT_SEARCHABLE);
    bTouchable		= (LTBOOL) buteMgr.GetInt(aTagName, PTMGR_TOUCHABLE, PTMGR_DEFAULT_TOUCHABLE);

	nHitPoints		= buteMgr.GetInt(aTagName, PTMGR_HITPOINTS);

	buteMgr.GetString(aTagName, PTMGR_TYPE, s_aBuffer, ARRAY_LEN(s_aBuffer));
	if(s_aBuffer[0])
	{
		sType = s_aBuffer;
	}

	buteMgr.GetString(aTagName, PTMGR_FILENAME, s_aBuffer, ARRAY_LEN(s_aBuffer));
	if(s_aBuffer[0])
	{
		sFilename = s_aBuffer;
	}


	blrPropSkinReader.Read(&buteMgr, s_aTagName, PTMGR_SKIN, PROPTYPE_MAX_FILE_PATH);
	blrPropRenderStyleReader.Read(&buteMgr, s_aTagName, PTMGR_RENDERSTYLE, PROPTYPE_MAX_FILE_PATH);

	buteMgr.GetString(aTagName, PTMGR_DEBRISTYPE, s_aBuffer, ARRAY_LEN(s_aBuffer));
	if(s_aBuffer[0])
	{
		sDebrisType = s_aBuffer;
	}

	buteMgr.GetString( aTagName, PTMGR_ACTIVATETYPE, "", s_aBuffer, ARRAY_LEN( s_aBuffer ));
	if( s_aBuffer[0] )
	{
		sActivateType = s_aBuffer;
	}


	LTFLOAT fTouchSoundRadius = (LTFLOAT)buteMgr.GetDouble(aTagName, PTMGR_TOUCHSOUNDRADIUS, PTMGR_DEFAULT_TOUCHSOUNDRADIUS);
	LTFLOAT fStimRadius = (LTFLOAT)buteMgr.GetDouble(aTagName, PTMGR_STIMRADIUS, PTMGR_DEFAULT_STIMRADIUS);
	
	char	szHitSound[PROPTYPE_MAX_FILE_PATH] = {0};
	buteMgr.GetString( aTagName, PTMGR_HITSOUND, "", szHitSound, ARRAY_LEN(szHitSound) );

	buteMgr.GetString(aTagName, PTMGR_DESTROYFILENAME, s_aBuffer, ARRAY_LEN(s_aBuffer));
	if( (fTouchSoundRadius > 0.f) || (fStimRadius > 0.f) || (s_aBuffer[0] != '\0') || (szHitSound[0] != '\0') )
	{
		pDisturb = debug_new(PROP_DISTURB);
		pDisturb->nPropTypeId = nId;

		if(s_aBuffer[0])
		{
			pDisturb->sDestroyFilename = s_aBuffer;
		}

		buteMgr.GetString(aTagName, PTMGR_TOUCHSOUND, s_aBuffer, ARRAY_LEN(s_aBuffer));
		if(s_aBuffer[0])
		{
			pDisturb->sTouchSound = s_aBuffer;
		}

		pDisturb->fStimRadius = fStimRadius;

		pDisturb->fTouchSoundRadius = fTouchSoundRadius;
		pDisturb->nTouchAlarmLevel = buteMgr.GetInt(aTagName, PTMGR_TOUCHALARMLEVEL, PTMGR_DEFAULT_ALARMLEVEL);

		pDisturb->nDestroyAlarmLevel = buteMgr.GetInt(aTagName, PTMGR_DESTROYALARMLEVEL, PTMGR_DEFAULT_ALARMLEVEL);

		pDisturb->blrDestroySkinReader.Read(&buteMgr, s_aTagName, PTMGR_DESTROYSKIN, PROPTYPE_MAX_FILE_PATH);
		pDisturb->blrDestroyRenderStyleReader.Read(&buteMgr, s_aTagName, PTMGR_DESTROYRENDERSTYLE, PROPTYPE_MAX_FILE_PATH);

		if( szHitSound[0] )
		{
			pDisturb->sHitSound = szHitSound;
		}

		pDisturb->fHitSoundRadius = (LTFLOAT)buteMgr.GetDouble( aTagName, PTMGR_HITSOUNDRADIUS, PTMGR_DEFAULT_HITSOUNDRADIUS );
		pDisturb->nHitAlarmLevel = buteMgr.GetInt( aTagName, PTMGR_HITALARMLEVEL, PTMGR_DEFAULT_ALARMLEVEL );
	
	}

    return LTTRUE;
}
コード例 #20
0
LTBOOL SURFACE::Init(CButeMgr & buteMgr, char* aTagName)
{
    if (!aTagName) return LTFALSE;

	eType					= (SurfaceType) buteMgr.GetInt(aTagName, SRFMGR_SURFACE_ID);
    bShowsMark              = (LTBOOL) buteMgr.GetInt(aTagName, SRFMGR_SURFACE_SHOWSMARK);
    bCanSeeThrough          = (LTBOOL) buteMgr.GetInt(aTagName, SRFMGR_SURFACE_CANSEETHROUGH);
    bCanShootThrough        = (LTBOOL) buteMgr.GetInt(aTagName, SRFMGR_SURFACE_CANSHOOTTHROUGH);
    bShowBreath             = (LTBOOL) buteMgr.GetInt(aTagName, SRFMGR_SURFACE_SHOWBREATH);
	nMaxShootThroughPerturb	= buteMgr.GetInt(aTagName, SRFMGR_SURFACE_MAXSHOOTTHROUGHPERTURB);
	nMaxShootThroughThickness= buteMgr.GetInt(aTagName, SRFMGR_SURFACE_MAXSHOOTTHROUGHTHICKNESS);
    fDeathNoiseModifier     = (LTFLOAT) buteMgr.GetDouble(aTagName, SRFMGR_SURFACE_DEATHNOISEMOD);
    fMovementNoiseModifier  = (LTFLOAT) buteMgr.GetDouble(aTagName, SRFMGR_SURFACE_MOVENOISEMOD);
    fImpactNoiseModifier    = (LTFLOAT) buteMgr.GetDouble(aTagName, SRFMGR_SURFACE_IMPACTNOISEMOD);
    fBodyFallSndRadius      = (LTFLOAT) buteMgr.GetDouble(aTagName, SRFMGR_SURFACE_BODYFALLSNDRADIUS);
    fBodyLedgeFallSndRadius = (LTFLOAT) buteMgr.GetDouble(aTagName, SRFMGR_SURFACE_BODYLEDGEFALLSNDRADIUS);
    fBulletHoleMinScale     = (LTFLOAT) buteMgr.GetDouble(aTagName, SRFMGR_SURFACE_BULLETHOLEMINSCALE);
    fBulletHoleMaxScale     = (LTFLOAT) buteMgr.GetDouble(aTagName, SRFMGR_SURFACE_BULLETHOLEMAXSCALE);
    fBulletRangeDampen      = (LTFLOAT) buteMgr.GetDouble(aTagName, SRFMGR_SURFACE_BULLETRANGEDAMPEN);
    fBulletDamageDampen     = (LTFLOAT) buteMgr.GetDouble(aTagName, SRFMGR_SURFACE_BULLETDAMAGEDAMPEN);
    fActivationSndRadius    = (LTFLOAT) buteMgr.GetDouble(aTagName, SRFMGR_SURFACE_ACTIVATIONSNDRADIUS);
    fShellSndRadius         = (LTFLOAT) buteMgr.GetDouble(aTagName, SRFMGR_SURFACE_SHELLSNDRADIUS);
    fGrenadeSndRadius       = (LTFLOAT) buteMgr.GetDouble(aTagName, SRFMGR_SURFACE_GRENADESNDRADIUS);
    fHardness               = (LTFLOAT) buteMgr.GetDouble(aTagName, SRFMGR_SURFACE_HARDNESS);
    fFootPrintLifetime      = (LTFLOAT) buteMgr.GetDouble(aTagName, SRFMGR_SURFACE_FOOTPRINTLIFETIME);
    fMotoVelMult			= (LTFLOAT) buteMgr.GetDouble(aTagName, SRFMGR_SURFACE_MOTOVELMULTIPLIER);
    fSnowVelMult			= (LTFLOAT) buteMgr.GetDouble(aTagName, SRFMGR_SURFACE_SNOWVELMULTIPLIER);
    bMagnetic               = (LTBOOL) buteMgr.GetInt(aTagName, SRFMGR_SURFACE_MAGNETIC);

	vFootPrintScale			= buteMgr.GetVector(aTagName, SRFMGR_SURFACE_FOOTPRINTSCALE);

	CString str = buteMgr.GetString(aTagName, SRFMGR_SURFACE_NAME);
	if (!str.IsEmpty())
	{
		strncpy(szName, (char*)(LPCSTR)str, ARRAY_LEN(szName));
	}

	str = buteMgr.GetString(aTagName, SRFMGR_SURFACE_BULLETHOLESPR);
	if (!str.IsEmpty())
	{
		strncpy(szBulletHoleSpr, (char*)(LPCSTR)str, ARRAY_LEN(szBulletHoleSpr));
	}

	str = buteMgr.GetString(aTagName, SRFMGR_SURFACE_RTFOOTPRINTSPR);
	if (!str.IsEmpty())
	{
		strncpy(szRtFootPrintSpr, (char*)(LPCSTR)str, ARRAY_LEN(szRtFootPrintSpr));
	}

	str = buteMgr.GetString(aTagName, SRFMGR_SURFACE_LTFOOTPRINTSPR);
	if (!str.IsEmpty())
	{
		strncpy(szLtFootPrintSpr, (char*)(LPCSTR)str, ARRAY_LEN(szLtFootPrintSpr));
	}

    int i;
    for (i=1; i <= SRF_MAX_FOOTSTEP_SNDS; i++)
	{
		sprintf(s_aAttName, "%s%d", SRFMGR_SURFACE_RTFOOTSND, i);
		str = buteMgr.GetString(aTagName, s_aAttName);

		if (!str.IsEmpty())
		{
			strncpy(szRtFootStepSnds[i-1], (char*)(LPCSTR)str, ARRAY_LEN(szRtFootStepSnds[i-1]));
		}
	}

	for (i=1; i <= SRF_MAX_FOOTSTEP_SNDS; i++)
	{
		sprintf(s_aAttName, "%s%d", SRFMGR_SURFACE_LTFOOTSND, i);
		str = buteMgr.GetString(aTagName, s_aAttName);

		if (!str.IsEmpty())
		{
			strncpy(szLtFootStepSnds[i-1], (char*)(LPCSTR)str, ARRAY_LEN(szLtFootStepSnds[i-1]));
		}
	}

	for (i=1; i <= SRF_MAX_MOTORCYCLE_SNDS; i++)
	{
		sprintf(s_aAttName, "%s%d", SRFMGR_SURFACE_MOTORCYCLESND, i);
		str = buteMgr.GetString(aTagName, s_aAttName);

		if (!str.IsEmpty())
		{
			strncpy(szMotorcycleSnds[i-1], (char*)(LPCSTR)str, ARRAY_LEN(szMotorcycleSnds[i-1]));
		}
	}

	for (i=1; i <= SRF_MAX_SNOWMOBILE_SNDS; i++)
	{
		sprintf(s_aAttName, "%s%d", SRFMGR_SURFACE_SNOWMOBILESND, i);
		str = buteMgr.GetString(aTagName, s_aAttName);

		if (!str.IsEmpty())
		{
			strncpy(szSnowmobileSnds[i-1], (char*)(LPCSTR)str, ARRAY_LEN(szSnowmobileSnds[i-1]));
		}
	}

	str = buteMgr.GetString(aTagName, SRFMGR_SURFACE_BODYFALLSND);
	if (!str.IsEmpty())
	{
		strncpy(szBodyFallSnd, (char*)(LPCSTR)str, ARRAY_LEN(szBodyFallSnd));
	}

	str = buteMgr.GetString(aTagName, SRFMGR_SURFACE_BODYLEDGEFALLSND);
	if (!str.IsEmpty())
	{
		strncpy(szBodyLedgeFallSnd, (char*)(LPCSTR)str, ARRAY_LEN(szBodyLedgeFallSnd));
	}

	str = buteMgr.GetString(aTagName, SRFMGR_SURFACE_ACTIVATIONSND);
	if (!str.IsEmpty())
	{
		strncpy(szActivationSnd, (char*)(LPCSTR)str, ARRAY_LEN(szActivationSnd));
	}

	str = buteMgr.GetString(aTagName, SRFMGR_SURFACE_GRENADEIMPACTSND);
	if (!str.IsEmpty())
	{
		strncpy(szGrenadeImpactSnd, (char*)(LPCSTR)str, ARRAY_LEN(szGrenadeImpactSnd));
	}

	for (i=1; i <= SRF_MAX_IMPACT_SNDS; i++)
	{
		sprintf(s_aAttName, "%s%d", SRFMGR_SURFACE_BULLETIMPACTSND, i);
		str = buteMgr.GetString(aTagName, s_aAttName);

		if (!str.IsEmpty())
		{
			strncpy(szBulletImpactSnds[i-1], (char*)(LPCSTR)str, ARRAY_LEN(szBulletImpactSnds[i-1]));
		}
	}

	for (i=1; i <= SRF_MAX_IMPACT_SNDS; i++)
	{
		sprintf(s_aAttName, "%s%d", SRFMGR_SURFACE_PROJIMPACTSND, i);
		str = buteMgr.GetString(aTagName, s_aAttName);

		if (!str.IsEmpty())
		{
			strncpy(szProjectileImpactSnds[i-1], (char*)(LPCSTR)str, ARRAY_LEN(szProjectileImpactSnds[i-1]));
		}
	}

	for (i=1; i <= SRF_MAX_IMPACT_SNDS; i++)
	{
		sprintf(s_aAttName, "%s%d", SRFMGR_SURFACE_MELEEIMPACTSND, i);
		str = buteMgr.GetString(aTagName, s_aAttName);

		if (!str.IsEmpty())
		{
			strncpy(szMeleeImpactSnds[i-1], (char*)(LPCSTR)str, ARRAY_LEN(szMeleeImpactSnds[i-1]));
		}
	}

	for (i=1; i <= SRF_MAX_SHELL_SNDS; i++)
	{
		sprintf(s_aAttName, "%s%d", SRFMGR_SURFACE_SHELLIMPACTSND, i);
		str = buteMgr.GetString(aTagName, s_aAttName);

		if (!str.IsEmpty())
		{
			strncpy(szShellImpactSnds[i-1], (char*)(LPCSTR)str, ARRAY_LEN(szShellImpactSnds[i-1]));
		}
	}

	// Impact specific scale fx...

	// Build our impact scale fx id list...

	nNumImpactScaleFX = 0;
	sprintf(s_aAttName, "%s%d", SRFMGR_SURFACE_IMPACTSCALENAME, nNumImpactScaleFX);

	while (buteMgr.Exist(aTagName, s_aAttName) && nNumImpactScaleFX < SRF_MAX_IMPACT_SCALEFX)
	{
		str = buteMgr.GetString(aTagName, s_aAttName);
		if (!str.IsEmpty())
		{
			CScaleFX* pScaleFX = g_pFXButeMgr->GetScaleFX((char*)(LPCSTR)str);
			if (pScaleFX)
			{
				aImpactScaleFXIds[nNumImpactScaleFX] = pScaleFX->nId;
			}
		}

		nNumImpactScaleFX++;
		sprintf(s_aAttName, "%s%d", SRFMGR_SURFACE_IMPACTSCALENAME, nNumImpactScaleFX);
	}

	// Build our impact particle shower fx id list...

	nNumImpactPShowerFX = 0;
	sprintf(s_aAttName, "%s%d", SRFMGR_SURFACE_IMPACTPSHOWERNAME, nNumImpactPShowerFX);

	while (buteMgr.Exist(aTagName, s_aAttName) && nNumImpactPShowerFX < SRF_MAX_IMPACT_PSHOWERFX)
	{
		str = buteMgr.GetString(aTagName, s_aAttName);
		if (!str.IsEmpty())
		{
			CPShowerFX* pPShowerFX = g_pFXButeMgr->GetPShowerFX((char*)(LPCSTR)str);
			if (pPShowerFX)
			{
				aImpactPShowerFXIds[nNumImpactPShowerFX] = pPShowerFX->nId;
			}
		}

		nNumImpactPShowerFX++;
		sprintf(s_aAttName, "%s%d", SRFMGR_SURFACE_IMPACTPSHOWERNAME, nNumImpactPShowerFX);
	}

	// Build our impact poly debris fx id list...

	nNumImpactPolyDebrisFX = 0;
	sprintf(s_aAttName, "%s%d", SRFMGR_SURFACE_IMPACTPOLYDEBRISNAME, nNumImpactPolyDebrisFX);

	while (buteMgr.Exist(aTagName, s_aAttName) && nNumImpactPolyDebrisFX < SRF_MAX_IMPACT_PSHOWERFX)
	{
		str = buteMgr.GetString(aTagName, s_aAttName);
		if (!str.IsEmpty())
		{
			CPolyDebrisFX* pPolyDebrisFX = g_pFXButeMgr->GetPolyDebrisFX((char*)(LPCSTR)str);
			if (pPolyDebrisFX)
			{
				aImpactPolyDebrisFXIds[nNumImpactPolyDebrisFX] = pPolyDebrisFX->nId;
			}
		}

		nNumImpactPolyDebrisFX++;
		sprintf(s_aAttName, "%s%d", SRFMGR_SURFACE_IMPACTPOLYDEBRISNAME, nNumImpactPolyDebrisFX);
	}

	// Build our under water impact particle shower fx id list...


	nNumUWImpactPShowerFX = 0;
	sprintf(s_aAttName, "%s%d", SRFMGR_SURFACE_UWIMPACTPSHOWERNAME, nNumUWImpactPShowerFX);

	while (buteMgr.Exist(aTagName, s_aAttName) && nNumUWImpactPShowerFX < SRF_MAX_IMPACT_PSHOWERFX)
	{
		str = buteMgr.GetString(aTagName, s_aAttName);
		if (!str.IsEmpty())
		{
			CPShowerFX* pPShowerFX = g_pFXButeMgr->GetPShowerFX((char*)(LPCSTR)str);
			if (pPShowerFX)
			{
				aUWImpactPShowerFXIds[nNumUWImpactPShowerFX] = pPShowerFX->nId;
			}
		}

		nNumUWImpactPShowerFX++;
		sprintf(s_aAttName, "%s%d", SRFMGR_SURFACE_UWIMPACTPSHOWERNAME, nNumUWImpactPShowerFX);
	}



	// Exit specific scale fx...

	// Build our exit scale fx id list...

	nNumExitScaleFX = 0;
	sprintf(s_aAttName, "%s%d", SRFMGR_SURFACE_EXITSCALENAME, nNumExitScaleFX);

	while (buteMgr.Exist(aTagName, s_aAttName) && nNumExitScaleFX < SRF_MAX_IMPACT_SCALEFX)
	{
		str = buteMgr.GetString(aTagName, s_aAttName);
		if (!str.IsEmpty())
		{
			CScaleFX* pScaleFX = g_pFXButeMgr->GetScaleFX((char*)(LPCSTR)str);
			if (pScaleFX)
			{
				aExitScaleFXIds[nNumExitScaleFX]  = pScaleFX->nId;
			}
		}

		nNumExitScaleFX++;
		sprintf(s_aAttName, "%s%d", SRFMGR_SURFACE_EXITSCALENAME, nNumExitScaleFX);
	}

	// Build our exit particle shower fx id list...

	nNumExitPShowerFX = 0;
	sprintf(s_aAttName, "%s%d", SRFMGR_SURFACE_EXITPSHOWERNAME, nNumExitPShowerFX);

	while (buteMgr.Exist(aTagName, s_aAttName) && nNumExitPShowerFX < SRF_MAX_IMPACT_PSHOWERFX)
	{
		str = buteMgr.GetString(aTagName, s_aAttName);
		if (!str.IsEmpty())
		{
			CPShowerFX* pPShowerFX = g_pFXButeMgr->GetPShowerFX((char*)(LPCSTR)str);
			if (pPShowerFX)
			{
				aExitPShowerFXIds[nNumExitPShowerFX] = pPShowerFX->nId;
			}
		}

		nNumExitPShowerFX++;
		sprintf(s_aAttName, "%s%d", SRFMGR_SURFACE_EXITPSHOWERNAME, nNumExitPShowerFX);
	}

	// Build our exit poly debris fx id list...

	nNumExitPolyDebrisFX = 0;
	sprintf(s_aAttName, "%s%d", SRFMGR_SURFACE_EXITPOLYDEBRISNAME, nNumExitPolyDebrisFX);

	while (buteMgr.Exist(aTagName, s_aAttName) && nNumExitPolyDebrisFX < SRF_MAX_IMPACT_PSHOWERFX)
	{
		str = buteMgr.GetString(aTagName, s_aAttName);
		if (!str.IsEmpty())
		{
			CPolyDebrisFX* pPolyDebrisFX = g_pFXButeMgr->GetPolyDebrisFX((char*)(LPCSTR)str);
			if (pPolyDebrisFX)
			{
				aExitPolyDebrisFXIds[nNumExitPolyDebrisFX] = pPolyDebrisFX->nId;
			}
		}

		nNumExitPolyDebrisFX++;
		sprintf(s_aAttName, "%s%d", SRFMGR_SURFACE_EXITPOLYDEBRISNAME, nNumExitPolyDebrisFX);
	}

	// Build our under water exit particle shower fx id list...

	nNumUWExitPShowerFX = 0;
	sprintf(s_aAttName, "%s%d", SRFMGR_SURFACE_UWIMPACTPSHOWERNAME, nNumUWExitPShowerFX);

	while (buteMgr.Exist(aTagName, s_aAttName) && nNumUWExitPShowerFX < SRF_MAX_IMPACT_PSHOWERFX)
	{
		str = buteMgr.GetString(aTagName, s_aAttName);
		if (!str.IsEmpty())
		{
			CPShowerFX* pPShowerFX = g_pFXButeMgr->GetPShowerFX((char*)(LPCSTR)str);
			if (pPShowerFX)
			{
				aUWExitPShowerFXIds[nNumUWExitPShowerFX] = pPShowerFX->nId;
			}
		}

		nNumUWExitPShowerFX++;
		sprintf(s_aAttName, "%s%d", SRFMGR_SURFACE_UWIMPACTPSHOWERNAME, nNumUWExitPShowerFX);
	}

    return LTTRUE;
}