AlliedModders

AlliedModders (https://forums.alliedmods.net/index.php)
-   Scripting Help (https://forums.alliedmods.net/forumdisplay.php?f=11)
-   -   Solved get_pcvar_string error weapon_modifier.amxx (https://forums.alliedmods.net/showthread.php?t=314218)

RojedaFeik 02-08-2019 19:29
get_pcvar_string error weapon_modifier.amxx
 
Hi, I hope you are well, I have downloaded this plugin https://forums.alliedmods.net/showthread.php?t=165075 it compiles well, but this error appears in console with the active debug. Can you help me?

Code:
L 02/08/2019 - 12:44:33: [AMXX]    [0] weapon_modifier.sma::event_AmmoX (line 266)
L 02/08/2019 - 12:44:33: Invalid CVAR pointer
L 02/08/2019 - 12:44:33: [AMXX] Displaying debug trace (plugin "weapon_modifier.amxx")
L 02/08/2019 - 12:44:33: [AMXX] Run time error 10: native error (native "get_pcvar_string")
Here is the code too

PHP Code:
#include <amxmodx>
#include <amxmisc>
#include <engine>
#include <cstrike>
#include <fakemeta_util>
#include <hamsandwich>

#define CSW_THIGHPACK     0
#define CSW_SHIELD        2
#define CSW_BACKPACK    32

// Offsets
const OFFSET_USE_STOPPED             = 0;
const OFFSET_PDATA                    = 2;
const OFFSET_LINUX_WEAPONS             = 4;
const OFFSET_LINUX                     = 5;
const OFFSET_WEAPON_OWNER            = 41;
const OFFSET_ID                        = 43;
const OFFSET_NEXT_PRIMARY_ATTACK    = 46;
const OFFSET_NEXT_SECONDARY_ATTACK     = 47;
const OFFSET_TIME_WEAPON_IDLE         = 48;
const OFFSET_IN_RELOAD                 = 54;
const OFFSET_IN_SPECIAL_RELOAD         = 55;
const OFFSET_NEXT_ATTACK            = 83;
const OFFSET_FOV                    = 363;
const OFFSET_ACTIVE_ITEM             = 373;

new const g_customization_file_cfg[] = "weapon_modifier.cfg"
new const g_customization_file_ini[] = "weapon_modifier.ini"

new const g_weapon_ent_names[][] = {"", "weapon_p228", "", "weapon_scout", "", "weapon_xm1014", "", "weapon_mac10",
"weapon_aug", "", "weapon_elite", "weapon_fiveseven", "weapon_ump45", "weapon_sg550", "weapon_galil", "weapon_famas", "weapon_usp", "weapon_glock18",
"weapon_awp", "weapon_mp5navy", "weapon_m249", "weapon_m3", "weapon_m4a1", "weapon_tmp", "weapon_g3sg1", "", "weapon_deagle", "weapon_sg552",
"weapon_ak47", "weapon_knife", "weapon_p90", "all"};

new const g_weapon_ent_names_all[][] = {"weapon_thighpack", "weapon_p228", "weapon_shield", "weapon_scout", "weapon_hegrenade", "weapon_xm1014", "weapon_c4",
"weapon_mac10", "weapon_aug", "weapon_smokegrenade", "weapon_elite", "weapon_fiveseven", "weapon_ump45", "weapon_sg550", "weapon_galil", "weapon_famas", "weapon_usp",
"weapon_glock18", "weapon_awp", "weapon_mp5navy", "weapon_m249", "weapon_m3", "weapon_m4a1", "weapon_tmp", "weapon_g3sg1", "weapon_flashbang", "weapon_deagle",
"weapon_sg552", "weapon_ak47", "weapon_knife", "weapon_p90", "w_backpack"};

new const g_model_default[][] = {"models/w_thighpack.mdl", "models/w_p228.mdl", "models/w_shield.mdl", "models/w_scout.mdl", "models/w_hegrenade.mdl",
"models/w_xm1014.mdl", "models/w_c4.mdl", "models/w_mac10.mdl", "models/w_aug.mdl", "models/w_smokegrenade.mdl", "models/w_elite.mdl", "models/w_fiveseven.mdl",
"models/w_ump45.mdl", "models/w_sg550.mdl", "models/w_galil.mdl", "models/w_famas.mdl", "models/w_usp.mdl", "models/w_glock18.mdl", "models/w_awp.mdl",
"models/w_mp5.mdl", "models/w_m249.mdl", "models/w_m3.mdl", "models/w_m4a1.mdl", "models/w_tmp.mdl", "models/w_g3sg1.mdl", "models/w_flashbang.mdl",
"models/w_deagle.mdl", "models/w_sg552.mdl", "models/w_ak47.mdl", "models/w_knife.mdl", "models/w_p90.mdl", "models/w_backpack.mdl"};

new const g_max_bpammo[] = {-1, 52, -1, 90, 1, 32, 1, 100, 90, 1, 120, 100, 100, 90, 90, 90, 100, 120, 30, 120, 200, 32, 90, 120, 90, 2, 35, 90, 90, -1, 100};
new const g_max_clip[] = {-1, 13, -1, 10, -1, 7, -1, 30, 30, -1, 30, 20, 25, 30, 35, 25, 12, 20, 10, 30, 100, 8, 30, 30, 20, -1, 7, 30, 30, -1, 50};
new const g_ammo_type[][] = {"", "357sig", "", "762nato", "", "buckshot", "", "45acp", "556nato", "", "9mm", "57mm", "45acp", "556nato", "556nato", "556nato", "45acp",
"9mm", "338magnum", "9mm", "556natobox", "buckshot", "556nato", "9mm", "762nato", "", "50ae", "556nato", "762nato", "", "57mm"};
new const g_ammo_weapon[] = {0, CSW_AWP, CSW_SCOUT, CSW_M249, CSW_AUG, CSW_XM1014, CSW_MAC10, CSW_FIVESEVEN, CSW_DEAGLE, CSW_P228, CSW_ELITE, CSW_FLASHBANG,
CSW_HEGRENADE, CSW_SMOKEGRENADE, CSW_C4};
new const SECONDARY_WEAPONS_BIT_SUM = (1 << CSW_P228)|(1 << CSW_ELITE)|(1 << CSW_FIVESEVEN)|(1 << CSW_USP)|(1 << CSW_GLOCK18)|(1 << CSW_DEAGLE)
new const SHOTGUN_WEAPONS_BIT_SUM = (1 << CSW_M3)|(1 << CSW_XM1014)
new const ALREADY_SECONDARY_ATTACK = (1 << CSW_KNIFE)|(1 << CSW_USP)|(1 << CSW_GLOCK18)|(1 << CSW_FAMAS)|(1 << CSW_M4A1)

new const g_sound_knife_default[][] = {
    "weapons/knife_deploy1.wav",
    "weapons/knife_hit1.wav",
    "weapons/knife_hit2.wav",
    "weapons/knife_hit3.wav",
    "weapons/knife_hit4.wav",
    "weapons/knife_hitwall1.wav",
    "weapons/knife_slash1.wav",
    "weapons/knife_slash2.wav",
    "weapons/knife_stab.wav"
};

enum()
{
    WEAPON_DAMAGE = 0,
    WEAPON_RECOIL,
    WEAPON_SPEED,
    WEAPON_W_GLOW,
    WEAPON_P_GLOW,
    WEAPON_UNLIMITED_CLIP,
    WEAPON_UNLIMITED_BPAMMO,
    WEAPON_KNOCKBACK,
    WEAPON_AUTO_FIRE,
    WEAPON_ZOOM,

    MAX_WM
};
new g_cvar_weapon[CSW_P90+3][MAX_WM];
new g_cvar_knockback;
new g_cvar_knockback_zvel;
new g_cvar_knockback_dist;
new g_pcvar_ff;

enum()
{
    V_ = 0,
    P_,
    W_,
    
    ALL_MODELS
};
new g_model_weapon[ALL_MODELS][CSW_P90+2][128];
new g_sound_weapon[sizeof(g_sound_knife_default)][128];

new g_ent_weaponmodel[33];
new g_has_ammo[33];
new g_weapon[33];

new Trie:g_trie_wmodel;

new g_msg_curweapon;
new g_msg_ammopickup;

new g_maxplayers;

#define is_user_valid_connected(%1)    (1 <= %1 <= g_maxplayers && is_user_connected(%1))
public plugin_precache()
{
    fn_load_customization();
}
public plugin_init()
{
    new plugin_name[] = "Weapon Modifier";
    new plugin_version[] = "v1.56";
    new plugin_author[] = "Kiske";
    
    new i;
    new j;
    new buffer[64];
    
    new wm_cvars[][] = {"damage", "recoil", "speed", "wglow", "pglow", "unclip", "unbpammo", "kb", "autofire", "zoom"};
    
    register_plugin(plugin_name, plugin_version, plugin_author);
    
    register_event("AmmoX", "event_AmmoX", "be");
    
    RegisterHam(Ham_TakeDamage, "player", "fw_TakeDamage");
    RegisterHam(Ham_Killed, "player", "fw_PlayerKilled");
    RegisterHam(Ham_TraceAttack, "player", "fw_TraceAttack");
    RegisterHam(Ham_AddPlayerItem, "player", "fw_AddPlayerItem");
    RegisterHam(Ham_Use, "func_tank", "fw_UseStationary_Post", 1);
    RegisterHam(Ham_Use, "func_tankmortar", "fw_UseStationary_Post", 1);
    RegisterHam(Ham_Use, "func_tankrocket", "fw_UseStationary_Post", 1);
    RegisterHam(Ham_Use, "func_tanklaser", "fw_UseStationary_Post", 1);
    
    // Register CVARS
    for(i = 0; i < CSW_P90+2; i++)
    {
        // Get Weapon and Change Models
        if(i != 0 && i != 2 && i != 31) // weapon_thighpack(0) , weapon_shield (2) and w_backpack(31)
            RegisterHam(Ham_Item_Deploy, g_weapon_ent_names_all[i], "fw_Item_Deploy_Post", 1);
        
        if(g_weapon_ent_names[i][0])
        {
            // Recoil , Speed , Auto Fire Pistol and Zoom
            if(i != 31) // all is 31
            {
                RegisterHam(Ham_Weapon_PrimaryAttack, g_weapon_ent_names[i], "fw_Weapon_PrimaryAttack_Post", 1); // Recoil , Speed and Auto Fire Pistol
                
                // Zoom
                if(!((1 << i) & ALREADY_SECONDARY_ATTACK))
                {
                    RegisterHam(Ham_Item_PostFrame, g_weapon_ent_names[i], "fw_Item_PostFrame");
                    RegisterHam(Ham_Item_Holster, g_weapon_ent_names[i], "fw_Item_Holster");
                    RegisterHam(Ham_CS_Item_GetMaxSpeed, g_weapon_ent_names[i], "fw_CS_Item_GetMaxSpeed");
                    RegisterHam(Ham_Weapon_Reload, g_weapon_ent_names[i], ((1 << i) & SHOTGUN_WEAPONS_BIT_SUM) ? "fw_Weapon_Shotgun_Reload_Post" : "fw_Weapon_Reload_Post", 1);
                }
            }
            
            // Remove weapon_ from the names
            replace(g_weapon_ent_names[i], 17, "weapon_", "");
            
            for(j = 0; j < MAX_WM; j++)
            {
                formatex(buffer, charsmax(buffer), "wm_%s_%s", wm_cvars[j], g_weapon_ent_names[i]);
                
                switch(j)
                {
                    case WEAPON_KNOCKBACK: g_cvar_weapon[i][j] = register_cvar(buffer, "0.00");
                    case WEAPON_AUTO_FIRE:
                    {
                        if(i == 31) // all is 31
                        {
                            g_cvar_weapon[i][j] = register_cvar(buffer, "0");
                            continue;
                        }
                        
                        if((1 << i) & SECONDARY_WEAPONS_BIT_SUM)
                            g_cvar_weapon[i][j] = register_cvar(buffer, "0");
                    }
                    case WEAPON_ZOOM:
                    {
                        if(!((1 << i) & ALREADY_SECONDARY_ATTACK))
                            g_cvar_weapon[i][j] = register_cvar(buffer, "off");
                    }
                    default: g_cvar_weapon[i][j] = register_cvar(buffer, "off");
                }
            }
        }
    }
    
    // Extra Cvars for W_ models glow :)
    g_cvar_weapon[CSW_THIGHPACK][WEAPON_W_GLOW] = register_cvar("wm_wglow_thighpack", "off");
    g_cvar_weapon[CSW_SHIELD][WEAPON_W_GLOW] = register_cvar("wm_wglow_shield", "off");
    g_cvar_weapon[CSW_HEGRENADE][WEAPON_W_GLOW] = register_cvar("wm_wglow_hegrenade", "off");
    g_cvar_weapon[CSW_C4][WEAPON_W_GLOW] = register_cvar("wm_wglow_c4", "off");
    g_cvar_weapon[CSW_SMOKEGRENADE][WEAPON_W_GLOW] = register_cvar("wm_wglow_smokegrenade", "off");
    g_cvar_weapon[CSW_FLASHBANG][WEAPON_W_GLOW] = register_cvar("wm_wglow_flashbang", "off");
    g_cvar_weapon[CSW_BACKPACK][WEAPON_W_GLOW] = register_cvar("wm_wglow_backpack", "off");
    
    // Extra Cvars for P_ models glow :)
    g_cvar_weapon[CSW_HEGRENADE][WEAPON_P_GLOW] = register_cvar("wm_pglow_hegrenade", "off");
    g_cvar_weapon[CSW_C4][WEAPON_P_GLOW] = register_cvar("wm_pglow_c4", "off");
    g_cvar_weapon[CSW_SMOKEGRENADE][WEAPON_P_GLOW] = register_cvar("wm_pglow_smokegrenade", "off");
    g_cvar_weapon[CSW_FLASHBANG][WEAPON_P_GLOW] = register_cvar("wm_pglow_flashbang", "off");
    
    // Cvars for knockback
    g_cvar_knockback = register_cvar("wm_knockback", "0");
    g_cvar_knockback_zvel = register_cvar("wm_kb_zvel", "1");
    g_cvar_knockback_dist = register_cvar("wm_kb_dist", "500");
    g_pcvar_ff = get_cvar_pointer("mp_friendlyfire");
    
    new wmodels[][] = {"models/w_shield.mdl", "models/w_thighpack.mdl", "models/w_c4.mdl", "models/w_backpack.mdl"};
    
    g_trie_wmodel = TrieCreate();
    
    for(i = 0; i < sizeof(wmodels); i++)
        TrieSetCell(g_trie_wmodel, wmodels[i], 1);
    
    register_forward(FM_SetModel, "fw_SetModel");
    register_forward(FM_EmitSound, "fw_EmitSound");
    register_forward(FM_CmdStart, "fw_CmdStart");
    
    g_msg_curweapon = get_user_msgid("CurWeapon");
    g_msg_ammopickup = get_user_msgid("AmmoPickup");
    
    register_message(g_msg_curweapon, "message_CurWeapon");
    
    g_maxplayers = get_maxplayers();
}

public plugin_cfg()
{
    new cfgdir[32];
    get_configsdir(cfgdir, charsmax(cfgdir));
    
    server_cmd("exec %s/%s", cfgdir, g_customization_file_cfg);
}

public plugin_end()
{
    TrieDestroy(g_trie_wmodel);
}

public client_disconnect(id)
{
    g_has_ammo[id] = 0;
    
    fm_remove_model_ents(id);
}

public event_AmmoX(id)
{
    static bpammo_cvar[10];
    static bpammo_cvar_temp[10];
    static bpammo_cvar_int;
    static mode;
    mode = 0;
    
    get_pcvar_string(g_cvar_weapon[g_weapon[id]][WEAPON_UNLIMITED_BPAMMO], bpammo_cvar, charsmax(bpammo_cvar));
    get_pcvar_string(g_cvar_weapon[31][WEAPON_UNLIMITED_BPAMMO], bpammo_cvar_temp, charsmax(bpammo_cvar_temp));
    
    bpammo_cvar_int = str_to_num(bpammo_cvar);
    
    if(!equali(bpammo_cvar_temp, "off") || bpammo_cvar_int)
        mode = 1;
    
    if(!mode)
        return;
    
    static type;
    type = read_data(1);
    
    if(type >= sizeof(g_ammo_weapon))
        return;
    
    static weapon;
    weapon = g_ammo_weapon[type];
    
    if(g_max_bpammo[weapon] <= 2)
        return;
    
    static amount;
    amount = read_data(2);
    
    if(amount < g_max_bpammo[weapon])
    {
        // The BP Ammo refill code causes the engine to send a message, but we
        // can't have that in this forward or we risk getting some recursion bugs.
        // For more info see: https://bugs.alliedmods.net/show_bug.cgi?id=3664
        
        static args[1];
        args[0] = weapon;
        
        set_task(0.1, "fn_refill_bpammo", id, args, sizeof(args));
    }
}

public fw_TakeDamage(victim, inflictor, attacker, Float:damage, damage_type)
{
    if(victim == attacker || !is_user_valid_connected(attacker))
        return HAM_IGNORED;
    
    static dmg_cvar[10];
    static dmg_cvar_k[10];
    static dmg_cvar_temp[10];
    static dmg_cvar_temp_k[10];
    
    get_pcvar_string(g_cvar_weapon[g_weapon[attacker]][WEAPON_DAMAGE], dmg_cvar, charsmax(dmg_cvar));
    get_pcvar_string(g_cvar_weapon[31][WEAPON_DAMAGE], dmg_cvar_temp, charsmax(dmg_cvar_temp));
    
    copy(dmg_cvar_k, charsmax(dmg_cvar_k), dmg_cvar);
    copy(dmg_cvar_temp_k, charsmax(dmg_cvar_temp_k), dmg_cvar_temp);
    
    if(fn_contain_words(dmg_cvar_k) || fn_contain_words(dmg_cvar_temp_k))
    {
        fn_replace_words(dmg_cvar_k, charsmax(dmg_cvar_k));
        fn_replace_words(dmg_cvar_temp_k, charsmax(dmg_cvar_temp_k));
        
        static Float:dmg;
        
        if(equali(dmg_cvar_temp, "off")) dmg = str_to_float(dmg_cvar_k);
        else dmg = str_to_float(dmg_cvar_temp_k);
        
        switch((equali(dmg_cvar_temp, "off")) ? dmg_cvar[0] : dmg_cvar_temp[0])
        {
            case '+':
            {
                if(dmg < 1.00) return HAM_IGNORED;
                damage += dmg;
            }
            case '-':
            {
                if(dmg < 1.00) return HAM_IGNORED;
                damage -= dmg;
            }
            case '*':
            {
                if(dmg == 1.00) return HAM_IGNORED;
                damage *= dmg;
            }
            case '/':
            {
                if(dmg == 0.00) return HAM_IGNORED; // Can't divide by 0
                damage /= dmg;
            }
            case '=':
            {
                if(dmg < 1.00) return HAM_IGNORED;
                damage = dmg;
            }
        }
        
        SetHamParamFloat(4, damage);
    }
    
    return HAM_IGNORED;
}

public fw_PlayerKilled(victim, attacker, shouldgib)
{
    fm_remove_model_ents(victim);
}

public fw_TraceAttack(victim, attacker, Float:damage, Float:direction[3], trace_handle, damage_type)
{
    if(victim == attacker || !is_user_valid_connected(attacker))
        return HAM_IGNORED;
    
    if(!get_pcvar_num(g_cvar_knockback))
        return HAM_IGNORED;
    
    if(!(damage_type & DMG_BULLET))
        return HAM_IGNORED;
    
    if(!get_pcvar_num(g_pcvar_ff) && (cs_get_user_team(attacker) == cs_get_user_team(victim)))
        return HAM_IGNORED;
    
    static kb_duck;
    static origin1[3];
    static origin2[3];
    
    kb_duck = entity_get_int(victim, EV_INT_flags) & (FL_DUCKING | FL_ONGROUND) == (FL_DUCKING | FL_ONGROUND);
    
    get_user_origin(victim, origin1);
    get_user_origin(attacker, origin2);
    
    if(get_distance(origin1, origin2) > get_pcvar_num(g_cvar_knockback_dist))
        return HAM_IGNORED;
    
    static Float:velocity[3];
    entity_get_vector(victim, EV_VEC_velocity, velocity);
    
    xs_vec_mul_scalar(direction, damage, direction);
    
    static Float:kb_cvar;
    
    if(get_pcvar_float(g_cvar_weapon[31][WEAPON_KNOCKBACK]) == 0.00) kb_cvar = get_pcvar_float(g_cvar_weapon[g_weapon[attacker]][WEAPON_KNOCKBACK]);
    else kb_cvar = get_pcvar_float(g_cvar_weapon[31][WEAPON_KNOCKBACK]);
    
    if(kb_cvar > 0.00)
        xs_vec_mul_scalar(direction, kb_cvar, direction);
    
    if(kb_duck)
        xs_vec_mul_scalar(direction, 0.2, direction);
    
    xs_vec_add(velocity, direction, direction);
    
    if(!get_pcvar_num(g_cvar_knockback_zvel))
        direction[2] = velocity[2];
    
    entity_set_vector(victim, EV_VEC_velocity, direction);
    
    return HAM_IGNORED;
}

public fw_AddPlayerItem(id, weapon_ent)
{
    static extra_ammo;
    extra_ammo = entity_get_int(weapon_ent, EV_INT_iuser1);
    
    if(extra_ammo)
    {
        static weaponid;
        weaponid = cs_get_weapon_id(weapon_ent);
        
        ExecuteHamB(Ham_GiveAmmo, id, extra_ammo, g_ammo_type[weaponid], g_max_bpammo[weaponid]);
        entity_set_int(weapon_ent, EV_INT_iuser1, 0);
    }
}

public fw_UseStationary_Post(entity, caller, activator, use_type)
{
    if(use_type == OFFSET_USE_STOPPED && is_user_valid_connected(caller))
    {
        fm_remove_model_ents(caller);
        fn_replace_weapon_models(caller, g_weapon[caller]);
    }
}

public fw_Item_Deploy_Post(weapon_ent)
{
    if(!pev_valid(weapon_ent))
        return;
    
    static id;
    id = fm_get_weapon_ent_owner(weapon_ent);
    
    if(!pev_valid(id))
        return;
    
    fm_remove_model_ents(id);
    
    static weaponid;
    weaponid = cs_get_weapon_id(weapon_ent);
    
    if(weaponid != CSW_C4 && 
    weaponid != CSW_SHIELD &&
    weaponid != CSW_HEGRENADE &&
    weaponid != CSW_FLASHBANG &&
    weaponid != CSW_SMOKEGRENADE)
        g_weapon[id] = weaponid;
    
    // Replace Weapon Models
    fn_replace_weapon_models(id, weaponid);
}

public fw_Weapon_PrimaryAttack_Post(weapon_ent) // Recoil , Speed and Auto Fire Pistol
{
    if(!pev_valid(weapon_ent))
        return HAM_IGNORED;
    
    static id;
    id = fm_get_weapon_ent_owner(weapon_ent);
    
    if(!pev_valid(id) || cs_get_weapon_ammo(weapon_ent) < 1)
        return HAM_IGNORED;
    
    // Recoil
    static Float:def_recoil[3];
    entity_get_vector(id, EV_VEC_punchangle, def_recoil);
    
    static recoil_cvar[10];
    static recoil_cvar_k[10];
    static recoil_cvar_temp[10];
    static recoil_cvar_temp_k[10];
    
    get_pcvar_string(g_cvar_weapon[g_weapon[id]][WEAPON_RECOIL], recoil_cvar, charsmax(recoil_cvar));
    get_pcvar_string(g_cvar_weapon[31][WEAPON_RECOIL], recoil_cvar_temp, charsmax(recoil_cvar_temp));
    
    copy(recoil_cvar_k, charsmax(recoil_cvar_k), recoil_cvar);
    copy(recoil_cvar_temp_k, charsmax(recoil_cvar_temp_k), recoil_cvar_temp);
    
    if(fn_contain_words(recoil_cvar_k) || fn_contain_words(recoil_cvar_temp_k))
    {
        fn_replace_words(recoil_cvar_k, charsmax(recoil_cvar_k));
        fn_replace_words(recoil_cvar_temp_k, charsmax(recoil_cvar_temp_k));
        
        static Float:recoil;
        
        if(equali(recoil_cvar_temp, "off")) recoil = str_to_float(recoil_cvar_k);
        else recoil = str_to_float(recoil_cvar_temp_k);
        
        switch((equali(recoil_cvar_temp, "off")) ? recoil_cvar[0] : recoil_cvar_temp[0])
        {
            case '+':
            {
                if(recoil == 0.00) return HAM_IGNORED;
                def_recoil[0] += recoil;
            }
            case '-':
            {
                if(recoil == 0.00) return HAM_IGNORED;
                def_recoil[0] -= recoil;
            }
            case '*':
            {
                if(recoil == 1.00) return HAM_IGNORED;
                def_recoil[0] *= recoil;
            }
            case '/':
            {
                if(recoil == 0.00) return HAM_IGNORED; // Can't divide by 0
                def_recoil[0] /= recoil;
            }
            case '=':
            {
                def_recoil[0] = recoil;
                if(recoil == 0)
                    def_recoil[1] = def_recoil[2] = recoil;
            }
        }
        
        entity_set_vector(id, EV_VEC_punchangle, def_recoil);
    }
    
    // Speed
    static Float:def_speed[3];
    def_speed[0] = get_pdata_float(weapon_ent, OFFSET_NEXT_PRIMARY_ATTACK, OFFSET_LINUX_WEAPONS);
    def_speed[1] = get_pdata_float(weapon_ent, OFFSET_NEXT_SECONDARY_ATTACK, OFFSET_LINUX_WEAPONS);
    def_speed[2] = get_pdata_float(weapon_ent, OFFSET_TIME_WEAPON_IDLE, OFFSET_LINUX_WEAPONS);
    
    static speed_cvar[10];
    static speed_cvar_k[10];
    static speed_cvar_temp[10];
    static speed_cvar_temp_k[10];
    
    get_pcvar_string(g_cvar_weapon[g_weapon[id]][WEAPON_SPEED], speed_cvar, charsmax(speed_cvar));
    get_pcvar_string(g_cvar_weapon[31][WEAPON_SPEED], speed_cvar_temp, charsmax(speed_cvar_temp));
    
    copy(speed_cvar_k, charsmax(speed_cvar_k), speed_cvar);
    copy(speed_cvar_temp_k, charsmax(speed_cvar_temp_k), speed_cvar_temp);
    
    if(fn_contain_words(speed_cvar_k) || fn_contain_words(speed_cvar_temp_k))
    {
        fn_replace_words(speed_cvar_k, charsmax(speed_cvar_k));
        fn_replace_words(speed_cvar_temp_k, charsmax(speed_cvar_temp_k));
        
        static Float:speed;
        
        if(equali(speed_cvar_temp, "off")) speed = str_to_float(speed_cvar_k);
        else speed = str_to_float(speed_cvar_temp_k);
        
        switch((equali(speed_cvar_temp, "off")) ? speed_cvar[0] : speed_cvar_temp[0])
        {
            case '+':
            {
                if(speed == 0.00) return HAM_IGNORED;
                def_speed[0] += speed;
                def_speed[1] += speed;
                def_speed[2] += speed;
            }
            case '-':
            {
                if(speed == 0.00) return HAM_IGNORED;
                def_speed[0] -= speed;
                def_speed[1] -= speed;
                def_speed[2] -= speed;
            }
            case '*':
            {
                if(speed == 1.00) return HAM_IGNORED;
                def_speed[0] *= speed;
                def_speed[1] *= speed;
                def_speed[2] *= speed;
            }
            case '/':
            {
                if(speed == 0.00) return HAM_IGNORED; // Can't divide by 0
                def_speed[0] /= speed;
                def_speed[1] /= speed;
                def_speed[2] /= speed;
            }
            case '=': def_speed[0] = def_speed[1] = def_speed[2] = speed;
        }
        
        set_pdata_float(weapon_ent, OFFSET_NEXT_PRIMARY_ATTACK, def_speed[0], OFFSET_LINUX_WEAPONS)
        set_pdata_float(weapon_ent, OFFSET_NEXT_SECONDARY_ATTACK, def_speed[1], OFFSET_LINUX_WEAPONS)
        set_pdata_float(weapon_ent, OFFSET_TIME_WEAPON_IDLE, def_speed[2], OFFSET_LINUX_WEAPONS)
    }
    
    // Auto Fire Pistol
    if((1 << g_weapon[id]) & SECONDARY_WEAPONS_BIT_SUM)
    {
        static autofire_cvar;
        
        if(!get_pcvar_num(g_cvar_weapon[31][WEAPON_AUTO_FIRE])) autofire_cvar = get_pcvar_num(g_cvar_weapon[g_weapon[id]][WEAPON_AUTO_FIRE]);
        else autofire_cvar = 1;
        
        g_has_ammo[id] = autofire_cvar;
    }
    
    return HAM_IGNORED;
}

public fw_Item_PostFrame(weapon_ent)
{
    if(!pev_valid(weapon_ent))
        return HAM_IGNORED;
    
    static id;
    id = fm_get_weapon_ent_owner(weapon_ent);
    
    if(!pev_valid(id))
        return HAM_IGNORED;
    
    static button;
    button = entity_get_int(id, EV_INT_button);
    
    if(button & IN_ATTACK2)
    {
        static zoom_cvar[32];
        static zoom_delay[9];
        static zoom_speed[1]; // not interesting here
        static zoom_1[3];
        static zoom_2[3];
        static Float:f_zoom_delay;
        static i_zoom_1;
        static i_zoom_2;
        
        get_pcvar_string(g_cvar_weapon[31][WEAPON_ZOOM], zoom_cvar, charsmax(zoom_cvar));
        
        if(equali(zoom_cvar, "off"))
        {
            get_pcvar_string(g_cvar_weapon[g_weapon[id]][WEAPON_ZOOM], zoom_cvar, charsmax(zoom_cvar));
        
            if(equali(zoom_cvar, "off"))
                return HAM_IGNORED;
        }
        
        parse(zoom_cvar, zoom_delay, charsmax(zoom_delay), zoom_speed, charsmax(zoom_speed), zoom_1, charsmax(zoom_1), zoom_2, charsmax(zoom_2));
        
        f_zoom_delay = str_to_float(zoom_delay);
        i_zoom_1 = clamp(str_to_num(zoom_1), 0, 255);
        i_zoom_2 = clamp(str_to_num(zoom_2), 0, 255);
        
        static fov;
        fov = get_pdata_int(id, OFFSET_FOV, OFFSET_LINUX);
        
        if(fov == 90) fn_SetFov(id, i_zoom_1);
        else if(fov == i_zoom_1) fn_SetFov(id, i_zoom_2);
        else fn_SetFov(id, 90);
        
        ExecuteHamB(Ham_Item_PreFrame, id);
        
        emit_sound(id, CHAN_ITEM, "weapons/zoom.wav", 0.20, 2.40, 0, 100);
        set_pdata_float(id, OFFSET_NEXT_ATTACK, f_zoom_delay, OFFSET_LINUX);
        
        return HAM_SUPERCEDE;
    }
    
    return HAM_IGNORED;
}

public fw_Item_Holster(weapon_ent)
{
    if(pev_valid(weapon_ent))
    {
        if(ExecuteHamB(Ham_Item_CanHolster, weapon_ent))
            fn_ResetFov(fm_get_weapon_ent_owner(weapon_ent));
    }
}

public fw_CS_Item_GetMaxSpeed(weapon_ent)
{
    if(!pev_valid(weapon_ent))
        return HAM_IGNORED;
    
    static id;
    id = fm_get_weapon_ent_owner(weapon_ent);
    
    if(!pev_valid(id))
        return HAM_IGNORED;
    
    if(get_pdata_int(id, OFFSET_FOV, OFFSET_LINUX) == 90)
        return HAM_IGNORED;
    
    static zoom_cvar[32];
    static zoom_delay[1]; // not interesting here
    static zoom_speed[9];
    static zoom_1[1]; // not interesting here
    static zoom_2[1]; // not interesting here
    static Float:f_zoom_speed;
    
    get_pcvar_string(g_cvar_weapon[31][WEAPON_ZOOM], zoom_cvar, charsmax(zoom_cvar));
    
    if(equali(zoom_cvar, "off"))
    {
        get_pcvar_string(g_cvar_weapon[g_weapon[id]][WEAPON_ZOOM], zoom_cvar, charsmax(zoom_cvar));
    
        if(equali(zoom_cvar, "off"))
            return HAM_IGNORED;
    }
    
    parse(zoom_cvar, zoom_delay, charsmax(zoom_delay), zoom_speed, charsmax(zoom_speed), zoom_1, charsmax(zoom_1), zoom_2, charsmax(zoom_2));
    f_zoom_speed = str_to_float(zoom_speed);

    static Float:f_MaxSpeed;
    f_MaxSpeed = f_zoom_speed;
    
    if(f_MaxSpeed > 0.00)
    {
        SetHamReturnFloat(f_MaxSpeed);
        return HAM_SUPERCEDE;
    }

    return HAM_IGNORED;
}

public fw_Weapon_Reload_Post(weapon_ent)
{
    if(pev_valid(weapon_ent))
    {
        if(get_pdata_int(weapon_ent, OFFSET_IN_RELOAD, OFFSET_LINUX_WEAPONS))
            fn_ResetFov(fm_get_weapon_ent_owner(weapon_ent))
    }
}

public fw_Weapon_Shotgun_Reload_Post(weapon_ent)
{
    if(pev_valid(weapon_ent))
    {
        if(get_pdata_int(weapon_ent, OFFSET_IN_SPECIAL_RELOAD, OFFSET_LINUX_WEAPONS) == 1)
            fn_ResetFov(fm_get_weapon_ent_owner(weapon_ent))
    }
}

fn_SetFov(id, fov)
{
    entity_set_float(id, EV_FL_fov, float(fov));
    set_pdata_int(id, OFFSET_FOV, fov, OFFSET_LINUX);
}

fn_ResetFov(id)
{
    if(0 <= get_pdata_int(id, OFFSET_FOV, OFFSET_LINUX) <= 90)
    {
        entity_set_float(id, EV_FL_fov, 90.0);
        set_pdata_int(id, OFFSET_FOV, 90, OFFSET_LINUX);
    }
}

public fw_SetModel(entity, const model[])
{
    if(strlen(model) < 8 || model[7] != 'w' || model[8] != '_')
        return FMRES_IGNORED;
    
    static classname[10];
    static color_all[21];
    
    entity_get_string(entity, EV_SZ_classname, classname, charsmax(classname));
    get_pcvar_string(g_cvar_weapon[31][WEAPON_W_GLOW], color_all, charsmax(color_all));
    
    if(equal(classname, "weaponbox") ||
    TrieKeyExists(g_trie_wmodel, model))
    {
        static i;
        static color[21];
        static p_rgb[3][4];
        static i_rgb[3];
        
        for(i = 0; i < CSW_P90+2; i++)
        {
            if(equali(model, g_model_default[i]))
            {
                get_pcvar_string(g_cvar_weapon[i][WEAPON_W_GLOW], color, charsmax(color));
                if(!equali(color, "off") || !equali(color_all, "off"))
                {
                    if(equali(color_all, "off")) parse(color, p_rgb[0], charsmax(p_rgb[]), p_rgb[1], charsmax(p_rgb[]), p_rgb[2], charsmax(p_rgb[]));
                    else parse(color_all, p_rgb[0], charsmax(p_rgb[]), p_rgb[1], charsmax(p_rgb[]), p_rgb[2], charsmax(p_rgb[]));
                    
                    i_rgb[0] = clamp(str_to_num(p_rgb[0]), 0, 255);
                    i_rgb[1] = clamp(str_to_num(p_rgb[1]), 0, 255);
                    i_rgb[2] = clamp(str_to_num(p_rgb[2]), 0, 255);
                    
                    fm_set_rendering(entity, kRenderFxGlowShell, i_rgb[0], i_rgb[1], i_rgb[2], kRenderNormal, 16);
                }
                
                if(g_model_weapon[W_][i][0])
                {
                    entity_set_model(entity, g_model_weapon[W_][i]);
                    return FMRES_SUPERCEDE;
                }
            }
        }
        
        return FMRES_IGNORED;
    }
    
    static Float:dmg_time;
    dmg_time = entity_get_float(entity, EV_FL_dmgtime);
    
    if(dmg_time == 0.0)
        return FMRES_IGNORED;
    
    static pg_rgb[3][3][4];
    static ig_rgb[3][3];
    if(equali(color_all, "off"))
    {
        static color_grenades[3][21];
        
        get_pcvar_string(g_cvar_weapon[CSW_HEGRENADE][WEAPON_W_GLOW], color_grenades[0], charsmax(color_grenades[]));
        get_pcvar_string(g_cvar_weapon[CSW_FLASHBANG][WEAPON_W_GLOW], color_grenades[1], charsmax(color_grenades[]));
        get_pcvar_string(g_cvar_weapon[CSW_SMOKEGRENADE][WEAPON_W_GLOW], color_grenades[2], charsmax(color_grenades[]));
        
        if(!equali(color_grenades[0], "off"))
        {
            parse(color_grenades[0], pg_rgb[0][0], charsmax(pg_rgb[][]), pg_rgb[1][0], charsmax(pg_rgb[][]), pg_rgb[2][0], charsmax(pg_rgb[][]));
            
            ig_rgb[0][0] = clamp(str_to_num(pg_rgb[0][0]), 0, 255);
            ig_rgb[1][0] = clamp(str_to_num(pg_rgb[1][0]), 0, 255);
            ig_rgb[2][0] = clamp(str_to_num(pg_rgb[2][0]), 0, 255);
        }
        if(!equali(color_grenades[1], "off"))
        {
            parse(color_grenades[1], pg_rgb[0][1], charsmax(pg_rgb[][]), pg_rgb[1][1], charsmax(pg_rgb[][]), pg_rgb[2][1], charsmax(pg_rgb[][]));
            
            ig_rgb[0][1] = clamp(str_to_num(pg_rgb[0][1]), 0, 255);
            ig_rgb[1][1] = clamp(str_to_num(pg_rgb[1][1]), 0, 255);
            ig_rgb[2][1] = clamp(str_to_num(pg_rgb[2][1]), 0, 255);
        }
        if(!equali(color_grenades[2], "off"))
        {
            parse(color_grenades[2], pg_rgb[0][2], charsmax(pg_rgb[][]), pg_rgb[1][2], charsmax(pg_rgb[][]), pg_rgb[2][2], charsmax(pg_rgb[][]));
            
            ig_rgb[0][2] = clamp(str_to_num(pg_rgb[0][2]), 0, 255);
            ig_rgb[1][2] = clamp(str_to_num(pg_rgb[1][2]), 0, 255);
            ig_rgb[2][2] = clamp(str_to_num(pg_rgb[2][2]), 0, 255);
        }
    }
    else
    {
        parse(color_all, pg_rgb[0][0], charsmax(pg_rgb[][]), pg_rgb[1][0], charsmax(pg_rgb[][]), pg_rgb[2][0], charsmax(pg_rgb[][]));
        
        ig_rgb[0][0] = ig_rgb[0][1] = ig_rgb[0][2] = clamp(str_to_num(pg_rgb[0][0]), 0, 255);
        ig_rgb[1][0] = ig_rgb[1][1] = ig_rgb[1][2] = clamp(str_to_num(pg_rgb[1][0]), 0, 255);
        ig_rgb[2][0] = ig_rgb[2][1] = ig_rgb[2][2] = clamp(str_to_num(pg_rgb[2][0]), 0, 255);
    }
    
    if(model[9] == 'h' && model[10] == 'e') // HE Grenade
    {
        // Give it a glow
        fm_set_rendering(entity, kRenderFxGlowShell, ig_rgb[0][0], ig_rgb[1][0], ig_rgb[2][0], kRenderNormal, 16);
        
        // Change Model
        if(g_model_weapon[W_][CSW_HEGRENADE][0])
        {
            entity_set_model(entity, g_model_weapon[W_][CSW_HEGRENADE]);
            return FMRES_SUPERCEDE;
        }
    }
    else if(model[9] == 'f' && model[10] == 'l') // Flash Grenade
    {
        // Give it a glow
        fm_set_rendering(entity, kRenderFxGlowShell, ig_rgb[0][1], ig_rgb[1][1], ig_rgb[2][1], kRenderNormal, 16);
        
        // Change Model
        if(g_model_weapon[W_][CSW_FLASHBANG][0])
        {
            entity_set_model(entity, g_model_weapon[W_][CSW_FLASHBANG]);
            return FMRES_SUPERCEDE;
        }
    }
    else if(model[9] == 's' && model[10] == 'm') // Smoke Grenade
    {
        // Give it a glow
        fm_set_rendering(entity, kRenderFxGlowShell, ig_rgb[0][2], ig_rgb[1][2], ig_rgb[2][2], kRenderNormal, 16);
        
        // Change Model
        if(g_model_weapon[W_][CSW_SMOKEGRENADE][0])
        {
            entity_set_model(entity, g_model_weapon[W_][CSW_SMOKEGRENADE]);
            return FMRES_SUPERCEDE;
        }
    }
    
    return FMRES_IGNORED;
}

public fw_EmitSound(id, channel, const sample[], Float:volume, Float:attn, flags, pitch)
{
    if(!is_user_valid_connected(id))
        return FMRES_IGNORED;
    
    new i;
    for(i = 0; i < sizeof(g_sound_knife_default); i++)
    {
        if(equal(sample, g_sound_knife_default[i]) && g_sound_weapon[i][0])
        {
            emit_sound(id, channel, g_sound_weapon[i], volume, attn, flags, pitch);
            return FMRES_SUPERCEDE;
        }
    }
    
    return FMRES_IGNORED;
}

public fw_CmdStart(id, handle)
{
    if(!is_user_alive(id))
        return;
    
    if((1 << g_weapon[id]) & SECONDARY_WEAPONS_BIT_SUM)
    {
        static autofire_cvar;
        
        if(!get_pcvar_num(g_cvar_weapon[31][WEAPON_AUTO_FIRE])) autofire_cvar = get_pcvar_num(g_cvar_weapon[g_weapon[id]][WEAPON_AUTO_FIRE]);
        else autofire_cvar = 1;
        
        if(autofire_cvar)
        {
            static button;
            button = get_uc(handle, UC_Buttons);
            
            if((button & IN_ATTACK) && g_has_ammo[id])
            {
                set_uc(handle, UC_Buttons, button & ~IN_ATTACK);
                g_has_ammo[id] = 0;
            }
        }
    }
}

public message_CurWeapon(msg_id, msg_dest, msg_entity)
{
    if(!is_user_alive(msg_entity) || get_msg_arg_int(1) != 1)
        return;
    
    static clip_cvar[10];
    static clip_cvar_temp[10];
    static clip_cvar_int;
    static mode;
    static weapon;
    
    mode = 0;
    weapon = get_msg_arg_int(2);
    
    get_pcvar_string(g_cvar_weapon[g_weapon[msg_entity]][WEAPON_UNLIMITED_CLIP], clip_cvar, charsmax(clip_cvar));
    get_pcvar_string(g_cvar_weapon[31][WEAPON_UNLIMITED_CLIP], clip_cvar_temp, charsmax(clip_cvar_temp));
    
    clip_cvar_int = str_to_num(clip_cvar);
    
    if(!equali(clip_cvar_temp, "off") || clip_cvar_int)
        mode = 1;
    
    if(!mode)
        return;
    
    if(g_max_bpammo[weapon] > 2)
    {
        static weapon_ent;
        weapon_ent = get_pdata_cbase(msg_entity, OFFSET_ACTIVE_ITEM, OFFSET_LINUX);
        
        if(pev_valid(weapon_ent))
            cs_set_weapon_ammo(weapon_ent, g_max_clip[weapon])
        
        set_msg_arg_int(3, get_msg_argtype(3), g_max_clip[weapon]);
    }
}

// Functions
fn_contain_words(const string[])
{
    if(contain(string, "+") != -1 ||
    contain(string, "-") != -1 ||
    contain(string, "*") != -1 ||
    contain(string, "/") != -1 ||
    contain(string, "=") != -1)
        return 1;
    
    return 0;
}
fn_replace_words(string[], len)
{
    replace(string, len, "+", "");
    replace(string, len, "-", "");
    replace(string, len, "*", "");
    replace(string, len, "/", "");
    replace(string, len, "=", "");
}
fn_load_customization()
{
    new path[64];
    get_configsdir(path, charsmax(path));
    
    format(path, charsmax(path), "%s/%s", path, g_customization_file_ini);
    
    if(!file_exists(path)) return;
    
    new linedata[1024];
    new key[64];
    new value[960];
    new weaponname[32];
    new file = fopen(path, "rt");
    new i;
    new const soundname[][] = {
        "KNIFE_DEPLOY",
        "KNIFE_HIT_1",
        "KNIFE_HIT_2",
        "KNIFE_HIT_3",
        "KNIFE_HIT_4",
        "KNIFE_HIT_WALL",
        "KNIFE_SLASH_1",
        "KNIFE_SLASH_2",
        "KNIFE_STAB"
    }
    
    while(file && !feof(file))
    {
        fgets(file, linedata, charsmax(linedata));
        replace(linedata, charsmax(linedata), "^n", "");
        
        if(!linedata[0] || linedata[0] == ';') continue;
        
        strtok(linedata, key, charsmax(key), value, charsmax(value), '=');
        trim(key);
        trim(value);
        
        // Models
        for(i = 0; i < CSW_P90+2; i++)
        {
            if(g_weapon_ent_names_all[i][0])
            {
                // Remove weapon_ from the names
                copy(weaponname, charsmax(weaponname), g_weapon_ent_names_all[i]);
                
                // Get and precache V_ model
                replace(weaponname, charsmax(weaponname), "weapon_", "V_");
                if(!equali(g_weapon_ent_names_all[i], "weapon_thighpack"))
                {
                    if(equali(key, weaponname)) copy(g_model_weapon[V_][i], charsmax(g_model_weapon[][]), value);
                    if(g_model_weapon[V_][i][0]) precache_model(g_model_weapon[V_][i]);
                }
                
                // Get and precache P_ model
                replace(weaponname, charsmax(weaponname), "V_", "P_");
                if(equali(key, weaponname)) copy(g_model_weapon[P_][i], charsmax(g_model_weapon[][]), value);
                if(g_model_weapon[P_][i][0]) precache_model(g_model_weapon[P_][i]);
                
                // Get and precache W_ model
                replace(weaponname, charsmax(weaponname), "P_", "W_");
                if(equali(key, weaponname)) copy(g_model_weapon[W_][i], charsmax(g_model_weapon[][]), value);
                if(g_model_weapon[W_][i][0]) precache_model(g_model_weapon[W_][i]);
            }
        }
        
        // Knife Sounds
        for(i = 0; i < sizeof(g_sound_knife_default); i++)
        {
            if(equali(key, soundname[i])) copy(g_sound_weapon[i], charsmax(g_sound_weapon[]), value);
            if(g_sound_weapon[i][0]) precache_model(g_sound_weapon[i]);
        }
    }
    
    if(file)
        fclose(file);
}
fn_replace_weapon_models(id, weaponid)
{
    if(!is_user_alive(id))
        return;
    
    if(g_model_weapon[V_][weaponid][0]) entity_set_string(id, EV_SZ_viewmodel, g_model_weapon[V_][weaponid]);
    if(g_model_weapon[P_][weaponid][0]) entity_set_string(id, EV_SZ_weaponmodel, g_model_weapon[P_][weaponid]);
    
    new color[21];
    new color_all[21];
    
    get_pcvar_string(g_cvar_weapon[weaponid][WEAPON_P_GLOW], color, charsmax(color));
    get_pcvar_string(g_cvar_weapon[31][WEAPON_P_GLOW], color_all, charsmax(color_all));
    
    if(!equali(color, "off") || !equali(color_all, "off"))
    {
        new p_rgb[3][4];
        new i_rgb[3];
        
        if(equali(color_all, "off")) parse(color, p_rgb[0], charsmax(p_rgb[]), p_rgb[1], charsmax(p_rgb[]), p_rgb[2], charsmax(p_rgb[]));
        else parse(color_all, p_rgb[0], charsmax(p_rgb[]), p_rgb[1], charsmax(p_rgb[]), p_rgb[2], charsmax(p_rgb[]));
        
        i_rgb[0] = clamp(str_to_num(p_rgb[0]), 0, 255);
        i_rgb[1] = clamp(str_to_num(p_rgb[1]), 0, 255);
        i_rgb[2] = clamp(str_to_num(p_rgb[2]), 0, 255);
        
        fm_set_weaponmodel_ent(id, i_rgb[0], i_rgb[1], i_rgb[2]);
    }
}
public fn_refill_bpammo(const args[], id)
{
    if(!is_user_alive(id))
        return;
    
    set_msg_block(g_msg_ammopickup, BLOCK_ONCE);
    ExecuteHamB(Ham_GiveAmmo, id, g_max_bpammo[args[0]], g_ammo_type[args[0]], g_max_bpammo[args[0]]);
}

// Stocks
stock fm_set_weaponmodel_ent(id, red = -1, green = -1, blue = -1) // Thanks MeRcyLeZZ for the stock!
{
    static model[128];
    entity_get_string(id, EV_SZ_weaponmodel, model, charsmax(model));
    
    if(!pev_valid(g_ent_weaponmodel[id]))
    {
        g_ent_weaponmodel[id] = engfunc(EngFunc_CreateNamedEntity, engfunc(EngFunc_AllocString, "info_target"));
        if(!pev_valid(g_ent_weaponmodel[id])) return;
        
        entity_set_string(g_ent_weaponmodel[id], EV_SZ_classname, "weapon_model");
        entity_set_int(g_ent_weaponmodel[id], EV_INT_movetype, MOVETYPE_FOLLOW);
        entity_set_edict(g_ent_weaponmodel[id], EV_ENT_aiment, id);
        entity_set_edict(g_ent_weaponmodel[id], EV_ENT_owner, id);
        
        if(red != -1 || green != -1 || blue != -1)
            fm_set_rendering(g_ent_weaponmodel[id], kRenderFxGlowShell, red, green, blue, kRenderNormal, 16);
    }
    
    engfunc(EngFunc_SetModel, g_ent_weaponmodel[id], model);
}
stock fm_remove_model_ents(id) // Thanks MeRcyLeZZ for the stock!
{
    if(pev_valid(g_ent_weaponmodel[id]))
    {
        remove_entity(g_ent_weaponmodel[id]);
        g_ent_weaponmodel[id] = 0;
    }
}
stock cs_weapon_name_to_id(const weapon[]) // Simplified get_weaponid (CS only) -- Thanks MeRcyLeZZ for the stock!
{
    static i;
    for(i = 0; i < sizeof(g_weapon_ent_names) - 1; i++)
    {
        if(equal(weapon, g_weapon_ent_names[i]))
            return i;
    }
    
    return 0;
}
stock fm_get_weapon_ent_owner(ent)
{
    if(pev_valid(ent) != OFFSET_PDATA)
        return -1;
    
    return get_pdata_cbase(ent, OFFSET_WEAPON_OWNER, OFFSET_LINUX_WEAPONS);
} 

DjSoftero 02-08-2019 20:36
Re: get_pcvar_string error weapon_modifier.amxx
 
show configs weapon_modifier.ini and weapon_modifier.cfg

RojedaFeik 02-08-2019 21:46
Re: get_pcvar_string error weapon_modifier.amxx
 
Quote:
Originally Posted by DjSoftero (Post 2638773)
show configs weapon_modifier.ini and weapon_modifier.cfg
Code:
weapon_modifier.ini

; V_ models!
; ==========
V_P228 =
V_SHIELD =
V_SCOUT =
V_HEGRENADE =
V_XM1014 =
V_C4 =
V_MAC10 =
V_AUG =
V_SMOKEGRENADE =
V_ELITE =
V_FIVESEVEN =
V_UMP45 =
V_SG550 =
V_GALIL =
V_FAMAS =
V_USP =
V_GLOCK18 =
V_AWP =
V_MP5NAVY =
V_M249 =
V_M3 =
V_M4A1 =
V_TMP =
V_G3SG1 =
V_FLASHBANG =
V_DEAGLE =
V_SG552 =
V_AK47 =
V_KNIFE =
V_P90 = 

; P_ models!
; ==========
P_THIGHPACK =
P_P228 =
P_SHIELD =
P_SCOUT =
P_HEGRENADE =
P_XM1014 =
P_C4 =
P_MAC10 =
P_AUG =
P_SMOKEGRENADE =
P_ELITE =
P_FIVESEVEN =
P_UMP45 =
P_SG550 =
P_GALIL =
P_FAMAS =
P_USP =
P_GLOCK18 =
P_AWP =
P_MP5NAVY =
P_M249 =
P_M3 =
P_M4A1 =
P_TMP =
P_G3SG1 =
P_FLASHBANG =
P_DEAGLE =
P_SG552 =
P_AK47 =
P_KNIFE =
P_P90 =

; W_ models!
; ==========
W_THIGHPACK =
W_P228 =
W_SHIELD =
W_SCOUT =
W_HEGRENADE =
W_XM1014 =
W_C4 =
W_MAC10 =
W_AUG =
W_SMOKEGRENADE =
W_ELITE =
W_FIVESEVEN =
W_UMP45 =
W_SG550 =
W_GALIL =
W_FAMAS =
W_USP =
W_GLOCK18 =
W_AWP =
W_MP5NAVY =
W_M249 =
W_M3 =
W_M4A1 =
W_TMP =
W_G3SG1 =
W_FLASHBANG =
W_DEAGLE =
W_SG552 =
W_AK47 =
W_KNIFE =
W_P90 =
W_BACKPACK =

; Knife Sounds!
; =============
KNIFE_DEPLOY =
KNIFE_HIT_1 =
KNIFE_HIT_2 =
KNIFE_HIT_3 =
KNIFE_HIT_4 =
KNIFE_HIT_WALL =
KNIFE_SLASH_1 =
KNIFE_SLASH_2 =
KNIFE_STAB =
Code:
weapon_modifier.cfg only modified recoil to 0.80

; Damage!
; =======
wm_damage_p228 off
wm_damage_scout off
wm_damage_xm1014 off
wm_damage_mac10 off
wm_damage_aug off
wm_damage_elite off
wm_damage_fiveseven off
wm_damage_ump45 off
wm_damage_sg550 off
wm_damage_galil off
wm_damage_famas off
wm_damage_usp off
wm_damage_glock18 off
wm_damage_awp off
wm_damage_mp5navy off
wm_damage_m249 off
wm_damage_m3 off
wm_damage_m4a1 off
wm_damage_tmp off
wm_damage_g3sg1 off
wm_damage_deagle off
wm_damage_sg552 off
wm_damage_ak47 off
wm_damage_knife off
wm_damage_p90 off
wm_damage_all off

; Recoil!
; =======
wm_recoil_p228 0.80
wm_recoil_scout 0.80
wm_recoil_xm1014 0.80
wm_recoil_mac10 0.80
wm_recoil_aug 0.80
wm_recoil_elite 0.80
wm_recoil_fiveseven 0.80
wm_recoil_ump45 0.80
wm_recoil_sg550 0.80
wm_recoil_galil 0.80
wm_recoil_famas 0.80
wm_recoil_usp 0.80
wm_recoil_glock18 0.80
wm_recoil_awp 0.80
wm_recoil_mp5navy 0.80
wm_recoil_m249 0.80
wm_recoil_m3 0.80
wm_recoil_m4a1 0.80
wm_recoil_tmp 0.80
wm_recoil_g3sg1 0.80
wm_recoil_deagle 0.80
wm_recoil_sg552 0.80
wm_recoil_ak47 0.80
wm_recoil_knife 0.80
wm_recoil_p90 0.80
wm_recoil_all 0.80

; Speed!
; ======
wm_speed_p228 off
wm_speed_scout off
wm_speed_xm1014 off
wm_speed_mac10 off
wm_speed_aug off
wm_speed_elite off
wm_speed_fiveseven off
wm_speed_ump45 off
wm_speed_sg550 off
wm_speed_galil off
wm_speed_famas off
wm_speed_usp off
wm_speed_glock18 off
wm_speed_awp off
wm_speed_mp5navy off
wm_speed_m249 off
wm_speed_m3 off
wm_speed_m4a1 off
wm_speed_tmp off
wm_speed_g3sg1 off
wm_speed_deagle off
wm_speed_sg552 off
wm_speed_ak47 off
wm_speed_knife off
wm_speed_p90 off
wm_speed_all off

; W_ Glow!
; ========
wm_wglow_thighpack off
wm_wglow_p228 off
wm_wglow_shield off
wm_wglow_scout off
wm_wglow_hegrenade off
wm_wglow_xm1014 off
wm_wglow_c4 off
wm_wglow_mac10 off
wm_wglow_aug off
wm_wglow_smokegrenade off
wm_wglow_elite off
wm_wglow_fiveseven off
wm_wglow_ump45 off
wm_wglow_sg550 off
wm_wglow_galil off
wm_wglow_famas off
wm_wglow_usp off
wm_wglow_glock18 off
wm_wglow_awp off
wm_wglow_mp5navy off
wm_wglow_m249 off
wm_wglow_m3 off
wm_wglow_m4a1 off
wm_wglow_tmp off
wm_wglow_g3sg1 off
wm_wglow_flashbang off
wm_wglow_deagle off
wm_wglow_sg552 off
wm_wglow_ak47 off
wm_wglow_knife off
wm_wglow_p90 off
wm_wglow_all off
wm_wglow_backpack off

; P_ Glow!
; ========
wm_pglow_p228 off
wm_pglow_shield off
wm_pglow_scout off
wm_pglow_hegrenade off
wm_pglow_xm1014 off
wm_pglow_c4 off
wm_pglow_mac10 off
wm_pglow_aug off
wm_pglow_smokegrenade off
wm_pglow_elite off
wm_pglow_fiveseven off
wm_pglow_ump45 off
wm_pglow_sg550 off
wm_pglow_galil off
wm_pglow_famas off
wm_pglow_usp off
wm_pglow_glock18 off
wm_pglow_awp off
wm_pglow_mp5navy off
wm_pglow_m249 off
wm_pglow_m3 off
wm_pglow_m4a1 off
wm_pglow_tmp off
wm_pglow_g3sg1 off
wm_pglow_flashbang off
wm_pglow_deagle off
wm_pglow_sg552 off
wm_pglow_ak47 off
wm_pglow_knife off
wm_pglow_p90 off
wm_pglow_all off

; Unlimited Clip!
; ===============
wm_unclip_p228 off
wm_unclip_scout off
wm_unclip_xm1014 off
wm_unclip_mac10 off
wm_unclip_aug off
wm_unclip_elite off
wm_unclip_fiveseven off
wm_unclip_ump45 off
wm_unclip_sg550 off
wm_unclip_galil off
wm_unclip_famas off
wm_unclip_usp off
wm_unclip_glock18 off
wm_unclip_awp off
wm_unclip_mp5navy off
wm_unclip_m249 off
wm_unclip_m3 off
wm_unclip_m4a1 off
wm_unclip_tmp off
wm_unclip_g3sg1 off
wm_unclip_deagle off
wm_unclip_sg552 off
wm_unclip_ak47 off
wm_unclip_knife off
wm_unclip_p90 off
wm_unclip_all off

; Unlimited BPAmmo!
; =================
wm_unbpammo_p228 off
wm_unbpammo_scout off
wm_unbpammo_xm1014 off
wm_unbpammo_mac10 off
wm_unbpammo_aug off
wm_unbpammo_elite off
wm_unbpammo_fiveseven off
wm_unbpammo_ump45 off
wm_unbpammo_sg550 off
wm_unbpammo_galil off
wm_unbpammo_famas off
wm_unbpammo_usp off
wm_unbpammo_glock18 off
wm_unbpammo_awp off
wm_unbpammo_mp5navy off
wm_unbpammo_m249 off
wm_unbpammo_m3 off
wm_unbpammo_m4a1 off
wm_unbpammo_tmp off
wm_unbpammo_g3sg1 off
wm_unbpammo_deagle off
wm_unbpammo_sg552 off
wm_unbpammo_ak47 off
wm_unbpammo_knife off
wm_unbpammo_p90 off
wm_unbpammo_all off

; Automatic Fire Pistol!
; ======================
wm_autofire_p228 0
wm_autofire_elite 0
wm_autofire_fiveseven 0
wm_autofire_usp 0
wm_autofire_glock18 0
wm_autofire_deagle 0
wm_autofire_all 0

; Zoom!
; =====
wm_zoom_p228 off
wm_zoom_scout off
wm_zoom_xm1014 off
wm_zoom_mac10 off
wm_zoom_aug off
wm_zoom_elite off
wm_zoom_fiveseven off
wm_zoom_ump45 off
wm_zoom_sg550 off
wm_zoom_galil off
wm_zoom_awp off
wm_zoom_mp5navy off
wm_zoom_m249 off
wm_zoom_m3 off
wm_zoom_tmp off
wm_zoom_g3sg1 off
wm_zoom_deagle off
wm_zoom_sg552 off
wm_zoom_ak47 off
wm_zoom_p90 off
wm_zoom_all off

; Knockback!
; ==========
wm_knockback 0
wm_kb_zvel 1                ; Multiplier Z velocity
wm_kb_dist 500                ; Distance

wm_kb_p228 0
wm_kb_scout 0
wm_kb_xm1014 0
wm_kb_mac10 0
wm_kb_aug 0
wm_kb_elite 0
wm_kb_fiveseven 0
wm_kb_ump45 0
wm_kb_sg550 0
wm_kb_galil 0
wm_kb_famas 0
wm_kb_usp 0
wm_kb_glock18 0
wm_kb_awp 0
wm_kb_mp5navy 0
wm_kb_m249 0
wm_kb_m3 0
wm_kb_m4a1 0
wm_kb_tmp 0
wm_kb_g3sg1 0
wm_kb_deagle 0
wm_kb_sg552 0
wm_kb_ak47 0
wm_kb_knife 0
wm_kb_p90 0
wm_kb_all 0

RojedaFeik 02-10-2019 18:52
Re: get_pcvar_string error weapon_modifier.amxx
 
Please help :(

PartialCloning 02-10-2019 21:26
Re: get_pcvar_string error weapon_modifier.amxx
 
Try:

PHP Code:
public event_AmmoX(id)
{
    if(!g_weapon[id])
        return;
.... 

OciXCrom 02-11-2019 04:16
Re: get_pcvar_string error weapon_modifier.amxx
 
The error means that the plugin is trying to get a value from a cvar that hasn't been created (yet). Check that.

RojedaFeik 02-13-2019 14:55
Re: get_pcvar_string error weapon_modifier.amxx
 
Quote:
Originally Posted by PartialCloning (Post 2639105)
Try:

PHP Code:
public event_AmmoX(id)
{
    if(!g_weapon[id])
        return;
.... 

Thank u! :fox:


All times are GMT -4. The time now is 04:37.

Powered by vBulletin®
Copyright ©2000 - 2024, vBulletin Solutions, Inc.