FREE TeamId : 1.0.5 1.0.5

using System;
using System.Collections.Generic;
using System.Text;

namespace Oxide.Plugins
{
    [Info("TeamId", "xADROCx", "1.0.5")]
    [Description("Lightweight team inspector")]
    public class TeamId : RustPlugin
    {
        private const string PermAdmin = "teamid.admin";
        private const string PermUse = "teamid.use";

        #region Init

        private void Init()
        {
            permission.RegisterPermission(PermAdmin, this);
            permission.RegisterPermission(PermUse, this);

            cmd.AddConsoleCommand("ti.team", this, nameof(CmdTeamC));
            cmd.AddConsoleCommand("ti.all", this, nameof(CmdAllC));

            cmd.AddChatCommand("ti.team", this, nameof(CmdTeamChat));
            cmd.AddChatCommand("ti.all", this, nameof(CmdAllChat));
        }

        #endregion

        #region Permissions

        private bool HasUsePerm(BasePlayer player)
        {
            if (player == null) return true;
            if (player.IsAdmin) return true;

            var uid = player.UserIDString;
            return permission.UserHasPermission(uid, PermUse) || permission.UserHasPermission(uid, PermAdmin);
        }

        private bool DenyIfNoPerm(BasePlayer player)
        {
            if (HasUsePerm(player)) return false;
            player.ChatMessage("<color=#f66>Missing permission (teamid.use or teamid.admin).</color>");
            return true;
        }

        #endregion

        #region Console Commands

        private void CmdTeamC(ConsoleSystem.Arg arg)
        {
            ulong tid;
            // Post-June-2026 Rust update: arg.Args is Facepunch.StringView[] not string[].
            // Convert via the explicit (string) cast that StringView exposes.
            string[] sargs = null;
            if (arg?.Args != null)
            {
                sargs = new string[arg.Args.Length];
                for (int i = 0; i < sargs.Length; i++) sargs[i] = (string)arg.Args[i];
            }
            if (!TryParseUlong(sargs, out tid))
            {
                arg?.ReplyWith("[TeamId] Usage: ti.team <teamId>");
                return;
            }
            var report = BuildReportTeam(tid);
            arg?.ReplyWith(report);
            Puts(report);
        }

        private void CmdAllC(ConsoleSystem.Arg arg)
        {
            var report = BuildReportAll();
            arg?.ReplyWith(report);
            Puts(report);
        }

        #endregion

        #region Chat Commands

        private void CmdTeamChat(BasePlayer player, string command, string[] args)
        {
            if (DenyIfNoPerm(player)) return;

            ulong tid;
            if (!TryParseUlong(args, out tid))
            {
                player.ChatMessage("<color=#f66>Usage: /ti.team <teamId></color>");
                return;
            }
            ToConsoleAndNotify(player, BuildReportTeam(tid));
        }

        private void CmdAllChat(BasePlayer player, string command, string[] args)
        {
            if (DenyIfNoPerm(player)) return;
            ToConsoleAndNotify(player, BuildReportAll());
        }

        private static void ToConsoleAndNotify(BasePlayer player, string payload)
        {
            player.ConsoleMessage(payload);
            player.ChatMessage("<color=#ccc>TeamId: Output sent to your F1 console.</color>");
        }

        #endregion

        #region Builders

        private string BuildReportAll()
        {
            var rm = RelationshipManager.ServerInstance;
            if (rm == null || rm.teams == null || rm.teams.Count == 0)
                return "[TeamId] No teams found.";

            var ids = new List<ulong>(rm.teams.Keys);
            ids.Sort();

            var sb = new StringBuilder(4096);
            sb.AppendLine($"[TeamId] Teams: {ids.Count}");
            sb.AppendLine("------------------------------------------------------------");

            for (int i = 0; i < ids.Count; i++)
            {
                var team = rm.FindTeam(ids[i]);
                if (team == null)
                {
                    sb.Append("Team ").Append(ids[i]).AppendLine(" (not found)").AppendLine();
                    continue;
                }
                AppendTeamBlock(sb, team);
            }

            return sb.ToString();
        }

        private string BuildReportTeam(ulong teamId)
        {
            var rm = RelationshipManager.ServerInstance;
            if (rm == null || rm.teams == null || rm.teams.Count == 0)
                return "[TeamId] No teams found.";

            var team = rm.FindTeam(teamId);
            if (team == null) return $"[TeamId] Team {teamId} not found.";

            var sb = new StringBuilder(256);
            AppendTeamBlock(sb, team);
            return sb.ToString();
        }

        #endregion

        #region Formatting & Utils

        private static void AppendTeamBlock(StringBuilder sb, RelationshipManager.PlayerTeam team)
        {
            sb.Append("TeamID: ").AppendLine(team.teamID.ToString());
            sb.Append("  Leader: ").Append(ResolveName(team.teamLeader)).Append(" (").Append(team.teamLeader).AppendLine(")");

            var members = team.members;
            if (members != null && members.Count > 0)
            {
                sb.AppendLine("  Members:");
                for (int i = 0; i < members.Count; i++)
                {
                    var uid = members[i];
                    sb.Append("    - ").Append(ResolveName(uid)).Append(" (").Append(uid).AppendLine(")");
                }
            }
            else
            {
                sb.AppendLine("  Members: <none>");
            }
            sb.AppendLine();
        }

        private static string ResolveName(ulong userId)
        {
            if (userId == 0) return "Unknown";

            var online = BasePlayer.FindByID(userId);
            if (online != null && !string.IsNullOrEmpty(online.displayName))
                return Sanitize(online.displayName);

            var sleeper = BasePlayer.FindSleeping(userId);
            if (sleeper != null && !string.IsNullOrEmpty(sleeper.displayName))
                return Sanitize(sleeper.displayName);

            return "Unknown";
        }

        private static string Sanitize(string s) =>
            string.IsNullOrEmpty(s) ? "Unknown" : s.Replace("\n", " ").Replace("\r", " ");

        private static bool TryParseUlong(string[] args, out ulong tid)
        {
            tid = 0;
            if (args == null || args.Length == 0) return false;
            return ulong.TryParse(args[0], out tid);
        }

        #endregion
    }
}