// By this call you specify that Q3DemoStream must poll underlying stream for a new datagram.
// All unreaded data stored in readBuffer will be erased.
// It is like Flush () but for reading purposes.
public int ReadNew(byte [] array, int offset, int count, out PacketKind kind)
{
int bytesReceieved = this.ReadNew(array, offset, count);
kind = this.readPacketKind;
return(bytesReceieved);
}
// By this call you specify that Q3NetworkStream must poll underlying stream for a new datagram.
// All unreaded data stored in readBuffer will be erased.
// It is like Flush () but for reading purposes.
public int ReadNew(byte [] array, int offset, int count, out PacketKind kind)
{
int bytesReceieved = this.ReadNew(array, offset, count);
kind = (( Q3NetworkStreamOld )baseStream).ReadPacketKind; // FIXIT: make q3-specified abstract stream instead of System.IO.Stream
return(bytesReceieved);
}
// By this call you specify that Q3HuffmanStream must poll underlying stream for a new datagram.
// All unreaded data stored in readBuffer will be erased.
// It is like Flush () but for reading purposes.
public int ReadNew(byte [] array, int offset, int count, out PacketKind kind)
{
int bytesReceieved = this.ReadNew(array, offset, count);
kind = baseStream is Q3DatagramStream ? (( Q3DatagramStream )baseStream).ReadPacketKind : PacketKind.Unknown; // FIXIT: make q3-specified abstract stream instead of System.IO.Stream
return(bytesReceieved);
}
public void Write(byte [] array, int offset, int count, PacketKind kind)
{
if (this.writePacketKind != kind && msWriteBuffer.Length != 0)
{
this.Flush();
}
this.writePacketKind = kind;
this.Write(array, offset, count);
}
private bool ReadConnectionlessPacket(out string command, out byte [] data)
{
byte [] buffer = new byte [256];
PacketKind packetKind = q3NetStream.BeginReadPacket();
int bytesRead = q3NetStream.Read(buffer, 0, buffer.Length);
bool res = false;
if (packetKind != PacketKind.Connectionless)
{
command = null;
data = null;
return(false);
}
string data_cmd = Encoding.ASCII.GetString(buffer, 0, 17);
if (data_cmd.Contains("challengeResponse"))
{
command = "challengeResponse";
res = true;
}
else if (data_cmd.Contains("connectResponse"))
{
command = "connectResponse";
res = true;
}
else
{
command = null;
}
if (res)
{
int data_len = bytesRead - command.Length;
if (data_len != 0)
{
data = new byte [bytesRead - command.Length];
Array.Copy(buffer, command.Length, data, 0, bytesRead - command.Length);
}
else
{
data = null;
}
}
else
{
data = null;
}
return(res);
}
public void ProcessPacket(NetIncomingMessage im, PacketKind kind)
{
switch (kind)
{
case PacketKind.NewCharacter:
var om = server.NetServer.CreateMessage();
om.Write((byte)PacketKind.NewCharacter);
om.Write((byte)1); //allowed (1 byte as Lidgren packs bools)
om.Write(1000); //Credits
server.NetServer.SendMessage(om, connection, NetDeliveryMethod.ReliableOrdered);
break;
}
server.NetServer.Recycle(im);
}
public override void Flush()
{
#region Exception checks
if (baseStream == null)
{
throw new ObjectDisposedException("sock");
}
#endregion Exception checks
baseStream.Write(msWriteBuffer.GetBuffer(), 0, ( int )msWriteBuffer.Length);
msWriteBuffer.SetLength(0);
justFlushed = true;
writePacketKind = PacketKind.ConnectionOriented;
}
//
// Summary:
// Flush is not necessary for this kind of stream
//
// Exceptions:
// System.ObjectDisposedException:
// The stream is closed.
public override void Flush()
{
#region Exception checks
if (sock == null)
{
throw new ObjectDisposedException("sock");
}
#endregion Exception checks
sock.Send(msWriteBuffer.GetBuffer(), ( int )msWriteBuffer.Length, SocketFlags.None);
msWriteBuffer.SetLength(0);
justFlushed = true;
writePacketKind = PacketKind.ConnectionOriented;
}
public virtual void BeginWritePacket(PacketKind packetKind)
{
if (msWriteBuffer != null)
{
msWriteBuffer.SetLength(0);
}
bytesWritten = 0;
if (underlying is Q3DatagramStream)
{
(underlying as Q3DatagramStream).BeginWritePacket(packetKind);
}
else
{
writePacketKind = packetKind;
}
}
private void ReadPacket(Q3HuffmanStream stream)
{
List <string> cmdLog = new List <string> ();
PacketKind pktKind = stream.BeginRead();
this.reliableAcknowledge = stream.ReadInt32();
ServerCommandType cmd;
while (ServerCommandType.EOF != (cmd = ( ServerCommandType )stream.ReadByte()))
{
switch (cmd)
{
case ServerCommandType.Nop:
cmdLog.Add("Nop");
break;
case ServerCommandType.ServerCommand:
this.ParseCommandString(stream);
cmdLog.Add("ServerCommand");
break;
case ServerCommandType.GameState:
this.ParseGamestate(stream);
cmdLog.Add("GameState");
break;
case ServerCommandType.Snapshot:
this.ParseSnapshot(stream);
cmdLog.Add("Snapshot");
break;
case ServerCommandType.Download:
// We never download ;)
return;
default:
// Unknown command
return;
}
}
stream.EndRead();
}
public PacketData(ushort size, DateTime sendPoint, PacketKind kind)
{
Size = size; SendPoint = sendPoint; Kind = kind;
}
//
// Summary:
// Reads data from the Q3Network.Q3NetworkStream.
//
// Parameters:
// array:
// The array used to store obtained bytes.
//
// offset:
// The byte offset in array at which to begin writing data read from the stream.
//
// count:
// The number of bytes to read.
//
// Returns:
// The number of bytes that were read into the byte array. If the end
// of the stream has been reached, zero or the number of bytes read is returned.
//
// Exceptions:
// System.ArgumentNullException:
// array is null.
//
// System.ArgumentOutOfRangeException:
// offset or count is less than zero. -or- array length minus the index starting
// point is less than count.
//
// System.ObjectDisposedException:
// The stream is closed.
public override int Read(byte [] array, int offset, int count)
{
#region Exception checks
if (array == null)
{
throw new ArgumentNullException("array");
}
if (sock == null)
{
throw new ObjectDisposedException("baseStream");
}
if (offset < 0)
{
throw new ArgumentOutOfRangeException("offset");
}
if (count < 0)
{
throw new ArgumentOutOfRangeException("count");
}
if (array.Length < offset)
{
throw new ArgumentOutOfRangeException("offset");
}
if (array.Length < offset + count)
{
throw new ArgumentOutOfRangeException("count");
}
#endregion Exception checks
if (msReadBuffer.Position >= this.dGramLen && this.dGramLen != 0)
{
throw new InvalidOperationException
("Read position reached the end of the buffer." +
"Call ReadNew () instead of Read () in this case." +
"By calling ReadNew () you will be also notified about kind of received datagram");
}
if (msReadBuffer.Position == 0)
{
// Ready to peek new datagram from network
int bytesRead = sock.Receive(readBuffer, READ_BUFFER_SIZE, SocketFlags.None);
this.dGramLen = bytesRead;
if (readBuffer [0] == 0xff && readBuffer [1] == 0xff &&
readBuffer [2] == 0xff && readBuffer [3] == 0xff) // Connectionless packet
{
this.readPacketKind = PacketKind.Connectionless;
}
else
{
connection.IncomingSequence = BitConverter.ToInt32(readBuffer, 0);
this.readPacketKind = PacketKind.ConnectionOriented;
if ((connection.IncomingSequence & FRAGMENT_BIT) != 0)
{
int seq = connection.IncomingSequence & (~FRAGMENT_BIT);
if (this.fragmentSequence != seq)
{
this.fragmentSequence = seq;
Array.Copy(BitConverter.GetBytes(seq), fragmentBuffer, 4);
this.fDataLen = 4;
}
int fragmentStart = BitConverter.ToInt16(readBuffer, 4); // Needed only for warning (fragmentStart != this.fDataLen)
int fragmentLength = BitConverter.ToInt16(readBuffer, 6);
Array.Copy(readBuffer, 8, fragmentBuffer, this.fDataLen, fragmentLength);
this.fDataLen += fragmentLength;
if (fragmentLength != FRAGMENT_SIZE)
{
connection.IncomingSequence = seq;
Array.Copy(fragmentBuffer, readBuffer, fDataLen);
this.dGramLen = fDataLen;
return(bytesRead);
}
else
{
this.Read(array, offset, count);
if (fragmentStart != 0) // We're not on the top of the stack (relative to first Read())
{
return(bytesRead);
}
}
}
}
msReadBuffer.Position = 4;
}
// Return the next part of previously obtained packet data
int bytesToReturn = ( int )(count + msReadBuffer.Position > this.dGramLen ?
this.dGramLen - msReadBuffer.Position : count);
msReadBuffer.Read(array, 0, bytesToReturn);
return(bytesToReturn);
}
