SendProp *UTIL_FindSendProp(SendTable *pTable, const char *name)
{
int count = pTable->GetNumProps();
//SendTable *pTable;
SendProp *pProp;
for (int i=0; i<count; i++)
{
pProp = pTable->GetProp(i);
if ( g_PrintProps )
Msg("%s\n",pProp->GetName());
if (strcmp(pProp->GetName(), name) == 0)
{
return pProp;
}
if (pProp->GetDataTable())
{
if ((pProp=UTIL_FindSendProp(pProp->GetDataTable(), name)) != NULL)
{
return pProp;
}
}
}
return NULL;
}
void AddSendTable(SendTable* pTable, OffsetsMap& offsets, int offset=0, const char* baseName=NULL)
{
for (int i=0; i < pTable->GetNumProps(); ++i)
{
SendProp* pProp = pTable->GetProp(i);
if (strcmp(pProp->GetName(), "baseclass") == 0)
continue;
int currentOffset = offset + pProp->GetOffset();
char* currentName = NULL;
if (baseName == NULL) {
currentName = (char*) pProp->GetName();
}
else {
char tempName[256];
sprintf(tempName, "%s.%s", baseName, pProp->GetName());
currentName = strdup(tempName);
}
if (pProp->GetType() == DPT_DataTable)
{
AddSendTable(pProp->GetDataTable(), offsets, currentOffset, currentName);
}
else
{
offsets.insert(std::make_pair(currentName, currentOffset));
}
}
}
//---------------------------------------------------------------------------------
// 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;
}
bool UTIL_FindInSendTable(SendTable *pTable,
const char *name,
sm_sendprop_info_t *info,
unsigned int offset)
{
const char *pname;
int props = pTable->GetNumProps();
SendProp *prop;
for (int i=0; i<props; i++)
{
prop = pTable->GetProp(i);
pname = prop->GetName();
if (pname && strcmp(name, pname) == 0)
{
info->prop = prop;
info->actual_offset = offset + info->prop->GetOffset();
return true;
}
if (prop->GetDataTable())
{
if (UTIL_FindInSendTable(prop->GetDataTable(),
name,
info,
offset + prop->GetOffset())
)
{
return true;
}
}
}
return false;
}
void UTIL_DrawSendTable(FILE *fp, SendTable *pTable, int level = 1)
{
SendProp *pProp;
const char *type;
for (int i = 0; i < pTable->GetNumProps(); i++)
{
pProp = pTable->GetProp(i);
if (pProp->GetDataTable())
{
fprintf(fp, "%*sTable: %s (offset %d) (type %s)\n",
level, "",
pProp->GetName(),
pProp->GetOffset(),
pProp->GetDataTable()->GetName());
UTIL_DrawSendTable(fp, pProp->GetDataTable(), level + 1);
}
else
{
type = GetDTTypeName(pProp->GetType());
if (type != NULL)
{
fprintf(fp,
"%*sMember: %s (offset %d) (type %s) (bits %d) (%s)\n",
level, "",
pProp->GetName(),
pProp->GetOffset(),
type,
pProp->m_nBits,
UTIL_SendFlagsToString(pProp->GetFlags(), pProp->GetType()));
}
else
{
fprintf(fp,
"%*sMember: %s (offset %d) (type %d) (bits %d) (%s)\n",
level, "",
pProp->GetName(),
pProp->GetOffset(),
pProp->GetType(),
pProp->m_nBits,
UTIL_SendFlagsToString(pProp->GetFlags(), pProp->GetType()));
}
}
}
}
void UTIL_DrawSendTable(FILE *fp, SendTable *pTable, int level)
{
char spaces[255];
for (int i=0; i<level; i++)
spaces[i] = ' ';
spaces[level] = '\0';
const char *name, *type;
SendProp *pProp;
fprintf(fp, "%sSub-Class Table (%d Deep): %s\n", spaces, level, pTable->GetName());
for (int i=0; i<pTable->GetNumProps(); i++)
{
pProp = pTable->GetProp(i);
name = pProp->GetName();
if (pProp->GetDataTable())
{
UTIL_DrawSendTable(fp, pProp->GetDataTable(), level + 1);
}
else
{
type = GetDTTypeName(pProp->GetType());
if (type != NULL)
{
fprintf(fp,
"%s-Member: %s (offset %d) (type %s) (bits %d)\n",
spaces,
pProp->GetName(),
pProp->GetOffset(),
type,
pProp->m_nBits);
}
else
{
fprintf(fp,
"%s-Member: %s (offset %d) (type %d) (bits %d)\n",
spaces,
pProp->GetName(),
pProp->GetOffset(),
pProp->GetType(),
pProp->m_nBits);
}
}
}
}
cell_t GetPropName(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();
SendProp *pProp;
if ((err=g_pHandleSys->ReadHandle(hndl, g_SendTableHandle, &sec, (void **)&pProp)) != HandleError_None)
{
return pContext->ThrowNativeError("Invalid SendProp handle %x (error %d)", hndl, err);
}
pContext->StringToLocal(params[2], params[3], pProp->GetName());
return strlen(pProp->GetName());
}
// ============================================================================
// >> HELPER FUNCTIONS
// ============================================================================
SendTable* GetNextSendTable(SendTable* pTable)
{
for (int i=0; i < pTable->GetNumProps(); ++i)
{
SendProp* pProp = pTable->GetProp(i);
if (strcmp(pProp->GetName(), "baseclass") != 0)
continue;
return pProp->GetDataTable();
}
return NULL;
}
void UTIL_DrawSendTable_XML(FILE *fp, SendTable *pTable, int space_count)
{
char spaces[255];
for (int i = 0; i < space_count; i++)
{
spaces[i] = ' ';
}
spaces[space_count] = '\0';
const char *type_name;
SendTable *pOtherTable;
SendProp *pProp;
fprintf(fp, " %s<sendtable name=\"%s\">\n", spaces, pTable->GetName());
for (int i = 0; i < pTable->GetNumProps(); i++)
{
pProp = pTable->GetProp(i);
fprintf(fp, " %s<property name=\"%s\">\n", spaces, pProp->GetName());
if ((type_name = GetDTTypeName(pProp->GetType())) != NULL)
{
fprintf(fp, " %s<type>%s</type>\n", spaces, type_name);
}
else
{
fprintf(fp, " %s<type>%d</type>\n", spaces, pProp->GetType());
}
fprintf(fp, " %s<offset>%d</offset>\n", spaces, pProp->GetOffset());
fprintf(fp, " %s<bits>%d</bits>\n", spaces, pProp->m_nBits);
fprintf(fp, " %s<flags>%s</flags>\n", spaces, UTIL_SendFlagsToString(pProp->GetFlags(), pProp->GetType()));
if ((pOtherTable = pTable->GetProp(i)->GetDataTable()) != NULL)
{
UTIL_DrawSendTable_XML(fp, pOtherTable, space_count + 3);
}
fprintf(fp, " %s</property>\n", spaces);
}
fprintf(fp, " %s</sendtable>\n", spaces);
}
bool UTIL_FindInSendTable(SendTable *pTable,
const char *name,
sm_sendprop_info_t *info,
unsigned int offset)
{
const char *pname;
int props = pTable->GetNumProps();
SendProp *prop;
for (int i=0; i<props; i++)
{
prop = pTable->GetProp(i);
pname = prop->GetName();
if ( g_PrintProps )
Msg("%d : %s\n",offset + prop->GetOffset(),pname);
if (pname && strcmp(name, pname) == 0)
{
info->prop = prop;
// for some reason offset is sometimes negative when it shouldn't be
// so take the absolute value
info->actual_offset = offset + abs(info->prop->GetOffset());
return true;
}
if (prop->GetDataTable())
{
if (UTIL_FindInSendTable(prop->GetDataTable(),
name,
info,
offset + prop->GetOffset())
)
{
return true;
}
}
}
return false;
}
void EntityProp::getOffset(SendTable * table, istringstream & propPathLeft)
{
// Get the next step into the props table
string pathNextStep;
getline(propPathLeft, pathNextStep, '.');
//Msg("Scanning %s...\n", propPathLeft.c_str());
int nbrProps = table->GetNumProps();
int i=0;
while(i<nbrProps)
{
SendProp * sProp = table->GetProp(i);
if (pathNextStep == sProp->GetName())
{
offset += sProp->GetOffset();
switch(sProp->GetType())
{
case DPT_Int:
case DPT_Float:
case DPT_Vector:
case DPT_String:
case DPT_Array:
// Found the prop itself, the offset is up to date
i = nbrProps; // break
break;
case DPT_DataTable:
// Step reached, go to the next step
getOffset(sProp->GetDataTable(), propPathLeft);
break;
default:
// Prop not found
offset = 0;
i = nbrProps; // break
}
}
i++;
}
}
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;
}
// Spits out warnings for invalid properties and forces property values to
// be in valid ranges for the encoders and decoders.
static void SendTable_Validate( CSendTablePrecalc *pPrecalc )
{
SendTable *pTable = pPrecalc->m_pSendTable;
for( int i=0; i < pTable->m_nProps; i++ )
{
SendProp *pProp = &pTable->m_pProps[i];
if ( pProp->GetArrayProp() )
{
if ( pProp->GetArrayProp()->GetType() == DPT_DataTable )
{
Error( "Invalid property: %s/%s (array of datatables) [on prop %d of %d (%s)].", pTable->m_pNetTableName, pProp->GetName(), i, pTable->m_nProps, pProp->GetArrayProp()->GetName() );
}
}
else
{
ErrorIfNot( pProp->GetNumElements() == 1, ("Prop %s/%s has an invalid element count for a non-array.", pTable->m_pNetTableName, pProp->GetName()) );
}
// Check for 1-bit signed properties (their value doesn't get down to the client).
if ( pProp->m_nBits == 1 && !(pProp->GetFlags() & SPROP_UNSIGNED) )
{
DataTable_Warning("SendTable prop %s::%s is a 1-bit signed property. Use SPROP_UNSIGNED or the client will never receive a value.\n", pTable->m_pNetTableName, pProp->GetName());
}
}
for ( int i = 0; i < pPrecalc->GetNumProps(); ++i )
{
const SendProp *pProp = pPrecalc->GetProp( i );
if ( pProp->GetFlags() & SPROP_ENCODED_AGAINST_TICKCOUNT )
{
pTable->SetHasPropsEncodedAgainstTickcount( true );
break;
}
}
}
