public static void AddFinalsRaces(this Tournament tournament)
{
if (!tournament.Races.All(r => r.IsFinished()) || tournament.Groups.Any(g => g.Name == "Finals"))
{
return;
}
var finalsCars = new List<Car>();
var scoutGroup = tournament.Groups.First(g => g.Name == "Scouts");
var resultsByClass = ResultsByClass(tournament, scoutGroup);
foreach (var classGroup in resultsByClass)
{
var firstCar = GetFirstCar(tournament, classGroup);
if (firstCar == null)
{
return;
}
finalsCars.Add(firstCar.Copy());
}
for (int i = 0; i < finalsCars.Count; i++)
{
finalsCars[i].Number = i + 1;
}
var tournamentBuilder = new TournamentBuilder("finals", "");
var laneStats = tournament.LaneStats;
var finalsGroup = new Group {Name = "Finals", Round = "Finals", Cars = finalsCars.ToArray()};
var raceDef = RaceDefinitionSource.RaceDefinitions(finalsCars.Count, 1, laneStats);
tournamentBuilder.AddGroup(finalsGroup, raceDef);
var finalsTournament = tournamentBuilder.Build("Finals");
tournament.AddGroupsAndRaces(finalsTournament.Groups, finalsTournament.Races);
}
private void _AddGroup(string folder, string groupName, int rounds, bool showClassStandings = false, string round = "prelim")
{
groupName = groupName ?? folder;
var cars = CsvParser.ParseArray<Car>(Path.Combine(_baseGroupDirectory, folder, "cars.csv"));
var races = RaceDefinitionSource.RaceDefinitions(cars.Count, rounds, null);
var group = new Group {Cars = cars.ToArray(), Name = groupName, ShowClassStandings = showClassStandings, Round = round};
_groups.Add(new Tuple<Group, GroupRacesDefinition[]>(group, races.ToArray()));
}
private static IEnumerable<IGrouping<string, CarResult>> ResultsByClass(Tournament tournament, Group g)
{
var racesInGroup = tournament.Races.Where(r => r.Group == g.Name).ToArray();
var carResults = racesInGroup.SelectMany(r => new[] {r.Car1, r.Car2, r.Car3, r.Car4});
var carResultsByCar = from r in carResults
group r by r.Car.ID
into _g
select
new CarResult(_g.First().Car, _g.Count(r => r.Place == 1), _g.Count(r => r.Place == 2),
_g.Count(r => r.Place == 3), _g.Count(r => r.Place == 4), _g.Count());
var resultsByClass = from result in carResultsByCar
group result by g.ShowClassStandings ? result.Car.Class : ""
into _g
select _g;
return resultsByClass;
}
private static int BuildTiebreakerRacesForPointLevel(Tournament tournament, string classKey, IEnumerable<CarResult> classGroup, int maxPoints, Group g,
LaneStat[] laneStats, int byeCounter, string roundName, TournamentBuilder tiebreakerTournamentBuilder, int tiebreakerPlace)
{
var carsWithMaxPoints = classGroup.Where(r => r.Points == maxPoints).ToArray();
var baseGroup = g.ShowClassStandings ? classKey : g.Name;
if (carsWithMaxPoints.Count() > 1 && !tournament.Groups.Any(_g => _g.TiebreakGroup == baseGroup))
{
int i = 1;
var tiedCars =
carsWithMaxPoints.Select(
c =>
new Car
{
Builder = c.Car.Builder,
Class = c.Car.Class,
ID = c.Car.ID,
Name = c.Car.Name,
Number = i++
}).ToList();
var raceDef = RaceDefinitionSource.RaceDefinitions(tiedCars.Count(), 1, laneStats);
while (tiedCars.Count() < 4)
{
byeCounter++;
var carId = "BYE" + byeCounter;
tiedCars.Add(new Car {Builder = carId, Name = carId, ID = carId, Number = i});
i++;
}
var name = tiebreakerPlace == 1
? string.Join("-", baseGroup.Split('-').First(), roundName)
: string.Join("-", baseGroup.Split('-').First()+":"+tiebreakerPlace, roundName);
var tiedGroup = new Group {Name = name, Cars = tiedCars.ToArray(), Round = roundName, TiebreakGroup = baseGroup};
tiebreakerTournamentBuilder.AddGroup(tiedGroup, raceDef);
}
return byeCounter;
}
private static void AddGroupsAndRaces(this Tournament tournament, Group[] groupsToAdd, Race[] racesToAdd)
{
var groups = tournament.Groups.ToList();
groups.AddRange(groupsToAdd);
var races = tournament.Races.ToList();
races.AddRange(racesToAdd);
for (int i = 0; i < races.Count; i++)
{
races[i].RaceNumber = i + 1;
}
tournament.Groups = groups.ToArray();
tournament.Races = races.ToArray();
}
public void AddGroup(Group group, GroupRacesDefinition[] races)
{
_groups.Add(new Tuple<Group, GroupRacesDefinition[]>(group, races));
}
