public byte GetWarnings(CSteamID id)
 {
     byte num = 0;
     try
     {
         MySqlConnection mySqlConnection = this.createConnection();
         MySqlCommand mySqlCommand = mySqlConnection.CreateCommand();
         mySqlCommand.CommandText = string.Concat(new string[] { 
             "select `warninglevel` from `",
             Zaup_Warning.Instance.Configuration.Instance.TableName,
             "` where `steamId` = '",
             id.ToString(),
             "';" 
         });
         mySqlConnection.Open();
         object obj = mySqlCommand.ExecuteScalar();
         if (obj != null)
         {
             byte.TryParse(obj.ToString(), out num);
         }
         mySqlConnection.Close();
     }
     catch (Exception exception)
     {
         Logger.LogException(exception);
     }
     return num;
 }

        protected override void execute( CSteamID executorId, string parameter )
        {
            try
            {
                var commandSource = executorId == CSteamID.Nil
                                    ? EssProvider.ConsoleSource
                                    : UPlayer.From( executorId );

                if ( commandSource.IsConsole && Command.AllowedSource == AllowedSource.PLAYER )
                {
                    EssLang.CONSOLE_CANNOT_EXECUTE.SendTo( commandSource );
                }
                else if ( !commandSource.IsConsole && Command.AllowedSource == AllowedSource.CONSOLE )
                {
                    EssLang.PLAYER_CANNOT_EXECUTE.SendTo( commandSource );
                }
                else
                {
                    Command.OnExecute( commandSource , new CommandArgs( parameter ) );
                }
            }
            catch ( Exception e )
            {
                UPlayer.TryGet( executorId, EssLang.COMMAND_ERROR_OCURRED.SendTo );

                EssProvider.Logger.LogError( e.ToString() );
            }
        }

 public void ClearUser(CSteamID id)
 {
     lock (this._pendingReadBuffers)
     {
         this._deletionQueue.Enqueue(id);
     }
 }

 public void AddUpdateVictimAccount(CSteamID id, decimal bounty, string lastDisplayName)
 {
     try
     {
         MySqlConnection connection = CreateConnection();
         MySqlCommand command = connection.CreateCommand();
         if (CheckExists(id))
         {
             command.CommandText = "UPDATE `" + FeexHitman.Instance.Configuration.Instance.FeexHitmanDatabase.DatabaseTableName + "` SET `bounty` = bounty + (" + bounty + "), `lastDisplayName` = @lastDisplayName, `lastUpdated` = NOW() WHERE `steamId` = '" + id.ToString() + "';";
         }
         else
         {
             command.CommandText = "INSERT IGNORE INTO `" + FeexHitman.Instance.Configuration.Instance.FeexHitmanDatabase.DatabaseTableName + "` (steamId,bounty,lastDisplayName,lastUpdated) VALUES('" + id.ToString() + "','" + bounty + "',@lastDisplayName,NOW());";
         }
         command.Parameters.AddWithValue("@lastDisplayName", lastDisplayName);
         connection.Open();
         IAsyncResult result = command.BeginExecuteNonQuery();
         command.EndExecuteNonQuery(result);
         connection.Close();
     }
     catch (Exception ex)
     {
         Logger.LogException(ex);
     }
 }

 public static void ActivateGameOverlayToUser(string pchDialog, CSteamID steamID)
 {
     InteropHelp.TestIfAvailableClient();
     using (InteropHelp.UTF8StringHandle uTF8StringHandle = new InteropHelp.UTF8StringHandle(pchDialog))
     {
         NativeMethods.ISteamFriends_ActivateGameOverlayToUser(uTF8StringHandle, steamID);
     }
 }

 //[SteamCall]
 public void tellToggleHud(CSteamID steamID, bool visible)
 {
     if (base.channel.checkServer(steamID))
     {
         Debug.LogError("CALLED HUD");
         this.visible = visible;
     }
 }

 public void SetInvitedToGameId(ulong gameId)
 {
     CSteamID y = new CSteamID(gameId);
     if (y.IsValid() && (CoopLobby.Instance == null || CoopLobby.Instance.Info.LobbyId != y))
     {
         base.StartCoroutine(this.DelayedInviteReceived(new CoopLobbyInfo(gameId)));
     }
 }

        private void ClearInventory(UnturnedPlayer player, EDeathCause cause, ELimb limb, CSteamID murderer)
        {
            if (!player.HasPermission ("keepinventory.keep"))
            {
                return;
            }

            var playerInventory = player.Inventory;
            List<Item> ids = new List<Item> ();
            List<Item> clothes = new List<Item> ();

            // "Remove "models" of items from player "body""
            player.Player.channel.send ("tellSlot", ESteamCall.ALL, ESteamPacket.UPDATE_RELIABLE_BUFFER, ( byte ) 0, ( byte ) 0, new byte[0]);
            player.Player.channel.send ("tellSlot", ESteamCall.ALL, ESteamPacket.UPDATE_RELIABLE_BUFFER, ( byte ) 1, ( byte ) 0, new byte[0]);

            // Remove items
            for (byte page = 0; page < 8; page++)
            {
                var count = playerInventory.getItemCount (page);

                for (byte index = 0; index < count; index++)
                {
                    ids.Add (playerInventory.getItem (page, 0).item);
                    playerInventory.removeItem (page, 0);
                }
            }

            // Unequip & remove from inventory
            player.Player.clothing.askWearBackpack (0, 0, new byte[0], true);
            clothes.Add (removeUnequipped (playerInventory));

            player.Player.clothing.askWearGlasses (0, 0, new byte[0], true);
            clothes.Add (removeUnequipped (playerInventory));

            player.Player.clothing.askWearHat (0, 0, new byte[0], true);
            clothes.Add (removeUnequipped (playerInventory));

            player.Player.clothing.askWearPants (0, 0, new byte[0], true);
            clothes.Add (removeUnequipped (playerInventory));

            player.Player.clothing.askWearMask (0, 0, new byte[0], true);
            clothes.Add (removeUnequipped (playerInventory));

            player.Player.clothing.askWearShirt (0, 0, new byte[0], true);
            clothes.Add (removeUnequipped (playerInventory));

            player.Player.clothing.askWearVest (0, 0, new byte[0], true);
            clothes.Add (removeUnequipped (playerInventory));
            clothes.AddRange (ids);
            deadAdmins.Add (player);
            adminItems.Add (player, clothes);
        }

        internal void OnPlayerDeath( UnturnedPlayer player, EDeathCause cause, ELimb limb, 
                                     CSteamID murderer )
        {
            if ( !player.HasPermission( "essentials.command.back" ) )
                return;

            var displayName = player.DisplayName;

            if ( BackDict.ContainsKey( displayName ) )
                BackDict.Remove( displayName );

            BackDict.Add( displayName, player.Position );
        }

        public Party(UnturnedPlayer leader)
        {
            //create the party's fake steam group
            var buffer = new byte[sizeof(ulong)];
            random.NextBytes(buffer);
            ulong newID = BitConverter.ToUInt64(buffer, 0);
            steamGroup = new CSteamID(newID);
            claimedIDs.Add(newID);

            //set and add the leader
            this.leader = leader;
            leader.Player.SteamChannel.SteamPlayer.playerID.SteamGroupID = steamGroup;
            members.Add(leader);
        }

		public void ClearUser(CSteamID user)
		{
			lock (this._lock)
			{
				if (this._pendingSendData.ContainsKey(user))
				{
					Queue<SteamP2PWriter.WriteInformation> item = this._pendingSendData[user];
					while (item.Count > 0)
					{
						this._bufferPool.Enqueue(item.Dequeue().Data);
					}
				}
			}
		}

 public bool IsDataAvailable(CSteamID id)
 {
     bool flag;
     lock (this._pendingReadBuffers)
     {
         if (this._pendingReadBuffers.ContainsKey(id))
         {
             Queue<SteamP2PReader.ReadResult> item = this._pendingReadBuffers[id];
             flag = (item.Count == 0 || item.Peek().Size == 0 ? false : true);
         }
         else
         {
             flag = false;
         }
     }
     return flag;
 }

 protected override void execute(CSteamID executorID, string parameter)
 {
     CommandQueue queue = ExecScript.ToQueue(UnturnedFreneticMod.Instance.CommandSystem.System);
     MapTag map = new MapTag();
     if (executorID == CSteamID.Nil)
     {
         map.Internal["is_server"] = new BooleanTag(true);
     }
     else
     {
         map.Internal["player"] = new PlayerTag(PlayerTool.getSteamPlayer(executorID));
         map.Internal["is_server"] = new BooleanTag(false);
     }
     map.Internal["raw_arguments"] = new TextTag(parameter);
     queue.SetVariable("context", map);
     queue.CommandStack.Peek().Debug = DebugMode.MINIMAL; // Just in case
     queue.Execute();
 }

 public decimal GetBounty(CSteamID id)
 {
     decimal output = 0;
     try
     {
         MySqlConnection connection = CreateConnection();
         MySqlCommand command = connection.CreateCommand();
         command.CommandText = "SELECT `bounty` FROM `" + FeexHitman.Instance.Configuration.Instance.FeexHitmanDatabase.DatabaseTableName + "` WHERE `steamId` = '" + id.ToString() + "';";
         connection.Open();
         object result = command.ExecuteScalar();
         if (result != null) Decimal.TryParse(result.ToString(), out output);
         connection.Close();
     }
     catch (Exception ex)
     {
         Logger.LogException(ex);
     }
     return output;
 }

		private void CheckParameters()
		{
			ulong ulSteamID;
			if (Program.LaunchParameters.ContainsKey("+connect_lobby") && ulong.TryParse(Program.LaunchParameters["+connect_lobby"], out ulSteamID))
			{
				CSteamID lobbySteamId = new CSteamID(ulSteamID);
				if (lobbySteamId.IsValid())
				{
					Main.OpenPlayerSelect(delegate(PlayerFileData playerData)
					{
						Main.ServerSideCharacter = false;
						playerData.SetAsActive();
						Main.menuMode = 882;
						Main.statusText = "Joining...";
						this._lobby.Join(lobbySteamId, new CallResult<LobbyEnter_t>.APIDispatchDelegate(this.OnLobbyEntered));
					});
				}
			}
		}

 public int Receive(CSteamID user, byte[] buffer, int bufferOffset, int bufferSize)
 {
     int num;
     uint num1 = 0;
     lock (this._pendingReadBuffers)
     {
         if (this._pendingReadBuffers.ContainsKey(user))
         {
             Queue<SteamP2PReader.ReadResult> item = this._pendingReadBuffers[user];
             while (item.Count > 0)
             {
                 SteamP2PReader.ReadResult readResult = item.Peek();
                 uint num2 = (uint)Math.Min(bufferSize - num1, readResult.Size - readResult.Offset);
                 if (num2 != 0)
                 {
                     Array.Copy(readResult.Data, (long)readResult.Offset, buffer, (long)((long)bufferOffset + (long)num1), (long)num2);
                     if (num2 != readResult.Size - readResult.Offset)
                     {
                         SteamP2PReader.ReadResult offset = readResult;
                         offset.Offset = offset.Offset + num2;
                     }
                     else
                     {
                         this._bufferPool.Enqueue(item.Dequeue().Data);
                     }
                     num1 = num1 + num2;
                 }
                 else
                 {
                     num = (int)num1;
                     return num;
                 }
             }
             return (int)num1;
         }
         else
         {
             num = 0;
         }
     }
     return num;
 }

		public void QueueSend(CSteamID user, byte[] data, int length)
		{
			lock (this._lock)
			{
				Queue<SteamP2PWriter.WriteInformation> queue;
				if (this._pendingSendData.ContainsKey(user))
				{
					queue = this._pendingSendData[user];
				}
				else
				{
					queue = (this._pendingSendData[user] = new Queue<SteamP2PWriter.WriteInformation>());
				}
				int i = length;
				int num = 0;
				while (i > 0)
				{
					SteamP2PWriter.WriteInformation writeInformation;
					if (queue.Count == 0 || 1024 - queue.Peek().Size == 0)
					{
						if (this._bufferPool.Count > 0)
						{
							writeInformation = new SteamP2PWriter.WriteInformation(this._bufferPool.Dequeue());
						}
						else
						{
							writeInformation = new SteamP2PWriter.WriteInformation();
						}
						queue.Enqueue(writeInformation);
					}
					else
					{
						writeInformation = queue.Peek();
					}
					int num2 = Math.Min(i, 1024 - writeInformation.Size);
					Array.Copy(data, num, writeInformation.Data, writeInformation.Size, num2);
					writeInformation.Size += num2;
					i -= num2;
					num += num2;
				}
			}
		}

        internal static void TriggerReceive(SteamChannel instance, CSteamID d, byte[] a, int b,int size)
        {
#if DEBUG
            /*ESteamPacket eSteamPacket = (ESteamPacket)a[0];
            int num = a[1];

            if (eSteamPacket != ESteamPacket.UPDATE_VOICE && eSteamPacket != ESteamPacket.UPDATE_UDP_CHUNK && eSteamPacket != ESteamPacket.UPDATE_TCP_CHUNK)
            {
                object[] objects = SteamPacker.getObjects(d, 2, a, instance.Methods[num].Types);

                string o = "";
                foreach (object r in objects)
                {
                    o += r.ToString() + ",";
                }
                Logger.Log("Receive+" + d.ToString() + ": " + o + " - " + b);
            }*/
#endif
            return;
        }

		public void QueueSend(CSteamID user, byte[] data, int length)
		{
			Queue<SteamP2PWriter.WriteInformation> item;
			SteamP2PWriter.WriteInformation writeInformation;
			lock (this._lock)
			{
				if (!this._pendingSendData.ContainsKey(user))
				{
					Dictionary<CSteamID, Queue<SteamP2PWriter.WriteInformation>> cSteamIDs = this._pendingSendData;
					Queue<SteamP2PWriter.WriteInformation> writeInformations = new Queue<SteamP2PWriter.WriteInformation>();
					item = writeInformations;
					cSteamIDs[user] = writeInformations;
				}
				else
				{
					item = this._pendingSendData[user];
				}
				int num = length;
				int num1 = 0;
				while (num > 0)
				{
					if (item.Count == 0 || 1024 - item.Peek().Size == 0)
					{
						writeInformation = (this._bufferPool.Count <= 0 ? new SteamP2PWriter.WriteInformation() : new SteamP2PWriter.WriteInformation(this._bufferPool.Dequeue()));
						item.Enqueue(writeInformation);
					}
					else
					{
						writeInformation = item.Peek();
					}
					int num2 = Math.Min(num, 1024 - writeInformation.Size);
					Array.Copy(data, num1, writeInformation.Data, writeInformation.Size, num2);
					SteamP2PWriter.WriteInformation size = writeInformation;
					size.Size = size.Size + num2;
					num = num - num2;
					num1 = num1 + num2;
				}
			}
		}

        public bool CheckAccount(CSteamID id)
        {
            try
            {
                MySqlConnection connection = CreateConnection();
                MySqlCommand command = connection.CreateCommand();
                int exists = 0;
                connection.Open();
                command.CommandText = "SELECT COUNT(1) FROM `" + FeexRanks.Instance.Configuration.Instance.FeexRanksDatabase.DatabaseTableName + "` WHERE `steamId` = '" + id.ToString() + "'";
                object result = command.ExecuteScalar();
                if (result != null) Int32.TryParse(result.ToString(), out exists);
                connection.Close();

                if (exists == 0) { return false; }
                else { return true; }
            }
            catch (Exception ex)
            {
                Logger.LogException(ex);
                return false;
            }
        }