CommanderManager - Code Metrics - Inspection of "Merge pull request #164 from rtfmcorp/dev" - rtfmcorp/asylamba-game - Measure and Improve Code Quality continuously with Scrutinizer

Completed
Push — master ( 710d07...9f3829 )

by Jacky
created 2017-08-09 22:05 UTC
CommanderManager F

↳ Parent: Project
Complexity

Total Complexity
134
Size/Duplication

Total Lines	1033
Duplicated Lines	0 %
Coupling/Cohesion

Components	1
Dependencies	25
Importance

Changes
Metric	Value
dl	0
loc	1033
rs	0.8713
c	0
b	0
f	0
wmc	134
lcom	1
cbo	25
36 Methods

Rating	Name	Size	Complexity
B	__construct()	27	1
A	get()	4	1
A	getBaseCommanders()	4	1
A	getPlayerCommanders()	4	1
A	getMovingCommanders()	4	1
A	getCommandersByIds()	4	1
A	getCommandersByLine()	4	1
A	getIncomingAttacks()	4	1
A	getVisibleIncomingAttacks()	18	3
A	getOutcomingAttacks()	4	1
A	getIncomingCommanders()	4	1
A	scheduleMovements()	16	2
A	countCommandersByLine()	4	1
B	setEarnedExperience()	29	6
A	setBonus()	11	3
A	upExperience()	13	2
A	nbLevelUp()	12	3
A	experienceToLevelUp()	3	1
A	emptySquadrons()	12	4
B	uExperienceInSchool()	37	6
B	move()	25	4
A	resultOfFight()	22	2
B	engage()	15	5
A	getPosition()	13	2
A	getEventInfo()	19	1
D	uChangeBase()	81	13
D	uLoot()	134	21
D	uConquer()	207	29
A	uReturnBase()	15	2
A	endTravel()	10	1
A	comeBack()	6	1
A	lootAnEmptyPlace()	14	2
A	lootAPlayerPlace()	18	3
A	startFight()	13	2
B	createReport()	36	2
B	createVirtualCommander()	34	3
How to fix Complexity

<?php

/**
 * Commander Manager
 *
 * @author Noé Zufferey
 * @copyright Expansion - le jeu
 *
 * @package Arès
 * @update 20.05.13
*/
// !! lors d'un load, mettre c. avant les attribut where

namespace Asylamba\Modules\Ares\Manager;

use Asylamba\Classes\Entity\EntityManager;
use Asylamba\Classes\Library\Utils;
use Asylamba\Classes\Library\Game;
use Asylamba\Modules\Athena\Manager\OrbitalBaseManager;
use Asylamba\Modules\Zeus\Manager\PlayerManager;
use Asylamba\Modules\Zeus\Manager\PlayerBonusManager;
use Asylamba\Modules\Gaia\Manager\PlaceManager;
use Asylamba\Modules\Demeter\Manager\ColorManager;
use Asylamba\Modules\Hermes\Manager\NotificationManager;
use Asylamba\Classes\Container\ArrayList;

use Asylamba\Classes\Worker\EventDispatcher;

use Asylamba\Modules\Athena\Model\OrbitalBase;
use Asylamba\Modules\Gaia\Model\Place;
use Asylamba\Modules\Ares\Model\Report;
use Asylamba\Modules\Ares\Model\LiveReport;
use Asylamba\Modules\Zeus\Model\PlayerBonus;
use Asylamba\Modules\Ares\Model\Commander;
use Asylamba\Modules\Gaia\Resource\SquadronResource;
use Asylamba\Modules\Demeter\Model\Color;

use Asylamba\Classes\Scheduler\RealTimeActionScheduler;

use Asylamba\Modules\Gaia\Event\PlaceOwnerChangeEvent;

class CommanderManager
{
	/** @var EntityManager **/
	protected $entityManager;
	/** @var FightManager **/
	protected $fightManager;
	/** @var ReportManager **/
	protected $reportManager;
	/** @var OrbitalBaseManager **/
	protected $orbitalBaseManager;
	/** @var PlayerManager **/
	protected $playerManager;
	/** @var PlayerBonusManager **/
	protected $playerBonusManager;
	/** @var PlaceManager **/
	protected $placeManager;
	/** @var ColorManager **/
	protected $colorManager;
	/** @var NotificationManager **/
	protected $notificationManager;
	/** @var RealTimeActionScheduler **/
	protected $realtimeActionScheduler;
	/** @var EventDispatcher **/
	protected $eventDispatcher;
	/** @var int **/
	protected $commanderBaseLevel;
	
	protected $actions = [
		Commander::MOVE => 'uChangeBase',
		Commander::LOOT => 'uLoot',
		Commander::COLO => 'uConquer',
		Commander::BACK => 'uReturnBase'
	];

	/**
	 * @param EntityManager $entityManager
	 * @param FightManager $fightManager
	 * @param ReportManager $reportManager
	 * @param OrbitalBaseManager $orbitalBaseManager
	 * @param PlayerManager $playerManager
	 * @param PlayerBonusManager $playerBonusManager
	 * @param PlaceManager $placeManager
	 * @param ColorManager $colorManager
	 * @param NotificationManager $notificationManager
	 * @param RealTimeActionScheduler $realtimeActionScheduler
	 * @param EventDispatcher $eventDispatcher
	 * @param int $commanderBaseLevel
	 */
	public function __construct(
		EntityManager $entityManager,
		FightManager $fightManager,
		ReportManager $reportManager,
		OrbitalBaseManager $orbitalBaseManager,
		PlayerManager $playerManager,
		PlayerBonusManager $playerBonusManager,
		PlaceManager $placeManager,
		ColorManager $colorManager,
		NotificationManager $notificationManager,
		RealTimeActionScheduler $realtimeActionScheduler,
		EventDispatcher $eventDispatcher,
		$commanderBaseLevel
	) {
		$this->entityManager = $entityManager;
		$this->fightManager = $fightManager;
		$this->reportManager = $reportManager;
		$this->orbitalBaseManager = $orbitalBaseManager;
		$this->playerManager = $playerManager;
		$this->playerBonusManager = $playerBonusManager;
		$this->placeManager = $placeManager;
		$this->colorManager = $colorManager;
		$this->notificationManager = $notificationManager;
		$this->realtimeActionScheduler = $realtimeActionScheduler;
		$this->eventDispatcher = $eventDispatcher;
		$this->commanderBaseLevel = $commanderBaseLevel;
	}
	
	/**
	 * @param integer $id
	 * @return Commander
	 */
	public function get($id)
	{
		return $this->entityManager->getRepository(Commander::class)->get($id);
abstract class User
{
    /** @return string */
    abstract public function getPassword();
}

class MyUser extends User
{
    public function getPassword()
    {
        // return something
    }

    public function getDisplayName()
    {
        // return some name.
    }
}

class AuthSystem
{
    public function authenticate(User $user)
    {
        $this->logger->info(sprintf('Authenticating %s.', $user->getDisplayName()));
        // do something.
    }
}
	}
	
	/**
	 * @param integer $orbitalBaseId
	 * @param array $statements
	 * @return array
	 */
	public function getBaseCommanders($orbitalBaseId, $statements = [], $orderBy = [])
	{
		return $this->entityManager->getRepository(Commander::class)->getBaseCommanders($orbitalBaseId, $statements, $orderBy);
abstract class User
{
    /** @return string */
    abstract public function getPassword();
}

class MyUser extends User
{
    public function getPassword()
    {
        // return something
    }

    public function getDisplayName()
    {
        // return some name.
    }
}

class AuthSystem
{
    public function authenticate(User $user)
    {
        $this->logger->info(sprintf('Authenticating %s.', $user->getDisplayName()));
        // do something.
    }
}
	}
	
	/**
	 * @param int $playerId
	 * @param array $statements
	 * @return array
	 */
	public function getPlayerCommanders($playerId, $statements = [], $orderBy = [])
	{
		return $this->entityManager->getRepository(Commander::class)->getPlayerCommanders($playerId, $statements, $orderBy);
abstract class User
{
    /** @return string */
    abstract public function getPassword();
}

class MyUser extends User
{
    public function getPassword()
    {
        // return something
    }

    public function getDisplayName()
    {
        // return some name.
    }
}

class AuthSystem
{
    public function authenticate(User $user)
    {
        $this->logger->info(sprintf('Authenticating %s.', $user->getDisplayName()));
        // do something.
    }
}
	}
	
	/**
	 * @return array
	 */
	public function getMovingCommanders()
	{
		return $this->entityManager->getRepository(Commander::class)->getMovingCommanders();
abstract class User
{
    /** @return string */
    abstract public function getPassword();
}

class MyUser extends User
{
    public function getPassword()
    {
        // return something
    }

    public function getDisplayName()
    {
        // return some name.
    }
}

class AuthSystem
{
    public function authenticate(User $user)
    {
        $this->logger->info(sprintf('Authenticating %s.', $user->getDisplayName()));
        // do something.
    }
}
	}
	
	/**
	 * @param array $ids
	 * @return array
	 */
	public function getCommandersByIds($ids)
	{
		return $this->entityManager->getRepository(Commander::class)->getCommandersByIds($ids);
abstract class User
{
    /** @return string */
    abstract public function getPassword();
}

class MyUser extends User
{
    public function getPassword()
    {
        // return something
    }

    public function getDisplayName()
    {
        // return some name.
    }
}

class AuthSystem
{
    public function authenticate(User $user)
    {
        $this->logger->info(sprintf('Authenticating %s.', $user->getDisplayName()));
        // do something.
    }
}
	}
	
	/**
	 * @param int $orbitalBaseId
	 * @param int $line
	 * @return array
	 */
	public function getCommandersByLine($orbitalBaseId, $line)
	{
		return $this->entityManager->getRepository(Commander::class)->getCommandersByLine($orbitalBaseId, $line);
abstract class User
{
    /** @return string */
    abstract public function getPassword();
}

class MyUser extends User
{
    public function getPassword()
    {
        // return something
    }

    public function getDisplayName()
    {
        // return some name.
    }
}

class AuthSystem
{
    public function authenticate(User $user)
    {
        $this->logger->info(sprintf('Authenticating %s.', $user->getDisplayName()));
        // do something.
    }
}
	}
	
	/**
	 * @param int $playerId
	 * @return array
	 */
	public function getIncomingAttacks($playerId)
	{
		return $this->entityManager->getRepository(Commander::class)->getIncomingAttacks($playerId);
abstract class User
{
    /** @return string */
    abstract public function getPassword();
}

class MyUser extends User
{
    public function getPassword()
    {
        // return something
    }

    public function getDisplayName()
    {
        // return some name.
    }
}

class AuthSystem
{
    public function authenticate(User $user)
    {
        $this->logger->info(sprintf('Authenticating %s.', $user->getDisplayName()));
        // do something.
    }
}
	}
	
	/**
	 * @param int $playerId
	 * @return array
	 */
	public function getVisibleIncomingAttacks($playerId)
	{
		$attackingCommanders = $this->getIncomingAttacks($playerId) ;
		$incomingCommanders = [] ;
		
		foreach ($attackingCommanders as $commander) { 
			# va chercher les heures auxquelles il rentre dans les cercles d'espionnage
			$startPlace = $this->placeManager->get($commander->getRBase());
			$destinationPlace = $this->placeManager->get($commander->getRPlaceDestination());
			$times = Game::getAntiSpyEntryTime($startPlace, $destinationPlace, $commander->getArrivalDate());

			if (strtotime(Utils::now()) >= strtotime($times[0])) {
				# ajout de l'événement
				$incomingCommanders[] = $commander;
			}
		}		
		return $incomingCommanders;
	}
	
	/**
	 * @param int $playerId
	 * @return array
	 */
	public function getOutcomingAttacks($playerId)
	{
		return $this->entityManager->getRepository(Commander::class)->getOutcomingAttacks($playerId);
abstract class User
{
    /** @return string */
    abstract public function getPassword();
}

class MyUser extends User
{
    public function getPassword()
    {
        // return something
    }

    public function getDisplayName()
    {
        // return some name.
    }
}

class AuthSystem
{
    public function authenticate(User $user)
    {
        $this->logger->info(sprintf('Authenticating %s.', $user->getDisplayName()));
        // do something.
    }
}
	}
	
	/**
	 * @param array $place
	 * @return array
	 */
	public function getIncomingCommanders($place)
	{
		return $this->entityManager->getRepository(Commander::class)->getIncomingCommanders($place);
abstract class User
{
    /** @return string */
    abstract public function getPassword();
}

class MyUser extends User
{
    public function getPassword()
    {
        // return something
    }

    public function getDisplayName()
    {
        // return some name.
    }
}

class AuthSystem
{
    public function authenticate(User $user)
    {
        $this->logger->info(sprintf('Authenticating %s.', $user->getDisplayName()));
        // do something.
    }
}
	}
	
	public function scheduleMovements()
	{
		$commanders = $this->getMovingCommanders();
		foreach ($commanders as $commander) {
			$this->realtimeActionScheduler->schedule(
				'ares.commander_manager',
				$this->actions[$commander->getTravelType()],
				$commander,
				$commander->dArrival,
				[
					'class' => Place::class,
					'id' => $commander->getRPlaceDestination()
				]
			);
		}
	}
	
	/**
	 * @param int $orbitalBaseId
	 * @param int $line
	 * @return int
	 */
	public function countCommandersByLine($orbitalBaseId, $line)
	{
		return $this->entityManager->getRepository(Commander::class)->countCommandersByLine($orbitalBaseId, $line);
abstract class User
{
    /** @return string */
    abstract public function getPassword();
}

class MyUser extends User
{
    public function getPassword()
    {
        // return something
    }

    public function getDisplayName()
    {
        // return some name.
    }
}

class AuthSystem
{
    public function authenticate(User $user)
    {
        $this->logger->info(sprintf('Authenticating %s.', $user->getDisplayName()));
        // do something.
    }
}
	}

	public function setEarnedExperience(Commander $commander, Commander $enemyCommander) {
		$commander->setArmy();
		$finalOwnPev = 0;

		foreach ($commander->army as $squadron) {
			foreach ($squadron->getSquadron() as $ship) {
				$finalOwnPev += $ship->getPev();
			}
		}
		$importance = (($finalOwnPev + 1) * ($enemyCommander->getPevInBegin())) / 
			((($commander->pevInBegin + 1) * (($enemyCommander->getLevel() + 1) / 
				($commander->level + 1))));

		$commander->earnedExperience = $importance * Commander::COEFFEARNEDEXP;
class Id
{
    public $id;

    public function __construct($id)
    {
        $this->id = $id;
    }

}

class Account
{
    /** @var  Id $id */
    public $id;
}

$account_id = false;

if (starsAreRight()) {
    $account_id = new Id(42);
}

$account = new Account();
if ($account instanceof Id)
{
    $account->id = $account_id;
}
		if($commander->winner) {

			LiveReport::$importance = $importance;
class Id
{
    public $id;

    public function __construct($id)
    {
        $this->id = $id;
    }

}

class Account
{
    /** @var  Id $id */
    public $id;
}

$account_id = false;

if (starsAreRight()) {
    $account_id = new Id(42);
}

$account = new Account();
if ($account instanceof Id)
{
    $account->id = $account_id;
}
		}
		
		if ($commander->rPlayer > 0) {
			$exp = round($commander->earnedExperience / Commander::COEFFEXPPLAYER);
			$this->playerManager->increaseExperience($this->playerManager->get($commander->rPlayer), $exp);

			if ($enemyCommander->isAttacker == TRUE) {
				LiveReport::$expPlayerD = $exp;
$answer = 42;

$correct = false;

$correct = (bool) $answer;
			} else {
				LiveReport::$expPlayerA = $exp;
$answer = 42;

$correct = false;

$correct = (bool) $answer;
			}
		}
	}

	public function setBonus(Commander $commander) {
		$commander->setArmy();
		$playerBonus = new PlayerBonus($commander->rPlayer);

		$playerBonus->load();


		foreach ($commander->army as $squadron) {
			foreach ($squadron->squadron as $ship) {
				$ship->setBonus($playerBonus->bonus);
			}
		}
	}

	public function upExperience(Commander $commander, $earnedExperience) {
		$commander->experience += $earnedExperience;
		$initialLevel = $commander->getLevel();
		
		while ($commander->experience >= $this->experienceToLevelUp($commander)) {
			$commander->setLevel($commander->getLevel() + 1);
		}
		$this->entityManager->getRepository(Commander::class)->updateExperience(

			$commander,
			$earnedExperience,
			$commander->getLevel() - $initialLevel
		);
	}

	public function nbLevelUp($level, $newExperience) {
		$oLevel = $level;
		$nLevel = $level;
		while (1) {
			if ($newExperience >= (pow(2, $nLevel) * $this->commanderBaseLevel)) {
				$nLevel++;
			} else {
				break;
			}
		}
		return $nLevel - $oLevel;
	}

	public function experienceToLevelUp(Commander $commander) {
		return pow(2, $commander->level) * $this->commanderBaseLevel;
	}

	public function emptySquadrons(Commander $commander) {
		if (($orbitalBase = $this->orbitalBaseManager->get($commander->rBase)) === null) {
			return;
		}
		$nbSquadrons = count($commander->squadronsIds);
		for ($i = 0; $i < $nbSquadrons; ++$i) {
			for ($j = 0; $j < 12; $j++) {
				$orbitalBase->setShipStorage($j, $orbitalBase->getShipStorage($j) + $commander->getSquadron($i)->getNbrShipByType($j));
			}
			$commander->getSquadron($i)->emptySquadron();
		}
	}

	public function uExperienceInSchool()
	{
		$now = Utils::now();
		$commanders = $this->entityManager->getRepository(Commander::class)->getAllByStatements([Commander::INSCHOOL]);
abstract class User
{
    /** @return string */
    abstract public function getPassword();
}

class MyUser extends User
{
    public function getPassword()
    {
        // return something
    }

    public function getDisplayName()
    {
        // return some name.
    }
}

class AuthSystem
{
    public function authenticate(User $user)
    {
        $this->logger->info(sprintf('Authenticating %s.', $user->getDisplayName()));
        // do something.
    }
}
		$this->entityManager->beginTransaction();
		
		foreach ($commanders as $commander) {
			// If the commander was updated recently, we skip him
			if (Utils::interval($commander->uCommander, $now, 'h') === 0) {
				continue;
			}
			
			$nbrHours = Utils::intervalDates($now, $commander->uCommander);
			$commander->uCommander = $now;
			$orbitalBase = $this->orbitalBaseManager->get($commander->rBase);
			
			$playerBonus = $this->playerBonusManager->getBonusByPlayer($this->playerManager->get($commander->rPlayer));
			$this->playerBonusManager->load($playerBonus);
			$playerBonus = $playerBonus->bonus;
			foreach ($nbrHours as $hour) {
				$invest  = $orbitalBase->iSchool;
				$invest += $invest * $playerBonus->get(PlayerBonus::COMMANDER_INVEST) / 100;

				# xp gagnée
				$earnedExperience  = $invest / Commander::COEFFSCHOOL;
				$earnedExperience += (rand(0, 1) == 1) 
					? rand(0, $earnedExperience / 20)
					: -(rand(0, $earnedExperience / 20));
				$earnedExperience  = round($earnedExperience);
				$earnedExperience  = ($earnedExperience < 0)
					? 0 : $earnedExperience;

				$this->upExperience($commander, $earnedExperience);
			}
		}
		$this->entityManager->commit();
	}

	public function move(Commander $commander, $rDestinationPlace, $rStartPlace, $travelType, $travelLength, $duration) {
		$commander->rDestinationPlace = $rDestinationPlace;
		$commander->rStartPlace = $rStartPlace;
		$commander->travelType = $travelType;
		$commander->travelLength = $travelLength;
		$commander->statement = Commander::MOVING;

		$commander->dStart = ($travelType != 3) ? Utils::now() : $commander->dArrival;
		$commander->destinationPlaceName = ($travelType != 3) ? $commander->destinationPlaceName : $commander->startPlaceName;
		$commander->startPlaceName = ($travelType != 3) ? $commander->oBName : $commander->destinationPlaceName;
		$date = new \DateTime($commander->dStart);
		$date->modify('+' . $duration . 'second');
		$commander->dArrival = $date->format('Y-m-d H:i:s');
		
		$this->realtimeActionScheduler->schedule(
			'ares.commander_manager',
			$this->actions[$travelType],
			$commander,
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
			$commander->dArrival,
			[
				'class' => Place::class,
				'id' => $commander->getRPlaceDestination()
			]
		);
	}
	
	public function resultOfFight(Commander $commander, $isWinner, $enemyCommander) {
		if ($isWinner == TRUE) {
			$this->setEarnedExperience($commander, $enemyCommander);
			$commander->earnedExperience = round($commander->earnedExperience);
$answer = 42;

$correct = false;

$correct = (bool) $answer;
			LiveReport::$expCom = $commander->earnedExperience;
$answer = 42;

$correct = false;

$correct = (bool) $answer;

			$commander->winner = TRUE;
			$commander->palmares++;
			$commander->setArmyAtEnd();
			$this->upExperience($commander, $commander->earnedExperience);
			$commander->hasChanged = TRUE;

		} else {
			/** @TOVERIFY **/
			$this->setEarnedExperience($commander, $commander, $enemyCommander);

			$commander->earnedExperience = round($commander->earnedExperience);

			$commander->winner = FALSE;
			$commander->setArmyAtEnd();
			$this->upExperience($commander, $commander->earnedExperience);
			$commander->hasChanged = TRUE;
		}
	}

	# ENGAGE UN COMBAT ENTRE CHAQUE SQUADRON CONTRE UN COMMANDANT
	public function engage(Commander $commander, $enemyCommander) {
		$commander->setArmy();
		
		for ($i = 0; $i < count($commander->squadronsIds); $i++) {
for ($i=0; $i<count($array); $i++) { // calls count() on each iteration
}

// Better
for ($i=0, $c=count($array); $i<$c; $i++) { // calls count() just once
}
			$commander->getSquadron($i)->relId = 0;
		}
		$idSquadron = 0;
		foreach ($commander->army as $squadron) {
			if ($squadron->getNbrShips() != 0 AND $squadron->getLineCoord() * 3 <= FightManager::getCurrentLine()) {

				$enemyCommander = $squadron->engage($enemyCommander, $idSquadron, $commander->id, $commander->name, $commander);
			}
			$idSquadron++;
		}
		return $enemyCommander;
	}

	public function getPosition(Commander $commander, $x1, $y1, $x2, $y2) {
		$x = $x1;
		$y = $y1;
		if ($commander->statement == Commander::MOVING) {
			$parcouredTime = Utils::interval($commander->dStart, Utils::now(), 's');
			$totalTime = Utils::interval($commander->dStart, $commander->dArrival, 's');
			$progression = $parcouredTime / $totalTime;

			$x = $x1 + $progression * ($x2-$x1);
			$y = $y1 + $progression * ($y2-$y1);
		}
		return array($x, $y);
	}

	public function getEventInfo(Commander $commander) {
		$info = new ArrayList();
		$info->add('id', $commander->id);
		$info->add('name', $commander->name);
		$info->add('avatar', $commander->avatar);
		$info->add('level', $commander->level);

		$info->add('dStart', $commander->dStart);
		$info->add('rStart', $commander->rStartPlace);
		$info->add('nStart', $commander->startPlaceName);
		$info->add('dArrival', $commander->dArrival);
		$info->add('rArrival', $commander->rDestinationPlace);
		$info->add('nArrival', $commander->destinationPlaceName);

		$info->add('travelType', $commander->travelType);
		$info->add('resources', $commander->resources);

		return $info;
	}

	/**
	 * Fleet moving
	 * 
	 * @param int $commanderId
	 */
	public function uChangeBase($commanderId) {
		$commander = $this->get($commanderId);
		$place = $this->placeManager->get($commander->rDestinationPlace);
		$place->commanders = $this->getBaseCommanders($place->id);
		$commanderPlace = $this->placeManager->get($commander->rBase);
		$player = $this->playerManager->get($commander->rPlayer);
		$playerBonus = $this->playerBonusManager->getBonusByPlayer($player);
		$this->playerBonusManager->load($playerBonus);
		# si la place et la flotte ont la même couleur
		# on pose la flotte si il y a assez de place
		# sinon on met la flotte dans les hangars
		if ($place->playerColor !== $commander->playerColor or $place->typeOfBase !== Place::TYP_ORBITALBASE) {
			# retour forcé
			$this->comeBack($place, $commander, $commanderPlace, $playerBonus);
			$this->placeManager->sendNotif($place, Place::CHANGELOST, $commander);
			$this->entityManager->flush();
			return;
		}
		$maxCom =
			($place->typeOfOrbitalBase == OrbitalBase::TYP_MILITARY || $place->typeOfOrbitalBase == OrbitalBase::TYP_CAPITAL)
			? OrbitalBase::MAXCOMMANDERMILITARY
			: OrbitalBase::MAXCOMMANDERSTANDARD
		;

		# si place a assez de case libre :
		if (count($place->commanders) < $maxCom) {
			$comLine2 = 0;

			foreach ($place->commanders as $com) {
				if ($com->line == 2) {
					$comLine2++;
				}
			}

			if ($maxCom == OrbitalBase::MAXCOMMANDERMILITARY) {
				if ($comLine2 < 2) {
					$commander->line = 2;
				} else {
					$commander->line = 1;
				}
			} else {
				if ($comLine2 < 1) {
					$commander->line = 2;
				} else {
					$commander->line = 1;
				}
			}

			# changer rBase commander
			$commander->rBase = $place->id;
			$this->endTravel($commander, Commander::AFFECTED);

			# ajouter à la place le commandant
			$place->commanders[] = $commander;

			# envoi de notif
			$this->placeManager->sendNotif($place, Place::CHANGESUCCESS, $commander);
		} else {
			# changer rBase commander
			$commander->rBase = $place->id;
			$this->endTravel($commander, Commander::RESERVE);

			$this->emptySquadrons($commander);

			# envoi de notif
			$this->placeManager->sendNotif($place, Place::CHANGEFAIL, $commander);
		}

		# modifier le rPlayer (ne se modifie pas si c'est le même)
		$commander->rPlayer = $place->rPlayer;

		# instance de la place d'envoie + suppr commandant de ses flottes
		# enlever à rBase le commandant
		for ($i = 0; $i < count($commanderPlace->commanders); $i++) {
for ($i=0; $i<count($array); $i++) { // calls count() on each iteration
}

// Better
for ($i=0, $c=count($array); $i<$c; $i++) { // calls count() just once
}
			if ($commanderPlace->commanders[$i]->id == $commander->id) {
				unset($commanderPlace->commanders[$i]);
				$commanderPlace->commanders = array_merge($commanderPlace->commanders);
			}
		}
		$this->entityManager->flush();
	}

	# pillage
	public function uLoot($commanderId) {
		$commander = $this->get($commanderId);
		$place = $this->placeManager->get($commander->rDestinationPlace);
		$place->commanders = $this->getBaseCommanders($place->id);
		$placePlayer = $this->playerManager->get($place->rPlayer);
		$placeBase = $this->orbitalBaseManager->get($place->id);
		$commanderPlace = $this->placeManager->get($commander->rBase);
		$commanderPlayer = $this->playerManager->get($commander->rPlayer);
		$commanderColor = $this->colorManager->get($commanderPlayer->rColor);
		$playerBonus = $this->playerBonusManager->getBonusByPlayer($commanderPlayer);
		$this->playerBonusManager->load($playerBonus);
		LiveReport::$type   = Commander::LOOT;
		LiveReport::$dFight = $commander->dArrival;

		# si la planète est vide
		if ($place->rPlayer == NULL) {
			LiveReport::$isLegal = Report::LEGAL;

			# planète vide : faire un combat
			$this->startFight($place, $commander, $commanderPlayer);

			# victoire
			if ($commander->getStatement() != Commander::DEAD) {
				# piller la planète
				$this->lootAnEmptyPlace($place, $commander, $playerBonus);
				# création du rapport de combat
				$report = $this->createReport($place);

				# réduction de la force de la planète
				$percentage = (($report->pevAtEndD + 1) / ($report->pevInBeginD + 1)) * 100;
				$place->danger = round(($percentage * $place->danger) / 100);
$answer = 42;

$correct = false;

$correct = (bool) $answer;

				$this->comeBack($place, $commander, $commanderPlace, $playerBonus);
				$this->placeManager->sendNotif($place, Place::LOOTEMPTYSSUCCESS, $commander, $report->id);
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
			} else {
				# si il est mort
				# enlever le commandant de la session
				for ($i = 0; $i < count($commanderPlace->commanders); $i++) {
for ($i=0; $i<count($array); $i++) { // calls count() on each iteration
}

// Better
for ($i=0, $c=count($array); $i<$c; $i++) { // calls count() just once
}
					if ($commanderPlace->commanders[$i]->getId() == $commander->getId()) {
						unset($commanderPlace->commanders[$i]);
						$commanderPlace->commanders = array_merge($commanderPlace->commanders);
					}
				}

				# création du rapport de combat
				$report = $this->createReport($place);
				$this->placeManager->sendNotif($place, Place::LOOTEMPTYFAIL, $commander, $report->id);
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);

				# réduction de la force de la planète
				$percentage = (($report->pevAtEndD + 1) / ($report->pevInBeginD + 1)) * 100;
				$place->danger = round(($percentage * $place->danger) / 100);
			}
		# si il y a une base d'un joueur
		} else {
			if ($commanderColor->colorLink[$place->playerColor] == Color::ALLY || $commanderColor->colorLink[$place->playerColor] == Color::PEACE) {
				LiveReport::$isLegal = Report::ILLEGAL;
			} else {
				LiveReport::$isLegal = Report::LEGAL;
			}

			# planète à joueur : si $this->rColor != commandant->rColor
			# si il peut l'attaquer
			if (($place->playerColor != $commander->getPlayerColor() && $place->playerLevel > 1 && $commanderColor->colorLink[$place->playerColor] != Color::ALLY) || ($place->playerColor == 0)) {
				$dCommanders = array();
				foreach ($place->commanders as $dCommander) {
					if ($dCommander->statement == Commander::AFFECTED && $dCommander->line == 1) {
						$dCommanders[] = $dCommander;
					}
				}

				# il y a des commandants en défense : faire un combat avec un des commandants
				if (count($dCommanders) != 0) {
					$aleaNbr = rand(0, count($dCommanders) - 1);
					$this->startFight($place, $commander, $commanderPlayer, $dCommanders[$aleaNbr], $placePlayer, TRUE);

					# victoire
					if ($commander->getStatement() != Commander::DEAD) {
						# piller la planète
						$this->lootAPlayerPlace($commander, $playerBonus, $placeBase);
						$this->comeBack($place, $commander, $commanderPlace, $playerBonus);
	
						# suppression des commandants						
						unset($place->commanders[$aleaNbr]);
						$place->commanders = array_merge($place->commanders);

						# création du rapport
						$report = $this->createReport($place);

						$this->placeManager->sendNotif($place, Place::LOOTPLAYERWHITBATTLESUCCESS, $commander, $report->id);
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
				
					# défaite
					} else {
						# enlever le commandant de la session
						for ($i = 0; $i < count($commanderPlace->commanders); $i++) {
for ($i=0; $i<count($array); $i++) { // calls count() on each iteration
}

// Better
for ($i=0, $c=count($array); $i<$c; $i++) { // calls count() just once
}
							if ($commanderPlace->commanders[$i]->getId() == $commander->getId()) {
								unset($commanderPlace->commanders[$i]);
								$commanderPlace->commanders = array_merge($commanderPlace->commanders);
							}
						}

						# création du rapport
						$report = $this->createReport($place);

						# mise à jour des flottes du commandant défenseur
						for ($j = 0; $j < count($dCommanders[$aleaNbr]->armyAtEnd); $j++) {
for ($i=0; $i<count($array); $i++) { // calls count() on each iteration
}

// Better
for ($i=0, $c=count($array); $i<$c; $i++) { // calls count() just once
}
							for ($i = 0; $i < 12; $i++) { 
								$dCommanders[$aleaNbr]->armyInBegin[$j][$i] = $dCommanders[$aleaNbr]->armyAtEnd[$j][$i];
							}
						}

						$this->placeManager->sendNotif($place, Place::LOOTPLAYERWHITBATTLEFAIL, $commander, $report->id);
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
					}
				} else {
					$this->lootAPlayerPlace($commander, $playerBonus, $placeBase);
					$this->comeBack($place, $commander, $commanderPlace, $playerBonus);
					$this->placeManager->sendNotif($place, Place::LOOTPLAYERWHITOUTBATTLESUCCESS, $commander);
				}


			} else {
				# si c'est la même couleur
				if ($place->rPlayer == $commander->rPlayer) {
					# si c'est une de nos planètes
					# on tente de se poser
					$this->uChangeBase($commander->id);
				} else {
					# si c'est une base alliée
					# on repart
					$this->comeBack($place, $commander, $commanderPlace, $playerBonus);
					$this->placeManager->sendNotif($place, Place::CHANGELOST, $commander);
				}
			}
		}
		$this->entityManager->flush();
	}

	# conquest
	public function uConquer($commanderId) {
		$commander = $this->get($commanderId);
		$place = $this->placeManager->get($commander->rDestinationPlace);
		$place->commanders = $this->getBaseCommanders($place->id);
		$placePlayer = $this->playerManager->get($place->rPlayer);
		$placeBase = $this->orbitalBaseManager->get($place->id);
		$commanderPlace = $this->placeManager->get($commander->rBase);
		$commanderPlayer = $this->playerManager->get($commander->rPlayer);
		$commanderColor = $this->colorManager->get($commanderPlayer->rColor);
		$baseCommanders = $this->getBaseCommanders($place->getId());
		$playerBonus = $this->playerBonusManager->getBonusByPlayer($commanderPlayer);
		$this->playerBonusManager->load($playerBonus);
		# conquete
		if ($place->rPlayer != NULL) {
			if (($place->playerColor != $commander->getPlayerColor() && $place->playerLevel > 3 && $commanderColor->colorLink[$place->playerColor] != Color::ALLY) || ($place->playerColor == 0)) {
				$tempCom = array();

				for ($i = 0; $i < count($place->commanders); $i++) {
for ($i=0; $i<count($array); $i++) { // calls count() on each iteration
}

// Better
for ($i=0, $c=count($array); $i<$c; $i++) { // calls count() just once
}
					if ($place->commanders[$i]->line <= 1) {
						$tempCom[] = $place->commanders[$i];
					}
				}
				for ($i = 0; $i < count($place->commanders); $i++) {
for ($i=0; $i<count($array); $i++) { // calls count() on each iteration
}

// Better
for ($i=0, $c=count($array); $i<$c; $i++) { // calls count() just once
}
					if ($place->commanders[$i]->line >= 2) {
						$tempCom[] = $place->commanders[$i];
					}
				}

				$place->commanders = $tempCom;

				$nbrBattle = 0;
				$reportIds   = array();
				$reportArray = array();

				while ($nbrBattle < count($place->commanders)) {
					if ($place->commanders[$nbrBattle]->statement == Commander::AFFECTED) {
						LiveReport::$type = Commander::COLO;
						LiveReport::$dFight = $commander->dArrival;

						if ($commanderColor->colorLink[$place->playerColor] == Color::ALLY || $commanderColor->colorLink[$place->playerColor] == Color::PEACE) {
							LiveReport::$isLegal = Report::ILLEGAL;
						} else {
							LiveReport::$isLegal = Report::LEGAL;
						}

						$this->startFight($place, $commander, $commanderPlayer, $place->commanders[$nbrBattle], $placePlayer, TRUE);

						$report = $this->createReport($place);
						$reportArray[] = $report;
						$reportIds[] = $report->id;
						# PATCH DEGUEU POUR LES MUTLIS-COMBATS
						$this->entityManager->clear($report);
						$reports = $this->reportManager->getByAttackerAndPlace($commander->rPlayer, $place->id, $commander->dArrival);
						foreach($reports as $r) {

							if ($r->id == $report->id) {
								continue;
							}
							$r->statementAttacker = Report::DELETED;
							$r->statementDefender = Report::DELETED;
						}
						$this->entityManager->flush(Report::class);
						$this->entityManager->clear(Report::class);
						########################################

						# mettre à jour armyInBegin si prochain combat pour prochain rapport
						for ($j = 0; $j < count($commander->armyAtEnd); $j++) {
for ($i=0; $i<count($array); $i++) { // calls count() on each iteration
}

// Better
for ($i=0, $c=count($array); $i<$c; $i++) { // calls count() just once
}
							for ($i = 0; $i < 12; $i++) { 
								$commander->armyInBegin[$j][$i] = $commander->armyAtEnd[$j][$i];
							}
						}
						for ($j = 0; $j < count($place->commanders[$nbrBattle]->armyAtEnd); $j++) {
for ($i=0; $i<count($array); $i++) { // calls count() on each iteration
}

// Better
for ($i=0, $c=count($array); $i<$c; $i++) { // calls count() just once
}
							for ($i = 0; $i < 12; $i++) {
								$place->commanders[$nbrBattle]->armyInBegin[$j][$i] = $place->commanders[$nbrBattle]->armyAtEnd[$j][$i];
							}
						}
						
						$nbrBattle++;
						# mort du commandant
						# arrêt des combats
						if ($commander->getStatement() == Commander::DEAD) {
							break;
						}
					} else {
						$nbrBattle++;
					}
				}

				# victoire
				if ($commander->getStatement() != Commander::DEAD) {
					if ($nbrBattle == 0) {
						$this->placeManager->sendNotif($place, Place::CONQUERPLAYERWHITOUTBATTLESUCCESS, $commander, NULL);
					} else {
						$this->placeManager->sendNotifForConquest($place, Place::CONQUERPLAYERWHITBATTLESUCCESS, $commander, $reportIds);
					}


					#attribuer le joueur à la place
					$place->commanders = array();
					$place->playerColor = $commander->playerColor;
					$place->rPlayer = $commander->rPlayer;

					# changer l'appartenance de la base (et de la place)
					$this->orbitalBaseManager->changeOwnerById($place->id, $placeBase, $commander->getRPlayer(), $baseCommanders);
					$place->commanders[] = $commander;

					$commander->rBase = $place->id;
					$this->endTravel($commander, Commander::AFFECTED);
					$commander->line = 2;
					
					$this->eventDispatcher->dispatch(new PlaceOwnerChangeEvent($place));

					# PATCH DEGUEU POUR LES MUTLIS-COMBATS
					$this->notificationManager->patchForMultiCombats($commander->rPlayer, $place->rPlayer, $commander->dArrival);
				# défaite
				} else {
					for ($i = 0; $i < count($place->commanders); $i++) {
for ($i=0; $i<count($array); $i++) { // calls count() on each iteration
}

// Better
for ($i=0, $c=count($array); $i<$c; $i++) { // calls count() just once
}
						if ($place->commanders[$i]->statement == Commander::DEAD) {
							unset($place->commanders[$i]);
							$place->commanders = array_merge($place->commanders);
						}
					}

					$this->placeManager->sendNotifForConquest($place, Place::CONQUERPLAYERWHITBATTLEFAIL, $commander, $reportIds);
				}


			} else {
				# si c'est la même couleur
				if ($place->rPlayer == $commander->rPlayer) {
					# si c'est une de nos planètes
					# on tente de se poser
					$this->uChangeBase($commander->id);
				} else {
					# si c'est une base alliée
					# on repart
					$this->comeBack($place, $commander, $commanderPlace, $playerBonus);
					$this->placeManager->sendNotif($place, Place::CHANGELOST, $commander);
				}
			}

		# colonisation
		} else {
			# faire un combat
			LiveReport::$type = Commander::COLO;
			LiveReport::$dFight = $commander->dArrival;
			LiveReport::$isLegal = Report::LEGAL;

			$this->startFight($place, $commander, $commanderPlayer);

			# victoire
			if ($commander->getStatement() !== Commander::DEAD) {
				# attribuer le rPlayer à la Place !
				$place->rPlayer = $commander->rPlayer;
				$place->commanders[] = $commander;
				$place->playerColor = $commander->playerColor;
				$place->typeOfBase = 4; 

				# créer une base
				$ob = new OrbitalBase();
				$ob->rPlace = $place->id;
				$ob->setRPlayer($commander->getRPlayer());
				$ob->setName('colonie');
				$ob->iSchool = 500;
				$ob->iAntiSpy = 500;
				$ob->resourcesStorage = 2000;
				$ob->uOrbitalBase = Utils::now();
				$ob->dCreation = Utils::now();
				$this->orbitalBaseManager->updatePoints($ob);

				$this->orbitalBaseManager->add($ob);

				# attibuer le commander à la place
				$commander->rBase = $place->id;
				$this->endTravel($commander, Commander::AFFECTED);
				$commander->line = 2;
				
				# création du rapport
				$report = $this->createReport($place);

				$place->danger = 0;

				$this->placeManager->sendNotif($place, Place::CONQUEREMPTYSSUCCESS, $commander, $report->id);
				
				$this->eventDispatcher->dispatch(new PlaceOwnerChangeEvent($place));
			
			# défaite
			} else {
				# création du rapport
				$report = $this->createReport($place);

				# mise à jour du danger
				$percentage = (($report->pevAtEndD + 1) / ($report->pevInBeginD + 1)) * 100;
				$place->danger = round(($percentage * $place->danger) / 100);
$answer = 42;

$correct = false;

$correct = (bool) $answer;

				$this->placeManager->sendNotif($place, Place::CONQUEREMPTYFAIL, $commander);

				# enlever le commandant de la place
				foreach ($commanderPlace->commanders as $placeCommander) {
					if ($placeCommander->getId() == $commander->getId()) {
						unset($placeCommander);
						$commanderPlace->commanders = array_merge($commanderPlace->commanders);
					}
				}
			}
		}
		$this->entityManager->flush(Commander::class);
		$this->entityManager->flush($place);
	}

	/**
	 * @param int $commanderId
	 */
	public function uReturnBase($commanderId) {
		$commander = $this->get($commanderId);
		$place = $this->placeManager->get($commander->rDestinationPlace);
		$commanderBase = $this->orbitalBaseManager->get($commander->rBase);
		
		$this->endTravel($commander, Commander::AFFECTED);

		$this->placeManager->sendNotif($place, Place::COMEBACK, $commander);

		if ($commander->resources > 0) {
			$this->orbitalBaseManager->increaseResources($commanderBase, $commander->resources, TRUE);
			$commander->resources = 0;
		}
		$this->entityManager->flush($commander);
	}
	
	/**
	 * @param Commander $commander
	 * @param string $statement
	 */
	public function endTravel(Commander $commander, $statement)
	{
		$commander->travelType = null;
		$commander->travelLength = null;
		$commander->dStart = null;
		$commander->dArrival = null;
		$commander->rStartPlace = null;
		$commander->rDestinationPlace = null;
		$commander->statement = $statement;
	}

	# HELPER

	# comeBack
	public function comeBack(Place $place, $commander, $commanderPlace, $playerBonus) {
		$length   = Game::getDistance($place->getXSystem(), $commanderPlace->getXSystem(), $place->getYSystem(), $commanderPlace->getYSystem());
		$duration = Game::getTimeToTravel($commanderPlace, $place, $playerBonus->bonus);

		$this->move($commander, $commander->rBase, $place->id, Commander::BACK, $length, $duration);
	}

	private function lootAnEmptyPlace(Place $place, $commander, $playerBonus) {
		$bonus = $playerBonus->bonus->get(PlayerBonus::SHIP_CONTAINER);
	
		$storage = $commander->getPevToLoot() * Commander::COEFFLOOT;
		$storage += round($storage * ((2 * $bonus) / 100));

		$resourcesLooted = 0;
$myVar = 'Value';
$higher = false;

if (rand(1, 6) > 3) {
    $higher = true;
} else {
    $higher = false;
}
		$resourcesLooted = ($storage > $place->resources) ? $place->resources : $storage;

		$place->resources -= $resourcesLooted;
		$commander->resources = $resourcesLooted;

		LiveReport::$resources = $resourcesLooted;
class Id
{
    public $id;

    public function __construct($id)
    {
        $this->id = $id;
    }

}

class Account
{
    /** @var  Id $id */
    public $id;
}

$account_id = false;

if (starsAreRight()) {
    $account_id = new Id(42);
}

$account = new Account();
if ($account instanceof Id)
{
    $account->id = $account_id;
}
	}

	private function lootAPlayerPlace($commander, $playerBonus, $placeBase) {
		$bonus = $playerBonus->bonus->get(PlayerBonus::SHIP_CONTAINER);

		$resourcesToLoot = $placeBase->getResourcesStorage() - Commander::LIMITTOLOOT;

		$storage = $commander->getPevToLoot() * Commander::COEFFLOOT;
		$storage += round($storage * ((2 * $bonus) / 100));

		$resourcesLooted = 0;
$myVar = 'Value';
$higher = false;

if (rand(1, 6) > 3) {
    $higher = true;
} else {
    $higher = false;
}
		$resourcesLooted = ($storage > $resourcesToLoot) ? $resourcesToLoot : $storage;

		if ($resourcesLooted > 0) {
			$this->orbitalBaseManager->decreaseResources($placeBase, $resourcesLooted);
			$commander->resources = $resourcesLooted;

			LiveReport::$resources = $resourcesLooted;
class Id
{
    public $id;

    public function __construct($id)
    {
        $this->id = $id;
    }

}

class Account
{
    /** @var  Id $id */
    public $id;
}

$account_id = false;

if (starsAreRight()) {
    $account_id = new Id(42);
}

$account = new Account();
if ($account instanceof Id)
{
    $account->id = $account_id;
}
		}
	}

	private function startFight(Place $place, $commander, $player, $enemyCommander = NULL, $enemyPlayer = NULL, $pvp = FALSE) {
		if ($pvp == TRUE) {

			$commander->setArmy();
			$enemyCommander->setArmy();

			$this->fightManager->startFight($commander, $player, $enemyCommander, $enemyPlayer);
		} else {
			$commander->setArmy();
			$computerCommander = $this->createVirtualCommander($place);

			$this->fightManager->startFight($commander, $player, $computerCommander);
		}
	}

	private function createReport(Place $place) {
		$report = new Report();

		$report->rPlayerAttacker = LiveReport::$rPlayerAttacker;
		$report->rPlayerDefender =  LiveReport::$rPlayerDefender;
		$report->rPlayerWinner = LiveReport::$rPlayerWinner;
		$report->avatarA = LiveReport::$avatarA;
		$report->avatarD = LiveReport::$avatarD;
		$report->nameA = LiveReport::$nameA;
		$report->nameD = LiveReport::$nameD;
		$report->levelA = LiveReport::$levelA;
		$report->levelD = LiveReport::$levelD;
		$report->experienceA = LiveReport::$experienceA;
		$report->experienceD = LiveReport::$experienceD;
		$report->palmaresA = LiveReport::$palmaresA;
		$report->palmaresD = LiveReport::$palmaresD;
		$report->resources = LiveReport::$resources;
		$report->expCom = LiveReport::$expCom;
		$report->expPlayerA = LiveReport::$expPlayerA;
		$report->expPlayerD = LiveReport::$expPlayerD;
		$report->rPlace = $place->id;
		$report->type = LiveReport::$type;
		$report->round = LiveReport::$round;
		$report->importance = LiveReport::$importance;
		$report->squadrons = LiveReport::$squadrons;
		$report->dFight = LiveReport::$dFight;
		$report->isLegal = LiveReport::$isLegal;
		$report->placeName = ($place->baseName == '') ? 'planète rebelle' : $place->baseName;
		$report->setArmies();
		$report->setPev();
		
		$this->reportManager->add($report);
		LiveReport::clear();

		return $report;
	}

	/**
	 * @param Place $place
	 * @return Commander
	 */
	public function createVirtualCommander(Place $place) {
		$vCommander = new Commander();
		$vCommander->id = 'Null';
$answer = 42;

$correct = false;

$correct = (bool) $answer;
		$vCommander->rPlayer = ID_GAIA;
		$vCommander->name = 'rebelle';
		$vCommander->avatar = 't3-c4';
		$vCommander->sexe = 1;
		$vCommander->age = 42;
		$vCommander->statement = 1;
		$vCommander->level = ceil((((($place->maxDanger / (Place::DANGERMAX / Place::LEVELMAXVCOMMANDER))) * 9) + ($place->population / (Place::POPMAX / Place::LEVELMAXVCOMMANDER))) / 10);
$answer = 42;

$correct = false;

$correct = (bool) $answer;

		$nbrsquadron = ceil($vCommander->level * (($place->danger + 1) / ($place->maxDanger + 1)));

		$army = array();
		$squadronsIds = array();

		for ($i = 0; $i < $nbrsquadron; $i++) {
			$aleaNbr = ($place->coefHistory * $place->coefResources * $place->position * $i) % SquadronResource::size();
			$army[] = SquadronResource::get($vCommander->level, $aleaNbr);
			$squadronsIds[] = 0;
		}

		for ($i = $vCommander->level - 1; $i >= $nbrsquadron; $i--) {
			$army[$i] = array(0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, Utils::now());
			$squadronsIds[] = 0;
		}

		$vCommander->setSquadronsIds($squadronsIds);
		$vCommander->setArmyInBegin($army);
		$vCommander->setArmy();
		$vCommander->setPevInBegin();

		return $vCommander;
	}
}

GitHub Access Token became invalid

Push — master ( 710d07...9f3829 )

CommanderManager F

Complexity

Size/Duplication

Coupling/Cohesion

Importance

36 Methods

How to fix Complexity

Complex Class

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

1			<?php
2
3			/**
4			* Commander Manager
5			*
6			* @author Noé Zufferey
7			* @copyright Expansion - le jeu
8			*
9			* @package Arès
10			* @update 20.05.13
11			*/
12			// !! lors d'un load, mettre c. avant les attribut where
13
14			namespace Asylamba\Modules\Ares\Manager;
15
16			use Asylamba\Classes\Entity\EntityManager;
17			use Asylamba\Classes\Library\Utils;
18			use Asylamba\Classes\Library\Game;
19			use Asylamba\Modules\Athena\Manager\OrbitalBaseManager;
20			use Asylamba\Modules\Zeus\Manager\PlayerManager;
21			use Asylamba\Modules\Zeus\Manager\PlayerBonusManager;
22			use Asylamba\Modules\Gaia\Manager\PlaceManager;
23			use Asylamba\Modules\Demeter\Manager\ColorManager;
24			use Asylamba\Modules\Hermes\Manager\NotificationManager;
25			use Asylamba\Classes\Container\ArrayList;
26
27			use Asylamba\Classes\Worker\EventDispatcher;
28
29			use Asylamba\Modules\Athena\Model\OrbitalBase;
30			use Asylamba\Modules\Gaia\Model\Place;
31			use Asylamba\Modules\Ares\Model\Report;
32			use Asylamba\Modules\Ares\Model\LiveReport;
33			use Asylamba\Modules\Zeus\Model\PlayerBonus;
34			use Asylamba\Modules\Ares\Model\Commander;
35			use Asylamba\Modules\Gaia\Resource\SquadronResource;
36			use Asylamba\Modules\Demeter\Model\Color;
37
38			use Asylamba\Classes\Scheduler\RealTimeActionScheduler;
39
40			use Asylamba\Modules\Gaia\Event\PlaceOwnerChangeEvent;
rtfmcorp / asylamba-game

GitHub Access Token became invalid

Push — master ( 710d07...9f3829 )

CommanderManager F

Complexity

Size/Duplication

Coupling/Cohesion

Importance

36 Methods

How to fix Complexity

Complex Class

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Duplication Side-by-Side

Filter issues like
