private void FlushPackets()
{
while (PacketQueue.Count > 0)
{
ServerPacket packet;
if (PacketQueue.TryDequeue(out packet))
{
if (packet.Header.HasFlag(PacketHeaderFlags.EncryptedChecksum) && ConnectionData.PacketSequence < 2)
{
ConnectionData.PacketSequence = 2;
}
packet.Header.Sequence = ConnectionData.PacketSequence++;
packet.Header.Id = 0x0B; // This value is currently the hard coded Server ID. It can be something different...
packet.Header.Table = 0x14;
packet.Header.Time = (ushort)ConnectionData.ServerTime;
if (packet.Header.Sequence >= 2u)
{
CachedPackets.TryAdd(packet.Header.Sequence, packet);
}
SendPacket(packet);
}
}
}
private void FlushPackets()
{
while (PacketQueue.Count > 0)
{
ServerPacket packet;
if (PacketQueue.TryDequeue(out packet))
{
if (packet.Header.HasFlag(PacketHeaderFlags.EncryptedChecksum) && ConnectionData.PacketSequence < 2)
{
ConnectionData.PacketSequence = 2;
}
packet.Header.Sequence = ConnectionData.PacketSequence++;
packet.Header.Id = (ushort)(connectionType == ConnectionType.Login ? 0x0B : 0x18);
packet.Header.Table = 0x14;
packet.Header.Time = (ushort)ConnectionData.ServerTime;
if (packet.Header.Sequence >= 2u)
{
CachedPackets.TryAdd(packet.Header.Sequence, packet);
}
SendPacket(packet);
}
}
}
void Update()
{
Session session = null;
byte[] data = null;
while (recvQueue.TryDequeue(out session, out data))
{
dispatcher.OnNext(session, data);
}
room.GameLoop();
}
public void Start()
{
serialPort.Open();
byte[] buffer = new byte[SPO2Packet.PACKET_SIZE];
reading = true;
while (reading)
{
bool readOk = true;
SPO2Packet packet = new SPO2Packet();
for (int i = 0; i < buffer.Length && readOk; i++)
{
int val = serialPort.ReadByte();
if (val == -1)
{
throw new Exception("Serial Port: End of stream.");
}
byte readByte = (byte)val;
if ((i == 0 && !highBitOn(readByte)) ||
(i != 0 && highBitOn(readByte)))
{
readOk = false;
}
buffer[i] = readByte;
}
packet.Unpack(buffer);
if (readOk && packet.HeartRate != 0)
{
PacketQueue.Enqueue(packet);
while (PacketQueue.Count > maxQueueSize)
{
SPO2Packet temp;
PacketQueue.TryDequeue(out temp);
}
}
}
if (serialPort != null)
{
serialPort.Close();
}
}
public void FlushPackets()
{
while (PacketQueue.Count > 0)
{
IStarboundPacket next;
while (!PacketQueue.TryDequeue(out next))
{
;
}
var memoryStream = new MemoryStream();
var stream = new StarboundStream(memoryStream);
next.Write(stream);
byte[] buffer = new byte[stream.Position];
Array.Copy(memoryStream.GetBuffer(), buffer, buffer.Length);
int length = buffer.Length;
var compressed = ZlibStream.CompressBuffer(buffer);
if (compressed.Length < buffer.Length)
{
buffer = compressed;
length = -buffer.Length;
}
byte[] header = new byte[StarboundStream.GetSignedVLQLength(length) + 1];
header[0] = next.PacketId;
int discarded;
StarboundStream.WriteSignedVLQ(header, 1, length, out discarded);
int payloadStart = header.Length;
Array.Resize(ref header, header.Length + buffer.Length);
Array.Copy(buffer, 0, header, payloadStart, buffer.Length);
lock (PacketsWaitingLock)
PacketsWaiting++;
EmptyQueueReset.Reset();
Socket.BeginSend(header, 0, header.Length, SocketFlags.None, r =>
{
lock (PacketsWaitingLock)
{
PacketsWaiting--;
if (PacketsWaiting == 0)
{
EmptyQueueReset.Set();
}
}
}, null);
}
}
private void NetworkWorker()
{
while (true)
{
if (IsSpawned && nextPlayerUpdate < DateTime.Now)
{
nextPlayerUpdate = DateTime.Now.AddMilliseconds(100);
lock (_positionLock)
{
SendPacket(new PlayerPacket(OnGround));
if (_positionChanged)
{
SendPacket(new PlayerPositionPacket(
Position.X,
Position.Y,
Position.Z,
Position.Y - 1.62,
OnGround
));
_positionChanged = false;
}
}
}
// Send queued packets
while (PacketQueue.Count != 0)
{
IPacket packet;
if (PacketQueue.TryDequeue(out packet))
{
try
{
// Write packet
NetworkManager.WritePacket(packet, PacketDirection.Serverbound);
if (packet is DisconnectPacket)
{
return;
}
}
catch { /* TODO */ }
}
}
// Read incoming packets
var readTimeout = DateTime.Now.AddMilliseconds(20); // Maximum read time given to server per iteration
while (NetworkStream.DataAvailable && DateTime.Now < readTimeout)
{
try
{
var packet = NetworkManager.ReadPacket(PacketDirection.Clientbound);
HandlePacket(packet);
if (packet is DisconnectPacket)
{
Console.WriteLine(((DisconnectPacket)packet).Reason);
return;
}
}
catch (Exception e)
{
// TODO: OnNetworkException or something
Console.WriteLine(e);
}
}
NetworkingReset.Set();
NetworkingReset.Reset();
Thread.Sleep(1);
}
}
public async Task FlushPackets()
{
while (PacketQueue.Count > 0)
{
try
{
IPacket next;
if (!PacketQueue.TryDequeue(out next))
{
continue;
}
if (!next.IsReceive)
{
foreach (var handler in Server.PacketHandlers)
{
if (next.PacketId == handler.PacketId)
{
await handler.Handle(next, OtherClient);
}
}
}
if (next.Ignore)
{
continue;
}
var stream = new StarboundStream();
next.Write(stream);
byte[] buffer = stream.ToArray();
bool compressed = stream.Length >= 512;
if (compressed)
{
buffer = ZlibStream.CompressBuffer(buffer);
}
stream.Dispose();
int length = compressed ? -buffer.Length : buffer.Length;
var finalStream = new StarboundStream();
finalStream.WriteUInt8(next.PacketId);
finalStream.WriteSignedVLQ(length);
finalStream.Write(buffer, 0, buffer.Length);
byte[] toSend = finalStream.ToArray();
finalStream.Dispose();
if (Socket == null)
{
return;
}
var token = new AsyncUserToken();
token.Socket = Socket;
SocketAsyncEventArgs writeArgs = new SocketAsyncEventArgs();
writeArgs.RemoteEndPoint = Socket.RemoteEndPoint;
writeArgs.UserToken = token;
writeArgs.SetBuffer(toSend, 0, toSend.Length);
writeArgs.Completed += IO_Completed;
Socket.SendAsync(writeArgs);
}
catch
{
CloseClientSocket(readEventArgs);
}
}
}
