• Пожалуйста, создайте название темы отражающее ее смысл
  • Для ускорения решения Вашего вопроса заполните обязательные поля и подробно опишите возникшую проблему

Помощь включить слышимость Gag Manager v1.3

alan191

Участник
Сообщения
121
Реакции
2
Баллы
18
Доброе утро! использую плагин Гага версии 1.3 (на данный момент она мне более пока по душе из за временного отсутствия CMS)
так вот как убрать запрет слышимости товарищей по команде когда игрок мертв?
если я правильно закомментировал то не помогло, исправьте если я не прав пожалуйста, так как всё равно выводится hud о запрете передать инфу

Код:
//#define INFA_LOL    5.0 //время для инфы никчемным игрокам

или просто удалить с кода следующее?
Код:
public FwdPlayerKilled(id)
{
    #if defined INFA_LOL
        set_task(INFA_LOL, "BlockForKilled", id);
    #else
        BlockForKilled(id);
    #endif
}

Код:
#include <amxmodx>
#include <amxmisc>
#include <hamsandwich>
#include <fakemeta>
#include <sqlx>
#include <gamecms>
#include <time>
#include <engine>

#define PLUGIN    "GameCMS_GagManager"
#define VERSION    "1.3"
#define AUTHOR    "zhorzh78"

#define REAPI        //Использовать ReApi вместо VtcApi
//#define ST_CHAT    //используется стандартный чат. Отключить, если есть плагины, меняющие чат
//#define INFA_LOL    5.0 //время для инфы никчемным игрокам

#if defined REAPI
    #include <reapi>
    #define VTC_OnClientStartSpeak(sender) VTC_OnClientStartSpeak(const sender)
    #define VTC_OnClientStopSpeak(sender)    VTC_OnClientStopSpeak(const sender)
#else
    #include <VtcApi>
#endif

#define MAX_PLAYERS    32

#define    GetBit(%1,%2)        ((%1) & (1 << (%2 & 31)))
#define    SetBit(%1,%2)        ((%1) |= (1 << (%2 & 31)))
#define    ResetBit(%1,%2)        ((%1) &= ~(1 << (%2 & 31)))

#if AMXX_VERSION_NUM < 183
    #include <colorchat>
#endif
#if defined AMXX_VERSION_RELEASE
    #define    client_disconnect client_disconnected
#endif

new const sqlTable[] = "comms";
new const soundFilePath[] = "../valve/sound/buttons/blip2.wav";
new g_Muted[MAX_PLAYERS+1], g_PlayerTeam[MAX_PLAYERS+1], bool:g_isAlivePlayer[MAX_PLAYERS+1], g_ImmunLevel[MAX_PLAYERS+1];
new Trie:g_WhiteListCmdArray, Trie:g_BlockedUsers, Trie:g_AdminInfo;
new g_bBlockVoice, g_bBlockChat, g_bBlocked, g_bTeamVoice;
new g_TimeMenu, g_ReasonMenu, g_TypeMenu, g_StaticMenuCallback;
new cv_LocAllTalk, cv_DeadAdmTalk, cv_AllTalk;
new g_AddTime, g_AddLastId, actfwd, fwd;
new adminData[AdminInfo];

enum _:BlockInfo
{
    bid,        //comms.bid BanID
    BlockType,    //comms.type
    Expired,    //comms.expired
    AdminId,    //comms.admin_id
    Created,    //comms.created
    BlockTime,    //comms.length
    AuthId[24],    //comms.authid
    Name[33],    //comms.name
    BlockReason[65],//comms.reason
    AdminNick[33], //comms.admin_nick
    ModifiedBy[33],    //comms.modified_by
    bool:ModifiedBlocked,
    targetID
};

new plBlockInfo[MAX_PLAYERS+1][BlockInfo]
new g_BlockType[][] =
{
    "Чат + голос",
    "Чат",
    "Голос"
}

stock item_access, gagmenuCMD;
new Handle:g_SqlX, serverID
new bool:g_API_allow

//cvars
enum _:CvarHndl
{
    hTime,
    hPrefix,
    hAccessLvl,
    hWhiteCmds,
    hAllTalk,
    hDeadAdmTalk
};
new g_hCvars[CvarHndl]

new Array:g_BlockTime
new g_AccessLvl[5], PREFIX[20]

public plugin_init()
{
    register_plugin(PLUGIN, VERSION, AUTHOR);
    register_cvar("gamecms_gagmanager", VERSION, FCVAR_SERVER);

    register_clcmd("say /mute", "MuteMenu");
    register_clcmd("say_team /mute", "MuteMenu");
    register_clcmd("+teamvoice", "Team_VoiceOn");
    register_clcmd("-teamvoice", "Team_VoiceOff");
  
    register_dictionary("time.txt");

    register_concmd("cms_gag_reason", "AddGagReason");
    register_clcmd("say",         "HookSayChat");
    register_clcmd("say_team",     "HookSayChat");

    RegisterHam(Ham_Spawn, "player", "FwdPlayerSpawn", true);
    RegisterHam(Ham_Killed, "player", "FwdPlayerKilled", true);
  
    RegisterCvars();    //квары

    #if defined ST_CHAT
    register_message(get_user_msgid("SayText"),"CheckSayText")
    #endif

    /* ===========    Меню выбора причины    */
    g_StaticMenuCallback = menu_makecallback("StaticMenu_callback");
    g_ReasonMenu = menu_create("\yУкажите причину", "StaticMenu_Handler", 1);

    menu_additem(g_ReasonMenu, "Своя причина", "rs"/*, g_AccessLvl[2]*/);
    menu_setprop(g_ReasonMenu, MPROP_EXITNAME, "\yВыход");
  
    new configsDir[32], configsFile[55]
    get_configsdir(configsDir, charsmax(configsDir))
    formatex(configsFile, charsmax(configsFile), "%s/gamecms/gamecms_gagmanager.cfg", configsDir)
  
    server_cmd("exec %s", configsFile)
}
  
RegisterCvars()
{
    g_hCvars[hTime] = register_cvar("cms_gag_time", "-1, 10, 60, 1440, 0")
    g_hCvars[hAccessLvl] = register_cvar("cms_gag_access_lvl", "a, b, c, d")
    g_hCvars[hPrefix] = register_cvar("cms_gag_prefix", "MUTE")
    g_hCvars[hWhiteCmds] = register_cvar("cms_gag_whitecmds", "")
    g_hCvars[hAllTalk] = register_cvar("cms_gag_alltalk", "0")
    g_hCvars[hDeadAdmTalk] = register_cvar("cms_gag_deadadmtalk", "0")
}
  
public plugin_cfg()
{
    g_BlockTime = ArrayCreate()
    g_BlockedUsers = TrieCreate();
    g_WhiteListCmdArray = TrieCreate();

    //читаем квары
    new tmpCvarStr[64];
    if(get_pcvar_string(g_hCvars[hAccessLvl], tmpCvarStr, charsmax(tmpCvarStr)))
    {
        new tmpOut[4][5], len = sizeof(tmpOut);
        ExplodeString(tmpOut, 4, len, tmpCvarStr, ',');
        for(new i; i< len; i++)
            g_AccessLvl[i] = read_flags(tmpOut[i]);
      
        gagmenuCMD = register_clcmd("amx_gagmenu", "AdminPlayersMenu", g_AccessLvl[1]);
        register_clcmd("say /gag", "AdminPlayersMenu", g_AccessLvl[1]);
    }
    //время
    if(get_pcvar_string(g_hCvars[hTime], tmpCvarStr, charsmax(tmpCvarStr)))
        CvarsToArray(g_BlockTime, tmpCvarStr, ',', "t");
  
    //разрешенные команды
    if(get_pcvar_string(g_hCvars[hWhiteCmds], tmpCvarStr, charsmax(tmpCvarStr)))
        CvarsToArray(g_WhiteListCmdArray, tmpCvarStr, ',', "c");
  
    //префикс чата
    get_pcvar_string(g_hCvars[hPrefix], PREFIX, charsmax(PREFIX));

    cv_LocAllTalk = get_pcvar_num(g_hCvars[hAllTalk]);
    cv_DeadAdmTalk = get_pcvar_num(g_hCvars[hDeadAdmTalk]);
    cv_AllTalk = get_cvar_num("sv_alltalk");
  
    StaticMenuCreate();
}

/*======== Ловим соединение с БД от API =========*/
public init_database(Handle:sqlTuple)
{
    if(!(g_SqlX = sqlTuple))
        return;
  
    serverID = get_serverID();
    g_API_allow = true;
  
    if(get_playersnum()) //Если игроки зашли ДО соединения с БД
    {
        for(new i = 1; i <= MAX_PLAYERS; i++)
        {
            if(!is_user_connected(i) && !is_user_connecting(i))
                continue;
            client_putinserver(i);
        }
    }
}

/*======== Статические меню (время, причина, тип) =========*/
public StaticMenuCreate()
{
/* ===========    Меню выбора времени*/
    g_TimeMenu = menu_create("\yВыбрать время", "StaticMenu_Handler", 1);
    new g_TimeMenu_size = ArraySize(g_BlockTime);
    for (new i = 0; i < g_TimeMenu_size; ++i)
    {
        new tmp_iTime = ArrayGetCell(g_BlockTime, i);
        menu_additem(g_TimeMenu, FormatBlockTime(tmp_iTime, 1), "t", 0, g_StaticMenuCallback);
    }
    menu_setprop(g_TimeMenu, MPROP_EXITNAME, "\yВыход");
  
/* ===========    Меню выбора типа блокировки    */
    g_TypeMenu = menu_create("\yТип блокировки", "StaticMenu_Handler", 1);
    static g_TypeMenu_size = sizeof(g_BlockType);
    for (new i = 0; i < g_TypeMenu_size; ++i)
        menu_additem(g_TypeMenu, g_BlockType[i], "b", 0, g_StaticMenuCallback);

    menu_setprop(g_TypeMenu, MPROP_EXITNAME, "\yВыход");
}

public StaticMenu_callback(id, menu, item)
{
    new szData[3], szName[90], item_callback;
    menu_item_getinfo(menu, item, item_access, szData, charsmax(szData), szName, charsmax(szName), item_callback);
    new iTime = ArrayGetCell(g_BlockTime, item)
    new itemStatus;
    switch(szData[0])
    {
        case 't': itemStatus = (iTime == plBlockInfo[id][BlockTime] && plBlockInfo[id][Created]) ||
                    !g_API_allow && (iTime > get_timeleft()/60 || iTime == 0) ? ITEM_DISABLED : ITEM_IGNORE;
        case 'r': itemStatus = strcmp(szName, plBlockInfo[id][BlockReason]) == 0 ? ITEM_DISABLED : ITEM_IGNORE;
        case 'b': itemStatus = item == plBlockInfo[id][BlockType] && plBlockInfo[id][Created] ? ITEM_DISABLED : ITEM_IGNORE;
    }

    return itemStatus;
}

public StaticMenu_Handler(id, menu, item)
{
    if (item == MENU_EXIT)
    {
        arrayset(plBlockInfo[id], 0, BlockInfo);
        return PLUGIN_HANDLED;
    }
      
    new item_callback, szData[7], szName[90];
    menu_item_getinfo(menu, item, item_access, szData, charsmax(szData), szName, charsmax(szName), item_callback);
      
    switch(szData[0])
    {
        case 't':    //time
        {
            plBlockInfo[id][BlockTime] = ArrayGetCell(g_BlockTime, item);
            if(strlen(plBlockInfo[id][BlockReason]))
                return GagInfoMenu(id);
            menu_display(id, g_ReasonMenu, 0);

            return PLUGIN_HANDLED;
        }
        case 'r':    //reason
        {
            switch(szData[1])
            {
                case 's':
                    return client_cmd(id,"messagemode cms_gag_reason");
                default:
                {
                    copy(plBlockInfo[id][BlockReason], charsmax(plBlockInfo[]), szName);
                    if(plBlockInfo[id][Created])
                        return GagInfoMenu(id)

                    menu_display(id, g_TypeMenu, 0)
                    return PLUGIN_HANDLED;
                }
            }
        }
        case 'b':    //type
        {
            plBlockInfo[id][BlockType] = item;
            return GagInfoMenu(id);
        }
    }
          
    return PLUGIN_HANDLED;
}

/*======== Меню игроков (админ) =========*/
public AdminPlayersMenu(id)
{
    if(!cmd_access(id, g_AccessLvl[1], gagmenuCMD, 0))
        return PLUGIN_HANDLED;

    arrayset(plBlockInfo[id], 0, BlockInfo);
      
    new g_MenuCallback = menu_makecallback("AdminPlayersMenu_callback");
    new PlayersMenu = menu_create("\yБлокировка чата", "AdminPlayersMenu_Handler", 1);

    new pID, szName[33], szAuthID[24], szFmtName[64], players[32], pnum;
    get_players(players, pnum, "ch");

    for (new i; i < pnum; i++)
    {
        pID = players[i];
        get_user_name(pID, szName, charsmax(szName));
        get_user_authid(pID, szAuthID, charsmax(szAuthID));

        formatex(szFmtName, charsmax(szFmtName), "\w%s%s%s", szName,
            TrieKeyExists(g_BlockedUsers, szAuthID) ? "\r[Blocked]" : "", id == pID ? "\r[Это Вы]" : "");

        menu_additem(PlayersMenu, szFmtName, get_id_key(pID), 0, g_MenuCallback);
    }

    menu_setprop(PlayersMenu, MPROP_BACKNAME, "\yНазад");
    menu_setprop(PlayersMenu, MPROP_NEXTNAME, "\yДалее");
    menu_setprop(PlayersMenu, MPROP_EXITNAME, "\yВыход");
    menu_display(id, PlayersMenu, 0);
  
    return PLUGIN_HANDLED;
}

public AdminPlayersMenu_callback(id, menu, item)
{
    new szData[3], item_callback, target;
    menu_item_getinfo(menu, item, item_access, szData, charsmax(szData),_,_, item_callback);

    target = str_to_num(szData);
    return allow_access(get_user_flags(id), get_user_flags(target)) || id == target ? ITEM_ENABLED : ITEM_DISABLED;
}

public AdminPlayersMenu_Handler(id, menu, item)
{
    if(item == MENU_EXIT)
    {
        arrayset(plBlockInfo[id], 0, BlockInfo);
        menu_destroy(menu);
        return PLUGIN_HANDLED;
    }

    new item_callback, szData[3];
    menu_item_getinfo(menu, item, item_access, szData, charsmax(szData), _, _, item_callback);

    plBlockInfo[id][targetID] = str_to_num(szData);
    get_user_name(plBlockInfo[id][targetID], plBlockInfo[id][Name], charsmax(plBlockInfo[]));
    get_user_authid(plBlockInfo[id][targetID], plBlockInfo[id][AuthId], charsmax(plBlockInfo[]));

    new aID2;
    if(g_API_allow)
        aID2 = get_AdminID(id);

    if(!TrieGetArray(g_BlockedUsers,  plBlockInfo[id][AuthId], plBlockInfo[id], charsmax(plBlockInfo[])))
    {
        if(id == plBlockInfo[id][targetID])
        {
            client_print_color(id, 0, "^4[%s] ^1Не нужно себя блокировать)", PREFIX);
            return PLUGIN_HANDLED;
        }

        plBlockInfo[id][AdminId] = aID2;
        menu_destroy(menu);
        menu_display(id, g_TimeMenu, 0);
        return PLUGIN_HANDLED;
    }

    if(g_API_allow)
    {
        new aID = plBlockInfo[id][AdminId];
        if(aID != aID2)
        {
            g_AdminInfo = get_admin_info(aID);
            if(g_AdminInfo)
            {
                TrieGetArray(g_AdminInfo, get_id_key(aID), adminData, sizeof adminData);
                plBlockInfo[id][ModifiedBlocked] = allow_access(get_user_flags(id), read_flags(adminData[AdminServiceFlags])) ? false : true;
            }
        }
    }

    menu_destroy(menu);
    GagInfoMenu(id);

    return PLUGIN_HANDLED;
}

/*======== Загрузка причины =========*/
public AddGagReason(id, level, cid)
{
    if(!cmd_access(id, level, cid, 0))
        return PLUGIN_HANDLED;
  
    new args[90];
    read_args(args, charsmax(args));
  
    remove_quotes(args);
    trim(args);
  
    if(!id)
    {
        if(args[0])
            menu_additem(g_ReasonMenu, args, "r", 0, g_StaticMenuCallback);
        return PLUGIN_CONTINUE;
    }

    if(!args[0])
        return menu_display(id, g_ReasonMenu, 0);

    copy(plBlockInfo[id][BlockReason], charsmax(plBlockInfo[]), args);
    return strlen(plBlockInfo[id][Created]) ? GagInfoMenu(id) : menu_display(id, g_TypeMenu, 0);
}

/*======== Меню сохранения / удаления блока =========*/
public GagInfoMenu(id)
{
    new tmpName[90];
    new tmpTypeNum = plBlockInfo[id][BlockType];
    new GagInfoMenu_callback = menu_makecallback("GagInfoMenu_callback");
    new existKey = TrieKeyExists(g_BlockedUsers, plBlockInfo[id][AuthId]);
    new GagInfoMenu = menu_create("\yИнформация^n\wВыберите пункт для изменения", "GagInfoMenu_Handler", 1); 
  
    if(!plBlockInfo[id][Created])
        plBlockInfo[id][Created] = get_systime();
    formatex(tmpName, charsmax(tmpName), "\yНик: \w%s %s", plBlockInfo[id][Name], existKey ? "\r[Blocked]" : "");
    menu_additem(GagInfoMenu, tmpName, "p", 0);
  
    formatex(tmpName, charsmax(tmpName), "\yВремя: \w%s", FormatBlockTime(plBlockInfo[id][BlockTime], 1));
    menu_additem(GagInfoMenu, tmpName, "t", 0, GagInfoMenu_callback);
  
    formatex(tmpName, charsmax(tmpName), "\yПричина: \w%s", plBlockInfo[id][BlockReason]);
    menu_additem(GagInfoMenu, tmpName, "r", 0, GagInfoMenu_callback);
  
    formatex(tmpName, charsmax(tmpName), "\yТип блокировки: \w%s", g_BlockType[tmpTypeNum]);
    menu_additem(GagInfoMenu, tmpName, "b", 0, GagInfoMenu_callback);
  
    if(existKey)
    {
        formatex(tmpName, charsmax(tmpName), "\rИстекает: \w%s", FormatBlockTime((plBlockInfo[id][Expired] - get_systime())/60, 2));
        menu_addtext(GagInfoMenu, tmpName, 0);
    }
    if(strlen(plBlockInfo[id][AdminNick]))
    {
        formatex(tmpName, charsmax(tmpName), "\rВыдал: \w%s", plBlockInfo[id][AdminNick]);
        menu_addtext(GagInfoMenu, tmpName, 0);
    }
    if(strlen(plBlockInfo[id][ModifiedBy]))
    {
        formatex(tmpName, charsmax(tmpName), "\rИзменил: \w%s", plBlockInfo[id][ModifiedBy]);
        menu_addtext(GagInfoMenu, tmpName, 0);
    }
    #if AMXX_VERSION_NUM < 183
        menu_addblank(GagInfoMenu, 0);
    #else
        menu_addblank2(GagInfoMenu);
    #endif
    menu_additem(GagInfoMenu, existKey ? "Сохранить" : "Заблокировать", "s", 0, GagInfoMenu_callback);
  
    if(existKey)
        menu_additem(GagInfoMenu, "Снять блокировку", "d", 0, GagInfoMenu_callback);
  
    menu_setprop(GagInfoMenu, MPROP_EXITNAME, "\yВыход");
    menu_setprop(GagInfoMenu, MPROP_EXIT, MEXIT_ALL);
    menu_display(id, GagInfoMenu, 0);
  
    return PLUGIN_HANDLED;
}

public GagInfoMenu_callback(id, menu, item)
    return (plBlockInfo[id][ModifiedBlocked] || get_activeBlock(id) != -1) ? ITEM_DISABLED : ITEM_ENABLED;

public GagInfoMenu_Handler(id, menu, item)
{
    if (item == MENU_EXIT)
    {
        arrayset(plBlockInfo[id], 0, BlockInfo);
        return menu_destroy(menu);
    }

    new item_callback, szData[7], szName[33];
    menu_item_getinfo(menu, item, item_access, szData, charsmax(szData), szName, charsmax(szName), item_callback);
  
    switch(szData[0])
    {
        case 't':    menu_display(id, g_TimeMenu, 0);    //time
        case 'r':    menu_display(id, g_ReasonMenu, 0);    //reason
        case 'b':    menu_display(id, g_TypeMenu, 0);    //type
        case 'p':    AdminPlayersMenu(id);                //players menu
        case 's':    BlockQueryFunc(id, 1, 0, "", 0);            //add/ save block
        case 'd':    BlockQueryFunc(id, 2, 0, "", 0);            //remove block
    }

    menu_destroy(menu);
    return PLUGIN_HANDLED;
}

/*======== Меню игроков (игрок) =========*/
public MuteMenu(id)
{
    new g_MuteMenuCB = menu_makecallback("MuteMenu_callback");
    new PlayersMenu = menu_create("\yЗаглушить игрока", "MuteMenu_Handler", 1);

    new pID, szpID[3], players[32], pnum;
    get_players(players, pnum, "ch");
  
    for (new i; i < pnum; i++)
    {
        pID = players[i];
        if(id == pID)
            continue;

        num_to_str(pID, szpID, charsmax(szpID));
        menu_additem(PlayersMenu, "", szpID, 0, g_MuteMenuCB);
    }

    menu_setprop(PlayersMenu, MPROP_BACKNAME, "\yНазад");
    menu_setprop(PlayersMenu, MPROP_NEXTNAME, "\yДалее");
    menu_setprop(PlayersMenu, MPROP_EXITNAME, "\yВыход");

    menu_display(id, PlayersMenu, 0);
    return PLUGIN_HANDLED;
}

public MuteMenu_callback(id, menu, item)
{
    new szData[3], callback, pID, szName[33], szFmtName[64];
    menu_item_getinfo(menu, item, item_access, szData, charsmax(szData),_,_, callback);

    pID = str_to_num(szData);
    get_user_name(pID, szName, charsmax(szName));

    formatex(szFmtName, charsmax(szFmtName), "\w%s%s", szName,
        GetBit(g_bBlocked, pID) ? "\r[Blocked by Admin]" :
            GetBit(g_Muted[id], pID) ? "\r[Muted]" : "");
                  
    menu_item_setname(menu, item, szFmtName);
    return GetBit(g_bBlocked, pID) ? ITEM_DISABLED : ITEM_IGNORE;
}

public MuteMenu_Handler(id, menu, item)
{
    if (item == MENU_EXIT)
    {
        menu_destroy(menu);
        return PLUGIN_HANDLED;
    }

    new item_callback, szData[7];
    menu_item_getinfo(menu, item, item_access, szData, charsmax(szData), _, _, item_callback);
  
    new pID = str_to_num(szData);
    new szName[33];
    get_user_name(pID, szName, charsmax(szName));
  
    if(!is_user_connected(pID))
    {
        client_print_color(id, 0, "^4[%s] ^1Игрок ^3%s ^1вышел с сервера", PREFIX, szName);
        return PLUGIN_HANDLED;
    }

    if(!GetBit(g_Muted[id], pID))
    {
        if(GetBit(g_bBlocked, pID))
        {
            client_print_color(id, 0, "^4[%s] Ошибка! ^1Вероятно, игрок уже заблокирован администратором.", PREFIX);
            menu_destroy(menu);
            return MuteMenu(id);
        }

        SetBit(g_Muted[id], pID);
    }
    else
        ResetBit(g_Muted[id], pID);

    client_print_color(id, 0, "^4[%s] ^1Вы %s ^4mute ^1%s игрока ^3%s", PREFIX, GetBit(g_Muted[id], pID) ? "установили" : "сняли",
        GetBit(g_Muted[id], pID) ? "на" : "с", szName);
  
    new imenu, newmenu, menupage;
    player_menu_info(id, imenu, newmenu, menupage);
  
    menu_display(id, menu, menupage);
    return PLUGIN_HANDLED;
}

public client_putinserver(id)
{
    if(is_user_bot(id) || is_user_hltv(id))
        return;

    g_ImmunLevel[id] = get_immunity_level(get_user_flags(id))
    ExistBlockQuery(id);
}

public client_disconnect(id)
{
    ResetBlockFunc(id);
    g_isAlivePlayer[id] = false;
    ResetBit(g_bTeamVoice, id);
    g_Muted[id] = 0;
    for (new i = 1; i < MAX_PLAYERS; i++)
    {
        if(id == i)
            continue;
        ResetBit(g_Muted[i], id)
    }
}

/*======== Получение данных из БД =========*/
public ExistBlockQuery(id)
{
    static steamID[24];
    get_user_authid(id, steamID,  charsmax(steamID));
  
    if(TrieGetArray(g_BlockedUsers,  steamID, plBlockInfo[id], charsmax(plBlockInfo[])))
    {
        ChangeBlockFunc(id, plBlockInfo[id][BlockType]);
        return;
    }

    if(!g_API_allow)
        return;

    static exist[210]
    formatex(exist, charsmax(exist), "SELECT * FROM `%s` WHERE `server_id` = '%d' AND `authid` = '%s'\
    AND ((`expired` > UNIX_TIMESTAMP(NOW()) OR `expired` = '0' ) AND `length` != '-1' AND `expired` != '-1') LIMIT 1;",
    sqlTable, serverID, steamID);

    static Data[2];    Data[0] = id;
    SQL_ThreadQuery(g_SqlX, "ExistBlockQuery_post", exist, Data, sizeof(Data));
}

public ExistBlockQuery_post(failstate, Handle:query, const error[], errornum, const postData[], DataSize)
{
    if(SQL_Error(error, errornum, failstate))
        return;

    if(!SQL_NumResults(query))
        return;
  
    static id; id = postData[0];

    plBlockInfo[id][bid] = SQL_ReadResult(query, SQL_FieldNameToNum(query, "bid"));
    plBlockInfo[id][BlockType] = SQL_ReadResult(query, SQL_FieldNameToNum(query, "type"));
    plBlockInfo[id][Expired] = SQL_ReadResult(query, SQL_FieldNameToNum(query, "expired"));
    plBlockInfo[id][Created] = SQL_ReadResult(query, SQL_FieldNameToNum(query, "created"));
    plBlockInfo[id][BlockTime] = SQL_ReadResult(query, SQL_FieldNameToNum(query, "length"));
    plBlockInfo[id][AdminId] = SQL_ReadResult(query, SQL_FieldNameToNum(query, "admin_id"));
      
    SQL_ReadResult(query, SQL_FieldNameToNum(query, "authid"), plBlockInfo[id][AuthId], charsmax(plBlockInfo[][AuthId]));
    SQL_ReadResult(query, SQL_FieldNameToNum(query, "name"), plBlockInfo[id][Name], charsmax(plBlockInfo[][Name]));
    SQL_ReadResult(query, SQL_FieldNameToNum(query, "reason"), plBlockInfo[id][BlockReason], charsmax(plBlockInfo[][BlockReason]));
    SQL_ReadResult(query, SQL_FieldNameToNum(query, "admin_nick"), plBlockInfo[id][AdminNick], charsmax(plBlockInfo[][AdminNick]));
    SQL_ReadResult(query, SQL_FieldNameToNum(query, "modified_by"), plBlockInfo[id][ModifiedBy], charsmax(plBlockInfo[][ModifiedBy]));

    mysql_escape_string(plBlockInfo[id][Name], charsmax(plBlockInfo[][Name]));
    mysql_escape_string(plBlockInfo[id][BlockReason], charsmax(plBlockInfo[][BlockReason]));
    mysql_escape_string(plBlockInfo[id][AdminNick], charsmax(plBlockInfo[][AdminNick]));
    mysql_escape_string(plBlockInfo[id][ModifiedBy], charsmax(plBlockInfo[][ModifiedBy]));
          
    if(TrieSetArray(g_BlockedUsers,  plBlockInfo[id][AuthId], plBlockInfo[id], sizeof(plBlockInfo[])))
        ChangeBlockFunc(id, plBlockInfo[id][BlockType])
}

/*======== Запрос на сохранение блока =========*/
/*
id- client index
typeFunc - тип операции блокировки(1- создание, 2- удаление)
blType - тип блока (чат / голос)
blReason - причина
blTime - время

pID - target index
**При автоматических операциях id = pID
*/
public BlockQueryFunc(id, typeFunc, const blType, const blReason[], const blTime)
{
    new pID = plBlockInfo[id][targetID];
    if(!pID)
        pID = id;
    new bool:exist = TrieKeyExists(g_BlockedUsers,  plBlockInfo[id][AuthId]);
    if(plBlockInfo[id][BlockTime] == 0)
        plBlockInfo[id][BlockTime] = blTime;
    new tmpTime = plBlockInfo[id][BlockTime];
    new systime = get_systime(), timeleft = get_timeleft();
  
    if(!strlen(plBlockInfo[id][Name]))
    {
        new szName[33];
        get_user_name(pID, szName, charsmax(szName));
        copy(plBlockInfo[id][Name], charsmax(plBlockInfo[][Name]), szName);
    }
    if(!strlen(plBlockInfo[id][BlockReason]))
        copy(plBlockInfo[id][BlockReason], charsmax(plBlockInfo[][BlockReason]), blReason);
  
    plBlockInfo[id][Created] = systime;
    get_user_authid(pID, plBlockInfo[id][AuthId], charsmax(plBlockInfo[][AuthId]));
  
    if(blType)
        plBlockInfo[id][BlockType] = blType;

    switch(typeFunc)
    {
        case 1:
        {
            plBlockInfo[id][Expired] = tmpTime > 0 ?
                plBlockInfo[id][Created] + tmpTime*60 : tmpTime == 0 ?
                    0 : plBlockInfo[id][Created] + timeleft;
        }
        case 2: plBlockInfo[id][Expired] = -1;
    }

    if(!exist)
    {
        get_user_name(id, plBlockInfo[id][AdminNick], charsmax(plBlockInfo[][AdminNick]));
        if(pID == id)
            plBlockInfo[id][AdminNick] = "Сервер";
    }
    else
    {
        if(g_AddLastId == pID && systime < g_AddTime + 20)
            return client_print_color(id, 0, "^4[%s] Ошибка! ^1Возможно, игрок редактируется другим администратором.", PREFIX);
        get_user_name(id, plBlockInfo[id][ModifiedBy], charsmax(plBlockInfo[][ModifiedBy]));
    }
  
    if(g_API_allow)    //Запись в бд, если она доступна
    {
        mysql_insert_string(plBlockInfo[id][Name], charsmax(plBlockInfo[][Name]));
        mysql_insert_string(plBlockInfo[id][BlockReason], charsmax(plBlockInfo[][BlockReason]));
        mysql_insert_string(plBlockInfo[id][AdminNick], charsmax(plBlockInfo[][AdminNick]));
        mysql_insert_string(plBlockInfo[id][ModifiedBy], charsmax(plBlockInfo[][ModifiedBy]));
      
        static inQuery[460];
        if(plBlockInfo[id][bid])
        {
            formatex(inQuery, charsmax(inQuery),
            "SET NAMES `utf8`; UPDATE `%s` SET expired='%d', length='%d', reason='%s', modified_by='%s', type='%d' WHERE `bid` = '%d';",
            sqlTable, plBlockInfo[id][Expired], tmpTime, plBlockInfo[id][BlockReason],
            plBlockInfo[id][ModifiedBy], plBlockInfo[id][BlockType], plBlockInfo[id][bid]);
            exist = true;
        }
        else
        {
            if(((timeleft/60) < tmpTime || tmpTime == 0) && typeFunc != 2)    //Запись в бд, если время блока больше времени карты или Навсегда
            {
                formatex(inQuery, charsmax(inQuery),
                "SET NAMES `utf8`; INSERT DELAYED INTO `%s` (bid, authid, name, created, expired, length, reason, admin_id, admin_nick, server_id, modified_by, type) \
                values ('%d', '%s', '%s', '%d', '%d', '%d', '%s', '%d', '%s', '%d', '%s', '%d');",
                sqlTable, plBlockInfo[id][bid], plBlockInfo[id][AuthId], plBlockInfo[id][Name], plBlockInfo[id][Created],
                plBlockInfo[id][Expired], tmpTime, plBlockInfo[id][BlockReason],
                plBlockInfo[id][AdminId], plBlockInfo[id][AdminNick], serverID, plBlockInfo[id][ModifiedBy], plBlockInfo[id][BlockType]);
                exist = false;
            }
            else
                return ASD_BlockFunc(id, exist, pID, typeFunc);
        }

        static Data[4];
        Data[0] = id;
        Data[1] = exist;
        Data[2] = pID;
        Data[3] = typeFunc;

        return SQL_ThreadQuery(g_SqlX, "BlockQueryFunc_post", inQuery, Data, sizeof(Data));
    }

    if(plBlockInfo[id][Expired]- systime < timeleft/60)
        plBlockInfo[id][Expired] = -1;

    return ASD_BlockFunc(id, exist, pID, typeFunc);
}

public BlockQueryFunc_post(failstate, Handle:query, const error[], errornum, const postData[], DataSize)
{
    new id, bool:typeQuery, target, typeFunc;
    id = postData[0];
    typeQuery = bool:postData[1];
    target = postData[2];
    typeFunc = postData[3];
  
    if(SQL_Error(error, errornum, failstate))
    {
        plBlockInfo[id][BlockTime] = -1;
        return ASD_BlockFunc(id, typeQuery, target, typeFunc);
    }

    if(!typeQuery && typeFunc != 2)    //если не удаление
        plBlockInfo[id][bid] = SQL_GetInsertId(query);

    return ASD_BlockFunc(id, typeQuery, target, typeFunc);
}

public FwdPlayerSpawn(id)
{
    g_PlayerTeam[id] = get_pdata_int(id, 114, 5);
    if(is_user_alive(id))
        g_isAlivePlayer[id] = true;
}

public FwdPlayerKilled(id)
{
    #if defined INFA_LOL
        set_task(INFA_LOL, "BlockForKilled", id);
    #else
        BlockForKilled(id);
    #endif
}

public BlockForKilled(id)
{
    g_isAlivePlayer[id] = false;
    if(cv_LocAllTalk)
        return
  
    set_hudmessage(255, 150, 0, -1.0, 0.63, 0, _, 5.0);
    show_hudmessage(id, "Живые товарищи по команде Вас больше не слышат");
}

public Team_VoiceOn(id)
{
    SetBit(g_bTeamVoice, id);
    client_cmd(id, "+voicerecord");
    return PLUGIN_HANDLED;
}

public Team_VoiceOff(id)
{
    ResetBit(g_bTeamVoice, id);
    client_cmd(id, "-voicerecord");
    return PLUGIN_HANDLED;
}

public VTC_OnClientStartSpeak(sender)
{
    if(VTC_IsClientMuted(sender))
        return CheckBlock(sender, 2)

    //if(!g_isAlivePlayer[sender] && g_ImmunLevel[sender] > 1 && (GetBit(g_bTeamVoice, sender) || cv_DeadAdmTalk))
    //    return is_user_connected(sender) ? set_speak(sender, SPEAK_ALL) : PLUGIN_HANDLED;

    if(!cv_AllTalk)
        return PLUGIN_CONTINUE;
  
    ++actfwd 
    if(actfwd && !fwd)
        fwd = register_forward(FM_Voice_SetClientListening, "FwdSetClientListening", false);
  
    return PLUGIN_CONTINUE;
}

public VTC_OnClientStopSpeak(sender)
{
    //if(is_user_connected(sender))
        //if(get_speak(sender) != SPEAK_NORMAL)
            //return set_speak(sender, SPEAK_NORMAL)
  
    --actfwd
    if(!actfwd && fwd)
    {
        unregister_forward(FM_Voice_SetClientListening, fwd);
        fwd = 0;
    }
      
    return PLUGIN_CONTINUE;
}

public FwdSetClientListening(Receiver, Sender, bool:Listen)
{
    if(Receiver == Sender)
        return FMRES_IGNORED;
  
    if(!g_isAlivePlayer[Sender] && g_ImmunLevel[Sender] > 1 && (GetBit(g_bTeamVoice, Sender) || cv_DeadAdmTalk))
        return FMRES_IGNORED;
  
    if(!GetBit(g_Muted[Receiver], Sender))
    {
        if(cv_LocAllTalk || !g_isAlivePlayer[Receiver])
            return FMRES_IGNORED;

        if(g_isAlivePlayer[Sender] && g_isAlivePlayer[Receiver])
        {
            if(!GetBit(g_bTeamVoice, Sender))
                return FMRES_IGNORED;

            if(g_PlayerTeam[Receiver] == g_PlayerTeam[Sender])
                return FMRES_IGNORED;
        }
    }

    engfunc(EngFunc_SetClientListening, Receiver, Sender, false);
    forward_return(FMV_CELL, false);

    return FMRES_SUPERCEDE;
}

public HookSayChat(id)
{
    new szMsg[128];
    read_args(szMsg, charsmax(szMsg));
    remove_quotes(szMsg);
  
    if(TrieKeyExists(g_WhiteListCmdArray, szMsg))
        return PLUGIN_CONTINUE;

    if(get_activeBlock(id) != -1)
        return CheckBlock(id, 1);
  
    return PLUGIN_CONTINUE;
}

stock CheckBlock(id, type)
{
    new steamID[24];
    get_user_authid(id, steamID,  charsmax(steamID));
    if(TrieGetArray(g_BlockedUsers,  steamID, plBlockInfo[id], charsmax(plBlockInfo[])))
    {
        if(plBlockInfo[id][Expired] > get_systime() || plBlockInfo[id][Expired] <= 0)
        {
            new chat = get_activeBlock(id);
            switch(chat)
            {
                case 0, 1: client_print_color(id, 0, "^4[%s] ^1Ваш чат заблокирован на ^4[%s]^1. Причина: ^3[%s]",
                    PREFIX, FormatBlockTime(plBlockInfo[id][BlockTime], 1), plBlockInfo[id][BlockReason]);
                case 2:
                {
                    if(type == 2)
                        client_print_color(id, 0, "^4[%s] ^1Ваш голосовой чат заблокирован на ^4[%s]^1. Причина: ^3[%s]",
                            PREFIX, FormatBlockTime(plBlockInfo[id][BlockTime], 1), plBlockInfo[id][BlockReason]);
                }
            }

            VTC_PlaySound(id, soundFilePath);
            return chat == 2 ? PLUGIN_CONTINUE : PLUGIN_HANDLED;
        }
        else
            RemoveBlock(id);
    }

    return PLUGIN_CONTINUE;
}

#if defined ST_CHAT
public CheckSayText(MsgID, MsgDEST, MsgENT)
{
    if(MsgDEST != MSG_ONE)
        return PLUGIN_HANDLED;

    new id = get_msg_arg_int(1);
    if(is_MutedBy(MsgENT, id))
        return PLUGIN_HANDLED;

    return PLUGIN_CONTINUE;
}
#endif

/*======== Создание/Сохранение/Удаление блока =========*/
stock ASD_BlockFunc(id, bool:addType, pID, funcType)
{
    if(funcType == 2)
        return RemoveBlock(id);

    if(TrieSetArray(g_BlockedUsers,  plBlockInfo[id][AuthId], plBlockInfo[id], sizeof(plBlockInfo[])))
    {
        new tmpType = plBlockInfo[id][BlockType];
        new szTime[51];
        copy(szTime, charsmax(szTime), FormatBlockTime(plBlockInfo[id][BlockTime], 1));

        switch(addType)
        {
            case false:
            {
                client_print_color(0, 0, "^4[%s] ^1Игроку ^3[%s] ^1заблокирован ^4[%s] ^1на ^4[%s]^1. Причина: ^3[%s]",
                    PREFIX, plBlockInfo[id][Name], g_BlockType[tmpType], szTime, plBlockInfo[id][BlockReason]);
                log_amx("Игроку [%s] заблокирован [%s] на [%s]. Причина: [%s]",
                    plBlockInfo[id][Name], g_BlockType[tmpType], szTime, plBlockInfo[id][BlockReason]);
            }
            case true:
            {
                client_print_color(id, 0, "^4[%s] ^1Игроку ^4[%s] ^1изменена блокировка: ^4[%s] ^1на ^4[%s]",
                    PREFIX, plBlockInfo[id][Name], g_BlockType[tmpType], szTime);
                log_amx("Игроку [%s] изменена блокировка: [%s] на [%s]", plBlockInfo[id][Name], g_BlockType[tmpType], szTime);
            }
        }

        if(is_user_connected(pID))     
            ChangeBlockFunc(pID, tmpType);
              
        g_AddTime = plBlockInfo[id][Created];
        g_AddLastId = pID;

    }
    else
        log_amx("ASD_BlockFunc: Error");

    arrayset(plBlockInfo[id], 0, BlockInfo);
    return PLUGIN_HANDLED;
}

/*======== Сброс блока =========*/
stock ResetBlockFunc(pID)
{
    ResetBit(g_bBlocked, pID);
    ResetBit(g_bBlockChat, pID);
    ResetBit(g_bBlockVoice, pID);
  
    //VTC_UnmuteClient(pID);
} 

/*======== Изменение блока =========*/
stock ChangeBlockFunc(pID, Type)
{
    ResetBit(g_bBlocked, pID);
    ResetBit(g_bBlockChat, pID);
    ResetBit(g_bBlockVoice, pID);
    VTC_UnmuteClient(pID);

    switch(Type)
    {
        case 0:
        {
            SetBit(g_bBlocked, pID);
            VTC_MuteClient(pID);
        }
        case 1: SetBit(g_bBlockChat, pID);
        case 2:
        {
            SetBit(g_bBlockVoice, pID);
            VTC_MuteClient(pID);
        }
    }
}

/*======== Удаление блока =========*/     
stock RemoveBlock(id)
{
    new player = find_player("c", plBlockInfo[id][AuthId])
    if(TrieDeleteKey(g_BlockedUsers, plBlockInfo[id][AuthId]))
    {
        new type[34]
        copy(type, charsmax(type), g_BlockType[plBlockInfo[id][BlockType]])
        client_print_color(0, 0, "^4[%s] ^1С игрока ^4%s ^1снята блокировка ^4[%s]", PREFIX, plBlockInfo[id][Name], type);
        log_amx("С игрока %s снята блокировка [%s]", plBlockInfo[id][Name], type);
        arrayset(plBlockInfo[id], 0, BlockInfo);
        ResetBlockFunc(player);
        VTC_UnmuteClient(player);
    }
    else
        log_amx("RemoveBlock: Error");

    return PLUGIN_CONTINUE;
}

/*======== Стоки / нативы =========*/
stock allow_access(flags_id, flags_target)
{
    return get_immunity_level(flags_id) >
        get_immunity_level(flags_target) ? 1 : 0;
}
  
stock get_immunity_level(flags)
{
    return flags & g_AccessLvl[3] ?
        3 : flags & g_AccessLvl[2] ?
            2 : flags & g_AccessLvl[1] ?
                1 : 0;
}

stock FormatBlockTime(iTime, type)
{
    new Time[50];
    if(iTime < 0)
        Time = type == 1 ? "На карту" : "В конце карты";
    else if(iTime == 0)
    {
        switch(type)
        {
            case 1: Time = "Навсегда";
            case 2: Time = "Никогда";
        }
    }
    else 
        get_time_length(0, iTime, 1, Time, charsmax(Time));

    return Time;
}

public plugin_end()
if(g_BlockTime)
    ArrayDestroy(g_BlockTime);

public plugin_natives()
{
    set_native_filter("native_filter");
    register_native("get_activeBlock", "native_get_activeBlock");
    register_native("is_MutedBy", "native_is_MutedBy");
}

public native_filter(const name[], index, trap)
    return !trap ? PLUGIN_HANDLED : PLUGIN_CONTINUE;

/*
    Проверка текущего блока от Админа
    @index - индекс игрока
    0-    voice + chat
    1-    chat
    2-    voice
    -1- not blocked
*/
public native_get_activeBlock()
{
    new id = get_param(1)
    return GetBit(g_bBlocked, id) ?
        0 : GetBit(g_bBlockChat, id) ?
            1 : GetBit(g_bBlockVoice, id) ?
                2 : -1;
}

/*
    Проверка текущего блока от игрока
    @sender - индекс отправителя
    @receiver - индекс получателя
*/
public native_is_MutedBy()
{
    return GetBit(g_Muted[get_param(1)], get_param(2));
}
 
Последнее редактирование:
alan191, Включить квар cms_gag_alltalk.
Тогда, будет установлено разделение чата в соответствии с настройками движка. Т.е., насколько помню, sv_alltalk нужен "1".
Плагин всегда имел возможность работы без движка. Не вижу проблем в использовании последней версии.
 
Тогда, будет установлено разделение чата в соответствии с настройками движка.
Добавлено:

zhorzh78, Т.е., если можно разговаривать, то будут. Нет- нет.
 
Назад
Сверху