source: binary-improvements/7dtd-server-fixes/src/CommonMappingFunctions.cs@ 137

using System;
using System.Collections.Generic;
using System.Text.RegularExpressions;
using ManagedSteam.SteamTypes;

namespace AllocsFixes
{
        public class CommonMappingFunctions
        {
                public static ConnectionManager GetConnectionManager ()
                {
                        return ConnectionManager.Instance;
                }

                public static GameManager GetGameManager ()
                {
                        return GetConnectionManager ().gameManager;
                }

                public static string GetPlayerName (ClientInfo _ci)
                {
                        try {
                                int entityId = GetConnectionManager ().mapClientToEntity [_ci.clientId];
                                return GetGameManager ().World.playerEntities.dict [entityId].EntityName;
                        } catch (Exception e) {
                                Log.Out ("Error getting player name for ClientInfo: " + e);
                        }
                        return null;
                }

                public static EntityPlayer GetEntityPlayer (ClientInfo _ci)
                {
                        try {
                                int entityId = GetConnectionManager ().mapClientToEntity [_ci.clientId];
                                return GetGameManager ().World.playerEntities.dict [entityId];
                        } catch (Exception e) {
                                Log.Out ("Error getting entity player for ClientInfo: " + e);
                        }
                        return null;
                }

                public static string GetSteamID (ClientInfo _ci)
                {
                        return SingletonMonoBehaviour<Authenticator>.Instance.GetPlayerId (GetPlayerName (_ci));
                }

                public static string GetSteamID (string _playerName)
                {
                        return SingletonMonoBehaviour<Authenticator>.Instance.GetPlayerId (_playerName);
                }

                public static int GetClientID (ClientInfo _ci)
                {
                        if (_ci != null) {
                                if (GetConnectionManager ().connectedClients.ContainsKey (_ci.clientId))
                                        return _ci.clientId;
                        }
                        return -1;
                }

                public static int GetEntityID (ClientInfo _ci)
                {
                        try {
                                ConnectionManager cm = GetConnectionManager ();

                                if (cm.mapClientToEntity.ContainsKey (_ci.clientId))
                                        return cm.mapClientToEntity [_ci.clientId];
                                else
                                        return -1;
                        } catch (Exception e) {
                                Log.Out ("Error getting entity ID for ClientInfo: " + e);
                        }
                        return -1;
                }

                public static ClientInfo GetClientInfoFromEntityID (int _entityId)
                {
                        try {
                                ConnectionManager cm = GetConnectionManager ();

                                if (cm.mapClientToEntity.ContainsValue (_entityId)) {
                                        foreach (KeyValuePair<int, int> kvp in cm.mapClientToEntity) {
                                                if (kvp.Value == _entityId) {
                                                        return cm.connectedClients [kvp.Key];
                                                }
                                        }
                                }

                                return null;
                        } catch (Exception e) {
                                Log.Out ("Error getting ClientInfo for entity ID: " + e);
                        }
                        return null;
                }

                public static ClientInfo GetClientInfoFromClientID (int _clientId)
                {
                        try {
                                ConnectionManager cm = GetConnectionManager ();

                                if (cm.connectedClients.ContainsKey (_clientId))
                                        return cm.connectedClients [_clientId];
                                else
                                        return null;
                        } catch (Exception e) {
                                Log.Out ("Error getting ClientInfo for client ID: " + e);
                        }
                        return null;
                }

                public static ClientInfo GetClientInfoFromPlayerName (string _playerName, bool ignoreColorcodes)
                {
                        try {
                                ConnectionManager cm = GetConnectionManager ();

                                _playerName = _playerName.ToLower ();
                                if (ignoreColorcodes) {
                                        _playerName = Regex.Replace (_playerName, "\\[[0-9a-fA-F]{6}\\]", "");
                                }
                                foreach (ClientInfo ci in cm.connectedClients.Values) {
                                        string curName = GetPlayerName (ci).ToLower ();
                                        if (ignoreColorcodes) {
                                                curName = Regex.Replace (curName, "\\[[0-9a-fA-F]{6}\\]", "");
                                        }
                                        if (curName.Equals (_playerName)) {
                                                return ci;
                                        }
                                }
                        } catch (Exception e) {
                                Log.Out ("Error getting ClientInfo for player name: " + e);
                        }
                        return null;
                }

                public static ClientInfo GetClientInfoFromNameOrID (string _nameOrId, bool ignoreColorcodes)
                {
                        try {
                                int entityId = -1;
                                if (int.TryParse (_nameOrId, out entityId)) {
                                        ClientInfo ci = GetClientInfoFromEntityID (entityId);
                                        if (ci != null)
                                                return ci;
                                }

                                return GetClientInfoFromPlayerName (_nameOrId, ignoreColorcodes);
                        } catch (Exception e) {
                                Log.Out ("Error getting ClientInfo for entity ID or player name: " + e);
                        }
                        return null;
                }

                public static ClientInfo GetClientInfoFromSteamID (string _steamId)
                {
                        try {
                                Dictionary<string, object> uToID = Authenticator.Instance.usersToIDs;
                                foreach (KeyValuePair<string, object> kvp in uToID) {
                                        string curId = string.Empty + ((SteamID)kvp.Value).AsUInt64;
                                        if (curId.Equals (_steamId)) {
                                                return GetClientInfoFromPlayerName (kvp.Key, false);
                                        }
                                }
                        } catch (Exception e) {
                                Log.Out ("Error getting ClientInfo for steam ID: " + e);
                        }
                        return null;
                }

        }
}