//---------------------------------------------------------------------------------
// Purpose: returns the specified prop offset relative to the table provided.
// if offset or table not found, bErr returns true and offset returned is 0
//---------------------------------------------------------------------------------
unsigned int GetPropOffsetFromTable(const char *pTableName, const char *pPropName)
{
ServerClass *pClass = pServerDLL->GetAllServerClasses();
if (!pClass)
{
Warning("servergamedll->GetAllServerClasses() returned null\n");
return 0;
}
while (pClass)
{
SendTable *pTable = GetDataTable( pTableName, pClass->m_pTable );
if (pTable == NULL)
{
pClass = pClass->m_pNext;
continue;
}
int num = pTable->GetNumProps();
for (int i = 0; i < num; i++)
{
SendProp *pProp = pTable->GetProp(i);
if ( FStrEq( pPropName, pProp->GetName() ) )
{
return pProp->GetOffset();
}
}
pClass = pClass->m_pNext;
}
Warning("prop %s not found in %s or table name incorrect\n", pPropName, pTableName);
return 0;
}
//---------------------------------------------------------------------------------
// Purpose: returns the specified prop from the class and table provided.
// if prop or table not found, pointer returns NULL
//---------------------------------------------------------------------------------
SendProp *GetPropFromClassAndTable(const char *szClassName, const char *szTableName, const char *szPropName)
{
ServerClass *pServerClass = pServerDLL->GetAllServerClasses();
if (!pServerClass)
{
Warning("servergamedll->GetAllServerClasses() returned null\n");
return NULL;
}
while (pServerClass)
{
if ( FStrEq(szClassName, pServerClass->GetName()) )
{
SendTable *pTable = GetDataTable( szTableName, pServerClass->m_pTable );
if (pTable)
{
int numprops = pTable->GetNumProps();
for (int i = 0; i < numprops; ++i)
{
SendProp *pProp = pTable->GetProp(i);
if (pProp && FStrEq(szPropName, pProp->GetName()) )
{
return pProp;
}
}
}
}
pServerClass = pServerClass->m_pNext;
}
Warning("prop %s not found in %s => %s\n", szPropName, szClassName, szTableName);
return NULL;
}
void SendTable_PrintStats( void )
{
int numTables = 0;
int numFloats = 0;
int numStrings = 0;
int numArrays = 0;
int numInts = 0;
int numVecs = 0;
int numSubTables = 0;
int numSendProps = 0;
int numFlatProps = 0;
int numExcludeProps = 0;
for ( int i=0; i < g_SendTables.Count(); i++ )
{
SendTable *st = g_SendTables[i];
numTables++;
numSendProps += st->GetNumProps();
numFlatProps += st->m_pPrecalc->GetNumProps();
for ( int j=0; j < st->GetNumProps(); j++ )
{
SendProp* sp = st->GetProp( j );
if ( sp->IsExcludeProp() )
{
numExcludeProps++;
continue; // no real sendprops
}
if ( sp->IsInsideArray() )
continue;
switch( sp->GetType() )
{
case DPT_Int : numInts++; break;
case DPT_Float : numFloats++; break;
case DPT_Vector : numVecs++; break;
case DPT_String : numStrings++; break;
case DPT_Array : numArrays++; break;
case DPT_DataTable : numSubTables++; break;
}
}
}
Msg("Total Send Table stats\n");
Msg("Send Tables : %i\n", numTables );
Msg("Send Props : %i\n", numSendProps );
Msg("Flat Props : %i\n", numFlatProps );
Msg("Int Props : %i\n", numInts );
Msg("Float Props : %i\n", numFloats );
Msg("Vector Props: %i\n", numVecs );
Msg("String Props: %i\n", numStrings );
Msg("Array Props : %i\n", numArrays );
Msg("Table Props : %i\n", numSubTables );
Msg("Exclu Props : %i\n", numExcludeProps );
}
cell_t GetProp(IPluginContext *pContext, const cell_t *params) {
Handle_t hndl = static_cast<Handle_t>(params[1]);
HandleError err;
HandleSecurity sec;
sec.pOwner = NULL;
sec.pIdentity = myself->GetIdentity();
SendTable *pTable;
if ((err=g_pHandleSys->ReadHandle(hndl, g_SendTableHandle, &sec, (void **)&pTable)) != HandleError_None)
{
return pContext->ThrowNativeError("Invalid SendTable handle %x (error %d)", hndl, err);
}
return g_pHandleSys->CreateHandle(g_SendTableHandle,
pTable->GetProp(params[2]),
pContext->GetIdentity(),
myself->GetIdentity(),
NULL);
}
bool MyPlugin::Load(CreateInterfaceFn interfaceFactory, CreateInterfaceFn gameServerFactory)
{
serverGameDLL = (IServerGameDLL *)gameServerFactory(INTERFACEVERSION_SERVERGAMEDLL, NULL);
if (serverGameDLL)
{
ServerClass *svrclass = serverGameDLL->GetAllServerClasses();
while (svrclass)
{
const char *classname = svrclass->GetName();
Msg("[%s]\n", classname);
if (strcmp(classname, "CBasePlayer") == 0)
{
SendTable *st = svrclass->m_pTable;
for (int i = 0; i < st->m_nProps; i++)
{
SendProp *sp = st->GetProp(i);
const char *propname = sp->GetName();
Msg("Prop name: %s | Prop Offset: %d | Type: %d | IsSigned: %d\n", propname, sp->GetOffset(), sp->GetType(), sp->IsSigned());
if (strcmp(propname, "m_fFlags") == 0)
{
m_fFlags_off = sp->GetOffset();
continue;
}
if (strcmp(propname, "m_iHealth") == 0)
{
m_iHealth_off = sp->GetOffset();
continue;
}
}
}
if (strcmp(classname, "CBaseEntity") == 0)
{
SendTable *st = svrclass->m_pTable;
for (int i = 0; i < st->m_nProps; i++)
{
SendProp *sp = st->GetProp(i);
const char *propname = sp->GetName();
Msg("Prop name: %s | Prop Offset: %d | Type: %d | IsSigned: %d\n", propname, sp->GetOffset(), sp->GetType(), sp->IsSigned());
if (strcmp(propname, "m_iTeamNum") == 0)
{
m_iTeamNum_off = sp->GetOffset();
continue;
}
if (strcmp(propname, "m_iPendingTeamNum") == 0)
{
m_iPendingTeamNum_off = sp->GetOffset();
continue;
}
if (strcmp(propname, "m_fEffects") == 0)
{
m_fEffects_off = sp->GetOffset();
continue;
}
if (strcmp(propname, "m_nRenderMode") == 0)
{
m_nRenderMode_off = sp->GetOffset();
continue;
}
}
}
/*if (strcmp(classname, "CBaseCombatWeapon") == 0)
{
SendTable *st = svrclass->m_pTable;
for (int i = 0; i < st->m_nProps; i++)
{
SendProp *sp = st->GetProp(i);
const char *propname = sp->GetName();
Msg("Prop name: %s | Prop Offset: %d | Type: %d | IsSigned: %d\n", propname, sp->GetOffset(), sp->GetType(), sp->IsSigned());
}
}*/
svrclass = svrclass->m_pNext;
}
}
else
{
Warning("Unable to load IServerGameDLL.\n");
return false;
}
serverGameEnts = (IServerGameEnts *)gameServerFactory(INTERFACEVERSION_SERVERGAMEENTS, NULL);
if (!serverGameEnts)
{
Warning("Unable to load IServerGameEnts.\n");
return false;
}
playerInfoManager = (IPlayerInfoManager *)gameServerFactory(INTERFACEVERSION_PLAYERINFOMANAGER, NULL);
if (playerInfoManager)
{
globalVars = playerInfoManager->GetGlobalVars();
}
else
{
Warning("Unable to load IPlayerInfoManager.\n");
return false;
}
g_pCVar = (ICvar *)interfaceFactory(CVAR_INTERFACE_VERSION, NULL);
if (g_pCVar)
{
ICvar::Iterator iter(g_pCVar);
for (iter.SetFirst(); iter.IsValid(); iter.Next())
{
ConCommandBase *cmd = iter.Get();
if (cmd->IsCommand())
continue;
const char *cmdname = cmd->GetName();
ConVar *cvar = (ConVar *)cmd;
if (strcmp(cmdname, "net_maxcleartime") == 0)
cvar->SetValue(0.001f);
/*if (strcmp(cmdname, "net_minroutable") == 0)
cvar->SetValue(1000);*/
}
}
else
{
Warning("Unable to load ICVar.\n");
return false;
}
gameEventManager2 = (IGameEventManager2 *)interfaceFactory(INTERFACEVERSION_GAMEEVENTSMANAGER2, NULL);
if (!gameEventManager2)
{
Warning("Unable to load IGameEventManager2.\n");
return false;
}
vEngineServer = (IVEngineServer *)interfaceFactory(INTERFACEVERSION_VENGINESERVER, NULL);
if (!vEngineServer)
{
Warning("Unable to load IVEngineServer.\n");
return false;
}
serverTools = (IServerTools *)gameServerFactory(VSERVERTOOLS_INTERFACE_VERSION, NULL);
if (!serverTools)
{
Warning("Unable to load IServerTools.\n");
return false;
}
serverPluginHelpers = (IServerPluginHelpers *)interfaceFactory(INTERFACEVERSION_ISERVERPLUGINHELPERS, NULL);
if (!serverPluginHelpers)
{
Warning("Unable to load IServerPluginHelpers.\n");
return false;
}
//playerDeathEvent = new PlayerDeathEvent();
//playerSayEvent = new PlayerSayEvent();
//playerConnectEvent = new PlayerConnectEvent();
//playerDisconnectEvent = new PlayerDisconnectEvent();
roundStartEvent = new RoundStartEvent();
//itemPickupEvent = new ItemPickupEvent();
//playerSpawnEvent = new PlayerSpawnEvent();
//playerSpawnedEvent = new PlayerSpawnedEvent();
//announphaseendevent = new AnnouncePhaseEndEvent();
return true;
}
int EntityPropsManager::getPropOffset(const std::string &path)
{
// Try to find if we have already this offset
int iOffset = 0;
int index = this->getIndexInList(path);
if(index > -1)
{
iOffset = EntityPropsList.at(index).propOffset;
}
if(iOffset)
{
return iOffset;
}
// If not, we have to find it.
iOffset = 0;
int i = 0;
std::string cpath;
std::vector<std::string> props;
strSplit(path, ".", &props);
ServerClass *pAllClasses = gamedll->GetAllServerClasses();
while(pAllClasses)
{
if(pAllClasses->GetName() == props.at(0)) // If we found the class
{
const int pSize = props.size(); // The use of const will accelerate the for instruction
if(pSize > 2) // path containing class.datatable.(...).prop
{
SendTable *lastTable = pAllClasses->m_pTable;
int iProps = 0;
for(int iPath = 1; iPath < pSize-1; iPath++) // get the last datatable in path
{
cpath = props.at(iPath);
iProps = lastTable->GetNumProps();
for(i = 0; i < iProps; i++)
{
if(lastTable->GetProp(i)->GetName() == props.at(iPath))
{
lastTable = lastTable->GetProp(i)->GetDataTable();
i = iProps;
}
}
}
iProps = lastTable->m_nProps;
for(i = 0; i < iProps; i++) // get the prop offset
{
if(lastTable->GetProp(i)->GetName() == props.back())
{
iOffset = lastTable->GetProp(i)->GetOffset();
if(iOffset < 0) // The offset must be not negative
{
iOffset *= -1;
}
return iOffset;
}
}
}
else // path containing only class.prop
{
const int iProps = pAllClasses->m_pTable->GetNumProps();
for(i = 0; i < iProps; i++)
{
//Msg(pAllClasses->m_pTable->GetProp(i)->GetName());
//Msg("\n");
if(pAllClasses->m_pTable->GetProp(i)->GetName() == props.back())
{
iOffset = pAllClasses->m_pTable->GetProp(i)->GetOffset();
if(iOffset < 0) // The offset must be not negative
{
iOffset *= -1;
}
return iOffset;
}
}
break;
}
} // End if(pAllClasses->GetName() == props.at(0))
pAllClasses = pAllClasses->m_pNext;
} // End while(!pAllClasses)
return 0;
}
