fix: add brute force fallback for enum member attribute, fixes #150

Co-authored-by: Roflmuffin <shortguy014@gmail.com>

configs/addons/counterstrikesharp/gamedata/gamedata.json

@@ -71,12 +71,12 @@
     "signatures": {
         "library": "server",
         "windows": "\\x48\\x89\\x5C\\x24\\x10\\x48\\x89\\x7C\\x24\\x20\\x55\\x48\\x8B\\xEC\\x48\\x83\\xEC\\x50",
-        "linux": "\\x55\\x48\\x89\\xF2\\x48\\x89\\xE5\\x41\\x54\\x49\\x89\\xFC\\x48\\x8D\\x7D\\xE0\\x48\\x83\\xEC\\x18\\x48\\x8D\\x05\\xA5"
+        "linux": "\\x55\\x48\\x89\\xF2\\x48\\x89\\xE5\\x41\\x54\\x49\\x89\\xFC\\x48\\x8D\\x2A\\x2A\\x48\\x83\\x2A\\x2A\\x2A\\x8D\\x05\\x2A\\x2A\\x2A\\x00\\x48\\x8B\\x30\\x48\\x8B\\x06\\xFF\\x2A\\x2A\\x48\\x8B\\x45\\x2A\\x48\\x8D\\x2A\\x2A\\x4C\\x89\\x2A\\x48\\x89\\x45\\x2A\\x2A\\x68\\xFC"
     }
   },
   "CCSPlayer_ItemServices_DropActivePlayerWeapon": {
     "offsets": {
-        "windows": 20,
+        "windows": 18,
         "linux": 19
     }
   },
@@ -103,7 +103,7 @@
     "signatures": {
         "library": "server",
         "windows": "\\x48\\x83\\xEC\\x48\\xC6\\x44\\x24\\x30\\x00\\x4C\\x8B\\xC1",
-        "linux": "\\x48\\x8D\\x05\\xC9\\xC2\\xBC"
+        "linux": "\\x48\\x8D\\x05\\x2A\\x2A\\x2A\\x2A\\x55\\x48\\x89\\xFA"
       }
   },
   "CBaseEntity_DispatchSpawn": {

docs/src/content/docs/guides/dependency-injection.md

@@ -0,0 +1,71 @@
+---
+title: Dependency Injection
+description: How to make use of dependency injection in CounterStrikeSharp
+sidebar:
+  order: 1
+---
+
+`CounterStrikeSharp` uses a standard <a href="https://learn.microsoft.com/en-us/aspnet/core/fundamentals/dependency-injection?view=aspnetcore-8.0" target="_blank">`IServiceCollection`</a> to allow for dependency injection in plugins.
+
+There are a handful of standard services that are predefined for you (`ILogger` for logging for instance), with more to come in the future. To add your own scoped & singleton services to the container, you can create a new class that implements the `IPluginServiceCollection<T>` interface for your plugin.
+
+```csharp
+public class TestPlugin : BasePlugin
+{
+  // Plugin code...
+}
+
+public class TestPluginServiceCollection : IPluginServiceCollection<TestPlugin>
+{
+    public void ConfigureServices(IServiceCollection serviceCollection)
+    {
+        serviceCollection.AddScoped<ExampleInjectedClass>();
+        serviceCollection.AddLogging(builder => ...);
+    }
+}
+```
+
+CounterStrikeSharp will search your assembly for any implementations of `IPlugin` and then any implementations of `IPluginServiceCollection<T>` where `T` is your plugin. It will then configure the service provider and then request a singleton instance of your plugin before proceeding to the load step.
+
+In this way, any dependencies that are listed in your plugin class constructor will automatically get injected at instantation time (before load).
+
+### Example
+
+```csharp
+public class TestInjectedClass
+{
+    private readonly ILogger<TestInjectedClass> _logger;
+
+    public TestInjectedClass(ILogger<TestInjectedClass> logger)
+    {
+        _logger = logger;
+    }
+
+    public void Hello()
+    {
+        _logger.LogInformation("Hello World from Test Injected Class");
+    }
+}
+
+public class TestPluginServiceCollection : IPluginServiceCollection<SamplePlugin>
+{
+    public void ConfigureServices(IServiceCollection serviceCollection)
+    {
+        serviceCollection.AddScoped<TestInjectedClass>();
+    }
+}
+
+public class SamplePlugin : BasePlugin
+{
+    private readonly TestInjectedClass _testInjectedClass;
+    public SamplePlugin(TestInjectedClass testInjectedClass)
+    {
+        _testInjectedClass = testInjectedClass;
+    }
+
+    public override void Load(bool hotReload)
+    {
+        _testInjectedClass.Hello();
+    }
+}
+```

docs/src/content/docs/guides/getting-started.md

@@ -1,6 +1,8 @@
 ---
 title: Getting Started
 description: How to get started installing & using CounterStrikeSharp.
+sidebar:
+  order: 0
 ---
 
 # Installation

docs/src/content/docs/guides/hello-world-plugin.md

@@ -1,6 +1,8 @@
 ---
 title: Hello World Plugin
 description: How to write your first plugin for CounterStrikeSharp
+sidebar:
+  order: 0
 ---
 
 ## Creating a New Project

managed/CounterStrikeSharp.API/Bootstrap.cs

@@ -0,0 +1,67 @@
+using System;
+using System.IO;
+using System.Reflection;
+using System.Runtime.InteropServices;
+using CounterStrikeSharp.API.Core;
+using CounterStrikeSharp.API.Core.Hosting;
+using CounterStrikeSharp.API.Core.Logging;
+using CounterStrikeSharp.API.Core.Plugin;
+using CounterStrikeSharp.API.Core.Plugin.Host;
+using Microsoft.Extensions.DependencyInjection;
+using Microsoft.Extensions.Hosting;
+using Microsoft.Extensions.Logging;
+using Serilog;
+
+namespace CounterStrikeSharp.API;
+
+public static class Bootstrap
+{
+    [UnmanagedCallersOnly]
+    // Used by .NET Host in C++ to initiate loading
+    public static int Run()
+    {
+        try
+        {
+            // Path to /game/csgo/addons/counterstrikesharp
+            var contentRoot = new FileInfo(Assembly.GetExecutingAssembly().Location).Directory.Parent.FullName;
+
+            using var host = Host.CreateDefaultBuilder()
+                .UseContentRoot(contentRoot)
+                .ConfigureServices(services =>
+                {
+                    services.AddLogging(builder =>
+                    {
+                        builder.ClearProviders();
+                        builder.AddCoreLogging(contentRoot);
+                    });
+
+                    services.AddSingleton<IScriptHostConfiguration, ScriptHostConfiguration>();
+                    services.AddScoped<Application>();
+                    services.AddSingleton<IPluginManager, PluginManager>();
+                    services.AddScoped<IPluginContextQueryHandler, PluginContextQueryHandler>();
+
+                    services.Scan(i => i.FromCallingAssembly()
+                        .AddClasses(c => c.AssignableTo<IStartupService>())
+                        .AsSelfWithInterfaces()
+                        .WithSingletonLifetime());
+                })
+                .Build();
+
+            using IServiceScope scope = host.Services.CreateScope();
+
+            // TODO: Improve static singleton access
+            GameData.GameDataProvider = scope.ServiceProvider.GetRequiredService<GameDataProvider>();
+
+            var application = scope.ServiceProvider.GetRequiredService<Application>();
+            application.Start();
+
+            return 1;
+        }
+        catch (Exception e)
+        {
+            Console.Error.WriteLine(e);
+            Log.Fatal(e, "Failed to start application");
+            return 0;
+        }
+    }
+}

managed/CounterStrikeSharp.API/Core/Application.cs

@@ -0,0 +1,254 @@
+/*
+ *  This file is part of CounterStrikeSharp.
+ *  CounterStrikeSharp is free software: you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation, either version 3 of the License, or
+ *  (at your option) any later version.
+ *
+ *  CounterStrikeSharp is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with CounterStrikeSharp.  If not, see <https://www.gnu.org/licenses/>. *
+ */
+
+using System.Linq;
+using System.Text;
+using CounterStrikeSharp.API.Core.Hosting;
+using CounterStrikeSharp.API.Core.Plugin;
+using CounterStrikeSharp.API.Core.Plugin.Host;
+using CounterStrikeSharp.API.Modules.Admin;
+using CounterStrikeSharp.API.Modules.Commands;
+using CounterStrikeSharp.API.Modules.Menu;
+using CounterStrikeSharp.API.Modules.Utils;
+using Microsoft.Extensions.Logging;
+
+namespace CounterStrikeSharp.API.Core
+{
+    public sealed class Application
+    {
+        private static Application _instance = null!;
+        public ILogger Logger { get; }
+        public static Application Instance => _instance!;
+
+        public static string RootDirectory => Instance._scriptHostConfiguration.RootPath;
+
+        private readonly IScriptHostConfiguration _scriptHostConfiguration;
+        private readonly GameDataProvider _gameDataProvider;
+        private readonly CoreConfig _coreConfig;
+        private readonly IPluginManager _pluginManager;
+        private readonly IPluginContextQueryHandler _pluginContextQueryHandler;
+
+        public Application(ILoggerFactory loggerFactory, IScriptHostConfiguration scriptHostConfiguration,
+            GameDataProvider gameDataProvider, CoreConfig coreConfig, IPluginManager pluginManager,
+            IPluginContextQueryHandler pluginContextQueryHandler)
+        {
+            Logger = loggerFactory.CreateLogger("Core");
+            _scriptHostConfiguration = scriptHostConfiguration;
+            _gameDataProvider = gameDataProvider;
+            _coreConfig = coreConfig;
+            _pluginManager = pluginManager;
+            _pluginContextQueryHandler = pluginContextQueryHandler;
+            _instance = this;
+        }
+
+        public void Start()
+        {
+            Logger.LogInformation("CounterStrikeSharp is starting up...");
+
+            _coreConfig.Load();
+            _gameDataProvider.Load();
+
+            var adminGroupsPath = Path.Combine(_scriptHostConfiguration.RootPath, "configs", "admin_groups.json");
+            Logger.LogInformation("Loading Admin Groups from {Path}", adminGroupsPath);
+            AdminManager.LoadAdminGroups(adminGroupsPath);
+
+            var adminPath = Path.Combine(_scriptHostConfiguration.RootPath, "configs", "admins.json");
+            Logger.LogInformation("Loading Admins from {Path}", adminPath);
+            AdminManager.LoadAdminData(adminPath);
+
+            var overridePath = Path.Combine(_scriptHostConfiguration.RootPath, "configs", "admin_overrides.json");
+            Logger.LogInformation("Loading Admin Command Overrides from {Path}", overridePath);
+            AdminManager.LoadCommandOverrides(overridePath);
+
+            AdminManager.MergeGroupPermsIntoAdmins();
+
+            _pluginManager.Load();
+
+            for (var i = 1; i <= 9; i++)
+            {
+                CommandUtils.AddStandaloneCommand("css_" + i, "Command Key Handler", (player, info) =>
+                {
+                    if (player == null) return;
+                    var key = Convert.ToInt32(info.GetArg(0).Split("_")[1]);
+                    ChatMenus.OnKeyPress(player, key);
+                });
+            }
+
+            RegisterPluginCommands();
+        }
+
+        [RequiresPermissions("@css/generic")]
+        [CommandHelper(whoCanExecute: CommandUsage.CLIENT_AND_SERVER)]
+        private void OnCSSCommand(CCSPlayerController? caller, CommandInfo info)
+        {
+            var currentVersion = Api.GetVersion();
+
+            info.ReplyToCommand(
+                "  CounterStrikeSharp was created and is maintained by Michael \"roflmuffin\" Wilson.\n" +
+                "  Counter-Strike Sharp uses code borrowed from SourceMod, Source.Python, FiveM, Saul Rennison and CS2Fixes.\n" +
+                "  See ACKNOWLEDGEMENTS.md for more information.\n" +
+                "  Current API Version: " + currentVersion, true);
+            return;
+        }
+
+        [RequiresPermissions("@css/generic")]
+        [CommandHelper(minArgs: 1,
+            usage: "[option]\n" +
+                   "  list - List all plugins currently loaded.\n" +
+                   "  start / load - Loads a plugin not currently loaded.\n" +
+                   "  stop / unload - Unloads a plugin currently loaded.\n" +
+                   "  restart / reload - Reloads a plugin currently loaded.",
+            whoCanExecute: CommandUsage.CLIENT_AND_SERVER)]
+        private void OnCSSPluginCommand(CCSPlayerController? caller, CommandInfo info)
+        {
+            switch (info.GetArg(1))
+            {
+                case "list":
+                {
+                    info.ReplyToCommand(
+                        $"  List of all plugins currently loaded by CounterStrikeSharp: {_pluginManager.GetLoadedPlugins().Count()} plugins loaded.",
+                        true);
+
+                    foreach (var plugin in _pluginManager.GetLoadedPlugins())
+                    {
+                        var sb = new StringBuilder();
+                        sb.AppendFormat("  [#{0}:{1}]: \"{2}\" ({3})", plugin.PluginId,
+                            plugin.State.ToString().ToUpper(), plugin.Plugin.ModuleName,
+                            plugin.Plugin.ModuleVersion);
+                        if (!string.IsNullOrEmpty(plugin.Plugin.ModuleAuthor))
+                            sb.AppendFormat(" by {0}", plugin.Plugin.ModuleAuthor);
+                        if (!string.IsNullOrEmpty(plugin.Plugin.ModuleDescription))
+                        {
+                            sb.Append("\n");
+                            sb.Append("    ");
+                            sb.Append(plugin.Plugin.ModuleDescription);
+                        }
+
+                        info.ReplyToCommand(sb.ToString(), true);
+                    }
+
+                    break;
+                }
+                case "start":
+                case "load":
+                {
+                    if (info.ArgCount < 2)
+                    {
+                        info.ReplyToCommand(
+                            "Valid usage: css_plugins start/load [relative plugin path || absolute plugin path] (e.g \"TestPlugin\", \"plugins/TestPlugin/TestPlugin.dll\")\n",
+                            true);
+                        break;
+                    }
+                    
+                    // If our arugment doesn't end in ".dll" - try and construct a path similar to PluginName/PluginName.dll.
+                    // We'll assume we have a full path if we have ".dll".
+                    var path = info.GetArg(2);
+                    if (!path.EndsWith(".dll"))
+                    {
+                        path = Path.Combine(_scriptHostConfiguration.RootPath, $"plugins/{path}/{path}.dll");
+                    }
+                    else
+                    {
+                        path = Path.Combine(_scriptHostConfiguration.RootPath, path);
+                    }
+
+                    var plugin = _pluginContextQueryHandler.FindPluginByModulePath(path);
+
+                    if (plugin == null)
+                    {
+                        try
+                        {
+                            _pluginManager.LoadPlugin(path);
+                        } catch (Exception e)
+                        {
+                            info.ReplyToCommand($"Could not load plugin \"{path}\")", true);
+                        }
+                    }
+                    else
+                    {
+                        plugin.Load(false);
+                    }
+                    
+                    break;
+                }
+
+                case "stop":
+                case "unload":
+                {
+                    if (info.ArgCount < 2)
+                    {
+                        info.ReplyToCommand(
+                            "Valid usage: css_plugins stop/unload [plugin name || #plugin id] (e.g \"TestPlugin\", \"1\")\n",
+                            true);
+                        break;
+                    }
+
+                    var pluginIdentifier = info.GetArg(2);
+                    IPluginContext? plugin = _pluginContextQueryHandler.FindPluginByIdOrName(pluginIdentifier);
+                    if (plugin == null)
+                    {
+                        info.ReplyToCommand($"Could not unload plugin \"{pluginIdentifier}\")", true);
+                        break;
+                    }
+
+                    plugin.Unload(false);
+                    break;
+                }
+
+                case "restart":
+                case "reload":
+                {
+                    if (info.ArgCount < 2)
+                    {
+                        info.ReplyToCommand(
+                            "Valid usage: css_plugins restart/reload [plugin name || #plugin id] (e.g \"TestPlugin\", \"#1\")\n",
+                            true);
+                        break;
+                    }
+
+                    var pluginIdentifier = info.GetArg(2);
+                    var plugin = _pluginContextQueryHandler.FindPluginByIdOrName(pluginIdentifier);
+
+                    if (plugin == null)
+                    {
+                        info.ReplyToCommand($"Could not reload plugin \"{pluginIdentifier}\")", true);
+                        break;
+                    }
+
+                    plugin.Unload(true);
+                    plugin.Load(true);
+                    break;
+                }
+
+                default:
+                    info.ReplyToCommand("Valid usage: css_plugins [option]\n" +
+                                        "  list - List all plugins currently loaded.\n" +
+                                        "  start / load - Loads a plugin not currently loaded.\n" +
+                                        "  stop / unload - Unloads a plugin currently loaded.\n" +
+                                        "  restart / reload - Reloads a plugin currently loaded."
+                        , true);
+                    break;
+            }
+        }
+
+        private void RegisterPluginCommands()
+        {
+            CommandUtils.AddStandaloneCommand("css", "Counter-Strike Sharp options.", OnCSSCommand);
+            CommandUtils.AddStandaloneCommand("css_plugins", "Counter-Strike Sharp plugin options.",
+                OnCSSPluginCommand);
+        }
+    }
+}

managed/CounterStrikeSharp.API/Core/BasePlugin.cs

@@ -18,25 +18,19 @@ using System;
 using System.Collections.Generic;
 using System.IO;
 using System.Linq;
-using System.Linq.Expressions;
 using System.Reflection;
-using System.Runtime.InteropServices;
-using System.Runtime.Loader;
 using CounterStrikeSharp.API.Core.Attributes;
 using CounterStrikeSharp.API.Core.Attributes.Registration;
 using CounterStrikeSharp.API.Modules.Admin;
 using CounterStrikeSharp.API.Modules.Commands;
 using CounterStrikeSharp.API.Modules.Events;
-using CounterStrikeSharp.API.Modules.Entities;
-using CounterStrikeSharp.API.Modules.Listeners;
 using CounterStrikeSharp.API.Modules.Timers;
-using McMaster.NETCore.Plugins;
 using CounterStrikeSharp.API.Modules.Config;
 using Microsoft.Extensions.Logging;
 
 namespace CounterStrikeSharp.API.Core
 {
-    public abstract class BasePlugin : IPlugin, IDisposable
+    public abstract class BasePlugin : IPlugin
     {
         private bool _disposed;
 
@@ -51,7 +45,7 @@ namespace CounterStrikeSharp.API.Core
         
         public virtual string ModuleDescription { get; }
 
-        public string ModulePath { get; internal set; }
+        public string ModulePath { get; set; }
 
         public string ModuleDirectory => Path.GetDirectoryName(ModulePath);
         public ILogger Logger { get; set; }
@@ -316,7 +310,7 @@ namespace CounterStrikeSharp.API.Core
                 .Select(p => p.GetCustomAttribute<CastFromAttribute>()?.Type)
                 .ToArray();
 
-            GlobalContext.Instance.Logger.LogDebug("Registering listener for {ListenerName} with {ParameterCount} parameters",
+            Application.Instance.Logger.LogDebug("Registering listener for {ListenerName} with {ParameterCount} parameters",
                 listenerName, parameterTypes.Length);
 
             var wrappedHandler = new Action<ScriptContext>(context =>

managed/CounterStrikeSharp.API/Core/CoreConfig.cs

@@ -19,12 +19,13 @@ using System.IO;
 using System.Reflection;
 using System.Text.Json;
 using System.Text.Json.Serialization;
-
 using CounterStrikeSharp.API.Modules.Utils;
 using CounterStrikeSharp.API.Modules.Admin;
 using CounterStrikeSharp.API.Modules.Commands;
 using System.Collections.Generic;
+using CounterStrikeSharp.API.Core.Hosting;
 using CounterStrikeSharp.API.Core.Logging;
+using Microsoft.Extensions.Hosting;
 using Microsoft.Extensions.Logging;
 
 namespace CounterStrikeSharp.API.Core
@@ -34,17 +35,20 @@ namespace CounterStrikeSharp.API.Core
     /// </summary>
     internal sealed partial class CoreConfigData
     {
-        [JsonPropertyName("PublicChatTrigger")] public IEnumerable<string> PublicChatTrigger { get; set; } = new HashSet<string>() { "!" };
+        [JsonPropertyName("PublicChatTrigger")]
+        public IEnumerable<string> PublicChatTrigger { get; set; } = new HashSet<string>() { "!" };
 
-        [JsonPropertyName("SilentChatTrigger")] public IEnumerable<string> SilentChatTrigger { get; set; } = new HashSet<string>() { "/" };
+        [JsonPropertyName("SilentChatTrigger")]
+        public IEnumerable<string> SilentChatTrigger { get; set; } = new HashSet<string>() { "/" };
 
-        [JsonPropertyName("FollowCS2ServerGuidelines")] public bool FollowCS2ServerGuidelines { get; set; } = true;
+        [JsonPropertyName("FollowCS2ServerGuidelines")]
+        public bool FollowCS2ServerGuidelines { get; set; } = true;
     }
 
     /// <summary>
     /// Configuration related to the Core API.
     /// </summary>
-    public static partial class CoreConfig
+    public partial class CoreConfig
     {
         /// <summary>
         /// List of characters to use for public chat triggers.
@@ -78,49 +82,56 @@ namespace CounterStrikeSharp.API.Core
         public static bool FollowCS2ServerGuidelines => _coreConfig.FollowCS2ServerGuidelines;
     }
 
-    public static partial class CoreConfig
+    public partial class CoreConfig : IStartupService
     {
         private static CoreConfigData _coreConfig = new CoreConfigData();
-        
-        // TODO: ServiceCollection
-        private static ILogger _logger = CoreLogging.Factory.CreateLogger("CoreConfig");
 
-        static CoreConfig()
+        private readonly ILogger<CoreConfig> _logger;
+
+        private readonly string _coreConfigPath;
+
+        public CoreConfig(IScriptHostConfiguration scriptHostConfiguration, ILogger<CoreConfig> logger)
         {
-            CommandUtils.AddStandaloneCommand("css_core_reload", "Reloads the core configuration file.", ReloadCoreConfigCommand);
+            _logger = logger;
+            _coreConfigPath = Path.Join(scriptHostConfiguration.ConfigsPath, "core.json");
         }
 
         [RequiresPermissions("@css/config")]
         [CommandHelper(whoCanExecute: CommandUsage.CLIENT_AND_SERVER)]
-        private static void ReloadCoreConfigCommand(CCSPlayerController? player, CommandInfo command)
+        private void ReloadCoreConfigCommand(CCSPlayerController? player, CommandInfo command)
         {
-            var rootDir = new FileInfo(Assembly.GetExecutingAssembly().Location).Directory.Parent;
-            Load(Path.Combine(rootDir.FullName, "configs", "core.json"));
+            Load();
         }
 
-        public static void Load(string coreConfigPath)
+        public void Load()
         {
-            if (!File.Exists(coreConfigPath))
+            CommandUtils.AddStandaloneCommand("css_core_reload", "Reloads the core configuration file.",
+                ReloadCoreConfigCommand);
+
+            if (!File.Exists(_coreConfigPath))
             {
-                _logger.LogWarning("Core configuration could not be found at path \"{CoreConfigPath}\", fallback values will be used.", coreConfigPath);
+                _logger.LogWarning(
+                    "Core configuration could not be found at path \"{CoreConfigPath}\", fallback values will be used.",
+                    _coreConfigPath);
                 return;
             }
 
             try
             {
-                var data = JsonSerializer.Deserialize<CoreConfigData>(File.ReadAllText(coreConfigPath), new JsonSerializerOptions() { ReadCommentHandling = JsonCommentHandling.Skip });
+                var data = JsonSerializer.Deserialize<CoreConfigData>(File.ReadAllText(_coreConfigPath),
+                    new JsonSerializerOptions() { ReadCommentHandling = JsonCommentHandling.Skip });
 
                 if (data != null)
                 {
                     _coreConfig = data;
                 }
-                
-                _logger.LogInformation("Successfully loaded core configuration.");
             }
             catch (Exception ex)
             {
                 _logger.LogWarning(ex, "Failed to load core configuration, fallback values will be used");
             }
+            
+            _logger.LogInformation("Successfully loaded core configuration");
         }
     }
-}
+}

managed/CounterStrikeSharp.API/Core/FunctionReference.cs

@@ -77,7 +77,7 @@ namespace CounterStrikeSharp.API.Core
                     }
                     catch (Exception e)
                     {
-                        GlobalContext.Instance.Logger.LogError(e, "Error invoking callback");
+                        Application.Instance.Logger.LogError(e, "Error invoking callback");
                     }
                 });
                 s_callback = dg;
@@ -141,7 +141,7 @@ namespace CounterStrikeSharp.API.Core
             {
                 ms_references.Remove(reference);
 
-                GlobalContext.Instance.Logger.LogDebug("Removing function/callback reference: {Reference}", reference);
+                Application.Instance.Logger.LogDebug("Removing function/callback reference: {Reference}", reference);
             }
         }
     }

managed/CounterStrikeSharp.API/Core/GameData.cs

@@ -5,11 +5,12 @@ using System.Linq;
 using System.Runtime.InteropServices;
 using System.Text.Json;
 using System.Text.Json.Serialization;
+using CounterStrikeSharp.API.Core.Hosting;
 using Microsoft.Extensions.Logging;
 
 namespace CounterStrikeSharp.API.Core;
 
-class LoadedGameData
+public class LoadedGameData
 {
     [JsonPropertyName("signatures")] public Signatures? Signatures { get; set; }
     [JsonPropertyName("offsets")] public Offsets? Offsets { get; set; }
@@ -31,33 +32,45 @@ public class Offsets
     [JsonPropertyName("linux")] public int Linux { get; set; }
 }
 
-public static class GameData
+public sealed class GameDataProvider : IStartupService
 {
-    private static Dictionary<string, LoadedGameData> _methods;
+    private readonly string _gameDataFilePath;
+    public Dictionary<string,LoadedGameData> Methods;
+    private readonly ILogger<GameDataProvider> _logger;
 
-    public static void Load(string gameDataPath)
+    public GameDataProvider(IScriptHostConfiguration scriptHostConfiguration, ILogger<GameDataProvider> logger)
+    {
+        _logger = logger;
+        _gameDataFilePath = Path.Join(scriptHostConfiguration.GameDataPath, "gamedata.json");
+    }
+    
+    public void Load()
     {
         try
         {
-            _methods = JsonSerializer.Deserialize<Dictionary<string, LoadedGameData>>(File.ReadAllText(gameDataPath))!;
-
-            GlobalContext.Instance.Logger.LogInformation("Loaded game data with {Count} methods.", _methods.Count);
+            Methods = JsonSerializer.Deserialize<Dictionary<string, LoadedGameData>>(File.ReadAllText(_gameDataFilePath))!;
         }
         catch (Exception ex)
         {
-            GlobalContext.Instance.Logger.LogError(ex, "Failed to load game data");
+            _logger.LogError(ex, "Failed to load game data");
         }
+        
+        _logger.LogInformation("Successfully loaded {Count} game data entries from {Path}", Methods.Count, _gameDataFilePath);
     }
+} 
 
+public static class GameData
+{
+    internal static GameDataProvider GameDataProvider { get; set; } = null!;
     public static string GetSignature(string key)
     {
-        GlobalContext.Instance.Logger.LogDebug("Getting signature: {Key}", key);
-        if (!_methods.ContainsKey(key))
+        Application.Instance.Logger.LogDebug("Getting signature: {Key}", key);
+        if (!GameDataProvider.Methods.ContainsKey(key))
         {
             throw new ArgumentException($"Method {key} not found in gamedata.json");
         }
 
-        var methodMetadata = _methods[key];
+        var methodMetadata = GameDataProvider.Methods[key];
         if (methodMetadata.Signatures == null)
         {
             throw new InvalidOperationException($"No signatures found for {key} in gamedata.json");
@@ -79,12 +92,12 @@ public static class GameData
 
     public static int GetOffset(string key)
     {
-        if (!_methods.ContainsKey(key))
+        if (!GameDataProvider.Methods.ContainsKey(key))
         {
             throw new Exception($"Method {key} not found in gamedata.json");
         }
 
-        var methodMetadata = _methods[key];
+        var methodMetadata = GameDataProvider.Methods[key];
 
         if (methodMetadata.Offsets == null)
         {

managed/CounterStrikeSharp.API/Core/GlobalContext.cs

@@ -1,355 +0,0 @@
-/*
- *  This file is part of CounterStrikeSharp.
- *  CounterStrikeSharp is free software: you can redistribute it and/or modify
- *  it under the terms of the GNU General Public License as published by
- *  the Free Software Foundation, either version 3 of the License, or
- *  (at your option) any later version.
- *
- *  CounterStrikeSharp is distributed in the hope that it will be useful,
- *  but WITHOUT ANY WARRANTY; without even the implied warranty of
- *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *  GNU General Public License for more details.
- *
- *  You should have received a copy of the GNU General Public License
- *  along with CounterStrikeSharp.  If not, see <https://www.gnu.org/licenses/>. *
- */
-
-using System;
-using System.Collections.Generic;
-using System.IO;
-using System.Linq;
-using System.Reflection;
-using System.Text;
-using CounterStrikeSharp.API.Core.Logging;
-using CounterStrikeSharp.API.Modules.Admin;
-using CounterStrikeSharp.API.Modules.Commands;
-using CounterStrikeSharp.API.Modules.Menu;
-using CounterStrikeSharp.API.Modules.Utils;
-using Microsoft.Extensions.Logging;
-using Serilog;
-using ILogger = Microsoft.Extensions.Logging.ILogger;
-
-namespace CounterStrikeSharp.API.Core
-{
-    public sealed class GlobalContext
-    {
-        private static GlobalContext _instance = null;
-
-        public ILogger Logger { get; }
-        public static GlobalContext Instance => _instance;
-
-        public static string RootDirectory => _instance.rootDir.FullName;
-        private DirectoryInfo rootDir;
-
-        private readonly List<PluginContext> _loadedPlugins = new();
-
-        public GlobalContext()
-        {
-            rootDir = new FileInfo(Assembly.GetExecutingAssembly().Location).Directory.Parent;
-            _instance = this;
-            Logger = CoreLogging.Factory.CreateLogger("Core");
-            
-            Logger.LogInformation("CounterStrikeSharp is starting up...");
-        }
-
-        ~GlobalContext()
-        {
-            foreach (var plugin in _loadedPlugins)
-            {
-                plugin.Unload();
-            }
-        }
-
-        public void OnNativeUnload()
-        {
-            foreach (var plugin in _loadedPlugins)
-            {
-                plugin.Unload();
-            }
-        }
-        public void InitGlobalContext()
-        {
-            var coreConfigPath = Path.Combine(rootDir.FullName, "configs", "core.json");
-            Logger.LogInformation("Loading CoreConfig from {Path}", coreConfigPath);
-            CoreConfig.Load(coreConfigPath);
-
-            var gameDataPath = Path.Combine(rootDir.FullName, "gamedata", "gamedata.json");
-            Logger.LogInformation("Loading GameData from {Path}", gameDataPath);
-            GameData.Load(gameDataPath);
-            
-   
-            var adminGroupsPath = Path.Combine(rootDir.FullName, "configs", "admin_groups.json");
-            Logger.LogInformation("Loading Admin Groups from {Path}", adminGroupsPath);
-            AdminManager.LoadAdminGroups(adminGroupsPath);
-            
-            var adminPath = Path.Combine(rootDir.FullName, "configs", "admins.json");
-            Logger.LogInformation("Loading Admins from {Path}", adminPath);
-            AdminManager.LoadAdminData(adminPath);
-            
-            var overridePath = Path.Combine(rootDir.FullName, "configs", "admin_overrides.json");
-            Logger.LogInformation("Loading Admin Command Overrides from {Path}", overridePath);
-            AdminManager.LoadCommandOverrides(overridePath);
-
-            AdminManager.MergeGroupPermsIntoAdmins();
-
-            for (var i = 1; i <= 9; i++)
-            {
-                CommandUtils.AddStandaloneCommand("css_" + i, "Command Key Handler", (player, info) =>
-                {
-                    if (player == null) return;
-                    var key = Convert.ToInt32(info.GetArg(0).Split("_")[1]);
-                    ChatMenus.OnKeyPress(player, key);
-                });
-            }
-            
-            Logger.LogInformation("Loading C# plugins...");
-            var pluginCount = LoadAllPlugins();
-            Logger.LogInformation("All managed modules were loaded. {PluginCount} plugins loaded.", pluginCount);
-
-            RegisterPluginCommands();
-        }
-
-        private void LoadPlugin(string path)
-        {
-            var existingPlugin = FindPluginByModulePath(path);
-            if (existingPlugin != null)
-            {
-                throw new FileLoadException("Plugin is already loaded.");
-            }
-
-            var plugin = new PluginContext(path, _loadedPlugins.Select(x => x.PluginId).DefaultIfEmpty(0).Max() + 1);
-            plugin.Load();
-            _loadedPlugins.Add(plugin);
-        }
-
-        private int LoadAllPlugins()
-        {
-            DirectoryInfo modulesDirectoryInfo;
-            try
-            {
-                modulesDirectoryInfo = new DirectoryInfo(Path.Combine(rootDir.FullName, "plugins"));
-            }
-            catch (Exception e)
-            {
-                Logger.LogError(e, "Error finding plugin path");
-                return 0;
-            }
-
-            DirectoryInfo[] properModulesDirectories;
-            try
-            {
-                properModulesDirectories = modulesDirectoryInfo.GetDirectories();
-            }
-            catch
-            {
-                properModulesDirectories = Array.Empty<DirectoryInfo>();
-            }
-
-
-            var filePaths = properModulesDirectories
-                .Where(d => d.GetFiles().Any((f) => f.Name == d.Name + ".dll"))
-                .Select(d => d.GetFiles().First((f) => f.Name == d.Name + ".dll").FullName)
-                .ToArray();
-
-
-            foreach (var path in filePaths)
-            {
-                try
-                {
-                    LoadPlugin(path);
-                }
-                catch (Exception e)
-                {
-                    Logger.LogError(e, "Failed to load plugin from {Path}", path);
-                }
-            }
-
-            return _loadedPlugins.Count;
-        }
-
-        public void UnloadAllPlugins()
-        {
-            foreach (var plugin in _loadedPlugins)
-            {
-                plugin.Unload();
-                _loadedPlugins.Remove(plugin);
-            }
-        }
-
-        private PluginContext? FindPluginByType(Type moduleClass)
-        {
-            return _loadedPlugins.FirstOrDefault(x => x.PluginType == moduleClass);
-        }
-
-        private PluginContext? FindPluginById(int id)
-        {
-            return _loadedPlugins.FirstOrDefault(x => x.PluginId == id);
-        }
-
-        private PluginContext? FindPluginByModuleName(string name)
-        {
-            return _loadedPlugins.FirstOrDefault(x => x.Name == name);
-        }
-
-        private PluginContext? FindPluginByModulePath(string path)
-        {
-            return _loadedPlugins.FirstOrDefault(x => x.PluginPath == path);
-        }
-
-        private PluginContext? FindPluginByIdOrName(string query)
-        {
-
-            PluginContext? plugin = null;
-            if (Int32.TryParse(query, out var pluginNumber))
-            {
-                plugin = FindPluginById(pluginNumber);
-                if (plugin != null) return plugin;
-            }
-
-            plugin = FindPluginByModuleName(query);
-
-            return plugin;
-        }
-
-        [RequiresPermissions("@css/generic")]
-        [CommandHelper(whoCanExecute: CommandUsage.CLIENT_AND_SERVER)]
-        private void OnCSSCommand(CCSPlayerController? caller, CommandInfo info)
-        {
-            var currentVersion = Api.GetVersion();
-
-            info.ReplyToCommand("  CounterStrikeSharp was created and is maintained by Michael \"roflmuffin\" Wilson.\n" +
-                "  Counter-Strike Sharp uses code borrowed from SourceMod, Source.Python, FiveM, Saul Rennison and CS2Fixes.\n" +
-                "  See ACKNOWLEDGEMENTS.md for more information.\n" +
-                "  Current API Version: " + currentVersion, true);
-            return;
-        }
-
-        [RequiresPermissions("@css/generic")]
-        [CommandHelper(minArgs: 1, 
-        usage: "[option]\n" +
-                "  list - List all plugins currently loaded.\n" +
-                "  start / load - Loads a plugin not currently loaded.\n" +
-                "  stop / unload - Unloads a plugin currently loaded.\n" +
-                "  restart / reload - Reloads a plugin currently loaded.",
-        whoCanExecute: CommandUsage.CLIENT_AND_SERVER)]
-        private void OnCSSPluginCommand(CCSPlayerController? caller, CommandInfo info)
-        {
-            switch (info.GetArg(1))
-            {
-                case "list":
-                {
-                    info.ReplyToCommand($"  List of all plugins currently loaded by CounterStrikeSharp: {_loadedPlugins.Count} plugins loaded.", true);
-
-                    foreach (var plugin in _loadedPlugins)
-                    {
-                        var sb = new StringBuilder();
-                        sb.AppendFormat("  [#{0}]: \"{1}\" ({2})", plugin.PluginId, plugin.Name, plugin.Version);
-                        if (!string.IsNullOrEmpty(plugin.Author)) sb.AppendFormat(" by {0}", plugin.Author);
-                        if (!string.IsNullOrEmpty(plugin.Description))
-                        {
-                            sb.Append("\n");
-                            sb.Append("    ");
-                            sb.Append(plugin.Description);
-                        }
-                        info.ReplyToCommand(sb.ToString(), true);
-                        
-                    }
-
-                    break;
-                }
-                case "start":
-                case "load":
-                {
-                    if (info.ArgCount < 2)
-                    {
-                        info.ReplyToCommand("Valid usage: css_plugins start/load [relative plugin path || absolute plugin path] (e.g \"TestPlugin\", \"plugins/TestPlugin/TestPlugin.dll\")\n", true);
-                        break;
-                    }
-
-                    // If our arugment doesn't end in ".dll" - try and construct a path similar to PluginName/PluginName.dll.
-                    // We'll assume we have a full path if we have ".dll".
-                    var path = info.GetArg(2);
-                    if (!path.EndsWith(".dll"))
-                    {
-                        path = Path.Combine(rootDir.FullName, $"plugins/{path}/{path}.dll");
-                    }
-                    else
-                    {
-                        path = Path.Combine(rootDir.FullName, path);
-                    }
-
-                    try
-                    {
-                        LoadPlugin(path);
-                    }
-                    catch (Exception e)
-                    {
-                        Logger.LogError(e, "Failed to load plugin from {Path}", path);
-                    }
-
-                    break;
-                }
-
-                case "stop":
-                case "unload":
-                {
-                    if (info.ArgCount < 2)
-                    {
-                        info.ReplyToCommand("Valid usage: css_plugins stop/unload [plugin name || #plugin id] (e.g \"TestPlugin\", \"1\")\n", true);
-                        break;
-                    }
-
-                    var pluginIdentifier = info.GetArg(2);
-                    PluginContext? plugin = FindPluginByIdOrName(pluginIdentifier);
-                    if (plugin == null)
-                    {
-                        info.ReplyToCommand($"Could not unload plugin \"{pluginIdentifier}\")", true);
-                        break;
-                    }
-                    plugin.Unload();
-                    _loadedPlugins.Remove(plugin);
-                    break;
-                }
-
-                case "restart":
-                case "reload":
-                {
-                    if (info.ArgCount < 2)
-                    {
-                        info.ReplyToCommand("Valid usage: css_plugins restart/reload [plugin name || #plugin id] (e.g \"TestPlugin\", \"#1\")\n", true);
-                        break;
-                    }
-
-                    var pluginIdentifier = info.GetArg(2);
-                    var plugin = FindPluginByIdOrName(pluginIdentifier);
-
-                    if (plugin == null)
-                    {
-                        info.ReplyToCommand($"Could not reload plugin \"{pluginIdentifier}\")", true);
-                        break;
-                    }
-                    plugin.Unload(true);
-                    plugin.Load(true);
-                    break;
-                }
-
-                default:
-                    info.ReplyToCommand("Valid usage: css_plugins [option]\n" +
-                        "  list - List all plugins currently loaded.\n" +
-                        "  start / load - Loads a plugin not currently loaded.\n" +
-                        "  stop / unload - Unloads a plugin currently loaded.\n" +
-                        "  restart / reload - Reloads a plugin currently loaded."
-                        , true);
-                    break;
-            }
-
-        }
-
-        private void RegisterPluginCommands()
-        {
-            CommandUtils.AddStandaloneCommand("css", "Counter-Strike Sharp options.", OnCSSCommand);
-            CommandUtils.AddStandaloneCommand("css_plugins", "Counter-Strike Sharp plugin options.", OnCSSPluginCommand);
-        }
-        
-    }
-}

managed/CounterStrikeSharp.API/Core/Helpers.cs

@@ -22,53 +22,12 @@ using System.Security;
 
 namespace CounterStrikeSharp.API.Core
 {
-    public class MethodAttribute<T> where T : Attribute
-    {
-        public MethodAttribute(T attribute, MethodInfo method)
-        {
-            Attribute = attribute;
-            Method = method;
-        }
-
-        public T Attribute;
-        public MethodInfo Method;
-    }
-
     public static class Helpers
     {
-        private static MethodAttribute<T>[] FindMethodAttributes<T>(BasePlugin plugin) where T: Attribute
-        {
-            return plugin
-                .GetType()
-                .GetMethods()
-                .Where(m => m.GetCustomAttributes(typeof(T), false).Length > 0)
-                .Select(x => new MethodAttribute<T>(x.GetCustomAttribute<T>(), x))
-                .ToArray();   
-        }
-
         private const string dllPath = "counterstrikesharp";
 
         [SecurityCritical]
         [DllImport(dllPath, EntryPoint = "InvokeNative")]
         public static extern void InvokeNative(IntPtr ptr);
-
-        [UnmanagedCallersOnly]
-        // Used by .NET Host in C++ to initiate loading
-        public static int LoadAllPlugins()
-        {
-            try
-            {
-                var globalContext = new GlobalContext();
-                globalContext.InitGlobalContext();
-                return 1;
-            }
-            catch (Exception e)
-            {
-                Console.WriteLine(e);
-                return 0;
-            }
-        }
-
-        public delegate void Callback();
     }
 }

managed/CounterStrikeSharp.API/Core/Hosting/IScriptHostConfiguration.cs

@@ -0,0 +1,32 @@
+namespace CounterStrikeSharp.API.Core.Hosting;
+
+
+/// <summary>
+/// Provides information about the CounterStrikeSharp host configuration.
+/// </summary>
+public interface IScriptHostConfiguration
+{
+    /// <summary>
+    /// Gets the absolute path to the directory that contains CounterStrikeSharp files.
+    /// e.g. /game/csgo/addons/counterstrikesharp
+    /// </summary>
+    string RootPath { get; }
+    
+    /// <summary>
+    /// Gets the absolute path to the directory that contains CounterStrikeSharp plugins.
+    /// e.g. /game/csgo/addons/counterstrikesharp/plugins
+    /// </summary>
+    string PluginPath { get; }
+    
+    /// <summary>
+    /// Gets the absolute path to the directory that contains CounterStrikeSharp configs.
+    /// e.g. /game/csgo/addons/counterstrikesharp/configs
+    /// </summary>
+    string ConfigsPath { get; }
+    
+    /// <summary>
+    /// Gets the absolute path to the directory that contains CounterStrikeSharp game data.
+    /// e.g. /game/csgo/addons/counterstrikesharp/gamedata
+    /// </summary>
+    string GameDataPath { get; }
+}

managed/CounterStrikeSharp.API/Core/Hosting/ScriptHostConfiguration.cs

@@ -0,0 +1,20 @@
+using System.IO;
+using Microsoft.Extensions.Hosting;
+
+namespace CounterStrikeSharp.API.Core.Hosting;
+
+internal sealed class ScriptHostConfiguration : IScriptHostConfiguration
+{
+    public string RootPath { get; }
+    public string PluginPath { get; }
+    public string ConfigsPath { get; }
+    public string GameDataPath { get; }
+
+    public ScriptHostConfiguration(IHostEnvironment hostEnvironment)
+    {
+        RootPath = Path.Join(new[] { hostEnvironment.ContentRootPath });
+        PluginPath = Path.Join(new[] { hostEnvironment.ContentRootPath, "plugins" });
+        ConfigsPath = Path.Join(new[] { hostEnvironment.ContentRootPath, "configs" });
+        GameDataPath = Path.Join(new[] { hostEnvironment.ContentRootPath, "gamedata" });
+    }
+}

managed/CounterStrikeSharp.API/Core/IPlugin.cs

@@ -14,28 +14,30 @@
  *  along with CounterStrikeSharp.  If not, see <https://www.gnu.org/licenses/>. *
  */
 
+using System;
+using Microsoft.Extensions.DependencyInjection;
+using Microsoft.Extensions.Logging;
+
 namespace CounterStrikeSharp.API.Core
 {
     /// <summary>
     /// Interface which every CounterStrikeSharp plugin must implement. Module will be created with parameterless constructor and then Load method will be called.
     /// </summary>
-    public interface IPlugin
+    public interface IPlugin : IDisposable
     {
         /// <summary>
         /// Name of the plugin.
         /// </summary>
-        string ModuleName
-        {
-            get;
-        }
+        string ModuleName { get; }
 
         /// <summary>
         /// Module version.
         /// </summary>
-        string ModuleVersion
-        {
-            get;
-        }
+        string ModuleVersion { get; }
+
+        string ModuleAuthor { get; }
+
+        string ModuleDescription { get; }
 
         /// <summary>
         /// This method is called by CounterStrikeSharp on plugin load and should be treated as plugin constructor.
@@ -48,5 +50,13 @@ namespace CounterStrikeSharp.API.Core
         /// Event handlers, listeners etc. will automatically be deregistered.
         /// </summary>
         void Unload(bool hotReload);
+
+        string ModulePath { get; internal set; }
+
+        ILogger Logger { get; set; }
+
+        void RegisterAllAttributes(object instance);
+
+        void InitializeConfig(object instance, Type pluginType);
     }
 }

managed/CounterStrikeSharp.API/Core/IPluginServiceCollection.cs

@@ -0,0 +1,15 @@
+using Microsoft.Extensions.DependencyInjection;
+
+namespace CounterStrikeSharp.API.Core;
+
+/// <summary>
+/// Represents a service collection configuration for a plugin.
+/// </summary>
+/// <typeparam name="T"></typeparam>
+public interface IPluginServiceCollection<T> where T : IPlugin
+{
+    /// <summary>
+    /// Used to configure services exposed for dependency injection.
+    /// </summary>
+    public void ConfigureServices(IServiceCollection serviceCollection);
+}

managed/CounterStrikeSharp.API/Core/IStartupService.cs

@@ -0,0 +1,6 @@
+namespace CounterStrikeSharp.API.Core;
+
+public interface IStartupService
+{
+    public void Load();
+}

managed/CounterStrikeSharp.API/Core/Logging/CoreLogging.cs

@@ -2,28 +2,40 @@ using System;
 using System.IO;
 using Microsoft.Extensions.Logging;
 using Serilog;
+using Serilog.Core;
 using ILogger = Microsoft.Extensions.Logging.ILogger;
 
 namespace CounterStrikeSharp.API.Core.Logging;
 
 public static class CoreLogging
 {
-    public static ILoggerFactory Factory { get; }
-    
-    static CoreLogging()
-    {
-        var logger = new LoggerConfiguration()
-            .Enrich.FromLogContext()
-            .Enrich.With<SourceContextEnricher>()
-            .WriteTo.Console(outputTemplate: "{Timestamp:HH:mm:ss} [{Level:u4}] (cssharp:{SourceContext}) {Message:lj}{NewLine}{Exception}")
-            .WriteTo.File(Path.Join(new[] {GlobalContext.RootDirectory, "logs", $"log-cssharp.txt"}), rollingInterval: RollingInterval.Day, outputTemplate: "{Timestamp:yyyy-MM-dd HH:mm:ss.fff zzz} [{Level:u4}] (cssharp:{SourceContext}) {Message:lj}{NewLine}{Exception}")
-            .WriteTo.File(Path.Join(new[] {GlobalContext.RootDirectory, "logs", $"log-all.txt"}), rollingInterval: RollingInterval.Day, shared: true, outputTemplate: "{Timestamp:yyyy-MM-dd HH:mm:ss.fff zzz} [{Level:u4}] (cssharp:{SourceContext}) {Message:lj}{NewLine}{Exception}")
-            .CreateLogger();
+    public static ILoggerFactory Factory { get; private set; }
+    private static Logger? SerilogLogger { get; set; }
 
-        Factory =
-            LoggerFactory.Create(builder =>
-            {
-                builder.AddSerilog(logger);
-            });
+    public static void AddCoreLogging(this ILoggingBuilder builder, string contentRoot)
+    {
+        if (SerilogLogger == null)
+        {
+            SerilogLogger = new LoggerConfiguration()
+                .Enrich.FromLogContext()
+                .Enrich.With<SourceContextEnricher>()
+                .WriteTo.Console(
+                    outputTemplate:
+                    "{Timestamp:HH:mm:ss} [{Level:u4}] (cssharp:{SourceContext}) {Message:lj}{NewLine}{Exception}")
+                .WriteTo.File(Path.Join(new[] { contentRoot, "logs", $"log-cssharp.txt" }),
+                    rollingInterval: RollingInterval.Day,
+                    outputTemplate:
+                    "{Timestamp:yyyy-MM-dd HH:mm:ss.fff zzz} [{Level:u4}] (cssharp:{SourceContext}) {Message:lj}{NewLine}{Exception}")
+                .WriteTo.File(Path.Join(new[] { contentRoot, "logs", $"log-all.txt" }),
+                    rollingInterval: RollingInterval.Day, shared: true,
+                    outputTemplate:
+                    "{Timestamp:yyyy-MM-dd HH:mm:ss.fff zzz} [{Level:u4}] (cssharp:{SourceContext}) {Message:lj}{NewLine}{Exception}")
+                .CreateLogger();
+
+            Factory =
+                LoggerFactory.Create(builder => { builder.AddSerilog(SerilogLogger); });
+        }
+
+        builder.AddSerilog(SerilogLogger);
     }
 }

managed/CounterStrikeSharp.API/Core/Logging/PluginLogging.cs

@@ -1,32 +0,0 @@
-using System.IO;
-using Microsoft.Extensions.Logging;
-using Serilog;
-using ILogger = Microsoft.Extensions.Logging.ILogger;
-
-namespace CounterStrikeSharp.API.Core.Logging;
-
-public class PluginLogging
-{
-    /// <summary>
-    /// Creates a logger scoped to a specific plugin
-    /// <remarks>Eventually this should probably come from a service collection</remarks>
-    /// </summary>
-    public static ILogger CreatePluginLogger(PluginContext pluginContext)
-    {
-        var logger = new LoggerConfiguration()
-            .Enrich.FromLogContext()
-            .Enrich.With(new PluginNameEnricher(pluginContext))
-            .WriteTo.Console(outputTemplate: "{Timestamp:HH:mm:ss} [{Level:u4}] (plugin:{PluginName}) {Message:lj}{NewLine}{Exception}")
-            .WriteTo.File(Path.Join(new[] {GlobalContext.RootDirectory, "logs", $"log-{pluginContext.PluginType.Name}.txt"}), rollingInterval: RollingInterval.Day, outputTemplate: "{Timestamp:yyyy-MM-dd HH:mm:ss.fff zzz} [{Level:u4}] plugin:{PluginName} {Message:lj}{NewLine}{Exception}")
-            .WriteTo.File(Path.Join(new[] {GlobalContext.RootDirectory, "logs", $"log-all.txt"}), rollingInterval: RollingInterval.Day, shared: true, outputTemplate: "{Timestamp:yyyy-MM-dd HH:mm:ss.fff zzz} [{Level:u4}] plugin:{PluginName} {Message:lj}{NewLine}{Exception}")
-            .CreateLogger();
-
-        using ILoggerFactory loggerFactory =
-            LoggerFactory.Create(builder =>
-            {
-                builder.AddSerilog(logger);
-            });
-        
-        return loggerFactory.CreateLogger(pluginContext.PluginType);
-    }
-}

managed/CounterStrikeSharp.API/Core/Logging/PluginNameEnricher.cs

@@ -1,3 +1,4 @@
+using CounterStrikeSharp.API.Core.Plugin;
 using Serilog.Core;
 using Serilog.Events;
 
@@ -16,7 +17,7 @@ public class PluginNameEnricher : ILogEventEnricher
 
     public void Enrich(LogEvent logEvent, ILogEventPropertyFactory propertyFactory)
     {
-        var property = propertyFactory.CreateProperty(PropertyName, Context.PluginType.Name);
+        var property = propertyFactory.CreateProperty(PropertyName, Context.Plugin.ModuleName);
         logEvent.AddPropertyIfAbsent(property);
     }
 }

managed/CounterStrikeSharp.API/Core/Plugin/Host/IPluginContextQueryHandler.cs

@@ -0,0 +1,14 @@
+namespace CounterStrikeSharp.API.Core.Plugin.Host;
+
+public interface IPluginContextQueryHandler
+{
+    IPluginContext? FindPluginByType(Type moduleClass);
+
+    IPluginContext? FindPluginById(int id);
+
+    IPluginContext? FindPluginByModuleName(string name);
+
+    IPluginContext? FindPluginByModulePath(string path);
+
+    IPluginContext? FindPluginByIdOrName(string query);
+}

managed/CounterStrikeSharp.API/Core/Plugin/Host/IPluginManager.cs

@@ -0,0 +1,10 @@
+using System.Collections.Generic;
+
+namespace CounterStrikeSharp.API.Core.Plugin.Host;
+
+public interface IPluginManager
+{
+    public void Load();
+    public void LoadPlugin(string path);
+    public IEnumerable<PluginContext> GetLoadedPlugins();
+}

managed/CounterStrikeSharp.API/Core/Plugin/Host/PluginContextQueryHandler.cs

@@ -0,0 +1,38 @@
+using System.Linq;
+
+namespace CounterStrikeSharp.API.Core.Plugin.Host;
+
+public class PluginContextQueryHandler : IPluginContextQueryHandler
+{
+    private readonly IPluginManager _pluginManager;
+
+    public PluginContextQueryHandler(IPluginManager pluginManager)
+    {
+        _pluginManager = pluginManager;
+    }
+
+    public IPluginContext? FindPluginByType(Type moduleClass)
+    {
+        return _pluginManager.GetLoadedPlugins().FirstOrDefault(x => x.Plugin.GetType() == moduleClass);
+    }
+
+    public IPluginContext? FindPluginById(int id)
+    {
+        return _pluginManager.GetLoadedPlugins().FirstOrDefault(x => x.PluginId == id);
+    }
+
+    public IPluginContext? FindPluginByModuleName(string name)
+    {
+        return _pluginManager.GetLoadedPlugins().FirstOrDefault(x => x.Plugin.ModuleName == name);
+    }
+
+    public IPluginContext? FindPluginByModulePath(string path)
+    {
+        return _pluginManager.GetLoadedPlugins().FirstOrDefault(x => x.Plugin.ModulePath == path);
+    }
+
+    public IPluginContext? FindPluginByIdOrName(string query)
+    {
+        return _pluginManager.GetLoadedPlugins().FirstOrDefault(x => x.PluginId.ToString() == query || x.Plugin.ModuleName == query);
+    }
+}

managed/CounterStrikeSharp.API/Core/Plugin/Host/PluginManager.cs

@@ -0,0 +1,54 @@
+using System.Collections.Generic;
+using System.Linq;
+using CounterStrikeSharp.API.Core.Hosting;
+using Microsoft.Extensions.Logging;
+
+namespace CounterStrikeSharp.API.Core.Plugin.Host;
+
+public class PluginManager : IPluginManager
+{
+    private readonly HashSet<PluginContext> _loadedPluginContexts = new();
+    private readonly IScriptHostConfiguration _scriptHostConfiguration;
+    private readonly IServiceProvider _serviceProvider;
+    private readonly ILogger<PluginManager> _logger;
+
+    public PluginManager(IScriptHostConfiguration scriptHostConfiguration, ILogger<PluginManager> logger, IServiceProvider serviceProvider)
+    {
+        _scriptHostConfiguration = scriptHostConfiguration;
+        _logger = logger;
+        _serviceProvider = serviceProvider;
+    }
+
+    public void Load()
+    {
+        var pluginDirectories = Directory.GetDirectories(_scriptHostConfiguration.PluginPath);
+        var pluginAssemblyPaths = pluginDirectories
+            .Select(dir => Path.Combine(dir, Path.GetFileName(dir) + ".dll"))
+            .Where(File.Exists)
+            .ToArray();
+
+        foreach (var path in pluginAssemblyPaths)
+        {
+            try
+            {
+                LoadPlugin(path);
+            }
+            catch (Exception e)
+            {
+                _logger.LogError(e, "Failed to load plugin from {Path}", path);
+            }
+        }
+    }
+
+    public IEnumerable<PluginContext> GetLoadedPlugins()
+    {
+        return _loadedPluginContexts;
+    }
+
+    public void LoadPlugin(string path)
+    {
+        var plugin = new PluginContext(_serviceProvider, _scriptHostConfiguration, path, _loadedPluginContexts.Select(x => x.PluginId).DefaultIfEmpty(0).Max() + 1);
+        _loadedPluginContexts.Add(plugin);
+        plugin.Load();
+    }
+}

managed/CounterStrikeSharp.API/Core/Plugin/IPluginContext.cs

@@ -0,0 +1,11 @@
+namespace CounterStrikeSharp.API.Core.Plugin;
+
+public interface IPluginContext
+{
+    PluginState State { get; }
+    IPlugin Plugin { get; }
+    int PluginId { get; }
+
+    void Load(bool hotReload);
+    void Unload(bool hotReload);
+}

managed/CounterStrikeSharp.API/Core/Plugin/PluginContext.cs

@@ -0,0 +1,206 @@
+/*
+ *  This file is part of CounterStrikeSharp.
+ *  CounterStrikeSharp is free software: you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation, either version 3 of the License, or
+ *  (at your option) any later version.
+ *
+ *  CounterStrikeSharp is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with CounterStrikeSharp.  If not, see <https://www.gnu.org/licenses/>. *
+ */
+
+using System.Linq;
+using System.Reflection;
+using System.Threading.Tasks;
+using CounterStrikeSharp.API.Core.Attributes;
+using CounterStrikeSharp.API.Core.Hosting;
+using CounterStrikeSharp.API.Core.Logging;
+using McMaster.NETCore.Plugins;
+using Microsoft.Extensions.DependencyInjection;
+using Microsoft.Extensions.Logging;
+using Serilog;
+using ILogger = Microsoft.Extensions.Logging.ILogger;
+
+namespace CounterStrikeSharp.API.Core.Plugin
+{
+    public class PluginContext : IPluginContext
+    {
+        public PluginState State { get; set; } = PluginState.Unregistered;
+        public IPlugin Plugin { get; private set; }
+
+        private PluginLoader Loader { get; set; }
+
+        private IServiceProvider ServiceProvider { get; set; }
+
+        public int PluginId { get; }
+
+        private readonly IScriptHostConfiguration _hostConfiguration;
+        private readonly string _path;
+        private readonly FileSystemWatcher _fileWatcher;
+        private readonly IServiceProvider _applicationServiceProvider;
+
+        // TOOD: ServiceCollection
+        private ILogger _logger = CoreLogging.Factory.CreateLogger<PluginContext>();
+
+        public PluginContext(IServiceProvider applicationServiceProvider, IScriptHostConfiguration hostConfiguration, string path, int id)
+        {
+            _applicationServiceProvider = applicationServiceProvider;
+            _hostConfiguration = hostConfiguration;
+            _path = path;
+            PluginId = id;
+
+            Loader = PluginLoader.CreateFromAssemblyFile(path,
+                new[]
+                {
+                    typeof(IPlugin), typeof(ILogger), typeof(IServiceCollection), typeof(IPluginServiceCollection<>)
+                }, config =>
+                {
+                    config.EnableHotReload = true;
+                    config.IsUnloadable = true;
+                });
+
+            _fileWatcher = new FileSystemWatcher
+            {
+                Path = Path.GetDirectoryName(path)
+            };
+
+            _fileWatcher.Deleted += async (s, e) =>
+            {
+                if (e.FullPath == path)
+                {
+                    _logger.LogInformation("Plugin {Name} has been deleted, unloading...", Plugin.ModuleName);
+                    Unload(true);
+                }
+            };
+
+            _fileWatcher.Filter = "*.dll";
+            _fileWatcher.EnableRaisingEvents = true;
+            Loader.Reloaded += async (s, e) => await OnReloadedAsync(s, e);
+        }
+
+        private Task OnReloadedAsync(object sender, PluginReloadedEventArgs eventargs)
+        {
+            _logger.LogInformation("Reloading plugin {Name}", Plugin.ModuleName);
+            Loader = eventargs.Loader;
+            Unload(hotReload: true);
+            Load(hotReload: true);
+
+            return Task.CompletedTask;
+        }
+
+        public void Load(bool hotReload = false)
+        {
+            if (State == PluginState.Loaded) return;
+
+            using (Loader.EnterContextualReflection())
+            {
+                var defaultAssembly = Loader.LoadDefaultAssembly();
+
+                Type pluginType = defaultAssembly.GetTypes()
+                    .FirstOrDefault(t => typeof(IPlugin).IsAssignableFrom(t));
+
+                if (pluginType == null) throw new Exception("Unable to find plugin in assembly");
+
+                var serviceCollection = new ServiceCollection();
+
+                serviceCollection.Scan(scan =>
+                    scan.FromAssemblies(defaultAssembly)
+                        .AddClasses(c => c.AssignableTo<IPlugin>())
+                        .AsSelf()
+                        .WithSingletonLifetime()
+                );
+
+                serviceCollection.AddLogging(builder =>
+                {
+                    builder.ClearProviders();
+                    builder.AddSerilog(new LoggerConfiguration()
+                        .Enrich.FromLogContext()
+                        .Enrich.With(new PluginNameEnricher(this))
+                        .WriteTo.Console(
+                            outputTemplate:
+                            "{Timestamp:HH:mm:ss} [{Level:u4}] (plugin:{PluginName}) {Message:lj}{NewLine}{Exception}")
+                        .WriteTo.File(
+                            Path.Join(new[]
+                            {
+                                _hostConfiguration.RootPath, "logs",
+                                $"log-{pluginType.Assembly.GetName().Name}.txt"
+                            }), rollingInterval: RollingInterval.Day,
+                            outputTemplate:
+                            "{Timestamp:yyyy-MM-dd HH:mm:ss.fff zzz} [{Level:u4}] plugin:{PluginName} {Message:lj}{NewLine}{Exception}")
+                        .WriteTo.File(Path.Join(new[] { _hostConfiguration.RootPath, "logs", $"log-all.txt" }),
+                            rollingInterval: RollingInterval.Day, shared: true,
+                            outputTemplate:
+                            "{Timestamp:yyyy-MM-dd HH:mm:ss.fff zzz} [{Level:u4}] plugin:{PluginName} {Message:lj}{NewLine}{Exception}")
+                        .CreateLogger());
+                });
+
+                Type interfaceType = typeof(IPluginServiceCollection<>).MakeGenericType(pluginType);
+                Type[] serviceCollectionConfiguratorTypes = AppDomain.CurrentDomain.GetAssemblies()
+                    .SelectMany(assembly => assembly.GetTypes())
+                    .Where(type => interfaceType.IsAssignableFrom(type) && !type.IsInterface && !type.IsAbstract)
+                    .ToArray();
+
+                if (serviceCollectionConfiguratorTypes.Any())
+                {
+                    foreach (var t in serviceCollectionConfiguratorTypes)
+                    {
+                        var pluginServiceCollection = Activator.CreateInstance(t);
+                        MethodInfo method = t.GetMethod("ConfigureServices");
+                        method?.Invoke(pluginServiceCollection, new object[] { serviceCollection });
+                    }
+                }
+                
+                serviceCollection.AddSingleton(this);
+                ServiceProvider = serviceCollection.BuildServiceProvider();
+
+                var minimumApiVersion = pluginType.GetCustomAttribute<MinimumApiVersion>()?.Version;
+                var currentVersion = Api.GetVersion();
+
+                // Ignore version 0 for local development
+                if (currentVersion > 0 && minimumApiVersion != null && minimumApiVersion > currentVersion)
+                    throw new Exception(
+                        $"Plugin \"{Path.GetFileName(_path)}\" requires a newer version of CounterStrikeSharp. The plugin expects version [{minimumApiVersion}] but the current version is [{currentVersion}].");
+
+                _logger.LogInformation("Loading plugin {Name}", pluginType.Assembly.GetName().Name);
+
+                Plugin = ServiceProvider.GetRequiredService(pluginType) as IPlugin;
+                
+                if (Plugin == null) throw new Exception("Unable to create plugin instance");
+                
+                State = PluginState.Loading;
+
+                Plugin.ModulePath = _path;
+                Plugin.RegisterAllAttributes(Plugin);
+                Plugin.Logger = ServiceProvider.GetRequiredService<ILoggerFactory>().CreateLogger(pluginType);
+
+                Plugin.InitializeConfig(Plugin, pluginType);
+                Plugin.Load(hotReload);
+
+                _logger.LogInformation("Finished loading plugin {Name}", Plugin.ModuleName);
+
+                State = PluginState.Loaded;
+            }
+        }
+
+        public void Unload(bool hotReload = false)
+        {
+            if (State == PluginState.Unloaded) return;
+
+            State = PluginState.Unloaded;
+            var cachedName = Plugin.ModuleName;
+
+            _logger.LogInformation("Unloading plugin {Name}", Plugin.ModuleName);
+
+            Plugin.Unload(hotReload);
+
+            Plugin.Dispose();
+
+            _logger.LogInformation("Finished unloading plugin {Name}", cachedName);
+        }
+    }
+}

managed/CounterStrikeSharp.API/Core/Plugin/PluginState.cs

@@ -0,0 +1,9 @@
+namespace CounterStrikeSharp.API.Core.Plugin;
+
+public enum PluginState
+{
+    Unregistered,
+    Loading,
+    Loaded, 
+    Unloaded,
+}

managed/CounterStrikeSharp.API/Core/PluginContext.cs

@@ -1,137 +0,0 @@
-/*
- *  This file is part of CounterStrikeSharp.
- *  CounterStrikeSharp is free software: you can redistribute it and/or modify
- *  it under the terms of the GNU General Public License as published by
- *  the Free Software Foundation, either version 3 of the License, or
- *  (at your option) any later version.
- *
- *  CounterStrikeSharp is distributed in the hope that it will be useful,
- *  but WITHOUT ANY WARRANTY; without even the implied warranty of
- *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *  GNU General Public License for more details.
- *
- *  You should have received a copy of the GNU General Public License
- *  along with CounterStrikeSharp.  If not, see <https://www.gnu.org/licenses/>. *
- */
-
-using System;
-using System.IO;
-using System.Linq;
-using System.Reflection;
-using System.Threading.Tasks;
-using CounterStrikeSharp.API.Core.Attributes;
-using CounterStrikeSharp.API.Core.Logging;
-using McMaster.NETCore.Plugins;
-using Microsoft.Extensions.Logging;
-
-namespace CounterStrikeSharp.API.Core
-{
-    public class PluginContext
-    {
-        private BasePlugin _plugin;
-        private PluginLoader _assemblyLoader;
-
-        public string Name => _plugin?.ModuleName;
-        public string Version => _plugin?.ModuleVersion;
-        public string Description => _plugin.ModuleDescription;
-        public string Author => _plugin.ModuleAuthor;
-        public Type PluginType => _plugin?.GetType();
-        public string PluginPath => _plugin?.ModulePath;
-
-        public int PluginId { get; }
-
-        private readonly string _path;
-        private readonly FileSystemWatcher _fileWatcher;
-
-        // TOOD: ServiceCollection
-        private ILogger _logger = CoreLogging.Factory.CreateLogger<PluginContext>();
-
-        public PluginContext(string path, int id)
-        {
-            _path = path;
-            PluginId = id;
-
-            _assemblyLoader = PluginLoader.CreateFromAssemblyFile(path, new[] { typeof(IPlugin) }, config =>
-            {
-                config.EnableHotReload = true;
-                config.IsUnloadable = true;
-            });
-
-            _fileWatcher = new FileSystemWatcher
-            {
-                Path = Path.GetDirectoryName(path)
-            };
-
-            _fileWatcher.Deleted += async (s, e) =>
-            {
-                if (e.FullPath == path)
-                {
-                    _logger.LogInformation("Plugin {Name} has been deleted, unloading...", Name);
-                    Unload(true);
-                }
-            };
-
-            _fileWatcher.Filter = "*.dll";
-            _fileWatcher.EnableRaisingEvents = true;
-            _assemblyLoader.Reloaded += async (s, e) => await OnReloadedAsync(s, e);
-        }
-
-        private Task OnReloadedAsync(object sender, PluginReloadedEventArgs eventargs)
-        {
-            _logger.LogInformation("Reloading plugin {Name}", Name);
-            _assemblyLoader = eventargs.Loader;
-            Unload(hotReload: true);
-            Load(hotReload: true);
-
-            return Task.CompletedTask;
-        }
-
-        public void Load(bool hotReload = false)
-        {
-            using (_assemblyLoader.EnterContextualReflection())
-            {
-                Type pluginType = _assemblyLoader.LoadDefaultAssembly().GetTypes()
-                    .FirstOrDefault(t => typeof(IPlugin).IsAssignableFrom(t));
-
-                if (pluginType == null) throw new Exception("Unable to find plugin in DLL");
-
-                var minimumApiVersion = pluginType.GetCustomAttribute<MinimumApiVersion>()?.Version;
-                var currentVersion = Api.GetVersion();
-                
-                // Ignore version 0 for local development
-                if (currentVersion > 0 && minimumApiVersion != null && minimumApiVersion > currentVersion)
-                    throw new Exception(
-                        $"Plugin \"{Path.GetFileName(_path)}\" requires a newer version of CounterStrikeSharp. The plugin expects version [{minimumApiVersion}] but the current version is [{currentVersion}].");
-
-                _logger.LogInformation("Loading plugin {Name}", pluginType.Name);
-                _plugin = (BasePlugin)Activator.CreateInstance(pluginType)!;
-                _plugin.ModulePath = _path;
-                _plugin.RegisterAllAttributes(_plugin);
-                _plugin.Logger =  PluginLogging.CreatePluginLogger(this);
-                _plugin.InitializeConfig(_plugin, pluginType);
-                _plugin.Load(hotReload);
-
-                _logger.LogInformation("Finished loading plugin {Name}", Name);
-            }
-        }
-
-        public void Unload(bool hotReload = false)
-        {
-            var cachedName = Name;
-
-            _logger.LogInformation("Unloading plugin {Name}", Name);
-
-            _plugin.Unload(hotReload);
-
-            _plugin.Dispose();
-
-            if (!hotReload)
-            {
-                _assemblyLoader.Dispose();
-                _fileWatcher.Dispose();
-            }
-
-            _logger.LogInformation("Finished unloading plugin {Name}", Name);
-        }
-    }
-}

managed/CounterStrikeSharp.API/CounterStrikeSharp.API.csproj

@@ -1,4 +1,4 @@
-<Project Sdk="Microsoft.NET.Sdk">
+<Project Sdk="Microsoft.NET.Sdk">
   <PropertyGroup>
     <TargetFramework>net7.0</TargetFramework>
     <EnableDynamicLoading>true</EnableDynamicLoading>
@@ -23,7 +23,10 @@
   <ItemGroup>
     <PackageReference Include="McMaster.NETCore.Plugins" Version="1.4.0" />
     <PackageReference Include="Microsoft.CSharp" Version="4.7.0" />
+    <PackageReference Include="Microsoft.Extensions.Hosting" Version="7.0.0" />
+    <PackageReference Include="Microsoft.Extensions.Hosting.Abstractions" Version="7.0.0" />
     <PackageReference Include="Microsoft.Extensions.Logging" Version="7.0.0" />
+    <PackageReference Include="Scrutor" Version="4.2.2" />
     <PackageReference Include="Serilog.Extensions.Logging" Version="7.0.0" />
     <PackageReference Include="Serilog.Sinks.Console" Version="5.0.0" />
     <PackageReference Include="Serilog.Sinks.File" Version="5.0.0" />

managed/CounterStrikeSharp.API/GlobalUsings.cs

@@ -0,0 +1,5 @@
+// Global using directives
+
+global using System;
+global using System.IO;
+global using CounterStrikeSharp.API.Core;

managed/CounterStrikeSharp.API/Modules/Commands/CommandExtensions.cs

@@ -0,0 +1,14 @@
+using CounterStrikeSharp.API.Modules.Commands.Targeting;
+
+namespace CounterStrikeSharp.API.Modules.Commands;
+
+public static class CommandExtensions
+{
+    /// <summary>
+    /// Treats the argument at the specified index as a target string (@all, @me etc.) and returns the result.
+    /// </summary>
+    public static TargetResult GetArgTargetResult(this CommandInfo commandInfo, int index)
+    {
+        return new Target(commandInfo.GetArg(index)).GetTarget(commandInfo.CallingPlayer);
+    }
+}

managed/CounterStrikeSharp.API/Modules/Commands/CommandInfo.cs

@@ -25,13 +25,14 @@ namespace CounterStrikeSharp.API.Modules.Commands
         
         public delegate HookResult CommandListenerCallback(CCSPlayerController? player, CommandInfo commandInfo);
 
-        private CCSPlayerController _player;
-        public IntPtr Handle { get; private set; }
+        public CCSPlayerController? CallingPlayer { get; }
+        
+        public IntPtr Handle { get; }
         
         internal CommandInfo(IntPtr pointer, CCSPlayerController player) 
         {
             Handle = pointer;
-            _player = player;
+            CallingPlayer = player;
         }
 
         public int ArgCount => NativeAPI.CommandGetArgCount(Handle);
@@ -42,12 +43,12 @@ namespace CounterStrikeSharp.API.Modules.Commands
 
         public string ArgByIndex(int index) => NativeAPI.CommandGetArgByIndex(Handle, index);
         public string GetArg(int index) => NativeAPI.CommandGetArgByIndex(Handle, index);
-
+        
         public void ReplyToCommand(string message, bool console = false) {
-            if (_player != null) 
+            if (CallingPlayer != null) 
             {
-                if (console) { _player.PrintToConsole(message); }
-                else _player.PrintToChat(message);
+                if (console) { CallingPlayer.PrintToConsole(message); }
+                else CallingPlayer.PrintToChat(message);
             }
             else 
             {

managed/CounterStrikeSharp.API/Modules/Commands/Targeting/Target.cs

@@ -0,0 +1,126 @@
+using System.Collections.Generic;
+using System.Diagnostics.CodeAnalysis;
+using System.Linq;
+using CounterStrikeSharp.API.Modules.Entities;
+using CounterStrikeSharp.API.Modules.Utils;
+
+namespace CounterStrikeSharp.API.Modules.Commands.Targeting;
+
+public class Target
+{
+    private TargetType Type { get; }
+    private string Raw { get; }
+    private string Slug { get; }
+    
+    private static readonly Dictionary<string, TargetType> TargetTypeMap = new(StringComparer.OrdinalIgnoreCase)
+    {
+        { "@all", TargetType.GroupAll },
+        { "@bots", TargetType.GroupBots },
+        { "@human", TargetType.GroupHumans },
+        { "@alive", TargetType.GroupAlive },
+        { "@dead", TargetType.GroupDead },
+        { "@!me", TargetType.GroupNotMe },
+        { "@me", TargetType.PlayerMe },
+        { "@ct", TargetType.TeamCt },
+        { "@t", TargetType.TeamT },
+        { "@spec", TargetType.TeamSpec }
+    };
+
+
+    private static bool ConstTargetType(string target, out TargetType targetType)
+    {
+        targetType = TargetType.Invalid;
+        if (!target.StartsWith("@"))
+        {
+            return false;
+        }
+
+        return TargetTypeMap.TryGetValue(target, out targetType);
+    }
+
+    private bool IdTargetType(string target,
+        out TargetType targetType,
+        [MaybeNullWhen(false)] out string slug)
+    {
+        targetType = TargetType.Invalid;
+        slug = null!;
+        if (!target.StartsWith("#"))
+        {
+            return false;
+        }
+        
+        slug = target.TrimStart('#');
+        if (slug.StartsWith("STEAM")) targetType = TargetType.IdSteamEscaped;
+        else if (!ulong.TryParse(slug, out _)) targetType = TargetType.ExplicitName;
+        else if (slug.Length == 17) targetType = TargetType.IdSteam64;
+        else targetType = TargetType.IdUserid;
+
+        return true;
+    }
+
+
+    public Target(string target)
+    {
+        Raw = target.Trim();
+        if (ConstTargetType(Raw, out var targetType))
+        {
+            Type = targetType;
+            Slug = Raw;
+        }
+        else if (IdTargetType(Raw, out targetType, out var slug))
+        {
+            Type = targetType;
+            Slug = slug;
+        }
+        else
+        {
+            Type = TargetType.ImplicitName;
+            Slug = Raw;
+        }
+    }
+
+    private bool TargetPredicate(CCSPlayerController player, CCSPlayerController? caller)
+    {
+        switch (Type)
+        {
+            case TargetType.TeamCt:
+                return player.TeamNum == (byte)CsTeam.CounterTerrorist;
+            case TargetType.TeamT:
+                return player.TeamNum == (byte)CsTeam.Terrorist;
+            case TargetType.TeamSpec:
+                return player.TeamNum == (byte)CsTeam.Spectator;
+            case TargetType.GroupAll:
+                return true;
+            case TargetType.GroupBots:
+                return player.IsBot;
+            case TargetType.GroupHumans:
+                return !player.IsBot;
+            case TargetType.GroupAlive:
+                return player.PlayerPawn is { IsValid: true, Value.LifeState: (byte)LifeState_t.LIFE_ALIVE };
+            case TargetType.GroupDead:
+                return player.PlayerPawn is { IsValid: true, Value.LifeState: (byte)LifeState_t.LIFE_DEAD or (byte)LifeState_t.LIFE_DYING };
+            case TargetType.GroupNotMe:
+                return player.SteamID != caller?.SteamID;
+            case TargetType.PlayerMe:
+                return player.SteamID == caller?.SteamID;
+            case TargetType.IdUserid:
+                return player.UserId.ToString() == Slug;
+            case TargetType.IdSteamEscaped:
+                return ((SteamID)player.SteamID).SteamId2 == Slug;
+            case TargetType.IdSteam64:
+                return ((SteamID)player.SteamID).SteamId64.ToString() == Slug;
+            case TargetType.ExplicitName:
+            case TargetType.ImplicitName:
+                return player.PlayerName.Contains(Slug, StringComparison.OrdinalIgnoreCase);
+            default:
+                return false;
+        }
+    }
+
+    public TargetResult GetTarget(CCSPlayerController? caller)
+    {
+        var players = Utilities.GetPlayers().Where(player => TargetPredicate(player, caller)).ToList();
+        
+        return new TargetResult() { Players = players };
+    }
+}

managed/CounterStrikeSharp.API/Modules/Commands/Targeting/TargetResult.cs

@@ -0,0 +1,20 @@
+using System.Collections;
+using System.Collections.Generic;
+using System.Linq;
+
+namespace CounterStrikeSharp.API.Modules.Commands.Targeting;
+
+public class TargetResult : IEnumerable<CCSPlayerController>
+{
+    public List<CCSPlayerController> Players { get; set; } = new();
+    
+    public IEnumerator<CCSPlayerController> GetEnumerator()
+    {
+        return Players.GetEnumerator();
+    }
+
+    IEnumerator IEnumerable.GetEnumerator()
+    {
+        return GetEnumerator();
+    }
+}

managed/CounterStrikeSharp.API/Modules/Commands/Targeting/TargetType.cs

@@ -0,0 +1,25 @@
+namespace CounterStrikeSharp.API.Modules.Commands.Targeting;
+
+public enum TargetType
+{
+    TeamCt, // @ct
+    TeamT, // @t
+    TeamSpec, // @spec
+
+    GroupAll, // @all
+    GroupBots, // @bots
+    GroupHumans, // @human
+    GroupAlive, // @alive
+    GroupDead, // @dead
+    GroupNotMe, // @!me
+
+    PlayerMe, // @me
+
+    IdUserid, // #4
+    IdSteamEscaped, // "#STEAM_0:1:8614"
+    IdSteam64, // #76561198116940237
+
+    ExplicitName, // #name
+    ImplicitName, // name
+    Invalid
+}

managed/CounterStrikeSharp.API/Modules/Config/ConfigManager.cs

@@ -43,10 +43,11 @@ namespace CounterStrikeSharp.API.Modules.Config
         {
             string directoryPath = Path.Combine(_pluginConfigsFolderPath, pluginName);
             string configPath = Path.Combine(directoryPath, $"{pluginName}.json");
+            string exampleConfigPath = Path.Combine(directoryPath, $"{pluginName}.example.json");
 
             T config = (T)Activator.CreateInstance(typeof(T))!;
 
-            if (!File.Exists(configPath))
+            if (!File.Exists(configPath) && !File.Exists(exampleConfigPath))
             {
                 try
                 {
@@ -56,8 +57,10 @@ namespace CounterStrikeSharp.API.Modules.Config
                     }
 
                     StringBuilder builder = new StringBuilder();
-                    builder.Append($"// This configuration was automatically generated by CounterStrikeSharp for plugin '{pluginName}', at {DateTimeOffset.Now:yyyy/MM/dd hh:mm:ss}\n");
-                    builder.Append(JsonSerializer.Serialize<T>(config, new JsonSerializerOptions { WriteIndented = true }));
+                    builder.Append(
+                        $"// This configuration was automatically generated by CounterStrikeSharp for plugin '{pluginName}', at {DateTimeOffset.Now:yyyy/MM/dd hh:mm:ss}\n");
+                    builder.Append(JsonSerializer.Serialize<T>(config,
+                        new JsonSerializerOptions { WriteIndented = true }));
                     File.WriteAllText(configPath, builder.ToString());
                     return config;
                 }
@@ -65,6 +68,17 @@ namespace CounterStrikeSharp.API.Modules.Config
                 {
                     _logger.LogError(ex, "Failed to generate configuration file for {PluginName}", pluginName);
                 }
+            } else if (File.Exists(exampleConfigPath) && !File.Exists(configPath))
+            {
+                try
+                {
+                    _logger.LogInformation("Copying example configuration file for {PluginName}", pluginName);
+                    File.Copy(exampleConfigPath, configPath);
+                }
+                catch (Exception ex)
+                {
+                    _logger.LogError(ex, "Failed to copy example configuration file for {PluginName}", pluginName);
+                }
             }
 
             try

managed/CounterStrikeSharp.API/Modules/Memory/DataType.cs

@@ -73,7 +73,7 @@ namespace CounterStrikeSharp.API.Modules.Memory
                 return types[Enum.GetUnderlyingType(type)];
             }
             
-            GlobalContext.Instance.Logger.LogWarning("Error retrieving data type for type {Type}", type.FullName);
+            Core.Application.Instance.Logger.LogWarning("Error retrieving data type for type {Type}", type.FullName);
 
             return null;
         }

managed/CounterStrikeSharp.API/Modules/Utils/ChatColors.cs

@@ -14,29 +14,29 @@
  *  along with CounterStrikeSharp.  If not, see <https://www.gnu.org/licenses/>. *
  */
 
-namespace CounterStrikeSharp.API.Modules.Utils
+namespace CounterStrikeSharp.API.Modules.Utils;
+
+public class ChatColors
 {
-    public class ChatColors
-    {
-        public static char Default = '\x01';
-        public static char White = '\x01';
-        public static char Darkred = '\x02';
-        public static char Green = '\x04';
-        public static char LightYellow = '\x09';
-        public static char LightBlue = '\x0B';
-        public static char Olive = '\x05';
-        public static char Lime = '\x06';
-        public static char Red = '\x07';
-        public static char LightPurple = '\x03';
-        public static char Purple = '\x0E';
-        public static char Grey = '\x08';
-        public static char Yellow = '\x09';
-        public static char Gold = '\x10';
-        public static char Silver = '\x0A';
-        public static char Blue = '\x0B';
-        public static char DarkBlue = '\x0C';
-        public static char BlueGrey = '\x0A';
-        public static char Magenta = '\x0E';
-        public static char LightRed = '\x0F';
-}
+    public static char Default = '\x01';
+    public static char White = '\x01';
+    public static char Darkred = '\x02';
+    public static char Green = '\x04';
+    public static char LightYellow = '\x09';
+    public static char LightBlue = '\x0B';
+    public static char Olive = '\x05';
+    public static char Lime = '\x06';
+    public static char Red = '\x07';
+    public static char LightPurple = '\x03';
+    public static char Purple = '\x0E';
+    public static char Grey = '\x08';
+    public static char Yellow = '\x09';
+    public static char Gold = '\x10';
+    public static char Silver = '\x0A';
+    public static char Blue = '\x0B';
+    public static char DarkBlue = '\x0C';
+    public static char BlueGrey = '\x0A';
+    public static char Magenta = '\x0E';
+    public static char LightRed = '\x0F';
+    public static char Orange = '\x10';
 }

managed/CounterStrikeSharp.API/Modules/Utils/EnumUtils.cs

@@ -1,5 +1,6 @@
 using System;
 using System.Linq;
+using System.Reflection;
 using System.Runtime.Serialization;
 
 
@@ -7,30 +8,57 @@ namespace CounterStrikeSharp.API.Modules.Utils
 {
     public static class EnumUtils
     {
-        public static string? GetEnumMemberAttributeValue<T>(T enumValue)
+        /// <summary>
+        /// Brute force search using Enum.GetNames as enum members pointing to other enum members do not have the correct attributes.
+        /// </summary>
+        public static T? GetEnumMemberAttribute<T>(this Enum enumValue) where T : Attribute
+        {
+            var type = enumValue.GetType();
+            foreach (var name in Enum.GetNames(type))
+            {
+                var field = type.GetField(name);
+                if (field == null) continue;
+
+                var fieldValue = field.GetValue(null)!;
+                if (fieldValue.Equals(enumValue))
+                {
+                    var attribute = field.GetCustomAttribute<T>();
+                    if (attribute != null)
+                    {
+                        return attribute;
+                    }
+                }
+            }
+
+            return null;
+        }
+
+        public static string? GetEnumMemberAttributeValue<T>(T? enumValue) where T : Enum
         {
             var enumType = typeof(T);
 
-            if(!enumType.IsEnum || enumValue == null) 
+            if (!enumType.IsEnum || enumValue == null)
             {
                 return null;
             }
 
             var enumString = enumValue.ToString();
 
-            if(string.IsNullOrWhiteSpace(enumString))
+            if (string.IsNullOrWhiteSpace(enumString))
             {
                 return null;
             }
 
             var memberInfo = enumType.GetMember(enumString);
-            var enumMemberAttribute = memberInfo.FirstOrDefault()?.GetCustomAttributes(false).OfType<EnumMemberAttribute>().FirstOrDefault();
+            var enumMemberAttribute = memberInfo.FirstOrDefault()?.GetCustomAttributes(false)
+                .OfType<EnumMemberAttribute>().FirstOrDefault();
             if (enumMemberAttribute != null)
             {
                 return enumMemberAttribute.Value;
             }
 
-            return null;
+            // Brute force search by name if we still can't find it.
+            return enumValue.GetEnumMemberAttribute<EnumMemberAttribute>()?.Value;
         }
     }
-}
+}

managed/CounterStrikeSharp.API/PlayerButtons.cs

@@ -14,8 +14,6 @@
  *  along with CounterStrikeSharp.  If not, see <https://www.gnu.org/licenses/>. *
  */
 
-using System;
-
 namespace CounterStrikeSharp.API
 {
     [Flags]

managed/CounterStrikeSharp.API/Utilities.cs

@@ -14,15 +14,14 @@
  *  along with CounterStrikeSharp.  If not, see <https://www.gnu.org/licenses/>. *
  */
 
-using CounterStrikeSharp.API.Core;
 using CounterStrikeSharp.API.Modules.Memory;
 using CounterStrikeSharp.API.Modules.Utils;
-using System;
 using System.Collections.Generic;
 using System.Linq;
 using System.Runtime.CompilerServices;
 using System.Runtime.InteropServices;
 using System.Text;
+using CounterStrikeSharp.API.Modules.Commands.Targeting;
 
 namespace CounterStrikeSharp.API
 {
@@ -64,6 +63,16 @@ namespace CounterStrikeSharp.API
             return Utilities.GetEntityFromIndex<CCSPlayerController>((userid & 0xFF) + 1);
         }
 
+        public static CCSPlayerController? GetPlayerFromSteamId(ulong steamId)
+        {
+            return Utilities.GetPlayers().FirstOrDefault(player => player.SteamID == steamId);
+        }
+
+        public static TargetResult ProcessTargetString(string pattern, CCSPlayerController player)
+        {
+            return new Target(pattern).GetTarget(player);
+        }
+
         public static IEnumerable<T> FindAllEntitiesByDesignerName<T>(string designerName) where T : CEntityInstance
         {
             var pEntity = new CEntityIdentity(NativeAPI.GetFirstActiveEntity());

managed/TestPlugin/TestPlugin.cs

@@ -61,6 +61,13 @@ namespace TestPlugin
             Config = config;
         }
 
+        private TestInjectedClass _testInjectedClass;
+
+        public SamplePlugin(TestInjectedClass testInjectedClass)
+        {
+            _testInjectedClass = testInjectedClass;
+        }
+
         public override void Load(bool hotReload)
         {
             // Basic usage of the configuration system
@@ -105,6 +112,8 @@ namespace TestPlugin
             var result = virtualFunc() - 8;
             Logger.LogInformation("Result of virtual func call is {Pointer:X}", result);
             
+            _testInjectedClass.Hello();
+
             VirtualFunctions.CBaseTrigger_StartTouchFunc.Hook(h =>
             {
                 var trigger = h.GetParam<CBaseTrigger>(0);
@@ -335,6 +344,24 @@ namespace TestPlugin
             giveItemMenu.AddMenuOption("weapon_ak47", handleGive);
             giveItemMenu.AddMenuOption("weapon_p250", handleGive);
 
+            AddCommand("css_target", "Target Test", (player, info) =>
+            {
+                if (player == null) return;
+
+                var targetResult = info.GetArgTargetResult(1);
+
+                if (!targetResult.Any())
+                {
+                    player.PrintToChat("No players found.");
+                    return;
+                }
+                
+                foreach (var result in targetResult.Players)
+                {
+                    player.PrintToChat($"Target found: {result?.PlayerName}");
+                }
+            });
+            
             AddCommand("css_menu", "Opens example menu", (player, info) => { ChatMenus.OpenMenu(player, largeMenu); });
             AddCommand("css_gunmenu", "Gun Menu", (player, info) => { ChatMenus.OpenMenu(player, giveItemMenu); });
 

managed/TestPlugin/TestPluginServiceCollection.cs

@@ -0,0 +1,29 @@
+using System;
+using CounterStrikeSharp.API.Core;
+using Microsoft.Extensions.DependencyInjection;
+using Microsoft.Extensions.Logging;
+
+namespace TestPlugin;
+
+public class TestInjectedClass
+{
+    private readonly ILogger<TestInjectedClass> _logger;
+
+    public TestInjectedClass(ILogger<TestInjectedClass> logger)
+    {
+        _logger = logger;
+    }
+
+    public void Hello()
+    {
+        _logger.LogInformation("Hello World from Test Injected Class");
+    }
+}
+
+public class TestPluginServiceCollection : IPluginServiceCollection<SamplePlugin>
+{
+    public void ConfigureServices(IServiceCollection serviceCollection)
+    {
+        serviceCollection.AddScoped<TestInjectedClass>();
+    }
+}

src/core/coreconfig.cpp

@@ -26,11 +26,22 @@ CCoreConfig::~CCoreConfig() = default;
 
 bool CCoreConfig::Init(char* conf_error, int conf_error_size)
 {
-    std::ifstream ifs(m_sPath);
+    std::ifstream ifs(std::string(m_sPath + ".json"));
 
     if (!ifs) {
-        V_snprintf(conf_error, conf_error_size, "CoreConfig file not found.");
-        return false;
+        std::ifstream exampleIfs(std::string(m_sPath + ".example.json"));
+
+        if (!exampleIfs) {
+            V_snprintf(conf_error, conf_error_size, "CoreConfig file not found.");
+            return false;
+        }
+
+        CSSHARP_CORE_INFO("CoreConfig file not found, creating one from example.");
+        std::ofstream ofs(std::string(m_sPath + ".json"));
+        ofs << exampleIfs.rdbuf();
+        ofs.close();
+
+        return Init(conf_error, conf_error_size);
     }
 
     m_json = json::parse(ifs);

src/mm_plugin.cpp

@@ -84,7 +84,7 @@ bool CounterStrikeSharpMMPlugin::Load(PluginId id, ISmmAPI* ismm, char* error, s
     GET_V_IFACE_ANY(GetEngineFactory, globals::gameEventSystem, IGameEventSystem,
                     GAMEEVENTSYSTEM_INTERFACE_VERSION);
 
-    auto coreconfig_path = std::string(utils::ConfigsDirectory() + "/core.json");
+    auto coreconfig_path = std::string(utils::ConfigsDirectory() + "/core");
     globals::coreConfig = new CCoreConfig(coreconfig_path);
     char coreconfig_error[255] = "";
 

src/scripting/dotnet_host.cpp

@@ -199,16 +199,16 @@ bool CDotNetManager::Initialize()
     const std::string dotnetlib_path =
         std::string((base_dir + "/api/CounterStrikeSharp.API.dll").c_str());
 #endif
-    const auto dotnet_type = STR("CounterStrikeSharp.API.Core.Helpers, CounterStrikeSharp.API");
+    const auto dotnet_type = STR("CounterStrikeSharp.API.Bootstrap, CounterStrikeSharp.API");
     // Namespace, assembly name
 
     typedef int(CORECLR_DELEGATE_CALLTYPE * custom_entry_point_fn)();
     custom_entry_point_fn entry_point = nullptr;
     const int rc = load_assembly_and_get_function_pointer(
-        dotnetlib_path.c_str(), dotnet_type, STR("LoadAllPlugins"), UNMANAGEDCALLERSONLY_METHOD,
+        dotnetlib_path.c_str(), dotnet_type, STR("Run"), UNMANAGEDCALLERSONLY_METHOD,
         nullptr, reinterpret_cast<void**>(&entry_point));
     if (entry_point == nullptr) {
-        CSSHARP_CORE_ERROR("Trying to get entry point \"LoadAllPlugins\" but failed.");
+        CSSHARP_CORE_ERROR("Trying to get entry point \"Bootstrap::Run\" but failed.");
         return false;
     }
 
@@ -216,7 +216,7 @@ bool CDotNetManager::Initialize()
            "Failure: load_assembly_and_get_function_pointer()");
 
     if (const int invoke_result_code = entry_point(); invoke_result_code == 0) {
-        CSSHARP_CORE_ERROR("LoadAllPlugins return failure.");
+        CSSHARP_CORE_ERROR("Bootstrap::Run return failure.");
         return false;
     }