internal SevenDaysLivePlayer(ClientInfo client)
 {
     this.client = client;
     steamId = Convert.ToUInt64(client.playerId);
     Character = this;
     Object = GameManager.Instance.World.Players.dict[client.entityId].transform.gameObject;
 }

 public static void CheckWatchlist(ClientInfo _cInfo)
 {
     if (Dict.ContainsKey(_cInfo.playerId))
     {
         List<ClientInfo> _cInfoList = ConnectionManager.Instance.GetClients();
         foreach (ClientInfo _cInfo1 in _cInfoList)
         {
             if (GameManager.Instance.adminTools.IsAdmin(_cInfo1.playerId))
             {
                 string _phrase350;
                 if (!Phrases.Dict.TryGetValue(350, out _phrase350))
                 {
                     _phrase350 = "Player {PlayerName} is on the watchlist for {Reason}.";
                 }
                 string _reason = null;
                 if (Dict.TryGetValue(_cInfo.playerId, out _reason))
                 {
                     _phrase350 = _phrase350.Replace("{PlayerName}", _cInfo.playerName);
                     _phrase350 = _phrase350.Replace("{Reason}", _reason);
                     _cInfo1.SendPackage(new NetPackageGameMessage(EnumGameMessages.Chat, string.Format("[FF8000]{0}[-]", _phrase350), "Server", false, "", false));
                 }
             }
         }
     }
 }

    public bool GetUserByTokenIDSecure(string tokenID, int connectionID, out ClientInfo client, out string detailMessage)
    {
        lock (lockTokenObject)
        {
            if (!TokenClients.TryGetValue(tokenID, out client))
            {
                detailMessage = "There is no User with TokenID: " + tokenID;
                Debug.LogWarning(detailMessage);
                return false;
            }
        }

        ClientInfo clientSecure;
        lock (lockConnectedObject)
        {
            if (!ConnectedClients.TryGetValue(connectionID, out clientSecure))
            {
                detailMessage = "No Client Connected from: " + client.ConnectionID;
                Debug.LogWarning(detailMessage);
                return false;
            }
        }
        if (!clientSecure.UserID.Equals(client.UserID))
        {
            detailMessage = "Client Connected from: " + client.ConnectionID+" is different from TokenID: " + tokenID;
            Debug.LogWarning(detailMessage);
            return false;
        }
        detailMessage = "Success";
        return true;
    }

 public static void SendAdmins(ClientInfo _sender, string _message)
 {
     if (!GameManager.Instance.adminTools.IsAdmin(_sender.playerId))
     {
         string _phrase200;
         if (!Phrases.Dict.TryGetValue(200, out _phrase200))
         {
             _phrase200 = "{PlayerName} you do not have permissions to use this command.";
         }
         _phrase200 = _phrase200.Replace("{PlayerName}", _sender.playerName);
         _sender.SendPackage(new NetPackageGameMessage(EnumGameMessages.Chat, string.Format("{0}{1}[-]", CustomCommands.ChatColor, _phrase200), "Server", false, "", false));
     }
     else
     {
         List<ClientInfo> _cInfoList = ConnectionManager.Instance.GetClients();
         foreach (ClientInfo _cInfo in _cInfoList)
         {
             if (GameManager.Instance.adminTools.IsAdmin(_cInfo.playerId))
             {
                 _message = _message.Replace("@ADMINS ", "");
                 _message = _message.Replace("@admins ", "");
                 _cInfo.SendPackage(new NetPackageGameMessage(EnumGameMessages.Chat, string.Format("[FF0080]{0}[-]", _message), _sender.playerName, false, "", false));
             }
         }
     }
 }

    protected void Page_Load(object sender, EventArgs e)
    {
        String isShowMetro = ConfigurationManager.AppSettings["ShowMetro"];
        if (String.IsNullOrEmpty(isShowMetro) || isShowMetro.ToLower() == "false")
        {
            JQMetro1.Visible = false;
            MainImg.Visible = true;
        }
        else if (isShowMetro.ToLower() == "true")
        {
            JQMetro1.Visible = true;
            MainImg.Visible = false;
        }
        var key = this.Request.QueryString["key"];
        var param = this.Request.QueryString["param"];
        if (!string.IsNullOrEmpty(key) && !string.IsNullOrEmpty(param))
        {
            try
            {
                var clientInfo = new ClientInfo() { SecurityKey = key, UseDataSet = true };
                EFServiceClient client = EFClientTools.ClientUtility.Client;
                clientInfo = client.LogOn(clientInfo);
                var locale = Request.UserLanguages.Length > 0 ? Request.UserLanguages[0] : "en-us";
                clientInfo.Locale = locale;
                clientInfo.LogonResult = LogonResult.Logoned;
                Session["ClientInfo"] = clientInfo;

                parameter.Value = DecryptParameters(param, key);
            }
            catch
            {
                Response.Redirect("Timeout.aspx", true);
            }
        }
    }

 void Start()
 {
     Socket sock = Sockets.CreateTCPSocket("www.myserver.com", 2345);
     client = new ClientInfo(sock, false); // Don't start receiving yet
     client.OnReadBytes += new ConnectionReadBytes(ReadData);
     client.BeginReceive();
 }

    protected void Page_Load(object sender, EventArgs e)
    {
        string strFullUrl = Request.Url.ToString();
        string url = strFullUrl.Substring(strFullUrl.IndexOf("RedirectUrl") + 12);
        var publicKey = this.Request.QueryString["PublicKey"];

        if (!string.IsNullOrEmpty(url) && !string.IsNullOrEmpty(publicKey))
        {
            try
            {
                var clientInfo = new ClientInfo() { SecurityKey = publicKey, UseDataSet = true };
                EFServiceClient client = EFClientTools.ClientUtility.Client;
                clientInfo = client.LogOn(clientInfo);
                var locale = Request.UserLanguages.Length > 0 ? Request.UserLanguages[0] : "en-us";
                clientInfo.Locale = locale;
                clientInfo.LogonResult = LogonResult.Logoned;
                Session["ClientInfo"] = clientInfo;
                Response.Redirect(url);
            }
            catch(Exception ex)
            {
                Response.Write(ex.Message);
            }
        }
        else
        {
            Response.Write("PublishKey is null or url is null.");
        }
    }

 public static void Execute( ClientInfo ci, byte param1, byte param2a, byte param2b )
 {
     ci.PrimaryCave[data1offset + 24] = param1;
     ci.PrimaryCave[data1offset + 28] = param2b;
     ci.PrimaryCave[data1offset + 29] = param2a;
     Memory.Write( ci.Handle, ci.CaveAddress, ci.PrimaryCave, true );
 }

 public override void PlayerLogin(ClientInfo _cInfo, string _compatibilityVersion)
 {
     if (ReservedSlots.IsEnabled)
     {
         ReservedSlots.CheckReservedSlot(_cInfo);
     }
 }

    public string LogOn(string userId, string password, string dataBase, string solution)
    {
        EFServiceClient client = EFClientTools.ClientUtility.Client;
        EFClientTools.ClientUtility.ServerIPAddress = client.GetServerIPAddress();
        var ipAddress = HttpContext.Current.Request.UserHostAddress;
        var clientInfo = new ClientInfo()
        {
            UserID = userId,
            Password = password,
            Database = dataBase,
            Solution = solution,
            IPAddress = ipAddress,
            Locale = "en-us",
            UseDataSet = true
        };
        if(clientInfo.UserID.Contains("'"))
        {
            return string.Empty;
        }
        var result = client.LogOn(clientInfo);

        client = EFClientTools.ClientUtility.Client;
        if (result.LogonResult == LogonResult.Logoned)
        {
            return result.SecurityKey;
        }
        else
        {
            return string.Empty;
        }
    }

 public static void SetLastPMSender(ClientInfo _sender, ClientInfo _receiver)
 {
     if (senderOfLastPM.ContainsKey (_receiver))
         senderOfLastPM [_receiver] = _sender;
     else
         senderOfLastPM.Add (_receiver, _sender);
 }

    protected void Page_Load(object sender, EventArgs e)
    {
        var key = this.Request.QueryString["key"];
        var param = this.Request.QueryString["param"];
        if (!string.IsNullOrEmpty(key) && !string.IsNullOrEmpty(param))
        {
            try
            {
                var clientInfo = new ClientInfo() { SecurityKey = key, UseDataSet = true };
                EFServiceClient client = EFClientTools.ClientUtility.Client;
                clientInfo = client.LogOn(clientInfo);
                var locale = Request.UserLanguages.Length > 0 ? Request.UserLanguages[0] : "en-us";
                clientInfo.Locale = locale;
                clientInfo.LogonResult = LogonResult.Logoned;
                Session["ClientInfo"] = clientInfo;

                parameter.Value = DecryptParameters(param, key);
            }
            catch
            {
                Response.Redirect("Timeout.aspx", true);
            }
        }
        else
        {
            Response.Redirect("Timeout.aspx", true);
        }
    }

 public override void Verify(ClientInfo clientInfo)
 {
     Assert.NotNull(clientInfo);
       AssertMatch(Family,clientInfo.Device.Family,"Family");
       AssertMatch(IsMobile, clientInfo.Device.IsMobile, "IsMobile");
       AssertMatch(IsSpider, clientInfo.Device.IsSpider, "IsSpider");
 }

 public void AddClient(int id, ClientInfo client)
 {
     lock (this)
     {
         clients[lastClientID] = client;
     }
     Context.Current.UpdateTrayIcon();
 }

 public static void GM_SavePlayerData(ClientInfo _cInfo, PlayerDataFile _playerDataFile)
 {
     try {
         PersistentContainer.Instance.Players[_cInfo.playerId, true].Update (_playerDataFile);
     } catch (Exception e) {
         Log.Out ("Error in GM_SavePlayerData: " + e);
     }
 }

 // Use this for initialization
 void Start()
 {
     _controller = new Controller();
     _princessHasShot = false;
     coolDownValue = 1.0f;
     currCD = 0.0f;
     this.clientInfo = this.transform.parent.GetComponent<ClientInfo>();
 }

 /// <summary>
 /// Send a message to the host.
 /// </summary>
 /// <param name="clientInfo">Client identifier.</param>
 /// <param name="buildMessage">Message to send.</param>
 public void SendTo(ClientInfo clientInfo, byte[] buildMessage)
 {
     lock (server)
     {
         server.SendMore(clientInfo.Id);
         server.Send(buildMessage);
     }
 }

    public override void Verify(ClientInfo clientInfo)
    {
      Assert.NotNull(clientInfo);
      AssertMatch(Family, clientInfo.UserAgent.Family, "Family");
      AssertMatch(Major, clientInfo.UserAgent.Major, "Major");
      AssertMatch(Minor, clientInfo.UserAgent.Minor, "Minor");
      AssertMatch(Patch, clientInfo.UserAgent.Patch, "Patch");

    }

 public static void CheckPing(ClientInfo _cInfo)
 {
     string _steamid = _cInfo.playerId;
     if (_cInfo.ping > MAXPING && !_whiteListPlayers.ContainsKey(_steamid))
     {
         Log.Out("Kicking (" + _cInfo.playerName + ") for high ping. (" + _cInfo.ping + ") Max is " + MAXPING + ".");
         GameManager.Instance.GameMessageServer(_cInfo, "[FF8000]Kicking (" + _cInfo.playerName + ") for high ping. (" + _cInfo.ping + ") Max is " + MAXPING + ".[-]", "Server");
         SdtdConsole.Instance.ExecuteSync("kick " + _cInfo.entityId + " \"Ping To High. Max Ping is " + MAXPING + ".\"", _cInfo);
     }
 }

 public RedisInfo()
 {
     Replication = new ReplicationInfo();
     Clients = new ClientInfo();
     Server = new ServerInfo();
     Memory = new MemoryInfo();
     Persistence = new PersistenceInfo();
     Stats = new StatsInfo();
     CPU = new CPUInfo();
     Keyspace = new KeyspaceInfo();
 }