AMXX.pl: Support AMX Mod X i SourceMod

int AddToFullPack( struct entity_state_s *state, int e, edict_t *ent, edict_t *host, int hostflags, int player, unsigned char *pSet ) 
{ 
    int                    i; 

    // don't send if flagged for NODRAW and it's not the host getting the message 
    if ( ( ent->v.effects == EF_NODRAW ) && 
         ( ent != host ) ) 
        return 0; 

    // Ignore ents without valid / visible models 
    if ( !ent->v.modelindex || !STRING( ent->v.model ) ) 
        return 0; 

    // Don't send spectators to other players 
    if ( ( ent->v.flags & FL_SPECTATOR ) && ( ent != host ) ) 
    { 
        return 0; 
    } 

    // Ignore if not the host and not touching a PVS/PAS leaf 
    // If pSet is NULL, then the test will always succeed and the entity will be added to the update 
    if ( ent != host ) 
    { 
        if ( !ENGINE_CHECK_VISIBILITY( (const struct edict_s *)ent, pSet ) ) 
        { 
            return 0; 
        } 
    } 


    // Don't send entity to local client if the client says it's predicting the entity itself. 
    if ( ent->v.flags & FL_SKIPLOCALHOST ) 
    { 
        if ( ( hostflags & 1 ) && ( ent->v.owner == host ) ) 
            return 0; 
    } 

    if ( host->v.groupinfo ) 
    { 
        UTIL_SetGroupTrace( host->v.groupinfo, GROUP_OP_AND ); 

        // Should always be set, of course 
        if ( ent->v.groupinfo ) 
        { 
            if ( g_groupop == GROUP_OP_AND ) 
            { 
                if ( !(ent->v.groupinfo & host->v.groupinfo ) ) 
                    return 0; 
            } 
            else if ( g_groupop == GROUP_OP_NAND ) 
            { 
                if ( ent->v.groupinfo & host->v.groupinfo ) 
                    return 0; 
            } 
        } 

        UTIL_UnsetGroupTrace(); 
    } 

    memset( state, 0, sizeof( *state ) ); 

    // Assign index so we can track this entity from frame to frame and 
    //  delta from it. 
    state->number      = e; 
    state->entityType = ENTITY_NORMAL; 

    // Flag custom entities. 
    if ( ent->v.flags & FL_CUSTOMENTITY ) 
    { 
        state->entityType = ENTITY_BEAM; 
    } 

    //  
    // Copy state data 
    // 

    // Round animtime to nearest millisecond 
    state->animtime   = (int)(1000.0 * ent->v.animtime ) / 1000.0; 

    memcpy( state->origin, ent->v.origin, 3 * sizeof( float ) ); 
    memcpy( state->angles, ent->v.angles, 3 * sizeof( float ) ); 
    memcpy( state->mins, ent->v.mins, 3 * sizeof( float ) ); 
    memcpy( state->maxs, ent->v.maxs, 3 * sizeof( float ) ); 

    memcpy( state->startpos, ent->v.startpos, 3 * sizeof( float ) ); 
    memcpy( state->endpos, ent->v.endpos, 3 * sizeof( float ) ); 

    state->impacttime = ent->v.impacttime; 
    state->starttime = ent->v.starttime; 

    state->modelindex = ent->v.modelindex; 

    state->frame      = ent->v.frame; 

    state->skin       = ent->v.skin; 
    state->effects    = ent->v.effects; 

    // This non-player entity is being moved by the game .dll and not the physics simulation system 
    //  make sure that we interpolate it's position on the client if it moves 
    if ( !player && 
         ent->v.animtime && 
         ent->v.velocity[ 0 ] == 0 &&  
         ent->v.velocity[ 1 ] == 0 &&  
         ent->v.velocity[ 2 ] == 0 ) 
    { 
        state->eflags |= EFLAG_SLERP; 
    } 

    state->scale      = ent->v.scale; 
    state->solid      = ent->v.solid; 
    state->colormap   = ent->v.colormap; 

    state->movetype   = ent->v.movetype; 
    state->sequence   = ent->v.sequence; 
    state->framerate  = ent->v.framerate; 
    state->body       = ent->v.body; 

    for (i = 0; i < 4; i++) 
    { 
        state->controller[i] = ent->v.controller[i]; 
    } 

    for (i = 0; i < 2; i++) 
    { 
        state->blending[i]   = ent->v.blending[i]; 
    } 

    state->rendermode    = ent->v.rendermode; 
    state->renderamt     = ent->v.renderamt;  
    state->renderfx      = ent->v.renderfx; 
    state->rendercolor.r = ent->v.rendercolor.x; 
    state->rendercolor.g = ent->v.rendercolor.y; 
    state->rendercolor.b = ent->v.rendercolor.z; 

    state->aiment = 0; 
    if ( ent->v.aiment ) 
    { 
        state->aiment = ENTINDEX( ent->v.aiment ); 
    } 

    state->owner = 0; 
    if ( ent->v.owner ) 
    { 
        int owner = ENTINDEX( ent->v.owner ); 

        // Only care if owned by a player 
        if ( owner >= 1 && owner <= gpGlobals->maxClients ) 
        { 
            state->owner = owner;     
        } 
    } 

    // HACK:  Somewhat... 
    // Class is overridden for non-players to signify a breakable glass object ( sort of a class? ) 
    if ( !player ) 
    { 
        state->playerclass  = ent->v.playerclass; 
    } 

    // Special stuff for players only 
    if ( player ) 
    { 
        memcpy( state->basevelocity, ent->v.basevelocity, 3 * sizeof( float ) ); 

        state->weaponmodel  = MODEL_INDEX( STRING( ent->v.weaponmodel ) ); 
        state->gaitsequence = ent->v.gaitsequence; 
        state->spectator = ent->v.flags & FL_SPECTATOR; 
        state->friction     = ent->v.friction; 

        state->gravity      = ent->v.gravity; 
//        state->team            = ent->v.team; 
//         
        state->usehull      = ( ent->v.flags & FL_DUCKING ) ? 1 : 0; 
        state->health        = ent->v.health; 
    } 

    return 1; 
}