IPhysicsVehicleController *GetLuaVehicle(ILuaInterface *gLua)
{
gLua->CheckType(1, GLua::TYPE_ENTITY);
CBaseHandle *handle = (CBaseHandle*)gLua->GetUserData(1);
CBaseEntity *entity = GetBaseEntity(handle->GetEntryIndex());
if(!entity)
{
gLua->Error("[gm_pimpmyride] NO ENTITY!");
return NULL;
}
IServerVehicle *vehicle = entity->GetServerVehicle();
if(!vehicle)
{
gLua->Error("[gm_pimpmyride] NO VEHICLE!");
return NULL;
}
IPhysicsVehicleController *controller = vehicle->GetVehicleController();
if(!controller)
{
gLua->Error("[gm_pimpmyride] NO PHYSICS CONTROLLER!");
return NULL;
}
return controller;
}
bool CTeamControlPointRound :: isPointInRound ( edict_t *point_pent )
{
edict_t *pPoint;
extern ConVar rcbot_const_point_offset;
for ( int i = 0; i < m_ControlPoints.Size(); i ++ )
{
CBaseHandle *hndl;
hndl = (CBaseHandle *)&(m_ControlPoints[i]);
if ( hndl )
{
pPoint = INDEXENT(hndl->GetEntryIndex());
CBaseEntity *pent = pPoint->GetUnknown()->GetBaseEntity();
if ( point_pent->GetUnknown()->GetBaseEntity() == pent )
return true;
//CTeamControlPoint *point = (CTeamControlPoint*)((unsigned long)pent + rcbot_const_point_offset.GetInt() );
//if ( point )
//{
// if ( point->m_iIndex == iIndex )
// return true;
//}
}
}
return false;
}
int CheckBaseHandle(CBaseHandle &hndl)
{
if (!hndl.IsValid())
{
return -1;
}
int index = hndl.GetEntryIndex();
edict_t *pStoredEdict;
pStoredEdict = engine->PEntityOfEntIndex(index);
if (pStoredEdict == NULL)
{
return -1;
}
IServerEntity *pSE = pStoredEdict->GetIServerEntity();
if (pSE == NULL)
{
return -1;
}
if (pSE->GetRefEHandle() != hndl)
{
return -1;
}
return index;
}
void CClientEntityList::OnAddEntity( IHandleEntity *pEnt, CBaseHandle handle )
{
int entnum = handle.GetEntryIndex();
EntityCacheInfo_t *pCache = &m_EntityCacheInfo[entnum];
if ( entnum >= 0 && entnum < MAX_EDICTS )
{
// Update our counters.
m_iNumServerEnts++;
if ( entnum > m_iMaxUsedServerIndex )
{
m_iMaxUsedServerIndex = entnum;
}
// Cache its networkable pointer.
Assert( dynamic_cast< IClientUnknown* >( pEnt ) );
Assert( ((IClientUnknown*)pEnt)->GetClientNetworkable() ); // Server entities should all be networkable.
pCache->m_pNetworkable = ((IClientUnknown*)pEnt)->GetClientNetworkable();
}
// Store it in a special list for fast iteration if it's a C_BaseEntity.
IClientUnknown *pUnknown = (IClientUnknown*)pEnt;
C_BaseEntity *pBaseEntity = pUnknown->GetBaseEntity();
if ( pBaseEntity )
{
pCache->m_BaseEntitiesIndex = m_BaseEntities.AddToTail( pBaseEntity );
}
else
{
pCache->m_BaseEntitiesIndex = m_BaseEntities.InvalidIndex();
}
}
int PyHandle::Cmp( bp::object other )
{
// The thing to which we compare is NULL
PyObject *pPyObject = other.ptr();
if( pPyObject == Py_None ) {
return Get() != NULL;
}
// We are NULL
if( Get() == NULL )
{
return pPyObject != NULL;
}
// Check if it is directly a pointer to an entity
#ifdef CLIENT_DLL
if( PyObject_IsInstance(pPyObject, bp::object(_entities.attr("C_BaseEntity")).ptr()) )
#else
if( PyObject_IsInstance(pPyObject, bp::object(_entities.attr("CBaseEntity")).ptr()) )
#endif // CLIENT_DLL
{
CBaseEntity *pSelf = Get();
CBaseEntity *pOther = boost::python::extract< CBaseEntity * >(other);
if( pOther == pSelf )
{
return 0;
}
else if( pOther->entindex() > pSelf->entindex() )
{
return 1;
}
else
{
return -1;
}
}
try
{
// Must be a handle
CBaseHandle *pHandle = bp::extract< CBaseHandle * >( other );
if( pHandle )
{
if( pHandle->ToInt() == ToInt() )
return 0;
else if( pHandle->GetEntryIndex() > GetEntryIndex() )
return 1;
else
return -1;
}
}
catch( bp::error_already_set & )
{
// Not a handle, just clear error and return -1
PyErr_Clear();
}
return -1;
}
//-----------------------------------------------------------------------------
// Returns an index from the given BaseHandle instance.
//-----------------------------------------------------------------------------
bool IndexFromBaseHandle( CBaseHandle hBaseHandle, unsigned int& output )
{
if (!hBaseHandle.IsValid() || !hBaseHandle.ToInt())
return false;
int iEntityIndex = hBaseHandle.GetEntryIndex();
if (iEntityIndex == INVALID_ENTITY_INDEX)
return false;
output = iEntityIndex;
return true;
}
void SendProxy_EHandleToInt( const SendProp *pProp, const void *pStruct, const void *pVarData, DVariant *pOut, int iElement, int objectID)
{
CBaseHandle *pHandle = (CBaseHandle*)pVarData;
if ( pHandle && pHandle->Get() )
{
int iSerialNum = pHandle->GetSerialNumber() & (1 << NUM_NETWORKED_EHANDLE_SERIAL_NUMBER_BITS) - 1;
pOut->m_Int = pHandle->GetEntryIndex() | (iSerialNum << MAX_EDICT_BITS);
}
else
{
pOut->m_Int = INVALID_NETWORKED_EHANDLE_VALUE;
}
}
cell_t CHalfLife2::EntityToBCompatRef(CBaseEntity *pEntity)
{
if (pEntity == NULL)
{
return INVALID_EHANDLE_INDEX;
}
IServerUnknown *pUnknown = (IServerUnknown *)pEntity;
CBaseHandle hndl = pUnknown->GetRefEHandle();
if (hndl == INVALID_EHANDLE_INDEX)
{
return INVALID_EHANDLE_INDEX;
}
if (hndl.GetEntryIndex() >= MAX_EDICTS)
{
return (hndl.ToInt() | (1<<31));
}
else
{
return hndl.GetEntryIndex();
}
}
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
}
void CGlobalEntityList::OnAddEntity( IHandleEntity *pEnt, CBaseHandle handle )
{
int i = handle.GetEntryIndex();
// record current list details
m_iNumEnts++;
if ( i > m_iHighestEnt )
m_iHighestEnt = i;
// If it's a CBaseEntity, notify the listeners.
CBaseEntity *pBaseEnt = static_cast<IServerUnknown*>(pEnt)->GetBaseEntity();
if ( pBaseEnt->edict() )
m_iNumEdicts++;
// NOTE: Must be a CBaseEntity on server
Assert( pBaseEnt );
//DevMsg(2,"Created %s\n", pBaseEnt->GetClassname() );
for ( i = m_entityListeners.Count()-1; i >= 0; i-- )
{
m_entityListeners[i]->OnEntityCreated( pBaseEnt );
}
}
void CClientEntityList::OnRemoveEntity( IHandleEntity *pEnt, CBaseHandle handle )
{
int entnum = handle.GetEntryIndex();
EntityCacheInfo_t *pCache = &m_EntityCacheInfo[entnum];
if ( entnum >= 0 && entnum < MAX_EDICTS )
{
// This is a networkable ent. Clear out our cache info for it.
pCache->m_pNetworkable = NULL;
m_iNumServerEnts--;
if ( entnum >= m_iMaxUsedServerIndex )
{
RecomputeHighestEntityUsed();
}
}
if ( pCache->m_BaseEntitiesIndex != m_BaseEntities.InvalidIndex() )
m_BaseEntities.Remove( pCache->m_BaseEntitiesIndex );
pCache->m_BaseEntitiesIndex = m_BaseEntities.InvalidIndex();
}
void CBaseEntityList::RemoveEntity( CBaseHandle handle )
{
RemoveEntityAtSlot( handle.GetEntryIndex() );
}