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; }
// 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 (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; } ServerClass *sClass = network->GetServerClass(); const char *name = sClass->GetName(); if (strcmp(name, classname) == 0) { return current; } } return NULL; }
// 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; }
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"); }
IterationRetval_t EnumElement( IHandleEntity *pHandleEntity ) { // skip static props, the game DLL doesn't care about them if ( StaticPropMgr()->IsStaticProp( pHandleEntity ) ) return ITERATION_CONTINUE; IServerNetworkable *pNetworkable = static_cast< IServerNetworkable* >( pHandleEntity ); Assert( pNetworkable ); // Convert the user ID to and edict_t*... edict_t* pTouch = pNetworkable->GetEdict(); // Can't ever touch itself because it's in the other list if ( pTouch == m_pTriggerEntity ) return ITERATION_CONTINUE; IServerEntity *serverEntity = pTouch->GetIServerEntity(); if ( !serverEntity ) return ITERATION_CONTINUE; if ( m_headnode >= 0 ) { Vector vecMins, vecMaxs; CM_WorldAlignBounds( serverEntity->GetCollideable(), &vecMins, &vecMaxs ); int contents = CM_TransformedBoxContents( serverEntity->GetAbsOrigin(), vecMins, vecMaxs, m_headnode, m_origin, m_angles ); if ( !(contents & MASK_SOLID) ) return ITERATION_CONTINUE; } m_TouchedEntities.AddToTail( pTouch ); return ITERATION_CONTINUE; }
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"); }
inline edict_t *BaseEntityToEdict(CBaseEntity *pEntity) { IServerUnknown *pUnk = (IServerUnknown *)pEntity; IServerNetworkable *pNet = pUnk->GetNetworkable(); if(!pNet) return NULL; return pNet->GetEdict(); }
CBaseNetworkable *CreateNetworkableByName( const char *className ) { IServerNetworkable *pNetwork = EntityFactoryDictionary()->Create( className ); if ( !pNetwork ) return NULL; CBaseNetworkable *pNetworkable = pNetwork->GetBaseNetworkable(); Assert( pNetworkable ); return pNetworkable; }
ICollideable *CEngineTraceServer::GetCollideable( IHandleEntity *pEntity ) { Assert( pEntity ); ICollideable *pProp = StaticPropMgr()->GetStaticProp( pEntity ); if ( pProp ) return pProp; IServerNetworkable *pNetEntity = (IServerNetworkable*)pEntity; return pNetEntity->GetEdict()->GetCollideable(); }
IterationRetval_t EnumElement( IHandleEntity *pHandleEntity ) { // Static props should never be in the trigger list Assert( !StaticPropMgr()->IsStaticProp( pHandleEntity ) ); IServerNetworkable *pNetworkable = static_cast<IServerNetworkable*>( pHandleEntity ); Assert( pNetworkable ); // Convert the IHandleEntity to an edict_t*... // Context is the thing we're testing everything against edict_t* pTouch = pNetworkable->GetEdict(); // Can't bump against itself if ( pTouch == m_pEnt ) return ITERATION_CONTINUE; IServerEntity *serverEntity = pTouch->GetIServerEntity(); if ( !serverEntity ) return ITERATION_CONTINUE; // Hmmm.. everything in this list should be a trigger.... ICollideable *pCollideable = serverEntity->GetCollideable(); Assert(pCollideable->GetSolidFlags() & FSOLID_TRIGGER ); if ( (pCollideable->GetSolidFlags() & FSOLID_TRIGGER) == 0 ) return ITERATION_CONTINUE; model_t* pModel = sv.GetModel( pCollideable->GetCollisionModelIndex() ); if ( pModel && pModel->type == mod_brush ) { int headnode = SV_HullForEntity( pTouch ); int contents; if (!m_Ray.m_IsSwept) { contents = CM_TransformedBoxContents( m_Ray.m_Start, m_mins, m_maxs, headnode, serverEntity->GetAbsOrigin(), serverEntity->GetAbsAngles() ); } else { trace_t trace; CM_TransformedBoxTrace( m_Ray, headnode, MASK_ALL, serverEntity->GetAbsOrigin(), serverEntity->GetAbsAngles(), trace ); contents = trace.contents; } if ( !(contents & MASK_SOLID) ) return ITERATION_CONTINUE; } m_TouchedEntities.AddToTail( pTouch ); return ITERATION_CONTINUE; }
//----------------------------------------------------------------------------- // Returns an index from the given BaseEntity instance. //----------------------------------------------------------------------------- bool IndexFromBaseEntity( CBaseEntity *pBaseEntity, unsigned int& output ) { if (!pBaseEntity) return false; IServerNetworkable *pServerNetworkable = pBaseEntity->GetNetworkable(); if (!pServerNetworkable) return false; edict_t* pEdict = pServerNetworkable->GetEdict(); if (!pEdict || pEdict->IsFree()) return false; return IndexFromEdict(pEdict, output); }
//----------------------------------------------------------------------------- // Returns an Edict instance from the given BaseEntity instance. //----------------------------------------------------------------------------- bool EdictFromBaseEntity( CBaseEntity *pBaseEntity, edict_t*& output ) { if (!pBaseEntity) return false; IServerNetworkable *pServerNetworkable = pBaseEntity->GetNetworkable(); if (!pServerNetworkable) return false; edict_t* pEdict = pServerNetworkable->GetEdict(); if (!pEdict || pEdict->IsFree()) return false; output = pEdict; return true; }
// creates an entity by string name, but does not spawn it CBaseEntity *CreateEntityByName( const char *className, int iForceEdictIndex ) { if ( iForceEdictIndex != -1 ) { g_pForceAttachEdict = engine->CreateEdict( iForceEdictIndex ); if ( !g_pForceAttachEdict ) Error( "CreateEntityByName( %s, %d ) - CreateEdict failed.", className, iForceEdictIndex ); } IServerNetworkable *pNetwork = EntityFactoryDictionary()->Create( className ); g_pForceAttachEdict = NULL; if ( !pNetwork ) return NULL; CBaseEntity *pEntity = pNetwork->GetBaseEntity(); Assert( pEntity ); return pEntity; }
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; }
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; }
//----------------------------------------------------------------------------- // Converts a user id to a collideable + username //----------------------------------------------------------------------------- void CEngineTraceServer::HandleEntityToCollideable( IHandleEntity *pHandleEntity, ICollideable **ppCollide, const char **ppDebugName ) { *ppCollide = StaticPropMgr()->GetStaticProp( pHandleEntity ); if ( *ppCollide ) { *ppDebugName = "static prop"; return; } IServerNetworkable *pServerNetworkable = static_cast<IServerNetworkable*>(pHandleEntity); if ( !pServerNetworkable ) { *ppCollide = NULL; *ppDebugName = "<null>"; return; } edict_t *pEdict = pServerNetworkable->GetEdict(); Assert( pEdict ); *ppCollide = pEdict->GetCollideable(); *ppDebugName = pServerNetworkable->GetServerClass()->GetName(); }
void SMJS_Entity::SetEntity(CBaseEntity *ent){ if(this->ent != NULL){ if(this->ent != ent){ throw "Cannot set entity twice"; } return; } this->valid = false; if(ent == NULL) return; this->ent = ent; IServerUnknown *pUnk = (IServerUnknown *)ent; IServerNetworkable *pNet = pUnk->GetNetworkable(); if(pNet){ edict = pNet->GetEdict(); entIndex = gamehelpers->IndexOfEdict(edict); } this->valid = true; }
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; }
IServerEntity *CServerTools::GetIServerEntity( IClientEntity *pClientEntity ) { if ( pClientEntity == NULL ) return NULL; CBaseHandle ehandle = pClientEntity->GetRefEHandle(); if ( ehandle.GetEntryIndex() >= MAX_EDICTS ) return NULL; // the first MAX_EDICTS entities are networked, the rest are client or server only #if 0 // this fails, since the server entities have extra bits in their serial numbers, // since 20 bits are reserved for serial numbers, except for networked entities, which are restricted to 10 // Brian believes that everything should just restrict itself to 10 to make things simpler, // so if/when he changes NUM_SERIAL_NUM_BITS to 10, we can switch back to this simpler code IServerNetworkable *pNet = gEntList.GetServerNetworkable( ehandle ); if ( pNet == NULL ) return NULL; CBaseEntity *pServerEnt = pNet->GetBaseEntity(); return pServerEnt; #else IHandleEntity *pEnt = gEntList.LookupEntityByNetworkIndex( ehandle.GetEntryIndex() ); if ( pEnt == NULL ) return NULL; CBaseHandle h = gEntList.GetNetworkableHandle( ehandle.GetEntryIndex() ); const int mask = ( 1 << NUM_NETWORKED_EHANDLE_SERIAL_NUMBER_BITS ) - 1; if ( !h.IsValid() || ( ( h.GetSerialNumber() & mask ) != ( ehandle.GetSerialNumber() & mask ) ) ) return NULL; IServerUnknown *pUnk = static_cast< IServerUnknown* >( pEnt ); return pUnk->GetBaseEntity(); #endif }
CEntity *CEntityManager::CBaseEntityPostConstructor(CBaseEntity *pEntity, const char * szClassname ) { IServerNetworkable *pNetworkable = pEntity->GetNetworkable(); Assert(pNetworkable); edict_t *pEdict = pNetworkable->GetEdict(); if(strcmp(szClassname,"player") == 0 && engine->IndexOfEdict(pEdict) == 0) { return NULL; } IEntityFactory_CE **value = NULL; bool m_bShouldAddToCache = false; value = pCacheTrie.retrieve(szClassname); if(!value) { m_bShouldAddToCache = true; value = pFactoryTrie.retrieve(szClassname); } if (!value) { /* Attempt to do an RTTI lookup for C++ class links */ IType *pType = GetType(pEntity); IBaseType *pBase = pType->GetBaseType(); do { const char *classname = GetTypeName(pBase->GetTypeInfo()); value = pFactoryTrie.retrieve(classname); if (value) { break; } } while (pBase->GetNumBaseClasses() && (pBase = pBase->GetBaseClass(0))); pType->Destroy(); } if (!value) { /* No specific handler for this entity */ value = pFactoryTrie.retrieve("baseentity"); assert(value); } IEntityFactory_CE *pFactory = *value; assert(pFactory); if(m_bShouldAddToCache) { pCacheTrie.insert(szClassname, pFactory); } CEntity *cent = pFactory->Create(pEdict, pEntity); char vtable[20]; _snprintf(vtable, sizeof(vtable), "%x", (unsigned int) *(void **)pEntity); cent->ClearAllFlags(); cent->InitProps(); if (!pHookedTrie.retrieve(vtable)) { cent->InitHooks(); pHookedTrie.insert(vtable, true); } cent->InitDataMap(); return cent; }