VoteBKM 1.0.5

Плагины и дополнения / Plugins and add-ons

Модераторы: Dame-danners, Longipongeoos

Аватар пользователя
Dame-danners
Сообщений: 52
Зарегистрирован: 12 апр 2017, 17:10

VoteBKM 1.0.5

Сообщение Dame-danners » 23 ноя 2018, 11:05

Плагин позволяет создать голосование за бан, кик и мут игрока.
Исходный код

Код: Выбрать все

#include <sdktools_gamerules>
#include <colorschat>

#undef REQUIRE_PLUGIN
#include <basecomm>

#undef REQUIRE_EXTENSIONS
#include <steamworks>

#pragma semicolon 1
#pragma newdecls required

public Plugin myinfo =
{
   name = "VoteBKM",
   description = "Голосование за бан, кик и мут игрока",
   author = "Drumanid",
   version = "1.0.5",
   url = "vk.com/drumanid"
};

enum      {BAN, KICK, MUTE};
KeyValues   g_hKeyValues;
Menu      g_hMenu;
Handle      g_hTimer;

int         g_iType,
         g_iTarget,
         g_iPlayers,
         g_iCount,
         g_iTimeTimer,
         g_iTimeLimitAll,
         g_iTimeLimit[MAXPLAYERS +1],
         g_iChat;

float      g_fPercent,
         g_fCount;

char      g_sBuffer[256],
         g_sReason[64],
         g_sLog[128];

bool      g_bExpansion[2],
         g_bUse[MAXPLAYERS +1],
         g_bVote[MAXPLAYERS +1][MAXPLAYERS +1][3],
         g_bNoSteam[MAXPLAYERS +1];

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

bool      g_kvbInBan,
         g_kvbInKick,
         g_kvbInMute,
         g_kvbType,
         g_kvbAdmins,
         g_kvbMessage,
         g_kvbMultiplier,
         g_kvbLog,
         g_kvbNoSteam,
         g_kvbMutePlayer;

int         g_kviTimeTimer,
         g_kviPlayersLimit,
         g_kviDisconnectBan,
         g_kviTimeBan,
         g_kviTimeLimitAll,
         g_kviPercent;

char      g_kvsFlag[2][4];

public APLRes AskPluginLoad2(Handle hMySelf, bool bLate, char[] szError, int iErrMax)
{
   if(GetEngineVersion() == Engine_CSGO) g_bGame = true;
   else g_bGame = false;
   
   return APLRes_Success;
}

public void OnAllPluginsLoaded()
{
   g_bExpansion[0] = LibraryExists("basecomm");
   g_bExpansion[1] = LibraryExists("SteamWorks");
}

public void OnLibraryRemoved(const char[] sName)
{
   UsePlugin(sName, false);
}

public void OnLibraryAdded(const char[] sName)
{
   UsePlugin(sName, true);
}

public void OnPluginStart()
{
   BuildPath(Path_SM, g_sLog, sizeof(g_sLog), "logs/VoteBKM.log");
   
   RegConsoleCmd("sm_voteban", BanCmd);
   RegConsoleCmd("sm_votekick", KickCmd);
   RegConsoleCmd("sm_votemute", MuteCmd);
   RegConsoleCmd("sm_rev", RevoteCmd);
   RegConsoleCmd("sm_votecancel", VoteCancelCmd);
}

public void OnMapStart()
{
   if(g_hKeyValues != null) delete g_hKeyValues;

   char sPath[128];
   BuildPath(Path_SM, sPath, sizeof(sPath), "configs/votebkm.ini");

   g_hKeyValues = new KeyValues("VoteBKM");
   if(!g_hKeyValues.ImportFromFile(sPath)) SetFailState("No found file: '%s'", sPath);

   if(g_bExpansion[0]) g_kvbType = view_as<bool>(g_hKeyValues.GetNum("Type", 0));
   else g_kvbType = true;
   g_kvbInBan = view_as<bool>(g_hKeyValues.GetNum("InBan", 1));
   g_kvbInKick = view_as<bool>(g_hKeyValues.GetNum("InKick", 1));
   g_kvbInMute = view_as<bool>(g_hKeyValues.GetNum("InMute", 1));
   g_kvbAdmins = view_as<bool>(g_hKeyValues.GetNum("Admins", 0));
   g_kvbMessage = view_as<bool>(g_hKeyValues.GetNum("Message", 1));
   g_kvbMultiplier = view_as<bool>(g_hKeyValues.GetNum("Multiplier", 0));
   g_kvbLog = view_as<bool>(g_hKeyValues.GetNum("Log", 1));
   g_kvbNoSteam = view_as<bool>(g_hKeyValues.GetNum("NoSteam", 1));
   g_kvbMutePlayer = view_as<bool>(g_hKeyValues.GetNum("MutePlayer", 1));
   g_kviTimeTimer = g_hKeyValues.GetNum("Time", 20);
   g_kviPlayersLimit = g_hKeyValues.GetNum("PlayersLimit", 4);
   g_kviDisconnectBan = g_hKeyValues.GetNum("DisconnectBan", 60);
   g_kviTimeBan = g_hKeyValues.GetNum("TimeBan", 60);
   g_kviTimeLimitAll = g_hKeyValues.GetNum("TimeLimitAll", 30);
   g_kviPercent = g_hKeyValues.GetNum("VotePercent", 0);
   g_hKeyValues.GetString("FlagImmunity", g_kvsFlag[0], sizeof(g_kvsFlag[]), "t");
   g_hKeyValues.GetString("FlagCancel", g_kvsFlag[1], sizeof(g_kvsFlag[]), "d");

   ClearVeriables(false);
}

public Action BanCmd(int iClient, int iArgs)
{
   if(g_kvbInBan) Type(iClient, BAN);
   return Plugin_Handled;
}

public Action KickCmd(int iClient, int iArgs)
{
   if(g_kvbInKick) Type(iClient, KICK);
   return Plugin_Handled;
}

public Action MuteCmd(int iClient, int iArgs)
{
   if(g_kvbInMute) Type(iClient, MUTE);
   return Plugin_Handled;
}

public Action RevoteCmd(int iClient, int iArgs)
{
   if(iClient && CheckVote(iClient))
   {
      if(g_bUse[iClient])
      {
         g_bUse[iClient] = false; g_fCount -= g_fPercent; g_iCount--;
         if(g_kvbMessage) CPrintToChatAll("{WHITE}[{GREEN}VoteBKM{WHITE}] {GREEN}%N {WHITE}решил переголосовать!", iClient);
      }
      else CPrintToChat(iClient, "{WHITE}[{GREEN}VoteBKM{WHITE}] Сначала проголосуйте, а потом сможете переголосовать!");
   }
   return Plugin_Handled;
}

public Action VoteCancelCmd(int iClient, int iArgs)
{
   if(iClient && CheckVote(iClient))
   {
      if(IsAdminFlag(iClient, g_kvsFlag[1]))
      {
         VoteClosed();
         Log("Администратор %L отменил голосование!\n ", iClient);
         CPrintToChatAll("{WHITE}[{GREEN}VoteBKM{WHITE}] {RED}Администратор {WHITE}отменил голосование!");
      }
      else CPrintToChat(iClient, "{WHITE}[{GREEN}VoteBKM{WHITE}] У вас нет доступа к этой команде!");
   }
   return Plugin_Handled;
}

void Type(int iClient, int iType)
{
   if(iClient < 1) return;

   if(g_kvbNoSteam && g_bExpansion[1] && g_bNoSteam[iClient])
   {
      CPrintToChat(iClient, "{WHITE}[{GREEN}VoteBKM{WHITE}] Вы не можете этого сделать играя с пиратской версии игры!");
      return;
   }

   if(!g_kvbMutePlayer && g_bExpansion[0])
   {
      if(BaseComm_IsClientGagged(iClient) || BaseComm_IsClientMuted(iClient))
      {
         CPrintToChat(iClient, "{WHITE}[{GREEN}VoteBKM{WHITE}] Вы не можете этого сделать т.к вы имеете блокировку чата или микрофона!");
         return;
      }
   }

   if(!g_bGame || !GameRules_GetProp("m_bWarmupPeriod"))
   {
      if(g_iTarget < 1)
      {
         int iTime = GetTime();
         if(g_iTimeLimitAll <= iTime)
         {
            if(GetPlayers() >= g_kviPlayersLimit)
            {
               if(!g_kvbAdmins || g_iPlayers == 0)
               {
                  if(g_iTimeLimit[iClient] <= iTime)
                  {
                     g_fPercent = 100.0 / float((g_iPlayers = GetPlayers()));
                     
                     Menu hMenu = new Menu(PlayerListMenuItems);
                     hMenu.ExitButton = true;

                     char sBuffer[64], sBuffer2[32]; int iCount, i;
                     GetType(iType, sBuffer, sizeof(sBuffer));

                     if(g_kviPercent == 0)
                     {
                        g_iTarget++;
                        hMenu.SetTitle("Выберите игрока которого хотите - '%s'\n ", sBuffer);

                        for(i = 1; i <= MaxClients; i++)
                        {
                           if(IsClientInGame(i) && !IsFakeClient(iClient) && i != iClient)
                           {
                              GetClientName(i, sBuffer, sizeof(sBuffer));
                              FormatEx(sBuffer2, sizeof(sBuffer2), "%i %i", GetClientUserId(i), iType);
                              if(!IsAdminFlag(i, g_kvsFlag[0])) hMenu.AddItem(sBuffer2, sBuffer);
                              else hMenu.AddItem(sBuffer2, sBuffer, ITEMDRAW_DISABLED);
                              iCount++;
                           }
                        }
                     }
                     else
                     {
                        hMenu.SetTitle("Выберите игрока которого хотите - '%s'\nДля того чтобы начать голосование, нужно:\n[n - текущее / n - необходимое] кол-во голосов\n ", sBuffer);

                        int iVotes[2];
                        for(i = 1; i <= MaxClients; i++)
                        {
                           if(IsClientInGame(i) && !IsFakeClient(iClient) && i != iClient)
                           {
                              if(!IsAdminFlag(i, g_kvsFlag[0]))
                              {
                                 iVotes[0] = GetAllVotes(float(g_kviPercent)); iVotes[1] = GetVotes(i, iType);
                                 if(!g_bVote[iClient][i][iType])
                                 {
                                    if(iVotes[0] > iVotes[1]) FormatEx(sBuffer, sizeof(sBuffer), "%N [%i/%i]", i, iVotes[1], iVotes[0]);
                                    else FormatEx(sBuffer, sizeof(sBuffer), "%N [Начать голосование]", i);
                                 }
                                 else FormatEx(sBuffer, sizeof(sBuffer), "%N [Забрать голос]", i);
                                 FormatEx(sBuffer2, sizeof(sBuffer2), "%i %i %i %i", GetClientUserId(i), iType, iVotes[0], iVotes[1]);
                                 hMenu.AddItem(sBuffer2, sBuffer);
                              }
                              else
                              {
                                 FormatEx(sBuffer, sizeof(sBuffer), "%N [-/-]", i);
                                 hMenu.AddItem(NULL_STRING, sBuffer, ITEMDRAW_DISABLED);
                              }
                              
                              iCount++;
                           }
                        }

                        g_iPlayers = 0;
                     }

                     if(iCount == 0) CPrintToChat(iClient, "{WHITE}[{GREEN}VoteBKM{WHITE}] На данный момент нет подходящих игроков!");
                     hMenu.Display(iClient, 0);
                  }
                  else CPrintToChat(iClient, "{WHITE}[{GREEN}VoteBKM{WHITE}] Вы недавно создавали голосование! Вы сможете запустить голосование только через {RED}%i{WHITE} секунд(у/ы)!", g_iTimeLimit[iClient] - iTime);
               }
               else CPrintToChat(iClient, "{WHITE}[{GREEN}VoteBKM{WHITE}] Вы не сможете запустить голосование, т.к на сервере есть администратор!");
            }
            else CPrintToChat(iClient, "{WHITE}[{GREEN}VoteBKM{WHITE}] Необходимо {RED}%i{WHITE} игрока, чтобы создать голосование!", g_kviPlayersLimit);
         }
         else CPrintToChat(iClient, "{WHITE}[{GREEN}VoteBKM{WHITE}] Недавно было голосование! Игроки смогут запустить голосование только через {RED}%i{WHITE} секунд(у/ы)!", g_iTimeLimitAll - iTime);
      }
      else CPrintToChat(iClient, "{WHITE}[{GREEN}VoteBKM{WHITE}] Вы не можете создать голосование, т.к его уже создали(ют)");
   }
   else CPrintToChat(iClient, "{WHITE}[{GREEN}VoteBKM{WHITE}] Нельзя запустить голосование во время разминки!");
}

public int PlayerListMenuItems(Menu hMenu, MenuAction action, int iClient, int iItem)
{
   switch(action)
   {
      case MenuAction_End: delete hMenu;
      case MenuAction_Cancel:
      {
         if(g_kviPercent == 0 && (iItem == MenuCancel_Interrupted || iItem == MenuCancel_Timeout || iItem == MenuCancel_Exit)) g_iTarget = 0;
      }
      case MenuAction_Select:
      {
         char sBuffer[24], sExplodeBuffer[4][8]; int iTarget;
         hMenu.GetItem(iItem, sBuffer, sizeof(sBuffer));
         ExplodeString(sBuffer, " ", sExplodeBuffer, sizeof(sExplodeBuffer), sizeof(sExplodeBuffer[]));
         if(!CheckTarget((iTarget = GetClientOfUserId(StringToInt(sExplodeBuffer[0]))), iClient)) return;
         
         int iType = StringToInt(sExplodeBuffer[1]);
         if(g_kviPercent != 0)
         {
            if(!g_bVote[iClient][iTarget][iType])
            {
               g_bVote[iClient][iTarget][iType] = true; int iVotes[2];
               iVotes[0] = StringToInt(sExplodeBuffer[2]); iVotes[1] = StringToInt(sExplodeBuffer[3]) +1;
               
               if(iVotes[1] < iVotes[0])
               {
                  CPrintToChat(iClient, "{WHITE}[{GREEN}VoteBKM{WHITE}] Необходимо еще {RED}%i{WHITE} голос(а), чтобы создать голосование за наказание данного игрока!", iVotes[0] - iVotes[1]);
                  if(g_kvbMessage) CPrintToChatAll("{WHITE}[{GREEN}VoteBKM{WHITE}] {GREEN}%N {WHITE}отдал свой голос за наказание игрока {RED}%N", iClient, iTarget);
                  return;
               }
            }
            else
            {
               g_bVote[iClient][iTarget][iType] = false;
               if(g_kvbMessage) CPrintToChatAll("{WHITE}[{GREEN}VoteBKM{WHITE}] {GREEN}%N {WHITE}забрал свой голос с игрока {RED}%N!", iClient, iTarget);
               return;
            }
         }

         g_iType = iType;
         g_iTarget = iTarget;
         ReasonMenu(iClient);
      }
   }
}

void ReasonMenu(int iClient)
{
   if(!CheckTarget(g_iTarget, iClient)) return;

   Menu hMenu = new Menu(ReasonMenuItems);
   hMenu.ExitButton = true;

   hMenu.SetTitle("Выбранный игрок: %N\nВыберите причину наказания:\n ", g_iTarget);

   char sKey[32];
   switch(g_iType)
   {
      case BAN: sKey = "ban_reason";
      case KICK: sKey = "kick_reason";
      case MUTE: sKey = "mute_reason";
   }

   g_hKeyValues.Rewind();
   if(g_hKeyValues.JumpToKey(sKey) && g_hKeyValues.GotoFirstSubKey(false))
   {
      char sReason[2][64];
      do
      {
         g_hKeyValues.GetSectionName(sReason[0], sizeof(sReason[]));
         g_hKeyValues.GetString(NULL_STRING, sReason[1], sizeof(sReason[]));
         hMenu.AddItem(sReason[0], sReason[1]);
      }
      while(g_hKeyValues.GotoNextKey(false));
   }
   else g_iTarget = 0;

   hMenu.Display(iClient, 0);
}

public int ReasonMenuItems(Menu hMenu, MenuAction action, int iClient, int iItem)
{
   switch(action)
   {
      case MenuAction_End: delete hMenu;
      case MenuAction_Cancel:
      {
         if(iItem == MenuCancel_Interrupted || iItem == MenuCancel_Timeout || iItem == MenuCancel_Exit) g_iTarget = 0;
      }
      case MenuAction_Select:
      {
         hMenu.GetItem(iItem, g_sReason, sizeof(g_sReason));
         if(StrContains(g_sReason, "chat", false) == 0)
         {
            g_hTimer = CreateTimer(15.0, TimerChat, GetClientUserId(iClient), TIMER_FLAG_NO_MAPCHANGE);
            CPrintToChat(iClient, "{WHITE}[{GREEN}VoteBKM{WHITE}] Введите причину в чате, вам дано {GREEN}15 {WHITE}секунд!");
            g_iChat = iClient; return;
         }

         ConfirmationMenu(iClient);
      }
   }
}

public Action TimerChat(Handle hTimer, any iClient)
{
   iClient = GetClientOfUserId(iClient);
   if(IsClientInGame(iClient))
   {
      CPrintToChat(iClient, "{WHITE}[{GREEN}VoteBKM{WHITE}] Вы не успели ввести причину!");
      g_iChat = -1; g_iTarget = 0; TimeLimit(iClient, GetTime());
   }
   else g_iTarget = 0;

   g_hTimer = null;
   return Plugin_Stop;
}

void ConfirmationMenu(int iClient)
{
   if(!CheckTarget(g_iTarget, iClient)) return;

   Menu hMenu = new Menu(ConfirmationMenuItems);
   hMenu.ExitButton = false;

    char sType[32];
    GetType(g_iType, sType, sizeof(sType));
   hMenu.SetTitle("Вы хотите %s игрока %N?\nПричина: %s\n ", sType, g_iTarget, g_sReason);

   for(int i; i < 3; i++) hMenu.AddItem(NULL_STRING, NULL_STRING, ITEMDRAW_NOTEXT);
   hMenu.AddItem("", "Да");
   hMenu.AddItem("", "Нет, изменить причину!");
   hMenu.AddItem("", "Нет, отменить голосование!");
   hMenu.Display(iClient, 0);
}

public int ConfirmationMenuItems(Menu hMenu, MenuAction action, int iClient, int iItem)
{
   switch(action)
   {
      case MenuAction_End: delete hMenu;
      case MenuAction_Cancel:
      {
         if(iItem == MenuCancel_Interrupted || iItem == MenuCancel_Timeout) g_iTarget = 0;
      }
      case MenuAction_Select:
      {
         switch(iItem)
         {
            case 3:
            {
               if(!CheckTarget(g_iTarget, iClient)) return;
               g_iPlayers--;

               int iTime = GetTime();
               g_iTimeLimitAll = iTime + g_kviTimeLimitAll;
               TimeLimit(iClient, iTime);

               g_iTimeTimer = g_kviTimeTimer;
               g_hTimer = CreateTimer(1.0, TimerReturnMenu, _, TIMER_REPEAT | TIMER_FLAG_NO_MAPCHANGE);

               char sReason[64], sType[32];
               FormatEx(sReason, sizeof(sReason), "%s", g_sReason);
               switch(g_iType)
               {
                  case BAN:
                  {
                     sType = "забанить";
                     FormatEx(g_sReason, sizeof(g_sReason), "[VOTEBAN] Причина: %s", sReason);
                     
                  }
                  case KICK:
                  {
                     sType = "кикнуть";
                     FormatEx(g_sReason, sizeof(g_sReason), "[VOTEKICK] Причина: %s", sReason);
                  }
                  case MUTE:
                  {
                     sType = "замутить";
                     FormatEx(g_sReason, sizeof(g_sReason), "[VOTEMUTE] Причина: %s", sReason);
                  }
               }

               FormatEx(g_sBuffer, sizeof(g_sBuffer), "Игрок: %N\nХочет %s игрока: %N\nПричина: %s", iClient, sType, g_iTarget, sReason);
               Log("Игрок %L хочет %s игрока %L | Причина: %s", iClient, sType, g_iTarget, sReason);
               CPrintToChatAll("{WHITE}[{GREEN}VoteBKM{WHITE}] {GREEN}%N {WHITE}хочет {RED}%s {WHITE}игрока {RED}%N{WHITE}. Создано голосование! Причина: {RED}%s", iClient, sType, g_iTarget, sReason);

               Voted(iClient, true);

               g_hMenu = new Menu(MenuVoteItems);
               g_hMenu.ExitButton = false;

               for(int i; i < 3; i++) g_hMenu.AddItem(NULL_STRING, NULL_STRING, ITEMDRAW_NOTEXT);
               g_hMenu.AddItem("", "Наказать");
               g_hMenu.AddItem("", "Не наказывать");

            }
            case 4: ReasonMenu(iClient);
            case 5: g_iTarget = 0;
         }
      }
   }
}

public int MenuVoteItems(Menu hMenu, MenuAction action, int iClient, int iItem)
{
   if(action == MenuAction_Select)
   {
      if(!CheckTarget(g_iTarget, iClient)) return;

      char sMessage[32];
      switch(iItem)
      {
         case 3:
         {
            Voted(iClient, true);
            sMessage = "за наказание";
         }
         case 4:
         {
            Voted(iClient, false);
            sMessage = "не наказывать";
         }
      }

      if(g_kvbMessage) CPrintToChatAll("{WHITE}[{GREEN}VoteBKM{WHITE}] Игрок {GREEN}%N {WHITE}голосует - {GREEN}%s{WHITE} игрока", iClient, sMessage);
      CPrintToChat(iClient, "{WHITE}[{GREEN}VoteBKM{WHITE}] Введите в чат {RED}!rev{WHITE}, чтобы переголосовать!");
      if(g_iPlayers == g_iCount) FinishVote();
   }
}

public Action TimerReturnMenu(Handle hTimer)
{
   if(--g_iTimeTimer > 0)
   {
      for(int i = 1; i <= MaxClients; i++)
      {
         if(IsClientInGame(i) && !IsFakeClient(i) && i != g_iTarget && !g_bUse[i])
         {
            g_hMenu.SetTitle("%s\nОсталось время на выбор: %i\n ", g_sBuffer, g_iTimeTimer);
            g_hMenu.Display(i, 1);
         }
      }

      return Plugin_Continue;
   }

   FinishVote();
   g_hTimer = null;
   return Plugin_Stop;
}

void Voted(int iClient, bool bUse)
{
   g_iCount++; g_bUse[iClient] = true;

   if(bUse)
   {
      if(IsAdminFlag(iClient, g_kvsFlag[1]))
      {
         CPrintToChat(iClient, "{WHITE}[{GREEN}VoteBKM{WHITE}] Введите {RED}!votecancel{WHITE}, чтобы отменить голсование!");
         if(g_kvbMultiplier)
         {
            g_fCount += g_fPercent * 2;
            return;
         }
      }

      g_fCount += g_fPercent;
   }
}

void FinishVote()
{
   char sBuffers[256]; int iPercent;
   GetKey(sBuffers, sizeof(sBuffers)); g_hKeyValues.Rewind();
   if(g_hKeyValues.JumpToKey(sBuffers))
   {
      g_hKeyValues.GetString("Command", sBuffers, sizeof(sBuffers));
      iPercent = g_hKeyValues.GetNum("Percent");
   }

   if(RoundToCeil(g_fCount) >= iPercent)
   {
      if(!CheckTarget(g_iTarget, _)) return;
      Log("Игрок %L был наказан!\n ", g_iTarget);

      if(g_kvbType)
      {
         char sReplace[40], sBuffer[32];
         if(StrContains(sBuffers, "{UID}", true) != -1)
         {
            IntToString(GetClientUserId(g_iTarget), sBuffer, sizeof(sBuffer));
            FormatEx(sReplace, sizeof(sReplace), "\"#%s\"", sBuffer);
            ReplaceString(sBuffers, sizeof(sBuffers), "{UID}", sReplace, true);
         }
         else if(StrContains(sBuffers, "{NAME}", true) != -1)
         {
            GetClientName(g_iTarget, sBuffer, sizeof(sBuffer));
            FormatEx(sReplace, sizeof(sReplace), "\"%s\"", sBuffer);
            ReplaceString(sBuffers, sizeof(sBuffers), "{NAME}", sReplace, true);
         }
         else if(StrContains(sBuffers, "{STEAMID}", true) != -1)
         {
            GetClientAuthId(g_iTarget, AuthId_Steam2, sBuffer, sizeof(sBuffer));
            FormatEx(sReplace, sizeof(sReplace), "\"%s\"", sBuffer);
            ReplaceString(sBuffers, sizeof(sBuffers), "{STEAMID}", sReplace, true);
         }

         if(StrContains(sBuffers, "{REASON}", true) != -1) ReplaceString(sBuffers, sizeof(sBuffers), "{REASON}", g_sReason, true);
         ServerCommand(sBuffers);
      }
      else
      {
         switch(g_iType)
         {
            case BAN: BanClient(g_iTarget, g_kviTimeBan, BANFLAG_AUTO, g_sReason);
            case KICK: KickClient(g_iTarget, g_sReason);
            case MUTE:
            {
               BaseComm_SetClientGag(g_iTarget, true); BaseComm_SetClientMute(g_iTarget, true);
               CPrintToChat(g_iTarget, "{WHITE}[{GREEN}VoteBKM{WHITE}] Вы получили мут! {WHITE}Причина: {RED}%s", g_sReason);
            }
         }
      }
            
      sBuffers = "Голосование завершено, игрок был наказан!";
   }
   else
   {
      Log("Игрок %L не был наказан, недостаточно голосов!\n ", g_iTarget);
      sBuffers = "Недостаточно голосов, голосование завершено!";
   }

   CPrintToChatAll("{WHITE}[{GREEN}VoteBKM{WHITE}] Проголосовало {GREEN}%i {WHITE}игрок(а/ов) из {RED}%i{WHITE} игроков. %s", g_iCount, g_iPlayers, sBuffers);
   VoteClosed();
}

public void OnClientPostAdminCheck(int iClient)
{
   if(g_kvbNoSteam && g_bExpansion[1] && !IsFakeClient(iClient))
   {
      if(g_bGame && SteamWorks_HasLicenseForApp(iClient, 730) == k_EUserHasLicenseResultDoesNotHaveLicense) g_bNoSteam[iClient] = true;
      else if(!g_bGame && SteamWorks_HasLicenseForApp(iClient, 240) == k_EUserHasLicenseResultDoesNotHaveLicense) g_bNoSteam[iClient] = true;
   }
}

public void OnClientDisconnect(int iClient)
{
   g_bUse[iClient] = false;
   g_bNoSteam[iClient] = false;
   g_iTimeLimit[iClient] = 0;
   if(g_iChat == iClient) g_iChat = -1;

   int a, b;
   for(a = 1; a <= MaxClients; a++)
   {   
      for(b = 0; b < 3; b++) g_bVote[iClient][a][b] = false;
   }

   if(g_fPercent > 0.0 && g_iTarget == iClient)
   {
      Log("Игрок %L вышел во время голосования!\n ", iClient);
      BanClient(iClient, g_kviDisconnectBan, BANFLAG_AUTO, "Покинул сервер во время голосования");
      CPrintToChatAll("{WHITE}[{GREEN}VoteBKM{WHITE}] {RED}Игрок вышел с сервера, голсоование завершено!");
      VoteClosed();
   }
}

public Action OnClientSayCommand(int iClient, const char[] sCommand, const char[] sArgs)
{
   if(g_kvbInBan && StrContains(sArgs, "voteban", false) == 0)
   {
      Type(iClient, BAN);
      return Plugin_Handled;
   }
   else if(g_kvbInKick && StrContains(sArgs, "votekick", false) == 0)
   {
      Type(iClient, KICK);
      return Plugin_Handled;
   }
   else if(g_kvbInMute && StrContains(sArgs, "votemute", false) == 0)
   {
      Type(iClient, MUTE);
      return Plugin_Handled;
   }
   else if(g_iChat == iClient)
   {
      FormatEx(g_sReason, sizeof(g_sReason), "%s", sArgs);
      g_iChat = -1; DeleteTimer();

      ConfirmationMenu(iClient);
      return Plugin_Handled;
   }

   return Plugin_Continue;
}

void ClearVeriables(bool bUse)
{
   if(bUse)
   {
      for(int i = 1; i <= MaxClients; i++)
      {
         g_bUse[i] = false;
         g_bVote[i][g_iTarget][g_iType] = false;
      }
   }
   else
   {
      for(int a = 1, b, c; a <= MaxClients; a++)
      {
         g_bUse[a] = false;
         for(b = 1; b <= MaxClients; b++) for(c = 0; c < 3; c++) g_bVote[a][b][c] = false;
      }
   }

   g_iType = 0;
   g_iTarget = 0;
   g_iPlayers = 0;
   g_iCount = 0;
   g_fCount = 0.0;
   g_fPercent = 0.0;
   g_sBuffer[0] = 0;
   g_sReason[0] = 0;
   g_iTimeTimer = 0;
   g_iChat = -1;
}

void GetType(int iType, char[] sType, int iSize)
{
   switch(iType)
   {
      case BAN: strcopy(sType, iSize, "ЗАБАНИТЬ");
      case KICK: strcopy(sType, iSize, "КИКНУТЬ");
      case MUTE: strcopy(sType, iSize, "ЗАМУТИТЬ");
   }
}

void GetKey(char[] sKey, int iSize)
{
   switch(g_iType)
   {
      case BAN: strcopy(sKey, iSize, "ban_settings");
      case KICK: strcopy(sKey, iSize, "kick_settings");
      case MUTE: strcopy(sKey, iSize, "mute_settings");
   }
}

bool CheckTarget(int iTarget, int iClient = 0)
{
   if(iTarget > 0 && IsClientInGame(iTarget)) return true;

   if(iClient != 0) CPrintToChat(iClient, "{WHITE}[{GREEN}VoteBKM{WHITE}] Игрока больше нет на сервере!");
   return false;
}

bool CheckVote(int iClient)
{
   if(g_hTimer) return true;

   CPrintToChat(iClient, "{WHITE}[{GREEN}VoteBKM{WHITE}] Нет на данный момент голосования!");
   return false;
}

bool IsAdminFlag(int iClient, char[] sFlag)
{
   int iFlagBits = GetUserFlagBits(iClient);

   if(iFlagBits & ReadFlagString("z") || iFlagBits & ReadFlagString(sFlag)) return true;
   return false;
}

int GetPlayers()
{
   int iPlayers;
   for(int i = 1; i <= MaxClients; i++)
   {
      if(IsClientInGame(i) && !IsFakeClient(i) && i != g_iTarget)
      {
         iPlayers++;
         if(IsAdminFlag(i, g_kvsFlag[1])) g_iPlayers++;
      }
   }

   return iPlayers;
}

void VoteClosed()
{
   if(g_hMenu != null) delete g_hMenu;
   ClearVeriables(true);
   DeleteTimer();
}

void DeleteTimer()
{
   if(g_hTimer)
   {
      KillTimer(g_hTimer);
      g_hTimer = null;
   }
}

void TimeLimit(int iClient, int iTime)
{
   char sKey[32];
   GetKey(sKey, sizeof(sKey)); g_hKeyValues.Rewind();
   if(g_hKeyValues.JumpToKey(sKey)) g_iTimeLimit[iClient] = g_hKeyValues.GetNum("TimeLimit") + iTime;
}

int GetAllVotes(float fPrecent)
{
   int iVotes;
   for(int i; i < g_iPlayers; i++)
   {
      fPrecent -= g_fPercent;
      if(fPrecent >= 0.0) iVotes++;
      else break;
   }

   return iVotes;
}

int GetVotes(int iTarget, int iType)
{
   int iVotes;
   for(int i = 1; i <= MaxClients; i++)
   {
      if(g_bVote[i][iTarget][iType]) iVotes++;
   }

   return iVotes;
}


void Log(const char[] sMessage, any ...)
{
   if(g_kvbLog)
   {
      char sBuffer[256];
      VFormat(sBuffer, sizeof(sBuffer), sMessage, 2);

      LogToFile(g_sLog, sBuffer);
   }
}

void UsePlugin(const char[] sName, bool bUse)
{
   if(StrEqual(sName, "basecomm")) g_bExpansion[0] = bUse;
   else if(StrEqual(sName, "SteamWorks")) g_bExpansion[1] = bUse;
}

Команды:
!voteban - забанить игрока
!votekick - кикнуть игрока
!votemute - заткнуть игрока
!votecancel - отменить голосование
!rev - переголосовать

Установка:
Скопируйте файл VoteBKM.sp в папку addons/sourcemod/scripting, так же colorschat.inc но в scripting/include.
Скомпилируйте плагин, перетащив файл исходника(VoteBKM.sp) мышью на (addons/sourcemod/scripting/spcomp.exe/compile.exe).
Скопируйте скомпилированный файл VoteBKM.smx в директорию addons/sourcemod/plugins
Скопируйте файл настроек votebkm.ini в директорию addons/sourcemod/configs/

Настройки:

Код: Выбрать все

"VoteBKM"
{
    // 1 - Включить голосование за наказание игрока... | 0 - выключить
    "InBan" "1" // Бан

    "InKick" "1" // Кик

    "InMute" "1" // Мут


    "Admins" "0" // 1 - Блокировать голосование, если на сервере есть админ | 0 - Не блокировать

    "Type" "1" // Тип бана? 1 - через консоль(Изменять: 'Command') | 0 - через стандартные функции в плагине

    "Message" "1" // 1 - Включить сообщения в чате | 0 - выключить

    "Multiplier" "0" // 1 - Считать голос администратора как за два голоса | 0 - выключить(не считать)

    "Time" "15" // Время таймера(голосования)

    "PlayersLimit" "4" // Минимальное кол-во игроков, чтобы использовать голосования

    "DisconnectBan" "120" // Сколько минут бана получит игрок, если выйдет во время голосования

    "TimeBan" "60" // Время бана (только при включеном "Type" "0")

    "TimeLimitAll" "0" // Тайм-лимит в секундах, распространяющийся на всех игроков после любого голосования

    "VotePercent" "30" // Сколько процентов голосов необходимо, чтобы создать голосование за наказание игрока | 0 - голосование запускать сразу

    "Log" "1" // 1 - включить лог сообщения в файл (addons/sourcemod/logs/VoteBKM.log) | 0 - выключить

    "NoSteam" "1" // 1 - позволять игрокам играющие с пиратской версии игры создавать голосования | 0 - запретить

    "MutePlayer" "1" // 1 - позволять игроку у которого есть мут чата или микрофона создавать голосование (basecomm.smx) | 0 - запретить



    // Флаг админа, который...

    "FlagImmunity" "t" // Имеет иммунитет от голосования

    "FlagCancel" "d" // Может закрыть голосование



    // Команды наказаниий | >>

    // {NAME} - по нику

    // {UID} - по id

    // {STEAMID} - по steam id

    // {REASON} - причина



    "ban_settings"

    {

        "Command" "sm_ban {UID} 60 {REASON}" // Команда сервера, если голосование прошло удачно

        "TimeLimit" "0" // Тайм-лимит в секундах на игрока, использовавший голосование

        "Percent" "70" // Сколько процентов необходимо, чтобы забанить игрока

    }



    "kick_settings"

    {

        "Command" "sm_kick {UID} {REASON}"

        "TimeLimit" "0"

        "Percent" "65"

    }



    "mute_settings"

    {

        "Command" "sm_silence {UID}"

        "TimeLimit" "0"

        "Percent" "70"

    }



    "ban_reason"

    {

        "chat" "Написать причину в чате"

        "Багоюзер" "Багоюзер"

        "Читы" "Читы"

    }



    "kick_reason"

    {

        "chat" "Написать причину в чате"

        "Афк" "Афк"

        "Задержка игрового процесса" "Задержка игрового процесса"

    }



    "mute_reason"

    {

        "chat" "Написать причину в чате"

        "Мат" "Мат"

        "Обман" "Обман"

        "Оскорбление" "Оскорбление"

        "Троллинг" "Троллинг"

        "Реклама" "Реклама"

    }

}


Отправлено спустя 54 минуты 10 секунды:
Не обходимые инклюды для компиляции
Вложения
SteamWorks.zip
(6 KiB) Загружено 161 раз
VoteBKM.zip
(9.93 KiB) Загружено 156 раз

Аватар пользователя
Longipongeoos
Сообщений: 189
Зарегистрирован: 12 апр 2017, 16:50

Re: VoteBKM 1.0.5

Сообщение Longipongeoos » 08 апр 2023, 09:45

Не корректно работает с последним sourcemod-1.11.0 6931


Вернуться в «SourceMod»

Кто сейчас на форуме

Количество пользователей, которые сейчас просматривают этот форум: нет зарегистрированных пользователей и 1 гость