internal static string GetNextMatchString(Team team)
{
League league = LeagueManager.League;
if (!league.NextMatchLookup.ContainsKey(team))
{
return("No match found.");
}
MatchResult match = league.NextMatchLookup[team];
List <BracketRound> rounds = league.Bracket.Rounds.Last();
BracketRound round = rounds.Where(r => r.Matches.SelectMany(m => new List <Team>()
{
m.HomeTeam, m.AwayTeam
}).Contains(team)).First();
if (match.Bye)
{
return(string.Format("{0}'s next match is a *BYE*",
team));
}
else
{
return(string.Format("{0} ({3}) vs {1} ({4}) {2}",
match.HomeTeam, match.AwayTeam, match.Completed ? $" (Completed) [{match.HomeGamesWon}-{match.AwayGamesWon}]" : "", match.HomeTeam.RoundRanking[round], match.AwayTeam.RoundRanking[round]));
}
}
public void IssueIsReportedWhenStartDateTimeForMatchIsSetEarlierThanAnyMatchInPreviousRound()
{
List <string> playerNames = new List <string>()
{
"Maru", "Stork", "Taeja", "Rain", "Bomber", "FanTaSy", "Stephano", "Thorzain"
};
bracketRound.SetPlayersPerGroupCount(4);
BracketRound secondBracketRound = tournament.AddBracketRound() as BracketRound;
foreach (string playerName in playerNames)
{
tournament.RegisterPlayerReference(playerName);
}
BracketGroup bracketGroup = bracketRound.Groups.First() as BracketGroup;
BracketNode finalNodeFromFirstRound = bracketGroup.BracketNodeSystem.FinalNode;
BracketGroup bracketGroupFromSecondRound = secondBracketRound.Groups.First() as BracketGroup;
BracketNode finalNodeFromSecondRound = bracketGroupFromSecondRound.BracketNodeSystem.FinalNode;
Match finalFromFirstRound = finalNodeFromFirstRound.Match;
Match finalFromSecondRound = finalNodeFromSecondRound.Match;
DateTime oneHourBeforeFinalFromFirstRound = finalFromFirstRound.StartDateTime.AddHours(-1);
bool validationResult = MatchStartDateTimeValidator.Validate(finalFromSecondRound, oneHourBeforeFinalFromFirstRound);
validationResult.Should().BeTrue();
tournamentIssueReporter.Issues.Should().HaveCount(1);
}
internal static bool AddNextMatchToEmbed(EmbedBuilder builder, Team team)
{
League league = LeagueManager.League;
if (!league.NextMatchLookup.ContainsKey(team))
{
return(false);
}
MatchResult match = league.NextMatchLookup[team];
List <BracketRound> rounds = league.Bracket.Rounds.Last();
BracketRound round = rounds.Where(r => r.Matches.SelectMany(m => new List <Team>()
{
m.HomeTeam, m.AwayTeam
}).Contains(team)).First();
string message;
if (match.Bye)
{
message = string.Format("{0}'s next match is a *BYE*.",
team);
}
else
{
message = string.Format("{0}'s next match is {1} ({4}) vs {2} ({5}).{3}",
team, match.HomeTeam, match.AwayTeam, match.Completed ? $" (Completed) [{match.HomeGamesWon}-{match.AwayGamesWon}]" : "", match.HomeTeam.RoundRanking[round], match.AwayTeam.RoundRanking[round]);
}
builder.AddField(team.Name, message);
return(true);
}
public void CanSolveTie()
{
PlayerReference maruPlayerReference = tournament.RegisterPlayerReference("Maru");
round.SetPlayersPerGroupCount(3);
PlayerReference storkPlayerReference = tournament.RegisterPlayerReference("Stork");
round.SetAdvancingPerGroupCount(2);
PlayerReference taejaPlayerReference = tournament.RegisterPlayerReference("Taeja");
BracketRound bracketRound = tournament.AddBracketRound();
GroupBase group = round.Groups.First();
foreach (Match match in round.Groups.First().Matches)
{
SystemTimeMocker.SetOneSecondAfter(match.StartDateTime);
match.Player1.IncreaseScore(2);
}
group.HasProblematicTie().Should().BeTrue();
group.HasSolvedTie().Should().BeFalse();
group.SolveTieByChoosing(taejaPlayerReference.Id).Should().BeFalse();
group.HasProblematicTie().Should().BeTrue();
group.HasSolvedTie().Should().BeFalse();
group.SolveTieByChoosing(storkPlayerReference.Id).Should().BeTrue();
group.HasProblematicTie().Should().BeTrue();
group.HasSolvedTie().Should().BeTrue();
bracketRound.Groups.First().Matches[0].Player1.GetName().Should().Be("Taeja");
bracketRound.Groups.First().Matches[0].Player2.GetName().Should().Be("Stork");
}
public TournamentTests()
{
tournament = Tournament.Create("GSL 2019");
bracketRound = tournament.AddBracketRound() as BracketRound;
user = User.Create("Stålberto");
better = tournament.AddBetter(user);
}
public MatchStartDateTimeValidatorTests()
{
tournament = Tournament.Create("GSL 2019");
tournamentIssueReporter = tournament.TournamentIssueReporter;
bracketRound = tournament.AddBracketRound() as BracketRound;
tournament.RegisterPlayerReference(firstPlayerName);
tournament.RegisterPlayerReference(secondPlayerName);
}
async Task ICeaSubCommand.Run(SocketSlashCommand command, DiscordSocketClient client, IReadOnlyDictionary <SlashCommandOptions, string> options, Lazy <List <Team> > lazyTeams)
{
bool ephemeral = !options.ContainsKey(SlashCommandOptions.post) || !options[SlashCommandOptions.post].Equals("True");
BracketSet currentBrackets = LeagueManager.League.Bracket;
if (currentBrackets == null)
{
await command.RespondAsync(text : "No Current Brackets.", ephemeral : ephemeral);
}
List <Tuple <string, string, string> > bracketResults = new();
foreach (Bracket bracket in currentBrackets.Brackets)
{
List <BracketRound> rounds = bracket.Rounds;
int roundIndex = !options.ContainsKey(SlashCommandOptions.week) ? rounds.Count - 1 : int.Parse(options[SlashCommandOptions.week]);
BracketRound round = rounds[roundIndex];
StringBuilder sb = new();
foreach (MatchResult match in round.NonByeMatches)
{
sb.AppendLine($"[{match.HomeGamesWon}-{match.AwayGamesWon}] (**{match.HomeTeam.RoundRanking[round]}**){match.HomeTeam} vs (**{match.AwayTeam.RoundRanking[round]}**){match.AwayTeam}");
}
foreach (MatchResult match in round.ByeMatches)
{
sb.AppendLine($"[BYE] (**{match.HomeTeam.RoundRanking[round]}**){match.HomeTeam} vs *BYE*");
}
bracketResults.Add(new Tuple <string, string, string>(bracket.Name, round.RoundName, sb.ToString()));
}
if (bracketResults.All(s => s.Item3.Length < 1024))
{
List <Embed> embeds = new();
foreach (Tuple <string, string, string> bracketResult in bracketResults)
{
EmbedBuilder builder = new();
builder.Title = bracketResult.Item1;
builder.AddField(bracketResult.Item2, bracketResult.Item3);
embeds.Add(builder.Build());
}
await command.RespondAsync(embeds : embeds.ToArray(), ephemeral : ephemeral);
}
else
{
StringBuilder result = new StringBuilder();
foreach (Tuple <string, string, string> bracketResult in bracketResults)
{
result.AppendLine(bracketResult.Item1);
result.AppendLine(bracketResult.Item2);
result.AppendLine(bracketResult.Item3);
}
await command.RespondAsync(text : result.ToString(), ephemeral : ephemeral);
}
}
public MatchTests()
{
tournament = Tournament.Create("GSL 2019");
bracketRound = tournament.AddBracketRound() as BracketRound;
tournament.RegisterPlayerReference(firstPlayerName);
tournament.RegisterPlayerReference(secondPlayerName);
bracketGroup = bracketRound.Groups.First() as BracketGroup;
match = bracketGroup.Matches.First();
}
public void AdvancingCountInBracketRoundsCannotBeAnythingOtherThanOne()
{
BracketRound round = tournament.AddBracketRound();
for (int advancingPerGroupCount = -5; advancingPerGroupCount < 16; ++advancingPerGroupCount)
{
round.SetAdvancingPerGroupCount(advancingPerGroupCount);
round.AdvancingPerGroupCount.Should().Be(1);
}
}
public MatchBetTests()
{
user = User.Create("Stålberto");
tournament = Tournament.Create("GSL 2019");
better = tournament.AddBetter(user);
round = tournament.AddBracketRound() as BracketRound;
tournament.RegisterPlayerReference("Maru");
tournament.RegisterPlayerReference("Stork");
group = round.Groups.First() as BracketGroup;
firstMatch = group.Matches.First();
}
public void CannotChangePlayersPerGroupSize()
{
BracketRound round = tournament.AddBracketRound();
round.Groups.First().Matches.Should().HaveCount(1);
round.PlayersPerGroupCount.Should().Be(2);
round.SetPlayersPerGroupCount(8);
round.Groups.First().Matches.Should().HaveCount(7);
round.PlayersPerGroupCount.Should().Be(8);
}
public void CanCreateBracketRound()
{
BracketRound round = tournament.AddBracketRound();
round.Should().NotBeNull();
round.Id.Should().NotBeEmpty();
round.Name.Should().Be("Round A");
round.PlayersPerGroupCount.Should().Be(2);
round.AdvancingPerGroupCount.Should().Be(1);
round.Groups.Should().HaveCount(1);
round.TournamentId.Should().Be(tournament.Id);
round.Tournament.Should().Be(tournament);
}
public void MatchMustContainDifferentPlayers()
{
Tournament tournament = Tournament.Create("GSL 2019");
BracketRound bracketRound = tournament.AddBracketRound() as BracketRound;
PlayerReference playerReference = tournament.RegisterPlayerReference(firstPlayerName);
Match match = bracketRound.Groups.First().Matches.First();
match.AssignPlayerReferencesToPlayers(playerReference.Id, playerReference.Id);
match.Player1.PlayerReferenceId.Should().Be(playerReference.Id);
match.Player2.PlayerReferenceId.Should().BeEmpty();
}
public void CannotSetPlayersPerGroupSizeToAnythingLessThanTwo()
{
BracketRound round = tournament.AddBracketRound();
round.Groups.First().Matches.Should().HaveCount(1);
round.PlayersPerGroupCount.Should().Be(2);
round.SetPlayersPerGroupCount(1);
round.SetPlayersPerGroupCount(0);
round.SetPlayersPerGroupCount(-1);
round.Groups.First().Matches.Should().HaveCount(1);
round.PlayersPerGroupCount.Should().Be(2);
}
public static BracketGroup Create(BracketRound round)
{
if (round == null)
{
return(null);
}
BracketGroup group = new BracketGroup
{
RoundId = round.Id,
Round = round
};
group.AssignDefaultName();
return(group);
}
public PlayerInBracketGroupTests()
{
tournament = Tournament.Create("GSL 2019");
round = tournament.AddBracketRound();
round.SetAdvancingPerGroupCount(1);
round.SetPlayersPerGroupCount(4);
foreach (string playerName in playerNames)
{
tournament.RegisterPlayerReference(playerName);
}
group = round.Groups.First() as BracketGroup;
match = group.Matches.First();
match.SetBestOf(5);
player = match.Player1;
}
public BracketRound AddBracketRound()
{
BracketRound round = BracketRound.Create(this);
if (round == null)
{
return(null);
}
bool roundWasIntegrated = IntegrateRoundToTournament(round);
if (roundWasIntegrated)
{
return(round);
}
return(null);
}
async Task ICeaSubCommand.Run(SocketSlashCommand command, DiscordSocketClient client, IReadOnlyDictionary <SlashCommandOptions, string> options, Lazy <List <Team> > lazyTeams)
{
List <BracketRound> rounds = LeagueManager.League.Bracket.Rounds;
int roundIndex = !options.ContainsKey(SlashCommandOptions.week) ? rounds.Count - 1 : int.Parse(options[SlashCommandOptions.week]);
BracketRound r = rounds[roundIndex];
StringBuilder sb = new();
foreach (MatchResult match in r.Matches)
{
sb.AppendLine($"[{match.HomeGamesWon}-{match.AwayGamesWon}] (**{match.HomeTeam.RoundRanking[r]}**){match.HomeTeam} vs (**{match.AwayTeam.RoundRanking[r]}**){match.AwayTeam}");
}
EmbedBuilder builder = new();
builder.AddField(r.RoundName, sb.ToString());
bool ephemeral = !options.ContainsKey(SlashCommandOptions.post) || !options[SlashCommandOptions.post].Equals("True");
await command.RespondAsync(embed : builder.Build(), ephemeral : ephemeral);
}
internal override Embed Run(SocketSlashCommand command, DiscordSocketClient client, IReadOnlyDictionary <SlashCommandOptions, string> options, Team team)
{
League league = LeagueManager.League;
if (!league.NextMatchLookup.ContainsKey(team))
{
return(null);
}
EmbedBuilder builder = new();
MatchResult match = league.NextMatchLookup[team];
BracketRound round = league.Bracket.Rounds.Last();
string message = string.Format("{0}'s next match is , {1} ({4}) vs {2} ({5}).{3}",
team, match.HomeTeam, match.AwayTeam, match.Completed ? $" (Completed) [{match.HomeGamesWon}-{match.AwayGamesWon}]" : "", match.HomeTeam.RoundRanking[round], match.AwayTeam.RoundRanking[round]);
builder.AddField(team.Name, message);
return(builder.Build());
}
async Task ICeaSubCommand.Run(SocketSlashCommand command, DiscordSocketClient client, IReadOnlyDictionary <SlashCommandOptions, string> options, Lazy <List <Team> > lazyTeams)
{
BracketSet currentBrackets = LeagueManager.League.Bracket;
BracketRound currentRound = currentBrackets.Rounds.Last().First();
string currentStage = StageMatcher.Lookup(currentRound.RoundName);
List <StageGroup> stageGroups = ConfigurationManager.Configuration.stageGroups.ToList();
List <StageGroup> currentStageGroups = stageGroups.Where(g => g.Stage.Equals(currentStage)).ToList();
List <Embed> embeds = new();
foreach (StageGroup group in currentStageGroups)
{
EmbedBuilder builder = new();
StringBuilder result = new StringBuilder();
int page = 0;
List <Team> teams = group.Teams.OrderBy(t => t.RoundRanking[currentRound]).ToList();
foreach (Team team in teams)
{
TeamStatistics stats = team.StageStats[currentStage];
result.AppendLine($"{team.RoundRanking[currentRound]} {team} [**{stats.MatchWins}**-{stats.MatchLosses}] GoalDiff: {stats.TotalGoalDifferential}");
if (result.Length > 800)
{
builder.AddField(page == 0 ? $"{group.Name} Standings" : $"{group.Name} Continued", result.ToString());
result = new StringBuilder();
page++;
}
}
if (result.Length > 0)
{
builder.AddField(page == 0 ? $"{group.Name} Standings" : $"{group.Name} Continued", result.ToString());
}
embeds.Add(builder.Build());
}
bool ephemeral = !options.ContainsKey(SlashCommandOptions.post) || !options[SlashCommandOptions.post].Equals("True");
await command.RespondAsync(embeds : embeds.ToArray(), ephemeral : ephemeral);
}
public BracketGroupTests()
{
tournament = Tournament.Create("GSL 2019");
bracketRound = tournament.AddBracketRound() as BracketRound;
}
public BracketStartDateTimeTests()
{
tournament = Tournament.Create("GSL 2019");
tournamentIssueReporter = tournament.TournamentIssueReporter;
bracketRound = tournament.AddBracketRound() as BracketRound;
}
public GroupBaseTests()
{
tournament = Tournament.Create("GSL 2019");
round = tournament.AddBracketRound();
round.SetPlayersPerGroupCount(2);
}
public PlayerSwitcherTests()
{
tournament = Tournament.Create("GSL 2019");
bracketRound = tournament.AddBracketRound() as BracketRound;
}
