/// <summary> /// Initializes a new instance of the <see cref="PlayerConnectionEventArgs"/> class. /// </summary> /// <param name="ConnectionState">State of the connection.</param> /// <param name="Client">The client.</param> /// <remarks></remarks> public PlayerConnectionEventArgs(ConnectionState ConnectionState, RemoteClient Client) { this.ConnectionState = ConnectionState; this.Client = Client; }
/// <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); }
/// <summary> /// Writes a packet to a RemoteClient. /// </summary> /// <param name="Client">The RemoteClient to be written to.</param> public abstract void WritePacket(RemoteClient Client);
/// <summary> /// Reads the packet. /// </summary> /// <param name="Client">The client.</param> /// <remarks></remarks> public override void ReadPacket(RemoteClient Client) { this.PlayerID = (byte)Client.TcpClient.GetStream().ReadByte(); this.Position.X = ReadShort(Client.TcpClient.GetStream()); this.Position.Y = ReadShort(Client.TcpClient.GetStream()); this.Position.Z = ReadShort(Client.TcpClient.GetStream()); this.Yaw = (byte)Client.TcpClient.GetStream().ReadByte(); this.Pitch = (byte)Client.TcpClient.GetStream().ReadByte(); }
/// <summary> /// Does the work. /// </summary> /// <param name="o">The object.</param> /// <remarks></remarks> protected void DoWork(object o) { if (listener.Pending()) { RemoteClient c = new RemoteClient(); c.TcpClient = listener.AcceptTcpClient(); c.EndPoint = c.TcpClient.Client.RemoteEndPoint; Clients.Add(c); } int totalQueuedPackets = 0; for (int i = 0; i < Clients.Count; i++) { totalQueuedPackets += Clients[i].PacketQueue.Count; } // Any leftover time from each client is given to any client that could use it double additionalTime = 0; for (int i = 0; i < Clients.Count; i++) { if (!Clients[i].TcpClient.Connected) { if (OnPlayerConnectionChanged != null && Clients[i].LoggedIn) { OnPlayerConnectionChanged(this, new PlayerConnectionEventArgs(ConnectionState.Disconnected, Clients[i])); } EnqueueToAllClientsInWorld(new DespawnPlayerPacket((byte)i), Clients[i].World); } else { try { // Read in a packet if (Clients[i].TcpClient.Available != 0) { Packet p = Packet.GetPacket((PacketID)Clients[i].TcpClient.GetStream().ReadByte(), true); if (PrePacketEvent != null) { PrePacketEvent(this, new PrePacketEventArgs(p, Clients[i])); } if (cancelprepacket) { cancelprepacket = false; goto here; } p.ReadPacket(Clients[i]); p.HandlePacket(this, Clients[i]); if (p.PacketID == PacketID.Identification && OnPlayerConnectionChanged != null) { OnPlayerConnectionChanged(this, new PlayerConnectionEventArgs(ConnectionState.Connected, Clients[i])); } } here: // Write out from the packet queue if (Clients[i].PacketQueue.Count == 0) { continue; } // For the sake of server speed, each client is limited in the amount // of time per tick they are allocated for sending of packets. DateTime startTime = DateTime.Now; double maxClientSendTime = double.PositiveInfinity; if (!(totalQueuedPackets == 0 || Clients[i].PacketQueue.Count / totalQueuedPackets == 0)) { maxClientSendTime = (1 / 20) * (Clients[i].PacketQueue.Count / totalQueuedPackets) + additionalTime; } additionalTime = 0; while (Clients[i].PacketQueue.Count != 0 && (DateTime.Now - startTime).TotalMilliseconds <= maxClientSendTime) { // Send out packets from the queue PacketID id = Clients[i].PacketQueue.Peek().PacketID; Clients[i].PacketQueue.Dequeue().WritePacket(Clients[i]); if (id == PacketID.DisconnectPlayer) { if (Clients[i].TcpClient.Connected) { Clients[i].TcpClient.Close(); } if (OnPlayerConnectionChanged != null) { OnPlayerConnectionChanged(this, new PlayerConnectionEventArgs(ConnectionState.Disconnected, Clients[i])); } EnqueueToAllClientsInWorld(new DespawnPlayerPacket((byte)i), Clients[i].World); Clients.RemoveAt(i); i--; break; } } if ((DateTime.Now - startTime).TotalMilliseconds <= maxClientSendTime) { additionalTime += maxClientSendTime - (DateTime.Now - startTime).TotalMilliseconds; } } catch { if (OnPlayerConnectionChanged != null && Clients[i].LoggedIn) { OnPlayerConnectionChanged(this, new PlayerConnectionEventArgs(ConnectionState.Disconnected, Clients[i])); } EnqueueToAllClients(new DespawnPlayerPacket((byte)i), Clients[i]); //TODO: Find out why this exceptions. Clients.RemoveAt(i); i--; } } } netWorker = new Timer(new TimerCallback(DoWork), null, 0, Timeout.Infinite); }
/// <summary> /// Enqueues to all clients in a certain world. /// </summary> /// <param name="Packet">The packet.</param> /// <param name="World">The world.</param> /// <param name="IgnoreClient">If specified, the client won't recieve the packet.</param> /// <remarks></remarks> public void EnqueueToAllClientsInWorld(Packet Packet, string World, RemoteClient IgnoreClient = null) { foreach (RemoteClient Client in Clients) if (IgnoreClient != Client && Client.World.ToLower() == World.ToLower()) Client.PacketQueue.Enqueue(Packet); }
/// <summary> /// Does the work. /// </summary> /// <param name="o">The object.</param> /// <remarks></remarks> protected void DoWork(object o) { if (listener.Pending()) { RemoteClient c = new RemoteClient(); c.TcpClient = listener.AcceptTcpClient(); c.EndPoint = c.TcpClient.Client.RemoteEndPoint; Clients.Add(c); } int totalQueuedPackets = 0; for (int i = 0; i < Clients.Count; i++) totalQueuedPackets += Clients[i].PacketQueue.Count; // Any leftover time from each client is given to any client that could use it double additionalTime = 0; for (int i = 0; i < Clients.Count; i++) { if (!Clients[i].TcpClient.Connected) { if (OnPlayerConnectionChanged != null && Clients[i].LoggedIn) OnPlayerConnectionChanged(this, new PlayerConnectionEventArgs(ConnectionState.Disconnected, Clients[i])); EnqueueToAllClientsInWorld(new DespawnPlayerPacket((byte)i), Clients[i].World); } else { try { // Read in a packet if (Clients[i].TcpClient.Available != 0) { Packet p = Packet.GetPacket((PacketID)Clients[i].TcpClient.GetStream().ReadByte(), true); if (PrePacketEvent != null) PrePacketEvent(this, new PrePacketEventArgs(p, Clients[i])); if (cancelprepacket) { cancelprepacket = false; goto here; } p.ReadPacket(Clients[i]); p.HandlePacket(this, Clients[i]); if (p.PacketID == PacketID.Identification && OnPlayerConnectionChanged != null) OnPlayerConnectionChanged(this, new PlayerConnectionEventArgs(ConnectionState.Connected, Clients[i])); } here: // Write out from the packet queue if (Clients[i].PacketQueue.Count == 0) continue; // For the sake of server speed, each client is limited in the amount // of time per tick they are allocated for sending of packets. DateTime startTime = DateTime.Now; double maxClientSendTime = double.PositiveInfinity; if (!(totalQueuedPackets == 0 || Clients[i].PacketQueue.Count / totalQueuedPackets == 0)) maxClientSendTime = (1 / 20) * (Clients[i].PacketQueue.Count / totalQueuedPackets) + additionalTime; additionalTime = 0; while (Clients[i].PacketQueue.Count != 0 && (DateTime.Now - startTime).TotalMilliseconds <= maxClientSendTime) { // Send out packets from the queue PacketID id = Clients[i].PacketQueue.Peek().PacketID; Clients[i].PacketQueue.Dequeue().WritePacket(Clients[i]); if (id == PacketID.DisconnectPlayer) { if (Clients[i].TcpClient.Connected) Clients[i].TcpClient.Close(); if (OnPlayerConnectionChanged != null) OnPlayerConnectionChanged(this, new PlayerConnectionEventArgs(ConnectionState.Disconnected, Clients[i])); EnqueueToAllClientsInWorld(new DespawnPlayerPacket((byte)i), Clients[i].World); Clients.RemoveAt(i); i--; break; } } if ((DateTime.Now - startTime).TotalMilliseconds <= maxClientSendTime) additionalTime += maxClientSendTime - (DateTime.Now - startTime).TotalMilliseconds; } catch { if (OnPlayerConnectionChanged != null && Clients[i].LoggedIn) OnPlayerConnectionChanged(this, new PlayerConnectionEventArgs(ConnectionState.Disconnected, Clients[i])); EnqueueToAllClients(new DespawnPlayerPacket((byte)i), Clients[i]); //TODO: Find out why this exceptions. Clients.RemoveAt(i); i--; } } } netWorker = new Timer(new TimerCallback(DoWork), null, 0, Timeout.Infinite); }
/// <summary> /// Reads the packet. /// </summary> /// <param name="Client">The client.</param> /// <remarks></remarks> public override void ReadPacket(RemoteClient Client) { throw new InvalidOperationException(); }
public PrePacketEventArgs(Packet packet, RemoteClient client) { this.Packet = packet; this.Client = client; }
/// <summary> /// Reads the packet. /// </summary> /// <param name="Client">The client.</param> /// <remarks></remarks> public override void ReadPacket(RemoteClient Client) { Position.X = ReadShort(Client.TcpClient.GetStream()); Position.Y = ReadShort(Client.TcpClient.GetStream()); Position.Z = ReadShort(Client.TcpClient.GetStream()); this.Mode = (byte)Client.TcpClient.GetStream().ReadByte(); this.Type = (byte)Client.TcpClient.GetStream().ReadByte(); }
public PlayerDisconnectEvent(RemoteClient player) { this.player = player; }
/// <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) { World.Find(Client.World)._SetBlock(Position, Type); //Send the block to all clients. if (Mode != 0) Server.EnqueueToAllClients(new ServerSetBlockPacket(Position, Type)); else Server.EnqueueToAllClients(new ServerSetBlockPacket(Position, 0)); }
/// <summary> /// Reads the packet. /// </summary> /// <param name="Client">The client.</param> /// <remarks></remarks> public override void ReadPacket(RemoteClient Client) { this.ProtocolVersion = (byte)Client.TcpClient.GetStream().ReadByte(); this.UserNameOrServerName = ReadString(Client.TcpClient.GetStream()); this.VerificationKeyOrMOTD = ReadString(Client.TcpClient.GetStream()); Client.TcpClient.GetStream().ReadByte(); }
public PlayerChatEvent(RemoteClient player, string Message) { this.player = player; this.Message = Message; }
public OnPlayerConnectEvent(RemoteClient player) { this.player = player; }
/// <summary> /// Enqueues a packet to all clients. /// </summary> /// <param name="Packet">The packet.</param> /// <param name="IgnoreClient">If specified, the client won't recieve the packet.</param> /// <remarks></remarks> public void EnqueueToAllClients(Packet Packet, RemoteClient IgnoreClient = null) { foreach (RemoteClient Client in Clients) if (IgnoreClient != Client) Client.PacketQueue.Enqueue(Packet); }
/// <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) { throw new NotImplementedException(); }
/// <summary> /// Loads all players to client. /// </summary> /// <param name="Client">The client.</param> /// <remarks></remarks> public void LoadAllClientsToClient(RemoteClient Client) { foreach (RemoteClient others in Clients) if (others != Client) Client.PacketQueue.Enqueue(new SpawnPlayerPacket(others.PlayerID, others.UserName, others.Position, others.Yaw, others.Pitch)); }
/// <summary> /// Reads the packet. /// </summary> /// <param name="Client">The client.</param> /// <remarks></remarks> public override void ReadPacket(RemoteClient Client) { throw new NotImplementedException(); }
/// <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.Position = Position; Position.X = Position.X / 32; Position.Y = Position.Y / 32; Position.Z = Position.Z / 32; Client.Yaw = Yaw; Client.Pitch = Pitch; Server.EnqueueToAllClientsInWorld(new PositionAndOrientationPacket(Client.PlayerID, Position, Yaw, Pitch), Client.World, Client); }
/// <summary> /// Deals with an incoming packet from a RemoteClient/ClassicServer /// </summary> /// <param name="Server">The server involved</param> /// <param name="Client">The RemoteClient involved</param> public abstract void HandlePacket(ClassicServer Server, RemoteClient Client);
/// <summary> /// Writes the packet. /// </summary> /// <param name="Client">The client.</param> /// <remarks></remarks> public override void WritePacket(RemoteClient Client) { Client.TcpClient.GetStream().Write(Payload, 0, Length); }
/// <summary> /// Reads a packet from a RemoteClient. /// </summary> /// <param name="Client">The sender of said packet.</param> public abstract void ReadPacket(RemoteClient Client);
public OnPlayerChatEvent(RemoteClient c, string Message) { this.Message = Message; this.client = c; }
public static void KickPlayer(RemoteClient toKick) { }