private List <List <Player> > SplitQueueSkillGroup(List <Player> players, TeamSize sizeHint)
{
PlayerMMRComparer mmrComparer = new PlayerMMRComparer();
players.Sort(mmrComparer);
return(SplitSortedGroup(players, sizeHint));
}
/// <summary>
/// Returns true if ClanWarLogEntry instances are equal
/// </summary>
/// <param name="input">Instance of ClanWarLogEntry to be compared</param>
/// <returns>Boolean</returns>
public bool Equals(ClanWarLogEntry?input)
{
if (input == null)
{
return(false);
}
return
((
Clan == input.Clan ||
(Clan != null &&
Clan.Equals(input.Clan))
) &&
(
TeamSize == input.TeamSize ||
TeamSize.Equals(input.TeamSize)
) &&
(
Opponent == input.Opponent ||
(Opponent != null &&
Opponent.Equals(input.Opponent))
) &&
(
EndTime == input.EndTime ||
(EndTime != null &&
EndTime.Equals(input.EndTime))
) &&
(
Result == input.Result ||
Result.Equals(input.Result)
));
}
public async Task TeamsCommand(string queueName, string teamSizeStr, string splitModeStr)
{
try
{
TeamSize size = ParseTeamSize(teamSizeStr);
SplitMode splitMode = ParseSplitMode(splitModeStr);
var queue = await GetQueue(queueName);
if (queue == null)
{
throw new ArgumentException("Did not find any current inhouse queue for this channel.");
}
List <List <Player> > playerGroups = SplitQueue(size, queue, splitMode);
int groupNumber = 1;
foreach (List <Player> players in playerGroups)
{
var matches = DivideTeams(players);
if (matches != null)
{
await Output.OutputUniqueMatches(matches, groupNumber, Context.Channel);
}
++groupNumber;
}
}
catch (Exception e)
{
await Context.Channel.SendMessageAsync($"Error: {e.Message}");
}
}
private List <List <Player> > SplitSortedGroup(List <Player> players, TeamSize sizeHint)
{
int matchSize = (int)sizeHint * 2;
List <List <Player> > playerGroups = new List <List <Player> >();
while (players.Count > PlayerMatchSplits.Count)
{
playerGroups.Add(players.Take(matchSize).ToList());
players.RemoveRange(0, matchSize);
}
if (players.Count > 0)
{
foreach (int playerCount in PlayerMatchSplits[players.Count])
{
playerGroups.Add(players.Take(playerCount).ToList());
players.RemoveRange(0, playerCount);
}
}
if (players.Count > 0)
{
throw new ArgumentException($"We didn't handle the last {players.Count} players when splitting!");
}
return(playerGroups);
}
private static int calc_idx(MatchMode mode, Arena arena, TeamSize size)
{
var mode_int = (int)mode;
var arena_int = (int)arena - 1;
var team_size_int = (int)size;
var idx = mode_int * MaxMatchModeValue * MaxTeamSizeValue + arena_int * MaxTeamSizeValue + team_size_int;
return(idx);
}
public void Queue(Arena arena, MatchMode mode, TeamSize team_size)
{
SendRequestAsync(client.QueueAsync(new QueueAttempt
{
Arena = arena,
MatchMode = mode,
TeamSize = team_size
}, metadata), handle_result);
}
private MatchMaker(int dummy)
{
mutex = new object();
state = State.NotQueued;
match_player_decl = new MatchDecl();
match_mode = MatchMode.Skirmish; //Garbage
aren_type = Arena.None; //Atleast an invalid value
team_size = TeamSize.One; //Garbage
arena = null;
}
internal IArenaFactory GetArenaFactory(MatchMode mode, Arena arena, TeamSize size)
{
if (arena == Arena.None) //The zero case
{
throw new ArgumentException("The parameter 'arena' can not be Arena.None");
}
var idx = calc_idx(mode, arena, size);
return(arena_factories[idx]);
}
internal IMatchFinder GetMatchFinder(MatchMode mode, Arena arena, TeamSize size)
{
if (arena == Arena.None) //The zero case
{
throw new ArgumentException("The parameter 'arena' can not be Arena.None");
}
int idx = calc_idx(mode, arena, size);
return(match_finders[idx]);
}
private Measurement GetMeasurement(App app, MeasurementType measurementType)
{
Measurement measurement = null;
switch (measurementType)
{
case MeasurementType.RegisteredUsers:
measurement = new RegisteredUsers(app, measurementType);
break;
case MeasurementType.TeamSize:
measurement = new TeamSize(app, measurementType);
break;
case MeasurementType.DbSize:
measurement = new DbSize(app, measurementType);
break;
case MeasurementType.XmlSize:
measurement = new XmlSize(app, measurementType);
break;
case MeasurementType.Factor:
measurement = new Factor(app, measurementType);
break;
case MeasurementType.TotalRows:
measurement = new TotalRows(app, measurementType);
break;
case MeasurementType.MaxTableTotalRows:
measurement = new MaxTableTotalRows(app, measurementType);
break;
case MeasurementType.S3FilesSize:
measurement = new FilesS3Measurement(app, measurementType);
break;
case MeasurementType.S3HostingSize:
measurement = new HostingS3Measurement(app, measurementType);
break;
case MeasurementType.S3NodeJsSize:
measurement = new NodeJsS3Measurement(app, measurementType);
break;
default:
break;
}
return(measurement);
}
public static string ToUserFriendlyString(this TeamSize teamSize)
{
return(teamSize switch
{
TeamSize.Pairs => "Pairs",
TeamSize.Triples => "Triples",
TeamSize.PairsOrTriples => "Pairs or Triples",
TeamSize.Fours => "Fours",
TeamSize.TriplesOrFours => "Not Pairs",
TeamSize.Any => "Any",
_ => teamSize.ToString(),
});
/// <summary>
/// If return state == <see cref="State.Queued"/> then the player is safe to add to the match finder.
/// </summary>
/// <param name="matchFinder"></param>
/// <returns></returns>
public State Queue(MatchMode match_mode, Arena arena, TeamSize team_size)
{
lock (mutex)
{
var old = state;
if (state != State.NotQueued)
{
return(state);
}
state = State.Queued;
this.match_mode = match_mode;
this.aren_type = arena;
this.team_size = team_size;
return(State.Queued);
}
}
/// <summary>
/// Returns true if ClanWar instances are equal
/// </summary>
/// <param name="input">Instance of ClanWar to be compared</param>
/// <returns>Boolean</returns>
public bool Equals(ClanWar?input)
{
if (input == null)
{
return(false);
}
return
((
Clan == input.Clan ||
(Clan != null &&
Clan.Equals(input.Clan))
) &&
(
TeamSize == input.TeamSize ||
TeamSize.Equals(input.TeamSize)
) &&
(
Opponent == input.Opponent ||
(Opponent != null &&
Opponent.Equals(input.Opponent))
) &&
(
StartTime == input.StartTime ||
(StartTime != null &&
StartTime.Equals(input.StartTime))
) &&
(
State == input.State ||
State.Equals(input.State)
) &&
(
EndTime == input.EndTime ||
(EndTime != null &&
EndTime.Equals(input.EndTime))
) &&
(
PreparationStartTime == input.PreparationStartTime ||
(PreparationStartTime != null &&
PreparationStartTime.Equals(input.PreparationStartTime))
));
}
private List <List <Player> > SplitQueue(TeamSize sizeHint, InhouseQueue queue, SplitMode splitMode)
{
if (queue == null)
{
return(null);
}
List <Player> players = queue.Players.Values.ToList <Player>();
if (splitMode == SplitMode.Random)
{
return(SplitQueueRandom(players, sizeHint));
}
else if (splitMode == SplitMode.SkillGroup)
{
return(SplitQueueSkillGroup(players, sizeHint));
}
else
{
return(null);
}
}
public static bool IsMatchSizeSupported(Arena arena, TeamSize team_size)
{
switch (arena)
{
case Arena.None:
return(false);
case Arena.Agar:
switch (team_size)
{
case TeamSize.One:
case TeamSize.Two:
case TeamSize.Three:
return(true);
default:
throw new Exception("Unhandled enum value " + team_size);
}
default:
throw new Exception("Unhandled enum value " + arena);
}
}
public bool IsPenalty(Player player, TeamSize size, out WrongTeamSize penalty)
{
if (player == null || (player.PreferredTeamSizes & size) != 0)
{
penalty = null;
return(false);
}
if (!wrongTeamSizes.TryGetValue(player, out HistoryOfPenalty historical))
{
historical = new HistoryOfPenalty();
}
penalty = new WrongTeamSize
{
player = player,
givenSize = size,
historical = historical,
score = weights.IncorrectTeamSize.Score,
wantedSize = player.PreferredTeamSizes,
};
return(true);
}
private List <List <Player> > SplitQueueRandom(List <Player> players, TeamSize sizeHint)
{
Random rnd = new Random();
return(SplitSortedGroup(players.OrderBy(x => rnd.Next()).ToList(), sizeHint));
}
private void on_team_size_selected(TeamSize size)
{
selected_team_size = size;
}
