Game::setResults() - Code Metrics - Inspection of "Decoupling and fixing" - Heroyt/tournament-generator - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Branch — master (0e4a87)

by Tomáš

created 2019-07-27 17:30 UTC

Game::setResults() B

↳ Parent: Game

Complexity

Conditions	7
Paths	12

Size

Total Lines	28
Code Lines	25

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
cc	7
eloc	25
nc	12
nop	1
dl	0
loc	28
rs	8.5866
c	0
b	0
f	0

<?php

namespace TournamentGenerator;

/**
 *
 */
class Game
{

	private $teams = [];
	private $results = [];
	private $group = null;
	private $winId = null;
	private $lossId = null;
	private $secondId = null;
	private $thirdId = null;
	private $drawIds = [];

	function __construct(array $teams, Group $group) {
		$this->group = $group;
		$error = [];
		$tids = [];
		foreach ($teams as $key => $team) {
			if (!$team instanceof Team) {
				$error[] = $team;
				unset($teams[$key]);
				continue;
			}
			$team->addGame($this);
			$tids[] = $team->id;
		}
		$this->teams = $teams;
		foreach ($this->teams as $team) {
			foreach ($this->teams as $team2) {
				if ($team === $team2) continue;
				$team->addGameWith($team2, $group);
			}
		}
		if (count($error) > 0) throw new \Exception('Trying to add teams ('.count($error).') that are not instance of Team class'.PHP_EOL.print_r($error, true));
	}

	public function getGroup() {
		return $this->group;
	}

	public function addTeam(...$teams) {
		$error = [];
		foreach ($teams as $key => $team) {
			if (!$team instanceof Team) {
				$error[] = $team;
				unset($teams[$key]);
				continue;
			}
			$this->teams[] = $team;
			$team->addGame($this);

			foreach ($this->teams as $team2) {
				if ($team === $team2) continue;
				if ($team instanceof Team) {
					$team->addGameWith($team2, $this->group);
					$team2->addGameWith($team, $this->group);
				}
			}
		}
		if (count($error) > 0) throw new \Exception('Trying to add teams ('.count($error).') that are not instance of Team class'.PHP_EOL.print_r($error, true));
		return $this;
	}
	public function getTeams(){
		return $this->teams;
	}
	public function getTeamsIds(){
		return array_map(function($a){ return $a->id; }, $this->teams);
	}
	public function getTeam(string $id) {
		foreach ($this->teams as $team) {
			if ($team->id === $id) return $team;
		}
		return false;
	}

	/**
	* $results = array (
	* * team->id => team->score
	* )
	*/
	public function setResults(array $results = []) {
		if (count($this->results) === 0) $this->resetResults();
		arsort($results);
		$inGame = /** @scrutinizer ignore-call */ $this->group->getInGame();
		$i = 1;
		foreach ($results as $id => $score) {
			$team = $this->getTeam($id);
			if ($team === false) throw new \Exception('Couldn\'t find team with id of "'.$id.'"');
			$this->results[$team->id] = ['score' => $score];
			$team->sumScore += $score;
			$prev = prev($results);
			next($results);
			$next = next($results);
			switch ($inGame) {
				case 2:
					$this->setResults2($score, $prev, $next, $team);
					break;
				case 3:
					$this->setResults3($i, $team);
					break;
				case 4:
					$this->setResults4($i, $team);
					break;
			}
			$team->groupResults[$this->group->id]['score'] += $score;
			$i++;
		}
		return $this;
	}
	private function setResults2($score, $prev, $next, $team) {
		if ($score === $prev || $score === $next) {
			$this->drawIds[] = $team->id;
			$team->addDraw($this->group->id);
			$this->results[$team->id] += ['points' => $this->group->drawPoints, 'type' => 'draw'];
		}
		elseif ($i === 1) {

			$this->winId = $team->id;
			$team->addWin($this->group->id);
			$this->results[$team->id] += ['points' => $this->group->winPoints, 'type' => 'win'];
		}
		else {
			$this->lossId = $team->id;
			$team->addLoss($this->group->id);
			$this->results[$team->id] += ['points' => $this->group->lostPoints, 'type' => 'loss'];
		}
		return $this;
	}
	private function setResults3($i, $team) {
		switch ($i) {
			case 1:
				$this->winId = $team->id;
				$team->addWin($this->group->id);
				$this->results[$team->id] += ['points' => $this->group->winPoints, 'type' => 'win'];
				break;
			case 2:
				$this->secondId = $team->id;
				$team->addSecond($this->group->id);
				$this->results[$team->id] += ['points' => $this->group->secondPoints, 'type' => 'second'];
				break;
			case 3:
				$this->lossId = $team->id;
				$team->addLoss($this->group->id);
				$this->results[$team->id] += ['points' => $this->group->lostPoints, 'type' => 'loss'];
				break;
		}
		return $this;
	}
	private function setResults4($i, $team) {
		switch ($i) {
			case 1:
				$this->winId = $team->id;
				$team->addWin($this->group->id);
				$this->results[$team->id] += ['points' => $this->group->winPoints, 'type' => 'win'];
				break;
			case 2:
				$this->secondId = $team->id;
				$team->addSecond($this->group->id);
				$this->results[$team->id] += ['points' => $this->group->secondPoints, 'type' => 'second'];
				break;
			case 3:
				$this->thirdId = $team->id;
				$team->addThird($this->group->id);
				$this->results[$team->id] += ['points' => $this->group->thirdPoints, 'type' => 'third'];
				break;
			case 4:
				$this->lossId = $team->id;
				$team->addLoss($this->group->id);
				$this->results[$team->id] += ['points' => $this->group->lostPoints, 'type' => 'loss'];
				break;
		}
		return $this;
	}

	public function resetResults() {
		foreach ($this->results as $teamId => $score) {
			$team = $this->getTeam($teamId);
			$team->groupResults[$this->group->id]['score'] -= $score['score'];
			$team->sumScore -= $score['score'];
			switch ($score['type']) {
				case 'win':
					$team->removeWin($this->group->id);
					break;
				case 'draw':
					$team->removeDraw($this->group->id);
					break;
				case 'loss':
					$team->removeLoss($this->group->id);
					break;
				case 'second':
					$team->removeSecond($this->group->id);
					break;
				case 'third':
					$team->removeThird($this->group->id);
					break;
			}
		}
		$this->results = [];
		return $this;
	}
	public function getWin() {
		return $this->winId;
	}
	public function getLoss() {
		return $this->lossId;
	}
	public function getSecond() {
		return $this->secondId;
	}
	public function getThird() {
		return $this->thirdId;
	}
	public function getDraw() {
		return $this->drawIds;
	}

	public function isPlayed() {
		if (count($this->results) > 0) return true;
		return false;
	}
}


1			<?php
2
3			namespace TournamentGenerator;
4
5			/**
6			*
7			*/
8			class Game
9			{
10
11			private $teams = [];
12			private $results = [];
13			private $group = null;
14			private $winId = null;
15			private $lossId = null;
16			private $secondId = null;
17			private $thirdId = null;
18			private $drawIds = [];
19
20			function __construct(array $teams, Group $group) {
21			$this->group = $group;
22			$error = [];
23			$tids = [];
24			foreach ($teams as $key => $team) {
25			if (!$team instanceof Team) {
26			$error[] = $team;
27			unset($teams[$key]);
28			continue;
29			}
30			$team->addGame($this);
31			$tids[] = $team->id;
32			}
33			$this->teams = $teams;
34			foreach ($this->teams as $team) {
35			foreach ($this->teams as $team2) {
36			if ($team === $team2) continue;
37			$team->addGameWith($team2, $group);
38			}
39			}
40			if (count($error) > 0) throw new \Exception('Trying to add teams ('.count($error).') that are not instance of Team class'.PHP_EOL.print_r($error, true));
41			}
42
43			public function getGroup() {
44			return $this->group;
45			}
46
47			public function addTeam(...$teams) {
48			$error = [];
49			foreach ($teams as $key => $team) {
50			if (!$team instanceof Team) {
51			$error[] = $team;
52			unset($teams[$key]);
53			continue;
54			}
55			$this->teams[] = $team;
56			$team->addGame($this);
57
58			foreach ($this->teams as $team2) {
59			if ($team === $team2) continue;
60			if ($team instanceof Team) {
61			$team->addGameWith($team2, $this->group);
62			$team2->addGameWith($team, $this->group);
63			}
64			}
65			}
66			if (count($error) > 0) throw new \Exception('Trying to add teams ('.count($error).') that are not instance of Team class'.PHP_EOL.print_r($error, true));
67			return $this;
68			}
69			public function getTeams(){
70			return $this->teams;
71			}
72			public function getTeamsIds(){
73			return array_map(function($a){ return $a->id; }, $this->teams);
74			}
75			public function getTeam(string $id) {
76			foreach ($this->teams as $team) {
77			if ($team->id === $id) return $team;
78			}
79			return false;
80			}
81
82			/**
83			* $results = array (
84			* * team->id => team->score
85			* )
86			*/
87			public function setResults(array $results = []) {
88			if (count($this->results) === 0) $this->resetResults();
89			arsort($results);
90			$inGame = /** @scrutinizer ignore-call */ $this->group->getInGame();
91			$i = 1;
92			foreach ($results as $id => $score) {
93			$team = $this->getTeam($id);
94			if ($team === false) throw new \Exception('Couldn\'t find team with id of "'.$id.'"');
95			$this->results[$team->id] = ['score' => $score];
96			$team->sumScore += $score;
97			$prev = prev($results);
98			next($results);
99			$next = next($results);
100			switch ($inGame) {
101			case 2:
102			$this->setResults2($score, $prev, $next, $team);
103			break;
104			case 3:
105			$this->setResults3($i, $team);
106			break;
107			case 4:
108			$this->setResults4($i, $team);
109			break;
110			}
111			$team->groupResults[$this->group->id]['score'] += $score;
112			$i++;
113			}
114			return $this;
115			}
116			private function setResults2($score, $prev, $next, $team) {
117			if ($score === $prev \|\| $score === $next) {
118			$this->drawIds[] = $team->id;
119			$team->addDraw($this->group->id);
120			$this->results[$team->id] += ['points' => $this->group->drawPoints, 'type' => 'draw'];
121			}
122			elseif ($i === 1) {
			0 ignored issues – show Comprehensibility Best Practice introduced 2019-07-27 17:31 UTC by Report Bug Copy Issue Report The variable `$i` seems to be never defined. Loading history...
123			$this->winId = $team->id;
124			$team->addWin($this->group->id);
125			$this->results[$team->id] += ['points' => $this->group->winPoints, 'type' => 'win'];
126			}
127			else {
128			$this->lossId = $team->id;
129			$team->addLoss($this->group->id);
130			$this->results[$team->id] += ['points' => $this->group->lostPoints, 'type' => 'loss'];
131			}
132			return $this;
133			}
134			private function setResults3($i, $team) {
135			switch ($i) {
136			case 1:
137			$this->winId = $team->id;
138			$team->addWin($this->group->id);
139			$this->results[$team->id] += ['points' => $this->group->winPoints, 'type' => 'win'];
140			break;
141			case 2:
142			$this->secondId = $team->id;
143			$team->addSecond($this->group->id);
144			$this->results[$team->id] += ['points' => $this->group->secondPoints, 'type' => 'second'];
145			break;
146			case 3:
147			$this->lossId = $team->id;
148			$team->addLoss($this->group->id);
149			$this->results[$team->id] += ['points' => $this->group->lostPoints, 'type' => 'loss'];
150			break;
151			}
152			return $this;
153			}
154			private function setResults4($i, $team) {
155			switch ($i) {
156			case 1:
157			$this->winId = $team->id;
158			$team->addWin($this->group->id);
159			$this->results[$team->id] += ['points' => $this->group->winPoints, 'type' => 'win'];
160			break;
161			case 2:
162			$this->secondId = $team->id;
163			$team->addSecond($this->group->id);
164			$this->results[$team->id] += ['points' => $this->group->secondPoints, 'type' => 'second'];
165			break;
166			case 3:
167			$this->thirdId = $team->id;
168			$team->addThird($this->group->id);
169			$this->results[$team->id] += ['points' => $this->group->thirdPoints, 'type' => 'third'];
170			break;
171			case 4:
172			$this->lossId = $team->id;
173			$team->addLoss($this->group->id);
174			$this->results[$team->id] += ['points' => $this->group->lostPoints, 'type' => 'loss'];
175			break;
176			}
177			return $this;
178			}
179
180			public function resetResults() {
181			foreach ($this->results as $teamId => $score) {
182			$team = $this->getTeam($teamId);
183			$team->groupResults[$this->group->id]['score'] -= $score['score'];
184			$team->sumScore -= $score['score'];
185			switch ($score['type']) {
186			case 'win':
187			$team->removeWin($this->group->id);
188			break;
189			case 'draw':
190			$team->removeDraw($this->group->id);
191			break;
192			case 'loss':
193			$team->removeLoss($this->group->id);
194			break;
195			case 'second':
196			$team->removeSecond($this->group->id);
197			break;
198			case 'third':
199			$team->removeThird($this->group->id);
200			break;
201			}
202			}
203			$this->results = [];
204			return $this;
205			}
206			public function getWin() {
207			return $this->winId;
208			}
209			public function getLoss() {
210			return $this->lossId;
211			}
212			public function getSecond() {
213			return $this->secondId;
214			}
215			public function getThird() {
216			return $this->thirdId;
217			}
218			public function getDraw() {
219			return $this->drawIds;
220			}
221
222			public function isPlayed() {
223			if (count($this->results) > 0) return true;
224			return false;
225			}
226			}
227

Heroyt / tournament-generator

Branch — master (0e4a87)

Game::setResults() B

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like