// http://svn.alliedmods.net/viewvc.cgi/trunk/extensions/tf2/extension.cpp?revision=2183&root=sourcemod&pathrev=2183
edict_t *CClassInterface::FindEntityByNetClass(int start, const char *classname)
{
edict_t *current;
for (register short int i = 0; i < MAX_ENTITIES; i++)
{
current = engine->PEntityOfEntIndex(i);
if (current == NULL)
{
continue;
}
IServerNetworkable *network = current->GetNetworkable();
if (network == NULL)
{
continue;
}
ServerClass *sClass = network->GetServerClass();
const char *name = sClass->GetName();
if (strcmp(name, classname) == 0)
{
return current;
}
}
return NULL;
}
DataTableInfo *CHalfLife2::_FindServerClass(const char *classname)
{
DataTableInfo *pInfo = NULL;
if (!sm_trie_retrieve(m_pClasses, classname, (void **)&pInfo))
{
ServerClass *sc = gamedll->GetAllServerClasses();
while (sc)
{
if (strcmp(classname, sc->GetName()) == 0)
{
pInfo = new DataTableInfo;
pInfo->sc = sc;
sm_trie_insert(m_pClasses, classname, pInfo);
m_Tables.push_back(pInfo);
break;
}
sc = sc->m_pNext;
}
if (!pInfo)
{
return NULL;
}
}
return pInfo;
}
const char *CClassInterface::FindEntityNetClass(int start, const char *classname)
{
edict_t *current;
for (register short int i = 0; i < MAX_ENTITIES; i++)
{
current = INDEXENT(i);
if (current == NULL)
{
continue;
}
IServerNetworkable *network = current->GetNetworkable();
if (network == NULL)
{
continue;
}
if (strcmp(current->GetClassName(), classname) == 0)
{
ServerClass *sClass = network->GetServerClass();
return sClass->GetName();
}
}
return NULL;
}
void EntityProp::initialize()
{
// Get all server classes
IServerGameDLL * serverGameDll = ServerPlugin::getInstance()->getInterfaces()->serverGameDll;
if (serverGameDll != NULL)
{
ServerClass * classes = serverGameDll->GetAllServerClasses();
// Search the suitable class
while (classes != NULL)
{
if (theClass == classes->GetName())
{
istringstream pathToProp(path);
getOffset(classes->m_pTable, pathToProp);
break;
}
else
classes = classes->m_pNext; // until m_pNext is NULL
}
}
else
CSSMATCH_PRINT(string(
"Unable to find the offset of prop ") + theClass +
", IServerGameDll instance not ready")
}
void UTIL_FindServerClassnamePrint(const char *name_cmd)
{
edict_t *current;
register short int maxEnts = (short int)MAX_ENTITIES;
for (register short int i = 0; i < maxEnts; i++)
{
current = INDEXENT(i);
if (current == NULL)
{
continue;
}
IServerNetworkable *network = current->GetNetworkable();
if (network == NULL)
{
continue;
}
ServerClass *sClass = network->GetServerClass();
const char *name = sClass->GetName();
if (strcmp(name, name_cmd) == 0)
{
CBotGlobals::BotMessage(NULL, 0, "%s", current->GetClassName());
return;
}
}
CBotGlobals::BotMessage(NULL, 0, "Not found");
}
int CSizzPluginContext::GetEntityByClassName( const char *name, edict_t *out[], int max_out )
{
int cur_ents = 0;
if (name && out)
{
int max_ents = m_pGlobals->maxEntities;
for (int i = 0; ((i < max_ents) && (cur_ents < max_out)); ++i)
{
edict_t *pEdict = EdictFromEntIndex(i);
if (pEdict && !pEdict->IsFree())
{
IServerNetworkable *pNetworkable = pEdict->GetNetworkable();
if (pNetworkable)
{
ServerClass *pServerClass = pNetworkable->GetServerClass();
if (pServerClass && SCHelpers::FStrEq(pServerClass->GetName(), name))
{
out[cur_ents++] = pEdict;
}
}
}
}
}
return cur_ents;
}
void UTIL_FindServerClassnamePrint(const char *name_cmd)
{
edict_t *current;
for (int i = 0; i < gpGlobals->maxEntities; i++)
{
current = engine->PEntityOfEntIndex(i);
if (current == NULL)
{
continue;
}
IServerNetworkable *network = current->GetNetworkable();
if (network == NULL)
{
continue;
}
ServerClass *sClass = network->GetServerClass();
const char *name = sClass->GetName();
if (strcmp(name, name_cmd) == 0)
{
CBotGlobals::botMessage(NULL,0,"%s",current->GetClassName());
return;
}
}
CBotGlobals::botMessage(NULL,0,"Not found");
}
const char *CClassInterface::FindEntityNetClass(int start, const char *classname)
{
edict_t *current;
for (int i = ((start != -1) ? start : 0); i < gpGlobals->maxEntities; i++)
{
current = engine->PEntityOfEntIndex(i);
if (current == NULL)
{
continue;
}
IServerNetworkable *network = current->GetNetworkable();
if (network == NULL)
{
continue;
}
if (strcmp(current->GetClassName(), classname) == 0)
{
ServerClass *sClass = network->GetServerClass();
return sClass->GetName();
}
}
return NULL;
}
//---------------------------------------------------------------------------------
// 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;
}
int FindEntityByNetClass(int start, const char *classname)
{
edict_t *current;
for (int i = ((start != -1) ? start : 0); i < gpGlobals->maxEntities; i++)
{
current = engine->PEntityOfEntIndex(i);
if (current == NULL || current->IsFree())
{
continue;
}
IServerNetworkable *network = current->GetNetworkable();
if (network == NULL)
{
continue;
}
ServerClass *sClass = network->GetServerClass();
const char *name = sClass->GetName();
if (strcmp(name, classname) == 0)
{
return i;
}
}
return -1;
}
GVariant *
server_get_variant (Server * server)
{
/* Okay, this doesn't do anything useful, but it will generate an error
which could be a good thing */
g_return_val_if_fail(IS_SERVER(server), NULL);
ServerClass * klass = SERVER_GET_CLASS(server);
if (klass->get_properties != NULL) {
GVariantBuilder tuple;
g_variant_builder_init(&tuple, G_VARIANT_TYPE_TUPLE);
if (IS_CITRIX_SERVER(server)) {
g_variant_builder_add_value(&tuple, g_variant_new_string("ica"));
} else if (IS_RDP_SERVER(server)) {
g_variant_builder_add_value(&tuple, g_variant_new_string("freerdp"));
} else if (IS_UCCS_SERVER(server)) {
g_variant_builder_add_value(&tuple, g_variant_new_string("uccs"));
} else if (IS_X2GO_SERVER(server)) {
g_variant_builder_add_value(&tuple, g_variant_new_string("x2go"));
} else {
g_assert_not_reached();
}
if (server->name != NULL) {
g_variant_builder_add_value(&tuple, g_variant_new_string(server->name));
} else {
g_warning("Server has no name");
g_variant_builder_add_value(&tuple, g_variant_new_string(""));
}
if (server->uri != NULL) {
g_variant_builder_add_value(&tuple, g_variant_new_string(server->uri));
} else {
g_warning("Server has no URI");
g_variant_builder_add_value(&tuple, g_variant_new_string(""));
}
g_variant_builder_add_value(&tuple, g_variant_new_boolean(server->last_used));
GVariant * props = klass->get_properties(server);
g_variant_builder_add_value(&tuple, props);
if (klass->get_applications != NULL) {
GVariant * array = klass->get_applications(server);
g_variant_builder_add_value(&tuple, array);
} else {
/* NULL array of applications */
g_variant_builder_add_value(&tuple, g_variant_new_array(G_VARIANT_TYPE("(si)"), NULL, 0));
}
return g_variant_builder_end(&tuple);
}
return NULL;
}
/**
* server_cached_domains:
* @server: Where should we find those domains?
*
* Gets a list of cached domains for a particular server, if this function
* isn't overriden, then a null array is returned.
*/
GVariant *
server_cached_domains (Server * server)
{
g_return_val_if_fail(IS_SERVER(server), NULL);
ServerClass * klass = SERVER_GET_CLASS(server);
if (klass->get_domains != NULL) {
return klass->get_domains(server);
}
return g_variant_new_array(G_VARIANT_TYPE_STRING, NULL, 0);
}
static ServerClass *UTIL_FindServerClass(const char *classname)
{
ServerClass *sc = gamedll->GetAllServerClasses();
while (sc)
{
if (strcmp(classname, sc->GetName()) == 0)
{
return sc;
}
sc = sc->m_pNext;
}
return nullptr;
}
/**
* server_set_last_used:
* @server: Server to look in
* @uri: URI to set as last used
*
* Checks the URI of this server to see if it matches, and then look
* to see if subclasses have a way to match it another way.
*/
void
server_set_last_used_server (Server * server, const gchar * uri)
{
g_return_if_fail(IS_SERVER(server));
if (g_strcmp0(server->uri, uri) == 0) {
server->last_used = TRUE;
} else {
ServerClass * klass = SERVER_GET_CLASS(server);
if (klass->set_last_used_server != NULL) {
klass->set_last_used_server(server, uri);
}
}
}
/**
* server_find_uri:
* @server: Server to look in
* @uri: URI to search for
*
* Checks the URI of this server to see if it matches, and then look
* to see if subclasses have a way to match it another way.
*/
Server *
server_find_uri (Server * server, const gchar * uri)
{
g_return_val_if_fail(IS_SERVER(server), NULL);
if (g_strcmp0(server->uri, uri) == 0) {
return server;
}
ServerClass * klass = SERVER_GET_CLASS(server);
if (klass->find_uri != NULL) {
return klass->find_uri(server, uri);
}
return NULL;
}
edict_t *CClassInterface::FindEntityByNetClassNearest(Vector vstart, const char *classname)
{
edict_t *current;
edict_t *pfound = NULL;
float fMindist = 8192.0f;
float fDist;
for (short int i = 0; i < gpGlobals->maxEntities; i++)
{
current = engine->PEntityOfEntIndex(i);
if (current == NULL)
{
continue;
}
if ( current->IsFree() )
continue;
if ( current->GetUnknown() == NULL )
continue;
IServerNetworkable *network = current->GetNetworkable();
if (network == NULL)
{
continue;
}
ServerClass *sClass = network->GetServerClass();
const char *name = sClass->GetName();
if (strcmp(name, classname) == 0)
{
fDist = (vstart - CBotGlobals::entityOrigin(current)).Length();
if ( !pfound || (fDist < fMindist))
{
fMindist = fDist;
pfound = current;
}
}
}
return pfound;
}
void InitTeamNatives()
{
g_Teams.clear();
g_Teams.resize(1);
int edictCount = gpGlobals->maxEntities;
for (int i=0; i<edictCount; i++)
{
edict_t *pEdict = PEntityOfEntIndex(i);
if (!pEdict || pEdict->IsFree())
{
continue;
}
if (!pEdict->GetNetworkable())
{
continue;
}
ServerClass *pClass = pEdict->GetNetworkable()->GetServerClass();
if (FindNestedDataTable(pClass->m_pTable, "DT_Team"))
{
SendProp *pTeamNumProp = g_pGameHelpers->FindInSendTable(pClass->GetName(), "m_iTeamNum");
if (pTeamNumProp != NULL)
{
int offset = pTeamNumProp->GetOffset();
CBaseEntity *pEnt = pEdict->GetUnknown()->GetBaseEntity();
int TeamIndex = *(int *)((unsigned char *)pEnt + offset);
if (TeamIndex >= (int)g_Teams.size())
{
g_Teams.resize(TeamIndex+1);
}
g_Teams[TeamIndex].ClassName = pClass->GetName();
g_Teams[TeamIndex].pEnt = pEnt;
}
}
}
}
static CBaseEntity *FindEntityByNetClass(int start, const char *classname)
{
int maxEntities = gpGlobals->maxEntities;
for (int i = start; i < maxEntities; i++)
{
edict_t *current = gamehelpers->EdictOfIndex(i);
if (current == NULL || current->IsFree())
continue;
IServerNetworkable *network = current->GetNetworkable();
if (network == NULL)
continue;
ServerClass *sClass = network->GetServerClass();
const char *name = sClass->GetName();
if (!strcmp(name, classname))
return gamehelpers->ReferenceToEntity(gamehelpers->IndexOfEdict(current));
}
return NULL;
}
DataTableInfo *CHalfLife2::_FindServerClass(const char *classname)
{
DataTableInfo *pInfo = NULL;
if (!m_Classes.retrieve(classname, &pInfo))
{
ServerClass *sc = gamedll->GetAllServerClasses();
while (sc)
{
if (strcmp(classname, sc->GetName()) == 0)
{
pInfo = new DataTableInfo(sc);
m_Classes.insert(classname, pInfo);
break;
}
sc = sc->m_pNext;
}
if (!pInfo)
return NULL;
}
return pInfo;
}
void SDKTools::OnCoreMapStart(edict_t *pEdictList, int edictCount, int clientMax)
{
g_Teams.clear();
g_Teams.resize(1);
for (int i=0; i<edictCount; i++)
{
edict_t *pEdict = engine->PEntityOfEntIndex(i);
if (!pEdict || pEdict->IsFree())
{
continue;
}
if (!pEdict->GetNetworkable())
{
continue;
}
ServerClass *pClass = pEdict->GetNetworkable()->GetServerClass();
if (FindTeamEntities(pClass->m_pTable, "DT_Team"))
{
SendProp *pTeamNumProp = g_pGameHelpers->FindInSendTable(pClass->GetName(), "m_iTeamNum");
if (pTeamNumProp != NULL)
{
int offset = pTeamNumProp->GetOffset();
CBaseEntity *pEnt = pEdict->GetUnknown()->GetBaseEntity();
int TeamIndex = *(int *)((unsigned char *)pEnt + offset);
if (TeamIndex >= (int)g_Teams.size())
{
g_Teams.resize(TeamIndex+1);
}
g_Teams[TeamIndex].ClassName = pClass->GetName();
g_Teams[TeamIndex].pEnt = pEnt;
}
}
}
}
edict_t *CSizzPluginContext::GetEntityByClassName( const char *name, int start_ent /*= 0*/ )
{
if (name)
{
int max_ents = m_pGlobals->maxEntities;
for (int i = start_ent; i < max_ents; ++i)
{
edict_t *pEdict = EdictFromEntIndex(i);
if (pEdict && !pEdict->IsFree())
{
IServerNetworkable *pNetworkable = pEdict->GetNetworkable();
if (pNetworkable)
{
ServerClass *pServerClass = pNetworkable->GetServerClass();
if (pServerClass && SCHelpers::FStrEq(pServerClass->GetName(), name))
{
return pEdict;
}
}
}
}
}
return nullptr;
}
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;
}
