[teh ORiON]

Hi,

Im a bit puzzled as to how func_breakables actually gets removed when they die. The function "CBreakable :: Die( void )" is called when the breakable is destroyed.

CBreakable::Die( void )

PHP Code:

void CBreakable::Die( void )
{
    Vector vecSpot;// shard origin
    Vector vecVelocity;// shard velocity
    CBaseEntity *pEntity = NULL;
    char cFlag = 0;
    int pitch;
    float fvol;
    
    pitch = 95 + RANDOM_LONG(0,29);

    if (pitch > 97 && pitch < 103)
        pitch = 100;

    // The more negative pev->health, the louder
    // the sound should be.

    fvol = RANDOM_FLOAT(0.85, 1.0) + (abs(pev->health) / 100.0);

    if (fvol > 1.0)
        fvol = 1.0;


    switch (m_Material)
    {
    case matGlass:
        switch ( RANDOM_LONG(0,1) )
        {
        case 0:    EMIT_SOUND_DYN(ENT(pev), CHAN_VOICE, "debris/bustglass1.wav", fvol, ATTN_NORM, 0, pitch);    
            break;
        case 1:    EMIT_SOUND_DYN(ENT(pev), CHAN_VOICE, "debris/bustglass2.wav", fvol, ATTN_NORM, 0, pitch);    
            break;
        }
        cFlag = BREAK_GLASS;
        break;

    case matWood:
        switch ( RANDOM_LONG(0,1) )
        {
        case 0:    EMIT_SOUND_DYN(ENT(pev), CHAN_VOICE, "debris/bustcrate1.wav", fvol, ATTN_NORM, 0, pitch);    
            break;
        case 1:    EMIT_SOUND_DYN(ENT(pev), CHAN_VOICE, "debris/bustcrate2.wav", fvol, ATTN_NORM, 0, pitch);    
            break;
        }
        cFlag = BREAK_WOOD;
        break;

    case matComputer:
    case matMetal:
        switch ( RANDOM_LONG(0,1) )
        {
        case 0:    EMIT_SOUND_DYN(ENT(pev), CHAN_VOICE, "debris/bustmetal1.wav", fvol, ATTN_NORM, 0, pitch);    
            break;
        case 1:    EMIT_SOUND_DYN(ENT(pev), CHAN_VOICE, "debris/bustmetal2.wav", fvol, ATTN_NORM, 0, pitch);    
            break;
        }
        cFlag = BREAK_METAL;
        break;

    case matFlesh:
        switch ( RANDOM_LONG(0,1) )
        {
        case 0:    EMIT_SOUND_DYN(ENT(pev), CHAN_VOICE, "debris/bustflesh1.wav", fvol, ATTN_NORM, 0, pitch);    
            break;
        case 1:    EMIT_SOUND_DYN(ENT(pev), CHAN_VOICE, "debris/bustflesh2.wav", fvol, ATTN_NORM, 0, pitch);    
            break;
        }
        cFlag = BREAK_FLESH;
        break;

    case matRocks:
    case matCinderBlock:
        switch ( RANDOM_LONG(0,1) )
        {
        case 0:    EMIT_SOUND_DYN(ENT(pev), CHAN_VOICE, "debris/bustconcrete1.wav", fvol, ATTN_NORM, 0, pitch);    
            break;
        case 1:    EMIT_SOUND_DYN(ENT(pev), CHAN_VOICE, "debris/bustconcrete2.wav", fvol, ATTN_NORM, 0, pitch);    
            break;
        }
        cFlag = BREAK_CONCRETE;
        break;

    case matCeilingTile:
        EMIT_SOUND_DYN(ENT(pev), CHAN_VOICE, "debris/bustceiling.wav", fvol, ATTN_NORM, 0, pitch);
        break;
    }
    
        
    if (m_Explosion == expDirected)
        vecVelocity = g_vecAttackDir * 200;
    else
    {
        vecVelocity.x = 0;
        vecVelocity.y = 0;
        vecVelocity.z = 0;
    }

    vecSpot = pev->origin + (pev->mins + pev->maxs) * 0.5;
    MESSAGE_BEGIN( MSG_PVS, SVC_TEMPENTITY, vecSpot );
        WRITE_BYTE( TE_BREAKMODEL);

        // position
        WRITE_COORD( vecSpot.x );
        WRITE_COORD( vecSpot.y );
        WRITE_COORD( vecSpot.z );

        // size
        WRITE_COORD( pev->size.x);
        WRITE_COORD( pev->size.y);
        WRITE_COORD( pev->size.z);

        // velocity
        WRITE_COORD( vecVelocity.x ); 
        WRITE_COORD( vecVelocity.y );
        WRITE_COORD( vecVelocity.z );

        // randomization
        WRITE_BYTE( 10 ); 

        // Model
        WRITE_SHORT( m_idShard );    //model id#

        // # of shards
        WRITE_BYTE( 0 );    // let client decide

        // duration
        WRITE_BYTE( 25 );// 2.5 seconds

        // flags
        WRITE_BYTE( cFlag );
    MESSAGE_END();

    float size = pev->size.x;
    if ( size < pev->size.y )
        size = pev->size.y;
    if ( size < pev->size.z )
        size = pev->size.z;

    // !!! HACK  This should work!
    // Build a box above the entity that looks like an 8 pixel high sheet
    Vector mins = pev->absmin;
    Vector maxs = pev->absmax;
    mins.z = pev->absmax.z;
    maxs.z += 8;

    // BUGBUG -- can only find 256 entities on a breakable -- should be enough
    CBaseEntity *pList[256];
    int count = UTIL_EntitiesInBox( pList, 256, mins, maxs, FL_ONGROUND );
    if ( count )
    {
        for ( int i = 0; i < count; i++ )
        {
            ClearBits( pList[i]->pev->flags, FL_ONGROUND );
            pList[i]->pev->groundentity = NULL;
        }
    }

    // Don't fire something that could fire myself
    pev->targetname = 0;

    pev->solid = SOLID_NOT;
    // Fire targets on break
    SUB_UseTargets( NULL, USE_TOGGLE, 0 );

    SetThink( SUB_Remove );
    pev->nextthink = pev->ltime + 0.1;
    if ( m_iszSpawnObject )
        CBaseEntity::Create( (char *)STRING(m_iszSpawnObject), VecBModelOrigin(pev), pev->angles, edict() );


    if ( Explodable() )
    {
        ExplosionCreate( Center(), pev->angles, edict(), ExplosionMagnitude(), TRUE );
    }
} 


It's pretty clear towards the end of the function that SUB_Remove is called which will call ENTITY_REMOVE:

SUB_Remove( void )

PHP Code:

// Convenient way to delay removing oneself
void CBaseEntity :: SUB_Remove( void )
{
    UpdateOnRemove();
    if (pev->health > 0)
    {
        // this situation can screw up monsters who can't tell their entity pointers are invalid.
        pev->health = 0;
        ALERT( at_aiconsole, "SUB_Remove called on entity with health > 0\n");
    }

    REMOVE_ENTITY(ENT(pev));
} 


However it doesn't seem like ENTITY_REMOVE is called when Im hooking it and destroying the breakable.