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)); } }