Вырезать лишний функционал плагина

Yooki

Yooki

Добрая душа
Сообщения
473
Реакции
169
Привет всем!
Есть такой плагин Knife Dozor, в новой версии плагина еще не добавили функцию для проверки рейтов игроков и проверку на knife bot (не так важно).
Может кто помочь вырезать из старой версии плагина все, кроме проверки на рейты (!rates) и проверку на knife bot(!kb)? Мб за плату?
У меня не получилось оставить нужный функционал, выдавало в консоли пару ошибок и предупреждений.
PHP: 
#pragma semicolon 1

#include <sourcemod>
#include <cstrike>
#include <adminmenu>
#include <sdkhooks>
#include <sdktools>

#define PLUGIN_VERSION "v1.0.6"

new ID,
    OffsetCollision,
    g_AFKwarnings[MAXPLAYERS+1],
    g_LastItem[MAXPLAYERS+1],
    g_TargetId[MAXPLAYERS+1],
    ClientTeam[MAXPLAYERS+1],
    Float:g_iAfkStartPositions[MAXPLAYERS+1][3],
    Float:g_iMyStartPositions[MAXPLAYERS+1][3],
    Float:g_iKillTimeVictim[MAXPLAYERS+1],
    Float:g_iPositionNow[MAXPLAYERS+1][3],  
    Float:AdminOldPos[MAXPLAYERS+1][3],
    Float:g_iParavozTimeProtect = 1.3,
    Float:g_fRemoveRadgollDelay,
    Float:g_fRespawnDelay,
    Float:g_fProtectTime,
    Handle:g_iActiveCollision = INVALID_HANDLE,
    Handle:g_iActiveFixer35hp = INVALID_HANDLE,  
    Handle:g_iActiveBlockBack = INVALID_HANDLE,
    Handle:g_iActiveBlockParo = INVALID_HANDLE,
    Handle:g_iActiveBlockTolp = INVALID_HANDLE,
    Handle:g_iActiveColorAFK = INVALID_HANDLE,
    Handle:g_iActiveColorPar = INVALID_HANDLE,
    Handle:g_iActiveKnifeDM = INVALID_HANDLE,
    Handle:Timer_Respawn[MAXPLAYERS+1] = {INVALID_HANDLE, ... },
    Handle:Timer_Protect[MAXPLAYERS+1] = {INVALID_HANDLE, ... },
    Handle:g_hPanel[MAXPLAYERS + 1] = {INVALID_HANDLE, ...},
    Handle:g_hTimer[MAXPLAYERS + 1] = {INVALID_HANDLE, ...},  
    Handle:g_iCheckAfkTimer[MAXPLAYERS+1],
    Handle:g_iRespawnTimer[MAXPLAYERS+1],
    Handle:g_iProtectTimer[MAXPLAYERS+1],
    bool:g_MyAFKprotectOn[MAXPLAYERS+1],
    bool:no_need_more[MAXPLAYERS + 1],
    bool:g_bRemoveRadgoll,
    String:Antiparavoz_sound[] = "resource/warning.wav",
    String:sClientVar[][] =
{
    "rate",
    "cl_cmdrate",
    "cl_updaterate",
    "cl_interp",
    "cl_interp_ratio",
    "cl_interpolate",
    "cl_interp_npcs",
    "cl_interp_all",
    "cl_lagcompensation",
    "cl_allowdownload",
    "cl_allowupload",
    "fps_max",
    "net_graph",
    "cl_pred_optimize",
    "cl_resend",
    "cl_smoothtime",
    "cl_smooth"
};


//============================================================================//


public Plugin:myinfo =
{
    name = "Knife Dozor",
    author = "RoadSide Romeo",
    version = PLUGIN_VERSION
};

public OnPluginStart()
{
    CreateConVar("sm_knife_dozor", PLUGIN_VERSION, "Knife Dozor Version", FCVAR_PLUGIN|FCVAR_SPONLY|FCVAR_REPLICATED|FCVAR_NOTIFY);  
  
    g_iActiveCollision = CreateConVar("kd_collision_off", "0", "включить/выключить столкновения между игроками");
    g_iActiveFixer35hp = CreateConVar("kd_fixer35hp_enable", "1", "включить/выключить выдачу 35хп при респавне");
    g_iActiveBlockBack = CreateConVar("kd_blockback", "1", "включить/выключить защиту спины игрокам");
    g_iActiveBlockParo = CreateConVar("kd_blockparovoz", "1", "включить/выключить защиту от паровоза игрокам");
    g_iActiveBlockTolp = CreateConVar("kd_blocktolpa", "0", "включить/выключить защиту от толпы игрокам");
    g_iActiveColorAFK = CreateConVar("kd_colorafk", "1", "включить/выключить перекрашивание АФК в зелёный цвет");
    g_iActiveColorPar = CreateConVar("kd_colorparovoz", "1", "включить/выключить перекрашивание игрока защищенного от паровоза в красный цвет");  
    g_iActiveKnifeDM = CreateConVar("kd_knifedm_enable", "0", "включить/выключить КНАЙФ ДМ режим");

    new Handle:hCvar;  
    HookConVarChange((hCvar = CreateConVar("kd_knifedm_respawn_delay", "1.0", "Через сколько секунд после смерти игрок возродится.")), OnRespawnDelayChange);     g_fRespawnDelay = GetConVarFloat(hCvar);
    HookConVarChange((hCvar = CreateConVar("kd_knifedm_protect_time", "1.0", "Сколько секунд длится защита игрока при возрождении.")), OnProtectTimeChange);    g_fProtectTime = GetConVarFloat(hCvar);
    HookConVarChange((hCvar = CreateConVar("kd_knifedm_remove_radgoll", "1", "Удалять ли трупы после смерти.")), OnRemoveRadgollChange);    g_bRemoveRadgoll = GetConVarBool(hCvar);
    HookConVarChange((hCvar = CreateConVar("kd_knifedm_remove_radgoll_delay", "1.0", "Через сколько секунд после смерти удалять труп.")), OnRemoveRadgollDelayChange);    g_fRemoveRadgollDelay = GetConVarFloat(hCvar);
    CloseHandle(hCvar);
  
    AutoExecConfig(true, "knife_dozor");
  
    HookConVarChange(g_iActiveBlockTolp, Enable_Disable_BlockTolpa);
    HookEvent("player_hurt", ProtectClient, EventHookMode_Pre);  
    HookEvent("player_spawn", SpawnClient, EventHookMode_Post);
    HookEvent("player_death", DeathClient);
    HookEvent("player_team", PlayerTeam);  

    RegAdminCmd("sm_rates", CheckManyRates, ADMFLAG_BAN);
    RegAdminCmd("sm_knifebot", Knifebot, ADMFLAG_BAN);

    OffsetCollision = FindSendPropOffs("CBaseEntity", "m_CollisionGroup");
  
    if(OffsetCollision == -1)
    {
        SetFailState("[KD] Failed to get OFFSet");
    }
}

public OnMapStart()
{
    PrecacheSound(Antiparavoz_sound, true);
}

public OnRespawnDelayChange(Handle:hCvar, const String:oldValue[], const String:newValue[])            g_fRespawnDelay = GetConVarFloat(hCvar);
public OnProtectTimeChange(Handle:hCvar, const String:oldValue[], const String:newValue[])            g_fProtectTime = GetConVarFloat(hCvar);
public OnRemoveRadgollChange(Handle:hCvar, const String:oldValue[], const String:newValue[])        g_bRemoveRadgoll = GetConVarBool(hCvar);
public OnRemoveRadgollDelayChange(Handle:hCvar, const String:oldValue[], const String:newValue[])    g_fRemoveRadgollDelay = GetConVarFloat(hCvar);
public Enable_Disable_BlockTolpa(Handle:hCvar, const String:oldValue[], const String:newValue[])
{
    if(GetConVarBool(hCvar))
    {
        for(new i = 1; i <= MaxClients; i++)
        {
            if(IsClientInGame(i))
            {
                SDKHook(i, SDKHook_PostThinkPost, OnPostThinkPost);
            }
        }
    }
    else
    {
        for(new i = 1; i <= MaxClients; i++)
        {
            SDKUnhook(i, SDKHook_PostThinkPost, OnPostThinkPost);
        }
    }
}

public OnClientConnected(client)
{
    g_LastItem[client] = 0;
}

public Action:OnPlayerRunCmd(client, &buttons, &impulse, Float:vel[3], Float:angles[3], &weapon)
{
    // Отключение защиты игрока, когда перестал быть АФК
    if (!no_need_more[client])
    {
        if ((buttons & IN_MOVELEFT)|(buttons & IN_MOVERIGHT)|(buttons & IN_BACK)|(buttons & IN_FORWARD))
        {
            no_need_more[client] = true;
            g_MyAFKprotectOn[client] = false;
          
            if(GetConVarBool(g_iActiveColorAFK) && !GetConVarBool(g_iActiveKnifeDM))
            {
                SetPlayerColor(client, 255, 255, 255, 255);
            }
        }
    }
    return Plugin_Continue;
}

public OnPostThinkPost(client)
{
    if(IsPlayerAlive(client))
    {
        GetClientAbsOrigin(client, g_iPositionNow[client]);
        static i, bool:respawn;
      
        for(i = respawn = true; i <= MaxClients; i++)
        {
            if(IsClientInGame(i) && IsPlayerAlive(i) && ClientTeam[client] != ClientTeam[i] && GetVectorDistance(g_iPositionNow[client], g_iPositionNow[i]) < 150)
            {
                if(respawn) respawn = false;
                else
                {
                    respawn = true;
                    CS_RespawnPlayer(i);
                    PrintCenterText(i, "[KD] Не нападай толпой!!!");
                }
            }
        }
    }
}

SetPlayerColor(client, r, g, b, a)
{
    SetEntityRenderMode(client, RENDER_TRANSCOLOR);
    SetEntityRenderColor(client, r, g, b, a);
}

/*//============================================================================//
ProtectGamer
*///============================================================================//

public Action:ProtectClient( Handle:event, const String:name[], bool:dontBroadcast )
{
    decl Float:GameTime, Float:origin[3];
    GameTime    = GetGameTime();

    new victim = GetClientOfUserId( GetEventInt( event, "userid" ) );
    new attacker = GetClientOfUserId( GetEventInt( event, "attacker" ) );
  
    decl String:weapon[64];
    GetEventString(event, "weapon", weapon, sizeof(weapon));
  
    if(StrEqual(weapon, "knife") || StrEqual(weapon, "knifegg"))
    {
        new Float:attacker_angles[3], Float:victim_angles[3], Float:back_angles[3];
  
        GetClientAbsAngles( victim, victim_angles );
        GetClientAbsAngles( attacker, attacker_angles );
  
        MakeVectorFromPoints( victim_angles, attacker_angles, back_angles );

        // Защита спины
        if(back_angles[1] > -90.0 && back_angles[1] < 90.0 && GetConVarBool(g_iActiveBlockBack))
        {
            EmitSoundToClient(attacker, Antiparavoz_sound);
            PrintCenterText(attacker, "[KD] Не бей в спину!");
            CS_RespawnPlayer(victim);
        }
      
        // Защита от паровоза
        if(((GameTime - g_iKillTimeVictim[victim]) < g_iParavozTimeProtect) && GetConVarBool(g_iActiveBlockParo))
        {
            CS_RespawnPlayer(attacker);
            SetEntProp(victim, Prop_Data, "m_iHealth", 35);      
            PrintCenterText(attacker, "[KD] Не паровозь!");
            EmitSoundToClient(attacker, Antiparavoz_sound);
        }      
    }
  
    // Защита АФК игроков
    if(g_MyAFKprotectOn[victim])
    {
        GetClientAbsOrigin(victim, origin);
        if (origin[0] == g_iMyStartPositions[victim][0] && origin[1] == g_iMyStartPositions[victim][1])
        {
            new victim_team = GetClientTeam(victim);
            for (new i = 1; i <= MaxClients; i++)
            {
                if (i != victim && IsClientInGame(i) && IsPlayerAlive(i) && GetClientTeam(i) == victim_team && !g_MyAFKprotectOn[i] )
                {
                    SetEntProp(victim, Prop_Data, "m_iHealth", 35);
                    return Plugin_Continue;
                }
            }
        }
        g_MyAFKprotectOn[victim] = false;
    }

    if (g_MyAFKprotectOn[attacker])
    {
        g_MyAFKprotectOn[attacker] = false;

        GetClientAbsOrigin(attacker, origin);
        if (origin[0] == g_iMyStartPositions[attacker][0] && origin[1] == g_iMyStartPositions[attacker][1])
        {
            SetEntProp(victim, Prop_Data, "m_iHealth", 35);
            return Plugin_Continue;
        }
    }

    if (GetEventInt(event, "health") < 1) g_iKillTimeVictim[attacker] = GameTime;
  
    return Plugin_Continue;
}

public SpawnClient(Handle:event, const String:name[], bool:dontBroadcast)
{
    new client = GetClientOfUserId(GetEventInt(event, "userid"));
  
    g_iKillTimeVictim[client] = 0.0;
    g_MyAFKprotectOn[client] = true;
    no_need_more[client] = false;
  
    if(GetConVarBool(g_iActiveColorAFK))
    {
        SetPlayerColor(client, 0, 255, 0, 255);
    }
  
    // Fixer35hp
    GetClientAbsOrigin(client, g_iMyStartPositions[client]);
  
    if(GetConVarBool(g_iActiveFixer35hp))
    {  
        g_iRespawnTimer[client] = CreateTimer(0.2, Giver35hp, GetClientUserId(client));
    }
      
    // NoBlock  
    if(GetConVarBool(g_iActiveCollision))
    {
        SetEntData(client, OffsetCollision, 2, 4, true);
    }

    // KnifeDM by R1KO
    if(client > 0 && GetConVarBool(g_iActiveKnifeDM))
    {
        if(IsPlayerAlive(client))
        {
            SetEntProp(client, Prop_Data, "m_takedamage", 0);
            Timer_Protect[client] = CreateTimer(g_fProtectTime, ProtectTimer_CallBack, client);
        }
    }
}

public Action:Giver35hp(Handle:timer, any:userid)
{
    new client = GetClientOfUserId(userid);
    new m_iHealth = GetEntProp(client, Prop_Data, "m_iHealth");
    g_iRespawnTimer[client] = INVALID_HANDLE;
  
    if(m_iHealth > 35 && m_iHealth != 1000)
    {
        SetEntProp(client, Prop_Data, "m_iHealth", 35);
    }
}

public Action:DeathClient(Handle:event, const String:name[], bool:dontBroadcast)
{
    new attacker = GetClientOfUserId(GetEventInt(event, "attacker"));
    new client = GetClientOfUserId(GetEventInt(event, "userid"));

    if(attacker > 0)
    {
        new i = GetClientUserId(attacker);

        if (IsClientInGame(attacker) && GetConVarBool(g_iActiveColorPar))
        {  
            SetPlayerColor(attacker, 255, 0, 0, 255);
            g_iProtectTimer[attacker] = CreateTimer(1.3, EndProtect, i);      
        }
    }

    // KnifeDM by R1KO
    if(IsClientInGame(client) && GetConVarBool(g_iActiveKnifeDM))
    {
        if(g_bRemoveRadgoll)
        {
            new iEntity = GetEntPropEnt(client, Prop_Send, "m_hRagdoll");
            if (iEntity > MaxClients && IsValidEdict(iEntity))  CreateTimer(g_fRemoveRadgollDelay, f_Dissolve, iEntity, TIMER_FLAG_NO_MAPCHANGE);
        }
        Timer_Respawn[client] = CreateTimer(g_fRespawnDelay, f_Respawn, client);
    }      
}

public Action:EndProtect(Handle:timer, any:userid)
{
    new client = GetClientOfUserId(userid);
  
    if(client > 0 && GetConVarBool(g_iActiveColorPar))
    {
        SetPlayerColor(client, 255, 255, 255, 255);
    }
}

public PlayerTeam(Handle:event, const String:name[], bool:silent)
{
    new client = GetClientOfUserId(GetEventInt(event, "userid"));
    ClientTeam[client] = GetClientTeam(client);
  
    if (GetEventInt(event, "team") > 1)
    {
        if(Timer_Respawn[client] == INVALID_HANDLE) Timer_Respawn[client] = CreateTimer(g_fRespawnDelay, f_Respawn, client);
    }
    else KillTimerS(client);
}


//============================================================================//


public OnClientPostAdminCheck(client)
{
    g_AFKwarnings[client] = 0;
    g_iCheckAfkTimer[client] = CreateTimer(15.0, g_iCheckAfkTimer_CallBack, client, TIMER_REPEAT | TIMER_FLAG_NO_MAPCHANGE);
    if(GetConVarBool(g_iActiveBlockTolp))
    {
        SDKHook(client, SDKHook_PostThinkPost, OnPostThinkPost);
    }
}

public Action:g_iCheckAfkTimer_CallBack(Handle:timer, any:client)
{
    if (!IsClientInGame(client))
    {
        g_iCheckAfkTimer[client] = INVALID_HANDLE;
        return Plugin_Stop;
    }
  
    if (!IsPlayerAlive(client))
    {
        g_AFKwarnings[client] = 0;
        return Plugin_Continue;
    }

    decl Float:x_vec[3];
    GetClientAbsOrigin(client, x_vec);
  
    if (x_vec[0] == g_iAfkStartPositions[client][0] && x_vec[1] == g_iAfkStartPositions[client][1])
    {
        if(++g_AFKwarnings[client] > 2)
        {
            g_iCheckAfkTimer[client] = INVALID_HANDLE;
            ChangeClientTeam(client, 1);
            return Plugin_Stop;
        }

        // предупреждение
        else if(g_AFKwarnings[client] == 2)
        {
            PrintCenterText(client, "[KD] Играй, иначе выкинем в спектаторы!");
            EmitSoundToClient(client, Antiparavoz_sound);
        }
    }
    else
    {
        g_iAfkStartPositions[client][0] = x_vec[0];
        g_iAfkStartPositions[client][1] = x_vec[1];
        g_AFKwarnings[client] = 0;
    }

    return Plugin_Continue;
}

/*//============================================================================//
Check Rates
*///============================================================================//

public Action:CheckManyRates(client, args)
{
    if(client > 0)
    {
        g_LastItem[client] = 0;
        PlayersMenu(client);
    }
    return Plugin_Handled;
}

PlayersMenu(client)
{
    new Handle:menu = CreateMenu(PlayersMenu_CallBack);
    SetMenuTitle(menu, "Knife Dozor | Выберите игрока\n \n");
    decl String:str_id[15], String:str_nick[32];
    for (new i = 1; i <= MaxClients; i++)
    {
        if (IsClientInGame(i) && !IsFakeClient(i))
        {
            IntToString(GetClientUserId(i), str_id, 15);
            str_nick[0] = '\0';
            GetClientName(i, str_nick, 32);
            AddMenuItem(menu, str_id, str_nick, ITEMDRAW_DEFAULT);
        }
    }
    DisplayMenuAtItem(menu, client, g_LastItem[client], 0);
}

public PlayersMenu_CallBack(Handle:menu, MenuAction:action, client, item)
{
    if (action == MenuAction_End)
    {
        CloseHandle(menu);
        return;
    }

    if (action != MenuAction_Select)
        return;

    decl String:str_id[15];
    if (!GetMenuItem(menu, item, str_id, 15))
        return;

    g_TargetId[client] = StringToInt(str_id);
    new target = GetClientOfUserId(g_TargetId[client]);
    if (target < 1)
    {
        PlayersMenu(client);
        return;
    }

    g_LastItem[client] = GetMenuSelectionPosition();
    if (g_hPanel[client] != INVALID_HANDLE) CloseHandle(g_hPanel[client]);
    g_hPanel[client] = CreatePanel();
    decl String:title[65];
    Format(title, 65, "%N\n \n", target);
    SetPanelTitle(g_hPanel[client], title);
    new id = GetClientUserId(client);
    for (new i = 0; i < 18; i++) QueryClientConVar(target, sClientVar[i], RateQueryFinished, id);
}

public RateQueryFinished(QueryCookie:cookie, client, ConVarQueryResult:result, const String:cvarName[], const String:cvarValue[], any:x)
{
    if (client > 0 && (x = GetClientOfUserId(x)) > 0 && client == GetClientOfUserId(g_TargetId[x]))
    {
        decl String:info[100];
        Format(info, 100, "%s: %s", cvarName, cvarValue);
        DrawPanelText(g_hPanel[x], info);
        SendPanelToClient(g_hPanel[x], x, Panel_CallBack, 0);
    }
}

public Panel_CallBack(Handle:panel, MenuAction:action, client, item)
{
    if (action == MenuAction_Select)
    {
        PlayersMenu(client);
    }
}

/*//============================================================================//
KnifeBot Detector (wS plugin)
*///============================================================================//

public Action:Knifebot(admin, args)
{
    ShowPlayers(admin);
    return Plugin_Handled;
}

stock ShowPlayers(admin, item = 0)
{
    new Handle:menu = CreateMenu(menu_CallBack);
    SetMenuTitle(menu, "Knife Dozor | Проверить на КнайфБот:\n \n");
    SetMenuExitBackButton(menu, true);
    decl String:str_id[15], String:str_nick[32];
    for (new i = 1; i <= MaxClients; i++)
    {
        if (IsClientInGame(i) && !IsFakeClient(i))
        {
            IntToString(GetClientUserId(i), str_id, 15);
            str_nick[0] = '\0';
            GetClientName(i, str_nick, 32);
            AddMenuItem(menu, str_id, str_nick, i != admin ? ITEMDRAW_DEFAULT : ITEMDRAW_DISABLED);
        }
    }
    DisplayMenuAtItem(menu, admin, item, 0);
}

public menu_CallBack(Handle:menu, MenuAction:action, admin, item)
{
    if (action == MenuAction_End)
        CloseHandle(menu);

    else if (action == MenuAction_Cancel && item == MenuCancel_ExitBack)
    {
        new Handle:hAdminMenu = GetAdminTopMenu();
        if (hAdminMenu != INVALID_HANDLE) DisplayTopMenu(hAdminMenu, admin, TopMenuPosition_LastCategory);
    }

    else if (action == MenuAction_Select)
    {
        if (g_hTimer[admin] == INVALID_HANDLE)
        {
            decl String:str_id[15];
            if (!GetMenuItem(menu, item, str_id, 15))
                return;

            new target = GetClientOfUserId(StringToInt(str_id));
            ID = target;
            if (target > 0 && IsPlayerAlive(admin) && IsPlayerAlive(target))
            {
                SetEntProp(admin,  Prop_Data, "m_CollisionGroup", 2);
                SetEntProp(target, Prop_Data, "m_CollisionGroup", 2);
                SetColor(admin, 255, 255, 255, 0);
                decl Float:pos[3];
                GetClientAbsOrigin(target, pos);
                GetClientAbsOrigin(admin, AdminOldPos[admin]);
              
                // Выдача 1000 hp, чтобы недобросовестные админы не могли убить игрока во время телепорта
                SetEntProp(ID, Prop_Data, "m_iHealth", 1000);
              
                // Телепортирование админа
                TeleportEntity(admin, pos, NULL_VECTOR, NULL_VECTOR);
                g_hTimer[admin] = CreateTimer(0.1, g_hTimer_CallBack, admin);
            }
            else
            {
                PrintCenterText(admin, "Вы и цель должны быть живы");
            }
        }
      
        ShowPlayers(admin, GetMenuSelectionPosition());
    }
}

public Action:g_hTimer_CallBack(Handle:timer, any:admin)
{
    g_hTimer[admin] = INVALID_HANDLE;
  
    if (IsClientInGame(admin))
    {
        SetColor(admin, 255, 255, 255, 255);
        if (IsPlayerAlive(admin))
        {
            PrintCenterText(admin, "КнайфБот не обнаружен");
          
            // Выдача игроку 35 hp , после проверки на КнайфБот
            SetEntProp(ID, Prop_Data, "m_iHealth", 35);
          
            TeleportEntity(admin, AdminOldPos[admin], NULL_VECTOR, NULL_VECTOR);
        }
        else
            PrintCenterText(admin, "КНАЙФБОТ Обнаружен!");
    }
    return Plugin_Stop;
}

/*//============================================================================//
KnifeDM by R1KO
*///============================================================================//

public Action:ProtectTimer_CallBack(Handle:timer, any:iClient)
{
    if (IsClientInGame(iClient) && IsPlayerAlive(iClient) && GetConVarBool(g_iActiveKnifeDM))
    {
        SetEntProp(iClient, Prop_Data, "m_takedamage", 2);
        SetPlayerColor(iClient, 255, 255, 255, 255);
    }
    Timer_Protect[iClient] = INVALID_HANDLE;
  
    return Plugin_Stop;
}

public Action:f_Dissolve(Handle:hTimer, any:iEntity)
{
    if(GetConVarBool(g_iActiveKnifeDM))
    {
    if(!IsValidEdict(iEntity))
    {
        return;
    }

    decl String:sName[32];
    Format(sName, sizeof(sName), "target_%d", iEntity);
    new iDissolve = CreateEntityByName("env_entity_dissolver");
  
    if(iDissolve > 0)
    {
        DispatchKeyValue(iEntity, "targetname", sName);
        DispatchKeyValue(iDissolve, "dissolvetype", "3");
        DispatchKeyValue(iDissolve, "target", sName);
        AcceptEntityInput(iDissolve, "Dissolve");
        AcceptEntityInput(iDissolve, "kill");
    }
    else
    {
        AcceptEntityInput(iEntity, "Kill");
    }
    }
}

public Action:f_Respawn(Handle:timer, any:iClient)
{
    if (iClient > 0 && IsClientInGame(iClient) && !IsPlayerAlive(iClient) && GetConVarBool(g_iActiveKnifeDM))
    {
        CS_RespawnPlayer(iClient);
    }
  
    Timer_Respawn[iClient] = INVALID_HANDLE;
}

/*//============================================================================//
End
*///============================================================================//

stock SetColor(entity, r, g, b, a)
{
    SetEntityRenderMode(entity, RENDER_TRANSCOLOR);
    SetEntityRenderColor(entity, r, g, b, a);
}

public OnClientDisconnect(client)
{
    KillTimerS(client);
    SDKUnhook(client, SDKHook_PostThinkPost, OnPostThinkPost);
  
    if (g_iCheckAfkTimer[client] != INVALID_HANDLE)
    {
        KillTimer(g_iCheckAfkTimer[client]);
        g_iCheckAfkTimer[client] = INVALID_HANDLE;
    }
}

KillTimerS(client)
{
    if (Timer_Respawn[client] != INVALID_HANDLE)
    {
        KillTimer(Timer_Respawn[client]);
        Timer_Respawn[client] = INVALID_HANDLE;
    }
  
    if (Timer_Protect[client] != INVALID_HANDLE)
    {
        KillTimer(Timer_Protect[client]);
        Timer_Protect[client] = INVALID_HANDLE;
    }
}
Прости меня RoadSide Romeo :biggrin:
 

Вложения

  • KnifeDozor.sp
    21.5 КБ · Просмотры: 7
Войдите или зарегистрируйтесь для ответа.
Сверху Снизу