public async virtual Task <NascarEvent> SimulatePracticeAsync(NascarEvent raceEvent)
{
_lapTimeService = new LapTimeService(raceEvent.Track);
NascarPracticeRun p1 = raceEvent.Runs.OfType <NascarPracticeRun>().FirstOrDefault(r => r.RunType == NascarRunType.Practice1);
if (p1 != null)
{
p1.Vehicles = raceEvent.Vehicles;
SimulatePracticeRun(p1);
PopulateResults(p1);
}
NascarPracticeRun p2 = raceEvent.Runs.OfType <NascarPracticeRun>().FirstOrDefault(r => r.RunType == NascarRunType.Practice2);
if (p2 != null)
{
p2.Vehicles.Clear();
p2.Vehicles = raceEvent.Vehicles;
SimulatePracticeRun(p2);
PopulateResults(p2);
}
NascarPracticeRun p3 = raceEvent.Runs.OfType <NascarPracticeRun>().FirstOrDefault(r => r.RunType == NascarRunType.FinalPractice);
if (p3 != null)
{
p3.Vehicles.Clear();;
p3.Vehicles = raceEvent.Vehicles;
SimulatePracticeRun(p3);
PopulateResults(p3);
}
return(await Task.FromResult(raceEvent));
}
public List <NascarRaceLap> GetStartingLineup(NascarEvent raceEvent)
{
NascarRaceRun stage1 = raceEvent
.Runs
.OfType <NascarRaceRun>()
.FirstOrDefault(r => r.RunType == NascarRunType.RaceStage1);
return(StartingLineup(raceEvent, stage1));
}
protected virtual List <int> GetStageEndLaps(NascarEvent raceEvent)
{
var stageRuns = raceEvent.Runs.OfType <NascarRaceRun>().Where(r => r.RunType != NascarRunType.FinalRaceStage);
List <int> stageEndLaps = new List <int>();
stageEndLaps.AddRange(stageRuns.Select(s => s.EndLap).ToList());
return(stageEndLaps);
}
public async virtual Task <NascarEvent> SimulateQualifyingAsync(NascarEvent raceEvent)
{
_lapTimeService = new LapTimeService(raceEvent.Track);
NascarQualifyingRun q1 = raceEvent.Runs.OfType <NascarQualifyingRun>().FirstOrDefault(r => r.RunType == NascarRunType.QualifyingStage1);
if (q1 != null)
{
q1.Vehicles = raceEvent.Vehicles;
SimulateQualifyingRun(q1);
PopulateResults(q1, raceEvent.Series.QualifyingRound1Count.Value);
}
NascarQualifyingRun q2 = raceEvent.Runs.OfType <NascarQualifyingRun>().FirstOrDefault(r => r.RunType == NascarRunType.QualifyingStage2);
if (q2 != null)
{
q2.Vehicles.Clear();
foreach (QualifyingResult result in q1.Results.OrderBy(r => r.Position).Take(raceEvent.Series.QualifyingRound2Count.Value))
{
q2.Vehicles.Add(new NascarVehicle()
{
DriverId = result.DriverId,
VehicleId = result.VehicleId
});
}
SimulateQualifyingRun(q2);
PopulateResults(q2, raceEvent.Series.QualifyingRound2Count.Value);
}
NascarQualifyingRun q3 = raceEvent.Runs.OfType <NascarQualifyingRun>().FirstOrDefault(r => r.RunType == NascarRunType.FinalQualifyingStage);
if (q3 != null)
{
q3.Vehicles.Clear();
foreach (QualifyingResult result in q2.Results.OrderBy(r => r.Position).Take(raceEvent.Series.QualifyingFinalRoundCount))
{
q3.Vehicles.Add(new NascarVehicle()
{
DriverId = result.DriverId,
VehicleId = result.VehicleId
});
}
SimulateQualifyingRun(q3);
PopulateResults(q3, raceEvent.Series.QualifyingFinalRoundCount);
}
((List <QualifyingResult>)raceEvent.QualifyingResults).AddRange(q1.Results.OrderBy(r => r.Position).Skip(raceEvent.Series.QualifyingRound2Count.Value));
((List <QualifyingResult>)raceEvent.QualifyingResults).AddRange(q2.Results.OrderBy(r => r.Position).Skip(raceEvent.Series.QualifyingFinalRoundCount));
((List <QualifyingResult>)raceEvent.QualifyingResults).AddRange(q3.Results.OrderBy(r => r.Position).Take(raceEvent.Series.QualifyingRound1Count.Value));
PrintQualifyingResults(raceEvent);
return(await Task.FromResult(raceEvent));
}
private async void button4_Click(object sender, EventArgs e)
{
try
{
double trackLength = 2.66;
double cautionLapTime = 136.8;
double raceLapTime = 46.00;
double pitInTime = 12.5;
double pitOutTime = 12.5;
double pitStopTime = 15.0;
int talladegaTrackId = 5;
int testSeriesId = 0;
_nascarEvent = await GenerateNewEvent(talladegaTrackId, testSeriesId);
_lapService = new VehicleLapService(_nascarEvent.Track);
_lapService.LapTimeService = new TestLapTimeService(
trackLength,
cautionLapTime,
raceLapTime,
pitInTime,
pitOutTime,
pitStopTime);
var run = _nascarEvent.Runs.OfType <NascarRaceRun>().FirstOrDefault(r => r.RunType == NascarRunType.RaceStage1);
laps = GenerateRaceLaps(raceLapTime);
((List <NascarRaceLap>)run.Laps).AddRange(laps);
laps = _lapService.UpdateRaceLaps(laps, LapState.OneToGreenFlag);
laps = _lapService.UpdateRaceLaps(laps, LapState.GreenFlag);
laps.Where(l => l.VehicleId == 2).FirstOrDefault().PitInLap = true;
laps = _lapService.UpdateRaceLaps(laps, LapState.GreenFlag);
laps = _lapService.UpdateRaceLaps(laps, LapState.GreenFlag);
laps.Where(l => l.VehicleId == 1).FirstOrDefault().PitInLap = true;
laps.Where(l => l.VehicleId == 3).FirstOrDefault().PitInLap = true;
laps = _lapService.UpdateRaceLaps(laps, LapState.GreenFlag);
laps = _lapService.UpdateRaceLaps(laps, LapState.GreenFlag);
laps = _lapService.UpdateRaceLaps(laps, LapState.GreenFlag);
//laps = _lapService.UpdateRaceLaps(laps, LapState.CautionFlag);
//laps = _lapService.UpdateRaceLaps(laps, LapState.CautionFlag);
//laps = _lapService.UpdateRaceLaps(laps, LapState.CautionFlag);
//laps = _lapService.UpdateRaceLaps(laps, LapState.CautionFlag);
//laps = _lapService.UpdateRaceLaps(laps, LapState.OneToGreenFlag);
//laps = _lapService.UpdateRaceLaps(laps, LapState.GreenFlag);
//laps = _lapService.UpdateRaceLaps(laps, LapState.GreenFlag);
}
catch (Exception ex)
{
ExceptionHandler(ex);
}
}
private async void button1_Click(object sender, EventArgs e)
{
try
{
_nascarEvent = await GenerateNewEvent(4, (int)SeriesType.MonsterEnergyCup);
}
catch (Exception ex)
{
ExceptionHandler(ex);
}
}
private void PrintQualifyingResults(NascarEvent qEvent)
{
Console.WriteLine($"*** Event Qualifying Results ***");
foreach (QualifyingResult q in qEvent.QualifyingResults.OrderBy(r => r.Position))
{
Console.WriteLine($"{q.Position} Car# {q.VehicleId} {q.LapTime} {q.LapSpeed} {q.Round}");
}
Console.WriteLine();
}
protected virtual List <NascarRaceLap> StartingLineup(NascarEvent raceEvent, NascarRaceRun stage1)
{
List <NascarRaceLap> raceLaps = new List <NascarRaceLap>();
int position = 1;
double leaderTotalTime = 0;
foreach (QualifyingResult vehicle in raceEvent.QualifyingResults.OrderBy(q => q.Position))
{
vehicle.Position = position;
double deltaRow = 0.5;
double deltaNext = vehicle.Position == 1 ? 0 : (vehicle.Position % 2) == 0 ? 0.0 : 0.5;
double deltaLeader = vehicle.Position <= 2 ? 0 : Math.Round((double)((vehicle.Position - 1) / 2), 0) * deltaRow;
var newLap = new NascarRaceLap()
{
Position = vehicle.Position,
VehicleId = vehicle.VehicleId,
DriverId = vehicle.DriverId,
LapNumber = 0,
LeaderLap = 0,
Delta = Math.Round(deltaNext, 3),
DeltaLeader = Math.Round(deltaLeader, 3),
DeltaTravelledLeader = Math.Round(deltaLeader, 3),
LapSpeed = 0,
LapTime = 0,
TotalTime = 0
};
raceLaps.Add(newLap);
if (leaderTotalTime == 0)
{
leaderTotalTime = newLap.TotalTime;
}
position++;
}
Console.WriteLine("Starting Lineup");
PrintStandings(raceLaps, LapState.OneToGreenFlag);
return(raceLaps);
}
public async Task <NascarEvent> GenerateEventAsync(NascarTrack track, NascarSeries series)
{
try
{
var vehicles = await _vehicleRepository.GetListAsync();
var newEvent = new NascarEvent(track, series, vehicles.Take(50).ToList());
newEvent = await _eventRepository.Save(newEvent);
return(newEvent);
}
catch (Exception ex)
{
return(await Task.FromException <NascarEvent>(ex));
}
}
private async void button3_Click(object sender, EventArgs e)
{
try
{
if (_lapService == null)
{
_nascarEvent = await GenerateNewEvent(0, 0);
_nascarEvent = await _pSimulator.SimulatePracticeAsync(_nascarEvent);
_nascarEvent = await _qSimulator.SimulateQualifyingAsync(_nascarEvent);
_lapService = new VehicleLapService(_nascarEvent.Track);
}
laps = _lapService.GetStartingLineup(_nascarEvent);
laps = _lapService.UpdateRaceLaps(laps, LapState.OneToGreenFlag);
laps = _lapService.UpdateRaceLaps(laps, LapState.GreenFlag);
laps = _lapService.UpdateRaceLaps(laps, LapState.GreenFlag);
laps = _lapService.UpdateRaceLaps(laps, LapState.GreenFlag);
laps = _lapService.UpdateRaceLaps(laps, LapState.GreenFlag);
laps = _lapService.UpdateRaceLaps(laps, LapState.CautionFlag);
laps = _lapService.UpdateRaceLaps(laps, LapState.CautionFlag);
laps = _lapService.UpdateRaceLaps(laps, LapState.CautionFlag);
laps = _lapService.UpdateRaceLaps(laps, LapState.OneToGreenFlag);
laps = _lapService.UpdateRaceLaps(laps, LapState.GreenFlag);
laps = _lapService.UpdateRaceLaps(laps, LapState.GreenFlag);
laps = _lapService.UpdateRaceLaps(laps, LapState.GreenFlag);
laps = _lapService.UpdateRaceLaps(laps, LapState.GreenFlag);
laps = _lapService.UpdateRaceLaps(laps, LapState.GreenFlag);
laps = _lapService.UpdateRaceLaps(laps, LapState.GreenFlag);
laps = _lapService.UpdateRaceLaps(laps, LapState.CautionFlag);
laps = _lapService.UpdateRaceLaps(laps, LapState.CautionFlag);
laps = _lapService.UpdateRaceLaps(laps, LapState.OneToGreenFlag);
laps = _lapService.UpdateRaceLaps(laps, LapState.GreenFlag);
laps = _lapService.UpdateRaceLaps(laps, LapState.GreenFlag);
}
catch (Exception ex)
{
ExceptionHandler(ex);
}
}
private async void button2_Click(object sender, EventArgs e)
{
try
{
if (_nascarEvent == null)
{
_nascarEvent = await GenerateNewEvent(4, (int)SeriesType.MonsterEnergyCup);
}
_nascarEvent = await _pSimulator.SimulatePracticeAsync(_nascarEvent);
_nascarEvent = await _qSimulator.SimulateQualifyingAsync(_nascarEvent);
_nascarEvent = await _rSimulator.SimulateRaceAsync(_nascarEvent);
}
catch (Exception ex)
{
ExceptionHandler(ex);
}
}
public async Task <NascarEvent> Save(NascarEvent nascarEvent)
{
if (nascarEvent.EventId == 0)
{
nascarEvent.EventId = await GetNextEventId();
}
else
{
var existing = await Get(nascarEvent.EventId);
if (existing != null)
{
_events.Remove(existing);
}
}
_events.Add(nascarEvent);
return(await Task.FromResult(nascarEvent));
}
public async virtual Task <NascarEvent> SimulateRaceAsync(NascarEvent raceEvent)
{
_lapTimeService = new LapTimeService(raceEvent.Track);
_vehicleLapService = new VehicleLapService2(_lapTimeService);
StateService.Initialize();
int cautionLapsRemaining = 0;
int greenWhiteCheckeredLapCount = 2;
int endOfStageCautionLapCount = 5;
int pitsClosedBeforeStageEndLaps = 2;
int nextStageEndLap = 0;
int currentStageIndex = 0;
int lapsRunUnderThisCaution = 0;
bool pitsAreOpen = true;
bool leadLapPitOnly = false;
bool isFirstCautionLap = true;
List <int> stageEndLaps = GetStageEndLaps(raceEvent);
nextStageEndLap = stageEndLaps[currentStageIndex];
var firstStage = raceEvent.Runs.OfType <NascarRaceRun>().Where(r => r.RunType == NascarRunType.RaceStage1).SingleOrDefault();
var secondStage = raceEvent.Runs.OfType <NascarRaceRun>().Where(r => r.RunType == NascarRunType.RaceStage2).SingleOrDefault();
var finalStage = raceEvent.Runs.OfType <NascarRaceRun>().Where(r => r.RunType == NascarRunType.FinalRaceStage).SingleOrDefault();
NascarRaceRun run = firstStage;
int advertisedRaceEndLap = finalStage.EndLap;
int actualRaceEndLap = advertisedRaceEndLap;
List <NascarRaceLap> raceLaps = _vehicleLapService.GetStartingLineup(raceEvent);
List <NascarRaceLap> laps = new List <NascarRaceLap>();
StateService.GreenFlagOn();
for (int lapNumber = 1; lapNumber <= actualRaceEndLap; lapNumber++)
{
//***** random caution generator *****//
if (!StateService.IsCaution)
{
var randomCautionResult = _cautionService.GetRandomCautionResult();
var isCaution = randomCautionResult.IsCaution;
if (isCaution)
{
var caution = new NascarCautionSegment()
{
StartLap = lapNumber
};
raceEvent.Cautions.Add(caution);
isFirstCautionLap = true;
StateService.CautionOn();
if (StateService.IsWhiteFlag)
{
cautionLapsRemaining = 1;
}
else
{
cautionLapsRemaining = randomCautionResult.CautionLaps;
pitsAreOpen = false;
}
}
}
else
{
isFirstCautionLap = false;
if (!pitsAreOpen && lapsRunUnderThisCaution > 0 && (lapNumber + pitsClosedBeforeStageEndLaps <= nextStageEndLap))
{
pitsAreOpen = true;
leadLapPitOnly = true;
}
else if (pitsAreOpen)
{
leadLapPitOnly = false;
}
}
//***** end of race *****//
if (lapNumber == actualRaceEndLap - 1)
{
StateService.WhiteFlagOn();
}
else if (lapNumber == actualRaceEndLap)
{
StateService.CheckeredFlagOn();
}
//***** end of stage *****//
if (run.RunType != NascarRunType.FinalRaceStage)
{
if (lapNumber + pitsClosedBeforeStageEndLaps == nextStageEndLap)
{
// end of stage
pitsAreOpen = false;
}
else if (lapNumber == nextStageEndLap)
{
// end of stage
StateService.EndOfStageOn();
cautionLapsRemaining = endOfStageCautionLapCount;
var caution = new NascarCautionSegment()
{
StartLap = lapNumber
};
raceEvent.Cautions.Add(caution);
isFirstCautionLap = true;
currentStageIndex++;
if (currentStageIndex == 1)
{
if (currentStageIndex < stageEndLaps.Count)
{
nextStageEndLap = stageEndLaps[currentStageIndex];
run = secondStage;
}
else
{
currentStageIndex++;
}
}
leadLapPitOnly = (pitsAreOpen && lapsRunUnderThisCaution <= 2);
pitsAreOpen = (lapsRunUnderThisCaution > 0);
if (currentStageIndex == 2)
{
run = finalStage;
nextStageEndLap = finalStage.EndLap;
}
}
}
//***** overdrive *****//
if (StateService.IsCaution && !StateService.IsWhiteFlag && lapNumber + cautionLapsRemaining >= actualRaceEndLap)
{
// end of race extended by caution
StateService.OverdriveOn();
actualRaceEndLap = (lapNumber + cautionLapsRemaining + greenWhiteCheckeredLapCount);
}
//***** end of caution *****//
if (StateService.IsCaution && cautionLapsRemaining == 0)
{
// end of caution, back to green
StateService.GreenFlagOn();
lapsRunUnderThisCaution = 0;
raceEvent.Cautions.LastOrDefault().EndLap = lapNumber;
var luckyDog = raceLaps.FirstOrDefault(l => l.IsLuckyDog);
if (luckyDog != null)
{
luckyDog.IsLuckyDog = false;
}
}
// vehicle pit stops
if (pitsAreOpen)
{
raceLaps = SetPitStops(raceLaps, raceEvent.Track.PitWindow, StateService.IsCaution, leadLapPitOnly);
}
// vehicle lap times
if (StateService.IsGreenFlag)
{
laps = _vehicleLapService.UpdateRaceLaps(raceLaps, LapState.GreenFlag);
}
else if (StateService.IsCaution)
{
if (isFirstCautionLap)
{
laps = _vehicleLapService.UpdateRaceLaps(raceLaps, LapState.CautionFlag);
}
else if (cautionLapsRemaining == 1)
{
laps = _vehicleLapService.UpdateRaceLaps(raceLaps, LapState.OneToGreenFlag);
}
else
{
laps = _vehicleLapService.UpdateRaceLaps(raceLaps, LapState.CautionFlag);
}
}
((List <NascarRaceLap>)run.Laps).AddRange(laps.ToList());
raceLaps.Clear();
raceLaps.AddRange(laps);
laps.Clear();
if (StateService.IsCaution)
{
cautionLapsRemaining--;
lapsRunUnderThisCaution++;
}
Console.WriteLine($"Lap {lapNumber} [{StateService.State.ToString()}] ");
}
return(await Task.FromResult(raceEvent));
}
