Bomb Real Timer + Multimeter 6.0

#include <amxmodx>
#include <amxmisc>
#include <fakemeta>
#include <hamsandwich>
#include <xs>

/* Code makeup special for HamletEagle */

#define PLUGIN_NAME    "BOMB REAL TIMER"
#define PLUGIN_VERSION    "6.0"
#define PLUGIN_AUTHOR    "Vaqtincha | Flymic24 | MayroN | bizon"

enum any: CvarsStruct
{
    CVAR_BOMB_ANIMATION,
    CVAR_BACKPACK_ACTIVE,
    CVAR_LED_GLOW,
    CVAR_ACTIVE_MULTIMETER
};

new const V_MODEL[] = "models/bomb_real_timer/v_c4.mdl"
new const P_MODEL[] = "models/bomb_real_timer/p_c4.mdl"
new const W_MODEL[] = "models/bomb_real_timer/w_c4.mdl"

new const BACKPACK[] = "models/bomb_real_timer/w_backpack.mdl"
new const MULTIMETER_ENT_MODEL[] = "models/bomb_real_timer/multimeter.mdl";

new Float:g_flOrigin[3], Float:g_flAngles[3], g_fwdSetModel;
new g_eMultimeter, bool: g_bIsBombAlreadyPlant, HamHook: g_hThinkMultimeter;
new g_eCvar[CvarsStruct];

const m_flC4Blow = 100;
const m_pPlayer = 41;
const m_flNextBlink = 106;

public plugin_precache()
{
    precache_model(V_MODEL)
    precache_model(P_MODEL)
    precache_model(W_MODEL)

    precache_model(BACKPACK)

    precache_model(MULTIMETER_ENT_MODEL);
}

public plugin_init()
{
    if(engfunc(EngFunc_FindEntityByString, FM_NULLENT, "info_bomb_target") || engfunc(EngFunc_FindEntityByString, FM_NULLENT, "func_bomb_target"))
    {
        register_plugin(PLUGIN_NAME, PLUGIN_VERSION, PLUGIN_AUTHOR);

        register_forward(FM_SetModel, "fw_SetModel", 1);

        RegisterHam(Ham_Item_Deploy, "weapon_c4", "ItemDeploy_Post", 1)

        RegisterHam(Ham_Think, "grenade", "C4_Think");

        register_event("BarTime", "event_bomb_planting", "be", "1=3")
        register_event("BarTime", "event_bomb_defusing", "be", "1=5", "1=10")

        register_logevent("logevent_round_end",2,"1=Round_End")
        register_logevent("logevent_bomb_defused",3,"2=Defused_The_Bomb")
        register_logevent("logevent_bomb_planted",3,"2=Planted_The_Bomb")

        cvars_attach();

        if(g_eCvar[CVAR_ACTIVE_MULTIMETER])
        {
            register_event("BarTime", "event_bomb_defusing_abort", "b", "1=0")
            register_event("23", "event_bomb_explode", "a", "1=17", "6=-105", "7=17")
            register_event("HLTV", "event_start_round", "a", "1=0", "2=0")

            g_eMultimeter = engfunc(EngFunc_CreateNamedEntity, engfunc(EngFunc_AllocString, "info_target"));
            set_pev(g_eMultimeter, pev_classname, "multimeter");

            engfunc(EngFunc_SetOrigin, g_eMultimeter, Float: { 0.0, 0.0, 0.0 }, Float: { 0.0, 0.0, 0.0 });
            engfunc(EngFunc_SetModel, g_eMultimeter, MULTIMETER_ENT_MODEL);
            engfunc(EngFunc_SetSize, g_eMultimeter, Float: { 0.0, 0.0, 0.0 }, Float: { 0.0, 0.0, 3.0 });

            fm_set_entity_visibility(g_eMultimeter, false);

            DisableHamForward(g_hThinkMultimeter = RegisterHamFromEntity(Ham_Think, g_eMultimeter, "fwHam_MultimeterThink", true));
        }
    }
}

public C4_Think(ent)
{
    if(!pev_valid(ent))
        return;

    static szModel[64];
    pev(ent, pev_model, szModel, charsmax(szModel))

    if(!equali(szModel, W_MODEL))
        return;

    new iSkin;
    iSkin = 60 - floatround(get_pdata_float(ent, m_flC4Blow) - get_gametime());
 
    set_pev(ent, pev_skin, iSkin);
}

public event_bomb_planting()
{
    g_fwdSetModel = register_forward(FM_SetModel, "fw_SetModel", 0)
}

public logevent_bomb_planted()
{
    new loguser[80], name[32], id;

    read_logargv(0, loguser, charsmax(loguser))
    parse_loguser(loguser, name, charsmax(name))

    id =  get_user_index(name);

    if(is_user_connected(id))
    {
        new Float:flAngles[3], ent
        pev(id, pev_v_angle, flAngles)

        ent = func_find_ent_by_model(FM_NULLENT, "grenade", W_MODEL)

        if(pev_valid(ent))
        {
            flAngles[0]=0.0
            flAngles[1]+=90.0

            set_pev(ent, pev_angles, flAngles)

            if(g_eCvar[CVAR_LED_GLOW])
            {
                set_pdata_float(ent, m_flNextBlink, 9999.9)
            }

            set_pev(ent, pev_angles, Float: { 0.0, 0.0, 0.0 });
        }
    }
}

public event_bomb_defusing()
{
    new ent;
    ent = func_find_ent_by_model(FM_NULLENT, "grenade", W_MODEL)

    if(pev_valid(ent))
    {
        pev(ent, pev_origin, g_flOrigin)
        pev(ent, pev_angles, g_flAngles)

        if(g_eCvar[CVAR_ACTIVE_MULTIMETER])
        {
            if(!g_bIsBombAlreadyPlant)
            {
                new Float: flOrigin[3];
                pev(ent, pev_origin, flOrigin);

                if(is_the_place_valid_set_multimeter(ent, flOrigin, g_eMultimeter))
                {
                    g_bIsBombAlreadyPlant = true;

                    fm_set_entity_visibility(g_eMultimeter, true);

                    set_pev(g_eMultimeter, pev_skin, 1);
                    set_pev(g_eMultimeter, pev_nextthink, get_gametime() + 0.1);

                    EnableHamForward(g_hThinkMultimeter);

                    engfunc(EngFunc_SetOrigin, g_eMultimeter, flOrigin);
                }
            }
            else
            {
                set_pev(g_eMultimeter, pev_skin, 1);
                set_pev(g_eMultimeter, pev_nextthink, get_gametime() + 0.1);

                EnableHamForward(g_hThinkMultimeter);
            }
        }
    }
}

public event_bomb_defusing_abort()
{
    set_pev(g_eMultimeter, pev_skin, 0);
    set_pev(g_eMultimeter, pev_nextthink, -1.0);

    DisableHamForward(g_hThinkMultimeter);
}

public event_bomb_explode()
{
    multimeter_remove();
}

public event_start_round()
{
    multimeter_remove();
}

public logevent_bomb_defused()
{
    new ent;
    ent = engfunc(EngFunc_CreateNamedEntity, engfunc(EngFunc_AllocString, "grenade"));

    if(!pev_valid(ent))
        return;

    set_pev(ent, pev_origin, g_flOrigin)
    set_pev(ent, pev_angles, g_flAngles)
    dllfunc(DLLFunc_Spawn, ent)

    engfunc(EngFunc_SetModel, ent, W_MODEL)

    if(g_eCvar[CVAR_BOMB_ANIMATION])
    {
        set_pev(ent, pev_animtime, get_gametime())
        set_pev(ent, pev_sequence, 1)
        set_pev(ent, pev_frame, 0.0)
        set_pev(ent, pev_framerate, 1.0)
    }
    else
        set_pev(ent, pev_sequence, 0)

    set_pev(ent, pev_skin, 61)
    set_pev(ent, pev_movetype, MOVETYPE_NONE)
    set_pev(ent, pev_solid, SOLID_NOT)
    set_pev(ent, pev_spawnflags, pev(ent, pev_spawnflags) | SF_NORESPAWN)

    if(g_eCvar[CVAR_ACTIVE_MULTIMETER])
    {
        set_pev(g_eMultimeter, pev_skin, 0);
        set_pev(g_eMultimeter, pev_nextthink, -1.0);

        DisableHamForward(g_hThinkMultimeter);
    }
}

public ItemDeploy_Post(wEnt)
{
    new id;
    id = get_pdata_cbase(wEnt, m_pPlayer, .linuxdiff = 4)

    if(is_user_connected(id))
    {
        set_pev(id, pev_viewmodel2, V_MODEL)
        set_pev(id, pev_weaponmodel2, P_MODEL)
    }
}

public fw_SetModel(ent, const model[])
{
    if(!pev_valid(ent))
        return FMRES_IGNORED;

    if(equal(model, "models/w_c4.mdl"))
    {
        engfunc(EngFunc_SetModel, ent, W_MODEL);
        set_pev(ent, pev_skin, 0)
        return FMRES_SUPERCEDE;
    }

    if(g_eCvar[CVAR_BACKPACK_ACTIVE])
    {
        if(equal(model, "models/w_backpack.mdl"))
        {
            engfunc(EngFunc_SetModel, ent, BACKPACK);
            return FMRES_SUPERCEDE;
        }
    }

    return FMRES_IGNORED;
}

public logevent_round_end()
{
    if(g_fwdSetModel)
        unregister_forward(FM_SetModel, g_fwdSetModel, 0)
}

public fwHam_MultimeterThink(eEnt)
{
    if(!pev_valid(eEnt))
        return;

    const MULTIMETER_MODEL_SKINS_COUNT = 12;

    set_pev(eEnt, pev_skin, random_num(1, MULTIMETER_MODEL_SKINS_COUNT - 1));
    set_pev(eEnt, pev_nextthink, get_gametime() + random_float(0.1, 0.3));
}

public multimeter_remove()
{
    if(pev_valid(g_eMultimeter))
        fm_set_entity_visibility(g_eMultimeter, false);

    g_bIsBombAlreadyPlant = false;
}

public cvars_attach()
{
    bind_pcvar_num(
        create_cvar(
            "brt_bomb_animation", "1", FCVAR_SERVER,
            .description = "Анимация бомбы (1 - вкл, 0 - выкл)",
            .has_min = false, .min_val = 0.0,
            .has_max = false, .max_val = 0.0
        ), g_eCvar[CVAR_BOMB_ANIMATION]
    );

    bind_pcvar_num(
        create_cvar(
            "brt_backpack_active", "1", FCVAR_SERVER,
            .description = "Кастомный рюкзак (1 - вкл, 0 - выкл)",
            .has_min = false, .min_val = 0.0,
            .has_max = false, .max_val = 0.0
        ), g_eCvar[CVAR_BACKPACK_ACTIVE]
    );

    bind_pcvar_num(
        create_cvar(
            "brt_led_glow", "1", FCVAR_SERVER,
            .description = "Мигание бомбы (1 - вкл, 0 - выкл)",
            .has_min = false, .min_val = 0.0,
            .has_max = false, .max_val = 0.0
        ), g_eCvar[CVAR_LED_GLOW]
    );

    bind_pcvar_num(
        create_cvar(
            "brt_active_multimeter", "1", FCVAR_SERVER,
            .description = "Создаение мультиметра (1 - вкл, 0 - выкл)",
            .has_min = false, .min_val = 0.0,
            .has_max = false, .max_val = 0.0
        ), g_eCvar[CVAR_ACTIVE_MULTIMETER]
    );

    AutoExecConfig(true, "bomb_real_timer_settings");
}

stock func_find_ent_by_model(index, const classname[], const model[])
{
    new ent = index, mdl[72]

    while((ent = engfunc(EngFunc_FindEntityByString, ent, "classname", classname)))
    {
        pev(ent, pev_model, mdl, charsmax(mdl))

        if(equal(mdl, model))
            return ent
    }

    return 0
}

stock is_the_place_valid_set_multimeter(eEnt, Float: fOriginEnd[3], eIgnoreEnt)
{
    const Float: fShiftUnit = 22.0;

    new Float: fOriginStart[3];

    pev(eEnt, pev_origin, fOriginStart);
    pev(eEnt, pev_angles, fOriginEnd);

    engfunc(EngFunc_MakeVectors, fOriginEnd);
    global_get(glb_v_right, fOriginEnd);

    xs_vec_neg(fOriginEnd, fOriginEnd);

    xs_vec_mul_scalar(fOriginEnd, fShiftUnit, fOriginEnd);
    xs_vec_add(fOriginStart, fOriginEnd, fOriginEnd);

    engfunc(EngFunc_TraceLine, fOriginStart, fOriginEnd, DONT_IGNORE_MONSTERS, eIgnoreEnt, 0);

    get_tr2(0, TR_vecEndPos, fOriginEnd);

    engfunc(EngFunc_TraceHull, fOriginEnd, fOriginEnd, DONT_IGNORE_MONSTERS, HULL_POINT, eIgnoreEnt, 0);

    if(!get_tr2(0, TR_StartSolid) && !get_tr2(0, TR_AllSolid) && get_tr2(0, TR_InOpen))
    {
        fOriginEnd = fOriginStart;
        return true;
    }

    return false;
}

stock fm_set_entity_visibility(eEnt, bool: bIsStateVisible)
{
    if(bIsStateVisible)
        set_pev(eEnt, pev_effects, pev(eEnt, pev_effects) & ~EF_NODRAW);
    else
        set_pev(eEnt, pev_effects, pev(eEnt, pev_effects) | EF_NODRAW);
}