public SessionInfo()
{
id = 0;
lapsTotal = 0;
lapsComplete = 0;
leadChanges = 0;
cautions = 0;
cautionLaps = 0;
fastestlap = 0;
fastestdriver = new DriverInfo();
fastestlapnum = 0;
time = 0;
sessiontimeremaining = 0;
sessionlength = 0;
sessionstarttime = -1;
sessionstartpos = 0;
finishline = Int32.MaxValue;
type = sessionType.invalid;
state = sessionState.invalid;
flag = sessionFlag.invalid;
startlight = sessionStartLight.off;
standings = new List<StandingsItem>();
followedDriver = new StandingsItem();
}
public Event(eventType type, Int64 replay, DriverInfo driver, String desc, Sessions.SessionInfo.sessionType session, Int32 lap)
{
this.type = type;
this.timestamp = DateTime.Now;
this.replaypos = replay;
this.driver = driver;
this.description = desc;
this.session = session;
this.lapnum = lap;
this.rewind = 0;
}
public void setDriver(int carIdx)
{
int index = SharedData.Drivers.FindIndex(d => d.CarIdx.Equals(carIdx));
if (index >= 0)
{
driver = SharedData.Drivers[index];
}
else
{
driver = new DriverInfo();
}
}
public StandingsItem()
{
driver = new DriverInfo();
laps = new List<LapInfo>();
fastestlap = 0;
lapsled = 0;
classlapsled = 0;
surface = SurfaceType.NotInWorld;
trackpct = 0;
prevtrackpct = 0;
speed = 0;
prevspeed = 0;
position = 0;
currentlap = new LapInfo();
sector = 0;
sectorbegin = 0;
pitstops = 0;
pitstoptime = 0;
pitstorbegin = DateTime.MinValue;
begin = 0;
finished = false;
offtracksince = 0;
positionlive = 0;
}
public Int32 getClassPosition(DriverInfo driver)
{
IEnumerable<Sessions.SessionInfo.StandingsItem> query = this.Standings.Where(s => s.Driver.CarClassName == driver.CarClassName).OrderBy(s => s.Position);
Int32 position = 1;
foreach (Sessions.SessionInfo.StandingsItem si in query)
{
if (si.Driver.CarIdx == driver.CarIdx)
return position;
else
position++;
}
return 0;
}
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.tracktemp = (Single)parseDoubleValue(WeekendInfo, "TrackSurfaceTemp", "C");
SharedData.Track.airtemp = (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;
IniFile trackNames;
string filename = Directory.GetCurrentDirectory() + "\\themes\\" + SharedData.theme.name + "\\tracks.ini";
if (!File.Exists(filename))
filename = Directory.GetCurrentDirectory() + "\\tracks.ini";
if (File.Exists(filename))
{
trackNames = new IniFile(filename);
SharedData.Track.name = trackNames.IniReadValue("Tracks", SharedData.Track.id.ToString());
}
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)
{
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();
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");
driverItem.CarId = parseIntValue(driver, "CarID");
driverItem.CarClass = parseIntValue(driver, "CarClassID");
driverItem.UserId = parseIntValue(driver, "UserID");
driverItem.CarIdx = parseIntValue(driver, "CarIdx");
driverItem.CarClassName = SharedData.theme.getCarClass(driverItem.CarId);
driverItem.iRating = parseIntValue(driver, "IRating");
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 = "";
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
{
Sessions.SessionInfo sessionItem = new Sessions.SessionInfo();
sessionItem.Id = sessionNum;
sessionItem.LapsTotal = parseIntValue(session, "SessionLaps");
sessionItem.SessionLength = parseFloatValue(session, "SessionTime", "sec");
sessionItem.Type = sessionTypeMap[parseStringValue(session, "SessionType")];
if (sessionItem.Type == iRTVO.Sessions.SessionInfo.sessionType.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");
}
}
// 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 )
)
{
// TODO ADD Logging!!
// remoteServer.debugLog(String.Format("Triggering fastedlap Old={0} new={1}",SharedData.Sessions.SessionList[sessionIndex].PreviousFastestLap,SharedData.Sessions.SessionList[sessionIndex].FastestLap));
// Push Event to Overlay
SharedData.triggers.Push(TriggerTypes.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<iRTVO.DriverInfo> standingsDrivers = SharedData.Drivers.ToList();
foreach (string standing in standingList)
{
int carIdx = parseIntValue(standing, "CarIdx");
if (carIdx < Int32.MaxValue)
{
Sessions.SessionInfo.StandingsItem standingItem = new Sessions.SessionInfo.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)
{
Event ev = new Event(
Event.eventType.fastlap,
(Int32)(((Double)sdk.GetData("SessionTime") * 60) + timeoffset),
standingItem.Driver,
"New session fastest lap (" + iRTVO.Overlay.floatTime2String(parseFloatValue(standing, "LastTime"), 3, false) + ")",
SharedData.Sessions.SessionList[sessionIndex].Type,
parseIntValue(standing, "LapsComplete")
);
SharedData.Events.List.Add(ev);
}
}
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<LapInfo.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");
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 == iRTVO.Sessions.SessionInfo.sessionState.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++;
}
}
// update/add position for drivers not in results
foreach (DriverInfo driver in standingsDrivers)
{
Sessions.SessionInfo.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>();
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
iRTVO.Sessions.SessionInfo qualifySession = SharedData.Sessions.findSessionType(iRTVO.Sessions.SessionInfo.sessionType.qualify);
if (qualifySession.Type == iRTVO.Sessions.SessionInfo.sessionType.invalid)
{
qualifySession.Type = iRTVO.Sessions.SessionInfo.sessionType.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:")
{
Sessions.SessionInfo.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");
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 (Sessions.SessionInfo session in SharedData.Sessions.SessionList)
{
if (session.Type == iRTVO.Sessions.SessionInfo.sessionType.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:")
{
Sessions.SessionInfo.StandingsItem standingItem = new Sessions.SessionInfo.StandingsItem();
standingItem.setDriver(parseIntValue(result, "CarIdx"));
standingItem.Position = parseIntValue(result, "Position") + 1;
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);
foreach (string camera in cameraList)
{
int cameraNum = parseIntValue(camera, "GroupNum");
if (cameraNum < Int32.MaxValue)
{
CameraInfo.CameraGroup camgrp = SharedData.Camera.FindId(cameraNum);
if (camgrp.Id < 0)
{
CameraInfo.CameraGroup cameraGroupItem = new CameraInfo.CameraGroup();
cameraGroupItem.Id = cameraNum;
cameraGroupItem.Name = parseStringValue(camera, "GroupName");
SharedData.Camera.Groups.Add(cameraGroupItem);
}
}
}
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
IniFile sectorsIni = new IniFile(Directory.GetCurrentDirectory() + "\\sectors.ini");
string sectorValue = sectorsIni.IniReadValue("Sectors", SharedData.Track.id.ToString());
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;
}
}
}
}
}
}
