private bool TrySaveLap(LapInfo lapInfo)
{
try
{
LapSummaryDto lapSummaryDto = CreateLapSummary(lapInfo);
TimedTelemetrySnapshot fistSnapshotsByDistance = lapInfo.LapTelemetryInfo.TimedTelemetrySnapshots.Snapshots.First(x => x.PlayerData.LapDistance < _sessionInfoDto.LayoutLength * 0.5);
LapTelemetryDto lapTelemetryDto = new LapTelemetryDto()
{
LapSummary = lapSummaryDto,
TimedTelemetrySnapshots = lapInfo.LapTelemetryInfo.TimedTelemetrySnapshots.Snapshots.Skip(lapInfo.LapTelemetryInfo.TimedTelemetrySnapshots.Snapshots.ToList().IndexOf(fistSnapshotsByDistance)).ToArray()
};
Interpolate(lapTelemetryDto, lapTelemetryDto.TimedTelemetrySnapshots.First().SimulatorSourceInfo.TelemetryInfo.RequiresDistanceInterpolation, lapTelemetryDto.TimedTelemetrySnapshots.First().SimulatorSourceInfo.TelemetryInfo.RequiresPositionInterpolation);
LapSummaryDto previousLapInfo = _sessionInfoDto.LapsSummary.FirstOrDefault(x => x.LapNumber == lapSummaryDto.LapNumber);
if (previousLapInfo != null)
{
_sessionInfoDto.LapsSummary.Remove(previousLapInfo);
}
_sessionInfoDto.LapsSummary.Add(lapSummaryDto);
_telemetryRepository.SaveRecentSessionInformation(_sessionInfoDto, SessionIdentifier);
_telemetryRepository.SaveRecentSessionLap(lapTelemetryDto, SessionIdentifier);
return(true);
}
catch (Exception ex)
{
Logger.Error(ex, "Uanble to Save Telemetry");
return(false);
}
}
public void RegisterWin(LapInfo cart)
{
GameObject rankItem = Instantiate(item);
rankItem.transform.parent = uiRanks.transform;
rankItem.GetComponent <Text>().text = "Place nr" + rank + " " + cart.gameObject.name;
}
protected override void OnLapCompleted(LapInfo lap)
{
DriverInfo driver = PluginManager.GetDriverByConnectionId(lap.ConnectionId);
driver.LapCount = lap.LapNo;
if (lap.Cuts == 0 && (lap.Laptime < driver.BestLap || driver.BestLap == 0))
{
driver.BestLap = lap.Laptime;
}
if (this.BroadcastFastestLap > 0)
{
// check if this is a new fastest lap for this session
if (lap.Cuts == 0 && this.PluginManager.CurrentSession.Laps.FirstOrDefault(l => l.Cuts == 0 && l.Laptime < lap.Laptime) == null)
{
this.PluginManager.BroadcastChatMessage(
string.Format("{0} has set a new fastest lap: {1}", driver.DriverName, AcServerPluginManager.FormatTimespan((int)lap.Laptime)));
}
else if (this.BroadcastFastestLap > 1)
{
if (lap.Cuts == 0)
{
this.PluginManager.BroadcastChatMessage(
string.Format("{0} completed a lap: {1}", driver.DriverName, AcServerPluginManager.FormatTimespan((int)lap.Laptime)));
}
else
{
this.PluginManager.BroadcastChatMessage(
string.Format("{0} did a lap with {1} cut(s): {2}", driver.DriverName, lap.Cuts, AcServerPluginManager.FormatTimespan((int)lap.Laptime)));
}
}
}
}
/// <summary>
/// Laps are always sent in a common way, it makes sense to have a shared function to parse them
/// </summary>
private static LapInfo ReadLap(BinaryReader br)
{
var lap = new LapInfo();
lap.LaptimeMS = br.ReadInt32();
lap.CarIndex = br.ReadUInt16();
lap.DriverIndex = br.ReadUInt16();
var splitCount = br.ReadByte();
for (int i = 0; i < splitCount; i++)
{
lap.Splits.Add(br.ReadInt32());
}
lap.IsInvalid = br.ReadByte() > 0;
lap.IsValidForBest = br.ReadByte() > 0;
var isOutlap = br.ReadByte() > 0;
var isInlap = br.ReadByte() > 0;
if (isOutlap)
{
lap.Type = LapType.Outlap;
}
else if (isInlap)
{
lap.Type = LapType.Inlap;
}
else
{
lap.Type = LapType.Regular;
}
// Now it's possible that this is "no" lap that doesn't even include a
// first split, we can detect this by comparing with int32.Max
while (lap.Splits.Count < 3)
{
lap.Splits.Add(null);
}
// "null" entries are Int32.Max, in the C# world we can replace this to null
for (int i = 0; i < lap.Splits.Count; i++)
{
if (lap.Splits[i] == Int32.MaxValue)
{
lap.Splits[i] = null;
}
}
if (lap.LaptimeMS == Int32.MaxValue)
{
lap.LaptimeMS = null;
}
return(lap);
}
private bool SaveLapTelemetrySync(LapInfo lapInfo)
{
if (_sessionInfoDto == null)
{
_sessionInfoDto = CreateSessionInfo(lapInfo);
}
return(TrySaveLap(lapInfo));
}
public int myLapNr; //The number of this trigger box in the list of lap trigger boxes
private void OnTriggerEnter(Collider other)
{
if (other.gameObject.GetComponent <LapInfo>())
{
LapInfo cart = other.gameObject.GetComponent <LapInfo>();
if (myLapNr == cart.lastLapTriggerPassed + 1)
{
cart.lastLapTriggerPassed++;
}
}
}
public void Lap(string label = null)
{
double lapStartTime = laps.Count == 0 ? startTime : laps.Last().endTime;
double lapEndTime = (DateTime.Now - applicationStartTime).TotalSeconds;
double lapSpanTime = lapEndTime - lapStartTime;
LapInfo lap = new LapInfo(
label: string.Format("[{0:000.00}s] {1}", lapSpanTime, label ?? string.Empty),
startTime: lapStartTime,
endTime: lapEndTime);
laps.Add(lap);
}
private static Lap ConvertToSummaryLap(Driver summaryDriver, LapInfo lapInfo, int lapNumber)
{
Lap summaryLap = new Lap(summaryDriver, lapInfo.Valid)
{
LapNumber = lapNumber,
LapTime = lapInfo.LapTime,
Sector1 = lapInfo.Sector1?.Duration ?? TimeSpan.Zero,
Sector2 = lapInfo.Sector2?.Duration ?? TimeSpan.Zero,
Sector3 = lapInfo.Sector3?.Duration ?? TimeSpan.Zero,
LapEndSnapshot = lapInfo.LapTelemetryInfo.LapEndSnapshot
};
return(summaryLap);
}
public Task <bool> TrySaveLapTelemetry(LapInfo lapInfo)
{
Logger.Info($"Saving Telemetry for Lap:{lapInfo.LapNumber}");
if (lapInfo.LapTelemetryInfo.IsPurged)
{
Logger.Error("Lap Is PURGED! Cannot Save");
return(Task.FromResult(false));
}
Task <bool> returnTask = Task.Run(() => SaveLapTelemetrySync(lapInfo));
returnTask.ConfigureAwait(false);
return(returnTask);
}
private LapSummaryDto CreateLapSummary(LapInfo lapInfo)
{
LapSummaryDto lapSummaryDto = new LapSummaryDto()
{
LapNumber = lapInfo.LapNumber,
LapTimeSeconds = lapInfo.LapTime.TotalSeconds,
Sector1Time = lapInfo.Sector1?.Duration ?? TimeSpan.Zero,
Sector2Time = lapInfo.Sector2?.Duration ?? TimeSpan.Zero,
Sector3Time = lapInfo.Sector3?.Duration ?? TimeSpan.Zero,
SessionIdentifier = SessionIdentifier,
Simulator = _sessionInfoDto.Simulator,
TrackName = _sessionInfoDto.TrackName,
LayoutName = _sessionInfoDto.LayoutName,
};
return(lapSummaryDto);
}
private SessionInfoDto CreateSessionInfo(LapInfo lapInfo)
{
SessionInfoDto sessionInfoDto = new SessionInfoDto()
{
CarName = lapInfo.Driver.CarName,
Id = SessionIdentifier,
TrackName = lapInfo.Driver.Session.LastSet.SessionInfo.TrackInfo.TrackName,
LayoutName = lapInfo.Driver.Session.LastSet.SessionInfo.TrackInfo.TrackLayoutName,
LayoutLength = lapInfo.Driver.Session.LastSet.SessionInfo.TrackInfo.LayoutLength.InMeters,
PlayerName = lapInfo.Driver.Name,
Simulator = lapInfo.Driver.Session.LastSet.Source,
SessionRunDateTime = DateTime.Now,
LapsSummary = new List <LapSummaryDto>(),
SessionType = lapInfo.Driver.Session.SessionType.ToString()
};
return(sessionInfoDto);
}
private void parser(string yaml)
{
int start = 0;
int end = 0;
int length = 0;
length = yaml.Length;
start = yaml.IndexOf("WeekendInfo:\n", 0, length);
end = yaml.IndexOf("\n\n", start, length - start);
string WeekendInfo = yaml.Substring(start, end - start);
SharedData.Track.Length = (Single)parseDoubleValue(WeekendInfo, "TrackLength", "km") * 1000;
SharedData.Track.Id = parseIntValue(WeekendInfo, "TrackID");
SharedData.Track.Turns = parseIntValue(WeekendInfo, "TrackNumTurns");
SharedData.Track.City = parseStringValue(WeekendInfo, "TrackCity");
SharedData.Track.Country = parseStringValue(WeekendInfo, "TrackCountry");
SharedData.Track.Altitude = (Single)parseDoubleValue(WeekendInfo, "TrackAltitude", "m");
SharedData.Track.Sky = parseStringValue(WeekendInfo, "TrackSkies");
SharedData.Track.TrackTemperature = (Single)parseDoubleValue(WeekendInfo, "TrackSurfaceTemp", "C");
SharedData.Track.AirTemperature = (Single)parseDoubleValue(WeekendInfo, "TrackAirTemp", "C");
SharedData.Track.AirPressure = (Single)parseDoubleValue(WeekendInfo, "TrackAirPressure", "Hg");
SharedData.Track.WindSpeed = (Single)parseDoubleValue(WeekendInfo, "TrackWindVel", "m/s");
SharedData.Track.WindDirection = (Single)parseDoubleValue(WeekendInfo, "TrackWindDir", "rad");
SharedData.Track.Humidity = parseIntValue(WeekendInfo, "TrackRelativeHumidity", "%");
SharedData.Track.Fog = parseIntValue(WeekendInfo, "TrackFogLevel", "%");
if (parseIntValue(WeekendInfo, "Official") == 0 &&
parseIntValue(WeekendInfo, "SeasonID") == 0 &&
parseIntValue(WeekendInfo, "SeriesID") == 0)
SharedData.Sessions.Hosted = true;
else
SharedData.Sessions.Hosted = false;
if ( SharedData.theme != null )
SharedData.Track.Name = SharedData.theme.TrackNames.getValue("Tracks", SharedData.Track.Id.ToString(),false,"Unknown Track",false);
SharedData.Sessions.SessionId = parseIntValue(WeekendInfo, "SessionID");
SharedData.Sessions.SubSessionId = parseIntValue(WeekendInfo, "SubSessionID");
length = yaml.Length;
start = yaml.IndexOf("DriverInfo:\n", 0, length);
end = yaml.IndexOf("\n\n", start, length - start);
string DriverInfo = yaml.Substring(start, end - start);
length = DriverInfo.Length;
start = DriverInfo.IndexOf(" Drivers:\n", 0, length);
end = length;
string Drivers = DriverInfo.Substring(start, end - start - 1);
string[] driverList = Drivers.Split(new string[] { "\n - " }, StringSplitOptions.RemoveEmptyEntries);
foreach (string driver in driverList)
{
// KJ: fix
// let's see if car is already in list ...
int carIdx = parseIntValue(driver, "CarIdx");
var driverCarIdx = SharedData.Drivers.Find(d => d.CarIdx.Equals(carIdx));
if (driverCarIdx != null)
{
// car already in list, check if driver changed
var newUserId = parseIntValue(driver, "UserID");
if (driverCarIdx.UserId != newUserId)
{
logger.Info("driverChange detected - new driver ({0})", parseStringValue(driver,"UserName"));
// driver changed - update driver details
SharedData.updateControls = true;
SharedData.Drivers.Find(d => d.CarIdx.Equals(carIdx)).Name = parseStringValue(driver, "UserName");
SharedData.Drivers.Find(d => d.CarIdx.Equals(carIdx)).Initials = parseStringValue(driver, "Initials");
if (parseStringValue(driver, "AbbrevName") != null)
{
string[] splitName = parseStringValue(driver, "AbbrevName").Split(',');
if (splitName.Length > 1)
SharedData.Drivers.Find(d => d.CarIdx.Equals(carIdx)).Shortname = splitName[1] + " " + splitName[0];
else
SharedData.Drivers.Find(d => d.CarIdx.Equals(carIdx)).Shortname = parseStringValue(driver, "AbbrevName");
}
else
SharedData.Drivers.Find(d => d.CarIdx.Equals(carIdx)).Shortname = "";
SharedData.Drivers.Find(d => d.CarIdx.Equals(carIdx)).Club = parseStringValue(driver, "Club");
SharedData.Drivers.Find(d => d.CarIdx.Equals(carIdx)).SR = parseStringValue(driver, "SR");
SharedData.Drivers.Find(d => d.CarIdx.Equals(carIdx)).iRating = parseIntValue(driver, "iRating");
SharedData.Drivers.Find(d => d.CarIdx.Equals(carIdx)).UserId = newUserId;
logger.Info("driverChange - looking for external data", "");
string[] external_driver;
if ( SharedData.externalData.TryGetValue(newUserId, out external_driver) )
{
logger.Info("driverChange - external data found", "");
int ed_idx;
if ( ( ed_idx = Int32.Parse(SharedData.theme.getIniValue("General", "dataFullName") ) ) >= 0 && external_driver.Length > ed_idx )
{
SharedData.Drivers.Find(d => d.CarIdx.Equals(carIdx)).Name = external_driver[ed_idx];
}
if ( ( ed_idx = Int32.Parse(SharedData.theme.getIniValue("General", "dataShortName") ) ) >= 0 && external_driver.Length > ed_idx )
{
SharedData.Drivers.Find(d => d.CarIdx.Equals(carIdx)).Shortname = external_driver[ed_idx];
}
if ( ( ed_idx = Int32.Parse(SharedData.theme.getIniValue("General", "dataInitials") ) ) >= 0 && external_driver.Length > ed_idx )
{
SharedData.Drivers.Find(d => d.CarIdx.Equals(carIdx)).Initials = external_driver[ed_idx];
}
}
logger.Info("driverChange - data ready", "");
}
}
int userId = parseIntValue(driver, "UserID");
if (userId < Int32.MaxValue && userId > 0)
{
int index = SharedData.Drivers.FindIndex(d => d.UserId.Equals(userId));
if (index < 0 &&
parseStringValue(driver, "CarPath") != "safety pcfr500s" &&
parseStringValue(driver, "AbbrevName") != "Pace Car")
{
if (SharedData.settings.IncludeMe || (!SharedData.settings.IncludeMe && parseIntValue(driver, "CarIdx") != 63))
{
DriverInfo driverItem = new DriverInfo();
char[] charsToTrim = {'"'};
driverItem.Name = parseStringValue(driver, "UserName");
if (parseStringValue(driver, "AbbrevName") != null)
{
string[] splitName = parseStringValue(driver, "AbbrevName").Split(',');
if (splitName.Length > 1)
driverItem.Shortname = splitName[1] + " " + splitName[0];
else
driverItem.Shortname = parseStringValue(driver, "AbbrevName");
}
driverItem.Initials = parseStringValue(driver, "Initials");
driverItem.Club = parseStringValue(driver, "ClubName");
driverItem.NumberPlate = parseStringValue(driver, "CarNumber").Trim(charsToTrim);
driverItem.CarId = parseIntValue(driver, "CarID");
driverItem.CarClass = parseIntValue(driver, "CarClassID");
driverItem.UserId = parseIntValue(driver, "UserID");
driverItem.CarIdx = parseIntValue(driver, "CarIdx");
driverItem.CarClassName = ( SharedData.theme != null ? SharedData.theme.getCarClass(driverItem.CarId) : "unknown" );
driverItem.iRating = parseIntValue(driver, "IRating");
// KJ: teamID!
driverItem.TeamId = parseIntValue(driver, "TeamID");
int liclevel = parseIntValue(driver, "LicLevel");
int licsublevel = parseIntValue(driver, "LicSubLevel");
switch (liclevel)
{
case 0:
case 1:
case 2:
case 3:
case 4:
driverItem.SR = "R" + ((double)licsublevel / 100).ToString("0.00");
break;
case 5:
case 6:
case 7:
case 8:
driverItem.SR = "D" + ((double)licsublevel / 100).ToString("0.00");
break;
case 9:
case 10:
case 11:
case 12:
driverItem.SR = "C" + ((double)licsublevel / 100).ToString("0.00");
break;
case 14:
case 15:
case 16:
case 17:
driverItem.SR = "B" + ((double)licsublevel / 100).ToString("0.00");
break;
case 18:
case 19:
case 20:
case 21:
driverItem.SR = "A" + ((double)licsublevel / 100).ToString("0.00");
break;
case 22:
case 23:
case 24:
case 25:
driverItem.SR = "P" + ((double)licsublevel / 100).ToString("0.00");
break;
case 26:
case 27:
case 28:
case 29:
driverItem.SR = "WC" + ((double)licsublevel / 100).ToString("0.00");
break;
default:
driverItem.SR = "Unknown";
break;
}
driverItem.CarClass = -1;
int carclass = parseIntValue(driver, "CarClassID");
int freeslot = -1;
for (int i = 0; i < SharedData.Classes.Length; i++)
{
if (SharedData.Classes[i] == carclass)
{
driverItem.CarClass = i;
}
else if (SharedData.Classes[i] == -1 && freeslot < 0)
{
freeslot = i;
}
}
if (driverItem.CarClass < 0 && freeslot >= 0)
{
SharedData.Classes[freeslot] = carclass;
driverItem.CarClass = freeslot;
}
if (!SharedData.externalPoints.ContainsKey(userId) && driverItem.CarIdx < 60)
SharedData.externalPoints.Add(userId, 0);
// fix bugges
if (driverItem.NumberPlate == null)
driverItem.NumberPlate = "000";
if (driverItem.Initials == null)
driverItem.Initials = "";
// KJ: if we are team-racing: get the teamname or make one up ...
if (driverItem.TeamId > 0)
{
if (SharedData.externalTeamData.ContainsKey(driverItem.TeamId))
{
// found teamname for teamid in teams.csv
string[] td_result;
SharedData.externalTeamData.TryGetValue(driverItem.TeamId, out td_result);
driverItem.TeamName = td_result[0];
}
else if (SharedData.externalTeamData.ContainsKey(Int32.Parse(driverItem.NumberPlate)))
{
// found teamname for carnum in teams.csv
string[] td_result;
SharedData.externalTeamData.TryGetValue(Int32.Parse(driverItem.NumberPlate), out td_result);
driverItem.TeamName = td_result[0];
}
else
{
// make up generic teamname (to be parametrized in future)
driverItem.TeamName = "Team #" + driverItem.NumberPlate;
}
}
// KJ: if we have external data - perhaps we shall overload name data for the driver
string[] external_driver;
if (SharedData.externalData.TryGetValue(userId, out external_driver))
{
// found external data for userid
int ed_idx;
SharedData.theme.getIniValue("General", "dataFullName");
if ((ed_idx = Int32.Parse(SharedData.theme.getIniValue("General", "dataFullName"))) >= 0 && external_driver.Length > ed_idx )
{
// fullname gets replaced with column of data.csv
driverItem.Name = external_driver[ed_idx];
}
if ((ed_idx = Int32.Parse(SharedData.theme.getIniValue("General", "dataShortName"))) >= 0 && external_driver.Length > ed_idx )
{
// shortname gets replaced with column of data.csv
driverItem.Shortname = external_driver[ed_idx];
}
if ((ed_idx = Int32.Parse(SharedData.theme.getIniValue("General", "dataInitials"))) >= 0 && external_driver.Length > ed_idx )
{
// initials get replaced with column of data.csv
driverItem.Initials = external_driver[ed_idx];
}
}
SharedData.Drivers.Add(driverItem);
}
}
}
}
length = yaml.Length;
start = yaml.IndexOf("SessionInfo:\n", 0, length);
end = yaml.IndexOf("\n\n", start, length - start);
string SessionInfo = yaml.Substring(start, end - start);
length = SessionInfo.Length;
start = SessionInfo.IndexOf(" Sessions:\n", 0, length);
end = length;
string Sessions = SessionInfo.Substring(start, end - start);
string[] sessionList = Sessions.Split(new string[] { "\n - " }, StringSplitOptions.RemoveEmptyEntries);
// Get Current running Session
int _CurrentSession = (int)sdk.GetData("SessionNum");
foreach (string session in sessionList)
{
int sessionNum = parseIntValue(session, "SessionNum");
if (sessionNum < Int32.MaxValue)
{
int sessionIndex = SharedData.Sessions.SessionList.FindIndex(s => s.Id.Equals(sessionNum));
if (sessionIndex < 0) // add new session item
{
SessionInfo sessionItem = new SessionInfo();
sessionItem.Id = sessionNum;
sessionItem.LapsTotal = parseIntValue(session, "SessionLaps");
sessionItem.SessionLength = parseFloatValue(session, "SessionTime", "sec");
sessionItem.Type = sessionTypeMap[parseStringValue(session, "SessionType")];
if (sessionItem.Type == SessionTypes.race)
{
sessionItem.FinishLine = parseIntValue(session, "SessionLaps") + 1;
}
else
{
sessionItem.FinishLine = Int32.MaxValue;
}
if (sessionItem.FinishLine < 0)
{
sessionItem.FinishLine = Int32.MaxValue;
}
sessionItem.Cautions = parseIntValue(session, "ResultsNumCautionFlags");
sessionItem.CautionLaps = parseIntValue(session, "ResultsNumCautionLaps");
sessionItem.LeadChanges = parseIntValue(session, "ResultsNumLeadChanges");
sessionItem.LapsComplete = parseIntValue(session, "ResultsLapsComplete");
length = session.Length;
start = session.IndexOf(" ResultsFastestLap:\n", 0, length);
end = length;
string ResultsFastestLap = session.Substring(start, end - start);
sessionItem.FastestLap = parseFloatValue(ResultsFastestLap, "FastestTime");
int index = SharedData.Drivers.FindIndex(d => d.CarIdx.Equals(parseIntValue(ResultsFastestLap, "CarIdx")));
if (index >= 0)
{
sessionItem.FastestLapDriver = SharedData.Drivers[index];
sessionItem.FastestLapNum = parseIntValue(ResultsFastestLap, "FastestLap");
}
SharedData.Sessions.SessionList.Add(sessionItem);
sessionIndex = SharedData.Sessions.SessionList.FindIndex(s => s.Id.Equals(sessionNum));
}
else // update only non fixed fields
{
SharedData.Sessions.SessionList[sessionIndex].LeadChanges = parseIntValue(session, "ResultsNumLeadChanges");
SharedData.Sessions.SessionList[sessionIndex].LapsComplete = parseIntValue(session, "ResultsLapsComplete");
length = session.Length;
start = session.IndexOf(" ResultsFastestLap:\n", 0, length) + " ResultsFastestLap:\n".Length;
end = length;
string ResultsFastestLap = session.Substring(start, end - start);
SharedData.Sessions.SessionList[sessionIndex].FastestLap = parseFloatValue(ResultsFastestLap, "FastestTime");
int index = SharedData.Drivers.FindIndex(d => d.CarIdx.Equals(parseIntValue(ResultsFastestLap, "CarIdx")));
if (index >= 0)
{
SharedData.Sessions.SessionList[sessionIndex].FastestLapDriver = SharedData.Drivers[index];
SharedData.Sessions.SessionList[sessionIndex].FastestLapNum = parseIntValue(ResultsFastestLap, "FastestLap");
}
}
length = session.Length;
start = session.IndexOf(" ResultsPositions:\n", 0, length);
end = session.IndexOf(" ResultsFastestLap:\n", start, length - start);
string Standings = session.Substring(start, end - start);
string[] standingList = Standings.Split(new string[] { "\n - " }, StringSplitOptions.RemoveEmptyEntries);
Int32 position = 1;
List<DriverInfo> standingsDrivers = SharedData.Drivers.ToList();
foreach (string standing in standingList)
{
int carIdx = parseIntValue(standing, "CarIdx");
if (carIdx < Int32.MaxValue)
{
StandingsItem standingItem = new StandingsItem();
standingItem = SharedData.Sessions.SessionList[sessionIndex].FindDriver(carIdx);
standingsDrivers.Remove(standingsDrivers.Find(s => s.CarIdx.Equals(carIdx)));
if (parseFloatValue(standing, "LastTime") > 0)
{
if (parseFloatValue(standing, "LastTime") < SharedData.Sessions.SessionList[sessionIndex].FastestLap && SharedData.Sessions.SessionList[sessionIndex].FastestLap > 0)
{
// Race Condition?
//SharedData.Sessions.SessionList[sessionIndex].FastestLap = parseFloatValue(standing, "FastestTime");
}
}
/*
if (parseFloatValue(standing, "FastestTime") < SharedData.Sessions.SessionList[sessionIndex].FastestLap ||
SharedData.Sessions.SessionList[sessionIndex].FastestLap <= 0)
{
SharedData.Sessions.SessionList[sessionIndex].FastestLap = parseFloatValue(standing, "FastestTime");
}
*/
/*
if (standingItem.Finished == false)
{
standingItem.PreviousLap.LapTime = parseFloatValue(standing, "LastTime");
if (standingItem.PreviousLap.LapTime <= 1)
{
standingItem.PreviousLap.LapTime = standingItem.CurrentLap.LapTime;
}
}
*/
if (SharedData.Sessions.SessionList[sessionIndex].Type == SharedData.Sessions.CurrentSession.Type)
{
if ((standingItem.CurrentTrackPct % 1.0) > 0.1)
{
standingItem.PreviousLap.Position = parseIntValue(standing, "Position");
standingItem.PreviousLap.Gap = parseFloatValue(standing, "Time");
standingItem.PreviousLap.GapLaps = parseIntValue(standing, "Lap");
standingItem.CurrentLap.Position = parseIntValue(standing, "Position");
}
}
if (standingItem.Driver.CarIdx < 0)
{
// insert item
int driverIndex = SharedData.Drivers.FindIndex(d => d.CarIdx.Equals(carIdx));
standingItem.setDriver(carIdx);
standingItem.FastestLap = parseFloatValue(standing, "FastestTime");
standingItem.LapsLed = parseIntValue(standing, "LapsLed");
standingItem.CurrentTrackPct = parseFloatValue(standing, "LapsDriven");
standingItem.Laps = new List<LapInfo>();
LapInfo newLap = new LapInfo();
newLap.LapNum = parseIntValue(standing, "LapsComplete");
newLap.LapTime = parseFloatValue(standing, "LastTime");
newLap.Position = parseIntValue(standing, "Position");
newLap.Gap = parseFloatValue(standing, "Time");
newLap.GapLaps = parseIntValue(standing, "Lap");
newLap.SectorTimes = new List<Sector>(3);
standingItem.Laps.Add(newLap);
standingItem.CurrentLap = new LapInfo();
standingItem.CurrentLap.LapNum = parseIntValue(standing, "LapsComplete") + 1;
standingItem.CurrentLap.Position = parseIntValue(standing, "Position");
standingItem.CurrentLap.Gap = parseFloatValue(standing, "Time");
standingItem.CurrentLap.GapLaps = parseIntValue(standing, "Lap");
lock (SharedData.SharedDataLock)
{
SharedData.Sessions.SessionList[sessionIndex].Standings.Add(standingItem);
SharedData.Sessions.SessionList[sessionIndex].UpdatePosition();
}
}
int lapnum = parseIntValue(standing, "LapsComplete");
standingItem.FastestLap = parseFloatValue(standing, "FastestTime");
standingItem.LapsLed = parseIntValue(standing, "LapsLed");
if (SharedData.Sessions.SessionList[sessionIndex].Type == SharedData.Sessions.CurrentSession.Type)
{
standingItem.PreviousLap.LapTime = parseFloatValue(standing, "LastTime");
}
if (SharedData.Sessions.CurrentSession.State == SessionStates.cooldown)
{
standingItem.CurrentLap.Gap = parseFloatValue(standing, "Time");
standingItem.CurrentLap.GapLaps = parseIntValue(standing, "Lap");
standingItem.CurrentLap.Position = parseIntValue(standing, "Position");
standingItem.CurrentLap.LapNum = parseIntValue(standing, "LapsComplete");
}
standingItem.Position = parseIntValue(standing, "Position");
standingItem.NotifySelf();
standingItem.NotifyLaps();
position++;
}
}
// Trigger Overlay Event, but only in current active session
if ((SharedData.Sessions.SessionList[sessionIndex].FastestLap != SharedData.Sessions.SessionList[sessionIndex].PreviousFastestLap)
&& (_CurrentSession == SharedData.Sessions.SessionList[sessionIndex].Id)
)
{
if (SharedData.Sessions.SessionList[sessionIndex].FastestLap > 0)
{
SessionEvent ev = new SessionEvent(
SessionEventTypes.fastlap,
(Int32)(((Double)sdk.GetData("SessionTime") * 60) + timeoffset),
SharedData.Sessions.SessionList[sessionIndex].FastestLapDriver,
"New session fastest lap (" + Utils.floatTime2String(SharedData.Sessions.SessionList[sessionIndex].FastestLap, 3, false) + ")",
SharedData.Sessions.SessionList[sessionIndex].Type,
SharedData.Sessions.SessionList[sessionIndex].FastestLapNum
);
SharedData.Events.Add(ev);
// Push Event to Overlay
logger.Info("New fastest lap in Session {0} : {1}", _CurrentSession, SharedData.Sessions.SessionList[sessionIndex].FastestLap);
SharedData.triggers.Push(TriggerTypes.fastestlap);
}
}
// update/add position for drivers not in results
foreach (DriverInfo driver in standingsDrivers)
{
StandingsItem standingItem = SharedData.Sessions.SessionList[sessionIndex].FindDriver(driver.CarIdx);
if (standingItem.Driver.CarIdx < 0)
{
if (SharedData.settings.IncludeMe || (!SharedData.settings.IncludeMe && standingItem.Driver.CarIdx != 63))
{
standingItem.setDriver(driver.CarIdx);
standingItem.Position = position;
standingItem.Laps = new List<LapInfo>();
lock (SharedData.SharedDataLock)
{
SharedData.Sessions.SessionList[sessionIndex].Standings.Add(standingItem);
}
position++;
}
}
else if (!SharedData.settings.IncludeMe && driver.CarIdx < 63)
{
standingItem.Position = position;
position++;
}
}
}
}
// add qualify session if it doesn't exist when race starts and fill it with YAML QualifyResultsInfo
SessionInfo qualifySession = SharedData.Sessions.findSessionByType(SessionTypes.qualify);
if (qualifySession.Type == SessionTypes.none)
{
qualifySession.Type = SessionTypes.qualify;
length = yaml.Length;
start = yaml.IndexOf("QualifyResultsInfo:\n", 0, length);
// if found
if (start >= 0)
{
end = yaml.IndexOf("\n\n", start, length - start);
string QualifyResults = yaml.Substring(start, end - start);
length = QualifyResults.Length;
start = QualifyResults.IndexOf(" Results:\n", 0, length);
end = length;
string Results = QualifyResults.Substring(start, end - start - 1);
string[] resultList = Results.Split(new string[] { "\n - " }, StringSplitOptions.RemoveEmptyEntries);
qualifySession.FastestLap = float.MaxValue;
foreach (string result in resultList)
{
if (result != " Results:")
{
StandingsItem qualStandingsItem = qualifySession.FindDriver(parseIntValue(result, "CarIdx"));
if (qualStandingsItem.Driver.CarIdx > 0) // check if driver is in quali session
{
qualStandingsItem.Position = parseIntValue(result, "Position") + 1;
}
else // add driver to quali session
{
qualStandingsItem.setDriver(parseIntValue(result, "CarIdx"));
qualStandingsItem.Position = parseIntValue(result, "Position") + 1;
qualStandingsItem.FastestLap = parseFloatValue(result, "FastestTime");
lock (SharedData.SharedDataLock)
{
qualifySession.Standings.Add(qualStandingsItem);
}
// update session fastest lap
if (qualStandingsItem.FastestLap < qualifySession.FastestLap && qualStandingsItem.FastestLap > 0)
qualifySession.FastestLap = qualStandingsItem.FastestLap;
}
}
}
SharedData.Sessions.SessionList.Add(qualifySession); // add quali session
}
}
// get qualify results if race session standings is empty
foreach (SessionInfo session in SharedData.Sessions.SessionList)
{
if (session.Type == SessionTypes.race && session.Standings.Count < 1)
{
length = yaml.Length;
start = yaml.IndexOf("QualifyResultsInfo:\n", 0, length);
// if found
if (start >= 0)
{
end = yaml.IndexOf("\n\n", start, length - start);
string QualifyResults = yaml.Substring(start, end - start);
length = QualifyResults.Length;
start = QualifyResults.IndexOf(" Results:\n", 0, length);
end = length;
string Results = QualifyResults.Substring(start, end - start - 1);
string[] resultList = Results.Split(new string[] { "\n - " }, StringSplitOptions.RemoveEmptyEntries);
foreach (string result in resultList)
{
if (result != " Results:")
{
StandingsItem standingItem = new StandingsItem();
standingItem.setDriver(parseIntValue(result, "CarIdx"));
standingItem.Position = parseIntValue(result, "Position") + 1;
lock (SharedData.SharedDataLock)
{
session.Standings.Add(standingItem);
}
}
}
}
}
}
length = yaml.Length;
start = yaml.IndexOf("CameraInfo:\n", 0, length);
end = yaml.IndexOf("\n\n", start, length - start);
string CameraInfo = yaml.Substring(start, end - start);
length = CameraInfo.Length;
start = CameraInfo.IndexOf(" Groups:\n", 0, length);
end = length;
string Cameras = CameraInfo.Substring(start, end - start - 1);
string[] cameraList = Cameras.Split(new string[] { "\n - " }, StringSplitOptions.RemoveEmptyEntries);
bool haveNewCam = false;
foreach (string camera in cameraList)
{
int cameraNum = parseIntValue(camera, "GroupNum");
if (cameraNum < Int32.MaxValue)
{
CameraGroup camgrp = SharedData.Camera.FindId(cameraNum);
if (camgrp.Id < 0)
{
CameraGroup cameraGroupItem = new CameraGroup();
cameraGroupItem.Id = cameraNum;
cameraGroupItem.Name = parseStringValue(camera, "GroupName");
lock (SharedData.SharedDataLock)
{
SharedData.Camera.Groups.Add(cameraGroupItem);
haveNewCam = true;
}
}
}
}
if (SharedData.settings.CamerasButtonColumn && haveNewCam) // If we have a new cam and want Camera Buttons, then forece a refresh of the main window buttons
SharedData.refreshButtons = true;
length = yaml.Length;
start = yaml.IndexOf("SplitTimeInfo:\n", 0, length);
end = yaml.IndexOf("\n\n", start, length - start);
string SplitTimeInfo = yaml.Substring(start, end - start);
length = SplitTimeInfo.Length;
start = SplitTimeInfo.IndexOf(" Sectors:\n", 0, length);
end = length;
string Sectors = SplitTimeInfo.Substring(start, end - start - 1);
string[] sectorList = Sectors.Split(new string[] { "\n - " }, StringSplitOptions.RemoveEmptyEntries);
if (sectorList.Length != SharedData.Sectors.Count)
{
SharedData.Sectors.Clear();
foreach (string sector in sectorList)
{
int sectornum = parseIntValue(sector, "SectorNum");
if (sectornum < 100)
{
float sectorborder = parseFloatValue(sector, "SectorStartPct");
SharedData.Sectors.Add(sectorborder);
}
}
// automagic sector selection
if (SharedData.SelectedSectors.Count == 0)
{
SharedData.SelectedSectors.Clear();
// load sectors
CfgFile sectorsIni = new CfgFile(Directory.GetCurrentDirectory() + "\\sectors.ini");
string sectorValue = sectorsIni.getValue("Sectors", SharedData.Track.Id.ToString(),false,String.Empty,false);
string[] selectedSectors = sectorValue.Split(';');
Array.Sort(selectedSectors);
SharedData.SelectedSectors.Clear();
if (sectorValue.Length > 0)
{
foreach (string sector in selectedSectors)
{
float number;
if (Single.TryParse(sector, out number))
{
SharedData.SelectedSectors.Add(number);
}
}
}
else
{
if (SharedData.Sectors.Count == 2)
{
foreach (float sector in SharedData.Sectors)
SharedData.SelectedSectors.Add(sector);
}
else
{
float prevsector = 0;
foreach (float sector in SharedData.Sectors)
{
if (sector == 0 && SharedData.SelectedSectors.Count == 0)
{
SharedData.SelectedSectors.Add(sector);
}
else if (sector >= 0.333 && SharedData.SelectedSectors.Count == 1)
{
if (sector - 0.333 < Math.Abs(prevsector - 0.333))
{
SharedData.SelectedSectors.Add(sector);
}
else
{
SharedData.SelectedSectors.Add(prevsector);
}
}
else if (sector >= 0.666 && SharedData.SelectedSectors.Count == 2)
{
if (sector - 0.666 < Math.Abs(prevsector - 0.666))
{
SharedData.SelectedSectors.Add(sector);
}
else
{
SharedData.SelectedSectors.Add(prevsector);
}
}
prevsector = sector;
}
}
}
}
}
}
protected override void OnLapCompleted(LapInfo msg)
{
using (var a = new FileStream("Test.txt", FileMode.Append, FileAccess.Write))
using (var b = new StreamWriter(a))
{
b.WriteLine($"{DateTime.Now.TimeOfDay}: OnLapCompleted Called:{TimeSpan.FromMilliseconds(msg.Laptime).ToString()}");
}
var currentCompetitor = Competitors.FirstOrDefault(driver => msg.ConnectionId == driver.ConnectionId);
var currentLap = CurrentLaps.FirstOrDefault(l => l.CompetitorId == currentCompetitor.CompetitorId);
CurrentLaps.Remove(currentLap);
if (currentLap != null)
{
currentLap.Cuts = msg.Cuts;
currentLap.GripLevel = msg.GripLevel;
currentLap.LapTime = (int)msg.Laptime;
currentLap.LapNo = msg.LapNo;
currentLap.Timestamp = (int)msg.Timestamp;
currentLap.Position = msg.Position;
currentLap.IsValid = msg.Cuts == 0;
currentLap.LapLength = msg.LapLength;
currentLap.TyreCompound = currentCompetitor.CurrentTyreCompound;
if (currentLap.Sector1 == default(int?))
{
currentLap.Sector1 = currentLap.LapTime;
}
else if (currentLap.Sector2 == default(int?))
{
currentLap.Sector2 = currentLap.LapTime - currentLap.Sector1;
}
else if (currentLap.Sector3 == default(int?))
{
currentLap.Sector3 = currentLap.LapTime - currentLap.Sector1 - currentLap.Sector2;
}
var result = ApiWrapperNet4.Post <Lap>("lap/editlap", currentLap);
}
else
{
Lap lap = new Lap
{
LapId = Guid.NewGuid().ToString(),
CompetitorId = currentCompetitor.CompetitorId,
ConnectionId = msg.ConnectionId,
Cuts = msg.Cuts,
GripLevel = msg.GripLevel,
LapTime = (int)msg.Laptime,
LapNo = msg.LapNo,
Timestamp = (int)msg.Timestamp,
Position = msg.Position,
IsValid = msg.Cuts == 0,
LapLength = msg.LapLength,
TyreCompound = currentCompetitor.CurrentTyreCompound
};
var addLap = ApiWrapperNet4.Post <Lap>("lap/addlap", lap);
}
}
public virtual void OnLapCompleted(LapInfo msg)
{
}
public LapEventArgs(LapInfo lapInfo)
{
Lap = lapInfo;
}
protected internal virtual void OnLapCompleted(LapInfo msg)
{
}
protected override void OnLapCompleted(LapInfo lap)
{
base.OnLapCompleted(lap);
this.form.BeginInvoke(new Action(this.form.UpdateGui), null);
}
public LapViewModel(LapInfo lapInfo)
{
LapInfo = lapInfo;
RefreshInfo();
TimerMethod(RefreshInfo, () => LapInfo.Driver.Session.TimingDataViewModel.DisplaySettingsViewModel.RefreshRate);
}
protected virtual IList <ILapInfo> ParseLaps(SessionData session)
{
var sessionLaps = new List <ILapInfo>();
var currentLapNumber = -999;
var currentLapIndex = 0;
var currentFrameIndex = 0;
var lapFrameCount = 0;
var lapMap = new Dictionary <int, lapInfo>();
lapInfo _lapInfo = new lapInfo();
foreach (var frame in session.Frames.OrderBy(f => f.SessionTime))
{
if (frame.Lap > 0)
{
if (frame.Lap != currentLapNumber)
{
// save existing lap info, if any.
if (currentLapNumber != -999)
{
_lapInfo.frameCount = lapFrameCount;
_lapInfo.lapIndex = currentLapIndex;
lapMap.Add(currentLapIndex, _lapInfo);
currentLapIndex++;
}
_lapInfo = new lapInfo();
_lapInfo.lapNumber = frame.Lap;
_lapInfo.sessionState = (irsdk_SessionState)frame.SessionState;
_lapInfo.startFrameIdx = currentFrameIndex;
lapFrameCount = 0;
currentLapNumber = frame.Lap;
}
else
{
if (lapMap.Count > 0)
{
var lastLap = lapMap[lapMap.Count - 1];
// same lap... lap time changed?
if (frame.LapLastLapTime != lastLap.lapTime)
{
lastLap.lapTime = frame.LapLastLapTime;
lastLap.lapSpeed = 0F; // TODO: Calculate Speed
lapMap[lapMap.Count - 1] = lastLap;
}
}
}
lapFrameCount++;
currentFrameIndex++;
}
}
// add the last lap
_lapInfo.frameCount = lapFrameCount;
if (lapMap.Count > 0)
{
var lastLapInfo = lapMap[lapMap.Count - 1];
var lastFrame = session.Frames.OrderBy(f => f.SessionTime).LastOrDefault();
if ((null == lastFrame) || lastLapInfo.lapTime == lastFrame.LapLastLapTime)
{
_lapInfo.lapTime = -2;
}
else
{
_lapInfo.lapTime = lastFrame.LapLastLapTime;
}
}
else
{
_lapInfo.lapTime = -1;
}
_lapInfo.lapIndex = currentLapIndex;
lapMap.Add(currentLapIndex, _lapInfo);
var trackLength = GetTrackLengthInMiles(session);
// map is built, build the lap list.
foreach (lapInfo lap in lapMap.Values)
{
var lapSpeed = (lap.lapTime > 1) ? ((float)trackLength / lap.lapTime) * 3600 : 0;
var newLap = new LapInfo()
{
FrameIndex = lap.startFrameIdx,
LapIndex = lap.lapIndex,
LapNumber = lap.lapNumber,
LapSpeed = lapSpeed,
LapTime = lap.lapTime,
SessionState = lap.sessionState,
LapFrames = session.Frames.Skip(lap.startFrameIdx).Take(lap.frameCount).ToList()
};
sessionLaps.Add(newLap);
}
return(sessionLaps);
}
