PLUGIN 2 ABI

Kood:

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

#define m_iJoinedState 121
#define JOINSTATE_INGAME 5

#define m_iUserPrefs 510
#define PREFS_VGUIMENUS (1<<0)

#define HasVGUIMenus(%1) (get_pdata_int(%1, m_iUserPrefs) & PREFS_VGUIMENUS)
#define SetVGUIMenus(%1) set_pdata_int(%1, m_iUserPrefs, (get_pdata_int(%1, m_iUserPrefs) | PREFS_VGUIMENUS))
#define RemoveVGUIMenus(%1) set_pdata_int(%1, m_iUserPrefs, (get_pdata_int(%1, m_iUserPrefs) & ~PREFS_VGUIMENUS))

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

enum BalanceMethod {
   Balance_Off,
   Balance_Spec,
   Balance_Transfer,
   Balance_Kick
};

#define VGUIMENU_ARG_MENUID 1
#define VGUIMENU_MENUID_TEAMSELECT 2

new gVGUIMenus;

new gCvarImmunity;
new gCvarImmunityFlag;
new gCvarAutoTeam;
new gCvarAutoFavor;
new gCvarAutoClass[CsTeams];
new gCvarAllowSwitch;
new gCvarLimit[CsTeams];
new gCvarRatio[CsTeams];
new gCvarBalance;

new gLimitTeams;

new Trie:gBalanceMethods;

new gMsgIdShowMenu;

new gMaxPlayers;

public plugin_init() {
   register_plugin("Teams Manager AIO", "0.0.6", "Exolent");
   
   register_clcmd("jointeam", "CmdJoinTeam");
   register_clcmd("chooseteam", "CmdChooseTeam");
   
   register_message(get_user_msgid("VGUIMenu"), "MessageVGUIMenu");
   register_message((gMsgIdShowMenu = get_user_msgid("ShowMenu")), "MessageShowMenu");
   
   register_menucmd(register_menuid("Team_Select", 1), (1<<0|1<<1|1<<4|1<<5|1<<9), "MenuTeamSelect");
   
   register_menucmd(register_menuid("CT_Select", 1), (1<<0|1<<1|1<<2|1<<3|1<<4), "MenuModelSelect");
   register_menucmd(register_menuid("Terrorist_Select", 1), (1<<0|1<<1|1<<2|1<<3|1<<4), "MenuModelSelect");
   
   register_event("HLTV", "EventNewRound", "a", "1=0", "2=0");
   register_event("TextMsg", "EventRestartRound", "a", "2&#Game_w", "2&#Game_C");
   register_logevent("EventRoundEnd", 2, "1=Round_End");
   
   gCvarImmunity = register_cvar("team_immunity", "0");
   gCvarImmunityFlag = register_cvar("team_immunity_flag", "a");
   
   gCvarAutoTeam = register_cvar("team_autojoin_team", "5");
   gCvarAutoFavor = register_cvar("team_autojoin_favor", "0");
   gCvarAutoClass[CS_TEAM_T]  = register_cvar("team_autojoin_class_t",  "5");
   gCvarAutoClass[CS_TEAM_CT] = register_cvar("team_autojoin_class_ct", "5");
   
   gCvarAllowSwitch = register_cvar("team_allow_switch", "1");
   
   gCvarLimit[CS_TEAM_T]  = register_cvar("team_limit_t",  "32");
   gCvarLimit[CS_TEAM_CT] = register_cvar("team_limit_ct", "32");
   
   gCvarRatio[CS_TEAM_T]  = register_cvar("team_ratio_t",  "1");
   gCvarRatio[CS_TEAM_CT] = register_cvar("team_ratio_ct", "1");
   
   gCvarBalance = register_cvar("team_balance", "off");
   
   gBalanceMethods = TrieCreate();
   TrieSetCell(gBalanceMethods, "no", Balance_Off);
   TrieSetCell(gBalanceMethods, "off", Balance_Off);
   TrieSetCell(gBalanceMethods, "none", Balance_Off);
   TrieSetCell(gBalanceMethods, "spec", Balance_Spec);
   TrieSetCell(gBalanceMethods, "spectate", Balance_Spec);
   TrieSetCell(gBalanceMethods, "spectater", Balance_Spec);
   TrieSetCell(gBalanceMethods, "spectator", Balance_Spec);
   TrieSetCell(gBalanceMethods, "move", Balance_Transfer);
   TrieSetCell(gBalanceMethods, "switch", Balance_Transfer);
   TrieSetCell(gBalanceMethods, "transfer", Balance_Transfer);
   TrieSetCell(gBalanceMethods, "kick", Balance_Kick);
   
   gMaxPlayers = get_maxplayers();
   
   new mp_limitteams = get_cvar_pointer("mp_limitteams");
   
   gLimitTeams = clamp(get_pcvar_num(mp_limitteams), 0, gMaxPlayers);
   
   if(gLimitTeams == gMaxPlayers) {
      gLimitTeams = 0;
   }
   
   set_pcvar_num(mp_limitteams, 0);
   set_cvar_num("mp_autoteambalance", 0);
}

public client_disconnect(id) {
   CheckVGUIMenus(id);
}

public CmdJoinTeam(id) {
   if(Immune(id)) {
      return PLUGIN_CONTINUE;
   }
   
   if(!get_pcvar_num(gCvarAllowSwitch) && cs_get_user_team(id)/* != CS_TEAM_UNASSIGNED */) {
      return PLUGIN_HANDLED;
   }
   
   new arg[11];
   read_argv(1, arg, charsmax(arg));
   
   if(is_str_num(arg)) {
      new team = str_to_num(arg);
      
      switch(team) {
         case 1, 2: {
            if(!CanJoinTeam(id, team)) {
               return PLUGIN_HANDLED;
            }
         }
         case 5: {
            if(CanJoinTeam(id, 1)) {
               if(CanJoinTeam(id, 2)) {
                  new favor = get_pcvar_num(gCvarAutoFavor);
                  
                  if(favor == 1 || favor == 2) {
                     arg[0] = favor + '0';
                     arg[1] = 0;
                     
                     ForceJoinTeam(id, arg, true);
                     
                     return PLUGIN_HANDLED;
                  }
                  
                  return PLUGIN_CONTINUE;
               }
               
               ForceJoinTeam(id, "1", true);
            }
            else if(CanJoinTeam(id, 2)) {
               ForceJoinTeam(id, "2", true);
            }
            
            return PLUGIN_HANDLED;
         }
      }
   }
   
   return PLUGIN_CONTINUE;
}

public CmdChooseTeam(id) {
   if(!Immune(id) && !get_pcvar_num(gCvarAllowSwitch) && cs_get_user_team(id)/* != CS_TEAM_UNASSIGNED */) {
      return PLUGIN_HANDLED;
   }
   
   return PLUGIN_CONTINUE;
}

public MessageVGUIMenu(msgId, dest, id) {
   if(is_user_connected(id)
   && !Immune(id)
   && get_msg_arg_int(VGUIMENU_ARG_MENUID) == VGUIMENU_MENUID_TEAMSELECT) {
      if(!CheckAutoJoin(id, msgId)) {
         SetBit(gVGUIMenus, id);
         
         RemoveVGUIMenus(id);
         
         set_task(0.1, "TaskForceChooseteam", id);
      }
      
      return PLUGIN_HANDLED;
   }
   
   return PLUGIN_CONTINUE;
}

public TaskForceAutoJoin(params[], id) {
   HandleAutoJoin(id, params[0], params[1]);
}

public TaskForceChooseteam(id) {
   engclient_cmd(id, "chooseteam");
}

public MessageShowMenu(msgId, dest, id) {
   if(Immune(id)) {
      return PLUGIN_CONTINUE;
   }
   
   new menuCode[32];
   get_msg_arg_string(4, menuCode, charsmax(menuCode));
   
   if(containi(menuCode, "Team_Select") > 0 && CheckAutoJoin(id, msgId)) {
      return PLUGIN_HANDLED;
   }
   
   return PLUGIN_CONTINUE;
}

bool:CheckAutoJoin(id, msgId) {
   new team = get_pcvar_num(gCvarAutoTeam);
   
   if(team == 1 || team == 2 || team == 5 || team == 6) {
      new params[2];
      params[0] = team;
      params[1] = msgId;
      
      set_task(0.1, "TaskForceAutoJoin", id, params, sizeof(params));
      
      return true;
   }
   
   return false;
}

public MenuTeamSelect(id, key) {
   if(Immune(id)) {
      return PLUGIN_CONTINUE;
   }
   
   switch(++key % 10) {
      case 1, 2: {
         if(!CanJoinTeam(id, key)) {
            engclient_cmd(id, "chooseteam");
            return PLUGIN_HANDLED;
         }
      }
      case 5: {
         if(CanJoinTeam(id, 1)) {
            if(CanJoinTeam(id, 2)) {
               new favor = get_pcvar_num(gCvarAutoFavor);
               
               if(favor == 1 || favor == 2) {
                  new team[2];
                  team[0] = favor + '0';
                  
                  ForceJoinTeam(id, team);
               }
               
               CheckVGUIMenus(id);
               
               return (1 <= favor <= 2) ? PLUGIN_HANDLED : PLUGIN_CONTINUE;
            }
            
            ForceJoinTeam(id, "1");
         }
         else if(CanJoinTeam(id, 2)) {
            ForceJoinTeam(id, "2");
         }
         
         CheckVGUIMenus(id);
         return PLUGIN_HANDLED;
      }
      case 6, 0: {
         CheckVGUIMenus(id);
      }
   }
   
   return PLUGIN_CONTINUE;
}

public MenuModelSelect(id, key) {
   CheckVGUIMenus(id);
}

#define TASKID_CHECK_TEAMS 100

public EventNewRound() {
   set_task(0.1, "TaskCheckTeams", TASKID_CHECK_TEAMS);
}

enum _:PlayerData {
   Player_Id,
   Player_Immunity,
   Player_Time
};

public TaskCheckTeams() {
   new BalanceMethod:balanceMethod = GetBalanceMethod();
   
   if(!balanceMethod) return;
   
   new id, i, CsTeams:team, teamPlayers[CsTeams][32][PlayerData], numPlayers[CsTeams];
   for(id = 1; id <= gMaxPlayers; id++) {
      if(is_user_connected(id)) {
         team = cs_get_user_team(id);
         i = numPlayers[team]++;
         
         teamPlayers[team][i][Player_Id] = id;
         teamPlayers[team][i][Player_Immunity] = Immune(id);
         teamPlayers[team][i][Player_Time] = get_user_time(id);
      }
   }
   
   new maxPlayers[CsTeams];
   GetMaxPlayers(numPlayers, maxPlayers);
   
   new bool:transferImmunity = (get_pcvar_num(gCvarImmunity) < 2);
   
   new CsTeams:otherTeam;
   for(team = CS_TEAM_T; team <= CS_TEAM_CT; team++) {
      i = numPlayers[team];
      
      SortCustom2D(teamPlayers[team], i, "SortPlayers");
      
      otherTeam = CS_TEAM_SPECTATOR - team;
      
      while(i > maxPlayers[team]) {
         if(!transferImmunity && teamPlayers[team][--i][Player_Immunity]) {
            break;
         }
         
         id = teamPlayers[team][i][Player_Id];
         
         switch(balanceMethod) {
            case Balance_Spec: {
               Transfer(id, CS_TEAM_SPECTATOR);
            }
            case Balance_Transfer: {
               if(numPlayers[otherTeam] < maxPlayers[otherTeam]) {
                  Transfer(id, otherTeam);
                  
                  teamPlayers[otherTeam][numPlayers[otherTeam]++] = teamPlayers[team][i];
               } else {
                  Transfer(id, CS_TEAM_SPECTATOR);
               }
            }
            case Balance_Kick: {
               server_cmd("kick #%d ^"Kicked to balance the teams^"", get_user_userid(id));
            }
         }
      }
      
      numPlayers[team] = i;
   }
}

public SortPlayers(player1[], player2[], players[][], data[], dataSize) {
   // first order by immunity
   new diff = player2[Player_Immunity] - player1[Player_Immunity];
   
   if(!diff) {
      // then order by played time
      diff = player2[Player_Time] - player1[Player_Time];
   }
   
   //return diff & ~((~1 >> 1) & ~1);
   
   return clamp(diff, -1, 1);
}

public EventRestartRound() {
   remove_task(TASKID_CHECK_TEAMS);
}

public EventRoundEnd() {
   remove_task(TASKID_CHECK_TEAMS);
}

CheckVGUIMenus(id) {
   if(GetBit(gVGUIMenus, id)) {
      DelBit(gVGUIMenus, id);
      
      SetVGUIMenus(id);
   }
}

bool:CanJoinTeam(id, team) {
   new numPlayers[CsTeams];
   for(new i = 1; i <= gMaxPlayers; i++) {
      if(i != id && is_user_connected(i)) {
         numPlayers[cs_get_user_team(i)]++;
      }
   }
   
   new maxPlayers[CsTeams];
   GetMaxPlayers(numPlayers, maxPlayers);
   
   return (numPlayers[CsTeams:team] < maxPlayers[CsTeams:team]);
}

GetMaxPlayers(numPlayers[CsTeams], maxPlayers[CsTeams]) {
   maxPlayers[CS_TEAM_T]  = GetLimit(_:CS_TEAM_T);
   maxPlayers[CS_TEAM_CT] = GetLimit(_:CS_TEAM_CT);
   
   new ratio[CsTeams];
   ratio[CS_TEAM_T]  = get_pcvar_num(gCvarRatio[CS_TEAM_T]);
   ratio[CS_TEAM_CT] = get_pcvar_num(gCvarRatio[CS_TEAM_CT]);
   
   if(ratio[CS_TEAM_T] > 0 && ratio[CS_TEAM_CT] > 0) {
      ReduceFraction(ratio[CS_TEAM_T], ratio[CS_TEAM_CT]);
      
      new ratioDiff = ratio[CS_TEAM_T] - ratio[CS_TEAM_CT];
      
      if(ratioDiff) {
         new totalPlayers = numPlayers[CS_TEAM_T] + numPlayers[CS_TEAM_CT];
         new ratioInterval = ratio[CS_TEAM_T] + ratio[CS_TEAM_CT];
         new ratioTotal = 0;
         new expectedPlayers[CsTeams];
         
         while((ratioTotal + ratioInterval) <= totalPlayers
         && (expectedPlayers[CS_TEAM_T]  + ratio[CS_TEAM_T])  <= maxPlayers[CS_TEAM_T]
         && (expectedPlayers[CS_TEAM_CT] + ratio[CS_TEAM_CT]) <= maxPlayers[CS_TEAM_CT]) {
            expectedPlayers[CS_TEAM_T]  += ratio[CS_TEAM_T];
            expectedPlayers[CS_TEAM_CT] += ratio[CS_TEAM_CT];
            
            ratioTotal += ratioInterval;
         }
         
         new CsTeams:largerTeam = (ratioDiff > 0) ? CS_TEAM_T : CS_TEAM_CT;
         
         expectedPlayers[largerTeam] += ratio[largerTeam];
         
         if(expectedPlayers[largerTeam] > maxPlayers[largerTeam]) {
            expectedPlayers[largerTeam] = maxPlayers[largerTeam];
         }
         
         maxPlayers = expectedPlayers;
      }
   }
   
   if(gLimitTeams) {
      if((numPlayers[CS_TEAM_T] - gLimitTeams) > numPlayers[CS_TEAM_CT]) {
         maxPlayers[CS_TEAM_T] = min(maxPlayers[CS_TEAM_T], numPlayers[CS_TEAM_CT] + gLimitTeams);
      }
      else if((numPlayers[CS_TEAM_CT] - gLimitTeams) > numPlayers[CS_TEAM_T]) {
         maxPlayers[CS_TEAM_CT] = min(maxPlayers[CS_TEAM_CT], numPlayers[CS_TEAM_T] + gLimitTeams);
      }
   }
}

GetLimit(team) {
   new limit[11];
   get_pcvar_string(gCvarLimit[CsTeams:team], limit, charsmax(limit));
   
   new value = is_str_num(limit) ? str_to_num(limit) : gMaxPlayers;
   
   if(value < 0 || value > gMaxPlayers) {
      value = gMaxPlayers;
   }
   
   return value;
}

ForceJoinTeam(id, team[], bool:checkVGUI = false) {
   if(checkVGUI && HasVGUIMenus(id)) {
      SetBit(gVGUIMenus, id);
      
      RemoveVGUIMenus(id);
   }
   
   new class[2];
   class[0] = get_pcvar_num(gCvarAutoClass[CsTeams:(team[0] - '0')]) + '0';
   
   if(!('1' <= class[0] <= '5')) {
      class[0] = '5';
   }
   
   DoJoin(id, gMsgIdShowMenu, team, class);
   
   if(checkVGUI) {
      CheckVGUIMenus(id);
   }
}

HandleAutoJoin(id, team, msgId) {
   if(team == 5) {
      if(CanJoinTeam(id, 1)) {
         if(!CanJoinTeam(id, 2)) {
            team = 1;
         } else {
            new favor = get_pcvar_num(gCvarAutoFavor);
            
            if(favor == 1 || favor == 2) {
               team = favor;
            } else {
               // use random instead of the engine's auto join
               // so we can know the class to auto-assign the player to
               team = random(2) + 1; //
            }
         }
      }
      else if(CanJoinTeam(id, 2)) {
         team = 2;
      } else {
         return;
      }
   }
   
   new teamString[2];
   teamString[0] = team + '0';
   
   new class = (team == 6) ? 1 : get_pcvar_num(gCvarAutoClass[CsTeams:team]);
   
   if(!(1 <= class <= 5)) {
      class = 5;
   }
   
   new classString[2];
   classString[0] = class + '0';
   
   DoJoin(id, msgId, teamString, classString);
}

DoJoin(id, msgId, team[], class[]) {
   new block = get_msg_block(msgId);
   set_msg_block(msgId, BLOCK_SET);
   
   engclient_cmd(id, "jointeam", team);
   
   if(team[0] != '6') {
      engclient_cmd(id, "joinclass", class);
   }
   
   set_msg_block(msgId, block);
}

ReduceFraction(&numerator, &denominator) {
   if(!numerator || !denominator) return;
   
   new maxDivisor = sqroot(min(numerator, denominator));
   
   for(new i = 2, j, a; i <= maxDivisor; i += a) {
      j = 0;
      
      while(!(numerator % i) && !(denominator % i)) {
         numerator /= i;
         denominator /= i;
         
         j = 1;
      }
      
      if(j) {
         maxDivisor = sqroot(min(numerator, denominator));
      }
      
      if(i == 2) a = 1;
      else if(i < 7) a = 2;
      else a = 6 - a;
   }
}

bool:Immune(id) {
   if(get_pcvar_num(gCvarImmunity)) {
      new flags[27];
      get_pcvar_string(gCvarImmunityFlag, flags, charsmax(flags));
      
      return bool:has_all_flags(id, flags);
   }
   
   return false;
}

BalanceMethod:GetBalanceMethod() {
   new methodString[32], BalanceMethod:method;
   get_pcvar_string(gCvarBalance, methodString, charsmax(methodString));
   
   if(is_str_num(methodString)) {
      method = BalanceMethod:str_to_num(methodString);
      
      if(!(Balance_Off <= method < BalanceMethod)) {
         method = GetDefaultBalanceMethod();
      }
   } else {
      strtolower(methodString);
      
      if(!TrieGetCell(gBalanceMethods, methodString, method)) {
         method = GetDefaultBalanceMethod();
      }
   }
   
   return method;
}

BalanceMethod:GetDefaultBalanceMethod() {
   set_pcvar_string(gCvarBalance, "off");
   
   return Balance_Off;
}

Transfer(id, CsTeams:team) {
   if(team == CS_TEAM_SPECTATOR) {
      if(is_user_alive(id)) {
         user_silentkill(id);
      }
      
      cs_set_user_team(id, team);
   } else {
      cs_set_user_team(id, team);
      
      ExecuteHamB(Ham_CS_RoundRespawn, id);
   }
   
   new const teamNames[CsTeams][] = {
      "", "Terrorist", "Counter-Terrorist", "Spectator"
   };
   
   client_print(id, print_chat, "* Sind liigutati %s tiimi.", teamNames[team]);
}

flammable kirjutas:Endal üldse viitsimist pole otsida?

PTB, vajuta siia!