private static void UnitTest()
{
var testfileName = "unittest.data";
Stream fOut = new FileStream(testfileName, FileMode.Create, FileAccess.Write);
bool waar = true;
int drie = 3;
bool onwaar = false;
float vloot = 17.5f;
PacketHelper.SafeWrite <bool>(fOut, waar, PacketSize.BoolSize);
PacketHelper.SafeWrite <bool>(fOut, onwaar, PacketSize.BoolSize);
PacketHelper.SafeWrite <int>(fOut, drie, PacketSize.IntSize);
PacketHelper.SafeWrite <float>(fOut, vloot, PacketSize.FloatSize);
PacketHelper.SafeWrite <bool>(fOut, waar, PacketSize.BoolSize);
PacketHelper.SafeWrite <bool>(fOut, onwaar, PacketSize.BoolSize);
fOut.Close();
Stream fIn = new FileStream(testfileName, FileMode.Open, FileAccess.Read);
waar = PacketHelper.SafeRead <bool>(fIn, PacketSize.BoolSize);
if (waar != true)
{
throw new Exception("fout");
}
;
onwaar = PacketHelper.SafeRead <bool>(fIn, PacketSize.BoolSize);
if (onwaar != false)
{
throw new Exception("fout");
}
;
drie = PacketHelper.SafeRead <int>(fIn, PacketSize.IntSize);
if (drie != 3)
{
throw new Exception("fout");
}
;
vloot = PacketHelper.SafeRead <float>(fIn, PacketSize.FloatSize);
if (vloot != 17.5f)
{
throw new Exception("fout");
}
;
waar = PacketHelper.SafeRead <bool>(fIn, PacketSize.BoolSize);
if (waar != true)
{
throw new Exception("fout");
}
;
onwaar = PacketHelper.SafeRead <bool>(fIn, PacketSize.BoolSize);
if (onwaar != false)
{
throw new Exception("fout");
}
;
fIn.Close();
}
private static void Load(string fileName)
{
if (File.Exists(fileName))
{
try
{
var newLap = new CompletedLap(fileName);
if (newLap.lap == null || newLap.lap.lapTime == 0)
{
// Ignored invalid lap
}
else
{
Laps.Add(
new LapInfo()
{
CarNumber = newLap.playerInfo.raceNumber.ToString(),
CircuitName = Constants.TrackList.First(t => t.id == newLap.circuitInfo.trackId).name,
FileName = newLap.FileName(),
LapTime = newLap.lap.lapTime,
PlayerName = PacketHelper.GetString(newLap.playerInfo.name, 48),
SessionType = Constants.SessionTypeList.First(t => t.id == newLap.circuitInfo.sessionType).name,
TeamName = Constants.TeamList.First(t => t.id == newLap.playerInfo.teamId)?.name,
Tyre = "?", // Packet type Car Status not handled yet
Details = newLap
});
}
}
catch // (Exception e)
{
//lama
// MessageDialog.Show(e);
}
}
}
public static T SafeRead <T>(Stream dataStream, int size)
{
bool duurtTeLang = false;
if ((dataStream.Length - dataStream.Position) < size)
{
// Not enough data available
return(default(T));
}
else
{
int read = dataStream.Read(data, 0, size);
while (read != size || duurtTeLang)
{
int extraBytes = dataStream.Read(data, read, size - read);
read = read + extraBytes;
duurtTeLang = (extraBytes == 0);
}
if (read != size)
{
throw new Exception("Incomplete read");
}
return((T)PacketHelper.GetObjectFromBytes(data, typeof(T)));
}
}
public static void Add(CompletedLap completedLap)
{
if (Laps.FirstOrDefault(l => l.FileName == completedLap.Pathname()) == null)
{
// New Lap. Save to disk
Directory.CreateDirectory(BS(baseDir) + completedLap.Dirname());
if (!File.Exists(BS(baseDir) + completedLap.Pathname()))
{
completedLap.Save(baseDir);
Laps.Add(
new LapInfo()
{
CarNumber = completedLap.playerInfo.raceNumber.ToString(),
CircuitName = Constants.TrackList.First(t => t.id == completedLap.circuitInfo.trackId)?.name,
FileName = completedLap.FileName(),
LapTime = completedLap.lap.lapTime,
PlayerName = PacketHelper.GetString(completedLap.playerInfo.name, 48),
SessionType = Constants.SessionTypeList.First(t => t.id == completedLap.circuitInfo.sessionType)?.name,
TeamName = Constants.TeamList.First(t => t.id == completedLap.playerInfo.teamId)?.name,
Tyre = "?", // Packet type Car Status not handled yet
Details = completedLap
});
SaveDictionary();
}
}
}
public void Update(PacketParticipantsData data, bool addAlways = false)
{
participantsData = data;
if (circuit != null)
{
// LogLine("Aantal auto's: " + participantsData.numActiveCars);
circuit.NumberOfCars = data.numActiveCars;
}
int participantIndex = 0;
foreach (var participant in data.participants)
{
var str = PacketHelper.GetString(participant.name, 48);
// Data might be empty if not enough cars available
if (str != "" || participant.driverId != 0)
{
var isAI = (participant.aiControlled == (byte)1 ? "AI" : "=>");
// LogLine($"{isAI} {(int)participant.raceNumber} {str} {PacketHelper.Country(participant.nationality)}, {participant.driverId}, Team:{participant.teamId})");
lock (playerInfo)
{
var player = GetPlayerByDriverID(participant.driverId);
if (player == null || addAlways)
{
playerInfo[participantIndex] = new PlayerInfo(participant, participantIndex);
}
else
{
if (player.CarNumber != participant.raceNumber)
{
if (participant.raceNumber == 0)
{
playerInfo[participantIndex] = new PlayerInfo(participant, participantIndex);
}
else
{
throw new Exception($"Car switch detected {player.Name},{player.CarNumber} => {participant.name},{participant.raceNumber} ");
}
}
else
{
playerInfo[participantIndex]?.Update(participant);
}
}
}
}
participantIndex++;
}
}
public PlayerInfo(ParticipantData p, int index)
{
participantInfo = p;
Id = index;
driverId = p.driverId;
lapStore = new Dictionary <int, LapRecording>();
Name = PacketHelper.GetString(participantInfo.name, 48) + " (" + PacketHelper.CountryShort(participantInfo.nationality) + ")";
CarNumber = participantInfo.raceNumber;
if (index < ColorSchemes.schemes.Count)
{
BackColor = ColorSchemes.schemes[index].Background;
TextColor = ColorSchemes.schemes[index].Text;
}
else
{
BackColor = ColorSchemes.schemes[0].Background;
TextColor = ColorSchemes.schemes[0].Text;
}
}
public void Save(string baseDir)
{
var fileName = BS(baseDir) + Pathname();
Stream fOut = new FileStream(fileName, FileMode.Create, FileAccess.Write);
PacketHelper.SafeWrite <int>(fOut, 211, PacketSize.IntSize); // Version Number
PacketHelper.SafeWrite <PacketSessionData>(fOut, circuitInfo, PacketSize.PacketSessionDataSize);
PacketHelper.SafeWrite <ParticipantData>(fOut, playerInfo, PacketSize.ParticipantDataSize);
PacketHelper.SafeWrite <bool>(fOut, lap.complete, PacketSize.BoolSize);
PacketHelper.SafeWrite <LapData>(fOut, lap.FirstTiming, PacketSize.LapDataSize);
PacketHelper.SafeWrite <UInt32>(fOut, lap.lapTimeInMs, PacketSize.UInt32Size);
PacketHelper.SafeWrite <bool>(fOut, lap.started, PacketSize.BoolSize);
PacketHelper.SafeWrite <bool>(fOut, lap.valid, PacketSize.BoolSize);
PacketHelper.SafeWrite <CarSetupData>(fOut, lap.Setup, PacketSize.CarSetupDataSize);
PacketHelper.SafeWrite <int>(fOut, lap.lapMotion.Count, PacketSize.IntSize);
foreach (var motiondata in lap.lapMotion)
{
PacketHelper.SafeWrite <MotionInContext>(fOut, motiondata, PacketSize.MotionInContextSize);
}
PacketHelper.SafeWrite <int>(fOut, lap.lapTelemetry.Count, PacketSize.IntSize);
foreach (var lapTelemetry in lap.lapTelemetry)
{
PacketHelper.SafeWrite <TelemetryInContext>(fOut, lapTelemetry, PacketSize.TelemetryInContextSize);
}
PacketHelper.SafeWrite <int>(fOut, lap.lapData.Count, PacketSize.IntSize);
foreach (var lapData in lap.lapData)
{
PacketHelper.SafeWrite <LapDataInContext>(fOut, lapData, PacketSize.LapDataInContextSize);
}
fOut.Close();
}
public CompletedLap(string filename)
{
Stream fData = new FileStream(filename, FileMode.Open, FileAccess.Read);
byte[] data = new byte[fData.Length];
long totalRead = 0;
while (totalRead < fData.Length)
{
totalRead += fData.Read(data, (int)totalRead, (int)fData.Length);
}
MemoryStream fIn = new MemoryStream(data);
int version = PacketHelper.SafeRead <int>(fIn, PacketSize.IntSize);
if (version != 211)
{
// Invalid;
return;
}
lap = new LapRecording()
{
lapTelemetry = new List <TelemetryInContext>(),
lapMotion = new List <MotionInContext>(),
lapData = new List <LapDataInContext>()
};
circuitInfo = PacketHelper.SafeRead <PacketSessionData>(fIn, PacketSize.PacketSessionDataSize);
playerInfo = PacketHelper.SafeRead <ParticipantData>(fIn, PacketSize.ParticipantDataSize);
lap.complete = PacketHelper.SafeRead <bool>(fIn, PacketSize.BoolSize);
lap.FirstTiming = PacketHelper.SafeRead <LapData>(fIn, PacketSize.LapDataSize);
if (version == 210)
{
var lapTimeAsFloat = PacketHelper.SafeRead <float>(fIn, PacketSize.FloatSize);
lap.lapTimeInMs = (UInt32)Math.Round(lapTimeAsFloat * 1000f, 0);
}
else
{
lap.lapTimeInMs = PacketHelper.SafeRead <UInt32>(fIn, PacketSize.UInt32Size);
}
lap.started = PacketHelper.SafeRead <bool>(fIn, PacketSize.BoolSize);
lap.valid = PacketHelper.SafeRead <bool>(fIn, PacketSize.BoolSize);
lap.Setup = PacketHelper.SafeRead <CarSetupData>(fIn, PacketSize.CarSetupDataSize);
var timingCount = PacketHelper.SafeRead <int>(fIn, PacketSize.IntSize);
for (int i = 0; i < timingCount; i++)
{
lap.lapMotion.Add(PacketHelper.SafeRead <MotionInContext>(fIn, PacketSize.MotionInContextSize));
}
var telemetryCount = PacketHelper.SafeRead <int>(fIn, PacketSize.IntSize);
for (int i = 0; i < telemetryCount; i++)
{
lap.lapTelemetry.Add(PacketHelper.SafeRead <TelemetryInContext>(fIn, PacketSize.TelemetryInContextSize));
}
var lapDataCount = PacketHelper.SafeRead <int>(fIn, PacketSize.IntSize);
for (int i = 0; i < lapDataCount; i++)
{
lap.lapData.Add(PacketHelper.SafeRead <LapDataInContext>(fIn, PacketSize.LapDataInContextSize));
}
fIn.Close();
}
public string FileName()
{
return(Constants.GetName(Constants.StockType.stSessionType, circuitInfo.sessionType) + (playerInfo.aiControlled == 1 ? " AI " : " ") +
playerInfo.raceNumber.ToString() + " " + PacketHelper.GetString(playerInfo.name, 48) + (circuitInfo.formula == 0 ? " " : " F" + (circuitInfo.formula + 1).ToString() + " ") +
lap.lapTime.ToString("0.000").Replace(",", "."));
}
void HandlePacket(Stream fIn, CancellationToken token)
{
// read Header
var packet = new PacketInfo()
{
sequence = packetCount
};
packet.header = PacketHelper.SafeRead <PacketHeader>(fIn, PacketSize.PacketHeaderSize);
if (fIn.Position == fIn.Length)
{
// No more data
return;
}
// callBack.Log($"{packet.header.frameIdentifier}-");
while (packet.header.frameIdentifier == 0 && packet.header.packetFormat != 2021)
{
// empty packet?
packet.header = PacketHelper.SafeRead <PacketHeader>(fIn, PacketSize.PacketHeaderSize);
}
//if (packet.header.packetFormat != 2020 && packet.header.packetFormat != 2021)
//{
// callBack.LogLine($"FATAL: Invalid packet format: last Packet {packet.header.packetFormat}");
// //throw new Exception($"Invalid packet format: last Packet {packet.header.packetFormat}");
//}
if (ReaderMode == ReaderMode.rmReplay)
{
// Simulate time
if (Starttijd == DateTime.MinValue)
{
Starttijd = DateTime.Now.Add(TimeSpan.FromSeconds(-packet.header.sessionTime));
}
else
{
bool inPause = callBack.IsPausing();
DateTime startPause = DateTime.Now;
while (!token.IsCancellationRequested &&
(callBack.IsPausing() ||
(Starttijd.Add(TimeSpan.FromSeconds(packet.header.sessionTime)) > DateTime.Now)))
{
Thread.Sleep(1);
}
if (inPause)
{
Starttijd = Starttijd.Add(DateTime.Now - startPause);
}
}
}
switch (packet.header.packetId)
{
case 0: // Motion
{
if (logPackets)
{
callBack.Log("."); // Motion info
}
packet.details = PacketHelper.SafeRead <PacketMotionData>(fIn, PacketSize.PacketMotionDataSize);
callBack.UpdateMotion(packet.header, (PacketMotionData)packet.details);
break;
}
case 1: // Session
{
if (logPackets)
{
callBack.Log($"1S"); // Data about the session – track, time left
}
packet.details = PacketHelper.SafeRead <PacketSessionData>(fIn, PacketSize.PacketSessionDataSize);
callBack.UpdateSession(packet.header, (PacketSessionData)packet.details);
break;
}
case 2: // Lap
{
if (logPackets)
{
callBack.Log($"2L"); // Data about all the lap times of cars in the session
}
packet.details = PacketHelper.SafeRead <PacketLapData>(fIn, PacketSize.PacketLapDataSize);
callBack.UpdateLapdata(packet.header, (PacketLapData)packet.details);
break;
}
case 3: // Event
{
if (logPackets)
{
callBack.Log($"3E");
}
var ped = new PacketEventData()
{
eventStringCode = PacketHelper.GetEventType(fIn),
eventDetails = null
};
packet.details = ped;
// Depending on type of event the contents may differ. In C++ this is a union. Therefore the largest packetsize is the size.
byte[] data = new byte[PacketSize.FlashbackSize];
if (fIn.Read(data, 0, PacketSize.FlashbackSize) != PacketSize.FlashbackSize)
{
throw new Exception("Size error");
}
// Read all the remaining bytes into a memory stream to be able to proces them later
MemoryStream ms = new MemoryStream(data);
switch (ped.eventStringCode)
{
case EventType.Unknown:
break;
case EventType.SessionStarted:
callBack.StartSession(packet.header);
break;
case EventType.SessionEnded:
callBack.EndSession(packet.header);
SaveData();
break;
case EventType.FastestLap:
ped.eventDetails = PacketHelper.SafeRead <FastestLap>(ms, PacketSize.FastestLapSize);
break;
case EventType.Retirement:
ped.eventDetails = PacketHelper.SafeRead <Retirement>(ms, PacketSize.RetirementSize);
break;
case EventType.DRSEnabled:
break;
case EventType.DRSDisabled:
break;
case EventType.TeammateInPits:
ped.eventDetails = PacketHelper.SafeRead <TeamMateInPits>(ms, PacketSize.TeamMateInPitsSize);
break;
case EventType.CheckeredFlag:
break;
case EventType.RaceWinner:
ped.eventDetails = PacketHelper.SafeRead <RaceWinner>(ms, PacketSize.RaceWinnerSize);
break;
case EventType.PenaltyIssued:
ped.eventDetails = PacketHelper.SafeRead <Penalty>(ms, PacketSize.PenaltySize);
break;
case EventType.SpeedTrapTriggered:
ped.eventDetails = PacketHelper.SafeRead <SpeedTrap>(ms, PacketSize.SpeedTrapSize);
break;
default:
break;
}
if (logPackets)
{
Console.Write("Evt "); // Various notable events that happen during a session
}
break;
}
case 4: // Participants
{
if (logPackets)
{
callBack.Log($"4P"); /// List of participants in the session, mostly relevant for multiplayer
}
packet.details = PacketHelper.SafeRead <PacketParticipantsData>(fIn, PacketSize.PacketParticipantsDataSize);
Task t = new Task(() =>
{
callBack.UpdatePaticipants((PacketParticipantsData)packet.details);
});
t.Start();
break;
}
case 5: // Car Setup
{
if (logPackets)
{
callBack.Log("5C");
}
packet.details = PacketHelper.SafeRead <PacketCarSetupData>(fIn, PacketSize.PacketCarSetupDataSize);
Console.Write("Setup "); /// Packet detailing car setups for cars in the race
callBack.UpdateSetup(packet.header, (PacketCarSetupData)packet.details);
break;
}
case 6: // Car telemetry
{
if (logPackets)
{
callBack.Log("6T"); /// Telemetry data for all carsbreak;
}
packet.details = PacketHelper.SafeRead <PacketCarTelemetryData>(fIn, PacketSize.PacketCarTelemetryDataSize);
callBack.UpdateTelemetry(packet.header, (PacketCarTelemetryData)packet.details);
break;
}
case 7: // Car Status
{
if (logPackets)
{
callBack.Log("7ST");
}
packet.details = PacketHelper.SafeRead <PacketCarStatusData>(fIn, PacketSize.PacketCarStatusDataSize);
break;
}
case 8: // Final classification
{
if (logPackets)
{
callBack.Log("8F");
}
packet.details = PacketHelper.SafeRead <PacketFinalClassificationData>(fIn, PacketSize.PacketFinalClassificationDataSize);
break;
}
case 9: // Lobby
{
if (logPackets)
{
callBack.Log("9L");
}
packet.details = PacketHelper.SafeRead <PacketLobbyInfoData>(fIn, PacketSize.PacketLobbyInfoDataSize);
break;
}
case 10: // Car Damage
{
if (logPackets)
{
callBack.Log("10L");
}
packet.details = PacketHelper.SafeRead <PacketCarDamageData>(fIn, PacketSize.PacketCarDamageDataSize);
break;
}
case 11: // Session history
{
if (logPackets)
{
callBack.Log("11L");
}
packet.details = PacketHelper.SafeRead <PacketSessionHistoryData>(fIn, PacketSize.PacketSessionHistoryDataSize);
break;
}
default:
{
Console.Write($"??? Unknown packet type: {packet.header.packetId}");
callBack.LogLine($"??? Unknown packet type: {packet.header.packetId}");
break;
}
}
// notificate UI of packet
callBack.AddPacket(packet);
lastPacket = packet;
}
public void Update(ParticipantData p)
{
participantInfo = p;
Name = PacketHelper.GetString(participantInfo.name, 48) + " (" + PacketHelper.CountryShort(participantInfo.nationality) + ")";
}
