public new Client OnAttached()
{
Incoming.InitializeMapLoad(this);
AddServerHandler(0x04, Incoming.ClientLocationUpdated);
AddServerHandler(0x07, Incoming.EntitiesAdded);
AddServerHandler(0x0A, Incoming.Barmessage);
AddServerHandler(0x0B, Incoming.ClientPlayerWalked);
AddServerHandler(0x0C, Incoming.ObjectWalked);
AddServerHandler(0x0D, Incoming.ChatMessages);
AddServerHandler(0x0E, Incoming.ObjectRemoved);
AddServerHandler(0x11, Incoming.EntitiesChangedDirection);
AddServerHandler(0x15, Incoming.MapLoaded);
AddServerHandler(0x19, Incoming.PlaySound);
AddServerHandler(0x1A, Incoming.PlayerAction);
AddServerHandler(0x29, Incoming.Animation);
AddServerHandler(0x33, Incoming.AislingsAdded);
AddServerHandler(0x3A, Incoming.Sidebar);
AddServerHandler(0x39, Incoming.ProfileRequested);
AddServerHandler(0x05, Incoming.PlayerSerialAssigned);
AddServerHandler(0x06, Incoming.LoadingMap);
AddServerHandler(0x37, Incoming.EquipmentUpdated);
AddClientHandler(0x03, Outgoing.LoggingIn);
AddClientHandler(0x0B, Outgoing.LoggingOut);
AddClientHandler(0x1C, Outgoing.UseInventorySlot);
AddClientHandler(0x0F, Outgoing.SpellCasted);
AddClientHandler(0x0D, Outgoing.SpellBegin);
PreparePrelims();
base.OnAttached();
return(this);
}
internal void AddIncoming(BaseNode node)
{
Incoming.Add(new NodeLink(node)
{
Weight = Helpers.GetRandomWeight()
});
}
public async Task <IActionResult> Edit(int id, [Bind("Id,TourImage,TourIcon,TourName,TourTitle,TourTime,TourAction,ServiceId,Duration,TourId")] Incoming incoming)
{
if (id != incoming.Id)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(incoming);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!IncomingExists(incoming.Id))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
ViewData["ServiceId"] = new SelectList(_context.Services, "Id", "Id", incoming.ServiceId);
ViewData["TourId"] = new SelectList(_context.Tours, "Id", "ImagePath", incoming.TourId);
return(View(incoming));
}
public override string ToString()
{
var sb = new StringBuilder();
if (Unknown.Any())
{
sb.Append(string.Join(", ", Unknown.Select(x => x.Name)));
}
if (Incoming.Any())
{
if (sb.Length > 0)
{
sb.Append("; ");
}
sb.Append("Incoming: ");
sb.Append(string.Join(", ", Incoming.Select(x => x.Name)));
}
if (Outgoing.Any())
{
if (sb.Length > 0)
{
sb.Append("; ");
}
sb.Append("Outgoing: ");
sb.Append(string.Join(", ", Outgoing.Select(x => x.Name)));
}
return(sb.ToString());
}
public override String ToString()
{
return("OperatorDependencyEntry{" +
"incoming=" + Incoming.Render() +
", outgoing=" + Outgoing.Render() +
'}');
}
public IHttpActionResult PutIncoming(Incoming incoming)
{
var id = incoming.IncomingID;
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
if (id != incoming.IncomingID)
{
return(BadRequest());
}
db.Entry(incoming).State = EntityState.Modified;
try
{
db.SaveChanges();
}
catch (DbUpdateConcurrencyException)
{
if (!IncomingExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(StatusCode(HttpStatusCode.NoContent));
}
public async Task <IActionResult> Create([Bind("Id,TourImage,TourIcon,TourName,TourTitle,TourTime,TourAction,ServiceId,Duration,TourId")] Incoming incoming, IFormFile TourImage)
{
//CustomDateTimeFile customDateTimeFile = new CustomDateTimeFile();
//string fileName = customDateTimeFile.GetFileName(TourImage.FileName);
if (ModelState.IsValid)
{
//incoming.TourImage = fileName;
//if (_IsAcceptedFormat(TourImage.ContentType))
//{
// string path = Path.Combine(hostingEnvironment.WebRootPath, "images", fileName);
// byte[] data = new byte[TourImage.Length];
// using (FileStream fileStream = new FileStream(path, FileMode.Create))
// {
// await TourImage.CopyToAsync(fileStream);
// }
//}
await _context.AddAsync(incoming);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
ViewData["ServiceId"] = new SelectList(_context.Services, "Id", "Id", incoming.ServiceId);
ViewData["TourId"] = new SelectList(_context.Tours, "Id", "ImagePath", incoming.TourId);
return(View(incoming));
}
public Program(string[] args)
{
_baseDirectory = AppDomain.CurrentDomain.BaseDirectory;
In = new Incoming();
Out = new Outgoing();
Options = HBOptions.Parse(args);
if (string.IsNullOrWhiteSpace(Options.FetchRevision))
{
Game = new HGame(Options.GameInfo.FullName);
if (Options.Compression == null)
{
Options.Compression = Game.Compression;
}
}
if (string.IsNullOrWhiteSpace(Options.OutputDirectory))
{
if (Options.GameInfo == null)
{
Options.OutputDirectory = Environment.CurrentDirectory;
}
else
{
Options.OutputDirectory = Options.GameInfo.DirectoryName;
}
}
else
{
Options.OutputDirectory = Path.Combine(
Environment.CurrentDirectory, Options.OutputDirectory);
}
}
void DoReceive(bool slowOutgoing, bool slowIncoming)
{
Incoming.SlowConnection = slowIncoming;
Outgoing.SlowConnection = slowOutgoing;
int sent = 0;
buffer = new byte [data.Length];
var handle = new ManualResetEvent(false);
NetworkIO.EnqueueReceive(Outgoing, buffer, 0, buffer.Length, null, null, null, (s, t, o) => {
Assert.IsTrue(s, "#Receive successful");
Assert.AreEqual(buffer.Length, t, "#data was all received");
handle.Set();
}, null);
while (sent != buffer.Length)
{
int r = Incoming.Send(data, sent, data.Length - sent);
Assert.AreNotEqual(0, r, "#Received data");
sent += r;
}
Assert.IsTrue(handle.WaitOne(TimeSpan.FromSeconds(4)), "Data should be all received");
for (int i = 0; i < buffer.Length; i++)
{
if (data[i] != buffer[i])
{
Assert.Fail("Buffers differ at position " + i);
}
}
}
public override Task AppendLoad(XElement item, Process target)
{
return(Task.Run(() =>
{
// 中间流对象拥有前后连接
var ins = item.Elements("incoming");
foreach (var @in in ins)
{
if (Incoming == null)
{
Incoming = new List <SequenceFlow>();
}
Incoming.Add(target.Where(a => a.Id == @in.Value).FirstOrDefault() as SequenceFlow);
}
var outs = item.Elements("outgoing");
foreach (var @out in outs)
{
if (Outgoing == null)
{
Outgoing = new List <SequenceFlow>();
}
Outgoing.Add(target.Where(a => a.Id == @out.Value).FirstOrDefault() as SequenceFlow);
}
ProcessRef = target;
Executor.Init(this, item, Executor.TypesAll);
}));
}
public virtual string GetProperty(string strPropertyName, string strFormat, System.Globalization.CultureInfo formatProvider, DotNetNuke.Entities.Users.UserInfo accessingUser, DotNetNuke.Services.Tokens.Scope accessLevel, ref bool propertyNotFound)
{
switch (strPropertyName.ToLower())
{
case "rideid": // Int
return(RideId.ToString(strFormat, formatProvider));
case "moduleid": // Int
return(ModuleId.ToString(strFormat, formatProvider));
case "userid": // Int
return(UserId.ToString(strFormat, formatProvider));
case "incoming": // Bit
return(Incoming.ToString());
case "location": // NVarChar
return(PropertyAccess.FormatString(Location, strFormat));
case "notes": // NVarCharMax
return(PropertyAccess.FormatString(Notes, strFormat));
case "placesavailable": // Int
return(PlacesAvailable.ToString(strFormat, formatProvider));
default:
propertyNotFound = true;
break;
}
return(Null.NullString);
}
private void disableControls()
{
btnConnect.Text = "Connect";
btnLaser.Enabled = false;
laserStatus.BackColor = Color.LightGray;
laserStatusText.Text = disconnectedStatus;
laserStatusText.Enabled = false;
btnCalibrate.Enabled = false;
Incoming.ResetText();
btnRandomSpeed.Enabled = false;
btnFixedSpeed.Enabled = false;
btnIncrease.Enabled = false;
btnDecrease.Enabled = false;
btnStop.Enabled = false;
btnStop.BackColor = Color.LightGray;
square1.Enabled = false;
square2.Enabled = false;
square3.Enabled = false;
square4.Enabled = false;
line1.Enabled = false;
line2.Enabled = false;
line3.Enabled = false;
line4.Enabled = false;
cross1.Enabled = false;
cross2.Enabled = false;
triangle1.Enabled = false;
triangle2.Enabled = false;
manFigure.Enabled = false;
smiley.Enabled = false;
heart.Enabled = false;
star.Enabled = false;
}
//
// GET: /Incoming/Delete/5
public ActionResult Delete(int id)
{
Outcoming outcoming = db.Outcomings.Find(id);
Incoming incoming = db.Incomings.Find(id);
return(View());
}
/// <summary>
/// Initialize sockets for file stream
/// </summary>
private void InitSockets()
{
FileTransfer = new TCPClient(AddressString, TransferPort, SSL, Logging);
FileTransfer.OnMessage += (message) => {
using (MemoryStream ms = new MemoryStream(message.Content)) {
long id = TCPReaderWriter.ReadLong(ms, false);
long index = TCPReaderWriter.ReadLong(ms, false);
byte[] data = TCPReaderWriter.Read(ms, (uint)message.Content.Length - 16);
TCPFileProgress progress = Incoming.Peek();
if (progress.TransferData.ID == id)
{
progress.Cache.AddData(new TCPFileTile()
{
ID = id,
Data = data,
Index = index
});
}
}
};
}
private static void UpdateQueue()
{
Incoming inc = QueueManager.GetNextIncoming();
while (inc != null)
{
switch (inc.Method)
{
case "message":
QueueManager.Push(UsersManager.OnMessage(inc.Message), inc.UserInfo);
break;
case "start":
QueueManager.Push(UsersManager.Start(inc.UserInfo), inc.UserInfo);
break;
case "lang":
UsersManager.SetLanguage(inc.Message);
break;
default:
continue;
}
inc = QueueManager.GetNextIncoming();
}
}
void DoReceive(bool slowOutgoing, bool slowIncoming)
{
Incoming.SlowConnection = slowIncoming;
Outgoing.SlowConnection = slowOutgoing;
int sent = 0;
buffer = new byte[data.Length];
var task = NetworkIO.ReceiveAsync(Outgoing, buffer, 0, buffer.Length, null, null, null);
while (sent != buffer.Length)
{
int r = Incoming.Send(data, sent, data.Length - sent);
Assert.AreNotEqual(0, r, "#Received data");
sent += r;
}
Assert.IsTrue(task.Wait(TimeSpan.FromSeconds(10)), "Data should be all received");
for (int i = 0; i < buffer.Length; i++)
{
if (data[i] != buffer[i])
{
Assert.Fail("Buffers differ at position " + i);
}
}
}
public async Task ReceiveAsync(
PipeWriter writer,
CancellationToken cancellationToken)
{
while (!cancellationToken.IsCancellationRequested &&
!Incoming.Any())
{
await Task.Delay(100, cancellationToken);
}
if (cancellationToken.IsCancellationRequested)
{
return;
}
GenericOperationMessage message = Incoming.Dequeue();
string json = JsonConvert.SerializeObject(message);
byte[] buffer = Encoding.UTF8.GetBytes(json);
Memory <byte> memory = writer.GetMemory(buffer.Length);
for (int i = 0; i < buffer.Length; i++)
{
memory.Span[i] = buffer[i];
}
writer.Advance(buffer.Length);
await writer
.FlushAsync(cancellationToken)
.ConfigureAwait(false);
}
public override string ToString()
{
return(string.Format("{0} (color: {1}, before: {2})",
Type.Name,
Color,
Incoming.Select(i => i.Type.Name).JoinToString(", ")));
}
public async Task <IHttpActionResult> PostIncoming(Incoming incoming)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
db.Incoming.Add(incoming);
try
{
await db.SaveChangesAsync();
}
catch (DbUpdateException)
{
if (IncomingExists(incoming.IncomeID))
{
return(Conflict());
}
else
{
throw;
}
}
return(CreatedAtRoute("DefaultApi", new { id = incoming.IncomeID }, incoming));
}
public void Test_RemainNomenclature_WithDifferentIncConsMoreQuantity_ShouldReturnBalanceWithMinusQuantity()
{
var incoming = new Incoming();
var consumption = new Consumption();
var selectedNomenclature = SelectNomenclature("AMD");
var incomingQuantity = 50;
incoming.Warehouse = SelectWarehouse("Main");
incoming.ListOfNomenc.Add(CreateLineItemWithData(selectedNomenclature, incomingQuantity));
var consumptionQuantity = 100;
consumption.Warehouse = SelectWarehouse("Main");
consumption.ListOfNomenc.Add(CreateLineItemWithData(selectedNomenclature, consumptionQuantity));
try
{
_incomingService.Write(incoming);
_consumptionService.Write(consumption);
}
catch (ArgumentException e)
{
Assert.NotNull(e);
}
///// var costPriceBalance = _db.GetLeftoversRemainCostPriceBalance("AMD");
///// var remainNomenclatureBalance = _db.GetLeftoversRemainNomenclatureBalance("AMD", "Main");
//// Assert.Equal(incomingQuantity - consumptionQuantity, costPriceBalance.Select(t => t.Amount).First());
//// Assert.Equal(incomingQuantity - consumptionQuantity, remainNomenclatureBalance.Select(t => t.Quantity).First());
}
// PUT api/Incoming/5
public async Task <IHttpActionResult> PutIncoming(short id, Incoming incoming)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
if (id != incoming.IncomeID)
{
return(BadRequest());
}
db.Entry(incoming).State = EntityState.Modified;
try
{
await db.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!IncomingExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(StatusCode(HttpStatusCode.NoContent));
}
public void Test_RemainNomenclature_WithManyDifferentIncConsQuantity_ShouldReturnBalanceWithSomeQuantity()
{
var incoming = new Incoming();
var consumption = new Consumption();
var rand = new Random();
string[] nomenc = new string[3] {
"NVIDIA", "NVIDIA", "NVIDIA"
};
for (int i = 0; i < 3; i++)
{
var quantity = 20 * i + 10;
var lineItemInc = CreateLineItemWithData(SelectNomenclature("NVIDIA"), quantity + 10 * i);
var lineItemCons = CreateLineItemWithData(SelectNomenclature("NVIDIA"), quantity);
incoming.ListOfNomenc.Add(lineItemInc);
consumption.ListOfNomenc.Add(lineItemCons);
}
incoming.Warehouse = SelectWarehouse("Main");
consumption.Warehouse = SelectWarehouse("Main");
_incomingService.Write(incoming);
_consumptionService.Write(consumption);
var costPriceBalance = _db.GetLeftoversRemainCostPriceBalance("NVIDIA");
var remainNomenclatureBalance = _db.GetLeftoversRemainNomenclatureBalance("NVIDIA", "Main");
var costPriceBalance1 = _db.GetLeftoversRemainCostPriceBalance("AMD");
var remainNomenclatureBalance1 = _db.GetLeftoversRemainNomenclatureBalance("AMD", "Main");
var costPriceBalance2 = _db.GetLeftoversRemainCostPriceBalance("WD");
var remainNomenclatureBalance2 = _db.GetLeftoversRemainNomenclatureBalance("WD", "Main");
Assert.True(true);
}
public void Test_RemainNomenclature_WithEqualIncConsQuantity_ShouldReturnBalanceWithZeroQuantity()
{
var incoming = new Incoming();
var consumption = new Consumption();
var selectedNomenclature = SelectNomenclature("AMD");
var incomingQuantity = 100;
incoming.Warehouse = SelectWarehouse("Main");
incoming.ListOfNomenc.Add(CreateLineItemWithData(selectedNomenclature, incomingQuantity));
var consumptionQuantity = 100;
consumption.Warehouse = SelectWarehouse("Main");
consumption.ListOfNomenc.Add(CreateLineItemWithData(selectedNomenclature, consumptionQuantity));
_incomingService.Write(incoming);
_consumptionService.Write(consumption);
var costPriceBalance = _db.GetLeftoversRemainCostPriceBalance("AMD");
var remainNomenclatureBalance = _db.GetLeftoversRemainNomenclatureBalance("AMD", "Main");
Assert.Equal(incomingQuantity - consumptionQuantity, costPriceBalance.Select(t => t.Amount).First());
Assert.Equal(incomingQuantity - consumptionQuantity, remainNomenclatureBalance.Select(t => t.Quantity).First());
}
public IHttpActionResult PutIncoming(Incoming incoming)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
//if (id != incoming.IncomeID)
//{
// return BadRequest();
//}
db.Entry(incoming).State = EntityState.Modified;
try
{
db.SaveChanges();
}
catch (DbUpdateConcurrencyException)
{
//if (!IncomingExists(id))
//{
// return NotFound();
//}
//else
//{
// throw;
//}
}
return(StatusCode(HttpStatusCode.NoContent));
}
protected override void ProcessIncomingData(byte[] data, int start, int len)
{
//if (data.Length > 0)
if (len > 0)
{
var type = (Utilities.PackType)data[start];
switch (type)
{
case Utilities.PackType.Udp:
var realdata = new byte[len - 1]; //todo , try to reuse
Array.Copy(data, start + 1, realdata, 0, realdata.Length);
if (Incoming != null)
{
Incoming.Enqueue(realdata);
}
break;
case Utilities.PackType.Kcp:
base.ProcessIncomingData(data, start + 1, len - 1);
break;
default:
//unknown packtype, drop it
debug($"unknown packtype, drop it. typeid = {type}");
break;
}
}
}
public bool CanFire()
{
var incoming = Incoming.TrueForAll(a => a.CanFire());
var outgoing = Outgoing.TrueForAll(a => a.CanFire());
return(incoming && outgoing);
}
public void IncomingItem(Product[] products)
{
foreach (Product item in products)
{
Incoming.InCome(item);
View.ViewProduct(item, "Incoming");
}
}
private void Read(Incoming packet)
{
//lock (ReadQueue)
{
ReadQueue.Add(packet);
}
ContinueRead();
}
public ActionResult DeleteConfirmed(int id)
{
Incoming incoming = db.Incomings.Find(id);
db.Incomings.Remove(incoming);
db.SaveChanges();
return(RedirectToAction("Index"));
}
public void Process(Incoming incoming)
{
var validator = new IncomingValidator();
validator.ValidateAndThrow(incoming);
// Do some awesome work ...
}
protected void Next(int aPacketSize, Action<byte[]> aCompleted)
{
if (aCompleted == null)
{
throw new ArgumentNullException("aCompleted");
}
var xIncoming = new Incoming();
if (aPacketSize == 0)
{
// Can occur with variable size packets for exampmle.
// Dont call read, becuase that will close the stream.
// So we just call the Completed directly
aCompleted(new byte[0]);
return;
}
else if (aPacketSize == -1)
{
// Variable size packet, split into two reads
mCompletedAfterSize = aCompleted;
aPacketSize = 2;
xIncoming.Completed = SizePacket;
}
else
{
xIncoming.Completed = bytes =>
{
DebugLog(String.Format("DC - Received: 0x{0}", BytesToString(bytes, 0, bytes.Length)));
try
{
aCompleted(bytes);
}
catch (Exception E)
{
HandleError(E);
}
};
}
if (aPacketSize > (1024 * 1024))
{
throw new Exception("Safety exception. Receiving " + aPacketSize + " bytes!");
}
xIncoming.Packet = new byte[aPacketSize];
DebugLog(String.Format("DC - Next: Expecting: {0}", aPacketSize) + "\r\n");
if (xIncoming.Completed == null)
{
throw new InvalidOperationException("No completed!");
}
mPendingReads.Add(xIncoming);
}
private void ProcessPendingActions()
{
Incoming xPendingRead = mIncompletePendingRead;
if (xPendingRead != null || mPendingReads.TryTake(out xPendingRead, 5))
{
var xNrOfBytesToRead = xPendingRead.Packet.Length - xPendingRead.CurrentPos;
var xBytesRead = TryRead(xPendingRead.Packet, xPendingRead.CurrentPos, xNrOfBytesToRead, 5);
xPendingRead.CurrentPos += xBytesRead;
if (xPendingRead.CurrentPos == xPendingRead.Packet.Length)
{
// Full packet received, process it
xPendingRead.Completed(xPendingRead.Packet);
mIncompletePendingRead = null;
}
else
{
mIncompletePendingRead = xPendingRead;
}
}
//process_writes:
// now process sends.
Outgoing xPendingWrite;
if (mPendingWrites.TryTake(out xPendingWrite, 5))
{
if (!SendRawData(xPendingWrite.Packet))
{
throw new Exception("SendRawData returned false!");
}
if (xPendingWrite.Completed != null)
{
xPendingWrite.Completed.Set();
}
}
}
private void ThreadMethod()
{
// todo: error handling
mIncompletePendingRead = null;
try
{
InitializeBackground();
DoConnected();
Next(1, WaitForSignature);
while (true)
{
if (!GetIsConnectedToDebugStub())
{
ConnectionLost(null);
return;
}
ProcessPendingActions();
}
}
catch (ThreadAbortException)
{
while (true)
{
Outgoing xPendingOutgoing;
if (!mPendingWrites.TryTake(out xPendingOutgoing))
{
break;
}
xPendingOutgoing.Packet = null;
xPendingOutgoing.Completed.Set();
}
return;
}
catch (Exception E)
{
CmdMessageBox("Error occurred in DebugConnector.ThreadMethod: " + E.ToString());
}
ConnectionLost(null);
}
protected override void Next(int aPacketSize, Action<byte[]> aCompleted)
{
var xIncoming = new Incoming();
if (aPacketSize == 0)
{
// Can occur with variable size packets for exampmle.
// Dont call read, becuase that will close the stream.
// So we just call the Completed directly
aCompleted(new byte[0]);
}
else if (aPacketSize == -1)
{
// Variable size packet, split into two reads
mCompletedAfterSize = aCompleted;
aPacketSize = 2;
xIncoming.Completed = SizePacket;
}
else
{
xIncoming.Completed = bytes =>
{
DoDebugMsg(String.Format("DC - Received: 0x{0}", BytesToString(bytes, 0, bytes.Length)));
try
{
aCompleted(bytes);
}
catch (Exception E)
{
HandleError(E);
}
};
}
if (aPacketSize > (1024 * 1024))
{
throw new Exception("Safety exception. Receiving " + aPacketSize + " bytes!");
}
xIncoming.Packet = new byte[aPacketSize];
xIncoming.Stream = mStream;
System.Diagnostics.Debug.WriteLine(String.Format("DC - Next: Expecting: {0}", aPacketSize));
DoDebugMsg(String.Format("DC - Next: Expecting: {0}", aPacketSize) + "\r\n");
Read(xIncoming);
#if TRACK_PENDING
try {
Interlocked.Increment(ref _pendingReadsCount);
#endif
//mStream.BeginRead(xIncoming.Packet, 0, aPacketSize, new AsyncCallback(DoRead), xIncoming);
#if TRACK_PENDING
}
catch (Exception e) {
Interlocked.Decrement(ref _pendingReadsCount);
throw;
}
#endif
}
private void Read(Incoming packet)
{
//lock (ReadQueue)
{
ReadQueue.Add(packet);
}
ContinueRead();
}
// This will start reading from the buffers and modify the incoming array.
public static void HandleIncomingPackets(LaneSetup setup, Incoming[] packets, uint packetsCount)
{
// Zero pass make own buffers.
for (uint i=0;i<packetsCount;i++)
{
if (!packets[i].CanKeepData)
{
Bitstream.Buffer tmp = packets[i].Packet;
Bitstream.Buffer copy = setup.Factory.GetBuffer((uint)tmp.buf.Length);
Bitstream.Insert(copy, tmp);
copy.Flip();
packets[i].Packet = copy;
}
}
// First pass extract.
for (uint i=0;i<packetsCount;i++)
{
Bitstream.Buffer tmp = packets[i].Packet;
Lane lane = packets[i].Lane;
lane.Stats.RecvCount++;
lane.Stats.RecvBytes += tmp.BitsLeft() / 8;
bool reliable = Bitstream.ReadBits(tmp, 1) == 1;
uint seq = Bitstream.ReadCompressedUint(tmp);
packets[i].Internal.Seq = seq;
packets[i].Internal.IsReliable = reliable;
if (seq == 0)
{
lane.Stats.RecvAckOnly++;
}
if (reliable)
{
packets[i].Internal.IsFinalPiece = Bitstream.ReadBits(tmp, 1) == 1;
if (!packets[i].Internal.IsFinalPiece)
{
lane.Stats.RecvNonFinal++;
}
if (seq != 0)
{
if (lane.AckCount < lane.Acks.Length)
{
lane.Acks[lane.AckCount++] = seq;
}
}
while (true)
{
uint seqAck = Bitstream.ReadCompressedUint(tmp);
if (seqAck != 0)
{
for (int j=0;j!=lane.OutCount;j++)
{
if (lane.Out[j].SeqId == seqAck)
{
double msLag = (packets[i].ArrivalTime - lane.Out[j].InitialSendTime).TotalMilliseconds;
if (msLag > 0)
{
uint ms = (uint) msLag;
if (ms < lane.LagMsMin || lane.LagMsMin == 0)
{
if (ms >= setup.MinResendTimeMs)
{
lane.LagMsMin = ms;
lane.ResendMs = 2 * ms;
}
}
}
if (lane.Out[j].Source != null)
{
if (--lane.Out[j].Source.userdata == 0)
{
setup.Factory.ReturnBuffer(lane.Out[j].Source);
}
lane.Out[j].Source = null;
}
}
}
continue;
}
break;
}
}
else
{
packets[i].Internal.IsFinalPiece = true;
}
Bitstream.SyncByte(tmp);
}
// Unreliable packets, these are placed in the out queue after reading out the sequence and mode.
for (int i=0;i<packets.Length;i++)
{
if (packets[i].Internal.IsReliable || packets[i].Internal.Seq == 0)
continue;
Lane lane = packets[i].Lane;
if (lane.DoneHead - lane.DoneTail != lane.Done.Length)
{
uint head = lane.DoneHead % (uint)lane.Done.Length;
lane.Done[head].Data = packets[i].Packet;
lane.Done[head].Reliable = false;
lane.Done[head].SeqId = packets[i].Internal.Seq;
lane.Done[head].ArrivalTime = packets[i].ArrivalTime;
lane.Done[head].CompletionTime = packets[i].ArrivalTime;
lane.Done[head].Lane = lane;
lane.DoneHead = lane.DoneHead + 1;
}
}
// Handle reliable. These go straight
for (int i=0;i<packets.Length;i++)
{
if (!packets[i].Internal.IsReliable || packets[i].Internal.Seq == 0)
continue;
Lane lane = packets[i].Lane;
if (packets[i].Internal.Seq <= lane.ReliableSeq)
{
lane.Stats.RecvDupes++;
continue;
}
// If packet arrives a second time, ignore.
uint numProgress = (uint)lane.Progress.Length;
bool hadit = false;
for (uint p = lane.ProgressTail;p != lane.ProgressHead;p++)
{
uint idx = p % numProgress;
if (lane.Progress[idx].SeqId == packets[i].Internal.Seq)
{
hadit = true;
break;
}
}
if (hadit)
{
// Already got the packet for this sequence id.
lane.Stats.RecvDupes++;
continue;
}
if (lane.ProgressHead - lane.ProgressTail != lane.Progress.Length)
{
uint head = lane.ProgressHead % (uint)lane.Progress.Length;
lane.Progress[head].Data = packets[i].Packet;
lane.Progress[head].IsFinalPiece = packets[i].Internal.IsFinalPiece;
lane.Progress[head].ArrivalTime = packets[i].ArrivalTime;
lane.Progress[head].SeqId = packets[i].Internal.Seq;
lane.ProgressHead = lane.ProgressHead + 1;
}
}
}
