private void OnPcapTimer(Object source, ElapsedEventArgs e)
{
// Console.WriteLine("The Elapsed event of the pcapTimer was raised at {0:HH:mm:ss.fff}", e.SignalTime);
uint myTimer = PCapReader.StartTime + PcapSeconds;
for (var i = PCapReader.CurrentPcapRecordStart; i < PCapReader.EndRecordIndex; i++)
{
// Check if the record is not a "send" (client TO server)
if (PCapReader.Records[i].isSend == false && PCapReader.Records[i].tsSec == myTimer)
{
GameMessageGroup group = GameMessageGroup.InvalidQueue;
if (PCapReader.Records[i].frags.Count > 0)
{
group = (GameMessageGroup)PCapReader.Records[i].frags[0].memberHeader_.queueID;
}
var opcode = (GameMessageOpcode)PCapReader.Records[i].opcodes[0];
// Console.WriteLine("--Sending packet " + opcode.ToString());
// Set opcode to none since it will be written as part of the data packet
GameMessage newMessage = new GameMessage(GameMessageOpcode.None, group);
switch (opcode)
{
case GameMessageOpcode.UpdatePosition:
var updatePosData = getUpdatePosition(PCapReader.Records[i].data);
newMessage.Writer.Write(updatePosData);
break;
case GameMessageOpcode.MovementEvent:
var movementEventData = getMovementEvent(PCapReader.Records[i].data);
newMessage.Writer.Write(movementEventData);
break;
default:
newMessage.Writer.Write(PCapReader.Records[i].data);
break;
}
SendMessage(newMessage);
PCapReader.CurrentPcapRecordStart = i;
}
}
PcapSeconds++;
// Write out how far along we are...
var perc = (float)PCapReader.CurrentPcapRecordStart / (float)TotalRecords * 100f;
string percentDone = perc.ToString("0.0");
if (percentDone != PercentComplete.ToString("0.0"))
{
Console.WriteLine($"Processed record {PCapReader.CurrentPcapRecordStart} - {percentDone}% complete.");
PercentComplete = perc;
}
if (PCapReader.Records[PCapReader.EndRecordIndex - 1].tsSec <= myTimer)
{
Console.WriteLine("*************** FINISHED ***************");
StopPcapPlayback();
}
}
public GameEventMessage(GameEventType eventType, GameMessageGroup group, Session session) : base(GameMessageOpcode.GameEvent, group)
{
EventType = eventType;
Session = session;
Writer.WriteGuid(session.Player.Guid);
Writer.Write(session.GameEventSequence++);
Writer.Write((uint)EventType);
}
protected GameEventMessage(GameEventType eventType, GameMessageGroup group, Session session) : base(GameMessageOpcode.GameEvent, group)
{
EventType = eventType;
Session = session;
// Force session to not be null -- due to races with player initialization
session.WaitForPlayer();
Writer.WriteGuid(session.Player.Guid);
Writer.Write(session.GameEventSequence++);
Writer.Write((uint)EventType);
}
protected GameEventMessage(GameEventType eventType, GameMessageGroup group, Session session) : base(GameMessageOpcode.GameEvent, group)
{
EventType = eventType;
Session = session;
Writer.WriteGuid(session.Player.Guid);
//var debugMessage = $"GameEventSequence Update - {eventType} - GameEventSequence was {session.GameEventSequence}";
Writer.Write(session.GameEventSequence++);
//Console.WriteLine(debugMessage + $" and is now {session.GameEventSequence}");
Writer.Write((uint)EventType);
}
protected GameEventMessage(GameEventType eventType, GameMessageGroup group, Session session) : base(GameMessageOpcode.GameEvent, group)
{
EventType = eventType;
Session = session;
// Force session to not be null -- due to races with player initialization
session.WaitForPlayer();
Writer.WriteGuid(session.Player.Guid);
var debugMessage = $"GameEventSequence Update - {eventType} - GameEventSequence was {session.GameEventSequence}";
Writer.Write(session.GameEventSequence++);
//Console.WriteLine(debugMessage + $" and is now {session.GameEventSequence}");
Writer.Write((uint)EventType);
}
protected GameMessage(GameMessageOpcode opCode, GameMessageGroup group)
{
Opcode = opCode;
Group = group;
Data = new System.IO.MemoryStream();
Writer = new System.IO.BinaryWriter(Data);
if (Opcode != GameMessageOpcode.None)
{
Writer.Write((uint)Opcode);
}
}
/// <summary>
/// This function handles turning a bundle of messages (representing all messages accrued in a timeslice),
/// into 1 or more packets, combining multiple messages into one packet or spliting large message across
/// several packets as needed.
/// </summary>
/// <param name="bundle"></param>
private void SendBundle(NetworkBundle bundle, GameMessageGroup group)
{
packetLog.DebugFormat("[{0}] Sending Bundle", session.LoggingIdentifier);
bool writeOptionalHeaders = true;
List <MessageFragment> fragments = new List <MessageFragment>();
// Pull all messages out and create MessageFragment objects
while (bundle.HasMoreMessages)
{
var message = bundle.Dequeue();
var fragment = new MessageFragment(message, ConnectionData.FragmentSequence++);
fragments.Add(fragment);
}
packetLog.DebugFormat("[{0}] Bundle Fragment Count: {1}", session.LoggingIdentifier, fragments.Count);
// Loop through while we have fragements
while (fragments.Count > 0 || writeOptionalHeaders)
{
ServerPacket packet = new ServerPacket();
PacketHeader packetHeader = packet.Header;
if (fragments.Count > 0)
{
packetHeader.Flags |= PacketHeaderFlags.BlobFragments;
}
if (bundle.EncryptedChecksum)
{
packetHeader.Flags |= PacketHeaderFlags.EncryptedChecksum;
}
int availableSpace = ServerPacket.MaxPacketSize;
// Pull first message and see if it is a large one
var firstMessage = fragments.FirstOrDefault();
if (firstMessage != null)
{
// If a large message send only this one, filling the whole packet
if (firstMessage.DataRemaining >= availableSpace)
{
packetLog.DebugFormat("[{0}] Sending large fragment", session.LoggingIdentifier);
ServerPacketFragment spf = firstMessage.GetNextFragment();
packet.Fragments.Add(spf);
availableSpace -= spf.Length;
if (firstMessage.DataRemaining <= 0)
{
fragments.Remove(firstMessage);
}
}
// Otherwise we'll write any optional headers and process any small messages that will fit
else
{
if (writeOptionalHeaders)
{
writeOptionalHeaders = false;
WriteOptionalHeaders(bundle, packet);
if (packet.Data != null)
{
availableSpace -= (int)packet.Data.Length;
}
}
// Create a list to remove completed messages after iterator
List <MessageFragment> removeList = new List <MessageFragment>();
foreach (MessageFragment fragment in fragments)
{
// Is this a large fragment and does it have a tail that needs sending?
if (!fragment.TailSent && availableSpace >= fragment.TailSize)
{
packetLog.DebugFormat("[{0}] Sending tail fragment", session.LoggingIdentifier);
ServerPacketFragment spf = fragment.GetTailFragment();
packet.Fragments.Add(spf);
availableSpace -= spf.Length;
}
// Otherwise will this message fit in the remaining space?
else if (availableSpace >= fragment.NextSize)
{
packetLog.DebugFormat("[{0}] Sending small message", session.LoggingIdentifier);
ServerPacketFragment spf = fragment.GetNextFragment();
packet.Fragments.Add(spf);
availableSpace -= spf.Length;
}
// If message is out of data, set to remove it
if (fragment.DataRemaining <= 0)
{
removeList.Add(fragment);
}
}
// Remove all completed messages
fragments.RemoveAll(x => removeList.Contains(x));
}
}
// If no messages, write optional headers
else
{
packetLog.DebugFormat("[{0}] No messages, just sending optional headers", session.LoggingIdentifier);
if (writeOptionalHeaders)
{
writeOptionalHeaders = false;
WriteOptionalHeaders(bundle, packet);
if (packet.Data != null)
{
availableSpace -= (int)packet.Data.Length;
}
}
}
EnqueueSend(packet);
}
}
