[dj_freeze]

Is this thing working?

PHP Code:

#include <amxmodx> 
#include <fakemeta> 
#include <engine> 
#include <cstrike> 

enum EntityPart 
{ 
    Body, 
    Weapon 
} 

new EntitiesOwner 

new CsInternalModel:InternalModelChangeTable[CsInternalModel] =  
{ 
    _:CS_DONTCHANGE,  
    _:CS_T_ARCTIC,//CS_CT_URBAN 
    _:CS_CT_GSG9,//CS_T_TERROR 
    _:CS_CT_GIGN,//CS_T_LEET 
    _:CS_CT_URBAN,//CS_T_ARCTIC 
    _:CS_T_TERROR,//CS_CT_GSG9 
    _:CS_T_LEET,//CS_CT_GIGN 
    _:CS_T_GUERILLA,//CS_CT_SAS 
    _:CS_CT_SAS,//CS_T_GUERILLA 
    _:CS_CT_VIP,  
    _:CZ_CT_SPETSNAZ,//CZ_T_MILITIA 
    _:CZ_T_MILITIA,//CZ_CT_SPETSNAZ 
} 

new CsTeams:InternalModelChangeTableTeam[CsInternalModel] =  
{ 
    _:CS_TEAM_UNASSIGNED,  
    _:CS_TEAM_CT,//CS_CT_URBAN 
    _:CS_TEAM_T,//CS_T_TERROR 
    _:CS_TEAM_T,//CS_T_LEET 
    _:CS_TEAM_T,//CS_T_ARCTIC 
    _:CS_TEAM_CT,//CS_CT_GSG9 
    _:CS_TEAM_CT,//CS_CT_GIGN 
    _:CS_TEAM_CT,//CS_CT_SAS 
    _:CS_TEAM_T,//CS_T_GUERILLA 
    _:CS_TEAM_CT,  
    _:CS_TEAM_T,//CZ_T_MILITIA 
    _:CS_TEAM_CT,//CZ_CT_SPETSNAZ 
} 

new CsInternalModel:TeamsDefaultInternalModel[CsTeams] = 
{ 
    0, 
    _:CS_T_GUERILLA, 
    _:CS_CT_SAS, 
    0 
} 

new InternalModelModels[CsInternalModel][] =  
{ 
    "", 
    "urban", 
    "terror", 
    "leet", 
    "arctic", 
    "gsg9", 
    "gign", 
    "sas", 
    "guerilla", 
    "vip", 
    "militia", 
    "spetsnaz" 
} 

new InternalModelModelIDs[CsInternalModel]  

const OffsetInternalModel = 126 

new Trie:ModelToCsInternalModel 

new CsTeams:TeamsSum = CS_TEAM_T + CS_TEAM_CT 

public plugin_precache() 
{ 
    ModelToCsInternalModel = TrieCreate() 
     
    new model[50] 
     
    for(new CsInternalModel:i = CS_CT_URBAN;i<CsInternalModel;i++) 
    { 
        format(model,charsmax(model),"models/player/%s/%s.mdl",InternalModelModels[i],InternalModelModels[i]) 
         
        TrieSetCell(ModelToCsInternalModel,model,i) 
    } 
     
    register_forward(FM_PrecacheModel,"PrecacheModel",1) 
} 

public client_connect(id) 
{ 
    client_cmd(id,"mp_playerid 2") 
} 

public client_disconnect(id) 
{ 
    client_cmd(id,"mp_playerid 0") 
} 

public PrecacheModel(model[]) 
{ 
    static CsInternalModel:internalModel  
     
    if(TrieGetCell(ModelToCsInternalModel,model,internalModel)) 
    { 
        InternalModelModelIDs[internalModel] = get_orig_retval() 
    } 
} 

public plugin_init() 
{ 
    register_plugin("CSDM All as Enemy", "0.1", "joaquimandrade"); 
    register_forward(FM_AddToFullPack,"AddToFullPackPre",0); 
    register_forward(FM_AddToFullPack,"AddToFullPackPost",1); 
     
    set_msg_block(get_user_msgid("ClCorpse"), BLOCK_SET) 
} 

public plugin_cfg() 
{ 
    EntitiesOwner = create_entity("info_target") 
     
    for(new EntityPart:i=Body;i<EntityPart;i++) 
    { 
        for(new j=1;j<=get_maxplayers();j++) 
        { 
            new ent = create_entity("info_target") 
             
            set_pev(ent,pev_owner,EntitiesOwner) 
            set_pev(ent,pev_aiment,j) 
            set_pev(ent,pev_movetype,MOVETYPE_FOLLOW) 
            set_pev(ent,pev_solid,SOLID_NOT) 
             
            entity_set_model(ent,"models/player/leet/leet.mdl"); 
                                 
            set_pev(ent,pev_iuser1,_:i) 
        } 
    } 
} 

public AddToFullPackPre(es,e,ent,host,hostflags,player,pSet) 
{ 
    if(!player) 
    { 
        if(is_valid_ent(ent) && (pev(ent,pev_owner) == EntitiesOwner)) 
        { 
            new aiment = pev(ent,pev_aiment) 
             
            if((aiment == host) || !is_user_connected(aiment) || (pev(aiment,pev_effects) & EF_NODRAW) || (cs_get_user_team(host) != cs_get_user_team(aiment)) ) 
            { 
                forward_return(FMV_CELL,0) 
                return FMRES_SUPERCEDE 
            } 
        } 
    } 
     
    return FMRES_IGNORED 
} 
public AddToFullPackPost(es,e,ent,host,hostflags,player,pSet) 
{ 
    if(!player && get_orig_retval()) 
    { 
        if(is_valid_ent(ent) && (pev(ent,pev_owner) == EntitiesOwner)) 
        { 
            new aiment = pev(ent,pev_aiment) 
             
            if(pev(ent,pev_iuser1) == _:Weapon) 
            { 
                static weaponModel[50] 
                pev(aiment,pev_weaponmodel2,weaponModel,charsmax(weaponModel)) 
             
                if(weaponModel[0]) 
                { 
                    set_es(es,ES_ModelIndex,engfunc(EngFunc_ModelIndex,weaponModel)) 
                    set_es(es,ES_Sequence,pev(aiment,pev_weaponanim)) 
                } 
                else 
                { 
                    set_es(es,ES_Effects,EF_NODRAW) 
                }         
            } 
            else 
            { 
                new CsTeams:wantedTeam = TeamsSum - cs_get_user_team(host) 
                 
                new CsInternalModel:internalModel = CsInternalModel:get_pdata_int(aiment,OffsetInternalModel) 
                 
                if(internalModel) 
                { 
                    internalModel = InternalModelChangeTable[internalModel] 
                     
                    if(InternalModelChangeTableTeam[internalModel] != wantedTeam) 
                    { 
                        internalModel = TeamsDefaultInternalModel[wantedTeam] 
                    } 
                } 
                else 
                { 
                    internalModel = TeamsDefaultInternalModel[wantedTeam] 
                } 
                 
                set_es(es,ES_ModelIndex,InternalModelModelIDs[internalModel]) 
            } 
        } 
    } 
    else if(is_user_connected(ent) && (ent != host) && (cs_get_user_team(host) == cs_get_user_team(ent))) 
    { 
        set_es(es,ES_RenderMode,kRenderTransAlpha) 
        set_es(es,ES_RenderAmt,0) 
    } 
} 


I need a plugin that will make this:

When FFA is ON player must see all as enemy models.
When you are a CT you will see all dressed as Leet model
When you are a T you will see all dressed as Gign model