1.3.9a

**MAJOR UPDATE**

- New database schema
- Added `css_admins_flags` table
- Added `css_unmutes` table
- Added `css_unbans` table

Managers/AdminSQLManager.cs

@@ -6,21 +6,15 @@ using System.Collections.Concurrent;
 
 namespace CS2_SimpleAdmin;
 
-public class AdminSQLManager
+public class AdminSQLManager(Database database)
 {
-	private readonly Database _database;
+	private readonly Database _database = database;
 
 	// Unused for now
 	//public static readonly ConcurrentDictionary<string, ConcurrentBag<string>> _adminCache = new ConcurrentDictionary<string, ConcurrentBag<string>>();
 	public static readonly ConcurrentDictionary<SteamID, DateTime?> _adminCache = new();
 
-	//public static readonly ConcurrentDictionary<SteamID, DateTime?> _adminCacheTimestamps = new ConcurrentDictionary<SteamID, DateTime?>();
-
-	public AdminSQLManager(Database database)
-	{
-		_database = database;
-	}
-
+	/*
 	public async Task<List<(List<string>, int)>> GetAdminFlags(string steamId)
 	{
 		DateTime now = DateTime.UtcNow.ToLocalTime();
@@ -35,7 +29,7 @@ public class AdminSQLManager
 			return new List<(List<string>, int)>();
 		}
 
-		List<(List<string>, int)> filteredFlagsWithImmunity = new List<(List<string>, int)>();
+		List<(List<string>, int)> filteredFlagsWithImmunity = [];
 
 		foreach (dynamic flags in activeFlags)
 		{
@@ -61,6 +55,7 @@ public class AdminSQLManager
 
 		return filteredFlagsWithImmunity;
 	}
+	*/
 
 	public async Task<List<(string, List<string>, int, DateTime?)>> GetAllPlayersFlags()
 	{
@@ -70,61 +65,74 @@ public class AdminSQLManager
 		{
 			await using MySqlConnection connection = await _database.GetConnectionAsync();
 
-			string sql = "SELECT player_steamid, flags, immunity, ends FROM sa_admins WHERE (ends IS NULL OR ends > @CurrentTime) AND (server_id IS NULL OR server_id = @serverid)";
+			string sql = @"
+            SELECT sa_admins.player_steamid, sa_admins_flags.flag, sa_admins.immunity, sa_admins.ends
+            FROM sa_admins_flags
+            JOIN sa_admins ON sa_admins_flags.admin_id = sa_admins.id
+            WHERE (sa_admins.ends IS NULL OR sa_admins.ends > @CurrentTime)
+            AND (sa_admins.server_id IS NULL OR sa_admins.server_id = @serverid)
+            ORDER BY sa_admins.player_steamid";
+
 			List<dynamic>? activeFlags = (await connection.QueryAsync(sql, new { CurrentTime = now, serverid = CS2_SimpleAdmin.ServerId }))?.ToList();
 
 			if (activeFlags == null)
 			{
-				return new List<(string, List<string>, int, DateTime?)>();
+				return [];
 			}
 
-			List<(string, List<string>, int, DateTime?)> filteredFlagsWithImmunity = new List<(string, List<string>, int, DateTime?)>();
+			List<(string, List<string>, int, DateTime?)> filteredFlagsWithImmunity = [];
+			string currentSteamId = string.Empty;
+			List<string> currentFlags = [];
+			int immunityValue = 0;
+			DateTime? ends = null;
 
-			foreach (dynamic flags in activeFlags)
+			foreach (dynamic flagInfo in activeFlags)
 			{
-				if (flags is not IDictionary<string, object> flagsDict)
+				if (flagInfo is not IDictionary<string, object> flagInfoDict)
 				{
 					continue;
 				}
 
-				if (!flagsDict.TryGetValue("player_steamid", out var steamIdObj) ||
-					!flagsDict.TryGetValue("flags", out var flagsValueObj) ||
-					!flagsDict.TryGetValue("immunity", out var immunityValueObj) ||
-					!flagsDict.TryGetValue("ends", out var endsObj))
+				if (!flagInfoDict.TryGetValue("player_steamid", out var steamIdObj) ||
+					!flagInfoDict.TryGetValue("flag", out var flagObj) ||
+					!flagInfoDict.TryGetValue("immunity", out var immunityValueObj) ||
+					!flagInfoDict.TryGetValue("ends", out var endsObj))
 				{
-					//Console.WriteLine("One or more required keys are missing.");
 					continue;
 				}
 
-				DateTime? ends = null;
-
-				if (endsObj != null) // Check if "ends" is not null
+				if (steamIdObj is not string steamId ||
+					flagObj is not string flag ||
+					!int.TryParse(immunityValueObj.ToString(), out immunityValue))
 				{
-					if (!DateTime.TryParse(endsObj.ToString(), out var parsedEnds))
-					{
-						//Console.WriteLine("Failed to parse 'ends' value.");
-						continue;
-					}
+					continue;
+				}
 
+				if (endsObj != null && DateTime.TryParse(endsObj.ToString(), out var parsedEnds))
+				{
 					ends = parsedEnds;
 				}
 
-				if (!(steamIdObj is string steamId) ||
-					!(flagsValueObj is string flagsValue) ||
-					!int.TryParse(immunityValueObj.ToString(), out var immunityValue))
+				if (currentSteamId != steamId && !string.IsNullOrEmpty(currentSteamId))
 				{
-					//Console.WriteLine("Failed to parse one or more values.");
-					continue;
+					filteredFlagsWithImmunity.Add((currentSteamId, currentFlags, immunityValue, ends));
+					currentFlags = [];
 				}
 
-				filteredFlagsWithImmunity.Add((steamId, flagsValue.Split(',').ToList(), immunityValue, ends));
+				currentSteamId = steamId;
+				currentFlags.Add(flag);
+			}
+
+			if (!string.IsNullOrEmpty(currentSteamId))
+			{
+				filteredFlagsWithImmunity.Add((currentSteamId, currentFlags, immunityValue, ends));
 			}
 
 			return filteredFlagsWithImmunity;
 		}
 		catch (Exception)
 		{
-			return new List<(string, List<string>, int, DateTime?)>();
+			return [];
 		}
 	}
 
@@ -161,52 +169,73 @@ public class AdminSQLManager
 
 		//_adminCache.TryRemove(playerSteamId, out _);
 
-		await using MySqlConnection connection = await _database.GetConnectionAsync();
-
-		string sql = "";
-
-		if (globalDelete)
+		try
 		{
-			sql = "DELETE FROM sa_admins WHERE player_steamid = @PlayerSteamID";
-		}
-		else
-		{
-			sql = "DELETE FROM sa_admins WHERE player_steamid = @PlayerSteamID AND server_id = @ServerId";
-		}
+			await using MySqlConnection connection = await _database.GetConnectionAsync();
+			string sql = "";
 
-		await connection.ExecuteAsync(sql, new { PlayerSteamID = playerSteamId, ServerId = CS2_SimpleAdmin.ServerId });
+			if (globalDelete)
+			{
+				sql = "DELETE FROM sa_admins WHERE player_steamid = @PlayerSteamID";
+			}
+			else
+			{
+				sql = "DELETE FROM sa_admins WHERE player_steamid = @PlayerSteamID AND server_id = @ServerId";
+			}
+
+			await connection.ExecuteAsync(sql, new { PlayerSteamID = playerSteamId, CS2_SimpleAdmin.ServerId });
+		}
+		catch { };
 	}
 
-	public async Task AddAdminBySteamId(string playerSteamId, string playerName, string flags, int immunity = 0, int time = 0, bool globalAdmin = false)
+	public async Task AddAdminBySteamId(string playerSteamId, string playerName, List<string> flagsList, int immunity = 0, int time = 0, bool globalAdmin = false)
 	{
-		if (string.IsNullOrEmpty(playerSteamId)) return;
-
-		flags = flags.Replace(" ", "");
+		if (string.IsNullOrEmpty(playerSteamId) || flagsList == null || flagsList.Count == 0) return;
 
 		DateTime now = DateTime.UtcNow.ToLocalTime();
 		DateTime? futureTime;
+
 		if (time != 0)
 			futureTime = now.ToLocalTime().AddMinutes(time);
 		else
 			futureTime = null;
 
-		await using MySqlConnection connection = await _database.GetConnectionAsync();
-
-		var sql = "INSERT INTO `sa_admins` (`player_steamid`, `player_name`, `flags`, `immunity`, `ends`, `created`, `server_id`) " +
-			"VALUES (@playerSteamid, @playerName, @flags, @immunity, @ends, @created, @serverid)";
-
-		int? serverId = globalAdmin ? null : CS2_SimpleAdmin.ServerId;
-
-		await connection.ExecuteAsync(sql, new
+		try
 		{
-			playerSteamId,
-			playerName,
-			flags,
-			immunity,
-			ends = futureTime,
-			created = now,
-			serverid = serverId
-		});
+			await using MySqlConnection connection = await _database.GetConnectionAsync();
+
+			// Insert admin into sa_admins table
+			var insertAdminSql = "INSERT INTO `sa_admins` (`player_steamid`, `player_name`, `immunity`, `ends`, `created`, `server_id`) " +
+								 "VALUES (@playerSteamid, @playerName, @immunity, @ends, @created, @serverid); SELECT LAST_INSERT_ID();";
+
+			int adminId = await connection.ExecuteScalarAsync<int>(insertAdminSql, new
+			{
+				playerSteamId,
+				playerName,
+				immunity,
+				ends = futureTime,
+				created = now,
+				serverid = globalAdmin ? null : CS2_SimpleAdmin.ServerId
+			});
+
+			// Insert flags into sa_admins_flags table
+			foreach (var flag in flagsList)
+			{
+				Console.WriteLine(flag);
+				var insertFlagsSql = "INSERT INTO `sa_admins_flags` (`admin_id`, `flag`) " +
+									 "VALUES (@adminId, @flag)";
+
+				await connection.ExecuteAsync(insertFlagsSql, new
+				{
+					adminId,
+					flag
+				});
+			}
+		}
+		catch (Exception ex)
+		{
+			Console.WriteLine(ex.ToString());
+		}
 	}
 
 	public async Task DeleteOldAdmins()
@@ -220,8 +249,7 @@ public class AdminSQLManager
 		}
 		catch (Exception)
 		{
-			if (CS2_SimpleAdmin._logger != null)
-				CS2_SimpleAdmin._logger.LogCritical("Unable to remove expired admins");
+			CS2_SimpleAdmin._logger?.LogCritical("Unable to remove expired admins");
 		}
 	}
 }

Managers/BanManager.cs

@@ -173,7 +173,7 @@ internal class BanManager(Database database, CS2_SimpleAdminConfig config)
 		return 0;
 	}
 
-	public async Task UnbanPlayer(string playerPattern)
+	public async Task UnbanPlayer(string playerPattern, string adminSteamId, string reason)
 	{
 		if (playerPattern == null || playerPattern.Length <= 1)
 		{
@@ -183,8 +183,43 @@ internal class BanManager(Database database, CS2_SimpleAdminConfig config)
 		{
 			await using MySqlConnection connection = await _database.GetConnectionAsync();
 
+			string sqlRetrieveBans = "SELECT id FROM sa_bans WHERE (player_steamid = @pattern OR player_name = @pattern OR player_ip = @pattern) AND status = 'ACTIVE'";
+			var bans = await connection.QueryAsync(sqlRetrieveBans, new { pattern = playerPattern });
+
+			if (!bans.Any())
+				return;
+
+			string sqlAdmin = "SELECT id FROM sa_admins WHERE player_steamid = @adminSteamId";
+			string sqlInsertUnban = "INSERT INTO sa_unbans (ban_id, admin_id, reason) VALUES (@banId, @adminId, @reason); SELECT LAST_INSERT_ID();";
+
+			int? sqlAdminId = await connection.ExecuteScalarAsync<int?>(sqlAdmin, new { adminSteamId });
+			int adminId = sqlAdminId ?? 0;
+
+			foreach (var ban in bans)
+			{
+				int banId = ban.id;
+				int? unbanId;
+
+				// Insert into sa_unbans
+				if (reason != null)
+				{
+					unbanId = await connection.ExecuteScalarAsync<int>(sqlInsertUnban, new { banId, adminId, reason });
+				}
+				else
+				{
+					sqlInsertUnban = "INSERT INTO sa_unbans (ban_id, admin_id) VALUES (@banId, @adminId); SELECT LAST_INSERT_ID();";
+					unbanId = await connection.ExecuteScalarAsync<int>(sqlInsertUnban, new { banId, adminId });
+				}
+
+				// Update sa_bans to set unban_id
+				string sqlUpdateBan = "UPDATE sa_bans SET status = 'UNBANNED', unban_id = @unbanId WHERE id = @banId";
+				await connection.ExecuteAsync(sqlUpdateBan, new { unbanId, banId });
+			}
+
+			/*
 			string sqlUnban = "UPDATE sa_bans SET status = 'UNBANNED' WHERE player_steamid = @pattern OR player_name = @pattern OR player_ip = @pattern AND status = 'ACTIVE'";
 			await connection.ExecuteAsync(sqlUnban, new { pattern = playerPattern });
+			*/
 
 		}
 		catch { }

Managers/MuteManager.cs

@@ -4,20 +4,14 @@ using MySqlConnector;
 
 namespace CS2_SimpleAdmin;
 
-internal class MuteManager
+internal class MuteManager(Database database)
 {
-	private readonly Database _database;
-
-	public MuteManager(Database database)
-	{
-		_database = database;
-	}
+	private readonly Database _database = database;
 
 	public async Task MutePlayer(PlayerInfo player, PlayerInfo issuer, string reason, int time = 0, int type = 0)
 	{
 		if (player == null || player.SteamId == null) return;
 
-		await using MySqlConnection connection = await _database.GetConnectionAsync();
 
 		DateTime now = DateTime.UtcNow.ToLocalTime();
 		DateTime futureTime = now.AddMinutes(time).ToLocalTime();
@@ -28,29 +22,33 @@ internal class MuteManager
 		else if (type == 2)
 			muteType = "SILENCE";
 
-		var sql = "INSERT INTO `sa_mutes` (`player_steamid`, `player_name`, `admin_steamid`, `admin_name`, `reason`, `duration`, `ends`, `created`, `type`, `server_id`) " +
-			"VALUES (@playerSteamid, @playerName, @adminSteamid, @adminName, @banReason, @duration, @ends, @created, @type, @serverid)";
-
-		await connection.ExecuteAsync(sql, new
+		try
 		{
-			playerSteamid = player.SteamId,
-			playerName = player.Name,
-			adminSteamid = issuer.SteamId == null ? "Console" : issuer.SteamId,
-			adminName = issuer.SteamId == null ? "Console" : issuer.Name,
-			banReason = reason,
-			duration = time,
-			ends = futureTime,
-			created = now,
-			type = muteType,
-			serverid = CS2_SimpleAdmin.ServerId
-		});
+			await using MySqlConnection connection = await _database.GetConnectionAsync();
+			var sql = "INSERT INTO `sa_mutes` (`player_steamid`, `player_name`, `admin_steamid`, `admin_name`, `reason`, `duration`, `ends`, `created`, `type`, `server_id`) " +
+				"VALUES (@playerSteamid, @playerName, @adminSteamid, @adminName, @muteReason, @duration, @ends, @created, @type, @serverid)";
+
+			await connection.ExecuteAsync(sql, new
+			{
+				playerSteamid = player.SteamId,
+				playerName = player.Name,
+				adminSteamid = issuer.SteamId ?? "Console",
+				adminName = issuer.SteamId == null ? "Console" : issuer.Name,
+				muteReason = reason,
+				duration = time,
+				ends = futureTime,
+				created = now,
+				type = muteType,
+				serverid = CS2_SimpleAdmin.ServerId
+			});
+		}
+		catch { };
 	}
 
 	public async Task AddMuteBySteamid(string playerSteamId, PlayerInfo issuer, string reason, int time = 0, int type = 0)
 	{
 		if (string.IsNullOrEmpty(playerSteamId)) return;
 
-		await using MySqlConnection connection = await _database.GetConnectionAsync();
 
 		DateTime now = DateTime.UtcNow.ToLocalTime();
 		DateTime futureTime = now.AddMinutes(time).ToLocalTime();
@@ -61,28 +59,33 @@ internal class MuteManager
 		else if (type == 2)
 			muteType = "SILENCE";
 
-		var sql = "INSERT INTO `sa_mutes` (`player_steamid`, `admin_steamid`, `admin_name`, `reason`, `duration`, `ends`, `created`, `type`, `server_id`) " +
-			"VALUES (@playerSteamid, @adminSteamid, @adminName, @banReason, @duration, @ends, @created, @type, @serverid)";
-
-		await connection.ExecuteAsync(sql, new
+		try
 		{
-			playerSteamid = playerSteamId,
-			adminSteamid = issuer.SteamId == null ? "Console" : issuer.SteamId,
-			adminName = issuer.Name == null ? "Console" : issuer.Name,
-			banReason = reason,
-			duration = time,
-			ends = futureTime,
-			created = now,
-			type = muteType,
-			serverid = CS2_SimpleAdmin.ServerId
-		});
+			await using MySqlConnection connection = await _database.GetConnectionAsync();
+			var sql = "INSERT INTO `sa_mutes` (`player_steamid`, `admin_steamid`, `admin_name`, `reason`, `duration`, `ends`, `created`, `type`, `server_id`) " +
+				"VALUES (@playerSteamid, @adminSteamid, @adminName, @muteReason, @duration, @ends, @created, @type, @serverid)";
+
+			await connection.ExecuteAsync(sql, new
+			{
+				playerSteamid = playerSteamId,
+				adminSteamid = issuer.SteamId ?? "Console",
+				adminName = issuer.Name ?? "Console",
+				muteReason = reason,
+				duration = time,
+				ends = futureTime,
+				created = now,
+				type = muteType,
+				serverid = CS2_SimpleAdmin.ServerId
+			});
+		}
+		catch { };
 	}
 
 	public async Task<List<dynamic>> IsPlayerMuted(string steamId)
 	{
 		if (string.IsNullOrEmpty(steamId))
 		{
-			return new List<dynamic>();
+			return [];
 		}
 
 #if DEBUG
@@ -102,49 +105,84 @@ internal class MuteManager
 		}
 		catch (Exception)
 		{
-			return new List<dynamic>();
+			return [];
 		}
 	}
 
 	public async Task<int> GetPlayerMutes(string steamId)
 	{
-		await using MySqlConnection connection = await _database.GetConnectionAsync();
+		try
+		{
+			await using MySqlConnection connection = await _database.GetConnectionAsync();
 
-		int muteCount;
-		string sql = "SELECT COUNT(*) FROM sa_mutes WHERE player_steamid = @PlayerSteamID";
+			int muteCount;
+			string sql = "SELECT COUNT(*) FROM sa_mutes WHERE player_steamid = @PlayerSteamID";
 
-		muteCount = await connection.ExecuteScalarAsync<int>(sql, new { PlayerSteamID = steamId });
-
-		return muteCount;
+			muteCount = await connection.ExecuteScalarAsync<int>(sql, new { PlayerSteamID = steamId });
+			return muteCount;
+		}
+		catch (Exception)
+		{
+			return 0;
+		}
 	}
 
-	public async Task UnmutePlayer(string playerPattern, int type = 0)
+	public async Task UnmutePlayer(string playerPattern, string adminSteamId, string reason, int type = 0)
 	{
 		if (playerPattern == null || playerPattern.Length <= 1)
 		{
 			return;
 		}
 
-		await using MySqlConnection connection = await _database.GetConnectionAsync();
-
-		if (type == 2)
+		try
 		{
-			string _unbanSql = "UPDATE sa_mutes SET status = 'UNMUTED' WHERE (player_steamid = @pattern OR player_name = @pattern) AND status = 'ACTIVE'";
-			await connection.ExecuteAsync(_unbanSql, new { pattern = playerPattern });
+			await using MySqlConnection connection = await _database.GetConnectionAsync();
 
-			return;
+			string muteType = "GAG";
+			if (type == 1)
+			{
+				muteType = "MUTE";
+			}
+			else if (type == 2)
+				muteType = "SILENCE";
+
+			string sqlRetrieveMutes = "SELECT id FROM sa_mutes WHERE (player_steamid = @pattern OR player_name = @pattern) AND type = @muteType AND status = 'ACTIVE'";
+			var mutes = await connection.QueryAsync(sqlRetrieveMutes, new { pattern = playerPattern, muteType });
+
+			if (!mutes.Any())
+				return;
+
+			string sqlAdmin = "SELECT id FROM sa_admins WHERE player_steamid = @adminSteamId";
+			string sqlInsertUnmute = "INSERT INTO sa_unmutes (mute_id, admin_id, reason) VALUES (@muteId, @adminId, @reason); SELECT LAST_INSERT_ID();";
+
+			int? sqlAdminId = await connection.ExecuteScalarAsync<int?>(sqlAdmin, new { adminSteamId });
+			int adminId = sqlAdminId ?? 0;
+
+			foreach (var mute in mutes)
+			{
+				int muteId = mute.id;
+				int? unmuteId;
+
+				// Insert into sa_unmutes
+				if (reason != null)
+				{
+					unmuteId = await connection.ExecuteScalarAsync<int>(sqlInsertUnmute, new { muteId, adminId, reason });
+				}
+				else
+				{
+					sqlInsertUnmute = "INSERT INTO sa_unmutes (muteId, admin_id) VALUES (@muteId, @adminId); SELECT LAST_INSERT_ID();";
+					unmuteId = await connection.ExecuteScalarAsync<int>(sqlInsertUnmute, new { muteId, adminId });
+				}
+
+				// Update sa_mutes to set unmute_id
+				string sqlUpdateMute = "UPDATE sa_mutes SET status = 'UNMUTED', unmute_id = @unmuteId WHERE id = @muteId";
+				await connection.ExecuteAsync(sqlUpdateMute, new { unmuteId, muteId });
+			}
 		}
-
-		string muteType = "GAG";
-		if (type == 1)
+		catch (Exception ex)
 		{
-			muteType = "MUTE";
+			Console.WriteLine(ex);
 		}
-		else if (type == 2)
-			muteType = "SILENCE";
-
-		string sqlUnban = "UPDATE sa_mutes SET status = 'UNMUTED' WHERE (player_steamid = @pattern OR player_name = @pattern) AND type = @muteType AND status = 'ACTIVE'";
-		await connection.ExecuteAsync(sqlUnban, new { pattern = playerPattern, muteType });
 	}
 
 	public async Task ExpireOldMutes()
@@ -158,8 +196,7 @@ internal class MuteManager
 		}
 		catch (Exception)
 		{
-			if (CS2_SimpleAdmin._logger != null)
-				CS2_SimpleAdmin._logger.LogCritical("Unable to remove expired mutes");
+			CS2_SimpleAdmin._logger?.LogCritical("Unable to remove expired mutes");
 		}
 	}
 }

Managers/PlayerPenaltyManager.cs

@@ -15,13 +15,15 @@ public class PlayerPenaltyManager
 		new ConcurrentDictionary<int, Dictionary<PenaltyType, List<(DateTime, int)>>>();
 
 	// Add a penalty for a player
-	public void AddPenalty(int slot, PenaltyType penaltyType, DateTime endDateTime, int durationSeconds)
+	public static void AddPenalty(int slot, PenaltyType penaltyType, DateTime endDateTime, int durationSeconds)
 	{
 		penalties.AddOrUpdate(slot,
 			(_) =>
 			{
-				var dict = new Dictionary<PenaltyType, List<(DateTime, int)>>();
-				dict[penaltyType] = new List<(DateTime, int)>() { (endDateTime, durationSeconds) };
+				var dict = new Dictionary<PenaltyType, List<(DateTime, int)>>
+				{
+					[penaltyType] = [(endDateTime, durationSeconds)]
+				};
 				return dict;
 			},
 			(_, existingDict) =>
@@ -35,7 +37,7 @@ public class PlayerPenaltyManager
 			});
 	}
 
-	public bool IsPenalized(int slot, PenaltyType penaltyType)
+	public static bool IsPenalized(int slot, PenaltyType penaltyType)
 	{
 		//Console.WriteLine($"Checking penalties for player with slot {slot} and penalty type {penaltyType}");
 
@@ -78,23 +80,23 @@ public class PlayerPenaltyManager
 	}
 
 	// Get the end datetime and duration of penalties for a player and penalty type
-	public List<(DateTime EndDateTime, int Duration)> GetPlayerPenalties(int slot, PenaltyType penaltyType)
+	public static List<(DateTime EndDateTime, int Duration)> GetPlayerPenalties(int slot, PenaltyType penaltyType)
 	{
 		if (penalties.TryGetValue(slot, out Dictionary<PenaltyType, List<(DateTime EndDateTime, int Duration)>>? penaltyDict) &&
 			penaltyDict.TryGetValue(penaltyType, out List<(DateTime EndDateTime, int Duration)>? penaltiesList) && penaltiesList != null)
 		{
 			return penaltiesList;
 		}
-		return new List<(DateTime EndDateTime, int Duration)>();
+		return [];
 	}
 
-	public bool IsSlotInPenalties(int slot)
+	public static bool IsSlotInPenalties(int slot)
 	{
 		return penalties.ContainsKey(slot);
 	}
 
 	// Remove all penalties for a player slot
-	public void RemoveAllPenalties(int slot)
+	public static void RemoveAllPenalties(int slot)
 	{
 		if (penalties.ContainsKey(slot))
 		{
@@ -103,13 +105,13 @@ public class PlayerPenaltyManager
 	}
 
 	// Remove all penalties
-	public void RemoveAllPenalties()
+	public static void RemoveAllPenalties()
 	{
 		penalties.Clear();
 	}
 
 	// Remove all penalties of a selected type from a specific player
-	public void RemovePenaltiesByType(int slot, PenaltyType penaltyType)
+	public static void RemovePenaltiesByType(int slot, PenaltyType penaltyType)
 	{
 		if (penalties.TryGetValue(slot, out Dictionary<PenaltyType, List<(DateTime EndDateTime, int Duration)>>? penaltyDict) &&
 			penaltyDict.ContainsKey(penaltyType))
@@ -119,7 +121,7 @@ public class PlayerPenaltyManager
 	}
 
 	// Remove all expired penalties for all players and penalty types
-	public void RemoveExpiredPenalties()
+	public static void RemoveExpiredPenalties()
 	{
 		DateTime now = DateTime.UtcNow.ToLocalTime();
 		foreach (var kvp in penalties.ToList()) // Use ToList to avoid modification while iterating