| @@ -20,7 +20,7 @@ discard block | ||
| 20 | 20 | |
| 21 | 21 | private $allowSkip = false; | 
| 22 | 22 | |
| 23 | -	function __construct(string $name = ''){ | |
| 23 | +	function __construct(string $name = '') { | |
| 24 | 24 | $this->name = $name; | 
| 25 | 25 | } | 
| 26 | 26 |  	public function __toString() { | 
| @@ -55,16 +55,16 @@ discard block | ||
| 55 | 55 |  	public function getCategoryWait() { | 
| 56 | 56 | return $this->expectedCategoryWait; | 
| 57 | 57 | } | 
| 58 | -	public function getTournamentTime(){ | |
| 58 | +	public function getTournamentTime() { | |
| 59 | 59 | $games = count($this->getGames()); | 
| 60 | 60 | return $games*$this->expectedPlay+$games*$this->expectedGameWait+count($this->getRounds())*$this->expectedRoundWait+count($this->getCategories())*$this->expectedCategoryWait; | 
| 61 | 61 | } | 
| 62 | 62 | |
| 63 | -	public function allowSkip(){ | |
| 63 | +	public function allowSkip() { | |
| 64 | 64 | $this->allowSkip = true; | 
| 65 | 65 | return $this; | 
| 66 | 66 | } | 
| 67 | -	public function disallowSkip(){ | |
| 67 | +	public function disallowSkip() { | |
| 68 | 68 | $this->allowSkip = false; | 
| 69 | 69 | return $this; | 
| 70 | 70 | } | 
| @@ -76,7 +76,7 @@ discard block | ||
| 76 | 76 | return $this->allowSkip; | 
| 77 | 77 | } | 
| 78 | 78 | |
| 79 | -	public function addCategory(Category ...$categories){ | |
| 79 | +	public function addCategory(Category ...$categories) { | |
| 80 | 80 |  		foreach ($categories as $category) { | 
| 81 | 81 | if ($category instanceof Category) $this->categories[] = $category; | 
| 82 | 82 |  			else throw new \Exception('Trying to add category which is not an instance of the Category class.'); | 
| @@ -117,7 +117,7 @@ discard block | ||
| 117 | 117 | |
| 118 | 118 |  	public function addTeam(...$teams) { | 
| 119 | 119 |  		foreach ($teams as $team) { | 
| 120 | -			if ($team instanceof Team)  { | |
| 120 | +			if ($team instanceof Team) { | |
| 121 | 121 | $this->teams[] = $team; | 
| 122 | 122 | continue; | 
| 123 | 123 | } | 
| @@ -78,8 +78,11 @@ discard block | ||
| 78 | 78 | |
| 79 | 79 |  	public function addCategory(Category ...$categories){ | 
| 80 | 80 |  		foreach ($categories as $category) { | 
| 81 | - if ($category instanceof Category) $this->categories[] = $category; | |
| 82 | -			else throw new \Exception('Trying to add category which is not an instance of the Category class.'); | |
| 81 | +			if ($category instanceof Category) { | |
| 82 | + $this->categories[] = $category; | |
| 83 | +			} else { | |
| 84 | +				throw new \Exception('Trying to add category which is not an instance of the Category class.'); | |
| 85 | + } | |
| 83 | 86 | } | 
| 84 | 87 | return $this; | 
| 85 | 88 | } | 
| @@ -94,8 +97,11 @@ discard block | ||
| 94 | 97 | |
| 95 | 98 |  	public function addRound(Round ...$rounds) { | 
| 96 | 99 |  		foreach ($rounds as $round) { | 
| 97 | - if ($round instanceof Round) $this->rounds[] = $round; | |
| 98 | -			else throw new \Exception('Trying to add round which is not an instance of the Round class.'); | |
| 100 | +			if ($round instanceof Round) { | |
| 101 | + $this->rounds[] = $round; | |
| 102 | +			} else { | |
| 103 | +				throw new \Exception('Trying to add round which is not an instance of the Round class.'); | |
| 104 | + } | |
| 99 | 105 | } | 
| 100 | 106 | return $this; | 
| 101 | 107 | } | 
| @@ -120,8 +126,7 @@ discard block | ||
| 120 | 126 |  			if ($team instanceof Team)  { | 
| 121 | 127 | $this->teams[] = $team; | 
| 122 | 128 | continue; | 
| 123 | - } | |
| 124 | -			elseif (gettype($team) === 'array') { | |
| 129 | +			} elseif (gettype($team) === 'array') { | |
| 125 | 130 |  				array_merge($teams, array_filter($team, function($a) { | 
| 126 | 131 | return ($a instanceof Team); | 
| 127 | 132 | })); | 
| @@ -147,7 +152,9 @@ discard block | ||
| 147 | 152 | } | 
| 148 | 153 | $this->teams = $teams; | 
| 149 | 154 | } | 
| 150 | - if ($ordered) $this->sortTeams($ordering); | |
| 155 | +		if ($ordered) { | |
| 156 | + $this->sortTeams($ordering); | |
| 157 | + } | |
| 151 | 158 | return $this->teams; | 
| 152 | 159 | } | 
| 153 | 160 |  	public function sortTeams($ordering = \POINTS) { | 
| @@ -170,7 +177,9 @@ discard block | ||
| 170 | 177 | |
| 171 | 178 |  	public function splitTeams(Round ...$wheres) { | 
| 172 | 179 | |
| 173 | - if (count($wheres) === 0) $wheres = $this->getRounds(); | |
| 180 | +		if (count($wheres) === 0) { | |
| 181 | + $wheres = $this->getRounds(); | |
| 182 | + } | |
| 174 | 183 | |
| 175 | 184 |  		foreach ($wheres as $key => $value) { | 
| 176 | 185 |  			if (gettype($value) === 'array') { | 
| @@ -185,7 +194,9 @@ discard block | ||
| 185 | 194 | |
| 186 | 195 |  		while (count($teams) > 0) { | 
| 187 | 196 |  			foreach ($wheres as $where) { | 
| 188 | - if (count($teams) > 0) $where->addTeam(array_shift($teams)); | |
| 197 | +				if (count($teams) > 0) { | |
| 198 | + $where->addTeam(array_shift($teams)); | |
| 199 | + } | |
| 189 | 200 | } | 
| 190 | 201 | } | 
| 191 | 202 |  		foreach ($wheres as $where) { | 
| @@ -197,13 +208,17 @@ discard block | ||
| 197 | 208 |  	public function genGamesSimulate(bool $returnTime = false) { | 
| 198 | 209 | $games = Utilis\Simulator::simulateTournament($this); | 
| 199 | 210 | |
| 200 | - if ($returnTime) return $this->getTournamentTime(); | |
| 211 | +		if ($returnTime) { | |
| 212 | + return $this->getTournamentTime(); | |
| 213 | + } | |
| 201 | 214 | return $games; | 
| 202 | 215 | } | 
| 203 | 216 |  	public function genGamesSimulateReal(bool $returnTime = false) { | 
| 204 | 217 | $games = Utilis\Simulator::simulateTournamentReal($this); | 
| 205 | 218 | |
| 206 | - if ($returnTime) return $this->getTournamentTime(); | |
| 219 | +		if ($returnTime) { | |
| 220 | + return $this->getTournamentTime(); | |
| 221 | + } | |
| 207 | 222 | return $games; | 
| 208 | 223 | } | 
| 209 | 224 | |
| @@ -25,8 +25,11 @@ discard block | ||
| 25 | 25 | |
| 26 | 26 |  	public function addGroup(Group ...$groups){ | 
| 27 | 27 |  		foreach ($groups as $group) { | 
| 28 | - if ($group instanceof Group) $this->groups[] = $group; | |
| 29 | -			else throw new \Exception('Trying to add group which is not an instance of Group class.'); | |
| 28 | +			if ($group instanceof Group) { | |
| 29 | + $this->groups[] = $group; | |
| 30 | +			} else { | |
| 31 | +				throw new \Exception('Trying to add group which is not an instance of Group class.'); | |
| 32 | + } | |
| 30 | 33 | } | 
| 31 | 34 | return $this; | 
| 32 | 35 | } | 
| @@ -77,7 +80,9 @@ discard block | ||
| 77 | 80 | } | 
| 78 | 81 |  	public function isPlayed(){ | 
| 79 | 82 |  		foreach ($this->groups as $group) { | 
| 80 | - if (!$group->isPlayed()) return false; | |
| 83 | +			if (!$group->isPlayed()) { | |
| 84 | + return false; | |
| 85 | + } | |
| 81 | 86 | } | 
| 82 | 87 | return true; | 
| 83 | 88 | } | 
| @@ -86,10 +91,11 @@ discard block | ||
| 86 | 91 |  		foreach ($teams as $team) { | 
| 87 | 92 |  			if ($team instanceof Team)  { | 
| 88 | 93 | $this->teams[] = $team; | 
| 89 | - } | |
| 90 | -			elseif (gettype($team) === 'array') { | |
| 94 | +			} elseif (gettype($team) === 'array') { | |
| 91 | 95 |  				foreach ($team as $team2) { | 
| 92 | - if ($team2 instanceof Team) $this->teams[] = $team2; | |
| 96 | +					if ($team2 instanceof Team) { | |
| 97 | + $this->teams[] = $team2; | |
| 98 | + } | |
| 93 | 99 | $team2->groupResults[$this->id] = [ | 
| 94 | 100 | 'group' => $this, | 
| 95 | 101 | 'points' => 0, | 
| @@ -101,8 +107,9 @@ discard block | ||
| 101 | 107 | 'third' => 0 | 
| 102 | 108 | ]; | 
| 103 | 109 | } | 
| 110 | +			} else { | |
| 111 | +				throw new \Exception('Trying to add team which is not an instance of Team class'); | |
| 104 | 112 | } | 
| 105 | -			else throw new \Exception('Trying to add team which is not an instance of Team class'); | |
| 106 | 113 | } | 
| 107 | 114 | return $this; | 
| 108 | 115 | } | 
| @@ -131,7 +138,9 @@ discard block | ||
| 131 | 138 | |
| 132 | 139 |  	public function splitTeams(...$groups) { | 
| 133 | 140 | |
| 134 | - if (count($groups) === 0) $groups = $this->getGroups(); | |
| 141 | +		if (count($groups) === 0) { | |
| 142 | + $groups = $this->getGroups(); | |
| 143 | + } | |
| 135 | 144 | |
| 136 | 145 |  		foreach ($groups as $key => $value) { | 
| 137 | 146 |  			if (gettype($value) === 'array') { | 
| @@ -146,7 +155,9 @@ discard block | ||
| 146 | 155 |  		while (count($teams) > 0) { | 
| 147 | 156 |  			foreach ($groups as $group) { | 
| 148 | 157 |  				if ($group instanceof Group) { | 
| 149 | - if (count($teams) > 0) $group->addTeam(array_shift($teams)); | |
| 158 | +					if (count($teams) > 0) { | |
| 159 | + $group->addTeam(array_shift($teams)); | |
| 160 | + } | |
| 150 | 161 | } | 
| 151 | 162 | } | 
| 152 | 163 | } | 
| @@ -26,27 +26,31 @@ discard block | ||
| 26 | 26 |  				switch (strtolower($key)) { | 
| 27 | 27 | case 'and': | 
| 28 | 28 |  						foreach ($teams as $tkey => $team) { | 
| 29 | - if (!$this->filterAnd($team, $filter)) unset($teams[$tkey]); // IF FILTER IS NOT VALIDATED REMOVE TEAM FROM RETURN ARRAY | |
| 29 | +							if (!$this->filterAnd($team, $filter)) { | |
| 30 | + unset($teams[$tkey]); | |
| 31 | + } | |
| 32 | + // IF FILTER IS NOT VALIDATED REMOVE TEAM FROM RETURN ARRAY | |
| 30 | 33 | } | 
| 31 | 34 | break; | 
| 32 | 35 | case 'or': | 
| 33 | 36 |  						foreach ($teams as $tkey => $team) { | 
| 34 | - if (!$this->filterOr($team, $filter)) unset($teams[$tkey]); // IF FILTER IS NOT VALIDATED REMOVE TEAM FROM RETURN ARRAY | |
| 37 | +							if (!$this->filterOr($team, $filter)) { | |
| 38 | + unset($teams[$tkey]); | |
| 39 | + } | |
| 40 | + // IF FILTER IS NOT VALIDATED REMOVE TEAM FROM RETURN ARRAY | |
| 35 | 41 | } | 
| 36 | 42 | break; | 
| 37 | 43 | default: | 
| 38 | 44 |  						throw new \Exception('Unknown opperand type "'.$key.'". Expected "and" or "or".'); | 
| 39 | 45 | break; | 
| 40 | 46 | } | 
| 41 | - } | |
| 42 | -			elseif ($filter instanceof TeamFilter) { | |
| 47 | +			} elseif ($filter instanceof TeamFilter) { | |
| 43 | 48 |  				foreach ($teams as $tkey => $team) { | 
| 44 | 49 |  					if (!$filter->validate($team, $this->group->id, 'sum', $this->group)) { | 
| 45 | 50 | unset($teams[$tkey]); // IF FILTER IS NOT VALIDATED REMOVE TEAM FROM RETURN ARRAY | 
| 46 | 51 | } | 
| 47 | 52 | } | 
| 48 | - } | |
| 49 | -			else { | |
| 53 | +			} else { | |
| 50 | 54 |  				throw new \Exception('Filer ['.$key.'] is not an instance of TeamFilter class'); | 
| 51 | 55 | } | 
| 52 | 56 | } | 
| @@ -58,20 +62,24 @@ discard block | ||
| 58 | 62 |  			if (gettype($value) === 'array') { | 
| 59 | 63 |  				switch (strtolower($key)) { | 
| 60 | 64 | case 'and': | 
| 61 | - if ($this->filterAnd($team, $value)) return false; | |
| 65 | +						if ($this->filterAnd($team, $value)) { | |
| 66 | + return false; | |
| 67 | + } | |
| 62 | 68 | break; | 
| 63 | 69 | case 'or': | 
| 64 | - if ($this->filterOr($team, $value)) return false; | |
| 70 | +						if ($this->filterOr($team, $value)) { | |
| 71 | + return false; | |
| 72 | + } | |
| 65 | 73 | break; | 
| 66 | 74 | default: | 
| 67 | 75 |  						throw new \Exception('Unknown opperand type "'.$key.'". Expected "and" or "or".'); | 
| 68 | 76 | break; | 
| 69 | 77 | } | 
| 70 | - } | |
| 71 | -			elseif ($value instanceof TeamFilter) { | |
| 72 | - if (!$value->validate($team, $this->group->id, 'sum', $this->group)) return false; | |
| 73 | - } | |
| 74 | -			else { | |
| 78 | +			} elseif ($value instanceof TeamFilter) { | |
| 79 | +				if (!$value->validate($team, $this->group->id, 'sum', $this->group)) { | |
| 80 | + return false; | |
| 81 | + } | |
| 82 | +			} else { | |
| 75 | 83 |  				throw new \Exception('Filer ['.$key.'] is not an instance of TeamFilter class'); | 
| 76 | 84 | } | 
| 77 | 85 | } | 
| @@ -82,20 +90,24 @@ discard block | ||
| 82 | 90 |  			if (gettype($value) === 'array') { | 
| 83 | 91 |  				switch (strtolower($key)) { | 
| 84 | 92 | case 'and': | 
| 85 | - if ($this->filterAnd($team, $value)) return true; | |
| 93 | +						if ($this->filterAnd($team, $value)) { | |
| 94 | + return true; | |
| 95 | + } | |
| 86 | 96 | break; | 
| 87 | 97 | case 'or': | 
| 88 | - if ($this->filterOr($team, $value)) return true; | |
| 98 | +						if ($this->filterOr($team, $value)) { | |
| 99 | + return true; | |
| 100 | + } | |
| 89 | 101 | break; | 
| 90 | 102 | default: | 
| 91 | 103 |  						throw new \Exception('Unknown opperand type "'.$key.'". Expected "and" or "or".'); | 
| 92 | 104 | break; | 
| 93 | 105 | } | 
| 94 | - } | |
| 95 | -			elseif ($value instanceof TeamFilter) { | |
| 96 | - if (!$value->validate($team, $this->group->id, 'sum', $this->group)) return true; | |
| 97 | - } | |
| 98 | -			else { | |
| 106 | +			} elseif ($value instanceof TeamFilter) { | |
| 107 | +				if (!$value->validate($team, $this->group->id, 'sum', $this->group)) { | |
| 108 | + return true; | |
| 109 | + } | |
| 110 | +			} else { | |
| 99 | 111 |  				throw new \Exception('Filer ['.$key.'] is not an instance of TeamFilter class'); | 
| 100 | 112 | } | 
| 101 | 113 | } | 
| @@ -18,7 +18,9 @@ discard block | ||
| 18 | 18 | $game->setResults($results); | 
| 19 | 19 | } | 
| 20 | 20 | $return = $group->sortTeams($filters); | 
| 21 | - if (!$reset) return $return; | |
| 21 | +		if (!$reset) { | |
| 22 | + return $return; | |
| 23 | + } | |
| 22 | 24 |  		foreach ($group->getGames() as $game) { | 
| 23 | 25 | $game->resetResults(); | 
| 24 | 26 | } | 
| @@ -27,14 +29,18 @@ discard block | ||
| 27 | 29 | |
| 28 | 30 |  	public static function simulateRound(\TournamentGenerator\Round $round) { | 
| 29 | 31 |  		foreach ($round->getGroups() as $group) { | 
| 30 | - if ($group->isPlayed()) continue; | |
| 32 | +			if ($group->isPlayed()) { | |
| 33 | + continue; | |
| 34 | + } | |
| 31 | 35 | $group->simulate([], false); | 
| 32 | 36 | } | 
| 33 | 37 | return true; | 
| 34 | 38 | } | 
| 35 | 39 | |
| 36 | 40 |  	public static function simulateTournament(\TournamentGenerator\Tournament $tournament) { | 
| 37 | -		if (count($tournament->getCategories()) === 0 && count($tournament->getRounds()) === 0) throw new \Exception('There are no rounds or categories to simulate games from.'); | |
| 41 | +		if (count($tournament->getCategories()) === 0 && count($tournament->getRounds()) === 0) { | |
| 42 | +			throw new \Exception('There are no rounds or categories to simulate games from.'); | |
| 43 | + } | |
| 38 | 44 | |
| 39 | 45 | $games = []; | 
| 40 | 46 | |
| @@ -55,7 +61,9 @@ discard block | ||
| 55 | 61 | |
| 56 | 62 |  	public static function simulateTournamentReal(\TournamentGenerator\Tournament $tournament) { | 
| 57 | 63 | $games = []; | 
| 58 | -		if (count($tournament->getCategories()) === 0 && count($tournament->getRounds()) === 0) throw new \Exception('There are no rounds or categories to simulate games from.'); | |
| 64 | +		if (count($tournament->getCategories()) === 0 && count($tournament->getRounds()) === 0) { | |
| 65 | +			throw new \Exception('There are no rounds or categories to simulate games from.'); | |
| 66 | + } | |
| 59 | 67 | |
| 60 | 68 |  		foreach ($tournament->getCategories() as $category) { | 
| 61 | 69 | $games = array_merge($games, $category->genGamesSimulate()); | 
| @@ -30,14 +30,18 @@ discard block | ||
| 30 | 30 |  		foreach ($settings as $key => $value) { | 
| 31 | 31 |  			switch ($key) { | 
| 32 | 32 | case 'name': | 
| 33 | -					if (gettype($value) !== 'string') throw new \Exception('Expected string as group name '.gettype($value).' given'); | |
| 33 | +					if (gettype($value) !== 'string') { | |
| 34 | +						throw new \Exception('Expected string as group name '.gettype($value).' given'); | |
| 35 | + } | |
| 34 | 36 | $this->name = $value; | 
| 35 | 37 | break; | 
| 36 | 38 | case 'type': | 
| 37 | 39 | $this->generator->setType($value); | 
| 38 | 40 | break; | 
| 39 | 41 | case 'ordering': | 
| 40 | -					if (!in_array($value, orderingTypes)) throw new \Exception('Unknown group ordering: '.$value); | |
| 42 | +					if (!in_array($value, orderingTypes)) { | |
| 43 | +						throw new \Exception('Unknown group ordering: '.$value); | |
| 44 | + } | |
| 41 | 45 | $this->ordering = $value; | 
| 42 | 46 | break; | 
| 43 | 47 | case 'inGame': | 
| @@ -45,7 +49,9 @@ discard block | ||
| 45 | 49 | break; | 
| 46 | 50 | case 'maxSize': | 
| 47 | 51 | $value = (int) $value; | 
| 48 | - if ($value > 1) $this->generator->setMaxSize($value); | |
| 52 | +					if ($value > 1) { | |
| 53 | + $this->generator->setMaxSize($value); | |
| 54 | + } | |
| 49 | 55 | break; | 
| 50 | 56 | case 'order': | 
| 51 | 57 | $this->order = (int) $value; | 
| @@ -87,10 +93,11 @@ discard block | ||
| 87 | 93 | 'second' => 0, | 
| 88 | 94 | 'third' => 0 | 
| 89 | 95 | ]; | 
| 90 | - } | |
| 91 | -			elseif (gettype($team) === 'array') { | |
| 96 | +			} elseif (gettype($team) === 'array') { | |
| 92 | 97 |  				foreach ($team as $team2) { | 
| 93 | - if ($team2 instanceof Team) $this->teams[] = $team2; | |
| 98 | +					if ($team2 instanceof Team) { | |
| 99 | + $this->teams[] = $team2; | |
| 100 | + } | |
| 94 | 101 | $team2->groupResults[$this->id] = [ | 
| 95 | 102 | 'group' => $this, | 
| 96 | 103 | 'points' => 0, | 
| @@ -102,16 +109,20 @@ discard block | ||
| 102 | 109 | 'third' => 0 | 
| 103 | 110 | ]; | 
| 104 | 111 | } | 
| 112 | +			} else { | |
| 113 | +				throw new \Exception('Trying to add team which is not an instance of Team class'); | |
| 105 | 114 | } | 
| 106 | -			else throw new \Exception('Trying to add team which is not an instance of Team class'); | |
| 107 | 115 | } | 
| 108 | 116 | return $this; | 
| 109 | 117 | } | 
| 110 | 118 |  	public function getTeams($filters = []) { | 
| 111 | 119 | $teams = $this->teams; | 
| 112 | 120 | |
| 113 | - if (gettype($filters) !== 'array' && $filters instanceof TeamFilter) $filters = [$filters]; | |
| 114 | - elseif (gettype($filters) !== 'array') $filters = []; | |
| 121 | +		if (gettype($filters) !== 'array' && $filters instanceof TeamFilter) { | |
| 122 | + $filters = [$filters]; | |
| 123 | +		} elseif (gettype($filters) !== 'array') { | |
| 124 | + $filters = []; | |
| 125 | + } | |
| 115 | 126 | |
| 116 | 127 | // APPLY FILTERS | 
| 117 | 128 | $filter = new Filter($this, $filters); | 
| @@ -136,7 +147,9 @@ discard block | ||
| 136 | 147 | return $t; | 
| 137 | 148 | } | 
| 138 | 149 |  	public function sortTeams($filters = [], $ordering = null) { | 
| 139 | - if (!isset($ordering)) $ordering = $this->ordering; | |
| 150 | +		if (!isset($ordering)) { | |
| 151 | + $ordering = $this->ordering; | |
| 152 | + } | |
| 140 | 153 | Utilis\Sorter\Teams::sortGroup($this->teams, $this, $ordering); | 
| 141 | 154 | return $this->getTeams($filters); | 
| 142 | 155 | } | 
| @@ -150,8 +163,11 @@ discard block | ||
| 150 | 163 | } | 
| 151 | 164 | |
| 152 | 165 |  	public function setOrdering(string $ordering = \POINTS) { | 
| 153 | - if (in_array($ordering, orderingTypes)) $this->ordering = $ordering; | |
| 154 | -		else throw new \Exception('Unknown group ordering: '.$ordering); | |
| 166 | +		if (in_array($ordering, orderingTypes)) { | |
| 167 | + $this->ordering = $ordering; | |
| 168 | +		} else { | |
| 169 | +			throw new \Exception('Unknown group ordering: '.$ordering); | |
| 170 | + } | |
| 155 | 171 | return $this; | 
| 156 | 172 | } | 
| 157 | 173 |  	public function getOrdering() { | 
| @@ -184,16 +200,13 @@ discard block | ||
| 184 | 200 |  		foreach ($teams as $team) { | 
| 185 | 201 |  			if ($team instanceOf Team) { | 
| 186 | 202 | $this->progressed[] = $team->id; | 
| 187 | - } | |
| 188 | -			elseif (gettype($team) === 'string' || gettype($team) === 'integer') { | |
| 203 | +			} elseif (gettype($team) === 'string' || gettype($team) === 'integer') { | |
| 189 | 204 | $this->progressed[] = $team; | 
| 190 | - } | |
| 191 | -			elseif (gettype($team) === 'array') { | |
| 205 | +			} elseif (gettype($team) === 'array') { | |
| 192 | 206 |  				foreach ($team as $teamInner) { | 
| 193 | 207 |  					if ($teamInner instanceOf Team) { | 
| 194 | 208 | $this->progressed[] = $teamInner->id; | 
| 195 | - } | |
| 196 | -					elseif (gettype($teamInner) === 'string' || gettype($teamInner) === 'integer') { | |
| 209 | +					} elseif (gettype($teamInner) === 'string' || gettype($teamInner) === 'integer') { | |
| 197 | 210 | $this->progressed[] = $teamInner; | 
| 198 | 211 | } | 
| 199 | 212 | } | 
| @@ -226,8 +239,11 @@ discard block | ||
| 226 | 239 | } | 
| 227 | 240 | } | 
| 228 | 241 |  		foreach ($games as $game) { | 
| 229 | - if ($game instanceof Game) $this->games[] = $game; | |
| 230 | -			else throw new \Exception('Trying to add game which is not instance of Game object.'); | |
| 242 | +			if ($game instanceof Game) { | |
| 243 | + $this->games[] = $game; | |
| 244 | +			} else { | |
| 245 | +				throw new \Exception('Trying to add game which is not instance of Game object.'); | |
| 246 | + } | |
| 231 | 247 | } | 
| 232 | 248 | return $this; | 
| 233 | 249 | } | 
| @@ -235,7 +251,9 @@ discard block | ||
| 235 | 251 | return $this->games; | 
| 236 | 252 | } | 
| 237 | 253 |  	public function orderGames() { | 
| 238 | - if (count($this->games) <= 4) return $this->games; | |
| 254 | +		if (count($this->games) <= 4) { | |
| 255 | + return $this->games; | |
| 256 | + } | |
| 239 | 257 | $this->games = $this->generator->orderGames(); | 
| 240 | 258 | return $this->games; | 
| 241 | 259 | } | 
| @@ -245,13 +263,17 @@ discard block | ||
| 245 | 263 | } | 
| 246 | 264 |  	public function resetGames() { | 
| 247 | 265 |  		foreach ($this->getGames() as $game) { | 
| 248 | - if (isset($game)) $game->resetResults(); | |
| 266 | +			if (isset($game)) { | |
| 267 | + $game->resetResults(); | |
| 268 | + } | |
| 249 | 269 | } | 
| 250 | 270 | return $this; | 
| 251 | 271 | } | 
| 252 | 272 |  	public function isPlayed(){ | 
| 253 | 273 |  		foreach ($this->games as $game) { | 
| 254 | - if ((isset($game) || !$this->getSkip()) && !$game->isPlayed()) return false; | |
| 274 | +			if ((isset($game) || !$this->getSkip()) && !$game->isPlayed()) { | |
| 275 | + return false; | |
| 276 | + } | |
| 255 | 277 | } | 
| 256 | 278 | return true; | 
| 257 | 279 | } |