update 1.1.0

Author: xstage

.gitignore

@@ -0,0 +1,4 @@
+.editorconfig
+obj
+bin
+*.sln

FixRandomSpawn.csproj

@@ -8,10 +8,7 @@
   </PropertyGroup>
 
   <ItemGroup>
-    <PackageReference Include="CounterStrikeSharp.API" Version="1.0.282" />
-    <Content Include="gamedata\**">
-      <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
-    </Content>
+    <PackageReference Include="CounterStrikeSharp.API" Version="1.0.303" />
   </ItemGroup>
 
 </Project>

Plugin.cs

@@ -0,0 +1,39 @@
+using CounterStrikeSharp.API;
+using CounterStrikeSharp.API.Core;
+using Microsoft.Extensions.Logging;
+
+namespace FixRandomSpawn;
+
+public sealed class GameRules
+{
+    private Plugin plugin_ = null!;
+    private CCSGameRules value_ = null!;
+
+    public void Init(bool hotReload, Plugin plugin)
+    {
+        plugin_ = plugin;
+
+        plugin.RegisterListener<Listeners.OnMapStart>(manName =>
+        {
+            Server.NextFrame(() =>
+            {
+                FindGameRules();
+            });
+        });
+        if (hotReload) FindGameRules();
+    }
+
+    public CCSGameRules Get() => value_;
+
+    public void FindGameRules()
+    {
+        try
+        {
+            value_ = Utilities.FindAllEntitiesByDesignerName<CCSGameRulesProxy>("cs_gamerules").First().GameRules!;
+        }
+        catch (Exception)
+        {
+            plugin_.Logger.LogError("Couldn't find `CCSGameRules`");
+        }
+    }
+}

Plugin/GameRules.cs

@@ -0,0 +1,83 @@
+using System.Globalization;
+using System.Runtime.InteropServices;
+using CounterStrikeSharp.API.Core;
+using CounterStrikeSharp.API.Modules.Memory;
+
+namespace FixRandomSpawn;
+
+public unsafe partial class MemoryPatch
+{
+    [LibraryImport("libc", EntryPoint = "mprotect")]
+    private static partial int MProtect(nint address, int len, int protect);
+
+    [LibraryImport("kernel32.dll")]
+    [return: MarshalAs(UnmanagedType.Bool)]
+    private unsafe static partial bool VirtualProtect(nint address, int dwSize, int newProtect, int* oldProtect);
+
+    private readonly Dictionary<int, List<byte>> oldPattern_ = [];
+    private readonly string modulePath_;
+    private nint addr_;
+
+    public MemoryPatch(string? modulePath = null)
+    {
+        modulePath_ = modulePath ?? Addresses.ServerPath;
+    }
+
+    public void Init(string signature)
+    {
+        addr_ = NativeAPI.FindSignature(modulePath_, signature);
+    }
+
+    public void Apply(string patchSignature, int offset = 0)
+    {
+        if (string.IsNullOrEmpty(patchSignature) || oldPattern_.ContainsKey(offset)) return;
+
+        byte[] bytes = [.. patchSignature.Split(' ').Select(b => byte.Parse(b, NumberStyles.HexNumber))];
+        byte* ptrAddr = GetPtr<byte>(offset);
+
+        SetMemAccess(ptrAddr, bytes.Length);
+
+        for (int i = 0; i < bytes.Length; i++)
+        {
+            oldPattern_[offset] = [];
+            oldPattern_[offset].Add(ptrAddr[i]);
+            
+            ptrAddr[i] = bytes[i];
+        }
+    }
+
+    public void Restore()
+    {
+        if (oldPattern_.Count == 0) return;
+
+        foreach (var (offset, pattern) in oldPattern_)
+        {
+            byte* ptrAddr = GetPtr<byte>(offset);
+
+            for (int i = 0; i < pattern.Count; i++)
+            {
+                ptrAddr[i] = pattern[i];
+            }
+        }
+    }
+
+    private T* GetPtr<T>(int offset = 0) where T: unmanaged => (T*)(addr_ + offset);
+
+    private bool SetMemAccess<T>(T* ptrAddr, int size) where T: unmanaged
+    {
+        nint addr = (nint)ptrAddr;
+
+        if (addr == nint.Zero)
+            throw new ArgumentNullException(nameof(ptrAddr));
+
+        const int PAGESIZE = 4096;
+
+        nint LALIGN(nint addr) => addr & ~(PAGESIZE-1);
+        int LALDIF(nint addr) => (int)(addr % PAGESIZE);
+
+        int* oldProtect = stackalloc int[1];
+
+        return RuntimeInformation.IsOSPlatform(OSPlatform.Linux) ? 
+            MProtect(LALIGN(addr), size + LALDIF(addr), 7) == 0 : VirtualProtect(addr, size, 0x40, oldProtect);
+    }
+} 

Plugin/MemoryPatch.cs

@@ -0,0 +1,26 @@
+using CounterStrikeSharp.API.Core;
+
+namespace FixRandomSpawn;
+
+public sealed partial class Plugin : BasePlugin
+{
+    public override string ModuleName { get; } = "FixRandomSpawn";
+    public override string ModuleVersion { get; } = "1.1.0";
+    public override string ModuleAuthor { get; } = "xstage";
+
+    private readonly GameRules gameRules_ = new GameRules();
+    private readonly MemoryPatch memoryPatch_ = new MemoryPatch();
+    
+    public override void Load(bool hotReload)
+    {
+        gameRules_.Init(hotReload, this);
+
+        memoryPatch_.Init(GameData.GetSignature("EntSelectSpawnPoint"));
+        memoryPatch_.Apply(GameData.GetSignature("EntSelectSpawnPoint_Patch1"), GameData.GetOffset("EntSelectSpawnPoint_Patch1"));
+    }
+
+    public override void Unload(bool hotReload)
+    {
+        memoryPatch_.Restore();
+    }
+}

Plugin/Plugin.cs

@@ -0,0 +1,57 @@
+using System.Text.Json.Serialization;
+using CounterStrikeSharp.API.Core;
+using CounterStrikeSharp.API.Core.Attributes.Registration;
+using CounterStrikeSharp.API.Modules.Commands;
+using CounterStrikeSharp.API.Modules.Extensions;
+using Microsoft.Extensions.Logging;
+
+namespace FixRandomSpawn;
+
+public class Warmup
+{
+    [JsonPropertyName("enable")]
+    public bool Enable { get; set; } = false;
+
+    [JsonPropertyName("buy_anywhere")]
+    public bool BuyAnywhere { get; set; } = false;
+
+    [JsonPropertyName("alert_for_players")]
+    public bool AlertForPlayers { get; set; } = false; 
+}
+
+public class PluginConfig : BasePluginConfig
+{
+    [JsonPropertyName("warmup_mode")]
+    public Warmup WarmupMode { get; set; } = new();
+}
+
+public sealed partial class Plugin : IPluginConfig<PluginConfig>
+{
+    public PluginConfig Config { get; set; } = new();
+
+    [ConsoleCommand("css_randomspawn_reload", $"Reload plugin FixRandomSpawn`")]
+    public void OnConfigReload(CCSPlayerController? player, CommandInfo info)
+    {
+        try
+        {
+            Config.Reload();
+
+            info.ReplyToCommand($"[{ModuleName}] You have successfully reloaded the config.");
+        }
+        catch (Exception ex)
+        {
+            info.ReplyToCommand($"[{ModuleName}] An error occurred.");
+            Logger.LogError("An error occurred while reloading the configuration: {error}", ex.Message);
+        }
+    }
+
+    public void OnConfigParsed(PluginConfig config)
+    {
+        if (config.Version < Config.Version)
+        {
+            Logger.LogError("Your plugin configuration version is outdated! (v. {old} -> v. {new})", config.Version, Config.Version);
+        }
+
+        Config = config;
+    }
+}

Plugin/PluginConfig.cs

@@ -0,0 +1,51 @@
+using CounterStrikeSharp.API;
+using CounterStrikeSharp.API.Core;
+using CounterStrikeSharp.API.Core.Attributes.Registration;
+using CounterStrikeSharp.API.Core.Translations;
+using CounterStrikeSharp.API.Modules.Cvars;
+
+namespace FixRandomSpawn;
+
+public sealed partial class Plugin
+{
+    [GameEventHandler]
+    public HookResult OnRoundPrestart(EventRoundPrestart @event, GameEventInfo info)
+    {
+        if (!Config.WarmupMode.Enable)
+            return HookResult.Continue;
+
+        int value = Convert.ToInt32(gameRules_.Get().WarmupPeriod);
+
+        ConVar[] convars = [
+            ConVar.Find("mp_randomspawn")!,
+            ConVar.Find("mp_buy_anywhere")!,
+        ];
+
+        if (convars[0].GetPrimitiveValue<int>() != 0 || value != 0)
+        {
+            convars[0]!.SetValue(value);
+        }
+
+        if (Config.WarmupMode.BuyAnywhere && (convars[1].GetPrimitiveValue<int>() != 0 || value != 0))
+        {
+            Server.ExecuteCommand($"mp_buy_anywhere {value}");
+        }
+
+        return HookResult.Continue;
+    }
+
+    [GameEventHandler]
+    public HookResult OnPlayerTeam(EventPlayerTeam @event, GameEventInfo info)
+    {
+        var player = @event.Userid;
+
+        if (player == null || @event.Oldteam != 0 || player.IsBot) return HookResult.Continue;
+
+        if (gameRules_.Get().WarmupPeriod && Config.WarmupMode.Enable && Config.WarmupMode.AlertForPlayers)
+        {
+            player.PrintToChat(Localizer.ForPlayer(player, "Plugin.AlertForPlayers"));
+        }
+
+        return HookResult.Continue;
+    }
+}

Plugin/PluginEvents.cs

@@ -13,3 +13,16 @@ Fixes ConVar `mp_randomspawn` for any game mode
 - Make a folder in /plugins named /FixRandomSpawn.
 - Put the plugin files in to the new folder.
 - Restart your server.
+
+## Configuration
+`css_randomspawn_reload` - Reload configuration
+```json
+{
+    "warmup_mode": {
+        "enable": false, // Enable the plugin only for warmup time
+        "buy_anywhere": false, // Allow purchase anywhere on the map
+        "alert_for_players": false // Notification for players about the enabled random spawns
+    },
+    "ConfigVersion": 1
+}
+```