/// <summary>
///
/// </summary>
/// <param name="players"></param>
/// <param name="seed"></param>
/// <param name="playersPerTeam"></param>
/// <param name="r"></param>
/// <returns></returns>
private Tuple<Team, Team> chooseTeams( List<Player> players, Player seed, int playersPerTeam, Random r )
{
if ( players.Count >= 2 * playersPerTeam )
{
List<Player> t = players.RandomOrdering( r, 2 * playersPerTeam ).ToList();
Team a = new Team();
Team b = new Team();
for ( int count = 0; count < 2 * playersPerTeam; count++ )
{
if ( count < playersPerTeam )
{
a.Players.Add( t[count] );
}
else
{
b.Players.Add( t[count] );
}
}
return new Tuple<Team, Team>( a, b );
}
//Return a tuple of EmptyTeams because we never got enough players together
return new Tuple<Team, Team>( new EmptyTeam(), new EmptyTeam() );
}
/// <summary>
/// Divide players into two teams with even players on one team and odd players on the other
/// </summary>
/// <param name="players"></param>
/// <param name="playersPerTeam"></param>
/// <param name="seed"></param>
/// <returns></returns>
private Tuple<Team, Team> bucketPlayers( List<Player> players, int playersPerTeam, Player seed )
{
//Create teams
Team a = new Team();
Team b = new Team();
//Add seed to first Team
a.Players.Add( seed );
//Divide players between Teams
for ( int count = 1; count < 2 * playersPerTeam; count++ )
{
if ( count % 2 == 0 )
a.Players.Add( players[count - 1] );
else
b.Players.Add( players[count - 1] );
}
//Return Teams
return new Tuple<Team, Team>( a, b );
}
/// <summary>
///
/// </summary>
/// <param name="players"></param>
/// <param name="playersPerTeam"></param>
/// <param name="seed"></param>
/// <returns></returns>
public Tuple<Team, Team> DividePlayers( List<Player> players, int playersPerTeam, Player seed )
{
//if ( players.Count > 2 * PLAYERS_PER_TEAM )
//players.Sort( ( p1, p2 ) => p2.GetElo().CompareTo( p1.GetElo() ) );
//players.Sort( ( p1, p2 ) => Math.Abs( seed.GetElo() - p2.GetElo() ) );
int seedElo = seed.GetElo();
players.Sort( ( p1, p2 ) => Math.Abs( seedElo - p1.GetElo() ).CompareTo( Math.Abs( seedElo - p2.GetElo() ) ) );
//players.OrderByDescending( p => Math.Abs( seedElo - p.GetElo() ) );
Team a = new Team();
Team b = new Team();
a.Players.Add( seed );
for ( int count = 1; count < 2 * playersPerTeam; count++ )
{
if ( count % 2 == 0 )
a.Players.Add( players[count - 1] );
else
b.Players.Add( players[count - 1] );
}
return new Tuple<Team, Team>( a, b );
}
/// <summary>
/// Divide players into two teams with some players on each team having guaranteed close Elo scores, the rest assigned based upon total team Elo
/// </summary>
/// <param name="players"></param>
/// <param name="playersPerTeam"></param>
/// <param name="seed"></param>
/// <param name="numClose"></param>
/// <param name="r"></param>
/// <returns></returns>
private Tuple<Team, Team> dividePlayers( List<Player> players, int playersPerTeam, Player seed, int numClose, Random r )
{
if ( numClose < 2 * playersPerTeam )
{
//Sort the players so that both teams get some of the top available players
players.Sort( ( p1, p2 ) => p2.GetElo().CompareTo( p1.GetElo() ) );
//Create two Teams
Team a = new Team();
Team b = new Team();
int startIndex = 0;
int totalPlayersAssigned = 0;
//Check if all of the players must be close in Elo
if ( numClose == 2 * playersPerTeam )
{
//Add the seed player to one team
a.Players.Add( seed );
startIndex = 1;
}
//Add the number of players that need to be close to teams
for ( int count = startIndex; count < numClose; count++ )
{
if ( count % 2 == 0 )
a.Players.Add( players[count - 1] );
else
b.Players.Add( players[count - 1] );
}
totalPlayersAssigned = numClose;
int numLeft = 2 * playersPerTeam - numClose;
if ( numLeft > 0 )
{
//Add the seed player to one team
a.Players.Add( seed );
numLeft--;
totalPlayersAssigned++;
}
//Get as many players as are needed and randomize them
players = players.GetRange( numClose, players.Count - totalPlayersAssigned ).RandomOrdering( r ).ToList();
//Assign rest of players as needed
for ( int count = 0; count < numLeft; count++ )
{
//Don't reassign the seed
if ( players[count] != seed )
{
//Check if both teams need a player
if ( a.Players.Count < playersPerTeam && b.Players.Count < playersPerTeam )
{
//Calculate Elo differences
double diffWithA = ((double)(a.GetTeamElo() + players[count].GetElo())) / (double)(a.Players.Count + 1) - b.GetAverageElo();
double diffWithB = ((double)(b.GetTeamElo() + players[count].GetElo())) / (double)(b.Players.Count + 1) - a.GetAverageElo();
//Decide which team gets the player
if ( Math.Abs( diffWithA ) < Math.Abs( diffWithB ) )
{
a.Players.Add( players[count] );
}
else
{
b.Players.Add( players[count] );
}
}
//Assign to Team A
else if ( a.Players.Count < playersPerTeam )
a.Players.Add( players[count] );
//Assign to Team B
else if ( b.Players.Count < playersPerTeam )
b.Players.Add( players[count] );
}
}
return new Tuple<Team, Team>( a, b );
}
//Return a game with EmptyTeams because there weren't enough players
return new Tuple<Team, Team>( new EmptyTeam(), new EmptyTeam() );
}