public override void OnListPlayers(List<CPlayerInfo> players, CPlayerSubset subset)
{
foreach (var player in players)
{
var soldierName = player.SoldierName;
if (ignoreReservedPlayers && reservedPlayers != null && reservedPlayers.Contains(soldierName))
{
continue;
}
int rank = player.Rank;
if (rank == 0)
{
rank = _GetGameTrackerBC2Stats(soldierName);
if (rank == 0)
{
rank = _GetBFBCStatRank(soldierName);
if (rank == 0) continue;
}
}
if (rank > rankLimit)
{
ExecuteCommand("procon.protected.send", "admin.kickPlayer", soldierName, "You got kicked due to your Player Rank (" + rank + ") being too high!");
ExecuteCommand("procon.protected.send", "admin.say", "Kicked '" + soldierName + "' because their Player Rank (" + rank + ") is too high!");
}
}
}
public override void OnListPlayers(List<CPlayerInfo> players, CPlayerSubset subset)
{
if (reservedPlayers == null)
{
return;
}
foreach (var player in players)
{
var soldierName = player.SoldierName;
if (!reservedPlayers.Contains(soldierName))
{
_KickPlayer(soldierName);
}
}
}
public void OnCommandPlayerGUID(string strSpeaker, string strText, MatchCommand mtcCommand, CapturedCommand capCommand, CPlayerSubset subMatchedScope) {
if (this.m_enAllowPlayersToGuidOthers == enumBoolYesNo.Yes) {
if (base.PunkbusterPlayerInfoList.ContainsKey(capCommand.MatchedArguments[0].Argument) == true && base.PunkbusterPlayerInfoList[capCommand.MatchedArguments[0].Argument].GUID.Length == 32) {
this.ExecuteCommand("procon.protected.send", "admin.say", base.PunkbusterPlayerInfoList[capCommand.MatchedArguments[0].Argument].SoldierName + "'s P/GUID: " + base.PunkbusterPlayerInfoList[capCommand.MatchedArguments[0].Argument].GUID.Substring(24, 8), "player", strSpeaker);
}
else {
this.ExecuteCommand("procon.protected.send", "admin.say", "Player not found", "player", strSpeaker);
}
}
}
public override void OnListPlayers(List<CPlayerInfo> lstPlayers, CPlayerSubset cpsSubset)
{
// EVENT EXCEPTION BLOCK:
try
{
WriteDebugInfo("ProconRulz: ********************OnListPlayers******************************");
// if (trace_rules == enumBoolYesNo.Yes) prdebug("counts");
// if 'admin.listPlayers all' then do full update of players list and return
if (cpsSubset.Subset == CPlayerSubset.PlayerSubsetType.All)
{
players.pre_scrub(); // reset all 'updated' flags to false
admins_reset(); // empty list of currently logged on admins
foreach (CPlayerInfo cp_info in lstPlayers)
{
players.update(cp_info);
// add this player to list of logged-on admins if required
admins_add(cp_info.SoldierName);
// create/update a score variable for each player
string var_name = "%server_score[" + cp_info.SoldierName + "]%";
rulz_vars.set_value(null, var_name, cp_info.Score.ToString(), null);
}
players.scrub(); // remove all players that were not updated
}
if (trace_rules == enumBoolYesNo.Yes) prdebug("counts");
}
catch (Exception ex)
{
WriteConsole("ProconRulz: recoverable exception in OnListPlayers");
PrintException(ex);
}
}
public void onPlayersStatsCmd(List<CPlayerInfo> lstPlayers, CPlayerSubset cpsSubset) {
if (cpsSubset.Subset == CPlayerSubset.PlayerSubsetType.All)
foreach (CPlayerInfo cpiPlayer in lstPlayers)
if (this.players.ContainsKey(cpiPlayer.SoldierName))
this.players[cpiPlayer.SoldierName].updateInfo(cpiPlayer);
/* fail safe to get the maximum number of players in server */
if (lstPlayers.Count > max_player_count)
max_player_count = lstPlayers.Count;
}
public override void OnListPlayers(List<CPlayerInfo> players, CPlayerSubset subset)
{
if (!fIsEnabled) return;
DebugWrite("^9^bGot OnListPlayers^n", 8);
try {
if (subset.Subset != CPlayerSubset.PlayerSubsetType.All) return;
lock (fListPlayersQ) {
fListPlayersTimestamp = DateTime.Now;
Monitor.Pulse(fListPlayersQ);
}
/*
Check if server crashed or Blaze dumped players or model invalid for too long.
Detected by: last recorded server uptime is greater than zero and less than new uptime,
or a player model timed out while still being on the all players list,
or got an OnLogin callback, which is used in connection initialization for Procon,
or the current list of players is more than CRASH_COUNT_HEURISTIC players less than the last
recorded count, or the last known player count is greater than the maximum server size,
or more than 3 minutes have elapsed since a move/reassign was started.
Since these detections are not completely reliable, do a minimal amount of recovery,
don't do a full reset
*/
if (fServerCrashed
|| fGotLogin
|| fRefreshCommand
|| (fServerCrashed = (this.TotalPlayerCount >= 16
&& this.TotalPlayerCount > players.Count
&& (this.TotalPlayerCount - players.Count) >= Math.Min(CRASH_COUNT_HEURISTIC, this.TotalPlayerCount)))
|| this.TotalPlayerCount > MaximumServerSize
|| (fTimeOutOfJoint > 0 && GetTimeInRoundMinutes() - fTimeOutOfJoint > 3.0)) {
ValidateModel(players);
fServerCrashed = false;
fGotLogin = false;
fRefreshCommand = false;
fTimeOutOfJoint = 0;
} else {
fUnassigned.Clear();
foreach (CPlayerInfo p in players) {
try {
UpdatePlayerModel(p.SoldierName, p.TeamID, p.SquadID, p.GUID, p.Score, p.Kills, p.Deaths, p.Rank);
} catch (Exception e) {
ConsoleException(e);
continue;
}
}
}
GarbageCollectKnownPlayers(); // also resets LastMoveTo
UpdateTeams();
LogStatus(false, DebugLevel);
/* Special handling for JustEnabled state */
if (fPluginState == PluginState.JustEnabled) {
fPluginState = PluginState.Active;
fRoundStartTimestamp = DateTime.Now;
DebugWrite("^b^3State = " + fPluginState, 6);
}
// Use updated player list, one-time updates
if (fNeedPlayerListUpdate) {
try { AssignGroups(); } catch (Exception e) { ConsoleException(e); }
try { RememberTeams(); } catch (Exception e) { ConsoleException(e); }
fNeedPlayerListUpdate = false;
}
//CommandToLog("whitelist");
foreach (CPlayerInfo p in players) {
try {
PlayerModel player = GetPlayer(p.SoldierName);
if (player == null) continue;
String guid = (String.IsNullOrEmpty(player.EAGUID)) ? INVALID_NAME_TAG_GUID : player.EAGUID;
String xt = ExtractTag(player);
if (String.IsNullOrEmpty(xt)) xt = INVALID_NAME_TAG_GUID;
foreach (String item in fSettingWhitelist) {
List<String> tokens = new List<String>(Regex.Split(item, @"\s+"));
if (tokens.Count < 1) {
continue;
}
if (tokens[0] == player.Name || tokens[0] == xt || tokens[0] == guid) {
if (player.Whitelist == 0) {
DebugWrite("^8^bWARNING^n^0: (^b" + player.Name + ", " + xt + ", ^n" + guid + ") matches (" + String.Join(", ", tokens.ToArray()) + ") ^8^bBUT NO WHITELIST FLAGS SET!", 7);
}
}
}
} catch (Exception e) {
ConsoleException(e);
}
}
} catch (Exception e) {
ConsoleException(e);
}
}
public void OnCommandToggle(string strSpeaker, string strText, MatchCommand mtcCommand, CapturedCommand capCommand, CPlayerSubset subMatchedScope)
{
if (capCommand.ExtraArguments == "0" || capCommand.ExtraArguments == "off")
{
this.ExecuteCommand("procon.protected.send", "admin.say", "RankKicker disabled!", "all");
this.ExecuteCommand("procon.protected.pluginconsole.write", "^b^4AccessRestriction: ^0RankKicker disabled ingame!");
this.m_RankKickerOnOff = enumBoolOnOff.Off;
}
else if (capCommand.ExtraArguments == "1" || capCommand.ExtraArguments == "on")
{
this.ExecuteCommand("procon.protected.send", "admin.say", "RankKicker enabled!", "all");
this.ExecuteCommand("procon.protected.pluginconsole.write", "^b^4AccessRestriction: ^0RankKicker enabled ingame!");
this.m_RankKickerOnOff = enumBoolOnOff.On;
}
else if (capCommand.ExtraArguments == "clear")
{
Clear(0);
}
else if (capCommand.ExtraArguments == "check")
{
this.ExecuteCommand("procon.protected.send", "admin.say", "RankKicker checking all players!", "all");
this.ExecuteCommand("procon.protected.pluginconsole.write", "^b^4AccessRestriction: ^0RankKicker checking all players!");
this.ExecuteCommand("procon.protected.send", "admin.listPlayers", "all");
}
else
{
this.ExecuteCommand("procon.protected.send", "admin.say", "Wrong arguments. Use '0'/'off', '1'/'on', 'clear' or 'check'!", "all");
}
}
public void OnListPlayers(List<CPlayerInfo> lstPlayers, CPlayerSubset cpsSubset) {
}
public override void OnListPlayers(List<CPlayerInfo> players, CPlayerSubset subset)
{
}
public override void OnListPlayers(List<CPlayerInfo> Players, CPlayerSubset Subset)
{
PlayerList = Players;
if (ZombieModeEnabled == false)
return;
if (Players.Count + JoinQueue.Count > 0 && GetState() != GState.Idle) DebugWrite("OnListPlayers: " + Players.Count + " players, " + JoinQueue.Count + " joining", 5);
if (OldGameState != GetState()) DebugWrite("OnListPlayers: GameState = " + GetState(), 3);
OldGameState = GetState();
if (CheckIdle(Players))
{
// We kicked some idle players, so update the player list again
RequestPlayersList();
return;
}
List<String> HumanCensus = new List<String>();
List<String> ZombieCensus = new List<String>();
foreach (CPlayerInfo Player in Players)
{
KillTracker.AddPlayer(Player.SoldierName.ToString());
// Team tracking
if (Player.TeamID == 1)
{
HumanCensus.Add(Player.SoldierName);
DebugWrite("OnListPlayers: counted " + Player.SoldierName + " as human (" + HumanCensus.Count + ")", 6);
}
else if (Player.TeamID == 2)
{
// Othewise, add
ZombieCensus.Add(Player.SoldierName);
DebugWrite("OnListPlayers: counted " + Player.SoldierName + " as zombie (" + ZombieCensus.Count + ")", 6);
}
else
{
DebugWrite("OnListPlayers: unknown team " + Player.TeamID + " for player " + Player.SoldierName, 5);
}
RemoveJoinQueue(Player.SoldierName);
}
// Check for differences
KnownPlayerCount = HumanCensus.Count + ZombieCensus.Count;
bool SomeoneMoved = false;
lock (TeamHuman)
{
if (Players.Count > 0) DebugWrite("OnListPlayers: human count " + TeamHuman.Count + " vs " + HumanCensus.Count + ", zombie count " + TeamZombie.Count + " vs " + ZombieCensus.Count, 6);
SomeoneMoved = (TeamHuman.Count != HumanCensus.Count);
SomeoneMoved |= (TeamZombie.Count != ZombieCensus.Count);
}
if (GetState() != GState.Idle && (HumanCensus.Count+ZombieCensus.Count) == 0)
{
Reset();
return;
}
if (GetState() == GState.Playing)
{
if (SomeoneMoved)
{
DebugWrite("OnListPlayers: playing, checking victory conditions", 5);
}
CheckVictoryConditions(false);
}
else if (GetState() == GState.BetweenRounds)
{
DebugWrite("OnListPlayers: between rounds", 5);
}
else if (GetState() == GState.Idle || GetState() == GState.Waiting || GetState() == GState.RoundStarting)
{
// force update when not playing a match
if (SomeoneMoved)
{
DebugWrite("OnListPlayers: teams updated, not playing yet", 5);
lock (TeamHuman)
{
TeamHuman.Clear();
TeamHuman.AddRange(HumanCensus);
TeamZombie.Clear();
TeamZombie.AddRange(ZombieCensus);
}
}
}
}
public void OnCommandPlayerTimes(string strSpeaker, string strText, MatchCommand mtcCommand, CapturedCommand capCommand, CPlayerSubset subMatchedScope) {
if (this.m_enAllowPlayersToTimeOthers == enumBoolYesNo.Yes) {
if (base.FrostbitePlayerInfoList.ContainsKey(capCommand.MatchedArguments[0].Argument) == true && base.FrostbitePlayerInfoList[capCommand.MatchedArguments[0].Argument].SessionTime != 0) {
string strOutTime = this.SecondsToText((UInt32)base.FrostbitePlayerInfoList[capCommand.MatchedArguments[0].Argument].SessionTime, this.m_astrTimeDescription, true);
this.ExecuteCommand("procon.protected.send", "admin.say", base.FrostbitePlayerInfoList[capCommand.MatchedArguments[0].Argument].SoldierName + "'s playTime: " + strOutTime, "player", strSpeaker);
} else {
this.ExecuteCommand("procon.protected.send", "admin.say", "Player not found / or just joined", "player", strSpeaker);
}
}
}
public void OnCommandMyTimes(string strSpeaker, string strText, MatchCommand mtcCommand, CapturedCommand capCommand, CPlayerSubset subMatchedScope) {
if (base.FrostbitePlayerInfoList.ContainsKey(strSpeaker) == true && base.FrostbitePlayerInfoList[strSpeaker].SessionTime != 0) {
string strOutTime = this.SecondsToText((UInt32)base.FrostbitePlayerInfoList[strSpeaker].SessionTime, this.m_astrTimeDescription, true);
this.ExecuteCommand("procon.protected.send", "admin.say", "Your current playTime: " + strOutTime, "player", strSpeaker);
} else {
this.ExecuteCommand("procon.protected.send", "admin.say", "Sorry, you've just joined =(", "player", strSpeaker);
}
}
public void OnCommandVersion(string strSpeaker, string strText, MatchCommand mtcCommand, CapturedCommand capCommand, CPlayerSubset subMatchedScope) {
this.ExecuteCommand("procon.protected.send", "admin.say", String.Format("IP: {0}, Location: {1}, Rcon: PRoCon {2}", this.m_strHostName, this.GetVariable<string>("SERVER_COUNTRY", ""), this.m_strPRoConVersion), "player", strSpeaker);
}
public void OnCommandHelpSpecific(string strSpeaker, string strText, MatchCommand mtcCommand, CapturedCommand capCommand, CPlayerSubset subMatchedScope) {
List<MatchCommand> lstCommands = this.GetRegisteredCommands();
CPrivileges privileges = this.GetAccountPrivileges(strSpeaker);
foreach (MatchCommand mtcLoopedCommand in lstCommands) {
if (String.Compare(mtcLoopedCommand.Command, capCommand.MatchedArguments[0].Argument, true) == 0 && mtcLoopedCommand.Requirements.HasValidPermissions(privileges) == true) {
foreach (string strLine in this.WordWrap(String.Format("> {0}; {1}", mtcLoopedCommand.ToString(), mtcLoopedCommand.Description), 100)) {
this.ExecuteCommand("procon.protected.send", "admin.say", strLine, "player", strSpeaker);
}
}
}
}
public void OnCommandHelp(string strSpeaker, string strText, MatchCommand mtcCommand, CapturedCommand capCommand, CPlayerSubset subMatchedScope) {
this.ExecuteCommand("procon.protected.send", "admin.say", String.Format("Type \"{0}help [command]\" for more information about a command:", capCommand.ResposeScope), "player", strSpeaker);
foreach (string strCommandOutput in this.WordWrap(String.Join(", ", this.GetExcludedCommandStrings(strSpeaker).ToArray()), 100)) {
this.ExecuteCommand("procon.protected.send", "admin.say", strCommandOutput, "player", strSpeaker);
}
}
// Communication Events
public void OnYelling(string strMessage, int iMessageDuration, CPlayerSubset cpsSubset) {
}
public void OnSaying(string strMessage, CPlayerSubset cpsSubset) {
}
public override void OnListPlayers(List<CPlayerInfo> players, CPlayerSubset subset)
{
List<string> tmpTeam1Players = new List<string>();
List<string> tmpTeam2Players = new List<string>();
foreach(CPlayerInfo player in players){
if(player.TeamID == 1){
tmpTeam1Players.Add(player.SoldierName);
} else if(player.TeamID == 2){
tmpTeam2Players.Add(player.SoldierName);
}
}
this.team1Players = tmpTeam1Players;
this.team2Players = tmpTeam2Players;
}
public override void OnListPlayers(List<CPlayerInfo> players, CPlayerSubset cpsSubset)
{
try {
//Only handle the list if it is an "All players" list
if (cpsSubset.Subset == CPlayerSubset.PlayerSubsetType.All) {
//Return if small duration (5 seconds) since last player list
if ((DateTime.UtcNow - this._LastSuccessfulPlayerList) < TimeSpan.FromSeconds(5)) {
//Avoid "over-handling" player listing
}
else {
//Only perform the following if all threads are ready
if (this._ThreadsReady) {
this.QueuePlayerListForProcessing(players);
}
}
}
}
catch (Exception e) {
this.HandleException(new AdKatsException("Error occured while listing players.", e));
}
}
public override void OnListPlayers(List<CPlayerInfo> lstPlayers, CPlayerSubset cpsSubset) {
int numStatsFetch = this.intMaxPlayersToFetch;
int numRemaining = lstPlayers.Count;
if (lstPlayers.Count == 0 && this.boolnoplayer == false){
this.boolnoplayer = true;
this.dicPlayerCache.Clear();
this.DebugInfo("^3^b" + lstPlayers.Count.ToString() + " Players on the server.");
return;
} else if (lstPlayers.Count != 0 && this.boolnoplayer) {
this.boolnoplayer = false;
} else if (lstPlayers.Count == 0) {
return; // suppress debugging messages for empty server
}
TimeSpan ScrambleTime = new TimeSpan(0);
ScrambleTime = DateTime.Now - this.DTScramblestarted;
if (ScrambleTime.TotalSeconds > 20 && this.boolscrambleActive){
this.DebugInfoSkill("^b^8Was not able to scramble teams in 15 seconds! Teams partly scrambled.");
this.boolTeamsScrambled = true;
this.intScrambledPlayers = 0;
this.boolscrambleNow = false;
this.boolscrambleActive = false;
this.intScrambleCount = 0;
}
if (!this.boolscrambleActive){
List<String> removeFromCache = new List<String>();
int numWithStats = 0;
foreach (String k in this.dicPlayerCache.Keys) {
if (this.dicPlayerCache[k].statsFetched) ++numWithStats;
}
DebugInfoSkill("OnListPlayers: Players = " + lstPlayers.Count + " vs Known with stats = " + numWithStats);
foreach (KeyValuePair<string, CPlayerJoinInf> kvp in this.dicPlayerCache)
{
if (this.m_isPluginEnabled == false) break;
this.boolplayerexists = false;
foreach (CPlayerInfo cpiPlayer in lstPlayers)
{
if (this.m_isPluginEnabled == false) break;
if (cpiPlayer.SoldierName == kvp.Key)
{
boolplayerexists = true;
if (this.dicPlayerCache[kvp.Key].teamID != cpiPlayer.TeamID){
if(this.boolmanuellchange && this.dicPlayerCache[kvp.Key].teamID != 0 && kvp.Key != this.strMovedPlayer){
this.dicPlayerCache[kvp.Key].Playerjoined = DateTime.Now;
this.dicPlayerCache[kvp.Key].playerWL = 0;
this.DebugInfo("Switched Manually!");
}
this.dicPlayerCache[kvp.Key].teamID = cpiPlayer.TeamID;
}
this.dicPlayerCache[kvp.Key].playerSquad = cpiPlayer.SquadID;
this.dicPlayerCache[kvp.Key].score = cpiPlayer.Score;
if (this.strcurrentGametype.Contains("Conquest") || this.strcurrentGametype.Contains("TankSuperiority0") || this.strcurrentGametype.Contains("Scavenger0") || this.strcurrentGametype.Contains("AirSuperiority0") || this.strcurrentGametype.Contains("CarrierAssault") || this.strcurrentGametype.Contains("Chainlink"))
{
if (this.ScrambleByCONQUEST == "Rank")
{
this.dicPlayerCache[kvp.Key].playerValue = this.dicPlayerCache[kvp.Key].rank;
}
else if (this.ScrambleByCONQUEST == "Skill")
{
this.dicPlayerCache[kvp.Key].playerValue = this.dicPlayerCache[kvp.Key].skill;
}
else if (this.ScrambleByCONQUEST == "SPM")
{
this.dicPlayerCache[kvp.Key].playerValue = this.dicPlayerCache[kvp.Key].spm;
}
else if (this.ScrambleByCONQUEST == "SPMcombat")
{
this.dicPlayerCache[kvp.Key].playerValue = this.dicPlayerCache[kvp.Key].spmcombat;
}
else if (this.ScrambleByCONQUEST == "K/D")
{
this.dicPlayerCache[kvp.Key].playerValue = this.dicPlayerCache[kvp.Key].kdr;
}
else if (this.ScrambleByCONQUEST == "TB-Value")
{
this.dicPlayerCache[kvp.Key].playerValue = this.dicPlayerCache[kvp.Key].TBvalue;
}
}
if (this.strcurrentGametype.Contains("Domination"))
{
if (this.ScrambleByDOM == "Rank")
{
this.dicPlayerCache[kvp.Key].playerValue = this.dicPlayerCache[kvp.Key].rank;
}
else if (this.ScrambleByDOM == "Skill")
{
this.dicPlayerCache[kvp.Key].playerValue = this.dicPlayerCache[kvp.Key].skill;
}
else if (this.ScrambleByDOM == "SPM")
{
this.dicPlayerCache[kvp.Key].playerValue = this.dicPlayerCache[kvp.Key].spm;
}
else if (this.ScrambleByDOM == "SPMcombat")
{
this.dicPlayerCache[kvp.Key].playerValue = this.dicPlayerCache[kvp.Key].spmcombat;
}
else if (this.ScrambleByDOM == "K/D")
{
this.dicPlayerCache[kvp.Key].playerValue = this.dicPlayerCache[kvp.Key].kdr;
}
else if (this.ScrambleByDOM == "TB-Value")
{
this.dicPlayerCache[kvp.Key].playerValue = this.dicPlayerCache[kvp.Key].TBvalue;
}
}
else if (this.strcurrentGametype.Contains("Obliteration"))
{
if (this.ScrambleByOB == "Rank")
{
this.dicPlayerCache[kvp.Key].playerValue = this.dicPlayerCache[kvp.Key].rank;
}
else if (this.ScrambleByOB == "Skill")
{
this.dicPlayerCache[kvp.Key].playerValue = this.dicPlayerCache[kvp.Key].skill;
}
else if (this.ScrambleByOB == "SPM")
{
this.dicPlayerCache[kvp.Key].playerValue = this.dicPlayerCache[kvp.Key].spm;
}
else if (this.ScrambleByOB == "SPMcombat")
{
this.dicPlayerCache[kvp.Key].playerValue = this.dicPlayerCache[kvp.Key].spmcombat;
}
else if (this.ScrambleByOB == "K/D")
{
this.dicPlayerCache[kvp.Key].playerValue = this.dicPlayerCache[kvp.Key].kdr;
}
else if (this.ScrambleByOB == "TB-Value")
{
this.dicPlayerCache[kvp.Key].playerValue = this.dicPlayerCache[kvp.Key].TBvalue;
}
}
else if (this.strcurrentGametype.Contains("Rush"))
{
if (this.ScrambleByRUSH == "Rank"){
this.dicPlayerCache[kvp.Key].playerValue = this.dicPlayerCache[kvp.Key].rank;
}else if (this.ScrambleByRUSH == "Skill"){
this.dicPlayerCache[kvp.Key].playerValue = this.dicPlayerCache[kvp.Key].skill;
}else if (this.ScrambleByRUSH == "SPM"){
this.dicPlayerCache[kvp.Key].playerValue = this.dicPlayerCache[kvp.Key].spm;
}else if (this.ScrambleByRUSH == "SPMcombat"){
this.dicPlayerCache[kvp.Key].playerValue = this.dicPlayerCache[kvp.Key].spmcombat;
}else if (this.ScrambleByRUSH == "K/D"){
this.dicPlayerCache[kvp.Key].playerValue = this.dicPlayerCache[kvp.Key].kdr;
}
else if (this.ScrambleByRUSH == "TB-Value")
{
this.dicPlayerCache[kvp.Key].playerValue = this.dicPlayerCache[kvp.Key].TBvalue;
}
}
else if (this.strcurrentGametype.Contains("GunMaster") || this.strcurrentGametype.Contains("CaptureTheFlag0"))
{
if (this.ScrambleByGM == "Rank")
{
this.dicPlayerCache[kvp.Key].playerValue = this.dicPlayerCache[kvp.Key].rank;
}
else if (this.ScrambleByGM == "Skill")
{
this.dicPlayerCache[kvp.Key].playerValue = this.dicPlayerCache[kvp.Key].skill;
}
else if (this.ScrambleByGM == "SPM")
{
this.dicPlayerCache[kvp.Key].playerValue = this.dicPlayerCache[kvp.Key].spm;
}
else if (this.ScrambleByGM == "SPMcombat")
{
this.dicPlayerCache[kvp.Key].playerValue = this.dicPlayerCache[kvp.Key].spmcombat;
}
else if (this.ScrambleByGM == "K/D")
{
this.dicPlayerCache[kvp.Key].playerValue = this.dicPlayerCache[kvp.Key].kdr;
}
else if (this.ScrambleByGM == "TB-Value")
{
this.dicPlayerCache[kvp.Key].playerValue = this.dicPlayerCache[kvp.Key].TBvalue;
}
}
else if (this.strcurrentGametype.Contains("Elimination"))
{
if (this.ScrambleByDF == "Rank")
{
this.dicPlayerCache[kvp.Key].playerValue = this.dicPlayerCache[kvp.Key].rank;
}
else if (this.ScrambleByDF == "Skill")
{
this.dicPlayerCache[kvp.Key].playerValue = this.dicPlayerCache[kvp.Key].skill;
}
else if (this.ScrambleByDF == "SPM")
{
this.dicPlayerCache[kvp.Key].playerValue = this.dicPlayerCache[kvp.Key].spm;
}
else if (this.ScrambleByDF == "SPMcombat")
{
this.dicPlayerCache[kvp.Key].playerValue = this.dicPlayerCache[kvp.Key].spmcombat;
}
else if (this.ScrambleByDF == "K/D")
{
this.dicPlayerCache[kvp.Key].playerValue = this.dicPlayerCache[kvp.Key].kdr;
}
else if (this.ScrambleByDF == "TB-Value")
{
this.dicPlayerCache[kvp.Key].playerValue = this.dicPlayerCache[kvp.Key].TBvalue;
}
}
else if (this.strcurrentGametype.Contains("TeamDeathMatch"))
{
if (this.ScrambleByTDM == "Rank"){
this.dicPlayerCache[kvp.Key].playerValue = this.dicPlayerCache[kvp.Key].rank;
}else if (this.ScrambleByTDM == "Skill"){
this.dicPlayerCache[kvp.Key].playerValue = this.dicPlayerCache[kvp.Key].skill;
}else if (this.ScrambleByTDM == "SPM"){
this.dicPlayerCache[kvp.Key].playerValue = this.dicPlayerCache[kvp.Key].spm;
}else if (this.ScrambleByTDM == "SPMcombat"){
this.dicPlayerCache[kvp.Key].playerValue = this.dicPlayerCache[kvp.Key].spmcombat;
}else if (this.ScrambleByTDM == "K/D"){
this.dicPlayerCache[kvp.Key].playerValue = this.dicPlayerCache[kvp.Key].kdr;
}
else if (this.ScrambleByTDM == "TB-Value")
{
this.dicPlayerCache[kvp.Key].playerValue = this.dicPlayerCache[kvp.Key].TBvalue;
}
}
if ( ( ((IList<string>)this.strAWhitelistComplete).Contains(cpiPlayer.SoldierName) || ( ((IList<string>)this.strAClantagWhitelist).Contains(dicPlayerCache[cpiPlayer.SoldierName].tag) && dicPlayerCache[cpiPlayer.SoldierName].tag != String.Empty ) ) && this.ynbWhitelist == enumBoolYesNo.Yes)
{
this.dicPlayerCache[kvp.Key].playerWL = 1;
}
break;
}
}
if (boolplayerexists == false)
{
if (!removeFromCache.Contains(kvp.Key))
{
removeFromCache.Add(kvp.Key);
}
// FIXME this.dicPlayerCache.Remove(kvp.Key);
//PlayersOnServer.Remove(kvp.Key);
}
}
foreach (String s in removeFromCache)
{
if (this.dicPlayerCache.ContainsKey(s))
{
this.dicPlayerCache.Remove(s);
}
}
foreach (CPlayerInfo cpiPlayer in lstPlayers)
{
if (this.m_isPluginEnabled == false) break;
--numRemaining;
if (this.dicPlayerCache.ContainsKey(cpiPlayer.SoldierName) == true && this.dicPlayerCache[cpiPlayer.SoldierName].statsFetched)
{
if (this.dicPlayerCache[cpiPlayer.SoldierName].teamID != cpiPlayer.TeamID){
if(this.boolmanuellchange && this.dicPlayerCache[cpiPlayer.SoldierName].teamID != 0 && cpiPlayer.SoldierName != this.strMovedPlayer){
this.dicPlayerCache[cpiPlayer.SoldierName].Playerjoined = DateTime.Now;
this.dicPlayerCache[cpiPlayer.SoldierName].playerWL = 0;
this.DebugInfo("Switched Manually!(2)");
}
this.dicPlayerCache[cpiPlayer.SoldierName].teamID = cpiPlayer.TeamID;
}
this.dicPlayerCache[cpiPlayer.SoldierName].playerSquad = cpiPlayer.SquadID;
this.dicPlayerCache[cpiPlayer.SoldierName].score = cpiPlayer.Score;
if (this.strcurrentGametype.Contains("Conquest") || this.strcurrentGametype.Contains("TankSuperiority0") || this.strcurrentGametype.Contains("Scavenger") || this.strcurrentGametype.Contains("AirSuperiority0") || this.strcurrentGametype.Contains("CarrierAssault") || this.strcurrentGametype.Contains("Chainlink"))
{
if (this.ScrambleByCONQUEST == "Rank")
{
this.dicPlayerCache[cpiPlayer.SoldierName].playerValue = this.dicPlayerCache[cpiPlayer.SoldierName].rank;
}
else if (this.ScrambleByCONQUEST == "Skill")
{
this.dicPlayerCache[cpiPlayer.SoldierName].playerValue = this.dicPlayerCache[cpiPlayer.SoldierName].skill;
}
else if (this.ScrambleByCONQUEST == "SPM")
{
this.dicPlayerCache[cpiPlayer.SoldierName].playerValue = this.dicPlayerCache[cpiPlayer.SoldierName].spm;
}
else if (this.ScrambleByCONQUEST == "SPMcombat")
{
this.dicPlayerCache[cpiPlayer.SoldierName].playerValue = this.dicPlayerCache[cpiPlayer.SoldierName].spmcombat;
}
else if (this.ScrambleByCONQUEST == "K/D")
{
this.dicPlayerCache[cpiPlayer.SoldierName].playerValue = this.dicPlayerCache[cpiPlayer.SoldierName].kdr;
}
else if (this.ScrambleByCONQUEST == "TB-Value")
{
this.dicPlayerCache[cpiPlayer.SoldierName].playerValue = this.dicPlayerCache[cpiPlayer.SoldierName].TBvalue;
}
}
if (this.strcurrentGametype.Contains("Domination"))
{
if (this.ScrambleByDOM == "Rank")
{
this.dicPlayerCache[cpiPlayer.SoldierName].playerValue = this.dicPlayerCache[cpiPlayer.SoldierName].rank;
}
else if (this.ScrambleByDOM == "Skill")
{
this.dicPlayerCache[cpiPlayer.SoldierName].playerValue = this.dicPlayerCache[cpiPlayer.SoldierName].skill;
}
else if (this.ScrambleByDOM == "SPM")
{
this.dicPlayerCache[cpiPlayer.SoldierName].playerValue = this.dicPlayerCache[cpiPlayer.SoldierName].spm;
}
else if (this.ScrambleByDOM == "SPMcombat")
{
this.dicPlayerCache[cpiPlayer.SoldierName].playerValue = this.dicPlayerCache[cpiPlayer.SoldierName].spmcombat;
}
else if (this.ScrambleByDOM == "K/D")
{
this.dicPlayerCache[cpiPlayer.SoldierName].playerValue = this.dicPlayerCache[cpiPlayer.SoldierName].kdr;
}
else if (this.ScrambleByDOM == "TB-Value")
{
this.dicPlayerCache[cpiPlayer.SoldierName].playerValue = this.dicPlayerCache[cpiPlayer.SoldierName].TBvalue;
}
}
else if (this.strcurrentGametype.Contains("Obliteration"))
{
if (this.ScrambleByOB == "Rank")
{
this.dicPlayerCache[cpiPlayer.SoldierName].playerValue = this.dicPlayerCache[cpiPlayer.SoldierName].rank;
}
else if (this.ScrambleByOB == "Skill")
{
this.dicPlayerCache[cpiPlayer.SoldierName].playerValue = this.dicPlayerCache[cpiPlayer.SoldierName].skill;
}
else if (this.ScrambleByOB == "SPM")
{
this.dicPlayerCache[cpiPlayer.SoldierName].playerValue = this.dicPlayerCache[cpiPlayer.SoldierName].spm;
}
else if (this.ScrambleByOB == "SPMcombat")
{
this.dicPlayerCache[cpiPlayer.SoldierName].playerValue = this.dicPlayerCache[cpiPlayer.SoldierName].spmcombat;
}
else if (this.ScrambleByOB == "K/D")
{
this.dicPlayerCache[cpiPlayer.SoldierName].playerValue = this.dicPlayerCache[cpiPlayer.SoldierName].kdr;
}
else if (this.ScrambleByOB == "TB-Value")
{
this.dicPlayerCache[cpiPlayer.SoldierName].playerValue = this.dicPlayerCache[cpiPlayer.SoldierName].TBvalue;
}
}
else if (this.strcurrentGametype.Contains("Rush"))
{
if (this.ScrambleByRUSH == "Rank"){
this.dicPlayerCache[cpiPlayer.SoldierName].playerValue = this.dicPlayerCache[cpiPlayer.SoldierName].rank;
}else if (this.ScrambleByRUSH == "Skill"){
this.dicPlayerCache[cpiPlayer.SoldierName].playerValue = this.dicPlayerCache[cpiPlayer.SoldierName].skill;
}else if (this.ScrambleByRUSH == "SPM"){
this.dicPlayerCache[cpiPlayer.SoldierName].playerValue = this.dicPlayerCache[cpiPlayer.SoldierName].spm;
}else if (this.ScrambleByRUSH == "SPMcombat"){
this.dicPlayerCache[cpiPlayer.SoldierName].playerValue = this.dicPlayerCache[cpiPlayer.SoldierName].spmcombat;
}else if (this.ScrambleByRUSH == "K/D"){
this.dicPlayerCache[cpiPlayer.SoldierName].playerValue = this.dicPlayerCache[cpiPlayer.SoldierName].kdr;
}
else if (this.ScrambleByRUSH == "TB-Value")
{
this.dicPlayerCache[cpiPlayer.SoldierName].playerValue = this.dicPlayerCache[cpiPlayer.SoldierName].TBvalue;
}
}
else if (this.strcurrentGametype.Contains("GunMaster") || this.strcurrentGametype.Contains("CaptureTheFlag0"))
{
if (this.ScrambleByGM == "Rank")
{
this.dicPlayerCache[cpiPlayer.SoldierName].playerValue = this.dicPlayerCache[cpiPlayer.SoldierName].rank;
}
else if (this.ScrambleByGM == "Skill")
{
this.dicPlayerCache[cpiPlayer.SoldierName].playerValue = this.dicPlayerCache[cpiPlayer.SoldierName].skill;
}
else if (this.ScrambleByGM == "SPM")
{
this.dicPlayerCache[cpiPlayer.SoldierName].playerValue = this.dicPlayerCache[cpiPlayer.SoldierName].spm;
}
else if (this.ScrambleByGM == "SPMcombat")
{
this.dicPlayerCache[cpiPlayer.SoldierName].playerValue = this.dicPlayerCache[cpiPlayer.SoldierName].spmcombat;
}
else if (this.ScrambleByGM == "K/D")
{
this.dicPlayerCache[cpiPlayer.SoldierName].playerValue = this.dicPlayerCache[cpiPlayer.SoldierName].kdr;
}
else if (this.ScrambleByGM == "TB-Value")
{
this.dicPlayerCache[cpiPlayer.SoldierName].playerValue = this.dicPlayerCache[cpiPlayer.SoldierName].TBvalue;
}
}
else if (this.strcurrentGametype.Contains("Elimination"))
{
if (this.ScrambleByDF == "Rank")
{
this.dicPlayerCache[cpiPlayer.SoldierName].playerValue = this.dicPlayerCache[cpiPlayer.SoldierName].rank;
}
else if (this.ScrambleByDF == "Skill")
{
this.dicPlayerCache[cpiPlayer.SoldierName].playerValue = this.dicPlayerCache[cpiPlayer.SoldierName].skill;
}
else if (this.ScrambleByDF == "SPM")
{
this.dicPlayerCache[cpiPlayer.SoldierName].playerValue = this.dicPlayerCache[cpiPlayer.SoldierName].spm;
}
else if (this.ScrambleByDF == "SPMcombat")
{
this.dicPlayerCache[cpiPlayer.SoldierName].playerValue = this.dicPlayerCache[cpiPlayer.SoldierName].spmcombat;
}
else if (this.ScrambleByDF == "K/D")
{
this.dicPlayerCache[cpiPlayer.SoldierName].playerValue = this.dicPlayerCache[cpiPlayer.SoldierName].kdr;
}
else if (this.ScrambleByDF == "TB-Value")
{
this.dicPlayerCache[cpiPlayer.SoldierName].playerValue = this.dicPlayerCache[cpiPlayer.SoldierName].TBvalue;
}
}
else if (this.strcurrentGametype.Contains("TeamDeathMatch"))
{
if (this.ScrambleByTDM == "Rank"){
this.dicPlayerCache[cpiPlayer.SoldierName].playerValue = this.dicPlayerCache[cpiPlayer.SoldierName].rank;
}else if (this.ScrambleByTDM == "Skill"){
this.dicPlayerCache[cpiPlayer.SoldierName].playerValue = this.dicPlayerCache[cpiPlayer.SoldierName].skill;
}else if (this.ScrambleByTDM == "SPM"){
this.dicPlayerCache[cpiPlayer.SoldierName].playerValue = this.dicPlayerCache[cpiPlayer.SoldierName].spm;
}else if (this.ScrambleByTDM == "SPMcombat"){
this.dicPlayerCache[cpiPlayer.SoldierName].playerValue = this.dicPlayerCache[cpiPlayer.SoldierName].spmcombat;
}else if (this.ScrambleByTDM == "K/D"){
this.dicPlayerCache[cpiPlayer.SoldierName].playerValue = this.dicPlayerCache[cpiPlayer.SoldierName].kdr;
}
else if (this.ScrambleByTDM == "TB-Value")
{
this.dicPlayerCache[cpiPlayer.SoldierName].playerValue = this.dicPlayerCache[cpiPlayer.SoldierName].TBvalue;
}
}
if ( ( ((IList<string>)this.strAWhitelistComplete).Contains(cpiPlayer.SoldierName) || ( ((IList<string>)this.strAClantagWhitelist).Contains(dicPlayerCache[cpiPlayer.SoldierName].tag) && dicPlayerCache[cpiPlayer.SoldierName].tag != String.Empty ) ) && this.ynbWhitelist == enumBoolYesNo.Yes)
{
this.dicPlayerCache[cpiPlayer.SoldierName].playerWL = 1;
}
}
else
{
PlayerStats stats = new PlayerStats();
stats.reset();
/* If stats fetching is taking too long, skip for the rest of the current players list */
if (numStatsFetch > 0)
{
DebugInfoSkill("Starting Battlelog stats fetch for: ^b^5" + cpiPlayer.SoldierName);
DateTime startTime = DateTime.Now;
if (Servertype == "BF3")
{
stats = this.bclient.getPlayerStats(cpiPlayer.SoldierName, BattlelogClient.ServerType.BF3);
}
if (Servertype == "BF4")
{
stats = this.bclient.getPlayerStats(cpiPlayer.SoldierName, BattlelogClient.ServerType.BF4);
}
stats.statsFetched = true;
String name = (stats.tag != String.Empty) ? "[" + stats.tag + "]" + cpiPlayer.SoldierName : cpiPlayer.SoldierName;
DebugInfoSkill("^5^b" + name + "^n^9 stats fetched, rank is " + stats.rank + ", spm is " + stats.spm.ToString("F0") + ", ^b" + numRemaining + "^n players still need stats. ^2ELAPSED TIME: " + DateTime.Now.Subtract(startTime).TotalSeconds.ToString("F1") + " seconds");
--numStatsFetch;
}
double ValueTemp = 0;
double tempskill = stats.skill;
if (tempskill == 0)
tempskill = (this.skillA + this.skillB) / 2;
else if (tempskill < 0)
tempskill = 0;
double tempspm = stats.spm;
if (tempspm == 0)
tempspm = (this.spmA + this.spmB) / 2;
double tempspmcombat = stats.spmcombat;
if (tempspmcombat == 0)
{
tempspmcombat = (this.spmcombatA + this.spmcombatB) / 2;
}
double tempkdr = stats.kdr;
if (tempkdr == 0)
tempkdr = (this.kdrA + this.kdrB) / 2;
double TBvalueTemp = TBValue(stats.rank, tempskill, tempspm, tempspmcombat, tempkdr);
if (this.strcurrentGametype.Contains("Conquest") || this.strcurrentGametype.Contains("TankSuperiority0") || this.strcurrentGametype.Contains("Scavenger") || this.strcurrentGametype.Contains("AirSuperiority0") || this.strcurrentGametype.Contains("CarrierAssault") || this.strcurrentGametype.Contains("Chainlink"))
{
if (this.ScrambleByCONQUEST == "Rank")
{
ValueTemp = stats.rank;
}
else if (this.ScrambleByCONQUEST == "Skill")
{
ValueTemp = tempskill;
}
else if (this.ScrambleByCONQUEST == "SPM")
{
ValueTemp = tempspm;
}
else if (this.ScrambleByCONQUEST == "SPMcombat")
{
ValueTemp = tempspmcombat;
}
else if (this.ScrambleByCONQUEST == "K/D")
{
ValueTemp = tempkdr;
}
else if (this.ScrambleByCONQUEST == "TB-Value")
{
ValueTemp = TBvalueTemp;
}
}
if (this.strcurrentGametype.Contains("Domination"))
{
if (this.ScrambleByDOM == "Rank")
{
ValueTemp = stats.rank;
}
else if (this.ScrambleByDOM == "Skill")
{
ValueTemp = tempskill;
}
else if (this.ScrambleByDOM == "SPM")
{
ValueTemp = tempspm;
}
else if (this.ScrambleByDOM == "SPMcombat")
{
ValueTemp = tempspmcombat;
}
else if (this.ScrambleByDOM == "K/D")
{
ValueTemp = tempkdr;
}
else if (this.ScrambleByDOM == "TB-Value")
{
ValueTemp = TBvalueTemp;
}
}
else if (this.strcurrentGametype.Contains("Obliteration"))
{
if (this.ScrambleByCONQUEST == "Rank")
{
ValueTemp = stats.rank;
}
else if (this.ScrambleByOB == "Skill")
{
ValueTemp = tempskill;
}
else if (this.ScrambleByOB == "SPM")
{
ValueTemp = tempspm;
}
else if (this.ScrambleByOB == "SPMcombat")
{
ValueTemp = tempspmcombat;
}
else if (this.ScrambleByOB == "K/D")
{
ValueTemp = tempkdr;
}
else if (this.ScrambleByOB == "TB-Value")
{
ValueTemp = TBvalueTemp;
}
}
else if (this.strcurrentGametype.Contains("Rush"))
{
if (this.ScrambleByRUSH == "Rank"){
ValueTemp = stats.rank;
}else if (this.ScrambleByRUSH == "Skill"){
ValueTemp = tempskill;
}else if (this.ScrambleByRUSH == "SPM"){
ValueTemp = tempspm;
}else if (this.ScrambleByRUSH == "SPMcombat"){
ValueTemp = tempspmcombat;
}else if (this.ScrambleByRUSH == "K/D"){
ValueTemp = tempkdr;
}
else if (this.ScrambleByRUSH == "TB-Value")
{
ValueTemp = TBvalueTemp;
}
}
else if (this.strcurrentGametype.Contains("GunMaster") || this.strcurrentGametype.Contains("CaptureTheFlag0"))
{
if (this.ScrambleByGM == "Rank")
{
ValueTemp = stats.rank;
}
else if (this.ScrambleByGM == "Skill")
{
ValueTemp = tempskill;
}
else if (this.ScrambleByGM == "SPM")
{
ValueTemp = tempspm;
}
else if (this.ScrambleByGM == "SPMcombat")
{
ValueTemp = tempspmcombat;
}
else if (this.ScrambleByGM == "K/D")
{
ValueTemp = tempkdr;
}
else if (this.ScrambleByGM == "TB-Value")
{
ValueTemp = TBvalueTemp;
}
}
else if (this.strcurrentGametype.Contains("Elimination"))
{
if (this.ScrambleByDF == "Rank")
{
ValueTemp = stats.rank;
}
else if (this.ScrambleByDF == "Skill")
{
ValueTemp = tempskill;
}
else if (this.ScrambleByDF == "SPM")
{
ValueTemp = tempspm;
}
else if (this.ScrambleByDF == "SPMcombat")
{
ValueTemp = tempspmcombat;
}
else if (this.ScrambleByDF == "K/D")
{
ValueTemp = tempkdr;
}
else if (this.ScrambleByDF == "TB-Value")
{
ValueTemp = TBvalueTemp;
}
}
else if (this.strcurrentGametype.Contains("TeamDeathMatch"))
{
if (this.ScrambleByTDM == "Rank"){
ValueTemp = stats.rank;
}else if (this.ScrambleByTDM == "Skill"){
ValueTemp = tempskill;
}else if (this.ScrambleByTDM == "SPM"){
ValueTemp = tempspm;
}else if (this.ScrambleByTDM == "SPMcombat"){
ValueTemp = tempspmcombat;
}else if (this.ScrambleByTDM == "K/D"){
ValueTemp = tempkdr;
}
else if (this.ScrambleByTDM == "TB-Value")
{
ValueTemp = TBvalueTemp;
}
}
bool commander = cpiPlayer.Type == 1 || cpiPlayer.Type == 2 ? true : false;
bool spectator = cpiPlayer.Type == 3 ? true : false;
if ((((IList<string>)this.strAWhitelistComplete).Contains(cpiPlayer.SoldierName) || (((IList<string>)this.strAClantagWhitelist).Contains(stats.tag) && stats.tag != String.Empty)) && this.ynbWhitelist == enumBoolYesNo.Yes)
{
CPlayerJoinInf newEntry = new CPlayerJoinInf(cpiPlayer.TeamID, 1, cpiPlayer.SquadID, DateTime.Now, cpiPlayer.Score, stats.rank, tempskill, tempspm, tempspmcombat, tempkdr, TBvalueTemp, ValueTemp, stats.tag, false, commander, spectator);
newEntry.statsFetched = stats.statsFetched;
this.dicPlayerCache[cpiPlayer.SoldierName] = newEntry;
//this.dicPlayerCache.Add(cpiPlayer.SoldierName, newEntry);
//PlayersOnServer.Add(cpiPlayer.SoldierName);
//this.ExecuteCommand("procon.protected.pluginconsole.write", spm.ToString());
}
else
{
if (cpiPlayer.TeamID == 0)
{
CPlayerJoinInf newEntry = new CPlayerJoinInf(cpiPlayer.TeamID, 0, cpiPlayer.SquadID, DateTime.Now, cpiPlayer.Score, stats.rank, tempskill, tempspm, tempspmcombat, tempkdr, TBvalueTemp, ValueTemp, stats.tag, true, commander, spectator);
newEntry.statsFetched = stats.statsFetched;
this.dicPlayerCache[cpiPlayer.SoldierName] = newEntry;
//this.dicPlayerCache.Add(cpiPlayer.SoldierName, newEntry);
//PlayersOnServer.Add(cpiPlayer.SoldierName);
}
else
{
CPlayerJoinInf newEntry = new CPlayerJoinInf(cpiPlayer.TeamID, 0, cpiPlayer.SquadID, DateTime.Now, cpiPlayer.Score, stats.rank, tempskill, tempspm, tempspmcombat, tempkdr, TBvalueTemp, ValueTemp, stats.tag, false, commander, spectator);
newEntry.statsFetched = stats.statsFetched;
this.dicPlayerCache[cpiPlayer.SoldierName] = newEntry;
//this.dicPlayerCache.Add(cpiPlayer.SoldierName, newEntry);
//PlayersOnServer.Add(cpiPlayer.SoldierName);
}
//this.ExecuteCommand("procon.protected.pluginconsole.write", spm.ToString());
}
}
}
if (this.ynbWhitelist == enumBoolYesNo.Yes && this.ynbincludeVIPlist == enumBoolYesNo.Yes) {
this.ExecuteCommand("procon.protected.send", "reservedSlotsList.list");
}
this.strMovedPlayer = "";
this.boolmanuellchange = false;
this.DebugInfo("-------OP-------");
string printSoldier = "";
string strPlayerlist = "";
string strPLTeam1 = "";
string strPLTeam2 = "";
string strPLNeutral = "";
/* Dictionary<string, CPlayerJoinInf> dicSorted = new Dictionary<string, CPlayerJoinInf>();
dicSorted = from k in dicPlayerCache.Keys
orderby dicPlayerCache[k].Playerjoined ascending
select k; */
Dictionary<string, CPlayerJoinInf> dicPlayerSorted = new Dictionary<string, CPlayerJoinInf>();
string whitelisttemp = "^2";
foreach (KeyValuePair<string, CPlayerJoinInf> kvp1 in this.dicPlayerCache)
{
if (this.dicPlayerCache[kvp1.Key].playerWL == 1 || dicPlayerCache[kvp1.Key].IsCommander || dicPlayerCache[kvp1.Key].IsSpectator)
{
whitelisttemp = whitelisttemp + "^b" + kvp1.Key + "^n" + ", ";
}
// DateTime maxValueJoined = new DateTime();
double minpoints = 100000000;
KeyValuePair<string, CPlayerJoinInf> kvplastjoiner = new KeyValuePair<string, CPlayerJoinInf>();
foreach (KeyValuePair<string, CPlayerJoinInf> kvp2 in this.dicPlayerCache)
{
if (this.dicPlayerCache[kvp2.Key].score <= minpoints && dicPlayerSorted.ContainsKey(kvp2.Key) == false)
{
minpoints = this.dicPlayerCache[kvp2.Key].score;
kvplastjoiner = kvp2;
}
}
dicPlayerSorted.Add(kvplastjoiner.Key, kvplastjoiner.Value);
}
foreach (KeyValuePair<string, CPlayerJoinInf> kvp in dicPlayerSorted)
{
printSoldier = kvp.Key.Replace("{", "(");
printSoldier = printSoldier.Replace("}", ")");
if (dicPlayerSorted[kvp.Key].teamID == 1){
strPLTeam1 = strPLTeam1 + "^0^n[" + dicPlayerSorted[kvp.Key].tag + "]^b" + printSoldier + "^n:^2" + Convert.ToString(dicPlayerSorted[kvp.Key].playerWL) +
"^0.^1" + Convert.ToString(dicPlayerSorted[kvp.Key].playerSquad) + " - ^i^3" + dicPlayerSorted[kvp.Key].TBvalue.ToString("F1") + "^0/^3" + dicPlayerSorted[kvp.Key].rank.ToString("F2") + "^0/^3" + dicPlayerSorted[kvp.Key].skill.ToString("F2") + "^0/^3" + dicPlayerSorted[kvp.Key].spm.ToString("F2") + "^0/^3" +
dicPlayerSorted[kvp.Key].spmcombat.ToString("F2") + "^0/^3" + dicPlayerSorted[kvp.Key].kdr.ToString("F2") + "^b^4 -=- ";
}else if (dicPlayerSorted[kvp.Key].teamID == 2){
strPLTeam2 = strPLTeam2 + "^0^n[" + dicPlayerSorted[kvp.Key].tag + "]^b" + printSoldier + "^n:^2" + Convert.ToString(dicPlayerSorted[kvp.Key].playerWL) +
"^0.^1" + Convert.ToString(dicPlayerSorted[kvp.Key].playerSquad) + " - ^i^3" + dicPlayerSorted[kvp.Key].TBvalue.ToString("F1") + "^0/^3" + dicPlayerSorted[kvp.Key].rank.ToString("F2") + "^0/^3" + dicPlayerSorted[kvp.Key].skill.ToString("F2") + "^0/^3" + dicPlayerSorted[kvp.Key].spm.ToString("F2") + "^0/^3" +
dicPlayerSorted[kvp.Key].spmcombat.ToString("F2") + "^0/^3" + dicPlayerSorted[kvp.Key].kdr.ToString("F2") + "^b^4 -=- ";
}else{
strPLNeutral = strPLNeutral + "^0^n[" + dicPlayerSorted[kvp.Key].tag + "]^b" + printSoldier + "^n:^2" + Convert.ToString(dicPlayerSorted[kvp.Key].playerWL) +
"^0.^1" + Convert.ToString(dicPlayerSorted[kvp.Key].playerSquad) + " - ^i^3" + dicPlayerSorted[kvp.Key].TBvalue.ToString("F1") + "^0/^3" + dicPlayerSorted[kvp.Key].rank.ToString("F2") + "^0/^3" + dicPlayerSorted[kvp.Key].skill.ToString("F2") + "^0/^3" + dicPlayerSorted[kvp.Key].spm.ToString("F2") + "^0/^3" +
dicPlayerSorted[kvp.Key].spmcombat.ToString("F2") + "^0/^3" + dicPlayerSorted[kvp.Key].kdr.ToString("F2") + "^b^4 -=- ";
}
}
/* foreach (KeyValuePair<string, CPlayerJoinInf> kvp in this.dicPlayerCache)
{
printSoldier = kvp.Key.Replace("{", "(");
printSoldier = printSoldier.Replace("}", ")");
if (this.dicPlayerCache[kvp.Key].teamID == 1){
strPLTeam1 = strPLTeam1 + Convert.ToString(this.dicPlayerCache[kvp.Key].playerWL) +
"." + Convert.ToString(this.dicPlayerCache[kvp.Key].playerSquad) + "." +
this.dicPlayerCache[kvp.Key].Playerjoined.ToString("HH:mm:ss") + "-" + printSoldier + " -=- ";
}else if (this.dicPlayerCache[kvp.Key].teamID == 2){
strPLTeam2 = strPLTeam2 + Convert.ToString(this.dicPlayerCache[kvp.Key].playerWL) +
"." + Convert.ToString(this.dicPlayerCache[kvp.Key].playerSquad) + "." +
this.dicPlayerCache[kvp.Key].Playerjoined.ToString("HH:mm:ss") + "-" + printSoldier + " -=- ";
}else{
strPLNeutral = strPLNeutral + Convert.ToString(this.dicPlayerCache[kvp.Key].playerWL) +
"." + Convert.ToString(this.dicPlayerCache[kvp.Key].playerSquad) + "." +
this.dicPlayerCache[kvp.Key].Playerjoined.ToString("HH:mm:ss") + "-" + printSoldier + " -=- ";
}
} */
strPlayerlist = "\n^b^4TEAM 1:^n " + strPLTeam1 + "\n\n^bTEAM 2:^n " + strPLTeam2 + "\n\n^bNeutral:^n " + strPLNeutral;
this.DebugInfo(strPlayerlist);
this.DebugInfo("Online whitelisted players: " + whitelisttemp);
//this.DebugInfo("WaitSeconds: " + this.intWaitSeconds.ToString());
this.TSLevelStartWait = DateTime.Now - this.DTLevelStart;
if (this.boolLevelStart && this.TSLevelStartWait.TotalSeconds > 30)
{
if (this.boolFirstOP == false)
{
this.boolFirstOP = true;
}
if (strcurrentGametype != "squaddeathmatch0")
{
// if ( this.intScoreTeamA > this.intminScore && this.intScoreTeamB > this.intminScore){
CompareTeams();
// } else {
// this.DebugInfo("Not comparing teams. Tickets till Endround: TeamA: " + this.intScoreTeamA + ", TeamB: " + this.intScoreTeamB );
// }
}
else if (strcurrentGametype != "")
{
if (this.boolgametype == false)
{
this.boolgametype = true;
this.ExecuteCommand("procon.protected.pluginconsole.write", "TrueBalancer: Still no data or GameMode not supported: " + "I" + strcurrentGametype + "I" );
}
}
}
}else {
DebugInfoSkill("^3OnListPlayers, skill scramble in progress");
double afterscrambleValueA = 0;
double afterscrambleTeamSizeA = 0;
double afterscrambleValueB = 0;
double afterscrambleTeamSizeB = 0;
if (this.boolscrambleNow && this.boolRunOnList){
this.boolTeamsScrambled = true;
foreach (KeyValuePair<int, CPlayerScoreInf> kvp in this.dicPlayerScore){
if (this.m_isPluginEnabled == false) break;
foreach (CPlayerInfo cpiPlayer in lstPlayers){
if (this.m_isPluginEnabled == false) break;
if (this.dicPlayerScore[kvp.Key].playerName == cpiPlayer.SoldierName){
if (cpiPlayer.TeamID == this.dicPlayerScore[kvp.Key].teamID && cpiPlayer.SquadID == this.dicPlayerScore[kvp.Key].playerSquad){
this.dicPlayerScore[kvp.Key].scrambled = true;
if (cpiPlayer.TeamID == 1)
{
afterscrambleValueA = afterscrambleValueA + this.dicPlayerScore[kvp.Key].playerValue;
afterscrambleTeamSizeA++;
}
else
{
afterscrambleValueB = afterscrambleValueB + this.dicPlayerScore[kvp.Key].playerValue;
afterscrambleTeamSizeB++;
}
}else{
this.dicPlayerScore[kvp.Key].scrambled = false;
this.boolTeamsScrambled = false;
this.DebugInfoSkill("^3Not scrambled: ^b" + cpiPlayer.SoldierName + "^n. Is in: ^b" + cpiPlayer.TeamID.ToString() +"."+cpiPlayer.SquadID +"^n - Goal: ^b" + this.dicPlayerScore[kvp.Key].teamID .ToString() + "." + this.dicPlayerScore[kvp.Key].playerSquad.ToString());
}
break;
}
}
}
if (this.boolTeamsScrambled) {
this.boolRunOnList = false;
this.DebugInfoSkill("^b^2Teams are scrambled now!");
this.DebugInfoSkill("Team 1 Value: ^b^2" + afterscrambleValueA / afterscrambleTeamSizeA + "^9*^7" + afterscrambleTeamSizeA + "^n^9 --- Team 2 Value: ^b^2" + afterscrambleValueB / afterscrambleTeamSizeB + "^9*^7" + afterscrambleTeamSizeB);
double valuediffendround = afterscrambleValueA / afterscrambleTeamSizeA - afterscrambleValueB / afterscrambleTeamSizeB;
this.DebugInfoSkill("ValueDifference: ^b^2" + valuediffendround);
TimeSpan ScrambleDuration = DateTime.Now - this.DTScramblestarted;
this.DebugInfoSkill("ScrambleDuration: " + ScrambleDuration.TotalSeconds.ToString("F2") + " seconds");
this.boolscrambleNow = false;
this.boolscrambleActive = false;
this.intScrambleCount = 0;
if (this.boolLevelStart){
if (this.ynbScrambleMessage == enumBoolYesNo.Yes){
if (this.strScrambleDoneMsg !=""){
if (this.boolVirtual)
{
this.ExecuteCommand("procon.protected.pluginconsole.write", "^b[TB] VIRTUAL:^n say all - " + strScrambleDoneMsg);
}
else
{
this.ExecuteCommand("procon.protected.send", "admin.say", strScrambleDoneMsg , "all");
}
if (this.ynbYellScrambleManuall == enumBoolYesNo.Yes && !this.boolVirtual){
this.ExecuteCommand("procon.protected.send", "admin.yell", strScrambleDoneMsg , "30");
}
}
}
}
} else{
this.boolRunOnList = false;
ScrambleNow();
}
} else {
DebugInfoSkill("^3Scrambler Active OnList!");
}
}
/* Since the playername matching feature requires the lastest list of player names, we have
* to re-register commands after every player list update, bleah!
*/
this.RegisterAllCommands();
DebugInfoSkill("OnListPlayers handler returning");
}
/*
public void OnPlayerPunkbusterInfo(CPunkbusterInfo pbInfo) {
}
*/
private void m_prcClient_ListPlayers(FrostbiteClient sender, List<CPlayerInfo> lstPlayers, CPlayerSubset cpsSubset) {
this.InvokeIfRequired(() => {
if (cpsSubset.Subset == CPlayerSubset.PlayerSubsetType.All) {
foreach (CPlayerInfo cpiPlayer in lstPlayers) {
if (this.Players.ContainsKey(cpiPlayer.SoldierName) == true) {
ListViewItem playerListItem = this.Players[cpiPlayer.SoldierName];
if (this.Client != null && this.Client.Game != null && this.Client.Game.HasSquads == true) {
if (cpiPlayer.SquadID != uscPlayerListPanel.NeutralSquad) {
if (String.Compare(playerListItem.SubItems["squad"].Text, cpiPlayer.ClanTag) == 0) {
playerListItem.SubItems["squad"].Text = this.Language.GetLocalized("global.Squad" + cpiPlayer.SquadID.ToString(), null);
}
}
else {
if (String.IsNullOrEmpty(playerListItem.SubItems["squad"].Text) != false) {
playerListItem.SubItems["squad"].Text = String.Empty;
}
}
}
if (String.Compare(playerListItem.SubItems["tags"].Text, cpiPlayer.ClanTag) != 0) {
playerListItem.SubItems["tags"].Text = cpiPlayer.ClanTag;
}
if (String.Compare(playerListItem.SubItems["score"].Text, cpiPlayer.Score.ToString()) != 0) {
playerListItem.SubItems["score"].Text = cpiPlayer.Score.ToString();
}
playerListItem.SubItems["kills"].Tag = (Double)cpiPlayer.Kills;
if (String.Compare(playerListItem.SubItems["kills"].Text, cpiPlayer.Kills.ToString()) != 0) {
playerListItem.SubItems["kills"].Text = cpiPlayer.Kills.ToString();
}
playerListItem.SubItems["deaths"].Tag = (Double)cpiPlayer.Deaths;
if (String.Compare(playerListItem.SubItems["deaths"].Text, cpiPlayer.Kills.ToString()) != 0) {
playerListItem.SubItems["deaths"].Text = cpiPlayer.Deaths.ToString();
}
string kdr = cpiPlayer.Deaths > 0 ? String.Format("{0:0.00}", (Double)cpiPlayer.Kills / (Double)cpiPlayer.Deaths) : String.Format("{0:0.00}", (Double)cpiPlayer.Kills);
if (String.Compare(playerListItem.SubItems["kdr"].Text, kdr) == 0) {
playerListItem.SubItems["kdr"].Text = kdr;
}
//if (String.Compare(playerListItem.SubItems["ping"].Text, cpiPlayer.Ping.ToString()) != 0) { playerListItem.SubItems["ping"].Text = cpiPlayer.Ping.ToString(); }
if ((this.Client.Game.GameType.Equals("BF3") == true) && (this.Pings.ContainsKey(cpiPlayer.SoldierName) == true)) {
if (String.Compare(playerListItem.SubItems["ping"].Text, this.Pings[cpiPlayer.SoldierName].ToString()) != 0) {
playerListItem.SubItems["ping"].Text = this.Pings[cpiPlayer.SoldierName].ToString();
cpiPlayer.Ping = this.Pings[cpiPlayer.SoldierName];
}
}
else {
if (String.Compare(playerListItem.SubItems["ping"].Text, cpiPlayer.Ping.ToString()) != 0) {
playerListItem.SubItems["ping"].Text = cpiPlayer.Ping.ToString();
}
}
if (String.Compare(playerListItem.SubItems["rank"].Text, cpiPlayer.Rank.ToString()) != 0) {
playerListItem.SubItems["rank"].Text = cpiPlayer.Rank.ToString();
}
string strTime = cpiPlayer.SessionTime > 60 ? String.Format("{0:0}", cpiPlayer.SessionTime / 60) : "0";
playerListItem.SubItems["time"].Text = strTime;
if (String.Compare(playerListItem.SubItems["type"].Text, cpiPlayer.Type.ToString()) != 0) {
if (cpiPlayer.Type == 0) {
//playerListItem.SubItems["type"].Text = this.m_clocLanguage.GetDefaultLocalized("Player", "uscPlayerListPanel.lsvPlayers.Type.Player", null);
playerListItem.SubItems["type"].Text = String.Empty;
}
else if (cpiPlayer.Type == 1) {
playerListItem.SubItems["type"].Text = this.Language.GetDefaultLocalized("Spectator", "uscPlayerListPanel.lsvPlayers.Type.Spectator", null);
}
else if (cpiPlayer.Type == 2) {
playerListItem.SubItems["type"].Text = this.Language.GetDefaultLocalized("Commander (PC)", "uscPlayerListPanel.lsvPlayers.Type.CommanderPC", null);
}
else if (cpiPlayer.Type == 3) {
playerListItem.SubItems["type"].Text = this.Language.GetDefaultLocalized("Commander (Tablet)", "uscPlayerListPanel.lsvPlayers.Type.CommanderTablet", null);
}
}
AdditionalPlayerInfo sapiAdditional;
if (playerListItem.Tag == null) {
sapiAdditional = new AdditionalPlayerInfo();
sapiAdditional.ResolvedHostName = String.Empty;
}
else {
sapiAdditional = (AdditionalPlayerInfo)playerListItem.Tag;
}
sapiAdditional.Player = cpiPlayer;
playerListItem.Tag = sapiAdditional;
}
else {
this.Players.Add(cpiPlayer.SoldierName, this.CreatePlayer(cpiPlayer));
}
}
List<string> lstKeys = new List<string>(this.Players.Keys);
for (int i = 0; i < lstKeys.Count; i++) {
bool blFoundPlayer = false;
foreach (CPlayerInfo cpiPlayer in lstPlayers) {
if (String.Compare(cpiPlayer.SoldierName, this.Players[lstKeys[i]].Name) == 0) {
blFoundPlayer = true;
break;
}
}
if (blFoundPlayer == false) {
this.Players[lstKeys[i]].Remove();
this.Players.Remove(lstKeys[i]);
}
}
this.Players.Add("procon.playerlist.totals1", this.CreateTotalsPlayer(new CPlayerInfo("Totals", "procon.playerlist.totals1", 1, 0), 1));
this.Players.Add("procon.playerlist.totals2", this.CreateTotalsPlayer(new CPlayerInfo("Totals", "procon.playerlist.totals2", 2, 0), 2));
this.Players.Add("procon.playerlist.totals3", this.CreateTotalsPlayer(new CPlayerInfo("Totals", "procon.playerlist.totals3", 3, 0), 3));
this.Players.Add("procon.playerlist.totals4", this.CreateTotalsPlayer(new CPlayerInfo("Totals", "procon.playerlist.totals4", 4, 0), 4));
this.Players.Add("procon.playerlist.averages1", this.CreateTotalsPlayer(new CPlayerInfo("Averages", "procon.playerlist.averages1", 1, 0), 1));
this.Players.Add("procon.playerlist.averages2", this.CreateTotalsPlayer(new CPlayerInfo("Averages", "procon.playerlist.averages2", 2, 0), 2));
this.Players.Add("procon.playerlist.averages3", this.CreateTotalsPlayer(new CPlayerInfo("Averages", "procon.playerlist.averages3", 3, 0), 3));
this.Players.Add("procon.playerlist.averages4", this.CreateTotalsPlayer(new CPlayerInfo("Averages", "procon.playerlist.averages4", 4, 0), 4));
this.ArrangePlayers();
}
});
}
public void OnCommandScrambleNow(string strSpeaker, string strText, MatchCommand mtcCommand, CapturedCommand capCommand, CPlayerSubset subMatchedScope){
bool blIsAdmin = false;
CPrivileges cpAccount = this.GetAccountPrivileges(strSpeaker);
if (cpAccount != null && cpAccount.PrivilegesFlags > 0) { blIsAdmin = true; }
if(blIsAdmin){
this.DebugInfoSkill("^1Admin requested a scramble now!");
this.TSLevelStartWait = DateTime.Now - this.DTLevelStart;
if (this.boolLevelStart && this.boolFirstOP){
if (this.ynbEnableScrambleNow == enumBoolYesNo.Yes){
if (!this.boolscrambleActive){
if (this.ynbScrambleMessage == enumBoolYesNo.Yes){
if (this.strScrambleNowMsg != ""){
if (this.boolVirtual)
{
this.ExecuteCommand("procon.protected.pluginconsole.write", "^b[TB] VIRTUAL:^n say all - " + this.strScrambleNowMsg);
}
else
{
this.ExecuteCommand("procon.protected.send", "admin.say", this.strScrambleNowMsg , "all");
}
if (this.ynbYellScrambleManuall == enumBoolYesNo.Yes && !this.boolVirtual){
this.ExecuteCommand("procon.protected.send", "admin.yell", this.strScrambleNowMsg , "30");
}
}
}
int i = 1;
this.dicPlayerScore.Clear();
this.dicSquadScore.Clear();
this.bestSquadTeamID = 0;
foreach (KeyValuePair<string, CPlayerJoinInf> kvp in this.dicPlayerCache) {
double value = this.dicPlayerCache[kvp.Key].playerValue;
string tag = this.dicPlayerCache[kvp.Key].tag;
CPlayerScoreInf newEntry = new CPlayerScoreInf(kvp.Key, this.dicPlayerCache[kvp.Key].teamID, this.dicPlayerCache[kvp.Key].playerSquad, value, false, false, tag);
this.dicPlayerScore.Add(i, newEntry);
i++;
}
bool Sortiert;
do{
Sortiert = true;
for (int j = 1; j < this.dicPlayerScore.Count; j++) {
if (this.dicPlayerScore[j].playerValue < this.dicPlayerScore[j+1].playerValue){
CPlayerScoreInf temp = new CPlayerScoreInf(this.dicPlayerScore[j].playerName, this.dicPlayerScore[j].teamID, this.dicPlayerScore[j].playerSquad, this.dicPlayerScore[j].playerValue, false, false, this.dicPlayerScore[j].tag);
this.dicPlayerScore[j] = this.dicPlayerScore[j+1];
this.dicPlayerScore[j+1] = temp;
Sortiert = false;
}
}
} while (!Sortiert);
this.boolFirstOP = false;
this.boolwaitfordeath = false;
this.boolscrambleActive = true;
this.boolTeamsScrambled = false;
this.intScrambledPlayers = 0;
this.teamswitcher.Clear();
this.ExecuteCommand("procon.protected.tasks.add", "WaitScrambleTimer", "3", "1", "1", "procon.protected.plugins.call", "TrueBalancer", "StartScrambler");
//StartScrambler();
}else{
this.DebugInfoSkill("^3A scrambing has allready been requested.");
if (this.boolVirtual)
{
this.ExecuteCommand("procon.protected.pluginconsole.write", "^b[TB] VIRTUAL^n admin.say player " + strSpeaker + " - " + "A scrambing has allready been requested.");
}
{
this.ExecuteCommand("procon.protected.send", "admin.say", "A scrambing has allready been requested." , "player", strSpeaker);
}
}
}else{
this.DebugInfoSkill("^3This command is deactivated at the moment. Activate in in PRoCon.");
if (this.boolVirtual)
{
this.ExecuteCommand("procon.protected.pluginconsole.write", "^b[TB] VIRTUAL^n admin.say player " + strSpeaker + " - " + "This command is not activated for your server in PRoCon.");
}
else
{
this.ExecuteCommand("procon.protected.send", "admin.say", "This command is not activated for your server in PRoCon." , "player", strSpeaker);
}
}
}
}
}
public void OnListPlayers(List<CPlayerInfo> lstPlayers, CPlayerSubset cpsSubset)
{
this.lstPlayerList = lstPlayers;
if (this.m_RoCAccepted == enumBoolYesNo.Yes)
{
foreach (CPlayerInfo info in lstPlayers)
{
if (this.m_RankKicker == enumBoolOnOff.On)
{
if (this.m_RankKickerOnOff == enumBoolOnOff.On)
{
if (this.m_RankKickerOnOff == enumBoolOnOff.On && this.m_PlayerKicks.ContainsKey(info.SoldierName) == false && this.m_WhiteList.Contains(info.SoldierName) == false && this.m_WhiteListClanTags.Contains(info.ClanTag) == false)
{
this.m_PlayerKicks.Add(info.SoldierName, 0);
}
else if (this.m_RankKickerOnOff == enumBoolOnOff.On && this.m_PlayerKicks.ContainsKey(info.SoldierName) == true && this.m_WhiteList.Contains(info.SoldierName) == false)
{
if (this.m_RankKickerOnOff == enumBoolOnOff.On && this.m_PlayerKicks[info.SoldierName] > 0 && this.m_PlayerKicks[info.SoldierName] < this.m_KicksBeforeBan && this.m_BanAfterKicks == enumBoolYesNo.Yes)
{
this.ExecuteCommand("procon.protected.send", "admin.kickPlayer", info.SoldierName, this.m_KickReason);
this.m_PlayerKicks[info.SoldierName]++;
this.ExecuteCommand("procon.protected.send", "admin.say", String.Format("Player '{0}' kicked due to a too high rank!", info.SoldierName));
if (this.m_ConsoleLog == enumBoolYesNo.Yes)
{
this.ExecuteCommand("procon.protected.pluginconsole.write", String.Format("^b^4AccessRestriction: ^0RankKicker-Player '{0}' kicked. Number of kicks: {1}", info.SoldierName, this.m_PlayerKicks[info.SoldierName]));
}
}
else if (this.m_RankKickerOnOff == enumBoolOnOff.On && this.m_PlayerKicks[info.SoldierName] > 0 && this.m_PlayerKicks[info.SoldierName] >= this.m_KicksBeforeBan && this.m_BanAfterKicks == enumBoolYesNo.Yes)
{
if (this.m_BanGUID == enumBoolYesNo.No || this.m_PlayerGUIDs.ContainsKey(info.SoldierName) == false)
{
this.ExecuteCommand("procon.protected.send", "banList.add", "name", info.SoldierName, "perm", this.m_PermBanReason);
}
else
{
this.ExecuteCommand("procon.protected.send", "banList.add", "guid", this.m_PlayerGUIDs[info.SoldierName], "perm", this.m_PermBanReason);
}
this.ExecuteCommand("procon.protected.send", "admin.say", String.Format("Player '{0}' banned permanently due to a too high rank!", info.SoldierName));
if (this.m_ConsoleLog == enumBoolYesNo.Yes)
{
this.ExecuteCommand("procon.protected.pluginconsole.write", String.Format("^b^4AccessRestriction: ^0RankKicker-Player '{0}' banned permanently.", info.SoldierName));
}
}
}
PlayerStats? stats = getBFBCStats(info.SoldierName);
if (stats == null)
continue;
if (this.m_RankKickerOnOff == enumBoolOnOff.On && stats.Value.rank >= this.m_RankLimit && this.m_TempBanPlayers == enumBoolYesNo.No && this.m_PermBanPlayers == enumBoolYesNo.No && this.m_WhiteList.Contains(info.SoldierName) == false)
{
this.ExecuteCommand("procon.protected.send", "admin.kickPlayer", info.SoldierName, this.m_KickReason);
this.m_PlayerKicks[info.SoldierName]++;
this.ExecuteCommand("procon.protected.send", "admin.say", String.Format("Player '{0}' kicked due to a too high rank!", info.SoldierName));
if (this.m_ConsoleLog == enumBoolYesNo.Yes)
{
this.ExecuteCommand("procon.protected.pluginconsole.write", String.Format("^b^4AccessRestriction: ^0RankKicker-Player '{0}' kicked. Number of kicks: {1}", info.SoldierName, this.m_PlayerKicks[info.SoldierName]));
}
}
else if (this.m_RankKickerOnOff == enumBoolOnOff.On && stats.Value.rank >= this.m_RankLimit && this.m_TempBanPlayers == enumBoolYesNo.Yes && this.m_PermBanPlayers == enumBoolYesNo.No && this.m_WhiteList.Contains(info.SoldierName) == false)
{
if (this.m_BanGUID == enumBoolYesNo.No || this.m_PlayerGUIDs.ContainsKey(info.SoldierName) == false)
{
this.ExecuteCommand("procon.protected.send", "banList.add", "name", info.SoldierName, "seconds", (this.m_TempBanTime * 60).ToString(), this.m_BanReason);
}
else
{
this.ExecuteCommand("procon.protected.send", "banList.add", "guid", this.m_PlayerGUIDs[info.SoldierName], "seconds", (this.m_TempBanTime * 60).ToString(), this.m_BanReason);
}
this.ExecuteCommand("procon.protected.send", "admin.say", String.Format("Player '{0}' banned for {1} minutes due to a too high rank!", info.SoldierName, this.m_TempBanTime));
if (this.m_ConsoleLog == enumBoolYesNo.Yes)
{
this.ExecuteCommand("procon.protected.pluginconsole.write", String.Format("^b^4AccessRestriction: ^0RankKicker-Player '{0}' banned for {1} minutes.", info.SoldierName, this.m_TempBanTime));
}
}
else if (this.m_RankKickerOnOff == enumBoolOnOff.On && stats.Value.rank >= this.m_RankLimit && this.m_TempBanPlayers == enumBoolYesNo.Yes && this.m_PermBanPlayers == enumBoolYesNo.Yes && this.m_WhiteList.Contains(info.SoldierName) == false)
{
if (this.m_BanGUID == enumBoolYesNo.No || this.m_PlayerGUIDs.ContainsKey(info.SoldierName) == false)
{
this.ExecuteCommand("procon.protected.send", "banList.add", "name", info.SoldierName, "perm", this.m_PermBanReason);
}
else
{
this.ExecuteCommand("procon.protected.send", "banList.add", "guid", this.m_PlayerGUIDs[info.SoldierName], "perm", this.m_PermBanReason);
}
this.ExecuteCommand("procon.protected.send", "admin.say", String.Format("Player '{0}' banned permanently due to a too high rank!", info.SoldierName));
if (this.m_ConsoleLog == enumBoolYesNo.Yes)
{
this.ExecuteCommand("procon.protected.pluginconsole.write", String.Format("^b^4AccessRestriction: ^0RankKicker-Player '{0}' banned permanently.", info.SoldierName));
}
}
}
}
if (this.m_AccessLimitation == enumBoolOnOff.On)
{
if (this.m_AccessLimitationPlayers == enumBoolYesNo.Yes || this.m_AccessLimitationTags == enumBoolYesNo.Yes)
{
bool validPlayer;
if (this.m_AllowedPlayers.Contains(info.SoldierName) == true || this.m_AllowedClanTags.Contains(info.ClanTag) == true)
{
validPlayer = true;
}
else
{
validPlayer = false;
}
if (validPlayer != true)
{
if (this.m_AccessBanPlayers == enumBoolYesNo.No)
{
this.ExecuteCommand("procon.protected.send", "admin.kickPlayer", info.SoldierName, this.m_AccessKickReason);
this.ExecuteCommand("procon.protected.send", "admin.say", String.Format("Player '{0}' kicked for not being on the list of allowed players!", info.SoldierName));
if (this.m_ConsoleLog == enumBoolYesNo.Yes)
{
this.ExecuteCommand("procon.protected.pluginconsole.write", String.Format("^b^4AccessRestriction: ^0AccessLimitation-Player '{0}' kicked.", info.SoldierName));
}
}
else if (this.m_AccessBanPlayers == enumBoolYesNo.Yes)
{
if (this.m_BanGUID == enumBoolYesNo.No || this.m_PlayerGUIDs.ContainsKey(info.SoldierName) == false)
{
this.ExecuteCommand("procon.protected.send", "banList.add", "name", info.SoldierName, "perm", this.m_AccessPermBanReason);
}
else
{
this.ExecuteCommand("procon.protected.send", "banList.add", "guid", this.m_PlayerGUIDs[info.SoldierName], "perm", this.m_AccessPermBanReason);
}
this.ExecuteCommand("procon.protected.send", "admin.say", String.Format("Player '{0}' banned permanently for not being on the list of allowed players!", info.SoldierName));
if (this.m_ConsoleLog == enumBoolYesNo.Yes)
{
this.ExecuteCommand("procon.protected.pluginconsole.write", String.Format("^b^4AccessRestriction: ^0AccessLimitation-Player '{0}' banned permanently.", info.SoldierName));
}
}
}
}
}
if (this.m_ClanTagModeration == enumBoolOnOff.On)
{
if (this.m_ModeratedClanTags.Contains(info.ClanTag) == true)
{
if (this.m_AllowedClanPlayers.Contains(info.SoldierName) != true)
{
if (this.m_ClanTagBanPlayers == enumBoolYesNo.No)
{
this.ExecuteCommand("procon.protected.send", "admin.kickPlayer", info.SoldierName, this.m_ClanTagKickReason);
this.ExecuteCommand("procon.protected.send", "admin.say", String.Format("Player '{0}' kicked for using a clantag by unfair means!", info.SoldierName));
if (this.m_ConsoleLog == enumBoolYesNo.Yes)
{
this.ExecuteCommand("procon.protected.pluginconsole.write", String.Format("^b^4AccessRestriction: ^0ClanTagModeration-Player '{0}' kicked.", info.SoldierName));
}
}
else if (this.m_ClanTagBanPlayers == enumBoolYesNo.Yes)
{
if (this.m_BanGUID == enumBoolYesNo.No || this.m_PlayerGUIDs.ContainsKey(info.SoldierName) == false)
{
this.ExecuteCommand("procon.protected.send", "banList.add", "name", info.SoldierName, "perm", this.m_ClanTagPermBanReason);
}
else
{
this.ExecuteCommand("procon.protected.send", "banList.add", "guid", this.m_PlayerGUIDs[info.SoldierName], "perm", this.m_ClanTagPermBanReason);
}
this.ExecuteCommand("procon.protected.send", "admin.say", String.Format("Player '{0}' banned permanently for using a clantag by unfair means!", info.SoldierName));
if (this.m_ConsoleLog == enumBoolYesNo.Yes)
{
this.ExecuteCommand("procon.protected.pluginconsole.write", String.Format("^b^4AccessRestriction: ^0ClanTagModeration-Player '{0}' banned permanently.", info.SoldierName));
}
}
}
}
}
if (this.m_DisallowedTags == enumBoolOnOff.On)
{
if (this.m_DisallowedClanTags.Contains(info.ClanTag) == true)
{
if (this.m_DisallowedTagsBan == enumBoolYesNo.No)
{
this.ExecuteCommand("procon.protected.send", "admin.kickPlayer", info.SoldierName, this.m_DisallowedTagsKickReason);
this.ExecuteCommand("procon.protected.send", "admin.say", String.Format("Player '{0}' kicked due to his clan not being welcome here!", info.SoldierName));
if (this.m_ConsoleLog == enumBoolYesNo.Yes)
{
this.ExecuteCommand("procon.protected.pluginconsole.write", String.Format("^b^4AccessRestriction: ^0DisallowedClanTags-Player '{0}' kicked.", info.SoldierName));
}
}
else if (this.m_DisallowedTagsBan == enumBoolYesNo.Yes)
{
if (this.m_BanGUID == enumBoolYesNo.No || this.m_PlayerGUIDs.ContainsKey(info.SoldierName) == false)
{
this.ExecuteCommand("procon.protected.send", "banList.add", "name", info.SoldierName, "perm", this.m_DisallowedTagsBanReason);
}
else
{
this.ExecuteCommand("procon.protected.send", "banList.add", "guid", this.m_PlayerGUIDs[info.SoldierName], "perm", this.m_DisallowedTagsBanReason);
}
this.ExecuteCommand("procon.protected.send", "admin.say", String.Format("Player '{0}' banned permanently due to his clan not being welcome here!", info.SoldierName));
if (this.m_ConsoleLog == enumBoolYesNo.Yes)
{
this.ExecuteCommand("procon.protected.pluginconsole.write", String.Format("^b^4AccessRestriction: ^0DisallowedClanTags-Player '{0}' banned permanently.", info.SoldierName));
}
}
}
}
}
}
}
public void OnCommandScrambleRound(string strSpeaker, string strText, MatchCommand mtcCommand, CapturedCommand capCommand, CPlayerSubset subMatchedScope){
bool blIsAdmin = false;
CPrivileges cpAccount = this.GetAccountPrivileges(strSpeaker);
if (cpAccount != null && cpAccount.PrivilegesFlags > 0) { blIsAdmin = true; }
if(blIsAdmin){
this.DebugInfoSkill("^1Admin requested a scramble next round!");
if (this.ynbEnableScrambleRound == enumBoolYesNo.Yes){
this.boolscramblebyadminroundend = true;
if (this.boolLevelStart){
if (this.ynbScrambleMessage == enumBoolYesNo.Yes){
if (this.strScrambleRoundMsg != ""){
if (this.boolVirtual)
{
this.ExecuteCommand("procon.protected.pluginconsole.write", "^b[TB] VIRTUAL:^n say all - " + this.strScrambleRoundMsg);
}
else
{
this.ExecuteCommand("procon.protected.send", "admin.say", this.strScrambleRoundMsg , "all");
}
if (this.ynbYellScrambleManuall == enumBoolYesNo.Yes && !this.boolVirtual){
this.ExecuteCommand("procon.protected.send", "admin.yell", this.strScrambleRoundMsg , "30");
}
}
}
}
}else{
this.DebugInfoSkill("^3This command is deactivated at the moment. Activate it in PRoCon.");
if (this.boolVirtual)
{
this.ExecuteCommand("procon.protected.pluginconsole.write", "^b[TB] VIRTUAL^n admin.say player " + strSpeaker + " - " + "This command is not activated for your server in PRoCon.");
}
else
{
this.ExecuteCommand("procon.protected.send", "admin.say", "This command is not activated for your server in PRoCon." , "player", strSpeaker);
}
}
}
}
public void OnCommandTBForceMove(string strSpeaker, string strText, MatchCommand mtcCommand, CapturedCommand capCommand, CPlayerSubset subMatchedScope)
{
if (capCommand.MatchedArguments.Count == 0) {
this.DebugInfoGuard("^4Malformed tb-fmove command: " + strText);
if (this.boolVirtual)
{
this.ExecuteCommand("procon.protected.pluginconsole.write", "^b[TB] VIRTUAL^n admin.say player " + strSpeaker + " - " + "Malformed command: " + strText);
}
else
{
this.ExecuteCommand("procon.protected.send", "admin.say", "Malformed command: " + strText, "player", strSpeaker);
}
return;
}
string player = capCommand.MatchedArguments[0].Argument;
this.DebugInfoGuard("^4Force Moving Player: ^b" + player);
this.DTForceMove = DateTime.Now;
if (this.OnCommandMove.ContainsKey(player) == false)
{
this.OnCommandMove.Add(player, true);
}
else
{
this.OnCommandMove[player] = true;
}
int team = 0;
if (this.dicPlayerCache[player].teamID == 1)
team = 2;
else
team = 1;
if (this.boolVirtual)
{
this.ExecuteCommand("procon.protected.pluginconsole.write", "^b[TB] VIRTUAL^n admin.movePlayer " + player + " " + team.ToString() + " 0 false");
}
else
{
this.ExecuteCommand("procon.protected.send", "admin.movePlayer", player, team.ToString(), "0", "true");
}
this.DebugInfoGuard("^4Trying to force player to the other side, due to TB-ForceMoveCommand: ^b" + player);
}
public void OnCommandTBMove(string strSpeaker, string strText, MatchCommand mtcCommand, CapturedCommand capCommand, CPlayerSubset subMatchedScope)
{
if (capCommand.MatchedArguments.Count == 0) {
this.DebugInfoGuard("^4Malformed tb-move command: " + strText);
if (this.boolVirtual)
{
this.ExecuteCommand("procon.protected.pluginconsole.write", "^b[TB] VIRTUAL^n admin.say player " + strSpeaker + " - " + "Malformed command: " + strText);
}
else
{
this.ExecuteCommand("procon.protected.send", "admin.say", "Malformed command: " + strText, "player", strSpeaker);
}
return;
}
string player = capCommand.MatchedArguments[0].Argument;
this.DebugInfoGuard("^4Move Player when dead: ^b" + player);
if (this.boolVirtual)
{
this.ExecuteCommand("procon.protected.pluginconsole.write", "^b[TB] VIRTUAL^n admin.say player " + player + " - " + "You will be moved to the other team upon death.");
}
else
{
this.ExecuteCommand("procon.protected.send", "admin.say", "You will be moved to the other team upon death.", "player", player);
}
if (this.OnCommandMoveDone.Contains(player))
{
this.OnCommandMoveDone.Remove(player);
}
if (this.OnCommandMove.ContainsKey(player) == false)
{
this.OnCommandMove.Add(player, false);
}
else
{
this.OnCommandMove[player] = false;
}
}
public override void OnListPlayers(List<CPlayerInfo> lstPlayers, CPlayerSubset cpsSubset) {
if (cpsSubset.Subset != CPlayerSubset.PlayerSubsetType.All)
return;
updateQueues(lstPlayers);
syncPlayersList(lstPlayers);
/* fail safe to get the maximum number of players in server */
if (lstPlayers.Count > max_player_count)
max_player_count = lstPlayers.Count;
if (check_state_phase == 1)
startCheckState(utc);
}
public void OnListPlayers(List<CPlayerInfo> lstPlayers, CPlayerSubset cpsSubset)
{
if (cpsSubset.Subset == CPlayerSubset.PlayerSubsetType.All)
{
foreach (CPlayerInfo cpiPlayer in lstPlayers)
{
if (this.m_dicPlayersAndBalances.ContainsKey(cpiPlayer.SoldierName) == false)
{
if (this.CheckAccountByName(cpiPlayer.SoldierName) == false)
{
this.CreateSQLAccount(cpiPlayer.GUID.ToString(), cpiPlayer.SoldierName);
this.m_dicPlayersAndBalances.Add(cpiPlayer.SoldierName, 0);
}
else
{
int balanceFromSQL = int.Parse(GetBalance(cpiPlayer.SoldierName));
this.m_dicPlayersAndBalances.Add(cpiPlayer.SoldierName, balanceFromSQL);
}
}
if (this.m_dicPlayersAndInfo.ContainsKey(cpiPlayer.SoldierName) == true)
{
this.m_dicPlayersAndInfo[cpiPlayer.SoldierName] = cpiPlayer;
}
else
{
this.m_dicPlayersAndInfo.Add(cpiPlayer.SoldierName, cpiPlayer);
}
if (this.m_ebynEnablePayroll == enumBoolYesNo.Yes)
{
this.PayrollManager(cpiPlayer.SoldierName);
}
if (this.m_dicOldPlayersAndBalances.ContainsKey(cpiPlayer.SoldierName))
{
if (this.m_dicOldPlayersAndBalances[cpiPlayer.SoldierName] != this.m_dicPlayersAndBalances[cpiPlayer.SoldierName])
{
this.SetCurrency(this.m_dicPlayersAndBalances[cpiPlayer.SoldierName], cpiPlayer.SoldierName);
this.m_dicOldPlayersAndBalances[cpiPlayer.SoldierName] = this.m_dicPlayersAndBalances[cpiPlayer.SoldierName];
}
}
else
{
this.m_dicOldPlayersAndBalances.Add(cpiPlayer.SoldierName, this.m_dicPlayersAndBalances[cpiPlayer.SoldierName]);
}
}
SquadCensus("update", 0, 0);
}
}
public override void OnListPlayers(List<CPlayerInfo> players, CPlayerSubset subset)
{
if (this.threadsReady)
{
this.DebugWrite("Listing Players", 5);
//Player list and ban list need to be locked for this operation
lock (playersMutex)
{
//Reset the player counts of both sides and recount everything
this.USPlayerCount = 0;
this.RUPlayerCount = 0;
foreach (CPlayerInfo player in players)
{
AdKat_Player aPlayer = null;
if (this.playerDictionary.TryGetValue(player.SoldierName, out aPlayer))
{
//If the player does not have an IP address, check the database until they have one.
if (String.IsNullOrEmpty(aPlayer.player_ip))
{
aPlayer = this.fetchPlayer(-1, player.SoldierName, player.GUID, null);
aPlayer.frostbitePlayerInfo = player;
//In case of quick name-change, update their IGN
aPlayer.player_name = player.SoldierName;
//if player now has an IP, call a ban check
if (!String.IsNullOrEmpty(aPlayer.player_ip))
{
//Check with ban enforcer
this.queuePlayerForBanCheck(aPlayer);
}
}
else
{
//Otherwise, just update the frostbite player info
this.playerDictionary[player.SoldierName].frostbitePlayerInfo = player;
}
}
else
{
aPlayer = this.fetchPlayer(-1, player.SoldierName, player.GUID, null);
aPlayer.frostbitePlayerInfo = player;
//In case of quick name-change, update their IGN
aPlayer.player_name = player.SoldierName;
this.playerDictionary.Add(player.SoldierName, aPlayer);
//Check with ban enforcer
this.queuePlayerForBanCheck(aPlayer);
if (this.isAdminAssistant(aPlayer))
{
this.DebugWrite(player.SoldierName + " IS an Admin Assistant.", 3);
if (!this.adminAssistantCache.ContainsKey(player.SoldierName))
{
this.adminAssistantCache.Add(player.SoldierName, false);
this.DebugWrite(player.SoldierName + " added to the Admin Assistant Cache.", 4);
}
else
{
this.DebugWrite("Player is already in the admin assitant cache, this is abnormal.", 3);
}
}
else
{
this.DebugWrite(player.SoldierName + " is NOT an Admin Assistant.", 4);
}
}
if (player.TeamID == USTeamID)
{
this.USPlayerCount++;
}
else
{
this.RUPlayerCount++;
}
}
}
//Set the handle for teamswap
this.listPlayersHandle.Set();
}
}
public void OnCommandPlayerLocation(string strSpeaker, string strText, MatchCommand mtcCommand, CapturedCommand capCommand, CPlayerSubset subMatchedScope) {
if (this.m_enAllowPlayersToGetOthersCountry == enumBoolYesNo.Yes) {
if (base.PunkbusterPlayerInfoList.ContainsKey(capCommand.MatchedArguments[0].Argument) == true) {
this.ExecuteCommand("procon.protected.send", "admin.say", base.PunkbusterPlayerInfoList[capCommand.MatchedArguments[0].Argument].SoldierName + "'s location: " + base.PunkbusterPlayerInfoList[capCommand.MatchedArguments[0].Argument].PlayerCountry, "player", strSpeaker);
}
else {
this.ExecuteCommand("procon.protected.send", "admin.say", "Player not found", "player", strSpeaker);
}
}
}
