Mute Banner for Profile & Prevent Self-Target & Correctly Expire Early Unmutes (#272)

* Fix self-targeting
Remove creation of penalty on mute expiration

* Display mute penalties on profile
Expire mute penalties on unmute

* Resolves issues in code review
Added comment in ClientController.cs
Fixed order of operations in MuteManager.cs
Fixed condition in MuteManager.cs

* Fix self-targeting
Remove creation of penalty on mute expiration

* Display mute penalties on profile
Expire mute penalties on unmute

* Resolves issues in code review
Added comment in ClientController.cs
Fixed order of operations in MuteManager.cs
Fixed condition in MuteManager.cs

* Changed localisation value to be more generic
Fix null reference warning (it should never be null) (34da216)

Application/Alerts/AlertExtensions.cs

@@ -0,0 +1,55 @@
+using System;
+using SharedLibraryCore;
+using SharedLibraryCore.Alerts;
+using SharedLibraryCore.Database.Models;
+
+namespace IW4MAdmin.Application.Alerts;
+
+public static class AlertExtensions
+{
+    public static Alert.AlertState BuildAlert(this EFClient client, Alert.AlertCategory? type = null)
+    {
+        return new Alert.AlertState
+        {
+            RecipientId = client.ClientId,
+            Category = type ?? Alert.AlertCategory.Information
+        };
+    }
+
+    public static Alert.AlertState WithCategory(this Alert.AlertState state, Alert.AlertCategory category)
+    {
+        state.Category = category;
+        return state;
+    }
+
+    public static Alert.AlertState OfType(this Alert.AlertState state, string type)
+    {
+        state.Type = type;
+        return state;
+    }
+
+    public static Alert.AlertState WithMessage(this Alert.AlertState state, string message)
+    {
+        state.Message = message;
+        return state;
+    }
+
+    public static Alert.AlertState ExpiresIn(this Alert.AlertState state, TimeSpan expiration)
+    {
+        state.ExpiresAt = DateTime.Now.Add(expiration);
+        return state;
+    }
+    
+    public static Alert.AlertState FromSource(this Alert.AlertState state, string source)
+    {
+        state.Source = source;
+        return state;
+    }
+
+    public static Alert.AlertState FromClient(this Alert.AlertState state, EFClient client)
+    {
+        state.Source = client.Name.StripColors();
+        state.SourceId = client.ClientId;
+        return state;
+    }
+}

Application/Alerts/AlertManager.cs

@@ -0,0 +1,137 @@
+using System;
+using System.Collections.Concurrent;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading.Tasks;
+using SharedLibraryCore.Alerts;
+using SharedLibraryCore.Configuration;
+using SharedLibraryCore.Database.Models;
+using SharedLibraryCore.Interfaces;
+
+namespace IW4MAdmin.Application.Alerts;
+
+public class AlertManager : IAlertManager
+{
+    private readonly ApplicationConfiguration _appConfig;
+    private readonly ConcurrentDictionary<int, List<Alert.AlertState>> _states = new();
+    private readonly List<Func<Task<IEnumerable<Alert.AlertState>>>> _staticSources = new();
+
+    public AlertManager(ApplicationConfiguration appConfig)
+    {
+        _appConfig = appConfig;
+        _states.TryAdd(0, new List<Alert.AlertState>());
+    }
+
+    public EventHandler<Alert.AlertState> OnAlertConsumed { get; set; }
+
+    public async Task Initialize()
+    {
+        foreach (var source in _staticSources)
+        {
+            var alerts = await source();
+            foreach (var alert in alerts)
+            {
+                AddAlert(alert);
+            }
+        }
+    }
+
+    public IEnumerable<Alert.AlertState> RetrieveAlerts(EFClient client)
+    {
+        lock (_states)
+        {
+            var alerts = Enumerable.Empty<Alert.AlertState>();
+            if (client.Level > Data.Models.Client.EFClient.Permission.Trusted)
+            {
+                alerts = alerts.Concat(_states[0].Where(alert =>
+                    alert.MinimumPermission is null || alert.MinimumPermission <= client.Level));
+            }
+
+            if (_states.ContainsKey(client.ClientId))
+            {
+                alerts = alerts.Concat(_states[client.ClientId].AsReadOnly());
+            }
+
+            return alerts.OrderByDescending(alert => alert.OccuredAt);
+        }
+    }
+
+    public void MarkAlertAsRead(Guid alertId)
+    {
+        lock (_states)
+        {
+            foreach (var items in _states.Values)
+            {
+                var matchingEvent = items.FirstOrDefault(item => item.AlertId == alertId);
+
+                if (matchingEvent is null)
+                {
+                    continue;
+                }
+
+                items.Remove(matchingEvent);
+                OnAlertConsumed?.Invoke(this, matchingEvent);
+            }
+        }
+    }
+
+    public void MarkAllAlertsAsRead(int recipientId)
+    {
+        lock (_states)
+        {
+            foreach (var items in _states.Values)
+            {
+                items.RemoveAll(item =>
+                {
+                    if (item.RecipientId != null && item.RecipientId != recipientId)
+                    {
+                        return false;
+                    }
+
+                    OnAlertConsumed?.Invoke(this, item);
+                    return true;
+                });
+            }
+        }
+    }
+
+    public void AddAlert(Alert.AlertState alert)
+    {
+        lock (_states)
+        {
+            if (alert.RecipientId is null)
+            {
+                _states[0].Add(alert);
+                return;
+            }
+
+            if (!_states.ContainsKey(alert.RecipientId.Value))
+            {
+                _states[alert.RecipientId.Value] = new List<Alert.AlertState>();
+            }
+
+            if (_appConfig.MinimumAlertPermissions.ContainsKey(alert.Type))
+            {
+                alert.MinimumPermission = _appConfig.MinimumAlertPermissions[alert.Type];
+            }
+
+            _states[alert.RecipientId.Value].Add(alert);
+
+            PruneOldAlerts();
+        }
+    }
+
+    public void RegisterStaticAlertSource(Func<Task<IEnumerable<Alert.AlertState>>> alertSource)
+    {
+        _staticSources.Add(alertSource);
+    }
+
+
+    private void PruneOldAlerts()
+    {
+        foreach (var value in _states.Values)
+        {
+            value.RemoveAll(item => item.ExpiresAt < DateTime.UtcNow);
+        }
+    }
+}

Application/Application.csproj

@@ -24,14 +24,14 @@
   </PropertyGroup>
 
   <ItemGroup>
-    <PackageReference Include="Jint" Version="3.0.0-beta-2037" />
+    <PackageReference Include="Jint" Version="3.0.0-beta-2042" />
     <PackageReference Include="MaxMind.GeoIP2" Version="5.1.0" />
-    <PackageReference Include="Microsoft.EntityFrameworkCore.Design" Version="6.0.1">
+    <PackageReference Include="Microsoft.EntityFrameworkCore.Design" Version="6.0.8">
       <PrivateAssets>all</PrivateAssets>
       <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
     </PackageReference>
     <PackageReference Include="Microsoft.Extensions.DependencyInjection" Version="6.0.0" />
-    <PackageReference Include="RestEase" Version="1.5.5" />
+    <PackageReference Include="RestEase" Version="1.5.7" />
     <PackageReference Include="System.Text.Encoding.CodePages" Version="6.0.0" />
   </ItemGroup>
 

Application/ApplicationManager.cs

@@ -46,6 +46,8 @@ namespace IW4MAdmin.Application
 
         public IList<IRConParser> AdditionalRConParsers { get; }
         public IList<IEventParser> AdditionalEventParsers { get; }
+        public IList<Func<GameEvent, bool>> CommandInterceptors { get; set; } =
+            new List<Func<GameEvent, bool>>();
         public ITokenAuthentication TokenAuthenticator { get; }
         public CancellationToken CancellationToken => _tokenSource.Token;
         public string ExternalIPAddress { get; private set; }
@@ -57,10 +59,11 @@ namespace IW4MAdmin.Application
         private readonly List<MessageToken> MessageTokens;
         private readonly ClientService ClientSvc;
         readonly PenaltyService PenaltySvc;
+        private readonly IAlertManager _alertManager;
         public IConfigurationHandler<ApplicationConfiguration> ConfigHandler;
         readonly IPageList PageList;
         private readonly TimeSpan _throttleTimeout = new TimeSpan(0, 1, 0);
-        private readonly CancellationTokenSource _tokenSource;
+        private CancellationTokenSource _tokenSource;
         private readonly Dictionary<string, Task<IList>> _operationLookup = new Dictionary<string, Task<IList>>();
         private readonly ITranslationLookup _translationLookup;
         private readonly IConfigurationHandler<CommandConfiguration> _commandConfiguration;
@@ -82,18 +85,19 @@ namespace IW4MAdmin.Application
             IEnumerable<IPlugin> plugins, IParserRegexFactory parserRegexFactory, IEnumerable<IRegisterEvent> customParserEvents,
             IEventHandler eventHandler, IScriptCommandFactory scriptCommandFactory, IDatabaseContextFactory contextFactory,
             IMetaRegistration metaRegistration, IScriptPluginServiceResolver scriptPluginServiceResolver, ClientService clientService, IServiceProvider serviceProvider,
-            ChangeHistoryService changeHistoryService, ApplicationConfiguration appConfig, PenaltyService penaltyService)
+            ChangeHistoryService changeHistoryService, ApplicationConfiguration appConfig, PenaltyService penaltyService, IAlertManager alertManager, IInteractionRegistration interactionRegistration)
         {
             MiddlewareActionHandler = actionHandler;
             _servers = new ConcurrentBag<Server>();
             MessageTokens = new List<MessageToken>();
             ClientSvc = clientService;
             PenaltySvc = penaltyService;
+            _alertManager = alertManager;
             ConfigHandler = appConfigHandler;
             StartTime = DateTime.UtcNow;
             PageList = new PageList();
-            AdditionalEventParsers = new List<IEventParser>() { new BaseEventParser(parserRegexFactory, logger, _appConfig) };
-            AdditionalRConParsers = new List<IRConParser>() { new BaseRConParser(serviceProvider.GetRequiredService<ILogger<BaseRConParser>>(), parserRegexFactory) };
+            AdditionalEventParsers = new List<IEventParser> { new BaseEventParser(parserRegexFactory, logger, _appConfig) };
+            AdditionalRConParsers = new List<IRConParser> { new BaseRConParser(serviceProvider.GetRequiredService<ILogger<BaseRConParser>>(), parserRegexFactory) };
             TokenAuthenticator = new TokenAuthentication();
             _logger = logger;
             _tokenSource = new CancellationTokenSource();
@@ -111,9 +115,11 @@ namespace IW4MAdmin.Application
             _changeHistoryService = changeHistoryService;
             _appConfig = appConfig;
             Plugins = plugins;
+            InteractionRegistration = interactionRegistration;
         }
 
         public IEnumerable<IPlugin> Plugins { get; }
+        public IInteractionRegistration InteractionRegistration { get; }
 
         public async Task ExecuteEvent(GameEvent newEvent)
         {
@@ -223,14 +229,13 @@ namespace IW4MAdmin.Application
         {
             // store the server hash code and task for it
             var runningUpdateTasks = new Dictionary<long, (Task task, CancellationTokenSource tokenSource, DateTime startTime)>();
+            var timeout = TimeSpan.FromSeconds(60);
 
-            while (!_tokenSource.IsCancellationRequested)
+            while (!_tokenSource.IsCancellationRequested) // main shutdown requested
             {
                 // select the server ids that have completed the update task
                 var serverTasksToRemove = runningUpdateTasks
-                    .Where(ut => ut.Value.task.Status == TaskStatus.RanToCompletion ||
-                                 ut.Value.task.Status == TaskStatus.Canceled || // we want to cancel if a task takes longer than 5 minutes
-                                 ut.Value.task.Status == TaskStatus.Faulted || DateTime.Now - ut.Value.startTime > TimeSpan.FromMinutes(5))
+                    .Where(ut => ut.Value.task.IsCompleted)
                     .Select(ut => ut.Key)
                     .ToList();
 
@@ -246,36 +251,16 @@ namespace IW4MAdmin.Application
                 }
 
                 // select the servers where the tasks have completed
-                var serverIds = Servers.Select(s => s.EndPoint).Except(runningUpdateTasks.Select(r => r.Key)).ToList();
-                foreach (var server in Servers.Where(s => serverIds.Contains(s.EndPoint)))
+                var newTaskServers = Servers.Select(s => s.EndPoint).Except(runningUpdateTasks.Select(r => r.Key)).ToList();
+                
+                foreach (var server in Servers.Where(s => newTaskServers.Contains(s.EndPoint)))
                 {
-                    var tokenSource = new CancellationTokenSource();
-                    runningUpdateTasks.Add(server.EndPoint, (Task.Run(async () =>
-                    {
-                        try
-                        {
-                            if (runningUpdateTasks.ContainsKey(server.EndPoint))
-                            {
-                                await server.ProcessUpdatesAsync(_tokenSource.Token)
-                                    .WithWaitCancellation(runningUpdateTasks[server.EndPoint].tokenSource.Token);
-                            }
-                        }
-
-                        catch (Exception e)
-                        {
-                            using (LogContext.PushProperty("Server", server.ToString()))
-                            {
-                                _logger.LogError(e, "Failed to update status");
-                            }
-                        }
-
-                        finally
-                        {
-                            server.IsInitialized = true;
-                        }
-                    }, tokenSource.Token), tokenSource, DateTime.Now));
+                    var firstTokenSource = new CancellationTokenSource();
+                    firstTokenSource.CancelAfter(timeout);
+                    var linkedTokenSource = CancellationTokenSource.CreateLinkedTokenSource(firstTokenSource.Token, _tokenSource.Token);
+                    runningUpdateTasks.Add(server.EndPoint, (ProcessUpdateHandler(server, linkedTokenSource.Token), linkedTokenSource, DateTime.Now));
                 }
-
+                
                 try
                 {
                     await Task.Delay(ConfigHandler.Configuration().RConPollRate, _tokenSource.Token);
@@ -283,7 +268,7 @@ namespace IW4MAdmin.Application
                 // if a cancellation is received, we want to return immediately after shutting down
                 catch
                 {
-                    foreach (var server in Servers.Where(s => serverIds.Contains(s.EndPoint)))
+                    foreach (var server in Servers.Where(s => newTaskServers.Contains(s.EndPoint)))
                     {
                         await server.ProcessUpdatesAsync(_tokenSource.Token);
                     }
@@ -292,6 +277,25 @@ namespace IW4MAdmin.Application
             }
         }
 
+        private async Task ProcessUpdateHandler(Server server, CancellationToken token)
+        {
+            try
+            {
+                await server.ProcessUpdatesAsync(token);
+            }
+            catch (Exception ex)
+            {
+                using (LogContext.PushProperty("Server", server.ToString()))
+                {
+                    _logger.LogError(ex, "Failed to update status");
+                }
+            }
+            finally
+            {
+                server.IsInitialized = true;
+            }
+        }
+
         public async Task Init()
         {
             IsRunning = true;
@@ -508,6 +512,7 @@ namespace IW4MAdmin.Application
             #endregion
 
             _metaRegistration.Register();
+            await _alertManager.Initialize();
 
             #region CUSTOM_EVENTS
             foreach (var customEvent in _customParserEvents.SelectMany(_events => _events.Events))
@@ -610,6 +615,8 @@ namespace IW4MAdmin.Application
         {
             IsRestartRequested = true;
             Stop().GetAwaiter().GetResult();
+            _tokenSource.Dispose();
+            _tokenSource = new CancellationTokenSource();
         }
 
         [Obsolete]
@@ -629,9 +636,9 @@ namespace IW4MAdmin.Application
             return _servers.SelectMany(s => s.Clients).ToList().Where(p => p != null).ToList();
         }
 
-        public EFClient FindActiveClient(EFClient client) =>client.ClientNumber < 0 ?
+        public EFClient FindActiveClient(EFClient client) => client.ClientNumber < 0 ?
                 GetActiveClients()
-                    .FirstOrDefault(c => c.NetworkId == client.NetworkId) ?? client :
+                    .FirstOrDefault(c => c.NetworkId == client.NetworkId && c.GameName == client.GameName) ?? client :
                 client;
 
         public ClientService GetClientService()
@@ -697,5 +704,6 @@ namespace IW4MAdmin.Application
         }
 
         public void RemoveCommandByName(string commandName) => _commands.RemoveAll(_command => _command.Name == commandName);
+        public IAlertManager AlertManager => _alertManager;
     }
 }

Application/BuildScripts/DownloadTranslations.ps1

@@ -7,6 +7,6 @@ foreach($localization in $localizations)
 {
     $url = "http://api.raidmax.org:5000/localization/{0}" -f $localization
     $filePath = "{0}Localization\IW4MAdmin.{1}.json" -f $OutputDir, $localization
-    $response = Invoke-WebRequest $url
+    $response = Invoke-WebRequest $url -UseBasicParsing
     Out-File -FilePath $filePath -InputObject $response.Content -Encoding utf8
-}
+}

Application/Commands/AddClientNoteCommand.cs

@@ -0,0 +1,52 @@
+using System;
+using System.Threading.Tasks;
+using Data.Models.Client;
+using IW4MAdmin.Application.Meta;
+using SharedLibraryCore;
+using SharedLibraryCore.Commands;
+using SharedLibraryCore.Configuration;
+using SharedLibraryCore.Dtos.Meta.Responses;
+using SharedLibraryCore.Interfaces;
+
+namespace IW4MAdmin.Application.Commands;
+
+public class AddClientNoteCommand : Command
+{
+    private readonly IMetaServiceV2 _metaService;
+
+    public AddClientNoteCommand(CommandConfiguration config, ITranslationLookup layout, IMetaServiceV2 metaService) : base(config, layout)
+    {
+        Name = "addnote";
+        Description = _translationLookup["COMMANDS_ADD_CLIENT_NOTE_DESCRIPTION"];
+        Alias = "an";
+        Permission = EFClient.Permission.Moderator;
+        RequiresTarget = true;
+        Arguments = new[]
+        {
+            new CommandArgument
+            {
+                Name = _translationLookup["COMMANDS_ARGS_PLAYER"],
+                Required = true
+            },
+            new CommandArgument
+            {
+                Name = _translationLookup["COMMANDS_ARGS_NOTE"],
+                Required = false
+            }
+        };
+        
+        _metaService = metaService;
+    }
+
+    public override async Task ExecuteAsync(GameEvent gameEvent)
+    {
+        var note = new ClientNoteMetaResponse
+        {
+            Note = gameEvent.Data?.Trim(),
+            OriginEntityId = gameEvent.Origin.ClientId,
+            ModifiedDate = DateTime.UtcNow
+        };
+        await _metaService.SetPersistentMetaValue("ClientNotes", note, gameEvent.Target.ClientId);
+        gameEvent.Origin.Tell(_translationLookup["COMMANDS_ADD_CLIENT_NOTE_SUCCESS"]);
+    }
+}

Application/Commands/OfflineMessageCommand.cs

@@ -1,11 +1,14 @@
 using System;
+using System.Linq;
 using System.Threading.Tasks;
 using Data.Abstractions;
 using Data.Models.Client;
 using Data.Models.Misc;
+using IW4MAdmin.Application.Alerts;
 using Microsoft.EntityFrameworkCore;
 using Microsoft.Extensions.Logging;
 using SharedLibraryCore;
+using SharedLibraryCore.Alerts;
 using SharedLibraryCore.Configuration;
 using SharedLibraryCore.Interfaces;
 using ILogger = Microsoft.Extensions.Logging.ILogger;
@@ -16,19 +19,66 @@ namespace IW4MAdmin.Application.Commands
     {
         private readonly IDatabaseContextFactory _contextFactory;
         private readonly ILogger _logger;
+        private readonly IAlertManager _alertManager;
         private const short MaxLength = 1024;
-        
+
         public OfflineMessageCommand(CommandConfiguration config, ITranslationLookup layout,
-            IDatabaseContextFactory contextFactory, ILogger<IDatabaseContextFactory> logger) : base(config, layout)
+            IDatabaseContextFactory contextFactory, ILogger<IDatabaseContextFactory> logger, IAlertManager alertManager)
+            : base(config, layout)
         {
             Name = "offlinemessage";
             Description = _translationLookup["COMMANDS_OFFLINE_MESSAGE_DESC"];
             Alias = "om";
             Permission = EFClient.Permission.Moderator;
             RequiresTarget = true;
-            
+
             _contextFactory = contextFactory;
             _logger = logger;
+            _alertManager = alertManager;
+
+            _alertManager.RegisterStaticAlertSource(async () =>
+            {
+                var context = contextFactory.CreateContext(false);
+                return await context.InboxMessages.Where(message => !message.IsDelivered)
+                    .Where(message => message.CreatedDateTime >= DateTime.UtcNow.AddDays(-7))
+                    .Where(message => message.DestinationClient.Level > EFClient.Permission.User)
+                    .Select(message => new Alert.AlertState
+                    {
+                        OccuredAt = message.CreatedDateTime,
+                        Message = message.Message,
+                        ExpiresAt = DateTime.UtcNow.AddDays(7),
+                        Category = Alert.AlertCategory.Message,
+                        Source = message.SourceClient.CurrentAlias.Name.StripColors(),
+                        SourceId = message.SourceClientId,
+                        RecipientId = message.DestinationClientId,
+                        ReferenceId = message.InboxMessageId,
+                        Type = nameof(EFInboxMessage)
+                    }).ToListAsync();
+            });
+
+            _alertManager.OnAlertConsumed += (_, state) =>
+            {
+                if (state.Category != Alert.AlertCategory.Message || state.ReferenceId is null)
+                {
+                    return;
+                }
+
+                try
+                {
+                    var context = contextFactory.CreateContext(true);
+                    foreach (var message in context.InboxMessages
+                                 .Where(message => message.InboxMessageId == state.ReferenceId.Value).ToList())
+                    {
+                        message.IsDelivered = true;
+                    }
+
+                    context.SaveChanges();
+                }
+                catch (Exception ex)
+                {
+                    _logger.LogError(ex, "Could not update message state for alert {@Alert}", state);
+                }
+            };
         }
 
         public override async Task ExecuteAsync(GameEvent gameEvent)
@@ -38,23 +88,24 @@ namespace IW4MAdmin.Application.Commands
                 gameEvent.Origin.Tell(_translationLookup["COMMANDS_OFFLINE_MESSAGE_TOO_LONG"].FormatExt(MaxLength));
                 return;
             }
-            
+
             if (gameEvent.Target.ClientId == gameEvent.Origin.ClientId)
             {
                 gameEvent.Origin.Tell(_translationLookup["COMMANDS_OFFLINE_MESSAGE_SELF"].FormatExt(MaxLength));
                 return;
             }
-            
+
             if (gameEvent.Target.IsIngame)
             {
-                gameEvent.Origin.Tell(_translationLookup["COMMANDS_OFFLINE_MESSAGE_INGAME"].FormatExt(gameEvent.Target.Name));
+                gameEvent.Origin.Tell(_translationLookup["COMMANDS_OFFLINE_MESSAGE_INGAME"]
+                    .FormatExt(gameEvent.Target.Name));
                 return;
             }
-            
+
             await using var context = _contextFactory.CreateContext(enableTracking: false);
             var server = await context.Servers.FirstAsync(srv => srv.EndPoint == gameEvent.Owner.ToString());
 
-            var newMessage = new EFInboxMessage()
+            var newMessage = new EFInboxMessage
             {
                 SourceClientId = gameEvent.Origin.ClientId,
                 DestinationClientId = gameEvent.Target.ClientId,
@@ -62,6 +113,12 @@ namespace IW4MAdmin.Application.Commands
                 Message = gameEvent.Data,
             };
 
+            _alertManager.AddAlert(gameEvent.Target.BuildAlert(Alert.AlertCategory.Message)
+                .WithMessage(gameEvent.Data.Trim())
+                .FromClient(gameEvent.Origin)
+                .OfType(nameof(EFInboxMessage))
+                .ExpiresIn(TimeSpan.FromDays(7)));
+
             try
             {
                 context.Set<EFInboxMessage>().Add(newMessage);
@@ -75,4 +132,4 @@ namespace IW4MAdmin.Application.Commands
             }
         }
     }
-}
+}

Application/Commands/ReadMessageCommand.cs

@@ -24,7 +24,7 @@ namespace IW4MAdmin.Application.Commands
             Name = "readmessage";
             Description = _translationLookup["COMMANDS_READ_MESSAGE_DESC"];
             Alias = "rm";
-            Permission = EFClient.Permission.Flagged;
+            Permission = EFClient.Permission.User;
 
             _contextFactory = contextFactory;
             _logger = logger;
@@ -76,4 +76,4 @@ namespace IW4MAdmin.Application.Commands
             }
         }
     }
-}
+}

Application/DefaultSettings.json

@@ -564,7 +564,56 @@
           "Alias": "Momentum"
         }
       ]
-    }
+    },
+{
+      "Game": "H1",
+      "Gametypes": [
+	{
+          "Name": "conf",
+          "Alias": "Kill Confirmed"
+        },
+        {
+          "Name": "ctf",
+          "Alias": "Capture The Flag"
+        },
+        {
+          "Name": "dd",
+          "Alias": "Demolition"
+        },
+        {
+          "Name": "dm",
+          "Alias": "Free For All"
+        },
+        {
+          "Name": "dom",
+          "Alias": "Domination"
+        },
+	{
+          "Name": "gun",
+          "Alias": "Gun Game"
+        },
+	{
+          "Name": "hp",
+          "Alias": "Hardpoint"
+        },
+        {
+          "Name": "koth",
+          "Alias": "Headquarters"
+        },
+        {
+          "Name": "sab",
+          "Alias": "Sabotage"
+        },
+        {
+          "Name": "sd",
+          "Alias": "Search & Destroy"
+        },
+        {
+          "Name": "war",
+          "Alias": "Team Deathmatch"
+        }
+      ]
+}
   ],
   "Maps": [
     {
@@ -1768,6 +1817,103 @@
         }
       ]
     },
+    {
+      "Game": "H1",
+      "Maps": [
+        {
+          "Alias": "Ambush",
+          "Name": "mp_convoy"
+        },
+        {
+          "Alias": "Backlot",
+          "Name": "mp_backlot"
+        },
+        {
+          "Alias": "Bloc",
+          "Name": "mp_bloc"
+        },
+        {
+          "Alias": "Bog",
+          "Name": "mp_bog"
+        },
+        {
+          "Alias": "Countdown",
+          "Name": "mp_countdown"
+        },
+        {
+          "Alias": "Crash",
+          "Name": "mp_crash"
+        },
+        {
+          "Alias": "Crossfire",
+          "Name": "mp_crossfire"
+        },
+        {
+          "Alias": "District",
+          "Name": "mp_citystreets"
+        },
+        {
+          "Alias": "Downpour",
+          "Name": "mp_farm"
+        },
+        {
+          "Alias": "Overgrown",
+          "Name": "mp_overgrown"
+        },
+        {
+          "Alias": "Pipeline",
+          "Name": "mp_pipeline"
+        },
+        {
+          "Alias": "Shipment",
+          "Name": "mp_shipment"
+        },
+        {
+          "Alias": "Showdown",
+          "Name": "mp_showdown"
+        },
+        {
+          "Alias": "Strike",
+          "Name": "mp_strike"
+        },
+        {
+          "Alias": "Vacant",
+          "Name": "mp_vacant"
+        },
+        {
+          "Alias": "Wet Work",
+          "Name": "mp_cargoship"
+        },
+        {
+          "Alias": "Winter Crash",
+          "Name": "mp_crash_snow"
+        },
+        {
+          "Alias": "Broadcast",
+          "Name": "mp_broadcast"
+        },
+        {
+          "Alias": "Creek",
+          "Name": "mp_creek"
+        },
+        {
+          "Alias": "Chinatown",
+          "Name": "mp_carentan"
+        },
+        {
+          "Alias": "Killhouse",
+          "Name": "mp_killhouse"
+        },
+        {
+          "Alias": "Day Break",
+          "Name": "mp_farm_spring"
+        },
+        {
+          "Alias": "Beach Bog",
+          "Name": "mp_bog_summer"
+        }
+      ]
+    },  
     {
       "Game": "CSGO",
       "Maps": [

Application/EventParsers/BaseEventParser.cs

@@ -105,6 +105,8 @@ namespace IW4MAdmin.Application.EventParsers
             {
                 {"say", GameEvent.EventType.Say},
                 {"sayteam", GameEvent.EventType.Say},
+                {"chat", GameEvent.EventType.Say},
+                {"chatteam", GameEvent.EventType.Say},
                 {"K", GameEvent.EventType.Kill},
                 {"D", GameEvent.EventType.Damage},
                 {"J", GameEvent.EventType.PreConnect},

Application/Extensions/ScriptPluginExtensions.cs

@@ -0,0 +1,34 @@
+using System.Collections.Generic;
+using System.Linq;
+using Data.Models.Client.Stats;
+using Microsoft.EntityFrameworkCore;
+using SharedLibraryCore;
+
+namespace IW4MAdmin.Application.Extensions;
+
+public static class ScriptPluginExtensions
+{
+    public static IEnumerable<object> GetClientsBasicData(
+        this DbSet<Data.Models.Client.EFClient> set, int[] clientIds)
+    {
+        return set.Where(client => clientIds.Contains(client.ClientId))
+            .Select(client => new
+            {
+                client.ClientId,
+                client.CurrentAlias,
+                client.Level,
+                client.NetworkId
+            }).ToList();
+    }
+
+    public static IEnumerable<object> GetClientsStatData(this DbSet<EFClientStatistics> set, int[] clientIds,
+        double serverId)
+    {
+        return set.Where(stat => clientIds.Contains(stat.ClientId) && stat.ServerId == (long)serverId).ToList();
+    }
+
+    public static object GetId(this Server server)
+    {
+        return server.GetIdForServer().GetAwaiter().GetResult();
+    }
+}

Application/IW4MServer.cs

@@ -9,6 +9,7 @@ using SharedLibraryCore.Helpers;
 using SharedLibraryCore.Interfaces;
 using System;
 using System.Collections.Generic;
+using System.Globalization;
 using System.IO;
 using System.Linq;
 using System.Net;
@@ -24,8 +25,10 @@ using Serilog.Context;
 using static SharedLibraryCore.Database.Models.EFClient;
 using Data.Models;
 using Data.Models.Server;
+using IW4MAdmin.Application.Alerts;
 using IW4MAdmin.Application.Commands;
 using Microsoft.EntityFrameworkCore;
+using SharedLibraryCore.Alerts;
 using static Data.Models.Client.EFClient;
 
 namespace IW4MAdmin
@@ -73,7 +76,7 @@ namespace IW4MAdmin
         {
             ServerLogger.LogDebug("Client slot #{clientNumber} now reserved", clientFromLog.ClientNumber);
 
-            EFClient client = await Manager.GetClientService().GetUnique(clientFromLog.NetworkId);
+            var client = await Manager.GetClientService().GetUnique(clientFromLog.NetworkId, GameName);
 
             // first time client is connecting to server
             if (client == null)
@@ -116,7 +119,7 @@ namespace IW4MAdmin
 
         public override async Task OnClientDisconnected(EFClient client)
         {
-            if (!GetClientsAsList().Any(_client => _client.NetworkId == client.NetworkId))
+            if (GetClientsAsList().All(eachClient => eachClient.NetworkId != client.NetworkId))
             {
                 using (LogContext.PushProperty("Server", ToString()))
                 {
@@ -152,11 +155,9 @@ namespace IW4MAdmin
             {
                 if (E.IsBlocking)
                 {
-                    await E.Origin?.Lock();
+                    await E.Origin.Lock();
                 }
 
-                bool canExecuteCommand = true;
-
                 try
                 {
                     if (!await ProcessEvent(E))
@@ -164,53 +165,52 @@ namespace IW4MAdmin
                         return;
                     }
 
-                    Command C = null;
+                    Command command = null;
                     if (E.Type == GameEvent.EventType.Command)
                     {
                         try
                         {
-                            C = await SharedLibraryCore.Commands.CommandProcessing.ValidateCommand(E, Manager.GetApplicationSettings().Configuration(), _commandConfiguration);
+                            command = await SharedLibraryCore.Commands.CommandProcessing.ValidateCommand(E, Manager.GetApplicationSettings().Configuration(), _commandConfiguration);
                         }
 
                         catch (CommandException e)
                         {
-                            ServerLogger.LogWarning(e, "Error validating command from event {@event}", 
+                            ServerLogger.LogWarning(e, "Error validating command from event {@Event}", 
                                 new { E.Type, E.Data, E.Message, E.Subtype, E.IsRemote, E.CorrelationId });
                             E.FailReason = GameEvent.EventFailReason.Invalid;
                         }
 
-                        if (C != null)
+                        if (command != null)
                         {
-                            E.Extra = C;
+                            E.Extra = command;
                         }
                     }
 
-                    try
+                    var canExecuteCommand = Manager.CommandInterceptors.All(interceptor =>
                     {
-                        var loginPlugin = Manager.Plugins.FirstOrDefault(_plugin => _plugin.Name == "Login");
-
-                        if (loginPlugin != null)
+                        try
                         {
-                            await loginPlugin.OnEventAsync(E, this);
+                            return interceptor(E);
                         }
+                        catch
+                        {
+                            return true;
+                        }
+                    });
+
+                    if (!canExecuteCommand)
+                    {
+                        E.Origin.Tell(_translationLookup["SERVER_COMMANDS_INTERCEPTED"]);
                     }
 
-                    catch (AuthorizationException e)
+                    else if (E.Type == GameEvent.EventType.Command && E.Extra is Command cmd)
                     {
-                        E.Origin.Tell($"{loc["COMMAND_NOTAUTHORIZED"]} - {e.Message}");
-                        canExecuteCommand = false;
-                    }
-
-                    // hack: this prevents commands from getting executing that 'shouldn't' be
-                    if (E.Type == GameEvent.EventType.Command && E.Extra is Command command &&
-                        (canExecuteCommand || E.Origin?.Level == Permission.Console))
-                    {
-                        ServerLogger.LogInformation("Executing command {comamnd} for {client}", command.Name, E.Origin.ToString());
-                        await command.ExecuteAsync(E);
+                        ServerLogger.LogInformation("Executing command {Command} for {Client}", cmd.Name,
+                            E.Origin.ToString());
+                        await cmd.ExecuteAsync(E);
                     }
 
                     var pluginTasks = Manager.Plugins
-                        .Where(_plugin => _plugin.Name != "Login")
                         .Select(async plugin => await CreatePluginTask(plugin, E));
                     
                     await Task.WhenAll(pluginTasks);
@@ -306,8 +306,16 @@ namespace IW4MAdmin
                     if (!Manager.GetApplicationSettings().Configuration().IgnoreServerConnectionLost)
                     {
                         Console.WriteLine(loc["SERVER_ERROR_COMMUNICATION"].FormatExt($"{IP}:{Port}"));
+                        
+                        var alert = Alert.AlertState.Build().OfType(E.Type.ToString())
+                            .WithCategory(Alert.AlertCategory.Error)
+                            .FromSource("System")
+                            .WithMessage(loc["SERVER_ERROR_COMMUNICATION"].FormatExt($"{IP}:{Port}"))
+                            .ExpiresIn(TimeSpan.FromDays(1));
+                        
+                        Manager.AlertManager.AddAlert(alert);
                     }
-
+      
                     Throttled = true;
                 }
 
@@ -318,7 +326,15 @@ namespace IW4MAdmin
                     
                     if (!Manager.GetApplicationSettings().Configuration().IgnoreServerConnectionLost)
                     {
-                        Console.WriteLine(loc["MANAGER_CONNECTION_REST"].FormatExt($"[{IP}:{Port}]"));
+                        Console.WriteLine(loc["MANAGER_CONNECTION_REST"].FormatExt($"{IP}:{Port}"));
+                        
+                        var alert = Alert.AlertState.Build().OfType(E.Type.ToString())
+                            .WithCategory(Alert.AlertCategory.Information)
+                            .FromSource("System")
+                            .WithMessage(loc["MANAGER_CONNECTION_REST"].FormatExt($"{IP}:{Port}"))
+                            .ExpiresIn(TimeSpan.FromDays(1));
+
+                        Manager.AlertManager.AddAlert(alert);
                     }
 
                     if (!string.IsNullOrEmpty(CustomSayName))
@@ -355,9 +371,9 @@ namespace IW4MAdmin
                         var clientTag = await _metaService.GetPersistentMetaByLookup(EFMeta.ClientTagV2,
                             EFMeta.ClientTagNameV2, E.Origin.ClientId, Manager.CancellationToken);
 
-                        if (clientTag?.LinkedMeta != null)
+                        if (clientTag?.Value != null)
                         {
-                            E.Origin.Tag = clientTag.LinkedMeta.Value;
+                            E.Origin.Tag = clientTag.Value;
                         }
 
                         try
@@ -431,7 +447,7 @@ namespace IW4MAdmin
                         Clients[E.Origin.ClientNumber] = E.Origin;
                         try
                         {
-                            E.Origin.GameName = (Reference.Game?)GameName;
+                            E.Origin.GameName = (Reference.Game)GameName;
                             E.Origin = await OnClientConnected(E.Origin);
                             E.Target = E.Origin;
                         }
@@ -499,7 +515,7 @@ namespace IW4MAdmin
 
                     E.Target.SetLevel(Permission.User, E.Origin);
                     await Manager.GetPenaltyService().RemoveActivePenalties(E.Target.AliasLinkId, E.Target.NetworkId,
-                        E.Target.CurrentAlias?.IPAddress);
+                        E.Target.GameName, E.Target.CurrentAlias?.IPAddress);
                     await Manager.GetPenaltyService().Create(unflagPenalty);
                 }
 
@@ -657,7 +673,7 @@ namespace IW4MAdmin
 
                 else if (E.Type == GameEvent.EventType.MapChange)
                 {
-                    ServerLogger.LogInformation("New map loaded - {clientCount} active players", ClientNum);
+                    ServerLogger.LogInformation("New map loaded - {ClientCount} active players", ClientNum);
 
                     // iw4 doesn't log the game info
                     if (E.Extra == null)
@@ -671,29 +687,58 @@ namespace IW4MAdmin
 
                         else
                         {
-                            Gametype = dict["gametype"];
-                            Hostname = dict["hostname"];
+                            if (dict.ContainsKey("gametype"))
+                            {
+                                Gametype = dict["gametype"];
+                            }
 
-                            string mapname = dict["mapname"] ?? CurrentMap.Name;
-                            UpdateMap(mapname);
+                            if (dict.ContainsKey("hostname"))
+                            {
+                                Hostname = dict["hostname"];
+                            }
+
+                            var newMapName = dict.ContainsKey("mapname")
+                                ? dict["mapname"] ?? CurrentMap.Name
+                                : CurrentMap.Name;
+                            UpdateMap(newMapName);
                         }
                     }
 
                     else
                     {
-                        var dict = (Dictionary<string, string>) E.Extra;
-                        Gametype = dict["g_gametype"];
-                        Hostname = dict["sv_hostname"];
-                        MaxClients = int.Parse(dict["sv_maxclients"]);
+                        var dict = (Dictionary<string, string>)E.Extra;
+                        if (dict.ContainsKey("g_gametype"))
+                        {
+                            Gametype = dict["g_gametype"];
+                        }
 
-                        string mapname = dict["mapname"];
-                        UpdateMap(mapname);
+                        if (dict.ContainsKey("sv_hostname"))
+                        {
+                            Hostname = dict["sv_hostname"];
+                        }
+
+                        if (dict.ContainsKey("sv_maxclients"))
+                        {
+                            MaxClients = int.Parse(dict["sv_maxclients"]);
+                        }
+
+                        else if (dict.ContainsKey("com_maxclients"))
+                        {
+                            MaxClients = int.Parse(dict["com_maxclients"]);
+                        }
+
+                        if (dict.ContainsKey("mapname"))
+                        {
+                            UpdateMap(dict["mapname"]);
+                        }
                     }
 
                     if (E.GameTime.HasValue)
                     {
                         lastGameTime = E.GameTime.Value;
                     }
+
+                    MatchStartTime = DateTime.Now;
                 }
 
                 else if (E.Type == GameEvent.EventType.MapEnd)
@@ -704,6 +749,8 @@ namespace IW4MAdmin
                     {
                         lastGameTime = E.GameTime.Value;
                     }
+
+                    MatchEndTime = DateTime.Now;
                 }
 
                 else if (E.Type == GameEvent.EventType.Tell)
@@ -723,6 +770,34 @@ namespace IW4MAdmin
                 {
                     E.Origin.UpdateTeam(E.Extra as string);
                 }
+                
+                else if (E.Type == GameEvent.EventType.MetaUpdated)
+                {
+                    if (E.Extra is "PersistentClientGuid")
+                    {
+                        var parts = E.Data.Split(",");
+
+                        if (parts.Length == 2 && int.TryParse(parts[0], out var high) &&
+                            int.TryParse(parts[1], out var low))
+                        {
+                            var guid = long.Parse(high.ToString("X") + low.ToString("X"), NumberStyles.HexNumber);
+
+                            var penalties = await Manager.GetPenaltyService()
+                                .GetActivePenaltiesByIdentifier(null, guid, (Reference.Game)GameName);
+                            var banPenalty =
+                                penalties.FirstOrDefault(penalty => penalty.Type == EFPenalty.PenaltyType.Ban);
+
+                            if (banPenalty is not null && E.Origin.Level != Permission.Banned)
+                            {
+                                ServerLogger.LogInformation(
+                                    "Banning {Client} as they have have provided a persistent clientId of {PersistentClientId}, which is banned",
+                                    E.Origin.ToString(), guid);
+                                E.Origin.Ban(loc["SERVER_BAN_EVADE"].FormatExt(guid),
+                                    Utilities.IW4MAdminClient(this), true);
+                            }
+                        }
+                    }
+                }
 
                 lock (ChatHistory)
                 {
@@ -745,7 +820,7 @@ namespace IW4MAdmin
 
         private async Task OnClientUpdate(EFClient origin)
         {
-            var client = Manager.GetActiveClients().FirstOrDefault(c => c.NetworkId == origin.NetworkId);
+            var client = GetClientsAsList().FirstOrDefault(c => c.NetworkId == origin.NetworkId);
 
             if (client == null)
             {
@@ -790,10 +865,22 @@ namespace IW4MAdmin
         /// array index 2 = updated clients
         /// </summary>
         /// <returns></returns>
-        async Task<List<EFClient>[]> PollPlayersAsync()
+        async Task<List<EFClient>[]> PollPlayersAsync(CancellationToken token)
         {
+            if (DateTime.Now - (MatchEndTime ?? MatchStartTime) < TimeSpan.FromSeconds(15))
+            {
+                ServerLogger.LogDebug("Skipping status poll attempt because the match ended recently");
+                return null;
+            }
+ 
             var currentClients = GetClientsAsList();
-            var statusResponse = await this.GetStatusAsync(Manager.CancellationToken);
+            var statusResponse = await this.GetStatusAsync(token);
+
+            if (statusResponse is null)
+            {
+                return null;
+            }
+
             var polledClients = statusResponse.Clients.AsEnumerable();
 
             if (Manager.GetApplicationSettings().Configuration().IgnoreBots)
@@ -910,11 +997,11 @@ namespace IW4MAdmin
         private DateTime _lastMessageSent = DateTime.Now;
         private DateTime _lastPlayerCount = DateTime.Now;
 
-        public override async Task<bool> ProcessUpdatesAsync(CancellationToken cts)
+        public override async Task<bool> ProcessUpdatesAsync(CancellationToken token)
         {
             try
             {
-                if (cts.IsCancellationRequested)
+                if (token.IsCancellationRequested)
                 {
                     await ShutdownInternal();
                     return true;
@@ -928,13 +1015,18 @@ namespace IW4MAdmin
                         return true;
                     }
 
-                    var polledClients = await PollPlayersAsync();
+                    var polledClients = await PollPlayersAsync(token);
+
+                    if (polledClients is null)
+                    {
+                        return true;
+                    }
 
                     foreach (var disconnectingClient in polledClients[1]
                                  .Where(client => !client.IsZombieClient /* ignores "fake" zombie clients */))
                     {
                         disconnectingClient.CurrentServer = this;
-                        var e = new GameEvent()
+                        var e = new GameEvent
                         {
                             Type = GameEvent.EventType.PreDisconnect,
                             Origin = disconnectingClient,
@@ -951,7 +1043,7 @@ namespace IW4MAdmin
                                  !string.IsNullOrEmpty(client.Name) && (client.Ping != 999 || client.IsBot)))
                     {
                         client.CurrentServer = this;
-                        client.GameName = (Reference.Game?)GameName;
+                        client.GameName = (Reference.Game)GameName;
                         
                         var e = new GameEvent
                         {
@@ -1216,28 +1308,17 @@ namespace IW4MAdmin
             this.GamePassword = gamePassword.Value;
             UpdateMap(mapname);
 
-            if (RconParser.CanGenerateLogPath)
+            if (RconParser.CanGenerateLogPath && string.IsNullOrEmpty(ServerConfig.ManualLogPath))
             {
-                bool needsRestart = false;
-
                 if (logsync.Value == 0)
                 {
                     await this.SetDvarAsync("g_logsync", 2, Manager.CancellationToken); // set to 2 for continous in other games, clamps to 1 for IW4
-                    needsRestart = true;
                 }
 
                 if (string.IsNullOrWhiteSpace(logfile.Value))
                 {
                     logfile.Value = "games_mp.log";
                     await this.SetDvarAsync("g_log", logfile.Value, Manager.CancellationToken);
-                    needsRestart = true;
-                }
-
-                if (needsRestart)
-                {  
-                    // disabling this for the time being
-                    /*Logger.WriteWarning("Game log file not properly initialized, restarting map...");
-                    await this.ExecuteCommandAsync("map_restart");*/ 
                 }
 
                 // this DVAR isn't set until the a map is loaded
@@ -1443,6 +1524,11 @@ namespace IW4MAdmin
 
             ServerLogger.LogDebug("Creating tempban penalty for {TargetClient}", targetClient.ToString());
             await newPenalty.TryCreatePenalty(Manager.GetPenaltyService(), ServerLogger);
+            
+            foreach (var reports in Manager.GetServers().Select(server => server.Reports))
+            {
+                reports.RemoveAll(report => report.Target.ClientId == targetClient.ClientId);
+            }
 
             if (activeClient.IsIngame)
             {
@@ -1473,6 +1559,11 @@ namespace IW4MAdmin
             activeClient.SetLevel(Permission.Banned, originClient);
             await newPenalty.TryCreatePenalty(Manager.GetPenaltyService(), ServerLogger);
 
+            foreach (var reports in Manager.GetServers().Select(server => server.Reports))
+            {
+                reports.RemoveAll(report => report.Target.ClientId == targetClient.ClientId);
+            }
+
             if (activeClient.IsIngame)
             {
                 ServerLogger.LogDebug("Attempting to kicking newly banned client {ActiveClient}", activeClient.ToString());
@@ -1501,7 +1592,7 @@ namespace IW4MAdmin
             ServerLogger.LogDebug("Creating unban penalty for {targetClient}", targetClient.ToString());
             targetClient.SetLevel(Permission.User, originClient);
             await Manager.GetPenaltyService().RemoveActivePenalties(targetClient.AliasLink.AliasLinkId,
-                targetClient.NetworkId, targetClient.CurrentAlias?.IPAddress);
+                targetClient.NetworkId, targetClient.GameName, targetClient.CurrentAlias?.IPAddress);
             await Manager.GetPenaltyService().Create(unbanPenalty);
         }
 

Application/Main.cs

@@ -27,6 +27,7 @@ using System.Threading.Tasks;
 using Data.Abstractions;
 using Data.Helpers;
 using Integrations.Source.Extensions;
+using IW4MAdmin.Application.Alerts;
 using IW4MAdmin.Application.Extensions;
 using IW4MAdmin.Application.Localization;
 using Microsoft.Extensions.Logging;
@@ -448,7 +449,10 @@ namespace IW4MAdmin.Application
                 .AddSingleton<IServerDataCollector, ServerDataCollector>()
                 .AddSingleton<IEventPublisher, EventPublisher>()
                 .AddSingleton<IGeoLocationService>(new GeoLocationService(Path.Join(".", "Resources", "GeoLite2-Country.mmdb")))
+                .AddSingleton<IAlertManager, AlertManager>()
                 .AddTransient<IScriptPluginTimerHelper, ScriptPluginTimerHelper>()
+                .AddSingleton<IInteractionRegistration, InteractionRegistration>()
+                .AddSingleton<IRemoteCommandService, RemoteCommandService>()
                 .AddSingleton(translationLookup)
                 .AddDatabaseContextOptions(appConfig);
 

Application/Meta/PermissionLevelChangedResourceQueryHelper.cs

@@ -27,7 +27,8 @@ public class
         await using var context = _contextFactory.CreateContext();
 
         var auditEntries = context.EFChangeHistory.Where(change => change.TargetEntityId == query.ClientId)
-            .Where(change => change.TypeOfChange == EFChangeHistory.ChangeType.Permission);
+            .Where(change => change.TypeOfChange == EFChangeHistory.ChangeType.Permission)
+            .OrderByDescending(change => change.TimeChanged);
 
         var audits = from change in auditEntries
             join client in context.Clients

Application/Misc/AsyncResult.cs

@@ -0,0 +1,12 @@
+using System;
+using System.Threading;
+
+namespace IW4MAdmin.Application.Misc;
+
+public class AsyncResult : IAsyncResult
+{
+    public object AsyncState { get; set; }
+    public WaitHandle AsyncWaitHandle { get; set; }
+    public bool CompletedSynchronously { get; set; }
+    public bool IsCompleted { get; set; }
+}

Application/Misc/ClientNoticeMessageFormatter.cs

@@ -33,7 +33,7 @@ namespace IW4MAdmin.Application.Misc
             builder.Append(header);
             builder.Append(config.NoticeLineSeparator);
             // build the reason
-            var reason = _transLookup["GAME_MESSAGE_PENALTY_REASON"].FormatExt(penalty.Offense);
+            var reason = _transLookup["GAME_MESSAGE_PENALTY_REASON"].FormatExt(penalty.Offense.FormatMessageForEngine(config));
 
             if (isNewLineSeparator)
             {
@@ -117,4 +117,4 @@ namespace IW4MAdmin.Application.Misc
             return segments;
         }
     }
-}
+}

Application/Misc/EventPublisher.cs

@@ -10,6 +10,7 @@ namespace IW4MAdmin.Application.Misc
     {
         public event EventHandler<GameEvent> OnClientDisconnect;
         public event EventHandler<GameEvent> OnClientConnect;
+        public event EventHandler<GameEvent> OnClientMetaUpdated;
 
         private readonly ILogger _logger;
 
@@ -29,10 +30,15 @@ namespace IW4MAdmin.Application.Misc
                     OnClientConnect?.Invoke(this, gameEvent);
                 }
 
-                if (gameEvent.Type == GameEvent.EventType.Disconnect)
+                if (gameEvent.Type == GameEvent.EventType.Disconnect && gameEvent.Origin.ClientId != 0)
                 {
                     OnClientDisconnect?.Invoke(this, gameEvent);
                 }
+
+                if (gameEvent.Type == GameEvent.EventType.MetaUpdated)
+                {
+                    OnClientMetaUpdated?.Invoke(this, gameEvent);
+                }
             }
 
             catch (Exception ex)
@@ -41,4 +47,4 @@ namespace IW4MAdmin.Application.Misc
             }
         }
     }
-}
+}

Application/Misc/InteractionRegistration.cs

@@ -0,0 +1,157 @@
+using System;
+using System.Collections.Concurrent;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
+using Data.Models;
+using Microsoft.Extensions.DependencyInjection;
+using Microsoft.Extensions.Logging;
+using SharedLibraryCore.Interfaces;
+using InteractionRegistrationCallback =
+    System.Func<int?, Data.Models.Reference.Game?, System.Threading.CancellationToken,
+        System.Threading.Tasks.Task<SharedLibraryCore.Interfaces.IInteractionData>>;
+
+namespace IW4MAdmin.Application.Misc;
+
+public class InteractionRegistration : IInteractionRegistration
+{
+    private readonly ILogger<InteractionRegistration> _logger;
+    private readonly IServiceProvider _serviceProvider;
+    private readonly ConcurrentDictionary<string, InteractionRegistrationCallback> _interactions = new();
+
+    public InteractionRegistration(ILogger<InteractionRegistration> logger, IServiceProvider serviceProvider)
+    {
+        _logger = logger;
+        _serviceProvider = serviceProvider;
+    }
+
+    public void RegisterScriptInteraction(string interactionName, string source, Delegate interactionRegistration)
+    {
+        if (string.IsNullOrWhiteSpace(source))
+        {
+            throw new ArgumentException("Script interaction source cannot be null");
+        }
+        
+        _logger.LogDebug("Registering script interaction {InteractionName} from {Source}", interactionName, source);
+        
+        var plugin = _serviceProvider.GetRequiredService<IEnumerable<IPlugin>>()
+            .FirstOrDefault(plugin => plugin.Name == source);
+
+        if (plugin is not ScriptPlugin scriptPlugin)
+        {
+            return;
+        }
+
+        Task<IInteractionData> WrappedDelegate(int? clientId, Reference.Game? game, CancellationToken token) =>
+            Task.FromResult(
+                scriptPlugin.WrapDelegate<IInteractionData>(interactionRegistration, token, clientId, game, token));
+
+        if (!_interactions.ContainsKey(interactionName))
+        {
+            _interactions.TryAdd(interactionName, WrappedDelegate);
+        }
+        else
+        {
+            _interactions[interactionName] = WrappedDelegate;
+        }
+    }
+
+    public void RegisterInteraction(string interactionName, InteractionRegistrationCallback interactionRegistration)
+    {
+        if (!_interactions.ContainsKey(interactionName))
+        {
+            _logger.LogDebug("Registering interaction {InteractionName}", interactionName);
+            _interactions.TryAdd(interactionName, interactionRegistration);
+        }
+        else
+        {
+            _logger.LogDebug("Updating interaction {InteractionName}", interactionName);
+            _interactions[interactionName] = interactionRegistration;
+        }
+    }
+
+    public void UnregisterInteraction(string interactionName)
+    {
+        if (!_interactions.ContainsKey(interactionName))
+        {
+            return;
+        }
+
+        _logger.LogDebug("Unregistering interaction {InteractionName}", interactionName);
+        _interactions.TryRemove(interactionName, out _);
+    }
+
+    public async Task<IEnumerable<IInteractionData>> GetInteractions(string interactionPrefix = null,
+        int? clientId = null,
+        Reference.Game? game = null, CancellationToken token = default)
+    {
+        return await GetInteractionsInternal(interactionPrefix, clientId, game, token);
+    }
+
+    public async Task<string> ProcessInteraction(string interactionId, int originId, int? targetId = null,
+        Reference.Game? game = null, IDictionary<string, string> meta = null, CancellationToken token = default)
+    {
+        if (!_interactions.ContainsKey(interactionId))
+        {
+            throw new ArgumentException($"Interaction with ID {interactionId} has not been registered");
+        }
+
+        try
+        {
+            var interaction = await _interactions[interactionId](targetId, game, token);
+
+            if (interaction.Action is not null)
+            {
+                return await interaction.Action(originId, targetId, game, meta, token);
+            }
+
+            if (interaction.ScriptAction is not null)
+            {
+                foreach (var plugin in _serviceProvider.GetRequiredService<IEnumerable<IPlugin>>())
+                {
+                    if (plugin is not ScriptPlugin scriptPlugin || scriptPlugin.Name != interaction.Source)
+                    {
+                        continue;
+                    }
+
+                    return scriptPlugin.ExecuteAction<string>(interaction.ScriptAction, token, originId, targetId, game, meta,
+                        token);
+                }
+            }
+        }
+        catch (Exception ex)
+        {
+            _logger.LogWarning(ex,
+                "Could not process interaction for {InteractionName} and OriginId {ClientId}",
+                interactionId, originId);
+        }
+
+        return null;
+    }
+
+    private async Task<IEnumerable<IInteractionData>> GetInteractionsInternal(string prefix = null, int? clientId = null,
+        Reference.Game? game = null, CancellationToken token = default)
+    {
+        var interactions = _interactions
+            .Where(interaction => string.IsNullOrWhiteSpace(prefix) || interaction.Key.StartsWith(prefix)).Select(
+                async kvp =>
+                {
+                    try
+                    {
+                        return await kvp.Value(clientId, game, token);
+                    }
+                    catch (Exception ex)
+                    {
+                        _logger.LogWarning(ex,
+                            "Could not get interaction for {InteractionName} and ClientId {ClientId}",
+                            kvp.Key,
+                            clientId);
+                        return null;
+                    }
+                }).Where(interaction => interaction is not null)
+            .ToList();
+
+        return await Task.WhenAll(interactions);
+    }
+}

Application/Misc/MetaServiceV2.cs

@@ -7,7 +7,10 @@ using System.Threading.Tasks;
 using Data.Abstractions;
 using Data.Models;
 using Microsoft.EntityFrameworkCore;
+using Microsoft.Extensions.DependencyInjection;
 using Microsoft.Extensions.Logging;
+using SharedLibraryCore;
+using SharedLibraryCore.Database.Models;
 using SharedLibraryCore.Dtos;
 using SharedLibraryCore.Interfaces;
 using SharedLibraryCore.QueryHelper;
@@ -19,13 +22,15 @@ public class MetaServiceV2 : IMetaServiceV2
 {
     private readonly IDictionary<MetaType, List<dynamic>> _metaActions;
     private readonly IDatabaseContextFactory _contextFactory;
+    private readonly IServiceProvider _serviceProvider;
     private readonly ILogger _logger;
 
-    public MetaServiceV2(ILogger<MetaServiceV2> logger, IDatabaseContextFactory contextFactory)
+    public MetaServiceV2(ILogger<MetaServiceV2> logger, IDatabaseContextFactory contextFactory, IServiceProvider serviceProvider)
     {
         _logger = logger;
         _metaActions = new Dictionary<MetaType, List<dynamic>>();
         _contextFactory = contextFactory;
+        _serviceProvider = serviceProvider;
     }
 
     public async Task SetPersistentMeta(string metaKey, string metaValue, int clientId,
@@ -64,6 +69,26 @@ public class MetaServiceV2 : IMetaServiceV2
         }
 
         await context.SaveChangesAsync(token);
+            
+            
+        var manager = _serviceProvider.GetRequiredService<IManager>();
+        var matchingClient = manager.GetActiveClients().FirstOrDefault(client => client.ClientId == clientId);
+        var server = matchingClient?.CurrentServer ?? manager.GetServers().FirstOrDefault();
+
+        if (server is not null)
+        {
+            manager.AddEvent(new GameEvent
+            {
+                Type = GameEvent.EventType.MetaUpdated,
+                Origin = matchingClient ?? new EFClient
+                {
+                    ClientId = clientId
+                },
+                Data = metaValue,
+                Extra = metaKey,
+                Owner = server
+            });
+        }
     }
 
     public async Task SetPersistentMetaValue<T>(string metaKey, T metaValue, int clientId,

Application/Misc/RemoteCommandService.cs

@@ -0,0 +1,99 @@
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading.Tasks;
+using Microsoft.Extensions.Logging;
+using SharedLibraryCore;
+using SharedLibraryCore.Configuration;
+using SharedLibraryCore.Dtos;
+using SharedLibraryCore.Interfaces;
+using SharedLibraryCore.Services;
+using ILogger = Microsoft.Extensions.Logging.ILogger;
+
+namespace IW4MAdmin.Application.Misc;
+
+public class RemoteCommandService : IRemoteCommandService
+{
+    private readonly ILogger _logger;
+    private readonly ApplicationConfiguration _appConfig;
+    private readonly ClientService _clientService;
+
+    public RemoteCommandService(ILogger<RemoteCommandService> logger, ApplicationConfiguration appConfig, ClientService clientService)
+    {
+        _logger = logger;
+        _appConfig = appConfig;
+        _clientService = clientService;
+    }
+
+    public async Task<IEnumerable<CommandResponseInfo>> Execute(int originId, int? targetId, string command,
+        IEnumerable<string> arguments, Server server)
+    {
+        if (originId < 1)
+        {
+            _logger.LogWarning("Not executing command {Command} for {Originid} because origin id is invalid", command,
+                originId);
+            return Enumerable.Empty<CommandResponseInfo>();
+        }
+        
+        var client = await _clientService.Get(originId);
+        client.CurrentServer = server;
+
+        command += $" {(targetId.HasValue ? $"@{targetId} " : "")}{string.Join(" ", arguments ?? Enumerable.Empty<string>())}";
+
+        var remoteEvent = new GameEvent
+        {
+            Type = GameEvent.EventType.Command,
+            Data = command.StartsWith(_appConfig.CommandPrefix) ||
+                   command.StartsWith(_appConfig.BroadcastCommandPrefix)
+                ? command
+                : $"{_appConfig.CommandPrefix}{command}",
+            Origin = client,
+            Owner = server,
+            IsRemote = true
+        };
+
+        server.Manager.AddEvent(remoteEvent);
+        CommandResponseInfo[] response;
+
+        try
+        {
+            // wait for the event to process
+            var completedEvent =
+                await remoteEvent.WaitAsync(Utilities.DefaultCommandTimeout, server.Manager.CancellationToken);
+
+            if (completedEvent.FailReason == GameEvent.EventFailReason.Timeout)
+            {
+                response = new[]
+                {
+                    new CommandResponseInfo()
+                    {
+                        ClientId = client.ClientId,
+                        Response = Utilities.CurrentLocalization.LocalizationIndex["SERVER_ERROR_COMMAND_TIMEOUT"]
+                    }
+                };
+            }
+
+            else
+            {
+                response = completedEvent.Output.Select(output => new CommandResponseInfo()
+                {
+                    Response = output,
+                    ClientId = client.ClientId
+                }).ToArray();
+            }
+        }
+
+        catch (System.OperationCanceledException)
+        {
+            response = new[]
+            {
+                new CommandResponseInfo
+                {
+                    ClientId = client.ClientId,
+                    Response = Utilities.CurrentLocalization.LocalizationIndex["COMMANDS_RESTART_SUCCESS"]
+                }
+            };
+        }
+
+        return response;
+    }
+}

Application/Misc/ScriptPlugin.cs

@@ -10,9 +10,11 @@ using SharedLibraryCore.Interfaces;
 using System.Collections.Generic;
 using System.IO;
 using System.Linq;
+using System.Runtime.CompilerServices;
 using System.Text;
 using System.Threading;
 using System.Threading.Tasks;
+using IW4MAdmin.Application.Extensions;
 using Jint.Runtime.Interop;
 using Microsoft.Extensions.Logging;
 using Serilog.Context;
@@ -53,7 +55,7 @@ namespace IW4MAdmin.Application.Misc
             Watcher = new FileSystemWatcher
             {
                 Path = workingDirectory ?? $"{Utilities.OperatingDirectory}Plugins{Path.DirectorySeparatorChar}",
-                NotifyFilter = NotifyFilters.Size,
+                NotifyFilter = NotifyFilters.LastWrite,
                 Filter = _fileName.Split(Path.DirectorySeparatorChar).Last()
             };
 
@@ -111,12 +113,17 @@ namespace IW4MAdmin.Application.Misc
                 }
 
                 _scriptEngine = new Engine(cfg =>
-                    cfg.AllowClr(new[]
+                    cfg.AddExtensionMethods(typeof(Utilities), typeof(Enumerable), typeof(Queryable),
+                            typeof(ScriptPluginExtensions))
+                        .AllowClr(new[]
                         {
                             typeof(System.Net.Http.HttpClient).Assembly,
                             typeof(EFClient).Assembly,
                             typeof(Utilities).Assembly,
-                            typeof(Encoding).Assembly
+                            typeof(Encoding).Assembly,
+                            typeof(CancellationTokenSource).Assembly,
+                            typeof(Data.Models.Client.EFClient).Assembly,
+                            typeof(IW4MAdmin.Plugins.Stats.Plugin).Assembly
                         })
                         .CatchClrExceptions()
                         .AddObjectConverter(new PermissionLevelToStringConverter()));
@@ -160,11 +167,19 @@ namespace IW4MAdmin.Application.Misc
                     }
                 }
 
+                async Task<bool> OnLoadTask()
+                {
+                    await OnLoadAsync(manager);
+                    return true;
+                }
+
+                var loadComplete = false;
+                
                 try
                 {
                     if (pluginObject.isParser)
                     {
-                        await OnLoadAsync(manager);
+                        loadComplete = await OnLoadTask();
                         IsParser = true;
                         var eventParser = (IEventParser)_scriptEngine.Evaluate("eventParser").ToObject();
                         var rconParser = (IRConParser)_scriptEngine.Evaluate("rconParser").ToObject();
@@ -177,30 +192,34 @@ namespace IW4MAdmin.Application.Misc
                 {
                     var configWrapper = new ScriptPluginConfigurationWrapper(Name, _scriptEngine);
                     await configWrapper.InitializeAsync();
-                    _scriptEngine.SetValue("_configHandler", configWrapper);
-                    await OnLoadAsync(manager);
+
+                    if (!loadComplete)
+                    {
+                        _scriptEngine.SetValue("_configHandler", configWrapper);
+                        loadComplete = await OnLoadTask();
+                    }
                 }
 
-                if (!firstRun)
+                if (!firstRun && !loadComplete)
                 {
-                    await OnLoadAsync(manager);
+                    loadComplete = await OnLoadTask();
                 }
 
-                _successfullyLoaded = true;
+                _successfullyLoaded = loadComplete;
             }
             catch (JavaScriptException ex)
             {
                 _logger.LogError(ex,
-                    "Encountered JavaScript runtime error while executing {MethodName} for script plugin {Plugin} at {@LocationInfo}",
-                    nameof(Initialize), Path.GetFileName(_fileName), ex.Location);
+                    "Encountered JavaScript runtime error while executing {MethodName} for script plugin {Plugin} at {@LocationInfo} StackTrace={StackTrace}",
+                    nameof(Initialize), Path.GetFileName(_fileName), ex.Location, ex.JavaScriptStackTrace);
 
                 throw new PluginException("An error occured while initializing script plugin");
             }
             catch (Exception ex) when (ex.InnerException is JavaScriptException jsEx)
             {
                 _logger.LogError(ex,
-                    "Encountered JavaScript runtime error while executing {MethodName} for script plugin {Plugin} initialization {@LocationInfo}",
-                    nameof(Initialize), _fileName, jsEx.Location);
+                    "Encountered JavaScript runtime error while executing {MethodName} for script plugin {Plugin} initialization {@LocationInfo} StackTrace={StackTrace}",
+                    nameof(Initialize), _fileName, jsEx.Location, jsEx.JavaScriptStackTrace);
 
                 throw new PluginException("An error occured while initializing script plugin");
             }
@@ -231,36 +250,65 @@ namespace IW4MAdmin.Application.Misc
             try
             {
                 await _onProcessing.WaitAsync();
-                _scriptEngine.SetValue("_gameEvent", gameEvent);
+                WrapJavaScriptErrorHandling(() =>
+                {
+                    _scriptEngine.SetValue("_gameEvent", gameEvent);
+                    _scriptEngine.SetValue("_server", server);
+                    _scriptEngine.SetValue("_IW4MAdminClient", Utilities.IW4MAdminClient(server));
+                    return _scriptEngine.Evaluate("plugin.onEventAsync(_gameEvent, _server)");
+                }, new { EventType = gameEvent.Type }, server);
+            }
+            finally
+            {
+                if (_onProcessing.CurrentCount == 0)
+                {
+                    _onProcessing.Release(1);
+                }
+            }
+            
+        }
+
+        public  Task OnLoadAsync(IManager manager)
+        {
+            _logger.LogDebug("OnLoad executing for {Name}", Name);
+
+            WrapJavaScriptErrorHandling(() =>
+            {
+                _scriptEngine.SetValue("_manager", manager);
+                _scriptEngine.SetValue("getDvar", BeginGetDvar);
+                _scriptEngine.SetValue("setDvar", BeginSetDvar);
+                return _scriptEngine.Evaluate("plugin.onLoadAsync(_manager)");
+            });
+
+            return Task.CompletedTask;
+        }
+
+        public Task OnTickAsync(Server server)
+        {
+            WrapJavaScriptErrorHandling(() =>
+            {
                 _scriptEngine.SetValue("_server", server);
-                _scriptEngine.SetValue("_IW4MAdminClient", Utilities.IW4MAdminClient(server));
-                _scriptEngine.Evaluate("plugin.onEventAsync(_gameEvent, _server)");
-            }
+                return _scriptEngine.Evaluate("plugin.onTickAsync(_server)");
+            });
 
-            catch (JavaScriptException ex)
+            return Task.CompletedTask;
+        }
+
+        public async Task OnUnloadAsync()
+        {
+            if (!_successfullyLoaded)
             {
-                using (LogContext.PushProperty("Server", server.ToString()))
-                {
-                    _logger.LogError(ex,
-                        "Encountered JavaScript runtime error while executing {MethodName} for script plugin {Plugin} with event type {EventType} {@LocationInfo}",
-                        nameof(OnEventAsync), Path.GetFileName(_fileName), gameEvent.Type, ex.Location);
-                }
-
-                throw new PluginException("An error occured while executing action for script plugin");
+                return;
             }
 
-            catch (Exception ex)
+            try
             {
-                using (LogContext.PushProperty("Server", server.ToString()))
-                {
-                    _logger.LogError(ex,
-                        "Encountered error while running {MethodName} for script plugin {Plugin} with event type {EventType}",
-                        nameof(OnEventAsync), _fileName, gameEvent.Type);
-                }
+                await _onProcessing.WaitAsync();
 
-                throw new PluginException("An error occured while executing action for script plugin");
+                _logger.LogDebug("OnUnload executing for {Name}", Name);
+
+                WrapJavaScriptErrorHandling(() => _scriptEngine.Evaluate("plugin.onUnloadAsync()"));
             }
-
             finally
             {
                 if (_onProcessing.CurrentCount == 0)
@@ -270,71 +318,66 @@ namespace IW4MAdmin.Application.Misc
             }
         }
 
-        public Task OnLoadAsync(IManager manager)
+        public T ExecuteAction<T>(Delegate action, CancellationToken token, params object[] param)
         {
             try
             {
-                _logger.LogDebug("OnLoad executing for {Name}", Name);
-                _scriptEngine.SetValue("_manager", manager);
-                _scriptEngine.SetValue("getDvar", GetDvarAsync);
-                _scriptEngine.SetValue("setDvar", SetDvarAsync);
-                _scriptEngine.Evaluate("plugin.onLoadAsync(_manager)");
-
-                return Task.CompletedTask;
+                using var forceTimeout = new CancellationTokenSource(5000);
+                using var combined = CancellationTokenSource.CreateLinkedTokenSource(forceTimeout.Token, token);
+                _onProcessing.Wait(combined.Token);
+                
+                _logger.LogDebug("Executing action for {Name}", Name);
+                
+                return WrapJavaScriptErrorHandling(T() =>
+                    {
+                        var args = param.Select(p => JsValue.FromObject(_scriptEngine, p)).ToArray();
+                        var result = action.DynamicInvoke(JsValue.Undefined, args);
+                        return (T)(result as JsValue)?.ToObject();
+                    },
+         new
+                    {
+                        Params = string.Join(", ",
+                            param?.Select(eachParam => $"Type={eachParam?.GetType().Name} Value={eachParam}") ??
+                            Enumerable.Empty<string>())
+                    });
             }
-            catch (JavaScriptException ex)
+            finally
             {
-                _logger.LogError(ex,
-                    "Encountered JavaScript runtime error while executing {MethodName} for script plugin {Plugin} at {@LocationInfo}",
-                    nameof(OnLoadAsync), Path.GetFileName(_fileName), ex.Location);
-
-                throw new PluginException("A runtime error occured while executing action for script plugin");
-            }
-            catch (Exception ex)
-            {
-                _logger.LogError(ex,
-                    "Encountered JavaScript runtime error while executing {MethodName} for script plugin {Plugin}",
-                    nameof(OnLoadAsync), Path.GetFileName(_fileName));
-
-                throw new PluginException("An error occured while executing action for script plugin");
+                if (_onProcessing.CurrentCount == 0)
+                {
+                    _onProcessing.Release(1);
+                }
             }
         }
 
-        public async Task OnTickAsync(Server server)
+        public T WrapDelegate<T>(Delegate act, CancellationToken token, params object[] args)
         {
-            _scriptEngine.SetValue("_server", server);
-            await Task.FromResult(_scriptEngine.Evaluate("plugin.onTickAsync(_server)"));
-        }
-
-        public Task OnUnloadAsync()
-        {
-            if (!_successfullyLoaded)
-            {
-                return Task.CompletedTask;
-            }
-
             try
             {
-                _scriptEngine.Evaluate("plugin.onUnloadAsync()");
+                using var forceTimeout = new CancellationTokenSource(5000);
+                using var combined = CancellationTokenSource.CreateLinkedTokenSource(forceTimeout.Token, token);
+                _onProcessing.Wait(combined.Token);
+
+                _logger.LogDebug("Wrapping delegate action for {Name}", Name);
+
+                return WrapJavaScriptErrorHandling(
+                    T() => (T)(act.DynamicInvoke(JsValue.Null,
+                            args.Select(arg => JsValue.FromObject(_scriptEngine, arg)).ToArray()) as ObjectWrapper)
+                        ?.ToObject(),
+                    new
+                    {
+                        Params = string.Join(", ",
+                            args?.Select(eachParam => $"Type={eachParam?.GetType().Name} Value={eachParam}") ??
+                            Enumerable.Empty<string>())
+                    });
             }
-            catch (JavaScriptException ex)
+            finally
             {
-                _logger.LogError(ex,
-                    "Encountered JavaScript runtime error while executing {MethodName} for script plugin {Plugin} at {@LocationInfo}",
-                    nameof(OnUnloadAsync), Path.GetFileName(_fileName), ex.Location);
-
-                throw new PluginException("A runtime error occured while executing action for script plugin");
+                if (_onProcessing.CurrentCount == 0)
+                {
+                    _onProcessing.Release(1);
+                }
             }
-            catch (Exception ex)
-            {
-                _logger.LogError(ex,
-                    "Encountered JavaScript runtime error while executing {MethodName} for script plugin {Plugin}",
-                    nameof(OnUnloadAsync), Path.GetFileName(_fileName));
-
-                throw new PluginException("An error occured while executing action for script plugin");
-            }
-
-            return Task.CompletedTask;
         }
 
         /// <summary>
@@ -343,7 +386,8 @@ namespace IW4MAdmin.Application.Misc
         /// <param name="commands">commands value from jint parser</param>
         /// <param name="scriptCommandFactory">factory to create the command from</param>
         /// <returns></returns>
-        private IEnumerable<IManagerCommand> GenerateScriptCommands(JsValue commands, IScriptCommandFactory scriptCommandFactory)
+        private IEnumerable<IManagerCommand> GenerateScriptCommands(JsValue commands,
+            IScriptCommandFactory scriptCommandFactory)
         {
             var commandList = new List<IManagerCommand>();
 
@@ -354,6 +398,12 @@ namespace IW4MAdmin.Application.Misc
                 string name = dynamicCommand.name;
                 string alias = dynamicCommand.alias;
                 string description = dynamicCommand.description;
+
+                if (dynamicCommand.permission is Data.Models.Client.EFClient.Permission perm)
+                {
+                    dynamicCommand.permission = perm.ToString();
+                }
+
                 string permission = dynamicCommand.permission;
                 List<Server.Game> supportedGames = null;
                 var targetRequired = false;
@@ -410,7 +460,7 @@ namespace IW4MAdmin.Application.Misc
 
                         _scriptEngine.SetValue("_event", gameEvent);
                         var jsEventObject = _scriptEngine.Evaluate("_event");
-                        
+
                         dynamicCommand.execute.Target.Invoke(_scriptEngine, jsEventObject);
                     }
 
@@ -424,7 +474,7 @@ namespace IW4MAdmin.Application.Misc
 
                         throw new PluginException("A runtime error occured while executing action for script plugin");
                     }
-                    
+
                     catch (Exception ex)
                     {
                         using (LogContext.PushProperty("Server", gameEvent.Owner?.ToString()))
@@ -437,7 +487,6 @@ namespace IW4MAdmin.Application.Misc
                         throw new PluginException("An error occured while executing action for script plugin");
                     }
 
-
                     finally
                     {
                         if (_onProcessing.CurrentCount == 0)
@@ -454,83 +503,203 @@ namespace IW4MAdmin.Application.Misc
             return commandList;
         }
 
-        private void GetDvarAsync(Server server, string dvarName, Delegate onCompleted)
+        private void BeginGetDvar(Server server, string dvarName, Delegate onCompleted)
         {
-            Task.Run(() =>
+            var operationTimeout = TimeSpan.FromSeconds(5);
+
+            void OnComplete(IAsyncResult result)
             {
-                var tokenSource = new CancellationTokenSource();
-                tokenSource.CancelAfter(TimeSpan.FromSeconds(5));
-                string result = null;
-                var success = true;
                 try
                 {
-                    result = server.GetDvarAsync<string>(dvarName, token: tokenSource.Token).GetAwaiter().GetResult().Value;
-                }
-                catch
-                {
-                    success = false;
-                }
+                    _onProcessing.Wait();
 
-                _onProcessing.Wait();
-                try
-                {
-                    onCompleted.DynamicInvoke(JsValue.Undefined,
-                        new[]
-                        {
-                            JsValue.FromObject(_scriptEngine, server), 
-                            JsValue.FromObject(_scriptEngine, dvarName),
-                            JsValue.FromObject(_scriptEngine, result),
-                            JsValue.FromObject(_scriptEngine, success), 
-                        });
-                }
-
-                finally
-                {
-                    if (_onProcessing.CurrentCount == 0)
-                    {
-                        _onProcessing.Release();
-                    }
-                }
-            });
-        }
-        private void SetDvarAsync(Server server, string dvarName, string dvarValue, Delegate onCompleted)
-        {
-            Task.Run(() =>
-            {
-                var tokenSource = new CancellationTokenSource();
-                tokenSource.CancelAfter(TimeSpan.FromSeconds(5));
-                var success = true;
-
-                try
-                {
-                    server.SetDvarAsync(dvarName, dvarValue, tokenSource.Token).GetAwaiter().GetResult();
-                }
-                catch
-                {
-                    success = false;
-                }
-
-                _onProcessing.Wait();
-                try
-                {
+                    var (success, value) = (ValueTuple<bool, string>)result.AsyncState;
                     onCompleted.DynamicInvoke(JsValue.Undefined,
                         new[]
                         {
                             JsValue.FromObject(_scriptEngine, server),
-                            JsValue.FromObject(_scriptEngine, dvarName), 
-                            JsValue.FromObject(_scriptEngine, dvarValue),
+                            JsValue.FromObject(_scriptEngine, dvarName),
+                            JsValue.FromObject(_scriptEngine, value),
                             JsValue.FromObject(_scriptEngine, success)
                         });
                 }
-
+                catch (JavaScriptException ex)
+                {
+                    using (LogContext.PushProperty("Server", server.ToString()))
+                    {
+                        _logger.LogError(ex, "Could not invoke BeginGetDvar callback for {Filename} {@Location}",
+                            Path.GetFileName(_fileName), ex.Location);
+                    }
+                }
+                catch (Exception ex)
+                {
+                    _logger.LogError(ex, "Could not complete {BeginGetDvar} for {Class}", nameof(BeginGetDvar), Name);
+                }
                 finally
                 {
                     if (_onProcessing.CurrentCount == 0)
                     {
-                        _onProcessing.Release();
+                        _onProcessing.Release(1);
                     }
                 }
-            });
+            }
+
+            new Thread(() =>
+            {
+                if (DateTime.Now - (server.MatchEndTime ?? server.MatchStartTime) < TimeSpan.FromSeconds(15))
+                {
+                    using (LogContext.PushProperty("Server", server.ToString()))
+                    {
+                        _logger.LogDebug("Not getting DVar because match recently ended");
+                    }
+
+                    OnComplete(new AsyncResult
+                    {
+                        IsCompleted = false,
+                        AsyncState = (false, (string)null)
+                    });
+                }
+
+                using var tokenSource = new CancellationTokenSource();
+                tokenSource.CancelAfter(operationTimeout);
+
+                server.GetDvarAsync<string>(dvarName, token: tokenSource.Token).ContinueWith(action =>
+                {
+                    if (action.IsCompletedSuccessfully)
+                    {
+                        OnComplete(new AsyncResult
+                        {
+                            IsCompleted = true,
+                            AsyncState = (true, action.Result.Value)
+                        });
+                    }
+                    else
+                    {
+                        OnComplete(new AsyncResult
+                        {
+                            IsCompleted = false,
+                            AsyncState = (false, (string)null)
+                        });
+                    }
+                });
+            }).Start();
+        }
+
+        private void BeginSetDvar(Server server, string dvarName, string dvarValue, Delegate onCompleted)
+        {
+            var operationTimeout = TimeSpan.FromSeconds(5);
+
+            void OnComplete(IAsyncResult result)
+            {
+                try
+                {
+                    _onProcessing.Wait();
+                    var success = (bool)result.AsyncState;
+                    onCompleted.DynamicInvoke(JsValue.Undefined,
+                        new[]
+                        {
+                            JsValue.FromObject(_scriptEngine, server),
+                            JsValue.FromObject(_scriptEngine, dvarName),
+                            JsValue.FromObject(_scriptEngine, dvarValue),
+                            JsValue.FromObject(_scriptEngine, success)
+                        });
+                }
+                catch (JavaScriptException ex)
+                {
+                    using (LogContext.PushProperty("Server", server.ToString()))
+                    {
+                        _logger.LogError(ex, "Could complete BeginSetDvar for {Filename} {@Location}",
+                            Path.GetFileName(_fileName), ex.Location);
+                    }
+                }
+                catch (Exception ex)
+                {
+                    _logger.LogError(ex, "Could not complete {BeginSetDvar} for {Class}", nameof(BeginSetDvar), Name);
+                }
+                finally
+                {
+                    if (_onProcessing.CurrentCount == 0)
+                    {
+                        _onProcessing.Release(1);
+                    }
+                }
+            }
+
+            new Thread(() =>
+            {
+                if (DateTime.Now - (server.MatchEndTime ?? server.MatchStartTime) < TimeSpan.FromSeconds(15))
+                {
+                    using (LogContext.PushProperty("Server", server.ToString()))
+                    {
+                        _logger.LogDebug("Not setting DVar because match recently ended");
+                    }
+
+                    OnComplete(new AsyncResult
+                    {
+                        IsCompleted = false,
+                        AsyncState = false
+                    });
+                }
+
+                using var tokenSource = new CancellationTokenSource();
+                tokenSource.CancelAfter(operationTimeout);
+
+                server.SetDvarAsync(dvarName, dvarValue, token: tokenSource.Token).ContinueWith(action =>
+                {
+                    if (action.IsCompletedSuccessfully)
+                    {
+                        OnComplete(new AsyncResult
+                        {
+                            IsCompleted = true,
+                            AsyncState = true
+                        });
+                    }
+                    else
+                    {
+                        OnComplete(new AsyncResult
+                        {
+                            IsCompleted = false,
+                            AsyncState = false
+                        });
+                    }
+                });
+            }).Start();
+        }
+
+        private T WrapJavaScriptErrorHandling<T>(Func<T> work, object additionalData = null, Server server = null,
+            [CallerMemberName] string methodName = "")
+        {
+            using (LogContext.PushProperty("Server", server?.ToString()))
+            {
+                try
+                {
+                    return work();
+                }
+                catch (JavaScriptException ex)
+                {
+                    _logger.LogError(ex,
+                        "Encountered JavaScript runtime error while executing {MethodName} for script plugin {Plugin} at {@LocationInfo} StackTrace={StackTrace} {@AdditionalData}",
+                        methodName, Path.GetFileName(_fileName), ex.Location, ex.StackTrace, additionalData);
+
+                    throw new PluginException("A runtime error occured while executing action for script plugin");
+                }
+                catch (Exception ex) when (ex.InnerException is JavaScriptException jsEx)
+                {
+                    _logger.LogError(ex,
+                        "Encountered JavaScript runtime error while executing {MethodName} for script plugin {Plugin} initialization {@LocationInfo} StackTrace={StackTrace} {@AdditionalData}",
+                        methodName, _fileName, jsEx.Location, jsEx.JavaScriptStackTrace, additionalData);
+
+                    throw new PluginException("A runtime error occured while executing action for script plugin");
+                }
+                catch (Exception ex)
+                {
+                    _logger.LogError(ex,
+                        "Encountered JavaScript runtime error while executing {MethodName} for script plugin {Plugin}",
+                        methodName, Path.GetFileName(_fileName));
+
+                    throw new PluginException("An error occured while executing action for script plugin");
+                }
+            }
         }
     }
 
@@ -544,7 +713,6 @@ namespace IW4MAdmin.Application.Misc
                 return true;
             }
 
-
             result = JsValue.Null;
             return false;
         }

Application/Misc/ScriptPluginTimerHelper.cs

@@ -14,10 +14,13 @@ public class ScriptPluginTimerHelper : IScriptPluginTimerHelper
     private Action _actions;
     private Delegate _jsAction;
     private string _actionName;
+    private int _interval = DefaultInterval;
+    private long _waitingCount;
     private const int DefaultDelay = 0;
     private const int DefaultInterval = 1000;
+    private const int MaxWaiting = 10;
     private readonly ILogger _logger;
-    private readonly ManualResetEventSlim _onRunningTick = new();
+    private readonly SemaphoreSlim _onRunningTick = new(1, 1);
     private SemaphoreSlim _onDependentAction;
 
     public ScriptPluginTimerHelper(ILogger<ScriptPluginTimerHelper> logger)
@@ -31,6 +34,7 @@ public class ScriptPluginTimerHelper : IScriptPluginTimerHelper
         {
             Stop();
         }
+
         _onRunningTick.Dispose();
     }
 
@@ -50,13 +54,13 @@ public class ScriptPluginTimerHelper : IScriptPluginTimerHelper
         {
             throw new ArgumentException("Timer interval must be at least 20ms");
         }
-        
+
         Stop();
-        
+
         _logger.LogDebug("Starting script timer...");
 
-        _onRunningTick.Set();
         _timer ??= new Timer(callback => _actions(), null, delay, interval);
+        _interval = interval;
         IsRunning = true;
     }
 
@@ -76,7 +80,7 @@ public class ScriptPluginTimerHelper : IScriptPluginTimerHelper
         {
             return;
         }
-        
+
         _logger.LogDebug("Stopping script timer...");
         _timer.Change(Timeout.Infinite, Timeout.Infinite);
         _timer.Dispose();
@@ -100,53 +104,90 @@ public class ScriptPluginTimerHelper : IScriptPluginTimerHelper
 
         _jsAction = action;
         _actionName = actionName;
-        _actions = OnTick;
+        _actions = OnTickInternal;
     }
 
-    private void ReleaseThreads()
+    private void ReleaseThreads(bool releaseOnRunning, bool releaseOnDependent)
     {
-        _onRunningTick.Set();
-
-        if (_onDependentAction?.CurrentCount != 0)
+        if (releaseOnRunning && _onRunningTick.CurrentCount == 0)
         {
-            return;
+            _logger.LogDebug("-Releasing OnRunning for timer");
+            _onRunningTick.Release(1);
         }
 
-        _onDependentAction?.Release(1);
+        if (releaseOnDependent && _onDependentAction?.CurrentCount == 0)
+        {
+            _onDependentAction?.Release(1);
+        }
     }
-    private void OnTick()
+
+    private async void OnTickInternal()
     {
+        var releaseOnRunning = false;
+        var releaseOnDependent = false;
+
         try
         {
-            if (!_onRunningTick.IsSet)
+            try
+            {
+                if (Interlocked.Read(ref _waitingCount) > MaxWaiting)
+                {
+                    _logger.LogWarning("Reached max number of waiting count ({WaitingCount}) for {OnTick}",
+                        _waitingCount, nameof(OnTickInternal));
+                    return;
+                }
+
+                Interlocked.Increment(ref _waitingCount);
+                using var tokenSource1 = new CancellationTokenSource();
+                tokenSource1.CancelAfter(TimeSpan.FromMilliseconds(_interval));
+                await _onRunningTick.WaitAsync(tokenSource1.Token);
+                releaseOnRunning = true;
+            }
+            catch (OperationCanceledException)
             {
                 _logger.LogDebug("Previous {OnTick} is still running, so we are skipping this one",
-                    nameof(OnTick));
+                    nameof(OnTickInternal));
                 return;
             }
 
-            _onRunningTick.Reset();
+            using var tokenSource = new CancellationTokenSource();
+            tokenSource.CancelAfter(TimeSpan.FromSeconds(5));
 
-            // the js engine is not thread safe so we need to ensure we're not executing OnTick and OnEventAsync simultaneously
-            _onDependentAction?.WaitAsync().Wait();
+            try
+            {
+                // the js engine is not thread safe so we need to ensure we're not executing OnTick and OnEventAsync simultaneously
+                if (_onDependentAction is not null)
+                {
+                    await _onDependentAction.WaitAsync(tokenSource.Token);
+                    releaseOnDependent = true;
+                }
+            }
+            catch (OperationCanceledException)
+            {
+                _logger.LogWarning("Dependent action did not release in allotted time so we are cancelling this tick");
+                return;
+            }
+
+            _logger.LogDebug("+Running OnTick for timer");
             var start = DateTime.Now;
             _jsAction.DynamicInvoke(JsValue.Undefined, new[] { JsValue.Undefined });
             _logger.LogDebug("OnTick took {Time}ms", (DateTime.Now - start).TotalMilliseconds);
-            ReleaseThreads();
         }
-
-        catch (Exception ex) when (ex.InnerException is JavaScriptException jsex)
+        catch (Exception ex) when (ex.InnerException is JavaScriptException jsx)
         {
-            _logger.LogError(jsex,
-                "Could not execute timer tick for script action {ActionName} [@{LocationInfo}]", _actionName,
-                jsex.Location);
-            ReleaseThreads();
+            _logger.LogError(jsx,
+                "Could not execute timer tick for script action {ActionName} [{@LocationInfo}] [{@StackTrace}]",
+                _actionName,
+                jsx.Location, jsx.JavaScriptStackTrace);
         }
         catch (Exception ex)
         {
             _logger.LogError(ex, "Could not execute timer tick for script action {ActionName}", _actionName);
-            _onRunningTick.Set();
-            ReleaseThreads();
+        }
+        finally
+        {
+            ReleaseThreads(releaseOnRunning, releaseOnDependent);
+            Interlocked.Decrement(ref _waitingCount);
         }
     }
 

Application/Misc/ServerDataViewer.cs

@@ -5,6 +5,7 @@ using System.Threading;
 using System.Threading.Tasks;
 using Data.Abstractions;
 using Data.Models.Client;
+using Data.Models.Client.Stats;
 using Data.Models.Server;
 using Microsoft.EntityFrameworkCore;
 using Microsoft.Extensions.Logging;
@@ -22,18 +23,20 @@ namespace IW4MAdmin.Application.Misc
         private readonly IDataValueCache<EFServerSnapshot, (int?, DateTime?)> _snapshotCache;
         private readonly IDataValueCache<EFClient, (int, int)> _serverStatsCache;
         private readonly IDataValueCache<EFServerSnapshot, List<ClientHistoryInfo>> _clientHistoryCache;
+        private readonly IDataValueCache<EFClientRankingHistory, int> _rankedClientsCache;
 
         private readonly TimeSpan? _cacheTimeSpan =
             Utilities.IsDevelopment ? TimeSpan.FromSeconds(30) : (TimeSpan?) TimeSpan.FromMinutes(10);
 
         public ServerDataViewer(ILogger<ServerDataViewer> logger, IDataValueCache<EFServerSnapshot, (int?, DateTime?)> snapshotCache,
             IDataValueCache<EFClient, (int, int)> serverStatsCache,
-            IDataValueCache<EFServerSnapshot, List<ClientHistoryInfo>> clientHistoryCache)
+            IDataValueCache<EFServerSnapshot, List<ClientHistoryInfo>> clientHistoryCache, IDataValueCache<EFClientRankingHistory, int> rankedClientsCache)
         {
             _logger = logger;
             _snapshotCache = snapshotCache;
             _serverStatsCache = serverStatsCache;
             _clientHistoryCache = clientHistoryCache;
+            _rankedClientsCache = rankedClientsCache;
         }
 
         public async Task<(int?, DateTime?)> 
@@ -160,5 +163,30 @@ namespace IW4MAdmin.Application.Misc
                 return Enumerable.Empty<ClientHistoryInfo>();
             }
         }
+
+        public async Task<int> RankedClientsCountAsync(long? serverId = null, CancellationToken token = default)
+        {
+            _rankedClientsCache.SetCacheItem(async (set, cancellationToken) =>
+            {
+                var fifteenDaysAgo = DateTime.UtcNow.AddDays(-15);
+                return await set
+                    .Where(rating => rating.Newest)
+                    .Where(rating => rating.ServerId == serverId)
+                    .Where(rating => rating.CreatedDateTime >= fifteenDaysAgo)
+                    .Where(rating => rating.Client.Level != EFClient.Permission.Banned)
+                    .Where(rating => rating.Ranking != null)
+                    .CountAsync(cancellationToken);
+            }, nameof(_rankedClientsCache), serverId is null ? null: new[] { (object)serverId },  _cacheTimeSpan);
+            
+            try
+            {
+                return await _rankedClientsCache.GetCacheItem(nameof(_rankedClientsCache), serverId, token);
+            }
+            catch (Exception ex)
+            {
+                _logger.LogError(ex, "Could not retrieve data for {Name}", nameof(RankedClientsCountAsync));
+                return 0;
+            }
+        }
     }
 }

Application/Misc/TokenAuthentication.cs

@@ -9,40 +9,41 @@ namespace IW4MAdmin.Application.Misc
 {
     internal class TokenAuthentication : ITokenAuthentication
     {
-        private readonly ConcurrentDictionary<long, TokenState> _tokens;
+        private readonly ConcurrentDictionary<int, TokenState> _tokens;
         private readonly RandomNumberGenerator _random;
-        private static readonly TimeSpan TimeoutPeriod = new TimeSpan(0, 0, 120);
+        private static readonly TimeSpan TimeoutPeriod = new(0, 0, 120);
         private const short TokenLength = 4;
 
         public TokenAuthentication()
         {
-            _tokens = new ConcurrentDictionary<long, TokenState>();
+            _tokens = new ConcurrentDictionary<int, TokenState>();
             _random = RandomNumberGenerator.Create();
         }
 
-        public bool AuthorizeToken(long networkId, string token)
+        public bool AuthorizeToken(ITokenIdentifier authInfo)
         {
-            var authorizeSuccessful = _tokens.ContainsKey(networkId) && _tokens[networkId].Token == token;
+            var authorizeSuccessful = _tokens.ContainsKey(authInfo.ClientId) &&
+                                      _tokens[authInfo.ClientId].Token == authInfo.Token;
 
             if (authorizeSuccessful)
             {
-                _tokens.TryRemove(networkId, out _);
+                _tokens.TryRemove(authInfo.ClientId, out _);
             }
 
             return authorizeSuccessful;
         }
 
-        public TokenState GenerateNextToken(long networkId)
+        public TokenState GenerateNextToken(ITokenIdentifier authInfo)
         {
             TokenState state;
 
-            if (_tokens.ContainsKey(networkId))
+            if (_tokens.ContainsKey(authInfo.ClientId))
             {
-                state = _tokens[networkId];
+                state = _tokens[authInfo.ClientId];
 
-                if ((DateTime.Now - state.RequestTime) > TimeoutPeriod)
+                if (DateTime.Now - state.RequestTime > TimeoutPeriod)
                 {
-                    _tokens.TryRemove(networkId, out _);
+                    _tokens.TryRemove(authInfo.ClientId, out _);
                 }
 
                 else
@@ -53,17 +54,16 @@ namespace IW4MAdmin.Application.Misc
 
             state = new TokenState
             {
-                NetworkId = networkId,
                 Token = _generateToken(),
                 TokenDuration = TimeoutPeriod
             };
 
-            _tokens.TryAdd(networkId, state);
+            _tokens.TryAdd(authInfo.ClientId, state);
 
             // perform some housekeeping so we don't have built up tokens if they're not ever used
             foreach (var (key, value) in _tokens)
             {
-                if ((DateTime.Now - value.RequestTime) > TimeoutPeriod)
+                if (DateTime.Now - value.RequestTime > TimeoutPeriod)
                 {
                     _tokens.TryRemove(key, out _);
                 }

Application/RConParsers/BaseRConParser.cs

@@ -10,6 +10,7 @@ using System.Text.RegularExpressions;
 using System.Threading;
 using System.Threading.Tasks;
 using Data.Models;
+using IW4MAdmin.Application.Misc;
 using Microsoft.Extensions.Logging;
 using static SharedLibraryCore.Server;
 using ILogger = Microsoft.Extensions.Logging.ILogger;
@@ -19,6 +20,7 @@ namespace IW4MAdmin.Application.RConParsers
     public class BaseRConParser : IRConParser
     {
         private readonly ILogger _logger;
+        private static string _botIpIndicator = "00000000.";
         
         public BaseRConParser(ILogger<BaseRConParser> logger, IParserRegexFactory parserRegexFactory)
         {
@@ -51,7 +53,7 @@ namespace IW4MAdmin.Application.RConParsers
             Configuration.Status.AddMapping(ParserRegex.GroupType.RConName, 5);
             Configuration.Status.AddMapping(ParserRegex.GroupType.RConIpAddress, 7);
 
-            Configuration.Dvar.Pattern = "^\"(.+)\" is: \"(.+)?\" default: \"(.+)?\"\n(?:latched: \"(.+)?\"\n)? *(.+)$";
+            Configuration.Dvar.Pattern = "^\"(.+)\" is: \"(.+)?\" default: \"(.+)?\"\n?(?:latched: \"(.+)?\"\n?)? *(.+)?$";
             Configuration.Dvar.AddMapping(ParserRegex.GroupType.RConDvarName, 1);
             Configuration.Dvar.AddMapping(ParserRegex.GroupType.RConDvarValue, 2);
             Configuration.Dvar.AddMapping(ParserRegex.GroupType.RConDvarDefaultValue, 3);
@@ -80,7 +82,7 @@ namespace IW4MAdmin.Application.RConParsers
 
         public async Task<string[]> ExecuteCommandAsync(IRConConnection connection, string command, CancellationToken token = default)
         {
-            command = command.FormatMessageForEngine(Configuration?.ColorCodeMapping);
+            command = command.FormatMessageForEngine(Configuration);
             var response = await connection.SendQueryAsync(StaticHelpers.QueryType.COMMAND, command, token);
             return response.Where(item => item != Configuration.CommandPrefixes.RConResponse).ToArray();
         }
@@ -103,7 +105,7 @@ namespace IW4MAdmin.Application.RConParsers
                 lineSplit = Array.Empty<string>();
             }
 
-            var response = string.Join('\n', lineSplit).TrimEnd('\0');
+            var response = string.Join('\n', lineSplit).Replace("\n", "").TrimEnd('\0');
             var match = Regex.Match(response, Configuration.Dvar.Pattern);
 
             if (response.Contains("Unknown command") ||
@@ -141,6 +143,30 @@ namespace IW4MAdmin.Application.RConParsers
             };
         }
 
+        public void BeginGetDvar(IRConConnection connection, string dvarName, AsyncCallback callback, CancellationToken token = default)
+        {
+            GetDvarAsync<string>(connection, dvarName, token: token).ContinueWith(action =>
+            {
+                if (action.IsCompletedSuccessfully)
+                {
+                    callback?.Invoke(new AsyncResult
+                    {
+                        IsCompleted = true,
+                        AsyncState = (true, action.Result.Value)
+                    });
+                }
+
+                else
+                {
+                    callback?.Invoke(new AsyncResult
+                    {
+                        IsCompleted = true,
+                        AsyncState = (false, (string)null)
+                    });
+                }
+            },  CancellationToken.None);
+        }
+
         public virtual async Task<IStatusResponse> GetStatusAsync(IRConConnection connection, CancellationToken token = default)
         {
             var response = await connection.SendQueryAsync(StaticHelpers.QueryType.COMMAND_STATUS, "status", token);
@@ -150,16 +176,16 @@ namespace IW4MAdmin.Application.RConParsers
             return new StatusResponse
             {
                 Clients = ClientsFromStatus(response).ToArray(),
-                Map = GetValueFromStatus<string>(response, ParserRegex.GroupType.RConStatusMap, Configuration.MapStatus.Pattern),
-                GameType = GetValueFromStatus<string>(response, ParserRegex.GroupType.RConStatusGametype, Configuration.GametypeStatus.Pattern),
-                Hostname = GetValueFromStatus<string>(response, ParserRegex.GroupType.RConStatusHostname, Configuration.HostnameStatus.Pattern),
-                MaxClients = GetValueFromStatus<int?>(response, ParserRegex.GroupType.RConStatusMaxPlayers, Configuration.MaxPlayersStatus.Pattern)
+                Map = GetValueFromStatus<string>(response, ParserRegex.GroupType.RConStatusMap, Configuration.MapStatus),
+                GameType = GetValueFromStatus<string>(response, ParserRegex.GroupType.RConStatusGametype, Configuration.GametypeStatus),
+                Hostname = GetValueFromStatus<string>(response, ParserRegex.GroupType.RConStatusHostname, Configuration.HostnameStatus),
+                MaxClients = GetValueFromStatus<int?>(response, ParserRegex.GroupType.RConStatusMaxPlayers, Configuration.MaxPlayersStatus)
             };
         }
 
-        private T GetValueFromStatus<T>(IEnumerable<string> response, ParserRegex.GroupType groupType, string groupPattern)
+        private T GetValueFromStatus<T>(IEnumerable<string> response, ParserRegex.GroupType groupType, ParserRegex parserRegex)
         {
-            if (string.IsNullOrEmpty(groupPattern))
+            if (string.IsNullOrEmpty(parserRegex.Pattern))
             {
                 return default;
             }
@@ -167,10 +193,10 @@ namespace IW4MAdmin.Application.RConParsers
             string value = null;
             foreach (var line in response)
             {
-                var regex = Regex.Match(line, groupPattern);
-                if (regex.Success)
+                var regex = Regex.Match(line, parserRegex.Pattern);
+                if (regex.Success && parserRegex.GroupMapping.ContainsKey(groupType))
                 {
-                    value = regex.Groups[Configuration.MapStatus.GroupMapping[groupType]].ToString();
+                    value = regex.Groups[parserRegex.GroupMapping[groupType]].ToString();
                 }
             }
 
@@ -196,6 +222,31 @@ namespace IW4MAdmin.Application.RConParsers
             return (await connection.SendQueryAsync(StaticHelpers.QueryType.SET_DVAR, dvarString, token)).Length > 0;
         }
 
+        public void BeginSetDvar(IRConConnection connection, string dvarName, object dvarValue, AsyncCallback callback,
+            CancellationToken token = default)
+        {
+            SetDvarAsync(connection, dvarName, dvarValue, token).ContinueWith(action =>
+            {
+                if (action.Exception is null && !action.IsCanceled)
+                {
+                    callback?.Invoke(new AsyncResult
+                    {
+                        IsCompleted = true,
+                        AsyncState = true
+                    });
+                }
+
+                else
+                {
+                    callback?.Invoke(new AsyncResult
+                    {
+                        IsCompleted = true,
+                        AsyncState = false
+                    });
+                }
+            }, CancellationToken.None);
+        }
+
         private List<EFClient> ClientsFromStatus(string[] Status)
         {
             List<EFClient> StatusPlayers = new List<EFClient>();
@@ -240,8 +291,15 @@ namespace IW4MAdmin.Application.RConParsers
                     long networkId;
                     var name = match.Values[Configuration.Status.GroupMapping[ParserRegex.GroupType.RConName]].TrimNewLine();
                     string networkIdString;
+                    
                     var ip = match.Values[Configuration.Status.GroupMapping[ParserRegex.GroupType.RConIpAddress]].Split(':')[0].ConvertToIP();
 
+                    if (match.Values[Configuration.Status.GroupMapping[ParserRegex.GroupType.RConIpAddress]]
+                        .Contains(_botIpIndicator))
+                    {
+                        ip = System.Net.IPAddress.Broadcast.ToString().ConvertToIP();
+                    }
+
                     try
                     {
                         networkIdString = match.Values[Configuration.Status.GroupMapping[ParserRegex.GroupType.RConNetworkId]];
@@ -256,9 +314,9 @@ namespace IW4MAdmin.Application.RConParsers
                         continue;
                     }
 
-                    var client = new EFClient()
+                    var client = new EFClient
                     {
-                        CurrentAlias = new EFAlias()
+                        CurrentAlias = new EFAlias
                         {
                             Name = name,
                             IPAddress = ip
@@ -310,15 +368,28 @@ namespace IW4MAdmin.Application.RConParsers
             (T)Convert.ChangeType(Configuration.DefaultDvarValues[dvarName], typeof(T)) :
             default;
 
-        public TimeSpan OverrideTimeoutForCommand(string command)
+        public TimeSpan? OverrideTimeoutForCommand(string command)
         {
-            if (command.Contains("map_rotate", StringComparison.InvariantCultureIgnoreCase) ||
-                command.StartsWith("map ", StringComparison.InvariantCultureIgnoreCase))
+            if (string.IsNullOrEmpty(command))
             {
-                return TimeSpan.FromSeconds(30);
+                return TimeSpan.Zero;
+            }
+            
+            var commandToken = command.Split(' ', StringSplitOptions.RemoveEmptyEntries).First().ToLower();
+
+            if (!Configuration.OverrideCommandTimeouts.ContainsKey(commandToken))
+            {
+                return TimeSpan.Zero;
             }
 
-            return TimeSpan.Zero;
+            var timeoutValue = Configuration.OverrideCommandTimeouts[commandToken];
+            
+            if (timeoutValue.HasValue && timeoutValue.Value != 0) // JINT doesn't seem to be able to properly set nulls on dictionaries
+            {
+                return TimeSpan.FromSeconds(timeoutValue.Value);
+            }
+
+            return null;
         }
     }
 }

Application/RConParsers/DynamicRConParserConfiguration.cs

@@ -26,12 +26,14 @@ namespace IW4MAdmin.Application.RConParsers
         public NumberStyles GuidNumberStyle { get; set; } = NumberStyles.HexNumber;
         public IDictionary<string, string> OverrideDvarNameMapping { get; set; } = new Dictionary<string, string>();
         public IDictionary<string, string> DefaultDvarValues { get; set; } = new Dictionary<string, string>();
+        public IDictionary<string, int?> OverrideCommandTimeouts { get; set; } = new Dictionary<string, int?>();
         public int NoticeMaximumLines { get; set; } = 8;
         public int NoticeMaxCharactersPerLine { get; set; } = 50;
         public string NoticeLineSeparator { get; set; } = Environment.NewLine;
         public int? DefaultRConPort { get; set; }
         public string DefaultInstallationDirectoryHint { get; set; }
         public short FloodProtectInterval { get; set; } = 750;
+        public bool ShouldRemoveDiacritics { get; set; }
 
         public ColorCodeMapping ColorCodeMapping { get; set; } = new ColorCodeMapping
         {
@@ -46,7 +48,7 @@ namespace IW4MAdmin.Application.RConParsers
             {ColorCodes.White.ToString(), "^7"},
             {ColorCodes.Map.ToString(), "^8"},
             {ColorCodes.Grey.ToString(), "^9"},
-            {ColorCodes.Wildcard.ToString(), ":^"},
+            {ColorCodes.Wildcard.ToString(), "^:"}
         };
 
         public DynamicRConParserConfiguration(IParserRegexFactory parserRegexFactory)
@@ -58,6 +60,25 @@ namespace IW4MAdmin.Application.RConParsers
             StatusHeader = parserRegexFactory.CreateParserRegex();
             HostnameStatus = parserRegexFactory.CreateParserRegex();
             MaxPlayersStatus = parserRegexFactory.CreateParserRegex();
+
+
+            const string mapRotateCommand = "map_rotate";
+            const string mapCommand = "map";
+            const string fastRestartCommand = "fast_restart";
+            const string quitCommand = "quit";
+
+            foreach (var command in new[] { mapRotateCommand, mapCommand, fastRestartCommand})
+            {
+                if (!OverrideCommandTimeouts.ContainsKey(command))
+                {
+                    OverrideCommandTimeouts.Add(command, 45);
+                }
+            }
+
+            if (!OverrideCommandTimeouts.ContainsKey(quitCommand))
+            {
+                OverrideCommandTimeouts.Add(quitCommand, 0); // we don't want to wait for a response when we quit the server
+            }
         }
     }
 }

Data/Abstractions/IDataValueCache.cs

@@ -1,4 +1,5 @@
 using System;
+using System.Collections.Generic;
 using System.Threading;
 using System.Threading.Tasks;
 using Microsoft.EntityFrameworkCore;
@@ -9,6 +10,11 @@ namespace Data.Abstractions
     {
         void SetCacheItem(Func<DbSet<TEntityType>, CancellationToken, Task<TReturnType>> itemGetter, string keyName,
             TimeSpan? expirationTime = null, bool autoRefresh = false);
+
+        void SetCacheItem(Func<DbSet<TEntityType>, CancellationToken, Task<TReturnType>> itemGetter, string keyName,
+            IEnumerable<object> ids = null, TimeSpan? expirationTime = null, bool autoRefresh = false);
+
         Task<TReturnType> GetCacheItem(string keyName, CancellationToken token = default);
+        Task<TReturnType> GetCacheItem(string keyName, object id = null, CancellationToken token = default);
     }
-}
+}

Data/Context/DatabaseContext.cs

@@ -32,6 +32,7 @@ namespace Data.Context
         public DbSet<EFClientMessage> ClientMessages { get; set; }
         
         public DbSet<EFServerStatistics> ServerStatistics { get; set; }
+        public DbSet<EFClientStatistics> ClientStatistics { get; set; }
         public DbSet<EFHitLocation> HitLocations { get; set; }
         public DbSet<EFClientHitStatistic> HitStatistics { get; set; }
         public DbSet<EFWeapon> Weapons { get; set; }
@@ -85,7 +86,15 @@ namespace Data.Context
         protected override void OnModelCreating(ModelBuilder modelBuilder)
         {
             // make network id unique
-            modelBuilder.Entity<EFClient>(entity => { entity.HasIndex(e => e.NetworkId).IsUnique(); });
+            modelBuilder.Entity<EFClient>(entity =>
+            {
+                entity.HasIndex(e => e.NetworkId);
+                entity.HasAlternateKey(client => new
+                {
+                    client.NetworkId,
+                    client.GameName
+                });
+            });
 
             modelBuilder.Entity<EFPenalty>(entity =>
             {

Data/Helpers/DataValueCache.cs

@@ -1,5 +1,7 @@
 using System;
 using System.Collections.Concurrent;
+using System.Collections.Generic;
+using System.Linq;
 using System.Threading;
 using System.Threading.Tasks;
 using Data.Abstractions;
@@ -15,8 +17,8 @@ namespace Data.Helpers
         private readonly ILogger _logger;
         private readonly IDatabaseContextFactory _contextFactory;
 
-        private readonly ConcurrentDictionary<string, CacheState<TReturnType>> _cacheStates =
-            new ConcurrentDictionary<string, CacheState<TReturnType>>();
+        private readonly ConcurrentDictionary<string, Dictionary<object, CacheState<TReturnType>>> _cacheStates = new();
+        private readonly object _defaultKey = new();
 
         private bool _autoRefresh;
         private const int DefaultExpireMinutes = 15;
@@ -51,41 +53,61 @@ namespace Data.Helpers
         public void SetCacheItem(Func<DbSet<TEntityType>, CancellationToken, Task<TReturnType>> getter, string key,
             TimeSpan? expirationTime = null, bool autoRefresh = false)
         {
-            if (_cacheStates.ContainsKey(key))
-            {
-                _logger.LogDebug("Cache key {Key} is already added", key);
-                return;
-            }
-
-            var state = new CacheState<TReturnType>
-            {
-                Key = key,
-                Getter = getter,
-                ExpirationTime = expirationTime ?? TimeSpan.FromMinutes(DefaultExpireMinutes)
-            };
-
-            _autoRefresh = autoRefresh;
-
-            _cacheStates.TryAdd(key, state);
-
-            if (!_autoRefresh || expirationTime == TimeSpan.MaxValue)
-            {
-                return;
-            }
-
-            _timer = new Timer(state.ExpirationTime.TotalMilliseconds);
-            _timer.Elapsed += async (sender, args) => await RunCacheUpdate(state, CancellationToken.None);
-            _timer.Start();
+            SetCacheItem(getter, key, null, expirationTime, autoRefresh);
         }
 
-        public async Task<TReturnType> GetCacheItem(string keyName, CancellationToken cancellationToken = default)
+        public void SetCacheItem(Func<DbSet<TEntityType>, CancellationToken, Task<TReturnType>> getter, string key,
+            IEnumerable<object> ids = null, TimeSpan? expirationTime = null, bool autoRefresh = false)
+        {
+            ids ??= new[] { _defaultKey };
+            
+            if (!_cacheStates.ContainsKey(key))
+            {
+                _cacheStates.TryAdd(key, new Dictionary<object, CacheState<TReturnType>>());
+            }
+
+            foreach (var id in ids)
+            {
+                if (_cacheStates[key].ContainsKey(id))
+                {
+                    continue;
+                }
+
+                var state = new CacheState<TReturnType>
+                {
+                    Key = key,
+                    Getter = getter,
+                    ExpirationTime = expirationTime ?? TimeSpan.FromMinutes(DefaultExpireMinutes)
+                };
+
+                _cacheStates[key].Add(id, state);
+
+                _autoRefresh = autoRefresh;
+                
+
+                if (!_autoRefresh || expirationTime == TimeSpan.MaxValue)
+                {
+                    return;
+                }
+                
+                _timer = new Timer(state.ExpirationTime.TotalMilliseconds);
+                _timer.Elapsed += async (sender, args) => await RunCacheUpdate(state, CancellationToken.None);
+                _timer.Start();
+            }
+        }
+
+        public async Task<TReturnType> GetCacheItem(string keyName, CancellationToken cancellationToken = default) =>
+            await GetCacheItem(keyName, null, cancellationToken);
+
+        public async Task<TReturnType> GetCacheItem(string keyName, object id = null,
+            CancellationToken cancellationToken = default)
         {
             if (!_cacheStates.ContainsKey(keyName))
             {
                 throw new ArgumentException("No cache found for key {key}", keyName);
             }
 
-            var state = _cacheStates[keyName];
+            var state = id is null ? _cacheStates[keyName].Values.First() : _cacheStates[keyName][id];
 
             // when auto refresh is off we want to check the expiration and value
             // when auto refresh is on, we want to only check the value, because it'll be refreshed automatically
@@ -115,4 +137,4 @@ namespace Data.Helpers
             }
         }
     }
-}
+}

Data/Migrations/MySql/20220609135128_AddIndexToEFRankingHistoryCreatedDatetime.cs

@@ -0,0 +1,24 @@
+using Microsoft.EntityFrameworkCore.Migrations;
+
+#nullable disable
+
+namespace Data.Migrations.MySql
+{
+    public partial class AddIndexToEFRankingHistoryCreatedDatetime : Migration
+    {
+        protected override void Up(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.CreateIndex(
+                name: "IX_EFClientRankingHistory_CreatedDateTime",
+                table: "EFClientRankingHistory",
+                column: "CreatedDateTime");
+        }
+
+        protected override void Down(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.DropIndex(
+                name: "IX_EFClientRankingHistory_CreatedDateTime",
+                table: "EFClientRankingHistory");
+        }
+    }
+}

Data/Migrations/MySql/20220613192602_AddAlternateKeyToEFClients.cs

@@ -0,0 +1,63 @@
+using Microsoft.EntityFrameworkCore.Migrations;
+
+#nullable disable
+
+namespace Data.Migrations.MySql
+{
+    public partial class AddAlternateKeyToEFClients : Migration
+    {
+        protected override void Up(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.DropIndex(
+                name: "IX_EFClients_NetworkId",
+                table: "EFClients");
+            
+            migrationBuilder.Sql("UPDATE `EFClients` set `GameName` = 0 WHERE `GameName` IS NULL");
+
+            migrationBuilder.AlterColumn<int>(
+                name: "GameName",
+                table: "EFClients",
+                type: "int",
+                nullable: false,
+                defaultValue: 0,
+                oldClrType: typeof(int),
+                oldType: "int",
+                oldNullable: true);
+
+            migrationBuilder.AddUniqueConstraint(
+                name: "AK_EFClients_NetworkId_GameName",
+                table: "EFClients",
+                columns: new[] { "NetworkId", "GameName" });
+
+            migrationBuilder.CreateIndex(
+                name: "IX_EFClients_NetworkId",
+                table: "EFClients",
+                column: "NetworkId");
+        }
+
+        protected override void Down(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.DropUniqueConstraint(
+                name: "AK_EFClients_NetworkId_GameName",
+                table: "EFClients");
+
+            migrationBuilder.DropIndex(
+                name: "IX_EFClients_NetworkId",
+                table: "EFClients");
+
+            migrationBuilder.AlterColumn<int>(
+                name: "GameName",
+                table: "EFClients",
+                type: "int",
+                nullable: true,
+                oldClrType: typeof(int),
+                oldType: "int");
+
+            migrationBuilder.CreateIndex(
+                name: "IX_EFClients_NetworkId",
+                table: "EFClients",
+                column: "NetworkId",
+                unique: true);
+        }
+    }
+}

Data/Migrations/MySql/20220616224602_AddDescendingTimeSentIndexEFClientMessages.cs

@@ -0,0 +1,27 @@
+using System;
+using Microsoft.EntityFrameworkCore.Migrations;
+
+#nullable disable
+
+namespace Data.Migrations.MySql
+{
+    public partial class AddDescendingTimeSentIndexEFClientMessages : Migration
+    {
+        protected override void Up(MigrationBuilder migrationBuilder)
+        {
+            try
+            {
+                migrationBuilder.Sql(@"create index IX_EFClientMessages_TimeSentDesc on EFClientMessages (TimeSent desc);");
+            }
+            catch
+            {
+                migrationBuilder.Sql(@"create index IX_EFClientMessages_TimeSentDesc on efclientmessages (TimeSent desc);");
+            }
+        }
+
+        protected override void Down(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.Sql(@"drop index IX_EFClientMessages_TimeSentDesc on EFClientMessages;");
+        }
+    }
+}

Data/Migrations/MySql/MySqlDatabaseContextModelSnapshot.cs

@@ -64,7 +64,7 @@ namespace Data.Migrations.MySql
                     b.Property<DateTime>("FirstConnection")
                         .HasColumnType("datetime(6)");
 
-                    b.Property<int?>("GameName")
+                    b.Property<int>("GameName")
                         .HasColumnType("int");
 
                     b.Property<DateTime>("LastConnection")
@@ -90,12 +90,13 @@ namespace Data.Migrations.MySql
 
                     b.HasKey("ClientId");
 
+                    b.HasAlternateKey("NetworkId", "GameName");
+
                     b.HasIndex("AliasLinkId");
 
                     b.HasIndex("CurrentAliasId");
 
-                    b.HasIndex("NetworkId")
-                        .IsUnique();
+                    b.HasIndex("NetworkId");
 
                     b.ToTable("EFClients", (string)null);
                 });
@@ -456,6 +457,8 @@ namespace Data.Migrations.MySql
 
                     b.HasIndex("ClientId");
 
+                    b.HasIndex("CreatedDateTime");
+
                     b.HasIndex("Ranking");
 
                     b.HasIndex("ServerId");

Data/Migrations/Postgresql/20220609135210_AddIndexToEFRankingHistoryCreatedDatetime.cs

@@ -0,0 +1,24 @@
+using Microsoft.EntityFrameworkCore.Migrations;
+
+#nullable disable
+
+namespace Data.Migrations.Postgresql
+{
+    public partial class AddIndexToEFRankingHistoryCreatedDatetime : Migration
+    {
+        protected override void Up(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.CreateIndex(
+                name: "IX_EFClientRankingHistory_CreatedDateTime",
+                table: "EFClientRankingHistory",
+                column: "CreatedDateTime");
+        }
+
+        protected override void Down(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.DropIndex(
+                name: "IX_EFClientRankingHistory_CreatedDateTime",
+                table: "EFClientRankingHistory");
+        }
+    }
+}

Data/Migrations/Postgresql/20220613181913_AddAlternateKeyToEFClients.cs

@@ -0,0 +1,63 @@
+using Microsoft.EntityFrameworkCore.Migrations;
+
+#nullable disable
+
+namespace Data.Migrations.Postgresql
+{
+    public partial class AddAlternateKeyToEFClients : Migration
+    {
+        protected override void Up(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.DropIndex(
+                name: "IX_EFClients_NetworkId",
+                table: "EFClients");
+
+            migrationBuilder.Sql("UPDATE \"EFClients\" SET \"GameName\" = 0 WHERE \"GameName\" IS NULL");
+
+            migrationBuilder.AlterColumn<int>(
+                name: "GameName",
+                table: "EFClients",
+                type: "integer",
+                nullable: false,
+                defaultValue: 0,
+                oldClrType: typeof(int),
+                oldType: "integer",
+                oldNullable: true);
+
+            migrationBuilder.AddUniqueConstraint(
+                name: "AK_EFClients_NetworkId_GameName",
+                table: "EFClients",
+                columns: new[] { "NetworkId", "GameName" });
+
+            migrationBuilder.CreateIndex(
+                name: "IX_EFClients_NetworkId",
+                table: "EFClients",
+                column: "NetworkId");
+        }
+
+        protected override void Down(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.DropUniqueConstraint(
+                name: "AK_EFClients_NetworkId_GameName",
+                table: "EFClients");
+
+            migrationBuilder.DropIndex(
+                name: "IX_EFClients_NetworkId",
+                table: "EFClients");
+
+            migrationBuilder.AlterColumn<int>(
+                name: "GameName",
+                table: "EFClients",
+                type: "integer",
+                nullable: true,
+                oldClrType: typeof(int),
+                oldType: "integer");
+
+            migrationBuilder.CreateIndex(
+                name: "IX_EFClients_NetworkId",
+                table: "EFClients",
+                column: "NetworkId",
+                unique: true);
+        }
+    }
+}

Data/Migrations/Postgresql/20220616224145_AddDescendingTimeSentIndexEFClientMessages.cs

@@ -0,0 +1,24 @@
+using Microsoft.EntityFrameworkCore.Migrations;
+
+#nullable disable
+
+namespace Data.Migrations.Postgresql
+{
+    public partial class AddDescendingTimeSentIndexEFClientMessages : Migration
+    {
+        protected override void Up(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.Sql(
+                @"CREATE INDEX""IX_EFClientMessages_TimeSentDesc""
+                ON public.""EFClientMessages"" USING btree
+                (""TimeSent"" DESC NULLS LAST)
+                TABLESPACE pg_default;"
+            );
+        }
+
+        protected override void Down(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.Sql(@"DROP INDEX public.""IX_EFClientMessages_TimeSentDesc""");
+        }
+    }
+}

Data/Migrations/Postgresql/PostgresqlDatabaseContextModelSnapshot.cs

@@ -71,7 +71,7 @@ namespace Data.Migrations.Postgresql
                     b.Property<DateTime>("FirstConnection")
                         .HasColumnType("timestamp without time zone");
 
-                    b.Property<int?>("GameName")
+                    b.Property<int>("GameName")
                         .HasColumnType("integer");
 
                     b.Property<DateTime>("LastConnection")
@@ -97,12 +97,13 @@ namespace Data.Migrations.Postgresql
 
                     b.HasKey("ClientId");
 
+                    b.HasAlternateKey("NetworkId", "GameName");
+
                     b.HasIndex("AliasLinkId");
 
                     b.HasIndex("CurrentAliasId");
 
-                    b.HasIndex("NetworkId")
-                        .IsUnique();
+                    b.HasIndex("NetworkId");
 
                     b.ToTable("EFClients", (string)null);
                 });
@@ -475,6 +476,8 @@ namespace Data.Migrations.Postgresql
 
                     b.HasIndex("ClientId");
 
+                    b.HasIndex("CreatedDateTime");
+
                     b.HasIndex("Ranking");
 
                     b.HasIndex("ServerId");

Data/Migrations/Sqlite/20220609022511_AddIndexToEFRankingHistoryCreatedDatetime.cs

@@ -0,0 +1,24 @@
+using Microsoft.EntityFrameworkCore.Migrations;
+
+#nullable disable
+
+namespace Data.Migrations.Sqlite
+{
+    public partial class AddIndexToEFRankingHistoryCreatedDatetime : Migration
+    {
+        protected override void Up(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.CreateIndex(
+                name: "IX_EFClientRankingHistory_CreatedDateTime",
+                table: "EFClientRankingHistory",
+                column: "CreatedDateTime");
+        }
+
+        protected override void Down(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.DropIndex(
+                name: "IX_EFClientRankingHistory_CreatedDateTime",
+                table: "EFClientRankingHistory");
+        }
+    }
+}

Data/Migrations/Sqlite/20220613160952_AddAlternateKeyToEFClients.cs

@@ -0,0 +1,61 @@
+using Microsoft.EntityFrameworkCore.Migrations;
+
+#nullable disable
+
+namespace Data.Migrations.Sqlite
+{
+    public partial class AddAlternateKeyToEFClients : Migration
+    {
+        protected override void Up(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.DropIndex(
+                name: "IX_EFClients_NetworkId",
+                table: "EFClients");
+
+            migrationBuilder.AlterColumn<int>(
+                name: "GameName",
+                table: "EFClients",
+                type: "INTEGER",
+                nullable: false,
+                defaultValue: 0,
+                oldClrType: typeof(int),
+                oldType: "INTEGER",
+                oldNullable: true);
+
+            migrationBuilder.AddUniqueConstraint(
+                name: "AK_EFClients_NetworkId_GameName",
+                table: "EFClients",
+                columns: new[] { "NetworkId", "GameName" });
+
+            migrationBuilder.CreateIndex(
+                name: "IX_EFClients_NetworkId",
+                table: "EFClients",
+                column: "NetworkId");
+        }
+
+        protected override void Down(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.DropUniqueConstraint(
+                name: "AK_EFClients_NetworkId_GameName",
+                table: "EFClients");
+
+            migrationBuilder.DropIndex(
+                name: "IX_EFClients_NetworkId",
+                table: "EFClients");
+
+            migrationBuilder.AlterColumn<int>(
+                name: "GameName",
+                table: "EFClients",
+                type: "INTEGER",
+                nullable: true,
+                oldClrType: typeof(int),
+                oldType: "INTEGER");
+
+            migrationBuilder.CreateIndex(
+                name: "IX_EFClients_NetworkId",
+                table: "EFClients",
+                column: "NetworkId",
+                unique: true);
+        }
+    }
+}

Data/Migrations/Sqlite/20220616225008_AddDescendingTimeSentIndexEFClientMessages.cs

@@ -0,0 +1,19 @@
+using Microsoft.EntityFrameworkCore.Migrations;
+
+#nullable disable
+
+namespace Data.Migrations.Sqlite
+{
+    public partial class AddDescendingTimeSentIndexEFClientMessages : Migration
+    {
+        protected override void Up(MigrationBuilder migrationBuilder)
+        {
+
+        }
+
+        protected override void Down(MigrationBuilder migrationBuilder)
+        {
+
+        }
+    }
+}

Data/Migrations/Sqlite/SqliteDatabaseContextModelSnapshot.cs

@@ -62,7 +62,7 @@ namespace Data.Migrations.Sqlite
                     b.Property<DateTime>("FirstConnection")
                         .HasColumnType("TEXT");
 
-                    b.Property<int?>("GameName")
+                    b.Property<int>("GameName")
                         .HasColumnType("INTEGER");
 
                     b.Property<DateTime>("LastConnection")
@@ -88,12 +88,13 @@ namespace Data.Migrations.Sqlite
 
                     b.HasKey("ClientId");
 
+                    b.HasAlternateKey("NetworkId", "GameName");
+
                     b.HasIndex("AliasLinkId");
 
                     b.HasIndex("CurrentAliasId");
 
-                    b.HasIndex("NetworkId")
-                        .IsUnique();
+                    b.HasIndex("NetworkId");
 
                     b.ToTable("EFClients", (string)null);
                 });
@@ -454,6 +455,8 @@ namespace Data.Migrations.Sqlite
 
                     b.HasIndex("ClientId");
 
+                    b.HasIndex("CreatedDateTime");
+
                     b.HasIndex("Ranking");
 
                     b.HasIndex("ServerId");

Data/Models/Client/EFClient.cs

@@ -63,7 +63,7 @@ namespace Data.Models.Client
         public DateTime FirstConnection { get; set; }
         [Required]
         public DateTime LastConnection { get; set; }
-        public Reference.Game? GameName { get; set; } = Reference.Game.UKN;
+        public Reference.Game GameName { get; set; } = Reference.Game.UKN;
         public bool Masked { get; set; }
         [Required]
         public int AliasLinkId { get; set; }

Data/Models/Client/Stats/EFClientRankingHistory.cs

@@ -7,8 +7,6 @@ namespace Data.Models.Client.Stats
 {
     public class EFClientRankingHistory: AuditFields
     {
-        public const int MaxRankingCount = 30;
-        
         [Key]
         public long ClientRankingHistoryId { get; set; }
         
@@ -28,4 +26,4 @@ namespace Data.Models.Client.Stats
         public double? ZScore { get; set; }
         public double? PerformanceMetric { get; set; }
     }
-}
+}

Data/Models/Configuration/StatsModelConfiguration.cs

@@ -86,7 +86,8 @@ namespace Data.Models.Configuration
                 entity.HasIndex(ranking => ranking.Ranking);
                 entity.HasIndex(ranking => ranking.ZScore);
                 entity.HasIndex(ranking => ranking.UpdatedDateTime);
+                entity.HasIndex(ranking => ranking.CreatedDateTime);
             });
         }
     }
-}
+}

Data/Models/EFPenalty.cs

@@ -18,6 +18,9 @@ namespace Data.Models
             Unban,
             Any,
             Unflag,
+            Mute,
+            TempMute,
+            Unmute,
             Other = 100
         }
 

Data/Models/Reference.cs

@@ -15,7 +15,8 @@
             T6 = 7,
             T7 = 8,
             SHG1 = 9,
-            CSGO = 10
+            CSGO = 10,
+            H1 = 11
         }
         
         public enum ConnectionType
@@ -24,4 +25,4 @@
             Disconnect
         }
     }
-}
+}

DeploymentFiles/PostPublish.ps1

@@ -9,7 +9,7 @@ foreach($localization in $localizations)
 {
     $url = "http://api.raidmax.org:5000/localization/{0}" -f $localization
     $filePath = "{0}\Localization\IW4MAdmin.{1}.json" -f $PublishDir, $localization
-    $response = Invoke-WebRequest $url
+    $response = Invoke-WebRequest $url -UseBasicParsing
     Out-File -FilePath $filePath -InputObject $response.Content -Encoding utf8
 }
 
@@ -20,4 +20,4 @@ Minor = $versionInfo.ProductMinorPart
 Build = $versionInfo.ProductBuildPart  
 Revision = $versionInfo.ProductPrivatePart
 }
-$json | ConvertTo-Json | Out-File -FilePath ("{0}\VersionInformation.json" -f $PublishDir) -Encoding ASCII
+$json | ConvertTo-Json | Out-File -FilePath ("{0}\VersionInformation.json" -f $PublishDir) -Encoding ASCII

DeploymentFiles/UpdateIW4MAdmin.ps1

@@ -39,7 +39,7 @@ else
 
 Write-Output "Retrieving latest version info..."
 
-$releaseInfo = (Invoke-WebRequest $releasesUri | ConvertFrom-Json) | Select -First 1
+$releaseInfo = (Invoke-WebRequest $releasesUri -UseBasicParsing | ConvertFrom-Json) | Select -First 1
 $asset = $releaseInfo.assets | Where-Object name -like $assetPattern | Select -First 1
 $downloadUri = $asset.browser_download_url
 $filename = Split-Path $downloadUri -leaf
@@ -55,7 +55,7 @@ if (!$Silent)
 
 Write-Output "Downloading update. This might take a moment..."
 
-$fileDownload = Invoke-WebRequest -Uri $downloadUri
+$fileDownload = Invoke-WebRequest -Uri $downloadUri -UseBasicParsing
 if ($fileDownload.StatusDescription -ne "OK")
 {
     throw "Could not update IW4MAdmin. ($fileDownload.StatusDescription)"

GameFiles/AntiCheat/IW4x/userraw/scripts/_customcallbacks.gsc

@@ -29,8 +29,9 @@ onPlayerConnect( player )
 	for( ;; )
 	{
 		level waittill( "connected", player );	
-		player setClientDvar("cl_autorecord", 1);
-		player setClientDvar("cl_demosKeep", 200);
+		player setClientDvars( "cl_autorecord", 1,
+					"cl_demosKeep", 200 );
+
 		player thread waitForFrameThread();
 		player thread waitForAttack();
 	}
@@ -60,7 +61,7 @@ getHttpString( url )
 
 runRadarUpdates()
 {
-	interval = int(getDvar("sv_printradar_updateinterval"));
+	interval = getDvarInt( "sv_printradar_updateinterval", 500 );
 
 	for ( ;; )
 	{
@@ -191,7 +192,7 @@ waitForAdditionalAngles( logString, beforeFrameCount, afterFrameCount )
 		i++;
 	}
 
-	lastAttack = int(getTime()) - int(self.lastAttackTime);
+	lastAttack = getTime() - self.lastAttackTime;
 	isAlive = isAlive(self);
 
 	logPrint(logString + ";" + anglesStr + ";" + isAlive + ";" + lastAttack + "\n" ); 

GameFiles/AntiCheat/IW5/storage/iw5/scripts/README.MD

@@ -0,0 +1,23 @@
+# IW5
+
+This expands IW4M-Admins's Anti-cheat to Plutonium IW5
+## Installation
+
+Add ``_customcallbacks.gsc`` into the scripts folder. (%localappdata%\Plutonium\storage\iw5\scripts)
+
+For more info check out Chase's [how-to guide](https://forum.plutonium.pw/topic/10738/tutorial-loading-custom-gsc-scripts).
+
+You need to add this to you ``StatsPluginSettings.json`` found in your IW4M-Admin configuration folder.
+
+```
+      "IW5": {
+        "Recoil": [
+          "iw5_1887_mp.*",
+          "turret_minigun_mp"
+        ],
+        "Button": [
+          ".*akimbo.*"
+        ]
+      }
+```
+[Example](https://imgur.com/Ji9AafI)

GameFiles/AntiCheat/IW5/storage/iw5/scripts/_customcallbacks.gsc

@@ -53,7 +53,7 @@ waitForAttack()
 
 runRadarUpdates()
 {
-	interval = int(getDvar("sv_printradar_updateinterval"));
+	interval = getDvarInt( "sv_printradar_updateinterval", 500 );
 
 	for ( ;; )
 	{
@@ -183,7 +183,7 @@ waitForAdditionalAngles( logString, beforeFrameCount, afterFrameCount )
 		i++;
 	}
 
-	lastAttack = int(getTime()) - int(self.lastAttackTime);
+	lastAttack = getTime() - self.lastAttackTime;
 	isAlive = isAlive(self);
 
 	logPrint(logString + ";" + anglesStr + ";" + isAlive + ";" + lastAttack + "\n" ); 

GameFiles/AntiCheat/PT6/README.MD

@@ -24,12 +24,12 @@ Add this to the WeaponNameParserConfigurations List in the StatsPluginSettings.j
     }
 ```
 
-Now create the following entry for __EVERY__ T6 server you are using this on in the ServerDetectionTypes list:
+Now update the `GameDetectionTypes` list with the following, if it does not already exist:
 
 ```
-    "1270014976": [
+    "T6": [
         "Offset",
-        "Strain",
-        "Snap"
-      ]
-```
+        "Snap",
+        "Strain"
+    ]
+```

GameFiles/AntiCheat/PT6/storage/t6/scripts/mp/_customcallbacks.gsc.src

@@ -60,7 +60,7 @@ waitForAttack()
 
 runRadarUpdates()
 {
-	interval = int(getDvar("sv_printradar_updateinterval"));
+	interval = getDvarInt( "sv_printradar_updateinterval" );
 
 	for ( ;; )
 	{
@@ -190,7 +190,7 @@ waitForAdditionalAngles( logString, beforeFrameCount, afterFrameCount )
 		i++;
 	}
 
-	lastAttack = int(getTime()) - int(self.lastAttackTime);
+	lastAttack = getTime() - self.lastAttackTime;
 	isAlive = isAlive(self);
 
 	logPrint(logString + ";" + anglesStr + ";" + isAlive + ";" + lastAttack + "\n" ); 

GameFiles/GameInterface/_integration_base.gsc

@@ -0,0 +1,715 @@
+#include common_scripts\utility;
+#include maps\mp\_utility;
+#include maps\mp\gametypes\_hud_util;
+
+Init()
+{    
+    level thread Setup();
+}
+
+Setup()
+{
+    level endon( "game_ended" );
+    
+    // setup default vars
+    level.eventBus              = spawnstruct();
+    level.eventBus.inVar        = "sv_iw4madmin_in";
+    level.eventBus.outVar       = "sv_iw4madmin_out";
+    level.eventBus.failKey      = "fail";
+    level.eventBus.timeoutKey   = "timeout";
+    level.eventBus.timeout      = 30;
+    
+    level.commonFunctions              = spawnstruct();
+    level.commonFunctions.setDvar      = "SetDvarIfUninitialized";
+    
+    level.commonKeys = spawnstruct();
+    
+    level.notifyTypes                                   = spawnstruct();
+    level.notifyTypes.gameFunctionsInitialized          = "GameFunctionsInitialized";
+    level.notifyTypes.integrationBootstrapInitialized   = "IntegrationBootstrapInitialized";
+    
+    level.clientDataKey = "clientData";
+
+    level.eventTypes                            = spawnstruct();
+    level.eventTypes.localClientEvent           = "client_event";
+    level.eventTypes.clientDataReceived         = "ClientDataReceived";
+    level.eventTypes.clientDataRequested        = "ClientDataRequested";
+    level.eventTypes.setClientDataRequested     = "SetClientDataRequested";
+    level.eventTypes.setClientDataCompleted     = "SetClientDataCompleted";
+    level.eventTypes.executeCommandRequested    = "ExecuteCommandRequested";
+    
+    level.iw4madminIntegrationDebug = 0;
+    
+    // map the event type to the handler
+    level.eventCallbacks = [];
+    level.eventCallbacks[level.eventTypes.clientDataReceived]       = ::OnClientDataReceived;
+    level.eventCallbacks[level.eventTypes.executeCommandRequested]  = ::OnExecuteCommand; 
+    level.eventCallbacks[level.eventTypes.setClientDataCompleted]   = ::OnSetClientDataCompleted;
+
+    level.clientCommandCallbacks = [];
+    level.clientCommandRusAsTarget = [];
+    level.logger = spawnstruct();
+    level.overrideMethods = [];
+
+    level.iw4madminIntegrationDebug = GetDvarInt( "sv_iw4madmin_integration_debug" );
+    InitializeLogger();
+    
+    wait ( 0.05 ); // needed to give script engine time to propagate notifies
+    
+    level notify( level.notifyTypes.integrationBootstrapInitialized );
+    level waittill( level.notifyTypes.gameFunctionsInitialized );
+    
+    LogDebug( "Integration received notify that game functions are initialized" );
+    
+    _SetDvarIfUninitialized( level.eventBus.inVar, "" );
+    _SetDvarIfUninitialized( level.eventBus.outVar, "" );
+    _SetDvarIfUninitialized( "sv_iw4madmin_integration_enabled", 1 );
+    _SetDvarIfUninitialized( "sv_iw4madmin_integration_debug", 0 );
+    
+    if ( GetDvarInt( "sv_iw4madmin_integration_enabled" ) != 1 )
+    {
+        return;
+    }
+    
+    // start long running tasks
+    level thread MonitorClientEvents();
+    level thread MonitorBus();
+    level thread OnPlayerConnect();
+}
+
+//////////////////////////////////
+// Client Methods
+//////////////////////////////////
+
+OnPlayerConnect()
+{
+    level endon ( "game_ended" );
+    
+    for ( ;; )
+    {
+        level waittill( "connected", player );
+        
+        if ( _IsBot( player ) ) 
+        {
+            // we don't want to track bots
+            continue;    
+        }
+        
+        if ( !IsDefined( player.pers[level.clientDataKey] ) )
+        {
+            player.pers[level.clientDataKey] = spawnstruct();
+        }
+        
+        player thread OnPlayerSpawned();
+        player thread OnPlayerJoinedTeam();
+        player thread OnPlayerJoinedSpectators();
+        player thread PlayerTrackingOnInterval();
+    }
+}
+
+OnPlayerSpawned()
+{
+    self endon( "disconnect" );
+
+    for ( ;; )
+    {
+        self waittill( "spawned_player" );
+        self PlayerSpawnEvents();
+    }
+}
+
+OnPlayerJoinedTeam()
+{
+    self endon( "disconnect" );
+
+    for( ;; )
+    {
+        self waittill( "joined_team" );
+        // join spec and join team occur at the same moment - out of order logging would be problematic
+        wait( 0.25 ); 
+        LogPrint( GenerateJoinTeamString( false ) );
+    }
+}
+
+OnPlayerJoinedSpectators()
+{
+    self endon( "disconnect" );
+
+    for( ;; )
+    {
+        self waittill( "joined_spectators" );
+        LogPrint( GenerateJoinTeamString( true ) );
+    }
+}
+
+OnGameEnded() 
+{
+    for ( ;; )
+    {
+        level waittill( "game_ended" );
+        // note: you can run data code here but it's possible for 
+        // data to get truncated, so we will try a timer based approach for now
+    }
+}
+
+DisplayWelcomeData()
+{
+    self endon( "disconnect" );
+
+    clientData = self.pers[level.clientDataKey];
+    
+    if ( clientData.permissionLevel == "User" || clientData.permissionLevel == "Flagged" ) 
+    {
+        return;
+    } 
+    
+    self IPrintLnBold( "Welcome, your level is ^5" + clientData.permissionLevel );
+    wait( 2.0 );
+    self IPrintLnBold( "You were last seen ^5" + clientData.lastConnection );
+}
+
+PlayerSpawnEvents() 
+{
+    self endon( "disconnect" );
+
+    clientData = self.pers[level.clientDataKey];
+    
+    // this gives IW4MAdmin some time to register the player before making the request;
+    // although probably not necessary some users might have a slow database or poll rate
+    wait ( 2 );
+
+    if ( IsDefined( clientData.state ) && clientData.state == "complete" ) 
+    {
+        return;
+    }
+    
+    self RequestClientBasicData();
+}
+
+PlayerTrackingOnInterval() 
+{
+    self endon( "disconnect" );
+
+    for ( ;; )
+    {
+        wait ( 120 );
+        if ( IsAlive( self ) )
+        {
+            self SaveTrackingMetrics();
+        }
+    }
+}
+
+MonitorClientEvents()
+{
+    level endon( "game_ended" );
+
+    for ( ;; ) 
+    {
+        level waittill( level.eventTypes.localClientEvent, client );
+ 
+        LogDebug( "Processing Event " + client.event.type + "-" + client.event.subtype );
+        
+        eventHandler = level.eventCallbacks[client.event.type];
+
+        if ( IsDefined( eventHandler ) )
+        {
+            client [[eventHandler]]( client.event );
+            LogDebug( "notify client for " + client.event.type );
+            client notify( level.eventTypes.localClientEvent, client.event );
+        }
+        
+        client.eventData = [];
+    }
+}
+
+//////////////////////////////////
+// Helper Methods
+//////////////////////////////////
+
+_IsBot( entity )
+{
+    // there already is a cgame function exists as "IsBot", for IW4, but unsure what all titles have it defined,
+    // so we are defining it here
+    return IsDefined( entity.pers["isBot"] ) && entity.pers["isBot"];
+}
+
+_SetDvarIfUninitialized( dvarName, dvarValue )
+{
+    [[level.overrideMethods[level.commonFunctions.setDvar]]]( dvarName, dvarValue );
+}
+
+NotImplementedFunction( a, b, c, d, e, f ) 
+{
+    LogWarning( "Function not implemented" );
+}
+
+// Not every game can output to console or even game log.
+// Adds a very basic logging system that every
+// game specific script can extend.accumulate
+// Logging to dvars used as example.
+InitializeLogger()
+{
+    level.logger._logger = [];
+    RegisterLogger( ::Log2Dvar );
+    RegisterLogger( ::Log2IngamePrint );
+    level.logger.debug = ::LogDebug;
+    level.logger.error = ::LogError;
+    level.logger.warning = ::LogWarning;
+}
+
+_Log( LogLevel, message )
+{
+    for( i = 0; i < level.logger._logger.size; i++ )
+    {
+        [[level.logger._logger[i]]]( LogLevel, message );
+    }
+}
+
+LogDebug( message )
+{
+    if ( level.iw4madminIntegrationDebug )
+    {
+        _Log( "debug", level.eventBus.gamename + ": " + message );
+    }
+}
+
+LogError( message )
+{
+    _Log( "error", message );
+}
+
+LogWarning( message )
+{
+    _Log( "warning", message );
+}
+
+Log2Dvar( LogLevel, message )
+{
+    switch ( LogLevel )
+    {
+        case "debug":
+            SetDvar( "sv_iw4madmin_last_debug", message );
+            break;
+        case "error":
+            SetDvar( "sv_iw4madmin_last_error", message );
+            break;
+        case "warning":
+            SetDvar( "sv_iw4madmin_last_warning", message );
+            break;
+    }
+}
+
+Log2IngamePrint( LogLevel, message )
+{
+    switch ( LogLevel )
+    {
+        case "debug":
+            IPrintLn( "[DEBUG] " + message );
+            break;
+        case "error":
+            IPrintLn( "[ERROR] " + message );
+            break;
+        case "warning":
+            IPrintLn( "[WARN] " + message );
+            break;
+    }
+}
+
+RegisterLogger( logger )
+{
+    level.logger._logger[level.logger._logger.size] = logger;
+}
+
+RequestClientMeta( metaKey )
+{
+    getClientMetaEvent = BuildEventRequest( true, level.eventTypes.clientDataRequested, "Meta", self, metaKey );
+    level thread QueueEvent( getClientMetaEvent, level.eventTypes.clientDataRequested, self );
+}
+
+RequestClientBasicData()
+{
+    getClientDataEvent = BuildEventRequest( true, level.eventTypes.clientDataRequested, "None", self, "" );
+    level thread QueueEvent( getClientDataEvent, level.eventTypes.clientDataRequested, self );
+}
+
+IncrementClientMeta( metaKey, incrementValue, clientId )
+{
+    SetClientMeta( metaKey, incrementValue, clientId, "increment" );
+}
+
+DecrementClientMeta( metaKey, decrementValue, clientId )
+{
+    SetClientMeta( metaKey, decrementValue, clientId, "decrement" );
+}
+
+GenerateJoinTeamString( isSpectator ) 
+{
+    team = self.team;
+
+    if ( IsDefined( self.joining_team ) )
+    {
+        team = self.joining_team;
+    }
+    else
+    {
+        if ( isSpectator || !IsDefined( team ) ) 
+        {
+            team = "spectator";
+        }
+    }
+
+    guid = self GetXuid();
+
+    if ( guid == "0" )
+    {
+        guid = self.guid;
+    }
+
+    if ( !IsDefined( guid ) || guid == "0" )
+    {
+        guid = "undefined";
+    }
+
+    return "JT;" + guid + ";" + self getEntityNumber() + ";" + team + ";" + self.name + "\n";
+}
+
+SetClientMeta( metaKey, metaValue, clientId, direction )
+{
+    data = "key=" + metaKey + "|value=" + metaValue;
+    clientNumber = -1;
+
+    if ( IsDefined ( clientId ) )
+    {
+        data = data + "|clientId=" + clientId;
+        clientNumber = -1;
+    }
+
+    if ( IsDefined( direction ) )
+    {
+        data = data + "|direction=" + direction;
+    }
+
+    if ( IsPlayer( self ) )
+    {
+        clientNumber = self getEntityNumber();
+    }
+
+    setClientMetaEvent = BuildEventRequest( true, level.eventTypes.setClientDataRequested, "Meta", clientNumber, data );
+    level thread QueueEvent( setClientMetaEvent, level.eventTypes.setClientDataRequested, self );
+}
+
+SaveTrackingMetrics()
+{
+    if ( !IsDefined( self.persistentClientId ) )
+    {
+        return;
+    }
+
+    LogDebug( "Saving tracking metrics for " + self.persistentClientId );
+    
+    if ( !IsDefined( self.lastShotCount ) )
+    {
+        self.lastShotCount = 0;
+    }
+
+    currentShotCount = self [[level.overrideMethods["GetTotalShotsFired"]]]();
+    change = currentShotCount - self.lastShotCount;
+    self.lastShotCount = currentShotCount;
+
+    LogDebug( "Total Shots Fired increased by " + change );
+
+    if ( !IsDefined( change ) )
+    {
+        change = 0;
+    }
+    
+    if ( change == 0 )
+    {
+        return;
+    }
+
+    IncrementClientMeta( "TotalShotsFired", change, self.persistentClientId );
+}
+
+BuildEventRequest( responseExpected, eventType, eventSubtype, entOrId, data ) 
+{
+    if ( !IsDefined( data ) )
+    {
+        data = "";
+    }
+    
+    if ( !IsDefined( eventSubtype ) )
+    {
+        eventSubtype = "None";
+    }
+
+    if ( IsPlayer( entOrId ) )
+    {
+        entOrId = entOrId getEntityNumber();
+    }
+    
+    request = "0";
+    
+    if ( responseExpected ) 
+    {
+        request = "1";
+    }
+  
+    request = request + ";" + eventType + ";" + eventSubtype + ";" + entOrId + ";" + data;
+    return request;
+}
+
+MonitorBus()
+{
+    level endon( "game_ended" );
+
+    for( ;; )
+    {
+        wait ( 0.1 );
+        
+        // check to see if IW4MAdmin is ready to receive more data
+        if ( getDvar( level.eventBus.inVar ) == "" ) 
+        {
+            level notify( "bus_ready" );
+        }
+        
+        eventString = getDvar( level.eventBus.outVar );
+        
+        if ( eventString == "" ) 
+        {
+            continue;
+        }
+        LogDebug( "-> " + eventString );
+        
+        NotifyClientEvent( strtok( eventString, ";" ) );
+        
+        SetDvar( level.eventBus.outVar, "" );
+    }
+}
+
+QueueEvent( request, eventType, notifyEntity ) 
+{
+    level endon( "game_ended" );
+
+    start = GetTime();
+    maxWait = level.eventBus.timeout * 1000; // 30 seconds
+    timedOut = "";
+   
+    while ( GetDvar( level.eventBus.inVar ) != "" && ( GetTime() - start ) < maxWait )
+    {
+        level [[level.overrideMethods["waittill_notify_or_timeout"]]]( "bus_ready", 1 );
+        
+        if ( GetDvar( level.eventBus.inVar ) != "" )
+        {
+            LogDebug( "A request is already in progress..." );
+            timedOut = "set";
+            continue;
+        }
+        
+        timedOut = "unset";
+    }
+   
+    if ( timedOut == "set")
+    {
+        LogDebug( "Timed out waiting for response..." );
+        
+        if ( IsDefined( notifyEntity ) )
+        {
+            notifyEntity NotifyClientEventTimeout( eventType );
+        }
+        
+        SetDvar( level.eventBus.inVar, "" );
+
+        return;
+    }
+    
+    LogDebug("<- " + request );
+    
+    SetDvar( level.eventBus.inVar, request );
+}
+
+ParseDataString( data ) 
+{
+    if ( !IsDefined( data ) )
+    {
+        LogDebug( "No data to parse" );
+        return [];
+    }
+    
+    dataParts = strtok( data, "|" );
+    dict = [];
+    
+    for ( i = 0; i < dataParts.size; i++ )
+    {
+        part = dataParts[i];
+        splitPart = strtok( part, "=" );
+        key = splitPart[0];
+        value = splitPart[1];
+        dict[key] = value;
+        dict[i] = key;
+    }
+    
+    return dict;
+}
+
+NotifyClientEventTimeout( eventType ) 
+{
+    // todo: make this actual eventing
+    if ( eventType == level.eventTypes.clientDataRequested )
+    {
+        self.pers["clientData"].state = level.eventBus.timeoutKey;
+    }
+}
+
+NotifyClientEvent( eventInfo )
+{
+    origin = getPlayerFromClientNum( int( eventInfo[3] ) );
+    target = getPlayerFromClientNum( int( eventInfo[4] ) );
+    
+    event = spawnstruct();
+    event.type = eventInfo[1];
+    event.subtype = eventInfo[2];
+    event.data = eventInfo[5];
+    event.origin = origin;
+    event.target = target;
+    
+    if ( IsDefined( event.data ) )
+    {
+        LogDebug( "NotifyClientEvent->" + event.data );
+    }
+    
+    if ( int( eventInfo[3] ) != -1 && !IsDefined( origin ) )
+    {
+        LogDebug( "origin is null but the slot id is " + int( eventInfo[3] ) );
+    }
+    if ( int( eventInfo[4] ) != -1 && !IsDefined( target ) )
+    {
+        LogDebug( "target is null but the slot id is " + int( eventInfo[4] ) );
+    }
+
+    if ( IsDefined( target ) )
+    {
+        client = event.target;
+    }
+    else if ( IsDefined( origin ) )
+    {
+        client = event.origin;
+    }
+    else
+    {
+        LogDebug( "Neither origin or target are set but we are a Client Event, aborting" );
+        
+        return;
+    }
+    
+    client.event = event;
+    level notify( level.eventTypes.localClientEvent, client );
+}
+
+GetPlayerFromClientNum( clientNum )
+{
+    if ( clientNum < 0 )
+    {
+        return undefined;
+    }
+    
+    for ( i = 0; i < level.players.size; i++ )
+    {
+        if ( level.players[i] getEntityNumber() == clientNum )
+        {
+            return level.players[i];
+        }
+    }
+    
+    return undefined;
+}
+
+AddClientCommand( commandName, shouldRunAsTarget, callback, shouldOverwrite )
+{
+    if ( IsDefined( level.clientCommandCallbacks[commandName] ) && IsDefined( shouldOverwrite ) && !shouldOverwrite ) 
+    {
+        return;
+    }
+    
+    level.clientCommandCallbacks[commandName] = callback;
+    level.clientCommandRusAsTarget[commandName] = shouldRunAsTarget == true; //might speed up things later in case someone gives us a string or number instead of a boolean
+}
+
+//////////////////////////////////
+// Event Handlers
+/////////////////////////////////
+
+OnClientDataReceived( event )
+{
+    event.data = ParseDataString( event.data );
+    clientData = self.pers[level.clientDataKey];
+
+    if ( event.subtype == "Fail" ) 
+    {
+        LogDebug( "Received fail response" );
+        clientData.state = level.eventBus.failKey;
+        return;
+    }
+
+    if ( event.subtype == "Meta" )
+    {
+        if ( !IsDefined( clientData.meta ) )
+        {
+            clientData.meta = [];
+        }
+        
+        metaKey = event.data[0];
+        clientData.meta[metaKey] = event.data[metaKey];
+
+ 	    LogDebug( "Meta Key=" + metaKey + ", Meta Value=" + event.data[metaKey] );
+        
+        return;
+    }
+    
+    clientData.permissionLevel = event.data["level"];
+    clientData.clientId = event.data["clientId"];
+    clientData.lastConnection = event.data["lastConnection"];
+    clientData.tag = event.data["tag"];
+    clientData.performance = event.data["performance"];
+    clientData.state = "complete";
+    self.persistentClientId = event.data["clientId"];
+
+    self thread DisplayWelcomeData();
+}
+
+OnExecuteCommand( event ) 
+{
+    data = ParseDataString( event.data );
+    response = "";
+    
+    command = level.clientCommandCallbacks[event.subtype];
+    runAsTarget = level.clientCommandRusAsTarget[event.subtype];
+    executionContextEntity = event.origin;
+    
+    if ( runAsTarget ) 
+    {
+        executionContextEntity = event.target;
+    }
+    
+    if ( IsDefined( command ) ) 
+    {
+        response = executionContextEntity [[command]]( event, data );
+    }
+    else
+    {
+        LogDebug( "Unknown Client command->" +  event.subtype );
+    }
+    
+    // send back the response to the origin, but only if they're not the target
+    if ( IsDefined( response ) && response != "" && IsPlayer( event.origin ) && event.origin != event.target ) 
+    {
+        event.origin IPrintLnBold( response );
+    }
+}
+
+OnSetClientDataCompleted( event )
+{
+    // IW4MAdmin let us know it persisted (success or fail)
+    LogDebug( "Set Client Data -> subtype = " + event.subType + " status = " + event.data["status"] );
+}

GameFiles/GameInterface/_integration_iw4x.gsc

@@ -0,0 +1,590 @@
+#include common_scripts\iw4x_utility;
+
+Init()
+{
+    level.eventBus.gamename = "IW4";
+
+    level thread Setup();
+}
+
+Setup()
+{
+    level endon( "game_ended" );
+    
+    // it's possible that the notify type has not been defined yet so we have to hard code it 
+    level waittill( "IntegrationBootstrapInitialized" );
+    
+    scripts\_integration_base::RegisterLogger( ::Log2Console );
+    
+    level.overrideMethods["GetTotalShotsFired"]                                    = ::GetTotalShotsFired;
+    level.overrideMethods[level.commonFunctions.setDvar]                           = ::_SetDvarIfUninitialized;
+    level.overrideMethods["waittill_notify_or_timeout"]                            = ::_waittill_notify_or_timeout;
+    level.overrideMethods[level.commonFunctions.changeTeam]                        = ::ChangeTeam;
+    level.overrideMethods[level.commonFunctions.getTeamCounts]                     = ::CountPlayers;
+    level.overrideMethods[level.commonFunctions.getMaxClients]                     = ::GetMaxClients;
+    level.overrideMethods[level.commonFunctions.getTeamBased]                      = ::GetTeamBased;
+    level.overrideMethods[level.commonFunctions.getClientTeam]                     = ::GetClientTeam;
+    level.overrideMethods[level.commonFunctions.getClientKillStreak]               = ::GetClientKillStreak;
+    level.overrideMethods[level.commonFunctions.backupRestoreClientKillStreakData] = ::BackupRestoreClientKillStreakData;
+    level.overrideMethods[level.commonFunctions.waitTillAnyTimeout]                = ::WaitTillAnyTimeout;
+    
+    RegisterClientCommands();
+    
+    level notify( level.notifyTypes.gameFunctionsInitialized );
+    
+    if ( GetDvarInt( "sv_iw4madmin_integration_enabled" ) != 1 )
+    {
+        return;
+    }
+    
+    level thread OnPlayerConnect();
+}
+
+OnPlayerConnect()
+{
+    level endon ( "game_ended" );
+
+    for ( ;; )
+    {
+        level waittill( "connected", player );
+        
+        if ( scripts\_integration_base::_IsBot( player ) ) 
+        {
+            // we don't want to track bots
+            continue;    
+        }
+        
+        player thread SetPersistentData();
+        player thread WaitForClientEvents();
+    }
+}
+
+RegisterClientCommands() 
+{
+    scripts\_integration_base::AddClientCommand( "GiveWeapon",     true,  ::GiveWeaponImpl );
+    scripts\_integration_base::AddClientCommand( "TakeWeapons",    true,  ::TakeWeaponsImpl );
+    scripts\_integration_base::AddClientCommand( "SwitchTeams",    true,  ::TeamSwitchImpl );
+    scripts\_integration_base::AddClientCommand( "Hide",           false, ::HideImpl );
+    scripts\_integration_base::AddClientCommand( "Alert",          true,  ::AlertImpl );
+    scripts\_integration_base::AddClientCommand( "Goto",           false, ::GotoImpl );
+    scripts\_integration_base::AddClientCommand( "Kill",           true,  ::KillImpl );
+    scripts\_integration_base::AddClientCommand( "SetSpectator",   true,  ::SetSpectatorImpl );
+    scripts\_integration_base::AddClientCommand( "LockControls",   true,  ::LockControlsImpl ); 
+    scripts\_integration_base::AddClientCommand( "PlayerToMe",     true,  ::PlayerToMeImpl );
+    scripts\_integration_base::AddClientCommand( "NoClip",         false, ::NoClipImpl );
+}
+
+WaitForClientEvents()
+{
+    self endon( "disconnect" );
+    
+    // example of requesting a meta value
+    lastServerMetaKey = "LastServerPlayed";
+    // self scripts\_integration_base::RequestClientMeta( lastServerMetaKey );
+
+    for ( ;; )
+    {
+        self waittill( level.eventTypes.localClientEvent, event );
+
+	    scripts\_integration_base::LogDebug( "Received client event " + event.type );
+        
+        if ( event.type == level.eventTypes.clientDataReceived && event.data[0] == lastServerMetaKey )
+        {
+            clientData = self.pers[level.clientDataKey];
+            lastServerPlayed = clientData.meta[lastServerMetaKey];
+        }
+    }
+}
+
+GetMaxClients()
+{
+    return level.maxClients;
+}
+
+GetTeamBased()
+{
+    return level.teamBased;
+}
+
+CountPlayers()
+{
+    return maps\mp\gametypes\_teams::CountPlayers();
+}
+
+GetClientTeam()
+{
+    if ( IsDefined( self.pers["team"] ) && self.pers["team"] == "allies" )
+    {
+        return "allies";
+    }
+    
+    else if ( IsDefined( self.pers["team"] ) && self.pers["team"] == "axis" )
+    {
+        return "axis";
+    }
+    
+    else
+    {
+        return "none";
+    }
+}
+
+GetClientKillStreak()
+{
+    return int( self.pers["cur_kill_streak"] );
+}
+
+BackupRestoreClientKillStreakData( restore ) 
+{
+    if ( restore )
+    {
+        foreach ( index, streakStruct in self.pers["killstreaks_backup"] )
+        {
+		    self.pers["killstreaks"][index] =  self.pers["killstreaks_backup"][index];
+        }
+    }
+
+    else 
+    {
+        self.pers["killstreaks_backup"] = [];
+        
+        foreach ( index, streakStruct in self.pers["killstreaks"] )
+        {
+            self.pers["killstreaks_backup"][index] = self.pers["killstreaks"][index];
+        }
+    }
+}
+
+WaitTillAnyTimeout( timeOut, string1, string2, string3, string4, string5 )
+{
+    return common_scripts\utility::waittill_any_timeout( timeOut, string1, string2, string3, string4, string5 );
+}
+
+ChangeTeam( team )
+{
+    switch ( team )
+    {
+        case "allies":
+            self [[level.allies]]();
+            break;
+    
+        case "axis":
+            self [[level.axis]]();
+            break;
+
+        case "spectator":
+            self [[level.spectator]]();
+            break;
+    }
+}
+
+GetTotalShotsFired()
+{
+    return maps\mp\_utility::getPlayerStat( "mostshotsfired" );
+}
+
+_SetDvarIfUninitialized( dvar, value )
+{
+    SetDvarIfUninitialized( dvar, value );
+}
+
+_waittill_notify_or_timeout( _notify, timeout )
+{
+    common_scripts\utility::waittill_notify_or_timeout( _notify, timeout );
+}
+
+Log2Console( logLevel, message ) 
+{
+    PrintConsole( "[" + logLevel + "] " + message + "\n" );
+}
+
+//////////////////////////////////
+// GUID helpers
+/////////////////////////////////
+
+SetPersistentData() 
+{
+    self endon( "disconnect" );
+    
+    guidHigh = self GetPlayerData( "bests", "none" ); 
+    guidLow = self GetPlayerData( "awards", "none" );
+    persistentGuid = guidHigh + "," + guidLow;
+    guidIsStored = guidHigh != 0 && guidLow != 0;
+     
+    if ( guidIsStored )
+    {
+        // give IW4MAdmin time to collect IP
+        wait( 15 );
+        scripts\_integration_base::LogDebug( "Uploading persistent guid " + persistentGuid );
+        scripts\_integration_base::SetClientMeta( "PersistentClientGuid", persistentGuid );
+        return;
+    }
+    
+    guid = self SplitGuid();
+    
+    scripts\_integration_base::LogDebug( "Persisting client guid " + guidHigh + "," + guidLow );
+    
+    self SetPlayerData( "bests", "none", guid["high"] );
+    self SetPlayerData( "awards", "none", guid["low"] );
+}
+
+SplitGuid()
+{
+    guid = self GetGuid();
+    
+    if ( isDefined( self.guid ) )
+    {
+        guid = self.guid;
+    }
+    
+    firstPart = 0;
+    secondPart = 0;
+    stringLength = 17;
+    firstPartExp = 0;
+    secondPartExp = 0;
+    
+    for ( i = stringLength - 1; i > 0; i-- )
+    {
+        char = GetSubStr( guid, i - 1, i );
+        if ( char == "" ) 
+        {
+            char = "0";
+        }
+        
+        if ( i > stringLength / 2 )
+        {
+            value = GetIntForHexChar( char );
+            power = Pow( 16, secondPartExp );
+            secondPart = secondPart + ( value * power );
+            secondPartExp++;
+        }   
+        else
+        {
+            value = GetIntForHexChar( char );
+            power = Pow( 16, firstPartExp );
+            firstPart = firstPart + ( value * power );
+            firstPartExp++;
+        }
+    }
+    
+    split = [];
+    split["low"] = int( secondPart );
+    split["high"] = int( firstPart );
+
+    return split;
+}
+
+Pow( num, exponent )
+{
+    result = 1;
+    while( exponent != 0 )
+    {
+        result = result * num;
+        exponent--;
+    }
+    
+    return result;
+}
+
+GetIntForHexChar( char )
+{
+    char = ToLower( char );
+    // generated by co-pilot because I can't be bothered to make it more "elegant"
+    switch( char )
+    {
+        case "0":
+            return 0;
+        case "1":
+            return 1;
+        case "2":
+            return 2;
+        case "3":
+            return 3;
+        case "4":
+            return 4;
+        case "5":
+            return 5;
+        case "6":
+            return 6;
+        case "7":
+            return 7;
+        case "8":
+            return 8;
+        case "9":
+            return 9;
+        case "a":
+            return 10;
+        case "b":
+            return 11;
+        case "c":
+            return 12;
+        case "d":
+            return 13;
+        case "e":
+            return 14;
+        case "f":
+            return 15;
+        default:
+            return 0;
+    }
+}
+
+//////////////////////////////////
+// Command Implementations
+/////////////////////////////////
+
+GiveWeaponImpl( event, data )
+{
+    if ( !IsAlive( self ) )
+    {
+        return self.name + "^7 is not alive";
+    }
+    
+    self IPrintLnBold( "You have been given a new weapon" );
+    self GiveWeapon( data["weaponName"] );
+    self SwitchToWeapon( data["weaponName"] );
+    
+    return self.name + "^7 has been given ^5" + data["weaponName"]; 
+}
+
+TakeWeaponsImpl()
+{
+    if ( !IsAlive( self ) )
+    {
+        return self.name + "^7 is not alive";
+    }
+    
+    self TakeAllWeapons();
+    self IPrintLnBold( "All your weapons have been taken" );
+    
+    return "Took weapons from " + self.name;
+}
+
+TeamSwitchImpl()
+{
+    if ( !IsAlive( self ) )
+    {
+        return self + "^7 is not alive";
+    }
+    
+    team = level.allies;
+    
+    if ( self.team == "allies" ) 
+    {
+        team = level.axis;
+    }
+    
+    self IPrintLnBold( "You are being team switched" );
+    wait( 2 );
+    self [[team]]();
+
+    return self.name + "^7 switched to " + self.team;
+}
+
+LockControlsImpl()
+{
+    if ( !IsAlive( self ) )
+    {
+        return self.name + "^7 is not alive";
+    }
+
+    if ( !IsDefined ( self.isControlLocked ) )
+    {
+        self.isControlLocked = false;
+    }
+
+    if ( !self.isControlLocked )
+    {
+        self freezeControls( true );
+        self God();
+        self Hide();
+
+        info = [];
+        info[ "alertType" ] = "Alert!";
+        info[ "message" ] = "You have been frozen!";
+        
+        self AlertImpl( undefined, info );
+
+        self.isControlLocked = true;
+        
+        return self.name + "\'s controls are locked";
+    }
+    else
+    {
+        self freezeControls( false );
+        self God();
+        self Show();
+
+        self.isControlLocked = false;
+
+        return self.name + "\'s controls are unlocked";
+    }
+}
+
+NoClipImpl()
+{
+    if ( !IsAlive( self ) )
+    {
+        self IPrintLnBold( "You are not alive" );
+        return;
+    }
+    
+    if ( !IsDefined ( self.isNoClipped ) )
+    {
+        self.isNoClipped = false;
+    }
+
+    if ( !self.isNoClipped )
+    {
+        self SetClientDvar( "sv_cheats", 1 );
+        self SetClientDvar( "cg_thirdperson", 1 );
+        self SetClientDvar( "sv_cheats", 0 );
+        
+        self God();
+        self Noclip();
+        self Hide();
+        
+        self.isNoClipped = true;
+        
+        self IPrintLnBold( "NoClip enabled" );
+    }
+    else
+    {
+        self SetClientDvar( "sv_cheats", 1 );
+        self SetClientDvar( "cg_thirdperson", 0 );
+        self SetClientDvar( "sv_cheats", 0 );
+        
+        self God();
+        self Noclip();
+        self Show();
+        
+        self.isNoClipped = false;
+        
+        self IPrintLnBold( "NoClip disabled" );
+    }
+}
+
+HideImpl()
+{
+    if ( !IsAlive( self ) )
+    {
+        self IPrintLnBold( "You are not alive" );
+        return;
+    }
+    
+    if ( !IsDefined ( self.isHidden ) )
+    {
+        self.isHidden = false;
+    }
+
+    if ( !self.isHidden )
+    {
+        self SetClientDvar( "sv_cheats", 1 );
+        self SetClientDvar( "cg_thirdperson", 1 );
+        self SetClientDvar( "sv_cheats", 0 );
+        
+        self God();
+        self Hide();
+        
+        self.isHidden = true;
+        
+        self IPrintLnBold( "Hide enabled" );
+    }
+    else
+    {
+        self SetClientDvar( "sv_cheats", 1 );
+        self SetClientDvar( "cg_thirdperson", 0 );
+        self SetClientDvar( "sv_cheats", 0 );
+        
+        self God();
+        self Show();
+        
+        self.isHidden = false;
+        
+        self IPrintLnBold( "Hide disabled" );
+    }
+}
+
+AlertImpl( event, data )
+{
+    if ( level.eventBus.gamename == "IW4" ) 
+    {
+        self thread maps\mp\gametypes\_hud_message::oldNotifyMessage( data["alertType"], data["message"], "compass_waypoint_target", ( 1, 0, 0 ), "ui_mp_nukebomb_timer", 7.5 );
+    }
+
+    return "Sent alert to " + self.name; 
+}
+
+GotoImpl( event, data )
+{
+    if ( IsDefined( event.target ) )
+    {
+        return self GotoPlayerImpl( event.target );
+    }
+    else
+    {
+        return self GotoCoordImpl( data );
+    }
+}
+
+GotoCoordImpl( data )
+{
+    if ( !IsAlive( self ) )
+    {
+        self IPrintLnBold( "You are not alive" );
+        return;
+    }
+
+    position = ( int( data["x"] ), int( data["y"] ), int( data["z"]) );
+    self SetOrigin( position );
+    self IPrintLnBold( "Moved to " + "("+ position[0] + "," + position[1] + "," + position[2] + ")" );
+}
+
+GotoPlayerImpl( target )
+{
+    if ( !IsAlive( target ) )
+    {
+        self IPrintLnBold( target.name + " is not alive" );
+        return;
+    }
+
+    self SetOrigin( target GetOrigin() );
+    self IPrintLnBold( "Moved to " + target.name );
+}
+
+PlayerToMeImpl( event )
+{
+    if ( !IsAlive( self ) )
+    {
+        return self.name + " is not alive";
+    }
+
+    self SetOrigin( event.origin GetOrigin() );
+    return "Moved here " + self.name;    
+}
+
+KillImpl()
+{
+    if ( !IsAlive( self ) )
+    {
+        return self.name + " is not alive";
+    }
+
+    self Suicide();
+    self IPrintLnBold( "You were killed by " + self.name );
+
+    return "You killed " + self.name;
+}
+
+SetSpectatorImpl()
+{
+    if ( self.pers["team"] == "spectator" ) 
+    {
+        return self.name + " is already spectating";
+    }
+    
+    self [[level.spectator]]();
+    self IPrintLnBold( "You have been moved to spectator" );
+    
+    return self.name + " has been moved to spectator";
+}

GameFiles/GameInterface/_integration_iw5.gsc

@@ -0,0 +1,501 @@
+#include common_scripts\utility;
+
+Init()
+{
+    level.eventBus.gamename = "IW5";
+
+    level thread Setup();
+}
+
+Setup()
+{
+    level endon( "game_ended" );
+    
+    // it's possible that the notify type has not been defined yet so we have to hard code it 
+    level waittill( "IntegrationBootstrapInitialized" );
+    
+    scripts\mp\_integration_base::RegisterLogger( ::Log2Console );
+    
+    level.overrideMethods["GetTotalShotsFired"] = ::GetTotalShotsFired;
+    level.overrideMethods["SetDvarIfUninitialized"] = ::_SetDvarIfUninitialized;
+    level.overrideMethods["waittill_notify_or_timeout"] = ::_waittill_notify_or_timeout;
+    
+    RegisterClientCommands();
+    
+    level notify( level.notifyTypes.gameFunctionsInitialized );
+    
+    if ( GetDvarInt( "sv_iw4madmin_integration_enabled" ) != 1 )
+    {
+        return;
+    }
+    
+    level thread OnPlayerConnect();
+}
+
+OnPlayerConnect()
+{
+    level endon ( "game_ended" );
+
+    for ( ;; )
+    {
+        level waittill( "connected", player );
+        
+        if ( scripts\mp\_integration_base::_IsBot( player ) ) 
+        {
+            // we don't want to track bots
+            continue;    
+        }
+        
+        player thread SetPersistentData();
+        player thread WaitForClientEvents();
+    }
+}
+
+RegisterClientCommands() 
+{
+    scripts\mp\_integration_base::AddClientCommand( "GiveWeapon",     true,  ::GiveWeaponImpl );
+    scripts\mp\_integration_base::AddClientCommand( "TakeWeapons",    true,  ::TakeWeaponsImpl );
+    scripts\mp\_integration_base::AddClientCommand( "SwitchTeams",    true,  ::TeamSwitchImpl );
+    scripts\mp\_integration_base::AddClientCommand( "Hide",           false, ::HideImpl );
+    scripts\mp\_integration_base::AddClientCommand( "Alert",          true,  ::AlertImpl );
+    scripts\mp\_integration_base::AddClientCommand( "Goto",           false, ::GotoImpl );
+    scripts\mp\_integration_base::AddClientCommand( "Kill",           true,  ::KillImpl );
+    scripts\mp\_integration_base::AddClientCommand( "SetSpectator",   true,  ::SetSpectatorImpl );
+    scripts\mp\_integration_base::AddClientCommand( "LockControls",   true,  ::LockControlsImpl ); 
+    scripts\mp\_integration_base::AddClientCommand( "PlayerToMe",     true,  ::PlayerToMeImpl );
+    scripts\mp\_integration_base::AddClientCommand( "NoClip",         false, ::NoClipImpl );
+}
+
+WaitForClientEvents()
+{
+    self endon( "disconnect" );
+    
+    // example of requesting a meta value
+    lastServerMetaKey = "LastServerPlayed";
+    // self scripts\mp\_integration_base::RequestClientMeta( lastServerMetaKey );
+
+    for ( ;; )
+    {
+        self waittill( level.eventTypes.localClientEvent, event );
+
+	    scripts\mp\_integration_base::LogDebug( "Received client event " + event.type );
+        
+        if ( event.type == level.eventTypes.clientDataReceived && event.data[0] == lastServerMetaKey )
+        {
+            clientData = self.pers[level.clientDataKey];
+            lastServerPlayed = clientData.meta[lastServerMetaKey];
+        }
+    }
+}
+
+GetTotalShotsFired()
+{
+    return maps\mp\_utility::getPlayerStat( "mostshotsfired" );
+}
+
+_SetDvarIfUninitialized( dvar, value )
+{
+    SetDvarIfUninitialized( dvar, value );
+}
+
+_waittill_notify_or_timeout( _notify, timeout )
+{
+    common_scripts\utility::waittill_notify_or_timeout( _notify, timeout );
+}
+
+Log2Console( logLevel, message ) 
+{
+    Print( "[" + logLevel + "] " + message + "\n" );
+}
+
+//////////////////////////////////
+// GUID helpers
+/////////////////////////////////
+
+SetPersistentData() 
+{
+    self endon( "disconnect" );
+    
+    guidHigh = self GetPlayerData( "bests", "none" ); 
+    guidLow = self GetPlayerData( "awards", "none" );
+    persistentGuid = guidHigh + "," + guidLow;
+    guidIsStored = guidHigh != 0 && guidLow != 0;
+     
+    if ( guidIsStored )
+    {
+        // give IW4MAdmin time to collect IP
+        wait( 15 );
+        scripts\mp\_integration_base::LogDebug( "Uploading persistent guid " + persistentGuid );
+        scripts\mp\_integration_base::SetClientMeta( "PersistentClientGuid", persistentGuid );
+        return;
+    }
+    
+    guid = self SplitGuid();
+    
+    scripts\mp\_integration_base::LogDebug( "Persisting client guid " + guidHigh + "," + guidLow );
+    
+    self SetPlayerData( "bests", "none", guid["high"] );
+    self SetPlayerData( "awards", "none", guid["low"] );
+}
+
+SplitGuid()
+{
+    guid = self GetGuid();
+    
+    if ( isDefined( self.guid ) )
+    {
+        guid = self.guid;
+    }
+    
+    firstPart = 0;
+    secondPart = 0;
+    stringLength = 17;
+    firstPartExp = 0;
+    secondPartExp = 0;
+    
+    for ( i = stringLength - 1; i > 0; i-- )
+    {
+        char = GetSubStr( guid, i - 1, i );
+        if ( char == "" ) 
+        {
+            char = "0";
+        }
+        
+        if ( i > stringLength / 2 )
+        {
+            value = GetIntForHexChar( char );
+            power = Pow( 16, secondPartExp );
+            secondPart = secondPart + ( value * power );
+            secondPartExp++;
+        }   
+        else
+        {
+            value = GetIntForHexChar( char );
+            power = Pow( 16, firstPartExp );
+            firstPart = firstPart + ( value * power );
+            firstPartExp++;
+        }
+    }
+    
+    split = [];
+    split["low"] = int( secondPart );
+    split["high"] = int( firstPart );
+
+    return split;
+}
+
+Pow( num, exponent )
+{
+    result = 1;
+    while( exponent != 0 )
+    {
+        result = result * num;
+        exponent--;
+    }
+    
+    return result;
+}
+
+GetIntForHexChar( char )
+{
+    char = ToLower( char );
+    // generated by co-pilot because I can't be bothered to make it more "elegant"
+    switch( char )
+    {
+        case "0":
+            return 0;
+        case "1":
+            return 1;
+        case "2":
+            return 2;
+        case "3":
+            return 3;
+        case "4":
+            return 4;
+        case "5":
+            return 5;
+        case "6":
+            return 6;
+        case "7":
+            return 7;
+        case "8":
+            return 8;
+        case "9":
+            return 9;
+        case "a":
+            return 10;
+        case "b":
+            return 11;
+        case "c":
+            return 12;
+        case "d":
+            return 13;
+        case "e":
+            return 14;
+        case "f":
+            return 15;
+        default:
+            return 0;
+    }
+}
+
+//////////////////////////////////
+// Command Implementations
+/////////////////////////////////
+
+GiveWeaponImpl( event, data )
+{
+    if ( !IsAlive( self ) )
+    {
+        return self.name + "^7 is not alive";
+    }
+    
+    self IPrintLnBold( "You have been given a new weapon" );
+    self GiveWeapon( data["weaponName"] );
+    self SwitchToWeapon( data["weaponName"] );
+    
+    return self.name + "^7 has been given ^5" + data["weaponName"]; 
+}
+
+TakeWeaponsImpl()
+{
+    if ( !IsAlive( self ) )
+    {
+        return self.name + "^7 is not alive";
+    }
+    
+    self TakeAllWeapons();
+    self IPrintLnBold( "All your weapons have been taken" );
+    
+    return "Took weapons from " + self.name;
+}
+
+TeamSwitchImpl()
+{
+    if ( !IsAlive( self ) )
+    {
+        return self + "^7 is not alive";
+    }
+    
+    team = level.allies;
+    
+    if ( self.team == "allies" ) 
+    {
+        team = level.axis;
+    }
+    
+    self IPrintLnBold( "You are being team switched" );
+    wait( 2 );
+    self [[team]]();
+
+    return self.name + "^7 switched to " + self.team;
+}
+
+LockControlsImpl()
+{
+    if ( !IsAlive( self ) )
+    {
+        return self.name + "^7 is not alive";
+    }
+
+    if ( !IsDefined ( self.isControlLocked ) )
+    {
+        self.isControlLocked = false;
+    }
+
+    if ( !self.isControlLocked )
+    {
+        self freezeControls( true );
+        self God();
+        self Hide();
+
+        info = [];
+        info[ "alertType" ] = "Alert!";
+        info[ "message" ] = "You have been frozen!";
+        
+        self AlertImpl( undefined, info );
+
+        self.isControlLocked = true;
+        
+        return self.name + "\'s controls are locked";
+    }
+    else
+    {
+        self freezeControls( false );
+        self God();
+        self Show();
+
+        self.isControlLocked = false;
+
+        return self.name + "\'s controls are unlocked";
+    }
+}
+
+NoClipImpl()
+{
+    if ( !IsAlive( self ) )
+    {
+        self IPrintLnBold( "You are not alive" );
+    }
+    
+    if ( !IsDefined ( self.isNoClipped ) )
+    {
+        self.isNoClipped = false;
+    }
+
+    if ( !self.isNoClipped )
+    {
+        SetDvar( "sv_cheats", 1 );
+        self SetClientDvar( "cg_thirdperson", 1 );
+        
+        self God();
+        self Noclip();
+        self Hide();
+        SetDvar( "sv_cheats", 0 );
+        
+        self.isNoClipped = true;
+        
+        self IPrintLnBold( "NoClip enabled" );
+    }
+    else
+    {
+        SetDvar( "sv_cheats", 1 );
+        self SetClientDvar( "cg_thirdperson", 0 );
+        
+        self God();
+        self Noclip();
+        self Hide();
+        
+        SetDvar( "sv_cheats", 0 );
+        
+        self.isNoClipped = false;
+        
+        self IPrintLnBold( "NoClip disabled" );
+    }
+
+    self IPrintLnBold( "NoClip enabled" );
+}
+
+HideImpl()
+{
+    if ( !IsAlive( self ) )
+    {
+        self IPrintLnBold( "You are not alive" );
+        return;
+    }
+    
+    if ( !IsDefined ( self.isHidden ) )
+    {
+        self.isHidden = false;
+    }
+
+    if ( !self.isHidden )
+    {
+        SetDvar( "sv_cheats", 1 );
+        self SetClientDvar( "cg_thirdperson", 1 );
+        
+        self God();
+        self Hide();
+        SetDvar( "sv_cheats", 0 );
+        
+        self.isHidden = true;
+        
+        self IPrintLnBold( "Hide enabled" );
+    }
+    else
+    {
+        SetDvar( "sv_cheats", 1 );
+        self SetClientDvar( "cg_thirdperson", 0 );
+        
+        self God();
+        self Show();
+        SetDvar( "sv_cheats", 0 );
+        
+        self.isHidden = false;
+        
+        self IPrintLnBold( "Hide disabled" );
+    }
+}
+
+AlertImpl( event, data )
+{
+    if ( level.eventBus.gamename == "IW5" ) {
+        self thread maps\mp\gametypes\_hud_message::oldNotifyMessage( data["alertType"], data["message"], undefined, ( 1, 0, 0 ), "ui_mp_nukebomb_timer", 7.5 );
+    }
+
+    return "Sent alert to " + self.name; 
+}
+
+GotoImpl( event, data )
+{
+    if ( IsDefined( event.target ) )
+    {
+        return self GotoPlayerImpl( event.target );
+    }
+    else
+    {
+        return self GotoCoordImpl( data );
+    }
+}
+
+GotoCoordImpl( data )
+{
+    if ( !IsAlive( self ) )
+    {
+        self IPrintLnBold( "You are not alive" );
+        return;
+    }
+
+    position = ( int( data["x"] ), int( data["y"] ), int( data["z"]) );
+    self SetOrigin( position );
+    self IPrintLnBold( "Moved to " + "("+ position[0] + "," + position[1] + "," + position[2] + ")" );
+}
+
+GotoPlayerImpl( target )
+{
+    if ( !IsAlive( target ) )
+    {
+        self IPrintLnBold( target.name + " is not alive" );
+        return;
+    }
+
+    self SetOrigin( target GetOrigin() );
+    self IPrintLnBold( "Moved to " + target.name );
+}
+
+PlayerToMeImpl( event )
+{
+    if ( !IsAlive( self ) )
+    {
+        return self.name + " is not alive";
+    }
+
+    self SetOrigin( event.origin GetOrigin() );
+    return "Moved here " + self.name;    
+}
+
+KillImpl()
+{
+    if ( !IsAlive( self ) )
+    {
+        return self.name + " is not alive";
+    }
+
+    self Suicide();
+    self IPrintLnBold( "You were killed by " + self.name );
+
+    return "You killed " + self.name;
+}
+
+SetSpectatorImpl()
+{
+    if ( self.pers["team"] == "spectator" ) 
+    {
+        return self.name + " is already spectating";
+    }
+    
+    self [[level.spectator]]();
+    self IPrintLnBold( "You have been moved to spectator" );
+    
+    return self.name + " has been moved to spectator";
+}

GameFiles/GameInterface/_integration_shared.gsc

@@ -0,0 +1,451 @@
+
+Init()
+{
+    level thread Setup();
+}
+
+Setup()
+{
+    level endon( "game_ended" );
+    
+    level.commonFunctions.changeTeam                        = "ChangeTeam";
+    level.commonFunctions.getTeamCounts                     = "GetTeamCounts";
+    level.commonFunctions.getMaxClients                     = "GetMaxClients";
+    level.commonFunctions.getTeamBased                      = "GetTeamBased";
+    level.commonFunctions.getClientTeam                     = "GetClientTeam";
+    level.commonFunctions.getClientKillStreak               = "GetClientKillStreak";
+    level.commonFunctions.backupRestoreClientKillStreakData = "BackupRestoreClientKillStreakData";
+    level.commonFunctions.waitTillAnyTimeout                = "WaitTillAnyTimeout";
+    
+    level.overrideMethods[level.commonFunctions.changeTeam]                        = scripts\_integration_base::NotImplementedFunction;
+    level.overrideMethods[level.commonFunctions.getTeamCounts]                     = scripts\_integration_base::NotImplementedFunction;
+    level.overrideMethods[level.commonFunctions.getTeamBased]                      = scripts\_integration_base::NotImplementedFunction;
+    level.overrideMethods[level.commonFunctions.getMaxClients]                     = scripts\_integration_base::NotImplementedFunction;
+    level.overrideMethods[level.commonFunctions.getClientTeam]                     = scripts\_integration_base::NotImplementedFunction;
+    level.overrideMethods[level.commonFunctions.getClientKillStreak]               = scripts\_integration_base::NotImplementedFunction;
+    level.overrideMethods[level.commonFunctions.backupRestoreClientKillStreakData] = scripts\_integration_base::NotImplementedFunction;
+    level.overrideMethods[level.commonFunctions.waitTillAnyTimeout]                = scripts\_integration_base::NotImplementedFunction;
+    
+    // these can be overridden per game if needed
+    level.commonKeys.team1         = "allies"; 
+    level.commonKeys.team2         = "axis";
+    level.commonKeys.teamSpectator = "spectator";
+    
+    level.eventTypes.connect     = "connected";
+    level.eventTypes.disconnect  = "disconnect";
+    level.eventTypes.joinTeam    = "joined_team";
+    level.eventTypes.spawned	 = "spawned_player";
+    level.eventTypes.gameEnd     = "game_ended";
+    
+    level.iw4madminIntegrationDefaultPerformance = 200;
+    
+    if ( GetDvarInt( "sv_iw4madmin_integration_enabled" ) != 1 )
+    {
+        return;
+    }
+
+    if ( GetDvarInt( "sv_iw4madmin_autobalance" ) != 1 )
+    {
+        return;
+    }
+    
+    level thread OnPlayerConnect();
+}
+
+OnPlayerConnect()
+{
+    level endon( level.eventTypes.gameEnd );
+
+    for ( ;; )
+    {
+        level waittill( level.eventTypes.connect, player );
+
+        if ( ![[level.overrideMethods[level.commonFunctions.getTeamBased]]]() ) 
+        {
+            continue;
+        }
+        
+        teamToJoin = player GetTeamToJoin();
+        player [[level.overrideMethods[level.commonFunctions.changeTeam]]]( teamToJoin );
+        
+        player thread OnClientFirstSpawn();
+        player thread OnClientJoinedTeam();
+        player thread OnClientDisconnect();
+    }
+}
+
+OnClientDisconnect()
+{
+    level endon( level.eventTypes.gameEnd );
+    self endon( "disconnect_logic_end" );
+
+    for ( ;; )
+    {
+        self waittill( level.eventTypes.disconnect );
+        scripts\_integration_base::LogDebug( "client is disconnecting" );
+
+        OnTeamSizeChanged();
+        self notify( "disconnect_logic_end" );
+    }
+}
+
+OnClientJoinedTeam()
+{
+    self endon( level.eventTypes.disconnect );
+
+    for( ;; )
+    {
+        self waittill( level.eventTypes.joinTeam );
+
+        if ( IsDefined( self.wasAutoBalanced ) && self.wasAutoBalanced )
+        {
+            self.wasAutoBalanced = false;
+            continue;
+        }
+        
+        newTeam = self [[level.overrideMethods[level.commonFunctions.getClientTeam]]]();
+        scripts\_integration_base::LogDebug( self.name + " switched to " + newTeam );
+        
+        if ( newTeam != level.commonKeys.team1 && newTeam != level.commonKeys.team2 )
+        {
+            OnTeamSizeChanged();
+            scripts\_integration_base::LogDebug( "not force balancing " + self.name + " because they switched to spec"  );
+            continue;
+        }
+        
+        properTeam = self GetTeamToJoin();
+        if ( newTeam != properTeam )
+        {
+            self [[level.overrideMethods[level.commonFunctions.backupRestoreClientKillStreakData]]]( false );
+            self [[level.overrideMethods[level.commonFunctions.changeTeam]]]( properTeam );
+            wait ( 0.1 );
+            self [[level.overrideMethods[level.commonFunctions.backupRestoreClientKillStreakData]]]( true );
+        } 		
+    }
+}
+
+OnClientFirstSpawn()
+{
+    self endon( level.eventTypes.disconnect );
+    timeoutResult = self [[level.overrideMethods[level.commonFunctions.waitTillAnyTimeout]]]( 30, level.eventTypes.spawned );
+
+    if ( timeoutResult != "timeout" )
+    {
+       return;
+    }
+
+    scripts\_integration_base::LogDebug( "moving " + self.name + " to spectator because they did not spawn within expected duration" );
+    self [[level.overrideMethods[level.commonFunctions.changeTeam]]]( level.commonKeys.teamSpectator );
+}
+
+OnTeamSizeChanged()
+{
+    if ( level.players.size < 3 )
+    {
+        scripts\_integration_base::LogDebug( "not enough clients to autobalance" );
+        return;
+    }
+
+    if ( !IsDefined( GetSmallerTeam( 1 ) ) )
+    {
+        scripts\_integration_base::LogDebug( "teams are not unbalanced enough to auto balance" );
+        return;
+    }
+    
+    toSwap = FindClientToSwap();
+    curentTeam = toSwap [[level.overrideMethods[level.commonFunctions.getClientTeam]]]();
+    otherTeam = level.commonKeys.team1;
+
+    if ( curentTeam == otherTeam ) 
+    {
+        otherTeam = level.commonKeys.team2;
+    }
+
+    toSwap.wasAutoBalanced = true;
+    
+    if ( !IsDefined( toSwap.autoBalanceCount ) )
+    {
+        toSwap.autoBalanceCount = 1;
+    }
+    else
+    {
+        toSwap.autoBalanceCount++;
+    }
+
+    toSwap [[level.overrideMethods[level.commonFunctions.backupRestoreClientKillStreakData]]]( false );
+    scripts\_integration_base::LogDebug( "swapping " + toSwap.name + " from " + curentTeam + " to " + otherTeam );
+    toSwap [[level.overrideMethods[level.commonFunctions.changeTeam]]]( otherTeam );
+    wait ( 0.1 ); // give the killstreak on team switch clear event time to execute
+    toSwap [[level.overrideMethods[level.commonFunctions.backupRestoreClientKillStreakData]]]( true );
+}
+
+FindClientToSwap()
+{
+    smallerTeam = GetSmallerTeam( 1 );
+    teamPool = level.commonKeys.team1;
+
+    if ( IsDefined( smallerTeam ) )
+    {
+        if ( smallerTeam == teamPool )
+        {
+            teamPool = level.commonKeys.team2;
+        }
+    }
+    else
+    {
+        teamPerformances = GetTeamPerformances();
+        team1Perf = teamPerformances[level.commonKeys.team1];
+        team2Perf = teamPerformances[level.commonKeys.team2];
+        teamPool = level.commonKeys.team1;
+
+        if ( team2Perf > team1Perf )
+        {
+            teamPool = level.commonKeys.team2;
+        }
+    }
+
+    client = GetBestSwapCandidate( teamPool );
+
+    if ( !IsDefined( client ) )
+    {
+        scripts\_integration_base::LogDebug( "could not find candidate to swap teams" );
+    }
+    else
+    {
+        scripts\_integration_base::LogDebug( "best candidate to swap teams is " + client.name );
+    }
+
+    return client;
+}
+
+GetBestSwapCandidate( team )
+{
+    candidates = [];
+    maxClients = [[level.overrideMethods[level.commonFunctions.getMaxClients]]]();
+
+    for ( i = 0; i < maxClients; i++ )
+    {
+        candidates[i] = GetClosestPerformanceClientForTeam( team, candidates );
+    }
+
+    candidate = undefined;
+    
+    foundCandidate = false;
+    for ( i = 0; i < maxClients; i++ )
+    {
+        if ( !IsDefined( candidates[i] ) )
+        {
+            continue;
+        }
+
+        candidate = candidates[i];
+        candidateKillStreak = candidate [[level.overrideMethods[level.commonFunctions.getClientKillStreak]]]();
+
+        scripts\_integration_base::LogDebug( "candidate killstreak is " + candidateKillStreak );
+        
+        if ( candidateKillStreak > 3 )
+        {
+            scripts\_integration_base::LogDebug( "skipping candidate selection for " + candidate.name + " because their kill streak is too high" );
+            continue;
+        }
+
+        if ( IsDefined( candidate.autoBalanceCount ) && candidate.autoBalanceCount > 2 )
+        {
+            scripts\_integration_base::LogDebug( "skipping candidate selection for " + candidate.name + " they have been swapped too many times" );
+            continue;
+        }
+
+        foundCandidate = true;
+        break;
+    }
+
+    if ( foundCandidate )
+    {
+        return candidate;
+    }
+
+    return undefined;
+}
+
+GetClosestPerformanceClientForTeam( sourceTeam, excluded )
+{
+    if ( !IsDefined( excluded ) )
+    {
+        excluded = [];
+    }
+
+    otherTeam = level.commonKeys.team1;
+
+    if ( sourceTeam == otherTeam ) 
+    {
+        otherTeam = level.commonKeys.team2;
+    }
+
+    teamPerformances = GetTeamPerformances();
+    players = level.players;
+    choice = undefined;
+    closest = 9999999;
+
+    for ( i = 0; i < players.size; i++ )
+    {
+        isExcluded = false;
+        
+        for ( j = 0; j < excluded.size; j++ )
+        {
+            if ( excluded[j] == players[i] )
+            {
+                isExcluded = true;
+                break;
+            }
+        }
+
+        if ( isExcluded )
+        {
+            continue;
+        }
+
+        if ( players[i] [[level.overrideMethods[level.commonFunctions.getClientTeam]]]() != sourceTeam )
+        {
+            continue;
+        }
+
+        clientPerformance = players[i] GetClientPerformanceOrDefault();
+        sourceTeamNewPerformance = teamPerformances[sourceTeam] - clientPerformance;
+        otherTeamNewPerformance = teamPerformances[otherTeam] + clientPerformance;
+        candidateValue = Abs( sourceTeamNewPerformance - otherTeamNewPerformance );
+
+        scripts\_integration_base::LogDebug( "perf=" + clientPerformance + " candidateValue=" + candidateValue + " src=" + sourceTeamNewPerformance + " dst=" + otherTeamNewPerformance );
+
+        if ( !IsDefined( choice ) )
+        {
+            choice = players[i];
+            closest = candidateValue;
+        } 
+
+        else if ( candidateValue < closest )
+        {
+            scripts\_integration_base::LogDebug( candidateValue + " is the new best value ");
+            choice = players[i];
+            closest = candidateValue;
+        }
+    }
+
+    scripts\_integration_base::LogDebug( choice.name + " is the best candidate to swap" + " with closest=" + closest );
+    return choice;
+}
+
+GetTeamToJoin()
+{
+    smallerTeam = GetSmallerTeam( 1 );
+
+    if ( IsDefined( smallerTeam ) )
+    {
+        return smallerTeam;
+    }
+    
+    teamPerformances = GetTeamPerformances( self );
+    
+    if ( teamPerformances[level.commonKeys.team1] < teamPerformances[level.commonKeys.team2] )
+    {
+        scripts\_integration_base::LogDebug( "Team1 performance is lower, so selecting Team1" );
+        return level.commonKeys.team1;
+    }
+    
+    else
+    {
+        scripts\_integration_base::LogDebug( "Team2 performance is lower, so selecting Team2" );
+        return level.commonKeys.team2;
+    }
+}
+
+GetSmallerTeam( minDiff )
+{
+    teamCounts = [[level.overrideMethods[level.commonFunctions.getTeamCounts]]]();
+    team1Count = teamCounts[level.commonKeys.team1];
+    team2Count = teamCounts[level.commonKeys.team2];
+    maxClients = [[level.overrideMethods[level.commonFunctions.getMaxClients]]]();
+
+    if ( team1Count == team2Count )
+    {
+        return undefined;
+    }
+    
+    if ( team2Count == maxClients / 2 )
+    {
+        scripts\_integration_base::LogDebug( "Team2 is full, so selecting Team1" );
+        return level.commonKeys.team1;
+    }
+    
+    if ( team1Count == maxClients / 2 )
+    {
+        scripts\_integration_base::LogDebug( "Team1 is full, so selecting Team2" );
+        return level.commonKeys.team2;
+    }
+    
+    sizeDiscrepancy = Abs( team1Count - team2Count );
+    
+    if ( sizeDiscrepancy > minDiff ) 
+    {
+        scripts\_integration_base::LogDebug( "Team size differs by more than 1" );
+        
+        if ( team1Count < team2Count )
+        {
+            scripts\_integration_base::LogDebug( "Team1 is smaller, so selecting Team1" );
+            return level.commonKeys.team1;
+        }
+        
+        else
+        {
+            scripts\_integration_base::LogDebug( "Team2 is smaller, so selecting Team2" );
+            return level.commonKeys.team2;
+        }
+    }
+
+    return undefined;
+}
+
+GetTeamPerformances( ignoredClient )
+{
+    players = level.players;
+    
+    team1 = 0;
+    team2 = 0;
+    
+    for ( i = 0; i < players.size; i++ )
+    {
+        if ( IsDefined( ignoredClient ) && players[i] == ignoredClient )
+        {
+            continue;
+        }
+        
+        performance = players[i] GetClientPerformanceOrDefault();
+        clientTeam = players[i] [[level.overrideMethods[level.commonFunctions.getClientTeam]]]();
+        
+        if ( clientTeam == level.commonKeys.team1 )
+        {
+            team1 = team1 + performance;
+        }
+        else
+        {
+            team2 = team2 + performance;
+        }
+    }
+    
+    result = [];
+    result[level.commonKeys.team1] = team1;
+    result[level.commonKeys.team2] = team2;
+    return result;
+}
+
+GetClientPerformanceOrDefault()
+{
+    clientData = self.pers[level.clientDataKey];
+    performance = level.iw4madminIntegrationDefaultPerformance;
+        
+    if ( IsDefined( clientData ) && IsDefined( clientData.performance ) ) 
+    {
+        performance = int( clientData.performance );
+    }
+
+    return performance;
+}

GameFiles/GameInterface/_integration_t5.gsc

@@ -0,0 +1,522 @@
+#include common_scripts\utility;
+
+Init()
+{
+    level.eventBus.gamename = "T5";
+
+    level thread Setup();
+}
+
+Setup()
+{
+    level endon( "game_ended" );
+    
+    // it's possible that the notify type has not been defined yet so we have to hard code it 
+    level waittill( "IntegrationBootstrapInitialized" );
+    
+    scripts\mp\_integration_base::RegisterLogger( ::Log2Console );
+    
+    level.overrideMethods["GetTotalShotsFired"] = ::GetTotalShotsFired;
+    level.overrideMethods["SetDvarIfUninitialized"] = ::_SetDvarIfUninitialized;
+    level.overrideMethods["waittill_notify_or_timeout"] = ::_waittill_notify_or_timeout;
+    
+    RegisterClientCommands();
+    
+    level notify( level.notifyTypes.gameFunctionsInitialized );
+    
+    if ( GetDvarInt( "sv_iw4madmin_integration_enabled" ) != 1 )
+    {
+        return;
+    }
+    
+    level thread OnPlayerConnect();
+}
+
+OnPlayerConnect()
+{
+    level endon ( "game_ended" );
+
+    for ( ;; )
+    {
+        level waittill( "connected", player );
+        
+        if ( scripts\mp\_integration_base::_IsBot( player ) ) 
+        {
+            // we don't want to track bots
+            continue;    
+        }
+        
+        //player thread SetPersistentData();
+        player thread WaitForClientEvents();
+    }
+}
+
+RegisterClientCommands() 
+{
+    scripts\mp\_integration_base::AddClientCommand( "GiveWeapon",     true,  ::GiveWeaponImpl );
+    scripts\mp\_integration_base::AddClientCommand( "TakeWeapons",    true,  ::TakeWeaponsImpl );
+    scripts\mp\_integration_base::AddClientCommand( "SwitchTeams",    true,  ::TeamSwitchImpl );
+    scripts\mp\_integration_base::AddClientCommand( "Hide",           false, ::HideImpl );
+    scripts\mp\_integration_base::AddClientCommand( "Alert",          true,  ::AlertImpl );
+    scripts\mp\_integration_base::AddClientCommand( "Goto",           false, ::GotoImpl );
+    scripts\mp\_integration_base::AddClientCommand( "Kill",           true,  ::KillImpl );
+    scripts\mp\_integration_base::AddClientCommand( "SetSpectator",   true,  ::SetSpectatorImpl );
+    scripts\mp\_integration_base::AddClientCommand( "LockControls",   true,  ::LockControlsImpl );
+    scripts\mp\_integration_base::AddClientCommand( "PlayerToMe",     true,  ::PlayerToMeImpl );
+    scripts\mp\_integration_base::AddClientCommand( "NoClip",         false, ::NoClipImpl );
+}
+
+WaitForClientEvents()
+{
+    self endon( "disconnect" );
+    
+    // example of requesting a meta value
+    lastServerMetaKey = "LastServerPlayed";
+    // self scripts\mp\_integration_base::RequestClientMeta( lastServerMetaKey );
+
+    for ( ;; )
+    {
+        self waittill( level.eventTypes.localClientEvent, event );
+
+	    scripts\mp\_integration_base::LogDebug( "Received client event " + event.type );
+        
+        if ( event.type == level.eventTypes.clientDataReceived && event.data[0] == lastServerMetaKey )
+        {
+            clientData = self.pers[level.clientDataKey];
+            lastServerPlayed = clientData.meta[lastServerMetaKey];
+        }
+    }
+}
+
+GetTotalShotsFired()
+{
+    return maps\mp\gametypes\_persistence::statGet( "total_shots" );
+}
+
+_SetDvarIfUninitialized(dvar, value)
+{
+    maps\mp\_utility::set_dvar_if_unset(dvar, value);
+}
+
+_waittill_notify_or_timeout( msg, timer )
+{
+	self endon( msg );
+	wait( timer );
+}
+
+Log2Console( logLevel, message ) 
+{
+    Print( "[" + logLevel + "] " + message + "\n" );
+}
+
+God()
+{
+
+    if ( !IsDefined( self.godmode ) )
+    {
+        self.godmode = false;
+    }
+    
+    if (!self.godmode )
+    {
+        self enableInvulnerability();
+        self.godmode = true;
+    }
+    else
+    {
+        self.godmode = false;
+        self disableInvulnerability();
+    }
+}
+
+//////////////////////////////////
+// GUID helpers
+/////////////////////////////////
+
+/*SetPersistentData() 
+{
+    self endon( "disconnect" );
+    
+    guidHigh = self GetPlayerData( "bests", "none" ); 
+    guidLow = self GetPlayerData( "awards", "none" );
+    persistentGuid = guidHigh + "," + guidLow;
+    guidIsStored = guidHigh != 0 && guidLow != 0;
+     
+    if ( guidIsStored )
+    {
+        // give IW4MAdmin time to collect IP
+        wait( 15 );
+        scripts\mp\_integration_base::LogDebug( "Uploading persistent guid " + persistentGuid );
+        scripts\mp\_integration_base::SetClientMeta( "PersistentClientGuid", persistentGuid );
+        return;
+    }
+    
+    guid = self SplitGuid();
+    
+    scripts\mp\_integration_base::LogDebug( "Persisting client guid " + guidHigh + "," + guidLow );
+    
+    self SetPlayerData( "bests", "none", guid["high"] );
+    self SetPlayerData( "awards", "none", guid["low"] );
+}
+
+SplitGuid()
+{
+    guid = self GetGuid();
+    
+    if ( isDefined( self.guid ) )
+    {
+        guid = self.guid;
+    }
+    
+    firstPart = 0;
+    secondPart = 0;
+    stringLength = 17;
+    firstPartExp = 0;
+    secondPartExp = 0;
+    
+    for ( i = stringLength - 1; i > 0; i-- )
+    {
+        char = GetSubStr( guid, i - 1, i );
+        if ( char == "" ) 
+        {
+            char = "0";
+        }
+        
+        if ( i > stringLength / 2 )
+        {
+            value = GetIntForHexChar( char );
+            power = Pow( 16, secondPartExp );
+            secondPart = secondPart + ( value * power );
+            secondPartExp++;
+        }   
+        else
+        {
+            value = GetIntForHexChar( char );
+            power = Pow( 16, firstPartExp );
+            firstPart = firstPart + ( value * power );
+            firstPartExp++;
+        }
+    }
+    
+    split = [];
+    split["low"] = int( secondPart );
+    split["high"] = int( firstPart );
+
+    return split;
+}
+
+Pow( num, exponent )
+{
+    result = 1;
+    while( exponent != 0 )
+    {
+        result = result * num;
+        exponent--;
+    }
+    
+    return result;
+}
+
+GetIntForHexChar( char )
+{
+    char = ToLower( char );
+    // generated by co-pilot because I can't be bothered to make it more "elegant"
+    switch( char )
+    {
+        case "0":
+            return 0;
+        case "1":
+            return 1;
+        case "2":
+            return 2;
+        case "3":
+            return 3;
+        case "4":
+            return 4;
+        case "5":
+            return 5;
+        case "6":
+            return 6;
+        case "7":
+            return 7;
+        case "8":
+            return 8;
+        case "9":
+            return 9;
+        case "a":
+            return 10;
+        case "b":
+            return 11;
+        case "c":
+            return 12;
+        case "d":
+            return 13;
+        case "e":
+            return 14;
+        case "f":
+            return 15;
+        default:
+            return 0;
+    }
+}*/
+
+//////////////////////////////////
+// Command Implementations
+/////////////////////////////////
+
+GiveWeaponImpl( event, data )
+{
+    if ( !IsAlive( self ) )
+    {
+        return self.name + "^7 is not alive";
+    }
+    
+    self IPrintLnBold( "You have been given a new weapon" );
+    self GiveWeapon( data["weaponName"] );
+    self SwitchToWeapon( data["weaponName"] );
+    
+    return self.name + "^7 has been given ^5" + data["weaponName"]; 
+}
+
+TakeWeaponsImpl( event, data )
+{
+    if ( !IsAlive( self ) )
+    {
+        return self.name + "^7 is not alive";
+    }
+    
+    self TakeAllWeapons();
+    self IPrintLnBold( "All your weapons have been taken" );
+    
+    return "Took weapons from " + self.name;
+}
+
+TeamSwitchImpl( event, data )
+{
+    if ( !IsAlive( self ) )
+    {
+        return self + "^7 is not alive";
+    }
+    
+    team = level.allies;
+    
+    if ( self.team == "allies" ) 
+    {
+        team = level.axis;
+    }
+    
+    self IPrintLnBold( "You are being team switched" );
+    wait( 2 );
+    self [[team]]();
+
+    return self.name + "^7 switched to " + self.team;
+}
+
+LockControlsImpl( event, data )
+{
+    if ( !IsAlive( self ) )
+    {
+        return self.name + "^7 is not alive";
+    }
+
+    if ( !IsDefined ( self.isControlLocked ) )
+    {
+        self.isControlLocked = false;
+    }
+
+    if ( !self.isControlLocked )
+    {
+        self freezeControls( true );
+        self God();
+        self Hide();
+
+        info = [];
+        info[ "alertType" ] = "Alert!";
+        info[ "message" ] = "You have been frozen!";
+        
+        self AlertImpl( undefined, info );
+
+        self.isControlLocked = true;
+        
+        return self.name + "\'s controls are locked";
+    }
+    else
+    {
+        self freezeControls( false );
+        self God();
+        self Show();
+
+        self.isControlLocked = false;
+
+        return self.name + "\'s controls are unlocked";
+    }
+}
+
+NoClipImpl( event, data )
+{
+    /*if ( !IsAlive( self ) )
+    {
+        self IPrintLnBold( "You are not alive" );
+    }
+    
+    if ( !IsDefined ( self.isNoClipped ) )
+    {
+        self.isNoClipped = false;
+    }
+
+    if ( !self.isNoClipped )
+    {
+        self SetClientDvar( "sv_cheats", 1 );
+        self SetClientDvar( "cg_thirdperson", 1 );
+        self SetClientDvar( "sv_cheats", 0 );
+        
+        self God();
+        self Noclip();
+        self Hide();
+        
+        self.isNoClipped = true;
+        
+        self IPrintLnBold( "NoClip enabled" );
+    }
+    else
+    {
+        self SetClientDvar( "sv_cheats", 1 );
+        self SetClientDvar( "cg_thirdperson", 1 );
+        self SetClientDvar( "sv_cheats", 0 );
+        
+        self God();
+        self Noclip();
+        self Hide();
+        
+        self.isNoClipped = false;
+        
+        self IPrintLnBold( "NoClip disabled" );
+    }
+
+    self IPrintLnBold( "NoClip enabled" );*/
+
+    scripts\mp\_integration_base::LogWarning( "NoClip is not supported on T5!" );
+
+}
+
+HideImpl( event, data )
+{
+    if ( !IsAlive( self ) )
+    {
+        self IPrintLnBold( "You are not alive" );
+        return;
+    }
+    
+    if ( !IsDefined ( self.isHidden ) )
+    {
+        self.isHidden = false;
+    }
+
+    if ( !self.isHidden )
+    {
+        self SetClientDvar( "sv_cheats", 1 );
+        self SetClientDvar( "cg_thirdperson", 1 );
+        self SetClientDvar( "sv_cheats", 0 );
+        
+        self God();
+        self Hide();
+        
+        self.isHidden = true;
+        
+        self IPrintLnBold( "Hide enabled" );
+    }
+    else
+    {
+        self SetClientDvar( "sv_cheats", 1 );
+        self SetClientDvar( "cg_thirdperson", 0 );
+        self SetClientDvar( "sv_cheats", 0 );
+        
+        self God();
+        self Show();
+        
+        self.isHidden = false;
+        
+        self IPrintLnBold( "Hide disabled" );
+    }
+}
+
+AlertImpl( event, data )
+{
+    self thread maps\mp\gametypes\_hud_message::oldNotifyMessage( data["alertType"], data["message"], undefined, ( 1, 0, 0 ), "mpl_sab_ui_suitcasebomb_timer", 7.5 );
+
+    return "Sent alert to " + self.name; 
+}
+
+GotoImpl( event, data )
+{
+    if ( IsDefined( event.target ) )
+    {
+        return self GotoPlayerImpl( event.target );
+    }
+    else
+    {
+        return self GotoCoordImpl( data );
+    }
+}
+
+GotoCoordImpl( data )
+{
+    if ( !IsAlive( self ) )
+    {
+        self IPrintLnBold( "You are not alive" );
+        return;
+    }
+
+    position = ( int( data["x"] ), int( data["y"] ), int( data["z"]) );
+    self SetOrigin( position );
+    self IPrintLnBold( "Moved to " + "("+ position[0] + "," + position[1] + "," + position[2] + ")" );
+}
+
+GotoPlayerImpl( target )
+{
+    if ( !IsAlive( target ) )
+    {
+        self IPrintLnBold( target.name + " is not alive" );
+        return;
+    }
+
+    self SetOrigin( target GetOrigin() );
+    self IPrintLnBold( "Moved to " + target.name );
+}
+
+PlayerToMeImpl( event, data )
+{
+    if ( !IsAlive( self ) )
+    {
+        return self.name + " is not alive";
+    }
+
+    self SetOrigin( event.origin GetOrigin() );
+    return "Moved here " + self.name;    
+}
+
+KillImpl( event, data )
+{
+    if ( !IsAlive( self ) )
+    {
+        return self.name + " is not alive";
+    }
+
+    self Suicide();
+    self IPrintLnBold( "You were killed by " + self.name );
+
+    return "You killed " + self.name;
+}
+
+SetSpectatorImpl( event, data )
+{
+    if ( self.pers["team"] == "spectator" ) 
+    {
+        return self.name + " is already spectating";
+    }
+    
+    self [[level.spectator]]();
+    self IPrintLnBold( "You have been moved to spectator" );
+    
+    return self.name + " has been moved to spectator";
+}

GameFiles/deploy.bat

@@ -0,0 +1,14 @@
+@echo off
+
+ECHO "Pluto IW5"
+xcopy /y .\GameInterface\_integration_base.gsc "%LOCALAPPDATA%\Plutonium\storage\iw5\scripts\mp"
+xcopy /y .\GameInterface\_integration_iw5.gsc "%LOCALAPPDATA%\Plutonium\storage\iw5\scripts\mp"
+xcopy /y .\AntiCheat\IW5\storage\iw5\scripts\_customcallbacks.gsc "%LOCALAPPDATA%\Plutonium\storage\iw5\scripts\mp"
+
+ECHO "Pluto T5"
+xcopy /y .\GameInterface\_integration_base.gsc "%LOCALAPPDATA%\Plutonium\storage\t5\scripts\mp"
+xcopy /y .\GameInterface\_integration_t5.gsc "%LOCALAPPDATA%\Plutonium\storage\t5\scripts\mp"
+
+ECHO "Pluto T6"
+xcopy /y .\AntiCheat\PT6\storage\t6\scripts\mp\_customcallbacks.gsc "%LOCALAPPDATA%\Plutonium\storage\t6\scripts\mp"
+xcopy /y .\AntiCheat\PT6\storage\t6\scripts\mp\_customcallbacks.gsc.src "%LOCALAPPDATA%\Plutonium\storage\t6\scripts\mp"

IW4MAdmin.sln

@@ -6,14 +6,12 @@ Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "Plugins", "Plugins", "{26E8
 EndProject
 Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "Solution Items", "Solution Items", "{8C8F3945-0AEF-4949-A1F7-B18E952E50BC}"
 	ProjectSection(SolutionItems) = preProject
-		GameFiles\IW4x\userraw\scripts\_customcallbacks.gsc = GameFiles\IW4x\userraw\scripts\_customcallbacks.gsc
 		DeploymentFiles\deployment-pipeline.yml = DeploymentFiles\deployment-pipeline.yml
 		DeploymentFiles\PostPublish.ps1 = DeploymentFiles\PostPublish.ps1
 		README.md = README.md
 		version.txt = version.txt
 		DeploymentFiles\UpdateIW4MAdmin.ps1 = DeploymentFiles\UpdateIW4MAdmin.ps1
 		DeploymentFiles\UpdateIW4MAdmin.sh = DeploymentFiles\UpdateIW4MAdmin.sh
-		GameFiles\_integration.gsc = GameFiles\_integration.gsc
 	EndProjectSection
 EndProject
 Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "SharedLibraryCore", "SharedLibraryCore\SharedLibraryCore.csproj", "{AA0541A2-8D51-4AD9-B0AC-3D1F5B162481}"
@@ -53,6 +51,8 @@ Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "ScriptPlugins", "ScriptPlug
 		Plugins\ScriptPlugins\GameInterface.js = Plugins\ScriptPlugins\GameInterface.js
 		Plugins\ScriptPlugins\SubnetBan.js = Plugins\ScriptPlugins\SubnetBan.js
 		Plugins\ScriptPlugins\BanBroadcasting.js = Plugins\ScriptPlugins\BanBroadcasting.js
+		Plugins\ScriptPlugins\ParserH1MOD.js = Plugins\ScriptPlugins\ParserH1MOD.js
+		Plugins\ScriptPlugins\ParserPlutoniumT5.js = Plugins\ScriptPlugins\ParserPlutoniumT5.js
 	EndProjectSection
 EndProject
 Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "AutomessageFeed", "Plugins\AutomessageFeed\AutomessageFeed.csproj", "{F5815359-CFC7-44B4-9A3B-C04BACAD5836}"
@@ -69,6 +69,39 @@ Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Integrations.Cod", "Integra
 EndProject
 Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Integrations.Source", "Integrations\Source\Integrations.Source.csproj", "{9512295B-3045-40E0-9B7E-2409F2173E9D}"
 EndProject
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Mute", "Plugins\Mute\Mute.csproj", "{259824F3-D860-4233-91D6-FF73D4DD8B18}"
+EndProject
+Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "GameFiles", "GameFiles", "{6CBF412C-EFEE-45F7-80FD-AC402C22CDB9}"
+EndProject
+Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "GameInterface", "GameInterface", "{5C2BE2A8-EA1D-424F-88E1-7FC33EEC2E55}"
+	ProjectSection(SolutionItems) = preProject
+		GameFiles\GameInterface\_integration_base.gsc = GameFiles\GameInterface\_integration_base.gsc
+		GameFiles\GameInterface\_integration_iw4x.gsc = GameFiles\GameInterface\_integration_iw4x.gsc
+		GameFiles\GameInterface\_integration_iw5.gsc = GameFiles\GameInterface\_integration_iw5.gsc
+		GameFiles\GameInterface\_integration_shared.gsc = GameFiles\GameInterface\_integration_shared.gsc
+		GameFiles\GameInterface\_integration_t5.gsc = GameFiles\GameInterface\_integration_t5.gsc
+	EndProjectSection
+EndProject
+Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "AntiCheat", "AntiCheat", "{AB83BAC0-C539-424A-BF00-78487C10753C}"
+EndProject
+Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "IW4x", "IW4x", "{3EA564BD-3AC6-479B-96B6-CB059DCD0C77}"
+	ProjectSection(SolutionItems) = preProject
+		GameFiles\AntiCheat\IW4x\userraw\scripts\_customcallbacks.gsc = GameFiles\AntiCheat\IW4x\userraw\scripts\_customcallbacks.gsc
+	EndProjectSection
+EndProject
+Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "Pluto T6", "Pluto T6", "{866F453D-BC89-457F-8B55-485494759B31}"
+	ProjectSection(SolutionItems) = preProject
+		GameFiles\AntiCheat\PT6\storage\t6\scripts\mp\_customcallbacks.gsc = GameFiles\AntiCheat\PT6\storage\t6\scripts\mp\_customcallbacks.gsc
+		GameFiles\AntiCheat\PT6\storage\t6\scripts\mp\_customcallbacks.gsc.src = GameFiles\AntiCheat\PT6\storage\t6\scripts\mp\_customcallbacks.gsc.src
+		GameFiles\AntiCheat\PT6\README.MD = GameFiles\AntiCheat\PT6\README.MD
+	EndProjectSection
+EndProject
+Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "Pluto IW5", "Pluto IW5", "{603725A4-BC0B-423B-955B-762C89E1C4C2}"
+	ProjectSection(SolutionItems) = preProject
+		GameFiles\AntiCheat\IW5\storage\iw5\scripts\_customcallbacks.gsc = GameFiles\AntiCheat\IW5\storage\iw5\scripts\_customcallbacks.gsc
+		GameFiles\AntiCheat\IW5\README.MD = GameFiles\AntiCheat\IW5\README.MD
+	EndProjectSection
+EndProject
 Global
 	GlobalSection(SolutionConfigurationPlatforms) = preSolution
 		Debug|Any CPU = Debug|Any CPU
@@ -373,6 +406,30 @@ Global
 		{9512295B-3045-40E0-9B7E-2409F2173E9D}.Release|x86.Build.0 = Release|Any CPU
 		{9512295B-3045-40E0-9B7E-2409F2173E9D}.Prerelease|Any CPU.ActiveCfg = Prerelease|Any CPU
 		{9512295B-3045-40E0-9B7E-2409F2173E9D}.Prerelease|Any CPU.Build.0 = Prerelease|Any CPU
+		{259824F3-D860-4233-91D6-FF73D4DD8B18}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{259824F3-D860-4233-91D6-FF73D4DD8B18}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{259824F3-D860-4233-91D6-FF73D4DD8B18}.Debug|Mixed Platforms.ActiveCfg = Debug|Any CPU
+		{259824F3-D860-4233-91D6-FF73D4DD8B18}.Debug|Mixed Platforms.Build.0 = Debug|Any CPU
+		{259824F3-D860-4233-91D6-FF73D4DD8B18}.Debug|x64.ActiveCfg = Debug|Any CPU
+		{259824F3-D860-4233-91D6-FF73D4DD8B18}.Debug|x64.Build.0 = Debug|Any CPU
+		{259824F3-D860-4233-91D6-FF73D4DD8B18}.Debug|x86.ActiveCfg = Debug|Any CPU
+		{259824F3-D860-4233-91D6-FF73D4DD8B18}.Debug|x86.Build.0 = Debug|Any CPU
+		{259824F3-D860-4233-91D6-FF73D4DD8B18}.Prerelease|Mixed Platforms.ActiveCfg = Debug|Any CPU
+		{259824F3-D860-4233-91D6-FF73D4DD8B18}.Prerelease|Mixed Platforms.Build.0 = Debug|Any CPU
+		{259824F3-D860-4233-91D6-FF73D4DD8B18}.Prerelease|x64.ActiveCfg = Debug|Any CPU
+		{259824F3-D860-4233-91D6-FF73D4DD8B18}.Prerelease|x64.Build.0 = Debug|Any CPU
+		{259824F3-D860-4233-91D6-FF73D4DD8B18}.Prerelease|x86.ActiveCfg = Debug|Any CPU
+		{259824F3-D860-4233-91D6-FF73D4DD8B18}.Prerelease|x86.Build.0 = Debug|Any CPU
+		{259824F3-D860-4233-91D6-FF73D4DD8B18}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{259824F3-D860-4233-91D6-FF73D4DD8B18}.Release|Any CPU.Build.0 = Release|Any CPU
+		{259824F3-D860-4233-91D6-FF73D4DD8B18}.Release|Mixed Platforms.ActiveCfg = Release|Any CPU
+		{259824F3-D860-4233-91D6-FF73D4DD8B18}.Release|Mixed Platforms.Build.0 = Release|Any CPU
+		{259824F3-D860-4233-91D6-FF73D4DD8B18}.Release|x64.ActiveCfg = Release|Any CPU
+		{259824F3-D860-4233-91D6-FF73D4DD8B18}.Release|x64.Build.0 = Release|Any CPU
+		{259824F3-D860-4233-91D6-FF73D4DD8B18}.Release|x86.ActiveCfg = Release|Any CPU
+		{259824F3-D860-4233-91D6-FF73D4DD8B18}.Release|x86.Build.0 = Release|Any CPU
+		{259824F3-D860-4233-91D6-FF73D4DD8B18}.Prerelease|Any CPU.ActiveCfg = Prerelease|Any CPU
+		{259824F3-D860-4233-91D6-FF73D4DD8B18}.Prerelease|Any CPU.Build.0 = Prerelease|Any CPU
 	EndGlobalSection
 	GlobalSection(SolutionProperties) = preSolution
 		HideSolutionNode = FALSE
@@ -387,6 +444,13 @@ Global
 		{00A1FED2-2254-4AF7-A5DB-2357FA7C88CD} = {26E8B310-269E-46D4-A612-24601F16065F}
 		{A9348433-58C1-4B9C-8BB7-088B02529D9D} = {A2AE33B4-0830-426A-9E11-951DAB12BE5B}
 		{9512295B-3045-40E0-9B7E-2409F2173E9D} = {A2AE33B4-0830-426A-9E11-951DAB12BE5B}
+		{259824F3-D860-4233-91D6-FF73D4DD8B18} = {26E8B310-269E-46D4-A612-24601F16065F}
+		{6CBF412C-EFEE-45F7-80FD-AC402C22CDB9} = {8C8F3945-0AEF-4949-A1F7-B18E952E50BC}
+		{5C2BE2A8-EA1D-424F-88E1-7FC33EEC2E55} = {6CBF412C-EFEE-45F7-80FD-AC402C22CDB9}
+		{AB83BAC0-C539-424A-BF00-78487C10753C} = {6CBF412C-EFEE-45F7-80FD-AC402C22CDB9}
+		{3EA564BD-3AC6-479B-96B6-CB059DCD0C77} = {AB83BAC0-C539-424A-BF00-78487C10753C}
+		{866F453D-BC89-457F-8B55-485494759B31} = {AB83BAC0-C539-424A-BF00-78487C10753C}
+		{603725A4-BC0B-423B-955B-762C89E1C4C2} = {AB83BAC0-C539-424A-BF00-78487C10753C}
 	EndGlobalSection
 	GlobalSection(ExtensibilityGlobals) = postSolution
 		SolutionGuid = {84F8F8E0-1F73-41E0-BD8D-BB6676E2EE87}

Integrations/Cod/CodRConConnection.cs

@@ -56,6 +56,11 @@ namespace Integrations.Cod
             {
                 return await SendQueryAsyncInternal(type, parameters, token);
             }
+            catch (RConException ex) when (ex.IsOperationCancelled)
+            {
+                _log.LogDebug(ex, "Could not complete RCon request");
+                throw;
+            }
             catch (Exception ex)
             {
                 using (LogContext.PushProperty("Server", Endpoint.ToString()))
@@ -67,10 +72,7 @@ namespace Integrations.Cod
             }
             finally
             {
-                using (LogContext.PushProperty("Server", Endpoint.ToString()))
-                {
-                    _log.LogDebug("Releasing OnComplete {Count}", ActiveQueries[Endpoint].OnComplete.CurrentCount);
-                }
+                _log.LogDebug("Releasing OnComplete {Count}", ActiveQueries[Endpoint].OnComplete.CurrentCount);
 
                 if (ActiveQueries[Endpoint].OnComplete.CurrentCount == 0)
                 {
@@ -89,7 +91,11 @@ namespace Integrations.Cod
 
             if (!ActiveQueries.TryGetValue(Endpoint, out var connectionState))
             {
-                _log.LogError("Could not retrieve connection state");
+                using (LogContext.PushProperty("Server", Endpoint.ToString()))
+                {
+                    _log.LogError("Could not retrieve connection state");
+                }
+
                 throw new InvalidOperationException("Could not get connection state");
             }
 
@@ -104,7 +110,7 @@ namespace Integrations.Cod
             {
                 _log.LogDebug("OnComplete did not complete before timeout {Count}",
                     connectionState.OnComplete.CurrentCount);
-                throw new RConException("Timed out waiting for access to rcon socket");
+                throw new RConException("Timed out waiting for access to rcon socket", true);
             }
 
             var timeSinceLastQuery = (DateTime.Now - connectionState.LastQuery).TotalMilliseconds;
@@ -121,7 +127,7 @@ namespace Integrations.Cod
                 {
                     _log.LogDebug("Waiting for flood protect did not complete before timeout timeout {Count}",
                         connectionState.OnComplete.CurrentCount);
-                    throw new RConException("Timed out waiting for flood protect to expire");
+                    throw new RConException("Timed out waiting for flood protect to expire", true);
                 }
             }
 
@@ -145,7 +151,7 @@ namespace Integrations.Cod
                 switch (type)
                 {
                     case StaticHelpers.QueryType.GET_DVAR:
-                        waitForResponse |= true;
+                        waitForResponse = true;
                         payload = string
                             .Format(_config.CommandPrefixes.RConGetDvar, convertedRConPassword,
                                 convertedParameters + '\0').Select(Convert.ToByte).ToArray();
@@ -161,15 +167,15 @@ namespace Integrations.Cod
                                 convertedParameters + '\0').Select(Convert.ToByte).ToArray();
                         break;
                     case StaticHelpers.QueryType.GET_STATUS:
-                        waitForResponse |= true;
+                        waitForResponse = true;
                         payload = (_config.CommandPrefixes.RConGetStatus + '\0').Select(Convert.ToByte).ToArray();
                         break;
                     case StaticHelpers.QueryType.GET_INFO:
-                        waitForResponse |= true;
+                        waitForResponse = true;
                         payload = (_config.CommandPrefixes.RConGetInfo + '\0').Select(Convert.ToByte).ToArray();
                         break;
                     case StaticHelpers.QueryType.COMMAND_STATUS:
-                        waitForResponse |= true;
+                        waitForResponse = true;
                         payload = string.Format(_config.CommandPrefixes.RConCommand, convertedRConPassword, "status\0")
                             .Select(Convert.ToByte).ToArray();
                         break;
@@ -189,20 +195,9 @@ namespace Integrations.Cod
                 throw new RConException("Invalid character encountered when converting encodings");
             }
 
-            byte[][] response = null;
+            byte[][] response;
 
             retrySend:
-            if (connectionState.ConnectionAttempts > 1)
-            {
-                using (LogContext.PushProperty("Server", Endpoint.ToString()))
-                {
-                    _log.LogInformation(
-                        "Retrying RCon message ({ConnectionAttempts}/{AllowedConnectionFailures} attempts) with parameters {Payload}",
-                        connectionState.ConnectionAttempts,
-                        _retryAttempts, parameters);
-                }
-            }
-
             using (var socket = new Socket(AddressFamily.InterNetwork, SocketType.Dgram, ProtocolType.Udp)
                    {
                        DontFragment = false,
@@ -210,51 +205,43 @@ namespace Integrations.Cod
                        ExclusiveAddressUse = true,
                    })
             {
-                // wait for send to be ready
-                try
+                if (!token.IsCancellationRequested)
                 {
-                    await connectionState.OnSentData.WaitAsync(token);
-                }
-                catch (OperationCanceledException)
-                {
-                    _log.LogDebug("OnSent did not complete in time");
-                    throw new RConException("Timed out waiting for access to RCon send socket");
+                    connectionState.ConnectionAttempts++;
                 }
 
-                // wait for receive to be ready
-                try
-                {
-                    await connectionState.OnReceivedData.WaitAsync(token);
-                }
-                catch (OperationCanceledException)
-                {
-                    _log.LogDebug("OnReceived did not complete in time");
-                    if (connectionState.OnSentData.CurrentCount == 0)
-                    {
-                        connectionState.OnSentData.Release();
-                    }
-
-                    throw new RConException("Timed out waiting for access to RCon receive socket");
-                }
-
-                connectionState.SendEventArgs.UserToken = new ConnectionUserToken
-                {
-                    Socket = socket,
-                    CancellationToken = token
-                };
-
-                connectionState.ConnectionAttempts++;
-                connectionState.BytesReadPerSegment.Clear();
+                connectionState.ReceivedBytes.Clear();
 
                 _log.LogDebug(
-                    "Sending {PayloadLength} bytes to [{Endpoint}] ({ConnectionAttempts}/{AllowedConnectionFailures})",
-                    payload.Length, Endpoint, connectionState.ConnectionAttempts, _retryAttempts);
+                    "Sending {PayloadLength} bytes to [{Endpoint}] ({ConnectionAttempts}/{AllowedConnectionFailures}) parameters {Payload}",
+                    payload.Length, Endpoint, connectionState.ConnectionAttempts, _retryAttempts, parameters);
 
                 try
                 {
                     connectionState.LastQuery = DateTime.Now;
-                    response = await SendPayloadAsync(payload, waitForResponse,
-                        _parser.OverrideTimeoutForCommand(parameters), token);
+                    var retryTimeout = StaticHelpers.SocketTimeout(connectionState.ConnectionAttempts);
+                    var overrideTimeout = _parser.OverrideTimeoutForCommand(parameters);
+                    var maxTimeout = !overrideTimeout.HasValue || overrideTimeout == TimeSpan.Zero
+                        ? retryTimeout
+                        : overrideTimeout.Value;
+
+                    using var internalTokenSource = new CancellationTokenSource(maxTimeout);
+                    using var chainedTokenSource =
+                        CancellationTokenSource.CreateLinkedTokenSource(token, internalTokenSource.Token);
+
+                    if (connectionState.ConnectionAttempts > 1)
+                    {
+                        using (LogContext.PushProperty("Server", Endpoint.ToString()))
+                        {
+                            _log.LogInformation(
+                                "Retrying RCon message ({ConnectionAttempts}/{AllowedConnectionFailures} attempts, {Timeout}ms timeout) with parameters {Payload}",
+                                connectionState.ConnectionAttempts, _retryAttempts,
+                                maxTimeout.TotalMilliseconds, parameters);
+                        }
+                    }
+
+                    waitForResponse = waitForResponse && overrideTimeout.HasValue;
+                    response = await SendPayloadAsync(socket, payload, waitForResponse, chainedTokenSource.Token);
 
                     if ((response?.Length == 0 || response[0].Length == 0) && waitForResponse)
                     {
@@ -267,26 +254,23 @@ namespace Integrations.Cod
 
                 catch (OperationCanceledException)
                 {
+                    _log.LogDebug("OperationCanceledException when waiting for payload send to complete");
+
                     // if we timed out due to the cancellation token,
                     // we don't want to count that as an attempt
-                    _log.LogDebug("OperationCanceledException when waiting for payload send to complete");
-                    connectionState.ConnectionAttempts = 0;
-                }
-                catch
-                {
-                    // we want to retry with a delay
-                    if (connectionState.ConnectionAttempts < _retryAttempts)
+                    if (token.IsCancellationRequested)
                     {
-                        try
+                        if (connectionState.ConnectionAttempts > 0)
                         {
-                            await Task.Delay(StaticHelpers.SocketTimeout(connectionState.ConnectionAttempts), token);
-                        }
-                        catch (OperationCanceledException)
-                        {
-                            _log.LogDebug("OperationCancelled while waiting for retry");
-                            throw;
+                            connectionState.ConnectionAttempts--;
                         }
 
+                        throw new RConException("Timed out waiting on retry delay for RCon socket",
+                            token.IsCancellationRequested);
+                    }
+
+                    if (connectionState.ConnectionAttempts < _retryAttempts)
+                    {
                         goto retrySend;
                     }
 
@@ -300,25 +284,24 @@ namespace Integrations.Cod
                     connectionState.ConnectionAttempts = 0;
                     throw new NetworkException("Reached maximum retry attempts to send RCon data to server");
                 }
-                finally
+                catch (Exception ex)
                 {
-                    try
-                    {
-                        if (connectionState.OnSentData.CurrentCount == 0)
-                        {
-                            connectionState.OnSentData.Release();
-                        }
+                    _log.LogDebug(ex, "RCon Exception");
 
-                        if (connectionState.OnReceivedData.CurrentCount == 0)
-                        {
-                            connectionState.OnReceivedData.Release();
-                        }
-                    }
-                    catch
+                    if (connectionState.ConnectionAttempts < _retryAttempts)
                     {
-                        // ignored because we can have the socket operation cancelled (which releases the semaphore) but 
-                        // this thread is not notified because it's an event
+                        goto retrySend;
                     }
+
+                    using (LogContext.PushProperty("Server", Endpoint.ToString()))
+                    {
+                        _log.LogWarning(
+                            "Made {ConnectionAttempts} attempts to send RCon data to server, but received no response",
+                            connectionState.ConnectionAttempts);
+                    }
+
+                    connectionState.ConnectionAttempts = 0;
+                    throw new NetworkException("Reached maximum retry attempts to send RCon data to server");
                 }
             }
 
@@ -334,6 +317,81 @@ namespace Integrations.Cod
                 ? ReassembleSegmentedStatus(response)
                 : RecombineMessages(response);
 
+            var validatedResponse = ValidateResponse(type, responseString);
+
+            return validatedResponse;
+        }
+
+        private async Task<byte[][]> SendPayloadAsync(Socket rconSocket, byte[] payload, bool waitForResponse,
+            CancellationToken token = default)
+        {
+            var connectionState = ActiveQueries[Endpoint];
+
+            if (rconSocket is null)
+            {
+                _log.LogDebug("Invalid state");
+                throw new InvalidOperationException("State is not valid for socket operation");
+            }
+
+            var sentByteCount = await rconSocket.SendToAsync(payload, SocketFlags.None, Endpoint, token);
+            var complete = sentByteCount == payload.Length;
+
+            if (!complete)
+            {
+                using (LogContext.PushProperty("Server", Endpoint.ToString()))
+                {
+                    _log.LogWarning("Could not send data to remote RCon socket on attempt #{ConnectionAttempts}",
+                        connectionState.ConnectionAttempts);
+                }
+
+                rconSocket.Close();
+                throw new NetworkException("Could not send data to remote RCon socket", rconSocket);
+            }
+
+            if (!waitForResponse)
+            {
+                return Array.Empty<byte[]>();
+            }
+
+            _log.LogDebug("Waiting to asynchronously receive data on attempt #{ConnectionAttempts}",
+                connectionState.ConnectionAttempts);
+
+            await ReceiveAndStoreSocketData(rconSocket, token, connectionState);
+
+            if (_parser.GameName == Server.Game.IW3)
+            {
+                await Task.Delay(100, token); // CoD4x shenanigans 
+            }
+
+            while (rconSocket.Available > 0)
+            {
+                await ReceiveAndStoreSocketData(rconSocket, token, connectionState);
+            }
+
+            rconSocket.Close();
+            return GetResponseData(connectionState);
+        }
+
+        private async Task ReceiveAndStoreSocketData(Socket rconSocket, CancellationToken token,
+            ConnectionState connectionState)
+        {
+            var result = await rconSocket.ReceiveFromAsync(connectionState.ReceiveBuffer,
+                SocketFlags.None, Endpoint, token);
+
+            if (result.ReceivedBytes == 0)
+            {
+                return;
+            }
+
+            var storageBuffer = new byte[result.ReceivedBytes];
+            Array.Copy(connectionState.ReceiveBuffer, storageBuffer, storageBuffer.Length);
+            connectionState.ReceivedBytes.Add(storageBuffer);
+        }
+
+        #region Helpers
+
+        private string[] ValidateResponse(StaticHelpers.QueryType type, string responseString)
+        {
             // note: not all games respond if the password is wrong or not set
             if (responseString.Contains("Invalid password", StringComparison.InvariantCultureIgnoreCase) ||
                 responseString.Contains("rconpassword"))
@@ -357,19 +415,19 @@ namespace Integrations.Cod
                 ? _config.CommandPrefixes.RconGetInfoResponseHeader
                 : responseHeaderMatch);
 
-            if (headerSplit.Length != 2)
+            if (headerSplit.Length == 2)
             {
-                using (LogContext.PushProperty("Server", Endpoint.ToString()))
-                {
-                    _log.LogWarning("Invalid response header from server. Expected {Expected}, but got {Response}",
-                        _config.CommandPrefixes.RConResponse, headerSplit.FirstOrDefault());
-                }
-
-                throw new RConException("Unexpected response header from server");
+                return headerSplit.Last().Split(new[] { '\n' }, StringSplitOptions.RemoveEmptyEntries)
+                    .Select(line => line.StartsWith("^7") ? line[2..] : line).ToArray();
             }
 
-            var splitResponse = headerSplit.Last().Split(new[] { '\n' }, StringSplitOptions.RemoveEmptyEntries);
-            return splitResponse;
+            using (LogContext.PushProperty("Server", Endpoint.ToString()))
+            {
+                _log.LogWarning("Invalid response header from server. Expected {Expected}, but got {Response}",
+                    _config.CommandPrefixes.RConResponse, headerSplit.FirstOrDefault());
+            }
+
+            throw new RConException("Unexpected response header from server");
         }
 
         /// <summary>
@@ -400,7 +458,7 @@ namespace Integrations.Cod
 
             return string.Join("", splitStatusStrings);
         }
-
+        
         /// <summary>
         /// Recombines multiple game messages into one
         /// </summary>
@@ -429,263 +487,11 @@ namespace Integrations.Cod
             return builder.ToString();
         }
 
-        private async Task<byte[][]> SendPayloadAsync(byte[] payload, bool waitForResponse, TimeSpan overrideTimeout,
-            CancellationToken token = default)
-        {
-            var connectionState = ActiveQueries[Endpoint];
-            var rconSocket = ((ConnectionUserToken)connectionState.SendEventArgs.UserToken)?.Socket;
-
-            if (rconSocket is null)
-            {
-                _log.LogDebug("Invalid state");
-                throw new InvalidOperationException("State is not valid for socket operation");
-            }
-
-            if (connectionState.ReceiveEventArgs.RemoteEndPoint == null &&
-                connectionState.SendEventArgs.RemoteEndPoint == null)
-            {
-                // setup the event handlers only once because we're reusing the event args
-                connectionState.SendEventArgs.Completed += OnDataSent;
-                connectionState.ReceiveEventArgs.Completed += OnDataReceived;
-                connectionState.ReceiveEventArgs.UserToken = connectionState.SendEventArgs.UserToken;
-                connectionState.SendEventArgs.RemoteEndPoint = Endpoint;
-                connectionState.ReceiveEventArgs.RemoteEndPoint = Endpoint;
-                connectionState.ReceiveEventArgs.DisconnectReuseSocket = true;
-                connectionState.SendEventArgs.DisconnectReuseSocket = true;
-            }
-
-            connectionState.SendEventArgs.SetBuffer(payload);
-
-            // send the data to the server
-            var sendDataPending = rconSocket.SendToAsync(connectionState.SendEventArgs);
-
-            if (sendDataPending)
-            {
-                // the send has not been completed asynchronously
-                // this really shouldn't ever happen because it's UDP
-                var complete = await connectionState.OnSentData.WaitAsync(StaticHelpers.SocketTimeout(4), token);
-
-                if (!complete)
-                {
-                    using (LogContext.PushProperty("Server", Endpoint.ToString()))
-                    {
-                        _log.LogWarning("Socket timed out while sending RCon data on attempt {Attempt}",
-                            connectionState.ConnectionAttempts);
-                    }
-
-                    rconSocket.Close();
-                    throw new NetworkException("Timed out sending RCon data", rconSocket);
-                }
-            }
-
-            if (!waitForResponse)
-            {
-                return Array.Empty<byte[]>();
-            }
-
-            connectionState.ReceiveEventArgs.SetBuffer(connectionState.ReceiveBuffer);
-
-            // get our response back
-            var receiveDataPending = rconSocket.ReceiveFromAsync(connectionState.ReceiveEventArgs);
-
-            if (receiveDataPending)
-            {
-                _log.LogDebug("Waiting to asynchronously receive data on attempt #{ConnectionAttempts}",
-                    connectionState.ConnectionAttempts);
-
-                var completed = false;
-
-                try
-                {
-                    completed = await connectionState.OnReceivedData.WaitAsync(
-                        new[]
-                        {
-                            StaticHelpers.SocketTimeout(connectionState.ConnectionAttempts),
-                            overrideTimeout
-                        }.Max(), token);
-                }
-                catch (OperationCanceledException)
-                {
-                    // ignored
-                }
-
-                if (!completed)
-                {
-                    if (connectionState.ConnectionAttempts > 1) // this reduces some spam for unstable connections
-                    {
-                        using (LogContext.PushProperty("Server", Endpoint.ToString()))
-                        {
-                            _log.LogWarning(
-                                "Socket timed out while waiting for RCon response on attempt {Attempt} with timeout delay of {Timeout}",
-                                connectionState.ConnectionAttempts,
-                                StaticHelpers.SocketTimeout(connectionState.ConnectionAttempts));
-                        }
-                    }
-
-                    rconSocket.Close();
-                    _log.LogDebug("OnDataReceived did not complete in allocated time");
-                    throw new NetworkException("Timed out receiving RCon response", rconSocket);
-                }
-            }
-
-            rconSocket.Close();
-            return GetResponseData(connectionState);
-        }
-
         private static byte[][] GetResponseData(ConnectionState connectionState)
         {
-            var responseList = new List<byte[]>();
-            var totalBytesRead = 0;
-
-            foreach (var bytesRead in connectionState.BytesReadPerSegment)
-            {
-                responseList.Add(connectionState.ReceiveBuffer
-                    .Skip(totalBytesRead)
-                    .Take(bytesRead)
-                    .ToArray());
-
-                totalBytesRead += bytesRead;
-            }
-
-            return responseList.ToArray();
-        }
-
-        private void OnDataReceived(object sender, SocketAsyncEventArgs e)
-        {
-            _log.LogDebug("Read {BytesTransferred} bytes from {Endpoint}", e.BytesTransferred,
-                e.RemoteEndPoint?.ToString());
-
-            // this occurs when we close the socket
-            if (e.BytesTransferred == 0)
-            {
-                _log.LogDebug("No bytes were transmitted so the connection was probably closed");
-
-                var semaphore = ActiveQueries[Endpoint].OnReceivedData;
-
-                try
-                {
-                    if (semaphore.CurrentCount == 0)
-                    {
-                        semaphore.Release();
-                    }
-                }
-                catch
-                {
-                    // ignored because we can have the socket operation cancelled (which releases the semaphore) but 
-                    // this thread is not notified because it's an event
-                }
-
-                return;
-            }
-
-            var state = ActiveQueries[Endpoint];
-            var cancellationRequested = ((ConnectionUserToken)e.UserToken)?.CancellationToken.IsCancellationRequested ??
-                                        false;
-
-            if (sender is not Socket sock || cancellationRequested)
-            {
-                var semaphore = ActiveQueries[Endpoint].OnReceivedData;
-
-                try
-                {
-                    if (semaphore.CurrentCount == 0)
-                    {
-                        semaphore.Release();
-                    }
-                }
-                catch
-                {
-                    // ignored because we can have the socket operation cancelled (which releases the semaphore) but 
-                    // this thread is not notified because it's an event
-                }
-
-                return;
-            }
-
-            state.BytesReadPerSegment.Add(e.BytesTransferred);
-
-            // I don't even want to know why this works for getting more data from Cod4x
-            // but I'm leaving it in here as long as it doesn't break anything.
-            // it's very stupid...
-            Thread.Sleep(150);
-
-            try
-            {
-                var totalBytesTransferred = e.BytesTransferred;
-                _log.LogDebug("{Total} total bytes transferred with {Available} bytes remaining", totalBytesTransferred,
-                    sock.Available);
-
-                // we still have available data so the payload was segmented
-                while (sock.Available > 0)
-                {
-                    _log.LogDebug("{Available} more bytes to be read", sock.Available);
-
-                    var bufferSpaceAvailable = sock.Available + totalBytesTransferred - state.ReceiveBuffer.Length;
-                    if (bufferSpaceAvailable >= 0)
-                    {
-                        _log.LogWarning(
-                            "Not enough buffer space to store incoming data {BytesNeeded} additional bytes required",
-                            bufferSpaceAvailable);
-                        continue;
-                    }
-
-                    state.ReceiveEventArgs.SetBuffer(state.ReceiveBuffer, totalBytesTransferred, sock.Available);
-                    if (sock.ReceiveAsync(state.ReceiveEventArgs))
-                    {
-                        _log.LogDebug("Remaining bytes are async");
-                        continue;
-                    }
-
-                    _log.LogDebug("Read {BytesTransferred} synchronous bytes from {Endpoint}",
-                        state.ReceiveEventArgs.BytesTransferred, e.RemoteEndPoint?.ToString());
-
-                    // we need to increment this here because the callback isn't executed if there's no pending IO
-                    state.BytesReadPerSegment.Add(state.ReceiveEventArgs.BytesTransferred);
-                    totalBytesTransferred += state.ReceiveEventArgs.BytesTransferred;
-                }
-            }
-
-            catch (ObjectDisposedException)
-            {
-                _log.LogDebug("Socket was disposed while receiving data");
-            }
-
-            finally
-            {
-                var semaphore = ActiveQueries[Endpoint].OnReceivedData;
-                try
-                {
-                    if (semaphore.CurrentCount == 0)
-                    {
-                        semaphore.Release();
-                    }
-                }
-                catch
-                {
-                    // ignored because we can have the socket operation cancelled (which releases the semaphore) but 
-                    // this thread is not notified because it's an event
-                }
-            }
-        }
-
-        private void OnDataSent(object sender, SocketAsyncEventArgs e)
-        {
-            _log.LogDebug("Sent {ByteCount} bytes to {Endpoint}", e.Buffer?.Length,
-                e.ConnectSocket?.RemoteEndPoint?.ToString());
-
-            var semaphore = ActiveQueries[Endpoint].OnSentData;
-            try
-            {
-                if (semaphore.CurrentCount == 0)
-                {
-                    semaphore.Release();
-                }
-            }
-            catch
-            {
-                // ignored because we can have the socket operation cancelled (which releases the semaphore) but 
-                // this thread is not notified because it's an event
-            }
+            return connectionState.ReceivedBytes.ToArray();
         }
+        
+        #endregion
     }
 }

Integrations/Cod/ConnectionState.cs

@@ -1,6 +1,5 @@
 using System;
 using System.Collections.Generic;
-using System.Net.Sockets;
 using System.Threading;
 
 namespace Integrations.Cod
@@ -13,26 +12,13 @@ namespace Integrations.Cod
         ~ConnectionState()
         {
             OnComplete.Dispose();
-            OnSentData.Dispose();
-            OnReceivedData.Dispose();
         }
 
         public int ConnectionAttempts { get; set; }
         private const int BufferSize = 16384;
         public readonly byte[] ReceiveBuffer = new byte[BufferSize];
         public readonly SemaphoreSlim OnComplete = new(1, 1);
-        public readonly SemaphoreSlim OnSentData = new(1, 1);
-        public readonly SemaphoreSlim OnReceivedData = new (1, 1);
-       
-        public List<int> BytesReadPerSegment { get; set; } = new();
-        public SocketAsyncEventArgs SendEventArgs { get; set; } = new();
-        public SocketAsyncEventArgs ReceiveEventArgs { get; set; } = new();
+        public List<byte[]> ReceivedBytes { get; } = new();
         public DateTime LastQuery { get; set; } = DateTime.Now;
     }
-
-    internal class ConnectionUserToken
-    {
-        public Socket Socket { get; set; }
-        public CancellationToken CancellationToken { get; set; }
-    }
 }

Plugins/AutomessageFeed/AutomessageFeed.csproj

@@ -10,7 +10,7 @@
 
   <ItemGroup>
     <PackageReference Include="Microsoft.SyndicationFeed.ReaderWriter" Version="1.0.2" />
-    <PackageReference Include="RaidMax.IW4MAdmin.SharedLibraryCore" Version="2022.3.23.1" PrivateAssets="All" />
+    <PackageReference Include="RaidMax.IW4MAdmin.SharedLibraryCore" Version="2022.10.13.1" PrivateAssets="All" />
   </ItemGroup>
 
   <Target Name="PostBuild" AfterTargets="PostBuildEvent">

Plugins/LiveRadar/LiveRadar.csproj

@@ -16,7 +16,7 @@
   </PropertyGroup>
 
   <ItemGroup>
-    <PackageReference Include="RaidMax.IW4MAdmin.SharedLibraryCore" Version="2022.3.23.1" PrivateAssets="All" />
+    <PackageReference Include="RaidMax.IW4MAdmin.SharedLibraryCore" Version="2022.10.13.1" PrivateAssets="All" />
   </ItemGroup>
 
   <Target Name="PostBuild" AfterTargets="PostBuildEvent">

Plugins/Login/Commands/LoginCommand.cs

@@ -4,6 +4,7 @@ using SharedLibraryCore.Configuration;
 using SharedLibraryCore.Database.Models;
 using SharedLibraryCore.Interfaces;
 using System.Threading.Tasks;
+using SharedLibraryCore.Helpers;
 
 namespace IW4MAdmin.Plugins.Login.Commands
 {
@@ -18,7 +19,7 @@ namespace IW4MAdmin.Plugins.Login.Commands
             RequiresTarget = false;
             Arguments = new CommandArgument[]
             {
-                new CommandArgument()
+                new()
                 {
                     Name = Utilities.CurrentLocalization.LocalizationIndex["COMMANDS_ARGS_PASSWORD"],
                     Required = true
@@ -26,24 +27,28 @@ namespace IW4MAdmin.Plugins.Login.Commands
             };
         }
 
-        public override async Task ExecuteAsync(GameEvent E)
+        public override async Task ExecuteAsync(GameEvent gameEvent)
         {
-            bool success = E.Owner.Manager.TokenAuthenticator.AuthorizeToken(E.Origin.NetworkId, E.Data);
+            var success = gameEvent.Owner.Manager.TokenAuthenticator.AuthorizeToken(new TokenIdentifier
+            {
+                ClientId = gameEvent.Origin.ClientId,
+                Token = gameEvent.Data
+            });
 
             if (!success)
             {
-                string[] hashedPassword = await Task.FromResult(SharedLibraryCore.Helpers.Hashing.Hash(E.Data, E.Origin.PasswordSalt));
-                success = hashedPassword[0] == E.Origin.Password;
+                var hashedPassword = await Task.FromResult(Hashing.Hash(gameEvent.Data, gameEvent.Origin.PasswordSalt));
+                success = hashedPassword[0] == gameEvent.Origin.Password;
             }
 
             if (success)
             {
-                Plugin.AuthorizedClients[E.Origin.ClientId] = true;
+                Plugin.AuthorizedClients[gameEvent.Origin.ClientId] = true;
             }
 
             _ = success ?
-                E.Origin.Tell(_translationLookup["PLUGINS_LOGIN_COMMANDS_LOGIN_SUCCESS"]) :
-                E.Origin.Tell(_translationLookup["PLUGINS_LOGIN_COMMANDS_LOGIN_FAIL"]);
+                gameEvent.Origin.Tell(_translationLookup["PLUGINS_LOGIN_COMMANDS_LOGIN_SUCCESS"]) :
+                gameEvent.Origin.Tell(_translationLookup["PLUGINS_LOGIN_COMMANDS_LOGIN_FAIL"]);
         }
     }
 }

Plugins/Login/Login.csproj

@@ -19,7 +19,7 @@
   </PropertyGroup>
 
   <ItemGroup>
-    <PackageReference Include="RaidMax.IW4MAdmin.SharedLibraryCore" Version="2022.3.23.1" PrivateAssets="All" />
+    <PackageReference Include="RaidMax.IW4MAdmin.SharedLibraryCore" Version="2022.10.13.1" PrivateAssets="All" />
   </ItemGroup>
 
   <Target Name="PostBuild" AfterTargets="PostBuildEvent">

Plugins/Login/Plugin.cs

@@ -26,49 +26,22 @@ namespace IW4MAdmin.Plugins.Login
             _configHandler = configurationHandlerFactory.GetConfigurationHandler<Configuration>("LoginPluginSettings");
         }
 
-        public Task OnEventAsync(GameEvent E, Server S)
+        public Task OnEventAsync(GameEvent gameEvent, Server server)
         {
-            if (E.IsRemote || _configHandler.Configuration().RequirePrivilegedClientLogin == false)
+            if (gameEvent.IsRemote || _configHandler.Configuration().RequirePrivilegedClientLogin == false)
                 return Task.CompletedTask;
 
-            if (E.Type == GameEvent.EventType.Connect)
+            if (gameEvent.Type == GameEvent.EventType.Connect)
             {
-                AuthorizedClients.TryAdd(E.Origin.ClientId, false);
-                E.Origin.SetAdditionalProperty("IsLoggedIn", false);
+                AuthorizedClients.TryAdd(gameEvent.Origin.ClientId, false);
+                gameEvent.Origin.SetAdditionalProperty("IsLoggedIn", false);
             }
 
-            if (E.Type == GameEvent.EventType.Disconnect)
+            if (gameEvent.Type == GameEvent.EventType.Disconnect)
             {
-                AuthorizedClients.TryRemove(E.Origin.ClientId, out bool value);
+                AuthorizedClients.TryRemove(gameEvent.Origin.ClientId, out _);
             }
-
-            if (E.Type == GameEvent.EventType.Command)
-            {
-                if (E.Origin.Level < EFClient.Permission.Moderator ||
-                    E.Origin.Level == EFClient.Permission.Console)
-                    return Task.CompletedTask;
-
-                if (E.Extra.GetType() == typeof(SetPasswordCommand) &&
-                    E.Origin?.Password == null)
-                    return Task.CompletedTask;
-
-                if (E.Extra.GetType() == typeof(LoginCommand))
-                    return Task.CompletedTask;
-
-                if (E.Extra.GetType() == typeof(RequestTokenCommand))
-                    return Task.CompletedTask;
-
-                if (!AuthorizedClients[E.Origin.ClientId])
-                {
-                    throw new AuthorizationException(Utilities.CurrentLocalization.LocalizationIndex["PLUGINS_LOGIN_AUTH"]);
-                }
-
-                else
-                {
-                    E.Origin.SetAdditionalProperty("IsLoggedIn", true);
-                }
-            }
-
+            
             return Task.CompletedTask;
         }
 
@@ -76,6 +49,36 @@ namespace IW4MAdmin.Plugins.Login
         {
             AuthorizedClients = new ConcurrentDictionary<int, bool>();
 
+            manager.CommandInterceptors.Add(gameEvent =>
+            {
+                if (gameEvent.Type != GameEvent.EventType.Command || gameEvent.Extra is null)
+                {
+                    return true;
+                }
+
+                if (gameEvent.Origin.Level < EFClient.Permission.Moderator ||
+                    gameEvent.Origin.Level == EFClient.Permission.Console)
+                    return true;
+
+                if (gameEvent.Extra.GetType() == typeof(SetPasswordCommand) &&
+                    gameEvent.Origin?.Password == null)
+                    return true;
+
+                if (gameEvent.Extra.GetType() == typeof(LoginCommand))
+                    return true;
+
+                if (gameEvent.Extra.GetType() == typeof(RequestTokenCommand))
+                    return true;
+
+                if (!AuthorizedClients[gameEvent.Origin.ClientId])
+                {
+                    return false;
+                }
+
+                gameEvent.Origin.SetAdditionalProperty("IsLoggedIn", true);
+                return true;
+            });
+
             await _configHandler.BuildAsync();
             if (_configHandler.Configuration() == null)
             {

Plugins/Mute/Commands/MuteCommand.cs

@@ -0,0 +1,55 @@
+using Data.Models.Client;
+using SharedLibraryCore;
+using SharedLibraryCore.Commands;
+using SharedLibraryCore.Configuration;
+using SharedLibraryCore.Interfaces;
+
+namespace Mute.Commands;
+
+public class MuteCommand : Command
+{
+    public MuteCommand(CommandConfiguration config, ITranslationLookup translationLookup) : base(config,
+        translationLookup)
+    {
+        Name = "mute";
+        Description = translationLookup["PLUGINS_MUTE_COMMANDS_MUTE_DESC"];
+        Alias = "mu";
+        Permission = EFClient.Permission.Moderator;
+        RequiresTarget = true;
+        SupportedGames = Plugin.SupportedGames;
+        Arguments = new[]
+        {
+            new CommandArgument
+            {
+                Name = translationLookup["COMMANDS_ARGS_PLAYER"],
+                Required = true
+            },
+            new CommandArgument
+            {
+                Name = translationLookup["COMMANDS_ARGS_REASON"],
+                Required = true
+            }
+        };
+    }
+
+    public override async Task ExecuteAsync(GameEvent gameEvent)
+    {
+        if (gameEvent.Origin.ClientId == gameEvent.Target.ClientId)
+        {
+            gameEvent.Origin.Tell(_translationLookup["COMMANDS_DENY_SELF_TARGET"]);
+            return;
+        }
+
+        if (await Plugin.MuteManager.Mute(gameEvent.Owner, gameEvent.Origin, gameEvent.Target, null, gameEvent.Data))
+        {
+            gameEvent.Origin.Tell(_translationLookup["PLUGINS_MUTE_COMMANDS_MUTE_MUTED"]
+                .FormatExt(gameEvent.Target.CleanedName));
+            gameEvent.Target.Tell(_translationLookup["PLUGINS_MUTE_COMMANDS_MUTE_TARGET_MUTED"]
+                .FormatExt(gameEvent.Data));
+            return;
+        }
+
+        gameEvent.Origin.Tell(_translationLookup["PLUGINS_MUTE_COMMANDS_MUTE_NOT_UNMUTED"]
+            .FormatExt(gameEvent.Target.CleanedName));
+    }
+}

Plugins/Mute/Commands/MuteInfoCommand.cs

@@ -0,0 +1,50 @@
+using Data.Models.Client;
+using Humanizer;
+using SharedLibraryCore;
+using SharedLibraryCore.Commands;
+using SharedLibraryCore.Configuration;
+using SharedLibraryCore.Interfaces;
+
+namespace Mute.Commands;
+
+public class MuteInfoCommand : Command
+{
+    public MuteInfoCommand(CommandConfiguration config, ITranslationLookup translationLookup) : base(config,
+        translationLookup)
+    {
+        Name = "muteinfo";
+        Description = translationLookup["PLUGINS_MUTE_COMMANDS_MUTEINFO_DESC"];
+        Alias = "mi";
+        Permission = EFClient.Permission.Moderator;
+        RequiresTarget = true;
+        SupportedGames = Plugin.SupportedGames;
+        Arguments = new[]
+        {
+            new CommandArgument
+            {
+                Name = translationLookup["COMMANDS_ARGS_PLAYER"],
+                Required = true
+            }
+        };
+    }
+
+    public override async Task ExecuteAsync(GameEvent gameEvent)
+    {
+        var currentMuteMeta = await Plugin.MuteManager.GetCurrentMuteState(gameEvent.Target);
+        switch (currentMuteMeta.MuteState)
+        {
+            case MuteState.Muted when currentMuteMeta.Expiration is null:
+                gameEvent.Origin.Tell(_translationLookup["PLUGINS_MUTE_COMMANDS_MUTEINFO_SUCCESS"]
+                    .FormatExt(gameEvent.Target.Name, currentMuteMeta.Reason));
+                return;
+            case MuteState.Muted when currentMuteMeta.Expiration.HasValue && currentMuteMeta.Expiration.Value > DateTime.UtcNow:
+                var remainingTime = (currentMuteMeta.Expiration.Value - DateTime.UtcNow).HumanizeForCurrentCulture();
+                gameEvent.Origin.Tell(_translationLookup["PLUGINS_MUTE_COMMANDS_MUTEINFO_TM_SUCCESS"]
+                    .FormatExt(gameEvent.Target.Name, currentMuteMeta.Reason, remainingTime));
+                return;
+            default:
+                gameEvent.Origin.Tell(_translationLookup["PLUGINS_MUTE_COMMANDS_MUTEINFO_NONE"]);
+                break;
+        }
+    }
+}

Plugins/Mute/Commands/TempMuteCommand.cs

@@ -0,0 +1,73 @@
+using System.Text.RegularExpressions;
+using Data.Models.Client;
+using SharedLibraryCore;
+using SharedLibraryCore.Commands;
+using SharedLibraryCore.Configuration;
+using SharedLibraryCore.Interfaces;
+
+namespace Mute.Commands;
+
+public class TempMuteCommand : Command
+{
+    private const string TempBanRegex = @"([0-9]+\w+)\ (.+)";
+
+    public TempMuteCommand(CommandConfiguration config, ITranslationLookup translationLookup) : base(config,
+        translationLookup)
+    {
+        Name = "tempmute";
+        Description = translationLookup["PLUGINS_MUTE_COMMANDS_TEMPMUTE_DESC"];
+        Alias = "tm";
+        Permission = EFClient.Permission.Moderator;
+        RequiresTarget = true;
+        SupportedGames = Plugin.SupportedGames;
+        Arguments = new[]
+        {
+            new CommandArgument
+            {
+                Name = translationLookup["COMMANDS_ARGS_PLAYER"],
+                Required = true
+            },
+            new CommandArgument
+            {
+                Name = translationLookup["COMMANDS_ARGS_DURATION"],
+                Required = true
+            },
+            new CommandArgument
+            {
+                Name = translationLookup["COMMANDS_ARGS_REASON"],
+                Required = true
+            }
+        };
+    }
+
+    public override async Task ExecuteAsync(GameEvent gameEvent)
+    {
+        if (gameEvent.Origin.ClientId == gameEvent.Target.ClientId)
+        {
+            gameEvent.Origin.Tell(_translationLookup["COMMANDS_DENY_SELF_TARGET"]);
+            return;
+        }
+        
+        var match = Regex.Match(gameEvent.Data, TempBanRegex);
+        if (match.Success)
+        {
+            var expiration = DateTime.UtcNow + match.Groups[1].ToString().ParseTimespan();
+            var reason = match.Groups[2].ToString();
+
+            if (await Plugin.MuteManager.Mute(gameEvent.Owner, gameEvent.Origin, gameEvent.Target, expiration, reason))
+            {
+                gameEvent.Origin.Tell(_translationLookup["PLUGINS_MUTE_COMMANDS_TEMPMUTE_TEMPMUTED"]
+                    .FormatExt(gameEvent.Target.CleanedName));
+                gameEvent.Target.Tell(_translationLookup["PLUGINS_MUTE_COMMANDS_TEMPMUTE_TARGET_TEMPMUTED"]
+                    .FormatExt(expiration.HumanizeForCurrentCulture(), reason));
+                return;
+            }
+
+            gameEvent.Origin.Tell(_translationLookup["PLUGINS_MUTE_COMMANDS_MUTE_NOT_UNMUTED"]
+                .FormatExt(gameEvent.Target.CleanedName));
+            return;
+        }
+
+        gameEvent.Origin.Tell(_translationLookup["PLUGINS_MUTE_COMMANDS_TEMPMUTE_BAD_FORMAT"]);
+    }
+}

Plugins/Mute/Commands/UnmuteCommand.cs

@@ -0,0 +1,55 @@
+using Data.Models.Client;
+using SharedLibraryCore;
+using SharedLibraryCore.Commands;
+using SharedLibraryCore.Configuration;
+using SharedLibraryCore.Interfaces;
+
+namespace Mute.Commands;
+
+public class UnmuteCommand : Command
+{
+    public UnmuteCommand(CommandConfiguration config, ITranslationLookup translationLookup) : base(config,
+        translationLookup)
+    {
+        Name = "unmute";
+        Description = translationLookup["PLUGINS_MUTE_COMMANDS_UNMUTE_DESC"];
+        Alias = "um";
+        Permission = EFClient.Permission.Moderator;
+        RequiresTarget = true;
+        SupportedGames = Plugin.SupportedGames;
+        Arguments = new[]
+        {
+            new CommandArgument
+            {
+                Name = translationLookup["COMMANDS_ARGS_PLAYER"],
+                Required = true
+            },
+            new CommandArgument
+            {
+                Name = translationLookup["COMMANDS_ARGS_REASON"],
+                Required = true
+            }
+        };
+    }
+
+    public override async Task ExecuteAsync(GameEvent gameEvent)
+    {
+        if (gameEvent.Origin.ClientId == gameEvent.Target.ClientId)
+        {
+            gameEvent.Origin.Tell(_translationLookup["COMMANDS_DENY_SELF_TARGET"]);
+            return;
+        }
+
+        if (await Plugin.MuteManager.Unmute(gameEvent.Owner, gameEvent.Origin, gameEvent.Target, gameEvent.Data))
+        {
+            gameEvent.Origin.Tell(_translationLookup["PLUGINS_MUTE_COMMANDS_UNMUTE_UNMUTED"]
+                .FormatExt(gameEvent.Target.CleanedName));
+            gameEvent.Target.Tell(_translationLookup["PLUGINS_MUTE_COMMANDS_UNMUTE_TARGET_UNMUTED"]
+                .FormatExt(gameEvent.Data));
+            return;
+        }
+
+        gameEvent.Origin.Tell(_translationLookup["PLUGINS_MUTE_COMMANDS_UNMUTE_NOT_MUTED"]
+            .FormatExt(gameEvent.Target.CleanedName));
+    }
+}

Plugins/Mute/Mute.csproj

@@ -0,0 +1,20 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+    <PropertyGroup>
+        <TargetFramework>net6.0</TargetFramework>
+        <ImplicitUsings>enable</ImplicitUsings>
+        <Nullable>enable</Nullable>
+        <Authors>MrAmos123</Authors>
+        <OutputType>Library</OutputType>
+        <Configurations>Debug;Release;Prerelease</Configurations>
+        <Platforms>AnyCPU</Platforms>
+    </PropertyGroup>
+
+    <ItemGroup>
+        <PackageReference Include="RaidMax.IW4MAdmin.SharedLibraryCore" Version="2022.10.13.1" PrivateAssets="All" />
+    </ItemGroup>
+    
+    <Target Name="PostBuild" AfterTargets="PostBuildEvent">
+        <Exec Command="dotnet publish $(ProjectPath) -c $(ConfigurationName) -o $(ProjectDir)..\..\Build\Plugins --no-build --no-restore --no-dependencies" />
+    </Target>
+</Project>

Plugins/Mute/MuteManager.cs

@@ -0,0 +1,206 @@
+using Data.Abstractions;
+using Data.Models;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.Extensions.DependencyInjection;
+using Microsoft.Extensions.Logging;
+using SharedLibraryCore;
+using SharedLibraryCore.Database.Models;
+using SharedLibraryCore.Interfaces;
+using static System.Enum;
+using ILogger = Microsoft.Extensions.Logging.ILogger;
+
+namespace Mute;
+
+public class MuteManager
+{
+    private readonly IMetaServiceV2 _metaService;
+    private readonly ITranslationLookup _translationLookup;
+    private readonly ILogger _logger;
+    private readonly IDatabaseContextFactory _databaseContextFactory;
+    private readonly SemaphoreSlim _onMuteAction = new(1, 1);
+
+    public MuteManager(IServiceProvider serviceProvider)
+    {
+        _metaService = serviceProvider.GetRequiredService<IMetaServiceV2>();
+        _translationLookup = serviceProvider.GetRequiredService<ITranslationLookup>();
+        _logger = serviceProvider.GetRequiredService<ILogger<MuteManager>>();
+        _databaseContextFactory = serviceProvider.GetRequiredService<IDatabaseContextFactory>();
+    }
+
+    public static bool IsExpiredMute(MuteStateMeta muteStateMeta) =>
+        muteStateMeta.Expiration is not null && muteStateMeta.Expiration < DateTime.UtcNow;
+
+    public async Task<MuteStateMeta> GetCurrentMuteState(EFClient client)
+    {
+        try
+        {
+            await _onMuteAction.WaitAsync();
+            var clientMuteMeta = await ReadPersistentDataV2(client);
+            if (clientMuteMeta is not null) return clientMuteMeta;
+
+            // Return null if the client doesn't have old or new meta.
+            var muteState = await ReadPersistentDataV1(client);
+            clientMuteMeta = new MuteStateMeta
+            {
+                Reason = muteState is null ? string.Empty : _translationLookup["PLUGINS_MUTE_MIGRATED"],
+                Expiration = muteState switch
+                {
+                    null => DateTime.UtcNow,
+                    MuteState.Muted => null,
+                    _ => DateTime.UtcNow
+                },
+                MuteState = muteState ?? MuteState.Unmuted,
+                CommandExecuted = true
+            };
+
+            // Migrate old mute meta, else, client has no state, so set a generic one, but don't write it to database.
+            if (muteState is not null)
+            {
+                clientMuteMeta.CommandExecuted = false;
+                await WritePersistentData(client, clientMuteMeta);
+                await CreatePenalty(muteState.Value, Utilities.IW4MAdminClient(), client, clientMuteMeta.Expiration,
+                    clientMuteMeta.Reason);
+            }
+            else
+            {
+                client.SetAdditionalProperty(Plugin.MuteKey, clientMuteMeta);
+            }
+
+            return clientMuteMeta;
+        }
+        finally
+        {
+            if (_onMuteAction.CurrentCount == 0) _onMuteAction.Release();
+        }
+    }
+
+    public async Task<bool> Mute(Server server, EFClient origin, EFClient target, DateTime? dateTime, string reason)
+    {
+        var clientMuteMeta = await GetCurrentMuteState(target);
+        if (clientMuteMeta.MuteState is MuteState.Muted && clientMuteMeta.CommandExecuted) return false;
+
+        clientMuteMeta = new MuteStateMeta
+        {
+            Expiration = dateTime,
+            MuteState = MuteState.Muted,
+            Reason = reason,
+            CommandExecuted = false
+        };
+        await WritePersistentData(target, clientMuteMeta);
+
+        await CreatePenalty(MuteState.Muted, origin, target, dateTime, reason);
+
+        // Handle game command
+        var client = server.GetClientsAsList().FirstOrDefault(client => client.NetworkId == target.NetworkId);
+        await PerformGameCommand(server, client, clientMuteMeta);
+
+        return true;
+    }
+
+    public async Task<bool> Unmute(Server server, EFClient origin, EFClient target, string reason)
+    {
+        var clientMuteMeta = await GetCurrentMuteState(target);
+        if (clientMuteMeta.MuteState is MuteState.Unmuted && clientMuteMeta.CommandExecuted) return false;
+        if (!target.IsIngame && clientMuteMeta.MuteState is MuteState.Unmuting) return false;
+
+        if (clientMuteMeta.MuteState is not MuteState.Unmuting && origin.ClientId != 1)
+        {
+            await CreatePenalty(MuteState.Unmuted, origin, target, DateTime.UtcNow, reason);
+        }
+
+        await ExpireMutePenalties(target);
+
+        clientMuteMeta = new MuteStateMeta
+        {
+            Expiration = DateTime.UtcNow,
+            MuteState = target.IsIngame ? MuteState.Unmuted : MuteState.Unmuting,
+            Reason = reason,
+            CommandExecuted = false
+        };
+        await WritePersistentData(target, clientMuteMeta);
+
+        // Handle game command
+        var client = server.GetClientsAsList().FirstOrDefault(client => client.NetworkId == target.NetworkId);
+        await PerformGameCommand(server, client, clientMuteMeta);
+
+        return true;
+    }
+
+    private async Task CreatePenalty(MuteState muteState, EFClient origin, EFClient target, DateTime? dateTime,
+        string reason)
+    {
+        var newPenalty = new EFPenalty
+        {
+            Type = muteState is MuteState.Unmuted ? EFPenalty.PenaltyType.Unmute :
+                dateTime is null ? EFPenalty.PenaltyType.Mute : EFPenalty.PenaltyType.TempMute,
+            Expires = muteState is MuteState.Unmuted ? DateTime.UtcNow : dateTime,
+            Offender = target,
+            Offense = reason,
+            Punisher = origin,
+            Link = target.AliasLink
+        };
+        _logger.LogDebug("Creating new {MuteState} Penalty for {Target} with reason {Reason}",
+            nameof(muteState), target.Name, reason);
+        await newPenalty.TryCreatePenalty(Plugin.Manager.GetPenaltyService(), _logger);
+    }
+
+    private async Task ExpireMutePenalties(EFClient client)
+    {
+        await using var context = _databaseContextFactory.CreateContext();
+        var mutePenalties = await context.Penalties
+            .Where(penalty => penalty.OffenderId == client.ClientId &&
+                              (penalty.Type == EFPenalty.PenaltyType.Mute ||
+                               penalty.Type == EFPenalty.PenaltyType.TempMute) &&
+                              (penalty.Expires == null || penalty.Expires > DateTime.UtcNow))
+            .ToListAsync();
+
+        foreach (var mutePenalty in mutePenalties)
+        {
+            mutePenalty.Expires = DateTime.UtcNow;
+        }
+
+        await context.SaveChangesAsync();
+    }
+
+    public static async Task PerformGameCommand(Server server, EFClient? client, MuteStateMeta muteStateMeta)
+    {
+        if (client is null || !client.IsIngame) return;
+
+        switch (muteStateMeta.MuteState)
+        {
+            case MuteState.Muted:
+                await server.ExecuteCommandAsync($"muteClient {client.ClientNumber}");
+                muteStateMeta.CommandExecuted = true;
+                break;
+            case MuteState.Unmuted:
+                await server.ExecuteCommandAsync($"unmute {client.ClientNumber}");
+                muteStateMeta.CommandExecuted = true;
+                break;
+        }
+    }
+
+    private async Task<MuteState?> ReadPersistentDataV1(EFClient client) => TryParse<MuteState>(
+        (await _metaService.GetPersistentMeta(Plugin.MuteKey, client.ClientId))?.Value,
+        out var muteState)
+        ? muteState
+        : null;
+
+    private async Task<MuteStateMeta?> ReadPersistentDataV2(EFClient client)
+    {
+        // Get meta from client
+        var clientMuteMeta = client.GetAdditionalProperty<MuteStateMeta>(Plugin.MuteKey);
+        if (clientMuteMeta is not null) return clientMuteMeta;
+
+        // Get meta from database and store in client if exists
+        clientMuteMeta = await _metaService.GetPersistentMetaValue<MuteStateMeta>(Plugin.MuteKey, client.ClientId);
+        if (clientMuteMeta is not null) client.SetAdditionalProperty(Plugin.MuteKey, clientMuteMeta);
+
+        return clientMuteMeta;
+    }
+
+    private async Task WritePersistentData(EFClient client, MuteStateMeta clientMuteMeta)
+    {
+        client.SetAdditionalProperty(Plugin.MuteKey, clientMuteMeta);
+        await _metaService.SetPersistentMetaValue(Plugin.MuteKey, clientMuteMeta, client.ClientId);
+    }
+}

Plugins/Mute/MuteStateMeta.cs

@@ -0,0 +1,18 @@
+using System.Text.Json.Serialization;
+
+namespace Mute;
+
+public class MuteStateMeta
+{
+    public string? Reason { get; set; }
+    public DateTime? Expiration { get; set; }
+    public MuteState MuteState { get; set; }
+    [JsonIgnore] public bool CommandExecuted { get; set; }
+}
+
+public enum MuteState
+{
+    Muted,
+    Unmuting,
+    Unmuted
+}

Plugins/Mute/Plugin.cs

@@ -0,0 +1,311 @@
+using Data.Abstractions;
+using Microsoft.Extensions.Logging;
+using Mute.Commands;
+using SharedLibraryCore;
+using SharedLibraryCore.Commands;
+using SharedLibraryCore.Database.Models;
+using SharedLibraryCore.Helpers;
+using SharedLibraryCore.Interfaces;
+using JsonSerializer = System.Text.Json.JsonSerializer;
+
+namespace Mute;
+
+public class Plugin : IPlugin
+{
+    public string Name => "Mute";
+    public float Version => (float)Utilities.GetVersionAsDouble();
+    public string Author => "Amos";
+
+    public const string MuteKey = "IW4MMute";
+    public static MuteManager MuteManager { get; private set; } = null!;
+    public static IManager Manager { get; private set; } = null!;
+    public static readonly Server.Game[] SupportedGames = {Server.Game.IW4};
+    private static readonly string[] DisabledCommands = {nameof(PrivateMessageAdminsCommand), "PrivateMessageCommand"};
+    private readonly IInteractionRegistration _interactionRegistration;
+    private readonly IRemoteCommandService _remoteCommandService;
+    private static readonly string MuteInteraction = "Webfront::Profile::Mute";
+
+    public Plugin(ILogger<Plugin> logger, IInteractionRegistration interactionRegistration,
+        IRemoteCommandService remoteCommandService, IServiceProvider serviceProvider)
+    {
+        _interactionRegistration = interactionRegistration;
+        _remoteCommandService = remoteCommandService;
+        MuteManager = new MuteManager(serviceProvider);
+    }
+
+    public async Task OnEventAsync(GameEvent gameEvent, Server server)
+    {
+        if (!SupportedGames.Contains(server.GameName)) return;
+
+        switch (gameEvent.Type)
+        {
+            case GameEvent.EventType.Join:
+                // Check if user has any meta set, else ignore (unmuted)
+                var muteMetaJoin = await MuteManager.GetCurrentMuteState(gameEvent.Origin);
+
+                switch (muteMetaJoin.MuteState)
+                {
+                    case MuteState.Muted:
+                        // Let the client know when their mute expires.
+                        gameEvent.Origin.Tell(Utilities.CurrentLocalization
+                            .LocalizationIndex["PLUGINS_MUTE_REMAINING_TIME"].FormatExt(
+                                muteMetaJoin.Expiration is not null
+                                    ? muteMetaJoin.Expiration.Value.HumanizeForCurrentCulture()
+                                    : Utilities.CurrentLocalization.LocalizationIndex["PLUGINS_MUTE_NEVER"],
+                                muteMetaJoin.Reason));
+                        break;
+                    case MuteState.Unmuting:
+                        // Handle unmute of unmuted players.
+                        await MuteManager.Unmute(server, Utilities.IW4MAdminClient(), gameEvent.Origin,
+                            muteMetaJoin.Reason ?? string.Empty);
+                        gameEvent.Origin.Tell(Utilities.CurrentLocalization
+                            .LocalizationIndex["PLUGINS_MUTE_COMMANDS_UNMUTE_TARGET_UNMUTED"]
+                            .FormatExt(muteMetaJoin.Reason));
+                        break;
+                }
+
+                break;
+            case GameEvent.EventType.Say:
+                var muteMetaSay = await MuteManager.GetCurrentMuteState(gameEvent.Origin);
+
+                switch (muteMetaSay.MuteState)
+                {
+                    case MuteState.Muted:
+                        // Let the client know when their mute expires.
+                        gameEvent.Origin.Tell(Utilities.CurrentLocalization
+                            .LocalizationIndex["PLUGINS_MUTE_REMAINING_TIME"].FormatExt(
+                                muteMetaSay.Expiration is not null
+                                    ? muteMetaSay.Expiration.Value.HumanizeForCurrentCulture()
+                                    : Utilities.CurrentLocalization.LocalizationIndex["PLUGINS_MUTE_NEVER"],
+                                muteMetaSay.Reason));
+                        break;
+                }
+
+                break;
+            case GameEvent.EventType.Update:
+                // Get correct EFClient object
+                var client = server.GetClientsAsList()
+                    .FirstOrDefault(client => client.NetworkId == gameEvent.Origin.NetworkId);
+                if (client == null) break;
+
+                var muteMetaUpdate = await MuteManager.GetCurrentMuteState(client);
+                if (!muteMetaUpdate.CommandExecuted)
+                {
+                    await MuteManager.PerformGameCommand(server, client, muteMetaUpdate);
+                }
+
+                switch (muteMetaUpdate.MuteState)
+                {
+                    case MuteState.Muted:
+                        // Handle unmute if expired.
+                        if (MuteManager.IsExpiredMute(muteMetaUpdate))
+                        {
+                            await MuteManager.Unmute(server, Utilities.IW4MAdminClient(), client,
+                                Utilities.CurrentLocalization.LocalizationIndex["PLUGINS_MUTE_EXPIRED"]);
+                            client.Tell(
+                                Utilities.CurrentLocalization.LocalizationIndex["PLUGINS_MUTE_TARGET_EXPIRED"]);
+                        }
+
+                        break;
+                }
+
+                break;
+        }
+    }
+
+    public Task OnLoadAsync(IManager manager)
+    {
+        Manager = manager;
+
+        manager.CommandInterceptors.Add(gameEvent =>
+        {
+            if (gameEvent.Extra is not Command command)
+            {
+                return true;
+            }
+
+            var muteMeta = MuteManager.GetCurrentMuteState(gameEvent.Origin).GetAwaiter().GetResult();
+            if (muteMeta.MuteState is not MuteState.Muted)
+            {
+                return true;
+            }
+
+            return !DisabledCommands.Contains(command.GetType().Name) && !command.IsBroadcast;
+        });
+
+        _interactionRegistration.RegisterInteraction(MuteInteraction, async (targetClientId, game, token) =>
+        {
+            if (!targetClientId.HasValue || game.HasValue && !SupportedGames.Contains((Server.Game)game.Value))
+            {
+                return null;
+            }
+
+            var clientMuteMetaState =
+                (await MuteManager.GetCurrentMuteState(new EFClient {ClientId = targetClientId.Value}))
+                .MuteState;
+            var server = manager.GetServers().First();
+
+            string GetCommandName(Type commandType) =>
+                manager.Commands.FirstOrDefault(command => command.GetType() == commandType)?.Name ?? "";
+
+            return clientMuteMetaState is MuteState.Unmuted or MuteState.Unmuting
+                ? CreateMuteInteraction(targetClientId.Value, server, GetCommandName)
+                : CreateUnmuteInteraction(targetClientId.Value, server, GetCommandName);
+        });
+        return Task.CompletedTask;
+    }
+
+    private InteractionData CreateMuteInteraction(int targetClientId, Server server,
+        Func<Type, string> getCommandNameFunc)
+    {
+        var reasonInput = new
+        {
+            Name = "Reason",
+            Label = Utilities.CurrentLocalization.LocalizationIndex["WEBFRONT_ACTION_LABEL_REASON"],
+            Type = "text",
+            Values = (Dictionary<string, string>?)null
+        };
+
+        var durationInput = new
+        {
+            Name = "Duration",
+            Label = Utilities.CurrentLocalization.LocalizationIndex["WEBFRONT_ACTION_LABEL_DURATION"],
+            Type = "select",
+            Values = (Dictionary<string, string>?)new Dictionary<string, string>
+            {
+                {"5m", TimeSpan.FromMinutes(5).HumanizeForCurrentCulture()},
+                {"30m", TimeSpan.FromMinutes(30).HumanizeForCurrentCulture()},
+                {"1h", TimeSpan.FromHours(1).HumanizeForCurrentCulture()},
+                {"6h", TimeSpan.FromHours(6).HumanizeForCurrentCulture()},
+                {"1d", TimeSpan.FromDays(1).HumanizeForCurrentCulture()},
+                {"p", Utilities.CurrentLocalization.LocalizationIndex["WEBFRONT_ACTION_SELECTION_PERMANENT"]}
+            }
+        };
+
+        var inputs = new[] {reasonInput, durationInput};
+        var inputsJson = JsonSerializer.Serialize(inputs);
+
+        return new InteractionData
+        {
+            EntityId = targetClientId,
+            Name = Utilities.CurrentLocalization.LocalizationIndex["WEBFRONT_PROFILE_CONTEXT_MENU_ACTION_MUTE"],
+            DisplayMeta = "oi-volume-off",
+            ActionPath = "DynamicAction",
+            ActionMeta = new()
+            {
+                {"InteractionId", MuteInteraction},
+                {"Inputs", inputsJson},
+                {
+                    "ActionButtonLabel",
+                    Utilities.CurrentLocalization.LocalizationIndex["WEBFRONT_PROFILE_CONTEXT_MENU_ACTION_MUTE"]
+                },
+                {
+                    "Name",
+                    Utilities.CurrentLocalization.LocalizationIndex["WEBFRONT_PROFILE_CONTEXT_MENU_ACTION_MUTE"]
+                },
+                {"ShouldRefresh", true.ToString()}
+            },
+            MinimumPermission = Data.Models.Client.EFClient.Permission.Moderator,
+            Source = Name,
+            Action = async (originId, targetId, gameName, meta, cancellationToken) =>
+            {
+                if (!targetId.HasValue)
+                {
+                    return "No target client id specified";
+                }
+
+                var isTempMute = meta.ContainsKey(durationInput.Name) &&
+                                 meta[durationInput.Name] != durationInput.Values?.Last().Key;
+                var muteCommand = getCommandNameFunc(isTempMute ? typeof(TempMuteCommand) : typeof(MuteCommand));
+                var args = new List<string>();
+
+                if (meta.TryGetValue(durationInput.Name, out var duration) &&
+                    duration != durationInput.Values?.Last().Key)
+                {
+                    args.Add(duration);
+                }
+
+                if (meta.TryGetValue(reasonInput.Name, out var reason))
+                {
+                    args.Add(reason);
+                }
+
+                var commandResponse =
+                    await _remoteCommandService.Execute(originId, targetId, muteCommand, args, server);
+                return string.Join(".", commandResponse.Select(result => result.Response));
+            }
+        };
+    }
+
+    private InteractionData CreateUnmuteInteraction(int targetClientId, Server server,
+        Func<Type, string> getCommandNameFunc)
+    {
+        var reasonInput = new
+        {
+            Name = "Reason",
+            Label = Utilities.CurrentLocalization.LocalizationIndex["WEBFRONT_ACTION_LABEL_REASON"],
+            Type = "text",
+        };
+
+        var inputs = new[] {reasonInput};
+        var inputsJson = JsonSerializer.Serialize(inputs);
+
+        return new InteractionData
+        {
+            EntityId = targetClientId,
+            Name = Utilities.CurrentLocalization.LocalizationIndex[
+                "WEBFRONT_PROFILE_CONTEXT_MENU_ACTION_UNMUTE"],
+            DisplayMeta = "oi-volume-high",
+            ActionPath = "DynamicAction",
+            ActionMeta = new()
+            {
+                {"InteractionId", MuteInteraction},
+                {"Outputs", reasonInput.Name},
+                {"Inputs", inputsJson},
+                {
+                    "ActionButtonLabel",
+                    Utilities.CurrentLocalization.LocalizationIndex[
+                        "WEBFRONT_PROFILE_CONTEXT_MENU_ACTION_UNMUTE"]
+                },
+                {
+                    "Name",
+                    Utilities.CurrentLocalization.LocalizationIndex[
+                        "WEBFRONT_PROFILE_CONTEXT_MENU_ACTION_UNMUTE"]
+                },
+                {"ShouldRefresh", true.ToString()}
+            },
+            MinimumPermission = Data.Models.Client.EFClient.Permission.Moderator,
+            Source = Name,
+            Action = async (originId, targetId, gameName, meta, cancellationToken) =>
+            {
+                if (!targetId.HasValue)
+                {
+                    return "No target client id specified";
+                }
+
+                var args = new List<string>();
+
+                if (meta.TryGetValue(reasonInput.Name, out var reason))
+                {
+                    args.Add(reason);
+                }
+
+                var commandResponse =
+                    await _remoteCommandService.Execute(originId, targetId, getCommandNameFunc(typeof(UnmuteCommand)),
+                        args, server);
+                return string.Join(".", commandResponse.Select(result => result.Response));
+            }
+        };
+    }
+
+    public Task OnUnloadAsync()
+    {
+        _interactionRegistration.UnregisterInteraction(MuteInteraction);
+        return Task.CompletedTask;
+    }
+
+    public Task OnTickAsync(Server server)
+    {
+        return Task.CompletedTask;
+    }
+}

Plugins/ProfanityDeterment/ProfanityDeterment.csproj

@@ -16,7 +16,7 @@
   </PropertyGroup>
 
   <ItemGroup>
-    <PackageReference Include="RaidMax.IW4MAdmin.SharedLibraryCore" Version="2022.3.23.1" PrivateAssets="All" />
+    <PackageReference Include="RaidMax.IW4MAdmin.SharedLibraryCore" Version="2022.10.13.1" PrivateAssets="All" />
   </ItemGroup>
 
   <Target Name="PostBuild" AfterTargets="PostBuildEvent">

Plugins/ScriptPlugins/GameInterface.js

@@ -46,7 +46,7 @@ let plugin = {
                 break;
             case 'warn':
                 const warningTitle = _localization.LocalizationIndex['GLOBAL_WARNING'];
-                sendScriptCommand(server, 'Alert', gameEvent.Target, {
+                sendScriptCommand(server, 'Alert', gameEvent.Origin, gameEvent.Target, {
                     alertType: warningTitle + '!',
                     message: gameEvent.Data
                 });
@@ -72,27 +72,27 @@ let plugin = {
 };
 
 let commands = [{
-    name: 'giveweapon',
-    description: 'gives specified weapon',
-    alias: 'gw',
-    permission: 'SeniorAdmin',
-    targetRequired: true,
-    arguments: [{
-        name: 'player',
-        required: true
-    },
-        {
-            name: 'weapon name',
+        name: 'giveweapon',
+        description: 'gives specified weapon',
+        alias: 'gw',
+        permission: 'SeniorAdmin',
+        targetRequired: true,
+        arguments: [{
+            name: 'player',
             required: true
-        }],
-    supportedGames: ['IW4', 'IW5'],
-    execute: (gameEvent) => {
-        if (!validateEnabled(gameEvent.Owner, gameEvent.Origin)) {
-            return;
+        },
+            {
+                name: 'weapon name',
+                required: true
+            }],
+        supportedGames: ['IW4', 'IW5', 'T5'],
+        execute: (gameEvent) => {
+            if (!validateEnabled(gameEvent.Owner, gameEvent.Origin)) {
+                return;
+            }
+            sendScriptCommand(gameEvent.Owner, 'GiveWeapon', gameEvent.Origin, gameEvent.Target, {weaponName: gameEvent.Data});
         }
-        sendScriptCommand(gameEvent.Owner, 'GiveWeapon', gameEvent.Origin, gameEvent.Target, {weaponName: gameEvent.Data});
-    }
-},
+    },
     {
         name: 'takeweapons',
         description: 'take all weapons from specified player',
@@ -103,7 +103,7 @@ let commands = [{
             name: 'player',
             required: true
         }],
-        supportedGames: ['IW4', 'IW5'],
+        supportedGames: ['IW4', 'IW5', 'T5'],
         execute: (gameEvent) => {
             if (!validateEnabled(gameEvent.Owner, gameEvent.Origin)) {
                 return;
@@ -121,7 +121,7 @@ let commands = [{
             name: 'player',
             required: true
         }],
-        supportedGames: ['IW4', 'IW5'],
+        supportedGames: ['IW4', 'IW5', 'T5'],
         execute: (gameEvent) => {
             if (!validateEnabled(gameEvent.Owner, gameEvent.Origin)) {
                 return;
@@ -139,7 +139,7 @@ let commands = [{
             name: 'player',
             required: true
         }],
-        supportedGames: ['IW4', 'IW5'],
+        supportedGames: ['IW4', 'IW5', 'T5'],
         execute: (gameEvent) => {
             if (!validateEnabled(gameEvent.Owner, gameEvent.Origin)) {
                 return;
@@ -147,24 +147,6 @@ let commands = [{
             sendScriptCommand(gameEvent.Owner, 'LockControls', gameEvent.Origin, gameEvent.Target, undefined);
         }
     },
-    {
-        name: 'unlockcontrols',
-        description: 'unlocks target player\'s controls',
-        alias: 'ulc',
-        permission: 'Administrator',
-        targetRequired: true,
-        arguments: [{
-            name: 'player',
-            required: true
-        }],
-        supportedGames: ['IW4', 'IW5'],
-        execute: (gameEvent) => {
-            if (!validateEnabled(gameEvent.Owner, gameEvent.Origin)) {
-                return;
-            }
-            sendScriptCommand(gameEvent.Owner, 'UnlockControls', gameEvent.Origin, gameEvent.Target, undefined);
-        }
-    },
     {
         name: 'noclip',
         description: 'enable noclip on yourself ingame',
@@ -180,21 +162,6 @@ let commands = [{
             sendScriptCommand(gameEvent.Owner, 'NoClip', gameEvent.Origin, gameEvent.Origin, undefined);
         }
     },
-    {
-        name: 'noclipoff',
-        description: 'disable noclip on yourself ingame',
-        alias: 'nco',
-        permission: 'SeniorAdmin',
-        targetRequired: false,
-        arguments: [],
-        supportedGames: ['IW4', 'IW5'],
-        execute: (gameEvent) => {
-            if (!validateEnabled(gameEvent.Owner, gameEvent.Origin)) {
-                return;
-            }
-            sendScriptCommand(gameEvent.Owner, 'NoClipOff', gameEvent.Origin, gameEvent.Origin, undefined);
-        }
-    },
     {
         name: 'hide',
         description: 'hide yourself ingame',
@@ -202,7 +169,7 @@ let commands = [{
         permission: 'SeniorAdmin',
         targetRequired: false,
         arguments: [],
-        supportedGames: ['IW4', 'IW5'],
+        supportedGames: ['IW4', 'IW5', 'T5'],
         execute: (gameEvent) => {
             if (!validateEnabled(gameEvent.Owner, gameEvent.Origin)) {
                 return;
@@ -210,21 +177,6 @@ let commands = [{
             sendScriptCommand(gameEvent.Owner, 'Hide', gameEvent.Origin, gameEvent.Origin, undefined);
         }
     },
-    {
-        name: 'unhide',
-        description: 'unhide yourself ingame',
-        alias: 'unh',
-        permission: 'SeniorAdmin',
-        targetRequired: false,
-        arguments: [],
-        supportedGames: ['IW4', 'IW5'],
-        execute: (gameEvent) => {
-            if (!validateEnabled(gameEvent.Owner, gameEvent.Origin)) {
-                return;
-            }
-            sendScriptCommand(gameEvent.Owner, 'Unhide', gameEvent.Origin, gameEvent.Origin, undefined);
-        }
-    },
     {
         name: 'alert',
         description: 'alert a player',
@@ -239,7 +191,7 @@ let commands = [{
                 name: 'message',
                 required: true
             }],
-        supportedGames: ['IW4', 'IW5'],
+        supportedGames: ['IW4', 'IW5', 'T5'],
         execute: (gameEvent) => {
             if (!validateEnabled(gameEvent.Owner, gameEvent.Origin)) {
                 return;
@@ -260,7 +212,7 @@ let commands = [{
             name: 'player',
             required: true
         }],
-        supportedGames: ['IW4', 'IW5'],
+        supportedGames: ['IW4', 'IW5', 'T5'],
         execute: (gameEvent) => {
             if (!validateEnabled(gameEvent.Owner, gameEvent.Origin)) {
                 return;
@@ -278,7 +230,7 @@ let commands = [{
             name: 'player',
             required: true
         }],
-        supportedGames: ['IW4', 'IW5'],
+        supportedGames: ['IW4', 'IW5', 'T5'],
         execute: (gameEvent) => {
             if (!validateEnabled(gameEvent.Owner, gameEvent.Origin)) {
                 return;
@@ -304,7 +256,7 @@ let commands = [{
                 name: 'z',
                 required: true
             }],
-        supportedGames: ['IW4', 'IW5'],
+        supportedGames: ['IW4', 'IW5', 'T5'],
         execute: (gameEvent) => {
             if (!validateEnabled(gameEvent.Owner, gameEvent.Origin)) {
                 return;
@@ -328,7 +280,7 @@ let commands = [{
             name: 'player',
             required: true
         }],
-        supportedGames: ['IW4', 'IW5'],
+        supportedGames: ['IW4', 'IW5', 'T5'],
         execute: (gameEvent) => {
             if (!validateEnabled(gameEvent.Owner, gameEvent.Origin)) {
                 return;
@@ -336,21 +288,6 @@ let commands = [{
             sendScriptCommand(gameEvent.Owner, 'Kill', gameEvent.Origin, gameEvent.Target, undefined);
         }
     },
-    {
-        name: 'nightmode',
-        description: 'sets server into nightmode',
-        alias: 'nitem',
-        permission: 'SeniorAdmin',
-        targetRequired: false,
-        arguments: [],
-        supportedGames: ['IW4', 'IW5'],
-        execute: (gameEvent) => {
-            if (!validateEnabled(gameEvent.Owner, gameEvent.Origin)) {
-                return;
-            }
-            sendScriptCommand(gameEvent.Owner, 'NightMode', gameEvent.Origin, undefined, undefined);
-        }
-    },
     {
         name: 'setspectator',
         description: 'sets a player as spectator',
@@ -361,7 +298,7 @@ let commands = [{
             name: 'player',
             required: true
         }],
-        supportedGames: ['IW4', 'IW5'],
+        supportedGames: ['IW4', 'IW5', 'T5'],
         execute: (gameEvent) => {
             if (!validateEnabled(gameEvent.Owner, gameEvent.Origin)) {
                 return;
@@ -437,6 +374,15 @@ const initialize = (server) => {
     return true;
 }
 
+const getClientStats = (client, server) => {
+    const contextFactory = _serviceResolver.ResolveService('IDatabaseContextFactory');
+    const context = contextFactory.CreateContext(false);
+    const stats = context.ClientStatistics.GetClientsStatData([client.ClientId], server.GetId()); // .Find(client.ClientId, serverId);
+    context.Dispose();
+    
+    return  stats.length > 0 ? stats[0] : undefined;
+}
+
 function onReceivedDvar(server, dvarName, dvarValue, success) {
     const logger = _serviceResolver.ResolveService('ILogger');
     logger.WriteDebug(`Received ${dvarName}=${dvarValue} success=${success}`);
@@ -463,7 +409,11 @@ function onReceivedDvar(server, dvarName, dvarValue, success) {
     if (input.length > 0) {
         const event = parseEvent(input)
 
-        logger.WriteDebug(`Processing input... ${event.eventType} ${event.subType} ${event.data} ${event.clientNumber}`);
+        logger.WriteDebug(`Processing input... ${event.eventType} ${event.subType} ${event.data.toString()} ${event.clientNumber}`);
+
+        const metaService = _serviceResolver.ResolveService('IMetaServiceV2');
+        const threading = importNamespace('System.Threading');
+        const token = new threading.CancellationTokenSource().Token;
 
         // todo: refactor to mapping if possible
         if (event.eventType === 'ClientDataRequested') {
@@ -474,15 +424,21 @@ function onReceivedDvar(server, dvarName, dvarValue, success) {
 
                 let data = [];
 
+                const metaService = _serviceResolver.ResolveService('IMetaServiceV2');
+
                 if (event.subType === 'Meta') {
-                    const metaService = _serviceResolver.ResolveService('IMetaService');
-                    const meta = metaService.GetPersistentMeta(event.data, client).GetAwaiter().GetResult();
+                    const meta = metaService.GetPersistentMeta(event.data, client.ClientId, token).GetAwaiter().GetResult();
                     data[event.data] = meta === null ? '' : meta.Value;
+                    logger.WriteDebug(`event data is ${event.data}`);
                 } else {
+                    const clientStats = getClientStats(client, server);
+                    const tagMeta = metaService.GetPersistentMetaByLookup('ClientTagV2', 'ClientTagNameV2', client.ClientId, token).GetAwaiter().GetResult();
                     data = {
                         level: client.Level,
                         clientId: client.ClientId,
-                        lastConnection: client.LastConnection
+                        lastConnection: client.LastConnection,
+                        tag: tagMeta?.Value ?? '',
+                        performance:  clientStats?.Performance ?? 200.0
                     };
                 }
 
@@ -510,19 +466,21 @@ function onReceivedDvar(server, dvarName, dvarValue, success) {
                 sendEvent(server, false, 'SetClientDataCompleted', 'Meta', {ClientNumber: event.clientNumber}, undefined, {status: 'Fail'});
             } else {
                 if (event.subType === 'Meta') {
-                    const metaService = _serviceResolver.ResolveService('IMetaService');
                     try {
-                        logger.WriteDebug(`Key=${event.data['key']}, Value=${event.data['value']}`);
-                        if (event.data['direction'] != null) {
-                            event.data['direction'] = 'up'
-                                ? metaService.IncrementPersistentMeta(event.data['key'], event.data['value'], clientId).GetAwaiter().GetResult()
-                                : metaService.DecrementPersistentMeta(event.data['key'], event.data['value'], clientId).GetAwaiter().GetResult();
-                        } else {
-                            metaService.SetPersistentMeta(event.data['key'], event.data['value'], clientId).GetAwaiter().GetResult();
+                        if (event.data['value'] != null && event.data['key'] != null) {
+                            logger.WriteDebug(`Key=${event.data['key']}, Value=${event.data['value']}, Direction=${event.data['direction']} ${token}`);
+                            if (event.data['direction'] != null) {
+                                event.data['direction'] = 'up'
+                                    ? metaService.IncrementPersistentMeta(event.data['key'], parseInt(event.data['value']), clientId, token).GetAwaiter().GetResult()
+                                    : metaService.DecrementPersistentMeta(event.data['key'], parseInt(event.data['value']), clientId, token).GetAwaiter().GetResult();
+                            } else {
+                                metaService.SetPersistentMeta(event.data['key'], event.data['value'], clientId, token).GetAwaiter().GetResult();
+                            }
                         }
                         sendEvent(server, false, 'SetClientDataCompleted', 'Meta', {ClientNumber: event.clientNumber}, undefined, {status: 'Complete'});
                     } catch (error) {
                         sendEvent(server, false, 'SetClientDataCompleted', 'Meta', {ClientNumber: event.clientNumber}, undefined, {status: 'Fail'});
+                        logger.WriteError('Could not persist client meta ' + error.toString());
                     }
                 }
             }
@@ -555,11 +513,13 @@ const pollForEvents = server => {
     }
 
     if (server.Throttled) {
+        logger.WriteDebug('Server is throttled so we are not polling for game data');
         return;
     }
 
     if (!state.waitingOnInput) {
         state.waitingOnInput = true;
+        logger.WriteDebug('Attempting to get in dvar value');
         getDvar(server, inDvar, onReceivedDvar);
     }
 
@@ -623,7 +583,7 @@ const parseDataString = data => {
         dict[keyValue[0]] = keyValue[1];
     }
 
-    return dict.length === 0 ? data : dict;
+    return Object.keys(dict).length === 0 ? data : dict;
 }
 
 const validateEnabled = (server, origin) => {

Plugins/ScriptPlugins/ParserCoD4x.js

@@ -3,7 +3,7 @@ var eventParser;
 
 var plugin = {
     author: 'FrenchFry, RaidMax',
-    version: 0.8,
+    version: 0.9,
     name: 'CoD4x Parser',
     isParser: true,
 
@@ -15,7 +15,7 @@ var plugin = {
         eventParser = manager.GenerateDynamicEventParser(this.name);
 
         rconParser.Configuration.StatusHeader.Pattern = 'num +score +ping +playerid +steamid +name +lastmsg +address +qport +rate *';
-        rconParser.Configuration.Status.Pattern = '^ *([0-9]+) +-?([0-9]+) +((?:[A-Z]+|[0-9]+)) +((?:[a-z]|[0-9]{16,32})|0) +([[0-9]+|0]) +(.{0,32}) +([0-9]+) +(\\d+\\.\\d+\\.\\d+.\\d+\\:-*\\d{1,5}|0+.0+:-*\\d{1,5}|loopback|bot) +(-*[0-9]+) +([0-9]+) *$';
+        rconParser.Configuration.Status.Pattern = '^ *([0-9]+) +-?([0-9]+) +((?:[A-Z]+|[0-9]+)) +((?:[a-z]|[0-9]{16,32})|0) +([[0-9]+|0]) +(.{0,34}) +([0-9]+) +(\\d+\\.\\d+\\.\\d+.\\d+\\:-*\\d{1,5}|0+.0+:-*\\d{1,5}|loopback|bot) +(-*[0-9]+) +([0-9]+) *$';
         rconParser.Configuration.Status.AddMapping(104, 6); // RConName
         rconParser.Configuration.Status.AddMapping(105, 8); // RConIPAddress
         rconParser.Configuration.CommandPrefixes.RConResponse = '\xff\xff\xff\xffprint\n';
@@ -41,4 +41,4 @@ var plugin = {
 
     onTickAsync: function (server) {
     }
-};
+};

Plugins/ScriptPlugins/ParserIW6x.js

@@ -20,7 +20,7 @@ var plugin = {
         rconParser.Configuration.CommandPrefixes.Ban = 'clientkick {0} "{1}"';
         rconParser.Configuration.CommandPrefixes.TempBan = 'clientkick {0} "{1}"';
         rconParser.Configuration.CommandPrefixes.RConResponse = '\xff\xff\xff\xffprint\n';
-        rconParser.Configuration.Dvar.Pattern = '^ *\\"(.+)\\" is: \\"(.+)?\\" default: \\"(.+)?\\"\\n(?:latched: \\"(.+)?\\"\\n)? *(.+)$';
+        rconParser.Configuration.Dvar.Pattern = '^ *\\"(.+)\\" is: \\"(.+)?\\" default: \\"(.+)?\\"\\n?(?:latched: \\"(.+)?\\"\\n?)? *(.+)$';
         rconParser.Configuration.Status.Pattern = '^ *([0-9]+) +-?([0-9]+) +(Yes|No) +((?:[A-Z]+|[0-9]+)) +((?:[a-z]|[0-9]){8,32}|(?:[a-z]|[0-9]){8,32}|bot[0-9]+|(?:[0-9]+)) *(.{0,32}) +(\\d+\\.\\d+\\.\\d+.\\d+\\:-*\\d{1,5}|0+.0+:-*\\d{1,5}|loopback|unknown|bot) +(-*[0-9]+) *$';
         rconParser.Configuration.StatusHeader.Pattern = 'num +score +bot +ping +guid +name +address +qport *';
         rconParser.Configuration.WaitForResponse = false;

Plugins/ScriptPlugins/ParserPT6.js

@@ -3,7 +3,7 @@ var eventParser;
 
 var plugin = {
     author: 'RaidMax, Xerxes',
-    version: 1.2,
+    version: 1.4,
     name: 'Plutonium T6 Parser',
     isParser: true,
 
@@ -29,9 +29,10 @@ var plugin = {
         rconParser.Configuration.NoticeLineSeparator = '. ';
         rconParser.Configuration.DefaultRConPort = 4976;
         rconParser.Configuration.DefaultInstallationDirectoryHint = '{LocalAppData}/Plutonium/storage/t6';
+        rconParser.Configuration.ShouldRemoveDiacritics = true;
 
         rconParser.Configuration.StatusHeader.Pattern = 'num +score +bot +ping +guid +name +lastmsg +address +qport +rate *';
-        rconParser.Configuration.Status.Pattern = '^ *([0-9]+) +([0-9]+) +(?:[0-1]{1}) +([0-9]+) +([A-F0-9]+|0) +(.+?) +(?:[0-9]+) +(\\d+\\.\\d+\\.\\d+\\.\\d+\\:-?\\d{1,5}|0+\\.0+:-?\\d{1,5}|loopback) +(?:-?[0-9]+) +(?:[0-9]+) *$';
+        rconParser.Configuration.Status.Pattern = '^ *([0-9]+) +([0-9]+) +(?:[0-1]{1}) +([0-9]+) +([A-F0-9]+|0) +(.+?) +(?:[0-9]+) +(\\d+\\.\\d+\\.\\d+\\.\\d+\\:-?\\d{1,5}|0+\\.0+:-?\\d{1,5}|loopback|unknown) +(?:-?[0-9]+) +(?:[0-9]+) *$';
         rconParser.Configuration.Status.AddMapping(100, 1);
         rconParser.Configuration.Status.AddMapping(101, 2);
         rconParser.Configuration.Status.AddMapping(102, 3);

Plugins/ScriptPlugins/ParserPlutoniumT5.js

@@ -0,0 +1,44 @@
+var rconParser;
+var eventParser;
+
+var plugin = {
+    author: 'RaidMax',
+    version: 0.2,
+    name: 'Plutonium T5 Parser',
+    isParser: true,
+
+    onEventAsync: function (gameEvent, server) {
+    },
+
+    onLoadAsync: function (manager) {
+        rconParser = manager.GenerateDynamicRConParser(this.name);
+        eventParser = manager.GenerateDynamicEventParser(this.name);
+
+        rconParser.Configuration.DefaultInstallationDirectoryHint = '{LocalAppData}/Plutonium/storage/t5';
+        rconParser.Configuration.CommandPrefixes.RConResponse = '\xff\xff\xff\xffprint\n';
+        rconParser.Configuration.Dvar.Pattern = '^(?:\\^7)?\\"(.+)\\" is: \\"(.+)?\\" default: \\"(.+)?\\"\\n?(?:latched: \\"(.+)?\\"\\n)?\\w*(.+)*$';
+        rconParser.Configuration.CommandPrefixes.Tell = 'tell {0} {1}';
+        rconParser.Configuration.CommandPrefixes.RConGetInfo = undefined;
+        rconParser.Configuration.GuidNumberStyle = 7; // Integer
+        rconParser.Configuration.DefaultRConPort = 3074;
+        rconParser.Configuration.CanGenerateLogPath = false;
+
+        rconParser.Configuration.OverrideCommandTimeouts.Clear();
+        rconParser.Configuration.OverrideCommandTimeouts.Add('map', 0);
+        rconParser.Configuration.OverrideCommandTimeouts.Add('map_rotate', 0);
+        rconParser.Configuration.OverrideCommandTimeouts.Add('fast_restart', 0);
+
+        rconParser.Version = 'Call of Duty Multiplayer - Ship COD_T5_S MP build 7.0.189 CL(1022875) CODPCAB-V64 CEG Wed Nov 02 18:02:23 2011 win-x86';
+        rconParser.GameName = 6; //  T5
+        eventParser.Version = 'Call of Duty Multiplayer - Ship COD_T5_S MP build 7.0.189 CL(1022875) CODPCAB-V64 CEG Wed Nov 02 18:02:23 2011 win-x86';
+        eventParser.GameName = 6; // T5
+        eventParser.Configuration.GuidNumberStyle = 7; // Integer
+
+    },
+
+    onUnloadAsync: function () {
+    },
+
+    onTickAsync: function (server) {
+    }
+};

Plugins/ScriptPlugins/ParserS1x.js

@@ -17,7 +17,7 @@ var plugin = {
         rconParser.Configuration.CommandPrefixes.Ban = 'kickClient {0} "{1}"';
         rconParser.Configuration.CommandPrefixes.TempBan = 'kickClient {0} "{1}"';
         rconParser.Configuration.CommandPrefixes.RConResponse = '\xff\xff\xff\xffprint';
-        rconParser.Configuration.Dvar.Pattern = '^ *\\"(.+)\\" is: \\"(.+)?\\" default: \\"(.+)?\\"\\n(?:latched: \\"(.+)?\\"\\n)? *(.+)$';
+        rconParser.Configuration.Dvar.Pattern = '^ *\\"(.+)\\" is: \\"(.+)?\\" default: \\"(.+)?\\"\\n?(?:latched: \\"(.+)?\\"\\n?)? *(.+)$';
         rconParser.Configuration.Status.Pattern = '^ *([0-9]+) +-?([0-9]+) +(Yes|No) +((?:[A-Z]+|[0-9]+)) +((?:[a-z]|[0-9]){8,32}|(?:[a-z]|[0-9]){8,32}|bot[0-9]+|(?:[0-9]+)) *(.{0,32}) +(\\d+\\.\\d+\\.\\d+.\\d+\\:-*\\d{1,5}|0+.0+:-*\\d{1,5}|loopback|unknown|bot) +(-*[0-9]+) *$';
         rconParser.Configuration.StatusHeader.Pattern = 'num +score +bot +ping +guid +name +address +qport *';
         rconParser.Configuration.Status.AddMapping(102, 4);
@@ -37,4 +37,4 @@ var plugin = {
     onUnloadAsync: function() {},
 
     onTickAsync: function(server) {}
-};
+};

Plugins/ScriptPlugins/ParserT4.js

@@ -3,7 +3,7 @@ var eventParser;
 
 var plugin = {
     author: 'RaidMax',
-    version: 0.2,
+    version: 0.3,
     name: 'Call of Duty 5: World at War Parser',
     isParser: true,
 
@@ -17,6 +17,7 @@ var plugin = {
         rconParser.Configuration.GuidNumberStyle = 7; // Integer
         rconParser.Configuration.DefaultRConPort = 28960;
         rconParser.Version = 'Call of Duty Multiplayer COD_WaW MP build 1.7.1263 CL(350073) JADAMS2 Thu Oct 29 15:43:55 2009 win-x86';
+        rconParser.GameName = 5; // T4
         
         eventParser.Configuration.GuidNumberStyle = 7; // Integer
         eventParser.GameName = 5; // T4

Plugins/ScriptPlugins/ParserT7.js

@@ -3,7 +3,7 @@ var eventParser;
 
 var plugin = {
     author: 'RaidMax',
-    version: 0.4,
+    version: 0.5,
     name: 'Black Ops 3 Parser',
     isParser: true,
 
@@ -15,7 +15,7 @@ var plugin = {
         eventParser = manager.GenerateDynamicEventParser(this.name);
 
         rconParser.Configuration.Status.Pattern = '^ *([0-9]+) +-?([0-9]+) +((?:[A-Z]+|[0-9]+)) +((?:[a-z]|[0-9]){8,32}|(?:[a-z]|[0-9]){8,32}|bot[0-9]+|(?:[0-9]+)) *(.{0,32}) +(\\d+\\.\\d+\\.\\d+.\\d+\\:-*\\d{1,5}|0+.0+:-*\\d{1,5}|loopback|unknown)(?:\\([0-9]+\\)) +(-*[0-9]+) *$';
-        rconParser.Configuration.StatusHeader.Pattern           = 'num +score +ping +xuid +name +address +qport';
+        rconParser.Configuration.StatusHeader.Pattern           = 'num +score +ping +xuid +name +address +qport|---------- Live ----------';
         rconParser.Configuration.CommandPrefixes.Kick           = 'clientkick {0}';
         rconParser.Configuration.CommandPrefixes.Ban            = 'clientkick {0}';
         rconParser.Configuration.CommandPrefixes.TempBan        = 'tempbanclient {0}';
@@ -30,6 +30,7 @@ var plugin = {
         rconParser.Configuration.DefaultRConPort = 27016;
 
         rconParser.Configuration.OverrideDvarNameMapping.Add('sv_hostname', 'live_steam_server_name');
+        rconParser.Configuration.OverrideDvarNameMapping.Add('g_password', 'live_steam_server_password');
         rconParser.Configuration.DefaultDvarValues.Add('sv_running', '1');
         rconParser.Configuration.DefaultDvarValues.Add('g_gametype', '');
         rconParser.Configuration.DefaultDvarValues.Add('fs_basepath', '');

Plugins/ScriptPlugins/SubnetBan.js

@@ -1,5 +1,6 @@
 const cidrRegex = /^([0-9]{1,3}\.){3}[0-9]{1,3}(\/([0-9]|[1-2][0-9]|3[0-2]))?$/;
 const validCIDR = input => cidrRegex.test(input);
+const subnetBanlistKey = 'Webfront::Nav::Admin::SubnetBanlist';
 let subnetList = [];
 
 const commands = [{
@@ -26,7 +27,36 @@ const commands = [{
 
         gameEvent.Origin.Tell(`Added ${input} to subnet banlist`);
     }
-}];
+},
+    {
+        name: 'unbansubnet',
+        description: 'unbans an IPv4 subnet',
+        alias: 'ubs',
+        permission: 'SeniorAdmin',
+        targetRequired: false,
+        arguments: [{
+            name: 'subnet in IPv4 CIDR notation',
+            required: true
+        }],
+        execute: (gameEvent) => {
+            const input = String(gameEvent.Data).trim();
+
+            if (!validCIDR(input)) {
+                gameEvent.Origin.Tell('Invalid CIDR input');
+                return;
+            }
+
+            if (!subnetList.includes(input)) {
+                gameEvent.Origin.Tell('Subnet is not banned');
+                return;
+            }
+
+            subnetList = subnetList.filter(item => item !== input);
+            _configHandler.SetValue('SubnetBanList', subnetList);
+
+            gameEvent.Origin.Tell(`Removed ${input} from subnet banlist`);
+        }
+    }];
 
 convertIPtoLong = ip => {
     let components = String(ip).match(/^(\d{1,3})\.(\d{1,3})\.(\d{1,3})\.(\d{1,3})$/);
@@ -66,7 +96,7 @@ isSubnetBanned = (ip, list) => {
 
 const plugin = {
     author: 'RaidMax',
-    version: 1.0,
+    version: 1.1,
     name: 'Subnet Banlist Plugin',
     manager: null,
     logger: null,
@@ -86,7 +116,8 @@ const plugin = {
         this.manager = manager;
         this.logger = manager.GetLogger(0);
         this.configHandler = _configHandler;
-        this.subnetList = [];
+        subnetList = [];
+        this.interactionRegistration = _serviceResolver.ResolveService('IInteractionRegistration');
 
         const list = this.configHandler.GetValue('SubnetBanList');
         if (list !== undefined) {
@@ -105,9 +136,58 @@ const plugin = {
             this.banMessage = 'You are not allowed to join this server.';
             this.configHandler.SetValue('BanMessage', this.banMessage);
         }
+
+        this.interactionRegistration.RegisterScriptInteraction(subnetBanlistKey, plugin.name, (targetId, game, token) => {
+            const helpers = importNamespace('SharedLibraryCore.Helpers');
+            const interactionData = new helpers.InteractionData();
+
+            interactionData.Name = 'Subnet Banlist'; // navigation link name
+            interactionData.Description = `List of banned subnets (${subnetList.length} Total)`;  // alt and title
+            interactionData.DisplayMeta = 'oi-circle-x'; // nav icon
+            interactionData.InteractionId = subnetBanlistKey;
+            interactionData.MinimumPermission = 3; // moderator
+            interactionData.InteractionType = 2; // 1 is RawContent for apis etc..., 2 is 
+            interactionData.Source = plugin.name;
+
+            interactionData.ScriptAction = (sourceId, targetId, game, meta, token) => {
+                let table = '<table class="table bg-dark-dm bg-light-lm">';
+
+                const unbanSubnetInteraction = {
+                    InteractionId: 'command',
+                    Data: 'unbansubnet',
+                    ActionButtonLabel: 'Unban',
+                    Name: 'Unban Subnet'
+                };
+
+                subnetList.forEach(subnet => {
+                    unbanSubnetInteraction.Data += ' ' + subnet
+                    table += `<tr>
+                                    <td>
+                                        <p>${subnet}</p>
+                                    </td>
+                                    <td>
+                                        <a href="#" class="profile-action no-decoration float-right" data-action="DynamicAction"
+                                           data-action-meta="${encodeURI(JSON.stringify(unbanSubnetInteraction))}"> 
+                                            <div class="btn">
+                                                <i class="oi oi-circle-x mr-5 font-size-12"></i>
+                                                <span class="text-truncate">Unban Subnet</span>
+                                            </div>
+                                        </a>
+                                    </td>
+                                </tr>`;
+                });
+
+                table += '</table>';
+
+                return table;
+            }
+
+            return interactionData;
+        });
     },
 
     onUnloadAsync: () => {
+        this.interactionRegistration.UnregisterInteraction(subnetBanlistKey);
     },
 
     onTickAsync: server => {

Plugins/ScriptPlugins/VPNDetection.js

@@ -1,12 +1,15 @@
 let vpnExceptionIds = [];
+const vpnAllowListKey = 'Webfront::Nav::Admin::VPNAllowList';
+const vpnWhitelistKey = 'Webfront::Profile::VPNWhitelist';
+
 const commands = [{
-    name: "whitelistvpn",
-    description: "whitelists a player's client id from VPN detection",
-    alias: "wv",
-    permission: "SeniorAdmin",
+    name: 'whitelistvpn',
+    description: 'whitelists a player\'s client id from VPN detection',
+    alias: 'wv',
+    permission: 'SeniorAdmin',
     targetRequired: true,
     arguments: [{
-        name: "player",
+        name: 'player',
         required: true
     }],
     execute: (gameEvent) => {
@@ -15,21 +18,47 @@ const commands = [{
 
         gameEvent.Origin.Tell(`Successfully whitelisted ${gameEvent.Target.Name}`);
     }
+},
+{
+    name: 'disallowvpn',
+    description: 'disallows a player from connecting with a VPN',
+    alias: 'dv',
+    permission: 'SeniorAdmin',
+    targetRequired: true,
+    arguments: [{
+        name: 'player',
+        required: true
+    }],
+    execute: (gameEvent) => {
+        vpnExceptionIds = vpnExceptionIds.filter(exception => parseInt(exception) !== parseInt(gameEvent.Target.ClientId));
+        plugin.configHandler.SetValue('vpnExceptionIds', vpnExceptionIds);
+
+        gameEvent.Origin.Tell(`Successfully disallowed ${gameEvent.Target.Name} from connecting with VPN`);
+    }
 }];
 
+const getClientsData = (clientIds) => {
+    const contextFactory = _serviceResolver.ResolveService('IDatabaseContextFactory');
+    const context = contextFactory.CreateContext(false);
+    const clientSet = context.Clients;
+    const clients = clientSet.GetClientsBasicData(clientIds);
+    context.Dispose();
+
+    return clients;
+}
+
 const plugin = {
     author: 'RaidMax',
-    version: 1.3,
+    version: 1.5,
     name: 'VPN Detection Plugin',
     manager: null,
     logger: null,
 
-
     checkForVpn: function (origin) {
         let exempt = false;
         // prevent players that are exempt from being kicked
         vpnExceptionIds.forEach(function (id) {
-            if (id === origin.ClientId) {
+            if (parseInt(id) === parseInt(origin.ClientId)) {
                 exempt = true;
                 return false;
             }
@@ -80,11 +109,103 @@ const plugin = {
         this.logger = manager.GetLogger(0);
 
         this.configHandler = _configHandler;
-        this.configHandler.GetValue('vpnExceptionIds').forEach(element => vpnExceptionIds.push(element));
+        this.configHandler.GetValue('vpnExceptionIds').forEach(element => vpnExceptionIds.push(parseInt(element)));
         this.logger.WriteInfo(`Loaded ${vpnExceptionIds.length} ids into whitelist`);
+
+        this.interactionRegistration = _serviceResolver.ResolveService('IInteractionRegistration');
+
+        // registers the profile action
+        this.interactionRegistration.RegisterScriptInteraction(vpnWhitelistKey, this.name, (targetId, game, token) => {
+            const helpers = importNamespace('SharedLibraryCore.Helpers');
+            const interactionData = new helpers.InteractionData();
+
+            interactionData.ActionPath = 'DynamicAction';
+            interactionData.InteractionId = vpnWhitelistKey;
+            interactionData.EntityId = targetId;
+            interactionData.MinimumPermission = 3;
+            interactionData.Source = this.name;
+            interactionData.ActionMeta.Add('InteractionId', 'command'); // indicate we're wanting to execute a command
+            interactionData.ActionMeta.Add('ShouldRefresh', true.toString()); // indicates that the page should refresh after performing the action
+
+            if (vpnExceptionIds.includes(targetId)) {
+                interactionData.Name = _localization.LocalizationIndex['WEBFRONT_VPN_BUTTON_DISALLOW']; // text for the profile button
+                interactionData.DisplayMeta = 'oi-circle-x';
+
+                interactionData.ActionMeta.Add('Data', `disallowvpn`);         // command to execute
+                interactionData.ActionMeta.Add('ActionButtonLabel', _localization.LocalizationIndex['WEBFRONT_VPN_ACTION_DISALLOW_CONFIRM']);   // confirm button on the dialog
+                interactionData.ActionMeta.Add('Name', _localization.LocalizationIndex['WEBFRONT_VPN_ACTION_DISALLOW_TITLE']);                 // title on the confirm dialog
+            } else {
+                interactionData.Name = _localization.LocalizationIndex['WEBFRONT_VPN_ACTION_ALLOW']; // text for the profile button
+                interactionData.DisplayMeta = 'oi-circle-check';
+                
+                interactionData.ActionMeta.Add('Data', `whitelistvpn`);         // command to execute
+                interactionData.ActionMeta.Add('ActionButtonLabel', _localization.LocalizationIndex['WEBFRONT_VPN_ACTION_ALLOW_CONFIRM']);   // confirm button on the dialog
+                interactionData.ActionMeta.Add('Name', _localization.LocalizationIndex['WEBFRONT_VPN_ACTION_ALLOW_TITLE']);                 // title on the confirm dialog
+            }
+
+            return interactionData;
+        });
+
+        // registers the navigation/page
+        this.interactionRegistration.RegisterScriptInteraction(vpnAllowListKey, this.name, (targetId, game, token) => {
+
+            const helpers = importNamespace('SharedLibraryCore.Helpers');
+            const interactionData = new helpers.InteractionData();
+            
+            interactionData.Name = _localization.LocalizationIndex['WEBFRONT_NAV_VPN_TITLE'];         // navigation link name
+            interactionData.Description =  _localization.LocalizationIndex['WEBFRONT_NAV_VPN_DESC'];  // alt and title
+            interactionData.DisplayMeta = 'oi-circle-check'; // nav icon
+            interactionData.InteractionId = vpnAllowListKey;
+            interactionData.MinimumPermission = 3; // moderator
+            interactionData.InteractionType = 2; // 1 is RawContent for apis etc..., 2 is 
+            interactionData.Source = this.name;
+
+            interactionData.ScriptAction = (sourceId, targetId, game, meta, token) => {
+                const clientsData = getClientsData(vpnExceptionIds);
+
+                let table = '<table class="table bg-dark-dm bg-light-lm">';
+
+                const disallowInteraction = {
+                    InteractionId: 'command',
+                    Data: 'disallowvpn',
+                    ActionButtonLabel: _localization.LocalizationIndex['WEBFRONT_VPN_ACTION_DISALLOW_CONFIRM'],
+                    Name: _localization.LocalizationIndex['WEBFRONT_VPN_ACTION_DISALLOW_TITLE']
+                };
+
+                if (clientsData.length === 0)
+                {
+                    table += `<tr><td>No players are whitelisted.</td></tr>`
+                }
+
+                clientsData.forEach(client => {
+                    table +=    `<tr>
+                                    <td>
+                                        <a href="/Client/Profile/${client.ClientId}" class="level-color-${client.Level.toLowerCase()} no-decoration">${client.CurrentAlias.Name.StripColors()}</a>
+                                    </td>
+                                    <td>
+                                        <a href="#" class="profile-action no-decoration float-right" data-action="DynamicAction" data-action-id="${client.ClientId}"
+                                           data-action-meta="${encodeURI(JSON.stringify(disallowInteraction))}">
+                                            <div class="btn">
+                                                <i class="oi oi-circle-x mr-5 font-size-12"></i>
+                                                <span class="text-truncate">${_localization.LocalizationIndex['WEBFRONT_VPN_BUTTON_DISALLOW']}</span>
+                                            </div>
+                                        </a>
+                                    </td>
+                                </tr>`;
+                });
+
+                table += '</table>';
+                
+                return table;
+            }
+            
+            return interactionData;
+        });
     },
 
     onUnloadAsync: function () {
+        this.interactionRegistration.UnregisterInteraction(vpnWhitelistKey);
+        this.interactionRegistration.UnregisterInteraction(vpnAllowListKey);
     },
 
     onTickAsync: function (server) {

Plugins/Stats/Client/ServerDistributionCalculator.cs

@@ -1,6 +1,7 @@
 using System;
 using System.Collections.Generic;
 using System.Linq;
+using System.Threading;
 using System.Threading.Tasks;
 using Data.Abstractions;
 using Data.Models.Client;
@@ -88,8 +89,8 @@ namespace Stats.Client
                 return zScore ?? 0;
             }, MaxZScoreCacheKey, Utilities.IsDevelopment ? TimeSpan.FromMinutes(5) : TimeSpan.FromMinutes(30));
 
-            await _distributionCache.GetCacheItem(DistributionCacheKey);
-            await _maxZScoreCache.GetCacheItem(MaxZScoreCacheKey);
+            await _distributionCache.GetCacheItem(DistributionCacheKey, new CancellationToken());
+            await _maxZScoreCache.GetCacheItem(MaxZScoreCacheKey, new CancellationToken());
 
             /*foreach (var serverId in _serverIds)
             {
@@ -132,7 +133,7 @@ namespace Stats.Client
 
         public async Task<double> GetZScoreForServer(long serverId, double value)
         {
-            var serverParams = await _distributionCache.GetCacheItem(DistributionCacheKey);
+            var serverParams = await _distributionCache.GetCacheItem(DistributionCacheKey, new CancellationToken());
             if (!serverParams.ContainsKey(serverId))
             {
                 return 0.0;
@@ -150,7 +151,7 @@ namespace Stats.Client
 
         public async Task<double?> GetRatingForZScore(double? value)
         {
-            var maxZScore = await _maxZScoreCache.GetCacheItem(MaxZScoreCacheKey);
+            var maxZScore = await _maxZScoreCache.GetCacheItem(MaxZScoreCacheKey, new CancellationToken());
             return maxZScore == 0 ? null : value.GetRatingForZScore(maxZScore);
         }
     }

Plugins/Stats/Commands/MostPlayedCommand.cs

@@ -79,7 +79,7 @@ namespace IW4MAdmin.Plugins.Stats.Commands
             }
             else
             {
-                gameEvent.Owner.Broadcast(topStats);
+                await gameEvent.Owner.BroadcastAsync(topStats);
             }
         }
     }