Heroyt / tournament-generator

src/TournamentGenerator/Tournament.php

Spacing +1 added lines, -1 removed lines

@@ -155,7 +155,7 @@
 	 */
 	public function getTournamentTime() : int {
 		$games = count($this->getGames());
-		return $games * $this->expectedPlay + ($games - 1) * $this->expectedGameWait + (count($this->getRounds()) - 1) * $this->expectedRoundWait + (count($this->getCategories()) - 1) * $this->expectedCategoryWait;
+		return $games*$this->expectedPlay+($games-1)*$this->expectedGameWait+(count($this->getRounds())-1)*$this->expectedRoundWait+(count($this->getCategories())-1)*$this->expectedCategoryWait;
 	}
 
 	/**

src/TournamentGenerator/Helpers/FilterComparator.php

Spacing +1 added lines, -1 removed lines

@@ -121,7 +121,7 @@
 		foreach ($groupsId as $id) {
 			$games += count($team->getGames(null, $id));
 		}
-		return self::calcSum($team, $groupsId) / $games;
+		return self::calcSum($team, $groupsId)/$games;
 	}
 
 	/**

src/TournamentGenerator/Helpers/Generator.php

Braces +1 added lines, -2 removed lines

@@ -62,8 +62,7 @@
 	public function setType(string $type = Constants::ROUND_ROBIN) : Generator {
 		if (in_array($type, Constants::GroupTypes, true)) {
 			$this->type = $type;
-		}
-		else {
+		} else {
 			throw new Exception('Unknown group type: '.$type);
 		}
 		return $this;

Spacing +6 added lines, -6 removed lines

@@ -178,14 +178,14 @@ 
 	 */
 	public static function circle_genGames2(Group $group, array $teams = []) : array {
 
-		if (count($teams) % 2 !== 0) {
+		if (count($teams)%2 !== 0) {
 			$teams[] = Constants::DUMMY_TEAM;
 		} // IF NOT EVEN NUMBER OF TEAMS, ADD DUMMY
 
 		shuffle($teams); // SHUFFLE TEAMS FOR MORE RANDOMNESS
 
 		$rounds = [];
-		for ($i = 0; $i < count($teams) - 1; $i++) {
+		for ($i = 0; $i < count($teams)-1; $i++) {
 			$rounds[] = self::circle_saveBracket($teams, $group); // SAVE CURRENT ROUND
 
 			$teams = self::circle_rotateBracket($teams); // ROTATE TEAMS IN BRACKET
@@ -207,7 +207,7 @@ 
 
 		$bracket = [];
 
-		for ($i = 0; $i < count($teams) / 2; $i++) { // GO THROUGH HALF OF THE TEAMS
+		for ($i = 0; $i < count($teams)/2; $i++) { // GO THROUGH HALF OF THE TEAMS
 
 			$home = $teams[$i];
 			$reverse = array_reverse($teams);
@@ -235,7 +235,7 @@ 
 	public static function circle_rotateBracket(array $teams) : array {
 
 		$first = array_shift($teams); // THE FIRST TEAM REMAINS FIRST
-		$last = array_shift($teams);  // THE SECOND TEAM MOVES TO LAST PLACE
+		$last = array_shift($teams); // THE SECOND TEAM MOVES TO LAST PLACE
 
 		return array_merge([$first], $teams, [$last]); // MERGE BACK TOGETHER
 
@@ -304,7 +304,7 @@ 
 		shuffle($teams);
 		$count = count($teams); // Store original count for exception
 
-		$discard = array_splice($teams, 0, $count % $this->inGame);
+		$discard = array_splice($teams, 0, $count%$this->inGame);
 
 		$teams = $this->saveTwoTwoGames($teams);
 
@@ -333,7 +333,7 @@ 
 			$games = [];
 
 			// Split teams into chunks of maximum size
-			$groups = array_chunk($teams, (int) ceil($count / ceil($count / $this->maxSize)));
+			$groups = array_chunk($teams, (int) ceil($count/ceil($count/$this->maxSize)));
 			// Generate games for each chunk
 			foreach ($groups as $group) {
 				$games[] = $this->r_rGames($group);

src/TournamentGenerator/Game.php

Braces +2 added lines, -4 removed lines

@@ -221,13 +221,11 @@
 			$this->drawIds[] = $team->getId();
 			$team->addDraw($this->group->getId());
 			$this->results[$team->getId()] += ['points' => $this->group->getDrawPoints(), 'type' => 'draw'];
-		}
-		elseif ($teamPosition === 1) {
+		} elseif ($teamPosition === 1) {
 			$this->winId = $team->getId();
 			$team->addWin($this->group->getId());
 			$this->results[$team->getId()] += ['points' => $this->group->getWinPoints(), 'type' => 'win'];
-		}
-		else {
+		} else {
 			$this->lossId = $team->getId();
 			$team->addLoss($this->group->getId());
 			$this->results[$team->getId()] += ['points' => $this->group->getLostPoints(), 'type' => 'loss'];

src/TournamentGenerator/Preset/R2G.php

Spacing +2 added lines, -2 removed lines

@@ -50,14 +50,14 @@
 
 		$this->splitTeams($round1);
 
-		if (count($this->getTeams()) % 4 === 2) {
+		if (count($this->getTeams())%4 === 2) {
 			$group_top = $round2->group('TOP')->setType(Constants::ROUND_TWO);
 
 			$filter_win_2 = new TeamFilter('wins', '=', 2, [$group_0_0, $group_top]);
 			$filter_loss_2 = new TeamFilter('losses', '=', 2, [$group_0_0, $group_top]);
 			$filter_win_1_both = new TeamFilter('wins', '=', 1, [$group_0_0, $group_top]);
 			$filter_loss_1_both = new TeamFilter('losses', '=', 1, [$group_0_0, $group_top]);
-			$group_0_0->progression($group_top, 0, 1)->addFilter($filter_win_1);  // PROGRESS THE BEST WINNING TEAM
+			$group_0_0->progression($group_top, 0, 1)->addFilter($filter_win_1); // PROGRESS THE BEST WINNING TEAM
 			$group_0_0->progression($group_top, 0, 1)->addFilter($filter_loss_1); // PROGRESS THE BEST LOSING TEAM
 			$group_top->progression($group_2_0)->addFilter($filter_win_2);
 			$group_top->progression($group_0_2)->addFilter($filter_loss_2);

src/TournamentGenerator/Preset/DoubleElimination.php

Spacing +23 added lines, -23 removed lines

@@ -43,9 +43,9 @@ 
 
 		$startRound = $this->round('Start round');
 
-		$roundsNum = log($nextPow, 2) * 2;
+		$roundsNum = log($nextPow, 2)*2;
 
-		$startGroups = ($countTeams + $byes) / 2;
+		$startGroups = ($countTeams+$byes)/2;
 
 		$previousGroups = [];
 		$previousLosingGroups = [];
@@ -63,7 +63,7 @@ 
 		$lastLosingGroup = null;
 		$lastWinningGroup = end($allGroups);
 
-		for ($r = 2; $r <= $roundsNum - 1; $r++) {
+		for ($r = 2; $r <= $roundsNum-1; $r++) {
 			$groups = [];
 			$losingGroups = [];
 			$round = $this->round('Round '.$r);
@@ -112,7 +112,7 @@ 
 		$nextPow = $countTeams;
 		if (!Functions::isPowerOf2($countTeams)) {
 			$nextPow = Functions::nextPowerOf2($countTeams);
-			$byes = $nextPow - $countTeams;
+			$byes = $nextPow-$countTeams;
 		}
 		return $byes;
 	}
@@ -130,10 +130,10 @@ 
 	 * @return void Last losing group
 	 */
 	private function generateLosingSide(int $roundNum, Round $round, array &$allGroups, array $previousLosingGroups = [], array $previousGroups = [], array &$losingGroups = []) : void {
-		$losingGroupTeamsCount = count($previousLosingGroups) + count($previousGroups);
+		$losingGroupTeamsCount = count($previousLosingGroups)+count($previousGroups);
 		$order = 2;
 		if (Functions::isPowerOf2($losingGroupTeamsCount)) { // IF THE NUMBER OF TEAMS IS A POWER OF 2, GENERATE GROUPS WITHOUT BYES
-			for ($g = 1; $g <= $losingGroupTeamsCount / 2; $g++) {
+			for ($g = 1; $g <= $losingGroupTeamsCount/2; $g++) {
 				$group = $round
 					->group('Round '.$roundNum.' (loss '.$g.')')
 					->setInGame(2)
@@ -143,13 +143,13 @@ 
 				$order += 2;
 				$losingGroups[] = $group;
 				if ($roundNum === 2) {                                                   // FIRST LOSING ROUND
-					$previousGroups[2 * ($g - 1)]->progression($group, 1, 1);              // PROGRESS FROM STARTING GROUP
-					$previousGroups[(2 * ($g - 1)) + 1]->progression($group, 1, 1);        // PROGRESS FROM STARTING GROUP
+					$previousGroups[2*($g-1)]->progression($group, 1, 1); // PROGRESS FROM STARTING GROUP
+					$previousGroups[(2*($g-1))+1]->progression($group, 1, 1); // PROGRESS FROM STARTING GROUP
 				}
 				elseif ($losingGroupTeamsCount >= 2) {
-					$previousLosingGroups[$g - 1]->progression($group, 0, 1); // PROGRESS FROM LOSING GROUP BEFORE
-					if (isset(array_reverse($previousGroups)[$g - 1])) {
-						array_reverse($previousGroups)[$g - 1]->progression($group, 1, 1);
+					$previousLosingGroups[$g-1]->progression($group, 0, 1); // PROGRESS FROM LOSING GROUP BEFORE
+					if (isset(array_reverse($previousGroups)[$g-1])) {
+						array_reverse($previousGroups)[$g-1]->progression($group, 1, 1);
 					} // PROGRESS FROM WINNING GROUP BEFORE
 					else {
 						$previousLosingGroups[$g]->progression($group, 0, 1);
@@ -159,15 +159,15 @@ 
 		}
 		else { // IF THE NUMBER OF TEAMS IS NOT A POWER OF 2, GENERATE GROUPS WITH BYES
 			// LOOK FOR THE CLOSEST LOWER POWER OF 2
-			$losingByes = $losingGroupTeamsCount - Functions::previousPowerOf2($losingGroupTeamsCount);
-			$n = (floor(count($previousLosingGroups) / 2) + $losingByes);
+			$losingByes = $losingGroupTeamsCount-Functions::previousPowerOf2($losingGroupTeamsCount);
+			$n = (floor(count($previousLosingGroups)/2)+$losingByes);
 			$byesGroupsNums = [];
 			$byesProgressed = 0;
 			for ($i = 0; $i < $losingByes; $i++) {
-				$byesGroupsNums[] = (int) $n - ($i * 2);
+				$byesGroupsNums[] = (int) $n-($i*2);
 			}
 			$lastGroup = 0;
-			for ($g = 1; $g <= ((count($previousLosingGroups) / 2) + $losingByes); $g++) {
+			for ($g = 1; $g <= ((count($previousLosingGroups)/2)+$losingByes); $g++) {
 				$group = $round
 					->group('Round '.$roundNum.' (loss '.$g.')')
 					->setInGame(2)
@@ -177,13 +177,13 @@ 
 				$order += 2;
 				$losingGroups[] = $group;
 				if (isset($previousGroups[$byesProgressed]) && in_array($lastGroup, $byesGroupsNums, true)) {  // EMPTY GROUP FROM BYE
-					$previousGroups[$byesProgressed]->progression($group, 1, 1);                                 // PROGRESS FROM WINNING GROUP BEFORE
+					$previousGroups[$byesProgressed]->progression($group, 1, 1); // PROGRESS FROM WINNING GROUP BEFORE
 					$byesProgressed++;
 				}
 				else {
 					$previousLosingGroups[$lastGroup]->progression($group, 0, 1); // PROGRESS FROM LOSING GROUP BEFORE
-					if (isset($previousLosingGroups[$lastGroup + 1])) {                         // PROGRESS FROM LOSING GROUP BEFORE
-						$previousLosingGroups[$lastGroup + 1]->progression($group, 0, 1);
+					if (isset($previousLosingGroups[$lastGroup+1])) {                         // PROGRESS FROM LOSING GROUP BEFORE
+						$previousLosingGroups[$lastGroup+1]->progression($group, 0, 1);
 					}
 					$lastGroup += 2;
 				}
@@ -207,7 +207,7 @@ 
 	 */
 	private function generateWinSide(int $roundNum, int $byes, int $countTeams, Round $round, array &$allGroups, array &$groups, Group &$lastWinningGroup = null, array $previousGroups = []) : void {
 		$order = 1;
-		for ($g = 1; $g <= (($countTeams + $byes) / (2 ** $roundNum)); $g++) {
+		for ($g = 1; $g <= (($countTeams+$byes)/(2 ** $roundNum)); $g++) {
 			$group = $round
 				->group('Round '.$roundNum.' (win '.$g.')')
 				->setInGame(2)
@@ -216,9 +216,9 @@ 
 			$allGroups[] = $group;
 			$order += 2;
 			$groups[] = $group;
-			$lastWinningGroup = $group;                                                   // KEEP THE LAST GROUP FOR FINALE
-			$previousGroups[2 * ($g - 1)]->progression($group, 0, 1);                     // PROGRESS FROM GROUP BEFORE
-			$previousGroups[(2 * ($g - 1)) + 1]->progression($group, 0, 1);               // PROGRESS FROM GROUP BEFORE
+			$lastWinningGroup = $group; // KEEP THE LAST GROUP FOR FINALE
+			$previousGroups[2*($g-1)]->progression($group, 0, 1); // PROGRESS FROM GROUP BEFORE
+			$previousGroups[(2*($g-1))+1]->progression($group, 0, 1); // PROGRESS FROM GROUP BEFORE
 		}
 	}
 
@@ -230,7 +230,7 @@ 
 		foreach ($this->getRounds() as $round) {
 			$name = $round->getName();
 			$len = strlen($name);
-			$str .= "\n| ---------------------------------------- |\n| ".str_repeat('-', floor((40 - $len) / 2) - 1).' '.$name.' '.str_repeat('-', ceil((40 - $len) / 2) - 1)." |\n| ---------------------------------------- |\n\n";
+			$str .= "\n| ---------------------------------------- |\n| ".str_repeat('-', floor((40-$len)/2)-1).' '.$name.' '.str_repeat('-', ceil((40-$len)/2)-1)." |\n| ---------------------------------------- |\n\n";
 			foreach ($round->getGroups() as $group) {
 				$str .= '-- '.$group->getName().PHP_EOL;
 				foreach ($group->getGames() as $game) {

Braces +3 added lines, -6 removed lines

@@ -145,8 +145,7 @@ 
 				if ($roundNum === 2) {                                                   // FIRST LOSING ROUND
 					$previousGroups[2 * ($g - 1)]->progression($group, 1, 1);              // PROGRESS FROM STARTING GROUP
 					$previousGroups[(2 * ($g - 1)) + 1]->progression($group, 1, 1);        // PROGRESS FROM STARTING GROUP
-				}
-				elseif ($losingGroupTeamsCount >= 2) {
+				} elseif ($losingGroupTeamsCount >= 2) {
 					$previousLosingGroups[$g - 1]->progression($group, 0, 1); // PROGRESS FROM LOSING GROUP BEFORE
 					if (isset(array_reverse($previousGroups)[$g - 1])) {
 						array_reverse($previousGroups)[$g - 1]->progression($group, 1, 1);
@@ -156,8 +155,7 @@ 
 					} // PROGRESS OTHER TEAM FROM LOSING GROUP BEFORE
 				}
 			}
-		}
-		else { // IF THE NUMBER OF TEAMS IS NOT A POWER OF 2, GENERATE GROUPS WITH BYES
+		} else { // IF THE NUMBER OF TEAMS IS NOT A POWER OF 2, GENERATE GROUPS WITH BYES
 			// LOOK FOR THE CLOSEST LOWER POWER OF 2
 			$losingByes = $losingGroupTeamsCount - Functions::previousPowerOf2($losingGroupTeamsCount);
 			$n = (floor(count($previousLosingGroups) / 2) + $losingByes);
@@ -179,8 +177,7 @@ 
 				if (isset($previousGroups[$byesProgressed]) && in_array($lastGroup, $byesGroupsNums, true)) {  // EMPTY GROUP FROM BYE
 					$previousGroups[$byesProgressed]->progression($group, 1, 1);                                 // PROGRESS FROM WINNING GROUP BEFORE
 					$byesProgressed++;
-				}
-				else {
+				} else {
 					$previousLosingGroups[$lastGroup]->progression($group, 0, 1); // PROGRESS FROM LOSING GROUP BEFORE
 					if (isset($previousLosingGroups[$lastGroup + 1])) {                         // PROGRESS FROM LOSING GROUP BEFORE
 						$previousLosingGroups[$lastGroup + 1]->progression($group, 0, 1);

src/TournamentGenerator/Preset/SingleElimination.php

Spacing +4 added lines, -4 removed lines

@@ -33,16 +33,16 @@ 
 		$byes = 0;
 		if (!Functions::isPowerOf2($countTeams)) {
 			$nextPow = Functions::nextPowerOf2($countTeams);
-			$byes = $nextPow - $countTeams;
+			$byes = $nextPow-$countTeams;
 		}
 
-		$roundsNum = log($countTeams + $byes, 2); // NUMBER OF ROUNDS
+		$roundsNum = log($countTeams+$byes, 2); // NUMBER OF ROUNDS
 
 		$startRound = $this->round('Start');
 
 		$previousGroups = [];
 
-		for ($i = 1; $i <= (($countTeams + $byes) / 2); $i++) {
+		for ($i = 1; $i <= (($countTeams+$byes)/2); $i++) {
 			$g = $startRound->group('Round 1 '.$i)->setInGame(2)->setType(Constants::ROUND_TWO);
 			$previousGroups[] = $g;
 		}
@@ -52,7 +52,7 @@ 
 		for ($r = 2; $r <= $roundsNum; $r++) {
 			$groups = [];
 			$round = $this->round('Round '.$r);
-			for ($g = 1; $g <= (($countTeams + $byes) / (2 ** $r)); $g++) {
+			for ($g = 1; $g <= (($countTeams+$byes)/(2 ** $r)); $g++) {
 				$group = $round->group('Round '.$r.' - '.$g)->setInGame(2)->setType(Constants::ROUND_TWO);
 				$groups[] = $group;
 				array_shift($previousGroups)->progression($group, 0, 1); // PROGRESS FROM GROUP BEFORE

src/TournamentGenerator/Progression.php

Braces +3 added lines, -6 removed lines

@@ -95,15 +95,13 @@ 
 
 		if ($blank) {
 			$teams = $this->from->isPlayed() ? $this->from->sortTeams(null, $this->filters) : $this->from->simulate($this->filters);
-		}
-		else {
+		} else {
 			$teams = $this->from->sortTeams(null, $this->filters);
 		}
 
 		if ($this->start !== 0 || $this->len !== null) {
 			$next = array_splice($teams, $this->start, ($this->len ?? count($teams)));
-		}
-		else {
+		} else {
 			$next = $teams;
 		}
 
@@ -112,8 +110,7 @@ 
 		foreach ($next as $team) {
 			if ($blank) {
 				$this->to->addTeam(new BlankTeam($this.' - '.$i++, $team, $this->from, $this));
-			}
-			else {
+			} else {
 				$team->addPoints($this->from->getProgressPoints());
 			}
 		}

src/TournamentGenerator/Base.php

Braces +1 added lines, -2 removed lines

@@ -70,8 +70,7 @@
 		if (!is_string($id) && !is_int($id)) {
 			$this->id = uniqid('', false);
 			throw new InvalidArgumentException('Unsupported id type ('.gettype($id).') - expected type of string or int');
-		}
-		else {
+		} else {
 			$this->id = $id;
 		}
 		return $this;