public override int Read(byte[] buffer, int offset, int count)
{
int read = 0;
while (read < count)
{
// Ensure a buffer is available
if (TakeBuffer())
{
// Get as much as we can from the current buffer
read += _current.Read(buffer, offset + read, count - read);
if (_current.Count == 0)
{
// Used up this buffer, return to the pool if it's a pool buffer
if (_current.FromPool)
{
_pool.Add(_current);
}
_current = null;
}
}
else
{
break;
}
}
return(read);
}
internal override ReadWithCommentResult <dynamic> TryReadInner(bool returnComments, bool checkRow, ref dynamic row)
{
TryAllocateAndTrack(this, ColumnNames, ref NotifyOnDisposeHead, checkRow, ref row);
var madeProgress = true;
while (true)
{
PreparingToWriteToBuffer();
var available = Buffer.Read(Inner, madeProgress);
if (available == 0)
{
var endRes = EndOfData();
return(HandleAdvanceResult(endRes, returnComments, ending: true));
}
if (!RowBuilder.RowStarted)
{
StartRow();
}
var res = AdvanceWork(available, out madeProgress);
var possibleReturn = HandleAdvanceResult(res, returnComments, ending: false);
if (possibleReturn.ResultType != ReadWithCommentResultType.NoValue)
{
return(possibleReturn);
}
}
}
void NextCh()
{
if (oldEols > 0)
{
ch = EOL; oldEols--;
}
else
{
pos = buffer.Pos;
ch = buffer.Read(); col++;
// replace isolated '\r' by '\n' in order to make
// eol handling uniform across Windows, Unix and Mac
if (ch == '\r' && buffer.Peek() != '\n')
{
ch = EOL;
}
if (ch == EOL)
{
line++; col = 0;
}
}
valCh = (char)ch;
if (ch != Buffer.EOF)
{
ch = char.ToLower((char)ch);
}
}
public override bool OnDataReceived(MainForm form, bool isTcp, Peer peer, int dataType, byte[] data)
{
if (!isTcp || peer.Pending)
{
return(false);
}
string hash = null;
Buffer.Read(data, br =>
{
hash = br.ReadString();
});
form.RemoveWorldObject(hash);
var buf = Buffer.Write(br =>
{
br.Write(peer.SessionID);
br.Write(hash);
});
form.Server.SendTcp(DataType.ResponseObjectPicked, buf);
return(true);
}
void NextCh()
{
if (oldEols > 0)
{
ch = EOL; oldEols--;
}
else
{
pos = buffer.Pos;
// buffer reads unicode chars, if UTF8 has been detected
ch = buffer.Read();
col++;
charPos++;
// replace isolated '\r' by '\n' in order to make
// eol handling uniform across Windows, Unix and Mac
if (ch == '\r' && buffer.Peek() != '\n')
{
ch = EOL;
}
if (ch == EOL)
{
line++;
col = 0;
}
}
}
internal override ReadWithCommentResult <T> TryReadInner(bool returnComments, bool checkRecord, ref T record)
{
TryPreAllocateRow(checkRecord, ref record);
var madeProgress = true;
while (true)
{
PreparingToWriteToBuffer();
var available = Buffer.Read(Inner, madeProgress);
if (available == 0)
{
var endRes = EndOfData();
return(HandleAdvanceResult(endRes, returnComments, ending: true));
}
if (!RowBuilder.RowStarted)
{
StartRow();
}
var res = AdvanceWork(available, out madeProgress);
var possibleReturn = HandleAdvanceResult(res, returnComments, ending: false);
if (possibleReturn.ResultType != ReadWithCommentResultType.NoValue)
{
return(possibleReturn);
}
}
}
private string ReadStringBody(int size)
{
CheckReadLength(size);
byte[] buf = new byte[size];
Buffer.Read(buf, 0, size);
return(Encoding.UTF8.GetString(buf, 0, buf.Length));
}
public bool Execute(Server server, int dataType, byte[] data, bool isTcp)
{
if (isTcp)
{
return(false);
}
var ids = new List <int>();
var poses = new List <Vector3f>();
var rots = new List <Vector3f>();
Buffer.Read(data, br =>
{
while (br.BaseStream.Position < data.Length)
{
ids.Add(br.ReadInt32());
poses.Add(new Vector3f(br.ReadSingle(), br.ReadSingle(), br.ReadSingle()));
rots.Add(new Vector3f(br.ReadSingle(), br.ReadSingle(), br.ReadSingle()));
}
});
for (var i = 0; i < ids.Count; i++)
{
var player = worldData.Players.Find(p => p.SessionID == ids[i]);
if (player == null)
{
continue;
}
player.Position = poses[i];
player.Rotation = rots[i];
}
return(true);
}
public Byte[] ReadByteArray()
{
var len = ReadInt32();
var data = new Byte[len];
Buffer.Read(data, 0, len);
return(data);
}
/// <summary>
/// Remove the contents of the buffer from the cursor to the end of the
/// buffer, and place them in the paste buffer.
/// </summary>
public void CutToEnd()
{
var charsToCut = Buffer.Length - Buffer.CursorIndex;
PasteBuffer = new string(Buffer.Read(charsToCut));
SyncBufferToConsole(0, 0, charsToCut);
Buffer.Truncate();
}
public override byte[] ReadBinary()
{
int size = ReadI32();
CheckReadLength(size);
byte[] buf = new byte[size];
Buffer.Read(buf, 0, size);
return(buf);
}
public String ReadString()
{
var len = ReadInt32();
Buffer.Read(_readBuffer, 0, len);
var data = System.Text.Encoding.UTF8.GetString(_readBuffer, 0, len);
return(data);
}
public bool Execute(Server server, int dataType, byte[] data, bool isTcp)
{
Buffer.Read(data, br =>
{
var player = br.ReadInt32();
var hash = br.ReadString();
//script.ReceivedObjectPicked((Player)Array.Find(server.Players, p => p.SessionID == player), hash);
});
return(true);
}
public void ReadFromBuffer()
{
var sut = new Buffer <string>();
var fixture = new Fixture();
var value = fixture.Create <string>();
sut.Write(value);
var result = sut.Read();
result.Should().Be(value);
}
/**
* Read a byte[] of a known length from the wire.
*/
private byte[] ReadBinary(int length)
{
if (length == 0)
{
return(new byte[0]);
}
byte[] buf = new byte[length];
Buffer.Read(buf, 0, length);
return(buf);
}
public void Wrapped_Empty_Message_ShouldBe_Unwrapped()
{
MockSocketProxy mockSocket = new MockSocketProxy();
NormalPerson normalPerson = new NormalPerson(new Person(mockSocket));
Buffer buffer = new Buffer();
mockSocket.internalReceiveBuffer.Add(new Message("").WrapData());
byte[] res = buffer.Read(mockSocket);
string result = Encoding.ASCII.GetString(res);
Assert.Equal("", result);
}
public void Wrapped_Invalid_BiggerLength_Message_ShouldBe_Unwrapped()
{
MockSocketProxy mockSocket = new MockSocketProxy();
NormalPerson normalPerson = new NormalPerson(new Person(mockSocket));
Buffer buffer = new Buffer();
mockSocket.internalReceiveBuffer.Add(mockSocket.WrapData(new Message("test").ToByteArray(), 10));
var exception = Record.Exception(() => buffer.Read(mockSocket));
Assert.IsType(typeof(System.Exception), exception);
Assert.True(exception.Message.Contains("You've received zero bytes. Please, check your connection."));
}
public bool TryReadWithReuse(ref T record)
{
AssertNotDisposed();
if (RowEndings == null)
{
HandleLineEndings();
}
if (ReadHeaders == null)
{
HandleHeaders();
}
while (true)
{
PreparingToWriteToBuffer();
var available = Buffer.Read(Inner);
if (available == 0)
{
EndOfData();
if (HasValueToReturn)
{
record = GetValueForReturn();
return(true);
}
// intentionally _not_ modifying record here
return(false);
}
if (!HasValueToReturn)
{
if (record == null)
{
if (!Configuration.NewCons(out record))
{
Throw.InvalidOperationException($"Failed to construct new instance of {typeof(T)}");
}
}
SetValueToPopulate(record);
}
var res = AdvanceWork(available);
if (res)
{
record = GetValueForReturn();
return(true);
}
}
}
public void StartUdp()
{
if (udp != null)
{
try
{
udp.Close();
}
catch { }
udp = null;
}
Task.Factory.StartNew(() =>
{
try
{
udp = new UdpClient(LocalUdpPort, AddressFamily.InterNetwork);
udp.JoinMulticastGroup(MulticastAddress, 50);
while (true)
{
IPEndPoint ep = null;
var data = udp.Receive(ref ep);
if (!DataType.Magic.SequenceEqual(data.Take(4)))
{
continue;
}
Buffer.Read(data, (ms, br) =>
{
br.ReadBytes(4);
while (ms.Position < data.Length)
{
var type = br.ReadInt32();
var l = br.ReadInt32();
var buf = br.ReadBytes(l);
UdpDataReceived(this, new DataEventArgs()
{
Data = buf,
DataType = type,
IsTcp = false,
});
}
});
}
}
catch (Exception ex)
{
Debug.WriteLine(ex);
}
});
}
/**
* Read a byte[] from the wire.
*/
public override byte[] ReadBinary()
{
int length = (int)ReadVarint32();
if (length == 0)
{
return(new byte[0]);
}
byte[] buf = new byte[length];
Buffer.Read(buf, 0, length);
return(buf);
}
/* AW 2003-03-10 moved this from ParserGen.cs */
public static string GetString(int beg, int end)
{
StringBuilder s = new StringBuilder(64);
int oldPos = Buffer.Pos;
Buffer.Pos = beg;
while (beg < end)
{
s.Append((char)Buffer.Read()); beg++;
}
Buffer.Pos = oldPos;
return(s.ToString());
}
public override bool OnDataReceived(MainForm form, bool isTcp, Peer peer, int dataType, byte[] data)
{
if (peer.Pending || isTcp)
{
return(false);
}
Buffer.Read(data, br =>
{
peer.Player.Position = new Vector3f(br.ReadSingle(), br.ReadSingle(), br.ReadSingle());
peer.Player.Rotation = new Vector3f(br.ReadSingle(), br.ReadSingle(), br.ReadSingle());
});
return(true);
}
public override void OnTcpReceived(int dataType, byte[] data)
{
Buffer.Read(data, br =>
{
var str = br.ReadString();
if (str != GameObject.Hash)
{
return;
}
var name = br.ReadString();
if (name != Script.ScriptHash)
{
return;
}
var length = br.ReadInt32();
Status = br.ReadBytes(length);
});
}
/**
* Reading methods.
*/
///<summary>
/// Read in a JSON string, unescaping as appropriate.. Skip Reading from the
/// context if skipContext is true.
///</summary>
private byte[] ReadJSONString(bool skipContext)
{
MemoryStream buffer = new MemoryStream();
if (!skipContext)
{
context.Read();
}
ReadJSONSyntaxChar(QUOTE);
while (true)
{
byte ch = reader.Read();
if (ch == QUOTE[0])
{
break;
}
if (ch == ESCSEQ[0])
{
ch = reader.Read();
if (ch == ESCSEQ[1])
{
ReadJSONSyntaxChar(ZERO);
ReadJSONSyntaxChar(ZERO);
Buffer.Read(tempBuffer, 0, 2);
ch = (byte)((HexVal((byte)tempBuffer[0]) << 4) + HexVal(tempBuffer[1]));
}
else
{
int off = Array.IndexOf(ESCAPE_CHARS, (char)ch);
if (off == -1)
{
throw new SerializerException(SerializerException.INVALID_DATA,
"Expected control char");
}
ch = ESCAPE_CHAR_VALS[off];
}
}
buffer.Write(new byte[] { (byte)ch }, 0, 1);
}
return(buffer.ToArray());
}
public override bool OnDataReceived(MainForm form, bool isTcp, Peer peer, int dataType, byte[] data)
{
if (!isTcp || peer.Pending)
{
return(true);
}
Buffer.Read(data, br =>
{
var objHash = br.ReadString();
var scrHash = br.ReadString();
var length = br.ReadInt32();
var buf = br.ReadBytes(length);
form.UpdateWorldObjectStatus(objHash, scrHash, buf);
});
form.Server.SendTcp(DataType.ResponseScriptUpdate, data);
return(true);
}
static void NextCh()
{
if (oldEols > 0)
{
ch = EOL; oldEols--;
}
else
{
ch = (char)Buffer.Read(); pos++;
// replace isolated '\r' by '\n' in order to make
// eol handling uniform across Windows, Unix and Mac
if (ch == '\r' && Buffer.Peek() != '\n')
{
ch = EOL;
}
if (ch == EOL)
{
line++; lineStart = pos + 1;
}
}
}
public bool Execute(Server server, int dataType, byte[] data, bool isTcp)
{
if (!isTcp)
{
return(false);
}
Buffer.Read(data, br =>
{
var res = br.ReadInt32();
if (res >= 0)
{
server.SessionID = res;
}
MMW.BroadcastMessage("login result", res >= 0);
//server.EventLoginResultReceived(res >= 0);
});
return(true);
}
public override void OnTcpReceived(int dataType, byte[] data)
{
if (dataType == Walker.DataType.ResponseObjectDestroy)
{
string hash = null;
Buffer.Read(data, br => hash = br.ReadString());
RemoveGameObject(SyncWorldObjects.Find(go => go.Hash == hash));
}
else if (dataType == Walker.DataType.ResponseItemUsed)
{
var obj = Util.DeserializeJsonBinary <NwWalkerGameObject>(data);
ItemUse(obj, worldData.Players.Find(p => p.UserID == obj.UserID), true);
}
else if (dataType == Walker.DataType.ResponseObjectPut)
{
var obj = Util.DeserializeJsonBinary <NwWalkerGameObject>(data);
PutGameObject(obj, true);
}
else if (dataType == Walker.DataType.ResponsePlayerJoin)
{
var player = Util.DeserializeJsonBinary <WalkerPlayer>(data);
if (worldData.Players.Exists(p => p.SessionID == player.SessionID))
{
return;
}
JoinPlayer(player);
}
else if (dataType == Walker.DataType.ResponseWorldStatus)
{
var status = Util.DeserializeJsonBinary <NwWorldStatus>(data);
ResolveReceiveWorldStatus(status);
}
else if (dataType == Walker.DataType.ResponseLeaveWorld)
{
server.Disconnected -= Server_Disconnected;
OnUnload();
}
}
/// <summary>
/// Transforms the current word by passing it through the provided
/// function. Does not move the cursor.
/// </summary>
/// <param name="transformation">Function to apply.</param>
/// <exception cref="ArgumentNullException">Thrown when <paramref name="transformation" />
/// is null.</exception>
public void TransformCurrentWord(Func <string, string> transformation)
{
if (transformation == null)
{
throw new ArgumentNullException(nameof(transformation));
}
var word = new string(Buffer.Read(FindIndexOfNextWord() - Buffer.CursorIndex));
var transformedWord = transformation(word);
Buffer.Remove(word.Length);
Buffer.Insert(transformedWord);
var extraSpaces = 0;
if (transformedWord.Length < word.Length)
{
extraSpaces = word.Length - transformedWord.Length;
}
SyncBufferToConsole(Buffer.CursorIndex, Buffer.Length - Buffer.CursorIndex, extraSpaces);
}
public void Start()
{
//Thread.Sleep(delay);
this.colour = Color.White;
for (int k = 1; k <= 12; k++)
{
semaphore.Signal();
this.zeroPlane();
buffer.Read(ref this.colour);
for (int i = 1; i <= 20; i++)
{
panel.Invalidate();
this.movePlane(xDelta, yDelta);
Thread.Sleep(delay);
}
this.colour = Color.White;
panel.Invalidate();
}
this.colour = Color.Gray;
panel.Invalidate();
}
