public static BracketNode BuildWhitespaceNode()
{
var space = BuildLiteralNode(TokenBuilder.BuildLiteralToken((char)32));
var t = BuildLiteralNode(TokenBuilder.BuildLiteralToken((char)9));
/*
* var cr = BuildLiteralNode(TokenBuilder.BuildLiteralToken((char)13));
* var nl = BuildLiteralNode(TokenBuilder.BuildLiteralToken((char)10));
* var vt = BuildLiteralNode(TokenBuilder.BuildLiteralToken((char)11));
* var ff = BuildLiteralNode(TokenBuilder.BuildLiteralToken((char)12));
*/
var set = new BracketNode(new BracketRightToken());
set.ChildNodes.Add(space);
set.ChildNodes.Add(t);
/*
* set.ChildNodes.Add(cr);
* set.ChildNodes.Add(nl);
* set.ChildNodes.Add(vt);
* set.ChildNodes.Add(ff);
*/
return(set);
}
private void SwapEntrants(BracketNode node1, BracketNode node2)
{
var temp = node1.Entrant;
node1.Entrant = node2.Entrant;
node2.Entrant = temp;
}
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);
}
public void IssueIsReportedWhenStartDateTimeForMatchIsEarlierThanAnyParentMatch()
{
List <string> playerNames = new List <string>()
{
"Maru", "Stork", "Taeja", "Rain", "Bomber", "FanTaSy", "Stephano", "Thorzain"
};
bracketRound.SetPlayersPerGroupCount(playerNames.Count);
foreach (string playerName in playerNames)
{
tournament.RegisterPlayerReference(playerName);
}
BracketGroup bracketGroup = bracketRound.Groups.First() as BracketGroup;
BracketNode finalNode = bracketGroup.BracketNodeSystem.FinalNode;
Match final = finalNode.Match;
Match firstSemifinal = finalNode.Children[0].Match;
Match secondSemifinal = finalNode.Children[1].Match;
DateTime oneHourBeforeFirstSemifinal = firstSemifinal.StartDateTime.AddHours(-1);
DateTime oneHourBeforeSecondSemifinal = secondSemifinal.StartDateTime.AddHours(-1);
final.SetStartDateTime(oneHourBeforeFirstSemifinal);
final.StartDateTime.Should().Be(oneHourBeforeFirstSemifinal);
final.SetStartDateTime(oneHourBeforeSecondSemifinal);
final.StartDateTime.Should().Be(oneHourBeforeSecondSemifinal);
tournamentIssueReporter.Issues.Should().HaveCount(2);
}
private void Explode(BracketNode bracketNode)
{
BaseNode tip = bracketNode;
while (tip.Parent is not null)
{
tip = tip.Parent;
}
var daList = Flatten(tip).ToList();
var index = daList.IndexOf(bracketNode);
if (index == 1)
{
// left goes away
(daList[index + 3] as ValueNode).Value += (daList[index + 1] as ValueNode).Value;
}
else if (index == daList.Count - 2)
{
// right goes away
(daList[index - 3] as ValueNode).Value += (daList[index - 1] as ValueNode).Value;
}
else
{
(daList[index + 3] as ValueNode).Value += (daList[index + 1] as ValueNode).Value;
(daList[index - 3] as ValueNode).Value += (daList[index - 1] as ValueNode).Value;
}
}
public override void OnMatchScoreIncreased(Match match)
{
bool matchExistInThisGroup = Matches.Where(currentMatch => currentMatch.Id == match.Id).Any();
if (!matchExistInThisGroup)
{
// LOG Error: Match does not exist in this group
return;
}
if (BracketNodeSystem == null)
{
BracketNodeSystem = new BracketNodeSystem();
BracketNodeSystem.Construct(Matches);
}
BracketNode finalNode = BracketNodeSystem.FinalNode;
bool matchIsFinished = match.GetPlayState() == PlayStateEnum.Finished;
bool matchIsNotFinal = match.Id != finalNode.Match.Id;
if (matchIsFinished && matchIsNotFinal)
{
BracketNode bracketNode = finalNode.GetBracketNodeByMatchId(match.Id);
BracketNode parentNode = bracketNode.Parent;
parentNode.Match.AssignPlayerReferenceToFirstAvailablePlayer(match.GetWinningPlayer().PlayerReferenceId);
}
}
/// <summary>
/// Return true, if bracket area is closed
/// </summary>
public bool Proceed(BracketNode node)
{
if (_borderCounters.Count is 0)
{
return(false);
}
var last = _borderCounters[^ 1];
private static BracketNode AddOpenBracket(List <BaseFormulaNode> nodes)
{
var bracket = new BracketNode(Bracket.Open);
nodes.Add(bracket);
return(bracket);
}
private static void AddAdditionalNodesForUnaryMinus(List <BaseFormulaNode> nodes)
{
var bracket = new BracketNode(Bracket.Open);
var value = new NumberNode(0);
var minus = new OperatorNode(Operator.Minus);
nodes.Add(bracket);
nodes.Add(value);
nodes.Add(minus);
}
private void ValidateBracketNodeMatch(BracketNode bracketNode, Match correctMatch)
{
if (correctMatch == null)
{
bracketNode.Should().BeNull();
}
else
{
bracketNode.Match.Should().Be(correctMatch);
}
}
private BaseNode Add(BaseNode left, BaseNode right)
{
var b = new BracketNode
{
Left = left,
Right = right
};
b.Left.Parent = b;
b.Right.Parent = b;
return(b);
}
public static BracketNode BuildWordNode()
{
var numeric = BuildNumericNode();
var uppercase = BuildRangeNode(TokenBuilder.BuildLiteralToken((char)65), TokenBuilder.BuildLiteralToken((char)90));
var lowercase = BuildRangeNode(TokenBuilder.BuildLiteralToken((char)97), TokenBuilder.BuildLiteralToken((char)122));
var underscore = BuildLiteralNode(TokenBuilder.BuildLiteralToken((char) 95));
var set = new BracketNode(new BracketRightToken());
set.ChildNodes.Add(numeric);
set.ChildNodes.Add(uppercase);
set.ChildNodes.Add(lowercase);
set.ChildNodes.Add(underscore);
return set;
}
public override Node DeepClone()
{
BracketNode clone = new BracketNode(CompetitorA.DeepClone(), CompetitorB.DeepClone());
if (BestCompetitor == CompetitorA)
{
clone.BestCompetitor = clone.CompetitorA;
}
else if (BestCompetitor == CompetitorB)
{
clone.BestCompetitor = clone.CompetitorB;
}
return(clone);
}
public static BracketNode BuildWordNode()
{
var numeric = BuildNumericNode();
var uppercase = BuildRangeNode(TokenBuilder.BuildLiteralToken((char)65), TokenBuilder.BuildLiteralToken((char)90));
var lowercase = BuildRangeNode(TokenBuilder.BuildLiteralToken((char)97), TokenBuilder.BuildLiteralToken((char)122));
var underscore = BuildLiteralNode(TokenBuilder.BuildLiteralToken((char)95));
var set = new BracketNode(new BracketRightToken());
set.ChildNodes.Add(numeric);
set.ChildNodes.Add(uppercase);
set.ChildNodes.Add(lowercase);
set.ChildNodes.Add(underscore);
return(set);
}
private BracketNode Split(ValueNode valueNode)
{
var div2 = valueNode.Value / 2;
var b = new BracketNode {
};
b.Left = new ValueNode(div2)
{
Parent = b
};
b.Right = new ValueNode(div2 + valueNode.Value % 2)
{
Parent = b
};
return(b);
}
private void FindRandomNode(out BracketNode node1, out BracketNode node2)
{
var rand = new Random();
node1 = _bracket.Root;
while (!node1.IsLeaf)
{
node1 = rand.Next() % 2 == 0 ? node1.Left : node1.Right;
}
node2 = _bracket.Root;
while (!node2.IsLeaf)
{
node2 = rand.Next() % 2 == 0 ? node2.Left : node2.Right;
}
}
public static BracketNode BuildWhitespaceNode()
{
var space = BuildLiteralNode(TokenBuilder.BuildLiteralToken((char)32));
var t = BuildLiteralNode(TokenBuilder.BuildLiteralToken((char)9));
/*
var cr = BuildLiteralNode(TokenBuilder.BuildLiteralToken((char)13));
var nl = BuildLiteralNode(TokenBuilder.BuildLiteralToken((char)10));
var vt = BuildLiteralNode(TokenBuilder.BuildLiteralToken((char)11));
var ff = BuildLiteralNode(TokenBuilder.BuildLiteralToken((char)12));
*/
var set = new BracketNode(new BracketRightToken());
set.ChildNodes.Add(space);
set.ChildNodes.Add(t);
/*
set.ChildNodes.Add(cr);
set.ChildNodes.Add(nl);
set.ChildNodes.Add(vt);
set.ChildNodes.Add(ff);
*/
return set;
}
public void CanConstructBracketNodeSystemWithUnevenPlayers()
{
List <string> playerNames = new List <string>()
{
"Maru", "Stork", "Taeja", "Rain", "Bomber", "FanTaSy", "Stephano"
};
bracketRound.SetPlayersPerGroupCount(playerNames.Count);
foreach (string playerName in playerNames)
{
tournament.RegisterPlayerReference(playerName);
}
bracketGroup = bracketRound.Groups.First() as BracketGroup;
BracketNode finalNode = bracketGroup.BracketNodeSystem.FinalNode;
ValidateBracketNodeConnections(finalNode, null, bracketGroup.Matches[4], bracketGroup.Matches[3]);
BracketNode semifinalNode1 = finalNode.Children[0];
BracketNode semifinalNode2 = finalNode.Children[1];
ValidateBracketNodeConnections(semifinalNode1, bracketGroup.Matches[5], bracketGroup.Matches[2], bracketGroup.Matches[1]);
ValidateBracketNodeConnections(semifinalNode2, bracketGroup.Matches[5], bracketGroup.Matches[0], null);
BracketNode quarterfinalNode1 = semifinalNode1.Children[0];
BracketNode quarterfinalNode2 = semifinalNode1.Children[1];
BracketNode quarterfinalNode3 = semifinalNode2.Children[0];
BracketNode quarterfinalNode4 = semifinalNode2.Children[1];
ValidateBracketNodeConnections(quarterfinalNode1, bracketGroup.Matches[4], null, null);
ValidateBracketNodeConnections(quarterfinalNode2, bracketGroup.Matches[4], null, null);
ValidateBracketNodeConnections(quarterfinalNode3, bracketGroup.Matches[3], null, null);
quarterfinalNode4.Should().BeNull();
}
public static List <TeamViewModel> createBracket(List <TeamViewModel> teams, int algorithm)
{
//0 - Random except for the top two seeds
if (algorithm == 0)
{
Random random = new Random();
var secondSeed = teams[1];
teams[1] = teams[teams.Count - 1];
teams[teams.Count - 1] = secondSeed;
for (int i = 0; i < 100; i++)
{
int swap1 = random.Next(1, teams.Count - 1);
int swap2 = random.Next(1, teams.Count - 1);
var temp = teams[swap1];
teams[swap1] = teams[swap2];
teams[swap2] = temp;
}
}
else if (algorithm == 1)
{
var root1 = teams.ElementAt(0);
var root2 = teams.ElementAt(1);
teams.Remove(root1);
teams.Remove(root2);
BracketNode rootNode = new BracketNode();
rootNode.Teams = new string[2] {
root1.TeamName, root2.TeamName
};
rootNode.leftValue = root1;
rootNode.rightValue = root2;
Queue <BracketNode> queue = new Queue <BracketNode>();
queue.Enqueue(rootNode);
while (queue.Count > 0)
{
var node = queue.Dequeue();
BracketNode rightChildNode = new BracketNode();
rightChildNode.leftValue = node.leftValue;
if (teams.Count > 0)
{
var rightValue = teams.ElementAt(0);
teams.Remove(rightValue);
rightChildNode.rightValue = rightValue;
}
}
}
//1 Standard Tournament generating algorithm
//2 Complete random
return(teams);
}
public static void Print(this BracketNode root, int topMargin = 2, int leftMargin = 2)
{
if (root == null)
{
return;
}
int rootTop = Console.CursorTop + topMargin;
var last = new List <NodeInfo>();
var next = root;
for (int level = 0; next != null; level++)
{
var item = new NodeInfo {
Node = next, Text = $" {next.Entrant.ToString()} "
};
if (level < last.Count)
{
item.StartPos = last[level].EndPos + 1;
last[level] = item;
}
else
{
item.StartPos = leftMargin;
last.Add(item);
}
if (level > 0)
{
item.Parent = last[level - 1];
if (next == item.Parent.Node.Left)
{
item.Parent.Left = item;
item.EndPos = Math.Max(item.EndPos, item.Parent.StartPos);
}
else
{
item.Parent.Right = item;
item.StartPos = Math.Max(item.StartPos, item.Parent.EndPos);
}
}
next = next.Left ?? next.Right;
for (; next == null; item = item.Parent)
{
Print(item, rootTop + 2 * level);
if (--level < 0)
{
break;
}
if (item == item.Parent.Left)
{
item.Parent.StartPos = item.EndPos;
next = item.Parent.Node.Right;
}
else
{
if (item.Parent.Left == null)
{
item.Parent.EndPos = item.StartPos;
}
else
{
item.Parent.StartPos += (item.StartPos - item.Parent.EndPos) / 2;
}
}
}
}
Console.SetCursorPosition(0, rootTop + 2 * last.Count - 1);
}
private void ValidateBracketNodeConnections(BracketNode bracketNode, Match correctParentMatch, Match correctChildMatch1, Match correctChildMatch2)
{
ValidateBracketNodeMatch(bracketNode.Parent, correctParentMatch);
ValidateBracketNodeMatch(bracketNode.Children[0], correctChildMatch1);
ValidateBracketNodeMatch(bracketNode.Children[1], correctChildMatch2);
}
static void PlotBrackets(IAsyncComparator <T> comparator, Node topMostRoot)
{
Graph graph = Graph.Directed;
Dictionary <Node, NodeId> nodeIdCache = new Dictionary <Node, NodeId>();
int bracketCounter = 0;
string NodeToString(Node node)
{
if (node is LeafNode)
{
return(((LeafNode)node).Item.ToString());
}
else
{
return($"B{++bracketCounter}");
}
}
NodeId NodeToNodeId(Node node)
{
if (!nodeIdCache.ContainsKey(node))
{
nodeIdCache[node] = new NodeId(NodeToString(node));
}
return(nodeIdCache[node]);
}
void Recurse(Node root)
{
if (root is BracketNode)
{
BracketNode node = root as BracketNode;
Debug.Assert(node.CompetitorA.Parent == node);
Debug.Assert(node.CompetitorB.Parent == node);
graph = graph.Add(EdgeStatement.For(
NodeToNodeId(node),
NodeToNodeId(node.CompetitorA)));
graph = graph.Add(EdgeStatement.For(
NodeToNodeId(node),
NodeToNodeId(node.CompetitorB)));
Recurse(node.CompetitorA);
Recurse(node.CompetitorB);
}
}
Recurse(topMostRoot);
IRenderer renderer = new Renderer(@"C:\Program Files (x86)\Graphviz2.38\bin");
using (Stream file = File.Create("graph.png"))
{
AsyncHelper.RunSync(async() => await renderer.RunAsync(
graph, file,
RendererLayouts.Dot,
RendererFormats.Png,
CancellationToken.None));
}
}
