public static void EntityAction(RemoteClient client, MinecraftServer server, IPacket _packet) { var packet = (EntityActionPacket)_packet; switch (packet.Action) { case EntityActionPacket.EntityAction.Crouch: client.Entity.IsCrouching = true; break; case EntityActionPacket.EntityAction.Uncrouch: client.Entity.IsCrouching = false; break; case EntityActionPacket.EntityAction.StartSprinting: client.Entity.IsSprinting = true; break; case EntityActionPacket.EntityAction.StopSprinting: client.Entity.IsSprinting = false; break; // case EntityActionPacket.EntityAction.LeaveBed: // client.Entity.LeaveBed(); // break; } if (packet.Action != EntityActionPacket.EntityAction.LeaveBed) // NOTE: Does this matter? { // TODO ? } }
/// <summary> /// Handles the packet. /// </summary> /// <param name="Server">The server.</param> /// <param name="Client">The client.</param> /// <remarks></remarks> public override void HandlePacket(MultiplayerServer Server, RemoteClient Client) { if (EntityID != Client.PlayerEntity.ID) { Server.KickPlayer(Client.PlayerEntity.Name, "Hacking!"); return; } if (Action == EntityAction.Crouch || Action == EntityAction.UnCrouch) { Animation animation = Action == EntityAction.Crouch ? Animation.Crouch : Animation.UnCrouch; foreach (RemoteClient c in Server.GetClientsInWorldExcept(Server.GetWorld(Client), Client)) { c.PacketQueue.Enqueue(new AnimationPacket(Client.PlayerEntity.ID, animation)); } } if (Action == EntityAction.LeaveBed) { //Unoccupy the metadata of the block Block bed = Server.GetWorld(Client.PlayerEntity).GetBlock(Client.PlayerEntity.OccupiedBed); //Get the block bed.Metadata = (byte)(bed.Metadata & ~0x4); // Remove flag Server.GetWorld(Client.PlayerEntity).SetBlock(Client.PlayerEntity.OccupiedBed, bed); //Set block Client.PlayerEntity.OccupiedBed = null; //Nullify the clients bed position Server.EnqueueToAllClients(new AnimationPacket(Client.PlayerEntity.ID, Animation.LeaveBed)); } }
/// <summary> /// Initializes a new instance of the <see cref="PacketEventArgs"/> class. /// </summary> /// <param name="PacketID">The packet ID.</param> /// <param name="RemoteClient">The remote client.</param> /// <param name="PacketMode">The packet mode.</param> /// <param name="Packet">The packet.</param> /// <remarks></remarks> public PacketEventArgs(PacketID PacketID, RemoteClient RemoteClient, PacketMode PacketMode, Packet Packet) { this.PacketID = PacketID; this.RemoteClient = RemoteClient; this.Handled = false; this.Packet = Packet; }
public static void Handshake(RemoteClient client, MinecraftServer server, IPacket _packet) { var packet = (HandshakePacket)_packet; if (packet.ProtocolVersion < PacketReader.ProtocolVersion) { client.SendPacket(new DisconnectPacket("Outdated client!")); return; } if (packet.ProtocolVersion > PacketReader.ProtocolVersion) { client.SendPacket(new DisconnectPacket("Outdated server!")); return; } if (server.Clients.Any(c => c.Username == packet.Username)) { client.SendPacket(new DisconnectPacket("")); return; } client.Username = packet.Username; client.Hostname = packet.ServerHostname + ":" + packet.ServerPort; if (server.Settings.OnlineMode) client.AuthenticationHash = CreateHash(); else client.AuthenticationHash = "-"; if (server.Settings.EnableEncryption) client.SendPacket(CreateEncryptionRequest(client, server)); else server.LogInPlayer(client); }
public static void Animation(RemoteClient client, MinecraftServer server, IPacket _packet) { var packet = (AnimationPacket)_packet; var clients = server.EntityManager.GetKnownClients(client.Entity); foreach (var _client in clients) _client.SendPacket(packet); }
public static void PlayerLook(RemoteClient client, MinecraftServer server, IPacket _packet) { var packet = (PlayerLookPacket)_packet; client.Entity.Pitch = packet.Pitch; client.Entity.Yaw = packet.Yaw; client.Entity.HeadYaw = packet.Yaw; }
public override void Send(RemoteClient RemoteClient, Message message) { if (!(message is NetworkMessage)) throw new Exception("Network IE: Can send only networkmessage"); message._fromId = RemoteClient.Id.ToString(); (message as NetworkMessage).FromIP = Addresses[RemoteClient].ToString(); }
/// <summary> /// Initializes a new instance of the <see cref="RespawnPacket"/> class. /// </summary> /// <param name="client">The client.</param> /// <param name="world">The world.</param> /// <remarks></remarks> public RespawnPacket(RemoteClient client, World world) { this.Dimension = client.PlayerEntity.Dimension; this.Difficulty = world.Level.Difficulty; this.GameMode = client.PlayerEntity.GameMode; this.WorldHeight = World.Height; this.LevelType = world.Level.WorldGenerator.Name; }
public override void OnRecived(RemoteClient from, Client to) { Environment.ParentClient.Log(LogLevel.Info, "{1}: удалить файл {0}",RelativePath,from); base.OnRecived(from, to); var fs = Environment.ParentClient.FileSystem as MockFS; var fsobj = fs.Find(RelativePath); if (fsobj == null) return; Environment.ParentClient.FileSystem.Delete(fsobj,FSObjectEvents.remote_delete); }
public override void OnRecived(RemoteClient from, Client to) { base.OnRecived(from, to); if (!string.IsNullOrEmpty(RelativePath)) srcFile = Environment.ParentClient.FileSystem.Find(RelativePath) as BaseFile; if (srcFile == null) { throw new Exception(string.Format("File {0} not fount (request from {1})", RelativePath, from.Id)); Environment.ParentClient.Log(LogLevel.Error, "File {0} not fount (request from {1})", RelativePath, from.Id); } }
public ChatServer() { _packetLogger = new PacketLogger(); _logger = new Logger() { WriteToConsole = true }; _logger.Load(Path.Combine("logs", string.Format("chat_{0}.log", DateTime.Now.ToString("dd-MM-yyyy_HH-mm-ss")))); AppDomain.CurrentDomain.UnhandledException += (s, e) => { Error(s, new ExceptionEventArgs((Exception)e.ExceptionObject)); Environment.Exit(0); }; _packetLogger.Load("chat_packets.log"); _logger.Info("Loading chat_config.xml..."); ChatConfig.Load(); _logger.Info("Setting up servers..."); _server = new TcpServer(IPAddress.Parse(ChatConfig.Instance.IP), ChatConfig.Instance.Port); _server.PacketReceived += HandlePacket; _server.ClientDisconnected += ClientDisconnected; _server.Error += Error; var isMono = Type.GetType("Mono.Runtime") != null; switch (ChatConfig.Instance.AuthRemote.Binding) { case "pipe": if (isMono) { _logger.Error("pipe is not supported in mono, use http!"); Environment.Exit(1); return; } _authRemoteClient = new RemoteClient(ERemoteBinding.Pipe, string.Format("localhost/AuthServer/{0}/", SHA256.ComputeHash(ChatConfig.Instance.AuthRemote.Password))); break; case "tcp": if (isMono) { _logger.Error("pipe is not supported in mono, use http!"); Environment.Exit(1); return; } _authRemoteClient = new RemoteClient(ERemoteBinding.Pipe, string.Format("{0}:{1}/AuthServer/{2}/", ChatConfig.Instance.AuthRemote.Server, ChatConfig.Instance.AuthRemote.Port, SHA256.ComputeHash(ChatConfig.Instance.AuthRemote.Password))); break; case "http": _authRemoteClient = new RemoteClient(ERemoteBinding.Http, string.Format("{0}:{1}/AuthServer/{2}/", ChatConfig.Instance.AuthRemote.Server, ChatConfig.Instance.AuthRemote.Port, SHA256.ComputeHash(ChatConfig.Instance.AuthRemote.Password))); break; default: _logger.Error("Invalid remote binding '{0}' for AuthRemote", ChatConfig.Instance.AuthRemote.Binding); Environment.Exit(1); break; } }
public override void MessageRecieved(RemoteClient client, byte[] data) { if (ServerPingReceived != null) { var stream = new MinecraftStream(new MemoryStream(data)); var eventArgs = new ServerPingEventArgs( stream.ReadInt32(), stream.ReadString(), stream.ReadInt32()); ServerPingReceived(this, eventArgs); } }
public static void ClientStatus(RemoteClient client, MinecraftServer server, IPacket _packet) { var packet = (ClientStatusPacket)_packet; if (packet.Status == ClientStatusPacket.ClientStatus.InitialSpawn) { // Create a hash for session verification AsnKeyBuilder.AsnMessage encodedKey = AsnKeyBuilder.PublicKeyToX509(server.ServerKey); byte[] shaData = Encoding.UTF8.GetBytes(client.AuthenticationHash) .Concat(client.SharedKey) .Concat(encodedKey.GetBytes()).ToArray(); string hash = Cryptography.JavaHexDigest(shaData); // Talk to session.minecraft.net if (server.Settings.OnlineMode) { var webClient = new WebClient(); var webReader = new StreamReader(webClient.OpenRead( new Uri(string.Format(sessionCheckUri, client.Username, hash)))); string response = webReader.ReadToEnd(); webReader.Close(); if (response != "YES") { client.Disconnect("Failed to verify username!"); return; } } var eventArgs = new ConnectionEstablishedEventArgs(client); server.OnConnectionEstablished(eventArgs); if (eventArgs.PermitConnection) server.LogInPlayer(client); else client.Disconnect(eventArgs.DisconnectReason); } else if (packet.Status == ClientStatusPacket.ClientStatus.Respawn) { var world = client.Entity.World; client.Entity.Position = new Vector3( client.Entity.SpawnPoint.X, // FIXME: This seems to drop the player camera from half the height of a login spawn client.Entity.SpawnPoint.Y, client.Entity.SpawnPoint.Z); client.Entity.Health = client.Entity.MaxHealth; client.Entity.Food = 20; client.Entity.FoodSaturation = 20; server.EntityManager.SpawnEntity(world, client.Entity); client.SendPacket(new UpdateHealthPacket(client.Entity.Health, client.Entity.Food, client.Entity.FoodSaturation)); client.SendPacket(new RespawnPacket(Dimension.Overworld, server.Settings.Difficulty, client.GameMode, World.Height, world.WorldGenerator.GeneratorName)); client.SendPacket(new PlayerPositionAndLookPacket(client.Entity.Position.X, client.Entity.Position.Y, client.Entity.Position.Z, client.Entity.Position.Y + PlayerEntity.Height, client.Entity.Yaw, client.Entity.Pitch, true)); } }
/// <summary> /// /// </summary> /// <param name="packet"></param> public void HandleChatPacket(RemoteClient client, string chatMessage) { if (m_customEmotes.ContainsKey(chatMessage.ToLower())) { var animationController = client.GetComponent<Player.PlayerAnimationController>(); animationController.PerformEmote(m_customEmotes[chatMessage.ToLower()]); } else { AddMessage(client.Username, chatMessage); client.SetChatLine(chatMessage); } }
public static void HeldItemChange(RemoteClient client, MinecraftServer server, IPacket _packet) { var packet = (HeldItemChangePacket)_packet; if (packet.SlotIndex < 10 && packet.SlotIndex >= 0) { // TODO: Move the equipment update packet to an OnPropertyChanged event handler client.Entity.SelectedSlot = (short)(InventoryWindow.HotbarIndex + packet.SlotIndex); var clients = server.EntityManager.GetKnownClients(client.Entity); foreach (var _client in clients) _client.SendPacket(new EntityEquipmentPacket(client.Entity.EntityId, EntityEquipmentPacket.EntityEquipmentSlot.HeldItem, client.Entity.Inventory[client.Entity.SelectedSlot])); } }
private void ConnectButtonClick(object sender, RoutedEventArgs e) { if(string.IsNullOrEmpty(ServerBox.Text) || string.IsNullOrEmpty(PasswordBox.Password)) { System.Windows.MessageBox.Show("You didn't fill in the required fields.", "Error!", MessageBoxButton.OK, MessageBoxImage.Error); return; } try { _server = ServerBox.Text; _password = PasswordBox.Password; _rmc = new RemoteClient("BasicHttpBinding_IRemote", new EndpointAddress(_server)); _rmc.Open(); if(!_rmc.Authorize(Utility.MD5String(_password))) { System.Windows.MessageBox.Show("Invalid password entered!", "Error!", MessageBoxButton.OK, MessageBoxImage.Error); _rmc.Close(); return; } } catch(Exception x) { System.Windows.MessageBox.Show(string.Format("Something unexpexted happened! Please report this to devs!{0}{1}---------------------------------------------------------------------------{2}{3}", Environment.NewLine, Environment.NewLine, Environment.NewLine, x), "Error!", MessageBoxButton.OK, MessageBoxImage.Error); _rmc.Close(); return; } MessageTab.IsEnabled = true; System.Windows.MessageBox.Show("Connection successful!", "Success!", MessageBoxButton.OK, MessageBoxImage.Information); _connected = true; }
public static void Handshake(RemoteClient client, MinecraftServer server, IPacket _packet) { var packet = (HandshakePacket)_packet; if (packet.ProtocolVersion < NetworkManager.ProtocolVersion) { client.SendPacket(new DisconnectPacket("Outdated client!")); return; } if (packet.ProtocolVersion > NetworkManager.ProtocolVersion) { client.SendPacket(new DisconnectPacket("Outdated server!")); return; } client.Hostname = packet.ServerHostname + ":" + packet.ServerPort; }
public override void OnRecived(RemoteClient from, Client to) { ////check folder exists Environment.ParentClient.Log(LogLevel.Info, "{1}: Создать папку {0}", Name,from); base.OnRecived(from, to); var fs = Environment.ParentClient.FileSystem; var fsobj = fs.Find(RelativePath) as BaseFolder; if (fsobj == null) fsobj = Environment.ParentClient.FileSystem.CreateFolder(Environment.ParentClient.FileSystem.RootDir, RelativePath, FSObjectEvents.remote_create); Environment.ParentClient.FileSystem.CreateFolder(fsobj, Name, FSObjectEvents.remote_create); }
public static RemoteClient GetInstance(string applicationName) { //读取本地信息 myConfigurationManager = new PPLiveRemoteLibrary.ConfigurationManager(); //读取并应用配置 PPLiveRemoteLibrary.ConfigurationManager.Configure(System.Web.Configuration.WebConfigurationManager.OpenWebConfiguration("/").FilePath); //获取远程对象 manager = System.Activator.CreateInstance(typeof(PPLiveRemoteLibrary.PPLiveRemoteManager)) as PPLiveRemoteLibrary.PPLiveRemoteManager; RemoteClient rc = new RemoteClient(applicationName); return rc; }
public static void PlayerPosition(RemoteClient client, MinecraftServer server, IPacket _packet) { var packet = (PlayerPositionPacket)_packet; client.Entity.FoodExhaustion += (float)client.Entity.Position.DistanceTo( new Vector3(packet.X, packet.Y, packet.Z));// * //(client.Entity.IsSprinting ? 0.1f : 0.01f); // TODO: Swimming if ((packet.Y - client.Entity.Position.Y) > 0) client.Entity.PositiveDeltaY += (packet.Y - client.Entity.Position.Y); else client.Entity.PositiveDeltaY = 0; client.Entity.Position = new Vector3(packet.X, packet.Y, packet.Z); client.UpdateChunksAsync(); }
public static void EncryptionKeyResponse(RemoteClient client, MinecraftServer server, IPacket _packet) { var packet = (EncryptionKeyResponsePacket)_packet; var decryptedToken = server.CryptoServiceProvider.Decrypt(packet.VerificationToken, false); for (int i = 0; i < decryptedToken.Length; i++) { if (decryptedToken[i] != client.VerificationToken[i]) { client.Disconnect("Unable to authenticate."); return; } } client.SharedKey = server.CryptoServiceProvider.Decrypt(packet.SharedSecret, false); client.SendPacket(new EncryptionKeyResponsePacket(new byte[0], new byte[0])); }
public override void OnRecived(RemoteClient from, Client to) { Environment.ParentClient.Log(LogLevel.Info, "{1}: загрузить файл {0}", RelativePath,from); Environment.ParentClient.Log(LogLevel.Info, "Отправка файла {0} на узел {1}", RelativePath, from); base.OnRecived(from, to); var newfilename = Path.Combine(ExchageFolder.FullName,specdir, srcFile.Name); if (File.Exists(newfilename)) File.Delete(newfilename); if (File.Exists(srcFile.RealPath)) File.Copy(srcFile.RealPath, newfilename); // else // from.Send(new SendFileMessage()); from.Send(new SendFileMessage(srcFile,specdir)); }
public override bool CheckRemoteClientState(RemoteClient rc) { Client c = null; // lock (Clients) { for (int i = 0; i < Clients.Count; i++) if (Clients[i].Id == rc.Id) { c = Clients[i]; break; } } if (c == null) return false; var res = (c.State != ClientStates.Offline); return res; }
private void Teleport(Point16 from, Point16 to, bool auto) { Rectangle fromRect = new Rectangle(from.X * 16 - 16, from.Y * 16 - 48, 48, 48); Rectangle toRect = new Rectangle(to.X * 16 - 16, to.Y * 16 - 48, 48, 48); Vector2 delta = new Vector2(toRect.X - fromRect.X, toRect.Y - fromRect.Y); if (!Wiring.blockPlayerTeleportationForOneIteration) { for (int i = 0; i < Main.player.Length; i++) { if (Main.player[i].active && !Main.player[i].dead && !Main.player[i].teleporting && fromRect.Intersects(Main.player[i].getRect())) { if (!CanAuto(i) && auto) { continue; } Vector2 newPos = Main.player[i].position + delta; if (Main.netMode == 2) { RemoteClient.CheckSection(i, newPos, 1); } Main.player[i].Teleport(newPos, 0, 0); if (Main.netMode == 2) { NetMessage.SendData(65, -1, -1, null, 0, (float)i, newPos.X, newPos.Y, 0, 0, 0); } } } } if (!auto) { for (int i = 0; i < Main.npc.Length; i++) { if (Main.npc[i].active && !Main.npc[i].teleporting && Main.npc[i].lifeMax > 5 && !Main.npc[i].boss && !Main.npc[i].noTileCollide) { int type = Main.npc[i].type; if (!NPCID.Sets.TeleportationImmune[type] && fromRect.Intersects(Main.npc[i].getRect())) { Main.npc[i].Teleport(Main.npc[i].position + delta, 0, 0); } } } } }
private static async Task AsyncRPC2(string url) { ConsoleColor color = ConsoleColor.Cyan; RemoteClient client = new RemoteClient(); ColorConsole.WriteLine("AsyncRPC2 -> var task = await client.GetBodyAsync(url);", color); var task = await client.GetBodyAsync(url, "AsyncRPC2", color); ColorConsole.WriteLine("AsyncRPC2 -> WasteTime.Waste(2000);", color); WasteTime.Waste(2000); ColorConsole.WriteLine("AsyncRPC2 -> string html = task;", color); string html = task; ColorConsole.WriteLine("AsyncRPC2 -> end", color); ColorConsole.WriteLine("AsyncRPC2 -> body = ", color); ColorConsole.WriteLine(Limit(html, "AsyncRPC2"), color); }
public static bool IsPlayerLocalServerOwner(int whoAmI) { if (Main.netMode == NetmodeID.MultiplayerClient) { return(Netplay.Connection.Socket.GetRemoteAddress().IsLocalHost()); } for (int i = 0; i < Main.maxPlayers; i++) { RemoteClient client = Netplay.Clients[i]; if (client.State == 10 && i == whoAmI && client.Socket.GetRemoteAddress().IsLocalHost()) { return(true); } } return(false); }
public static void EncryptionKeyResponse(RemoteClient client, MinecraftServer server, IPacket _packet) { var packet = (EncryptionKeyResponsePacket)_packet; var decryptedToken = server.CryptoServiceProvider.Decrypt(packet.VerificationToken, false); for (int i = 0; i < decryptedToken.Length; i++) { if (decryptedToken[i] != client.VerificationToken[i]) { client.Disconnect("Unable to authenticate."); return; } } client.SharedKey = server.CryptoServiceProvider.Decrypt(packet.SharedSecret, false); // Create a hash for session verification AsnKeyBuilder.AsnMessage encodedKey = AsnKeyBuilder.PublicKeyToX509(server.ServerKey); byte[] shaData = Encoding.UTF8.GetBytes(client.ServerId) .Concat(client.SharedKey) .Concat(encodedKey.GetBytes()).ToArray(); string hash = Cryptography.JavaHexDigest(shaData); // Talk to sessionserver.minecraft.net if (server.Settings.OnlineMode) { var webClient = new WebClient(); var webReader = new StreamReader(webClient.OpenRead( new Uri(string.Format(sessionCheckUri, client.Username, hash)))); string response = webReader.ReadToEnd(); webReader.Close(); var json = JToken.Parse(response); if (string.IsNullOrEmpty(response)) { client.Disconnect("Failed to verify username!"); return; } client.UUID = json["id"].Value<string>(); } client.NetworkStream = new AesStream(client.NetworkClient.GetStream(), client.SharedKey); client.NetworkManager.BaseStream = client.NetworkStream; client.EncryptionEnabled = true; var eventArgs = new ConnectionEstablishedEventArgs(client); server.OnConnectionEstablished(eventArgs); if (eventArgs.PermitConnection) server.LogInPlayer(client); else client.Disconnect(eventArgs.DisconnectReason); }
public static void ChatMessage(RemoteClient client, MinecraftServer server, IPacket _packet) { var packet = (ChatMessagePacket)_packet; //LogProvider.Log("<" + client.Username + "> " + packet.Message, LogImportance.Medium); var args = new ChatMessageEventArgs(client, packet.Message); server.OnChatMessage(args); if (!args.Handled) { //var team = server.ScoreboardManager.GetPlayerTeam(client.Username); string chat; //if (team != null) // chat = string.Format("<{0}{1}{2}> {3}", team.PlayerPrefix, client.Username, team.PlayerSuffix, packet.Message); //else chat = string.Format("<{0}> {1}", client.Username, packet.Message); server.SendChat(chat); } }
public static void Handshake(RemoteClient client, Proxy proxy, IPacket _packet) { var packet = (HandshakePacket)_packet; if (packet.ProtocolVersion < PacketReader.ProtocolVersion) { client.SendPacket(new DisconnectPacket("Outdated client!")); return; } if (packet.ProtocolVersion > PacketReader.ProtocolVersion) { client.SendPacket(new DisconnectPacket("Outdated server!")); return; } client.AuthenticationHash = "-"; client.Username = packet.Username; client.SendPacket(CreateEncryptionRequest(client, proxy)); }
public static void ChatMessage(RemoteClient client, MinecraftServer server, IPacket _packet) { var packet = (ChatMessagePacket)_packet; //LogProvider.Log("<" + client.Username + "> " + packet.Message, LogImportance.Medium); var args = new ChatMessageEventArgs(client, packet.Message); server.OnChatMessage(args); if (!args.Handled) { //var team = server.ScoreboardManager.GetPlayerTeam(client.Username); ChatMessage chat; //if (team != null) // chat = string.Format("<{0}{1}{2}> {3}", team.PlayerPrefix, client.Username, team.PlayerSuffix, packet.Message); //else chat = new ChatMessage(string.Format("<{0}> {1}", client.Username, packet.Message)); server.SendChat(chat); } }
public async Task <List <Product> > GetByNameAsync(GetProductsByNameQuery query) { var client = new RemoteClient(); Dictionary <string, string> data = new Dictionary <string, string>(); data.Add("name", query.Name); var response = await client.sendRequest("POST", data); List <Product> products = JsonConvert.DeserializeObject <List <Product> >(response); foreach (var product in products) { product.PriceRecords = product.PriceRecords.Where(x => x.CurrencyCode == "ZAR").ToList(); } return(products); }
//Обработка запрососа на логин private void HandleLogin(RemoteClient client, LoginMessage loginMessage) { //Находим пользователя в базе, у которого имя и пароль имеют переданные логин и пароль var targetaccount = storage.Find(U => U.Name == loginMessage.Name && U.Password == loginMessage.Password); //Если пользователя не найдено if (targetaccount == null) { //отправляем ответ, с инфой о том, что пара логин пароль неверна client.Send(new Response(StatusCode.IncorrectLoginOrPassword)); //Ну и больше ничего не делаем return; } //нашли пользователя, который подходит по переданным параметрам client.UserView = targetaccount; //Отправляем сообщение что всё хорошо, пользотель вошел client.Send(Response.GoodResponse); }
public override void Execute(Server server, RemoteClient user, string text, params string[] parameters) { if (parameters.Length < 2) { user.SendChat(ChatColors.Red + "Insufficient parameters. Use \"/help tell\" for more information."); return; } var client = server.MinecraftServer.GetClient(parameters[0]); if (client == null) { user.SendChat(parameters[0] + " is not online."); return; } var format = server.SettingsProvider.Get <string>("chat.private.format"); client.SendChat(string.Format(format, user.Username, client.Username, text)); }
public override void Execute(Server server, RemoteClient user, string text, params string[] parameters) { if (parameters.Length != 1) { user.SendChat(ChatColors.Red + "Invalid parameters. Use /help op for more information."); return; } var groups = server.GetUserGroups(parameters[0]); if (groups.Contains("server.op")) { user.SendChat(ChatColors.Red + "User is already an op."); return; } groups.Add("server.op"); server.SetUserGroups(parameters[0], groups); server.SendChatToGroup("server.op", ChatColors.Gray + user.Username + " adds " + parameters[0] + " to server.op group."); }
private void clientDisconnectedHandler(RemoteClient client) { Log("clientDisconnectedHandler"); if ( clientWaitingToMatch != null && clientWaitingToMatch.remoteClient != null && clientWaitingToMatch.remoteClient.ClientID == client.ClientID ) { clientWaitingToMatch = null; } if (clientList.ContainsKey(client.ClientID) && clientList[client.ClientID].remoteOpponent != null) { server.Disconnect(clientList[client.ClientID].remoteOpponent.remoteClient); } clientList.Remove(client.ClientID); }
/// <summary> /// Handles the packet. /// </summary> /// <param name="Server">The server.</param> /// <param name="Client">The client.</param> /// <remarks></remarks> public override void HandlePacket(ClassicServer Server, RemoteClient Client) { Client.LoggedIn = true; Client.UserName = UserNameOrServerName; Client.World = Server.MainLevel; Client.PacketQueue.Enqueue(new IdentificationPacket(Server.Server.Name, Server.Server.MotD, Client.UserType)); Client.PlayerID = (byte)(Server.Clients.Count() - 1); Client.PacketQueue.Enqueue(new WorldInitializePacket()); MemoryStream ms = new MemoryStream(); GZipStream s = new GZipStream(ms, CompressionMode.Compress, true); s.Write(BitConverter.GetBytes(IPAddress.HostToNetworkOrder(World.Find(Client.World).Data.Length)), 0, sizeof(int)); s.Write(World.Find(Client.World).Data, 0, World.Find(Client.World).Data.Length); s.Close(); byte[] data = ms.GetBuffer(); ms.Close(); double numChunks = data.Length / 1024; double chunksSent = 0; for (int i = 0; i < data.Length; i += 1024) { byte[] chunkData = new byte[1024]; short chunkLength = 1024; if (data.Length - i < chunkLength) { chunkLength = (short)(data.Length - i); } Array.Copy(data, i, chunkData, 0, chunkLength); Client.PacketQueue.Enqueue(new WorldDataChunkPacket(chunkLength, chunkData, (byte)((chunksSent / numChunks) * 100))); chunksSent++; } Client.PacketQueue.Enqueue(new WorldFinalizePacket(World.Find(Client.World).Width, World.Find(Client.World).Height, World.Find(Client.World).Depth)); Client.Position = World.Find(Client.World).Spawn.Clone(); Client.Yaw = 0; Client.Pitch = 0; unchecked { Client.PacketQueue.Enqueue(new PositionAndOrientationPacket((byte)-1, Client.Position, Client.Yaw, Client.Pitch)); } Server.LoadAllClientsToClient(Client); Server.EnqueueToAllClientsInWorld(new SpawnPlayerPacket(Client.PlayerID, Client.UserName, Client.Position, Client.Yaw, Client.Pitch), Client.World, Client); }
public override void Execute(Server server, RemoteClient user, string text, params string[] parameters) { string player = user.Username; GameMode gameMode; if (parameters.Length == 0 || parameters.Length > 2) { user.SendChat(ChatColors.Red + "Incorrect usage. Use /help gamemode for more information."); return; } int value; if (int.TryParse(parameters[0], out value)) { if (value < 0 || value > 2) { user.SendChat(ChatColors.Red + "Incorrect usage. Use /help gamemode for more information."); return; } gameMode = (GameMode)value; } else { if (!Enum.TryParse <GameMode>(parameters[0], true, out gameMode)) { user.SendChat(ChatColors.Red + "Incorrect usage. Use /help gamemode for more information."); return; } } if (parameters.Length == 2) { player = parameters[1]; } var client = server.MinecraftServer.GetClient(player); if (client == null) { user.SendChat(ChatColors.Red + player + " is not online."); // TODO: Set it anyway return; } client.GameMode = gameMode; server.SendChatToGroup("server.op", ChatColors.Gray + user.Username + " sets " + player + " to " + gameMode + " mode."); }
static void Main(string[] args) { try { RemoteClient client = new RemoteClient(); while (true) { Console.WriteLine("1. Ping"); Console.WriteLine("2. Echo"); Console.WriteLine("3. Login"); Console.WriteLine("Enter command:"); var choose = int.Parse(Console.ReadLine()); switch (choose) { case 1: Console.WriteLine(client.Ping()); break; case 2: Console.WriteLine("Enter text: "); var text = Console.ReadLine(); Console.WriteLine(client.Echo(text)); break; case 3: Console.WriteLine("Enter name: "); var name = Console.ReadLine(); Console.WriteLine("Enter pass: "******"Press <ENTER> to terminate client."); Console.ReadLine(); } catch (EndpointNotFoundException ex) { Console.WriteLine("Service endpoint not found: {0}", ex.Message); Console.ReadLine(); } }
static void Main(string[] args) { var data = new string[] { "1", "2", "3" }; var remoteService = new RemoteService(); var remoteClient = new RemoteClient(remoteService); var result = remoteClient.SendData(data); foreach (var item in result.Exceptions) { System.Console.WriteLine(item.Message); } }
public override void Execute(Server server, RemoteClient user, string text, params string[] parameters) { if (parameters.Length > 2 || parameters.Length == 0) { user.SendChat(ChatColors.Red + "Incorrect usage. Use /help speed for more information."); return; } if (parameters[0].ToLower() == "reset") { user.Entity.Abilities.WalkingSpeed = 12; user.Entity.Abilities.FlyingSpeed = 24; return; } string player = user.Username; int speed; if (parameters.Length == 2) { player = parameters[0]; if (!int.TryParse(parameters[1], out speed)) { user.SendChat(ChatColors.Red + "Incorrect usage. Use /help speed for more information."); return; } } else { if (!int.TryParse(parameters[0], out speed)) { user.SendChat(ChatColors.Red + "Incorrect usage. Use /help speed for more information."); return; } } var client = server.MinecraftServer.GetClient(player); if (client == null) { user.SendChat(ChatColors.Red + player + " is not online."); return; } client.Entity.Abilities.WalkingSpeed = (byte)speed; client.Entity.Abilities.FlyingSpeed = (byte)(speed * 2); }
/// <summary> /// Disconnects this connection. /// </summary> public void Disconnect() { if (_disconnectCalls > 0) { return; } _disconnectCalls++; _writeDone.WaitOne(); try { ClientDisconnected(this, EventArgs.Empty); } catch { // ignore } try { #if !NET452 RemoteClient.Dispose(); SecureStream?.Dispose(); NetworkStream?.Dispose(); #else RemoteClient.Close(); SecureStream?.Close(); NetworkStream?.Close(); #endif } catch { // ignored } finally { NetworkStream = null; SecureStream = null; RemoteClient = null; _continuousReadingThread = null; } }
private IEnumerator ConnectServer() { rc = new RemoteClient(ml); rc.evtHandler = EvtHandler; rc.msgHandler = MsgHandler; rc.Connect("127.0.0.1", 12031); while (lastEvt == RemoteClientEvent.None) { yield return(null); } if (lastEvt == RemoteClientEvent.Connected) { //var logic = gameObject.AddComponent<Logic>(); //logic.Init(); var mobaLogic = gameObject.AddComponent <MobaLogic>(); mobaLogic.Init(); } }
public static void ClientStatus(RemoteClient client, Proxy proxy, IPacket _packet) { var packet = (ClientStatusPacket)_packet; if (packet.Status == ClientStatusPacket.ClientStatus.InitialSpawn) { // Throw them into an empty world and inform them that we'll be connecting them shortly. client.SendPacket(new LoginRequestPacket(1, "FLAT", GameMode.Creative, Dimension.Overworld, Difficulty.Normal, 100)); client.SendPacket(new PlayerAbilitiesPacket(0, 0.05f, 0.1f)); client.SendPacket(new EntityPropertiesPacket(1, new[] { new EntityProperty("generic.movementSpeed", 0.05f) })); client.SendPacket(new PlayerPositionAndLookPacket(0, 1.72, 0, 0.1, 0, 0, false)); client.SendChat(ChatColors.Yellow + "Connecting to the classic server, please wait."); proxy.Connect(client); } else if (packet.Status == ClientStatusPacket.ClientStatus.Respawn) { // TODO } }
/// <summary> /// Connect to DF, and register basic RPC functions. /// </summary> void Connect() { blockRequest.blocks_needed = BlocksToFetch; networkClient = new RemoteClient(dfNetworkOut); bool success = networkClient.Connect(); if (!success) { networkClient.Disconnect(); networkClient = null; ModalPanel.Instance.Choice( "Armok Vision could not find a running instance of Dwarf Fortress!\n\n" + "Please make sure you have Dwarf Fortress running, with the latest version of DFHack installed.", Connect, QuitGame, "Retry", "Quit"); throw new UnityException("DF Connection Failure"); } BindStaticMethods(); if (dfWorldInfoCall != null) { dfWorldInfoCall.TryExecute(null, out netWorldInfo); if (netWorldInfo == null) { Debug.Log("World not loaded."); } else { Debug.Log("World Mode: " + netWorldInfo.mode); WorldMode = netWorldInfo.mode; } } if (GameSettings.Instance.game.askToUpdatePlugin) { CheckPlugin(); } else { Init(); } }
/// <summary> /// Initializes a new instance of the <see cref="TcpClientConnectionHandler" /> class. /// </summary> /// <param name="server">The underlying server.</param> /// <param name="client">The underlying client.</param> /// <exception cref="ArgumentNullException"> /// At least one argument is <see langword="null" />. /// </exception> public TcpClientConnectionHandler(Server server, RemoteClient client) { if (server == null) { throw new ArgumentNullException("server"); } if (client == null) { throw new ArgumentNullException("client"); } this._STREAM = new NetworkStream(client.Client.Client, true); this._REMOTE_CLIENT = client; this._SERVER = server; this.CloseConnection = true; }
private static async void AsyncRPC1(string url) { ConsoleColor color = ConsoleColor.DarkYellow; RemoteClient client = new RemoteClient(); ColorConsole.WriteLine("AsyncRPC1 -> var task = client.GetBodyAsync(url);", color); var task = client.GetBodyAsync(url, "AsyncRPC1", color); ColorConsole.WriteLine("AsyncRPC1 -> WasteTime.Waste(2000);", color); WasteTime.Waste(2000); ColorConsole.WriteLine("AsyncRPC1 -> string html = await task;", color); string html = await task; ColorConsole.WriteLine("AsyncRPC1 -> Task.WaitAll(task);", color); Task.WaitAll(task); ColorConsole.WriteLine("AsyncRPC1 -> end", color); ColorConsole.WriteLine("AsyncRPC1 -> body = ", color); ColorConsole.WriteLine(Limit(html, "AsyncRPC1"), color); }
public override void Execute(Server server, RemoteClient user, string text, params string[] parameters) { Server = server; if (parameters.Length != 0) { user.SendChat(ChatColors.Red + "Invalid parameters. Use /help repl for more information."); return; } if (ReplContext.Self != null) { user.SendChat(ChatColors.Red + ReplContext.Self.Username + " is currently in REPL mode. Only one user may be in REPL mode at a time."); // TODO: Upgrade Mono.CSharp to Mono 3.0 and support several REPLs at once return; } server.ChatMessage -= HandleChatMessage; server.ChatMessage += HandleChatMessage; server.MinecraftServer.PlayerLoggedOut += (s, e) => { if (Evaluators.ContainsKey(e.Username)) { Evaluators.Remove(e.Username); } ReplContext.Self = null; }; Evaluators[user.Username] = new Evaluator(new CompilerContext(new CompilerSettings(), new MinecraftReportPrinter(user))); Evaluators[user.Username].ReferenceAssembly(typeof(Server).Assembly); Evaluators[user.Username].ReferenceAssembly(typeof(MinecraftServer).Assembly); Evaluators[user.Username].ReferenceAssembly(typeof(Craft.Net.Networking.IPacket).Assembly); Evaluators[user.Username].ReferenceAssembly(typeof(World).Assembly); Evaluators[user.Username].ReferenceAssembly(typeof(IServer).Assembly); Evaluators[user.Username].InteractiveBaseClass = typeof(ReplContext); Evaluators[user.Username].Run("using Craft.Net"); Evaluators[user.Username].Run("using Craft.Net.Data"); Evaluators[user.Username].Run("using Craft.Net.Data.Blocks"); Evaluators[user.Username].Run("using Craft.Net.Data.Items"); Evaluators[user.Username].Run("using Craft.Net.Server"); Evaluators[user.Username].Run("using PartyCraft"); ReplContext.Self = user; ReplContext.Server = server; user.SendChat(ChatColors.Blue + "Entering C# Interactive Mode"); user.SendChat(ChatColors.Blue + "Use `Exit()` to exit REPL mode."); }
public override void Execute(Server server, RemoteClient user, string text, params string[] parameters) { string player = user.Username; int x = (int)user.Entity.Position.X; int y = (int)user.Entity.Position.Y; int z = (int)user.Entity.Position.Z; if (parameters.Length == 1) { player = parameters[0]; } else if (parameters.Length == 3) { if (!int.TryParse(parameters[0], out x) && !int.TryParse(parameters[1], out y) && !int.TryParse(parameters[2], out z)) { user.SendChat(ChatColors.Red + "Incorrect usage. Use /help spawnpoint for more information."); return; } } else if (parameters.Length == 4) { player = parameters[0]; if (!int.TryParse(parameters[1], out x) && !int.TryParse(parameters[2], out y) && !int.TryParse(parameters[3], out z)) { user.SendChat(ChatColors.Red + "Incorrect usage. Use /help spawnpoint for more information."); return; } } var client = server.MinecraftServer.GetClient(player); if (player == null) { user.SendChat(ChatColors.Red + player + " is not online."); // TODO: Set it anyway return; } client.Entity.SpawnPoint = new Vector3(x, y, z); server.SendChatToGroup("server.op", user.Username + " set " + player + " spawn point to " + client.Entity.SpawnPoint); }
//Метод обработки конкретного клиента private async Task HandleClient(TcpClient client) { //Оборачиваем TcpClient в наш собственный класс RemoteClient //Сделано для сопоставления TCP соединения и нашей моделей пользователя //Чтобы понимать, по какому соединению необходимо отправлять данные RemoteClient remoteClient = new RemoteClient( //Аргументом является функция отправки сообщения //Этому клиенту. Мы и пишем, что при отправке сообщения //Этому клиенту надо отправить данное сообщение именно на этот client R => SendResponseToClient(R, client)); //Вызываем событие о том, что клиент присоединился. //Так внешний код сможет узнать о том, что подсоединился новый клиент //И начать следить ща его действиями ClientAccepted?.Invoke(remoteClient); //Пока не отменили работу while (!cancellationToken.IsCancellationRequested) { //Буффер для хранения длины сообщения var messageLength = new byte[4]; //Буффер для хранения самого сообщения var buffer = new byte[4096]; //Читаем 4 байта, представляющие длину сообщения await client.GetStream().ReadAsync(messageLength, 0, 4); //Преобразуем эти 4 байта в число var length = BitConverter.ToInt32(messageLength, 0); //Читаем все сообщение в спец буффер для сообщения //Читаем именно нужное нам колчество денег await client.GetStream().ReadAsync(buffer, 0, length); //Получаем из считанныз байт саму строку JSON //которую нам прислал клиент var jsonString = Encoding.UTF8.GetString(buffer, 0, length); //Разбираем строку и кладем все данные в JToken var token = JToken.Parse(jsonString); //Выводим сообщение о том, что мы получили некое сообщение Console.WriteLine("Received message"); //Уведомляем клиента о том, что пришло новое сообщение remoteClient.Notify(token); } }
/// <summary> /// Configures the splash screen and initializes the main application form /// This runs once the splash screen is visible. /// </summary> protected override void OnCreateMainForm() { CommandLineArgs parameters = new CommandLineArgs(CommandLineArgs); if (parameters.Hide || !Environment.UserInteractive) { SplashScreen.SafeInvoke( () => ((TVRenameSplash)SplashScreen).Visible = false, true); } // Update splash screen SplashScreen.SafeInvoke( () => ((TVRenameSplash)SplashScreen).UpdateStatus("Initializing"), true); // Update RegVersion to bring the WebBrowser up to speed RegistryHelper.UpdateBrowserEmulationVersion(); TVDoc doc = LoadSettings(parameters); if (TVSettings.Instance.mode == TVSettings.BetaMode.BetaToo || TVSettings.Instance.ShareLogs) { SetupLogging(); } // Show user interface UI ui = new UI(doc, (TVRenameSplash)SplashScreen, !parameters.Unattended && !parameters.Hide && Environment.UserInteractive); ui.Text = ui.Text + " " + Helpers.DisplayVersion; // Bind IPC actions to the form, this allows another instance to trigger form actions try { RemoteClient.Bind(ui); } catch (RemotingException ex) { Logger.Warn( $"Could not create IPC Port: {ex.Message} : TV Rename will not be able to accept incoming commands"); } MainForm = ui; }
public static void PlayerPosition(RemoteClient client, MinecraftServer server, IPacket _packet) { var packet = (PlayerPositionPacket)_packet; client.Entity.FoodExhaustion += (float)client.Entity.Position.DistanceTo( new Vector3(packet.X, packet.Y, packet.Z));// * //(client.Entity.IsSprinting ? 0.1f : 0.01f); // TODO: Swimming if ((packet.Y - client.Entity.Position.Y) > 0) { client.Entity.PositiveDeltaY += (packet.Y - client.Entity.Position.Y); } else { client.Entity.PositiveDeltaY = 0; } client.Entity.Position = new Vector3(packet.X, packet.Y, packet.Z); client.UpdateChunksAsync(); }
public static void SyncError(RemoteClient Sender, Dictionary <String, Object> ErrorLog0, Dictionary <String, Object> ErrorLog1, Dictionary <String, Object> ErrorLog2) { string level = StormLib.Console.GetValue("Debugging_Level").Value; switch (level) { default: case "0": // Sender.SyncError(ErrorLog0); break; case "1": // Sender.SyncError(ErrorLog1); break; case "2": // Sender.SyncError(ErrorLog2); break; } }
private void Server_OnClientDisconnected(RemoteClient client) { logLine("Client disconnected: " + client.RemoteEndpoint.ToString()); clients--; NumClientsText.text = clients.ToString() + "/" + MaxClients.ToString(); /*Destroy(players[client].gameObject); * players.Remove(client); * endpointsByClient[client].Reset(); * endpointsByClient.Remove(client); */ PLAYER_DISCONNECTED.Send(client); //if less than 1 player -> stop send position data to clients if (players.Count < 1) { StopCoroutine(updateSender()); } }
private void Window_Loaded(object sender, RoutedEventArgs e) { //this.Code.ItemsSource = Encoding.GetEncodings().Select(m => m.DisplayName); var rdp = new RemoteClient(Protocol.SSH); if (this.Client != null) { this.SSH.DataContext = this.Client; this.Password.Password = LibRDP.Utils.DecryptChaCha20(this.Client.RInfo.Password, Properties.Settings.Default.Nonce, Properties.Settings.Default.SHA256); this.Btn.Content = "修改"; this.Window.Header = "修改" + Protocol.SSH + "桌面参数"; } else { this.SSH.DataContext = rdp; this.Btn.Content = "添加"; this.Window.Header = "新建" + Protocol.SSH + "桌面"; } }
public override void HandlePacket(BinaryReader reader, int whoAmI) { var msgType = (MessageType)reader.ReadByte(); switch (msgType) { case MessageType.AddLink: var transmitter = new Point16(reader.ReadInt16(), reader.ReadInt16()); var receiver = new Point16(reader.ReadInt16(), reader.ReadInt16()); if (!WirelessUtils.AlreadyExists(transmitter, receiver)) { WirelessSystem.Links[transmitter] = receiver; if (Main.netMode == NetmodeID.Server) //Server-side { SyncAddLink(transmitter, receiver, whoAmI); //Broadcast the change to other clients } } break; case MessageType.RemoveLink: transmitter = new Point16(reader.ReadInt16(), reader.ReadInt16()); WirelessSystem.Links.Remove(transmitter); if (Main.netMode == NetmodeID.Server) { SyncRemoveLink(transmitter, whoAmI); } break; case MessageType.TripWire: receiver = new Point16(reader.ReadInt16(), reader.ReadInt16()); ActivateReceiver(receiver); if (Main.netMode == NetmodeID.Server) { RemoteClient.CheckSection(whoAmI, receiver.ToWorldCoordinates()); } break; } }
private static void RunTeleport(Player player, Vector2 pos, bool syncData = false, bool convertFromTiles = false) { bool postImmune = player.immune; int postImmunteTime = player.immuneTime; if (convertFromTiles) { pos = new Vector2(pos.X * 16 + 8 - player.width / 2, pos.Y * 16 - player.height); } LeaveDust(player); //Kill hooks player.grappling[0] = -1; player.grapCount = 0; for (int index = 0; index < 1000; ++index) { if (Main.projectile[index].active && Main.projectile[index].owner == player.whoAmI && Main.projectile[index].aiStyle == 7) { Main.projectile[index].Kill(); } } player.Teleport(pos, 2, 0); player.velocity = Vector2.Zero; player.immune = postImmune; player.immuneTime = postImmunteTime; LeaveDust(player); if (Main.netMode != 2) { return; } if (syncData) { RemoteClient.CheckSection(player.whoAmI, player.position, 1); NetMessage.SendData(65, -1, -1, null, 0, (float)player.whoAmI, pos.X, pos.Y, 3, 0, 0); } }
public static void LoginStart(RemoteClient client, MinecraftServer server, IPacket _packet) { var packet = (LoginStartPacket)_packet; if (server.Clients.Any(c => c.IsLoggedIn && c.Username == packet.Username)) client.Disconnect("You're already on this server!"); else { client.Username = packet.Username; if (server.Settings.OnlineMode) client.ServerId = CreateId(); else { client.ServerId = CreateId(); client.UUID = Guid.NewGuid().ToJavaUUID(); } if (server.Settings.EnableEncryption) client.SendPacket(CreateEncryptionRequest(client, server)); else server.LogInPlayer(client); } }
public override void Send(RemoteClient RemoteClient, Messages.Message message) { ///Remote Client must be offline ///this ckeck must be in remoteclient.send Tasks.Enqueue(new Task(() => { lock (Clients) { message.Environment = this; if (!Clients.Any(x => x.Id == RemoteClient.Id)) { ParentClient.Log(LogLevel.Error, "Не могу послать сообщение {0} узлу {1}. Похоже что он оффлайн", message, RemoteClient); return; } var B = Clients.FirstOrDefault(x => x.Id == RemoteClient.Id).Environment; if (B == null) throw new Exception("client not ready or offline"); var m = Message.Decode(message.Code(), B); var remote = B.RemoteClients.First(x => x.Id == m.FromId); B.EmitMessageRecived(remote, m); } }, string.Format("Message {0} to {1} sended", message.Type, RemoteClient.Id) )); m_signal.Set(); }
public SendQueue(RemoteClient client) { this.client = client; freeLargeBlocks = new int[maxLargeBlocks]; freeSmallBlocks = new int[maxSmallBlocks]; for (int i = 0; i < maxLargeBlocks; i++) { freeLargeBlocks[i] = 1; } for (int i = 0; i < maxSmallBlocks; i++) { freeSmallBlocks[i] = 1; } queuedLargeBlocks = new bool[maxLargeBlocks]; queuedSmallBlocks = new bool[maxSmallBlocks]; largeObjectHeap = new byte[maxLargeBlocks * kSendQueueLargeBlockSize]; smallObjectHeap = new byte[maxSmallBlocks * kSendQueueSmallBlockSize]; }
public static void CreativeInventoryAction(RemoteClient client, MinecraftServer server, IPacket _packet) { var packet = (CreativeInventoryActionPacket)_packet; if (packet.SlotIndex == -1) { var entity = new ItemEntity(client.Entity.Position + new Vector3(0, client.Entity.Size.Height, 0), packet.Item); entity.Velocity = MathHelper.FowardVector(client.Entity.Yaw) * new Vector3(0.25); server.EntityManager.SpawnEntity(client.Entity.World, entity); } else if (packet.SlotIndex < client.Entity.Inventory.Length && packet.SlotIndex > 0) { client.Entity.Inventory[packet.SlotIndex] = packet.Item; if (packet.SlotIndex == client.Entity.SelectedSlot) { var clients = server.EntityManager.GetKnownClients(client.Entity); foreach (var _client in clients) _client.SendPacket(new EntityEquipmentPacket(client.Entity.EntityId, EntityEquipmentPacket.EntityEquipmentSlot.HeldItem, client.Entity.Inventory[packet.SlotIndex])); } } }