Add Votekick functionality (#32005)

Content.Server/Voting/IVoteHandle.cs

@@ -1,4 +1,4 @@
-using Content.Server.Voting.Managers;
+using Content.Server.Voting.Managers;
 using Robust.Shared.Player;
 
 namespace Content.Server.Voting
@@ -43,6 +43,11 @@ namespace Content.Server.Voting
         /// </remarks>
         bool Cancelled { get; }
 
+        /// <summary>
+        /// Dictionary of votes cast by players, matching the option's id.
+        /// </summary>
+        IReadOnlyDictionary<ICommonSession, int> CastVotes { get; }
+
         /// <summary>
         /// Current count of votes per option type.
         /// </summary>

Content.Server/Voting/Managers/IVoteManager.cs

@@ -1,4 +1,4 @@
-using System.Diagnostics.CodeAnalysis;
+using System.Diagnostics.CodeAnalysis;
 using Content.Shared.Voting;
 using Robust.Shared.Player;
 
@@ -51,7 +51,7 @@ namespace Content.Server.Voting.Managers
         /// If null it is assumed to be an automatic vote by the server.
         /// </param>
         /// <param name="voteType">The type of standard vote to make.</param>
-        void CreateStandardVote(ICommonSession? initiator, StandardVoteType voteType);
+        void CreateStandardVote(ICommonSession? initiator, StandardVoteType voteType, string[]? args = null);
 
         /// <summary>
         /// Create a non-standard vote with special parameters.

Content.Server/Voting/Managers/VoteManager.DefaultVotes.cs

@@ -1,11 +1,18 @@
 using System.Linq;
+using Content.Server.Administration;
+using Content.Server.Administration.Managers;
+using Content.Server.Database;
 using Content.Server.GameTicking;
 using Content.Server.GameTicking.Presets;
 using Content.Server.Maps;
+using Content.Server.Roles;
 using Content.Server.RoundEnd;
 using Content.Shared.CCVar;
+using Content.Shared.Chat;
 using Content.Shared.Database;
 using Content.Shared.Ghost;
+using Content.Shared.Players;
+using Content.Shared.Players.PlayTimeTracking;
 using Content.Shared.Voting;
 using Robust.Shared.Configuration;
 using Robust.Shared.Enums;
@@ -16,20 +23,33 @@ namespace Content.Server.Voting.Managers
 {
     public sealed partial class VoteManager
     {
+        [Dependency] private readonly IPlayerLocator _locator = default!;
+        [Dependency] private readonly ILogManager _logManager = default!;
+        [Dependency] private readonly IBanManager _bans = default!;
+        [Dependency] private readonly IServerDbManager _dbManager = default!;
+
+        private VotingSystem? _votingSystem;
+        private RoleSystem? _roleSystem;
+
         private static readonly Dictionary<StandardVoteType, CVarDef<bool>> _voteTypesToEnableCVars = new()
         {
             {StandardVoteType.Restart, CCVars.VoteRestartEnabled},
             {StandardVoteType.Preset, CCVars.VotePresetEnabled},
             {StandardVoteType.Map, CCVars.VoteMapEnabled},
+            {StandardVoteType.Votekick, CCVars.VotekickEnabled}
         };
 
-        public void CreateStandardVote(ICommonSession? initiator, StandardVoteType voteType)
+        public void CreateStandardVote(ICommonSession? initiator, StandardVoteType voteType, string[]? args = null)
         {
-            if (initiator != null)
+            if (initiator != null && args == null)
                 _adminLogger.Add(LogType.Vote, LogImpact.Medium, $"{initiator} initiated a {voteType.ToString()} vote");
+            else if (initiator != null && args != null)
+                _adminLogger.Add(LogType.Vote, LogImpact.Extreme, $"{initiator} initiated a {voteType.ToString()} vote with the arguments: {String.Join(",", args)}");
             else
                 _adminLogger.Add(LogType.Vote, LogImpact.Medium, $"Initiated a {voteType.ToString()} vote");
 
+            bool timeoutVote = true;
+
             switch (voteType)
             {
                 case StandardVoteType.Restart:
@@ -41,12 +61,17 @@ namespace Content.Server.Voting.Managers
                 case StandardVoteType.Map:
                     CreateMapVote(initiator);
                     break;
+                case StandardVoteType.Votekick:
+                    timeoutVote = false; // Allows the timeout to be updated manually in the create method
+                    CreateVotekickVote(initiator, args);
+                    break;
                 default:
                     throw new ArgumentOutOfRangeException(nameof(voteType), voteType, null);
             }
             var ticker = _entityManager.EntitySysManager.GetEntitySystem<GameTicker>();
             ticker.UpdateInfoText();
-            TimeoutStandardVote(voteType);
+            if (timeoutVote)
+                TimeoutStandardVote(voteType);
         }
 
         private void CreateRestartVote(ICommonSession? initiator)
@@ -56,104 +81,127 @@ namespace Content.Server.Voting.Managers
             var totalPlayers = _playerManager.Sessions.Count(session => session.Status != SessionStatus.Disconnected);
 
             var ghostVotePercentageRequirement = _cfg.GetCVar(CCVars.VoteRestartGhostPercentage);
-            var ghostCount = 0;
-            
-            foreach (var player in _playerManager.Sessions)
-            {
-                _playerManager.UpdateState(player);
-                if (player.Status != SessionStatus.Disconnected && _entityManager.HasComponent<GhostComponent>(player.AttachedEntity))
-                {
-                    ghostCount++;
-                }
-            }
+            var ghostVoterPercentage = CalculateEligibleVoterPercentage(VoterEligibility.Ghost);
 
-            var ghostPercentage = 0.0;
-            if (totalPlayers > 0)
-            {
-                ghostPercentage = ((double)ghostCount / totalPlayers) * 100;
-            }
-
-            var roundedGhostPercentage = (int)Math.Round(ghostPercentage);
-
-            if (totalPlayers <= playerVoteMaximum || roundedGhostPercentage >= ghostVotePercentageRequirement)
+            if (totalPlayers <= playerVoteMaximum || ghostVoterPercentage >= ghostVotePercentageRequirement)
             {
                 StartVote(initiator);
             }
             else
             {
-                NotifyNotEnoughGhostPlayers(ghostVotePercentageRequirement, roundedGhostPercentage);
+                NotifyNotEnoughGhostPlayers(ghostVotePercentageRequirement, ghostVoterPercentage);
             }
         }
 
+        /// <summary>
+        /// Gives the current percentage of players eligible to vote, rounded to nearest percentage point.
+        /// </summary>
+        /// <param name="eligibility">The eligibility requirement to vote.</param>
+        public int CalculateEligibleVoterPercentage(VoterEligibility eligibility)
+        {
+            var eligibleCount = CalculateEligibleVoterNumber(eligibility);
+            var totalPlayers = _playerManager.Sessions.Count(session => session.Status != SessionStatus.Disconnected);
+
+            var eligiblePercentage = 0.0;
+            if (totalPlayers > 0)
+            {
+                eligiblePercentage = ((double)eligibleCount / totalPlayers) * 100;
+            }
+
+            var roundedEligiblePercentage = (int)Math.Round(eligiblePercentage);
+
+            return roundedEligiblePercentage;
+        }
+
+        /// <summary>
+        /// Gives the current number of players eligible to vote.
+        /// </summary>
+        /// <param name="eligibility">The eligibility requirement to vote.</param>
+        public int CalculateEligibleVoterNumber(VoterEligibility eligibility)
+        {
+            var eligibleCount = 0;
+
+            foreach (var player in _playerManager.Sessions)
+            {
+                _playerManager.UpdateState(player);
+                if (player.Status != SessionStatus.Disconnected && CheckVoterEligibility(player, eligibility))
+                {
+                    eligibleCount++;
+                }
+            }
+
+            return eligibleCount;
+        }
+
         private void StartVote(ICommonSession? initiator)
         {
             var alone = _playerManager.PlayerCount == 1 && initiator != null;
-                var options = new VoteOptions
+            var options = new VoteOptions
+            {
+                Title = Loc.GetString("ui-vote-restart-title"),
+                Options =
                 {
-                    Title = Loc.GetString("ui-vote-restart-title"),
-                    Options =
-                    {
-                        (Loc.GetString("ui-vote-restart-yes"), "yes"),
-                        (Loc.GetString("ui-vote-restart-no"), "no"),
-                        (Loc.GetString("ui-vote-restart-abstain"), "abstain")
-                    },
-                    Duration = alone
-                        ? TimeSpan.FromSeconds(_cfg.GetCVar(CCVars.VoteTimerAlone))
-                        : TimeSpan.FromSeconds(_cfg.GetCVar(CCVars.VoteTimerRestart)),
-                    InitiatorTimeout = TimeSpan.FromMinutes(5)
-                };
+                    (Loc.GetString("ui-vote-restart-yes"), "yes"),
+                    (Loc.GetString("ui-vote-restart-no"), "no"),
+                    (Loc.GetString("ui-vote-restart-abstain"), "abstain")
+                },
+                Duration = alone
+                    ? TimeSpan.FromSeconds(_cfg.GetCVar(CCVars.VoteTimerAlone))
+                    : TimeSpan.FromSeconds(_cfg.GetCVar(CCVars.VoteTimerRestart)),
+                InitiatorTimeout = TimeSpan.FromMinutes(5)
+            };
 
-                if (alone)
-                    options.InitiatorTimeout = TimeSpan.FromSeconds(10);
+            if (alone)
+                options.InitiatorTimeout = TimeSpan.FromSeconds(10);
 
-                WirePresetVoteInitiator(options, initiator);
+            WirePresetVoteInitiator(options, initiator);
 
-                var vote = CreateVote(options);
+            var vote = CreateVote(options);
 
-                vote.OnFinished += (_, _) =>
+            vote.OnFinished += (_, _) =>
+            {
+                var votesYes = vote.VotesPerOption["yes"];
+                var votesNo = vote.VotesPerOption["no"];
+                var total = votesYes + votesNo;
+
+                var ratioRequired = _cfg.GetCVar(CCVars.VoteRestartRequiredRatio);
+                if (total > 0 && votesYes / (float) total >= ratioRequired)
                 {
-                    var votesYes = vote.VotesPerOption["yes"];
-                    var votesNo = vote.VotesPerOption["no"];
-                    var total = votesYes + votesNo;
-
-                    var ratioRequired = _cfg.GetCVar(CCVars.VoteRestartRequiredRatio);
-                    if (total > 0 && votesYes / (float) total >= ratioRequired)
+                    // Check if an admin is online, and ignore the passed vote if the cvar is enabled
+                    if (_cfg.GetCVar(CCVars.VoteRestartNotAllowedWhenAdminOnline) && _adminMgr.ActiveAdmins.Count() != 0)
                     {
-                        // Check if an admin is online, and ignore the passed vote if the cvar is enabled
-                        if (_cfg.GetCVar(CCVars.VoteRestartNotAllowedWhenAdminOnline) && _adminMgr.ActiveAdmins.Count() != 0)
-                        {
-                            _adminLogger.Add(LogType.Vote, LogImpact.Medium, $"Restart vote attempted to pass, but an admin was online. {votesYes}/{votesNo}");
-                        }
-                        else // If the cvar is disabled or there's no admins on, proceed as normal
-                        {
-                            _adminLogger.Add(LogType.Vote, LogImpact.Medium, $"Restart vote succeeded: {votesYes}/{votesNo}");
-                            _chatManager.DispatchServerAnnouncement(Loc.GetString("ui-vote-restart-succeeded"));
-                            var roundEnd = _entityManager.EntitySysManager.GetEntitySystem<RoundEndSystem>();
-                            roundEnd.EndRound();
-                        }
+                        _adminLogger.Add(LogType.Vote, LogImpact.Medium, $"Restart vote attempted to pass, but an admin was online. {votesYes}/{votesNo}");
                     }
-                    else
+                    else // If the cvar is disabled or there's no admins on, proceed as normal
                     {
-                        _adminLogger.Add(LogType.Vote, LogImpact.Medium, $"Restart vote failed: {votesYes}/{votesNo}");
-                        _chatManager.DispatchServerAnnouncement(
-                            Loc.GetString("ui-vote-restart-failed", ("ratio", ratioRequired)));
-                    }
-                };
-
-                if (initiator != null)
-                {
-                    // Cast yes vote if created the vote yourself.
-                    vote.CastVote(initiator, 0);
-                }
-
-                foreach (var player in _playerManager.Sessions)
-                {
-                    if (player != initiator)
-                    {
-                        // Everybody else defaults to an abstain vote to say they don't mind.
-                        vote.CastVote(player, 2);
+                        _adminLogger.Add(LogType.Vote, LogImpact.Medium, $"Restart vote succeeded: {votesYes}/{votesNo}");
+                        _chatManager.DispatchServerAnnouncement(Loc.GetString("ui-vote-restart-succeeded"));
+                        var roundEnd = _entityManager.EntitySysManager.GetEntitySystem<RoundEndSystem>();
+                        roundEnd.EndRound();
                     }
                 }
+                else
+                {
+                    _adminLogger.Add(LogType.Vote, LogImpact.Medium, $"Restart vote failed: {votesYes}/{votesNo}");
+                    _chatManager.DispatchServerAnnouncement(
+                        Loc.GetString("ui-vote-restart-failed", ("ratio", ratioRequired)));
+                }
+            };
+
+            if (initiator != null)
+            {
+                // Cast yes vote if created the vote yourself.
+                vote.CastVote(initiator, 0);
+            }
+
+            foreach (var player in _playerManager.Sessions)
+            {
+                if (player != initiator)
+                {
+                    // Everybody else defaults to an abstain vote to say they don't mind.
+                    vote.CastVote(player, 2);
+                }
+            }
         }
 
         private void NotifyNotEnoughGhostPlayers(int ghostPercentageRequirement, int roundedGhostPercentage)
@@ -275,6 +323,230 @@ namespace Content.Server.Voting.Managers
             };
         }
 
+        private async void CreateVotekickVote(ICommonSession? initiator, string[]? args)
+        {
+            if (args == null || args.Length <= 1)
+            {
+                return;
+            }
+
+            if (_roleSystem == null)
+                _roleSystem = _entityManager.SystemOrNull<RoleSystem>();
+            if (_votingSystem == null)
+                _votingSystem = _entityManager.SystemOrNull<VotingSystem>();
+
+            // Check that the initiator is actually allowed to do a votekick.
+            if (_votingSystem != null && !await _votingSystem.CheckVotekickInitEligibility(initiator))
+            {
+                _logManager.GetSawmill("admin.votekick").Warning($"User {initiator} attempted a votekick, despite not being eligible to!");
+                _adminLogger.Add(LogType.Vote, LogImpact.Extreme, $"Votekick attempted by {initiator}, but they are not eligible to votekick!");
+                DirtyCanCallVoteAll();
+                return;
+            }
+
+            var eligibleVoterNumberRequirement = _cfg.GetCVar(CCVars.VotekickEligibleNumberRequirement);
+            var eligibleVoterNumber = _cfg.GetCVar(CCVars.VotekickVoterGhostRequirement) ? CalculateEligibleVoterNumber(VoterEligibility.GhostMinimumPlaytime) : CalculateEligibleVoterNumber(VoterEligibility.MinimumPlaytime);
+
+            string target = args[0];
+            string reason = args[1];
+
+            // Start by getting all relevant target data
+            var located = await _locator.LookupIdByNameOrIdAsync(target);
+            if (located == null)
+            {
+                _logManager.GetSawmill("admin.votekick")
+                    .Warning($"Votekick attempted for player {target} but they couldn't be found!");
+                _adminLogger.Add(LogType.Vote, LogImpact.Extreme, $"Votekick attempted by {initiator} for player string {target}, but they could not be found!");
+                DirtyCanCallVoteAll();
+                return;
+            }
+            var targetUid = located.UserId;
+            var targetHWid = located.LastHWId;
+            if (!_playerManager.TryGetSessionById(located.UserId, out ICommonSession? targetSession))
+            {
+                _logManager.GetSawmill("admin.votekick")
+                    .Warning($"Votekick attempted for player {target} but their session couldn't be found!");
+                _adminLogger.Add(LogType.Vote, LogImpact.Extreme, $"Votekick attempted by {initiator} for player string {target}, but they could not be found!");
+                DirtyCanCallVoteAll();
+                return;
+            }
+
+            string targetEntityName = located.Username; // Target's player-facing name when voting; uses the player's username as fallback if no entity name is found
+            if (targetSession.AttachedEntity is { Valid: true } attached && _votingSystem != null)
+                targetEntityName = _votingSystem.GetPlayerVoteListName(attached);
+
+            var isAntagSafe = false;
+            var targetMind = targetSession.GetMind();
+            var playtime = _playtimeManager.GetPlayTimes(targetSession);
+
+            // Check whether the target is an antag, and if they are, give them protection against the Raider votekick if they have the requisite hours.
+            if (targetMind != null &&
+                _roleSystem != null &&
+                _roleSystem.MindIsAntagonist(targetMind) &&
+                playtime.TryGetValue(PlayTimeTrackingShared.TrackerOverall, out TimeSpan overallTime) &&
+                overallTime >= TimeSpan.FromHours(_cfg.GetCVar(CCVars.VotekickAntagRaiderProtection)))
+            {
+                isAntagSafe = true;
+            }
+
+
+            // Don't let a user votekick themselves
+            if (initiator == targetSession)
+            {
+                _adminLogger.Add(LogType.Vote, LogImpact.Extreme, $"Votekick attempted by {initiator} for themselves? Votekick cancelled.");
+                DirtyCanCallVoteAll();
+                return;
+            }
+
+            // Cancels the vote if there's not enough voters; only the person initiating the vote gets a return message.
+            if (eligibleVoterNumber < eligibleVoterNumberRequirement)
+            {
+                _adminLogger.Add(LogType.Vote, LogImpact.Extreme, $"Votekick attempted by {initiator} for player {targetSession}, but there were not enough ghost roles! {eligibleVoterNumberRequirement} required, {eligibleVoterNumber} found.");
+                if (initiator != null)
+                {
+                    var message = Loc.GetString("ui-vote-votekick-not-enough-eligible", ("voters", eligibleVoterNumber.ToString()), ("requirement", eligibleVoterNumberRequirement.ToString()));
+                    var wrappedMessage = Loc.GetString("chat-manager-server-wrap-message", ("message", message));
+                    _chatManager.ChatMessageToOne(ChatChannel.Server, message, wrappedMessage, default, false, initiator.Channel);
+                }
+                DirtyCanCallVoteAll();
+                return;
+            }
+
+            // Check for stuff like the target being an admin. These targets shouldn't show up in the UI, but it's necessary to doublecheck in case someone writes the command in console.
+            if (_votingSystem != null && !_votingSystem.CheckVotekickTargetEligibility(targetSession))
+            {
+                _adminLogger.Add(LogType.Vote, LogImpact.Extreme, $"Votekick attempted by {initiator} for player {targetSession}, but they are not eligible to be votekicked!");
+                DirtyCanCallVoteAll();
+                return;
+            }
+
+            // Create the vote object
+
+            string voteTitle = "";
+            NetEntity? targetNetEntity = _entityManager.GetNetEntity(targetSession.AttachedEntity);
+            var initiatorName = initiator != null ? initiator.Name : Loc.GetString("ui-vote-votekick-unknown-initiator");
+
+            voteTitle = Loc.GetString("ui-vote-votekick-title", ("initiator", initiatorName), ("targetEntity", targetEntityName), ("reason", reason));
+
+            var options = new VoteOptions
+            {
+                Title = voteTitle,
+                Options =
+                {
+                    (Loc.GetString("ui-vote-votekick-yes"), "yes"),
+                    (Loc.GetString("ui-vote-votekick-no"), "no"),
+                    (Loc.GetString("ui-vote-votekick-abstain"), "abstain")
+                },
+                Duration = TimeSpan.FromSeconds(_cfg.GetCVar(CCVars.VotekickTimer)),
+                InitiatorTimeout = TimeSpan.FromMinutes(_cfg.GetCVar(CCVars.VotekickTimeout)),
+                VoterEligibility = _cfg.GetCVar(CCVars.VotekickVoterGhostRequirement) ? VoterEligibility.GhostMinimumPlaytime : VoterEligibility.MinimumPlaytime,
+                DisplayVotes = false,
+                TargetEntity = targetNetEntity
+            };
+
+            WirePresetVoteInitiator(options, initiator);
+
+            var vote = CreateVote(options);
+            _adminLogger.Add(LogType.Vote, LogImpact.Extreme, $"Votekick for {located.Username} ({targetEntityName}) due to {reason} started, initiated by {initiator}.");
+
+            // Time out the vote now that we know it will happen
+            TimeoutStandardVote(StandardVoteType.Votekick);
+
+            vote.OnFinished += (_, _) =>
+            {
+
+                var votesYes = vote.VotesPerOption["yes"];
+                var votesNo = vote.VotesPerOption["no"];
+                var total = votesYes + votesNo;
+
+                // Get the voters, for logging purposes.
+                List<ICommonSession> yesVoters = new();
+                List<ICommonSession> noVoters = new();
+                foreach (var (voter, castVote) in vote.CastVotes)
+                {
+                    if (castVote == 0)
+                    {
+                        yesVoters.Add(voter);
+                    }
+                    if (castVote == 1)
+                    {
+                        noVoters.Add(voter);
+                    }
+                }
+                var yesVotersString = string.Join(", ", yesVoters);
+                var noVotersString = string.Join(", ", noVoters);
+
+                var ratioRequired = _cfg.GetCVar(CCVars.VotekickRequiredRatio);
+                if (total > 0 && votesYes / (float)total >= ratioRequired)
+                {
+                    // Some conditions that cancel the vote want to let the vote run its course first and then cancel it
+                    // so we check for that here
+
+                    // Check if an admin is online, and ignore the vote if the cvar is enabled
+                    if (_cfg.GetCVar(CCVars.VotekickNotAllowedWhenAdminOnline) && _adminMgr.ActiveAdmins.Count() != 0)
+                    {
+                        _adminLogger.Add(LogType.Vote, LogImpact.Extreme, $"Votekick for {located.Username} attempted to pass, but an admin was online. Yes: {votesYes} / No: {votesNo}. Yes: {yesVotersString} / No: {noVotersString}");
+                        AnnounceCancelledVotekickForVoters(targetEntityName);
+                        return;
+                    }
+                    // Check if the target is an antag and the vote reason is raiding (this is to prevent false positives)
+                    else if (isAntagSafe && reason == VotekickReasonType.Raiding.ToString())
+                    {
+                        _adminLogger.Add(LogType.Vote, LogImpact.Extreme, $"Votekick for {located.Username} due to {reason} finished, created by {initiator}, but was cancelled due to the target being an antagonist.");
+                        AnnounceCancelledVotekickForVoters(targetEntityName);
+                        return;
+                    }
+                    // Check if the target is an admin/de-admined admin
+                    else if (targetSession.AttachedEntity != null && _adminMgr.IsAdmin(targetSession.AttachedEntity.Value, true))
+                    {
+                        _adminLogger.Add(LogType.Vote, LogImpact.Extreme, $"Votekick for {located.Username} due to {reason} finished, created by {initiator}, but was cancelled due to the target being a de-admined admin.");
+                        AnnounceCancelledVotekickForVoters(targetEntityName);
+                        return;
+                    }
+                    else
+                    {
+                        _adminLogger.Add(LogType.Vote, LogImpact.Extreme, $"Votekick for {located.Username} succeeded:  Yes: {votesYes} / No: {votesNo}. Yes: {yesVotersString} / No: {noVotersString}");
+                        _chatManager.DispatchServerAnnouncement(Loc.GetString("ui-vote-votekick-success", ("target", targetEntityName), ("reason", reason)));
+
+                        if (!Enum.TryParse(_cfg.GetCVar(CCVars.VotekickBanDefaultSeverity), out NoteSeverity severity))
+                        {
+                            _logManager.GetSawmill("admin.votekick")
+                                .Warning("Votekick ban severity could not be parsed from config! Defaulting to high.");
+                            severity = NoteSeverity.High;
+                        }
+
+                        uint minutes = (uint)_cfg.GetCVar(CCVars.VotekickBanDuration);
+
+                        _bans.CreateServerBan(targetUid, target, null, null, targetHWid, minutes, severity, reason);
+                    }
+                }
+                else
+                {
+                    _adminLogger.Add(LogType.Vote, LogImpact.Extreme, $"Votekick failed: Yes: {votesYes} / No: {votesNo}. Yes: {yesVotersString} / No: {noVotersString}");
+                    _chatManager.DispatchServerAnnouncement(Loc.GetString("ui-vote-votekick-failure", ("target", targetEntityName), ("reason", reason)));
+                }
+            };
+
+            if (initiator != null)
+            {
+                // Cast yes vote if created the vote yourself.
+                vote.CastVote(initiator, 0);
+            }
+        }
+
+        private void AnnounceCancelledVotekickForVoters(string target)
+        {
+            foreach (var player in _playerManager.Sessions)
+            {
+                if (CheckVoterEligibility(player, VoterEligibility.GhostMinimumPlaytime))
+                {
+                    var message = Loc.GetString("ui-vote-votekick-server-cancelled", ("target", target));
+                    var wrappedMessage = Loc.GetString("chat-manager-server-wrap-message", ("message", message));
+                    _chatManager.ChatMessageToOne(ChatChannel.Server, message, wrappedMessage, default, false, player.Channel);
+                }
+            }
+        }
+
         private void TimeoutStandardVote(StandardVoteType type)
         {
             var timeout = TimeSpan.FromSeconds(_cfg.GetCVar(CCVars.VoteSameTypeTimeout));

Content.Server/Voting/Managers/VoteManager.cs

@@ -11,6 +11,8 @@ using Content.Server.Maps;
 using Content.Shared.Administration;
 using Content.Shared.CCVar;
 using Content.Shared.Database;
+using Content.Shared.Ghost;
+using Content.Shared.Players.PlayTimeTracking;
 using Content.Shared.Voting;
 using Robust.Server.Player;
 using Robust.Shared.Configuration;
@@ -38,6 +40,7 @@ namespace Content.Server.Voting.Managers
         [Dependency] private readonly IGameMapManager _gameMapManager = default!;
         [Dependency] private readonly IEntityManager _entityManager = default!;
         [Dependency] private readonly IAdminLogManager _adminLogger = default!;
+        [Dependency] private readonly ISharedPlaytimeManager _playtimeManager = default!; 
 
         private int _nextVoteId = 1;
 
@@ -209,7 +212,7 @@ namespace Content.Server.Voting.Managers
             var start = _timing.RealTime;
             var end = start + options.Duration;
             var reg = new VoteReg(id, entries, options.Title, options.InitiatorText,
-                options.InitiatorPlayer, start, end);
+                options.InitiatorPlayer, start, end, options.VoterEligibility, options.DisplayVotes, options.TargetEntity);
 
             var handle = new VoteHandle(this, reg);
 
@@ -245,12 +248,24 @@ namespace Content.Server.Voting.Managers
             msg.VoteId = v.Id;
             msg.VoteActive = !v.Finished;
 
+            if (!CheckVoterEligibility(player, v.VoterEligibility))
+            {
+                msg.VoteActive = false;
+                player.Channel.SendMessage(msg);
+                return;
+            }
+
             if (!v.Finished)
             {
                 msg.VoteTitle = v.Title;
                 msg.VoteInitiator = v.InitiatorText;
                 msg.StartTime = v.StartTime;
                 msg.EndTime = v.EndTime;
+
+                if (v.TargetEntity != null)
+                {
+                    msg.TargetEntity = v.TargetEntity.Value.Id;
+                }
             }
 
             if (v.CastVotes.TryGetValue(player, out var cast))
@@ -266,11 +281,17 @@ namespace Content.Server.Voting.Managers
                 }
             }
 
+            // Admin always see the vote count, even if the vote is set to hide it.
+            if (_adminMgr.HasAdminFlag(player, AdminFlags.Moderator))
+            {
+                msg.DisplayVotes = true;
+            }
+
             msg.Options = new (ushort votes, string name)[v.Entries.Length];
             for (var i = 0; i < msg.Options.Length; i++)
             {
                 ref var entry = ref v.Entries[i];
-                msg.Options[i] = ((ushort) entry.Votes, entry.Text);
+                msg.Options[i] = (msg.DisplayVotes ? (ushort) entry.Votes : (ushort) 0, entry.Text);
             }
 
             player.Channel.SendMessage(msg);
@@ -362,6 +383,16 @@ namespace Content.Server.Voting.Managers
                 return;
             }
 
+            // Remove ineligible votes that somehow slipped through
+            foreach (var playerVote in v.CastVotes)
+            {
+                if (!CheckVoterEligibility(playerVote.Key, v.VoterEligibility))
+                {
+                    v.Entries[playerVote.Value].Votes -= 1;
+                    v.CastVotes.Remove(playerVote.Key);
+                }
+            }
+
             // Find winner or stalemate.
             var winners = v.Entries
                 .GroupBy(e => e.Votes)
@@ -395,6 +426,37 @@ namespace Content.Server.Voting.Managers
             DirtyCanCallVoteAll();
         }
 
+        public bool CheckVoterEligibility(ICommonSession player, VoterEligibility eligibility)
+        {
+            if (eligibility == VoterEligibility.All)
+                return true;
+
+            if (eligibility == VoterEligibility.Ghost || eligibility == VoterEligibility.GhostMinimumPlaytime)
+            {
+                if (!_entityManager.TryGetComponent(player.AttachedEntity, out GhostComponent? ghostComp))
+                    return false;
+
+                if (eligibility == VoterEligibility.GhostMinimumPlaytime)
+                {
+                    var playtime = _playtimeManager.GetPlayTimes(player);
+                    if (!playtime.TryGetValue(PlayTimeTrackingShared.TrackerOverall, out TimeSpan overallTime) || overallTime < TimeSpan.FromHours(_cfg.GetCVar(CCVars.VotekickEligibleVoterPlaytime)))
+                        return false;
+
+                    if ((int)_timing.RealTime.Subtract(ghostComp.TimeOfDeath).TotalSeconds < _cfg.GetCVar(CCVars.VotekickEligibleVoterDeathtime))
+                        return false;
+                }
+            }
+
+            if (eligibility == VoterEligibility.MinimumPlaytime)
+            {
+                var playtime = _playtimeManager.GetPlayTimes(player);
+                if (!playtime.TryGetValue(PlayTimeTrackingShared.TrackerOverall, out TimeSpan overallTime) || overallTime < TimeSpan.FromHours(_cfg.GetCVar(CCVars.VotekickEligibleVoterPlaytime)))
+                    return false;
+            }
+
+            return true;
+        }
+
         public IEnumerable<IVoteHandle> ActiveVotes => _voteHandles.Values;
 
         public bool TryGetVote(int voteId, [NotNullWhen(true)] out IVoteHandle? vote)
@@ -442,6 +504,9 @@ namespace Content.Server.Voting.Managers
             public readonly TimeSpan StartTime;
             public readonly TimeSpan EndTime;
             public readonly HashSet<ICommonSession> VotesDirty = new();
+            public readonly VoterEligibility VoterEligibility;
+            public readonly bool DisplayVotes;
+            public readonly NetEntity? TargetEntity;
 
             public bool Cancelled;
             public bool Finished;
@@ -452,7 +517,7 @@ namespace Content.Server.Voting.Managers
             public ICommonSession? Initiator { get; }
 
             public VoteReg(int id, VoteEntry[] entries, string title, string initiatorText,
-                ICommonSession? initiator, TimeSpan start, TimeSpan end)
+                ICommonSession? initiator, TimeSpan start, TimeSpan end, VoterEligibility voterEligibility, bool displayVotes, NetEntity? targetEntity)
             {
                 Id = id;
                 Entries = entries;
@@ -461,6 +526,9 @@ namespace Content.Server.Voting.Managers
                 Initiator = initiator;
                 StartTime = start;
                 EndTime = end;
+                VoterEligibility = voterEligibility;
+                DisplayVotes = displayVotes;
+                TargetEntity = targetEntity;
             }
         }
 
@@ -478,6 +546,14 @@ namespace Content.Server.Voting.Managers
             }
         }
 
+        public enum VoterEligibility
+        {
+            All,
+            Ghost, // Player needs to be a ghost
+            GhostMinimumPlaytime, // Player needs to be a ghost, with a minimum playtime and deathtime as defined by votekick CCvars.
+            MinimumPlaytime //Player needs to have a minimum playtime and deathtime as defined by votekick CCvars.
+        }
+
         #endregion
 
         #region IVoteHandle API surface
@@ -492,6 +568,7 @@ namespace Content.Server.Voting.Managers
             public string InitiatorText => _reg.InitiatorText;
             public bool Finished => _reg.Finished;
             public bool Cancelled => _reg.Cancelled;
+            public IReadOnlyDictionary<ICommonSession, int> CastVotes => _reg.CastVotes;
 
             public IReadOnlyDictionary<object, int> VotesPerOption { get; }
 

Content.Server/Voting/VoteCommands.cs

@@ -29,11 +29,17 @@ namespace Content.Server.Voting
 
         public void Execute(IConsoleShell shell, string argStr, string[] args)
         {
-            if (args.Length != 1)
+            if (args.Length != 1 && args[0] != StandardVoteType.Votekick.ToString())
             {
                 shell.WriteError(Loc.GetString("shell-need-exactly-one-argument"));
                 return;
             }
+            if (args.Length != 3 && args[0] == StandardVoteType.Votekick.ToString())
+            {
+                shell.WriteError(Loc.GetString("shell-wrong-arguments-number-need-specific", ("properAmount", 3), ("currentAmount", args.Length)));
+                return;
+            }
+
 
             if (!Enum.TryParse<StandardVoteType>(args[0], ignoreCase: true, out var type))
             {
@@ -50,7 +56,7 @@ namespace Content.Server.Voting
                 return;
             }
 
-            mgr.CreateStandardVote(shell.Player, type);
+            mgr.CreateStandardVote(shell.Player, type, args.Skip(1).ToArray());
         }
 
         public CompletionResult GetCompletion(IConsoleShell shell, string[] args)

Content.Server/Voting/VoteOptions.cs

@@ -1,6 +1,6 @@
+using Content.Server.Voting.Managers;
 using Robust.Shared.Player;
 
-
 namespace Content.Server.Voting
 {
     /// <summary>
@@ -39,6 +39,21 @@ namespace Content.Server.Voting
         /// </summary>
         public List<(string text, object data)> Options { get; set; } = new();
 
+        /// <summary>
+        ///     Which sessions may send a vote. Used when only a subset of players should be able to vote. Defaults to all.
+        /// </summary>
+        public VoteManager.VoterEligibility VoterEligibility = VoteManager.VoterEligibility.All;
+
+        /// <summary>
+        ///     Whether the vote should send and display the number of votes to the clients. Being an admin defaults this option to true for your client.
+        /// </summary>
+        public bool DisplayVotes = true;
+
+        /// <summary>
+        ///     Whether the vote should have an entity attached to it, to be used for things like letting ghosts follow it. 
+        /// </summary>
+        public NetEntity? TargetEntity = null;
+
         /// <summary>
         ///     Sets <see cref="InitiatorPlayer"/> and <see cref="InitiatorText"/>
         ///     by setting the latter to the player's name.

Content.Server/Voting/VotingSystem.cs

@@ -0,0 +1,122 @@
+using Content.Server.Administration.Managers;
+using Content.Server.Database;
+using Content.Server.Ghost;
+using Content.Server.Roles.Jobs;
+using Content.Shared.CCVar;
+using Content.Shared.Ghost;
+using Content.Shared.Mind.Components;
+using Content.Shared.Voting;
+using Robust.Server.Player;
+using Robust.Shared.Configuration;
+using Robust.Shared.Network;
+using Robust.Shared.Player;
+using Robust.Shared.Timing;
+using System.Threading.Tasks;
+
+namespace Content.Server.Voting;
+
+public sealed class VotingSystem : EntitySystem
+{
+
+    [Dependency] private readonly IPlayerManager _playerManager = default!;
+    [Dependency] private readonly IAdminManager _adminManager = default!;
+    [Dependency] private readonly IServerDbManager _dbManager = default!;
+    [Dependency] private readonly IGameTiming _gameTiming = default!;
+    [Dependency] private readonly IConfigurationManager _cfg = default!;
+    [Dependency] private readonly JobSystem _jobs = default!;
+
+    public override void Initialize()
+    {
+        base.Initialize();
+
+        SubscribeNetworkEvent<VotePlayerListRequestEvent>(OnVotePlayerListRequestEvent);
+    }
+
+    private async void OnVotePlayerListRequestEvent(VotePlayerListRequestEvent msg, EntitySessionEventArgs args)
+    {
+        if (args.SenderSession.AttachedEntity is not { Valid: true } entity
+            || !await CheckVotekickInitEligibility(args.SenderSession))
+        {
+            var deniedResponse = new VotePlayerListResponseEvent(new (NetUserId, NetEntity, string)[0], true);
+            RaiseNetworkEvent(deniedResponse, args.SenderSession.Channel);
+            return;
+        }
+
+        List<(NetUserId, NetEntity, string)> players = new();
+
+        foreach (var player in _playerManager.Sessions)
+        {
+            if (player.AttachedEntity is not { Valid: true } attached)
+                continue;
+
+            if (attached == entity) continue;
+
+            if (_adminManager.IsAdmin(player, false)) continue;
+
+            var playerName = GetPlayerVoteListName(attached);
+            var netEntity = GetNetEntity(attached);
+
+            players.Add((player.UserId, netEntity, playerName));
+        }
+
+        var response = new VotePlayerListResponseEvent(players.ToArray(), false);
+        RaiseNetworkEvent(response, args.SenderSession.Channel);
+    }
+
+    public string GetPlayerVoteListName(EntityUid attached)
+    {
+        TryComp<MindContainerComponent>(attached, out var mind);
+
+        var jobName = _jobs.MindTryGetJobName(mind?.Mind);
+        var playerInfo = $"{Comp<MetaDataComponent>(attached).EntityName} ({jobName})";
+
+        return playerInfo;
+    }
+
+    /// <summary>
+    /// Used to check whether the player initiating a votekick is allowed to do so serverside.
+    /// </summary>
+    /// <param name="initiator">The session initiating the votekick.</param>
+    public async Task<bool> CheckVotekickInitEligibility(ICommonSession? initiator)
+    {
+        if (initiator == null)
+            return false;
+
+        // Being an admin overrides the votekick eligibility
+        if (initiator.AttachedEntity != null && _adminManager.IsAdmin(initiator.AttachedEntity.Value, false))
+            return true;
+
+        if (_cfg.GetCVar(CCVars.VotekickInitiatorGhostRequirement))
+        {
+            // Must be ghost
+            if (!TryComp(initiator.AttachedEntity, out GhostComponent? ghostComp))
+                return false;
+
+            // Must have been dead for x seconds
+            if ((int)_gameTiming.RealTime.Subtract(ghostComp.TimeOfDeath).TotalSeconds < _cfg.GetCVar(CCVars.VotekickEligibleVoterDeathtime))
+                return false;
+        }
+
+        // Must be whitelisted
+        if (!await _dbManager.GetWhitelistStatusAsync(initiator.UserId))
+            return false;
+
+        return true;
+    }
+
+    /// <summary>
+    /// Used to check whether the player being targetted for a votekick is a valid target.
+    /// </summary>
+    /// <param name="target">The session being targetted for a votekick.</param>
+    public bool CheckVotekickTargetEligibility(ICommonSession? target)
+    {
+        if (target == null)
+            return false;
+
+        // Admins can't be votekicked
+        if (target.AttachedEntity != null && _adminManager.IsAdmin(target.AttachedEntity.Value))
+            return false;
+
+        return true;
+    }
+}